蓝桥杯JAVA-试题-基础练习

已于 2024-10-27 21:13:27 修改
阅读量658 收藏 25
点赞数 15
分类专栏： 备赛蓝桥杯 文章标签： 蓝桥杯 java 职场和发展 开发语言
于 2024-03-26 12:16:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_76949164/article/details/137038952
版权
该博客围绕蓝桥杯Java算法题展开，涵盖十六进制与八进制、十进制的相互转换，回文数、杨辉三角、查找整数等多种题型。介绍了各题的问题描述、输入输出格式，给出解题思路，部分题目还对比不同实现方式的优劣，涉及BigInteger类等知识。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、十六进制转八进制

资源限制

内存限制：512.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

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

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

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

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

样例输入
　　2
　　39
　　123ABC

样例输出
　　71
　　4435274

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

解题思路

 输入十六进制转八进制，java支持十六进制转二进制或十进制，和二进制或十进制转八进制

因此要中转一下

本题目如果使用Integer和String会超数据域，因此引入BigInteger类

BigInteger这个类，是超巨整数类，整数域能达到2的2的32次方，很适合在十六进制转换时使用，具体操作请看代码

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

public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        //int[] a=new int[n];
        for (int i = 0; i < n; i++) {
            String a=in.next();
            BigInteger big=new BigInteger(a,16);//输入16进制数
            System.out.println(big.toString(8));//输出转八进制数
        }
    }
}

若不考虑数据域，使用Integer和String把十六进制转十进制再转八进制，请看以下代码 

String sixteen=in.next();
String eight=Integer.toOctalString((Integer.parseInt(sixteen,16)));
System.out.println(eight);

 二、试题 基础练习 十六进制转十进制

资源限制

内存限制：512.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

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

样例输入

FFFF

样例输出

65535

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

public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        //int n=in.nextInt();
        //int[] a=new int[n];
        //for (int i = 0; i < n; i++) {
            String a=in.next();
            BigInteger big=new BigInteger(a,16);
            System.out.println(big.toString(10));
        //}
    }
}

 若不考虑数据域，使用Integer和String把十六进制转十进制，请看以下代码 

String sixteen=in.next();
int ten=Integer.parseInt(sixteen,16);
System.out.println(ten);

三、十进制转十六进制

资源限制

内存限制：512.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

　　十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有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.math.BigInteger;
import java.util.Arrays;
import java.util.Locale;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        //int n=in.nextInt();
        //int[] a=new int[n];
        //for (int i = 0; i < n; i++) {
            String a=in.next();
            BigInteger big=new BigInteger(a,10);
            System.out.println(big.toString(16).toUpperCase(Locale.ROOT));
        //}
    }
}

若不考虑数据域，使用Integer和String把十进制转十六进制，请看以下代码  

int ten=in.nextInt();
String sixteen=Integer.toHexString(ten);

四、特殊回文数

资源限制

内存限制：512.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

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

输入格式

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

输出格式

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

样例输入

52

样例输出

899998
989989
998899

数据规模和约定

　　1<=n<=54。

解题思路

本题有两个条件：

1.回文数

2.各个位数的和为它本身

因此就制造两个函数，分别实现两个判断功能

最后在循环里跑起来就可以了 

import java.util.*;
public class Main{
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int sum=0;
        for(int i=10000;i<1000000;i++)
        {
            if(isIt(i))
            {
                if(getSum(i)==n)
                    System.out.println(i);
            }
        }
    }
    public static boolean isIt(int n)
    {
        String s=Integer.toString(n);
        for(int i=0,j=s.length()-1;i<j;i++,j--)
        {
            if(s.charAt(i)!=s.charAt(j))
                return false;
        }
        return true;
    }
    public static int getSum(int n)
    {
        int sum=0;
        while(n>0)
        {
            sum+=(n%10);
            n/=10;
        }
        return sum;
    }

}

五、回文数

资源限制

内存限制：512.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

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

输出格式

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

思路

这题是刚才的削弱版，同理 

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        for(int i=1000;i<10000;i++)
        {
            if(isIt(i))
                System.out.println(i);
        }
    }
    public static boolean isIt(int n)
    {
        String s=Integer.toString(n);
        for(int i=0,j=s.length()-1;i<j;i++,j--)
        {
            if(s.charAt(i)!=s.charAt(j))
                return false;
        }
        return true;
    }
}

六、杨辉三角

资源限制

内存限制：256.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

杨辉三角形又称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。

解题思路

杨辉三角的规则：

第一行为1，

第二行为11，

从第三行开始往后每一行，边界都为1，每一行从第2个数到第n-1个数为上一行的相邻数依次相加得到，如图

 

实现的过程中，记住我给出的原理小的时候

记录上一行，留给下一行计算使用

二维列表法 

使用List实现的优势：
1. 更灵活：List的长度可以动态增长，不需要提前指定数组的大小。
2. 更易于操作：List提供了丰富的方法，如add、clear等，方便对数据进行操作。
3. 可读性更好：使用List可以更直观地表示数据结构，代码可读性更高。

使用List实现的劣势：
1. 性能较差：List的底层是基于数组实现的，相比直接使用数组会有一定的性能损失。
2. 内存占用较大：List在动态增长时可能会造成内存碎片，占用更多内存空间。

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        List<List<Integer>> list=Triangle(n);
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<list.get(i).size();j++)
            {
                if(j==0)
                    System.out.print(list.get(i).get(j));
                else
                    System.out.print(" "+list.get(i).get(j));

            }
            System.out.println();
        }
    }
    public static List<List<Integer>> Triangle(int n)
    {
        List<List<Integer>> list=new ArrayList<>();
        if(n==0)
            return null;
        List<Integer> row=new ArrayList<>();//上一行
        List<Integer> now=new ArrayList<>();//现在这行
        row.add(1);//初始化上一行为第一行：1
        for(int i=0;i<n;i++) {
            list.add(new ArrayList<>(row));
            now.clear();//清空本行
            now.add(1);//本行左边界1
            for(int j=0;j<row.size()-1;j++)
            {
                now.add(row.get(j)+row.get(j+1));
            }
            now.add(1);//本行右边界1
            row.clear();//清空上一行
            row.addAll(now);//把本行数据赋给上一行，也就是说，当前行变成上一行了
        }
        return list;
    }
}

二维数组法

使用数组实现的优势：
1. 性能更好：数组在内存中是连续存储的，访问元素速度更快。
2. 内存占用更小：数组的大小是固定的，不会因动态增长而产生额外开销。

使用数组实现的劣势：
1. 不够灵活：数组长度固定，需要提前指定大小，不适合动态增长的情况。
2. 操作复杂：需要手动处理数组的边界情况，代码相对复杂一些。

import java.util.*;

public class Main{
	public static void main(String args[]){
		Scanner in=new Scanner(System.in);
		int n=in.nextInt();
		int arr[][]=new int[n][n];
		for(int i=0;i<n;i++) {
			for(int j=0;j<i+1;j++) {
				arr[i][j]=1;
				if(i>=1&&j>=1) {
					arr[i][j]=arr[i-1][j]+arr[i-1][j-1];
				}
				System.out.print(arr[i][j]+" ");
			}
			System.out.println();
		}
	}
}

综合来看，如果数据规模较小且代码可读性更重要，可以选择使用List实现；如果需要处理大规模数据且性能要求较高，可以选择使用数组实现。在实际应用中，根据具体需求和场景选择合适的实现方式会更加合适。 

七、查找整数

资源限制

内存限制：256.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

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

输入格式

第一行包含一个整数n。

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

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

输出格式

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

样例输入

6
1 9 4 8 3 9
9

样例输出

2

数据规模与约定

1 <= n <= 1000。

解题思路

本题其实就是在数组里找一个数，找到了返回位置，找不到返回-1

常规做法就是for循环

但如何不用for循环呢？

那就用java的列表，使用查找ArrayList.indexOf() 

import java.util.ArrayList;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        ArrayList<Integer> list=new ArrayList<>();
        for (int i = 0; i < n; i++) {
            list.add(in.nextInt());
        }
        int m=in.nextInt();
        int i=list.indexOf(m)>-1 ? list.indexOf(m)+1 : -1;
        System.out.println(i);
    }
}

八、数列特征

资源限制

内存限制：256.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

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

输入格式

第一行为整数n，表示数的个数。
第二行有n个数，为给定的n个数，每个数的绝对值都小于10000。

输出格式

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

样例输入

5
1 3 -2 4 5

Data

样例输出

5
-2
11

Data

数据规模和约定

1 <= n <= 10000。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int[] a=new int[n];
        int sum=0;
        for (int i = 0; i < n; i++) {
            a[i]=in.nextInt();
            sum+=a[i];
        }
        Arrays.sort(a);
        System.out.println(a[n-1]);
        System.out.println(a[0]);
        System.out.println(sum);
    }
}

九、字母图形

资源限制

内存限制：256.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

利用字母可以组成一些美丽的图形，下面给出了一个例子：

ABCDEFG

BABCDEF

CBABCDE

DCBABCD

EDCBABC

这是一个5行7列的图形，请找出这个图形的规律，并输出一个n行m列的图形。

输入格式

输入一行，包含两个整数n和m，分别表示你要输出的图形的行数的列数。

输出格式

输出n行，每个m个字符，为你的图形。

样例输入

5 7

样例输出

ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC

数据规模与约定

1 <= n, m <= 26。

解题思路

这题做的我是真想骂人

题目的意思其实就是，输入两个数N行 M列

这个数M代表第一行的字母数，比如M=7,第一行就是ABCDEFG

N代表行数

题目要从第二行开始，在A的左边遍历字母到Z，每一行多遍历一个字母，最多到Z

比如这样：

24 7

ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
FEDCBAB
GFEDCBA
HGFEDCB
IHGFEDC
JIHGFED
KJIHGFE
LKJIHGF
MLKJIHG
NMLKJIH
ONMLKJI
PONMLKJ
QPONMLK
RQPONML
SRQPONM
TSRQPON
UTSRQPO
VUTSRQP
WVUTSRQ
XWVUTSR

 您猜我以为是啥？

我以为是在第一行的基础上，循环遍历第一行的字母，像一个圈一样，右边走了到左边

呈现这样的效果：

24 7
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
FEDCBAB
GFEDCBA
FGFEDCB
EFGFEDC
DEFGFED
CDEFGFE
BCDEFGF
ABCDEFG
GABCDEF
AGABCDE
BAGABCD
CBAGABC
DCBAGAB
EDCBAGA
FEDCBAG
GFEDCBA
FGFEDCB
EFGFEDC
DEFGFED

按我自己读题的思路，代码是这样的：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt(),m= in.nextInt();
        int sum=0;
        LinkedList<Character> list=new LinkedList<>();
        LinkedList<Character> list1=new LinkedList<>();
        char[] a=new char[m];
        for (int i = 0; i < m; i++) {
            a[i]=(char)(i+'A');
        }
        for (int i = 0; i < m; i++) {
            list.add((char)(i+'A'));
        }
        for(int i=0;i<n;i++)
        {
            if(i==0)
            {
                Print(list);
                continue;
            }
            list1.clear();
            list1.addAll(rt(i,list,a));
            list.clear();
            list.addAll(list1);
            Print(list);

        }
    }
    public static LinkedList<Character> rt(int n,LinkedList<Character> list,char[] a)
    {
        int count=0;
        if(a[n%a.length]=='A'||a[n%a.length]==a[a.length-1])
        {
            if((n+1)/a.length%2==0)
                list.addFirst(a[(n)%a.length]);
            else
                list.addFirst(a[a.length-1-((n+1)%a.length)]);
            count++;
        }
        else
        {
            if(n/a.length%2==0)
                list.addFirst(a[(n+count)%a.length]);
            else
                list.addFirst(a[a.length-1-((n+count+1)%a.length)]);
        }
        list.removeLast();
        return list;
    }
    public static void Print(LinkedList<Character> list)
    {
        for (Character c : list) {
            System.out.print(c);
        }
        System.out.println();
    }
}

 按题目的意思代码是这样的

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        char[][] a = new char[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                a[i][j]=(char) ('A'+Math.abs(i-j));//给A加上i-j的绝对值
            }
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                System.out.print(a[i][j]);
            }
            System.out.println();
        }
    }
}

家人们谁懂啊！！！！！ 

十、01字串

资源限制

内存限制：256.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

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

00000

00001

00010

00011

00100

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

输入格式

本试题没有输入。

输出格式

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

样例输出

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

解题思路

这道题就是从0到31输出二进制数 

先搞一个for循环，把每一个int数转换成二进制的字符串，再把字符串转化成int

保留五位输出即可

public class Main {
    public static void main(String[] args) {
        for(int i=0;i<32;i++)
        {
            String s=Integer.toBinaryString(i);
            int a=Integer.valueOf(s);
            System.out.printf("%05d\n",a);
        }
    }
}

十一、阶乘计算（vip）

资源限制

内存限制：512.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

　　输入一个正整数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

解题思路

一看这个数据域，n<=1000就知道，这题不简单，涉及到超大整数

1000的阶乘，这得多大啊

我们就想到了java的BigInteger类

补充BigInteger类的方法 

变量和类型方法描述
BigIntegerabs()

返回一个BigInteger，其值是此BigInteger的绝对值。

BigIntegeradd​(BigInteger val)

返回一个值为 (this + val)的BigInteger。

BigIntegerand​(BigInteger val)

返回值为 (this & val)的BigInteger。

BigIntegerandNot​(BigInteger val)

返回值为 (this & ~val)的BigInteger。

intbitCount()

返回此BigInteger的二进制补码表示中与其符号位不同的位数。

intbitLength()

返回此BigInteger的最小二进制补码表示中的位数， 不包括符号位。

bytebyteValueExact()

将 BigInteger转换为 byte ，检查是否丢失了信息。

BigIntegerclearBit​(int n)

返回一个BigInteger，其值等于此BigInteger且指定位已清除。

intcompareTo​(BigInteger val)

将此BigInteger与指定的BigInteger进行比较。

BigIntegerdivide​(BigInteger val)

返回值为 (this / val)的BigInteger。

BigInteger[]divideAndRemainder​(BigInteger val)

返回两个BigIntegers的数组，其中包含 (this / val)后跟 (this % val) 。

doubledoubleValue()

将此BigInteger转换为 double 。

booleanequals​(Object x)

将此BigInteger与指定的Object进行相等性比较。

BigIntegerflipBit​(int n)

返回一个BigInteger，其值等于此BigInteger，并且指定的位被翻转。

floatfloatValue()

将此BigInteger转换为 float 。

BigIntegergcd​(BigInteger val)

返回一个BigInteger，其值是 abs(this)和 abs(val) 。

intgetLowestSetBit()

返回此BigInteger中最右边（最低位）一位的索引（最右边一位右边的零位数）。

inthashCode()

返回此BigInteger的哈希码。

intintValue()

将此BigInteger转换为 int 。

intintValueExact()

将此 BigInteger转换为 int ，检查是否丢失了信息。

booleanisProbablePrime​(int certainty)

返回 true如果此BigInteger可能为素数， false ，如果它一定为合。

longlongValue()

将此BigInteger转换为 long 。

longlongValueExact()

将此 BigInteger转换为 long ，检查是否丢失了信息。

BigIntegermax​(BigInteger val)

返回此BigInteger和 val 。

BigIntegermin​(BigInteger val)

返回此BigInteger和 val 。

BigIntegermod​(BigInteger m)

返回一个值为 (this mod m的BigInteger。

BigIntegermodInverse​(BigInteger m)

返回BigInteger，其值为 (this -1 mod m) 。

BigIntegermodPow​(BigInteger exponent, BigInteger m)

返回一个值为 (thisexponent mod m)的BigInteger。

BigIntegermultiply​(BigInteger val)

返回值为 (this * val)的BigInteger。

BigIntegernegate()

返回值为 (-this)的BigInteger。

BigIntegernextProbablePrime()

返回大于此 BigInteger的第一个整数，该整数可能是素数。

BigIntegernot()

返回一个值为 (~this)的BigInteger。

BigIntegeror​(BigInteger val)

返回一个值为 (this | val)的BigInteger。

BigIntegerpow​(int exponent)

返回值为 (thisexponent)的BigInteger。

static BigIntegerprobablePrime​(int bitLength, Random rnd)

使用指定的bitLength返回可能为素数的正BigInteger。

BigIntegerremainder​(BigInteger val)

返回一个值为 (this % val)的BigInteger。

BigIntegersetBit​(int n)

返回一个BigInteger，其值等于此BigInteger并设置了指定的位。

BigIntegershiftLeft​(int n)

返回值为 (this << n)的BigInteger。

BigIntegershiftRight​(int n)

返回值为 (this >> n)的BigInteger。

shortshortValueExact()

将此 BigInteger转换为 short ，检查是否丢失了信息。

intsignum()

返回此BigInteger的signum函数。

BigIntegersqrt()

返回此BigInteger的整数平方根。

BigInteger[]sqrtAndRemainder()

返回两个BigIntegers的数组，其中包含 s的整数平方根 this及其余部分 this - s*s 。

BigIntegersubtract​(BigInteger val)

返回值为 (this - val)的BigInteger。

booleantestBit​(int n)

当且仅当指定位置位时，返回 true 。

byte[]toByteArray()

返回一个包含此BigInteger的二进制补码表示的字节数组。

StringtoString()

返回此BigInteger的十进制String表示形式。

StringtoString​(int radix)

返回给定基数中此BigInteger的String表示形式。

static BigIntegervalueOf​(long val)

返回一个BigInteger，其值等于指定的 long 。

BigIntegerxor​(BigInteger val)

返回值为 (this ^ val)的BigInteger。

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


public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        String a=Integer.toString(n);
        BigInteger big=new BigInteger(a);
        int b=0;
        for (int i = n-1; i >0; i--) {
            big=big.multiply(new BigInteger(Integer.toString(i)));
        }
        System.out.println(big);
    }
    
}

十二、高精度加法（vip）

资源限制

内存限制：512.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

　　输入两个整数a和b，输出这两个整数的和。a和b都不超过100位。

算法描述

　　由于a和b都比较大，所以不能直接使用语言中的标准数据类型来存储。对于这种问题，一般使用数组来处理。
　　定义一个数组A，A[0]用于存储a的个位，A[1]用于存储a的十位，依此类推。同样可以用一个数组B来存储b。
　　计算c = a + b的时候，首先将A[0]与B[0]相加，如果有进位产生，则把进位（即和的十位数）存入r，把和的个位数存入C[0]，即C[0]等于(A[0]+B[0])%10。然后计算A[1]与B[1]相加，这时还应将低位进上来的值r也加起来，即C[1]应该是A[1]、B[1]和r三个数的和．如果又有进位产生，则仍可将新的进位存入到r中，和的个位存到C[1]中。依此类推，即可求出C的所有位。
　　最后将C输出即可。

输入格式

　　输入包括两行，第一行为一个非负整数a，第二行为一个非负整数b。两个整数都不超过100位，两数的最高位都不是0。

输出格式

　　输出一行，表示a + b的值。

样例输入

20100122201001221234567890
2010012220100122

样例输出

20100122203011233454668012

import javax.sound.midi.Soundbank;
import java.math.BigInteger;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        String a=in.next();
        String b=in.next();
        BigInteger big1=new BigInteger(a);
        BigInteger big2=new BigInteger(b);
        System.out.println(big1.add(big2));
    }
}

十三、矩阵乘法（vip）

资源限制

内存限制：512.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

　　给定一个N阶矩阵A，输出A的M次幂（M是非负整数）
　　例如：
　　A =
　　1 2
　　3 4
　　A的2次幂
　　7 10
　　15 22

输入格式

　　第一行是一个正整数N、M（1<=N<=30, 0<=M<=5），表示矩阵A的阶数和要求的幂数
　　接下来N行，每行N个绝对值不超过10的非负整数，描述矩阵A的值

输出格式

　　输出共N行，每行N个整数，表示A的M次幂所对应的矩阵。相邻的数之间用一个空格隔开

样例输入

2 2
1 2
3 4

样例输出

7 10
15 22

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int m=in.nextInt();
        int[][] a=new int[n][n];

        for (int i = 0; i < n; i++) {
            for (int i1 = 0; i1 < n; i1++) {
                a[i][i1]=in.nextInt();
            }
        }
        if(m==0)
        {
            for (int i = 0; i < n; i++) {
                for (int i1 = 0; i1 < n; i1++) {
                    if(i1==i)
                        System.out.print(1+" ");
                    else
                        System.out.print(0+" ");
                }
                System.out.println();
            }
            return;
        }
        int[][] res=a;
        for (int i = 1; i < m; i++) {
            res=getMatrix(a,res);
        }
        for (int i = 0; i < n; i++) {
            for (int i1 = 0; i1 < n; i1++) {
                System.out.print(res[i][i1]+" ");
            }
            System.out.println();
        }
    }
    static int[][] getMatrix(int[][] a,int[][] res)
    {
        int n=a.length;
        int[][] b=new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int i1 = 0; i1 < n; i1++) {
                for (int i2 = 0; i2 < n; i2++) {
                    b[i][i1]+=a[i][i2]*res[i2][i1];
                }
            }
        }
        return b;
    }
}

十四、字符串对比（vip）

资源限制

内存限制：512.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

　　给定两个仅由大写字母或小写字母组成的字符串(长度介于1到10之间)，它们之间的关系是以下4中情况之一：
　　1：两个字符串长度不等。比如 Beijing 和 Hebei
　　2：两个字符串不仅长度相等，而且相应位置上的字符完全一致(区分大小写)，比如 Beijing 和 Beijing
　　3：两个字符串长度相等，相应位置上的字符仅在不区分大小写的前提下才能达到完全一致（也就是说，它并不满足情况2）。比如 beijing 和 BEIjing
　　4：两个字符串长度相等，但是即使是不区分大小写也不能使这两个字符串一致。比如 Beijing 和 Nanjing
　　编程判断输入的两个字符串之间的关系属于这四类中的哪一类，给出所属的类的编号。

输入格式

　　包括两行，每行都是一个字符串

输出格式

　　仅有一个数字，表明这两个字符串的关系编号

样例输入

BEIjing

beiJing

样例输出

3

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        String str=in.next();
        String str1=in.next();
        System.out.println(Judge(str,str1));
    }
    static int Judge(String str,String str1)
    {
        if(str.length()!=str1.length())
            return 1;
        if(str.equals(str1))
            return 2;
        if(str.toLowerCase().equals(str1.toLowerCase()))
            return 3;
        return 4;

    }
}

十五、时间转换

资源限制

内存限制：512.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

　　给定一个以秒为单位的时间t，要求用“<H>:<M>:<S>”的格式来表示这个时间。<H>表示时间，<M>表示分钟，而<S>表示秒，它们都是整数且没有前导的“0”。例如，若t=0，则应输出是“0:0:0”；若t=3661，则输出“1:1:1”。

输入格式

　　输入只有一行，是一个整数t（0<=t<=86399）。

输出格式

　　输出只有一行，是以“<H>:<M>:<S>”的格式所表示的时间，不包括引号。

样例输入

0

样例输出

0:0:0

样例输入

5436

样例输出

1:30:36


import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int t=in.nextInt();
        int h=t/3600;
        int m=t/60%60;
        int s=t%60;
        System.out.println(h+":"+m+":"+s);
    }
}

第五届蓝桥杯——基础练习：数列排序
爱音乐，爱编程。
12-24 7056
问题描述 　　给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1 输入格式 　　第一行为一个整数n。 　　第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。 输出格式 　　输出一行，按从小到大的顺序输出排序后的数列。 样例输入 5 8 3 6 4 9 样例输出 3 4 6 8 9 问题程序 import java
java蓝桥杯 试题-基础练习-数列排序
qq_coding的博客
01-02 279
试题-基础练习-数列排序 题目 问题描述 　　给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200 输入格式 　　第一行为一个整数n。 　　第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。 输出格式 　　输出一行，按从小到大的顺序输出排序后的数列。 样例输入 5 8 3 6 4 9 样例输出 3 4 6 8 9 代码 冒泡排序：外层n-1；内层n-i-1 记得关闭Scanner package other.lanqiao.practiceBase; im
蓝桥杯JAVA基础速刷题（1）
m0_74408723的博客
01-13 256
当他面对一块矩形材料时，他总是从中间切割一刀，切出一块最大的正方形，剩下一块矩形，然后再切割剩下的矩形材料，直到全部切为正方形为止。例如，对于一块两边分别为5和3的材料（记为5×3），小明会依次切出3×3、2×2、1×1、1×1共4个正方形。他决定再X星站打工。比如：1，4，5，6，9，24，25，...;请你计算一下，在10^4以内的数字（指该数字，并非它立方后的数值）。小明对数位中含有2、0、1、9的数字很感兴趣，在1到40中这样的数包括1、2、9、10至32、39和40，共28个，他们的和是574。
蓝桥杯 数字判定 Java实现
weixin_46110492的博客
07-11 160
算法训练 判定数字 时间限制：1.0s 内存限制：512.0MB 　　编写函数，判断某个给定字符是否为数字。 样例输入 9 样例输出 yes 代码： ———————————————————————— import java.util.Scanner; public class Main{ public static void main(String[] args) { Scanner sc=new Scanner(System.in); String str=sc.next(); char[]a=str.
蓝桥杯练习题和真题（含代码）
01-19
包含最近几年蓝桥杯的编程题目，有题目和通过的代码，一共几千道题目，格式为cpp
算法-蓝桥杯习题（七）
weixin_30522095的博客
01-09 927
蓝桥杯习题 蓝桥杯练习系统习题加答案更新新地址（已更新200左右习题） http://blog.csdn.net/rodestillfaraway 目录 算法训练（详见 算法-蓝桥杯习题（一））Go 算法训练（详见 算法-蓝桥杯习题（二））Go 算法提高（waiting...） 历届试题（详见 算法-蓝桥杯习题（六））Go 历届试题（详见 算法-蓝桥杯习题（七））...
Java实现 蓝桥杯 算法提高 最大值路径
南 墙
02-11 1万+
试题 算法提高 最大值路径 资源限制 时间限制：1.0s 内存限制：256.0MB 问题描述 　　刷微博，编程序。如下图所示，@北京发布 提出了如下“头脑震荡”问题。对此问题做一般化描述： 　　有n阶方阵，从矩阵的左下角元素为起点，从行或列（水平或垂直）两个方向上移动，直到右上角。求出有多少条路径可以使得经过的元素累加值最大，最大值是多少。 输入格式 　　共有n+1行。 　　第一行整数n，表...
蓝桥杯介绍-参加比赛心得-往年试题-相关练习-蓝桥杯-计算机-比赛-算法竞赛
01-20
比赛涵盖多个领域，包括C/C++程序设计、Java程序设计、Python程序设计、嵌入式系统开发、网页设计与制作以及信息安全技术等，通过机试形式考核参赛者的编程能力和解决问题的能力。 参加蓝桥杯，提前准备至关重要。...
蓝桥杯 - 蓝桥杯竞赛 - 算法开发
10-28
在这一部分中，参赛者通常需要利用计算机编程语言，如C/C++、Java或Python等，来解决一系列算法问题。这些问题可能涵盖数据结构、图论、动态规划、搜索算法等多个计算机科学领域。通过这样的竞赛，参赛者能够锻炼...
蓝桥杯C-C++，Java组备考.zip
最新发布
03-12
从文件信息来看，压缩包包含了与蓝桥杯C/C++组和Java组相关的备考内容，其中的“项目源码”很可能指的是参赛者在准备竞赛时编写的源代码。这些代码应该是参赛者在准备过程中对特定问题的编程实践和解决方案。尽管...
**蓝桥杯--试题 基础练习 字母图形**
weixin_44035979的博客
08-27 382
蓝桥杯–试题 基础练习 字母图形 资源限制 时间限制：1.0s 内存限制：256.0MB 问题描述 利用字母可以组成一些美丽的图形，下面给出了一个例子： ABCDEFG BABCDEF CBABCDE DCBABCD EDCBABC 这是一个5行7列的图形，请找出这个图形的规律，并输出一个n行m列的图形。 输入格式 输入一行，包含两个整数n和m，分别表示你要输出的图形的行数的列数。 输出格式 输出n行，每个m个字符，为你的图形。 样例输入 5 7 样例输出 ABCDEFG BABCDEF CBABCDE
蓝桥杯—对局匹配（JAVA实现）
学海无涯乐作舟
03-24 1031
文章目录一、题目二、解题思路三、代码实现 一、题目 资源限制 时间限制：1.0s 内存限制：256.0MB 问题描述 　　小明喜欢在一个围棋网站上找别人在线对弈。这个网站上所有注册用户都有一个积分，代表他的围棋水平。 小明发现网站的自动对局系统在匹配对手时，只会将积分差恰好是K的两名用户匹配在一起。如果两人分差小于或大于K，系统都不会将他们匹配。 现在小明知道这个网站总共有N名用户，以及他们的...
蓝桥杯题目练习 基础篇 [蓝桥杯2018初赛]星期一
Ace_bb的博客
02-11 1056
星期一 题目描述 整个20世纪(1901年1月1日至2000年12月31日之间)，一共有多少个星期一？ (不要告诉我你不知道今天是星期几) 输出 输出一个整数表示答案 思路 非常简单，直接计算从1901年1月1日至2000年12月31日之间一共有多少天，然后除以7，就是了。 代码： #include <iostream> #include <cmath> using nam...
蓝桥杯（Java）注意事项
热门推荐
哈哈er的博客
02-25 2万+
蓝桥杯Java注意事项 常用技巧 输入输出 字符串操作 Java数组基本操作 数据格式化 eclipse快捷键 编程技巧 蓝桥杯Java注意事项 类名称必须采用public class Main方式命名 整数之间的运算为整数。 int的取值范围为（-2147483648~2147483647），占用4个字节（-2的31次方到2的31次方-1），一个字节占8位，也就是32位。 所...
“蓝桥杯”练习系统练习题答案（自己做的）
李英俊小朋友
03-23 9351
题目来源： 蓝桥杯练习系统（写博客日期为2019.3.23，所以可能读者看到的时候，更新了新的题） 这里只提供每道题的我的解题代码，仅供参考。这里不会写解题思路和详解，如果有需要的话，请留言给我，我会在留言区回复。vip题目来源dotcpp（顺序跟练习系统一样，只不过我没有vip，所以在dotcpp网站中看题并解题）。 试题集截图： 目录 入门训练： 1-1BEGIN-1...
蓝桥杯试题练习
蜗牛转转的博客
05-03 214
今天练习一道蓝桥杯试题 题目叫做：母牛的故事 有兴趣的可以去网上搜索一下，今天呢我们采用递归的方式解决这道题目。 题目描述：有一头母牛，它每年年初生一头小母牛。每头小母牛从第四个年头开始，每年年初也生一头小母牛。请编程实现在第n年的时候，共有多少头母牛？ 输入：输入数据由多个测试实例组成，每个测试实例占一行，包括一个整数n(0<n<55)，n的含义如题目中描述。n=0表示输入数据的结束，不做处理。 输出：对于每个测试实例，输出在第n年的时候母牛的数量。每个输出占一行。 样例输入：
蓝桥杯练习题库——基础练习（更新中）
qq_41176515的博客
03-04 2869
方法一： import java.math.BigInteger; import java.util.*; class Main{ public static void main(String[] args) { Scanner scan=new Scanner(System.in); int n=scan.nextInt(); BigInteger s=BigInteger....
算法-蓝桥杯习题（六）
weixin_30713953的博客
01-09 2460
蓝桥杯习题 蓝桥杯练习系统习题加答案更新新地址（已更新200左右习题） http://blog.csdn.net/rodestillfaraway 目录 算法训练（详见 算法-蓝桥杯习题（一））Go 算法训练（详见 算法-蓝桥杯习题（二））Go 算法提高（waiting...） 历届试题（详见 算法-蓝桥杯习题（六））Go 历届试题（详见 算法-蓝桥杯习题（七））...
Java实现蓝桥杯历届试题买不到的数目
06-04 5548
历届试题 买不到的数目 时间限制：1.0s 内存限制：256.0MB 提交此题 锦囊1 锦囊2 问题描述 小明开...
蓝桥杯C-C++项目练习源码解析
蓝桥杯分为多个赛程，包括但不限于C/C++程序设计、Java程序设计、软件测试等项目，其中C/C++项目一直以来都是该竞赛中最受欢迎的部分之一。 标题“蓝桥杯平时练习代码（C-C++）.zip”暗示了这份压缩文件内含的是为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值