小紧

2018-07-11 18:30 已编辑南阳理工学院 Java

关注

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

这两天在讨论区看到了不少阿里巴巴的内推贴，想起去年的时候，阿里7月中下旬开始内推大家都觉得早……谁能想到今年各家企业都这么积极。

在牛客也混了很长时间了，一直没有对牛客做什么贡献，想来只有分享一波阿里巴巴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

7、请阅读下面代码，计算运行结果;

    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.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）

TID	Items
1	Bread，Milk
2	Bread，Diaper，Beer，Eggs
3	Milk，Diaper，Beer，Coke
4	Bread，Milk，Diaper，Beer，
5	Bread，Milk，Diaper，Coke

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());
        }
    }
}

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

单边车优化原则：

将单边车优化的规则进行可抽象为以下三种（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;}
    }
}

阿里2018笔试

1. 下面代码中，当点击点我时，输出的正确结果是：

<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);

A、A B C D

B、D A C B

C、A D B C

D、D C A B

E、B D A C

2. 关于Fetch API，以下描述错误的是：

A、fetch()返回的是一个Promise实例

B、Fetch API可以结合async / await使用

C、Fetch API提供的API囊括但不限于XHR的所有功能

D、Fetch API可以跨域

E、Fetch提供了对Request和Response对象的通用定义

F、fetch()必须接受一个参数：资源的路径

3. 以下代码片段在Node.js环境下执行的结果顺序是：

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

A、2、1、4、3

B、2、1、3、4

C、2、3、1、4

D、4、1、2、3

E、4、2、1、3

F、1、4、2、3

正确答案：C

4. 以下哪个标签不属于svg元素：

A、<circle>

B、<ellipse>

C、<rectangle>

D、<marker>

E、<polyline>

F、<animate>

关于ES6当中箭头函数说法错误的是:

A、箭头函数可以使用yield

B、箭头函数不可以用作构造函数

C、不会改变this的指向

D、箭头函数是Function的实例

E、箭头函数函数体没有花括号可以做为返回值

F、内部不能访问到arguments对象

正确答案：A

6. 关于JavaScript中的函数，以下说法正确的有：

A、在已知名称的函数的函数体声明语句之外，不能获知该函数的形参个数

B、在函数内部，可以通过arguments获取函数的实参个数

C、因为arguments是Array的实例，因此可以使用数组的方法去操作它

D、对同一个函数foo，使用 new foo() 和 foo() 调用的结果是一样的

E、如果一个函数中没有使用return语句，则它默认返回null

G、如果函数的实参是一个引用对象，则对应形参会和该实参指向同一个对象

正确答案：BF

7. 关于CSS的position属性，下列说法中正确的是：

默认值是relative

A、值为static时，left、right、top、bottom的值无效。

B、fixed相对于页面视口定位

C、absolute是相对于body标签定位

D、absolute的元素可以设置外边距（margins），且不会与其他边距合并

E、fix和absolute相对的定位对象是一样的

正确答案：AD

10．关于ES6类（Class）的实现，以下表述正确的是：

A、ES6的class只是一个语法糖，实际上还是基于原型来实现的

B、如果没在class里面定义constructor方法，编译器会自动帮你添加

C、ES6的class中支持定义私有属性

D、和ES5一样，同一个类的所有实例共享一个原型对象

E、如果没有显式指定构造方法，则会添加默认的constructor方法

F、修改基类的原型，派生类实例的原型不会被修改

11. 变量data为树状结构，数据大小层次不固定，格式如下：

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",
  },
];

请实现个方法transformData,递归处理数据，给所有的父节点（children不为空的）添加一个字段relateId,值为当前第一个子节点（children为空的） id的值。

如上面的数据经过处理后的结果为：

[
  {
    "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"
  }
]

12. 下面HTML中的内嵌JS代码会生成一个列表，格式为"{index}. {点击目标的全名}"。于此同时当点击列表中的某个名字会在控制台中输出"click on no.{点击目标的index} {firstName},{lastName}"。请尝试指出代码中存在的BUG以及可能会发生的性能问题，并从优雅、高效、可读性以及性能方面进行优化，在指出问题的同时请尽量给出修正代码。

<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>