阿里巴巴2018届应届生在线编程测验-研发工程师C/C++

刚才去做了阿里巴巴的编程测验,好消息是抽到的题相对别的题简单一些,坏消息是编的太慢了,没有做完.

现在把题目和自己后来编出来的代码贴在这里,供大家参考.

题目:

1. 从命令行输入若干个正整数(大于等于2个)，得到一个集合N。
2. 从N中任意取出两个数并求和，得到的值构成集合A。
3. 从N中任意取出两个数，并求差的绝对值，得到的值构成集合B。
4. 从集合A和集合B当中，任意取出两个数，其差的绝对值，又构成集合D
D的最小元素是d1,D的最大元素是d2,D的元素个数是s
请输出d1+d2+s

题目要求

编译器版本: gcc 4.8.4
请使用标准输入输出(stdin，stdout) ；请把所有程序写在一个文件里，勿使用已禁用图形、文件、网络、系统相关的头文件和操作，如sys/stat.h , unistd.h , curl/curl.h , process.h
时间限制: 3S (C/C++以外的语言为: 5 S) 内存限制: 128M (C/C++以外的语言为: 640 M)
输入:
n //这是输入整数的个数 x1 //第一个整数 x2 //第二个整数 ... xn //第n个整数
输出:
m //一个整数
输入范例:
5
101
102
103
104
105
输出范例:
417

题目中的代码:

 #include <iostream>
 #include <vector>
 #include <numeric>
 #include <limits>
 using namespace std;
 // 请完成下面这个函数，实现题目要求的功能
 // 当然，你也可以不按照这个模板来作答，完全按照自己的想法来 ^-^
 int result(const vector <int>& inputs) {
     return ;
 }

 int main() {
     int size = ;
     cin >> size;
     cin.ignore (numeric_limits<std::streamsize>::max(), '\n');
     vector<int> points;
     for(size_t i=; i<size; ++i) {
         int item;
         cin >> item;
         cin.ignore (numeric_limits<std::streamsize>::max(), '\n');
         points.push_back(item);
     }
     int res = result(points);
     cout << res << endl;
     return ;
 }

自己编写的区域:

 //第一版 未使用set
 int result(const vector <int>& inputs) {
     vector<int> vecA;
     for (int i = ; i < inputs.size() - ; ++i)
     {
         for (int j = i + ; j < inputs.size(); ++j)
         {
             vecA.push_back(inputs[i] + inputs[j]);
             for (int k = ; k < vecA.size() - ; ++k)
             {
                 if ((inputs[i] + inputs[j]) == vecA[k])
                 {
                     vecA.pop_back();
                 }
             }
         }
     }

     vector<int> vecB;
     for (int i = ; i < inputs.size() - ; ++i)
     {
         for (int j = i + ; j < inputs.size(); ++j)
         {
             vecB.push_back((abs)(inputs[i] - inputs[j]));
             for (int k = ; k < vecB.size() - ; ++k)
             {
                 if ((abs)(inputs[i] - inputs[j]) == vecB[k])
                 {
                     vecB.pop_back();
                 }
             }
         }
     }

     vector<int> vecD;
     for (int i = ; i < vecA.size(); ++i)
     {
         for (int j = ; j < vecB.size(); ++j)
         {
             vecD.push_back((abs)(vecA[i] - vecB[j]));
             for (int k = ; k < vecD.size() - ; ++k)
             {
                 if ((abs)(vecA[i] - vecB[j]) == vecD[k])
                 {
                     vecD.pop_back();
                 }
             }

         }
     }

     int nMax, nMin;
     nMax = nMin = vecD[];
     for (int k = ; k < vecD.size(); ++k)
     {
         if (vecD[k] >= nMax)
         {
             nMax = vecD[k];
         }
         if (vecD[k] <= nMin)
         {
             nMin = vecD[k];
         }
     }
     return nMax + nMin + vecD.size();
 }

 //第二版 使用vector较多
 int result(const vector <int>& inputs) {
     set<int> setA, setB, setD;

     vector<int> vecA;
     for (int i = ; i < inputs.size() - ; ++i)
     {
         for (int j = i + ; j < inputs.size(); ++j)
         {
             vecA.push_back(inputs[i] + inputs[j]);
         }
     }
     setA.insert(vecA.begin(), vecA.end());

     vector<int> vecB;
     for (int i = ; i < inputs.size() - ; ++i)
     {
         for (int j = i + ; j < inputs.size(); ++j)
         {
             vecB.push_back((abs)(inputs[i] - inputs[j]));
         }
     }
     setB.insert(vecB.begin(), vecB.end());

     vector<int> vecD;
     for (int i = ; i < vecA.size(); ++i)
     {
         for (int j = ; j < vecB.size(); ++j)
         {
             vecD.push_back((abs)(vecA[i] - vecB[j]));
         }
     }
     setD.insert(vecD.begin(), vecD.end());
     vector<int> ivec(setD.begin(), setD.end());    //set没有sort函数,先加到vector中.
     sort(ivec.begin(), ivec.end());
     cout << ivec[] + ivec[ivec.size() - ] + ivec.size();
     return ;
 }

 //第三版 去除不必要的vector
 int result(const vector <int>& inputs) {
     set<int> setA, setB, setD;

     for (int i = ; i < inputs.size() - ; ++i)
     {
         for (int j = i + ; j < inputs.size(); ++j)
         {
             setA.insert(inputs[i] + inputs[j]);    //这里可以使用insert.
         }
     }

     for (int i = ; i < inputs.size() - ; ++i)
     {
         for (int j = i + ; j < inputs.size(); ++j)
         {
             setB.insert((abs)(inputs[i] - inputs[j]));
         }
     }

     for (set<int>::iterator it1 = setA.begin(); it1 != setA.end(); ++it1)
     {
         for (set<int>::iterator it2 = setB.begin(); it2 != setB.end(); ++it2)
         {
             setD.insert((abs)(*it1 - *it2));
         }
     }
     vector<int> ivec(setD.begin(), setD.end());    //set没有sort函数,先加到vector中.
     sort(ivec.begin(), ivec.end());
     return ivec[] + ivec[ivec.size() - ] + ivec.size();

 }

评论中学到的新知识

//From 木子可 

set<int> s, A, B, D;
for (auto i : inputs)    //!C++11新特性
    s.insert(i);    //!for循环省略了{}
for (auto i = s.begin(); i != prev(s.end()); i++)//!prev,next新的特性吧
    for (auto j = next(i); j != s.end(); j++)
    {
        A.insert(*i + *j);
    }

for (auto i = s.begin(); i != prev(s.end()); i++)
    for (auto j = next(i); j != s.end(); j++)
    {
        int tmp = *i - *j;
        tmp = tmp >  ? tmp : -tmp;
        B.insert(tmp);
    }

//From Garcia-0 

forward iterator是前向迭代器,总共有5种:

     种类                                      特性                                                                   示例

输入迭代器                   读,不能写,只支持自增                                                istream_iterator

输出迭代器                   写,不能读,只支持自增　　　　　　　　　　　　　  ostream_iterator

前向迭代器　　　　　  读和写,只支持自增　　　　　　　　　　　　　　   unordered_map、unordered_set

双向迭代器　　　　　  读和写,支持自增和自减　　　　　　　　　　　   　map,set,list

随机访问迭代器            读和写,支持完整的迭代器算术运算                            string,vector,deque