7-1 厘米换算英尺英寸 (15 分)
如果已知英制长度的英尺foot和英寸inch的值，那么对应的米是(foot+inch/12)×0.3048。现在，如果用户输入的是厘米数，那么对应英制长度的英尺和英寸是多少呢？别忘了1英尺等于12英寸。
输入格式：
输入在一行中给出1个正整数，单位是厘米。
输出格式：
在一行中输出这个厘米数对应英制长度的英尺和英寸的整数值，中间用空格分开。
输入样例：
170输出样例：
5 6要求输出的英寸（inch）和英尺（foot）都是整数值，inch/12是foot的小数部分，如果inch的数值大于12，那么foot的值就会+1，因为12inch是等于foot的，所以inch的值不会超过12。。。。。。
所以foot的整数部分可以直接用 输入的数/30.48来求。
代码：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
int foot,inch;
Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
foot = (int) (x/30.48);
inch = (int)((x/30.48-foot)*12);
System.out.println(foot+" "+inch);
}
}7-2 然后是几点 (15 分)
有时候人们用四位数字表示一个时间，比如 1106 表示 11 点零 6 分。现在，你的程序要根据起始时间和流逝的时间计算出终止时间。
读入两个数字，第一个数字以这样的四位数字表示当前时间，第二个数字表示分钟数，计算当前时间经过那么多分钟后是几点，结果也表示为四位数字。当小时为个位数时，没有前导的零，例如 5 点 30 分表示为 530；0 点 30 分表示为 030。注意，第二个数字表示的分钟数可能超过 60，也可能是负数。
输入格式：
输入在一行中给出 2 个整数，分别是四位数字表示的起始时间、以及流逝的分钟数，其间以空格分隔。注意：在起始时间中，当小时为个位数时，没有前导的零，即 5 点 30 分表示为 530；0 点 30 分表示为 030。流逝的分钟数可能超过 60，也可能是负数。
输出格式：
输出四位数字表示的终止时间，当小时为个位数时，没有前导的零。题目保证起始时间和终止时间在同一天内。
输入样例：
1120 110输出样例：
1310代码 ：
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String s = sc.nextLine(); //接收数据
String[] arry = s.split(" ");
int x = Integer.parseInt(arry[0]); //将接收的数据转为int类型
int y = Integer.parseInt(arry[1]);
if (y > 0) {
int minute = (x / 100) * 60 + (x % 100) + y;
int hour = (minute / 60) * 100 + minute % 60;
System.out.println(hour);
} else {
int minute = (x / 100) * 60 + (x % 100) + y;
int hour = minute / 60;
int minute1 = minute - hour * 60;
String ss = "";
ss = ss + hour + minute1;
System.out.println(ss);
}
}
}7-3 逆序的三位数 (10 分)
程序每次读入一个正3位数，然后输出按位逆序的数字。注意：当输入的数字含有结尾的0时，输出不应带有前导的0。比如输入700，输出应该是7。
输入格式：
每个测试是一个3位的正整数。
输出格式：
输出按位逆序的数。
输入样例：
123输出样例：
321代码：
//用StringBuilder
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
String s = "";
s += x;
StringBuilder sb = new StringBuilder(s);
sb.reverse();
System.out.println(Integer.parseInt(sb.toString()));
}
}//得到个位数，十位数，百位数在调换
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
int y = x / 100; //百位数
int z = x / 10 % 10; //十位数
int o = x % 10; //个位数
int l = o * 100 + z * 10 + y;
System.out.println(l);
}
}
7-4 BCD解密 (10 分)
BCD数是用一个字节来表达两位十进制的数，每四个比特表示一位。所以如果一个BCD数的十六进制是0x12，它表达的就是十进制的12。但是小明没学过BCD，把所有的BCD数都当作二进制数转换成十进制输出了。于是BCD的0x12被输出成了十进制的18了！
现在，你的程序要读入这个错误的十进制数，然后输出正确的十进制数。提示：你可以把18转换回0x12，然后再转换回12。
输入格式：
输入在一行中给出一个[0, 153]范围内的正整数，保证能转换回有效的BCD数，也就是说这个整数转换成十六进制时不会出现A-F的数字。
输出格式：
输出对应的十进制数。
输入样例：
18输出样例：
12BCD数的0x12表示的就是十进制数的12，题上小明将BCD数的0x12当做16进制数转换为十进制数18。。。所以只需把十进制数18转换为十六进制数
代码：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int x = n / 16;
int y = n % 16;
System.out.println(x*10+y);
}
}
7-5 表格输出 (5 分)
本题要求编写程序，按照规定格式输出表格。
输入格式：
本题目没有输入。
输出格式：
要求严格按照给出的格式输出下列表格：
------------------------------------
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
------------------------------------代码：
public class Main {
public static void main(String[] args) {
//直接输出
System.out.println("------------------------------------");
System.out.println("Province Area(km2) Pop.(10K)");
System.out.println("------------------------------------");
System.out.println("Anhui 139600.00 6461.00");
System.out.println("Beijing 16410.54 1180.70");
System.out.println("Chongqing 82400.00 3144.23");
System.out.println("Shanghai 6340.50 1360.26");
System.out.println("Zhejiang 101800.00 4894.00");
System.out.println("------------------------------------");
}
}7-6 混合类型数据格式化输入 (5 分)
本题要求编写程序，顺序读入浮点数1、整数、字符、浮点数2，再按照字符、整数、浮点数1、浮点数2的顺序输出。
输入格式：
输入在一行中顺序给出浮点数1、整数、字符、浮点数2，其间以1个空格分隔。
输出格式：
在一行中按照字符、整数、浮点数1、浮点数2的顺序输出，其中浮点数保留小数点后2位。
输入样例：
2.12 88 c 4.7输出样例：
c 88 2.12 4.70代码：
import java.text.DecimalFormat;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
String[] arry = s.split(" ");
float a = Float.parseFloat(arry[0]); //将a转化为float类型
int b = Integer.parseInt(arry[1]); //将b转化为int类型
char c = arry[2].charAt(0); //将c转化为char类型
float d = Float.parseFloat(arry[3]); //将d转化为float类型
//规范输出格式
DecimalFormat de = new DecimalFormat(".00");
String p = de.format(d);
System.out.println(c+" "+b+" "+a+" "+p);
}
}7-7 12-24小时制 (15 分)
编写一个程序，要求用户输入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。
输入样例：
21:11输出样例：
9:11 PM代码：
import java.text.DecimalFormat;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.nextLine(); //接收数据
String[] array = s.split(":"); //将接收的数据按:分隔后存入数组
int x = Integer.parseInt(array[0]);
int y = Integer.parseInt(array[1]);
//根据题中条件进行划分
if(x>12){
System.out.println((x-12)+":"+y+" PM");
}else if(x == 24){
System.out.println((x-24)+":"+y+" AM");
}
else if(x == 12){
System.out.println(x+":"+y+" PM");
}else{
System.out.println(x+":"+y+" AM");
}
}
}
7-8 超速判断 (10 分)
模拟交通警察的雷达测速仪。输入汽车速度，如果速度超出60 mph，则显示“Speeding”，否则显示“OK”。
输入格式：
输入在一行中给出1个不超过500的非负整数，即雷达测到的车速。
输出格式：
在一行中输出测速仪显示结果，格式为：Speed: V - S，其中V是车速，S或者是Speeding、或者是OK。
输入样例1：
40输出样例1：
Speed: 40 - OK输入样例2：
75输出样例2：
Speed: 75 - Speeding代码：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int speed = sc.nextInt(); //接收数据
//根据条件判断
if(speed>60){
System.out.println("Speed: "+speed+" - Speeding");
}else {
System.out.println("Speed: "+speed+" - OK");
}
}
}
7-9 用天平找小球 (10 分)
三个球A、B、C，大小形状相同且其中有一个球与其他球重量不同。要求找出这个不一样的球。
输入格式：
输入在一行中给出3个正整数，顺序对应球A、B、C的重量。
输出格式：
在一行中输出唯一的那个不一样的球。
输入样例：
1 1 2输出样例：
C代码：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.nextLine(); //接收数据
String[] array = s.split(" ");
//直接分别比较三个小球的重量
if(array[0].equals(array[1])){
System.out.println("C");
}else if(array[0].equals(array[2])){
System.out.println("B");
}else {
System.out.println("A");
}
}
}
7-10 计算工资 (15 分)
某公司员工的工资计算方法如下：一周内工作时间不超过40小时，按正常工作时间计酬；超出40小时的工作时间部分，按正常工作时间报酬的1.5倍计酬。员工按进公司时间分为新职工和老职工，进公司不少于5年的员工为老职工，5年以下的为新职工。新职工的正常工资为30元/小时，老职工的正常工资为50元/小时。请按该计酬方式计算员工的工资。
输入格式：
输入在一行中给出2个正整数，分别为某员工入职年数和周工作时间，其间以空格分隔。
输出格式：
在一行输出该员工的周薪，精确到小数点后2位。
输入样例1：
5 40输出样例1：
2000.00输入样例2：
3 50输出样例2：
1650.00代码：
import java.text.DecimalFormat;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.nextLine(); //接收数据
String[] array = s.split(" ");
int x = Integer.parseInt(array[0]); //将数据转换为int类型
int y = Integer.parseInt(array[1]);
double mony;
//根据不同的情况计算工资
if(x>=5){
if(y<=40){
mony = y * 50;
}else {
mony = 40 * 50 + (y-40) * 50 * 1.5;
}
}else {
if(y<=40){
mony = y * 30;
}else {
mony = 40 * 30 + (y-40) * 30 * 1.5;
}
}
//规范输出格式
DecimalFormat de = new DecimalFormat("0.00");
String p = de.format(mony);
System.out.println(p);
//为了简便，也可以
//System.out.println(new DecimalFormat("0.00").format(mony));
}
}
7-11 分段计算居民水费 (10 分)
为鼓励居民节约用水，自来水公司采取按用水量阶梯式计价的办法，居民应交水费y（元）与月用水量x（吨）相关：当x不超过15吨时，y=4x/3；超过后，y=2.5x−17.5。请编写程序实现水费的计算。
输入格式：
输入在一行中给出非负实数x。
输出格式：
在一行输出应交的水费，精确到小数点后2位。
输入样例1：
12输出样例1：
16.00输入样例2：
16输出样例2：
22.50代码：
import java.text.DecimalFormat;
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner sc =new Scanner(System.in);
DecimalFormat df=new DecimalFormat("0.00"); //规范输出格式
double x;
double money;
x=sc.nextInt(); //接收数据
//根据两种公式计算
if(x>15){
money = (2.5 * x) - 17.5;
System.out.print(df.format(money));
}else{
money = (4 * x) / 3;
System.out.print(df.format(money));
}
}
}
//为了方便也可以这样写
//System.out.print(new DecimalFormat("0.00").format(money));7-12 两个数的简单计算器 (10 分)
本题要求编写一个简单计算器程序，可根据输入的运算符，对2个整数进行加、减、乘、除或求余运算。题目保证输入和输出均不超过整型范围。
输入格式：
输入在一行中依次输入操作数1、运算符、操作数2，其间以1个空格分隔。操作数的数据类型为整型，且保证除法和求余的分母非零。
输出格式：
当运算符为+、-、*、/、%时，在一行输出相应的运算结果。若输入是非法符号（即除了加、减、乘、除和求余五种运算符以外的其他符号）则输出ERROR。
输入样例1：
-7 / 2输出样例1：
-3输入样例2：
3 & 6输出样例2：
ERROR代码：
import java.util.*;
public class Main {
public static void main(String[] args){
int result; //定义一个辅助变量用来保存结果
Scanner sc = new Scanner(System.in);
String s = sc.nextLine(); //接收数据
String[] array = s.split(" "); //将接收的数据以空格分开存入数组
//判断进行什么运算，判断时不能用==，字符串间的==是表示其地址
if(array[1].equals("+")){
result = Integer.parseInt(array[0]) + Integer.parseInt(array[2]);
System.out.println(result);
}else if(array[1].equals("-")){
result = Integer.parseInt(array[0]) - Integer.parseInt(array[2]);
System.out.println(result);
}else if(array[1].equals("*")){
result = Integer.parseInt(array[0]) * Integer.parseInt(array[2]);
System.out.println(result);
}else if(array[1].equals("/")){
if(!array[2].equals("0")){ //除法运算被除数不能为0
result = Integer.parseInt(array[0]) / Integer.parseInt(array[2]);
System.out.println(result);
}
}else if(array[1].equals("%")){
if(!array[2].equals("0")){ //取余运算被余数不能为0
result = Integer.parseInt(array[0]) % Integer.parseInt(array[2]);
System.out.println(result);
}
}else {
System.out.println("ERROR");
}
}
}
7-13 日K蜡烛图 (15 分)
股票价格涨跌趋势，常用蜡烛图技术中的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：
5.110 5.250 5.100 5.105输出样例1：
BW-Solid with Lower Shadow and Upper Shadow输入样例2：
5.110 5.110 5.110 5.110输出样例2：
R-Cross输入样例3：
5.110 5.125 5.112 5.126输出样例3：
R-Hollow代码：
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String s = sc.nextLine(); //接收数据
String[] array = s.split(" ");
//根据题中条件进行划分输出
if(Double.parseDouble(array[0]) > Double.parseDouble(array[3])){
if(Double.parseDouble(array[1])>Double.parseDouble(array[0]) && Double.parseDouble(array[1])>Double.parseDouble(array[3])){
if(Double.parseDouble(array[2])<Double.parseDouble(array[0]) && Double.parseDouble(array[2])<Double.parseDouble(array[3])){
System.out.println("BW-Solid with Lower Shadow and Upper Shadow");
}else{
System.out.println("BW-Solid with Upper Shadow");
}
}else if(Double.parseDouble(array[2])<Double.parseDouble(array[0]) && Double.parseDouble(array[2])<Double.parseDouble(array[3])){
System.out.println("BW-Solid with Lower Shadow");
}else {
System.out.println("BW-Solid");
}
}else if(Double.parseDouble(array[0]) < Double.parseDouble(array[3])){
if(Double.parseDouble(array[1])>Double.parseDouble(array[0]) && Double.parseDouble(array[1])>Double.parseDouble(array[3])){
if(Double.parseDouble(array[2])<Double.parseDouble(array[0]) && Double.parseDouble(array[2])<Double.parseDouble(array[3])){
System.out.println("R-Hollow with Lower Shadow and Upper Shadow");
}else {
System.out.println("R-Hollow with Upper Shadow");
}
}else if(Double.parseDouble(array[2])<Double.parseDouble(array[0]) && Double.parseDouble(array[2])<Double.parseDouble(array[3])){
System.out.println("R-Hollow with Lower Shadow");
}else {
System.out.println("R-Hollow");
}
}else {
if(Double.parseDouble(array[0]) < Double.parseDouble(array[1])){
if(Double.parseDouble(array[0]) > Double.parseDouble(array[2])){
System.out.println("R-Cross with Lower Shadow and Upper Shadow");
}else {
System.out.println("R-Cross with Upper Shadow");
}
}else if(Double.parseDouble(array[2])<Double.parseDouble(array[0]) && Double.parseDouble(array[2])<Double.parseDouble(array[3])){
System.out.println("R-Cross with Lower Shadow");
}else {
System.out.println("R-Cross");
}
}
}
}
7-14 求整数段和 (15 分)
给定两个整数A和B，输出从A到B的所有整数以及这些数的和。
输入格式：
输入在一行中给出2个整数A和B，其中−100≤A≤B≤100，其间以空格分隔。
输出格式：
首先顺序输出从A到B的所有整数，每5个数字占一行，每个数字占5个字符宽度，向右对齐。最后在一行中按Sum = X的格式输出全部数字的和X。
输入样例：
-3 8输出样例：
-3 -2 -1 0 1
2 3 4 5 6
7 8
Sum = 30import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String s = sc.nextLine(); //接收数据
String[] array = s.split(" "); //用空格分开后存入数组
int start = Integer.parseInt(array[0]); //将数据由String类型转为int类型
int end = Integer.parseInt(array[1]);
int sum = 0; //定义辅助变量表示和
int x = 0; //定义辅助变量
//遍历输出
for(int i = start;i<=end;i++){
sum += i;
x++;
System.out.printf("%5d",i); //输出占5个字符，右对齐
//每五个数据换行和最后一个数据结束后换行
if(x%5==0 || x == end - start + 1){
System.out.println();
}
}
System.out.println("Sum = "+sum);
}
}
补充：
System.out.printf("%-5d",i); //左对齐
System.out.printf("%5d",i); //右对齐
System.out.printf("%+5d",i); //显示正负号的右对齐7-15 计算圆周率 (15 分)
根据下面关系式，求圆周率的值，直到最后一项的值小于给定阈值。
2π=1+1/3+2!/3*5+3!/3*5*7+⋯+n!/3*5*7*⋯*(2n+1)+⋯
输入格式：
输入在一行中给出小于1的阈值。
输出格式：
在一行中输出满足阈值条件的近似圆周率，输出到小数点后6位。
输入样例：
0.01输出样例：
3.132157import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
double s = sc.nextDouble(); //接收阈值
double sum = 1; //多项式第一项的值
for(double i=1;i<100;i++){
//计算多项式的每一项的值
double d = jie(i) / fen(i);
sum += d;
//判断阈值
if(d<s){
System.out.printf("%6f",sum*2);
break;
}
}
}
//定义一个计算阶乘的方法
public static double jie(double i){
if(i == 1){
return 1;
}
if(i == 0){
return 0;
}
return i * jie(i-1);
}
//定义一个分母等差数列求积的方法
public static double fen(double i){
if(i == 1){
return 3;
}
return (2*i+1) * fen(i-1);
}
}
7-16 求符合给定条件的整数集 (15 分)
给定不超过6的正整数A，考虑从A开始的连续4个数字。请输出所有由它们组成的无重复数字的3位数。
输入格式：
输入在一行中给出A。
输出格式：
输出满足条件的的3位数，要求从小到大，每行6个整数。整数间以空格分隔，但行末不能有多余空格。
输入样例：
2输出样例：
234 235 243 245 253 254
324 325 342 345 352 354
423 425 432 435 452 453
523 524 532 534 542 543代码：
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int x = sc.nextInt(); //接收正整数
int y,z,o;
int count = 0;
//通过循环来进行随机组合，组合都是输入的正整数及往后连续的三个数
for(y = x;y < x+4;y++){
for(z = x;z < x+4;z++){
for(o = x;o < x+4;o++) {
//排除一些数，例如：222，333
if (y != z && y != o && z != o) {
//用字符串格式得到所需要的格式
String s = "";
count++; //定义一个辅助变量
s = s + y + z + o;
//每六个数换行，每个数中间用空格分离
if (count % 6 == 0) {
System.out.println(s);
}else {
System.out.print(s+" ");
}
}
}
}
}
}
}
7-17 爬动的蠕虫 (15 分)
一条蠕虫长1寸，在一口深为N寸的井的底部。已知蠕虫每1分钟可以向上爬U寸，但必须休息1分钟才能接着往上爬。在休息的过程中，蠕虫又下滑了D寸。就这样，上爬和下滑重复进行。请问，蠕虫需要多长时间才能爬出井？
这里要求不足1分钟按1分钟计，并且假定只要在某次上爬过程中蠕虫的头部到达了井的顶部，那么蠕虫就完成任务了。初始时，蠕虫是趴在井底的（即高度为0）。
输入格式：
输入在一行中顺序给出3个正整数N、U、D，其中D<U，N不超过100。
输出格式：
在一行中输出蠕虫爬出井的时间，以分钟为单位。
输入样例：
12 3 1输出样例：
11代码：
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.nextLine(); //接收数据
String[] array = s.split(" "); //将接收到的按空格分开存入数组
int x = Integer.parseInt(array[0]); //将数据转化为int类型
int y = Integer.parseInt(array[1]);
int z = Integer.parseInt(array[2]);
int minute ; //定义爬出所需要的时间
//如果井深小于等于每分钟爬的高度，一分钟就可以上去
if(x <= y){
System.out.println("1");
}else {
for (int i = 1; i < 100; i++) {
//每分钟爬的高度-每分钟下滑的高度就是两分钟爬的高度
//最后一分钟爬的高度需要单独考虑
//i表示需要多少个两分钟
if (i * (y - z) + y >= x) {
minute = i * 2 + 1;
System.out.println(minute);
break;
}
}
}
}
}
7-18 二分法求多项式单根 (20 分)
二分法求函数根的原理为：如果连续函数f(x)在区间[a,b]的两个端点取值异号，即f(a)f(b)<0，则它在这个区间内至少存在1个根r，即f(r)=0。
二分法的步骤为：
- 检查区间长度，如果小于给定阈值，则停止，输出区间中点(a+b)/2；否则
- 如果f(a)f(b)<0，则计算中点的值f((a+b)/2)；
- 如果f((a+b)/2)正好为0，则(a+b)/2就是要求的根；否则
- 如果f((a+b)/2)与f(a)同号，则说明根在区间[(a+b)/2,b]，令a=(a+b)/2，重复循环；
- 如果f((a+b)/2)与f(b)同号，则说明根在区间[a,(a+b)/2]，令b=(a+b)/2，重复循环。
本题目要求编写程序，计算给定3阶多项式f(x)=a3x3+a2x2+a1x+a0在给定区间[a,b]内的根。
输入格式：
输入在第1行中顺序给出多项式的4个系数a3、a2、a1、a0，在第2行中顺序给出区间端点a和b。题目保证多项式在给定区间内存在唯一单根。
输出格式：
在一行中输出该多项式在该区间内的根，精确到小数点后2位。
输入样例：
3 -1 -3 1
-0.5 0.5输出样例：
0.33代码：(自己比较笨的方法)
import java.text.DecimalFormat;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.nextLine(); //接收数据
String[] ss = s.split(" "); //将输入的数据按空格分开后存入数组
double a3 = Double.parseDouble(ss[0]); //将数组中数据转为double类型
double a2 = Double.parseDouble(ss[1]);
double a1 = Double.parseDouble(ss[2]);
double a0 = Double.parseDouble(ss[3]);
double a = sc.nextDouble(); //接收区间a，b
double b = sc.nextDouble();
//找不到结果便一直循环
while (true) {
//定义三个表达式
double f1 = a3 * Math.pow(a, 3) + a2 * Math.pow(a, 2) + a1 * a + a0;
double f2 = a3 * Math.pow(b, 3) + a2 * Math.pow(b, 2) + a1 * b + a0;
double f3 = a3 * Math.pow((a + b) / 2, 3) + a2 * Math.pow((a + b) / 2, 2) + a1 * (a + b) / 2 + a0;
//检查区域长度
if ((b - a) <= 0.01) {
System.out.println(new DecimalFormat("0.00").format((a + b) / 2));
break;
} else if (f1 == 0) {
System.out.println(new DecimalFormat("0.00").format(a));
break;
} else if (f2 == 0) {
System.out.println(new DecimalFormat("0.00").format(b));
break;
} else {
if (f1 * f2 < 0) {
if (f3 == 0) {
System.out.println(new DecimalFormat("0.00").format((a + b) / 2));
break;
}
if (f3 * f1 > 0) {
a = (a + b) / 2;
}
if (f3 * f2 > 0) {
b = (a + b) / 2;
}
}
}
}
}
}
转载别人的代码：
import java.util.Scanner;
public class Main{
static float[] A=new float[4];
// static float[] A={1,-3,-1,3};
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
for(int i=3;i>=0;i--){
A[i]=sc.nextFloat();
}
float a=sc.nextFloat();
float b=sc.nextFloat();
//保留两位有效小数
System.out.println(new java.text.DecimalFormat("0.00").format(solve(a,b)));
}
public static float solve(float a,float b) {
float x=(a+b)/2;
float res=0;
//中点的f值很小但不一定是根
if(b-a<=0.01){//注意：如果设置:b-a<=0,答案错误
return x;
}
//注意:考虑区间端点是根的情况
if(f(a)==0){
return a;
}
if(f(b)==0){
return b;
}
if(f(a)*f(b)<0){
if(f(x)==0){
res=x;
} else if((f(x)*f(a)>0))//同号
return solve(x,b);
else if((f(x)*f(b)>0))
return solve(a,x);
}
return res;
}
public static float f(float x) {
return A[3]*x*x*x+A[2]*x*x+A[1]*x+A[0];
}
}
————————————————
版权声明：本文为CSDN博主「ThisAmy」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/ThisAmy/article/details/883757787-19 支票面额 (15 分)
一个采购员去银行兑换一张y元f分的支票，结果出纳员错给了f元y分。采购员用去了n分之后才发觉有错，于是清点了余额尚有2y元2f分，问该支票面额是多少？
输入格式：
输入在一行中给出小于100的正整数n。
输出格式：
在一行中按格式y.f输出该支票的原始面额。如果无解，则输出No Solution。
输入样例1：
23输出样例1：
25.51输入样例2：
22输出样例2：
No Solution代码如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
int y,f;
Scanner sc = new Scanner(System.in);
int n = sc.nextInt(); //接收正整数n
//寻找符合条件的数值，100分等于1元(f<100)
for(f = 0;f < 100;f++){
for(y = 0;y < 50;y++){
if(98*f-199*y==n){
System.out.println(y+"."+f);
System.exit(0);
}
}
}
System.out.println("No Solution");
}
}
7-20 打印九九口诀表 (15 分)
下面是一个完整的下三角九九口诀表：
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位、左对齐（不会格式的参考7-14的补充）。
输入样例：
4输出样例：
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 代码如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt(); //接收正整数N
//遍历打印
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 求特殊方程的正整数解 (15 分)
本题要求对任意给定的正整数N，求方程X2+Y2=N的全部正整数解。
输入格式：
输入在一行中给出正整数N（≤10000）。
输出格式：
输出方程X2+Y2=N的全部正整数解，其中X≤Y。每组解占1行，两数字间以1空格分隔，按X的递增顺序输出。如果没有解，则输出No Solution。
输入样例1：
884输出样例1：
10 28
20 22输入样例2：
11输出样例2：
No Solution代码如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
int X,Y;
boolean flag = true; //判断是否存在正解
Scanner sc = new Scanner(System.in);
int N = sc.nextInt(); //接收正整数N
//寻找符合条件的数，Y>=X，所以Y从X开始遍历
for(X = 1;X < 100;X++){
for(Y = X;Y < 100;Y++){
if(X*X+Y*Y == N){
System.out.println(X+" "+Y);
flag = false;
}
}
}
if(flag){
System.out.println("No Solution");
}
}
}
7-22 龟兔赛跑 (20 分)
乌龟与兔子进行赛跑，跑场是一个矩型跑道，跑道边可以随地进行休息。乌龟每分钟可以前进3米，兔子每分钟前进9米；兔子嫌乌龟跑得慢，觉得肯定能跑赢乌龟，于是，每跑10分钟回头看一下乌龟，若发现自己超过乌龟，就在路边休息，每次休息30分钟，否则继续跑10分钟；而乌龟非常努力，一直跑，不休息。假定乌龟与兔子在同一起点同一时刻开始起跑，请问T分钟后乌龟和兔子谁跑得快？
输入格式：
输入在一行中给出比赛时间T（分钟）。
输出格式：
在一行中输出比赛的结果：乌龟赢输出@_@，兔子赢输出^_^，平局则输出-_-；后跟1空格，再输出胜利者跑完的距离。
输入样例：
242输出样例：
@_@ 726代码如下 ：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int T = sc.nextInt(); //接收比赛时间
int distance = 0; //定义一个辅助变量
//比赛时间为0，平局
if(T == 0){
System.out.println("-_- "+distance);
}
//通过写出前90分钟即可发现90分钟为一个循环，90分钟时时间相同，路程相同(兔子刚好不睡觉)
//每次循环的[1,30)分钟兔子快
if(T % 90 >= 1 && T % 90 < 30){
distance = 9 * (T % 90) + (T / 90) * 270; //每个循环距离为270
System.out.println("^_^ "+distance);
}
//每次循环的30分钟，45分钟，60分钟和90分钟距离一样
if(T % 90 == 30 || T % 90 == 45 || T % 90 == 60 || T % 90 == 0){
distance = 3 * (T % 90) + (T / 90) * 270;
System.out.println("-_- "+distance);
}
//每次循环的（30,45)分钟乌龟快
if(T % 90 > 30 && T % 90 < 45){
distance = 3 * (T % 90) + (T / 90) * 270;
System.out.println("@_@ "+distance);
}
//每次循环的(45,50)分钟兔子快,注意45分钟到50分钟为兔子赶路时间
if(T % 90 > 45 && T % 90 <= 50){
distance = 9 * (T % 90 - 30) + (T / 90) * 270; //50分钟内只有30分钟为睡觉时间
System.out.println("^_^ "+distance);
}
//每次循环的(50,60)分钟兔子快，兔子在50到60分钟为睡觉时间
if(T % 90 > 50 && T % 90 < 60){
distance = 9 * 20 + (T / 90) * 270;
System.out.println("^_^ "+distance);
}
//每次循环的(60,90)分钟乌龟快
if(T % 90 > 60 && T % 90 < 90){
distance = 3 * (T % 90) + (T / 90) * 270;
System.out.println("@_@ "+distance);
}
}
}
别人的代码：
import java.util.Scanner;
public class Pta7_22 {
public static void main(String[] args) {
int t = 0;
//System.out.println("t:");
Scanner sc = new Scanner(System.in);
if (sc.hasNextInt()) {
t = sc.nextInt();
if (t < 0) {
System.exit(0);
}
} else {
System.exit(0);
}
int tz = 0;// 兔子跑的距离
int wg = 0;// 乌龟跑的距离
int j = 1; // 兔子的分钟控制
int flag = 0;// 控制兔子是否睡觉的变量
for (int i = 1; i <= t; i++) {
wg += 3;// 乌龟每分钟跑3米
if ((j % 10) == 0 && tz > wg) {// 整10判断一次兔子与乌龟的距离
if (flag == 0) {// 判断兔子是否在睡觉
tz += 9;// 兔子每分钟跑9米
j += 31;// 兔子
flag = 1;
}
}
if (j == i) {
tz += 9;// 兔子每分钟跑9米
flag = 0;// 兔子跑起来的时候设置其为未睡觉状态
j++;
}
}
if (tz > wg) {
System.out.println("^_^ " + tz);
} else if (tz < wg) {
System.out.println("@_@ " + wg);
} else {
System.out.println("-_- " + tz);
}
}
}
————————————————
版权声明：本文为CSDN博主「hello!world!」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/gwgw0621/article/details/1080606337-24 约分最简分式 (15 分)
分数可以表示为分子/分母的形式。编写一个程序，要求用户输入一个分数，然后将其约分为最简分式。最简分式是指分子和分母不具有可以约分的成分了。如6/12可以被约分为1/2。当分子大于分母时，不需要表达为整数又分数的形式，即11/8还是11/8；而当分子分母相等时，仍然表达为1/1的分数形式。
输入格式：
输入在一行中给出一个分数，分子和分母中间以斜杠/分隔，如：12/34表示34分之12。分子和分母都是正整数（不包含0，如果不清楚正整数的定义的话）。
输出格式：
在一行中输出这个分数对应的最简分式，格式与输入的相同，即采用分子/分母的形式表示分数。如 5/6表示6分之5。
输入样例：
66/120输出样例：
11/20代码如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
String[] array = s.split("/");
int x = Integer.parseInt(array[0]);
int y = Integer.parseInt(array[1]);
int o = gy(x,y);
//都约去最大公约数
x = x / o;
y = y / o;
System.out.println(x+"/"+y);
}
//求最大公约数，用辗转相除法
public static int gy(int a,int b){
int rem;
while (b > 0){
rem = a % b;
a = b;
b = rem;
}
return a;
}
}
7-25 念数字 (15 分)
输入一个整数，输出每个数字对应的拼音。当整数为负数时，先输出fu字。十个数字对应的拼音如下：
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。
输入样例：
-600输出样例：
fu liu ling ling代码如下：
import java.util.HashMap;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
//以键值对的形式存在map集合中
HashMap<Character,String> map = new HashMap<>();
map.put('-',"fu");
map.put('0',"ling");
map.put('1',"yi");
map.put('2',"er");
map.put('3',"san");
map.put('4',"si");
map.put('5',"wu");
map.put('6',"liu");
map.put('7',"qi");
map.put('8',"ba");
map.put('9',"jiu");
//遍历输入的值输出对应的值
for(int i=0;i<s.length();i++){
char c = s.charAt(i);
//行末没有最后的空格
if(i == s.length()-1){
System.out.println(map.get(c));
break;
}
System.out.print(map.get(c)+" ");
}
}
}
7-26 单词长度 (15 分)
你的程序要读入一行文本，其中以空格分隔为若干个单词，以.结束。你要输出每个单词的长度。这里的单词与语言无关，可以包括各种符号，比如it's算一个单词，长度为4。注意，行中可能出现连续的空格；最后的.不计算在内。
输入格式：
输入在一行中给出一行文本，以.结束
输出格式：
在一行中输出这行文本对应的单词的长度，每个长度之间以空格隔开，行末没有最后的空格。
输入样例：
It's great to see you here.输出样例：
4 5 2 3 3 4代码如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
//将输入的字符串变截止到第一个.出现的位置
int index = s.indexOf(".");
String ss = s.substring(0,index);
//去掉空格以及多个空格
String [] array = ss.split("\\s+");
for(String x : array) {
//长度不为0的字符串才输出
if (x.length() != 0) {
//行末没有最后的空格
if (array[array.length - 1].equals(x)) {
System.out.println(x.length());
break;
}
System.out.print(x.length() + " ");
}
}
}
}
7-27 冒泡法排序 (20 分)
将N个整数按从小到大排序的冒泡排序法是这样工作的：从头到尾比较相邻两个元素，如果前面的元素大于其紧随的后面元素，则交换它们。通过一遍扫描，则最后一个元素必定是最大的元素。然后用同样的方法对前N−1个元素进行第二遍扫描。依此类推，最后只需处理两个元素，就完成了对N个数的排序。
本题要求对任意给定的K（<N），输出扫描完第K遍后的中间结果数列。
输入格式：
输入在第1行中给出N和K（1≤K<N≤100），在第2行中给出N个待排序的整数，数字间以空格分隔。
输出格式：
在一行中输出冒泡排序法扫描完第K遍后的中间结果数列，数字间以空格分隔，但末尾不得有多余空格。
输入样例：
6 2
2 3 5 1 6 4输出样例：
2 1 3 4 5 6代码如下：
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
String[] array1 = s.split(" ");
//获得输入数字的个数和扫描的次数
int x = Integer.parseInt(array1[0]);
int y = Integer.parseInt(array1[1]);
//获得需要排序的数字
String ss = sc.nextLine();
String[] array2 = ss.split(" ");
//创建int类型的数组
int[] array = new int[x];
int i = 0;
//将输入的数字放入int数组中
for(String o : array2){
array[i] = Integer.parseInt(o);
i++;
}
//冒泡排序
for(int j = 0;j < y;j++){
for(int k = 0;k < x - 1;k++){
if(array[k] > array[k+1]){
int temp = array[k];
array[k] = array[k+1];
array[k+1] = temp;
}
}
}
//遍历输出
for(int o : array){
if(o == array[x-1]){
System.out.println(o);
break;
}
System.out.print(o + " ");
}
}
}
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
