Uzyskaj indeks n-tego wystąpienia ciągu znaków?

Question

Chyba że brakuje mi oczywistej wbudowanej metody, jaki jest najszybszy sposób na uzyskanie wystąpienia ciągu znaków w ciągu znaków?

Zdaję sobie sprawę, że mogę zapętlić metodę IndexOf aktualizując jej indeks początkowy w każdej iteracji pętli. Ale robienie tego w ten sposób wydaje mi się nierozważne.

Answer 1

To w zasadzie to, co musisz zrobić - a przynajmniej to najprostsze rozwiązanie. Wszystko, co "marnujesz", to koszt inwokacji metodą n - w rzeczywistości nie będziesz dwa razy sprawdzał przypadku, jeśli się nad tym zastanowisz. (IndexOf powróci, gdy tylko znajdzie dopasowanie, a będziesz kontynuował od miejsca, w którym zostało przerwane).

Answer 2

Naprawdę możesz użyć wyrażenia regularnego /((s).*?){n}/, aby wyszukać n-ty występowanie podła s.

W języku C# to może wyglądać następująco:

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

Uwaga: Dodałem Regex.Escape do oryginalnego rozwiązania, które umożliwi wyszukanie znaków, które mają szczególne znaczenie dla regex silnika.

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

lub w C# z metod rozszerzenie

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.)

Oto rekurencyjna realizacja (wyzej idei) jako metodę rozszerzenia, dokładnie taki efekt formatu metody ramowej (ów):

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

Także tutaj są niektóre (MBUnit) testy jednostkowe które t pomóc (to udowodnić jest poprawna):

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

Może to zrobić:

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

Answer 6

Możliwe byłoby również miło pracować z Metodą String.Split() i sprawdzić, czy żądana występowanie jest w tablica, jeśli nie potrzebujesz indeksu, ale wartość na indeksie