[Java] 实验13

1. 分段函数

1. 用 if - else if - else, 可以表达这三个分支。

2. 保留小数

之所以用 Math.round() 去保留小数，而不是 * 100d / 100, 是因为后者无法处理负数的情况。具体可以参考实验5. 求一元二次方程的根

在此给出保留任意位小数的方法 remainDigits. 

大家应该理解下述原理，自行实现保留两位小数 或 保留任意位小数 的功能。

public class Test {
  public static void main(String[] args) {
    double num = 3.1415926535;
    for (int i = 0; i <= 10; ++ i) {
      System.out.println(remainDigits(num, i));
    }
  }

  static double remainDigits(double num, int digitsToRemain) {
    // e.g. remainDigits(3.14159, 2) was called, then it will return 
    // Math.round(3.14159 * 100d) / 100d, which equals 3.14
    return Math.round(num * Math.pow(10, digitsToRemain)) 
        / Math.pow(10, digitsToRemain);
  }
}

3. 对 System.out.println(double number) 的解释

用 println 输出一个 double 的时候，它总是会忽略这个数值的后导0.

    - 如果 number 的值是一个整数（比如 5.0000），因为它的类型是 double, 那么会输出 5.0;

    - 如果 number 的值是 5.1000, 在保留两位小数后，它会输出 5.1; 

    - 如果 number 的值是 5.1010, 在保留两位小数后，它会输出 5.1.

    - 如果 number 的值是 5.1050, 在保留两位小数后，它会输出 5.11.

这是应该是语法决定的，还望大家不要纠结。

大家只需要关注如何正确地保留两位小数即可。

代码：

public class Test {
  public static void main(String[] args) {
    System.out.println(remainDigits(5.0000, 2));  // Output 5.0
    System.out.println(remainDigits(5.1000, 2));  // Output 5.1
    System.out.println(remainDigits(5.1010, 2));  // Output 5.1
    System.out.println(remainDigits(5.1050, 2));  // Output 5.11
  }

  static double remainDigits(double num, int digitsToRemain) {
    // e.g. remainDigits(3.14159, 2) was called, then it will return 
    // Math.round(3.14159 * 100d) / 100d, which equals 3.14
    return Math.round(num * Math.pow(10, digitsToRemain)) 
        / Math.pow(10, digitsToRemain);
  }
}

2. 输入 2 个正整数 m 和 n, 输出 m 和 n 之间所有能被 7 或 11 整除,但不能被两者同时整除的数。

if ((num % 7 == 0 || num % 11 == 0) && num % 77 != 0) {
  // Print the result here
}

3. 计算近似的 PI

4. 输出从元旦到该日经过的天数

1. 闰年的定义参考 实验 8. 40035 计算某月的天数

2. 这题可以通过定义一个含有 12 个月份的天数的数组 int[] days = { ... }; 

注意，需要根据是否是闰年，修改数组的第 1 个元素；

譬如，求 1月1号 到 3月8号 有多少天，那么只需要从 days[0] + days[1] + 8 - 1 即可。

5. 给学生成绩排降序

排序方法可以参考实验12. 60030 编写排序函数（方法）

在此我假设学生学号为 String 类型，学生成绩为 double 类型。我们要做的是：

    1. 维护两个数组：学号数组 ids 和成绩数组 grades，该数组满足学生 ids[index] 对应的成绩即为 grades[index]. 亦即通过相同的下标，建立学号和成绩的一一对应关系。

    2. 在给成绩降序排序的同时，维护这个一一对应关系：如果在成绩数组中交换了元素 grades[i] 和 grades[j]. 那么我们也在学号数组中，交换 ids[i] 和 ids[j].

假设题目输入满足下列格式：

3
3150100001 86.5
3150100002 88.5
3150100003 87.5

我们的程序可以写成：

// Assume the input has the format like this:
// student_number
// student1_id grade
// student2_id grade
// ...

import java.util.Scanner;

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

    // Input
    int studentNumber = in.nextInt();
    // Use "String" instead of "int" to represent the student ID,
    // in case it might larger than the maximal value "int" can hold
    String[] ids = new String[studentNumber];
    // Use "double" to represent the student grade
    // in case it might be a floating-point instead of an integer.
    double[] grades = new double[studentNumber];
    for (int i = 0; i < studentNumber; ++ i) {
      ids[i] = in.next();  // Input String
      grades[i] = in.nextDouble();  // Input double
    }

    // Bubble sort
    bubbleSort(ids, grades);

    // Output
    for (String id: ids)
      System.out.println(id);
  }

  static void bubbleSort(String[] ids, double[] grades) {
    for (int i = 1; i < grades.length; ++ i) {
      for (int j = i; j >= 1; -- j) {
        if (grades[j] > grades[j - 1]) {
          swap(grades, j, j -1);
          swap(ids, j, j - 1);
        }
      }
    }
  }

  // Note that we could use the "generic" property to implement ONLY ONE
  // swap method here, while this property is beyond your course requirement.

  static void swap(String[] ids, int i, int j) {
    String temp = ids[i];
    ids[i] = ids[j];
    ids[j] = temp;
  }

  static void swap(double[] grades, int i, int j) {
    double temp = grades[i];
    grades[i] = grades[j];
    grades[j] = temp;
  }
}

6. 计算最大数的出现次数

for (int x = in.nextInt(); x != 0; x = in.nextInt()) {
  // Do your statistics here.
}

7. 回文素数

在此没有引入 String 类，这样使得要解决这题，不需要依赖（记住）其他方法 (method), 只依赖更为基础的编程知识。

我们可以通过下述方法，判断一个数，比如说数字 32123 是否为回文：

    - 通过 32123 / 10000, 取最左边的数字 3, 通过 32123 % 10 取最右边的数字 3. 比较这两个数字是否相同

    - 拿掉最左边和最右边的数字 3，数字变成 212. 通过 212 / 100, 取最左边的数字 2, 通过 212 % 10 取最右边的数字 2. 比较这两个数字是否相同

    - 拿掉最左边和最右边的数字 2，数字变成 1. 所以这是一个回文数。

public class PalindromicPrime {
  public static void main(String[] args) {
    for (int i = 2, count = 0; count < 50; ++ i)
      if (prime(i) && palindrome(i)) {
        System.out.print(i + " " 
          + (++ count % 10 == 0? "\n": ""));
      }
  }
  
  // Determine whether a number is prime or not
  static boolean prime(int num) {
    for (int i = 2; i <= Math.sqrt(num); ++ i)
      if (num % i == 0)
        return false;
    return true;
  }

  // Determine whether a number is palindromic or not
  static boolean palindrome(int num) {
    int digitNum = 1;
    for (int temp = num / 10; temp != 0; temp /= 10)
      ++ digitNum;
    // Thus num has # of digitNum digits
    // e.g. Number 0 has 1 digit, digitNum = 1
    //      Number 52 has 2 digits, digitNum = 2
    //      Number 123 has 3 digits, digitNum = 3
    while (digitNum > 1) {
      int leftmostDigit = (int) (num / Math.pow(10, digitNum - 1));
      int rightmostDigit = num % 10;
      if (leftmostDigit != rightmostDigit)
        return false;
      num =  (num % (int)Math.pow(10, digitNum - 1)) / 10;
      digitNum = digitNum - 2;
    }
    return true;
  }
}

9. 显示素数因子

public class PrimeFactor {
  public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    int num = in.nextInt();
    for (int i = num; i != 1; -- i)
      if (prime(i))
        for (; num % i == 0; num /= i)
          System.out.print(i + " ");        
    in.close();
  }
  
  // Determine whether a number is prime or not  
  static boolean prime(int num) {  
    for (int i = 2; i <= Math.sqrt(num); ++ i)  
      if (num % i == 0)  
        return false;  
    return true;  
  }    
}

10. 统计在字符串中每个数字出现的次数

1. int 数组中每个元素的默认值是 0, 原因可以参考 实验5. Q10

2. 代码：

public static int[] count(String s) {
  int[] res = new int[10];
  for (int i = 0; i < s.length(); ++ i)
    if (s.charAt(i) >= '0' && s.charAt(i) <= '9')
      ++ res[s.charAt(i) - '0'];
  return res;
}

13. 计算两个日期间的天数，并以二进制形式输出

在此我们把问题简化为：

    - 计算给定 year1, yaer2 中间那些年份的日期 days1

    - 计算 year1/month1/day1 到年终的那段日期 days2

    - 计算 year2/month2/day2 距离该年元旦已经过的日期 days3

days1 + days2 + days3 即为所得。

注意到，上述方法可以处理所有情况。

import java.util.Scanner;

public class Days {
  public static void main(String[] args) {
    // Input
    Scanner in = new Scanner(System.in);
    int year1 = in.nextInt();
    int month1 = in.nextInt();
    int day1 = in.nextInt();
    int year2 = in.nextInt();
    int month2 = in.nextInt();
    int day2 = in.nextInt();
    in.close();
    
    // Begin calculation
    int sum = 0;
    
    if (year1 != year2) {
      // Days between [(year1+1)/01/01, (year2-1)/12/lastDay]
      for (int i = year1 + 1; i < year2; ++i)
        sum += leapYear(i) ? 366 : 365;
      // Days between [year1/month1/day1, year1/12/lastDay]
      sum += (leapYear(year1) ? 366 : 365) - (days(year1, month1, day1) - 1);      
      // Days between [year2/01/01, year2/month2/day2]
      sum += days(year2, month2, day2);
    } else {
      sum = days(year2, month2, day2) - days(year1, month1, day1) + 1;
    }
    
    // Output the result
    decToBin(sum);
  }

  private static boolean leapYear(int year) {
    return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0);
  }

  // Days between [year/01/01, year/month/day]
  // i.e. days(2016, 03, 01) = 31 + 29 + 1 = 61
  private static int days(int year, int month, int day) {
    int sum = 0;
    int[] daysInMonth = { 31, leapYear(year) ? 29 : 28, 31, 30, 31, 30, 31, 31,
        30, 31, 30, 31 };
    for (int i = 0; i < month - 1; ++i)
      sum += daysInMonth[i];
    return sum + day;
  }
  
  // Note that we're going to solve this problem recursively (递归地解决问题)  
  // Decimal to binary  
  private static void decToBin(int n) {  
    if (n != 0) {  
      // Print the higher bit first  
      decToBin(n >> 1);  
      // Then print the lower bit  
      System.out.print(n % 2);  
    }  
  }  
}

14. 数字加密

a. 学习简单的数字加密有什么用？

学习数字加密，我们可以比较好的保护自己的信息安全：

    - 对于每个网站，我们的密码可以由 公共前缀(prefix) + 特殊后缀(postfix) 组成

    - 我们对后缀进行加密，得到新的字符串 prefix + encrypt(postfix), 将它作为我们的密码。

    - 而在记录本中，我们只记录自己的 prefix 和 postfix. 

由于加密算法由我们唯一拥有，所以即使这个记录本被别人拿走了，他们仍然无法猜出我们的密码；

不仅如此，我们的每个网站都有着唯一的密码 （你们的助教就是这么做的；）

b. 回到原题

代码如下：

import java.util.Scanner;

public class Encrption {
  public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    String num1 = in.next();
    String num2 = in.next();
    String result = "";
    char[] table = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'J', 'Q',
        'K' };
    int i = num1.length() - 1, j = num2.length() - 1;    
    for (boolean isOdd = true; i >= 0 && j >= 0; -- i, -- j, isOdd = !isOdd) {
      if (isOdd) {
        int num = (num1.charAt(i) - '0' + num2.charAt(j) - '0') % 13;
        result = table[num] + result;
      } else {
        int num = num2.charAt(j) - num1.charAt(i);
        num = num > 0? num: num + 10;
        result = table[num] + result;
      }
    }
    for (; j >= 0; -- j) result = table[num2.charAt(j) - '0'] + result;
    System.out.println(result);
    in.close();
  }
}

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------

一下题目为 10.77.30.33 网上的实验 13, 应该是不要求完成的。

70001 

参考《Java语言程序设计--基础篇》：

    - 8.1 引言

    - 8.2 定义对象的类。简单描述了语法规则

    - 8.3 举例：定义类和创建对象。以 Circle 为例。

代码填空：

import java.util.*;

public class CircleTest {
  public static void main(String args[]) {
    Scanner in = new Scanner(System.in);
    int repeat= in.nextInt();
    while (repeat-- != 0) {
      float radius = in.nextFloat();
      Circle cir = new Circle();
      cir.setRadius(radius);
      System.out.println(Math.round(cir.area()));
      System.out.println(Math.round(cir.perimeter()));
    }
    in.close();
  }  
}

class Circle {  
  void setRadius(float radius) {
    radius_ = radius;
  }
  
  // According to the problem specification, the type of the return value 
  // should be double
  double area() {
    ?
  }

  // According to the problem specification, the type of the return value 
  // should be double
  double perimeter() {
    ?
  }
  
  float radius_;
}

70002 设计一个立方体类

基础和代码参考 70001. 

同时注意到，我们在此不像 70001 那样，编写一个 CircleTest 放 main, 另一个 Circle 类放其他方法。事实上，我们只需要一个 Cube 就可以完成题目要求。（70001 也只需要一个 Circle 类，也是可以完成要求——只要把 public static void main 也放进 Circle 中即可）

代码填空：

import java.util.Scanner;

public class Cube {
  public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    double length = in.nextDouble();
    System.out.println("Length=" + cube1.getLength());
    System.out.println("Surface area=" + cube1.calcArea());
    System.out.println("Volume=" + cube1.calcV());
  }
  
  ? setLength(?) {
    ?
  }
  
  ? getLength(?) {
    ?
  }
  
  // Define your calcArea here
  ?
      
  // Define your calcVolume here
  ?
  
  double length_;
}

70011 设计一个Circle的子类——圆柱体Cylinder

参考《Java语言程序设计--基础篇》，第 11 章 继承和多态：

    - 11.1 引言

    - 11.2 父类和子类。给出了父类与子类的图例，同时给出了相应的代码实现。

程序填空：

import java.util.Scanner;

public class CylinderTest {
  public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    double x = in.nextDouble();
    double y = in.nextDouble();
    double r = in.nextDouble();
    double h = in.nextDouble();
    // Note that we just ignore the x, y, whose reason has been explained 
    // in line 21.
    Cylinder cy = new Cylinder(r, h);
    System.out.println("r=" + cy.getRadius());
    System.out.println("h=" + cy.getHeight());
    System.out.println("V=" + Math.round(cy.calcVolume() * 100) / 100.);
    System.out.println("S=" + Math.round(cy.calcArea() * 100) / 100.);
  }
}

class Circle {
  // The reason we abandon x, y here is we are NOT gonna use them actually
  public Circle(double r) {
    // Thus for a circle, the only information needed to remain is its radius
    this.radius_ = r;
  }

  // Calculate the perimeter for this circle
  public double perimeter() {
    return 2 * Math.PI * radius_;
  }

  // Calculate the area for this circle
  public double area() {
    return Math.PI * radius_ * radius_;
  }

  public double getRadius() {
    return radius_;
  }

  private double radius_;
}

class Cylinder extends Circle {
  Cylinder(double radius, double height) {
    // Call its parent's constructor, Circle(radius), by calling super(radius)
    super(radius);
    // Initialize its own filed
    height_ = height;
  }

  // Define your calcArea here
  ?
      
  // Define your calcVolumn here
  ?

  // Define your getHeight here
  ?

  private double height_;
}

70012 编写重载方法，求二个数或三个数的最大值

import java.util.Scanner;

public class CompareTest {
  public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    int repeat = in.nextInt();
    while (repeat-- != 0) {
      int a = in.nextInt();
      int b = in.nextInt();
      int c = in.nextInt();
      System.out.println("max(a,b)=" + Compare.max(a, b));
      System.out.println("max(a,b,c)=" + Compare.max(a, b, c));
    }
    in.close();
  }
}

class Compare {
  static int max(int a, int b) {
    ?
  }
  
  static int max(int a, int b, int c) {
    ?
  }
}