¿Obtiene el índice de la enésima aparición de una cadena?

Question

A menos que me falta un método incorporado obvio, ¿cuál es la forma más rápida de obtener n la aparición de una cadena dentro de una cadena?

Me doy cuenta de que podría recorrer el método IndexOf al actualizar su índice de inicio en cada iteración del ciclo. Pero hacerlo de esta manera me parece un desperdicio.

Answer 1

Eso es básicamente lo que necesita hacer, o al menos, es la solución más fácil. Lo único que "malgastaría" es el costo de n invocaciones de métodos: en realidad no revisará ningún caso dos veces, si lo piensa. (IndexOf volverá tan pronto como encuentre la coincidencia, y continuará desde donde se quedó.)

Answer 2

Podría utilizar realmente la expresión regular /((s).*?){n}/ para buscar n-ésima aparición de la subcadena s.

En C# que podría tener este aspecto:

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: he añadido a Regex.Escape solución original para permitir buscar caracteres que tienen un significado especial para motor de expresiones regulares.

Answer 3

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

o en C# con los métodos de extensión

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

Answer 4

That's basically what you need to do - or at least, it's the easiest solution. All you'd be "wasting" is the cost of n method invocations - you won't actually be checking any case twice, if you think about it. (IndexOf will return as soon as it finds the match, and you'll keep going from where it left off.)

Aquí está la implementación recursiva (de lo anterior idea) como un método de extensión, imitando el formato del método del marco (s):

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

Además, he aquí algunas pruebas de unidad (MBUnit) que t ayuda que (para demostrar que es correcta):

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

Answer 5

Esto podría hacerlo:

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

Answer 6

Tal vez también sería agradable trabajar con el Método String.Split() y comprobar si la ocurrencia solicitado está en la matriz, si no necesita el índice, pero el valor en el índice