蓝桥杯程序练习

数列排序

问题描述

  给定一个长度为n的数列,将这个数列按从小到大的顺序排列。1<=n<=200

输入格式

  第一行为一个整数n。
  第二行包含n个整数,为待排序的数,每个整数的绝对值小于10000。

输出格式

  输出一行,按从小到大的顺序输出排序后的数列。

样例输入

5
8 3 6 4 9

样例输出

3 4 6 8 9

源代码:

import java.util.Arrays;
import java.util.Scanner;

public class Main{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int [] a = new int[n];
        for(int i = 0; i < n; i++) {
            a[i] = scanner.nextInt();
        }
        Arrays.sort(a);
        for(int i = 0; i < a.length; i++)
            System.out.print(a[i] + " ");
    }
}

Fibonacci数列

问题描述

​ Fibonacci数列的递推公式为:Fn=Fn-1+Fn-2,其中 F1=F2=1。

​ 当n比较大时,Fn也非常大,现在我们想知道,Fn除以10007的余数是多少。

输入格式

​ 输入包含一个整数n。

输出格式

​ n

​ 说明:在本题中,答案是要求Fn除以10007的余数,因此我们只要能算出这个余数即可,而不需要先计算出Fn的准确值,再将计算的结果除以10007取余数,直接计算余数往往比先算出原数再取余简单。

样例输入 10 样例输出 55

样例输入 22 样例输出 7704

数据规模与约定

1 <= n <= 1,000,000。

源代码:

import java.util.Scanner;


public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] a = new int[1000000];
        a[1] = 1;
        a[2] = 1;
        for(int i=3; i<=n; i++)
            a[i] = (a[i-1]+a[i-2])%10007;
        System.out.println(a[n]);
    } 
}

十六进制转八进制

问题描述**
  给定n个十六进制正整数,输出它们对应的八进制数。

输入格式**
  输入的第一行为一个正整数n (1<=n<=10)。
  接下来n行,每行一个由0~9、大写字母A~F组成的字符串,表示要转换的十六进制正整数,每个十六进制数长度不超过100000。

输出格式**
  输出n行,每行为输入对应的八进制正整数。

  【注意**
  输入的十六进制数不会有前导0,比如012A。
  输出的八进制数也不能有前导0。

样例输入**
  2
  39
  123ABC

样例输出**
  71
  4435274

  【提示**
  先将十六进制数转换成某进制数,再由某进制数转换成八进制。

源代码:

import java.util.Scanner;

public class Main{
    public static void main(String[] args) {
        Scanner sc =  new Scanner(System.in);
        int n = sc.nextInt();
        String [] h = new String[n];
        for(int i = 0; i < n; i++) {
            h[i] = sc.next();
        }
        sc.close();

        String [] b = new String[n];
        String [] o = new String[n];
        for(int i=0; i<n; i++) {
            b[i] = toBinary(h[i]);
            if(b[i].length()%3 == 1)
                b[i] = "00" + b[i];
            if(b[i].length()%3 == 2)
                b[i] = "0" + b[i];
            o[i] = toOctal(b[i]);
            System.out.println(o[i]);
        }

    }

    private static String toOctal(String strBinary) {
        int len = strBinary.length();
        int k;
        StringBuffer stb =new StringBuffer();
        if(strBinary.substring(0,3).equals("000")) k=3;
        else k=0;
        for(int i=k;i<len; i+=3){
            String string = strBinary.substring(i,i+3);
            if(string.equals("000")) stb.append("0");
            else if(string.equals("001")) stb.append("1");
            else if(string.equals("010")) stb.append("2");
            else if(string.equals("011")) stb.append("3");
            else if(string.equals("100")) stb.append("4");
            else if(string.equals("101")) stb.append("5");
            else if(string.equals("110")) stb.append("6");
            else if(string.equals("111")) stb.append("7");
        }
        return stb.toString();
    }



    private static String toBinary(String strHex) {
        StringBuffer stb =new StringBuffer();
        for(int i=0;i < strHex.length(); i++) {
            switch(strHex.charAt(i)) {
            case '0': stb.append("0000");break;
            case '1': stb.append("0001");break;
            case '2': stb.append("0010");break;
            case '3': stb.append("0011");break;
            case '4': stb.append("0100");break;
            case '5': stb.append("0101");break;
            case '6': stb.append("0110");break;
            case '7': stb.append("0111");break;
            case '8': stb.append("1000");break;
            case '9': stb.append("1001");break;
            case 'A': stb.append("1010");break;
            case 'B': stb.append("1011");break;
            case 'C': stb.append("1100");break;
            case 'D': stb.append("1101");break;
            case 'E': stb.append("1110");break;
            case 'F': stb.append("1111");break;
            default:break;
            }
        } 
        return stb.toString();
    }
}

十六进制转十进制

问题描述

  从键盘输入一个不超过8位的正的十六进制数字符串,将它转换为正的十进制数后输出。
  注:十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。

样例输入

FFFF

样例输出

65535

源代码:


import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String string = scanner.next();
        int a = 0;
        long sum = 0;

        for(int i = 0; i < string.length(); i++) {

            switch (string.charAt(i)) {
            case '0': a = 0;break;
            case '1': a = 1;break;
            case '2': a = 2;break;
            case '3': a = 3;break;
            case '4': a = 4;break;
            case '5': a = 5;break;
            case '6': a = 6;break;
            case '7': a = 7;break;
            case '8': a = 8;break;
            case '9': a = 9;break;
            case 'A': a = 10;break;
            case 'B': a = 11;break;
            case 'C': a = 12;break;
            case 'D': a = 13;break;
            case 'E': a = 14;break;
            case 'F': a = 15;break;
            default:
                break;
            }
            sum += a* Math.pow(16, string.length()-i-1);
        }
        System.out.println(sum);

    }
}

十进制转十六进制

问题描述

  十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F共16个符号,分别表示十进制数的0至15。十六进制的计数方法是满16进1,所以十进制数16在十六进制中是10,而十进制的17在十六进制中是11,以此类推,十进制的30在十六进制中是1E。
  给出一个非负整数,将它表示成十六进制的形式。

输入格式

  输入包含一个非负整数a,表示要转换的数。0<=a<=2147483647

输出格式

  输出这个整数的16进制表示

样例输入

30

样例输出

1E

源代码:

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        int[] b = new int[10];
        int len = 0;
        if(a==0) {
            System.out.println(0);
            return ;
        }
        while(a != 0) {
            b[len] = a%16;
            len++;
            a /= 16;
        }

        StringBuffer stb = new StringBuffer();
        for( int i = len-1; i >= 0; i--) {
            String s = null;
            switch(b[i]) {
            case 0: s = "0";break;
            case 1: s = "1";break;
            case 2: s = "2";break;
            case 3: s = "3";break;
            case 4: s = "4";break;
            case 5: s = "5";break;
            case 6: s = "6";break;
            case 7: s = "7";break;
            case 8: s = "8";break;
            case 9: s = "9";break;
            case 10: s = "A";break;
            case 11: s = "B";break;
            case 12: s = "C";break;
            case 13: s = "D";break;
            case 14: s = "E";break;
            case 15: s = "F";break;
            default:
                break;
            }           
            stb.append(s);              
        }   
        System.out.println(stb.toString());
    }
}

特殊回文数:

问题描述

  123321是一个非常特殊的数,它从左边读和从右边读是一样的。
  输入一个正整数n, 编程求所有这样的五位和六位十进制数,满足各位数字之和等于n 。

输入格式

  输入一行,包含一个正整数n。

输出格式

  按从小到大的顺序输出满足条件的整数,每个整数占一行。

样例输入

52

样例输出

899998
989989
998899

数据规模和约定

  1<=n<=54。

源代码:


import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        ArrayList<Integer> rs = new ArrayList<Integer>();

        for(int i=1; i<10; i++) {
            for(int j=0; j<10; j++) {
                for(int k=0; k<10; k++) {
                    if(2*i+2*j+k == n)
                        rs.add(i*10000 + j*1000 + k*100 + j*10 + i);
                    if(2*i+2*j+2*k == n)
                        rs.add(i*100000 + j*10000 + k*1000 + k*100 + j*10 + i);
                }
            }
        }
        Collections.sort(rs);
        for(int i=0; i<rs.size(); i++)
            System.out.println(rs.get(i));
    }
}

回文数:

问题描述

  1221是一个非常特殊的数,它从左边读和从右边读是一样的,编程求所有这样的四位十进制数。

输出格式

  按从小到大的顺序输出满足条件的四位十进制数。

源代码:

public class Main {

    public static void main(String [] arg) {

        for(int i = 1000; i < 10000; i++) {
            int a = i/1000;
            int b = i%1000/100;
            int c = i%100/10;
            int d = i%10;
            if( a == d && b ==c) 
                System.out.println(i);
        }
    }
}

特殊的数字:

问题描述

  153是一个非常特殊的数,它等于它的每位数字的立方和,即153=1*1*1+5*5*5+3*3*3。编程求所有满足这种条件的三位十进制数。

输出格式

  按从小到大的顺序输出满足条件的三位十进制数,每个数占一行。

源代码:

public class Main {

    public static void main(String[] args) {
        for(int i = 100; i < 1000; i++) {
            int a = i/100;
            int b = i%100/10;
            int c = i%10;
            if(i == a*a*a + b*b*b + c*c*c)
                System.out.println(i);
        }
    }
}

杨辉三角

问题描述

​ 杨辉三角形又称Pascal三角形,它的第i+1行是(a+b)i的展开式的系数。

​ 它的一个重要性质是:三角形中的每个数字等于它两肩上的数字相加。

​ 下面给出了杨辉三角形的前4行:

   1

  1 1

​ 1 2 1

​ 1 3 3 1

​ 给出n,输出它的前n行。

输入格式

​ 输入包含一个数n。

输出格式

​ 输出杨辉三角形的前n行。每一行从这一行的第一个数开始依次输出,中间使用一个空格分隔。请不要在前面输出多余的空格。

样例输入

4

样例输出

1
1 1
1 2 1
1 3 3 1

数据规模与约定

1 <= n <= 34。

源代码:

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();

        int [][] array = new int[n][n];
        for(int i = 0; i < n; i++) {
            for(int j = 0; j <= i; j++) {
                if( j == 0 || j == i)
                    array[i][j] = 1;
                else
                    array[i][j] = array[i-1][j] + array[i-1][j-1];
                System.out.print(array[i][j] + " ");
            }
            System.out.println();   
        }

    }

}

查找整数:

问题描述

​ 给出一个包含n个整数的数列,问整数a在数列中的第一次出现是第几个。

输入格式

​ 第一行包含一个整数n。

​ 第二行包含n个非负整数,为给定的数列,数列中的每个数都不大于10000。

​ 第三行包含一个整数a,为待查找的数。

输出格式

​ 如果a在数列中出现了,输出它第一次出现的位置(位置从1开始编号),否则输出-1。

样例输入

6
1 9 4 8 3 9
9

样例输出

2

数据规模与约定

1 <= n <= 1000。

源代码:

import java.util.Scanner;

public class Main {

    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();
        }
        int s = sc.nextInt();
        int b = 0;
        for(int i = 0; i < n; i++) {
            if(a[i] == s) {
                System.out.println(i+1);
                b = 1;
                break;
            }
        }
        if(b == 0)
            System.out.println(-1);
    }

}

数列特征:

问题描述

​ 给出n个数,找出这n个数的最大值,最小值,和。

输入格式

​ 第一行为整数n,表示数的个数。

​ 第二行有n个数,为给定的n个数,每个数的绝对值都小于10000。

输出格式

​ 输出三行,每行一个整数。第一行表示这些数中的最大值,第二行表示这些数中的最小值,第三行表示这些数的和。

样例输入

5
1 3 -2 4 5

样例输出

5
-2
11

数据规模与约定

1 <= n <= 10000。

源代码:

import java.util.Arrays;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int [] a = new int[n];
        int b = 0;
        for(int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
            b += a[i];
        }
        Arrays.sort(a);
        System.out.println(a[n-1]);
        System.out.println(a[0]);
        System.out.println(b);
    }   
}

闰年判断:

问题描述

给定一个年份,判断这一年是不是闰年。

当以下情况之一满足时,这一年是闰年:

  1. 年份是4的倍数而不是100的倍数;
  2. 年份是400的倍数。

其他的年份都不是闰年。

输入格式

输入包含一个整数y,表示当前的年份。

输出格式

输出一行,如果给定的年份是闰年,则输出yes,否则输出no。

样例输入

2013

样例输出

no

样例输入

2016

样例输出

yes

数据规模与约定

1990 <= y <= 2050。

源代码:

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int y = sc.nextInt();
        if((y%4 == 0 && y%100 != 0) || y%400 == 0) 
            System.out.println("yes");
        else
            System.out.println("no");
    }
}

01字符:

问题描述

对于长度为5位的一个01串,每一位都可能是0或1,一共有32种可能。它们的前几个是:

00000

00001

00010

00011

00100

请按从小到大的顺序输出这32种01串。

输入格式

本试题没有输入。

输出格式

输出32行,按从小到大的顺序每行一个长度为5的01串。

样例输出

00000
00001
00010
00011
<以下部分省略>

源代码:

public class Main{
    public static void main(String[] args) {
        for(int i=0; i<2; i++)
            for(int j=0; j<2; j++)
                for(int k=0; k<2; k++)
                    for(int l=0; l<2; l++)
                        for(int m=0; m<2; m++) {
                            System.out.println(i+""+j+""+k+""+l+""+m);
                        }                       
    }
}

阶乘计算:

问题描述

  输入一个正整数n,输出n!的值。
  其中n!=1*2*3*…*n。

算法描述

  n!可能很大,而计算机能表示的整数范围有限,需要使用高精度计算的方法。使用一个数组A来表示一个大整数a,A[0]表示a的个位,A[1]表示a的十位,依次类推。
  将a乘以一个整数k变为将数组A的每一个元素都乘以k,请注意处理相应的进位。
  首先将a设为1,然后乘2,乘3,当乘到n时,即得到了n!的值。

输入格式

  输入包含一个正整数n,n<=1000。

输出格式

  输出n!的准确值。

样例输入

10

样例输出

3628800

源代码:

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Scanner;

public class 阶乘计算 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        System.out.println(f(n));
    }

    //初始化数组
    protected static ArrayList<BigInteger> table = new ArrayList<BigInteger>();
    static {
        //BigInterger.valueof(long val);
        //返回其值等于指定 long 的值的 BigInteger。
        table.add(BigInteger.valueOf(1));//给数组添加初始值1
    }

    public static BigInteger f(int x) {
        for(int size = table.size(); size <= x; size++) {
            //获取当前数组的最后一个数
            BigInteger lastfact = (BigInteger)table.get(size-1);
            /*
             *multiply(BigInterger val)
             *返回其值为(this * val)的BigInterger。
             */
            //当前数组的最后一个数和size相乘,并存入数组
            BigInteger nextfact = lastfact.multiply(BigInteger.valueOf(size));
            table.add(nextfact);
        }
        return (BigInteger)table.get(x);//返回数组的最后一个数
    }
}
已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 技术工厂 设计师:CSDN官方博客 返回首页