webdevqa.jp.net

文字列内の文字列(実際にはchar)の出現回数をどのように数えますか?

/の文字列中にいくつを見つけられるかを数えたいと思ったので、それを実行する方法がいくつかあることに気付きました。 。

現時点では私はのようなもので行っています:

string source = "/once/upon/a/time/";
int count = source.Length - source.Replace("/", "").Length;

しかし、私はまったく好きではありません。

私は本当にこのためにRegExを掘り下げたいとは思わないでしょうか?

私の文字列は私が探している用語を持つことになるので、あなたはそれを仮定することができます...

もちろん文字列 に対して length> 1

string haystack = "/once/upon/a/time";
string needle = "/";
int needleCount = ( haystack.Length - haystack.Replace(needle,"").Length ) / needle.Length;
765
inspite

.NET 3.5を使用している場合は、LINQを使用してこれをワンライナーで実行できます。

int count = source.Count(f => f == '/');

LINQを使いたくない場合は、次のようにしてください。

int count = source.Split('/').Length - 1;

あなたはあなたのオリジナルのテクニックがこれらのどちらよりも約30%速いように思われることを学ぶのに驚くかもしれません! "/ once/upon/a/time /"で簡単なベンチマークを行ったところ、結果は次のようになりました。

あなたのオリジナル= 12秒
source.Count = 19秒
source.Split = 17s
foreach( bobwienholtの回答から )= 10秒

(時間は50,000,000回の繰り返しであるため、現実の世界で大きな違いに気付くことはほとんどありません。)

891
LukeH
string source = "/once/upon/a/time/";
int count = 0;
foreach (char c in source) 
  if (c == '/') count++;

それ自体でsource.Replace()より速くなければなりません。

162
bobwienholt
int count = new Regex(Regex.Escape(needle)).Matches(haystack).Count;
126

文字だけでなく、文字列全体を検索できるようにしたい場合は、次のようにします。

src.Select((c, i) => src.Substring(i)).Count(sub => sub.StartsWith(target))

「文字列内の各文字について、その文字から始まる文字列の残りを部分文字列とします。対象文字列で始まっている場合はそれを数えます。」

81
mqp

私はいくつかの調査を行ったところ、 Richard Watsonの 解決策がほとんどの場合最速であることがわかりました。これは、投稿内のすべての解決策の結果をまとめた表です( "test {test"のように文字列を解析している間は例外がスローされるため、 Regex を使用します)。

    Name      | Short/char |  Long/char | Short/short| Long/short |  Long/long |
    Inspite   |         134|        1853|          95|        1146|         671|
    LukeH_1   |         346|        4490|         N/A|         N/A|         N/A|
    LukeH_2   |         152|        1569|         197|        2425|        2171|
Bobwienholt   |         230|        3269|         N/A|         N/A|         N/A|
Richard Watson|          33|         298|         146|         737|         543|
StefanosKargas|         N/A|         N/A|         681|       11884|       12486|

短い文字列(10〜50文字)で短い部分文字列(1〜5文字)の出現数を見つける場合は、元のアルゴリズムが優先されることがわかります。

また、多文字部分文字列の場合は、次のコードを使用する必要があります( Richard Watsonの solutionに基づく)。

int count = 0, n = 0;

if(substring != "")
{
    while ((n = source.IndexOf(substring, n, StringComparison.InvariantCulture)) != -1)
    {
        n += substring.Length;
        ++count;
    }
}
61
tsionyx

LINQはすべてのコレクションで動作します。文字列は単なる文字のコレクションなので、この素敵な小さなワンライナーはどうでしょうか。

var count = source.Count(c => c == '/');

using System.Linq;はその名前空間の拡張メソッドであるため、コードファイルの先頭に.Countがあることを確認してください。

53
string source = "/once/upon/a/time/";
int count = 0;
int n = 0;

while ((n = source.IndexOf('/', n)) != -1)
{
   n++;
   count++;
}

私のコンピュータでは、5000万回の繰り返し処理のための文字ごとのソリューションよりも約2秒高速です。

2013年改訂

文字列をchar []に変更して、それを繰り返します。 50m反復の合計時間をさらに1〜2秒短縮します。

char[] testchars = source.ToCharArray();
foreach (char c in testchars)
{
     if (c == '/')
         count++;
}

これはもっと速いです:

char[] testchars = source.ToCharArray();
int length = testchars.Length;
for (int n = 0; n < length; n++)
{
    if (testchars[n] == '/')
        count++;
}

良い方法として、配列の末尾から0までの反復が最も速いようです(約5%)。

int length = testchars.Length;
for (int n = length-1; n >= 0; n--)
{
    if (testchars[n] == '/')
        count++;
}

なぜこれが可能なのか、そしてグーグリングしていたのか(私は逆反復の方が速いことを思い出します)、そして文字列をchar []の手法にいらいらさせながら使うこのSO質問に思いつきました。しかし、この文脈では逆転トリックは新しいと思います。

C#の文字列内の個々の文字を反復処理する最も速い方法は何ですか?

46
Richard Watson

これらはどちらも1文字の検索語に対してのみ機能します。

countOccurences("the", "the answer is the answer");

int countOccurences(string needle, string haystack)
{
    return (haystack.Length - haystack.Replace(needle,"").Length) / needle.Length;
}

長い針の方が良いことが判明するかもしれません...

しかし、もっとエレガントな方法があるはずです。 :)

45
ZombieSheep

編集:

source.Split('/').Length-1
19
Brian Rudolph
Regex.Matches( Regex.Escape(input),  "stringToMatch" ).Count
15
cederlof

C#では、Nice String SubStringカウンターは予想外にトリッキーな仲間です。

public static int CCount(String haystack, String needle)
{
    return haystack.Split(new[] { needle }, StringSplitOptions.None).Length - 1;
}
14
Dave
private int CountWords(string text, string Word) {
    int count = (text.Length - text.Replace(Word, "").Length) / Word.Length;
    return count;
}

元の解決策はcharsにとって最速だったので、私はそれが文字列にもなるだろうと思います。だからここに私の貢献です。

コンテキストについては:私はログファイルの中で '失敗した'と '成功した'のような単語を探していました。

Gr、ベン

11
Ben
string s = "65 fght 6565 4665 hjk";
int count = 0;
foreach (Match m in Regex.Matches(s, "65"))
  count++;
11
preetham

String拡張メソッドをすぐに使えるようにしたいという人のために、

これが私が使っているもので、投稿された答えのうち最高のものに基づいています。

public static class StringExtension
{    
    /// <summary> Returns the number of occurences of a string within a string, optional comparison allows case and culture control. </summary>
    public static int Occurrences(this System.String input, string value, StringComparison stringComparisonType = StringComparison.Ordinal)
    {
        if (String.IsNullOrEmpty(value)) return 0;

        int count    = 0;
        int position = 0;

        while ((position = input.IndexOf(value, position, stringComparisonType)) != -1)
        {
            position += value.Length;
            count    += 1;
        }

        return count;
    }

    /// <summary> Returns the number of occurences of a single character within a string. </summary>
    public static int Occurrences(this System.String input, char value)
    {
        int count = 0;
        foreach (char c in input) if (c == value) count += 1;
        return count;
    }
}
7
WhoIsRich

これを行う最も簡単な方法は、正規表現を使用することです。これにより、myVar.Split( 'x')を使用した場合と同じ分割数を取得できますが、複数文字の設定を使用できます。

string myVar = "do this to count the number of words in my wording so that I can Word it up!";
int count = Regex.Split(myVar, "Word").Length;
5
Beroc
public static int GetNumSubstringOccurrences(string text, string search)
{
    int num = 0;
    int pos = 0;

    if (!string.IsNullOrEmpty(text) && !string.IsNullOrEmpty(search))
    {
        while ((pos = text.IndexOf(search, pos)) > -1)
        {
            num ++;
            pos += search.Length;
        }
    }
    return num;
}
5
user460847
string search = "/string";
var occurrences = (regex.Match(search, @"\/")).Count;

これは、プログラムが "/ s"を正確に見つけるたびに(大文字と小文字を区別して)カウントし、この発生回数は変数 "occurrences"に格納されます。

3
Adam Higgins

ストリング内のストリング:

「.. JD JD JD JDなど」JDJDJDJDJDJDJDJDなどの「etc」を見つけます。

var strOrigin = " .. JD JD JD JD etc. and etc. JDJDJDJDJDJDJDJD and etc.";
var searchStr = "etc";
int count = (strOrigin.Length - strOrigin.Replace(searchStr, "").Length)/searchStr.Length.

これを不健康で不器用なものとして捨てる前にパフォーマンスをチェックしてください...

2
user3090281
string source = "/once/upon/a/time/";
int count = 0, n = 0;
while ((n = source.IndexOf('/', n) + 1) != 0) count++;

Richard Watsonの答えのバリエーションです。文字列にcharが多く含まれるほど効率が上がり、コードが少なくなります。

すべてのシナリオを徹底的にテストしなくても、言う必要がありますが、次のものを使用することで、速度が大幅に向上しました。

int count = 0;
for (int n = 0; n < source.Length; n++) if (source[n] == '/') count++;
2
user2011559

文字列の出現に対する一般的な関数:

public int getNumberOfOccurencies(String inputString, String checkString)
{
    if (checkString.Length > inputString.Length || checkString.Equals("")) { return 0; }
    int lengthDifference = inputString.Length - checkString.Length;
    int occurencies = 0;
    for (int i = 0; i < lengthDifference; i++) {
        if (inputString.Substring(i, checkString.Length).Equals(checkString)) { occurencies++; i += checkString.Length - 1; } }
    return occurencies;
}
2
Stefanos Kargas
            var conditionalStatement = conditionSetting.Value;

            //order of replace matters, remove == before =, incase of ===
            conditionalStatement = conditionalStatement.Replace("==", "~").Replace("!=", "~").Replace('=', '~').Replace('!', '~').Replace('>', '~').Replace('<', '~').Replace(">=", "~").Replace("<=", "~");

            var listOfValidConditions = new List<string>() { "!=", "==", ">", "<", ">=", "<=" };

            if (conditionalStatement.Count(x => x == '~') != 1)
            {
                result.InvalidFieldList.Add(new KeyFieldData(batch.DECurrentField, "The IsDoubleKeyCondition does not contain a supported conditional statement. Contact System Administrator."));
                result.Status = ValidatorStatus.Fail;
                return result;
            }

文字列から条件文をテストするのと同じようなことをする必要がありました。

探していたものを1文字に置き換え、その1文字のインスタンスを数えました。

明らかに、あなたが使っている単一文字は、これが起こる前に文字列の中に存在しないことをチェックする必要があるでしょう。

2
bizah
string s = "HOWLYH THIS ACTUALLY WORKSH WOWH";
int count = 0;
for (int i = 0; i < s.Length; i++)
   if (s[i] == 'H') count++;

文字列内のすべての文字をチェックします。その文字が検索している文字である場合は、countに1を追加します。

1
joppiesaus
str="aaabbbbjjja";
int count = 0;
int size = str.Length;

string[] strarray = new string[size];
for (int i = 0; i < str.Length; i++)
{
    strarray[i] = str.Substring(i, 1);
}
Array.Sort(strarray);
str = "";
for (int i = 0; i < strarray.Length - 1; i++)
{

    if (strarray[i] == strarray[i + 1])
    {

        count++;
    }
    else
    {
        count++;
        str = str + strarray[i] + count;
        count = 0;
    }

}
count++;
str = str + strarray[strarray.Length - 1] + count;

これはキャラクターの発生数を数えるためのものです。この例では、出力は "a4b4j3"になります。

1
Narendra Kumar

私の最初のテイクは私に何かを与えました:

public static int CountOccurrences(string original, string substring)
{
    if (string.IsNullOrEmpty(substring))
        return 0;
    if (substring.Length == 1)
        return CountOccurrences(original, substring[0]);
    if (string.IsNullOrEmpty(original) ||
        substring.Length > original.Length)
        return 0;
    int substringCount = 0;
    for (int charIndex = 0; charIndex < original.Length; charIndex++)
    {
        for (int subCharIndex = 0, secondaryCharIndex = charIndex; subCharIndex < substring.Length && secondaryCharIndex < original.Length; subCharIndex++, secondaryCharIndex++)
        {
            if (substring[subCharIndex] != original[secondaryCharIndex])
                goto continueOuter;
        }
        if (charIndex + substring.Length > original.Length)
            break;
        charIndex += substring.Length - 1;
        substringCount++;
    continueOuter:
        ;
    }
    return substringCount;
}

public static int CountOccurrences(string original, char @char)
{
    if (string.IsNullOrEmpty(original))
        return 0;
    int substringCount = 0;
    for (int charIndex = 0; charIndex < original.Length; charIndex++)
        if (@char == original[charIndex])
            substringCount++;
    return substringCount;
}

これは約15.2かかりますが、置き換えと分割を使用したhaystackアプローチの針は21秒以上の時間がかかります。

CharIndexにsubstring.Length - 1を追加するビットを追加した後に編集します(11.6秒です)。

編集2:私は26個の2文字の文字列を持つ文字列を使いました。これは同じサンプルテキストに更新された時間です:

干し草の針(OPのバージョン):7.8秒

推奨されるメカニズム:4.6秒.

編集3:1文字のコーナーケースを追加して、それは1.2秒に行きました。

編集4:文脈のために:5000万回の繰り返しが使用された。

1
Alexander Morou

文字列区切り文字の場合(主題が言うように、charの場合ではありません):
string source = "@@@ once @@@ upon @@@ a @@@ time @@@";
int count = source.Split(new [] {"@@@"}、StringSplitOptions.RemoveEmptyEntries).Length - 1;

投稿者の元のソース値( "/ once/upon/a/time /")の自然な区切り文字はchar '/'であり、レスポンスはsource.Split(char [])オプションを説明します...

1
Sam Saarian

私は自分の拡張方法を輪にするだろうと思った(詳細についてはコメントを参照)。正式なベンチマーキングは行っていませんが、ほとんどのシナリオでは非常に高速である必要があると思います。

編集:わかりました - このSO質問で、私たちの現在の実装のパフォーマンスがここに提示された解決策のいくつかに対してどのように重なるのか疑問に思いました。私はちょっとしたベンチマーキングをすることにしました、そして私たちの解決策は、あなたが大きな文字列(100 Kb +)を使って積極的な検索をするまで、リチャードワトソンによって提供された解決策のパフォーマンスと非常に一致しました大きな部分文字列(32 Kb +)と多数の埋め込み反復(10K +)その時点で私達の解決策はおよそ2倍から4倍遅くなりました。これと、Richard Watsonが提示したソリューションが本当に気に入っているという事実を考えると、それに応じてソリューションをリファクタリングしました。私はちょうどそれから恩恵を受けるかもしれないだれでもこれを利用可能にしたかったです。

当社独自のソリューション

    /// <summary>
    /// Counts the number of occurrences of the specified substring within
    /// the current string.
    /// </summary>
    /// <param name="s">The current string.</param>
    /// <param name="substring">The substring we are searching for.</param>
    /// <param name="aggressiveSearch">Indicates whether or not the algorithm 
    /// should be aggressive in its search behavior (see Remarks). Default 
    /// behavior is non-aggressive.</param>
    /// <remarks>This algorithm has two search modes - aggressive and 
    /// non-aggressive. When in aggressive search mode (aggressiveSearch = 
    /// true), the algorithm will try to match at every possible starting 
    /// character index within the string. When false, all subsequent 
    /// character indexes within a substring match will not be evaluated. 
    /// For example, if the string was 'abbbc' and we were searching for 
    /// the substring 'bb', then aggressive search would find 2 matches 
    /// with starting indexes of 1 and 2. Non aggressive search would find 
    /// just 1 match with starting index at 1. After the match was made, 
    /// the non aggressive search would attempt to make it's next match 
    /// starting at index 3 instead of 2.</remarks>
    /// <returns>The count of occurrences of the substring within the string.</returns>
    public static int CountOccurrences(this string s, string substring, 
        bool aggressiveSearch = false)
    {
        // if s or substring is null or empty, substring cannot be found in s
        if (string.IsNullOrEmpty(s) || string.IsNullOrEmpty(substring))
            return 0;

        // if the length of substring is greater than the length of s,
        // substring cannot be found in s
        if (substring.Length > s.Length)
            return 0;

        var sChars = s.ToCharArray();
        var substringChars = substring.ToCharArray();
        var count = 0;
        var sCharsIndex = 0;

        // substring cannot start in s beyond following index
        var lastStartIndex = sChars.Length - substringChars.Length;

        while (sCharsIndex <= lastStartIndex)
        {
            if (sChars[sCharsIndex] == substringChars[0])
            {
                // potential match checking
                var match = true;
                var offset = 1;
                while (offset < substringChars.Length)
                {
                    if (sChars[sCharsIndex + offset] != substringChars[offset])
                    {
                        match = false;
                        break;
                    }
                    offset++;
                }
                if (match)
                {
                    count++;
                    // if aggressive, just advance to next char in s, otherwise, 
                    // skip past the match just found in s
                    sCharsIndex += aggressiveSearch ? 1 : substringChars.Length;
                }
                else
                {
                    // no match found, just move to next char in s
                    sCharsIndex++;
                }
            }
            else
            {
                // no match at current index, move along
                sCharsIndex++;
            }
        }

        return count;
    }

そして、これが私たちの修正された解決策です:

    /// <summary>
    /// Counts the number of occurrences of the specified substring within
    /// the current string.
    /// </summary>
    /// <param name="s">The current string.</param>
    /// <param name="substring">The substring we are searching for.</param>
    /// <param name="aggressiveSearch">Indicates whether or not the algorithm 
    /// should be aggressive in its search behavior (see Remarks). Default 
    /// behavior is non-aggressive.</param>
    /// <remarks>This algorithm has two search modes - aggressive and 
    /// non-aggressive. When in aggressive search mode (aggressiveSearch = 
    /// true), the algorithm will try to match at every possible starting 
    /// character index within the string. When false, all subsequent 
    /// character indexes within a substring match will not be evaluated. 
    /// For example, if the string was 'abbbc' and we were searching for 
    /// the substring 'bb', then aggressive search would find 2 matches 
    /// with starting indexes of 1 and 2. Non aggressive search would find 
    /// just 1 match with starting index at 1. After the match was made, 
    /// the non aggressive search would attempt to make it's next match 
    /// starting at index 3 instead of 2.</remarks>
    /// <returns>The count of occurrences of the substring within the string.</returns>
    public static int CountOccurrences(this string s, string substring, 
        bool aggressiveSearch = false)
    {
        // if s or substring is null or empty, substring cannot be found in s
        if (string.IsNullOrEmpty(s) || string.IsNullOrEmpty(substring))
            return 0;

        // if the length of substring is greater than the length of s,
        // substring cannot be found in s
        if (substring.Length > s.Length)
            return 0;

        int count = 0, n = 0;
        while ((n = s.IndexOf(substring, n, StringComparison.InvariantCulture)) != -1)
        {
            if (aggressiveSearch)
                n++;
            else
                n += substring.Length;
            count++;
        }

        return count;
    }
1
Casey Chester
string Name = "Very good Nice one is very good but is very good Nice one this is called the term";
bool valid=true;
int count = 0;
int k=0;
int m = 0;
while (valid)
{
    k = Name.Substring(m,Name.Length-m).IndexOf("good");
    if (k != -1)
    {
        count++;
        m = m + k + 4;
    }
    else
        valid = false;
}
Console.WriteLine(count + " Times accures");
1
Prashanth

このWebページをチェックアウトした場合 、これを行うための15の異なる方法が並列ループの使用を含めてベンチマークされています。

最速の方法は、シングルスレッドforループ(.Netバージョン<4.0がある場合)またはparallel.forループ(.Net> 4.0で何千ものチェックを使用する場合)を使用することです。

"ss"をあなたの検索文字列、 "ch"をあなたの文字配列(あなたが探している複数のcharを持っているなら)と仮定すると、これは最も速い実行時間のシングルスレッドを持つコードの基本的な要旨です:

for (int x = 0; x < ss.Length; x++)
{
    for (int y = 0; y < ch.Length; y++)
    {
        for (int a = 0; a < ss[x].Length; a++ )
        {
        if (ss[x][a] == ch[y])
            //it's found. DO what you need to here.
        }
    }
}

ベンチマークのソースコードも提供されているので、自分でテストを実行できます。

1

安全でないバイトごとの比較など、特定の種類のサブストリングのカウントが欠けていると感じました。私はオリジナルのポスターの方法と私が考えることができる方法をまとめました。

これらは私が作った文字列の拡張子です。

namespace Example
{
    using System;
    using System.Text;

    public static class StringExtensions
    {
        public static int CountSubstr(this string str, string substr)
        {
            return (str.Length - str.Replace(substr, "").Length) / substr.Length;
        }

        public static int CountSubstr(this string str, char substr)
        {
            return (str.Length - str.Replace(substr.ToString(), "").Length);
        }

        public static int CountSubstr2(this string str, string substr)
        {
            int substrlen = substr.Length;
            int lastIndex = str.IndexOf(substr, 0, StringComparison.Ordinal);
            int count = 0;
            while (lastIndex != -1)
            {
                ++count;
                lastIndex = str.IndexOf(substr, lastIndex + substrlen, StringComparison.Ordinal);
            }

            return count;
        }

        public static int CountSubstr2(this string str, char substr)
        {
            int lastIndex = str.IndexOf(substr, 0);
            int count = 0;
            while (lastIndex != -1)
            {
                ++count;
                lastIndex = str.IndexOf(substr, lastIndex + 1);
            }

            return count;
        }

        public static int CountChar(this string str, char substr)
        {
            int length = str.Length;
            int count = 0;
            for (int i = 0; i < length; ++i)
                if (str[i] == substr)
                    ++count;

            return count;
        }

        public static int CountChar2(this string str, char substr)
        {
            int count = 0;
            foreach (var c in str)
                if (c == substr)
                    ++count;

            return count;
        }

        public static unsafe int CountChar3(this string str, char substr)
        {
            int length = str.Length;
            int count = 0;
            fixed (char* chars = str)
            {
                for (int i = 0; i < length; ++i)
                    if (*(chars + i) == substr)
                        ++count;
            }

            return count;
        }

        public static unsafe int CountChar4(this string str, char substr)
        {
            int length = str.Length;
            int count = 0;
            fixed (char* chars = str)
            {
                for (int i = length - 1; i >= 0; --i)
                    if (*(chars + i) == substr)
                        ++count;
            }

            return count;
        }

        public static unsafe int CountSubstr3(this string str, string substr)
        {
            int length = str.Length;
            int substrlen = substr.Length;
            int count = 0;
            fixed (char* strc = str)
            {
                fixed (char* substrc = substr)
                {
                    int n = 0;

                    for (int i = 0; i < length; ++i)
                    {
                        if (*(strc + i) == *(substrc + n))
                        {
                            ++n;
                            if (n == substrlen)
                            {
                                ++count;
                                n = 0;
                            }
                        }
                        else
                            n = 0;
                    }
                }
            }

            return count;
        }

        public static int CountSubstr3(this string str, char substr)
        {
            return CountSubstr3(str, substr.ToString());
        }

        public static unsafe int CountSubstr4(this string str, string substr)
        {
            int length = str.Length;
            int substrLastIndex = substr.Length - 1;
            int count = 0;
            fixed (char* strc = str)
            {
                fixed (char* substrc = substr)
                {
                    int n = substrLastIndex;

                    for (int i = length - 1; i >= 0; --i)
                    {
                        if (*(strc + i) == *(substrc + n))
                        {
                            if (--n == -1)
                            {
                                ++count;
                                n = substrLastIndex;
                            }
                        }
                        else
                            n = substrLastIndex;
                    }
                }
            }

            return count;
        }

        public static int CountSubstr4(this string str, char substr)
        {
            return CountSubstr4(str, substr.ToString());
        }
    }
}

テストコードが続きます...

static void Main()
{
    const char matchA = '_';
    const string matchB = "and";
    const string matchC = "muchlongerword";
    const string testStrA = "_and_d_e_banna_i_o___pfasd__and_d_e_banna_i_o___pfasd_";
    const string testStrB = "and sdf and ans andeians andano ip and and sdf and ans andeians andano ip and";
    const string testStrC =
        "muchlongerword amuchlongerworsdfmuchlongerwordsdf jmuchlongerworijv muchlongerword sdmuchlongerword dsmuchlongerword";
    const int testSize = 1000000;
    Console.WriteLine(testStrA.CountSubstr('_'));
    Console.WriteLine(testStrA.CountSubstr2('_'));
    Console.WriteLine(testStrA.CountSubstr3('_'));
    Console.WriteLine(testStrA.CountSubstr4('_'));
    Console.WriteLine(testStrA.CountChar('_'));
    Console.WriteLine(testStrA.CountChar2('_'));
    Console.WriteLine(testStrA.CountChar3('_'));
    Console.WriteLine(testStrA.CountChar4('_'));
    Console.WriteLine(testStrB.CountSubstr("and"));
    Console.WriteLine(testStrB.CountSubstr2("and"));
    Console.WriteLine(testStrB.CountSubstr3("and"));
    Console.WriteLine(testStrB.CountSubstr4("and"));
    Console.WriteLine(testStrC.CountSubstr("muchlongerword"));
    Console.WriteLine(testStrC.CountSubstr2("muchlongerword"));
    Console.WriteLine(testStrC.CountSubstr3("muchlongerword"));
    Console.WriteLine(testStrC.CountSubstr4("muchlongerword"));
    var timer = new Stopwatch();
    timer.Start();
    for (int i = 0; i < testSize; ++i)
        testStrA.CountSubstr(matchA);
    timer.Stop();
    Console.WriteLine("CS1 chr: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrB.CountSubstr(matchB);
    timer.Stop();
    Console.WriteLine("CS1 and: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrC.CountSubstr(matchC);
    timer.Stop();
    Console.WriteLine("CS1 mlw: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrA.CountSubstr2(matchA);
    timer.Stop();
    Console.WriteLine("CS2 chr: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrB.CountSubstr2(matchB);
    timer.Stop();
    Console.WriteLine("CS2 and: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrC.CountSubstr2(matchC);
    timer.Stop();
    Console.WriteLine("CS2 mlw: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrA.CountSubstr3(matchA);
    timer.Stop();
    Console.WriteLine("CS3 chr: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrB.CountSubstr3(matchB);
    timer.Stop();
    Console.WriteLine("CS3 and: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrC.CountSubstr3(matchC);
    timer.Stop();
    Console.WriteLine("CS3 mlw: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrA.CountSubstr4(matchA);
    timer.Stop();
    Console.WriteLine("CS4 chr: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrB.CountSubstr4(matchB);
    timer.Stop();
    Console.WriteLine("CS4 and: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrC.CountSubstr4(matchC);
    timer.Stop();
    Console.WriteLine("CS4 mlw: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrA.CountChar(matchA);
    timer.Stop();
    Console.WriteLine("CC1 chr: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrA.CountChar2(matchA);
    timer.Stop();
    Console.WriteLine("CC2 chr: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrA.CountChar3(matchA);
    timer.Stop();
    Console.WriteLine("CC3 chr: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrA.CountChar4(matchA);
    timer.Stop();
    Console.WriteLine("CC4 chr: " + timer.Elapsed.TotalMilliseconds + "ms");
}

結果:CSXはCountSubstrXに対応し、CCXはCountCharXに対応します。 "chr"は '_'の文字列を検索し、 "and"は "and"の文字列を検索し、 "mlw"は "muchlongerword"の文字列を検索します。

CS1 chr: 824.123ms
CS1 and: 586.1893ms
CS1 mlw: 486.5414ms
CS2 chr: 127.8941ms
CS2 and: 806.3918ms
CS2 mlw: 497.318ms
CS3 chr: 201.8896ms
CS3 and: 124.0675ms
CS3 mlw: 212.8341ms
CS4 chr: 81.5183ms
CS4 and: 92.0615ms
CS4 mlw: 116.2197ms
CC1 chr: 66.4078ms
CC2 chr: 64.0161ms
CC3 chr: 65.9013ms
CC4 chr: 65.8206ms

そして最後に、私は360万文字のファイルを持っていました。 10万回繰り返された「derp adfderdserp dfaerpderp deasderp」でした。これらの結果を100回上記の方法でファイル内の "derp"を検索しました。

CS1Derp: 1501.3444ms
CS2Derp: 1585.797ms
CS3Derp: 376.0937ms
CS4Derp: 271.1663ms

だから私の4番目の方法は間違いなく勝者ですが、現実的には、100万回の360万文字のファイルが最悪のケースとして1586msしかかからなかった場合、これらのすべてはごくわずかです。

ところで、私はまた、CountSubstrとCountCharメソッドを100回使って、360万文字のファイルの中の 'd'文字を探しました。結果...

CS1  d : 2606.9513ms
CS2  d : 339.7942ms
CS3  d : 960.281ms
CS4  d : 233.3442ms
CC1  d : 302.4122ms
CC2  d : 280.7719ms
CC3  d : 299.1125ms
CC4  d : 292.9365ms

これによると、元のポスターの方法は大きな干し草の山の中の一文字の針にはとても悪いです。

注:すべての値はリリースバージョンの出力に更新されました。初めて投稿したときに、誤ってリリースモードでビルドするのを忘れてしまいました。私の声明のいくつかは修正されました。

1

system.Linqを使用します。

int CountOf => "A :: B C :: D" .Split( "::")。長さ - 1;

0
Solarev Sergey