Exemplo n.º 1
0
        /// <summary>
        /// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения каждой буквы.
        /// Статистика РЕГИСТРОЗАВИСИМАЯ!
        /// </summary>
        /// <param name="stream">Стрим для считывания символов для последующего анализа</param>
        /// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
        private static IList <LetterStats> FillSingleLetterStats(IReadOnlyStream stream)
        {
            stream.ResetPositionToStart();
            Dictionary <char, LetterStats> letterDict = new Dictionary <char, LetterStats>();

            while (!stream.IsEof)
            {
                char c = stream.ReadNextChar();
                if (!IsLetter(c))
                {
                    continue;
                }
                // TODO : заполнять статистику с использованием метода IncStatistic. Учёт букв - регистрозависимый.
                if (letterDict.TryGetValue(c, out var letter))
                {
                    IncStatistic(letter);
                }
                else
                {
                    letterDict.Add(c, new LetterStats()
                    {
                        Letter = c.ToString(),
                        Count  = 1
                    });
                }
            }

            return(new List <LetterStats>(letterDict.Values));
        }
Exemplo n.º 2
0
        /// <summary>
        /// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения каждой буквы.
        /// Статистика РЕГИСТРОЗАВИСИМАЯ!
        /// </summary>
        /// <param name="stream">Стрим для считывания символов для последующего анализа</param>
        /// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
        private static IList <LetterStats> FillSingleLetterStats(IReadOnlyStream stream)
        {
            stream.ResetPositionToStart();
            List <LetterStats> singleLetters = new List <LetterStats>();

            while (!stream.IsEof)
            {
                char   c     = stream.ReadNextChar();
                string value = c.ToString();
                if (!Char.IsLetter(c)) // если символ не является буквой - идем на следующую итерацию
                {
                    continue;
                }

                var foundIndex = singleLetters.FindIndex(stat => stat.Letter.Equals(value));
                if (foundIndex >= 0)
                {
                    OnFoundIndex(singleLetters, foundIndex);
                }
                else // если в коллекции записи о букве нет - создаем запись, определяя тип звука
                {
                    CharType type = Vowel.Contains(value) ? CharType.Vowel : CharType.Consonants;
                    singleLetters.Add(new LetterStats(type, value, 1));
                }
            }
            return(singleLetters);
        }
Exemplo n.º 3
0
        /// <summary>
        /// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения парных букв.
        /// В статистику должны попадать только пары из одинаковых букв, например АА, СС, УУ, ЕЕ и т.д.
        /// Статистика - НЕ регистрозависимая!
        /// </summary>
        /// <param name="stream">Стрим для считывания символов для последующего анализа</param>
        /// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
        //private static IList<LetterStats> FillDoubleLetterStats(IReadOnlyStream stream)
        private static void FillDoubleLetterStats(IReadOnlyStream stream, AlphabetLetter alphabetDoubleLetter)
        {
            char c1 = '0', c2;

            stream.ResetPositionToStart();
            if (!stream.IsEof)
            {
                c1 = Char.ToLower(stream.ReadNextChar());
            }

            while (!stream.IsEof)
            {
                c2 = Char.ToLower(stream.ReadNextChar());
                // TODO : заполнять статистику с использованием метода IncStatistic. Учёт букв - НЕ регистрозависимый.
                for (int i = 0; i < alphabetDoubleLetter.alphabet.Length; i++)
                {
                    if (c1 == alphabetDoubleLetter.alphabet[i] && c2 == alphabetDoubleLetter.alphabet[i])
                    {
                        alphabetDoubleLetter.letterCounter[i]++;
                        break;
                    }
                }
                c1 = c2;
            }
        }
Exemplo n.º 4
0
        /// <summary>
        /// Программа принимает на входе 2 пути до файлов.
        /// Анализирует в первом файле кол-во вхождений каждой буквы (регистрозависимо). Например А, б, Б, Г и т.д.
        /// Анализирует во втором файле кол-во вхождений парных букв (не регистрозависимо). Например АА, Оо, еЕ, тт и т.д.
        /// По окончанию работы - выводит данную статистику на экран.
        /// </summary>
        /// <param name="args">Первый параметр - путь до первого файла.
        /// Второй параметр - путь до второго файла.</param>
        static void Main(string[] args)
        {
            IReadOnlyStream inputStream1 = GetInputStream(args[0]);
            IReadOnlyStream inputStream2 = GetInputStream(args[1]);

            IList <LetterStats> singleLetterStats = FillSingleLetterStats(inputStream1);
            IList <LetterStats> doubleLetterStats = FillDoubleLetterStats(inputStream2);

            RemoveCharStatsByType(singleLetterStats, CharType.Vowel);
            RemoveCharStatsByType(doubleLetterStats, CharType.Consonants);

            PrintStatistic(singleLetterStats);
            PrintStatistic(doubleLetterStats);

            // TODO : Необходимо дождаться нажатия клавиши, прежде чем завершать выполнение программы.
            Console.WriteLine("Press any key for exit...");
            ManualResetEvent quitEvent = new ManualResetEvent(false);

            new Task(() =>
            {
                Console.ReadKey();
                quitEvent.Set();
            }).Start();
            quitEvent.WaitOne();
        }
Exemplo n.º 5
0
        /// <summary>
        /// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения парных букв.
        /// В статистику должны попадать только пары из одинаковых букв, например АА, СС, УУ, ЕЕ и т.д.
        /// Статистика - НЕ регистрозависимая!
        /// </summary>
        /// <param name="stream">Стрим для считывания символов для последующего анализа</param>
        /// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
        private static IList <LetterStats> FillDoubleLetterStats(IReadOnlyStream stream)
        {
            List <LetterStats> listStats = new List <LetterStats>();
            char previousChar            = Char.MinValue;

            stream.ResetPositionToStart();
            while (!stream.IsEof)
            {
                char currentChar = stream.ReadNextChar();
                if (char.IsLetter(currentChar))
                {
                    if (char.ToLowerInvariant(previousChar) == char.ToLowerInvariant(currentChar))
                    {
                        string str = string.Empty;
                        str += previousChar;
                        str += currentChar;
                        IncStatistic(str, listStats, false);
                        previousChar = char.MinValue;
                    }
                    else
                    {
                        previousChar = currentChar;
                    }
                }
            }

            return(listStats);
        }
Exemplo n.º 6
0
        /// <summary>
        /// Программа принимает на входе 2 пути до файлов.
        /// Анализирует в первом файле кол-во вхождений каждой буквы (регистрозависимо). Например А, б, Б, Г и т.д.
        /// Анализирует во втором файле кол-во вхождений парных букв (не регистрозависимо). Например АА, Оо, еЕ, тт и т.д.
        /// По окончанию работы - выводит данную статистику на экран.
        /// </summary>
        /// <param name="args">Первый параметр - путь до первого файла.
        /// Второй параметр - путь до второго файла.</param>
        static void Main(string[] args)
        {
            AlphabetLetter alphabetSingleLetter = new AlphabetLetter("абвгдеёжзийклмнопрстуфхцчшщъыьэюяАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ");
            AlphabetLetter alphabetDoubleLetter = new AlphabetLetter("абвгдеёжзийклмнопрстуфхцчшщъыьэюя");

            IReadOnlyStream inputStream1 = GetInputStream(args[0]);
            IReadOnlyStream inputStream2 = GetInputStream(args[1]);

            //IList<LetterStats> singleLetterStats =
            FillSingleLetterStats(inputStream1, alphabetSingleLetter);
            PrintStatisticSingle(alphabetSingleLetter);


            //IList<LetterStats> doubleLetterStats =
            FillDoubleLetterStats(inputStream2, alphabetDoubleLetter);
            PrintStatisticDouble(alphabetDoubleLetter);

            Console.WriteLine("Убираем гласные.");
            RemoveCharStatsByType(alphabetSingleLetter, CharType.Vowel);
            PrintStatisticSingle(alphabetSingleLetter);

            Console.WriteLine("Убираем согласные.");
            RemoveCharStatsByType(alphabetDoubleLetter, CharType.Consonants);
            PrintStatisticDouble(alphabetDoubleLetter);

            inputStream1.Close();
            inputStream2.Close();

            // TODO : Необжодимо дождаться нажатия клавиши, прежде чем завершать выполнение программы.
            Console.Read();
        }
Exemplo n.º 7
0
        /// <summary>
        /// Программа принимает на входе 2 пути до файлов.
        /// Анализирует в первом файле кол-во вхождений каждой буквы (регистрозависимо). Например А, б, Б, Г и т.д.
        /// Анализирует во втором файле кол-во вхождений парных букв (не регистрозависимо). Например АА, Оо, еЕ, тт и т.д.
        /// По окончанию работы - выводит данную статистику на экран.
        /// </summary>
        /// <param name="args">Первый параметр - путь до первого файла.
        /// Второй параметр - путь до второго файла.</param>
        static void Main(string[] args)
        {
            if (args.Length != 2)
            {
                Console.WriteLine("Error: incorrect number of paths to files. Press any key to exit...");
                Console.ReadKey();
                return;
            }

            string singleLettersFilePath = args[0];
            string doubleLettersFilePath = args[1];

            try
            {
                using (IReadOnlyStream inputStreamSingleLetters = GetInputStream(singleLettersFilePath),
                       inputStreamDoubleLetters = GetInputStream(doubleLettersFilePath))
                {
                    IList <LetterStats> singleLetterStats = FillSingleLetterStats(inputStreamSingleLetters);
                    IList <LetterStats> doubleLetterStats = FillDoubleLetterStats(inputStreamDoubleLetters);

                    RemoveCharStatsByType(ref singleLetterStats, CharType.Vowel);
                    RemoveCharStatsByType(ref doubleLetterStats, CharType.Consonants);

                    PrintResult(singleLetterStats, doubleLetterStats);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("The file could not be read: {0}", e.Message);
            }

            Console.WriteLine("Press any key to exit...");
            Console.ReadKey();
        }
Exemplo n.º 8
0
        /// <summary>
        /// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения каждой буквы.
        /// Статистика РЕГИСТРОЗАВИСИМАЯ!
        /// </summary>
        /// <param name="stream">Стрим для считывания символов для последующего анализа</param>
        /// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
        private static IList <LetterStats> FillSingleLetterStats(IReadOnlyStream stream)
        {
            stream.ResetPositionToStart();
            List <LetterStats> stats = new List <LetterStats>();

            while (!stream.IsEof)
            {
                char c = stream.ReadNextChar();
                if (char.IsLetter(c))
                {
                    string letter = c.ToString();
                    var    index  = stats.FindIndex(x => string.Compare(x.Letter, letter) == 0);
                    if (index == -1)
                    {
                        var stat = new LetterStats
                        {
                            Letter = letter,
                            Count  = 1
                        };
                        stats.Add(stat);
                    }
                    else
                    {
                        var stat = stats[index];
                        IncStatistic(ref stat);
                        stats[index] = stat;
                    }
                }
            }

            return(stats);
        }
Exemplo n.º 9
0
        /// <summary>
        /// Программа принимает на входе 2 пути до файлов.
        /// Анализирует в первом файле кол-во вхождений каждой буквы (регистрозависимо). Например А, б, Б, Г и т.д.
        /// Анализирует во втором файле кол-во вхождений парных букв (не регистрозависимо). Например АА, Оо, еЕ, тт и т.д.
        /// По окончанию работы - выводит данную статистику на экран.
        /// </summary>
        /// <param name="args">Первый параметр - путь до первого файла.
        /// Второй параметр - путь до второго файла.</param>
        static void Main(string[] args)
        {
            if (args.Length != 2)
            {
                Console.WriteLine("Введено неверное количество аргументов, допустимо только 2");
                return;
            }

            try
            {
                using (IReadOnlyStream inputStream1 = GetInputStream(args[0]))
                    using (IReadOnlyStream inputStream2 = GetInputStream(args[1]))
                    {
                        IList <LetterStats> singleLetterStats = FillSingleLetterStats(inputStream1);
                        IList <LetterStats> doubleLetterStats = FillDoubleLetterStats(inputStream2);

                        RemoveCharStatsByType(singleLetterStats, CharType.Vowel);
                        RemoveCharStatsByType(doubleLetterStats, CharType.Consonants);

                        PrintStatistic(singleLetterStats);
                        PrintStatistic(doubleLetterStats);
                    }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
            Console.WriteLine("Для выхода из программы нажмите любую клавишу...");
            Console.ReadKey();
        }
Exemplo n.º 10
0
        /// <summary>
        /// Программа принимает на входе 2 пути до файлов.
        /// Анализирует в первом файле кол-во вхождений каждой буквы (регистрозависимо). Например А, б, Б, Г и т.д.
        /// Анализирует во втором файле кол-во вхождений парных букв (не регистрозависимо). Например АА, Оо, еЕ, тт и т.д.
        /// По окончанию работы - выводит данную статистику на экран.
        /// </summary>
        /// <param name="args">Первый параметр - путь до первого файла.
        /// Второй параметр - путь до второго файла.</param>
        static void Main(string[] args)
        {
            if (args.Length < 2)
            {
                Console.WriteLine("Не указаны пути к файлам");
                Console.ReadKey(false);
                return;
            }

            IList <LetterStats> singleLetterStats;
            IList <LetterStats> doubleLetterStats;

            using (IReadOnlyStream inputStream1 = GetInputStream(args[0]))
            {
                singleLetterStats = FillSingleLetterStats(inputStream1);
            }
            using (IReadOnlyStream inputStream2 = GetInputStream(args[1]))
            {
                doubleLetterStats = FillDoubleLetterStats(inputStream2);
            }

            RemoveCharStatsByType(ref singleLetterStats, CharType.Vowel);
            RemoveCharStatsByType(ref doubleLetterStats, CharType.Consonants);

            PrintStatistic(singleLetterStats);
            PrintStatistic(doubleLetterStats);

            // TODO : DONE Необжодимо дождаться нажатия клавиши, прежде чем завершать выполнение программы.
            Console.ReadKey(false);
        }
Exemplo n.º 11
0
        /// <summary>
        /// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения каждой буквы.
        /// Статистика РЕГИСТРОЗАВИСИМАЯ!
        /// </summary>
        /// <param name="stream">Стрим для считывания символов для последующего анализа</param>
        /// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
        private static IList <LetterStats> FillSingleLetterStats(IReadOnlyStream stream)
        {
            var dict = new Dictionary <char, LetterStats>();

            stream.ResetPositionToStart();
            while (!stream.IsEof)
            {
                char c = stream.ReadNextChar();
                if (stream.IsEof)
                {
                    continue;
                }

                if (IsRussianLetter(c))
                {
                    if (dict.ContainsKey(c))
                    {
                        var item = dict[c];
                        item.Count++;
                        dict[c] = item;
                    }
                    else
                    {
                        var newItem = new LetterStats {
                            Count = 1, Letter = c.ToString()
                        };
                        dict.Add(c, newItem);
                    }
                }
            }

            return(dict.Values.ToList());
        }
Exemplo n.º 12
0
        /// <summary>
        /// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения каждой буквы.
        /// Статистика РЕГИСТРОЗАВИСИМАЯ!
        /// </summary>
        /// <param name="stream">Стрим для считывания символов для последующего анализа</param>
        /// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
        private static IList <LetterStats> FillSingleLetterStats(IReadOnlyStream stream)
        {
            IList <LetterStats> result = new List <LetterStats>();

            stream.ResetPositionToStart();
            while (!stream.IsEof)
            {
                char charCurrent = stream.ReadNextChar();

                //если символ не является буквой перейти к следующему
                if (!char.IsLetter(charCurrent))
                {
                    continue;
                }

                // TODO : заполнять статистику с использованием метода IncStatistic. Учёт букв - регистрозависимый.
                LetterStats row = result.SingleOrDefault(item => item.Letter == charCurrent.ToString());

                if (row != null)
                {
                    IncStatistic(row);
                }
                else
                {
                    result.Add(new LetterStats {
                        Letter = charCurrent.ToString(), Count = 1
                    });
                }
            }

            return(result);
        }
Exemplo n.º 13
0
        public static async Task <Recorder> RecordAsync(this IReadOnlyStream stream)
        {
            var recorder = new Recorder();
            await stream.ReadAsync(recorder).ConfigureAwait(false);

            return(recorder);
        }
Exemplo n.º 14
0
        /// <summary>
        /// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения парных букв.
        /// В статистику должны попадать только пары из одинаковых букв, например АА, СС, УУ, ЕЕ и т.д.
        /// Статистика - НЕ регистрозависимая!
        /// </summary>
        /// <param name="stream">Стрим для считывания символов для последующего анализа</param>
        /// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
        private static IList <LetterStats> FillDoubleLetterStats(IReadOnlyStream stream)
        {
            var statsList = new List <LetterStats>();

            stream.ResetPositionToStart();

            string prev = stream.ReadNextChar().ToString().ToLower();

            while (!stream.IsEof)
            {
                string next = stream.ReadNextChar().ToString().ToLower();

                // TODO : заполнять статистику с использованием метода IncStatistic. Учёт букв - НЕ регистрозависимый.

                if (prev != next)
                {
                    prev = next;
                    continue;
                }

                string pair = string.Concat(next, prev);

                if (!statsList.Exists(item => item.Letter == pair))
                {
                    var stats = new LetterStats(pair);
                    statsList.Add(stats);
                }

                IncStatistic(statsList.Find(item => item.Letter == pair));
            }

            return(statsList);
        }
Exemplo n.º 15
0
        /// <summary>
        /// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения каждой буквы.
        /// Статистика РЕГИСТРОЗАВИСИМАЯ!
        /// </summary>
        /// <param name="stream">Стрим для считывания символов для последующего анализа</param>
        /// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
        private static IList <LetterStats> FillSingleLetterStats(IReadOnlyStream stream)
        {
            stream.ResetPositionToStart();
            IList <LetterStats> letterStats = new List <LetterStats>();

            while (!stream.IsEof)
            {
                char c = stream.ReadNextChar();
                if (char.IsLetter(c))
                {
                    var ls = new LetterStats {
                        Letter = c.ToString()
                    };
                    if (letterStats.Contains(ls))
                    {
                        IncStatistic(letterStats[letterStats.IndexOf(ls)]);
                    }
                    else
                    {
                        letterStats.Add(new LetterStats {
                            Letter = c.ToString(), Count = 1
                        });
                    }
                }
            }
            return(letterStats);
        }
Exemplo n.º 16
0
        /// <summary>
        /// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения парных букв.
        /// В статистику должны попадать только пары из одинаковых букв, например АА, СС, УУ, ЕЕ и т.д.
        /// Статистика - НЕ регистрозависимая!
        /// </summary>
        /// <param name="stream">Стрим для считывания символов для последующего анализа</param>
        /// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
        private static IList <LetterStats> FillDoubleLetterStats(IReadOnlyStream stream)
        {
            stream.ResetPositionToStart();
            var stats = new List <LetterStats>();

            if (stream.IsEof)
            {
                return(stats);
            }
            var chars = new char[2];

            chars[0] = stream.ReadNextChar();

            while (!stream.IsEof)
            {
                chars[1] = stream.ReadNextChar();
                if (char.IsLetter(chars[0]) && char.IsLetter(chars[1]))
                {
                    var str = new string(chars).ToLower();
                    IncStatistic(stats, str);
                }
                chars[0] = chars[1];
            }

            return(stats);
        }
Exemplo n.º 17
0
        /// <summary>
        /// Программа принимает на входе 2 пути до файлов.
        /// Анализирует в первом файле кол-во вхождений каждой буквы (регистрозависимо). Например А, б, Б, Г и т.д.
        /// Анализирует во втором файле кол-во вхождений парных букв (не регистрозависимо). Например АА, Оо, еЕ, тт и т.д.
        /// По окончанию работы - выводит данную статистику на экран.
        /// </summary>
        /// <param name="args">Первый параметр - путь до первого файла.
        /// Второй параметр - путь до второго файла.</param>
        static void Main(string[] args)
        {
            Console.WriteLine("Подсчёт статистики вхождения символов/пар символов в заданных файлах.");
            IList <LetterStats> singleLetterStats;
            IList <LetterStats> doubleLetterStats;

            using (IReadOnlyStream inputStream1 = GetInputStream(args[0]))
            {
                singleLetterStats = FillSingleLetterStats(inputStream1);
            }

            using (IReadOnlyStream inputStream2 = GetInputStream(args[1]))
            {
                doubleLetterStats = FillDoubleLetterStats(inputStream2);
            }

            RemoveCharStatsByType(ref singleLetterStats, CharType.Vowel);
            RemoveCharStatsByType(ref doubleLetterStats, CharType.Consonants);

            Console.WriteLine(Environment.NewLine + $"Статистика вхождения символов в файле {args[0]}:");
            PrintStatistic(singleLetterStats);

            Console.WriteLine(Environment.NewLine + $"Статистика вхождения пар символов в файле {args[1]}:");
            PrintStatistic(doubleLetterStats);

            // TODO : Необжодимо дождаться нажатия клавиши, прежде чем завершать выполнение программы.
            Console.WriteLine(Environment.NewLine + "Для завершения работы нажмите любую клавишу.");
            Console.ReadKey(true);
        }
Exemplo n.º 18
0
        /// <summary>
        /// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения парных букв.
        /// В статистику должны попадать только пары из одинаковых букв, например АА, СС, УУ, ЕЕ и т.д.
        /// Статистика - НЕ регистрозависимая!
        /// </summary>
        /// <param name="stream">Стрим для считывания символов для последующего анализа</param>
        /// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
        private static IList <LetterStats> FillDoubleLetterStats(IReadOnlyStream stream)
        {
            List <LetterStats> rez = new List <LetterStats>();

            stream.ResetPositionToStart();
            char old = '\0';

            while (!stream.IsEof)
            {
                char c = stream.ReadNextChar();

                if (c.ToString().ToLower() == old.ToString().ToLower())
                {
                    var ls = new LetterStats()
                    {
                        Count  = 1,
                        Letter = old.ToString().ToLower() + c.ToString().ToLower(),
                    };
                    var item = rez.Find(x => x.Letter == ls.Letter);
                    if (item == null)
                    {
                        rez.Add(ls);
                    }
                    else
                    {
                        IncStatistic(item);
                    }
                }
                old = c;
            }
            return(rez);
        }
Exemplo n.º 19
0
        async Task CopyAsync(
            IReadOnlyStream source,
            IWriteOnlyStream destination,
            CancellationToken cancellationToken = default)
        {
            byte[] buffer = this._bufferPool.Rent(4096);
            try
            {
                int bytesRead;
                while ((bytesRead = await source
                                    .ReadAsync(buffer, 0, buffer.Length, cancellationToken)
                                    .ConfigureAwait(false)) != 0)
                {
                    // Transform

                    await destination
                    .WriteAsync(buffer, 0, bytesRead, cancellationToken)
                    .ConfigureAwait(false);
                }
            }
            finally
            {
                this._bufferPool.Return(buffer);
            }
        }
Exemplo n.º 20
0
        /// <summary>
        /// Программа принимает на входе 2 пути до файлов.
        /// Анализирует в первом файле кол-во вхождений каждой буквы (регистрозависимо). Например А, б, Б, Г и т.д.
        /// Анализирует во втором файле кол-во вхождений парных букв (не регистрозависимо). Например АА, Оо, еЕ, тт и т.д.
        /// По окончанию работы - выводит данную статистику на экран.
        /// </summary>
        /// <param name="args">Первый параметр - путь до первого файла.
        /// Второй параметр - путь до второго файла.</param>
        static void Main(string[] args)
        {
            if (args.Length != 0)
            {
                IReadOnlyStream inputStream1 = GetInputStream(args[0]);
                IReadOnlyStream inputStream2 = GetInputStream(args[1]);

                IList <LetterStats> singleLetterStats = FillSingleLetterStats(inputStream1);
                IList <LetterStats> doubleLetterStats = FillDoubleLetterStats(inputStream2);

                IList <LetterStats> RemoveVowelChars      = RemoveCharStatsByType(singleLetterStats, CharType.Vowel);
                IList <LetterStats> RemoveConsonantsChars = RemoveCharStatsByType(doubleLetterStats, CharType.Consonants);
                //Вывод на экрна исходных статистик и после удаления завленных типов букв.
                {
                    PrintStatistic(singleLetterStats);
                    PrintStatistic(doubleLetterStats);
                    Console.WriteLine("Удаление гласных");
                    PrintStatistic(RemoveVowelChars);

                    Console.WriteLine("Удаление согласных");
                    PrintStatistic(RemoveConsonantsChars);
                }
            }
            else
            {
                Console.WriteLine("Не заданы аргументы командной строки.");
            }
            // TODO : Необжодимо дождаться нажатия клавиши, прежде чем завершать выполнение программы.
            Console.ReadKey();
        }
Exemplo n.º 21
0
        /// <summary>
        /// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения каждой буквы.
        /// Статистика РЕГИСТРОЗАВИСИМАЯ!
        /// </summary>
        /// <param name="stream">Стрим для считывания символов для последующего анализа</param>
        /// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
        private static IList <LetterStats> FillSingleLetterStats(IReadOnlyStream stream)
        {
            List <LetterStats> rez = new List <LetterStats>();

            stream.ResetPositionToStart();
            while (!stream.IsEof)
            {
                char c  = stream.ReadNextChar();
                var  ls = new LetterStats()
                {
                    Letter = c.ToString(),
                    Count  = 1
                };
                var item = rez.Find(x => x.Letter == ls.Letter);
                if (item == null)
                {
                    rez.Add(ls);
                }
                else
                {
                    IncStatistic(item);
                }
            }
            return(rez);
        }
Exemplo n.º 22
0
        /// <summary>
        /// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения каждой буквы.
        /// Статистика РЕГИСТРОЗАВИСИМАЯ!
        /// </summary>
        /// <param name="stream">Стрим для считывания символов для последующего анализа</param>
        /// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
        private static IList <LetterStats> FillSingleLetterStats(IReadOnlyStream stream)
        {
            List <LetterStats> dictionary = new List <LetterStats>();

            stream.ResetPositionToStart();

            while (!stream.IsEof)
            {
                try
                {
                    char c = stream.ReadNextChar();
                    // TODO : заполнять статистику с использованием метода IncStatistic. Учёт букв - регистрозависимый.
                    if (char.IsLetter(c))
                    {
                        var entry = dictionary.Where(e => e.Letter.Equals(c.ToString(),
                                                                          StringComparison.InvariantCulture)).SingleOrDefault();
                        if (entry == null)                                 //Если не нашли - добавим
                        {
                            dictionary.Add(new LetterStats(c.ToString())); // Т.к. регистрозависимая статистика - добавляем ключи как есть.
                        }
                        else
                        {
                            IncStatistic(entry);
                        }
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);
                    continue;
                }
            }
            return(dictionary);
        }
Exemplo n.º 23
0
        /// <summary>
        /// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения каждой буквы.
        /// Статистика РЕГИСТРОЗАВИСИМАЯ!
        /// </summary>
        /// <param name="stream">Стрим для считывания символов для последующего анализа</param>
        /// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
        private static IList <LetterStats> FillSingleLetterStats(IReadOnlyStream stream)
        {
            using (stream)
            {
                stream.ResetPositionToStart();

                List <LetterStats> result = new List <LetterStats>();

                while (!stream.IsEof)
                {
                    char c = stream.ReadNextChar();

                    // TODO : заполнять статистику с использованием метода IncStatistic. Учёт букв - регистрозависимый.
                    LetterStats stat = result.Find(x => x.Letter == c.ToString());

                    if (stat == null)
                    {
                        stat = new LetterStats(c.ToString());
                        result.Add(stat);
                    }

                    IncStatistic(stat);
                }

                return(result);
            }
        }
Exemplo n.º 24
0
        /// <summary>
        /// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения каждой буквы.
        /// Статистика РЕГИСТРОЗАВИСИМАЯ!
        /// </summary>
        /// <param name="stream">Стрим для считывания символов для последующего анализа</param>
        /// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
        private static IList <LetterStats> FillSingleLetterStats(IReadOnlyStream stream)
        {
            List <LetterStats> list = new List <LetterStats>();

            stream.ResetPositionToStart();
            while (!stream.IsEof)
            {
                char c = stream.ReadNextChar();
                if (char.IsLetter(c))
                {
                    int index = list.FindIndex(x => x.Letter == c.ToString());
                    if (index == -1)
                    {
                        list.Add(new LetterStats {
                            Letter = c.ToString(), Count = 1
                        });
                    }
                    else
                    {
                        LetterStats stats = list[index];

                        // заполнять статистику с использованием метода IncStatistic. Учёт букв - регистрозависимый.
                        IncStatistic(ref stats);
                        list[index] = stats;
                    }
                }
            }
            return(list);
        }
Exemplo n.º 25
0
        /// <summary>
        /// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения каждой буквы.
        /// Статистика РЕГИСТРОЗАВИСИМАЯ!
        /// </summary>
        /// <param name="stream">Стрим для считывания символов для последующего анализа</param>
        /// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
        private static IList <LetterStats> FillSingleLetterStats(IReadOnlyStream stream)
        {
            stream.ResetPositionToStart();

            List <LetterStats> letterStatsList = new List <LetterStats>();

            while (!stream.IsEof)
            {
                try
                {
                    char c = stream.ReadNextChar();

                    // Проверяем, что символ является буквой, иначе продолжаем проход по циклу
                    if (!Char.IsLetter(c))
                    {
                        continue;
                    }

                    AddCharInListWithCheck(letterStatsList, c.ToString());
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }

            return(letterStatsList);
        }
Exemplo n.º 26
0
        /// <summary>
        /// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения каждой буквы.
        /// Статистика РЕГИСТРОЗАВИСИМАЯ!
        /// </summary>
        /// <param name="stream">Стрим для считывания символов для последующего анализа</param>
        /// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
        private static IList <LetterStats> FillSingleLetterStats(IReadOnlyStream stream)
        {
            IList <LetterStats> letterStateList = new List <LetterStats>();

            stream.ResetPositionToStart();
            while (!stream.IsEof)
            {
                char c = stream.ReadNextChar();
                if (!Char.IsLetter(c))
                {
                    continue;
                }

                string letter = new String(c, 1);
                if (letter == " ")
                {
                    continue;
                }

                var letterState = letterStateList.FirstOrDefault(o => o.Letter == letter);
                if (letterState == null)
                {
                    letterState = new LetterStats(letter);

                    letterStateList.Add(letterState);
                }

                IncStatistic(letterState);
            }

            return(letterStateList);
        }
Exemplo n.º 27
0
        /// <summary>
        /// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения каждой буквы.
        /// Статистика РЕГИСТРОЗАВИСИМАЯ!
        /// </summary>
        /// <param name="stream">Стрим для считывания символов для последующего анализа</param>
        /// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
        private static IList <LetterStats> FillSingleLetterStats(IReadOnlyStream stream)
        {
            stream.ResetPositionToStart();
            IList <LetterStats> answer = new List <LetterStats>();

            while (!stream.IsEof)
            {
                char c = stream.ReadNextChar();
                if (!char.IsLetter(c))
                {
                    continue;
                }
                int i;
                for (i = 0; i < answer.Count; i++)
                {
                    if (answer[i].Letter[0] == c)
                    {
                        answer[i] = IncStatistic(answer[i]);
                        break;
                    }
                }

                if (i == answer.Count)
                {
                    var newStruct = new LetterStats();
                    newStruct.Letter = c.ToString();
                    newStruct.Count  = 1;
                    answer.Add(newStruct);
                }
            }

            return(answer);
        }
Exemplo n.º 28
0
        /// <summary>
        /// Программа принимает на входе 2 пути до файлов.
        /// Анализирует в первом файле кол-во вхождений каждой буквы (регистрозависимо). Например А, б, Б, Г и т.д.
        /// Анализирует во втором файле кол-во вхождений парных букв (не регистрозависимо). Например АА, Оо, еЕ, тт и т.д.
        /// По окончанию работы - выводит данную статистику на экран.
        /// </summary>
        /// <param name="args">Первый параметр - путь до первого файла.
        /// Второй параметр - путь до второго файла.</param>
        static void Main(string[] args)
        {
            try
            {
                using (IReadOnlyStream inputStream1 = GetInputStream(args[0]))
                {
                    using (IReadOnlyStream inputStream2 = GetInputStream(args[1]))
                    {
                        IList <LetterStats> singleLetterStats = FillSingleLetterStats(inputStream1);
                        IList <LetterStats> doubleLetterStats = FillDoubleLetterStats(inputStream2);

                        PrintStatistic(RemoveCharStatsByType(singleLetterStats, CharType.Vowel));
                        Console.WriteLine("=====================");
                        PrintStatistic(RemoveCharStatsByType(doubleLetterStats, CharType.Consonants));
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            finally
            {
            }

            // TODO : Необжодимо дождаться нажатия клавиши, прежде чем завершать выполнение программы.
            Console.ReadLine();
        }
Exemplo n.º 29
0
 public static Task <TResult> AggregateAsync <TResult>(
     this IReadOnlyStream stream,
     IPayloadProcessor processor,
     CancellationToken cancellationToken
     ) where TResult : new()
 {
     return(stream.Aggregate().RunAsync <TResult>(processor, cancellationToken));
 }
Exemplo n.º 30
0
        /// <summary>
        /// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения парных букв.
        /// В статистику должны попадать только пары из одинаковых букв, например АА, СС, УУ, ЕЕ и т.д.
        /// Статистика - НЕ регистрозависимая!
        /// </summary>
        /// <param name="stream">Стрим для считывания символов для последующего анализа</param>
        /// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
        private static IList <LetterStats> FillDoubleLetterStats(IReadOnlyStream stream)
        {
            List <LetterStats> lst = new List <LetterStats>();
            LetterStats        ls;
            int  index;
            char c1;

            stream.ResetPositionToStart();
            char c = stream.ReadNextChar();

            while (!stream.IsEof)
            {
                if (char.IsLetter(c))
                {
                    c1 = stream.ReadNextChar();
                    if (char.IsLetter(c1))
                    {
                        if (char.ToLower(c) == char.ToLower(c1))
                        {
                            ls    = lst.FirstOrDefault(x => x.Letter == (c.ToString() + c1.ToString()));
                            index = lst.IndexOf(ls);
                            if (ls.Letter == null)
                            {
                                ls.Letter = (c.ToString() + c1.ToString());
                                ls.Count  = 1;
                                lst.Add(ls);
                            }
                            else
                            {
                                lst[index] = IncStatistic(ls);
                            }
                            if (!stream.IsEof)
                            {
                                c = stream.ReadNextChar();
                            }
                        }
                        else
                        {
                            c = c1;
                        }
                    }
                    else
                    {
                        c = c1;
                    }
                }
                else
                {
                    if (!stream.IsEof)
                    {
                        c = stream.ReadNextChar();
                    }
                }
            }
            return(lst);

            //throw new NotImplementedException();
        }