1、输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序 vector<vector<int> > FindContinuousSequence(int sum) ；

解析：题目需要解析的点，如何计算累加？数组下标控制涉及到读取问题，考虑由于是连续的数组，所以可以采用small和big变量标记代表数字，并且进行++/--；

如何返回一个保存容器的容器？一维数组的容器不可以直接返回，可以采用形参引用的方式来返回，但是二维可以直接返回，并且要知道赋值的方式；

2、对应每个测试案例，输出两个数，小的先输出

解析：这个题目从首位开始加起，排除不可能的情况，对于乘积，从远处优先排除，就可以不用特地考虑乘积的问题（两数越远乘积越小）

3、统计一个数字在排序数组中出现的次数。

解析：注意是排序数组，找到第一个出现的位置和最后一个出现的位置，两个位置相减就是数字出现的次数。

查找由于是有序的就用二分查找的方法

4、在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。

解析：利用哈希的想法，按下标存入

5、一个整型数组里除了两个数字之外，其他的数字都出现了偶数次。请写程序找出这两个只出现一次的数字。

解析：排序 然后两个指针比较

6、二维数组的旋转打印问题

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

答案：
1、 vector<vector<int> > FindContinuousSequence(int sum) {
        vector<vector<int>> vec;
        int small=1;
        int big=2;
        int msum=small+big;
        while(small<big)
        {    
             while(msum>sum)
            {
                msum-=small;
                small++;
            }
            if(msum==sum&&small!=big)
            {
                vector<int> tmp;
               for(int i=small;i<=big;i++)
                   tmp.push_back(i);
                vec.push_back(tmp);
            }
            big++;
            msum+=big;
        }
        return vec;
    }
2、vector<int> FindNumbersWithSum(vector<int> array,int sum) {
        int len=array.size();
        int s=0;
        int b=len-1;
        vector<int> vec;
        while(s<b)
        {
          
            if(array[s]+array[b]<sum)
                s++;
            else if(array[s]+array[b]>sum)
                b--;
            else
            {
                vec.push_back(array[s]);
                vec.push_back(array[b]);
                break;
            }  
        }
        return vec;
    }
4、 bool duplicate(int numbers[], int length, int* duplication) {
         if(numbers==NULL||length==0) 
             return 0;
         int hashTable[255]={0};
        for(int i=0;i<length;i++)
        {
            hashTable[numbers[i]]++;
        }
        int count=0;
        for(int i=0;i<length;i++)
        {
            if(hashTable[numbers[i]]>1)
            {
                duplication[count++]=numbers[i];
                //break;
                return true;
            }
        }
        return false;
    }
5、 void FindNumsAppearOnce(vector<int> arr,int* num1,int *num2) {
        sort(arr.begin(),arr.end());
        arr.push_back('*');
        vector<int> re;
        for(int i=0;i<(int)arr.size();)
        {
            if(arr[i]==arr[i+1])
                i=i+2;
            else
            {
                re.push_back(arr[i]);
                i++;
            }
        }
        *num1=re[0];
        *num2=re[1];

    }
6、二维数组的旋转打印
vector<int> printMatrix(vector<vector<int> > matrix) 
    {
        
        int row=matrix.size();
        int col=matrix[0].size();
        
        vector<int> vec;
        
        if(row==0||col==0)
            return vec;
        int start=0;
        while(row>start*2&&col>start*2)
        {
            int endx=col-1-start;
            int endy=row-1-start;
              for(int i=start;i<=endx;i++)
              {
                vec.push_back(matrix[start][i]);
               }
           
            if(endy>start)
            {
                for(int i=start+1;i<=endy;i++)
                {
                     vec.push_back(matrix[i][endx]);
                }
            }
             if(endy>start&&endx>start)
            {
                for(int i=endx-1;i>=start;i--)
                {
                     vec.push_back(matrix[endy][i]);
                }
            }
             if(endy>start+1&&endx>start)
            {
                for(int i=endy-1;i>=start+1;i--)
                {
                     vec.push_back(matrix[i][start]);
                }
            }
            start++;
        }
       
        return vec; 
        
    }
};