เครื่องมือวัดความจริง (เครดิตไปหาผู้ชายคนนี้เพื่อหามัน) เป็นโปรแกรมที่ง่ายมากที่ออกแบบมาเพื่อแสดงให้เห็นถึง I / O และควบคุมการไหลของภาษา นี่คือสิ่งที่เครื่องจักรความจริงทำ:

• รับค่าตัวเลข (ทั้ง 0 หรือ 1) จาก STDIN

• หากหมายเลขนั้นคือ 0 ให้พิมพ์ 0 และยุติ

• หากหมายเลขนั้นคือ 1 ให้พิมพ์ 1 ตลอดไป

ท้าทาย

เขียนเครื่องจริงตามที่อธิบายไว้ข้างต้นในภาษาที่คุณเลือก เครื่องความจริงจะต้องเป็นโปรแกรมเต็มรูปแบบที่ปฏิบัติตามกฎเหล่านี้:

• ใช้อินพุตจาก STDIN หรือทางเลือกที่ยอมรับได้
  • หากภาษาของคุณไม่สามารถรับอินพุตจาก STDIN อาจใช้อินพุตจากตัวแปร hardcoded หรือเทียบเท่าที่เหมาะสมในโปรแกรม
• จะต้องส่งออกไปยัง STDOUT หรือทางเลือกที่ยอมรับได้
  • หากภาษาของคุณไม่สามารถแสดงผลอักขระได้0หรือ1สามารถยอมรับไบต์ / unary I / O ได้
• เมื่ออินพุต1นั้นจะต้องพิมพ์อย่างต่อเนื่อง1และหยุดเฉพาะเมื่อโปรแกรมถูกฆ่าหรือหน่วยความจำไม่เพียงพอ

• เอาต์พุตจะต้องเป็นอย่างใดอย่างหนึ่ง0ตามด้วยการขึ้นบรรทัดใหม่หรือเว้นวรรคอย่างใดอย่างหนึ่งหรือไม่หรือการสิ้นสุด1ของแต่ละ1บรรทัดตามด้วยการขึ้นบรรทัดใหม่หรือช่องว่างอย่างใดอย่างหนึ่ง ไม่สามารถสร้างเอาต์พุตอื่นได้ยกเว้นเอาท์พุทคงที่ของล่ามภาษาของคุณที่ไม่สามารถระงับได้ (เช่นคำทักทายรหัสสี ANSI หรือการเยื้อง) การใช้งานของการขึ้นบรรทัดใหม่หรือการเว้นวรรคต้องสอดคล้องกัน: ตัวอย่างเช่นหากคุณเลือกที่จะแสดงผล1ด้วยการขึ้นบรรทัดใหม่หลังจากนั้นทุกบรรทัดจะ1ต้องมีการขึ้นบรรทัดใหม่หลังจากนั้น

• ถ้าหากว่าภาษาของคุณไม่สามารถยุติการป้อนข้อมูลของ0มันก็เป็นที่ยอมรับได้สำหรับรหัสที่จะเข้าสู่วงวนไม่สิ้นสุดที่ไม่มีสิ่งใดถูกเอาท์พุท

เนื่องจากนี่คือแคตตาล็อกภาษาที่สร้างขึ้นหลังจากความท้าทายนี้ได้รับอนุญาตให้แข่งขัน โปรดทราบว่าจะต้องมีล่ามเพื่อให้สามารถส่งการทดสอบได้ ได้รับอนุญาต (และสนับสนุนให้) เขียนล่ามนี้ด้วยตัวคุณเองสำหรับภาษาที่ยังไม่ได้ใช้งานมาก่อน นอกจากนั้นต้องปฏิบัติตามกฎมาตรฐานทั้งหมดของcode-golf การส่งในภาษาส่วนใหญ่จะได้คะแนนเป็นไบต์ในการเข้ารหัสที่มีมาก่อน (ปกติคือ UTF-8)

แค็ตตาล็อก

สแต็คส่วนย่อยที่ด้านล่างของโพสต์นี้สร้างแคตตาล็อกจากคำตอบ a) เป็นรายการคำตอบสั้นที่สุดต่อภาษาและ b) เป็นลีดเดอร์บอร์ดโดยรวม

เพื่อให้แน่ใจว่าคำตอบของคุณปรากฏขึ้นโปรดเริ่มคำตอบด้วยหัวข้อโดยใช้เทมเพลต Markdown ต่อไปนี้:

## 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: 320px; 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 = 62732; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 12012; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "https://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 "https://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(), 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>

Hexagonyขนาด 6 ไบต์

นี่เป็นเรื่องยุ่งยากอย่างน่าประหลาดใจและฉันไม่เชื่อว่ามันจะเป็นสิ่งที่ดีที่สุด ...

<.@!$?

หลังจาก padding และแฉรหัสนี้แสดงถึงกริดฐานสิบหกต่อไปนี้:

สิ่งนี้ใช้โฟลว์การควบคุมที่คล้ายกันเช่นโปรแกรม cat ปราศจากข้อผิดพลาดล่าสุดของฉันเคลื่อนไปตามแนวต้านเส้นทแยงมุม เพื่อให้บรรลุว่าเราเริ่มต้นจากการเบี่ยงเบนตัวชี้คำสั่ง (IP) ไปทางซ้ายซึ่งเส้นทางสีม่วงล้อมรอบไปที่มุมซ้ายล่าง

?อ่านอินพุตเป็นจำนวนเต็ม !พิมพ์มันกลับ .เป็นเพียงไม่มี ตอนนี้มุมของกริดทำหน้าที่เป็นสาขา:

ถ้าใส่เป็น0ที่ IP @จะยังคงไปตามเส้นทางสีแดงซึ่งก็ยุติโปรแกรมด้วย

หากอินพุตเป็น1IP จะดำเนินการต่อบนเส้นทางสีเขียว อีกครั้ง.เป็นเพียง no-op แต่$เทียบเท่ากับแทรมโพลีนของ Befunge: มันข้ามคำสั่งต่อไป หลังจากการตัดคำแนะนำต่อไปจะเป็น?แต่เนื่องจาก$การดำเนินการจริงยังคงอยู่บนเส้นทางสีฟ้าที่เริ่มต้นด้วยการพิมพ์สำเนาของอีก! 1วนซ้ำที่มีเฉพาะ!..$ตอนนี้จะถูกทำซ้ำไปเรื่อย ๆ

การศึกษาการควบคุมการไหลของ Hexagony ...

ฉันเชื่อว่าวิธีการแก้ปัญหาข้างต้นเหมาะสมที่สุด ฉันได้เขียนนักสืบเดรัจฉานซึ่งตรวจสอบโปรแกรม Hexagony 6 ไบต์ทั้งหมดซึ่งมีอย่างน้อยหนึ่งรายการ?!@(ซึ่งจำเป็นต้องใช้ฉันได้ตรวจสอบ:และ%แทนที่@ด้วยข้อผิดพลาดการหารด้วยศูนย์ แต่ ที่ไม่ได้ช่วยเช่นกัน) เช็คจะพิมพ์โปรแกรมทั้งหมดที่ a) สร้าง a 0on input 0และยุติและ b) สร้างอย่างน้อยสอง1s (และไม่มีอะไรอื่น) และจะไม่ยุติภายใน 60 ticks แรกของโปรแกรม (200 ticks สำหรับ 5-byte solution) . ฉันสงสัยว่าโซลูชันที่ถูกต้องจะใช้เวลามากกว่า 200 เห็บในการพิมพ์ครั้งแรก0หรือครั้งที่สอง1บนกริดขนาดเล็กเช่นนั้นอย่างถูกต้องดังนั้นฉันจึงไม่คิดว่าจะพลาดวิธีแก้ไขที่เป็นไปได้

การค้นหาไม่ได้ผลลัพธ์ใด ๆ สำหรับ 5 ไบต์ แต่ 57 ผลลัพธ์สำหรับ 6 ไบต์ (โดยใช้@ไม่จำเป็นต้องยุติด้วยข้อผิดพลาดหากเราสามารถแก้ปัญหานี้ได้อย่างหมดจดในจำนวนไบต์เดียวกัน) ในบรรดา 57 เพียง 6 ข้อนั้นเป็นผลบวกปลอมซึ่งจริง ๆ แล้วพิมพ์เพียงสอง1วินาทีแล้วเข้าสู่วงวนไม่สิ้นสุดโดยไม่ต้องพิมพ์อีกต่อไป โซลูชันหนึ่งรายการถูกแสดงสองครั้งเนื่องจากมีสอง!คำสั่ง นั่นคือโซลูชันที่ถูกต้อง 50 ข้อ

มีความเสื่อมในจำนวนหนึ่งระหว่างวิธีแก้ปัญหาที่อักขระหนึ่งหรือสองตัวไม่มากเช่นเนื่องจากพวกมันไม่มีประสิทธิภาพ การแก้ปัญหาสามารถแบ่งออกเป็น 23 ชุดของโปรแกรมที่แตกต่างกันอย่างแท้จริง (ในบางกรณีมีเพียงความแตกต่างอักขระเดียวระหว่างสองชุด แต่เปลี่ยนการควบคุมการไหลอย่างมีนัยสำคัญดังนั้นฉันจึงนับพวกเขาแยกต่างหาก) กลุ่มสองกลุ่มใช้ประโยชน์จากตัวชี้คำสั่งหลายอย่างในแบบที่ไม่คาดคิด เนื่องจากฉันไม่เคยใช้วิธีเหล่านี้ในการใช้กิ่งไม้และกระจกพวกเขาทำการศึกษาที่น่าสนใจมากในการควบคุมการไหลใน Hexagony และฉันได้เรียนรู้เทคนิคใหม่ ๆ สำหรับสนามกอล์ฟในอนาคต

โดยรวมการควบคุมการไหลเกือบจะเสมอกัน: อ่านจำนวนพิมพ์ ถ้ามัน0หาทางไป@, ถ้าไม่วนซ้ำไปเรื่อย ๆ ใน!ขณะที่กำลังทำให้ค่าขอบเป็น1ศูนย์ มีข้อยกเว้นเด่นสี่ประการ:

• ทางออกหนึ่ง (หนึ่งกับสอง!) พิมพ์สอง1s ต่อการวนซ้ำผ่านกริดดังนั้นการพิมพ์ประมาณสองครั้งเร็วที่สุดเท่าที่โปรแกรมส่วนใหญ่ ฉันได้ทำเครื่องหมายสิ่งนี้ด้วยx2ด้านล่าง
• วิธีแก้ปัญหาเล็กน้อย (ที่มีo) แทนที่1ด้วย111(รหัสตัวอักษรของo) ดังนั้นพวกเขาจึงพิมพ์สาม 1วินาทีต่อการวนซ้ำทำให้พวกเขาพิมพ์ประมาณสามครั้งเร็วที่สุดเท่าที่โปรแกรมส่วนใหญ่ ฉันได้ทำเครื่องหมายสิ่งเหล่านี้ด้วยx3ด้านล่าง
• สองโซลูชั่นผนวก1กับค่าขอบในแต่ละซ้ำ (ดังนั้น1-> 11-> 111-> ... ) งานพิมพ์เหล่านั้นเร็วมากแต่ในที่สุดหน่วยความจำจะหมด ฉันได้ทำเครื่องหมายสิ่งเหล่านี้ด้วยOoMด้านล่าง
• โซลูชันสองตัวเข้าสู่วงจรที่แน่นหนาซึ่งเพียงแค่ตีกลับไปมา!โดยพิมพ์ลงบนเห็บอื่น ๆ (แทนที่จะเป็นทุก ๆ 5 หรือมากกว่านั้น) ซึ่งทำให้พวกมันเร็วขึ้นเล็กน้อย (และ neater) ฉันได้ทำเครื่องหมายสิ่งเหล่านี้ด้วย><ด้านล่าง

ดังนั้นที่นี่เป็นสวนสัตว์ทั้งหมด:

#1                #5                #12                #19
?!/$.@            ?$!>$@            .?!/$@             |!|?$@  # ><
?!/$1@  # OoM     ?$!|$@            =?!/$@
?!/$=@                                                 #20
?!/$\@            #6                #13                $@.?<!
?!/$o@  # x3      ?/!<|@            .?/!$@             $@1?<!  # OoM
?!/$!@  # x2                        =?/!$@             $@=?<!
                  #7                                   $@o?<!  # x3
#2                ?\!<|@            #14
?!>$)@                              \!?__@             #21
?!>$1@            #8                                   _>_!?@
?!>$o@  # x3      ?<!>$@  # ><      #15
?!|$)@                              \_?!$@             #22
?!|$1@            #9                                   <!@.$?
?!|$o@  # x3      ?\$!@$            #16                <!@/$?
                                    \_?!_@             <!@=$?
#3                #10                                  <$@!$?
?!|)$@            ?~#!@)            #17                <.@!$?
?!|1$@            ?~#!@1            $$?\@!             </@!$?
?!|o$@  # x3                                           <=@!$?
                  #11               #18
#4                ?$)\@!            \$?\@!             #23
?_!<@>            ?$1\@!                               <<@]!?
                  ?$o\@!  # x3

ต่อไปนี้เป็นคำแนะนำสั้น ๆ สำหรับกลุ่มตัวแทนจำนวนหนึ่ง โดยเฉพาะอย่างยิ่งกลุ่มที่ 10 และ 23 คุ้มค่าที่จะเช็คเอาท์ มีเส้นทางอื่นที่น่าสนใจและซับซ้อนบางครั้งในกลุ่มอื่น ๆ แต่ฉันคิดว่าฉันเบื่อคุณมากพอในตอนท้าย สำหรับใครที่อยากจะเรียนรู้จริงๆ Hexagony $เหล่านี้เป็นมั่นเหมาะมูลค่าการตรวจสอบว่าเป็นพวกเขาแสดงการใช้งานที่เป็นไปได้มากยิ่งขึ้นของกระจกและ

กลุ่มที่ 1

อันนี้ไม่ค่อยซับซ้อนกว่าโซลูชันเดิมของฉัน แต่เส้นทางไปในทิศทางที่แตกต่างกัน นอกจากนี้ยังอนุญาตให้มีการเปลี่ยนแปลงจำนวนมากที่สุดในเซลล์เดียวเนื่องจากไม่สามารถแทนที่ op-right ขวาด้วย 5 คำสั่งต่าง ๆ ซึ่งยังคงใช้งานได้โดยไม่ต้องเปลี่ยนโครงสร้าง:

กลุ่ม 2

อันนี้ค่อนข้างน่าสนใจเพราะมันเคลื่อนที่ในแนวนอนเท่านั้น หลังจากตัดไปที่>IP จะกลับด้านทันทีโดยแยกสาขาที่มุม มันไม่ชัดเจนเลยว่าไม่มีแผนภาพ แต่ในกรณีที่1เราสำรวจแถวแรกอีกครั้ง แต่ย้อนหลังในเวลานี้ นอกจากนี้ยังหมายถึงเราพบกัน?อีกครั้งซึ่งตอนนี้ส่งคืน0(EOF) นี้ได้รับการแก้ไขด้วย)(เพิ่มขึ้น) เพื่อให้การพิมพ์1s นอกจากนี้ยังมี 5 รูปแบบที่)อาจจะเป็น1หรือoและ>อาจเป็น|:

กลุ่ม 3

อันนี้ดูเกือบจะเหมือนกันกับอันก่อนหน้านี้ แต่มันก็รกเหมือนนรก ขึ้นไปถึงการกดปุ่ม|แล้วข้ามด้านล่างหรือแถวบนสุดเหมือนกัน แต่ในกรณีของลูป$ตอนนี้ข้ามไป) บนกระจก ดังนั้นเราจึงทำตามเส้นทางสีเขียวขุ่นไปทางขวาตอนนี้ตีเพิ่มขึ้นข้ามในช่วง@ก่อนที่เราจะห่อรอบไป| อีกครั้งและจากนั้นกลับไปที่เส้นทางสีเขียวที่ด้านบน

กลุ่ม 4

ฉันคิดว่าอันนี้ดีโดยเฉพาะ:

_กระจกที่มุมบนด้านขวาเป็นครั้งแรกไม่มี-op ดังนั้นเราพิมพ์ด้วยและกด! เส้นทางตอนนี้ฮิตกระจกแนวนอนและสิ้นสุด เส้นทางใช้เวลาโคจรที่น่าสนใจจริงๆว่า: มัน deflects ลง wraps ไปได้รับการเปลี่ยนเส้นทางไปทางแนวนอนแล้วตัดกลับไปอีกครั้ง จากนั้นจะยังคงเคลื่อนไหวในรูปสี่เหลี่ยมขนมเปียกปูนนี้พิมพ์สองครั้งต่อการทำซ้ำ (ทุกติ๊กที่สาม)<01!!

กลุ่ม 8

นี่เป็นหนึ่งในสองวิธีที่มีการพิมพ์วนอย่างแน่นหนา:

<ทำหน้าที่เป็นสาขา หลังจากห่อสองฮิต0 ในทางกลับกันให้ข้ามไปก่อนจากนั้นส่งไปที่อีกครั้งเพื่อข้ามไป จากนั้น IP จะตัดเข้าไปในเส้นทางสีฟ้าครามซึ่งกระดอนไปมาระหว่างและ(ล้อมรอบขอบระหว่าง)@1?>$@><

กลุ่ม 10

หนึ่งในสองกลุ่มที่ใช้พอยน์เตอร์คำแนะนำอื่น ๆ และมันก็สวยงามมาก Hexagony มี 6 - แต่ละอันเริ่มจากมุมที่แตกต่างกันตามขอบตามเข็มนาฬิกา แต่จะมีเพียงอันเดียวที่เปิดใช้งานในแต่ละครั้ง

?ตามปกติเราอ่านด้วย ตอนนี้~เป็นผลทางลบเอก: มันจะเปลี่ยนเป็น1 ต่อไปเราจะตี-1 #นี่เป็นวิธีหนึ่งในการสลับระหว่าง IP: ใช้ค่าขอบโมดูโล 6 ปัจจุบันและเปลี่ยนเป็น IP ที่สอดคล้องกัน (IP จะถูกกำหนดหมายเลขจาก0ในทิศทางตามเข็มนาฬิกา) ดังนั้นถ้าใส่เป็น0แล้ว IP !@ก็ยังคงเหมือนเดิมและการเดินทางน่าเอือมระอาตรงไปข้างหน้าเข้า แต่ถ้าอินพุตเป็น1ดังนั้นค่าปัจจุบัน-1คือ5 (mod 6)อะไร ดังนั้นเราจึงเปลี่ยนเป็น IP ซึ่งเริ่มต้นในเซลล์เดียวกัน (เส้นทางสีเขียว) ตอนนี้#เป็นแบบไม่มี op และ?ตั้งค่าขอบหน่วยความ0จำเป็น )เพิ่มขึ้นเพื่อให้พิมพ์! 1ตอนนี้เราตี~อีกครั้งเพื่อให้แน่ใจว่า#ยังคงเป็นแบบไม่ใช้งาน (ตรงข้ามกับการสลับเราเป็น IP 1 ซึ่งจะยุติโปรแกรม) มันเป็นความคิดที่แสดงให้เห็นว่าทุกอย่างเข้ากันได้ดีในโปรแกรมเล็ก ๆ นี้

กลุ่ม 22

นี่เป็นกลุ่มที่โซลูชันดั้งเดิมของฉันตั้งอยู่นอกจากนี้ยังเป็นกลุ่มที่ใหญ่ที่สุดเนื่องจากไม่มีการใช้งานในสถานที่ที่แตกต่างกันสองแห่งและมีตัวเลือกมากมายสำหรับคำสั่ง (ไม่มีผลบังคับใช้จริง)

กลุ่ม 23

นี่คือกลุ่มอื่นที่ใช้หลาย IP อันที่จริงอันนี้ใช้3 IP ที่แตกต่างกัน มุมขวาบนนั้นค่อนข้างยุ่งเหยิง แต่ฉันจะพยายามแนะนำคุณผ่านสิ่งนี้:

ดังนั้นจุดเริ่มต้นที่คุณเคยเห็นมาก่อน: <หันเหความสนใจภาคตะวันออกเฉียงเหนือ?อ่านอินพุต ตอนนี้]เป็นอีกวิธีหนึ่งในการเปลี่ยนระหว่าง IP: มันสามารถควบคุม IP ต่อไปตามลำดับทวนเข็มนาฬิกา ดังนั้นเราจึงเปลี่ยนการควบคุมเป็นเส้นทางสีฟ้าครามซึ่ง (ฉันรู้ว่ามันยากที่จะมองเห็น) เริ่มต้นในมุมตะวันออกเฉียงเหนือไปทางตะวันออกเฉียงใต้ มันถูกสะท้อนโดยทันที<เพื่อที่จะล้อมรอบมุมตะวันออกเฉียงใต้ไปทางตะวันตกเฉียงเหนือ นอกจากนี้ยังได้รับความนิยม]ดังนั้นเราจึงเปลี่ยนเป็นIP ถัดไป นี่คือเส้นทางสีเทาที่เริ่มต้นที่มุมตะวันออกไปทางตะวันตกเฉียงใต้ มันพิมพ์อินพุตจากนั้นล้อมรอบมุมตะวันออกเฉียงเหนือ <เบี่ยงเบนเส้นทางไปสู่แนวนอนซึ่งมีการสะท้อนจากอีกด้าน <หนึ่ง ตอนนี้มือขวา<ทำหน้าที่เป็นสาขา: ถ้าใส่เป็น0ที่ IP ย้ายภาคตะวันออกเฉียงเหนือและ wraps @ไป หากอินพุตคือ1IP จะย้ายไปที่!, ห่อไปที่ไฟล์ lef-thand <ที่มันสะท้อน ... ตอนนี้ที่มุม, มันย้อนกลับไปที่!, ได้รับการเบี่ยงเบนจากด้านขวา<, สะท้อนจากด้านซ้าย<และเส้นทางเริ่มต้น เกิน...

ค่อนข้างยุ่ง แต่เป็นระเบียบที่สวยงาม :)

ไดอะแกรมสร้างขึ้นด้วยTimwi ของที่น่าตื่นตาตื่นใจHexagonyColorer

รหัสเครื่องMotorola MC14500Bขนาด 2 ไบต์

ในรูปหกเหลี่ยม:

58EC

คำอธิบาย:

5  OR the register with input from the data bus
8  Write the register to the data bus
E  Skip next instruction if register is zero
C  Jump

Motorola MC14500B เป็นไมโครคอนโทรลเลอร์ขนาด 1 บิต; มันมีการลงทะเบียน 1 บิตและบัสข้อมูล 1 บิต เนื่องจาก opcodes มี 4 บิตแต่ละตัวมีเพียงสิบหกเท่านั้น ครึ่งหนึ่งของพวกเขาดำเนินการทางตรรกะระหว่าง register และ bit บน data bus

คำสั่งการกระโดดตั้งค่าสถานะการกระโดด เมื่อไม่มีการระบุที่อยู่เป็นเรื่องปกติที่จะตั้งโปรแกรมตัวนับเป็น 0 ถ้าบิตอินพุตเป็นศูนย์ตัวประมวลผลจะไม่กระโดด หากบิตอินพุตเป็น 1 ตัวประมวลผลจะกระโดดกลับไปที่จุดเริ่มต้น เนื่องจากเรากำลังORเข้ากับอินพุตมันไม่สำคัญว่าสัญญาณเข้าจะเป็นอะไรหลังจากนั้นการลงทะเบียนจะเป็น 1 ตลอดไป

ตามปกติการลงทะเบียนจะเริ่มต้นเป็น 0

รายชื่อของ opcodes ต่อ A สามารถพบได้บนแผ่นข้อมูลหรือนี่

Arnold C, 296 Bytes

IT'S SHOWTIME
    HEY CHRISTMAS TREE i    
    YOU SET US UP @NO PROBLEMO
    BECAUSE I'M GOING TO SAY PLEASE i
        STICK AROUND i
            TALK TO THE HAND i
        CHILL
    BULLSHIT
        TALK TO THE HAND i
    YOU HAVE NO RESPECT FOR LOGIC
YOU HAVE BEEN TERMINATED

ไม่ได้แข่งขันกันจริงๆ แต่เพื่อความสนุกของมัน ไม่รองรับ stdin แทนที่@NO PROBLEMOด้วย@I LIEDค่าศูนย์ @No Problemoคือ 1

ทำงานด้วย (ไฟล์สมมติว่าเป็น factmachine.arnoldc):

wget http://lhartikk.github.io/ArnoldC.jar
java -jar ArnoldC.jar truthmachine.arnoldc
java truthmachine

Minecraft, 18 ไบต์ (รุ่น MC 15w45a)

อย่างที่คุณเห็นมีคันโยกที่นำไปสู่บล็อกคำสั่งซ้ำซึ่งมีคำสั่งsay 1อยู่ มีสัญญาณการกลับด้านบนของไฟฉายซึ่งส่งพลังงานไปยังบล็อกคำสั่งแบบเรียกใช้ครั้งเดียวโดยมีคำสั่งsay 0อยู่

เมื่อใดก็ตามที่สวิทช์เป็นผู้กำกับที่มีต่อ truthy บล็อก repeater ใช้รหัสsay 1การส่งออกอนันต์1s 0เมื่อคันจะถูกนำไปเป็นเท็จมันจะออกผลลัพธ์เดียว

โปรดทราบว่าสิ่งนี้จะส่งออก[@]โดยค่าเริ่มต้น หากคุณจริงๆต้องการเพียงแค่ตรงขึ้น 1s และศูนย์นี้จะกลายเป็น 34 ไบต์ที่รหัสในคำสั่งบล็อกเป็นและtellraw @a [1] tellraw @a [0]นี้กำลังใช้ @ CᴏɴᴏʀO'Bʀɪᴇɴบอกนับไบต์สำหรับ MC ที่สามารถพบได้ใน Meta

Bash + GNU utils, 13

grep 0||yes 1

Bash, 35

read n;for((;n;));{ echo 1;};echo 0

ทับทิม, 20

print while/1/||gets

เรียกใช้จากบรรทัดคำสั่งเพื่อหลีกเลี่ยงคำเตือนเช่น

ruby -e "print while/1/||gets" <<< 0
ruby -e "print while/1/||gets" <<< 1

คำอธิบาย:

น้อย golfed นี่คือ

while /1/ || gets
  print
end

เมื่อใช้ Regexp ในเงื่อนไขมันจะประเมินว่าเป็นเท็จเว้นแต่ตัวแปร$_จะถูกเติมและตรงกับรูปแบบ ในครั้งแรกที่ผ่านลูป$_นั้นว่างเปล่าดังนั้นเราจึงไปถึงgetsซึ่งตั้งค่า$_เป็นบรรทัดที่อ่านจาก STDIN โดยไม่มีข้อโต้แย้งพิมพ์print $_ตอนนี้เราประเมินเงื่อนไขอีกครั้ง ถ้าเราอ่านใน 1 เราจะลัดวงจรและพิมพ์ 1 อีกครั้งตลอดไปเรื่อย ๆ มิฉะนั้นเราจะผ่านไปgetsแต่เนื่องจากไม่มีอินพุตบรรทัดที่สองจึงgetsส่งกลับศูนย์ดังนั้นลูปจึงสิ้นสุด

ไมโครสโคปขนาด 3 ไบต์

i{p

สั้นที่สุดที่ฉันรู้

คำอธิบาย:

i  Takes numeric input and puts it in register 1
{  while register 1 is truthy
  p  Print the contents of register 1

Microscript มีการพิมพ์โดยนัยของการลงทะเบียน 1 เมื่อสิ้นสุดซึ่งเป็นเหตุผลที่ทำให้การป้อนข้อมูลของ0ได้รับการพิมพ์ครั้งเดียว

ทัวริงรหัสเครื่อง 32 ไบต์

การใช้ไวยากรณ์ตารางกฎพบได้ที่นี่

0 0 0 * halt
0 1 1 r 1
1 _ 1 r 1

JavaScript ขนาด 28 ไบต์

สำหรับลูปมักจะสั้นกว่าในขณะที่ลูป

alert(x)ผลตอบแทนundefinedซึ่งเป็น falsy ดังนั้นค่าที่เหมาะสมหรือผู้ประกอบการปลดเปลื้องมัน| 0ดังนั้นหากxมีการ"0"แจ้งเตือนครั้งเดียวมิฉะนั้นให้วนลูป ใช้alertสำหรับ STDOUT เหมือนคำตอบนี้

for(x=prompt();alert(x)|x;);

Python 2, 29 ไบต์

a=input()
while 1:print a;1/a

นี้สิ้นสุดลงด้วยข้อผิดพลาดส่วนบน0ซึ่งเป็นที่ได้รับอนุญาตโดยค่าเริ่มต้น

Brainfuck, 41 36 31 30 ไบต์

ย่อด้วยการพิมพ์เพียงครั้งเดียวหลังจากป้อนข้อมูลและด้วยความช่วยเหลือจาก Ethan และผู้ใช้ 46915

,.+++[->>+<-----<]>>---<-[>.<]

รุ่นก่อนหน้านี้: 48 ลบจากการป้อนข้อมูลและถ้ามันไม่ได้เป็นศูนย์เพิ่ม 1 ถึง 48 พิมพ์ ASCII ตลอดไปพิมพ์เป็นอย่างอื่น10

-[>+<-----]>--->,<[->->+<<]>[>+<]>.<[>.<]

ฉันรันที่นี่แต่เนื่องจากเอาต์พุตบัฟเฟอร์คุณไม่สามารถเห็นเอาต์พุตใด ๆ ได้เนื่องจากโปรแกรมไม่เคยหยุด1ทำงาน

แก้ไข: ฉันได้ลืมที่จะพิมพ์กับการป้อนข้อมูล0 0แก้ไขแล้ว ฉันชอบ>.<ใบหน้าที่สุด

Piet, 27 18 16 codels

(Codel เป็นชื่อแฟนซีสำหรับพิกเซลที่ใช้เพื่อหลีกเลี่ยงความสับสนเมื่อรูปภาพถูกยืดสำหรับการดูฉันนับ codels แทน bytes เนื่องจากสคริปต์ piet ถูกบันทึกเป็นรูปภาพดังนั้นขนาดทางกายภาพอาจแตกต่างกันฉันคิดว่ารูปแบบไฟล์ที่เหมาะที่สุดที่จะบันทึก piet นี้อย่างมีประสิทธิภาพมากที่สุดจะใช้เวลา 11 ไบต์ในทางปฏิบัติไฟล์ gif เล็ก ๆ ของฉันคือ 62 bytes กับข้อมูล palette ที่ดีที่สุดบอกฉันว่าฉันควรใช้นี่เป็นขนาดของรายการของฉันแทนที่จะเป็นจำนวน codel)

ภาพต้นฉบับ:

ขยาย:

ใน piet ความแตกต่างระหว่างสองสีคือสิ่งที่กำหนดว่าคำสั่งใดรันดังนั้นการเห็นสีเดียวกันสองครั้งไม่ได้หมายความว่ามันทำสิ่งเดียวกัน การดำเนินการเริ่มต้นในรูปแบบซ้ายบน จากนั้นมันจะเคลื่อนที่ในแนวนอนโดยทำสิ่งต่อไปนี้:

1. อ่านตัวเลขแล้ววางลงบนสแต็ก
2. ทำซ้ำส่วนบนสุดของสแต็ก
3. แสดงและส่งออกด้านบนของสแต็ก
4. วางส่วนบนสุดของสแต็กแล้วหมุนตามเข็มนาฬิกาตามจำนวนครั้ง

หากอินพุตเป็น 1 เคอร์เซอร์จะเลื่อนลงไปที่โมเดล cime ซึ่งกด 1 บนสแต็ก จากนั้นการประหารยังคงดำเนินต่อไป เมื่อเคอร์เซอร์ผ่านจากสีเป็นสีขาวและจากสีขาวเป็นสีจะไม่มีอะไรเกิดขึ้น เนื่องจากสีดำถือเป็นกำแพงเช่นกันเคอร์เซอร์จะกลับไปที่ปูนขาวในบรรทัดบนสุดและทำซ้ำทั้งหมดตั้งแต่ขั้นตอนที่ 2

อย่างไรก็ตามถ้าอินพุทเป็น 0 เคอร์เซอร์จะไม่ลงไปและจะจบลงใน J สีฟ้าทางด้านขวา (ปุนตั้งใจมันคุ้มค่า) ถ้ามันติดอยู่ (เพราะด้านบนขวาซ้ายและ ด้านล่างของบล็อกรูปตัว J นี้อยู่ติดกับรหัสสีดำหรือขอบของภาพ) เนื่องจากเคอร์เซอร์ติดอยู่การทำงานจึงสิ้นสุดลง

ค่าที่ไม่คาดคิด:
หากผู้ใช้เขียนหมายเลขอื่นมันจะยังคงถูกพิมพ์แล้วเคอร์เซอร์จะหมุนเวลามากหรือน้อยขึ้นอยู่กับค่า

• ทวีคูณของ 4 หรือ 0: การดำเนินการต่อเนื่องในแนวนอนและสิ้นสุด
• หลายค่า 3: เมื่อขึ้นไปไม่ได้เคอร์เซอร์จะหมุนตามเข็มนาฬิกาทันทีและต่อเนื่องในแนวนอนจากนั้นจะสิ้นสุด
• ทวีคูณของ 2 และไม่ใช่ทวีคูณของ 4: เคอร์เซอร์หมุนและเริ่มเคลื่อนไปทางซ้าย โชคดีที่ทั้งหมดนี้ดำเนินการหลายอย่างซึ่งไม่ส่งผลกระทบต่อการไหลของโปรแกรมและสิ้นสุดการล้างสแต็ก เมื่อการดำเนินการไม่สามารถทำได้เนื่องจากสแต็กว่างเปล่ามันจะถูกละเว้นเพียงแค่ เมื่อมันกระทบกับมุมบนซ้ายเคอร์เซอร์จะไม่มีที่อื่นที่จะไป แต่ไปทางขวาอีกครั้งทำให้รีสตาร์ทโปรแกรมได้อย่างมีประสิทธิภาพ
• ค่าอื่น ๆ : เคอร์เซอร์จะลดลงราวกับว่ามันเป็น 1 ซึ่งทำให้มันพิมพ์ 1 ตลอดไป หากอินพุตเป็น 5 เอาต์พุตจะเป็น5111111111111...

ค่าที่ไม่ใช่จำนวนเต็มใด ๆ จะยุติโปรแกรม การดำเนินการจะดำเนินการตามปกติ แต่การดำเนินการทั้งหมดจะถูกละเว้นเนื่องจากไม่มีสิ่งใดในสแต็ก ดังนั้นในทางโปรแกรมไม่ล้มเหลว - มันหยุดปกติหรือวนซ้ำตลอดไป

รุ่นที่เป็นมิตรกับ PietDev

PietDev (Piet IDE ออนไลน์ขั้นพื้นฐานมาก) ดูเหมือนว่าจะมีปัญหากับโคเดกสีขาวดังนั้นฉันจึงสร้างเวอร์ชันใหม่ที่หมุนแบ็คอัพแบบแมนนวลด้วยตนเองแทนที่จะพึ่งพาโมเดลหมุนอัตโนมัติสีขาวที่เหมาะสม และฉันก็ไม่จำเป็นต้องใช้สีใหม่! หากคุณต้องการทดสอบให้แน่ใจว่าคุณวาดเส้นขอบสีดำรอบ ๆ รหัสเพราะ PietDev ไม่สนับสนุนขนาดโปรแกรมที่กำหนดเอง

รุ่นเก่ากว่า

รุ่นแรกไม่ได้กด 1 ครั้งบนสแต็กและวนกลับไปที่คำสั่งการทำสำเนาก่อนหน้านี้แทน มันยังมีโคเดอร์ที่ไร้ประโยชน์อีกด้วย

จากนั้นฉันก็มีความคิดที่จะผลัก 1 บนสแต็กเพื่อลบบรรทัดว่าง มันตลกที่ฉันคิดว่ามันต้องขอบคุณ codels ตกแต่งของฉัน

จากนั้นฉันก็รู้ว่าฉันมีภาพซ้อนทับที่ไม่จำเป็นอีกต่อไปและฉันลดจำนวนสีลงเพื่อประหยัดข้อมูลจานสีในภาพ ฉันก็กำจัดโมเดลตกแต่งเดียวเพราะฉันไม่รู้

Pyth, 4 3 2

Wp

มีไม่! พื้นที่ต่อท้าย (ขอบคุณ isaac :)) พื้นที่ที่ใช้ในการสร้างคอมไพล์ในขณะที่ แต่ Pyth ได้รับการปรับปรุง ปกติแล้วจะตัดสิทธิ์การใช้งาน แต่เนื่องจากนี่เป็นแคตตาล็อกจึงควรใช้งานได้

คำอธิบาย:

Wp        : implicit Q = eval(input)
W         : while
 p        : print and return the value of Q, to be evaluated as the while condition
          : Functions without enough arguments automatically use Q now
          : do nothing in the body of the while loop

ชิปขนาด 6 ไบต์

e*faAs

ชิพเป็นภาษา 2 มิติที่มีพฤติกรรมคล้ายกับวงจรรวม มันใช้เวลาในการป้อนข้อมูลทีละหนึ่งไบต์และแบ่งออกเป็นบิตเพื่อองค์ประกอบการป้อนข้อมูลของแต่ละบุคคล เอาท์พุทเย็บค่าขององค์ประกอบเอาท์พุทกลับมารวมกันเป็นไบต์

เราจะทำลายสิ่งนี้ลง:

*เป็นสัญญาณต้นทางมันจะส่งค่าที่แท้จริงไปยังองค์ประกอบที่อยู่ติดกันทั้งหมด eและfสอดคล้องกับบิตที่ห้าและหกของการส่งออก ดังนั้นe*fผลิตไบนารี00110000ซึ่งเป็น ASCII ถ่าน "0"

ตอนนี้Aเป็นบิตแรกของอินพุตและaเป็นบิตแรกของเอาต์พุตดังนั้นaAคัดลอกบิตนั้นจากอินพุตไปยังเอาต์พุต ดังนั้นเมื่อรวมกับe*fอินพุตของ ASCII "0" จะสร้าง "0" และ "1" จะสร้าง "1" (ไม่มีการโต้ตอบระหว่างfและaเนื่องจากไม่มีสัญญาณใด ๆ )

sที่สิ้นสุดเมื่อเปิดใช้งานโดยสัญญาณที่แท้จริงจะป้องกันไม่ให้การป้อนข้อมูลจากล้ำหน้าไปไบต์ต่อไปหมายความว่าสิ่งที่ทั้งจะทำงานอีกครั้งด้วยการป้อนข้อมูลเดียวกัน

เนื่องจากไบต์แรกของ "0" เป็นศูนย์มันจะไม่เปิดใช้งานองค์ประกอบนี้และโปรแกรมจะพิมพ์ "0" ดังนั้นจึงหมดอินพุตซึ่งอนุญาตให้ยกเลิกได้ อย่างไรก็ตาม "1" จะเปิดใช้งานองค์ประกอบนี้ซึ่งหมายความว่า "1" เป็นเอาต์พุต แต่ไม่ได้ใช้กับอินพุตทำให้วงจรสามารถทำซ้ำได้อย่างไม่มีกำหนด

หากใช้ค่า 0x0 และ 0x1 สำหรับเอาท์พุทแทนที่จะเป็น ASCII เราสามารถกำจัดe*fส่วนที่เป็นผลลัพธ์ใน3 ไบต์เท่านั้น:

aAs

หากศูนย์ต้องยุติตัวเองแทนที่จะคาดหวังว่าจะปิด stdin เราจะได้รับดังต่อไปนี้ซึ่งจะสลับไบต์แรกด้วย~และส่งผลลัพธ์ไปให้tซึ่งจะยุติโปรแกรม ( 10 ไบต์ ):

aA~te*f
 s

( tไม่สร้างสัญญาณดังนั้นจึงไม่มีการโต้ตอบระหว่างtและe.)

Brainbool 5 ไบต์

,.[.]

Brainbool เป็น Brainfuck แต่ทำงานในบิตเท่านั้นและใช้ I / O ผ่าน0และ1ตัวละคร

LOLCODE ขนาด 119 ไบต์

GIMMEH n
n R SUM OF n AN 0
BOTH SAEM n AN 0, O RLY?
YA RLY
 VISIBLE 0
NO WAI
 IM IN UR l
  VISIBLE 1
 IM OUTTA UR l
OIC

Ungolfed:

HAI

BTW, Read n as a string from STDIN and convert to an integer
GIMMEH n
n R SUM OF n AN 0

BTW, Test n for equality with 0
BOTH SAEM n AN 0, O RLY?
YA RLY
    BTW, Write 0 to STDOUT and exit
    VISIBLE 0
NO WAI
    BTW, Loop forever, printing 1
    IM IN YR l
        VISIBLE 1
    IM OUTTA YR l
OIC

KTHXBYE

C, 37 ไบต์

วิธีการต่าง ๆ ใน C

main(c){for(gets(&c);putchar(c)&1;);}

cค่าเริ่มต้นไปยังintของมูลค่า 1. gets(&c)ได้รับสตริงจากstdinที่นี่ clobbering ค่าของc, hackishly ตั้งแต่ไม่ได้เป็นc พิมพ์ค่าของการและผลตอบแทน เนื่องจากเป็น 48 และ49 ใน ASCII เราสามารถใช้บิตสุดท้าย ( ) เพื่อกำหนดว่ามันคืออะไร ถ้ามันวนซ้ำ ไม่อย่างนั้นมันจะไปตลอดกาลchar*putchar(c)cstdoutc'0''1'&1'0'

คอมไพล์ (มีคำเตือนเกี่ยวกับgets) และทำงานภายใต้gcc-4.8บน Linux

เขาวงกต 7 ไบต์

 ?+
@!:

Labyrinth เป็นภาษาสแต็ก 2D ที่การควบคุมการไหลขึ้นอยู่กับสัญลักษณ์ขององค์ประกอบด้านบนของสแต็กซึ่งตรวจสอบทุก ๆ คำสั่ง ?การดำเนินการเริ่มการเคลื่อนย้ายทางขวาจากการเรียนการสอนที่ถูกต้องเป็นครั้งแรกในแถวบนสุดซึ่งที่นี่เป็น

คำแนะนำที่เกี่ยวข้องคือ:

?      Input integer
+      Add top two elements (Labyrinth's stack has infinite 0s on the bottom)
:      Duplicate top element
!      Output as number
@      Terminate program

หากอินพุตเป็น 0 IP จะอ่านอินพุตด้วย?เพิ่มสองอันดับแรกของสแต็ก ( 0 + 0 = 0) จากนั้นทำซ้ำ:และเอาท์พุท!0 ที่นี่เราพบจุดเชื่อมต่อเดี่ยวในโปรแกรมและต้องตรวจสอบด้านบนของสแต็กเพื่อพิจารณา ว่าจะไปที่ไหน. ตั้งแต่ด้านบนเป็น 0 @เราก้าวไปข้างหน้าและยุติด้วย

ในทางตรงกันข้ามถ้าใส่คือ 1, การเรียนการสอนที่เราทำเช่นเดียวกับก่อน ( แต่ outputting 1) !ก่อนที่จะถึงทางแยกที่ ?ตอนบนของสแต็คเป็นบวกทำให้เราเลี้ยวขวาเข้าสู่ เมื่อวันที่ EOF เขาวงกตดัน 0 ดังนั้นเราจึงทำ0 + 1 = 1ที่+ซ้ำกันและเอาท์พุท: !อีกครั้งเรามี 1 ที่ด้านบนสุดของสแต็กและลูปจะดำเนินต่อไป

สำหรับโบนัสนี่เป็นโซลูชั่น 7 ไบต์ของ @ MartinBüttnerซึ่งทำงานคล้ายกัน:

?+!@
1!

โปรดทราบว่าแตกต่างจากภาษาส่วนใหญ่1จริง ๆ โผล่nออกมาจากกองและผลักn*10 + 1ทำให้การสร้างจำนวนมากง่าย อย่างไรก็ตามเนื่องจากส่วนบนสุดของสแต็กว่างเปล่า ณ จุดนั้นจึงไม่แตกต่างจากเพียงแค่กด 1

> <> , 7 ไบต์

i2%:n:,

สิ่งนี้ใช้ความจริงที่ว่า> <> พุช -1 บน EOF ซึ่งคือ 1 mod 2 นอกจากนี้ยังใช้การหารด้วย 0 สำหรับการเลิกจ้าง (ซึ่งเห็นได้ชัดว่าไม่เป็นไร

สำหรับการอ้างอิงเท่านั้นการออกโดยไม่มีข้อผิดพลาดเป็นไบต์พิเศษ

i2%:n?!;

APL, 6 ไบต์

→⎕←⍣⍲⎕

คำอธิบาย:

     ⎕ Read the input, then
 ⎕←    write it out
   ⍣   repeatedly
    ⍲  until NAND of it with itself becomes true.
→      Branch to zero to avoid printing the result again.

Brian & Chuckขนาด 21 ไบต์

,}<-{-?<SOH>_{+?
_>+{?<.p

ที่นี่<SOH>ควรถูกแทนที่ด้วยอักขระควบคุมที่สอดคล้องกัน (0x01)

คำอธิบาย

แนวคิดพื้นฐานคือการลบรหัสอักขระของอินพุต (48 หรือ 49) จากpตอนท้ายของ Chuck ซึ่งจะให้?(ซึ่งเป็นคำสั่งที่ถูกต้อง) หรือ a @-no

,อ่านอักขระอินพุตในเซลล์แรกของ Chuck (ทำเครื่องหมายด้วย_) เราต้องการลดค่านี้ลง0ในลูปในขณะที่ทำการเปลี่ยนแปลงอื่น ๆ :

}<ย้ายไปที่pและ-ลดค่ามัน จากนั้น{เลื่อนกลับไปที่การ-ลดลงของเซลล์อินพุตเช่นกัน ตราบใดที่นี่ยังไม่เป็นศูนย์?ให้การควบคุมกับชัค ตอนนี้>ย้ายส่วนหัวของเทปของไบรอันหนึ่งเซลล์ไปทางขวา (ซึ่งถูกกำหนดค่าเริ่มต้น1) และ+เพิ่มขึ้น {?แล้วเรารีเซ็ตวงด้วย

เมื่อถึงเวลาที่ถือเป็นครั้งแรกในชัคฮิต0ที่<SOH>มือถือจะได้รับเพิ่มขึ้นให้กับตัวละครที่เราได้อ่านจาก STDIN และpจะเป็น?สำหรับการป้อนข้อมูล1หรือสำหรับการป้อนข้อมูล@0

ตอนนี้?ไม่สลับการควบคุมอีกต่อไป 0หรือ1หลังจากที่มันเป็น no-op ที่เป็นโมฆะไบต์ (แสดง_) {ย้ายกลับไปที่เซลล์แรกของชัคและ+เพิ่มขึ้นเพื่อให้แน่ใจว่าเป็นบวกเช่นนั้น?มือควบคุมไปยังชัค

เวลานี้>+เพิ่มเซลล์หลังจากสิ้นสุดเทปเริ่มต้นของ Brian เซลล์นั้นเป็นขยะ แต่เราจะไม่ใช้มัน ตอนนี้{ไม่ได้สแกนไปทางด้านหน้าของเทปของไบรอัน _แต่เฉพาะกับ ดังนั้นจึง?ไม่มีการ op เพราะเซลล์ปัจจุบันเป็นศูนย์ จากนั้น<.เลื่อนหนึ่งไปทางซ้าย (สำเนาของอักขระอินพุต) และพิมพ์

สุดท้ายเราพบหรือ? @หากอินพุตเป็น0และเซลล์นี้เป็น@แบบไม่ใช้งานและโปรแกรมจะหยุดทำงาน แต่ถ้าอินพุตเป็น1และเซลล์นี้คือ?เราส่งมอบให้กับไบรอันซึ่ง{+?จะรีเซ็ตวนรอบบนชัคและตอนนี้เรากำลังพิมพ์1ของตลอดไป (จนกระทั่งจำนวนเต็มในเซลล์ที่ส่วนท้ายของเทปของไบรอันไม่พอดีกับหน่วยความจำใด ๆ มากกว่านั้นฉันคิดว่า ... )

โบนัส

Sp3000 และฉันเล่นกอล์ฟมาหลายวันแล้ว เราเริ่มต้นประมาณ 40 ไบต์และมาถึงสองวิธีที่แตกต่างกันอย่างสมบูรณ์ แต่เชื่อมโยงโซลูชันที่ 26 ไบต์ เมื่อฉันเริ่มเขียนคำอธิบายสำหรับของฉันแล้วโซลูชัน 21 ไบต์ข้างต้นเกิดขึ้นกับฉัน ต้องขอบคุณ Sp สำหรับการขว้างความคิดไปรอบ ๆ และสอนเทคนิคการตีกอล์ฟให้กับ B&C :)

นี่คือโซลูชัน 26 ไบท์ของเขา:

>,----{?{>1?0
#I<?_}<.<<<?

และนี่คือของฉัน:

,{>-<-?_0+?_1{<?
_®{?_{>.?

ที่ไหน®เป็นไบต์ที่มีมูลค่า 174 (เช่นเพียงแค่บันทึกไฟล์เป็น ISO 8859-1)

ที่เหมืองหลักทำงานคล้ายกับโซลูชั่น 21- ไบต์ซึ่ง®กลายเป็น}อินพุต1และ~(ไม่มี op) สำหรับอินพุต0แต่การประมวลผลนั้นสวยงามน้อยกว่ามาก

วิธีแก้ปัญหาของเขาค่อนข้างเรียบร้อยในซอร์สโค้ดนั้นเป็นแบบ ASCII เท่านั้นและไม่ต้องใช้ลูปในการประมวลผลอินพุต ให้----เปลี่ยน1เป็น-และ0เปลี่ยน,(ไม่มี op สำหรับ Chuck) แทน ที่-จะเปลี่ยนคนแรก?ในเทปของไบรอันเป็น>ดังนั้นการสร้างการควบคุมการไหลที่แตกต่างกันสำหรับ1-case

แท็กวงจร Bitwise 3 บิตหรือ <1 ไบต์

แท็ก Cyclic Bitwise เป็นหนึ่งในภาษาทัวริงที่สมบูรณ์แบบที่ง่ายที่สุดออกมี จะทำงานร่วมกับสอง bitstrings ที่โปรแกรมและข้อมูล บิตของโปรแกรมจะถูกอ่านแบบวนรอบและตีความดังนี้:

• 0: ลบบิตข้อมูลแรก (และส่งออกในการนำไปใช้งานที่มีเอาต์พุต)
• 1x: ถ้าบิตแรกของข้อมูล1ให้ผนวกx(แทนอย่างใดอย่างหนึ่ง0หรือ1) ที่ส่วนท้ายของข้อมูล (ถ้าบิตแรกของข้อมูลคือ0ไม่ทำอะไรเลย)

โปรแกรมรันจนกว่าสตริงข้อมูลจะว่างเปล่า

ความจริงเครื่อง

110

เมื่อสตริงข้อมูลถูกตั้งค่าเป็น0:

• 111ไม่ได้อะไรเลยเพราะผนวกบิตข้อมูลแรกไม่ได้
• 00ลบ / เอาท์พุท
• ตอนนี้สตริงข้อมูลว่างเปล่าและโปรแกรมหยุดทำงาน

เมื่อสตริงข้อมูลถูกตั้งค่าเป็น1:

• 11ผนวก a 1.
• 01ลบ / เอาท์พุท
• สายอักขระข้อมูลกลับไปเป็นรายการเดียว1และโปรแกรมกลับไปยังจุดเริ่มต้นดังนั้นเราจึงวนซ้ำตลอดไป

GNU sed, 10

:;/1/{p;b}

คำอธิบาย

• : กำหนดป้ายกำกับที่ไม่มีชื่อ
• /1/หากข้อมูลตรงกับ regex 1แล้ว
• p พิมพ์พื้นที่รูปแบบ (เช่น 1)
• b และข้ามกลับไปที่ป้ายกำกับที่ไม่มีชื่อ (ถาวร)
• หากอินพุตไม่เป็น 1 (เช่น 0) พื้นที่รูปแบบจะถูกพิมพ์โดยไม่ถูกแก้ไขและโปรแกรมจะสิ้นสุด

อย่างจริงจัง , 4 3 ไบต์

_{ข้ามออก 4 ยังคงเป็น 4 :(}

,W■

,อ่านค่าจาก STDIN Wเริ่มห่วงที่ทำงานในขณะที่มูลค่าที่ด้านบนของสแต็คเป็น truthy ■กับร่างกาย ■พิมพ์องค์ประกอบสแต็คด้านบนโดยไม่ต้อง popping การวนซ้ำถูกปิดที่ EOF

ในการป้อนข้อมูลของ0ลูปไม่เคยดำเนินการ (เนื่องจาก0เป็นเท็จ) และโปรแกรมสิ้นสุดที่ EOF, popping และพิมพ์โดยอัตโนมัติทุกค่าในสแต็ค กับการป้อนข้อมูลของ1(หรือค่าใด ๆ ที่ไม่ได้0, ""หรือ[]), วงวิ่งเพียบ

ในอันที่จริง , ชั้นนำ,ไม่จำเป็น (ขอบคุณการป้อนข้อมูลโดยปริยาย) นำคะแนนลงไป 2 ไบต์

ถึง 34 ไบต์

1::=12
2::=~1
0::=~0
@::=:::
::=
@

คำอธิบาย:

1::=12 อินสแตนซ์ของสตริงย่อย "1" สามารถกลายเป็น "12"

2::=~1 อินสแตนซ์ของสตริงย่อย "2" สามารถลบออกได้พิมพ์ "1"

0::=~0 อินสแตนซ์ของสตริงย่อย "0" สามารถลบได้โดยพิมพ์ "0"

@::=::: อินสแตนซ์ของสตริงย่อย "@" สามารถถูกแทนที่ด้วยสตริงจากอินพุต

::= รายการสิ้นสุดของกฎการแทนที่

@ สตริงเริ่มต้นคือ "@"

อาร์โนลด์ C, 134 ไบต์

IT'S SHOWTIME
HEY CHRISTMAS TREE i
YOU SET US UP 0         //or 1
STICK AROUND i
TALK TO THE HAND 1
CHILL
TALK TO THE HAND 0
YOU HAVE BEEN TERMINATED

ในขณะที่สิ่งนี้ไม่ได้ให้ความบันเทิงเท่าคำตอบอื่น ๆ ของ ArnoldC แต่ก็มีการตีกอล์ฟ ยกตัวอย่างเช่นการเยื้องไม่จำเป็นและเพื่อให้มีแมโครและ@NO PROBLEMO@I LIED

ทดสอบกับภาษาเวอร์ชันนี้ซึ่งไม่สามารถรับข้อมูลได้

Cubix , 5 6ไบต์

Cubix เป็น @ETHproductions ภาษา 2 มิติใหม่ที่มีคำสั่งล้อมรอบใบหน้าของคิวบ์ ล่ามออนไลน์ ขอบคุณ @ETHproductions สำหรับการบันทึก

!I\@O

สิ่งนี้จะขยายออกไปสู่คิวบ์

  !
I \ @ O
  .

สิ่งนี้เริ่มต้นด้วยIคำสั่ง ใส่จำนวนเต็มลงในสแต็ก
\เปลี่ยนเส้นทางตัวชี้คำแนะนำลงที่ไม่มี op
Oเอาท์พุทค่าตัวเลขของด้านบนของสแต็ค
!ข้ามคำสั่งถัดไป ( @) ถ้าด้านบนของกองจริง สิ่งนี้จะข้ามการ\เปลี่ยนเส้นทางถ้า 1
\เปลี่ยนเส้นทางตัวชี้คำสั่งไปยัง@โปรแกรมออก

สิ่งนี้ใช้ประโยชน์จากข้อเท็จจริงที่ว่าสแต็กไม่ได้ถูกเรียกโดยO ? !คำสั่ง

Foo , 6 ไบต์

&1($i)

อินพุตเป็นฮาร์ดโค้ดที่เป็นอักขระตัวที่สองเนื่องจาก Foo ไม่มีอินพุต STDIN เราไม่เห็นด้วยหรอกเหรอว่าตอนนี้ยอดเยี่ยมมาก? :)

คำอธิบาย

&1          Set current cell to 1
  (  )      Do-while loop (or, at least according to the interpreter)
   $i       Print current cell as int

Perl, 18 + 1 = 19 13 + 1 = 14 ไบต์

print while$_

ทำงานแบบนี้:

echo -n NUM | perl -p truth.pl

ขอบคุณ ThisSuitIsBlackNot (ผู้ที่เป็นวิธีที่ดีกว่าที่ Perl Golfing มากกว่าฉัน) สำหรับการเล่นกอล์ฟที่ห่างออกไปห้าไบต์

> <> , 6 ไบต์

::n?!;

ดันอินพุตบนสแต็กเพื่อเริ่มต้น

:        copy top element on stack
 :       copy top element on stack again
  n      pop and outputs top element
   ?     condition trampoline - pops top element, if it is zero skips next instruction
    !    trampoline skips next instruction
     ;   finish execution