ํŒŒ์ด์ฌ์„ ํŒŒ์ด์ฌ ๋‹ต๊ฒŒ

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. ์ˆซ์ž๋ฅผ ์ฐจ๋ก€๋กœ ๊ณฑํ•ด ๋‚˜์˜จ ์ˆ˜๊ฐ€ ์ œ๊ณฑ์ˆ˜1๊ฐ€ ๋˜๋ฉด found๋ฅผ ์ถœ๋ ฅํ•˜๊ณ 
  2. ๋ชจ๋“  ์ˆ˜๋ฅผ ๊ณฑํ•ด๋„ ์ œ๊ณฑ์ˆ˜๊ฐ€ ๋‚˜์˜ค์ง€ ์•Š์•˜๋‹ค๋ฉด 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์˜ ์œ ์šฉํ•œ ๋ฌธ๋ฒ•๊ณผ ๋ชจ๋“ˆ์— ๋Œ€ํ•ด ์•Œ์•„๋ณด์•˜๋Š”๋ฐ์š”. 

์ €๋Š” 'ํŒŒ์ด์ฌ์„ ํŒŒ์ด์ฌ ๋‹ต๊ฒŒ' ๊ฐ•์˜๋ฅผ ๋“ค์œผ๋ฉด์„œ ์•„์ฃผ ์œ ์ตํ•œ ํŒŒ์ด์ฌ ์ฝ”๋“œ ์ž‘์„ฑํ•˜๋Š” ๋ฒ•์— ๋Œ€ํ•ด ๋ฐฐ์šธ ์ˆ˜ ์žˆ์—ˆ๋˜ ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค. 

ํŒŒ์ด์ฌ์œผ๋กœ ์•Œ๊ณ ๋ฆฌ์ฆ˜ ๋ฌธ์ œ๋ฅผ ํ‘ธ์‹œ๋Š” ๋ถ„๋“ค์ด๋ผ๋ฉด ๋งค์šฐ ์ถ”์ฒœํ•˜๋Š” ๊ฐ•์˜ ์ž…๋‹ˆ๋‹ค! : )

๋ฐ˜์‘ํ˜•