>>03641
Ебать ты Катющик от мира информатики, смотри к чему сводится твое "открытие":
1. Любое кроме нуля число можно записать непустым и без нулей в начале, т. е. 0001 = 1, 0010 = 10, 0011 = 11, 0100 = 100 и так далее
2. Так как первая цифра после этого не ноль, то это единица и зная это можно ее отбросить, получится 0001 › {пустота}, 0010 › 0, 0011 › 1, 0100 › 00 и т. п.
Действительно, таким образом все кроме одной последовательности фиксированной длины n можно отобразить на последовательности длин меньших n, вот только исходная длина в результате нигде не фиксируется, следовательно то же 00 может быть произведено от 100, 0100, 00100, 00000100 и еще до бесконечности аналогичных строк {n нулей}100. При этом 50% возможных входных строк (начинающиеся с 1) сократятся на 1 бит, 25% (начинающиеся на 01) — на 2 бита, 12.5% (на 001) — на 3, и лишь 0.39% получится сократить хотя бы на байт (00000001) и всё это НЕ учитывая запись информации об исходной длине, а длину или количество убранных нулей тоже надо где-то сохранять и притом отдельно от "сжатых" данных, что также несет дополнительную информацию. Возьмем некоторый реальный файл, скажем текст "Я шиз" в стандартной кодировке Windows-1251, в битах это 1101111100100000111110001110100011100111, сжатие Zogoschiz Digital Coding System отбросит первый бит, то есть останется 1011... и т. д., как длину сокращения записываем ноль, так как было убрано ноль нулей, допустим мы не зогошизы и нахуй нам не нужон аж целый 1 бит (тем более испокон веков минимальная практическая единица — это 8 бит ака байт), хотим и дальше сжимать чудо-способом, следующая попытка отбросит еще одну единичку и также запишет длину 0, дальше выходит 1, 0, 0, 0, 0, 2, 5 (ого!), 0, 0, 0, 0, 3, 0, 0, 1, 3, 0, 0, 2, 0, 0 (здесь "сжатый" великим алгоритмом файл уже пуст). Вместо 40 бит получили набор из 23 чисел (и добавим еще 0 как длину итоговой строки без единиц, ведь те уже не "сжимаются"), которые еще вопрос как упаковать и удастся ли это меньше чем в те же 40 бит, фактически это просто количества нулей на участках, разделенных по единицам. В общем, выходит полное фуфло, который было бы сколь-либо практично лишь если бы объем входного файла был сплошняком забит ненужными нулевыми байтами, ну так при эмуляции различных архаичных систем тоже не ты придумал хранить в дампе не всю память от 0000 до FFFF, а только значимую часть, и в целом этот примитив максимально далек от даже самых основ теории сжатия данных. У тебя фундаментальная ошибка в том, что ты противопоставляешь "исходные" 2^n файлов "сжатым" 2^(n-m) файлам, тогда как реальные "исходные" файлы куда чаще имеют размеры из этих 2^(n-m) (было бы странно, если бы верхнюю границу алгоритма выделенную скажем для фильма занимала бы и картинка и текст) и подгонять их всех под верхнюю границу можно разве что мусорными данными, которые потом сей "алгоритм сжатия" обратно же и откатит, принцип кота Матроскина — чтобы продать что-то ненужное, надо перед этим купить что-то ненужное (где в качестве валюты выступает память компьютера). С последующих ссылок тоже порофлил, скрин бессмысленного говнокода с генерацией случайных чисел и неприкрыто шуточный проект про волшебное число пи, где есть все последовательности цифр (внезапно все они же есть в натуральном ряду чисел, но если его общая структура известна заранее, то вычисление очередных цифр пи — задача, которая выполняется нихуевыми мощностями и где ставятся рекорды, мотивированные явно не игрушкой в "спрятать в пи словарь русского мата" (не говоря о том что уже "Я шиз" едва ли удастся спрятать, к примеру, цифры 0123456789 встречаются впервые лишь в 18-ом триллиарде знаков, а всего вычислено 100 триллионов)

>>49730
У слоота было 3 алгоритма и все они были основаны на базе данных состояний которые могли рекурсивно перемножатся друг на друга в итоге получался кадр или фильм, но и сами перемножения тоже можно сделать базой ведь у 4 битного кода всего 16 состояний.

В информатике числа генерируются не случайно, генератор чисел это два синуса умноженные друг на друга те слот, взломав рандом, запрогал его на генерацию из состояний по типу таких

на основе этого мною создан генератор бесконечных предложений по шаблону и сиду генерации

https://codepen.io/procoders000001/pen/QwLmZaK

Seed: 1, Random number: 0.13436424411240122

Seed: 2, Random number: 0.9560342718892494

Seed: 3, Random number: 0.9478274872513002

Seed: 4, Random number: 0.7323522922883514

Seed: 5, Random number: 0.417022004702574

Seed: 6, Random number: 0.7203244934421581

Seed: 7, Random number: 0.00011437481734488664

Seed: 8, Random number: 0.3023325726318398

Seed: 9, Random number: 0.14611920292230097

Seed: 10, Random number: 0.9202604022500913

>>49946
чел не в теме плез, мною тему изучена можно сжимать файлы в 500 раз но пока что алгоритм жрёт 1 мин на 1 мб.

> к генератору случайных чисел - прохождение теста на следующий бит.

Все текущие генераторы чисел, это умножение времени в секундах и миллисекундах на само себя. те все тесты будут пройдены.

У меня начальные навыки кодинга ИИ не может закончить код
Что сделал Слоот,
1) он взломал функцию генерации хешей,
2) с помощью этих хешей создал рекурсивную таблицу хешей
3) эти хеши он сапоставил с бинарным кодом ведь у 4 бит всего 16 комбинаций для всех комбинаций можно сделать рекурсивный хеш.

У лота фильмы хранились на чипе вз-лом-ан-ной бан-ковс-кой кар-т-е, те перепрошитой на генерацию бинарного кода из общей таблицы

вот код,

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

DATA_FILE = "data.json"

# Функция для преобразования ключей словаря из кортежей в строки
def dict_tuple_to_str(dictionaries):
new_dictionaries = []
for dictionary in dictionaries:
new_dict = {}
for key, value in dictionary.items():
new_dict[str(key)] = value # Преобразуем кортеж в строку
new_dictionaries.append(new_dict)
return new_dictionaries

# Функция для преобразования ключей словаря из строк обратно в кортежи
def dict_str_to_tuple(dictionaries):
new_dictionaries = []
for dictionary in dictionaries:
new_dict = {}
for key, value in dictionary.items():
tuple_key = eval(key) # Преобразуем строку обратно в кортеж
new_dict[tuple_key] = value
new_dictionaries.append(new_dict)
return new_dictionaries

# Функция для сохранения данных в файл
def save_data_file(data):
data["dictionary"] = dict_tuple_to_str(data["dictionary"]) # Преобразуем кортежи в строки
with open(DATA_FILE, 'w') as f:
json.dump(data, f, indent=4)

# Функция для загрузки данных из файла
def load_data_file():
if os.path.exists(DATA_FILE):
with open(DATA_FILE, 'r') as f:
data = json.load(f)
data["dictionary"] = dict_str_to_tuple(data["dictionary"]) # Преобразуем строки обратно в кортежи
return data
else:
# Инициализация пустого словаря
return {"dictionary": [{}], "files": {}}

# Функция для разбиения данных на 2-битные блоки
def split_into_2bit_blocks(data):
blocks = []
for byte in data:
blocks.append((byte >> 6) & 0x3) # Старшие 2 бита
blocks.append((byte >> 4) & 0x3) # Средние 2 бита
blocks.append((byte >> 2) & 0x3) # Младшие 2 бита
blocks.append(byte & 0x3) # Самые младшие 2 бита
return blocks

# Функция для преобразования 2-битных блоков обратно в байты
def combine_from_2bit_blocks(blocks):
data = []
for i in range(0, len(blocks), 4):
byte = (blocks << 6) | (blocks[i + 1] << 4) | (blocks[i + 2] << 2) | blocks[i + 3]
data.append(byte)
return data

# Функция для сжатия данных с помощью древовидной структуры до 40 уровней
def compress(data, dictionary, cache):
compressed_data = []
current_data = split_into_2bit_blocks(data)

for level in range(40): # Ограничиваем количество уровней до 40
# Динамическое добавление новых уровней при необходимости
if level >= len(dictionary):
dictionary.append({})

if level in cache and tuple(current_data) in cache[level]:
new_data = cache[level][tuple(current_data)]
else:
new_data = []
for i in range(0, len(current_data), 2):
pair = tuple(current_data[i:i + 2])
if pair not in dictionary[level]:
dictionary[level][pair] = len(dictionary[level])
new_data.append(dictionary[level][pair])

if level not in cache:
cache[level] = {}
cache[level][tuple(current_data)] = new_data

compressed_data.append(new_data)
current_data = new_data

# Если все данные сжались до одного состояния или достигли максимального уровня
if len(new_data) == 1 or len(set(new_data)) == len(current_data):
break

return compressed_data

# Функция для распаковки данных
def decompress(compressed_data, dictionary, cache):
level = len(compressed_data) - 1
data = compressed_data[-1]

while level >= 0:
if level in cache:
reverse_cache = {v: k for k, v in cache[level].items()}
else:
reverse_cache = {v: k for k, v in dictionary[level].items()}

new_data = []
for value in data:
if value in reverse_cache:
new_data.extend(list(reverse_cache[value]))

data = new_data
level -= 1

return combine_from_2bit_blocks(data)

# Класс FileManager для управления файлами
class FileManager:
def __init__(self, root):
self.root = root
self.root.title("File Manager")

self.data = load_data_file() # Загрузить данные из файла
self.dictionary = self.data["dictionary"]
self.cache = {}

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

self.load_button = tk.Button(self.root, text="Load File", command=self.load_file)
self.load_button.pack(side=tk.LEFT)

self.unload_button = tk.Button(self.root, text="Unload File", command=self.unload_file)
self.unload_button.pack(side=tk.RIGHT)

self.update_file_list()

def update_file_list(self):
self.file_listbox.delete(0, tk.END)
for filename in self.data["files"]:
self.file_listbox.insert(tk.END, filename)

def load_file(self):
file_path = filedialog.askopenfilename()
if file_path:
with open(file_path, 'rb') as f:
binary_data = list(f.read()) # Прочитать файл как бинарные данные
compressed_data = compress(binary_data, self.dictionary, self.cache)
self.data["files"][os.path.basename(file_path)] = compressed_data
save_data_file(self.data) # Сохранить обновленные данные
self.update_file_list()

def unload_file(self):
selected_file = self.file_listbox.get(tk.ACTIVE)
if selected_file:
compressed_data = self.data["files"].get(selected_file)
if compressed_data:
decompressed_data = decompress(compressed_data, self.dictionary, self.cache)
save_path = filedialog.asksaveasfilename(defaultextension=".bin", initialfile=selected_file)
if save_path:
with open(save_path, 'wb') as f:
f.write(bytearray(decompressed_data))
else:
messagebox.showerror("Error", "File not found in data.")
else:
messagebox.showwarning("Warning", "No file selected.")

# Запуск приложения
if __name__ == "__main__":
root = tk.Tk()
file_manager = FileManager(root)
root.mainloop()

>>00744 (OP)

> Особенность - там не существовало закладок и бекдоров. Причем как на аппаратно-связном, так и на программном уровне.

- Брехня. Как и то что, он сам бы гарантрпованно не вставлял... (Не говоря уже про неизбежные баги). И что он лично бы делал миллионы платы? А, удавка патентной мафии?...
Но, даже если бы не это у этой идеи ещё столько подводных камней что, не счесть. Человек ранее работавший в этой экосистеме - как никто другой должен был бы знать (и потому не заниматься ерундистикой, т.б.планируя якоы выпускать такое), т.о. не было этого случая реально. Скорей OP троллит, уже просто "высасывая из пальца" истории типично тут отвлекая от зог ситуации в РФ. Но, если и не он лично высасывае(что не противоречит что, отвлекая) это не значит что нет других желающих ровно того же - в любой другой стране.

>>15824

>> P.S. Для тех кто не в теме вопроса - без разницы как шифровать передаваемые данные, если устройство создания данных (например смартфон) имеет доступ к расшифрованной информации.

> Поэтому в рашке шифруют в ручную на бумажке ...

А, [амерские/рфянские] сатанисты (да и уже и квантовыйе компьютеры не для того ли изобретенны) потом прямо из мозга считывают - и ржут с наивных шифрователей, лишь подыгрывая симуляцией незнанния планов.
С каждым годом ситуация всё плачевней, только открытая война может что то исправить, потому что квантовые компьютеры да ещё и с ИИ настроенные, сатанистски же и прост оработая на тех, это серьёзный дисбаланс сил, уже только почему человечество полностью или нет но, будет выпиленно если не светлыми ситлами то междоусобицей тёмных что и видим и это неизбежно, такова природа. Т.б.всё давно предсказанно сверхавторитетами (зачищается тут, как будто это что то изменит... хоть возможно с целью своими лжепророками тут и их несбывающимися "пророчествами" - пытаясь дискредитировать первых). Но, да как жаль что как обычно все хороше испольуется для злых целей, хоть по сути оно и создавалось реально именно для них. :(
По сути то даже и не создавалось а, по подсказе было созданно (интересующиеся в этом могут убидиться в этом вникнув в историю изобретения, но не от сатанистов же, я как то даже расписывал на примере ключевых первых из учёных, с их сранительно с совренными - очень простыми изобретениями), а уж как там эти нано и пикометры в чипах клепают да ещё многослойной - ну это просто фантастика же, без чернокнижия такая точность(уровня размера молекул) невозможно просто-технике. А, скептиков - отсылаю самим сделать такой хоть один станок лично, никакие $миллиарды не помогут.

>>50338
Ну тогда смотри сам. но спешу предупедить, что любой продвинутый метод превращает любого человека в -ж-и-д-а. хотя, могли бы жить в цифровой сингулярности

Это полностью рабочая программа

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

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

ALPHABET = (
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
'abcdefghijklmnopqrstuvwxyz'
'0123456789'
'一丁七万丈三上下不与丑专且世丘丙业丛东丝丞丢两严並丧丨'
'अआइईउऊऋएऐओऔकखगघङचछजझञटठडढणतथदधनपफबभमयरлвшищзжзийклмнопрстуфхцчшщъыьэюяєіїґ' # Added more cyrillic letters just in case
)
ALPHABET = ''.join(sorted(set(ALPHABET)))

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

def dict_tuple_to_str(dictionaries):
return [{str(k): v for k, v in d.items()} for d in dictionaries]

def dict_str_to_tuple(dictionaries):
return [{eval(k): v for k, v in d.items()} for d in dictionaries]

def save_data_file(data):
try:
data["dictionary"] = dict_tuple_to_str(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 file: {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"] = dict_str_to_tuple(data["dictionary"])
return data
except Exception as e:
messagebox.showerror("Error", f"Error loading data file: {str(e)}")
return {"dictionary": [{} for _ in range(4)], "files": []}
return {"dictionary": [{} for _ in range(4)], "files": []}

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

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

def compress(data, dictionary):
current_data = split_into_2bit_blocks(data)

for level in range(4):
print(f"Compression Level: {level}") # Debug print
new_data = []
print(f" Dictionary Level {level} before compression: {dictionary[level]}") # Debug print
for i in range(0, len(current_data), 2):
pair = tuple(current_data[i:i+2])
if pair not in dictionary[level]:
hash_code = int_to_hash(len(dictionary[level]))
dictionary[level][pair] = hash_code
print(f" Level {level}: Added to dictionary: Pair {pair} -> Hash {hash_code}") # Debug print
else:
print(f" Level {level}: Pair {pair} already in dictionary, Hash: {dictionary[level][pair]}") # Debug print
new_data.append(dictionary[level][pair])
current_data = new_data
print(f" Level {level} Compressed Data: {current_data}") # Debug print

if len(new_data) <= 1: # Modified condition to exit when data is compressed to single or zero hash
break

return ''.join(current_data)

def decompress(compressed_str, dictionary):
try:
current_data = [compressed_str[i:i+4] for i in range(0, len(compressed_str), 4)] # Изменено на 4 для чтения 4-значных хешей
except Exception as e:
messagebox.showerror("Error", f"Error during initial string split: {str(e)}")
return [] # Return empty data on error

print(f"Decompressed String Chunks (initial): {current_data}") # Debug print

for level in reversed(range(4)):
print(f"Decompression Level: {level}") # Debug print
reverse_dict = {v: k for k, v in dictionary[level].items()}
print(f" Reverse Dictionary Level {level}: {reverse_dict}") # Debug print
new_data = []
for hash_code in current_data:
print(f" Level {level}: Processing Hash Code: '{hash_code}'") # Debug print
if hash_code in reverse_dict:
original_pair = reverse_dict[hash_code]
new_data.extend(original_pair)
print(f" Level {level}: Hash '{hash_code}' found, Original Pair: {original_pair}") # Debug print
else:
# Handle case where hash_code is not in dictionary (for robustness)
# In a perfect scenario this should not happen if compression/decompression use the same dictionary
# However, for error handling, you might want to consider how to proceed.
# For now, we'll assume it's an error and might raise an exception or log a warning.
print(f"Warning: Hash code '{hash_code}' not found in level {level} dictionary. Data might be corrupted.")
new_data.extend([0, 0]) # Placeholder in case of missing hash, you may need more sophisticated error handling
current_data = new_data
print(f" Level {level} Decompressed Data: {current_data}") # Debug print

return combine_from_2bit_blocks(current_data)

class FileManager:
def __init__(self, root):
self.root = root
self.root.title("4-Level Compressor")
self.data = load_data_file()
self.dictionary = self.data["dictionary"]
print("Loaded Dictionary on Startup:", self.dictionary) # Debug print on startup

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

btn_frame = tk.Frame(self.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 fname in self.data["files"]:
self.listbox.insert(tk.END, fname)

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

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

compressed_str = compress(data, self.dictionary)
output_name = os.path.basename(path) + COMPRESSED_EXT

try:
with open(output_name, 'w', encoding='utf-8') as f:
f.write(compressed_str)
except Exception as e:
messagebox.showerror("Error", f"Error writing compressed file: {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()
print("Dictionary after compression:", self.dictionary) # Debug print after compression

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"Error reading compressed file: {str(e)}")
return

print("Compressed String read from file:", compressed_str) # Debug print compressed string before decompression
print("Dictionary before decompression:", self.dictionary) # Debug print dictionary before decompression

try:
decompressed = decompress(compressed_str, self.dictionary)
if decompressed: #Check for empty data to avoid errors
with open(save_path, 'wb') as f:
f.write(bytes(decompressed))
messagebox.showinfo("Success", "Decompression successful!") # Added success message
else:
messagebox.showerror("Error", "Decompression failed.") # Display error if decompress returns empty
except Exception as e:
messagebox.showerror("Error", f"Decompression failed: {str(e)}")

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

>>50483
Конечно, давайте разберем код и ответим на ваши вопросы о комбинациях и размере словаря на каждом уровне.

Анализ словаря и уровней сжатия

Программа использует 4-уровневое сжатие, основанное на словаре пар 2-битных блоков. Давайте рассмотрим каждый уровень:

Уровень 0:

Комбинации: На вход первого уровня подаются 2-битные блоки. Всего существует 4 возможных 2-битных блока (00, 01, 10, 11, или 0, 1, 2, 3 в десятичном виде). На этом уровне словарь формируется из пар этих 2-битных блоков. Теоретически, количество возможных пар 2-битных блоков равно 4 4 = 16. Это максимальное количество уникальных пар, которые могут быть добавлены в словарь нулевого уровня.

Размер словаря: Словарь на каждом уровне (dictionaries[level]) представляет собой список пар. В худшем случае, на нулевом уровне словарь может содержать до 16 пар. Каждая пара состоит из двух 2-битных чисел (фактически, целых чисел от 0 до 3). Размер одной пары в памяти Python очень мал (несколько байт). Даже если грубо оценить, что каждая пара занимает, скажем, 16 байт (учитывая накладные расходы Python на списки и объекты), то максимальный размер словаря нулевого уровня будет около 16 пар 16 байт/пара = 256 байт. Это очень мало, меньше 1 КБ.

Уровень 1:

Комбинации: На вход второго уровня подаются коды из словаря первого уровня. В худшем случае, словарь первого уровня мог содержать до 16 кодов. На втором уровне словарь формируется из пар этих кодов. Теоретически, количество возможных пар кодов из первого уровня равно 16 16 = 256. Это максимальное количество уникальных пар, которые могут быть добавлены в словарь первого уровня.

Размер словаря: В худшем случае, словарь первого уровня может содержать до 256 пар. Теперь пара состоит из двух кодов (индексов в словаре предыдущего уровня). Эти коды, вероятно, будут представлены как целые числа. Если предположить, что каждая пара кодов также занимает около 16 байт, то максимальный размер словаря первого уровня будет около 256 пар 16 байт/пара = 4096 байт = 4 КБ.

Уровень 2:

Комбинации: На вход третьего уровня подаются коды из словаря второго уровня. В худшем случае, словарь второго уровня мог содержать до 256 кодов. На третьем уровне словарь формируется из пар этих кодов. Теоретически, количество возможных пар кодов из второго уровня равно 256 256 = 65536. Это максимальное количество уникальных пар, которые могут быть добавлены в словарь второго уровня.

Размер словаря: В худшем случае, словарь второго уровня может содержать до 65536 пар. Если каждая пара кодов по-прежнему занимает около 16 байт, то максимальный размер словаря второго уровня будет около 65536 пар 16 байт/пара = 1048576 байт = 1 МБ.

Уровень 3:

Комбинации: На вход четвертого уровня подаются коды из словаря третьего уровня. В худшем случае, словарь третьего уровня мог содержать до 65536 кодов. На четвертом уровне словарь формируется из пар этих кодов. Теоретически, количество возможных пар кодов из третьего уровня равно 65536 65536 = 4 294 967 296. Это огромное число, но маловероятно, что словарь достигнет такого размера на практике, поскольку сжатие должно значительно уменьшить количество уникальных пар на более высоких уровнях.

Размер словаря: В худшем случае, словарь третьего уровня мог бы содержать до 4 294 967 296 пар. Если каждая пара кодов занимает 16 байт, то максимальный размер словаря третьего уровня был бы около 4 294 967 296 пар 16 байт/пара = 68 719 476 736 байт = 64 ГБ. Это очень много, и практически невозможно, чтобы словарь достиг такого размера в реальном сценарии сжатия. Такой словарь не поместится в оперативную память большинства компьютеров.

Сводная таблица (худший случай)

Уровень Максимальное количество комбинаций пар Оценка максимального размера словаря
0 16 ~ 256 байт
1 256 ~ 4 КБ
2 65 536 ~ 1 МБ
3 4 294 967 296 ~ 64 ГБ (теоретический максимум, нереалистично)

>>51787
Переписать данный код на чистом C++ требует значительных изменений, так как C++ не имеет встроенных библиотек для работы с графическим интерфейсом, сериализацией данных и т.д., как это делает Python. Однако, я предоставлю вам пример, который включает основные функции, такие как сжатие и распаковка данных, а также базовую структуру для работы с файлами. Для графического интерфейса можно использовать библиотеку, такую как Qt или wxWidgets, но в этом примере я сосредоточусь на логике сжатия и распаковки.

#include <iostream>
#include <fstream>
#include <vector>
#include <unordered_map>
#include <string>
#include <algorithm>
#include <stdexcept>

const std::string DATA_FILE = "data.dat";
const std::string COMPRESSED_EXT = ".ctxt";

const std::string ALPHABET =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789"
"一丁七万丈三上下不与丑专且世丘丙业丛东丝丞丢两严並丧丨"
"अआइईउऊऋएऐओऔकखगघङचछजझञटठडढणतथदधनपफबभमयरлвшищзжзийклмнопрстуфхцчшщъыьэюяєіїґ";

std::string int_to_hash(int n, int length = 4) {
std::string hash_str;
int base = ALPHABET.size();
for (int i = 0; i < length; ++i) {
hash_str += ALPHABET[n % base];
n /= base;
}
std::reverse(hash_str.begin(), hash_str.end());
return hash_str;
}

std::vector<uint8_t> compress(const std::vector<uint8_t>& data, std::unordered_map<std::string, std::string>& dictionary) {
std::vector<std::string> current_data;
for (auto byte : data) {
current_data.push_back(std::string(1, ALPHABET[byte]));
}

for (int level = 0; level < 2; ++level) {
std::vector<std::string> new_data;
for (size_t i = 0; i < current_data.size(); i += 2) {
std::string pair = current_data;
if (i + 1 < current_data.size()) {
pair += current_data[i + 1];
}
if (dictionary.find(pair) == dictionary.end()) {
std::string hash_code = int_to_hash(dictionary.size());
dictionary[pair] = hash_code;
}
new_data.push_back(dictionary[pair]);
}
current_data = new_data;
if (current_data.size() <= 1) {
break;
}
}

std::string compressed_str = std::accumulate(current_data.begin(), current_data.end(), std::string());
std::vector<uint8_t> byte_data;
for (char c : compressed_str) {
auto pos = ALPHABET.find(c);
if (pos == std::string::npos) {
throw std::runtime_error("Symbol not found in ALPHABET");
}
byte_data.push_back(static_cast<uint8_t>(pos));
}
return byte_data;
}

std::vector<uint8_t> decompress(const std::vector<uint8_t>& compressed_data, const std::unordered_map<std::string, std::string>& dictionary) {
std::string compressed_str;
for (auto byte : compressed_data) {
compressed_str += ALPHABET[byte];
}

std::vector<std::string> current_data;
for (size_t i = 0; i < compressed_str.size(); i += 4) {
current_data.push_back(compressed_str.substr(i, 4));
}

for (int level = 1; level >= 0; --level) {
std::unordered_map<std::string, std::string> reverse_dict;
for (const auto& pair : dictionary) {
reverse_dict[pair.second] = pair.first;
}
std::vector<uint8_t> new_data;
for (const auto& hash_code : current_data) {
if (reverse_dict.find(hash_code) != reverse_dict.end()) {
const std::string& pair = reverse_dict[hash_code];
for (char c : pair) {
new_data.push_back(static_cast<uint8_t>(ALPHABET.find(c)));
}
} else {
new_data.push_back(0);
new_data.push_back(0);
}
}
current_data.clear();
for (size_t i = 0; i < new_data.size(); ++i) {
current_data.push_back(std::string(1, ALPHABET[new_data]));
}
}

return current_data; // Возвращаем байты
}

void save_data_file(const std::unordered_map<std::string, std::string>& dictionary) {
std::ofstream ofs(DATA_FILE, std::ios::binary);
if (!ofs) {
throw std::runtime_error("Error saving data file");
}
// Сохранение словаря в файл (можно использовать сериализацию)
for (const auto& pair : dictionary) {
ofs << pair.first << ":" << pair.second << "\n";
}
}

std::unordered_map<std::string, std::string> load_data_file() {
std::unordered_map<std::string, std::string> dictionary;
std::ifstream ifs(DATA_FILE, std::ios::binary);
if (!ifs) {
return dictionary; // Возвращаем пустой словарь, если файл не найден
}
std::string line;
while (std::getline(ifs, line)) {
auto pos = line.find(':');
if (pos != std::string::npos) {
dictionary[line.substr(0, pos)] = line.substr(pos + 1);
}
}
return dictionary;
}

int main() {
std::unordered_map<std::string, std::string> dictionary = load_data_file();

// Пример использования
std::vector<uint8_t> data = {65, 66, 67}; // Пример данных для сжатия
auto compressed_data = compress(data, dictionary);
save_data_file(dictionary);

auto decompressed_data = decompress(compressed_data, dictionary);
for (auto byte : decompressed_data) {
std::cout << byte << " ";
}
std::cout << std::endl;

return 0;
}

Объяснение кода:

Сжатие и распаковка: Функции compress и decompress реализуют логику сжатия и распаковки данных, аналогично тому, как это сделано в Python.
Словарь: Используется std::unordered_map для хранения словаря, который сопоставляет пары символов с их хешами.
Сохранение и загрузка данных: Функции save_data_file и load_data_file реализуют простую сериализацию словаря в текстовом формате.
Основная функция: В main показан пример использования сжатия и распаковки данных.

Примечание:

Для полноценного графического интерфейса вам нужно будет использовать библиотеку, такую как Qt или wxWidgets, и адаптировать код для работы с GUI.

>>51919

> %высер% вс умные ЛЮДИ ДАвНО ПОНЯЛИ.

ДАВНо ПОНЯЛИ - И ПОСЛАЛИ тебя... даже на обоих твоих форумах.
Это я с тобой тут вожусь ещё, из принципа: с паршивой овцы/алгоритма - хоть клочок(даже если ничего не получится глядишь убеждусь лично почему ну и значит ориг.алгоритм был фейк). Но, пока у тебя только высеры...
(даже о тестах не слышно, не говоря о чём то более относящемся к оригинальной идее сжатия, которая сама по себе как я понял только предполагаема)

>>52005
С++ без компилябельности... С stlбиблиотеками... а, уже это токльо к сожалению не приемлемый мне Си dzen-way для поиграться(т.б.такими компиляторами не пользуюсь; да забыл уточнить) (не поверишь: в прямом смысле рыгать охота от С++ STL и подобного шлака в С++ - не меньше чем от засилия мозговыноса закорючек питона и пёрла, впрочем эти больше как VM лагеры, меня человека привыкшего оптимизировать на коммандном и микркомандном уровне... (в ч.н.больше для проекта компилятора). А, вот STL не только из-за этого - а и как псевдо Си синтаксиса. Да и от всего что выше С++ 89-93 тоже, я их даже не смотрел особо и компиляторами их не пользуюсь вовсе - настолько это чужеродный плохо вписывающийся кал - а, не Си/С++ и т.б проитворечащий dzen идеалогии Сей как HLA до которой оно и так еле дотягивает, потому и продумываю Си пододящий компилятор получше уже не первый год в кач.хобби).
Впрочем, чуть позже как освобожусь теоретично-повникаю в этот исходник предоставленный но, ещё никак до статей не дойду из-за нехватки времени, т.б.хочу ещё раз фору мы этоот и те перечитать.
Вообще, это правда что генерируешь - в C.GPT4 ? или в каком то ином (а то этот даже текст мне ниразу нормально не смог корректно сформатировать переводя...), а прочие я не приемлю хоть вчера нашол online ~форк той же моделидаже несколько на сайте - вроде адекватней но, тоже фантазёро-брехло на ровном месте, обычно неожиданном.
2) через чатпрямо на Web-сайте? Или какой то IDE с ИИ?
3) вручную доправляешь исходники?
4) твой питон код сам вообще у тебя работает?
5) чтобы тебя не дёргать тут из-за моих забубонов напиши что ты ему говоришь дословно - я сам по мере обновлений у тебя буду ослылать обновляя ему [вместе с полным исходником на питоне] и уже сам буду мучать пытаясь сгенеерировать в более легко понятном мне стиле и в сколько оптимизиваронный вариант потому что когда я вижу что то вроде кода выше(на С++) я сразу понимаю что он - условно на порядок больше тормозить будет, чем мог бы; Т.е.не менее питона и раста, - даже без учёта прочих возможных оптимизаций вытекающих из отсутвующих оптимизаций).

>>52434
Этот код реализует приложение для сжатия и распаковки файлов, использующее многоуровневый словарный алгоритм сжатия. Приложение имеет графический интерфейс на Tkinter и использует SQLite для хранения словарей сжатия на диске. Давайте разберем код по частям:

1. Импорт библиотек:

os: для работы с операционной системой, например, для работы с файловой системой.

sqlite3: для работы с базой данных SQLite, которая используется для хранения словарей сжатия.

tkinter: для создания графического интерфейса пользователя (GUI).

logging: для ведения журнала работы приложения, записи ошибок и важных событий.

sys: для доступа к системным переменным и функциям, в частности для контроля размера объектов в памяти.

filedialog, messagebox из tkinter: для создания диалоговых окон выбора файлов и сообщений.

datetime из datetime: для получения текущей даты и времени для имени файла журнала.

defaultdict из collections: для создания словарей, которые автоматически инициализируют значение по умолчанию для отсутствующих ключей.

2. Константы:

DATA_FILE = "compression.db": Имя файла базы данных (фактически не используется в коде).

COMPRESSED_EXT = ".ctxt": Расширение, которое будет добавляться к имени сжатых файлов.

LOG_FORMAT = "%(asctime)s - %(levelname)s - %(message)s": Формат записей журнала.

DATE_FORMAT = "%Y-%m-%d %H:%M:%S": Формат даты и времени в журнале.

ALPHABET: Строка, содержащая все символы, которые будут использоваться для создания "хешей" (коротких строк-замен) в процессе сжатия. Включает латинские и кириллические буквы, цифры, а также некоторые китайские иероглифы. Обрезается до 256 символов.

3. setup_logger() функция:

Настраивает систему логирования для приложения.

Создает логгер с именем "CompressionApp".

Устанавливает уровень логирования на logging.DEBUG, то есть будут регистрироваться все сообщения, начиная с уровня DEBUG и выше.

Создает файловый обработчик (file_handler), который будет записывать логи в файл с именем, основанным на текущей дате и времени (compression_ГГГГММДД_ЧЧММСС.log). Файл журнала создается в кодировке utf-8.

Создает консольный обработчик (console_handler), который будет выводить логи в консоль.

Устанавливает форматтеры для обоих обработчиков, определяя, как будут выглядеть сообщения в журнале и консоли.

Добавляет оба обработчика к логгеру.

Возвращает настроенный логгер.

4. DiskDictionary класс:

Реализует словарь, который хранит пары ключ-значение на диске, используя базу данных SQLite. Это нужно для хранения словарей сжатия для каждого уровня.

__init__(self, level): Конструктор класса.

level: Уровень словаря (0, 1, 2, 3).

db_file: Имя файла базы данных для этого уровня (dict_level_{level}.db).

conn: Соединение с базой данных SQLite.

cache: Кэш в памяти (defaultdict(str)) для ускорения доступа к часто используемым парам.

cache_size: Максимальный размер кэша (100 000 элементов).

total_count: Общее количество записей в словаре (включая кэш и базу данных).

_init_db(): Вызывает метод для инициализации базы данных.

_init_db(self): Инициализирует базу данных SQLite.

Подключается к базе данных (self.db_file).

Создает таблицу pairs, если она не существует, с колонками:

key1 INTEGER NOT NULL: Первая часть ключа (целое число).

key2 INTEGER NOT NULL: Вторая часть ключа (целое число).

value TEXT PRIMARY KEY: Значение, соответствующее ключу (текст, используется как первичный ключ).

Фиксирует изменения в базе данных (self.conn.commit()).

Получает текущее количество записей из таблицы pairs и сохраняет в self.total_count.

__len__(self): Возвращает общее количество элементов в словаре (сумма записей в кэше и базе данных).

__getitem__(self, key): Получает значение по ключу.

Сначала проверяет, есть ли ключ в кэше (self.cache). Если есть, возвращает значение из кэша.

Если нет в кэше, выполняет SQL-запрос к базе данных для поиска значения по ключу (key[0], key[1]).

Возвращает найденное значение или None, если ключ не найден.

__setitem__(self, key, value): Устанавливает значение по ключу.

Проверяет, не превышен ли размер кэша (self.cache_size). Если превышен, вызывает _flush_cache() для сброса кэша в базу данных.

Добавляет пару ключ-значение в кэш (self.cache).

_flush_cache(self): Сбрасывает содержимое кэша в базу данных.

Если кэш пуст, ничего не делает.

Преобразует содержимое кэша в список кортежей для вставки в базу данных.

Выполняет SQL-запрос INSERT OR IGNORE для добавления новых пар в таблицу pairs. IGNORE предотвращает ошибки, если пара ключ-значение уже существует.

Фиксирует изменения в базе данных (self.conn.commit()).

Обновляет self.total_count.

Очищает кэш (self.cache.clear()).

close(self): Закрывает словарь.

Вызывает _flush_cache() для сохранения данных из кэша в базу данных перед закрытием.

Закрывает соединение с базой данных (self.conn.close()), если оно открыто.

5. int_to_hash(n, length=4) функция:

Преобразует целое число n в строку "хеш" заданной длины (length, по умолчанию 4 символа), используя ALPHABET.

Использует систему счисления с основанием, равным длине ALPHABET.

Делит число n на основание и берет остатки, чтобы получить индексы символов из ALPHABET.

Собирает символы в строку и возвращает ее.

6. split_into_2bit_blocks(data) функция:

Разбивает байтовые данные (data) на список 2-битных блоков.

Для каждого байта в данных извлекает 4 блока по 2 бита: биты 6-7, 4-5, 2-3, 0-1.

Возвращает список целых чисел, представляющих 2-битные блоки.

7. combine_from_2bit_blocks(blocks) функция:

Выполняет обратную операцию к split_into_2bit_blocks().

Собирает 2-битные блоки (blocks) обратно в байтовые данные.

Группирует блоки по 4 и объединяет их в байты.

Возвращает байтовые данные (bytes).

8. compress_file(input_path, dictionaries) функция:

Выполняет сжатие файла.

input_path: Путь к входному файлу.

dictionaries: Список из 4 объектов DiskDictionary, по одному для каждого уровня сжатия.

Читает содержимое входного файла в бинарном режиме ('rb').

Разбивает данные на 2-битные блоки с помощью split_into_2bit_blocks().

Проходит 4 уровня сжатия (цикл for level in range(4)).

На каждом уровне создает новый список данных (new_data).

Итерируется по текущим данным (current) парами (по 2 элемента).

Для каждой пары (или одиночного элемента, если нечетное количество):

Проверяет, есть ли эта пара в словаре текущего уровня (dictionaries[level]).

Если пара есть в словаре, использует соответствующий "хеш" (значение из словаря).

Если пары нет в словаре, создает новый "хеш" с помощью int_to_hash(len(dictionaries[level])), добавляет пару в словарь и использует этот новый "хеш".

Добавляет "хеш" в new_data.

Проверяет размер new_data в памяти, чтобы предотвратить переполнение памяти. Если размер приближается к лимиту (1.5 ГБ), выводит предупреждение и прерывает сжатие.

Заменяет current на new_data для следующего уровня.

Прерывает цикл, если длина current становится меньше или равна 1.

После всех уровней сжатия, объединяет "хеши" в строку, кодирует ее в UTF-8 и возвращает как сжатые данные (compressed).

9. decompress_file(input_path, dictionaries) функция:

Выполняет распаковку сжатого файла.

input_path: Путь к сжатому файлу.

dictionaries: Список из 4 объектов DiskDictionary.

Читает содержимое сжатого файла, декодируя его из UTF-8 ('rb', decode('utf-8')).

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

Проходит уровни распаковки в обратном порядке (от уровня 3 до 0, цикл for level in reversed(range(4))).

На каждом уровне создает новый список данных (new_data).

Итерируется по текущим данным (current), которые на этом этапе являются "хешами".

Для каждого "хеша" (code):

Ищет "хеш" в словаре текущего уровня (dictionaries[level]). Сначала ищет в кэше, затем в базе данных.

Если "хеш" найден, получает соответствующую пару 2-битных блоков (ключ из словаря) и добавляет ее в new_data.

Если "хеш" не найден, добавляет [0, 0] (значение по умолчанию) и регистрирует предупреждение.

.

Общее описание алгоритма сжатия:

Код реализует многоуровневое словарное сжатие. Исходные данные разбиваются на 2-битные блоки. На каждом уровне сжатия пары 2-битных блоков (или одиночные блоки) заменяются на короткие строковые "хеши". Словарь "пара блоков" -> "хеш" хранится в базе данных SQLite и кэшируется в памяти для ускорения. При распаковке происходит обратный процесс: "хеши" ищутся в словарях, и заменяются на соответствующие пары блоков. Использование нескольких уровней сжатия позволяет уменьшить размер данных за счет многократного применения словарной замены.

В заключение:

Этот код представляет собой рабочее приложение для сжатия и распаковки файлов. Он демонстрирует использование словарного сжатия, баз данных SQLite для хранения словарей, логирования и графического интерфейса на Tkinter. Приложение имеет 4 уровня сжатия, что позволяет достичь определенной степени сжатия, хотя эффективность алгоритма может варьироваться в зависимости от типа данных.