leetcode single number

给定一个数组，里面每个数都出现3遍，除了某一个数。找出这个数。

题目说有不用额外空间的解法，但是暂时没想出来，用两个set过了。

PS：遇到另一个题，每个数都出现2遍，除了某两个数，找出这两个数。解法类似，不过需要思考。

int singleNumber(int A[], int n) {
	unordered_set<int> data1, data2;
	int i = 0;
	for (i = 0; i < n; i++){
		if (data2.count(A[i]) > 0){
			if (data1.count(A[i]) > 0) data1.erase(A[i]);
			continue;
		}
		if (data1.count(A[i]) == 0)data1.insert(A[i]);
		else data2.insert(A[i]);
	}
	//iterator<int> it = data1.begin();
	return *data1.begin();
}

真是没想到。。 居然能这么算，惊叹一下~

转自leetcode：

To solve this problem using only constant space, you have to rethink how the numbers are being represented in computers -- using bits.

If you sum the ith bit of all numbers and mod 3, it must be either 0 or 1 due to the constraint of this problem where each number must appear either three times or once. This will be the ith bit of that "single number".

A straightforward implementation is to use an array of size 32 to keep track of the total count of ith bit.

int singleNumber(int A[], int n) {
    int count[32] = {0};
    int result = 0;
    for (int i = 0; i < 32; i++) {
        for (int j = 0; j < n; j++) {
            if ((A[j] >> i) & 1) {
                count[i]++;
            }
        }
        result |= ((count[i] % 3) << i);
    }
    return result;
}

---

We can improve this based on the previous solution using three bitmask variables:

1. ones as a bitmask to represent the ith bit had appeared once.
2. twos as a bitmask to represent the ith bit had appeared twice.
3. threes as a bitmask to represent the ith bit had appeared three times.

When the ith bit had appeared for the third time, clear the ith bit of both ones and twos to 0. The final answer will be the value of ones.

int singleNumber(int A[], int n) {
    int ones = 0, twos = 0, threes = 0;
    for (int i = 0; i < n; i++) {
        twos |= ones & A[i];
        ones ^= A[i];
        threes = ones & twos;
        ones &= ~threes;
        twos &= ~threes;
    }
    return ones;
}

另一个写法：

public class Solution {
    public int singleNumber(int[] A) {
        if (A == null) return 0;
        int x0 = ~0, x1 = 0, x2 = 0, t;
        for (int i = 0; i < A.length; i++) {
            t = x2;
            x2 = (x1 & A[i]) | (x2 & ~A[i]);
            x1 = (x0 & A[i]) | (x1 & ~A[i]);
            x0 = (t & A[i]) | (x0 & ~A[i]);
        }
        return x1;
    }
}

The general version of the question would be:

Given an array of integers, every element appears k times except for one. Find that single one who appears l times.

We need a array x[i] with size k for saving the bits appears i times. For every input number a, generate the new counter by x[j] = (x[j-1] & a) | (x[j] & ~a). Except x[0] = (x[k] & a) | (x[0] & ~a).

In the equation, the first part indicates the the carries from previous one. The second part indicates the bits not carried to next one.

Then the algorithms run in O(kn) and the extra space O(k).

public class Solution {
    public int singleNumber(int[] A, int k, int l) {
        if (A == null) return 0;
        int t;
        int[] x = new int[k];
        x[0] = ~0;
        for (int i = 0; i < A.length; i++) {
            t = x[k-1];
            for (int j = k-1; j > 0; j--) {
                x[j] = (x[j-1] & A[i]) | (x[j] & ~A[i]);
            }
            x[0] = (t & A[i]) | (x[0] & ~A[i]);
        }
        return x[l];
    }
}