Geben Sie bei Eingabe eines gültigen Glypho- Programms dessen "lesbares" Gegenstück aus.

Glypho ist eine interessante Esolang-Idee:

Die Anweisungsreferenz wird hier gegeben. Für jeden Befehl stehen die Zeichen abcd für die Symbole, aus denen jeder Befehl besteht. a bezieht sich auf das erste eindeutige Symbol, b bezieht sich auf das zweite eindeutige Symbol usw.

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 [

_{(Kredit: Brian Thompson aka Wildhalcyon)}

So PPCGwürde zum Beispiel die Push- Anweisung dargestellt - PPCGentspricht dem Muster aabc, wobei adarstellt P, bdarstellt Cund c darstellt G.

Die Eingabe ist eine einzelne Zeichenfolge, die nur aus druckbaren ASCII-Zeichen besteht. Es wird immer eine Länge haben, die durch vier (duh) teilbar ist.

Die Ausgabe ist jede Gruppe von vier Zeichen in der Eingabezeichenfolge, die durch die von ihnen angegebene Anweisung ersetzt wird. Verwenden Sie die aus einem Buchstaben bestehenden Anweisungsnamen (die in der obigen Tabelle nach den fünf Punkten stehen).

Da es sich um Code-Golf , wird der kürzeste Code in Bytes gewinnen.

Testfälle:

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

Pyth, 37 35 34 Bytes

Der Code enthält nicht druckbare Zeichen. Hier ist der 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

Hier ist eine druckbare Version mit 36 ​​Bytes:

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

Probieren Sie es online aus. Testsuite.

Erläuterung

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

Sparte 4 Bytes und borgte die Idee von user81655 aus, Base 3 anstelle von Base 4 zu verwenden.

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

Führen Sie alle Testfälle aus.

Es muss eine bessere Möglichkeit geben, die Nachschlagetabelle der Befehle zu komprimieren ...

JavaScript (ES6), 97

Für jeden Block mit 4 Zeichen ersetze ich jedes Symbol durch seine Position im Block und erhalte eine Zahl zur Basis 4. Zum Beispiel 'aabc' -> '0023'. Die möglichen Zahlen liegen im Bereich von 0..0123, dh 0..27 in Dezimalzahl. Ich benutze die Zahl als Index, um das richtige Anweisungszeichen aus einer Zeichenfolge mit 28 Zeichen zu finden.

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

Prüfung

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

Ich habe ziemlich lange gezögert, ob ich meine Antwort begehen sollte. Ich habe nur mit MATLAB rumgespielt. Mir ist bewusst, dass es nicht wirklich möglich ist, dichten Code zu generieren (eine geringe Anzahl von Anweisungen / Bytes; ungefähr dreimal so groß wie Ihre ~ 100-Byte-Lösungen), und dass MATLAB möglicherweise nicht zu gut für Code-Golf geeignet ist und ich neu im Code-Golf bin . Aber ich wollte es einfach versuchen, und der Code funktioniert (Zeilenumbrüche bleiben erhalten). Hinweise sind willkommen. : 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 bis 101 Byte

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 Bytes gespart dank @ edc65 !

Erläuterung

Speichert die Anweisungsliste in einer Zeichenfolge mit jedem Zeichen im Index zur Basis 3. Entspricht beispielsweise dem, +was abacin Basis 3 als 0102oder 11in Dezimal dargestellt werden kann. Der einzige Befehl, der in der Basis 3 nicht dargestellt werden kann, ist ], dass der Algorithmus, der zur Berechnung der Basis 3-Zahl verwendet wird, am Ende der Zeichenfolge auf Position 18 stehen muss.

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

Prüfung

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

Nimmt Eingaben wie "test". Die Ausgabe ist eine Liste von Zeichen.

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

Probieren Sie es online aus

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