PTA 基础编程题
本文详细解析了 PTA 基础编程题中的多道入门练习,涵盖单位换算、时间进制转换、数字逆序、BCD 解密、固定格式输出、混合输入输出、超速判断、找出不等球、工资
原题链接:https://pintia.cn/problem-sets/14/exam/problems/781?type=7&page=0
7-1 厘米换算英尺英寸
如果已知英制长度的英尺和英寸的值,那么对应的米是。现在,如果用户输入的是厘米数,那么对应英制长度的英尺和英寸是多少呢?别忘了1英尺等于12英寸。
输入格式:
输入在一行中给出1个正整数,单位是厘米。
输出格式:
在一行中输出这个厘米数对应英制长度的英尺和英寸的整数值,中间用空格分开。英寸的值应小于12。
输入样例:
sh
170
输出样例:
sh
5 6
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
这里用长整型接收,防止测试用例有些数字过大。注意计算的一些精度丢失情况。
java
import java.util.*;
// 7-1 厘米换算英尺英寸
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long num = sc.nextLong();
// 使用公式将米转换为英尺和英寸
long foot = (long) (num / 100.0 / 0.3048);
long inch = (long) ((num / 100.0 / 0.3048 - foot) * 12);
// 输出结果
System.out.println(foot + " " + inch);
}
}
7-2 然后是几点
有时候人们用四位数字表示一个时间,比如 1106 表示 11 点零 6 分。现在,你的程序要根据起始时间和流逝的时间计算出终止时间。
读入两个数字,第一个数字以这样的四位数字表示当前时间,第二个数字表示分钟数,计算当前时间经过那么多分钟后是几点,结果也表示为四位数字。当小时为个位数时,没有前导的零,例如 5 点 30 分表示为 530;0 点 30 分表示为 030。注意,第二个数字表示的分钟数可能超过 60,也可能是负数。
输入格式:
输入在一行中给出 2 个整数,分别是四位数字表示的起始时间、以及流逝的分钟数,其间以空格分隔。注意:在起始时间中,当小时为个位数时,没有前导的零,即 5 点 30 分表示为 530;0 点 30 分表示为 030。流逝的分钟数可能超过 60,也可能是负数。
输出格式:
输出不多于四位数字表示的终止时间,当小时为个位数时,没有前导的零。题目保证起始时间和终止时间在同一天内。
输入样例:
sh
1120 110
输出样例:
sh
1310
鸣谢燕山大学穆运峰老师、用户任钰补充数据!
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
// 7-2 然后是几点
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
String[] arr = s.split(" ");
String start = arr[0]; // 起始时间
Integer min = Integer.parseInt(arr[1]); // 流逝的分钟数 可能负数
if (start.length() == 3) {
start = "0" + start;
}
// 开始分钟数
Integer startMin = Integer.parseInt(start.substring(0, 2)) * 60 + Integer.parseInt(start.substring(2, 4));
Integer end = startMin + min;
System.out.print(end / 60);
Integer endMin = end % 60;
if(endMin<10) {
System.out.print(0);
}
System.out.print(endMin);
}
}
7-3 逆序的三位数
程序每次读入一个正3位数,然后输出按位逆序的数字。注意:当输入的数字含有结尾的0时,输出不应带有前导的0。比如输入700,输出应该是7。
输入格式:
每个测试是一个3位的正整数。
输出格式:
输出按位逆序的数。
输入样例:
sh
123
输出样例:
sh
321
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
// 7-3 逆序的三位数
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
int num = Integer.parseInt(s);
while (num % 10 == 0) {
num /= 10;
}
StringBuilder sb = new StringBuilder(num + "");
System.out.println(sb.reverse());
}
}
7-4 BCD解密
BCD数是用一个字节来表达两位十进制的数,每四个比特表示一位。所以如果一个BCD数的十六进制是0x12,它表达的就是十进制的12。但是小明没学过BCD,把所有的BCD数都当作二进制数转换成十进制输出了。于是BCD的0x12被输出成了十进制的18了!
现在,你的程序要读入这个错误的十进制数,然后输出正确的十进制数。提示:你可以把18转换回0x12,然后再转换回12。
输入格式:
输入在一行中给出一个[0, 153]范围内的正整数,保证能转换回有效的BCD数,也就是说这个整数转换成十六进制时不会出现A-F的数字。
输出格式:
输出对应的十进制数。
输入样例:
sh
18
输出样例:
sh
12
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
// 7-4 BCD解密
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String binary = Integer.toHexString(n);
System.out.println(binary);
}
}
7-5 表格输出
本题要求编写程序,按照规定格式输出表格。
输入格式:
本题目没有输入。
输出格式:
要求严格按照给出的格式输出下列表格:
sh
------------------------------------
Province Area(km2) Pop.(10K)
------------------------------------
Anhui 139600.00 6461.00
Beijing 16410.54 1180.70
Chongqing 82400.00 3144.23
Shanghai 6340.50 1360.26
Zhejiang 101800.00 4894.00
------------------------------------
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
public class Main {
public static void main(String[] args) {
System.out.println("------------------------------------\n"
+ "Province Area(km2) Pop.(10K)\n"
+ "------------------------------------\n"
+ "Anhui 139600.00 6461.00\n"
+ "Beijing 16410.54 1180.70\n"
+ "Chongqing 82400.00 3144.23\n"
+ "Shanghai 6340.50 1360.26\n"
+ "Zhejiang 101800.00 4894.00\n"
+ "------------------------------------");
}
}
7-6 混合类型数据格式化输入
本题要求编写程序,顺序读入浮点数1、整数、字符、浮点数2,再按照字符、整数、浮点数1、浮点数2的顺序输出。
输入格式:
输入在一行中顺序给出浮点数1、整数、字符、浮点数2,其间以1个空格分隔。
输出格式:
在一行中按照字符、整数、浮点数1、浮点数2的顺序输出,其中浮点数保留小数点后2位。
输入样例:
sh
2.12 88 c 4.7
输出样例:
sh
c 88 2.12 4.70
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
// 7-6 混合类型数据格式化输入
public class Main {
public static void main(String[] args) {
// 顺序读入浮点数1、整数、字符、浮点数2,再按照字符、整数、浮点数1、浮点数2的顺序输出。
Scanner sc = new Scanner(System.in);
double f1 = sc.nextDouble();
int i = sc.nextInt();
String s = sc.next();
double f2 = sc.nextDouble();
System.out.printf("%s %d %.2f %.2f", s, i, f1, f2);
}
}
7-7 12-24小时制
编写一个程序,要求用户输入24小时制的时间,然后显示12小时制的时间。
输入格式:
输入在一行中给出带有中间的:符号(半角的冒号)的24小时制的时间,如12:34表示12点34分。当小时或分钟数小于10时,均没有前导的零,如5:6表示5点零6分。
提示:在scanf的格式字符串中加入:,让scanf来处理这个冒号。
输出格式:
在一行中输出这个时间对应的12小时制的时间,数字部分格式与输入的相同,然后跟上空格,再跟上表示上午的字符串AM或表示下午的字符串PM。如5:6 PM表示下午5点零6分。注意,在英文的习惯中,中午12点被认为是下午,所以24小时制的12:00就是12小时制的12:0 PM;而0点被认为是第二天的时间,所以是0:0 AM。
输入样例:
sh
21:11
输出样例:
sh
9:11 PM
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
// 7-7 12-24小时制
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String time = sc.next();
String[] arr = time.split(":");
int hour = Integer.parseInt(arr[0]);
boolean isPm = false;
if (hour > 12) {
isPm = true;
hour -= 12;
}
if (hour == 12) {
isPm = true;
}
System.out.printf("%d:%d %s", hour, Integer.parseInt(arr[1]), isPm ? "PM" : "AM");
}
}
7-8 超速判断
模拟交通警察的雷达测速仪。输入汽车速度,如果速度超出60 mph,则显示“Speeding”,否则显示“OK”。
输入格式:
输入在一行中给出1个不超过500的非负整数,即雷达测到的车速。
输出格式:
在一行中输出测速仪显示结果,格式为:Speed: V - S,其中V是车速,S或者是Speeding、或者是OK。
输入样例1:
sh
40
输出样例1:
sh
Speed: 40 - OK
输入样例2:
sh
75
输出样例2:
sh
Speed: 75 - Speeding
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
// 7-8 超速判断
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int speed = sc.nextInt();
System.out.printf("Speed: %d - %s", speed, speed > 60 ? "Speeding" : "OK");
}
}
7-9 用天平找小球
三个球A、B、C,大小形状相同且其中有一个球与其他球重量不同。要求找出这个不一样的球。
输入格式:
输入在一行中给出3个正整数,顺序对应球A、B、C的重量。
输出格式:
在一行中输出唯一的那个不一样的球。
输入样例:
sh
1 1 2
输出样例:
sh
C
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
// 7-9 用天平找小球
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[] counts = new int[3];
for (int i = 0; i < 3; i++) {
counts[i] = sc.nextInt();
}
if (counts[0] == counts[1]) {
System.out.println("C");
} else if (counts[0] == counts[2]) {
System.out.println("B");
} else {
System.out.println("A");
}
}
}
7-10 计算工资
某公司员工的工资计算方法如下:一周内工作时间不超过40小时,按正常工作时间计酬;超出40小时的工作时间部分,按正常工作时间报酬的1.5倍计酬。员工按进公司时间分为新职工和老职工,进公司不少于5年的员工为老职工,5年以下的为新职工。新职工的正常工资为30元/小时,老职工的正常工资为50元/小时。请按该计酬方式计算员工的工资。
输入格式:
输入在一行中给出2个正整数,分别为某员工入职年数和周工作时间,其间以空格分隔。
输出格式:
在一行输出该员工的周薪,精确到小数点后2位。
输入样例1:
sh
5 40
输出样例1:
sh
2000.00
输入样例2:
sh
3 50
输出样例2:
sh
1650.00
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
// 7-10 计算工资
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int year = sc.nextInt();
int workTime = sc.nextInt();
int salary = year >= 5 ? 50 : 30;
int jiaban = workTime - 40;
jiaban = jiaban < 0 ? 0 : jiaban;
double money = salary * (workTime - jiaban) + salary * 1.5 * jiaban;
System.out.printf("%.2f", money);
}
}
7-11 分段计算居民水费
为鼓励居民节约用水,自来水公司采取按用水量阶梯式计价的办法,居民应交水费(元)与月用水量(吨)相关:当不超过15吨时,;超过后,。请编写程序实现水费的计算。
输入格式:
输入在一行中给出非负实数x。
输出格式:
在一行输出应交的水费,精确到小数点后2位。
输入样例1:
sh
12
输出样例1:
sh
16.00
输入样例2:
sh
16
输出样例2:
sh
22.50
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
// 7-11 分段计算居民水费
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
double x = sc.nextInt();
if (x < 15) {
System.out.printf("%.2f", 4 * x / 3);
} else {
System.out.printf("%.2f", (2.5 * x) - 17.5);
}
}
}
7-12 两个数的简单计算器
本题要求编写一个简单计算器程序,可根据输入的运算符,对2个整数进行加、减、乘、除或求余运算。题目保证输入和输出均不超过整型范围。
输入格式:
输入在一行中依次输入操作数1、运算符、操作数2,其间以1个空格分隔。操作数的数据类型为整型,且保证除法和求余的分母非零。
输出格式:
当运算符为+、-、*、/、%时,在一行输出相应的运算结果。若输入是非法符号(即除了加、减、乘、除和求余五种运算符以外的其他符号)则输出ERROR。
输入样例1:
sh
-7 / 2
输出样例1:
sh
-3
输入样例2:
sh
3 & 6
输出样例2:
sh
ERROR
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
String b = sc.next();
int y = sc.nextInt();
if (b.equals("+")) {
System.out.print(x + y);
} else if (b.equals("-")) {
System.out.print(x - y);
} else if (b.equals("*")) {
System.out.print(x * y);
} else if (b.equals("/")) {
System.out.print(x / y);
} else if (b.equals("%")) {
System.out.print(x % y);
} else {
System.out.print("ERROR");
}
}
}
7-13 日K蜡烛图
股票价格涨跌趋势,常用蜡烛图技术中的K线图来表示,分为按日的日K线、按周的周K线、按月的月K线等。以日K线为例,每天股票价格从开盘到收盘走完一天,对应一根蜡烛小图,要表示四个价格:开盘价格Open(早上刚刚开始开盘买卖成交的第1笔价格)、收盘价格Close(下午收盘时最后一笔成交的价格)、中间的最高价High和最低价Low。
如果Close<Open,表示为“BW-Solid”(即“实心蓝白蜡烛”);如果Close>Open,表示为“R-Hollow”(即“空心红蜡烛”);如果Open等于Close,则为“R-Cross”(即“十字红蜡烛”)。如果Low比Open和Close低,称为“Lower Shadow”(即“有下影线”),如果High比Open和Close高,称为“Upper Shadow”(即“有上影线”)。请编程序,根据给定的四个价格组合,判断当日的蜡烛是一根什么样的蜡烛。
输入格式:
输入在一行中给出4个正实数,分别对应Open、High、Low、Close,其间以空格分隔。
输出格式:
在一行中输出日K蜡烛的类型。如果有上、下影线,则在类型后加上with 影线类型。如果两种影线都有,则输出with Lower Shadow and Upper Shadow。
输入样例1:
sh
5.110 5.250 5.100 5.105
输出样例1:
sh
BW-Solid with Lower Shadow and Upper Shadow
输入样例2:
sh
5.110 5.110 5.110 5.110
输出样例2:
sh
R-Cross
输入样例3:
sh
5.110 5.125 5.112 5.126
输出样例3:
sh
R-Hollow
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
// 7-13 日K蜡烛图
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
double Open = sc.nextDouble();
double High = sc.nextDouble();
double Low = sc.nextDouble();
double Close = sc.nextDouble();
StringBuilder sb = new StringBuilder();
if (Close < Open) {
sb.append("BW-Solid");
} else if (Close == Open) {
sb.append("R-Cross");
} else {
sb.append("R-Hollow");
}
// Low比Open和Close低,称为“Lower Shadow”(即“有下影线”)
// 如果High比Open和Close高,称为“Upper Shadow”(即“有上影线”)
if (((Low < Open && Low < Close) && (High > Open && High > Close))) {
sb.append(" with Lower Shadow and Upper Shadow");
} else if (Low < Open && Low < Close) {
sb.append(" with Lower Shadow");
} else if (High > Open && High > Close) {
sb.append(" with Upper Shadow");
}
System.out.print(sb);
}
}
7-14 求整数段和
给定两个整数和,输出从到的所有整数以及这些数的和。
输入格式:
输入在一行中给出2个整数和,其中,其间以空格分隔。
输出格式:
首先顺序输出从A到B的所有整数,每5个数字占一行,每个数字占5个字符宽度,向右对齐。最后在一行中按Sum = X的格式输出全部数字的和X。
输入样例:
sh
-3 8
输出样例:
sh
-3 -2 -1 0 1
2 3 4 5 6
7 8
Sum = 30
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
// 7-14 求整数段和
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int begin = sc.nextInt();
int end = sc.nextInt();
int sum = 0;
int count = 0;
for (int i = begin; i <= end; i++) {
System.out.printf("%5d", i);
sum += i;
count++;
if (count % 5 == 0 && end != i) {
System.out.print("\n");
}
}
System.out.printf("\nSum = %d", sum);
}
}
7-15 计算圆周率
根据下面关系式,求圆周率的值,直到最后一项的值小于给定阈值。

输入格式:
输入在一行中给出小于1的阈值。
输出格式:
在一行中输出满足阈值条件的近似圆周率,输出到小数点后6位。
输入样例:
sh
0.01
输出样例:
sh
3.132157
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.*;
// 7-15 计算圆周率
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
double min = sc.nextDouble();
double pi = 1;
int i = 1;
double res = 1;
while (pi > min) {
// 每一个数都是 上一个数 * n/(2n+1)
pi = pi * i / (1 + 2 * i);
res += pi; // 求和
i++;
}
System.out.printf("%.6f", res * 2);
}
}
7-16 求符合给定条件的整数集
给定不超过6的正整数A,考虑从A开始的连续4个数字。请输出所有由它们组成的无重复数字的3位数。
输入格式:
输入在一行中给出A。
输出格式:
输出满足条件的的3位数,要求从小到大,每行6个整数。整数间以空格分隔,但行末不能有多余空格。
输入样例:
sh
2
输出样例:
sh
234 235 243 245 253 254
324 325 342 345 352 354
423 425 432 435 452 453
523 524 532 534 542 543
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
// 7-16 求符合给定条件的整数集
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] arrs = new int[] { n, n + 1, n + 2, n + 3 };
int count = 0;
for (int i = 0; i < arrs.length; i++) {
for (int j = 0; j < arrs.length; j++) {
if (i == j)
continue;
for (int k = 0; k < arrs.length; k++) {
if (i == k || j == k)
continue;
System.out.printf("%d%d%d", arrs[i], arrs[j], arrs[k]);
count++;
if (count % 6 == 0) {
System.out.print("\n");
} else {
System.out.print(" ");
}
}
}
}
}
}
7-17 爬动的蠕虫
一条蠕虫长1寸,在一口深为N寸的井的底部。已知蠕虫每1分钟可以向上爬U寸,但必须休息1分钟才能接着往上爬。在休息的过程中,蠕虫又下滑了D寸。就这样,上爬和下滑重复进行。请问,蠕虫需要多长时间才能爬出井?
这里要求不足1分钟按1分钟计,并且假定只要在某次上爬过程中蠕虫的头部到达了井的顶部,那么蠕虫就完成任务了。初始时,蠕虫是趴在井底的(即高度为0)。
输入格式:
输入在一行中顺序给出3个正整数N、U、D,其中D<U,N不超过100。
输出格式:
在一行中输出蠕虫爬出井的时间,以分钟为单位。
输入样例:
sh
12 3 1
输出样例:
sh
11
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
// 7-17 爬动的蠕虫
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
double N = sc.nextInt(); // 井深
double U = sc.nextInt(); // 每分钟移动距离
double D = sc.nextInt(); // 休息的时候下滑多少距离
int high = 0, time = 0;
while (high < N) {
high += U;
time++;
if (high >= N) {
break;
}
high -= D;
time++;
}
System.out.println(time);
}
}
7-18 二分法求多项式单根
二分法求函数根的原理为:如果连续函数f(x)在区间[a,b]的两个端点取值异号,即f(a)f(b)<0,则它在这个区间内至少存在1个根r,即f(r)=0。
二分法的步骤为:
- 检查区间长度,如果小于给定阈值,则停止,输出区间中点;否则
- 如果,则计算中点的值;
- 如果正好为0,则就是要求的根;否则
- 如果与同号,则说明根在区间,令,重复循环;
- 如果与同号,则说明根在区间,令,重复循环。
本题目要求编写程序,计算给定3阶多项式
在给定区间内的根。
输入格式:
输入在第1行中顺序给出多项式的4个系数、、、,在第2行中顺序给出区间端点和。题目保证多项式在给定区间内存在唯一单根。
输出格式:
在一行中输出该多项式在该区间内的根,精确到小数点后2位。
输入样例:
sh
3 -1 -3 1
-0.5 0.5
输出样例:
sh
0.33
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
// 7-18 二分法求多项式单根
public class Main {
static double a3;
static double a2;
static double a1;
static double a0;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// a3 x^3 +a2 x^2 + a1 x + a0
a3 = sc.nextDouble();
a2 = sc.nextDouble();
a1 = sc.nextDouble();
a0 = sc.nextDouble();
double a = sc.nextDouble();
double b = sc.nextDouble();
double mid = 0;
while(b-a>=0.001&&f(a)*f(b)<=0){
if(f(a)==0){
mid=a;
break;
}
else if(f(b)==0){
mid=b;
break;
}
mid=(a+b)/2;
if(f(mid)==0){
break;
}
else
{
if(f(a)*f(mid)>=0){
a=(a + b) / 2;
}
else{
b=(a + b) / 2;
}
}
}
System.out.printf("%.2f",mid);
}
public static double f(double x) {
return a3 * x * x * x + a2 * x * x + a1 * x + a0;
}
}
7-19 支票面额
一个采购员去银行兑换一张元分的支票,结果出纳员错给了元分。采购员用去了分之后才发觉有错,于是清点了余额尚有元分,问该支票面额是多少?
输入格式:
输入在一行中给出小于100的正整数。
输出格式:
在一行中按格式y.f输出该支票的原始面额。如果无解,则输出No Solution。
输入样例1:
sh
23
输出样例1:
sh
25.51
输入样例2:
sh
22
输出样例2:
sh
No Solution
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
// 7-19 支票面额
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
// 原来的金额 分:y*100 + f
// 错给的金额 分:f*100 + y
// 采购员用去了 分: n
// 剩余余额尚有 分: 2*y*100 + 2*f
// 故得出关系: f * 100 + y - n = 2 * y * 100 + 2 * f
// 化简: f * 98 - 199 * y = n
for (int f = 0; f < 100; f++) {
for (int y = 0; y < 100; y++) {
int fail = f * 100 + y;
int yu = 2 * y * 100 + 2 * f;
if (fail - yu == n) {
System.out.printf("%d.%d", y, f);
return;
}
}
}
System.out.print("No Solution");
}
}
7-20 打印九九口诀表
下面是一个完整的下三角九九口诀表:
sh
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
本题要求对任意给定的一位正整数N,输出从1*1到N*N的部分口诀表。
输入格式:
输入在一行中给出一个正整数N(1≤N≤9)。
输出格式:
输出下三角N*N部分口诀表,其中等号右边数字占4位、左对齐。
输入样例:
sh
4
输出样例:
sh
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
// 7-20 打印九九口诀表
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++) {
for (int j = 1; j <= i; j++) {
System.out.printf("%d*%d=%-4d", j, i, i * j);
}
System.out.println();
}
}
}
7-21 求特殊方程的正整数解
本题要求对任意给定的正整数,求方程的全部正整数解。
输入格式:
输入在一行中给出正整数(≤10000)。
输出格式:
输出方程的全部正整数解,其中。每组解占1行,两数字间以1空格分隔,按X的递增顺序输出。如果没有解,则输出No Solution。
输入样例1:
sh
884
输出样例1:
sh
10 28
20 22
输入样例2:
sh
11
输出样例2:
sh
No Solution
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
// 7-21 求特殊方程的正整数解
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
boolean flag = false;
// x与y为正整数
for (int x = 1; x <= 100; x++) {
for (int y = 1; y <= 100; y++) {
if ((x * x + y * y) == n && x <= y) {
System.out.printf("%d %d\n", x, y);
flag = true;
}
}
}
if (!flag)
System.out.println("No Solution");
}
}
7-22 龟兔赛跑
乌龟与兔子进行赛跑,跑场是一个矩型跑道,跑道边可以随地进行休息。乌龟每分钟可以前进3米,兔子每分钟前进9米;兔子嫌乌龟跑得慢,觉得肯定能跑赢乌龟,于是,每跑10分钟回头看一下乌龟,若发现自己超过乌龟,就在路边休息,每次休息30分钟,否则继续跑10分钟;而乌龟非常努力,一直跑,不休息。假定乌龟与兔子在同一起点同一时刻开始起跑,请问T分钟后乌龟和兔子谁跑得快?
输入格式:
输入在一行中给出比赛时间T(分钟)。
输出格式:
在一行中输出比赛的结果:乌龟赢输出@_@,兔子赢输出^_^,平局则输出-_-;后跟1空格,再输出胜利者跑完的距离。
输入样例:
sh
242
输出样例:
sh
@_@ 726
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
// 7-22 龟兔赛跑
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int all = sc.nextInt(); // 比赛时间
int time = 0, rabbit = 0, turtle = 0;
while (time < all) {
// 每跑10分钟回头看一下乌龟,若发现自己超过乌龟,就在路边休息,每次休息30分钟
if (time % 10 == 0 && rabbit > turtle) {
int relax = 30;
// 防止休息中途比赛时间结束
if (time + 30 > all) {
relax = all - time;
}
time += relax;
turtle += 3 * relax;
}
if (time >= all) {
break;
}
time += 1;
rabbit += 9;
turtle += 3;
}
if (rabbit > turtle) {
System.out.printf("^_^ %d", rabbit);
} else if (rabbit < turtle) {
System.out.printf("@_@ %d", turtle);
} else {
System.out.printf("-_- %d", rabbit);
}
}
}
7-23 币值转换
输入一个整数(位数不超过9位)代表一个人民币值(单位为元),请转换成财务要求的大写中文格式。如23108元,转换后变成“贰万叁仟壹百零捌”元。为了简化输出,用小写英文字母a-j顺序代表大写数字0-9,用S、B、Q、W、Y分别代表拾、百、仟、万、亿。于是23108元应被转换输出为“cWdQbBai”元。
输入格式:
输入在一行中给出一个不超过9位的非负整数。
输出格式:
在一行中输出转换后的结果。注意“零”的用法必须符合中文习惯。
输入样例1:
sh
813227345
输出样例1:
sh
iYbQdBcScWhQdBeSf
输入样例2:
sh
6900
输出样例2:
sh
gQjB
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.*;
// 7-23 币值转换
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String n = sc.next();
int length = n.length();
int[] num = new int[length + 1];
char[] lit = new char[] { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j' };
String[] uni = { "", "S", "B", "Q" };
// 将输入的数字 逆序 放进数组
for (int i = 0; i < length; i++) {
num[length - i] = n.charAt(i) - 48;
}
int count = 0; // 当前处理的数字
int count0 = 0; // 统计0的个数
StringBuilder sb = new StringBuilder();
// 处理数字是0的情况
if (n.equals("0")) {
System.out.print("a");
} else {
// 处理亿的情况
if (length == 9) {
sb.append(lit[num[9]]).append("Y");
length -= 1; // 更新剩余需要处理的数字长度
}
// 处理上万到亿之间
// 8,8888,8888
if (length > 4 && length < 9) {
for (int i = length; i > 4; i--) {
int cur = num[i]; // 当前要处理的数字
// 遇到数字为0的情况要不输出单位
// 如果全是0,那么就没必要输出了
if (cur != 0) {
sb.append(lit[cur]).append(uni[i - 5]);
// 如果当前数字后面都是0
for (int j = i - 1; j > 4; j--) {
if (num[j] == 0) {
count0++; // 累计连续0的个数
}
}
// 当前范围内的数字全是0
if (i - 1 - 4 == count0) {
break;
}
count0 = 0; // 重置连续0的个数
} else {
// 判断当前数字是0,则判断它前面的数字是否是0
// 不是0,则记录当前这个0
if (num[i + 1] != 0) {
sb.append(lit[cur]);
}
count++; // 累计遇到的0的个数
}
}
// 如果遇到0的个数小于4个。
// 如:8,8008,0000 // 这种可以输出万
// 如:8,0000,0000 // 万到亿之间都是0,那么不输出万
if (count < 4) {
sb.append("W");
}
if (length == 8) {
length -= 4; // 更新剩余需要处理的数量
} else {
// 不足8个数的情况
int wn = length % 4; // 万以上部分数字的数量
length -= wn;
}
}
count0 = 0; // 重置
// 处理个位数到万以内的数字
if (length > 0 && length < 5) {
for (int i = length; i > 0; i--) {
// 遇到数字为0的情况要不输出单位
int cur = num[i]; // 当前要处理的数字
if (cur != 0) {
sb.append(lit[cur]).append(uni[i - 1]);
// 如果当前数字后面都是0
for (int j = i - 1; j > 0; j--) {
if (num[j] == 0) {
count0++; // 累计连续0的个数
}
}
// 当前范围内的数字全是0
if (i - 1 == count0) {
break;
}
count0 = 0; // 重置连续0的个数
} else {
// 当前数字是0
// 前面还是0,那么不输出这个0
if (num[i + 1] != 0 || i == 4) {
sb.append(lit[cur]);
}
}
}
}
// 处理末尾的0
String res = sb.toString();
char[] arr = res.toCharArray();
int ans = 0;
for (int i = arr.length - 1; i > 0; i--) {
if (arr[i] == 'a') {
ans++;
} else {
break;
}
}
System.out.print(res.substring(0, arr.length - ans));
}
}
}
7-24 约分最简分式
分数可以表示为分子/分母的形式。编写一个程序,要求用户输入一个分数,然后将其约分为最简分式。最简分式是指分子和分母不具有可以约分的成分了。如6/12可以被约分为1/2。当分子大于分母时,不需要表达为整数又分数的形式,即11/8还是11/8;而当分子分母相等时,仍然表达为1/1的分数形式。
输入格式:
输入在一行中给出一个分数,分子和分母中间以斜杠/分隔,如:12/34表示34分之12。分子和分母都是正整数(不包含0,如果不清楚正整数的定义的话)。
提示:
- 对于C语言,在
scanf的格式字符串中加入/,让scanf来处理这个斜杠。 - 对于Python语言,用
a,b=map(int, input().split('/'))这样的代码来处理这个斜杠。
输出格式:
在一行中输出这个分数对应的最简分式,格式与输入的相同,即采用分子/分母的形式表示分数。如
5/6表示6分之5。
输入样例:
sh
66/120
输出样例:
sh
11/20
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
// 7-24 约分最简分式
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = sc.next();
String[] arr = str.split("/");
int fenzi = Integer.parseInt(arr[0]);
int fenmu = Integer.parseInt(arr[1]);
int min = fenmu > fenzi ? fenzi : fenmu;
for (int i = min; i >= 1; i--) {
if (fenmu % i == 0 && fenzi % i == 0) {
fenmu /= i;
fenzi /= i;
}
}
System.out.printf("%d/%d", fenzi, fenmu);
}
}
7-25 念数字
输入一个整数,输出每个数字对应的拼音。当整数为负数时,先输出fu字。十个数字对应的拼音如下:
sh
0: ling
1: yi
2: er
3: san
4: si
5: wu
6: liu
7: qi
8: ba
9: jiu
输入格式:
输入在一行中给出一个整数,如:1234。
提示:整数包括负数、零和正数。
输出格式:
在一行中输出这个整数对应的拼音,每个数字的拼音之间用空格分开,行末没有最后的空格。如
yi er san si。
输入样例:
sh
-600
输出样例:
sh
fu liu ling ling
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.*;
// 7-25 念数字
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String n = sc.next();
StringBuilder sb = new StringBuilder();
int start = 0;
String[] pinyin = new String[] { "ling", "yi", "er", "san", "si", "wu", "liu", "qi", "ba", "jiu" };
if (Integer.parseInt(n) < 0) {
sb.append("fu ");
start++;
}
for (int i = start; i < n.length(); i++) {
int cur = Integer.parseInt(n.charAt(i) + "");
sb.append(pinyin[cur] + " ");
}
sb.delete(sb.length() - 1, sb.length());
System.out.println(sb);
}
}
7-26 单词长度
你的程序要读入一行文本,其中以空格分隔为若干个单词,以.结束。你要输出每个单词的长度。这里的单词与语言无关,可以包括各种符号,比如it's算一个单词,长度为4。注意,行中可能出现连续的空格;最后的.不计算在内。
输入格式:
输入在一行中给出一行文本,以.结束
提示:用scanf("%c",...);来读入一个字符,直到读到.为止。
输出格式:
在一行中输出这行文本对应的单词的长度,每个长度之间以空格隔开,行末没有最后的空格。
输入样例:
sh
It's great to see you here.
输出样例:
sh
4 5 2 3 3 4
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
// 7-26 单词长度
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String word = sc.nextLine().trim();
word = word.replace(".", "");
String[] words = word.split(" +"); // 处理连续多个空格
if (words[0].length() != 0)
System.out.print(words[0].length());
for (int i = 1; i < words.length; i++) {
System.out.print(" " + words[i].length());
}
}
}
7-27 冒泡法排序
将个整数按从小到大排序的冒泡排序法是这样工作的:从头到尾比较相邻两个元素,如果前面的元素大于其紧随的后面元素,则交换它们。通过一遍扫描,则最后一个元素必定是最大的元素。然后用同样的方法对前个元素进行第二遍扫描。依此类推,最后只需处理两个元素,就完成了对个数的排序。
本题要求对任意给定的,输出扫描完第K遍后的中间结果数列。
输入格式:
输入在第1行中给出和,在第2行中给出个待排序的整数,数字间以空格分隔。
输出格式:
在一行中输出冒泡排序法扫描完第K遍后的中间结果数列,数字间以空格分隔,但末尾不得有多余空格。
输入样例:
sh
6 2
2 3 5 1 6 4
输出样例:
sh
2 1 3 4 5 6
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
// 7-27 冒泡法排序
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 输入在第1行中给出N和K(1≤K<N≤100),在第2行中给出N个待排序的整数,数字间以空格分隔。
int n = sc.nextInt();
int k = sc.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = sc.nextInt();
}
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
if (k == ++count) {
break;
}
}
System.out.print(arr[0]);
for (int i = 1; i < n; i++) {
System.out.print(" " + arr[i]);
}
}
}
7-28 猴子选大王
一群猴子要选新猴王。新猴王的选择方法是:让N只候选猴子围成一圈,从某位置起顺序编号为1~N号。从第1号开始报数,每轮从1报到3,凡报到3的猴子即退出圈子,接着又从紧邻的下一只猴子开始同样的报数。如此不断循环,最后剩下的一只猴子就选为猴王。请问是原来第几号猴子当选猴王?
输入格式:
输入在一行中给一个正整数N()。
输出格式:
在一行中输出当选猴王的编号。
输入样例:
sh
11
输出样例:
sh
7
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
// 7-28 猴子选大王
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] arr = new int[n];
int count = 0, index = 0, res = -1, exit = 0;
while (true) {
// 剩最后一只猴子
if (n - exit == 1 && arr[index] == 0) {
res = index;
break;
}
// 只有当前的猴子还未退出,才处理
if (arr[index] == 0) {
count++; // 计当前处理第几只猴子
// 第三个退出
if (count == 3) {
arr[index] = 1;
count = 0;
exit++; // 已退出的猴子数
}
}
if (++index == n) {
index = 0;
}
}
System.out.print(res + 1);
}
}
7-29 删除字符串中的子串
输入2个字符串S1和S2,要求删除字符串S1中出现的所有子串S2,即结果字符串中不能包含S2。
输入格式:
输入在2行中分别给出不超过80个字符长度的、以回车结束的2个非空字符串,对应S1和S2。
输出格式:
在一行中输出删除字符串S1中出现的所有子串S2后的结果字符串。
输入样例:
sh
Tomcat is a male ccatat
cat
输出样例:
sh
Tom is a male
sh
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
题解
注意,末尾可能有空格。不要去除。
java
import java.util.Scanner;
// 7-29 删除字符串中的子串
public class Main {
// Tomcat is a male ccatat
// cat
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
String s = sc.nextLine();
while (str.contains(s)) {
str = str.replace(s, "");
}
System.out.print(str);
}
}
7-30 字符串的冒泡排序
我们已经知道了将个整数按从小到大排序的冒泡排序法。本题要求将此方法用于字符串序列,并对任意给定的,输出扫描完第K遍后的中间结果序列。
输入格式:
输入在第1行中给出和,此后行,每行包含一个长度不超过10的、仅由小写英文字母组成的非空字符串。
输出格式:
输出冒泡排序法扫描完第遍后的中间结果序列,每行包含一个字符串。
输入样例:
sh
6 2
best
cat
east
a
free
day
输出样例:
sh
best
a
cat
day
east
free
sh
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
题解
java
import java.util.Scanner;
// 7-30 字符串的冒泡排序
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int k = sc.nextInt();
String[] strs = new String[n];
for (int i = 0; i < n; i++) {
strs[i] = sc.next();
}
for (int i = 0; i < k; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (strs[j].compareTo(strs[j + 1]) > 0) {
String temp = strs[j];
strs[j] = strs[j + 1];
strs[j + 1] = temp;
}
}
}
for (int i = 0; i < n; i++) {
System.out.println(strs[i]);
}
}
}
7-31 字符串循环左移
输入一个字符串和一个非负整数,要求将字符串循环左移次。
输入格式:
输入在第1行中给出一个不超过100个字符长度的、以回车结束的非空字符串;第2行给出非负整数。
输出格式:
在一行中输出循环左移次后的字符串。
输入样例:
sh
Hello World!
2
输出样例:
sh
llo World!He
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
// 7-31 字符串循环左移
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
int n = sc.nextInt();
n = n % s.length();
System.out.printf("%s%s", s.substring(n, s.length()), s.substring(0, n));
}
}
7-32 说反话-加强版
给定一句英语,要求你编写程序,将句中所有单词的顺序颠倒输出。
输入格式:
测试输入包含一个测试用例,在一行内给出总长度不超过500 000的字符串。字符串由若干单词和若干空格组成,其中单词是由英文字母(大小写有区分)组成的字符串,单词之间用若干个空格分开。
输出格式:
每个测试用例的输出占一行,输出倒序后的句子,并且保证单词间只有1个空格。
输入样例:
sh
Hello World Here I Come
输出样例:
sh
Come I Here World Hello
感谢杭州电子科技大学李卫明老师修正数据! 感谢浙江工业大学之江学院石洗凡老师修正测试点提示。
sh
代码长度限制 16 KB
时间限制 300 ms
内存限制 64 MB
题解
java
import java.util.*;
// 7-32 说反话-加强版
// 最大句子,卡strcat:前250000个字母组成1个单词,后面每个单词1个字母
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
//String a = input.nextLine();
//String[] b = a.split("[\\s.]+");//结尾的空格可以去掉
String a = input.nextLine().trim();
String[] b = a.split(" +");
int i;
for(i=b.length-1;i>0;i--) {
System.out.print(b[i]+" ");
}
System.out.print(b[0]);
}
}
这题运行超时了

c语言使用双指针遇到空格输出单词的方法,就通过了,速度贼快。。
c
#include<stdio.h>
#include<string.h>
int main()
{
char str[500001];
gets(str);
int b = strlen(str)-1; //单词开始指针
int e = b; //单词结束指针
int tmp = b;
int flag = 1;
while (b > 0)
{
if (str[b] == 32 && b == e)
{
// 多个空格跳过
b--;
e--;
}
else if (str[b] == 32 && b < e)
{
// 该输出一个单词了
if(flag)
{
flag = 0;
}
else
{
printf(" ");
}
tmp = b + 1;
while (tmp <= e)
{
printf("%c", str[tmp]);
tmp++;
}
b--;
e = b;
}
else
{
b--;
}
}
if (b != e || e == 0)
{
// 输出最后一个单词
if(str[b] != 32)
{
if(flag)
{
flag = 0;
}
else
{
printf(" ");
}
tmp = b;
while (tmp <= e)
{
printf("%c", str[tmp]);
tmp++;
}
}
}
}

7-33 有理数加法
本题要求编写程序,计算两个有理数的和。
输入格式:
输入在一行中按照a1/b1 a2/b2的格式给出两个分数形式的有理数,其中分子和分母全是整形范围内的正整数。
输出格式:
在一行中按照a/b的格式输出两个有理数的和。注意必须是该有理数的最简分数形式,若分母为1,则只输出分子。
输入样例1:
sh
1/3 1/6
输出样例1:
sh
1/2
输入样例2:
sh
4/3 2/3
输出样例2:
sh
2
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.Scanner;
// 7-33 有理数加法
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
String[] arr = str.split(" ");
int a1 = Integer.parseInt(arr[0].split("/")[0]);
int b1 = Integer.parseInt(arr[0].split("/")[1]);
int a2 = Integer.parseInt(arr[1].split("/")[0]);
int b2 = Integer.parseInt(arr[1].split("/")[1]);
int a = a1 * b2 + a2 * b1; // 分子和
int b = b1 * b2; // 分母
int min = a > b ? b : a;
for (int i = min; i > 0; i--) {
if (a % i == 0 && b % i == 0) {
a /= i;
b /= i;
}
}
if (b == 1) {
System.out.print(a);
} else {
System.out.printf("%d/%d", a, b);
}
}
}
7-34 通讯录的录入与显示
通讯录中的一条记录包含下述基本信息:朋友的姓名、出生日期、性别、固定电话号码、移动电话号码。
本题要求编写程序,录入N条记录,并且根据要求显示任意某条记录。
输入格式:
输入在第一行给出正整数;随后N行,每行按照格式姓名 生日 性别 固话 手机给出一条记录。其中姓名是不超过10个字符、不包含空格的非空字符串;生日按yyyy/mm/dd的格式给出年月日;性别用M表示“男”、F表示“女”;固话和手机均为不超过15位的连续数字,前面有可能出现+。
在通讯录记录输入完成后,最后一行给出正整数,并且随后给出个整数,表示要查询的记录编号(从0到顺序编号)。数字间以空格分隔。
输出格式:
对每一条要查询的记录编号,在一行中按照姓名 固话 手机 性别 生日的格式输出该记录。若要查询的记录不存在,则输出Not Found。
输入样例:
sh
3
Chris 1984/03/10 F +86181779452 13707010007
LaoLao 1967/11/30 F 057187951100 +8618618623333
QiaoLin 1980/01/01 M 84172333 10086
2 1 7
输出样例:
sh
LaoLao 057187951100 +8618618623333 F 1967/11/30
Not Found
sh
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
题解
java
import java.util.*;
// 7-34 通讯录的录入与显示
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
Map<Integer, String> map = new HashMap<>();
for (int i = 0; i <= n; i++) {
// 朋友的姓名、出生日期、性别、固定电话号码、移动电话号码
String str = sc.nextLine();
if (str.equals(""))
continue;
String[] arr = str.split(" ");
// 姓名 固话 手机 性别 生日
map.put(i, arr[0] + " " + arr[3] + " " + arr[4] + " " + arr[2] + " " + arr[1]);
}
int k = sc.nextInt();
for (int i = 0; i < k; i++) {
int num = sc.nextInt();
if (map.containsKey(num + 1)) {
System.out.println(map.get(num + 1));
} else {
System.out.println("Not Found");
}
}
}
}
7-35 有理数均值
本题要求编写程序,计算N个有理数的平均值。
输入格式:
输入第一行给出正整数N();第二行中按照a1/b1 a2/b2 …的格式给出N个分数形式的有理数,其中分子和分母全是整形范围内的整数;如果是负数,则负号一定出现在最前面。
输出格式:
在一行中按照a/b的格式输出N个有理数的平均值。注意必须是该有理数的最简分数形式,若分母为1,则只输出分子。
输入样例1:
sh
4
1/2 1/6 3/6 -5/10
输出样例1:
sh
1/6
输入样例2:
sh
2
4/3 2/3
输出样例2:
sh
1
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.*;
// 7-35 有理数均值
public class Main {
static Map<String, Long> map = new HashMap<>();
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
// a1/b1 a2/b2
String[] arr = new String[n];
for (int i = 0; i < n; i++) {
arr[i] = sc.next();
}
long[] zi = new long[n]; // 分子集合
long[] mu = new long[n]; // 分母集合
for (int i = 0; i < n; i++) {
int a = Integer.parseInt(arr[i].split("/")[0]);
int b = Integer.parseInt(arr[i].split("/")[1]);
zi[i] = a;
mu[i] = b;
}
long fenzi = zi[0];
// a/b/n = a/(b*n)
long fenmu = mu[0];
// 每一项的分子相加
for (int i = 1; i < n; i++) {
long curzi = zi[i];
long curmu = mu[i];
// 如果已计算的分数的分母与当前分数的分母不相等
// a/b + c/d
// 1/4 + 1/2
// 1*2/4*2 + 1*4/4*2
if (fenmu != curmu) {
curzi *= fenmu; // 当前分子乘公因子 c=c*b
fenzi *= curmu; // 之前的分子乘公因子 a=a*d
fenmu *= curmu; // 之前的分母重新计算 b=b*d
fenzi += curzi; // 之前的分子重新计算 a=a+c
} else {
fenzi += curzi;
}
if (fenzi == fenmu) {
fenzi = 1;
fenmu = 1;
continue;
}
boolean isFu = false;
if (fenzi * -1 > 0) {
isFu = true;
fenzi *= -1;
}
long gcd = gcd(fenzi, fenmu);
fenzi /= gcd;
fenmu /= gcd;
if (isFu) {
fenzi *= -1;
}
}
fenmu *= n;
boolean isFu = false;
if (fenzi * -1 > 0) {
isFu = true;
fenzi *= -1;
}
long gcd = gcd(fenzi, fenmu);
fenzi /= gcd;
fenmu /= gcd;
if (isFu) {
fenzi *= -1;
}
if (fenzi == 0) {
System.out.print(0);
} else if (fenmu == 1) {
System.out.print(fenzi);
} else {
System.out.printf("%d/%d", fenzi, fenmu);
}
}
// 求最大公约数
private static long gcd(long a, long b) {
String key = a + "_" + b;
String key1 = b + "_" + a;
if (map.containsKey(key))
return map.get(key);
if (map.containsKey(key1))
return map.get(key1);
while (b != 0) {
long temp = b;
b = a % b;
a = temp;
}
map.put(key, a);
map.put(key1, a);
return a;
}
}
7-36 复数四则运算
本题要求编写程序,计算2个复数的和、差、积、商。
输入格式:
输入在一行中按照a1 b1 a2 b2的格式给出2个复数C1=a1+b1i和C2=a2+b2i的实部和虚部。题目保证C2不为0。
输出格式:
分别在4行中按照(a1+b1i) 运算符 (a2+b2i) = 结果的格式顺序输出2个复数的和、差、积、商,数字精确到小数点后1位。如果结果的实部或者虚部为0,则不输出。如果结果为0,则输出0.0。
输入样例1:
sh
2 3.08 -2.04 5.06
输出样例1:
sh
(2.0+3.1i) + (-2.0+5.1i) = 8.1i
(2.0+3.1i) - (-2.0+5.1i) = 4.0-2.0i
(2.0+3.1i) * (-2.0+5.1i) = -19.7+3.8i
(2.0+3.1i) / (-2.0+5.1i) = 0.4-0.6i
输入样例2:
sh
1 1 -1 -1.01
输出样例2:
sh
(1.0+1.0i) + (-1.0-1.0i) = 0.0
(1.0+1.0i) - (-1.0-1.0i) = 2.0+2.0i
(1.0+1.0i) * (-1.0-1.0i) = -2.0i
(1.0+1.0i) / (-1.0-1.0i) = -1.0
sh
代码长度限制 16 KB
时间限制 400 ms
内存限制 64 MB
题解
java
import java.util.*;
import java.math.*;
// 7-36 复数四则运算
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 输入在一行中按照a1 b1 a2 b2的格式
// 给出2个复数C1=a1+b1i和C2=a2+b2i的实部和虚部。题目保证C2不为0。
BigDecimal a1 = BigDecimal.valueOf(sc.nextDouble()).setScale(2, RoundingMode.HALF_UP);
BigDecimal b1 = BigDecimal.valueOf(sc.nextDouble()).setScale(2, RoundingMode.HALF_UP);
BigDecimal a2 = BigDecimal.valueOf(sc.nextDouble()).setScale(2, RoundingMode.HALF_UP);
BigDecimal b2 = BigDecimal.valueOf(sc.nextDouble()).setScale(2, RoundingMode.HALF_UP);
// (a1+b1i) 运算符 (a2+b2i) = 结果 保留一位小数,四色五入
/**
* 2 3.08 -2.04 5.06
*/
// (2.0+3.1i) + (-2.0+5.1i) = 8.1i
// (a + b) - (c + d) = a + c + b + d
BigDecimal p1 = cumpute("+", a1, a2).setScale(1, RoundingMode.HALF_UP);
BigDecimal p2 = cumpute("+", b1, b2).setScale(1, RoundingMode.HALF_UP);
String s1 = getResult(p1, p2);
output(a1, b1, a2, b2, "+", s1);
// (2.0+3.1i) - (-2.0+5.1i) = 4.0 -2.0i
// (a + b) - (c + d) = a -c + b -d
BigDecimal p3 = cumpute("-", a1, a2).setScale(1, RoundingMode.HALF_UP);
BigDecimal p4 = cumpute("-", b1, b2).setScale(1, RoundingMode.HALF_UP);
String s2 = getResult(p3, p4);
output(a1, b1, a2, b2, "-", s2);
// (2.0+3.1i) * (-2.0+5.1i) = -19.7+3.8i
// (a + b) * (c + d) = a*c + a*d + b*c + b*d = a*c + (a*d + b*d + b*c )
// (1.0+1.0i) * (-1.0-1.0i) = -2.0i
// 1 * -1 + (-1.0i) - 1.0i - 1.0i
BigDecimal p5 = cumpute("*", a1, a2).setScale(2, RoundingMode.HALF_UP);
BigDecimal p6 = cumpute("*", a1, b2).setScale(2, RoundingMode.HALF_UP);
BigDecimal p7 = cumpute("*", b1, b2).multiply(new BigDecimal("-1")).setScale(2, RoundingMode.HALF_UP);
BigDecimal p8 = cumpute("*", b1, a2).setScale(2, RoundingMode.HALF_UP);
BigDecimal p9 = cumpute("+", p5, p7).setScale(1, RoundingMode.HALF_UP);
BigDecimal p10 = cumpute("+", p6, p8).setScale(1, RoundingMode.HALF_UP);
String s3 = getResult(p9, p10);
output(a1, b1, a2, b2, "*", s3);
// (2.0+3.1i) / (-2.0+5.1i) = 0.4-0.6i
// (a + b) / (c + d) = a/(c+d) + b/(c+d)
// (a + b)(c - d) / c^2-d^2 = ac - ad + bc -bd
// 分母部分
BigDecimal p11 = cumpute("*", a2, a2).setScale(2, RoundingMode.HALF_UP);
BigDecimal p12 = cumpute("*", b2, b2).multiply(new BigDecimal("-1")).setScale(2, RoundingMode.HALF_UP);
BigDecimal p13 = cumpute("-", p11, p12).setScale(2, RoundingMode.HALF_UP);
// 分子部分
BigDecimal p14 = cumpute("*", a1, a2).setScale(2, RoundingMode.HALF_UP);
BigDecimal p15 = cumpute("*", a1, b2).multiply(new BigDecimal("-1")).setScale(2, RoundingMode.HALF_UP);
BigDecimal p16 = cumpute("*", b1, a2).setScale(2, RoundingMode.HALF_UP);
BigDecimal p17 = cumpute("*", b1, b2).setScale(2, RoundingMode.HALF_UP);
// 实数部分
BigDecimal p18 = cumpute("/", p14.add(p17), p13).setScale(1, RoundingMode.HALF_UP);
// 虚数部分
BigDecimal p19 = cumpute("/", p15.add(p16), p13).setScale(1, RoundingMode.HALF_UP);
String s4 = getResult(p18, p19);
output(a1, b1, a2, b2, "/", s4);
}
// 打印语句
private static void output(BigDecimal a1, BigDecimal b1, BigDecimal a2, BigDecimal b2, String fu, String result) {
String s1 = isZero(b1) ? "0.0i" : b1.setScale(1, RoundingMode.HALF_UP) + "i";
String s2 = isZero(b2) ? "0.0i" : b2.setScale(1, RoundingMode.HALF_UP) + "i";
System.out.printf("(%.1f%s%s) %s (%.1f%s%s) = %s\n", a1, getFu(b1), s1, fu, a2, getFu(b2), s2, result);
}
// 判断是否为0
private static boolean isZero(BigDecimal num) {
return num.compareTo(BigDecimal.ZERO) == 0;
}
// 获取符号
private static String getFu(BigDecimal num) {
return num.compareTo(BigDecimal.ZERO) >= 0 ? "+" : "";
}
// 根据实数与虚数封装结果
private static String getResult(BigDecimal shi, BigDecimal xu) {
StringBuilder sb = new StringBuilder();
if (isZero(shi) && isZero(xu)) {
sb.append(BigDecimal.ZERO.setScale(1));
} else {
if (!isZero(shi)) {
sb.append(shi.setScale(1));
}
// 前面的实数部不为0,则虚数部的前面要加符号
if (!isZero(shi) && xu.compareTo(BigDecimal.ZERO) > 0) {
sb.append("+");
}
if (!isZero(xu)) {
sb.append(xu.setScale(1));
sb.append("i");
}
}
return sb.toString();
}
// 根据符号做计算
private static BigDecimal cumpute(String fu, BigDecimal a, BigDecimal b) {
if (fu.equals("+")) {
return a.add(b);
} else if (fu.equals("-")) {
return a.subtract(b);
} else if (fu.equals("*")) {
return a.multiply(b);
} else {
return a.divide(b, 2, RoundingMode.HALF_UP);
}
}
}
7-37 整数分解为若干项之和
将一个正整数N分解成几个正整数相加,可以有多种分解方法,例如7=6+1,7=5+2,7=5+1+1,…。编程求出正整数N的所有整数分解式子。
输入格式:
每个输入包含一个测试用例,即正整数N (0<N≤30)。
输出格式:
按递增顺序输出N的所有整数分解式子。递增顺序是指:对于两个分解序列和,若存在i使得,但是, 则序列必定在序列之前输出。每个式子由小到大相加,式子间用分号隔开,且每输出4个式子后换行。
输入样例:
sh
7
输出样例:
sh
7=1+1+1+1+1+1+1;7=1+1+1+1+1+2;7=1+1+1+1+3;7=1+1+1+2+2
7=1+1+1+4;7=1+1+2+3;7=1+1+5;7=1+2+2+2
7=1+2+4;7=1+3+3;7=1+6;7=2+2+3
7=2+5;7=3+4;7=7
sh
代码长度限制 16 KB
时间限制 800 ms
内存限制 64 MB
题解
这里是之前想到的暴力解法,但写的有点混乱,没什么技巧。
java
import java.util.*;
// 7-37 整数分解为若干项之和
public class Main {
static Map<Integer, TreeSet<String>> map = new HashMap<>();
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
TreeSet<String> list = new TreeSet<>();
list.add(getFenJie(n));
for (int i = 1; i <= n; i++) {
TreeSet<String> arr = map.get(i);
if (arr == null) {
arr = new TreeSet<>();
}
for (int j = 1; j <= i / 2 + 1; j++) {
// 判断这个差是否还有其它替代的方案
int ca = i - j;
if (ca == 0)
continue;
TreeSet<String> arr2 = map.get(ca);
if (arr2 != null) {
for (String s : arr2) {
arr.add(j + "+" + s);
}
}
arr.add(j + "+" + ca);
}
map.put(i, arr);
}
for (int i = n - 1; i > 0; i--) {
String str = getFenJie(i);
int ca = n - i;
if (ca == 0) {
continue;
}
if (ca > 1) {
list.add(sort(str + "+" + ca));
}
if (ca <= n / 2 + 1) {
list.add(sort(ca + "+" + i));
}
TreeSet<String> arr = map.get(ca);
if (arr != null) {
for (String s : arr) {
String res = str + "+" + s;
list.add(sort(res));
}
}
if (i != n && i > n / 2) {
TreeSet<String> arr2 = map.get(i);
if (arr2 != null) {
for (String s : arr2) {
String res = s + "+" + ca;
list.add(sort(res));
}
}
}
}
list.add(n + "");
int count = 0;
for (String s : list) {
System.out.print(n + "=" + s);
++count;
if (count % 4 == 0 || count == list.size()) {
System.out.print("\n");
} else {
System.out.print(";");
}
}
}
private static String sort(String str) {
String[] arr = str.split("\\+");
List<Integer> list = new ArrayList<>();
for (String s : arr) {
list.add(Integer.parseInt(s));
}
Collections.sort(list);
String res = "";
for (Integer s : list) {
res += "+" + s;
}
return res.replaceFirst("\\+", "");
}
private static String getFenJie(int num) {
StringBuilder sb = new StringBuilder();
if (num != 0) {
sb.append("1");
for (int i = 1; i < num; i++) {
sb.append("+").append("1");
}
}
return sb.toString();
}
}
这个代码会导致超时。下边换另一种思路。

我们其实可以将其抽象成一颗树,利用深度搜索算法(DFS),找到其匹配的各种结果。

代码实现:
java
import java.util.*;
// 7-37 整数分解为若干项之和
public class Main {
static int[] nums = new int[31];
static int count = 1;
static int n;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
dfs(0, n, 1);
}
/**
* 深度搜索
*
* @param index 存储在数组的下标
* @param max 最大值
* @param start 开始数
*/
public static void dfs(int index, int max, int start) {
if (max == 0) {
print();
count++;
return;
}
for (int i = start; i <= max; i++) {
// 记录当前的相加项
nums[index] = i;
// 接下来去搜索 max-i 的组合情况
dfs(index + 1, max - i, i);
// 清空当前位置的相加
nums[index] = 0;
}
}
/**
* 输出当前结果
*/
public static void print() {
System.out.printf("%d=", n);
// 组合项的数字不为0
int i;
for (i = 0; nums[i] != 0; i++) {
System.out.printf("%d", nums[i]);
if (nums[i + 1] != 0) {
System.out.print("+");
}
}
if (count % 4 == 0) {
System.out.print("\n");
} else if (nums[i - 1] != n) {
System.out.print(";");
}
}
}
虽然速度比我之前的代码快很多,但发现还是超时了,可能是Java代码本身相对于其他语言比较慢,我用C++就能过测试用例。
c++
#include<stdio.h>
int num[31], cnt = 1, n;
void Print() {
printf("%d=",n);
int i;
for (i=0; num[i]!=0; i++) {
printf("%d",num[i]);
if (num[i+1] != 0) printf("+");
}
if (cnt % 4 == 0) printf("\n");
else if (num[i-1] != n) printf(";");
}
void dfs(int index, int max, int start) {
if (max == 0) {
Print();
cnt++;
return;
}
for (int i=start; i<=max; i++) {
num[index] = i;
dfs(index+1, max-i, i);
num[index] = 0;
}
}
int main() {
scanf("%d",&n);
dfs(0, n, 1);
return 0;
}

7-38 数列求和-加强版
题解
这是暴力方法,但大数计算耗时很长。过不了最后的 最大A和N 测试点。
java
import java.math.BigInteger;
import java.util.Scanner;
// 7-38 数列求和-加强版
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 例如A=1, N=3时,S=1+11+111=123。
int a = sc.nextInt();
int n = sc.nextInt();
if (n == 0) {
System.out.println(0);
return;
}
BigInteger s = BigInteger.valueOf(a);
BigInteger lastNum = BigInteger.valueOf(a);
for (int i = 1; i < n; i++) {
BigInteger temp = BigInteger.valueOf(a);
temp = temp.multiply(BigInteger.valueOf(10).pow(i));
lastNum = lastNum.add(temp);
s = s.add(lastNum);
}
System.out.println(s);
}
}
下面这个是在网上看到别人的思路的解法,利用的是由于每一项相同列的数字相同,只不过每一列的求和随着个十百千位逐渐变化时,需要计算的相同数字逐渐减少。
例如:
sh
a 第一项
a a 第二项
a a a 第三项
num[0] nums[1] nums[2]
(3-3)*a (3-2)*a (3-1)*a

代码实现:
java
import java.util.Scanner;
// 7-38 数列求和-加强版
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 例如A=1, N=3时,S=1+11+111=123。
int a = sc.nextInt();
int n = sc.nextInt();
if (n == 0) {
System.out.println(0);
return;
}
int sum = 0;
int[] result = new int[100005];
// 为了处理最小的a和n,也就是答案为0的情况
// 从个位开始记录每一位上的值
for (int i = 0; i < n; i++) {
/**
* 例子:
* a 第一项
* aa 第二项
* aaa 第三项
* num[0] nums[1] nums[2]
*(3-3)*a (3-2)*a (3-1)*a
*/
// 累加每一项当前列的值
// (n-i)表示当前需要计算多少次 a+a+a
sum += (n - i) * a;
// 得到当前累加项值的个位数
result[i] = sum % 10;
// 只保留进位数 如果后面加法的值超过10,则需要进1,
// 但个位数的数字在上边已经记录,故只保留十位数值
sum /= 10;
}
if (sum != 0) {// 考虑到有最高一位可能进一的情况
System.out.print(sum);
}
for (int j = n - 1; j >= 0; j--) {
System.out.print(result[j]);
}
}
}
但发现还是超时了,可能由于最后的一层循环,n过大时,就比较耗时了,我们可以直接用 StringBuilder 收集结果起来。
java
import java.util.Scanner;
// 7-38 数列求和-加强版
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 例如A=1, N=3时,S=1+11+111=123。
int a = sc.nextInt();
int n = sc.nextInt();
if (n == 0) {
System.out.println(0);
return;
}
int sum = 0;
// 为了处理最小的a和n,也就是答案为0的情况
StringBuilder sb = new StringBuilder();
// 从个位开始记录每一位上的值
for (int i = 0; i < n; i++) {
// 累加每一项当前列的值
// (n-i)表示当前需要计算多少次 a+a+a
sum += (n - i) * a;
// 得到当前累加项值的个位数
sb.append(sum % 10);
// 只保留进位数 如果后面加法的值超过10,则需要进1,
// 但个位数的数字在上边已经记录,故只保留十位数值
sum /= 10;
}
// 考虑到有最高一位可能进一的情况
if (sum != 0) {
System.out.print(sum);
}
System.out.println(sb.length() > 0 ? sb.reverse() : 0);
}
}

总结
Java来解决一些基本算法还是简单的,很多库已经帮我们实现了,但效率也是真的低,因为是基于C++写的虚拟机上运行的,效率没有纯C或者C++快。写高性能程序还是C++好。