๐ ๊ฐ์๋ ธํธ ๐
๊ณฑ์งํฉ (Cartesian product) ๊ตฌํ๊ธฐ
๋ณดํต ๊ณฑ์งํฉ์ ๊ตฌํ ๋ ๋ฐ๋ณต๋ฌธ์ ์ด์ฉํด ๋ iterable์ ์์๋ฅผ ํ๋์ฉ ๊ณฑํด๊ฐ๋ค. ํ์ด์ฌ์์๋ itertools.product๋ฅผ ์ด์ฉํ๋ฉด, for๋ฌธ์ ์ฌ์ฉํ์ง ์๊ณ ๋ ๊ณฑ์งํฉ์ ๊ตฌํ ์ ์๋ค.
import itertools
iterable1 ='ABCD'
iterable2 = 'xy'
print(list(itertools.product(iterable1, iterable2)))
โ ๋ฌธ์ 1 2์ฐจ์ ๋ฆฌ์คํธ๋ฅผ 1์ฐจ์ ๋ฆฌ์คํธ๋ก ๋ง๋ค๊ธฐ
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
๋ฌธ์์ด์ ๋ด์ ์ด์ฐจ์ ๋ฆฌ์คํธ, mylist ๊ฐ solution ํจ์์ ํ๋ผ๋ฏธํฐ๋ก ์ฃผ์ด์ง๋๋ค. solution ํจ์๊ฐ mylist๋ฅผ ์ผ์ฐจ์ ๋ฆฌ์คํธ๋ก ๋ง๋ค์ด ๋ฆฌํดํ๋๋ก ์ฝ๋๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ ์กฐ๊ฑด
- arr์ ๊ธธ์ด๋ 1 ์ด์ 100 ์ดํ์ธ ์์ฐ์์ ๋๋ค.
- arr ์์์ ๊ธธ์ด๋ 5๋ฅผ ๋์ง ์์ต๋๋ค.
์ ์ถ๋ ฅ ์

โ Solution
def solution(mylist):
answer = []
for i in mylist:
for j in i:
answer.append(j)
return answer
์ด ๋ฐฉ๋ฒ ๋ง๊ณ ๋ 2์ฐจ์์์ 1์ฐจ์์ผ๋ก ๋ง๋๋ ค๋ฉด 1์ฐจ์ ๋ฆฌ์คํธ์ ๋ํด์ฃผ๋ฉด ๋๋ ๊ฒ๋ ์๋ค.
โ Feedback โ
๋ณดํต์ ๋ฐ๋ณต๋ฌธ์ ์ด์ฉํด 2์ฐจ์์ 1์ฐจ์์ผ๋ก ๋ง๋ ๋ค. ํ์ด์ฌ์์๋ for๋ฌธ์ ์ด์ฉํ์ง ์๊ณ ๋ฆฌ์คํธ๋ฅผ ์ด์ด ๋ถ์ผ ์ ์๋ค.
my_list = [[1, 2], [3, 4], [5, 6]]
# ๋ฐฉ๋ฒ 1 - sum ํจ์
answer = sum(my_list, [])
# ๋ฐฉ๋ฒ 2 - itertools.chain
import itertools
list(itertools.chain.from_iterable(my_list))
# ๋ฐฉ๋ฒ 3 - itertools์ unpacking
import itertools
list(itertools.chain(*my_list))
# ๋ฐฉ๋ฒ 4 - list comprehension ์ด์ฉ
[element for array in my_list for element in array]
# ๋ฐฉ๋ฒ 5 - reduce ํจ์ ์ด์ฉ 1
from functools import reduce
list(reduce(lambda x, y: x+y, my_list))
# ๋ฐฉ๋ฒ 6 - reduce ํจ์ ์ด์ฉ 2
from functools import reduce
import operator
list(reduce(operator.add, my_list))
์ ํ์ ์ผ๋ก ์ฌ์ฉ ๊ฐ๋ฅํ ๋ฐฉ๋ฒ๋ ์๋ค. ๊ฐ ์์์ ๊ธธ์ด๊ฐ ๋์ผํ ๊ฒฝ์ฐ์ ์ฌ์ฉ ๊ฐ๋ฅํ๋ค.
# ๋ฐฉ๋ฒ 7 - numpy ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ flatten ์ด์ฉ
import numpy as np
np.array(my_list).flatten().tolist()
โ ๋ฌธ์ 2 ์์ด๊ณผ ์กฐํฉ
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
์ซ์๋ฅผ ๋ด์ ์ผ์ฐจ์ ๋ฆฌ์คํธ, mylist์ ๋ํด mylist์ ์์๋ก ์ด๋ฃจ์ด์ง ๋ชจ๋ ์์ด์ ์ฌ์ ์์ผ๋ก ๋ฆฌํดํ๋ ํจ์ solution์ ์์ฑํด์ฃผ์ธ์.
์ ํ ์กฐ๊ฑด
- mylist ์ ๊ธธ์ด๋ 1 ์ด์ 100 ์ดํ์ธ ์์ฐ์์ ๋๋ค.
์ ์ถ๋ ฅ ์์

โ Solution
from itertools import *
def solution(mylist):
return sorted(list(permutations(mylist, len(mylist))))
- permutaions : ์์ด์ ๋ง๋๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ด๋ค. ์์๋ฅผ ๊ณ ๋ คํ์ฌ ์ค๋ณต์์ด ๋ฝ์ ์ ์๋ค.
- combinations : ์กฐํฉ์ ๋ง๋๋ ๋ผ์ด๋ธ๋ฌ์ด๋ค. ์์๋ฅผ ๊ณ ๋ คํ์ง ์๊ณ ์ค๋ณต์์ด ๋ฝ์ ์ ์๋ค.
์์๋ฅผ ๊ณ ๋ คํ๋ค๋ ๊ฒ์ AB์ BA๋ ๋ค๋ฅธ ๊ฑฐ๋ผ๊ณ ์ทจ๊ธํ๋ ๊ฒ์ด๋ค. ๊ทธ๋ ๋ค๋ฉด ์์๋ฅผ ๊ณ ๋ คํ๋ ๊ฒ์ AB์ BA๋ ๊ฐ์ ๊ฑฐ๋ผ๊ณ ์ทจ๊ธํ๋ค๋ ๊ฒ์ด๋ค.
โ ๋ฌธ์ 3 ๊ฐ์ฅ ๋ง์ด ๋ฑ์ฅํ๋ ์ํ๋ฒณ ์ฐพ๊ธฐ
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
์ด ๋ฌธ์ ์๋ ํ์ค ์ ๋ ฅ์ผ๋ก ๋ฌธ์์ด, mystr์ด ์ฃผ์ด์ง๋๋ค. mystr์์ ๊ฐ์ฅ ๋ง์ด ๋ฑ์ฅํ๋ ์ํ๋ฒณ๋ง์ ์ฌ์ ์์ผ๋ก ์ถ๋ ฅํ๋ ์ฝ๋๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ ์กฐ๊ฑด
- mystr์ ์์๋ ์ํ๋ฒณ ์๋ฌธ์๋ก๋ง ์ฃผ์ด์ง๋๋ค.
- mystr์ ๊ธธ์ด๋ 1 ์ด์ 100 ์ดํ์ ๋๋ค.
์ ์ถ๋ ฅ ์์

โ Solution
from collections import Counter
my_str = list(map(str, input().strip()))
count = Counter(my_str)
max = 0
ans = []
for key, value in count.items():
if max <= value:
max = value
ans.append(key)
print(''.join(sorted(ans)))
์์ ๋ ํต๊ณผํ์ผ๋ ๋ค๋ฅธ ํ ์คํธ ์ผ์ด์ค์์ ํต๊ณผํ์ง ๋ชปํ๋ค. Counter์ ์ฌ์ฉํ๋๋ฐ ์์ผ๊น?
ccddd๋ฅผ ์ ๋ ฅํ์ ๋ ์ฌ๋ฐ๋ฅธ ์ถ๋ ฅ๊ฐ์ d์ด๋ค. ๊ทธ๋ฌ๋ ์์ ์ฝ๋๋ cd๋ฅผ ์ถ๋ ฅํ๋ค.
max๊ฐ ์ฒ์์ 0์ด์์ผ๋ c์ ๊ฐ์๊ฐ ์ต๋๊ฐ์ด ๋์ด์ c๋ ์ถ๋ ฅ๋๋ ๊ฒ์ด๋ค. ์ด ๋ฐ๋ก๋ฅผ ๊ฐ์ง๊ณ ๋ค์ ํ์ด์ ํด๊ฒฐํ๋ค.
from collections import Counter
my_str = sorted(list(map(str, input().strip()))) #๋ฌธ์๋ฅผ ๋ถ๋ฆฌํ๊ณ ์ฌ์ ์์ผ๋ก ์ ๋ ฌ
m = max(Counter(my_str).values()) #์ต๋๊ฐ
for key, value in Counter(my_str).items():
if m <= value:
print(key, end = '')
- Counter.keys() : ํค ๊ฐ์ ๋ฐํํ๋ค. { 'c' : 2, 'd' : 3 } ์์ c์ d๋ฅผ ๋ฐํํ๋ค.
- Counter.values() : values๊ฐ์ ๋ฐํํ๋ค. { 'c' : 2, 'd' : 3 } ์์ 2์ 3์ ๋ฐํํ๋ค.
- Counter.items() : key์ value ๊ฐ์ ๋ฐํํ๋ค.