[์๋ฃํ]
[์กฐ๊ฑด๋ฌธ, ๋ฐ๋ณต๋ฌธ๊ณผ ํจ์]
[์ ์ถ๋ ฅ]
[์ฃผ์ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ]
- ์ ์ํ : ์์, ์ ์, 0
- ์ค์ํ
- ์์๋ถ๋ ์ ์๋ถ๊ฐ 0์ผ ๋ ์๋ต ๊ฐ๋ฅ ex) .7, -5.
- e(E) ํ๊ธฐ๋ฒ:
- ์ ํจ์ซ์e^(์ง์) = ์ ํจ์ซ์ x 10^(์ง์) โ ์๋ฆฟ์ ์ค์๋ฅผ ํ ํ๋ฅ ์ ์ค์
- ๋ฌดํ(INF)๋ฅผ 1e9(10์ต)๋ก ํํํ๊ธฐ๋ ํจ
- round(์ค์, ๋ฐ์ฌ๋ฆผํ ์์น - 1):
- round๊ฐ ํ์ํ ์ด์ ? - ๋ณดํต ์์์ ๋ค์ฏ๋ฒ์งธ ์๋ฆฌ์์ ๋ฐ์ฌ๋ฆผํ ๊ฒฐ๊ณผ๊ฐ ๊ฐ์ผ๋ฉด ์ ๋ต์ผ๋ก ์ธ์
a = 0.3 + 0.6 print(a) ==== 0.899999999.... #2์ง์๋ก 0.9๋ฅผ ์ ํํ ํํํ ๋ฐฉ๋ฒ์ด ์์
- round VS print(โ%.fโ, %_)
- round(1.4736, 2) โ 1.5 (0์ ์๋ต ๋จ)
- print(โ%.2fโ %์ค์๋ณ์)์ 1.4736์ ๋ฃ์ผ๋ฉด? โ 1.50
- round๊ฐ ํ์ํ ์ด์ ? - ๋ณดํต ์์์ ๋ค์ฏ๋ฒ์งธ ์๋ฆฌ์์ ๋ฐ์ฌ๋ฆผํ ๊ฒฐ๊ณผ๊ฐ ๊ฐ์ผ๋ฉด ์ ๋ต์ผ๋ก ์ธ์
- ์ฐ์ฐ
-
์ฝ๋๋ฅผ ์งค ๋ 0์ ํญ์ ์์ธ์ ์ผ๋ก ๊ฒ์ฌํ๊ธฐ
-
ํ์ด์ฌ3์์ ์ ์/์ ์๋ ์ค์ ๊ฐ์ด ์ ์๋ผ๋ ์ค์๋ก ๋์ด ex) 4/2 = 2.0
์ข ๋ฅ ์์ ์ผ๋ฐ ์ฐ์ฐ์ +, -, *, /(์ผ๋ฐ์ ์ธ ๋๋๊ธฐ), //(๋ชซ), %(๋๋จธ์ง), **(๊ฑฐ๋ญ์ ๊ณฑ) ์ฌํํธ ์ฐ์ฐ์ << N (2^N๋ฐฐ), >> N ((1/2)^N๋ฐฐ) ๋นํธ๋จ์ ์ฐ์ฐ์ ~(not), &(and), |(or), ^(xor)
- C์ธ์ด์ ๋์ผํ๊ฒ ์์์ ๋ชซ ๊ตฌํ๊ธฐ: int(a/b)
- ๋ฆฌ์คํธ ์์ฑ
- list() or []
- 1์ฐจ์ ๋ฐฐ์ด ์ด๊ธฐํ: arr = [0] * N
- 2์ฐจ์ ๋ฐฐ์ด ์ด๊ธฐํ: arr = [[0] * N for _ in range(M)]
- ์ธ๋ฑ์ฑ๊ณผ ์ฌ๋ผ์ด์ฑ
- ์ธ๋ฑ์ค๋ ์,์์ ์ ์ ๋ชจ๋ ๊ฐ๋ฅ.
- ์์ ์ ์์ ๊ฒฝ์ฐ ๊ฑฐ๊พธ๋ก ํ์ ex) arr[-1] => ๋ง์ง๋ง ์์ ๊ฐ์ ธ์ค๊ธฐ
- arr[a:b(:step)] โ a๋ถํฐ b-1 ๊น์ง ๊ฐ์ ธ์ค๊ธฐ. step์ ์ต์ & ์์๋ก ๋ฃ์ผ๋ฉด ๋ค์์๋ถํฐ ๊ฐ์ ธ์ค๊ธฐ
- ๋ฆฌ์คํธ ์ปดํ๋ฆฌํจ์ (์์)
- array = [i for i in range(20) if i % 2 == 1] โ 0~19๊น์ง์ ์ ์ค ํ์๋ง ํฌํจํ๋ ๋ฆฌ์คํธ ์์ฑ
- array = [i * i for i in range(1,10)] โ 1~9๊น์ง์ ์์ ์ ๊ณฑ ๊ฐ์ ํฌํจํ๋ ๋ฆฌ์คํธ
- 2์ฐจ์ ๋ฐฐ์ด ์ด๊ธฐํ ๋ฐฉ๋ฒ๋ ์ฌ๊ธฐ์ ํด๋น
- 2์ฐจ์ ๋ฐฐ์ด flatten
# 2์ฐจ์ -> 1์ฐจ์ flatten_arr = [y for x in arr for y in x]
-
spread์ ์ ์ฌํ ๋ฌธ๋ฒ = unpacking
numbers = [1, 2, 3, 4, 5, 6] # unpacking์ ์ข๋ณ์ ๋ฆฌ์คํธ ๋๋ ํํ์ ํํ๋ฅผ ๊ฐ์ ธ์ผํ๋ฏ๋ก ๋จ์ผ unpacking์ ๊ฒฝ์ฐ *a๊ฐ ์๋ *a,๋ฅผ ์ฌ์ฉ *a, = numbers # a = [1, 2, 3, 4, 5, 6] *a, b = numbers # a = [1, 2, 3, 4, 5] # b = 6 a, *b, = numbers # a = 1 # b = [2, 3, 4, 5, 6] a, *b, c = numbers # a = 1 # b = [2, 3, 4, 5] # c = 6
-
ํ์ฉ
์ฌ์ฉ๋ฒ ์ค๋ช ์๊ฐ ๋ณต์ก๋ append(๊ฐ) ๋งจ ๋ค์ ์์ ํ๋ ์ฝ์ O(1) extend(๊ฐ) ๋ฆฌ์คํธ ์ฐ์ฅ O(len(โฆ)) - ํ์ฅ ๊ธธ์ด์ ๋ฐ๋ผ pop(index) ํด๋น ์ธ๋ฑ์ค์ ์์ ์ ๊ฑฐ. ๊ธฐ๋ณธ๊ฐ์ -1 pop()์ ๊ฒฝ์ฐ O(1), ๊ทธ ์ธ์ ์ธ๋ฑ์ค๋ O(N) sort() ์ค๋ฆ์ฐจ์ ์ ๋ ฌ. reverse = True ์ธ์๋ฅผ ๋ฃ์ด์ฃผ๋ฉด ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ & key ์ธ์๋ก ์ ๋ ฌ ํจ์ ๋ฃ์ด์ฃผ๊ธฐ ๊ฐ๋ฅ O(NlogN) reverse() ์์์ ์์๋ฅผ ๋ชจ๋ ๋ค์ง๊ธฐ O(N) insert(์ฝ์ ํ ์ธ๋ฑ์ค, ๊ฐ) ํน์ ์์น์ ์์ ์ฝ์ O(N) count(๊ฐ) ํน์ ๊ฐ์ ๊ฐ์ง๋ ๋ฐ์ดํฐ ๊ฐ์ ์ธ๊ธฐ O(N) remove(๊ฐ) ํน์ ๊ฐ์ ๊ฐ์ง๋ ์์ ์ ๊ฑฐ. ์ฌ๋ฌ๊ฐ๊ฐ ์์ผ๋ฉด ํ๋๋ง ์ ๊ฑฐํ๋ค. ๊ทธ ๊ฐ์ด ์๋ค๋ฉด ์๋ฌ ๋ฐ์(in ์ผ๋ก ์ ํ์ธ ํ์) O(N) x in array ๋ฆฌ์คํธ์ ํน์ ํ ๊ฐ์ด ์๋์ง ๊ฒ์ฌ O(N) index(x) ๋ฆฌ์คํธ์์ ํน์ ์์์ ์ธ๋ฑ์ค ์ฐพ๊ธฐ -
์ถ๊ฐ
- ํน์ ์์๋ฅผ ๋ชจ๋ ์ ๊ฑฐํ๋ ๋ฉ์๋๋ ์์. ๋์ ์๋์ ๊ฐ์ ๋ฐฉ์ ์ฌ์ฉ
a = [1,2,3,4,5,6] remove_set = {3,4} result = [i for i in a if i not in remove_set]
-
2์ฐจ์ ๋ฐฐ์ด ์์ธ
# ๋ณต์ฌ ๋ฐฉ๋ฒ1. deepcopy() import copy a = [[1,2],[3,4]] b = copy.deepcopy(a) # ๋ณต์ฌ ๋ฐฉ๋ฒ2. ์๋ก์ด ๋ฐฐ์ด ์์ฑ a = [[1, 2], [3, 4]] b = [arr[:] for arr in a]
# count() test=[0,0,0] test2 = [[0,0,0]] print(test.count(0), test2.count(0)) ======= 3 0
# ์ค๋ณต์ ๊ฑฐ - tuple๋ก ๋ฌถ์ด์ค ํ set() # ex) ๋์ผํ (x,y) ์ ์ด ๋ค์ด๊ฐ์ง ์๋๋ก ํ๊ธฐ a = [] a.append((element1, element2)) # ...๋ฐ๋ณต a = set(a)
# 2์ฐจ์ ๋ฐฐ์ด ์ ๋ ฌ -> key ๋ฃ์ด์ฃผ๊ธฐ a = [(1, 2), (0, 1), (5, 2), (5, 1), (3, 0)] sorted(a) # ๋ํดํธ - 0์ธ๋ฑ์ค ๋จผ์ ๊ทธ๋ค์ 1์ธ๋ฑ์ค... [(0, 1), (1, 2), (3, 0), (5, 1), (5, 2)] sorted(a, key=lambda x: x[0]) # 0 ์ธ๋ฑ์ค์ ๋ํด์๋ง ์ ๋ ฌ, 1์ธ๋ฑ์ค ์ ๋ ฌ x [(0, 1), (1, 2), (3, 0), (5, 2), (5, 1)]
- ์ด๊ธฐํ
- ""๋ '' ์ฌ์ฉ. ํฐ ๋ฐ์ดํ๋ก ๊ตฌ์ฑํ๋ ๊ฒฝ์ฐ ๋ด๋ถ์ ์ผ๋ก ์์ ๋ฐ์ดํ ์ฌ์ฉ ๊ฐ๋ฅ(๋ฐ๋๋ ๋ง์ฐฌ๊ฐ์ง)
- ๋ฐฑ์ฌ๋์(\)๋ฅผ ์ฌ์ฉํ๋ฉด ํฐ ๋ฐ์ดํ๋ ์์ ๋ฐ์ดํ๋ฅผ ์ํ๋ ๋งํผ ํฌํจ์ํฌ ์ ์์
- ์ฐ์ฐ
- ๋ง์ : 'a' + 'b' = 'ab'
- ๊ณฑ์ : 'a' * 3 = 'aaa'
- ๋ด๋ถ์ ์ผ๋ก ๋ฆฌ์คํธ์ ๊ฐ์ด ์ฒ๋ฆฌ๋๋ฏ๋ก ์ธ๋ฑ์ฑ๊ณผ ์ฌ๋ผ์ด์ฑ์ด ๊ฐ๋ฅํ๋ค
-
๋ฌธ์์ด์ ์ผ์ ๊ธธ์ด๋ก ์๋ฅด๊ธฐ
length = N # range์ 3๋ฒ์งธ ์ธ์๋ step [arr[i:i + length] for i in range(0, len(arr), length)]
-
๊ด๋ จ ํจ์
์ฌ์ฉ๋ฒ ์ค๋ช replace(target, wanted, [count]) ํน์ ๋ฌธ์๋ฅผ ์ํ๋ ๋ฌธ์๋ก ๊ต์ฒด, count ๋ฏธ์ ๋ ฅ์ ์ ์ฒด ๋ณํ 'A'.join(B) B๋ ๋ฌธ์์ด ํน์ ๋ฌธ์ ๋ฐฐ์ด. A๋ฅผ ์์ ์ฌ์ด์ ๋ฃ์ด ํฉ์น ํ ๋ฌธ์์ด๋ก ๋ฐํ. ์ฃผ๋ก ๊ณต๋ฐฑ์ ๋ฃ๊ณ ์ถ์ ๋ ์ฌ์ฉ isdigit() ์ด๋ค ๋ฌธ์์ด์ด ์ซ์์ ํํ๋ฉด True๋ฅผ ๋ฐํ isdecimal() ์ด๋ค ๋ฌธ์์ด์ด intํ์ผ๋ก ๋ณํ์ด ๊ฐ๋ฅํ๋ฉด True๋ฅผ ๋ฐํ isalpha() ์ฃผ์ด์ง ๋ฌธ์์ด์ด ์ํ๋ฒณ์ผ๋ก๋ง ๊ตฌ์ฑ๋์ด ์๋์ง ํ๋ณํ๋ค. ๊ณต๋ฐฑ์ด ์์ผ๋ฉด False๋ฅผ ๋ฐํ isalnum() ์ฃผ์ด์ง ๋ฌธ์์ด์ด ์ํ๋ฒณ+์ซ์๋ก๋ง ๊ตฌ์ฑ๋์ด ์๋์ง ํ๋ณ. ๊ณต๋ฐฑ ์ False lower()/upper() ์๋ฌธ์/๋๋ฌธ์๋ก ๋ณ๊ฒฝ islower()/isupper() ์๋ฌธ์/๋๋ฌธ์์ธ์ง ํ๋ณ 'A'.rjust(N, 'B') ๋ฌธ์์ด์ N๊ธธ์ด๋ก ๋ง์ถ๊ธฐ ์ํด B ๋ฌธ์์ด์ ์ฝ์ ex) N=3 B=0 A=2 => 002 'A'.ljust(N, 'B') rjust๊ฐ ์ค๋ฅธ์ชฝ ์ ๋ ฌ์ด๋ผ๋ฉด, ljust๋ ์ผ์ชฝ์ ๋ ฌ. A๋ฌธ์์ด ์์ฒด๋ฅผ ๋ฐ๊พธ๋ ๊ฒ ์๋. ์ ๋ฌธ์์ด ๋ฐํ! 'A'.zfill(N) ๋ฌธ์์ด์ N๊ธธ์ด๋ก ๋ง์ถ๊ธฐ ์ํด 0 ์ฝ์ re.sub('[^a-z0-9]', '', str) re.sub('ํจํด', '๋ฐ๊ฟ๋ฌธ์์ด', '์ ์ฉํ ๋ฌธ์์ด')
์ ๊ท์์ ํ์ฉํด์ ํน์๋ฌธ์ ์ ๊ฑฐํ๊ธฐ
(์์1, ์์2)
- ํ ๋ฒ ์ ์ธ๋ ๊ฐ์ ๋ณ๊ฒฝ ๋ถ๊ฐ๋ฅ
- ์ฐ์ ์์ ํ ๊ตฌํ์ ์ฌ์ฉ
- ๋ณ๊ฒฝํ๋ฉด ์๋๋ ๊ฐ์ ๋ณ๊ฒฝํ๊ณ ์์ง๋ ์์์ง ์ฒดํฌ ๊ฐ๋ฅ
- ์๊ดํธ(()) ์ฌ์ฉ
- ๋ฆฌ์คํธ์ ๋นํด ์๋์ ์ผ๋ก ๊ณต๊ฐ์ด ํจ์จ์
- ์ผ๋ฐ์ ์ผ๋ก ๊ฐ ์์์ ์ฑ์ง์ด ๋ค๋ฅผ ๋ ์ฌ์ฉ. ์์) ๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ - (๋น์ฉ, ๋ ธ๋ ๋ฒํธ)
{key1: value1, key2: value2}
- ํค(key)์ ๊ฐ(value)์ ์์ ๋ฐ์ดํฐ๋ก ๊ฐ์ง => ์์ X
- {} ๋๋ dict()๋ก ์ด๊ธฐํ
- ๋ด๋ถ์ ์ผ๋ก ํด์ ํ ์ด๋ธ์ ์ฌ์ฉํ๋ฏ๋ก ๊ฒ์ ๋ฐ ์์ ์ด O(1) => ๋ฆฌ์คํธ๋ณด๋ค ํจ์ฌ ๋นจ๋ฆฌ ๋์ํจ
- ์๋ ํค๋ฅผ ์ฐธ์กฐํ๊ฒ ๋ ๊ฒฝ์ฐ ์๋ฌ
- ํ์ฉ
์ฌ์ฉ๋ฒ ์ค๋ช ์์ in ์ฌ์ ํน์ ์์๊ฐ ์๋์ง ์ฐพ๊ธฐ keys() ํค ๋ฐ์ดํฐ๋ง ๋ฝ์์ ๋ฆฌ์คํธ๋ก ๋ฐํ values() ๊ฐ ๋ฐ์ดํฐ๋ง ๋ฝ์์ ๋ฆฌ์คํธ๋ก ๋ฐํ del dict[key] dict์์ key์ ํด๋นํ๋ ๊ฐ ์ ๊ฑฐ
{1, 2, 3, 4, 5} ๋๋ set([1, 2, 3, 4, 5])
- ์ค๋ณต์ ํ์ฉํ์ง ์์
- ์ฌ์ ์๋ฃํ๊ณผ ๋์ผํ๊ฒ ์์๊ฐ ์์ = ์ธ๋ฑ์ฑ ๋ถ๊ฐ๋ฅ
- ๋ง์ฐฌ๊ฐ์ง๋ก ๊ฒ์ ๋ฐ ์์ ์ด O(1)
- set()์ผ๋ก ์ด๊ธฐํ
- ์ผ๋ฐ์ ์ผ๋ก ํน์ ํ ๋ฐ์ดํฐ๊ฐ ์ด๋ฏธ ๋ฑ์ฅํ ์ ์ด ์๋์ง ์ฌ๋ถ๋ฅผ ์ฒดํฌํ ๋ ์ฌ์ฉ
- set(์งํฉ) ๋ด๋ถ ์์
- mutable(๋ณ๊ฒฝ ๊ฐ๋ฅ - ๋ฆฌ์คํธ, ๋์ ๋๋ฆฌ, ์งํฉ)ํ ๊ฐ์ ๊ฐ์ง ์ ์์
- ์์, ๋ฌธ์์ด, ํํ ๋ฑ immutableํ ๊ฐ์ ๊ฐ๋ฅํจ
- ์ฐ์ฐ: ํฉ์งํฉ(|), ์ฐจ์งํฉ(-), ๊ต์งํฉ(&)
- ํ์ฉ
์ฌ์ฉ๋ฒ ์ค๋ช add(x) ํ๋์ ์งํฉ ๋ฐ์ดํฐ์ ๊ฐ์ ์ถ๊ฐ update([x,y...]) ์ฌ๋ฌ ๊ฐ์ ๊ฐ์ ํ๊บผ๋ฒ์ ์ถ๊ฐ remove(x) ํน์ ํ ๊ฐ ์ ๊ฑฐ. ์์ผ๋ฉด ์ค๋ฅ o discard(x) ํน์ ํ ๊ฐ ์ ๊ฑฐ. ์์ด๋ ์ค๋ฅ x x (not) in set ํน์ ํ ๊ฐ์ด ์๋์ง (์๋์ง) ๊ฒ์ฌ clear() ์งํ์ ์๋ ๋ชจ๋ ๊ฐ์ ์ญ์ copy() ์งํฉ์ ๋ณต์ ํ์ฌ ๋ฆฌํด len(์งํฉ) ์งํฉ ์์์ ๊ฐ์ ๊ตฌํ๊ธฐ
- if, elif, else๋ก ๋ถ๊ธฐ๋ฌธ ์์ฑ.
- ๋น๊ต ์ฐ์ฐ์: == , !=, >, <, >=, <=
- ๋ ผ๋ฆฌ ์ฐ์ฐ์: and, or, not
- ๊ธฐํ ์ฐ์ฐ์: in, not in โ ์ฌ๋ฌ๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ๋ด๋ ์๋ฃํ์ ์ฌ์ฉ ๊ฐ๋ฅ
- ์กฐ๊ฑด๋ถ ํํ์ (์์)
- result = โSuccessโ if score โฅ 80 else โFailโ
- ์กฐ๊ฑด๋ฌธ ์ค์ฒฉ ๊ฐ๋ฅ
- ํ์ด์ฌ์ ํน์ดํ ํน์ง
- 1 < x < 20 โ (O)
- ๋ค๋ฅธ ์ธ์ด์ ๋ฌ๋ฆฌ ํ์ด์ฌ์ ์ํ์ ๋ถ๋ฑ์์ ๊ทธ๋๋ก ์ฌ์ฉ ๊ฐ๋ฅ
- a == b == c : ๋น๊ต ์ฐ์ฐ์๋ฅผ ์ฐ๋ฌ์ ์ฌ์ฉ๊ฐ๋ฅ
-
While๋ฌธ
while i < 9: # ์ฝ๋
-
For๋ฌธ
for i in range(1,n): # 1~n-1 # ์ฝ๋
-
ํค์๋: break, continue, pass
-
์ฌ์ฉ๋ฒ
def ํจ์๋ช (๋งค๊ฐ๋ณ์): # ์คํ ์ฝ๋ # ๋งค๊ฐ๋ณ์๋ return ๋ฌธ์ ํ์ ์๋ return ๋ฐํ ๊ฐ
-
ํ๋ผ๋ฏธํฐ ์ง์ ๋ฐ ๋ํดํธ
def add(a = 0,b = 0): # ๋ํดํธ print(a,b) add(b=3, a=2) # ํ๋ผ๋ฏธํฐ ์ง์ , ์ด ๊ฒฝ์ฐ ์์๊ฐ ๋ฌ๋ผ๋ ๋จ
-
๊ธ๋ก๋ฒ ํค์๋: ํจ์ ์์์ ํจ์ ๋ฐ์ ๋ณ์ ๋ฐ์ดํฐ๋ฅผ ๋ณ๊ฒฝํ๋ ๋ฐฉ๋ฒ
a = 0 def fun(): global a # read๋ง ํ ๊ฑฐ๋ฉด global ํค์๋ ์์ด๋ ๋จ a += 1
-
๋๋ค ํํ์
-
ํจ์๋ฅผ ๋งค์ฐ ๊ฐ๋จํ๊ฒ ์์ฑํ ์ ์์
-
ํ์ด์ฌ ์ ๋ ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํ ๋ ์ ๋ ฌ ๊ธฐ์ค(key)์ ์ค์ ํ ๋๋ ์์ฃผ ์ฌ์ฉ
# ์ผ๋ฐ์ ์ธ add ๋ฉ์๋ def add(a,b) return a+b print(add(3,7)) # ๋๋ค ํํ์์ผ๋ก ๊ตฌํํ add() ๋ฉ์๋ print((lambda a,b: a+b)(3,7))
- input()
- ํ์ค์ ๋ฌธ์์ด ์ ๋ ฅ (์ค๋ฐ๊ฟ ๋จ์) -> split()์ ํตํด ๊ณต๋ฐฑ ๋จ์๋ก ์ชผ๊ฐ์ ์ฌ์ฉ ๊ฐ๋ฅ
- ๋ฌธ์์ด๋ก ๋ฐ๊ธฐ ๋๋ฌธ์ ์๋ฃํ ๋ณํ์ด ํ์
- ์ฌ์ฉ๋ฒ ๊ณต์ *** ํ์ ์๊ธฐ
- list(map(int, input().split())) โ int ๋์ float, str ๊ฐ๋ฅ
- ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋ ๋ฐ์ดํฐ ๊ฐ์๊ฐ ๋ง์ง ์๋ค๋ฉด list() ์์ด ๋ณ์์ ํ์ด์ ๋ฐ์๋ ๋จ
- a, b, c = map(int, input().split())
- split(':'): ๊ตฌ๋ถ์ ์ง์ ๊ฐ๋ฅ
-
๋น ๋ฅธ ์ ๋ ฅ โ ๋งค์ฐ ๋ง์ ์์ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅ ๋ฐ์์ผ ํ ๋ ์ฌ์ฉ โญ๏ธ๊ดํ์ ์ผ๋ก ์ธ์์ ์ฌ์ฉโญ๏ธ
import sys sys.stdin.readline().rstrip() # readline()์ผ๋ก ์ ๋ ฅ ์ ์ํฐ๊ฐ ์ค ๋ฐ๊ฟ ๊ธฐํธ๋ก ์ ๋ ฅ๋๋๋ฐ, # ์ด ๊ณต๋ฐฑ ๋ฌธ์๋ฅผ ์ ๊ฑฐํ๋ ค๋ฉด ๋ฐ๋์ rstrip() ํจ์๊ฐ ํ์ # ์ผ๋ฐ์ ์ธ ์ฌ์ฉ๋ฒ - int() ์ ์ฉ ์ ๊ฐํ๋ฌธ์๊น์ง ์ ๊ฑฐ๋์ rstrip ๋ถํ์ input = sys.stdin.readline int(input())
-
๊ธฐํ ํจ์
์ฌ์ฉ๋ฒ ์ค๋ช ord() ์ ๋์ฝ๋๋ฅผ ์ ์๋ก ๋ณ๊ฒฝ. ( A -> 65, a -> 97 ), ordinal์ ์๋ฏธ chr() ์ ์๋ฅผ ์ ๋์ฝ๋๋ก ๋ณ๊ฒฝ. ( 65 -> A, 97 -> a ) bool() 0 = False, ๋๋จธ์ง๋ True (*์ค์ ๋ก print(False == 0) -> True)
- print()
- ๊ธฐ๋ณธ์ ์ผ๋ก ์ถ๋ ฅ ํ ์ค๋ฐ๊ฟ ์ํ
-
๋ค์ํ ์ถ๋ ฅ๋ฒ
์ฌ์ฉ๋ฒ ์ค๋ช print(a,b) ๋์ด์ฐ๊ธฐ๋ก ๊ตฌ๋ถํ์ฌ ์ถ๋ ฅ print(a+b) print("a" + "b") => ab, ๋ค๋ง ๋ฌธ์์ด๊ณผ ์๋ฅผ ๋ํ๊ฒ ๋ ๊ฒฝ์ฐ ์๋ฌ๊ฐ ๋๋ฏ๋ก ํ๋ณํ ํ์ print(f"์ ๋ต์ {answer}์ ๋๋ค") python 3.6์ด์ ๋ถํฐ ์ง์ํ๋ f-string ๋ฌธ๋ฒ print(a,b,sep='') ๋์ด์ฐ๊ธฐ ์์ด ์ถ๋ ฅ print(a, end = '') ์ค๋ฐ๊ฟ ์์ด ์ถ๋ ฅ. ๋ค์ ์ค๋ฐ๊ฟ์ ํด์ฃผ๊ณ ์ถ์ ๋๋ ์ถ๊ฐ๋ก print() ์ฌ์ฉ print('%x %o' %(16์ง์๋ณ์, 8์ง์๋ณ์)) 16,8์ง์๋ก ์ถ๋ ฅ. ๋๋ฌธ์ ์ฌ์ฉ ์ ๋๋ฌธ์๋ก ์ถ๋ ฅ print('%.2f' %์ค์๋ณ์) print('%.2f' %1.235) => 1.24 print('%08d' %์ ์) print('%.05d' %21) => 00021, 0์ ์๋ตํ๋ฉด ๊ณต๋ฐฑ์ผ๋ก ์๋ฆฌ ์ฑ์
๋๋ถ๋ถ์ ์ฝ๋ฉ ํ ์คํธ์์๋ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ฌ์ฉ์ ํ์ฉํ๋ค.
์ถ๊ฐ๋ก ํ์ํ ๊ธฐ๋ฅ์ ์ฐพ์์ ์ฌ์ฉํ๋๋ก ํ์.
import ์์ด ์ฌ์ฉ. ์์ด์๋ ์๋ ํ์์ ์ธ ๊ธฐ๋ฅ ํฌํจ
๋๋๊ฒ๋ avg ์์!
- sum(): ๋ชจ๋ ์์์ ํฉ์ ๋ฐํ
- min()/max(): 2๊ฐ์ด์์ ํ๋ผ๋ฏธํฐ๋ฅผ ๋ฐ์์ ๊ทธ ์ค ์ต์/์ต๋๊ฐ์ ๋ฐํ
- eval(): ์ํ ์์์ด ๋ฌธ์์ด ํ์์ผ๋ก ๋ค์ด์ค๋ฉด ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํ -> ์์ฐ๋๊ฒ ์ข๋ค๊ณ ํจ
- sorted(): ์ ๋ ฌ๋ ๊ฒฐ๊ณผ ๋ฐํ
- ๋ฌธ์์ด ์ ๋ ฌ ๊ฐ๋ฅ ex) sorted('zdefa') => ['a','d','e','f','z']
- key ์์ฑ์ผ๋ก ์ ๋ ฌ ๊ธฐ์ค ๋ช
์ ๊ฐ๋ฅ
# ํํ์ ์ฒซ๋ฒ์งธ ์ธ์๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ ํ ๋๋ฒ์งธ ์ธ์๋ก ๋ด๋ฆผ์ฐจ์ ํ๊ฒ ํ๋ ค๋ฉด # x[1] ์๋ฆฌ์ (x[0], -x[1]) ๋ฃ์ด์ฃผ๋ฉด ๋จ result = sorted([('ํ๊ธธ๋', 35), ('์ด์์ ', 23), ('์๋ฌด๊ฐ', 40)], key = lambda x: x[1]) print(result) ===== [('์ด์์ ', 23), ('ํ๊ธธ๋', 35), ('์๋ฌด๊ฐ', 40)]
- reverse ์์ฑ์ผ๋ก ์ค๋ฆ์ฐจ์/๋ด๋ฆผ์ฐจ์ ์ค์ . ๊ธฐ๋ณธ์ ์ผ๋ก ์ค๋ฆ์ฐจ์
๋ฐ๋ณต๋๋ ํํ์ ๋ฐ์ดํฐ ์ฒ๋ฆฌ
-
permutations:
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')]
-
combinations:
from itertools import combinations data = ['A','B','C'] result = list(combinations(data, 2)) print(result) ===== [('A', 'B'), ('A', 'C'), ('B', 'C')]
-
product: ์ค๋ณต์ ํ์ฉํ๋ ์์ด
from itertools import product data = ['A','B','C'] result = list(product(data, repeat=2)) print(result) ===== [('A', 'A'), ('A', 'B'), ('A', 'C'),('B', 'A'), ('B', 'B'), ('B', 'C'),('C', 'A'), ('C', 'B'), ('C', 'C')]
-
combinations_with_replacement: ์ค๋ณต์ ํ์ฉํ๋ ์กฐํฉ
from itertools import combinations_with_replacement data = ['A','B','C'] result = list(combinations_with_replacement(data, 2)) print(result) ===== [('A', 'A'), ('A', 'B'), ('A', 'C'),('B', 'B'), ('B', 'C'), ('C', 'C')]
-
2์ฐจ์ ๋ฐฐ์ด์ ๊ฒฝ์ฐ
# ์ด๋ฐ์์ผ๋ก ์๋ก์ด ํํ ๋ฐฐ์ด์ ๋ง๋ ํ ์กฐํฉ ํน์ ์์ด ์ ์ฉ coords = [(x, y) for x in range(n) for y in range(m)]
(์ต์) ํ ์ ๊ณต. ์ฐ์ ์์ ํ ๊ธฐ๋ฅ ๊ตฌํํ ๋ ์ฌ์ฉ
-
๋จ์ํ ์์๋ฅผ ์ ๋ถ ๋ฃ์ด๋ค๊ฐ ๋นผ๋ ๊ฒ๋ง์ผ๋ก ์๊ฐ ๋ณต์ก๋ O(NlogN)์ ์ค๋ฆ์ฐจ์ ์ ๋ ฌ ์๋ฃ
-
ํ์ ์ต์๋จ ์์๋ ํญ์ ๊ฐ์ฅ ์์ ์์์ด๊ธฐ ๋๋ฌธ!
-
์ต๋ ํ์ ์ ๊ณตํ์ง ์์ -> ์ฝ์ ์ ๋ถํธ ๋ณ๊ฒฝ & ๊บผ๋ผ ๋ ๋ค์ ๋ถํธ ๋ณ๊ฒฝํ๋ฉด ๋จ
-
์ฌ์ฉ๋ฒ
import heapq # ์ด๊ธฐํ q = [] # ์์ - ํํ ํ heapq.heappush(q, (3, 22)) heapq.heappush(q, (2, 30)) # [์ฐธ๊ณ ] heapq.heapify ํจ์๋ import ๊ฐ๋ฅ print(q[0]) result = sorted(q, key = lambda x: x[1]) print(result) heapq.heappop(q) ====== (2, 30) [(3, 20), (2, 30)]
-
heappush(h,value): ์์ ์ฝ์
-
heappop(h): ์์ ๊บผ๋ด๊ธฐ
์ด์งํ์. โ์ ๋ ฌ๋ ๋ฐฐ์ดโ์์ ํน์ ํ ์์๋ฅผ ์ฐพ์์ผ ํ ๋ ๋งค์ฐ ํจ๊ณผ์
-
bisect_left(a,x): ์ ๋ ฌ๋ ์์๋ฅผ ์ ์งํ๋ฉด์ ๋ฆฌ์คํธ a์ ๋ฐ์ดํฐ x๋ฅผ ์ฝ์ ํ ๊ฐ์ฅ ์ผ์ชฝ ์ธ๋ฑ์ค ์ฐพ๊ธฐ -> O(logN)
-
bisect_right(a,x): ์ ๋ ฌ๋ ์์๋ฅผ ์ ์งํ๋ฉด์ ๋ฆฌ์คํธ a์ ๋ฐ์ดํฐ x๋ฅผ ์ฝ์ ํ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ์ธ๋ฑ์ค ์ฐพ๊ธฐ -> O(logN)
-
์์
from bisect import bisect_right, bisect_left def count_by_range(a, left_val, right_val): right_index = bisect_right(a, right_val) left_index = bisect_left(a, left_val) return right_index - left_index a = [1,2,3,3,3,3,4,4,8,9] # ๊ฐ์ด 4์ธ ๋ฐ์ดํฐ ๊ฐ์ ์ถ๋ ฅ print(count_by_range(a,4,4)) ==== 2 # ๊ฐ์ด [-1,3] ๋ฒ์์ ์๋ ๋ฐ์ดํฐ ๊ฐ์ ์ถ๋ ฅ print(count_by_range(a,-1,3)) ==== 6
์ ์ฉํ ์๋ฃ๊ตฌ์กฐ ์ ๊ณต
-
deque
from collections import deque data = deque([2,3,4]) # deque()๋ก ์ด๊ธฐํ ๊ฐ๋ฅ data.appendleft(1) data.append(5) print(data) print(list(data)) ===== deque([1,2,3,4,5]) [1,2,3,4,5]
-
๋ฆฌ์คํธ ์๋ฃํ์ ์ฝ์ ๊ณผ ์ญ์ ๋ฅผ '๋งจ ๋ค'์์๋ฅผ ๊ธฐ์ค์ผ๋ก ์ํ => ์์ชฝ์ ์์๋ฅผ ์ฒ๋ฆฌํ ๋๋ ๋ง์ ์๊ฐ ์์
-
๋น๊ต
๋ฆฌ์คํธ deque ๊ฐ์ฅ ์์ชฝ์ ์์ ์ถ๊ฐ O(N) O(1) ๊ฐ์ฅ ๋ค์ชฝ์ ์์ ์ถ๊ฐ O(1) O(1) ๊ฐ์ฅ ์์ชฝ์ ์์ ์ ๊ฑฐ O(N) O(1) ๊ฐ์ฅ ๋ค์ชฝ์ ์์ ์ ๊ฑฐ O(1) O(1) -
๋ค๋ง ๋ฆฌ์คํธ์ ๋ฌ๋ฆฌ ์ธ๋ฑ์ฑ๊ณผ ์ฌ๋ผ์ด์ฑ ์ฌ์ฉ ๋ถ๊ฐ
-
์คํ, ํ์ ๊ธฐ๋ฅ์ ๋ชจ๋ ํฌํจ
- stack: ์์ ์ฝ์ => append(), ์์ ์ญ์ => pop()
- queue: ์์ ์ฝ์ => append(), ์์ ์ญ์ => popleft()
-
Counter: ๋ฑ์ฅ ํ์๋ฅผ ์ธ๋ ๊ธฐ๋ฅ
from collections import Counter counter = Counter(['red','blue','red','green']) print(counter['blue']) print(dict(counter)) ===== 1 {'red':2, 'blue':1, 'green': 1}
ํ์์ ์ธ ์ํ์ ๊ธฐ๋ฅ์ ์ ๊ณต
ํจ์ | ์ค๋ช |
---|---|
math.pi | ํ์ด |
math.e | ์์ฐ์์ |
math.ceil(x)โญ๏ธ | x๋ฅผ ์ฌ๋ฆผํ์ฌ ์ ์๊ฐ์ ๋ฐํ |
math.floor(x)โญ๏ธ | x๋ฅผ ๋ด๋ฆผํ์ฌ ์ ์๊ฐ์ ๋ฐํ |
math.trunc(x)โญ๏ธ | x์ ์์์ ์ ์๋ฅธ ํ ์ ์๊ฐ์ ๋ฐํ |
math.copysign(x, y) | x๊ฐ์ ์ ๋๊ฐ์ y์ ๋ถํธ๋ฅผ ๊ฐ๋ ์ ๋ฆฌ์๋ฅผ ๋ฐํ |
math.comb(n, k) | nCk๊ณผ ๊ฐ์ ์กฐํฉ ๊ฐ์ ๋ฐํ (n๊ฐ์ ์์์ k๊ฐ๋ฅผ ์ ํ) |
math.perm(n, k) | nPk์ ๊ฐ์ ์์ด ๊ฐ์ ๋ฐํ (n๊ฐ์ ์์์ k๋ฅผ ๊บผ๋ด ์์๋๋ก ๋์ด) |
math.factorial(x) | x์ ํฉํ ๋ฆฌ์ผ์ ๋ฐํ (123*...*x) |
math.fmod(x, y) | x์ y๋ฅผ ๋๋ ํ ๋๋จธ์ง๋ฅผ ์ ๊ณต (๋ถ๋์์์ ์ฐ์ฐ์ ์ฌ์ฉ) |
math.fsum(iterable) | ์ดํฐ๋ฌ๋ธ(iterable)์ ์๋ ๊ฐ์ ์ ํํ ๋ถ๋ ์์์ ํฉ์ ๋ฐํ |
math.prod(iterable) | ์ดํฐ๋ฌ๋ธ(iterable)์ ๋ชจ๋ ์์ ๊ณฑ์ ๋ฐํ (๋น ๊ฒฝ์ฐ 1์ ๋ฐํ) |
math.gcd(integers)โญ๏ธ | ์ฌ๋ฌ๊ฐ์ ์ ์๋ฅผ ๋ฐ์ ์ต๋ ๊ณต์ฝ์๋ฅผ ๋ฐํ |
math.lcm(integers)โญ๏ธ | ์ฌ๋ฌ๊ฐ์ ์ ์๋ฅผ ๋ฐ์ ์ต์ ๊ณต๋ฐฐ์๋ฅผ ๋ฐํ |
math.isclose(a, b)โญ๏ธ | ๋ ์ค์๊ฐ ๊ฐ์์ง ํ๋จํ๋ ์ ํํ ํจ์ |
math.isfinite(x) | x๊ฐ์ด ๋ฌดํํ๊ฑฐ๋ Nan(Not a number) ์ผ๊ฒฝ์ฐ True ๊ฐ์ ๋ฐํ |
math.isinf(x) | x๊ฐ ์ ๋๋ ์์ ๋ฌดํ๋์ด๋ฉด True, ๋ฐ๋์ผ ๊ฒฝ์ฐ False๋ฅผ ๋ฐํ |
math.isnan(x)โญ๏ธ | x๊ฐ Nan(Not a number)์ผ๊ฒฝ์ฐ True, ๋ฐ๋์ผ ๊ฒฝ์ฐ False๋ฅผ ๋ฐํ |
math.sqrt(n)โญ๏ธ | ์ ๊ณฑ๊ทผ ๋ฐํ |
math.modf(x) | x์ (์์, ์ ์)๋ถ๋ถ์ผ๋ก ๋ฐํ, ์ ์๋ถ๋ถ์ float๋ก ๋ฐํ |
์๊ณ ๋ฆฌ์ฆ์ ์ํด ํ์ํ ์ฐ์ฐ์ ํ์. ์ด๋ ์ฐ์ฐ์ด๋, ์ฌ์น ์ฐ์ฐ๊ณผ ๋น๊ต ์ฐ์ฐ ๋ฑ์ ๊ธฐ๋ณธ ์ฐ์ฐ์ ๋งํจ.
-
๊ฐ์ฅ ๋น ๋ฅด๊ฒ ์ฆ๊ฐํ๋(= ๊ฐ์ฅ ์ํฅ๋ ฅ์ด ํฐ) ํญ๋ง์ ๊ณ ๋ ค. ์์) 5N^3 + 2N^2 + N => O(N^3)
-
๋ค๋ง, ํญ์ ๋ง๋ ๊ฑด ์๋. ์์) N^3 + 100000000000 => N์ด ์์ ๋๋ ์์์ ์ํฅ์ด ํจ์ฌ ํฌ๋ค
-
์ต์ ์ ๊ฒฝ์ฐ์ ๋ํ ์ฐ์ฐ ํ์๋ฅผ ๊ณ ๋ คํด์ผ ํจ
-
์ฐ์ฐ ํ์๊ฐ ํ์ด์ฌ ๊ธฐ์ค 2000๋ง๋ฒ(2e7)์ ๋์ด๊ฐ๋ฉด 1์ด ์ ๋ ์์
-
ํ (ํ์ด์ฌ ๊ธฐ์ค)
ํ๊ธฐ๋ฒ ๋ช ์นญ ์๊ณ ๋ฆฌ์ฆ(์ต์ ์ ๊ฒฝ์ฐ ๊ธฐ์ค) ๋๋ต์ ์ธ N ๋ฒ์ O(1) ์์ ์๊ฐ ์คํ์ push/pop, ์ธ๋ฑ์ค๋ก ์ ๊ทผํด์ ๋ฐ๋ก ์ฒ๋ฆฌ ๊ฐ๋ฅํ ์ฐ์ฐ, ์๋ก์ ์งํฉ ์ฐ์ฐ ~ O(logN) ๋ก๊ทธ ์๊ฐ ์ด์ง ํ์, ํธ๋ฆฌ ํํ ์๋ฃ๊ตฌ์กฐ ํ์, 1000๋ง ๋จ์ ์ด์ O(N) ์ ํ ์๊ฐ 1์ค for๋ฌธ, ๋ฐ๋ณตํ ํผ๋ณด๋์น ์์ด, DFS/BFS, ์์ ์ ๋ ฌ 1000๋ง๋จ์ ์ดํ O(NlogN) ๋ก๊ทธ ์ ํ ์๊ฐ ํ/๋ณํฉ ์ ๋ ฌ, sort()(ํ์ด์ฌ ๊ธฐ๋ณธ ์ ๋ ฌ ํจ์), LIS, ๊ฐ์ ๋ ๋ค์ต์คํธ๋ผ, ํฌ๋ฃจ์ค์นผ 100๋ง๋จ์ ์ดํ O(N^2) ์ด์ฐจ ์๊ฐ ํต/์ ํ/๊ฑฐํ/์ฝ์ ์ ๋ ฌ, 2์ค for๋ฌธ 1000๋จ์ ์ดํ O(N^3) ์ผ์ฐจ ์๊ฐ (๋ณดํต ์๊ฐ ์ด๊ณผ) ํ๋ก์ด๋ ์์ 100๋จ์ ์ดํ O(2^N) ์ง์ ์๊ฐ (๋ณดํต ์๊ฐ ์ด๊ณผ) ์ฌ๊ทํ ํผ๋ณด๋์น ์์ด X
- ์๊ฐ ๋ณต์ก๋ ๋ถ์์ ๋ฌธ์ ํ์ด์ ํต์ฌ -> ๋ฌธ์ ์กฐ๊ฑด์ ํ์ธํ ํ ์ฌ์ฉํ ์ ์๋ ์๊ณ ๋ฆฌ์ฆ์ ์ขํ๋๊ฐ์
[์์] - N์ ๋ฒ์๊ฐ 500์ธ ๊ฒฝ์ฐ = O(N^3)์ผ๋ก ์ค๊ณ - N์ ๋ฒ์๊ฐ 2000์ธ ๊ฒฝ์ฐ = O(N^2)์ผ๋ก ์ค๊ณ - N์ ๋ฒ์๊ฐ 2,000,000์ธ ๊ฒฝ์ฐ = O(N)์ผ๋ก ์ค๊ณ
์๊ณ ๋ฆฌ์ฆ์ ์ํด ํ์ํ ๋ฉ๋ชจ๋ฆฌ์ ์
- ์ผ๋ฐ์ ์ผ๋ก ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ ๊ธฐ์ค์ MB๋ก ์ ์ -> ๋ณดํต 128 ~ 512MB๋ก ์ ํ
- ์ฆ, ์ผ๋ฐ์ ์ผ๋ก ๋ฐ์ดํฐ์ ๊ฐ์๊ฐ 1000๋ง๊ฐ๊ฐ ๋์ง ์๋๋ก ์ค์ ํด์ผํจ์ ๋งํจ
- int a[1000] = 4KB, int a[1,000,000] = 4MB
- ๋ณ์ ๋ค์ด๋ฐ ์ ํค์๋ ์ฌ์ฉ ์ ๋ ๊ธ์ง ex) str, input...
- division by zero ์ฃผ์
- ์ ์ถ ์ ์์, 0, ์์, ์ต๋๊ฐ, ์ต์๊ฐ ์ฒดํฌ
- ๋ฐฐ์ด ์ฌ์ฉ ์, out of range ์ฃผ์
- /๋ฅผ ์จ์ผํ ๋์ //๋ฅผ ์จ์ผํ ๋ ๊ตฌ๋ถ ์ํ๊ธฐ
- ๋ฐ๋ก ์ฝ๋๋ฅผ ์์ฑํ์ง ๋ง๊ณ ์ค๊ณ & ์ฃผ์์ผ๋ก ์๋์ฝ๋ ์์ฑ
- ์ ๋ ฅ์ด ๋ง์ผ๋ฉด sys.std.readline().rstrip() !!
- ๋ณ์๋ค์ด๋ฐ์ ์ต๋ํ ์งง๊ฒ ์ฐ๋ ํธ์ด ๋ณด๊ธฐ ํธํจ ex) cx, nx <- current_x next_x
- ^๋ ์น์ ํํ์ด ์๋๋ค! ๋นํธ ์ฐ์ฐ์์ -> math.pow ๋๋ ** ์ฌ์ฉํ๊ธฐ
- 2,8,16์ง๋ฒ์ 10์ง๋ฒ์ผ๋ก ๋ณํ => int('aa',16),int('56',8),int('10',2)
- 10์ง๋ฒ์ 2,8,16์ง๋ฒ์ผ๋ก ๋ณํ => bin(30),oct(n),hex(n)
- ๋ฌธ์์ด ์์ ์ - ex) board = '0##00'
- board[x] = '#' ๋ฌธ์์ด์ immutable์ด๋ฏ๋ก ์ค๊ฐ์ ํ๋๋ฅผ ์์ ๋ชปํจ
- ์ธ๋ฑ์ค๋ฅผ ์ง์ ํด์ ๋ฐ๊พธ๊ณ ์ถ์ผ๋ฉด arr=list(str) ํ์ arr[idx]๋ก ์ ๊ทผ
- for case in range(1 << 10): - 2์ ์ ๊ณฑ์ด๋ฉด ์ด๋ฐ์์ผ๋ก ๊ฐ๋ฅ
- rjust๋ ์ค๋ฅธ์ชฝ์ ์ฑ์ฐ๋๊ฒ ์๋๋ผ ์ค๋ฅธ์ชฝ ์ ๋ ฌ์
- int ๋ก ์๊ฐ์์ผ๋ฉด rstrip ์ถ๊ฐ!!
- ํ์ด์ฌ์ a == b == c == d ์ด๋ฐ์์ผ๋ก ๊ณ์ ์ฐ์ฐ ๊ฐ๋ฅ
- ๋์ ์ a = b = 0 ์ด๋ ๊ฒ๋ ๊ฐ๋ฅ
- ์ํ์ ์๋ฃ๊ตฌ์กฐ๊ฐ ์๋ค๋ฉด ๊ธธ์ด๋ฅผ ๋๋ฐฐ๋ก ๋๋ ค์ ์ฐ๊ฒฐ๋๊ฒ ํ๋ ๋ฐฉ์๋ ๊ณ ๋ ค
- reversed ๋ณด๋ค [::-1] ๋ฐฉ์์ด ๋ ์ข์
- reversed์ ๊ฒฐ๊ณผ์ ๋ํ ์ธ๋ฑ์ค ์ iteration ์ด์ฉ๊ตฌ ์๋ฌ๋ธ
- max(seasons, key=len) ์ด๋ฐ์์ผ๋ก min max์ ์ ๋ ฌ ํค ์ค์ ๊ฐ๋ฅ
- list(map(int,input().split())) => 0100010 ์ด๋ฐ ๊ฒฝ์ฐ์ ๋งจ์ 0์ด ์๋ ค์ ๋ค์ด๊ฐ
- bfs์์ visited์ ๋ค์ด๊ฐ๋ ๋ ธ๋๊ฐ ๋ง์์ ์๊ฐ์ด๊ณผ๊ฐ ๋ ๊ฒ ๊ฐ์ผ๋ฉด set ์๋ฃ๊ตฌ์กฐ ๊ณ ๋ ค
- ๊ทธ๋ํ์์ '๋ฌถ์'์ ๊ฐ์๋ฅผ ๊ตฌํ๊ธฐ = DFS/BFS !
- ๊ทธ๋ํ ์๊ณ ๋ฆฌ์ฆ์ ๊ฒฝ์ฐ ๋ฐ์ด๋๋ฆฌ ๋ฒ์๋ฅผ ๋์ด๊ฐ์ง ์๋์ง ์ฒดํฌ
- ์ด๋ถ ํ์์์๋ start, end๋ฅผ ์ ๋๋ก ์ค์ ํ๋ ๊ฒ์ด ๋งค์ฐ ์ค์!
- for i in arr: ... ํ๊ณ for ๋ฌธ ๋ด๋ถ์์ arr์ ์ถ๊ฐ, ์ญ์ ๋ฅผ ํ๊ฒ๋๋ฉด ์ํฅ ๋ฐ์
- 0,1 ์ ์์ ์๋
- dfs ์ฌ์ฉ ์ ์คํ์ค๋ฒํ๋ก์ฐ ์ฃผ์!!
- list(input().rstrip()) ๋ก ์ฒ๋ฆฌํด์ผ ํ๋์ ๋ฌธ์์ด์ ๊ธ์๋ณ๋ก ๋๋ ์ ๋ฐฐ์ดํ & \n ์๋ ์ ๊ฑฐ
- union_parent๋ง ํ๊ฒ ๋๋ฉด parent๋ ๊ฒฝ๋ก์์ถ์ด ์๋ ์ํ๋ผ๋๊ฑฐ ๋ช ์ฌ
- ํ๋ก์ด๋์์ a->b๋ก ๊ฐ๋ ๊ฒฝ๋ก๊ฐ ์ฌ๋ฌ๊ฐ๋ฉด ๊ฐ์ฅ ์งง์ ๊ฒฝ๋ก ๊ธฐ์ค์ผ๋ก ๋๋ฆฌ๊ธฐ
- ์๋ฐฉํฅ์ธ ๊ฒฝ์ฐ a->b b->a ๊ฐ์ ์ ๊ฐ๊ฐ ์ถ๊ฐ
- ์ต๋จ ๊ฒฝ๋ก๊ฐ ์ฌ๋ฌ๊ฐ ์ด๋๋ผ๋ '๋น์ฉ'์ ๋ชจ๋ ๋์ผํ๋ค๋ ์ ์ ํ์ฉ
- 0์ด False๋ก ์ฒ๋ฆฌ๋์ ์กฐ๊ฑด๋ฌธ์ ๋ค์ด๊ฐ์ง ์๋์ง ์ฒดํฌ
- [:-k]๋ก ์ธ๋ฑ์ฑ ํ ๋ => k๊ฐ 1๋ณด๋ค ์์์ง๋ ๊ฒฝ์ฐ๋ ์๋์ง ์ฒดํฌ
| https://paris-in-the-rain.tistory.com/100
| https://velog.io/@21stairs/C-%EB%AC%B8%EB%B2%95-%EC%A0%95%EB%A6%AC