this.code();

🧐 백준 2609 (최대공약수, 최소공배수)

🤫 해결의 실마리 

🤔 최대공약수, 최소공배수는 math 내장 라이브러리에 있는 gcd, lcm 함수를 이용하자!  

from math import gcd, lcm

🤫  solution_2609

from math import gcd, lcm
x, y = map(int, input().split())
print(gcd(x,y), lcm(x,y), sep = "\n")

🧐 백준 1676 (factorial)

🤫 해결의 실마리 

🤔 팩토리얼은 math 내장 라이브러리에 있는 factorial 함수를 이용하자!

from math import factorial

🤔 문자열이나 리스트에 대한 뒤에서의 접근은 reversed를 애용하자!

for i in reversed(ans):

🤫  solution_1676

from math import factorial
ans = str(factorial(int(input())))
cnt = 0
for i in reversed(ans):
    if i == '0':
        cnt += 1
    else:
        break
print(cnt)

🧐 백준 2004 (combination_조합)

🤫 해결의 실마리 

🤔 조합론의 원리, 즉 본질의 파악이 우선이다!

0의 개수 = 
min{
(M!이 가지는 2의 개수 - N!이 가지는 2의 개수 - (M-N)!이 갖는 2의 개수) 
                             /
(M!이 가지는 5의 개수 - N!이 가지는 5의 개수 - (M-N)!이 갖는 5의 개수)
}

🤫  solution_2004 (시간초과)

from math import factorial

def combination(n, m):
    return factorial(n) // (factorial(m) * factorial(n-m))

n, m = map(int, input().split())
num = str(combination(n,m))

cnt = 0
for i in reversed(num):
    if i == '0':
        cnt += 1
    else:
        break
print(cnt)

🤫  solution_2004

M, N = map(int, input().split())
def countNum(N, num):
    cnt = 0
    divNum = num
    while(N >= divNum):
        cnt = cnt + (N // divNum)
        divNum *= num
    return cnt

# 0의 개수 = min(M!이 가지는 2의 개수 - N!이 가지는 2의 개수 - (M-N)!이 갖는 2의 개수  /  M!이 가지는 5의 개수 - N!이 가지는 5의 개수 - (M-N)!이 갖는 5의 개수)
print(min(countNum(M, 5) - countNum(N, 5) - countNum(M-N, 5), countNum(M, 2) - countNum(N, 2) - countNum(M-N, 2)))

🧐 백준 11051 (이항정리)

🤫  solution_2004

from math import factorial
n, k = map(int, input().split())
print((factorial(n) // (factorial(k) * factorial(n - k))) % 10007)

조합의 경우 n! / k! (n-k)! 으로 표현이 가능하기에 위와 같이 표현할 수 있다.

🧐 백준 2981 (combination_조합)  Gold IV

🤫 해결의 실마리 _ 유클리드 호제법

 

🤔 Algorithm
나눗셈에서 몫과 나머지가 어떻게 나오는지, 본질의 파악이 우선이다!
위의 예제입력 2의 일부를 예로 들어 알고리즘 과정을 설명해 보겠다.

# 17 = 5*(3) + '2'
# 83 = 27*(3) + '2'

# 3 = (number - 'rest')*몫
# 즉, 숫자 2개를 빼주면? => ()괄호 값을 인수로 갖는 숫자가 나옴
# ex) 83-17 = 66의 공약수 = 2 3 6 11 22 33 66
# ex) 17- 5 = 12의 공약수 = 2 3 4 6 12
# ex) 17-14 = 3의 공약수 = 3
# 즉, 최종적으로 위의 리스트들의 공약수는 3이므로 3을 출력하면 됨.

🤔Algorithm 과정
위에서 설명한 바와 같은 방식으로 진행할 것이다.
1. 입력된 num간의 차이를 저장하는 num_interval 리스트를 생성해주고 저장한다.
2. ans는 num_interval의 최대공약수를 구하여 넣어주기 위한 리스트이다.
3. gcd(*num_interval)을 통해 모든 num_interval의 원소들을 비교, 최대공약수를 구해준다.
4. ans에 저장된 1을 제외한 약수가 답이 되므로 약수를 구하기 위한 divisor함수를 선언해준다.
5. divisor함수에서는 2부터 n까지를 돌면서 나머지가 0이 될 때, i값을 append해준다.
6. 이렇게 모인 answer 리스트가 바로 1을 제외한 약수가 저장되있는 리스트이다.
7. 이 함수에 ans에 저장된 최대공약수의 원소를 넣어주고 함수로 도출된 리스트의 원소를 뽑아준다.

🤫  solution_2981

from math import gcd

N = int(input())
num = [int(input()) for _ in range(N)]

num_interval = []
ans = []
for i in range(1, N):
    num_interval.append(abs(num[i] - num[i-1]))
ans.append(gcd(*num_interval))

def divisor(n):
    answer = []
    for i in range(2, n+1):
        if n%i == 0:
            answer.append(i)
    return answer

print(*divisor(*ans))

🧐 백준 2877 (2진수) Gold V

🤫 해결의 실마리 _  format() 

>>> format(42, 'b') # 2진수
'101010'
>>> format(42, 'o') # 8진수
'52'
>>> format(42, 'x') # 16진수
'2a

🤔 Algorithm 

🤫  solution_ 2877

n = format(int(input()) + 1, 'b') # k+1 숫자를 2진수('b')로 변환
print(n[1:].replace('0', '4').replace('1', '7'))

🧐 백준 1158 (요세푸스 문제)

🤫 해결의 실마리 _  deque 

🤔 collections의 deque를 이용하자!  

from collections import deque
dq = deque()

# dq의 뒤(오른쪽)에 값 추가, 삭제
dq.append(num)
dq.pop()

# dq의 앞(왼쪽)에 값 추가
dq.appendleft(num)
dq.popleft()

# dq안의 값들 회전 (원형 큐를 이용)
dq.rotate(양수)  = 양수 칸씩 오른쪽으로 밀린다.
dq.rotate(음수)  = 음수 칸씩 왼쪽으로 밀린다.

print(dq)  # deque([1, 2, 3, 4, 5])

dq.rotate(1)
print(dq)  # deque([5, 1, 2, 3, 4])

dq.rotate(-1)
print(dq)  # deque([1, 2, 3, 4, 5])

dq.rotate(-1)
print(dq)  # deque([2, 3, 4, 5, 1])

 

🤫  solution_1158

from collections import deque

n, k = map(int, input().split())
dq = deque([i for i in range(1, n+1)])

ans = []
while dq:
    dq.rotate(-k+1)
    ans.append(dq.popleft())  # popleft: 덱의 앞(왼쪽)값 삭제후 반환

print("<" + ", ".join(map(str, ans)) + ">")

🧐 백준 2581 (소수의 원리 이용)

🤫 해결의 실마리 

🤔 소수의 원리 
소수의 원리 => 약수의 개수가 2개 (1과 자기자신)

🤔 Algorithm 과정 
1. num이라는 빈 리스트에 입력된 M ~ N까지의 숫자를 넣는다.
2. 약수의 개수를 세는 cnt라는 변수를 선언, 0으로 초기화한다.
3. 소수를 담을 리스트 dec을 선언한다.
4. num리스트의 원소를 차례로 돌면서 i % j == 0 즉, 약수일 때, cnt값을 증가시킨다.
5. 이렇게 약수의 개수가 담긴 cnt변수에 대해 만약 약수의 개수가 2개라면(cnt == 2) 소수인것!
따라서 소수라면 dec 리스트에 원소를 추가해주고 cnt==0이라면 소수가 없는 것이므로 0을 출력!

🤫  solution_2581

 

M, N = int(input()), int(input())
num = []
for i in range(N-M+1):
    num.append(i+M)

dec = []
for i in num:
    cnt = 0
    for j in range(1, i+1):
        if i % j == 0:
            cnt += 1
    if cnt == 2:
        dec.append(i)
if len(dec) == 0:
    print(-1)
else:
    print(sum(dec))
    print(min(dec))

🧐 백준 1929 (에라토스테네스의 체) _ 앞으로 계속 이 문제에서 파생하여 문항을 해결함

🤫 해결의 실마리 

🤔 에라토스테네스의 체 (Sieve of Eratosthenes)

 

에라토스테네스의 체 원리는 다음과 같다.
1. 소수가 아닌 1을 지운다.
2. 2의 배수를 지운다.
3. 앞서 지운 2의 배수가 아닌 것들 중 최소값인 3의 배수를 지운다.
4. 앞서 지운 2, 3의 배수가 아닌 값들 중 최소값인 5의 배수를 지운다.
5. 이 과정을 반복하여 걸러지는 것들이 비로소 소수가 된다.

이러한 에라토스테네스의 체는 "특정 구간이 주어졌을 때" 매우 빠르게 소수를 도출할 수 있다.
위의 2581번처럼 풀면 시간복잡도는 O(n)으로 비교적 시간이 오래 걸린다.
하지만 에라토스테네스의 체의 시간복잡도는 O(nlog(log n))으로 매우 빠르게 도출이 가능하다.
또한 약수의 경우, 2*4, 4*2 처럼 반복이 되기 때문에
가장 중요한 것은 범위의 마지막 수의 루트 값까지만 반복함으로 시간을 더욱 줄일 수 있다!


🤔 Algorithm 과정 
알고리즘과정은 위에서 설명하는 에라토스테네스의 방식을 차용하였다.
또한 코드에 대한 설명은 아래 그림으로 대체하겠다.

🤫  solution_1929

m, n = map(int, input().split())
num = [i for i in range(max(2, m), n+1)]  # m ~ n사이 숫자를 넣은 리스트 (단, 1은 제외)
dec_sqr_n = []   # n의 제곱근까지의 범위안에서 소수를 집어 넣을 리스트

for i in range(2, int(n**0.5) + 1):   # 2에서 n의 제곱근까지만 반복
    if i in num:
        dec_sqr_n.append(i)
    num = [j for j in num if j % i != 0]

print(*(dec_sqr_n + num), sep = "\n")

 

 

🧐 백준 4948 (에라토스테네스의 체)

🤫 해결의 실마리 

🤔 에라토스테네스의 체 (Sieve of Eratosthenes)

🤔 Algorithm 과정 
위 1929와 거의 동일한 방식으로 풀었지만 방법은 다음과 같다.
1. n의 범위 사이의 자연수를 저장하는 num 리스트를 생성한다. (1 ≤ n ≤ 123456)
2. 리스트 num을 1929번 풀이처럼 소수만 존재하도록 만들어준다.
3. 1929와 같은 방식으로 n의 범위사이에 존재하는 모든 소수가 담긴 decimal이라는 리스트를 생성해준다.
4. 0이 들어오기 전까지 while문을 이용해 입력을 받아주고
5. decimal 리스트에서 입력의 범위에 해당하는 값들의 개수를 세어 출력해준다.

 

🤫  solution_4948 (시간초과)

def decimal(N):
    n = N+1
    num = [i for i in range(n, 2*N + 1)]
    dec_half = []
    for i in range(2, int((2*N)**0.5) + 1):
        if i in num:
            dec_half.append(i)
        num = [j for j in num if j % i != 0]
    return len(dec_half+num)

num = -1
while True:
    num = int(input())
    if num == 0:
        break
    else:
        print(decimal(num))

 

처음 짠 코드로 1929와 비슷하게 함수를 생성하여 풀었으나 시간초과가 발생하였다.
시간복잡도를 염두하지 않고 머리를 장식으로 두고 문제에 접근한 결과라 생각할 수 밖에 없다.
함수에서 2중 for문을 사용한 것을 while문에서 계속 받으니 그럴 수 밖에...

🤫  solution_4948

from math import sqrt

# 1 <= n <= 123456 사이 자연수를 담은 리스트 생성
num = [i for i in range(2, 123456 * 2)]

# 리스트 num을 이전처럼 소수만 있게 만들어주기.
dec_half = []
for i in range(2, int(sqrt(123456*2)) + 1):
    if i in num:
        dec_half.append(i)
    num = [j for j in num if j%i != 0]

decimal = dec_half + num

n = -1
while True:
    n = int(input())
    if n == 0:
        break
    # decimal 리스트에서 입력의 범위에 해당하는 값들의 개수를 세어 출력
    print(len([i for i in decimal if n < i <= 2*n]))

🧐 백준 9020 (에라토스테네스의 체)

🤫 해결의 실마리 

🤔 에라토스테네스의 체 (Sieve of Eratosthenes)

🤔 Algorithm 과정 
두 소수의 차이가 가장 작은 것의 의미를 생각해보면 다음과 같다.
소수간의 차이가 작을수록 최대값의 절반과 가까워진다! 
16으 예로 들자면 다음과 같다.
[3, 13], [5, 11]  =>  3  5  (8)  11  13

따라서 핵심은 시간초과가 걸리지 않으려면 소수의 절반만 훑어야 한다.

 

🤫  solution_9020 (시간초과)

T = int(input())
n = [int(input()) for _ in range(T)]

num = [i for i in range(2, 10001)]
dec_half = []
for i in range(2, 100 + 1):
    if i in num:
        dec_half.append(i)
    num = [j for j in num if j % i != 0]
decimal = dec_half + num

for i in n:
    dec = []
    for j in range(len(decimal)):
        for k in range(j, len(decimal)):
            if i == decimal[j] + decimal[k]:
                dec.append([decimal[j], decimal[k]])
    print(*dec[-1])

처음 짠 코드로 문제점은 소수의 전체를 계속 훑으면서 비교를 진행하기 때문에 위의 알고리즘보다 2배 이상의 시간이 걸릴 가능성이 높다.
먼저 위의 코드를 짠 과정은 다음과 같다.
1. 먼저 범위에 해당하는 모든 소수를 담는 리스트를 생성하고 
2. 그 리스트 안에서 두 소수간의 덧셈이 입력값과 동일한 것을 찾아서 dec이라는 리스트에 넣는다.
3. dec에는 [[3, 5]], [[3, 7], [5, 5]], [[3, 13], [5, 11]] 처럼 들어간 것이므로 
4. 각 리스트의 마지막 인덱스에 해당하는 리스트가 차이가 가장 작은 소수 리스트인것.
이를 for문을 이용해 출력하였다.

🤫  solution_9020

num = [i for i in range(2, 10000 + 1)]
dec_half = []
for i in range(2, 100 + 1):
    if i in num:
        dec_half.append(i)
    num = [j for j in num if j%i != 0]
decimal = dec_half + num

T = int(input())
for i in range(T):
    n = int(input())
    n_half = n // 2
    for j in range(n_half, 1, -1):
        if j in decimal and n - j in decimal:
            print(j, n - j)
            break

🧐 백준 1427, 1676, 2577, 2711  _ 단일 숫자에 대한 리스트를 이용한 접근

🤫 해결의 실마리 

🤔 단일숫자나 문자열에 대한 접근이나 리스트로 어떻게 바꿀까?

🙃 단일 숫자의 경우는 다음과 같다.
1. 단일 숫자를 문자열로 바꾼다.
2. 문자열을 리스트에 넣는다.

str_num = str(n)
str_list = list(str_num)​

🙃 문제에 맞는 연산 진행 후 다시 숫자로 출력하고 싶다면?
3. 리스트값들을 출력

print(*sorted(num, reverse = True) , sep = '')
# sep=''를 통해 원소간의 구분자인 공백을 없애줌으로
# 9 9 9 9 9 9 9 9 8 을
# 999999998 로 출력​

🧐 사용법에 대한 정리.

num = int(input())
str_x = list(str(num))          # ['1', '2', '3', '4', '5', '6']
int_x = list(map(int, str_x))   # [1, 2, 3, 4, 5, 6]

print(*int_x)           # 1 2 3 4 5 6
print(*int_x, sep="")   # 123456

 

🤔  원하는 원소를 어떻게 지울까?  pop, del, remove 함수! 

# cf-1  pop
a = [1,2,1,3,4,5,1]
removed = a.pop(1)  # 1번째 index 삭제 단, return 가능

print(a)            # [1, 1, 3, 4, 5, 1]
print(removed)      # 2   <-- pop한 원소를 return 가능

# cf-2  del  -> pop과 다르게 리스트의 범위를 지정해 삭제 가능
a = [1,2,1,3,4,5,1]

del a[:2]
print(a)        # [1, 3, 4, 5, 1]

#cf-3   remove  -> 위와 달리 지우고자 하는 인덱스가 아닌 값을 입력
for _ in numbers :
    numbers.remove(3)

🤫  solution_1427

# 입력: 999998999

num = list(map(int, input()))  # 공백없이 입력받을 때, list에 저장하는 법
print(*sorted(num, reverse = True) , sep = '')
# sep=''를 통해 원소간의 구분자인 공백을 없애줌으로
# 9 9 9 9 9 9 9 9 8 을
# 999999998 로 출력

# cf. end옵션을 사용하면 그 뒤에 나오는 출력값과 구분을 짓는 구분자 역할을 한다.
print(*sorted(num, reverse = True) , end = " hello ")
print(num)
# 9 9 9 9 9 9 9 9 8 hello [9, 9, 9, 9, 9, 8, 9, 9, 9] 가 출력

🤫  solution_1676

def fac(n):
    if n <= 1:
        return 1
    else:
        return n * fac(n - 1)

N = int(input())
n = fac(N)

# 숫자를 리스트에 한자리씩 넣기 (숫자->문자열)
str_num = str(n)
str_list = list(str_num)

cnt = 0
for i in reversed(str_list):
    if i == '0':
        cnt += 1
    else:
        break
print(cnt)

 

🤫  solution_2577

num = []
for i in range(3):
    n = int(input())
    num.append(n)

mul = 1
for i in range(3):
    mul *= num[i]

str_x = list(str(mul))
int_x = list(map(int, str_x))

out_ls = []
for i in range(10):
    out_ls.append(int_x.count(i))

for i in range(10):
    print(out_ls[i])

 

🧐 백준 1292 , 4458 풀이 및 사용함수

🤫 해결의 실마리 

🤔 리스트 사용의 핵심! 인덱스 슬라이싱 
인덱스 슬라이싱에 대한 응용방법을 아래 해설을 통해 볼 수 있는데, [:]를 이용한다.

🤫  solution_1292

A, B = map(int, input().split())
num_sequences = []

for i in range(1000):
    for j in range(i):
        num_sequences.append(i
print(sum(num_sequences[A-1:B]))

🤫  solution_4458

for i in [input() for _ in range(int(input()))]:
    print(i[:1].upper() + i[1:])

🧐 백준 1157  풀이 및 사용 함수

🤫 해결의 실마리 

🤔 원소가 겹치지 않아? set 자료구조 
주로 사용하는 리스트로 set을 변환하는 방법은 다음과 같다.

a_set = set(a)
lst = []
for i in a_set:
    lst.append(a.count(i))

🤫  solution_1546

a = list(str(input()).upper())
a_set = set(a)
cnt = []
for i in a_set:
    cnt.append(a.count(i))
if cnt.count(max(cnt)) <= 1:
    print(max(a, key = a.count))
else:
    print("?")

🧐 백준 1292 , 4458 풀이 및 사용함수

🤫 해결의 실마리 

🤔 리스트 사용의 핵심! 인덱스 슬라이싱 
인덱스 슬라이싱에 대한 응용방법을 아래 해설을 통해 볼 수 있는데, [:]를 이용한다.

🤫  solution_1292

A, B = map(int, input().split())
num_sequences = []

for i in range(1000):
    for j in range(i):
        num_sequences.append(i
print(sum(num_sequences[A-1:B]))

🤫  solution_4458

for i in [input() for _ in range(int(input()))]:
    print(i[:1].upper() + i[1:])

🧐 백준 2309,  2822 풀이 및 사용함수

🤫 해결의 실마리 

🤔 정렬을 스스로 해주는 내장함수, sorted를 이용하자! 

정렬 함수는 다음 2가지를 사용할 수 있다.

a.sort()
sorted(a)

둘의 차이는 바로 반환의 여부이다.
a.sort의 경우, 반환을 해주지 않기에 print문에 넣어주면 오류가 발생하게 된다.
하지만 sorted의 경우, 값의 반환이 이루어질 수 있어서 print문에서도 오류가 발생하지 않는다.

🤔 cf. 출력 조건에 따라 다음과 같이 작성하자!

sorted(idx_list)  => [3, 4, 5, 6, 8]
*sorted(idx_list) =>   3 4 5 6 8

🤫  solution_2309

dwarf = [int(input()) for _ in range(9)]

for i in range(len(dwarf)):
    for j in range(i+1, len(dwarf)):
        if (sum(dwarf) - (dwarf[i] + dwarf[j])) == 100:
            dwarf1, dwarf2 = dwarf[j], dwarf[i]  # out of index range 조심
            dwarf.remove(dwarf1)
            dwarf.remove(dwarf2)
            break
        else:
            continue

print(*sorted(dwarf), sep = "\n")

 

🤫  solution_2822

score = [int(input()) for _ in range(8)]
total = list(sorted(score, reverse=True))
print(sum(total[:5]))

idx_list = []
for i in range(5):
    idx_list.append(score.index(max(score)) + 1)
    score[score.index(max(score))] = -100
print(*sorted(idx_list))
# sorted(idx_list)  => [3, 4, 5, 6, 8]
# *sorted(idx_list) =>   3 4 5 6 8

🧐 백준 11047 풀이

🤫  solution_11047  (Greedy Algorithm)

N, K = map(int, input().split())

coin = sorted([int(input()) for _ in range(N)], reverse=True)

cnt = 0
while K != 0:
    for i in range(N):
        if coin[i] > K:
            i -= 1
        else:
            frequency = K // coin[i]
            K -= coin[i] * frequency
            cnt += frequency
print(cnt)

🧐 입력받기

🤔 단일 입력 ( a = input() 처럼 사용할 때는 default가 str로 아래와 같이 type을 표시할 수 있다.)

a = int(input())

🤔 123456과 같이 공백없이 입력을 list로 받을 때 (a를 list가 아닌 float변수로 받고자 하면 map으로 시작)

num = list(map(int, input())) 

🤔 1 2 3 4와 같이 띄어쓰기를 기준으로 입력을 list로 받을 때 (a를 list가 아닌 float변수로 받고자 하면 map으로 시작)

- 공백을 기준으로 입력받은 애들을 잘라서 int로 만든 뒤 (map이 반복되는 애들을 특정 자료형으로 바꿔준다.)

- 이를 list로 감싸줘서 int형의 반복적인 것들이 리스트화 되는 것이다.

a = list(map(float, input().split()))

a = [int(input()) for i in range(10)]

TestCase = int(input())
num = [list(map(int, input().split())) for _ in range(TestCase)]

# 위의 코드는 앞으로 다음과 같이 사용
num = [list(map(int, input().split())) for _ in range(int(input()))]

이를 다른 언어로 생각해보면
num [ TestCase ][ list(map(int, input().split())) ]
위와 같은 느낌이라 생각하면 된다.

🧐 백준 1546에서 사용한 함수

🤫 해결의 실마리 

🤔 최대값, 최소값을 반환하는 함수 max, min 

1. 인자 1개일 때       =>    max(list_name)
2. 인자 2개일 때       =>    max(arg1, arg2)    # arg에서 가장 큰 값을 출력, list라면 list 자체를 출력
3. key나 lambda를 이용 =>   max(num, key = num.count)  # 최빈값을 구하는 식

그렇다면 2번째로 큰 값이나 작은 값은 어떤 방식으로 구하면 될까? 
1. 정렬을 해준다. => sort 사용
2. sort 후 1번 인덱스 값을 출력해주면 된다.

num = [int(input()) for _ in range(9)]
num.sort(reverse=True)
print(num[1])

🤔 뒤집어 주는 함수 reverse

for i in reversed(str_list):
    if i == '0':
        cnt += 1
    else:
        break

위의 코드처럼 reversed를 for문에 넣어 기존 원소를 반대방향에서 접근할 수 있다.


🤔 리스트에 새로운 요소를 추가하는 함수 append, insert

list_name.append(x)는 list의 맨 끝에 객체 x를 추가한다.
list_name.insert(idx, x)는 list의 idx에 객체 x를 추가한다.

🤔 특정 값의 길이를 구하는 함수 len

len(list_name) 는 list_name의 길이를,
len(string) 은 string의 길이를 구할 수 있다

 

🤫  solution_1546

N = int(input())
score = list(map(float, input().split()))
M = max(score)
new_score = []
for i in range(N):
    new_score.append(score[i]/M*100)

new_mean = sum(new_score) / len(new_score)
print(new_mean)

🤫  solution_1676

def fac(n):
    if n <= 1:
        return 1
    else:
        return n * fac(n - 1)

N = int(input())
n = fac(N)

# 숫자를 리스트에 한자리씩 넣기 (숫자->문자열)
str_num = str(n)
str_list = list(str_num)

cnt = 0
for i in reversed(str_list):
    if i == '0':
        cnt += 1
    else:
        break
print(cnt)

 

🧐 백준 2562 , 10797사용함수

🤫 해결의 실마리 

🤔 리스트에서 조건에 맞는 인덱스를 찾는 함수   ls.index(조건)

ls = []
ls.index(max(ls))

🤔 리스트에서 조건에 맞는 개수를 찾는 함수  ls.count(조건)

num.count(day)

🤔 리스트에 특정 값이 존재하는지 확인하는 법   if a in ls

if item in list:
    print('리스트에 값이 있습니다.')
else:
    print('리스트에 값이 없습니다.')

🤔 리스트에 특정 값이 없는지 확인하는 법   if a not in ls

if item not in list:
    print('리스트에 값이 없습니다.')
else:
    print('리스트에 값이 있습니다.')

🤫  solution_2562

num = [int(input()) for _ in range(9)]
print(max(num), num.index(max(num))+1, sep = " \n")

 

🤫  solution_10797

day = int(input())
num = list(map(int, input().split()))

if day in num:
    print(num.count(day))
else:
    print(0)

🧐 백준 2506 풀이 및 사용함수

🤫 해결의 실마리 

🤔 리스트에 저장된 value 기준의 for문을 이용하자! 

for i in lst:
    if (i == 1):
        . . .​

for i in range(len(list_name))은 list의 길이만큼 for문을 순회하는 것으로 i의 값이 0, 1, 2, 3, . . . , list길이 만큼 나오지만

for i in lst: 의 경우 만약 lst = [10, 30, 345, 123]이라면 4회 돌긴 하지만 i의 값이 10일때, 30일때로 돌게 된다.
즉, i에 리스트의 값이 되입되면서 list 원소를 이용한 접근할 수 있다.

🤫  solution_2506

num = int(input())
ox = list(map(int, input().split()))

sum, cnt = 0, 0

for i in ox:
    if (i == 1):
        cnt += 1
        sum += cnt
    else:
        cnt = 0
print(sum)

🧐 백준 2576, 9085 풀이 

🤫  solution_2576

num = [int(input()) for _ in range(7)]

sum, ans = 0, 0
odd_list = []

for i in range(7):
    odd = num[i] % 2 != 0
    if odd:
        odd_list.append(num[i])
        sum += num[i]

if len(odd_list) == 0:
    print(-1)
else:
    print(sum, min(odd_list), sep = "\n")

🤫  solution_9085

T = int(input())
sum_T = []
for i in range(T):
    N = int(input())
    sum_T.append(sum(list(map(int, input().split()))))
    print(sum_T[i])

🫠 백준 1065 (https://www.acmicpc.net/problem/1065)

🧐 Algorithm 
1. 먼저 등차수열이어야 하므로 자리수간의 공차가 같아야 하기에 a-b와 b-c의 값이 동일해야함.
2. 이를 위해 함수 hansu를 만들었고 이를 100의자리수에서 사용.
3. 100~999까지 기준일 때 등차수열조건을 만족시켜야 하므로 다음과 같이 함수를 사용한다.

#include <iostream>
#include <algorithm>
using namespace std;

bool hansu (int num){
    int a = num / 100;
    int b = (num - a*100) / 10;
    int c = num % 10;
    return a-b == b-c;
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);

    int cnt = 0;
    int num;    cin >> num;

    if (num <= 99){
        cout << num;
    }
    else if (num >= 100 && num <= 999) {
        for (int i = 100; i <= num; i++) {
            cnt += hansu(i);
        }
        cout <<  cnt + 99;
    }
    else
        cout << 144;
}

🫠 백준 1978(https://www.acmicpc.net/problem/1978)

🧐 Algorithm _ 소수를 찾는 법
1. a % b == 2라는 식은 약수를 구하는 식이며 
2. 이 약수의 개수를 세는 cnt라는 변수를 이용해 x의 약수개수를 구하고
3. 소수의 특징 (약수의 개수가 1과 자기자신)을 이용해 약수 개수가 2인 자연수 값들을 세준다.

#include <iostream>
using namespace std;

int main() {
   ios_base::sync_with_stdio(0);

    int num;    cin >> num;
    int count = 0;
    for (int i = 0; i < num; i++) {
        int cnt = 0;
        int x; cin >> x;
        for (int j = 1; j <= x; j++)
            if (x % j == 0)
                cnt++;
        if (cnt == 2)
            count++;
    }
    cout << count << endl;
    return 0;
}

🫠 백준 2581(https://www.acmicpc.net/problem/2581)

🧐 Algorithm _ 소수를 찾는 법
1. a % b == 2라는 식은 약수를 구하는 식이며 
2. 이 약수의 개수를 세는 cnt라는 변수를 이용해 x의 약수개수를 구하고
3. 소수의 특징 (약수의 개수가 1과 자기자신)을 이용해 약수 개수가 2인 자연수 값들을 세준다.

이를 이용해 값들의 전체 합을 구해주고 가장 최소값은 작은 순서대로 vector에 넣어줬으므로
당연히 vector의 첫번째 원소에 들어있는 값이 최소값이 된다.

#include <iostream>
#include <vector>
using namespace std;


int main() {
   ios_base::sync_with_stdio(0);

    int M, N;   cin >> M >> N;
    int sum = 0;

    vector<int> v;

    for (int i = M; i <= N; i++) {
        int cnt = 0;
        for (int j = 1; j <= i; j++)
            if (i % j == 0)
                cnt++;
        if (cnt == 2){
            v.push_back(i);
            sum += i;
        }
    }

    if (v.size() == 0)
        cout << -1 << endl;

    else {
        cout << sum << endl;
        cout << v[0] << endl;
    }
}

#include <iostream>
#include <algorithm>
using namespace std;

pair<int, string> p[100000];

bool compare (pair<int, string> p1, pair<int, string> p2) {
    return p1.first < p2.first;
}

int main() {
   ios_base::sync_with_stdio(0);
    cin.tie(0);

    int num;
    cin >> num;

    for (int i = 0; i < num; i++) {
        int num; string str;  cin >> num >> str;
        p[i] = { num, str };
    }

    stable_sort(p, p+num, compare);

    for (int i=0; i<num; i++) {
        cout << p[i].first << " " << p[i].second << "\n";
    }
}

※ 유클리드 호제법 (Euclidean Algorithm)

※ 등수 구하기

※ 방향 탐색 (knight의 이동)

 § 4방향 탐색, 8방향 탐색

 § Knight의 방향탐색

https://www.acmicpc.net/problem/7562

https://www.acmicpc.net/problem/16959

https://www.acmicpc.net/problem/16952

※ 이차원 배열을 이용한 부분합

- Euclidean Algorithm(유클리드 호제법)
https://www.acmicpc.net/problemset?sort=ac_desc&algo=26

- 등수 구하기

- 방향 탐색(4방향, 8방향, knight)
https://www.acmicpc.net/problem/7562

- 이차원 배열의 부분합
- 이차원 배열의 부분합(feat. 포함-배제의 원리)
https://www.acmicpc.net/problemset?sort=ac_desc&algo=139

※ 약수, 배수 (최대공약수, 최소공배수)

※ 최소, 최대, 최빈값 찾기

§ 최소, 최대값을 찾기 위한 방법: https://chan4im.tistory.com/48

§ 최빈값 찾는 알고리즘

※ palindrome (회문) 

https://www.acmicpc.net/problem/17609

※ 일정구간 연속값 찾기

※ 소수판별과 에라토스테네스의 체

※ 부분합 (누적합)

- 약수, 배수, 최대공약수, 최소공배수

- 소문자->대문자 , 완전수

- Palindrome, 최대,최소,최빈값
https://www.acmicpc.net/problem/17609

- 소수판별, 에라토스테네스의 체
https://www.acmicpc.net/problem/1929

- 부분합
https://www.acmicpc.net/problemset?sort=ac_desc&algo=139