์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
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 |
- opencv
- pandas
- ๊ตฐ์งํ
- ํฌ๋กค๋ง
- Lambda
- LDA
- ํ ์คํธ๋ถ์
- ๋น ๋ฐ์ดํฐ๋ถ์๊ธฐ์ฌ
- ํ์ด์ฌ
- t-test
- ์ค๋ฒ์ํ๋ง
- dataframe
- ๋ ๋ฆฝํ๋ณธ
- DBSCAN
- datascience
- ๋ฐ์ดํฐ๋ถ์์ ๋ฌธ๊ฐ
- ๋ฐ์ดํฐ๋ถ๊ท ํ
- ๋ฐ์ดํฐ๋ถ์
- ๋์ํ๋ณธ
- Python
- ADsP
- iloc
- ์ฃผ์ฑ๋ถ๋ถ์
- numpy
- ๋น ๋ฐ์ดํฐ
- ADP
- ๋ฐ์ดํฐ๋ถ์์ค์ ๋ฌธ๊ฐ
- PCA
- ์๋ํด๋ผ์ฐ๋
- ์ธ๋์ํ๋ง
Data Science LAB
[Python] ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ฉํ ์คํธ ์ฐ์ต level2 (๋ด์ค ํด๋ฌ์คํฐ๋ง) ๋ณธ๋ฌธ
[Python] ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ฉํ ์คํธ ์ฐ์ต level2 (๋ด์ค ํด๋ฌ์คํฐ๋ง)
ใ ใ ใ ใ 2022. 11. 2. 16:271. ๋ฌธ์ ์ค๋ช
์ฌ๋ฌ ์ธ๋ก ์ฌ์์ ์์์ง๋ ๋ด์ค, ํนํ ์๋ณด์ฑ ๋ด์ค๋ฅผ ๋ณด๋ฉด ๋น์ท๋น์ทํ ์ ๋ชฉ์ ๊ธฐ์ฌ๊ฐ ๋ง์ ์ ์ ํ์ํ ๊ธฐ์ฌ๋ฅผ ์ฐพ๊ธฐ๊ฐ ์ด๋ ต๋ค. Daum ๋ด์ค์ ๊ฐ๋ฐ ์ ๋ฌด๋ฅผ ๋งก๊ฒ ๋ ์ ์ ์ฌ์ ํ๋ธ๋ ์ฌ์ฉ์๋ค์ด ํธ๋ฆฌํ๊ฒ ๋ค์ํ ๋ด์ค๋ฅผ ์ฐพ์๋ณผ ์ ์๋๋ก ๋ฌธ์ ์ ์ ๊ฐ์ ํ๋ ์ ๋ฌด๋ฅผ ๋งก๊ฒ ๋์๋ค.
๊ฐ๋ฐ์ ๋ฐฉํฅ์ ์ก๊ธฐ ์ํด ํ๋ธ๋ ์ฐ์ ์ต๊ทผ ํ์ ๊ฐ ๋๊ณ ์๋ "์นด์นด์ค ์ ์ ๊ฐ๋ฐ์ ๊ณต์ฑ" ๊ด๋ จ ๊ธฐ์ฌ๋ฅผ ๊ฒ์ํด๋ณด์๋ค.
- ์นด์นด์ค ์ฒซ ๊ณต์ฑ..'๋ธ๋ผ์ธ๋' ๋ฐฉ์ ์ฑ์ฉ
- ์นด์นด์ค, ํฉ๋ณ ํ ์ฒซ ๊ณต์ฑ.. ๋ธ๋ผ์ธ๋ ์ ํ์ผ๋ก ๊ฐ๋ฐ์ ์ฑ์ฉ
- ์นด์นด์ค, ๋ธ๋ผ์ธ๋ ์ ํ์ผ๋ก ์ ์ ๊ฐ๋ฐ์ ๊ณต์ฑ
- ์นด์นด์ค ๊ณต์ฑ, ์ ์ ๊ฐ๋ฐ์ ์ฝ๋ฉ ๋ฅ๋ ฅ๋ง ๋ณธ๋ค
- ์นด์นด์ค, ์ ์ ๊ณต์ฑ.. "์ฝ๋ฉ ์ค๋ ฅ๋ง ๋ณธ๋ค"
- ์นด์นด์ค "์ฝ๋ฉ ๋ฅ๋ ฅ๋ง์ผ๋ก 2018 ์ ์ ๊ฐ๋ฐ์ ๋ฝ๋๋ค"
๊ธฐ์ฌ์ ์ ๋ชฉ์ ๊ธฐ์ค์ผ๋ก "๋ธ๋ผ์ธ๋ ์ ํ"์ ์ฃผ๋ชฉํ๋ ๊ธฐ์ฌ์ "์ฝ๋ฉ ํ ์คํธ"์ ์ฃผ๋ชฉํ๋ ๊ธฐ์ฌ๋ก ๋๋๋ ๊ฑธ ๋ฐ๊ฒฌํ๋ค. ํ๋ธ๋ ์ด๋ค์ ๊ฐ๊ฐ ๋ฌถ์ด์ ๋ณด์ฌ์ฃผ๋ฉด ์นด์นด์ค ๊ณต์ฑ ๊ด๋ จ ๊ธฐ์ฌ๋ฅผ ์ฐพ์๋ณด๋ ์ฌ์ฉ์์๊ฒ ์ ์ฉํ ๋ฏ์ถ์๋ค.
์ ์ฌํ ๊ธฐ์ฌ๋ฅผ ๋ฌถ๋ ๊ธฐ์ค์ ์ ํ๊ธฐ ์ํด์ ๋ ผ๋ฌธ๊ณผ ์๋ฃ๋ฅผ ์กฐ์ฌํ๋ ํ๋ธ๋ "์์นด๋ ์ ์ฌ๋"๋ผ๋ ๋ฐฉ๋ฒ์ ์ฐพ์๋๋ค.
์์นด๋ ์ ์ฌ๋๋ ์งํฉ ๊ฐ์ ์ ์ฌ๋๋ฅผ ๊ฒ์ฌํ๋ ์ฌ๋ฌ ๋ฐฉ๋ฒ ์ค์ ํ๋๋ก ์๋ ค์ ธ ์๋ค. ๋ ์งํฉ A, B ์ฌ์ด์ ์์นด๋ ์ ์ฌ๋ J(A, B)๋ ๋ ์งํฉ์ ๊ต์งํฉ ํฌ๊ธฐ๋ฅผ ๋ ์งํฉ์ ํฉ์งํฉ ํฌ๊ธฐ๋ก ๋๋ ๊ฐ์ผ๋ก ์ ์๋๋ค.
์๋ฅผ ๋ค์ด ์งํฉ A = {1, 2, 3}, ์งํฉ B = {2, 3, 4}๋ผ๊ณ ํ ๋, ๊ต์งํฉ A ∩ B = {2, 3}, ํฉ์งํฉ A ∪ B = {1, 2, 3, 4}์ด ๋๋ฏ๋ก, ์งํฉ A, B ์ฌ์ด์ ์์นด๋ ์ ์ฌ๋ J(A, B) = 2/4 = 0.5๊ฐ ๋๋ค. ์งํฉ A์ ์งํฉ B๊ฐ ๋ชจ๋ ๊ณต์งํฉ์ผ ๊ฒฝ์ฐ์๋ ๋๋์ ์ด ์ ์๋์ง ์์ผ๋ ๋ฐ๋ก J(A, B) = 1๋ก ์ ์ํ๋ค.
์์นด๋ ์ ์ฌ๋๋ ์์์ ์ค๋ณต์ ํ์ฉํ๋ ๋ค์ค์งํฉ์ ๋ํด์ ํ์ฅํ ์ ์๋ค. ๋ค์ค์งํฉ A๋ ์์ "1"์ 3๊ฐ ๊ฐ์ง๊ณ ์๊ณ , ๋ค์ค์งํฉ B๋ ์์ "1"์ 5๊ฐ ๊ฐ์ง๊ณ ์๋ค๊ณ ํ์. ์ด ๋ค์ค์งํฉ์ ๊ต์งํฉ A ∩ B๋ ์์ "1"์ min(3, 5)์ธ 3๊ฐ, ํฉ์งํฉ A ∪ B๋ ์์ "1"์ max(3, 5)์ธ 5๊ฐ ๊ฐ์ง๊ฒ ๋๋ค. ๋ค์ค์งํฉ A = {1, 1, 2, 2, 3}, ๋ค์ค์งํฉ B = {1, 2, 2, 4, 5}๋ผ๊ณ ํ๋ฉด, ๊ต์งํฉ A ∩ B = {1, 2, 2}, ํฉ์งํฉ A ∪ B = {1, 1, 2, 2, 3, 4, 5}๊ฐ ๋๋ฏ๋ก, ์์นด๋ ์ ์ฌ๋ J(A, B) = 3/7, ์ฝ 0.42๊ฐ ๋๋ค.
์ด๋ฅผ ์ด์ฉํ์ฌ ๋ฌธ์์ด ์ฌ์ด์ ์ ์ฌ๋๋ฅผ ๊ณ์ฐํ๋๋ฐ ์ด์ฉํ ์ ์๋ค. ๋ฌธ์์ด "FRANCE"์ "FRENCH"๊ฐ ์ฃผ์ด์ก์ ๋, ์ด๋ฅผ ๋ ๊ธ์์ฉ ๋์ด์ ๋ค์ค์งํฉ์ ๋ง๋ค ์ ์๋ค. ๊ฐ๊ฐ {FR, RA, AN, NC, CE}, {FR, RE, EN, NC, CH}๊ฐ ๋๋ฉฐ, ๊ต์งํฉ์ {FR, NC}, ํฉ์งํฉ์ {FR, RA, AN, NC, CE, RE, EN, CH}๊ฐ ๋๋ฏ๋ก, ๋ ๋ฌธ์์ด ์ฌ์ด์ ์์นด๋ ์ ์ฌ๋ J("FRANCE", "FRENCH") = 2/8 = 0.25๊ฐ ๋๋ค.
2. ๋ด ํ์ด
import re, math
def solution(str1, str2):
str1, str2 = str1.lower(), str2.lower()
list1 = [str1[x:x+2] for x in range(len(str1)-1) if str1[x:x+2].isalpha()]
list2 = [str2[x:x+2] for x in range(len(str2)-1) if str2[x:x+2].isalpha()]
interaction = []
copy1, copy2 = list1.copy(), list2.copy()
if list1 == [] and list2 == []:
answer = 65536
else:
for i in list1:
if i in copy2:
interaction.append(i)
copy1.remove(i)
copy2.remove(i)
union = interaction + copy1 + copy2
answer = math.floor(len(interaction)/len(union)*65536)
return answer
1. ์๋ฌธ์, ๋๋ฌธ์๋ฅผ ๊ตฌ๋ถํ์ง ์์ผ๋ฏ๋ก ๋ ๋ฌธ์์ด์ ๋ชจ๋ ์๋ฌธ์๋ก ๋ณํ
2. for๋ฌธ์ ์ฌ์ฉํ์ฌ 2๊ธ์์ ์์ด๋ก๋ง ์ด๋ฃจ์ด์ง ๊ธ์๋ฅผ ๋ฆฌ์คํธ ํํ๋ก ๋ฐ์์ค (isalpha(): ์์ด๋ฉด True, ์๋๋ฉด False ๋ฐํ)
3. ๋ง์ฝ ๋ ๋ฆฌ์คํธ ๋ชจ๋ ๋น์ด์์ผ๋ฉด answer = 65536
4. list1์ ์กด์ฌํ๋ ๋ฌธ์๊ฐ list2์๋ ์กด์ฌํ๋ฉด interaction ๋ฆฌ์คํธ์ ์ถ๊ฐ, ๋ณต์ฌ๋ ๋ฆฌ์คํธ 1,2์์๋ ๊ฐ๊ฐ ์ญ์ ์ฒ๋ฆฌ
5. ํฉ์งํฉ์ ๊ต์งํฉ + ๋ฆฌ์คํธ์ ์ญ์ ๋์ง ์๊ณ ๋จ์์๋ ์์ ๋ก ๊ณ์ฐ
6. floor()ํจ์๋ก ๊ฒฐ๊ณผ๊ฐ ๊ณ์ฐ
3. ๋ค๋ฅธ ์ฌ๋ ํ์ด
import re
import math
def solution(str1, str2):
str1 = [str1[i:i+2].lower() for i in range(0, len(str1)-1) if not re.findall('[^a-zA-Z]+', str1[i:i+2])]
str2 = [str2[i:i+2].lower() for i in range(0, len(str2)-1) if not re.findall('[^a-zA-Z]+', str2[i:i+2])]
gyo = set(str1) & set(str2)
hap = set(str1) | set(str2)
if len(hap) == 0 :
return 65536
gyo_sum = sum([min(str1.count(gg), str2.count(gg)) for gg in gyo])
hap_sum = sum([max(str1.count(hh), str2.count(hh)) for hh in hap])
return math.floor((gyo_sum/hap_sum)*65536)
1. str1,2๋ฅผ ๊ฐ๊ฐ ๋๊ธ์์ฉ ๋๋์ด ์์ด๋ก๋ง ์ด๋ฃจ์ด์ ธ ์๋ ๋ฌธ์์ด์ ๋ฆฌ์คํธ๋ก ๋ฐ์์ค
2. ๊ฐ๊ฐ์ ๊ต์งํฉ๊ณผ ํฉ์งํฉ์ ๊ตฌํจ
3. ํฉ์งํฉ์ด 0์ธ ๊ฒฝ์ฐ 65536 ๋ฐํ
4. ๊ต์งํฉ ๋ฆฌ์คํธ์ ์์๊ฐ ๊ฐ๊ฐ ์๋์ ๋ฆฌ์คํธ์ ๋ค์ด์์์ ๋์ ๊ฐ์๋ฅผ ์นด์ดํธํ์ฌ ๋ ์ค ์์ ๊ฐ์ ๋ฐํํ์ฌ ๋ํด์ค
ํฉ์งํฉ ๋ฆฌ์คํธ์ ์์๊ฐ ๊ฐ๊ฐ ์๋์ ๋ฆฌ์คํธ์ ๋ค์ด์์์ ๋์ ๊ฐ์๋ฅผ ์นด์ดํธํ์ฌ ๋ ์ค ํฐ ๊ฐ์ ๋ฐํํ์ฌ ๋ํด์ค
5. ๊ต์งํฉ์ ์ / ํฉ์งํฉ์ ์ * 65536 ๋ฐํ
def solution(str1, str2):
list1 = [str1[n:n+2].lower() for n in range(len(str1)-1) if str1[n:n+2].isalpha()]
list2 = [str2[n:n+2].lower() for n in range(len(str2)-1) if str2[n:n+2].isalpha()]
tlist = set(list1) | set(list2)
res1 = [] #ํฉ์งํฉ
res2 = [] #๊ต์งํฉ
if tlist:
for i in tlist:
res1.extend([i]*max(list1.count(i), list2.count(i)))
res2.extend([i]*min(list1.count(i), list2.count(i)))
answer = int(len(res2)/len(res1)*65536)
return answer
else:
return 65536
1. ๋ด๊ฐ ํ์ดํ ๋ฐฉ์๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ๊ฐ ๋ฌธ์์ด์ isalpha()ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ๋๊ธ์์ฉ ๋์ด์ ๋ฐํ
2. ๋ฆฌ์คํธ๋ฅผ ์งํฉํ์์ผ๋ก ๋ณํํ์ฌ ํฉ์งํฉ์ ์์ฑ
3. ํฉ์งํฉ์ ์์๊ฐ ์กด์ฌํ๋ ๊ฒฝ์ฐ -> for ๋ฌธ์ ์ฌ์ฉํ์ฌ tlist์ ์กด์ฌํ๋ ์์๋ค์ ๊ฐ ๋ฆฌ์คํธ์์ ์นด์ดํธํ์ฌ ํฉ์งํฉ์๋ ์ต๋๊ฐ๋งํผ ์ถ๊ฐ, ๊ต์งํฉ์๋ ์ต์๊ฐ๋งํผ ์ถ๊ฐํด์ค ๋ค ๊ณ์ฐ
ํฉ์งํฉ์ ์์๊ฐ ์กด์ฌํ์ง ์๋ ๊ฒฝ์ฐ -> 65536 ๋ฐํ