JAVA：比较字符串和子字符串

这就是我想要实现的目标。我正在尝试从两个给定的字符串中生成一个执行以下操作的代码：

target

和

source

//  Determines whether the string TARGET occurs as a substring of string SOURCE where "gaps" are allowed between characters of target.`
//  That is, the characters in TARGET occur in SOURCE in their given order but do not have to be adjacent.`
//  (Pictured another way, this method returns true if TARGET could be obtained from SOURCE by removing some of the letters of SOURCE.)`
//  This method is case sensitive. For example,`
//  containsWithGaps("hamburgers", "mug") returns true`
//  containsWithGaps("hamburgers", "burrs") returns true`
//  containsWithGaps("hamburgers", "hamburgers") returns true`
//  containsWithGaps("hamburgers", "gum") returns false`
//  containsWithGaps("hamburgers", "hamm") returns false`
//  containsWithGaps("hamburgers", "") returns true`
//  Parameters:`
//  SOURCE - the given string in which to find the target characters`
//  TARGET - the characters to be found`

//  Returns:`
//  true if the characters in TARGET can be found as a subsequence in SOURCE, false otherwise`

这是我写的代码。对于我认为不应该是一项困难的任务来说，这似乎过于复杂，但无论如何，我仍然会不断出错，如果给定一个源字符串<代码>汉堡和一个目标字符串<代码>毛刺，它将不起作用：

    public static boolean substringWithGaps(String source, String target) {

    boolean substring = false;
    int[] target_index;
    target_index = new int [target.length()];

    if (target.length() > source.length()) {
        substring = false;
    }
    else {
        for (int i = 0; i < target.length(); i++) {
            if (source.contains("" + target.charAt(i))) {           
                target_index[i] = target.indexOf(i);
                i++;
            }
            else {
                target_index[i] = target.indexOf(i);
                i++;
            }
        }
        for (int i = 0; i < target_index.length; i++) {
            if (target_index[i] == -1) {
                substring = false;
                break;
            }
            else if (target_index[i] >= target_index[i+1]) {
                substring = false;
                break;
            }
            else {
                substring = true;
            }
        if (target_index.length != target.length()) {
            substring = false;
            }
        }   
    }
    return substring;
}

public static boolean substringWithGaps（字符串源、字符串目标）{
布尔子串=假；
int[]目标指数；
target_index=newint[target.length（）]；
if（target.length（）>source.length（））{
子字符串=假；
}
否则{
for（int i=0；i=target_index[i+1]）{
子字符串=假；
打破
}
否则{
子字符串=真；
}
if（target_index.length！=target.length（））{
子字符串=假；
}
}   
}
返回子串；
}

---

有什么想法吗

应该非常简单：

public static boolean substringWithGaps(String source, String target) {
    int targetIndex = 0;
    for (int i = 0; i < source.length(); i++) {
        if (source.charAt(i) == target.charAt(targetIndex)) {
            targetIndex = targetIndex + 1;
            if (targetIndex == target.length()) {
                return true;
            }
        }
    }
    return false;
}

public static boolean substringWithGaps（字符串源、字符串目标）{
int targetIndex=0；
对于（int i=0；i

---

我们保留了需要在

target

中查找的下一个字母的索引。然后我们在

source

上循环寻找那个字母，当我们找到它时，我们将

target

中的索引向前移动一个。如果

target

的索引始终等于

target

的长度，则表示我们找到了所需的所有字符。如果我们循环所有源代码而没有找到所有的

目标，则返回false。
应该非常简单：

public static boolean substringWithGaps(String source, String target) {
    int targetIndex = 0;
    for (int i = 0; i < source.length(); i++) {
        if (source.charAt(i) == target.charAt(targetIndex)) {
            targetIndex = targetIndex + 1;
            if (targetIndex == target.length()) {
                return true;
            }
        }
    }
    return false;
}

public static boolean substringWithGaps（字符串源、字符串目标）{
int targetIndex=0；
对于（int i=0；i

我们保留了需要在
target
中查找的下一个字母的索引。然后我们在
source
上循环寻找那个字母，当我们找到它时，我们将
target
中的索引向前移动一个。如果
target
的索引始终等于
target
的长度，则表示我们找到了所需的所有字符。如果我们在所有源代码上循环而没有找到所有的
目标代码，我们将返回false。
下面的操作应该可以完成

public static boolean containsWithGaps(String a, String b){
    if(b.length() > a.length())
    {
      return false;
    }
    char[] targetChars = new char[b.length()];
    b.getChars(0,b.length(),targetChars, 0);
    int pos = 0;
    for(char myChar : targetChars)
    {
      pos = a.indexOf(myChar, pos);
      if(pos == -1)
      {
        return false;
      }
    }
    return true;
  }

下面的步骤应该可以做到这一点

public static boolean containsWithGaps(String a, String b){
    if(b.length() > a.length())
    {
      return false;
    }
    char[] targetChars = new char[b.length()];
    b.getChars(0,b.length(),targetChars, 0);
    int pos = 0;
    for(char myChar : targetChars)
    {
      pos = a.indexOf(myChar, pos);
      if(pos == -1)
      {
        return false;
      }
    }
    return true;
  }

轻微优化，当字符无法匹配时，它会立即返回（如果目标长度为零，则不会崩溃）

public static boolean substringWithGaps（字符串源、字符串目标）{
for（int i=0，last=-1；i
轻微优化，当字符无法匹配时，它会立即返回（如果目标长度为零，则不会崩溃）

public static boolean substringWithGaps（字符串源、字符串目标）{
for（int i=0，last=-1；i
Pseaudocode:
String foo=source.replace（/\s+/，“”，g）；如果（-1！=foo.indexOf（target）{hooray（）}
仅此
源代码.contains（target）
，在Java中可以正常工作。@Jorge Campos否，这将不满足要求-仅当目标完全位于源代码中时，它才会返回true。要求是可以有中间字母，Pseaudocode:
字符串foo=source.replace（/\s+/，“”，g）；if（-1！=foo.indexOf（target）{hooray（）}
仅此
source.contains（target）
，用Java就可以了。@Jorge Campos不，这不能满足要求-只有当目标在源代码中时才会返回true。要求是可以有中间字母，
StringIndexOutOfBoundsException
当target=”是，但这似乎是我不理解的。take
source=在代码的第4行，`if（source.charAt（i）=target.charAt（targetIndex））{`targetIndex将保持在0，直到循环在
hamburger
中的
b
上迭代，其索引为3，但targetIndex仍应为0，因此它们永远不会相等。@saka1029我在
if（target==“”）中添加了if（return true；{return true；}
到顶部，然后它似乎工作正常。我是个白痴。好吧，我现在明白了，哈哈！@Muldawg2020你会问为什么
targetIndex
在这段代码中保持为0。
targetIndex
指的是字符串
target
的索引。所以搜索“b”时
targetIndex
的值应该是0“，而
source
的索引可以向前移动。下载代码，如果您认为它不起作用，请自己运行。我已经对它进行了测试并获得了