Dada una entrada de cualquier programa Glypho válido, genera su contraparte "legible para humanos".

Glypho es una idea interesante de esolang:

La referencia de instrucciones se da aquí. Para cada instrucción, los caracteres abcd representan los símbolos que componen cada instrucción. a se refiere al primer símbolo único, b se refiere al segundo símbolo único, 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, alias Wildhalcyon)}

Entonces, por ejemplo, PPCGrepresentaría la instrucción Push:PPCG coincide con el patrón aabc, donde arepresenta P, brepresenta Cy c representa G.

La entrada será una sola cadena que consta de solo caracteres ASCII imprimibles. Siempre tendrá una longitud divisible por cuatro (duh).

La salida es cada grupo de cuatro caracteres en la cadena de entrada reemplazado por la instrucción que designan. Utilice los nombres de instrucciones de una letra (los que aparecen justo después de los cinco puntos en la tabla citada anteriormente).

Como se trata de code-golf , ganará el código más corto en bytes.

Casos de prueba:

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

Pyth, 37 35 34 bytes

El código contiene caracteres no imprimibles, así que aquí está el 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

Aquí hay una versión imprimible de 36 bytes:

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

Pruébalo en línea. Banco de pruebas.

Explicación

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

Ahorro de 4 bytes prestando la idea del usuario 81655 de usar la base 3 en lugar de la base 4.

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

Ejecute todos los casos de prueba.

Tiene que haber una mejor manera de comprimir la tabla de búsqueda de comandos ...

JavaScript (ES6), 97

Para cada bloque de 4 caracteres, sustituyo cada símbolo con su posición en el bloque, obteniendo un número base 4. Por ejemplo 'aabc' -> '0023'. Los números posibles están en el rango 0..0123, es decir 0..27 en decimal. Utilizo el número como índice para encontrar el carácter de instrucción correcto de una cadena 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])

Prueba

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

Dudé durante bastante tiempo si debía comprometer mi respuesta. Solo estaba jugando con MATLAB. Soy consciente de que no es realmente posible generar código denso (un número bajo de instrucciones / bytes; aproximadamente 3 veces mayor que sus soluciones de ~ 100 bytes) y que MATLAB podría no ser demasiado adecuado para el golf de código y soy nuevo en el código de golf . Pero simplemente quería probar, y el código funciona (se mantienen los caracteres de nueva línea). Cualquier sugerencia bienvenida. :PAG

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

¡Guardado 14 bytes gracias a @ edc65 !

Explicación

Almacena la lista de instrucciones en una cadena con cada carácter en su índice de base 3. Por ejemplo, +corresponde a lo abacque se puede representar en base-3 como 0102, o 11en decimal. La única instrucción que no se puede representar en base-3 es ], pero con el algoritmo utilizado para calcular el número de base-3, convenientemente termina necesitando estar en la posición 18 al final de la cadena.

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

Prueba

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". La salida es una 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))

Pruébalo en línea

Sin golf:

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