問題： 重複 N 次的元素

在大小為 2N 的陣列 A 中有 N+1 個不同的元素，其中有一個元素重複了 N 次。

返回重複了 N 次的那個元素。

示例 1：

輸入：[1,2,3,3]
輸出：3

示例 2：

輸入：[2,1,2,5,3,2]
輸出：2

示例 3：

輸入：[5,1,5,2,5,3,5,4]
輸出：5

提示：

1. 4 <= A.length <= 10000
2. 0 <= A[i] < 10000
3. A.length
    為偶數

連結：https://leetcode-cn.com/contest/weekly-contest-116/problems/n-repeated-element-in-size-2n-array/

分析：

0.AC做法，將資料排序，統計每個元素的個數，一旦某一個是N，返回這個數字。

1.2N個元素中有N+1個不同的元素，且一個元素重複了N次，則這個重複了N次的必定是唯一眾數，且除非是最大值或者最小值，否則也必定是中數。

比賽期間嘗試直接返回中位值，不過失敗了，沒繼續深入，現在想來，只有是最大值或者最小值的時候才會失敗，完全可以只統計最大值個數，最小值個數，如果有一個是N，返回，否則返回排序後中間的那個數字。

AC Code：

 1 class Solution {
 2 public:
 3 int repeatedNTimes(vector<int>& A) {
 4         if (A.size() == 2)
 5         {
 6             return A[0];
 7         }
 8         int ret = 0;
 9         sort(A.begin(), A.end());
10         //ret = A[A.size() / 2];
11         int
 
 num = 1;
12         ret = A[0];
13         for (unsigned int i = 1; i < A.size(); i++)
14         {
15             if (A[i] != ret)
16             {
17                 ret = A[i];
18                 num = 1;
19             }
20             else
21             {
22                 num++;
23                 if (num == A.size() / 2)
24                 {
25                     return ret;
26                 }
27             }
28         }
29         return ret;
30     }
31 };

賽後AC code

class Solution {
public:
int repeatedNTimes(vector<int>& A) {
        if (A.size() == 2)
        {
            return A[0];
        }
        int ret = 0;
        sort(A.begin(), A.end());
        
        int num = A[0];
        int times = 1;
        for (int i = 1; i < A.size(); i++)
        {
            if (num != A[i])
            {
                if (times == A.size() / 2)
                {
                    return A[0];
                }
                break;
            }
            else
            {
                times++;
            }
        }
        num = A[A.size() - 1];
        times = 1;
        for (int i = A.size()-2;i>=0 ;i--)
        {
            if (num != A[i])
            {
                if (times == A.size() / 2)
                {
                    return num;
                }
                break;
            }
            else
            {
                times++;
            }
        }        
        ret = A[A.size() / 2];
        
        return ret;
    }
};

其他：

1.簡單的題，隨便就過了，如果對時間有要求的話，可能就得用第二種方法才能過了。

不考慮太多，統計每個元素個數就夠了。

2.第一code：

 1 class Solution:
 2     def repeatedNTimes(self, A):
 3         """
 4         :type A: List[int]
 5         :rtype: int
 6         """
 7         n = len(A)//2
 8         l = dict()
 9         for e in A:
10             if e in l:
11                 l[e] += 1
12             else:
13                 l[e] = 1
14         for e in l:
15             if l[e] == n:
16                 return e

統計個數找個數是N的，可能都沒怎麼多想吧

第二code：

 1 class Solution(object):
 2     def repeatedNTimes(self, A):
 3         """
 4         :type A: List[int]
 5         :rtype: int
 6         """
 7         d = set()
 8         for num in A:
 9             if num not in d:
10                 d.add(num)
11             else:
12                 return num

感覺更有意思一點，2N個元素，N+1個不同，其中一個還是有N個元素的，那麼其他的都是隻有一個元素，那麼完全可以更快：答案必定是A[A.size()/2]和A[A.size()/2-1]中的一個，如果兩者相同，即為結果，否則如果A[A.size()/2-1]==A[A.size()/2-2]，是答案，否則A[A.size()/2]是答案。