Étant donné une entrée de n'importe quel programme Glypho valide, sortez son équivalent "lisible par l'homme".

Le glypho est une idée esolang intéressante:

La référence d'instruction est donnée ici. Pour chaque instruction, les caractères abcd représentent les symboles composant chaque instruction. a fait référence au premier symbole unique, b fait référence au deuxième symbole unique, 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édit: Brian Thompson alias Wildhalcyon)}

Ainsi, par exemple, PPCGreprésenterait l' instruction Push -PPCG correspond au modèle aabc, où areprésente P, breprésente Cet c représente G.

L'entrée sera une chaîne unique composée uniquement de caractères ASCII imprimables. Il aura toujours une longueur divisible par quatre (duh).

La sortie est chaque groupe de quatre caractères de la chaîne d'entrée remplacé par l'instruction qu'ils désignent. Utilisez les noms d'instructions à une seule lettre (ceux juste après les cinq points dans le tableau cité ci-dessus).

Puisqu'il s'agit de code-golf , le code le plus court en octets gagnera.

Cas de test:

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

Pyth, 37 35 34 octets

Le code contient des caractères non imprimables, voici donc l' 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

Voici une version imprimable à 36 octets:

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

Essayez-le en ligne. Suite de tests.

Explication

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 octets

Enregistrement de 4 octets en empruntant l'idée de user81655 d'utiliser la base 3 au lieu de la base 4.

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

Exécutez tous les cas de test.

Il doit y avoir un meilleur moyen de compresser la table de recherche des commandes ...

JavaScript (ES6), 97

Pour chaque bloc de 4 caractères, je remplace chaque symbole par sa position dans le bloc, obtenant un nombre de base 4. Par exemple 'aabc' -> '0023'. Les nombres possibles sont compris entre 0..0123, c'est-à-dire 0..27 en décimal. J'utilise le nombre comme index pour trouver le bon caractère d'instruction à partir d'une chaîne de 28 caractères.

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

Tester

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 octets

J'ai longtemps hésité si je devais engager ma réponse. Je jouais juste avec MATLAB. Je suis conscient qu'il n'est pas vraiment possible de générer du code dense (un faible nombre d'instructions / octets; environ 3 fois plus gros que vos solutions de ~ 100 octets) et que MATLAB n'est peut-être pas trop approprié pour le golf de code et je suis nouveau dans le golf de code . Mais je voulais simplement essayer, et le code fonctionne (caractères de nouvelle ligne conservés). Tous les indices sont les bienvenus. : 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 octets

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

14 octets enregistrés grâce à @ edc65 !

Explication

Stocke la liste des instructions dans une chaîne avec chaque caractère à son index base-3. Par exemple, +correspond à abacce qui peut être représenté en base 3 comme 0102, ou 11en décimal. La seule instruction qui ne peut pas être représentée en base-3 est ], mais avec l'algorithme utilisé pour calculer le nombre en base-3, il finit commodément par devoir être à la position 18 à la fin de la chaîne.

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

Tester

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 octets

Prend l'entrée comme "test". La sortie est une liste de caractères.

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

Essayez-le en ligne

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