Java期末复习题目合集

7-1 一个整数各个位上的最大数字

编写一个类的方法，其输入参数为一个整数，输出为该整数各个位上的最大数字。

输入格式:
输入一个整数N

输出格式:
输出该整数N各个位上的最大数字

输入样例:
在这里给出一组输入。例如：

59274

输出样例:
在这里给出相应的输出。例如：

9

答案：

import java.util.*;

public class Main{
    public static void main(String []args){
        Scanner s = new Scanner(System.in);
        int N = s.nextInt();
        int max =  0,a = 0;
        while(N!=0) {
        	a = N % 10;
        	N /= 10;
        	if(a>max) max = a;
        }
        System.out.println(max);
    }
}

7-2 十进制转二进制

编写代码，要求：输入参数是一个正整数，输出该整数所对应的二进制数对应的字符串。

输入格式:
正整数

输出格式:
输入的正整数对应的二进制字符串“1001”

输入样例:
在这里给出一组输入。例如：

9

输出样例:
在这里给出相应的输出。例如：

1001

答案：

7-3 判断回文

编码实现：输入一个字符串，判断该字符串是否是回文（回文是指将该字符串含有的字符逆序排列后得到的字符串和原字符串相同的字符串）如果是回文，则输出“Yes”；否则输出“No”。

输入格式:
判定是否是回文的字符串

输出格式:
“Yes”或者“No”

输入样例:
在这里给出一组输入。例如：

TooooT

输出样例:
在这里给出相应的输出。例如：

Yes

答案：

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		String str = s.nextLine();
		String revers = "";
		for (int i = str.length()-1; i >= 0; i--) {
			revers += str.charAt(i);
		}
		if (str.equals(revers)) {
			System.out.println("Yes");
		} else
			System.out.println("No");
	}
}

7-4 学投资

小白学习了一些复利投资知识，想比较一下复利能多赚多少钱（所谓复利投资，是指每年投资的本金是上一年的本金加收益。而非复利投资是指每年投资金额不包含上一年的收益，即固定投资额）。假设他每年固定投资M元（整数），每年的年收益达到P（0<P<1，double)，那么经过N（整数）年后，复利投资比非复利投资多收入多赚多少钱呢？计算过程使用双精度浮点数，最后结果四舍五入输出整数（Math的round函数）。

输入格式:
M P N

输出格式:
复利收入（含本金），非复利收入（含本金），复利比非复利收入多的部分（全部取整，四舍五入）

输入样例:

10000 0.2 3

输出样例:

17280 16000 1280

答案：

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		int m = s.nextInt();
		double p = s.nextDouble();
		int n = s.nextInt();
		long a = Math.round(m * Math.pow(1 + p, n));
		long b = Math.round(m + m * p * n);
		System.out.print(a + " ");
		System.out.print(b + " ");
		System.out.println(a - b);
	}
}

7-5 打印所有的水仙花数

编写程序打印出所有的水仙花数。所谓"水仙花数"是指一个三位数，其各位数字立方和等于该本身。例如：153是一个水仙花数，因为153=1³⁺⁵3+3^3。 输出的数之间用“,”（英文半角的逗号）分割。

输入格式:
无

输出格式:

153,370,371,407

输入样例:
在这里给出一组输入。例如：

输出样例:
在这里给出相应的输出。例如：

153,370,371,407

答案：

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		int flag = 0;
		for (int n = 100; n < 999; n++) {
			int a = n % 10, b = (n / 10) % 10, c = (n / 100) % 10;
			if (Math.pow(a, 3) + Math.pow(b, 3) + Math.pow(c, 3) == n) {
				if (flag == 0) {
					System.out.print(n);
					flag = 1;
				} 
				else
					System.out.print("," + n);
			}
		}
	}
}

​7-6 逆序输出整数

编写程序将整数逆序输出。如输入为9876输出为6789
Main函数中读入n个整数，输出n个整数的逆序数

输入格式:
整数个数n
n个整数

输出格式:
n个整数的逆序数

输入样例:
在这里给出一组输入。例如：

3
1234
2323
1112

输出样例:
在这里给出相应的输出。例如：

4321
3232
2111

答案：

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();
		for(int i = 0;i<n;i++) {
			String s1 = s.next();
			StringBuilder s2 = new StringBuilder(s1);
			System.out.println(s2.reverse());
		}	
	}
}

7-7 1！+2！+……+N！

给定一个整数N，编写程序求1！+2！+……+N！（0<N<100）

输入格式:
输入一个整数N

输出格式:
输出1！+2！+……+N！

输入样例:
在这里给出一组输入。例如：

6

输出样例:
在这里给出相应的输出。例如：

873

答案：

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();
		int result = 0;
		while(n!=0) {
			result += JC(n);
			n--;
		}
		System.out.println(result);
	}

	public static int JC(int n) {
		if (n == 0)
			return 1;
		else
			return n * JC(n - 1);
	}
}

7-8 完数

一个数如果恰好等于它的因子之和，这个数就称为"完数"。 例如，6的因子为1、2、3，而6=1+2+3，因此6是"完数"。 编程序找出N之内的所有完数。

输入格式:
整数N

输出格式:
N之内的所有完数，每个完数之间用逗号（英文半角）分隔开。注意：1不作为完数

输入样例:
在这里给出一组输入。例如：

30

输出样例:
在这里给出相应的输出。例如：

6,28

答案：

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();
		int flag = 0;
		for (int i = 1; i < n; i++) {
			if (Wanshu(i)) {
				if (flag == 0) {
					System.out.print(i);
					flag = 1;
				} else
					System.out.print("," + i);
			}
		}
	}

	public static boolean Wanshu(int a) {
		int r = 0;
		if (a == 0)
			return false;
		for (int i = 1; i < a; i++) {
			if (a % i == 0) {
				r += i;
			}
		}
		if (r == a)
			return true;
		else
			return false;
	}
}

7-9 n个a数字求和

求Sn=a+aa+aaa+…+aa…aaa（有n个a）之值，其中a是一个数字(1<=a<=9)。例如：2+22+222+2222+22222（a=2,n=5），a和n由键盘输入。

输入格式:
a,n（说明：a是出现在各个数字每一位的数字，n是最大数的位数）

输出格式:
Sn=a+aa+aaa+…+aa…aaa的值

输入样例:
在这里给出一组输入。例如：

2 3

输出样例:
在这里给出相应的输出。例如：

246

答案：

import java.util.*;
public class Main {
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		int a = s.nextInt();
		int n = s.nextInt();
		int r = 0, sum = 0;
		for (int i = 0; i < n; i++) {
			sum = sum * 10 + a;
			// System.out.println(sum);
			r += sum;
		}
		System.out.println(r);
	}
}

7-10 数字统计

输入一个长整型的数，统计其中0、1、2、3、4、5、6、7、8、9各个数字的个数，并将结果合成一个整数。（前面的0不输出）

输入格式:
长整型数

输出格式:
合成后的整数

输入样例:
在这里给出一组输入。例如：

234353632

输出样例:
在这里给出相应的输出。例如：

24111000

答案：

import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		Scanner s= new Scanner(System.in);
        String a = s.next();
        int[] b = new int[10];
        for(int i = 0; i < 10; i++)
            b[i] = 0;
        for(int i = 0; i < a.length(); i++)
        {
            int n = a.charAt(i) - '0';
            b[n]++;
        }
        int k=0;
        for(int i=0;i<10;i++) {
        	if(b[i]!=0)k=1;
        	if(k==1)System.out.print(b[i]);
        }
        
	}
}

7-11 尼科彻斯定理

验证尼科彻斯定理，即：任何一个正整数 N 的立方都可以写成 N 个连续奇数之和。(首个奇数是：N*N-N+1)

输入格式:
任一正整数N。

输出格式:
该数的立方分解为一串连续奇数的和。

输入样例:

13

输出样例:

13*13*13=2197=157+159+161+163+165+167+169+171+173+175+177+179+181

答案：

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();
		System.out.print(n + "*" + n + "*" + n + "=" + n * n * n + "=");
		int a = n * n - n + 1;
		System.out.print(a);
		for (int i = 1; i < n; i++) {
			a += 2;
			System.out.print("+" + a);
		}
	}
}

7-12 复数类的定义

编写一个复数类，可以进行复数加法和减法运算。编写一个包含main方法的类测试该复数类。要求该复数类至少包含一个无参的构造方法和一个带参的构造方法；数据成员包括复数的实部和虚部，为double类型；包括两个方法，分别实现复数的加法和减法运算。测试代码如下：

    public static void main(String [] args){
            Complex a=new Complex();
            Complex b=new Complex();
            Scanner in=new Scanner(System.in);
            a.setRealPart(in.nextDouble());
            a.setImaginaryPart(in.nextDouble());
            b.setRealPart(in.nextDouble());
            b.setImaginaryPart(in.nextDouble());
            System.out.println(a);
            System.out.println(b);
            System.out.println(a.add(b));
            System.out.println(a.sub(b));      
}

输入格式:
输入两个复数。输入为两行，每一行为一个复数的实部和虚部，用空格隔开。

输出格式:
输出复数加法和减法结果。输出为4行，第一行和第二行输出两个复数，第三行为两个复数的加法运算结果，第四行为减法运算结果。

输入样例:
在这里给出两组输入。例如：

1 2
3 4
-1 2
1 2

输出样例:
在这里给出相应的输出。例如：

1.0+2.0i
3.0+4.0i
4.0+6.0i
-2.0-2.0i
-1.0+2.0i
1.0+2.0i
4.0i
-2.0

答案：

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Complex a = new Complex();
		Complex b = new Complex();
		Scanner in = new Scanner(System.in);
		a.setRealPart(in.nextDouble());
		a.setImaginaryPart(in.nextDouble());
		b.setRealPart(in.nextDouble());
		b.setImaginaryPart(in.nextDouble());
		System.out.println(a);
		System.out.println(b);
		System.out.println(a.add(b));
		System.out.println(a.sub(b));
	}
}

class Complex {

	double real;
	double image;

	public Complex() {

	}

	public Complex(double r, double i) {
		this.real = r;
		this.image = i;
	}

	public void setRealPart(double r) {
		this.real = r;
	}

	public void setImaginaryPart(double i) {
		this.image = i;
	}

	public Complex sub(Complex b) {
		Complex c = new Complex();
		c.real = this.real - b.real;
		c.image = this.image - b.image;
		return c;
	}

	public Complex add(Complex b) {
		Complex c = new Complex();
		c.real = this.real + b.real;
		c.image = this.image + b.image;
		return c;
	}

	public String toString() {
		if (real == 0)
			return image + "i";
		if (image == 0)
			return real + "";
		if (image > 0)
			return real + "+" + image + "i";
		return real + "" + image + "i";
	}

}

7-13 MyDate类

构造日期类MyDate类，包含年月日，提供相应的get和set函数，提供void print()函数打印日期，提供int compare(MyDate d)测试当前对象和参数对象d的早晚，如果早则返回-1，晚则返回1，相等则返回0
在main函数中，读入两个日期对象，输出第一个日期对象的信息，输出两个对象的比较结果

输入格式:
两个日期对象，第一个为当前日期对象的年月日，第二个为待比较日期对象的年月日

输出格式:
当前日期对象的信息，当前对象和待比较日期对象的比较结果

输入样例:
在这里给出一组输入。例如：

2008 6 12 2009 6 22

输出样例:
在这里给出相应的输出。例如：

6/12/2008 -1

答案：

import java.util.Scanner;

public class Main {
	public static void main(String[] argc)
	{
		Scanner scan = new Scanner(System.in);
		int Year = scan.nextInt();
		int Month = scan.nextInt();
		int Day = scan.nextInt();
		int AnotherYear = scan.nextInt();
		int AnotherMonth = scan.nextInt();
		int AnotherDay = scan.nextInt();
		scan.close();
		MyDate firstDay = new MyDate(Year, Month, Day);
		MyDate secondDay = new MyDate(AnotherYear, AnotherMonth, AnotherDay);
		firstDay.print();
		System.out.print(firstDay.compare(secondDay));
	}
}
class MyDate {
	private int year;
	private int month;
	private int day;
	public MyDate(int year, int month, int day)
	{
		this.year = year;
		this.month = month;
		this.day = day;
	}
	public void setYear(int y)
	{
		year = y;
	}
	public void setMonth(int m)
	{
		month = m;
	}
	public void setDay(int d)
	{
		day = d;
	}
	public int getYear()
	{
		return year;
	}
	public int getMonth()
	{
		return month;
	}
	public int getDay()
	{
		return day;
	}
	public void print()
	{
		System.out.print(month + "/" + day + "/" + year + " ");
	}
	public int compare(MyDate d)
	{
		if (d.year > this.year)
		{
			return -1;
		}
		else if (d.year == this.year)
		{
			if (d.month > this.month)
			{
				return -1;
			}
			else if (d.month == this.month)
			{
				if (d.day > this.day)
				{
					return -1;
				}
				else if (d.day == this.day)
				{
					return 0;
				}
			}
		}
		return 1;
	}
}

7-14 Person类-静态变量

在Person类的基础上，添加一个静态变量avgAge表示所有Person对象的平均年龄（整数），提供方法getAvgAge能够读取该静态变量。
main函数中，构造三个Person类的对象，读入他们的信息，并输出他们的平均年龄

输入格式:
多个用户信息

输出格式:
平均年龄

输入样例:
在这里给出一组输入。例如：

a male 23
b female 21
c male 22

输出样例:
在这里给出相应的输出。例如：

22

答案：

import java.util.*;
 
public class Main{
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in); 
        Person p = new Person();
        for(int i = 0;i<3;i++)
        {
        String name = scan.next();      
        String sex = scan.next();      
        int age = scan.nextInt();
        p = new Person(name,sex,age);
        }
        System.out.println(p.getAvgAge());
   }
}
 
class Person {
    private String name;
    private String sex;
    private int age;
    static int avgAge = 0;
    public Person()
    {
        name = null;
        sex = null;
        age = 0;
    }
    public Person(String n, String s,int a)
    {
        name = n;
        sex = s;
        age = a;
        avgAge += age;
    }
    public int getAvgAge()
    {
        return avgAge/3;
    }
    public void setName(String n)
    {
        name = n;
    }
    public void setSex(String s)
    {
        sex = s;
    }
    public void setAge(int a)
    {
        age = a;
    }
}

7-15 卡片邻居游戏

有个游戏叫卡片邻居游戏，它使用多张正方形的卡片，每张卡片在上下左右四边上有数字，可以顺时针旋转，如下图所示。

卡片在游戏板上被放成一排，相邻两张卡片的邻边应当具有相同的数字，不断有新的卡片需要放置到游戏板上，放置的位置应当满足相临边数字相同的要求（亦可放在头部和尾部）。下图展示了游戏板上的一组卡片排列和新增一张卡片后的游戏板

完成类NumberCard，包含构造函数和方法 rotate 和 getLeft，getRight，分别表示顺时针旋转卡片，返回左侧数字，返回右侧数字

完成类CardGame表示游戏版，包含方法int getIndexForFit(NameCard)，boolean insertCard(NameCard)，print()
其中getIndexForFit返回通过若干旋转能将卡片插入到游戏板中的最靠前的位置，头部位置为0. insertCard将卡片通过最少的旋转插入到游戏板，按旋转完成的方向插入getIndexForFit返回的位置，返回插入成功与否。print函数按顺序输出每个卡片，每个卡片按照上右下左的顺序输出各个边上的数字。（注：应当选择适当的结构存储游戏板中的卡片）

输入格式:
插入新的卡片的个数
每个新插入的新卡片，按上右下左顺序

输出格式:
依次输出游戏板上各个卡片，按上右下左的顺序

输入样例:
在这里给出一组输入。例如：

3
1 2 3 4
6 4 3 3
4 3 7 4

输出样例:
在这里给出相应的输出。例如：

4 3 7 4 6 4 3 3 1 2 3 4

答案：

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n=input.nextInt();
        int[] a=new int[4];
        CardGame cardgame=new CardGame();
        cardgame.card[0].nextmark=1;
        for(int i=0;i<n;i++){
            for(int j=0;j<4;j++){
                a[j]=input.nextInt();
            }
            NumberCard c=new NumberCard(a);
            c.mark=NumberCard.num++;
            cardgame.insertCard(c);
        }
        cardgame.print();
    }
}

class NumberCard {
    public int[] number;
    public int mark;
    public int nextmark;
    public int left, right;
    public static int num = 2;

    public NumberCard(int[] a) {
        number = new int[4];
        for (int i = 0; i < 4; i++) {
            number[i] = a[i];
        }
        left = 0;
        right = 0;
        mark = 0;
        nextmark = 0;
    }

    public NumberCard() {
        number=new int[4];
        left = 0;
        right = 0;
        mark = 0;
        nextmark = 0;
    }

    public int getLeft() {
        return number[3];
    }

    public int getRight() {
        return number[1];
    }

    public void rotate() {
        for (int i = 0; i < 4; i++) {
            number[i] = number[(i - 1 + 4) % 4];
        }
    }
}

class CardGame {
    public NumberCard[] card;
    public CardGame() {
        card=new NumberCard[100];
        for(int i=0;i<100;i++){
            card[i]=new NumberCard();
        }
        card[0].nextmark = 1;
        card[1].mark=1;
    }

    public int getIndexForFit(NumberCard c) {
        for (int i = 0; i < 4; i++)
        {
            for (int j = 0; j != 1;) {
                boolean left = false, right = false;
                NumberCard a = card[j], b = card[card[j].nextmark];
                if (a.mark == 0 || a.number[1] == c.number[3])
                    left = true;
                if (b.mark == 1 || b.number[3] == c.number[1])
                    right = true;
                if (left==true && right==true) {
                    return j;
                }
                j = card[j].nextmark;
            }
            c.rotate();
        }
        return -1;
    }

    public boolean insertCard(NumberCard c) {
        int x = getIndexForFit(c);
        if (x == -1)
            return false;
        c.nextmark = card[x].nextmark;
        card[x].nextmark = c.mark;
        card[c.mark]=c;
        return true;
    }

    public void print() {
        int x = card[0].nextmark;
        boolean flag=false;
        while (x != 1) {
            for (int i = 0; i < 4; i++) {
                if(flag==true)
                    System.out.print(" "+card[x].number[i]);
                else
                    System.out.print(card[x].number[i]);
                flag=true;
            }
            x=card[x].nextmark;
        }

    }
}

7-16 Battery Charge

电动汽车的电池必须周期性地进行充电，每次充电若干小时，充电过程不能被中断。充电费用基于充电的起止时间决定，费用表列出了一天内各个小时（0-23）的充电费率。每天使用的充电费率表相同，每小时费率是正整数。一个充电费率表示例如下图所示

类BatteryCharger使用费率表来决定最经济的充电方式。该类包含如下两个公有方法：

int getChargeCost(int startHour, int chargeTime) 该方法返回从开始时间经过一定的充电时长的全部充电费用。

int getChargeStartTime(int chargeTime)，该函数返回给定充电时长后能使充电费用最小的起始时间。如果存在多个可能的起始时间能产生最少的费用，返回较早（较小）的一个时间。

请写出BatteryCharge类。

在main函数中首先读入24个整数代表每个小时的费用，而后调用getChargeCost，读入两个参数startHour和chargeTime，输出总的费用；而后调用getChargeStartTime，读入充电时间chargeTime,输出费用最少的起始时间。

输入格式:
每小时费用
开始时间和充电时间
充电时间

输出格式:
总的费用
最小费用的起始时间

输入样例:
在这里给出一组输入。例如：

50 60 160 60 80 100 100 120 150 150 150 200 40 240 220 220 200 200 180 180 140 100 80 60
0 2
7

输出样例:
在这里给出相应的输出。例如：

110
22

答案:

import java.util.*;

class BatteryCharger{
	
	int [] t;
	public BatteryCharger(int[] t) {
		this.t = t;
	}
	
	int getChargeCost(int startHour, int chargeTime) {
		int sum = 0;
		for(int i = startHour; i < startHour + chargeTime; i++) {
			sum += t[i%24];
		}
		return sum;
	}
	
	int getChargeStartTime(int chargeTime) {
		int mincost = 99999;
		int starttime = 0;
		for(int i = 0; i < 24; i++) {
			int sumcost = 0;
			for(int j = i; j < i+chargeTime; j++) {
				sumcost += t[j%24];
			}
			if(sumcost < mincost) {
				mincost = sumcost;
				starttime = i;
			}
		}
		return starttime;
	}
	
}

public class Main {
    public static void main(String [] args){
    	
    	Scanner scan = new Scanner(System.in);
    	int t[] = new int[24];//用数组存放24小时的充电费率
    	for(int i = 0; i < 24; i++) {
    		t[i] = scan.nextInt();
    	}
    	BatteryCharger s = new BatteryCharger(t);
    	System.out.println(s.getChargeCost(scan.nextInt(), scan.nextInt()));
    	System.out.println(s.getChargeStartTime(scan.nextInt()));
    	
    }
}

7-17 N个数的排序与查

从键盘输入N个整数，并输出指定的某个整数在这N个整数中的按照由小到大的顺序排列的位次（最小的位次是1，最大的位次是N，指定的整数如果不在这N个数中，则其位次是-1）

输入格式:
整数个数，指定的整数值

输出格式:
指定的整数的位次

输入样例:
在这里给出一组输入。例如：

3
12 4 7
4

输出样例:
在这里给出相应的输出。例如：

1

答案：

import java.util.*;

public class Main {
    public static void main(String [] args){
    	
    	Scanner scan = new Scanner(System.in);
    	int num = scan.nextInt();
    	int flag = 0;
    	int arr[] = new int [num];
    	int arr2[] = new int [num];
    	for(int i = 0; i < num; i++) {
    		arr[i] = scan.nextInt();
    	}
    	System.arraycopy(arr, 0, arr2, 0, num);
    	Arrays.sort(arr2);
    	int x = scan.nextInt();
    	for(int i = 0; i < num; i++) {
    		if(arr2[i]==x) {
    			System.out.printf("%d",i+1);
    			flag = 1;
    		}
    	}
    	if(flag == 0) {
    		System.out.printf("%d",-1);
    	}   
    }
}

7-18 整数数组比较

给定两个整型数组A和B，将A的元素复制到B中，使得两个数组完全相同。再将B数组从小到大排列，将两数组的同一位置上对应的元素进行比较，统计出A中大于B的元素个数，等于B中元素的个数，小于B中的元素的个数。
提示：可用Arrays.sort排序

输入格式:
数组A的个数
数组A元素

输出格式:
A大于B的个数
A等于B的个数
A小于B的个数

输入样例:
在这里给出一组输入。例如：

10
23 1 32 87 65 12 21 9 76 45

输出样例:
在这里给出相应的输出。例如：

4
1
5

答案：

import java.util.*;

public class Main {
    public static void main(String [] args){
    	
    	Scanner scan = new Scanner(System.in);
    	int BigNum = 0;
    	int EqualNum = 0;
    	int SmallNum = 0;
    	int num = scan.nextInt();
    	int arr1[] = new int [num];
    	int arr2[] = new int [num];
    	for(int i = 0; i < num; i++) {
    		arr1[i] = scan.nextInt();
    	//  arr1[i] = arr1[i];
    	}
    	System.arraycopy(arr1, 0, arr2, 0, num);
        Arrays.sort(arr2);
        for(int i = 0; i < num; i++) {
        	if(arr1[i] > arr2[i]) {
        		BigNum++;
        	}
        	else if(arr1[i] == arr2[i]) {
        		EqualNum++;
        	}
        	else if(arr1[i] < arr2[i]) {
            	SmallNum++;
            }
        }
        System.out.println(BigNum);
        System.out.println(EqualNum);
        System.out.println(SmallNum);
        
    }
}

7-19 多数组排序

3个整数数组进行整体排序，根据输入的三个数组的元素，输出排序后的结果（从大到小）

输入格式:
第1个数组的长度

第1个数组的各个元素

第2个数组的长度

第2个数组的各个元素

第3个数组的长度

第3个数组的各个元素

输出格式:
所有数组的整体排序

输入样例:
在这里给出一组输入。例如：

3 
79 80 61
3
88 66 77
2
23 90

输出样例:
在这里给出相应的输出。例如：

90 88 80 79 77 66 61 23

答案：

import java.util.Arrays;
import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		
		int M = sc.nextInt();
		 int[] cns1= new int[M];
		for(int i=0; i<M; i++) {
			cns1[i]=sc.nextInt();
		}
		int N = sc.nextInt();
		 int[] cns2= new int[N];
		for(int i=0; i<N; i++) {
			cns2[i]=sc.nextInt();
		}
		int P = sc.nextInt();
		 int[] cns3= new int[P];
		for(int i=0; i<P; i++) {
			cns3[i]=sc.nextInt();
		}
		int cns[]=new int[M+N+P];
		for(int i=0;i<M+N+P;i++) {
			if(i<M)
				cns[i]=cns1[i];
			else if(i<M+N)
				cns[i]=cns2[i-M];
			else
				cns[i]=cns3[i-M-N];
		}
		Arrays.sort(cns);
		for(int i=cns.length-1;i>=0;i--) {
			System.out.print(cns[i]);
			if(i!=0)
				System.out.print(" ");
		}
	}
}

7-20 两队PK

A、B两队进行比赛，每队各有多名队员及其分数（分数不重复），使用A、B队所有队员得分的TOP 3来判断两队输赢，在TOP 3中拥有更多人数的队获胜。写程序实现该过程。

输入格式:
A队人数

A队每人得分

B队人数

B队每人得分

输出格式:
前三甲分数

赢的队

输入样例:

5
22 33 44 55 11
4
12 32 42 52

输出样例:

55 52 44
A

答案：

import java.util.Arrays;
import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int M = sc.nextInt();
		int[] cns1= new int[M];
		int top[]=new int[6];
		for(int i=0; i<M; i++) {
			cns1[i]=sc.nextInt();
			}
		Arrays.sort(cns1);
		int N = sc.nextInt();
		 int[] cns2= new int[N];
		for(int i=0; i<N; i++) {
			cns2[i]=sc.nextInt();
		}
		Arrays.sort(cns2);
		for(int i=0;i<6;i++) {
			if(i<3)
			top[i]=cns1[i+M-3];
			else
				top[i]=cns2[i+N-6];
		}
		Arrays.sort(top);
		int charA=0;
		int charB=0;
		for(int i=2;i>=0;i--) {
		if(Arrays.binarySearch(cns1, top[i+3])>=0)
			charA++;
		if(Arrays.binarySearch(cns2, top[i+3])>=0)
			charB++;
		if(i==0)
		System.out.println(top[i+3]);
		else
			System.out.print(top[i+3]+" ");
		}
		if(charA>charB)
			System.out.println("A");
		else
			System.out.println("B");
	}			
}

7-21 数组元素的删除

第一行包括一个整数n（1<=n<=100），表示数组元素的个数。
第二行输入n个数组元素，均为整数，用空格隔开。
第三行输入一个数k（1<=k<=100），表示要进行k次删除。
接下来k行，每行一个数x，表示要删除第x个元素。

输出格式:
输出经过k次删除后的数组，每两个元素之间用空格隔开。

输入样例:

10
1 2 3 4 5 6 7 8 9 10
4
3
2
4
6

输出样例:

1 4 5 7 8 10

答案：

import java.util.LinkedList;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		LinkedList<Integer> list = new LinkedList<Integer>();
		int n = sc.nextInt();
		for (int i = 0; i < n; i++) {
			list.add(sc.nextInt());
		}
		int k = sc.nextInt();
		for (int i = 0; i < k; i++) {
			int index = sc.nextInt();
			list.remove(index - 1);
		}
		sc.close();

		for (int i = 0; i < list.size(); i++) {
			System.out.print(list.get(i));
			if (i < list.size() - 1) {
				System.out.print(" ");
			}
		}
	}
}

7-22 sdut-array1-1 RDMP音乐播放器（II）(一维数组）

注意: 这是在使用数组的情况下完成的。

RDMP音乐播放器将存储5首歌曲，它们的名称将永远是“A”，“B”，“C”，“D”和“E”。RDMP有3个按钮，用户可以按下这些按钮来重新排列播放列表并播放歌曲。
最初，RDMP播放列表是“A, B, C, D, E”。3个控制按钮做以下工作:
   按钮1:将播放列表的第一首歌曲移动到播放列表的末尾。例如:“A, B, C, D, E”会变成“B, C, D, E, A”。
   按钮2:将播放列表的最后一首歌移动到播放列表的开始。例如，“A, B, C, D, E”会变成“E, A, B, C, D”。
   按钮3:交换播放列表的前两首歌。例如，“A, B, C, D, E”会变成“B, A, C, D, E”。

你需要编写一个程序来模拟一个可以按下n次按钮的RD音乐播放器。（n>0)

输入格式:

输入有多行。
首行是数值n，表示后续要按下按钮的次数。
后续有n行。均为1到3之间的数字，代表要采取的行动。

输出格式:

输出最终播放列表的正确顺序。
歌曲名称中间用逗号作分隔。最后一首歌名称之后没有逗号。

输入样例1:

1
1

输出样例1:

B,C,D,E,A

输入样例2:

1
2

输出样例2:

E,A,B,C,D

输入样例3:

1
3

输出样例3:

B,A,C,D,E

输入样例4:

6
1
2
3
3
2
1

输出样例4:

A,B,C,D,E

答案：

7-23 重复数据问题

在一大堆数据中找出重复的是一件经常要做的事情。现在要处理许多整数，在这些整数中，可能存在重复的数据。
你要写一个程序来做这件事情，读入数据，检查是否有重复的数据。如果有，输出“yes”这三个字母；如果没有，则输出“no”。

输入格式:
程序会读到n个整数的字符串【1<=n<=10000】，以空格分开，这些整数的范围是[1,10000]。

输出格式:
如果这些整数中存在重复的，就输出：
yes

否则，就输出：
no

输入样例:
在这里给出一组输入。例如：

1 2 3 1 4

输出样例:
在这里给出相应的输出。例如：

yes

答案：

7-24 公司季度销售额以及年销售额统计

年底了，某公司要做销售统计，请输入各月份的销售额（单位：万元），请分别统计每季度的以及全年度的公司销售总额。
要求：
1.用一个四行3列数组记录销售额

2.在Main类中写一个方法统计并输出季度以及全年度的销售总额，并输出。方法声明定义为：

public static void showTotal(int [][]sale)

3.在main方法中顶一个二维数组并通过键盘输入各月份的销售总额，然后调用showTotal方法，输出统计结果。

输入格式:
输入在一行中给出12个月份的销售额，中间用空格隔开。

输出格式:
每一行分别输出各季度的销售额总和，最后一行输出年度销售额。

输入样例:
在这里给出一组输入。例如：

22 33 44 33 44 66 77 45 64 43 34 23 45

输出样例:
在这里给出相应的输出。例如：

1季度的销售额为：99
2季度的销售额为：143
3季度的销售额为：186
4季度的销售额为：100
全年销售额为：528

答案：

import java.util.Scanner;

public class Main{
    public static void main(String[] args) {
         Scanner cin = new Scanner(System.in);
         int a[][] = new int [10][10];//防溢出
         for(int i = 1; i <= 4; i++) {
        	 for(int j = 1; j <= 3; j++) {
        		 a[i][j] = cin.nextInt();
        	 }
         }
         showTotal(a);  
    }
    //方法 统计并输出季度及全年的销售总额
    public static void showTotal(int [][]sale) {
    	int sum = 0;
    	for(int i = 1; i <= 4; i++) {
    		int s = 0;
    		for(int j = 1; j <= 3; j++) {
    			s += sale[i][j];
    		} 
    		System.out.println(i+"季度的销售额为："+s);
    		sum += s;  
    	}
    	System.out.println("全年销售额为："+sum);
    }
}

7-25 解析二维数组

读入一个字符串，该字符串表示一个整型二维数组d，数组中的元素通过解析字符串参数获得。例如，字符串参数：“1,2;3,4,5;6,7,8”，对应的数组为：
d[0,0] = 1 d[0,1] = 2
d[1,0] = 3 d[1,1] = 4 d[1,2] = 5
d[2,0] = 6 d[2,1] = 7 d[2,2] = 8
打印这个数组各元素的内容

输入格式:
字符串

输出格式:
二维数组各元素

输入样例:
在这里给出一组输入。例如：

1,2;3,4,5;6,7,8

输出样例:
在这里给出相应的输出。例如：

d[0,0] = 1 d[0,1] = 2
d[1,0] = 3 d[1,1] = 4 d[1,2] = 5
d[2,0] = 6 d[2,1] = 7 d[2,2] = 8

答案：

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
    	Scanner sc = new Scanner(System.in);
    	String str;
    	str = sc.next();//读入字符串
    	int i = 0,j = 0;
    	
    	if(str.length()!=0) {
    		System.out.print("d[" + i + "," + j + "] = ");
    	}
    	
    	for(int k = 0; k < str.length(); k++) {
    		if(str.charAt(k)==',') {
    			j++;
    			System.out.print(" d[" + i + "," + j + "] = ");
    		}
    		else if(str.charAt(k)==';') {
    			i++;
    			j = 0;
    			System.out.print("\nd[" + i + "," + j + "] = ");
    		}
    		else {
    			System.out.print(str.charAt(k));
    		}
    	}
    	
    }
}

7-26 矩阵类

利用二维数组（int[]）实现一个矩阵类：Matrix。要求提供以下方法：（1）set（int row, int col, int value）：将第row行第col列的元素赋值为value；（2）get（int row，int col）：取第row行第col列的元素；（3）width()：返回矩阵的列数；（4）height()：返回矩阵的行数；（5）Matrix add（Matrix b）：返回当前矩阵与矩阵b相加后的矩阵；（6）Matrix multiply（Matrix b）：返回当前矩阵与矩阵b相乘后的矩阵。（7）Matrix transpose()：返回当前矩阵的转置矩阵；（8）toString()：以行和列的形式打印出当前矩阵。

输入格式:
矩阵的行列数
矩阵的数据
设置矩阵值的行、列和值
获取矩阵值的行、列
待相加矩阵的行列数
待相加矩阵的值
待相乘矩阵的行列数
待相乘矩阵的值

输出格式:
矩阵的行、列数
设置矩阵值后的矩阵
某行某列的矩阵值
矩阵相加结果
矩阵相乘结果
矩阵转置结果

输入样例:
在这里给出一组输入。例如：

3 3
1 2 3
4 5 6
7 8 9
2 3 8
1 3
3 3
1 2 3
4 5 6
7 8 9
3 2
1 2
1 2
1 2

输出样例:
在这里给出相应的输出。例如：

row:3 column:3
after set value:
1 2 3
4 5 8
7 8 9
value on (1,3):3
after add:
2 4 6
8 10 14
14 16 18
after multiply:
6 12
17 34
24 48
after transpose:
1 4 7
2 5 8
3 8 9

答案：

import java.text.DecimalFormat;
import java.util.*;

class Matrix {

	private int row;
	
	private int col;
	
	// private double value;

	double[][] Data;

	public Matrix(int row, int col, double[][] Data) {

		this.row = row;

		this.col = col;

		// this.value = value;

		this.Data = Data;

	}

	public void setMatrix(int row, int col, double value) {
		this.Data[row - 1][col - 1] = value;
	}

	public double getMatrix(int row, int col) {
		return Data[row - 1][col - 1];
	}

	public int width() {
		return row;
	}

	public int height() {
		return col;
	}

	public Matrix add(Matrix b) {
		if (this.width() != b.width() && this.height() != b.height()) {
			return null;
		}
		double add[][] = new double[this.row][this.col];
		for (int i = 0; i < col; i++) {
			for (int j = 0; j < row; j++) {
				add[i][j] = this.Data[i][j] + b.Data[i][j];
			}
		}
		Matrix another = new Matrix(this.col, this.row, add);
		System.out.println("after add:");
		return another;
	}

	public Matrix multiply(Matrix b) {
		if (this.col != b.row) {
			return null;
		}
		double mul[][] = new double[this.row][b.col];
		double temp = 0;
		for (int i = 0; i < this.row; i++) {
			for (int k = 0; k < b.col; k++) {
				for (int j = 0; j < this.col; j++) {
					temp += this.Data[i][j] * b.Data[j][k];
				}
				mul[i][k] = temp;
				temp = 0;
			}
		}
		Matrix another = new Matrix(this.row, b.col, mul);
		System.out.println("after multiply:");
		return another;
	}

	public Matrix transpose() {
		double tran[][] = new double[this.row][this.col];
		for (int i = 0; i < this.row; i++) {
			for (int j = 0; j < this.col; j++) {
				tran[j][i] = this.Data[i][j];
			}
		}
		Matrix another = new Matrix(this.col, this.row, tran);
		System.out.println("after transpose:");
		return another;
	}

	public String toString() {
		DecimalFormat df = new DecimalFormat("0");
		String result = "";
		// result += df.format(Date[0][0]);
		for (int i = 0; i < this.row; i++) {
			result += df.format(Data[i][0]);
			for (int j = 1; j < this.col; j++) {
				result += " " + df.format(Data[i][j]);
			}
			result += "\n";
		}
		return result;
	}
}

public class Main {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int row = scan.nextInt();
		int col = scan.nextInt();
		System.out.println("row:" + row + " column:" + col);
		// set value
		double data[][] = new double[row][col];
		for (int i = 0; i < row; i++) {
			for (int j = 0; j < col; j++) {
				double d = scan.nextDouble();
				data[i][j] = d;
			}
		}
		Matrix matrix = new Matrix(row, col, data);
		int srow = scan.nextInt();
		int scol = scan.nextInt();
		double sv = scan.nextDouble();
		System.out.println("after set value:");
		matrix.setMatrix(srow, scol, sv);
		System.out.print(matrix);
		// get value
		DecimalFormat df = new DecimalFormat("0");
		int vrow = scan.nextInt();
		int vcol = scan.nextInt();
		System.out.print("value on (" + vrow + "," + vcol + "):");
		System.out.println(df.format(matrix.getMatrix(vrow, vcol)));
		// add
		int addrow = scan.nextInt();
		int addcol = scan.nextInt();
		double addMatrix[][] = new double[addrow][addcol];
		for (int i = 0; i < addrow; i++) {
			for (int j = 0; j < addcol; j++) {
				double ad = scan.nextDouble();
				addMatrix[i][j] = ad;

			}
		}
		Matrix add = new Matrix(addrow, addcol, addMatrix);
		System.out.print(matrix.add(add));
		// mul
		int mulrow = scan.nextInt();
		int mulcol = scan.nextInt();
		double mulMatrix[][] = new double[mulrow][mulcol];
		for (int i = 0; i < mulrow; i++) {
			for (int j = 0; j < mulcol; j++) {
				double mu = scan.nextDouble();
				mulMatrix[i][j] = mu;

			}
		}
		Matrix mul = new Matrix(mulrow, mulcol, mulMatrix);
		// System.out.print(matrix.multiply(add));
		System.out.print(matrix.multiply(mul));

		// transpose
		System.out.print(matrix.transpose());
	}

}

7-27 sdut-array1-2 RDMP音乐播放器（III）(一维数组）

注意: 这是在使用数组的情况下完成的。

RDMP音乐播放器将存储m首歌曲，它们的名称将是以字母'A'开始的歌曲。(m<=26)
例如：
  M=3，则歌曲名称将是：'A'，'B'，'C' 。
  M=7，则歌曲名称将是：'A'，'B'，'C'， D'，'E'，'F'，'G' 。

RDMP有3个按钮，用户可以按下这些按钮来重新排列播放列表并播放歌曲。
举例：
如果，最初RDMP播放列表是“A, B, C, D, E”。3个控制按钮做以下工作:
   按钮1: 将播放列表的第一首歌曲移动到播放列表的末尾。例如:“A, B, C, D, E”会变成“B, C, D, E, A”。
   按钮2: 将播放列表的最后一首歌移动到播放列表的开始。例如，“A, B, C, D, E”会变成“E, A, B, C, D”。
   按钮3: 交换播放列表的前两首歌。例如，“A, B, C, D, E”会变成“B, A, C, D, E”。

你需要编写一个程序来模拟一个可以按下n次按钮的RD音乐播放器。（n>0)

输入格式:

输入有多行。
首行是两个整数，分别为歌曲的数量m和按下播放按钮的次数n。
后续有n行整数，表示按下按扭的不同的操作，均为1到3之间的数字，代表要采取的行动。

输出格式:

输出最终播放列表的正确顺序。
歌曲名称中间用逗号作分隔。最后一首歌名称之后没有逗号。

输入样例1:

5 2
1
2

输出样例1:

A,B,C,D,E

输入样例2:

5 2
3
3

输出样例2:

A,B,C,D,E

输入样例3:

10 5
1
2
3
3
1

输出样例3:

B,C,D,E,F,G,H,I,J,A

答案：

import java.util.*;

public class Main{
	public static void main(String [] args) {
		Scanner sc = new Scanner(System.in);
		int m = sc.nextInt();
		char a[] = new char [] {'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};

		int n = sc.nextInt();
		for(int j = 0; j < n; j++) {
			int x = sc.nextInt();
			if(x == 1) {
				char temp = a[0];
				for(int i = 0; i <= m-2; i++) {
					a[i] = a[i+1];
				}
				a[m-1] = temp;
			}
			else if(x == 2) {
				char temp = a[m-1];
				for(int i = m-1; i >= 1; i--) {
					a[i] = a[i-1];
				}
				a[0] = temp;
			}
			else if(x == 3) {
				char temp = a[0];
				a[0] = a[1];
				a[1] = temp;
			}
		}
		
		for(int i = 0; i < m-1; i++) {
			System.out.print(a[i]+",");
		}
		System.out.println(a[m-1]);
	}
}

7-28 sdut-array2-2-局部峰值

给定一个N行乘N列的2D数组，逐行扫描该值并打印出所有局部峰值，该值大于其左上、上、右上、左、右、左下、下、右下的值（如果有）。

N的范围是2到150。

输入格式:
多组输入。每组输入包含两部分：

第一行包含整数N，表示2D数组的大小。

后面的N行中的每一行包含N个非负整数，用空格分隔。

输出格式:
对于每组输入，输出所有局部峰值按行顺序排列，每个局部峰值后跟一个空格。

如果没有局部峰值，则输出“none”。

每组输出之后加换行符。

输入样例:

2 
5 1 
1 0 
2
5 2
2 3
3
5 5 5
0 5 0
5 5 5
3
1 2 5
2 3 2
4 2 3

输出样例:

5 
5 
none
5 4 

答案：

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		int[][] arr = new int[155][155];
		int i, j, n, flag;
		while (s.hasNextInt()) {
			n = s.nextInt();
			for (i = 1; i <= n; ++i) {
				for (j = 1; j <= n; ++j) {
					arr[i][j] = s.nextInt();
				}
			}
			flag = 0;
			for (i = 1; i <= n; ++i) {
				for (j = 1; j <= n; ++j) {
					if (IsMax(arr, i, j, n)) {
						// if(flag==1)
						// System.out.print(" ");
						System.out.print(arr[i][j] + " ");
						flag = 1;
						// System.out.println(i+" "+j);
					}
				}
			}
			if (flag == 0) {
				System.out.print("none");
			}
			System.out.println();
		}
	}

	public static boolean IsMax(int[][] arr, int a, int b, int n) {
		if (a - 1 >= 1 && b - 1 >= 1) // 左上
			if (arr[a][b] <= arr[a - 1][b - 1])
				return false;
		if (a - 1 >= 1)// 上
			if (arr[a - 1][b] >= arr[a][b])
				return false;
		if (a - 1 >= 1 && b + 1 <= n)// 右上
			if (arr[a - 1][b + 1] >= arr[a][b])
				return false;
		if (b - 1 >= 1)// 左
			if (arr[a][b - 1] >= arr[a][b])
				return false;
		if (b + 1 <= n)// 右
			if (arr[a][b + 1] >= arr[a][b])
				return false;
		if (a + 1 <= n && b - 1 >= 1)// 左下
			if (arr[a + 1][b - 1] >= arr[a][b])
				return false;
		if (a + 1 <= n)// 下
			if (arr[a + 1][b] >= arr[a][b])
				return false;
		if (a + 1 <= n && b + 1 <= n)// 右下
			if (arr[a + 1][b + 1] >= arr[a][b])
				return false;
		return true;
	}
}

7-29 sdut-array2-3 二维方阵变变变

有4行,4列的数据组成的矩阵。

1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16

它经过顺时针90度旋转后的效果为：（旋转角度值设为 90 ）

13 9 5 1
14 10 6 2
15 11 7 3
16 12 8 4

顺时针180度旋转后的效果为：（旋转角度值设为 180 ）

16 15 14 13
12 11 10 9
8 7 6 5
4 3 2 1

逆时针90度旋转后的结果为：（旋转角度值设为 -90 ）

4 8 12 16
3 7 11 15
2 6 10 14
1 5 9 13

输入格式:
首行包括：（1）二维矩阵的行（列）数n，（2）矩阵旋转的角度，从90、180、-90中取一个；
接下来是n行n列的整数，数据之间以空格分隔，组成一个方阵。

输出格式:
矩阵按指定角度旋转后的结果。输出时按行、列进行组织。每行的数据之间有一个空格；行末尾数据后没有空格。

输入样例1:

4 90
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16

输出样例1:

13 9 5 1
14 10 6 2
15 11 7 3
16 12 8 4

输入样例2:

4 180
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16

输出样例2:

16 15 14 13
12 11 10 9
8 7 6 5
4 3 2 1

输入样例3:

4 -90
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16

输出样例3:

4 8 12 16
3 7 11 15
2 6 10 14
1 5 9 13

答案：

import java.util.*;

public class Main{
	public static void main(String [] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int arr[][] = new int [n][n]; 
		int a[][] = new int [n][n]; 
		int m = sc.nextInt();
		for(int i = 0; i < n; i++) {
			for(int j = 0; j < n; j++) {
				arr[i][j] = sc.nextInt();
			}
		}
		
		if(m == 90) {
			for(int i = 0; i < n; i++) {
				for(int j = 0; j < n; j++) {
					a[i][j] = arr[n-j-1][i];
				}
			}
		}
		
		if(m == 180) {
			for(int i = 0; i < n; i++) {
				for(int j = 0; j < n; j++) {
					a[i][j] = arr[n-i-1][n-j-1];
				}
			}
		}
		
		if(m == -90) {
			for(int i = 0; i < n; i++) {
				for(int j = 0; j < n; j++) {
					a[i][j] = arr[j][n-i-1];
				}
			}
		}
		
		for(int i = 0; i < n; i++) {
			for(int j = 0; j < n-1; j++) {
				System.out.print(a[i][j]+" ");
			}
			System.out.println(a[i][n-1]);
		}
		
	}
}

7-30 sdut-array2-4 打印“杨辉三角“ 品中国数学史 增民族自豪感（1）

背景介绍： 北宋人贾宪约1050年首先使用“贾宪三角”进行高次开方运算。

南宋数学家杨辉在《详解九章算法》（1261年）记载并保存了“贾宪三角”，故称杨辉三角。杨辉三角是中国数学史上的一个伟大成就。
杨辉三角，是中国古代数学的杰出研究成果之一，它把二项式系数图形化，把组合数内在的一些代数性质直观地从图形中体现出来，是一种离散型的数与形的结合。

中国南宋数学家杨辉1261年所著的《详解九章算法》一书中出现。在欧洲，帕斯卡（1623----1662）在1654年发现这一规律，所以这个表又叫做帕斯卡三角形。帕斯卡的发现比杨辉要迟393年，比贾宪迟600年。

杨辉三角数字的特点为：

（1）在三角形的首列和对角线上，数值均为1；

（2）其余数据为：每个数字等于上一行的左右两个数字之和，第n+1行的第i个数等于第n行的第i-1个数和第i个数之和，用公式表示为： C(n+1,i)=C(n,i)+C(n,i-1)。

图示为：

杨辉三角的应用：(a+b)的n次方，展开式中的各项系数依次对应杨辉三角的第(n+1)行中的每一项。

输入格式:
欲打印杨辉三角的行数n（1<=n<=13)。

输出格式:
每个数字占据4个字符的位置，数字左对齐，数字不足4位的右边留出空格。

输入样例:

13

输出样例:

1   
1   1   
1   2   1   
1   3   3   1   
1   4   6   4   1   
1   5   10  10  5   1   
1   6   15  20  15  6   1   
1   7   21  35  35  21  7   1   
1   8   28  56  70  56  28  8   1   
1   9   36  84  126 126 84  36  9   1   
1   10  45  120 210 252 210 120 45  10  1   
1   11  55  165 330 462 462 330 165 55  11  1   
1   12  66  220 495 792 924 792 495 220 66  12  1   

答案：

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int i,j;
		int [][] a = new int [n][n];
		for(i = 0; i < n; i++) {
			a[i][0] = 1;
			a[i][i] = 1;
		}
		for(i = 2; i < n; i++) {
			for(j = 1; j < i; j++) {
				a[i][j] = a[i-1][j]+a[i-1][j-1];
			}
		}
		for(i = 0; i < n; i++) {
			for(j = 0; j <= i; j++) {
				System.out.printf("%-4d",a[i][j]);
			}
			System.out.print("\n");
		}
		
	}
}

7-31 sdut-array2-5 打印“杨辉三角“ 品中国数学史 增民族自豪感（2）

背景介绍：

北宋人贾宪约1050年首先使用“贾宪三角”进行高次开方运算。
南宋数学家杨辉在《详解九章算法》（1261年）记载并保存了“贾宪三角”，故称杨辉三角。杨辉三角是中国数学史上的一个伟大成就。
杨辉三角，是中国古代数学的杰出研究成果之一，它把二项式系数图形化，把组合数内在的一些代数性质直观地从图形中体现出来，是一种离散型的数与形的结合。

中国南宋数学家杨辉1261年所著的《详解九章算法》一书中出现。在欧洲，帕斯卡（1623----1662）在1654年发现这一规律，所以这个表又叫做帕斯卡三角形。帕斯卡的发现比杨辉要迟393年，比贾宪迟600年。

杨辉三角数字的特点为：

（1）在三角形的首列和对角线上，数值均为1；

（2）其余数据为：每个数字等于上一行的左右两个数字之和，第n+1行的第i个数等于第n行的第i-1个数和第i个数之和，用公式表示为： C(n+1,i)=C(n,i)+C(n,i-1)。

图示为：

杨辉三角的应用：(a+b)的n次方，展开式中的各项系数依次对应杨辉三角的第(n+1)行中的每一项。

输入格式:
欲打印杨辉三角的行数n（1<=n<=13)。

输出格式:
（1）输出的数据为等腰三角形样式；

（2）每个数字占据4个字符的位置，数字左对齐，数字不足4位的右边留出空格；

（3）最后一行的数值“1”顶格，前面无空格。

提示：以n=5，分析行首空格数为：

输入样例1:

5

输出样例:

        1   
      1   1   
    1   2   1   
  1   3   3   1   
1   4   6   4   1   

输入样例2:

6

输出样例:

          1   
        1   1   
      1   2   1   
    1   3   3   1   
  1   4   6   4   1   
1   5   10  10  5   1   

答案：

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int i,j,k;
		int [][] a = new int [n][n];
		for(i = 0; i < n; i++) {
			a[i][0] = 1;
			a[i][i] = 1;
		}
		for(i = 2; i < n; i++) {
			for(j = 1; j < i; j++) {
				a[i][j] = a[i-1][j]+a[i-1][j-1];
			}
		}
		for(i = 0; i < n; i++) {
			for(k = 0; k < 2*(n-i-1); k++) {
				System.out.print(" ");
			}
			for(j = 0; j <= i; j++) {
				System.out.printf("%-4d",a[i][j]);
			}
			System.out.print("\n");
		}
		
	}
}

7-32 Shape类-2

定义一个形状类Shape，提供计算周长getPerimeter()和面积getArea()的函数
定义一个子类正方形类Square继承自Shape类，拥有边长属性，提供构造函数，能够计算周长getPerimeter()和面积getArea()
定义一个子类长方形类Rectangle继承自Square类，拥有长、宽属性，提供构造函数，能够计算周长getPerimeter()和面积getArea()
定义一个子类圆形类Circle继承自Shape，拥有半径属性，提供构造函数，能够计算周长getPerimeter()和面积getArea()

在main函数中，分别构造三个Shape类的变量，分别指向一个Square、Rectangle、Circle对象，并输出他们的周长、面积.

输入格式:
正方形类的边长
长方形类的长宽
圆类的半径

输出格式:
正方形的周长、面积
长方形的周长、面积
圆形的周长、面积

输入样例:
在这里给出一组输入。例如：

1
1 2
2

输出样例:
在这里给出相应的输出。例如：

4.00 1.00
6.00 2.00
12.57 12.57

答案：

import java.util.*;

abstract class Shape{
	abstract double getPerimeter();
	abstract double getArea();
}

class Square extends Shape{
	double len;
	public Square(double len) {
		this.len = len;
	}
	public double getPerimeter() {
		return 4*len;
	}
	public double getArea() {
		return len*len;
	}
}

class Rectangle extends Square{
	double broad;
	public Rectangle(double len,double broad) {
		super(len);
		this.broad = broad;
	}
	public double getPerimeter() {
		return 2*(len+broad);
	}
	public double getArea() {
		return len*broad;
	}
}

 class Circle extends Shape{
	double r;
	public Circle(double r) {
		this.r = r;
	}
	public double getPerimeter() {
		return 2*Math.PI*r;
	}
	public double getArea() {
		return Math.PI*r*r;
	}
}

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		double a = sc.nextDouble();
		Square s = new Square(a);
		System.out.printf("%.2f ",s.getPerimeter());
		System.out.printf("%.2f\n",s.getArea());
		
		double len = sc.nextDouble();
		double broad = sc.nextDouble();
		Rectangle re = new Rectangle(len,broad);
		System.out.printf("%.2f ",re.getPerimeter());
		System.out.printf("%.2f\n",re.getArea());
		
		double r = sc.nextDouble();
		Circle c = new Circle(r);
		System.out.printf("%.2f ",c.getPerimeter());
		System.out.printf("%.2f\n",c.getArea());
		
	}
}

7-33 学生、大学生、研究生类-2

修改题目125（学生类-本科生类-研究生类）
为学生类添加属性成绩，添加相应的get和set函数，添加函数getGrade()表示获得等级，该函数应当为抽象函数。
本科生和研究生的等级计算方式不同，如下所示

本科生标准 研究生标准
[80–100) A [90–100) A
[70–80) B [80–90) B
[60–70) C [70–80) C
[50–60) D [60–70) D
50 以下 E 60 以下 E

main函数中构造两个学生Student变量，分别指向本科生和研究生对象，调用getGrade()方法输出等级

输入格式:
本科生类信息，学号、姓名、性别、专业、成绩
研究生类信息，学号、姓名、性别、专业、导师、成绩

输出格式:
本科生等级
研究生等级

输入样例:
在这里给出一组输入。例如：

2 chen female cs 90
3 li male sc wang 80

输出样例:
在这里给出相应的输出。例如：

A
B

答案：

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		
		int no = scan.nextInt();
		String name = scan.next();
		String sex = scan.next();
		String major = scan.next();
		int score = scan.nextInt();
		CollegeStudent c = new CollegeStudent(no, name, sex, major,score);
		c.getGrade();
		
		no = scan.nextInt();
		name = scan.next();
		sex = scan.next();
		major = scan.next();
		String supervisor = scan.next();
		score = scan.nextInt();
		GraduateStudent g = new GraduateStudent(no, name, sex, major, supervisor,score);
		g.getGrade();
		scan.close();
	}
}

abstract class Student {
	int no;
	String name;
	String sex;
	int score;

	public Student(int no, String name, String sex, int score) {
		this.no = no;
		this.name = name;
		this.sex = sex;
		this.score = score;
	}

	public int getNo() {
		return no;
	}

	public void setNo(int no) {
		this.no = no;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	abstract void getGrade();

	public int getScore() {
		return score;
	}

	public void setScore(int score) {
		this.score = score;
	}

	public void attendClass(String className) {

	}

	public void print() {
		System.out.println("no: " + no);
		System.out.println("name: " + name);
		System.out.println("sex: " + sex);
	}
}

class CollegeStudent extends Student {
	String major;

	public CollegeStudent(int no, String name, String sex, String major, int score) {
		super(no, name, sex, score);
		this.major = major;
	}

	public String getMajor() {
		return major;
	}

	public void setMajor(String major) {
		this.major = major;
	}

	public void print() {
		System.out.println("no: " + no);
		System.out.println("name: " + name);
		System.out.println("sex: " + sex);
		System.out.println("major: " + major);
	}

	public void getGrade() {
		if (score >= 80) {
			System.out.println("A");
		} else if (score >= 70) {
			System.out.println("B");
		} else if (score >= 60) {
			System.out.println("C");
		} else if (score >= 50) {
			System.out.println("D");
		} else {
			System.out.println("E");
		}
	}

}

class GraduateStudent extends CollegeStudent {
	String supervisor;

	public GraduateStudent(int no, String name, String sex, String major, String supervisor, int score) {
		super(no, name, sex, major, score);
		this.supervisor = supervisor;
	}

	public String getSupervisor() {
		return supervisor;
	}

	public void setSupervisor(String supervisor) {
		this.supervisor = supervisor;
	}

	public void doResearch() {
		System.out.println(name + " is doing research");
	}

	public void print() {
		System.out.println("no: " + no);
		System.out.println("name: " + name);
		System.out.println("sex: " + sex);
		System.out.println("major: " + major);
		System.out.println("supervisor: " + supervisor);
	}
	
	public void getGrade() {
		if (score >= 90) {
			System.out.println("A");
		} else if (score >= 80) {
			System.out.println("B");
		} else if (score >= 70) {
			System.out.println("C");
		} else if (score >= 60) {
			System.out.println("D");
		} else {
			System.out.println("E");
		}
	}
}