Week1-3
[์ค๋์ ํ์ต]
1. ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ(sort, sorted ํจ์)
2. divmod ํจ์
3. ์ฌ๊ท ์๊ณ ๋ฆฌ์ฆ
~ํผ์ฃ๋ง~
๋ฐฑ์ค์ด ์ต์ํด์์ธ์ง ์๋๋ฉด ๋ฌด์ธ๊ฐ ์๊ณ ๋ฆฌ์ฆ์
์ฌ์ฉํด์ผ ๋๋ค๋ ๊ฐ๋ฐ ๊ด๋ ๋๋ฌธ์ธ์ง
์์ฆ ๋ฌธ์ ๊ฐ ์ ํ๋ฆฌ์ง ์๋๋ค
๋ฌธ์ ํด๊ฒฐ ์ฝ๋๋ฅผ ๋ณด๋ฉด "์ ์ด๊ฑฐ๋ค" ์ถ์๋ฐ
๋ง์ ์ค์ค๋ก ํ๋ ค๊ณ ํ๋ฉด ๋ง๋งํ๊ณ ๋ต๋ตํ๋ค
์ด์ ์๋ ์ด๋ฐ ๊ฒฝํ์ด ์๋๋ฐ,
๊พธ์คํ ๋ฌธ์ ํด๊ฒฐ ๋ฐฉ๋ฒ์ ๊ณต๋ถํ๋ค ๋ณด๋ฉด
ํด๊ฒฐ ํ๋ฆ์ ์ค์ค๋ก ๋ ์ฌ๋ฆด ์ ์์ผ๋ฆฌ๋ผ ๋ฏฟ์ด ์์ฌ์น ์๋๋ค
1. ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ(sort, sorted ํจ์)
์ ๋ ฌ์ ์ฝ๋ฉ์ ์์ํ๋ ๋ถ๋ค๋ ์ ์๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ผ๊ณ ์๊ฐํ๋ค.
์ฌ๋ฌ ๊ฐ์ง ์ข ๋ฅ์ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ด ์์ง๋ง Python์ ๋ด์ฅํจ์ Sort์ Sorted๋ฅผ ํจ๊ป ์ดํด๋ณด๋๋ก ํ์
ํ์ด์ฌ์ด ์ ๊ณตํ๋ ์๋ฃ๊ตฌ์กฐ์๋ 'ํํ', '๋ฆฌ์คํธ', '๋์ ๋๋ฆฌ'๊ฐ ์๋ค.
sort๋ ๋ฆฌ์คํธ๋ฅผ ํตํด์, sorted๋ ๋์ ๋๋ฆฌ์ ๋ฆฌ์คํธ ์ ํํ์ ํตํด์ ํ์ตํด ๋ณด์
์๋ฌด๋ฐ ์ต์ ์ ๋ถ์ด์ง ์๊ณ ์คํํ sort๋ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ค.
listA = [4,6,3,1,7,8,9,2,5]
listA.sort()
print(listA)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ค๋ฉด 'reverse=True'๋ฅผ ์ถ๊ฐํ๋ฉด ๋๋ค
listA = [4,6,3,1,7,8,9,2,5]
listA.sort(reverse=True)
print(listA)
# [9, 8, 7, 6, 5, 4, 3, 2, 1]
์์์ ์ ๋ ฌ ์กฐ๊ฑด์ ์ฌ์ฉํ๊ธฐ ์ํด์๋ 'key=lambda'์ ์ฌ์ฉํ๋ฉด ๋๋ค.
#๋ฌธ์ : ์ฃผ์ด์ง๋ numbers ๋ฆฌ์คํธ ์ซ์๋ค์ ์กฐํฉํ ๊ฐ์ฅ ํฐ ์๋ฅผ ๋ฌธ์์ด๋ก ๋ง๋ค๊ธฐ
#ex) [4, 40, 3]์ด๋ผ๋ฉด 4403
numbers = [6, 10, 2]
numbers = [str(n) for n in numbers]
numbers.sort(key=lambda x : (x*3)[:4]) #๋ฌธ์ ๋ฆฌ์คํธ ๊ฐ ๊ฐ์ 3๋ฒ์ฉ ๊ณฑํ์ฌ ์์์ 4๋ฒ์งธ๊ฐ์ผ๋ก ์ ๋ ฌ
if numbers[0] == '0': #์ ๋ ฌํ ๋ฆฌ์คํธ์ ๋งจ ์์ด 0์ด๋ผ๋ฉด ๋ชจ๋ ๋ฆฌ์คํธ ๊ฐ์ด 0๋ณด๋ค ํฌ์ง ์๋ค
print('0')
else:
print(''.join(numbers))
join(๋ฆฌ์คํธ) ํ์์ ์ ๋ฌธ์์ด์ ๋ฆฌ์คํธ์ ๋ชจ๋ ๊ฐ์ ์์๋๋ก ๋ถ์ฌ์ค๋ค
์ด์ ๋ sorted์ ๋ํด ์์๋ณด์. ์ sort์ sorted๋ฅผ ๊ตฌ๋ถํ์๋๋ฉด ๋์ ๋๋ฆฌ๋ sort๋ฅผ ์ฌ์ฉํ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค.
์์๊ฐ ์์ด (key, value) ํํ์์ key๊ฐ์ผ๋ก value๋ฅผ ์ ๊ทผํ๋ ๋ฐฉ์์ ๋์ ๋๋ฆฌ๋ ์์๊ฐ ์๋ค.
๊ธฐ๋ณธ์ ์ผ๋ก sorted(๋์ ๋๋ฆฌ) ํํ๋ก ์ฌ์ฉํ ์ ์๋ค.
dic = {"name": "sina", "age": 25, "department": "software"}
sorted_dic = sorted(dic.items()) #key๋ฅผ ๊ธฐ์ค์ผ๋ก ์ฌ๋ฆผ์ฐจ์ ์ ๋ ฌ
print(dic)
print(sorted_dic)
# {'name': 'sina', 'age': 25, 'department': 'software'}
# [('age', 25), ('department', 'software'), ('name', 'sina')]
์ฃผ์ ์ฌํญ : sorted๋ ๋์ ๋๋ฆฌ ์์ฒด๋ฅผ sortํด์ฃผ๋ ๊ฒ์ด ์๋ ์กฐ๊ฑด์ ๋ถํฉํ๋ ์์๋ก ์ ๋ ฌํ์ฌ ๋ฆฌ์คํธ๋ฅผ ๋ฐํํ๋ค
์ด๋ฒ์ ๋ฆฌ์คํธ๋ก ์ ์ฅ๋ ํํ์ ์ ๋ ฌํด ๋ณด์
sorted์ ์กฐ๊ฑด์ ๋ถ์ฌํ๊ณ ์ถ๋ค๋ฉด sort์ ๋ง์ฐฌ๊ฐ์ง๋ก 'key=lambda'๋ฅผ ์ฌ์ฉํ๋ฉด ๋๋ค.
tupleList = [('a', 3), ('e', 1), ('c', 9), ('b', 2), ('d', 0)]
sorted_tuple = sorted(tupleList, key=lambda x: x[0])
print(sorted_tuple)
# [('a', 3), ('b', 2), ('c', 9), ('d', 0), ('e', 1)]
2. divmod ํจ์
divmod ํจ์๋ ํ์ด์ฌ์ ๋ด์ฅํจ์๋ก, ๋ชซ๊ณผ ๋๋จธ์ง๋ฅผ ํ ๋ฒ์ ๋ฐํํด ์ค๋ค.
#5๋ก ๋๋ ๋ชซ๊ณผ ๋๋จธ์ง
alist = [1, 4, 6, 5, 10, 14, 40, 33, 9, 65, 90]
for i in alist:
q, r = divmod(i, 5)
print("%d์ (๋ชซ,๋๋จธ์ง) : (%d,%d)" %(i, q, r))
#1์ (๋ชซ,๋๋จธ์ง) : (0,1)
#4์ (๋ชซ,๋๋จธ์ง) : (0,4)
#6์ (๋ชซ,๋๋จธ์ง) : (1,1)
#5์ (๋ชซ,๋๋จธ์ง) : (1,0)
#10์ (๋ชซ,๋๋จธ์ง) : (2,0)
#14์ (๋ชซ,๋๋จธ์ง) : (2,4)
#40์ (๋ชซ,๋๋จธ์ง) : (8,0)
#33์ (๋ชซ,๋๋จธ์ง) : (6,3)
#9์ (๋ชซ,๋๋จธ์ง) : (1,4)
#65์ (๋ชซ,๋๋จธ์ง) : (13,0)
#90์ (๋ชซ,๋๋จธ์ง) : (18,0)
3. ์ฌ๊ท ์๊ณ ๋ฆฌ์ฆ
๋ฌธ์ ๋ฅผ ํตํด divmod๋ฅผ ๋์ฑ ๊น์ด ์ดํดํ๊ณ ์ฌ๊ท ์๊ณ ๋ฆฌ์ฆ์ ๋ฐฐ์๋ณด์
<์ฌ๊ท ์๊ณ ๋ฆฌ์ฆ >
ํ๋์ ํจ์์์ ์๊ธฐ ์์ ์ ๋ค์ ํธ์ถํ์ฌ ์์ ์ ์ํํ๋ ์๊ณ ๋ฆฌ์ฆ
๋ฌธ์ : 1, 10, 100... ์ด๋ ๊ฒ 10 ์ ๊ณฑ ๋จ์๋ก ๊ฐ๊ฐํ ์ ์๋ number๊ฐ ์ฃผ์ด์ง๋ค.
number๊ฐ 0์ด ๋๋ ๊ฐ์ฅ ์ต์์ ๊ฐ๊ฐ ํ์๋ฅผ ๊ตฌํ๋ผ
ex. 46์ด๋ผ๋ฉด 4๋ฅผ ๋ํ๊ณ 50์ ๋นผ์ 9ํ์ด๊ณ , 44๋ผ๋ฉด 4๋ฅผ ๋นผ๊ณ 40์ ๋นผ์ 8ํ
def solution(number):
if number <= 1:
return number
q, r = divmod(number, 10)
return min(solution(q) + r, solution(q+1) + (10-r))
ํด์ค : ์ฌ๊ท ํจ์๋ฅผ ์ด์ฉํ์ฌ ๋ช์ ์๋ฆฌ์ธ์ง ๋ชจ๋ฅด๋ number์ ๊ฐ ์๋ฆฟ์๋ง ํ์ธํ์ฌ ์ต์ ํ์๋ฅผ ๊ตฌํ๋ค.
์ฌ๊ท ํจ์๋ ๋ฐ๋์ ์ข ๋ฃ ์กฐ๊ฑด์ด ์กด์ฌํด์ผ ๋๋ค. ์ฌ๊ธฐ์์ ์ข ๋ฃ์กฐ๊ฑด์ number๊ฐ 1๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ๋์ด๋ค.
์ฆ divmode๋ฅผ ํตํด q(๋ชซ) ๊ฐ์ด 0์ด ๋์ด์ ๋๋จธ์ง๋ง ๋จ์ ๊ฒฝ์ฐ๋ก, q+1์ ์ฌ๊ท๋ก ํธ์ถํ๋ ๋ถ๋ถ์ด ์๊ธฐ ๋๋ฌธ์ 1๋ณด๋ค ์์ ๊ฒ์ด ์๋ ๊ฐ๊ฑฐ๋ ์์ ๋ number๋ฅผ ๋ฐํํ๋ค. ํด๋น ๊ฒฝ์ฐ๋ ์ด๊ธฐ number์ ๋ง์ง๋ง ์๋ฆฟ์๊น์ง ๋๋ฌํ ์ํ์ด๋ค.
๋ฐํ๋ ๊ฐ์ r ๋๋ (10-r)์ ๋ํ ๊ฐ ์ค ์์ ๊ฐ์ ๋ฐํํ๊ณ ๋ฐํ๋ ๊ฐ์ ๋ ์ด์ ์๋ฆฟ์์ r ๋๋ 10-r์ ๋ํ ๊ฒ ์ค ์์ ๊ฒ์ ์ ํํ๊ณ .... ๋ฐ๋ณตํ๋ค.
์ต์ข ์ ์ผ๋ก solution์ ์ฒ์ ํธ์ถํ์ ๋๋ก ๋์์์ ๋๋ ๋ชจ๋ ์๋ฆฟ์์ ๋ํ ์ต์ ๊ฐ๊ฐ ํ์๋ฅผ ์ป์ ์ ์๋ค.