https://school.programmers.co.kr/learn/courses/30/lessons/250137
๋ฌธ์
๋ฌธ์ ์ค๋ช
์ด๋ค ๊ฒ์์๋ ๋ถ๋ ๊ฐ๊ธฐ๋ผ๋ ๊ธฐ์ ์ด ์์ต๋๋ค.
๋ถ๋ ๊ฐ๊ธฐ๋ t์ด ๋์ ๋ถ๋๋ฅผ ๊ฐ์ผ๋ฉด์ 1์ด๋ง๋ค x๋งํผ์ ์ฒด๋ ฅ์ ํ๋ณตํฉ๋๋ค. t์ด ์ฐ์์ผ๋ก ๋ถ๋๋ฅผ ๊ฐ๋ ๋ฐ ์ฑ๊ณตํ๋ค๋ฉด y๋งํผ์ ์ฒด๋ ฅ์ ์ถ๊ฐ๋ก ํ๋ณตํฉ๋๋ค. ๊ฒ์ ์บ๋ฆญํฐ์๋ ์ต๋ ์ฒด๋ ฅ์ด ์กด์ฌํด ํ์ฌ ์ฒด๋ ฅ์ด ์ต๋ ์ฒด๋ ฅ๋ณด๋ค ์ปค์ง๋ ๊ฒ์ ๋ถ๊ฐ๋ฅํฉ๋๋ค.
๊ธฐ์ ์ ์ฐ๋ ๋์ค ๋ชฌ์คํฐ์๊ฒ ๊ณต๊ฒฉ์ ๋นํ๋ฉด ๊ธฐ์ ์ด ์ทจ์๋๊ณ , ๊ณต๊ฒฉ์ ๋นํ๋ ์๊ฐ์๋ ์ฒด๋ ฅ์ ํ๋ณตํ ์ ์์ต๋๋ค. ๋ชฌ์คํฐ์๊ฒ ๊ณต๊ฒฉ๋นํด ๊ธฐ์ ์ด ์ทจ์๋นํ๊ฑฐ๋ ๊ธฐ์ ์ด ๋๋๋ฉด ๊ทธ ์ฆ์ ๋ถ๋ ๊ฐ๊ธฐ๋ฅผ ๋ค์ ์ฌ์ฉํ๋ฉฐ, ์ฐ์ ์ฑ๊ณต ์๊ฐ์ด 0์ผ๋ก ์ด๊ธฐํ๋ฉ๋๋ค.
๋ชฌ์คํฐ์ ๊ณต๊ฒฉ์ ๋ฐ์ผ๋ฉด ์ ํด์ง ํผํด๋๋งํผ ํ์ฌ ์ฒด๋ ฅ์ด ์ค์ด๋ญ๋๋ค. ์ด๋, ํ์ฌ ์ฒด๋ ฅ์ด 0 ์ดํ๊ฐ ๋๋ฉด ์บ๋ฆญํฐ๊ฐ ์ฃฝ์ผ๋ฉฐ ๋ ์ด์ ์ฒด๋ ฅ์ ํ๋ณตํ ์ ์์ต๋๋ค.
๋น์ ์ ๋ถ๋๊ฐ๊ธฐ ๊ธฐ์ ์ ์ ๋ณด, ์บ๋ฆญํฐ๊ฐ ๊ฐ์ง ์ต๋ ์ฒด๋ ฅ๊ณผ ๋ชฌ์คํฐ์ ๊ณต๊ฒฉ ํจํด์ด ์ฃผ์ด์ง ๋ ์บ๋ฆญํฐ๊ฐ ๋๊น์ง ์์กดํ ์ ์๋์ง ๊ถ๊ธํฉ๋๋ค.
๋ถ๋ ๊ฐ๊ธฐ ๊ธฐ์ ์ ์์ ์๊ฐ, 1์ด๋น ํ๋ณต๋, ์ถ๊ฐ ํ๋ณต๋์ ๋ด์ 1์ฐจ์ ์ ์ ๋ฐฐ์ด bandage์ ์ต๋ ์ฒด๋ ฅ์ ์๋ฏธํ๋ ์ ์ health, ๋ชฌ์คํฐ์ ๊ณต๊ฒฉ ์๊ฐ๊ณผ ํผํด๋์ ๋ด์ 2์ฐจ์ ์ ์ ๋ฐฐ์ด attacks๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ๋ชจ๋ ๊ณต๊ฒฉ์ด ๋๋ ์งํ ๋จ์ ์ฒด๋ ฅ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ๋ง์ฝ ๋ชฌ์คํฐ์ ๊ณต๊ฒฉ์ ๋ฐ๊ณ ์บ๋ฆญํฐ์ ์ฒด๋ ฅ์ด 0 ์ดํ๊ฐ ๋์ด ์ฃฝ๋๋ค๋ฉด -1์ return ํด์ฃผ์ธ์.
์ ํ ์ฌํญ
- bandage๋ [์์ ์๊ฐ, ์ด๋น ํ๋ณต๋, ์ถ๊ฐ ํ๋ณต๋] ํํ์ ๊ธธ์ด๊ฐ 3์ธ ์ ์ ๋ฐฐ์ด์ ๋๋ค.
- 1 ≤ ์์ ์๊ฐ = t ≤ 50
- 1 ≤ ์ด๋น ํ๋ณต๋ = x ≤ 100
- 1 ≤ ์ถ๊ฐ ํ๋ณต๋ = y ≤ 100
- 1 ≤ health ≤ 1,000
- 1 ≤ attacks์ ๊ธธ์ด ≤ 100
- attacks[i]๋ [๊ณต๊ฒฉ ์๊ฐ, ํผํด๋] ํํ์ ๊ธธ์ด๊ฐ 2์ธ ์ ์ ๋ฐฐ์ด์ ๋๋ค.
- attacks๋ ๊ณต๊ฒฉ ์๊ฐ์ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ๋ ์ํ์ ๋๋ค.
- attacks์ ๊ณต๊ฒฉ ์๊ฐ์ ๋ชจ๋ ๋ค๋ฆ ๋๋ค.
- 1 ≤ ๊ณต๊ฒฉ ์๊ฐ ≤ 1,000
- 1 ≤ ํผํด๋ ≤ 100
์ ์ถ๋ ฅ ์
bandage | health | attacks | result |
[5, 1, 5] | 30 | [[2, 10], [9, 15], [10, 5], [11, 5]] | 5 |
[3, 2, 7] | 20 | [[1, 15], [5, 16], [8, 6]] | -1 |
[4, 2, 7] | 20 | [[1, 15], [5, 16], [8, 6]] | -1 |
[1, 1, 1] | 5 | [[1, 2], [3, 2]] | 3 |
์์ค ์ฝ๋
def solution(bandage, health, attacks):
t, x, y = bandage
max = health
success = 0
# ๊ณต๊ฒฉ ๋นํ ์๊ฐ ๊ตฌํ๊ธฐ
attack_times = []
for attack in attacks:
attack_times.append(attack[0])
# ๋ง์ง๋ง ๊ณต๊ฒฉ๊น์ง ์์กด์ฌ๋ถ ํ์ธ
for now in range(1,attack_times[-1]+1):
# ๊ณต๊ฒฉ ๋นํ๋ฉด ์ฒด๋ ฅ๊ฐ์ ๋ฐ ์ฐ์์ฑ๊ณต ์ด๊ธฐํ
if now in attack_times:
idx = attack_times.index(now)
health -= attacks[idx][1]
success = 0
# ๊ณต๊ฒฉ ๋นํด์ ์ฒด๋ ฅ์ด ๋ฐ๋ฅ๋๋ ๊ฒฝ์ฐ
if health <= 0:
return -1
break
# ๊ณต๊ฒฉ ๋นํ์ง ์์ผ๋ฉด ๋ถ๋์คํฌ
else:
# ์ฒด๋ ฅ์ด ์ต๋์น๋ณด๋ค ์์ผ๋ฉด ํ๋ณต / ์ต๋์น์ด๊ฑฐ๋ ํฌ๋ฉด ์ต๋์น๋ก ์ด๊ธฐํ
# ๋ชฌ์คํฐ์ ๊ณต๊ฒฉ์ ๋ฐ์ง ์์์ผ๋ฏ๋ก ์ฐ์ ์ฑ๊ณต
if health < max:
health += x
else:
health = max
success += 1
if success == t:
health += y
success = 0
return health
ํ์ด
- ๋ถ๋๊ฐ๊ธฐ ์คํฌ ๋ฆฌ์คํธ์์ ์์ ์๊ฐ, ์ด๋น ํ๋ณต๋, ์ถ๊ฐ ํ๋ณต๋ ์ค์
- t = ์์ ์๊ฐ (๋ถ๋๊ฐ๊ธฐ ์คํฌ์ ์ต๋ ์งํ์๊ฐ)
- x = ์ด๋น ํ๋ณต๋ (1์ด๋์ ํ๋ณต๋)
- y = ์ถ๊ฐ ํ๋ณต๋ (t์๊ฐ๋งํผ ๋ถ๋๊ฐ๊ธฐ ์คํฌ์ ์ฑ๊ณตํ ๊ฒฝ์ฐ ์ถ๊ฐ ํ๋ณต)
- ์ฒด๋ ฅ์ ์ต๋์น max, ์ฐ์์ฑ๊ณต ํ์ succes ์ค์
- ๋ชฌ์คํฐ์๊ฒ ๊ณต๊ฒฉ๋นํ ์๊ฐ์ attack_times์ ์ถ๊ฐ
- ๋ง์ง๋ง ๊ณต๊ฒฉ์๊ฐ๊น์ง for๋ฌธ์ ๋๋ฉด์ ๊ณต๊ฒฉ์ฌ๋ถ ํ์ธ
- ํ์ฌ ์๊ฐ์ด ๊ณต๊ฒฉ๋นํ ์๊ฐ attack_times์ ์์ผ๋ฉด ์ฒด๋ ฅ๊ฐ์ ๋ฐ ์ฐ์์ฑ๊ณต ์ด๊ธฐํ
- ๊ณต๊ฒฉ์ ๋นํด์ ์ฒด๋ ฅ์ด 0๋ณด๋ค ์์์ง๋ฉด -1์ ๋ฆฌํดํ๊ณ ์ข ๋ฃ
- ๊ณต๊ฒฉ๋นํ์ง ์์์ผ๋ฉด ๋ถ๋๊ฐ๊ธฐ๋ก ์ฒด๋ ฅ ํ๋ณต
- ์ฒด๋ ฅ์ด max๋ณด๋ค ์์ผ๋ฉด ํ๋ณตํ๊ณ max๋ณด๋ค ํฌ๋ฉด max๋ก ์ด๊ธฐํ
- ์ฐ์ ์ฑ๊ณตํ์ ๊ฒฝ์ฐ ์ถ๊ฐ ํ๋ณต
- ํ์ฌ ์๊ฐ์ด ๊ณต๊ฒฉ๋นํ ์๊ฐ attack_times์ ์์ผ๋ฉด ์ฒด๋ ฅ๊ฐ์ ๋ฐ ์ฐ์์ฑ๊ณต ์ด๊ธฐํ
์กฐ๊ฑด์ด ๋ง๊ธด ํ๋ฐ ๋ณต์กํ์ง๋ ์์์ ํ๋์ฉ ์๊ฐํ๋ฉด์ ํธ๋๊น ์์ธ๋ก ๊ธ๋ฐฉ ํ๋ฆฐ ๋ฌธ์ ์๋ค. ํ๋ก๊ทธ๋๋จธ์ค๋ ์ฌ๋ฏธ์๋ ๋ฌธ์ ์ํฉ์ด ๋ง์์ ์ข๋ค..ใ ใ ....
'์ฝ๋ฉ ๋ฌธ์ ํ์ด ๐ป > ํ๋ก๊ทธ๋๋จธ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค / ํ์ด์ฌ] Lv.2 ๊ดํธ ํ์ ํ๊ธฐ (0) | 2024.07.01 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค / ํ์ด์ฌ] Lv.1 ๊ฐ์ฅ ๋ง์ด ๋ฐ์ ์ ๋ฌผ (2) | 2024.01.08 |
[ํ๋ก๊ทธ๋๋จธ์ค / ํ์ด์ฌ] Lv.1 ๊ณต์ ์ฐ์ฑ (0) | 2024.01.05 |
[ํ๋ก๊ทธ๋๋จธ์ค / ํ์ด์ฌ] Lv.1 ๊ธฐ์ฌ๋จ์์ ๋ฌด๊ธฐ (1) | 2023.12.22 |
[ํ๋ก๊ทธ๋๋จธ์ค / ํ์ด์ฌ] Lv.1 ์ซ์ ์ง๊ฟ (0) | 2023.12.15 |