https://school.programmers.co.kr/learn/courses/30/lessons/42586
๋ฌธ์
๋ฌธ์ ์ค๋ช
ํ๋ก๊ทธ๋๋จธ์ค ํ์์๋ ๊ธฐ๋ฅ ๊ฐ์ ์์
์ ์ํ ์ค์
๋๋ค. ๊ฐ ๊ธฐ๋ฅ์ ์ง๋๊ฐ 100%์ผ ๋ ์๋น์ค์ ๋ฐ์ํ ์ ์์ต๋๋ค.
๋, ๊ฐ ๊ธฐ๋ฅ์ ๊ฐ๋ฐ์๋๋ ๋ชจ๋ ๋ค๋ฅด๊ธฐ ๋๋ฌธ์ ๋ค์ ์๋ ๊ธฐ๋ฅ์ด ์์ ์๋ ๊ธฐ๋ฅ๋ณด๋ค ๋จผ์ ๊ฐ๋ฐ๋ ์ ์๊ณ , ์ด๋ ๋ค์ ์๋ ๊ธฐ๋ฅ์ ์์ ์๋ ๊ธฐ๋ฅ์ด ๋ฐฐํฌ๋ ๋ ํจ๊ป ๋ฐฐํฌ๋ฉ๋๋ค.
๋จผ์ ๋ฐฐํฌ๋์ด์ผ ํ๋ ์์๋๋ก ์์
์ ์ง๋๊ฐ ์ ํ ์ ์ ๋ฐฐ์ด progresses์ ๊ฐ ์์
์ ๊ฐ๋ฐ ์๋๊ฐ ์ ํ ์ ์ ๋ฐฐ์ด speeds๊ฐ ์ฃผ์ด์ง ๋ ๊ฐ ๋ฐฐํฌ๋ง๋ค ๋ช ๊ฐ์ ๊ธฐ๋ฅ์ด ๋ฐฐํฌ๋๋์ง๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํ์ธ์.
์ ํ ์ฌํญ
- ์์ ์ ๊ฐ์(progresses, speeds๋ฐฐ์ด์ ๊ธธ์ด)๋ 100๊ฐ ์ดํ์ ๋๋ค.
- ์์ ์ง๋๋ 100 ๋ฏธ๋ง์ ์์ฐ์์ ๋๋ค.
- ์์ ์๋๋ 100 ์ดํ์ ์์ฐ์์ ๋๋ค.
- ๋ฐฐํฌ๋ ํ๋ฃจ์ ํ ๋ฒ๋ง ํ ์ ์์ผ๋ฉฐ, ํ๋ฃจ์ ๋์ ์ด๋ฃจ์ด์ง๋ค๊ณ ๊ฐ์ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด ์ง๋์จ์ด 95%์ธ ์์
์
๊ฐ๋ฐ ์๋๊ฐ ํ๋ฃจ์ 4%๋ผ๋ฉด ๋ฐฐํฌ๋ 2์ผ ๋ค์ ์ด๋ฃจ์ด์ง๋๋ค.
์ ์ถ๋ ฅ ์
progresses | speeds | return |
[93, 30, 55] | [1, 30, 5] | [2, 1] |
[95, 90, 99, 99, 80, 99] | [1, 1, 1, 1, 1] | [1, 3, 2] |
์์ค ์ฝ๋
# 1
import math
def solution(progresses, speeds):
n = len(progresses)
answers = []
# ๊ฐ ์์
์ด 100% ๋๊ธฐ ์ํด ๊ฑธ๋ฆฌ๋ ์๊ฐ
times = [math.ceil((100-progresses[i])/speeds[i]) for i in range(n)]
cnt = 1 # ์๋ฃ๋ ์์
์ ์
max_time = times[0] # ์ฒซ ๋ฒ์งธ ์์
์ ์๊ฐ์ max_time์ผ๋ก ์ง์
# ์๊ฐ ๋ฆฌ์คํธ๋ฅผ ๋๋ฉด์ max_time๊ณผ ๋น๊ต
for i in range(1,n):
if times[i] <= max_time: # 1. ํ์ํ ์๊ฐ์ด max_time๋ณด๋ค ์ ์ผ๋ฉด
cnt += 1 # ์์
์ด ์๋ฃ๋ ๊ฒ์ด๋ฏ๋ก ์์
์ ์ +1
else: # 2. ํ์ํ ์๊ฐ์ด max_time๋ณด๋ค ๋ง์ผ๋ฉด
answers.append(cnt) # ํ์ฌ๊น์ง ์๋ฃํ ์์
์ ์๋ฅผ answers์ ์ถ๊ฐ
max_time = times[i] # max_time์ ํ์ฌ ์์
์ ๋จ์์๊ฐ์ผ๋ก ๋ณ๊ฒฝ
cnt = 1 # ์์
์ ์ ์ด๊ธฐํ
answers.append(cnt) # 3. ๋ง์ง๋ง ์์
์ด ์ถ๊ฐ๋์ง ์๊ณ for๋ฌธ ์ข
๋ฃ๋์์ผ๋ฏ๋ก ๋ง์ง๋ง ์์
์ ์ถ๊ฐ
return answers
ํ์ด #1
- ์ฃผ์ด์ง ์์ ์ ์๋ฅผ n์ผ๋ก ์ ์
- ์๋์ ๊ณต์์ ์ฐธ๊ณ ํ์ฌ ๊ฐ ์์
์ด ์๋ฃ๋๋ ค๋ฉด ๊ฑธ๋ฆฌ๋ ์๊ฐ์ times ๋ฆฌ์คํธ๋ก ์์ฑ
- progresses(ํ์ฌ ์๋ฃ๋ ์์ ์ ์ ๋) + (speeds(์์ ์ ์๋) * times(์์ ์๊ฐ) = 100%
- cnt : ์๋ฃ๋ ์์ ์ ์ / max_time : ์๋ถ๋ถ ์์ ์ด ์๋ฃ๋๋ ค๋ฉด ๊ฑธ๋ฆฌ๋ ์๊ฐ
- ํ์ฌ ์์
์ ๋จ์ ์๊ฐ(times[i])๊ณผ ๊ธฐ์ค์ด ๋๋ ์๊ฐ(max_time)์ ๋น๊ต
- times[i] ๊ฐ max_time๋ณด๋ค ์ ๋ค๋ฉด ํ์ฌ์ ์์ ์ด ์๋ฃ๋ ๊ฒ์ด๋ฏ๋ก cnt + 1
- times[i]๊ฐ max_time๋ณด๋ค ๋ง๋ค๋ฉด ์์
์ด ์๋ฃ๋๊ธฐ๊น์ง ์๊ฐ์ด ๋ ํ์ํ ๊ฒ
- ํ์ฌ๊น์ง ์๋ฃ๋ ์์ ์ ์๋ฅผ answers์ ์ถ๊ฐ
- ๊ธฐ์ค์ด ๋๋ ์๊ฐ(max_time)์ ํ์ฌ ์๊ฐ์ผ๋ก ๋ฐ๊พธ๊ณ cnt๋ ์ด๊ธฐํ
# 2
def solution(progresses, speeds):
answers = []
time = 0 # ์์
์ด ํ์ํ ์๊ฐ
cnt = 0 # ์๋ฃ๋ ์์
์ ์
while len(progresses) > 0:
# 1. ์งํ ์ํฉ์ด 100 ์ด์์ด ๋ ๊ฒฝ์ฐ
if(progresses[0] + time * speeds[0]) >= 100:
progresses.pop(0) # ์์
์ด ์๋ฃ๋ ๊ฒ์ด๋ฏ๋ก progresses์์ ํด๋น ์์
์ ๊ฑฐ
speeds.pop(0) # ์์
๊ณผ ์๋์ ์ธ๋ฑ์ค๋ฅผ ๋ง์ถ์ด์ผ ํ๋ฏ๋ก speeds์์๋ ์ ๊ฑฐ
cnt += 1 # ์์
์ ์ + 1
# 2. ์งํ ์ํฉ์ด 100 ๋ฏธ๋ง์ธ ๊ฒฝ์ฐ
else:
if cnt > 0: # ์๋ฃ๋ ์์
์ด ์๋ค๋ฉด
answers.append(cnt) # ํ์ฌ๊น์ง ์๋ฃํ ์์
์ answers์ ์ถ๊ฐ
cnt = 0 # ์์
์ ์ ์ด๊ธฐํ
else: # ์๋ฃ๋ ์์
์ด ์๋ค๋ฉด
time += 1 # ํ์ํ ์๊ฐ์ ์ถ๊ฐ
# 3. ๋ง์ง๋ง ์์
์ด ์ถ๊ฐ๋์ง ์๊ณ while๋ฌธ ์ข
๋ฃ๋์์ผ๋ฏ๋ก ๋ง์ง๋ง ์์
์ ์ถ๊ฐ
answers.append(cnt)
return answers
ํ์ด #2
- ์์ ์ด ํ์ํ ์๊ฐ๊ณผ ์๋ฃ๋ ์์ ์ ์๋ฅผ ๊ฐ๊ฐ time, cnt๋ก ์ ์
- ์งํ ์ค์ธ ์์
์ด ์๋ ๋ฆฌ์คํธ(progresses)์ ๊ธธ์ด๊ฐ 0๋ณด๋ค ํฌ๋ฉด ์๋์ ๋ด์ฉ์ ๋ฐ๋ณตํด์ ์งํ
- ์๋์ ๊ณต์์ด 100์ด์์ด๋ฉด ์์
์ด ์๋ฃ๋ ๊ฒ์ด๋ฏ๋ก progresses์ speed์์ ํด๋น ์์
์ ๊ฑฐ
- progresses(ํ์ฌ ์๋ฃ๋ ์์ ์ ์ ๋) + (speeds(์์ ์ ์๋) * times(์์ ์๊ฐ) = 100%
- ์๋ฃ๋ ์์ ์ ์ cnt + 1
- cnt๊ฐ 0๋ณด๋ค ํฌ๋ค๋ฉด ์๋ฃ๋ ์์ ์ด ์๋ ๊ฒ์ด๋ฏ๋ก answers์ ์๋ฃ๋ ์์ ์ ์ ์ถ๊ฐํ๊ณ ์ด๊ธฐํ
- ์๋ฃ๋ ์์ ์ด ์๋ค๋ฉด ์๊ฐ์ด ๋ ํ์ํ ๊ฒ์ด๋ฏ๋ก ์๊ฐ์ ์ถ๊ฐ
- ์๋์ ๊ณต์์ด 100์ด์์ด๋ฉด ์์
์ด ์๋ฃ๋ ๊ฒ์ด๋ฏ๋ก progresses์ speed์์ ํด๋น ์์
์ ๊ฑฐ
์ฝ๊ฒ ํ๋ฆด ๊ฒ ๊ฐ์๋๋ฐ ์๊ทผํ ํ๊ธฐ ์ด๋ ค์ด ๋ฌธ์ ์๋ค.....๊ฑธ๋ฆฌ๋ ์๊ฐ์ ๊ธฐ์ค์ผ๋ก ๋๊ณ ๋น๊ตํ๋ ๋ฐฉ๋ฒ๊ณผ ์งํ์ํฉ์ ํ๋จํด์ ๋น๊ตํ๋ 2๊ฐ์ง ๋ฐฉ๋ฒ์ด ์์ด์ ํธํ ๋ฐฉ๋ฒ์ผ๋ก ์ฌ์ฉํ๋ฉด ์ข์ ๊ฒ ๊ฐ๋ค.
'์ฝ๋ฉ ๋ฌธ์ ํ์ด ๐ป > ํ๋ก๊ทธ๋๋จธ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค / ํ์ด์ฌ] Lv.2 ์ฃผ์๊ฐ๊ฒฉ (0) | 2024.07.01 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค / ํ์ด์ฌ] Lv.2 ๊ดํธ ํ์ ํ๊ธฐ (0) | 2024.07.01 |
[ํ๋ก๊ทธ๋๋จธ์ค / ํ์ด์ฌ] Lv.1 ๊ฐ์ฅ ๋ง์ด ๋ฐ์ ์ ๋ฌผ (2) | 2024.01.08 |
[ํ๋ก๊ทธ๋๋จธ์ค / ํ์ด์ฌ] Lv.1 [PCCP ๊ธฐ์ถ๋ฌธ์ ] 1๋ฒ / ๋ถ๋ ๊ฐ๊ธฐ (1) | 2024.01.07 |
[ํ๋ก๊ทธ๋๋จธ์ค / ํ์ด์ฌ] Lv.1 ๊ณต์ ์ฐ์ฑ (0) | 2024.01.05 |