Dada a entrada de qualquer programa Glypho válido, envie sua contraparte "legível por humanos".

Glypho é uma idéia interessante do esolang:

A referência da instrução é dada aqui. Para cada instrução, os caracteres abcd representam os símbolos que compõem cada instrução. a refere-se ao primeiro símbolo exclusivo, b refere-se ao segundo símbolo exclusivo, etc.

aaaa ..... n NOP - no operation; do nothing
aaab ..... i Input - push input onto top of stack
aaba ..... > Rot - pops top stack element and pushes to bottom of stack
aabb ..... \ Swap - swaps top two stack elements
aabc ..... 1 Push - pushes a 1 onto the top of stack (creates new element)
abaa ..... < RRot - pops bottom element and pushes to top of stack
abab ..... d Dup - Duplicates top stack element
abac ..... + Add - pops top two elements and pushes their sum
abba ..... [ L-brace - skip to matching ] if top stack element is 0
abbb ..... o Output - pops and outputs top stack element
abbc ..... * Multiply - pops top two elements and pushes their product
abca ..... e Execute - Pops four elements and interprets them as an instruction
abcb ..... - Negate - pops value from stack, pushes -(value)
abcc ..... ! Pop - pops and discards top stack element
abcd ..... ] R-brace - skip back to matching [

_{(crédito: Brian Thompson, também conhecido como Wildhalcyon)}

Assim, por exemplo, PPCGrepresentaria a instrução Push -PPCG corresponde ao padrão aabc, onde arepresenta P, brepresenta Ce c representa G.

A entrada será uma única sequência que consiste apenas em caracteres ASCII imprimíveis. Sempre terá um comprimento divisível por quatro (duh).

A saída é cada grupo de quatro caracteres na sequência de entrada substituída pela instrução que eles designam. Use os nomes de instruções de uma letra (aqueles logo após os cinco pontos na tabela citada acima).

Como esse é o código-golfe , o código mais curto em bytes será vencedor.

Casos de teste:

In                                Out
------------------------------------------------
Programming Puzzles & Code Golof  ]!]!]]]+
nananananananana batman!          dddd]]
;;;;;;;:;;:;;;::                  ni>\
llamas sleep                      1-*
8488133190003453                  <[oe
<empty string>                    <empty string>

Pyth, 37 35 34 bytes

O código contém caracteres não imprimíveis, então aqui está o xxdhexdump:

0000000: 5663 7a34 7040 2e22 216f d78c 40bf d4f0  Vcz4p@."!o..@...
0000010: 38d6 7dfe 7312 3ff8 ea22 6958 4e7b 4e55  8.}.s.?.."iXN{NU
0000020: 5433                                     T3

Aqui está uma versão imprimível em 36 bytes:

Vcz4p@"ni >\\1   <d+[o*e-!]"iXN{NUT3

Experimente online. Suíte de teste.

Explicação

Vcz4p@."…"iXN{NUT3       implicit: z = input
  z                      input
 c 4                     split to 4-character blocks
V                        loop over that in N
           X               replace...
            N                in current part
             {N              unique chars in current part, in order
               UT            with numbers 0-9
          i      3         interpret as base 3
     @                     take that item of
      ."…"                   string "ni >\\1   <d+[o*e-!]"
    p                      and print without newline

CJam, 42 39 35 bytes

Economizou 4 bytes emprestando a idéia de user81655 de usar a base 3 em vez da base 4.

l4/{__&f#3b"ni >\1   <d+[o*e-!]"=}%

Execute todos os casos de teste.

Deve haver uma maneira melhor de compactar a tabela de comandos de pesquisa ...

JavaScript (ES6), 97

Para cada bloco de 4 caracteres, substituo cada símbolo com sua posição no bloco, obtendo um número base 4. Por exemplo 'aabc' -> '0023'. Os números possíveis estão no intervalo 0..0123, ou seja, 0..27 em decimal. Eu uso o número como um índice para encontrar o caractere de instrução correto de uma string de 28 caracteres.

s=>s.replace(/.{4}/g,s=>'n..i....>.\\1....<d.+[o.*e-!]'[[...s].map(c=>n=n*4+s.indexOf(c),n=0),n])

Teste

F=s=>s.replace(/.{4}/g,s=>'n..i....>.\\1....<d.+[o.*e-!]'[[...s].map(c=>n=n*4+s.indexOf(c),n=0),n])

function test() { O.textContent=F(I.value) }

test();

#I { width:90% }

<input id=I value="nananananananana batman!" oninput="test()">
<br><span id=O></span>

MATLAB, 291 bytes

Hesitei por muito tempo se eu deveria dar minha resposta. Eu estava apenas brincando com o MATLAB. Estou ciente de que não é realmente possível gerar código denso (um número baixo de instruções / bytes; cerca de três vezes mais do que suas soluções de ~ 100 bytes) e que o MATLAB pode não ser muito adequado ao código golf e eu sou novo no código golf . Mas eu simplesmente queria tentar, e o código funciona (caracteres de nova linha mantidos). Qualquer dica bem-vinda. : P

i=input('','s');
l=reshape(i,4,length(i)/4)';
m=']!- e';m(9)='*';m(12:22)='o[   + d  <';m(33:34)='1\';m(39)='>';m(57)='i';m(64)='n';
s='';
for k = 1:size(l,1)
n=l(k,:);
c=combvec(n,n);
t=triu(reshape(c(1,:)==c(2,:),4,4),1);
t=sum(t([5,9:10,13:15]).*2.^[5:-1:0]);
s=[s,m(t+1)];
end
display(s)

JavaScript (ES6), 115 101 bytes

s=>s.replace(/..../g,g=>"ni >\\1   <d+[o*e-!]"[[...g].map(c=>r=r*3+(m[c]=m[c]||++i)-1,i=r=0,m={})|r])

Economizou 14 bytes graças a @ edc65 !

Explicação

Armazena a lista de instruções em uma string com cada caractere no índice base-3. Por exemplo, +corresponde ao abacqual pode ser representado na base 3 como 0102ou 11em decimal. A única instrução que não pode ser representada na base 3 é ], mas com o algoritmo usado para calcular o número da base 3, ele acaba precisando convenientemente estar na posição 18 no final da string.

s=>
  s.replace(/..../g,g=>    // replace each four-character group with it's instruction
    "ni >\\1   <d+[o*e-!]" // list of instructions at their base-3 index
    [
      [...g].map(c=>       // for each character c
        r=r*3+(m[c]=m[c]   // shift r left and add the number associated with c to r
          ||++i)-1,        // if nothing is associated, associate the next number to c
                           // save i + 1 to m[c] so that it is truthy for 0
        i=                 // i = current number to assign to the next unique character
        r=0,               // r = 4-character group as a base-3 number
        m={}               // m = map of numbers assigned to each character
      )
      |r                   // return r
    ]
  )

Teste

var solution = s=>s.replace(/..../g,g=>"ni >\\1   <d+[o*e-!]"[[...g].map(c=>r=r*3+(m[c]=m[c]||++i)-1,i=r=0,m={})|r])

<input type="text" id="input" value="Programming Puzzles & Code Golof" />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

Python 2, 158 bytes

Toma entrada como "test". Saída é uma lista de caracteres.

def b(s,i=0):
    for c in s:i=i*4+s.index(c)
    return"n..i....>.\\1....<d.+[o.*e-!]"[i]
print map(b,(lambda l,n:[l[i:i+n]for i in range(0,len(l),n)])(input(),4))

Experimente online

Ungolfed:

def chunks(l, n):
    return (l[i:i+n] for i in range(0, len(l), n))

def convert(inst):
    i = 0
    for c in inst:
        i = i*4 + inst.index(c)

    return "n..i....>.\\1....<d.+[o.*e-!]"[i]

print map(convert, chunks(input(), 4))