ํฐ์คํ ๋ฆฌ ๋ธ๋ก๊ทธ์์ ๋ค๋ฅธ ๋ธ๋ก๊ทธ๋ก ์ด์ ์์ ํ๋ฌํฐ ๊ณต์ ๋ฌธ์ ๊ธฐ์ฌํ ๊ฒ ํฌ์คํ
๋ฐ ํ๋ฌํฐ ๊ด๋ จ ๊ธ๋ค ์ ๋ฆฌ ํ๋ก ํธ ์ฌ๋ฌ ๊ธฐ์ ๋ค ํ์ตํ์ฌ ์ ๋ฆฌ ๊น์ด์๋ ๋ด์ฉ์ผ๋ก ํฌ์คํ
ํ ์์
์ ์ฒด ๊ธ
์ฑ์ฅํ๊ธฐ ์ํ ๊ธ์ ์์ฑํ๋ ค๊ณ ๋ ธ๋ ฅ์ค ์ ๋๋ค
๋ฌธ์ ์ฒซ ํ์ด์ ์คํจ์ฐ์ ๊ฐ์ฅ ๋จผ์ ์๊ฐ๋๋ ๋ฐฉ๋ฒ์ผ๋ก ์ฝ๋ฉ์ ํ์๋ค. n, p = map(int, input().split())words = [input() for _ in range(n)]#words = []#for i in range(len(arr)):# words.append(arr[i][4:len(arr[i]) - 4])obj = {}for word in words: for letter in word: obj[letter] = 1for i in range(len(words)): for j in range(len(words[i])): for k in range(i + 1, len(words)): if i == k: continue if words[i][..

Type Challenges ์์์ด๋ฒ์ ์คํ๋ฆฐํธ์์ ์๋ก ๋ฐฐ์ ๋ฐ์ ๋ฉํ ๋์ ์ถ์ฒ์ ๋ฐ์ ์์ํ๊ฒ ๋์๋ค. ๋ฌธ์ ์ฒซ ๋ฌธ์ ๋ utility type์ธ Pick์ ๊ตฌํํ๋ ๋ฌธ์ ์ด๋ค. ๋์ด๋๋ easy ํ์ด๊ณผ์ type MyPick = {[key in K]:T[K]} ์ต๋ํ ๋ค๋ฅธ ์ธํฐ๋ท ์๋ฃ๋ฅผ ์ฐพ์๋ณด๋ ค๊ณ ํ์ง ์์๋ค. ์ฐจ๊ทผ์ฐจ๊ทผ ์๊ฐํ๋ฉฐ ํ์๋ค. ๋ฐ์ ๊ฒ์์ ์๋ฌ๊ฐ ๋ด๋ค. 1๋ถ ๋์ ๊ณ ๋ฏผํ๋ค๊ฐ ๋ด๊ฐ ์ค์๋ฅผ ํ๋จ ๊ฑธ ๊นจ๋ฌ์๋ค. type MyPick = {[key in K]:T[key]} T[K] ๋ฅผ T[key]๋ก ๋ฐ๊ฟจ๋ค. ์๋ฌ๋ ๋ค ์ฌ๋ผ์ก์ง๋ง ์ด๊ฒ ์ ๋ต์ธ์ง ๋ชจ๋ฅด๊ฒ ๋ค? ๋ฐ๋ก ์ด์๋ฅผ ๋จ๊ธฐ๋ ค๊ณ ํ์ง๋ง ๋น์ทํ ๋ต์์ด ์์ ๊ฒฝ์ฐ thumb up๋ง ๋จ๊ฒจ๋ฌ๋ผ๊ณ ํด์ ์ผ๋จ ์ ๋ต๋ค์ ์ดํด๋ณด๊ธฐ๋ก ํ๋ค. ์ ๋ต๋ค ์ดํด๋ณด๊ธฐ ์ ๋ต๋ค์ ..

๋ฌธ์ ๋งํฌhttps://leetcode.com/problems/letter-combinations-of-a-phone-number/description/ ๋ฌธ์ ์ค๋ช
๊ฐ๋จํ ๋ฐฑํธ๋ํน ๋ฌธ์ ๋ฌธ์ ํด๊ฒฐ๊ณผ์ ์ด๋ฒ ๋ฌธ์ ๋ ์ด๋ ต์ง๋ ์์๊ณ ํ
์คํธ์ผ์ด์ค๋ ์ ๋ถ ํต๊ณผ๋ฅผ ํ์ง๋ง ๋ฌธ์ ๋ฅผ ํ๊ธฐ์ํ ์ ๊ทผ์ ์กฐ๊ธ์ ์ด์ํ๊ฒ ํ ๋ถ๋ถ์ด ์์๊ธฐ์ ๊ทธ ๋ถ๋ถ์ ์ง๊ณ ๋์ด๊ฐ๊ณ ์ ํ๋ค. letters = [[],[],['a','b','c'],['d','e','f'],['g','h','i'],['j','k','l'],['m','n','o'],['p','q','r','s'],['t','u','v'],['w','x','y','z']]class Solution: def backtracking(arr,ans, digits,results): ..

๊ณจ๋5 ๋ฌธ์ ์ด๋ค. ์ฝ๋dictionary = []puzzels = []flag = Truewhile True: s = input() if s == '#': break if s == '-': flag = False continue if flag: dictionary.append(s) else: puzzels.append(s)for puzzel in puzzels: candidates = [] for word in dictionary: puzzel_list = list(puzzel) flag = True for i in range(len(word)): if word[i] not in puzzel_list: flag = False ..

https://www.acmicpc.net/problem/1027 ๋ฌธ์ ์ค๋ช
๋ฌธ์ ๋ฅผ ๋ฑ ๋ณด์๋ง์ ์์ ํ์์ด๋ผ๊ณ ์๊ฐํ๋ค. ๊ฑด๋ฌผ๋ค์ ํ๋์ฉ ๋น๊ตํ๋ฉฐ ์นด์ดํ
์ ํ ์ฝ๊ฒ ํ ์ ์์ ๊ฑฐ๋ผ๊ณ ์๊ฐํ๋ค.๋น๋ฉ์ ์๋ ์ ์ผ๋ 3์ค ๋ฐ๋ณต๋ฌธ๋ ์๊ฐ์ด๊ณผ๊ฐ ์๋ ๊ฒ์ด๋ผ๊ณ ์๊ฐํ๋ค.ํด๊ฒฐ๊ณผ์ ์ฒซํ์ดn = int(input())arr = list(map(int, input().split()))for i in range(n): cnt = 0 for j in range(n): if i == j: continue target = abs(arr[j] - arr[i]) / abs(j - i) start = min(i, j) end = max(i, j) flag = True if end - start..
์ข์๋์ ์ข์ ๋๋ฃ์ ํจ๊ปํ๋ค์ค๋ ฅ์ด ์ข์ ๋๋ฃ์ ํจ๊ปํด์ ์ข์๋ค ๋๋ ๋ค๋ฅธ์ฌ๋์ ์ฅ์ ์ ํก์ํ์ฌ ๋ฐ์ ์ํค๋๋ฐ์ ์ ๋ง ๋ฅํ๊ธฐ ๋๋ฌธ์ ๊ฐ์ด ์ฝ๋์ ๋ํด ๊ณ ๋ฏผํ๊ณ ์๊ธฐํ๋ฉฐ ์ค๋ ฅ์ด ๋ง์ด ์ฑ์ฅํ์์ ๋๊ผ๋ค. ๊ธฐ์ด ํ๋ก์ ํธ์ธ ๋กค๋ง๋๋ ์ข์ ์ฝ๋์ ๋ํ ๊ณ ๋ฏผ๋ณด๋ค๋ ๋ด๊ฐ ์ด๋ค ๊ธฐ๋ฅ์ด๋ ๋น ๋ฅธ ์๊ฐ ๋ด์ ๊ตฌํํ ์ ์๊ตฌ๋๋ฅผ ๋๊ผ๋ค๋ฉด ์ด๋ฒ์๋ ์ข์ ๋๋ฃ๋ค๊ณผ ์ด๋ป๊ฒ ํ์
์ ํ๋ฉด ์ข์์ง ๋ฐฐ์ด ๊ฒ ๊ฐ๋ค. ๋กค๋ง๋ ์์ฌ์ ๋ ์ ํด์๋กค๋ง๋ ์์ฌ์ ๋ ๊ฒ์ ์๋ฌ์ฒ๋ฆฌ ๋ฐ ๋ก๋ฉ์ฒ๋ฆฌ์ ๋ํ ์ ๊ฒฝ์ ๋ ์ด ๊ฒ์ด์๋๋ฐ ์ด๋ฒ ํ๋ก์ ํธ์์๋ ์์ ์๋ฌ์ฒ๋ฆฌ์ ๋ํ ํ์๊น์ง ํ๋ฉด์ ์๋ฌ์ฒ๋ฆฌ์ ๋ํ ์ ๊ฒฝ์ ๋ง์ด ์ผ๋ค. ๋ก๋ฉ ์ฒ๋ฆฌ์ ๊ฒฝ์ฐ SSR์ผ ๋ ์ ์ฉ์ ํด์ฃผ์ง ์์๋ค. Link ํ๊ทธ ๋๋ถ์ด๊ณ , ๊ฑฑ์ ๋๋ ๋ถ๋ถ์ Link ๋ก ํ์ด์ง ์ด๋์ ๋๋ ์ด๊ฐ ์๊ธฐ๋ ๋ถ..

๋ฌธ์ ์ 1 - ํด๊ฒฐ์ ํ
์ด๋ธ ์ปดํฌ๋ํธ๋ ๊ณตํต ์ปดํฌ๋ํธ๋ก ๊ตฌํํด์ผ ํ๋ค. ์ด ํ
์ด๋ธ์ ๊ณตํตํ๋ฅผ ํ๊ฒ ๋๋ฉด ํ
์ด๋ธ์ ๊ทธ์ ๋ฐ์ดํฐ๋ฅผ ๋ฐ์์์ ๋ณด์ฌ์ฃผ๋ ์ญํ ๋ง์ ์ํํ๋๊ฒ ์ณ๋ค๊ณ ํ๋จํ๋ค. (๊ฐ๊ฒ, ์ผ์, ์๊ธ, ์ํ)์ ๊ฐ์ ํ์ดํ๊ณผ ๋ด์ฉ์ ๊ทธ์ string ๋ฐฐ์ด ๋ฐ์ดํฐ๋ก ๋๊ฒจ์ฃผ๋ฉด ๋์ง๋ง ๊ฐ์ฒด๋ก ๋ฐ์ดํฐ๋ฅผ ๋๊ธฐ์๋ ํ์๋ค์ ์๊ฒฌ์ด ์์๋ค. ๋๋ ๊ทธ์ string ๋ฐฐ์ด๋ก ํ์ง ์๊ณ ํ์
์ ์ข ๋ ์ขํ๊ณ ๊ฐ์ ํด์ ์ฌ์ฉํ๋๊ฒ ์ข๋ค๊ณ ์๊ฐํ๋ค. ๊ฒฐ๋ก ์ ์ผ๋ก ๊ฐ์ด ์ฝ๋ฉํ๋ฉฐ ์์ ๊ฐ์ด ์ฝ๋ฉ์ ํ์๋ค. ๋ญ.. ๋๋ฆ ๊ด์ฐฎ์ ๊ฒ ๊ฐ๋ค. ๋ฌธ์ ์ 2 - ํด๊ฒฐํ์ด์ง๋ค์ด์
์ ๊ณตํต ํ
์ด๋ธ ์ปดํฌ๋ํธ ์์ ๋ฃ๋๋ค๋ฉด ๋ฐ์ดํฐ๋ฅผ ํ
์ด๋ธ์์ ๊ฐ์ ธ์ค์ง ์์ผ๋ฉด ํ
์ด๋ธ์ ์ด์ฉํ๋ ์์ ์ปดํฌ๋ํธ์์ ํ์ด์ง์ ๋ํ ์ ๋ณด๋ฅผ ๊ฐ์ง๊ณ ์๊ณ ์ด๊ฒ์ ํ
์ด๋ธ์ ๋๊ฒจ์ฃผ..