๋ง์ด ์ฌ์ฉ๋๋ ๊ธฐ๋ณธ์ผ๋ก ์ ๊ณตํ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๋ชฉ๋ก ๋ฆฌ์คํธ์ด๋ค.
๊ณต์ ๋ฌธ์๋ฅผ ๊ธฐ์ค์ผ๋ก ์ด๋ ํ ๊ธฐ๋ฅ๋ค์ ์ ๊ณตํ๋์ง ์ ๋ฆฌํด ๋ณด์.
๐ช import collections
dictionary, list, set, tuple ์๋ฃํ์ ๋ํ ๋์์ ์ ๊ณตํ๋ค.
ํด๋น ๊ฒ์๊ธ ์ฐธ๊ณ (https://steady-eschoi.tistory.com/5)
๐ช import heapq
์ด์งํธ๋ฆฌ ๊ธฐ๋ฐ์ ์ต์ heap ์๊ณ ๋ฆฌ์ฆ(๋ถ๋ชจ ๋ ธ๋์ ๊ฐ์ ํญ์ ์์ ๋ ธ๋๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์)์ ์ ๊ณตํ๋ค.
๊ฐ์ฅ ์์ ๊ฐ์ heap [0]์ ์์น
- heappush
- heappop
- heappushpop
- heapreplace
- heapify
- nlargest
- nsmallest
from heapq import *
#ํ ๋ชจ๋์ ํํ ๊ฐ์ฒด๋ฅผ ์ํ ๋ฐฐ์ด ์ ์ธ
h=[]
#์ ์ธ ๋ ๋ฐฐ์ด์ ์์ ์ถ๊ฐ
heappush(h, value)
#์ ์ธ ๋ ๋ฐฐ์ด์์ ์ ์ผ ์์ ์์ ํ๋ ๊บผ๋ด๊ธฐ
heappop(h)
#์ ์ธ ๋ ๋ฐฐ์ด์์ push ์ฐ์ฐ ๋ค ๋ฐ๋ก pop ์ฐ์ฐ ์คํ
heapq.heappushpop(h, value)
#์ ์ธ ๋ ๋ฐฐ์ด์์ pop ์ฐ์ฐ ๋ค ๋ฐ๋ก push ์ฐ์ฐ ์คํ
heapq.heapreplace(h, value)
#๋ฐฐ์ด์ ํ ๊ฐ์ฒด๋ก ๋ฐํ
heapq.heapify(x)
#ํ์์ n๊ฐ์ ์ ์ผ ํฐ ๊ฐ์ ๋ฐํ
heapq.nlargest(n, iterable, key=None)
#ํ์์ n๊ฐ์ ์ ์ผ ์์ ๊ฐ์ ๋ฐํ
heapq.nsmallest(n, iterable, key=None)
๐ช import functools
๊ณ ์ฐจ์ ํจ์๋ฅผ ์ํด ๊ณ ์๋ ๋ชจ๋๋ก ํจ์์ ์ ์ฉํ๊ฑฐ๋, ํจ์๋ฅผ ๋ฐํํ๋ ๋ชจ๋์ด๋ค.
- @lru_cached
- cmp_to_key
- @total_ordering
- partial
- reduce
#lru_cached : ์บ์ ๊ธฐ๋ฅ์ ์ด์ฉํด ํจ์ ์ฐ์ฐ ์๊ฐ์ ์ค์ฌ์ค
from functools import lru_cache
@lru_cached(maxsize=128)
def ํจ์๋ช
(๋งค๊ฐ๋ณ์):
#cmp_to_key : ์ ๋ ฌ ํจ์์ key์ ํจ์๋ฅผ ์ฌ์ฉ
from functools import cmp_to_key
sorted(key=์ํ๋ ํจ์, reverse=False)
ex) sorted(๋ฆฌ์คํธ, key=len) >> ๋ฆฌ์คํธ์ ์์์ ๊ธธ์ด ์์๋๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
#total_ordering : ์ฌ์ฉ์ ์ ์ ๊ฐ์ฒด๋ผ๋ฆฌ ๋น๊ต(๋น๊ต์ฐ์ฐ์ ์ฌ์ฉ)ํ๊ฑฐ๋ ์ ๋ ฌ
from functools import total_ordering
@total_ordering
class ํด๋์ค๋ช
:
# ๋น๊ต : ๊ฐ์ฒด1 ๋น๊ต์ฐ์ฐ์ ๊ฐ์ฒด2
# ์ ๋ ฌ : ๊ฐ์ฒด๋ฅผ ์์๋ก ๊ฐ์ง๋ ๋ฐฐ์ด.sort(reverse=False)
#partial : ํจ์์ ํน์ ์ธ์๋ฅผ๊ณ ์ ์์ผ ์๋ก์ด ํจ์๋ก ์ ์
from functools import partial
์๋ก์ด_ํจ์๋ช
=partial(ํจ์๋ช
, ๊ณ ์ ์ํฌ๋งค๊ฐ๋ณ์๊ฐ)
#reduce : ํจ์ ์ฐ์ฐ์ ์ดํฐ๋ฌ๋ธ ๊ฐ์ฒด์ ๋ํด ๋์ ์ฐ์ฐ
from functools import reduce
reduce(ํจ์๋ช
, ์ดํฐ๋ฌ๋ธ๊ฐ์ฒด)
ex) reduce(lambda a, b : a+b, [0,1,2,3,4]) >> 10
cf) ์บ์ฑ : ์ ๊ทผํ๋๋ฐ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฌ๋ ๋ฐ์ดํฐ๋ฅผ ์ ๊ทผ ์๋๊ฐ ๋น ๋ฅธ ์ ์ฅ์์ ์ ์ฅํด ๋๊ณ ์ฌ์ฌ์ฉํ๊ฑฐ๋,
์คํํ๋๋ฐ ์ค๋ ๊ฑธ๋ฆฌ๋ ์ฐ์ฐ์ ์ต์ด๋ง ๊ณ์ฐํ์ฌ ์ ์ฅํ๊ณ ์ฌ์ฌ์ฉํ๋ ๊ธฐ๋ฒ-์ฌ๊ท ํจ์์์ ํนํ ์ ์ฉํ๋ค.
๐ช import itertools
ํจ์จ์ ์ธ ๋ฐ๋ณต์ ์ํด ์ดํฐ๋ ์ดํฐ๋ฅผ ๋ง๋๋ ๋ชจ๋์ด๋ค.
๊ด๋ จ ํจ์๊ฐ ๋ง์ผ๋ ๊ณต์ ๋ฌธ์๋ฅผ ์ฐธ๊ณ ํ์ (https://docs.python.org/3/library/itertools.html)
- ๋ฌดํ ์ดํฐ๋ ์ดํฐ๋ฅผ ์ฐ์ถํ๋ ํจ์
- count(์ซ์) >> ์ซ์๋ถํฐ 1์ฉ ์ฆ๊ฐ
- cycle(๋ฌธ์์ด) >> ๋ฌธ์ ๊ฐ๊ฐ ์์๋ก ๋ง๋ค์ด ๋ฐ๋ณต
- repeat(๋ฐ๋ณตํ ์์, ์ซ์) >> ์ซ์๋งํผ ์์๋ฅผ ๋ฐ๋ณต
- ์ ํ ์ดํฐ๋ ์ดํฐ๋ฅผ ์ฐ์ถํ๋ ํจ์
- accumulate
- chain
- chain.from_iterable
- compress
- dropwhile
- filterfalse
- groupby
- islice
- pairwise
- starmap
- takewhile
- tee
- zip_longest
- ์กฐํฉํ ์ดํฐ๋ ์ดํฐ๋ฅผ ์ฐ์ถํ๋ ํจ์
- product(๋ฌธ์์ด, repeat=์ซ์) : ์ซ์ ์นธ์ ์๋ฆฌ์ ๋ฌธ์์ด ์์๋ฅผ ์ค๋ณต ์ถ์ถํ๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์ ์กฐํฉ
- permutations(๋ฌธ์์ด, ์ซ์) : ์ซ์ ์นธ์ ์๋ฆฌ์ ๋ฌธ์์ด ์์๋ฅผ ์ค์ธ์ฐ๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์
- combinations(๋ฌธ์์ด, ์ซ์) : ์ซ์ ์นธ์ ์๋ฆฌ์ ๋ฌธ์์ด ์์์ ์ง๊ฟ์ ๋ง๋๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์
- combinations_with_replacement(๋ฌธ์์ด, ์ซ์) : ์ซ์ ์นธ์ ์๋ฆฌ์ ๋ฌธ์์ด ์์์ ์ค๋ณตํด์ ์ง๊ฟ์ ๋ง๋๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์
# 1. product
product('ABC' repeat=2)
>> AA, AB, AC, BA, BB, BC, CA, CB, CC
# 2. permutations
permutations('ABC', 2)
>> AB, AC, BA, BC, CA, CB
#3. combinations
combinations('ABC', 2)
>> AB AC BC
#4. combinations_with_replacement('ABC', 2)
>> AA AB AC BB BC BD CC
๐ช import re
์ ๊ท์ ์ฐ์ฐ์ ์ ๊ณตํ๋ ๋ชจ๋์ด๋ค.
๐ช import sys
ํ์ด์ฌ ์ธํฐํ๋ฆฌํฐ๊ฐ ์ ๊ณตํ๋ ๋ณ์๋ ํจ์๋ฅผ ์ ์ดํ ์ ์๋ ๋ฐฉ๋ฒ์ ์ ๊ณตํ๋ค.
๐ช import math
C ํ์ค์์ ์ ์๋ ์ํ ํจ์์ ๋ํ ์ ๊ทผ์ ์ ๊ณตํ๋ค
๐ช import bisect
๋ฐฐ์ด ์ด์ง ๋ถํ ์๊ณ ๋ฆฌ์ฆ์ ์ง์ํ๋ค.
๐ช from typing import *
๋ค์ํ ํ์ ์ด๋ ธํ ์ด์ ์ ์ํด ์ฌ์ฉํ๋ ๋ชจ๋์ด๋ค.
์ฒ์๋ถํฐ ๋ชจ๋ ๋ชจ๋์ ์ดํด๋ณผ ์ ์๊ธฐ ๋๋ฌธ์ ์ฌ๋ฌ ๋ฌธ์ ๋ฅผ ํ๋ฉฐ ์์ฃผ ๋์ค๋ ์ฐ์ฐ๋ค์ ์ ๋ฆฌํ๋ ค ํ๋ค.
'์๊ณ ๋ฆฌ์ฆ๐ฅ > ๋ฌธ์ ํ์ด (Python)' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[LeetCode] 49. group-anagrams (Medium) 2023/4/28 (0) | 2023.04.28 |
---|---|
[LeetCode] 937. reorder-data-in-log-files (Easy) 2023/4/27 (0) | 2023.04.27 |
[LeetCode] 344. reverse-string (Easy) 2023/4/27 (0) | 2023.04.27 |
[LeetCode] 125. valid-palindrome (Easy) 2023/4/27 (0) | 2023.04.27 |
[python] 1. ์ฝ๋ฉํ ์คํธ์ ํ์ ์ฒดํฌ ๋ชฉ๋ก (0) | 2023.04.26 |