Question

我想使用Java中的静态递归方法cleanString（String s）接受一个字母s的字符串并返回一个字符串，在该字符串中，相同的相邻字母被该字母的一次出现替换。该方法区分大小写。

例如：

cleanString("sensssaatiionnaallll!") -> "sensational!"                             

cleanString("PPProoggggraamm") -> "Program"

cleanString("Lletterriiing") -> "Lletering"

Answer 1

尝试一下：

public class Main {
    public static void main(String[] args) {
        System.out.println(cleanString("sensssaatiionnaallll!"));
    }
    static String cleanString(String input)
    {
        if(input.length()<1) //To stop infinite recursion
            return input;
        var first = input.charAt(0);
        var count = input.chars().takeWhile(x -> x == first).count();
        return first + cleanString(input.substring((int)count));
    }
}

首先，它检查字符串的长度是否小于1。如果是，则返回字符串本身（为空）并停止递归。
下一步获取字符串的第一个字符。（例如PPProoggggraamm -> P）
获取开头等于第一个字符的字符数（在PPProoggggraamm的情况下为3）
再次调用该函数，但这一次从上述步骤中取消前n个字符，并在第一个字符之前添加。（'P' + cleanString("rooggggraamm")）

Answer 2

它只是生成一个新的String并排除重复字符。

static String cleanString(String input) {
  if(input == null) return null;

  char lastChar = 0;
  StringBuilder output = new StringBuilder(input.length());
  for (int i=0,n=input.length(); i<n; i++) {
    char c = input.charAt(i);
    if(c != lastChar) {
      lastChar = c;
      output.append(c);
    }
  }

  return output.toString();
}

递归方法：

public class Example {
  public static int main(String[] args) {
    String input = "sensssaatiionnaallll";
    String output = cleanString(input, 0);
    System.out.println(output); // print: sensational
    return 0;
  }

  private static String cleanString(String input, int index) {
    if(input == null) return "";
        if(index >= input.length()) return "";

        StringBuilder output = new StringBuilder();

        char current = input.charAt(index);

        int nextIndex = index + 1;
        if(nextIndex >= input.length()) {
            return output.append(current).toString();
        }

        char next = input.charAt(nextIndex);

        if (current != next) {
            output.append(current);
        }

        output.append(cleanString(input, nextIndex));

        return output.toString();
  }
}

Answer 3

最短的递归代码可从输入字符串中删除相邻字符。

public class StackOverflow { 

static String cleanString(String input) {
    return input==null || input.length()<=1?input:cleanStringWrapper(input.substring(1),input.substring(0,1));
}

static String cleanStringWrapper(String input, String result) {
  if (input.length() - 1 <= 0) {
    return result+(result.charAt(result.length() - 1)!=input.charAt(0)?input:"");
} else {
    return cleanStringWrapper(input.substring(1), result+(result.charAt(result.length() - 1) != input.charAt(0)?input.charAt(0):""));
}
} 

 public static void main(String[] args) 
 {
     System.out.println(cleanString("OOPS"));
     } 
 }

输出：

cleanString（“ sensssaatiionnaallll！”）->“引起轰动！”

cleanString（“ PPProoggggraamm”）->“程序”

cleanString（“ Lletterriiing”）->“ Lletering”

cleanString（“ Gooooogle”）->“ Gogle”

cleanString（“ ABC”）->“ ABC”

cleanString（“ A”）->“ A”

cleanString（“”）->“”

cleanString（ null ）-> null

Answer 4

为什么要为此创建静态方法？

我知道，您希望从输入字符串中删除重复的字符。

您也可以在代码下面进行操作。

StringBuilder sb = new StringBuilder();
str.chars().distinct().forEach(c -> sb.append((char) c));

如果需要，可以将这2行的方法作为代码中的功能。

希望这会有所帮助！

如何用Java编写静态递归方法？

4 个答案: