blocks|key|1936213|text|与其创建一堆子字符串，为什么不使用the+IndexOf+overload+that+takes+a+starting+index呢？这将会更容易(你不需要调整最终的索引)和更高效(你不需要分配一大堆的子串)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1936214|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/5xkyx09y.aspx^0|L|7|H|1C|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

Instead of creating a bunch of substrings, why not use <a href="http://msdn.microsoft.com/en-us/library/5xkyx09y.aspx" rel="nofollow">the <code>IndexOf</code> overload that takes a starting index</a>? This will be both easier (you won't have to adjust the final index) and more efficient (you don't have to allocate a bunch of substrings).

blocks|key|1722672|text|在我看来，获取所有这些子字符串是非常浪费的。为什么不直接循环你自己呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1722673|private+int+IndexOfNth(string+str,+char+c,+int+n)
{
++++int+remaining+=+n;
++++for+(int+i+=+0;+i+<+str.Length;+i%2B%2B)
++++{
++++++++if+(str[i]+==+c)
++++++++{
++++++++++++remaining--;
++++++++++++if+(remaining+==+0)
++++++++++++{
++++++++++++++++return+i;
++++++++++++}
++++++++}
++++}
++++return+-1;
}|code-block|syntax|javascript|1722674|(我考虑过在一个循环中使用IndexOf，就像minitech的解决方案一样，但我觉得这样做有点麻烦。当然，这两个都很好。两者基本上做相同的工作，只检查每个字符一次。使用IndexOf可能会稍微高效一些，但请选择您认为更具可读性的方法。)|offset|length|style|CODE|1722675|entityMap^0|0|0|D|7|2D|7|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

Taking all these substrings seems pretty wasteful to me. Why not just loop yourself?

<pre><code>private int IndexOfNth(string str, char c, int n)
{
 int remaining = n;
 for (int i = 0; i &lt; str.Length; i++)
 {
 if (str[i] == c)
 {
 remaining--;
 if (remaining == 0)
 {
 return i;
 }
 }
 }
 return -1;
}
</code></pre>

(I considered using <code>IndexOf</code> in a loop like minitech's solution, but decided it was a bit fiddly. Either's fine, of course. Both basically do the same work, only ever checking each character once. Using <code>IndexOf</code> may be slightly more efficient, but go for whichever you find more readable.)

blocks|key|1936239|text|不要这样做；IndexOf接受第二个参数，该参数指定从哪里开始。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1936240|private+static+int+IndexOfNth(string+str,+char+c,+int+n)+{
++++int+s+=+-1;

++++for+(int+i+=+0;+i+<+n;+i%2B%2B)+{
++++++++s+=+str.IndexOf(c,+s+%2B+1);

++++++++if+(s+==+-1)+break;
++++}

++++return+s;
}|code-block|syntax|javascript|1936241|entityMap^0|6|7|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Don't do that; <code>IndexOf</code> takes a second parameter that specifies where to start.

<pre><code>private static int IndexOfNth(string str, char c, int n) {
 int s = -1;

 for (int i = 0; i &lt; n; i++) {
 s = str.IndexOf(c, s + 1);

 if (s == -1) break;
 }

 return s;
}
</code></pre>

blocks|key|1722712|text|使用LINQ查找字符串aababaababa中的第5个a的索引|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1722713|var+str+=+"aababaababa";
var+ch+=+'a';
var+n+=+5;
var+result+=+str
++.Select((c,+i)+=>+new+{+c,+i+})
++.Where(x+=>+x.c+==+ch)
++.Skip(n+-+1)
++.FirstOrDefault();
return+result+!=+null+?+result.i+:+-1;|code-block|syntax|javascript|1722714|entityMap^0|B|B|R|1|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

Using LINQ to find the index of the 5'th <code>a</code> in the string <code>aababaababa</code>:

<pre><code>var str = "aababaababa";
var ch = 'a';
var n = 5;
var result = str
 .Select((c, i) =&gt; new { c, i })
 .Where(x =&gt; x.c == ch)
 .Skip(n - 1)
 .FirstOrDefault();
return result != null ? result.i : -1;
</code></pre>

blocks|key|1936339|text|没有经过测试，但是像这样的东西应该可以工作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1936340|private+int+IndexOfNth(string+str,+char+c,+int+n)
{
++++int+index+=+-1;
++++while+(n--+>+0)
++++{
++++++++index+=+str.IndexOf(c,+index+%2B+1);
++++++++if+(index+==+-1)+break;
++++}
++++return+index;
}|code-block|syntax|javascript|1936341|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Not tested but something like this should work:

<pre><code>private int IndexOfNth(string str, char c, int n)
{
 int index = -1;
 while (n-- &gt; 0)
 {
 index = str.IndexOf(c, index + 1);
 if (index == -1) break;
 }
 return index;
}
</code></pre>

blocks|key|1936398|text|我倾向于首先考虑如何使用Linq访问集合。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1936399|++//+0-based+n.
char+result+=+str
++.Where(x+=>+x+==+c)
++.Skip(n)
++.FirstOrDefault();|code-block|syntax|javascript|1936400|然后，我将解压linq并添加索引迭代。|1936401|int+foundCount+=+-1;
for(int+position+=+0;+position+<+str.Length;+position%2B%2B)
{
++char+x+=+str[position];
++if+(x+==+c)
++{
++++foundCount+%2B=+1;
++++//+0-based+n
++++if+(foundCount+==+n)
++++{
++++++return+position;
++++}
++}
}
return+-1;|1936402|然后我想:如果这个方法返回所有的索引，这样我就可以查询它们了：|1936403|public+IEnumerable<int>+IndexesOf(string+str,+char+c)
{
++for(int+position+=+0;+position+<+str.Length;+position%2B%2B)
++{
++++char+x+=+str[position];
++++if+(x+==+c)
++++{
++++++yield+return+position;
++++}
++}
}|1936404|调用者：|1936405|int+position+=+IndexesOf(str,+c)
+.Skip(n)+//+0-based+n
+.DefaultIfEmpty(-1)
+.First();|1936406|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

I tend to first think about how to access the collection using Linq.

<pre><code> // 0-based n.
char result = str
 .Where(x =&gt; x == c)
 .Skip(n)
 .FirstOrDefault();
</code></pre>

Then I'll unpack the linq and add the indexed iteration.

<pre><code>int foundCount = -1;
for(int position = 0; position &lt; str.Length; position++)
{
 char x = str[position];
 if (x == c)
 {
 foundCount += 1;
 // 0-based n
 if (foundCount == n)
 {
 return position;
 }
 }
}
return -1;
</code></pre>

Then I think about: what if this method returned all the indexes so I can query them:

<pre><code>public IEnumerable&lt;int&gt; IndexesOf(string str, char c)
{
 for(int position = 0; position &lt; str.Length; position++)
 {
 char x = str[position];
 if (x == c)
 {
 yield return position;
 }
 }
}
</code></pre>

Called by:

<pre><code>int position = IndexesOf(str, c)
 .Skip(n) // 0-based n
 .DefaultIfEmpty(-1)
 .First();
</code></pre>

blocks|key|1936456|text|还没见过有人用过CharEnumerator呢...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1936457|++++public+Int32+getNthIndex(string+str,+char+c,+Int32+n)
++++{
++++++++Int32+index+=+0;
++++++++Int32+count+=+0;
++++++++if+(str+!=+null+&&+str.Length+>+0+&&+!(n+<+1))
++++++++{
++++++++++++CharEnumerator+scanner+=+str.GetEnumerator();
++++++++++++while+(scanner.MoveNext())
++++++++++++{
++++++++++++++++if+(scanner.Current+==+c)+{+count%2B%2B;+}
++++++++++++++++if+(count+==+n)+{+break;+}
++++++++++++++++index%2B%2B;
++++++++++++}
++++++++++++if+(count+<+n)+{+index+=+-1;+}
++++++++}
++++++++if+(count+==+0)+{+return+-1;+}+else+{+return+index;+}
++++}|code-block|syntax|javascript|1936458|应该是非常有效的，没有子字符串或任何东西，只需扫描给定的字符串并计数即可。|1936459|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Hadn't seen anyone use the CharEnumerator yet...

<pre><code> public Int32 getNthIndex(string str, char c, Int32 n)
 {
 Int32 index = 0;
 Int32 count = 0;
 if (str != null &amp;&amp; str.Length &gt; 0 &amp;&amp; !(n &lt; 1))
 {
 CharEnumerator scanner = str.GetEnumerator();
 while (scanner.MoveNext())
 {
 if (scanner.Current == c) { count++; }
 if (count == n) { break; }
 index++;
 }
 if (count &lt; n) { index = -1; }
 }
 if (count == 0) { return -1; } else { return index; }
 }
</code></pre>

Should be pretty efficient, no substrings or anything, just scan through the string you're given and keep count.

blocks|key|1722970|text|您可以使用以下方法，它将返回指定字符串中指定字符的第n个匹配项。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1722971|public+static+int+IndexOfNthCharacter(string+str,+int+n,+char+c)+{
++++int+index+=+-1;
++++if+(!str.Contains(c.ToString())+%7C%7C+(str.Split(c).Length-1+<+n))+{
++++++++return+-1;
++++}
++++else+{
++++++++for+(int+i+=+0;+i+<+str.Length;+i%2B%2B)+{
++++++++++++if+(n+>+0)+{++++++++++++
++++++++++++++++index%2B%2B;
++++++++++++}
++++++++++++else+{
++++++++++++++++return+index;
++++++++++++}
++++++++++++if+(str[i]+==+c)+{
++++++++++++++++n--;
++++++++++++}
++++++++}
++++++++return+index;
++++}
}|code-block|syntax|javascript|1722972|请注意，如果您正在搜索的字符不存在于您正在搜索的字符串中，或者您正在搜索的出现次数大于字符串中存在的出现次数，则此方法将返回-1。|1722973|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You could use the following method which will return the nth occurrence of the specified character within the designated string.

<pre><code>public static int IndexOfNthCharacter(string str, int n, char c) {
 int index = -1;
 if (!str.Contains(c.ToString()) || (str.Split(c).Length-1 &lt; n)) {
 return -1;
 }
 else {
 for (int i = 0; i &lt; str.Length; i++) {
 if (n &gt; 0) { 
 index++;
 }
 else {
 return index;
 }
 if (str[i] == c) {
 n--;
 }
 }
 return index;
 }
}
</code></pre>

Note that if the character you are searching for does not exist within the string you are searching or the the occurrence number you are searching for is greater than what exists in the string then this method will return -1.

blocks|key|1936562|text|首先，我会让它成为一个扩展方法。这样，您就可以跳过强制的null检查，也可以像对IndexOf、IndexOfAny等一样在字符串上调用它。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1936563|然后我会做两个方法。一个用于检索所有索引(IndexesOf，有时可能会派上用场)，另一个(IndexOfNth)使用第一个函数检查第n个索引：|1936564|using+System;
using+System.Collections.Generic;+//+#+Necessary+for+IList<int>
using+System.Linq;+//+#+Necessary+for+IList<int>.ToArray()

///+<summary>
///+Returns+all+indexes+of+the+specified+<paramref+name="value"/>+in+the+current+string.
///+</summary>
///+<param+name="@this">The+current+string+this+method+is+operating+on.</param>
///+<param+name="value">The+value+to+be+searched.</param>
///+<returns><c>Null</c>,+if+<paramref+name="value"/>+is+<c>null</c>+or+empty.
///+An+array+holding+all+indexes+of+<paramref+name="value"/>+in+this+string,
///+else.</returns>
static+int[]+IndexesOf(this+string+@this,+string+value)
{
++++//+#+Can't+search+for+null+or+string.Empty,+you+can+return+what
++++//+++suits+you+best
++++if+(string.IsNullOrEmpty(value))
++++++++return+null;

++++//+#+Using+a+list+instead+of+an+array+saves+us+statements+to+resize+the+
++++//+++array+by+ourselves
++++IList<int>+indexes+=+new+List<int>();
++++int+startIndex+=+0;

++++while+(startIndex+<+@this.Length)
++++{
++++++++startIndex+=+@this.IndexOf(value,+startIndex);
++++++++if+(startIndex+>=+0)
++++++++{
++++++++++++//+#+Add+the+found+index+to+the+result+and+increment+it+by+length+of+value
++++++++++++//+++afterwards+to+keep+searching+AFTER+the+current+position
++++++++++++indexes.Add(startIndex);
++++++++++++startIndex+%2B=+value.Length;
++++++++}
++++++++else
++++++++{
++++++++++++//+#+Exit+loop,+if+value+does+not+occur+in+the+remaining+string
++++++++++++break;
++++++++}
++++}

++++//+#+Return+an+array+to+conform+with+other+string+operations.
++++return+indexes.ToArray();
}

///+<summary>
///+Returns+the+indexes+of+the+<paramref+name="n"/>th+occurrence+of+the+specified
///+<paramref+name="value"/>+in+the+current+string.
///+</summary>
///+<param+name="@this">The+current+string+this+method+is+operating+on.</param>
///+<param+name="value">The+value+to+be+searched.</param>
///+<param+name="n">The+1-based+nth+occurrence.</param>
///+<returns><c>-1</c>,+if+<paramref+name="value"/>+is+<c>null</c>+or+empty+-or-
///+<paramref+name="n"/>+is+less+than+1.</returns>
static+int+IndexOfNth(this+string+@this,+string+value,+int+n+/*+n+is+1-based+*/)
{
++++//+#+You+could+throw+an+ArgumentException+as+well,+if+n+is+less+than+1
++++if+(string.IsNullOrEmpty(value)+%7C%7C+n+<+1)
++++++++return+-1;

++++int[]+indexes+=+@this.IndexesOf(value);

++++//+#+If+there+are+n+or+more+occurrences+of+'value'+in+'@this'
++++//+++return+the+nth+index.
++++if+(indexes+!=+null+&&+indexes.Length+>=+n)
++++{
++++++++return+indexes[n+-+1];
++++}

++++return+-1;
}|code-block|syntax|javascript|1936565|您可以在签名中使用char+value而不是string+value来重载它们，并通过value.ToString()调用它们各自的对等物。瞧啊！|1936566|当然，这些方法是可以重构的，例如使用LINQ，make+IndexesOf+recursive等。|1936567|entityMap^0|S|4|14|7|1C|A|0|L|9|1A|A|0|0|9|A|M|C|17|G|0|S|9|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|14|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1C|8|@$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]]|R|$]]

First of all, I'd make it an extension method. This way, you can skip the otherwise obligatory <code>null</code> check and also just call it on a string like you would do with <code>IndexOf</code>, <code>IndexOfAny</code> etc.

Then I'd make two methods of this. One to retrieve all indexes (<code>IndexesOf</code>, that might come handy at sometime) and the other one (<code>IndexOfNth</code>) uses the first function to check for the nth index:

<pre><code>using System;
using System.Collections.Generic; // # Necessary for IList&lt;int&gt;
using System.Linq; // # Necessary for IList&lt;int&gt;.ToArray()

/// &lt;summary&gt;
/// Returns all indexes of the specified &lt;paramref name="value"/&gt; in the current string.
/// &lt;/summary&gt;
/// &lt;param name="@this"&gt;The current string this method is operating on.&lt;/param&gt;
/// &lt;param name="value"&gt;The value to be searched.&lt;/param&gt;
/// &lt;returns&gt;&lt;c&gt;Null&lt;/c&gt;, if &lt;paramref name="value"/&gt; is &lt;c&gt;null&lt;/c&gt; or empty.
/// An array holding all indexes of &lt;paramref name="value"/&gt; in this string,
/// else.&lt;/returns&gt;
static int[] IndexesOf(this string @this, string value)
{
 // # Can't search for null or string.Empty, you can return what
 // suits you best
 if (string.IsNullOrEmpty(value))
 return null;

 // # Using a list instead of an array saves us statements to resize the 
 // array by ourselves
 IList&lt;int&gt; indexes = new List&lt;int&gt;();
 int startIndex = 0;

 while (startIndex &lt; @this.Length)
 {
 startIndex = @this.IndexOf(value, startIndex);
 if (startIndex &gt;= 0)
 {
 // # Add the found index to the result and increment it by length of value
 // afterwards to keep searching AFTER the current position
 indexes.Add(startIndex);
 startIndex += value.Length;
 }
 else
 {
 // # Exit loop, if value does not occur in the remaining string
 break;
 }
 }

 // # Return an array to conform with other string operations.
 return indexes.ToArray();
}

/// &lt;summary&gt;
/// Returns the indexes of the &lt;paramref name="n"/&gt;th occurrence of the specified
/// &lt;paramref name="value"/&gt; in the current string.
/// &lt;/summary&gt;
/// &lt;param name="@this"&gt;The current string this method is operating on.&lt;/param&gt;
/// &lt;param name="value"&gt;The value to be searched.&lt;/param&gt;
/// &lt;param name="n"&gt;The 1-based nth occurrence.&lt;/param&gt;
/// &lt;returns&gt;&lt;c&gt;-1&lt;/c&gt;, if &lt;paramref name="value"/&gt; is &lt;c&gt;null&lt;/c&gt; or empty -or-
/// &lt;paramref name="n"/&gt; is less than 1.&lt;/returns&gt;
static int IndexOfNth(this string @this, string value, int n /* n is 1-based */)
{
 // # You could throw an ArgumentException as well, if n is less than 1
 if (string.IsNullOrEmpty(value) || n &lt; 1)
 return -1;

 int[] indexes = @this.IndexesOf(value);

 // # If there are n or more occurrences of 'value' in '@this'
 // return the nth index.
 if (indexes != null &amp;&amp; indexes.Length &gt;= n)
 {
 return indexes[n - 1];
 }

 return -1;
}
</code></pre>

You can overload these using <code>char value</code> instead of <code>string value</code> in the signature and calling their respective counterparts passing <code>value.ToString()</code>. Et voilá!

Surely, these methods can be refactored, e.g. using LINQ, make <code>IndexesOf</code> recursive etc.

I'm trying to make a function that returns the index of the Nth occurrence of a given char in a string.

Here is my attempt:

<pre><code>private int IndexOfNth(string str, char c, int n)
{
 int index = str.IndexOf(c) + 1;
 if (index &gt;= 0)
 {
 string temp = str.Substring(index, str.Length - index);
 for (int j = 1; j &lt; n; j++)
 {
 index = temp.IndexOf(c) + 1;
 if (index &lt; 0)
 {
 return -1;
 }
 temp = temp.Substring(index, temp.Length - index);
 }
 index = index + (str.Length);
 }
 return index;
}
</code></pre>

This should find the first occurrence, chop off that front part of the string, find the first occurrence from the new substring, and on and on until it gets the index of the nth occurrence. However I failed to consider how the index of the final substring is going to be offset from the original actual index in the original string. How do I make this work?

Also as a side question, if I want the char to be the tab character do I pass this function '\t' or what?

Get index of nth occurrence of char in a string

我正在尝试创建一个函数，该函数返回字符串中给定字符第N次出现的索引。这是我的尝试：private int IndexOfNth(string str, char c, int n){    int index = str.IndexOf(c) + 1;    if (index >= 0)    {        st...

问获取字符串中第n次出现的字符的索引
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问获取字符串中第n次出现的字符的索引EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问获取字符串中第n次出现的字符的索引
EN