private IList <LetterStats> FillSingleLetterStats()
{
var dictLetter = new Dictionary <char, LetterStats>();
_stream.ResetPositionToStart();
while (!_stream.IsEof)
{
char c = _stream.ReadNextChar();
if (!char.IsLetter(c))
{
continue;
}
if (!dictLetter.ContainsKey(c))
{
dictLetter[c] = new LetterStats {
Letter = c
};
}
dictLetter[c].IncStatistic();
}
return(dictLetter.Values.ToList());
}
/// <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>
/// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения каждой буквы.
/// Статистика РЕГИСТРОЗАВИСИМАЯ!
/// </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>
/// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения каждой буквы.
/// Статистика РЕГИСТРОЗАВИСИМАЯ!
/// </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);
}
/// <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);
}
/// <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>
/// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения каждой буквы.
/// Статистика РЕГИСТРОЗАВИСИМАЯ!
/// </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)
{
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)
{
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)
{
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>
/// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения парных букв.
/// В статистику должны попадать только пары из одинаковых букв, например АА, СС, УУ, ЕЕ и т.д.
/// Статистика - НЕ регистрозависимая!
/// </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> 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> 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> 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> 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)
{
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)
{
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)
{
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();
}
/// <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)
{
stream.ResetPositionToStart();
while (!stream.IsEof)
{
char c = stream.ReadNextChar();
// TODO : заполнять статистику с использованием метода IncStatistic. Учёт букв - НЕ регистрозависимый.
}
//return ???;
throw new NotImplementedException();
}
/// <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>
/// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения каждой буквы.
/// Статистика РЕГИСТРОЗАВИСИМАЯ!
/// </summary>
/// <param name="stream">Стрим для считывания символов для последующего анализа</param>
/// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
private static IList <LetterStats> FillSingleLetterStats(IReadOnlyStream stream)
{
List <LetterStats> listStats = new List <LetterStats>();
stream.ResetPositionToStart();
while (!stream.IsEof)
{
char currentChar = stream.ReadNextChar();
if (char.IsLetter(currentChar))
{
IncStatistic(currentChar.ToString(), listStats, true);
}
}
return(listStats);
}
/// <summary>
/// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения каждой буквы.
/// Статистика РЕГИСТРОЗАВИСИМАЯ!
/// </summary>
/// <param name="stream">Стрим для считывания символов для последующего анализа</param>
/// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
private static IList <LetterStats> FillSingleLetterStats(IReadOnlyStream stream)
{
stream.ResetPositionToStart();
var stats = new List <LetterStats>();
while (!stream.IsEof)
{
var ch = stream.ReadNextChar();
if (char.IsLetter(ch))
{
IncStatistic(stats, ch.ToString());
}
}
return(stats);
}
/// <summary>
/// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения парных букв.
/// В статистику должны попадать только пары из одинаковых букв, например АА, СС, УУ, ЕЕ и т.д.
/// Статистика - НЕ регистрозависимая!
/// </summary>
/// <param name="stream">Стрим для считывания символов для последующего анализа</param>
/// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
private static IList <LetterStats> FillDoubleLetterStats(IReadOnlyStream stream)
{
List <LetterStats> result = new List <LetterStats>();
var wordReg = new Regex(@"[A-Zа-я]{2}", RegexOptions.IgnoreCase);
stream.ResetPositionToStart();
char symbolPrevious = stream.ReadNextChar();
while (!stream.IsEof)
{
char symbol = stream.ReadNextChar();
var doubleLetter = $"{symbolPrevious}{symbol}";
symbolPrevious = symbol;
if (!wordReg.IsMatch(doubleLetter))
{
continue;
}
for (int ii = 0; ii < result.Count; ii++)
{
if (result[ii].Letter != doubleLetter)
{
continue;
}
var tmp = result[ii];
IncStatistic(ref tmp);
result[ii] = tmp;
doubleLetter = string.Empty;
break;
}
if (string.IsNullOrEmpty(doubleLetter))
{
continue;
}
result.Add(new LetterStats()
{
Letter = doubleLetter, Count = 1
});
}
return(result);
}
/// <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>
/// Ф-ция считывающая из входящего потока все буквы, и возвращающая коллекцию статистик вхождения парных букв.
/// В статистику должны попадать только пары из одинаковых букв, например АА, СС, УУ, ЕЕ и т.д.
/// UPD: на эквивалетность символы проверяются по типу "скользящего окна", поэтому комбинацию "АаА"
/// программа засчитает, причем как две пары: "Аа"А и А"аА".
/// Статистика - НЕ регистрозависимая!
/// </summary>
/// <param name="stream">Стрим для считывания символов для последующего анализа</param>
/// <returns>Коллекция статистик по каждой букве, что была прочитана из стрима.</returns>
private static IList <LetterStats> FillDoubleLetterStats(IReadOnlyStream stream)
{
stream.ResetPositionToStart();
List <LetterStats> doubleLetters = new List <LetterStats>();
string pattern = @"\w+";
Regex rgx = new Regex(pattern);
string value = string.Empty;
while (!stream.IsEof)
{
char c = stream.ReadNextChar();
value += c;
if (value.Length < 2) // проверяет только парами
{
continue;
}
if (value.Length == 3)
{
value = value.Remove(0, 1);
}
if (!rgx.IsMatch(value))
{
continue;
}
var a = value[0].ToString();
var b = value[1].ToString();
if (!String.Equals(a, b, StringComparison.OrdinalIgnoreCase)) // игнорирует пары неэквивалентных символов (регистр игнорируется)
{
continue;
}
var foundIndex = doubleLetters.FindIndex(stat => stat.Letter.Equals(value, StringComparison.OrdinalIgnoreCase));
if (foundIndex >= 0)
{
OnFoundIndex(doubleLetters, foundIndex);
}
else // если в коллекции записи о букве нет - создаем запись, определяя тип звука.
{
CharType type = Vowel.Contains(a) ? CharType.Vowel : CharType.Consonants;
doubleLetters.Add(new LetterStats(type, value.ToUpper(), 1)); // Для эстетичности вывода регистр меняется на заглавные
}
}
return(doubleLetters);
}
/// <summary>
/// Посимвольно читает поток.
/// </summary>
/// <param name="stream">Стрим для считывания символов для последующего анализа</param>
/// <returns>Список симовлов.</returns>
private static List <char> GetCyrillicCharsFromStream(IReadOnlyStream stream)
{
var buffer = new List <char>();
stream.ResetPositionToStart();
while (!stream.IsEof)
{
char current = stream.ReadNextChar();
if (!Regex.IsMatch(current.ToString(), Constants.CyrillicPattern))
{
continue;
}
buffer.Add(current);
}
return(buffer);
}