Angesichts der jüngsten Diskussion über die Verwendung von Komprimierungswerkzeugen im Codegolf hielt ich es für eine schöne Herausforderung, einen eigenen Textkomprimierer und -dekomprimierer zu schreiben.

Herausforderung:

Schreiben Sie zwei Programme : eines zum Komprimieren von ASCII-Text in eine Folge von Bytes und eines zum Dekomprimieren. Die Programme müssen nicht in derselben Sprache sein.

Das erste Programm sollte einen Teil des ASCII-Texts lesen (aus einer Datei oder von der Standardeingabe oder unter Verwendung eines für die Sprache am natürlichsten wirkenden Mechanismus) und eine komprimierte Version davon ausgeben. (Die komprimierte Ausgabe kann aus beliebigen Bytes bestehen; sie muss nicht lesbar sein.) Das zweite Programm sollte die Ausgabe der ersten lesen und den ursprünglichen Eingabetext neu erstellen.

Wertung:

Die Punktzahl einer Lösung ergibt sich aus der Summe der folgenden drei Punkte :

1. Die Länge des Kompressorprogramms in Zeichen.
2. Die Länge der Ausgabe des Kompressors in Byte, wenn die Testeingabe unten angegeben ist.
3. Die Länge des Dekomprimierungsprogramms (falls vom Kompressor verschieden) in Zeichen.

Sie sollten alle drei Zählungen und ihre Summe in Ihrer Antwort notieren. Da dies Codegolf ist, ist es umso besser, je niedriger die Punktzahl ist.

Regeln und Einschränkungen:

• Sie dürfen keine bereits vorhandenen Komprimierungs- oder Dekomprimierungs-Tools oder -Bibliotheken verwenden, auch wenn diese in der von Ihnen gewählten Sprache enthalten sind. Wenn Sie Zweifel haben, ob ein bestimmtes Werkzeug oder eine bestimmte Funktion zulässig ist, fragen Sie bitte.

• Ihr Kompressorprogramm muss Eingaben verarbeiten können, die aus druckbarem ASCII-Text bestehen , einschließlich Registerkarten (ASCII 9) und Zeilenvorschüben (ASCII 10). Sie können, müssen aber nicht mit beliebigen Unicode- und / oder Binäreingaben umgehen.

• Ihr Dekompressor-Programm muss genau die gleiche Ausgabe erzeugen , die dem Kompressor als Eingabe gegeben wurde. Achten Sie insbesondere darauf, keinen nachgestellten Zeilenvorschub auszugeben, wenn der Eingang keinen hatte. (Der unten stehende Testeingang verfügt über einen Zeilenvorschub am Ende der Zeile, daher müssen Sie diesen separat testen. Tipp für GolfScript:. '':n)

• Ihr Kompressor und Ihr Dekompressor können dasselbe Programm sein (mit dem entsprechenden ausgewählten Modus, z. B. mit einem Befehlszeilenschalter). In diesem Fall wird die Länge nur einmal gezählt .

• Die Programme sollten nicht extrem langsam oder speicherhungrig sein . Wenn das Komprimieren oder Dekomprimieren der Testeingabe auf meinem nicht ganz neuen Desktop (2,2 GHz AMD Athlon64 X2) mehr als eine Minute dauert oder mehr als ein Gigabyte RAM verbraucht, wird die Lösung als ungültig eingestuft. Diese Grenzen sind absichtlich lasch - bitte versuchen Sie nicht, sie zu überschreiten. (Siehe Änderung unten: Sie müssen in der Lage sein, mindestens 100 kB an Eingaben innerhalb dieser Grenzen zu verarbeiten.)

• Auch wenn nur die Testeingabe für das Scoring von Bedeutung ist, sollten Sie sich zumindest bemühen, beliebigen Eingabetext zu komprimieren. Eine Lösung, die nur für die Testeingabe und für nichts anderes ein anständiges Komprimierungsverhältnis erzielt , ist technisch gültig, wird aber von mir nicht positiv bewertet.

• Ihre Kompressor- und Dekompressorprogramme sollten in sich geschlossen sein . Insbesondere wenn sie in der Lage sind, eine Datei oder Netzwerkressource zu lesen, die nicht Teil der Standardlaufzeitumgebung Ihrer gewählten Sprache ist, sollte die Länge dieser Datei oder Ressource als Teil der Länge des Programms (der Programme) gezählt werden. (Dies soll "Kompressoren" verbieten, die die Eingabe mit einer Datei im Web vergleichen und null Bytes ausgeben, wenn sie übereinstimmen. Tut mir leid, aber das ist kein neuer Trick mehr.)

Änderungen und Klarstellungen:

• Ihr Kompressor muss in der Lage sein, Dateien, die aus mindestens 100 kB typisch englischem Text bestehen, in angemessener Zeit und mit angemessenem Speicherbedarf (höchstens 1 Minute und 1 GB Speicher) zu verarbeiten. Ihr Dekomprimierer muss in der Lage sein, die resultierende Ausgabe innerhalb der gleichen Grenzen zu dekomprimieren. Natürlich ist es vollkommen in Ordnung und lobenswert, Dateien länger verarbeiten zu können. Es ist in Ordnung, lange Eingabedateien in Blöcke aufzuteilen und diese einzeln zu komprimieren oder auf andere Weise die Komprimierungseffizienz gegen die Geschwindigkeit für lange Eingaben auszutauschen.

• Der Kompressor kann seine Eingabe verlangen angesichts Ihrer bevorzugten Plattform der Verwendung von nativen Newline Darstellung (LF, CR + LF, CR, etc.), solange Ihr Dekompressor die gleiche Newline Darstellung in seiner Ausgabe verwendet. Natürlich ist es auch in Ordnung, dass der Kompressor alle Arten von Zeilenumbrüchen akzeptiert (oder sogar nur Unix-Zeilenumbrüche, unabhängig von der Plattform), solange Ihr Dekomprimierer dann die gleichen Zeilenumbrüche ausgibt wie in der ursprünglichen Eingabe.

Testeingang:

Zur Beurteilung der Komprimierungseffizienz der Antworten wird der folgende Testeingang ( The Raven von Edgar Allan Poe, mit freundlicher Genehmigung von Project Gutenberg ) verwendet:

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!

Die korrekte Testeingabe (codiert mit LF-Zeilenumbrüchen im Unix-Stil) sollte 7043 Byte lang sein und den hexadezimalen MD5-Hash enthalten 286206abbb7eca7b1ab69ea4b81da227. ( md5sum -tSollte den gleichen Hash-Wert erzeugen, auch wenn Sie CR + LF-Zeilenumbrüche unter DOS / Windows verwenden.) Die Ausgabe Ihres Dekomprimierers sollte die gleiche Länge und den gleichen Hash haben.

Ps. Denken Sie daran, dass diese Herausforderung nur so schwer ist, wie Sie es schaffen. Wirklich, alles unter 7043 zählt als gutes Ergebnis. (Am anderen Ende der Skala bin ich sehr beeindruckt, wenn jemand eine Punktzahl unter 2500 erreicht.)

Perl, 3502 = 133 + 3269 + 100

Der Encoder:

#!/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

Und der Decoder:

#!/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

Für Puristen, die es vorziehen, Befehlszeilenoptionen nicht zu verwenden: Sie können die Shebang-Zeile entfernen und $/=chr;zum Encoder und $/=$,;zum Decoder hinzufügen , um den gleichen Effekt zu erzielen. (Dies würde die Punktzahl auf 3510 bringen.)

Dieser Code verwendet ein sehr primitives Komprimierungsschema:

• Suchen Sie das Bigram mit zwei Zeichen, das im Quelltext am häufigsten vorkommt.
• Ersetzen Sie das Bigram durch einen aktuell nicht verwendeten Bytewert.
• Wiederholen, bis keine Bigrams mehr wiederholt werden (oder keine nicht verwendeten Bytewerte mehr).

Jemand da draußen erkennt dies möglicherweise als vereinfachte Version der "Re-Pair" -Komprimierung (kurz für rekursive Paare).

Es ist kein sehr gutes allgemeines Komprimierungsschema. Es eignet sich nur für ASCII-Text, bei dem viele Bytewerte nicht verwendet werden, und selbst dann beträgt das Verhältnis in der Regel nicht mehr als 45-50%. Es hat jedoch den Vorteil, dass es mit einem Minimum an Code implementiert werden kann. Insbesondere der Dekompressor kann recht kompakt sein. (Die meisten Zeichen in meinem Decoder-Skript dienen zum Abrufen des Bigram-Wörterbuchs.)

Hier ist eine ungolfed Version des Codes:

#!/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, $_;
}

Ein Ausdruck im Golf-Encoder muss erklärt werden, und zwar (sort{$p{$a}<=>$p{$b}}keys%p)[-1], um den Schlüssel mit dem höchsten Wert zu erhalten. Das sieht so aus, als sollte es so geschrieben werden (sort{$p{$b}<=>$p{$a}}keys%p)[0], dass es dasselbe tut und ein Zeichen kürzer ist. Der Grund, warum ich es nicht so geschrieben habe, ist, dass es den ausgewählten Schlüssel ändert, wenn es mehrere Schlüssel mit dem höchsten Wert gibt. Dies führte zufällig dazu, dass die resultierende Ausgabe für die Testeingabe 10 Byte länger war. Ich hasste es, den unnützen zusätzlichen Charakter anzunehmen, aber nicht genug, um 9 Punkte von meiner Punktzahl zu opfern.

In deinem Gesicht, Golfscript! (Haha, Golfscript würde total hier rüberkommen und mir in den Arsch treten, wenn es mich hören könnte.)

Python, 3514 = 294 + 2894 + 326

Grundsätzlich eine bzip2- Implementierung. Es führt eine Burrows-Wheeler-Transformation , eine Move-to-Front-Transformation , eine einfache Huffman-Codierung in einen Bitstrom durch, konvertiert diesen Bitstrom in eine Ganzzahl und schreibt Bytes aus.

Encoder:

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

Sist die Move-to-Front-Warteschlange, Hder Huffman-Encoder und Nder Bitstream.

Die Codierung reduziert die Testeingabe auf etwa 41% ihrer ursprünglichen Größe.

Decoder:

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 Assembler / MS_DOS

Kompressor: 155

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

Daten: 3506

Dekomprimierer: 203

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

Insgesamt: 3864

Verwenden Sie diesen Base64-Decoder und speichern Sie die Binärdateien als 'compress.com' und 'decompress.com'. Führen Sie dann Folgendes aus:

compress < source > compressed_file
decompress < compressed_file > copy_of_source

in einer DOS-Shell (getestet mit WinXP). Es gibt keine Fehlerprüfung, daher führt das Komprimieren großer Dateien zu falschen Ergebnissen. Ein paar kleine Ergänzungen und es könnte mit jeder Größe der Datei fertig werden. Es kann auch nicht als Binärdatei dekomprimiert werden, da kein 0xff-Wert ausgegeben werden kann (die komprimierten Daten entziehen sich dem 0xff-Wert als 0xfe 0xff, wobei 0xfe als 0xfe 0xfe maskiert wird). Die Verwendung von Befehlszeilen-Dateinamen würde das Problem der Binärausgabe überwinden, wäre jedoch eine umfangreichere ausführbare Datei.

Bash Poem (566 + 117) + 4687 = 5370

Zum Spaß habe ich einen Kompressor als Gedicht getarnt:

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

Dies ist ein einheitlicher Kompressor: Mit der Option "c" wird er komprimiert und mit "d" wird er dekomprimiert. Es besteht aus zwei Teilen: einer 566-Byte-Version des Gedichts "Readers Digest" und (2) einem 117-Byte-Suffix, in dem der gesamte "echte" Bash ausgeführt wird.

Mit einiger Sorgfalt (zB wenn Sie das Gedicht mit "for I in" beginnen) interpretiert bash die "verlustbehaftete" Version des Gedichts als Array. Es ersetzt jedes Element des Arrays durch ein Nicht-ASCII-Zeichen (wir gehen davon aus, dass die Eingabe ASCII ist, sodass keine Kollisionen auftreten). Ein kleiner Vorteil dieser Lösung: Da wir davon ausgehen können, dass die Eingabe ASCII ist, wird die Ausgabe dieser Komprimierung niemals länger als die Eingabe sein, unabhängig davon, was die Eingabe und / oder der verlustbehaftete Teil ist.

Die Regel, die der Regelverletzung am nächsten kommt, ist die Regel, bei anderen Texten ein angemessenes Komprimierungsverhältnis bereitzustellen. Der GPL V2-Text wird jedoch um 1386 Bytes reduziert, und zwar weit über seine eigene Größe hinaus, was anscheinend mit der OPs-Definition von übereinstimmt decent. Es scheint also eine sogenannte decentKomprimierung von allgemeinen Texten zu geben. Dies liegt daran, dass so gut wie jeder englische Text das "", was "" hat. Es funktioniert eindeutig besser, wenn Sie den "verlustbehafteten" Teil durch Text ersetzen, der dem Original ähnelt, das Sie verlustfrei komprimieren möchten.

Das Aufteilen von Bildern und Ton in verlustbehaftete und verlustfreie Teile ist eine bekannte Technik. Dies funktioniert nicht so gut für Text: 4687 Bytes sind nicht so großartig, selbst wenn wir die 566 Bytes von der verlustbehafteten Version ausschließen und wir nicht automatisch eine verlustbehaftete Textversion erzeugen können, so wie wir es für Audio können. Auf der positiven Seite bedeutet dies, dass Sie jedes Mal, wenn Sie etwas mit diesem Kompressor komprimieren, den Spaß haben können, eine verlustbehaftete Version von Hand zu erstellen. Dies scheint also eine vernünftige "zum Spaß" -Lösung zu sein.

C ++, 4134 Byte (Code = 1357, komprimiert = 2777)

Dies führt eine Burrows-Wheeler-Transformation + eine Move-To-Front-Transformation wie bei Keith Randall durch, komprimiert dann aber die resultierende Byte-Sequenz mit einem adaptiven Range Coder . Leider reicht die verbesserte Komprimierung des Range Coders nicht aus, um die Ausführlichkeit von C ++ auszugleichen. Ich könnte diesen Code noch etwas weiter verbessern, nämlich eine andere Eingabe- / Ausgabemethode verwenden, aber es würde nicht ausreichen, die anderen Einreichungen mit dem aktuellen Algorithmus zu übertreffen. Der Code ist Windows-spezifisch und nur ASCII-Text wird unterstützt.
So komprimieren Sie: "C text_file compress_file"
So dekomprimieren Sie: "D compress_file uncompressed_file" Nahezu
jeder Befehlszeilen- oder Dateifehler führt zum Absturz des Programms, und es dauert fast eine Minute, um das Gedicht zu codieren oder zu decodieren.

#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 (Code) + 3521 (Test) = 3914 (Gesamt)

Dieses Programm ersetzt iterativ nicht verwendete Bytewerte für 2- bis 4-stellige Chunks der Eingabe. Jede Substitution wird basierend auf der Häufigkeit und Länge des ursprünglichen Blocks gewertet, und die beste Substitution wird jedes Mal ausgewählt. Ich würde eine letzte Huffman-Codierungsstufe hinzufügen, wenn ich herausfinden könnte, wie dies mit einer relativ geringen Anzahl von Zeichen getan werden kann. Die Dekomprimierung besteht im Wesentlichen aus einer Reihe von Such- und Ersetzungsvorgängen.

Verwendung

C () sorgt für Komprimierung; U () sorgt für Dekomprimierung. Da JavaScript-Zeichenfolgen auf 16-Bit-Unicode-Codeeinheiten basieren, werden im komprimierten Datenformat nur die niedrigstwertigen 8 Bits jeder Codeeinheit verwendet. Dies ist kompatibel mit den Firefox-Funktionen btoa () und atob () für die Base64-Codierung. ( Anwendungsbeispiel )

Dieses Programm funktioniert möglicherweise nur in Firefox, da die Option "g" für .replace () nicht dem Standard entspricht.

Code

Golf Code:

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}

Vor dem Golfen:

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

Also ging ich mit einem simplen Wörterbuch + Substitutionsansatz vor.

Wenn ein Wort mehrmals vorkommt und es kürzer ist (das Wort codieren + den Ersetzungseintrag speichern), wird es ersetzt. Wenn es sich bei dem "Wort" zufällig um eine Zahl handelt, wird dies trotzdem getan, um versehentliche Ersetzungen während der Dekomprimierung zu verhindern. Das "Wörterbuch" der Ersetzungen wird durch Null-Bytes gefolgt von zwei Null-Bytes gefolgt von dem Hauptteil, an dem die Ersetzung ausgeführt wird, ergänzt.

Mögliche Verbesserungen:

• Windows mag es nicht, mehr als 4 KB an Daten weiterzuleiten. Finden Sie also einen besseren Weg, als Dateien zu verwenden.
• Die Möglichkeit, lange Leerzeichenfolgen zuzuordnen und als "Wörter" zu zählen, ohne zu viel Code hinzuzufügen.
• Sich etwas Besseres einfallen lassen, anstatt Zahlen zu verwenden.

Verwendung: Der Kompressor sucht nach einer Datei mit dem Namen "i" und schreibt die komprimierten Daten nach "o". Der Dekomprimierer sucht nach "o" und schreibt die unkomprimierten Daten nach "d". Dies ist meine bescheidene Problemumgehung für Windows, die nicht gerne Daten von Booten weiterleitet.

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);

Erweiterte Version mit Kommentaren und Erläuterungen.

Beispiel ohne Wörterbuch ausgeben. Etwas lustig anzusehen.
Normale Größe: 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."

decompress.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);

Erweiterte Version mit Erläuterung.

Verbesserungsvorschläge sind willkommen.

Bearbeiten: Fügte die "entrollten" Versionen des Codes hinzu und fügte Tonnen von Kommentaren hinzu. Sollte leicht zu folgen sein.

GolfScript, 3647 (komprimierte Größe 3408 + Codegröße 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

Der verwendete Algorithmus ist die LZW-Komprimierung mit Codes variabler Breite. Die erste Zeile ist gemeinsam genutzter Code, die zweite Zeile ist der Kompressionscode und die dritte Zeile ist der Dekomprimierungscode.

Es verarbeitet Dateien mit ASCII-Zeichen im Bereich von 1 bis 127 und erkennt komprimierte Dateien automatisch (sie beginnen mit einem 0-Byte), sodass keine Parameter zum Dekomprimieren erforderlich sind.

Beispiellauf:

$ 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  -

Hinweis: Ich habe damit begonnen, lange bevor die Anforderung, 100 KB zu verarbeiten, hinzugefügt wurde. Daher habe ich sie bei Eingaben dieser Größe nicht getestet. Es dauert jedoch ungefähr 30 Sekunden, um die Testeingabe zu komprimieren, und 5 Sekunden, um sie zu dekomprimieren, wobei ungefähr 20 MB Speicher an der Spitze verwendet werden.

Haskell, 3973

Spät zur Party und werde nicht gewinnen, aber ich hatte Spaß daran, es zu schreiben, also könnte ich es auch posten.

Es ist eine einfache Implementierung von LZW mit variabler Breite, wobei ein Wörterbuch explizit auf druckbares ASCII, Tabulator und Zeilenvorschub beschränkt ist. Wird ohne Argumente ausgeführt und komprimiert die Standardeingabe in eine Datei C. Führen Sie ein beliebiges Argument aus ("--decompress" ist jedoch eine sinnvolle Option), um die Datei Cauf die Standardausgabe zu dekomprimieren .

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)

• Codegröße: 578
• komprimierte Stichprobengröße: 3395