def solution(arrangement): answer = 0 # ์ ๋ง๋๊ธฐ ์กฐ๊ฐ ๋ณ์ stack = [] # ๋ฐฐ์ด ์์๋ก ๋ด์ ์คํ meet = False # )๋ง๋ฌ๋์ง ํ์ธ ์ฌ๋ถ for arr in arrangement: # (๋ฅผ ๋ง๋ ๊ฒฝ์ฐ if arr == '(': # ์คํ์ ์ ์ฅ stack.append(arr) meet = False # )๋ฅผ ๋ง๋ ๊ฒฝ์ฐ else: # ์คํ์์ ๊บผ๋ stack.pop() # )๊ฐ ์ฒ์์ผ๋ก ๋์ค๋๊ฒฝ์ฐ : ๋ ์ด์ ์๊ธฐ if meet == False: answer += len(stack) # )๊ฐ ์ฐ์์ผ๋ก ๋์ค๋๊ฒฝ์ฐ : ๋ง๋๊ธฐ๊ฐ ๋๋จ else: answer += 1 # )๋ฅผ ๋ง๋ฌ์ผ๋ True๋ก ์ ํ meet = True return answer ๋ญ๊ฐ ์๋นํ ์ฝ๊ณ ๋น ๋ฅด..
์ฒ์์ ์๊ฐํ์ ๋ minํจ์๋ฅผ ์จ์ ์ต์๊ฐ์ ์ฐพ์์ ๋น๊ตํ๋ ๋ฐฉ์์ ์๊ฐํ๋ค. ๊ทผ๋ฐ ์ด๋ ๊ฒํ๋ฉด ๋น๊ตํด์ผํ ๊ฒ๋ ๋ง๊ณ ์ด๋ค ์ ์ด ์ต์๊ฐ์ด ๋๋์ง ๋งค๋ฒ ๋ฌ๋ผ์ง ์ ์๊ธฐ ๋๋ฌธ์ ๋ง๋ ๋ฐฉ๋ฒ์ด ์๋๊ฒ๊ฐ๋ค. ๋ ๋ฒจ 1๋ฌธ์ ์ธ๋ฐ๋ ํ์ด ๋ฐฉ๋ฒ์ด ๋ ์ค๋ฅด์ง ์์๋๋ฐ ๊ฐ๊ฐ์ ์ซ์๊ฐ ์ ๋ถ ์ง์๊ฐ ๋์ด์ผ ์ ์ด ๋ค๊ฐ๊ฐ ๋ค ์๋๊ฒ์ด ๋๋๊น ํ์๊ฐ์ธ ์ซ์๋ฅผ ๋ฝ์์ ๋ฆฌํดํ๋ฉด ๋๋จธ์ง ํ ์ ์ ์ฐพ์ ์ ์์ ๊ฒ์ด๋ค. ์ ๋ฒ ์คํฐ๋๋ ์๊ฒ๋ collection ๋ชจ๋์ counter๋ฅผ ์ด์ฉํด์ ์ซ์๋ฅผ ๋ฝ์๋ด๋ณด๊ฒ ๋ค! import collections def solution(v): answer = [] # 2์ฐจ์ ๋ฆฌ์คํธ๋ฅผ 1์ฐจ์์ผ๋ก ๋ง๋ค๊ธฐ v = sum(v, []) # ๋ฆฌ์คํธ์์ ๊ฐ๋ค ์ซ์์ธ๊ธฐ v = collections.Counter(v) # ํ..
์คํธ ์คํ ๋๊ฐ๋ก FIFO ํ๋ฅผ ๊ตฌํํ ์ ์๊ตฌ๋ง ๋ชฐ๋๋ ์ฌ์ค! class MyStack(object): def __init__(self): self.lst = list() def push(self, x): self.lst.append(x) def pop(self): return self.lst.pop() def size(self): return len(self.lst) class MyQueue(object): def __init__(self, max_size): self.stack1 = MyStack() self.stack2 = MyStack() self.max_size = max_size def qsize(self): # ํ๊ฐ ๊ฐ์ง ์์ ์๋ฅผ ๋ฆฌํดํฉ๋๋ค. return self.stack1.size()..
๋ญ ๊ธธ๊ฒ ์์ฑํ ํ์์์ด ๋ฐ๋ก ๊ตฌํ ํด๋ณผ ์ ์์๊ฒ ๊ฐ์์ ์ฝ๋๋ก ๊ตฌํ์ ํ๋ค. (๋ด ๊ธ์จ ์์ ๋ฌ๋) def solution(scoville, K): answer = 0 while scoville[0] < K: scoville.sort() print("========================") print("์ค์ฝ๋น: {}".format(scoville)) new_scoville = scoville[0] + (scoville[1]*2) del scoville[0:2] print("์ค์ฝ๋น: {}".format(scoville)) scoville.append(new_scoville) answer+=1 if len(scoville) < 1: return -1 return answer scoville = [1..
์ฒ์์ ๋ฌธ์ ๋ฅผ ์ฝ์์ ๋ ์ด๊ฒ ๋ญ์๋ฆฐ๊ฐํ๋๋ฐ ๊ธ๋ฐฉ ์ดํดํ๋ค. ๋ญ ๋์ถฉ ์ ์ผ ํฐ์๋ฅผ ์ค์ด๋ฉด ๋ฐฐ์๋น์ฉ์ด ์ต์๊ฐ ๋๋๊น ์ ์ผ ํฐ ์๋ฅผ ๊น๋๊ฒ์ ๋ฐ๋ณตํด์ผํ๋ค๊ณ ์๊ฐํจ def solution(no, works): result = 0 # ์ ์ผ ํฐ ์๋ฅผ ์ผํด์ผ์ง ๋น์ฉ์ด ์ต์ํ๊ฐ ๋๋ค. -> ํฐ ์๋ฅผ ๊น์์ผํจ while no > 0 : works.sort() works[-1] -= 1 no -= 1 for n, i in enumerate(works): works[n] = i*i return sum(works) def solution(no, works): result = 0 # ์ ์ผ ํฐ ์๋ฅผ ์ผํด์ผ์ง ๋น์ฉ์ด ์ต์ํ๊ฐ ๋๋ค. -> ํฐ ์๋ฅผ ๊น์์ผํจ while no > 0 : works.sort() if works[-1] ..
์ด ๋ฌธ์ ๋ ๊ฝค ๊ฐ๋จํ๊ฒ ํ์ด ์กํ๋ค. from math import ceil def solution(progresses, speeds): answer = [] temp = 0 task = 1 for a, b in zip(progresses, speeds): day = ceil((100 - a) / b) if temp > day: task += 1 else: answer.append(task) task = 1 temp = day return answer progresses = [93, 30, 55, 4] speeds = [1, 30, 5, 95] print(solution(progresses,speeds)) ๋ฐ๋ก ๊ตฌํ ๋ผ์ ์คํจ ๋ค์ ์๊ฐํด๋ณด์ from math import ceil def solution..
def solution(s): # ์ต์ ์์ถ๊ฐ์ ์ฒ์์๋ ๋ฌธ์์ด์ ๊ธธ์ด๋ก ์ด๊ธฐํ (์ต๋๋ก ๋์ฌ ์ ์๋ ๊ฐ์ด ๋ฌธ์์ด์ ๊ธธ์ด์ด๋๊น) answer = len(s) for unit in range(len(s)): print("===================================") unit += 1 # ์์ถ ๋จ์์ด๋๊น 1์ ๋ํจ print("๋ฌธ์์ด ์์ถ ๋จ์ : {}".format(unit)) count = 1 # ๋ฐ๋ณต๋๋ ํ์ result = "" # ์์ถ๋ ๊ฒฐ๊ณผ ๋ฌธ์์ด, ๋จ์๊ฐ ๋ฐ๋๋๋ง๋ค ์ด๊ธฐํ compression_unit = s[:unit] # ์์ถ ๋ฌธ์์ด ์ ์ฅ print("์์ถ ๋ฌธ์์ด : {}".format(compression_unit)) for i in range(unit, len(s)..
- Total
- Today
- Yesterday
- ์๊ณ ๋ฆฌ์ฆ
- ๊ฒ์ํ ์ญ์
- ์ ์ฒด๊ฒ์๋ฌผ ์กฐํ
- java ํ๊ฒฝ๋ณ์
- java jdk ์ค์น
- ๊ฐ๋ฐ
- Java
- ๊ฒ์ํ๋ง๋ค๊ธฐ
- ๊ฒ์๋ฌผ์กฐํ
- ๊ฒ์๋ฌผ ์ญ์
- ์๋ฐ
- tomcat์ค์น
- mysql์ค์น
- ๊ฒ์ํ ์กฐํ
- ๋ณ๋ช ์ฒ๋ฆฌ
- ์ดํด๋ฆฝ์ค ์ค์น
- ์ดํด๋ฆฝ์ค ํ๊ธ ์ธ์ฝ๋ฉ
- ์๋ฃ๊ตฌ์กฐ
- ๋ถํธ ์๋์์ฑ
- ์จ๋ฆฌ์์ค
- ์คํ๋ง๋ถํธ ์๋์์ฑ
- ๊ฐ๋ฐํ๊ฒฝ๊ตฌ์ถ
- Algorithm
- typeAliases
์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | |||
5 | 6 | 7 | 8 | 9 | 10 | 11 |
12 | 13 | 14 | 15 | 16 | 17 | 18 |
19 | 20 | 21 | 22 | 23 | 24 | 25 |
26 | 27 | 28 | 29 | 30 | 31 |