【LEETCODE OJ】Single Number II

Problem link:

http://oj.leetcode.com/problems/single-number-ii/

The problem seems like the Single Number. Suppose we have following (3m+1) numbers in the array A:

x0, x1, x1, x1, ..., xm, xm, xm

We are asked to find out the value of x0.

However we cannot solve it using XOR since all xi has odd number of appearances.

If we consider the problem as an automata, each time we scan a number from A and update the status of the automata. We consider a integer as an array of bits, and for each number we count the number of "1" for each bit of an integer. Then, after scanning the (3m+1) numbers, for i-th bit, there would be 3k+1 1's (and 3(m-k) 0's) if x0's i-th bit is "1"; otherwise there would be 3k 1's (and 3(m-k)+1 0's). Therefore, if we set the bits having (3k+1) 1's to 1 and other bits to 0, this number should be the same to x0.

We use 3 integers to represent the status of the automata, let's say B0, B1, and B2. For j=0,1,2 and i-th bit, Bj[i] = 1 means the automata has scanned 3k+j numbers with i-th bit set to 1. For each bit there is and only is one "1" in B0, B1, and B2 at any time. That is,

1. B0 OR B1 OR B2 = "111........1"
2. Bi AND Bj = 0 for i ≠ j

The initial status is as follows,

B0: 1111........1
B1: 0000........0
B2: 0000........0

since there is no numbers scanned yet. Then for each number x, we move the common 1's of x and B0 from B0 to B1, common 1's of x and B1 from B1 to B2, and common 1's of x and B2 from B2 to B0. After scanning all numbers, the value of B1 equals to x0 as we mentioned./p>

The python code is as follows.

class Solution:
    # @param A, a list of integer
    # @return an integer
    def singleNumber(self, A):
        """
        Similar to Single Number I,
        suppose we have 3m+1 numbers where n0 is the single number:
        x0, x1, x1, x1, x2, x2, x2, ..., xm, xm, xm.
        We are asked to find out the value of x0.
        """
        # special cases:
        n = len(A)
        assert n > 0
        if n == 1:
            return A[0]

        # Bit-counters, with following properties
        #  1) bc0 OR bc1 OR bc2 = ~0
        #  2) bc0 AND bc1 = 0
        #  3) bc1 AND bc2 = 0
        #  4) bc0 AND bc2 = 0
        bc0 = ~0  # bc0's i-th bit is 1 means there are 3k numbers with i-th bit of 1
        bc1 = 0   # bc1's i-th bit is 1 means there are 3k+1 numbers with i-th bit of 1
        bc2 = 0   # bc2's i-th bit is 1 means there are 3k+2 numbers with i-th bit of 1

        # Scan numbers in A
        for x in A:
            # Commen bits of bc0 and x
            c0 = bc0 & x
            # Commen bits of bc1 and x
            c1 = bc1 & x
            # Commen bits of bc2 and x
            c2 = bc2 & x
            # Move bits of 1 in c0 from bc0 to bc1,
            bc0 &= (~c0)
            bc1 |= c0
            # Move bits of 1 in c1 from bc1 to bc2
            bc1 &= (~c1)
            bc2 |= c1
            # Move bits of 1 in c2 from bc2 to bc0
            bc2 &= (~c2)
            bc0 |= c2

        return bc1

Actually, we do not need all bc0, bc1, and bc2, since one can be computed from the other two. If then, we only need to update two variables each time and compute another one on-fly. However, I prefer to using 3 variables which is easy to read and understand.