Java 方法以字符串形式返回分形序列（1121234…），但最后一个序列打印两次。（爪哇）

这个程序的要点是返回一个“分形序列”，直到某个数字n。这听起来很奇怪，但它的意思是，如果，比如说，n=4，那么它将返回：1 1 2 1 2 3 1 3 4。（它只是先数到1，再数到2，再数到3，再数到4，然后在到达时返回每个步骤。）为了更容易查看：1121234

该方法称为“foo”，主方法必须打印它。因此，main方法通过go System.out.print（foo（4））调用它

foo方法必须返回字符串

循环可能出现在foo方法中，但练习的重点是递归地解决问题，因此大部分工作都应该以递归为特征。否则，使用一些for循环会容易得多

public class test{
  public static void main(String args[]){

    System.out.print(foo(4));

  }
  public static String foo(int n){

    String s = "";


    if(n == 1){               //Base step of the recursion
      s = 1 + " ";
    }
    else{
      s = foo(n-1) + n + " "; //Recursive step of the recursion    
    }
    System.out.print(s);      
    return s;

  }
}

现在，程序将打印的是1 1 2 1 3 2 3 41 2 3 4

问题是它在最后打印出一套额外的1234。我意识到它这样做的原因是因为System.out.print（s）打印出我需要的所有内容，但是主方法中额外的System.out.print（foo（4））在最后打印出额外的1234

如果在main方法中，我只取出System.out.print，然后只写foo（4）；，那么这个问题很容易解决；。但是，正如规则（1）所说，主方法必须具有打印。不允许我编辑foo方法之外的任何内容

我已经尝试了很多不同的东西（大约7个小时了），但我似乎没有“明白”。有人能告诉我哪里出了问题吗

衷心感谢

将方法更改为：

public static String foo(int n){
    String s = "";


    if( n <= 0 ) {       //Base step of the recursion
        s = "";
    }
    else {
        String foo = foo(n-1);
        s = foo + foo.substring(foo(n-2).length(), foo.length() -1) + n + " "; //Recursive step of the recursion    
    }
    return s;
}

没有空间：

  s = foo + foo.substring(foo.length()- (n-1), foo.length()) + n; 

[编辑2]

值n>10时不起作用，新版本使用foo（n-2）来计算子字符串。请注意，这会使复杂性类别变得更糟。更好的版本要么是迭代式的，使用动态规划，要么使用整数列表而不是字符串。

这应该可以：

pulic class test {
    public static void main(String args[]) {
        System.out.print(foo(4));
    }

    public static String foo(int n) {
        String s = "";

        if(n == 0) {    //do nothing      
        }
        else {
            s = foo(n-1);
            System.out.print(s);
            s=s+n;
        }      
        return s;
    }
}

---

我首先想到了这个问题的迭代解决方案

//Iterative Solution
public static String bar(final int n){
    final StringBuilder builder = new StringBuilder();
    for (int i = 1; i <= n ; i++) {
        for (int j = 1; j <= i ; j++) {
            builder.append(j);
        }
        builder.append(" ");
    }
    return builder.toString();
}

生成此输出：

1121234

1121234

---

现在，您正在打印递归的结果以及每个步骤。结果是“1 2 3 4”，你会得到双倍的收益

1       for `System.out.print(s);` on step 1
1 2     for `System.out.print(s);` on step 2
1 2 3   for `System.out.print(s);` on step 3
1 2 3 4 for `System.out.print(s);` on step 4

1 2 3 4 for `System.out.print(foo(4));`

---

所以调用

foo（4）将得到您想要的结果
，然后在foo方法中查看如何消除打印，看看是否可以从中获得。请学习如何阅读和解决家庭作业。您已声明不应在函数中打印任何内容，并且没有尝试从函数中删除打印内容？这是否正确！？我尝试时得到的输出是：
1234
不幸的是，我得到了与@DanTemple相同的输出。但子串似乎是一个不错的策略；我只是不确定我是如何实现它的，而且我以前从未使用过子字符串。到目前为止，我们被允许使用的方法是相当基本的@但丁：我忘了解释空间，我纠正了我的错误answer@kutschkem您是否尝试过将此值设置为11或更高？10之后的分形序列似乎缺少开头的值。@DanTemple不，我根本没有尝试过这段代码。但是，当我们达到11或更高时，它就崩溃了，这是有道理的，因为数字使用了字符串的两个字符。如果使用整数列表而不是字符串，并在main方法中打印数字而不是在函数中处理字符串，则可以解决此问题。这比找出需要使用的子字符串要容易得多。我想到了这一点，但仍然没有给出正确的答案。谢谢。我刚试过“s=foo（n-1）+foo（n-1）+n+”；”正如您所建议的，作为递归步骤，输出如下：1 1 2 1 3 1 2 1 3 4。它确实消除了双重打印的问题，但是序列现在有一些不需要的数字。也许我的递归步骤是错误的（因为你离得更近了）。正如OP刚才所说的，你在输出中得到了很多额外的1。现在检查解决方案，不幸的是，我现在没有编译器。是的，除了没有空格之外，现在看起来是正确的。谢谢。我在原稿中碰巧注意到了这一点，主要问题是我不允许在main中删除System.out.print，只需单独调用foo（4）。我希望我能！
//Recursive Solution (with some iteration too)
public static String foo(final int n) {
    if( n == 1 ) {
        return 1 + " ";
    }

    String s = "";
    for (int i = 1; i <= n; i++) {
        s += i;
    }

    return foo(n-1) + s + " ";
}

public static void main(final String args[]){
    System.out.println(bar(4));
    System.out.println(foo(4));
}

1       for `System.out.print(s);` on step 1
1 2     for `System.out.print(s);` on step 2
1 2 3   for `System.out.print(s);` on step 3
1 2 3 4 for `System.out.print(s);` on step 4

1 2 3 4 for `System.out.print(foo(4));`