fundo

A transformação de movimento para frente (MTF) é um algoritmo de codificação de dados projetado para melhorar o desempenho das técnicas de codificação de entropia.

No algoritmo de compactação bzip2 , é aplicado após a transformação Burrows – Wheeler (como visto em Burrows, Wheeler e Back ), com o objetivo de transformar grupos de caracteres repetidos em números inteiros não negativos pequenos e facilmente compactáveis.

Definição

Para o objetivo deste desafio, definiremos a versão ASCII imprimível do MTF da seguinte maneira:

Dada uma sequência de entrada s , pegue uma matriz vazia r , a sequência d de todos os caracteres ASCII imprimíveis (0x20 a 0x7E) e repita o seguinte para cada caractere c de s :

1. Anexe o índice de c em d para r .

2. Mova c para a frente de d , ou seja, remova c de d e coloque-o no restante.

Finalmente, pegamos os elementos de r como índices no original d e buscamos os caracteres correspondentes.

Exemplo passo a 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"

Tarefa

Escreva um programa ou função que implemente o MTF ASCII imprimível (conforme definido acima).

Casos de teste

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(**:

Regras adicionais

• Você não pode usar nenhum operador interno que calcule o MTF de uma sequência.

• Seu código pode imprimir uma nova linha à direita se você escolher STDOUT para saída.

• Seu código precisa funcionar para qualquer entrada de 1000 caracteres ASCII imprimíveis ou menos (0x20 a 0x7E).

• Aplicam-se as regras de código padrão do golfe. O menor envio em bytes vence.

CJam, 20

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

Experimente online

Explicação:

'¡,      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

Avestruz , 46 45 caracteres

Não tenha um número de versão no cabeçalho, porque este é apenas o último commit . Eu adicionei o O(código ASCII para string) operador depois de lançar a versão mais recente (mas ainda antes de este desafio foi publicado).

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

Explicação:

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='')

Usando algumas idéias da minha solução CJam.
-4 bytes pertencem ao Sp3000 :)

SWI-Prolog, 239 197 189 bytes

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

Exemplo: a(`Two more questions and I have bzip2 in less than 100 bytes!`).saídas:

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

(e true .depois disso, obviamente)

Nota: sua versão do SWI-Prolog deve ser uma das mais recentes, nas quais a cotação posterior `representa sequências de códigos. As cadeias de código costumavam ser representadas com aspas duplas "em versões mais antigas.

Python 2, 137 110 104

Não foi difícil de implementar, mas talvez ainda seja um jogo de golfe?

Experimente aqui

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

Pitão, 24 bytes

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

Demonstração. Equipamento de teste.

A primeira parte. JK>95CM127configura a lista necessária e a salva em Je K. ~J+d-Jdexecuta a atualização da lista, enquanto xL ... zmapeia os caracteres de entrada para suas posições na lista. Por fim, s@LKconverte esses índices em caracteres na lista original.

Haskell, 120 bytes

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

Exemplo de uso: f "CODEGOLF"->"COEFH#MI"

Como funciona: #é uma função de índice que retorna a posição de ein s(não é possível usar o nativo de Haskell por elemIndexcausa de um caro import). A função principal fsegue um padrão de dobra em que atualiza a sequência de posição de a sequência de resultados à rmedida que caminha pela sequência de entrada.