2020. 12. 30. 18:00ใ๐ Algorithm/๐ Python ๋ฌธ๋ฒ
์ค๋์ ํ์ด์ฌ ๊ณต๋ถํ ๋ ๋ง์ด ์ ์ฉํ๋ ํ๋ก๊ทธ๋๋จธ์ค์ 'ํ์ด์ฌ์ ํ์ด์ฌ ๋ต๊ฒ' ๊ฐ์์ ๋ํด ์๊ฐํด๋๋ฆฌ๊ณ ์ ํด์!
ํ์ด์ฌ์ ํ์ด์ฌ๋ต๊ฒ
๋ณธ ๊ฐ์๋ ํ์ด์ฌ ๋ฌธ๋ฒ์ ์ด๋ฏธ ์๊ณ ์๋ ๋ถ๋ค์ ๋์์ผ๋ก ๋ง๋ค์ด์ก์ต๋๋ค. ##### ์ด๋ฐ ๋ถ๋ค๊ป ์ถ์ฒํฉ๋๋ค * ํ์ด์ฌ ๋ฌธ๋ฒ์ ์๊ณ ๊ณ์๋ ๋ถ * ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ฅผ ์กฐ๊ธ ๋ ์ฝ๊ฒ ํ๊ณ ์ถ์ ๋ถ * Python ์ฝ
programmers.co.kr
ํ์ด์ฌ ์ ๋งํ ๋ฌธ๋ฒ์ ๋ํด ๋ค ์ ์๊ณ ์๋ค๊ณ ์๊ฐํ๋๋ฐ 'ํ์ด์ฌ์ ํ์ด์ฌ๋ต๊ฒ' ๊ฐ์์ ๋ฌธ์ ๋ฅผ ํ์ด๋ณด๋ฉด์ ์์ง ๋ง์ด ๋ถ์กฑํ๊ณ , ํ์ด์ฌ์ ์ ๋ง ๋ฌด๊ถ๋ฌด์งํ ์ธ์ด๋ผ๋ ๊ฒ์ ์์์ด์! ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ํ ๋ ํ์ด์ฌ์ด ์ผ๋ง๋ ์ข์ ์ธ์ด์ธ์ง๋ ๋ค์ํ๋ฒ ๊นจ๋ฌ์์ต๋๋ค ๐
๊ทธ๋์ ! 'ํ์ด์ฌ์ ํ์ด์ฌ ๋ต๊ฒ' ๊ฐ์์์ ์๋กญ๊ฒ ๋ฐฐ์ด ์ ์ฉํ ํ์ด์ฌ ๋ฌธ๋ฒ/๋ชจ๋์ ๋ํด ์ ๋ฆฌํด๋ณผ๊ฒ์!
'ํ์ด์ฌ์ ํ์ด์ฌ ๋ต๊ฒ' ๊ฐ์ ์์ฝ ๋ฐ ์ ๋ฆฌ๋ผ๊ณ ์๊ฐํ์๋ฉด ๋ ๊ฑฐ ๊ฐ์ต๋๋ค : )
๐ ๋ชซ๊ณผ ๋๋จธ์ง๋ฅผ ๊ตฌํ ๋?! - divmod
๋ณดํต์ ๋ชซ๊ณผ ๋๋จธ์ง๋ฅผ ๊ตฌํ ๋ ์ด๋ป๊ฒ ๊ตฌํ์๋์!? ์๋์ ๊ฐ์ด ์ฐ์ฐ์๋ฅผ ์ด์ฉํ์ฌ ๋ชซ, ๋๋จธ์ง ๋ฐ๋ก ๊ตฌํ์ค ๊ฑฐ ๊ฐ์๋ฐ์.
divmod๋ฅผ ์ด์ฉํ๋ฉด ๋ณด๋ค ์ฝ๊ฒ ๋ชซ ๊ณผ ๋๋จธ์ง๋ฅผ ๋์์ ๊ตฌํ์ค ์ ์์ต๋๋ค.
a = 7
b = 5
print( a//b , a%b ) # 1 2 ์ถ๋ ฅ
a = 7
b = 5
print( *divmod(a, b) ) # 1 2 ์ถ๋ ฅ
๐ n ์ง๋ฒ ํ๊ธฐ ๋ string์ 10 ์ง๋ฒ ์ซ์๋ก ๋ณํํ๊ธฐ - int
string์ผ๋ก ํ๊ธฐ๋ n ์ง๋ฒ ์ซ์๋ฅผ 10 ์ง๋ฒ์ผ๋ก ๋ณํํ๋ ๋ฌธ์ ๊ฐ ์์์ต๋๋ค.
์ ๊ฐ ์๊ณ ์๋ int๋ Integer ํ์ผ๋ก ๋ณํ์ ํด์ฃผ๋ ์ญํ ๋ง ํ๋ค๊ณ ์๊ฐํ์๋๋ฐ ์ด๋ฒ ๊ธฐํ์ 10์ง๋ฒ ๋ณํ๋ ์๋์ผ๋ก ํด์ค๋ค๋ ์ฌ์ค์ ๋ฐฐ์ ์ต๋๋ค!
ํ์ด์ฌ์ ์ฌ์ฉํ๋ฉด ์ง๋ฒ ๋ณํ๋ ๋งค์ฐ ์ฝ๊ฒ ํ ์ ์๋ค๋ ๊ฑธ ๋ฐฐ์ฐ๊ฒ ๋์์ด์.
num = '3212'
base = 5
st = [int(i) for i in str(num)] # string ์ซ์๋ฅผ ํ๊ธ์์ฉ ์ชผ๊ฐ์ด intํ์ผ๋ก list์ ์ ์ฅํ๊ธฐ
st.reverse() # ์ง๋ฒ์ ๋ง๊ฒ ๊ณฑํด์ฃผ๊ธฐ ์ํ์ฌ list ๊ฑฐ๊พธ๋ก ํ๊ธฐ
answer = 0 # 10์ง๋ฒ์ผ๋ก ๋ณํ๋ ์ซ์ ๋ํด์ฃผ๊ธฐ
for i in range(len(st)):
answer += st[i]*(base**i)
num = '3212'
base = 5
answer = 0
for idx, i in enumerate(num[::-1]):
answer += int(i) * ( base ** idx )
์ด๋ ๊ฒ ๊ฝค ๊ธด ์์์ int๋ฅผ ํตํด ๋จ ํ๋ฒ์ 10์ง๋ฒ์ผ๋ก ์ง๋ฒ ๋ณํ์ด ๊ฐ๋ฅํฉ๋๋ค.
num = '3212'
base = 5
answer = int(num, base)
๐ ๋ฌธ์์ด ์ ๋ ฌํ๊ธฐ - ljust, center, rjust
๋ฌธ์์ด์ ๋ํ ํจ์๋ค์ ์ ๋ฆฌํด๋ ผ ์ ์์๋๋ฐ, ljust,center,rjust์ ์ฌ์ฉ๋ฒ์ ๋ํด์๋ ์ ๋ชจ๋ฅด๊ณ ์์์ต๋๋ค.
์ด๋ฒ์ ๋ฌธ์์ด ์ ๋ ฌ ๋ฌธ์ ๋ฅผ ํ๋ฉด์ ์ด๋ ๊ฒ ์ฌ์ฉ๋๋ ๊ตฌ๋ ๊นจ๋ฌ์์ต๋๋ค.
๐ ๋ฌธ์์ด s๋ฅผ ์ข์ธก / ๊ฐ์ด๋ฐ / ์ฐ์ธก ์ ๋ ฌํ ๊ธธ์ด n์ธ ๋ฌธ์์ด์ ํ ์ค์ฉ ํ๋ฆฐํธํด๋ณด๊ธฐ
s = '๊ฐ๋๋ค๋ผ'
n = 7
s.ljust(n) # ์ข์ธก ์ ๋ ฌ
s.center(n) # ๊ฐ์ด๋ฐ ์ ๋ ฌ
s.rjust(n) # ์ฐ์ธก ์ ๋ ฌ
๐ ์ํ๋ฒณ ์ถ๋ ฅํ๊ธฐ - string ๋ชจ๋
๋ณดํต 'a' ๋ถํฐ 'z'๊น์ง ์ถ๋ ฅํ์์ค ํ๋ฉด 'abcd....xyz' ์ด๋ ๊ฒ ํ๋ํ๋ ๋์ดํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์์ ๊ฑฐ ๊ฐ์๋ฐ์.
์ ๋ํ ํ๋ํ๋ ๋ถํ์ํ๊ฒ ๋์ดํ๋ ์ฌ๋ ์ค ํ๋ช ์ด์์ต๋๋ค.
string ๋ชจ๋์๋ ์๋ฌธ์, ๋๋ฌธ์, ๋์๋ฌธ์ ๋ชจ๋, ์ซ์๋ฅผ ์ถ๋ ฅํด์ฃผ๋ ๊ธฐ๋ฅ์ด ์์์ต๋๋ค.
string ๋ชจ๋์ ๋ํด ๋ ๋ง์ด ๊ณต๋ถํด์ผ ๊ฒ ์ด์!
import string
string.ascii_lowercase # ์๋ฌธ์ abcdefghijklmnopqrstuvwxyz
string.ascii_uppercase # ๋๋ฌธ์ ABCDEFGHIJKLMNOPQRSTUVWXYZ
string.ascii_letters #๋์๋ฌธ์ ๋ชจ๋ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
string.digits # ์ซ์ 0123456789
๐ 2์ฐจ์ ๋ฆฌ์คํธ ๋ค์ง๊ธฐ - zip
' [ [1,2,3], [4,5,6], [7,8,9] ] ๋ฆฌ์คํธ๊ฐ ์ฃผ์ด์ง ๊ฒฝ์ฐ, [[1, 4, 7], [2, 5, 8], [3, 6, 9]] ๋ก ๋ค์ง์ด๋ผ ' ๋ผ๋ ๋ฌธ์ ๋ฅผ ๋ณด๊ณ ์ด๋ป๊ฒ ๋ค์ง์ ์ ์์๊น ์๊ฐํด๋ณด๋ค ๋ฆฌ์คํธ์ ํ๊ณผ ์ด์ ๊ธธ์ด๊ฐ ๊ฐ๋ค๋ ์กฐ๊ฑด์ ๋ณด๊ณ , for๋ฌธ์ ํตํด temp ๋ฆฌ์คํธ์ 1ํ 1์ด, 2ํ 1์ด .. ์์ฐจ์ ์ผ๋ก ์ ์ฅํ์ฌ ์ ๋ต ๋ฆฌ์คํธ์ ๋ํด์ฃผ๋ ํ์์ผ๋ก ๊ตฌํํด๋ณด์๋๋ฐ์.
zip์ ์ด์ฉํ๋ฉด ๋ณด๋ค ์์ํ๊ฒ 2์ฐจ์ ๋ฆฌ์คํธ๋ฅผ ๋ค์ง์ ์ ์๋ค๋ ๊ฒ์ ๋ฐฐ์ ์ต๋๋ค.
def solution(mylist):
answer = []
for i in range(len(mylist[0])):
tmp = []
for j in range(len(mylist)):
tmp.append(mylist[j][i])
answer.append(tmp)
return answer
mylist = [ [1,2,3], [4,5,6], [7,8,9] ]
new_list = list(map(list, zip(*mylist)))
์ถ๊ฐ๋ก zip์ ์ ์ฉํ ์ฌ์ฉ ์์๋ ์ ๋ฆฌํด๋ณด์์ต๋๋ค.
โ๏ธ์ฌ๋ฌ ๊ฐ์ Iterable ๋์์ ์ํํ ๋
list1 = [1, 2, 3, 4]
list2 = [100, 120, 30, 300]
list3 = [392, 2, 33, 1]
answer = []
for i, j, k in zip(list1, list2, list3):
print( i + j + k )
โ๏ธKey ๋ฆฌ์คํธ์ Value ๋ฆฌ์คํธ๋ก ๋์ ๋๋ฆฌ ์์ฑํ ๋
animals = ['cat', 'dog', 'lion']
sounds = ['meow', 'woof', 'roar']
answer = dict(zip(animals, sounds)) # {'cat': 'meow', 'dog': 'woof', 'lion': 'roar'}
๐ ๋ฆฌ์คํธ์ ๋ชจ๋ ์์์ type ๋ณํํ๊ธฐ - map
map ์ input์ผ๋ก ์ฌ๋ฌ๊ฐ์ ์ซ์๋ฅผ ํ ์ค๋ก ๋ฐ์ ๋ ๋ง์ด ์ฌ์ฉํ๋ ํจ์๋ผ ๊ฝค ์ต์ ํ์ค๊ฑฐ ๊ฐ์๋ฐ์.
map์ ์์ฉํ ๋ฐฉ๋ฒ์ ๋ํด๋ ์๊ฐ ํด๋๋ฆฌ๊ณ ์ ํฉ๋๋ค.
list1 = ['1', '100', '33']
list2 = list(map(int, list1)) # [1, 100, 33]
โ๏ธ์ด์ฐจ์ ๋ฆฌ์คํธ์ ์์์ ๊ธธ์ด๋ฅผ ๋ด์ ๋ฆฌ์คํธ๋ก ๋ง๋ค๋
[ [1,2] , [3,4,5], [1] ] ๐๐ป [ 2, 3, 1 ] ๋ก ๋ง๋ค๊ธฐ
answer = list(map(len,mylist))
ํญ์ map์ ์ฌ์ฉํ ๋ int ๋ง ๋ฃ์ด๋ณธ ๊ฑฐ ๊ฐ์๋ฐ ๋ด๊ฐ ์ ์ํ ํจ์๋, len๊ณผ ๊ฐ์ ํจ์๋ค์ ๋ฃ์ด๋ ์๋์ผ๋ก ์ธ์๋ค์ ํจ์์ ๋ฃ์ด ๋ณํํด์ฃผ๋ ์ฑ์ง์ ๊ฐ๊ณ ์๋ค๋ ๊ฒ์ ๋ฐฐ์ธ ์ ์์์ต๋๋ค.
๐ sequence ์์๋ค์ ํ๋๋ก ์ด์ด ๋ถ์ด๊ธฐ - join
- ๋ฌธ์์ด ๋ฐฐ์ด ['1', '100', '33']์ ์ด์ด ๋ถ์ฌ ๋ฌธ์์ด '110033' ๋ง๋ค๊ธฐ
- ์ ์ํ ํํ (3, 22, 91)์ ์ด์ด๋ถ์ฌ ๋ฌธ์์ด '32291' ๋ง๋ค๊ธฐ
์์ ๊ฐ์ ์ํฉ์์ ์ด๋ป๊ฒ ๋ถ์ผ ์ ์์๊น ?! ๋ง๋งํ ๊ฒฝ์ฐ๊ฐ ์์ผ์ จ์ ํ ๋ฐ ํ์ด์ฌ์์๋ join์ ํตํด ํ๋ฒ์ string์ผ๋ก ์ด์ด ๋ถ์ด์ค ์ ์์ต๋๋ค.
my_list = ['1', '100', '33']
answer = ''.join(my_list) # '110033'
โ๏ธString์ List๋ก ๋ณํํ๋ ค๋ฉด !?
str = '11 22 33'
list = str.split( ) # ['11', '22', '33']
๐๊ณฑ์งํฉ(Cartesian product) ๊ตฌํ๊ธฐ - product
product์ ๋ํด์๋ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ํ๋ ์์ฃผ ๋ณด์ง ๋ชปํ ๊ฒ ๊ฐ์ง๋ง ์์๋๋ฉด ํจ์ฌ ๋น ๋ฅด๊ณ ์ฝ๊ฒ ์ฌ์ฉํ ์ ์๋ ํจ์ ์ค ํ๋์ธ ๊ฒ ๊ฐ์ต๋๋ค!
๋ ์คํธ๋ง 'ABCD', 'xy' ์ ๊ณฑ์งํฉ์ธ Ax Ay Bx By Cx Cy Dx Dy ๊ตฌํ ๋ / 2๊ฐ์ด์์ iterable ๊ณฑ์งํฉ ๊ตฌํ ๋
import itertools
iterable1 = 'ABCD'
iterable2 = 'xy'
iterable3 = '1234'
itertools.product(iterable1, iterable2, iterable3)
๐ 2์ฐจ์ ๋ฆฌ์คํธ๋ฅผ 1์ฐจ์ ๋ฆฌ์คํธ๋ก ๋ง๋ค๊ธฐ - from_iterable
itertools๋ฅผ ์ด์ฉํ๋ฉด ์ฝ๊ฒ 2์ฐจ์ ๋ฆฌ์คํธ๋ฅผ 1์ฐจ์ ๋ฆฌ์คํธ๋ก ๋ง๋ค ์ ์์ต๋๋ค!
2์ฐจ์ ๋ฆฌ์คํธ๋ฅผ 1์ฐจ์ ๋ฆฌ์คํธ๋ก ๋ง๋๋ ๋ฐฉ๋ฒ ์ค ๊ฐ๋จํ ๋ฐฉ๋ฒ์ ๋ํด์ ์๊ฐํด๋๋ฆด๊ฒ์.
import itertools
my_list = [[1, 2], [3, 4], [5, 6]]
# ๋ฐฉ๋ฒ 1 - sum ํจ์
answer = sum(my_list, [])
# ๋ฐฉ๋ฒ 2 - itertools.chainimport itertools
list(itertools.chain.from_iterable(my_list))
# ๋ฐฉ๋ฒ 3 - itertools์ unpackingimport itertools
list(itertools.chain(*my_list))
# ๋ฐฉ๋ฒ4 - list comprehension ์ด์ฉ
[element for array in my_list for element in array]
๐ ์์ด๊ณผ ์กฐํฉ - combinations, permutations
iterable์ ์์๋ฅผ ๊ฐ์ง๊ณ ์์ด๊ณผ ์กฐํฉ์ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ ๋ํด ์๋ ค๋๋ฆฌ๊ณ ์ ํฉ๋๋ค.
์์ด๊ณผ ์กฐํฉ์ ๊ตฌํ๋ ๋ฐฉ์์ ์์์ ๊ฐ์๊ฐ ์ ์ผ๋ฉด ์ฝ๊ฒ ๊ตฌํ์ค ์ ์์ง๋ง ์๊ณ ๋ฆฌ์ฆ์ ๊ตฌํ๊ธฐ์๋ ์ด๋ ค์ด ๋ฌธ์ ์ด์ง ์์๊น ์ถ์ต๋๋ค.
itertools์ permutations์ ์ด์ฉํ๋ฉด ๋ณด๋ค ์ฝ๊ฒ ๊ตฌํ์ค ์ ์์ต๋๋ค!
- 1,2,3์ ์ซ์๊ฐ ์ ํ ์นด๋๊ฐ ์์ ๋, ์ด ์ค ๋ ์ฅ์ ๊บผ๋ด๋ ๊ฒฝ์ฐ์ ์ -> 12, 13, 21, 23, 31, 32
- 'A', 'B', 'C'๋ก ๋ง๋ค ์ ์๋ ๊ฒฝ์ฐ์ ์ -> 'ABC', 'ACB', 'BAC', 'BCA', 'CAB', 'CBA'
import itertools
pool = ['A', 'B', 'C']
print(list(map(''.join, itertools.permutations(pool)))) # 3๊ฐ์ ์์๋ก ์์ด ๋ง๋ค๊ธฐ
print(list(map(''.join, itertools.permutations(pool, 2)))) # 2๊ฐ์ ์์๋ก ์์ด ๋ง๋ค๊ธฐ
๐ ๊ฐ์ฅ ๋ง์ด ๋ฑ์ฅํ๋ ์ํ๋ฒณ ์ฐพ๊ธฐ - Counter
collections ๋ชจ๋์ ์กด์ฌํ๋ Counter๋ ๊ฝค ๋ง์ด ์ฌ์ฉํด๋ณด์ จ์ ๊ฑฐ๋ผ๊ณ ์๊ฐํฉ๋๋ค.
ํ์ง๋ง ' mystr์์ ๊ฐ์ฅ ๋ง์ด ๋ฑ์ฅํ๋ ์ํ๋ฒณ๋ง์ ์ฌ์ ์์ผ๋ก ์ถ๋ ฅํ๊ธฐ ' ์ด๋ฐ ๋ฌธ์ ๋ฅผ ๋ฐ์์ ๋ ์ด๋ป๊ฒ ๋ฌธ์ ๋ฅผ ํ์ด์ผ ํ ์ง ๋ฐ๋ก ์๊ฐ๋์ง ์์๋๋ฐ์. Counter์ ์ด์ฉํ๋ฉด ์ฝ๊ฒ ํ ์ ์๋ค๋ ๊ฑธ ๋ฐฐ์ธ ์ ์์์ต๋๋ค.
- 'aab' -> 'a'
- 'dfdefdgf' -> 'df'
- 'bbaa' -> 'ab'
from collections import Counter
my_str = input().strip()
counter = Counter(my_str).most_common()
answer =""
for i in range(len(counter)):
if counter[i][1] == counter[0][1]:
answer+=counter[i][0]
print(''.join(sorted(list(answer))))
collections์ Counter ํด๋์ค์๋ ์์๊ฐ ๋ช๋ฒ ๋ฑ์ฅํ๋์ง ๊ตฌํ๋ ๊ฒ ๋ง๊ณ ๋ most_common() ์ฒ๋ผ ๋ฐ์ดํฐ์ ๊ฐ์๊ฐ ๋ง์ ์์ผ๋ก ์ ๋ ฌ๋ ๋ฆฌ์คํธ๋ฅผ ๋ฆฌํดํ๋ ๋ฉ์๋๋ ์กด์ฌํฉ๋๋ค.
from collections import Counter
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 7, 9, 1, 2, 3, 3, 5, 2, 6, 8, 9, 0, 1, 1, 4, 7, 0]
answer = Counter(my_list)
print(answer[1]) # = 4
print(answer[3]) # = 3
print(answer[100]) # = 0
๐ for ๋ฌธ๊ณผ if๋ฌธ์ ํ๋ฒ์ - List comprehension์ if ๋ฌธ
list ์์๋ค ์ค 2์ ๋ฐฐ์๋ง์ 2๋ฐฐ ํ์ฌ ์ ์ฅํ๊ณ ์ถ๋ค๋ฉด ?! ํ์ด์ฌ์์๋ for๋ฌธ๊ณผ if๋ฌธ์ ํ๋ฒ์ ์ธ ์ ์๋ List์ comprehension์ด ์กด์ฌํฉ๋๋ค.
mylist = [3, 2, 6, 7]
answer = [ i**2 for i in mylist if i %2 == 0] # [4, 12]
๐ flag OR for - else
for ๋ฌธ์ ๋๋ ค ์กฐ๊ฑด์ ํด๋นํ๋ ์์๊ฐ ์กด์ฌํ๋์ง ํ์ธํ ๋ค์์ ์กด์ฌํ๋ฉด True๋ฅผ , ์กด์ฌํ์ง ์์ผ๋ฉด Fasle์ ๊ฐ์ด ์ถ๋ ฅํด์ผํ๋ ๊ฒฝ์ฐ๊ฐ ์กด์ฌํ ์ ์์ต๋๋ค. ์ด๋ for - else ๋ฌธ์ ์ฌ์ฉํ๋ฉด ๊ฐํธํ๊ฒ ์ฝ๋๋ฅผ ์ง์ค ์ ์์ต๋๋ค.
๋ฌธ์ )
- ์ซ์๋ฅผ ์ฐจ๋ก๋ก ๊ณฑํด ๋์จ ์๊ฐ ์ ๊ณฑ์1๊ฐ ๋๋ฉด found๋ฅผ ์ถ๋ ฅํ๊ณ
- ๋ชจ๋ ์๋ฅผ ๊ณฑํด๋ ์ ๊ณฑ์๊ฐ ๋์ค์ง ์์๋ค๋ฉด not found๋ฅผ ์ถ๋ ฅํ๊ธฐ
import math
numbers = [int(input()) for _ in range(5)]
multiplied = 1
for number in numbers:
multiplied *= number
if math.sqrt(multiplied) == int(math.sqrt(multiplied)):
print('found')
break
else:
print('not found')
๐ ๋ ๋ณ์์ ๊ฐ ๋ฐ๊พธ๊ธฐ - swap
swap์ ํ๊ธฐ ์ํด์๋ ๋ณดํต temp๋ฅผ ์ด์ฉํ์ฌ ๋ณํํ๋ ๋ฐฉ๋ฒ์ ๋ํด ์ต์ํ์ค ํ ๋ฐ์.
ํ์ด์ฌ์์๋ ๊ฐ๋จํ๊ฒ swap๋ฅผ ํ์ค ์ ์์ต๋๋ค!
a = 3
b = 'abc'
a, b = b, a # a = 'abc', b = 3
๐์ด์ง ํ์ ํ๊ธฐ (binary search) - bisect
์ด์ง ํ์์ด๋ ?! ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋ ๋ฆฌ์คํธ์์ ํน์ ๊ฐ ์์น๋ฅผ ์ฐพ์๋ด๋ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ๊ฒ์์๋๊ฐ ๋น ๋ฅด๋ค๋ ์ฅ์ ์ด ์์ต๋๋ค.
์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ฅผ ํธ์ค ๋ ์ด์ง ํ์์ ์ฌ์ฉํ๋ ๋ฌธ์ ๊ฐ ๋ง์ด ๋ฑ์ฅํ๋๋ฐ์. ์ด๋ ์ด์ง ํ์ ์๊ณ ๋ฆฌ์ฆ์ ์์ฑํ๋ ๊ฒ์ด ์๋ bisect๋ชจ๋์ bisect ๋ฅผ ์ด์ฉํ์๋ฉด ๊ฐ๋จํ๊ฒ ์ด์ง ํ์์ ์ด์ฉํ์ค ์ ์์ต๋๋ค.
์ด์ง ํ์ ์๊ณ ๋ฆฌ์ฆ
def bisect(a, x, lo=0, hi=None):
if lo < 0:
raise ValueError('lo must be non-negative')
if hi is None:
hi = len(a)
while lo < hi:
mid = (lo + hi) // 2
if a[mid] < x:
lo = mid + 1
else:
hi = mid
return lo
mylist = [1, 2, 3, 7, 9, 11, 33]
print(bisect(mylist, 3))
bisect ๋ชจ๋์ ์ด์ฉํ ์ด์ง ํ์
import bisect
mylist = [1, 2, 3, 7, 9, 11, 33]
print(bisect.bisect(mylist, 3))
๐ํด๋์ค์ ์ธ์คํด์ค ์ถ๋ ฅ - class์ ์๋ string casting
class๋ฅผ ์์ฑํ ๋ค print๋ฌธ์ ์ถ๊ฐ๋ก ์ถ๋ ฅํ๊ณ ์ถ์ ๋๊ฐ ์์ต๋๋ค.
์ด๋ ํ์ด์ฌ์์๋ __str__ ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ class ๋ด๋ถ์์ ์ถ๋ ฅ format์ ์ง์ ํ๋ ๊ฒ์ด ๊ฐ๋ฅํฉ๋๋ค!
class Coord(object):
def __init__ (self, x, y):
self.x, self.y = x, y
point = Coord(1, 2)
print( '({}, {})'.format(point.x, point.y) )
# ๋๋
def print_coord(coord):
print( '({}, {})'.format(coord.x, coord.y) )
print_coord(point)
class Coord(object):
def __init__ (self, x, y):
self.x, self.y = x, y
def __str__ (self):
return '({}, {})'.format(self.x, self.y)
point = Coord(1, 2)
๐ ๊ฐ์ฅ ํฐ์ - inf
inf๋ฅผ ์ด์ฉํ๋ฉด ์๋ฌด๋ฆฌ ํฐ ์ด๋ค ์ซ์์ ๋น๊ตํ๋๋ผ๋ ๋ฌด์กฐ๊ฑด ํฌ๋ค๊ณ ํ์ ํ์ค ์ ์์ต๋๋ค.
inf์๋ ์์ ๊ธฐํธ๋ฅผ ๋ถ์ผ ์ ์๋ค๋ ์ ๋ ๊ธฐ์ตํด์ฃผ์๋ฉด ์ข์๊ฑฐ ๊ฐ์์.
min_val = float('inf')
min_val > 10000000000
max_val = float('-inf')
๐ ํ์ผ ์ ์ถ๋ ฅ ๊ฐ๋จํ๊ฒ ํ๊ธฐ
ํ์ด์ฌ์ with - as ๊ตฌ๋ฌธ์ ์ด์ฉํ๊ฒ ๋๋ฉด ํ์ผ์ closeํ์ง ์๊ณ ์๋ closeํ์ค ์ ์๊ณ ,
readlines์ ํ์ผ์ EOF ๊น์ง๋ง ์ฝ์ด, while๋ฌธ์ ํตํด EOF๋ฅผ ์ฒดํฌํ ํ์๊ฐ ์์ต๋๋ค.
with - as ๊ตฌ๋ฌธ์ ํ์ผ ๋ฟ๋ง์๋๋ผ socket, http์์๋ ์ฌ์ฉํ์ค ์ ์์ต๋๋ค!
with open('myfile.txt') as file:
for line in file.readlines():
print(line.strip().split('\t'))
์ด๋ฒ ํฌ์คํ ์์๋ python์ ์ ์ฉํ ๋ฌธ๋ฒ๊ณผ ๋ชจ๋์ ๋ํด ์์๋ณด์๋๋ฐ์.
์ ๋ 'ํ์ด์ฌ์ ํ์ด์ฌ ๋ต๊ฒ' ๊ฐ์๋ฅผ ๋ค์ผ๋ฉด์ ์์ฃผ ์ ์ตํ ํ์ด์ฌ ์ฝ๋ ์์ฑํ๋ ๋ฒ์ ๋ํด ๋ฐฐ์ธ ์ ์์๋ ๊ฒ ๊ฐ์ต๋๋ค.
ํ์ด์ฌ์ผ๋ก ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ฅผ ํธ์๋ ๋ถ๋ค์ด๋ผ๋ฉด ๋งค์ฐ ์ถ์ฒํ๋ ๊ฐ์ ์ ๋๋ค! : )
'๐ Algorithm > ๐ Python ๋ฌธ๋ฒ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Python ์๋ฃ๊ตฌ์กฐ] Queue (ํ) ๊ตฌํํ๊ธฐ (0) | 2021.01.06 |
---|---|
๋ฆฌ์คํธ(List) / ๋์ ๋๋ฆฌ(Dictionary) ์ ๋ ฌ (0) | 2020.12.29 |
๋ฆฌ์คํธ(List) (1) | 2020.12.28 |