2021Q4 OD 考试试卷
例1
[编程题目]ACM模式单行输入输出规范示例
题目描述：
求a+b的和
输入描述：
多组输入，每一行有两个数A，B， 0 < A , B < 1000000
输出描述：
每行输出一个结果
示例1：
输入
1 1
输出
2
C
#include<stdio.h>
int main()
{
int a,b;
while(scanf("%d%d",&a,&b)!=EOF)
{
if(a>=0 && b>=0 && a<1000000 && b<1000000)
printf("%d\n",a+b);
}
return 0;
}Java
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
int a = sc.nextInt();
int b = sc.nextInt();
if(a < 0 || b < 0 || a > 1000000 || b > 1000000){
System.out.println("error");
}else{
System.out.println(a + b);
}
}
}
}C++
#include <iostream>
using namespace std;
// int main()
// {
// int a, b;
// while (cin >> a >> b) {
// cout << a + b << endl;
// }
// return 0;
// }
int main()
{
int a, b;
while (cin >> a >> b) {
if(a < 0 || b < 0 || a > 1000000 || b > 1000000)
{
cout << "error" << endl;
}else
{
cout << a + b << endl;
}
}
return 0;
}Python3
while True:
try:
a, b = map(int, input().split())
if 0 < a < 1000000 and 0 < b < 1000000:
print(a + b)
except:
break例2
输出n阶方阵所有数，求方阵里所有数的和
输入描述：
输入有多个测试用例，每个测试用例第一行为一个整数n（n<=1000）,
表示方阵阶数为。接下来是n行的数字，每行n个数用空格隔开。
输出描述：
输出一个整数，表示n阶方程的和
示例1
输入
3
1 2 3
2 1 3
3 2 1
输出
18
C
#include<stdio.h>
int main()
{
int n,i,j;
int matrix[1000][1000];
while(scanf("%d",&n)!=EOF)
{
int sum=0;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
{
scanf("%d",&matrix[i][j]);
sum+=matrix[i][j];
}
printf("%d\n",sum);
}
return 0;
}C++
#include <iostream>
using namespace std;
int main()
{
int n;
while (cin >> n)
{
int sum = 0;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
int num;
cin >> num;
sum += num;
}
}
cout << sum << endl;
}
return 0;
}Java
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
int n = sc.nextInt();
int sum = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
sum += sc.nextInt();
}
}
System.out.println(sum);
}
}
}Python3
while True:
try:
n = int(input())
arr = []
for _ in range(n):
arr.append(list(map(int, input().split())))
res = 0
for i in range(n):
for j in range(n):
res += arr[i][j]
print(res)
except:
break题目1
用java 完成
题目描述：
为了充分发挥GPU算力，需要尽可能多的将任务交给GPU
执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增的任务个数且每秒都有新增任务，假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成
输入描述：
第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]
第二个参数为任务数组长度，取值范围[1,10000]
第三个参数为任务数组，数字范围[1,10000]
输出描述：
执行完所有任务最少需要多少秒
示例1
输入
3
5
1 2 3 4 5
输出
6
说明
一次最多执行3个任务，最少耗时6s
示例2
输入
4
5
5 4 1 1 1
输出
5
说明
一次最多执行4个任务，最少耗时5s
C
#include <stdio.h>
int main() {
int n, length, i, total = 0;
int arr[10000];
scanf("%d %d", &n, &length);
for (i = 0; i < length; i++) {
scanf("%d", &arr[i]);
total += arr[i];
}
int res = (total % n == 0) ? (total / n) : (total / n + 1);
printf("%d\n", res);
return 0;
}C++
#include <iostream>
int main() {
int n, length, total = 0;
int arr[10000];
std::cin >> n >> length;
for (int i = 0; i < length; i++) {
std::cin >> arr[i];
total += arr[i];
}
int res = (total % n == 0) ? (total / n) : (total / n + 1);
std::cout << res << std::endl;
return 0;
}Java
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt(); // GPU一次最多执行的任务个数
int length = in.nextInt(); // 任务数组长度
int[] arr = new int[length];
for (int i = 0; i < length; i++) {
arr[i] = in.nextInt(); // 任务数组
}
in.close();
int time = 0;
for (int i = 0; i < length; i++) {
time += (int)Math.ceil(arr[i] / (double) n);
}
System.out.println(time);
}
}Python3
n, length = map(int, input().split())
arr = list(map(int, input().split()))
total = 0
for i in range(length):
total += arr[i]
res = (total % n == 0) ? (total // n) : (total // n + 1)
print(res)题目2
用Java完成
题目描述
第一行输入N，表示有N个坐标，0<=N<=100
第k行输入坐标x y(中间用空格隔开)，-10<=x,y<=10,
输出 输入N个坐标后构成正方形的个数
示例1
3
1 3
2 4
3 1
输出
0
说明
3个点不足以构成正方形
示例2
输入
4
0 0
1 2
3 1
2 -1
输出
1
说明
4个点构成1个正方形
C
#include <stdio.h>
int main()
{
int n;
scanf("%d", &n);
int points[n][2];
for (int i = 0; i < n; i++) {
scanf("%d %d", &points[i][0], &points[i][1]);
}
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
for (int k = j + 1; k < n; k++) {
for (int m = k + 1; m < n; m++) {
if (points[i][0] == points[j][0] && points[i][1] == points[k][1] && points[j][1] == points[m][1] && points[k][0] == points[m][0]) {
count++;
}
}
}
}
}
printf("%d\n", count);
return 0;
}C++
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int points[n][2];
for (int i = 0; i < n; i++) {
cin >> points[i][0] >> points[i][1];
}
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
for (int k = j + 1; k < n; k++) {
for (int m = k + 1; m < n; m++) {
if (points[i][0] == points[j][0] && points[i][1] == points[k][1] && points[j][1] == points[m][1] && points[k][0] == points[m][0]) {
count++;
}
}
}
}
}
cout << count << endl;
return 0;
}Java
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[][] points = new int[n][2];
for (int i = 0; i < n; i++) {
points[i][0] = sc.nextInt();
points[i][1] = sc.nextInt();
}
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
for (int k = j + 1; k < n; k++) {
for (int m = k + 1; m < n; m++) {
if (isSquare(points[i], points[j], points[k], points[m])) {
count++;
}
}
}
}
}
System.out.println(count);
}
public static boolean isSquare(int[] p1, int[] p2, int[] p3, int[] p4) {
if (p1[0] == p2[0] && p1[1] == p3[1] && p2[1] == p4[1] && p3[0] == p4[0])
return true;
return false;
}
}Python3
n = int(input())
points = []
for _ in range(n):
x, y = map(int, input().split())
points.append((x, y))
count = 0
for i in range(n):
for j in range(i + 1, n):
for k in range(j + 1, n):
for m in range(k + 1, n):
if points[i][0] == points[j][0] and points[i][1] == points[k][1] and points[j][1] == points[m][1] and points[k][0] == points[m][0]:
count += 1
print(count)题目3
用Java完成
题目描述
某文件系统中有N个目录，每个目录都一个独一无二的ID。
每个目录只有一个父目录，但每个父目录下可以有零个或者多个子目录，目录结构呈树状结构。
假设，根目录的ID为0，且根目录没有父目录，其他所有目录的ID用唯一的正整数表示，并统一编号。
现给定目录ID和其父目录ID的对应父子关系表[子目录ID，父目录ID]，
以及一个待删除的目录ID，请计算并返回一个ID序列，表示因为删除指定目录后剩下的所有目录，返回的ID序列以递增序输出。
注意：
1、被删除的目录或文件编号一定在输入的ID序列中；
2、当一个目录删除时，它所有的子目录都会被删除。
输入描述：
输入的第一行为父子关系表的长度m;接下来的m行为m个父子关系
对，最后一行为待删除的ID。序列中的元素以空格分割，参见详例。
输出描述：
输出一个序列，表示因为删除指定目录后，剩余的目录ID。
示例1
输入
5
8 6
10 8
6 0
20 8
2 6
8
输出
2 6
说明
目录结构如下所示：
//二叉树：[6,2,8,null,null,10,20],
6
/ \
2 8
/ \
10 20
删除目录8，同时它的子目录10也会被删除，剩余2和6两个目录。
(
即
m: 5
[子目录ID，父目录ID]
[8,6],
[10,8],
[6,0],
[2,6]
delete: 8
即 二叉树：
[6,2,8,null,null,10,20],
输出
2 6
)
C
C++
Java
import java.util.Scanner;
import java.util.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int m = sc.nextInt();
Map<Integer, List<Integer>> map = new HashMap<>();
while (m--> 0) {
int child = sc.nextInt();
int parent = sc.nextInt();
List<Integer> list = map.getOrDefault(parent, new ArrayList<>());
list.add(child);
map.put(parent, list);
}
int delete = sc.nextInt();
List<Integer> res = new ArrayList<>();
dfs(map, delete, res);
for (int i : res) {
System.out.print(i + " ");
}
}
private static void dfs(Map<Integer, List<Integer>> map, int delete, List<Integer> res) {
List<Integer> list = map.get(delete);
if (list != null) {
for (int i : list) {
dfs(map, i, res);
}
}
if (!res.contains(delete)) {
res.add(delete);
}
}
}Python3