>>47701
Для описания процесса рекурсивного сжатия данных, рассмотрим формулу, которая отражает несколько ключевых этапов сжатия, включая разбиение на блоки, использование словаря и рекурсивное сжатие.

### Формула для рекурсивного сжатия:

\[
C_{\text{final}} = f_{\text{compress}}\left( \dots f_{\text{compress}}\left( f_{\text{compress}}\left( D \right) \right) \dots \right)
\]

где:

- \( D \) — исходные данные, представленные в виде последовательности байтов.
- \( f_{\text{compress}} \) — функция сжатия данных с использованием словаря, которая выполняет рекурсию на нескольких уровнях.
- \( C_{\text{final}} \) — окончательно сжатые данные.

### Описание шагов в формуле:

1. Разбиение на 2-битные блоки (split into 2-bit blocks):
Исходные данные сначала разбиваются на более мелкие блоки — 2-битные блоки. Это помогает эффективно представлять данные в виде более компактных единиц, что облегчает их дальнейшую обработку.

\[
B_i = \text{split}(D) \quad \text{где } B_i \text{ — 2-битный блок, полученный из данных } D.
\]

2. Построение словаря на каждом уровне сжатия (dictionary creation):
Каждый уровень сжатия строит свой собственный словарь, в котором хранятся уникальные пары блоков из предыдущего уровня. Эти пары кодируются в виде числовых значений, которые становятся всё короче по мере углубления в рекурсию.

\[
S_{\text{level}} = \{(p_{\text{pair}}, \text{index})\}, \quad \text{где } p_{\text{pair}} \text{ — пара блоков, а } \text{index} \text{ — индекс пары в словаре}.
\]

3. Рекурсивное сжатие на каждом уровне (recursive compression):
Функция сжатия на каждом уровне использует словарь для замены найденных пар блоков на их индексы. Этот процесс продолжается рекурсивно до тех пор, пока данные не смогут быть дополнительно сжаты или не достигнут минимального размера.

\[
f_{\text{compress}}(D_{\text{level}}) = \{ \text{code}_{\text{pair}} \} \quad \text{для каждой пары } p_{\text{pair}} \text{ на уровне}.
\]

4. Объединение сжатых блоков в итоговый результат (final compressed data):
После завершения рекурсии все коды пар блоков из всех уровней сжимаются в итоговый компактный формат, который можно сохранить в файл.

\[
C_{\text{final}} = \text{combine}(\{ \text{code}_i \})
\]

### Пример конкретной реализации:

Предположим, что у нас есть строка данных \( D = \text{"hellohellohello"} \), и мы её хотим сжать с использованием описанного алгоритма. На первом уровне мы разбиваем строку на 2-битные блоки и строим словарь для каждого уникального символа или пары символов. На следующем уровне, если встречаются одинаковые пары блоков, мы заменяем их на более короткие коды, используя уже созданный словарь. Процесс повторяется на нескольких уровнях.

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

### Итоговое описание формулы:

Рекурсивная формула для сжатия данных через многослойный словарь описывает последовательность шагов, где на каждом уровне:

- Происходит разбиение на более мелкие блоки.
- Строится новый словарь для замены повторяющихся блоков.
- Применяется рекурсия до тех пор, пока сжатие не станет невозможным.

Это позволяет значительно уменьшить размер исходных данных, эффективно используя повторяющиеся шаблоны и структуры в данных, и дает возможность дальнейшего сжатия.

>>50167
>>50167
Да, это делает этот код, а также это запатентовал Ян Слоот, но он был жмотом и умер до анонса метода

import os
import json
import tkinter as tk
from tkinter import filedialog, messagebox

DATA_FILE = "data.json"
COMPRESSED_EXT = ".ctxt"

ALPHABET = (
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
'abcdefghijklmnopqrstuvwxyz'
'0123456789'
'一丁七万丈三上下不与丑专且世丘丙业丛东丝丞丢两严並丧丨'
'अआइईउऊऋएऐओऔकखगघङचछजझञटठडढणतथदधनपफबभमयरलवशीष़ज़ािीुूृॅेैॉौं्аәбвгджзклмнөпрстуүфхцчшщъыьэюя' # Cyrillic and Devanagari
)
ALPHABET = ''.join(sorted(set(ALPHABET)))

def int_to_hash(n, length=4):
base = len(ALPHABET)
digits = []
for _ in range(length):
n, rem = divmod(n, base)
digits.append(rem)
return ''.join(ALPHABET[d] for d in reversed(digits))

def hash_to_int(hash_str):
base = len(ALPHABET)
code = 0
for char in hash_str:
code = code * base + ALPHABET.index(char)
return code

def split_into_2bit_blocks(data):
blocks = []
for byte in data:
blocks.extend([
(byte >> 6) & 0x03,
(byte >> 4) & 0x03,
(byte >> 2) & 0x03,
byte & 0x03
])
return blocks

def combine_from_2bit_blocks(blocks):
data = []
for i in range(0, len(blocks), 4):
chunk = blocks[i:i+4]
while len(chunk) < 4:
chunk.append(0)
byte = (chunk[0] << 6) | (chunk[1] << 4) | (chunk[2] << 2) | chunk[3]
data.append(byte)
return data

def compress(data, dictionaries):
current_data = split_into_2bit_blocks(data)
original_length = len(current_data)

for level in range(4):
if len(current_data) % 2 != 0:
current_data.append(0) # Padding
code_to_pair = dictionaries[level]
pair_to_code = {pair: idx for idx, pair in enumerate(code_to_pair)}
new_data = []
for i in range(0, len(current_data), 2):
pair = (current_data, current_data[i+1])
if pair in pair_to_code:
new_data.append(pair_to_code[pair])
else:
code = len(code_to_pair)
code_to_pair.append(pair)
pair_to_code[pair] = code
new_data.append(code)
current_data = new_data
if len(current_data) <= 1:
break

compressed_str = ''.join(int_to_hash(code) for code in current_data)
return f"{original_length}:{compressed_str}"

def decompress(compressed_str, dictionaries):
if ':' not in compressed_str:
messagebox.showerror("Error", "Invalid compressed format")
return []
original_length_str, hash_str = compressed_str.split(':', 1)
original_length = int(original_length_str)

hash_length = 4
chunked = [hash_str[i:i+hash_length] for i in range(0, len(hash_str), hash_length)]
try:
current_data = [hash_to_int(h) for h in chunked]
except ValueError:
return []

for level in reversed(range(4)):
if not current_data:
break
if level >= len(dictionaries):
continue
code_to_pair = dictionaries[level]
new_data = []
for code in current_data:
if code < len(code_to_pair):
new_data.extend(code_to_pair[code])
else:
return []
current_data = new_data

current_data = current_data[:original_length] # Trim padding
return combine_from_2bit_blocks(current_data)

def save_data_file(data):
try:
data["dictionary"] = [[list(p) for p in level] for level in data["dictionary"]]
with open(DATA_FILE, 'w') as f:
json.dump(data, f, indent=4)
except Exception as e:
messagebox.showerror("Error", f"Error saving data: {str(e)}")

def load_data_file():
try:
if os.path.exists(DATA_FILE):
with open(DATA_FILE, 'r') as f:
data = json.load(f)
data["dictionary"] = [[tuple(p) for p in level] for level in data["dictionary"]]
return data
except Exception as e:
messagebox.showerror("Error", f"Error loading data: {str(e)}")
return {"dictionary": [[] for _ in range(4)], "files": []}

class FileManager:
def __init__(self, root):
self.root = root
self.root.title("4-Level Compressor")
self.data = load_data_file()
self.dictionaries = self.data["dictionary"]

self.listbox = tk.Listbox(root)
self.listbox.pack(fill=tk.BOTH, expand=True)

btn_frame = tk.Frame(root)
btn_frame.pack(fill=tk.X)

self.compress_btn = tk.Button(btn_frame, text="Compress", command=self.compress_file)
self.compress_btn.pack(side=tk.LEFT, padx=5)

self.decompress_btn = tk.Button(btn_frame, text="Decompress", command=self.decompress_file)
self.decompress_btn.pack(side=tk.RIGHT, padx=5)

self.update_list()

def update_list(self):
self.listbox.delete(0, tk.END)
for f in self.data["files"]:
self.listbox.insert(tk.END, f)

def compress_file(self):
path = filedialog.askopenfilename()
if not path:
return

try:
with open(path, 'rb') as f:
data = f.read()
except Exception as e:
messagebox.showerror("Error", f"Read error: {str(e)}")
return

compressed = compress(list(data), self.dictionaries)
output_name = os.path.basename(path) + COMPRESSED_EXT

try:
with open(output_name, 'w', encoding='utf-8') as f:
f.write(compressed)
except Exception as e:
messagebox.showerror("Error", f"Write error: {str(e)}")
return

if output_name not in self.data["files"]:
self.data["files"].append(output_name)
save_data_file(self.data)
self.update_list()

def decompress_file(self):
selected = self.listbox.get(tk.ACTIVE)
if not selected:
return

save_path = filedialog.asksaveasfilename(
defaultextension=".bin",
initialfile=selected.replace(COMPRESSED_EXT, "")
)
if not save_path:
return

try:
with open(selected, 'r', encoding='utf-8') as f:
compressed_str = f.read()
except Exception as e:
messagebox.showerror("Error", f"Read error: {str(e)}")
return

decompressed = decompress(compressed_str, self.dictionaries)
if not decompressed:
messagebox.showerror("Error", "Decompression failed")
return

try:
with open(save_path, 'wb') as f:
f.write(bytes(decompressed))
messagebox.showinfo("Success", "File decompressed successfully!")
except Exception as e:
messagebox.showerror("Error", f"Write error: {str(e)}")

if __name__ == "__main__":
root = tk.Tk()
app = FileManager(root)
root.mainloop()