原題出處：牛客網-騰訊2017暑期實習生程式設計題

[程式設計題] 有趣的數字
時間限制：1秒

空間限制：32768K

小Q今天在上廁所時想到了這個問題：有n個數，兩兩組成二元組，差最小的有多少對呢？差最大呢？

輸入描述:

輸入包含多組測試資料。

對於每組測試資料：

N - 本組測試資料有n個數

a1,a2…an - 需要計算的資料

保證:

1<=N<=100000,0<=ai<=INT_MAX.

輸出描述:

對於每組資料，輸出兩個數，第一個數表示差最小的對數，第二個數表示差最大的對數。

輸入例子1:
6
45 12 45 32 5 6

輸出例子1:
1 2

解題思路：
　個人思路：
　　看不懂題目…二元組的概念，百度得到的資訊（多元組概念、有序對概念）：二元組為一個有序對，有序對對元素的排列順序是重視的，那麼(a,b)和(b,a)就是兩個不同的二元組，既然如此應該也要考慮到差值為負的情況。。。結果錯誤，不知這是我想多了還是我的理解出錯？但是hofighter的題解給了我很大的啟示，面對一個問題要多考慮一下其他情況。
　　
　hofighter解題思路
　對輸入序列排序
　判斷序列首個元素與末尾元素是否相等
　　是，說明序列中所有元素相同，直接輸出結果為n*(n-1)/2 <= 組合公式推出
　　否，執行下一步
　統計各數字的出現次數
　判斷序列中是否有重複出現的元素
　　是，說明最小值為0，直接統計各個重複出現的元素的所有組合數的和，結果為最小差對數。
　　否，執行下一步
　對序列中元素按序進行遍歷，查詢最小差，統計最小差對數。
　統計最大差對數，最大差對數=序列首個元素的個數*序列末尾元素的個數
　
貼上C#程式碼：

using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{
    static int[] HandleArr(int[] arr)
    {
    　　// Sort array.
        Array.Sort(arr);
        // Check if all element is same.
        if (arr[0] == arr[arr.Length - 1])
            return new int[] { (arr.Length * (arr.Length - 1
 
)) / 2, (arr.Length * (arr.Length - 1)) / 2 };

        // Count the appear amount each element.
        Dictionary<int, int> arrDict = new Dictionary<int, int>();
        for (int i = 0; i < arr.Length; i++)
        {
            if(arrDict.ContainsKey(arr[i]))
            {
                arrDict[arr[i]]++;
            }else
            {
                arrDict[arr[i]] = 1;
            }
        }

        int min = int.MaxValue;
        int max = int.MinValue;
        int minCount = 0;
        int maxCount = 0;
        bool hasRepeat = false;
        // Check repaet situation.
        foreach (int value in arrDict.Values)
        {
            if (value > 1 && hasRepeat == false)
            {
                hasRepeat = true;
                min = 0;
                minCount = 0;
            }

            if(hasRepeat)
            {
                if(value > 1)
                {
                    minCount += value * (value - 1) / 2;
                }
            }          
        }

 　　　　// Common count.
        if(hasRepeat == false)
        {
            for (int i = 0; i < arr.Length-1; i++)
            {
                int t = arr[i + 1] - arr[i];
                if(t<min)
                {
                    min = t;
                    minCount = 1;
                }else if(t==min)
                {
                    minCount++;
                }
            }
        }
 　　　　
 　　　　// Count maxCount.
        maxCount = arrDict.Values.Last<int>() * arrDict.Values.First<int>();

        int[] res = new int[2];
        res[0] = minCount;
        res[1] = maxCount;
        return res;
    }

    static void Main(string[] args)
    {
        string tStr;
        while((tStr = Console.ReadLine()) != null)
        {
            int t = int.Parse(tStr);
            string str = Console.ReadLine();
            string[] strArr = str.Split(' ');
            int[] arr = new int[t];
            for (int i = 0; i < t; i++)
            {
                arr[i] = int.Parse(strArr[i]);
            }

            int[] result = new int[2];
            result = HandleArr(arr);
            Console.WriteLine(result[0] + " " + result[1]);
        }
    }
}