sfondo

La trasformazione move-to-front (MTF) è un algoritmo di codifica dei dati progettato per migliorare le prestazioni delle tecniche di codifica entropica.

Nella algoritmo di compressione bzip2 , viene applicata dopo l' Burrows-Wheeler trasformata (come visto in Burrows, Wheeler e indietro ), con l'obiettivo di trasformare gruppi di caratteri ripetuti in piccoli numeri interi non negativi facilmente comprimibili.

Definizione

Ai fini di questa sfida, definiremo la versione stampabile ASCII dell'MTF come segue:

Data una stringa di input s , prendi un array vuoto r , la stringa d di tutti i caratteri ASCII stampabili (da 0x20 a 0x7E) e ripeti quanto segue per ogni carattere c di s :

1. Aggiungi l'indice di c in d a r .

2. Spostare c sulla parte anteriore di d , ovvero rimuovere c da d e anteporre al resto.

Infine, prendiamo gli elementi di r come indici nella d originale e recuperiamo i caratteri corrispondenti.

Esempio passo-passo

INPUT: "CODEGOLF"

0. s = "CODEGOLF"
   d = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
   r = []
1. s = "ODEGOLF"
   d = "C !\"#$%&'()*+,-./0123456789:;<=>?@ABDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
   r = [35]
2. s = "DEGOLF"
   d = "OC !\"#$%&'()*+,-./0123456789:;<=>?@ABDEFGHIJKLMNPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
   r = [35 47]
3. s = "EGOLF"
   d = "DOC !\"#$%&'()*+,-./0123456789:;<=>?@ABEFGHIJKLMNPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
   r = [35 47 37]
4. s = "GOLF"
   d = "EDOC !\"#$%&'()*+,-./0123456789:;<=>?@ABFGHIJKLMNPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
   r = [35 47 37 38]
5. s = "OLF"
   d = "GEDOC !\"#$%&'()*+,-./0123456789:;<=>?@ABFHIJKLMNPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
   r = [35 47 37 38 40]
6. s = "LF"
   d = "OGEDC !\"#$%&'()*+,-./0123456789:;<=>?@ABFHIJKLMNPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
   r = [35 47 37 38 40 3]
7. s = "F"
   d = "LOGEDC !\"#$%&'()*+,-./0123456789:;<=>?@ABFHIJKMNPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
   r = [35 47 37 38 40 3 45]
8. s = ""
   d = "FLOGEDC !\"#$%&'()*+,-./0123456789:;<=>?@ABHIJKMNPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
   r = [35 47 37 38 40 3 45 41]

OUTPUT: "COEFH#MI"

Compito

Scrivi un programma o una funzione che implementa l'ASCII MTF stampabile (come definito sopra).

Casi test

Input:  Programming Puzzles & Code Golf
Output: Prpi"do lp%((uz rnu&3!P/o&$U$(p

Input:  NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN BATMAN!
Output: Na! !! !! !! !! !! !! !! !! !! !! !! !! !! !! !!"DDUP"%'

Input:  Two more questions and I have bzip2 in less than 100 bytes!
Output: Twp#o"si$sv#uvq(u$(l#o#W!r%w+$pz,xF%#,"x(. #0--'$GG ".z(**:

Regole aggiuntive

• Non è possibile utilizzare alcun operatore incorporato che calcola l'MTF di una stringa.

• Il codice può stampare una riga finale se si sceglie STDOUT per l'output.

• Il codice deve funzionare per qualsiasi input di 1000 o meno caratteri ASCII stampabili (da 0x20 a 0x7E).

• Si applicano le regole standard per il golf. Vince l'invio più breve in byte.

CJam, 20

'¡,q{_C#c' ,C+@|}fC;

Provalo online

Spiegazione:

'¡,      make a string of characters with codes from 0 to 160 (a modified "d")
         could have been to 126 but stackexchange doesn't like the DEL character
q        read the input (s)
{…}fC    for each character C in s
  _      duplicate the d string
  C#     find the index of C in d
  c      convert to character (this is the result)
  ' ,    make a string of characters from 0 to 31
  C+     append C to the string
  @      bring d to the top
  |      set union, preserving order; effectively, C is moved to position 32
         this is the updated d string
;        pop the last d

Struzzo , 46 45 caratteri

Non hai un numero di versione nell'intestazione perché in realtà si tratta solo dell'ultimo commit . Ho aggiunto l' Ooperatore (codice ascii alla stringa) dopo aver rilasciato l'ultima versione (ma ancora prima che questa sfida fosse pubblicata).

{a95,{32+O}%:d3@{:x\.3@?3@\+\x-x\+}/;{d=}%s*}

Spiegazione:

a             this is the "r" array (a is short for [], empty array)
95,{32+O}%:d  this is the "d" array
3@{...}/      for each character in the input (as an "argument")...
  :x            store in variable x (stack is now [r d c])
  \.3@?         find index in d     (stack is now [r d idx])
  3@\+          append index to r   (stack is now [d modified_r])
  \x-           remove char from d, and then...
  x\+           prepend char to d   (stack is now [modified_r modified_d])
;             throw away modified_d
{d=}%         map r to indices of (original) d
s*            join (s is short for ``, empty string)

Python 3, 88

*d,=range(127)
for c in input():y=d.index(ord(c));d[:32]+=d.pop(y),;print(chr(y),end='')

Utilizzando alcune idee dalla mia soluzione CJam.
-4 byte appartengono a Sp3000 :)

SWI-Prolog, 239 197 189 byte

a(S):-l([126],X),a(S,X,[],R),b(R,X).
a([A|T],X,S,R):-nth0(I,X,A,Z),(a(T,[A|Z],[I|S],R);R=[I|S]).
b([A|T],X):-(b(T,X);!),nth0(A,X,E),put(E).
l([B|R],Z):-A is B-1,X=[A,B|R],(A=32,Z=X;l(X,Z)).

Esempio: a(`Two more questions and I have bzip2 in less than 100 bytes!`).output:

Twp#o"si$sv#uvq(u$(l#o#W!r%w+$pz,xF%#,"x(. #0--'$GG ".z(**:

(e true .dopo, ovviamente)

Nota: la versione SWI-Prolog deve essere una delle più recenti in cui il backquote `rappresenta stringhe di codici. Le stringhe di codice erano rappresentate con virgolette doppie "nelle versioni precedenti.

Python 2, 137 110 104

Non è stato difficile da implementare, ma forse è ancora golfabile?

Provalo qui

e=d=map(chr,range(32,127))
r=""
for c in raw_input():n=e.index(c);r+=d[n];e=[e[n]]+e[:n]+e[n+1:]
print r

Pyth, 24 byte

JK>95CM127s@LKxL~J+d-Jdz

Dimostrazione. Collaudare l'imbragatura.

Il primo bit. JK>95CM127imposta l'elenco necessario e lo salva in Je K. ~J+d-Jdesegue l'aggiornamento dell'elenco, mentre xL ... zmappa i caratteri di input nelle loro posizioni nell'elenco. Infine, s@LKconverte quegli indici in caratteri nell'elenco originale.

Haskell, 120 byte

e#s=[b|(b,a)<-zip[0..]s,a==e]!!0
a=[' '..'~']
f=snd.foldl(\(d,r)e->(e:take(e#d)d++tail(drop(e#d)d),r++[a!!(e#d)]))(a,[])

Esempio di utilizzo: f "CODEGOLF"->"COEFH#MI"

Come funziona: #è una funzione di indice che restituisce la posizione di ein s(non può usare il nativo di Haskell a elemIndexcausa di un costoso import). La funzione principale fsegue un modello di piega in cui aggiorna la stringa di posizione de la stringa del risultato rmentre percorre la stringa di input.