hw 8 verkh

Урок 8. Практическое задание/task_1.py

@@ -16,3 +16,24 @@
 
 Итог: 6 подстрок
 """
+
+import hashlib
+
+
+a = input('Введите строку состоящую из маленьких букв\n')
+b = []      # Создаем пустой список, в который будем вносить подстроки
+for i in range(0, len(a)):       # считаем от 0 до длинны строки
+    for j in range(i + 1, len(a) + 1):  # считаем от прошлого счёта + 1 до длинны строки +1
+        g = a[i:j]           # Находим срезы от [0:1] до [3:4]
+        print(g.encode('utf-8'))     # Кодируем срез в байты
+        print(hashlib.sha1(g.encode('utf-8')))  # Хэшируем наши срезы в байты
+        print(hashlib.sha1(g.encode('utf-8')).hexdigest())  # Представляем хэш в шестнадцатяричной форме
+        b.append(hashlib.sha1(g.encode('utf-8')).hexdigest())  # добавляем хэш в список
+
+b.remove(hashlib.sha1(a.encode('utf-8')).hexdigest())    # Удаляем хэщ целой(полной) строки
+r = set(b)    # Избавляемся от повторов изменяя тип данных на кортеж
+print(f'Колличество различных подстрок в строке {a} равно {len(r)}')
+
+
+
+

Урок 8. Практическое задание/task_2.py

@@ -8,3 +8,85 @@
 Результат:
 00 11 11 101 010 00 011 011 101 010 00 11 11 1000 1001
 """
+
+from collections import Counter, deque
+
+
+def haffman_tree(s):
+    count = Counter(s)   # Получаем частоты каждого элемента
+    sorted_elements = deque(sorted(count.items(), key=lambda item: item[1]))  # Создаем очередь по возрастанию частот
+    # Проверка, если строка состоит из одного повторяющего символа.
+    if len(sorted_elements) != 1:
+        # Цикл для построения дерева
+        while len(sorted_elements) > 1:
+            weight = sorted_elements[0][1] + sorted_elements[1][1]  # Суммируем частоты двух левых элементов лчереди
+            '''
+            {0: 'r', 1: '!'}
+            {0: {0: 'r', 1: '!'}, 1: 'p'}
+            {0: ' ', 1: 'o'}
+            {0: 'b', 1: {0: ' ', 1: 'o'}}
+            {0: {0: {0: 'r', 1: '!'}, 1: 'p'}, 1: 'e'}
+            {0: {0: 'b', 1: {0: ' ', 1: 'o'}}, 1: {0: {0: {0: 'r', 1: '!'}, 1: 'p'}, 1: 'e'}}
+            '''
+            comb = {0: sorted_elements.popleft()[0],   # Создаем узлы дерева 0 b 1. popleft удаляет элемент из очереди
+                    1: sorted_elements.popleft()[0]}   # и возвращает значение
+
+            # Ищем место для ставки объединенного элемента
+            for i, _count in enumerate(sorted_elements):
+                if weight > _count[1]:              # Если частота больше частоты iого элемента, то считаем дальше
+                    continue
+                else:
+                    sorted_elements.insert(i, (comb, weight))  # Если меньше, то вставляем узел
+                    break
+            else:
+                # Добавляем объединенный корневой элемент после
+                # завершения работы цикла
+
+                sorted_elements.append((comb, weight))
+            '''
+            deque([({0: 'r', 1: '!'}, 2), ('p', 2), (' ', 2), ('o', 2), ('b', 3), ('e', 4)])
+            deque([(' ', 2), ('o', 2), ('b', 3), ({0: {0: 'r', 1: '!'}, 1: 'p'}, 4), ('e', 4)])
+            deque([('b', 3), ({0: ' ', 1: 'o'}, 4), ({0: {0: 'r', 1: '!'}, 1: 'p'}, 4), ('e', 4)])
+            deque([({0: {0: 'r', 1: '!'}, 1: 'p'}, 4), ('e', 4), ({0: 'b', 1: {0: ' ', 1: 'o'}}, 7)])
+            deque([({0: 'b', 1: {0: ' ', 1: 'o'}}, 7), ({0: {0: {0: 'r', 1: '!'}, 1: 'p'}, 1: 'e'}, 8)])
+            deque([({0: {0: 'b', 1: {0: ' ', 1: 'o'}}, 1: {0: {0: {0: 'r', 1: '!'}, 1: 'p'}, 1: 'e'}}, 15)])
+            '''
+    else:
+        # приравниваемыем значение 0 к одному повторяющемуся символу
+        weight = sorted_elements[0][1]
+        comb = {0: sorted_elements.popleft()[0], 1: None}
+        sorted_elements.append((comb, weight))
+    # sorted_elements - deque([({0: {0: 'b', 1: {0: ' ', 1: 'o'}}, 1: {0: {0: {0: 'r', 1: '!'}, 1: 'p'}, 1: 'e'}}, 15)])
+    # {0: {0: 'b', 1: {0: ' ', 1: 'o'}}, 1: {0: {0: {0: 'r', 1: '!'}, 1: 'p'}, 1: 'e'}}
+    # словарь - дерево
+    return sorted_elements[0][0]
+
+
+code_table = dict()
+
+# tree - {0: {0: 'b', 1: {0: ' ', 1: 'o'}}, 1: {0: {0: {0: 'r', 1: '!'}, 1: 'p'}, 1: 'e'}}
+def haffman_code(tree, path=''):
+    # Если элемент не словарь, значит мы достигли самого символа
+    # и заносим его, а так же его код в словарь (кодовую таблицу).
+    if not isinstance(tree, dict):
+        code_table[tree] = path
+    # Если элемент словарь, рекурсивно спускаемся вниз
+    # по первому и второму значению (левая и правая ветви).
+    else:
+        haffman_code(tree[0], path=f'{path}0')
+        haffman_code(tree[1], path=f'{path}1')
+
+
+# строка для кодирования
+s = "beep boop beer!"
+
+# функция заполняет кодовую таблицу (символ-его код)
+# {'b': '00', ' ': '010', 'o': '011', 'r': '1000', '!': '1001', 'p': '101', 'e': '11'}
+haffman_code(haffman_tree(s))
+
+# code_table - {'b': '00', ' ': '010', 'o': '011', 'r': '1000', '!': '1001', 'p': '101', 'e': '11'}
+
+# выводим коды для каждого символа
+for i in s:
+    print(code_table[i], end=' ')
+print()