1. 基础练习 闰年判断
给定一个年份,判断这一年是不是闰年。
当以下情况之一满足时,这一年是闰年:
1. 年份是4的倍数而不是100的倍数;
2. 年份是400的倍数。
其他的年份都不是闰年。
说明:当试题指定你输出一个字符串作为结果(比如本题的yes或者no,你需要严格按照试题中给定的大小写,写错大小写将不得分。
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
int year = input.nextInt();
if(year>=1990 &&year<=2050){
if((year % 4==0 &&year%100!=0) ||(year%400==0))
System.out.println("yes");
else
System.out.println("no");
}
}
}
重点在于判断是否是闰年的语句:if((year % 4==0 &&year%100!=0) ||(year%400==0))
2.基础练习 01字串
问题描述
对于长度为5位的一个01串,每一位都可能是0或1,一共有32种可能。它们的前几个是:
00000
00001
00010
00011
00100
请按从小到大的顺序输出这32种01串。
00001
00010
00011
<以下部分省略>
public class Main {
public static void main(String[] args){
for(int a=0;a<2;a++)
for(int b=0;b<2;b++)
for(int c=0;c<2;c++)
for(int d=0;d<2;d++)
for(int e=0;e<2;e++)
System.out.println("" + a + "" + b + "" + c + "" + d + "" + e);
}
}
方法一:可以使用五层循环将这五位进行排列输出
方法二:将五位01字串转换成二进制数,0~31依次输出转换为二进制数,
注意运用%05d来保证输出的字串为5位右对齐,用0来补齐,对应使用printf进行格式化输出;
十进制转换成二进制是利用Integer.toBinaryString(i),再利用Integer.parseInt()将字符串转换为整型
public class Main {
public static void main(String[] args){
for(int i=0;i<32;i++){
int c=Integer.parseInt(Integer.toBinaryString(i));
System.out.printf("%05d\n",c);
}
}
}
3. 基础练习 字母图形
利用字母可以组成一些美丽的图形,下面给出了一个例子:
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
这是一个5行7列的图形,请找出这个图形的规律,并输出一个n行m列的图形。
BABCDEF
CBABCDE
DCBABCD
EDCBABC
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
int n = input.nextInt();
int m = input.nextInt();
if(n<=26&&m<=26){
for(int i = 0;i<n;i++){
for(int j = 0;j<m;j++){
char str = (char)(Math.abs(i-j)+'A');
System.out.print(str);
}
System.out.println("");
}
}
}
}
char str = (char)(Math.abs(i-j)+'A');关键是观察出行数和列数之差的绝对值控制着数组中某位置的字母。
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
int n = input.nextInt();
int m = input.nextInt();
char f[][]= new char[26][26];
int i=0,j=0;
for(i=0;i<n;i++){
char str = 'A';
for(j=i;j<m;j++){
f[i][j] = str++;
}
str = 'A';
for(j=i-1;j>=0;j--){
f[i][j] = ++str;
}
}
for(i=0;i<n;i++){
for(j=0;j<m;j++){
System.out.print(f[i][j]);
}
System.out.println("");
}
}
}
从一开始就要注意数据的规模与约定,限制二维数组的大小char f[][]= new char[26][26];
先存储数组,再输出数组符号;
存储数组分为两个循环,即将数组分成两部分:第一个循环从A开始向右输出每一行的上三角矩阵部分,第二个循环从右向左输出剩余部分。
System.out.println("");控制换行。4.基础练习 数列特征
给出n个数,找出这n个数的最大值,最小值,和。
第一行为整数n,表示数的个数。
第二行有n个数,为给定的n个数,每个数的绝对值都小于10000。
1 3 -2 4 5
-2
11
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
int n = input.nextInt();
int i=0;
int f[] = new int[10000];
for(i = 0;i<n;i++){
f[i]=input.nextInt();
}
int max = f[0];
int min = f[0];
int sum = 0;
for(i=0;i<n;i++){
if(f[i]>max)
max = f[i];
if(f[i]<min)
min = f[i];
sum = sum+f[i];
}
System.out.println(max);
System.out.println(min);
System.out.println(sum);
}
}
先将数组中的第一个元素设置为最大值和最小值分别存入max和min,然后将数组中的数值和max与min中的数值进行比较,即进行线性查找,同时计算所有元素的和。通过设置int f[] = new int[10000];满足数据规模与约定。
5. 基础练习 查找整数
给出一个包含n个整数的数列,问整数a在数列中的第一次出现是第几个。
第一行包含一个整数n。
第二行包含n个非负整数,为给定的数列,数列中的每个数都不大于10000。
第三行包含一个整数a,为待查找的数。
1 9 4 8 3 9
9
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
int n = input.nextInt();
int f[] = new int[1000];
int i,j,flag=0;
for(i = 0;i<n;i++){
f[i] = input.nextInt();
}
int a = input.nextInt();
for(j = 0;j<n;j++){
if(a == f[j]){
flag = j+1;
break;
}
}
if(flag > 0)
System.out.println(flag);
else
System.out.println(flag-1);
}
}
必须考虑所要查找的数并不在该数列的情况,对此进行处理:若不存在该数,则输出为-1。
break的用法,在找到第一个与数相匹配的位置时应该跳出for循环,只有一层循环用break即可;
如果有多层循环需要直接跳出则使用return;
continue只是结束了本次的循环,跳过其后面的语句直接执行下一次循环,并没有跳出总的循环。
6.基础练习 杨辉三角形
杨辉三角形又称Pascal三角形,它的第i+1行是(a+b)i的展开式的系数。
它的一个重要性质是:三角形中的每个数字等于它两肩上的数字相加。
下面给出了杨辉三角形的前4行:
1
1 1
1 2 1
1 3 3 1
给出n,输出它的前n行。
输入包含一个数n。
1 1
1 2 1
1 3 3 1
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
int n = input.nextInt();
int f[][] = new int[34][34];
int i,j=0;
for(i = 0;i < n;i++){
for(j = 0;j <= i;j++){
if((j == 0 )|| (i == j)){
f[i][j] = 1;
}
else
f[i][j] = f[i-1][j-1]+f[i-1][j];
}
}
for(i = 0;i < n; i++){
for(j = 0;j <= i;j++){
System.out.print(f[i][j]+" ");
}
System.out.println();
}
}
}
二维数组要先进行存储,再进行输出,需要两个for循环,一定要注意第二层循环中j<=i;
再有需要每个数字之间用空格隔开的条件不要忘记;
杨辉三角形的关键在于:第0列以及行数和列数相等的位置处的数均为1,而其余元素满足f[i][j] = f[i-1][j-1]+f[i-1][j];的条件。
7.基础练习 特殊的数字
public class Main {
public static void main(String[] args){
for(int i = 100;i < 1000;i++){
int k = i%10;
int t = i/10%10;
int h = i/100;
int sum = h*h*h + t*t*t + k*k*k;
if(i == sum){
System.out.println(i);
}
}
}
}
考察三位数各个数位的取法。
8.基础练习 回文数
public class Main {
public static void main(String[] args){
for(int i = 1000; i < 10000;i++){
int a = i/1000;
int b = i/100%10;
int c = i/10%10;
int d = i%10;
if(a == d && b == c)
System.out.println(i);
}
}
}
与第7题一样的套路,考察各个数位的取法,最后加一个判断就可以。
这是直接从所有的四位数中依次选择输出符合条件的数字。
有人还用了第二种方法,将四位数所对应的倒序数和原数进行比较,如果相等则为回文数,运用到了字符串的相关知识。
public class Main {
public static void main(String[] args){
String str ;
for(int i = 1000;i<10000;i++){
str = String.valueOf(i);
StringBuilder s = new StringBuilder(str);
s.reverse();
String f = new String(s);
if(f.equals(str)){
System.out.println(i);
}
}
}
}
利用str = String.valueOf(i);将数字转化为字符串
必须将String转变成StringBuilder,下面才可以使用reverse()进行取反;
最后再将StringBuilder转化成String类型,和原来转化的字符串进行对等比较,
注意字符串的对等比较应该使用f.equals(str),而我们经常使用的==是用来判断数字的;
相比较之下,还是第一种方法比较简便,CPU和内存的使用都比较低。
9.基础练习 特殊回文数
输入一个正整数n, 编程求所有这样的五位和六位十进制数,满足各位数字之和等于n 。
989989
998899
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
int n = input.nextInt();
for(int i = 10000;i < 100000;i++){
int a = i/10000;
int b = i/1000%10;
int c = i/100%10;
int d = i/10%10;
int e = i%10;
if(a==e && b==d && (a+b+c+d+e)==n)
System.out.println(i);
}
for(int j = 100000;j < 1000000;j++){
int a = j/100000;
int b = j/10000%10;
int c = j/1000%10 ;
int d = j/100%10;
int e = j/10%10;
int f = j%10;
if(a==f && b==e && c==d && (a+b+c+d+e+f) ==n)
System.out.println(j);
}
}
}
将五位数和六位数的判断分开进行,然后再用if语句进行判断输出符合条件的数。
10.基础练习 十进制转十六进制
给出一个非负整数,将它表示成十六进制的形式。
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
int a = input.nextInt();
int k = 0;
char m;
String str = "";
if (a == 0)
str = "0";
while(a%16 != 0 || a/16 != 0){
k = a%16;
if(k/10 == 1)
m = (char)(65 + k%10);
else
m = (char)(48 + k);
str = m + str;
a = a / 16;
}
System.out.println(str);
}
}
注意输入的十进制数为0的情况,单独讨论,不能漏掉。
采用while循环,注意循环条件a%16 != 0 || a/16 != 0,将要转化成的十六进制数用字符串的格式输出
注意10->A,11->B,...,15->F转化。
11.基础练习 十六进制转十进制
注:十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
String str = input.next();
double out = 0;
int m = 0;
for(int i = 0;i < str.length();i++){
char k = str.charAt(i);
if((int)k >= 65)
m = (int)k -65 + 10;
else
m = (int)(k)- 48;
out = m * Math.pow(16, str.length()-i-1)+out;
}
System.out.println((long)out);
}
}
利用char k = str.charAt(i);依次取出字符串的每一位字符;
将取出的字符根据ASCII表转化为十进制,0~9对应48~57,A~F对应65~70,
再将十进制数转化为真正意义上0~15,根据对应数位乘以16的幂次,利用for循环相加;
一定要注意将最后输出的结果转化为数据类型long,long数据类型是64位有符号的java原始数据类型 。当对整数的计算结果可能超出int数据类型的范围时进行使用。long的数据类型范围是(-2^63~2^63-1)。
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
while(input.hasNext()){
String str = input.nextLine();
System.out.println(Long.parseLong(str,16));
}
}
}
首先,next()一定要读取到有效字符后才可以结束输入,对输入有效字符之前遇到的空格键、Tab键或Enter键等结束符,next()方法会自动将其去掉,只有在输入有效字符之后,next()方法才将其后输入的空格键、Tab键或Enter键等视为分隔符或结束符。简单地说,next()查找并返回来自此扫描器的下一个完整标记。完整标记的前后是与分隔模式匹配的输入信息,所以next方法不能得到带空格的字符串import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
String str = input.next();
System.out.print(Long.valueOf(str,16));
}
}
Long.ValueOf(String) ,方法得到的值非常相似。只是最后被转换为一个Long的包装类。
hasNext()和Next()效果其实是一样的,系统都会等待输入下一个字符,只是返回值不同,hasNext()会返回true,next()返回输入的字符。
以上进行了直接用java类来将十六进制转化为十进制两组代码的比较。注重细节的积累!
12. 基础练习 十六进制转八进制
问题描述
给定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 {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
int n = input.nextInt();
String strHex[] = new String[n];
for(int i=0;i<n;i++){
strHex[i] = input.next();
}
input.close();
for(int i=0;i<n;i++){
String strBinary = toBinary(strHex[i]);
int len_strBin = strBinary.length();
if(len_strBin % 3 == 1)
strBinary = "00"+strBinary;
if(len_strBin % 3 == 2)
strBinary = "0"+strBinary;
String strOctal = toOctal(strBinary);
System.out.println(strOctal);
}
}
private static String toBinary(String strHex) {
// TODO Auto-generated method stub
int len = strHex.length();
StringBuffer s = new StringBuffer();
for(int i = 0;i<len;i++){
switch(strHex.charAt(i)){
case '0':s.append("0000");break;
case '1':s.append("0001");break;
case '2':s.append("0010");break;
case '3':s.append("0011");break;
case '4':s.append("0100");break;
case '5':s.append("0101");break;
case '6':s.append("0110");break;
case '7':s.append("0111");break;
case '8':s.append("1000");break;
case '9':s.append("1001");break;
case 'A':s.append("1010");break;
case 'B':s.append("1011");break;
case 'C':s.append("1100");break;
case 'D':s.append("1101");break;
case 'E':s.append("1110");break;
case 'F':s.append("1111");break;
default:break;
}
}
return s.toString();
}
private static String toOctal(String strBinary) {
// TODO Auto-generated method stub
int len = strBinary.length();
int k;
StringBuffer s = new StringBuffer();
if(strBinary.substring(0,3).equals("000"))
k = 3;
else
k = 0;
for(int i = k;i<len-2;i+=3){
switch (strBinary.substring(i,i+3)){
case "000":s.append("0");break;
case "001":s.append("1");break;
case "010":s.append("2");break;
case "011":s.append("3");break;
case "100":s.append("4");break;
case "101":s.append("5");break;
case "110":s.append("6");break;
case "111":s.append("7");break;
default:break;
}
}
return s.toString();
}
}
构造toBinary()和toOctal()两种方法,分别返回一个字符串对象s.toString();
十六进制转化成二进制的时候,利用 strHex.charAt(i);依次取出字符串的每一位字符;在for循环的作用下转化为二进制;
注意:在返回的二进制字符串里面,前面的0会舍弃,而二进制转化为八进制需要从右向左每三位二进制数转化为一位八进制数,为保证正确的变换,最后一组二进制数要注意补0操作:
if(len_strBin % 3 == 1)
strBinary = "00"+strBinary;if(len_strBin % 3 == 2)
strBinary = "0"+strBinary;
二进制转化成八进制的时候,要先利用substring(0,3)取出前三位判断是否为“000”的形式,如果是则不算在八进制数里面。
利用strBinary.substring(i,i+3)三位三位地转换。
使用StringBuffer类中的append方法,追加内容到当前StringBuffer对象的末尾,类似于字符串的连接。
注意:在java中单引号中的内容是char类型为单个字符,双引号中的内容是String类型为字符串。
char是基本类型,而String可以是一个类,直接调用其里面的方法。
String、StringBuffer与StringBuilder之间的区别:StringBuffer和StringBuilder类是可以替代String类的一种处理字符串的解决方案。一般来讲,只要是使用字符串的地方,都可以使用StringBufferr和StringBuilder类,而这两个类比String更灵活,他们可以添加、插入或追加新的内容,但是String对象一旦创建,其值也就确定了。
速度上:String<StringBuffer<StringBuilder;
安全上:StringBuffer线程安全,StringBuilder线程不安全。
13. 基础练习 数列排序
第二行包含n个整数,为待排序的数,每个整数的绝对值小于10000。
8 3 6 4 9
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
int n = input.nextInt();
int f[] = new int[n];
for(int i=0;i<n;i++){
f[i]=input.nextInt();
}
Arrays.sort(f);
for(int i=0; i<n; i++){
System.out.print(f[i]+" ");
}
}
}
分为两步,先将元素存储进数组,使用Arrays.sort(int[] a)对数组内的元素从小到大进行排序,然后依次输出。
Arrays.sort(int[] a, int fromIndex, int toIndex)这种形式是对数组进行部分排序,
即对数组a的下标从fromIndex到toIndex-1的元素排序,注意:下标为toIndex的元素不参与排序!