СОЗДАНА ПРОГРАММА ВЕЧНОГО СЖАТИЯ ИНФОРМАЦИИ БЕЗ ПОТЕРЬ.
Исходный код + программа на python
https://drive.google.com/file/d/1V6j4iDV0YeZXDTadlnpawXyUKgHgkfoW/view
64 ГБ СЛОВАРЯ ХВАТИТ ВСЕМ!
Шеннон доказал, что существует предел, до которого можно сжать данные без потерь. Этот предел определяется энтропией источника. В идеальных условиях, если данные имеют энтропию ( H ), то их можно сжать до размера, близкого к ( H ) бит на символ.
Но Шеннон не предполагал что можно создать словарь 4 уровня, где пары бинарного кода кодируются метками бинарного кода, а сами метки тоже бинарным кодом и так до 4 уровня.
Таким образом достигается вечное сжатие в рекурсии!
Вся информатика это бинарный код, все данные и программы. у 4 бит всего 16 комбинаций, если мы будем маркировать, и пары для пар в словаре ТО:
Уровень 0: 16 пар 8 байт/пара = 128 байт
Уровень 1: 256 пар 8 байт/пара = 2 КБ
Уровень 2: 65 536 пар 8 байт/пара = 512 КБ
Уровень 3: 4 294 967 296 пар 8 байт/пара = ~ 34 ГБ
34 гб описывают бесконечную рекурсию информации! Следовательно информацию и вычисления можно бесконечно сжимать и снова раскладывать без потерь!
Код создан с нуля ИИ, по подсказкам метода Яна Слоота.
Он работает медленно, любая попытка ИИ его улучить ломает код и работу программы
Что нужно сделать:
1) переписать на С++ или CUDA
2) переписать логику что бы не ел 34 ГБ RАМ постоянного словаря а ток с SSD
3) Добавить рекурсию после сжатия для нового сжатия
Принцип Работы, файл сжимается, размер его сохраняется но это теперь файл это ссылки на 34 гб словарь. Магия в том, что если поместить сжатый файл в ZIP и RAR то его размер в 10-20 раз МЕНЬШЕ ОРИГИНАЛА, И его можно восстановить из ОБЩЕГО СЛОВАРЯ. который постоянный 34 гб!
код и метод выложен на общее обозрение в Open source - вы можете редактировать и изменять его, но уважайте себя и научное сообщество, метод даёт возможным сингулярность и AGI
Получив бесконечные вычислительные мощности и память что будете делать с этим?
Исходный код + программа на python
https://drive.google.com/file/d/1V6j4iDV0YeZXDTadlnpawXyUKgHgkfoW/view
64 ГБ СЛОВАРЯ ХВАТИТ ВСЕМ!
Шеннон доказал, что существует предел, до которого можно сжать данные без потерь. Этот предел определяется энтропией источника. В идеальных условиях, если данные имеют энтропию ( H ), то их можно сжать до размера, близкого к ( H ) бит на символ.
Но Шеннон не предполагал что можно создать словарь 4 уровня, где пары бинарного кода кодируются метками бинарного кода, а сами метки тоже бинарным кодом и так до 4 уровня.
Таким образом достигается вечное сжатие в рекурсии!
Вся информатика это бинарный код, все данные и программы. у 4 бит всего 16 комбинаций, если мы будем маркировать, и пары для пар в словаре ТО:
Уровень 0: 16 пар 8 байт/пара = 128 байт
Уровень 1: 256 пар 8 байт/пара = 2 КБ
Уровень 2: 65 536 пар 8 байт/пара = 512 КБ
Уровень 3: 4 294 967 296 пар 8 байт/пара = ~ 34 ГБ
34 гб описывают бесконечную рекурсию информации! Следовательно информацию и вычисления можно бесконечно сжимать и снова раскладывать без потерь!
Код создан с нуля ИИ, по подсказкам метода Яна Слоота.
Он работает медленно, любая попытка ИИ его улучить ломает код и работу программы
Что нужно сделать:
1) переписать на С++ или CUDA
2) переписать логику что бы не ел 34 ГБ RАМ постоянного словаря а ток с SSD
3) Добавить рекурсию после сжатия для нового сжатия
Принцип Работы, файл сжимается, размер его сохраняется но это теперь файл это ссылки на 34 гб словарь. Магия в том, что если поместить сжатый файл в ZIP и RAR то его размер в 10-20 раз МЕНЬШЕ ОРИГИНАЛА, И его можно восстановить из ОБЩЕГО СЛОВАРЯ. который постоянный 34 гб!
код и метод выложен на общее обозрение в Open source - вы можете редактировать и изменять его, но уважайте себя и научное сообщество, метод даёт возможным сингулярность и AGI
Получив бесконечные вычислительные мощности и память что будете делать с этим?
В ходе полных тестов, удалось узнать что полный словарь всех комбинаций всех уровней составляет 900 гб. ( в сжатой папке 300гб)
Код был запущен в облаке гугла, где было 300 гб RAM файлы сжимались и расжимались рекурсивно в 100- и 200 раз. те 1 гб в 1 мб. без потерь,
Код создан с нуля ИИ, по подсказкам метода Яна Слоота.
Он работает медленно, любая попытка ИИ его улучить ломает код и работу программы
Что нужно сделать:
1) переписать на С++ или CUDA
2) переписать логику что бы не ел 34 ГБ RАМ постоянного словаря а ток с SSD
3) Добавить рекурсию после сжатия для нового сжатия
Код был запущен в облаке гугла, где было 300 гб RAM файлы сжимались и расжимались рекурсивно в 100- и 200 раз. те 1 гб в 1 мб. без потерь,
Код создан с нуля ИИ, по подсказкам метода Яна Слоота.
Он работает медленно, любая попытка ИИ его улучить ломает код и работу программы
Что нужно сделать:
1) переписать на С++ или CUDA
2) переписать логику что бы не ел 34 ГБ RАМ постоянного словаря а ток с SSD
3) Добавить рекурсию после сжатия для нового сжатия
Код колаба питона.
import os
import pickle
import time
import psutil
import sys
from google.colab import files
# Константы
DATA_FILE = "data.pickle"
COMPRESSED_EXT = ".ctxt"
GENERATED_DIR = "generated_files"
# Алфавит для хешей
ALPHABET = (
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
'abcdefghijklmnopqrstuvwxyz'
'0123456789'
'一丁七万丈三上下不与丑专且世丘丙业丛东丝丞丢两严並丧丨'
'अआइईउऊऋएऐओऔकखगघङचछजझञटठडढणतथदधनपफबभमयरलवशसह़ािीुूृॅेैॉोौ्ॐक़ख़ग़ज़ड़ढ़फ़य़'
)
ALPHABET = ''.join(sorted(set(ALPHABET)))[:256]
def int_to_hash(n, length=5):
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 print_progress(level, current, total, start_time):
elapsed = time.time() - start_time
memory = psutil.Process(os.getpid()).memory_info().rss / (10243)
percent = (current / total) 100
print(f"Level {level} | Pairs: {current}/{total} ({percent:.2f}%) | "
f"Memory: {memory:.2f} GB | Time: {elapsed:.1f}s")
def generate_level(dictionary, level, hashes):
total = len(hashes)2
start = time.time()
last_print = start
print(f"\n[Level {level}] Generating {total} pairs...")
for i, h1 in enumerate(hashes):
for j, h2 in enumerate(hashes):
pair = (h1, h2)
if pair not in dictionary[level]:
hash_code = int_to_hash(len(dictionary[level]))
dictionary[level][pair] = hash_code
if time.time() - last_print >= 1:
current = i len(hashes) + j + 1
print_progress(level, current, total, start)
last_print = time.time()
print(f"[Level {level}] Completed in {time.time()-start:.1f}s")
return dictionary
def generate_pairs(dictionary):
print("\n=== Generating pairs for levels 2 and 3 ===")
level1_hashes = list(dictionary[1].values())
dictionary = generate_level(dictionary, 2, level1_hashes)
level2_hashes = list(dictionary[2].values())
dictionary = generate_level(dictionary, 3, level2_hashes)
return dictionary
def initialize_dictionary():
print("Initializing dictionaries...")
dictionary = [{} for _ in range(4)]
for i in range(4):
for j in range(4):
pair = (i, j)
dictionary[0][pair] = int_to_hash(len(dictionary[0]))
level0_hashes = list(dictionary[0].values())
dictionary = generate_level(dictionary, 1, level0_hashes)
return dictionary
def load_data():
if os.path.exists(DATA_FILE) and os.path.getsize(DATA_FILE) > 0:
try:
with open(DATA_FILE, 'rb') as f:
return pickle.load(f)
except (EOFError, pickle.UnpicklingError):
print("Warning: Data file is corrupted. Creating a new one.")
data = {"dictionary": initialize_dictionary(), "files": []}
with open(DATA_FILE, 'wb') as f:
pickle.dump(data, f)
return data
else:
print("Creating a new data file.")
data = {"dictionary": initialize_dictionary(), "files": []}
with open(DATA_FILE, 'wb') as f:
pickle.dump(data, f)
return data
def split_into_2bit_blocks(data):
blocks = []
for byte in data:
blocks.extend([(byte >> shift) & 0x3 for shift in [6, 4, 2, 0]])
while len(blocks) % 2 != 0:
blocks.append(0)
return blocks
def combine_from_2bit_blocks(blocks):
data = []
for i in range(0, len(blocks), 4):
byte = sum([blocks[i+j] << (6-2j) for j in range(4)])
data.append(byte)
return bytes(data)
def compress(data, dictionary):
current = split_into_2bit_blocks(data)
for level in range(4):
current = [dictionary[level].get(tuple(current[i:i+2]), current[i:i+2])
for i in range(0, len(current), 2)]
return ''.join(current).encode('utf-8')
def compress_with_stats(data, dictionary, update_dict=False):
current = split_into_2bit_blocks(data)
stats = {'repeated': 0, 'new': 0}
for level in range(4):
new_current = []
for i in range(0, len(current), 2):
pair = tuple(current[i:i+2])
if pair in dictionary[level]:
new_current.append(dictionary[level][pair])
stats['repeated'] += 1
else:
if update_dict:
hash_code = int_to_hash(len(dictionary[level]))
dictionary[level][pair] = hash_code
new_current.append(hash_code)
stats['new'] += 1
else:
new_current.extend(pair)
current = new_current
return ''.join(current).encode('utf-8'), stats
def decompress(compressed_data, dictionary):
current = list(compressed_data.decode('utf-8'))
for level in reversed(range(4)):
current = [item for code in current
for item in dictionary[level].get(code, [0,0])]
return combine_from_2bit_blocks(current)
def get_dictionary_size(dictionary):
return sys.getsizeof(pickle.dumps(dictionary)) / (1024 3)
def generate_and_compress_continuously(data):
os.makedirs(GENERATED_DIR, exist_ok=True)
total_saved = 0
total_original = 0
total_compressed = 0
repeated_pairs = 0
new_pairs_added = 0
start_time = last_stat_time = time.time()
try:
while True:
original_data = os.urandom(1024 1024)
original_size = len(original_data)
original_filename = os.path.join(GENERATED_DIR, f"original_{time.time()}.txt")
with open(original_filename, 'wb') as f:
f.write(original_data)
compressed_data, stats = compress_with_stats(original_data, data['dictionary'], update_dict=True)
compressed_size = len(compressed_data)
compressed_filename = os.path.join(GENERATED_DIR, f"compressed_{time.time()}{COMPRESSED_EXT}")
with open(compressed_filename, 'wb') as f:
f.write(compressed_data)
total_original += original_size
total_compressed += compressed_size
total_saved += (original_size - compressed_size)
repeated_pairs += stats['repeated']
new_pairs_added += stats['new']
if time.time() - last_stat_time >= 1:
saved_gb = total_saved / (1024 3)
saved_percent = (total_saved / total_original) 100 if total_original else 0
dict_size_gb = get_dictionary_size(data['dictionary'])
level2_size = len(data['dictionary'][2])
max_level3 = level2_size 2
current_level3 = len(data['dictionary'][3])
level3_percent = (current_level3 / max_level3) 100 if max_level3 else 0
print(f"Saved: {saved_gb:.2f} GB ({saved_percent:.2f}%) | "
f"Repeated pairs: {repeated_pairs} | New pairs: {new_pairs_added} | "
f"Dict size: {dict_size_gb:.2f} GB | "
f"Level 3 pairs: {current_level3}/{max_level3} ({level3_percent:.2f}%)")
last_stat_time = time.time()
level2_size = len(data['dictionary'][2])
max_level3 = level2_size 2
current_level3 = len(data['dictionary'][3])
if current_level3 >= max_level3:
print("Level 3 dictionary filled. Stopping.")
break
with open(DATA_FILE, 'wb') as f:
pickle.dump(data, f)
except KeyboardInterrupt:
print("\nProcess stopped by user.")
finally:
with open(DATA_FILE, 'wb') as f:
pickle.dump(data, f)
print(f"Total saved space: {total_saved / (10243):.2f} GB")
def main_menu():
data = load_data()
while True:
print("\n=== Main Menu ===")
print("1. Compress file")
print("2. Decompress file")
print("3. Show dictionary stats")
print("4. Generate all pairs (Levels 2-3)")
print("5. Exit")
print("6. Generate and compress binary files continuously")
choice = input("Select action: ")
if choice == '1':
uploaded = files.upload()
if not uploaded: continue
filename = next(iter(uploaded))
compressed, stats = compress_with_stats(uploaded[filename], data['dictionary'], update_dict=True)
output_name = filename + COMPRESSED_EXT
with open(output_name, 'wb') as f:
f.write(compressed)
data['files'].append(output_name)
with open(DATA_FILE, 'wb') as f:
pickle.dump(data, f)
files.download(output_name)
print(f"Compressed: {output_name}")
print(f"Repeated pairs: {stats['repeated']} | New pairs: {stats['new']}")
elif choice == '2':
uploaded = files.upload()
if not uploaded: continue
filename = next(iter(uploaded))
decompressed = decompress(uploaded[filename], data['dictionary'])
output_name = filename.replace(COMPRESSED_EXT, "")
with open(output_name, 'wb') as f:
f.write(decompressed)
files.download(output_name)
print(f"Decompressed: {output_name}")
elif choice == '3':
print("\nDictionary Stats:")
for level in range(4):
print(f"Level {level}: {len(data['dictionary'][level])} pairs")
elif choice == '4':
print("\nGenerating pairs for levels 2-3...")
data['dictionary'] = generate_pairs(data['dictionary'])
with open(DATA_FILE, 'wb') as f:
pickle.dump(data, f)
print("Generation completed!")
elif choice == '5':
break
elif choice == '6':
generate_and_compress_continuously(data)
else:
print("Invalid choice")
if __name__ == "__main__":
main_menu()
import os
import pickle
import time
import psutil
import sys
from google.colab import files
# Константы
DATA_FILE = "data.pickle"
COMPRESSED_EXT = ".ctxt"
GENERATED_DIR = "generated_files"
# Алфавит для хешей
ALPHABET = (
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
'abcdefghijklmnopqrstuvwxyz'
'0123456789'
'一丁七万丈三上下不与丑专且世丘丙业丛东丝丞丢两严並丧丨'
'अआइईउऊऋएऐओऔकखगघङचछजझञटठडढणतथदधनपफबभमयरलवशसह़ािीुूृॅेैॉोौ्ॐक़ख़ग़ज़ड़ढ़फ़य़'
)
ALPHABET = ''.join(sorted(set(ALPHABET)))[:256]
def int_to_hash(n, length=5):
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 print_progress(level, current, total, start_time):
elapsed = time.time() - start_time
memory = psutil.Process(os.getpid()).memory_info().rss / (10243)
percent = (current / total) 100
print(f"Level {level} | Pairs: {current}/{total} ({percent:.2f}%) | "
f"Memory: {memory:.2f} GB | Time: {elapsed:.1f}s")
def generate_level(dictionary, level, hashes):
total = len(hashes)2
start = time.time()
last_print = start
print(f"\n[Level {level}] Generating {total} pairs...")
for i, h1 in enumerate(hashes):
for j, h2 in enumerate(hashes):
pair = (h1, h2)
if pair not in dictionary[level]:
hash_code = int_to_hash(len(dictionary[level]))
dictionary[level][pair] = hash_code
if time.time() - last_print >= 1:
current = i len(hashes) + j + 1
print_progress(level, current, total, start)
last_print = time.time()
print(f"[Level {level}] Completed in {time.time()-start:.1f}s")
return dictionary
def generate_pairs(dictionary):
print("\n=== Generating pairs for levels 2 and 3 ===")
level1_hashes = list(dictionary[1].values())
dictionary = generate_level(dictionary, 2, level1_hashes)
level2_hashes = list(dictionary[2].values())
dictionary = generate_level(dictionary, 3, level2_hashes)
return dictionary
def initialize_dictionary():
print("Initializing dictionaries...")
dictionary = [{} for _ in range(4)]
for i in range(4):
for j in range(4):
pair = (i, j)
dictionary[0][pair] = int_to_hash(len(dictionary[0]))
level0_hashes = list(dictionary[0].values())
dictionary = generate_level(dictionary, 1, level0_hashes)
return dictionary
def load_data():
if os.path.exists(DATA_FILE) and os.path.getsize(DATA_FILE) > 0:
try:
with open(DATA_FILE, 'rb') as f:
return pickle.load(f)
except (EOFError, pickle.UnpicklingError):
print("Warning: Data file is corrupted. Creating a new one.")
data = {"dictionary": initialize_dictionary(), "files": []}
with open(DATA_FILE, 'wb') as f:
pickle.dump(data, f)
return data
else:
print("Creating a new data file.")
data = {"dictionary": initialize_dictionary(), "files": []}
with open(DATA_FILE, 'wb') as f:
pickle.dump(data, f)
return data
def split_into_2bit_blocks(data):
blocks = []
for byte in data:
blocks.extend([(byte >> shift) & 0x3 for shift in [6, 4, 2, 0]])
while len(blocks) % 2 != 0:
blocks.append(0)
return blocks
def combine_from_2bit_blocks(blocks):
data = []
for i in range(0, len(blocks), 4):
byte = sum([blocks[i+j] << (6-2j) for j in range(4)])
data.append(byte)
return bytes(data)
def compress(data, dictionary):
current = split_into_2bit_blocks(data)
for level in range(4):
current = [dictionary[level].get(tuple(current[i:i+2]), current[i:i+2])
for i in range(0, len(current), 2)]
return ''.join(current).encode('utf-8')
def compress_with_stats(data, dictionary, update_dict=False):
current = split_into_2bit_blocks(data)
stats = {'repeated': 0, 'new': 0}
for level in range(4):
new_current = []
for i in range(0, len(current), 2):
pair = tuple(current[i:i+2])
if pair in dictionary[level]:
new_current.append(dictionary[level][pair])
stats['repeated'] += 1
else:
if update_dict:
hash_code = int_to_hash(len(dictionary[level]))
dictionary[level][pair] = hash_code
new_current.append(hash_code)
stats['new'] += 1
else:
new_current.extend(pair)
current = new_current
return ''.join(current).encode('utf-8'), stats
def decompress(compressed_data, dictionary):
current = list(compressed_data.decode('utf-8'))
for level in reversed(range(4)):
current = [item for code in current
for item in dictionary[level].get(code, [0,0])]
return combine_from_2bit_blocks(current)
def get_dictionary_size(dictionary):
return sys.getsizeof(pickle.dumps(dictionary)) / (1024 3)
def generate_and_compress_continuously(data):
os.makedirs(GENERATED_DIR, exist_ok=True)
total_saved = 0
total_original = 0
total_compressed = 0
repeated_pairs = 0
new_pairs_added = 0
start_time = last_stat_time = time.time()
try:
while True:
original_data = os.urandom(1024 1024)
original_size = len(original_data)
original_filename = os.path.join(GENERATED_DIR, f"original_{time.time()}.txt")
with open(original_filename, 'wb') as f:
f.write(original_data)
compressed_data, stats = compress_with_stats(original_data, data['dictionary'], update_dict=True)
compressed_size = len(compressed_data)
compressed_filename = os.path.join(GENERATED_DIR, f"compressed_{time.time()}{COMPRESSED_EXT}")
with open(compressed_filename, 'wb') as f:
f.write(compressed_data)
total_original += original_size
total_compressed += compressed_size
total_saved += (original_size - compressed_size)
repeated_pairs += stats['repeated']
new_pairs_added += stats['new']
if time.time() - last_stat_time >= 1:
saved_gb = total_saved / (1024 3)
saved_percent = (total_saved / total_original) 100 if total_original else 0
dict_size_gb = get_dictionary_size(data['dictionary'])
level2_size = len(data['dictionary'][2])
max_level3 = level2_size 2
current_level3 = len(data['dictionary'][3])
level3_percent = (current_level3 / max_level3) 100 if max_level3 else 0
print(f"Saved: {saved_gb:.2f} GB ({saved_percent:.2f}%) | "
f"Repeated pairs: {repeated_pairs} | New pairs: {new_pairs_added} | "
f"Dict size: {dict_size_gb:.2f} GB | "
f"Level 3 pairs: {current_level3}/{max_level3} ({level3_percent:.2f}%)")
last_stat_time = time.time()
level2_size = len(data['dictionary'][2])
max_level3 = level2_size 2
current_level3 = len(data['dictionary'][3])
if current_level3 >= max_level3:
print("Level 3 dictionary filled. Stopping.")
break
with open(DATA_FILE, 'wb') as f:
pickle.dump(data, f)
except KeyboardInterrupt:
print("\nProcess stopped by user.")
finally:
with open(DATA_FILE, 'wb') as f:
pickle.dump(data, f)
print(f"Total saved space: {total_saved / (10243):.2f} GB")
def main_menu():
data = load_data()
while True:
print("\n=== Main Menu ===")
print("1. Compress file")
print("2. Decompress file")
print("3. Show dictionary stats")
print("4. Generate all pairs (Levels 2-3)")
print("5. Exit")
print("6. Generate and compress binary files continuously")
choice = input("Select action: ")
if choice == '1':
uploaded = files.upload()
if not uploaded: continue
filename = next(iter(uploaded))
compressed, stats = compress_with_stats(uploaded[filename], data['dictionary'], update_dict=True)
output_name = filename + COMPRESSED_EXT
with open(output_name, 'wb') as f:
f.write(compressed)
data['files'].append(output_name)
with open(DATA_FILE, 'wb') as f:
pickle.dump(data, f)
files.download(output_name)
print(f"Compressed: {output_name}")
print(f"Repeated pairs: {stats['repeated']} | New pairs: {stats['new']}")
elif choice == '2':
uploaded = files.upload()
if not uploaded: continue
filename = next(iter(uploaded))
decompressed = decompress(uploaded[filename], data['dictionary'])
output_name = filename.replace(COMPRESSED_EXT, "")
with open(output_name, 'wb') as f:
f.write(decompressed)
files.download(output_name)
print(f"Decompressed: {output_name}")
elif choice == '3':
print("\nDictionary Stats:")
for level in range(4):
print(f"Level {level}: {len(data['dictionary'][level])} pairs")
elif choice == '4':
print("\nGenerating pairs for levels 2-3...")
data['dictionary'] = generate_pairs(data['dictionary'])
with open(DATA_FILE, 'wb') as f:
pickle.dump(data, f)
print("Generation completed!")
elif choice == '5':
break
elif choice == '6':
generate_and_compress_continuously(data)
else:
print("Invalid choice")
if __name__ == "__main__":
main_menu()
Код колаба питона.
import os
import pickle
import time
import psutil
import sys
from google.colab import files
# Константы
DATA_FILE = "data.pickle"
COMPRESSED_EXT = ".ctxt"
GENERATED_DIR = "generated_files"
# Алфавит для хешей
ALPHABET = (
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
'abcdefghijklmnopqrstuvwxyz'
'0123456789'
'一丁七万丈三上下不与丑专且世丘丙业丛东丝丞丢两严並丧丨'
'अआइईउऊऋएऐओऔकखगघङचछजझञटठडढणतथदधनपफबभमयरलवशसह़ािीुूृॅेैॉोौ्ॐक़ख़ग़ज़ड़ढ़फ़य़'
)
ALPHABET = ''.join(sorted(set(ALPHABET)))[:256]
def int_to_hash(n, length=5):
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 print_progress(level, current, total, start_time):
elapsed = time.time() - start_time
memory = psutil.Process(os.getpid()).memory_info().rss / (10243)
percent = (current / total) 100
print(f"Level {level} | Pairs: {current}/{total} ({percent:.2f}%) | "
f"Memory: {memory:.2f} GB | Time: {elapsed:.1f}s")
def generate_level(dictionary, level, hashes):
total = len(hashes)2
start = time.time()
last_print = start
print(f"\n[Level {level}] Generating {total} pairs...")
for i, h1 in enumerate(hashes):
for j, h2 in enumerate(hashes):
pair = (h1, h2)
if pair not in dictionary[level]:
hash_code = int_to_hash(len(dictionary[level]))
dictionary[level][pair] = hash_code
if time.time() - last_print >= 1:
current = i len(hashes) + j + 1
print_progress(level, current, total, start)
last_print = time.time()
print(f"[Level {level}] Completed in {time.time()-start:.1f}s")
return dictionary
def generate_pairs(dictionary):
print("\n=== Generating pairs for levels 2 and 3 ===")
level1_hashes = list(dictionary[1].values())
dictionary = generate_level(dictionary, 2, level1_hashes)
level2_hashes = list(dictionary[2].values())
dictionary = generate_level(dictionary, 3, level2_hashes)
return dictionary
def initialize_dictionary():
print("Initializing dictionaries...")
dictionary = [{} for _ in range(4)]
for i in range(4):
for j in range(4):
pair = (i, j)
dictionary[0][pair] = int_to_hash(len(dictionary[0]))
level0_hashes = list(dictionary[0].values())
dictionary = generate_level(dictionary, 1, level0_hashes)
return dictionary
def load_data():
if os.path.exists(DATA_FILE) and os.path.getsize(DATA_FILE) > 0:
try:
with open(DATA_FILE, 'rb') as f:
return pickle.load(f)
except (EOFError, pickle.UnpicklingError):
print("Warning: Data file is corrupted. Creating a new one.")
data = {"dictionary": initialize_dictionary(), "files": []}
with open(DATA_FILE, 'wb') as f:
pickle.dump(data, f)
return data
else:
print("Creating a new data file.")
data = {"dictionary": initialize_dictionary(), "files": []}
with open(DATA_FILE, 'wb') as f:
pickle.dump(data, f)
return data
def split_into_2bit_blocks(data):
blocks = []
for byte in data:
blocks.extend([(byte >> shift) & 0x3 for shift in [6, 4, 2, 0]])
while len(blocks) % 2 != 0:
blocks.append(0)
return blocks
def combine_from_2bit_blocks(blocks):
data = []
for i in range(0, len(blocks), 4):
byte = sum([blocks[i+j] << (6-2j) for j in range(4)])
data.append(byte)
return bytes(data)
def compress(data, dictionary):
current = split_into_2bit_blocks(data)
for level in range(4):
current = [dictionary[level].get(tuple(current[i:i+2]), current[i:i+2])
for i in range(0, len(current), 2)]
return ''.join(current).encode('utf-8')
def compress_with_stats(data, dictionary, update_dict=False):
current = split_into_2bit_blocks(data)
stats = {'repeated': 0, 'new': 0}
for level in range(4):
new_current = []
for i in range(0, len(current), 2):
pair = tuple(current[i:i+2])
if pair in dictionary[level]:
new_current.append(dictionary[level][pair])
stats['repeated'] += 1
else:
if update_dict:
hash_code = int_to_hash(len(dictionary[level]))
dictionary[level][pair] = hash_code
new_current.append(hash_code)
stats['new'] += 1
else:
new_current.extend(pair)
current = new_current
return ''.join(current).encode('utf-8'), stats
def decompress(compressed_data, dictionary):
current = list(compressed_data.decode('utf-8'))
for level in reversed(range(4)):
current = [item for code in current
for item in dictionary[level].get(code, [0,0])]
return combine_from_2bit_blocks(current)
def get_dictionary_size(dictionary):
return sys.getsizeof(pickle.dumps(dictionary)) / (1024 3)
def generate_and_compress_continuously(data):
os.makedirs(GENERATED_DIR, exist_ok=True)
total_saved = 0
total_original = 0
total_compressed = 0
repeated_pairs = 0
new_pairs_added = 0
start_time = last_stat_time = time.time()
try:
while True:
original_data = os.urandom(1024 1024)
original_size = len(original_data)
original_filename = os.path.join(GENERATED_DIR, f"original_{time.time()}.txt")
with open(original_filename, 'wb') as f:
f.write(original_data)
compressed_data, stats = compress_with_stats(original_data, data['dictionary'], update_dict=True)
compressed_size = len(compressed_data)
compressed_filename = os.path.join(GENERATED_DIR, f"compressed_{time.time()}{COMPRESSED_EXT}")
with open(compressed_filename, 'wb') as f:
f.write(compressed_data)
total_original += original_size
total_compressed += compressed_size
total_saved += (original_size - compressed_size)
repeated_pairs += stats['repeated']
new_pairs_added += stats['new']
if time.time() - last_stat_time >= 1:
saved_gb = total_saved / (1024 3)
saved_percent = (total_saved / total_original) 100 if total_original else 0
dict_size_gb = get_dictionary_size(data['dictionary'])
level2_size = len(data['dictionary'][2])
max_level3 = level2_size 2
current_level3 = len(data['dictionary'][3])
level3_percent = (current_level3 / max_level3) 100 if max_level3 else 0
print(f"Saved: {saved_gb:.2f} GB ({saved_percent:.2f}%) | "
f"Repeated pairs: {repeated_pairs} | New pairs: {new_pairs_added} | "
f"Dict size: {dict_size_gb:.2f} GB | "
f"Level 3 pairs: {current_level3}/{max_level3} ({level3_percent:.2f}%)")
last_stat_time = time.time()
level2_size = len(data['dictionary'][2])
max_level3 = level2_size 2
current_level3 = len(data['dictionary'][3])
if current_level3 >= max_level3:
print("Level 3 dictionary filled. Stopping.")
break
with open(DATA_FILE, 'wb') as f:
pickle.dump(data, f)
except KeyboardInterrupt:
print("\nProcess stopped by user.")
finally:
with open(DATA_FILE, 'wb') as f:
pickle.dump(data, f)
print(f"Total saved space: {total_saved / (10243):.2f} GB")
def main_menu():
data = load_data()
while True:
print("\n=== Main Menu ===")
print("1. Compress file")
print("2. Decompress file")
print("3. Show dictionary stats")
print("4. Generate all pairs (Levels 2-3)")
print("5. Exit")
print("6. Generate and compress binary files continuously")
choice = input("Select action: ")
if choice == '1':
uploaded = files.upload()
if not uploaded: continue
filename = next(iter(uploaded))
compressed, stats = compress_with_stats(uploaded[filename], data['dictionary'], update_dict=True)
output_name = filename + COMPRESSED_EXT
with open(output_name, 'wb') as f:
f.write(compressed)
data['files'].append(output_name)
with open(DATA_FILE, 'wb') as f:
pickle.dump(data, f)
files.download(output_name)
print(f"Compressed: {output_name}")
print(f"Repeated pairs: {stats['repeated']} | New pairs: {stats['new']}")
elif choice == '2':
uploaded = files.upload()
if not uploaded: continue
filename = next(iter(uploaded))
decompressed = decompress(uploaded[filename], data['dictionary'])
output_name = filename.replace(COMPRESSED_EXT, "")
with open(output_name, 'wb') as f:
f.write(decompressed)
files.download(output_name)
print(f"Decompressed: {output_name}")
elif choice == '3':
print("\nDictionary Stats:")
for level in range(4):
print(f"Level {level}: {len(data['dictionary'][level])} pairs")
elif choice == '4':
print("\nGenerating pairs for levels 2-3...")
data['dictionary'] = generate_pairs(data['dictionary'])
with open(DATA_FILE, 'wb') as f:
pickle.dump(data, f)
print("Generation completed!")
elif choice == '5':
break
elif choice == '6':
generate_and_compress_continuously(data)
else:
print("Invalid choice")
if __name__ == "__main__":
main_menu()
import os
import pickle
import time
import psutil
import sys
from google.colab import files
# Константы
DATA_FILE = "data.pickle"
COMPRESSED_EXT = ".ctxt"
GENERATED_DIR = "generated_files"
# Алфавит для хешей
ALPHABET = (
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
'abcdefghijklmnopqrstuvwxyz'
'0123456789'
'一丁七万丈三上下不与丑专且世丘丙业丛东丝丞丢两严並丧丨'
'अआइईउऊऋएऐओऔकखगघङचछजझञटठडढणतथदधनपफबभमयरलवशसह़ािीुूृॅेैॉोौ्ॐक़ख़ग़ज़ड़ढ़फ़य़'
)
ALPHABET = ''.join(sorted(set(ALPHABET)))[:256]
def int_to_hash(n, length=5):
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 print_progress(level, current, total, start_time):
elapsed = time.time() - start_time
memory = psutil.Process(os.getpid()).memory_info().rss / (10243)
percent = (current / total) 100
print(f"Level {level} | Pairs: {current}/{total} ({percent:.2f}%) | "
f"Memory: {memory:.2f} GB | Time: {elapsed:.1f}s")
def generate_level(dictionary, level, hashes):
total = len(hashes)2
start = time.time()
last_print = start
print(f"\n[Level {level}] Generating {total} pairs...")
for i, h1 in enumerate(hashes):
for j, h2 in enumerate(hashes):
pair = (h1, h2)
if pair not in dictionary[level]:
hash_code = int_to_hash(len(dictionary[level]))
dictionary[level][pair] = hash_code
if time.time() - last_print >= 1:
current = i len(hashes) + j + 1
print_progress(level, current, total, start)
last_print = time.time()
print(f"[Level {level}] Completed in {time.time()-start:.1f}s")
return dictionary
def generate_pairs(dictionary):
print("\n=== Generating pairs for levels 2 and 3 ===")
level1_hashes = list(dictionary[1].values())
dictionary = generate_level(dictionary, 2, level1_hashes)
level2_hashes = list(dictionary[2].values())
dictionary = generate_level(dictionary, 3, level2_hashes)
return dictionary
def initialize_dictionary():
print("Initializing dictionaries...")
dictionary = [{} for _ in range(4)]
for i in range(4):
for j in range(4):
pair = (i, j)
dictionary[0][pair] = int_to_hash(len(dictionary[0]))
level0_hashes = list(dictionary[0].values())
dictionary = generate_level(dictionary, 1, level0_hashes)
return dictionary
def load_data():
if os.path.exists(DATA_FILE) and os.path.getsize(DATA_FILE) > 0:
try:
with open(DATA_FILE, 'rb') as f:
return pickle.load(f)
except (EOFError, pickle.UnpicklingError):
print("Warning: Data file is corrupted. Creating a new one.")
data = {"dictionary": initialize_dictionary(), "files": []}
with open(DATA_FILE, 'wb') as f:
pickle.dump(data, f)
return data
else:
print("Creating a new data file.")
data = {"dictionary": initialize_dictionary(), "files": []}
with open(DATA_FILE, 'wb') as f:
pickle.dump(data, f)
return data
def split_into_2bit_blocks(data):
blocks = []
for byte in data:
blocks.extend([(byte >> shift) & 0x3 for shift in [6, 4, 2, 0]])
while len(blocks) % 2 != 0:
blocks.append(0)
return blocks
def combine_from_2bit_blocks(blocks):
data = []
for i in range(0, len(blocks), 4):
byte = sum([blocks[i+j] << (6-2j) for j in range(4)])
data.append(byte)
return bytes(data)
def compress(data, dictionary):
current = split_into_2bit_blocks(data)
for level in range(4):
current = [dictionary[level].get(tuple(current[i:i+2]), current[i:i+2])
for i in range(0, len(current), 2)]
return ''.join(current).encode('utf-8')
def compress_with_stats(data, dictionary, update_dict=False):
current = split_into_2bit_blocks(data)
stats = {'repeated': 0, 'new': 0}
for level in range(4):
new_current = []
for i in range(0, len(current), 2):
pair = tuple(current[i:i+2])
if pair in dictionary[level]:
new_current.append(dictionary[level][pair])
stats['repeated'] += 1
else:
if update_dict:
hash_code = int_to_hash(len(dictionary[level]))
dictionary[level][pair] = hash_code
new_current.append(hash_code)
stats['new'] += 1
else:
new_current.extend(pair)
current = new_current
return ''.join(current).encode('utf-8'), stats
def decompress(compressed_data, dictionary):
current = list(compressed_data.decode('utf-8'))
for level in reversed(range(4)):
current = [item for code in current
for item in dictionary[level].get(code, [0,0])]
return combine_from_2bit_blocks(current)
def get_dictionary_size(dictionary):
return sys.getsizeof(pickle.dumps(dictionary)) / (1024 3)
def generate_and_compress_continuously(data):
os.makedirs(GENERATED_DIR, exist_ok=True)
total_saved = 0
total_original = 0
total_compressed = 0
repeated_pairs = 0
new_pairs_added = 0
start_time = last_stat_time = time.time()
try:
while True:
original_data = os.urandom(1024 1024)
original_size = len(original_data)
original_filename = os.path.join(GENERATED_DIR, f"original_{time.time()}.txt")
with open(original_filename, 'wb') as f:
f.write(original_data)
compressed_data, stats = compress_with_stats(original_data, data['dictionary'], update_dict=True)
compressed_size = len(compressed_data)
compressed_filename = os.path.join(GENERATED_DIR, f"compressed_{time.time()}{COMPRESSED_EXT}")
with open(compressed_filename, 'wb') as f:
f.write(compressed_data)
total_original += original_size
total_compressed += compressed_size
total_saved += (original_size - compressed_size)
repeated_pairs += stats['repeated']
new_pairs_added += stats['new']
if time.time() - last_stat_time >= 1:
saved_gb = total_saved / (1024 3)
saved_percent = (total_saved / total_original) 100 if total_original else 0
dict_size_gb = get_dictionary_size(data['dictionary'])
level2_size = len(data['dictionary'][2])
max_level3 = level2_size 2
current_level3 = len(data['dictionary'][3])
level3_percent = (current_level3 / max_level3) 100 if max_level3 else 0
print(f"Saved: {saved_gb:.2f} GB ({saved_percent:.2f}%) | "
f"Repeated pairs: {repeated_pairs} | New pairs: {new_pairs_added} | "
f"Dict size: {dict_size_gb:.2f} GB | "
f"Level 3 pairs: {current_level3}/{max_level3} ({level3_percent:.2f}%)")
last_stat_time = time.time()
level2_size = len(data['dictionary'][2])
max_level3 = level2_size 2
current_level3 = len(data['dictionary'][3])
if current_level3 >= max_level3:
print("Level 3 dictionary filled. Stopping.")
break
with open(DATA_FILE, 'wb') as f:
pickle.dump(data, f)
except KeyboardInterrupt:
print("\nProcess stopped by user.")
finally:
with open(DATA_FILE, 'wb') as f:
pickle.dump(data, f)
print(f"Total saved space: {total_saved / (10243):.2f} GB")
def main_menu():
data = load_data()
while True:
print("\n=== Main Menu ===")
print("1. Compress file")
print("2. Decompress file")
print("3. Show dictionary stats")
print("4. Generate all pairs (Levels 2-3)")
print("5. Exit")
print("6. Generate and compress binary files continuously")
choice = input("Select action: ")
if choice == '1':
uploaded = files.upload()
if not uploaded: continue
filename = next(iter(uploaded))
compressed, stats = compress_with_stats(uploaded[filename], data['dictionary'], update_dict=True)
output_name = filename + COMPRESSED_EXT
with open(output_name, 'wb') as f:
f.write(compressed)
data['files'].append(output_name)
with open(DATA_FILE, 'wb') as f:
pickle.dump(data, f)
files.download(output_name)
print(f"Compressed: {output_name}")
print(f"Repeated pairs: {stats['repeated']} | New pairs: {stats['new']}")
elif choice == '2':
uploaded = files.upload()
if not uploaded: continue
filename = next(iter(uploaded))
decompressed = decompress(uploaded[filename], data['dictionary'])
output_name = filename.replace(COMPRESSED_EXT, "")
with open(output_name, 'wb') as f:
f.write(decompressed)
files.download(output_name)
print(f"Decompressed: {output_name}")
elif choice == '3':
print("\nDictionary Stats:")
for level in range(4):
print(f"Level {level}: {len(data['dictionary'][level])} pairs")
elif choice == '4':
print("\nGenerating pairs for levels 2-3...")
data['dictionary'] = generate_pairs(data['dictionary'])
with open(DATA_FILE, 'wb') as f:
pickle.dump(data, f)
print("Generation completed!")
elif choice == '5':
break
elif choice == '6':
generate_and_compress_continuously(data)
else:
print("Invalid choice")
if __name__ == "__main__":
main_menu()
Полная демонстрация работы программы,
если есть вопрсы, задаём.
если есть вопрсы, задаём.
>>08572 (OP)
Ну смотри, ты пишешь что можно бесконечно сжимать информацию. Тогда можно можно всё сжать до 1 бита, имеющего два возможных значения. Значит будут ситуации, когда, скажем, текстуры условного макс пейн и условный трек бурзум будут иметь одно и то же значение. Потому, кроме словаря, нужно что то, что описывает процесс сжатия, для различения двух сжатых файлов. Так? И сколько будет такое весить?
Ну смотри, ты пишешь что можно бесконечно сжимать информацию. Тогда можно можно всё сжать до 1 бита, имеющего два возможных значения. Значит будут ситуации, когда, скажем, текстуры условного макс пейн и условный трек бурзум будут иметь одно и то же значение. Потому, кроме словаря, нужно что то, что описывает процесс сжатия, для различения двух сжатых файлов. Так? И сколько будет такое весить?
>>08572 (OP)
пшол накуой, пес шизанутый.
ии разъебал в пух и прах эту шизу про 34гб словарь.
Вывод: Предположение Шеннона в его теореме о кодировании не подтверждается математическими методами.
Не существует универсального размера словаря, который позволил бы бесконечно сжимать любые файлы без потери плотности сжатия. Однако использование словаря размером от 32 КБ до 4 МБ в сочетании с современными алгоритмами сжатия (например, Zstandard, Brotli, LZMA) обеспечивает высокую эффективность для большинства задач. Для многократного сжатия важно комбинировать разные методы и учитывать природу данных.
Применение словарей более 768 МБ не имеет доказанной эффективности.
Как мы и разобрались с тобой ранее, предложенный в программе метод в целом не является алгоритмом архивации, а представляет собой конвертацию данных с возможностью их итеративного преобразования, но без существенного изменения размера после первоначального сжатия.
Это скорее программа-шутка, которая пытается ввести пользователя в заблуждение по алгоритму, имитирующему обработку данных. Задавай ещё вопросы по теме архивации. Что тебя интересует, я помогу тебе разобраться вместе.
пшол накуой, пес шизанутый.
ии разъебал в пух и прах эту шизу про 34гб словарь.
Вывод: Предположение Шеннона в его теореме о кодировании не подтверждается математическими методами.
Не существует универсального размера словаря, который позволил бы бесконечно сжимать любые файлы без потери плотности сжатия. Однако использование словаря размером от 32 КБ до 4 МБ в сочетании с современными алгоритмами сжатия (например, Zstandard, Brotli, LZMA) обеспечивает высокую эффективность для большинства задач. Для многократного сжатия важно комбинировать разные методы и учитывать природу данных.
Применение словарей более 768 МБ не имеет доказанной эффективности.
Как мы и разобрались с тобой ранее, предложенный в программе метод в целом не является алгоритмом архивации, а представляет собой конвертацию данных с возможностью их итеративного преобразования, но без существенного изменения размера после первоначального сжатия.
Это скорее программа-шутка, которая пытается ввести пользователя в заблуждение по алгоритму, имитирующему обработку данных. Задавай ещё вопросы по теме архивации. Что тебя интересует, я помогу тебе разобраться вместе.
Кто не в теме, давайте начнём с простых основ как производители HDD И SSD наябывали вас 40 лет и не изучали другие типы кодирования.
что такое информация? Вся цифровая информация это 1 и 0 ( бинарный код )
программирование это обозначение этих цепочек что бы машина понимала инструкции, инструкции можно запрогать любые но они будут занимать МЕСТО те ячейки 1 и 0
До HDD Были перфокарты, магнитные ленты, и перфоленты.
Первые перфокарты кодировались примитивно 3 - как 3 пробела 9 как 9 пробелов
Но появилась логика таблиц позволяющая упростить это до 2-3 пробелов ( ведь у 3 дырок всего 9 комбинаций
Первое видео это музыкальная шкатулка там 20 нот. А в информатике только 2 ноты, ( те бинарный код 1 и 0 )
На дисках место это магнитные расстояния ячеек, на SSD это сами ячейки
те HDD и SSD это сжатые перфокарты в 500- и 1000 раз, методы кодирования 40 лет не менялись
Следовательно упрощённо 1 гигабайт HDD это 1 миллиард ячеек. текущие алгоритмы скоростного RLE сжимают файловую систему HDD в 4 раза. поэтому ваш 1 гигабайт по прошивке как 4 гб HDD
класические RLE ищут повторы по типу 000111 будет как 3o-3111 эта маркировка уже белый шум и повторов в ней нет.
Что же делает МЕТОД ВЫШЕ? Он создаёт всевозможные цепочки цепей бинарного кода, где ссылки 32 бита кодируют 128 бит. ведь у 4 бит всего 16 комбинаций, у 16 пар комбинаций 256 пар комбинаций, а у 256 пар комбинаций 4 миллиарда комбинаций! эти 4 миллиарда комбинации это 900 гб сырого словаря, и позволяют сжимать информацию за 1 цикл в 10 раз. ( циклов можно делать бесконечно но ограничение это 5кб на кластер )
что такое информация? Вся цифровая информация это 1 и 0 ( бинарный код )
программирование это обозначение этих цепочек что бы машина понимала инструкции, инструкции можно запрогать любые но они будут занимать МЕСТО те ячейки 1 и 0
До HDD Были перфокарты, магнитные ленты, и перфоленты.
Первые перфокарты кодировались примитивно 3 - как 3 пробела 9 как 9 пробелов
Но появилась логика таблиц позволяющая упростить это до 2-3 пробелов ( ведь у 3 дырок всего 9 комбинаций
Первое видео это музыкальная шкатулка там 20 нот. А в информатике только 2 ноты, ( те бинарный код 1 и 0 )
На дисках место это магнитные расстояния ячеек, на SSD это сами ячейки
те HDD и SSD это сжатые перфокарты в 500- и 1000 раз, методы кодирования 40 лет не менялись
Следовательно упрощённо 1 гигабайт HDD это 1 миллиард ячеек. текущие алгоритмы скоростного RLE сжимают файловую систему HDD в 4 раза. поэтому ваш 1 гигабайт по прошивке как 4 гб HDD
класические RLE ищут повторы по типу 000111 будет как 3o-3111 эта маркировка уже белый шум и повторов в ней нет.
Что же делает МЕТОД ВЫШЕ? Он создаёт всевозможные цепочки цепей бинарного кода, где ссылки 32 бита кодируют 128 бит. ведь у 4 бит всего 16 комбинаций, у 16 пар комбинаций 256 пар комбинаций, а у 256 пар комбинаций 4 миллиарда комбинаций! эти 4 миллиарда комбинации это 900 гб сырого словаря, и позволяют сжимать информацию за 1 цикл в 10 раз. ( циклов можно делать бесконечно но ограничение это 5кб на кластер )
>>08811
Незаконная врачебная деятельность плез, обсуждение диагнозов вне леч учреждений, назначение лечение, или обсуждение врачебной тайны вне учреждений как минимум уголовка, как максимум увольнение и выговор. Скажи ты врач или нет?
>Почему таблетки не пьёшь?
Незаконная врачебная деятельность плез, обсуждение диагнозов вне леч учреждений, назначение лечение, или обсуждение врачебной тайны вне учреждений как минимум уголовка, как максимум увольнение и выговор. Скажи ты врач или нет?
>>09126
Текущие ИИ имеют нейронов и параметров как у мухи и не могут критиковать и создавать новые методы, научных знаний,
тут речь идёт о новом методе научного знания.
Получать научные степени и доказывать, перед организациями. мне лень.
Ещё хуже, все текущие ИИ не могли мне правильно расчитать размер словаря на 4 уровне. ( клауди, чат гпт, гимини, ) говорили что будет 100 гб. Но на деле размер полного словаря 900 гб
>>09052
Минимальный размер кластера винды и линукса 5-10 кб, Информация сжимается в 10 раз за цикл, те весь интернет и всю инфу в мире можно сжать до 5-10кб но это будут миллионы и миллиарды циклов.
Текущие ИИ имеют нейронов и параметров как у мухи и не могут критиковать и создавать новые методы, научных знаний,
тут речь идёт о новом методе научного знания.
Получать научные степени и доказывать, перед организациями. мне лень.
Ещё хуже, все текущие ИИ не могли мне правильно расчитать размер словаря на 4 уровне. ( клауди, чат гпт, гимини, ) говорили что будет 100 гб. Но на деле размер полного словаря 900 гб
>>09052
Минимальный размер кластера винды и линукса 5-10 кб, Информация сжимается в 10 раз за цикл, те весь интернет и всю инфу в мире можно сжать до 5-10кб но это будут миллионы и миллиарды циклов.
>>09052
Давай очень по простому.
11 это 1 это словарь 1 уровня
Словарь второго уровня
11 это 2
Это значит что написав ссылку 2 на словарь 2 уровня. ты получаешь 11 11 ( те сжатие расжатие в 2 раза )
Создаём словарь 3 уровня где
22 это 3
те теперь написав ссылку на словарь 3 уровня. ты получаешь например. написал 3 получил 11 11 11 11 11 11
те логика умножения, тут но виде древ и хешей.
>словаря, нужно что то, что описывает процесс сжатия, для различения двух сжатых файлов. Так?
Давай очень по простому.
11 это 1 это словарь 1 уровня
Словарь второго уровня
11 это 2
Это значит что написав ссылку 2 на словарь 2 уровня. ты получаешь 11 11 ( те сжатие расжатие в 2 раза )
Создаём словарь 3 уровня где
22 это 3
те теперь написав ссылку на словарь 3 уровня. ты получаешь например. написал 3 получил 11 11 11 11 11 11
те логика умножения, тут но виде древ и хешей.
Пример реальных тестов.
если 16 % это 126 гб то сколько будет 100%?
Таким образом, 100% будет 787 ГБ
Таким образом имея 800 гб словаря на SSD можно рекурсивно сжимать информацию, 1 гб в 5 кб.
Доказано научно, ведь 800 гб это 4 уровневый словарь где все частотности бинарного кода ЕСТЬ.
Уровень 0: 16 пар 8 байт/пара = 128 байт
Уровень 1: 256 пар 8 байт/пара = 2 КБ
Уровень 2: 65 536 пар 8 байт/пара = 512 КБ
Уровень 3: 4 294 967 296 пар 8 байт/пара
если 16 % это 126 гб то сколько будет 100%?
Таким образом, 100% будет 787 ГБ
Таким образом имея 800 гб словаря на SSD можно рекурсивно сжимать информацию, 1 гб в 5 кб.
Доказано научно, ведь 800 гб это 4 уровневый словарь где все частотности бинарного кода ЕСТЬ.
Уровень 0: 16 пар 8 байт/пара = 128 байт
Уровень 1: 256 пар 8 байт/пара = 2 КБ
Уровень 2: 65 536 пар 8 байт/пара = 512 КБ
Уровень 3: 4 294 967 296 пар 8 байт/пара
448 Кб, 695x720>>09342
Ты не ответил на вопрос. Я рассуждал теоретически для упрощения. Мы сжимаем какое-то количество раз два разных файла до 1 бита. Сжимая любые файлы, мы будем приходить к 0 либо 1. И вот, так вышло, что два сжатых файла представлют собой совпадающее значение, допустим, 1. Тогда, чтобы их различить, мы должны иметь что-то кроме словаря. Что это и сколько весить такое может? Уж не столько же, сколько исходный файл?
Ты не ответил на вопрос. Я рассуждал теоретически для упрощения. Мы сжимаем какое-то количество раз два разных файла до 1 бита. Сжимая любые файлы, мы будем приходить к 0 либо 1. И вот, так вышло, что два сжатых файла представлют собой совпадающее значение, допустим, 1. Тогда, чтобы их различить, мы должны иметь что-то кроме словаря. Что это и сколько весить такое может? Уж не столько же, сколько исходный файл?
130 Кб, 1280x711>>09126
А сам ИИ квантуют и сжимают в 4 гб весов. те все знания челвоечества, все статьи и логика умещается в 4 гб весов? вот пруф ЛАМЫ, почему их не научили востанавливать запрос и ответ по сиду хешу?
вот большие языковые модели 512 гб квантуют в 2 гб. без потери качества ответов и запускают на смартах
раньше лламу и языковые можно было запускать ток на железе от 10 млн $ - но теперь большие языковые запускают на смартах и квантуют параметры в 1 - 2 бита. 32 бита.
>ии разъебал в пух и прах
А сам ИИ квантуют и сжимают в 4 гб весов. те все знания челвоечества, все статьи и логика умещается в 4 гб весов? вот пруф ЛАМЫ, почему их не научили востанавливать запрос и ответ по сиду хешу?
вот большие языковые модели 512 гб квантуют в 2 гб. без потери качества ответов и запускают на смартах
раньше лламу и языковые можно было запускать ток на железе от 10 млн $ - но теперь большие языковые запускают на смартах и квантуют параметры в 1 - 2 бита. 32 бита.
>>09676
Ты рассуждаешь единицами, а метод блочный,
минимальный размер кластера 5 кб. те 5 тысяч знаков
Размер 1 строки словаря 32 бита.
Это минимум. всё остальное комбинации. на винде минимальный блок это 5 кб те вся инфа и её минимальное количество невозможно ужать ниже 5кб.
простой пример. Много этажка это не схема каждого атома и кирпича, а схема 1 этажа и дубликаты 9 этажей.
Но мой метод ( а уже и ваш ) позволяет мгновенно раскладывать любые комбинации хоть атомов, и чего угодно
Проблема кодирования и хранения информации решена.
Цена за бесконечную рекурсию информации стоит 900 гб словаря, в сыром виде. код и метод выше.
> Сжимая любые файлы, мы будем приходить к 0 либо 1.
Ты рассуждаешь единицами, а метод блочный,
минимальный размер кластера 5 кб. те 5 тысяч знаков
Размер 1 строки словаря 32 бита.
Это минимум. всё остальное комбинации. на винде минимальный блок это 5 кб те вся инфа и её минимальное количество невозможно ужать ниже 5кб.
простой пример. Много этажка это не схема каждого атома и кирпича, а схема 1 этажа и дубликаты 9 этажей.
Но мой метод ( а уже и ваш ) позволяет мгновенно раскладывать любые комбинации хоть атомов, и чего угодно
Проблема кодирования и хранения информации решена.
Цена за бесконечную рекурсию информации стоит 900 гб словаря, в сыром виде. код и метод выше.
>>08572 (OP)
разархивируй мне по своему алгоритму
а) 10к единиц (10 000 символов)
б) 10к единиц + ноль (10 001 символов)
в) 10к нулей (10 000 символов)
г) 10к нулей + 1 (10 001 символов)
разархивируй мне по своему алгоритму
а) 10к единиц (10 000 символов)
б) 10к единиц + ноль (10 001 символов)
в) 10к нулей (10 000 символов)
г) 10к нулей + 1 (10 001 символов)
>>08788
Есть один вопрос. Люди конкретно заебываются, чтобы сделать что-нибудь хорошее, но это потом никому не нужно, потому что человечество предпочитает жрать говно. А другие люди вообще конкретно заебываются, чтобы просто заработать на жизнь. Значит у вас пидорасов дохуя свободного времени, значит вы свою работу сделали не так хорошо, как можно было бы, значит я завтра блядь зайду на сайт какого-нибудь уебищного Альфа банка, нажму кнопку "Войти" и ничего не произойдет, потому что чекнутый зумер насовал туда ненужного жопаскрипта, но оттестировать ему было некогда, ведь ебаная тварь была занята выиранием говна и еблей колаба ради потролить на дваче. Вот такой вопрос примерно.
>если есть вопрсы, задаём
Есть один вопрос. Люди конкретно заебываются, чтобы сделать что-нибудь хорошее, но это потом никому не нужно, потому что человечество предпочитает жрать говно. А другие люди вообще конкретно заебываются, чтобы просто заработать на жизнь. Значит у вас пидорасов дохуя свободного времени, значит вы свою работу сделали не так хорошо, как можно было бы, значит я завтра блядь зайду на сайт какого-нибудь уебищного Альфа банка, нажму кнопку "Войти" и ничего не произойдет, потому что чекнутый зумер насовал туда ненужного жопаскрипта, но оттестировать ему было некогда, ведь ебаная тварь была занята выиранием говна и еблей колаба ради потролить на дваче. Вот такой вопрос примерно.
103 Кб, 704x768>>09676
Скок готов заплатить за генерацию картинок 60 кадров в сек, на GTX 1050? 2 гб рам? метод оптимизирует миллиарды и триллионы$ но он прост что бы его спиздеть, а продавать и реализовывать не имеет смысла.
Создавать сервисы для генерации цифрового мусора и порнухи это унизительно когда знаешь что сингулярность может быть
>Ты не ответил на вопрос. Я рассуждал теоретически для упрощения. Мы сжимаем какое-то количество
Скок готов заплатить за генерацию картинок 60 кадров в сек, на GTX 1050? 2 гб рам? метод оптимизирует миллиарды и триллионы$ но он прост что бы его спиздеть, а продавать и реализовывать не имеет смысла.
Создавать сервисы для генерации цифрового мусора и порнухи это унизительно когда знаешь что сингулярность может быть
>>10015
Не важно что там винда может, а что нет. Но пусть. Где находится то, что описывает путь от исходного файла, до конечного. Я не про словарь. Я про то, что из двух совпадающих конечных (сжатых) файлов, что имеют одинаковые биты (по располажению и значению) в этих 5 кб. Для каждого файла это должно быть уникально. Ведь это неизбежно, что если сжимать огромное кол-во разных файлов до минимально возможного размера - мы будем приходить к двум одинаковым конечным файлам. Как их различать.
Не важно что там винда может, а что нет. Но пусть. Где находится то, что описывает путь от исходного файла, до конечного. Я не про словарь. Я про то, что из двух совпадающих конечных (сжатых) файлов, что имеют одинаковые биты (по располажению и значению) в этих 5 кб. Для каждого файла это должно быть уникально. Ведь это неизбежно, что если сжимать огромное кол-во разных файлов до минимально возможного размера - мы будем приходить к двум одинаковым конечным файлам. Как их различать.
>>10327
Авторизация усложнена что бы её не наебали и твои деньги не спиздели.с помощи подмены кук или эмуляции сессии в сша
А виноваты те кто народ спаивают алкоголизмом, и не маркируют бутылки как курево о вредности,
ты можешь работать на благо народа, а завтра в тебя алкаш врежется на встречке
Те в стране нету онлайн учёта водителей и покупки алкоголя.
>нажму кнопку "Войти" и ничего не произойдет, потому что
Авторизация усложнена что бы её не наебали и твои деньги не спиздели.с помощи подмены кук или эмуляции сессии в сша
А виноваты те кто народ спаивают алкоголизмом, и не маркируют бутылки как курево о вредности,
ты можешь работать на благо народа, а завтра в тебя алкаш врежется на встречке
Те в стране нету онлайн учёта водителей и покупки алкоголя.
>>10685
Тебе дан исходный код программы. дан метод
Таким образом, у 64-битного файла 64-битной длины существует 18,446,744,073,709,551,616 различных комбинаций.
те всю инфу в мире можно запрогать на словарь 700 гб и эти комбинации. и сжимать рекурсивно в 5 кб всё.
вот ИИ без реги и лимитов которые ответи на вопросы твои
https://www.blackbox.ai/
Тебе дан исходный код программы. дан метод
Таким образом, у 64-битного файла 64-битной длины существует 18,446,744,073,709,551,616 различных комбинаций.
те всю инфу в мире можно запрогать на словарь 700 гб и эти комбинации. и сжимать рекурсивно в 5 кб всё.
вот ИИ без реги и лимитов которые ответи на вопросы твои
https://www.blackbox.ai/
Ты не сжал данные, ты просто переложил их в словарь размером больше оригинала. Это не архивация, а индексирование.
Шеннон давно доказал, что любую информацию можно сжать только до определенного предела, который зависит от ее энтропии. Если твой метод позволял бы бесконечно сжимать данные без потерь, можно было бы сжать весь интернет до одного байта. Но это невозможно, потому что у разных файлов будут одинаковые "сжатые" представления, и их невозможно будет восстановить.
900 ГБ словаря – это не решение, а проблема. Он растет экспоненциально, и уже на нескольких уровнях займет всю память планеты. Ты просто кодируешь одни данные через другие, а не уменьшаешь объем.
Ну и контрольный: если твое "сжатие" после этого еще можно сжать ZIP'ом, значит, оно неэффективно. Ты просто написал костыль, который делает вид, что что-то делает.
Шеннон давно доказал, что любую информацию можно сжать только до определенного предела, который зависит от ее энтропии. Если твой метод позволял бы бесконечно сжимать данные без потерь, можно было бы сжать весь интернет до одного байта. Но это невозможно, потому что у разных файлов будут одинаковые "сжатые" представления, и их невозможно будет восстановить.
900 ГБ словаря – это не решение, а проблема. Он растет экспоненциально, и уже на нескольких уровнях займет всю память планеты. Ты просто кодируешь одни данные через другие, а не уменьшаешь объем.
Ну и контрольный: если твое "сжатие" после этого еще можно сжать ZIP'ом, значит, оно неэффективно. Ты просто написал костыль, который делает вид, что что-то делает.
>>11283
Да это так, но там всего 4 миллиарда пар и 900 гб словаря. Дальше наступает рекурсия. Так как индекс всех пар факторизован
>Ты не сжал данные, ты просто переложил их в словарь размером больше оригинала. Это не архивация, а индексирование.
Да это так, но там всего 4 миллиарда пар и 900 гб словаря. Дальше наступает рекурсия. Так как индекс всех пар факторизован
>>11283
Самолёты не хранят все карты, они летят по направлению компаса те градусам широт и долгот.и азимутам
таким образом, самолёты летают по прямым им нужно лишь знать градус маршрута. а не хранить все карты
Тут же в методе, вместо бинарного кода, ссылки на их цепочки.
Поэтому изучайте код,и делайте сингулярность.
Самолёты не хранят все карты, они летят по направлению компаса те градусам широт и долгот.и азимутам
таким образом, самолёты летают по прямым им нужно лишь знать градус маршрута. а не хранить все карты
Тут же в методе, вместо бинарного кода, ссылки на их цепочки.
Поэтому изучайте код,и делайте сингулярность.
63 Кб, 640x640>>10860
Вопросов нет, я всё понял, ты просто хуесос. По твоей теме - сожми мой хуй себе защеку.
>если есть вопрсы, задаём.
> не смог ответить на простые вопросы по своей реализации сжатия
>Тебе дан исходный код программы. дан метод
>вот ИИ без реги и лимитов которые ответи на вопросы твои
Вопросов нет, я всё понял, ты просто хуесос. По твоей теме - сожми мой хуй себе защеку.
>>11541
Самолёты летают по маршрутам, а не по твоей шизоидной хуйне про "направление компаса". Ты сравнил жопу с пальцем. Твой "метод" — это тупое перекладывание данных в раздувающийся словарь, который растёт быстрее, чем твой бред. Это не сжатие, а бесполезное ебалово с индексами. Никакой сингулярности не будет, кроме краха твоей фантазии под весом 900 ГБ мусора.
Самолёты летают по маршрутам, а не по твоей шизоидной хуйне про "направление компаса". Ты сравнил жопу с пальцем. Твой "метод" — это тупое перекладывание данных в раздувающийся словарь, который растёт быстрее, чем твой бред. Это не сжатие, а бесполезное ебалово с индексами. Никакой сингулярности не будет, кроме краха твоей фантазии под весом 900 ГБ мусора.
>>11558
ну так индекс минимальный это 5кб а там триллионы комбинаций. те все деревья в лесу одинаковы но их расположение разное. Также и код делает разные индексы и древа, позволяя востановить все цепочки и инфу в рекурсии
>. Но это невозможно, потому что у разных файлов будут одинаковые "сжатые" представления, и их невозможно будет восстановить.
ну так индекс минимальный это 5кб а там триллионы комбинаций. те все деревья в лесу одинаковы но их расположение разное. Также и код делает разные индексы и древа, позволяя востановить все цепочки и инфу в рекурсии
>>11394
Ты не сжал, а раздуваешь словарь в 900 ГБ мусора. Рекурсия только делает хуже. Это не факторизация, а бесполезное перетасовывание данных без реального сжатия.
Ты не сжал, а раздуваешь словарь в 900 ГБ мусора. Рекурсия только делает хуже. Это не факторизация, а бесполезное перетасовывание данных без реального сжатия.
>>11639
900 гб это индекс всех пар бинарного кода до 4 уровня. дальше он не растёт
у 4 бит всего 16 комбинаций. или 256 пар
Уровень 0: 16 пар 8 байт/пара = 128 байт
Уровень 1: 256 пар 8 байт/пара = 2 КБ
Уровень 2: 65 536 пар 8 байт/пара = 512 КБ
Уровень 3: 4 294 967 296 пар 8 байт/пара = ~ 34 ГБ
>Никакой сингулярности не будет, кроме краха твоей фантазии под весом 900 ГБ
900 гб это индекс всех пар бинарного кода до 4 уровня. дальше он не растёт
у 4 бит всего 16 комбинаций. или 256 пар
Уровень 0: 16 пар 8 байт/пара = 128 байт
Уровень 1: 256 пар 8 байт/пара = 2 КБ
Уровень 2: 65 536 пар 8 байт/пара = 512 КБ
Уровень 3: 4 294 967 296 пар 8 байт/пара = ~ 34 ГБ
>>11771
Но эти 900 гб могут сжимать сотни терабайты в 1 мб без потерь.
видео демонстрация
простой пример, в играх толпа это ссылки на 1 модель. таким образом потребление памяти падает в 100-150 раз.
>словарь в 900 ГБ
Но эти 900 гб могут сжимать сотни терабайты в 1 мб без потерь.
видео демонстрация
простой пример, в играх толпа это ссылки на 1 модель. таким образом потребление памяти падает в 100-150 раз.
>>11771
окей, эксперд, давай ответь на вопрос тогда ТАКОЙ.
Сколько центов стоит, генерация одной картинки в dalle3? 1 трека в SUNO. или 10 сек видео в haulio ai.?
окей, эксперд, давай ответь на вопрос тогда ТАКОЙ.
Сколько центов стоит, генерация одной картинки в dalle3? 1 трека в SUNO. или 10 сек видео в haulio ai.?
>>11771
откуда stablediffusion знает как рисовать бессконечное количество РАЗНЫХ картинок по промту и сиду? - вес базы stablediffusion всего 4 гб. НУ ТАК ЧТО? -
на пикролах промт одинаков, а сиды разные. это значит что с помощью сидов и промта можно востановит любое изображение
А если есть бесконечная генерация, то есть и бесконечное сжатие! без потерь.
изначально он был 128 гб, и запускать его могли ток на H100 за 40к$
потом эту базу заквантовали до 4 гб и запускать можно на средних ноутбуках.
>Ты не сжал, а раздуваешь словарь
откуда stablediffusion знает как рисовать бессконечное количество РАЗНЫХ картинок по промту и сиду? - вес базы stablediffusion всего 4 гб. НУ ТАК ЧТО? -
на пикролах промт одинаков, а сиды разные. это значит что с помощью сидов и промта можно востановит любое изображение
А если есть бесконечная генерация, то есть и бесконечное сжатие! без потерь.
>вес базы stablediffusion всего 4 гб.
изначально он был 128 гб, и запускать его могли ток на H100 за 40к$
потом эту базу заквантовали до 4 гб и запускать можно на средних ноутбуках.
>>11870
Ты даже наебывать нормально не умеешь. Весь твой "метод" - это просто упаковка файла в кастомный формат перед тем, как его реально сжимает RAR. Давай разберём по косточкам:
Твой "сжатый" файл весит столько же, сколько оригинал (1.7МБ) => он не сжат, а просто перекодирован.
RAR потом сжимает его в 65КБ => значит, в твоем "ctxt" файле куча мусора, который RAR легко убирает.
Ты повторяешь процесс и получаешь 4.8КБ => RAR просто работает как положено, твой "метод" тут вообще ни при чём.
На "разжатии" ты просто достаёшь файл из архива => ты ничего не восстанавливаешь, а просто используешь RAR как костыль.
Теперь делаем так: бери 10ГБ видео, "сожми" его по своей методике, удали все архивы, оставь только свой 4.8КБ файл и разожми обратно. Если после этого получится видео без потерь, тогда можешь что-то вякать.
Ты даже наебывать нормально не умеешь. Весь твой "метод" - это просто упаковка файла в кастомный формат перед тем, как его реально сжимает RAR. Давай разберём по косточкам:
Твой "сжатый" файл весит столько же, сколько оригинал (1.7МБ) => он не сжат, а просто перекодирован.
RAR потом сжимает его в 65КБ => значит, в твоем "ctxt" файле куча мусора, который RAR легко убирает.
Ты повторяешь процесс и получаешь 4.8КБ => RAR просто работает как положено, твой "метод" тут вообще ни при чём.
На "разжатии" ты просто достаёшь файл из архива => ты ничего не восстанавливаешь, а просто используешь RAR как костыль.
Теперь делаем так: бери 10ГБ видео, "сожми" его по своей методике, удали все архивы, оставь только свой 4.8КБ файл и разожми обратно. Если после этого получится видео без потерь, тогда можешь что-то вякать.
>>12620
Зачем использовать проприетарный рар, когда есть свободные и более качественные алгоритмы и форматы?
Зачем использовать проприетарный рар, когда есть свободные и более качественные алгоритмы и форматы?
>>12620
Чел имей уважение у тебя тут код сингулярности и он решит все проблемы человечства, твои и мои
Верно
Так вот рар и зип это просто RLE с библиотекой в 10 мб они эфективней сжимают ZLIB
метод работает по типу СЛОВАРЬ1
111000- А
СЛОВАРЬ 2
111000-B
СЛОВАРЬ 3
111000-G
как видишь бинарный код один и тот же, но словари разные ) это значит что правилу 3 словарей можно сжимать инфу в 3 раза и рекурсивно.
Код работает медленно, но говорю официально что 900 гб описывают все сжатые состояния вин рара и 7zip и zlib
Чел имей уважение у тебя тут код сингулярности и он решит все проблемы человечства, твои и мои
Верно
>Твой "сжатый" файл весит столько же, сколько оригинал (1.7МБ) => он не сжат, а просто перекодирован.
Так вот рар и зип это просто RLE с библиотекой в 10 мб они эфективней сжимают ZLIB
метод работает по типу СЛОВАРЬ1
111000- А
СЛОВАРЬ 2
111000-B
СЛОВАРЬ 3
111000-G
как видишь бинарный код один и тот же, но словари разные ) это значит что правилу 3 словарей можно сжимать инфу в 3 раза и рекурсивно.
>Теперь делаем так: бери 10ГБ видео, "сожми" его по своей методике, удали все архивы, оставь только свой 4.8КБ файл и разожми обратно. Если после этого получится видео без потерь, тогда можешь что-то вякать.
Код работает медленно, но говорю официально что 900 гб описывают все сжатые состояния вин рара и 7zip и zlib
7,3 Мб, mp4,1166x576, 1:05
>>12989
злиб сжимает в 3-4 раза. вин рар в 8-10 раз
При этом скачав 50 гб визуал студио ты не сможешь скопмилировать ЗЛИб в рекурри
злиб сжимает в 3-4 раза. вин рар в 8-10 раз
При этом скачав 50 гб визуал студио ты не сможешь скопмилировать ЗЛИб в рекурри
>>08572 (OP)
Я кстати написал архиватор, который сжимает книгу Война и Мир до 0 байт.
Но у него две проблемы:
1) Не работает на других книгах
2) Весит ровно как несжатая книга Война и Мир
Я кстати написал архиватор, который сжимает книгу Война и Мир до 0 байт.
Но у него две проблемы:
1) Не работает на других книгах
2) Весит ровно как несжатая книга Война и Мир
Этот код реализует простое приложение для сжатия и распаковки файлов с графическим интерфейсом на Python, используя библиотеку tkinter. Давайте разберем код по частям и поймем, что он делает.
Общая структура:
Код состоит из следующих частей:
Импорт библиотек: Импортируются необходимые библиотеки для работы с файловой системой, сериализацией данных, JSON (для миграции данных), и графическим интерфейсом.
Константы: Определены константы, такие как имя файла для хранения данных (DATA_FILE), расширение для сжатых файлов (COMPRESSED_EXT), и алфавит (ALPHABET), используемый для кодирования.
Функции: Набор функций для выполнения основных операций:
int_to_hash: Преобразует целое число в хеш-строку.
split_into_2bit_blocks: Разделяет байтовые данные на блоки по 2 бита.
combine_from_2bit_blocks: Собирает 2-битные блоки обратно в байты.
compress: Функция сжатия данных.
decompress: Функция распаковки данных.
save_data_file: Сохраняет данные приложения в файл.
load_data_file: Загружает данные приложения из файла.
Класс FileManager: Класс, реализующий графический интерфейс приложения.
Основной блок if __name__ == "__main__":: Создает окно приложения и запускает главный цикл обработки событий tkinter.
Подробное описание функций и класса:
int_to_hash(n, length=5):
Берет целое число n и преобразует его в строку фиксированной длины (length, по умолчанию 5) с использованием символов из ALPHABET.
Это похоже на преобразование числа в систему счисления с основанием, равным длине ALPHABET.
Используется для создания коротких "хеш-кодов" для представления последовательностей данных в процессе сжатия.
split_into_2bit_blocks(data):
Принимает список байтов (data).
Разделяет каждый байт на 4 блока по 2 бита (старшие биты первыми).
Дополняет список блоков нулями до тех пор, пока длина не станет кратной 16.
Это подготавливает данные для многоуровневого сжатия, разбивая их на более мелкие единицы.
combine_from_2bit_blocks(blocks):
Выполняет обратную операцию к split_into_2bit_blocks.
Берет список 2-битных блоков (blocks) и собирает их обратно в байты, по 4 блока на байт.
compress(data, dictionary):
Основная функция сжатия.
Принимает байтовые данные (data) и словарь (dictionary). Словарь используется для хранения соответствий между последовательностями 2-битных блоков и их хеш-кодами.
Многоуровневое сжатие (4 уровня):
Разбивает данные на 2-битные блоки.
Для каждого уровня сжатия (от 0 до 3):
Итерируется по блокам парами.
Проверяет, есть ли пара блоков в словаре текущего уровня.
Если нет, создает новый хеш-код (с помощью int_to_hash) и добавляет пару блоков и хеш-код в словарь.
Если есть, использует существующий хеш-код.
Заменяет пару блоков на соответствующий хеш-код.
После 4 уровней сжатия, current_data содержит список хеш-кодов.
Преобразует хеш-коды обратно в байты, используя ALPHABET. Каждый символ хеш-кода заменяется его индексом в ALPHABET.
Динамический словарь: Словарь dictionary обновляется в процессе сжатия, что позволяет адаптироваться к входным данным.
decompress(compressed_data, dictionary):
Функция распаковки.
Принимает сжатые данные (compressed_data) и словарь (dictionary).
Преобразует сжатые байты обратно в строку хеш-кодов, используя ALPHABET (обратная операция к сжатию).
Обратное многоуровневое распаковка:
Итерируется по уровням сжатия в обратном порядке (от 3 до 0).
Для каждого уровня:
Создает обратный словарь (хеш-код -> пара блоков).
Заменяет каждый хеш-код в current_data на соответствующую пару 2-битных блоков из обратного словаря.
После 4 уровней распаковки, current_data содержит список 2-битных блоков.
Собирает 2-битные блоки обратно в байты с помощью combine_from_2bit_blocks.
save_data_file(data):
Сохраняет данные приложения (data, которые включают словарь и список файлов) в файл DATA_FILE (data.pickle) с помощью pickle. pickle используется для сериализации объектов Python в бинарный формат.
load_data_file():
Загружает данные приложения из файла DATA_FILE (data.pickle) с помощью pickle.
Миграция из JSON: Проверяет наличие файла data.json. Если он существует (вероятно, для совместимости с предыдущими версиями), загружает данные из JSON, преобразует формат словаря (ключи словаря в JSON могли быть строками, а в коде они должны быть кортежами) и сохраняет в data.pickle. data.json затем удаляется.
Если data.pickle не существует или происходит ошибка при загрузке, возвращает структуру данных по умолчанию с пустым словарем и пустым списком файлов.
Класс FileManager(root):
Класс для управления графическим интерфейсом.
__init__: Конструктор класса.
Инициализирует главное окно tkinter.
Загружает данные приложения с помощью load_data_file.
Инициализирует словарь сжатия из загруженных данных.
Создает tk.Listbox для отображения списка сжатых файлов.
Создает кнопки "Compress" и "Decompress" и связывает их с соответствующими методами класса (compress_file и decompress_file).
Вызывает update_list для заполнения списка файлов.
update_list(): Обновляет содержимое tk.Listbox, отображая список файлов из self.data["files"].
compress_file(): Метод, вызываемый при нажатии кнопки "Compress".
Открывает диалоговое окно выбора файла (filedialog.askopenfilename).
Читает содержимое выбранного файла в бинарном режиме.
Вызывает функцию compress для сжатия данных.
Создает имя выходного файла с расширением .ctxt.
Записывает сжатые данные в выходной файл в бинарном режиме.
Добавляет имя выходного файла в список self.data["files"] и сохраняет данные приложения.
Обновляет список файлов в GUI.
Выводит сообщение об успешном сжатии.
Обрабатывает ошибки и выводит сообщения об ошибках.
decompress_file(): Метод, вызываемый при нажатии кнопки "Decompress".
Получает имя выбранного файла из tk.Listbox.
Открывает диалоговое окно сохранения файла (filedialog.asksaveasfilename) для выбора места сохранения распакованного файла.
Читает содержимое выбранного сжатого файла в бинарном режиме.
Вызывает функцию decompress для распаковки данных.
Записывает распакованные данные в выбранный файл в бинарном режиме.
Выводит сообщение об успешной распаковке.
Обрабатывает ошибки и выводит сообщения об ошибках.
if __name__ == "__main__": блок:
Создает главное окно tkinter (root).
Создает экземпляр класса FileManager (app), передавая root в качестве родительского окна.
Запускает главный цикл обработки событий tkinter (root.mainloop()), который делает окно приложения интерактивным и обрабатывает действия пользователя.
В целом, код представляет собой приложение для сжатия файлов, использующее собственный алгоритм словарного сжатия в 4 уровня. Алгоритм работает, разделяя данные на 2-битные блоки и заменяя повторяющиеся пары блоков хеш-кодами. Приложение имеет простой графический интерфейс для выбора файлов для сжатия и распаковки, а также для отображения списка сжатых файлов.
Возможные улучшения и замечания:
Эффективность сжатия: Вероятно, алгоритм не является очень эффективным по сравнению со стандартными алгоритмами сжатия, такими как gzip или zip. Эффективность будет зависеть от типа данных и частоты повторения пар 2-битных блоков.
Алфавит: Очень большой и разнообразный ALPHABET может быть избыточным для большинства сценариев. Возможно, достаточно было бы использовать стандартный ASCII или более ограниченный набор символов.
Словарь: Словарь сохраняется между запусками приложения. Это может быть полезно для повторного сжатия похожих данных, но словарь может расти со временем и занимать место. Возможно, стоит добавить механизм для очистки словаря или управления его размером.
Обработка ошибок: В коде есть обработка ошибок, но ее можно расширить и сделать более информативной.
Тем не менее, код является хорошим примером реализации простого алгоритма сжатия и создания GUI приложения на Python. Он демонстрирует основные принципы словарного сжатия и использование tkinter для создания пользовательского интерфейса.
Общая структура:
Код состоит из следующих частей:
Импорт библиотек: Импортируются необходимые библиотеки для работы с файловой системой, сериализацией данных, JSON (для миграции данных), и графическим интерфейсом.
Константы: Определены константы, такие как имя файла для хранения данных (DATA_FILE), расширение для сжатых файлов (COMPRESSED_EXT), и алфавит (ALPHABET), используемый для кодирования.
Функции: Набор функций для выполнения основных операций:
int_to_hash: Преобразует целое число в хеш-строку.
split_into_2bit_blocks: Разделяет байтовые данные на блоки по 2 бита.
combine_from_2bit_blocks: Собирает 2-битные блоки обратно в байты.
compress: Функция сжатия данных.
decompress: Функция распаковки данных.
save_data_file: Сохраняет данные приложения в файл.
load_data_file: Загружает данные приложения из файла.
Класс FileManager: Класс, реализующий графический интерфейс приложения.
Основной блок if __name__ == "__main__":: Создает окно приложения и запускает главный цикл обработки событий tkinter.
Подробное описание функций и класса:
int_to_hash(n, length=5):
Берет целое число n и преобразует его в строку фиксированной длины (length, по умолчанию 5) с использованием символов из ALPHABET.
Это похоже на преобразование числа в систему счисления с основанием, равным длине ALPHABET.
Используется для создания коротких "хеш-кодов" для представления последовательностей данных в процессе сжатия.
split_into_2bit_blocks(data):
Принимает список байтов (data).
Разделяет каждый байт на 4 блока по 2 бита (старшие биты первыми).
Дополняет список блоков нулями до тех пор, пока длина не станет кратной 16.
Это подготавливает данные для многоуровневого сжатия, разбивая их на более мелкие единицы.
combine_from_2bit_blocks(blocks):
Выполняет обратную операцию к split_into_2bit_blocks.
Берет список 2-битных блоков (blocks) и собирает их обратно в байты, по 4 блока на байт.
compress(data, dictionary):
Основная функция сжатия.
Принимает байтовые данные (data) и словарь (dictionary). Словарь используется для хранения соответствий между последовательностями 2-битных блоков и их хеш-кодами.
Многоуровневое сжатие (4 уровня):
Разбивает данные на 2-битные блоки.
Для каждого уровня сжатия (от 0 до 3):
Итерируется по блокам парами.
Проверяет, есть ли пара блоков в словаре текущего уровня.
Если нет, создает новый хеш-код (с помощью int_to_hash) и добавляет пару блоков и хеш-код в словарь.
Если есть, использует существующий хеш-код.
Заменяет пару блоков на соответствующий хеш-код.
После 4 уровней сжатия, current_data содержит список хеш-кодов.
Преобразует хеш-коды обратно в байты, используя ALPHABET. Каждый символ хеш-кода заменяется его индексом в ALPHABET.
Динамический словарь: Словарь dictionary обновляется в процессе сжатия, что позволяет адаптироваться к входным данным.
decompress(compressed_data, dictionary):
Функция распаковки.
Принимает сжатые данные (compressed_data) и словарь (dictionary).
Преобразует сжатые байты обратно в строку хеш-кодов, используя ALPHABET (обратная операция к сжатию).
Обратное многоуровневое распаковка:
Итерируется по уровням сжатия в обратном порядке (от 3 до 0).
Для каждого уровня:
Создает обратный словарь (хеш-код -> пара блоков).
Заменяет каждый хеш-код в current_data на соответствующую пару 2-битных блоков из обратного словаря.
После 4 уровней распаковки, current_data содержит список 2-битных блоков.
Собирает 2-битные блоки обратно в байты с помощью combine_from_2bit_blocks.
save_data_file(data):
Сохраняет данные приложения (data, которые включают словарь и список файлов) в файл DATA_FILE (data.pickle) с помощью pickle. pickle используется для сериализации объектов Python в бинарный формат.
load_data_file():
Загружает данные приложения из файла DATA_FILE (data.pickle) с помощью pickle.
Миграция из JSON: Проверяет наличие файла data.json. Если он существует (вероятно, для совместимости с предыдущими версиями), загружает данные из JSON, преобразует формат словаря (ключи словаря в JSON могли быть строками, а в коде они должны быть кортежами) и сохраняет в data.pickle. data.json затем удаляется.
Если data.pickle не существует или происходит ошибка при загрузке, возвращает структуру данных по умолчанию с пустым словарем и пустым списком файлов.
Класс FileManager(root):
Класс для управления графическим интерфейсом.
__init__: Конструктор класса.
Инициализирует главное окно tkinter.
Загружает данные приложения с помощью load_data_file.
Инициализирует словарь сжатия из загруженных данных.
Создает tk.Listbox для отображения списка сжатых файлов.
Создает кнопки "Compress" и "Decompress" и связывает их с соответствующими методами класса (compress_file и decompress_file).
Вызывает update_list для заполнения списка файлов.
update_list(): Обновляет содержимое tk.Listbox, отображая список файлов из self.data["files"].
compress_file(): Метод, вызываемый при нажатии кнопки "Compress".
Открывает диалоговое окно выбора файла (filedialog.askopenfilename).
Читает содержимое выбранного файла в бинарном режиме.
Вызывает функцию compress для сжатия данных.
Создает имя выходного файла с расширением .ctxt.
Записывает сжатые данные в выходной файл в бинарном режиме.
Добавляет имя выходного файла в список self.data["files"] и сохраняет данные приложения.
Обновляет список файлов в GUI.
Выводит сообщение об успешном сжатии.
Обрабатывает ошибки и выводит сообщения об ошибках.
decompress_file(): Метод, вызываемый при нажатии кнопки "Decompress".
Получает имя выбранного файла из tk.Listbox.
Открывает диалоговое окно сохранения файла (filedialog.asksaveasfilename) для выбора места сохранения распакованного файла.
Читает содержимое выбранного сжатого файла в бинарном режиме.
Вызывает функцию decompress для распаковки данных.
Записывает распакованные данные в выбранный файл в бинарном режиме.
Выводит сообщение об успешной распаковке.
Обрабатывает ошибки и выводит сообщения об ошибках.
if __name__ == "__main__": блок:
Создает главное окно tkinter (root).
Создает экземпляр класса FileManager (app), передавая root в качестве родительского окна.
Запускает главный цикл обработки событий tkinter (root.mainloop()), который делает окно приложения интерактивным и обрабатывает действия пользователя.
В целом, код представляет собой приложение для сжатия файлов, использующее собственный алгоритм словарного сжатия в 4 уровня. Алгоритм работает, разделяя данные на 2-битные блоки и заменяя повторяющиеся пары блоков хеш-кодами. Приложение имеет простой графический интерфейс для выбора файлов для сжатия и распаковки, а также для отображения списка сжатых файлов.
Возможные улучшения и замечания:
Эффективность сжатия: Вероятно, алгоритм не является очень эффективным по сравнению со стандартными алгоритмами сжатия, такими как gzip или zip. Эффективность будет зависеть от типа данных и частоты повторения пар 2-битных блоков.
Алфавит: Очень большой и разнообразный ALPHABET может быть избыточным для большинства сценариев. Возможно, достаточно было бы использовать стандартный ASCII или более ограниченный набор символов.
Словарь: Словарь сохраняется между запусками приложения. Это может быть полезно для повторного сжатия похожих данных, но словарь может расти со временем и занимать место. Возможно, стоит добавить механизм для очистки словаря или управления его размером.
Обработка ошибок: В коде есть обработка ошибок, но ее можно расширить и сделать более информативной.
Тем не менее, код является хорошим примером реализации простого алгоритма сжатия и создания GUI приложения на Python. Он демонстрирует основные принципы словарного сжатия и использование tkinter для создания пользовательского интерфейса.
Этот код реализует простое приложение для сжатия и распаковки файлов с графическим интерфейсом на Python, используя библиотеку tkinter. Давайте разберем код по частям и поймем, что он делает.
Общая структура:
Код состоит из следующих частей:
Импорт библиотек: Импортируются необходимые библиотеки для работы с файловой системой, сериализацией данных, JSON (для миграции данных), и графическим интерфейсом.
Константы: Определены константы, такие как имя файла для хранения данных (DATA_FILE), расширение для сжатых файлов (COMPRESSED_EXT), и алфавит (ALPHABET), используемый для кодирования.
Функции: Набор функций для выполнения основных операций:
int_to_hash: Преобразует целое число в хеш-строку.
split_into_2bit_blocks: Разделяет байтовые данные на блоки по 2 бита.
combine_from_2bit_blocks: Собирает 2-битные блоки обратно в байты.
compress: Функция сжатия данных.
decompress: Функция распаковки данных.
save_data_file: Сохраняет данные приложения в файл.
load_data_file: Загружает данные приложения из файла.
Класс FileManager: Класс, реализующий графический интерфейс приложения.
Основной блок if __name__ == "__main__":: Создает окно приложения и запускает главный цикл обработки событий tkinter.
Подробное описание функций и класса:
int_to_hash(n, length=5):
Берет целое число n и преобразует его в строку фиксированной длины (length, по умолчанию 5) с использованием символов из ALPHABET.
Это похоже на преобразование числа в систему счисления с основанием, равным длине ALPHABET.
Используется для создания коротких "хеш-кодов" для представления последовательностей данных в процессе сжатия.
split_into_2bit_blocks(data):
Принимает список байтов (data).
Разделяет каждый байт на 4 блока по 2 бита (старшие биты первыми).
Дополняет список блоков нулями до тех пор, пока длина не станет кратной 16.
Это подготавливает данные для многоуровневого сжатия, разбивая их на более мелкие единицы.
combine_from_2bit_blocks(blocks):
Выполняет обратную операцию к split_into_2bit_blocks.
Берет список 2-битных блоков (blocks) и собирает их обратно в байты, по 4 блока на байт.
compress(data, dictionary):
Основная функция сжатия.
Принимает байтовые данные (data) и словарь (dictionary). Словарь используется для хранения соответствий между последовательностями 2-битных блоков и их хеш-кодами.
Многоуровневое сжатие (4 уровня):
Разбивает данные на 2-битные блоки.
Для каждого уровня сжатия (от 0 до 3):
Итерируется по блокам парами.
Проверяет, есть ли пара блоков в словаре текущего уровня.
Если нет, создает новый хеш-код (с помощью int_to_hash) и добавляет пару блоков и хеш-код в словарь.
Если есть, использует существующий хеш-код.
Заменяет пару блоков на соответствующий хеш-код.
После 4 уровней сжатия, current_data содержит список хеш-кодов.
Преобразует хеш-коды обратно в байты, используя ALPHABET. Каждый символ хеш-кода заменяется его индексом в ALPHABET.
Динамический словарь: Словарь dictionary обновляется в процессе сжатия, что позволяет адаптироваться к входным данным.
decompress(compressed_data, dictionary):
Функция распаковки.
Принимает сжатые данные (compressed_data) и словарь (dictionary).
Преобразует сжатые байты обратно в строку хеш-кодов, используя ALPHABET (обратная операция к сжатию).
Обратное многоуровневое распаковка:
Итерируется по уровням сжатия в обратном порядке (от 3 до 0).
Для каждого уровня:
Создает обратный словарь (хеш-код -> пара блоков).
Заменяет каждый хеш-код в current_data на соответствующую пару 2-битных блоков из обратного словаря.
После 4 уровней распаковки, current_data содержит список 2-битных блоков.
Собирает 2-битные блоки обратно в байты с помощью combine_from_2bit_blocks.
save_data_file(data):
Сохраняет данные приложения (data, которые включают словарь и список файлов) в файл DATA_FILE (data.pickle) с помощью pickle. pickle используется для сериализации объектов Python в бинарный формат.
load_data_file():
Загружает данные приложения из файла DATA_FILE (data.pickle) с помощью pickle.
Миграция из JSON: Проверяет наличие файла data.json. Если он существует (вероятно, для совместимости с предыдущими версиями), загружает данные из JSON, преобразует формат словаря (ключи словаря в JSON могли быть строками, а в коде они должны быть кортежами) и сохраняет в data.pickle. data.json затем удаляется.
Если data.pickle не существует или происходит ошибка при загрузке, возвращает структуру данных по умолчанию с пустым словарем и пустым списком файлов.
Класс FileManager(root):
Класс для управления графическим интерфейсом.
__init__: Конструктор класса.
Инициализирует главное окно tkinter.
Загружает данные приложения с помощью load_data_file.
Инициализирует словарь сжатия из загруженных данных.
Создает tk.Listbox для отображения списка сжатых файлов.
Создает кнопки "Compress" и "Decompress" и связывает их с соответствующими методами класса (compress_file и decompress_file).
Вызывает update_list для заполнения списка файлов.
update_list(): Обновляет содержимое tk.Listbox, отображая список файлов из self.data["files"].
compress_file(): Метод, вызываемый при нажатии кнопки "Compress".
Открывает диалоговое окно выбора файла (filedialog.askopenfilename).
Читает содержимое выбранного файла в бинарном режиме.
Вызывает функцию compress для сжатия данных.
Создает имя выходного файла с расширением .ctxt.
Записывает сжатые данные в выходной файл в бинарном режиме.
Добавляет имя выходного файла в список self.data["files"] и сохраняет данные приложения.
Обновляет список файлов в GUI.
Выводит сообщение об успешном сжатии.
Обрабатывает ошибки и выводит сообщения об ошибках.
decompress_file(): Метод, вызываемый при нажатии кнопки "Decompress".
Получает имя выбранного файла из tk.Listbox.
Открывает диалоговое окно сохранения файла (filedialog.asksaveasfilename) для выбора места сохранения распакованного файла.
Читает содержимое выбранного сжатого файла в бинарном режиме.
Вызывает функцию decompress для распаковки данных.
Записывает распакованные данные в выбранный файл в бинарном режиме.
Выводит сообщение об успешной распаковке.
Обрабатывает ошибки и выводит сообщения об ошибках.
if __name__ == "__main__": блок:
Создает главное окно tkinter (root).
Создает экземпляр класса FileManager (app), передавая root в качестве родительского окна.
Запускает главный цикл обработки событий tkinter (root.mainloop()), который делает окно приложения интерактивным и обрабатывает действия пользователя.
В целом, код представляет собой приложение для сжатия файлов, использующее собственный алгоритм словарного сжатия в 4 уровня. Алгоритм работает, разделяя данные на 2-битные блоки и заменяя повторяющиеся пары блоков хеш-кодами. Приложение имеет простой графический интерфейс для выбора файлов для сжатия и распаковки, а также для отображения списка сжатых файлов.
Возможные улучшения и замечания:
Эффективность сжатия: Вероятно, алгоритм не является очень эффективным по сравнению со стандартными алгоритмами сжатия, такими как gzip или zip. Эффективность будет зависеть от типа данных и частоты повторения пар 2-битных блоков.
Алфавит: Очень большой и разнообразный ALPHABET может быть избыточным для большинства сценариев. Возможно, достаточно было бы использовать стандартный ASCII или более ограниченный набор символов.
Словарь: Словарь сохраняется между запусками приложения. Это может быть полезно для повторного сжатия похожих данных, но словарь может расти со временем и занимать место. Возможно, стоит добавить механизм для очистки словаря или управления его размером.
Обработка ошибок: В коде есть обработка ошибок, но ее можно расширить и сделать более информативной.
Тем не менее, код является хорошим примером реализации простого алгоритма сжатия и создания GUI приложения на Python. Он демонстрирует основные принципы словарного сжатия и использование tkinter для создания пользовательского интерфейса.
Общая структура:
Код состоит из следующих частей:
Импорт библиотек: Импортируются необходимые библиотеки для работы с файловой системой, сериализацией данных, JSON (для миграции данных), и графическим интерфейсом.
Константы: Определены константы, такие как имя файла для хранения данных (DATA_FILE), расширение для сжатых файлов (COMPRESSED_EXT), и алфавит (ALPHABET), используемый для кодирования.
Функции: Набор функций для выполнения основных операций:
int_to_hash: Преобразует целое число в хеш-строку.
split_into_2bit_blocks: Разделяет байтовые данные на блоки по 2 бита.
combine_from_2bit_blocks: Собирает 2-битные блоки обратно в байты.
compress: Функция сжатия данных.
decompress: Функция распаковки данных.
save_data_file: Сохраняет данные приложения в файл.
load_data_file: Загружает данные приложения из файла.
Класс FileManager: Класс, реализующий графический интерфейс приложения.
Основной блок if __name__ == "__main__":: Создает окно приложения и запускает главный цикл обработки событий tkinter.
Подробное описание функций и класса:
int_to_hash(n, length=5):
Берет целое число n и преобразует его в строку фиксированной длины (length, по умолчанию 5) с использованием символов из ALPHABET.
Это похоже на преобразование числа в систему счисления с основанием, равным длине ALPHABET.
Используется для создания коротких "хеш-кодов" для представления последовательностей данных в процессе сжатия.
split_into_2bit_blocks(data):
Принимает список байтов (data).
Разделяет каждый байт на 4 блока по 2 бита (старшие биты первыми).
Дополняет список блоков нулями до тех пор, пока длина не станет кратной 16.
Это подготавливает данные для многоуровневого сжатия, разбивая их на более мелкие единицы.
combine_from_2bit_blocks(blocks):
Выполняет обратную операцию к split_into_2bit_blocks.
Берет список 2-битных блоков (blocks) и собирает их обратно в байты, по 4 блока на байт.
compress(data, dictionary):
Основная функция сжатия.
Принимает байтовые данные (data) и словарь (dictionary). Словарь используется для хранения соответствий между последовательностями 2-битных блоков и их хеш-кодами.
Многоуровневое сжатие (4 уровня):
Разбивает данные на 2-битные блоки.
Для каждого уровня сжатия (от 0 до 3):
Итерируется по блокам парами.
Проверяет, есть ли пара блоков в словаре текущего уровня.
Если нет, создает новый хеш-код (с помощью int_to_hash) и добавляет пару блоков и хеш-код в словарь.
Если есть, использует существующий хеш-код.
Заменяет пару блоков на соответствующий хеш-код.
После 4 уровней сжатия, current_data содержит список хеш-кодов.
Преобразует хеш-коды обратно в байты, используя ALPHABET. Каждый символ хеш-кода заменяется его индексом в ALPHABET.
Динамический словарь: Словарь dictionary обновляется в процессе сжатия, что позволяет адаптироваться к входным данным.
decompress(compressed_data, dictionary):
Функция распаковки.
Принимает сжатые данные (compressed_data) и словарь (dictionary).
Преобразует сжатые байты обратно в строку хеш-кодов, используя ALPHABET (обратная операция к сжатию).
Обратное многоуровневое распаковка:
Итерируется по уровням сжатия в обратном порядке (от 3 до 0).
Для каждого уровня:
Создает обратный словарь (хеш-код -> пара блоков).
Заменяет каждый хеш-код в current_data на соответствующую пару 2-битных блоков из обратного словаря.
После 4 уровней распаковки, current_data содержит список 2-битных блоков.
Собирает 2-битные блоки обратно в байты с помощью combine_from_2bit_blocks.
save_data_file(data):
Сохраняет данные приложения (data, которые включают словарь и список файлов) в файл DATA_FILE (data.pickle) с помощью pickle. pickle используется для сериализации объектов Python в бинарный формат.
load_data_file():
Загружает данные приложения из файла DATA_FILE (data.pickle) с помощью pickle.
Миграция из JSON: Проверяет наличие файла data.json. Если он существует (вероятно, для совместимости с предыдущими версиями), загружает данные из JSON, преобразует формат словаря (ключи словаря в JSON могли быть строками, а в коде они должны быть кортежами) и сохраняет в data.pickle. data.json затем удаляется.
Если data.pickle не существует или происходит ошибка при загрузке, возвращает структуру данных по умолчанию с пустым словарем и пустым списком файлов.
Класс FileManager(root):
Класс для управления графическим интерфейсом.
__init__: Конструктор класса.
Инициализирует главное окно tkinter.
Загружает данные приложения с помощью load_data_file.
Инициализирует словарь сжатия из загруженных данных.
Создает tk.Listbox для отображения списка сжатых файлов.
Создает кнопки "Compress" и "Decompress" и связывает их с соответствующими методами класса (compress_file и decompress_file).
Вызывает update_list для заполнения списка файлов.
update_list(): Обновляет содержимое tk.Listbox, отображая список файлов из self.data["files"].
compress_file(): Метод, вызываемый при нажатии кнопки "Compress".
Открывает диалоговое окно выбора файла (filedialog.askopenfilename).
Читает содержимое выбранного файла в бинарном режиме.
Вызывает функцию compress для сжатия данных.
Создает имя выходного файла с расширением .ctxt.
Записывает сжатые данные в выходной файл в бинарном режиме.
Добавляет имя выходного файла в список self.data["files"] и сохраняет данные приложения.
Обновляет список файлов в GUI.
Выводит сообщение об успешном сжатии.
Обрабатывает ошибки и выводит сообщения об ошибках.
decompress_file(): Метод, вызываемый при нажатии кнопки "Decompress".
Получает имя выбранного файла из tk.Listbox.
Открывает диалоговое окно сохранения файла (filedialog.asksaveasfilename) для выбора места сохранения распакованного файла.
Читает содержимое выбранного сжатого файла в бинарном режиме.
Вызывает функцию decompress для распаковки данных.
Записывает распакованные данные в выбранный файл в бинарном режиме.
Выводит сообщение об успешной распаковке.
Обрабатывает ошибки и выводит сообщения об ошибках.
if __name__ == "__main__": блок:
Создает главное окно tkinter (root).
Создает экземпляр класса FileManager (app), передавая root в качестве родительского окна.
Запускает главный цикл обработки событий tkinter (root.mainloop()), который делает окно приложения интерактивным и обрабатывает действия пользователя.
В целом, код представляет собой приложение для сжатия файлов, использующее собственный алгоритм словарного сжатия в 4 уровня. Алгоритм работает, разделяя данные на 2-битные блоки и заменяя повторяющиеся пары блоков хеш-кодами. Приложение имеет простой графический интерфейс для выбора файлов для сжатия и распаковки, а также для отображения списка сжатых файлов.
Возможные улучшения и замечания:
Эффективность сжатия: Вероятно, алгоритм не является очень эффективным по сравнению со стандартными алгоритмами сжатия, такими как gzip или zip. Эффективность будет зависеть от типа данных и частоты повторения пар 2-битных блоков.
Алфавит: Очень большой и разнообразный ALPHABET может быть избыточным для большинства сценариев. Возможно, достаточно было бы использовать стандартный ASCII или более ограниченный набор символов.
Словарь: Словарь сохраняется между запусками приложения. Это может быть полезно для повторного сжатия похожих данных, но словарь может расти со временем и занимать место. Возможно, стоит добавить механизм для очистки словаря или управления его размером.
Обработка ошибок: В коде есть обработка ошибок, но ее можно расширить и сделать более информативной.
Тем не менее, код является хорошим примером реализации простого алгоритма сжатия и создания GUI приложения на Python. Он демонстрирует основные принципы словарного сжатия и использование tkinter для создания пользовательского интерфейса.
>>08572 (OP)
Так ты собрал в итоге весь словарь или нет? 1 Тб вполне подъемные объемы, плюс генерация легко параллелится, думаю можно за недельку его сгенерировать.
Так ты собрал в итоге весь словарь или нет? 1 Тб вполне подъемные объемы, плюс генерация легко параллелится, думаю можно за недельку его сгенерировать.
>>08572 (OP)
блять, оп, вот я рядовой анон.
я нихуя не умею в пайтон, как мне запустить твой скрипт? чисто хотя-бы для того что-бы проверить как это сжимает пикчи и видео.
почему нету не экзешника, нихуя?только блять страничка с исходным кодом.
блять, оп, вот я рядовой анон.
я нихуя не умею в пайтон, как мне запустить твой скрипт? чисто хотя-бы для того что-бы проверить как это сжимает пикчи и видео.
почему нету не экзешника, нихуя?только блять страничка с исходным кодом.
>>15218
да на колаб собран. надо переписать код что бы он работал в 40 раз быстрее. а также как то убрать зависимости от комбинации злиб и вин рар
точнее на 900 гб создан словарь всех сжатых состояний для всех сжатых состояний в виде ссылок.
код работает медленно твои 10 гб это будет неделя. но 100кб 1 сек.
да на колаб собран. надо переписать код что бы он работал в 40 раз быстрее. а также как то убрать зависимости от комбинации злиб и вин рар
точнее на 900 гб создан словарь всех сжатых состояний для всех сжатых состояний в виде ссылок.
>Теперь делаем так: бери 10ГБ видео, "сожми" его по своей методике
код работает медленно твои 10 гб это будет неделя. но 100кб 1 сек.
>>14801
Проверь сам, я бы могла подучить языки программирования и продать метод или запилить революционные сервисы о которых тебе и не снилось, но люди умирают, тело стареет. общество деградируе
Лучше сделать метод опен сорс, и показать всем чем наживатся как жидовка над тем что понятно всем и всем на благо пойдёт.
если найдёшь метод как 2 числа в одно и обратно то и метод 900 гб словарей не нужен будет. а файл сам будет ссылкой на 5 мб блоки.
Проверь сам, я бы могла подучить языки программирования и продать метод или запилить революционные сервисы о которых тебе и не снилось, но люди умирают, тело стареет. общество деградируе
Лучше сделать метод опен сорс, и показать всем чем наживатся как жидовка над тем что понятно всем и всем на благо пойдёт.
если найдёшь метод как 2 числа в одно и обратно то и метод 900 гб словарей не нужен будет. а файл сам будет ссылкой на 5 мб блоки.
137 Кб, 1280x538>>15389
скачиваешь питон, 30 мб. устанавливаешь. потом кликаешь на скрипт он запустится. но код работает медленно и создаёт базу больше чем файл. база перестаёт расти после 900 гб.
Вот ИИ без реги и лимитов, у него спрашивай
https://www.blackbox.ai/
скачиваешь питон, 30 мб. устанавливаешь. потом кликаешь на скрипт он запустится. но код работает медленно и создаёт базу больше чем файл. база перестаёт расти после 900 гб.
Вот ИИ без реги и лимитов, у него спрашивай
https://www.blackbox.ai/
>>12620
/thread
/thread
>>15540
блять, ну пиздец, мне ещё и 1 тб надо для твоей проги.
пиздос, неее, ну нахуй. сжатие это конечно ахуенно, но лишнего тб под твой псевдосжимающий скрипт у меня нет.
блять, ну пиздец, мне ещё и 1 тб надо для твоей проги.
пиздос, неее, ну нахуй. сжатие это конечно ахуенно, но лишнего тб под твой псевдосжимающий скрипт у меня нет.
>>08572 (OP)
Сжал тебе хуй за щеку, проверяй.
Сжал тебе хуй за щеку, проверяй.
>>15649
Ну так ты 1 тб в 1 мб сможешь сжать рекурсивно. Ну правдо в ручном режиме. Ты не кодер и не учёный-учёная. , ты не поймёшь
Ну так ты 1 тб в 1 мб сможешь сжать рекурсивно. Ну правдо в ручном режиме. Ты не кодер и не учёный-учёная. , ты не поймёшь
>>15476
Словарь будет нужен в любом случае, плюс ебучее железо на архивацию туда-обратно, то есть метод оправдан только там где канал не позволяет передать данные, но всё остальное в достатке, по этому мы передаём хэши от словаря, идея и код достаточно примитивные.
>>15691
Сжатые папки не годятся, тебе нужно дохулиард операций чтения сделать, нужно вменяемое хранилище заточенное чисто под чтение, для оптимизации нужна статистика по ключам чтобы не держать в памяти редкие вхождения, тогда можно сэкономить, но на текущем уровне придётся держать в памяти всё.
Словарь будет нужен в любом случае, плюс ебучее железо на архивацию туда-обратно, то есть метод оправдан только там где канал не позволяет передать данные, но всё остальное в достатке, по этому мы передаём хэши от словаря, идея и код достаточно примитивные.
>>15691
Сжатые папки не годятся, тебе нужно дохулиард операций чтения сделать, нужно вменяемое хранилище заточенное чисто под чтение, для оптимизации нужна статистика по ключам чтобы не держать в памяти редкие вхождения, тогда можно сэкономить, но на текущем уровне придётся держать в памяти всё.
>>08572 (OP)
Этот код реализует четырёхуровневое словарное сжатие, но не обеспечивает бесконечного сжатия. Разбираю его логику:
Как работает сжатие?
Разбивка данных на 2-битные блоки
Каждый байт (8 бит) разбивается на четыре 2-битных блока.
Это увеличивает размер данных в 4 раза, но делает возможным поиск повторяющихся пар.
Создание словаря (4 уровня)
На первом уровне пара 2-битных блоков заменяется короткой строкой (hash) из заранее заданного алфавита.
Полученный новый список снова сжимается парами на втором уровне и так до четвёртого уровня.
Если файл полностью сжимается до 1 символа, процесс останавливается.
Сохранение словаря
Словарь сохраняется в data.json. Это значит, что для разжатия нужен этот же словарь.
Обратная распаковка
Строка расшифровывается обратно, начиная с четвёртого уровня и двигаясь вниз, пока не будут восстановлены 2-битные блоки.
Затем блоки собираются обратно в байты.
Почему метод не работает для "вечного" сжатия?
При каждом уровне сжатия словарь увеличивается экспоненциально
Уровень 0: 16 пар (32 бита) → 16 записей в словаре
Уровень 1: 256 пар → 256 записей
Уровень 2: 65 536 пар → 65 536 записей
Уровень 3: 4 294 967 296 пар → 34 ГБ памяти!
Фактически, словарь растёт быстрее, чем размер файла уменьшается!
RAR и ZIP могут дополнительно сжимать, потому что в этом коде есть избыточность
После сжатия полученная строка всё ещё содержит повторяющиеся шаблоны, которые стандартные архиваторы могут удалить.
Это доказывает, что метод не делает данные максимально компактными.
Без словаря файл нельзя разжать
В отличие от RAR, ZIP или LZMA, где алгоритм одинаков для всех файлов, здесь каждому файлу нужен свой словарь.
Без data.json файл становится бесполезным.
Вывод
Этот код не является методом бесконечного сжатия, а просто многоуровневой хеш-таблицей, которая быстро достигает предела памяти.
Что можно улучшить?
Оптимизировать хранение словаря, убрав самые редкие комбинации.
Добавить ограничение на уровни, чтобы не уходить в 34 ГБ RAM.
Использовать стандартные алгоритмы (например, LZ77, Huffman, ANS), которые доказали свою эффективность.
Этот код реализует четырёхуровневое словарное сжатие, но не обеспечивает бесконечного сжатия. Разбираю его логику:
Как работает сжатие?
Разбивка данных на 2-битные блоки
Каждый байт (8 бит) разбивается на четыре 2-битных блока.
Это увеличивает размер данных в 4 раза, но делает возможным поиск повторяющихся пар.
Создание словаря (4 уровня)
На первом уровне пара 2-битных блоков заменяется короткой строкой (hash) из заранее заданного алфавита.
Полученный новый список снова сжимается парами на втором уровне и так до четвёртого уровня.
Если файл полностью сжимается до 1 символа, процесс останавливается.
Сохранение словаря
Словарь сохраняется в data.json. Это значит, что для разжатия нужен этот же словарь.
Обратная распаковка
Строка расшифровывается обратно, начиная с четвёртого уровня и двигаясь вниз, пока не будут восстановлены 2-битные блоки.
Затем блоки собираются обратно в байты.
Почему метод не работает для "вечного" сжатия?
При каждом уровне сжатия словарь увеличивается экспоненциально
Уровень 0: 16 пар (32 бита) → 16 записей в словаре
Уровень 1: 256 пар → 256 записей
Уровень 2: 65 536 пар → 65 536 записей
Уровень 3: 4 294 967 296 пар → 34 ГБ памяти!
Фактически, словарь растёт быстрее, чем размер файла уменьшается!
RAR и ZIP могут дополнительно сжимать, потому что в этом коде есть избыточность
После сжатия полученная строка всё ещё содержит повторяющиеся шаблоны, которые стандартные архиваторы могут удалить.
Это доказывает, что метод не делает данные максимально компактными.
Без словаря файл нельзя разжать
В отличие от RAR, ZIP или LZMA, где алгоритм одинаков для всех файлов, здесь каждому файлу нужен свой словарь.
Без data.json файл становится бесполезным.
Вывод
Этот код не является методом бесконечного сжатия, а просто многоуровневой хеш-таблицей, которая быстро достигает предела памяти.
Что можно улучшить?
Оптимизировать хранение словаря, убрав самые редкие комбинации.
Добавить ограничение на уровни, чтобы не уходить в 34 ГБ RAM.
Использовать стандартные алгоритмы (например, LZ77, Huffman, ANS), которые доказали свою эффективность.
>>08572 (OP)
Этот код реализует четырёхуровневое словарное сжатие, но не обеспечивает бесконечного сжатия. Разбираю его логику:
Как работает сжатие?
Разбивка данных на 2-битные блоки
Каждый байт (8 бит) разбивается на четыре 2-битных блока.
Это увеличивает размер данных в 4 раза, но делает возможным поиск повторяющихся пар.
Создание словаря (4 уровня)
На первом уровне пара 2-битных блоков заменяется короткой строкой (hash) из заранее заданного алфавита.
Полученный новый список снова сжимается парами на втором уровне и так до четвёртого уровня.
Если файл полностью сжимается до 1 символа, процесс останавливается.
Сохранение словаря
Словарь сохраняется в data.json. Это значит, что для разжатия нужен этот же словарь.
Обратная распаковка
Строка расшифровывается обратно, начиная с четвёртого уровня и двигаясь вниз, пока не будут восстановлены 2-битные блоки.
Затем блоки собираются обратно в байты.
Почему метод не работает для "вечного" сжатия?
При каждом уровне сжатия словарь увеличивается экспоненциально
Уровень 0: 16 пар (32 бита) → 16 записей в словаре
Уровень 1: 256 пар → 256 записей
Уровень 2: 65 536 пар → 65 536 записей
Уровень 3: 4 294 967 296 пар → 34 ГБ памяти!
Фактически, словарь растёт быстрее, чем размер файла уменьшается!
RAR и ZIP могут дополнительно сжимать, потому что в этом коде есть избыточность
После сжатия полученная строка всё ещё содержит повторяющиеся шаблоны, которые стандартные архиваторы могут удалить.
Это доказывает, что метод не делает данные максимально компактными.
Без словаря файл нельзя разжать
В отличие от RAR, ZIP или LZMA, где алгоритм одинаков для всех файлов, здесь каждому файлу нужен свой словарь.
Без data.json файл становится бесполезным.
Вывод
Этот код не является методом бесконечного сжатия, а просто многоуровневой хеш-таблицей, которая быстро достигает предела памяти.
Что можно улучшить?
Оптимизировать хранение словаря, убрав самые редкие комбинации.
Добавить ограничение на уровни, чтобы не уходить в 34 ГБ RAM.
Использовать стандартные алгоритмы (например, LZ77, Huffman, ANS), которые доказали свою эффективность.
Этот код реализует четырёхуровневое словарное сжатие, но не обеспечивает бесконечного сжатия. Разбираю его логику:
Как работает сжатие?
Разбивка данных на 2-битные блоки
Каждый байт (8 бит) разбивается на четыре 2-битных блока.
Это увеличивает размер данных в 4 раза, но делает возможным поиск повторяющихся пар.
Создание словаря (4 уровня)
На первом уровне пара 2-битных блоков заменяется короткой строкой (hash) из заранее заданного алфавита.
Полученный новый список снова сжимается парами на втором уровне и так до четвёртого уровня.
Если файл полностью сжимается до 1 символа, процесс останавливается.
Сохранение словаря
Словарь сохраняется в data.json. Это значит, что для разжатия нужен этот же словарь.
Обратная распаковка
Строка расшифровывается обратно, начиная с четвёртого уровня и двигаясь вниз, пока не будут восстановлены 2-битные блоки.
Затем блоки собираются обратно в байты.
Почему метод не работает для "вечного" сжатия?
При каждом уровне сжатия словарь увеличивается экспоненциально
Уровень 0: 16 пар (32 бита) → 16 записей в словаре
Уровень 1: 256 пар → 256 записей
Уровень 2: 65 536 пар → 65 536 записей
Уровень 3: 4 294 967 296 пар → 34 ГБ памяти!
Фактически, словарь растёт быстрее, чем размер файла уменьшается!
RAR и ZIP могут дополнительно сжимать, потому что в этом коде есть избыточность
После сжатия полученная строка всё ещё содержит повторяющиеся шаблоны, которые стандартные архиваторы могут удалить.
Это доказывает, что метод не делает данные максимально компактными.
Без словаря файл нельзя разжать
В отличие от RAR, ZIP или LZMA, где алгоритм одинаков для всех файлов, здесь каждому файлу нужен свой словарь.
Без data.json файл становится бесполезным.
Вывод
Этот код не является методом бесконечного сжатия, а просто многоуровневой хеш-таблицей, которая быстро достигает предела памяти.
Что можно улучшить?
Оптимизировать хранение словаря, убрав самые редкие комбинации.
Добавить ограничение на уровни, чтобы не уходить в 34 ГБ RAM.
Использовать стандартные алгоритмы (например, LZ77, Huffman, ANS), которые доказали свою эффективность.
Давай подумаем логически, без математики, программирования и прочих расчетов. Можно ли сжимать информацию бесконечно в принципе. Очевидно что нет. Из одного бита ничего извлечь нельзя, будь у тебя хоть миллион терабайт ключей и баз. Значит нижняя граница есть. Ее не может не быть.
Это классическая идея вечного сжатия, но она нарушает фундаментальные принципы теории информации. Клод Шеннон и Курт Гёдель доказали, что любой метод сжатия без потерь ограничен энтропией данных. Если бы такая система работала, можно было бы сжать любое количество информации до нуля и восстановить её, что противоречит математике.
Почему метод не работает?
Сжатие нельзя делать бесконечно – Любое кодирование приводит к тому, что словарь растёт быстрее, чем сжатые данные. В конце концов, хранение словаря требует больше места, чем сами данные.
"Словарь 4 уровня" – Это просто дедупликация данных, но она не даёт магического выигрыша. ZIP, RAR и другие алгоритмы уже используют словари, но их эффективность ограничена.
RAR не сжимает за счёт магии – Если после "сжатия" в этой системе RAR даёт дополнительное уменьшение, значит, "сжатый" файл всё ещё содержит избыточность, которую RAR может удалить.
Почему метод не работает?
Сжатие нельзя делать бесконечно – Любое кодирование приводит к тому, что словарь растёт быстрее, чем сжатые данные. В конце концов, хранение словаря требует больше места, чем сами данные.
"Словарь 4 уровня" – Это просто дедупликация данных, но она не даёт магического выигрыша. ZIP, RAR и другие алгоритмы уже используют словари, но их эффективность ограничена.
RAR не сжимает за счёт магии – Если после "сжатия" в этой системе RAR даёт дополнительное уменьшение, значит, "сжатый" файл всё ещё содержит избыточность, которую RAR может удалить.
344 Кб, 736x736ЗАВЯЗЫВАЕШЬ БОТИНКИ
@
В ПРОЦЕССЕ ПИШЕШЬ ЦЕЛЫЙ ТАЛМУД, КАК ТЫ ЗАВЯЗЫВАЕШЬ БОТИНКИ НОВЫМ АХУЕННЫМ СПОСОБОМ
@
БОТИНКИ ОСТАЮТСЯ РАЗВЯЗАННЫМИ, ВМЕСТО УЗЛОВ КАКАЯ-ТО ХУИТА
@
СПЕЦИАЛЬНО ОБУЧЕННЫЙ ЗАВЯЗЫВАТЕЛЬ БОТИНОК ЗАВЯЗЫВАЕТ БОТИНКИ ЗА ТЕБЯ
@
БЕЖИШЬ НА ДВАЧ РАССКАЗЫВАТЬ, КАК ТЫ ОХУЕННО ЗАВЯЗАЛ БОТИНКИ
@
В ПРОЦЕССЕ ПИШЕШЬ ЦЕЛЫЙ ТАЛМУД, КАК ТЫ ЗАВЯЗЫВАЕШЬ БОТИНКИ НОВЫМ АХУЕННЫМ СПОСОБОМ
@
БОТИНКИ ОСТАЮТСЯ РАЗВЯЗАННЫМИ, ВМЕСТО УЗЛОВ КАКАЯ-ТО ХУИТА
@
СПЕЦИАЛЬНО ОБУЧЕННЫЙ ЗАВЯЗЫВАТЕЛЬ БОТИНОК ЗАВЯЗЫВАЕТ БОТИНКИ ЗА ТЕБЯ
@
БЕЖИШЬ НА ДВАЧ РАССКАЗЫВАТЬ, КАК ТЫ ОХУЕННО ЗАВЯЗАЛ БОТИНКИ
75 Кб, 2048x2048>>08572 (OP)
У меня была такая штука как на первом пике
У меня была такая штука как на первом пике
>>15716
Сжать-то можно, но словарь для такой распаковки будет занимать миллион терабайт.
>Ну так ты 1 тб в 1 мб сможешь сжать рекурсивно. Ну правдо в ручном режиме. Ты не кодер и не учёный-учёная. , ты не поймёшь
Сжать-то можно, но словарь для такой распаковки будет занимать миллион терабайт.
>>16554
НЕТ 900 ГБ Я СКОЗАЛ
НЕТ 900 ГБ Я СКОЗАЛ
12 Кб, 558x252>>08572 (OP)
хуита, после декомпрессии файл уже не открывается, залупа
хуита, после декомпрессии файл уже не открывается, залупа
137 Кб, 1280x538>>16554
на гугл колабе доказано что после 900гб не растёт.
>>15909
у чела с помощью обратимой хеш функции был 300 мб словарь.
>>16375
успех gta никто не повторил и движок лучше не создал, гениев единицы, и плохо когда они шифруются или прячут
это не сжатие, это запись строк для словаря рекурсивно где словаь описывает словарь, самая простая функция это круг, бесконечная рекурсия, где только циклы определяют скок кругов ты намотаешь
>>16134
если думать логически то и двигателей внутренего сгорания и летающего метала быть не должно, ведь топливо и самолёт имеет вес. а всё что имеет вес не может летать. да?
на гугл колабе доказано что после 900гб не растёт.
>>15909
у чела с помощью обратимой хеш функции был 300 мб словарь.
>>16375
успех gta никто не повторил и движок лучше не создал, гениев единицы, и плохо когда они шифруются или прячут
>Это классическая идея вечного сжатия,
это не сжатие, это запись строк для словаря рекурсивно где словаь описывает словарь, самая простая функция это круг, бесконечная рекурсия, где только циклы определяют скок кругов ты намотаешь
>>16134
если думать логически то и двигателей внутренего сгорания и летающего метала быть не должно, ведь топливо и самолёт имеет вес. а всё что имеет вес не может летать. да?
>>16477
Вместо mesh p2p ради интернета
все платят провайдерам и пользуются интернетами через провайдеров
ручная рация моторола на 10 км передаёт инфу и может 10 кб сек кодировать
Вместо mesh p2p ради интернета
все платят провайдерам и пользуются интернетами через провайдеров
ручная рация моторола на 10 км передаёт инфу и может 10 кб сек кодировать
>>09514
давай
1. сожми каждое значение по отдельности:
00
01
10
11
2. напиши как будет записываться "11" в сжатом тобою виде
>Давай очень по простому.
давай
1. сожми каждое значение по отдельности:
00
01
10
11
2. напиши как будет записываться "11" в сжатом тобою виде
>>16791
У шиза словарь перестал расти, потому что коллаб на 11% заебался эту хуйню делать, я правильно понимаю?
>пик
У шиза словарь перестал расти, потому что коллаб на 11% заебался эту хуйню делать, я правильно понимаю?
>>08719
Да, снова за щеку будьте любезны.
Да, снова за щеку будьте любезны.
>>16791
Может не растёт, а может они тебе подрезали из-за оверхеда по операциям, ты проверял по-факту что там за словарь? Работает ли он должным образом?
>на гугл колабе доказано что после 900гб не растёт.
Может не растёт, а может они тебе подрезали из-за оверхеда по операциям, ты проверял по-факту что там за словарь? Работает ли он должным образом?
>>08572 (OP)
Сцуко, сколько уже этих тредов было И, БЛЯДЬ, НИОДНОГО ПРИМЕРА, СЦУКО, КАК РАБОТАЕТ ПРОГРАММА,пздц нхблд.
Где пример работы самый простой до и после сжатия? Вы как будто Санто-Барбору сжимаете
Сцуко, сколько уже этих тредов было И, БЛЯДЬ, НИОДНОГО ПРИМЕРА, СЦУКО, КАК РАБОТАЕТ ПРОГРАММА,пздц нхблд.
Где пример работы самый простой до и после сжатия? Вы как будто Санто-Барбору сжимаете
>>08572 (OP)
Пиздец шизов в треде корёжит от такой простой и гениальной идеи.
Пиздец шизов в треде корёжит от такой простой и гениальной идеи.
Почему тут все смеются над ОПом, он каждую неделю эти треды создаёт. Может кто-то объяснит, почуму ОП прав или не прав?Почему эти словари не используют?
мимо гуманитарий
мимо гуманитарий
>>17432
ето все заговор, ученые в говне моченые дурят всех словари не используют, на ноль не умножают
ето все заговор, ученые в говне моченые дурят всех словари не используют, на ноль не умножают
162 Кб, 1663x877не работает, оп - шиз
В первом посте старый пост и ручной пошаговый режим, вот автоматический + исходный код работает в 4 раза быстрей
https://drive.google.com/file/d/1SuTGcCMEDa_PVglfmwccYzJu_-pcQ8D8/view
https://drive.google.com/file/d/1SuTGcCMEDa_PVglfmwccYzJu_-pcQ8D8/view
52 Кб, 900x563>>18078
А смысл твоего словаря, если твой говнокод не сжимает ничего?
А смысл твоего словаря, если твой говнокод не сжимает ничего?
Аноньчики, объясните лор этого треда, а то я сколько раз на него натыкаюсь – ничего не пынемаю.
С меня нак всегда.
С меня нак всегда.
ИИ маска после 1 мин рассуждений сказал что общий словарь рекурсии будет 94 ГБ. навсегда.
Вот полный ответ.
Вот полный ответ.
>>08572 (OP)
Хуита, переделывай. Архиватор бабушкина сжимает любые файлы до 4 килобайт, и огромный словарь ему не требуется.
Хуита, переделывай. Архиватор бабушкина сжимает любые файлы до 4 килобайт, и огромный словарь ему не требуется.
89 Кб, 895x819И так ребят, полный словарь занимает 94 гб. НО в колабе была ошибка что он генерировался как 1 процесс, этот процесс в ходе сжатия и расжатия потреблял в 10 раз больше памяти. Вместо блочного и потокового
Что нужно сделать:
1) переписать на С++ или CUDA
2) переписать логику что бы не ел 34 ГБ RАМ постоянного словаря а ток с SSD
3) Добавить рекурсию после сжатия для нового сжатия
Принцип Работы, файл сжимается, размер его сохраняется но это теперь файл это ссылки на 94 гб словарь. Магия в том, что если поместить сжатый файл в ZIP и RAR то его размер в 10-20 раз МЕНЬШЕ ОРИГИНАЛА, И его можно восстановить из ОБЩЕГО СЛОВАРЯ. который постоянный 94 гб!
Что нужно сделать:
1) переписать на С++ или CUDA
2) переписать логику что бы не ел 34 ГБ RАМ постоянного словаря а ток с SSD
3) Добавить рекурсию после сжатия для нового сжатия
Принцип Работы, файл сжимается, размер его сохраняется но это теперь файл это ссылки на 94 гб словарь. Магия в том, что если поместить сжатый файл в ZIP и RAR то его размер в 10-20 раз МЕНЬШЕ ОРИГИНАЛА, И его можно восстановить из ОБЩЕГО СЛОВАРЯ. который постоянный 94 гб!
142 Кб, 760x760>>19179
А архиватор Попова какие результаты выдает?
А архиватор Попова какие результаты выдает?
>>18864
94 гб может быть без учета кодировки юникод, без учета спецсимволов разметки формата жсон и так далее, со всеми потрохами конечный файл наверное в терабайт и получается.
94 гб может быть без учета кодировки юникод, без учета спецсимволов разметки формата жсон и так далее, со всеми потрохами конечный файл наверное в терабайт и получается.
Ну нахуя эти трэды??? блядь возьми и сожми тогда Атомик Харт например и сюда залей раз такие умные
>>20548
Нужен словарь вменяемого формата и декодер который распаковывает быстрее чем за неделю.
Нужен словарь вменяемого формата и декодер который распаковывает быстрее чем за неделю.
>>12308
Дурной чи шо?
Попробуй снова прогнать генерацию из сида и промта. А потом сравни файлы визуально, ну и их хэш-суммы. Хотя чего это я.
Дурной чи шо?
Попробуй снова прогнать генерацию из сида и промта. А потом сравни файлы визуально, ну и их хэш-суммы. Хотя чего это я.