蓝桥杯-练习题（1000-1030）

1000.A+B 问题

一、题干

Description
计算 a+b 的值
Input
输入一行,两个整数 a,b (0<=a,b<=10)
Output
 a+b 的运算结果
Sample Input
1 2
Sample Output
3

二、分析

比较简单
1、接收，空格分割，数据类型转换

三、代码

package 模拟;

import java.util.Scanner;

public class T1 {

    /**
     * @param args
     */
    public static void main(String[] args) {


        Scanner scanner=new Scanner(System.in);
        
        String aString=scanner.nextLine();
        
        String[] arrStrings=aString.split(" ");
        
        int a=Integer.parseInt(arrStrings[0]);
        
        int b=Integer.parseInt(arrStrings[1]);
        
        System.out.println(a+b);

    }

}

1001.不重复数

一、题干

Description
给定N是一个正整数，求比N大的最小“不重复数”，这里的不重复是指没有两个相等的相邻位，如1102中的11是相等的两个相邻位故不是不重复数，而12301是不重复数。
Input
输入由多组测试数据组成。第一行输入一个整数t,表示测试数据的组数。
接下来的t行，每行输入一个数。
Output
输出有t行，每行依次对应一组测试数据的运算结果。
Sample Input
3
11000000
222222222
333333333
Sample Output
12010101
230101010
340101010

二、分析

当时觉得比较难，现在感觉还好
1、穷举法
2、判断是否有重复的
3、字符串的截取，charAt();

三、代码

package 模拟;

import java.util.Scanner;

public class T2 {

    public static void main(String[] args) {

        Scanner scanner=new Scanner(System.in);
        
        int conut=scanner.nextInt();
        
        int[] arr=new int[conut];
        
        for (int i = 0; i < arr.length; i++) {
            
            int in=scanner.nextInt();
            arr[i]=getMinNum(in);
            
        }
        
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
            
        }
    }

    //找最小的数
    private static int getMinNum(int in) {
        
        for ( in+=1; ; in++) {
            
            if (getCf(in)) {
                return in;
            }
            
        }
    }

    //判断是否有重复的，转成string比较好判断些
    private static boolean getCf(int in) {
        
        String string=in+"";
        
        for (int i = 0; i < string.length()-1; i++) {
            
            if (string.charAt(i)==string.charAt(i+1)) {
                return false;
            }
            
        }
        
        return true;
    }

}

1002.单位转换

一、题干

Description
在计算机存储里面的单位转换。我们都知道1MB=1024KB，1KB=1024B，1B=8bit，试编程实现单位转换。
Input
输入由多组测试数据组成。首先输入一个整数n,表示测试数据的数目。
接下来的n行，每行表示一个未化简的数据，如xMB，xKB，xB，xbit，(1≤x≤50)
Output
输出为换算过后的数据，ybit
Sample Input
4
1MB
1KB
2B
1bit
Sample Output
8388608bit
8192bit
16bit
1bit

二、分析

还是很简单的
1、接收一个字符串
2、提取后面的单位，提取数字部分
3、endsWith()；的使用，直接判断结尾

三、代码

package 模拟;

import java.util.Scanner;

public class T3 {

    public static void main(String[] args) {
        
        Scanner scanner=new Scanner(System.in);
        
        int conut=scanner.nextInt();
        
        String[] arr=new String[conut];
        
        for (int i = 0; i < arr.length; i++) {
            
            String in=scanner.next();
            arr[i]=getZh(in);
            
        }
        
        for (int i = 0; i < arr.length; i++) {
            
             System.out.println(arr[i]);
            
        }

    }

    private static String getZh(String nextLine) {
        
        int le=nextLine.length();
        String reString="";
        
        if (nextLine.endsWith("MB")) {

            reString=Integer.parseInt(nextLine.substring(0, le-2))*1024*1024*8 +"bit";
            
        }else if (nextLine.endsWith("KB")) {
            
            reString=Integer.parseInt(nextLine.substring(0, le-2))*1024*8 +"bit";
            
        }else if(nextLine.endsWith("B")){
            
            reString=Integer.parseInt(nextLine.substring(0, le-1))*8 +"bit";
            
        }else if (nextLine.endsWith("bit")) {
            
            reString=nextLine;
            
        }
        return reString;
    }

}

1003.奇偶排序

一、题干

Description
给定一个存放正数的数组，元素个数视输入情况而定，重新排列数组使得数组左边为奇数，右边为偶数，且保证奇数和偶数之间元素相对位置不变。
Input
输入由多组测试数据组成。第一行输入一个整数t,表示测试数据的组数。
输入字符串的格式为：“操作数1 操作数2 … 操作数n”，“操作数”与“操作数”之间以一个空格隔开。
Output
输出有t行，每行依次对应一组测试数据的运算结果。
Sample Input
3
7 32 56 32 1 9
23 11 2 68 98 2 3 68 100
3 5 12 22 1 23 567 876 3 2 56 78
Sample Output
7 1 9 32 56 32
23 11 3 2 68 98 2 68 100
3 5 1 23 567 3 12 22 876 2 56 78

二、分析

1、接收输入的字符串，转成int型数组
2、前面放奇数，后面放偶数的（相对位置不变）
3、也不难，先把所有的奇数找出来放在前面，在来找偶数的

三、代码

package 模拟;

import java.io.IOException;
import java.util.Scanner;

public class T4 {

    public static void main(String[] args) throws IOException {

        Scanner scanner=new Scanner(System.in);
        
        String con=scanner.nextLine();
        int conut=Integer.parseInt(con);
        
        //用数组装起来
        String[] arrStrings=new String[conut];
        
        for (int i = 0; i < arrStrings.length; i++) {
            
            //读取一个带空格的字符串
            //PS:用scanner.nextLine有问题、用scanner.next会以空格来结束
            //百度到用bufferedReader.readLine()
            //在自己电脑上测试可以，上传网上测不通过
            
            String inString=scanner.nextLine();
            arrStrings[i]=getArr(inString);
            
        }
        
        //输出
        for (int i = 0; i < arrStrings.length; i++) {
            
            System.out.println(arrStrings[i]);
            
        }

    }

    //奇数放前面，偶数放后面
    private static String getArr(String inString) {
        
        //转成字符串数组
        String[] strArrStrings=inString.split(" ");
        
        String re="";
        
        //奇数
        for (int i = 0; i < strArrStrings.length; i++) {
            
            if (Integer.parseInt(strArrStrings[i])%2==1) {
                re=re+strArrStrings[i]+" ";
            }
            
        }
        //偶数
        for (int i = 0; i < strArrStrings.length; i++) {
            
            if (Integer.parseInt(strArrStrings[i])%2==0) {
                re=re+strArrStrings[i]+" ";
            }
            
        }
        re=re.substring(0, re.length()-1);
        return re;
    }

}

1004.算术运算

一、题干

Description
通过键盘输入100以内正整数的加、减运算式，请编写一个程序输出运算结果字符串。
补充说明：
1. 操作数为正整数，不需要考虑计算结果溢出的情况。
2. 若输入算式格式错误，输出结果为“E”。
Input
输入由多组测试数据组成。第一行输入一个整数t,表示测试数据的组数。
输入字符串的格式为：“操作数1 运算符 操作数2”，“操作数”与“运算符”之间以一个空格隔开。
Output
输出有t行，每行依次对应一组测试数据的运算结果。
Sample Input
3
5 + 3
3 – 5
9 ++ 7
Sample Output
8
-2
E

二、分析

同1001题，无他的

三、代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;


public class T4 {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        
        Scanner scanner=new Scanner(System.in);
        BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
        
        int conut=scanner.nextInt();
        
        String[] arrString=new String[conut];
        
        for (int i = 0; i < arrString.length; i++) {
            
            arrString[i]=bufferedReader.readLine();
            
        }
        
        for (int i = 0; i < arrString.length; i++) {
            System.out.println(getNum(arrString[i]));
            
        }
        
    }
    public static String getNum(String s) {
        String sArrString[]=s.split(" ");
        
        String ret="E";
        try {
            if (sArrString[1].equals("+")) {
                ret=Integer.parseInt(sArrString[0])+Integer.parseInt(sArrString[2])+"";
            }
            if (sArrString[1].equals("-")) {
                ret=Integer.parseInt(sArrString[0])-Integer.parseInt(sArrString[2])+"";
            }
        } catch (Exception e) {

        }
        return ret;
    } 
}

1005.奇偶排序

一、题干

Description
将10000块钱兑换成由5000块、2000块、1000块、500块、100块、50块、10块、5块、1块的组成的零钱，问有多少种兑换方式？
Input
无输入
Output
运算结果。

样例输出中的结果不正确，只是格式提示

Sample Input
无输入
Sample Output
13456789

二、分析

    /**
     * 将10000块钱兑换成由5000块、2000块、1000块、500块、100块、50块、10块、5块、1块的组成的零钱，问有多少种兑换方式？
     * 
     * 参考来自：http://www.cnblogs.com/lekko/archive/2013/04/05/3000403.html
     * 
     * 一般的都是写八九层循环做的，
     * 优化：
     *     1、循环次数的控制（动态的控制，根据上层循环得结果来决定下层循环的次数）
     *     2、每层计算循环的结果：sum[]，省的每次都要重新计算一次
     *     3、最后一层，到5和1的时候，直接(10000-sum[6])/5就可得到5的次数，1不用考虑
     */

三、代码

（答案：24597373438）

package 模拟;

public class T6 {

    /**
     * 将10000块钱兑换成由5000块、2000块、1000块、500块、
     * 100块、50块、10块、5块、1块的组成的零钱，问有多少种兑换方式？
     */
    public static void main(String[] args) {
        
        //9种面额的钱
        int[] money=new int[]{5000,2000,1000,500,100,50,10,5,1};
        
        //没个循环后的钱数
        int[] sum=new int[9]; 
        
        //下层循环的次数
        int[] conut=new int[9];
        
        long re=0;
        //5000
        for (int i = 0; i < 3; i++) {
            sum[0]=i*money[0];
            conut[1]=(10000-sum[0])/money[1]+1;

            //2000
            for (int j = 0; j < conut[1]; j++) {
                sum[1]=j*money[1]+sum[0];
                conut[2]=(10000-sum[1])/money[2]+1;

                //1000
                for (int k = 0; k < conut[2]; k++) {
                    sum[2]=k*money[2]+sum[1];
                    conut[3]=(10000-sum[2])/money[3]+1;
                    
                    //500
                    for (int k2 = 0; k2 < conut[3]; k2++) {
                        sum[3]=k2*money[3]+sum[2];
                        conut[4]=(10000-sum[3])/money[4]+1;

                        //100
                        for (int l = 0; l < conut[4]; l++) {
                            sum[4]=l*money[4]+sum[3];
                            conut[5]=(10000-sum[4])/money[5]+1;

                            //50
                            for (int l2 = 0; l2 < conut[5]; l2++) {
                                sum[5]=l2*money[5]+sum[4];
                                conut[6]=(10000-sum[5])/money[6]+1;
                                
                                //10
                                for (int m = 0; m < conut[6]; m++) {
                                    sum[6]=m*money[6]+sum[5];
                                    conut[7]=(10000-sum[6])/money[7]+1;
                                    
                                    re+=conut[7];
                                }
                            }
                        }
                    }
                }
            }
        }
        System.out.println(re);
    }
}

1006.分解质因数

一、题干

Description
将一个正整数N分解质因数，比如150=2*3*5*5，其质因数为2 3 5 5。
Input
输入由多组测试数据组成。第一行输入一个整数t,表示测试数据的组数。
接下来的t行，每行输入一个正整数。
Output
输出有t行，每行依次对应一组测试数据的输出结果。
Sample Input
2
90
150
Sample Output
2 3 3 5
2 3 5 5 

二、分析

1、分解质因数，从2开始除，除不断时，找大一点的再除，直至余数为零
2、找更大的一个质因数
3、只能被自己和1整除的数为质因数

三、代码

package 模拟;

import java.util.Scanner;

public class T7 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
        Scanner scanner=new Scanner(System.in);
        int conut=Integer.parseInt(scanner.nextLine());
        
        String[] arrString=new String[conut];
        
        for (int i = 0; i < arrString.length; i++) {
             
            arrString[i]=getZY(scanner.nextLine());
            
        }
        for (int i = 0; i < arrString.length; i++) {
            System.out.println(arrString[i]);
            
        }
        
    }
    
    //分解质因数，从2开始除，除不断时，找大一点的再除，直至余数为零
    private static String getZY(String nextLine) {
        
        int num=Integer.parseInt(nextLine);
        
        int zhi=2;
        
        String reString="";
        
        for ( ;1!=num ; ) {
            if (num%zhi==0) {
                reString=reString+zhi+" ";
                num/=zhi;
            }else {
                zhi=getZHI(zhi);
            }
            
        }
        
        return reString;
    }
    
    //找更大的一个质因数
    private static int getZHI(int zhi) {
        
        for (int i = zhi+1; ; i++) {
            
            for (int j = 2; j < zhi+1/2+1; j++) {
                
                if (i%j==0) {
                    break;
                }
                
            }
            return i;
        }
    }

}

1007.回文素数

一、题干

Description
回文素数是指，如果一个正整数n从左向右和从右向左读结果都相同且是素数，则称之为回文素数。编程找出1000以内的回文素数
Input
无输入
Output
输出有若干行，每行输出5个回文素数。（样例输出只是格式提示）
Sample Input
无输入
Sample Output
2 3 5 7 11 
101 131 151 181 191 

二、分析

1、先判断是否为素数
2、再判断是否为回文数

三、代码

package 模拟;

public class T8 {

    /**
     * 回文素数是指，如果一个正整数n从左向右和从右向左读结果都相同且是素数，
     * 则称之为回文素数。编程找出1000以内的回文素数
     */
    public static void main(String[] args) {
        int co=0;
        
        //判断素数
        for (int i = 2; i < 1000; i++) {
            boolean fa=true;
            for (int j = 2; j < i/2+1; j++) {
                
                if (i%j==0) {
                    fa=false;
                    break;
                }else{
                    fa=true;
                }
            }
            //是素数的再看是不是回文数
            if (fa) {
                if (getHui(i)) {
                    co++;
                    System.out.print(i+" ");
                    if (co==5) {
                        System.out.println();
                        co=0;
                    }
                }
            }
        }
    }

    //判断是否为回文数
    private static boolean getHui(int i) {
        
        String aString=i+"";
        int le=aString.length();
        if (le==1) {
            return true;
        }else if (le==2) {
            if (aString.charAt(0)==aString.charAt(1)) {
                return true;
            }
        }else if (le==3) {
            if (aString.charAt(0)==aString.charAt(2)) {
                return true;
            }
        }
        return false;
    }

}