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

Вызов:

Напишите две программы : одну для сжатия текста ASCII в последовательность байтов, а другую для его распаковки. Программы не обязательно должны быть на одном языке.

Первая программа должна прочитать часть текста ASCII (из файла или из стандартного ввода, или используя любой механизм, наиболее естественный для языка) и вывести его сжатую версию. (Сжатый вывод может состоять или из произвольных байтов; он не должен быть читаемым.) Вторая программа должна прочитать вывод первого и воссоздать исходный входной текст.

Подсчет очков:

Оценка решения будет суммой следующих трех подсчетов:

1. Длина компрессора программы в символах.
2. Длина выхода компрессора, учитывая тестовый вход ниже, в байтах.
3. Длина декомпрессора программы (если он отличается от компрессора) в символах.

Вы должны отметить все три счета и их сумму в вашем ответе. Так как это кодовый гольф, чем ниже оценка, тем лучше.

Правила и ограничения:

• Вы не можете использовать какие-либо ранее существующие инструменты или библиотеки сжатия или распаковки, даже если они поставляются в комплекте с выбранным вами языком. Если вы сомневаетесь в том, разрешен ли данный инструмент или функция, спросите.

• Ваша программа компрессора должна быть способна обрабатывать ввод, состоящий из любого печатного текста ASCII , включая вкладки (ASCII 9) и переводы строк (ASCII 10). Вы можете, но не обязаны обрабатывать произвольный Unicode и / или двоичный ввод.

• Ваша программа декомпрессора должна производить точно такой же выходной сигнал, который был дан компрессору в качестве входного. В частности, будьте осторожны, чтобы не выводить завершающий перевод строки, если он не был введен. (Тестовый ввод ниже имеет задний перевод строки, поэтому вам нужно проверить это отдельно. Совет для GolfScript:. '':n)

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

• Программы не должны быть слишком медленными или требовательными к памяти . Если сжатие или распаковка тестового ввода займет больше минуты на моем не очень новом настольном компьютере (2,2 ГГц AMD Athlon64 X2) или потребляет больше гигабайта оперативной памяти, я считаю решение недействительным. Эти ограничения намеренно невелики - пожалуйста, постарайтесь их не подталкивать. (См. Поправку ниже: вы должны иметь возможность обрабатывать не менее 100 кБ входных данных в этих пределах.)

• Несмотря на то, что для оценки важен только тестовый ввод, вы должны по крайней мере приложить усилия для сжатия произвольного входного текста. Решение, которое достигает приемлемой степени сжатия только для тестового ввода и ни для чего другого, является технически обоснованным, но от меня не получит одобрения.

• Ваши программы компрессора и декомпрессора должны быть автономными . В частности, если они зависят от возможности чтения какого-либо файла или сетевого ресурса, который не является частью стандартной среды выполнения выбранного вами языка, длина этого файла или ресурса должна учитываться как часть длины программы (программ). (Это позволяет запретить «компрессоры», которые сравнивают входные данные с файлом в сети и выводят нулевые байты, если они совпадают. Извините, но это уже не новый трюк.)

Поправки и уточнения:

• Ваш компрессор должен быть в состоянии обрабатывать файлы, содержащие не менее 100 КБ типичного текста на английском языке, в течение разумного времени и использования памяти (не более одной минуты и одного ГБ памяти). Ваш декомпрессор должен быть в состоянии распаковать результирующий выход в тех же пределах. Конечно, возможность обрабатывать файлы дольше, чем это, прекрасно и похвально. Можно разбивать длинные входные файлы на куски и сжимать их по отдельности или использовать другие средства для снижения эффективности сжатия и скорости для длинных входов.

• Ваш компрессор может потребовать, чтобы его входные данные были даны с использованием собственного представления новой строки (LF, CR + LF, CR и т. Д.) Предпочитаемой платформы , если ваш декомпрессор использует то же представление новой строки в своих выходных данных. Конечно, также хорошо для компрессора принимать любые новые строки (или даже только новые строки Unix независимо от платформы), пока ваш декомпрессор выводит те же самые новые строки, что и в исходном вводе.

Тестовый ввод:

Чтобы оценить эффективность сжатия ответов, будет использован следующий тестовый ввод ( The Raven Эдгара По, любезно предоставленный Project Gutenberg ):

Once upon a midnight dreary, while I pondered, weak and weary,
Over many a quaint and curious volume of forgotten lore,
While I nodded, nearly napping, suddenly there came a tapping,
As of some one gently rapping, rapping at my chamber door.
"'T is some visiter," I muttered, "tapping at my chamber door--
                                          Only this, and nothing more."

Ah, distinctly I remember it was in the bleak December,
And each separate dying ember wrought its ghost upon the floor.
Eagerly I wished the morrow:--vainly I had sought to borrow
From my books surcease of sorrow--sorrow for the lost Lenore--
For the rare and radiant maiden whom the angels name Lenore--
                                          Nameless here for evermore.

And the silken sad uncertain rustling of each purple curtain
Thrilled me--filled me with fantastic terrors never felt before;
So that now, to still the beating of my heart, I stood repeating
"'T is some visiter entreating entrance at my chamber door
Some late visiter entreating entrance at my chamber door;--
                                          This it is, and nothing more."

Presently my soul grew stronger; hesitating then no longer,
"Sir," said I, "or Madam, truly your forgiveness I implore;
But the fact is I was napping, and so gently you came rapping,
And so faintly you came tapping, tapping at my chamber door,
That I scarce was sure I heard you"--here I opened wide the door;--
                                          Darkness there, and nothing more.

Deep into that darkness peering, long I stood there wondering, fearing,
Doubting, dreaming dreams no mortal ever dared to dream before;
But the silence was unbroken, and the darkness gave no token,
And the only word there spoken was the whispered word, "Lenore!"
This I whispered, and an echo murmured back the word, "Lenore!"
                                          Merely this and nothing more.

Back into the chamber turning, all my soul within me burning,
Soon again I heard a tapping, somewhat louder than before.
"Surely," said I, "surely that is something at my window lattice;
Let me see, then, what thereat is, and this mystery explore--
Let my heart be still a moment and this mystery explore;--
                                          'T is the wind and nothing more!"

Open here I flung the shutter, when, with many a flirt and flutter,
In there stepped a stately Raven of the saintly days of yore.
Not the least obeisance made he; not a minute stopped or stayed he;
But, with mien of lord or lady, perched above my chamber door--
Perched upon a bust of Pallas just above my chamber door--
                                          Perched, and sat, and nothing more.

Then this ebony bird beguiling my sad fancy into smiling,
By the grave and stern decorum of the countenance it wore,
"Though thy crest be shorn and shaven, thou," I said, "art sure no craven,
Ghastly grim and ancient Raven wandering from the Nightly shore,--
Tell me what thy lordly name is on the Night's Plutonian shore!"
                                          Quoth the Raven, "Nevermore."

Much I marvelled this ungainly fowl to hear discourse so plainly,
Though its answer little meaning--little relevancy bore;
For we cannot help agreeing that no living human being
Ever yet was blessed with seeing bird above his chamber door--
Bird or beast upon the sculptured bust above his chamber door,
                                          With such name as "Nevermore."

But the Raven, sitting lonely on the placid bust, spoke only
That one word, as if his soul in that one word he did outpour.
Nothing further then he uttered--not a feather then he fluttered--
Till I scarcely more than muttered, "Other friends have flown before--
On the morrow _he_ will leave me, as my hopes have flown before."
                                          Then the bird said, "Nevermore."

Startled at the stillness broken by reply so aptly spoken,
"Doubtless," said I, "what it utters is its only stock and store,
Caught from some unhappy master whom unmerciful Disaster
Followed fast and followed faster till his songs one burden bore--
Till the dirges of his Hope that melancholy burden bore
                                          Of 'Never--nevermore.'"

But the Raven still beguiling all my sad soul into smiling,
Straight I wheeled a cushioned seat in front of bird and bust and door;
Then, upon the velvet sinking, I betook myself to linking
Fancy unto fancy, thinking what this ominous bird of yore--
What this grim, ungainly, ghastly, gaunt and ominous bird of yore
                                          Meant in croaking "Nevermore."

This I sat engaged in guessing, but no syllable expressing
To the fowl whose fiery eyes now burned into my bosom's core;
This and more I sat divining, with my head at ease reclining
On the cushion's velvet lining that the lamplight gloated o'er,
But whose velvet violet lining with the lamplight gloating o'er
                                          _She_ shall press, ah, nevermore!

Then, methought, the air grew denser, perfumed from an unseen censer
Swung by seraphim whose foot-falls tinkled on the tufted floor.
"Wretch," I cried, "thy God hath lent thee--by these angels he hath sent thee
Respite--respite and nepenthe from thy memories of Lenore!
Quaff, oh quaff this kind nepenthe, and forget this lost Lenore!"
                                          Quoth the Raven, "Nevermore."

"Prophet!" said I, "thing of evil!--prophet still, if bird or devil!--
Whether Tempter sent, or whether tempest tossed thee here ashore,
Desolate yet all undaunted, on this desert land enchanted--
On this home by Horror haunted--tell me truly, I implore--
Is there--_is_ there balm in Gilead?--tell me--tell me, I implore!"
                                          Quoth the Raven, "Nevermore."

"Prophet!" said I, "thing of evil--prophet still, if bird or devil!
By that Heaven that bends above, us--by that God we both adore--
Tell this soul with sorrow laden if, within the distant Aidenn,
It shall clasp a sainted maiden whom the angels name Lenore--
Clasp a rare and radiant maiden whom the angels name Lenore."
                                          Quoth the Raven, "Nevermore."

"Be that word our sign of parting, bird or fiend!" I shrieked, upstarting--
"Get thee back into the tempest and the Night's Plutonian shore!
Leave no black plume as a token of that lie thy soul hath spoken!
Leave my loneliness unbroken!--quit the bust above my door!
Take thy beak from out my heart, and take thy form from off my door!"
                                          Quoth the Raven, "Nevermore."

And the Raven, never flitting, still is sitting, still is sitting
On the pallid bust of Pallas just above my chamber door;
And his eyes have all the seeming of a demon's that is dreaming,
And the lamplight o'er him streaming throws his shadow on the floor;
And my soul from out that shadow that lies floating on the floor
                                          Shall be lifted--nevermore!

Правильный тестовый ввод (закодированный с помощью новых строк LF в Unix-стиле) должен иметь длину 7043 байта и иметь шестнадцатеричный хэш MD5 286206abbb7eca7b1ab69ea4b81da227. (md5sum -t должно выдавать то же значение хеш-функции, даже если вы используете переводы строк CR + LF в DOS / Windows.) Вывод вашего декомпрессора должен иметь одинаковую длину и хеш-код.

Ps. Имейте в виду, что этот вызов настолько сложен, насколько вы его делаете. Действительно, все, что меньше 7043, считается хорошим результатом. (На другом конце шкалы я буду очень впечатлен, если кто-нибудь достигнет отметки менее 2500).

Perl, 3502 = 133 + 3269 + 100

Кодировщик:

#!/usr/bin/perl -0
$_=<>;for$e(map{~chr}0..255){++$p{$_}for/..|.\G./gs;
%p=$s=(sort{$p{$a}<=>$p{$b}}keys%p)[-1];$d.=/\Q$e/?$/:s/\Q$s/$e/g&&$s}print$_,$d

И декодер:

#!/usr/bin/perl -0777
sub d{($p=$d{$_})?d(@$p):print for@_}
sub r{%d=map{chr,ord($c=pop)&&[pop,$c]}0..255;&d}r<>=~/./gs

Для пуристов, которые предпочитают избегать использования переключателей командной строки: Вы можете удалить строку shebang и добавить $/=chr;к кодировщику и $/=$,;декодеру, чтобы получить тот же эффект. (Это довело бы счет до 3510.)

Этот код использует очень примитивную схему сжатия:

• Найдите биграмму из двух символов, которая чаще всего встречается в исходном тексте.
• Замените биграмму неиспользованным байтовым значением.
• Повторяйте до тех пор, пока больше не будет повторных биграмм (или больше не будет неиспользуемых значений байтов).

Кто-то может распознать это как упрощенную версию сжатия «повторных пар» (сокращение от рекурсивных пар).

Это не очень хорошая общая схема сжатия. Он хорошо работает только с такими вещами, как текст ASCII, где есть много неиспользуемых байтовых значений, и даже тогда он обычно имеет соотношение не более 45-50%. Тем не менее, он имеет преимущество в том, что его можно реализовать с минимумом кода. В частности, декомпрессор может быть довольно компактным. (Большинство символов в моем скрипте декодера предназначены для получения словаря биграмм.)

Вот неверная версия кода:

#!/usr/bin/perl
use strict;
use warnings;
# Run with -d to decode.
if ($ARGV[0] eq "-d") {
    shift;
    $_ = join "", <>;
    my @in = split //;
    my %dict;
    foreach my $n (0 .. 255) {
        my $c = shift @in;
        $dict{chr $n} = [ $c, shift @in ] if ord $c;
    }
    sub decode {
        foreach (@_) {
            if ($dict{$_}) {
                decode(@{$dict{$_}});
            } else {
                print $_;
            }
        }
    }
    decode @in;
} else {
    $_ = join "", <>;
    my @dict;
    for (my $n = 255 ; $n >= 0 ; --$n) {
        my $symbol = chr $n;
        if (!/\Q$symbol/) {
            my %pop;
            ++$pop{$_} for /../gs, /(?!^)../gs;
            my $str = (sort { $pop{$b} <=> $pop{$a} } keys %pop)[0];
            s/\Q$str/$symbol/g;
            $dict[$n] = $str;
        }
    }
    for (0..255) { $dict[$_] ||= "\0" }
    print @dict, $_;
}

Я думаю, что одно выражение в кодировщике для игры в гольф требует объяснения, а именно (sort{$p{$a}<=>$p{$b}}keys%p)[-1], чтобы получить ключ с наибольшим значением. Похоже, это должно быть написано как (sort{$p{$b}<=>$p{$a}}keys%p)[0], что делает то же самое и на один символ короче. Причина, по которой я так не написал, состоит в том, что он изменяет выбранный ключ в случае, когда существует несколько ключей с наибольшим значением. По чистой случайности это привело к тому, что результирующий вывод для тестового ввода был на 10 байтов длиннее. Я ненавидел брать лишнего дополнительного персонажа, но не настолько, чтобы жертвовать 9 очками из своего счета.

В твоем лице, Golfscript! (Ха-ха, Golfscript полностью подошел бы сюда и надрал бы мне задницу, если бы меня услышали.)

Python, 3514 = 294 + 2894 + 326

В основном реализация bzip2 . Это делает преобразование Burrows-Wheeler , шаг к передней преобразования , простой Хаффмана кодирования в битовый поток, преобразует этот поток битов в целое число и выписывает байт.

Кодер:

import sys
S=range(128)
H={0:'0'}
for b in range(7):
 for i in range(1<<b,2<<b):H[i]='1'*b+'10'+bin(i)[3:]
I=sys.stdin.read()+'\0'
N='1'
for x in sorted(I[i:]+I[:i]for i in range(len(I))):i=S.index(ord(x[-1]));N+=H[i];S=[S[i]]+S[:i]+S[i+1:]
N=int(N,2)
while N:sys.stdout.write(chr(N%256));N>>=8

Sэто очередь перемещения на передний план, Hкодировщик Хаффмана и Nбитовый поток.

Кодировка уменьшает ввод теста приблизительно до 41% от его исходного размера.

декодер:

import sys
N=0
b=1
for c in sys.stdin.read():N+=ord(c)*b;b<<=8
N=bin(N)[3:]
S=range(128)
L=''
while N:
 n=N.find('0')
 if n:i=2**n/2+int('0'+N[n+1:2*n],2);N=N[2*n:]
 else:i=0;N=N[1:]
 L+=chr(S[i]);S=[S[i]]+S[:i]+S[i+1:]
S=''
i=L.find('\0')
for j in L:S=L[i]+S;i=L[:i].count(L[i])+sum(c<L[i]for c in L)
sys.stdout.write(S[:-1])

8086 Ассемблер / MS_DOS

Компрессор: 155

jNiAxBCO2I7AM/+9/QW5AAGK2TPAq4rDqv7D4va6AQkz9lK0BrL/zSFadDK7
/f+DwwM733QNOTd19ThHAnXwid7r34k1iEUC6BMAtACKRQJr8AODxwPryrQC
zSHrxFIz0ovGuwMA9/Nai9iKztPL0ePQ0nMWgPr+cgtSsv60Bs0hWoDq/rQG
zSGyAf7JdeA5/XUHA+2DxQP+xsM=

Данные: 3506

Декомпрессор: 203

ieWD7CCM2IDEEI7YjsAz/7kAAYrZM8CrisOq/sPi9rYJxkb0Abn9BehtAIl2
/uhTAOhkAIl28Dv3cy3oRgCLRv6JBYt28Il2/oM8AHQEizTr94pEAohFAoPH
AznPddL+xgPJg8ED68mLdv6JNYM8AHQEizTr94pEAohFAol+/on+aFgBgzwA
dAdWizTo9f9etAaKVALNIcMz9ojz/k70dRu0BrL/zSF0IDz+cgi0BrL/zSEE
/sZG9AiIRvLQZvLR1v7Ldddr9gPDzSA=

Итого: 3864

Используйте этот декодер Base64 и сохраните двоичные файлы как «compress.com» и «degpress.com», а затем выполните:

compress < source > compressed_file
decompress < compressed_file > copy_of_source

в оболочке DOS (протестировано с WinXP). Там нет проверки ошибок, поэтому сжатие больших файлов приведет к неправильным результатам. Несколько небольших дополнений, и он может справиться с файлом любого размера. Кроме того, он не может распаковать в двоичный файл, поскольку он не может вывести значение 0xff (сжатые данные экранируют значение 0xff как 0xfe 0xff, а 0xfe экранируют как 0xfe 0xfe). Использование имен файлов командной строки позволило бы преодолеть проблему двоичного вывода, но было бы более выполнимым.

Стихотворение Баш (566 + 117) + 4687 = 5370

Ради интереса я замаскировал компрессор как стихотворение:

for I in my chamber nodded, nearly napping, suddenly heard rapping, tapping upon my door    \
"'T is some visiter" \ I\  muttered, o\'er lamplight "nothing more" \
just this sainted maiden whom the angels name Lenore    \
And "Prophet!" said me "thing of evil" -- "prophet still, if bird or devil!"    \
Leave no token of that lie thy soul hath spoken and sitting take thy ore from This floor    \
But you velvet bird from some shore above   \
here this with sad raven before his word still spoke nothing    \
"                                          " Quoth the Raven Never more;                    do C=$[C+1];E=`perl -e "print chr($C+128)"`;echo "s/$I/$E/g">>c;echo "s/$E/$I/g">>d;done;LANG=C sed -f $1;rm c d

Это унифицированный компрессор: при работе с опцией «c» он будет сжиматься, а с «d» он будет распаковываться. Он состоит из двух частей: 566-байтовой версии поэмы «читательский дайджест» и (2) 117-байтового суффикса, в котором выполняется весь «настоящий» bash.

С некоторой осторожностью (например, начиная стихотворение с "for I in") bash интерпретирует версию поэмы "с потерями" как массив. Он заменяет каждый элемент массива не-ASCII-символом (мы предполагаем, что вход ASCII, поэтому нет коллизий). Одно незначительное преимущество этого решения: поскольку мы используем тот факт, что мы можем предположить, что входом является ASCII, выход этого сжатия никогда не будет длиннее, чем его вход, независимо от того, что является входной частью и / или частью с потерями.

Правило, которое ближе всего к нарушению, это правило о предоставлении достойной степени сжатия для других текстов. Тем не менее, он сбрасывает 1386 байт из текста GPL V2, значительно превышая его собственный размер, который, кажется, соответствует определению OP decent. Таким образом, кажется, чтобы обеспечить так называемыйdecent сжатие общих текстов. Это связано с тем, что практически любой текст на английском языке будет иметь «то», «то» и т. Д. Очевидно, что он будет работать лучше, если вы замените часть «с потерями» текстом, напоминающим оригинал, который вы хотите сжать без потерь.

Разделение изображений и звука на части с потерями и без потерь является известным методом. Это не работает для текста: 4687 байт не так уж хорошо, даже если мы исключаем 566 байт из версии с потерями, и мы не можем автоматически генерировать версию текста с потерями, как мы можем это сделать для аудио. С положительной стороны это означает, что каждый раз, когда вы что-то сжимаете с помощью этого компрессора, вы можете весело создавать версию с потерями вручную. Так что это кажется разумным решением "для удовольствия".

C ++, 4134 байта (код = 1357, сжатый = 2777)

Это выполняет преобразование Берроуза-Уилера + движение к фронту, как у Кейта Рэндалла, но затем сжимает полученную последовательность байтов с помощью адаптивного дальномера . К сожалению, улучшенного сжатия от кодера диапазона недостаточно, чтобы компенсировать многословность C ++. Я мог бы еще немного поиграть в этот код, а именно использовать другой метод ввода / вывода, но этого было бы недостаточно, чтобы превзойти другие представления с помощью текущего алгоритма. Код специфичен для Windows, и поддерживается только текст ascii.
Сжать: "C текст_файл сжатый_файл". Распаковать
: "Д сжатый_файл uncompressed_file". В
значительной степени любая ошибка командной строки или ошибка файла приведет к сбою программы, и для кодирования или декодирования стихотворения потребуется больше минуты.

#include <windows.h>
#include <algorithm>
typedef DWORD I;typedef BYTE u;
#define W while
#define A(x)for(a=0;a<x;a++)
#define P(x)*o++=x;
I q,T=1<<31,B=T>>8,a,l,f[257],b,G=127,p=G,N=255;I Y(u*i,u*j){return
memcmp(i,j,l)<0;}I E(u*i,u*o){b=0;I L=0,h=0,R=T;u*c=o,*e=i+l;W(i<e){I
r=R/p,s=0;A(*i)s+=f[a];s*=r;L+=s;R=*i<N?r*f[*i++]++:R-s;p++;W(R<=B){if((L>>23)<N){for(;h;h--)P(N)P(L>>23)}else{if(L&T){o[-1]++;for(;h;h--)P(0)P(L>>23)}else
h++;}R<<=8;L<<=8;L&=T-1;}}P(L>>23)P(L>>15)P(L>>7)return
o-c;}void D(u*i,u*o){I R=128,L=*i>>1;u*e=o+l;W(o<e){W(R<=B){L<<=8;L|=((*i<<7)|(i++[1]>>1))&N;R<<=8;}I
h=R/p,m=L/h,x=0,v=0;W(v<=m)v+=f[x++];P(--x);L-=h*(v-f[x]);R=h*f[x]++;p++;}}void
main(I Z,char**v){u d[1<<16];I c=*v[1]<68,s;HANDLE F=CreateFileA(v[2],T,0,0,3,0,0),o=CreateFileA(v[3],T/2,0,0,2,0,0);ReadFile(F,d,GetFileSize(F,0),&l,0);l=c?l:*(I*)d;A(G)f[a]=1;u M[256];A(G)M[a]=a+1;u*g=new u[l*3],*h=g+l;if(c){memcpy(d+l,d,l);u**R=new
u*[l];A(l)R[a]=d+a;std::sort(R,R+l,Y);A(l){b=R[a][l-1];I
i=strchr((char*)M,b)-(char*)M;memmove(M+1,M,i);*M=g[a]=b;h[a]=i;}s=E(h,d+l+8);}else{D(d+8,g);A(l){I
k=g[a];g[a]=M[k];memmove(M+1,M,k);*M=g[a];}}u**j=new u*[l];A(l)j[a]=new
u[l*2],memset(j[a],0,l*2),j[a]+=l;A(l){for(b=0;b<l;)*--j[b]=g[b++];std::sort(j,j+l,Y);}if(c){A(l){if(!memcmp(j[a],d,l)){I*t=(I*)(d+l);*t=l;t[1]=a;g=d+l,l=s+8;}}}else
g=j[*(I*)(d+4)];WriteFile(o,g,l,&q,0);}

JavaScript, 393 (код) + 3521 (тест) = 3914 (всего)

Эта программа итеративно заменяет неиспользуемые байтовые значения на 2-4-символьные порции ввода. Каждая замена оценивается на основе частоты и длины исходного фрагмента, и лучшая замена выбирается каждый раз. Я бы добавил финальную стадию кодирования Хаффмана, если бы смог понять, как это сделать с относительно небольшим количеством символов. Декомпрессия - это, по сути, серия операций поиска и замены.

использование

C () обеспечивает сжатие; U () обеспечивает декомпрессию. Поскольку строки JavaScript основаны на 16-битных единицах кода Unicode, в формате сжатых данных используются только младшие 8 бит каждой единицы кода; это совместимо с функциями Firefox btoa () и atob () для кодирования Base64. ( пример использования )

Эта программа может работать только в Firefox из-за нестандартной опции "g" для .replace ().

Код

Гольф-код:

S=String.fromCharCode;function C(c){h=[];for(f=0;129>f;++f){g='';i=0;for(e=2;5>e;++e){d={};for(a=0;a<=c.length-e;a+=e)b="K"+c.substr(a,e),d[b]=d[b]?d[b]+1:1;for(b in d)a=d[b],a=a*e-(1+e+a),a>i&&(g=b.slice(1),i=a)}if(!g)break;h[f]=g;c=c.replace(g,S(127+f),"g")}return h.join("\1")+"\1"+c}function U(a){c=a.split("\1");a=c.pop();for(b=c.length,d=127+b;b--;)a=a.replace(S(--d),c[b],"g");return a}

Перед игрой в гольф:

function compress(str) {

    var hash, offset, match, iteration, expansions, bestMatch, bestScore, times, length, score;

    expansions = [];

    for (iteration = 0; iteration < 129; ++iteration) {

        bestMatch = null;
        bestScore = 0;

        for (length = 2; length < 5; ++length) {

            hash = {};

            for (offset = 0; offset <= str.length - length; offset += length) {
                match = 'K' + str.substr(offset, length);
                hash[match] = hash[match] ? hash[match] + 1 : 1;
            }

            for (match in hash) {
                times = hash[match];
                score = times * length - (1 + length + times);
                if (score > bestScore) {
                    bestMatch = match.slice(1);
                    bestScore = score;
                }
            }

        }

        if (!bestMatch) {
            break;
        }

        expansions[iteration] = bestMatch;
        str = str.replace(bestMatch, String.fromCharCode(127 + iteration), 'g');

    }

    return expansions.join('\u0001') + '\u0001' + str;
}

function uncompress(str) {
    var i, j, expansions;

    expansions = str.split('\u0001');
    str = expansions.pop();

    for (j = expansions.length, i = 127 + j; j--;) {
        str = str.replace(String.fromCharCode(--i), expansions[j], 'g');
    }

    return str;
}

PHP, (347 + 6166 + 176) = 6689

Таким образом, я пошел с упрощенным словарем + подход замены.

Если слово появляется несколько раз и оно короче (закодировать слово + сохранить запись замещения), оно выполняет замену. Если «слово» оказывается числом, оно все равно предотвращает случайные замены во время декомпрессии. «Словарь» подстановок объединяется нулевыми байтами, за которыми следуют два нулевых байта, за которыми следует тело, над которым работает подстановка.

Возможные улучшения:

• Windows не любит передавать более 4 КБ данных, поэтому найдите лучший способ, чем использовать файлы.
• Возможность сопоставлять длинные строки пробелов и считать их «словами», не добавляя слишком много кода.
• Придумать что-то лучшее, чем использовать цифры.

Использование: компрессор ищет файл с именем «i» и записывает сжатые данные в «o». Декомпрессор ищет «o» и записывает несжатые данные в «d». Это мой дурацкий обходной путь для Windows, который не любит передавать данные.

compress.php (347)

<?$d=file_get_contents('i');$z=chr(0);preg_match_all('|\b(\w+)\b|',$d,$m);$n=0;foreach($m[0]as$w){$l=strlen($w);$q[$w]=isset($q[$w])?$q[$w]+$l:$l;}arsort($q);foreach($q as$w=>$s){$l=strlen($w);$c=$s/$l;if($c*strlen($n)+$l<$s||is_int($w)){$d=preg_replace('|\b'.preg_quote($w).'\b|',$n++,$d);$f[]=$w;}}file_put_contents('o',implode($z,$f).$z.$z.$d);

Расширенная версия с комментариями и пояснениями.

Выходной образец без словаря. В некотором смысле смешно смотреть.
Нормальный размер: 6166 .

Ah, distinctly I remember it 45 in 0 bleak December,
25 each separate dying ember wrought its ghost 39 0 37.
Eagerly I wished 0 88:--vainly I had sought to borrow
From 9 books surcease of 43--43 for 0 lost 8--
For 0 rare 1 67 40 54 0 26 38 8--
                                          Nameless 63 for evermore.

25 0 silken sad uncertain rustling of each purple curtain
Thrilled me--filled me 19 fantastic terrors never felt 17;
So 4 now, to 13 0 beating of 9 64, I stood repeating
"'T is 57 31 36 49 at 9 2 5
Some late 31 36 49 at 9 2 5;--
                                          58 it is, 1 10 16."

degpress.php (176)

<?$z=chr(0);$d=file_get_contents('o');list($w,$d)=explode($z.$z,$d);$w=explode($z,$w);$n=0;foreach($w as$r){$d=preg_replace('|\b'.$n++.'\b|',$r,$d);};file_put_contents('d',$d);

Расширенная версия с объяснением.

Любые предложения по улучшению приветствуются.

Изменить: Добавлены "развернутые" версии кода и добавлено множество комментариев. Должно быть легко следовать.

GolfScript, 3647 (compressed size 3408 + code size 239)

128,{[.;]''+}%:d;8:k;{2k?={1k+:k;}*}:|;{2base}:b;{.[0]*@b+0@->}:$;.0=
{'':&,:i;1/{.d&@+?.0<{;d,i@d&@:&.0=:i;[+]+:d;k$\|}{:i;&\+:&;}if}%[0]k*+[]*8/{b}%"\0"\+}
{1>{8$}/][]*:^;{^k<b^k>:^;}:r~{.}{d,|d=:&r..d,<{d=}{;&}if[1<&\+]d\+:d;}while;}if

The algorithm used is LZW compression with variable-width codes. The first line is shared code, the second is the compression code and the third is the decompression code.

It handles files with ASCII characters in the range 1-127, and it recognizes compressed files automatically (they start with a 0 byte), so there are no parameters required to decompress.

Example run:

$ md5sum raven.txt
286206abbb7eca7b1ab69ea4b81da227  raven.txt
$ ruby golfscript.rb compress.gs < raven.txt > raven.lzw
$ ls -l raven.lzw
-rw-r--r-- 1 ahammar ahammar 3408 2012-01-27 22:27 raven.lzw
$ ruby golfscript.rb compress.gs < raven.lzw | md5sum
286206abbb7eca7b1ab69ea4b81da227  -

Note: I started on this long before the requirement to handle 100kb was added, so I haven't tested it on input of that size. However, it takes about 30 seconds to compress the test input and 5 seconds to decompress it, using about 20MB of memory at its peak.

Haskell, 3973

Late to the party, and not going to win, but I had fun writing it so I might as well post it.

It's a straightforward variable-width implementation of LZW, with a dictionary explicitely limited to printable ASCII, tab and linefeed. Run with no arguments, it compresses standard input to file C. Run with any argument (but "--decompress" would be a reasonable bet), it decompresses file C to standard output.

import List
import System
import Data.Binary
q=head
main=getArgs>>=m
m[]=getContents>>=encodeFile"C".s 97 128 1 0.e 97h
m _=decodeFile"C">>=putStr.d tail""96h.u 97 128
h=zip[0..].map(:[])$"\t\n"++[' '..'~']
e _ _[]=[]
e n s y=c:e(n+1)((n,take(1+l)y):s)(drop(l)y)where{Just(c,p)=find((`isPrefixOf`y).snd)s;l=length p}
d _ _ _ _[]=""
d f p n s(x:y)=t++d id t(n+1)(f$(n,p++[q t]):s)y where t=maybe(p++[q p])id$lookup x s
s _ _ _ a[]=a::Integer
s n w o a y|n>w=s n(2*w)o a y|0<1=s(n+1)w(o*w)(a+o*q y)(tail y)
u _ _ 0=[]
u n w x|n>w=u n(2*w)x|0<1=(x`mod`w::Integer):u(n+1)w(x`div`w)

• code size: 578
• compressed sample size: 3395