Obter o índice da enésima ocorrência de uma string?

A menos que esteja faltando um método óbvio integrado, qual é a maneira mais rápida de obter o n º ocorrência de uma cadeia dentro de uma string?

Percebo que poderia fazer um loop no método IndexOf atualizando seu índice inicial em cada iteração do loop. Mas fazer assim parece um desperdício para mim.

Isso é basicamente o que você precisa fazer - ou pelo menos, é a solução mais fácil. Tudo o que você estaria "desperdiçando" é o custo de n invocações de método - na verdade, você não verificará nenhum caso duas vezes, se pensar sobre isso. (IndexOf retornará assim que encontrar a correspondência, e você continuará de onde parou.)

Você realmente poderia usar a expressão regular /((s).*?){n}/para pesquisar a n-ésima ocorrência de substring s.

Em C #, pode ser assim:

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;
    }
}

Nota: Eu adicionei Regex.Escapea solução original para permitir a pesquisa de caracteres que têm um significado especial para o mecanismo regex.

Isso é basicamente o que você precisa fazer - ou pelo menos, é a solução mais fácil. Tudo o que você estaria "desperdiçando" é o custo de n invocações de método - na verdade, você não verificará nenhum caso duas vezes, se pensar sobre isso. (IndexOf retornará assim que encontrar a correspondência, e você continuará de onde parou.)

Aqui está a implementação recursiva (da ideia acima ) como um método de extensão, imitando o formato do (s) método (s) de estrutura:

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);
}

Além disso, aqui estão alguns testes de unidade (MBUnit) que podem ajudá-lo (para provar que está correto):

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;
}

ou em C # com métodos de extensão

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;
}

Talvez também seja bom trabalhar com o String.Split()Método e verificar se a ocorrência solicitada está no array, se você não precisa do índice, mas do valor do índice

Após alguns benchmarking, esta parece ser a solução mais simples e eficiente

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;

escrever uma função que é lição de casa

A resposta de Tod pode ser um pouco simplificada.

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));
    }
}

Resultado

1
3
5
-1

Ou algo assim com o loop do while

 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;
    }

Isso pode resolver:

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