कंप्यूटर के लिए गेम कैसे लिखें जिसमें कोई इनपुट और आउटपुट डिवाइस न हों

विद्युत चुम्बकीय रिले पर एक कंप्यूटर के साथ क्या किया जा सकता है जिसमें कोई इनपुट डिवाइस नहीं है, और आउटपुट डिवाइस से - केवल आठ बहनों का एक डंप?

बेशक खेल खेलें! प्राचीन लोग एमके -61 / 52 कैलकुलेटर पर खेले, जो केवल कुछ अधिक स्पष्ट हैं।

अंदाज लगाओ

मैंने खेल के साथ शुरू किया, जहां आधे डिवीजन का उपयोग करने वाले कंप्यूटर को 0 से 100 तक खिलाड़ी द्वारा छिपे हुए पूर्णांक का पता लगाना चाहिए।

कंप्यूटर ए पंजीकृत करने के लिए अपना कूबड़ लिखता है, और फिर बंद हो जाता है।

सभी रजिस्टरों के मूल्यों को रिले में निर्मित एल ई डी के लिए धन्यवाद देखा जा सकता है:



अब खिलाड़ी को ROM में प्रोग्राम कोड को बदलना होगा, रजिस्टर में लोड किए गए निरंतर डी की जगह। यदि 0 नहीं है, तो इसका मतलब है कि यह धारणा आपके द्वारा अनुरोधित संख्या से अधिक है। अन्यथा, कम। उसके बाद, आपको "काम जारी रखें" बटन पर क्लिक करने की आवश्यकता है। केस D की जाँच के बाद, कंप्यूटर अगले प्रयास में ऊपरी या निचली सीमा के रूप में पिछली धारणा का उपयोग करता है।




पहले कार्यक्रम का नुकसान यह है कि इसका उपयोग करना असुविधाजनक है। यह रॉम की तस्वीर को देखकर समझा जा सकता है - गेम खेलते समय इस तरह के छोटे टॉगल स्विच को स्विच करना बहुत आसान नहीं है (लेकिन आपको यह भी सुनिश्चित करने की आवश्यकता है कि प्रोग्राम गलती से इसे खराब न करें)।

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

अब कंप्यूटर अग्रिम में रजिस्टर डी में इकाई में प्रवेश करता है, और खिलाड़ी या तो इसे त्याग देता है (यदि अनुमान अनुमानित संख्या से कम है) या इसे छोड़ देता है जैसा कि यह है (यदि अनुमान अधिक है)।

घटाव खेल (बाश खेल)

एक और क्लासिक गेम जो नौसिखिए प्रोग्रामर अक्सर लागू करते हैं वह है बकेट गेम।
इसमें, शुरू में एन आइटम लेने वाले ढेर से दो खिलाड़ी कम से कम एक और एम आइटम से अधिक नहीं लेते हैं। हारने वाला वह है जिसके पास लेने के लिए कुछ नहीं है।



मेरे संस्करण में, गेम कंप्यूटर के साथ आता है। प्रारंभ में, 21 वस्तुओं का एक गुच्छा (उदाहरण के लिए, 21 मैच)। खिलाड़ी अपनी बारी पर 1 से 3 मैच लेते हैं, और जो आखिरी मैच जीतता है वह जीत जाता है।

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

लोगों को मौका देने के लिए कंप्यूटर दूसरे स्थान पर जाता है, लेकिन यह गलती नहीं करता है। और अगर खिलाड़ी जीतने की रणनीति का पालन नहीं करता है, तो कंप्यूटर ऐसा करेगा।


पहले संस्करण में, "दृष्टिकोण संख्या" के लिए एक ही दृष्टिकोण का उपयोग किया गया था - अपनी बारी पर आपको निर्देशों में से एक के अंदर मैचों की संख्या को एनकोड करना था। आप एक ही बार में सभी मैचों को गिन और ले सकते हैं, और कंप्यूटर कुछ भी नोटिस नहीं करेगा।

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


बेशक, कार्यक्रम कुछ हद तक लंबा हो गया, लेकिन इसका उपयोग करना अधिक सुविधाजनक है।


इसके अलावा, मैं ROM को खत्म करने की योजना बना रहा हूं (अब संभावित 64 में से केवल 32 शब्द हैं), और टॉगल स्विच के मैट्रिक्स के रूप में एक इनपुट डिवाइस भी जोड़ते हैं। शायद तब आप कम से कम टिक-टैक-टो बना सकते हैं।