ग्रिड आधारित डिजिटल लॉजिक (Duodyadic टाइलें)

Question

Duodyadic टाइल्स एक प्रकार के स्क्वायर फंक्शन ब्लॉक होते हैं जो दो इनपुट लेते हैं, एक उनके टॉप साइड से और एक उनके लेफ्ट साइड से, और दो आउटपुट होते हैं, एक उनके राइट साइड और दूसरा उनके बॉटम साइड पर। उनका प्रत्येक आउटपुट उनके दोनों इनपुट का एक अलग कार्य है।

उदाहरण के लिए, यदि #एक सामान्य टाइल का प्रतिनिधित्व करता है, तो सही आउटपुट इनपुट Rका एक कार्य fहै Tऔर L, और नीचे का आउटपुट Bएक और कार्य gहै : TऔरL

 T
L#R         R = f(T, L)
 B          B = g(T, L)

^{(टाइल्स को "डुओ" कहा जाता है क्योंकि दो कार्य हैं, और "रंगादिक" चूंकि दोनों कार्यों में दो तर्क हैं ।)}

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

 AB         D = f(f(A, C), B)
C##D        E = g(A, C)
 EF         F = g(f(A, C), B)

आप कल्पना कर सकते हैं कि ग्रहणी टाइलों का एक सेट दिया गया है, प्रत्येक को विशिष्ट कार्यक्षमता, जटिल (और संभवतः उपयोगी) रचनाओं के साथ बनाया जा सकता है।

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

टाइल वर्ण और उनके इनपुट-आउटपुट संबंध निम्नानुसार हैं:
( Tशीर्ष इनपुट के लिए, Lबाएं इनपुट के लिए, Rदाएं आउटपुट के लिए, Bनीचे आउटपुट के लिए है।)

1. शून्य: 0या (स्थान) → R = 0,B = 0
2. एक: 1→ R = 1,B = 1
3. क्रॉस: +→ R = L,B = T
4. दर्पण: \→ R = T,B = L
5. केवल शीर्ष: U→ R = T,B = T
6. केवल वाम: )→ R = L,B = L
7. नहीं: !→ R = not L,B = not T
8. और: &→ R = L and T,B = L and T
9. या: |→ R = L or T,B = L or T
10. Xor: ^→ R = L xor T,B = L xor T

चुनौती

0 1+\U)!&|^दस लॉजिक आधारित ग्रहणी टाइलों का उपयोग करके बनाए गए "सर्किट" का प्रतिनिधित्व करने वाले पात्रों के आयताकार ग्रिड में होने वाले एक प्रोग्राम या फ़ंक्शन को लिखें । आपको 0's 1' और 's ' के दो तार भी लेने होंगे ; एक बाएं इनपुट कॉलम होगा और एक शीर्ष इनपुट पंक्ति होगी। आपके कार्यक्रम / फ़ंक्शन को नीचे आउटपुट पंक्ति और सही आउटपुट कॉलम ( 0's और 1' s में भी) प्रिंट / वापस करने की आवश्यकता है ।

उदाहरण के लिए, इस ग्रिड में

+++
+++

सभी निविष्टियाँ सीधे ग्रिड से आउटपुट तक प्रवाहित होती हैं

 ABC
D+++D
E+++E
 ABC

इसलिए की एक इनपुट 010/ 01आउटपुट के लिए होता है 010/ 01:

 010
0+++0
1+++1
 010

आपके कार्यक्रम का सटीक आउटपुट [bottom output row]\n[right output column]या होगा [bottom output row]/[right output column]:

010
01

या

010/01

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

विवरण

• किसी भी उचित तरीके से स्ट्रिंग के रूप में तीन इनपुट लें (अधिमानतः आदेश ग्रिड, शीर्ष पंक्ति, बाएं कॉलम में): कमांड लाइन, पाठ फ़ाइल, एसडीटीआईएन, फ़ंक्शन आर्ग।
• आप मान सकते हैं कि इनपुट पंक्ति और कॉलम की लंबाई ग्रिड आयामों से मेल खाएगी और इसमें केवल 0's 1' और 's' शामिल होंगे ।
• आपके ग्रिड को उचित वर्ण ( 0 1+\U)!&|^) का उपयोग करना चाहिए । उसी को याद करो 0और उसी का मतलब रखो ।

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

(पढ़ें / ओ के रूप में top/ left→ bottom/ right)

नंद:

&!

00/ 0→ 01/ 1
00/ 1→ 01/ 1
10/ 0→ 01/ 1
10/ 1→ 11/0

सभी:

1111
1\+\
1+\+
1\+\

किसी भी इनपुट में परिणाम होना चाहिए 1111/ 1111।

नंद से एक्सोर: (ट्रेलिंग स्पेस के कॉलम पर ध्यान दें)

\)+\ 
U&!& 
+! ! 
\&!& 
   ! 

00000/ 00000→ 00000/ 00000
00000/ 10000→ 00010/ 00000
10000/ 00000→ 00010/ 00000
10000/ 10000→ 00000/00000

ज़िग ज़ैग:

+++\00000000
000\!!!!\000
00000000\+++

बाएं इनपुट का पहला बिट दाएं आउटपुट का अंतिम बिट बन जाता है। बाकी सब कुछ है 0।

000000000000/ 000→ 000000000000/ 000
000000000000/ 100→ 000000000000/001

प्रचार:

)))
UUU
U+U
U+U
UUU

बाएं इनपुट का पहला बिट सभी आउटपुट पर जाता है।

000/ 00000→ 000/ 00000
000/ 10000→ 111/11111

यहां सभी 1 × 1 ग्रिड परीक्षण मामलों का एक पेस्टबिन है।

स्कोरिंग

बाइट्स में सबसे कम सबमिशन जीतता है।

बोनस: आप क्या शांत "सर्किट" बना सकते हैं?

^{PS गूग्लिंग "ग्रहणी टाइल" को परेशान न करें। मैंने उन्हें कल बनाया; डी
यदि आप इस विचार को एक पूर्ण प्रोग्रामिंग भाषा में विस्तारित करने पर चर्चा करना चाहते हैं, तो इस चैट रूम में आएं ।}

Comments

एक शांत चुनौती के लिए +1 लेकिन क्योंकि आपने ग्रहणी टाइल्स का आविष्कार किया है , जो वास्तव में शांत है।

— एलेक्स ए।

+1 यह वास्तव में यह गूगल के लिए पूरी तरह से बेकार है: goo.gl/zuqfdW । अच्छी चुनौती!

— ब्रेनसैट

मैं उनके साथ हूं। मैं इस विशेष गोल्फ चुनौती की तुलना में प्रोग्रामिंग भाषा के रूप में आपकी टाइलों में बहुत अधिक दिलचस्पी रखता हूं। पुनश्च: 16 संभव टाइलें हैं, इसलिए अन्य छह के लिए अक्षर / नाम के साथ आना साफ-सुथरा होगा।

— 3

यह दिलचस्प होगा कि अलग-अलग दिशाओं से कौन से आउटपुट / इनपुट ब्लॉक होते हैं, क्योंकि अन्यथा आप एक कुंडी नहीं बना सकते क्योंकि सब कुछ सही-सही दिशा में बहता है।

— Sp3000

आप T / B को U (p) / D (स्वयं) में बदल सकते हैं, ताकि हम F / B को रूबिक के घन संकेतन के अनुरूप तरीके से, और फिर प्राप्त कर सकें। । । ट्राइट्रियडिक क्यूब्स?

— सोहम चौधरी

Answer 1

अजगर, १२२

एक राक्षस की तरह। बस पुनरावृत्ति का उपयोग करता है, गतिशील प्रोग्रामिंग की तरह फैंसी कुछ भी नहीं।

D:NGHR@Cm+d[1HG&GH|GHxGH0),[GH!G)[HG!H)x"+\\!1U)&|^"N#aYw)M:@@YGH?hgGtHHv@eYG?egtGHGv@ePYHjkm+0egtleYklePYjkm+0hgbtlePYleY

ऑनलाइन प्रदर्शन ।

इनपुट निम्नलिखित तरीके से है: पहले ग्रिड (कोई बच नहीं, कोई अतिरिक्त प्रतीक नहीं) और फिर इनपुट की दो लाइनें, उदाहरण के लिए (जिग दाग)

+++\00000000
000\!!!!\000
00000000\+++
000000000000
100

Answer 2

गणितज्ञ, 331 276 270 267 264 262 252 250 बाइट्स

Print@@@{#[[2;;,-1,2]],#[[-1,2;;,1]]}&@MapIndexed[h=Characters;({r@#2,b@#2}=<|##|>&@@Thread[h@"0 1+\\)U!&|^"->{0,0,1,i={##},{#2,#},##,1-i,1##,Max@i,(#-#2)^2}]&[r[#2-{1,0}],b[#2-{0,1}]]@#{1,1})&,Join[h@{"0"<>#3},h@StringSplit[#2<>"
"<>#,"
"]],{2}]&

एक निजी उपयोग में यूनिकोड वर्ण जो मेथेमेटिका एक सुपरस्क्रिप्ट के रूप में उपयोग करता है T, यानी यह स्थानांतरण ऑपरेटर है।

यहाँ एक अधिक पठनीय संस्करण है:

Print @@@ {#[[2 ;;, -1, 2]], #[[-1, 2 ;;, 1]]} &@
  MapIndexed[h = Characters;
   (
     {r@#2, b@#2} = <|##|> & @@ Thread[
            h@"0 1+\\)U!&|^" -> {
              0,
              0,
              1,
              i = {##},
              {#2, #},
              ##,
              1 - i,
              1 ##,
              Max@i,
              (# - #2)^2
              }] & [
          r[#2 - {1, 0}],
          b[#2 - {0, 1}]
          ] @ # {1, 1}
     ) &,
   Join[
    h@{"0" <> #3},
    h@StringSplit[#2 <> "\n" <> #, "\n"]\[Transpose]
   ],
   {2}] &

यह एक अनाम फ़ंक्शन है जो ग्रिड, टॉप और लेफ्ट इनपुट के लिए तीन स्ट्रिंग्स लेता है और नीचे और दाएं आउटपुट प्रिंट करता है।

व्याख्या

आइए इस कदम से कदम मिलाकर चलते हैं (मैं किसी भी गणितीय ज्ञान को नहीं मानने की कोशिश करूँगा)। आप कोड को वापस पढ़ने के लिए आवश्यकता चाहते हैं। मूल एल्गोरिथ्म बस प्रत्येक फ़ंक्शन की गणना करने वाली लाइनों के माध्यम से स्वीप करता है और परिणाम fको बाद की टाइलों द्वारा एक्सेस करने के लिए संग्रहीत करता है ।

इनपुट प्रोसेसिंग

यह बिट है:

Join[
  h@{"0" <> #3},
  h@StringSplit[#2 <> "\n" <> #, "\n"]\[Transpose]
]

यह केवल ग्रिड को वर्णों की एक नेस्टेड सूची में विभाजित करता है (ध्यान दें कि मैंने कोड में कहीं और के hलिए एक उपनाम के रूप में परिभाषित किया है Character) और फिर इनपुट के साथ एक पंक्ति और एक कॉलम तैयार करता है। यह काम करता है, क्योंकि 1और 0निरंतर-फ़ंक्शन टाइलों के नाम भी हैं, इसलिए वास्तव में उन पर उसी तरह का प्रभाव पड़ता है जैसा कि मैन्युअल रूप से इनपुट को खिलाने के रूप में होता है। चूँकि ये कार्य हैं, वे तकनीकी रूप से ग्रिड के बाहर से अपना इनपुट लेंगे, लेकिन चूंकि वे निरंतर कार्य करते हैं जो कोई फर्क नहीं पड़ता। शीर्ष बाएं कोने को मिलता है, 0लेकिन यह काफी मनमाना है क्योंकि उस टाइल के परिणामों का उपयोग कभी नहीं किया जाता है।

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

ग्रिड को हल करना

(यह खंड थोड़ा पुराना है। एक बार ठीक होने के बाद मैं निश्चित हो जाऊंगा कि मैं गोल्फ खेल रहा हूं।)

अगला, हम MapIndexedइस नेस्टेड सूची के आंतरिक स्तर पर चलते हैं। यह ग्रिड में प्रत्येक वर्ण के लिए पहले तर्क के रूप में दिए गए अनाम फ़ंक्शन को कॉल करता है, यह वर्तमान दो निर्देशांक के साथ एक सूची भी देता है। ग्रिड को क्रम में रखा गया है, इसलिए हम पिछले वाले के आधार पर प्रत्येक सेल की सुरक्षित गणना कर सकते हैं।

हम चर r(ight) और b(ottom) का उपयोग प्रत्येक कोशिका के परिणामों के लुकअप टेबल के रूप में करते हैं। हमारे अनाम फ़ंक्शन में वर्तमान निर्देशांक हैं #2, इसलिए हम किसी भी सेल के साथ इनपुट प्राप्त करते हैं

r[#2 - {1, 0}],
b[#2 - {0, 1}]

ध्यान दें कि पहली पंक्ति और कॉलम में यह अपरिभाषित मूल्यों तक पहुँच जाएगा rऔर b। Mathematica वास्तव में उस के साथ कोई समस्या नहीं है और आपको इसके बजाय अपने निर्देशांक वापस देगा, लेकिन हम इस परिणाम को वैसे भी छोड़ देते हैं, क्योंकि उस पंक्ति / स्तंभ में सभी टाइलें निरंतर कार्य करती हैं।

अब यह बात:

<|##|> & @@ Thread[
  h@"0 1+\\U)!&|^" -> {
     z = {0, 0}, z, o = 1 + z, {##}, ...
  }] &

का गोल्फ का रूप है

<|"0" -> (z = {0, 0}), " " -> z, "1" -> (o = 1 + z), "+" -> {##}, ... |> &

जो बदले में एक फ़ंक्शन होता है, जिसे दो टाइल इनपुट दिए जाते हैं, एक एसोसिएशन देता है (आप इसे अन्य भाषाओं में हैशमैप या एक टेबल कहेंगे), जिसमें इन दो इनपुट के लिए सभी संभावित टाइल परिणाम शामिल हैं। यह समझने के लिए कि सभी कार्यों को कैसे कार्यान्वित किया जाता है, आपको यह जानना होगा कि इस तरह के एक फ़ंक्शन के पहले तर्क के साथ #और दूसरे के साथ पहुँचा जा सकता है #2। इसके अलावा, ##आपको दोनों तर्कों का एक क्रम देता है , जिसका उपयोग तर्कों को "स्प्लिट" करने के लिए किया जा सकता है।

• 0: सीधा है, हम सिर्फ एक स्थिरांक लौटाते हैं {0, 0}और इसे zभविष्य में उपयोग के लिए भी निर्दिष्ट करते हैं (जैसे कि स्पेस टाइल में)।
• 1: अनिवार्य रूप से बस है {1,1}, लेकिन zयह होने के लिए छोटा है 1+z। हम इसे भी सहेजते हैं o, क्योंकि यह उन सभी टाइलों के लिए काम आएगा जहाँ दोनों आउटपुट समान हैं।
• +: यहाँ हम अनुक्रम का उपयोग करते हैं। {##}के रूप में ही है {#,#2}और अपरिवर्तित के माध्यम से दोनों इनपुट गुजरता है।
• \: हम दो तर्क स्वैप {#2,#}।
• U: अब हम इसका उपयोग कर सकते हैं o। o#2इसका मतलब है {1,1}*#2कि हम सिर्फ दोनों आउटपुट में शीर्ष तर्क रखते हैं।
• ): बाएं तर्क के अनुरूप o#।
• !: बिटवाइज़ मैथेमेटिका में गुस्सा नहीं कर रहा है, लेकिन चूंकि हमारे पास केवल कभी है 0और 1, हम बस दोनों इनपुटों को घटा सकते हैं 1(जिससे उन्हें इन्वर्ट कर रहे हैं) और उन्हें पास करें 1-{##}:।
• &: यह काफी निफ्टी है। सबसे पहले हम उस बिटवाइज़ नोटिस और के लिए 0और 1गुणा के समान है। इसके अलावा, के o##रूप में ही है o*#*#2।
• |: फिर से, हम एक समतुल्य फ़ंक्शन का उपयोग करते हैं। बिटवाइज़ या Maxइस मामले में जैसा है, इसलिए हम Maxइनपुट तर्कों पर लागू होते हैं और परिणाम को गुणा करते हैं {1,1}।
• ^: जो सबसे छोटा एक्सआर के लिए मैंने पाया है वह अंतर को लेने और इसे (सकारात्मकता सुनिश्चित करने के लिए) वर्ग है, इसलिए हमें मिल गया है o(#-#2)^2।

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

आउटपुट प्रसंस्करण

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

#[[2;;,-1,2]]

और अंतिम कॉलम के सही आउटपुट के साथ

#[[-1,2;;,1]]

ध्यान दें कि 2;;दूसरे से अंतिम तत्व तक की सीमा है।

अंत में, हम Printउन दोनों पर लागू होते हैं ( @@@दूसरे स्तर के लिए सिंटैक्टिक शुगर के रूप में उपयोग करते हैं Apply), जो कि इसके सभी तर्कों को बैक-टू-बैक प्रिंट करता है (और चूंकि यह दो अलग-अलग अभिव्यक्तियों पर लागू होता है, नीचे और बीच में एक नई रूपरेखा होगी) सही उत्पादन)।

Answer 3

सी, 332 309 272 270 266 259 247 225 बाइट्स

#define C(x)*c-x?
i,k,T,L,m;f(c,t,l)char*c,*t,*l;{while(L=l[i]){for(k=0;T=t[k];c++)L=C(49)C(43)C(92)C(85)C(41)C(33)C(38)C('|')C(94)T=48:(T^=L-48):(T|=L):(T&=L):(T^=1,L^1):(T=L):T:(m=T,T=L,m):L:(T=49),t[k++]=T;c++;l[i++]=L;}}

परिणाम ऑनलाइन यहाँ देखें !

यह एक फ़ंक्शन को परिभाषित करता है void f(char*, char*, char*), जिसे बोर्ड को पहले इनपुट के रूप में लेना चाहिए, फिर इनपुट की शीर्ष पंक्ति, और फिर इनपुट की बाईं पंक्ति।

यहाँ मैं इसका परीक्षण करने के लिए इस्तेमाल किया है:

#include "stdio.h"
int main() {
    char buf[1024],top[33],left[33];
    /* Copy and paste an example circuit as the first input,
       and put a 'Q' immediately after it. 
       Note that the Q is never touched by the function f, and is used
       solely as a delimiter for input. */
    scanf("%[^Q]Q ",buf);
    /* Then enter your top inputs */
    scanf("%[01]%*[^01]", top);
    /* Then your left ones */
    scanf("%[01]", left);
    /* OUTPUT: Bottom\nRight */
    f(buf, top, left);
    return 0;
}

इस प्रकार, Sp3000 के 2-बिट गुणक को इनपुट करके:

UUUU))))
UU++)))&
UUU+)  U
UU++&))U
U++&+)^U
U)&\&)UU
   U+^UU
   \&UUUQ
11110000
00000000

हमें मिला:

00001001
11111111

एक और नोट पर, Sp3000 के आधे योजक को ध्यान में रखते हुए, मैं एक पूर्ण योजक देखना चाहता हूं ... आप में से एक ने इसे किया था! मुझे नहीं लगता कि सिस्टम प्रोग्रामिंग भाषा के रूप में अपने दम पर खड़ा है, लेकिन यह बहुत दिलचस्प है। यह मेटागॉल्फ के लिए एक उत्कृष्ट लक्ष्य जैसा लगता है, हालांकि!

एक छोटी व्याख्या:

यहाँ पर अप्रकाशित, टिप्पणी कोड है:

/* We define the first half of the ?: conditional operator because, well,
   it appears over and over again. */
#define C(x)*c-x?
/* i,k are counting variables
   T,L are *current* top and left inputs */
i,k,T,L,m;
f(c,t,l)char*c,*t,*l;{
    /* The outer loop iterates from top to bottom over l and c */
    while(L=l[i]){
        /* Inner loop iterates from left to right over t and c */
        for(k=0;T=t[k];c++)
            /* This line looks awful, but it's just a bunch of character
            comparisons, and sets T and L to the output of the current c */
            L=C(49)C(43)C(92)C(85)C(41)C(33)C(38)C('|')C(94)T=48:(T^=L-48):(T|=L):(T&=L):(T^=1,L^1):(T=L):T:(m=T,T=L,m):L:(T=49),
            /* Write our output to our input, it will be used for the next row */
            t[k++]=T;
        c++; /*Absorbs the newline at the end of every row */
        /* Keep track of our right-most outputs, 
        and store them in the handy string passed to the function. */
        l[i++]=L;
    }
    /* Bottom output is now stored entirely in t, as is right output in l */        
}

हम पुनरावृति करते हैं c, बाएं से दाएं (फिर ऊपर से नीचे), tहर बार इनपुट को फिर से लिखना और दाएं-सबसे अधिक आउटपुट को बाहर धकेलना जो lस्ट्रिंग में छाया हुआ है । हम की शीर्ष पंक्ति की जगह के रूप में इस कल्पना कर सकते हैं cके साथ 1की और 0'iteratively है, और बिट्स है कि सही में बाहर धकेल दिया जाता है का ट्रैक रखने के।

यहां अधिक दृश्य अनुक्रम, पंक्ति द्वारा पंक्ति:

 111                                  
1&+^  =>  110 ->0  =>     ->0  =>     0 Thus, "01" has been written to l,
1+&+     1+&+         110 ->1         1
                                  110   And "110" is stored currently in t.

यह स्पष्ट रूप से विभिन्न प्रतीकों और आकारों के साथ अधिक जटिल हो जाता है, लेकिन केंद्रीय विचार रखता है। यह केवल इसलिए काम करता है क्योंकि डेटा कभी भी ऊपर या नीचे नहीं बहता है।

Comments

गोल्फ के लिए बहुत सारी संभावनाएं! के शीर्षक को बदलकर शुरू fकरने के लिए f(c,t,l)char*c,*t,*l(वापसी प्रकार के बारे में एक बकवास देना नहीं है)।

— फ़ूजएक्सएक्सएल

@FUZxxl किसी ने चैट में इसका उल्लेख किया है, लेकिन मैं इसे काम नहीं कर सका। क्या यह व्यवहार मानक है? LLVM उस रेखा के साथ कम से कम 2 त्रुटियां फेंकता है।

— ब्रेनसैटल

माफ़ कीजिये। होना चाहिए था f(c,t,l)char*c,*t,*l;। C11 मोड में संकलित न करें, क्योंकि निहित इंट नियम जो हमें वापसी प्रकार को छोड़ने की अनुमति देता है, उस संशोधन में छोड़ दिया गया है।

— फ़ूजक्कल

@FUZxxl यह C99 में भी विफल होता दिख रहा है। वास्तव में, मेरे द्वारा संकलित किए गए प्रत्येक मोड ने उस कोड को अस्वीकार कर दिया है।

— ब्रेनसैटल

क्या आपने अर्धविराम के ठीक बाद जोड़ा *l? यह मेरी मशीन पर C99 मोड में संकलित करता है।

— FUZxxl

Answer 4

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

यह फ़ंक्शन 10 टाइल लंबो फ़ंक्शन का निर्माण करता है, फिर ग्रिड को अपडेट करता है, लॉजिक स्टेट्स को अपडेट करता है। अंतिम ऊर्ध्वाधर और क्षैतिज तर्क वाले राज्य तब मुद्रित होते हैं।

def b(d,j,g):
 h=enumerate;e=dict((s[0],eval('lambda T,L:('+s[1:]+')'))for s in' 0,0#00,0#11,1#+L,T#\\T,L#UT,T#)L,L#!1-L,1-T#&T&L,T&L#|T|L,T|L#^T^L,T^L'.split('#'));j=list(j+'\n');g=list(g)
 for y,k in h(d.split('\n')):
  L=g[y]
  for x,c in h(k):T=j[x];L,B=e[c](int(T),int(L));j[x]=`B`
  g[y]=`L`
 print''.join(j+g)

परीक्षण सहित अपुष्ट कोड:

def logic(grid, top, left):
    loop = enumerate;
    func = dict((s[0], eval('lambda T,L:('+s[1:]+')')) for s in ' 0,0#00,0#11,1#+L,T#\\T,L#UT,T#)L,L#!1-L,1-T#&T&L,T&L#|T|L,T|L#^T^L,T^L'.split('#'));
    top = list(top+'\n');
    left = list(left)
    for y,row in loop(grid.split('\n')):
        L = left[y]
        for x,cell in loop(row) :
            T = top[x];
            L, B = func[cell](int(T), int(L));
            top[x] = `B`
        left[y] = `L`
    print ''.join(top + left)

import re
testset = open('test.txt', 'rt').read().strip()
for test in testset.split('\n\n'):
    if test.endswith(':'):
        print '------------------\n'+test
    elif re.match('^[01/\n]+$', test, re.S):
        for run in test.split():
            top, left = run.split('/')
            print 'test', top, left
            logic(grid, top, left)
    else:
        grid = test

test.txt(Sp3000 द्वारा 2 अन्य परीक्षण भी शामिल है) फ़ाइल:

Nand:

&!

00/0
00/1
10/0
10/1

All ones:

1111
1\+\
1+\+
1\+\

1001/1100

Xor from Nand (note the column of trailing spaces):

\)+\ 
U&!& 
+! ! 
\&!& 
   ! 

00000/00000
00000/10000
10000/00000
10000/10000

Half adder:

+))
U&+
U+^

000/000
000/100
100/000
100/100

Right shift:

\\\
\++
\++

001/110
010/101
101/100

परीक्षण उत्पादन:

------------------
Nand:
test 00 0
01
1
test 00 1
01
1
test 10 0
01
1
test 10 1
11
0
------------------
All ones:
test 1001 1100
1111
1111
------------------
Xor from Nand (note the column of trailing spaces):
test 00000 00000
00000
00000
test 00000 10000
00010
00000
test 10000 00000
00010
00000
test 10000 10000
00000
00000
------------------
Half adder:
test 000 000
000
000
test 000 100
001
101
test 100 000
101
001
test 100 100
110
110
------------------
Right shift:
test 001 110
000
111
test 010 101
101
010
test 101 100
010
110

Answer 5

पायथन 2, 384 338 325 बाइट्स

def f(G,T,L):
 def g(x,y):
  if x>-1<y:l=g(x-1,y)[1];t=g(x,y-1)[0];r=l,t,1-l,0,0,1,t,l,l&t,l|t,l^t;i="+\\!0 1U)&|^".index(G[y*-~W+x]);return((t,l,1-t)+r[3:])[i],r[i]
  return(int((y<0)*T[x]or L[y]),)*2
 H=G.count("\n")+1;W=len(G)/H;return eval('"".join(map(str,[g(%s]for _ in range(%s)])),'*2%('_,H-1)[0','W','W-1,_)[1','H'))

गंभीरता से सीएच, अगर यह एक खिलौना नहीं है, तो आपको पहले से ही कुछ खिलौना कारखानों को बजाना शुरू कर देना चाहिए।

अधिक गोल्फ और कम कुशल अब, लेकिन फिर भी CarpetPython को नहीं पकड़ा है। इनपुट की तरह f("1111\n1\\+\\\n1+\\+\n1\\+\\","0101","1010"), आउटपुट दो तार का एक टपल है। सुनिश्चित करें कि बोर्ड में एक अनुगामी नई रेखा नहीं है, जो चीजों को तोड़ देगी।

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

def f(G,T,L):
 def g(x,y):
  if x>-1<y:l=g(x-1,y)[1];t=g(x,y-1)[0];r=l,t,1-l,0,0,1,t,l,l&t,l|t,l^t;i="+\\!0 1U)&|^".index(G[y*-~W+x]);return((t,l,1-t)+r[3:])[i],r[i]
  return(int((y<0)*T[x]or L[y]),)*2
 H=G.count("\n")+1;W=len(G)/H;return eval('"".join(map(str,[g(%s]for _ in range(%s)])),'*2%('_,H-1)[0','W','W-1,_)[1','H'))


import itertools

G = r"""
+))
U&+
U+^
""".strip("\n")

def test(T, L):
    print f(G, T, L)

def test_all():
    W = len(G[0])
    H = len(G)

    for T in itertools.product([0, 1], repeat=len(G.split("\n")[0])):
        T = "".join(map(str, T))

        for L in itertools.product([0, 1], repeat=len(G.split("\n"))):
            L = "".join(map(str, L))

            print "[T = %s; L = %s]" % (T, L)
            test(T, L)
            print ""

test("000", "000")
test("000", "100")
test("100", "000")
test("100", "100")

आप सभी संभावित मामलों का परीक्षण भी कर सकते हैं test_all()।

अतिरिक्त परीक्षण के मामले

आधा योजक

यहाँ एक आधा योजक है जो शीर्ष बाएँ बिट्स को जोड़ता है, आउटपुट <input bit> <carry> <sum>:

+))
U&+
U+^

टेस्ट:

000 / 000  ->  000 / 000
000 / 100  ->  001 / 101
100 / 000  ->  101 / 001
100 / 100  ->  110 / 110

यदि इनपुट्स के दूसरे / तीसरे बिट्स को बदल दिया जाए तो भी आउटपुट समान होना चाहिए।

सही बदलाव

यह देखते हुए abc / def, यह आउटपुट fab / cde:

\\\
\++
\++

टेस्ट:

001 / 110 -> 000 / 111
010 / 101 -> 101 / 010
101 / 100 -> 010 / 110

3-बिट सॉर्टर

नीचे के अंतिम तीन बिट्स में ऊपर के पहले तीन बिट्स को सॉर्ट करता है। सही आउटपुट जंक है।

UUU)))
UU)U U
U&UU U
U+|&)U
\UU++|
 \)&UU
  \+|U
   UUU

टेस्ट:

000000 / 00000000 -> 000000 / 00000000
001000 / 00000000 -> 000001 / 11111111
010000 / 00000000 -> 000001 / 00001111
011000 / 00000000 -> 000011 / 11111111
100000 / 00000000 -> 000001 / 00001111
101000 / 00000000 -> 000011 / 11111111
110000 / 00000000 -> 000011 / 00001111
111000 / 00000000 -> 000111 / 11111111

2-बिट 2-बिट गुणक द्वारा

पहले नंबर के रूप में शीर्ष के 2/2 बिट्स लेता है, और दूसरे नंबर के रूप में शीर्ष के तीसरे / चौथे बिट्स। नीचे के अंतिम चार बिट्स को आउटपुट देता है। सही आउटपुट जंक है।

UUUU))))
UU++)))&
UUU+)  U
UU++&))U
U++&+)^U
U)&\&)UU
   U+^UU
   \&UUU

संपादित करें: एक स्तंभ और दो पंक्तियों को गढ़ा।

टेस्ट:

00000000 / 00000000 -> 00000000 / 00000000
00010000 / 00000000 -> 00000000 / 10000000
00100000 / 00000000 -> 00000000 / 00000000
00110000 / 00000000 -> 00000000 / 10000000
01000000 / 00000000 -> 00000000 / 00000000
01010000 / 00000000 -> 00000001 / 11111111
01100000 / 00000000 -> 00000010 / 00000000
01110000 / 00000000 -> 00000011 / 11111111
10000000 / 00000000 -> 00000000 / 00000000
10010000 / 00000000 -> 00000010 / 10000000
10100000 / 00000000 -> 00000100 / 00000000
10110000 / 00000000 -> 00000110 / 10000000
11000000 / 00000000 -> 00000000 / 00000000
11010000 / 00000000 -> 00000011 / 11111111
11100000 / 00000000 -> 00000110 / 00000000
11110000 / 00000000 -> 00001001 / 11111111

Answer 6

आर, 524 517

शायद इस समय इसे कम करने के लिए बहुत सारे कमरे हैं, लेकिन ऐसा करना वास्तव में दिलचस्प रहा है। दो कार्य हैं। फंक्शन d कार्यकर्ता है और f तुलना है।

फ़ंक्शन d को 3 स्ट्रिंग्स, गेट्स, टॉप और लेफ्ट के साथ कहा जाता है। गेट्स चौड़ाई द्वारा निर्धारित मैट्रिक्स में डाल दिए जाते हैं।

I=strtoi;S=strsplit;m=matrix;f=function(L,T,G){O=I(c(0,1,L,T,!L,!T,L&T,L|T,xor(L,T)));X=which(S(' 01+\\U)!&|^','')[[1]]==G);M=m(c(1,1,1,2,1,1,3,2,2,4,3,4,5,4,3,6,4,4,7,3,3,8,5,6,9,7,7,10,8,8,11,9,9),nrow=3);return(c(O[M[2,X]],O[M[3,X]]))};d=function(G,U,L){W=nchar(U);H=nchar(L);U=c(list(I(S(U,'')[[1]])),rep(NA,H));L=c(list(I(S(L,'')[[1]])),rep(NA,W));G=m((S(G,'')[[1]]),nrow=W);for(i in 1:H)for(n in 1:W){X=f(L[[n]][i],U[[i]][n],G[n,i]);L[[n+1]][i]=X[1];U[[i+1]][n]=X[2]};cat(U[[H+1]],' / ',L[[W+1]],sep='',fill=T)}

थोड़ा सा स्वरूप दिया

I=strtoi;S=strsplit;m=matrix;
f=function(L,T,G){
    O=I(c(0,1,L,T,!L,!T,L&T,L|T,xor(L,T)));
    X=which(S(' 01+\\U)!&|^','')[[1]]==G);
    M=m(c(1,1,1,2,1,1,3,2,2,4,3,4,5,4,3,6,4,4,7,3,3,8,5,6,9,7,7,10,8,8,11,9,9),nrow=3);
    return(c(O[M[2,X]],O[M[3,X]]))
};
d=function(G,U,L){
    W=nchar(U);H=nchar(L);
    U=c(list(I(S(U,'')[[1]])),rep(NA,H));
    L=c(list(I(S(L,'')[[1]])),rep(NA,W));
    G=m((S(G,'')[[1]]),nrow=W);
    for(i in 1:H)
        for(n in 1:W){
            X=f(L[[n]][i],U[[i]][n],G[n,i]);
            L[[n+1]][i]=X[1];
            U[[i+1]][n]=X[2]
        };
    cat(U[[H+1]],' / ',L[[W+1]],sep='',fill=T)
}

कुछ परीक्षण

> d('&!','00','0')
01 / 1
> d('&!','00','1')
01 / 1
> d('&!','10','0')
01 / 1
> d('&!','10','1')
11 / 0
> d('\\)+\\ U&!& +! ! \\&!&    ! ','00000','00000')
00000 / 00000
> d('\\)+\\ U&!& +! ! \\&!&    ! ','00000','10000')
00010 / 00000
> d('\\)+\\ U&!& +! ! \\&!&    ! ','10000','00000')
00010 / 00000
> d('\\)+\\ U&!& +! ! \\&!&    ! ','10000','10000')
00000 / 00000
> d('+++\\00000000000\\!!!!\\00000000000\\+++','000000000000','100')
000000000000 / 001
> d('+++\\00000000000\\!!!!\\00000000000\\+++','000000000000','000')
000000000000 / 000
> d('+))U&+U+^','000','000')
000 / 000
> d('+))U&+U+^','000','100')
001 / 101
> d('+))U&+U+^','100','000')
101 / 001
> d('+))U&+U+^','100','100')
110 / 110