2018网易测试开发编程题

编程题：

1、小易有一个古老的游戏机，上面有着经典的游戏俄罗斯方块。因为它比较古老，所以规则和一般的俄罗斯方块不同。
荧幕上一共有 n 列，每次都会有一个 1 x 1 的方块随机落下，在同一列中，后落下的方块会叠在先前的方块之上，当一整行方块都被占满时，这一行会被消去，并得到1分。
有一天，小易又开了一局游戏，当玩到第 m 个方块落下时他觉得太无聊就关掉了，小易希望你告诉他这局游戏他获得的分数。

输入描述：

第一行两个数 n,m

第二行m个数表示第i个方块落在第几列

输出描述：小容易这局游戏的分数

输入例子1：

3 9

1 1 2 2 2 3 1 2 3

输出例子1：2

import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;

public class Test1 {

    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int[] col = new int[m];
        for(int i=0; i < m; i++){
            col[i] = sc.nextInt();
        }
        
        System.out.println(computeScore(n,m,col));
    }
    
    public static int computeScore(int n, int m, int[] col){
        
        HashMap<Integer,Integer> hashMap = new HashMap<>();
        
        for(int i = 0; i < m; i++){
            if (hashMap.containsKey(col[i])){
                int count = hashMap.get(col[i]);
                hashMap.put(col[i], ++count);    
            }
            else{
                hashMap.put(col[i], 1);
            }
        }
        if(hashMap.size()<n){
            return 0;
        }
        Set<Integer> set = hashMap.keySet();
        int result = m;
        for(Integer s: set){
            if(hashMap.get(s) <result){
                result = hashMap.get(s);
            }
        }
        return result;
    }
}

2、小易觉得高数课太无聊了，决定睡觉。不过他对课上的一些内容挺感兴趣，所以希望你在老师讲到有趣的部分的时候叫醒他一下。你知道了小易对一堂课每分钟知识点的感兴趣程度，并以分数量化，以及他在这堂课上每分钟是否会睡着，你可以叫醒他一次，这会使得他在接下来的k分钟内保持清醒。你需要选择一种方案最大化小易这堂课听到的知识点分值。

输入描述：第一行 n, k。表示这堂课持续多少分钟，以及叫醒小易一次使他能够保持清醒的时间

第二行n 个数表示小易对每分钟知识点的感兴趣评分。

第三行 n 个数，表示每分钟小易是否清醒, 1表示清醒。

输出描述：小易这堂课听到的知识点的最大兴趣值。

输出例子1：

6 3

1 3 5 2 5 4

1 1 0 1 0 0

输出例子：

16

import java.util.Scanner;
import static java.lang.Math.max;

public class Test2 {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int time = sc.nextInt();
        int wake = sc.nextInt();
        int[] inte = new int[time];
        int[] isawake = new int[time];
        for(int i = 0; i < time; i++){
            inte[i] = sc.nextInt();
        }
        for(int i = 0; i < time; i++){
            isawake[i] = sc.nextInt();
        }
        
        System.out.println(maxScore(time,wake,inte,isawake));
    }
    
    public static int maxScore(int time, int wake, int[] inte, int[] isawake){
        int sum = 0;
        for(int i =0 ; i < time; i++){
            if(isawake[i]==1){
                sum += inte[i];
                inte[i] = 0;
            }
        }
        int s = 0;
        for(int j = 0; j < wake; j++){
            s += inte[j];
        }
        int ans = s;
        for(int i =0;i+wake<time;i++){
            s -= inte[i];
            s += inte[i+wake];
            ans=max(ans,s);
        }
        return ans+sum;
    }

}

3、牛牛常说他对整个果园的每个地方都了如指掌，小易不太相信，所以他想考考牛牛。
在果园里有N堆苹果，每堆苹果的数量为a_i，小易希望知道从左往右数第x个苹果是属于哪一堆的。
牛牛觉得这个问题太简单，所以希望你来替他回答。

输入描述：

第一行一个数n

第二行n个数a表示从左往右数第i堆有多少苹果

第三行一个数m表示有m次询问。

第四行m个数表示小易希望知道第q个苹果属于哪一堆

输出描述：m行，第i行输出第q个苹果属于哪一堆。

输入例子1：

5

2 7 3 4 9

3

1 25 11

输出例子1：

1

5

3

import java.util.HashMap;
import java.util.Scanner;

public class Test3 {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String[] get = new String[4];
        for(int i = 0; i < 4; i++){
            get[i] = sc.nextLine();
        }
        long duishui = Integer.valueOf(get[0]);
        String[] a = get[1].split(" ");
        long xunwen = Integer.valueOf(get[2]);
        String[] question = get[3].split(" ");

        for(int i = 0; i < xunwen; i++){
            String string = question[i];
            getAns(duishui,a,string);
        }
    }
    private static void getAns(long n, String[] a, String string) {
        HashMap<String, Integer> map = new HashMap<>();
        int count = 0;
        if(map.containsKey(string)){
            System.out.println(map.get(string));
        }
        else{
            for(int i = 0; i < n; i++){
                count = count + Integer.valueOf(a[i]);
                if(Integer.valueOf(string) <= count){
                    System.out.println(i+1);
                    map.put(string, i+1);
                    break;        
                }
            }
        }

    }
}

问答题：

1、给出一个包含26个小写英文字母的字符串（不超过15个字符），输出所有按字母顺序递增的子字符串，子串至少包含2个字符，输出子串不能重复

输入：acdd

输出：ac,ad,acd,acdd,cd,cdd,dd

import java.util.*;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class Test4 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.next();
        String result = subsequences(str);

        Set<String> set = new HashSet<>();
        String[] arr = result.split(",");
        List<String> list = new ArrayList<>();
        for (String s : arr) {
            if (s.length() >= 2) {
                set.add(s);
            }
        }
        for (String tmp : set) {
            list.add(tmp);
        }
        Collections.sort(list);
        for (int i = 0; i < list.size() - 1; i++)
            System.out.print(list.get(i) + ",");
        System.out.println(list.get(list.size() - 1));
    }

    public static String subsequences(String word) {
        if (word.isEmpty()) {
            return "";
        } else {
            char firstLetter = word.charAt(0);
            String restOfWord = word.substring(1);
            System.out.println(restOfWord);

            String subsequencesOfRest = subsequences(restOfWord);

            String result = "";
            for (String subsequence : subsequencesOfRest.split(",", -1)) {
                result += "," + subsequence;
                result += "," + firstLetter + subsequence;
            }
            result = result.substring(1); // remove extra leading comma
            return result;
        }
    }

}