๐ ํ์ด์ฌ ์ผ๋ก ํ์ด
๐ ๋ฌธ์ ๋งํฌ :
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
๐ ๋ฌธ์ ์ค๋ช :
์ค๋์ ์ ํํ๋ ์ฝ๋ผ ๋ฌธ์ ๊ฐ ์์ต๋๋ค. ์ฝ๋ผ ๋ฌธ์ ์ ์ง๋ฌธ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
์ ๋ต์ ์๋ฌด์๊ฒ๋ ๋งํ์ง ๋ง์ธ์.
์ฝ๋ผ ๋น ๋ณ 2๊ฐ๋ฅผ ๊ฐ์ ธ๋ค์ฃผ๋ฉด ์ฝ๋ผ 1๋ณ์ ์ฃผ๋ ๋งํธ๊ฐ ์๋ค. ๋น ๋ณ 20๊ฐ๋ฅผ ๊ฐ์ ธ๋ค์ฃผ๋ฉด ๋ช ๋ณ์ ๋ฐ์ ์ ์๋๊ฐ?
๋จ, ๋ณด์ ์ค์ธ ๋น ๋ณ์ด 2๊ฐ ๋ฏธ๋ง์ด๋ฉด, ์ฝ๋ผ๋ฅผ ๋ฐ์ ์ ์๋ค.
๋ฌธ์ ๋ฅผ ํ๋ ์๋น์ด๋ ์ฝ๋ผ ๋ฌธ์ ์ ์๋ฒฝํ ํด๋ต์ ์ฐพ์์ต๋๋ค. ์๋น์ด๊ฐ ํผ ๋ฐฉ๋ฒ์ ์๋ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ต๋๋ค. ์ฐ์ ์ฝ๋ผ ๋น ๋ณ 20๋ณ์ ๊ฐ์ ธ๊ฐ์ 10๋ณ์ ๋ฐ์ต๋๋ค. ๋ฐ์ 10๋ณ์ ๋ชจ๋ ๋ง์ ๋ค, ๊ฐ์ ธ๊ฐ์ 5๋ณ์ ๋ฐ์ต๋๋ค. 5๋ณ ์ค 4๋ณ์ ๋ชจ๋ ๋ง์ ๋ค ๊ฐ์ ธ๊ฐ์ 2๋ณ์ ๋ฐ๊ณ , ๋ 2๋ณ์ ๋ชจ๋ ๋ง์ ๋ค ๊ฐ์ ธ๊ฐ์ 1๋ณ์ ๋ฐ์ต๋๋ค. ๋ฐ์ 1๋ณ๊ณผ 5๋ณ์ ๋ฐ์์ ๋ ๋จ์ 1๋ณ์ ๋ชจ๋ ๋ง์ ๋ค ๊ฐ์ ธ๊ฐ๋ฉด 1๋ณ์ ๋ ๋ฐ์ ์ ์์ต๋๋ค. ์ด ๊ฒฝ์ฐ ์๋น์ด๋ ์ด 10 + 5 + 2 + 1 + 1 = 19๋ณ์ ์ฝ๋ผ๋ฅผ ๋ฐ์ ์ ์์ต๋๋ค.

๋ฌธ์ ๋ฅผ ์ด์ฌํ ํ๋ ์๋น์ด๋ ์ผ๋ฐํ๋ ์ฝ๋ผ ๋ฌธ์ ๋ฅผ ์๊ฐํ์ต๋๋ค. ์ด ๋ฌธ์ ๋ ๋น ๋ณ a๊ฐ๋ฅผ ๊ฐ์ ธ๋ค์ฃผ๋ฉด ์ฝ๋ผ b๋ณ์ ์ฃผ๋ ๋งํธ๊ฐ ์์ ๋, ๋น ๋ณ n๊ฐ๋ฅผ ๊ฐ์ ธ๋ค์ฃผ๋ฉด ๋ช ๋ณ์ ๋ฐ์ ์ ์๋์ง ๊ณ์ฐํ๋ ๋ฌธ์ ์ ๋๋ค. ๊ธฐ์กด ์ฝ๋ผ ๋ฌธ์ ์ ๋ง์ฐฌ๊ฐ์ง๋ก, ๋ณด์ ์ค์ธ ๋น ๋ณ์ด a๊ฐ ๋ฏธ๋ง์ด๋ฉด, ์ถ๊ฐ์ ์ผ๋ก ๋น ๋ณ์ ๋ฐ์ ์ ์์ต๋๋ค. ์๋น์ด๋ ์ด์ฌํ ๊ณ ์ฌํ์ง๋ง, ์ผ๋ฐํ๋ ์ฝ๋ผ ๋ฌธ์ ์ ๋ต์ ์ฐพ์ ์ ์์์ต๋๋ค. ์๋น์ด๋ฅผ ๋์, ์ผ๋ฐํ๋ ์ฝ๋ผ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ํ๋ก๊ทธ๋จ์ ๋ง๋ค์ด ์ฃผ์ธ์.
์ฝ๋ผ๋ฅผ ๋ฐ๊ธฐ ์ํด ๋งํธ์ ์ฃผ์ด์ผ ํ๋ ๋ณ ์ a, ๋น ๋ณ a๊ฐ๋ฅผ ๊ฐ์ ธ๋ค ์ฃผ๋ฉด ๋งํธ๊ฐ ์ฃผ๋ ์ฝ๋ผ ๋ณ ์ b, ์๋น์ด๊ฐ ๊ฐ์ง๊ณ ์๋ ๋น ๋ณ์ ๊ฐ์ n์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ์๋น์ด๊ฐ ๋ฐ์ ์ ์๋ ์ฝ๋ผ์ ๋ณ ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
๐ ์ ํ ์ฌํญ
- 1 ≤ b < a ≤ n ≤ 1,000,000
- ์ ๋ต์ ํญ์ int ๋ฒ์๋ฅผ ๋์ง ์๊ฒ ์ฃผ์ด์ง๋๋ค.
๐ ์ ์ถ๋ ฅ ์

์ถ์ธก)
* ๋งํธ๋ก ๊ฐ์ ธ๋ค ์ฃผ์ง ๋ชปํ๋ ๋๋จธ์ง๋ฅผ ๋ฒ๋ฆฌ์ง ๋ง๊ณ ๋ณ์๋ก ์ ์ฅํ ํ์๊ฐ ์๋ค.
* ๋งํธ๊ฐ ํญ์ 1๋ณ์ฉ๋ง ์ฃผ๋๊ฒ ์๋๋ผ b๋ณ์ ์ค ์๋ ์๋ค
- n % a ๊ฐ์ ๋จผ์ ์ ์ฅ = remain ๋์
- ๋งํธ์์ ๋ฐ์์จ n / a ๊ฐ์ ์ ์ฅ ํ๋ค = bottle
- bottle์ ๋ค์ remain ๊ฐ์ ๋ํด = n ๋์ (๋ฎ์ด์ฐ๊ธฐ)
- n % a ๊ฐ์ ๋ ์ ์ฅ = remain ๋์ (๋ฎ์ด์ฐ๊ธฐ)
- n / a ๊ฐ์ bottle์ +
- n๊ฐ์ด a๋ก ๋๋ ๋ชซ์ด 1์ด ๋์ง ๋ชปํ ๋ ๊น์ง ๋ฐ๋ณต > while๋ฌธ์ผ๋ก
- bottle ๊ฐ ๋ฐํ
์์ค์ฝ๋)
* 1์ฐจ) ์ฑ๊ณต : ๋ฉ๋ชจ๋ฆฌ: 10.3 MB, ์๊ฐ: 0.00 ms
def solution(a, b, n):
bottle = 0
while n / a >= 1 :
remain = n % a
n = (int(n / a)) * b
bottle += n
n = n + remain
return bottle
๋ฆฌ๋ทฐ)
์ถ์ธกํ๋๋ก ํ์ด์ง ๋ฌธ์ ! ์ถ์ธก๋๋ก ๋ก์ง์ง๋ณด๊ณ ์ฑ๊ณตํ๋ ์ด ๋ง์ ์๊ณ ๋ฆฌ์ฆ ํ์ง ๐
'Coding Test > Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| Programmers] ์ ๊ณ ๊ฒฐ๊ณผ ๋ฐ๊ธฐ (0) | 2023.02.22 |
|---|---|
| Programmers] ๋๋ง์ ์ํธ (0) | 2023.02.21 |
| Programmers] ์น์์ด (2) (0) | 2023.02.13 |
| Programmers] ํ๋ฒ๊ฑฐ ๋ง๋ค๊ธฐ (0) | 2023.02.13 |
| Programmers] ํธ๋ ํ์ดํธ ๋ํ (0) | 2023.02.13 |
