Cyclic Rotation ๋ฌธ์ ํด๊ฒฐ โ
๋ฌธ์ ์ค๋ช โ
๋ฐฐ์ด์ด ์ฃผ์ด์ง๊ณ , ์ ์ K๊ฐ ์ฃผ์ด์ง ๋, ๋ฐฐ์ด์ ์ค๋ฅธ์ชฝ์ผ๋ก K๋ฒ ํ์ ์ํจ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋ ๋ฌธ์ ์
๋๋ค. ๋ฐฐ์ด์์ ํ์ ์ด๋, ๋ฐฐ์ด์ ๋ง์ง๋ง ์์๊ฐ ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์์๋ก ์ด๋ํ๊ณ ๋๋จธ์ง ์์๋ ํ ์นธ์ฉ ๋ค๋ก ๋ฐ๋ฆฌ๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค.
์๋ฅผ ๋ค์ด:
- ๋ฐฐ์ด
[3, 8, 9, 7, 6]์ด ์์ ๋,K = 3์ด๋ฉด ๋ฐฐ์ด์[9, 7, 6, 3, 8]๋ก ๋ณํฉ๋๋ค.
ํด๊ฒฐ ๋ฐฉ๋ฒ โ
์๊ณ ๋ฆฌ์ฆ ์ค๋ช โ
- ์ฃผ์ด์ง ๋ฐฐ์ด
A์ ํ์ ํ์K์ ๋ํด, ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผN์ด๋ผ๊ณ ํ ๋, ์ฌ์คK๊ฐ ๋ฐฐ์ด์ ํฌ๊ธฐN๋ณด๋ค ํฌ๋ฉดK % N๋งํผ๋ง ํ์ ํ๋ฉด ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด,K = N์ด๋ฉด ๋ฐฐ์ด์ด ํ ๋ฐํด ๋์ ์๋ ์ํ๋ก ๋์์ต๋๋ค. - ๋ฐฐ์ด์
K % N๋งํผ ์ค๋ฅธ์ชฝ์ผ๋ก ํ์ ์ํค๋ฉด, ๊ฒฐ๊ณผ๋ ๋ฐฐ์ด์ ๋ ๋ถ๋ถ์ผ๋ก ๋๋์ด ํฉ์น๋ ๋ฐฉ์์ผ๋ก ๊ตฌํํ ์ ์์ต๋๋ค. - ๋ฐฐ์ด์ ํ์ ์ํค๋ ๋ฐฉ์์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
A.slice(N - K % N)๋ถ๋ถ์ ๋ฐฐ์ด์ ๋งจ ์์ ๋๊ณ ,A.slice(0, N - K % N)๋ถ๋ถ์ ๋ค์ ๋์ต๋๋ค.
์ฝ๋ ๊ตฌํ โ
typescript
function solution(A: number[], K: number): number[] {
const length = A.length
// ๋ฐฐ์ด์ด ๋น์ด ์์ ๊ฒฝ์ฐ ๊ทธ๋๋ก ๋ฐํ
if (length === 0) return A
const rotation = K % length
// ํ์ ํ์๊ฐ 0์ผ ๊ฒฝ์ฐ ์๋ ๋ฐฐ์ด ๊ทธ๋๋ก ๋ฐํ
if (rotation === 0) return A
const splitIndex = length - rotation
// ๋ฐฐ์ด์ ๋ ๋ถ๋ถ์ผ๋ก ๋๋์ด ํฉ์นจ
return [...A.slice(splitIndex), ...A.slice(0, splitIndex)]
}์ฝ๋ ์ค๋ช โ
- ๋น ๋ฐฐ์ด ์ฒ๋ฆฌ: ๋ฐฐ์ด
A๊ฐ ๋น์ด ์์ ๊ฒฝ์ฐ ํ์ ์ ์ํํ ํ์๊ฐ ์์ผ๋ฏ๋ก ๋ฐ๋ก ๋ฐํํฉ๋๋ค. - ํ์ ํ์ ์ต์ ํ:
K๊ฐ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ณด๋ค ํด ์ ์๊ธฐ ๋๋ฌธ์,K % length๋ฅผ ์ฌ์ฉํ์ฌ ์ค์ ๋ก ํ์ํ ํ์ ํ์๋ฅผ ๊ณ์ฐํฉ๋๋ค. - ๋ฐฐ์ด ๋ถํ ๋ฐ ์ฌ์กฐํฉ: ๋ฐฐ์ด์
slice๋ฅผ ์ฌ์ฉํ์ฌ ๋ ๋ถ๋ถ์ผ๋ก ๋๋๊ณ , ์ด๋ฅผ ํฉ์ณ์ ์๋ก์ด ๋ฐฐ์ด์ ๋ง๋ญ๋๋ค.
์๊ฐ ๋ณต์ก๋ โ
- ๋ฐฐ์ด์
slice๋ฅผ ์ฌ์ฉํ์ฌ ๋ ๋ถ๋ถ์ผ๋ก ๋๋๋ ๋ฐO(N)์๊ฐ์ด ๊ฑธ๋ฆฝ๋๋ค. - ๋ฐ๋ผ์ ์ด ์๊ณ ๋ฆฌ์ฆ์ ์๊ฐ ๋ณต์ก๋๋ **O(N)**์ ๋๋ค.
์์ โ
์์ 1 โ
์ ๋ ฅ:
typescript
;(A = [3, 8, 9, 7, 6]), (K = 3)์ถ๋ ฅ:
typescript
;[9, 7, 6, 3, 8]์์ 2 โ
์ ๋ ฅ:
typescript
;(A = [0, 0, 0]), (K = 4)์ถ๋ ฅ:
typescript
;[0, 0, 0]์์ 3 โ
์ ๋ ฅ:
typescript
;(A = [1, 2, 3, 4]), (K = 2)์ถ๋ ฅ:
typescript
;[3, 4, 1, 2]์ต์ข ๊ฒฐ๋ก โ
์ด ์ฝ๋๋ CyclicRotation ๋ฌธ์ ๋ฅผ ํจ์จ์ ์ด๊ณ ๊ฐ๋จํ ๋ฐฉ์์ผ๋ก ํด๊ฒฐํฉ๋๋ค. ๋ฐฐ์ด์ด ๋น์ด ์๋ ๊ฒฝ์ฐ์ ํ์ ํ์๊ฐ 0์ธ ๊ฒฝ์ฐ๋ฅผ ์ฒ๋ฆฌํ๋ฉฐ, ํ์ ํ์๊ฐ ๋ฐฐ์ด ๊ธธ์ด๋ณด๋ค ํฐ ๊ฒฝ์ฐ์๋ K % N์ ํ์ฉํด ๋ถํ์ํ ๊ณ์ฐ์ ์ค์
๋๋ค.