ब्रेनफुल बनाना *** एनओपी

Question

कभी-कभी ब्रेनफॉक कोड लिखते समय, आप डिबगिंग को प्रोत्साहित करने के लिए इसे जरूरत से ज्यादा लंबा करने की जरूरत महसूस करते हैं । तुम ><वहाँ में एक plopping द्वारा यह कर सकता है , लेकिन क्या मज़ा है? अपने कोड को पढ़ने में किसी को भ्रमित करने के लिए आपको कुछ अधिक और कम NOPey की आवश्यकता होगी।

ब्रेनफक के लिए त्वरित परिचय

Brainfuck 1993 में शहरी मुलर द्वारा बनाई गई एक गूढ़ प्रोग्रामिंग भाषा है, और अपने अतिसूक्ष्मवाद के लिए उल्लेखनीय है। (विकिपीडिया)

Brainfuck आठ आज्ञाओं पर आधारित भाषा है +-><,.[]:। कोड को ट्यूरिंग मशीन की तरह चलाया जाता है: एक अनंत टेप जिस पर मूल्यों को बदला जा सकता है। इस चुनौती में, हम पहले चार पर ध्यान केंद्रित करेंगे:

+    increment the value at the pointer
-    decrement the value at the pointer
>    move the pointer right
<    move the pointer left

ब्रेनफॉक एनओपी

एक ब्रेनफॉक एनओपी ब्रेनफक वर्णों का एक क्रम है, जो किसी भी राज्य से निष्पादित होने पर, राज्य में कोई परिवर्तन नहीं करता है। वे ऊपर वर्णित चार वर्णों से मिलकर बने हैं।

चुनौती

चुनौती एक प्रोग्राम या फ़ंक्शन लिखना है, जिसे निष्पादित करते समय, दी गई लंबाई का एक यादृच्छिक ब्रेनफैक एनओपी उत्पन्न करता है।

इनपुट

आपको इनपुट के रूप में एक नॉनवेजेटिव यहां तक ​​कि पूर्णांक प्राप्त होगा n। (विषम के लिए NOP असंभव हैं n।)

उत्पादन

आप लंबाई के एक यादृच्छिक brainfuck एनओपी का उत्पादन करेंगे n।

नियम

• एनओपी की परिभाषा: जब कार्यक्रम का आउटपुट किसी ब्रेनफक प्रोग्राम में किसी भी बिंदु पर डाला जाता है, तो उक्त प्रोग्राम का व्यवहार किसी भी तरह से नहीं बदलना चाहिए। दूसरे शब्दों में, यह दुभाषिया की स्थिति को नहीं बदलना चाहिए।
  • ध्यान दें कि उदाहरण के +>-<लिए गलत है, क्योंकि यह दो कोशिकाओं के मूल्यों को बिना बदले उन्हें बदल देता है। कृपया पोस्ट करने से पहले इन के लिए अपने समाधान का परीक्षण करें।
  • यह भी ध्यान दें कि +>-<->+<एक एनओपी है जिसे केवल हटाकर कुछ भी नहीं किया जा सकता है >< <> +- -+। इस प्रकार, आप एक एल्गोरिथ्म का उपयोग नहीं कर सकते हैं जो सिर्फ एक दूसरे के अंदर इन सम्मिलित करता है।
• लंबाई के प्रत्येक वैध एनओपी के nआउटपुट में प्रदर्शित होने का एक नॉनज़रो मौका होना चाहिए। वितरण में एकरूपता नहीं है, हालांकि।
• प्रश्न में ब्रेनफैक दुभाषिया में मनमानी परिशुद्धता कोशिकाओं का एक दोगुना अनंत टेप है। यही है, आप दोनों दिशाओं में असीम रूप से जा सकते हैं, और प्रत्येक सेल को अनिश्चित काल के लिए बढ़ा / घटा सकते हैं।
• मेरी मशीन पर = 1 के लिएn कार्यक्रम 1 मिनट के भीतर समाप्त होना चाहिए , इसलिए सभी संभावित एनओपी उत्पन्न नहीं कर रहे हैं और एक उठा रहे हैं।
• यदि अमान्य इनपुट (नॉन-पूर्णांक, ऋणात्मक, विषम, आदि) दिए गए हैं तो आप दुर्घटना सहित कुछ भी कर सकते हैं।

स्कोरिंग

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

उदाहरण

यहाँ n= 4 के लिए सभी मान्य आउटपुट हैं :

++--    +-+-    +--+    --++    -+-+    -++-
>><<    ><><    ><<>    <<>>    <><>    <>><
><+-    ><-+    <>+-    <>-+
>+-<    >-+<    <+->    <-+>
+><-    -><+    +<>-    -<>+
+-><    -+><    +-<>    -+<>

यहाँ n= 20 के लिए कुछ संभावित आउटपुट दिए गए हैं :

+>>->+<->-<<<->>++<<
>+>-<+<->+-<>->+<-<+
+--+-++--++-+--+-++-
>>>>>>>>>+-<<<<<<<<<

Comments

यहाँ एक ब्रेनफैक एनओपी है +-<>जो आपके द्वारा पूछे गए उपयोग नहीं करता है :a

— भूमिगत '

मुझे नहीं लगता कि गैर-सरल एनओपी मौजूद हैं, इसलिए आप शायद उस योग्यता को हटा सकते हैं। .एक साइड-इफेक्ट है, ,एक मूल्य को ओवरराइट करता है जिसे उपयोग किए बिना पुनर्प्राप्त नहीं किया जा सकता है []। लेकिन []एक मूल्य को शून्य पर सेट कर देगा। यह []तब तक एक मान को अधिलेखित कर देता है (इसलिए हमें इसे पुनर्प्राप्त करने के लिए दूसरे की आवश्यकता होगी ) जब तक हम यह सुनिश्चित नहीं कर सकते कि प्रभावित सेल शून्य से शुरू होना था। हालांकि, हमें इस तरह की सेल की तलाश करनी होगी, जैसे कि कुछ भी हो [>], और हम जिस स्थिति से आए हैं, उस पर वापस लौटना असंभव है।

— मार्टिन एंडर

@Eumel "विचाराधीन ब्रेनफॉक दुभाषिया में मनमानी परिशुद्धता कोशिकाओं का एक दोगुना अनंत टेप है।"

— मार्टिन एंडर

कृपया ध्यान दें कि "ब्रेनफक" को सिस्टम स्तर पर प्रश्न शीर्षक में अब अनुमति नहीं है। ऐसा लगता है कि आप गैर-ASCII वर्णों का उपयोग करके प्रतिबंध को दरकिनार करने में सक्षम थे। भविष्य में, कृपया इस प्रतिबंध का पालन करें।

— एलेक्स ए।

@undergroundmonorail, यह पूरी तरह से ट्यूरिंग है ... इसलिए तकनीकी रूप से कोई भी किसी अन्य भाषा की तरह इसमें PRNG लिख सकता है। (हालांकि इसे

— बोना

Answer 1

सीजेएम, 62 59 बाइट्स

3 बाइट बचाने के लिए nhahtdh के लिए धन्यवाद।

क्योंकि किसी भी विशेष वितरण के लिए कोई आवश्यकता नहीं है, जब तक कि प्रत्येक no-op परिमित संभावना के साथ दिखाई देता है, हम इसे सरल रूप से एक संतुलित संख्या वाले स्ट्रिंग उत्पन्न करके -+और <>क्रमशः परीक्षण कर सकते हैं, यदि यह एक NOP है और इसे क्रमबद्ध कर रहा है तो नहीं है।

बेशक, लंबे समय तक इनपुट के लिए, यह लगभग हमेशा सॉर्ट किए गए आउटपुट में परिणाम होगा, लेकिन आप कुछ इनपुट के साथ कोड का परीक्षण कर सकते हैं जैसे 8कि यह देखते हैं कि यह सिद्धांत रूप में दी गई लंबाई के किसी भी एनओपी का उत्पादन कर सकता है।

ri_0a*\2/{;"-+<>":L2/mR}%smr:SL["Xa.Xm"3/2e*L]z:sers~0-S$S?

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

Comments

हां ... 10 सेकंड के तहत मनमानी सीमा n = 1000 होनी चाहिए। कंप्यूटर आज उपवास करने का एकमात्र तरीका है ^ ^ क्योंकि एल्गोरिथम उत्तर n = 1000 के लिए एक सेकंड के तहत भी हल करता है

— Falco

और भी बड़े n के लिए, मुझे लगता है कि आउटपुट को छांटना संभव है अगर संतुलित स्ट्रिंग NOP नहीं है। वितरण बहुत तिरछा है, लेकिन इसे प्रश्न द्वारा अनुमति दी गई है।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

@ n @h neata̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ यह एक साफ विचार है।

— मार्टिन एंडर

@ n @h thata̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ धन्यवाद, जो वास्तव में यहां तीन बाइट्स बचाता है।

— मार्टिन एंडर

Answer 2

CJam, 118 116 बाइट्स

यह हाथ से थोड़ा बाहर निकल गया ... विशेष रूप से दूसरी छमाही ऐसा लगता है जैसे यह बहुत गोल्फ होना चाहिए।

ri2/_)mr:R-"<>"R*mr_'=fm0\{1$+}%+__&e`]:\{mr1aa..+}*\@](\z:~\{~\("+-"*mr1$3$e=[{_,)mr_2$<@@>}*+]@@f{`1$`={(}@?\}W<}/

इसका परीक्षण यहां करें।

यह N = 100बहुत तुरन्त संभालती है। अब मेरे पास कोड के पूर्ण विखंडन को लिखने का समय नहीं है, इसलिए यहाँ एल्गोरिथ्म है:

• के एक यादृच्छिक संतुलित स्ट्रिंग उत्पन्न <और >यादृच्छिक (भी) के बीच की लंबाई के साथ 0और Nसमावेशी।
• इस ऐरे में टेप हेड पोजिशन को रिफल करें। जैसे "<>><"बन जाता है [0 '< -1 '> 0 '> 1 '< 0]।
• प्रक्रिया में सभी पदों की सूची प्राप्त करें।
• प्रत्येक ऐसी स्थिति के लिए एक खाली स्ट्रिंग को इनिशियलाइज़ करें। यह भी निर्धारित करें कि लंबाई के एक स्ट्रिंग तक पहुंचने के लिए कितने जोड़े वर्ण शेष हैं N।
• प्रत्येक शेष जोड़ी के +-लिए एक यादृच्छिक स्थिति के स्ट्रिंग में जोड़ें ।
• उन सभी तारों को साधा।
• प्रत्येक स्थिति के लिए निर्धारित करें कि वह स्थिति कितनी बार उभरी हुई सरणी में होती है, और संबंधित स्ट्रिंग को उस कई (यादृच्छिक-लंबाई) विखंडू में विभाजित करें।
• Riffled सरणी में, स्थिति की घटनाओं को इसके यादृच्छिक विखंडू से बदलें।

किया हुआ। यह इस अवलोकन पर आधारित है कि:

• किसी भी NOP के पास समान राशि होनी चाहिए <और >टेप हेड को मूल स्थिति में वापस करना होगा।
• कोड एक एनओपी होगा जब तक कि प्रत्येक टेप सेल बढ़े हुए के रूप में अक्सर घट जाता है।

के यादृच्छिक लेकिन संतुलित मात्रा में बांट कर +और -सभी स्थानों पर जहां टेप सिर जब किसी सेल पर है के बीच है, हम यह सुनिश्चित है कि हम हर संभव एनओपी पाते हैं।

Answer 3

गणितज्ञ, 350 बाइट्स

Quiet@(For[a="+",If[{##4}=={},#3!=0||Union@#!={0},Switch[#4,"+",#0[ReplacePart[#,#2->#[[#2]]+1],#2,#3,##5],"-",#0[ReplacePart[#,#2->#[[#2]]-1],#2,#3,##5],">",#0[#~Append~0,#2+1,#3+1,##5],"<",If[#2<2,#0[#~Prepend~0,1,#3-1,##5],#0[#,#2-1,#3-1,##5]]]]&@@{{0},1,0}~Join~Characters@a,a=""<>RandomSample@Flatten@RandomChoice[{{"+","-"},{">","<"}},#/2]];a)&

बहुत लंबा रास्ता? हाँ। क्या मुझे भी परवाह है? तब तक नहीं जब तक कि कोई दूसरा मान्य उत्तर नहीं देता।

Comments

क्या आप एक स्पष्टीकरण जोड़ना चाहेंगे, ताकि लोग वास्तव में खुद को समझा सकें कि यह वैध है? :)

— मार्टिन एंडर

यह वास्तव में कैसे काम करता है ? यदि मैं फ़ंक्शन को एक संख्या के साथ कॉल करता हूं तो यह केवल रिटर्न करता है +।

— मार्टिन एंडर 19

@ मार्टिनबटनर फिक्स्ड ... वर्तमान में, यह सिर्फ एक समान संख्या में +- -और <- >जोड़े के साथ यादृच्छिक कार्यक्रम बनाता है जब तक कि एक एनओपी नहीं होता। इसका आधा हिस्सा साधारण बीएफ दुभाषिया द्वारा लिया जाता है।

— 22

क्या वास्तव में एक मिनट के भीतर लंबाई 100 की वैध नो-ऑप उत्पन्न करता है?

— मार्टिन एंडर

@ मार्टिनबटनर हाँ। औसतन, मैं कहूंगा कि इसमें लगभग 5 सेकंड लगते हैं। सबसे पहले, मैंने पूरी तरह से यादृच्छिक कार्यक्रमों की कोशिश की, लेकिन यह कभी भी 100 की लंबाई के लिए समाप्त नहीं हुआ।

— लेगियन मैमल 978

Answer 4

पायथन 3 , 177 बाइट्स

from random import*
n=int(input())
r=[0]*n*3
p=0
a=[43,45]
s=choices(a+[60,62],k=n)
for c in s:p+=~c%2*(c-61);r[p]+=c%2*(44-c)
if any(r+[p]):s=a*(n//2)
print(*map(chr,s),sep='')

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

मैंने BF सिमुलेशन के लिए बब्बलर के उत्तर से कोड का उपयोग किया।

Answer 5

पायथन 3 , 163 बाइट्स

from random import*
n=int(input())
p=0;d=[0]*n;a=choices(b'+-<>',k=n)
for c in a:d[p]+=c%2*(44-c);p+=~c%2*(c-61)
if p|any(d):a=n//2*b'+-'
print(*map(chr,a),sep='')

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

पूर्ण कार्यक्रम जिसमें प्रिंट STDOUT का परिणाम है। बीएफ कोड चलाने वाली लाइन गोल्फ हो सकती है।

टायलो के दृष्टिकोण को अपनाया; यदि उत्पन्न BF कोड NOP नहीं है, तो इसे पूरी तरह से त्याग दें और '+-'बार-बार वापस आ जाएं ।

Comments

N = 100 के लिए टाइमआउट

— l4m2

@ l4m2 ने उस आवश्यकता पर ध्यान नहीं दिया। फिक्स्ड।

— बब्बलर

Answer 6

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

n=>[...s=c(i=n,t=c(n/2,r=[],f=_=>'+-'),f=_=>'+-<>'[Math.random()*4|0])].map(_=>_<'<'?(r[i]=_+1-~r[i]-1):(i+=_<'>'||-1))|r.some(eval)|i-n?t:s;c=n=>n?c(n-1)+f():r

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

Answer 7

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 224 बाइट्स

(s=RandomSample[##&@@@Table["<"">",(r=RandomInteger)[#/2]]];While[(g=Length@s)<#,s=Insert[s=Insert[s,"+",i=r@g+1],"-",RandomChoice@@Select[GatherBy[0~Range~++g,Count[#,"<"]-Count[#,">"]&@Take[s,#]&],!FreeQ[#,i]&]+1]];""<>s)&

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

यहां अन-गोल्‍फेड (या पूर्व में, पूर्व-गोल्‍फेड) संस्‍करण है:

Function[{n},
 k = RandomInteger[n/2];
 s = RandomSample[## & @@@ Table["<" ">", k]];
 While[Length[s] < n,
   s = Insert[s, "+", i = RandomInteger[Length[s]] + 1];
   p = GatherBy[Range[0, Length[s]], 
     Count[#, "<"] - Count[#, ">"]& @ Take[s, #]&];
   j = RandomChoice @@ Select[p, ! FreeQ[#, i] &]];
   s = Insert[s, "-", j + 1];
   ];
 ""<>s]

हम पहले की एक यादृच्छिक संख्या लेने <के और >'उपयोग करने के लिए है, और प्रत्येक की एक समान संख्या के साथ एक यादृच्छिक सूची उत्पन्न करते हैं।

बाकी पात्रों को भरने के लिए, हम एक पोजिशन चुनते हैं जिसमें एक जोड़ना है +, फिर एक ऐसी पोजिशन ढूंढें जहां पॉइंटर उसी स्थान पर इंगित करता है और -वहां जोड़ देता है।

सूची की लंबाई होने तक दोहराएं n, और परिणाम को कठोर करें।