/// <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> 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);
}
/// <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> 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)
{
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();
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);
}
private static IList <LetterStats> FillLetterStatsDouble(ReadOnlyStream stream)
{
List <LetterStats> lstats = new List <LetterStats>();
LetterStats nx = new LetterStats
{
Letter = "",
Count = 1
};
var sr = new StreamReader(stream.fstream);
// stream.ResetPositionToStart();
//StreamReader sr = new StreamReader(streamex._localStream);
// while (!stream.IsEof)
while (sr.Peek() > 0)
{
// char c = stream.ReadNextChar();
// TODO : заполнять статистику с использованием метода IncStatistic. Учёт букв - регистрозависимый.
var buff = ((char)sr.Read()).ToString();
if ((buff == nx.Letter) && char.IsLetter(Convert.ToChar(buff)))
{
lstats.Add(nx);
}
nx.Count = 1;
nx.Letter = buff;
//Console.WriteLine(nx.Letter);
//if (char.IsLetter(Convert.ToChar(buff)))
}
return(lstats);
}
/// <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> 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)
{
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);
}
protected sealed override void FillStatistics()
{
using (stream)
{
var prevChar = new char();
while (!stream.IsEof)
{
var c = stream.ReadNextChar();
if (char.ToUpperInvariant(c) == char.ToUpperInvariant(prevChar))
{
var letter = new string(new[] { c, prevChar });
if (statistics.Any(x =>
string.Equals(x.Letter, letter, StringComparison.CurrentCultureIgnoreCase)))
{
var letterStats = statistics.FirstOrDefault(x =>
string.Equals(x.Letter, letter, StringComparison.CurrentCultureIgnoreCase));
letterStats?.IncStatistic();
}
else
{
var letterStats = new LetterStats(letter);
statistics.Add(letterStats);
}
}
prevChar = c;
}
}
}
/// <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)
{
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 CharType DetectType(LetterStats LetterStats)
{
if (Vowels.Contains(LetterStats.Letter.ToLower()))
{
return(CharType.Vowel);
}
else
{
return(CharType.Consonants);
}
}
/// <summary>
/// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения парных букв.
/// В статистику должны попадать только пары из одинаковых букв, например АА, СС, УУ, ЕЕ и т.д.
/// Статистика - НЕ регистрозависимая!
/// </summary>
/// <param name="stream">Стрим для считывания символов для последующего анализа</param>
/// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
private static IList <LetterStats> FillDoubleLetterStats(IReadOnlyStream stream)
{
//Список букв
IList <LetterStats> doubleLetters = new List <LetterStats>();
stream.ResetPositionToStart();
//Предыдущая буква
char cBack = stream.ReadNextChar();
while (!stream.IsEof)
{
//Перебор по символам
char c = stream.ReadNextChar();
//Буквы в верхнем регистре, предыдущая и текущая буквы
char upperLetterC = char.ToUpper(c);
char upperLetterCBack = char.ToUpper(cBack);
//Если входит в набор
if (Regex.IsMatch(cBack.ToString(), "[а-яА-Я]") && Regex.IsMatch(c.ToString(), "[а-яА-Я]"))
{
if (upperLetterCBack == upperLetterC)
{
int count = 0;
//Проходимся по списку, если имеется уже такая буква, то увеличиваем
//Если нет, то добавляем в список букву с количеством 1
foreach (LetterStats item in doubleLetters)
{
if (char.ToUpper(item.Letter[0]) == upperLetterCBack)
{
LetterStats copyLetter = doubleLetters[count];
IncStatistic(ref copyLetter);
doubleLetters[count] = copyLetter;
c = default;
break;
}
count++;
}
if (c != default)
{
doubleLetters.Add(new LetterStats()
{
Letter = upperLetterCBack + upperLetterC.ToString(), Count = 1
});
}
}
}
cBack = c;
// TODO : заполнять статистику с использованием метода IncStatistic. Учёт букв - НЕ регистрозависимый.
}
return(doubleLetters);
//throw new NotImplementedException();
}
/// <summary>
/// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения парных букв.
/// В статистику должны попадать только пары из одинаковых букв, например АА, СС, УУ, ЕЕ и т.д.
/// Статистика - НЕ регистрозависимая!
/// </summary>
/// <param name="stream">Стрим для считывания символов для последующего анализа</param>
/// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
private static IList <LetterStats> FillDoubleLetterStats(IReadOnlyStream stream)
{
List <LetterStats> stats = new List <LetterStats>();
stream.ResetPositionToStart();
char firstLetter = '\0';
bool firstLetterReaded = false;
while (!stream.IsEof)
{
if (!firstLetterReaded)
{
firstLetter = char.ToUpper(stream.ReadNextChar());
}
if (stream.IsEof)
{
break;
}
char secondLetter = char.ToUpper(stream.ReadNextChar());
if (char.IsLetter(firstLetter) && char.IsLetter(secondLetter) && firstLetter == secondLetter)
{
firstLetterReaded = false;
var pair = firstLetter.ToString() + secondLetter;
var index = stats.FindIndex(x => string.Compare(x.Letter, pair) == 0);
if (index == -1)
{
var stat = new LetterStats
{
Letter = pair,
Count = 1
};
stats.Add(stat);
}
else
{
var stat = stats[index];
IncStatistic(ref stat);
stats[index] = stat;
}
}
else
{
if (char.IsLetter(secondLetter))
{
firstLetterReaded = true;
firstLetter = secondLetter;
}
}
}
return(stats);
}
/// <summary>
/// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения парных букв.
/// В статистику должны попадать только пары из одинаковых букв, например АА, СС, УУ, ЕЕ и т.д.
/// Статистика - НЕ регистрозависимая!
/// </summary>
/// <param name="stream">Стрим для считывания символов для последующего анализа</param>
/// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
private static IList <LetterStats> FillDoubleLetterStats(IReadOnlyStream stream)
{
List <LetterStats> stats = new List <LetterStats>();
LetterStats ReadChar = new LetterStats();
foreach (string item in (stream as ReadOnlyStream).FindPairLetter())
{
ReadChar.Letter = item;
ReadChar.Count = (stream as ReadOnlyStream).NumberOfOccurrences(item);
stats.Add(ReadChar);
}
stream.Dispose();
return(stats);
}
/// <summary>
/// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения каждой буквы.
/// Статистика РЕГИСТРОЗАВИСИМАЯ!
/// </summary>
/// <param name="stream">Стрим для считывания символов для последующего анализа</param>
/// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
private static LetterStats FillSingleLetterStats(IReadOnlyStream stream)
{
LetterStats letterStats = new LetterStats();
stream.ResetPositionToStart();
while (!stream.IsEof)
{
char c = stream.ReadNextChar();
if (char.IsLetter(c))
{
letterStats.AddElement(c.ToString());
}
}
return(letterStats);
}
/// <summary>
/// Программа принимает на входе 2 пути до файлов.
/// Анализирует в первом файле кол-во вхождений каждой буквы (регистрозависимо). Например А, б, Б, Г и т.д.
/// Анализирует во втором файле кол-во вхождений парных букв (не регистрозависимо). Например АА, Оо, еЕ, тт и т.д.
/// По окончанию работы - выводит данную статистику на экран.
/// </summary>
/// <param name="args">Первый параметр - путь до первого файла.
/// Второй параметр - путь до второго файла.</param>
static void Main(string[] args)
{
IReadOnlyStream inputStream1 = GetInputStream(args[0]);
IReadOnlyStream inputStream2 = GetInputStream(args[1]);
LetterStats singleLetterStats = FillSingleLetterStats(inputStream1);
LetterStats doubleLetterStats = FillDoubleLetterStats(inputStream2);
singleLetterStats.RemoveCharStatsByType(CharType.Vowel);
doubleLetterStats.RemoveCharStatsByType(CharType.Consonants);
PrintStatistic(singleLetterStats);
PrintStatistic(doubleLetterStats);
Console.ReadKey();
}
/// <summary>
/// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения парных букв.
/// В статистику должны попадать только пары из одинаковых букв, например АА, СС, УУ, ЕЕ и т.д.
/// Статистика - НЕ регистрозависимая!
/// </summary>
/// <param name="stream">Стрим для считывания символов для последующего анализа</param>
/// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
private static IList <LetterStats> FillDoubleLetterStats(IReadOnlyStream stream)
{
stream.ResetPositionToStart();
var accumulator = new List <char>();
IList <LetterStats> answer = new List <LetterStats>();
var accPosition = 0;
while (!stream.IsEof)
{
while (accPosition < 2)
{
accumulator.Add(stream.ReadNextChar());
accPosition++;
}
var leftChar = Char.ToLower(accumulator[0]);
var rightChar = Char.ToLower(accumulator[1]);
if (leftChar.Equals(rightChar))
{
int i;
for (i = 0; i < answer.Count; i++)
{
if (answer[i].Letter == leftChar.ToString() + rightChar)
{
answer[i] = IncStatistic(answer[i]);
break;
}
}
if (i == answer.Count)
{
var newStruct = new LetterStats
{
Letter = leftChar.ToString() + rightChar, Count = 1
};
answer.Add(newStruct);
}
}
accumulator.RemoveAt(0);
accPosition--;
}
return(answer);
}
/// <summary>
/// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения каждой буквы.
/// Статистика РЕГИСТРОЗАВИСИМАЯ!
/// </summary>
/// <param name="stream">Стрим для считывания символов для последующего анализа</param>
/// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
private static IList <LetterStats> FillSingleLetterStats(IReadOnlyStream stream)
{
stream.ResetPositionToStart();
//Список букв
IList <LetterStats> singleLetters = new List <LetterStats>();
while (!stream.IsEof)
{
//Перебор по символам
char c = stream.ReadNextChar();
//Если входит в набор
if (Regex.IsMatch(c.ToString(), "[а-яА-Я]"))
{
int count = 0;
//Проходимся по списку, если имеется уже такая буква, то увеличиваем
//Если нет, то добавляем в список букву с количеством 1
foreach (LetterStats item in singleLetters)
{
if (item.Letter == c.ToString())
{
LetterStats copyLetter = singleLetters[count];
IncStatistic(ref copyLetter);
singleLetters[count] = copyLetter;
c = default;
break;
}
count++;
}
if (c != default)
{
singleLetters.Add(new LetterStats()
{
Letter = c.ToString(), Count = 1
});
}
}
// TODO : заполнять статистику с использованием метода IncStatistic. Учёт букв - регистрозависимый.
}
return(singleLetters);
//throw new NotImplementedException();
}
/// <summary>
/// Ф-ция чтения следующего символа из потока.
/// Если произведена попытка прочитать символ после достижения конца файла, метод
/// должен бросать соответствующее исключение
/// </summary>
/// <returns>Считанный символ.</returns>
public char ReadNextChar()
{
// TODO : Необходимо считать очередной символ из _localStream
// throw new NotImplementedException();
LetterStats nx = new LetterStats();
// nx.Letter= this._localStream
StreamReader sr = new StreamReader(_localStream);
// while (sr.Peek() >= 0)
// nx.Letter = (string)sr.Read();
// int Console.Write((char)sr.Read()); f = sr.Read()
//Console.Write((char)sr.Peek());
Console.Write((char)sr.Peek());
//Console.Write(555);
//IsEof = true;
return((char)sr.Peek());
}
/// <summary>
/// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения парных букв.
/// В статистику должны попадать только пары из одинаковых букв, например АА, СС, УУ, ЕЕ и т.д.
/// Статистика - НЕ регистрозависимая!
/// </summary>
/// <param name="stream">Стрим для считывания символов для последующего анализа</param>
/// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
private static IList <LetterStats> FillDoubleLetterStats(IReadOnlyStream stream)
{
stream.ResetPositionToStart();
IList <LetterStats> letterStats = new List <LetterStats>();
char prevChar = '\0';
while (!stream.IsEof)
{
char c = char.ToLower(stream.ReadNextChar());
if (char.IsLetter(c))
{
if (c == prevChar)
{
string doubleLetter = c.ToString() + c.ToString();
var ls = new LetterStats {
Letter = doubleLetter
};
if (letterStats.Contains(ls))
{
IncStatistic(letterStats[letterStats.IndexOf(ls)]);
}
else
{
letterStats.Add(new LetterStats {
Letter = doubleLetter, Count = 1
});
}
// Один и тот же символ не будем учитывать дважды (в условии не было оговорено)
// Если для строки "aaa" нужно получить { аа : 2 }, то закомментировать следующую строку
prevChar = '\0';
}
else
{
prevChar = c;
}
}
}
return(letterStats);
}
/// <summary>
/// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения каждой буквы.
/// Статистика РЕГИСТРОЗАВИСИМАЯ!
/// </summary>
/// <param name="stream">Стрим для считывания символов для последующего анализа</param>
/// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
private static IList <LetterStats> FillSingleLetterStats(IReadOnlyStream stream)
{
var statsList = new List <LetterStats>();
stream.ResetPositionToStart();
while (!stream.IsEof)
{
char c = stream.ReadNextChar();
// TODO : заполнять статистику с использованием метода IncStatistic. Учёт букв - регистрозависимый.
if (!statsList.Exists(item => item.Letter == c.ToString()))
{
LetterStats letterStats = new LetterStats(c.ToString());
statsList.Add(letterStats);
}
IncStatistic(statsList.Find(item => item.Letter == c.ToString()));
}
return(statsList);
}
/// <summary>
/// Ф-ция перебирает все найденные буквы/парные буквы, содержащие в себе только гласные или согласные буквы.
/// (Тип букв для перебора определяется параметром charType)
/// Все найденные буквы/пары соответствующие параметру поиска - удаляются из переданной коллекции статистик.
/// </summary>
/// <param name="letters">Коллекция со статистиками вхождения букв/пар.</param>
/// <param name="charType">Тип букв для анализа</param>
private static IList <LetterStats> RemoveCharStatsByType(IList <LetterStats> letters, CharType charType)
{
List <LetterStats> PatStats = new List <LetterStats>();
LetterStats LetterPatStats = new LetterStats();
string PatternVowel = "[АаЕеЁёИиОоУуЫыЭэЮюЯя]";
string patternConsonants = "[БбВвГгДдЖжЗзЙйКкЛлМмНнПпРрСсТтФфХхЦцЧчШшЩщ]";
string str = string.Empty;
// TODO : Удалить статистику по запрошенному типу букв.
switch (charType)
{
case CharType.Consonants:
foreach (var item in letters.ToList().Distinct())
{
str = Regex.Replace(item.Letter, patternConsonants, "");
if (str.Length > 0)
{
LetterPatStats.Letter = str;
LetterPatStats.Count = item.Count;
PatStats.Add(LetterPatStats);
}
}
break;
case CharType.Vowel:
foreach (var item in letters.ToList().Distinct())
{
str = Regex.Replace(item.Letter, PatternVowel, "");
if (str.Length > 0)
{
LetterPatStats.Letter = str;
LetterPatStats.Count = item.Count;
PatStats.Add(LetterPatStats);
}
}
break;
}
return(PatStats);
}
/// <summary>
/// Ф-ция перебирает все найденные буквы/парные буквы, содержащие в себе только гласные или согласные буквы.
/// (Тип букв для перебора определяется параметром charType)
/// Все найденные буквы/пары соответствующие параметру поиска - удаляются из переданной коллекции статистик.
/// </summary>
/// <param name="letters">Коллекция со статистиками вхождения букв/пар</param>
/// <param name="charType">Тип букв для анализа</param>
private static IList <LetterStats> RemoveCharStatsByType(IList <LetterStats> letters, CharType charType)
{
IList <LetterStats> result = new List <LetterStats>();
char[] gx = new char[55];
IList <LetterStats> resultnot = letters;
// TODO : Удалить статистику по запрошенному типу букв.
switch (charType)
{
case CharType.Consonants:
gx = "BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz".ToCharArray();
break;
case CharType.Vowel:
gx = "AEIOUYaeiou".ToCharArray();
break;
}
var gg = gx.ToString();
foreach (char bukva in gx)
{
LetterStats bb1 = resultnot.Where(t => t.Letter == bukva.ToString()).FirstOrDefault();
if (resultnot.Contains(bb1))
{
resultnot = resultnot.Where(t => t.Letter != bb1.Letter).ToList();
}
}
return(resultnot);
}
/// <summary>
/// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения парных букв.
/// В статистику должны попадать только пары из одинаковых букв, например АА, СС, УУ, ЕЕ и т.д.
/// Статистика - НЕ регистрозависимая!
/// </summary>
/// <param name="stream">Стрим для считывания символов для последующего анализа</param>
/// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
private static IList <LetterStats> FillDoubleLetterStats(IReadOnlyStream stream)
{
stream.ResetPositionToStart();
var letterstats = new List <LetterStats>();
string c;
if (!stream.IsEof)
{
c = stream.ReadNextChar().ToString();
}
else
{
return(letterstats);
}
while (!stream.IsEof)
{
string cnext = stream.ReadNextChar().ToString();
if (c.ToLower() == cnext.ToLower())
{
Console.WriteLine($"{c} {cnext}");
LetterStats ls = letterstats.FirstOrDefault(x => x.Letter.ToLower() == (c + cnext).ToLower());
if (ls == null)
{
letterstats.Add(new LetterStats()
{
Letter = (c + cnext), Count = 1
});
}
else
{
IncStatistic(ls);
}
}
c = cnext;
// TODO : DONE заполнять статистику с использованием метода IncStatistic. Учёт букв - НЕ регистрозависимый.
}
return(letterstats);
}
/// <summary>
/// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения парных букв.
/// В статистику должны попадать только пары из одинаковых букв, например АА, СС, УУ, ЕЕ и т.д.
/// Статистика - НЕ регистрозависимая!
/// </summary>
/// <param name="stream">Стрим для считывания символов для последующего анализа</param>
/// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
private static IList <LetterStats> FillDoubleLetterStats(IReadOnlyStream stream)
{
// по реализованной мною логике последовательность вида ААА - будет считаться за две пары
var dict = new Dictionary <char, LetterStats>();
stream.ResetPositionToStart();
char?prevChar = null;
while (!stream.IsEof)
{
char c = Char.ToUpper(stream.ReadNextChar());
if (stream.IsEof)
{
continue;
}
if (IsRussianLetter(c) && prevChar == 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);
}
}
prevChar = c;
}
return(dict.Values.ToList());
}
protected sealed override void FillStatistics()
{
using (stream)
{
while (!stream.IsEof)
{
var c = stream.ReadNextChar();
var letter = c.ToString();
if (statistics.Any(x => x.Letter == letter))
{
var letterStats = statistics.FirstOrDefault(x => x.Letter == letter);
letterStats?.IncStatistic();
}
else
{
var letterStats = new LetterStats(letter);
statistics.Add(letterStats);
}
}
}
}
/// <summary>
/// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения парных букв.
/// В статистику должны попадать только пары из одинаковых букв, например АА, СС, УУ, ЕЕ и т.д.
/// Статистика - НЕ регистрозависимая!
/// </summary>
/// <param name="stream">Стрим для считывания символов для последующего анализа</param>
/// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
private static IList <LetterStats> FillDoubleLetterStats(IReadOnlyStream stream)
{
IList <LetterStats> result = new List <LetterStats>();
stream.ResetPositionToStart();
while (!stream.IsEof)
{
char charCurrent = char.ToUpper(stream.ReadNextChar());
// TODO : заполнять статистику с использованием метода IncStatistic. Учёт букв - НЕ регистрозависимый.
char charNext = char.ToUpper(stream.GetNextChar());
//если один из символов не является буквой перейти к следующему
if (!(char.IsLetter(charCurrent) && char.IsLetter(charNext)))
{
continue;
}
if (charCurrent == charNext)
{
LetterStats row = result.SingleOrDefault(item => item.Letter == $"{charCurrent}{charNext}");
if (row != null)
{
IncStatistic(row);
}
else
{
result.Add(new LetterStats {
Letter = $"{charCurrent}{charNext}", Count = 1
});
}
}
}
return(result);
}
