- 01 A+B问题（简单
- 02 序列求和
- 03 圆的面积
- 04 Fibonacci数列
- 1 闰年判断（简单
- 2 01字符串
- 3 字母图形
- 4 数列特征（简单
- 5 查找整数
- 6 杨辉三角
- 7 特殊的数字
- 8 回文数
- 9 特殊回文数
- 10 十进制转十六进制
- 11 十六进制转十进制
- 12 十进制转八进制
- 13 数列排序
- 30 阶乘计算
- 14 时间转换（简单
- 15 字符串对比（简单
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
输入A、B，输出A+B。
输入格式
输入的第一行包括两个整数，由空格分隔，分别表示A、B。
输出格式
输出一行，包括一个整数，表示A+B的值。
样例输入
12 45
样例输出
57
数据规模与约定
-10000 <= A, B <= 10000。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int a=sc.nextInt();
int b=sc.nextInt();
System.out.println(a+b);
}
}
02 序列求和
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
求1+2+3+…+n的值。
输入格式
输入包括一个整数n。
输出格式
输出一行，包括一个整数，表示1+2+3+…+n的值。
样例输入
4
样例输出
10
样例输入
100
样例输出
5050
数据规模与约定
1 <= n <= 1,000,000,000。
int最大为2147483647
该题若用int存储累加结果，会导致n大到一定程度后结果出错
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
long num=0,sum=0;
Scanner a=new Scanner(System.in);
num=a.nextLong();
if(num>=1 && num<=1000000000) {
sum=num+num*(num-1)/2;
System.out.println(sum);
}
}
}
03 圆的面积
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
给定圆的半径r，求圆的面积。
输入格式
输入包含一个整数r，表示圆的半径。
输出格式
输出一行，包含一个实数，四舍五入保留小数点后7位，表示圆的面积。
样例输入
4
样例输出
50.2654825
数据规模与约定
1 <= r <= 10000。
在做乘法时，int与double相乘会导致部分结果错误
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
double r = sc.nextInt();
sc.close();
double PI=3.14159265358979323;
System.out.println(String.format("%.7f", PI*r*r));
}
}
04 Fibonacci数列
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中F1=F2=1。
当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。
输入格式
输入包含一个整数n。
输出格式
输出一行，包含一个整数，表示Fn除以10007的余数。
样例输入
10
样例输出
55
样例输入
22
样例输出
7704
数据规模与约定
1 <= n <= 1,000,000。
一开始想用函数递归调用，结果超时了
static long fib(int i) {
if(i<3)
return 1;
else
return (fib(i-1)+fib(i-2))%10007;
}
后来想到将数列存储在一维数组里，但int型存储长度有限，而1000000的斐波那契数实在太大，导致部分计算错误。
其实本题不要求精确的数值，只要输出余数，可以每次求得斐波那契数列后，直接取余数，这样可以控制数组中的每个数在10007以内。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
sc.close();
//初始化别瞎写，n会导致越界
int[] a=new int[n];
for(int i=0;i1) {
a[i]=(a[i-1]+a[i-2])%10007;
}
}
System.out.println(a[n-1]);
}
}
1 闰年判断（简单
可能每个初学高级语言的人第一道题都是判断闰年吧，题目就不贴了。
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");
}
}
2 01字符串
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
对于长度为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<32;i++) {
System.out.println(i/16%2+""+i/8%2+""+i/4%2+""+i/2%2+""+i%2);
}
}
}
3 字母图形
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
利用字母可以组成一些美丽的图形，下面给出了一个例子：
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
这是一个5行7列的图形，请找出这个图形的规律，并输出一个n行m列的图形。
输入格式
输入一行，包含两个整数n和m，分别表示你要输出的图形的行数的列数。
输出格式
输出n行，每个m个字符，为你的图形。
样例输入
5 7
样例输出
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
数据规模与约定
1 <= n, m <= 26。
这题控制好循环的开始结束就好。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
String str= "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
int w=0;
for(int i=0;i0)
w=i-m;//考虑为负的情况！！！！
for(int j=i;j>w;j--) {
System.out.print(str.charAt(j));
}
for(int j=0;j
4 数列特征（简单
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
给出n个数，找出这n个数的最大值，最小值，和。
输入格式
第一行为整数n，表示数的个数。
第二行有n个数，为给定的n个数，每个数的绝对值都小于10000。
输出格式
输出三行，每行一个整数。第一行表示这些数中的最大值，第二行表示这些数中的最小值，第三行表示这些数的和。
样例输入
5
1 3 -2 4 5
样例输出
5
-2
11
数据规模与约定
1 <= n <= 10000。
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;imax) {
max=a[i];
}
sum=sum+a[i];
}
System.out.println(max);
System.out.println(min);
System.out.println(sum);
}
}
5 查找整数
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
给出一个包含n个整数的数列，问整数a在数列中的第一次出现是第几个。
输入格式
第一行包含一个整数n。
第二行包含n个非负整数，为给定的数列，数列中的每个数都不大于10000。
第三行包含一个整数a，为待查找的数。
输出格式
如果a在数列中出现了，输出它第一次出现的位置(位置从1开始编号)，否则输出-1。
样例输入
6
1 9 4 8 3 9
9
样例输出
2
数据规模与约定
1 <= n <= 1000。
一开始我打算用Arrays.binarySearch，结果有几个测试用例一直出错，后来发现二分法查找必须是有序数组，即sort过的数组。
int index=Arrays.binarySearch(a, s);
if(index<0)
System.out.println(-1);
else
System.out.println(index+1);
后来改的时候我又掉了好多坑，这个题下标是从1开始的，而且只要首次出现的位置，需要及时break防覆盖
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String[] a=new String[n];
for(int i=0;i
6 杨辉三角
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
杨辉三角形又称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();
sc.close();
int[][] arr=new int[n][n];
for(int i=0;i
7 特殊的数字
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
153是一个非常特殊的数，它等于它的每位数字的立方和，即153=111+555+333。编程求所有满足这种条件的三位十进制数。
输出格式
按从小到大的顺序输出满足条件的三位十进制数，每个数占一行。
只要会Math.pow(a, b)函数就简单，a^b
public class Main {
public static void main(String[] args) {
for(int i=100;i<1000;i++) {
int a=i/100,b=i/10%10,c=i%10;
int re=(int) (Math.pow(a, 3)+Math.pow(b, 3)+Math.pow(c, 3));
if(i==re) {
System.out.println(i);
}
}
}
}
8 回文数
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
1221是一个非常特殊的数，它从左边读和从右边读是一样的，编程求所有这样的四位十进制数。
输出格式
按从小到大的顺序输出满足条件的四位十进制数。
只要会用System.out.println(""+i+j+j+i);把整型的按字符串输出就行，我这基本功真是啥也没剩啊。
public class Main {
public static void main(String[] args) {
for (int i = 1; i < 10; i++) {
for (int j = 0; j < 10; j++) {
System.out.println(""+i+j+j+i);
}
}
}
}
9 特殊回文数
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
123321是一个非常特殊的数，它从左边读和从右边读是一样的。
输入一个正整数n， 编程求所有这样的五位和六位十进制数，满足各位数字之和等于n 。
输入格式
输入一行，包含一个正整数n。
输出格式
按从小到大的顺序输出满足条件的整数，每个整数占一行。
样例输入
52
样例输出
899998
989989
998899
数据规模和约定
1<=n<=54。
这题就是求和固定的回文数，跟9题没啥区别，我没注意难度倒着写的，还停留在12题用的字符串，用8题的输出方法 代码会短十几行。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
sc.close();
if(n>0&&n<55) {
for (int i = 1; i < 10; i++) {
for (int j = 0; j < 10; j++) {
for (int k = 0; k < 10; k++) {
if (i * 2 + j * 2 + k == n) {
StringBuffer re=new StringBuffer("");
re.append(i);
re.append(j);
re.append(k);
re.append(j);
re.append(i);
System.out.println(re);
}
}
}
}
for (int i = 1; i < 10; i++) {
for (int j = 0; j < 10; j++) {
for (int k = 0; k < 10; k++) {
if (i * 2 + j * 2 + k*2 == n) {
StringBuffer re=new StringBuffer("");
re.append(i);
re.append(j);
re.append(k);
re.append(k);
re.append(j);
re.append(i);
System.out.println(re);
}
}
}
}
}
}
}
10 十进制转十六进制
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有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 sc = new Scanner(System.in);
int n = sc.nextInt();
StringBuffer re=new StringBuffer("");
String b16 = "0123456789ABCDEF";
if(n==0) {
re.append("0");
}
while (n > 0) {
//%取余 /取除数
String tmp=Character.toString(b16.charAt(n%16));
re.insert(0, tmp);
n=n/16;
}
System.out.println(re);
}
}
11 十六进制转十进制
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
从键盘输入一个不超过8位的正的十六进制数字符串，将它转换为正的十进制数后输出。
注：十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。
样例输入
FFFF
样例输出
65535
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str=sc.next();
String[] b16 = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F" };
long re=0;//int最大2147483647，不够8位正的十六进制
for(int i=0;i
12 十进制转八进制
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
给定n个十六进制正整数，输出它们对应的八进制数。
输入格式
输入的第一行为一个正整数n （1<=n<=10）。
接下来n行，每行一个由09、大写字母AF组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。
输出格式
输出n行，每行为输入对应的八进制正整数。
【注意】
输入的十六进制数不会有前导0，比如012A。
输出的八进制数也不能有前导0。
样例输入
2
39
123ABC
样例输出
71
4435274
一开始想直接用函数转换，后来果不其然又超限了。。。
for(int i=0;i
还是得手动写
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();
String[] a = new String[n];
for (int i = 0; i < n; i++) {
a[i] = sc.next();
}
sc.close();
String[] b16 = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F" };
String[] b2 = { "0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111", "1000", "1001", "1010", "1011",
"1100", "1101", "1110", "1111" };
String[] b8 = { "0", "1", "2", "3", "4", "5", "6", "7" };
for (int m = 0; m < n; m++) {
String c16 = a[m];
StringBuffer c2 = new StringBuffer();
StringBuffer c8 = new StringBuffer();
// 遍历16进制的每一个，去找对应的四位2进制
for (int j = 0; j < c16.length(); j++) {
// 返回一个16进制的字符c
String c = Character.toString(c16.charAt(j));
// 二分法查找字符c对应的坐标
int index = Arrays.binarySearch(b16, c);
c2.append(b2[index]);
}
// 3个二进制表示1个八进制，开头不够需要补齐
while (c2.length() % 3 != 0) {
c2.insert(0, "0");
}
// 8进制长度
int len8 = c2.length() / 3;
// 每次取3位二进制转化为8进制
for (int g = 0; g < len8; g++) {
String tmp = c2.substring(3 * g, 3 * (g + 1));
//2进制需要4位，前补0
int index = Arrays.binarySearch(b2, "0" + tmp);
c8.append(b8[index]);
}
//转化为16进制，把多余的0去掉
while(c8.charAt(0)=='0') {
c8.delete(0, 1);
}
System.out.println(c8.toString());
}
}
}
13 数列排序
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200
输入格式
第一行为一个整数n。
第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。
输出格式
输出一行，按从小到大的顺序输出排序后的数列。
样例输入
5
8 3 6 4 9
样例输出
3 4 6 8 9
函数真香hhhhh
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int a=sc.nextInt();
int[] n=new int[a];
for(int i=0;i
30 阶乘计算
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
输入一个正整数n，输出n!的值。
其中n!=123*…*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
阶乘结果太大了，简单的int不行
int w=1;
for(int i=1;i<=n;i++)
w=w*i;
System.out.println(w);
使用一个数组A来表示一个大整数a，A[0]表示a的个位，A[1]表示a的十位……
将a乘以一个整数k变为将数组A的每一个元素都乘以k，有两个不好控制，一个是进位，另一个是有效的数组长度，可以分别用jin和index表示。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
sc.close();
//初始化
int a[] = new int[10000];
a[1]=1;
int index=1,jin;
for(int i=2;i<=n;i++) {//乘数
jin=0;
for(int j=1;j<=index;j++) {//数组各数
int tmp=a[j]*i+jin;
a[j]=tmp%10;
jin=tmp/10;
}
while(jin>0) {
a[++index]=jin%10;
jin=jin/10;
}
}
for(int m=index;m>0;m--) {
System.out.print(a[m]);
}
}
}
14 时间转换（简单
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
给定一个以秒为单位的时间t，要求用“::”的格式来表示这个时间。表示时间，表示分钟，而表示秒，它们都是整数且没有前导的“0”。例如，若t=0，则应输出是“0:0:0”；若t=3661，则输出“1:1:1”。
输入格式
输入只有一行，是一个整数t（0<=t<=86399）。
输出格式
输出只有一行，是以“::”的格式所表示的时间，不包括引号。
样例输入
0
样例输出
0:0:0
样例输入
5436
样例输出
1:30:36
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t=sc.nextInt();
int[] re=new int[3];
re[0]=t%60;
re[1]=t/60%60;
re[2]=t/3600;
System.out.println(re[2]+":"+re[1]+":"+re[0]);
}
}
15 字符串对比（简单
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
给定两个仅由大写字母或小写字母组成的字符串(长度介于1到10之间)，它们之间的关系是以下4中情况之一：
1：两个字符串长度不等。比如 Beijing 和 Hebei
2：两个字符串不仅长度相等，而且相应位置上的字符完全一致(区分大小写)，比如 Beijing 和 Beijing
3：两个字符串长度相等，相应位置上的字符仅在不区分大小写的前提下才能达到完全一致（也就是说，它并不满足情况2）。比如 beijing 和 BEIjing
4：两个字符串长度相等，但是即使是不区分大小写也不能使这两个字符串一致。比如 Beijing 和 Nanjing
编程判断输入的两个字符串之间的关系属于这四类中的哪一类，给出所属的类的编号。
输入格式
包括两行，每行都是一个字符串
输出格式
仅有一个数字，表明这两个字符串的关系编号
样例输入
BEIjing
样例输出
3
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str1 = sc.next();
String str2 = sc.next();
if(str1.length()==str2.length()) {
if(str1.equals(str2))
System.out.println(2);
else if(str1.equalsIgnoreCase(str2))
System.out.println(3);
else
System.out.println(4);
}
else
System.out.println("1");
}
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）