๐Ÿ… ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค 131702 : ๊ณ ๊ณ ํ•™ ์ตœ๊ณ ์˜ ๋ฐœ๊ฒฌ - Javascript

๋ฌธ์ œ ์„ค๋ช…

๊ณ ๊ณ ํ•™์ž์ธ ํ˜œ์„ ์€ ์˜ค๋ž˜์ „๋ถ€ํ„ฐ ์„ฑ๊ถค์˜ ํ–‰๋ฐฉ์„ ์ถ”์ ํ•ด์™”์Šต๋‹ˆ๋‹ค. ๊ทธ๋™์•ˆ ๊ทธ์˜ ์—ฐ๊ตฌ๋Š” ์ฃผ๋ฅ˜ ํ•™์ž๋“ค๋กœ๋ถ€ํ„ฐ ์ธ์ •๋ฐ›์ง€ ๋ชปํ–ˆ์—ˆ์ง€๋งŒ, ํ˜œ์„ ์ด๋Š” ํฌ๊ธฐํ•˜์ง€ ์•Š๊ณ  ์กฐ์‚ฌ๋ฅผ ๊ณ„์†ํ–ˆ๊ณ  ๋งˆ์นจ๋‚ด ์„ฑ๊ถค์˜ ํ–‰๋ฐฉ์„ ์•Œ์•„๋‚ด์—ˆ์Šต๋‹ˆ๋‹ค.

๊ทธ๋Ÿฌ๋‚˜ ์˜ค๋ž˜์ „ ๋ˆ„๊ตฐ๊ฐ€๋กœ๋ถ€ํ„ฐ ๋ด‰์ธ๋œ ์„ฑ๊ถค๋Š” ํŠน๋ณ„ํ•œ ์ž ๊ธˆ์žฅ์น˜์— ์˜ํ•ด ๋ณดํ˜ธ๋˜๊ณ  ์žˆ์—ˆ์Šต๋‹ˆ๋‹ค. ์ž ๊ธˆ์žฅ์น˜๋Š” ์ผ์ข…์˜ ํผ์ฆ๊ณผ ์—ฐ๊ฒฐ๋˜์–ด ํผ์ฆ์„ ํ•ด๊ฒฐํ•˜๋ฉด ์—ด๋ฆฌ๋Š” ๊ฒƒ์œผ๋กœ ๋ณด์ž…๋‹ˆ๋‹ค.

ํผ์ฆ์€ ์‹œ๊ณ„๋“ค์ด ํ–‰๋ ฌ์„ ์ด๋ฃจ๋Š” ๊ตฌ์กฐ๋ฌผ์ธ๋ฐ ํ•˜๋‚˜์˜ ์‹œ๊ณ„์— ์‹œ๊ณ—๋ฐ”๋Š˜์€ ํ•˜๋‚˜์”ฉ๋งŒ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ฐ ์‹œ๊ณ—๋ฐ”๋Š˜์€ ์‹œ๊ณ„๋ฐฉํ–ฅ์œผ๋กœ๋งŒ ๋Œ๋ฆด ์ˆ˜ ์žˆ๊ณ  ํ•œ ๋ฒˆ์˜ ์กฐ์ž‘์œผ๋กœ 90๋„์”ฉ ๋Œ๋ฆด ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์‹œ๊ณ„๋“ค์€ ๊ธฐ๊ณ„์žฅ์น˜์— ์˜ํ•ด ์—ฐ๊ฒฐ๋˜์–ด ์žˆ์–ด ์–ด๋–ค ์‹œ๊ณ„์˜ ์‹œ๊ณ—๋ฐ”๋Š˜์„ ๋Œ๋ฆฌ๋ฉด ๊ทธ ์‹œ๊ณ„์˜ ์ƒํ•˜์ขŒ์šฐ๋กœ ์ธ์ ‘ํ•œ ์‹œ๊ณ„๋“ค์˜ ์‹œ๊ณ—๋ฐ”๋Š˜๋„ ํ•จ๊ป˜ ๋Œ์•„๊ฐ‘๋‹ˆ๋‹ค. ํ–‰๋ ฌ์˜ ๋ชจ์„œ๋ฆฌ์— ์œ„์น˜ํ•œ ์‹œ๊ณ„์˜ ์‹œ๊ณ—๋ฐ”๋Š˜์„ ๋Œ๋ฆฌ๋Š” ๊ฒฝ์šฐ์—๋Š” ์ธ์ ‘ํ•œ ์„ธ ์‹œ๊ณ„์˜ ์‹œ๊ณ—๋ฐ”๋Š˜๋“ค์ด ํ•จ๊ป˜ ๋Œ์•„๊ฐ€๋ฉฐ, ๊ผญ์ง“์ ์— ์œ„์น˜ํ•œ ์‹œ๊ณ„์˜ ์‹œ๊ณ—๋ฐ”๋Š˜์„ ๋Œ๋ฆฌ๋Š” ๊ฒฝ์šฐ์—๋Š” ์ธ์ ‘ํ•œ ๋‘ ์‹œ๊ณ„์˜ ์‹œ๊ณ—๋ฐ”๋Š˜๋“ค์ด ํ•จ๊ป˜ ๋Œ์•„๊ฐ‘๋‹ˆ๋‹ค.

๊ฐ ์‹œ๊ณ„๋Š” 12์‹œ, 3์‹œ, 6์‹œ, 9์‹œ ๋ฐฉํ–ฅ ์ค‘์˜ ํ•œ ๋ฐฉํ–ฅ์„ ๊ฐ€๋ฆฌํ‚ค๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค. ๊ฐ ์‹œ๊ณ„์˜ ์‹œ๊ณ—๋ฐ”๋Š˜์„ ์ ์ ˆํžˆ ์กฐ์ž‘ํ•˜์—ฌ ๋ชจ๋“  ์‹œ๊ณ—๋ฐ”๋Š˜์ด 12์‹œ ๋ฐฉํ–ฅ์„ ๊ฐ€๋ฆฌํ‚ค๋ฉด ํผ์ฆ์ด ํ•ด๊ฒฐ๋˜์–ด ์„ฑ๊ถค๋ฅผ ๋ด‰์ธํ•˜๊ณ  ์žˆ๋Š” ์ž ๊ธˆ์žฅ์น˜๊ฐ€ ์—ด๋ฆด ๊ฒƒ์ž…๋‹ˆ๋‹ค.

๋…ธํ›„ํ™”๋œ ํผ์ฆ ๊ธฐ๊ณ„์žฅ์น˜๊ฐ€ ๊ฑฑ์ •๋˜์—ˆ๋˜ ํ˜œ์„ ์€ ๊ฐ€๋Šฅํ•œ ์ตœ์†Œํ•œ์˜ ์กฐ์ž‘์œผ๋กœ ํผ์ฆ์„ ํ•ด๊ฒฐํ•˜๋ ค๊ณ  ํ•ฉ๋‹ˆ๋‹ค. ์‹œ๊ณ—๋ฐ”๋Š˜๋“ค์˜ ํ–‰๋ ฌ clockHands๊ฐ€ ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์งˆ ๋•Œ, ํผ์ฆ์„ ํ•ด๊ฒฐํ•˜๊ธฐ ์œ„ํ•œ ์ตœ์†Œํ•œ์˜ ์กฐ์ž‘ ํšŸ์ˆ˜๋ฅผ return ํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด์ฃผ์„ธ์š”.


์ œํ•œ์‚ฌํ•ญ

  • 2 โ‰ค clockHands์˜ ๊ธธ์ด โ‰ค 8
  • clockHands๋Š” 2์ฐจ์› ๋ฐฐ์—ด์ด๋ฉฐ ํ–‰๊ณผ ์—ด์˜ ํฌ๊ธฐ๊ฐ€ ๋™์ผํ•ฉ๋‹ˆ๋‹ค.
  • 0 โ‰ค clockHands์˜ ์›์†Œ โ‰ค 3
  • clockHands[i]์˜ ์›์†Œ๋“ค์€ ์‹œ๊ณ—๋ฐ”๋Š˜์˜ ๋ฐฉํ–ฅ์„ ๋‚˜ํƒ€๋‚ด๋ฉฐ 0์€ 12์‹œ ๋ฐฉํ–ฅ, 1์€ 3์‹œ ๋ฐฉํ–ฅ, 2๋Š” 6์‹œ ๋ฐฉํ–ฅ, 3์€ 9์‹œ ๋ฐฉํ–ฅ์„ ๋‚˜ํƒ€๋ƒ…๋‹ˆ๋‹ค.
  • ํ•ด๊ฒฐ ๊ฐ€๋Šฅํ•œ ํผ์ฆ๋งŒ ์ฃผ์–ด์ง‘๋‹ˆ๋‹ค.

์ž…์ถœ๋ ฅ ์˜ˆ

clockHands result
[[0,3,3,0],[3,2,2,3],[0,3,2,0],[0,3,3,3]] 3
  • ์˜ˆ์ œ #1
    2ํ–‰ 2์—ด์˜ ์‹œ๊ณ—๋ฐ”๋Š˜, 2ํ–‰ 3์—ด์˜ ์‹œ๊ณ—๋ฐ”๋Š˜, 4ํ–‰ 3์—ด์˜ ์‹œ๊ณ—๋ฐ”๋Š˜์„ ๊ฐ๊ฐ ํ•œ ๋ฒˆ์”ฉ ๋Œ๋ฆฌ๋ฉด ์ตœ์†Œ ์กฐ์ž‘ ํšŸ์ˆ˜๋กœ ํผ์ฆ์„ ํ•ด๊ฒฐํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. example img

ํ’€์ด ๊ณผ์ • - ์‹œ๋„ 1 : ํ’€(?) ์™„์ „ ํƒ์ƒ‰ (์‹คํŒจ)

์ฒ˜์Œ์—๋Š” ๋‹จ์ˆœํžˆ ๋ชจ๋“  ๊ฒฝ์šฐ์˜ ์ˆ˜๋ฅผ ๋Œ€์ž…ํ•ด์„œ ๊ฐ€์žฅ ๋‚ฎ์€ ํšŸ์ˆ˜๋ฅผ ๊ตฌํ•˜๋Š” ์™„์ „ ํƒ์ƒ‰์˜ ํ’€์ด๋กœ ํ•ด๊ฒฐํ•  ์ˆ˜ ์žˆ์„ ๊ฒƒ ๊ฐ™์•˜์Šต๋‹ˆ๋‹ค. ๊ทธ๋ž˜์„œ ๋จผ์ € ์ด ๋ฐฉ์‹์œผ๋กœ ํ’€์–ด๋ณด๋‹ˆ n<4n < 4์ผ ๋•Œ ์‹œ๊ฐ„ ์ดˆ๊ณผ๊ฐ€, n>=4n>=4์ผ ๋•Œ๋Š” ์•„์˜ˆ signal: aborted (core dumped) ์˜ค๋ฅ˜๊ฐ€ ๋ฐœ์ƒํ•ด ์‹คํŒจํ–ˆ์Šต๋‹ˆ๋‹ค. ๊ฒ€์ƒ‰ํ•ด๋ณด๋‹ˆ ํ•ด๋‹น ์˜ค๋ฅ˜์˜ ๊ฒฝ์šฐ ๋ฉ”๋ชจ๋ฆฌ ๋ฒ”์œ„๋ฅผ ๋ฒ—์–ด๋‚˜๊ฑฐ๋‚˜, ์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ ๋ฐฐ์—ด์˜ ์ตœ๋Œ€ ํฌ๊ธฐ์ธ 232โˆ’12^{32}-1์„ ์ดˆ๊ณผํ•  ๊ฒฝ์šฐ ๋ฐœ์ƒํ•œ๋‹ค๋Š” ๋‹ต๋ณ€์ด ์žˆ์—ˆ์Šต๋‹ˆ๋‹ค.

๋ชจ๋“  ๊ฒฝ์šฐ์˜ ์ˆ˜๋ฅผ ๋งŒ๋“ค๊ธฐ ์œ„ํ•ด ์ž‘์„ฑ๋œ ๋ฌธ์ œ์˜ ํ•จ์ˆ˜
const createAllCases = (count, arr = [], acc = []) => {
  if (arr.length == count * count) {
    const result = [];
    for (let i = 0; i < count; ++i) {
      result.push(arr.slice(i * count, (i + 1) * count));
    }
    acc.push(result);
    return;
  }
  for (let i = 0; i < 4; ++i) {
    arr.push(i);
    createAllCases(count, arr, acc);
    arr.pop();
  }
  return acc;
};

์ด๋Ÿฐ ๋ฌธ์ œ๊ฐ€ ๋ฐœ์ƒํ•˜๋Š” ์ด์œ ๊ฐ€ ๊ถ๊ธˆํ•ด ๊ฒฝ์šฐ์˜ ์ˆ˜๋ฅผ ๊ณ„์‚ฐํ•ด๋ณด๋‹ˆ nโˆ—nn*n ํ–‰๋ ฌ์— 0~3๋ฅผ ๋Œ€์ž…ํ•˜๋Š” ๊ฒฝ์šฐ์˜ ์ˆ˜๋Š” ๋ฌด๋ ค 4nโˆ—n4^{n*n}์œผ๋กœ, โ€œ์™€ ๋ณด๊ธฐ๋งŒํ•ด๋„ n์ด ์กฐ๊ธˆ๋งŒ ์ปค์ ธ๋„ ๋‚œ๋ฆฌ ๋‚˜๊ฒ ๋„คโ€ฆโ€ ์‹ถ์—ˆ์Šต๋‹ˆ๋‹ค. ์ง์ ‘ ๊ณ„์‚ฐ์„ ํ•ด๋ด๋„ ์ž…์ถœ๋ ฅ ์˜ˆ์™€ ๊ฐ™์ด n=4n=4์˜ ์ž‘์€ ํ–‰๋ ฌ์—์„œ๋„ 4164^{16}๊ฐœ์˜ ๊ฒฝ์šฐ์˜ ์ˆ˜๊ฐ€ ๋‚˜์˜ค๊ณ , ์ตœ๋Œ€ ํฌ๊ธฐ์ธ n=8n=8์˜ ๊ฒฝ์šฐ 4644^{64}๋กœ ๋ฌด๋ ค 39์ž๋ฆฌ์˜ ์ฝ๊ธฐ๋„ ํž˜๋“  ๊ธด ์ˆ˜๊ฐ€ ๋‚˜์™”์Šต๋‹ˆ๋‹ค. ๋ฌธ์ œ์˜ ์ž…๋ ฅ ๋ฒ”์œ„์™€ ํ’€์ด์˜ ์‹คํ–‰ ์‹œ๊ฐ„์„ ๋ฏธ๋ฆฌ ์ƒ๊ฐํ•ด๋ณด์ง€ ์•Š์€ ์ œ ์‹ค์ˆ˜์˜€์Šต๋‹ˆ๋‹คโ€ฆ

  • n=2ย โ‡’ย 42โˆ—2ย =ย 256n = 2\ \Rightarrow\ 4^{2*2}\ =\ 256
  • n=4ย โ‡’ย 44โˆ—4ย =ย 4,294,967,296n = 4\ \Rightarrow\ 4^{4*4}\ =\ 4,294,967,296
  • n=8ย โ‡’ย 48โˆ—8ย =ย 340,282,366,920,938,463,463,374,607,431,768,211,456n = 8\ \Rightarrow\ 4^{8*8}\ =\ 340,282,366,920,938,463,463,374,607,431,768,211,456 ๐Ÿคฏ
    • ์‹ฌ์ง€์–ด ์žฌ๊ท€ ํ•จ์ˆ˜๋กœ ๊ตฌํ˜„ํ–ˆ๊ณ , ํ•จ์ˆ˜์˜ ํ˜ธ์ถœ์ด๋‚˜ ๋กœ์ง ๋“ฑ์˜ ๋ชจ๋“  ๋ถ€๋ถ„์„ ๋ฌด์‹œํ•˜๋”๋ผ๋„ ๊ฒฝ์šฐ์˜ ์ˆ˜๋ฅผ ๋งŒ๋“ค ๋•Œ ๋งˆ๋‹ค nโˆ—nn*n์˜ ํ–‰๋ ฌ์„ ๋ณต์‚ฌํ•ด์•ผํ•œ๋‹ค๋Š” ๊ธฐ๋ณธ ์ „์ œ๊ฐ€ ์กด์žฌํ•˜๊ธฐ ๋•Œ๋ฌธ์— ์ด๋ณด๋‹ค ๋”ํ•œ ์—ฐ์‚ฐ ํšŸ์ˆ˜๊ฐ€ ํ•„์š”ํ•œ ์…ˆ์ด์ฃ โ€ฆ

ํ’€์ด ๊ณผ์ • - ์‹œ๋„ 2 : ์ฒซ ์ค„๋งŒ ์™„์ „ ํƒ์ƒ‰ (์„ฑ๊ณต)

์ด ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•˜๊ธฐ ์œ„ํ•ด ๋งŽ์€ ์‹œํ–‰์ฐฉ์˜ค ๋์— ๋ฌธ์ œ์—์„œ ์ฐพ์„ ์ˆ˜ ์žˆ๋Š” ์—ฌ๋Ÿฌ ๊ทœ์น™์„ ์ •๋ฆฌํ•˜๊ณ  ๊ฒฝ์šฐ์˜ ์ˆ˜๋ฅผ ์ค„์—ฌ๋ณด์•˜์Šต๋‹ˆ๋‹ค.

  1. ์‹œ๊ณ—๋ฐ”๋Š˜์„ ํšŒ์ „์‹œํ‚ค๋Š” ์ˆœ์„œ๊ฐ€ ๋ฐ”๋€Œ์–ด๋„ ๊ฐ ์‹œ๊ณ—๋ฐ”๋Š˜์˜ ํšŒ์ „ ์ˆ˜๊ฐ€ ๊ฐ™๊ธฐ ๋•Œ๋ฌธ์— ๊ฒฐ๊ณผ๊ฐ€ ๋™์ผํ•ฉ๋‹ˆ๋‹ค
  2. (x,y)(x, y)์˜ ์‹œ๊ณ—๋ฐ”๋Š˜์ด ํšŒ์ „ํ•˜๋ฉด (x,yโˆ’1)(x, y - 1)์˜ ์‹œ๊ณ—๋ฐ”๋Š˜๋„ ํšŒ์ „ํ•ฉ๋‹ˆ๋‹ค

1๋ฒˆ ์กฐ๊ฑด์„ ์ด์šฉํ•ด ๊ฒฝ์šฐ์˜ ์ˆ˜ ํƒ์ƒ‰์„ ํ•œ ์—ด์”ฉ ์ฐจ๋ก€๋Œ€๋กœ ์ง„ํ–‰ํ•˜๊ธฐ๋กœ ์ •ํ–ˆ์Šต๋‹ˆ๋‹ค ์ด๋ ‡๊ฒŒ ํ•œ ์—ด์”ฉ ์ฐจ๋ก€๋Œ€๋กœ ์ง„ํ–‰ํ•  ๊ฒฝ์šฐ yy์—ด์˜ ํƒ์ƒ‰์ด ๋๋‚˜๋ฉด yy์—ด์˜ ์‹œ๊ณ—๋ฐ”๋Š˜์„ ์ˆ˜์ •ํ•  ์ˆ˜ ์žˆ๋Š” ๊ฒƒ์€ y+1y+1์—ด์˜ ๊ฐ™์€ ํ–‰์˜ ์‹œ๊ณ—๋ฐ”๋Š˜ ๋ฟ์ž…๋‹ˆ๋‹ค ๋”ฐ๋ผ์„œ y+1y+1์—ด์—์„œ yy์—ด์˜ ํ–‰์„ 0์œผ๋กœ ๋งŒ๋“ค์ง€ ๋ชปํ•˜๋Š” ํ–‰์˜ ๊ฐ’์€ ์ƒ๋žตํ•ด๋„ ๋ฉ๋‹ˆ๋‹ค.

์ตœ์ข… ๋ฌธ์ œ ํ’€์ด ๋ฐฉ์‹์€ ์•„๋ž˜์™€ ๊ฐ™์Šต๋‹ˆ๋‹ค.

  1. ์ฒซ์งธ ์—ด์— ๋“ค์–ด๊ฐˆ ์ˆ˜ ์žˆ๋Š” ๋ชจ๋“  ๊ฒฝ์šฐ์˜ ์ˆ˜๋ฅผ ๊ตฌํ•œ๋‹ค : O(4n)O(4^n)
  2. ๋ณต์‚ฌํ•œ ํ–‰๋ ฌ์„ ๋Œ€์ƒ์œผ๋กœ ๋‚˜๋จธ์ง€ ์—ด์— ๋“ค์–ด๊ฐˆ ์ˆ˜ ์žˆ๋Š” ๋ชจ๋“  ๊ฒฝ์šฐ์˜ ์ˆ˜๋ฅผ ๊ตฌํ•œ๋‹ค : O(n2)O(n^2)

์œ„ ๋ฐฉ์‹๋Œ€๋กœ ์ง„ํ–‰ํ•  ๊ฒฝ์šฐ ํƒ์ƒ‰ํ•  ๊ฒฝ์šฐ์˜ ์ˆ˜๋Š” 4nโˆ—n24^n * n^2์ž…๋‹ˆ๋‹ค.

  • n=2ย โ‡’ย 42โˆ—ย 22ย =ย 64n = 2\ \Rightarrow\ 4^{2} *\ 2^2\ =\ 64
  • n=4ย โ‡’ย 44โˆ—ย 42ย =ย 4,096n = 4\ \Rightarrow\ 4^{4} *\ 4^2\ =\ 4,096
  • n=8ย โ‡’ย 48โˆ—ย 82ย =ย 4,194,304n = 8\ \Rightarrow\ 4^{8} *\ 8^2\ =\ 4,194,304 ๐Ÿ˜†
๊ฐœ์„ ๋œ ์ฝ”๋“œ ์ „๋ฌธ
//2์ฐจ์› ๋ฐฐ์—ด์˜ ๊นŠ์€ ๋ณต์‚ฌ๋ฅผ ์ˆ˜ํ–‰ํ•˜๋Š” ํ•จ์ˆ˜
const deepcopy = (arr) => arr.map((v) => v.slice());

//์ฃผ์–ด์ง„ clockHands์˜ [x, y]์™€ ์ธ์ ‘ํ•œ ์‹œ๊ณ—๋ฐ”๋Š˜์„ ํšŒ์ „ ์‹œํ‚ค๋Š” ํ•จ์ˆ˜
const rotateHand = (x, y, clockHands, rotate) => {
  //์‹ญ์ž ํ˜•ํƒœ๋กœ ํƒ์ƒ‰ํ•˜๊ธฐ ์œ„ํ•œ x, y ๋ฐฉํ–ฅ ๊ฐ’
  const dx = [0, -1, 1, 0, 0];
  const dy = [0, 0, 0, -1, 1];

  for (let i = 0; i < 5; i++) {
    const nx = x + dx[i];
    const ny = y + dy[i];
    if (clockHands[ny] !== undefined && clockHands[ny][nx] !== undefined) {
      clockHands[ny][nx] = (clockHands[ny][nx] + rotate) % 4;
    }
  }
};

//์ฒซ์งธ ์—ด์— ๋Œ€ํ•œ ๋ชจ๋“  ๊ฒฝ์šฐ์˜ ์ˆ˜๋ฅผ ์ƒ์„ฑํ•˜๋Š” ํ•จ์ˆ˜ (4 ** n ๊ฐœ)
//๋น ๋ฅธ ์ƒ์„ฑ์„ ์œ„ํ•ด ์บ์‹œ ๋ฐฐ์—ด์„ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค
//spead ์—ฐ์‚ฐ์ž๋ฅผ ์ด์šฉํ•ด ํ•ญ์ƒ ์ƒˆ ๋ฐฐ์—ด์„ ๋งŒ๋“ค๊ธฐ ๋•Œ๋ฌธ์— deepcopy๋ฅผ ์‚ฌ์šฉํ•  ํ•„์š”๋Š” ์—†์Šต๋‹ˆ๋‹ค.
const caseCache = [, [[0], [1], [2], [3]]];
const createFirstRowCases = (count) => {
  const results = [];

  for (let i = 0; i < 4; ++i) {
    const permutations = caseCache[count - 1] ?? createFirstRowCases(count - 1);
    const attached = permutations.map((permutation) => [i, ...permutation]);
    results.push(...attached);
  }

  return (caseCache[count] = results);
};

//๋‚˜๋จธ์ง€ ์—ด์€ ๋ฐ”๋กœ ์œ„ ์—ด์„ ๊ธฐ์ค€์œผ๋กœ ํšŒ์ „ ์‹œํ‚ค๊ณ  ์„ฑ๊ณต ์‹œ ์‹œ๋„ ํšŸ์ˆ˜๋ฅผ ๋ฐ˜ํ™˜ํ•˜๋Š” ํ•จ์ˆ˜
const tryOtherRows = (clockHands, count) => {
  const length = clockHands.length;
  for (let y = 1; y < length; ++y) {
    for (let x = 0; x < length; ++x) {
      const rotate = 4 - clockHands[y - 1][x];
      if (rotate === 4) {
        continue;
      }

      rotateHand(x, y, clockHands, rotate);
      count += rotate;
    }
  }
  if (clockHands[length - 1].every((el) => el === 0)) {
    return count;
  }

  return null;
};

function solution(originClockHands) {
  const length = originClockHands.length;
  let answer = Number.MAX_SAFE_INTEGER;

  createFirstRowCases(length).forEach((firstRow) => {
    let count = 0;
    const clockHands = deepcopy(originClockHands);
    firstRow.forEach((rotate, x) => {
      rotateHand(x, 0, clockHands, rotate);
      count += rotate;
    });

    count = tryOtherRows(clockHands, count);
    if (count !== null) {
      answer = Math.min(answer, count);
    }
  });

  return answer;
}