Java版基础练习题：
输入练习：
【问题描述】
任务很简单：
给定若干个整数，请编程输出它们的和。
【输入形式】
输入包含多组测试用例。
每组测试数据首先是一个正整数N，表示本组数据有N个整数。
请处理到文件结束。
【输出形式】
请计算每组数据的和，每组输出占一行。
【样例输入】
4 1 3 4 9 5 10 2 30 4 50
【样例输出】
17 96
代码段：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(true){
if(sc.hasNext()){
String s = sc.nextLine();
String[] str = s.split(" ");
int sum = 0;
int n = Integer.parseInt(str[0]);
for (int x = 1; x < n+1; x++) {
sum += Integer.parseInt(str[x]);
}
System.out.println(sum);
}else break;
}
}
}
解释：
其中需要注意的一点是，判断什么条件进行结束操作，这里采用的是hasNext(),结束，判断是否有输入，如果有输入返回True,否则返回false.
丑数：
【问题描述】
丑数的定义是这样的——
一个数，如果它分解后的素因子最多只有2、3、5、7四种，这个数则称为“丑数”。比如，前20个丑数是：1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 24, 25, 27。
现在你的任务是：给你一个数，你能判断是否是丑数吗？
【输入形式】
输入数据的第一行首先是一个整数C，表示测试数据的个数，然后是C组数据，每组测试数据包含一个整数n(1 <= n <= 2^31-1)。
【输出形式】
对于每组测试数据，如果n是丑数，则请输出“ Yes”,否则，请输出“No”.
【样例输入】
3 12 385875 11
【样例输出】
Yes Yes No
代码段：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
//读好题目，不是结合的样式，而是包含哪些素因子
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for (int i = 0; i < n; i++) {
int num = sc.nextInt();
if (check(num)==1) System.out.println("Yes");
else System.out.println("No");
}
}
public static int check(int num){
while(num%2==0){
num/=2;
}
while(num%3==0){
num/=3;
}
while(num%5==0){
num/=5;
}
while(num%7==0){
num/=7;
}
if(num==1)
return 1;
return 0;
}
}
解释：
首先需要读懂题目，刚开始没有读懂题目，写的时候思路就错了，其中分解后的素因子最后只有2、3、5、7四种，是包含的意思，不是结合的次数；
判断数字是否能整除的前提是看余数是不是等于0，如果都能整除的话最后会变成1，这样结束条件就有了，只要不能整除的全部都不是丑数。
小黄车：
【问题描述】最近2年，以小黄车为代表的共享单车飞速发展，在某种意义上确实给大家带来了便利。
这几天，小明就在思考一个问题：“骑车”是否一定比“走路”快呢？
毕竟，如果决定骑车的话，在找车、开锁、停车、锁车等环节也要花时间的。
假设要行走的距离为L米，每次找车和开锁的一共时间是T1秒，每次停车和锁车的时间一共是T2秒，骑车的速度为V1米/秒，行走的速度为V2米/秒。
你现在是个小程序员了，请编程判断是骑车快还是走路快。
【输入形式】
输入首先包含一个正整数N（N<100），表示有N组测试数据。
每组数据占一行，包含5个正整数L（L<10000）、T1（T1<100）、T2（T2<100）、V1（V1<100）、V2（V2<100），数据含义如题目描述。
【输出形式】
如果骑小黄车更快的话，请输出”Bike is OK!”；
如果走路更快的话，请输出”Walk is OK!”；
如果一样快，请输出”Both are OK!”；
每组数据输出一行。
【样例输入】
1 150 20 15 5 2
【样例输出】
Bike is OK!
代码段：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for (int i = 0; i < n; i++) {
int s = sc.nextInt();
int t1 = sc.nextInt();
int t2 = sc.nextInt();
int v1 = sc.nextInt();
int v2 = sc.nextInt();
int bike_time = t1+t2+s/v1;
int walk_time = s/v2;
if (bike_time<walk_time) System.out.println("Bike is OK!");
else if (bike_time==walk_time) System.out.println("Both are OK!");
else System.out.println("Walk is OK!");
}
}
}
解释：
这个其实没有什么好解释的，单纯的小学数学。
字符三角形：
【问题描述】
我们学习了编程，通过对程序的控制，可以做一些有趣的输出。
比如，这个题目就是给定一个正整数N，请你输出一个由N行的*组成的三角形。
但是——为了图形的美观，我们希望输出的是一个等腰三角形！
具体规则如下：
第一行是1个*
第二行是3个*
第三行是5个*
......
依次类推，一直到第N行（第N行的开始没有空格）。
更多了解可以参见样例。
【输入形式】
输入数据第一行是一个正整数C，表示一共有C组测试用例。
接下来C行，每组数据占一行，是一个正整数N（1<=N<=40），N的含义见题目描述。
【输出形式】
对于每组数据给定的N，请按照要求输出由*组成的N行等腰三角形。
【样例输入】
2 3 5
【样例输出】
代码段：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
//第一个for循环是控制最后输出几个三角形图案
for (int k = 0; k < n; k++) {
int num = sc.nextInt();
for (int i = 1; i <=num; i++) { //输出4行
for (int j = 0; j < num-i; j++) {
System.out.print(" ");
}
for (int j = 1; j <= 2*i-1; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
}
解释：
第一个for循环是控制最后输出几个三角形图案,第二个for循环时控制图案几层；
后两个循环每一次实现每行的图案；假如输出四行，
第一行先输出三个空格，再输出一个*；
第二行先输出输出两个空格，再输出三个*；
.......
成绩统计：
【问题描述】
2017年2月23号，文海中学信息学奥林匹克社团选拔考试顺利进行！本次选拔共有N位同学报名参加，现在，试卷已经批改完毕！刘老师想知道本次考试的平均分，以及高于平均分的人数有多少。现在就把这个任务交给喜欢编程的你吧~
注：如果分数和平均分一样，也计算在内。
【输入形式】
输入数据首先是一个正整数C（C<=10），表示有C组测试用例。
每组测试用例占两行，首先一行是一个正整数N（1<N<=59），表示有N位同学参加选拔考试。接下来一行是N个整数Si（0<=Si<=100），表示N位考生的成绩。
【输出形式】
每组测试数据输出一行，分别是本次考试的平均成绩（结果保留2位小数）和高于平均分的人数，中间用空格隔开。
【样例输入】
2 5 30 40 50 60 70 8 77 88 11 22 33 44 55 66
【样例输出】
50.00 3 49.50 4
代码段：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for (int i = 0; i < n; i++) {
int num = sc.nextInt();
int[] array = new int[num];
int count=0;
double average =0;
for (int j = 0; j < num; j++) {
array[j] = sc.nextInt();
average += array[j];
}
for (int j = 0; j < num; j++) {
if (array[j]>=average/num) count++;
}
System.out.println(String.format("%.2f",(average/(double)num))+" "+count);
}
}
}
成绩统计升级版：
【问题描述】 2017年12月23号，丁爸信奥培训班选拔考试顺利进行！
考试结束后，助教老师帮忙计算了本次选拔考试的平均分，但是，粗心的丁爸却不小心把平均分弄丢了！
现在，丁爸想请聪明的小朋友们再算一遍平均分。
不过这次，丁爸不仅需要平均分，还希望大家帮忙计算本次考试的成绩偏离程度。
注：“偏离程度”是指每个人的成绩与平均分差值的绝对值的总和。
【输入形式】输入数据第一行是一个正整数C（C<=10），表示有C组测试用例；
每组测试用例占两行，首先一行是一个正整数N（1<N<=59），表示有N位同学参加选拔考试。
接下来一行是N个整数Si（0<=Si<=100），表示N位考生的成绩。
【输出形式】每组测试数据输出一行，分别是本次考试的平均成绩（结果保留2位小数）和偏离程度（结果保留2位小数），中间用空格隔开。
【样例输入】
2 4 1 2 3 4 5 1 3 6 7 13
【样例输出】
2.50 4.00 6.00 16.00
【样例说明】在第一组数据中，平均分是2.50，那么，四个人偏离平均分的程度分别为1.50， 0.50， 0.50, 1.50,
所以，“偏离程度”为 1.5+0.5+0.5+1.5=4.00.
代码段：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for (int i = 0; i < n; i++) {
int num = sc.nextInt();
int[] array = new int[num];
double count=0;
double average =0;
for (int j = 0; j < num; j++) {
array[j] = sc.nextInt();
average += array[j];
}
for (int j = 0; j < num; j++) {
count +=Math.abs(array[j]-(average/num));
}
System.out.println(String.format("%.2f %.2f",(average/num),count));
}
}
}
解释：
在上一题的基础上再加一个for循环统计偏离度。
折中就好：
【问题描述】丁爸出去买东西最烦挑三拣四，一般都喜欢折中选择。所谓折中就是选择最接近平均值的那一个。这次他去菜场买鸡，面对卖家地上的一大堆鸡，他决定买重量最折中的那只，请你帮他选一下。
【输入形式】输入包含多组测试数据。
每组数据第一行，包括一个正整数N（2<=N<=20），
接下来有N行数据，每行包含N个正整数，表示每只鸡的重量（不超过200）
【输出形式】对于每组数据，请输出这组鸡的平均重量（保留两位小数）
以及最接近平均值的那只鸡的行号和列号（行号和列号都是从1开始）。
每组数据输出占一行。
注意:行号和列号从1开始，如果有多只鸡相同接近平均值，那么输出排在最前面的一只
（即行号最小的那只，如果行号相同则取列号最小的那只）。
【样例输入】
2 2 3 8 9 2 1 4 7 18
【样例输出】
5.50 1 2
7.50 2 1
代码段：
(有点小毛病的)基础版
package CG练习题;
import java.util.Arrays;
import java.util.Scanner;
public class 折中就好 {
static int define = 50;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
int n = sc.nextInt();
int[][] number = new int[n][n];
int count=0;
double sum = 0;
for (int j = 0; j < number.length; j++) {
for (int k = 0; k < number[j].length; k++) {
number [j][k] = sc.nextInt();
count++;
sum +=number[j][k];
}
}
// 以上求出sum
double avg =sum/count;
// 设计元素对应下标，创建平均值列表
double[] avg_num = new double[define];
// 保存横坐标
int[] row = new int[define];
// 保存纵坐标
int[] column = new int[define];
int index =0;
for (int j = 0; j < number.length; j++) {
for (int k = 0; k < number[j].length; k++) {
// 将相减的值加入avg_num中
avg_num[index] = Math.abs(number[j][k]-avg);
row[index] = j;
column[index] = k;
index++;
}
}
// 设初始值判断
double min = avg_num[0];
int xb =0;
for (int j = 0; j < index; j++) {
if(avg_num[j]<min){
min =avg_num[j];
xb=j;
}
}
System.out.println(String.format("%.2f",avg)+" "+(row[xb]+1)+" "+(column[xb]+1));
}
}
}
注意：这个代码测试用例有一个没有过，有一个范围内会造成数组越界；
所有用例全部过掉：原理相同
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
double[][] ji = new double[50][50];
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
int t = sc.nextInt();
double sum=0;
for (int i = 1; i <= t; i++) {
for (int j = 1; j <= t; j++) {
ji[i][j] = sc.nextInt();
sum +=ji[i][j];
}
}
sum /=(t*t);
double min = Math.abs(sum-ji[1][1]);
int x=1,y=1;
for (int i = 1; i <= t; i++) {
for (int j = 1; j <= t; j++) {
if (Math.abs(sum-ji[i][j])<min){
min = Math.abs(sum-ji[i][j]);
x=i;
y=j;
}
}
}
System.out.println(String.format("%.2f",sum)+" "+x+" "+y);
}
}
}
同学做的数组：
package CG练习题;
import java.util.ArrayList;
import java.util.Scanner;
public class 折中 {
public static void main(String[] args) {
int n=0,k=0;
Scanner scan=new Scanner(System.in);
ArrayList<Double> listAvg=new ArrayList<>();
ArrayList<Integer> listRow=new ArrayList<>();
ArrayList<Integer> listCol=new ArrayList<>();
while(scan.hasNext()){
n=scan.nextInt();
int r=1,c=1,p=0,sum=0;
double avg=0;
ArrayList<Integer> listWeight=new ArrayList<>();
for (int i = 0; i < n; i++) {
for (int j=0;j<n;j++){
listWeight.add(scan.nextInt());
sum+=listWeight.get(p);
p++;
}
}
avg=(double) sum/p;
listAvg.add(avg);
double min=Math.abs(listWeight.get(0)-listAvg.get(k));
listRow.add(r);
listCol.add(c);
for (int i=1;i<p;i++){
if (Math.abs(listWeight.get(i)-listAvg.get(k))<min){
min=Math.abs(listWeight.get(i)-listAvg.get(k));
listRow.set(k,i/n+1);
listCol.set(k,i%n+1);
}
}
k++;
}
for (int i=0;i<k;i++){
System.out.print(String.format("%.2f",listAvg.get(i))+" ");
System.out.print(listRow.get(i)+" ");
System.out.println(listCol.get(i));
}
}
}
奋勇争先：
【问题描述】
在丁爸信奥培训班中，每一次的作业，大家都奋勇争先，想拿下第一名。
现在已知某次测验的每位同学的解题数量和罚时，希望你能够告诉老师谁是第一名。
注：
首先依据解题数量从大到小排名，若解题数量相同，则比较罚时，罚时少的排名靠前。
【输入形式】
第一行是数据组数C，代表有C组测试实例。
每一组数据第一行为一个N，代表下面有N个人的成绩。
接下来N行，每一行依次给出名字Name，解题数量num和罚时time
( 1<=C<=10, 2<N<=1000, Name的长度最大为10， 1<=num<=10，
10<=time<=100000 )
【输出形式】
每组测试数据输出一行，依次为第一名的名字、解题数量和罚时，中间用空格隔开。
【样例输入】
1 3 Bob 5 50 Alice 4 46 John 5 48
【样例输出】
John 5 48
代码段：考察点是结构体，或者类的运用
import java.util.Arrays;
import java.util.Scanner;
class student{
private String name;
private int num;
private int time;
public student(String name,int num,int time){
this.name = name;
this.num = num;
this.time = time;
}
public String getName(){
return this.name;
}
public int getTime() {
return this.time;
}
public int getNum() {
return this.num;
}
public String tell(){
return this.name+" "+this.num+" "+this.time;
}
}
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 几组数据
int n = sc.nextInt();
for (int k = 0; k < n; k++) {
// 输入几行数字
int m = sc.nextInt();
// 申请几个数组
student[] st_arr = new student[m];
for (int i = 0; i < m; i++) {
String data1 = sc.next();
int data2 = sc.nextInt();
int data3 = sc.nextInt();
student st_data = new student(data1,data2,data3);
st_arr[i] = st_data;
}
int index=0;
// 遍历数组
String name = st_arr[0].getName();
int max_num = st_arr[0].getNum();
int time = st_arr[0].getTime();
for (int i = 0; i < m; i++) {
if (max_num<st_arr[i].getNum()){
name = st_arr[0].getName();
max_num = st_arr[i].getNum();
time = st_arr[i].getTime();
index =i;
}
if (max_num==st_arr[i].getNum()){
if(time>st_arr[i].getTime()){
name = st_arr[0].getName();
max_num = st_arr[i].getNum();
time = st_arr[i].getTime();
index = i;
}
}
}
System.out.println(st_arr[index].tell());
}
}
}
超级密码：
【问题描述】
上次设计的“高级密码”被你们破解了，一丁小朋友很不服气！
现在，他又设计了一套更加复杂的密码，称之为“超级密码”。
说实话，这套所谓的“超级密码”其实也并不难：
对于一个给定的字符串，你只要提取其中的数字，然后连在一起构成一个整数，再乘以刘一丁小朋友的幸运数字513，就是解密后的结果了~
比如，字符串“ads2d4,122”，提取后的整数是24122，然后乘以513，就能得到解密后的结果：12374586。
注：题目保证解密后的结果在32位无符号整数范围。
【输入形式】
输入首先包括一个正整数N，表示有N组测试用例。
每组数据占一行，包含一个长度不超过30的字符串。
【输出形式】
请根据题目要求输出解密后的结果，每组数据输出一行。
【样例输入】
2 ads2d4,122 0023asdf2AA90
【样例输出】
12374586 11947770
代码段：考察点是字符串的运用
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for (int i = 0; i <n; i++) {
StringBuilder buf=new StringBuilder();
String pword = sc.next();
int sum=0;
for (int j = 0; j < pword.length(); j++) {
if(pword.charAt(j)>='0' && pword.charAt(j)<='9'){
buf.append(pword.charAt(j));
}
}
//将StringBuilder转换成String
String number = buf.reverse().toString();
for (int j = 0; j < number.length(); j++) {
sum +=Integer.valueOf(number.charAt(j)-48)*Math.pow(10,j);
}
System.out.println(sum*513);
}
}
}
解释：
这题采用了StringBuilder；不了解的可以点击链接查看,采用遍历字符，是否在数字的ascii范围中；
其中要了解charAt()的转换格式（数字的ascii）;
先遍历提取字符串中的数字，然后转换成整数，在相乘；
萌数的约数：
【问题描述】
一个数，如果他的素数因子只包括2,3,5,7，则称这个数为萌数，比如，下面这些数就是前20个萌数：1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 24, 25, 27。
现在给你一个萌数，请编程计算它的约数的个数。
比如，4是一个萌数，他有3个约数(1,2,4)；12也是一个萌数，他有 6 个约数（1,2,3,4,6,12）。
【输入形式】
输入包含多组测试用例。
每个测试用例包含一个萌数n, 并且n在64位整数的范围( long long 类型，输入输出用%lld )。
如果n为0，则标志结束输入，不做处理。
【输出形式】
对于每个测试用例中的萌数，请输出他的约数的个数。
每个输出占一行。
【样例输入】
4
12
0
【样例输出】
3
6
代码段：有点问题
package CG练习题;
import java.util.Scanner;
public class 萌数的约数 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (true) {
long n = sc.nextLong();
int count = 0;
if (n ==0) break;
for (int i = 1; i <= n; i++) {
if (n % i == 0) {
count++;
}
}
System.out.println(count);
}
}
}
解释：
遍历输入的数字，如果能被整除的就是数字的约数，但是在一个数非常大的时候，超过了CPU 的执行能力，会造成（感官上的）死循环；
解决版本：
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[] a ={2,3,5,7};
int[] b = new int[4];
while(true){
long n = sc.nextLong();
if(n==0) break;
long ans = 1;
//核心代码
for (int i = 0; i < 4; i++) {
b[i] =0;
while(n%a[i] ==0){
n /= a[i];
b[i]++;
}
ans *=b[i]+1;
}
System.out.println(ans);
}
}
}
解释：
该题需要采用约数个数定理：
对于一个大于1正整数n可以分解质因数：
则n的正约数的个数就是
其中a1、a2、a3…ak是p1、p2、p3，…pk的指数。
如：例题：正整数378000共有多少个 正约数？
解：将378000 分解质因数378000=24×33×53×71
由约数个数定理可知378000共有正约数(4+1)×(3+1)×(3+1)×(1+1)=160个。
先找出2幂的个数，然后再找出3幂的个数......
for (int i = 0; i < 4; i++) {
b[i] =0;
while(n%a[i] ==0){
n /= a[i];
b[i]++;
}
ans *=b[i]+1;
}
结束：
感谢各位看到最后,寒假训练，每天进步一点点！
如果有错误的地方，欢迎指正！
参考文献：https://blog.csdn.net/piaocoder/article/details/47954385