回馈社区~阿里巴巴2018校招笔试题和面经汇总

阿里2018Java笔试

单项选择题

1、以下函数的时间复杂度是  （C ）

void func(int x,int y, int z){
if(x<=0)
printf("%d, %d\n", y, z);
else
{
func(x-1,y+1,z);
func(x-1,y,z+1);
}
}

A.O(x*y*z)

B.O(x^2*y^2)

C.O(2^x)

D.O(2^x*2^y*2^z)

E.O(x!)

F.O((x*y*z)!)

2、在一台64位的计算机上，以下哪段C语言代码与代码(x[2]+4)[3]等价（x的类型是int **） （B  ）

A.*((*(x+16))+28)

B.*((*(x+2))+7)

C.**(x+28)

D.*(((*x)+2)+7)

E.*(((*x)+16)+28)

F.**(x+9)

3、关于ios和Android应用以下描述错误的是（C ）

A.ios和Android应用界面都可以通过IDE可视化界面拖拽完成布局，也可以在运行时通过代码布局

B.Objective C的ARC和Java的GC，都是一种运行时内存管理机制

C.ios和Android应用都可以发布或接收通知来进行跨进程通信

D.Ios和Android应用都在调用某些系统功能如相机时，需预先拥有相应权限

E.ios和Andriod应用都拥有各自独立、安全隔离的文件空间

F.ios和Andriod应用都可以注册自定义URL  Scheme

4、堆栈中有元素abcdef，每次出栈可以选择一个或者两个元素栈，当有两个元素出栈时可以选择其中一个重新入栈，则所有元素为空，那么可能的出栈方式有（C ）种？

A.23

B.22

C.21

D.20

E.19

F.18

5、下列关于linux中kernel space和user space描述错误的是（C ）

A.user space不能直接对文件进行写操作

B.程序代码能手动指定在哪个space中运行

C.user space不能直接创建进程

D.user space和kernel space的运行空间是相互隔离的

E.Kernel space可以执行任意系统命令

F.user space中运行出错不会影响kernel space

正确答案：B

6、请阅读下面代码，计算运行结果：

public class C{
        static class A{
            
        }
        static class B extends A{
            
        }
        public static void main(String[] args){
            ArrayList<A> list = new ArrayList<A>();
            list.add(new B());
            method1(list);
        }
        private static void method1(List<?[侯萍1] supper A> list) {
            for(int i=0;i<list.size();i++){
                A a = list.get(0);
            }
        }
    }

以上程序的运行结果可能出现的是：（B  ）

A.list.add(new B())编译报错

B.method1编译报错

C.A a=list.get(0)编译报错

D.程序正常运行

E.list.add(new B())与method1(list)都编译报错

F.list.add(new B())与A a=list.get(0);编译报错

正确答案：C

    public class ThreadTest{
         private static AtomicInteger atomicInteger=new AtomicInteger();
         public static void main(String[] args){
           A a =new A();
           try{
              atomicInteger.wait();
           } catch (InterruptedException e){
                 e.printStackTrace();
           }
           a.start();
        }
        static class A extends Thread{ @Override public void run(){
           atomicInteger.notify();
           atomicInteger.lazySet(1);
        System.out.println(atomicInteger.get());
        }
    }
}

以上程序的运行结果是：（A ）

A.编译报错，有未捕捉的异常

B.程序正常运行后，一直hold

C.程序正常运行，控制台打印出1

D.程序正常运行，控制台打印出0

E.程序编译通过，但运行时报错

F.以上都不对

8、在一台6G内存Linux操作系统的机器上，coredump打开且大小不做限制，执行下面的程序分别会发生什么？

（1）

    #include<stdio.h>
    #include<stdlib.h>
     
    int32_t main(){
        unit64_t size=8*1024*1024*1024L;
        char* a=new char(size);
        *(a+1)='a';
        return 0;
    }

（2）

    #include<stdio.h>
    #include<stdlib.h>
     
    int32_t main(){
        unit64_t size=10*1024*1024*1024L;
        char* a=new char(size);
        *(a+1)='a';
        return 0;
    }

（3）

    #include<stdio.h>
    #include<stdlib.h>
     
    int32_t main(){
        unit64_t size=7*1024*1024*1024L;
        char* a=new char(size);
        *(a+size-1)='a';
        return 0;
    }

A

A.coredump，coredump，coredump

B.正常，coredump，正常

C.正常，正常，coredump

D.coredump，正常，coredump

E.coredump，正常，正常

F.正常，coredump，coredump

9、下列程序的输出是（A ）

#include<iostream>
using namespace std;
class A{
    public;
    A(int n):m_n(n){}
    int cal(){
        int result = 0,i = 0,j = 0;
        for(int k = m_n;k>0;k--){
            if(j>0)
                j = k*10+j;
            else 
                j = k;
            while (j>=10) {
                int t = j % 100;
                j = j / 100;
                result = ((i++ % 2==0) ? result+t:result-t);
            }
        }
        if(j>0)
            result = ((i++ % 2==0) ? result+j:result-j);
        return result;
    }  private;
    int m_n;
};
int main(){
    A a = A(101);
    cout<<a.cal()<<endl;
    return 0;
}

A.-80

B.-79

C.0

D.90

E.79

F.80

10、用0,1,2,3,4,5组成一个4位数，要求每一位都不一样，请问能组成多少个四位数（C）

A.240

B.280

C.300

D.360

E.400

F.450

11、小明有200个淘公仔，小梅有20个电脑包，每次小明给小梅6个淘公仔，小梅就给小明1个电脑包，经过多少次交互后，小明手中的淘公仔的个数是小梅手中电脑包数量的11倍？（A ）

A.4

B.5

C.6

D.7

E.8

F.9

12、以下描述正确的是（E ）

A.线性规划问题是一个NP-Hard问题

B.因为单纯形法可以保证在限步数内收敛，所以是复杂度为多项式级别的算法，用于解决线性规划问题

C.内点法只用于解决线性规划问题

D.线性规划区别于非线性规划的地方在于，其达到最优点的时候不需要满足K-K-T优化条件

E.一个可解的线性规划问题的主问题和对偶问题分别达到最优化的时候，最优值一定相等

F.以上都不对

正确答案：B

13、设有一个二维数组A[m][n]，假设A[0][1]存放位置在1601(10)，A[3][3]存放位置在1648(10)，每个元素占一个空间，问A[2][2](10)存放在什么位置？脚注(10)表示用10进制表示。（E）

A.1616

B.1617

C.1618

D.1631

E.1632

F.1633

14、天气预报说明天降水概率是84%，假设降水和时间无关，请问明天中午12点之前就降水的概率是多大？（D ）

A.30%

B.40%

C.50%

D.60%

E.70%

F.80%

15、

public class ListParamTest {
    public static void resetList(List<Integer> dataList) {
        dataList.subList(2,4).set(0,40);
        dataList = new ArrayList<Integer>(dataList);
        dataList.add(50);
    }
    public static void setOne(List<Integer> dataList) {
        dataList.set(3,100);
    }
    public static void main(String[] args){
        List<Integer> dataList = new ArrayList<Integer>(Arrays.asList(10,20,30,null));
        resetList(dataList);
        setOne(dataList);
        int sum = 0;
        for(Integer v:dataList){
            sum +=v;
        }
        System.out.println(sum);
    }

程序执行后，输出的结果是：F

A.160

B.抛出UnsupportedOperationException异常

C.抛出NullPointerException异常

D.220

E.210

F.170

16、一个等差数列第x ,y ,z三项的值分别时是y ,z ,x ,试求第x+y项和第z+y项的差值（D ）

A.-3

B.-2

C.-1

D.0

E.1

F.2

19.机器学习中，下面哪个方法不是为了防止过拟合的？A

A.Batchnorm

B.Dropout

C.Weight decay

D.Dropconnect

E.Early stopping

F.Data augmentation

20.在关联规则挖掘算法中，有已知如下事务类，支持度support=0.4，则下列选项不正确的是（A）

A.{Bread,Milk}是频繁项集

B. {Bread,Milk,Beer}是{Bread,Milk}的超集

C. {Bread,Milk}是频繁闭项集

D. {Bread,Milk}是最大频繁项集

E. {Bread,Diaper}是频繁项集

正确答案：D

21.评分卡算法（Score Card）是在金融领域广泛应用的一种评分算法，通过多个维度的评分汇总得到对于一个实体的总体评估，一下说法错误的是（A）

A.评分卡的底层分类算法最常用的是逻辑回归算法，因此评分卡是一种相对白盒的算法

B.评分卡算法其中一个重要的数据处理步骤是数据分箱，根据特征取值将数据离散化为若干区间，这种操作能对某些数据异常值进行处理

C.评分卡算法中如果变量之间存在多重共线性，说明可能存在两个变量高度相关，需要进行降维或剔除变量

D.评分卡中对用户分类使用的逻辑回归算法是广义线性回归模型的一种

E.评分卡模型效果的验证可以通过ROC曲线来看

F.评分卡中的逻辑回归算法可以用于二分类算法，而不能用于多分类问题

编程题：

天猫国际每天都会卖出很多跨境商品，用户每次下单可能购买多个商品，购买总数小于10件，由于海关规定，每一个进入海关的箱子里面的商品总额不能超过2000元（否则不能清关）所以当用户下单总金额超过2000，必须使用多个箱子分开包装运输；现在为了节约运输成本，希望在满足海关的要求下，能够使用尽可能少的箱子。

注：

每个商品都有自己的单价，有特定的长宽高，所有商品都是长方体

商品可以横放、竖放、侧放，但不用考虑斜放，但是长宽高各项总和必须都要小于等于箱子的长宽高

假定目前天猫国际使用同一种规格的箱子

boxLong,boxWidth,boxHigh

（箱子长，箱子宽，箱子高）

某用户下单买了如下商品

n（商品件数）

item1Price,item1Long,item1With,item1High

item2Price,item2Long,item2With,item2High

item3Price,item3Long,item3With,item3High

item4Price,item4Long,item4With,item4High

...

（商品价格，商品长，商品宽，商品高）

(所有输入类型均为int型正整数)

请你算出需要使用最小的箱子数量，可以将这些商品顺利得清关送到消费者手中，如果无解，输出-1

代码模板：

import java.lang.reflect.Array;
import java.util.Scanner;
public class Main {
/**请完成下面这个process函数，实现题目要求的功能**/
 /**当然，你也可以不按照这个模板来作答，完全按照自己的想法来^-^  **/
private static int process()
{
 
}
public static void main(String args[]){
        Scanner scanner = new Scanner(System.in);
        boxTemplate.price = CUSTOMS_LIMIT_MONEY_PER_BOX;
 
        while (scanner.hasNext()){
            boxTemplate.length = scanner.nextInt();
            boxTemplate.width = scanner.nextInt();
            boxTemplate.height = scanner.nextInt();
 
            int itemNum = scanner.nextInt();
            items = new Model[itemNum];
            for(int i=0; i<itemNum; i++){
                Model item = new Model();
                item.price = scanner.nextInt();
                item.length = scanner.nextInt();
                item.width = scanner.nextInt();
                item.height = scanner.nextInt();
                items[i] = item;
            }
            long startTime = System.currentTimeMillis();
            boxMinNum = Integer.MAX_VALUE;
          System.out.println (process());
        }
    }
}

2.

在快递公司干线运输的车辆使用中，存在着单边车和双边车的两种使用场景，例如北京中心-杭州中心，两个分拨中心到彼此的单量对等，则可以开双边车（即同一辆车可以往返对开），而当两个中心的对发单量不对等时，则会采用单边车，并且双边车的成本是低于单边车的，即将两辆对开的单边车合并为一辆往返的双边车是能够节省运力成本的

单边车优化原则：

将单边车优化的规则进行可抽象为以下三种（A,B,C均表示分拨中心）：

规则-1: A-B单边车，B-A单边车 优化方案：将A-B和B-A的两辆单边车合并为双边；

规则-2: A-B单边车，B-C单边车，C-A单边车 优化方案：将A-B、B-C、C-A的三辆单边车优化为一辆环形往返车；

规则-3: A-B单边车，C-A单边车，B、C同省 优化方案：当B、C同省，将A-B、C-A两辆单边优化为一辆环形往返

问题如下：

以某快递公司的实际单边车数据为例（线路ID编码;出分拨中心;出分拨中心所在省;到达分拨中心;到达分拨中心所在省；车型；），进行优化，优化的规则参照以上，并且优先级依次降低，合并的时候需要考虑车型（分为17.5m和9.6m两种）：1、相同车型才能进行合并；2、两辆同方向的9.6m可以与一辆17.5m的对开车型合并优化 说明：优化输出结果按照规则分类，例如rule1：2016120001+2016120002表示将单边车线路ID编码为2016120001和2016120002按照规则1合并优化

代码模板：

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        List<UnilateralLine> lineList = new ArrayList<UnilateralLine>();
        while (scanner.hasNextLine()) {
            String[] options = scanner.nextLine().split(";");
            if (options.length < 5) {
                break;
            }
            lineList.add(new UnilateralLine(options[0], options[1], options[2], options[3], options[4], options[5]));
        }
        scanner.close();
 
        // wirte your code here
        List<String> result = calculateUnilateral(lineList);
 
        for (String str : result) {
            System.out.println(str);
        }
    }
    public static List<String> calculateUnilateral(List<UnilateralLine> lineList) {
        List<String> result = new ArrayList<String>();
        return result;
    }
    public static class UnilateralLine {
    private String id;
    private String sCen;//出发分拨
    private String sPro;//出发省
    private String eCen;//到达分拨
    private String ePro;//到达省
    //9.6m/17.5m
    private String tType;//车型
    public UnilateralLine(String id, String sCen, String sPro, String eCen, String ePro,String tType) {
                this.id = id;this.sCen = sCen;this.sPro = sPro;this.eCen = eCen;this.ePro = ePro;this.tType = tType;}
    public String getId() {return id;}
    public void setId(String id) {this.id = id;}
    public String getSCen() {return sCen;}
    public void setSCen(String ePro) {this.ePro = ePro;}
    public String getSPro() {return sPro;}
    public void setSPro(String sPro) {this.sPro = sPro;}
    public String getECen() {return eCen;}
    public void setECen(String eCen) {this.eCen = eCen;}
    public String getEPro() {return ePro;}
    public void setEPro(String ePro) {this.ePro = ePro;}
    public String getTType() {return tType;}
    public void setTType(String tType) {this.tType = tType;}
    }
}

<div id="div2">
    <div id="div1">点我</div>
</div>
var div2=document.getElementById('div2');
var div1=document.getElementById('div1');
 
div1.addEventListener('click', function(event){console.log("A");}, true);
div2.addEventListener('click', function(event){console.log("B");});
div1.addEventListener('click', function(event){console.log("C");}, false);
div2.addEventListener('click', function(event){console.log("D");}, true);

setTimeout(function () {
 console.log('1');
}, 0);
 
process.nextTick(function(){
    console.log("3");
});
 
console.log('2');
 
setImmediate(function(){
  console.log("4");
});

const data = [
  {
    "id": '1',
    "children": [
   {
  "id": '1-1',
  "children": [],
  "value": "a-1",
   },
   {
  "id": '1-2',
  "children": [],
  "value": "a-2",
   },
 ],
    "value": "a",
  },
  {
    "id": '2',
    "children": [
   {
  "id": '2-1',
  "children": [
    {
"id": '2-1-1',
   "children": [],
   "value": "c-1",
    },
  ],
  "value": "b-1",
   },
 ],
    "value": "b",
  },
  {
    "id": '3',
    "children": [
 ],
    "value": "c",
  },
];

[
  {
    "id": "1",
    "children": [
      {
        "id": "1-1",
        "children": [],
        "value": "a-1"
      },
      {
        "id": "1-2",
        "children": [],
        "value": "a-2"
      }
    ],
    "value": "a",
    "relateId": "1-1"
  },
  {
    "id": "2",
    "children": [
      {
        "id": "2-1",
"children": [
          {
            "id": "2-1-1",
            "children": [],
            "value": "c-1"
          }
        ],
        "value": "b-1",
        "relateId": "2-1-1"
      }
    ],
    "value": "b",
    "relateId": "2-1-1"
  },
  {
    "id": "3",
    "children": [],
    "value": "c"
  }
]

<meta charset="UTF-8">
<title>Title</title>
 
 
<ul id="list">
 
</ul>
 
<script>
  maxLength = 4;
  list = document.querySelector('#list');
 
  function processName(name) {
    return {
      firstName: name[0],
      lastName: name[1],
      getFullName() {
        return this.firstName + ' ' + this.lastName;
      },
    };
  }
 
  var names = [
    ['Gregor', 'Bachmann'],
    ['Anita', 'Bruns'],
    ['Anke', 'Dorn'],
    ['Ulrich', 'Koch'],
    ['Dietrich', 'Riedl'],
    ['Wolfgang', 'Jahn'],
    ['Gesine', 'Sturm'],
    ['Theodor', 'Petersen'],
  ];
 
  var validCount = 0;
for (var i = 0; i < names.length; i += 1) {
    var flag1 = names[i][0].indexOf('A') !== 0;
    var getFullName;
    if (flag1 && names[i][0].length >= 4) {
      getFullName = processName(names[i]).getFullName;
      var lastName = processName(names[i]).lastName;
      var firstName = processName(names[i]).firstName;
      var span = document.createElement('li');
      var textNode = document.createTextNode(i + 1 + '. ' + getFullName());
      span.appendChild(textNode);
      span.addEventListener('click', function () {
        console.log('click on no.' + i + ' ' + firstName + ',' + lastName);
      });
      if (validCount + 1 > maxLength) {
        continue;
      }
      validCount += 1;
      list.appendChild(span);
    }
  }
</script>