Com a discussão recente sobre o uso de ferramentas de compactação no código golf , pensei que seria um bom desafio escrever seu próprio compressor e descompressor de texto.

Desafio:

Escreva dois programas : um para compactar o texto ASCII em uma sequência de bytes e outro para descompactá-lo. Os programas não precisam estar no mesmo idioma.

O primeiro programa deve ler um pedaço de texto ASCII (de um arquivo ou de uma entrada padrão ou usar qualquer mecanismo mais natural para o idioma) e gerar uma versão compactada dele. (A saída compactada pode consistir em bytes arbitrários; não precisa ser legível.) O segundo programa deve ler a saída do primeiro e recriar o texto de entrada original.

Pontuação:

A pontuação de uma solução será a soma das três seguintes contagens:

1. O comprimento do programa do compressor em caracteres.
2. O comprimento da saída do compressor, conforme a entrada de teste abaixo, em bytes.
3. O comprimento do programa descompressor (se diferente do compressor) em caracteres.

Você deve anotar todas as três contagens e a soma delas na sua resposta. Como se trata de código de golfe, quanto menor a pontuação, melhor.

Regras e restrições:

• Você não pode usar nenhuma ferramenta ou biblioteca de compactação ou descompactação preexistente, mesmo que elas sejam fornecidas com o idioma escolhido. Em caso de dúvida sobre se uma determinada ferramenta ou função é permitida, pergunte.

• Seu programa de compressor deve ser capaz de lidar com entradas que consistam em qualquer texto ASCII imprimível , incluindo guias (ASCII 9) e alimentações de linha (ASCII 10). Você pode, mas não precisa, lidar com Unicode arbitrário e / ou entrada binária.

• Seu programa de descompressor deve produzir exatamente a mesma saída que foi fornecida ao compressor como entrada. Em particular, tome cuidado para não emitir um avanço de linha à direita se a entrada não tiver um. (A entrada de teste abaixo possui um avanço de linha à direita, portanto, você precisará testá-lo separadamente. Dica para o GolfScript:. '':n)

• Seu compressor e descompressor podem ser o mesmo programa (com o modo apropriado selecionado, por exemplo, com uma chave de linha de comando). Nesse caso, seu comprimento é contado apenas uma vez .

• Os programas não devem ser extremamente lentos ou com muita memória . Se a compactação ou descompactação da entrada de teste levar mais de um minuto na minha área de trabalho não tão nova (AMD Athlon64 X2 de 2,2 GHz) ou consumir mais de um gigabyte de RAM, decidirei que a solução é inválida. Esses limites são deliberadamente frouxos - tente não pressioná-los. (Veja a alteração abaixo: você precisa poder manipular pelo menos 100 kB de entrada dentro desses limites.)

• Mesmo que apenas a entrada de teste seja importante para pontuação, você deve pelo menos fazer um esforço para compactar o texto de entrada arbitrário. Uma solução que alcança uma taxa de compactação decente apenas para a entrada de teste e para mais nada é tecnicamente válida, mas não receberá um voto positivo de mim.

• Seus programas de compressor e descompressor devem ser independentes . Em particular, se eles dependem da capacidade de ler algum arquivo ou recurso de rede que não faz parte do ambiente de tempo de execução padrão do idioma escolhido, o tamanho desse arquivo ou recurso deve ser contado como parte do tamanho do (s) programa (s). (Isso é para não permitir "compressores" que comparem a entrada com um arquivo na Web e produzam zero bytes se corresponderem. Desculpe, mas esse não é mais um truque novo.)

Alterações e esclarecimentos:

• Seu compressor deve ser capaz de lidar com arquivos que consistem em pelo menos 100 kB de texto típico em inglês dentro de um tempo razoável e uso de memória (no máximo um minuto e um GB de memória). Seu descompactador deve poder descomprimir a saída resultante dentro dos mesmos limites. Obviamente, ser capaz de lidar com arquivos por mais tempo é perfeitamente aceitável e recomendável. Não há problema em dividir arquivos de entrada longos em pedaços e compactá-los individualmente ou usar outros meios para trocar a eficiência da compactação pela velocidade de entradas longas.

• Seu compressor pode exigir que sua entrada seja fornecida usando a representação de nova linha nativa da sua plataforma preferida (LF, CR + LF, CR etc.), desde que o seu descompressor use a mesma representação de nova linha em sua saída. Obviamente, também é bom o compressor aceitar qualquer tipo de nova linha (ou mesmo apenas as novas linhas Unix, independentemente da plataforma), desde que o seu descompressor produza o mesmo tipo de nova linha da entrada original.

Entrada de teste:

Para julgar a eficiência da compactação das respostas, será utilizada a seguinte entrada de teste ( The Raven, de Edgar Allan Poe, cortesia do Projeto 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!

A entrada de teste correta (codificada com novas linhas LF no estilo Unix) deve ter 7043 bytes e ter o hash MD5 hexadecimal 286206abbb7eca7b1ab69ea4b81da227. ( md5sum -tdeve produzir o mesmo valor de hash, mesmo se você usar novas linhas de CR + LF no DOS / Windows.) A saída do seu descompactador deve ter o mesmo comprimento e hash.

Ps. Lembre-se de que esse desafio é tão difícil quanto você o faz. Realmente, qualquer coisa abaixo de 7043 conta como uma boa pontuação. (No outro extremo da escala, ficarei extremamente impressionado se alguém atingir uma pontuação abaixo de 2500.)

Perl, 3502 = 133 + 3269 + 100

O codificador:

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

E o decodificador:

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

Para os puristas que preferem evitar o uso de opções da linha de comando: Você pode remover a linha shebang e adicioná $/=chr;-la ao codificador e $/=$,;ao decodificador para obter o mesmo efeito. (Isso elevaria a pontuação até 3510.)

Este código usa um esquema de compactação muito primitivo:

• Encontre o bigram de dois caracteres que aparece com mais frequência no texto de origem.
• Substitua o bigram por um valor de bytes não utilizado no momento.
• Repita até que não haja mais bigrams repetidos (ou não mais valores de bytes não utilizados).

Alguém por aí pode reconhecer isso como uma versão simplificada da compactação "re-pair" (abreviação de pares recursivos).

Não é um bom esquema de compactação geral. Ele funciona bem com coisas como texto ASCII, onde existem muitos valores de bytes não utilizados e, mesmo assim, normalmente não obtém mais que uma proporção de 45 a 50%. No entanto, tem a vantagem de ser implementável com um mínimo de código. O descompressor em particular pode ser bastante compacto. (A maioria dos caracteres do meu script decodificador é para recuperar o dicionário bigram.)

Aqui está uma versão não destruída do código:

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

Uma expressão no codificador de golfe requer explicação, eu acho, ou seja (sort{$p{$a}<=>$p{$b}}keys%p)[-1], para obter a chave com o valor mais alto. Parece que deve ser escrito como (sort{$p{$b}<=>$p{$a}}keys%p)[0], que faz a mesma coisa e é um caractere mais curto. A razão pela qual não escrevi dessa maneira é que ela altera a chave selecionada no caso em que existem várias chaves com o valor mais alto. Por pura chance, isso fez com que a saída resultante da entrada de teste fosse 10 bytes mais longa. Eu odiava assumir o caráter extra inútil, mas não o suficiente para sacrificar 9 pontos da minha pontuação.

Na sua cara, Golfscript! (Haha, o Golfscript viria totalmente aqui e me chutaria se pudesse me ouvir.)

Python, 3514 = 294 + 2894 + 326

Basicamente uma implementação bzip2 . Ele faz uma transformação Burrows-Wheeler , uma transformação de mover para frente , uma simples codificação de Huffman em um fluxo de bits, converte esse fluxo de bits em um número inteiro e grava bytes.

Codificador:

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é a fila de mover para frente, Hé o codificador Huffman e Né o fluxo de bits.

A codificação reduz a entrada de teste para cerca de 41% do seu tamanho original.

Decodificador:

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

Montador 8086 / MS_DOS

Compressor: 155

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

Dados: 3506

Descompressor: 203

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

Total: 3864

Use esse decodificador Base64 e salve os arquivos binários como 'compress.com' e 'decompress.com' e faça:

compress < source > compressed_file
decompress < compressed_file > copy_of_source

em um shell do DOS (testado com WinXP). Como não há verificação de erros, a compactação de arquivos grandes criará resultados incorretos. Algumas pequenas adições e ele pode lidar com qualquer arquivo de tamanho. Além disso, ele não pode descompactar para binário, pois não pode gerar um valor 0xff (os dados compactados escapam do valor 0xff como 0xfe 0xff com 0xfe escapados como 0xfe 0xfe). O uso de nomes de arquivos da linha de comando superaria o problema de saída binária, mas seria um executável maior.

Poema de festança (566 + 117) + 4687 = 5370

Por diversão, disfarcei um compressor como um poema:

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

Este é um compressor unificado: execute com a opção "c" que comprimirá e com "d" descompactará. Ele tem duas partes: uma versão de 566 bytes "os leitores digerem" o poema e (2) um sufixo de 117 bytes em que é feita toda a festança "real".

Com algum cuidado (por exemplo, iniciando o poema com "for I in"), o bash interpretará a versão "com perdas" do poema como uma matriz. Ele substitui cada elemento da matriz por um caractere não ASCII (assumimos que a entrada é ASCII, portanto não há colisões). Uma pequena vantagem desta solução: como usamos o fato de que podemos assumir que a entrada é ASCII, a saída dessa compactação nunca será maior que a entrada, independentemente de qual seja a entrada e / ou a parte com perda.

A regra que mais se aproxima da violação é a regra sobre o fornecimento de uma taxa de compactação decente em outros textos. No entanto, ele remove 1386 bytes do texto da GPL V2, muito acima do seu próprio tamanho, o que parece corresponder à definição de OPs decent. Assim, parece fornecer a chamada decentcompressão em textos gerais. Isso ocorre porque praticamente qualquer texto em inglês terá "o" "que" etc. Claramente funcionará melhor se você substituir a parte "com perdas" por um texto semelhante ao original que deseja compactar sem perdas.

Dividir imagens e áudio em partes com e sem perdas é uma técnica conhecida. Isso não funciona tão bem para o texto: 4687 bytes não são tão bons, mesmo que excluamos os 566 bytes da versão com perda e não possamos realmente gerar automaticamente uma versão com perda do mesmo para o áudio. No lado positivo, isso significa que toda vez que você comprime algo com esse compressor, você pode se divertir criando uma versão com perdas manualmente. Portanto, essa parece ser uma solução razoável "por diversão".

C ++, 4134 bytes (código = 1357, compactado = 2777)

Isso transforma uma Burrows-Wheeler + uma Move-To-Front como a de Keith Randall, mas compacta a sequência de bytes resultante usando um Range Coder adaptável . Infelizmente, a compactação aprimorada do codificador de intervalo não é suficiente para compensar a verbosidade do C ++. Eu poderia jogar esse código um pouco mais, ou seja, usar um método diferente de entrada / saída, mas não seria suficiente para vencer as outras submissões com o algoritmo atual. O código é específico do Windows e apenas o texto ascii é suportado.
Para compactar: ​​"C text_file compressed_file"
Para descompactar: ​​"D compressed_file uncompressed_file"
Praticamente qualquer erro de linha de comando ou erro de arquivo trava o programa e leva quase um minuto para codificar ou decodificar o poema.

#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 (código) + 3521 (teste) = 3914 (total)

Este programa substitui iterativamente os valores de bytes não utilizados por pedaços de 2 a 4 caracteres da entrada. Cada substituição é pontuada com base na frequência e comprimento do pedaço original, e a melhor substituição é escolhida sempre. Eu adicionaria um estágio final de codificação de Huffman se pudesse descobrir como fazê-lo em um número relativamente pequeno de caracteres. A descompressão é essencialmente uma série de operações de localização e substituição.

Uso

C () fornece compactação; U () fornece descompressão. Como as strings do JavaScript são baseadas em unidades de código Unicode de 16 bits, apenas os 8 bits menos significativos de cada unidade de código são usados ​​no formato de dados compactados; isso é compatível com as funções btoa () e atob () do Firefox para codificação Base64. ( exemplo de uso )

Este programa pode funcionar apenas no Firefox devido a uma opção "g" não padrão para .replace ().

Código

Código de golfe:

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}

Antes de jogar golfe:

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

Então, eu fui com uma abordagem simplista de dicionário + substituição.

Se uma palavra aparecer várias vezes e for mais curta (codificar a palavra + salvar a entrada de substituição), ela fará a substituição. Se a "palavra" for um número, de qualquer maneira, evita substituições acidentais durante a descompressão. O "dicionário" de substituições é associado por bytes nulos, seguidos por dois bytes nulos, seguidos pelo corpo no qual a substituição trabalha.

Possíveis melhorias:

• O Windows não gosta de enviar mais de 4kb de dados, portanto, encontre uma maneira melhor do que usar arquivos.
• A capacidade de combinar longas sequências de espaços em branco e contá-las como "palavras" sem adicionar muito código.
• Chegando com algo melhor substituições em vez de usar números.

Uso: o compressor procura um arquivo chamado "i" e grava os dados compactados em "o". O descompactador procura "o" e grava os dados não compactados em "d". Esta é a minha solução de má qualidade para o Windows, que não gosta de canalizar barcos de dados.

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

Versão ampliada com comentários e explicações.

Amostra de saída sem dicionário. Meio engraçado de se olhar.
Tamanho normal: 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);

Versão expandida com explicação.

Todas as sugestões para melhorias são bem-vindas.

Editar: adicionadas as versões "desenroladas" do código e adicionadas toneladas de comentários. Deve ser fácil de seguir.

GolfScript, 3647 (tamanho compactado 3408 + código 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

O algoritmo usado é a compactação LZW com códigos de largura variável. A primeira linha é o código compartilhado, a segunda é o código de compactação e a terceira é o código de descompactação.

Ele lida com arquivos com caracteres ASCII no intervalo de 1 a 127 e reconhece arquivos compactados automaticamente (eles começam com um byte 0), para que não haja parâmetros necessários para descompactar.

Exemplo de execução:

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

Nota: Comecei isso muito antes de o requisito de lidar com 100kb ser adicionado, por isso não o testei na entrada desse tamanho. No entanto, leva cerca de 30 segundos para compactar a entrada de teste e 5 segundos para descompactá-la, usando cerca de 20 MB de memória em seu pico.

Haskell, 3973

Cheguei atrasado na festa e não ganhei, mas eu me diverti escrevendo para poder postar.

É uma implementação direta de largura variável do LZW, com um dicionário explicitamente limitado a ASCII, tabulação e alimentação de linha imprimíveis. Executar sem argumentos, compacta a entrada padrão no arquivo C. Executar com qualquer argumento (mas "- descompress" seria uma aposta razoável), descompacta o arquivo Cna saída padrão.

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)

• tamanho do código: 578
• tamanho da amostra compactada: 3395