एक सत्य तालिका को देखते हुए, एक स्टैक्ग्लोगिक कार्यक्रम का उत्पादन किया गया जो इसे संतुष्ट करता है

Question

Stackylogic एक प्रोग्रामिंग भाषा है जिसे मैंने पिछली चुनौती में बनाया था: Run Stackylogic । पूरी जानकारी और उदाहरण के लिए उस पोस्ट को पढ़ें, लेकिन यहां बताया गया है कि यह कैसे काम करता है:

Stackylogic इनपुट के लिए लेता है 0और 1एक 0 या 1पूरा होने पर आउटपुट देता है ।

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

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

1
?<
11
?
0

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

<, कर्सर कहा जाता है, के निशान स्टैक पर शुरू करने के लिए जब एक कार्यक्रम चलाया जाता है। निष्पादन की कार्यवाही निम्नानुसार है:

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

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

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

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

इस चुनौती के लिए महत्वपूर्ण बात यह है कि सभी स्टैकलॉजिक कार्यक्रम एक सत्य तालिका के समान हैं । बूलियन मानों की कुछ पूर्व निर्धारित संख्या इनपुट होती है और ठीक एक बूलियन नियत रूप से आउटपुट होता है।

तो आपका काम एक स्टैक्ग्लोगिक कार्यक्रम का उत्पादन करना है जो संतुष्ट या अनुकरण करता है, अर्थात किसी भी दिए गए सत्य तालिका के समान आउटपुट है। लेकिन यह स्पष्ट नहीं है कि स्टैकलॉजिक किसी भी सत्य तालिका का अनुकरण कर सकता है , इसलिए यहां प्रेरण द्वारा एक प्रमाण दिया गया है :

मुख्य मामला

दो 0-इनपुट सत्य तालिकाओं में हमेशा आउटपुट 0या 1। इन तालिकाओं के स्टैकलोजिक समकक्ष क्रमशः 0<और 1<हैं।

आगमनात्मक कदम

Stackylogic किसी भी एन-इनपुट सत्य तालिका का अनुकरण कर सकते हैं। आज्ञा देना M = N + 1।

एक एम-इनपुट टेबल, टी, को दो एन-इनपुट टेबल, टी ₀ और टी _{1 के} रूप में व्यक्त किया जा सकता है , साथ ही अतिरिक्त इनपुट बिट बी। जब बी 0 होता है, तो टी ₀ के परिणाम का उपयोग किया जाता है। जब बी 1 होता है, तो टी ₁ के परिणाम का उपयोग किया जाता है।

उदाहरण के लिए, 3-इनपुट सत्य तालिका स्यूडोकोड के अनुरूप है

if B:
    result = x OR y
else:
    result = x NAND y

है

B x y | result
0 0 0 | 1
0 0 1 | 1
0 1 0 | 1
0 1 1 | 0
1 0 0 | 0
1 0 1 | 1
1 1 0 | 1
1 1 1 | 1

जो वास्तव में नंद के लिए दो 2-इनपुट सत्य तालिकाएं हैं और OR एक दूसरे के ऊपर muxing बिट बी के साथ खड़ी हैं।

S ₀ और S ₁ को स्टैकलॉजिक प्रोग्राम कहते हैं जो क्रमशः T ₀ और T _{1 को} संतुष्ट करते हैं (हम जानते हैं कि ये पहली धारणा के आधार पर मौजूद हैं)। कार्यक्रम S जो T को संतुष्ट करता है उसका निर्माण निम्न प्रकार से किया जा सकता है:

[lines of S0 excluding the cursor, with 0 appended to all lines below the cursor]
?<
[lines of S1 excluding the cursor, with 1 appended to all lines above the cursor]

यह व्यवस्था पहले इनपुट बिट (लाइन से ) के आधार पर S ₀ और S _{1 के} बीच प्रभावी रूप से मेल करती है ?<। यदि यह है 0, तो कर्सर 0एस ₀ के मूल कर्सर की स्थिति के लिए अपेंडेड सवारी करेगा , जो तब खाली स्टैक द्वारा ऊपर और नीचे की सीमा पर होगा, और इस तरह मूल एस _{0 के} बिल्कुल समान होगा । इसी तरह, यदि 1इनपुट है, तो कर्सर 1एस ₁ के कर्सर स्थिति पर सवारी करेगा और इसे निष्पादित करने के लिए आगे बढ़ेगा जैसे कि यह अकेला था।

उदाहरण के लिए, OR और NAND के लिए स्टैकलॉजिक प्रोग्राम हैं

?
?<

तथा

1
?<
11
?
0

उन्हें अनुकरण करने के लिए जोड़ा जा सकता है

if B:
    result = x OR y
else:
    result = x NAND y

इस तरह:

1
?
110
?0
00
0
?<
?1
?

इस प्रकार, किसी भी सत्य तालिका को स्टैकलॉजिक प्रोग्राम द्वारा अनुकरण किया जा सकता है।

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें जो 2 ^एन बूलियन मानों की एक सूची के रूप में एन इनपुट सत्य तालिका (एन> 0) में होता है जो आरोही बाइनरी ऑर्डर में तालिका के आउटपुट का प्रतिनिधित्व करते हैं।

कोई भी उचित इनपुट प्रारूप ठीक है। उदाहरण के लिए एक सत्य तालिका

x y | OR
0 0 | 0
0 1 | 1
1 0 | 1
1 1 | 1

इनपुट की इन शैलियों में से कोई भी ठीक होगा:

0111

0, 1, 1, 1

0
1
1
1

[False, True, True, True]

सत्य तालिका को संतुष्ट करने वाले स्टैक्ग्लॉजिक प्रोग्राम को प्रिंट करें या लौटाएं, यानी सटीक एक ही आउटपुट को एक ही इनपुट दिया गया है। कोई भी परिमित प्रोग्राम जो उस तालिका को संतुष्ट करता है वह मान्य आउटपुट है। आपको निर्माण के प्रेरक प्रमाण की विधि का पालन करने की आवश्यकता नहीं है। Stackylogic प्रोग्राम को बहुत कम होने की आवश्यकता नहीं है।

उदाहरण के लिए, यदि इनपुट थे 11100111, तो एक वैध आउटपुट होगा

1
?
110
?0
00
0
?<
?1
?

लेकिन कई अन्य हैं।

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

यदि आपको दुभाषिया की आवश्यकता है तो मूल स्टैकलॉजिक चुनौती देखें ।

Comments

क्या हम N को दूसरे इनपुट के रूप में ले सकते हैं?

— लीकी नून

यदि आवश्यक हो तो @LeakyNun Yes (या 2 ^ N)।

— केल्विन के

Answer 1

पायथ, 53 बाइट्स

L?tb,lehJyMc2bsX0.e.e+W>_Wk-Yhb0ZkebJ\?,0]`hbjXF+yQ\<

ऑनलाइन कोशिश करें

यह स्टैक्यलोगिक में मनमानी सत्य तालिकाओं को लागू करने के लिए चुनौती में वर्णित प्रणाली का सटीक कार्यान्वयन है। हम केवल सत्य तालिका को आधे में काटते हैं, इसे पुनरावर्ती रूप से लागू करते हैं, और फिर 0 और 1 को उपयुक्त मानते हैं।

यह एक पुनरावर्ती फ़ंक्शन को परिभाषित करता है, जिसका वापसी मूल्य है [1, ['0', '?', '1']], जहां पहला नंबर पॉइंटर का स्थान है, और बाकी एक स्टैक्योग्लिक प्रोग्राम है।

L?tb,lehJyMc2bsX0.e.e+W>_Wk-Yhb0ZkebJ\?,0]`hbjXF+yQ\<
                                                         Q = eval(input())
L?tb,lehJyMc2bsX0.e.e+W>_Wk-Yhb0ZkebJ\?,0]`hb
L                                                 def y(b): return
 ?tb                                              if b[1:] (base case on false)
                                      ,0]`hb      else: [0, str([0])]
                                                  then:
           c2b                                    Cut the input in half
         yM                                       Map y over the halves
        J                                         Store that in J
    ,leh                                          The cursor position is the length 
                                                  of the body of the first function
                 .e                 J             enum-map, where k is the index
                                                  and b is the value, over J
                   .e             eb              enum-map, Y is the index and
                                                  Z is the value, over body of b
                     +W         Zk                Add to Z (line) k (the overall 
                                                  index, 0 or 1) conditional on
                          -Yhb                    Y (line index) - cursor
                       _Wk                        Negated if k
                      >       0                   > 0
               X0                    \?           Add '?' to the first element
              s                                   Concatenate, giving the body

jXF+yQ\<
    yQ      Call the above on the input
   +  \<    Append a '<'
 XF         Splat the 3 element list into the 'append-at' function,
            adding the curson in the right place
j           Join on newlines and print.

Comments

खैर ... मैं अपने समाधान को सही करने के लिए घर वापस चला गया ...

— लीक

Answer 2

पायथन 3, 352 208 205 बाइट्स

यह अभी भी बहुत असंयमित है, और मैं बाद में एक स्पष्टीकरण जोड़ने की कोशिश करूंगा। कुछ संशोधनों के बाद, मैं 144 147 बाइट्स निकालने में कामयाब रहा ।

f=lambda x,l=len,r=range:'\n'.join(*x)if l(x)<2 else f([[x[i][j]+['0',''][j<=l(x[i])//2]for j in r(l(x[i]))]+[['?','?<'][l(x)<3]]+[x[i+1][j]+['1',''][j>=l(x[i])//2]for j in r(l(x[i]))]for i in r(0,l(x),2)])

एक फ़ंक्शन fजो सत्य तालिका मानों के इनपुट को फार्म के बुलियन की सूची के रूप में लेता है ['1','1','1','0','0','1'...], जहां सत्य है '1'और '0'गलत है, और स्टैकलॉजिक कार्यक्रम लौटाता है।

Ideone पर इसे आज़माएं

यदि आप एक निर्मित कार्यक्रम का परीक्षण करना चाहते हैं, तो आप यहां GamrCorps के उत्तल दुभाषिया का उपयोग कर सकते हैं ।

यह काम किस प्रकार करता है

यह एक पुनरावर्ती कार्य है और प्रश्न में वर्णित प्रेरक विधि का उपयोग करता है।

शून्य-अनुक्रमित पुनरावर्तन स्तर पर a, फ़ंक्शन n/2 a+1सूची में -input कार्यक्रमों से -input Stackylogic प्रोग्राम बनाता है n a। यह सूची में दो कार्यक्रमों के सभी आसन्न जोड़े के साथ मिलकर किया जाता है ?; कर्सर प्रत्येक घटक कार्यक्रम के बीच तत्व पर हमेशा होता है के बाद से, के जोड़कर आवश्यक 0या 1नहीं जोड़ा जा सकेगा कार्यक्रमों में से प्रत्येक पंक्ति के ऊपर पुनरावृत्ति द्वारा किया जा सकता है, और जोड़कर यदि वर्तमान पंक्ति के सूचकांक की तुलना में कम या ज्यादा करने के लिए / अधिक से अधिक के बराबर है उचित के रूप में या मध्य सूचकांक के बराबर। यदि सूची में केवल दो कार्यक्रम हैं, तो अगली पुनरावर्ती कॉल अंतिम कार्यक्रम देगी; चूँकि इसके लिए एक कर्सर की आवश्यकता होती है, इसके बजाय ज्वाइनिंग होती है ?<।

जब सूची में लंबाई होती है 1, तो सूची में पूर्ण प्रोग्राम वाला केवल एक तत्व होना चाहिए। इसलिए, कार्यक्रम में सभी लाइनें एक नई लाइन में शामिल हो जाती हैं, और फिर लौट आती हैं।

एक उदाहरण यह स्पष्ट करने में मदद करता है:

Take the input ['1', '1', '1', '0', '0', '1', '1', '1'].

Level  Return value

0  [['1', '?', '1'], ['1', '?', '0'], ['0', '?', '1'], ['1', '?', '1']]
1  [['1', '?', '10', '?', '11', '?', '0'], ['0', '?', '10', '?', '11', '?', '1']]
2  [['1', '?', '10', '?', '110', '?0', '00', '?<', '01', '?1', '101', '?', '11', '?', '1']]
3  '1\n?\n10\n?\n110\n?0\n00\n?<\n01\n?1\n101\n?\n11\n?\n1'

which when printed gives:

1
?
10
?
110
?0
00
?<
01
?1
101
?
11
?
1