एक स्ट्रिंग की nth घटना की अनुक्रमणिका प्राप्त करें?

Question

जब तक कि मुझे एक स्पष्ट अंतर्निहित विधि नहीं मिल रही है, तो n स्ट्रिंग के भीतर स्ट्रिंग की वें घटना प्राप्त करने का सबसे तेज़ तरीका क्या है?

मुझे एहसास है कि मैं IndexOf विधि को लूप के प्रत्येक पुनरावृत्ति पर अपनी प्रारंभिक अनुक्रमणिका अपडेट करके पाश कर सकता हूं। लेकिन ऐसा करने से मुझे अपमानजनक लगता है।

Answer 1

मूल रूप से आपको क्या करना है - या कम से कम, यह सबसे आसान समाधान है। आप सभी "बर्बाद" होंगे, एन विधि आमंत्रण की लागत है - यदि आप इसके बारे में सोचते हैं तो आप वास्तव में किसी भी मामले की जांच नहीं करेंगे। (इंडेक्सऑफ जैसे ही यह मैच पाता है, वैसे ही आप वापस आ जाएंगे, और आप इसे छोड़कर कहां से आगे बढ़ेंगे।)

Answer 2

आप वास्तव में नियमित अभिव्यक्ति /((s).*?){n}/ का उपयोग कर सकते हैं ताकि s की एन-वें घटना की खोज हो सके।

सी # में यह इस प्रकार दिखाई देंगे:

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

नोट: मैं मूल समाधान के लिए Regex.Escape को शामिल किया है जो regex इंजन के लिए विशेष अर्थ नहीं होता पात्रों खोज अनुमति देने के लिए।

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

या सी # विस्तार तरीकों के साथ में

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

यहाँ ढांचे विधि का प्रारूप (रों mimicing, एक विस्तार पद्धति के रूप में (ऊपर विचार का) पुनरावर्ती कार्यान्वयन है):

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

इसके अलावा, यहां कुछ (एमबीयूनीट) यूनिट परीक्षण हैं जो माई हैं मदद नहीं आप (यह साबित करने के लिए सही है):

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

यह यह कर सकता है:

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

Answer 6

शायद यह भी String.Split() विधि के साथ काम करते हैं और यदि अनुरोध घटना में है की जाँच करने के अच्छा होगा सरणी, अगर आपको इंडेक्स की आवश्यकता नहीं है, लेकिन सूचकांक