गोल्फ एक बैंगनी दुभाषिया

बैंगनी एक एसोलंग है जिसे दो मुख्य उद्देश्यों के साथ डिज़ाइन किया गया है:

की एक न्यूनतम होना करने के लिए बैंगन , वहाँ के बाद से सिर्फ पर्याप्त स्वयं संशोधित एक अनुदेश भाषाओं के आसपास नहीं कर रहे हैं।
भयानक रूप से छोटे गोल्फ व्याख्याकारों की संभावना को स्वीकार करने के लिए । मेरा पहला पास काफी हद तक पाइथन 2 इंटरप्रेटर है जिसमें केवल 702 बाइट्स हैं, और मुझे यकीन है कि एक अधिक अनुभवी गोल्फर इससे थोड़ा बहुत दाढ़ी बना सकता है।

आपका लक्ष्य इस भाषा के लिए दुभाषिया लिखना है।

बैंगनी पर जानकारी:

एक बैंगनी कार्यक्रम एक अनंत, पता योग्य स्मृति सरणी में रखे गए वर्णों का एक क्रम है जैसे कि कार्यक्रम का पहला चरित्र पता शून्य पर रखा गया है। बाकी सरणी (दोनों जहां पहले और बाद में बैंगनी कार्यक्रम संग्रहीत किया जाता है) को शून्य पर आरंभीकृत किया जाता है।

बैंगनी में तीन रजिस्टर होते हैं, जिन्हें ए और बी और आई कहा जाता है , जिनमें से प्रत्येक पर हस्ताक्षर किए गए पूर्णांक को पकड़ कर रखा जा सकता है और इसे शून्य से आरंभ किया जाता है। मैं भी निर्देश सूचक हूं , और हमेशा वर्तमान में निष्पादित बैंगनी निर्देश को इंगित करता हूं ।

प्रत्येक चक्र, दुभाषिया निर्देश सूचक द्वारा इंगित मेमोरी स्थान से शुरू होने वाले तीन सन्निहित वर्णों के अनुक्रम को पढ़ेगा और इस अनुक्रम को बैंगनी निर्देश के रूप में निष्पादित करने का प्रयास करेगा। बाद में, निर्देश सूचक हमेशा 3 से बढ़ जाता है।

सिंथेटिक रूप से, बैंगनी निर्देश में एक पंक्ति में तीन वर्ण (या उसके एनकोडिंग) होते हैं, जैसे " xyz "।

पहला वर्ण x निम्नलिखित में से कोई भी हो सकता है:

abABio

इन प्रतीकों के निम्नलिखित अर्थ हैं:

a - Place the result in register a.
b - Place the result in register b.
A - Place the result in the location in memory referred to by register a.
B - Place the result in the location in memory referred to by register b.
i - Set the instruction pointer to the result.
o - Output the result to stdout.

अन्य दो बाइट्स y और z निम्न में से कोई भी हो सकते हैं:

abABio1

इन प्रतीकों में से प्रत्येक का निम्नलिखित अर्थ है:

a - Return the contents of register a.
b - Return the contents of register b.
A - Return the contents of the memory array at the address stored in register a.
B - Return the contents of the memory array at the address stored in register b.
i - Return the contents of register i (the instruction pointer).
o - Return the value of a single character read from stdin.
1 - Return the literal numeric value 1.

निर्देश प्राप्त करने के बाद, बैंगनी दुभाषिया y का मूल्यांकन करेगा और फिर z , y के परिणाम से z के परिणाम को घटाएगा , और फिर अंतर पर x द्वारा बताई गई क्रिया को करेगा।

यदि तीन वर्णों का क्रम (या उसमें संलग्न) एक मान्य बैंगनी निर्देश नहीं है, तो दुभाषिया बिना कोई त्रुटि दिए तुरंत रुक जाता है।

आपका दुभाषिया होना चाहिए:

एक पूर्ण कार्यक्रम हो, एक फ़ंक्शन नहीं।
जब तक EOF को नहीं पढ़ा जाता है , तब तक stderr को आउटपुट नहीं दिया जाता ।
नीचे दिए गए परीक्षण कार्यक्रमों सहित सभी अच्छी तरह से गठित इनपुट पर संदर्भ कार्यान्वयन के लिए व्यावहारिक रूप से व्यवहार करें, जिसमें बहुत बड़ी संख्या शामिल नहीं है। (खैर, पहचान समय तक - यह धीमी गति से चल सकता है, लेकिन बहुत अधिक नहीं!)

आप किसी भी रूप में आप दुभाषिया को कार्यक्रम प्रदान कर सकते हैं: इसे एक फ़ाइल से पढ़ें, इसे प्रोग्राम में एक स्ट्रिंग के रूप में एम्बेड करें, या इसे स्टड से पढ़ें।

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

कार्यक्रम

ooo

जब इनपुट के साथ चलाया जाता है

z!

उपज चाहिए

कार्यक्रम

bbboobiii

जब इनपुट के साथ चलाया जाता है

It's a cat program.

(या कोई अन्य इनपुट) उपज चाहिए

It's a cat program.

(या जो भी इनपुट प्राप्त हुआ है) और फिर शुरू करें और फिर से वही काम करें ।

कार्यक्रम

Aoab11bi1bABoAaiba

जब इनपुट के साथ चलाया जाता है

उपज चाहिए

और फिर रुका हुआ है, लेकिन जब इनपुट के साथ चलाया जाता है

आउटपुट जारी रखना चाहिए

सदैव।

कार्यक्रम

b1bbb1oAbabaa1ab1Ab1Bi1b

उपज चाहिए

b1bbb1oAbabaa1ab1Ab1Bi1b

कार्यक्रम

aA1aa1bb1oAbbi1bb1bbAb1Bi1b Purple is the awesomest! Why haven't you tried it yet?
!dlroW ,olleG

उपज चाहिए

Hello, World!

स्कोरिंग:

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा स्रोत, जैसा कि संभावित रूप से निम्न बोनस द्वारा संशोधित किया गया है, जीतता है।

बक्शीश:

-10% अगर आपका दुभाषिया स्टाइन से या कमांड लाइन तर्क से फ़ाइल नाम पढ़ता है और फ़ाइल से प्रोग्राम लोड करता है।

code-golf interpreter

— quintopia
स्रोत

मेमोरी कोशिकाओं का आकार क्या है? बाइट्स, वर्ण (यूनिकोड वाले?), (मनमानी) बड़े पूर्णांक? ऐसा लगता है कि आप एक ही अर्थ के साथ "चरित्र" और "बाइट" का उपयोग कर रहे हैं।

— पाओलो एबरमन 20

@ Pa @loEbermann मेरा अनुमान है कि यह कार्यान्वयन-विशिष्ट है; उदाहरण के लिए मुझे uint32ints के लिए पात्रों और MAXINT का उपयोग करने की आवश्यकता है

— बिल्ली

@sysreq क्या वास्तव में अवरोधक है? आपके कार्यान्वयन में केवल दो टेप हो सकते हैं, एक नकारात्मक और सकारात्मक सूचकांकों के लिए। (हां, यह थोड़ा अधिक कोड लेगा, लेकिन उतना नहीं, मुझे लगता है।)

— पाओलो एबरमन 16

@sysreq मूल रूप से, पर्पल सेल्फ-इंटरप्रेटर एक प्रोग्राम होगा जो स्टड से पर्पल प्रोग्राम को पढ़ता है और फिर उस प्रोग्राम को जो भी करना होता है करता है। पहला पर्पल प्रोग्राम (दुभाषिया) जो भी दुभाषिया आपको पसंद है उसमें चल सकता है। एक प्रोग्राम जो इनपुट के साथ सबसे कम मेमोरी पते को पूरी तरह से अधिलेखित करता है, फिर किसी भी तरह से पढ़ने के कोड में कूदने से पहले खुद को हटा देता है (हालांकि मुझे नहीं लगता कि यह वास्तव में संभव है)।

— क्विंटोपिया

मैं स्व-व्याख्या के लिए एक रनटाइम सक्षम होने के करीब आया, लेकिन मुझे बहुत देर हो चुकी थी।

— बिल्ली

जवाबों:

पायथ, 148 128 121 बाइट्स (या 124 *। 9 = 111.6, नीचे देखें)

J,00=kjb.z .eXHkCbz#=b-Fm?=zx"oabABi1"C@H+Zd@s[0Jm.x@Hk0JZ1H)zCh~tkS2 ?hKx"abAB"=YC@HZ?PKXH@JKbXJKb?qY\i=Zb?qY\opCbvN=+Z3

परीक्षण सूट

एसटीडीआईएन की पहली पंक्ति पर दिया गया कोड, बाकी एसटीडीआईएन पर बैंगनी कार्यक्रम के लिए इनपुट। कोड को नईलाइन के साथ उपयोग करने के लिए, नीचे की ओर वैकल्पिक संस्करण का उपयोग करें।

यथोचित रूप से गोल्फ। यहाँ यह स्पष्टता के लिए लाइनब्रेक और इंडेंटेशन के साथ है:

J,00
=kjb.z
 .eXHkCbz
#
  =b-Fm
    ?=zx"oabABi1"C@H+Zd
      @
        s[0Jm.x@Hk0JZ1H)
        z
      Ch~tk
    S2
   ?hKx"abAB"=YC@HZ
    ?PK
      XH@JKb
      XJKb
  ?qY\i=Zb
  ?qY\opCb
  vN
  =+Z3

मूल रूप से, एक #लूप निष्पादन और त्रुटि-विराम के माध्यम से रोक देता है।

aऔर b, एक एकल चर में जोड़ दिया जाता है J। Zनिर्देश सूचक है। kबैंगनी कार्यक्रम के लिए इनपुट है। Hटेप, एक शब्दकोश के रूप में प्रतिनिधित्व किया है। bवर्तमान परिणाम है। Yनिर्देश का पहला बाइट है।

फ़ाइल से पढ़ना:

J,00=kjb.z .eXHkCbjb'z#=b-Fm?q\o=zC@H+ZdCh~tk@s[Jm.x@Hk0JZ1H)x"abABi1"zS2 ?hKx"abAB"=YC@HZ?PKXH@JKbXJKb?qY\i=Zb?qY\opCbvN=+Z3

फ़ाइल का नाम STDIN की पहली पंक्ति के रूप में दें। परीक्षण चालन:

$ cat purple-final.pyth 
J,00=kjb.z .eXHkCbjb'z#=b-Fm?=zx"oabABi1"C@H+Zd@s[0Jm.x@Hk0JZ1H)zCh~tkS2 ?hKx"abAB"=YC@HZ?PKXH@JKbXJKb?qY\i=Zb?qY\opCbvN=+Z3
$ cat purple-code.txt 
aA1aa1bb1oAbbi1bb1bbAb1Bi1b Purple is the awesomest! Why haven't you tried it yet?
!dlroW ,olleG
$ pyth purple-final.pyth <<< 'purple-code.txt' 
Hello, World!

— isaacg
स्रोत

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

eval(`a=b=i=d=0;v=n=>(x=m[i+n])==97?a_98?b_65?m[a]_66?m[b]_105?i_111?p()[c]()_49?1:d=1;for(m=[...(p=prompt)()].map(b=>b[c="charCodeAt"]());!d;i+=3)(y=v(1),d)||(z=v(2),d)?1:(x=m[r=y-z,i])==97?a=r_98?b=r_65?m[a]=r_66?m[b]=r_105?i=r-3_111?alert(String.fromCharCode(r)):d=1`.replace(/_/g,":x=="))

व्याख्या

जावास्क्रिप्ट उत्तर हमेशा अजीब होते हैं STDINऔर जब STDOUTआवश्यक होते हैं ...

पहला संकेत प्रोग्राम स्ट्रिंग के लिए इनपुट है। प्रत्येक संकेत जो एक oनिर्देश से उत्पन्न होता है, केवल पहला वर्ण पढ़ेगा।

evalएक सामान्य वाक्यांश को बदलने के लिए उपयोग किया जाता है जो कुछ बाइट्स को बचाता है। Ungolfed और evalकार्यक्रम के बिना ऐसा दिखता है:

// Initialisation
a=b=i=                            // initialise registers to 0
  d=0;                            // d is set to true when the program should die

// Gets the result of Y or Z
v=n=>                             // n = offset from i
  (x=m[i+n])==97?a:               // x = value of instruction
  x==98?b:
  x==65?m[a]:
  x==66?m[b]:
  x==105?i:
  x==111?p()[c]():
  x==49?1:
  d=1;                            // if it was none of the valid values, die

// Execution loop
for(
  m=                              // m = memory array
    [...(p=prompt)()]             // receive the program
    .map(b=>b[c="charCodeAt"]()); // initialise m to the ASCII values of the program
  !d;                             // finish if an error occured
  i+=3                            // increment i
)
  (y=v(1),d)||                    // get the value of Y and check for errors
  (z=v(2),d)?1:                   // get the value of Z and check for errors

    // Get the result of X
    (x=m[r=y-z,i])==97?a=r:       // r = result of y - z
    x==98?b=r:
    x==65?m[a]=r:
    x==66?m[b]=r:
    x==105?i=r-3:
    x==111?alert(String.fromCharCode(r)):
    d=1

— user81655
स्रोत

क्या दूसरे c="charCodeAt"को बस के साथ बदला जा सकता है c?

— डेन्ड्रोबियम

क्या नकारात्मक सूचकांक के साथ सरणी का उपयोग जावास्क्रिप्ट में काम करता है?

— नीम

@ डेंड्रोबियम वाह, मुझे नहीं पता कि मैंने उस हाहा को कैसे याद किया! धन्यवाद।

— user81655

@ निमि यह काम करता है। Arrays खुद नकारात्मक सूचकांकों का समर्थन नहीं करते हैं, लेकिन यह इस तथ्य का लाभ उठाता है कि वे वस्तुओं के रूप में भी व्यवहार करते हैं। array[-1] = 1के रूप में ही है array = { "-1": 1 }। दोनों के साथ पहुँचा जा सकता है array[-1]।

— user81655

@ user81655: आह अच्छा, यह नहीं पता था।

— नीमी

सीलोन, 827 792 671 बाइट्स

import ceylon.language{l=variable,I=Integer,x=nothing,p=process,m=map}shared void run(){try{if(exists d=p.arguments[0]){l value t=m{*d*.hash.indexed};l I a=0;l I b=0;l I i=0;I g(I j)=>t[j]else 0;l{I*}c=[];I o{if(c==[]){if(exists e=p.readLine()){c=e*.hash.chain{10};}else{c={-1}.cycled;}}assert(is I r=c.first);c=c.rest;return r;}value f=m{97->{a},98->{b},65->{g(a)},66->{g(b)},105->{i},111->{o},49->{1}};value s=m{97->((I v)=>a=v),98->((I v)=>b=v),65->((I v)=>t=m{a->v,*t}),66->((I v)=>t=m{b->v,*t}),105->((I v)=>i=v),111->((I v)=>p.write("``v.character``"))};I h(I v)=>f[v]?.first else x;while(0<1){(s[g(i)]else x)(h(g(i+1))-h(g(i+2)));i+=3;}}}catch(AssertionError e){}}

जब संदर्भ ईओएफ पर इनपुट को पढ़ने की कोशिश करता है, तो यह संदर्भ कार्यान्वयन की तुलना में थोड़ा अलग व्यवहार करता है - संदर्भ कार्यान्वयन एक टाइपएयर के साथ दुर्घटनाग्रस्त हो जाता है, जो कि यहां पुन: पेश करने के लिए बहुत महंगा है (और एक बग की संभावना भी है), इसलिए यह बदले में -1 लौटेगा ( बार-बार, यदि आवश्यक हो)।

(जब स्टडआउट को यह -1 लिखने की कोशिश की जा रही है, तो दुभाषिया एक ओवरफ़्लो के साथ समाप्त हो जाएगा। हालांकि, ऐसा ही होगा यदि यूनीकोड रेंज के बाहर एक इंटेगर आउटपुट है।)

दुभाषिया कार्यक्रम को अपनी पहली कमांड लाइन तर्क के रूप में लेता है (जब यह व्हॉट्सएप या अन्य दिलचस्प सामग्री शामिल हो तो अपने शेल के लिए इसे उद्धृत करना सुनिश्चित करें)।

सीलोन में हम केवल आसानी से इनपुट लाइन-वार पढ़ सकते हैं (मुझे लगता है कि यह अगले संस्करणों में से एक में बदल जाएगा), इसलिए जब oपढ़ने के लिए उपयोग किया जाता है , तो मैं एक पूरी लाइन पढ़ रहा हूं और भविष्य के उपयोगों के लिए भागों को बफर करता हूं। मुझे लगता है कि यह एक टर्मिनल से जुड़े होने पर पायथन कार्यान्वयन में समान काम करता है।

जब एक कमांड (भाग) को निष्पादित करने का प्रयास किया जाता है, जो वैध वर्णों में से एक नहीं है, तो nothingएक जोर का जोर दिया जाएगा, जिसे हम मुख्य लूप के चारों ओर पकड़ने वाले ब्लॉक में पकड़ते हैं।

मुझे लगता है कि यह अधिमानतः एक कस्टम अपवाद प्रकार होना चाहिए (क्योंकि AssertionError अन्य स्थानों पर भी हो सकता है यदि मेरे पास एक बग है), लेकिन यह बहुत अधिक स्थान लेगा, सबसे पहले संस्करण से किए गए सुधारों को खाकर।

गोल्फिंग के लिए उपयोग किए जाने वाले कुछ ट्रिक्स:

पिछले संस्करणों ने ceylon.collection.HashMap का उपयोग किया था - इसके बजाय अब हम mapफ़ंक्शन द्वारा बनाए गए एक अपरिवर्तनीय मानचित्र का उपयोग करते हैं, और प्रत्येक बार एक नया बनाते हैं Aया x केB रूप में उपयोग किया जाता है ।
मैं ceylon.language से सभी पहचानकर्ताओं के लिए उपनाम-आयात का उपयोग करता हूं जो एक से अधिक बार उपयोग किए जाते हैं ( variableएनोटेशन सहित , जो अब है l)।
मुझे कक्षा E(पर्यावरण के लिए) और s(चरण) विधि से छुटकारा मिल गया - अब सब कुछ runफ़ंक्शन के अंदर होता है ।
.integerकिसी वर्ण का कोडपाइंट प्राप्त करने के लिए उपयोग करने के बजाय , .hashवही परिणाम देता है। इस प्रकार के string*.hashरूप में ही है string.map(Character.integer)(एक स्ट्रिंग से कोडपाइंट की पुनरावृत्ति देता है)।
जब कोई प्रकार अन्य रूप से आयात किया जाता है, is I ...से छोटा होता है exists ...।
जब किसी चीज़ (जैसे x) को एक स्ट्रिंग में परिवर्तित किया जाता है, "``t``"तो t.string(या, जो मैंने एक चरित्र के लिए इस्तेमाल किया है String{t}) से कम है।
कार्यों का उपयोग केवल एक बार किया जा सकता है।

यहाँ स्वरूपित (और टिप्पणी) संस्करण है:

// Purple – a self-modifying, "one-instruction" language.
//
// Question:  http://codegolf.stackexchange.com/q/65411/2338
// My answer: http://codegolf.stackexchange.com/a/65492/2338

import ceylon.language {
    l=variable,
    I=Integer,
    x=nothing,
    p=process,
    m=map
}

shared void run() {
    try {
        // Reading code from file certainly takes more than 73 characters,
        // this isn't worth the 10% bonus.
        if (exists d = p.arguments[0]) {

            // The memory tape, as a Map<Integer, Integer>.
            // We can't modify the map itself, but we
            // can replace it by a new map when update is needed.
            l value t = m {
                // It is initialized with the code converted to Integers.
                // We use `.hash` instead of `.integer` because it is shorter.
                *d*.hash.indexed };

            // three registers
            l I a = 0;
            l I b = 0;
            l I i = 0;

            // get value from memory
            I g(I j) =>
                    t[j] else 0;

            // cached input which is still to be read
            l {I*} c = [];

            // get value from stdin.
            // we can only comfortably access stdin by line, so we read a whole line
            // and cache the rest for later.
            I o {
                if (c == []) {
                    if (exists e = p.readLine()) {
                        c = e*.hash.chain { 10 }; // convert string into ints, append \n
                    } else {
                        // EOF – return just -1 from now on.
                        c = { -1 }.cycled;
                    }
                }
                assert (is I r = c.first);
                c = c.rest;
                return r;
            }


            // Map of "functions" for fetching values.
            // We wrap the values in iterable constructors for lazy evaluation
            //  – this is shorter than using (() => ...).
            // The keys are the (Unicode/ASCII) code points of the mapped
            // source code characters.
            value f = m {
                // a
                97 -> { a },
                // b
                98 -> { b },
                // A
                65 -> { g(a) },
                // B
                66 -> { g(b) },
                // i
                105 -> { i },
                // o
                111 -> { o },
                // 1
                49 -> { 1 }
            };

            // Map of functions for "storing" results.
            // The values are void functions taking an Integer,
            // the keys are the ASCII/Unicode code points of the corresponding
            // source code characters.
            value s = m {
                // a
                97 -> ((I v) => a = v),
                // b
                98 -> ((I v) => b = v),
                // Modification of the memory works by replacing the map with a new one.
                // This is certainly not runtime-efficient, but shorter than importing
                // ceylon.collections.HashMap.
                // A
                65 -> ((I v) => t = m { a->v, *t }),
                // B
                66 -> ((I v) => t = m { b->v, *t }),
                // i
                105 -> ((I v) => i = v),
                // o – output as a character.
                111 -> ((I v) => p.write("``v.character``"))
            };

            // accessor function for the f map
            I h(I v) =>
                    f[v]?.first else x;

            // the main loop, can only be left by exception
            while (0 < 1) {
                (s[g(i)] else x)(h(g(i + 1)) - h(g(i + 2)));
                i += 3;
            }
        }
    } catch (AssertionError e) {
        // abort silently
    }
}

— पाओलो एबरमन
स्रोत

मैंने एक "समानांतर दुभाषिया" के लिए उस कोड का हिस्सा पुन: उपयोग किया जो सभी पड़ाव कार्यक्रमों को खोजने की कोशिश कर रहा था। (उनमें से कई हैं।) (वहाँ मैंने बैंगनी का एक गैर-I / O संस्करण का उपयोग किया, क्योंकि I / O बहुत स्थान लेता है और उस कार्य में उपयोग नहीं किया जाता है।)

— Palolo Ebermann