017年校招全国统一模拟笔试(第三场)编程题集合

变换次数

---

牛牛想对一个数做若干次变换，直到这个数只剩下一位数字。
变换的规则是：将这个数变成 所有位数上的数字的乘积。比如285经过一次变换后转化成2*8*5=80.
问题是，要做多少次变换，使得这个数变成个位数。

输入描述:

输入一个整数。小于等于2,000,000,000。

输出描述:

输出一个整数，表示变换次数。

输入例子1:

285

输出例子1:

2

结果

您的代码已保存
答案正确:恭喜！您提交的程序通过了所有的测试用例

实现

import java.util.*;

public class Main{
    public static void main(String [] args){
        Scanner scanner = new Scanner(System.in);
        //获取值
        long value = scanner.nextLong();
        int count = 0;
        while(!(value<10)){
            long  temp = 1L;
            while(value>0){
                temp = temp*(value%10);
                value = (long)value/10;
            }
            value = temp;
            count++;
        }
        System.out.println(count);
    }
}

神奇数

---

时间限制：1秒
空间限制：32768K
给出一个区间[a, b]，计算区间内“神奇数”的个数。
神奇数的定义：存在不同位置的两个数位，组成一个两位数（且不含前导0），且这个两位数为质数。
比如：153，可以使用数字3和数字1组成13，13是质数，满足神奇数。同样153可以找到31和53也为质数，只要找到一个质数即满足神奇数。

输入描述:

输入为两个整数a和b，代表[a, b]区间 (1 ≤ a ≤ b ≤ 10000)。

输出描述:

输出为一个整数，表示区间内满足条件的整数个数

输入例子1:

11 20

输出例子1:

6

结果

您的代码已保存
答案正确:恭喜！您提交的程序通过了所有的测试用例

实现

import java.util.Arrays;
/**针对每个数字取其两位进行判断是否为质数，存在质数则累加，然后退出
 **/
import java.util.*;

public class Main{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int start = scanner.nextInt();
        int end = scanner.nextInt();
        int count = 0;
        for (int i = start; i <= end; i++) {
            if(isAmazing(i))
                count++;
        }
        System.out.println(count);
    }

    //判断一个数是否为神奇数
    public static boolean isAmazing(int value) {
        String string = String.valueOf(value);
        for (int i = 0; i < string.length(); i++) {
            for (int j = i + 1; j < string.length(); j++) {
                int value1 = (string.charAt(i)-'0') * 10 + (string.charAt(j)-'0');
                int value2 = (string.charAt(j)-'0') * 10 + (string.charAt(i)-'0');
                if(value1>10&&isZhi(value1))
                    return  true;
                if(value2>10&&isZhi(value2))
                    return  true;
            }
        }
        return false;
    }
    //判断一个两位数是否为质数
    public static boolean isZhi(int value) {
        if (value < 10)
            return false;
        for (int i = 2; i < value / 2 + 1; i++) {
            if (value % i == 0)
                return false;
        }
        return true;
    }
}

添加字符

---

时间限制：1秒
空间限制：32768K
牛牛手里有一个字符串A，羊羊的手里有一个字符串B，B的长度大于等于A，所以牛牛想把A串变得和B串一样长，这样羊羊就愿意和牛牛一起玩了。
而且A的长度增加到和B串一样长的时候，对应的每一位相等的越多，羊羊就越喜欢。比如”abc”和”abd”对应相等的位数为2，为前两位。
牛牛可以在A的开头或者结尾添加任意字符，使得长度和B一样。现在问牛牛对A串添加完字符之后，不相等的位数最少有多少位？

输入描述:

第一行为字符串A，第二行为字符串B，A的场地小于等于B的长度，B的长度小于等于50.字符均为小写字母。

输出描述:

输出一个整数表示A串添加完字符之后，不相等的位数最少有多少位？

输入例子1:

abe
cabc

输出例子1:

1

import java.util.*;
public class Main{
    public static void main(String [] args){
        Scanner scanner = new Scanner(System.in);
        String a = scanner.nextLine();
        String b = scanner.nextLine();//长
        int min = Integer.MAX_VALUE;
        for(int i = 0;i<=b.length()-a.length();i++){
                int index = getNumber(b,i,a);
                if(index<min)
                    min = index;
        }
        System.out.println(min);
    }
    public static int getNumber(String string1,int start,String string2){
        int count = 0;
        int end = string2.length()+start;
        for(int i = start,j = 0;i<end&&j<string2.length();i++,j++){
            if(string1.charAt(i)!=string2.charAt(j))
                count++;
        }
        return count;
    }   
}

数组变换

---

时间限制：1秒
空间限制：32768K
牛牛有一个数组，里面的数可能不相等，现在他想把数组变为：所有的数都相等。问是否可行。
牛牛可以进行的操作是：将数组中的任意一个数改为这个数的两倍。
这个操作的使用次数不限，也可以不使用，并且可以对同一个位置使用多次。

输入描述:

输入一个正整数N (N <= 50)
接下来一行输入N个正整数，每个数均小于等于1e9.

输出描述:

假如经过若干次操作可以使得N个数都相等，那么输出”YES”, 否则输出”NO”

输入例子1:

2
1 2

输出例子1:

YES

结果

您的代码已保存
答案正确:恭喜！您提交的程序通过了所有的测试用例

实现

import java.util.*;

public class Main{
    public static void main(String [] args){
        Scanner scanner = new Scanner(System.in);
        int number = scanner.nextInt();
        int index = 0;
        int flag = 1;
        while(index<number){
            int item = scanner.nextInt();
            if(item==1){
                index++;
                continue;
            }
            if(flag==1){
                flag = item;
                index++;
                continue;
            }
            if((item>=flag&&item%flag!=0)||(item<=flag&&flag%item!=0)||item==0)
            {   System.out.println("NO");
                return ;
            }
            index++;

        }
        System.out.println("YES");
    }
}

排序子序列

---

牛牛定义排序子序列为一个数组中一段连续的子序列,并且这段子序列是非递增或者非递减排序的。牛牛有一个长度为n的整数数组A,他现在有一个任务是把数组A分为若干段排序子序列,牛牛想知道他最少可以把这个数组分为几段排序子序列.
如样例所示,牛牛可以把数组A划分为[1,2,3]和[2,2,1]两个排序子序列,至少需要划分为2个排序子序列,所以输出2

输入描述:

输入的第一行为一个正整数n(1 ≤ n ≤ 10^5)

第二行包括n个整数A_i(1 ≤ A_i ≤ 10^9),表示数组A的每个数字。

输出描述:

输出一个整数表示牛牛可以将A最少划分为多少段排序子序列

输入例子1:

6
1 2 3 2 2 1

输出例子1:

2

结果

您的代码已保存
答案正确:恭喜！您提交的程序通过了所有的测试用例

实现

import java.util.*;

public class Main{

    public static void main(String[] args) {
        //获取输入
        Scanner scanner = new Scanner(System.in);
        int number = scanner.nextInt();
        int index = 0;
        int[] value = new int[number];
        while (index < number) {
            value[index++] = scanner.nextInt();
        }
        //处理
        int count = 1;
        int  flag = 0;
        if (value[1] >= value[0])
            flag = 1;
        else
            flag = -1;
        for (int i = 2; i < value.length; i++) {
            if(value[i]==value[i-1])
                continue;
            if (value[i] > value[i - 1] && ((flag ==1)||(flag==0)))
                {
                flag = 1;
                continue;
            }
            if ((value[i] < value[i - 1]) && ((flag == -1)||(flag==0))){
                flag = -1;
                continue;
            }
            flag = 0;
            count++;
        }
        System.out.println(count);
    }
}