CSP认证刷题【201903】

CSP认证刷题【201903】

201903-1【小中大】

思路

1. 由题可知数据一定是有序的，递增排序下第一个数是最小值，最后一个数是最大值；递减排序下第一个数是最大值，最后一个数是最小值。

2. 那么可以通过一个数组int[] a = new int[N]保存输入的数据，这样能够快速取得第一个数和最后一个数，方便取得最大值和最小值。

3. 中位数可以通过N/2得到位置，如果N是奇数，那么中位数为a[N/2]；如果N是偶数，中位数为(a[N/2]+a[N/2-1])/2.0，可以通过m%1==0判断是否为整数。

实现代码

import java.text.DecimalFormat;
import java.util.Scanner;

public class Main1 {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		int N = sc.nextInt();// 确定要输入N个数据
		int[] a = new int[N];// 保存N个数据

		// 输入N个数据
		for (int i = 0; i < N; i++) {
			a[i] = sc.nextInt();
		}

		sc.close();
		int b, s;
		b = s = 0;
		double m = 0;
		if (a[0] > a[N - 1]) {// 当数据是递减排序时
			b = a[0];
			s = a[N - 1];
		} else {// 当数据是递增排序时
			s = a[0];
			b = a[N - 1];
		}

		if (N % 2 == 1) {// 当N为奇数时
			m = a[N / 2];
		} else {// 当N为偶数时
			//需要除以2.0将int转成double
			m = (a[N / 2 - 1] + a[N / 2]) / 2.0;
		}
		System.out.println(m);
		// 判断中位数是否为整数
		if (m % 1 == 0) {// 中位数m为整数
			System.out.println(b + " " + (int) m + " " + s);
		} else {// 中位数m为小数，四舍五入保留1位小数
			DecimalFormat df = new DecimalFormat("#.0");
			System.out.println(b + " " + df.format(m) + " " + s);
		}
		
	}

}

201903-2【二十四点】

思路一

读题发现肯定是得操作字符串，使用StringBuffer。使用堆栈，利用其先进后出的特点可以较为简单实现算术运算。计算的时候需要注意乘除的优先级比加减要高，那就先将所有x和/运算算完，再进行+和-运算。

1. 进行两次for循环。
   1. 第一次for循环将数压栈，扫描到x和/时，将栈顶数据拿出来和后一位数据进行运算，将运算结果重新压栈；扫描到+时，直接将后一位数据压栈；扫描到-时，将后一位数据取反后再压栈。
   2. 第二次for循环将数据逐个出栈进行求和，得到最终结果。
2. 最终结果与24进行比较。

由于在定义堆栈时定义成字符串堆栈，需要在int和String之间不断转换，所以代码看起来比较繁琐。可以将堆栈定义为Stack<Integer> s = new Stack<Integer>()，将扫描出来的字符减去'0'可以得到相应的数据进行运算。

实现代码

import java.util.Scanner;
import java.util.Stack;

public class Main {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);
		
		int N = sc.nextInt();
		sc.nextLine();
		StringBuffer[] sb = new StringBuffer[N];
		for (int i = 0; i < N; i++) {
			sb[i] = new StringBuffer(sc.nextLine());// 保存算式
		}
		for (int i = 0; i < N; i++) {
			
			Stack<String> s = new Stack<String>();
			s.push(String.valueOf(sb[i].charAt(0)));
			int j = 1;
			while (j < 7) {
				if (String.valueOf(sb[i].charAt(j)).equals("x")) {
					int temp = Integer.parseInt(s.pop());
					int result = temp * Integer.parseInt(String.valueOf(sb[i].charAt(++j)));
					s.push(String.valueOf(result));
				} else if (String.valueOf(sb[i].charAt(j)).equals("/")) {
					int temp = Integer.parseInt(s.pop());
					int result = temp / Integer.parseInt(String.valueOf(sb[i].charAt(++j)));
					s.push(String.valueOf(result));
				} else if (String.valueOf(sb[i].charAt(j)).equals("+")) {
					s.push(String.valueOf(sb[i].charAt(++j)));
				} else if (String.valueOf(sb[i].charAt(j)).equals("-")) {
					s.push(String.valueOf(Integer.parseInt(String.valueOf(sb[i].charAt(++j)))*(-1)));
				} else {
					s.push(String.valueOf(sb[i].charAt(j)));
				}
				j++;
			}
			int result=0;
			while(!s.isEmpty()) {
				result+=Integer.parseInt(s.pop());
			}
			if(result==24) {
				System.out.println("Yes");
			}else {
				System.out.println("No");
			}
		}
		sc.close();

	}
}

思路二

将算式转换成后缀表达式，如：9+3+4x3转换成43x3+9+，然后再利用堆栈进行计算。

1. 将算式转换成后缀表达式，定义两个堆栈a,b，a用来保存数字，b用来保存运算符。再定义一个StringBuffer stringbuffer 保存后缀表达式。

   1. 遍历算式，遍历到数字直接压栈a，便利到运算符+或-直接压栈b。
   2. 当遍历到运算符x或/时，将a堆栈栈顶元素出栈，添加到stringbuffer（利用append()方法），运算符后面的一个数字也添加到stringbuffer，最后将运算符x或/添加到stringbuffer。【注：这三个元素的添加顺序不能调乱】
   3. 算式遍历完成后，判断此时的b堆栈是否为空，若不为空，按照运算符在先，数字在后的顺序，轮流将两个堆栈里的元素出栈添加到stringbuffer中。也就是运算符添加一个，数字添加一个，然后运算符再添加一个，如此反复至两个栈都为空。到此，算式已转换成后缀表达式保存在stringbuffer中。

2. 计算后缀表达式，定义一个堆栈c用来计算

   1. 遍历后缀表达式，数字直接压栈c，当遍历到运算符时，取出堆栈c里面最上面的两个数字，结合当前遍历到的运算符进行运算，然后将运算结果再重新压入栈c。

      如：后缀表达式a/b

      1）a入栈

      2）b入栈

      3）遍历到运算符/

      4）b出栈

      5）a出栈

      6）计算a/b得结果c

      7）c入栈

      【注：计算格式为a运算符b，也就是先入栈的元素，在拿出来运算时需要放在运算符的前面】

   2. 一直到遍历后缀表达式完成，此时堆栈c的栈顶元素就是该算式的运算结果。

实现代码

代码暂时先不实现，有兴趣的朋友可以自行实现。
或者可以底下留言提醒博主回来实现代码