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

一、十六进制转八进制

资源限制

内存限制：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类的方法 

变量和类型	方法	描述
BigInteger	abs()	返回一个BigInteger，其值是此BigInteger的绝对值。
BigInteger	add​(BigInteger val)	返回一个值为 (this + val)的BigInteger。
BigInteger	and​(BigInteger val)	返回值为 (this & val)的BigInteger。
BigInteger	andNot​(BigInteger val)	返回值为 (this & ~val)的BigInteger。
int	bitCount()	返回此BigInteger的二进制补码表示中与其符号位不同的位数。
int	bitLength()	返回此BigInteger的最小二进制补码表示中的位数， 不包括符号位。
byte	byteValueExact()	将 BigInteger转换为 byte ，检查是否丢失了信息。
BigInteger	clearBit​(int n)	返回一个BigInteger，其值等于此BigInteger且指定位已清除。
int	compareTo​(BigInteger val)	将此BigInteger与指定的BigInteger进行比较。
BigInteger	divide​(BigInteger val)	返回值为 (this / val)的BigInteger。
BigInteger[]	divideAndRemainder​(BigInteger val)	返回两个BigIntegers的数组，其中包含 (this / val)后跟 (this % val) 。
double	doubleValue()	将此BigInteger转换为 double 。
boolean	equals​(Object x)	将此BigInteger与指定的Object进行相等性比较。
BigInteger	flipBit​(int n)	返回一个BigInteger，其值等于此BigInteger，并且指定的位被翻转。
float	floatValue()	将此BigInteger转换为 float 。
BigInteger	gcd​(BigInteger val)	返回一个BigInteger，其值是 abs(this)和 abs(val) 。
int	getLowestSetBit()	返回此BigInteger中最右边（最低位）一位的索引（最右边一位右边的零位数）。
int	hashCode()	返回此BigInteger的哈希码。
int	intValue()	将此BigInteger转换为 int 。
int	intValueExact()	将此 BigInteger转换为 int ，检查是否丢失了信息。
boolean	isProbablePrime​(int certainty)	返回 true如果此BigInteger可能为素数， false ，如果它一定为合。
long	longValue()	将此BigInteger转换为 long 。
long	longValueExact()	将此 BigInteger转换为 long ，检查是否丢失了信息。
BigInteger	max​(BigInteger val)	返回此BigInteger和 val 。
BigInteger	min​(BigInteger val)	返回此BigInteger和 val 。
BigInteger	mod​(BigInteger m)	返回一个值为 (this mod m的BigInteger。
BigInteger	modInverse​(BigInteger m)	返回BigInteger，其值为 (this -1 mod m) 。
BigInteger	modPow​(BigInteger exponent, BigInteger m)	返回一个值为 (thisexponent mod m)的BigInteger。
BigInteger	multiply​(BigInteger val)	返回值为 (this * val)的BigInteger。
BigInteger	negate()	返回值为 (-this)的BigInteger。
BigInteger	nextProbablePrime()	返回大于此 BigInteger的第一个整数，该整数可能是素数。
BigInteger	not()	返回一个值为 (~this)的BigInteger。
BigInteger	or​(BigInteger val)	返回一个值为 (this | val)的BigInteger。
BigInteger	pow​(int exponent)	返回值为 (thisexponent)的BigInteger。
static BigInteger	probablePrime​(int bitLength, Random rnd)	使用指定的bitLength返回可能为素数的正BigInteger。
BigInteger	remainder​(BigInteger val)	返回一个值为 (this % val)的BigInteger。
BigInteger	setBit​(int n)	返回一个BigInteger，其值等于此BigInteger并设置了指定的位。
BigInteger	shiftLeft​(int n)	返回值为 (this << n)的BigInteger。
BigInteger	shiftRight​(int n)	返回值为 (this >> n)的BigInteger。
short	shortValueExact()	将此 BigInteger转换为 short ，检查是否丢失了信息。
int	signum()	返回此BigInteger的signum函数。
BigInteger	sqrt()	返回此BigInteger的整数平方根。
BigInteger[]	sqrtAndRemainder()	返回两个BigIntegers的数组，其中包含 s的整数平方根 this及其余部分 this - s*s 。
BigInteger	subtract​(BigInteger val)	返回值为 (this - val)的BigInteger。
boolean	testBit​(int n)	当且仅当指定位置位时，返回 true 。
byte[]	toByteArray()	返回一个包含此BigInteger的二进制补码表示的字节数组。
String	toString()	返回此BigInteger的十进制String表示形式。
String	toString​(int radix)	返回给定基数中此BigInteger的String表示形式。
static BigInteger	valueOf​(long val)	返回一个BigInteger，其值等于指定的 long 。
BigInteger	xor​(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);
    }
}