์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | ||||||
2 | 3 | 4 | 5 | 6 | 7 | 8 |
9 | 10 | 11 | 12 | 13 | 14 | 15 |
16 | 17 | 18 | 19 | 20 | 21 | 22 |
23 | 24 | 25 | 26 | 27 | 28 |
- LDA
- ์ค๋ฒ์ํ๋ง
- ๋ ๋ฆฝํ๋ณธ
- ๋น ๋ฐ์ดํฐ๋ถ์๊ธฐ์ฌ
- ๋ฐ์ดํฐ๋ถ๊ท ํ
- pandas
- opencv
- DBSCAN
- ์๋ํด๋ผ์ฐ๋
- ์ฃผ์ฑ๋ถ๋ถ์
- Python
- t-test
- iloc
- ADsP
- ํ์ด์ฌ
- ๋ฐ์ดํฐ๋ถ์์ ๋ฌธ๊ฐ
- datascience
- ๋น ๋ฐ์ดํฐ
- ๋์ํ๋ณธ
- ๋ฐ์ดํฐ๋ถ์์ค์ ๋ฌธ๊ฐ
- ํฌ๋กค๋ง
- ํ ์คํธ๋ถ์
- ๊ตฐ์งํ
- dataframe
- ๋ฐ์ดํฐ๋ถ์
- ์ธ๋์ํ๋ง
- PCA
- ADP
- numpy
- Lambda
Data Science LAB
[Python] ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ฉํ ์คํธ ์ฐ์ต level2 (๋ฉ๋ด ๋ฆฌ๋ด์ผ) ๋ณธ๋ฌธ
[Python] ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ฉํ ์คํธ ์ฐ์ต level2 (๋ฉ๋ด ๋ฆฌ๋ด์ผ)
ใ ใ ใ ใ 2022. 11. 6. 22:401. ๋ฌธ์ ์ค๋ช
๋ ์คํ ๋์ ์ด์ํ๋ ์ค์นดํผ๋ ์ฝ๋ก๋19๋ก ์ธํ ๋ถ๊ฒฝ๊ธฐ๋ฅผ ๊ทน๋ณตํ๊ณ ์ ๋ฉ๋ด๋ฅผ ์๋ก ๊ตฌ์ฑํ๋ ค๊ณ ๊ณ ๋ฏผํ๊ณ ์์ต๋๋ค.
๊ธฐ์กด์๋ ๋จํ์ผ๋ก๋ง ์ ๊ณตํ๋ ๋ฉ๋ด๋ฅผ ์กฐํฉํด์ ์ฝ์ค์๋ฆฌ ํํ๋ก ์ฌ๊ตฌ์ฑํด์ ์๋ก์ด ๋ฉ๋ด๋ฅผ ์ ๊ณตํ๊ธฐ๋ก ๊ฒฐ์ ํ์ต๋๋ค. ์ด๋ค ๋จํ๋ฉ๋ด๋ค์ ์กฐํฉํด์ ์ฝ์ค์๋ฆฌ ๋ฉ๋ด๋ก ๊ตฌ์ฑํ๋ฉด ์ข์ ์ง ๊ณ ๋ฏผํ๋ "์ค์นดํผ"๋ ์ด์ ์ ๊ฐ ์๋๋ค์ด ์ฃผ๋ฌธํ ๋ ๊ฐ์ฅ ๋ง์ด ํจ๊ป ์ฃผ๋ฌธํ ๋จํ๋ฉ๋ด๋ค์ ์ฝ์ค์๋ฆฌ ๋ฉ๋ด๋ก ๊ตฌ์ฑํ๊ธฐ๋ก ํ์ต๋๋ค.
๋จ, ์ฝ์ค์๋ฆฌ ๋ฉ๋ด๋ ์ต์ 2๊ฐ์ง ์ด์์ ๋จํ๋ฉ๋ด๋ก ๊ตฌ์ฑํ๋ ค๊ณ ํฉ๋๋ค. ๋ํ, ์ต์ 2๋ช
์ด์์ ์๋์ผ๋ก๋ถํฐ ์ฃผ๋ฌธ๋ ๋จํ๋ฉ๋ด ์กฐํฉ์ ๋ํด์๋ง ์ฝ์ค์๋ฆฌ ๋ฉ๋ด ํ๋ณด์ ํฌํจํ๊ธฐ๋ก ํ์ต๋๋ค.
์๋ฅผ ๋ค์ด, ์๋ 6๋ช
์ด ์ฃผ๋ฌธํ ๋จํ๋ฉ๋ด๋ค์ ์กฐํฉ์ด ๋ค์๊ณผ ๊ฐ๋ค๋ฉด,
(๊ฐ ์๋์ ๋จํ๋ฉ๋ด๋ฅผ 2๊ฐ ์ด์ ์ฃผ๋ฌธํด์ผ ํ๋ฉฐ, ๊ฐ ๋จํ๋ฉ๋ด๋ A ~ Z์ ์ํ๋ฒณ ๋๋ฌธ์๋ก ํ๊ธฐํฉ๋๋ค.)
2. ์ ํ ์ฌํญ
- orders ๋ฐฐ์ด์ ํฌ๊ธฐ๋ 2 ์ด์ 20 ์ดํ์ ๋๋ค.
- orders ๋ฐฐ์ด์ ๊ฐ ์์๋ ํฌ๊ธฐ๊ฐ 2 ์ด์ 10 ์ดํ์ธ ๋ฌธ์์ด์
๋๋ค.
- ๊ฐ ๋ฌธ์์ด์ ์ํ๋ฒณ ๋๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
- ๊ฐ ๋ฌธ์์ด์๋ ๊ฐ์ ์ํ๋ฒณ์ด ์ค๋ณตํด์ ๋ค์ด์์ง ์์ต๋๋ค.
- course ๋ฐฐ์ด์ ํฌ๊ธฐ๋ 1 ์ด์ 10 ์ดํ์
๋๋ค.
- course ๋ฐฐ์ด์ ๊ฐ ์์๋ 2 ์ด์ 10 ์ดํ์ธ ์์ฐ์๊ฐ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋์ด ์์ต๋๋ค.
- course ๋ฐฐ์ด์๋ ๊ฐ์ ๊ฐ์ด ์ค๋ณตํด์ ๋ค์ด์์ง ์์ต๋๋ค.
- ์ ๋ต์ ๊ฐ ์ฝ์ค์๋ฆฌ ๋ฉ๋ด์ ๊ตฌ์ฑ์ ๋ฌธ์์ด ํ์์ผ๋ก ๋ฐฐ์ด์ ๋ด์ ์ฌ์ ์์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌํด์ return ํด์ฃผ์ธ์.
- ๋ฐฐ์ด์ ๊ฐ ์์์ ์ ์ฅ๋ ๋ฌธ์์ด ๋ํ ์ํ๋ฒณ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋์ด์ผ ํฉ๋๋ค.
- ๋ง์ฝ ๊ฐ์ฅ ๋ง์ด ํจ๊ป ์ฃผ๋ฌธ๋ ๋ฉ๋ด ๊ตฌ์ฑ์ด ์ฌ๋ฌ ๊ฐ๋ผ๋ฉด, ๋ชจ๋ ๋ฐฐ์ด์ ๋ด์ return ํ๋ฉด ๋ฉ๋๋ค.
- orders์ course ๋งค๊ฐ๋ณ์๋ return ํ๋ ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ 1 ์ด์์ด ๋๋๋ก ์ฃผ์ด์ง๋๋ค.
3. ๋ด ํ์ด
from itertools import combinations
from collections import Counter
def solution(orders, course):
answer = []
orders = [sorted(x) for x in orders]
for i in course:
order = []
count = Counter()
for x in orders:
order.append(list(combinations(x,i)))
count = Counter(sum(order,[]))
answer.append([''.join(k) for k,v in count.items() if max(count.values()) == v and max(count.values()) >=2])
return sorted(sum(answer,[]))
1. order list์ ๋ฌธ์์ด์ ์ํ๋ฒณ ์์ผ๋ก ์ ๋ ฌ (Count()ํจ์์์ ์ํ๋ฒณ ์์๊ฐ ๋ค๋ฅด๋ฉด ๋ค๋ฅธ ์์๋ก ์ธ์)
2. ๊ฐ ๊ณ ๊ฐ์ order๋ณ ์กฐํฉ์ list์ ์ถ๊ฐ
3. ์ ์ฒด ๊ณ ๊ฐ์ ์ฃผ๋ฌธ ์กฐํฉ ์ค ๊ฐ์ฅ ๋ง์ ์ฃผ๋ฌธ ์กฐํฉ ์ถ์ถ ํ join() ํจ์๋ฅผ ์ด์ฉํ์ฌ answer์ ์ถ๊ฐ
4. answer ์ ๋ ฌ ํ ๋ฐํ
## ์์ด : ์์ ๊ณ ๋ ค / ์กฐํฉ : ์์ ๊ณ ๋ ค X
4. ๋ค๋ฅธ ์ฌ๋ ํ์ด
import collections
import itertools
def solution(orders, course):
result = []
for course_size in course:
order_combinations = []
for order in orders:
order_combinations += itertools.combinations(sorted(order), course_size)
most_ordered = collections.Counter(order_combinations).most_common()
result += [ k for k, v in most_ordered if v > 1 and v == most_ordered[0][1] ]
return [ ''.join(v) for v in sorted(result) ]
1. ์์ฑํ๊ณ ์ ํ๋ ์ฝ์ค ์๋ฆฌ ์ฃผ๋ฌธ ์ ๋ณ ๊ฐ ์๋์ ์ฃผ๋ฌธ ์กฐํฉ ์ ๋ ฌ ํ ๊ณ์ฐํ์ฌ ๋ฆฌ์คํธ์ ์ถ๊ฐ
2. Counterํจ์์ most_common()ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ์ฅ ๋ง์ด ์ฃผ๋ฌธํ ์กฐํฉ ์ถ์ถ
3. ๊ฐ์ฅ ๋ง์ด ์ฃผ๋ฌธํ ์ซ์ value๊ฐ์ ์ด์ฉํด ํด๋นํ๋ ์ฃผ๋ฌธ ์กฐํฉ(key)๊ฐ์ result ๋ฆฌ์คํธ์ ์ถ๊ฐ
4. ๋ฆฌ์คํธ๋ฅผ joinํ์ฌ ๋ฐํ