๐งก๋ฌธ์ ์ค๋ช
์ํธ๊ฐ ๊ด๋ฆฌํ๋ ์ด๋ค ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ํ ํ
์ด๋ธ์ ๋ชจ๋ ์ ์ ํ์
์ธ ์ปฌ๋ผ๋ค๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. ํ
์ด๋ธ์ 2์ฐจ์ ํ๋ ฌ๋ก ํํํ ์ ์์ผ๋ฉฐ ์ด์ ์ปฌ๋ผ์ ๋ํ๋ด๊ณ , ํ์ ํํ์ ๋ํ๋
๋๋ค.
์ฒซ ๋ฒ์งธ ์ปฌ๋ผ์ ๊ธฐ๋ณธํค๋ก์ ๋ชจ๋ ํํ์ ๋ํด ๊ทธ ๊ฐ์ด ์ค๋ณต๋์ง ์๋๋ก ๋ณด์ฅ๋ฉ๋๋ค. ์ํธ๋ ์ด ํ
์ด๋ธ์ ๋ํ ํด์ ํจ์๋ฅผ ๋ค์๊ณผ ๊ฐ์ด ์ ์ํ์์ต๋๋ค.
ํด์ ํจ์๋ col
, row_begin
, row_end
์ ์
๋ ฅ์ผ๋ก ๋ฐ์ต๋๋ค.
ํ
์ด๋ธ์ ํํ์ col
๋ฒ์งธ ์ปฌ๋ผ์ ๊ฐ์ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ์ ํ๋, ๋ง์ฝ ๊ทธ ๊ฐ์ด ๋์ผํ๋ฉด ๊ธฐ๋ณธํค์ธ ์ฒซ ๋ฒ์งธ ์ปฌ๋ผ์ ๊ฐ์ ๊ธฐ์ค์ผ๋ก ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌํฉ๋๋ค.
์ ๋ ฌ๋ ๋ฐ์ดํฐ์์ S_i๋ฅผ i ๋ฒ์งธ ํ์ ํํ์ ๋ํด ๊ฐ ์ปฌ๋ผ์ ๊ฐ์ i ๋ก ๋๋ ๋๋จธ์ง๋ค์ ํฉ์ผ๋ก ์ ์ํฉ๋๋ค.
row_begin
โค i โค row_end
์ธ ๋ชจ๋ S_i๋ฅผ ๋์ ํ์ฌ bitwise XOR ํ ๊ฐ์ ํด์ ๊ฐ์ผ๋ก์ ๋ฐํํฉ๋๋ค.
ํ
์ด๋ธ์ ๋ฐ์ดํฐ data์ ํด์ ํจ์์ ๋ํ ์
๋ ฅ col
, row_begin
, row_end
์ด ์ฃผ์ด์ก์ ๋ ํ
์ด๋ธ์ ํด์ ๊ฐ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
๐์ ํ ์ฌํญ
data
์ ๊ธธ์ด โค 2,500data
์ ์์์ ๊ธธ์ด โค 500data[i][j]
โค 1,000,000data[i][j]
๋ i + 1 ๋ฒ์งธ ํํ์ j + 1 ๋ฒ์งธ ์ปฌ๋ผ์ ๊ฐ์ ์๋ฏธํฉ๋๋ค.col
โค data
์ ์์์ ๊ธธ์ดrow_begin
โค row_end
โค data
์ ๊ธธ์ด๐์ ์ถ๋ ฅ ์
data | col | row_begin | row_end | result |
---|---|---|---|---|
[[2,2,6],[1,5,10],[4,2,9],[3,8,3]] | 2 | 2 | 3 | 4 |
๐์ ์ถ๋ ฅ ์ ์ค๋ช
๐๋์ ํ์ด
function solution(data, col, row_begin, row_end) {
// ์ ๋ต ๋ณ์
let result = 0
// col๋ฒ์งธ ์ปฌ๋ผ์ ๊ฐ์ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
const sortData = data.sort((a,b) => {
if(a[col-1] > b[col-1]) return 1
// ๋์ผํ๋ฉด ์ฒซ ๋ฒ์งธ ์ปฌ๋ผ ๊ธฐ์ค ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ
else if(a[col-1] === b[col-1]) return b[0] - a[0]
else return -1
})
// i ๋ฒ์งธ ํ์ ํํ์ ๋ํด ๊ฐ ์ปฌ๋ผ์ ๊ฐ์ i ๋ก ๋๋ ๋๋จธ์ง๋ค์ ํฉ์ผ๋ก ์ ์
for(let i = row_begin ; i <= row_end ; i ++) {
// ๊ฒฐ๊ด๊ฐ์ ์ ๋ต ๋ณ์์ XOR
result ^= sortData[i-1].map(a => a%i).reduce((acc, cur, idx) => acc+cur, 0)
}
return result
}