Den Index des n-ten Vorkommens einer Zeichenfolge abrufen?

Was ist der schnellste Weg, um das n- te Vorkommen einer Zeichenfolge innerhalb einer Zeichenfolge zu ermitteln, es sei denn, mir fehlt eine offensichtliche integrierte Methode ?

Mir ist klar, dass ich die IndexOf- Methode schleifen kann , indem ich ihren Startindex bei jeder Iteration der Schleife aktualisiere. Aber es so zu machen, scheint mir verschwenderisch.

Das ist im Grunde das, was Sie tun müssen - oder zumindest die einfachste Lösung. Alles, was Sie "verschwenden" würden, sind die Kosten für n Methodenaufrufe - Sie werden keinen Fall zweimal überprüfen, wenn Sie darüber nachdenken. (IndexOf kehrt zurück, sobald die Übereinstimmung gefunden wurde, und Sie werden dort weitermachen, wo es aufgehört hat.)

Sie könnten den regulären Ausdruck wirklich verwenden /((s).*?){n}/, um nach dem n-ten Auftreten von Teilzeichenfolgen zu suchen s.

In C # könnte es so aussehen:

public static class StringExtender
{
    public static int NthIndexOf(this string target, string value, int n)
    {
        Match m = Regex.Match(target, "((" + Regex.Escape(value) + ").*?){" + n + "}");

        if (m.Success)
            return m.Groups[2].Captures[n - 1].Index;
        else
            return -1;
    }
}

Hinweis: Ich habe Regex.Escapedie ursprüngliche Lösung hinzugefügt , um die Suche nach Zeichen zu ermöglichen, die für die Regex-Engine eine besondere Bedeutung haben.

Das ist im Grunde das, was Sie tun müssen - oder zumindest die einfachste Lösung. Alles, was Sie "verschwenden" würden, sind die Kosten für n Methodenaufrufe - Sie werden keinen Fall zweimal überprüfen, wenn Sie darüber nachdenken. (IndexOf kehrt zurück, sobald die Übereinstimmung gefunden wurde, und Sie werden dort weitermachen, wo es aufgehört hat.)

Hier ist die rekursive Implementierung (der obigen Idee ) als Erweiterungsmethode, die das Format der Framework-Methode (n) nachahmt:

public static int IndexOfNth(this string input,
                             string value, int startIndex, int nth)
{
    if (nth < 1)
        throw new NotSupportedException("Param 'nth' must be greater than 0!");
    if (nth == 1)
        return input.IndexOf(value, startIndex);
    var idx = input.IndexOf(value, startIndex);
    if (idx == -1)
        return -1;
    return input.IndexOfNth(value, idx + 1, --nth);
}

Außerdem sind hier einige (MBUnit) Unit-Tests aufgeführt, die Ihnen helfen könnten (um zu beweisen, dass sie korrekt sind):

using System;
using MbUnit.Framework;

namespace IndexOfNthTest
{
    [TestFixture]
    public class Tests
    {
        //has 4 instances of the 
        private const string Input = "TestTest";
        private const string Token = "Test";

        /* Test for 0th index */

        [Test]
        public void TestZero()
        {
            Assert.Throws<NotSupportedException>(
                () => Input.IndexOfNth(Token, 0, 0));
        }

        /* Test the two standard cases (1st and 2nd) */

        [Test]
        public void TestFirst()
        {
            Assert.AreEqual(0, Input.IndexOfNth("Test", 0, 1));
        }

        [Test]
        public void TestSecond()
        {
            Assert.AreEqual(4, Input.IndexOfNth("Test", 0, 2));
        }

        /* Test the 'out of bounds' case */

        [Test]
        public void TestThird()
        {
            Assert.AreEqual(-1, Input.IndexOfNth("Test", 0, 3));
        }

        /* Test the offset case (in and out of bounds) */

        [Test]
        public void TestFirstWithOneOffset()
        {
            Assert.AreEqual(4, Input.IndexOfNth("Test", 4, 1));
        }

        [Test]
        public void TestFirstWithTwoOffsets()
        {
            Assert.AreEqual(-1, Input.IndexOfNth("Test", 8, 1));
        }
    }
}

private int IndexOfOccurence(string s, string match, int occurence)
{
    int i = 1;
    int index = 0;

    while (i <= occurence && (index = s.IndexOf(match, index + 1)) != -1)
    {
        if (i == occurence)
            return index;

        i++;
    }

    return -1;
}

oder in C # mit Erweiterungsmethoden

public static int IndexOfOccurence(this string s, string match, int occurence)
{
    int i = 1;
    int index = 0;

    while (i <= occurence && (index = s.IndexOf(match, index + 1)) != -1)
    {
        if (i == occurence)
            return index;

        i++;
    }

    return -1;
}

Vielleicht wäre es auch schön, mit der String.Split()Methode zu arbeiten und zu überprüfen, ob sich das angeforderte Vorkommen im Array befindet, wenn Sie nicht den Index, sondern den Wert am Index benötigen

Nach einigem Benchmarking scheint dies die einfachste und effizienteste Lösung zu sein

public static int IndexOfNthSB(string input,
             char value, int startIndex, int nth)
        {
            if (nth < 1)
                throw new NotSupportedException("Param 'nth' must be greater than 0!");
            var nResult = 0;
            for (int i = startIndex; i < input.Length; i++)
            {
                if (input[i] == value)
                    nResult++;
                if (nResult == nth)
                    return i;
            }
            return -1;
        }

System.ValueTuple ftw:

var index = line.Select((x, i) => (x, i)).Where(x => x.Item1 == '"').ElementAt(5).Item2;

eine Funktion daraus zu schreiben ist Hausaufgabe

Tods Antwort kann etwas vereinfacht werden.

using System;

static class MainClass {
    private static int IndexOfNth(this string target, string substring,
                                       int seqNr, int startIdx = 0)
    {
        if (seqNr < 1)
        {
            throw new IndexOutOfRangeException("Parameter 'nth' must be greater than 0.");
        }

        var idx = target.IndexOf(substring, startIdx);

        if (idx < 0 || seqNr == 1) { return idx; }

        return target.IndexOfNth(substring, --seqNr, ++idx); // skip
    }

    static void Main () {
        Console.WriteLine ("abcbcbcd".IndexOfNth("bc", 1));
        Console.WriteLine ("abcbcbcd".IndexOfNth("bc", 2));
        Console.WriteLine ("abcbcbcd".IndexOfNth("bc", 3));
        Console.WriteLine ("abcbcbcd".IndexOfNth("bc", 4));
    }
}

Ausgabe

1
3
5
-1

Oder so ähnlich mit der do while-Schleife

 private static int OrdinalIndexOf(string str, string substr, int n)
    {
        int pos = -1;
        do
        {
            pos = str.IndexOf(substr, pos + 1);
        } while (n-- > 0 && pos != -1);
        return pos;
    }

Dies könnte es tun:

Console.WriteLine(str.IndexOf((@"\")+2)+1);