C# 检查字符串中的字符集

给定一个字符串，如何检查字符串中是否存在一组字符（并找到它们的位置），从而使这些字符的顺序相同但不连续

例如字符串“ineedTogethaircut”和查找{O'、'E'、'G'、'T'}的集合

谢谢

---

（ps-我已经尝试过暴力尝试，但这很可怕，不起作用！）

如果我正确理解您的问题：

可以使用查找序列的第一个字符

然后迭代字符串中的以下字符，检查它们是否都包含在合法字符集中。对于从列表中找到的每个字符（包括找到的第一个字符），请将其从后面的合法字符列表中删除，以禁止重复

如果遇到非法字符，则文本不匹配，因此请返回此算法的开头以处理字符串的其余部分

---

如果您在一行中找到所有合法字符，那么您就有了结果。

使用System.Linq，您可以执行以下操作：

"INEEDTOGETAHAIRCUT".ToCharArray().Any(c => c=='O' || c=='E' || c=='G' || c=='T');

public static class MyExtensions
{

    public static bool ContainsAnySequenceOf(this String str, List<char> charArray)
    {
        foreach (char c in charArray)
        {
            if (str.ToCharArray().Any(x => x == c))
            {
                charArray.Remove(c);
                return str.Substring(str.IndexOf(c), Math.Min(str.Length - str.IndexOf(c), charArray.Count)).ContainsAnySequenceOf(charArray);
            }
        }
        return false;
    }
}

或者编写一个新的扩展方法来接受char数组作为参数。 要以任何顺序拥有任何字符的“序列”，可以执行以下操作：

"INEEDTOGETAHAIRCUT".ToCharArray().Any(c => c=='O' || c=='E' || c=='G' || c=='T');

public static class MyExtensions
{

    public static bool ContainsAnySequenceOf(this String str, List<char> charArray)
    {
        foreach (char c in charArray)
        {
            if (str.ToCharArray().Any(x => x == c))
            {
                charArray.Remove(c);
                return str.Substring(str.IndexOf(c), Math.Min(str.Length - str.IndexOf(c), charArray.Count)).ContainsAnySequenceOf(charArray);
            }
        }
        return false;
    }
}

公共静态类MyExtensions
{
公共静态bool包含sysequenceof（此字符串str，列表字符）
{
foreach（charArray中的字符c）
{
if（str.ToCharArray（）.Any（x=>x==c））
{
字符。删除（c）；
返回str.Substring（str.IndexOf（c）、Math.Min（str.Length-str.IndexOf（c）、charArray.Count））.ContainsAnySequenceOf（charArray）；
}
}
返回false；
}
}

那么就这样称呼它：

"INEEDTOGETAHAIRCUT".ContainsAnySequenceOf(new List<char> {'O','E','G','T'});

“IneedTogethaircut”。包含一个序列of（新列表{'O'，'E'，'G'，'T'）；

如果我不能100%确定你所说的“字符彼此跟随”的意思，那么这里有一种可能的方法：生成字符序列的所有可能排列 并搜索排列

using System;
using System.Collections.Generic;
class Program {

    static IEnumerable<string> GetPermutations(string value) {
        if (value.Length == 1) {
            yield return value;
        } else {
            for (int i = 0; i < value.Length; ++i) {
                string a = value[i].ToString();
                foreach (string b in GetPermutations(value.Remove(i, 1))) {
                    yield return a + b;
                }
            }
        }
    }

    static void Main(string[] args) {

        string test = "INEEDTOGETAHAIRCUT";
        string chars = "OEGT";
        foreach (string to_find in GetPermutations(chars)) {
            int i = test.IndexOf(to_find);
            if (i != -1) {
                Console.WriteLine("Found {0} at index {1}", to_find, i);
            }
        }
    }
}

使用系统；
使用System.Collections.Generic；
班级计划{
静态IEnumerable GetPermutations（字符串值）{
如果（value.Length==1）{
收益回报值；
}否则{
对于（int i=0；i

这里有一个非常不雅观的老派方法来解决这个问题。虽然我相信一些代码可能会更有效，但它避免了枚举搜索集的所有排列（正如您接受的答案中所做的那样）。这样做可能会很昂贵

static bool matchesPermutation(string test, string search)
{
    string remaining = search;
    for (int i = 0; i < test.Length; i++)
    {
        int pos = remaining.IndexOf(test[i]);
        if (pos == -1)
            return false;
        else
            remaining = remaining.Remove(pos, 1);
    }
    return true;
}

static int findPermutation(string test, string search)
{
    for (int i = 0; i < test.Length-search.Length+1; i++)
        if (matchesPermutation(test.Substring(i, search.Length), search))
            return i;
    return -1;
}

static void Main(string[] args)
{
    string test = "INEEDTOGETAHAIRCUT";
    string search = "AHRI";
    int foundPos = findPermutation(test, search);
    Console.WriteLine(foundPos);
    if (foundPos != -1)
        Console.WriteLine(test.Substring(foundPos, search.Length));
}

静态布尔匹配项置换（字符串测试、字符串搜索）
{
剩余字符串=搜索；
for（int i=0；i

为什么不使用更简单的两行代码来检查所需内容

string strCompare = "INEEDTOGETAHAIRCUT";
string strStringContains = ""AHRI"; 
var matchingString = strCompare.IndexOfAny(strStringContains.ToCharArray()) != -1;
then wrap the matchingString in an if(matchingString){ } // should return true or false

---

问题不清楚。“只要字符彼此跟随，它们可以以任何顺序出现。”这似乎是自相矛盾的。字符不能出现在字符串中的任何位置，必须是顺序的，但顺序并不重要-嗯，我明白为什么听起来可能不清楚。我不知道如何解释，所以您需要在测试字符串中找到4个连续字符，这些字符将耗尽集合

{'O'、'E'、'G'、'T'}

是允许的“OOOO”值，还是要搜索oE G和T的任意组合？OOOO是不允许的，4个连续字符满足集合OEGT，返回我集合中任何字符的第一次出现的索引，而不是它们一起出现的第一次出现的索引（如果有意义的话）？但这没有意义满足需求“角色相互跟随”对不起，问题有点不清楚。更新了我的答案，增加了一点帮助。啊，这很完美，但不幸的是，我不需要知道答案在哪里，而只需要知道是真是假。我真的应该提到这个：/Ok。我现在更好地理解了你的问题，并编辑了我的答案来实现这一点。好吧，我唯一的问题是复杂性的顺序。但这对询问者来说可能并不重要。