目录
61:画矩形
62:敲七
63:等比数列末项计算
64:矩阵交换行
65:字符串hash
66:蛇形填充数组
67:反反复复
68:变幻的矩阵
69:计算矩阵边缘元素之和
70:计算鞍点
71:倒置排序
72:做游戏
73:石头剪刀布
74:有趣的跳跃
75:校门外的树
76:年龄与疾病
77:数组逆序重放
78:与指定数字相同的数的个数
79:寻找配对数
80:数字求和
81:向量点积计算
61:画矩形
描述
根据参数，画出矩形。
输入
输入一行，包括四个参数：前两个参数为整数，依次代表矩形的高和宽（高不少于3行不多于10行，宽不少于5列不多于10列）；第三个参数是一个字符，表示用来画图的矩形符号；第四个参数为1或0，0代表空心，1代表实心。
输出
输出画出的图形。
样例输入
7 7 @ 0
样例输出
@@@@@@@
@ @
@ @
@ @
@ @
@ @
@@@@@@@
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int h = sc.nextInt(); // 高height 3<=h<=10
int wid = sc.nextInt(); // 宽width 5<=w<=10
String f = sc.next(); // 用来画图的矩形符号
int xin = sc.nextInt(); // 0空心,1实心
if (xin == 0) {// 空心
for (int i = 0; i < h; i++) {
if ((i == 0) || (i == h - 1)) {
for (int j = 0; j < wid; j++) {
System.out.print(f);
}
System.out.println();
} else if (0 < i && i < h - 1) {
System.out.print(f);
for (int j = 2; j < wid; j++) {
System.out.print(" ");
}
System.out.print(f);
System.out.println();
}
}
}
if (xin == 1) { // 实心
for (int i = 0; i < h; i++) {
for (int j = 0; j < wid; j++) {
System.out.print(f);
}
System.out.println();
}
}
}
}62:敲七
描述
输出7和7的倍数，还有包含7的数字。例如（17，27，37...70，71，72，73...）
输入
一个整数N。(N不大于30000)
输出
从小到大排列的不大于N的与7有关的数字，每行一个。
样例输入
20
样例输出
7
14
17
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 = 7; i <= N; i++) {
qi(i);
}
}
static void qi(int a) {
if (a % 7 == 0) {
System.out.println(a);
} else if ((a % 7) != 0) {
int t = a;
while (t > 0) {
if (t % 10 == 7) {
System.out.println(a);
break;
}
t = t / 10;
}
}
}
}63:等比数列末项计算
描述
已知等比数列的公比是2，现给出等比数列的第一项a1，求第n项是多少？
输入
一行，包含三个整数a1，n。-100 <= a1<= 100，0 < n <= 63。
输出
一个整数，即第n项的值。
样例输入
1 3
样例输出
4
import java.util.Scanner;
import java.math.BigInteger;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
BigInteger p = sc.nextBigInteger();
int n = sc.nextInt();
for (int i = 1; i < n; i++) {
p = p.multiply(new BigInteger("2"));
}
System.out.println(p);
}
}64:矩阵交换行
描述
编写一个函数，输入参数是5*5的二维数组，和n，m两个行下标。功能：判断n，m是否在数组范围内，如果不在，则返回0；如果在范围内，则将n行和m行交换，并返回1。
在main函数中， 生成一个5*5的矩阵，输入矩阵数据，并输入n，m的值。调用前面的函数。如果返回值为0，输出error。如果返回值为1，输出交换n，m后的新矩阵。
输入
5*5矩阵的数据，以及n和m的值。
输出
如果不可交换，则输出error；
如果可交换，则输出新矩阵
样例输入
1 2 2 1 2
5 6 7 8 3
9 3 0 5 3
7 2 1 4 6
3 0 8 2 4
0 4
样例输出
3 0 8 2 4
5 6 7 8 3
9 3 0 5 3
7 2 1 4 6
1 2 2 1 2
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[][] a = new int[5][5];
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
a[i][j] = sc.nextInt();
}
}
int n = sc.nextInt();
int m = sc.nextInt();
int t = panduan(a, n, m);
if (t == 0) {
System.out.println("error");
} else if (t == 1) {
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
System.out.printf("%4d", a[i][j]); // 注意输出格式
}
System.out.println();
}
}
}
public static int panduan(int[][] a, int n, int m) {
if ((0 <= n && n < 5) && (0 <= m && m < 5)) {
for (int i = 0; i < 5; i++) {
int temp = a[m][i];
a[m][i] = a[n][i];
a[n][i] = temp;
}
return 1;
} else
return 0;
}
}65:字符串hash
描述
给定N个单词（每个单词长度不超过100，单词字符串内仅包含小写字母）。
请求出N个单词中共有多少个不同的单词。
输入
第1行包含1个正整数N。
接下来N行每行包含一个字符串。
输出
一个整数，代表不同单词的个数
样例输入
5
lalala
hahaha
haha
lalala
haha
样例输出
3
提示
* N <= 10000000
* 不同单词个数不超过100000
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
Set<String> ct = new HashSet<String>();
for (int i = 0; i < N; i++) {
ct.add(sc.next());
}
System.out.println(ct.size());
}
}66:蛇形填充数组
描述
用数字1,2,3,4,...,n*n这n2个数蛇形填充规模为n*n的方阵。
蛇形填充方法为：
对于每一条左下-右上的斜线，从左上到右下依次编号1,2,...,2n-1；按编号从小到大的顺序，将数字从小到大填入各条斜线，其中编号为奇数的从左下向右上填写，编号为偶数的从右上到左下填写。
比如n=4时，方阵填充为如下形式：
1 2 6 7
3 5 8 13
4 9 12 14
10 11 15 16
输入
输入一个不大于10的正整数n，表示方阵的行数。
输出
输出该方阵，相邻两个元素之间用单个空格间隔。
样例输入
4
样例输出
1 2 6 7
3 5 8 13
4 9 12 14
10 11 15 16
方法一
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[2 * n][2 * n];
int[] b = new int[2 * n];
int s = 1;
for (int i = 1; i <= 2 * n - 1; i++) {
if (i <= n) {
b[i] = i;
} else {
b[i] = 2 * n - i;
}
if (i % 2 == 1) {
for (int j = 1; j <= b[i]; j++) {
a[i][j] = s++;
}
} else {
for (int j = b[i]; j >= 1; j--) {
a[i][j] = s++;
}
}
}
for (int i = 1; i <= n; i++) {
System.out.print(a[i][1] + " ");
for (int j = i + 1; j <= i - 1 + n; j++) {
System.out.print(a[j][b[j]--] + " ");
}
System.out.println();
}
}
}方法二
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][n];
int sum = 1;
for (int i = 0; i <= 2 * (n - 1); i++) {
for (int j = 0; j <= i; j++) {
if (j < n && i - j < n) {
if (i % 2 == 1) {
a[j][i - j] = sum++;
} else {
a[i - j][j] = sum++;
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
System.out.print(a[i][j] + " ");
}
System.out.println();
}
}
}67:反反复复
描述
Mo和Larry发明了一种信息加密方法。他们首先决定好列数，然后将信息（只包含字母）从上往下依次填入各列，并在末尾补充一些随机字母使其成为一个完整的字母矩阵。例如，若信息是“There's no place like home on a snowy night”并且有5列，Mo会写成：
t o i o y
h p k n n
e l e a i
r a h s g
e c o n h
s e m o t
n l e w x
注意Mo只会填入字母，且全部是小写形式。在这个例子中，Mo用字母“x”填充了信息使之成为一个完整的矩阵，当然他使用任何字母都是可以的。
Mo根据这个矩阵重写信息：首先从左到右写下第一行，然后从右到左写下第二行，再从左到右写下第三行……以此左右交替地从上到下写下各行字母，形成新的字符串。这样，例子中的信息就被加密为：toioynnkpheleaigshareconhtomesnlewx。
你的工作是帮助Larry从加密后的信息中还原出原始信息（包括填充的字母）。
输入
第一行包含一个整数（范围2到20），表示使用的列数。
第二行是一个长度不超过200的字符串。
输出
一行，即原始信息。
样例输入
5
toioynnkpheleaigshareconhtomesnlewx
样例输出
theresnoplacelikehomeonasnowynightx
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
sc.nextLine();
String str = sc.nextLine();
String s = "";
int h = str.length() / n + 1;
for (int i = 1; i < h; i++) {
if (i % 2 != 0) {
s = s + str.substring((i - 1) * n, i * n);
}
if (i % 2 == 0) {
StringBuffer ss = new StringBuffer("");
ss.append(str.substring((i - 1) * n, i * n));
s = s + ss.reverse();
}
}
for (int i = 0; i < n; i++) {
int x = i;
for (int j = 0; j < h - 1; j++) {
System.out.print(s.charAt(x));
x += n;
}
}
}
}68:变幻的矩阵
描述
有一个N x N（N为奇数，且1 <= N <= 10）的矩阵，矩阵中的元素都是字符。这个矩阵可能会按照如下的几种变幻法则之一进行变幻（只会变幻一次）。
现在给出一个原始的矩阵，和一个变幻后的矩阵，请编写一个程序，来判定原始矩阵是按照哪一种法则变幻为目标矩阵的。
1. 按照顺时针方向旋转90度；
如：
1 2 3 7 4 1
4 5 6 变幻为 8 5 2
7 8 9 9 6 3
2. 按照逆时针方向旋转90度；
如：
1 2 3 3 6 9
4 5 6 变幻为 2 5 8
7 8 9 1 4 7
3. 中央元素不变（如下例中的 5），其他元素（如下例中的3）与“以中央元素为中心的对应元素”（如下例中的7）互换；
如：
1 2 3 9 8 7
4 5 6 变幻为 6 5 4
7 8 9 3 2 1
4. 保持原始矩阵，不变幻；
5. 如果 从原始矩阵 到 目标矩阵 的变幻，不符合任何上述变幻，请输出5
输入
第一行：矩阵每行/列元素的个数 N；
第二行到第N+1行：原始矩阵，共N行，每行N个字符；
第N+2行到第2*N+1行：目标矩阵，共N行，每行N个字符；
输出
只有一行，从原始矩阵 到 目标矩阵 的所采取的 变幻法则的编号。
样例输入
5
a b c d e
f g h i j
k l m n o
p q r s t
u v w x y
y x w v u
t s r q p
o n m l k
j i h g f
e d c b a
样例输出
3
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][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
a[i][j] = sc.next();
}
}
int num1 = 0, num2 = 0, num3 = 0, num4 = 0;
String[][] b = new String[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
b[i][j] = sc.next();
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i][j].equals(b[j][n - i - 1])) {
num1++;
}
if (a[i][j].equals(b[n - j - 1][i])) {
num2++;
}
if (a[i][j].equals(b[n - i - 1][n - j - 1])) {
num3++;
}
if (a[i][j].equals(b[i][j])) {
num4++;
}
}
}
if (num1 == n * n) {
System.out.println("1");
} else if (num2 == n * n) {
System.out.println("2");
} else if (num3 == n * n) {
System.out.println("3");
} else if (num4 == n * n) {
System.out.println("4");
} else {
System.out.println("5");
}
}
}69:计算矩阵边缘元素之和
描述
输入一个整数矩阵，计算位于矩阵边缘的元素之和。所谓矩阵边缘的元素，就是第一行和最后一行的元素以及第一列和最后一列的元素。
输入
第一行分别为矩阵的行数m和列数n（m < 100，n < 100），两者之间以一个空格分开。
接下来输入的m行数据中，每行包含n个整数，整数之间以一个空格分开。
输出
输出对应矩阵的边缘元素和
样例输入
3 3
3 4 1
3 7 1
2 0 1
样例输出
15
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int m = sc.nextInt();
int n = sc.nextInt();
int[][] a = new int[m][n];
int sum = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
a[i][j] = sc.nextInt();
if (i == 0 || i == m - 1) {
sum += a[i][j];
} else if (j == 0 || j == n - 1) {
sum += a[i][j];
}
}
}
System.out.println(sum);
}
}70:计算鞍点
描述
给定一个5*5的矩阵，每行只有一个最大值，每列只有一个最小值，寻找这个矩阵的鞍点。
鞍点指的是矩阵中的一个元素，它是所在行的最大值，并且是所在列的最小值。
例如：在下面的例子中（第4行第1列的元素就是鞍点，值为8 ）。
11 3 5 6 9
12 4 7 8 10
10 5 6 9 11
8 6 4 7 2
15 10 11 20 25
输入
输入包含一个5行5列的矩阵
输出
如果存在鞍点，输出鞍点所在的行、列及其值，如果不存在，输出"not found"
样例输入
11 3 5 6 9
12 4 7 8 10
10 5 6 9 11
8 6 4 7 2
15 10 11 20 25
样例输出
4 1 8
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[][] a = new int[5][5];
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
a[i][j] = sc.nextInt();
}
}
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
if (hang(i, a[i][j],a) && lie(j, a[i][j],a)) {
System.out.print((i + 1) + " " + (j + 1) + " " + a[i][j]);
return;
}
}
}
System.out.println("not found");
}
static boolean hang(int i, int num,int[][] a) {
int max = -1;
for (int j = 0; j < 5; j++) {
if (a[i][j] > max) {
max = a[i][j];
}
}
if (num == max) {
return true;
}
return false;
}
static boolean lie(int j, int num,int[][] a) {
int min = 1000000;
for (int i = 0; i < 5; i++) {
if (a[i][j] < min) {
min = a[i][j];
}
}
if (num == min) {
return true;
}
return false;}
}71:倒置排序
描述
将一些整数按倒置值排序后输出. 所谓倒置,是指把整数各位倒过来构成一个新数,例如:13倒置成了31.
输入
第一行的整数N表示后面列出的组数。每组数的第一个整数n表示后面将有n个整数。（每组数据量不超80）
输出
将每组数按倒置值进行排序输出.其每组数的结果占一行.
样例输入
2
4 83 13 24 36
4 99 100 123 12345
样例输出
13 83 24 36
100 99 123 12345
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;
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 n1 = sc.nextInt();
Map<Integer, Integer> map = new TreeMap<Integer, Integer>();
for (int j = 0; j < n1; j++) {
int a = sc.nextInt();
String s = a + "";
StringBuffer ss = new StringBuffer(s);
String reverse_s = ss.reverse().toString();
map.put(a, Integer.parseInt(reverse_s));
}
List<Map.Entry<Integer, Integer>> list = new ArrayList<>(map.entrySet());
Collections.sort(list, new Comparator<Map.Entry<Integer, Integer>>() {
public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
return o1.getValue() - o2.getValue();
}
});
for (Map.Entry<Integer, Integer> num : list) {
System.out.print(num.getKey() + " ");
}
System.out.println();
}
}
}72:做游戏
描述
有M个小孩子围成一圈做游戏，每个小孩子都有一个初始的号码。游戏有X步，每一步的操作方法都相同：每个小孩子把自己手上的号码改写成自己原来的号码加上右手边的小孩子的号码除以100的余数。请问你：经过X步之后，每个小孩子手上的号码是多少？ 比如：有3个初始编号为{1，2，3}的小孩子，第一步操作完成之后，他们的编号变成了{1+2，2+3，3+1}即{3，5，4}。
输入
输入有N组测试数据。每组测试数据有2行： 第一行包含M和X。 第二行包含M个不超过100的整数。
输出
输出数据有N行，每行是一组测试数据的结果。注意：两个数字之间只有一个空格。
样例输入
2
3 1
1 2 3
3 2
1 2 3
样例输出
3 5 4
8 9 7
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 m = sc.nextInt();
int x = sc.nextInt();
int[] a = new int[m];
for (int j = 0; j < m; j++) {
a[j] = sc.nextInt();
}
for (int k = 0; k < x; k++) { // x次加操作
int a1 = a[0];
for (int i1 = 0; i1 < m; i1++) {
if (i1 != m - 1) {
a[i1] += a[i1 + 1];
}
if (i1 == m - 1) {
a[i1] = a[i1] + a1;
}
}
}
for (int i2 = 0; i2 < m; i2++) {
System.out.print(a[i2] + " ");
}
System.out.println();
}
}
}73:石头剪刀布
描述
石头剪刀布是常见的猜拳游戏。石头胜剪刀，剪刀胜布，布胜石头。如果两个人出拳一样，则不分胜负。
一天，小A和小B正好在玩石头剪刀布。已知他们的出拳都是有周期性规律的，比如：“石头-布-石头-剪刀-石头-布-石头-剪刀……”，就是以“石头-布-石头-剪刀”为周期不断循环的。请问，小A和小B比了N轮之后，谁赢的轮数多？
输入
输入包含三行。
第一行包含三个整数：N，NA，NB，分别表示比了N轮，小A出拳的周期长度，小B出拳的周期长度。0 < N,NA,NB < 100。
第二行包含NA个整数，表示小A出拳的规律。
第三行包含NB个整数，表示小B出拳的规律。
其中，0表示“石头”，2表示“剪刀”，5表示“布”。相邻两个整数之间用单个空格隔开。
输出
输出一行，如果小A赢的轮数多，输出A；如果小B赢的轮数多，输出B；如果两人打平，输出draw。
样例输入
10 3 4
0 2 5
0 5 0 2
样例输出
A
提示
对于测试数据，猜拳过程为：
A：0 2 5 0 2 5 0 2 5 0
B：0 5 0 2 0 5 0 2 0 5
A赢了4轮，B赢了2轮，双方打平4轮，所以A赢的轮数多。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int NA = sc.nextInt();
int[] A = new int[NA];
int NB = sc.nextInt();
int[] B = new int[NB];
int i, count_A = 0, count_B = 0;
for (i = 0; i < NA; i++) {
A[i] = sc.nextInt();
}
for (i = 0; i < NB; i++) {
B[i] = sc.nextInt();
}
for (i = 0; i < N; i++) {
if (A[i % NA] == 0 && B[i % NB] == 2) {
count_A++;
}
if (A[i % NA] == 2 && B[i % NB] == 5) {
count_A++;
}
if (A[i % NA] == 5 && B[i % NB] == 0) {
count_A++;
}
if (A[i % NA] == 2 && B[i % NB] == 0) {
count_B++;
}
if (A[i % NA] == 5 && B[i % NB] == 2) {
count_B++;
}
if (A[i % NA] == 0 && B[i % NB] == 5) {
count_B++;
}
}
if (count_A > count_B) {
System.out.println("A");
} else if (count_A < count_B) {
System.out.println("B");
} else {
System.out.println("draw");
}
}
}74:有趣的跳跃
描述
一个长度为n（n>0）的序列中存在“有趣的跳跃”当前仅当相邻元素的差的绝对值经过排序后正好是从1到(n-1)。例如，1 4 2 3存在“有趣的跳跃”，因为差的绝对值分别为3,2,1。当然，任何只包含单个元素的序列一定存在“有趣的跳跃”。你需要写一个程序判定给定序列是否存在“有趣的跳跃”。
输入
一行，第一个数是n（0 < n < 3000），为序列长度，接下来有n个整数，依次为序列中各元素，各元素的绝对值均不超过1,000,000,000。
输出
一行，若该序列存在“有趣的跳跃”，输出"Jolly"，否则输出"Not jolly"。
样例输入
4 1 4 2 3
样例输出
Jolly
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
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; i < N; i++) {
a[i] = sc.nextInt();
}
List<Integer> list = new ArrayList<>();
for (int i = 1; i < N; i++) {
list.add(Math.abs(a[i] - a[i - 1]));
}
Collections.sort(list);
for (int i = 1; i < N; i++) {
if (list.get(i - 1) != i) {
System.out.println("Not jolly");
return;
}
}
System.out.println("Jolly");
}
}75:校门外的树
描述
某校大门外长度为L的马路上有一排树，每两棵相邻的树之间的间隔都是1米。我们可以把马路看成一个数轴，马路的一端在数轴0的位置，另一端在L的位置；数轴上的每个整数点，即0，1，2，……，L，都种有一棵树。
由于马路上有一些区域要用来建地铁。这些区域用它们在数轴上的起始点和终止点表示。已知任一区域的起始点和终止点的坐标都是整数，区域之间可能有重合的部分。现在要把这些区域中的树（包括区域端点处的两棵树）移走。你的任务是计算将这些树都移走后，马路上还有多少棵树。
输入
第一行有两个整数L（1 <= L <= 10000）和 M（1 <= M <= 100），L代表马路的长度，M代表区域的数目，L和M之间用一个空格隔开。接下来的M行每行包含两个不同的整数，用一个空格隔开，表示一个区域的起始点和终止点的坐标。
对于20%的数据，区域之间没有重合的部分；
对于其它的数据，区域之间有重合的情况。
输出
包括一行，这一行只包含一个整数，表示马路上剩余的树的数目。
样例输入
500 3
150 300
100 200
470 471
样例输出
298
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int L=sc.nextInt();
int M=sc.nextInt();
int[] a=new int[L + 1];
int tree=0,i,j;
for(i=0;i<M;i++) {
int start=sc.nextInt();
int end=sc.nextInt();
for (j=0;j<=L;j++){
if(j>=start&&j<=end){
a[j]=1;
}
}
}
for(i=0;i<=L;i++){
if (a[i] == 0){
tree++;
}
}
System.out.print(tree);
}
}76:年龄与疾病
描述
某医院想统计一下某项疾病的获得与否与年龄是否有关，需要对以前的诊断记录进行整理，按照0-18、19-35、36-60、61以上（含61）四个年龄段统计的患病人数占总患病人数的比例。
输入
共2行，第一行为过往病人的数目n（0 < n <= 100)，第二行为每个病人患病时的年龄。
输出
按照0-18、19-35、36-60、61以上（含61）四个年龄段输出该段患病人数占总患病人数的比例，以百分比的形式输出，精确到小数点后两位。每个年龄段占一行，共四行。
样例输入
10
1 11 21 31 41 51 61 71 81 91
样例输出
20.00%
20.00%
20.00%
40.00%
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt(), i, age;
double part1 = 0, part2 = 0, part3 = 0, part4 = 0;
double[] part = new double[4];
for (i = 0; i < n; i++) {
age = sc.nextInt();
if (0 <= age && age <= 18) {
part[0]++;
} else if (19 <= age && age <= 35) {
part[1]++;
} else if (36 <= age && age <= 60) {
part[2]++;
} else if (61 <= age) {
part[3]++;
}
}
for (i = 0; i < 4; i++) {
part[i] = part[i] * 100 / n;
System.out.printf("%.2f", part[i]);
System.out.print("%" + "\n");
}
}
}77:数组逆序重放
描述
将一个数组中的值按逆序重新存放。例如，原来的顺序为8,6,5,4,1。要求改为1,4,5,6,8。
输入
输入为两行：第一行数组中元素的个数n（1<n<100)，第二行是n个整数，每两个整数之间用空格分隔。
输出
输出为一行：输出逆序后数组的整数，每两个整数之间用空格分隔。
样例输入
5
8 6 5 4 1
样例输出
1 4 5 6 8
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; i < n; i++) {
a[i] = sc.nextInt();
}
for (int i = n - 1; i >= 0; i--) {
System.out.print(a[i] + " ");
}
}
}78:与指定数字相同的数的个数
描述
输出一个整数序列中与指定数字相同的数的个数。
输入
输入包含三行：
第一行为N，表示整数序列的长度(N <= 100)；
第二行为N个整数，整数之间以一个空格分开；
第三行包含一个整数，为指定的整数m。
输出
输出为N个数中与m相同的数的个数。
样例输入
3
2 3 2
2
样例输出
2
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int sum = 0;
int[] a = new int[N];
for (int i = 0; i < N; i++) {
a[i] = sc.nextInt();
}
int m = sc.nextInt();
for (int i = 0; i < N; i++) {
if (a[i] == m) {
sum += 1;
}
}
System.out.println(sum);
}
}79:寻找配对数
描述
在给定的n个互不相等的正整数中，寻找可以形成a*b=c的等式(a,b,c互不相等)的数目。比如在12,32,6,1,2,8,4中，只有2*4=8, 2*6=12, 4*8=32三对。
注意：给出的正整数互不相同。正整数的最大值为2^32-1，正整数的最大个数为1000.
输入
第一行输入总共的正整数数目n(n<=1000)
接下来的一行输入n个正整数，正整数之间用一个空格隔开。
输出
输出其中满足a*b=c等式的数目。
样例输入
7
8 6 3 4 10 5 2
样例输出
3
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();
int[] a = new int[n];
int count = 0, i, j, k;
for (i = 0; i < n; i++) {
a[i] = sc.nextInt();
}
Arrays.sort(a);
for (i = 0; i < n - 2; i++) {
for (j = i + 1; j < n - 1; j++) {
for (k = j + 1; k < n; k++) {
if (a[i] * a[j] == a[k]) {
count++;
}
}
}
}
System.out.print(count);
}
}80:数字求和
描述
Tom最近喜欢数字加法，她最喜欢把一行数据加在一起，然后输出。
输入
第一行有一个数字n,表示后面有n行数字。
以后的每一行数字，第一个数字m表示，该行要计算从该行第2个数字到m+1个数字之和。
输出
每一行对应一组输入数据的结果。
样例输入
3
3 1 2 3
2 10 20
4 1 2 3 1
样例输出
6
30
7
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 sum = 0;
int a = sc.nextInt();
for(int j = 0;j<a;j++){
sum+=sc.nextInt();
}
System.out.println(sum);
}
}
}81:向量点积计算
描述
在线性代数、计算几何中，向量点积是一种十分重要的运算。
给定两个n维向量a=(a1,a2,...,an)和b=(b1,b2,...,bn)，求点积a·b=a1b1+a2b2+...+anbn。
输入
第一行是一个整数n。1 <= n <= 1000。
第二行包含n个整数a1,a2,...,an。
第三行包含n个整数b1,b2,...,bn。
相邻整数之间用单个空格隔开。每个整数的绝对值都不超过1000。
输出
一个整数，即两个向量的点积结果。
样例输入
3
1 4 6
2 1 5
样例输出
36
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt(), i, sum = 0;
int[] a = new int[N];
int[] b = new int[N];
for (i = 0; i < N; i++) {
a[i] = sc.nextInt();
}
for (i = 0; i < N; i++) {
b[i] = sc.nextInt();
}
for (i = 0; i < N; i++) {
sum += b[i] * a[i];
}
System.out.println(sum);
}
}
