秋招算法笔试题汇总

题一：

你需要编写一个程序来模拟目录的操作，一开始，你在根目录"\"，一共有两种命令：

● cd s: s为一个目录名，表示从当前工作目录的路径进入名为s的目录。特别地，"cd .."(即s=="..")表示返回上一级目录，若当前已为根目录，则无视该次操作。数据保证若s不为".."，则一定为小写字母组成的长度不超过10的字符串。

● pwd: 表示查看当前工作目录的路径，你需要输出这个路径。

输入描述
第一个行是一个整数n，表示一共会有n个操作。

接下来每行是一条命令，命令的种类为问题描述中的二种之一。

注意，测试用例中cd s的操作，中间有空格。

输出描述
对于每个"pwd"命令，你需要单行输出当前的工作路径。

样例输入

7
cd a
cd b
pwd
cd ..
pwd
cd ..
pwd

样例输出

\a\b
\a
\

提示
1<=n<=300

代码

public class a1 {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int n = Integer.valueOf(cin.nextLine());
        List<String> list = new ArrayList<>();
        int k=0;
        while(n>0){
            String s = cin.nextLine();
            if(s.charAt(0)=='c'&&s.charAt(1)=='d'){
                String s2 = s.split(" ")[1];
                if("..".equals(s2)){
                    if(k>0){
                        list.remove(k-1);
                        k--;

                    }
                }else{
                    k++;
                    list.add("\\"+s2);
                }
            }else{
                for(int i=0;i<k;i++){
                    System.out.print(list.get(i));
                }
                if(k==0){
                    System.out.print("\\");
                }
                System.out.println();
            }
            n--;
        }
    }
}

题二：

对于一个整形数组，里边任何两个元素相加，小于M的组合有多少种，如果没有，返回0

代码

package kaoshi;
/*
* 对于一个整形数组，里边任何两个元素相加，小于M的组合有多少种，如果没有，返回0
* */
public class demo {

        public static int count(int a[], int m) {
            int count=0;
            for(int i=0;i<a.length;i++){
                for(int j=i+1;j<a.length;j++){
                    if((a[i]+a[j])<m){
                        count++;
                    }
                }
            }
            return count;
        }

    public static void main(String[] args) {
         int a[]={1,2,3,4};
        System.out.println(count(a,9));
    }
}

题三：

输入一个数组，表示孩子年龄，每个小朋友至少有一张纸，

当某个小朋友的年龄比相邻的大时，就多拿一张纸

代码

public class demo2 {
        public static void main(String[] args) {
            int a[]={4,4,5};
            int result=count(a);
            System.out.println(result);
        }

    public static int count(int a[]) {
        int i=0;
        int j=1;
        int count=0;
        while(j>a.length){
            if(a[j]>a[i]){
                count++;
                i++;
                j++;
            }else if(a[j]>a[j+1]){
                count++;
            }else{
                j++;
                i++;
            }
        }
        int counts=a.length+count;
        return counts;
    }
}

题四：

给定一个数组，找出中间值，使他两边的数的和相等

代码

import java.util.*;
public class m4{
    /*找一个中间值，使他两边的数的和相等*/
    public static void main(String []args){

        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int []array=new int[n];
        for(int i=0;i<n;i++){
            array[i]=sc.nextInt();
        }
        int result=mid(array);
        System.out.println(result);
    }
    public static int mid(int []array){
        int i=0;
        int j=array.length-1;
        int sum1=0;
        int sum2=0;
        while(sum1!=sum2||sum1==0)
        {
            sum1+=array[i];
            i++;
            while (sum1>sum2){
                sum2+=array[j];
                j--;
            }
        }
        return array[i+1];
    }
}

题五：

已知一个长度为n的序列A。我们求出了它的前缀序列，但是却不小心把它的原序列丢失了，请你从它的前缀序列中推出它的原序列，并输出出来。

这里的前缀序列B定义为，B[i]为所有下标小于等于i中的元素中，所有奇数位置的和减去所有偶数位置的和。A序列和B序列的下标均从1开始。

样例输入

4
1 -1 2 -2

样例输出

1 2 3 4

解析：  第一个数单独讨论，
       从第二个数开始，如果该数的在奇数位置i，则这个位置值用a[i]-a[i-1]替换
                    如果该数在偶数位置i，则这个位置的值用a[i-1]-a[i]替换

代码

public class m6{
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
       int n= sc.nextInt();
       int []a=new int[n];
       for(int i=0;i<n;i++){
           a[i]=sc.nextInt();
       }
       //索引是0,1,2,3
       for(int i=0;i<n;i++){
           if((i&1)==0)//(判断是否是奇数项)
           {
               if(i!=0)//如果是奇数项且不是第一个数
               {
                   System.out.print(" "+(a[i]-a[i-1]));
               }else {
                   System.out.print(a[i]);
               }
           }else {//(如果是偶数项)
               System.out.print(" "+(a[i-1]-a[i]));
           }
       }
    }
}

题六

一台机甲在一个二维空间里移动，它的移动受到一串事先写好的指令的控制，
每条指令会让它往特定方向移动一格。该空间为矩形，四周都是墙壁，无法通过，
空间中每个格子位置的阻力不同，我们用一个数值来表示它的阻力，还有一些格子存在障碍无法通过。
机器人每走一格，需要消耗能量，能量数为走之前和走之后位置的阻力数值中较大的那个数。
当它的方向改变时，消耗能量 x，当它走向墙壁或者障碍物时，会停在原地并消耗能量 y（如果需要，仍会先改变方向）。
一开始它位于整个空间的左上角，第一步移动不需要花能量改变方向，请计算它最后总共消耗了多少能量。
输入描述
    第一行四个整数 n, m, x, y，（0 < n, m <= 100，1 <= x, y <= 100000）

    后面 n 行，每行 m 个数，形成一个方阵，
    表示各个格子位置的阻力数值，如果为 -1，
    表示该位置无法通过。各个位置的数值范围为 [-1, 100000]。

    最后一行一个字符串，由 hjkl 四种字母组成，表示指令序列。
    h 表示向左移动一格，l 表示向右移动一格，
    k 表示向上移动一格，j 表示向下移动一格，字符串长度不超过 100000。

输出描述
一个整数，表示消耗的总能量。

样例输入

2 2 2 2
 1 2
-1 3
kjljk

样例输出

20

代码

public class m7 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String []s1=sc.nextLine().split(" ");
        int n=Integer.valueOf(s1[0]);//输入行数
        int m=Integer.valueOf(s1[1]);//输入列数
        int x=Integer.valueOf(s1[2]);//输入改变方向消耗的能量X
        int y=Integer.valueOf(s1[3]);//输入遇到障碍物时，停在原地消耗的能量Y
        int [][]a=new int[n][m];
        for(int i=0;i<n;i++){
            String []s2=sc.nextLine().split(" ");
            for(int j=0;j<m;j++){
                a[i][j]=Integer.valueOf(s2[j]);//输入方阵
                //System.out.println(a[i][j]);
            }
        }
        String s=sc.nextLine();
        int i=0,j=0;//  i是行  j是列
        char ch = s.charAt(0);//用来记录上一条指令方向
        int total=0;//记录消耗的能量
        for(char c:s.toCharArray())//遍历写好的指令方向
        {
            if(c!=ch)//如果指令方向不同则改变了方向 需要消耗能量
            {
                total+=x;
            }
            ch=c;//记录指令方向

            if(c=='k')//如果是向上指令
            {
                if (i - 1 < 0) //如果上边是墙的话
                {
                    total += y;//原地消耗能量
                } else {
                    //如果上边不是墙
                    if (a[i - 1][j] != -1)//判断是否有障碍物
                    {
                        i--;
                        //如果没有障碍物
                        //机器人每走一格，需要消耗能量，能量数为走之前和走之后位置的阻力数值中较大的那个数
                        total += Math.max(a[i][j], a[i + 1][j]);
                    } else {
                        total += y;//如果有障碍物，原地消耗能量
                    }
                }
            }
            else if(c=='j')//如果是向下指令
            {
                if (i + 1 >= n)//如果下边是墙的话
                {
                    total += y;//原地消耗能量
                } else {
                    if (a[i + 1][j] != -1) //判断是否有障碍物
                    {
                        i++;
                        //如果没有障碍物
                        //机器人每走一格，需要消耗能量，能量数为走之前和走之后位置的阻力数值中较大的那个数
                        total += Math.max(a[i][j], a[i - 1][j]);
                    } else {
                        total += y;//如果有障碍物，原地消耗能量
                    }
                }
            }
            else if(c=='h')//如果是向左的指令
            {
                if(j-1<0)//左边是墙
                {
                    total+=y;//原地消耗能量
                }else{
                    if(a[i][j-1]!=-1)//如果没有障碍物
                    {
                        j--;
                        //机器人每走一格，需要消耗能量，能量数为走之前和走之后位置的阻力数值中较大的那个数
                        total+=Math.max(a[i][j],a[i][j+1]);
                    }else {
                        total+=y;//如果有障碍物，原地消耗能量
                    }
                }
            }else {//如果是向右的指令
                    if(j+1>=m)//右边是墙
                    {
                        total+=y;//原地消耗能量
                    }else{
                        if(a[i][j+1]!=-1)//如果没有障碍物
                        {
                            j++;
                            //机器人每走一格，需要消耗能量，能量数为走之前和走之后位置的阻力数值中较大的那个数
                            total+=Math.max(a[i][j],a[i][j-1]);
                        }else {
                            total+=y;//如果有障碍物，原地消耗能量
                        }
                    }
            }
            //System.out.println(total);
        }
        System.out.println(total);
    }
}

题七

大哥在直播的时候经常被粉丝刁难。今天粉丝们在弹幕上问他的问题是：从公元a年1月到公元b年12月有多少个月份满足该月的第一天是星期一。大哥不会数数，所以装作掉线后找到了你来帮他答题，请你以最快的速度帮帮他。

输入描述
两个正整数满足1900<=a<=b<=2100

输出描述
输出公元a年1月到公元b年12月有多少个月份满足该月的第一天是星期一。


样例输入

2021 2021

样例输出

3

提示
2021年1月1日是星期五。2021年的二月，三月和十一月都满足条件。

代码

public class m8 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int a=sc.nextInt();
        int b=sc.nextInt();
        int k=0;
        for(int i=a;i<=b;i++){
            for(int j=1;j<=12;j++){
                String s = a+"-";
                if(j>9){
                    s+=j;
                }else{

                    s+="0"+j;
                }
                s+="-01";
                SimpleDateFormat time = new SimpleDateFormat("yyyy-MM-dd");
                Date d;
                try {
                    d = time.parse(s);
                    if(d.getDay()==1){
                        k++;
                    }
                } catch (ParseException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println(k);
    }
}
v

题八

小团每天都会走过一条路去上课。这条路旁种有丁香树，从左向右排成一排并编号为 1 … n。
 又是一年一度的丁香季，所有丁香都开花了，第 i 棵丁香树的芳香值为 ai。

小团要从第一棵丁香树走到最后一棵。
当走到第 i 棵丁香树时，如果这棵丁香树的芳香值比之前经过的 i - 1 棵丁香树中 x 棵的芳香值高，
她的 满意度就要加上那 x 棵丁香树的 不同的芳香值个数。

小团知道了这 n 棵丁香树的芳香值，她想知道走过这 n 棵丁香树后自己的满意度是多少。


输入描述
第一行一个正整数 n，为丁香树数目；

第二行 n 个数 ai，第 i 个数代表第 i 棵丁香树的芳香度。

对于 30% 的数据，n ≤ 100；

对于 100% 的数据，1 ≤ n ≤ 105, 1 ≤ ai ≤ 30。

输出描述
输出一行一个整数，表示小团的满意度。


样例输入

10
1 1 2 2 2 3 3 3 3 1

样例输出
11

提示
当走到第 3, 4, 5 棵丁香树时，因为它们的芳香值为 2，大于前两棵丁香树的芳香值 1，因为只有一种芳香值，所以经过 3, 4, 5 中的每棵树都会产生 1 的满意度，总满意度累计为 3；

当走到第 6, 7, 8, 9 棵丁香树时，因为它们的芳香值为 3，大于前面两种芳香值 1, 2，所以经过 6, 7, 8, 9 中的每棵树都会产生 2 的满意度，总满意度累计为 8；

综上，一共会产生 11 点满意度。

代码

public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int[] a = new int[31];//用来存芳香值的数组(芳香值0-31)
        int m = cin.nextInt();//m是丁香树的个数
        Arrays.fill(a,0);
        int n = 1;//初始芳香值
        int k=0;//统计满意度
        for (int i = 0; i < m; i++) {
            n=cin.nextInt();//n 是芳香值
            a[n]=1; //记录有此芳香值
            for(int j=1;j<n;j++)//题目的意思就是某个位置的满意度为前边比该芳香值小的有几种，就加几
            {
                if(a[j]==1)//说明存在此芳香值
                {
                    ++k;//满意度就加一
                }
            }
        }
        System.out.println(k);
}

题九

小美在整理她的书。

她有 n 本书要放，书架上也有 n 个位置可以放书。每本书都有一个厚度 ai，可以放书的每个位置都有一个宽度 bj。

小美不想让书折坏，因此只有在满足 ai ≤ bj 的情况下，第 i 本书才可以放到第 j 个位置，否则不可以放。

小美想知道有多少种放书的方案。



输入描述
第一行一个整数 n，表示有 n 本书，同时有 n 个位置。

第二行 n 个整数，表示每本书的厚度 ai(1 ≤ ai ≤ 109)。

第三行 n 个整数，表示每个可以放书位置的宽度 bj (1 ≤ bj ≤ 109)。

对于 30% 的数据，n ≤ 20；

对于 100% 的数据，1 ≤ n ≤ 105。

数据保证所有书可以返回书架

输出描述
输出一行一个整数，表示放书方案的种类数，由于这个方案数很大，请对 109 + 7 取模后输出。


样例输入

4
1 2 3 4
2 4 3 4

样例输出
8

代码

public class Main2 {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int m = cin.nextInt();
        int[] a = new int[m];
        int[] b = new int[m];
        long k=1L;
        for (int i = 0; i < m; i++) {
            a[i] = cin.nextInt();
        }
        Arrays.sort(a);
        for (int i = 0; i < m; i++) {
            b[i] = cin.nextInt();
        }
        Arrays.sort(b);
        int bb = m-1,kk=0;
        for (int i = m-1; i >=0 ; i--) {
            while (bb>=0&&b[bb]>=a[i]){
                kk++;bb--;
            }
            k*=kk;
            k%=1000000007;
            kk--;
        }
        System.out.println((int)k);
    }
}

题十

小团最近在学习操作系统。

文件流是操作系统中一个重要的概念。在 Linux 操作系统中，/dev/random 和 /dev/urandom 是两个重要的设备，它们可以提供永不为空的随机字节数据流。在这里，流是不能回退的。

小团自己也实现了一个类似于 /dev/random 的设备 /dev/crandom，但是它只能提供预先设定好但循环不断的某个由随机小写字母组成的字符串。比如这个随机字符串为 meituan，那么这个设备会提供永不为空的字符串流 meituanmeituanmeit…。

小团想利用这个设备生成一段由小写英文字母组成的文字，但她想知道恰好生成完这段文字时，浪费了这个流的多少个字符。


输入描述
第一行一个长为 n 的字符串 s，表示这个循环出现的随机字符串。

第二行一个长为 m 的字符串 a，表示小团想要生成的字符串。

对于 30% 的数据，1≤n, m≤103。

对于另外 20% 的数据，保证 s 串中 ASCII 码大的字母均出现在 ASCII 码小的字母之后。

对于全部数据，1≤n, m≤105，保证字符串 s 与 a 只包含小写英文字母。

输出描述
输出一行一个整数，如果不能生成字符串 a，则输出 -1，否则输出恰好生成完这个字符串时，浪费了这个流的多少个字符。


样例输入
meituan
uta

样例输出
10

提示
拿取生成流中字母的情况如下，拿取的字母用下划线表示。

在生成好最后一个 a 的时候，浪费了其之前没有标下划线的 10 个字符。

代码

public class Main3 {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        String s = cin.nextLine();
        String a = cin.nextLine();
        int n = s.length();
        int m = a.length();
        int q=0,x=0;
        int k =0;
        boolean boo = true;
        q = s.indexOf(a.charAt(0));
        if(q==-1){boo = false;}
        for (int i = 1; i < m; i++) {
            x = s.indexOf(a.charAt(i),q+1);
            if(boo)
            if(x==-1){
                k++;
                q=s.indexOf(a.charAt(i));
                if(q==-1){
                    boo=false;
                }
            }else {
                q=x;
            }
        }
        if(boo){
            System.out.println(k*(n+1)+q-m);
        }
        else {
            System.out.println(-1);
        }
    }
}