Add ru version (#1865)

* Add Russian docs site baseline

* Add Russian localized codebase

* Polish Russian code wording

* Update ru code translation.

* Update code translation and chapter covers.

* Fix pythontutor extraction.

* Add README and landing page.

* placeholder of profiles

* Use figures of English version

* Remove chapter paperbook

ru/codes/go/chapter_hashing/array_hash_map.go

@@ -0,0 +1,97 @@
+// File: array_hash_map.go
+// Created Time: 2022-12-14
+// Author: msk397 (machangxinq@gmail.com)
+
+package chapter_hashing
+
+import "fmt"
+
+/* Пара ключ-значение */
+type pair struct {
+	key int
+	val string
+}
+
+/* Хеш-таблица на основе массива */
+type arrayHashMap struct {
+	buckets []*pair
+}
+
+/* Инициализация хеш-таблицы */
+func newArrayHashMap() *arrayHashMap {
+	// Инициализировать массив, содержащий 100 корзин
+	buckets := make([]*pair, 100)
+	return &arrayHashMap{buckets: buckets}
+}
+
+/* Хеш-функция */
+func (a *arrayHashMap) hashFunc(key int) int {
+	index := key % 100
+	return index
+}
+
+/* Операция поиска */
+func (a *arrayHashMap) get(key int) string {
+	index := a.hashFunc(key)
+	pair := a.buckets[index]
+	if pair == nil {
+		return "Not Found"
+	}
+	return pair.val
+}
+
+/* Операция добавления */
+func (a *arrayHashMap) put(key int, val string) {
+	pair := &pair{key: key, val: val}
+	index := a.hashFunc(key)
+	a.buckets[index] = pair
+}
+
+/* Операция удаления */
+func (a *arrayHashMap) remove(key int) {
+	index := a.hashFunc(key)
+	// Присвоить nil, что означает удаление
+	a.buckets[index] = nil
+}
+
+/* Получить все ключи */
+func (a *arrayHashMap) pairSet() []*pair {
+	var pairs []*pair
+	for _, pair := range a.buckets {
+		if pair != nil {
+			pairs = append(pairs, pair)
+		}
+	}
+	return pairs
+}
+
+/* Получить все ключи */
+func (a *arrayHashMap) keySet() []int {
+	var keys []int
+	for _, pair := range a.buckets {
+		if pair != nil {
+			keys = append(keys, pair.key)
+		}
+	}
+	return keys
+}
+
+/* Получить все значения */
+func (a *arrayHashMap) valueSet() []string {
+	var values []string
+	for _, pair := range a.buckets {
+		if pair != nil {
+			values = append(values, pair.val)
+		}
+	}
+	return values
+}
+
+/* Вывести хеш-таблицу */
+func (a *arrayHashMap) print() {
+	for _, pair := range a.buckets {
+		if pair != nil {
+			fmt.Println(pair.key, "->", pair.val)
+		}
+	}
+}

ru/codes/go/chapter_hashing/array_hash_map_test.go

@@ -0,0 +1,52 @@
+// File: array_hash_map_test.go
+// Created Time: 2022-12-14
+// Author: msk397 (machangxinq@gmail.com)
+
+package chapter_hashing
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestArrayHashMap(t *testing.T) {
+	/* Инициализация хеш-таблицы */
+	hmap := newArrayHashMap()
+
+	/* Операция добавления */
+	// Добавить пару (key, value) в хеш-таблицу
+	hmap.put(12836, "Сяо Ха")
+	hmap.put(15937, "Сяо Ло")
+	hmap.put(16750, "Сяо Суань")
+	hmap.put(13276, "Сяо Фа")
+	hmap.put(10583, "Сяо Я")
+	fmt.Println("\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение")
+	hmap.print()
+
+	/* Операция поиска */
+	// Ввести в хеш-таблицу ключ key и получить значение value
+	name := hmap.get(15937)
+	fmt.Println("\nДля номера 15937 найдено имя " + name)
+
+	/* Операция удаления */
+	// Удалить пару (key, value) из хеш-таблицы
+	hmap.remove(10583)
+	fmt.Println("\nПосле удаления 10583 хеш-таблица имеет вид\nКлюч -> Значение")
+	hmap.print()
+
+	/* Обход хеш-таблицы */
+	fmt.Println("\nОтдельный обход пар ключ-значение")
+	for _, kv := range hmap.pairSet() {
+		fmt.Println(kv.key, " -> ", kv.val)
+	}
+
+	fmt.Println("\nОтдельный обход ключей")
+	for _, key := range hmap.keySet() {
+		fmt.Println(key)
+	}
+
+	fmt.Println("\nОтдельный обход значений")
+	for _, val := range hmap.valueSet() {
+		fmt.Println(val)
+	}
+}

ru/codes/go/chapter_hashing/hash_collision_test.go

@@ -0,0 +1,62 @@
+// File: hash_collision_test.go
+// Created Time: 2022-12-14
+// Author: msk397 (machangxinq@gmail.com)
+
+package chapter_hashing
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestHashMapChaining(t *testing.T) {
+	/* Инициализация хеш-таблицы */
+	hmap := newHashMapChaining()
+
+	/* Операция добавления */
+	// Добавить пару (key, value) в хеш-таблицу
+	hmap.put(12836, "Сяо Ха")
+	hmap.put(15937, "Сяо Ло")
+	hmap.put(16750, "Сяо Суань")
+	hmap.put(13276, "Сяо Фа")
+	hmap.put(10583, "Сяо Я")
+	fmt.Println("\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение")
+	hmap.print()
+
+	/* Операция поиска */
+	// Ввести в хеш-таблицу ключ key и получить значение value
+	name := hmap.get(15937)
+	fmt.Println("\nДля номера 15937 найдено имя", name)
+
+	/* Операция удаления */
+	// Удалить пару (key, value) из хеш-таблицы
+	hmap.remove(12836)
+	fmt.Println("\nПосле удаления 12836 хеш-таблица имеет вид\nКлюч -> Значение")
+	hmap.print()
+}
+
+func TestHashMapOpenAddressing(t *testing.T) {
+	/* Инициализация хеш-таблицы */
+	hmap := newHashMapOpenAddressing()
+
+	/* Операция добавления */
+	// Добавить пару (key, value) в хеш-таблицу
+	hmap.put(12836, "Сяо Ха")
+	hmap.put(15937, "Сяо Ло")
+	hmap.put(16750, "Сяо Суань")
+	hmap.put(13276, "Сяо Фа")
+	hmap.put(10583, "Сяо Я")
+	fmt.Println("\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение")
+	hmap.print()
+
+	/* Операция поиска */
+	// Ввести в хеш-таблицу ключ key и получить значение value
+	name := hmap.get(13276)
+	fmt.Println("\nДля номера 13276 найдено имя", name)
+
+	/* Операция удаления */
+	// Удалить пару (key, value) из хеш-таблицы
+	hmap.remove(16750)
+	fmt.Println("\nПосле удаления 16750 хеш-таблица имеет вид\nКлюч -> Значение")
+	hmap.print()
+}

ru/codes/go/chapter_hashing/hash_map_chaining.go

@@ -0,0 +1,134 @@
+// File: hash_map_chaining.go
+// Created Time: 2023-06-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_hashing
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+/* Хеш-таблица с цепочками */
+type hashMapChaining struct {
+	size        int      // Число пар ключ-значение
+	capacity    int      // Вместимость хеш-таблицы
+	loadThres   float64  // Порог коэффициента загрузки для запуска расширения
+	extendRatio int      // Коэффициент расширения
+	buckets     [][]pair // Массив корзин
+}
+
+/* Конструктор */
+func newHashMapChaining() *hashMapChaining {
+	buckets := make([][]pair, 4)
+	for i := 0; i < 4; i++ {
+		buckets[i] = make([]pair, 0)
+	}
+	return &hashMapChaining{
+		size:        0,
+		capacity:    4,
+		loadThres:   2.0 / 3.0,
+		extendRatio: 2,
+		buckets:     buckets,
+	}
+}
+
+/* Хеш-функция */
+func (m *hashMapChaining) hashFunc(key int) int {
+	return key % m.capacity
+}
+
+/* Коэффициент загрузки */
+func (m *hashMapChaining) loadFactor() float64 {
+	return float64(m.size) / float64(m.capacity)
+}
+
+/* Операция поиска */
+func (m *hashMapChaining) get(key int) string {
+	idx := m.hashFunc(key)
+	bucket := m.buckets[idx]
+	// Обойти корзину; если найден key, вернуть соответствующее val
+	for _, p := range bucket {
+		if p.key == key {
+			return p.val
+		}
+	}
+	// Если key не найден, вернуть пустую строку
+	return ""
+}
+
+/* Операция добавления */
+func (m *hashMapChaining) put(key int, val string) {
+	// Когда коэффициент загрузки превышает порог, выполнить расширение
+	if m.loadFactor() > m.loadThres {
+		m.extend()
+	}
+	idx := m.hashFunc(key)
+	// Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть
+	for i := range m.buckets[idx] {
+		if m.buckets[idx][i].key == key {
+			m.buckets[idx][i].val = val
+			return
+		}
+	}
+	// Если такого key нет, добавить пару ключ-значение в конец
+	p := pair{
+		key: key,
+		val: val,
+	}
+	m.buckets[idx] = append(m.buckets[idx], p)
+	m.size += 1
+}
+
+/* Операция удаления */
+func (m *hashMapChaining) remove(key int) {
+	idx := m.hashFunc(key)
+	// Обойти корзину и удалить из нее пару ключ-значение
+	for i, p := range m.buckets[idx] {
+		if p.key == key {
+			// Удаление из среза
+			m.buckets[idx] = append(m.buckets[idx][:i], m.buckets[idx][i+1:]...)
+			m.size -= 1
+			break
+		}
+	}
+}
+
+/* Расширить хеш-таблицу */
+func (m *hashMapChaining) extend() {
+	// Временно сохранить исходную хеш-таблицу
+	tmpBuckets := make([][]pair, len(m.buckets))
+	for i := 0; i < len(m.buckets); i++ {
+		tmpBuckets[i] = make([]pair, len(m.buckets[i]))
+		copy(tmpBuckets[i], m.buckets[i])
+	}
+	// Инициализация новой хеш-таблицы после расширения
+	m.capacity *= m.extendRatio
+	m.buckets = make([][]pair, m.capacity)
+	for i := 0; i < m.capacity; i++ {
+		m.buckets[i] = make([]pair, 0)
+	}
+	m.size = 0
+	// Перенести пары ключ-значение из исходной хеш-таблицы в новую
+	for _, bucket := range tmpBuckets {
+		for _, p := range bucket {
+			m.put(p.key, p.val)
+		}
+	}
+}
+
+/* Вывести хеш-таблицу */
+func (m *hashMapChaining) print() {
+	var builder strings.Builder
+
+	for _, bucket := range m.buckets {
+		builder.WriteString("[")
+		for _, p := range bucket {
+			builder.WriteString(strconv.Itoa(p.key) + " -> " + p.val + " ")
+		}
+		builder.WriteString("]")
+		fmt.Println(builder.String())
+		builder.Reset()
+	}
+}

ru/codes/go/chapter_hashing/hash_map_open_addressing.go

@@ -0,0 +1,126 @@
+// File: hash_map_open_addressing.go
+// Created Time: 2023-06-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_hashing
+
+import (
+	"fmt"
+)
+
+/* Хеш-таблица с открытой адресацией */
+type hashMapOpenAddressing struct {
+	size        int     // Число пар ключ-значение
+	capacity    int     // Вместимость хеш-таблицы
+	loadThres   float64 // Порог коэффициента загрузки для запуска расширения
+	extendRatio int     // Коэффициент расширения
+	buckets     []*pair // Массив корзин
+	TOMBSTONE   *pair   // Удалить метку
+}
+
+/* Конструктор */
+func newHashMapOpenAddressing() *hashMapOpenAddressing {
+	return &hashMapOpenAddressing{
+		size:        0,
+		capacity:    4,
+		loadThres:   2.0 / 3.0,
+		extendRatio: 2,
+		buckets:     make([]*pair, 4),
+		TOMBSTONE:   &pair{-1, "-1"},
+	}
+}
+
+/* Хеш-функция */
+func (h *hashMapOpenAddressing) hashFunc(key int) int {
+	return key % h.capacity // Вычислить хеш-значение по ключу
+}
+
+/* Коэффициент загрузки */
+func (h *hashMapOpenAddressing) loadFactor() float64 {
+	return float64(h.size) / float64(h.capacity) // Вычислить текущий коэффициент загрузки
+}
+
+/* Найти индекс корзины, соответствующий key */
+func (h *hashMapOpenAddressing) findBucket(key int) int {
+	index := h.hashFunc(key) // Получить начальный индекс
+	firstTombstone := -1     // Запомнить положение первого TOMBSTONE
+	for h.buckets[index] != nil {
+		if h.buckets[index].key == key {
+			if firstTombstone != -1 {
+				// Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс
+				h.buckets[firstTombstone] = h.buckets[index]
+				h.buckets[index] = h.TOMBSTONE
+				return firstTombstone // Вернуть индекс корзины после перемещения
+			}
+			return index // Вернуть найденный индекс
+		}
+		if firstTombstone == -1 && h.buckets[index] == h.TOMBSTONE {
+			firstTombstone = index // Запомнить положение первой метки удаления
+		}
+		index = (index + 1) % h.capacity // Линейное пробирование: при выходе за хвост вернуться к началу
+	}
+	// Если key не существует, вернуть индекс точки добавления
+	if firstTombstone != -1 {
+		return firstTombstone
+	}
+	return index
+}
+
+/* Операция поиска */
+func (h *hashMapOpenAddressing) get(key int) string {
+	index := h.findBucket(key) // Найти индекс корзины, соответствующий key
+	if h.buckets[index] != nil && h.buckets[index] != h.TOMBSTONE {
+		return h.buckets[index].val // Если пара ключ-значение найдена, вернуть соответствующее val
+	}
+	return "" // Если пара ключ-значение не существует, вернуть ""
+}
+
+/* Операция добавления */
+func (h *hashMapOpenAddressing) put(key int, val string) {
+	if h.loadFactor() > h.loadThres {
+		h.extend() // Когда коэффициент загрузки превышает порог, выполнить расширение
+	}
+	index := h.findBucket(key) // Найти индекс корзины, соответствующий key
+	if h.buckets[index] == nil || h.buckets[index] == h.TOMBSTONE {
+		h.buckets[index] = &pair{key, val} // Если пары ключ-значение нет, добавить ее
+		h.size++
+	} else {
+		h.buckets[index].val = val // Если пара ключ-значение найдена, перезаписать val
+	}
+}
+
+/* Операция удаления */
+func (h *hashMapOpenAddressing) remove(key int) {
+	index := h.findBucket(key) // Найти индекс корзины, соответствующий key
+	if h.buckets[index] != nil && h.buckets[index] != h.TOMBSTONE {
+		h.buckets[index] = h.TOMBSTONE // Если пара ключ-значение найдена, заменить ее меткой удаления
+		h.size--
+	}
+}
+
+/* Расширить хеш-таблицу */
+func (h *hashMapOpenAddressing) extend() {
+	oldBuckets := h.buckets               // Временно сохранить исходную хеш-таблицу
+	h.capacity *= h.extendRatio           // Обновить емкость
+	h.buckets = make([]*pair, h.capacity) // Инициализация новой хеш-таблицы после расширения
+	h.size = 0                            // Сбросить размер
+	// Перенести пары ключ-значение из исходной хеш-таблицы в новую
+	for _, pair := range oldBuckets {
+		if pair != nil && pair != h.TOMBSTONE {
+			h.put(pair.key, pair.val)
+		}
+	}
+}
+
+/* Вывести хеш-таблицу */
+func (h *hashMapOpenAddressing) print() {
+	for _, pair := range h.buckets {
+		if pair == nil {
+			fmt.Println("nil")
+		} else if pair == h.TOMBSTONE {
+			fmt.Println("TOMBSTONE")
+		} else {
+			fmt.Printf("%d -> %s\n", pair.key, pair.val)
+		}
+	}
+}

ru/codes/go/chapter_hashing/hash_map_test.go

@@ -0,0 +1,74 @@
+// File: hash_map_test.go
+// Created Time: 2022-12-14
+// Author: msk397 (machangxinq@gmail.com)
+
+package chapter_hashing
+
+import (
+	"fmt"
+	"strconv"
+	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+func TestHashMap(t *testing.T) {
+	/* Инициализация хеш-таблицы */
+	hmap := make(map[int]string)
+
+	/* Операция добавления */
+	// Добавить пару (key, value) в хеш-таблицу
+	hmap[12836] = "Сяо Ха"
+	hmap[15937] = "Сяо Ло"
+	hmap[16750] = "Сяо Суань"
+	hmap[13276] = "Сяо Фа"
+	hmap[10583] = "Сяо Я"
+	fmt.Println("\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение")
+	PrintMap(hmap)
+
+	/* Операция поиска */
+	// Ввести в хеш-таблицу ключ key и получить значение value
+	name := hmap[15937]
+	fmt.Println("\nДля номера 15937 найдено имя", name)
+
+	/* Операция удаления */
+	// Удалить пару (key, value) из хеш-таблицы
+	delete(hmap, 10583)
+	fmt.Println("\nПосле удаления 10583 хеш-таблица имеет вид\nКлюч -> Значение")
+	PrintMap(hmap)
+
+	/* Обход хеш-таблицы */
+	// Перебрать пары ключ-значение key->value
+	fmt.Println("\nОтдельный обход пар ключ-значение")
+	for key, value := range hmap {
+		fmt.Println(key, "->", value)
+	}
+	// Отдельно обходить ключи key
+	fmt.Println("\nОтдельный обход ключей")
+	for key := range hmap {
+		fmt.Println(key)
+	}
+	// Отдельно обходить значения value
+	fmt.Println("\nОтдельный обход значений")
+	for _, value := range hmap {
+		fmt.Println(value)
+	}
+}
+
+func TestSimpleHash(t *testing.T) {
+	var hash int
+
+	key := "Hello Algo"
+
+	hash = addHash(key)
+	fmt.Println("Хеш-сумма сложением = " + strconv.Itoa(hash))
+
+	hash = mulHash(key)
+	fmt.Println("Хеш-сумма умножением = " + strconv.Itoa(hash))
+
+	hash = xorHash(key)
+	fmt.Println("Хеш-сумма XOR = " + strconv.Itoa(hash))
+
+	hash = rotHash(key)
+	fmt.Println("Хеш-сумма с циклическим сдвигом = " + strconv.Itoa(hash))
+}

ru/codes/go/chapter_hashing/simple_hash.go

@@ -0,0 +1,55 @@
+// File: simple_hash.go
+// Created Time: 2023-06-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_hashing
+
+import "fmt"
+
+/* Аддитивное хеширование */
+func addHash(key string) int {
+	var hash int64
+	var modulus int64
+
+	modulus = 1000000007
+	for _, b := range []byte(key) {
+		hash = (hash + int64(b)) % modulus
+	}
+	return int(hash)
+}
+
+/* Мультипликативное хеширование */
+func mulHash(key string) int {
+	var hash int64
+	var modulus int64
+
+	modulus = 1000000007
+	for _, b := range []byte(key) {
+		hash = (31*hash + int64(b)) % modulus
+	}
+	return int(hash)
+}
+
+/* XOR-хеширование */
+func xorHash(key string) int {
+	hash := 0
+	modulus := 1000000007
+	for _, b := range []byte(key) {
+		fmt.Println(int(b))
+		hash ^= int(b)
+		hash = (31*hash + int(b)) % modulus
+	}
+	return hash & modulus
+}
+
+/* Хеширование с циклическим сдвигом */
+func rotHash(key string) int {
+	var hash int64
+	var modulus int64
+
+	modulus = 1000000007
+	for _, b := range []byte(key) {
+		hash = ((hash << 4) ^ (hash >> 28) ^ int64(b)) % modulus
+	}
+	return int(hash)
+}