【网易】2018内推编程题集合

一共八道题，前五道独立完成，较为简单，后三道没有独立完成。

[编程题]彩色的砖块
小易有一些彩色的砖块。每种颜色由一个大写字母表示。各个颜色砖块看起来都完全一样。现在有一个给定的字符串s,s中每个字符代表小易的某个砖块的颜色。小易想把他所有的砖块排成一行。如果最多存在一对不同颜色的相邻砖块,那么这行砖块就很漂亮的。请你帮助小易计算有多少种方式将他所有砖块排成漂亮的一行。(如果两种方式所对应的砖块颜色序列是相同的,那么认为这两种方式是一样的。)
例如: s = "ABAB",那么小易有六种排列的结果:
"AABB","ABAB","ABBA","BAAB","BABA","BBAA"
其中只有"AABB"和"BBAA"满足最多只有一对不同颜色的相邻砖块。

输入描述:

输入包括一个字符串s,字符串s的长度length(1 ≤ length ≤ 50),s中的每一个字符都为一个大写字母(A到Z)。

 

输出描述:

输出一个整数,表示小易可以有多少种方式。

示例1

输入

ABAB

输出

2

简单题，只能一种颜色或者两种颜色

import java.util.Scanner;
 
public class Main {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner scanner = new Scanner(System.in);
        String zhuan = scanner.nextLine();
        char[] array = zhuan.toCharArray();
 
        int[] count = new int[255];
        for (int i = 0; i < array.length; i++) {
            count[(int) array[i]]++;
        }
        int type = 0;
        for (int i = 0; i < count.length; i++) {
            if (count[i] != 0) {
                type++;
            }
        }
        // 计算个数，如果超过两种颜色，应该就是不符合了
        if (type > 2) {
            System.out.println(0);
            return;
        }
        // 一种颜色就一种
        if (type == 1) {
            System.out.println(1);
            return;
        }
        // 如果一种颜色的块数是1，那么符合要求的个数就是array数组的长度（zhuan的长度）
        // 如果没有颜色块数为1的，那么就是两种，AABB和BBAA
        if (type == 2) {
            for (int i = 0; i < count.length; i++) {
                if (count[i] == 1) {
                    System.out.println(array.length);
                    return;
                } else {
                    System.out.println(2);
                    return;
                }
            }
        }
    }
}

[编程题]等差数列
如果一个数列S满足对于所有的合法的i,都有S[i + 1] = S[i] + d, 这里的d也可以是负数和零,我们就称数列S为等差数列。
小易现在有一个长度为n的数列x,小易想把x变为一个等差数列。小易允许在数列上做交换任意两个位置的数值的操作,并且交换操作允许交换多次。但是有些数列通过交换还是不能变成等差数列,小易需要判别一个数列是否能通过交换操作变成等差数列

输入描述:

输入包括两行,第一行包含整数n(2 ≤ n ≤ 50),即数列的长度。
第二行n个元素x[i](0 ≤ x[i] ≤ 1000),即数列中的每个整数。

 

输出描述:

如果可以变成等差数列输出"Possible",否则输出"Impossible"。

示例1

输入

3
3 1 2

输出

Possible

简单，排序之后判断每两个相差是否相等

import java.util.Arrays;
import java.util.Scanner;
 
public class Main {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner scanner = new Scanner(System.in);
        int length=scanner.nextInt();
        int []list=new int [length];
        for(int i=0;i<length;i++){
            list[i]=scanner.nextInt();
        }
        Arrays.sort(list);
        if(length<=2){
            System.out.println("Possible");
            return;
        }else{
            int d=list[1]-list[0];
            for(int i=1;i<list.length-1;i++){
                if(list[i+1]-list[i]!=d){
                    System.out.println("Impossible");
                    return;
                }
            }
            System.out.println("Possible");
        }
         
         
    }
}

[编程题]交错01串

如果一个01串任意两个相邻位置的字符都是不一样的,我们就叫这个01串为交错01串。例如: "1","10101","0101010"都是交错01串。
小易现在有一个01串s,小易想找出一个最长的连续子串,并且这个子串是一个交错01串。小易需要你帮帮忙求出最长的这样的子串的长度是多少。

输入描述:

输入包括字符串s,s的长度length(1 ≤ length ≤ 50),字符串中只包含'0'和'1'

 

输出描述:

输出一个整数,表示最长的满足要求的子串长度。

示例1

输入

111101111

输出

3

简单，两个指针，一个指向子串开始，一个指向需要子串的结束

import java.util.Scanner;
 
public class Main {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner scanner = new Scanner(System.in);
        String str=scanner.nextLine();
        char []arr=str.toCharArray();
        int maxlength=Integer.MIN_VALUE;
        if(arr.length<2){
            System.out.println(0);
            return;
        }
        int start=0,end=0;
        int i=0,j=i+1;
        while(i<arr.length-1){
            if(arr[i+1]!=arr[i]){
                start=i;
            }
            //限制范围！！
            while(i<arr.length-1&&arr[i+1]!=arr[i]){
                end=i+1;
                i++;
            }
            maxlength=Math.max(maxlength, end-start+1);
            i++;
        }
         
        System.out.println(maxlength);
         
    }
}

[编程题]操作序列
小易有一个长度为n的整数序列,a_1,...,a_n。然后考虑在一个空序列b上进行n次以下操作:
1、将a_i放入b序列的末尾
2、逆置b序列
小易需要你计算输出操作n次之后的b序列。

输入描述:

输入包括两行,第一行包括一个整数n(2 ≤ n ≤ 2*10^5),即序列的长度。
第二行包括n个整数a_i(1 ≤ a_i ≤ 10^9),即序列a中的每个整数,以空格分割。

 

输出描述:

在一行中输出操作n次之后的b序列,以空格分割,行末无空格。

示例1

输入

4
1 2 3 4

输出

4 2 1 3

这是一个找规律的题

n	原始序列	最后序列
3	1 2 3	3 1 2
4	1 2 3 4	4 2 1 3
4	1 3 5 9	9 3 1 5
5	1 2 3 4 5	5 3 1 2 4

import java.util.ArrayList;
import java.util.Scanner;
 
public class Main {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner scanner = new Scanner(System.in);
        int num=scanner.nextInt();
        int []orgin=new int[num];
        for(int i=0;i<num;i++){
            orgin[i]=scanner.nextInt();
        }
        ArrayList<Integer>list=new ArrayList<>();
        for(int i=num-1;i>=0;i=i-2){
            list.add(orgin[i]);
        }
        //奇数偶数起点不同
        if(num%2==0){
            for(int i=0;i<num;i=i+2){
                list.add(orgin[i]);
            }
        }else{
            for(int i=1;i<num;i=i+2){
                list.add(orgin[i]);
            }
        }
        for(int i=0;i<list.size()-1;i++){
            System.out.print(list.get(i)+" ");
        }
        System.out.println(list.get(list.size()-1));
    }
}

[编程题]独立的小易
小易为了向他的父母表现他已经长大独立了,他决定搬出去自己居住一段时间。一个人生活增加了许多花费: 小易每天必须吃一个水果并且需要每天支付x元的房屋租金。当前小易手中已经有f个水果和d元钱,小易也能去商店购买一些水果,商店每个水果售卖p元。小易为了表现他独立生活的能力,希望能独立生活的时间越长越好,小易希望你来帮他计算一下他最多能独立生活多少天。

输入描述:

输入包括一行,四个整数x, f, d, p(1 ≤ x,f,d,p ≤ 2 * 10^9),以空格分割

 

输出描述:

输出一个整数, 表示小易最多能独立生活多少天。

示例1

输入

3 5 100 10

输出

11

简单的题

import java.util.Scanner;
 
public class Main {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner scanner = new Scanner(System.in);
        //x：房租；f：已经持有的水果数；d：一共多少钱；p：一个水果多少钱
        int x=scanner.nextInt();
        int f=scanner.nextInt();
        int d=scanner.nextInt();
        int p=scanner.nextInt();
        int date=0;
        if(d-x*f>0){
            date=(d-x*f)/(p+x)+f;
        }else{
            date=d/x;
        }
        System.out.println(date);
    }
}

[编程题]堆棋子
小易将n个棋子摆放在一张无限大的棋盘上。第i个棋子放在第x[i]行y[i]列。同一个格子允许放置多个棋子。每一次操作小易可以把一个棋子拿起并将其移动到原格子的上、下、左、右的任意一个格子中。小易想知道要让棋盘上出现有一个格子中至少有i(1 ≤ i ≤ n)个棋子所需要的最少操作次数.
 

输入描述:

输入包括三行,第一行一个整数n(1 ≤ n ≤ 50),表示棋子的个数
第二行为n个棋子的横坐标x[i](1 ≤ x[i] ≤ 10^9)
第三行为n个棋子的纵坐标y[i](1 ≤ y[i] ≤ 10^9)

 

输出描述:

输出n个整数,第i个表示棋盘上有一个格子至少有i个棋子所需要的操作数,以空格分割。行末无空格

如样例所示:
对于1个棋子: 不需要操作
对于2个棋子: 将前两个棋子放在(1, 1)中
对于3个棋子: 将前三个棋子放在(2, 1)中
对于4个棋子: 将所有棋子都放在(3, 1)中

示例1

输入

4
1 2 4 9
1 1 1 1

输出

0 1 3 10

看了牛客网上大神的解法，还是有点懵，要常看

应该是穷举法，去掉每个，计算距离

import java.util.*;
 
public class Main {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            int n = scanner.nextInt();
            int[] x = new int[n];
            int[] y = new int[n];
            for (int i = 0; i < n; i++) {
                x[i] = scanner.nextInt();
            }
            for (int i = 0; i < n; i++) {
                y[i] = scanner.nextInt();
            }
            List<Long> res = new ArrayList<Long>();
            long min, sum;
            for (int i = 1; i <= n; i++) {
                min = Long.MAX_VALUE;
                for (int row = 0; row < n; row++) {
                    for (int col = 0; col < n; col++) {
                        sum = 0;
                        PriorityQueue<Integer> pq = new PriorityQueue<>(i, new Comparator<Integer>() {
 
                            @Override
                            public int compare(Integer o1, Integer o2) {
                                // TODO Auto-generated method stub
                                return o2 - o1;
                            }
 
                        });
                        for (int c = 0; c < n; c++) {
                            int xc = x[c];
                            int yc = y[c];
                            int distance = Math.abs(xc - x[row]) + Math.abs(yc - y[col]);
                            sum += distance;
                            pq.add(distance);
                            if (pq.size() > i) {
                                sum -= pq.poll();
                            }
                        }
                        min = Math.min(min, sum);
                    }
                }
                res.add(min);
            }
            for (int i = 0; i < n - 1; i++)
                System.out.print(res.get(i) + " ");
            System.out.println(res.get(n - 1));
        }
 
    }
}

[编程题]疯狂队列
小易老师是非常严厉的,它会要求所有学生在进入教室前都排成一列,并且他要求学生按照身高不递减的顺序排列。有一次,n个学生在列队的时候,小易老师正好去卫生间了。学生们终于有机会反击了,于是学生们决定来一次疯狂的队列,他们定义一个队列的疯狂值为每对相邻排列学生身高差的绝对值总和。由于按照身高顺序排列的队列的疯狂值是最小的,他们当然决定按照疯狂值最大的顺序来进行列队。现在给出n个学生的身高,请计算出这些学生列队的最大可能的疯狂值。小易老师回来一定会气得半死。

输入描述:

输入包括两行,第一行一个整数n(1 ≤ n ≤ 50),表示学生的人数
第二行为n个整数h[i](1 ≤ h[i] ≤ 1000),表示每个学生的身高

 

输出描述:

输出一个整数,表示n个学生列队可以获得的最大的疯狂值。

如样例所示: 
当队列排列顺序是: 25-10-40-5-25, 身高差绝对值的总和为15+30+35+20=100。
这是最大的疯狂值了。

示例1

输入

5
5 10 25 40 25

输出

100

大的和小的挨着，应该会的题，加油

import java.util.Arrays;
import java.util.Scanner;
 
public class Main {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();
        int[] tall = new int[num];
        for (int i = 0; i < num; i++) {
            tall[i] = scanner.nextInt();
        }
        Arrays.sort(tall);
        // 记录最小值和最大值
        int min = tall[0];
        int max = tall[num - 1];
        int diff = max - min;
        int minIndex = 1;
        int maxIndex = num - 2;
        while (minIndex < maxIndex) {
            diff += max - tall[minIndex];
            diff += tall[maxIndex] - min;
            min = tall[minIndex++];
            max = tall[maxIndex--];
        }
 
        // 原数列中最后一个数 minIndex == maxIndex，将它放到合适的位置上
        diff += Math.max(tall[maxIndex] - min, max - tall[minIndex]);
        System.out.println(diff);
 
    }
}

[编程题]小易喜欢的数列
数列的长度为n
2、数列中的每个数都在1到k之间(包括1和k)
3、对于位置相邻的两个数A和B(A在B前),都满足(A <= B)或(A mod B != 0)(满足其一即可)
例如,当n = 4, k = 7
那么{1,7,7,2},它的长度是4,所有数字也在1到7范围内,并且满足第三条性质,所以小易是喜欢这个数列的
但是小易不喜欢{4,4,4,2}这个数列。小易给出n和k,希望你能帮他求出有多少个是他会喜欢的数列。

输入描述:

输入包括两个整数n和k(1 ≤ n ≤ 10, 1 ≤ k ≤ 10^5)

 

输出描述:

输出一个整数,即满足要求的数列个数,因为答案可能很大,输出对1,000,000,007取模的结果。

示例1

输入

2 2

输出

3

动态规划，参考了大神的解法，继续懵。

先把所有情况求出来，再减去不符合情况的。

import java.util.*;
 
public class Main {
    private static final int MOD = 1000000007;
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        while(scanner.hasNext()){
            int n=scanner.nextInt();
            int k=scanner.nextInt();
            int [][]dp=new int[n+1][k+1];
            dp[0][1]=1;
            for(int i=1;i<=n;i++){
                int sum=0;
                //所有情况
                for(int j=1;j<=k;j++){
                    sum=(sum+dp[i-1][j])%MOD;
                }
                 
                for(int j=1;j<=k;j++){
                    //去除不符合条件的情况
                    int invalid=0;
                    int p=2;
                    while(p*j<=k){
                        invalid=(invalid+dp[i-1][p*j])%MOD;
                        p++;
                    }
                    dp[i][j]=(sum-invalid)%MOD;
                }
            }
            int sum=0;
            for(int i=1;i<=k;i++){
                sum=(sum+dp[n][i])%MOD;
            }
            System.out.println(sum);
        }
         
 
    }
}