๐ก ์กฐ๊ฑด ๋ฐ ํ์ด
orders
๋ฐฐ์ด์ ํฌ๊ธฐ๋ 2 ์ด์ 20 ์ดํ.
orders
๋ฐฐ์ด์ ๊ฐ ์์๋ ํฌ๊ธฐ๊ฐ 2 ์ด์ 10 ์ดํ์ธ ๋ฌธ์์ด.
๊ฐ ๋ฌธ์์ด์ ์ํ๋ฒณ ๋๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ผ๋ฉฐ ์ค๋ณต์ ํ์ฉ ์ํจ.
course
๋ฐฐ์ด์ ํฌ๊ธฐ๋ 1 ์ด์ 10 ์ดํ.
course
๋ฐฐ์ด์ ๊ฐ ์์๋ 2 ์ด์ 10 ์ดํ์ธ ์์ฐ์๊ฐ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ
- ์ ๋ต์ ๊ฐ ์ฝ์ค์๋ฆฌ ๋ฉ๋ด์ ๊ตฌ์ฑ์ ๋ฌธ์์ด ํ์์ผ๋ก ๋ฐฐ์ด์ ๋ด์ ์ฌ์ ์์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌํด์ return
๋ฐฐ์ด์ ๊ฐ ์์์ ์ ์ฅ๋ ๋ฌธ์์ด ๋ํ ์ํ๋ฒณ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ
๋ง์ฝ ๊ฐ์ฅ ๋ง์ด ํจ๊ป ์ฃผ๋ฌธ๋ ๋ฉ๋ด ๊ตฌ์ฑ์ด ์ฌ๋ฌ ๊ฐ๋ผ๋ฉด, ๋ชจ๋ ๋ฐฐ์ด์ ๋ด์ return
๋ฌด์กฐ๊ฑด return ํ๋ ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ 1 ์ด์
- Python ์กฐํฉ
(combinations)
๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํด ๊ตฌํ
dict๋ฅผ ์ฌ์ฉํด๋ ๋๋ ๋ฌธ์ .
์ ๋ ฌ์ด ์ค์ํ ๋ฌธ์ .
- ๊ฐ ์๋์ ๋จํ๋ฉ๋ด๋ฅผ 2๊ฐ ์ด์ ์ฃผ๋ฌธํด์ผ ํ๋ค.
- ์ต์ 2๋ช
์ด์์ ์๋์ผ๋ก๋ถํฐ ์ฃผ๋ฌธ๋ ๋จํ๋ฉ๋ด ์กฐํฉ์ ๋ํด์๋ง ์ฝ์ค์๋ฆฌ ๋ฉ๋ด ํ๋ณด์ ํฌํจ
๐ฅ ์์ค ์ฝ๋
from itertools import combinations
def solution(orders, course):
answer = []
score = {}
n = len(orders)
for i in range(n):
data = sorted(list(orders[i]))
for j in course:
for k in list(set(combinations(data, j))):
t = ''.join(k)
if t in score:
score[t] += 1
else:
score[t] = 1
new_score = []
for menu, num in score.items():
if num > 1:
new_score.append((menu, num))
new_score.sort(key=lambda x: -x[1])
for i in course:
max_order = 0
for c, num in new_score:
if len(c) == i:
if max_order <= num:
max_order = num
answer.append(c)
else:
break
answer.sort()
return answer
๐ ์์ ๋ฐ ์คํ๊ฒฐ๊ณผ
์์
print(solution(["ABCFG", "AC", "CDE", "ACDE", "BCFG", "ACDEH"], [2, 3, 4]))
์คํ๊ฒฐ๊ณผ
["AC", "ACDE", "BCFG", "CDE"]
โจ๏ธ ๋ฌธ์ ํ์ด
- ์ฃผ๋ฌธ์ ๋ฐ์
orders
๋ฐฐ์ด์ ์์ฐจ์ ์ผ๋ก ์ํํ ๋ฐ๋ณต๋ฌธ.
- ์ํํ๋ฉฐ ๋ฉ๋ด๋ค์ ๋ฆฌ์คํธ๋ก ๋ง๋ค์ด ์ ๋ ฌ.
- ์ฝ์ค๋ฅผ ๋ง๋ค ๋ฉ๋ด ๊ฐ์๋ฅผ ์ํํ ๋ฐ๋ณต๋ฌธ. << ์ฌ๊ธฐ๊น์ง 2์ค ๋ฐ๋ณต๋ฌธ.
j
์กฐํฉ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
๋ฅผ ์ฌ์ฉํด 3๋ฒ ๋ฐ๋ณต๋ฌธ์์ ๋์ค๋ ์ฝ์ค์ ๋ฉ๋ด๊ฐ์๋งํผ ๋ฉ๋ด๋ฅผ ๋ฝ์์
์ค๋ณต์ ์์ค ๋ค t๋ฌธ์์ด์ ์ ์ฅ. (t๋ j ๊ฐ๋ฅผ ๋ฝ์ ๋ง๋ ๋ฉ๋ด์ ์กฐํฉ์
๋๋ค.)list(set(combinations(data, j)))
# set()์ ์ค๋ณต์ ์์ ์ค๋๋ค!
t
๊ฐ ์ ์ํ์ ์์ผ๋ฉด ์๋ก ๋ฑ๋ก์์ผ 1์ ๋ถ์ฌ
t
๊ฐ ์ ์ํ์ ์์ผ๋ฉด 1์ ๋ถ์ฌ
- ์ต์ 2๋ช
์ด์์ ์๋์ผ๋ก๋ถํฐ ์ฃผ๋ฌธ๋ ๋จํ๋ฉ๋ด ์กฐํฉ ๋ง ํด๋นํ๊ธฐ ๋๋ฌธ์
score
์ ์ ์ฅ๋ ์ ์๊ฐ 1์ ์ด์์ด๋ผ๋ฉด new_score
์ (๋ฉ๋ด, ์ ์)
ํ์์ผ๋ก ์ ์ฅ ํ ์ ์๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌ"""
# lambda ์ค๋ช
x ๋ฅผ x[1] ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ ๊ฑด๋ฐ, -๊ฐ ๋ถ์ผ๋ฉด ์ญ์์
๋๋ค.
"""
new_score.sort(key=lambda x: -x[1])
- ๋ง์ง๋ง์ผ๋ก ์ฝ์ค์๋ฆฌ๋ฅผ ๊ตฌ์ฑํ ๋ฉ๋ด ๊ฐ์๋ฅผ ์ํํ๋ฉด์
new_score
์ ๋ฃ์ ์ฝ์ค๋ฉ๋ด ํ๋ณด๋ค์ ๊ฒ์ฌํ๋ฉด์
์ ๋ต์ผ๋ก ๋ฐํํ ๋ฐฐ์ด answer
์ ๋ฃ์ด์ฃผ๊ณ , ์ ๋ ฌ์ ํ ๋ค ๋ฐํ ์์ผ์ค๋ค.
๐พ ๋๋์
- ์ ๋ ฌ์ ํ ๋
lambda
๋ฅผ ๋ง์ด ์ฌ์ฉํ๊ฒ ๋์์ด ๋์๋ค.
combinations
๋ฅผ ์ฌ์ฉํด์ ๋ฒ๊ฑฐ๋ก์ด ์ผ์ด ์ ์ด์ ์ข์๋ค.
์ด๋ฐ ๊ฐํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์๊ณ ์๋ค๋ ๊ฒ๋ณด๋ค ์ฌ์ฉํ ๋๋ฅผ ์๊ณ ์๋ค๋๊ฒ ๊ธฐ๋ถ ์ข์๋ค.
- ์นด์นด์ค ๊ธฐ์ถ๋ฌธ์ ๋ ๋ฌธ์ ๋ ๊ธธ๊ณ ์กฐ๊ฑด๋ ์์ธํ๊ฒ ์จ์๋๋ฐ ๋์ ์ ์๋ค์ด์จ๋ค.
์์ง ๋ฌธ์ ์์ถ๋ฅ๋ ฅ์ด ๋ถ์กฑํ ๊ฒ ๊ฐ๋ค.