Problem:
Score : 700 points

Problem Statement

Given is a sequence of N digits a_1a_2\ldots a_N, where each element is 1, 2, or 3.
Let x_{i,j} defined as follows:

x_{1,j} := a_j \quad (1 \leq j \leq N)

x_{i,j} := | x_{i-1,j} - x_{i-1,j+1} | \quad (2 \leq i \leq N and 1 \leq j \leq N+1-i)

Find x_{N,1}.

Constraints

2 \leq N \leq 10^6

a_i = 1,2,3 (1 \leq i \leq N)

Input

Input is given from Standard Input in the following format:

N
a_1a_2\ldotsa_N

Output

Print x_{N,1}.

Sample Input 1

4
1231

Sample Output 1

1

x_{1,1},x_{1,2},x_{1,3},x_{1,4} are respectively 1,2,3,1.

x_{2,1},x_{2,2},x_{2,3} are respectively |1-2| = 1,|2-3| = 1,|3-1| = 2.

x_{3,1},x_{3,2} are respectively |1-1| = 0,|1-2| = 1.

Finally, x_{4,1} = |0-1| = 1, so the answer is 1.

Sample Input 2

10
2311312312

Sample Output 2

0

Solution in Kotlin (1.0.0) (judge verdict: Wrong Answer)

fun main(args: Array<String>) {
    val N = readLine()!!.toInt();
    val a = IntArray(N)
    val num = readLine()!!.toCharArray()
    for (i in 0 until N) {
        a[i] = num[i] - '0'
    }
    if (N == 2) {
        println(Math.abs(a[0] - a[1]))
        return
    }
    for (i in 0 until N) {
        if (a[i] == 2) {
            a[i] = 0
        } else if (a[i] == 1) {
            a[i] = -1
        } else {
            a[i] = 1
        }
    }
    val b = IntArray(N - 1)
    for (i in 0 until N - 1) {
        b[i] = (a[i] + a[i + 1]) % 2
    }
    val MAX = 1000000
    val MOD = 3
    val fac = LongArray(MAX)
    val finv = LongArray(MAX)
    val inv = LongArray(MAX)
    fac[1] = 1
    fac[0] = fac[1]
    finv[1] = 1
    finv[0] = finv[1]
    inv[1] = 1
    for (i in 2 until MAX) {
        fac[i] = fac[i - 1] * i % MOD
        inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD
        finv[i] = finv[i - 1] * inv[i] % MOD
    }
    var sum = 0
    for (i in 0 until N - 1) {
        sum += (b[i] * ncr(fac, finv, N - 2, i, MOD)).toInt()
        sum %= 3
    }
    println(sum)
}

fun ncr(fac: LongArray, finv: LongArray, n: Int, k: Int, MOD: Int): Long {
    if (n < k) return 0
    return if (n < 0 || k < 0) 0 else fac[n] * (finv[k] * finv[n - k] % MOD) % MOD
}