๋ฐฐ์ด i~j๋ฒ์งธ๋ก ์ซ์๋ฅผ ์๋ฅด๊ณ ์ ๋ ฌํ์ ๋ k๋ฒ์จฐ ์๋ฅผ ๊ตฌํ๋ ๋ฌธ์ .
def solution(array, commands):
answer = []
for i in range(len(commands)):
result = sorted(array[commands[i][0]-1:commands[i][1]])
answer.append(result[commands[i][2]-1])
return answer
< ํ์ด ๊ณผ์ >
์ฃผ์ด์ง array๋ฅผ commands ๊ธธ์ด๋งํผ ๋ฐ๋ณตํ์ฌ array๋ฐฐ์ด์ commands๋ด ์ซ์๋ก ๋ฝ์ sortingํ ํ, answer์ k๋ฒ์งธ ์๋ง appendํ์๋ค.
์์ ์ ์๋ก ๋ ๋ฐฐ์ด numbers๊ฐ ์ฃผ์ด์ง๊ณ ์ด ๋ฌธ์์กฐํฉ์ผ๋ก ๊ฐ์ฅ ํฐ ์๋ฅผ ๋ฆฌํดํ๋ ๋ฌธ์
def solution(numbers):
numbers = list(map(str, numbers))
numbers.sort(key = lambda x : x*3, reverse = True)
return str(int(''.join(numbers)))
< ํ์ด ๊ณผ์ >
์ฐ์ ์ฃผ์ด์ง ์ ์ํ ๋ฆฌ์คํธ๋ฅผ ๋ฌธ์์ด ๋ฆฌ์คํธ๋ก ๋ฐ๊พผ ํ, numbers ๋ด ์์๊ฐ 1000์ดํ์ธ ๊ฒ์ ์ฃผ๋ชฉํ๋ค. ํ์ฌ ๋ฌธ์ํ์ธ numbers๋ฅผ 3๋ฐฐ ๊ณฑํด์ฃผ์ด ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌํ๋ค. ๊ทธ๋ ๊ฒ ๋๋ฉด, 3๊ณผ 30์ ๋น๊ตํ๋ฉด 333, 303์ด๋์ด 3์ด ๋ ํฐ ๊ฐ์ ๊ฐ๊ฒ ๋๋ค.
๊ณผํ์๊ฐ ๋ฐํํ ๋ ผ๋ฌธ nํธ ์ค hํธ ์ด์ ์ธ์ฉ๋ ๋ ผ๋ฌธ์ด hํธ ์ด์์ด๊ณ ๋๋จธ์ง ๋ ผ๋ฌธ์ด h๋ฒ ์ดํ ์ธ์ฉ๋ ๊ฒฝ์ฐ, h์ ์ต๋๊ฐ์ ๊ตฌํ๋ ๋ฌธ์ .
def solution(citations):
answer = 0
citations.sort()
for i in range(len(citations)):
if len(citations) - i <= citations[i]:
return len(citations) - i
return 0
< ํ์ด ๊ณผ์ >
์ ์ฒด ๊ธธ์ด - ์ธ๋ฑ์ค ๋ณด๋ค ์ ๋ ฌ๋ ๋
ผ๋ฌธ ๋ฐฐ์ด์ ์ซ์๊ฐ ํฌ๊ฑฐ๋ ๊ฐ์ ๊ฒฝ์ฐ ๋ฆฌํดํ๋ฉด ๋๋ ๋ฌธ์ .
return 0์ ํด์ค ์ด์ ๋, ๋ชจ๋ ๋
ผ๋ฌธ์ ์ธ์ฉ ํ์๊ฐ 0์ธ ๊ฒฝ์ฐ๋ ๊ณ ๋ ค๋ฅผ ํด์ผํ๋ค.
ํ์๋ง๋ค ๋ฒํธ๊ฐ ์ฃผ์ด์ง๊ณ , ์ฒด์ก๋ณต์ ์๋ค๋ฒํธ์ ํ์์ผ๋ก ๋ถํฐ ๋น๋ฆด ์ ์๋ค.
์ต์ข ์ ์ผ๋ก ์ฒด์ก๋ณต์ ๊ฐ์ ธ์จ ํ์์ ์๋ฅผ ๋ฆฌํดํ๋ ๋ฌธ์
def solution(n, lost, reserve):
answer = 0
reserve_num = set(reserve) - set(lost)
lost_num = set(lost) - set(reserve)
for i in reserve_num:
if i+1 in lost_num:
lost_num.remove(i+1)
elif i-1 in lost_num:
lost_num.remove(i-1)
answer = n - len(lost_num)
return answer
< ํ์ด ๊ณผ์ >
lost, reserve ๋ฐฐ์ด์์ reserve๋ฐฐ์ด์ ์ํ๋ฉด์ lost๋ฐฐ์ด์๋ ์ํ๋ ๊ฒฝ์ฐ๊ฐ ์๋ค๊ณ ๋ฌธ์ ์์ ์ฃผ์ด์ก๋ค. ์ด๋ ํด๋น ํ์์ ํ์ธ์๊ฒ ์ฒด์ก๋ณต์ ๋น๋ ค์ค ์ ์๋ค.
์ด ์กฐ๊ฑด์ ๋ง์กฑ์์ผ์ฃผ๊ธฐ ์ํด set ์๋ฃ๊ตฌ์กฐ๋ก ์ค๋ณต์ ์ ๊ฑฐํ ๊ฐ๋ค์ reserve_num, lost_num์ผ๋ก ์ ์ฅํ๊ณ for๋ฌธ์ผ๋ก reserve_num์ ํ์ํด ์๋ค๋ฒํธ๊ฐ lost์ ์๋ค๋ฉด ์ ๊ฑฐํ๋ ๋ฐฉ์์ผ๋ก ๊ตฌํํ๋ค.
์กฐ์ด์คํฑ์ผ๋ก ์ํ๋ฒณ ์ด๋ฆ์ ์์ฑํ๋ ๋ฌธ์ , ๋งจ ์ฒ์์ A๋ง ์ฃผ์ด์ง๋ค.
- ์๋ฐฉํฅ : ๋ค์ ์ํ๋ฒณ
- ์๋ซ๋ฐฉํฅ : ์ด์ ์ํ๋ฒณ
- ์ผ์ชฝ๋ฐฉํฅ : ์ผ์ชฝ์ผ๋ก ์ด๋ (์ฒซ๋ฒ์งธ ๋ฌธ์ > ๋ง์ง๋ง ๋ฌธ์๋ก ์ด๋)
- ์ค๋ฅธ์ชฝ ๋ฐฉํฅ : ์ค๋ฅธ์ชฝ์ผ๋ก ์ด๋ (๋ง์ง๋ง๋ฌธ์ > ์ฒซ๋ฒ์งธ ๋ฌธ์๋ก ์ด๋)
def solution(name):
answer = 0
์ต์ ์ข์ฐ ์ด๋ ํ์ ์ ์ฅ
min_move = len(name) - 1
for i, char in enumerate(name):
# ์ํ๋ฒณ ์ํ์ด๋ํ์ ์ต์๊ฐ ์ถ๊ฐ
answer += min(ord(char) - ord('A'), ord('Z') - ord(char) + 1)
# ์ฐ์๋ A ์ธ๋ฑ์ค ์ฐพ๊ธฐ
next = i + 1
while next < len(name) and name[next] == 'A':
next += 1
# ์ต์ ์ข์ฐ ์ด๋ํ์, ์ฐ์๋ A์ ์ผ์ชฝ, ์ค๋ฅธ์ชฝ ๋น๊ตํด ์ต์๊ฐ ๊ฐฑ์
min_move = min([min_move, 2*i+len(name)-next, i+2*(len(name)-next)])
answer += min_move
return answer
< ํ์ด ๊ณผ์ >
์ฃผ์ด์ง name์ ์ด๊ธฐ ์ํ๋ ์๋ฆฌ์๋ ๋์ผํ๋ A๋ก ์ฑ์์ง ๋ฐฐ์ด์์ ์ ์ ์๋ค. ex) JAZ > AAA๋ก ์์ํ๋ฏ๋ก ์ฐ์๋ A๋ ์ฐพ์ ํ์๊ฐ ์๋ค.
๋ฐ๋ผ์ ์ด๋ฅผ ํ์ฉํ์ฌ ์ํ ๋ฐฉํฅ, ํน์ ์ข์ฐ ๋ฐฉํฅ์ผ๋ก ๊ตฌ๋ถํ์ฌ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ์๋ค.
์ฃผ์ด์ง ์ซ์์์ K๊ฐ์ ์๋ฅผ ์ ๊ฑฐํด ๊ฐ์ฅ ํฐ ์๋ฅผ ๋ง๋๋ ๋ฌธ์
def solution(number, k):
answer = []
for num in number:
if not answer:
answer.append(num)
continue
if k > 0:
while answer[-1] < num:
answer.pop()
k -= 1
if not answer or k <= 0:
break
answer.append(num)
if k > 0:
answer = answer[:-k]
else:
answer
return ''.join(answer)
### ๊ฐ๋จ ๊ตฌํ
def solution(number, k):
answer = []
for num in number:
while answer and k > 0 and answer[-1] < num:
answer.pop()
k -= 1
answer.append(num)
return ''.join(answer[:len(answer)-k])
< ํ์ด ๊ณผ์ >
์ฃผ์ด์ง ๋ฌธ์ ๋ฐฐ์ด number์์ ์ ์์๋๋ก answer์ ๋ฃ์ด์ ๋ค์ ์ซ์์ ๋น๊ตํด ๋ค์ ์ซ์๊ฐ ๋ ํฌ๋ฉด, answer.pop ํ k - 1์ ํด ์์ ์๋ฅผ ์ ๊ฑฐํด์ค๋ค.
๋ฐ๋ณต๋ฌธ ์ดํ k๊ฐ 0๋ณด๋ค ํฐ ๊ฒฝ์ฐ๊ฐ ์์ ์ ์๊ธฐ์, answer[:-k]๋ก ํํํด์ฃผ๊ณ , ์๋ ๊ฒฝ์ฐ์ ๊ทธ๋ฅ answer๋ฅผ ๋ฆฌํดํ๋ค. ์ต์ข
์ ์ผ๋ก ๋ฆฌ์คํธ ๋ด ์์๋ง ๋ฆฌํดํด์ฃผ๋ฉด ๋๋ ๋ฌธ์ .
๊ตฌ๋ช ๋ณดํธ๋ ์ต๋ 2์ธ์น์ด๊ณ , ์ฌ๋๋ค ๊ฐ๊ฐ์ธ์ ๋ชธ๋ฌด๊ฒ์ ํ์น ์ ํ ๋ฌด๊ฒ๊ฐ ์ฃผ์ด์ง ๋ ํ์ํ ๊ตฌ๋ช ๋ณดํธ ๊ฐ์๋ฅผ ๋ฆฌํดํ๋ ๋ฌธ์ .
def solution(people, limit):
answer = 0
people.sort()
light = 0
heavy = len(people) - 1
while light <= heavy:
if people[light] + people[heavy] <= limit:
light += 1
heavy -= 1
else:
heavy -= 1
answer += 1
return answer
< ํ์ด ๊ณผ์ >
์ฃผ์ด์ง people ๋ฐฐ์ด์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํด ๊ฐ๋ฒผ์ด ์์๋ถํฐ ๋์ดํ ํ ๊ฐ๋ฒผ์ด ์ฌ๋๊ณผ ๋ฌด๊ฑฐ์ด ์ฌ๋์ ๋ํด ๋ฌด๊ฒ ์ ํ ๋ณด๋ค ๋ฎ๋ค๋ฉด ์ธ๋ฑ์ค๋ฅผ ์ฌ๋ ค๊ฐ๋ฉฐ ๋ฐ๋ณต์ ์งํํ๋ค. ๋ง์ผ ๋ฌด๊ฒ ์ ํ๋ณด๋ค ๋ฌด๊ฑฐ์ด ๊ฒฝ์ฐ, heavy๋ง ํ์๋ณด๋ธ๋ค. ์ด๋ฌํ ๋ฐ๋ณต์ด ์์ ๋๋ง๋ค answer + 1 ์ฒ๋ฆฌ๋ฅผ ํด ๋ฆฌํดํ๋ค.
n๊ฐ์ ์ฌ ์ฌ์ด์ ๋ค๋ฆฌ๋ฅผ ๊ฑด์คํ๋ costs๊ฐ ์ฃผ์ด์ง๋ ์ต์ ๋น์ฉ์ผ๋ก ๋ชจ๋ ์ฌ์ด ์๋ก ํตํ ๊ฐ๋ฅํ๋๋ก ๋ง๋๋ ์ต์ ๋น์ฉ์ ๊ตฌํ๋ ๋ฌธ์ .
costs ๋ฐฐ์ด์ [i, j, c] i>j๋ก ์ด๋ํ๋๋ฐ ๋๋ ๋น์ฉc๋งํผ ๋๋ ๊ฒ์ ์๋ฏธํ๋ค.
def find(parent, x):
if parent[x] != x:
return find(parent, parent[x])
else:
return x
def union(parent, rank, x, y):
x_root = find(parent, x)
y_root = find(parent, y)
if rank[x_root] < rank[y_root]:
parent[x_root] = y_root
else:
parent[y_root] = x_root
if rank[x_root] == rank[y_root]:
rank[x_root] += 1
def solution(n, costs):
answer = 0
costs.sort(key = lambda x: x[2])
# ๋
ธ๋ ๋ฒํธ, ๊ฐ ๋
ธ๋์ rank๊ฐ ์์ฑ
parent = [i for i in range(n)]
rank = [0 for _ in range(n)]
for cost in costs:
# ์ฌ๊ณผ ์ฌ๋ผ๋ฆฌ ์ฐ๊ฒฐ์ด ์๋์ด์๋ ๊ฒฝ์ฐ
if find(parent, cost[0]) != find(parent, cost[1]):
# ํฉ์น๊ธฐ
union(parent, rank, cost[0], cost[1])
answer += cost[2]
# ๋ชจ๋ ๋
ธ๋ ์ฐ๊ฒฐ ์ ์ข
๋ฃ
if len(set(parent)) == 1:
break
return answer
< ํ์ด ๊ณผ์ >
union-find, union-by rank ๊ธฐ๋ฒ์ผ๋ก ํฌ๋ฃจ์ค์นผ ์๊ณ ๋ฆฌ์ฆ์ ํ์ดํ์๋ค.
find ํจ์๋ก ๋ถ๋ชจ๋
ธ๋๋ฅผ ์ฐพ๊ณ , union ํจ์๋ก ๋ ๋ฃจํธ๋
ธ๋์ rank๊ฐ์ ๋น๊ตํด rank๊ฐ์ด ๋ ๋์ ์ชฝ์ด ๋ถ๋ชจ๋
ธ๋๋ฅผ ๊ฐ๋ ์์ผ๋ก ์ฒ๋ฆฌํ์๋ค.
์ดํ, solutionํจ์๋ก parent, rank๋ฅผ ๋ง๋ค์ด costs๋ฅผ for๋ฌธ์ ๋์ ๋ชจ๋ ๋
ธ๋๊ฐ ์ฐ๊ฒฐ๋๋๋ก ๊ฐ์ ์ ์ฐ๊ฒฐํด์ค๋ค. ์์ costs๋ฅผ ๋น์ฉ์ด ์์ ์์๋๋ก ์ ๋ ฌ ์์ผ์ฃผ๋ ๊ฒ์ด ํต์ฌ์ด๋ค.
์ฐจ๋ ๋ณ ๊ณ ์๋๋ก ์ง์ ์์ , ๊ณ ์๋๋ก ํ์ถ ์์ ์ด ์ฃผ์ด์ง๊ณ , ๋ชจ๋ ์ฐจ๋์ด ํ ๋ฒ์ ๋จ์์ฉ ์นด๋ฉ๋ผ๋ฅผ ๋ง๋๋๋ก ํ๊ธฐ ์ํด ์ต๋ ๋ช ๋์ ์นด๋ฉ๋ผ๋ฅผ ์ค์นํด์ผ ํ๋์ง๋ฅผ ๊ตฌํ๋ ๋ฌธ์
def solution(routes):
answer = 0
routes.sort(key = lambda x: x[1])
camera = -30001
for route in routes:
if camera < route[0]:
answer += 1
camera = route[1]
return answer
< ํ์ด ๊ณผ์ >
์ฃผ์ด์ง routes์์ route๋ฅผ ๊ณ ์๋๋ก ๋๊ฐ๋ ์ง์ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌํ๋ค.
camera ์์ ์ง์ ์ ๋ฒ์๊ฐ [-30000,30000]์ด๋ฏ๋ก -30001๋ก ์์์ ํ๊ณ camera๊ฐ route[0]๋ณด๋ค ์๋ค๋ฉด route[1]๋ก ๊ณ ์๋๋ก ๋๊ฐ๋ ์ง์ ์ผ๋ก ์นด๋ฉ๋ผ๋ฅผ ๋ณ๊ฒฝํ๋ค.