
๐งก๋ฌธ์  ์ค๋ช
์ํธ๊ฐ ๊ด๋ฆฌํ๋ ์ด๋ค ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ํ ํ
์ด๋ธ์ ๋ชจ๋ ์ ์ ํ์
์ธ ์ปฌ๋ผ๋ค๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. ํ
์ด๋ธ์ 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
}