【JAVA】（vip）蓝桥杯试题 基础练习 Sine之舞 BASIC-21 JAVA_java蓝桥杯方法的重载编写静态比较两个参数的大小

试题 基础练习 Sine之舞

资源限制
时间限制：1.0s 内存限制：512.0MB

问题描述
　　最近FJ为他的奶牛们开设了数学分析课，FJ知道若要学好这门课，必须有一个好的三角函数基本功。所以他准备和奶牛们做一个“Sine之舞”的游戏，寓教于乐，提高奶牛们的计算能力。
　　不妨设
　　An=sin(1–sin(2+sin(3–sin(4+…sin(n))…)
　　Sn=(…(A1+n)A2+n-1)A3+…+2)An+1
　　FJ想让奶牛们计算Sn的值，请你帮助FJ打印出Sn的完整表达式，以方便奶牛们做题。

输入格式
　　仅有一个数：N<201。

输出格式
　　请输出相应的表达式Sn，以一个换行符结束。输出中不得含有多余的空格或换行、回车符。

样例输入
3

样例输出
((sin(1)+3)sin(1–sin(2))+2)sin(1–sin(2+sin(3)))+1

额外知识

如何减少Java方法的参数？如何让Java 方法支持默认的参数值？

1. 方法一：通过方法的重载来间接地减少参数个数，通过方法的重载间接地支持默认的参数值，

   //递归An1
   //通过方法的重载
   //1.将An1的参数由两个变成一个
   //2.使An1支持默认的参数值
   public static String An1(int n) {
   	return An1(n, 1);
   }
   
   //递归An 索引i从小到大 以i记录当前递归的位置
   public static String An1(int n, int i) {
   	//。。。。
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12

2. 方法二：使用工厂模式。当方法的参数太多时，方法的重载这种方法就不适合了

思路一：递推

递推对应An和Sn

思路二：递归

递归对应An1和Sn1
思路二的要点：

1. 递归需要设置一个索引，表示递归的位置，本代码里以i表示，i从大到小还是从小到大很重要，

   //递归An 索引i从小到大 以i记录当前递归的位置
   public static String An1(int n, int i) {
   1
   2

   //递归Sn 索引i从大到小 以i记录当前递归的位置
   public static String Sn1(int n, int i) {
   1
   2

本题代码：

我将递推和递归写到了一个java文件里，你们可以自己搭配，一共四种方法，An+Sn（递推+递推），An+Sn1（递推+递归），An1+Sn（递归+递推），An1+Sn1（递归加递归）

import java.util.Scanner;

public class DanceOfSine2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.close();
        System.out.println(Sn(n));
        //或 输出Sn1 System.out.println(Sn1(n));
        /*检验代码
        for (int i = 1; i < 10; i++) {
            System.out.println(An(i));
            System.out.println(An1(i));
        }
        for (int i = 1; i < 10; i++) {
            System.out.println(Sn(i));
            System.out.println(Sn1(i));
        }*/
    }

    //递推An
    public static String An(int n) {
        StringBuilder str = new StringBuilder();
        for (int i = 1; i <= n; i++) {
            str.append("sin(").append(i);
            if (i % 2 == 1 && i != n) {
                str.append("-");
            } else if (i % 2 == 0 && i != n) {
                str.append("+");
            }
        }
        for (int i = 1; i <= n; i++) {
            str.append(")");
        }
        return str.toString();
    }

    //递归An1 
    //通过方法的重载
    //1.将An1的参数由两个变成一个
    //2.使An1支持默认的参数值
    public static String An1(int n) {
        return An1(n, 1);
    }

    //递归An 索引i从小到大 以i记录当前递归的位置
    public static String An1(int n, int i) {
        if (i == n) {
            return "sin(" + i + ")";
        }
        String operater = "-";
        if (i % 2 == 0) {
            operater = "+";
        }
        return "sin(" + i + operater + An1(n, i + 1) + ")";
    }

    //递推Sn
    public static String Sn(int n) {
        StringBuilder str = new StringBuilder();
        for (int i = 1; i < n; i++) {
            str.append("(");
        }
        for (int i = 1; i <= n; i++) {
            if (i != n) {
                str.append(An(i)).append("+").append(n - i + 1).append(")");
            } else {
                str.append(An(i)).append("+").append(n - i + 1);
            }
        }
        return str.toString();
    }

    //递归Sn 
    //通过方法的重载
    //1.将Sn1的参数由两个变成一个
    //2.使Sn1支持默认的参数值
    public static String Sn1(int n) {
        return Sn1(n, n);
    }

    //递归Sn 索引i从大到小 以i记录当前递归的位置
    public static String Sn1(int n, int i) {
        if (i == 1) {
            return An1(1) + "+" + n;
        }
        return "(" + Sn1(n, i - 1) + ")" + An1(i) + "+" + (n - i + 1);
    }

     /*//递归Sn 索引i从小到大 有很大的问题
    public static String Sn1(int n) {
        return Sn1(n, 1);
    }

    //递归Sn 索引i从小到大 有很大的问题
    public static String Sn1(int n, int i) {
        if (i == n) {
            return An1(n) + "+" + 1;
        }
        return "(" + An1(i) + "+" + (n - i + 1) + ")" + Sn1(n, i + 1);
    }*/
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102