Bir dizgenin n'inci oluşumunun dizinini alın?

Açık bir yerleşik yöntemi kaçırmadıysam , bir dizedeki bir dizenin n. Oluşumunu elde etmenin en hızlı yolu nedir?

Döngünün her yinelemesinde başlangıç ​​dizinini güncelleyerek IndexOf yöntemini döngüye alabileceğimi fark ettim . Ama bunu bu şekilde yapmak bana savurgan geliyor.

Temelde yapmanız gereken bu - veya en azından en kolay çözüm bu. "Boşa harcayacağınız" tek şey n yöntem çağrısının maliyetidir - eğer düşünürseniz aslında herhangi bir vakayı iki kez kontrol etmeyeceksiniz. (IndexOf, eşleşmeyi bulur bulmaz geri dönecek ve kaldığı yerden devam edeceksiniz.)

Normal ifadeyi /((s).*?){n}/, alt dizenin n'inci oluşumunu aramak için gerçekten kullanabilirsiniz s.

C # 'da şöyle görünebilir:

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

Not:Regex.Escape Regex motoru için özel anlamı olan karakterleri aramaya izin vermek için orijinal çözüme ekledim .

Temelde yapmanız gereken bu - veya en azından en kolay çözüm bu. "Boşa harcayacağınız" tek şey n yöntem çağrısının maliyetidir - eğer düşünürseniz aslında herhangi bir vakayı iki kez kontrol etmeyeceksiniz. (IndexOf, eşleşmeyi bulur bulmaz geri dönecek ve kaldığı yerden devam edeceksiniz.)

Çerçeve yöntem (ler) inin biçimini taklit eden bir genişletme yöntemi olarak yinelemeli uygulama (yukarıdaki fikrin ):

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

Ayrıca, size yardımcı olabilecek (doğru olduğunu kanıtlamak için) bazı (MBUnit) birim testleri şunlardır:

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

veya C # uzantı yöntemleriyle

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

Belki de String.Split()Yöntem ile çalışmak ve dizinde istenen oluşumun dizide olup olmadığını kontrol etmek, dizine ihtiyacınız yoksa, ancak dizindeki değere ihtiyacınız varsa iyi olur.

Bazı karşılaştırmalardan sonra, bu en basit ve en verimli çözüm gibi görünüyor

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;

ondan bir işlev yazmak ev ödevidir

Tod'un cevabı bir şekilde basitleştirilebilir.

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

Çıktı

1
3
5
-1

Veya do while döngüsünde bunun gibi bir şey

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

Bunu yapabilir:

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