
1 ~ย n์ ๋ฒํธ๊ฐ ์๋ ํ๋ฐฐ ์์๊ฐ ์ฐฝ๊ณ ์ ์์ต๋๋ค. ๋น์ ์ ํ๋ฐฐ ์์๋ค์ ๋ค์๊ณผ ๊ฐ์ด ์ ๋ฆฌํ์ต๋๋ค.
์ผ์ชฝ์์ ์ค๋ฅธ์ชฝ์ผ๋ก ๊ฐ๋ฉด์ 1๋ฒ ์์๋ถํฐ ๋ฒํธ ์์๋๋ก ํ๋ฐฐ ์์๋ฅผ ํ ๊ฐ์ฉ ๋์ต๋๋ค. ๊ฐ๋ก๋ก ํ๋ฐฐ ์์๋ฅผย w๊ฐ ๋์๋ค๋ฉด ์ด๋ฒ์๋ ์ค๋ฅธ์ชฝ์์ ์ผ์ชฝ์ผ๋ก ๊ฐ๋ฉด์ ๊ทธ ์์ธต์ ํ๋ฐฐ ์์๋ฅผ ํ ๊ฐ์ฉ ๋์ต๋๋ค. ๊ทธ ์ธต์ ์์๋ฅผย w๊ฐ ๋์ ๊ฐ์ฅ ์ผ์ชฝ์ผ๋ก ๋์์๋ค๋ฉด ๋๋ค์ ์ผ์ชฝ์์ ์ค๋ฅธ์ชฝ์ผ๋ก ๊ฐ๋ฉด์ ๊ทธ ์์ธต์ ์์๋ฅผ ๋์ต๋๋ค. ์ด๋ฌํ ๋ฐฉ์์ผ๋กย n๊ฐ์ ํ๋ฐฐ ์์๋ฅผ ๋ชจ๋ ๋์ ๋๊น์ง ํ ์ธต์ย w๊ฐ์ฉ ์์๋ฅผ ์์ต๋๋ค.

wย = 6์ผ ๋ ํ๋ฐฐ ์์ 22๊ฐ๋ฅผ ์์ ์์์
๋๋ค.๋ค์ ๋ ์๋์ ์์ ์ ํ๋ฐฐ๋ฅผ ์ฐพ์ผ๋ฌ ์ฐฝ๊ณ ์ ์์ต๋๋ค. ๋น์ ์ ์๋์ด ์์ ์ ํ๋ฐฐ ์์ ๋ฒํธ๋ฅผ ๋งํ๋ฉด ํด๋น ํ๋ฐฐ ์์๋ฅผ ๊บผ๋ด์ค๋๋ค. ํ๋ฐฐ ์์ A๋ฅผ ๊บผ๋ด๋ ค๋ฉด ๋จผ์ A ์์ ์๋ ๋ค๋ฅธ ๋ชจ๋ ์์๋ฅผ ๊บผ๋ด์ผ A๋ฅผ ๊บผ๋ผ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ์ ๊ทธ๋ฆผ์์ 8๋ฒ ์์๋ฅผ ๊บผ๋ด๋ ค๋ฉด ๋จผ์ 20๋ฒ, 17๋ฒ ์์๋ฅผ ๊บผ๋ด์ผ ํฉ๋๋ค.
๋น์ ์ ๊บผ๋ด๋ ค๋ ์์ ๋ฒํธ๊ฐ ์ฃผ์ด์ก์ ๋, ๊บผ๋ด๋ ค๋ ์์๋ฅผ ํฌํจํด ์ด ๋ช ๊ฐ์ ํ๋ฐฐ ์์๋ฅผ ๊บผ๋ด์ผ ํ๋์ง ์๊ณ ์ถ์ต๋๋ค.
์ด๋, ๊บผ๋ด์ผ ํ๋ ์์์ ์ด๊ฐ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์.
nย โค 100wย โค 10numย โคย n| n | w | num | result |
|---|---|---|---|
| 22 | 6 | 8 | 3 |
| 13 | 3 | 6 | 4 |
์ฒ์์๋, ๋ฌธ์ ์ ์ ํ ๊ทธ๋๋ก ์์๋๋ก ํ์์ต๋๋ค.
boxs๋ผ๋ ๋ฐฐ์ด์ ๋ง๋ค์ด์ ์์๋ฅผ ์ฐจ๋ก๋๋ก ์ ๋ ฌํ์ต๋๋ค.
const h = Math.ceil(n / w);
const boxs = Array.from({ length: h }, () => Array(w).fill(0));
for(let i = 0; i < h; i++){
for(let j = 0; j < w; j++){
if(i % 2 === 0){
// ์ง์๋ฒ์งธ ์ค์ด๋ผ๋ฉด -> ์ค๋ฅธ์ชฝ ๋ฐฉํฅ์ผ๋ก ์ซ์๋ฅผ ๋์ด
boxs[i][j] = i * w + j + 1
} else {
// ํ์๋ฒ์งธ ์ค์ด๋ผ๋ฉด <- ์ผ์ชฝ ๋ฐฉํฅ์ผ๋ก ์ซ์๋ฅผ ๋์ด
boxs[i][j] = i * w + (w - j)
}
}
}
๊ทธ๋ผ ์๋์ ๊ฐ์ด ์์๊ฐ ๋ฐฐ์น๋ฉ๋๋ค.

๊ทธ๋ฐ๋ฐ, n์ ๋์ด์๊น์ง ๋ฐฐ์น๊ฐ ๋๋ฏ๋ก, ์กฐ๊ฑด์ ์ถ๊ฐํด์ฃผ์์ต๋๋ค.
for(let i = 0; i < h; i++){
for(let j = 0; j < w; j++){
if(i % 2 === 0){
let curN = i * w + j + 1
if(curN <= n) boxs[i][j] = curN;
} else {
let curN = i * w + (w - j)
if(curN <= n) boxs[i][j] = curN;
}
}
}
์ด์ n์ ๋์ด์๋ ์ซ์๋ ๋ฐฐ์น๋์ง ์์ต๋๋ค.
์ด์ num์ ํ, ์ด์ ์ฐพ์์ผํฉ๋๋ค. ๋ฐ์ค๋ฅผ ๋ฐฐ์นํ๋ฉด์ ํ๋ฒ์ ์ฐพ์ผ๋ฉด ์ข์ ๊ฒ ๊ฐ์ต๋๋ค. ๋ฐ๋ณต๋ฌธ ๋ด์ ์กฐ๊ฑด์ ์ถ๊ฐํด์ ๋ณ์์ ์ ์ฅํด์ฃผ๊ฒ ์ต๋๋ค.
let row;
let col;
for(let i = 0; i < h; i++){
for(let j = 0; j < w; j++){
if(i % 2 === 0){
let curN = i * w + j + 1
if(curN <= n) boxs[i][j] = curN;
if(curN === num) {
row = i;
col = j;
}
} else {
let curN = i * w + (w - j)
if(curN <= n) boxs[i][j] = curN;
if(curN === num) {
row = i;
col = j;
}
}
}
}
์ด์ ํ์ํ ์กฐ๊ฑด์ ๋ชจ๋ ๊ฐ์ถ์์ต๋๋ค. boxs ๋ฐฐ์ด์ ๋๋ฉด์, ๋บด์ผํ ์์๋ฅผ ์ธ์ด์ค๋๋ค.
let count = 0;
for(let r = row; r < h; r++){
if(boxs[r][col] !== 0) count++;
}
์๋ ์ฌ์ง์ ๋นจ๊ฐ์ ๋ถ๋ถ๋ง ํ์ํ๋ฉฐ count๋ฅผ ์
๋๋ค. ๊ทธ๋ฆฌ๊ณ count๋ฅผ return ํด์ฃผ๋ฉด ๋ฉ๋๋ค.

ํ์ง๋ง, ์ ๋ฐฉ์์ ๋ฉ๋ชจ๋ฆฌ๋ ๋ง์ด ์ฐ๊ณ ๋ณต์กํฉ๋๋ค. ์ฌ์ค ์ฐ๋ฆฌ๋ num์ ์์น๋ฅผ ์ฐพ์์ row, col ์ ์๊ฒ๋๋ฉด ๋นจ๊ฐ์ ๋ถ๋ถ๋ง ํ์ํ ์ ์์ต๋๋ค. ๊ตณ์ด boxs ๋ฐฐ์ด์ ๋ง๋ค ํ์๊ฐ ์์ต๋๋ค.
์ผ๋จ row๋ ์ฝ๊ฒ ๊ตฌํ ์ ์์ต๋๋ค. num - 1๋ก ์ธ๋ฑ์ค ๋ฒํธ๋ฅผ ๊ธฐ์ค์ผ๋ก ํด์ w๋ก ๋๋๋ฉด ๋ช๋ฒ์งธ ์ค์ธ์ง ์ ์ ์์ต๋๋ค.
row๋ฅผ ๊ตฌํ๋ค๋ฉด, ์ด๋ฅผ ๊ฐ์ง๊ณ col ๋ ๊ตฌํ ์ ์์ต๋๋ค. row๊ฐ ์ง์๋ผ๋ฉด ์ค๋ฅธ์ชฝ์ผ๋ก ์ซ์๊ฐ ๋์ด๋๊ณ , ํ์๋ผ๋ฉด ์ผ์ชฝ์ผ๋ก ์ซ์๊ฐ ๋์ด๋ฉ๋๋ค. ์ด์ ๋ง์ถฐ์ ๊ตฌํ ์ ์์ต๋๋ค.
let row = Math.floor((num - 1) / w);
let col;
if(row % 2 === 0){
col = (num - 1) % w
} else {
col = w - 1 - (num - 1) % w
}
์ด์ row ์ด์์ ์ค์์ ํด๋น ์นธ์ ์ซ์๋ฅผ n๊ณผ ๋น๊ตํ์ฌ ์๊ฑฐ๋ ๊ฐ์ผ๋ฉด count๋ฅผ ์ฌ๋ฆฌ๊ณ , n๋ณด๋ค ํฌ๋ค๋ฉด ์์๊ฐ ์์ผ๋ฏ๋ก ๋ํ์ง ์์ผ๋ฉด ๋ฉ๋๋ค.
let count = 0;
for(let i = row; i < h; i++){
if(i % 2 === 0 && (i * w + col) <= n){
count++
} else if(i % 2 !== 0 && (i * w + (w - col)) <= n){
count++
}
}
์ด๋ ๊ฒ ํ๋ฉด ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํฌ๊ฒ ์ ์ฝํ๊ณ ๋ถํ์ํ ์ฐ์ฐ์ ์ค์ผ ์ ์์ต๋๋ค.