Stackylogic चलाएं

Question

Stackylogic एक तर्क आधारित प्रोग्रामिंग भाषा मैं में है कि ले बना हुआ है 0की और 1इनपुट के लिए की है और एक ही आउटपुट 0या 1पर पूरा होने के।

एक स्टैकलॉजिक प्रोग्राम में लाइनें शामिल होती हैं जिसमें केवल तीन वर्णों के 01?साथ-साथ <लाइनों में से एक के अंत में एक भी शामिल हो सकता है। लाइन्स खाली नहीं हो सकती और के साथ लाइन <में कम से कम एक होना चाहिए 0, 1या ?यह पहले।

यहाँ एक नमूना कार्यक्रम है (जैसा कि मैं समझाता हूँ) दो बिट्स के NAND की गणना करता है :

1
?<
11
?
0

Stackylogic प्रोग्राम की प्रत्येक पंक्ति को एक स्टैक माना जाता है , जिसमें बाईं ओर नीचे और दाईं ओर शीर्ष होता है। स्पष्ट रूप से, एक कार्यक्रम में पहली पंक्ति से पहले और आखिरी पंक्ति के बाद एक खाली स्टैक (खाली लाइन) होता है।

<है, जो हम फोन करता हूँ कर्सर , निशान स्टैक पर शुरू करने के लिए जब एक Stackylogic कार्यक्रम चलाया जाता है। इस तरह के रूप में एक Stackylogic कार्यक्रम आय का निष्पादन:

1. वर्तमान में कर्सर जिस स्टैक को इंगित कर रहा है, उसके शीर्ष वर्ण को पॉप करें।

   • यदि चरित्र है ?, तो उपयोगकर्ता को a 0या a के लिए संकेत दें 1और मान लें कि वह चरित्र था।
   • यदि चरित्र है 0, तो कर्सर को एक स्टैक अप करें (वर्तमान लाइन के ऊपर की रेखा पर)।
   • यदि चरित्र है 1, तो कर्सर को एक स्टैक डाउन (वर्तमान लाइन के नीचे की रेखा पर) ले जाएं।

2. यदि स्टैक कर्सर को खाली करता है, तो पिछले मान को स्टैक (हमेशा 0या एक 1) से पॉपअप किया गया है , और प्रोग्राम को समाप्त करें।

3. एल्स, यदि स्टैक कर्सर को स्थानांतरित करने के लिए खाली नहीं है, तो चरण 1 पर वापस जाएं और प्रक्रिया को दोहराएं।

ध्यान दें कि स्टैकलॉजिकल प्रोग्राम हमेशा समाप्त होते हैं क्योंकि उन्हें अंततः अपने स्टैक को पूरा करना होगा।

नंद उदाहरण

NAND प्रोग्राम में कर्सर एक पर शुरू होता है ?:

1
?<
11
?
0

हम मान लेते हैं कि एक 1बार ?पॉपअप होने पर उपयोगकर्ता इनपुट करेगा, जिसका अर्थ है कि कर्सर नीचे जाएगा, जिससे प्रोग्राम इस तरह दिखाई देगा:

1

11<
?
0

अब 1कर्सर स्टैक के शीर्ष पर एक मैदान है। यह विधिवत रूप से बंद है और कर्सर फिर से चलता है:

1

1
?<
0

अब उपयोगकर्ता इनपुट के 0लिए मान लें ?, जिसका अर्थ है कि कर्सर ऊपर जाएगा:

1

1<

0

फिर से, 1कर्सर स्टैक पर है इसलिए कर्सर पॉप होता है और नीचे जाता है:

1


<
0

अंत में कर्सर स्टैक खाली होता है, इसलिए अंतिम मान पॉप होता है, 1आउटपुट होता है और प्रोग्राम समाप्त होता है।

यह एक NAND गेट के लिए सटीक है क्योंकि 1 NAND 0है 1। यदि आप जांचना चाहते हैं तो यह पाठ्यक्रम अन्य तीन दो-बिट इनपुट के लिए काम करता है।

या उदाहरण है

यह स्टैकलॉजिक प्रोग्राम एक OR गेट का अनुकरण करता है :

?
?<

यह देखना आसान है कि 1कर्सर का एक प्रारंभिक इनपुट कर्सर को अंतिम पंक्ति के नीचे निहित खाली स्टैक में धकेल देगा, कार्यक्रम को समाप्त करने और 1इसे केवल इनपुट करने के लिए आउटपुट देगा।

00दूसरी ओर एक इनपुट के लिए, कर्सर शीर्ष पर निहित खाली स्टैक के लिए अपना रास्ता बना देगा, प्रोग्राम को समाप्त करके 0इनपुट होने के लिए अंतिम आउटपुट देगा।

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखिए जो स्टैकलॉजिक प्रोग्राम को एक स्ट्रिंग के रूप में लेता है और इसे चलाता है, जिसके परिणामस्वरूप 0या वापस लौटता है 1।

पर ?के लिए, आप एक के लिए उपयोगकर्ता का संकेत दे सकता 0या 1इनपुट, या का एक पूर्व निर्धारित स्ट्रिंग से मूल्य को पढ़ने 0के लिए और 1के है कि आप भी इनपुट के रूप में लेते हैं। (यह आपके प्रोग्राम / फ़ंक्शन के लिए एक और स्ट्रिंग इनपुट हो सकता है या आप प्रोग्राम स्ट्रिंग की पहली या अंतिम पंक्ति इनपुट स्ट्रीम हो सकते हैं)।

आप प्रोग्राम मान सकते हैं और इनपुट हमेशा अच्छी तरह से बनता है। आप वैकल्पिक रूप से मान सकते हैं कि इनपुट प्रोग्राम एक एकल अनुगामी न्यूलाइन के साथ आते हैं (हालांकि याद रखें कि अंत में एक निहित खाली स्टैक है)।

बाइट्स में सबसे छोटा कोड जीतता है।

अधिक नमूना कार्यक्रम

ZERO
0<

ONE
1<

BUFFER
?<

NOT
1
?<
0

AND
?<
?

NAND
1
?<
11
?
0

OR
?
?<

NOR
1
?
00
?<
0

XOR(v1)
?
0
1?<
?
0

XOR(v2)
?
?<
11
?
0

XNOR(v1)
1
?
0?<
1
?

XNOR(v2)
1
?
00
?<
?

MEDIAN(v1)
1
???<
0

MEDIAN(v2)
?
1?<
??

^{मंझले कार्यक्रमों के लिए धन्यवाद मार्टिन ।}

Comments

यदि आप 3-इनपुट फ़ंक्शन जोड़ना चाहते हैं, तो माध्य को लागू करने का एक तरीका है ?\1?<\??:। वैकल्पिक रूप से, यहां एक सममित 5-लाइन कार्यान्वयन है:?\?0\?<\?1\?

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

ओह, मैं एक भी भोजनालय कार्यान्वयन पाया 1\???<\0:।

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

@ 3-इनपुट माध्यिका फ़ंक्शन (समान रूप से, बहुमत-नियम फ़ंक्शन) के मार्टिनएंडर के खाने का कार्यान्वयन सामान्य रूप से होता है। उदाहरण के लिए, 7-इनपुट बहुमत-नियम फ़ंक्शन है 111\???????<\000।

— ग्रेग मार्टिन

Stackylogic प्रोग्राम $ P $ का "bizarro" मूल प्रोग्रामों की रेखाओं के क्रम को उलट कर, और सभी 1s को 0s में बदलकर और इसके विपरीत (लेकिन छोड़? S और <अकेला) प्रोग्राम $ BP हो सकता है? ऐसा लगता है कि इनपुट $ b_1, b_2, \ dots $ पर $ BP $ का आउटपुट इनपुट $! B_1;! B_2, \ dots $ पर $ P $ के आउटपुट का नहीं है। ध्यान दें कि AND और OR के दिए गए कार्यान्वयन इस तरह से संबंधित हैं, जैसे NAND और NOR और XOR / XNOR के दो संस्करण हैं। कुछ कार्यक्रम अपने स्वयं के विचित्र (BUFFER, NOT, MEDIAN (v1)) हैं।

— ग्रेग मार्टिन

@GregMartin हां। मेरा मानना ​​है कि तकनीकी शब्द द्वैत है ।

— केल्विन के शौक

Answer 1

रेटिना , 79 78 73 68 66 65 63 62 55 44 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

+`(.)([^_]*)\?<|(¶.*)0<|1<(¶.+)
$2$1$4<$3
1<

इनपुट STDIN के माध्यम से होता है और स्रोत कोड से दो लाइनफीड द्वारा अलग किए गए उपयोगकर्ता इनपुट होने की उम्मीद है।

इसे ऑनलाइन आज़माएं! (पहली दो पंक्तियाँ एक परीक्षण सूट को सक्षम करती हैं, जहाँ प्रत्येक पंक्ति /लाइनफ़ीड के बजाय एक अलग परीक्षण का मामला है ।)

मुझे पूरा यकीन नहीं है कि यहां क्या हुआ। यह वास्तव में एक क्लूनी समाधान की तरह लगता है और यह वास्तव में उस तरह की समस्या नहीं है जिसके लिए रेटिना बनाया गया था, लेकिन यह अभी भी किसी कारण के लिए सभी वर्तमान उत्तरों को हरा देता है।

व्याख्या

इसका अंतिम संस्करण वास्तव में काफी सरल था।

+`(.)([^_]*)\?<|(¶.*)0<|1<(¶.+)
$2$1$4<$3

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

1. प्रसंस्करण ?:

   (.)([^_]*)\?<
   $2$1<
   

   यह केवल इनपुट के पहले चरित्र को लेता है, फिर मनमाने अक्षरों से मेल खाता है जब तक कि यह नहीं मिल जाता है ?<, और उस पहले चरित्र को <(हटाने ?) के सामने रखता है ।

2. प्रसंस्करण 0:

   (¶.*)0<
   <$1
   

   यह पूर्ववर्ती रेखा से मेल खाता है 0<और इसे <हटाने, हटाने के बाद डालता है 0। (प्रभावी रूप से, यह बस हटाता है 0और <एक पंक्ति को ऊपर की ओर ले जाता है।)

3. प्रसंस्करण 1:

   1<(¶.+)
   $1<
   

   बहुत ज्यादा एक ही बात है, सिवाय इसके कि हम <एक को हटाते हुए एक पंक्ति नीचे जाते हैं 1। सूचना का एक महत्वपूर्ण विवरण +इसके बजाय का उपयोग है *, अर्थात, हमें अगली पंक्ति को खाली नहीं होने की आवश्यकता है।

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

के सामने चरित्र तो <है ?मैच विफल करने के लिए एक ही रास्ता है कि वहाँ के सामने रखी गई गैर linefeed चरित्र कहीं भी नहीं है कि है, लेकिन ऐसा नहीं कर सकते क्योंकि हम गारंटी कर रहे हैं हमेशा पर्याप्त इनपुट उपलब्ध न हो।

यदि सामने वाला पात्र <है 0, तो रेगेक्स हमेशा मेल करेगा, क्योंकि वर्तमान एक के ऊपर हमेशा एक और रेखा होती है (जो स्रोत कोड से इनपुट को अलग करने वाली खाली लाइन हो सकती है)।

यदि सामने वाला वर्ण <है 1, तो regex विफल हो जाएगा यदि हम या तो अंतिम पंक्ति पर हैं (चूंकि ¶मिलान करने में विफल होगा) या यदि अगली पंक्ति खाली है (चूंकि .+मिलान करने में विफल होगा)। ध्यान दें कि उन दोनों मामलों में पॉपिंग के बाद कार्यक्रम को समाप्त करने के अनुरूप हैं 1।

अंत में, वहाँ भी संभावना है कि <किसी से पहले नहीं है ?01। यह पता चला है कि हम केवल इस स्थिति तक पहुंच सकते हैं 0और पॉप अप करके एक खाली लाइन पर जा सकते हैं, ताकि <अब लाइनफीड से पहले हो।

इसलिए, जब कार्यक्रम एक पर समाप्त होता है 1, तब <भी उसके बाद होगा 1। लेकिन अगर कार्यक्रम एक पर समाप्त होता है 0, तो यह एक खाली रेखा पर चला जाएगा। हम इस जानकारी को आसानी से एक साधारण मिलान चरण के साथ वांछित आउटपुट में बदल सकते हैं:

1<

यह केवल 1<स्ट्रिंग के मैचों को गिनता है । उपर्युक्त तर्क से यह होगा 1यदि कार्यक्रम ए पर समाप्त हो गया है 1, और 0यदि यह एक पर समाप्त हो गया है 0।

Comments

आप सर, एक जादूगर हैं।

— GamrCorps

ऐसे रेगेक्स मच वाह

— रोहन झुनझुनवाला

Answer 2

उत्तल , 102 95 बाइट्स

ठीक है, स्टैक-आधारित भाषा में कोड की गई एक स्टैक-ऑफ-स्टैक-आधारित भाषा काफी कठिन निकली। मेरे शब्दों को चिह्नित करें: मुझे यह 100 बाइट्स या उससे कम में मिलेगा! संपादित करें: सफलता!

N/S\+{s)_'<={R:M;}{R):R;+}?}%'<-M){(æ=)s_:Q;"?10 ""l+ M):M; M(:M; W:M;A~p"S/Ë~~_!S*+tM)Q:A;}h;;

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

प्रोग्राम इनपुट कमांड-लाइन आर्ग्स के माध्यम से है। इनपुट 0एस और 1एस सामान्य रूप से (टीआईओ पर, इसका मतलब है "इनपुट" बॉक्स में न्यूलाइन-सेपरेट)।

---

स्पष्टीकरण:

सभी कोड को तीन टुकड़ों में विभाजित किया जा सकता है:

N/S\+

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

{s)_'<={R:M;}{R):R;+}?}%'<-

यह भाग निर्धारित करता है कि किस लाइन (या स्टैक) के साथ निष्पादन शुरू करना है। यह प्रत्येक पंक्ति के माध्यम से खोज करता है और सही स्टैक संख्या को Mचर में डालता है ।

M){(æ=)s_:Q;"?10 ""l+ M):M; M(:M; W:M;A~p"S/Ë~~_!S*+tM)Q:A;}h;;

यह मजेदार बिट है! यह लगातार लूप करता है जब तक कि यह केवल एक स्थान ( " ") के साथ एक पंक्ति तक नहीं पहुंचता ( खाली स्टैक का प्रतीक)। यदि रेखा खाली नहीं है, तो यह निम्नलिखित है:

1. स्टैक से अंतिम वर्ण पॉप करें।
2. स्विच स्टेटमेंट:
   1. यदि चरित्र ए है ?, तो इनपुट लें और उस चरित्र को लाइन में जोड़ें।
   2. यदि वर्ण ए है 0, तो लाइन पॉइंटर को ऊपर ले जाएं।
   3. यदि वर्ण ए है 1, तो लाइन पॉइंटर को नीचे ले जाएं।
   4. यदि चरित्र एक (स्थान) है, तो सबसे हाल ही में पॉप किए गए आइटम और अंत प्रोग्राम को प्रिंट करें।

Answer 3

32-बिट x86 मशीन कोड, 70 बाइट्स

हेक्स में:

FC89E1565F31D28A07A8DF740B3C3C7511428D5C24FCEB0A5729142484C07405B20147EBE2578B3B8A17F6C2DF7414FF0B923C3F7501AC3C30750383C30883EB04EBE389CCC3

इनपुट ईएसआई के माध्यम से पारित एक पूर्ण-समाप्त बहु-पंक्ति स्ट्रिंग (लाइनफीड-सेपरेटेड) है। उपयोगकर्ता इनपुट को पहली पंक्ति माना जाता है। AL में '0' / '1' देता है।

disassembly:

fc           cld
89 e1        mov    ecx,esp
56           push   esi
5f           pop    edi                  ;EDI=ESI
31 d2        xor    edx,edx              ;EDX=0
_loop0:
8a 07        mov    al,BYTE PTR [edi]    ;AL=*EDI
a8 df        test   al,0xf5              ;AL&~0x0a==0 => separator ('\n' or '\0')
74 0b        je     _stck
3c 3c        cmp    al,'<'
75 11        jne    _loop0end
42           inc    edx                  ;For "cursor" symbol adjust stack pointer offset
8d 5c 24 fc  lea    ebx,[esp-0x4]        ;and load EBX with the address where this pointer
eb 0a        jmp    _loop0end            ;is going to be stored in the next iteration
_stck:
57           push   edi                  ;Pointer to the separator
29 14 24     sub    DWORD PTR [esp],edx  ;adjusted to point to the top of the stack
84 c0        test   al,al                ;AL==0?
74 05        je     _loop0break          ;break
b2 01        mov    dl,0x1               ;EDX can be [0..2], resets to 1
_loop0end:
47           inc    edi                  ;++EDI
eb e2        jmp    _loop0
_loop0break:
57           push   edi                  ;*EDI==0, add lower implicit empty stack
_loop1:                                  ;The actual state machine code
8b 3b        mov    edi,DWORD PTR [ebx]  ;EDI=*EBX
8a 17        mov    dl,BYTE PTR [edi]    ;DL=*EDI
f6 c2 df     test   dl,0xf5              ;DL&~0x0a
74 14        je     _loop1break          ;ZF==1 => current stack is empty
ff 0b        dec    DWORD PTR [ebx]      ;--(*EBX): pop the stack
92           xchg   edx,eax              ;AL=DL
3c 3f        cmp    al,'?'
75 01        jne    _skplods             ;AL=='?' => substitute char from the input string
ac           lodsb
_skplods:
3c 30        cmp    al,'0'
75 03        jne    _0x31                ;EBX+=AL==0?4:-4
83 c3 08     add    ebx,0x8              ;But to avoid wasting 2 bytes for the jump after the 'add'
_0x31:                                   ;add 8 and fall through to subtract 4 back
83 eb 04     sub    ebx,0x4
eb e3        jmp    _loop1
_loop1break:
89 cc        mov    esp,ecx              ;Clear the stack
c3           ret                         ;Returns '0'/'1' in AL

Answer 4

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

कार्यक्रम में एक समाप्ति न्यूलाइन मानते हुए

(p,i,j=0)=>eval("for(p=`\n${p}`.split`\n`.map((x,i)=>((c=(x=[...x]).pop())=='<'?k=i:x.push(c),x));a=p[k].pop();k-=1-c-c)c=1/a?a:i[j++]")

कम गोल्फ वाला

(p, i, j=0)=>{
  p=`\n${p}`
     .split`\n`
     .map(
       (x,i)=>
       (
         x = [...x],
         c = x.pop(),
         c == '<' ? k=i : x.push(c),
         x
       )
     )
  for(; a = p[k].pop(); k -= 1-c-c)
    c = 1/a ? a : i[j++];
  return c;
}

परीक्षा

F=(p,i,j=0)=>eval("for(p=`\n${p}`.split`\n`.map((x,i)=>((c=(x=[...x]).pop())=='<'?k=i:x.push(c),x));a=p[k].pop();k-=1-c-c)c=1/a?a:i[j++]")

function run() {
  var pgm=P.value+'\n'
  var i=I.value
  O.textContent = F(pgm,i)
}

run()

#P { width:60%; height: 6em }
#I { width:50%;  }

Program<br>
<textarea id=P>1
?&lt;
11
?
0</textarea><br>
Input<br>
<input id=I value=01>
<button onclick='run()'>Run</button>
<br>Output
<pre id=O></pre>

Answer 5

05AB1E , 58 56 55 53 51 50 46 बाइट्स

Emigna के लिए धन्यवाद 2 बाइट्स सहेजे गए ! कोड:

õ|`õ)[¤'<å#À]`¨[¬V¨Y'?QiI«ëYi1U)À`ëY_i0U)Á`ëXq

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

Answer 6

पायथन 3, 147 146 145 144 बाइट्स

1 बाइट @ लियन को धन्यवाद।

def f(p):
 i=p[:p.find("<")].count("\n");p=p.split()
 try:
  while 1:*p[i],c=p[i];c=c>"<"and input()or c;i+=c<"<"and int(c)*2-1
 except:return c

Answer 7

पायथन 3, 318

def s(f,z):
 p=b="";g=0;a=[];n=a.append;n(p)
 for i in f:
  if i=="\n":n(p);p=''
  else:p+=i
 n(p);p=b;n(p)
 while g<len(a):
  if'<'in a[g]:q=g;a[q]=a[q][:-1]
  g+=1
 while 1:
  v=a[q]
  if v=='':print(b);break
  if v[-1]=='1':a[q]=v[:-1];q+=1;b=1
  elif v[-1]=="0":a[q]=v[:-1];q-=1;b=0
  else:a[q]=v[:-1]+z[0];z=z[1:]

एफ प्रोग्राम होने के नाते, जेड इनपुट हो रहा है। हां, मेरे परिवर्तनशील नाम पागल हैं।

Answer 8

ईएस 6, 190 बाइट्स

f=(p,i)=>{
n=p.split`<`[0].split`\n`.length-1
p=p.split`\n`.map(o=>o.split``)
i=i.split``
p[n].pop()
while(p[n]&&p[n].length){
c=p[n].pop()
v=c=='?'?i.shift():Number(c)
n+=v*2-1
}
return v
}

का उपयोग करें f(program, input)

Comments

सामान्य गोल्फिंग युक्तियों की एक जोड़ी (इसमें कहीं न कहीं की एक सूची है): [...o]इसके बजाय का o.split``उपयोग करें, और forइसके बजाय का उपयोग करें while, क्योंकि इससे आप दो अभिव्यक्तियों को forदो बाइट्स में स्थानांतरित कर सकते हैं । कुछ विशिष्ट सुझाव: मुझे लगता है कि आपकी Numberकास्ट अनावश्यक है, जैसा कि *2वसीयत आपके लिए डाली गई है , और मैं सिर्फ iउपयोग करना पढ़ूंगा j=0और i[j++]जो मुझे लगता है कि 11 बाइट्स बचाता है।

— नील

आपको f=अनाम कार्यों की आवश्यकता नहीं है ।

— gcampbell

Answer 9

जावा, 256 255 231 219 215 213 बाइट्स

int f(char[][]p,char[]I){int l=p.length,d=0,j=-1,c=0,k=0,i[]=new int[l];while(++j<l)if(p[j][i[j]=p[j].length-1]==60)i[k=j]--;try{for(;;k+=c>48?1:-1)c=(c=p[k][i[k]--])>49?I[d++]:c;}catch(Throwable t){}return c-48;}

Ideone पर डेमो।

कार्यक्रम और इनपुट को तर्क के रूप में लेता है और परिणाम को पूर्णांक के रूप में लौटाता है।

Comments

@LeakyNun एक forलूप में बदल गया , लेकिन आपकी पहली टिप्पणी का क्या अर्थ है?

— पुरकाकूदरी जूल

@ Pietu1998 LeakyNun का मतलब यह हो सकता है int f(String[]I)...और आप से बच सकते हैंString[]p=I.split("\n");

— बिल्ली

इसका मतलब है कि आप समारोह को घोषित कर सकते हैंint f(String[]P)

— लीक नून

@cat निंजा 7 सेकंड के द्वारा: /

— लीक नून

इसके अलावा, यदि आप जावा 8 के लिए समझौता करते हैं, तो आपके पास एक मेमना हो सकता है जैसे (मुझे लगता है)->(String[]I){...

— बिल्ली

Answer 10

PHP (<7.0), 195 192 बाइट्स

कार्यक्रम को पहले तर्क के रूप में और प्रत्येक मान को एक अतिरिक्त तर्क के रूप में लेता है।
ध्यान दें कि मैंने इसे विभाजन के साथ परीक्षण किया ("", ..) नए स्थानों के बजाय रिक्त स्थान पर लेकिन यह वैसे भी काम करना चाहिए।
अगर php> 5.3 में चलाया जाता है तो एक पदावनत नोटिस देता है।
यदि आप कार्यक्रम के शीर्ष पर जाते हैं, तो भी एक चेतावनी देता है। हालांकि यह अभी भी काम करता है और सही ढंग से आउटपुट करता है इसलिए यह ठीक है।

<?php foreach(split("\n",$argv[++$t])as$l)$p[]=str_split($l);for($i=-1;end($p[++$i])!='<';);array_pop($p[$i]);for(;($v=array_pop($p[$i]))!==null;$i+=$n?:-1)($n=$v)=='?'&&$n=$argv[++$t];echo$n;

Answer 11

सी, 264 249 244 242

C स्ट्रिंग्स में हेरफेर करने के साथ ऐसा नहीं करता है, लेकिन यह बहुत कम है।

यह कर्सर के लिए स्ट्रिंग को स्कैन करके काम करता है ( <), 1 जगह पीछे हटना, कमांड पढ़ना, इसे एक tabवर्ण के साथ बदलना , और आगे या पीछे एक लाइन को आगे बढ़ाना। इनपुट एक सी चार सरणी के रूप में है, जैसेchar array[]="1\n?<\n11\n?\n0";result = f(array); , हालांकि कैरिज रिटर्न की भी अनुमति है।

हालांकि इनपुट स्ट्रिंग को संशोधित किया गया है, लंबाई नहीं बदली गई है।

t;f(char*n){char*p=strchr(n,60);for(*p--=9;;){if(*p==63)scanf("%d",&t),*p=t+48;if(*p^49){for(*p--=9;p>n&&*p^10;--p);for(--p;p>n&&*p==9;--p);if(p<n||*p==10)return 0;}else{for(*p++=9;*p&&*p^10;++p);for(p+=!!*p;*p>10;++p);if(*--p<11)return 1;}}}

परीक्षण कार्यक्रम

प्रत्येक परीक्षण मामले के साथ एक अलग पैरामीटर के रूप में इस प्रोग्राम को चलाएं, जिसमें नई सुर्खियों के स्थान पर एकल बैकस्लैश का उपयोग किया गया है। परीक्षण मामलों को एक रिक्त रेखा से अलग किया जाएगा।

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main(int argc, const char **argv)
{
    while (*++argv)
    {
        char *input=malloc(strlen(*argv)+1),*p;
        strcpy(input,*argv);
        printf("testing %s\n",input);
        for (p=input;*p;++p)
            if (*p=='\\')
                *p=10;
        printf("result: %d\n\n",f(input));
        free(input);
    }
    return 0;
}