/// <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));
}
/// <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);
}
/// <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;
}
}
/// <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();
}
/// <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);
}
/// <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();
}
/// <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();
}
/// <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);
}
/// <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();
}
/// <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);
}
/// <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());
}
/// <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);
}
public static async Task <Recorder> RecordAsync(this IReadOnlyStream stream)
{
var recorder = new Recorder();
await stream.ReadAsync(recorder).ConfigureAwait(false);
return(recorder);
}
/// <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);
}
/// <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);
}
/// <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);
}
/// <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);
}
/// <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);
}
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);
}
}
/// <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();
}
/// <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);
}
/// <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);
}
/// <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);
}
}
/// <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);
}
/// <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);
}
/// <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);
}
/// <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);
}
/// <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();
}
public static Task <TResult> AggregateAsync <TResult>(
this IReadOnlyStream stream,
IPayloadProcessor processor,
CancellationToken cancellationToken
) where TResult : new()
{
return(stream.Aggregate().RunAsync <TResult>(processor, cancellationToken));
}
/// <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();
}
