目录
1.数列排序
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200
输入格式
第一行为一个整数n。
第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。输出格式
输出一行，按从小到大的顺序输出排序后的数列。
样例输入
5
8 3 6 4 9样例输出
3 4 6 8 9
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;
n = sc.nextInt();
int f[] = new int[n]; //创建数组
for(int i = 0;i<n;i++){ //待排数组
f[i] = sc.nextInt();
}
Arrays.sort(f); // Arrays.sort(f,1,4); //排序子数组
for(int j = 0;j<n;j++){ //排序后的数组
System.out.print(f[j]+" ");
}
}
}1、Arrays.sort(int[] a)
这种形式是对一个数组的所有元素进行排序，并且是按从小到大的顺序。
2、Arrays.sort(int[] a, int fromIndex, int toIndex)
这种形式是对数组部分排序，也就是对数组a的下标从fromIndex到toIndex-1的元素排序，注意：下标为toIndex的元素不参与排序。
例如：Arrays.sort(f,1,4)
2.A+B问题
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
输入A、B，输出A+B。
输入格式
输入的第一行包括两个整数，由空格分隔，分别表示A、B。
输出格式
输出一行，包括一个整数，表示A+B的值。
样例输入
12 45
样例输出
57
数据规模与约定
-10000 <= A, B <= 10000。
import java.util.*;
public class Main{
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
Integer a = sc.nextInt();
Integer b = sc.nextInt();
System.out.println(a + b);
}
}3.十六进制转八进制
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
给定n个十六进制正整数，输出它们对应的八进制数。
输入格式
输入的第一行为一个正整数n （1<=n<=10）。
接下来n行，每行一个由0~9、大写字母A~F组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。
输出格式
输出n行，每行为输入对应的八进制正整数。
【注意】
输入的十六进制数不会有前导0，比如012A。
输出的八进制数也不能有前导0。
样例输入
2
39
123ABC
样例输出
71
4435274
【提示】
先将十六进制数转换成某进制数，再由某进制数转换成八进制。
import java.util.Scanner;
public class Main {
//定义常量字符串数组
static String[] bin = { "0000", "0001", "0010", "0011", "0100", "0101",
"0110", "0111", "1000", "1001", "1010", "1011", "1100", "1101",
"1110", "1111" };
static String[] oct = { "0", "1", "2", "3", "4", "5", "6", "7" };
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int n = s.nextInt(); //n个十六进制正整数
String[] str = new String[n]; //接收十六进制正整数的数组
//接收十六进制正整数
for (int i = 0; i < n; i++) {
str[i] = s.next();
}
for(int i=0; i<n; i++) {
String result = hexToBin(str[i]).toString(); //十六进制转换成二进制
String octResult = binToOct(result); //二进制转换成八进制
if(octResult.startsWith("0")) {
octResult = octResult.substring(1);
//substring(int beginIndex)返回一个新的字符串，它是此字符串的一个子字符串。
//该子字符串从指定索引处的字符开始，直到此字符串末尾。
}
if(octResult.startsWith("0")) {
octResult = octResult.substring(1);
}
System.out.println(octResult);
}
}
//十六进制转换成二进制
private static StringBuffer hexToBin(String str) {
int length = str.length();
int start = 0;
int end = 1;
StringBuffer result = new StringBuffer();
for (int i = 0; i < length; i++) {
/*
* substring(int beginIndex,int endIndex)返回一个新字符串，它是此字符串的一个子字符串。
* 该子字符串从指定的 beginIndex 处开始，直到索引 endIndex - 1 处的字符。
* 因此，该子字符串的长度为 endIndex-beginIndex。
*/
String subStr = str.substring(start, end); //抽取一个十六进制字符
start++;
end++;
String s = transform(subStr); //将抽取的十六进制字符转换成二进制字符
result.append(s);
}
return result;
}
//二进制转换成八进制
private static String binToOct(String str) {
int length = str.length();
/*
* 二进制字符串的长度不是3的整数倍的时候，就要在字符串的前面补上相应个数的 ‘0’
* 来让二进制字符串的长度变成3的整数倍
*/
if(length % 3 == 1) {
str= "00"+str;
} else if(length % 3 == 2) {
str = "0"+str;
}
int start = 0;
int end = 3;
StringBuffer sb = new StringBuffer();
for(int i=0; i<str.length()/3; i++) {
String subStr = str.substring(start, end); //抽取三个二进制字符
start += 3;
end += 3;
String s = transform2(subStr); //将抽取的二进制字符串转换成八进制字符
sb.append(s);
}
return sb.toString();
}
//将抽取的十六进制字符转换成二进制字符
private static String transform(String str) {
String result = "";
switch (str) {
case "0": result = bin[0]; break;
case "1": result = bin[1]; break;
case "2": result = bin[2]; break;
case "3": result = bin[3]; break;
case "4": result = bin[4]; break;
case "5": result = bin[5]; break;
case "6": result = bin[6]; break;
case "7": result = bin[7]; break;
case "8": result = bin[8]; break;
case "9": result = bin[9]; break;
case "A": result = bin[10]; break;
case "B": result = bin[11]; break;
case "C": result = bin[12]; break;
case "D": result = bin[13]; break;
case "E": result = bin[14]; break;
case "F": result = bin[15]; break;
default: break;
}
return result;
}
//将抽取的二进制字符串转换成八进制字符
private static String transform2(String str) {
String result = "";
switch (str) {
case "000": result = oct[0]; break;
case "001": result = oct[1]; break;
case "010": result = oct[2]; break;
case "011": result = oct[3]; break;
case "100": result = oct[4]; break;
case "101": result = oct[5]; break;
case "110": result = oct[6]; break;
case "111": result = oct[7]; break;
}
return result;
}
}4.十六进制转十进制
问题描述
从键盘输入一个不超过8位的正的十六进制数字符串，将它转换为正的十进制数后输出。
注：十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。样例输入
FFFF
样例输出
65535
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String string = scanner.nextLine();
System.out.print(Long.valueOf(string,16));
}
}5.十进制转十六进制
资源限制
时间限制：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 scanner = new Scanner(System.in);
int n = scanner.nextInt();
System.out.printf("%X", n);
}
}
6.特殊回文数
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
123321是一个非常特殊的数，它从左边读和从右边读是一样的。
输入一个正整数n， 编程求所有这样的五位和六位十进制数，满足各位数字之和等于n 。
输入格式
输入一行，包含一个正整数n。
输出格式
按从小到大的顺序输出满足条件的整数，每个整数占一行。
样例输入
52
样例输出
899998
989989
998899
数据规模和约定
1<=n<=54。
【解析】枚举所有的五位六位整数，将它们的个十百千万（十万）位分别分离出来，然后判断是否是回文数并且各位数字的和满足输入的数。注意区分五位数、六位数两种情况。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
for(int i = 10000; i <= 999999; i++) {
if (i < 100000) {
int g = i / 1 % 10; //个位数字
int s = i / 10 % 10; //十位数字
int b = i / 100 % 10; //百位数字
int q = i / 1000 % 10; //千位数字
int w = i / 10000 % 10; //万位数字
if (g == w && s == q && g+s+b+q+w == n) {
System.out.println(i);
}
}else {
int g = i / 1 % 10; //个位数字
int s = i / 10 % 10; //十位数字
int b = i / 100 % 10; //百位数字
int q = i / 1000 % 10; //千位数字
int w = i / 10000 % 10; //万位数字
int sw = i / 100000 % 10; //十万位数字
if (g == sw && s == w && b == q && g+s+b+q+w+sw == n) {
System.out.println(i);
}
}
}
}
}【解析】用两重循环分别遍历五位数或六位数各位上的数字，若各位数字的和满足输入的数，则将其乘以该位上的权值求和即可。
当为5位数时，个位与万位（i）、十位与千位(j)、百位(k)的数字是相同的。
当为6位数时，个位与十万位(i)、十位与万位(j)、百位与千位(k)的数字是相同的。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int sum = 0;
//5位数
for (int i = 1; i < 10; i++) {
for(int j = 0; j < 10; j++) {
for(int k = 0; k < 10; k++) {
if (2 * (i + j) + k == n) {
sum = i * 10001 + j * 1010 + k * 100;
System.out.println(sum);
}
}
}
}
//6位数
for (int i = 1; i < 10; i++) {
for(int j = 0; j < 10; j++) {
for(int k = 0; k < 10; k++) {
if (2 * (i + j + k) == n) {
sum = i * 100001 + j * 10010 + k * 1100;
System.out.println(sum);
}
}
}
}
}
}7.回文数
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
1221是一个非常特殊的数，它从左边读和从右边读是一样的，编程求所有这样的四位十进制数。
输出格式
按从小到大的顺序输出满足条件的四位十进制数。
【解析】求出每一位的数字，然后，判断。
public class Main{
public static void main(String args[]){
for (int i=1000;i<10000;i++){
int ge=i/1000;
int shi=i%1000/100;
int bai=i%100/10;
int qian=i%10;
int a=qian*1000+bai*100+shi*10+ge;
if (a==i){
System.out.println(i);
}
}
}
}【解析】转换成字符串进行判断
public class Main{
public static void main(String args[]){
String a;
for (int i=1000;i<10000;i++){
a=String.valueOf(i); //字符串转数字 Integer.valueOf("12")
//数字转字符串 String.valueOf(12)
StringBuilder b=new StringBuilder(a); //这里要把String转变为StringBuilder，不然不能用下一句的reverse
b.reverse();
String c=new String(b); //这里就是再把StringBuilder转换成String
if (a.equals(c)){ //字符串的对等对比要用equals，==是用来判断数字的
System.out.println(i); //相同的字符串，如果用==，结果也是FALSE
}
}
}
}8.特殊的数字
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
153是一个非常特殊的数，它等于它的每位数字的立方和，即153=1*1*1+5*5*5+3*3*3。编程求所有满足这种条件的三位十进制数。
输出格式
按从小到大的顺序输出满足条件的三位十进制数，每个数占一行。
public class Main {
public static void main(String[] args) {
//遍历所有的三位十进制数
for(int i=100;i<1000;i++) {
int a=i / 100; //求出百位上的数
int b=i /10 % 10; //求出十位上的数
int c=i % 10; //求出个位上的数
if(a*a*a+b*b*b+c*c*c==i) {
System.out.println(i);
}
}
}
}public class Main {
static int a ,b ,c;
public static void function(){
for(int i =100;i<1000;i++){
a=i/100;
b=i%10;
c=(i/10)%10;
if(Math.pow(a,3) + (Math.pow(b,3)) + (Math.pow(c, 3))==(i)){
System.out.println(i);
}
}
}
public static void main(String [] args){
function();
}
}Math.pow(底数,几次方)
Math.pow(a,3)：求a的3次方
9.杨辉三角形
资源限制
时间限制：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 in = new Scanner(System.in);
int n = in.nextInt();
int[][] a = new int [35][35];
for (int i=1; i<=n; i++) {
for(int j=1; j<=i; j++) {
if (j==1 || i==j) a[i][j]=1;
else a[i][j] = a[i-1][j-1] + a[i-1][j];
System.out.print(a[i][j]+" ");
}
System.out.println();
}
}
}10.查找整数
资源限制
时间限制：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。
【解析】顺序遍历数组，如果相等则记录一下这个数值在数组的下标，因为顺序是从1开始的，所以+1，最后判断一下这个值是否大于0，大于0 则找到输出下标，小于等于0，则说明不存在，则输出-1。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();
int[] numArray = new int[num];
int index = 0;
for(int i=0;i<num;i++){
numArray[i] = scanner.nextInt();
}
int findNum = scanner.nextInt();
for(int k=0;k<numArray.length;k++){
if(numArray[k] == findNum){
index = k+1;
break;
}
}
if(index > 0){
System.out.println(index);
}else {
System.out.println(index-1);
}
}
} 11.数列特征
资源限制
时间限制：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.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();//个数n
int[] a = new int[n];
int sum = 0;
for(int i = 0 ; i < n; i++) {
a[i] = sc.nextInt();//输入数组
sum += a[i];//求和
}
Arrays.sort(a);//从小到大排序
System.out.println(a[n-1]);//最大值
System.out.println(a[0]);//最小值
System.out.println(sum);//和
}
}12.字母图形
资源限制
时间限制：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();//列数
for(int i = 0 ; i < n; i++) {
for(int j = 0 ; j < m ;j++) {
char c = (char)(Math.abs(i - j) + 'A');
System.out.print(c);
}
System.out.println();
}
}
}Math.abs(num)：返回num的绝对值 。
char(int)：根据ascii码取得其对应的字符。
13.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 < Math.pow(2, 5); i++) {
String s=Integer.toBinaryString(i).toString();
int l=5-s.length();
for (int j = 0; j < l; j++) {
s="0"+s;
}
System.out.println(s);
}
}
}Math.pow(底数,几次方)
Integer.toBinaryString(int i)：返回int变量的二进制表示的字符串。
toString() : 把对象转成字符串
14.闰年判断
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
给定一个年份，判断这一年是不是闰年。
当以下情况之一满足时，这一年是闰年：
1. 年份是4的倍数而不是100的倍数；
2. 年份是400的倍数。
其他的年份都不是闰年。
输入格式
输入包含一个整数y，表示当前的年份。
输出格式
输出一行，如果给定的年份是闰年，则输出yes，否则输出no。
样例输入
2013
样例输出
no
样例输入
2016
样例输出
yes
数据规模与约定
1990 <= y <= 2050。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int year = scanner.nextInt();
if (year % 4 == 0 && year != 100 || year % 400 == 0) {
System.out.println("yes");
} else {
System.out.println("no");
}
}
}15.Fibonacci数列
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中F1=F2=1。
当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。
输入格式
输入包含一个整数n。
输出格式
输出一行，包含一个整数，表示Fn除以10007的余数。
说明：在本题中，答案是要求Fn除以10007的余数，因此我们只要能算出这个余数即可，而不需要先计算出Fn的准确值，再将计算的结果除以10007取余数，直接计算余数往往比先算出原数再取余简单。
样例输入
10
样例输出
55
样例输入
22
样例输出
7704
数据规模与约定
1 <= n <= 1,000,000。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
int[] a = new int[10000001];
a[1] = 1;
a[2] = 1;
int n;
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
for (int i=3; i<=n; i++){
a[i] = (a[i-1]+a[i-2])%10007;
}
System.out.println(a[n]);
}
}16.圆的面积
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
给定圆的半径r，求圆的面积。
输入格式
输入包含一个整数r，表示圆的半径。
输出格式
输出一行，包含一个实数，四舍五入保留小数点后7位，表示圆的面积。
说明：在本题中，输入是一个整数，但是输出是一个实数。
对于实数输出的问题，请一定看清楚实数输出的要求，比如本题中要求保留小数点后7位，则你的程序必须严格的输出7位小数，输出过多或者过少的小数位数都是不行的，都会被认为错误。
实数输出的问题如果没有特别说明，舍入都是按四舍五入进行。
样例输入
4
样例输出
50.2654825
数据规模与约定
1 <= r <= 10000。
提示
本题对精度要求较高，请注意π的值应该取较精确的值。你可以使用常量来表示π，比如PI=3.14159265358979323，也可以使用数学公式来求π，比如PI=atan(1.0)*4。
import java.text.DecimalFormat;
import java.util.Scanner;
public class Main{
public static double PI=3.14159265358979323;
static DecimalFormat df = new DecimalFormat(".0000000");
public static void main(String[] args){
Scanner input=new Scanner(System.in);
int r=input.nextInt();
double s=PI*r*r;
System.out.println(df.format(s));
}
}17.序列求和
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
求1+2+3+...+n的值。
输入格式
输入包括一个整数n。
输出格式
输出一行，包括一个整数，表示1+2+3+...+n的值。
样例输入
4
样例输出
10
样例输入
100
说明：有一些试题会给出多组样例输入输出以帮助你更好的做题。
一般在提交之前所有这些样例都需要测试通过才行，但这不代表这几组样例数据都正确了你的程序就是完全正确的，潜在的错误可能仍然导致你的得分较低。
样例输出
5050
数据规模与约定
1 <= n <= 1,000,000,000。
说明：请注意这里的数据规模。
本题直接的想法是直接使用一个循环来累加，然而，当数据规模很大时，这种“暴力”的方法往往会导致超时。此时你需要想想其他方法。你可以试一试，如果使用1000000000作为你的程序的输入，你的程序是不是能在规定的上面规定的时限内运行出来。
本题另一个要值得注意的地方是答案的大小不在你的语言默认的整型(int)范围内，如果使用整型来保存结果，会导致结果错误。
如果你使用C++或C语言而且准备使用printf输出结果，则你的格式字符串应该写成%I64d以输出long long类型的整数。
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Integer n = scanner.nextInt();
long sum = 0;
for(int i = 1;i <= n;i++){
sum += i;
}
System.out.println(sum);
}
}
929
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
