from collections import deque
def solution(n, m, image):
answer = 0
q = deque()
img = [(im, (i, idx)) for i, img in enumerate(image) for idx, im in enumerate(img)]
while img:
has = False
if not q:
"""์ ์ ๋ฐฐ์ด์์ ๋ ๋ฒ์งธ๋ก ํฐ ๊ฐ์ ๋ฐํํ๋ผ | |
:์ ๋ ฅ: list of int | ์ ์ ๋ฐฐ์ด. ํฌ๊ธฐ๋ 2 ์ด์. (ex: [6, 5, 2, 1, 100, 3, 1, 59]) | |
:์ถ๋ ฅ: int | ์ ์ ๋ฐฐ์ด์ 2๋ฒ์งธ๋ก ํฐ ์ ์. (ex: 59) | |
:์กฐ๊ฑด: | |
1. list.sort() ํจ์๋ฅผ ์ฐ์ง ์๋๋ค. ์ด๊ฑธ ์ฐ๋ฉด ๋๋ฌด ์ฝ์ฃ ์ฌ์ค... | |
2. ๋ง์ฝ ์ต๋๊ฐ์ด ๋ ๊ฐ ์ด์์ด๋ฉด, ์ ๋ต์ ๊ทธ๊ฒ๋ณด๋ค ์์์ผ ํ๋ค.(ex: function([2, 2, 2, 1]) --> 1) | |
3. ๋ง์ฝ ๋ฐฐ์ด ๋ด ๋ชจ๋ ๊ฐ์ด ๋๊ฐ๋ค๋ฉด ๋ ๋ฒ์งธ ํฐ ๊ฐ์ ์๊ธฐ ๋๋ฌธ์ 'equality'๋ผ๋ ๋ฌธ์์ด์ ์ถ๋ ฅํ๋ค. | |
""" |
# 1. | |
""" | |
""" | |
def solution(s): | |
N = len(s) | |
MAX_SIZE = N // 2 + 1 | |
def run_length_len(s, r): | |
ans = count = 0 |
# ๋ฏธ์ฐ๋์ด ์ฌ๋ ค์ฃผ์ ์ฝ๋์์. ์ฌ๊ธฐ์ ๋ํด ํผ๋๋ฐฑ ๋๋ ค๋ณผ๊ฒ์.
# ์ ๋ต๋ณด๋ค๋ ๊ฐ๋
์ฑ ์ข์ ์ฝ๋ฉ ์คํ์ผ์ ๋ํด์
A = [1, 2, 3, 4, 5, 6, 73, 8, 10, 54]
odd = 0
even = 0
odds=[]
evens=[]
# ์์ฃผํ์ง ๋ชปํ ์ | |
# dict ๋ด์ฅ ์๋ฃ๊ตฌ์กฐ๋ ๋น๋์๋ฅผ ์ธ๋ ์ฐ์ฐ์ ๋งค์ฐ ํนํ๋์ด ์์ต๋๋ค. | |
# ์ ํ์ฉํ์๋ฉด ์ข์์. | |
def solution(participant, completion): | |
dic = {} | |
for p in participant: | |
dic[p] = dic.get(p, 0) + 1 | |
# dict.get ๋ฉ์๋๋ ์ค์ํด์ ๊ผญ ์์๋์ ์ผ ํฉ๋๋ค. |
"""์ ์ ๋ฐฐ์ด์ ์ค๋ฆ์ฐจ์ ์ ๋ ฌํ๋, ํ์๊ฐ ๋ฌด์กฐ๊ฑด ์ง์๋ณด๋ค ์์๊ฒ ์ ๋ ฌํ๋ผ. | |
:์ ๋ ฅ: | |
arr | arr: ์ ์ ๋ฐฐ์ด. ํฌ๊ธฐ๋ 1,000,000 ์ดํ. ๊ฐ ์ ์์ ์ ๋๊ฐ์ 1๋ฐฑ๋ง ์ดํ. | |
:์ถ๋ ฅ: | |
list of int: ์ ๋ ฌ๋ ๋ฐฐ์ด. ์ค๋ฆ์ฐจ์ ์ ๋ ฌํ๋, ํ์๋ ๋ฌด์กฐ๊ฑด ์ง์๋ณด๋ค ์์ ๋ค. | |
:ex: | |
[1, 4, 3, 2, 1, 5, 4, 2] --> [1, 1, 3, 5, 2, 2, 4, 4] | |
""" |
# 1. basic: using for loop | |
def is_palindrome_basic(word): | |
SIZE = len(word) | |
for i in range(SIZE // 2): | |
if word[i] != word[SIZE-1-i]: | |
return False | |
return True | |
# 2. Pythonic way: reversing word easily |
๊ฐ๋
์ ๋จธ๋ฆฌ๋ก ์ดํดํ๋ ๊ฒ์ ๋์ด, ํ์๊ณผ ์ํตํ๊ธฐ ์ํด์๋ ๊ทธ ์ด๋ฆ์ ์์์ผ ํฉ๋๋ค.
์ฌ๊ธฐ์๋ ํ๋ก๊ทธ๋๋ฐ์์ ๋งค์ฐ ๊ธฐ๋ณธ์ ์ธ ์ฉ์ด๋ฅผ ์กฐ๊ธ ์ ์ํด๋ณผ๊น ํฉ๋๋ค.
๋ด๊ฐ ๊ทธ์ ์ด๋ฆ์ ๋ถ๋ฌ์ฃผ๊ธฐ ์ ์๋ ๊ทธ๋ ๋ค๋ง ํ๋์ ๋ชธ์ง์ ์ง๋์ง ์์๋ค.
๋ด๊ฐ ๊ทธ์ ์ด๋ฆ์ ๋ถ๋ฌ์ฃผ์์ ๋, ๊ทธ๋ ๋์๊ฒ๋ก ์์ ๊ฝ์ด ๋์๋ค.๊น์ถ์ <๊ฝ>
ํ์ด์ฌ์์ ํด๋์ค๋ฅผ ์ฒ์ ๋ง๋ค๋ฉด ๋ชจ๋ ๋ฉ์๋์ ์ฒซ ์ธ์๋ 'self'๋ผ๊ณ ๋๊ณ ์์ํ๋๋ฐ์. ์ ๊ทธ๋ด๊น์? ์ค๋์ ๊ทธ ์ด์ ๋ฅผ ๊ฐ๋ตํ๊ฒ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
๋จผ์ ๊ฐ๋จํ ํด๋์ค๋ฅผ ๋ง๋ค์ด๋ณด๊ฒ ์ต๋๋ค.
class Person:
def __init__(self, name, job):
self.name = name
self.job = job
์ค๋์ ํด๋์ค์ ๋ํด ๊ณต๋ถํ์ต๋๋ค. ์ฌ์ค ํด๋์ค๋ผ๋ ๊ฐ๋ ์ด ์ด๋ ต๊ณ ์กฐ๊ธ์ ์ฒ ํ์ ์ด๊ธฐ๊น์ง ํด์ ์ดํด๊ฐ ์ ์ ๊ฐ์ค ์๋ ์์ต๋๋ค. ํ์ฌ๋ ์ดํด๊ฐ ๋น์ฅ์ ํ๋์ ๋ ์ ๋ง ๊ด์ฐฎ์ ๊ฒ ์ ๋ ์ด ๊ฐ๋ ์ ์ ๋ง ์ต์ํ์ด๋ผ๋ ์ดํดํ๋ ๋ฐ 1๋ ์ ๊ฑธ๋ฆฐ ๊ฒ ๊ฐ์ต๋๋ค. ํด๋์ค๋ ์ผ๋จ์ 'ํ์ค์ ์ค์ ๊ฐ๋ ๊ณผ ์ฌ๋ฌผ(์ธ๊ฐ, ์ฐจ, ๊ธธ๊ฑฐ๋ฆฌ์ BMW๋ฅผ)์ ํ๋ก๊ทธ๋๋ฐ์ ๋จ์๋ก ์ฌ์ฉํ๋ ๊ฒ'์ด๋ผ๊ณ ์๊ฐํ์ ๋ ๊ด์ฐฎ์ ๊ฒ ๊ฐ์ต๋๋ค. ๋ง์ด ์จ๋ณด๋ค ๋ณด๋ฉด ๊ฒฐ๊ตญ์๋ ์ดํดํ๊ฒ ๋ฉ๋๋ค.
์ฌ๊ธฐ์๋ ํด๋์ค ๋๋ OOP(Object-Oriented Programming) ์์ฒด๋ณด๋ค๋ ํ์ด์ฌ์์์ ํด๋์ค์ ํน์ง์ ๋ํด ๋ง์๋๋ฆฌ๋ ค๊ณ ํฉ๋๋ค. ํ์ด์ฌ์ ๊ณ์ ๊ณต๋ถํ์๋ฉด ๋ค์๊ณผ ๊ฐ์ ๋ช
์ ๋ฅผ ๋ค์ด๋ณด์ค ์๋ ์์ต๋๋ค. 'ํ์ด์ฌ์์๋ ๋ชจ๋ ๊ฒ์ด ํด๋์ค๋ค.'
์ด๊ฒ ๋๊ด์ ๋ฌด์จ ๋ป์ผ๊น์? ์ผ๋จ ์ ๋ช
์ ์์ฒด๋ '์ฐธ'(True)์
๋๋ค. ์ด ๊ธฐ์คํธ์์๋ ์ ๋ช
์ ๊ฐ ์ ์ฐธ์ธ์ง ๋๋ต์ ์ผ๋ก๋ผ๋ ํ์
ํด๋ณด๊ฒ ์ต๋๋ค.
์ ๋ช ์ ๋ฅผ ํ์ธํ๊ธฐ ์ํด ๋ด์ฅ ํจ์ isinstance, issubclass๋ฅผ ์ฌ์ฉํ๊ฒ ์ต๋๋ค. ๊ด๋ จ ๋ฌธ์(isinstance, issubclass)๊ฐ ์์ด์ ๋งค์ฐ ์์ธํ๊ฒ ์ค๋ช ํ์ง๋ ์์ง๋ง ๋ ํจ์๋ ํด๋์ค์ ๊ด๋ จํ ์ฐธ/๊ฑฐ์ง์ ํ๋ณํ๋ ํจ์์ ๋๋ค. ํ ์ค ์ค๋ช ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.