匿名网友
一、求两个数的和与差。程序填空，不要改变与输入输出有关的语句。
输入整数a和b，计算并输出a、b的和与差。
import java.io.*;
import java.util.Scanner;
public class Test20001{
public static void main(String args[]){
int a, b, sum, diff;
Scanner in=new Scanner(System.in);
a=in.nextInt();
b=in.nextInt();
/*------------------*/
sum=a+b;
diff=a-b;
System.out.println("The sum is "+sum);
System.out.println("The difference is "+diff);
}
}
二、求平方根。程序填空，不要改变与输入输出有关的语句。
输入1个实数x，计算并输出其平方根。
例：输入1.21输出The square root of 1.21 is 1.1
import java.io.*;
import java.util.Scanner;
public class Test20002{
public static void main(String args[]){
double x, root;
Scanner in=new Scanner(System.in);
x=in.nextDouble();
/*------------------*/
root=Math.sqrt(x);
System.out.println("The square root of "+x+" is "+root);
}
}
三、华氏温度转换为摄氏温度。程序填空，不要改变与输入输出有关的语句。
输入华氏温度f，计算并输出相应的摄氏温度c。c = 5/9(f-32).
例：括号内是说明:输入17.2 (华氏温度)输出The temprature is -8.222222222222223
import java.util.Scanner;
public class Test20003 {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
double f, c;
f=in.nextDouble();
/*------------------*/
c=5.0/9*(f-32);
System.out.println("The temprature is "+c);
}
}
四、计算旅途时间。程序填空，不要改变与输入输出有关的语句。
输入2个整数time1和time2，表示火车的出发时间和到达时间，计算并输出旅途时间。
有效的时间范围是0000到2359，不需要考虑出发时间晚于到达时间的情况。
例：括号内是说明:输入712 1411（出发时间是7：12，到达时间是14：11）
输出The train journey time is 6 hrs 59 mins.
import java.util.Scanner;
public class Test20004 {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
int time1, time2, hours, mins;
time1=in.nextInt();
time2=in.nextInt();
/*------------------*/
/*计算两个时间之间的小时数和分钟数*/
hours=time2/100-time1/100;
mins=time2%100-time1%100;
/*当计算得到的分钟数为负数时进行如下处理*/
hours=mins>0?hours:hours-1;
mins=mins>0?mins:mins+60;
System.out.println("The train journey time is "+hours+" hrs "+ mins+" mins.");
}
}
五、数字加密。程序填空，不要改变与输入输出有关的语句。
输入1个四位数，将其加密后输出。方法是将该数每一位上的数字加9，然后除以10取余，做为该位上的新数字，最后将第1位和第3位上的数字互换，第2位和第4位上的数字互换，组成加密后的新数。
例：括号内是说明:输入1257输出The encrypted number is 4601(每一位上的数字加9除以10取余后，得0146，交换后得到4601)
import java.util.Scanner;
public class Test20005 {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
int number, digit1, digit2, digit3, digit4, newnum;
number=in.nextInt();
/*------------------*/
/*先分离出各位上的数字*/
digit1=number/1000;（是这样来取得位数的）
digit2=number/100%10; //或 digit2=(number-digit1*1000)/100;
digit3=number/10%10; //或 digit3=(number-digit1*1000-digit2*100)/10;
digit4=number%10;
/*再调整各位上的数字*/
digit1=(digit1+9)%10;
digit2=(digit2+9)%10;
digit3=(digit3+9)%10;
digit4=(digit4+9)%10;
/*最后组成加密后的新数*/
newnum=digit3*1000+digit4*100+digit1*10+digit2;(注意这里是这样来实现交换的)
System.out.println("The encrypted number is "+newnum);
}
}
六、大写字母转换成小写字母。程序填空，不要改变与输入输出有关的语句。
输入一个大写英文字母，输出相应的小写字母。
例：输入G输出g
import java.io.*;
public class Test20006 {
public static void main(String[] args) throws IOException {
char ch;
ch=(char)System.in.read();
/*------------------*/
ch=(char)(ch+32);
System.out.println(ch);
}
}
七、计算三门课程的平均成绩。程序填空，不要改变与输入输出有关的语句。
已知某位学生的数学、英语和计算机课程的成绩分别是87分、72分和93分，求该生3门课程的平均分。
本题无输入。输出示例：math = 87, eng = 72, comp = 93 ,average = 84
public class test20007 {
public static void main(String[] args) {
int math, eng, comp, average;
/**********/
math=87;
eng=72;
comp=93;
average=(math+eng+comp)/3;
System.out.println("math = "+math+", eng = "+eng+", comp = "+comp);
System.out.println("average = "+ average);
}
}
八、计算存款利息。程序填空，不要改变与输入输出有关的语句。
输入存款金额 money、存期 year 和年利率 rate，根据下列公式计算存款到期时的利息 interest(税前)，输出时保留2位小数。
interest = money(1+rate)^year - money
输入输出示例：括号内为说明
输入1000 3 0.025 (money = 1000, year = 3, rate = 0.025)
输出interest = 76.89
import java.util.Scanner;
public class test20008 {
public static void main(String[] args) {
int money, year;
double interest, rate;
Scanner in=new Scanner(System.in);
/*使用in.nextDouble()和in.nextInt()输入double和int型数据*/
/**********/
money=in.nextInt();
year=in.nextInt();
rate=in.nextDouble();
interest=money*Math.pow((1+rate), year )- money;
表示的是1+rate的year方幂
System.out.println("interest = "+ (int)(interest*100+0.5)/100.0); //保留两位小数
}
}
实验5 分支结构程序的设计
一、显示两级成绩，程序填空，不要改变与输入输出有关的语句。
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入一个学生的数学成绩，如果它低于60，输出“Fail”，否则，输出“Pass”。
输出使用System.out.println("Pass");及System.out.println("Fail");
例：括号内是说明:输入2 (repeat=2) 60 59输出Pass Fail
import java.util.Scanner;
public class Test30001{
public static void main(String[] args){
int ri, repeat;
int mark;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
mark=in.nextInt();
/*------------------*/
if (mark<60)
System.out.println("Fail");
else
System.out.println("Pass");
}
}
}
二、找最小值，程序填空，不要改变与输入输出有关的语句。
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入四个整数，输出其中的最小值。
例：括号内是说明
输入
3 (repeat=3)
12 6 1 90
10 40 30 20
-1 -3 -4 -5
输出
min is 1 (12 6 1 90 中的最小值是1)
min is 10 (10 40 30 20 中的最小值是10)
min is -5 (-1 -3 -4 -5中的最小值是-5)
import java.util.Scanner;
public class Test30002 {
public static void main(String[] args){
int ri, repeat;
int a, b, c, d, min;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
a=in.nextInt();
b=in.nextInt();
c=in.nextInt();
d=in.nextInt();
/*------------------*/
min=a;
if(min>b) min=b;
if(min>c) min=c;
if(min>d) min=d;
System.out.println("min is "+min);
}
}
}
三、求三角形的面积和周长，程序填空，不要改变与输入输出有关的语句。
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入三角形的三条边a, b, c，如果能构成一个三角形，输出面积area和周长perimeter；否则，输出“These sides do not correspond to a valid triangle”。
在一个三角形中，任意两边之和大于第三边。
三角形的面积计算公式：
aere*area = s(s-a)(s-b)(s-c)
其中:s = (a+b+c)/2
输出代码:
System.out.println("area="+(int)(area*100+0.5)/100.+";perimeter="+(int)(perimeter*100+0.5)/100.);
System.out.println("These sides do not correspond to a valid triangle");
例：括号内是说明
输入
2 (repeat=2)
5 5 3
1 1 4
输出
area=7.15;perimeter=13.0
These sides do not correspond to a valid triangle
import java.util.Scanner;
public class Test30003 {
public static void main(String[] args){
int ri, repeat;
float a, b, c, area, perimeter, s;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
a=in.nextFloat();
b=in.nextFloat();
c=in.nextFloat();
/*------------------*/
if (a+b>c&&a+c>b&&b+c>a)
{ s=(a+b+c)/2;
area=(float)Math.sqrt(s*(s-a)*(s-b)*(s-c));
perimeter=a+b+c;
System.out.println("area="+(int)(area*100+0.5)/100.+";perimeter="+(int)(perimeter*100+0.5)/100.);
}
else
System.out.println("These sides do not correspond to a valid triangle");
}
}
}
四、判断数的符号，程序填空，不要改变与输入输出有关的语句。
输入整数x，若x大于0，y=1；若x等于0，y=0；否则，y=-1，最后输出y。
import java.util.Scanner;
public class Test30004{
public static void main(String[] args){
int ri, repeat;
int x, y;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
x=in.nextInt();
/*------------------*/
if (x>0)y=1;
else if(x==0)y=0;
else y=-1;
System.out.println(y);
}
}
}
if(x>0)
y=1;
if(x<0)
y=-1;
else
y=0;
(这样是错的。。这是为什么？)
五、计算个人所得税，程序填空，不要改变与输入输出有关的语句。
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入一个职工的月薪salary，输出应交的个人所得税tax。
tax = rate * (salary-850)
当 salary <= 850 时，rate = 0%;
当 850 < salary <= 1350 时，rate = 5%;
当 1350 < salary <= 2850 时，rate = 10%;
当 2850 < salary <= 5850 时，rate = 15%;
当 5850 < salary 时，rate = 20%;
例：括号内是说明
输入
5 (repeat=5)
1010.87
32098.76
800
4010
2850
输出
tax=8.04
tax=6249.75
tax=0.0
tax=474.0
tax=200.0
import java.util.Scanner;
public class Test30005 {
public static void main(String[] args){
int ri, repeat;
float rate, salary, tax;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
salary=in.nextFloat();
/*------------------*/
if(salary<=850)
rate=0;
else if(salary<=1350)
rate=0.05f;
else if(salary<=2850)
rate=0.1f;
else if(salary<=5850)
rate=0.15f;
else
rate=0.2f;
tax=rate*(salary-850);
System.out.println("tax="+(int)(tax*100+0.5)/100.0);
}
}
}
六、显示水果的价格，程序填空，不要改变与输入输出有关的语句。
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
以下4种水果的单价分别是3.00元/公斤，2.50元/公斤，4.10元/公斤，10.20元/公斤。
[1] apples
[2] pears
[3] oranges
[4] grapes
输入水果的编号，输出该水果的单价。如果输入不正确的编号，显示单价为0。
例：括号内是说明
输入
1 (repeat=1)
3 (oranges的编号)
输出
[1] apples
[2] pears
[3] oranges
[4] grapes
price=4.1
import java.util.Scanner;
public class Test30006{
public static void main(String[] args){
int ri, repeat;
int choice;
float price;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
System.out.println("[1] apples");
System.out.println("[2] pears");
System.out.println("[3] oranges");
System.out.println("[4] grapes");
choice=in.nextInt();
/*------------------*/
switch(choice){
case 1:price=3.0f;break;
case 2:price=2.5f;break;
case 3:price=4.1f;break;
case 4:price=10.2f;break;
default: price=0; }
System.out.println("price="+price);
}
}
}
七、字母转换，程序填空，不要改变与输入输出有关的语句。
输入一批以问号“?”结束的字符，对“?”以前的每一个字符，如果它是大写字母，输出相应的小写字母；如果它是小写字母，输出相应的大写字母；否则，原样输出。
import java.io.*;
public class Test30007 {
public static void main(String[] args)throws IOException{
char ch;
ch=(char)System.in.read();
while(ch!='?'){
/*------------------*/
if('A'<=ch&&ch<='Z')
ch+=32;
else if('a'<=ch&&ch<='z') //此处必须使用if结构的嵌套
ch-=32;
System.out.print(ch);
ch=(char)System.in.read();
}
}
}
循环结构程序的设计(一)
1. 求1＋1/2＋1/3＋……＋1/n 程序填空，不要改变与输入输出有关的语句。
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
读入1 个正整数 n(n<=100)，计算并输出1＋1/2＋1/3＋……＋1/n 。
i=1;
i<=n;
sum=0;
do
{
i=i+1;
sum=sum+1/i;
} while(n<=100);
System.out.println((int)(sum*1000+0.5)/1000.);
}
}
}
import java.util.Scanner;
public class Test40001 {
public static void main(String[] args) {
int ri, repeat;
int i, n;
float sum;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextInt();
/*--------------------*/
//以下if语句用于检查输入数据的正确性，可以不写
if(n<=0||n>100){ //输入0、负数或大于100的数时结束程序的运行
System.out.println("输入数据出错，程序退出");
System.exit(0);
}
sum=0; //注意这条赋初值语句的位置
for(i=1;i<=n;i++){
sum+=1.0f/i;
}
System.out.println((int)(sum*1000+0.5)/1000.);
}
}
}
2. 求n! 程序填空，不要改变与输入输出有关的语句。
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
读入1 个正整数 n(n<=50)，计算并输出n! 。
import java.util.Scanner;
public class Test40002 {
public static void main(String[] args) {
int ri, repeat;
int i, n;
double fact;/// 这里的double在编写中是用不到的吧~~
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextInt();
/*--------------------*/
fact=1;
for(i=1;i<=n;i++)
fact*=i;
System.out.println(fact);
}
}
}
3. 求x的n次幂 程序填空，不要改变与输入输出有关的语句。
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
读入1 个正实数x和1个正整数 n(n<=50)，计算并输出x的n次幂。
import java.util.Scanner;
public class Test40003 {
public static void main(String[] args) {
int ri, repeat;
int i, n;
double x, mypow;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
x=in.nextDouble();
n=in.nextInt();
/*--------------------*/
mypow=1;
for(i=1;i<=n;i++)
mypow*=x;
System.out.println(mypow);
} //这个，怎么感觉有些不对？？
}
}
4. 求1＋1/3＋1/5＋1/7＋…… 程序填空，不要改变与输入输出有关的语句。
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
读入1 个正整数 n(n<=100)，计算并输出1＋1/3＋1/5＋1/7＋……的前n项和。
import java.util.Scanner;
public class Test40005 {
public static void main(String[] args) {
int ri, repeat;
int i, n, temp;
float sum;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextInt();
/*--------------------*/
temp=1;
sum=0;
for(i=1;i<=n;i++) //那这里i是什么用的么？？循环N次！！
{ sum+=1.0f/temp;
temp+=2;
}
System.out.println(sum);
}
}
}
解法二：
temp=2*n-1;
sum=0;
for(i=1;i<=temp;i+=2)
sum+=1.0f/i;
5. 摄氏温度和华氏温度转换表。程序填空，不要改变与输入输出有关的语句。
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入2个整数begin和end，分别代表摄氏温度的起止值，输出该范围内摄氏温度C和华氏温度F的转换表。
F = 32 + C * 9 / 5
输出语句：System.out.println(c+"t"+f);
import java.util.Scanner;
public class Test40007 {
public static void main(String[] args){
int ri, repeat;
int begin, c, end, f;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
begin=in.nextInt();
end=in.nextInt();
System.out.println("Celsius Fahrenheit");//这一条在最后他是自会输出的！！
/*--------------------*/
for(c=begin;c<=end;c++) { //这样显然也是可以的~~
f=32+c*9/5;
System.out.println(c+"t"+f); //就算是空格也不要忘了加引号！！
}
}
}
}
6. 求奇数和。程序填空，不要改变与输入输出有关的语句。
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
读入一批正整数(以零或负数为结束标志)，求其中的奇数和。
import java.util.Scanner;
public class Test40008 {
public static void main(String[] args){
int ri, repeat;
int x, sum;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
x=in.nextInt();
/*--------------------*/
sum=0;
while(x>0){
if(x%2!=0)sum+=x;
x=in.nextInt(); 为什么把他放前面顺序就不一样了呢？
}
System.out.println(sum);
}
}
}
sum=0;
if(x%2!=0)
sum+=x; //if 和 while之间的区别要分清楚了！！
7. 求最大值。程序填空，不要改变与输入输出有关的语句。
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入一个正整数n, 再输入n个整数，输出最大值。
import java.util.Scanner;
public class Test40009 {
public static void main(String[] args){
int ri, repeat;
int i , max, n, x;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextInt();
/*--------------------*/
max=in.nextInt();
for(i=1;i<=n-1;i++){
x=in.nextInt();
if(x>max)max=x;
}
System.out.println(max);
}
}
}
8. 求整数的位数以及各位数之和。程序填空，不要改变与输入输出有关的语句。
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入一个整数，输出它的位数以及各位数之和。
import java.util.Scanner;
public class Test40010 {
public static void main(String[] args){
int ri, repeat;
int number, sum,n;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextInt();
/*--------------------*/
n=Math.abs(n);
number=sum=0;
do{
sum=sum+(n%10);
number++;
n=n/10; //这样一直除的话到后来sum一直是加0.但number不是还是一直在加上去么？
}while(n>0); //这个不是很显然的么？为什么还要写？
/* 如果使用while语句，输入0时输出 “number=0, sum=0”，
其中number的值不正确，应是1 */
System.out.println("number="+number+", sum="+sum);
}
}
}
import java.util.*;
public class grade {
public static void main(String []args){
Scanner in =new Scanner(System.in);
int gcd, lcm, m, n,r;
int repeat, ri;
repeat=in.nextInt();
for(ri = 1; ri <= repeat; ri++){
m=in.nextInt();
n=in.nextInt();
r=m;
if(m <= 0 || n <= 0)
System.out.println("m <= 0 or n <= 0");
else{lcm=m*n;
do{
if(m<n){r=m;m=n;n=r;
}
r=m%n ;
m=n;
n=r;
}while(r!=0);
gcd=m;
lcm=lcm/m;
System.out.println("the least common multiple:"+lcm+", the greatest common divisor:"+gcd);
}
}
}
}
循环结构程序的设计(二)
9. 求1－1/2＋1/3－1/4＋…… 程序填空，不要改变与输入输出有关的语句。
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
读入1 个正整数 n(n<=100)，计算并输出1－1/2＋1/3－1/4＋……的前n项和(四舍五入保留小数4位)。
import java.util.Scanner;
public class Test40004 {
public static void main(String[] args) {
int ri, repeat;
int i, n, flag;
float sum;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextInt();
/*--------------------*/
sum=0;
flag=1;
for(i=1;i<=n;i++) {
sum+=flag*1.0f/i;
flag=-flag;
}
System.out.println((long)(sum*10000+0.5)/10000.);
}
}
}
10. 求1－1/3＋1/5－1/7＋…… 程序填空，不要改变与输入输出有关的语句。
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
读入1 个正实数eps，计算并输出1－1/3＋1/5－1/7＋……，直到最后一项的绝对值小于eps为止(要求每一项的绝对值均大于等于eps,并以float类型输出数据)。
import java.util.Scanner;
public class Test40006 {
public static void main(String[] args) {
int ri, repeat;
int temp, flag;
double eps, item, sum;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
eps=in.nextDouble();
/*--------------------*/
item=1;
sum=0;
temp=flag=1;
while(Math.abs(item)>=eps){
sum+=item;
flag=-flag;
temp+=2;
item=flag*1.0/temp;
}
System.out.println((int)(sum*10000+0.5)/10000.);
}
}
}
11. 求2/1＋3/2＋5/3＋8/5＋... 程序填空，不要改变与输入输出有关的语句。
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入一个正整数n，输出 2/1+3/2+5/3+8/5 +...的前n项之和，保留4位小数(不足4位时,不必用0填满4位)。（该序列从第2项起，每一项的分子是前一项分子与分母的和，分母是前一项的分子）
import java.util.Scanner;
public class Test40011 {
public static void main(String[] args) {
int ri, repeat;
int i,n;
float a,b,s,t;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextInt();
/*--------------------*/
a=1; //分母 //这样的题目像兔子数列一样，开始时都定好一些值就好了。
b=2; //分子
s=0;
for(i=1;i<=n;i++) {
s+=b/a;
t=a;
a=b; //分母是前一项的分子
b=t+b; //分子是前一项分子与分母的和
}
s=s+b/a;
a=b;
b=a+b;
//为什么直接这样做他就错了呢？
System.out.println((int)(s*10000+.5)/10000.);
}
}
}
12. 求a＋aa＋aaa＋aa…a 程序填空，不要改变与输入输出有关的语句。
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入2个正整数a和n, 求a+aa+aaa+aa…a(n个a)之和。
import java.util.Scanner;
public class Test40012{
public static void main(String args[]){
int ri, repeat;
int i, n, a, sn, tn;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
a=in.nextInt();
n=in.nextInt();
/*--------------------*/
tn=a;
sn=0;
for(i=1;i<=n;i++){
sn+=tn;
tn=tn*10+a; //迭代公式
} sn=0;
tn=0;
for(i=1;i<=n;i++){
tn=tn*10+a;
sn=sn+tn;
}
System.out.println(sn);
}
}
}
13. 判断素数。程序填空，不要改变与输入输出有关的语句。
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入一个正整数m，如果它是素数，输出"YES"，否则，输出"NO"（素数就是只能被1和自身整除的正整数，1不是素数，2是素数）。
import java.util.Scanner;
public class Test40013{
public static void main(String args[]){
int ri, repeat;
int i, m, n;
boolean flag;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
m=in.nextInt();
/*--------------------*/
flag=true;
if(m==1)flag=false; ///true和false输进去是会变红的！！
for(i=2;i<=m-1;i++)
if(m%i==0){
flag=false;
break; //有些时候确实需要你确认一下是不是大括号方面出错了！！
} flag=true;if(m==1)flag=false;
for(i=2;i<=m-1;i++){
if(m%i==0)flag=false;
}
if(flag) System.out.println("YES");
else System.out.println("NO");
}
}
}
14. 求1 + 1/2! +....+ 1/n! 程序填空，不要改变与输入输出有关的语句。
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入1 个正整数n，计算 s 的前n项的和。
s = 1 + 1/2! +....+ 1/n!
import java.util.Scanner;
public class Test40021{
public static void main(String args[]){
int ri, repeat;
int i,n;
float s,t;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextInt();
/*--------------------*/
s=0;
t=1;
for(i=1;i<=n;i++){
t*=i;
s+=1/t; //如果这两条语句交换位置，则i=1要改成i=2
}
System.out.println((int)(s*10000+0.5)/10000.);
}
}
}
15. 求各位数字的立方和等于它本身的数。程序填空，不要改变与输入输出有关的语句。
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入2 个正整数m和n(1<=m,n<=1000)，输出m 和n之间所有满足各位数字的立方和等于它本身的数。
输出语句：System.out.println(i);
import java.util.Scanner;
public class Test40022{
public static void main(String args[]){
int ri, repeat;
int i, digit, m, n, number, sum;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
m=in.nextInt();
n=in.nextInt();
/*------------------*/
for(i=m;i<=n;i++){ //不能从值上来看i所代表的循环次数啊！！！
number=i;
sum=0; //为什么总有number大于0这个显然的东西？
while(number>0){
digit=number%10;
number=number/10;
sum+=digit*digit*digit;
}
if(i==sum)
System.out.println(i);
}
}
}
}
Method的使用
16. 统计素数并求和。程序填空，不要改变与输入输出有关的语句。
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入2 个正整数m和n(1<=m,n<=500)，统计并输出m 和n之间的素数的个数以及这些素数的和。
例：括号内是说明
输入：
3 (repeat=2)
1 10 (m=1, n=10)
20 35 (m=20, n=35)
14 16 (m=14, n=16)
输出：
count=4, sum=17 (1到10之间有4个素数：2,3,5,7)
count=3, sum=83 (20到35之间有3个素数：23, 29, 31)
count=0, sum=0 (14到16之间没有素数)
import java.util.Scanner;
public class Test40023 {
public static void main(String args[]){
int ri, repeat;
int count, digit, i, j, k , m, n, sum;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1;ri<=repeat;ri++) {
m=in.nextInt();
n=in.nextInt();
/*---------------------*/
count=sum=0;
for(k=m;k<=n;k++){
for(i=2;i<=k-1;i++)
if(k%i==0)break;
if(i==k){
count++;
sum+=k;
}
}
System.out.println("count="+count+", sum="+sum);
}
}
}
import java.util.Scanner;
public class Test40023_2 {
public static void main(String args[]){
int ri, repeat;
int count, i, j, k , m, n, sum;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1;ri<=repeat;ri++) {
m=in.nextInt();
n=in.nextInt();
/*---------------------*/
count=sum=0;
boolean flag;
for(k=m;k<=n;k++) {
if(k==1)flag=false; //1不是素数
else flag=true;
for(i=2;i<=k-1;i++) {
if(k%i==0){
flag=false;
break;
}
}
if(flag){
sum+=i;
count++;
}
}
System.out.println("count="+count+", sum="+sum); }
}
}
import java.util.Scanner;
public class a{
public static void main(String args[]){
int ri, repeat;
int count, i, j, k, m, n, sum;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
m=in.nextInt();
n=in.nextInt();
count=sum=0;
for(i=m;i<=n;i++)
{
if(isprime(i)) {count++;
sum+=i;}
}
System.out.println("count="+count+", sum="+sum);
}
}
public static boolean isprime(int n)
{
int i;
if(n<2) return false;
for(i=2;i<n;i++)
if(n%i==0) break;
if(i==n) return true;
else return false;
}
}
顺序结构程序的设计
17. 求1 + 1/2! +....+ 1/n!
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入1 个正整数n，计算 s 的前n项的和(保留 4 位小数)。
s = 1 + 1/2! +....+ 1/n!
要求定义并调用函数fact(n)计算n的阶乘。
import java.util.Scanner;
public class Test50001 {
public static void main(String[] args) {
int ri,repeat;
int i,n;
double s;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1;ri<=repeat;ri++){
n=in.nextInt();
/*---------------*/
s=0;
for(i=1;i<=n;i++)
s+=1.0/fact(i);
System.out.println((long)(s*10000+0.5)/10000.);
}
}
/*---------------*/
static double fact(int n) {
int i;
double f=1; //把两个变量先定义一下！！
for(i=1;i<=n;i++)
f*=i;
return f;
}
/* 方法fact()也可以用以下递归算法设计
static double fact(int n) {
if(n==1)
return 1;
else
return n*fact(n-1);
}
*/
}
18. 求a＋aa＋aaa＋aa…a
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入2个正整数a和n, 求a+aa+aaa+aa…a(n个a)之和。
要求定义并调用函数fn(a,n)，它的功能是返回aa…a(n个a)。例如，fn(3,2)的返回值是33。
import java.util.Scanner;
public class Test50002{
public static void main(String args[]){
int ri, repeat;
int i, n,a;
long sn;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
a=in.nextInt();
n=in.nextInt();
/*------------*/
sn=0;
for(i=1;i<=n;i++)
sn+=fn(a,i);
System.out.println(sn);
}
}
/*------------*/
static int fn(int a,int n){
int s=0;
for(int i=1;i<=n;i++)
s=s*10+a; f(a,n)=a+10*f(a,n-1); 错的原因是？
return s;
}
/* 方法fn()也可以用以下递归算法设计
static int fn(int a,int n){
if (n==1)
return a;
else
return a+10*fn(a,n-1);
} */
}
19. 统计一个整数中数字的个数
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
读入1 个整数，统计并输出该数中2的个数。
要求定义并调用函数countdigit(number,digit)，它的功能是统计整数number中数字digit的个数。例如，countdigit(10090,0)的返回值是3。
import java.util.Scanner;
public class Test50003{
public static void main(String args[]){
int ri, repeat;
int count;
long n;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextInt();
/*---------*/
n=Math.abs(n);
count = countdigit(n,2);
System.out.println("count="+count);
}
}
/*---------*/
static int countdigit(long number,int digit){
int a,c=0;
while(number>0){
a=(int)(number%10);
if(a==digit)c++ //当a不等于digit的情况下?是不是默认就进行下一个的循环了？
number=number/10;
}
return c;
}
}
20. 判断素数
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入一个正整数n，如果它是素数，输出"YES"，否则，输出"NO"（素数就是只能被1和自身整除的正整数，1不是素数，2是素数）。
要求定义并调用函数prime(m)判断m是否为素数。
import java.util.Scanner;
public class Test50004{
public static void main(String args[]){
int ri, repeat,n;
boolean flag;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextInt();
/*---------*/
flag=prime(n);
if(flag) System.out.println("YES");
else System.out.println("NO");
}
}
static boolean prime(int m){
boolean flag=true;
if(m==1)flag=false;
for(int i=2;i<=m-1;i++)
if(m%i==0)
{ flag=false; break; }
return flag;
}
}
21. 统计素数并求和
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入2 个正整数m和n(1<=m,n<=500)，统计并输出m 和n之间的素数的个数以及这些素数的和（素数就是只能被1和自身整除的正整数，1不是素数，2是素数）。
要求定义并调用函数prime(m)判断m是否为素数。
import java.util.Scanner;
public class Test50005{
public static void main(String args[]){
int ri, repeat;
int count, i, m, n, sum;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
m=in.nextInt();
n=in.nextInt();
/*---------*/
count=0;
sum=0;
for(i=m;i<=n;i++)
if(prime(i)){count++; sum+=i;}
System.out.println("count="+count+", sum="+sum);
}
}
/*---------*/
static boolean prime(int m){
boolean flag=true;
if(m==1)flag=false;
for(int i=2;i<=m-1;i++)
if(m%i==0)
{ flag=false; break; }
return flag;
}
}
22. 输出 Fibonacci 序列
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入2 个正整数m和n(1<=m,n<=10000)，输出m 和n之间所有的Fibonacci数。
Fibonacci 序列（第1项起）：1 1 2 3 5 8 13 21 ......
要求定义并调用函数fib(n)，它的功能是返回第n项Fibonacci数。例如，fib(7)的返回值是13。
输出语句：System.out.print(f+" ");
import java.util.Scanner;
public class Test50006{
public static void main(String args[]){
int ri,repeat;
int i, m, n;
long f;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
m=in.nextInt();
n=in.nextInt();
/*---------*/
i=1;
f=1;
while(f<=n){
if(f>=m) System.out.print(f+" ");
i++;
f=fib(i); //是要输出的数在mn之间，而不是要循环这么多次啊！
}
System.out.println();
}
}
/*---------*/
static long fib(int n){
int i;
long a=1,b=1,f=1;
for(i=3;i<=n;i++){ //从第3项开始计算
f=a+b;
a=b;
b=f;
}
return f;
}
}
/* 方法fib(n)用递归实现
static long fib(int n){
if(n==1||n==2) return 1;
else return fib(n-1)+fib(n-2);
}
*/
23. 求完数
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入2 个正整数m和n(1<=m,n<=1000)，输出m 到n之间的所有完数（完数就是因子和与它本身相等的数）。
要求定义并调用函数factorsum(number)，它的功能是返回number的因子和。例如，factorsum(12)的返回值是16（1+2+3+4+6）。
输出语句：System.out.print(i+" ");
import java.util.Scanner;
public class Test50007{
public static void main(String args[]){
int ri,repeat;
int i, m, n;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1;ri<=repeat;ri++){
m=in.nextInt();
n=in.nextInt();
/*---------*/
for(i=m;i<=n;i++)
if(i==factorsum(i))
System.out.print(i+" ");
System.out.println();
}
}
static int factorsum(int number){
int sum=0;
if(number==1)sum=1;
for(int i=1;i<=number-1;i++)
if(number%i==0)sum+=i;
return sum;
}
}
static int factorsum(int number){
int s=0,a=0;
while(number>0){
a=number%10;
s=s+a;
number=number/10;
}
return s;
} 哎呀！！！你这样定义的不是因子和啊！！
24. }求各位数字的立方和等于它本身的数
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入2 个正整数m和n(1<=m,n<=1000)，输出m 到n之间的所有满足各位数字的立方和等于它本身的数。
要求定义并调用函数is(number)判断number的各位数字之立方和是否等于它本身。
输出语句：System.out.print(i+" ");
import java.util.Scanner;
public class Test50008{
public static void main(String args[]){
int ri,repeat;
int i, m, n;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1;ri<=repeat;ri++){
m=in.nextInt();
n=in.nextInt();
/*---------*/
for(i=m;i<=n;i++)
if(is(i))
System.out.print(i+" ");
System.out.println();
}
}
/*---------*/
static boolean is(int number) {
int sum=0,n,digit;
n=number;
while(n>0){
digit=n%10;
n=n/10;
sum+=digit*digit*digit;
}
if(number==sum)
return true;
else
return false;
}
}
Method的使用(二)
25. 将一个整数逆序输出
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入一个整数，将它逆序输出。
要求定义并调用函数reverse(number)，它的功能是返回number的逆序数。例如reverse(12345)的返回值是54321。
import java.util.Scanner;
public class Test50009{
public static void main(String args[]){
int ri,repeat;
long n, res;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1;ri<=repeat;ri++){
n=in.nextInt();
/*---------*/
res=reverse(n);
System.out.println(res);
}
}
/*---------*/
static long reverse(long number){
int flag=1;
long a=0,digit;
if(number<0){
flag=-1;
number=-number;
}
while(number>0){
digit=number%10; //分离出个位数字
a=a*10+digit; //形成当前的逆序数
number=number/10;
}
return flag*a;
}
}
26. 十进制转换二进制
输入一个正整数 repeat (0<repeat<10)，做 repeat 次下列运算：
输入1 个正整数n，将其转换为二进制后输出。
要求定义并调用函数 dectobin(n)，它的功能是输出 n 的二进制。例如，调用dectobin(10)，输出1010。
输出语句：System.out.print(t); //t为某位二进制数
import java.util.Scanner;
public class Test50010{
public static void main(String args[]){
int ri,repeat;
int i,n;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1;ri<=repeat;ri++){
n=in.nextInt();
/*---------*/
dectobin(n);
System.out.println();
}
}
/*---------*/
static void dectobin(int n){
int t; //保存某位二进制
String s=""; //保存二进制数
do {
t=n%2; //获得除2后的余数
s=t+s; //拼接
n=n/2; //获得除2后的商
}while(n>0);
System.out.print(s); //本方法无返回值，需要在方法体中输出结果
}
}
一维数组的使用
27. 求平均值
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入一个正整数n (1<n≤10)，再输入n个整数，输出平均值。
import java.util.Scanner;
public class Test60001{
public static void main(String []args){
int ri, repeat;
int i, n, sum,a[];
float aver;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextInt();
a=new int[n];
for(i=0; i<n; i++)
a[i]=in.nextInt();
/*---------*/
sum=0;
for(i=0; i<n; i++) //这个循环实现累加
sum+=a[i];
aver=((float)sum)/n; //求平均值，注意要先把sum转换成float，再计算
System.out.println("aver="+aver);
}
}
}
28. 求最大值及其下标
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入一个正整数n (1<n≤10)，再输入n个整数，输出最大值极其下标（设最大值惟一，下标从0开始）。
import java.util.Scanner;
public class Test60002{
public static void main(String []args){
int ri, repeat;
int i, index, n, a[];
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextInt();
a=new int[n] ;
for(i=0; i<n; i++)
a[i]=in.nextInt();
/*---------*/
index=0; //用index保存最大数的下标，开始假设a[0]是最大数
for(i=1; i<n; i++)
if(a[index]<a[i]) index=i;
//a[i]与当前最大数a[index]比较，若a[i]更大，index变为i
System.out.println("max="+a[index]+",index="+index);
}
}
}
29. 逆序输出
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入一个正整数n (1<n≤10)，再输入n个整数，按逆序输出这些数。
import java.util.Scanner;
public class Test60003{
public static void main(String []args){
int ri, repeat;
int i, n, temp,a[];
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextInt();
a=new int[n];
for(i=0; i<n; i++)
a[i]=in.nextInt();
/*---------*/
for(i=0; i<n/2; i++){ //a[i]与a[n+1-i]交换，注意交换次数
temp=a[i];
a[i]=a[n+1-i];
a[n+1-i]=temp;
}
for(i=0; i<n; i++)
System.out.print(a[i]+" ");
System.out.println();
}
}
}
30. 交换最小值和最大值
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入一个正整数n，再输入n个整数，将最小值与第一个数交换，最大值与最后一个数交换，然后输出交换后的n个数。
import java.util.Scanner;
public class Test60004{
public static void main(String []args){
int ri, repeat;
int i, index, n, t,a[];
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextInt();
a=new int[n];
for(i=0; i<n; i++)
a[i]=in.nextInt();
/*---------*/
index=0; //找最大数
for(i=0; i<n; i++)
if(a[index]<a[i]) index=i;
t=a[index]; a[index]=a[n-1];a[n-1]=t; //交换
index=0; //找最小数
for(i=0; i<n; i++)
if(a[index]>a[i]) index=i;
t=a[index]; a[index]=a[0];a[0]=t; //交换
for(i=0; i<n; i++) //输出
System.out.print(a[i]+" ");
System.out.println();
}
}
}
二维数组的使用
31. 排序
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入一个正整数n，再输入n个整数，将它们从大到小排序后输出。
import java.util.Scanner;
public class Test60005{
public static void main(String []args){
int ri, repeat;
int i, index, k, n, temp,a[];
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextInt();
a=new int[n];
for(i=0; i<n; i++)
a[i]=in.nextInt();
/*---------*/
for(i=0;i<n-1;i++) { //选择法递减排序
index=i;
for(k=i+1;k<n;k++)
if(a[k]>a[index]) index=k;
temp=a[i];
a[i]=a[index];
a[index]=temp;
}
for(i=0; i<n; i++)
System.out.print(a[i]+" ");
System.out.println();
}
}
}
32. 矩阵运算
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
读入 1 个正整数 n(1≤n≤6), 再读入 n 阶方阵 a , 计算该矩阵除副对角线、最后一列和最后一行以外的所有元素之和.(副对角线为从矩阵的右上角至左下角的连线)
import java.util.Scanner;
public class Test60011{
public static void main(String []args){
int ri, repeat;
int a[][],i,j,n,sum;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextInt();
a=new int[n][n];
for(i=0; i<n; i++)
for(j=0;j<n;j++)
a[i][j]=in.nextInt();
/*---------*/
sum=0;
for(i=0; i<n-1; i++) //i<n-1 排除最后一行
for(j=0;j<n-1;j++){ //j<n-1 排除最后一列
if((i+j)!=(n-1)) sum+=a[i][j]; //非副对角线元素才加入
}
System.out.println("sum="+sum);
}
}
}
33. 加法口诀表
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入 1 个正整数 n(1≤n≤10), 输出一张 20 以内的加法口诀表. 加数与被加数都不大于 n, 分列第一行和第一列.(将加数、被加数、和放入一个二维数组中, 再输出该数组)
import java.util.Scanner;
public class Test60012{
public static void main(String []args){
int ri, repeat;
int i,j,n,a[][]=new int[10][10];
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextInt();
/*---------*/
for(i=1;i<=n;i++) { //给第1行和第1列所有元素赋值,a[0][0]不用赋值
a[0][i]=i; //第1行为被加数,从第2列开始赋值1,2,...,n
a[i][0]=i; //第1列为加数,从第2行元素开始赋值1,2,...,n
}
for(i=1;i<=n;i++) //计算和,从第2行第2列开始
for(j=1;j<=n;j++){
a[i][j]=i+j;
//或 a[i][j]=a[0][j]+a[i][0]; //所在列第1行元素+所在行第1列元素
}
for( i=0; i<=n; i++ ){
for( j=0; j<=n; j++ )
if(i==0&&j==0) System.out.print( "+ ");//在第1行第1列上输出"+ "
else if(i==0||j<=i) System.out.print(a[i][j]+" ");
//输出下三角阵和第1行元素
System.out.println();
}
}
}
}
34. 判断上三角矩阵
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入1 个正整数 n (1≤n≤6)和n 阶方阵a中的元素，如果a是上三角矩阵, 输出"YES", 否则, 输出"NO"。(上三角矩阵，即主对角线以下的元素都为0, 主对角线为从矩阵的左上角至右下角的连线)
import java.util.Scanner;
public class Test60013{
public static void main(String []args){
int ri, repeat;
int a[][],i,j,n;
boolean flag;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextInt();
a=new int[n][n]
for (i=0;i<n;i++)
for (j=0;j<n;j++)
a[i][j]=in.nextInt();
/*---------*/
flag=true;
for(i=1;i<n;i++) //上三角矩阵中值为0的元素位置:行1~n-1,列0~i-1
for(j=0;j<i;j++)
if(a[i][j]!=0) flag=false;//若有一个元素非0,则不是上三角矩阵
if(flag) System.out.println("YES");
else System.out.println("NO");
}
}
}
35. 求矩阵每行元素之和
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入2 个正整数 m 和 n (1≤m, n)，然后输入该m 行 n 列矩阵a中的元素，分别求出
各行元素之和, 并存入一维数组row中, 再输出row.
import java.util.Scanner;
public class Test60014{
public static void main(String []args){
int ri, repeat;
int i,j,m,n,a[][],row[];
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
m=in.nextInt();
n=in.nextInt();
a=new int[m][n];
row=new int[m]; //这里定义的时候row也是定义在行那里的！！！
for (i=0;i<m;i++)
for (j=0;j<n;j++)
a[i][j]=in.nextInt();
/*---------*/
for (i=0;i<m;i++)
for (j=0;j<n;j++) //表示的是那一个矩阵 row[i]+=a[i][j]; //计算数组a的第i+1行元素之和, 存入数组row的第i+1个元素
for(i=0;i<m;i++)
System.out.println("sum of row "+i+" is "+row[i]);
}
}
}
字符串处理
36. 求字符串长度
连续输入一批以 # 结束的多串字符（不包含空格）。。
统计并输出每串字符的长度。
输出使用：System.out.println(len);
import java.util.Scanner;
public class Test60021{
public static void main(String []args){
int len,count,i,k; //变量count,k未用到
char ch;
String str;
Scanner in=new Scanner(System.in);
//话说这里就是一个数组了么？ str=in.next(); //对5月7日前建立的练习用in.nextLine();
/*---------*/
len=0; //保存当前字符串的长度
// count=0; //保存字符串个数,可以不写
for(i=0;i<str.length();i++) {
ch=str.charAt(i); //从字符串中逐个取出字符
if(ch=='#'){ //当前字符串结束了
System.out.println(len);//输出长度
// count++; //字符串增加1个,可以不写
len=0; //新的字符串要开始了
}
else len++; //当前字符串长度加1
}
//以上程序段可以换成以下的程序段:
// String[] s=str.split("#"); //字符串数组
// for(i=0;i<s.length;i++)
// System.out.println(s[i].length()); 输出的是第i串字符的长度
}
}
37. 统计大写辅音字母
输入一个正整数n (0<n<10)，做n次下列运算：
输入一行字符串，统计并输出字符串中大写辅音字母的个数
(大写辅音字母:除“A”,“E”,“I”,“O”,“U”以外的大写字母)。
import java.util.Scanner;
public class Test60022{
public static void main(String []args){
int count,i,j,n;
char ch;
String str;
Scanner in=new Scanner(System.in);
n=(in.nextLine()).charAt(0)-'0'; //读取输入的第1行的第1个字符，转换成数字
for(i=1;i<=n;i++){
str=in.nextLine(); //读取输入的下一行
/*---------*/
count=0; //保存大写辅音字母的个数
for(j=0;j<str.length();j++){
ch=str.charAt(j); //从字符串中逐个取出字符
if((ch>='B'&&ch<='Z')&&(ch!='E'&&ch!='I'&&ch!='O'&&ch!='U'))//判断
//大写字母'B'~'Z'中去掉'E','I','O','U'
count++;
}
System.out.println(count);
}
}
}
38. 查找字符
先输入一个字符ch。然后输入一个正整数n (0<n<10)，做n次下列运算：
输入一行字符串，在字符串中查找该字符(ch)，如果找到，则输出
该字符在字符串中最后出现的位置(从0开始)；否则输出“Not Found”。
import java.util.Scanner;
public class Test60023{
public static void main(String []args){
int index,i,n,j;
char ch;
String str;
Scanner in=new Scanner(System.in);
ch=(in.nextLine()).charAt(0); //读取输入的第1行的第1个字符，就是要查找的字符
n=(in.nextLine()).charAt(0)-'0'; //读取输入的第2行的第1个字符，转换成数字
for(i=1;i<=n;i++){
str=in.nextLine(); //读取输入的下一行
/*---------*/
index=-1; //先假设找到
for(j=0;j<str.length();j++)
if(str.charAt(j)==ch) index=j;
//从当前字符串中找字符ch,找到时记住它的位置,继续找下一个
//循环结束后,index中的值就是最后出现的位置
if(index>=0) System.out.println(index);
else System.out.println("Not Found");
}
}
}
//解法2：从字符串末尾开始找字符ch，第1次找到时记住它的位置，终止循环。
index=-1;
for(j=str.length()-1;j>=0;j--){
if(str.charAt(j)==ch)
{index=j;break; }
}
39. 字符串替换
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入一行字符串，生成一个新的字符串，将原字符串中的大写字母用下面列出的对应大写字母替换, 其余字符不变, 输出新字符串.
原字母 对应字母
A ──→ Z
B ──→ Y
C ──→ X
D ──→ W
……
X ──→ C
Y ──→ B
Z ──→ A
import java.util.Scanner;
public class Test60024{
public static void main(String []args){
int ri, repeat, i;
char ch;
String str1,str2;
Scanner in=new Scanner(System.in);
repeat=(in.nextLine()).charAt(0)-'0';
for(ri=1; ri<=repeat; ri++){
str1=in.nextLine();
/*---------*/
str2=""; //保存转换后的新字符串
for(i=0;i<str1.length();i++) {
ch=str1.charAt(i); //从字符串中逐个取出字符
if((ch>='A'&&ch<='Z')) //对该字符进行转换
ch=(char)('Z'-ch+'A');
str2=str2+ch; //转换后字符添加到结果中
}
System.out.println(str2);
}
}
}
字符串处理（二）
40010 40031 40032 50003 50009 50010 60025
说明：本次实验中的题目请采用字符串处理来实现。
40. 求整数的位数以及各位数之和。40010
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入一个整数，输出它的位数以及各位数之和。
import java.util.Scanner;
public class Test40010 {
public static void main(String[] args){
int ri, repeat;
int number, sum,n;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextInt();
/*--------------------*/
n=Math.abs(n);
String s=String.valueOf(n); //把整数n转换成字符串
number=s.length(); //得到整数的位数
sum=0;
for(int i=0;i<number;i++){
sum+=(s.charAt(i)-'0'); //求各位数字和
}
System.out.println("number="+number+", sum="+sum);
}
}
}
41. 统计单词(选做) 40031
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入一行字符，统计其中单词的个数。各单词之间用空格分隔，空格数可以是多个。
import java.util.Scanner;
public class Test40031{
public static void main(String []args ){
int ri, repeat,count, word,i;
String line;
char c;
Scanner in=new Scanner(System.in);
repeat=(in.nextLine()).charAt(0)-'0';
for(ri=1; ri<=repeat; ri++){
line=in.nextLine();
/*---------*/
count=word=0;
for(i=0;i<line.length();i++){
c=line.charAt(i); //从字符串line中取出第i个字符，放入变量c
if(c==32) word=0; //当前字符是空格，表示不是单词
else if(word==0){ //当前字符不是空格，同时word=0，表示新单词开始
word=1;
count++;
}
}
System.out.println( count);
}
}
}
42. 输出一个整数的各位数字(选做) 40032
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入一个整数，从高位开始逐位输出它的各位数字。
输出语句：System.out.print(digit+" ");
例：括号内是说明
import java.util.Scanner;
public class Test40032{
public static void main(String []args ){
int ri, repeat;
int digit;
long n, temp, pow;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextLong();
/*---------*/
n=Math.abs(n);
String s=String.valueOf(n); //把整数n转换成字符串
for(int i=0;i<s.length();i++){
digit=s.charAt(i)-'0'; //从高位到低位依次得到一位数字
System.out.print(digit+" "); //输出该位数字，再加一个空格
}
System.out.println();
}
}
}
另一种编法：
n=Math.abs(n);
char[] cs=String.valueOf(n).toCharArray();
//把整数n转换成字符串后存入字符数组cs，cs的元素就是n的每位数字
for(int i=0;i<cs.length;i++)
System.out.print(cs[i]+" "); //依次输出字符数组cs的各个元素
43. 统计一个整数中数字的个数 50003
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
读入1 个整数，统计并输出该数中2的个数。
要求定义并调用函数countdigit(number,digit)，它的功能是统计整数number中数字digit的个数。例如，countdigit(10090,0)的返回值是3。
import java.util.Scanner;
public class Test50003{
public static void main(String args[]){
int ri, repeat;
int count;
long n;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextInt();
/*---------*/
n=Math.abs(n);
count=countdigit(n,2);
System.out.println("count="+count);
}
}
/*------------*/
static int countdigit(long number,int digit){//统计整数number中数字digit的个数
int c=0;
String s=String.valueOf(number); //把长整数number转换成字符串
//以下循环实现：依次取出number的每个数字与指定数字digit比较，若相等则个数加1
for(int i=0;i<s.length();i++)
if(s.charAt(i)-'0'==digit)c++;
return c;
}
}
44. 将一个整数逆序输出 50009
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入一个整数，将它逆序输出。
要求定义并调用函数reverse(number)，它的功能是返回number的逆序数。例如reverse(12345)的返回值是54321。
import java.util.Scanner;
public class Test50009{
public static void main(String args[]){
int ri,repeat;
long n, res;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1;ri<=repeat;ri++){
n=in.nextInt();
/*---------*/
res=reverse(n);
System.out.println(res);
}
}
/*---------*/
static long reverse(long number){//返回number的逆序数
long a;
int flag=1; //保存符号
if(number<0) {
flag=-1;
number=-number; //负数变成正数
}
String s1=String.valueOf(number);
String s2="";
for(int i=0;i<s1.length();i++)
s2=s1.charAt(i)+s2; //字符串逆序
a=Long.parseLong(s2); //转换成数值
return flag*a; //加上符号
}
}
45. 十进制转换二进制50010
输入一个正整数 repeat (0<repeat<10)，做 repeat 次下列运算：
输入1 个正整数n，将其转换为二进制后输出。
要求定义并调用函数 dectobin(n)，它的功能是输出 n 的二进制。例如，调用dectobin(10)，输出1010。
输出语句：System.out.print(t); //t为某位二进制数
import java.util.Scanner;
public class Test50010{
public static void main(String args[]){
int ri,repeat;
int i,n;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1;ri<=repeat;ri++){
n=in.nextInt();
/*---------*/
dectobin(n);
System.out.println();
}
}
/*---------*/
static void dectobin(int n){
int t; //保存某位二进制
String s=""; //保存二进制数,这是字符串
do {
t=n%2; //获得除2后的余数
s=t+s; //拼接
n=n/2; //获得除2后的商
}while(n>0);
System.out.print(s); //本方法无返回值，需要在方法体中输出结果
}
}
46. 十六进制转换十进制 60025
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入一行字符串，对字符串做如下处理：滤去所有的非十六进制字符后，组成一
个新字符串（十六进制形式），然后将其转换为十进制数后输出。
import java.util.Scanner;
public class Test60025{
public static void main(String []args){
int ri, repeat, i,number;
char ch;
String str;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
str=in.next();
/*---------*/
number=0;
for(i=0;i<str.length();i++){ //从左往右依次取出字符
ch=str.charAt(i);
if(ch>='0'&&ch<='9') //合法字符转换成相应数值后计算十进制数
number=number*16+(ch-'0');
else if(ch>='A'&&ch<='F')
number=number*16+(ch-'A'+10);
else if(ch>='a'&&ch<='f')
number=number*16+(ch-'a'+10);
}
//说明：要滤去所有的非十六进制字符，实际上只要对这些字符不进行任何操作就行了（当它不存在！）。
System.out.println(number);
}
}
}
或：
number=0;
str=str.toLowerCase(); //所有字母转换成小写字母
for(i=0;i<str.length();i++){ //从左往右依次取出字符
ch=str.charAt(i);
if(ch>='0'&&ch<='9') //合法字符转换成相应数值后计算十进制数
number=number*16+(ch-'0');
else if(ch>='a'&&ch<='f')
number=number*16+(ch-'a'+10);
}
或：
number=0;
str=str.toUpperCase(); //所有字母转换成大写字母
for(i=0;i<str.length();i++){ //从左往右依次取出字符
ch=str.charAt(i);
if(ch>='0'&&ch<='9') //合法字符转换成相应数值后计算十进制数
number=number*16+(ch-'0');
else if(ch>='A'&&ch<='F')
number=number*16+(ch-'A'+10);
}
实验13 数组作为方法的参数（4-6题）
40023 40033(选做) 60019(选做) 60030 60031 60032
47. 统计素数并求和。 40023
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入2 个正整数m和n(1<=m,n<=500)，统计并输出m 和n之间的素数的个数以及这些素数的和。
import java.util.Scanner;
public class Test40023{
public static void main(String args[]){
int ri, repeat;
int count, i, j, k, m, n, sum;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
m=in.nextInt();
n=in.nextInt();
/*---------------------*/
count=sum=0;
for(k=m;k<=n;k++){
for(i=2;i<=k-1;i++)
if(k%i==0)break;
if(i==k){
count++;
sum+=k;
}
}
System.out.println("count="+count+", sum="+sum);
}
}
}
另一种编法：
count=sum=0;
boolean flag;
for(k=m;k<=n;k++) {
if(k==1)flag=false; //1不是素数
else flag=true;
for(i=2;i<=k-1;i++) {
if(k%i==0){flag=false; break;}
}
if(flag){sum+=i; count++;}
}
48. 简单计算器(选做) 40033
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
程序模拟简单运算器的工作：输入一个算式，遇等号"="说明输入结束，输出结果。
假设计算器只能进行加减乘除运算，运算数和结果都是整数，4种运算符的优先级相同，按从左到右的顺序计算。
import java.util.Scanner;
public class T40033{
public static void main(String args[]) {
int ri, repeat;
int op1, op2, res;
char operator;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
op1=in.nextInt();
operator=(in.next()).charAt(0);
/*---------*/
res=op1;
while(operator!='=') {
op2=in.nextInt();
switch(operator) {
case '+': res+=op2;break;
case '-': res-=op2;break;
case '*': res*=op2;break;
case '/': res/=op2;break;
}
operator=(in.next()).charAt(0);
}
System.out.println(res);
}
}
}
49. 找鞍点(选做)
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入 1 个正整数 n和n 阶方阵a中的元素，如果找到a 的鞍点（鞍点的元素值在该行上最大, 在该列上最小）, 就输出它的下标, 否则,输出"NO"（设a最多有1个鞍点）。
import java.util.Scanner;
public class Test60019{
public static void main(String []args){
int ri, repeat;
int i,j,k,row,col,n,a[][];
boolean flag;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextInt();
a=new int[n][n];
for (i=0;i<n;i++)
for (j=0;j<n;j++)
a[i][j]=in.nextInt();
/*---------*/
flag=true; row=0; col=0;//不写这些，就通不过编译
for(i=0;i<n;i++){
//先在第i行中找出该行的最大值
row=i; //row保存最大值的行坐标
col=0; //col保存最大值的列坐标，假设第i行第0列元素为最大
for(j=1;j<n;j++)
if(a[row][j]>a[row][col]) col=j;
//再判断a[row][col]是否是第col列中的最小值
flag=true;
for(k=0;k<n;k++)
if(a[k][col]<a[row][col]){
flag=false;
break; //若有比a[row][col]小的，可知它不是鞍点，可结束循环
}
if(flag)break; //找到1个鞍点后就不用再找了
}
if(flag) System.out.println("a["+row+"]["+col+"]="+a[row][col]);
else System.out.println("NO");
}
}
}
50. 编写排序函数(方法) 60030
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入一个正整数n，再输入n个整数，将它们从小到大排序后输出。要求将排序编写为一个sort()方法。
import java.util.Scanner;
public class Test60030{
public static void main(String []args){
int ri, repeat;
int i, n, a[];
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextInt();
a=new int[n];
for(i=0; i<n; i++)
a[i]=in.nextInt();
sort(a);
for(i=0; i<n; i++)
System.out.print(a[i]+" ");
System.out.println();
}
}
/*---------*/
//说明：数组作参数时，传递的是地址，形参数组和实参数组共用同一块内存，
//方法sort()中对形参数组b排序，实际上就是对实参数组a排序，
//所以不需要返回值。
static void sort(int b[]){
int i,j,k,temp;
for(i=0;i<b.length-1;i++) { //选择法递增排序
k=i;
for(j=i+1;j<b.length;j++)
if(b[k]>b[j]) k=j;
if(i!=k){
temp=b[i];b[i]=b[k]; b[k]=temp;
}
}
}
}
51. 编写矩阵加法和输出函数(方法) 60031
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
读入 1 个正整数 n(1≤n≤6), 再读入2个 n 阶方阵 a和b , 计算矩阵的和。
要求：（1）编写计算矩阵和的函数（方法）add()。（2）编写输出矩阵的方法prt()。
矩阵元素输出使用：System.out.print(a[i][j]+" ");
import java.util.Scanner;
public class Test60031{
public static void main(String []args){
int ri, repeat;
int a[][],b[][],c[][],i,j,n;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextInt();
a=new int[n][n]; b=new int[n][n];c=new int[n][n];
for(i=0; i<n; i++)
for(j=0;j<n;j++)
a[i][j]=in.nextInt();
for(i=0; i<n; i++)
for(j=0;j<n;j++)
b[i][j]=in.nextInt();
add(a,b,c);
prt("A矩阵",a);
prt("B矩阵",b);
prt("A+B矩阵",c);
}
}
/*----加法-----*/
static void add(int x[][],int y[][],int z[][]){
for(int i=0;i<x.length;i++) {
for(int j=0;j<x[i].length;j++) {
z[i][j]=x[i][j]+y[i][j];
}
}
}
/*----输出-----*/
static void prt(String s,int a[][]){
System.out.println(s);
for(int i=0; i<a.length; i++){
for(int j=0;j<a[i].length;j++)
System.out.print(a[i][j]+" ");
System.out.println();
}
}
}
52. 编写函数求矩阵最大值 60032
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
读入 2 个正整数 m和n(1≤m,n≤6), 再读入1个 m×n 阶矩阵 a , 计算该矩阵元素的最大值。
要求：编写max()，返回矩阵元素的最大值。
import java.util.Scanner;
public class Test60032{
public static void main(String []args){
int ri, repeat;
int a[][],i,j,m,n;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
m=in.nextInt(); n=in.nextInt();
a=new int[m][n];
for(i=0; i<m; i++)
for(j=0;j<n;j++)
a[i][j]=in.nextInt();
System.out.println("max="+max(a));
}
}
/*---------*/
static int max(int b[][]){
int max=b[0][0]; 先设第一个元素是最大的
for(int i=0;i<b.length;i++)
for(int j=0;j<b[i].length;j++)
if(max<b[i][j]) max=b[i][j];
return max;
}
}
程序填空，不要改变与输入输出有关的语句。
输入一个正整数repeat (0<repeat<10)并换行，然后做repeat次下列运算：
输入一行字符，统计其中单词的个数。各单词之间用空格分隔，空格数可以是多个。
说明：
1）使用c=line.charAt(i);表示从line中获得第i个字符，i从0开始。
2）line中的字符个数为：line.length()
例：括号内是说明
输入
2
Reold building room 123 Programming is fun
输出
4
3
import java.util.Scanner;
public class Test40031{
public static void main(String []args ){
int ri, repeat,count, word,i;
String line;
char c;
Scanner in=new Scanner(System.in);
repeat=(in.nextLine()).charAt(0)-'0'; //输入repeat
for(ri=1; ri<=repeat; ri++){
line=in.nextLine(); //输入一行字符
/*---------*/
System.out.println( count);
}
}
}
程序填空，不要改变与输入输出有关的语句。
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入一个整数，从高位开始逐位输出它的各位数字。
输出语句：System.out.print(digit+" ");
例：括号内是说明
输入
3
123456
-600
8
输出
1 2 3 4 5 6
6 0 0
8
import java.util.Scanner;
public class Test40032{
public static void main(String []args ){
int ri, repeat;
int digit;
long n, temp, pow;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
n=in.nextLong();
/*---------*/
System.out.println();
}
}
}
import java.util.Scanner;
public class a {
public static void main(String[] args) {
int ri, repeat;
int digit;
long n, temp, pow;
Scanner in = new Scanner(System.in);
repeat = in.nextInt();
for (ri = 1; ri <= repeat; ri++) {
n = in.nextLong();
if(n<0){
n = -n;
}
temp = n;
digit = 0;
while(temp>0){
digit++;
temp /= 10;
}
while(digit>0){
pow = (long) Math.pow(10, digit-1);
System.out.print(n/pow%10+" ");
digit--;
}
System.out.println();
}
}
}
程序填空，不要改变与输入输出有关的语句。
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
程序模拟简单运算器的工作：输入一个算式，遇等号"="说明输入结束，输出结果。
假设计算器只能进行加减乘除运算，运算数和结果都是整数，4种运算符的优先级相同，按从左到右的顺序计算。
例：括号内是说明
输入
2
15 + 2 / 3 =
1 + 2 * 10 - 10 / 2 =
输出
5
10
import java.util.Scanner;
public class T40033{
public static void main(String args[]) {
int ri, repeat;
int op1, op2, res;
char operator;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
op1=in.nextInt();
operator =(in.next()).charAt(0);
/*---------*/
System.out.println(res);
}
}
}
import java.util.Scanner;
public class a{
public static void main(String args[]) {
int ri, repeat;
int op1, op2, res;
char operator;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1; ri<=repeat; ri++){
op1=in.nextInt();
operator =(in.next()).charAt(0);
while(operator!='=')
{op2=in.nextInt();
switch(operator){
case '+':op1+=op2;break;
case '-':op1-=op2;break;
case '*':op1*=op2;break;
case '/':op1/=op2;break;
}
operator=(in.next()).charAt(0);
}
res=op1;
System.out.println(res);
}
}}
输出m~n之间的所有闰年
程序填空，不要改变与输入输出有关的语句。
输入一个repeat(1<repeat<10))，做repeat次下列运算：
输入正整数m和n（1900<=m<=n<=2100），分别代表年份的起止值，输出该范围内所有的闰年。判断闰年的条件是：能被 4 整除但不能被 100 整除，或者能被 400 整除。
输出使用语句 System.out.println(year);
输入输出示例：括号内是说明
输入：
2
2000 2017
2030 2040
输出
2000
2004
2008
2012
2016
2032
2036
2040
import java.util.Scanner;
public class T{
public static void main(String []args){
int year,m,n,repeat,ri;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1;ri<=repeat;ri++){
m=in.nextInt();
n=in.nextInt();
/*---------*/
}
}
}
import java.util.Scanner;
public class a{
public static void main(String []args){
int year,m,n,repeat,ri;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri=1;ri<=repeat;ri++){
m=in.nextInt();
n=in.nextInt();
for(year=m;year<=n;year++){
if((year%4==0&&year%100!=0)||year%400==0){
System.out.println(year);
}}
}
}
}
import java.util.Scanner;
public class Test30009{
public static void main(String args[]){
int repeat, ri;
int a,b,c,d;
double x1,x2;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri = 1; ri <= repeat; ri++)
{
a=in.nextInt();b=in.nextInt();c=in.nextInt();
/*---------*/
if(a==0&&b==0&&c==0)
System.out.println("a=b=c=0,meaningless");
else if(a==0&&b==0&&c!=0)
System.out.println("a=b=0,c!=0,error");
else if(a==0)
System.out.println("x="+Math.round(-(float)c/b*100)/100.0);
else //满足一元二次方程a*x*x＋b*x＋c＝0条件
{
d=b*b-4*a*c;
if(d>=0)//前面三种情况排除了就是最后一种情况，所以就不用写出来了！
{ x1=(-b+Math.sqrt(d))/(2*a);
x2=(-b-Math.sqrt(d))/(2*a);
System.out.println("x1="+Math.round(x1*100)/100.0);
System.out.println("x2="+Math.round(x2*100)/100.0);
}
else
{
System.out.println("x1="+Math.round((float)(-b)/(2*a)*100)/100.0+"+"+Math.round(Math.sqrt(-d)/(2*a)*100)/100.0+"i");
System.out.println("x2="+Math.round((float)(-b)/(2*a)*100)/100.0+"-"+Math.round(Math.sqrt(-d)/(2*a)*100)/100.0+"i");
}
}
}
}
}
import java.util.Scanner;
public class Test30010{
public static void main(String args[]){
int repeat, ri;
char ch;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri = 1; ri <= repeat; ri++){
ch=(in.next()).charAt(0); /*输入1个字符*/
/*---------*/
switch(ch)
{
注意。。。这里的A是要加单引号的！！！ case 'A':System.out.println("90-100");break;//
case 'B':System.out.println("80-89");break;
case 'C':System.out.println("70-79");break;
case 'D':System.out.println("60-69");break;
case 'E':System.out.println("0-59");break;
default:System.out.println("Invalid input");
}
}
}
}
评论列表
文章目录
