Question

我开始学习Java，目前我正在玩递归。

我想尝试创建一个子串方法，它将从两边用1个字符子串，直到得到所需的字符串。

我成功完成了第一部分，但是我在查明如何从后面进行子串时遇到了问题。

n和m应该是我们想要子串（包括）的索引。

在此示例中，方法的结果应为“bstri”

这是我的代码：

public static void main(String[] args) {
    String s = "substringme";

    System.out.println(rec(s,2,6));
}

public static String rec(String s, int n, int m) {
    if(n == 0 /* && missing 2nd part of condition */){
        return s;
    } else {
        if(n>0){
            s = s.substring(1);
            n--;  
        }
        if(/* missing condition */){
            s= s.substring(0, s.length()-1);
        }
        return rec(s,n,m);
    }
}

我很感激能得到的任何帮助。

Answer 1

因此修复递归方法非常简单。我们的行为与n完全相同：

public static String rec(String s, int n, int m) {        
    if (n == 0 && m == 0) { 
        return s;
    }
    else {
        if(n > 0) {
            s = s.substring(1);
            n--;
        }
        if(m > 0) {
            s = s.substring(0, s.length()-1);
            m--;
        }
        return rec(s,n,m);
    }
}

现在的问题是，作为输入的m的值是从字符串的开头开始测量的，如果它是从字符串的末尾开始测量的话，对我们来说会更方便。

我们可以为我们引入一个新的方法，它作为递归方法的入口点：

public static String substr(String s, int n, int m) {
    final int newM = s.length() - m - 1; //-1 to be inclusive of the char
    return rec(s, n, newM);
}

然后，您可以更改主要方法来调用substr()：

public static void main(String[] args) {
    String s = "substringme";

    System.out.println(substr(s,2,6));
}

当我使用递归方法时，我经常发现自己正在编写这种“入口点”方法。如果您正确执行此操作，substr将是面向公众的方法，而rec将是私有的。

Answer 2

我建议您在第一个循环中执行export const { foo, bar } = { foo: 123, bar: 234, }，因为当您从前面缩短m--时，m作为索引的定义会发生变化。

Answer 3

你可以做的是寻找m和字符串长度之间的差异，并从字符串末尾剪切字符，直到它的长度正确。

import java.util.*;
public class Test {
    public static void main(String[] args) {
        String s = "substringme";
        System.out.println(rec(s,2,6));
    }

    public static String rec(String s, int n, int m) {
        if(n == 0 && s.length()-m < 1){
            return s;
        } else {

            if(s.length()-m > 1){
                s= s.substring(0, s.length()-1);
            }
            else if(n>0){
                s = s.substring(1);
                n--;  
            }
            return rec(s,n,m);
        }
    }
}

也不应该从2到6的子串是“bstr”，而不是“bstri”？

System.out.println(s.substring(2, 6)); //equals bstr

使用递归在2个索引之间的子串

3 个答案: