Java语法笔记（三）：循环
while循环
1 | public class Main |
练习1：求1~100中所有数的立方和
1 | public class Main |
练习2：求斐波那契数列的第n项。f(1) = 1, f(2) = 1, f(3) = 2, f(n) = f(n-1) + f(n-2)
1 | import java.util.Scanner; |
do while循环
do while语句与while语句非常相似。唯一的区别是，do while语句限制性循环体后检查条件。不管条件的值如何，我们都要至少执行一次循环。
for循环
基本思想：把控制循环次数的变量从循环体中剥离。
练习1：求1~100中所有数的立方和
1 | public class Main |
练习2：求斐波那契数列的第n项。f(1) = 1, f(2) = 1, f(3) = 2, f(n) = f(n-1) + f(n-2)
1 | import java.util.Scanner; |
练习3：求 1 * 10 + 2 * 9 + 3 * 8 + 4 * 7 + 5 * 6
1 | public class Main |
跳转语句
break
可以提前从循环中退出，一般与if语句搭配。
例题：输入一个大于1的数，判断这个数是否是质数
1 | import java.util.Scanner; |
continue
可以直接跳到当前循环体的结尾。作用与if语句类似。
例题：求1~100中所有偶数的和
1 | public class Main |
多层循环
练习1：将1~100打印到一个10 * 10的矩阵中
1 | public class Main |
练习2：打印1~100中的所有质数
1 | public class Main |
例题
偶数
输出1到100之间（包括1和100）之间的所有偶数
输出格式
输出全部偶数，每个偶数占一行
输出样例
1
2
3
4
52
4
6
...
100解
1
2
3
4
5
6
7
8
9
10
11public class Main
{
public static void main(String[] args)
{
for (int i = 1; i <= 100; i ++)
{
if (i % 2 == 0)
System.out.println(i);
}
}
}奇数
输入一个整数x，输出1到x之间（包括1和x）之间的全部奇数
输入格式
一个整数
输出格式
输出所有满足条件的奇数，每个数占一行
数据范围
1≤X≤1000
输入样例
1
8
输出样例
1
2
3
41
3
5
7解
1
2
3
4
5
6
7
8
9
10
11
12
13
14import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
for (int i = 1; i <= x; i ++)
if (i % 2 != 0)
System.out.println(i);
}
}正数
输入 6 个实数，它们要么是正数，要么是负数。
请你统计并输出正数的个数。
输入格式
六个数字，每个占一行。
输出格式
输出格式为
x positive numbers，其中 x 为正数的个数。数据范围
输入数字的绝对值不超过 100
输入样例
1
2
3
4
5
67
-5
6
-3.4
4.6
12输出样例
1
4 positive numbers
解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int cnt = 0;
for (int i = 0; i < 6; i ++)
{
double a = sc.nextDouble();
if (a > 0) cnt ++;
}
System.out.printf("%d positive numbers", cnt);
}
}连续奇数的和 1
给定两个整数 X 和 Y，输出在他们之间（不包括 X 和 Y）的所有奇数的和。
输入格式
第一行输入 X，第二行输入 Y
输出格式
输出一个整数，表示所有满足条件的奇数的和
数据范围
−100≤X,Y≤100
输入样例1
1
26
-5输出样例1
1
5
输入样例2
1
215
12输出样例2
1
13
输入样例3
1
212
12输出样例3
1
0
解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int x = sc.nextInt(), y = sc.nextInt();
int sum = 0;
if (x > y)
{
int tmp = x;
x = y;
y = tmp;
}
for (int i = x + 1; i < y; i ++)
{
if (i % 2 != 0)
{
sum += i;
}
}
System.out.println(sum);
}
}最大数和它的位置
给定 100 个整数，请你找出其中最大的数字，以及它的输入位置（位置从 1 开始）
输入格式
共 100 行，每行包含一个整数
输出格式
第一行输出最大的数字。
第二行输出该数字的输入位置。
数据范围
1≤输入数字≤50000
保证输入数字互不相同。
输入样例
1
2
3
4
5
6
722229
48558
24992
4755
11923
...
20213输出样例
1
248558
2解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int cnt = 1;
for (int i = 2; i <= 100; i ++)
{
int b = sc.nextInt();
if (a < b)
{
a = b; //用a记录最大的数
cnt = i; //用cnt记录最大的数的位置
}
}
System.out.println(a);
System.out.println(cnt);
}
}递增序列
读取一系列的整数 X，对于每个 X，输出一个 1,2,…,X 的序列。
输入格式
输入文件中包含若干个整数，其中最后一个为 0，其他的均为正整数。
每个整数占一行。
对于输入的正整数，按题目要求作输出处理。
对于最后一行的整数 0，不作任何处理。
输出格式
对于每个输入的正整数 X，输出一个从 1 到 X 的递增序列，每个序列占一行。
数据范围
1≤X≤100
输入样例
1
2
3
45
10
3
0输出样例
1
2
31 2 3 4 5
1 2 3 4 5 6 7 8 9 10
1 2 3解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
for (int i = 0; i < 100; i ++)
{
int x = sc.nextInt();
if (x == 0)
break;
else
{
for (int j = 1; j <= x; j ++)
System.out.printf("%d ", j);
}
System.out.println();
}
}
}连续整数相加
读入两个整数值 A 和 N，计算从 A 开始的 N 个连续整数的和。
注意，如果读入的 N 为 0 或负数，则继续读取数字直至读入 N 值为正整数为止。
输入格式
共一行，包含整数 A 和若干个整数 N（不超过 100 个）
输出格式
一个整数，表示从 A 开始的 N 个连续整数的和。
数据范围
1≤A≤100
−100≤N≤100
输入样例1
1
3 2
输出样例1
1
7
输入样例2
1
3 -1 0 -2 2
输出样例2
1
7
解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int n = 0, sum = 0;
for (int i = 0; i < 100; i ++)
{
n = sc.nextInt();
if (n > 0)
break;
}
for (int i = a; i < a + n; i ++)
sum += i;
System.out.println(sum);
}
}约数
输入一个整数 N，按照从小到大的顺序输出它的全部约数
输入格式
一个整数
输出格式
输出全部约数，每个约数占一行
数据范围
1≤N≤1000
输入样例
1
6
输出样例
1
2
3
41
2
3
6解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16import 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 = 1; i <= n; i ++)
{
if (n % i == 0)
System.out.println(i);
}
}
}PUM
输入两个整数 N 和 M，构造一个 N 行 M 列的数字矩阵，矩阵中的数字从第一行到最后一行，按从左到右的顺序依次为 1,2,3,…,N×M
矩阵构造完成后，将每行的最后一个数字变为 PUM。
输出最终矩阵。
输入格式
共一行，包含两个整数
输出格式
输出最终矩阵，具体形式参照输出样例
数据范围
1≤N,M≤20
输入样例
1
7 4
输出样例
1
2
3
4
5
6
71 2 3 PUM
5 6 7 PUM
9 10 11 PUM
13 14 15 PUM
17 18 19 PUM
21 22 23 PUM
25 26 27 PUM解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int n = sc.nextInt(), m = sc.nextInt();
int k = 1;
for (int i = 0; i < n; i ++)
{
for (int j = 0; j < m - 1; j ++)
{
System.out.printf("%d ", k);
k ++;
}
System.out.println("PUM");
k ++;
}
}
}
习题
余数
输入一个整数 N，请按顺序输出 1 到 10000 之间（不包括 1 和 10000）的所有除以 N 余 2 的数字。
输入格式
一个整数
输出格式
输出所有满足条件的数字，从小到大每行输出一个。
数据范围
2< N <10000
输入样例
1
13
输出样例
1
2
3
4
52
15
28
41
...解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16import 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 = 2; i < 10000; i ++)
{
if (i % n == 2)
System.out.println(i);
}
}
}六个奇数
读取一个整数 X，输出 X 之后的 6 个奇数，如果 X 也是奇数，那么它也算作 6 个奇数之一。
输入格式
一个整数
输出格式
所有满足条件的奇数，每个占一行
数据范围
1≤X≤100
输入样例
1
9
输出样例
1
2
3
4
5
69
11
13
15
17
19解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
if (x % 2 != 0)
{
for (int i = 0; i < 6; i ++)
{
System.out.println(x);
x += 2;
}
}
else
{
x += 1;
for (int i = 0; i < 6; i ++)
{
System.out.println(x);
x += 2;
}
}
}
}乘法表
输入一个整数 N，输出 N 的乘法表，如下
1
2
3
41 x N = N
2 x N = 2N
...
10 x N = 10N输入格式
一个整数
输出格式
具体形式参照输出样例
数据范围
1< N <1000
输入样例
1
140
输出样例
1
2
3
4
5
6
7
8
9
101 x 140 = 140
2 x 140 = 280
3 x 140 = 420
4 x 140 = 560
5 x 140 = 700
6 x 140 = 840
7 x 140 = 980
8 x 140 = 1120
9 x 140 = 1260
10 x 140 = 1400解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15import 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 = 1; i <= 10; i ++)
{
System.out.printf("%d x %d = %d\n", i, n, i * n);
}
}
}实验
医学部一共进行了 N 场动物实验。
共有三种小动物可用来实验，分别是青蛙、老鼠和兔子。
每次实验都会选取其中一种动物来参与实验，选取数量若干。
现在请你统计一下医学部一共用了多少小动物，每种分别用了多少，每种动物使用数量占总量的百分比分别是多少。
输入格式
第一行包含整数 N，表示实验次数。
接下来 N 行，每行包含一个整数 A（表示一次实验使用的小动物的数量）和一个字符 T（表示一次实验使用的小动物的类型，C 表示兔子(coney)，R 表示老鼠(rat)，F 表示青蛙(frog)）。
输出格式
请你参照输出样例，输出所用动物总数，每种动物的数量，以及每种动物所占百分比。
注意输出百分比时，保留两位小数。
数据范围
1≤N≤100
1≤A≤15
输入样例
1
2
3
4
5
6
7
8
9
10
1110
10 C
6 R
15 F
5 C
14 R
9 C
6 R
8 F
5 C
14 R输出样例
1
2
3
4
5
6
7Total: 92 animals
Total coneys: 29
Total rats: 40
Total frogs: 23
Percentage of coneys: 31.52 %
Percentage of rats: 43.48 %
Percentage of frogs: 25.00 %解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int cnt = 0, c = 0, r = 0, f = 0;
while (n -- > 0)
{
int a = sc.nextInt();
String t = sc.next();
if (t.equals("C"))
{
c += a;
}
else if (t.equals("R"))
{
r += a;
}
else
f += a;
cnt += a;
}
System.out.printf("Total: %d animals\n", cnt);
System.out.printf("Total coneys: %d\n", c);
System.out.printf("Total rats: %d\n", r);
System.out.printf("Total frogs: %d\n", f);
System.out.printf("Percentage of coneys: %.2f %%\n", (double)c * 100/ cnt);
System.out.printf("Percentage of rats: %.2f %%\n", (double)r * 100/ cnt);
System.out.printf("Percentage of frogs: %.2f %%\n", (double)f * 100/ cnt);
}
}区间 2
读取 N 个整数 X1,X2,…,XN，判断这 N 个整数中有多少个在 [10,20] 的范围内，有多少个在范围外。
输入格式
第一行包含整数 N，表示共有 N 个整数需要进行判断。
接下来 N 行，每行包含一个整数 Xi
输出格式
第一行输出 x in，其中 x 为在范围内的整数的数量。
第二行输出 y out，其中 y 为在范围外的整数的数量。
数据范围
1≤N≤10000
−107< Xi <107
输入样例
1
2
3
4
54
14
123
10
-25输出样例
1
22 in
2 out解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int cnt = 0;
for (int i = 0; i < n; i ++)
{
int x = sc.nextInt();
if (x >= 10 && x <= 20)
cnt ++;
}
System.out.printf("%d in\n", cnt);
System.out.printf("%d out\n", n - cnt);
}
}连续奇数的和 2
输入 N 对整数对 X,Y，对于每对 X,Y，请你求出它们之间（不包括 X 和 Y）的所有奇数的和
输入格式
第一行输入整数 N，表示共有 N 对测试数据。
接下来 N 行，每行输入一组整数 X 和 Y
输出格式
每对 X,Y 输出一个占一行的奇数和
数据范围
1≤N≤100
−1000≤X,Y≤1000
输入样例
1
2
3
4
5
6
7
87
4 5
13 10
6 4
3 3
3 5
3 4
3 8输出样例
1
2
3
4
5
6
70
11
5
0
0
0
12解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int cnt = 0;
for (int i = 0; i < n; i ++)
{
int x = sc.nextInt();
int y = sc.nextInt();
if (x > y)
{
int tmp = y;
y = x;
x = tmp;
}
int sum = 0;
for (int j = x + 1; j < y; j ++)
{
if (j % 2 != 0)
sum += j;
}
System.out.println(sum);
}
}
}简单斐波那契
输入一个整数 N，请你输出斐波那契序列的前 N 项
输入格式
一个整数
输出格式
在一行中输出斐波那契数列的前 N 项，数字之间用空格隔开
数据范围
0< N< 46
输入样例
1
5
输出样例
1
0 1 1 2 3
解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int a = 0, b = 1;
int n = sc.nextInt();
for (int i = 0; i < n; i ++)
{
System.out.printf("%d ", a);
int c = a + b;
a = b;
b = c;
}
}
}数字序列和它的和
输入若干个整数对 M,N，对于每个数对，输出以这两个数为最大值和最小值的公差为 1 的等差数列。
注意，当输入整数对中，任意一个数为 0 或负整数时，立即停止输入，且该组数对无需作任何处理。
输入格式
输入共若干行，每行包含两个整数。
最后一行的两个整数中，至少有一个是非正整数。
输出格式
对于每组需作处理的数对，输出一个结果，每个结果占一行。
结果包含从最小值到最大值的数字序列以及数字序列各数字之和。
具体格式请参照输出样例。
数据范围
M,N≤100
输入样例
1
2
32 5
6 3
5 0输出样例
1
22 3 4 5 Sum=14
3 4 5 6 Sum=18解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
for (int i = 0; i < 100; i ++)
{
int m = sc.nextInt();
int n = sc.nextInt();
int sum = 0;
if (m <= 0 || n <= 0)
break;
else
{
if (m > n)
{
int tmp = m;
m = n;
n = tmp;
}
for (int j = m; j <= n; j ++)
{
System.out.printf("%d ", j);
sum += j;
}
}
System.out.printf("Sum=%d\n", sum);
}
}
}完全数
一个整数，除了本身以外的其他所有约数的和如果等于该数，那么我们就称这个整数为完全数。
例如，6 就是一个完全数，因为它的除了本身以外的其他约数的和为 1+2+3=6
现在，给定你 N 个整数，请你依次判断这些数是否是完全数
输入格式
第一行包含整数 N，表示共有 N 个测试用例。
接下来 N 行，每行包含一个需要你进行判断的整数 X
输出格式
每个测试用例输出一个结果，每个结果占一行。
如果测试数据是完全数，则输出
X is perfect，其中 X 是测试数据。如果测试数据不是完全数，则输出
X is not perfect，其中 X 是测试数据。数据范围
1≤N≤100
1≤X≤10^8
输入样例
1
2
3
43
6
5
28输出样例
1
2
36 is perfect
5 is not perfect
28 is perfect解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
while (n -- > 0)
{
int x = sc.nextInt();
if (x == 1)
System.out.printf("%d is not perfect\n", 1);
else
{
int sum = 1;
for (int i = 2; i * i <= x; i ++)
{
if (x % i == 0)
{
if (i != x / i)
{
sum += i;
sum += x / i;
}
else
sum += i;
}
}
if (sum == x)
System.out.printf("%d is perfect\n", x);
else
System.out.printf("%d is not perfect\n", x);
}
}
}
}质数
一个大于 1 的自然数，如果除了 1 和它自身外，不能被其他自然数整除则称该数为质数。
例如 7 就是一个质数，因为它只能被 1 和 7 整除。
现在，给定你 N 个大于 1 的自然数，请你依次判断这些数是否是质数。
输入格式
第一行包含整数 N，表示共有 N 个测试数据。
接下来 N 行，每行包含一个自然数 X
输出格式
每个测试用例输出一个结果，每个结果占一行。
如果测试数据是质数，则输出 X is prime，其中 X 是测试数据。
如果测试数据不是质数，则输出 X is not prime，其中 X 是测试数据。
数据范围
1≤ N ≤100
1< X ≤107
输入样例
1
2
3
43
8
51
7输出样例
1
2
38 is not prime
51 is not prime
7 is prime解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
while(n -- > 0)
{
boolean isPrime = true;
int x = sc.nextInt();
if (x > 1)
{
for (int i = 2; i * i <= x; i ++)
{
if (x % i == 0)
{
isPrime = false;
break;
}
}
}
else
isPrime = false;
if (isPrime)
System.out.printf("%d is prime\n", x);
else
System.out.printf("%d is not prime\n", x);
}
}
}菱形
输入一个奇数 n，输出一个由
*构成的 n 阶实心菱形输入格式
一个奇数
输出格式
输出一个由
*构成的 n 阶实心菱形。具体格式参照输出样例。
数据范围
1≤n≤99
输入样例
1
5
输出样例
1
2
3
4
5*
***
*****
***
*解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23//曼哈顿距离
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 ++)
{
for (int j = 0; j < n; j ++)
{
if (Math.abs(i - n / 2) + Math.abs(j - n / 2) <= n / 2)
System.out.print('*');
else
System.out.print(' ');
}
System.out.println();
}
}
}
