[ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ฉํ ์คํธ ์ฐ์ต_Level 2] ์ฐ๋ฐ์์ด ์ ์ ๋ถ ํ๋ฌ ๊ฐ๊ธฐ
โ ๋ฌธ์ ์ค๋ช
์ฝ๋ผ์ธ ์ถ์ธก์ด๋ ๋กํ๋ฅด ์ฝ๋ผ์ธ (Lothar Collatz)๊ฐ 1937๋ ์ ์ ๊ธฐํ ์ถ์ธก์ผ๋ก ๋ชจ๋ ์์ฐ์ n์ ๋ํด ๋ค์ ์์ ์ ๋ฐ๋ณตํ๋ฉด ํญ์ 1๋ก ๋ง๋ค ์ ์๋ค๋ ์ถ์ธก์ ๋๋ค.
1-1. ์
๋ ฅ๋ ์๊ฐ ์ง์๋ผ๋ฉด 2๋ก ๋๋๋๋ค.
1-2. ์
๋ ฅ๋ ์๊ฐ ํ์๋ผ๋ฉด 3์ ๊ณฑํ๊ณ 1์ ๋ํฉ๋๋ค.
2. ๊ฒฐ๊ณผ๋ก ๋์จ ์๊ฐ 1๋ณด๋ค ํฌ๋ค๋ฉด 1๋ฒ ์์
์ ๋ฐ๋ณตํฉ๋๋ค.
์๋ฅผ ๋ค์ด ์ฃผ์ด์ง ์๊ฐ 5 ๋ผ๋ฉด 5 ⇒ 16 ⇒ 8 ⇒ 4 ⇒2 ⇒ 1 ์ด ๋์ด ์ด 5๋ฒ ๋ง์ 1์ด ๋ฉ๋๋ค.
์๊ฐ ์ปค์ก๋ค ์์์ง๊ธฐ๋ฅผ ๋ฐ๋ณตํ๋ ๋ชจ์ต์ด ๋น๊ตฌ๋ฆ์์ ๋น๋ฐฉ์ธ์ด ์ค๋ฅด๋ฝ๋ด๋ฆฌ๋ฝํ๋ฉฐ ์ฐ๋ฐ์ด ๋๋ ๋ชจ์ต๊ณผ ๋น์ทํ๋ค๊ณ ํ์ฌ ์ฐ๋ฐ์ ๋๋ ์ฐ๋ฐ์์ด๋ก ๋ถ๋ฆฌ๊ธฐ๋ ํฉ๋๋ค. ํ์ฌ ์ด ์ถ์ธก์ด ์ฐธ์ธ์ง ๊ฑฐ์ง์ธ์ง ์ฆ๋ช ๋์ง ์์์ง๋ง ์ฝ 1ํด๊น์ง์ ์์์ ๋ฐ๋ก๊ฐ ์์์ด ๋ฐํ์ ธ ์์ต๋๋ค.
์์ง๋ ์ฐ๋ฐ์์ด์ ์ขํ ํ๋ฉด ์์ ๊บพ์์ ๊ทธ๋ํ๋ก ๋ํ๋ด๋ณด๋ ค๊ณ ํฉ๋๋ค. ์ดํญ์ด K์ธ ์ฐ๋ฐ์์ด์ด ์๋ค๋ฉด, x = 0์ผ ๋ y = K์ด๊ณ ๋ค์ ์ฐ๋ฐ์๋ x = 1์ ํ์ํฉ๋๋ค. ์ด๋ฐ ์์ผ๋ก ์ฐ๋ฐ์๊ฐ 1์ด ๋ ๋๊น์ง ์ ๋ค์ ์ฐ๊ณ ์ธ์ ํ ์ ๋ค๋ผ๋ฆฌ ์ง์ ์ผ๋ก ์ฐ๊ฒฐํ๋ฉด ๋ค์๊ณผ ๊ฐ์ด ๊บพ์์ ๊ทธ๋ํ๋ฅผ ๋ง๋ค ์ ์์ต๋๋ค.
์์ง๋ ์ด๋ ๊ฒ ๋ง๋ ๊บพ์์ ๊ทธ๋ํ๋ฅผ ์ ์ ๋ถ ํด๋ณด๊ณ ์ถ์ด ์ก์ต๋๋ค. x์ ๋ํ ์ด๋ค ๋ฒ์ [a, b]๊ฐ ์ฃผ์ด์ง๋ค๋ฉด ์ด ๋ฒ์์ ๋ํ ์ ์ ๋ถ ๊ฒฐ๊ณผ๋ ๊บพ์์ ๊ทธ๋ํ์ x = a, x = b, y = 0์ผ๋ก ๋๋ฌ ์์ธ ๊ณต๊ฐ์ ๋ฉด์ ๊ณผ ๊ฐ์ต๋๋ค. ์์ง๋ ์ด๊ฒ์ ์ฐ๋ฐ์์ด ์ ์ ๋ถ์ด๋ผ๊ณ ์ ์ํ์๊ณ ๋ค์ํ ๊ตฌ๊ฐ์ ๋ํด์ ์ฐ๋ฐ์์ด ์ ์ ๋ถ์ ํด๋ณด๋ ค๊ณ ํฉ๋๋ค.
๋จ, ์ฐ๋ฐ์์ด ๊ทธ๋ํ์ ๊ฐ๋ก์ถ ๊ธธ์ด๋ฅผ ๋ฏธ๋ฆฌ ์ ์ ์๊ธฐ ๋๋ฌธ์ ๊ตฌ๊ฐ์ ์์์ ์์ด ์๋ ์ ์, ๊ตฌ๊ฐ์ ๋์ ์์ด ์๋ ์ ์๋ก ํํํฉ๋๋ค. ์ด๋ ๊ฐ๊ฐ ๊บพ์์ ๊ทธ๋ํ๊ฐ ์์ํ๋ ์ ๊ณผ ๋๋๋ ์ ์ x์ขํ์ ๋ํ ์๋์ ์ธ ์คํ์ ์ ์๋ฏธํฉ๋๋ค.
์๋ฅผ ๋ค์ด, 5๋ฅผ ์ดํญ์ผ๋ก ํ๋ ์ฐ๋ฐ์์ด์ 5 ⇒ 16 ⇒ 8 ⇒ 4 ⇒ 2 ⇒ 1์ ๋๋ค. ์ด๋ฅผ ์ขํ ํ๋ฉด์ผ๋ก ์ฎ๊ธฐ๋ฉด (0, 5), (1, 16), (2, 8), (3, 4), (4, 2), (5, 1)์ ์ ์ด ์ฐํ๊ณ ์ ๋ค์ ์ฐ๊ฒฐํ๋ฉด ๊บพ์์ ๊ทธ๋ํ๊ฐ ๋์ต๋๋ค. ์ด๋ฅผ [0,0] ๊ตฌ๊ฐ์ ๋ํด ์ ์ ๋ถ ํ๋ค๋ฉด ์ ์ฒด ๊ตฌ๊ฐ์ ๋ํ ์ ์ ๋ถ์ด๋ฉฐ, [1,-2] ๊ตฌ๊ฐ์ ๋ํด ์ ์ ๋ถ ํ๋ค๋ฉด 1 ≤ x ≤ 3์ธ ๊ตฌ๊ฐ์ ๋ํ ์ ์ ๋ถ์ ๋๋ค.
์ฐ๋ฐ์์ ์ดํญ k์, ์ ์ ๋ถ์ ๊ตฌํ๋ ๊ตฌ๊ฐ๋ค์ ๋ชฉ๋ก ranges๊ฐ ์ฃผ์ด์ก์ ๋ ์ ์ ๋ถ์ ๊ฒฐ๊ณผ ๋ชฉ๋ก์ return ํ๋๋ก solution์ ์์ฑํด ์ฃผ์ธ์. ๋จ, ์ฃผ์ด์ง ๊ตฌ๊ฐ์ ์์์ ์ด ๋์ ๋ณด๋ค ์ปค์ ์ ํจํ์ง ์์ ๊ตฌ๊ฐ์ด ์ฃผ์ด์ง ์ ์์ผ๋ฉฐ ์ด๋์ ์ ์ ๋ถ ๊ฒฐ๊ณผ๋ -1๋ก ์ ์ํฉ๋๋ค.
โ ์ ํ ์กฐ๊ฑด
- 2 ≤ k ≤ 10,000
- 1 ≤ ranges์ ๊ธธ์ด ≤ 10,000
- ranges์ ์์๋ [a, b] ํ์์ด๋ฉฐ 0 ≤ a < 200, -200 < b ≤ 0 ์ ๋๋ค.
- ์ฃผ์ด์ง ๋ชจ๋ ์ ๋ ฅ์ ๋ํด ์ ์ ๋ถ์ ๊ฒฐ๊ณผ๋ 227์ ๋์ง ์์ต๋๋ค.
- ๋ณธ ๋ฌธ์ ๋ ์ ๋ต์ ์ค์ํ์ด ํฌํจ๋๋ ๋ฌธ์ ์ ๋๋ค. ์ ์ถ๋ ฅ ์์ ์์ ๋ถ๋ถ. 0์ด ์ฝ๋ ์คํ ๋ฒํผ ํด๋ฆญ ํ ๋ํ๋๋ ๊ฒฐ๊ด๊ฐ, ๊ธฐ๋๊ฐ ํ์์ ๋ค๋ฅผ ์ ์์ต๋๋ค.
โ๏ธ ์ ์ถ๋ ฅ ์
k | ranges | result |
5 | [[0,0],[0,-1],[2,-3],[3,-3]] | [33.0,31.5,0.0,-1.0] |
์
์ถ๋ ฅ ์ #1
5๋ก ์์ํ๋ ์ฐ๋ฐ์์ด์ 5 ⇒ 16 ⇒ 8 ⇒ 4 ⇒ 2 ⇒ 1์
๋๋ค. ๊ทธ๋ํ์์ ๊บพ์ด๋ ์ง์ ์ ๊ฒฝ๊ณ๋ก 5๊ฐ์ ๊ตฌ์ญ์ผ๋ก ๋๋ ๋ณด๋ฉด ๊ฐ๊ฐ์ ๊ตฌ๊ฐ ๋์ด๋ 10.5, 12, 6, 3, 1.5์
๋๋ค.
๐ก ํ์ด
๐ ๊ธฐ๋ณธ ์์ด๋์ด
- ์ฝ๋ผ์ธ ์ถ์ธก
- ์๊ฐ 1์ด ๋ ๋๊น์ง ๋ฐ๋ณต
- while ๋ฐ๋ณต๋ฌธ์ ํตํด ํน์ ์กฐ๊ฑด(k==1)์ด ๋ ๋๊น์ง ๋ฐ๋ณต
- ์กฐ๊ฑด๋ฌธ์ ํตํด k๊ฐ ์ง์์ ํ์์ผ ๊ฒฝ์ฐ ๊ฐ๊ฐ ๋ค๋ฅด๊ฒ ์ฐ์ฐ
- ์๊ฐ 1์ด ๋ ๋๊น์ง ๋ฐ๋ณต
- ์ฐ๋ฐ์์ด์ ์ขํ ํ๋ฉด ์์ ๊บพ์์ ๊ทธ๋ํ
- ์ขํ (x, y)๋ x๋ ์ฐ์ฐ์ ์งํํ ํ์, y๋ ํด๋น ์ฐ์ฐ ํ์ ์
- ๋ฐ๋ผ์ ์์ ์งํํ ๋ฐ๋ณต๋ฌธ์์ ์ฐ์ฐ ํ์ ์๋ฅผ y_lst๋ก ์์ฐจ์ ์ ์ฅ
- ์ขํ (x, y)๋ x๋ ์ฐ์ฐ์ ์งํํ ํ์, y๋ ํด๋น ์ฐ์ฐ ํ์ ์
- ๊บพ์์ ๊ทธ๋ํ๋ฅผ ์ ์ ๋ถ
- ๋จ, ์ฐ๋ฐ์์ด ๊ทธ๋ํ์ ๊ฐ๋ก์ถ ๊ธธ์ด๋ฅผ ๋ฏธ๋ฆฌ ์ ์ ์๊ธฐ ๋๋ฌธ์ ๊ตฌ๊ฐ์ ์์์ ์์ด ์๋ ์ ์, ๊ตฌ๊ฐ์ ๋์ ์์ด ์๋ ์ ์๋ก ํํํฉ๋๋ค. ์ด๋ ๊ฐ๊ฐ ๊บพ์์ ๊ทธ๋ํ๊ฐ ์์ํ๋ ์ ๊ณผ ๋๋๋ ์ ์ x์ขํ์ ๋ํ ์๋์ ์ธ ์คํ์
์ ์๋ฏธ
- ๊ตฌ๊ฐ์ ์์์ ์ ๋ ฅ๊ฐ ๊ทธ๋๋ก ์ธ์
- ๊ตฌ๊ฐ์ ๋์ (๊ฐ๋ก์ถ์ ๊ธธ์ด + ์ ๋ ฅ๊ฐ - 1)๋ก ์ธ์
- ๋จ, ์ฃผ์ด์ง ๊ตฌ๊ฐ์ ์์์ ์ด ๋์ ๋ณด๋ค ์ปค์ ์ ํจํ์ง ์์ ๊ตฌ๊ฐ์ด ์ฃผ์ด์ง ์ ์์ผ๋ฉฐ ์ด๋์ ์ ์ ๋ถ ๊ฒฐ๊ณผ๋ -1๋ก ์ ์
- ๊ตฌ๊ฐ์ ์์๊ณผ ๋ ๋น๊ต ํ์ ⇒ ์ธ๋ชจ์๋ ์ฐ์ฐ์ ์ค์ด๊ธฐ ์ํด ์ ๋น๊ต ํ ์ฐ์ฐ
- ๊ตฌ๊ฐ์ ์์ > ๊ตฌ๊ฐ ๋ : -1
- ๊ตฌ๊ฐ์ ์์ == ๊ตฌ๊ฐ ๋ : 0
- ๊ตฌ๊ฐ์ ์์ < ๊ตฌ๊ฐ ๋ : ์ฐ์ฐ ์งํ
- ๊ตฌ๊ฐ์ ์์๊ณผ ๋ ๋น๊ต ํ์ ⇒ ์ธ๋ชจ์๋ ์ฐ์ฐ์ ์ค์ด๊ธฐ ์ํด ์ ๋น๊ต ํ ์ฐ์ฐ
- ์ ์ ๋ถ
- ์ฐ๋ฐ์์ด์ ๊บพ์์ ๊ทธ๋ํ๋ก ๋ํ๋ธ ๊ฒ์ ์ ๋ถ์ ์งํํด์ฃผ๊ธฐ ์ํด ๊ตฌ๊ฐ์ ๋๋์ด ์งํ
- ์ด๋, x๋ ์ฐ์ฐ์ ์งํํ ํ์๋ก ์ ์๊ฐ์ ๊ฐ์ง๊ธฐ ๋๋ฌธ์ ๊ตฌ๊ฐ์ [0,1], [1,2]...๋ก ๋๋ ์ ์์
- ๊ฐ๊ฐ ๊ตฌ๊ฐ์์ ์ผ์ฐจ ํจ์์ ๋ชจ์์ ๊ฐ์ง๋ฏ๋ก ๊ฐ๋จํ ์ฐ์ฐ ์งํ์ ์ํด ์ ์ ๋ถ ๊ณต์์ด ์๋ ์ฌ๋ค๋ฆฌ๊ผด ๋์ด ๊ณต์์ ์ด์ฉํ์ฌ ๋ค์๊ณผ ๊ฐ์ด ๊ตฌํ ์ ์์ (๋ฐ๋ณต๋ฌธ์ ํตํด ๊ตฌ๊ฐ ๋ด ์ฌ๋ค๋ฆฌ๊ผด ํฉ๊ณ ๊ตฌํจ)
- ๋จ, ์ฐ๋ฐ์์ด ๊ทธ๋ํ์ ๊ฐ๋ก์ถ ๊ธธ์ด๋ฅผ ๋ฏธ๋ฆฌ ์ ์ ์๊ธฐ ๋๋ฌธ์ ๊ตฌ๊ฐ์ ์์์ ์์ด ์๋ ์ ์, ๊ตฌ๊ฐ์ ๋์ ์์ด ์๋ ์ ์๋ก ํํํฉ๋๋ค. ์ด๋ ๊ฐ๊ฐ ๊บพ์์ ๊ทธ๋ํ๊ฐ ์์ํ๋ ์ ๊ณผ ๋๋๋ ์ ์ x์ขํ์ ๋ํ ์๋์ ์ธ ์คํ์
์ ์๋ฏธ
๐ python code
def solution(k, ranges):
answer = []
y_lst = [k] # ์ด๊ธฐ k๊ฐ
# ์ฝ๋ผ์ธ ์ถ์ธก
while k != 1 :
if k % 2 == 0 :
k = k//2
else :
k = k*3 + 1
y_lst.append(k)
for r in ranges :
# ๊ตฌ๊ฐ ์์์
a = r[0]
# ๊ตฌ๊ฐ ๋์
b = len(y_lst)+r[1]-1
# ๊ตฌ๊ฐ ์์์ ๊ณผ ๋์ ๋น๊ต
# ๊ฐ์ด ์ค์ํ์ผ๋ก ์๊ตฌ๋์ด -1.0๊ณผ 0.0 ์ ๋ฃ์ด์ค
if a > b :
answer.append(-1.0)
elif a == b :
answer.append(0.0)
else :
n = 0 # ์ฌ๋ค๋ฆฌ๊ผด ๋์ด ํฉ๊ณ
for A in range(a, b) :
n += 0.5*(y_lst[A] + y_lst[A+1])
answer.append(n)
return answer
๋๊ธ