Определить кол-во вхождений строки в строку — почему не работает?

Question

[Олег Остапчук]

using System;
 
class Kata{
  static int stringCounter(string s1, string s2)
  {
 
    bool b_n = s1.Contains(s2);
    int count;
 
    if ( !b_n )
        return 0;
 
        int index, length;
    do
    {
        length = s2.Length;
        index = s1.IndexOf(s2);
        s1 = s1.Remove(index,length);
        count++;
    }
    while (b_n);
 
            return count; 
  }
 
    static void Main() {
        
        string ControL = "тук-тук!";
        Console.WriteLine(ControL);
        Console.Write($"\"тук\" is {stringCounter(ControL, "тук")} times...")
        Console.ReadKey();
    }
}

Спасибо :)

Comments

[Foggy Finder]

Нет ; после

Console.Write($"\"тук\" is {stringCounter(ControL, "тук")} times...")

(вторая строчка с конца)

[Довольный Айтишникъ]

То есть вы не видите что вам компилятор говорит о синтаксических ошибках и о размере массива?

[stictt]

к двум коментам выше добавлю еще. что у вас бесконечный цикл, вы используете булевскую переменную которая не изменяется во время цикла. И судя по тому как вы называете переменные, вы явный новичок )

[Foggy Finder]

stictt, ох, пока писал свой ответ вы уже написали решение в комментариях. Если хотите могу удалить свой, чтобы не выглядело что я присвоил себе чужой ответ. Жаль, что здесь нет уведомление об изменении в вопросе при отправке.

[Олег Остапчук]

Довольный Жизнью,

о синтаксических ошибках

насколько помню, та строка, на которую он указывал, была не той искомой строкой. Или просто бывает ведь, что всегда ставишь все точки-запятые, а тут глядишь и не замечаешь.

Про ошибку насчёт "размера массива" - вообще непонятно было. Что за массив. Разумеется, я знаю, что раз у string есть Length - значит, это всё-таки char[] Но ведь Length - правильно написан - я пересматривал и сверялся. И только недоумевал - что за массив - откуда...

Answer 1

[#]

1 - https://duckduckgo.com/?q=c%23+%D0%9E%D0%BF%D1%80%...

запрос c# Определить кол-во вхождений строки в строку (под спойлером)

2 -

пару коротких вариантов

using System;
using System.Linq;
using System.Text.RegularExpressions;

namespace Occurrences
{
    class Program
    {
        static int method1(string source, string pattern)
            => new Regex(pattern).Matches(source).Count;

        static int method2(string source, string pattern)
            => source.Split(new string[] { pattern }, StringSplitOptions.None).Count() - 1;

        static void Main(string[] args)
        {
            var src = "тук - тук!";
            var ptn = "тук";
            Console.WriteLine($"'{ptn}' found on '{src}' use 'method1' {method1(src, ptn)} times...");
            Console.WriteLine($"'{ptn}' found on '{src}' use 'method2' {method2(src, ptn)} times...");
        }
    }
}

ну а по рукопашным вариантам.. ответ Foggy Finder пожалуй самодостаточен ))

Answer 2

[Foggy Finder]

Отбрасывая синтаксический ошибки (отсутствие точки с запятой и инициализации переменной) получаем следующую проблему:

Нет условия выхода из цикла - при текущей реализации программа упадет как только строка перестанет включать в себя вхождения.

Метод IndexOf вернет -1, в том случае если поиск оказался безрезультатным.

Очевидная проверка решает проблему:

if (index == -1)
    break;

Теперь к вопросу о том можно ли немного сократить код сохранив при этом подход.

Для начала использование метода Contains здесь выглядит избыточным - метод IndexOf вполне неплохо справится с этой задачей поиска.

Отдельная переменная length только создает лишний шум - длина подстроки остается неизменной.

Кроме того вместо метода Remove можно использовать метод Substring. Здесь большой разницы в использовании между ними нет, то лично мне кажется что название Substring лучше отражает суть происходящего. Но тут уже дело вкуса.

Напоследок - в C# принято называть методы с заглавной буквы, лучше соблюдать принятые соглашение об именовании.

Итого:

static int StringCounter(string s1, string s2)
{
    int count = 0;
    int index;
    while (true)
    {
        index = s1.IndexOf(s2);
        if (index == -1)
            return count;
        s1 = s1.Substring(index + s2.Length);
        count++;
    }
}

Comments

[Олег Остапчук]

Примечательно, что проверка

if (index == -1)
    break;

нужна даже для случая, когда метод вызывается единожды с IndexOf != -1

[#]

Олег Остапчук, еще бы )) ведь while (true)

[#]

Кроме того вместо метода Remove можно использовать метод Substring. Здесь большой разницы в использовании между ними нет, то лично мне кажется что название Substring лучше отражает суть происходящего. Но тут уже дело вкуса.

согласен что лучше отражает. мало того, это обычно приоритет в современном корпоративе - читаемость (а значит сопровождаемость кода)

.. но если кому то не лень - можно было бы забенчить варианты:
- с Remove
- с Substring
- с регулярками
- со сплитом

(последние два - см мой ответ)

.. на лимоне, или десяти, входных значений ))
меньше вряд ли будет разница достойная внимания

.. при этом, лично я бы сделал ставку именно на Substring, если аккуратно выписать сам метод ))
.. а аутсайдером по скорости, скорее ожидал бы увидеть регулярки

[Foggy Finder]

#, Можно еще по исходникам прикинуть, Remove, InternalSubString

[#]

Foggy Finder, и правда )).. а это точно не корка? десктопный фреймворк тоже открыли? ))

на глазок, скорее Substring.. если не буду сильно занят ближайшие пару часов - сделаю тест ))

[Foggy Finder]

#, не уверен - не помню насколько давно открыли эту часть исходников. Но учитывая что скоро будет один только .NET Core, то это не так и важно.

[#]

Foggy Finder, если не путаю, дотнет 5 обещан осенью 2020 ... а МС за такие сроки, иногда выкидывает фортели (хотя я то только за, можно сказать в предвкушении).. ))

[Foggy Finder]

#, да, в ноябре 2020 года

[#]

Foggy Finder, у вас вход на https://freedom.zulipchat.com/ по акку джита, косячит.. мне так кажется ))

[Foggy Finder]

#, не знаю, не пробовал зайти через гитхаб. Беглый поиск дал только старый ишшуй: Can't create account or login on chat.zulip.org wi...

[#]

Foggy Finder, не, не пляшет ((.. письмо с джита было, да, я кликнул по ссылке, но.. "не алле"

[#]

Foggy Finder, а вот по F# я пока только "слюнки пускал".. беру ваши репы в копилку ))

[Foggy Finder]

#, создал ишшуй: #12400 может что подскажут.

Вероятно имеет смысл временно отключить в настройках вход через гитхаб раз оно не стабильно работает?

[Foggy Finder]

а вот по F# я пока только "слюнки пускал"..

#, о, если будут вопросы по F# с радостью отвечу, если смогу, конечно. F# сообщество очень дружное (но я предвзят =)) Русскоязычное в основном в телеграмме сидит, а мировое - тут F# Slack Team

[#]

Олег Остапчук, Foggy Finder,

обещанный бенчмарк

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace Occurrences
{
    static class Program
    {
        static int useSubString(this string source, string pattern)
        {
            int count = 0;
            int index;
            while (true)
            {
                index = source.IndexOf(pattern);
                if (index == -1)
                    return count;
                source = source.Substring(index + pattern.Length);
                count++;
            }
        }

        static int useRemove(this string source, string pattern)
        {
            int count = 0;
            int index;
            while (true)
            {
                index = source.IndexOf(pattern);
                if (index == -1)
                    return count;
                source = source.Remove(index, pattern.Length);
                count++;
            }
        }

        static int useSplit(this string source, string pattern)
            => source.Split(new string[] { pattern }, StringSplitOptions.None).Count() - 1;

        static int useRegexp(this string source, string pattern)
            => new Regex(pattern).Matches(source).Count;

        static void sample()
        {
            var src = "тук - тук!";
            var ptn = "тук";
            $"'{ptn}' found on '{src}' use 'useSubString'\t {useSubString(src, ptn)} times...".print();
            $"'{ptn}' found on '{src}' use 'useRemove'\t {useRemove(src, ptn)} times...".print();
            $"'{ptn}' found on '{src}' use 'useSplit'\t {useSplit(src, ptn)} times...".print();
            $"'{ptn}' found on '{src}' use 'useRegexp'\t {useRegexp(src, ptn)} times...".print();
        }

        static Random rnd = new Random();
        static string pattren = genPattern();
        static string genPattern()
        {
            var l = rnd.Next(10, 20);
            var sb = new StringBuilder();
            for (var i = 0; i < l; i++)
                sb.Append((char)('A' + (char)rnd.Next(0, 26)));
            return sb.ToString();
        }

        static List<string> sources = new List<string>();
        static void fill(int n)
        {
            for (var i = 0; i < n; i++)
            {
                var l = rnd.Next(10, 20);
                var sb = new StringBuilder();
                for (var j = 0; j < l; j++)
                    if (rnd.Next(0, 7) % 3 != 0)
                        sb.Append((char)('A' + (char)rnd.Next(0, 26)));
                    else
                        sb.Append(pattren);
                sources.Add(sb.ToString());
            }
        }

        static void bench(int n)
        {
            // массивы что бы убрать влияние динамического создания объектов
            var uss = new int[n];
            var urm = new int[n];
            var usp = new int[n];
            var urx = new int[n];

            var sw = new Stopwatch();
            sw.Start();

            fill(n);
            var tsf = sw.Elapsed;
            sw.Reset();
            sw.Start();

            for (var i = 0; i < n; i++)
                uss[i] = sources[i].useSubString(pattren);
            var tss = sw.Elapsed;
            sw.Reset();
            sw.Start();

            for (var i = 0; i < n; i++)
                urm[i] = sources[i].useRemove(pattren);
            var trm = sw.Elapsed;
            sw.Reset();
            sw.Start();

            for (var i = 0; i < n; i++)
                usp[i] = sources[i].useSplit(pattren);
            var tsp = sw.Elapsed;
            sw.Reset();
            sw.Start();

            for (var i = 0; i < n; i++)
                urx[i] = sources[i].useRegexp(pattren);
            var trx = sw.Elapsed;
            sw.Stop();

            // весь вывод выносим за пределы замера
            $"fill\t {tsf.ToString(@"hh\:mm\:ss\.fffff")}".print();
            $"useSubString\t {tss.ToString(@"hh\:mm\:ss\.fffff")}".print();
            $"useRemove\t {trm.ToString(@"hh\:mm\:ss\.fffff")}".print();
            $"useSplit\t {tsp.ToString(@"hh\:mm\:ss\.fffff")}".print();
            $"useRegexp\t {trx.ToString(@"hh\:mm\:ss\.fffff")}".print();
            // вывод размерности массивов, что бы сборщик мусора не успел возбудиться ))
            $"{uss.Length} {urm.Length} {usp.Length} {urx.Length}".print();
        }

        static void Main(string[] args)
        {
            sample();
            var n = 1_000_000;
            bench(n);
        }

        static void print(this string s) => Console.WriteLine(s);
    }
}

.. и сюрпрайз

регекс ожидаемо проиграл, но и не сказать что бы фатально.. ))
сабстриг, так же ожидаемо выиграл у ремува...
но вот что сплит всех уделает "как бог черепаху" искренне не ожидал ))

[#]

Олег Остапчук, Foggy Finder,

добавил чек, для очистки совести ))

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace Occurrences
{
    static class Program
    {
        static int useSubString(this string source, string pattern)
        {
            int count = 0;
            int index;
            while (true)
            {
                index = source.IndexOf(pattern);
                if (index == -1)
                    return count;
                source = source.Substring(index + pattern.Length);
                count++;
            }
        }

        static int useRemove(this string source, string pattern)
        {
            int count = 0;
            int index;
            while (true)
            {
                index = source.IndexOf(pattern);
                if (index == -1)
                    return count;
                source = source.Remove(index, pattern.Length);
                count++;
            }
        }

        static int useSplit(this string source, string pattern)
            => source.Split(new string[] { pattern }, StringSplitOptions.None).Count() - 1;

        static int useRegexp(this string source, string pattern)
            => new Regex(pattern).Matches(source).Count;

        static void sample()
        {
            var src = "тук - тук!";
            var ptn = "тук";
            $"'{ptn}' found on '{src}' use 'useSubString'\t {useSubString(src, ptn)} times...".print();
            $"'{ptn}' found on '{src}' use 'useRemove'\t {useRemove(src, ptn)} times...".print();
            $"'{ptn}' found on '{src}' use 'useSplit'\t {useSplit(src, ptn)} times...".print();
            $"'{ptn}' found on '{src}' use 'useRegexp'\t {useRegexp(src, ptn)} times...".print();
        }

        static Random rnd = new Random();
        static string pattren = genPattern();
        static string genPattern()
        {
            var l = rnd.Next(10, 20);
            var sb = new StringBuilder();
            for (var i = 0; i < l; i++)
                sb.Append((char)('A' + (char)rnd.Next(0, 26)));
            return sb.ToString();
        }

        static List<string> sources = new List<string>();
        static void fill(int n)
        {
            for (var i = 0; i < n; i++)
            {
                var l = rnd.Next(10, 20);
                var sb = new StringBuilder();
                for (var j = 0; j < l; j++)
                    if (rnd.Next(0, 7) % 3 != 0)
                        sb.Append((char)('A' + (char)rnd.Next(0, 26)));
                    else
                        sb.Append(pattren);
                sources.Add(sb.ToString());
            }
        }

        static void bench(int n, bool check = true)
        {
            // массивы что бы убрать влияние динамического создания объектов
            var uss = new int[n];
            var urm = new int[n];
            var usp = new int[n];
            var urx = new int[n];

            var sw = new Stopwatch();
            sw.Start();

            fill(n);
            var tsf = sw.Elapsed;
            sw.Reset();
            sw.Start();

            for (var i = 0; i < n; i++)
                uss[i] = sources[i].useSubString(pattren);
            var tss = sw.Elapsed;
            sw.Reset();
            sw.Start();

            for (var i = 0; i < n; i++)
                urm[i] = sources[i].useRemove(pattren);
            var trm = sw.Elapsed;
            sw.Reset();
            sw.Start();

            for (var i = 0; i < n; i++)
                usp[i] = sources[i].useSplit(pattren);
            var tsp = sw.Elapsed;
            sw.Reset();
            sw.Start();

            for (var i = 0; i < n; i++)
                urx[i] = sources[i].useRegexp(pattren);
            var trx = sw.Elapsed;
            sw.Stop();

            // весь вывод выносим за пределы замера
            //Console.WriteLine(tsf.ToString(@"dddd\.hh\:mm\:ss\.fffffff"));
            $"fill\t {tsf.ToString(@"hh\:mm\:ss\.fffff")}".print();
            $"useSubString\t {tss.ToString(@"hh\:mm\:ss\.fffff")}".print();
            $"useRemove\t {trm.ToString(@"hh\:mm\:ss\.fffff")}".print();
            $"useSplit\t {tsp.ToString(@"hh\:mm\:ss\.fffff")}".print();
            $"useRegexp\t {trx.ToString(@"hh\:mm\:ss\.fffff")}".print();

            // выод размерности массивов, или чек, что бы сборщик мусора не успел возбудиться ))
            if (check)
                $"{chk(urm)} {chk(usp)} {chk(urx)}".print();
            else
                $"{uss.Length} {urm.Length} {usp.Length} {urx.Length}".print();

            bool chk(int[] x)
            {
                for (var i = 0; i < x.Length; i++)
                    if (uss[i] != x[i])
                        return false;
                return true;
            }
        }

        static void Main(string[] args)
        {
            sample();
            var n = 1_000_000;
            bench(n);
        }

        static void print(this string s) => Console.WriteLine(s);
    }
}

[#]

Олег Остапчук, Foggy Finder, обещаю закончить ))

мелкий рефакторинг.. но рекомендую найти отличия.. они такие, более шарповые что ли ))

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace Occurrences
{
    static class Program
    {
        static int useSubString(this string source, string pattern)
        {
            int count = 0;
            while (true)
            {
                var index = source.IndexOf(pattern);
                if (index < 0)
                    return count;
                source = source.Substring(index + pattern.Length);
                count++;
            }
        }

        static int useRemove(this string source, string pattern)
        {
            int count = 0;
            while (true)
            {
                var index = source.IndexOf(pattern);
                if (index < 0)
                    return count;
                source = source.Remove(index, pattern.Length);
                count++;
            }
        }

        static int useSplit(this string source, string pattern)
            => source.Split(new string[] { pattern }, StringSplitOptions.None).Count() - 1;

        static int useRegexp(this string source, string pattern)
            => new Regex(pattern).Matches(source).Count;

        static void sample(string src = "тук - тук!", string ptn = "тук")
        {
            $"'{ptn}' found on '{src}' use 'useSubString'\t {useSubString(src, ptn)} times...".print();
            $"'{ptn}' found on '{src}' use 'useRemove'\t {useRemove(src, ptn)} times...".print();
            $"'{ptn}' found on '{src}' use 'useSplit'\t {useSplit(src, ptn)} times...".print();
            $"'{ptn}' found on '{src}' use 'useRegexp'\t {useRegexp(src, ptn)} times...".print();
        }

        static Random rnd = new Random();
        static string pattren = genPattern();
        static string genPattern()
        {
            var l = rnd.Next(10, 20);
            var sb = new StringBuilder();
            for (var i = 0; i < l; i++)
                sb.Append((char)('A' + (char)rnd.Next(0, 26)));
            return sb.ToString();
        }

        static List<string> sources = new List<string>();
        static void fill(int n)
        {
            for (var i = 0; i < n; i++)
            {
                var l = rnd.Next(10, 20);
                var sb = new StringBuilder();
                for (var j = 0; j < l; j++)
                    if (rnd.Next(0, 7) % 3 != 0)
                        sb.Append((char)('A' + (char)rnd.Next(0, 26)));
                    else
                        sb.Append(pattren);
                sources.Add(sb.ToString());
            }
        }

        static void bench(int n = 1_000_000, bool check = true)
        {
            // массивы что бы убрать влияние динамического создания объектов
            var uss = new int[n];
            var urm = new int[n];
            var usp = new int[n];
            var urx = new int[n];

            var sw = new Stopwatch();
            sw.Start();

            fill(n);
            var tsf = sw.Elapsed;
            sw.Reset();
            sw.Start();

            for (var i = 0; i < n; i++)
                uss[i] = sources[i].useSubString(pattren);
            var tss = sw.Elapsed;
            sw.Reset();
            sw.Start();

            for (var i = 0; i < n; i++)
                urm[i] = sources[i].useRemove(pattren);
            var trm = sw.Elapsed;
            sw.Reset();
            sw.Start();

            for (var i = 0; i < n; i++)
                usp[i] = sources[i].useSplit(pattren);
            var tsp = sw.Elapsed;
            sw.Reset();
            sw.Start();

            for (var i = 0; i < n; i++)
                urx[i] = sources[i].useRegexp(pattren);
            var trx = sw.Elapsed;
            sw.Stop();

            // весь вывод выносим за пределы замера
            $"fill\t\t {tsf.ToString(@"hh\:mm\:ss\.fffff")}".print();
            $"useSubString\t {tss.ToString(@"hh\:mm\:ss\.fffff")}".print();
            $"useRemove\t {trm.ToString(@"hh\:mm\:ss\.fffff")}".print();
            $"useSplit\t {tsp.ToString(@"hh\:mm\:ss\.fffff")}".print();
            $"useRegexp\t {trx.ToString(@"hh\:mm\:ss\.fffff")}".print();

            // выод размерности массивов, или чек, что бы сборщик мусора не успел возбудиться ))
            if (check)
                $"{chk(urm)} {chk(usp)} {chk(urx)}".print();
            else
                $"{uss.Length} {urm.Length} {usp.Length} {urx.Length}".print();

            bool chk(int[] x)
            {
                for (var i = 0; i < x.Length; i++)
                    if (uss[i] != x[i])
                        return false;
                return true;
            }
        }

        static void Main(string[] args)
        {
            sample();
            bench();
        }

        static void print(this string s) => Console.WriteLine(s);
    }
}

[Foggy Finder]

но вот что сплит всех уделает "как бог черепаху" искренне не ожидал ))

#, хм, такой разницы и я не ожидал. Можно было бы использовать другую перегрузку IndexOf чтобы не копировать строку каждый раз, но там выигрыш в скорости будет не такой большой. Split все равно будет быстрее.

[#]

Foggy Finder, хмм.. вот вертелось в голове.. но

увы, разочарование

ну то есть у прочих "строчных" методов вроде и выиграли.. можно даже сказать заметно.. но сплит рулит )))

код (надеюсь ни чего не упустил?)

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace Occurrences
{
    static class Program
    {
        static int useSubString(this string source, string pattern)
        {
            var count = 0;
            while (true)
            {
                var index = source.IndexOf(pattern);
                if (index < 0)
                    return count;
                source = source.Substring(index + pattern.Length);
                count++;
            }
        }

        static int useRemove(this string source, string pattern)
        {
            var count = 0;
            while (true)
            {
                var index = source.IndexOf(pattern);
                if (index < 0)
                    return count;
                source = source.Remove(index, pattern.Length);
                count++;
            }
        }

        static int useIndex(this string source, string pattern)
        {
            var count = 0;
            var pos = 0;
            var len = pattern.Length;
            while (true)
            {
                var index = source.IndexOf(pattern, pos);
                if (index < 0)
                    return count;
                pos = index + len;
                count++;
            }
        }

        static int useSplit(this string source, string pattern)
            => source.Split(new string[] { pattern }, StringSplitOptions.None).Count() - 1;

        static int useRegexp(this string source, string pattern)
            => new Regex(pattern).Matches(source).Count;

        static void sample(string src = "тук - тук!", string ptn = "тук")
        {
            $"'{ptn}' found on '{src}' use 'useSubString'\t {src.useSubString(ptn)} times...".print();
            $"'{ptn}' found on '{src}' use 'useRemove'\t {src.useRemove(ptn)} times...".print();
            $"'{ptn}' found on '{src}' use 'useIndexOf'\t {src.useIndex(ptn)} times...".print();
            $"'{ptn}' found on '{src}' use 'useSplit'\t {src.useSplit(ptn)} times...".print();
            $"'{ptn}' found on '{src}' use 'useRegexp'\t {src.useRegexp(ptn)} times...".print();
        }

        static Random rnd = new Random();
        static string pattren = genPattern();
        static string genPattern()
        {
            var l = rnd.Next(10, 20);
            var sb = new StringBuilder();
            for (var i = 0; i < l; i++)
                sb.Append((char)('A' + (char)rnd.Next(0, 26)));
            return sb.ToString();
        }

        static List<string> sources = new List<string>();
        static void fill(int n)
        {
            for (var i = 0; i < n; i++)
            {
                var l = rnd.Next(10, 20);
                var sb = new StringBuilder();
                for (var j = 0; j < l; j++)
                    if (rnd.Next(0, 7) % 3 != 0)
                        sb.Append((char)('A' + (char)rnd.Next(0, 26)));
                    else
                        sb.Append(pattren);
                sources.Add(sb.ToString());
            }
        }

        static void bench(int n = 1_000_000, bool check = true)
        {
            // массивы что бы убрать влияние динамического создания объектов
            var uss = new int[n];
            var urm = new int[n];
            var uio = new int[n];
            var usp = new int[n];
            var urx = new int[n];

            var sw = new Stopwatch();
            sw.Start();

            fill(n);
            var tsf = sw.Elapsed;
            sw.Reset();
            sw.Start();

            for (var i = 0; i < n; i++)
                uss[i] = sources[i].useSubString(pattren);
            var tss = sw.Elapsed;
            sw.Reset();
            sw.Start();

            for (var i = 0; i < n; i++)
                urm[i] = sources[i].useRemove(pattren);
            var trm = sw.Elapsed;
            sw.Reset();
            sw.Start();

            for (var i = 0; i < n; i++)
                uio[i] = sources[i].useIndex(pattren);
            var tio = sw.Elapsed;
            sw.Reset();
            sw.Start();

            for (var i = 0; i < n; i++)
                usp[i] = sources[i].useSplit(pattren);
            var tsp = sw.Elapsed;
            sw.Reset();
            sw.Start();

            for (var i = 0; i < n; i++)
                urx[i] = sources[i].useRegexp(pattren);
            var trx = sw.Elapsed;
            sw.Stop();

            // весь вывод выносим за пределы замера
            $"fill\t\t {tsf.ToString(@"hh\:mm\:ss\.fffff")}".print();
            $"useSubString\t {tss.ToString(@"hh\:mm\:ss\.fffff")}".print();
            $"useRemove\t {trm.ToString(@"hh\:mm\:ss\.fffff")}".print();
            $"useIndexOf\t {tio.ToString(@"hh\:mm\:ss\.fffff")}".print();
            $"useSplit\t {tsp.ToString(@"hh\:mm\:ss\.fffff")}".print();
            $"useRegexp\t {trx.ToString(@"hh\:mm\:ss\.fffff")}".print();

            // выод размерности массивов, или чек, что бы сборщик мусора не успел возбудиться ))
            if (check)
                $"{chk(urm)} {chk(usp)} {chk(uio)} {chk(urx)}".print();
            else
                $"{uss.Length} {urm.Length} {usp.Length} {urx.Length}".print();

            bool chk(int[] x)
            {
                for (var i = 0; i < x.Length; i++)
                    if (uss[i] != x[i])
                        return false;
                return true;
            }
        }

        static void Main(string[] args)
        {
            sample();
            bench();
        }

        static void print(this string s) => Console.WriteLine(s);
    }
}

[#]

Foggy Finder,

мелкий рефакторинг, кажется даже улучшил метод на основе индекса, но самую малость

static int useIndex(this string source, string pattern)
        {
            var count = 0;
            var index = 0;
            while (true)
            {
                index = source.IndexOf(pattern, index);
                if (index < 0)
                    return count;
                index += pattern.Length;
                count++;
            }
        }

[Foggy Finder]

#, я бы избавился от while (true), перенеся условие из if туда, но это дело вкуса, на скорость повлиять не должно. Вопрос любопытный как появится время попробую разобраться почему такая большая разница.

[#]

Foggy Finder,

уже маньячим )) сокращаем количество строк, но время и правда чуток лучше ))

static int useIndex(this string source, string pattern)
        {
            var count = 0;
            var index = 0;
            while (true)
                if ((index = source.IndexOf(pattern, index)) < 0)
                    return count;
                else
                {
                    index += pattern.Length;
                    count++;
                }
        }

[#]

Foggy Finder,

снова маньячим (сишничаем )))

static int useIndex(this string source, string pattern)
        {
            for (int count = 0, index = 0; ; count++)
                if ((index = source.IndexOf(pattern, index)) < 0)
                    return count;
                else
                    index += pattern.Length;
        }

ухожу, ухожу, ухожу ... (с)

[#]

Foggy Finder,

если будут вопросы по F# с радостью отвечу, если смогу, конечно.

а переписать на F# мой "бенчмарк".. хлопотно? было бы любопытно ))

[Foggy Finder]

#, для замеров лучше использовать стандартную библиотеку бенчмаркдотнет, со мной поделились кодом:

результаты:

| Method | Mean | Error | StdDev | Median | Gen 0 | Gen 1 | Gen 2 | Allocated |
|------------- |----------:|----------:|-----------:|----------:|------:|------:|------:|----------:|
| UseSubstring | 156.15 us | 17.203 us | 50.181 us | 155.06 us | - | - | - | 49152 B |
| UseRemove | 358.88 us | 40.372 us | 119.037 us | 346.05 us | - | - | - | 49152 B |
| UseIndex | 55.18 us | 4.562 us | 13.379 us | 52.65 us | - | - | - | - |
| UseSplit | 15.85 us | 2.039 us | 5.949 us | 14.06 us | - | - | - | 16384 B |
| UseRegexp | 64.28 us | 3.878 us | 11.064 us | 63.59 us | - | - | - | 16384 B
| UseReplace | 11.97 us | 1.489 us | 4.272 us | 12.05 us | - | - | - | - |

// * Legends *
Mean : Arithmetic mean of all measurements
Error : Half of 99.9% confidence interval
StdDev : Standard deviation of all measurements
Median : Value separating the higher half of all measurements (50th percentile)
Gen 0 : GC Generation 0 collects per 1000 operations
Gen 1 : GC Generation 1 collects per 1000 operations
Gen 2 : GC Generation 2 collects per 1000 operations
Allocated : Allocated memory per single operation (managed only, inclusive, 1KB = 1024B)
1 us : 1 Microsecond (0.000001 sec)

код

код

class Program
    {
        static void Main() => BenchmarkRunner.Run<Benchmark>();
    }

    [MemoryDiagnoser]
    public class Benchmark
    {
        static Random rnd = new Random();

        static string GenPattern()
        {
            var l = rnd.Next(10, 20);
            var sb = new StringBuilder();
            for (var i = 0; i < l; i++)
                sb.Append((char)('A' + rnd.Next(0, 26)));
            return sb.ToString();
        }

        static string GenSource(string pattern)
        {
            var l = rnd.Next(100, 200);
            var sb = new StringBuilder();
            for (var j = 0; j < l; j++)
                if (rnd.Next(0, 7) % 3 != 0)
                    sb.Append((char)('A' + rnd.Next(0, 26)));
                else
                    sb.Append(pattern);
            return sb.ToString();
        }

        [IterationSetup]
        public void Setup()
        {
            pattern = GenPattern();
            source = GenSource(pattern);
        }

        string source;
        string pattern;

        [Benchmark]
        public int UseSubstring()
        {
            var count = 0;
            while (true)
            {
                var index = source.IndexOf(pattern);
                if (index < 0)
                    return count;
                source = source.Substring(index + pattern.Length);
                count++;
            }
        }

        [Benchmark]
        public int UseRemove()
        {
            var count = 0;
            while (true)
            {
                var index = source.IndexOf(pattern);
                if (index < 0)
                    return count;
                source = source.Remove(index, pattern.Length);
                count++;
            }
        }

        [Benchmark]
        public int UseIndex()
        {
            int c = 0, i = -pattern.Length;
            while ((i = source.IndexOf(pattern, i + pattern.Length)) > -1) ++c;
            return c;
        }

        [Benchmark]
        public int UseSplit()
            => source.Split(new string[] { pattern }, StringSplitOptions.None).Length - 1;

        [Benchmark]
        public int UseRegexp()
            => new Regex(pattern).Matches(source).Count;

        [Benchmark]
        public int UseReplace()
            => (source.Length - source.Replace(pattern, "").Length) / pattern.Length;
    }

В итоге побеждает Replace - изящное и, на мой взгляд, далеко не очевидное решение.

[Foggy Finder]

а переписать на F# мой "бенчмарк".. хлопотно? было бы любопыт

#, смогу написать только ближе к понедельнику

[#]

Foggy Finder,

В итоге побеждает Replace - изящное и, на мой взгляд, далеко не очевидное решение.

тоже интересный прием..

и в моем ломовом тесте он картина такая же ))

смогу написать только ближе к понедельнику

не вопрос, даже если и не сложится. но если сложится - мне проще заходить на "новые территории" сравнивая решения задачи, которая уже решена знакомым способом. как наверное и всем ))

[#]

Foggy Finder, думаю и

Replace

и

Split

имеют минимальные простые обертки, к низкоуровневым реализациям. наверняка аналоги давно есть в рантаймах типа user32.dll, или где то рядом ))

по результатам.. нуу.. мне кажется, мой ломовой вариант бенчмарка, дает очень схожие итоги

заметил, что бенчмаркдотнет, не пытается изолировать сборщик мусора, но отчитывается о нем. но и не готов заявить, что сам не упустил все варианты его деятельности - все версии, кроме Replace, основанные на базовых строковых функциях, неизбежно оставляют мусор )).. в общем буду осваивать сей бенчмарк. раньше видел упоминания, даже где то повесил в ссылки.. но спасибо за готовый пример кода, это снова быстрее, чем слабо мотивированные заходы ))

[Foggy Finder]

#,

вот перевод на F#

open System
open System.Text.RegularExpressions
open System.Text
open System.Diagnostics

module String =
    let print = printfn "%s"
    let useSubString x (pattern:string) = 
        let rec loop (source:string) count = 
            let index = source.IndexOf pattern 
            if source.IndexOf pattern < 0 then count
            else
                count + 1 |> loop (source.Substring (index + pattern.Length)) 
        loop x 0
    
    let useRemove x (pattern:string) = 
        let rec loop (source:string) count = 
            let index = source.IndexOf pattern 
            if source.IndexOf pattern < 0 then count
            else
                count + 1 |> loop (source.Remove(index, pattern.Length)) 
        loop x 0

    let useSplit (x:string) (pattern:string) = 
           x.Split([| pattern |], StringSplitOptions.None).Length - 1

    let useRegexp x (pattern:string) = Regex(pattern).Matches(x).Count

let sample() =
    let src = "тук - тук!"
    let ptn = "тук"
    [
        "useSubString", String.useSubString
        "useRemove", String.useRemove
        "useSplit", String.useSplit
        "useRegexp", String.useRegexp
    ]
    |> List.map(fun (n,f) ->
        f src ptn |> sprintf "'%s' found on '%s' use '%s'\t %i times..." ptn src n
    )
    |> List.iter String.print

let rnd = Random()
let genPattern() = 
    let l = rnd.Next(10, 20)
    (StringBuilder(), [0..l - 1])
    ||> List.fold (fun sb _ -> sb.Append('A').Append(rnd.Next 26))
            
let pattren = genPattern().ToString()

let fill n = 
    Array.init n (fun _ ->
         let l = rnd.Next(10, 20)
         (StringBuilder(), [0..l - 1])
         ||> List.fold (fun sb _ ->
            if (rnd.Next(0, 7) % 3 <> 0) then
                sb.Append('A').Append(rnd.Next 26)
            else
                sb.Append pattren
         )
         |> fun sb -> sb.ToString()
   )

let bench() = 
    let n = 1_000_000

    // массивы что бы убрать влияние динамического создания объектов
    let uss = Array.zeroCreate n
    let urm = Array.zeroCreate n
    let usp = Array.zeroCreate n
    let urx = Array.zeroCreate n

    let sw = Stopwatch()
    sw.Start()

    let sources = fill(n)
    let tsf = sw.Elapsed
    sw.Reset()
    sw.Start()

    for i in 0..n-1 do
        uss.[i] <- String.useSubString sources.[i] pattren 
    let tss = sw.Elapsed
    sw.Reset()
    sw.Start()

    for i in 0..n-1 do
        urm.[i] <- String.useRemove sources.[i] pattren 
    let trm = sw.Elapsed
    sw.Reset()
    sw.Start()

    for i in 0..n-1 do
        usp.[i] <- String.useSplit sources.[i] pattren 

    let tsp = sw.Elapsed
    sw.Reset()
    sw.Start()

    for i in 0..n-1 do
        urx.[i] <- String.useRegexp sources.[i] pattren 
    let trx = sw.Elapsed
    sw.Stop()

    // весь вывод выносим за пределы замера
    [
        sprintf "fill\t\t %s" <| tsf.ToString(@"hh\:mm\:ss\.fffff")
        sprintf "useSubString\t %s"  <| tss.ToString(@"hh\:mm\:ss\.fffff")
        sprintf "useRemove\t %s" <| trm.ToString(@"hh\:mm\:ss\.fffff")
        sprintf "useSplit\t %s" <| tsp.ToString(@"hh\:mm\:ss\.fffff")
        sprintf "useRegexp\t %s" <| trx.ToString(@"hh\:mm\:ss\.fffff")
    ] |> List.iter String.print

    // выод размерности массивов, или чек, что бы сборщик мусора не успел возбудиться ))
    printfn "%i %i %i %i" uss.Length urm.Length usp.Length urx.Length

sample()
bench()

код далеко не везде идиоматичный, но по другому было бы крайне сложно сохранить исходный посыл.

[Foggy Finder]

#, в ишшуе просят "clear/precise series of steps" для воспроизведения проблемы - если есть возможность, то напишите чуть подробнее

[#]

Foggy Finder,

touch Occurrences.fs

огромное спасибо!
и ща гляну по ишую что можно уточнить

[#]

Foggy Finder, но я бы предпочел, как можно скорее, удалить такие скрины.. ))

.. из паблика.. да с имгура тоже ))

[Foggy Finder]

#, посмотрел, удаляйте