День открытых дверей
Всё о курсе «Разработчик Golang»

Hello, OTUS!. Необходимо написать программу, печатающую в стандартный вывод перевернутую фразу
```
Hello, OTUS!
```

Для переворота строки следует воспользоваться возможностями
[golang.org/x/example/stringutil](https://github.com/golang/example/tree/master/stringutil).

Кроме этого необходимо исправить **go.mod** так, чтобы для данного модуля работала
команда `go get`, а полученный **go.sum** закоммитить.

Подробности:
https://github.com/OtusGolang/home_work/tree/master/hw01_hello_otus

Процесс сдачи домашнего задания:
https://github.com/OtusGolang/home_work/wiki/[Студентам]-Процесс-сдачи-ДЗ

Распаковка строки. Необходимо написать Go функцию, осуществляющую примитивную распаковку строки,
содержащую повторяющиеся символы/руны, например:
* "a4bc2d5e" => "aaaabccddddde"
* "abcd" => "abcd"
* "3abc" => "" (некорректная строка)
* "45" => "" (некорректная строка)
* "aaa10b" => "" (некорректная строка)
* "aaa0b" => "aab"
* "" => ""
* "d\n5abc" => "d\n\n\n\n\nabc"

Как видно из примеров, разрешено использование цифр, но не чисел.

В случае, если была передана некорректная строка, функция должна возвращать ошибку.
При необходимости можно выделять дополнительные функции / ошибки.

Подробности:
https://github.com/OtusGolang/home_work/tree/master/hw02_unpack_string

Процесс сдачи домашнего задания:
https://github.com/OtusGolang/home_work/wiki/[Студентам]-Процесс-сдачи-ДЗ

Частотный анализ . Необходимо написать Go функцию, принимающую на вход строку с текстом и
возвращающую слайс с 10-ю наиболее часто встречаемыми в тексте словами.

Если слова имеют одинаковую частоту, то должны быть отсортированы **лексикографически**.

* Словом считается набор символов, разделенных пробельными символами.

* Если есть более 10 самых частотых слов (например 15 разных слов встречаются ровно 133 раза,
остальные < 100), то следует вернуть 10 лексикографически первых слов.

* Словоформы не учитываем: "нога", "ногу", "ноги" - это разные слова.

* Слово с большой и маленькой буквы считать за разные слова. "Нога" и "нога" - это разные слова.

* Знаки препинания считать "буквами" слова или отдельными словами.
"-" (тире) - это отдельное слово. "нога," и "нога" - это разные слова.

## Пример
```
cat and dog, one dog,two cats and one man
```
Топ 7:
- `and` (2)
- `one` (2)
- `cat` (1)
- `cats` (1)
- `dog,` (1)
- `dog,two` (1)
- `man` (1)

При необходимости можно выделять дополнительные функции / ошибки.

Подробности:
https://github.com/OtusGolang/home_work/tree/master/hw03_frequency_analysis

Процесс сдачи домашнего задания:
https://github.com/OtusGolang/home_work/wiki/[Студентам]-Процесс-сдачи-ДЗ

LRU-кэш. Необходимо реализовать LRU-кэш на основе двусвязного списка.

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

## 1) Реализация двусвязного списка
Список имеет структуру вида
```text
nil <- (prev) front <-> ... <-> elem <-> ... <-> back (next) -> nil
```

Необходимо реализовать следующий интерфейс List:
- Len() int // длина списка
- Front() *ListItem // первый элемент списка
- Back() *ListItem // последний элемент списка
- PushFront(v interface{}) *ListItem // добавить значение в начало
- PushBack(v interface{}) *ListItem // добавить значение в конец
- Remove(i *ListItem) // удалить элемент
- MoveToFront(i *ListItem) // переместить элемент в начало

**Считаем, что методы Remove и MoveToFront вызываются только от существующих в списке элементов.**

Элемент списка ListItem:
- Value interface{} // значение
- Next *ListItem // следующий элемент
- Prev *ListItem // предыдущий элемент

Сложность всех операций должна быть O(1),
т.е. не должно быть мест, где осуществляется полный обход списка.

## 2) Реализация кэша на основе ранее написанного списка
Необходимо реализовать следующий интерфейс Cache:
- Set(key Key, value interface{}) bool // Добавить значение в кэш по ключу.
- Get(key Key) (interface{}, bool) // Получить значение из кэша по ключу.
- Clear() // Очистить кэш.

Структура кэша:
- ёмкость (количество сохраняемых в кэше элементов)
- очередь \[последних используемых элементов\] на основе двусвязного списка
- словарь, отображающий ключ (строка) на элемент очереди

Элемент кэша хранит в себе ключ, по которому он лежит в словаре, и само значение.
Для чего это нужно понятно из алгоритма работы кэша (см. ниже).

Сложность операций `Set`/`Get` должна быть O(1), при желании `Clear` тоже можно сделать О(1).

Алгоритм работы кэша:
- при добавлении элемента:
- если элемент присутствует в словаре, то обновить его значение и переместить элемент в начало очереди;
- если элемента нет в словаре, то добавить в словарь и в начало очереди
(при этом, если размер очереди больше ёмкости кэша,
то необходимо удалить последний элемент из очереди и его значение из словаря);
- возвращаемое значение - флаг, присутствовал ли элемент в кэше.
- при получении элемента:
- если элемент присутствует в словаре, то переместить элемент в начало очереди и вернуть его значение и true;
- если элемента нет в словаре, то вернуть nil и false
(работа с кешом похожа на работу с `map`)

Ожидаются следующие тесты:
- на логику выталкивания элементов из-за размера очереди
(например: n = 3, добавили 4 элемента - 1й из кэша вытолкнулся);
- на логику выталкивания давно используемых элементов
(например: n = 3, добавили 3 элемента, обратились несколько раз к разным элементам:
изменили значение, получили значение и пр. - добавили 4й элемент,
из первой тройки вытолкнется тот элемент, что был затронут наиболее давно).

Подробности:
https://github.com/OtusGolang/home_work/tree/master/hw04_lru_cache

Процесс сдачи домашнего задания:
https://github.com/OtusGolang/home_work/wiki/[Студентам]-Процесс-сдачи-ДЗ