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

Question

Олег Остапчук @number_118

C#

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

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

Спасибо :)

Вопрос задан более трёх лет назад
217 просмотров

5 комментариев

Подписаться 2 Простой 5 комментариев

Foggy Finder @FoggyFinder
Нет ; после

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

(вторая строчка с конца)
Написано более трёх лет назад
Довольный Айтишникъ @borisdenis

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

Написано более трёх лет назад
stictt @stictt

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

Написано более трёх лет назад
Foggy Finder @FoggyFinder

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

Написано более трёх лет назад
Олег Остапчук @number_118 Автор вопроса

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

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

Написано более трёх лет назад

Решения вопроса 2

Комментировать

33 комментария

Олег Остапчук @number_118 Автор вопроса
Примечательно, что проверка

if (index == -1) break;

нужна даже для случая, когда метод вызывается единожды с IndexOf != -1
Написано более трёх лет назад
# @mindtester Куратор тега C#

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

Написано более трёх лет назад
# @mindtester Куратор тега C#

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

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

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

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

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

Написано более трёх лет назад
Foggy Finder @FoggyFinder

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

Написано более трёх лет назад
# @mindtester Куратор тега C#

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

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

Написано более трёх лет назад
Foggy Finder @FoggyFinder

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

Написано более трёх лет назад
# @mindtester Куратор тега C#

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

Написано более трёх лет назад
Foggy Finder @FoggyFinder

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

Написано более трёх лет назад
# @mindtester Куратор тега C#

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

Написано более трёх лет назад
Foggy Finder @FoggyFinder

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

Написано более трёх лет назад
# @mindtester Куратор тега C#

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

Написано более трёх лет назад
# @mindtester Куратор тега C#

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

Написано более трёх лет назад
Foggy Finder @FoggyFinder

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

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

Написано более трёх лет назад
Foggy Finder @FoggyFinder

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

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

Написано более трёх лет назад

# @mindtester Куратор тега C#

Олег Остапчук, 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);
    }
}

.. и сюрпрайз

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

Написано более трёх лет назад

# @mindtester Куратор тега C#

Олег Остапчук, 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);
    }
}

Написано более трёх лет назад

# @mindtester Куратор тега C#

Олег Остапчук, 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 @FoggyFinder

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

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

Написано более трёх лет назад

# @mindtester Куратор тега C#

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

Написано более трёх лет назад

# @mindtester Куратор тега C#

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 @FoggyFinder

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

Написано более трёх лет назад

# @mindtester Куратор тега C#

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

Написано более трёх лет назад

# @mindtester Куратор тега C#

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

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

Написано более трёх лет назад

# @mindtester Куратор тега C#

Foggy Finder,
если будут вопросы по F# с радостью отвечу, если смогу, конечно.
а переписать на F# мой "бенчмарк".. хлопотно? было бы любопытно ))

Написано более трёх лет назад

Foggy Finder @FoggyFinder

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

результаты:

| 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 @FoggyFinder

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

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

Написано более трёх лет назад
# @mindtester Куратор тега C#

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

Написано более трёх лет назад
# @mindtester Куратор тега C#

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

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

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

Написано более трёх лет назад

Foggy Finder @FoggyFinder

#,

вот перевод на 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 @FoggyFinder

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

Написано более трёх лет назад
# @mindtester Куратор тега C#

Foggy Finder,
touch Occurrences.fs
огромное спасибо!
и ща гляну по ишую что можно уточнить

Написано более трёх лет назад
# @mindtester Куратор тега C#

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

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

Написано более трёх лет назад
Foggy Finder @FoggyFinder

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

Написано более трёх лет назад

Пригласить эксперта

Ваш ответ на вопрос

Войдите, чтобы написать ответ

Войти через центр авторизации

Похожие вопросы

C#

+3 ещё

Простой
На чём написать CMS?
- 1 подписчик
- 2 часа назад
- 99 просмотров
5

ответов
C#

+1 ещё

Простой
Как решить проблему database is locked?
- 1 подписчик
- вчера
- 75 просмотров
1

ответ
C#

Простой
C# и несколько CPU?
- 6 подписчиков
- 15 апр.
- 3512 просмотров
3

ответа
C#

+1 ещё

Простой
Как сделать смену обьекта при приближении?
- 1 подписчик
- 14 апр.
- 68 просмотров
1

ответ
Windows

+2 ещё

Простой
Как обеспечить относительный путь к БД SQLite?
- 1 подписчик
- 14 апр.
- 117 просмотров
3

ответа
C#

+1 ещё

Простой
Как понять что я выучил основы C#?
- 1 подписчик
- 12 апр.
- 470 просмотров
4

ответа
C#

+1 ещё

Средний
Почему не работают миграции при переходе на новый csproj формат?
- 1 подписчик
- 12 апр.
- 54 просмотра
1

ответ
C#

Простой
Что означает оператор => в linq c#?
- 1 подписчик
- 12 апр.
- 135 просмотров
2

ответа
C#

+1 ещё

Простой
Почему некорректно работает параметр маршрутизатора Razor Pages?
- 1 подписчик
- 11 апр.
- 53 просмотра
1

ответ
C#

Простой
Как сделать чтобы приложение для win ce открывалось на весь экран?
- 1 подписчик
- 11 апр.
- 52 просмотра
1

ответ
Показать ещё Загружается…

Разработчик C# (криптография)

Avanpost

от 200 000 ₽

Middle+ .Net(C#) developer

Zam.io

от 200 000 до 300 000 ₽

Middle C# developer

ЮГПА • Ростов-на-Дону

от 130 000 до 170 000 ₽

Настройка сервера

18 апр. 2024, в 21:56

2000 руб./за проект

Помощь с водпресс

18 апр. 2024, в 21:00

150 руб./за проект

Спарсить ссылки на все товары конкретного продавца в озон

18 апр. 2024, в 20:13

2000 руб./за проект

Нет ; после

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

(вторая строчка с конца)
То есть вы не видите что вам компилятор говорит о синтаксических ошибках и о размере массива?
к двум коментам выше добавлю еще. что у вас бесконечный цикл, вы используете булевскую переменную которая не изменяется во время цикла. И судя по тому как вы называете переменные, вы явный новичок )
stictt, ох, пока писал свой ответ вы уже написали решение в комментариях. Если хотите могу удалить свой, чтобы не выглядело что я присвоил себе чужой ответ. Жаль, что здесь нет уведомление об изменении в вопросе при отправке.
Довольный Жизнью,
о синтаксических ошибках
насколько помню, та строка, на которую он указывал, была не той искомой строкой. Или просто бывает ведь, что всегда ставишь все точки-запятые, а тут глядишь и не замечаешь.

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

Answer 1 · 2019-05-24 13:05:05

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 · 2019-05-24 13:10:23

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

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

Метод 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++;
    }
}

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

Войдите, чтобы написать ответ

Минуточку внимания

Войдите на сайт