数据结构（JAVA版）练习题

（题目难易程度与题号顺序无关哦）

1、多关键字排序

2、集合类的综合应用问题

3、数组排序

4、球的相关计算问题

5、利用类对象计算日期

6、日期计算问题

7、星期日期的计算

8、计算坐标平面上两点距离

9、异常处理设计问题

10、Java源文件和字节码文件名称的判断问题

11、函数表达式的计算

12、成绩的学分绩点计算

1、多关键字排序

学生考试成绩的统计利用计算机软件将变得十份简单的事，由于你很勤奋，并且刚学习了面向对象程序设计Java,在Java中提供了面向对象程序设计方法，并提供了大量有用的工具类，解决该问题你将成为能手，我们知道只要利用容器 Collections.sort()方法，很方便解决对象的排序问题，如果一个年级的学生参加了有语文、数学和英语三科目的考试，需要计算出每个学生的总分和平均成绩，并且要按照总分排序，如果总分相同，则依照语文、数学再英语的成绩排序，即排序关键词依次为总分、语文、数学、英语。请你设计一个程序解决该问题。
提示：利用输入数据的每行创建一个Student对象，将所有学生对象存储到一个List<Student> stulist = new ArrayList<Student>();线性表中，再利用Collections.sort(stulist,new MyComptor());就解决排序问题，然后将stulist中的每个学生输出，就完成该排序问题了，但为了能排序，Collections必须知道对象排序规则，要定义一个规则，是通过设计一个比较器完成，比较器的主体如下：

class MyComptor implements Comparator<Object> {

public int compare(Object o1, Object o2) {
Student stu1 =(Student)o1;
Student stu2 =(Student)o2;
if(...){//填写比较规则
return 1;
}else{
return 0;
}
}

}

下面是一个点对象排序的参考实例：
Point point2 = new Point(2,2,2);
Point point1 = new Point(1,1,1);
Point point3 = new Point(3,1,2);

List<Point> points = new ArrayList<Point>();
points.add(point2);
points.add(point1);
points.add(point3);

//根据point中的升序输出
Collections.sort(points, new SortByXdesc());
SortByXdesc对象的定义如下：
public class SortByXdesc implements Comparator<Object> {

//根据point中的x降序输出
@Override
public int compare(Object o1, Object o2) {
Point point1 =(Point)o1;
Point point2 =(Point)o2;
if(point1.getX()>point2.getX()){
return 1;
}else{
return 0;
}
}

}

标准输入：
第一行为一个正整数N，表示该年纪共有的学生数，接下来的N行，每行为一个学生的信息，依次为学号、班级、语文成绩、数学成绩和英语成绩，其中学号为10个字符的字符串，班级和成绩为正整数，他们之间由一个空格隔开。
标准输出：
输出该年级学生的成绩单，即根据总分和语文、数学、英语成绩为次关键词的排序后的成绩单，每行输出一个学生的成绩，使用一个空格隔开，依次输出如下数据：
学号班级语文数学英语总分平均
其中平均成绩四舍五入保留2位小数。

测试用例输入：
4
0806401001 1 56 64 77
0806401002 1 75 68 54
0806401003 1 68 79 76
0806401004 1 56 57 84
测试用例输出：
0806401003 1 68 79 76 223 74.33
0806401002 1 75 68 54 197 65.67
0806401001 1 56 64 77 197 65.67
0806401004 1 56 57 84 197 65.67

本题代码答案：

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
 
class AppForScoreSort {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
 
        int n=sc.nextInt();
        Student[] stu=new Student[n+1];
 
        for(int i=1;i<=n;i++){
            String id=sc.next();
            int cs=sc.nextInt();
            int x1=sc.nextInt();
            int x2=sc.nextInt();
            int x3=sc.nextInt();
            int total=x1+x2+x3;
            double average=(double)total/3;
            //实例化学生对象
            stu[i]=new Student(id,cs,x1,x2,x3,total,average);
        }
 
        Comparator<Student> cmp=new MyComparator();
 
        Arrays.sort(stu,1,1+n,cmp);
        for(int i=1;i<=n;i++){
            System.out.println(stu[i].toString());
        }
 
    }
}
 
class Student{
    //学号
    String id;
    //cs为所在班级
    int cs;
    //x1,x2,x3分别对应了语，数，英
    int x1,x2,x3;
 
    //总分
    int total;
    //平均分
    double average;
    
    //创建有参构造器
    public Student(String id, int cs, int x1, int x2, int x3, int total, double average) {
        this.id = id;
        this.cs = cs;
        this.x1 = x1;
        this.x2 = x2;
        this.x3 = x3;
        this.total = total;
        this.average = average;
    }
 
    //每个学生的输出语句
    @Override
    public String toString() {
        return id+" "+cs+" "+x1+" "+x2+" "+x3+" "+total+" "+String.format("%.2f",average);
    }
}
 
//自定义比较方法
class MyComparator implements Comparator<Student>{
 
    @Override
    public int compare(Student a, Student b) {
        if(b.total>a.total)return 1;
        else if(b.total<a.total)return -1;
        else if(b.x1>a.x1)return 1;
        else if(b.x1<a.x1)return -1;
        else if(b.x2>a.x2)return 1;
        else if(b.x2<a.x2)return -1;
        else if(b.x3>a.x3)return 1;
        else if(b.x3<a.x3)return -1;
        return 0;
    }
}

2、集合类的综合应用问题

问题描述：
在实际项目开发中需要存储各种类型的对象数据，一般使用数组存储存在存储个数不确定问题，通常使用集合类型来存储。给你的问题是，在学生信息系统中一个院系有班级信息和学生信息，一个班级有多个学生，每个学生属于一个班，在信息查询中往往需要进行某学生在那个班，该同学有那些同班同学等相关查询，如果使用集合合理存储了班级和学生对象，进行相关查询将变得容易。

本问题使用标准输入班级信息和学生信息，然后查出给定某同学的班级，以及该班同学人数和学号最前、最后的学生学号。
输入：
标准输入，输入的第一行为两个正整数N、M,N表示接下来的N行为班级信息，每行由班级编号、班级名称、入学年级，数据之间为一个逗号","分格；班级信息后M行为学生信息，学生信息的每行依次为学号、所在班级编号、姓名、性别、入学年构成，数据之间为一个逗号","分格。学生数据之后的所有行为学生学号数据，需要你完成查找的学生，每个学生查找信息使用一行输出。
输出：
标准输出，根据需要你查找的学生的学号使用一行输出该学生所在的班级编号和该班学生个数，并输出该班学号排序的第一个和最后一个学生的学号，中间使用一个空格隔开。如果该班只有一个学生，输出第一个学生学号，如果该该学号没有学生，输出”NO Student“。
输入样列：
5 11
2006405,5,2020
2006408,8,2020
2106402,2,2021
2106405,5,2021
2106406,6,2021
2000130841,2006408,杨凯,男,2020
2000130842,2006408,杨石磊,男,2020
2000130849,2006408,刘坤艳,男,2020
2000130501,2006405,文吉鑫,男,2020
2000130502,2006405,方大卫,男,2020
2000130503,2006405,伍一帆,男,2020
2000130504,2006405,赵天祺,男,2020
2000130505,2006405,易佳豪,男,2020
2000130506,2006405,欧阳哲浩,男,2020
2000130510,2006405,陈吉涛,男,2020
2000130511,2006405,曹毅凡,男,2020
2000130506
2000130508
2000130842

输出样列：
2006405 8 2000130501 2000130511
NO Student
2006408 3 2000130841 2000130849

本题代码答案：

import java.util.*;

public class AppForset {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        Map<String,Classes> claMap=new HashMap<String,Classes>();
        Map<String,Student>stuMap=new HashMap<String,Student>();
        int N,M;
        N=in.nextInt();
        M=in.nextInt();
        in.nextLine();
        for (int i=0;i<N;i++){
            String claline=in.nextLine();
            String[] datas=claline.split(",");
            Classes cla=new Classes(datas[0],datas[1],Integer.parseInt(datas[2]));
            claMap.put(datas[0],cla);
        }
        for(int i=0;i<M;i++){
            String stuline=in.nextLine();
            String[] datas=stuline.split(",");
            Classes cla=claMap.get(datas[1]);
            Student stu=new Student(datas[0],datas[2],datas[3],Integer.parseInt(datas[4]),cla);
            cla.stuSet.add(stu);
            stuMap.put(stu.stuid,stu);
        }
        while (in.hasNextLine()){
            String stuid=in.nextLine();
            Student stu=stuMap.get(stuid);
            if(stu==null)System.out.println("NO Student");
            else{
                Classes cla=stu.classes;
                Student[] stus=(Student[]) cla.stuSet.toArray(new Student[cla.stuSet.size()]);
                if(stus.length==1){
                    System.out.println(cla.classId+" "+stus.length+" "+stu.stuid);
                }else{
                    Arrays.sort(stus);
                    System.out.println(cla.classId+" "+stus.length+" "+stus[0].stuid+" "+stus[stus.length-1].stuid);
                }
            }
        }

    }
}
class Classes{
    String classId;
    String classname;
    int grade;
    Set<Student> stuSet=null;
    public  Classes(String classId,String Classname,int grade){
        this.classId=classId;
        this.classname=classname;
        this.grade=grade;
        stuSet=new HashSet<Student>();
    }
}
class Student implements Comparable{
    String stuid;
    String name;
    String sex;
    int grade;
    Classes classes;
    public  Student(String stuid,String name,String sex,int grade,Classes classes){
        this.stuid=stuid;
        this.name=name;
        this.sex=sex;
        this.grade=grade;
        this.classes=classes;
    }

    @Override
    public int compareTo(Object o) {
        Student stu=(Student)o;
        return this.stuid.compareTo(stu.stuid);
    }
}

3、数组排序

描述
给定一组n个正整数，根据各位数字之和从小到大进行排序。
输入
输入数据有多组，每组数据占一行，每行的第一个数正整数n，表示整数个数，后面接n个正整数。当n为0时，不作任何处理，输入结束。
输出
输出每组要求下原始数据排序的结果。
样例输入
2 1 2
3 121 10 111
0
样例输出
1 2
10 111 121

本题代码答案：

import java.util.Scanner;
public class ArraySort {
    public static void main(String[] args) {
        Scanner read=new Scanner(System.in);
        while(true)
        {
            int n;
            n=read.nextInt();
            if(n==0)break;
            int[] a;
            int[] b;
            a=new int[n];
            b=new int[n];
            for(int i=0;i<n;i++)
            {
                a[i]=read.nextInt();
                int x,sum=0;
                x=a[i];
                while(x!=0)
                {
                    sum+=x%10;
                    x/=10;
                }
                b[i]=sum;
            }
            for(int i=0;i<n;i++)
            {
                for(int j=i+1;j<n;j++)
                {
                    if(b[i]>b[j])
                    {
                        b[i]=b[i]^b[j];
                        b[j]=b[i]^b[j];
                        b[i]=b[i]^b[j];
                        a[i]=a[i]^a[j];
                        a[j]=a[i]^a[j];
                        a[i]=a[i]^a[j];
                    }
                }
            }
            for(int i=0;i<n;i++) System.out.print(a[i]+" ");
            System.out.println();
        }
    }
}

4、球的相关计算问题

球的相关计算涉及到球的体积和球的表面积以及过直径的截面积等，我们知道，以上计算仅需要知道球的半径就可以利用计算公式计算出来，计算中用到的圆周率使用3.14进行计算。
输入：
标准输入一个浮点数r(r>0)，代表需要计算的球的半径.
输出：
标准输出，根据输入的球半径r,依次输出球表面积、圆球体积和直径的侧面积大小，数据间由一个空格隔开，结果保留2位有效数字。
测试用例输入：
3
测试用例输出：
113.04 113.04 28.26

本题代码答案：

import java.util.Scanner;
public class Ball {
    public static void main(String args[]) {
        double pi=3.14;
        Scanner in = new Scanner(System.in);
        double r = in.nextDouble();
        double s = 4*pi * r * r;
        double v = 4/3.0*pi*r*r*r;
        double sc = pi * r * r;
        System.out.printf("%.2f ",s);
        System.out.printf("%.2f ",v);
        System.out.printf("%.2f",sc);
    }
}

5、利用类对象计算日期

在利用Java语言进行信息系统开发中，经常需要对日期进行计算和转换，比如，设置了某活动的开始日期和结束日期，系统需要判断当前是否是该活动时间，在Java开发的信息系统中，通常日期以字符串形式“yyyy-MM-dd hh:mm:ss”保存到数据库中，在进行转换中，通常需要将字符串表示的日期转换为Date对象，Java API提供了一个工具SimpleDateFormat对象能将一个满足“yyyy-MM-dd hh:mm:ss”形式的字符串转换成一个Date对象。在日期转换中，经常也利用到时间戳，什么是时间戳(timestamp)？时间戳(timestamp)是一种时间表示方式，定义为从格林威治时间1970年01月01日00时00分00秒起至现在的总秒数。通过日期对象的getTime()将获得该日期的当前时间戳的毫米数。
给你的问题是，如何给出某活动的开始日期和结束日期，已经当前日期的时间戳，需要你编程判定当前日期所处的位置.
样例输入：
输入的第一行为已个正整数N,表示需要你计算活动次数，接下来的N行，每行的第一个数为一个10位正整数，表示当前日期的时间戳秒数，接下来是两个字符串，表示活动开始日期和结束日期。字符串满足日期“yyyy-MM-dd hh:mm:ss”格式。
样例输出：
如果当前日期在活动开始之前，就输出“Before",如果在活动之中输出"NOW", 如果在活动之后，输出"After".
测试输入数据：
2
1389339888 "2013-10-11 12:12:12" "2013-10-12 12:12:12"
1389339888 "2014-01-09 12:12:12" "2014-01-12 12:12:12"
测试输出数据：
After
NOW

本题代码答案：

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class DataQuestion {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        for(int i=0;i<n;i++){
            long now=in.nextLong();
            String str = in.nextLine();
            MyDate mydate=new MyDate(now,str);
            System.out.println(mydate.getResult());
        }
    }
}
class MyDate{
    long now;//秒
    Date begindate,enddate;
    public MyDate(long now,String str) {
        this.now = now;
        //"2013-10-11 12:12:12" "2013-10-12 12:12:12"
        str=str.trim();
        String strd1=str.substring(1,20);
        String strd2=str.substring(23,str.length()-1);
        try {
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            begindate  = df.parse(strd1);
            enddate  = df.parse(strd2);
        } catch(Exception ex) {
            ex.printStackTrace();
        }
        //System.out.println(strd1+":"+strd2);
    }
    public String getResult(){
        if(now <begindate.getTime()/1000)
            return "Before";
        else if(now >enddate.getTime()/1000)
            return "After";
        else return "NOW";
    }
}

6、日期计算问题

在信息系统开发中，日期的计算成为常态，利用Java程序设计解决日期相关问题变得简单，给你的问题是计算两个日期（非时间上）相隔的天数。
输入：
标准输入，输入的第一行为一个正整数N，表示需要你计算的问题数目，接下来的N行，每行有两个表示日期和时间格式的数据，两数据之间有一个空格,并且前一个日期在后一个日期的前面。
输出：
标准输出,输出两日期（非时间）之间相处的天数，每个计算结果使用一行输出，并按照输入顺序依次输出该问题的结果。
测试用例输入：
4
2021-05-31 00:00 2021-06-01 00:01
2017-01-10 08:00 2017-01-10 09:00
2014-01-05 08:30 2014-01-14 08:00
2014-03-05 16:35 2014-07-03 08:00

测试用例输出：
1
0
9
120

本题代码答案：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
public class DateCalculation {
    public static void main(String[] args) throws ParseException {
        Scanner sc=new Scanner(System.in);
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
        int n=sc.nextInt();
        while (n-- > 0) {
            String s1=sc.next()+" "+sc.next();
            String s2=sc.next()+" "+sc.next();
            Date date1=sdf.parse(s1);
            Date date2=sdf.parse(s2);
            long dd=(long)(date2.getTime()-date1.getTime())/24/60/60/1000;
            System.out.println(dd);
        }
    }
}

7、星期日期的计算

问题描述：

在平时日常生活中通常需要回答当月的某日期为星期几的问题，常常通过提供你当月某天是星期几，然后需要计算当月的某日期为星期几。提供当月日期和星期的数（用阿拉伯数表示，0为Sunday，1为Monday，2为Tuesday，3为Wednesday，4为Thursday，5为Friday，6为Saturday），然后提供一个当月的日期号数，请计算该日期号数为星期几，使用英文单词输出星期几。

输入：

标准输入，输入的第一行为计算用例数为整数n，接下来的n行，每行有3个由空格分开整数，其中第一个整数为当月的日期数,第二个整数为第一个整数表示的日期的星期几，第三个整数是需要你回答当月该日期是星期几，如该行输入为：1 3 10，表示当月的1号为星期三，请问当月的10号为星期几。

输出：

标准输出：每一个计算的结果使用一行输出，输出使用英文单词输出星期几。

输入样例：

2
1 3 10
10 0 5

输出样例：

Friday
Tuesday

本题代码答案：

import java.util.Scanner;

public class DateWeek {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] week = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
        int n = sc.nextInt();
        while (n-- > 0) {
            int d1 = sc.nextInt();
            int w1 = sc.nextInt();
            int d2 = sc.nextInt();
            int w2 = (d2 - d1 + w1) % 7;
            w2 = w2 < 0? w2 + 7:w2;
            System.out.println(week[w2]);
        }
    }
}

8、计算坐标平面上两点距离

题目描述
在平面直角坐标系中求两点的距离。
输入
输入有若干行，每行四个数，分别代表两个坐标点（a，b）和（c，d），当每行四个数为0时，结束输入，本用例不用计算。
输出
对应输出这两点之间的距离。结果保留两位小数。请注意行尾输出换行。
样例输入
0 0 4 3
1.1 -2.3 0 1
0 0 0 0
样例输出
5.00
3.48

本题代码答案：

import java.util.Scanner;
import java.lang.Math;

public class DistQuestion {
    private static double a, b, c, d;
    //这种方法Scanner也要放外面并设置成static
    static Scanner sc = new Scanner(System.in);
    public static void main(String[] args) {
        while ( sin() ) {
            double s = Math.sqrt((a-c)*(a-c) + (b-d)*(b-d));
            System.out.printf("%.2f%n", s);
        }
    }
    private static boolean sin() {
        a = sc.nextDouble();
        b = sc.nextDouble();
        c = sc.nextDouble();
        d = sc.nextDouble();
        return a != 0 || b != 0 || c != 0 || d != 0;
    }
}

9、异常处理设计问题

我们能够通过海伦公式计算已知一个三角形三边长度的三角形面积，如果三角形的三边长为a,b,c,三角形的面积计算公式描述如下：

要求你完成MyMath对象中的trianglearea法的实现，如果参数a,b,c的值不能构成一个三角形，使用异常进行处理，产生无效三角形异常，如果a,b,c中有负数，产生参数无效异常，根据题目要求请你完成异常类型和MyMath类型的设计。MyMath设计代码如下：

import java.util.*;
public class MyMath
{
public static double trianglearea(double a,double b,double c)
throws NotTriAngleException,NegativeArgementsException{
//判定a,b,c是否全为正数

//判定a,b,c是否能构成三角形

//计算三角形面积
double s;
}
public static void main(String[] args)
{
double a,b,c;
int N;
Scanner sc= new Scanner(System.in);
N = sc.nextInt();
for(int i=0;i<N;i++){
a=sc.nextDouble();
b=sc.nextDouble();
c=sc.nextDouble();
System.out.printf("%.2f\n",MyMath.trianglearea(a,b,c));
}
}
}

class NotTriAngleException extends Exception
{ }

class NegativeArgementsException extends Exception
{ }

输入：
输入的第一行为一个正整数N(N>0)，表示以下有N行数据，每行为一个三角形边的输入信息，原则上是由空格隔开的三个浮点数，但也可能由于输入错误产生非正常情况。
输出：
如果某行三角形边数据能读入三个浮点数，输出方法trianglearea计算结果，保留2位小数，如果发生异常直接输出异常信息；每个三角形计算信息使用一行输出；如果某行三角形边数据读入出现问题，直接退出程序的运行。
测试1输入：
3
3 4 5.0
1 1 2
-2 4.0 3
测试1输出：
6.00
Not TriAngle
Negative Argements
测试2输入：
3
3 4 5.0
1a 1 2
-2 4.0 3

测试2输出：
6.00

本题代码答案：

import java.util.*;
public class Ex_Handing {
    public static double trianglearea(double a, double b, double c) throws NotTriAngleException, NegativeArgementsException {
    // 判定a,b,c是否全为 正数
    if (a < 0 || b < 0 || c < 0)
    { throw new NegativeArgementsException("Negative Argements"); }
    //判定a,b,c是否能构成三角形
    if (a + b <= c || a + c <= b || c + b <= a)
    { throw new NotTriAngleException("Not TriAngle"); }
    // 计算三角形面积
    double p = (a + b + c) / 2.0;
    double s = Math.sqrt(p*(p -a)*(p -b)*(p -c));
    return s; }

    public static void main(String[] args)
    { double a = 0, b = 0, c = 0;
        int N;
        Scanner sc = new Scanner(System.in);
        N = sc.nextInt();
        for (int i = 0; i < N; i++)
        { try
        { a = sc.nextDouble(); b = sc.nextDouble(); c = sc.nextDouble();
            System.out.printf("%.2f\n", Ex_Handing.trianglearea(a, b, c)); }
        catch (NegativeArgementsException e)
        { System.out.println(e.getMessage()); }
        catch (NotTriAngleException e)
        { System.out.println (e.getMessage()); }
        catch (Exception e) { }
        }
    }
}
class NotTriAngleException extends Exception
{
    NotTriAngleException(String message) { super(message); } }
class NegativeArgementsException extends Exception
{

    NegativeArgementsException(String message) { super(message); }
}

10、Java源文件和字节码文件名称的判断问题

Java源文件名必须满足以“.java”为后缀名，他编译的字节码文件以“.class”为后缀名，文件的命名（Java类型命名）必须满足标识符规则，即文件名必须由英文大小写字母、数字、下划线和美元符组成，并且第一个字母不能为数字字符。
给你的问题是请你编写程序判断提供的字符串是Java源文件还是字节码文件。
输入：
标准输入，标准输入多行，每行字符串为提供的一个文件名称。
输出：
标准输出，根据输入一行的字符串进行判断，如果是合法的源文件，使用一行输出“Java Source File",如果是合法的字节码文件，使用一行输出”Java Byte File"，如果文件既不是源文件，也不是字节码文件，使用一行输出“Not Java File"。
输入样列：
Test.java
Test1.class
3Demo.class

输出样列：
Java Source File
Java Byte File
Not Java File

本题代码答案：

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class File {
    public static void main(String[] args) {
        String s = null;
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) {
            s = in.nextLine();
            FileTool1 ss = new FileTool1(s);
            ss.getSource();
        }
    }
}
class FileTool1 {
    String s;
    public FileTool1(String s) { this.s = s;}
    public  void getSource () {
        int  n = s.indexOf(".");
        Pattern name  = Pattern.compile("^[a-zA-Z_$]+[a-zA-Z\\d_$]+$");
        String file = s.substring(0,n);
        Matcher f = name.matcher(file.trim());
        if (f.matches() && s.endsWith(".java"))
            System.out.println("Java Source File");
        else if (f.matches() && s.endsWith(".class"))
            System.out.println("Java Byte File");
        else
            System.out.println("Not Java File");
    }
}

11、函数表达式的计算

请你设计一个程序，根据输入的x值计算出函数值y,函数表达式为：
| x，x<1
y=| 2x-1, 1<=x<10
|3x-11, x>=10

输入数据的x值使用标准输入，x的输入占一行，你的计算结果也使用一行输出，输出结果保留6位小数。
输入测试用例：
12.54
用例输出结果：
26.620000

本题代码答案：

import java.util.Scanner;
public class FunctionExpression{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        double y,x=in.nextDouble();
        if(x<1) y=x;
        else if(x<10) y=2*x-1;
        else y=3*x-11;
        System.out.printf("%.6f",y);
    }
}

12、成绩的学分绩点计算

题目描述
某校学生评比采用绩点制，规则是：90分以上（含90分，下同）算5点，80分以上算4点，70分以上算3点，60分以上算2点，不及格算0点，请根据某个学生的成绩及学分计算该生该门课程所获得的绩点。
输入
标准输入，输入的第一行为需要计算用例个数N，接下来的N行，每行有两个浮点数，第一个数为某课程的考试成绩，第二个数为该课程的学分值。
输出
标准输出，每一行输出一个学生的某课程计算得到的绩点数(结果保留一位小数)，请注意行尾输出换行。
样例输入
3
85 1.5
90 3
50 4
样例输出
6.0
15.0
0.0

本题代码答案：

 import java.util.Scanner;

public class GradePoint{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        while ( n-- > 0 ) {
            double score = sc.nextDouble();
            double weight = sc.nextDouble();
            double point = 0.0;
            if ( score >= 90.0 ) point = 5.0;
            else if ( score >= 80.0 ) point = 4.0;
            else if ( score >= 70.0 ) point = 3.0;
            else if ( score >= 60.0 ) point = 2.0;
            System.out.printf("%.1f\n", weight * point);
        }
    }
}