柳婼の blog – 第145页 – 我不管，反正我最萌～

PAT 乙级 1051. 复数乘法 (15) Java版

复数可以写成(A + Bi)的常规形式，其中A是实部，B是虚部，i是虚数单位，满足i² = -1；也可以写成极坐标下的指数形式(R*e^(Pi))，其中R是复数模，P是辐角，i是虚数单位，其等价于三角形式(R(cos(P) + isin(P))。

现给定两个复数的R和P，要求输出两数乘积的常规形式。

输入格式：

输入在一行中依次给出两个复数的R1, P1, R2, P2，数字间以空格分隔。

输出格式：

在一行中按照“A+Bi”的格式输出两数乘积的常规形式，实部和虚部均保留2位小数。注意：如果B是负数，则应该写成“A-|B|i”的形式。

输入样例：

2.3 3.5 5.2 0.4

1	2.3 3.5 5.2 0.4

输出样例：

-8.68-8.23i

1	-8.68-8.23i

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {

		Scanner in = new Scanner(System.in);

		double r1 = in.nextDouble();
		double p1 = in.nextDouble();
		double r2 = in.nextDouble();
		double p2 = in.nextDouble();

		in.close();
		double a = r1 * Math.cos(p1) * r2 * Math.cos(p2) - r1 * Math.sin(p1) * r2 * Math.sin(p2);
		double b = r1 * Math.sin(p1) * r2 * Math.cos(p2) + r2 * Math.sin(p2) * r1 * Math.cos(p1);

		if (Math.abs(a) <= 0.001) {
			System.out.print("0.00");
		} else {
			System.out.printf("%.2f", a);
		}

		if (b > 0) {
			System.out.printf("+%.2fi", b);
		} else if (Math.abs(b) <= 0.001) {
			System.out.print("+0.00i");
		} else {
			System.out.printf("%.2fi", b);
		}
	}

}

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

double r1 = in.nextDouble();

double p1 = in.nextDouble();

double r2 = in.nextDouble();

double p2 = in.nextDouble();

in.close();

double a = r1 * Math.cos(p1) * r2 * Math.cos(p2) - r1 * Math.sin(p1) * r2 * Math.sin(p2);

double b = r1 * Math.sin(p1) * r2 * Math.cos(p2) + r2 * Math.sin(p2) * r1 * Math.cos(p1);

if (Math.abs(a) <= 0.001) {

System.out.print("0.00");

} else {

System.out.printf("%.2f", a);

}

if (b > 0) {

System.out.printf("+%.2fi", b);

} else if (Math.abs(b) <= 0.001) {

System.out.print("+0.00i");

} else {

System.out.printf("%.2fi", b);

}

PAT 乙级 1054. 求平均值 (20) Java版

本题的基本要求非常简单：给定N个实数，计算它们的平均值。但复杂的是有些输入数据可能是非法的。一个“合法”的输入是[-1000，1000]区间内的实数，并且最多精确到小数点后2位。当你计算平均值的时候，不能把那些非法的数据算在内。

输入格式：

输入第一行给出正整数N（<=100）。随后一行给出N个正整数，数字间以一个空格分隔。

输出格式：

对每个非法输入，在一行中输出“ERROR: X is not a legal number”，其中X是输入。最后在一行中输出结果：“The average of K numbers is Y”，其中K是合法输入的个数，Y是它们的平均值，精确到小数点后2位。如果平均值无法计算，则用“Undefined”替换Y。如果K为1，则输出“The average of 1 number is Y”。

输入样例1：

7
5 -3.2 aaa 9999 2.3.4 7.123 2.35

1 2	7 5 -3.2 aaa 9999 2.3.4 7.123 2.35

输出样例1：

ERROR: aaa is not a legal number
ERROR: 9999 is not a legal number
ERROR: 2.3.4 is not a legal number
ERROR: 7.123 is not a legal number
The average of 3 numbers is 1.38

ERROR: aaa is not a legal number

ERROR: 9999 is not a legal number

ERROR: 2.3.4 is not a legal number

ERROR: 7.123 is not a legal number

The average of 3 numbers is 1.38

输入样例2：

2
aaa -9999

1 2	2 aaa -9999

输出样例2：

ERROR: aaa is not a legal number
ERROR: -9999 is not a legal number
The average of 0 numbers is Undefined

ERROR: aaa is not a legal number

ERROR: -9999 is not a legal number

The average of 0 numbers is Undefined

这里用了抛异常的方式来判断输入的值是否符合规则

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int cnt = 0;
		double y = 0;
		for (int i = 0; i < n; i++) {
			double x = 0;
			String s = null;
			try {
				s = in.next();
				x = Double.parseDouble(s);
				double temp = Double.parseDouble(String.format("%.2f", x));
				if (x > 1000 || x < -1000 || Math.abs(temp - x) >= 0.001) {
					throw new NumberFormatException();
				}

				cnt++;
				y += x;
			} catch (NumberFormatException e) {
				System.out.println("ERROR: " + s + " is not a legal number");
			}
		}
		in.close();

		if (cnt == 0) {
			System.out.println("The average of 0 numbers is Undefined");
		} else if (cnt == 1) {
			System.out.printf("The average of 1 number is %.2f", y);
		} else {
			System.out.printf("The average of %d numbers is %.2f", cnt, y / cnt);
		}
	}

}

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

int n = in.nextInt();

int cnt = 0;

double y = 0;

for (int i = 0; i < n; i++) {

double x = 0;

String s = null;

try {

s = in.next();

x = Double.parseDouble(s);

double temp = Double.parseDouble(String.format("%.2f", x));

if (x > 1000 || x < -1000 || Math.abs(temp - x) >= 0.001) {

throw new NumberFormatException();

}

cnt++;

y += x;

} catch (NumberFormatException e) {

System.out.println("ERROR: " + s + " is not a legal number");

}

in.close();

if (cnt == 0) {

System.out.println("The average of 0 numbers is Undefined");

} else if (cnt == 1) {

System.out.printf("The average of 1 number is %.2f", y);

} else {

System.out.printf("The average of %d numbers is %.2f", cnt, y / cnt);

}

PAT 乙级 1008. 数组元素循环右移问题 (20) Java版

一个数组A中存有N（N>0）个整数，在不允许使用另外数组的前提下，将每个整数循环向右移M（M>=0）个位置，即将A中的数据由（A₀A₁……A_N-1）变换为（A_N-M …… A_N-1 A₀ A₁……A_N-M-1）（最后M个数循环移至最前面的M个位置）。如果需要考虑程序移动数据的次数尽量少，要如何设计移动的方法？

输入格式：每个输入包含一个测试用例，第1行输入N ( 1<=N<=100)、M（M>=0）；第2行输入N个整数，之间用空格分隔。

输出格式：在一行中输出循环右移M位以后的整数序列，之间用空格分隔，序列结尾不能有多余空格。

输入样例：

6 2
1 2 3 4 5 6

1 2	6 2 1 2 3 4 5 6

输出样例：

5 6 1 2 3 4

1	5 6 1 2 3 4

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {

		Scanner in = new Scanner(System.in);
		
		int size = in.nextInt();
		int cnt = in.nextInt();
		int[] array = new int [size];
		
		for(int i = 0; i < array.length; i++){
			array[i] = in.nextInt();
		}
		
		in.close();
		
		for(int i = 0; i < cnt; i++){
			int temp = array[array.length-1];
			for(int j = array.length-1; j > 0; j--){
				array[j] = array[j-1];
			}
			array[0] = temp;
		}
		
		for(int i = 0; i < array.length; i++){
			System.out.print(array[i]);
			if(i != array.length -1){
				System.out.print(" ");
			}
		}
	}

}

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

int size = in.nextInt();

int cnt = in.nextInt();

int[] array = new int [size];

for(int i = 0; i < array.length; i++){

array[i] = in.nextInt();

}

in.close();

for(int i = 0; i < cnt; i++){

int temp = array[array.length-1];

for(int j = array.length-1; j > 0; j--){

array[j] = array[j-1];

}

array[0] = temp;

}

for(int i = 0; i < array.length; i++){

System.out.print(array[i]);

if(i != array.length -1){

System.out.print(" ");

}

PAT 乙级 1007. 素数对猜想 (20) Java版

让我们定义 d_n 为：d_n = p_n+1 – p_n，其中 p_i 是第i个素数。显然有 d₁=1 且对于n>1有 d_n 是偶数。“素数对猜想”认为“存在无穷多对相邻且差为2的素数”。

现给定任意正整数N (< 10⁵)，请计算不超过N的满足猜想的素数对的个数。

输入格式：每个测试输入包含1个测试用例，给出正整数N。

输出格式：每个测试用例的输出占一行，不超过N的满足猜想的素数对的个数。

输入样例：

20

输出样例：

4

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

public class Main {

	public static void main(String[] args) {

		Scanner in = new Scanner(System.in);
		int number = in.nextInt();
		in.close();
		
		LinkedList<Integer> prime = new LinkedList<Integer>();
		for(int i = 2; i <= number; i++){
			if(isPrime(i)){
				prime.add(i);
			}
		}
		
		
		int cnt = 0;
		
		for(int i = 0; i < prime.size()-1; i++){
			if(prime.get(i) - prime.get(i+1) == -2){
				cnt++;
			}
		}
		
		System.out.println(cnt);
	}
	
	public static boolean isPrime(int number){
		for(int i = 2; i <= Math.sqrt(number); i++){
			if(number % i == 0){
				return false;
			}
		}
		return true;
	}

}

import java.util.LinkedList;

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

int number = in.nextInt();

in.close();

LinkedList<Integer> prime = new LinkedList<Integer>();

for(int i = 2; i <= number; i++){

if(isPrime(i)){

prime.add(i);

}

int cnt = 0;

for(int i = 0; i < prime.size()-1; i++){

if(prime.get(i) - prime.get(i+1) == -2){

cnt++;

}

System.out.println(cnt);

}

public static boolean isPrime(int number){

for(int i = 2; i <= Math.sqrt(number); i++){

if(number % i == 0){

return false;

}

return true;

}

PAT 乙级 1005. 继续(3n+1)猜想 (25) Java版

卡拉兹(Callatz)猜想已经在1001中给出了描述。在这个题目里，情况稍微有些复杂。

当我们验证卡拉兹猜想的时候，为了避免重复计算，可以记录下递推过程中遇到的每一个数。例如对n=3进行验证的时候，我们需要计算3、5、8、4、2、1，则当我们对n=5、8、4、2进行验证的时候，就可以直接判定卡拉兹猜想的真伪，而不需要重复计算，因为这4个数已经在验证3的时候遇到过了，我们称5、8、4、2是被3“覆盖”的数。我们称一个数列中的某个数n为“关键数”，如果n不能被数列中的其他数字所覆盖。

现在给定一系列待验证的数字，我们只需要验证其中的几个关键数，就可以不必再重复验证余下的数字。你的任务就是找出这些关键数字，并按从大到小的顺序输出它们。

输入格式：每个测试输入包含1个测试用例，第1行给出一个正整数K(<100)，第2行给出K个互不相同的待验证的正整数n(1<n<=100)的值，数字间用空格隔开。

输出格式：每个测试用例的输出占一行，按从大到小的顺序输出关键数字。数字间用1个空格隔开，但一行中最后一个数字后没有空格。

输入样例：

6
3 5 6 7 8 11

1 2	6 3 5 6 7 8 11

输出样例：

7 6

7 6

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Scanner;
import java.util.TreeSet;

public class Main {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int k = in.nextInt();
		int[] n = new int[k];
		TreeSet[] treeSets = new TreeSet[k];
		for (int i = 0; i < k; i++) {
			n[i] = in.nextInt();
			treeSets[i] = new TreeSet<Integer>(getNumber(n[i]));
		}
		in.close();
		
		LinkedList<Integer> list = new LinkedList<Integer>();
		for (int i = 0; i < k; i++) {
			if (isMajor(n[i], treeSets, i)) {
				list.add(n[i]);
			}
		}
		
		int[] array = new int[list.size()];
		for (int i = 0; i < array.length; i++) {
			array[i] = list.get(i);
		}
		
		Arrays.sort(array);
		
		for (int i = array.length - 1; i > 0; i--) {
			System.out.print(array[i] + " ");
		}
		System.out.print(array[0]);
	}
	
	public static boolean isMajor(int n, TreeSet[] treeSets, int index) {
		for (int i = 0; i < treeSets.length; i++) {
			if (i != index && treeSets[i].contains(n)) {
				return false;
			}
		}
		return true;
	}
	public static TreeSet<Integer> getNumber(int n) {
		TreeSet<Integer> treeSet = new TreeSet<Integer>();
		treeSet.add(n);
		while (n != 1) {
			if (n % 2 == 0) {
				n = n / 2;
			} else {
				
				n = (3 * n + 1) / 2;
			}
			
			treeSet.add(n);
		}
		return treeSet;
	}
}

import java.util.Arrays;

import java.util.LinkedList;

import java.util.Scanner;

import java.util.TreeSet;

public class Main {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

int k = in.nextInt();

int[] n = new int[k];

TreeSet[] treeSets = new TreeSet[k];

for (int i = 0; i < k; i++) {

n[i] = in.nextInt();

treeSets[i] = new TreeSet<Integer>(getNumber(n[i]));

}

in.close();

LinkedList<Integer> list = new LinkedList<Integer>();

for (int i = 0; i < k; i++) {

if (isMajor(n[i], treeSets, i)) {

list.add(n[i]);

}

int[] array = new int[list.size()];

for (int i = 0; i < array.length; i++) {

array[i] = list.get(i);

}

Arrays.sort(array);

for (int i = array.length - 1; i > 0; i--) {

System.out.print(array[i] + " ");

}

System.out.print(array[0]);

}

public static boolean isMajor(int n, TreeSet[] treeSets, int index) {

for (int i = 0; i < treeSets.length; i++) {

if (i != index && treeSets[i].contains(n)) {

return false;

}

return true;

}

public static TreeSet<Integer> getNumber(int n) {

TreeSet<Integer> treeSet = new TreeSet<Integer>();

treeSet.add(n);

while (n != 1) {

if (n % 2 == 0) {

n = n / 2;

} else {

n = (3 * n + 1) / 2;

}

treeSet.add(n);

}

return treeSet;

}

PAT 乙级 1002. 写出这个数 (20) Java版

读入一个自然数n，计算其各位数字之和，用汉语拼音写出和的每一位数字。

输入格式：每个测试输入包含1个测试用例，即给出自然数n的值。这里保证n小于10¹⁰⁰。

输出格式：在一行内输出n的各位数字之和的每一位，拼音数字间有1 空格，但一行中最后一个拼音数字后没有空格。

输入样例：

1234567890987654321123456789

1	1234567890987654321123456789

输出样例：

yi san wu

yi san wu

import java.util.*;
public class Main {
public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    String n = in.nextLine();
    in.close();

    int sum = 0;
    for (int i = 0; i < n.length(); i++) {
      sum += n.charAt(i) - '0';
    }

    Stack<String> stack = new Stack<>();
    String[] s = {"ling", "yi", "er", "san", "si", "wu", "liu", "qi", "ba", "jiu"};
    do {
      stack.push(s[sum % 10]);
      sum /= 10;
    } while (sum != 0);

    System.out.print(stack.pop());
    while (!stack.isEmpty()) {
      System.out.print(" " + stack.pop());
    }
  }
}

import java.util.*;

public class Main {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

String n = in.nextLine();

in.close();

int sum = 0;

for (int i = 0; i < n.length(); i++) {

sum += n.charAt(i) - '0';

}

Stack<String> stack = new Stack<>();

String[] s = {"ling", "yi", "er", "san", "si", "wu", "liu", "qi", "ba", "jiu"};

do {

stack.push(s[sum % 10]);

sum /= 10;

} while (sum != 0);

System.out.print(stack.pop());

while (!stack.isEmpty()) {

System.out.print(" " + stack.pop());

}