Single Number && Single Number II && Factorial Trailing Zeroes && Pow(x, n) && Add Two Numbers

Single Number

1、异或交换性质

    int singleNumber(int A[], int n) {
        int ans = A[0];
        for (int i = 1; i < n; i++)
            ans ^=A[i];
        return ans;
    }

Single Number II

1、只有一个数字出现一次，其他的出现3次，找出这个数字。

2、将每个数字每一位加起来对3取余得到的结果就是那个要找的数。

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

3、另一种方法。当作二进制来计算，用两个整数来表示第一位和第二位，bit1表示出现了1次，bit2为1表示出现了两次，如果两个都为1，表示出现了3次，然后取反等于清零。

参考链接

    int singleNumber(int A[], int n) {
        int bit1 = 0, bit2 = 0, bit3 = 0;
        for (int i = 0; i < n; i++) {
            bit2 |= bit1 & A[i];
            bit1 ^= A[i];
            bit3 = ~(bit1 & bit2);
            bit1 &= bit3;
            bit2 &= bit3;
        }
        return bit1;
    }

Factorial Trailing Zeroes

1、只有偶数乘5才会有0，偶数太多只要考虑5，同时考虑一个数有多个5的因子的情况。

    int trailingZeroes(int n) {
        int ans = 0;
        while (n) {
            ans += n / 5;
            n /= 5;
        }
        return ans;
    }

Pow(x, n)

1、求一个数的幂，考虑负数和0和正数幂，负数最小值比正数最大值大1。

2、求指数，扫描指数的二进制位，指数相加可以转换为指数的乘法。

参考网页

代码如下：

    double pow(double x, int n) {
        if (n < 0) {
            if (n == INT_MIN)
                return 1.0 / (pow(x, INT_MAX) * x);
            else 
                return 1.0 / pow(x, -n);
        }
        else if (n == 0)
            return 1.0;
        double ans = 1.0;
        for ( ; n > 0; x *= x, n >>= 1) 
            if (n & 1 > 0)
                ans *= x;
        return ans;
    }

Add Binary

我的思路：

1、申请一个string，从两个string的尾部把数据push进去，最后把string reverse。

    string addBinary(string a, string b) {
        int i, j, flag = 0;
        string s;
        for (i = a.size() - 1, j = b.size() - 1; i >= 0 && j >= 0; i--, j--) {
            s.push_back((a[i] + b[j] + flag) % 2);
            flag = (a[i] + b[j]) / 2;
        }
        if (i >= 0)
            for ( ; i >= 0; i--) {
                s.push_back((a[i] + flag) % 2);
                flag = (a[i] + flag) / 2;
            }
        if (j >= 0)
            for ( ; j >= 0; j--) {
                s.push_back((b[j] + flag) % 2);
                flag = (b[j] + flag) / 2;
            }
        reverse(s.begin(), s.end());
        return s;
    }

Add Two Numbers

我的思路：

1、一开始没考虑到这个是不带头节点的链表，所以返回head->next。

2、也可以不用那么多的while，用一个，在循环里面判断也是可以。

    ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
        ListNode *ans = new ListNode(0);
        ans->next == NULL;
        int flag = 0;
        ListNode *p1 = l1, *p2 = l2;
        ListNode *head = ans;
        while (p1 != NULL && p2 != NULL) {
            ListNode *p = new ListNode(0);
            p->val = (p1->val + p2->val + flag) % 10;
            flag = (p1->val + p2->val + flag) / 10;
            ans->next = p;
            ans = p;
            p1 = p1->next;
            p2 = p2->next;
        }
        while (p1 != NULL) {
            ListNode *p = new ListNode(0);
            p->val = (p1->val + flag) % 10;
            flag = (p1->val + flag) / 10;
            ans->next = p;
            ans = p;
            p1 = p1->next;
        }
        while (p2 != NULL) {
            ListNode *p = new ListNode(0);
            p->val = (p2->val + flag) % 10;
            flag = (p2->val + flag) / 10;
            ans->next = p;
            ans = p;
            p2 = p2->next;
        }
        if (flag != 0) {
            ListNode *p = new ListNode(0);
            p->val = flag;
            ans->next = p;
            ans = p;
        }
        ans->next = NULL;
        return head->next;    
    }