在字符串中查找子序列：Java答案

【问题标题】：find subsequence in a string: Java在字符串中查找子序列：Java
【发布时间】：2018-06-19 03:53:30
【问题描述】：

我有一个字符串hackkkerrank，我必须查找是否有任何子序列 给出的结果为hackerrank，如果存在则它给出的结果为@ 987654327@ 否则NO。

示例：

hereiamstackerrank: YES
hackerworld: NO

我不知道应该应用哪个String 方法，谁能帮我怎么做？

这是我的代码：

static String hackerrankInString(String s) {
  char str[] = {
   'h','a','c','k','e','r','a','n','k'
  };
 while (s.length() >= 10) {
  for (int i = 0; i < s.length(); i++) {
   for (char c: str) {
    if (s.indexOf(c)) {
     System.out.println("YES");
    } else {
     System.out.println("NO");
    }
   }
  }
 }
}

【问题讨论】：

您是否要查找输入字符串是否包含 hackerrank ？如果是，那么这个没有意义：hereiamstackerrank: YES hackerworld: NO。请为您的问题添加更多详细信息。
另外你的代码有格式问题而且它也不完整，变量str也没有在任何地方声明。
“我不知道应该应用哪种字符串方法” 我建议length()和charAt(int)，但是你为什么不看一下all the methods在String的javadoc中列出来自己决定？
@AmithKumar 是的，我正在尝试查找子序列而不是子字符串。
hereiamstackerank 应该返回 YES 或 NO 吗？因为它只有一个r。

标签： java string algorithm data-structures

【解决方案1】：

这是一种内置方式，使用正则表达式：

String regex = "[^h]*+h[^a]*+a[^c]*+c[^k]*+k[^e]*+e[^r]*+r[^r]*+r[^a]*+a[^n]*+n[^k]*+k.*";
System.out.println("hereiamstackerrank".matches(regex) ? "YES" : "NO");
System.out.println("hackerworld".matches(regex) ? "YES" : "NO");

输出

YES
NO

您可以创建一个通用方法来检查子序列，如下所示：

public static boolean containsSubsequence(String subsequence, String text) {
    StringBuilder buf = new StringBuilder();
    for (int i = 0, j; i < subsequence.length(); i = j) {
        j = subsequence.offsetByCodePoints(i, 1);
        String ch = Pattern.quote(subsequence.substring(i, j));
        buf.append("[^").append(ch).append("]*+").append(ch);
    }
    String regex = buf.append(".*").toString();
    return text.matches(regex);
}

测试

System.out.println(containsSubsequence("hackerrank", "hereiamstackerrank") ? "YES" : "NO");
System.out.println(containsSubsequence("hackerrank", "hackerworld") ? "YES" : "NO");

输出

YES
NO

当然，效率不是很高，但这是一种方法。

对于不处理 Supplementary Planes 中的字符的更简单和更有效的解决方案，您可以这样做：

public static boolean containsSubsequence(String subsequence, String text) {
    int j = 0;
    for (int i = 0; i < text.length() && j < subsequence.length(); i++)
        if (text.charAt(i) == subsequence.charAt(j))
            j++;
    return (j == subsequence.length());
}

【讨论】：

我没有投反对票，但我发现正则表达式很难理解，例如，对于hack，我的正则表达式将只是.*h+.*a+.*c+.*k+.*
@PhamTrung 正则表达式针对最佳性能进行了优化，例如使用[^h]*+h 表示匹配直到并包括下一个h 的所有字符。它比.*h 更好，因为它会搜索到字符串的末尾，然后回溯直到找到h，尝试从那里匹配余数正则表达式，如果不匹配则回溯更多，等等。对性能不好。例如。使用您提供的正则表达式扫描xxhxxaxxcxxkxx 需要 40 步，但使用我的正则表达式只需 10 步。
很高兴知道解释，+1

【解决方案2】：

这是一种老式的循环方式，它根据找到最后一个字符的位置增加第二个字符串的起始位置

    String str1 = "hackerrank";
    String str2 = "hereiamstackerrank";

    int index = 0;

    for (int i = 0; i < str1.length(); i++) 
    {
        boolean notfound = true;
        int x = index;
        for (; x < str2.length(); x++) {
            if (str1.charAt(i) == str2.charAt(x)) {
                notfound = false;
                break;
            }
        }
        if (notfound) {
            System.out.println("NO");
            return;
        }
        index = x + 1;
    }
    System.out.println("YES");

一个低效的替代方案是

    for (int i = 0; str1.length() > 0 && i < str2.length(); i++) 
    {
        if (str1.charAt(0) == str2.charAt(i)) {
            str1 = str1.substring(1);
        }
    }
    System.out.println(str1.length() == 0 ? "YES" : "NO");

【讨论】：

如果您将外部循环更改为迭代 str2 并且仅在字符匹配时推进 str1，则不需要内部循环。
现在substring 复制了后备数组，这不是很有效，是吗？
根本没有效率，但我正确地认为你会在自己的答案中发表你的想法

【解决方案3】：

static String re="";
    static String hackerrankInString(String s) {
        String pattern="[^h]*+h[^a]*+a[^c]*+c[^k]*+k[^e]*+e[^r]*+r[^r]*+r[^a]*+a[^n]*+n[^k]*+k.*";
        if(s.matches(pattern)){
            re="YES";
        }else{
            re="NO";
        }
        return re;
    }

【讨论】：

拜托，当您在帖子中插入一些代码时，您必须将代码放在引号中

【解决方案4】：

核心库中没有内置函数来检查subsequence。 substring 有一个，但您正在寻找的 subsequence 没有。

您必须自己编写代码。

下面是这个的伪代码：

1. Traverse both original string and string under test. 
2. Increment both's counter if characters are equal
3. Else increment originalString's counter only.
4. Repeat 2-3 `while` both strings are `not` empty. 
5. Given string under test is subsequence if its counter is exhausted.

【讨论】：