Finden aller Positionen der Teilzeichenfolge in einer größeren Zeichenfolge in C #

Habe ich einen großen string, die ich brauche, zu analysieren, und ich finden müssen, dass alle Instanzen extract"(me,i-have lots. of]punctuation, und speichern Sie den index jedes in eine Liste.

Also sagen, dass dieses Stück der Schnur war am Anfang und in der Mitte des größeren string, die beide von Ihnen gefunden werden würde, und Ihre Indizes würde Hinzugefügt werden, um die List. und die List enthalten würde 0 und die anderen index-was auch immer es sein würde.

Ich habe das Spiel, und die string.IndexOf hat fast das, was ich Suche, und ich schrieb einige code - aber es funktioniert nicht und ich habe nicht in der Lage, genau herauszufinden, was falsch ist:

List<int> inst = new List<int>();
int index = 0;
while (index < source.LastIndexOf("extract\"(me,i-have lots. of]punctuation", 0) + 39)
{
    int src = source.IndexOf("extract\"(me,i-have lots. of]punctuation", index);
    inst.Add(src);
    index = src + 40;
}

inst = Die Liste
source = Die großen string

Irgendwelche besseren Ideen?

InformationsquelleAutor der Frage caesay | 2010-04-14

.net asp.net c#string

Hier ist eine Beispiel-extension-Methode für Sie:

public static List<int> AllIndexesOf(this string str, string value) {
    if (String.IsNullOrEmpty(value))
        throw new ArgumentException("the string to find may not be empty", "value");
    List<int> indexes = new List<int>();
    for (int index = 0;; index += value.Length) {
        index = str.IndexOf(value, index);
        if (index == -1)
            return indexes;
        indexes.Add(index);
    }
}

Wenn man diese in eine statische Klasse und importieren Sie den namespace mit using erscheint es als Methode für eine beliebige Zeichenfolge, und Sie können einfach tun:

List<int> indexes = "fooStringfooBar".AllIndexesOf("foo");

Weitere Informationen über die Verlängerung Methoden, http://msdn.microsoft.com/en-us/library/bb383977.aspx

Auch gleich mit einem iterator:

public static IEnumerable<int> AllIndexesOf(this string str, string value) {
    if (String.IsNullOrEmpty(value))
        throw new ArgumentException("the string to find may not be empty", "value");
    for (int index = 0;; index += value.Length) {
        index = str.IndexOf(value, index);
        if (index == -1)
            break;
        yield return index;
    }
}

InformationsquelleAutor der Antwort Matti Virkkunen

10

Warum nimmst du nicht die eingebaute RegEx-Klasse:
```
public static IEnumerable<int> GetAllIndexes(this string source, string matchString)
{
   matchString = Regex.Escape(matchString);
   foreach (Match match in Regex.Matches(source, matchString))
   {
      yield return match.Index;
   }
}
```
Wenn Sie brauchen, um die Wiederverwendung der Ausdruck dann kompilieren Sie es und cache ist es, irgendwo. Ändern Sie den matchString param, um eine Regex-matchExpression in eine andere überladung für die Wiederverwendung Fall.

InformationsquelleAutor der Antwort csaam

mithilfe von LINQ

public static IEnumerable<int> IndexOfAll(this string sourceString, string subString)
{
    return Regex.Matches(sourceString, subString).Cast<Match>().Select(m => m.Index);
}

InformationsquelleAutor der Antwort ehosca

Polierte version + Fall ignorieren support:

public static int[] AllIndexesOf(string str, string substr, bool ignoreCase = false)
{
    if (string.IsNullOrWhiteSpace(str) ||
        string.IsNullOrWhiteSpace(substr))
    {
        throw new ArgumentException("String or substring is not specified.");
    }

    var indexes = new List<int>();
    int index = 0;

    while ((index = str.IndexOf(substr, index, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal)) != -1)
    {
        indexes.Add(index++);
    }

    return indexes.ToArray();
}

InformationsquelleAutor der Antwort net_prog

public List<int> GetPositions(string source, string searchString)
{
    List<int> ret = new List<int>();
    int len = searchString.Length;
    int start = -len;
    while (true)
    {
        start = source.IndexOf(searchString, start + len);
        if (start == -1)
        {
            break;
        }
        else
        {
            ret.Add(start);
        }
    }
    return ret;
}

Nennen mag:

List<int> list = GetPositions("bob is a chowder head bob bob sldfjl", "bob");
//list will contain 0, 22, 26

InformationsquelleAutor der Antwort MusiGenesis

Hallo nette Antwort von @Matti Virkkunen

public static List<int> AllIndexesOf(this string str, string value) {
    if (String.IsNullOrEmpty(value))
        throw new ArgumentException("the string to find may not be empty", "value");
    List<int> indexes = new List<int>();
    for (int index = 0;; index += value.Length) {
        index = str.IndexOf(value, index);
        if (index == -1)
            return indexes;
        indexes.Add(index);
        index--;
    }
}

Aber dieser duckt tests Fällen wie AOOAOOA
wo substring

sind AOOA und AOOA

Ausgang 0 und 3

InformationsquelleAutor der Antwort Pranay Deep

Basiert auf dem code, den ich verwendet habe, für die Suche nach mehreren Instanzen von string in einem größeren string, der code würde wie folgt Aussehen:

List<int> inst = new List<int>();
int index = 0;
while (index >=0)
{
    index = source.IndexOf("extract\"(me,i-have lots. of]punctuation", index);
    inst.Add(index);
    index++;
}

InformationsquelleAutor der Antwort Corin

public static Dictionary<string, IEnumerable<int>> GetWordsPositions(this string input, string[] Susbtrings)
{
    Dictionary<string, IEnumerable<int>> WordsPositions = new Dictionary<string, IEnumerable<int>>();
    IEnumerable<int> IndexOfAll = null;
    foreach (string st in Susbtrings)
    {
        IndexOfAll = Regex.Matches(input, st).Cast<Match>().Select(m => m.Index);
        WordsPositions.Add(st, IndexOfAll);

    }
    return WordsPositions;
}

InformationsquelleAutor der Antwort miguel quiros garcia

Ohne Regex, mit string-Vergleich Typ:

string search = "123aa456AA789bb9991AACAA";
string pattern = "AA";
Enumerable.Range(0, search.Length)
   .Select(index => { return new { Index = index, Length = (index + pattern.Length) > search.Length ? search.Length - index : pattern.Length }; })
   .Where(searchbit => searchbit.Length == pattern.Length && pattern.Equals(search.Substring(searchbit.Index, searchbit.Length),StringComparison.OrdinalIgnoreCase))
   .Select(searchbit => searchbit.Index)

Zurück {3,8,19,22}. Leere-Muster entspricht allen Positionen.

Für mehrere Muster:

string search = "123aa456AA789bb9991AACAA";
string[] patterns = new string[] { "aa", "99" };
patterns.SelectMany(pattern => Enumerable.Range(0, search.Length)
   .Select(index => { return new { Index = index, Length = (index + pattern.Length) > search.Length ? search.Length - index : pattern.Length }; })
   .Where(searchbit => searchbit.Length == pattern.Length && pattern.Equals(search.Substring(searchbit.Index, searchbit.Length), StringComparison.OrdinalIgnoreCase))
   .Select(searchbit => searchbit.Index))

Zurück {3, 8, 19, 22, 15, 16}

InformationsquelleAutor der Antwort Sean

@csam ist richtig in der Theorie, obwohl sein code wird nicht complie und kann refractored zu

public static IEnumerable<int> IndexOfAll(this string sourceString, string matchString)
{
    matchString = Regex.Escape(matchString);
    return from Match match in Regex.Matches(sourceString, matchString) select match.Index;
}

InformationsquelleAutor der Antwort arame3333

Bemerkte ich, dass mindestens zwei vorgeschlagenen Lösungen nicht behandeln, überlappende suchen hat. Ich habe nicht überprüfen den man markiert mit dem grünen Häkchen. Hier ist eine, die Griffe überlappende Treffer:

    public static List<int> GetPositions(this string source, string searchString)
    {
        List<int> ret = new List<int>();
        int len = searchString.Length;
        int start = -1;
        while (true)
        {
            start = source.IndexOf(searchString, start +1);
            if (start == -1)
            {
                break;
            }
            else
            {
                ret.Add(start);
            }
        }
        return ret;
    }

InformationsquelleAutor der Antwort Kevin Baker

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.