वायरवर्ल्ड में एक डिजिटल घड़ी बनाएँ

गेम ऑफ लाइफ के इस सवाल से प्रेरित है ।

वायरवर्ल्ड "इलेक्ट्रॉनों" को "तारों" से प्रवाहित करते हैं, जिनमें से साधारण व्यवस्थाएं विशिष्ट तर्क गेट व्यवहार का उत्पादन करती हैं।

मैं आपको वायरवर्ल्ड सेल्यूलर ऑटोमैटन में डिजिटल घड़ी बनाने की चुनौती देता हूं। आपकी घड़ी को सामान्य फैशन में 00:00 से 23:59 तक, या AM / PM संकेतक के साथ 11:59 तक गिनना चाहिए, फिर रीसेट करना चाहिए।

आपकी प्रविष्टि को नेत्रहीन रूप से दो भागों में विभाजित किया जाना चाहिए। भाग ए में सभी गैर-प्रदर्शन तर्क शामिल होने चाहिए, जो सभी अंकों को बढ़ाने और लूपिंग में शामिल हैं। पार्ट बी डिस्प्ले और लॉजिक होगा जो इसे ड्राइव करता है। इन दो हिस्सों के बीच एकमात्र कनेक्शन बीसीडी में समय के चार अंकों का प्रतिनिधित्व करने वाले 16 तार होना चाहिए (एएम / पीएम संकेतक के लिए एक वैकल्पिक तार के साथ, और सिग्नल घड़ी लाइन के लिए एक वैकल्पिक तार यदि आपके सिग्नल निरंतर नहीं हैं)। (EDIT: हमेशा-शून्य तारों को छोड़ा जा सकता है)

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

यह एक कोड-गोल्फ प्रतियोगिता है। आपका स्कोर धुरी के हिस्से के बाउंडिंग बॉक्स के चारों ओर का भाग A है।

सादृश्य से, यदि यह एक शाब्दिक भाषा थी, तो आपका स्कोर चार 4-बिट आउटपुट उत्पन्न करने वाले घड़ी-प्रबंधन फ़ंक्शन का आकार होगा, जिसमें 4 काउंटरों के लिए एक लूप और तर्क होता है, न कि फ़ंक्शन जो उस आउटपुट को डीकोड और प्रिंट करता है।

आपका भाग B जितना चाहे उतना बड़ा या छोटा हो सकता है। यह केवल इसलिए आवश्यक है ताकि आपके सबमिशन का आउटपुट इसे चलाने वाले किसी व्यक्ति द्वारा देखा जा सके, क्योंकि वायरवर्ल्ड सर्किट से केवल "डिबग" आउटपुट का कोई आसान तरीका नहीं है। ऑनलाइन कई BCD-> 7 सेक्ट सर्किट उपलब्ध हैं। अगर आपको एक क्लॉक सिग्नल लाइन की आवश्यकता है, या आप अपना कोई भी उपयोग करना चाहते हैं, तो अंक के समान किसी पैमाने पर अपने AM / PM इंडिकेटर को प्रदर्शित करें।

संपादित करें: पार्ट बी अब वैकल्पिक है। यदि आपके पास अपने भाग ए से सिर्फ बीसीडी आउटपुट हैं, तो उसे जमा करने के लिए स्वतंत्र महसूस करें। घड़ी के कामों की पुष्टि करने के लिए यह अधिक थकाऊ होगा, लेकिन मैं एक रुके हुए सिमुलेशन में बिट्स की एक पंक्ति को ठीक से पढ़ सकता हूं।

code-golf cellular-automata

— Sparr
स्रोत

यहाँ एक छोटा सा ऑनलाइन सिम्युलेटर है।

— NonlinearFruit

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

— wyldstallyns

मेरे पास 150,000 सेल काम करने वाला पार्ट ए है जिसे मैं काम कर सकता हूं लेकिन वर्तमान में एक नियम-अनुपालन पार्ट बी का अभाव है

— wyldstallyns

मुझे उम्मीद नहीं थी कि पार्ट बी कठिन होगा। भाग A में आपके इलेक्ट्रॉन कितने दूर हैं?

— 21

@wyldstallyns यह 16/12/2016 03: 30: 35Z पर बंद हो जाता है (आप सटीक समय पाने के लिए 'कल' पर मंडरा सकते हैं)। आपको बहुत बहुत शुभकामनाएँ। मैं वास्तव में आपकी घड़ी को पसंद करता हूं। यह एक बहुत ही सरल विचार और एक उत्कृष्ट निष्पादन है। मुझे मानना चाहिए कि मैं इस बात से भी आश्चर्यचकित था कि अंत में अंतरिक्ष ने मेरा कितना स्थान लिया। और मुझे आपके साथ आने वाले किसी भी सुधार को देखने में दिलचस्पी होगी। तो, शुभकामनाएँ :)

— नीमरियो

जवाबों:

लाचिंग घड़ी

स्कोर - 53,508 (जिनमें से केवल 36,828 एल-आकार के डिज़ाइन के कारण सक्रिय रूप से उपयोग किया जाता है)

उच्च गुणवत्ता रिकॉर्डिंग - https://1drv.ms/u/s !
ArQEzxH5nQLKhvt_HHfcqQKo2FODLQ Golly पैटर्न - https://1drv.ms/u/s !s -ArQEzxH5nQLKhvwAmwCY-ipiBuBmBmQ

मार्गदर्शक सिद्धांत -

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

भाग I: मिनट काउंटर

अंक शास्त्र

बाइनरी में 0 से 9 तक गिनती (कम से कम महत्वपूर्ण मिनट अंक के लिए) इस प्रकार है -

0 - 0000
1 - 0001
2 - 0010
3 - 0011
4 - 0100
5 - 0101
6 - 0110
7 - 0111
8 - 1000
9 - 1001

यह पढ़ते हुए कि कॉलम के रूप में, सबसे कम महत्वपूर्ण (2 ^ 0 यूनिट बिट स्ट्रीम) 01010101 जाता है, 2 ^ 1 यूनिट स्ट्रीम 0011001100 जाता है, 2 ^ 2 यूनिट स्ट्रीम 0000111100 और 2 ^ 3 यूनिट स्ट्रीम 0000000011 हो जाता है।

पहले वाला आसान है - बस फ्लिप-फ्लिप 01 हमेशा के लिए। तीसरा चार 1s, छह 0s, छह शून्य द्वारा स्थानांतरित चरण की एक धारा है। चौथा आठ 0 और दो 1 s की एक धारा है।

दूसरा थोड़ा कठिन है क्योंकि यह एक गंदा विषमता है। हालाँकि, मुझे लगता है कि (जहां है कॉनैट ऑपरेटर):

0011001100। 0011001100 = 0011001100। NOT (1100110011) = 0011001100110011001111 XOR 00000000001111111111 = 5 (0011) XOR 00000000001111111111

(संयोग से, जैसा कि बाद में कहा गया, मेरी घड़ी का अधिकांश हिस्सा 60-बीट टिकर पर चलता है। 00000000001111111111 डबल लेंथ वेव जहां 120-बीट टिकर की जरूरत होती है)।

डिज़ाइन

आउटपुट ऊपर से नीचे तक मिनटों की इकाइयों (2 ^ 0, 2 ^ 1, 2 ^ 2, 2 ^ 3) तब दस मिनट की मिनट (2 ^ 0, 2 ^ 2, 2 ^ 1) की धाराएं चलती हैं। ध्यान दें कि नीचे दो तारों को पार किया गया है।

120-बीट मेन क्लॉक।
ठंड शुरू करने के लिए इलेक्ट्रॉन कहां रखें। किसी भी इलेक्ट्रॉन पूंछ के बिना यह दो दिशाओं में विभाजित होता है, लेकिन ऊपर दी गई डायोड तुरंत इनमें से एक को पकड़ती है, जो एक अच्छा सायक्लिंग इलेक्ट्रॉन देती है और 120-बीट लूप के चारों ओर घूमती है।
12-बीट सेकेंडरी क्लॉक।
कंडक्टर + डायोड का कुंडली माध्यमिक 12-बीट घड़ी शुरू करता है। शब्द इस बात का वर्णन नहीं कर सकते हैं कि यह छोटा सा टुकड़ा कितनी आसानी से सिंक हुआ था। आपको 120 और 60 बीट घड़ियों को सिंक करना है, फिर 12-बीट और फ़्रीक्वेंसी हाल्वर 24-बीट स्यूडो घड़ियों में सिंक करना है, इसके बाद 24-बीट घड़ी को 120 बीट की घड़ी में वापस बांधना है अन्यथा XOR गेट काम नहीं करता है ।
चरण बदलाव।
फ्लिप फ्लॉप। इनपुट पर एक एकल इलेक्ट्रॉन पहले सेट लाइन को हिट करता है फिर बहुत विशिष्ट समय के बाद, रीसेट लाइन को हिट करता है, जिसमें एक पल्स इन, एक पल्स आउट होता है।
यहां कूबड़ जोड़ना - रीसेट लाइन पर, सेट के बीच देरी को बढ़ाता है और फ्लिप-फ्लॉप पर रीसेट करता है। प्रत्येक अतिरिक्त कूबड़ एक अतिरिक्त नाड़ी देता है। नीचे फ्लिप-फ्लॉप में नौ अतिरिक्त कूबड़ होते हैं, इसलिए सेट और रीसेट के बीच दस दालें होती हैं।
मेरी मुश्किल 2 ^ 1 यूनिट मिनट के लिए XOR गेट।
AND-NOT गेट और बहुत विशिष्ट भाग लंबाई का मतलब है कि प्रत्येक इलेक्ट्रॉन नाड़ी जो अपने आप पीछे वापस आती है और इलेक्ट्रॉन को पीछे हटा देती है। फ़्रिक्वेंसी हेल्वर। 12-बीट सेकंडरी स्रोत से 24-बीट घड़ी बनाता है।
60-बीट सेकेंडरी क्लॉक, जो वास्तव में अधिकांश काम करता है। बस धीमी गति से एक तेज घड़ी शुरू करना आसान है, इसलिए सबसे धीमी घड़ी (120-बीट्स) मास्टर है, भले ही इसका उपयोग मुश्किल से हो। 60 बीट वाली घड़ी इस चीज का दिल है।
प्रतिक्रिया तार जो केवल 60-बीट घड़ी को टिक करने पर इलेक्ट्रॉनों को वहन करती है। यह 120-बीट मास्टर से बार-बार शुरू होने वाली घड़ी को रोकने के लिए AND-NOT गेट के साथ संयोजन में उपयोग किया जाता है। अन्यथा कई भयानक चीजें होती हैं और Ctrl-Z उद्धारकर्ता होता है।
डायोड जहां 60-बीट घड़ी से शुरू किया जाता है।
यह पूरा उपकरण एक फ्लिप फ्लॉप, और गेट, और AND-NOT गेट संयुक्त है। यह एक कुंडी देता है। एक पल्स इसे शुरू करता है, एक पल्स इसे रोकता है।
तार की लूप 10 दालों के इनपुट पर एक के लिए 10 दालों को 10 दालों को कुंडी करने के लिए। इसके बिना हमें 12 दालें मिलती हैं, 8 दालें बंद। दस बंद लैच पर ये दस दस मिनट के ब्लॉक के बुनियादी घटकों को उसी तरह से बनाते हैं जैसे 6-माइक्रोन (1 पल्स) फ्लिप-फ्लॉप ने मिनट इकाइयों के बुनियादी घटकों का गठन किया।
कोल्ड स्टार्ट प्रारंभिक पल्स ने सभी प्रकार की समस्याओं का कारण बना दिया, जिसमें दो घड़ियां शामिल हैं जो कि घड़ियों के साथ शुरू होती हैं। इससे कुंडी खराब हो जाती है। यह और गेट सिंक दालों से बाहर निकलता है और निपटता है - विशेष रूप से शुरुआती पल्स।
यह डिजाइन का एक हिस्सा है जो मुझे पूर्वव्यापी में कुछ अफसोस है। यह एक इलेक्ट्रॉन लेता है, इसे पांच में विभाजित करता है और पांच इलेक्ट्रॉनों को पीछे छोड़ता है, 111111 से 100000 तक ले जाता है।
यह एक इलेक्ट्रॉन लेता है और इसे मोर्चे पर सिलाई करता है। सटीक होने के लिए दो चरण आगे। यह 100000 लेता है और 101000 बनाता है। भाग 16 के साथ संयुक्त हम 111111 प्राप्त करते हैं -> 100000 -> 101000। प्रतिशोध में मैं चाहता हूँ कि मैं 111111 -> 101010 -> 101000; इसने कम जगह में एक ही प्रभाव हासिल किया होगा।
इसके बाद के संस्करण पैटर्न नीचे कुंडी में धकेल दिया जाता है 20 प्राप्त करने के लिए, 40 बंद। यह विभाजित होता है, आधा चरण 20 इकाइयों द्वारा स्थानांतरित किया जाता है, और फिर ये दसियों मिनटों के दो उच्च क्रम बिट धाराओं का निर्माण करते हैं।

भाग II: घंटा काउंटर

व्याख्या

घंटे काउंटर का इनपुट एक एकल इलेक्ट्रॉन पल्स है, जो एक घंटे में एक बार होता है। पहला कदम यह है कि इसे हर एक इलेक्ट्रान पल्स में घटाया जाए, हर बारह घंटे में एक बार। यह कई "कुंडी और पकड़ने" का उपयोग कर प्राप्त किया जाता है।

एक "कुंडी" एक 6-माइक्रोन फ्लिप-फ्लॉप है जो AND-NOT और AND गेट से जुड़ा है जो 6-माइक्रोन को ऑन / ऑफ लैच देता है। एक "कैच" इनपुट के रूप में इलेक्ट्रॉनों की एक सतत स्ट्रीम लेता है, पहले के माध्यम से अनुमति देता है, फिर हर दूसरे इलेक्ट्रॉन को पीछे हटा देता है, जब तक कि स्ट्रीम किस बिंदु पर समाप्त नहीं हो जाती है।

श्रृंखला में, एक कैच के बाद, एक कुंडी रखने से, एक इलेक्ट्रॉन में परिणाम मिलता है -> कुंडी चालू होता है, एक इलेक्ट्रॉन दूसरे छोर से बाहर निकलता है (बाकी कैच द्वारा पकड़ा जाता है)। फिर दूसरा इलेक्ट्रॉन -> कुंडी बंद करता है, चुपचाप रीसेट को पकड़ता है। शुद्ध प्रभाव: पहला इलेक्ट्रॉन गुजरता है, दूसरा इलेक्ट्रॉन विलोपित होता है, और इसी तरह और आगे, चाहे वह उन इलेक्ट्रॉनों के बीच कितनी भी देरी हो ।

अब श्रृंखला में श्रृंखला दो "कुंडी और पकड़", और आपके पास केवल चार इलेक्ट्रॉनों में से एक है।

अगला, एक तीसरा "कुंडी और कैच" लें, लेकिन इस बार AND-NOT गेट और फ्लिप-फ्लॉप SET के बीच फ्लिप-फ्लॉप SET लाइन पर एक संपूर्ण चौथी कुंडी और कैच करें। मैं आपको यह सोचने के लिए छोड़ दूंगा कि यह कैसे काम करता है, लेकिन इस बार केवल तीन इलेक्ट्रॉनों में से एक गुजरता है, भले ही उन इलेक्ट्रॉनों के बीच देरी कितनी भी लंबी हो ।

अंत में, चार इलेक्ट्रॉनों में से एक को लें, और तीन में से एक, उन्हें एक एंड गेट के साथ मिलाएं, और केवल बारह इलेक्ट्रॉनों में से एक गुजरता है। यह पूरा खंड नीचे दिए गए घंटे के काउंटर के ऊपर बाईं ओर जाने वाले रास्तों का गन्दा भाग है।

इसके बाद, इलेक्ट्रॉन को हर बारह घंटे पर लें और प्रत्येक घंटे में वापस विभाजित करें, लेकिन प्रत्येक को एक अलग कंडक्टर तार पर आउटपुट करें। यह तेरह निकास बिंदुओं के साथ लंबे कुंडलित कंडक्टर का उपयोग करके प्राप्त किया जाता है।

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

अंत में - इन दालों को लें और उन्हें सही बीसीडी बिटकॉन्स को आउटपुट करने के लिए ROM (रीड-ओनली मेमोरी) के साढ़े सात बाइट्स में पास करें। वायरवर्ल्ड रोम के अधिक विस्तृत विवरण के लिए यहां देखें: http://www.quinapalus.com/wires6.html

डिज़ाइन

प्रति घंटे इनपुट एक इलेक्ट्रॉन।
पहले कुंडी।
पहला कैच।
"लाच एंड कैच" एक बाहरी "कुंडी और पकड़" SET लाइन पर एम्बेडेड है।
और गेट।
AM / PM कुंडी (हर बारह घंटे में एक बार चालू / बंद)।
तार का प्रत्येक लूप 6x60 = 360 इकाई लंबा है।
फ्लिप / फ्लॉप ने एक छोटी प्रोफ़ाइल बनाने के लिए अपना पक्ष बदल दिया।
रोम के साढ़े सात बाइट्स।

इसकी एक इलेक्ट्रॉन प्रति मिनट, 6-माइक्रोन डिज़ाइन के कारण, एक वास्तविक समय की घड़ी के लिए सिमुलेशन को प्रति मिनट छह पीढ़ियों (प्रत्येक 10 सेकंड में एक पीढ़ी) पर चलाएं।
पीएम के लिए एएम / पीएम लाइन हाई (1), पीएम के लिए लो (0) है। यह चुनने के लिए थोड़ा असामान्य तरीका हो सकता है, लेकिन औचित्य है। ठंड की शुरुआत के दौरान, AM / PM लाइन शुरू में स्वाभाविक रूप से कम (0) होती है। जैसे ही AM / PM लाइन को उच्च (1) खींचा जाता है, यह इंगित करता है कि गिनती 12:00 AM पर शुरू हो गई है। इस बिंदु से पहले सभी आउटपुट की अवहेलना की जानी चाहिए, इस बिंदु के सार्थक होने के बाद सभी आउटपुट।

उपयोगी कड़ियाँ

मैंने http://www.Winapalus.com/wi-index.html से वायरवर्ल्ड की मूल बातें सीखीं । एक उत्कृष्ट संसाधन।
बनाने के लिए और सेल्युलर ऑटोमेटन का अनुकरण करने के लिए मैंने Golly का उपयोग किया: http://golly.sourceforge.net/
मैंने http://mathworld.wolfram.com/WireWorld.html से AND गेट डिज़ाइन लिया
और मैंने केवल इस वेबपृष्ठ को पाया है इसलिए इसका उपयोग नहीं किया, लेकिन यह बहुत अच्छा लग रहा है: http://karlscherer.com/Wireworld.html

— niemiro
स्रोत

आवश्यकताओं को बदल दिया ताकि हमेशा-शून्य आउटपुट को छोड़ा जा सके। दसियों घंटे के लिए 4s और 8s बिट का उपयोग कभी नहीं किया जाता है, न ही 8s बिट्स दसियों मिनट के लिए।

— स्पैर

ठोस! सच्ची इंजीनियरिंग। क्या कोई अन्य तर्क द्वार उपयोगी होगा? मैं कुछ जबरदस्ती करने वाला हूं।

— wyldstallyns 1:

यह सुंदर है

— स्पार्क

ओह अच्छा दुःख जो अभी काफी करीब है अब मैं कोशिश कर रहा हूँ और मेरा अनुकूलन करने के लिए मजबूर हूँ। मेरे पास दोहराए जाने वाले पैटर्न हैं जिन्हें मैं दूसरों को मोड़ने के लिए जगह बनाने के लिए छोटा कर सकता हूं।

— wyldstallyns

मुझे नहीं पता कि आप मेटा पर कितने सक्रिय हैं, इसलिए आपको यह बताना है कि मैंने इस उत्तर को सर्वश्रेष्ठ पीपीसीजी 2016 के लिए नामित किया है ।

— पीटर टेलर

विलंब रेखा मेमोरी - 51 x 2880 = 146880

ज़ूम आउट:

आउटपुट प्रत्येक लूप के शीर्ष पर आता है।

मैंने इस लुआ के साथ सभी राज्यों को सीधे तार पर रख दिया, gollyताकि बिट्स के बीच इलेक्ट्रॉनों को आगे बढ़ाया जा सके ताकि हमें एक कर्सर के साथ तार का पालन न करना पड़े।

मैंने इस भोली विधि का उपयोग बार और क्रैश कोर्स वायरवर्ल्ड, गुल्ली और लूआ को सेट करने के लिए किया।

local g = golly()

local minutes_in_day = 1440 -- 60x24
local interval = 4 -- how often to send electrons

local function bcd4(num)
    num=math.floor(num)
    local t={}
    for b=4,1,-1 do
        t[b]=math.floor(math.fmod(num,2))
        num=(num-t[b])/2
    end
    return table.concat(t)
end

local function makewire(x,y1,y2)
    for y1=1,y2 do g.setcell(x,y1,3) end
end

local function makeloop(x,y,size)
    local len = size/2 - 1
    makewire(x,y+1,len); makewire(x+2,y+1,len) -- main wires
    g.setcell(x+1,y,3); g.setcell(x+1,y+len,3) -- endcape
end

local function paint(x,y,pattern)
    for v in string.gmatch(pattern,".") do
        if v=="1" then g.setcell(x, y, 1); g.setcell(x, y-1, 2) end
        x = x + 4
    end
    g.show(pattern);g.update() -- slows things down but more interesting to watch
    for i=1,interval do g.step() end
end

for x=0,63,4 do makeloop(x,0,minutes_in_day * interval) end

for hour = 0,23 do
      for minute = 0,59 do
         paint( 0, 2, bcd4(hour/10) .. bcd4(hour%10) .. bcd4(minute/10) .. bcd4(minute%10) )
      end
end

परीक्षण के लिए मैंने इन शीर्ष तारों को जोड़ा और उनकी युक्तियों को देखा।

Imgur

यहाँ 4 वायर बीसीडी के 4 सेट को नेत्रगोलक में इकट्ठा करने की स्क्रिप्ट है।

-- watches 16 wires spaced 4 apart starting at (0,-4)
local ticks = 1440 -- set to match the length of your 24 hour loop
local g = golly()
local output = ""
local nums = {  ["0000"] = "0", ["0001"] = "1", ["0010"] = "2", ["0011"] = "3", ["0100"] = "4",
                ["0101"] = "5", ["0110"] = "6", ["0111"] = "7", ["1000"] = "8", ["1001"] = "9",
                ["1010"] = "A", ["1011"] = "B", ["1100"] = "C", ["1101"] = "D", ["1110"] = "E",
                ["1111"] = "F" } -- full set in case we have errors (i did)

for i=0,ticks,1 do
   local text = ""
   for i=0,48,16 do -- set your X here, change the 0 and 48
       local word = ""
       for j=0,15,4 do
            local bit = g.getcell(i+j,-4) -- set your Y here, change -4
            if bit == 0 or bit == 3 then word = word .. "0" else word = word .. "1" end
       end
       text = text .. nums[word]
   end
   g.show(text); output = output..' '..text
   g.update(); g.step();g.step();g.step();g.step()
end
g.note(output)

अंतिम उत्तर में हमेशा-शून्य रेखाओं को छांटने और बाकी को उनके सही बीसीडी इनपुट्स तक पहुँचाने की आवश्यकता होती है।

— wyldstallyns
स्रोत

आवश्यकताओं को बदल दिया ताकि हमेशा-शून्य आउटपुट को छोड़ा जा सके। दसियों घंटे के लिए 4s और 8s बिट्स का उपयोग कभी नहीं किया जाता है, न ही 8s बिट्स दसियों मिनट के लिए।

— स्पैर

यह एक उल्लसित और भयानक कार्यान्वयन है!

— शुक्राणु

ठीक है मैं 11 वें घंटे में एक और कार्यात्मक घड़ी के साथ हरा रहा हूं। मैं अलग-अलग चाल के साथ सबसे लंबे और सबसे छोटे छोरों पर हमला करने जा रहा हूं।

— wyldstallyns

मैं इसे खींचने नहीं जा रहा हूं। मैं 3 माइक्रोन दालों पर स्विच करके 1/4 के आकार को बचा सकता हूं, लेकिन यह अभी भी नीमिरो को हरा करने के लिए पर्याप्त तंग नहीं करेगा।

— wyldstallyns

वायरवर्ल्ड में एक डिजिटल घड़ी बनाएँ

लाचिंग घड़ी

भाग I: मिनट काउंटर

अंक शास्त्र

डिज़ाइन

भाग II: घंटा काउंटर

व्याख्या

डिज़ाइन

टिप्पणियाँ

उपयोगी कड़ियाँ

विलंब रेखा मेमोरी - 51 x 2880 = 146880