""" 출처:프로그래머스, https://school.programmers.co.kr/learn/courses/30/lessons/17687 """ # 풀이과정 def solution(n, t, m, p): from collections import deque check = m * t all_num = deque([0]) count = 1 while True: start = count num = deque([]) while True: start, j = divmod(start, n) # i 몫 j 나머지 if start == 0: if j != 0: if j == 10: num.appendleft("A") elif j == 11: num.appendleft("B") elif j == 12: num.appendleft("C") elif j == 13: num.appendleft("D") elif j == 14: num.appendleft("E") elif j == 15: num.appendleft("F") else: num.appendleft(j) break else: if j == 10: num.appendleft("A") elif j == 11: num.appendleft("B") elif j == 12: num.appendleft("C") elif j == 13: num.appendleft("D") elif j == 14: num.appendleft("E") elif j == 15: num.appendleft("F") else: num.appendleft(j) all_num += num if len(all_num) >= check: break count += 1 all_num = "".join(list(map(str, list(all_num)[p - 1::m][0:t]))) return all_num

""" 출처:프로그래머스, https://school.programmers.co.kr/learn/courses/30/lessons/258707 """ # 풀이 과정 # 최대 라운드의 수 # 미래에 카드가 있을 수도 있지만 그걸 위해 당장의 라운드를 넘겨야한다! # 당장의 라운드를 넘기는거!! # 코인을 안쓰고 손 안의 숫자 뭉치부터 써야한다! from collections import deque def solution(coin, cards): n = max(cards) + 1 cards = deque(cards) hand = [] # 첫 카드 뭉치 r = 1 # 라운드 # 손에 든 뭉치 슬라이싱 두 번 사용의 경우 효율 떨어짐! for i in range(len(cards) // 3): k = cards.popleft() hand.append(k) check = [] # game start while cards and coin >= 0 and True: flag = False # 라운드 넘긴여부 for j in range(2): new = cards.popleft() # # 라운드를 넘기는 수 하나가 손 안에 있는 경우 # if (n-new) in hand and coin>0: # hand.append(new) # coin-=1 # # 임시로 넣어두기! # else: check.append(new) # 라운드 통과 여부 for i in range(1, ((n - 1) // 2) + 1): # 1순위 코인 안쓰고 손 안의 수로만! if i in hand and (n - i) in hand: one = hand.index(i) del hand[one] two = hand.index(n - i) del hand[two] flag = True r += 1 break if flag == True: continue # 2순위 코인 한 개 쓰고 손 안의 수 소모 for i in range(1, ((n - 1) // 2) + 1): if i in hand and (n - i) in check and coin > 0: one = hand.index(i) del hand[one] two = check.index(n - i) del check[two] flag = True r += 1 coin -= 1 break elif i in check and (n - i) in hand and coin > 0: one = check.index(i) del check[one] two = hand.index(n - i) del hand[two] flag = True r += 1 coin -= 1 break if flag == True: continue for i in range(1, ((n - 1) // 2) + 1): # 새로 뽑은 수를 다 가져오기 if i in check and (n - i) in check and coin >= 2: one = check.index(i) del check[one] two = check.index(n - i) del check[two] r += 1 coin -= 2 flag = True break if flag == False: break return r

""" 출처:프로그래머스, https://school.programmers.co.kr/learn/courses/30/lessons/12953 """ # 풀이 과정 def solution(arr): result = 2 for a in arr: if result != 1 and result % a == 0: continue else: count = min(a, result) while count > 1: if result % count == 0 and a % count == 0: break else: count -= 1 result = (a * result) // count return result

""" 출처:프로그래머스 https://school.programmers.co.kr/learn/courses/30/lessons/77886 """ # 풀이 과정 """ 조건:0과 1로 이루어진 x를 바탕으로 주어진 s를 순서를 바꿔 최소값을 return 생각방향: 110을 지속적으로 찾아내기 원래 s에 있는 형태의 110이 아니더라도 중간에 변형에 의하여 생긴 110 또한 존재 110 빼서 111 자리 앞에 넣어줘야한다 # 필요한 생각: 지속적으로 반복되는 110대한 처리 생각 > 모두 제거 한 후 110을 배치 모두 제거 방법에 대한 생각 """ from collections import deque def solution(s): result = [] for i in s: i = deque(list(i)) check = [] count = 0 while i: k = i.popleft() if len(check) < 2: check.append(k) else: if check[-2] + check[-1] + k == "110": check.pop() check.pop() count += 1 # 새로 생겨난 110 빼기 while len(check) >= 3: if check[-3] + check[-2] + check[-1] == "110": check.pop() check.pop() check.pop() count += 1 else: break else: check.append(k) new = "".join(check) # 111 위치 n = new.find("111") if n != -1: final = new[:n] + "110" * count + new[n:] result.append(final) else: for j in range(len(new) - 1, -1, -1): if new[j] == "0": final = new[:j + 1] + "110" * count + new[j + 1:] result.append(final) break else: final = "110" * count + new result.append(final) return result # ------------------------------------------ 개선 과정 ---------------------------------------------------------- # 내 풀이(개선 중) """ 조건:0과 1로 이루어진 x를 바탕으로 주어진 s를 순서를 바꿔 최소값을 return 생각방향: 110을 지속적으로 찾아내기 원래 s에 있는 형태의 110이 아니더라도 중간에 변형에 의하여 생긴 110 또한 존재 110 빼서 111 자리 앞에 넣어줘야한다 # 필요한 생각: 지속적으로 반복되는 110대한 처리 생각 > 모두 제거 한 후 110을 배치 모두 제거 방법에 대한 생각 """ # sol3 from collections import deque def solution(s): result = [] # 하나씩 추출 for i in s: # 반복 방지 start = 0 # 형태 변환 i = list(i) while True: before = "".join(i) # 루프 나올지 여부 flag = False for a in range(start, len(i) - 2): if i[a] + i[a + 1] + i[a + 2] == "110": # 110 위치 기억 k = a break # 110이 없을 때 else: result.append("".join(i)) break del i[k] del i[k] del i[k] check = "".join(i) n = check.find("111") ###111 존재 # if check.find("111") != -1: # chek return result """ # sol2 from collections import deque def solution(s): result=[] for i in s: i=deque(list(i)) start=[] while len(start)<len(i) or i: k=i.popleft() start.append(k) if len(start)>=3: if start[len(start)-3]+start[len(start)-2]+start[len(start)-1]=="111": start.pop() start.pop() start.pop() i= deque(list("111")+list(i)) print(i,"i 재배열 전 ") # 110 찾아 재배열 one=[] while i: t=i.popleft() one.append(t) if len(one)<3: continue else: if one[len(one)-3]+one[len(one)-2]+one[len(one)-1]=="110": one.pop() one.pop() one.pop() check=[] start+=one check+=list("110") check+=list(i) i=deque(check) break else: start+=one print(start,i,"재배열 후") return result """ # sol1 """ from collections import deque def change_s(i,j): #111 뒤에 있는 110 찾기 r=len(i) start=i[:] i=deque(list(i)) for k in range(j,r-2): if i[k]+i[k+1]+i[k+2]=="110": del i[k] del i[k] del i[k] break else: return start,True i=list(i) start=i[:j] end=i[j:] return "".join(start)+"110"+"".join(end),False def solution(s): result=[] for i in s: #111 찾기 for j in range(len(i)-2): if i[j]+i[j+1]+i[j+2]=="111": i,flag=change_s(i,j) if flag==True: result.append(i) break else: result.append(i) return result """ # 내 풀이(개선 중) """ 조건:0과 1로 이루어진 x를 바탕으로 주어진 s를 순서를 바꿔 최소값을 return 생각방향: 110을 지속적으로 찾아내기 원래 s에 있는 형태의 110이 아니더라도 중간에 변형에 의하여 생긴 110 또한 존재 110 빼서 111 자리 앞에 넣어줘야한다 # 필요한 생각: 지속적으로 반복되는 110대한 처리 생각 """ # sol3 from collections import deque def solution(s): result = [] # 하나씩 추출 for i in s: # 반복 방지 start = 0 # 형태 변환 i = list(i) while True: i = list(i) # 루프 나올지 여부 flag = False for a in range(start, len(i) - 2): if i[a] + i[a + 1] + i[a + 2] == "110": k = a break # 110이 없을 때 else: result.append("".join(i)) break del i[k] del i[k] del i[k] check = [] # 재배열 for b in range(len(i) - 2): if i[b] + i[b + 1] + i[b + 2] == "111": n = b start = b + 3 break else: if i[-1] == "0": final = i + list("110") result.append("".join(final)) break else: for f in range(len(i) - 1, -1, -1): if i[f] == "0": final = i[:f + 1] + list("110") + i[f + 1:] result.append("".join(final)) break else: final = list("110") + i result.append("".join(final)) break break i = i[:n] + list("110") + i[n:] return result """ # sol2 from collections import deque def solution(s): result=[] for i in s: i=deque(list(i)) start=[] while len(start)<len(i) or i: k=i.popleft() start.append(k) if len(start)>=3: if start[len(start)-3]+start[len(start)-2]+start[len(start)-1]=="111": start.pop() start.pop() start.pop() i= deque(list("111")+list(i)) print(i,"i 재배열 전 ") # 110 찾아 재배열 one=[] while i: t=i.popleft() one.append(t) if len(one)<3: continue else: if one[len(one)-3]+one[len(one)-2]+one[len(one)-1]=="110": one.pop() one.pop() one.pop() check=[] start+=one check+=list("110") check+=list(i) i=deque(check) break else: start+=one print(start,i,"재배열 후") return result """ # sol1 """ from collections import deque def change_s(i,j): #111 뒤에 있는 110 찾기 r=len(i) start=i[:] i=deque(list(i)) for k in range(j,r-2): if i[k]+i[k+1]+i[k+2]=="110": del i[k] del i[k] del i[k] break else: return start,True i=list(i) start=i[:j] end=i[j:] return "".join(start)+"110"+"".join(end),False def solution(s): result=[] for i in s: #111 찾기 for j in range(len(i)-2): if i[j]+i[j+1]+i[j+2]=="111": i,flag=change_s(i,j) if flag==True: result.append(i) break else: result.append(i) return result """ # 내 풀이(개선 중) """ 조건:0과 1로 이루어진 x를 바탕으로 주어진 s를 순서를 바꿔 최소값을 return 생각방향: 110을 지속적으로 찾아내기 원래 s에 있는 형태의 110이 아니더라도 중간에 변형에 의하여 생긴 110 또한 존재 110 빼서 111 자리 앞에 넣어줘야한다 """ # sol2 from collections import deque def solution(s): result = [] for i in s: i = deque(list(i)) start = [] while len(start) < len(i) or i: k = i.popleft() start.append(k) if len(start) >= 3: if start[len(start) - 3] + start[len(start) - 2] + start[len(start) - 1] == "111": start.pop() start.pop() start.pop() i = deque(list("111") + list(i)) print(i, "i 재배열 전 ") # 110 찾아 재배열 one = [] while i: t = i.popleft() one.append(t) if len(one) < 3: continue else: if one[len(one) - 3] + one[len(one) - 2] + one[len(one) - 1] == "110": one.pop() one.pop() one.pop() check = [] start += one check += list("110") check += list(i) i = deque(check) break else: start += one print(start, i, "재배열 후") return result # sol1 """ from collections import deque def change_s(i,j): #111 뒤에 있는 110 찾기 r=len(i) start=i[:] i=deque(list(i)) for k in range(j,r-2): if i[k]+i[k+1]+i[k+2]=="110": del i[k] del i[k] del i[k] break else: return start,True i=list(i) start=i[:j] end=i[j:] return "".join(start)+"110"+"".join(end),False def solution(s): result=[] for i in s: #111 찾기 for j in range(len(i)-2): if i[j]+i[j+1]+i[j+2]=="111": i,flag=change_s(i,j) if flag==True: result.append(i) break else: result.append(i) return result """ # 내 풀이(개선 중) """ 조건:0과 1로 이루어진 x를 바탕으로 주어진 s를 순서를 바꿔 최소값을 return 생각방향: 110을 지속적으로 찾아내기 원래 s에 있는 형태의 110이 아니더라도 중간에 변형에 의하여 생긴 110 또한 존재 """ from collections import deque def solution(s): result = [] check = [] for i in s: i = i.replace("110", "x") print(i) num = i.count("x") print(num) return result

""" 출처:프로그래머스, https://school.programmers.co.kr/learn/courses/30/lessons/12952 """ # 풀이 과정 def check(chess, n, queen): count = 0 if n == queen: return 1 for i in range(n): chess[queen] = i for j in range(queen): if chess[j] == chess[queen]: break if abs(chess[j] - chess[queen]) == (queen - j): break else: count += check(chess, n, queen + 1) return count def solution(n): chess = [0] * n return check(chess, n, 0)

""" 출처:프러그래머스, https://school.programmers.co.kr/learn/courses/30/lessons/131703 """ # 풀이과정(정답 풀이) # 조건: 동전을 뒤집기 위해서는 해당 줄에 포함된 모든 동전 뒤집기 # 0: 앞면 1:뒷면 # 만들 수 없다면 1 # 초기 모형:beginning, 목표 모형:target # 목표: 최소 몆 번을 뒤집어야 목표한 모형이 되는지 여부 # 생각방향 # 하나의 돌의 앞 뒤 모양을 바꿀 떄 십자가 형태로 가로 세로 다 바꾼다!(잘못된 생각) # 행 또는 열을 통째로 뒤집는다 행과 열 동시에 x # 그리디 생각 > 세부 조건이 너무 많아 풀기 난해 방향 전환 # 타겟이 10으로 길이가 짧기 때문에 브루트포스 접근 생각 # 뒤집는 순서에 따라 바뀌는가 여부 확인 후 풀이 스타트 # deepcopy를 활용하여 원형을 만든 후 가로 바꿀 거 세로 바꿀 거를 바꾼 후 타겟과 확인 (효율성 개선 필요) # deepcopy vs slicing (슬라이싱이 더 빠르다 그리고 id로 확인시 둘다 원형과 위치 다름) # 핵심 포인트 사고 # 기본 풀이 방향 전제: 모두를 탐색한다 최대 2**20개 (뒤집냐 vs 안뒤집냐) # 임의의 돌이 다시 원래 형태로 유지되려면 0 또는 짝수번을 유지해야한다 # dp로 접근: 지속적인 형태의 반복 # 주어진 타겟의 길이로 볼 떄 여러번 반복 가능 def change_row(start, count, row): n = 0 for k in range(row): if count & (1 << k): # 넘어가는 곳이 해당 열을 뒤집는다는 의미 # for change in range(len(start[0])): # if start[k][change]==0: # start[k][change]=1 # else: # start[k][change]=0 start[k] = [1 - t for t in start[k]] n += 1 return start, n def change_col(start, col): m = 0 for i in range(col): num = set([row[i] for row in start]) if len(num) == 2: return -1 elif 1 in num: m += 1 #----------------------------------------------------------------개선 과정 코드들--------------------------------------------------------------------------------------------------------# # 내 풀이(개선 중) # 조건: 동전을 뒤집기 위해서는 해당 줄에 포함된 모든 동전 뒤집기 # 0: 앞면 1:뒷면 # 만들 수 없다면 1 # 초기 모형:beginning, 목표 모형:target # 목표: 최소 몆 번을 뒤집어야 목표한 모형이 되는지 여부 # 생각방향 # 하나의 돌의 앞 뒤 모양을 바꿀 떄 십자가 형태로 가로 세로 다 바꾼다!(잘못된 생각) # 행 또는 열을 통째로 뒤집는다 행과 열 동시에 x # 그리디 생각 > 세부 조건이 너무 많아 풀기 난해 방향 전환 # 타겟이 10으로 길이가 짧기 때문에 브루트포스 접근 생각 # 뒤집는 순서에 따라 바뀌는가 여부 확인 후 풀이 스타트 # deepcopy를 활용하여 원형을 만든 후 가로 바꿀 거 세로 바꿀 거를 바꾼 후 타겟과 확인 (효율성 개선 필요) # deepcopy vs slicing (슬라이싱이 더 빠르다 그리고 id로 확인시 둘다 원형과 위치 다름) # 핵심 포인트 사고 # 기본 풀이 방향 전제: 모두를 탐색한다 최대 2**20개 (뒤집냐 vs 안뒤집냐) # 임의의 돌이 다시 원래 형태로 유지되려면 0 또는 짝수번을 유지해야한다 # dp로 접근: 지속적인 형태의 반복 # 주어진 타겟의 길이로 볼 떄 여러번 반복 가능 def change_row(start, count, row): n = 0 for k in range(row): if count & (1 << k): for change in range(len(start[0])): if start[k][change] == 0: start[k][change] = 1 else: start[k][change] = 0 else: n += 1 return start, n def change_col(start, col): m = 0 for i in range(col): num = set([row[i] for row in start]) print(num) if len(num) == 2: return -1 elif 1 in start: m += 1 return m def solution(beginning, target): result = [] b = beginning t = target # 행 row = len(b) # 열 col = len(b[0]) check = [[0] * len(b[0]) for _ in range(len(b))] for i in range(row): for j in range(col): if b[i][j] != t[i][j]: check[i][j] = 1 # count:바꿀 행 경우의 수 (전체 경우의 수:2**row: 바꾸냐 안바꾸냐) for count in range(2 ** row): start, count_row = change_row(check[:], count, row) count_col = change_col(start, col) if count_col == -1: continue else: result.append(count_row + count_col) return min(result) if len(result) > 0 else -1 # 내 풀이(개선 중) # 조건: 동전을 뒤집기 위해서는 해당 줄에 포함된 모든 동전 뒤집기 # 0: 앞면 1:뒷면 # 만들 수 없다면 1 # 초기 모형:beginning, 목표 모형:target # 목표: 최소 몆 번을 뒤집어야 목표한 모형이 되는지 여부 # 생각방향 # 하나의 돌의 앞 뒤 모양을 바꿀 떄 십자가 형태로 가로 세로 다 바꾼다!(잘못된 생각) # 행 또는 열을 통째로 뒤집는다 행과 열 동시에 x # 그리디 생각 > 세부 조건이 너무 많아 풀기 난해 방향 전환 # 타겟이 10으로 길이가 짧기 때문에 브루트포스 접근 생각 # 뒤집는 순서에 따라 바뀌는가 여부 확인 후 풀이 스타트 # deepcopy를 활용하여 원형을 만든 후 가로 바꿀 거 세로 바꿀 거를 바꾼 후 타겟과 확인 (효율성 개선 필요) # deepcopy vs slicing (슬라이싱이 더 빠르다 그리고 id로 확인시 둘다 원형과 위치 다름) # 핵심 포인트 사고 # 기본 풀이 방향 전제: 모두를 탐색한다 최대 2**20개 (뒤집냐 vs 안뒤집냐) # 임의의 돌이 다시 원래 형태로 유지되려면 0 또는 짝수번을 유지해야한다 # dp로 접근: 지속적인 형태의 반복 # 주어진 타겟의 길이로 볼 떄 여러번 반복 가능 from collections import deque def change(new, k, t): flag = False check = new[:] count = 0 # 바꾼 줄 수 for i in range(len(k)): if i < len(new) and k[i] == True: for j in range(len(check[0])): if check[i][j] == 1: check[i][j] = 0 else: check[i][j] = 1 count += 1 elif i >= len(new) and k[i] == True: v = i - len(new) for j in range(len(check)): if check[j][v] == 1: check[j][v] = 0 else: check[j][v] = 1 count += 1 if check == t: flag = True return flag, count def solution(beginning, target): b = beginning t = target result = [] m = len(b) # 세로 n = len(b[0]) # 가로 new = b[:] # 타겟과 같을 경우 바로 끝 if b == t: return 0 q = deque([[True], [False]]) while q: k = q.popleft() flag, count = change(new, k, t) if flag == True: result.append(count) if len(k) < (m + n): q.append(k + [True]) q.append(k + [False]) return min(result) if len(result) > 0 else -1 # 내 풀이(시간 초과) # 비트 마스크를 활용하여 재풀이 # nCr 원리등에 활용 # 내 풀이(개선 중) # 조건: 동전을 뒤집기 위해서는 해당 줄에 포함된 모든 동전 뒤집기 # 0: 앞면 1:뒷면 # 만들 수 없다면 1 # 초기 모형:beginning, 목표 모형:target # 목표: 최소 몆 번을 뒤집어야 목표한 모형이 되는지 여부 # 생각방향 # 하나의 돌의 앞 뒤 모양을 바꿀 떄 십자가 형태로 가로 세로 다 바꾼다!(잘못된 생각) # 행 또는 열을 통째로 뒤집는다 행과 열 동시에 x # 그리디 생각 > 세부 조건이 너무 많아 풀기 난해 방향 전환 # 타겟이 10으로 길이가 짧기 때문에 브루트포스 접근 생각 # 뒤집는 순서에 따라 바뀌는가 여부 확인 후 풀이 스타트 # deepcopy를 활용하여 원형을 만든 후 가로 바꿀 거 세로 바꿀 거를 바꾼 후 타겟과 확인 (효율성 개선 필요) # 각각은 모두 뒤집냐 뒤집지 않냐의 상황을 감안하여 다시 완탐의 방향으로 접근! # 임의의 돌이 다시 원래 형태로 유지되려면 0 또는 짝수번을 유지해야한다 # dp로 접근: 지속적인 형태의 반복 # 주어진 타겟의 길이로 볼 떄 여러번 반복 가능 from itertools import combinations from collections import deque import copy def change_raw(new, i, m): for k in i: for t in range(len(m)): if new[t][k] == 0: new[t][k] = 1 else: new[t][k] = 0 return new def change_col(new_2, j, n): for k in j: for t in range(len(n)): if new_2[k][t] == 0: new_2[k][t] = 1 else: new_2[k][t] = 0 return new_2 def solution(beginning, target): b = beginning t = target # 타겟과 같을 경우 바로 끝 if b == t: return 0 elif len(b) == 1: return 1 m = [k for k in range(len(target))] # 세로 길이 n = [t for t in range(len(target[0]))] # 가로 길이 check = [] for i in m: for j in n: check.append([i, j]) check.sort(key=lambda x: (x[0] + x[1])) check = deque(check) check.popleft() # [0,0] 제거 완전 같은 경우 제거 # m:세로 n:가로 while check: raw, col = check.popleft() # raw:가로 바꿀 줄 수 # col: 세로 바꿀 줄 수 raw_list = list(combinations(n, raw)) col_list = list(combinations(m, col)) if raw == 0: for i in col_list: new = copy.deepcopy(b) # 기본 모형 초기화 new = change_col(new, i, n) if new == t: return col + raw continue elif col == 0: for i in raw_list: new = copy.deepcopy(b) # 기본 모형 초기화 new = change_raw(new, i, m) if new == t: return raw + col continue for i in raw_list: # i 바꿀 라인 모음 new = copy.deepcopy(b) # 새로운 형태를 만들기 위해 deepcopy 비긴닝 복사 #기본 모형 초기화 new_raw = change_raw(new, i, m) # 형태 변환(가로 변환) for j in col_list: # j 바꿀 라인 모음 new_2 = copy.deepcopy(new_raw) final = change_col(new_2, j, n) if final == t: return raw + col return -1 # 내 풀이 (개선 중) # 조건: 동전을 뒤집기 위해서는 해당 줄에 포함된 모든 동전 뒤집기 # 0: 앞면 1:뒷면 # 만들 수 없다면 1 # 초기 모형:beginning, 목표 모형:target # 목표: 최소 몆 번을 뒤집어야 목표한 모형이 되는지 여부 # 생각방향 # 하나의 돌의 앞 뒤 모양을 바꿀 떄 십자가 형태로 가로 세로 다 바꾼다!(잘못된 생각) # 행 또는 열을 통째로 뒤집는다 # 임의의 돌이 다시 원래 형태로 유지되려면 0 또는 짝수번을 유지해야한다 # dp로 접근: 지속적인 형태의 반복 # 주어진 타겟의 길이로 볼 떄 여러번 반복 가능 def solution(beginning, target): b = beginning t = target if b == t: return 0 else: result = 0 check = [[0] * len(target[0]) for _ in range(len(target))] for i in range(len(target)): for j in range(len(target[0])): count_1 = sum(target[i]) start_1 = sum(b[i]) count_2 = 0 start_2 = 0 for k in range(len(target)): count_2 += target[k][j] start_2 += b[k][j] check[i][j] = max(abs(count_1 - start_1), abs(count_2 - start_2)) print(check) return result if result != 0 else -1

""" 출처:프로그래머스, https://school.programmers.co.kr/learn/courses/30/lessons/87390 """ # 풀이 과정 count = left result = [] k = 1 # 내부에 들어갈 수 num = left % n + 1 # 내부 체크 수 while count <= right: if int(count / n) + 1 >= num and num <= n: k = int(count / n) + 1 if count >= left and count <= right: result.append(k) num += 1 count += 1 elif int(count / n) + 1 < num and num <= n: if count >= left and count <= right: result.append(num) num += 1 count += 1 if num > n: num = 1 return result

""" 출처:프로그래머스, https://school.programmers.co.kr/learn/courses/30/lessons/92335 """ # 풀이과정 def solution(n, k): result = 0 a = "" while True: if k == 10: break t = n % k a += str(t) n = int(n / k) if n < k: a += str(n) break a = a[::-1] if k == 10: a = str(n) # print(a) b = a.split("0") if k == 10: for c in b: count = 0 if c.isdigit() == True and int(c) != 1: for d in range(1, int(int(c) ** 0.5) + 1): if int(c) % d == 0: count += 1 if count > 1: break if count == 1: result += 1 else: print(b) for c in b: count = 0 if c.isdigit() == True and int(c) != 1: for d in range(1, int(int(c) ** 0.5) + 1): if int(c) % d == 0: count += 1 if count > 1: break if count == 1: result += 1 print(result) return result

""" 출처:백준, https://www.acmicpc.net/problem/2579 """ # 풀이 과정 n = int(input()) stage = [0] for i in range(n): k = int(input()) stage.append(k) dp = [0] * (n + 1) dp_check = [False] * (n + 1) dp[1] = stage[1] if n == 1: print(stage[1]) elif n == 2: print(max(stage[1], stage[1] + stage[2])) else: if stage[1] == 0: dp[2] == stage[2] else: dp[2] = stage[1] + stage[2] dp_check[2] = True count = 3 while count < n + 1: if dp_check[count - 1] == False: one = stage[count] + dp[count - 1] else: one = stage[count] + dp[count - 3] + stage[count - 1] two = stage[count] + dp[count - 2] if one > two: dp_check[count] = True dp[count] = one else: dp_check[count] = False dp[count] = two count += 1 print(dp[-1])

""" 출처:프로그래머스, https://school.programmers.co.kr/learn/courses/30/lessons/12899 """ # 풀이 과정 # 1.재귀로 연속으로 숫자를 바꾸기 # 2.조합으로 생각 후 연속 된 숫자를 나눠서 위치로 숫자 찾기 # 1.재귀로 연속으로 숫자를 바꾸기 # 2.조합으로 생각 후 연속 된 숫자를 나눠서 위치로 숫자 찾기 def solution(n): k = ["1", "2", "4"] result = "" num = n count = 1 # 자릿수 파악 while num > 0: num -= 3 ** (count) if num > 0: count += 1 for a in range(1, count): n -= 3 ** a while count > 1: i, j = divmod(n, 3 ** (count - 1)) if j == 0: result += k[i - 1] else: result += k[i] n = n % (3 ** (count - 1)) count -= 1 if count == 1: i, j = divmod(n - 1, 3) result += k[j] return result