व्याख्या दोमेगा

Question

इस चुनौती में, आप एक के लिए दुभाषिया लिखेंगे 2 ^Ω (के रूप में लिखित TwoMega ), शिथिल के आधार पर एक भाषा brainfuck एक अनंत आयामी भंडारण स्थान के साथ।

भाषा

2 ^Ω राज्य के तीन टुकड़े शामिल हैं:

• टेप , जो बिट्स की एक अनंत सूची है, सभी यह 0 पर प्रारंभ एक वाम-पंथी तत्व है, लेकिन कोई सबसे दायीं ओर का तत्व है।

• मेमोरी सूचक है, जो ग़ैर-ऋणात्मक पूर्णांक टेप में एक तत्व के एक सूचकांक है। एक उच्च मेमोरी पॉइंटर आगे दाईं ओर एक टेप सेल को संदर्भित करता है; 0 का एक मेमोरी पॉइंटर सबसे बाएं तत्व को संदर्भित करता है। मेमोरी पॉइंटर को 0 से इनिशियलाइज़ किया जाता है।

• अतिविम है, जो एक धारणात्मक है ∞ आयामी कोशिकाओं के "बॉक्स", जिनमें से प्रत्येक एक सा 0 पर प्रारंभ होता है अतिविम की चौड़ाई केवल 2 कोशिकाओं के लिए हर आयाम में ही है, लेकिन आयामों की अनन्तता की संख्या का मतलब कोशिकाएं बेशुमार हैं ।

हाइपरक्यूब में एक सूचकांक बिट्स की एक अनंत सूची है जो हाइपरक्यूब में एक सेल को संदर्भित करता है (उसी तरह बिट्स की एक सीमित सूची का उपयोग परिमित आयाम के हाइपरक्यूब को संदर्भित करने के लिए किया जा सकता है)। क्योंकि टेप बिट्स की एक अनंत सूची है, पूरा टेप हमेशा हाइपरक्यूब के एक तत्व को संदर्भित करता है; इस तत्व को रेफरेंट कहा जाता है ।

2 ^Ω 7 विभिन्न पात्रों को अर्थ देता है:

• < मेमोरी पॉइंटर को 1. से घटाकर इसे 0 से कम करना अपरिभाषित व्यवहार है, इसलिए आपको इसे संभालने की आवश्यकता नहीं है।
• > 1 से मेमोरी पॉइंटर को बढ़ाता है।
• ! संदर्भित पर थोड़ा फ़्लिप करता है।
• . संदर्भ में बिट को आउटपुट करता है।
• ^सेल पर बिट की जगह रेफरेंस में बिट के व्युत्क्रम के साथ टेप पर मेमोरी पॉइंटर द्वारा इंगित किया गया है ।
• [x]xजब तक संदर्भ में बिट 1 है तब तक कोड चलाता है।

चुनौती

आपका काम एक प्रोग्राम है जो इनपुट और कार्यान्वित के रूप में एक स्ट्रिंग लेता है लिखना है कि एक 2 के रूप में इनपुट ^Ω कार्यक्रम।

ये है कोड गोल्फ, इसलिए सबसे छोटा वैध उत्तर (बाइट्स में मापा गया) जीतता है।

टिप्पणियाँ

• आप मान सकते हैं कि कार्यक्रम में केवल वर्ण शामिल होंगे <>!.^[]और यह []ठीक से नेस्टेड होगा।
• आपका दुभाषिया केवल सिस्टम पर उपलब्ध स्मृति द्वारा सीमित होना चाहिए। यह उचित समय में नमूना कार्यक्रमों को चलाने में सक्षम होना चाहिए।

नमूना कार्यक्रम

प्रिंट 1:

!.

010 प्रिंट करें:

.!.!.

प्रिंट 0 हमेशा के लिए:

![!.!]

यदि !प्रीपेड हो तो हमेशा के लिए 0 या 1 हमेशा के लिए प्रिंट करें :

[.]![!.!]

Comments

एक छोटा नोट: भंडारण कोशिकाओं की संख्या वास्तव में बेशुमार नहीं है, क्योंकि 1टेप पर एस की संख्या हमेशा परिमित रहती है। वास्तव में, प्राकृतिक नंबरों और टेप स्टेट्स के बीच एक काफी सरल आक्षेप होता है (टेप कंटेंट को बैकवर्ड बाइनरी नंबर के रूप में व्याख्या करें), जो दर्शाता है कि हाइपरस्यूक मूल रूप से एक अनंत 1D सरणी है, जो एक पूर्णांक मूल्य में बिट्स को फ़्लिप करके एक्सेस किया जाता है। के बजाय / में / कमी के रूप में brainfuck में।

— लिन

इसके अलावा, फिर से: एक catकार्यक्रम लिखने के लिए आपका निमंत्रण : इनपुट लेने के लिए एक निर्देश नहीं लगता है।

— लिन

मुझे लगता है कि निर्देश सेट के अधिक उपयोग करके नमूना कार्यक्रम होना चाहिए। हम सरल हैं: .- एक एकल शून्य प्रिंट करता है और फिर मौजूद होता है; !^!.- एक एकल प्रिंट करता है फिर बाहर निकलता है। हालांकि अधिक अच्छा होगा। फिलहाल उन्हें सत्यापित करने के लिए सबमिशन को समझना चाहिए (और इसलिए उन्हें आगे बढ़ाना चाहिए!)

— जोनाथन एलन

@Lynn सेल पर 1 या 0 या [0,0,0,0,0,0,0...](यानी !कार्यक्रम की शुरुआत में उपस्थिति ) होने से दिया जाएगा।

— २२:३६ पर फलों के फल

फिर आप [.]![!.!]उस सेल के मूल्य को हमेशा के लिए प्रिंट करने के लिए कर सकते हैं

— लियो

Answer 1

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

t=h=I=0
m=1
E=''
for c in input():i='[<>!.^]'.find(c);E+=' '*I+'while+2**t&h: m/=2 m*=2 h^=2**t print+(2**t&h>0) t=t&~m|m*(2**t&h<1) #'.split()[i]+'\n';I-=~-i/5
exec E

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

t टेप है। t = 6 का अर्थ है टेप [0 1 1 0 0 0…]

मी मेमोरी पॉइंटर की शक्ति में 2 है। तो m = 8 का अर्थ है कि हम टेप 3 पर इंगित कर रहे हैं।

h हाइपरक्यूब है। h = 80 (बिट्स 4 और 6 सेट) का अर्थ है [0 0 1 0 ...] और [0 1 1 0 ...] बिट्स सेट हैं।

संदर्भ में बिट को पढ़ने के लिए, हम 2 ^टी एंड एच की जांच करते हैं । इसे पलटने के लिए, हम h ^ = 2 ^{t करते हैं} ।

हम पायथन कोड के निर्देशों का अनुवाद करते हैं और परिणाम निष्पादित करते हैं। मैं लूप के इंडेंटेशन लेवल को स्टोर करता हूं ।

Comments

या तो अपने कार्यक्रम या दूसरे टेस्ट मामला गड़बड़ है

— wastl

@wastl दूसरा परीक्षण मामला गलत था। ;)

— 6

कुछ पुनर्व्यवस्था,2**t (-6 बाइट्स के लिए) अतिरिक्त चर ।

— 2137

Answer 2

जावास्क्रिप्ट (Node.js) , 148 बाइट्स

x=>eval(x.replace(e=/./g,c=>({'<':'u/=2','>':'u*=2','!':'e[v]^=1','.':'alert(+!!e[v])','^':'v=(v|u)^u*e[v]','[':'while(e[v]){'}[c]||'}')+';',v=u=1))

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

यह पूरा हो रहा है

BoolFuck TwoMega
< >^>^>[!]^<<<<[!]^>>[!]!^>[!]!^>[!]!^<<<<(>^>^>1<<<<1>>0>0>0<<<<)
> ^<^<[!]^>>>>[!]^<<[!]!^<[!]!^<[!]!^>>>(^<^<1>>>>1<<0<0<0>>>)

सही स्थानों पर जाने के रूप में init की आवश्यकता है और 1 और वर्तमान पते के सही बिट को 1 के रूप में डालें ( >>>>>>>>^>^<)

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

nBoolFuck में जगह के रूप में लिखा है (0, 0, ..., 0(n*0), [1], 1, 0, 0, ...)।

के लिए >, यह n=> करता हैn+1

     0 0 0 0 0[1]1 0 0 0 0
^    0 0 0 0 0[x]1 0 0 0 0
<    0 0 0 0[0]x 1 0 0 0 0
^    0 0 0 0[y]x 1 0 0 0 0, yx != 01
<    0 0 0[0]y x 1 0 0 0 0
[!]^ 0 0 0[1]y x 1 0 0 0 0, (0yx10) = 0
>>>> 0 0 0 1 y x 1[0]0 0 0
[!]^ 0 0 0 1 y x 1[1]0 0 0, (1yx10) = 0
<<   0 0 0 1 y[x]1 1 0 0 0
[!]! 0 0 0 1 y[x]1 1 0 0 0, (1yx11) = 1
^    0 0 0 1 y[0]1 1 0 0 0
<    0 0 0 1[y]0 1 1 0 0 0
[!]! 0 0 0 1[y]0 1 1 0 0 0, (1y011) = 1
^    0 0 0 1[0]0 1 1 0 0 0
<    0 0 0[1]0 0 1 1 0 0 0
[!]! 0 0 0[1]0 0 1 1 0 0 0, (10011) = 1
^    0 0 0[0]0 0 1 1 0 0 0
>>>  0 0 0 0 0 0[1]1 0 0 0

कैसे <काम करना है?

Comments

क्या आप सुनिश्चित हैं कि यह अनुवाद मान्य है? बूलफक में !>.प्रिंट करता है 1, लेकिन टूमेगा में !>^.1 प्रिंट >करता है, जो ( टेप ^को प्रभावित नहीं करता है, टेप को प्रभावित नहीं करता है क्योंकि

— रेफरेंस

@EsolangingFruit +>;कर [1]00... 1[0]0...(उत्पादन 0), !>^.कर (0,0,...)=1, ptr=([0],0,...) (0,0,...)=1, ptr=(0,[0],...) (0,0,...)=1, ptr=(0,[1],...)(उत्पादन 0), क्या गलत है?

— l4m2

@EsolangingFruit के लिए !>., केवल बूलफक >में एक मान्य आदेश है ...

— केवल

@ l4m2 TwoMega में, !टेप सेल नहीं, रेफ़रेंट को इन्वर्ट करता है।

— 6

@EsolangingFruit तो यहाँ क्या गलत है?

— l4m2

Answer 3

ब्रेन-फ्लैक क्लासिक , 816 बाइट्स

<>(((<(())>)))<>{(([][][])(((({}){}[])({}))({})[]([][](({})(({}())(({}){}{}({}(<()>))<{<>({}<>)}{}>))))))(([]{()(<{}>)}{}){<((<{}>))<>(()(){[](<{}>)}{}<{({}[]<({}<>)<>>)}{}{}>)<>({()<({}<>)<>>}<<>{<>(({}){}<>({}<>)[])<>}{}<>({()<({}[]<<>({}<>)>)>}{})<>(({})<<>{({}[]<({}<>)<>>)}({}<>)<>{({}<>)<>}>)<>>)<>({}<>)<>>}{}([]{()(<{}>)}{}){{}<>({})(<>)}{}([]{()(<{}>)}{}){(<{}<>({}<{((<({}[])>))}{}{((<(())>))}{}>)<>>)}{}([]{()(<{}>)}{}){(<{}<>({}<({}())>)<>>)}{}([]{()(<{}>)}{}){(<{}<>[({})]<>>)}{}([]{()(<{}>)}{})<{((<{}>))<>{}({}<{<>(({}){}<>({}<>)[])<>}{}<>({()<({}[]<<>({}<>)>)>}{})<>(((){[](<{}>)}{})<<>{({}[]<({}<>)<>>)}{}(<>)<>{({}<>)<>}>)<>>)<>({}<>)<>}{}(<>)<>{({}<>)<>}{}>()){((({}[]<>){(<{}({}<>)>)}{}())<{({}<({}<>)<>((((((([][][]){}){}){}()){}){}({})())[][])>{[](<{}>)}{}{()(<{}>)}{})}{}({}<>)>[]){{}(<>)}}{}}

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

यह कोड सिर्फ इसलिए लिखा गया ताकि मेरे पास ट्यूरिंग-पूर्णता का प्रमाण लिखने के लिए एक जगह हो।

ट्यूरिंग-पूर्णता का प्रमाण

हम बूलफक से टूमेगा में कमी दिखाते हैं:

Boolfuck   TwoMega
>          >>
<          <<
.          !^!.!^!
[          !^![!^!
]          !^!]!^!
+          !^[!]^[>!^<[!]!^>[!]!^<]

यह अनुवाद टूल्मेगा में बूलफ़क राज्य को समान संख्या वाली टेप कोशिकाओं में संग्रहीत करता है। सभी अनूदित कमांड निम्नलिखित हमलावरों को संरक्षित करेंगे:

• मेमोरी पॉइंटर एक समान संख्या वाली सेल में होता है।
• सभी विषम-संख्या वाली टेप कोशिकाएँ शून्य हैं।
• सभी विषम संख्या वाले शून्य वाले किसी भी संभावित टेप के लिए, हाइपरक्यूब पर संबंधित मूल्य शून्य है।

स्निपेट !^![0]0 स्थिर रहेगा और बीच में स्वैप करेगा 0[0]और[1]1 ( जहां ध्यान मेमोरी पॉइंटर को हिलाए बिना हाइपरक्यूब पर पहुंची लाइन तक सीमित है)। जैसे, इसका उपयोग अस्थायी रूप से वर्तमान टेप मान को बूलफ़क कमांड के लिए संदर्भित करने के लिए किया जाता है जो इसकी परवाह करते हैं।

यदि TwoMega को ,अपेक्षित शब्दार्थ के साथ एक इनपुट कमांड दी जाती है , तो Boolfuck कमांड ,अनुवाद करेगी >^<,!^>[!]!^<। चूंकि ,यह साबित करने के लिए आवश्यक नहीं है कि बूलफक ट्यूरिंग-पूर्ण है, इसलिए इनपुट कमांड की कमी इस प्रमाण को प्रभावित नहीं करती है।

Comments

यह मुख्य रूप से क्यूब के बजाय हाइपरक्यूब में स्थिति में जानकारी संग्रहीत करता है?

— l4m2

@ l4m2 बूलफ़क से मेरी कमी क्यूब में किसी भी डेटा को संग्रहीत नहीं करती है। हाइपरक्यूब पर मैं जो भी 1s बनाता हूं, वह केवल टेप सेल को 0. पर सेट करने के लिए होता है

— नाइट्रोडॉन

Answer 4

अजगर 3 , 297 284 274 बाइट्स

-10 बाइट्स ओव्स और जोनाथन एलन के लिए धन्यवाद

C=input()
h={}
t=set()
def f(C,p):
 c=C[0];r=hash(frozenset(t));v=h.get(r,0)
 p={"<":p-1,">":p+1}.get(c,p)
 if'"'>c:h[r]=not v
 if"."==c:print(int(v))
 if"]"<c:t.discard(p)if v else t.add(p)
 if"["==c:
  while f(C[1:],p):1
 else:return c=="]"and v or C and f(C[1:],p)
f(C,0)

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

Comments

t.discard(p)->t-={p}

— shooqie

@shooqie जब तक काम नहीं करता tहै global।

— फर्ग्यूसक

@fergusq हालांकि मैं बहुत यकीन है कि यह काम करता है अगर आप की घोषणा fके रूप मेंf(C,p,t=set())

— shooqie

Answer 5

पिप , 75 71 बाइट्स

lPB0aR:^"!><[].^_""!:_
--viPU0
++v
W_{
}
O_
i@v:!_LFBilPB0
l@FBi"^n;Vau

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

2 ^{ates का} अनुवाद करता है बराबर पिप कोड और यह मूल्यांकन करता है में कोड।

हम टेप पॉइंटर *, और हाइपरक्यूब के लिए iटेप का प्रतिनिधित्व करने के लिए उपयोग करते हैं । पहले दो उपयोगी मूल्यों के लिए प्रांतीय रूप से आते हैं; के रूप में शुरू होता है , जिससे हम अनुक्रमण-खाली-सूची समस्याओं से बचने के लिए ( ) धक्का देते हैं ।vll[]0lPU0

^{* वास्तव में, यह टेप पॉइंटर की बिटवाइज नेगेटिव है, क्योंकि हम दशमलव में आसान रूपांतरण के लिए टेप को पीछे की ओर रख रहे हैं।}

बाकी कोड है:

aR:...;     Do a bunch of replacements in a, translating it into Pip code
       Va   Evaluate a
         u  Suppress output of the final expression that was evaluated

अनुवाद तालिका:

!  !:_
>  --viPU0
<  ++v
[  W_{
]  }
.  O_
^  i@v:!_LFBilPB0
_  l@FBi

l@FBiसंदर्भ है: lसूचकांक में हाइपरक्यूब का तत्व ( iबाइनरी से कन्वर्ट )। यह अक्सर दिखाई देता है, इसलिए हम इसे कॉल करते हैं _और _अंत में वास्तविक कोड के साथ प्रतिस्थापित करते हैं।

• !:_ तार्किक रूप से जगह में संदर्भदाता की उपेक्षा करता है।

• --viPU0घटाव v(दाईं ओर टेप पॉइंटर को स्थानांतरित करना); यह तब दूसरी 0तरफ बाईं ओर धकेलता है i, यह सुनिश्चित करने के लिए कि टेप पॉइंटर सीमा में रहता है।

• ++vवेतन वृद्धि v(सीमा-जाँच की आवश्यकता नहीं, प्रति ओपी)।

• W_{एक लूप चलाता है जबकि रेफ़रेंस सत्य है (यानी नॉनज़रो, यानी 1)।

• } पाश बंद कर देता है।

• O_ नई पंक्ति के बिना संदर्भित आउटपुट।

अंत में, के लिए ^:

i@v:            Set the current tape cell to
    !_          The logical negation of the referent
                Now, make sure the list representing the hypercube is long enough:
      LFBi      Loop frombinary(i) times:
          lPB0  Push another 0 to the end of l
                This ensures that FBi will always be a valid index into l