Question

这个程序的目的是返回一个＆＃34;分形序列＆＃34;直到某个数字，n。这听起来很奇特，但所有这意味着，如果，比方说，n = 4，那么它将返回：1 1 2 1 2 3 1 2 3 4.（它只计数到1，然后是2，然后是3，然后是4 ，并在它到达时返回每一步。）为了更容易看到：1 12 123 1234.

该方法名为＆＃34; foo＆＃34;，主方法必须打印。因此，main方法通过执行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 2 3 1 2 3 4 1 2 3 4 。

问题在于它最后打印出一组额外的1 2 3 4。我意识到它之所以这样做是因为System.out.print打印出我需要的所有内容，但是主方法中的额外System.out.print（foo（4））正在打印出来最后的额外1 2 3 4。

如果在main方法中，我刚刚取出System.out.print，并且只写了foo（4）;这很容易解决。但是，就像规则（1）所说，主要方法必须有印刷品。我不允许编辑foo方法之外的任何内容。

我尝试了很多不同的东西（现在大约7个小时左右），但我似乎并没有＆＃34;得到它＆＃34;。有人可以说明我出错的地方吗？

真诚地感谢你！

Answer 1

将方法更改为：

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;
}

[编辑]：

说明：

我们需要的是累加器。然而，只使用foo（n-1）+ n将只给出序列12345.所以我们需要得到n-1序列的最后一部分来得到完整的1 12 123 1234 ...我还没有测试过这个代码，也许你需要使用foo.substring（foo.length - n，foo.length），但我认为n-1应该是正确的。这只是检索最后一个序列（123123中的123）。

我改变了界限，因为我忘记了空间。

有空间：

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

没有空间：

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

[编辑2]

没有为值n＆gt;工作10，新版本使用foo（n-2）来计算子字符串。请注意，这会更改复杂性类别。更好的版本可以是迭代的并使用动态编程，或使用整数列表而不是字符串。

Answer 2

我首先想到了一个迭代解决方案。

//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();
}

这依赖于2个嵌套循环这一事实向我表明，仅使用单个方法并且没有循环就不可能生成递归解决方案。因此，我必须在递归中包含一个循环来构建各个部分。

//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 + " ";
}

当用4调用时，这两个产生相同的输出，所以我的主要方法是：

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

生成此输出：

1 12 123 1234

1 12 123 1234

Answer 3

这应该有效：

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;
    }
}

Answer 4

现在您正在打印递归的结果以及每个步骤。结果是＆＃34; 1 2 3 4＆＃34;你得到这个加倍。

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);会得到你想要的结果

将分形序列（1 12 123 1234 ...）作为字符串返回的方法，但最后一个序列打印两次。（JAVA）

4 个答案:

将分形序列（1 12 123 1234 ...）作为字符串返回的方法，但最后一个序列打印两次。 （JAVA）

4 个答案:

将分形序列（1 12 123 1234 ...）作为字符串返回的方法，但最后一个序列打印两次。（JAVA）