网易－测试－笔试

最新推荐文章于 2021-07-22 17:17:12 发布
最新推荐文章于 2021-07-22 17:17:12 发布
阅读量837 收藏 2
点赞数
分类专栏： 测试 文章标签： 测试 网易
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012441545/article/details/52241321
版权

（1）第一题：洗牌

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)

Problem Description:

一、题目：

洗牌在生活中十分常见，现在需要写一个程序模拟洗牌的过程。

现在需要洗2n张牌，从上到下依次是第1张，第2张，第3张一直到第2n张。首先，我们把这2n张牌分成两堆，左手拿着第1张到第n张（上半堆），右手拿着第n+1张到第2n张（下半堆）。接着就开始洗牌的过程，先放下右手的最后一张牌，再放下左手的最后一张牌，接着放下右手的倒数第二张牌，再放下左手的倒数第二张牌，直到最后放下左手的第一张牌。接着把牌合并起来就可以了。

例如有6张牌，最开始牌的序列是1,2,3,4,5,6。首先分成两组，左手拿着1,2,3；右手拿着4,5,6。在洗牌过程中按顺序放下了6,3,5,2,4,1。把这六张牌再次合成一组牌之后，我们按照从上往下的顺序看这组牌，就变成了序列1,4,2,5,3,6。

现在给出一个原始牌组，请输出这副牌洗牌k次之后从上往下的序列。


输入

第一行一个数T(T<=100)，表示数据组数。对于每组数据，第一行两个数n,k(1<=n,k<=100)，接下来一行有2n个数a1,a2,...,a2n(1<=ai<=1000000000)。表示原始牌组从上到下的序列。


输出

对于每组数据，输出一行，最终的序列。数字之间用空格隔开，不要在行末输出多余的空格。


样例输入

3

3 1

1 2 3 4 5 6

3 2

1 2 3 4 5 6

2 2

1 1 1 1

样例输出

1 4 2 5 3 6

1 5 4 3 2 6

1 1 1 1

二、代码（两种方法）：

方法一思路：

1）洗牌的头和尾的牌的位置是不变的，一次的排序中，头和尾的数字不需要变化，从head＝1，tail＝length－2开始，中间的为mid;每次的循环后，head++;tail--; 当tail-head<0时，一次排序结束；在每次的循环中，tail的数据与mid 的数据交换位置，交换后，tail--,mid--;一直到mid<head的时候停止交换数据；

2）k指的是洗几次牌，也就是重复几次的1）操作

这个算法是以时间复杂度换取空间复杂度

import java.util.*;

public class Main {
    public static void sortStr(int[] a,int k)
    {
        while(k>0)
        {
            int tail=a.length-2;
            int head=1;
            int mid=a.length/2-1;
            while(tail-head>=0)
            {
                stangeStr(a,head,tail, mid);
                head++;
                tail--;
            }
            k--;
        }
        for(int i=0;i<a.length;i++)
        {
            System.out.print(a[i]);
        }
    }
    public static void stangeStr(int a[],int head,int tail,int mid)
    {
        int temp;
        while (mid>=head)
        {
            temp = a[tail];
            a[tail] = a[mid];
            a[mid] = temp;
            mid--;
            tail--;
        }
    }
    public static void main(String args[])
    {
        Scanner cin = new Scanner(System.in);
        int n, k;
        int c=cin.nextInt();
        while(c>0)
        {
            n = cin.nextInt();
            k = cin.nextInt();
            int n2=2*n;
            int[] a=new int[n2];
            for(int i=0;i<n2;i++)
                a[i]= cin.nextInt();

            sortStr(a,k);
            c--;
        }
    }
}
方法二思路：

将输入的数组a的前一半存储在arry1中，后面的一半数据存储在arry2中，然后一次将arry1和arry2中的数据轮流插入a 中，是从末位的数据开始插入a中的尾部；例如，第一次先把arry2中的最后一个数据插入a中的最后一个位置，下一次将arry1中的最后一个数据插入a中倒数第二个位置；接着将arry2中的倒出第二个数插入a中的倒数第三个位置，arry1中的倒数第二个数插入a中的倒数第四个位置；一次循环一直到arry1和arry2中的数据全部插入a中，这时a中的数据就是一次洗牌后的数据次序。

该方法是以空间换取时间

代码如下：

import java.util.*;

public class Main {
    public static void sortStr(int[] a,int k)
    {
        int len=a.length;
        int len1=len/2;
        while(k>0) {
            int[] arry1 = new int[len1];
            int[] arry2 = new int[len1];
            int i = 0;
            for (; i < len1; i++)
                arry1[i] = a[i];
            for (int j=0; i < len; j++,i++)
                arry2[j] = a[i];
            int tail1 = len1 - 1;
            int tail2 = len1 - 1;
            for (int j = len - 1; j >= 0; j--) {
                if (j % 2 == 0)
                    a[j] = arry1[tail1--];
                else
                    a[j] = arry2[tail2--];
            }
            k--;
        }
        for(int j=0;j<len;j++)
            System.out.print(a[j]);
    }
    public static void main(String args[])
    {
        Scanner cin = new Scanner(System.in);
        int n, k;
        int c=cin.nextInt();
        while(c>0)
        {
            n = cin.nextInt();
            k = cin.nextInt();
            int n2=2*n;
            int[] a=new int[n2];
            for(int i=0;i<n2;i++)
                a[i]= cin.nextInt();

            sortStr(a,k);
            c--;
        }
    }
}
（2）第二题：组成矩阵

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)

Problem Description:

对于一组水平线段及垂直线段，共有n条，已知其中必定存在一个若干条线段组成的矩形，输出这个矩形的左下角和右上角点，定义左下角点有最小的x值和y值，右上角点有最大的x值和y值。

线段可以重合，线段必须恰好能组成矩形，即线段不能头或尾部超出矩阵边界，如下图：


输入

第一行为线段数 n (4 <= n <= 25)

接下来有n行，每行为一条线段的首尾点坐标： xi yi xj yj

坐标值范围 -1e9 <= x, y <= 1e9

输出

在一行输出矩形的左下角点和右上角点坐标：

xi yi xj yj 

根据定义有 xi < xj && yi < yj


样例输入

4

0 0 0 1

0 0 1 0

0 1 1 1

1 0 1 1 

样例输出

​0 0 1 1

二、思路：假如左下角的坐标是（x1,y1）,右上角的坐标是（x2,y2）时，必然存在的输入数据如下

x1 y1 x1 y2

x1 y1 x2 y1

x1 y2 x2 y2

x2 y1 x2 y2

所以当判断两个坐标是否能够凑成一个矩阵的时候，只需判断输入数据中属否存在如上规律，如果存在，则这两个坐标分别是左下角坐标和右下角坐标，然后再用这两个坐标分别与最小的左下角坐标和最大的右上角坐标相比较；以此循环，最终能够得到最小的左下角坐标和最大的右上角坐标。

将输入的每行数据的前两个数作为左下角坐标集合，输入数据的每行的最后两个数做为右上角坐标集合，以此来两两判断左下角坐标集合与右上角坐标集合之间是否能够构成一个举证。

左下角集合和右上角集合中会存在着重复的数据，所以可以先去除重复的数据来减少时间的复杂度，我的思路是将已经出现过的坐标赋值为（－1，－1）

三、代码：

import java.util.*;

public class Main {

    public static void minPos(int[][] arry)
    {
        int minX=0,minY=0;
        int maxX=0,maxY=0;
        int xi,yi,xj,yj;
        boolean bool;
        int[][] arry1=new int[arry.length][2];
        int[][] arry2=new int[arry.length][2];
        duplicateNum(arry1,arry2,arry);
        for(int i=0;i<arry.length;i++)
        {
            xi=arry1[i][0];
            yi=arry1[i][1];
            if(xi!=-1&&yi!=-1) {
                for (int j = 0; j < arry.length; j++) {
                    xj = arry2[j][0];
                    yj = arry2[j][1];
                    if(xj!=-1&&yj!=-1) {
                        bool = beIn(xi, yi, xj, yj, arry);
                        if (bool) {
                            if (minX >= xi && minY >= yi) {
                                minX = xi;
                                minY = yi;
                            }
                            if (maxX <= xj && maxY <= yj) {
                                maxX = xj;
                                maxY = yj;
                            }
                        }
                    }

                }
            }
        }
        System.out.print(minX);
        System.out.print(minY);
        System.out.print(maxX);
        System.out.print(maxY);
    }
    public static void duplicateNum(int[][] arry1,int[][] arry2,int[][] arry)
    {
        for(int i=0;i<arry.length;i++ )
        {
            arry1[i][0]=arry[i][0];
            arry1[i][1]=arry[i][1];
            arry2[i][0]=arry[i][2];
            arry2[i][1]=arry[i][3];
        }
        int x,y,x1,y1;
        for(int i=0;i<arry.length;i++)
        {
            x= arry1[i][0];
            y=arry1[i][1];
            x1= arry2[i][0];
            y1= arry2[i][1];
            for(int j=i+1;j<arry.length;j++)
            {
                if(x==arry1[j][0]&&y==arry1[j][1])
                {
                    arry1[j][0]=-1;
                    arry1[j][1]=-1;
                }
                if(x1==arry2[j][0]&&y1==arry2[j][1])
                {
                    arry2[j][0]=-1;
                    arry2[j][1]=-1;
                }
            }
        }
    }
    public static boolean beIn(int xi,int yi,int xj,int yj,int[][] arry)
    {
        int ai=xi,aj=yj;
        int bi=xj,bj=yi;
        int num=0;
        int flag1=0,flag2=0,flag3=0,flag4=0;
        for(int i=0;i<arry.length;i++)
        {
            int ci=arry[i][0],cj=arry[i][1];
            int di=arry[i][2],dj=arry[i][3];
            if(ci==xi&&cj==yi&&(di==ai&&dj==aj)&&flag1==0)
            {
                num++;
                flag1=1;
                continue;
            }
            if(ci==xi&&cj==yi&&(di==bi&&dj==bj)&&flag2==0)
            {
                num++;
                flag2=1;
                continue;
            }
            if(ci==ai&&cj==aj&&di==xj&&dj==yj&&flag3==0)
            {
                num++;
                flag3=1;
                continue;
            }
            if(ci==bi&&cj==bj&&di==xj&&dj==yj&&flag4==0)
            {
                num++;
                flag4=1;
                continue;
            }

        }
        if(num==4)
            return true;
        return false;
    }
    public static void main(String args[])
    {
        Scanner cin = new Scanner(System.in);
        int c=cin.nextInt();
        int[][] arry=new int[c][4];
        for(int i=0;i<c;i++)
            for(int j=0;j<4;j++)
            {
                arry[i][j]= cin.nextInt();
            }
        minPos(arry);

    }
}
（3）第三题：构造队列

一、题目：

构造队列

Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)

Problem Description:

小明同学把1到n这n个数字按照一定的顺序放入了一个队列Q中。现在他对队列Q执行了如下程序：

while(!Q.empty())              //队列不空，执行循环

         {

                   int x=Q.front();            //取出当前队头的值x

                   Q.pop();                 //弹出当前队头

                   Q.push(x);               //把x放入队尾

                   x=Q.front();              //取出这时候队头的值

                   printf("%d\n",x);          //输出x

                   Q.pop();                 //弹出这时候的队头

         }

做取出队头的值操作的时候，并不弹出当前队头。

小明同学发现，这段程序恰好按顺序输出了1,2,3,...,n。现在小明想让你构造出原始的队列，你能做到吗？

输入

第一行一个整数T（T<=100）表示数据组数，每组数据输入一个数n（1<=n<=100000），输入的所有n之和不超过200000。

输出

对于每组数据，输出一行，表示原始的队列。数字之间用一个空格隔开，不要在行末输出多余的空格。


样例输入

4

1

2  

5

10

样例输出

1

2 1

2 1 3

8 1 6 2 10 3 7 4 9 5

二、思路：

根据题目的意思，可以理解为，

1）第一次从数组中的第二个数开始隔空取数字，一直到数组的末位；

2）当上次取的最后一个数恰好是数组的最后一个数的时候，这次从剩下的数组中也是按照1）中取数据的方式取数据，从第二个数据开始隔空取，一直到数组末位；

3）当上次取的最后一盒数是数组的倒数第二个数的时候，则在上次取剩下的数据的第一个数据开始隔空取数据；

4）当数组中的数据不为空时，依次循环上面的1）、2）或1）、3）

于此同时，用stackstatus记录每一轮取数据是从第一位数开始隔空取还是从第二位开始隔空取，如果是第一位开始，则status记为1，否则，记为0；

用stackNum来记录每一轮取出的数据的个数；

接下来是构造原始的数据队列，假设输出来的数组为que

1）从stackNum中弹出一个数num1,接着从que的末位去处num1个数一次存入int[num1] que1中，从stackStatus中弹出status1;

2）从stackNum中弹出一个数num2,接着从que的末位去处num2个数一次存入int[num2] que2中，从stackStatus中弹出status2;

3)int[num1+num2] que3,如果status2=1,则从que2开始，轮流从que2、que1中取出一个数存入que3;如果status2=0,则从que1开始，轮流从que1、que2中取出一个数存入que3;

4）que1=que3,num1=que3.length;

5)stackNum栈不为空时，一次重复上面的2）、3）、4）

最后得到的que1就是所要求的队列

三、代码

import java.util.*;

public class Main {
    public static void statusAndNum(int n)
    {
        int n1=n;
        Stack<Integer> stackStatus=new Stack<Integer>();
        Stack<Integer> stackNum=new Stack<Integer>();
        int num=0 ;
        int k=0;
        int status=0;
        while(n>1) {
            if (k == n||k==0) {
                status = 0;
                stackStatus.push(status);
                n = n - num;
                num = 1;
                k = 2;
                while (k<n-1) {
                    k += 2;
                    num++;

                }
                stackNum.push(num);
            } else {
                status = 1;
                stackStatus.push(status);
                n = n - num;
                num = 1;
                k = 1;
                while (k < n-1) {
                    k += 2;
                    num++;
                }
                stackNum.push(num);
            }
        }
        queueOrder(stackStatus,stackNum,n1);
    }
    public static void queueOrder(Stack<Integer> stackStatus,Stack<Integer> stackNum,int n)
    {
        int[] que=new int[n];
        for(int i=0;i<n;i++)
        {
            que[i]=i+1;
        }
        int num1,num2;
        num1=stackNum.pop();
        int[] que1=new int[num1];
        int i,j;
        int quePos=que.length-num1;
        for(i=que.length-num1,j=0;j<num1;i++,j++)
        {
           que1[j]=que[i];
        }
        int status1=stackStatus.pop();
        while(!stackNum.empty())
        {
            num2=stackNum.pop();
            int[] que2=new int[num2];
            int[] que3=new int[num2+num1];
            quePos=quePos-num2;
            for(i=quePos,j=0;j<num2;j++,i++)
            {
                que2[j]=que[i];
            }
            int status2=stackStatus.pop();
            if(status2>0)
            {

                int indexStr1=0,indexStr2=0,indexStr3=0;
                while(indexStr1<num1&&indexStr2<num2) {
                    que3[indexStr3++] = que2[indexStr2];
                    que3[indexStr3++] = que1[indexStr1];
                    indexStr1++;
                    indexStr2++;
                }
                if(indexStr1<num1)
                {
                    que3[indexStr3++] = que1[indexStr1];
                    indexStr1++;
                }
                if(indexStr2<num2)
                {
                    que3[indexStr3++] = que2[indexStr2];
                    indexStr2++;
                }
            }
            else
            {
                int indexStr1=0,indexStr2=0,indexStr3=0;
                while(indexStr1<num1&&indexStr2<num2) {
                    que3[indexStr3++] = que1[indexStr1];
                    que3[indexStr3++] = que2[indexStr2];
                    indexStr1++;
                    indexStr2++;
                }
                if(indexStr1<num1)
                {
                    que3[indexStr3++] = que1[indexStr1];
                    indexStr1++;
                }
                if(indexStr2<num2)
                {
                    que3[indexStr3++] = que2[indexStr2];
                    indexStr2++;
                }
            }
            que1=que3;
            num1=que1.length;
        }
        for(int reltI=0;reltI<n;reltI++)
        {
            System.out.print(que1[reltI]+" ");
        }
    }
    public static void main(String args[])
    {
        Scanner cin = new Scanner(System.in);
        int c=cin.nextInt();
        int num;
        while(c>0)
        {
            num=cin.nextInt();
            statusAndNum(num);
            c--;
        }
    }
}


说说互联网的那些事
关注
专栏目录
网易2021校招笔试-测试开发工程师
cxm3595的博客
08-14 487
题目一：小易得到了一个仅包含大小写英文字符的字符串，该字符串可能不是回文串（“回文串”是一个正读和反读都一样的字符串，比如”level”或者”noon”等等就是回文串，”asds”就不是回文串。） 小易可以在字符串尾部加入任意数量的任意字符，使其字符串变成回文串。 现在请你编写一个程序，程序要能计算出小易可以得到的最短回文串 输入描述：一行包括一个字符串s，1<=|s|<=10^3 输出描述：一行包括一个字符串，代表答案 示例1： 输入： noon 输出： noon 示例2： 输入： n
【2021网易游戏-游戏测试开发实习生面经】笔试+一面+二面+HR面
Borrr的博客
12-11 3746
引言：找实习准备了蛮久了吧，从年前就开始准备简历，年后就开始投简历，一百多家公司，基本上跟互联网沾边的都投了，然后每天坚持刷题，刷面经，写博客，很辛苦，很累，期间也面了大概有十几家，拿了几个小的，但是一直没放弃，不断笔试面试，今天总算是上岸了！！！ 4.1投的网易互娱，4.11笔试，4.17一面，4.28二面，5.11HR面 笔试大概只记得两道了，一共五道，我刚好这两道A过了，其他的都是三四十几的用例。 第一道是：巅峰选拔赛(不难) 第二道是：升级技能牌(中等) 一面(一小时二十五分钟)： 1.魔鬼一面，一
网易最新的笔试题大集合
10-24
网易笔试题大集合，集多份笔试题，好不容易收集到的，对笔试很有帮助
网易公司的软件测试师在线笔试,网易网站测试工程师笔试题目分享
weixin_26789847的博客
07-22 769
导读：这是我考过的最high的一次笔试了，笔试题，欢迎参考阅读。霸笔，晚进场半小时，从四楼打算走人的时候在二楼又混进了一个考场，最后一份测试试卷。不多，一页纸，两面未满。写了一个小时搞定。题我都能记下来了……1.编程：费不垃圾数列，f(0) = 0, f(1) = 1, f(n) = f(n-1) + f(n-2) n>1。给定n，求f(n)，要求越快越好。好吧，现在想想，我没有考虑到返回值...
网易测试笔试
qq_40088702的博客
03-16 733
1、 时间限制：1秒 空间限制：32768K 牛牛去犇犇老师家补课，出门的时候面向北方，但是现在他迷路了。虽然他手里有一张地图，但是他需要知道自己面向哪个方向，请你帮帮他。 输入描述: 每个输入包含一个测试用例。每个测试用例的第一行包含一个正整数，表示转方向的次数N(N&lt;=1000)。接下来的一行包含一个长度为N的字符串，由L和R组成，L表示向左转，R表示向右转。 输出描述: ...
2016年7月网易测试工程师笔试+面试（交友事业部）
weixin_30641999的博客
09-07 139
一． 选择题（2*10） 白盒测试静态测试使用的方法包括哪些？ 给出了一个数据流图让计算环形复杂度 Linux中的，kill – 9表示的意义 黑盒测试中各方法的不同点 8位二进制数，采用补码形式，会产生溢出的是哪个？ 软件质量的定义正确地是？ 逻辑表达式（A&&B||C）要设计几组测试用例？ 给出了一段代码问至少要设计几组测试用例，能够实现判定测试。 不记...
网易测试开发岗笔试题目
qq_37344615的博客
05-08 599
2道问答 1.尽可能多的为淘宝搜索商品功能设计测试用例 2.尽可能多的描述web 测试与 app测试的区别 4道编程题 (1)返回字符串的最长回文串的长度，且此回文串不包含给定字符集C里的字符 输入：abbaxaca [b,x] 输出：3 解释: aca (2)输入非负整数c, 若存在整数a,b 使得，返回max{a,b} (3)类似于leetCode直方图的水量，返回能储水的最小水量 (4)某公司招实习生，一人可投多岗，一岗只招一人，输入投递信息，输出最多有多少个..
求职资料-求职经验分享-笔试真题--网易.pdf
12-08
在应聘网易的过程中，笔试环节是必不可少的一环，以下是网易不同岗位的笔试情况： 1. **电商运营笔试**：通常涉及市场分析、营销策略、数据解读等方面的问题，考察应聘者的商业敏感度和逻辑分析能力。 2. **PM...
网易java笔试题目-iOS-Resources:iOS-资源
06-20
网易java笔试题目精选的 iOS 框架、库、教程、Xcode 插件、组件等等。 该列表分为框架、组件、测试等类别、开源项目、免费和付费服务。 每个类别中的项目没有预先确定的顺序，顺序是为了贡献。 如果你想贡献，请阅读...
网易校招面试笔试题
03-19
【标题】"网易校招面试笔试题"涵盖了网易公司在招聘过程中对候选人的技术与非技术能力的考察。作为中国互联网巨头之一，网易对于应聘者的选拔非常严谨，面试笔试环节是评估候选人是否具备所需技能和潜力的重要阶段。...
网易测试开发工程师笔试体会（秋招）
11-13
网易测试开发工程师笔试体会（秋招）
网易软测实习笔试总结
m0_37841960的博客
03-31 594
投的是软件测试岗——题型：20选择+2简答题+3编程题（两个小时的时间完全不够，不够！！！！！）      发现基础不够，对于树的节点，度概念话不清晰，HTTP的协议，进程的相关知识等还要好好补充选择题知识点：1.       进程死锁2.       HTTP1.0与HTTP1.1的区别3.       HTTP协议的304，header的后缀，参数ecoder，等4.       用到贪心算法...
【笔试记录】2020.9.12 网易互联网 测试开发工程师
weixin_37821353的博客
09-12 389
题目类型：4道编程+2道问答 编程1：特征组合 题目描述：给定若干个特征，要求你将特征进行组合，一定要注意组合的顺序。（类似于全排列） 题目输入： 3 man woman coder gamer painter phd 要求输出： man-coder-phd woman-coder-phd man-gamer-phd woman-gamer-phd man-painter-phd woman-painter-phd import java.util.*; public class Test1 {
网易笔试2019.8.3
CourageKang的博客
08-04 164
作者：NotDeep 链接：https://www.nowcoder.com/discuss/216237 来源：牛客网 最大公约数 思路 gcd(a,b) = gcd(b , a %b)gcd(a,b)=gcd(b,a%b)，这是欧几里得算法。那我们只要实现a % ba的计算。 a % ba可以直接在输入的时候维护（详见代码）。 #include<bits/stdc++.h> usi...
网易2018测试实习生笔试题记录
来自外星系的研究生
07-06 3705
1、linux系统中有如下cron任务：      20,40 */3 * * 1 sh test.sh 解析字段含义字段解析：每项工作有六个字段分别是：分钟 小时 日期 月份 周 指令0-59 0-23 1-31 1-12 0-7 指令 #0和7都代表星期天辅助特殊字符：* （星号）代表任何时刻，（逗号）代表分隔时候。如20分40分 就是20,40-（减号）代表一段时间范围内。如：3点到6点 就...
网易2018测试开发实习生笔试题记录
来自外星系的研究生
07-11 3990
一、选择题1. 关于随机测试，以下哪一项说明是正确的？随机测试是根据测试的经验在无测试用例的情况下进行的测试。随机测试也是需要写一定的测试用例，但可以用例中没有的测试点。随机测试不会产生测试冗余。随机测试是程序员自已开发时候进行的测试。2. 在对某支持语音聊天的SDK进行利用并二次开发后，关于语音功能的测试用例下列哪项是错误的？语音聊天功能的测试用例里，应该考虑语音请求发送的测试发送音频功能的测试...
网易2019测试开发笔试编程第一题（小易俄罗斯方块）
summer的博客
08-11 2251
题目描述 小易有一个古老的游戏机，上面有着经典的游戏俄罗斯方块。因为它比较古老，所以规则和一般的俄罗斯方块不同。荧幕上一共有n列，每次都会有一个1x 1的方块随机落下，在同一列中，后落下的方块会叠在先前的方块之上，当一整行方块都被占满时，这一行会被消去，并得到1分。有一天，小易又开了一一局游戏，当玩到第m个方块落下时他觉得太无聊就关掉了，小易希望你告诉他这局游戏他获得的分数。 输入描述: 第...
2017年网易测试开发实习生笔试题
sinat_35803474的博客
03-25 4857
15道单选，5道多选，3道编程，1道问答 （*有些选择题我没记选项。。。有些题是没记下来，反正大家看看，知道考点是什么就好啦） 1.16位又符合整型的数据范围是？ A.0-65536 B.-32768-32767 C.-2147483648-3147483647 D.0-4294967295 2.排序算法中是分治思想的是哪个 A.快速排序 B.基数排序 C.插入排序 D.冒泡排
网易2020测试开发实习生笔试题--做自闭了
小新的小白的博客
04-07 1597
网易2020测试开发实习生笔试题 只有题，没答案，我也不会 刚刚做完笔试题（没有做完，把我做自闭了），这是第二次笔试，本来时间是19：00-21：00，我知道再给我一年时间我也做不出来他那个题。 一看是看介绍挺开心的，没有编程题。结果，编程题四个，问答题也相当于两个编程题。下面我说说我记得得题。 **选择题**10个 第一个题记得听清楚的，因为上来第一个就不会，关于HTTP/2不正确的？ A、增...
网易笔试题集：游戏测试与营销篇
"这篇资料汇总了2010年网易公司的笔试题目，涵盖了游戏测试工程师、营销等多个职位的笔试内容，旨在帮助应聘者准备网易的面试。内容包括技术类问题、数学题、游戏类问题、简答题以及逻辑推理题等。" 在2010年的网易...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值