(์ฌ์ง: ํ๋ก๊ทธ๋๋จธ์ค ๋ง์ค์ฝํธ ๋จธ์ฑ์ด)
2021๋ 7-8์์ ํ๋ก๊ทธ๋๋จธ์ค์์ ์งํํ๋ ์ฝ๋ฉํ ์คํธ์ ์ค๋ฌด ์ญ๋ ๋ชจ๋ ์ก๋ ์คํฐ๋: Python๋ฐ์ ์ฐธ์ฌํ์ต๋๋ค. ๋น์ ์คํฐ๋๊ฐ ๋๋ ํ ์ผ๋ ์ฃผ์ฐจ๋ณ ํ๊ณ ๋ฅผ ์ฎ์ด์ ์์ ํ ์ฌ๋ฐํํ๋ ๊ธ์ ๋๋ค.
์คํฐ๋ ์ค
์ฝ๋ฉํ ์คํธ ๋ฌธ์ ํ์ด๋ฅผ ์ด์ฌํ ํ์ต๋๋ค. ํน์ ๊ตฌ๊ฐ์ ๋ค๋ค๋ฅด๋ ์ค๋ ฅ์ ์ ์ฒด๋ฅผ ๋๊ผ์ต๋๋ค. ์ฑ ์ ํตํด ๊ณต๋ถํ๊ณ ์์์ง๋ง, ์ฑ ์ ํ๊ณ๊ฐ ์์์ต๋๋ค. ์ํฉํธ ์บ ํผ์ค๋ฅผ ํตํด ํ๋ก๊ทธ๋๋จธ์ค์์ ์งํํ๋ ํ์ด์ฌ ์ฝ๋ฉํ ์คํธ ์คํฐ๋์ ์ฐธ์ฌํ๊ฒ ๋์์ต๋๋ค. ํผ์ ๊ณต๋ถํ ๋๋ ํ ์ ์๋ ๋ฌธ์ ๋ ํ ์ ์๋ค๋ (?) ํ๊ณ๊ฐ ์์๊ณ , ์ฑ ์ผ๋ก ๋ฐฐ์ฐ๋ฉฐ ์ฑ ์ ๊น๋ํ ์์ ์ฝ๋๋ฅผ ๋ฐ๋ผ์น๋ค ๋ณด๋ ๋ด ์ฝ๋์ ๋ฌธ์ ์ ์ ๋๋ผ์ง ๋ชปํ์์ต๋๋ค...
ํ์ง๋ง ์คํฐ๋๋ฅผ ์์ํ๋ฉฐ ์ฝ๋์ ๋ง์ ๋ฌธ์ ๊ฐ ์๋ค๋ ๊ฒ์ ์๊ฒ ๋์์ต๋๋ค..๐ญ ํ์ด์จ๋ํ๊ฒ ์ฝ๋๋ฅผ ์์ฑํ์ง ๋ชปํ๋ ๊ฒ์ ํ์ด์ฌ์ด ์ฒ์์ด๋ผ ๊ทธ๋ ๋ค๊ณ ์ณ๋, ๋ก์ง์ด ๋นํจ์จ์ ์ด๊ฑฐ๋ ์ง์ ๋ถํ ๊ฒ์ ๋๋ฌด ๋ถ๋๋ฝ๋๋ผ๊ณ ์. ํธ๋ ๋ฐฉ๋ฒ์ ์ดํดํ๊ณ ์๊ธฐํ๋๋ฐ, ์ฝ๋๊ฐ ์ง์ ๋ถํ ๊ฒ์ ์ฝ๊ฒ ๊ณ ์ณ์ง์ง ์์ 4์ฃผ ๋ด๋ด ์ด ๋ถ๋ถ์ ์ ๊ฒฝ์ผ์ต๋๋ค.
์คํฐ๋ ๊ทธ ํ
์คํฐ๋๋ฅผ ๋ง์น๊ณ ๋๋ฉด ์ด์ ๋ค์ ์์์ด๋ผ๋ ๊ธฐ๋ถ์ด ๋ญ๋๋ค. ๋ฐฐ์ด ๋ฐฉ๋ฒ์ ํ ๋๋ก ๋ ๋ง์ด ์ฐ์ตํด์ผ ํฉ๋๋ค.. ์ ๋ ์คํฐ๋ํ๋ฉฐ ๋ง๋ ์ด์ ์๋ ๋๋ฃ๋ค๊ณผ ์ฝ๋ฉํ ์คํธ ์คํฐ๋๋ฅผ ์ด์ด๊ฐ๊ณ ์์ต๋๋ค. ์ ๋ ์์ฝ๊ฒ๋ ๋ค๋ฅธ ์ธ์ด๋ฅผ ๊ณต๋ถํ๊ธฐ ์์ํด ๊ธฐ์ ์ฝํ ์ ์์ํ๊ณ ์์ง๋ ๋ชปํ์ง๋ง, ๋ฌธ์ ํธ๋ ๋ฐฉ๋ฒ์ ์์ ์์ด๋ฒ๋ฆฌ์ง ์์ ์ ๋๋ก ๊ณ์ ๊ณต๋ถํ๊ณ ์์ต๋๋ค.
์คํฐ๋์ ์ฅ์ , ๊ทผ๋ฐ ์ด์ ๊ฐ์ธ์ ์ธ ์๊ฐ์ ๋ง๋ถ์ธ
- ๋ฆฌ๋(ํ์ง ๊ฐ๋ฐ์)๊ฐ ์ฝ๋ ๋ฆฌ๋ทฐ๋ฅผ ํด์ค๋ค.
-> ํธ๋ ๋ฐฉ๋ฒ์ ์ตํ๊ฑฐ๋ ์ธ์์ ํผ ์ฌ๋(๋)์ ํ ์ ์๋ ๋ฌธ์ ๋ ๋์ฒด๋ก ํจ์จ์ ์ธ ๋ฐฉ๋ฒ์ผ๋ก ํ ๊ฒ์ด๊ณ , ๋ชป ํธ๋ ๋ฌธ์ ๋ ์์ ์๋ ๋ชป๋ ๊ฒ.. ๊ทธ๋์ ํธ๋ ๋ฐฉ๋ฒ๋ณด๋ค๋ ๋ค๋ฅธ ๋ถ๋ถ์์ ๋ฆฌ๋ทฐ๋ฐ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์์ต๋๋ค. ์ฒ์๋ถํฐ ๋๊น์ง ๋๋ง์ ์๊ฐ์ผ๋ก ํธ์๋ ๋ถ๋ค์ด๋ผ๋ฉด ๋ ํฐ ๋์์ด ๋ ๊ฒ๊ฐ์ต๋๋ค. - ๋ฆฌ๋๊ฐ ์ฝ๋ฉ ํ
์คํธ ํธ๋ ๋
ธํ์ฐ๋ฅผ ์ ์ํด์ค๋ค.
-> ์ฒ์ ์ฝ๋ฉํ ์คํธ๋ฅผ ์ค๋นํ๋ ๋ถ๋ค / ๊ณต๋ถ๋ฅผ ๊ฝค ํ์ จ๋๋ฐ ์ค๋ ฅ์ ์ ์ฒด๋ฅผ ๊ฒช๊ณ ๊ณ์ ๋ถ๋ค ๋ชจ๋์๊ฒ ๋์์ด ๋ ๊ฒ๊ฐ์ต๋๋ค. - ์คํฐ๋๊ฐ ๋๋๊ณ ์คํฐ๋ ํ์ด์ง๊ฐ ์ฌ๋ผ์ง์ง ์๋๋ค
-> ์ฃผ์ฐจ๋ณ ์ธ์ , ๋ฌธ์ , ํ๋ค์ด ๊ณ์ ๋จ์ ์์ต๋๋ค. ๋์ด๋ ๋ฑ ์ฌ๋ฌ ์ด์ ๋ก ๋ชป ํ๊ณ ๋์น ๋ถ๋ถ๋ ์๋๋ฐ, ๋๊ณ ๋๊ณ ๊ณต๋ถํ ์ ์์ต๋๋ค.
1์ฃผ์ฐจ (Queue & Heap)
# ๋ฆฌ๋ทฐ ํ
if 0 <= nx < n and 0 <= ny < m and image[nx][ny] == now:
image[nx][ny] = 0
q.append((nx, ny))
# ๋ฆฌ๋ทฐ ์
if nx < 0 or nx >= n or ny < 0 or ny >= m:
continue
if image[nx][ny] == 0:
continue
if image[nx][ny] == now:
image[nx][ny] = 0
q.append((nx, ny))
๋ฆฌ๋ทฐ ์ ์ฝ๋๋ ์ฒ์ bfs๋ฅผ ๊ณต๋ถํ ๋ ์ฑ
์์ ๋ดค๋ ์ฝ๋์
๋๋ค.
์ฒ์ ๋ฆฌ๋ทฐ๋ฅผ ๋ฐ์์ ๋๋ ์กฐ๊ฑด์ ์ด๋ป๊ฒ ํํํ๋์ง์ ๋ํ ์ ํธ์ ์ฐจ์ด๊ฐ ์๋๊ฐ? ์๊ฐํ๊ธด ํ์ต๋๋ค.
ํ์ง๋ง ๊ทธ ํ ์ด์ด์ง๋ ๋ฆฌ๋ทฐ์์ ์ ๊ฐ ์ฝ๋๋ฅผ ์์ฑํ ๋ ๋ง์น ๋จ๊ณ๋ฅผ ๋ฐ๋ ๊ฒ์ฒ๋ผ ์กฐ๊ฑด์ ์ฌ๋ฌ ๋ฒ ๋์ดํ๋ ๊ฒ์ ์ ํธํ๋ค๋ ๊ฒ์ ์๊ฒ ๋์์ต๋๋ค .. ์ฒ์์ผ๋ก ์ฝ๋๋ฅผ ์ ๊ฐํ๋ ๋ฐฉ์์ ๋ํด ์๊ฐํด๋ณด๊ฒ ๋์์ต๋๋ค.
# ๋ฆฌ๋ทฐ ํ
if day > prev:
answer.append(count)
count = 0
count += 1
# ๋ฆฌ๋ทฐ ์
if day == prev:
count += 1
elif day > prev:
answer.append(count)
count = 1
์กฐ๊ฑด์ ์ด๋ฐ ์(?)์ผ๋ก ์ฃผ๊ณ ์๋ค๋ ๊ฒ๋ ์๊ฒ ๋์๊ณ ์..
sum(ele ** 2 for ele in works) # ํจ์จ์ฑ ๋ ์ข์
sum([ele ** 2 for ele in works])
์์ sum์ด ๋ ๋น ๋ฅด๊ฒ ๋์จ ์ด์ ๊ฐ ๊ถ๊ธํด์ ์ฌ์ญค๋ณด์๋๋ ์ฌ๋์ด ์ธ์งํ ์ ์์ ์ ๋์ ์ฐจ์ด๋ก ๋น ๋ฅผ ์๋ ์์ง๋ง ์ค์ ์คํ ์๊ฐ์ ์ํฅ์ ์ค ์ ๋๋ ์๋๋ผ๊ณ ๋ต๋ณ ์ฃผ์ จ์ต๋๋ค. ใ ๊ถ๊ธํ ๋ถ๋ถ๋ ๋ง์๊ป ์ง๋ฌธํ์ต๋๋ค.
# ๋ฆฌ๋ทฐ ํ
while scoville[0] < K:
try:
heappush(scoville, heappop(scoville) + heappop(scoville) * 2)
answer += 1
except:
return -1
# ๋ฆฌ๋ทฐ ์
while scoville[0] < K:
first = heapq.heappop(scoville)
if scoville:
new_scov = first + (heapq.heappop(scoville) * 2)
heapq.heappush(scoville, new_scov)
answer += 1
else:
return -1
ํ์ด์ฌ์ try-except๋ฌธ์ ์๊ณ ๋ง ์์๋๋ฐ ์ฝ๋์ ์ ์ฉํ๋ ๋ฐฉ๋ฒ๊ณผ ์ฐธ๊ณ ๋งํฌ๋ ๊ณต์ ํด์ฃผ์
จ์ต๋๋ค.heapq.heapreplace
์ ์กด์ฌ๋ ์๋ ค์ฃผ์
จ์ต๋๋ค. ใ
ใ
2์ฃผ์ฐจ (Stack & Hash)
p = re.compile('(\(\))?(\{\})?(\[\])?')
s = re.sub(p, '', s)
ํ ํ ์คํธ์์ ์ ๊ทํํ์์ ์ฌ์ฉํ์ ๋ ํจ์จ์ฑ์์ ํต๊ณผํ์ง ๋ชปํ์ต๋๋ค. ์ด ์ฝ๋์ ํจ๊ป ์ฌ์ญค ๋ณด๋ ์ ๊ทํํ์์ ์ฑ๋ฅ์ด ์ข์ง ์์ ์ฝํ ์์๋ ์ฌ์ฉํ์ง ์๋ ๊ฒ์ ๊ถ์ฅํ๋ค๋ ๋ต๋ณ์ ๋ฐ์์ต๋๋ค.
# ๋ฆฌ๋ทฐ ์
if not stack:
return True
else:
return False
# ๋ฆฌ๋ทฐ ํ
return not stack
if else ๊ตฌ๋ฌธ์ ์์ฃผ ์ ์งํ๊ฒ ์ฐ๋ ํธ...
# ๋ฆฌ๋ทฐ ์
for name in names:
weight = int(trucks[name])
if weight == max_weight:
sum_weight = 0
answer += 2
continue
if weight < (max_weight - sum_weight):
sum_weight += weight
elif weight > (max_weight - sum_weight):
sum_weight = weight
answer += 1
elif weight == (max_weight - sum_weight):
sum_weight = 0
answer += 1
# ๋ฆฌ๋ทฐ ํ
for name in names:
weight = int(trucks[name])
if weight > (max_weight - sum_weight):
sum_weight = 0
answer += 1
sum_weight += weight
์ ๊ฐ ๋จ๊ณ๋ง๋ค ์กฐ๊ฑด์ฃผ๋ ๊ฒ์ ์ด๋ ๊ฒ๋ ์ข์ํ๋ ์ฌ๋์ ๋๋ค..
# ๋ฆฌ๋ทฐ ์
if sum(board[i]) == 0:
answer += 1
# ๋ฆฌ๋ทฐ ํ
answer += int(sum(board[i]) == 0)
์ด๋ ๊ฒ ํ ์ค๋ก ํํํ ์ ์์ต๋๋ค.
3์ฃผ์ฐจ (Searching)
3์ฃผ์ฐจ๋ถํฐ ๋ฌธ์ ์ ๋์ด๋๊ฐ ์์นํ์ต๋๋ค. ๋ฌธ์ ํ์ดํ๋ฉฐ ๋๋ ๊ฒ์ ํผ์ ์ด๋ป๊ฒ๋ ํ์ด๋ผ ์ ์๋ ๋ฌธ์ ๊ฐ ์๋ ๋ฐ๋ฉด ํธ๋ ๋ฐฉ๋ฒ์ ๋ชจ๋ฅด๋ฉด ํ์ง ๋ชปํ๋ ๋ฌธ์ ๊ฐ ์์ต๋๋ค. 3์ฃผ์ฐจ ์ฃผ์ ๊ฐ Searching์ธ ๋งํผ ํ์์ ๋ฌธ์ ๊ฐ ๋ง์๋ค๊ณ ์๊ฐํ์ต๋๋ค. ํผ์ ๊ณต๋ถํด์ผ ํ๋ ๋ถ๋ถ์ด ๋ณธ๊ฒฉ์ ์ผ๋ก ๋ง์์ง ์ฃผ์ฐจ๋ผ๊ณ ์๊ฐ๋ฉ๋๋ค.
# ๋ฆฌ๋ทฐ ์
prime = set([i for i in range(2, n) if prime[i] == True])
# ๋ฆฌ๋ทฐ ํ
prime = set([i for i in range(2, n) if prime[i]])
์ทจํฅ์ ๋ฐ๋ผ ์๋์ฒ๋ผ ์ธ ์ ์์ต๋๋ค. ์ทจํฅ๋๋ก ์ ํํ ๊ฒ์ด ์๋๋ผ ์๋์ฒ๋ผ ์ธ ์ ์๋ค๋ ๊ฒ์ ์๊ฐํ์ง ๋ชปํ๊ธฐ์ ๋์๋์์ต๋๋ค.
for i in range(1, len(weights) + 1):
# combi.append([sum(data) for data in itertools.combinations(weights, i)])
answer += [sum(data)
for data in itertools.combinations(weights, i)].count(m)
return answer
.count(number)
์ ์กด์ฌ๋ฅผ ๋ชฐ๋์ด์ ์ฃผ์์ ์๋ ์ฝ๋๋ก ์์ฑํ ํ ์ฐพ์ผ๋ ค๊ณ ํ์ต๋๋ค. ๋ค๋ง ํน์ ํ ๊ฐ์ ์ฐพ์์ผํ๋ค๋ฉด ์์ ์ฝ๋์ฒ๋ผ ์ธ ์ ์๋ค.
sieve = [True] * n
for i in range(2, int(n ** 0.5) + 1):
if sieve[i] == True:
for j in range(i + i, n, i):
sieve[j] = False
prime = [i for i in range(2, n) if sieve[i] == True]
์๋ผํ ์คํ ๋ค์ค์ ์ฒด ๊ฐ๋ ๋ ๊ณต๋ถํ์ต๋๋ค.
4์ฃผ์ฐจ (Sorting & Dynamic Programming)
DP๋ ๊ณต๋ถํ์ง ์์์๊ธฐ์ 4์ฃผ์ฐจ ๋ฌธ์ ๋ ์ํํ๊ธฐ ๋ฐ๋นด์ต๋๋ค.
def solution(n):
dp = [0 for i in range(n + 1)]
dp[1] = 1
dp[2] = 2
for i in range(3, n + 1):
dp[i] = (dp[i - 1] + dp[i - 2]) % 1000000007
return dp[n]
DP์ ๊ธฐ๋ณธ ๋ฌธ์ ๋ผ๋ 2xn ํ์ผ๋ง ๋ฌธ์ ์
๋๋ค.
ํ๊ต๋ค๋ ๋๋ ์ ํ์์ด ๊ทธ๋ ๊ฒ ์ด๋ ค์ ์๋๋ฐ.. ๋ค์ ๋ง๋๊ฑธ ๋ณด๊ณ ๋ง๊ฐ์ด ๊ต์ฐจํ์ต๋๋ค.
๊ทธ ๋ ํ ๊ฑธ
๋๋น๋๋์ด ์ฌ๋ ค์ค ์์์ ๋ณด๊ณ ๊ฐ์ ์ก์๊ณ , ๋๋ฃ์ ๋์์ผ๋ก ์กฐ๊ธ ๋ ๊น๊ฒ ์ดํดํ ์ ์์์ต๋๋ค.
๋ง์ง๋ง ์ธ์ ๋๋ ์ง์์๋ต๊ณผ ์๊ฐ์ ๋๋๋ ์๊ฐ์ด ๋ฐ๋ก ์์ต๋๋ค. ์ ๋ ์ง์์๋ต ์๊ฐ๋ ๋์์ด ๋ง์ด ๋์์ต๋๋ค. ํฌํธํด๋ฆฌ์ค๋ ์ด๋ ฅ์๋ฅผ ๋ด์ค์๋ ์๋ค๊ณ ํ์ จ์ผ๋ ์ด ๋ถ๋ถ๋ ์ ์ค๋นํ์ ์ ์ฐธ์ํ์๋ฉด ํฐ ๋์์ด ๋ ๊ฒ๊ฐ์ต๋๋ค.
'๐งฉ ์ฝ๋ฉ ํ ์คํธ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Swift] [ํ๋ก๊ทธ๋๋จธ์ค] ๋ ๊ฐ ๋ฝ์์ ๋ํ๊ธฐ ํ์ด (0) | 2022.01.07 |
---|
๋๊ธ