这个Java程序使用迭代将自然数转换为集合论编码。请求递归解决方案的帮助/策略？

我试图更好地理解ZFC集合论，特别是计算机程序如何对无限公理进行建模以“构造”自然数。我见过的用于构造自然数的典型符号是：“{”、“}”和“，”

下面的代码可以工作，但我希望有一个纯粹的递归解决方案。给定一个自然数（这里使用int），递归地将相应的字符串构建到其集合论编码中，然后返回它。理想情况下，我希望它能够在不使用任何额外数据结构（如当前使用的字符串数组）的情况下工作。

如果运行时很慢（指数级），则可以。使用递归有时会使流程的表达式更简单、更简洁/优雅、更容易理解，我非常希望看到这样的解决方案会是什么样子，而不管性能如何。最后，我想更好地理解数学/数字的基础。我有很多问题，但我认为这可能是一个好的开始。谢谢

// Converts an natural number to its ZFC set notation: 
// 0 = {}, 1 = {0} = {{}}, 2 = {0,1} = {{},{{}}},  
// 3 = {0,1,2} = {{},{{}},{{},{{}}}} ...    

import java.util.Scanner;

public class IntToSetNotation {
    private static final String openBrace = "{";
    private static final String closeBrace = "}";
    private static final String seperator = ",";

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        System.out.println(getSetNotationFromInt(n));
    }

    private static String getSetNotationFromInt(int n) {
        String[] nums = new String[n+1];
        nums[0] = openBrace + closeBrace;
        for (int i = 1; i < nums.length; i++) {
            if(i == nums.length-1)
                nums[i] = openBrace + getPrevSets(i,nums) + closeBrace;
            else
                nums[i] = seperator + openBrace + getPrevSets(i,nums) + closeBrace;
        }
        return nums[n];
    }

    private static String getPrevSets(int n, String[] nums) {
        String s = "";
        for (int i = 0; i<n; i++)
            s += nums[i];
        return s;
    }
} 

//将自然数转换为其ZFC集合表示法：
// 0 = {}, 1 = {0} = {{}}, 2 = {0,1} = {{},{{}}},  
// 3 = {0,1,2} = {{},{{}},{{},{{}}}} ...    
导入java.util.Scanner；
公共类IntToSetNotation{
私有静态最终字符串openBrace=“{”；
私有静态最终字符串closeBrace=“}”；
专用静态最终字符串分隔符=“，”；
公共静态void main（字符串[]args）{
扫描仪输入=新扫描仪（System.in）；
int n=input.nextInt（）；
System.out.println（getSetNotationFromInt（n））；
}
私有静态字符串getSetNotationFromInt（int n）{
字符串[]nums=新字符串[n+1]；
nums[0]=openBrace+closeBrace；
对于（int i=1；i对于（inti=0；i，递归听起来非常困难，但一旦你忘记了这个名字，它实际上有点简单

递归需要做很多事情：一个基本情况来停止递归，一个输出来做你想做的事情

假设您要编写一个递归问题，该问题包含一个数字x，并返回一个特定的花括号模式：

0==（无）

1=={}

2=={{}

3=={{}}


因此，递归方法将取一个整数

现在，让我们看看方法输出。如果我们在1上调用递归方法，我们希望返回{}.Easy。对于java，我们将返回一个字符串

很好，现在我们知道了方法的返回类型

如果我们在2上调用recursive method，我们希望该方法首先输出{}，然后我们希望该方法再次执行，但这一次，我们在开始处放置一个卷曲，在结束处放置一个卷曲

这是很难解释的部分。将递归想象成一个循环。最终，我们希望递归终止。假设我们最初在3上调用该方法。我们希望返回{{}}。首先，我们的方法将返回{}，然后是{{}，然后是{{}。它总共运行3次

在递归调用中，必须比初始调用少调用一次

好，现在你说，如果我们每次减去1，然后再次调用这个方法，我们如何让它停止

如果方法是在0上调用的，我们不想返回任何东西，因此我们想用一个简单的return语句退出方法

把这个应用到你自己的问题上，你应该表现得很好

String exampleRecursiveMethod(int x){
 if(x==0)return "";
 else return exampleRecursiveMethod(x-1)
}

这是一个让您开始学习的示例。else之后的return语句被称为递归调用，我在上面讨论过它。
我提出了下面的代码作为递归解决方案。它是有效的，但我想知道是否有任何方法可以简化它，或者使用更少的方法？欢迎任何想法或评论

public class IntToSetNotationRecursive {
    private static final String openBrace = "{";
    private static final String closeBrace = "}";
    private static final String seperator = ",";

    public static void main(String[] args) {
        for (int i = 0; i < 6; i++) {
            System.out.println(i + " = " + getSetNotationFromInt(i));
        }
    }

    static String getSetNotationFromInt(int n){
        return helper1(n, n, "");
    }

    static String helper1(int n, int x, String s){
        if(x<=0)
            return openBrace + s + closeBrace;

        return helper1(n, x-1, helper2(x-1) + ((x != n ) ? seperator : "") + s);
    }

    static String helper2(int x){
        if(x<=0)return openBrace+closeBrace;
        else return helper1(x, x, "");
    }
}

公共类IntToSetNotationRecursive{
私有静态最终字符串openBrace=“{”；
私有静态最终字符串closeBrace=“}”；
专用静态最终字符串分隔符=“，”；
公共静态void main（字符串[]args）{
对于（int i=0；i<6；i++）{
System.out.println（i+“=”+getSetNotationFromInt（i））；
}
}
静态字符串getSetNotationFromInt（int n）{
返回helper1（n，n，“”）；
}
静态字符串帮助器1（整数n、整数x、字符串s）{
如果（x第二个助手方法是不必要的。这里是一个简短的版本

public class IntToSetNotationRecursive {
    private static final String openBrace = "{";
    private static final String closeBrace = "}";
    private static final String separator = ",";

    public static void main(String[] args) {
        for (int i = 0; i < 6; i++) {
            System.out.println(i + " = " + getSetNotationFromInt(i));
        }
    }

    static String getSetNotationFromInt(int n){
        return helper1(n, n, "");
    }

    static String helper1(int n, int x, String s){
        if(x<=0)
            return openBrace + s + closeBrace;

        return helper1(n, x-1, helper1(x-1,x-1,"") + ((x != n ) ? separator : "") + s);
    }
}

公共类IntToSetNotationRecursive{
私有静态最终字符串openBrace=“{”；
私有静态最终字符串closeBrace=“}”；
专用静态最终字符串分隔符=“，”；
公共静态void main（字符串[]args）{
对于（int i=0；i<6；i++）{
System.out.println（i+“=”+getSetNotationFromInt（i））；
}
}
静态字符串getSetNotationFromInt（int n）{
返回helper1（n，n，“”）；
}
静态字符串帮助器1（整数n、整数x、字符串s）{
if（xI）我投票结束这个问题，因为stackoverflow.com不是一个免费的编码服务。@patrickhule19谢谢，很好的提示。但是棘手的部分是从3->{{}}到3->{{}，{}，{}，{}，{}，{}，{}}，很难看到如何让递归以这种方式构建字符串。