सरल बिल्ली कार्यक्रम

Question

सबसे आम मानक कार्यों में से एक (विशेषकर जब गूढ़ प्रोग्रामिंग भाषाओं को दिखाने के लिए) एक "बिल्ली कार्यक्रम" को लागू करना है : एसटीडीआईएन के सभी को पढ़ें और इसे एसटीडीयूएसटी पर प्रिंट करें। हालांकि इसका नाम यूनिक्स शैल उपयोगिता के नाम पर रखा गया है, catलेकिन यह वास्तविक चीज़ों की तुलना में बहुत कम शक्तिशाली है, जिसे आम तौर पर डिस्क से पढ़ी जाने वाली कई फ़ाइलों को प्रिंट (और संक्षिप्त) करने के लिए उपयोग किया जाता है।

कार्य

आपको एक पूर्ण कार्यक्रम लिखना चाहिए जो मानक इनपुट स्ट्रीम की सामग्री को पढ़ता है और उन्हें मानक आउटपुट स्ट्रीम में शब्दशः लिखता है। यदि आपकी भाषा केवल मानक इनपुट और / या आउटपुट स्ट्रीम (जैसा कि अधिकांश भाषाओं में समझा जाता है) का समर्थन नहीं करती है, तो आप इन शब्दों को अपनी भाषा में अपने निकटतम समकक्ष (उदाहरण के लिए जावास्क्रिप्ट ) promptऔर ले सकते हैं alert। ये I / O के केवल स्वीकार्य रूप हैं, क्योंकि कोई भी अन्य इंटरफ़ेस बड़े पैमाने पर कार्य की प्रकृति को बदल देगा और उत्तरों को काफी कम तुलनीय बना देगा।

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

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

जैसा कि प्रत्येक भाषा के भीतर एक चुनौती के रूप में किया जाता है और भाषाओं के बीच नहीं, कुछ भाषा विशिष्ट नियम हैं:

• यदि आपकी भाषा में ईओएफ से मानक इनपुट स्ट्रीम में नल बाइट्स को अलग करना संभव है, तो आपके प्रोग्राम को किसी भी अन्य बाइट्स की तरह अशक्त बाइट्स का समर्थन करना चाहिए (अर्थात, उन्हें मानक आउटपुट स्ट्रीम पर भी लिखा जाना चाहिए)।
• यदि यह अपनी भाषा एक का समर्थन करने के लिए सभी संभव पर है मनमाने ढंग से अनंत इनपुट धारा (यानी अगर आप इससे पहले कि आप इनपुट में EOF मारा मुद्रण उत्पादन के लिए बाइट्स शुरू कर सकते हैं), अपने कार्यक्रम इस मामले में सही ढंग से काम करने के लिए है। एक उदाहरण के रूप में एक yes | tr -d \\n | ./my_catअनंत धारा को मुद्रित करना चाहिए y। यह आप पर निर्भर करता है कि आप कितनी बार मानक आउटपुट स्ट्रीम को प्रिंट और फ्लश करते हैं, लेकिन यह निश्चित समय के बाद होने की गारंटी होनी चाहिए, चाहे स्ट्रीम की परवाह किए बिना (इसका मतलब है, विशेष रूप से, कि आप किसी विशिष्ट वर्ण की प्रतीक्षा नहीं कर सकते हैं) मुद्रण से पहले एक लाइनफीड)।

कृपया अपने उत्तर के बारे में उत्तर-बाइट्स, अनंत धाराओं और बाहरी आउटपुट के बारे में सटीक व्यवहार के लिए एक नोट जोड़ें।

अतिरिक्त नियम

• यह इसके लिए सबसे छोटे समाधान के साथ भाषा खोजने के बारे में नहीं है (कुछ ऐसे हैं जहां खाली कार्यक्रम चाल करता है) - यह हर भाषा में सबसे छोटा समाधान खोजने के बारे में है । इसलिए, कोई जवाब स्वीकार के रूप में चिह्नित नहीं किया जाएगा।

• अधिकांश भाषाओं में प्रस्तुतियाँ बाइट्स में एक उपयुक्त preexisting एन्कोडिंग में बनाई जाएंगी , आमतौर पर (लेकिन जरूरी नहीं) UTF-8।

  कुछ भाषाएं, जैसे फ़ोल्डर , स्कोर करने के लिए थोड़ा मुश्किल हैं। यदि संदेह हो तो कृपया मेटा पर पूछें ।

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

  ध्यान दें कि एक दुभाषिया होना चाहिए ताकि सबमिशन का परीक्षण किया जा सके। यह अनुमति दी जाती है (और यहां तक ​​कि प्रोत्साहित किया जाता है) कि इस दुभाषिया को पहले से बिना पढ़ी हुई भाषा के लिए स्वयं लिखें।

  यह भी ध्यान दें कि भाषाओं को प्रोग्रामिंग भाषाओं के लिए हमारे सामान्य मानदंडों को पूरा करना है ।

• यदि आपकी पसंद की भाषा किसी अन्य (संभावित रूप से अधिक लोकप्रिय) भाषा का एक तुच्छ संस्करण है, जिसमें पहले से ही एक उत्तर है (बेसिक या एसक्यूएल बोलियों, यूनिक्स के गोले या हेडस्कॉक या यूनरी की तरह तुच्छ ब्रेनफक डेरिवेटिव) पर विचार करें, मौजूदा उत्तर के लिए एक नोट जोड़ने पर विचार करें। समान या बहुत समान समाधान दूसरी भाषा में भी सबसे छोटा है।

• जब तक कि उन्हें पहले से अधिलेखित नहीं किया गया है, सभी मानक कोड-गोल्फ नियम लागू होते हैं, जिसमें http://meta.codegolf.stackexchange.com/q/1061 शामिल है ।

एक साइड नोट के रूप में, कृपया उन भाषाओं में उबाऊ (लेकिन मान्य) उत्तर न दें जहां गोल्फ के लिए बहुत कुछ नहीं है; ये अभी भी इस प्रश्न के लिए उपयोगी हैं क्योंकि यह एक कैटलॉग को यथासंभव पूरा करने का प्रयास करता है। हालांकि, मुख्य रूप से उन भाषाओं में जवाब देते हैं जहां लेखक को वास्तव में कोड को गोल करने में प्रयास करना था।

सूची

इस पोस्ट के निचले भाग में स्टैक स्निपेट उत्तर से सूची बनाता है) क) प्रति भाषा में सबसे छोटे समाधान की सूची के रूप में और बी) एक समग्र लीडरबोर्ड के रूप में।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

## Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

## Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो बाद में स्निपेट में दिखाई देगा:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table><script>var QUESTION_ID = 62230; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 8478; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "//api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "//api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(42), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>

Comments

बैश, 3 बाइट्स :cat

— TheDoctor

@ TheDctor मुझे लगता है कि यह "एक बिलिन का उपयोग न करें जो वास्तव में आवश्यक है" नियम का उपयोग करता है।

— पाओलो एबरमैन

@ Pa @loEbermann ऐसा कोई नियम नहीं है, और संबंधित मानक खामियों को अब स्वीकार नहीं किया गया है। (वास्तव में, पहले से ही एक shउत्तर है catजिसका उपयोग करके भी एक छोटा समाधान शामिल है dd।)

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

यदि केवल यह इनपुट और आउटपुट के मानक तरीकों का उपयोग करता है: ///, 0 बाइट्स ।

— कॉमरेड स्पार्कलपनी

@SparklePony को छोड़कर, आपको स्लैश और बैकस्लैश से बचना होगा।

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

Answer 1

पालकी, ०

खाली sedकार्यक्रम वही करता है जो यहां आवश्यक है:

$ printf "abc\ndef" | sed ''
abc
def$ 

Comments

अगर कोई लिखता है तो क्या होता है yes | tr -d \\n | sed ''?

— बेनगोल्डबर्ग

@BenGoldberg डिफ़ॉल्ट सेड प्रति-लाइन के आधार पर काम करता है, इसलिए इस स्थिति में यह yesएक पैटर्न बफ़र में स्लैपिंग जारी रखेगा, जब तक कि यह मेमोरी से बाहर न चला जाए। मुझे लगता है कि एक चेतावनी ...

— डिजिटल ट्रॉमा

POSIX यह बताता है कि पैटर्न स्पेस में कम से कम 8192 बाइट्स, IIRC का आकार होना चाहिए। मुझे पता है कि GNU कार्यान्वयन में एक गतिशील पैटर्न स्थान है, जो केवल उपलब्ध मेमोरी द्वारा सीमित है, इसलिए आप उस पर काफी सुरक्षित हैं।

— टोबे स्पाइट

Answer 2

ज़िम , 222 201 196 185 182 बाइट्स

    ↓ ↓

 ↓ ↓     ↓
 ↗ ↗↙↔↘↖ ↖
 ↓↓⤡⤢  ⤢↙
↘ ↖⤡ ↖
  ↙
  ↕↘ ↑ ↙
→↘↖↑ ↙ ↑
→↖   ↑
→↖↘ ↙
  ↑↓↑

   ⤡

यह संभवतः आपके ब्राउज़र में सही ढंग से प्रदर्शित नहीं होगा, इसलिए यहां कोड का एक चित्र है:

मैं ज़ीम में समस्या को हल करने के लिए एक सरल संरचना के बारे में नहीं सोच सकता , लेकिन मुझे यकीन है कि वास्तविक कोड अभी भी काफी गोल्फ है।

ज़ीम संभवतः अनंत धाराओं को संभाल नहीं सकता है क्योंकि कार्यक्रम के अंत में केवल कुछ भी प्रिंट करना संभव है।

व्याख्या

चूँकि ज़ीम में एक अद्वितीय, घोषित नियंत्रण प्रवाह मॉडल है, एक अनिवार्य छद्मकोश एल्गोरिथ्म इसे यहाँ नहीं काटेगा। इसके बजाय, मैं Ziim की मूल बातें और वर्तमान कोड की उपरोक्त संरचना (इसी तरह के चित्रमय तरीके से) के ASCII कला के रूप में समझाऊंगा।

ज़ीम में नियंत्रण प्रवाह सभी जगह होता है: प्रत्येक तीर जो दूसरे तीर द्वारा इंगित नहीं किया जाता है, एक "थ्रेड" को प्रारंभ करता है, जो दूसरों से स्वतंत्र रूप से संसाधित होता है (वास्तव में समानांतर में नहीं, लेकिन कोई गारंटी नहीं है कि वे किस क्रम में संसाधित होते हैं , जब तक आप उन्हें संघनन के माध्यम से सिंक नहीं करते हैं)। प्रत्येक ऐसा धागा बाइनरी अंकों की एक सूची रखता है, जैसा कि शुरू होता है {0}। अब कोड में प्रत्येक तीर कुछ प्रकार की कमांड है जिसमें एक या दो इनपुट हैं और एक या दो आउटपुट हैं। सटीक आदेश इस बात पर निर्भर करता है कि किस ओर से कितने तीर इंगित कर रहे हैं।

यहां कमांड की सूची है, जहां m -> nइंगित करता है कि कमांड mइनपुट लेता है और nआउटपुट उत्पन्न करता है ।

• 1 -> 1, नहीं- op : बस थ्रेड को रीडायरेक्ट करता है।
• 1 -> 1, उलटा : धागे में प्रत्येक बिट को नकारता है (और इसे पुनर्निर्देशित भी करता है)।
• 1 -> 1, पढ़ा : अगले द्वारा धागा के मूल्य की जगह बिट stdin से, या खाली सूची से अगर हम EOF तक पहुंचते हैं।
• 2 -> 1, संक्षिप्त : यह धागे को सिंक करने का एकमात्र तरीका है। जब एक धागा तीर के एक तरफ से टकराता है, तो इसे तब तक निलंबित रखा जाएगा जब तक कि दूसरा धागा दूसरे पक्ष से नहीं टकराता। उस बिंदु पर उन्हें एक ही धागे में समाहित किया जाएगा और निष्पादन जारी रहेगा।
• 2 -> 1, लेबल : यह विभिन्न निष्पादन पथों में शामिल होने का एकमात्र तरीका है। यह केवल एक नो-ऑप है जिसमें दो संभावित इनपुट हैं। तो किसी भी मार्ग के माध्यम से "लेबल" में प्रवेश करने वाले धागे को बस उसी दिशा में पुनर्निर्देशित किया जाएगा।
• 1 -> 2, विभाजन : एक एकल धागा लेता है, और अलग-अलग दिशाओं में दो प्रतियाँ भेजता है।
• 1 -> 1, ज़ीरो है? : थ्रेड के पहले बिट का उपभोग करता है, और थ्रेड को दो दिशाओं में से एक में भेजता है जो इस बात पर निर्भर करता है कि बिट 0 या 1 था।
• 1 -> 1, क्या खाली है? : पूरी सूची का उपभोग करता है (यानी इसे एक खाली सूची के साथ बदल देता है), और सूची को दो दिशाओं में से एक में भेजता है जो इस बात पर निर्भर करता है कि सूची पहले से ही खाली थी या नहीं।

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

वर्तमान सा जोड़कर के अलावा हम भी होगा पहले जोड़ें एक 0 या 1 का संकेत हम EOF पहुँच गए हैं या नहीं। यदि हम isZero के माध्यम से हमारे स्ट्रिंग भेजें ? , यह फिर से उस बिट से छुटकारा दिलाएगा, लेकिन हमें स्ट्रीम के अंत को अलग करने दें, जिस स्थिति में हम बस थ्रेड को ग्रिड के किनारे छोड़ देते हैं (जिसके कारण Zimim थ्रेड की सामग्री को STDOUT में प्रिंट कर सकता है और प्रोग्राम को समाप्त कर सकता है) ।

क्या हम EOF तक पहुँच गए हैं या नहीं, इसे isEmpty के उपयोग से निर्धारित किया जा सकता है ? इनपुट की एक प्रति पर

यहाँ वह आरेख है जिसका मैंने वादा किया था:

              +----------------------------+   {0} --> isEmpty --> label <--+
              |                            |                    n    |      |
              v                            |                         v      |
    {0} --> label --> read --> split --> split ------------------> concat   |
                                 |                                   |      |
                           n     v     y                             |      |
 inv --> label --> concat <-- isEmpty --> concat <-- label <-- {0}   |      |
  ^        ^          |                     |          ^             |      |
  |        |          v                     v          |             |      |
 {0}       +------- split ---> label <--- split -------+             |      |
                                 |                                   |      |
                                 +-------------> concat <------------+      |
                                                   |                        |
                                              y    v                        |
                         print and terminate <-- isZero --------------------+

पढ़ना शुरू करने के बारे में कुछ नोट्स:

• {0}ऊपरी बाएँ कोने में प्रारंभिक ट्रिगर जो इनपुट पाश शुरू होता है।
• {0}ऊपरी दाएं कोने की ओर तुरंत एक खाली सूची को मंजूरी दे दी एक प्रारंभिक स्ट्रिंग जो हम धीरे-धीरे इनपुट के साथ भर देंगे प्रतिनिधित्व करता है।
• अन्य दो {0}एस हमें एक "निर्माता" लूप (एक उल्टा, एक नहीं) में खिलाया जाता है, हमें 0एस और 1एस की असीमित आपूर्ति देने के लिए जिसे हमें स्ट्रिंग के लिए प्रस्तुत करने की आवश्यकता है।

Comments

तुम भी कैसे एक कार्यक्रम लिख सकते हैं कि आपके मस्तिष्क के बिना ऊतक के एक छोटे से छोटे हिस्से में विस्फोट हो सकता है।

— अश्विन गुप्ता

Answer 3

हेक्सागोनी , 6 बाइट्स

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

---

एक त्रुटि-मुक्त समाधान (यानी जो निश्चित दुभाषिया के साथ काम करता है) बहुत पेचीदा हो जाता है। मुझे 2x2 ग्रिड में इसे निचोड़ने में कुछ परेशानी हुई है, लेकिन मुझे अब इसका एक समाधान मिल गया है, हालाँकि मुझे पूरे 7 बाइट्स की आवश्यकता है :

<)@,;.(

सामने आने के बाद, हम प्राप्त करते हैं:

चूंकि प्रारंभिक मेमोरी एज 0 है, <बिना शर्त इंस्ट्रक्शन पॉइंटर को नॉर्थ-ईस्ट विकर्ण में बदल देता है, जहां यह ग्रे पथ पर जाता है। .नो-सेशन है। अब ,एक बाइट पढ़ता है, )इसे बढ़ाता है जैसे कि वैध बाइट्स (शून्य बाइट्स सहित) सकारात्मक हैं और ईओएफ 0 है।

इसलिए ईओएफ पर, आईपी लाल पथ पर लपेटता है, जहां @कार्यक्रम को समाप्त करता है। लेकिन अगर हम अभी भी एक बाइट पढ़ते हैं, तो आईपी हरे रंग के रास्ते पर लपेटता है, इसके बजाय जहां (मूल मूल्य में बढ़त को घटाता है , ;उससे पहले इसे STDOUT में प्रिंट करता है। आईपी ​​अब प्रक्रिया को दोहराते हुए बिना शर्त ग्रे ग्रे पथ पर वापस आ जाता है।

---

मेरे ट्रुथ मशीन के उत्तर के लिए एक ब्रूट फोर्स स्क्रिप्ट लिखने के बाद , मैंने इसे कैट-प्रोग्राम के लिए एक त्रुटि मुक्त 6-बाइट समाधान खोजने के लिए सेट किया । आश्चर्यजनक रूप से, यह सभी संभव 6-बाइट हेक्सागोनी कार्यक्रमों में एक - हां, बिल्कुल एक समाधान मिला। सत्य मशीन से 50 समाधानों के बाद, यह काफी आश्चर्यजनक था। यहाँ कोड है:

~/;,@~

खुलासा:

के ~बजाय (एकात्मक निषेध) का उपयोग ()दिलचस्प है, क्योंकि क) यह शून्य पर एक सेशन नहीं है, ख) यह शाखा के किनारों को स्वैप करता है, ग) कुछ कोडों में एक एकल ~को दो बार इस्तेमाल किया जा सकता है ताकि खुद के साथ ऑपरेशन को पूर्ववत किया जा सके। । तो यहाँ क्या हो रहा है:

पहली बार (बैंगनी पथ) हम इसके बीच से गुजरते हैं ~। /उत्तर-पश्चिम विकर्ण में आईपी को दर्शाता है। ग्रे पथ अब एक चरित्र को पढ़ता है और इसके चरित्र कोड को गुणा करता है -1। यह ईओएफ ( -1) को एक सत्य (सकारात्मक) मान और सभी वैध पात्रों को मिथ्या (गैर-सकारात्मक) मान में बदल देता है। ईओएफ के मामले में, आईपी लाल पथ लेता है और कोड समाप्त हो जाता है। एक वैध चरित्र के मामले में, आईपी ग्रीन पथ लेता है, जहां ~नकारात्मकता को ;मिटा देता है और चरित्र को प्रिंट करता है। दोहराएँ।

---

अंत में, यहां 3-बाइट संस्करण है जो मूल संस्करण हेक्सागोनी दुभाषिया में काम करता था।

,;&

भूलभुलैया उत्तर की तरह, यह एक त्रुटि के साथ समाप्त होता है यदि इनपुट स्ट्रीम परिमित है।

कोड को सामने लाने के बाद, यह निम्नलिखित हेक्स ग्रिड से मेल खाता है:

.कोई-ऑप्स कर रहे हैं। बैंगनी मार्ग पर निष्पादन शुरू होता है।

,एक बाइट पढ़ता है, एक बाइट ;लिखता है। फिर सामन (इश) पथ पर निष्पादन जारी है। हमें &वर्तमान मेमोरी एज को शून्य पर रीसेट करने की आवश्यकता है, जैसे कि दूसरी पंक्ति के अंत में कोने को मारते समय आईपी बैंगनी पंक्ति में वापस कूदता है। एक बार ,ईओएफ को हिट करने के बाद यह वापस आ जाएगा -1, जो ;इसे प्रिंट करने का प्रयास करते समय एक त्रुटि का कारण बनता है।

---

चित्र के साथ उत्पन्न Timwi की अद्भुत HexagonyColorer ।

Comments

6-बाइट संस्करण बहुत, बहुत चालाक है। जानवर के कैंसर अविश्वसनीय रूप से भयानक हो सकते हैं।

— ETHproductions

क्या आपके पास अपने ब्रूट-फोरसर का लिंक है?

— एमडी एक्सएफ

@MDXF मैं विभिन्न संस्करणों को अपने आस-पास नहीं रखता, लेकिन यह हमेशा इस रूबी लिपि का कुछ संशोधन है ।

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

Answer 4

TeaScript , 0 बाइट्स

TeaScript जावास्क्रिप्ट के लिए संकलित एक संक्षिप्त गोल्फिंग भाषा है

हाल के अद्यतन में इनपुट को पहली संपत्ति के रूप में जोड़ा गया है।

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

---

वैकल्पिक रूप से, 1 बाइट

x

xTeaScript में इनपुट समाहित है। आउटपुट निहित है

Comments

मैं यह पोस्ट करने वाला था :)

— क्रिस्ति लिथोस

हाह, मैंने सोचा कि "वैकल्पिक रूप से" एक भाषा का नाम था ...

— क्लेक्लेफ़

Answer 5

ब्रायन और चक , 44 बाइट्स

#{<{,+?+}_+{-?>}<?
_}>?>+<<<{>?_}>>.<+<+{<{?

मैंने मूल रूप से एक प्रोग्रामिंग भाषा बनाने के लिए यह भाषा बनाई थी जो केवल अनुपयोगी प्रतीत होती है । यह हालांकि इसमें साधारण समस्याओं को गोल्फ के लिए एक बहुत अच्छा व्यायाम हो जाता है।

मूल बातें: प्रत्येक दो पंक्तियों में एक ब्रेनफैक जैसा कार्यक्रम निर्धारित होता है जो दूसरे कार्यक्रम के स्रोत कोड पर संचालित होता है - पहले कार्यक्रम को ब्रायन और दूसरे को चक कहा जाता है। केवल ब्रायन ही पढ़ सकते हैं और केवल चक ही लिख सकते हैं। ब्रेनफॉक के छोरों के बजाय आपके पास ?अन्य प्रोग्राम (और इंस्ट्रक्शन पॉइंटर की भूमिकाएं और साथ ही टेप हेड चेंज) का नियंत्रण है। ब्रेनफक के अलावा एक {और }जो पहले गैर-शून्य सेल (या बाएं छोर) के लिए टेप को स्कैन करता है। इसके अलावा, _नल बाइट्स के साथ बदल दिए जाते हैं।

हालांकि मुझे नहीं लगता कि यह अभी तक इष्टतम है, मैं इस समाधान से काफी खुश हूं। मेरा पहला प्रयास 84 बाइट्स का था, और Sp3000 (और उनके प्रयासों से कुछ प्रेरणा लेने) के साथ कई गोल्फ सत्रों के बाद, मैं इसे धीरे-धीरे 44 तक ले जाने में कामयाब रहा, एक समय में कुछ बाइट्स। विशेष रूप से शानदार +}+चाल उनका विचार था (नीचे देखें)।

व्याख्या

इनपुट को चक के टेप पर पहली सेल में पढ़ा जाता है, फिर ब्रॉन्स्ट टेप के अंत में कॉपी किया जाता है, जहां यह मुद्रित होता है। इसे अंत तक कॉपी करके, हम पिछले चरित्र को शून्य पर सेट करने के लिए बाइट्स बचा सकते हैं।

#सिर्फ एक प्लेसहोल्डर क्योंकि नियंत्रण सेल निष्पादित नहीं करता है स्विचन हम चालू है। {<{यह सुनिश्चित करता है कि टेप हेड चक की पहली सेल पर है। ,एसटीडीआईएन से एक बाइट पढ़ता है या -1अगर हम ईओएफ को मारते हैं। इसलिए हमें लगता है कि +इसे EOF के लिए शून्य और गैर-शून्य को अन्यथा बनाया जाए।

चलो मान लेते हैं कि हम अभी EOF में नहीं हैं। तो सेल पॉजिटिव है और ?चक को कंट्रोल स्विच करेगा। }>टेप हेड (ब्रायन पर) को चलता +है _और ?ब्रायन को वापस कंट्रोल करता है।

{-अब चक पर पहली सेल को घटाता है। यदि यह अभी तक शून्य नहीं है, तो हम फिर से चक को नियंत्रित करते हैं ?। इस बार }>पिछले गैर-शून्य सेल के दाईं ओर ब्रायन दो कोशिकाओं पर टेप सिर ले जाता है। शुरू में यहाँ है:

#{<{,+?+}_+{-?>}<?__
                   ^

लेकिन बाद में, हम पहले से ही वहाँ कुछ पात्र रख लेंगे। उदाहरण के लिए, यदि हम पहले ही पढ़ चुके हैं और मुद्रित कर चुके हैं abc, तो यह इस तरह दिखेगा:

#{<{,+?+}_+{-?>}<?11a11b11c__
                            ^

जहां 1वास्तव में 1-बाइट्स होते हैं (हम देखेंगे कि बाद में क्या होता है)।

यह सेल हमेशा शून्य रहेगा, इसलिए यह समय नियंत्रण ? नहीं बदलेगा। >एक और सेल को दाईं ओर ले जाता है और +उस सेल को बढ़ाता है। यही कारण है कि इनपुट में पहला वर्ण दाईं ओर तीन कोशिकाओं को समाप्त करता है ?(और प्रत्येक बाद की तीन कोशिकाओं को आगे दाएं)।

<<<उस सूची में अंतिम वर्ण पर वापस जाता है (या ?यदि यह पहला वर्ण है), और लूप को दोहराने के लिए ब्रायन के टेप पर {>वापस जाता है +, जो धीरे-धीरे ब्रायन के टेप के अंत में इनपुट सेल को स्थानांतरित करता है।

एक बार उस इनपुट सेल के खाली हो जाने के ?बाद {-नियंत्रण स्विच नहीं किया जाएगा। फिर >}<चक पर टेप हेड को घुमाता है _और नियंत्रण को ऐसे स्विच करता है कि चक का दूसरा भाग इसके बजाय निष्पादित होता है।

}>>सेल में अब हम ब्रायन के टेप के अंत में लिखे हैं, जो कि हमने STDIN से पढ़ा है, जो बाइट है, इसलिए हम इसे वापस प्रिंट करते हैं .। }टेप पर इस नए चरित्र को चलाने के लिए हमें दो नल बाइट्स के अंतराल को बंद करने की आवश्यकता है, इसलिए हम उन्हें इसके 1साथ बढ़ाते हैं <+<+(इसलिए अंतिम टेप पर वास्तविक पात्रों के बीच 1-बाइट्स हैं)। अंत {<{में ब्रायन के टेप की शुरुआत में वापस जाता है और शुरुआत से ?सब कुछ शुरू करता है।

आप आश्चर्यचकित हो सकते हैं कि अगर हम जो चरित्र पढ़ते हैं वह एक अशक्त है। उस स्थिति में नव लिखित सेल ही शून्य होगी, लेकिन चूंकि यह ब्रायन के टेप के अंत में है और हमें परवाह नहीं है कि वह अंत कहां है, हम बस इसे अनदेखा कर सकते हैं। इसका मतलब है कि अगर इनपुट होता ab\0de, तो ब्रायन का टेप वास्तव में ऐसा दिखता:

#{<{,+?+}_+{-?>}<?11a11b1111d11e

अंत में, एक बार जब हमने ईओएफ को मारा कि पहले ?ब्रायन के टेप पर कोई ऑप नहीं होगा। इस बिंदु पर हम कार्यक्रम को समाप्त करते हैं। भोले समाधान चक के टेप के अंत में जाने और नियंत्रण को नियंत्रित करने के लिए होगा, जैसे कि कार्यक्रम का समापन >}>}<?:। यह वह जगह है जहाँ Sp3000 का वास्तव में चतुर विचार तीन बाइट्स बचाता है:

+चक की पहली सेल में बदल जाता है 1। इसका मतलब }है कि एक प्रारंभिक बिंदु है और _चक के टेप के बीच में पाता है । इसके अतीत को छोड़ देने के बजाय, हम बस इसे एक 1साथ में बदलकर अंतर को बंद कर देते हैं +। अब देखते हैं कि इस संशोधित चक के साथ ब्रायन के बाकी कोड क्या होते हैं ...

{हमेशा की तरह चक की पहली सेल में -वापस जाता है , और इसे वापस एक अशक्त में बदल देता है। इसका मतलब है कि ?यह एक सेशन नहीं है। लेकिन अब >}<, जो आमतौर पर टेप के सिर को चक के टेप के बीच में ले जाता था, वह ठीक अतीत को चक के टेप के अंत में ले जाता है और ?फिर कोड को समाप्त करते हुए चक पर नियंत्रण पारित करता है। यह अच्छा है जब चीजें बस काम करती हैं ... :)

Answer 6

हास्केल, 16 बाइट्स

main=interact id

interactइनपुट को पढ़ता है, इसे अपने तर्क के रूप में दिए गए फ़ंक्शन में भेजता है और प्राप्त होने वाले परिणाम को प्रिंट करता है। idपहचान समारोह है, अर्थात यह अपने इनपुट को अपरिवर्तित लौटाता है। हास्केल के आलस्य के लिए धन्यवाद interactअनंत इनपुट के साथ काम कर सकता है।

Answer 7

श + बिनुटिल्स, 3 2 बाइट्स

dd

खैर, बिल्कुल स्पष्ट नहीं है। @ रैंडम 832 से

मूल:

cat

दर्द स्पष्ट रूप से ...: डी

Comments

मैं एक बेहतर करूँगा dd:।

— 188 बजे रैंडम 832

मैं बिल्ली करने जा रहा था ... D:

— ev3commander

हाँ, यह बहुत अच्छा है और सभी ... लेकिन टाइपिंग के लिए 170 प्रतिनिधि cat???

— एमडी एक्सएफ

@MDXF के बारे में क्या पता है जो एक segfault से कितना प्रतिनिधि है? ;)

— caird coinheringaahing

Answer 8

फंकिटॉन , 16 बाइट्स

╔═╗
╚╤╝

(बीओएम के साथ UTF-16 के रूप में एन्कोडेड)

व्याख्या

बॉक्स STDIN की सामग्री लौटाता है। ढीला अंत यह आउटपुट देता है।

Answer 9

मोटोरोला MC14500B मशीन कोड , 1.5 बाइट्स

हेक्साडेसिमल में लिखा है:

18F

बाइनरी में लिखा:

0001 1000 1111

---

व्याख्या

1   Read from I/O pin
8   Output to I/O pin
F   Loop back to start

Opcodes 4 बिट्स हैं।

Comments

-1 नहीं स्क्रीनशॉट, उदाहरण या कोशिश ऑनलाइन लिंक: पी (जेके)

— एमडी एक्सएफ

+1। जिस तरह से मैं आगे इसे अनुकूलित करने के बारे में सोच सकता हूं वह सिर्फ आउटपुट पिन के इनपुट पिन को

— मिलाएगा

Answer 10

मॉर्निंगटन क्रिसेंट , 41 बाइट्स

Take Northern Line to Mornington Crescent

मुझे पता नहीं है कि मॉर्निंगटन क्रिसेंट नल बाइट्स को संभाल सकता है, और कार्यक्रम शुरू होने से पहले सभी इनपुट को पढ़ा जाता है, क्योंकि यह भाषा की प्रकृति है।

Answer 11

ब्रेनफक, 5 बाइट्स

,[.,]

छद्मकोश के समतुल्य:

x = getchar()
while x != EOF:
    putchar(x)
    x = getchar()

यह अनंत धाराओं को संभालता है, लेकिन अशक्त बाइट्स को ईओएफ के रूप में मानता है। बीएफ नल बाइट्स को सही ढंग से संभाल सकता है या नहीं , कार्यान्वयन से कार्यान्वयन तक भिन्न होता है, लेकिन यह सबसे आम दृष्टिकोण मानता है।

Comments

रफ़ू! तुम मुझे 5 मिनट से हरा दो!

— kirbyfan64sos

यदि पहला वर्ण NULL है तो यह सही ढंग से नहीं चलेगा। तो यह +[,.]सही होना चाहिए ?

— शेल्वैकु

@ Shel यह EOF बाइट के रूप में 0x00 का उपयोग कर रहा है। यदि पहला वर्ण ईओएफ है, तो यह कुछ भी प्रिंट नहीं करता है, जैसा कि अपेक्षित है।

— मेगो

"स्यूडोकोड" ओह, यह स्पष्ट रूप से अन-ब्रैकेटेड, अन-सेमीकोलन-एड सी: पी

— एमडी एक्सएफ

Answer 12

भूलभुलैया , 2 बाइट्स

,.

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

जैसा कि ब्रेनफक ,एक बाइट पढ़ता है (इसे भूलभुलैया के मुख्य स्टैक पर धकेलता है) और .एक बाइट लिखता है (इसे लैबरिंथ के मुख्य स्टैक से पॉपिंग करता है)।

कारण यह लूप है कि दोनों ,और .(बहुत तुच्छ) भूलभुलैया स्रोत कोड के प्रतिनिधित्व में "मृत समाप्त होता है" कर रहे हैं, ऐसा है कि अनुदेश सूचक बस के चारों ओर की मौके पर ही बदल जाता है और अन्य आदेश को वापस ले जाता है।

जब हम ईओएफ ,को हिट करते हैं तो -1इसके बजाय धक्का देते हैं और .एक त्रुटि को फेंक देते हैं क्योंकि -1एक वैध वर्ण कोड नहीं है। यह वास्तव में भविष्य में बदल सकता है, लेकिन मैंने अभी तक इस पर फैसला नहीं किया है।

---

संदर्भ के लिए, हम इसे 6 बाइट्स में त्रुटि के बिना हल कर सकते हैं

,)@
.(

यहां, )हम जिस बाइट को पढ़ते हैं , उसे बढ़ाते हैं, जो 0ईओएफ पर देता है और कुछ सकारात्मक होता है। यदि मान है 0, तो IP सीधे चलता है , जिस पर हिट करने @से प्रोग्राम समाप्त हो जाता है। यदि मान सकारात्मक था, तो IP इसके बजाय एक दायाँ मोड़ लेगा, (जो स्टैक के शीर्ष को वापस उसके मूल मान में घटाता है। आईपी ​​अब एक कोने में है और बस एक बार फिर से कांटे से टकराने से पहले, .एक नया बाइट पढ़ने के साथ , सही मोड़ बनाता रहेगा ।.)

Answer 13

सी, 40 बाइट्स

main(i){while(i=~getchar())putchar(~i);}

Comments

main () {जबकि (255-putchar (getchar)));} बाइट्स का एक जोड़ा छोटा है।

— Alchymist

अफसोस की बात है, कि समय से पहले 0xFF बाइट्स पर बाहर निकलता है और यदि इसमें इसे शामिल नहीं करता है, तो इनपुट को 0xFF बाइट देता है।

— डेनिस

निम्नलिखित के बारे में क्या, 36 बाइट्स: मुख्य () {के लिए; (; पुटकर (गेटचार ()));};

— जोहान डू टिट

@ user2943932 जब यह EOF से टकराता है , तो -1getchar लौटता है , इसलिए आपका कोड (परिमित) इनपुट के बाद 0xFF बाइट्स की अनंत धारा को प्रिंट करेगा।

— डेनिस

Answer 14

> <> , 7 बाइट्स

i:0(?;o

इसे यहाँ आज़माएँ । स्पष्टीकरण:

i:0(?;o
i        Take a character from input, pushing -1 if the input is empty
 :0(     Check if the input is less than 0, pushing 1 if true, 0 if false
    ?;   Pop a value of the top of the stack, ending the program if the value is non-zero
      o  Otherwise, output then loop around to the left and repeat

आप इसे जारी रखने के लिए जब तक आप इसे अधिक इनपुट देना चाहते हैं, की जगह ;के साथ !।

Comments

Aww आदमी, मैं पोस्ट करने की उम्मीद कर रहा था> <> जवाब ...: P (+1!)

— El'endia स्टैट्रान

io(2 बाइट्स) वही करता है, लेकिन क्रैश और something smells fishy...निष्पादन के अंत में STDERR को लिखता है, जिसकी अनुमति है।

— लिन

@Mauris ऑनलाइन दुभाषिया सिर्फ एक त्रुटि के साथ समाप्त होने के बजाय अशक्त बाइट्स का उत्पादन करता है।

— DanTheMan

Answer 15

X86 असेंबली, 70 बाइट्स

साथ डिस्सैडविज़न objdump:

00000000 <.data>:
   0:   66 83 ec 01             sub    sp,0x1
   4:   66 b8 03 00             mov    ax,0x3
   8:   00 00                   add    BYTE PTR [eax],al
   a:   66 31 db                xor    bx,bx
   d:   66 67 8d 4c 24          lea    cx,[si+0x24]
  12:   ff 66 ba                jmp    DWORD PTR [esi-0x46]
  15:   01 00                   add    DWORD PTR [eax],eax
  17:   00 00                   add    BYTE PTR [eax],al
  19:   cd 80                   int    0x80
  1b:   66 48                   dec    ax
  1d:   78 1c                   js     0x3b
  1f:   66 b8 04 00             mov    ax,0x4
  23:   00 00                   add    BYTE PTR [eax],al
  25:   66 bb 01 00             mov    bx,0x1
  29:   00 00                   add    BYTE PTR [eax],al
  2b:   66 67 8d 4c 24          lea    cx,[si+0x24]
  30:   ff 66 ba                jmp    DWORD PTR [esi-0x46]
  33:   01 00                   add    DWORD PTR [eax],eax
  35:   00 00                   add    BYTE PTR [eax],al
  37:   cd 80                   int    0x80
  39:   eb c9                   jmp    0x4
  3b:   66 b8 01 00             mov    ax,0x1
  3f:   00 00                   add    BYTE PTR [eax],al
  41:   66 31 db                xor    bx,bx
  44:   cd 80                   int    0x80

स्रोत:

sub esp, 1
t:
mov eax,3
xor ebx,ebx
lea ecx,[esp-1]
mov edx,1
int 0x80
dec eax
js e
mov eax,4
mov ebx,1
lea ecx,[esp-1]
mov edx,1
int 0x80
jmp t
e:
mov eax,1
xor ebx,ebx
int 0x80

Comments

इसलिए, objdumpइसे 32-बिट कोड के रूप में डिसाइड किया, जबकि आप 16-बिट के रूप में संकलित किए गए लगते हैं। क्या विश्वास करना है? जब से आप उपयोग करते हैं int 0x80, मुझे लगता है कि यह लिनक्स के लिए है, लेकिन फिर 16-बिट के रूप में क्यों संकलित किया गया है?

— रुस्लान

मैं पता ही यह 16 बिट में संकलित किया गया नहीं था @Ruslan ...

— kirbyfan64sos

Answer 16

यूनिवर्सल लाम्बा , 1 बाइट

!

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

बिट्स का अनुवाद लंबोदर शब्द में किया गया है:

• 00 एक लैम्ब्डा अमूर्तता का परिचय देता है।
• 01 दो बाद की शर्तों के एक आवेदन का प्रतिनिधित्व करता है।
• 111..10, बिट की एन पुनरावृत्ति के साथ 1, एन वें माता-पिता के लंबो के चर को संदर्भित करता है ; यानी यह यूनरी में एक डी ब्रूजन इंडेक्स है।

इस रूपांतरण द्वारा, 0010पहचान कार्य है λa.a, जिसका अर्थ है कि प्रपत्र 0010xxxxका कोई भी बाइट प्रोग्राम एक catकार्यक्रम है।

Comments

लेकिन !है 0x21, नहीं 0x4_?

— वैचेगिन

फिक्स्ड। --------

— लिन

Answer 17

पॉवरशेल, 88 41 30 बाइट्स

$input;write-host(read-host)-n

_{EDIT - भूल गए कि मैं $inputपाइपलाइन इनपुट के लिए स्वचालित चर का उपयोग कर सकता हूं} ... _{EDIT2 - के अस्तित्व के लिए परीक्षण करने की आवश्यकता नहीं है$input}

हाँ, इसलिए ... PowerShell में STDIN ... अजीब है, हम कहेंगे। इस धारणा के साथ कि हमें सभी प्रकार के एसटीडीआईएन से इनपुट स्वीकार करने की आवश्यकता है , यह इस कैटलॉग का एक संभावित उत्तर है, और मुझे यकीन है कि अन्य हैं। ¹

PowerShell में पाइपलाइन इनपुट वैसे काम नहीं करेगा जैसा आप सोचते हैं, हालांकि। चूंकि PowerShell में पाइपिंग भाषा का एक फ़ंक्शन है, और पर्यावरण / शेल का फ़ंक्शन नहीं है (और PowerShell वास्तव में वैसे भी केवल एक भाषा नहीं है), व्यवहार के लिए कुछ विचित्रताएं हैं।

शुरुआत के लिए, और इस प्रविष्टि के लिए सबसे प्रासंगिक, पाइप का मूल्यांकन तुरंत नहीं किया जाता है (अधिकांश समय)। मतलब, अगर हम command1 | command2 | command3अपने खोल में हैं , तो command2इनपुट नहीं लेंगे या command1पूरा होने तक प्रसंस्करण शुरू नहीं करेंगे ... जब तक कि आप अपने command1साथ एक ForEach-Object... को अलग नहीं करते हैं, जो अलग है नहीं करते ForEach। _{(भले ही इसके ForEachलिए एक अन्य नाम है ForEach-Object, लेकिन यह एक अलग मुद्दा है, क्योंकि मैं ForEachबयान के रूप में बात कर रहा हूं , उर्फ ​​नहीं)}

इसका मतलब होगा कि कुछ ऐसा yes | .\simple-cat-program.ps1 (भले ही yesवास्तव में मौजूद नहीं है, लेकिन जो भी) काम नहीं yesकरेगा क्योंकि कभी पूरा नहीं होगा। अगर हम ऐसा कर सकते हैं ForEach-Object -InputObject(yes) | .\simple-cat-program.ps1(सिद्धांत में) काम करना चाहिए।

Microsoft पर ForEach और ForEach-Object को जानना , "अरे, स्क्रिप्टिंग गाइ!" ब्लॉग।

इसलिए, वे सभी अनुच्छेद बता रहे हैं कि क्यों if($input){$input}मौजूद है। हम एक इनपुट पैरामीटर लेते हैं जो विशेष रूप से स्वचालित रूप से बनाया जाता है यदि पाइपलाइन इनपुट मौजूद है, तो यह मौजूद है या नहीं, यह परीक्षण करें, इसे आउटपुट करें।

फिर, हम उपयोगकर्ता (read-host)से इनपुट लेते हैं जो अनिवार्य रूप से एक अलग STDIN स्ट्रीम है, और write-hostयह वापस, के साथ है-n फ्लैग (शॉर्ट फॉर -NoNewLine) के । ध्यान दें कि यह मनमाने ढंग से लंबाई इनपुट का समर्थन नहीं करता है, जैसा read-hostकि केवल तभी पूरा होगा जब एक लाइनफीड दर्ज किया जाता है (तकनीकी रूप से जब उपयोगकर्ता "एन्टर" दबाता है, लेकिन कार्यात्मक रूप से समकक्ष)।

ओह।

¹ लेकिन अन्य विकल्प भी हैं:

उदाहरण के लिए, यदि हम केवल पाइपलाइन इनपुट से संबंधित थे , और हमें पूर्ण कार्यक्रम की आवश्यकता नहीं थी, तो आप कुछ ऐसा कर सकते थे| $_ जो कि इनपुट के अनुसार बस आउटपुट देगा।_{(सामान्य तौर पर, यह कुछ हद तक बेमानी है, क्योंकि पावरशेल में गणना के बाद "पीछे छोड़ दी गई" चीजों का एक अंतर्निहित उत्पादन होता है, लेकिन यह एक तरफ है।)}

यदि हम केवल इंटरएक्टिव उपयोगकर्ता इनपुट से चिंतित हैं, तो हम बस उपयोग कर सकते हैं write-host(read-host)-n ।

इसके अतिरिक्त, इस फ़ंक्शन में कमांड-लाइन इनपुट को स्वीकार करने की क्विक सुविधा है, उदाहरण के .\simple-cat-program.ps1 "test"लिए $aचर को पॉप्युलेट (और फिर आउटपुट) ।

Comments

अपने बनाया उपनाम में मत भूलना!

— चाड बैक्सटर

Answer 18

क्यूबिक्स , 6 5 बाइट्स

अब नल बाइट्स संभालता है!

@_i?o

क्यूबिक्स एक 2-आयामी, स्टैक-आधारित एसोलैंग है। क्यूबिक्स अन्य 2D लैंग्स से अलग है जिसमें स्रोत कोड एक क्यूब के बाहर चारों ओर लपेटा जाता है।

इसे ऑनलाइन टेस्ट करें!नोट: पुनरावृत्तियों के बीच 50 एमएस विलंब है।

व्याख्या

पहली बात यह है कि दुभाषिया करता है सबसे छोटा क्यूब है जो कोड पर फिट होगा। इस स्थिति में, किनारे की लंबाई 1. है और फिर कोड को बिना ऑप्स के साथ गद्देदार किया जाता है .जब तक कि सभी छह पक्ष भरे नहीं जाते। प्रसंस्करण से पहले व्हॉट्सएप हटा दिया जाता है, इसलिए यह कोड उपरोक्त के समान है:

  @
_ i ? o
  .

अब कोड चलाया जाता है। आईपी ​​(इंस्ट्रक्शन पॉइंटर) पूर्व की ओर इशारा करते हुए दूर बाएं चेहरे पर शुरू होता है।

पहला सामना आईपी का सामना करना पड़ता है _, जो एक दर्पण है जो आईपी को चारों ओर घुमा देता है अगर वह उत्तर या दक्षिण की ओर है; यह वर्तमान में पूर्व की ओर है, इसलिए यह कुछ नहीं करता है। अगला है i, जो STDIN से एक बाइट इनपुट करता है। ?यदि शीर्ष आइटम नकारात्मक है, या सही है तो आईपी को छोड़ दिया जाता है, यदि यह सकारात्मक है। यहां तीन संभावित रास्ते हैं:

• यदि इनपुट बाइट -1 (EOF) है, तो IP बाईं और मुड़ जाता है @ , जो प्रोग्राम को समाप्त कर देती है।
• यदि इनपुट बाइट 0 (शून्य बाइट) है, तो आईपी सीधे बाइट को आउटपुट के साथ जारी रखता है o।
• अन्यथा, आईपी सही हो जाता है, नीचे के चेहरे पर यात्रा करता है और दर्पण को हिट करता है _। यह इसे चारों ओर घुमाता है, इसे वापस भेजता है ?, जो इसे फिर से सही करता है और बाइट को आउटपुट करता है।

मुझे लगता है कि यह कार्यक्रम इष्टतम है। इससे पहले कि क्यूबिक्स नल बाइट्स को संभाल सके (ईओएफ 0 था, -1 नहीं), इस कार्यक्रम ने सब कुछ के लिए काम किया लेकिन अशक्त बाइट्स:

.i!@o

---

मैंने सभी 5-बाइट बिल्ली कार्यक्रमों को खोजने के लिए एक ब्रूट-फोरसर लिखा है । हालांकि इसे खत्म होने में ~ 5 मिनट लगते हैं, नवीनतम संस्करण में 5 कार्यक्रम मिले हैं:

@_i?o   (works as expected)
@i?o_   (works in exactly the same way as the above)
iW?@o   (works as expected)
?i^o@   (false positive; prints U+FFFF forever on empty input)
?iWo@   (works as expected)

Comments

कृपया एक बार में एक दर्जन पोस्ट संपादित न करें। आप सामने वाले पृष्ठ को भर रहे हैं। 3 एक समय में एक मुद्दा नहीं है, लेकिन अगर आपको इससे अधिक करना है तो कृपया हर 12 घंटे में छोटे बैचों में अपने संपादन करें।

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

@MartinEnder क्षमा करें, मैंने अभी देखा है। मैं भविष्य में उन्हें बाहर कर दूँगा।

— ETHproductions

Answer 19

विटेसी, 2 बाइट्स

zZ

z सभी इनपुट स्टैक हो जाता है और इसे सक्रिय प्रोग्राम स्टैक में धकेल देता है। ZSTDOUT में सक्रिय स्टैक के सभी प्रिंट करता है।

वैकल्पिक विधि:

मैं \ इल \ हे
इनपुट स्टैक की लंबाई के लिए मैं अगला वर्ण दोहराता हूं।
  मैं इनपुट से एक आइटम ले लो।
   l \ _ वर्तमान सक्रिय प्रोग्राम स्टैक की लंबाई के लिए अगला वर्ण दोहराएं।
     हे स्टैक के शीर्ष आइटम को एक चरित्र के रूप में आउटपुट करें।

Comments

^ _ ^ वैसे भी +1 है! :)

— एल'एंडिया स्ट्रैटन

दया मत, मेरे पसंदीदा!

— एडिसन क्रम्प

क्यों घटता है? यह पूरी तरह से मान्य प्रविष्टि है

— कॉनर ओ'ब्रायन

यह है सब चश्मा द्वारा मान्य।

— एडिसन क्रम्प

Answer 20

मारियोलेन , 11 बाइट्स

,<
."
>!
=#

मुझे पूरी तरह से यकीन नहीं है कि यह इष्टतम है, लेकिन यह सबसे छोटा है जो मैंने पाया है।

यह अनंत धाराओं का समर्थन करता है और EOF (कम से कम रूबी संदर्भ कार्यान्वयन करता है) तक पहुंचने पर एक त्रुटि के साथ समाप्त होगा।

इसका एक और संस्करण है जो मारियो को निंजा में बदल देता है जो दोहरी कूद कर सकता है:

,<
.^
>^
==

या तो मामले में, मारियो बाएं कॉलम को गिराना शुरू कर देता है, जहां ,एक बाइट पढ़ता है और .एक बाइट लिखता है (जो ईओएफ में एक त्रुटि फेंकता है क्योंकि ,एक वैध चरित्र वापस नहीं करता है)। >यह सुनिश्चित करता है कि मारियो दाईं ओर चलता है ( =उसके चलने के लिए सिर्फ एक मैदान है)। फिर वह ऊपर जाता है, या तो ^लिफ्ट के साथ या ( "और #जोड़ी) के माध्यम से एक डबल छलांग के माध्यम से <उसे बाएं स्तंभ पर वापस जाने के लिए कहता है।

Answer 21

आरएस , 0 बाइट्स

गंभीरता से। rs सिर्फ प्रिंट करता है जो भी मिलता है अगर दी गई स्क्रिप्ट पूरी तरह से खाली है।

Answer 22

GolfScript, 3 बाइट्स

:n;

खाली प्रोग्राम मानक इनपुट को गूँजता है। भाषा संभवतः अनंत धाराओं को संभाल नहीं सकती है। हालाँकि, यह @Dennis के अनुसार, एक नई पंक्ति को जोड़ता है। यह एक सरणी और कॉलिंग में पूरे स्टैक को लपेटकर ऐसा करता है puts, जिसे इस रूप में परिभाषित किया गया है print n print, जहां nएक नई रेखा है । हालांकि, हम nस्टैडिन को फिर से परिभाषित कर सकते हैं , और फिर स्टैक को खाली कर सकते हैं, जो ठीक :n;है।

Answer 23

हैवी ट्रैफिक में हाफ-ब्रोकन कार , 9 + 3 = 12 बाइट्स

#<
o^<
 v

हैवी ट्रैफिक (HBCHT) में हाफ-ब्रोकन कार कमांड लाइन आर्ग्स के रूप में इनपुट लेती है, इसलिए जैसे चलती है

py -3 hbcht cat.hbc -s "candy corn"

ध्यान दें कि +3 -sध्वज के लिए है, जो कि चार्ट के रूप में आउटपुट करता है। इसके अलावा, HBCHT हैंडल NULs नहीं लगता है, क्योंकि सभी शून्य आउटपुट से हटा दिए गए हैं (जैसे 97 0 98कि दो वर्णों के रूप में आउटपुट हैab )।

व्याख्या

HBCHT में, आपकी कार शुरू होती है oऔर आपका लक्ष्य निकास है #। ^>v<एक साथ बीएफ जैसे टेप को संशोधित करते हुए कार की गति को निर्देशित करें ( ^>v<अनुवाद करें+>-< ) । हालाँकि, जैसा कि भाषा के नाम से पता चलता है, आपकी कार केवल दाएं मुड़ सकती है - बाएं मुड़ने के किसी भी प्रयास को पूरी तरह से अनदेखा किया जाता है (उनके स्मृति प्रभाव सहित)। ध्यान दें कि यह केवल मोड़ के लिए है - आपकी कार आगे / पीछे की दिशा में ड्राइविंग करने में पूरी तरह से सक्षम है।

HBCHT के बारे में अन्य दिलचस्प अंश यह है कि आपकी कार की प्रारंभिक दिशा यादृच्छिक है, और ग्रिड टॉरॉयडल है। इस प्रकार हमें केवल कार को चारों प्रारंभिक दिशाओं के लिए टेप को संशोधित किए बिना इसे बाहर निकलने की आवश्यकता है:

• ऊपर और नीचे सीधा है, बाहर निकलने के लिए सीधे शीर्षक।

• बाईं ओर, हम लपेटते हैं और निष्पादित करते हैं <और बढ़ाते हैं ^। हम अगले मोड़ पर छोड़ नहीं सकते <इसलिए हम vपिछले वेतन वृद्धि को नकारते हुए लपेटते और घटाते हैं । चूंकि हम नीचे की ओर जा रहे हैं, अब हम दाएं मुड़ सकते हैं <और बाहर निकल सकते हैं, दो बार पॉइंटर को स्थानांतरित किया है और सेल मूल्यों को संशोधित नहीं किया है।

• दाएं के लिए, हम बाएं की तरह ही काम करते हैं लेकिन पहले छोड़ें ^क्योंकि हम बाएं मुड़ नहीं सकते।

---

संपादित करें : यह पता चला है कि HBCHT दुभाषिया आपको कमांड लाइन के ध्वज के माध्यम से केवल एक ही पथ निष्पादित करता है, जैसे

py -3 hbcht -d left cat.hbc

हालांकि, इस विशेष प्रश्न के लिए न केवल झंडा बहुत महंगा है (कम से कम 5 बाइट्स के लिए " -d u"), ऐसा लगता है कि सभी मार्गों को अभी भी कोड को निष्पादित करने के लिए बाहर निकलने के लिए सक्षम होने की आवश्यकता है।

Answer 24

मिंकोलंग , 5 बाइट्स

od?.O

इसे यहाँ आज़माएँ।

व्याख्या

oइनपुट से एक पात्र में पढ़ता है और इसके ASCII कोड को स्टैक ( 0यदि इनपुट खाली है) पर धकेलता है । dइसके बाद स्टैक के शीर्ष को दोहराता है (जो चरित्र अभी पढ़ा था)। ?एक सशर्त ट्रैम्पोलिन है, जो स्टैक के शीर्ष के अगले निर्देश को नहीं कूदता है 0। यदि इनपुट खाली था, तो .कूद नहीं जाता है और प्रोग्राम रुक जाता है। अन्यथा, Oएक चरित्र के रूप में स्टैक के शीर्ष आउटपुट। मिंकोलंग के टॉरोइडल प्रकृति का अर्थ है कि यह शुरुआत में चारों ओर घूमता है।

Comments

Grar! आपने मेरी भाषा को हरा दिया! गवारा नहीं! +1

— एडिसन क्रम्प

Answer 25

इंटरकॉल , 133 बाइट्स

वाट

INTERCALL IS A ANTIGOLFING LANGUAGE
SO THIS HEADER IS HERE TO PREVENT GOLFING IN INTERCALL
THE PROGRAM STARTS HERE:
READ
PRINT
GOTO I

Comments

यह कोई है वास्तव में एक विशुद्ध रूप से विरोधी गोल्फ भाषा में golfed तरह लग रहा है ... 133-116 = 17

— एरिक Outgolfer

@ E @G this चूंकि बिल्ली का कार्यक्रम बहुत सरल है, यह सभी कार्यक्रमों का मामला नहीं है ... codegolf.stackexchange.com/a/82748/53745

— TuxCrafting

जिस व्यक्ति ने भाषा बनाई है वह रोमन अंकों का उपयोग करने का इरादा रखता है, लेकिन अगर यह प्रिंट करने के लिए मामला था 500(निश्चित नहीं), तो यह PRINT Dसही होगा? (हेडर को छोड़कर)

— आउटगॉल्फ

@ E ,G print नहींं, INTERCALL केवल ASCII वर्णों को प्रिंट कर सकता है और एक स्टैक का उपयोग कर सकता है, इसलिए उदाहरण के लिए ascii मान 20 के साथ कोडर को प्रिंट करने के लिए कोड है PUSH XX<newline>PRINTया PUSH XX AND PRINT। ओह और मैं INTERCALL का निर्माता हूँ

— TuxCrafting

Answer 26

वी , 0 बाइट्स

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

वी का "मेमोरी" का विचार सिर्फ एक विशाल 2D वर्ण है। किसी भी कार्यक्रम को चलाने से पहले, सभी इनपुट इसे इस सरणी में लोड करते हैं (जिसे "द बफ़र" के रूप में जाना जाता है)। फिर, किसी भी कार्यक्रम के अंत में, बफर में सभी पाठ मुद्रित होते हैं।

दूसरे शब्दों में, खाली कार्यक्रम है एक बिल्ली कार्यक्रम।

Answer 27

स्नोमैन 1.0.2 , 15 वर्ण

(:vGsP10wRsp;bD

सीधे स्नोमैन की निर्देशिका से लिया गयाexamples । एक लाइन पढ़ता है, एक लाइन प्रिंट करता है, एक लाइन पढ़ता है, एक लाइन प्रिंट करता है ...

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

कोड की व्याख्या:

(        // set two variables (a and f) to active—this is all we need
:...;bD  // a "do-loop" which continues looping as long as its "return value"
         // is truthy
  vGsP   // read a line, print the line
  10wRsp // print a newline—"print" is called in nonconsuming mode; therefore,
         // that same newline will actually end up being the "return value" from
         // the do-loop, causing it to loop infinitely

Answer 28

FireType , 7 बाइट्स

,
&
_
=

कुछ की आवश्यकता है बदलावों की जिन्हें मैंने अभी धकेल दिया है । नियम कहते हैं:

हमारे सामान्य नियमों के विपरीत, एक भाषा (या भाषा संस्करण) का उपयोग करने के लिए स्वतंत्र महसूस करें, भले ही यह इस चुनौती से नया हो।

तो मैं स्पष्ट में हूँ!

Answer 29

विखंडन , 4 बाइट्स

R?J!

क्या यह अच्छा नहीं है जब आप भाषा के स्वयं के भंडार में नमूना कार्यक्रमों को हराते हैं? :) संदर्भ के लिए, यह 7-बाइट समाधान है

R?J0;0!

व्याख्या

तो, Rएक दाएं-बाएं परमाणु के साथ नियंत्रण-प्रवाह शुरू करता है। ?परमाणु के द्रव्यमान में STDIN के एक चरित्र को पढ़ता है। जब तक हम पात्रों को पढ़ रहे होते हैं, ऊर्जा शून्य रहती है, इसलिए Jअंप एक नो-ऑप है और !चरित्र को प्रिंट करता है। परमाणु शुरू में वापस चला जाता है (R अब एक नहीं है) और पूरी प्रक्रिया को दोहराता है।

जब हम EOF से टकराते हैं, ?तो परमाणु की ऊर्जा को निर्धारित करेंगे 1, इसलिए Jअंप अब प्रिंट कमांड को छोड़ देगा। लेकिन जब एक परमाणु के बाद हिट? ईओएफ के , तो वह पहले ही परमाणु को नष्ट कर देगा, जो कार्यक्रम को समाप्त कर देता है।

(भाषा के लेखक से समाधान ;कार्यक्रम को समाप्त करने के लिए एक स्पष्ट उपयोग करता है , जिसे दो- 0पोर्टल के साथ छोड़ दिया जाता है अन्यथा)

Answer 30

Shtriped , 20 बाइट्स

e )
"
 r )
 s )
 "
"

यह स्पष्ट रूप से प्रदर्शित करता है कि लगभग किसी भी मुद्रण योग्य ASCII स्ट्रिंग Shtriped में एक वैध पहचानकर्ता है।

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

e )   \ declares a variable named )
"     \ defines a function with 0 arguments named "
 r )  \ gets a line of string input, saving it to )
 s )  \ prints ) as a string
 "    \ recursively calls ", effectively looping forever
"     \ calls " from the main scope to get things started

ईओएफ का पता लगाने का कोई वास्तविक तरीका नहीं है, इसलिए यह पायथन उत्तर की तरह हमेशा के लिए बंद हो जाता है ।

जब एक खाली लाइन दी जाती है तो आप इसे आसानी से रोक सकते हैं (30 बाइट्स):

e )
"
 r )
 d ) \ tries to decrement ), if it was the empty string, aka 0, it can't, so 0 is returned all the way up
 i ) \ increment ) to put it back to normal after possibly decrementing
 s )
 "
"

ध्यान दें कि Shtriped I / O केवल मुद्रण योग्य ASCII , टैब, लाइन फीड, कैरेज रिटर्न, वर्टिकल टैब और फॉर्म फीड (कुल 100 चार्ट) का समर्थन करता है। ऐसा इसलिए है क्योंकि आंतरिक रूप से, स्ट्रिंग्स को गैर-नकारात्मक मनमाने ढंग से सटीक पूर्णांक के रूप में दर्शाया जाता है, और सभी तारों को एनकोड करने में सक्षम होने के लिए वर्णों की एक बारीक वर्णमाला होनी चाहिए।