[๐Ÿ“š์ด์ฝ”ํ…Œ #0] ์ฝ”๋”ฉ ํ…Œ์ŠคํŠธ ์ถœ์ œ ๊ฒฝํ–ฅ ๋ถ„์„ ๋ฐ ํŒŒ์ด์ฌ ๋ฌธ๋ฒ• ๐Ÿ”ฅ

์ตœํ˜ธ๋นˆยท2023๋…„ 4์›” 23์ผ
0
post-thumbnail

์ถœ์ฒ˜ : https://www.youtube.com/watch?v=m-9pAwq1o3w&list=PLRx0vPvlEmdAghTr5mXQxGpHjWqSz0dgC


๐Ÿค” ์ฝ”๋”ฉํ…Œ์ŠคํŠธ๋ž€?

  • ๊ธฐ์—…/๊ธฐ๊ด€์—์„œ ์ง์›์ด๋‚˜ ์—ฐ์ˆ˜์ƒ์„ ์„ ๋ฐœํ•˜๊ธฐ ์œ„ํ•œ ๋ชฉ์ ์œผ๋กœ ์‹œํ–‰๋˜๋Š” ์ผ์ข…์˜ ๋ฌธ์ œ ํ’€์ด ์‹œํ—˜
  • ๊ณต๊ฐœ์ฑ„์šฉ์„ ํ•˜๋Š” ๊ธฐ์—…์—์„œ๋Š” ์ฝ”๋”ฉ ํ…Œ์ŠคํŠธ๋ฅผ ์ฃผ๋กœ ์ด์šฉํ•ฉ๋‹ˆ๋‹ค.
    • ๋ฌธ์ œ ํ•ด๊ฒฐ ์—ญ๋Ÿ‰์„ ํ‰๊ฐ€ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
    • ์ฑ„์  ์‹œ์Šคํ…œ์„ ํ†ตํ•ด ์‘์‹œ์ž์˜ ์ˆ˜๋ฅผ ํšจ๊ณผ์ ์œผ๋กœ ์ค„์ผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๐Ÿค” ์˜จ๋ผ์ธ ์ €์ง€๋ž€?

  • ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๋Œ€ํšŒ๋‚˜ ์ฝ”๋”ฉํ…Œ์ŠคํŠธ์—์„œ ๋‚˜์˜ฌ ๋ฒ•ํ•œ ๋ฌธ์ œ๋“ค์„ ์‹œํ—˜ํ•ด๋ณด๋Š” ์˜จ๋ผ์ธ ์‹œ์Šคํ…œ
  • ํ•ด์™ธ : ๋ฆฟ์ฝ”๋“œ ์ถ”์ฒœ
  • ๊ตญ๋‚ด : ๋ฐฑ์ค€, ์ฝ”๋“œ์—…, ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค ์ถ”์ฒœ

๐Ÿค“ ์ž์‹ ๋งŒ์˜ ์†Œ์Šค์ฝ”๋“œ ๊ด€๋ฆฌํ•˜๊ธฐ

  • ์ž์‹ ๋งŒ์˜ ์†Œ์Šค์ฝ”๋“œ๋ฅผ ๊ด€๋ฆฌํ•˜๋Š” ์Šต๊ด€
  • ์ž์‹ ์ด ์ž์ฃผ ์‚ฌ์šฉํ•˜๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜ ์ฝ”๋“œ๋ฅผ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌํ™”
  • ํŒ€ ๋…ธํŠธ ์˜ˆ์‹œ) https://github.com/ndb796/Python-Competitive-Programming-Team-Notes

๐ŸŒ IT ๊ธฐ์—… ์ฝ”๋”ฉ ํ…Œ์ŠคํŠธ ์ถœ์ œ ๊ฒฝํ–ฅ (2016 ~ 2019)

  • ๊ฐ€์žฅ ์ถœ์ œ ๋นˆ๋„๊ฐ€ ๋†’์€ ์•Œ๊ณ ๋ฆฌ์ฆ˜ ์œ ํ˜•
    • ๊ทธ๋ฆฌ๋”” (์‰ฌ์šด ๋‚œ์ด๋„)
    • ๊ตฌํ˜„
    • DFS/BFS๋ฅผ ํ™œ์šฉํ•œ ํƒ์ƒ‰


๐ŸŒ ์ฃผ์š” ๊ธฐ์—… ์ฝ”๋”ฉํ…Œ์ŠคํŠธ ์œ ํ˜• ๋ถ„์„

์นด์นด์˜ค ์ฝ”๋”ฉ ํ…Œ์ŠคํŠธ ๋ฌธ์ œ ํ•ด์„ค ๋ชจ์•„๋ณด๊ธฐ
๐Ÿ‘‰๐Ÿป https://tech.kakao.com/careers/

  • 2018
  • 2019

๐Ÿ“ ๊ธฐ์—…๋ณ„ ์œ ํ˜• ์ •๋ฆฌ

์‚ผ์„ฑ : ์™„์ „ ํƒ์ƒ‰, DFS/BFS & ๊ฑฐ์˜ ๋‹ค ๋งž์•„์•ผ ํ•จ
์นด์นด์˜ค : ๋‹ค์–‘ํ•œ ๋ฌธ์ œ ์œ ํ˜•, ๊ตฌํ˜„(ํŠนํžˆ ๋ฌธ์ž์—ด) & ์ ˆ๋ฐ˜ ์ •๋„๋ฉด ํ‰ํƒ€
๋ผ์ธ : ๊ตฌํ˜„, ํƒ์ƒ‰, ๋‹ค์ด๋‚˜๋ฏน ํ”„๋กœ๊ทธ๋ž˜๋ฐ & ์ ˆ๋ฐ˜ ์ •๋„๋ฉด ํ‰ํƒ€



๐Ÿค“ ์•Œ๊ณ ๋ฆฌ์ฆ˜ ์„ฑ๋Šฅ ํ‰๊ฐ€


๋ณต์žก๋„

  • ์•Œ๊ณ ๋ฆฌ์ฆ˜์˜ ์„ฑ๋Šฅ์„ ๋‚˜ํƒ€๋‚ด๋Š” ์ฒ™๋„, ๋‚ฎ์„ ์ˆ˜๋ก ์ข‹๋‹ค.

์‹œ๊ฐ„ ๋ณต์žก๋„: ํŠน์ •ํ•œ ํฌ๊ธฐ์˜ ์ž…๋ ฅ์— ๋Œ€ํ•˜์—ฌ ์•Œ๊ณ ๋ฆฌ์ฆ˜์˜ ์ˆ˜ํ–‰ ์‹œ๊ฐ„ ๋ถ„์„
๊ณต๊ฐ„ ๋ณต์žก๋„: ํŠน์ •ํ•œ ํฌ๊ธฐ์˜ ์ž…๋ ฅ์— ๋Œ€ํ•˜์—ฌ ์•Œ๊ณ ๋ฆฌ์ฆ˜์˜ ๋ฉ”๋ชจ๋ฆฌ ์‚ฌ์šฉ๋Ÿ‰ ๋ถ„์„

๋น…์˜ค ํ‘œ๊ธฐ๋ฒ•

  • ํ•จ์ˆ˜์˜ ์ƒํ•œ๋งŒ์„ ๋‚˜ํƒ€๋ƒ„ ๐Ÿ‘‰๐Ÿป ๊ทนํ•œ๊ณผ ๋น„์Šท

ํŒŒ์ด์ฌ ์ž๋ฃŒํ˜• ๋ณ„ ์ฃผ์š” ์—ฐ์‚ฐ์ž์˜ ์‹œ๊ฐ„ ๋ณต์žก๋„ ๋งํฌ
๐Ÿ‘‰๐Ÿป https://wayhome25.github.io/python/2017/06/14/time-complexity/


์˜ˆ์‹œ 1) ์—ฐ์‚ฐ ํšŸ์ˆ˜๊ฐ€ 3N^3 + 5N^2 + 1,000,000์ธ ์•Œ๊ณ ๋ฆฌ์ฆ˜์ด

๐Ÿ‘‰๐Ÿป ์‹œ๊ฐ„ ๋ณต์žก๋„: O(N^3) ์ฐจ์ˆ˜๊ฐ€ ๊ฐ€์žฅ ํฐ ํ•ญ๋งŒ ๋‚จ๊ธฐ๋ฏ€๋กœ โœ…

์˜ˆ์‹œ 2) N๊ฐœ์˜ ๋ฐ์ดํ„ฐ์˜ ํ•ฉ์„ ๊ณ„์‚ฐํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ ์˜ˆ์ œ

array = [3, 5, 1, 2, 4]	# 5๊ฐœ์˜ ๋ฐ์ดํ„ฐ(N = 5)
summary = 0 	# ํ•ฉ๊ณ„๋ฅผ ์ €์žฅํ•  ๋ณ€์ˆ˜

# ๋ชจ๋“  ๋ฐ์ดํ„ฐ๋ฅผ ํ•˜๋‚˜์”ฉ ํ™•์ธํ•˜๋ฉฐ ํ•ฉ๊ณ„๋ฅผ ๊ณ„์‚ฐ
for x in array:
summary += x

# ๊ฒฐ๊ณผ๋ฅผ ์ถœ๋ ฅ
print (summary)

๐Ÿ‘‰๐Ÿป ์‹œ๊ฐ„ ๋ณต์žก๋„: O(N)

์˜ˆ์‹œ 3) 2์ค‘ ๋ฐ˜๋ณต๋ฌธ์„ ์ด์šฉํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ ์˜ˆ์ œ

array = [3, 5, 1, 2, 4]	 # 5๊ฐœ์˜ ๋ฐ์ดํ„ฐ(N = 5)
for i in array:
	for j in array:
		temp = i * j
print(temp)

๐Ÿ‘‰๐Ÿป ์‹œ๊ฐ„ ๋ณต์žก๋„: O(N^2)

โ€ข ์ฐธ๊ณ ๋กœ ๋ชจ๋“  2์ค‘ ๋ฐ˜๋ณต๋ฌธ์˜ ์‹œ๊ฐ„ ๋ณต์žก๋„๊ฐ€ O(N^2)์ธ ๊ฒƒ์€ ์•„๋‹ˆ๋‹ค!
โ€ข ์ฝ”๋“œ ๋‚ด๋ถ€์—์„œ ๋‹ค๋ฅธ ํ•จ์ˆ˜๋ฅผ ํ˜ธ์ถœํ•œ๋‹ค๋ฉด ๊ทธ ํ•จ์ˆ˜์˜ ์‹œ๊ฐ„ ๋ณต์žก๋„๊นŒ์ง€ ๊ณ ๋ คํ•ด์•ผ ํ•จ

๐Ÿ“ ์‹œ๊ฐ„ ๋ณต์žก๋„ ์ •๋ฆฌ

์š”๊ตฌ์‚ฌํ•ญ์— ๋”ฐ๋ผ ์ ์ ˆํ•œ ์•Œ๊ณ ๋ฆฌ์ฆ˜ ์„ค๊ณ„ํ•˜๊ธฐ ๐Ÿ“

๋ฌธ์ œ์—์„œ ๊ฐ€์žฅ ๋จผ์ € ํ™•์ธํ•ด์•ผ ํ•˜๋Š” ๋‚ด์šฉ์€ ์‹œ๊ฐ„์ œํ•œ(์ˆ˜ํ–‰์‹œ๊ฐ„ ์š”๊ตฌ์‚ฌํ•ญ)
์‹œ๊ฐ„์ œํ•œ์ด 1์ดˆ์ธ ๋ฌธ์ œ๋ฅผ ๋งŒ๋‚ฌ์„ ๋•Œ, ์ผ๋ฐ˜์ ์ธ ๊ธฐ์ค€์€ ์•„๋ž˜์™€ ๊ฐ™๋‹ค.

  • N์˜ ๋ฒ”์œ„๊ฐ€ 500์ธ ๊ฒฝ์šฐ: ์‹œ๊ฐ„ ๋ณต์žก๋„๊ฐ€ O(N^3)์ธ ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ์„ค๊ณ„
  • N์˜ ๋ฒ”์œ„๊ฐ€ 2,000์ธ ๊ฒฝ์šฐ: ์‹œ๊ฐ„ ๋ณต์žก๋„๊ฐ€ O(N^2)์ธ ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ์„ค๊ณ„
  • N์˜ ๋ฒ”์œ„๊ฐ€ 100.000์ธ ๊ฒฝ์šฐ: ์‹œ๊ฐ„ ๋ณต์žก๋„๊ฐ€ O(NLogN)์ธ ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ์„ค๊ณ„
  • N์˜ ๋ฒ”์œ„๊ฐ€ 10,000,000์ธ ๊ฒฝ์šฐ: ์‹œ๊ฐ„ ๋ณต์žก๋„๊ฐ€ O(N)์ธ ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ์„ค๊ณ„

์†Œ์Šค์ฝ”๋“œ๋ฅผ ํ†ตํ•œ ์ˆ˜ํ–‰์‹œ๊ฐ„ ์ธก์ •

import time
start_time = time.time() # ์ธก์ • ์‹œ์ž‘

# ํ”„๋กœ๊ทธ๋žจ ์†Œ์Šค์ฝ”๋“œ
end_time = time.time() # ์ธก์ • ์ข…๋ฃŒ
print("time:", end_time - start_time) # ์ˆ˜ํ–‰ ์‹œ๊ฐ„ ์ถœ๋ ฅ



๐Ÿ“š ํŒŒ์ด์ฌ ๋ฌธ๋ฒ•(์ผ๋ถ€)


์‹ค์ˆ˜ํ˜•

# ์†Œ์ˆ˜๋ถ€๊ฐ€ 0์ผ ๋•Œ 0์„ ์ƒ๋žต
a = 5.
print(a)	# 5.0

# ์ •์ˆ˜๋ถ€๊ฐ€ 0์ผ ๋•Œ 0์„ ์ƒ๋žต
b = -.7
print(b)	# -0.7

์ง€์ˆ˜ ํ‘œํ˜„ ๋ฐฉ์‹

# 1,000,000,000์˜ ์ง€์ˆ˜ ํ‘œํ˜„ ๋ฐฉ์‹
a = 1e9
print(a)

# 752.5
a = 75.25e1
print(a)

# 3.954
a = 3954e-3
print(a)

๋ฆฌ์ŠคํŠธ ์ปดํ”„๋ฆฌํ—จ์…˜ (์ข‹์€ ์˜ˆ์‹œ)

# N X M ํฌ๊ธฐ์˜ 2์ฐจ์› ๋ฆฌ์ŠคํŠธ ์ดˆ๊ธฐํ™”
n = 4
m = 3
array = [[0] * m for m in range (n)]
print(array)


๋ฆฌ์ŠคํŠธ ์ปดํ”„๋ฆฌํ—จ์…˜ (์ž˜๋ชป๋œ ์˜ˆ์‹œ)

# N X M ํฌ๊ธฐ์˜ 2์ฐจ์› ๋ฆฌ์ŠคํŠธ ์ดˆ๊ธฐํ™” (์ž˜๋ชป๋œ ๋ฐฉ๋ฒ•)
n = 4
m = 3
array = [[0] * m] * n
print(array)

array[1][1] = 5
print(array)


ํŠœํ”Œ์„ ์‚ฌ์šฉํ•˜๋ฉด ์ข‹์€ ๊ฒฝ์šฐ

  • ์„œ๋กœ ๋‹ค๋ฅธ ์„ฑ์งˆ์˜ ๋ฐ์ดํ„ฐ๋ฅผ ๋ฌถ์–ด์„œ ๊ด€๋ฆฌํ•ด์•ผ ํ•  ๋•Œ
    โ€ข ์ตœ๋‹จ ๊ฒฝ๋กœ ์•Œ๊ณ ๋ฆฌ์ฆ˜์—์„œ๋Š” (๋น„์šฉ, ๋…ธ๋“œ ๋ฒˆํ˜ธ)์˜ ํ˜•ํƒœ๋กœ ํŠœํ”Œ ์ž๋ฃŒํ˜•์„ ์ž์ฃผ ์‚ฌ์šฉํ•œ๋‹ค.
  • ๋ฐ์ดํ„ฐ์˜ ๋‚˜์—ด์„ ํ•ด(Hashing)์˜ ํ‚ค ๊ฐ’์œผ๋กœ ์‚ฌ์šฉํ•ด์•ผ ํ•  ๋•Œ
    โ€ข ํŠœํ”Œ์€ ๋ณ€๊ฒฝ์ด ๋ถˆ๊ฐ€๋Šฅํ•˜๋ฏ€๋กœ ๋ฆฌ์ŠคํŠธ์™€ ๋‹ค๋ฅด๊ฒŒ ํ‚ค ๊ฐ’์œผ๋กœ ์‚ฌ์šฉ๋  ์ˆ˜ ์žˆ๋‹ค.
  • ๋ฆฌ์ŠคํŠธ๋ณด๋‹ค ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ํšจ์œจ์ ์œผ๋กœ ์‚ฌ์šฉํ•ด์•ผ ํ•  ๋•Œ

์ง‘ํ•ฉ ์ž๋ฃŒํ˜•

  • ์ง‘ํ•ฉ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์€ ํŠน์ง•์ด ์žˆ์Šต๋‹ˆ๋‹ค.
    โ€ข ์ค‘๋ณต์„ ํ—ˆ์šฉํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.
    โ€ข ์ˆœ์„œ๊ฐ€ ์—†์Šต๋‹ˆ๋‹ค.
  • ์ง‘ํ•ฉ์€ ๋ฆฌ์ŠคํŠธ ํ˜น์€ ๋ฌธ์ž์—ด์„ ์ด์šฉํ•ด์„œ ์ดˆ๊ธฐํ™”ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
    โ€ข ์ด๋•Œ set() ํ•จ์ˆ˜๋ฅผ ์ด์šฉํ•ฉ๋‹ˆ๋‹ค.
  • ํ˜น์€ ์ค‘๊ด„ํ˜ธ ({})์•ˆ์— ๊ฐ ์›์†Œ๋ฅผ ์ฝค๋งˆ(,)๋ฅผ ๊ธฐ์ค€์œผ๋กœ ๊ตฌ๋ถ„ํ•˜์—ฌ ์‚ฝ์ž…ํ•จ์œผ๋กœ์จ ์ดˆ๊ธฐํ™” ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
  • ๋ฐ์ดํ„ฐ์˜ ์กฐํšŒ ๋ฐ ์ˆ˜์ •์— ์žˆ์–ด์„œ 0(1)์˜ ์‹œ๊ฐ„์— ์ฒ˜๋ฆฌํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
# ์ง‘ํ•ฉ ์ž๋ฃŒํ˜• ์ดˆ๊ธฐํ™” ๋ฐฉ๋ฒ• 1
data = set([1, 1, 2, 3, 4, 4, 5])
print (data)	# ์‹คํ–‰ ๊ฒฐ๊ณผ : {1, 2, 3, 4, 5}

# ์ง‘ํ•ฉ ์ž๋ฃŒํ˜• ์ดˆ๊ธฐํ™” ๋ฐฉ๋ฒ• 2
data = {1, 1, 2, 3, 4, 4, 5}
print (data)	# ์‹คํ–‰ ๊ฒฐ๊ณผ : {1, 2, 3, 4, 5}

์ง‘ํ•ฉ ์ž๋ฃŒํ˜•์˜ ์—ฐ์‚ฐ

a = set([1, 2, 3, 4, 5])
b = set([3, 4, 5, 6, 7])
# ํ•ฉ์ง‘ํ•ฉ
print(a ! b)   # {1, 2, 3, 4, 5, 6, 7}
# ๊ต์ง‘ํ•ฉ
print(a & b)   # {3, 4, 5}
# ์ฐจ์ง‘ํ•ฉ
print(a - b)   # {1, 2}

# ์ƒˆ๋กœ์šด ์›์†Œ ์ถ”๊ฐ€
a.add(4)

# ์ƒˆ๋กœ์šด ์›์†Œ ์—ฌ๋Ÿฌ ๊ฐœ ์ถ”๊ฐ€
a.update([5, 6])

# ํŠน์ •ํ•œ ๊ฐ’์„ ๊ฐ–๋Š” ์›์†Œ ์‚ญ์ œ
a.remove(3)

๋น ๋ฅด๊ฒŒ ์ž…๋ ฅ ๋ฐ›๊ธฐ

โ€ข ์‚ฌ์šฉ์ž๋กœ๋ถ€ํ„ฐ ์ž…๋ ฅ์„ ์ตœ๋Œ€ํ•œ ๋น ๋ฅด๊ฒŒ ๋ฐ›์•„์•ผ ํ•˜๋Š” ๊ฒฝ์šฐ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค.
โ€ข ํŒŒ์ด์ฌ์˜ ๊ฒฝ์šฐ sys ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ์— ์ •์˜๋˜์–ด ์žˆ๋Š” sys.stdin.readline() ๋ฉ”์„œ๋“œ๋ฅผ ์ด์šฉํ•ฉ๋‹ˆ๋‹ค.
โ€ข ๋‹จ, ์ž…๋ ฅ ํ›„ ์—”ํ„ฐ(Enter)๊ฐ€ ์ค„ ๋ฐ”๊ฟˆ ๊ธฐํ˜ธ๋กœ ์ž…๋ ฅ๋˜๋ฏ€๋กœ rstrip() ๋ฉ”์„œ๋“œ๋ฅผ ํ•จ๊ป˜ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

import sys
# ๋ฌธ์ž์—ด ์ž…๋ ฅ ๋ฐ›๊ธฐ
data = sys.stdin.readline().rstrip()
print(data)

global ํ‚ค์›Œ๋“œ

  • global ํ‚ค์›Œ๋“œ๋กœ ๋ณ€์ˆ˜๋ฅผ ์ง€์ •ํ•˜๋ฉด ํ•ด๋‹น ํ•จ์ˆ˜์—์„œ๋Š” ์ง€์—ญ ๋ณ€์ˆ˜๋ฅผ ๋งŒ๋“ค์ง€ ์•Š๊ณ , ํ•จ์ˆ˜ ๋ฐ”๊นฅ์— ์„ ์–ธ๋œ ๋ณ€์ˆ˜๋ฅผ ๋ฐ”๋กœ ์ฐธ์กฐํ•˜๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.
a = 0

def func():
	global a 
    a += 1
    
for i in range(10):
	func()

print(a)    # 10

๋žŒ๋‹ค ํ‘œํ˜„์‹

  • ๋žŒ๋‹ค ํ‘œํ˜„์‹์„ ์ด์šฉํ•˜๋ฉด ํ•จ์ˆ˜๋ฅผ ๊ฐ„๋‹จํ•˜๊ฒŒ ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
  • ํŠน์ •ํ•œ ๊ธฐ๋Šฅ์„ ์ˆ˜ํ–‰ํ•˜๋Š” ํ•จ์ˆ˜๋ฅผ ํ•œ ์ค„์— ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ๋‹ค๋Š” ์ ์ด ํŠน์ง•์ž…๋‹ˆ๋‹ค.
# ๋žŒ๋‹ค ํ‘œํ˜„์‹์œผ๋กœ ๊ตฌํ˜„ํ•œ ๋”ํ•˜๊ธฐ ๋ฉ”์„œ๋“œ
print((lambda a, b: a + b)(3, 7))   # 10

๋žŒ๋‹ค ํ‘œํ˜„์‹ ์˜ˆ์‹œ: ์—ฌ๋Ÿฌ ๊ฐœ์˜ ๋ฆฌ์ŠคํŠธ์— ์ ์šฉ

list1 = [1, 2, 3, 4, 5]
list2 = [6, 7, 8, 9, 10]

result = map(lambda a, b: a + b, list1, list2)
print(list(result))   # [7, 9, 11, 13, 15]

์‹ค์ „์—์„œ ์œ ์šฉํ•œ ํ‘œ์ค€ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ

  • ๋‚ด์žฅ ํ•จ์ˆ˜: ๊ธฐ๋ณธ ์ž…์ถœ๋ ฅ ํ•จ์ˆ˜๋ถ€ํ„ฐ ์ •๋ ฌ ํ•จ์ˆ˜๊นŒ์ง€ ๊ธฐ๋ณธ์ ์ธ ํ•จ์ˆ˜๋“ค์„ ์ œ๊ณตํ•ฉ๋‹ˆ๋‹ค.
    โ€ข ํŒŒ์ด์ฌ ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•  ๋•Œ ์—†์–ด์„œ๋Š” ์•ˆ ๋˜๋Š” ํ•„์ˆ˜์ ์ธ ๊ธฐ๋Šฅ์„ ํฌํ•จํ•˜๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค.
  • itertools: ํŒŒ์ด์ฌ์—์„œ ๋ฐ˜๋ณต๋˜๋Š” ํ˜•ํƒœ์˜ ๋ฐ์ดํ„ฐ๋ฅผ ์ฒ˜๋ฆฌํ•˜๊ธฐ ์œ„ํ•œ ์œ ์šฉํ•œ ๊ธฐ๋Šฅ๋“ค์„ ์ œ๊ณตํ•ฉ๋‹ˆ๋‹ค.
    โ€ข ํŠนํžˆ ์ˆœ์—ด๊ณผ ์กฐํ•ฉ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋Š” ์ฝ”๋”ฉ ํ…Œ์ŠคํŠธ์—์„œ ์ž์ฃผ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค.
  • heapq: ํž™(Heap) ์ž๋ฃŒ๊ตฌ์กฐ๋ฅผ ์ œ๊ณตํ•ฉ๋‹ˆ๋‹ค.
    โ€ข ์ผ๋ฐ˜์ ์œผ๋กœ ์šฐ์„ ์ˆœ์œ„ ํ ๊ธฐ๋Šฅ์„ ๊ตฌํ˜„ํ•˜๊ธฐ ์œ„ํ•ด ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค.
  • bisect: ์ด์ง„ ํƒ์ƒ‰(Binary Search) ๊ธฐ๋Šฅ์„ ์ œ๊ณตํ•ฉ๋‹ˆ๋‹ค.
  • collections: ๋ฑ(deque), ์นด์šดํ„ฐ(Counter) ๋“ฑ์˜ ์œ ์šฉํ•œ ์ž๋ฃŒ๊ตฌ์กฐ๋ฅผ ํฌํ•จํ•ฉ๋‹ˆ๋‹ค.
  • math: ํ•„์ˆ˜์ ์ธ ์ˆ˜ํ•™์  ๊ธฐ๋Šฅ์„ ์ œ๊ณตํ•ฉ๋‹ˆ๋‹ค.
    โ€ข ํŒฉํ† ๋ฆฌ์–ผ, ์ œ๊ณฑ๊ทผ, ์ตœ๋Œ€๊ณต์•ฝ์ˆ˜(GCD), ์‚ผ๊ฐํ•จ์ˆ˜ ๊ด€๋ จ ํ•จ์ˆ˜๋ถ€ํ„ฐ ํŒŒ์ด(pi)์™€ ๊ฐ™์€ ์ƒ์ˆ˜๋ฅผ ํฌํ•จํ•ฉ๋‹ˆ๋‹ค.

์ˆœ์—ด๊ณผ ์กฐํ•ฉ

์ˆœ์—ด: ์„œ๋กœ ๋‹ค๋ฅธ n๊ฐœ์—์„œ ์„œ๋กœ ๋‹ค๋ฅธ r๊ฐœ๋ฅผ ์„ ํƒํ•˜์—ฌ ์ผ๋ ฌ๋กœ ๋‚˜์—ดํ•˜๋Š” ๊ฒƒ

  • {'A', 'B', 'C'}์—์„œ ์„ธ ๊ฐœ๋ฅผ ์„ ํƒํ•˜์—ฌ ๋‚˜์—ดํ•˜๋Š” ๊ฒฝ์šฐ: 'ABC', 'ACB', 'BAC', 'BCA', 'CAB', 'CBA'
from itertools import permutations

data = ['A', 'B', 'C']	# ๋ฐ์ดํ„ฐ ์ค€๋น„
result = list(permutations(data, 3))  # ๋ชจ๋“  ์ˆœ์—ด ๊ตฌํ•˜๊ธฐ

print(result)

# ์‹คํ–‰ ๊ฒฐ๊ณผ
[('A','B','C'), ('A','C','B'), ('B','A','C'), 
('B', 'C', 'A'), ('C', 'A', 'B'), ('C', 'B', 'A')]

์กฐํ•ฉ: ์„œ๋กœ ๋‹ค๋ฅธ n๊ฐœ์—์„œ ์ˆœ์„œ์— ์ƒ๊ด€ ์—†์ด ์„œ๋กœ ๋‹ค๋ฅธ r๊ฐœ๋ฅผ ์„ ํƒํ•˜๋Š” ๊ฒƒ

  • {'A', 'B', 'C'}์—์„œ ์ˆœ์„œ๋ฅผ ๊ณ ๋ คํ•˜์ง€ ์•Š๊ณ  ๋‘ ๊ฐœ๋ฅผ ๋ฝ‘๋Š” ๊ฒฝ์šฐ: 'AB', 'AC', 'BC'
from itertools import combinations

data= ['A', 'B', 'C']  # ๋ฐ์ดํ„ฐ ์ค€๋น„
result = list(combinations(data, 2)) # 2๊ฐœ๋ฅผ ๋ฝ‘๋Š” ๋ชจ๋“  ์กฐํ•ฉ ๊ตฌํ•˜๊ธฐ

print(result)

# ์‹คํ–‰ ๊ฒฐ๊ณผ: [('A','B'), ('A','C'), ('B','C')]

์ค‘๋ณต ์ˆœ์—ด๊ณผ ์ค‘๋ณต ์กฐํ•ฉ

from itertools import product

data=['A', 'B', 'C'] # ๋ฐ์ดํ„ฐ ์ค€๋น„

# 2๊ฐœ๋ฅผ ๋ฝ‘๋Š” ๋ชจ๋“  ์ˆœ์—ด ๊ตฌํ•˜๊ธฐ (์ค‘๋ณต ํ—ˆ์šฉ)
result = list(product(data, repeat=2)) 

print(result)




from itertools import combinations_with_replacement

data=['A', 'B', 'C'] # ๋ฐ์ดํ„ฐ ์ค€๋น„

# 2๊ฐœ๋ฅผ ๋ฝ‘๋Š” ๋ชจ๋“  ์กฐํ•ฉ ๊ตฌํ•˜๊ธฐ (์ค‘๋ณต ํ—ˆ์šฉ)
result = list(combinations_with_replacement(data, 2)) 

print(result)
profile
๋ฐฑ์—”๋“œ ๋ณ‘์•„๋ฆฌ ๐Ÿฅ

0๊ฐœ์˜ ๋Œ“๊ธ€