「是否连续正整数之和A一递归」
代码案例解析
import java.util.Scanner;
public class 是否连续正整数之和A一递归 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
boolean isYes = checkNum(in.nextInt());
if (isYes) {
System.out.println("YES");
} else {
System.out.println("NO");
}
}
private static boolean checkNum(int num){
boolean isYes = false;
if (num>2){
if (num%2!=0){
isYes = true;
}else {
return checkNum(num/2);
}
}
return isYes;
}
}
「是否连续正整数之和B一划窗」
代码案例解析
import java.util.Scanner;
public class 是否连续正整数之和B一划窗 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int n = s.nextInt();
int left = 1;
int right = 1;
int count = 0;
while (left <= right && right <= n) {
if (count == n) {
System.out.println("YES");
return;
} else if (count > n) {
count = count - left;
left = left + 1;
continue;
} else {
count = count + right;
right = right + 1;
}
}
/**
* 1 2 3 4 5 15
* -1 -2 -3 9
* 6 15
* -4 11
*/
System.out.println("NO");
}
}
「求幂」
题目描述
涉及计算非常大的量值和精度的精确值的问题很常见。例如,对于许多计算机系统来说,国债的计算是一项繁重的工作。
此问题要求您编写一个程序来计算 R n的精确值,其中 R 是实数 ( 0.0 < R < 99.999 ),n 是 0 < n ≤ 25 的整数。
输入
输入将由一组 R 和 n 值对组成。R 值将占据第 1 至 6 列,n 值将占据第 8 和 9 列。
输出
输出将由一行组成,每一行输入给出 R n的精确值。输出中应抑制前导零。不得打印无意义的尾随零。如果结果是整数,则不打印小数点。
输入样例 1
95.123 12
0.4321 20
5.1234 15
6.7592 9
98.999 10
1.0100 12
输出样例 1
548815620517731830194541.899025343415715973535967221869852721
.00000005148554641076956121994511276767154838481760200726351203835429763013462401
43992025569.928573701266488041146654993318703707511666295476720493953024
29448126.764121021618164430206909037173276672
90429072743629540498.107596019456651774561044010001
1.126825030131969720661201
代码案例解析
import java.math.BigDecimal;
import java.util.Scanner;
public class 求幂 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNext()){
BigDecimal a = new BigDecimal(in.next());
int b = in.nextInt();
String str = a.pow(b).stripTrailingZeros().toPlainString();
if(str.startsWith("0."))
System.out.println(str.substring(1));
else
System.out.println(str);
}
}
}
「矩阵连词」
题目描述
Word Maze 是一个网络小游戏,你需要找到以字母标注的食物,但要求以给定单词字母的顺序吃掉。假设给定单词if,你必须先吃掉i然后才能吃掉f。
但现在你的任务可没有这么简单,你现在处于一个迷宫Maze(n×m的矩阵)当中,里面到处都是以字母标注的食物,但你只能吃掉能连成给定单词W的食物。
注意区分英文字母大小写,并且你只能上下左右行走。
输入
输入第一行包含两个整数n、m(0<n,m<21)分别表示n行m列的矩阵,第二行是长度不超过100的单词W,从第3行到第n+2行是只包含大小写英文字母的长度为m的字符串。
输出
如果能在地图中连成给定的单词,则输出“YES”,否则输出“NO”。注意:每个字母只能用一次。
输入样例 1
5 5
SOLO
CPUCY
EKLQH
CRSOL
EKLQO
PGRBC
输出样例 1
YES
代码案例解析
import java.util.Scanner;
public class 矩阵连词 {
static String target = "";
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String nAndM = in.nextLine();
String[] rangeArrays = nAndM.split(" ");
int n = Integer.parseInt(rangeArrays[0]); // 行
int m = Integer.parseInt(rangeArrays[1]); // 列
target = in.nextLine();
String[][] maze = new String[n][m];
for (int i=0;i<n;i++){ // 构建矩阵
String row = in.nextLine();
String[] rowArrays = row.split("");
for (int j=0;j<m;j++){
maze[i][j] = rowArrays[j];
}
}
// int n = 4;
// int m = 5;
// target = "solot";
// // a a a a a
// // s o l o l
// // a a a s o
// // a a a a t
// String[][] maze = new String[n][m];
// for (int i=0;i<n;i++){ // 构建矩阵
// String row = "";
// if (i==0){ row = "aaaaa";}
// if (i==1){ row = "solol";}
// if (i==2){ row = "aaaso";}
// if (i==3){ row = "aaaat";}
// String[] rowArrays = row.split("");
// for (int j=0;j<m;j++){
// maze[i][j] = rowArrays[j];
// }
// }
// 遍历矩阵,找到首位坐标后,递归匹配下一个字符
for (int i=0;i<n;i++){
for (int j=0;j<m;j++){
if (findNext(maze,i,j,0)){
System.out.println("YES");
return;
}
}
}
System.out.println("NO");
}
/**
* 递归判断是否能找到下一位,四个方向分别是n+1,n-1,m+1,m-1
* @param maze 迷宫矩阵
* @param n 当前行坐标
* @param m 当前纵坐标
* @param index 需要匹配的字符串索引
* @return
*/
static boolean findNext(String[][] maze,int n,int m,int index){
// 终止条件1:target字符串全部比对完
if (index>=target.length()){
return true;
}
// 终止条件2:查找的索引越界
if (n<0 || m<0 || n>=maze.length || m>=maze[n].length){
return false;
}
// 找到目标字符后,向四个方向继续匹配
if (maze[n][m].equals(target.substring(index,index+1))){
// 当前位置置空,防止重复“吃”
String temp = maze[n][m];
maze[n][m] = "";
// 四个方向
if (findNext(maze,n+1,m,index+1)){
return true;
}else if (findNext(maze,n-1,m,index+1)){
return true;
}else if (findNext(maze,n,m+1,index+1)){
return true;
}else if (findNext(maze,n,m-1,index+1)){
return true;
}else { // 说明当前位已匹配,下一位匹配不到,还原当前位字符
maze[n][m] = temp;
return false;
}
}else {
return false;
}
}
}
「连续n个整数的最小公倍数」
题目描述
为什么1小时有60分钟,而不是100分钟呢?这是历史上的习惯导致。但也并非纯粹的偶然:60是个优秀的数字,它的因子比较多。事实上,它是1至6的每个数字的倍数。即1,2,3,4,5,6都是可以除尽60。
我们希望寻找到能除尽1至n的的每个数字的最小整数。
输入
输入一个整数n,(1<n<=100),测试包含组样例,读到文件末尾结束。
输出
输出求1至n的最小公倍数。
输入样例 1
6
10
100
输出样例 1
60
2520
69720375229712477164533808935312303556800
代码案例解析
import java.math.BigInteger;
import java.util.Scanner;
public class 连续n个整数的最小公倍数 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNextInt()){
int intN = in.nextInt();
int intNum = intN*(intN-1);
BigInteger num = new BigInteger(intNum+"");
for (int i = intN; i >0; i--) {
if ("0".equals(yuShu(num,i))){
continue;
}else {
// 求最两个数小公倍数
num = getMinBei(num,i);
}
}
System.out.println(num);
}
}
static BigInteger getMinBei(BigInteger num,int intNn){
BigInteger n = new BigInteger(intNn+"");
BigInteger maxYue = new BigInteger("1");
for (int i = (num.compareTo(n)>0?n.intValue():num.intValue()); i > 0; i--) {
if ("0".equals(yuShu(num,i)) && "0".equals(yuShu(n,i))){
maxYue = new BigInteger(i+"");
break;
}
}
return num.multiply(n).divide(maxYue);
}
static String yuShu(BigInteger a, int c){
BigInteger b = new BigInteger(c+"");
BigInteger[] bigIntegers = a.divideAndRemainder(b);
return bigIntegers[1].toString();
}
}
「超过32位的乘法运算」
题目描述
我有一个非常简单的问题要问你。给定两个整数 A 和 B,您的任务是将 A × B 的乘积相乘。
输入
每行将包含两个整数 A 和 B。处理到文件末尾。请注意,整数非常大,这意味着您不应该使用 32 位整数来处理它们。
您可以假设每个整数的长度不会超过 1000。
输出
对于每种情况,在一行中输出 A × B 的乘积。
输入样例 1
1 2
3 11
14512451451245124512 15125125124512451245
输出样例 1
2
33
219502644063494817653152060344354417440
代码案例解析
import java.math.BigInteger;
import java.util.Scanner;
public class 超过32位的乘法运算 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNextBigInteger()){
BigInteger a = sc.nextBigInteger();
BigInteger b = sc.nextBigInteger();
BigInteger sum = a.multiply(b);
System.out.println(sum);
}
}
}
「超过32位的减法运算」
题目描述
我又给你一个非常简单的问题。给定两个整数 A 和 B,您的任务是计算 A - B 的结果。
输入
输入的第一行包含一个整数 T(1<=T<=20),表示测试用例的数量。
接下来是 T 行,每行由两个正整数 A 和 B 组成。请注意,这些整数非常大,这意味着您不应该使用 32 位整数来处理它们。
您可以假设每个整数的长度不会超过 1000。
输出
对于每个测试用例,您应该输出两行。第一行是“Case #:”,#表示测试用例的编号。第二行是方程“A - B = ?”, ? 表示 A - B 的结果。注意方程中有一些空格。在两个测试用例之间输出一个空行。
输入样例 1
3
9 8
12 8
123456789 987654321
输出样例 1
情况1:
9 - 8 = 1
案例2:
12 - 8 = 4
案例3:
123456789 - 987654321 = -864197532
代码案例解析
import java.math.BigInteger;
import java.util.Scanner;
public class 超过32位的减法运算 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int T = sc.nextInt();
StringBuffer sb = new StringBuffer();
for (int i = 1; i <= T; i++) {
BigInteger a = sc.nextBigInteger();
BigInteger b = sc.nextBigInteger();
BigInteger sum = a.subtract(b);
sb.append("Case " + i + ":\r\n");
sb.append(a + " - " + b + " = " + sum+"\r\n");
sb.append("\r\n");
}
System.out.println(sb);
}
}
「超过32位的加法运算」
题目描述
我有一个非常简单的问题要问你。给定两个整数 A 和 B,您的任务是计算 A + B 的总和。
输入
输入的第一行包含一个整数T(1≤T≤20),表示测试用例的数量。
接下来是 T 行,每行由两个正整数 A 和 B 组成。请注意,这些整数非常大,这意味着您不应该使用 32 位整数来处理它们。您可以假设每个整数的长度不会超过1000。
输出
对于每个测试用例,您应该输出两行。第一行是“Case #:”,#表示测试用例的编号。第二行是一个方程“A + B = Sum”,Sum表示A + B的结果。注意方程中有一些空格。在两个测试用例之间输出一个空行。
输入样例 1
2
1 2
112233445566778899 998877665544332211
输出样例 1
1 + 2 = 3
112233445566778899 + 998877665544332211 = 1111111111111111110
代码案例解析
import java.math.BigInteger;
import java.util.Scanner;
public class 超过32位的加法运算 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int T = sc.nextInt();
StringBuffer sb = new StringBuffer();
for (int i = 1; i <= T; i++) {
BigInteger a = sc.nextBigInteger();
BigInteger b = sc.nextBigInteger();
BigInteger sum = a.add(b);
sb.append("Case " + i + ":\r\n");
sb.append(a + " + " + b + " = " + sum+"\r\n");
sb.append("\r\n");
}
System.out.println(sb);
}
}
「阶乘BigInteger版本」
题目描述
给定一个整数 N(0 ≤ N ≤ 10000),你的任务是计算 N!
输入样例 1
3
输出样例 1
6
代码案例解析
import java.math.BigInteger;
import java.util.Scanner;
public class 阶乘 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println(jc(in.nextBigInteger()));
}
static BigInteger jc(BigInteger num){
BigInteger bi0 = new BigInteger("0");
BigInteger bi1 = new BigInteger("1");
if (num.compareTo(bi1)==0 || num.compareTo(bi0)==0){
return bi1;
}
return num.multiply(jc(num.subtract(bi1)));
}
}
「」
代码案例解析
阶乘a
在这里插入代码片