एक ग्लिफ़ो कार्यक्रम का अनुवाद करें

Question

किसी भी मान्य ग्लिफ़ो कार्यक्रम के इनपुट को देखते हुए , इसके "मानव-पठनीय" समकक्ष का उत्पादन किया।

ग्लाइफो एक दिलचस्प एसोलैंग विचार है:

निर्देश संदर्भ यहां दिया गया है। प्रत्येक निर्देश के लिए, अक्षर abcd प्रत्येक निर्देश को रचने वाले प्रतीकों का प्रतिनिधित्व करते हैं। पहले अनूठे प्रतीक को संदर्भित करता है, ख को दूसरे अद्वितीय प्रतीक को संदर्भित करता है, आदि।

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 [

_{(क्रेडिट: ब्रायन थॉम्पसन उर्फ वाइल्डहिल्सन)}

इसलिए, उदाहरण के लिए, पुश निर्देश का PPCGप्रतिनिधित्व करेगा-PPCG पैटर्न से मेल खाता है aabc, जहां aप्रतिनिधित्व करता है P, bप्रतिनिधित्व करता है C, और c प्रतिनिधित्व करता है G।

इनपुट एक एकल स्ट्रिंग होगा जिसमें केवल मुद्रण योग्य ASCII वर्ण होंगे। यह हमेशा चार (duh) से विभाज्य लंबाई होगी।

आउटपुट इनपुट स्ट्रिंग में चार वर्णों के प्रत्येक समूह को प्रतिस्थापित करता है, जिसके द्वारा वे निर्देशन करते हैं। एकल-पत्र निर्देश नामों का उपयोग करें (ऊपर उद्धृत तालिका में पांच बिंदुओं के ठीक बाद वाले)।

चूंकि यह कोड-गोल्फ है , बाइट्स में सबसे छोटा कोड जीत जाएगा।

परीक्षण के मामलों:

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

Comments

आह हां कोड गोलफ। मेरा पसंदीदा छींटा।

— कोरियाईवॉलेजेस

Answer 1

पायथ, 37 35 34 बाइट्स

कोड में अनपेक्षित वर्ण हैं, इसलिए यहां xxdहेक्सडंप है:

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

यहाँ 36 बाइट्स पर एक मुद्रण योग्य संस्करण है:

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

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

व्याख्या

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

Answer 2

CJam, 42 39 35 बाइट्स

आधार 4 के बजाय बेस 3 का उपयोग करने के उपयोगकर्ता81655 के विचार से 4 बाइट्स की बचत हुई।

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

सभी परीक्षण मामलों को चलाएं।

आदेशों के लुकअप टेबल को संपीड़ित करने का एक बेहतर तरीका होगा ...

Answer 3

जावास्क्रिप्ट (ईएस 6), 97

4 वर्णों के प्रत्येक ब्लॉक के लिए, मैं प्रत्येक प्रतीक को ब्लॉक में अपनी स्थिति के साथ प्रतिस्थापित करता हूं, आधार 4 नंबर प्राप्त करता है। उदाहरण के लिए 'aabc' -> '0023'। अधिभोग संख्या 0..0123 की सीमा में है, जो दशमलव में 0..27 है। मैं 28 वर्ण स्ट्रिंग से सही निर्देश वर्ण खोजने के लिए एक इंडेक्स के रूप में संख्या का उपयोग करता हूं।

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

परीक्षा

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>

Answer 4

MATLAB, 291 बाइट्स

अगर मुझे अपना जवाब देना चाहिए तो मैं काफी देर तक हिचकिचाया। मैं बस MATLAB के साथ खेल रहा था। मुझे पता है कि घने कोड (निर्देशों की कम संख्या / बाइट्स उत्पन्न करना संभव नहीं है; आपके ~ 100 बाइट समाधानों की तुलना में लगभग 3 गुना लार्जर) और MATLAB कोड गोल्फ के लिए बहुत उपयुक्त नहीं हो सकता है और मैं कोड गोल्फ के लिए नया हूं । लेकिन मैं बस कोशिश करना चाहता था, और कोड काम करता है (newline characters)। किसी भी संकेत का स्वागत करते हैं। : पी

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)

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! सभी जवाबों का स्वागत है, भले ही वे एक हास्यास्पद राशि से बढ़ गए हों (निश्चित रूप से मेरे साथ पहले भी हो चुके हैं)। ;) अच्छा पहला जवाब!

— दरवाज़े

Answer 5

जावास्क्रिप्ट (ईएस 6), 115 101 बाइट्स

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

@ Edc65 के लिए धन्यवाद, 14 बाइट्स सहेजे गए !

व्याख्या

आधार -3 सूचकांक में प्रत्येक वर्ण के साथ एक स्ट्रिंग में निर्देशों की सूची संग्रहीत करता है। उदाहरण के लिए, से +मेल खाता है abacजो बेस -3 में 0102, या 11दशमलव में दर्शाया जा सकता है । एकमात्र निर्देश जिसे बेस -3 में प्रस्तुत नहीं किया जा सकता है ], लेकिन बेस -3 नंबर की गणना करने के लिए उपयोग किए गए एल्गोरिदम के साथ, यह आसानी से स्ट्रिंग के अंत में स्थिति 18 पर होने की आवश्यकता को समाप्त करता है।

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

परीक्षा

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>

Comments

आप कई बाइट्स parseIntको बार-बार राशि और गुणा करके नंबर का उपयोग और कंप्यूटिंग नहीं कर सकते हैं । यह '0123' की समस्या से बचता है जो कि आधार 3 में अमान्य है लेकिन 1 * 9 + 2 * 6 + 3 == 18 देता है जो एक अच्छी स्थिति है। परिणाम:F=s=>s.replace(/..../g,g=>"ni]>\\1 <d+[o*e-!]"[[...g].map(c=>r=r*3+(m[c]=m[c]||++i)-1,r=i=0,m={})|r])

— edc65

@ edc65 महान सुझाव। धन्यवाद!

— user81655 11

Answer 6

पायथन 2, 158 बाइट्स

जैसे इनपुट लेता है "test"। आउटपुट पात्रों की एक सूची है।

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

इसे ऑनलाइन आज़माएं

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