该博客围绕蓝桥杯Java算法题展开，涵盖十六进制与八进制、十进制的相互转换，回文数、杨辉三角、查找整数等多种题型。介绍了各题的问题描述、输入输出格式，给出解题思路，部分题目还对比不同实现方式的优劣，涉及BigInteger类等知识。
一、十六进制转八进制
资源限制
内存限制：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 5Data
样例输出
5 -2 11Data
数据规模和约定
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-1mod 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);
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
