หนึ่งในภารกิจมาตรฐานที่พบบ่อยที่สุด (โดยเฉพาะอย่างยิ่งเมื่อแสดงภาษาการเขียนโปรแกรมที่ลึกลับ) คือการใช้"โปรแกรมแมว" : อ่าน STDIN ทั้งหมดและพิมพ์ไปยัง STDOUT แม้ว่าสิ่งนี้จะตั้งชื่อตามยูทิลิตี้เชลล์ Unix catแต่ก็มีประสิทธิภาพน้อยกว่าของจริงมากซึ่งโดยปกติจะใช้ในการพิมพ์ (และเชื่อมต่อ) หลายไฟล์ที่อ่านจากแผ่นดิสก์

งาน

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

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

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

เนื่องจากนี่เป็นความท้าทายในแต่ละภาษาและไม่ใช่ระหว่างภาษาจึงมีกฎเฉพาะบางภาษา:

หากเป็นไปได้ในภาษาของคุณที่จะแยกแยะโมฆะ null ในสตรีมอินพุตมาตรฐานจาก EOF โปรแกรมของคุณจะต้องสนับสนุน null ไบต์เช่นไบต์อื่น ๆ (นั่นคือพวกเขาจะต้องถูกเขียนไปยังสตรีมเอาต์พุตมาตรฐานด้วย)
หากเป็นไปได้ในภาษาของคุณที่จะสนับสนุนการป้อนข้อมูลแบบไม่มีที่สิ้นสุดโดยพลการ (เช่นถ้าคุณสามารถเริ่มพิมพ์ไบต์ไปยังเอาต์พุตก่อนที่คุณจะกด EOF ในอินพุต) โปรแกรมของคุณจะต้องทำงานอย่างถูกต้องในกรณีนี้ เป็นตัวอย่างyes | tr -d \\n | ./my_catควรพิมพ์กระแสไม่สิ้นสุดของys มันขึ้นอยู่กับคุณว่าคุณพิมพ์และส่งกระแสข้อมูลมาตรฐานบ่อยแค่ไหน แต่ต้องรับประกันว่าจะเกิดขึ้นหลังจากระยะเวลา จำกัด โดยไม่คำนึงถึงกระแส (โดยเฉพาะอย่างยิ่งหมายความว่าคุณไม่สามารถรอตัวละครที่เฉพาะเจาะจงเช่น ตัวป้อนบรรทัดก่อนพิมพ์)

โปรดเพิ่มหมายเหตุลงในคำตอบของคุณเกี่ยวกับพฤติกรรมที่แน่นอนเกี่ยวกับ null-bytes, infinite stream และเอาท์พุตภายนอก

กฎเพิ่มเติม

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

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

โปรดทราบว่าจะต้องมีล่ามเพื่อให้สามารถส่งการทดสอบได้ ได้รับอนุญาต (และสนับสนุนให้) เขียนล่ามนี้ด้วยตัวคุณเองสำหรับภาษาที่ยังไม่ได้ใช้งานมาก่อน

นอกจากนี้ทราบว่าภาษาไม่ต้องปฏิบัติตามเกณฑ์ปกติของเราสำหรับการเขียนโปรแกรมภาษา
หากภาษาที่คุณเลือกนั้นแตกต่างจากภาษาอื่น (อาจเป็นที่นิยมมากกว่า) ซึ่งมีคำตอบอยู่แล้ว (คิดว่าภาษาเบสิกหรือภาษา SQL, เชลล์ Unix หรืออนุพันธ์ Brainfuck ที่น่าสนใจเช่น Headsecks หรือ Unary) ให้เพิ่มบันทึกย่อลงในคำตอบที่มีอยู่ว่า วิธีการแก้ปัญหาที่เหมือนกันหรือคล้ายกันมากนั้นก็สั้นที่สุดในภาษาอื่น
จนกว่าพวกเขาจะได้รับการตกไปก่อนหน้านี้ทุกมาตรฐานรหัสกอล์ฟกฎรวมทั้งhttp://meta.codegolf.stackexchange.com/q/1061

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

แค็ตตาล็อก

สแต็คส่วนย่อยที่ด้านล่างของโพสต์นี้สร้างแคตตาล็อกจากคำตอบ 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: 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>

ขยายตัวอย่างข้อมูล

code-golf string

— Martin Ender
แหล่งที่มา

52

Bash ขนาด 3 ไบต์ :cat

— TheDoctor

3

@TheDoctor ฉันคิดว่านี่จะตกอยู่ในกฎ "อย่าใช้ builtin ซึ่งทำสิ่งที่จำเป็น" กฎ

— Paŭlo Ebermann

5

@ PaŭloEbermannไม่มีกฎดังกล่าวและไม่สามารถยอมรับช่องโหว่มาตรฐานที่เกี่ยวข้องได้อีกต่อไป (ในความเป็นจริงมีอยู่แล้วshคำตอบโดยใช้catซึ่งนอกจากนี้ยังมีวิธีการแก้ปัญหาโดยใช้สั้นdd.)

— มาร์ตินเอนเดอร์

1

ถ้าเพียง แต่จะใช้วิธีการมาตรฐานของอินพุตและเอาต์พุต: ///, 0 ไบต์

— สหาย SparklePony

1

@SparklePony ยกเว้นคุณจะต้องหลีกเลี่ยงเครื่องหมายทับและแบ็กสแลช

— Martin Ender

73

sed, 0

sedโปรแกรมเปล่าทำสิ่งที่ต้องการตรงนี้:

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

— การบาดเจ็บทางดิจิตอล
แหล่งที่มา

3

จะเกิดอะไรขึ้นถ้ามีคนเขียนyes | tr -d \\n | sed ''?

— BenGoldberg

@BenGoldberg โดยค่าเริ่มต้น sed ทำงานเป็นพื้นฐานต่อบรรทัดดังนั้นในกรณีนี้มันจะยังคง slurping ขึ้นyeses ในบัฟเฟอร์รูปแบบเดียวจนกว่าจะหมดหน่วยความจำ คำเตือนฉันคิดว่า ...

— Digital Trauma

POSIX สั่งว่าพื้นที่รูปแบบต้องมีขนาดอย่างน้อย 8192 ไบต์, IIRC ฉันรู้ว่าการนำ GNU ไปใช้นั้นมีพื้นที่รูปแบบไดนามิก จำกัด ด้วยหน่วยความจำที่มีอยู่เท่านั้นดังนั้นคุณจึงปลอดภัยกับมัน

— Toby Speight

59

Ziim , 222 201 196 185 182 ไบต์

    ↓ ↓

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

   ⤡

นี่อาจจะแสดงไม่ถูกต้องในเบราว์เซอร์ของคุณดังนั้นนี่คือแผนภาพของรหัส:

ฉันไม่สามารถนึกถึงโครงสร้างที่ง่ายกว่านี้ในการแก้ปัญหาใน Ziim แต่ฉันแน่ใจว่ารหัสจริงยังคงสามารถเล่นกอล์ฟได้

Ziim ไม่สามารถจัดการกับสตรีมที่ไม่มีที่สิ้นสุดได้เพราะมันเป็นไปได้ที่จะพิมพ์อะไรก็ได้เมื่อสิ้นสุดโปรแกรม

การอธิบาย

เนื่องจาก Ziim มีรูปแบบการไหลที่ไม่เหมือนใครการควบคุมการเปิดเผยจึงเป็นอัลกอริธึม pseudocode ที่มีความจำเป็นซึ่งจะไม่ตัดที่นี่ แต่ฉันจะอธิบายพื้นฐานของ Ziim และนำเสนอโครงสร้าง tidied up ของโค้ดข้างต้น (ในลักษณะกราฟิกที่คล้ายกัน) เป็นศิลปะ ASCII

การไหลของการควบคุมใน Ziim เกิดขึ้นทั่วทุกที่: ลูกศรแต่ละอันที่ไม่ได้ชี้ไปที่ลูกศรอื่นจะเริ่มต้น "เธรด" ซึ่งประมวลผลแยกกันจากลูกอื่น ยกเว้นว่าคุณเชื่อมข้อมูลผ่านการต่อข้อมูล) {0}แต่ละหัวข้อดังกล่าวถือเป็นรายการตัวเลขไบนารีเริ่มต้นเป็น ตอนนี้ลูกศรแต่ละตัวในรหัสคือคำสั่งบางประเภทซึ่งมีอินพุตหนึ่งหรือสองอินพุตและเอาต์พุตหนึ่งหรือสองตัว คำสั่งที่แน่นอนขึ้นอยู่กับจำนวนลูกศรชี้ไปที่ทิศทาง

นี่คือรายการคำสั่งที่m -> nระบุว่าคำสั่งรับmอินพุตและสร้างnเอาต์พุต

1 -> 1, no-op : เพียงเปลี่ยนเส้นทางเธรด
1 -> 1, invert : negates แต่ละบิตในเธรด (และเปลี่ยนเส้นทาง)
1 -> 1, read : แทนที่ค่าของเธรดด้วยบิตถัดไปจาก STDIN หรือโดยรายการว่างเปล่าหากเรากด EOF
2 -> 1, concatenate : นี่เป็นวิธีเดียวในการซิงค์เธรด เมื่อเธรดไปถึงด้านใดด้านหนึ่งของลูกศรเธรดนั้นจะถูกระงับจนกว่าเธรดอื่นจะเข้าสู่อีกฝั่ง ณ จุดนั้นพวกเขาจะถูกตัดแบ่งเป็นเธรดเดี่ยวและดำเนินการต่อ
2 -> 1, label : นี่เป็นวิธีเดียวที่จะเข้าร่วมเส้นทางการดำเนินการที่แตกต่างกัน นี่เป็นเพียง no-op ซึ่งมีสองอินพุตที่เป็นไปได้ ดังนั้นหัวข้อที่ป้อน "ป้ายกำกับ" ผ่านเส้นทางใดเส้นทางหนึ่งจะถูกเปลี่ยนเส้นทางไปในทิศทางเดียวกัน
1 -> 2, split : รับเธรดเดี่ยวและส่งสำเนาสองชุดออกไปในทิศทางที่ต่างกัน
1 -> 1, isZero? : กินบิตแรกของเธรดและส่งเธรดในหนึ่งในสองทิศทางขึ้นอยู่กับว่าบิตเป็น 0 หรือ 1
1 -> 1, isEmpty? : กินรายการทั้งหมด (เช่นแทนที่ด้วยรายการที่ว่างเปล่า) และส่งเธรดในหนึ่งในสองทิศทางขึ้นอยู่กับว่ารายการนั้นว่างเปล่าหรือไม่

ดังนั้นในใจเราสามารถหากลยุทธ์ทั่วไปได้ การใช้การต่อข้อมูลเราต้องการผนวกบิตใหม่เข้ากับสตริงซึ่งแสดงถึงอินพุตทั้งหมดซ้ำ ๆ เราสามารถทำได้โดยการวนเอาท์ของconcatenateกลับไปเป็นหนึ่งในอินพุตของมัน (และเราเริ่มต้นสิ่งนี้ในรายการที่ว่างเปล่าโดยการล้าง a {0}ด้วยisEmpty? ) คำถามคือเราจะยุติกระบวนการนี้ได้อย่างไร

นอกเหนือไปจากการผนวกบิตในปัจจุบันเรายังจะย่อหน้า 0 หรือ 1 ระบุว่าเราได้มาถึง EOF ถ้าเราส่งสายของเราผ่านisZero? มันจะกำจัดบิตนั้นอีกครั้ง แต่ให้เราแยกแยะจุดสิ้นสุดของกระแสข้อมูลในกรณีที่เราปล่อยให้เธรดออกจากขอบของตาราง (ซึ่งทำให้ Ziim พิมพ์เนื้อหาของเธรดไปยัง 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}s จะถูกป้อนเข้าสู่ "loop" loop (อันหนึ่งกลับไม่เป็นหนึ่ง) เพื่อให้เราจัดหา0s และ1s ได้ไม่ จำกัดซึ่งเราจำเป็นต้องเพิ่มเข้าไปในสตริง

— Martin Ender
แหล่งที่มา

29

คุณจะเขียนโปรแกรมแบบนี้ได้อย่างไรโดยที่สมองของคุณไม่ระเบิดเป็นเนื้อเยื่อชิ้นเล็ก ๆ

— Ashwin Gupta

40

Hexagonyขนาด 6 ไบต์

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

วิธีที่ปราศจากข้อผิดพลาด (เช่นที่ทำงานกับล่ามแบบคงที่) กลายเป็นเรื่องยากกว่ามาก ฉันมีปัญหาในการบีบมันลงในตาราง 2x2 แต่ฉันพบทางออกหนึ่งตอนนี้แม้ว่าฉันต้องการ7 ไบต์เต็ม:

<)@,;.(

หลังจากแฉเราจะได้รับ:

เนื่องจากขอบหน่วยความจำเริ่มต้นคือ 0 การ<เบี่ยงเบนโดยไม่มีเงื่อนไขทำให้ตัวชี้คำสั่งเข้าไปในแนวทแยงมุมทิศตะวันออกเฉียงเหนือซึ่งมันล้อมรอบเส้นทางสีเทา .เป็น no-op ตอนนี้,อ่านไบต์)เพิ่มขึ้นว่าไบต์ที่ถูกต้อง (รวมถึง null null) เป็นบวกและ EOF เป็น 0

ดังนั้นใน EOF IP จะตัดไปที่พา ธ สีแดงซึ่ง@จะยุติโปรแกรม แต่ถ้าเรายังอ่านไบต์แล้ว IP จะตัดกับพา ธ สีเขียวแทนโดย(ลดค่าขอบไปที่ค่าดั้งเดิมก่อนที่จะ;พิมพ์ลงใน STDOUT ตอนนี้ IP จะย้อนกลับไปที่เส้นทางสีเทาโดยไม่มีเงื่อนไข

หลังจากเขียนสคริปต์เดรัจฉานบังคับสำหรับคำตอบ Truth Machine ของฉันฉันตั้งค่าให้ค้นหาโซลูชัน6 ไบต์ที่ปราศจากข้อผิดพลาดสำหรับโปรแกรม cat ด้วย น่าประหลาดใจที่มันพบหนึ่ง - ใช่ว่าวิธีการแก้ปัญหาหนึ่งในโปรแกรมที่เป็นไปได้หกไบต์ Hexagony ทั้งหมด หลังจาก 50 โซลูชั่นจากเครื่องความจริงมันค่อนข้างน่าแปลกใจ นี่คือรหัส:

~/;,@~

แฉ:

การใช้~(unary negation) แทนที่จะ()เป็นสิ่งที่น่าสนใจเพราะ a) มันไม่มีค่าศูนย์, b) มันสลับข้างของสาขา, c) ในบางรหัส~อาจใช้สองครั้งเพื่อยกเลิกการทำงานด้วยตัวเอง . ดังนั้นนี่คือสิ่งที่เกิดขึ้น:

ครั้งแรก (เส้นทางสีม่วง) เราผ่าน~มันเป็นไม่มี การ/สะท้อน IP เข้าสู่เส้นทแยงมุมทิศตะวันตกเฉียงเหนือ -1เส้นทางสีเทาตอนนี้อ่านตัวอักษรและคูณรหัสอักขระของตนโดย สิ่งนี้จะเปลี่ยน EOF ( -1) เป็นค่าความจริง (บวก) และอักขระที่ใช้ได้ทั้งหมดเป็นค่าเท็จ (ไม่เป็นบวก) ในกรณีของ EOF IP จะใช้พา ธ สีแดงและรหัสจะถูกยกเลิก ในกรณีของตัวละครที่ถูกต้อง IP ใช้เส้นทางสีเขียวที่~ยกเลิกการปฏิเสธและ;พิมพ์ตัวละคร ทำซ้ำ

ในที่สุดนี่คือ 3-byte version ซึ่งเคยทำงานในล่าม Hexagony รุ่นดั้งเดิม

,;&

เช่นเดียวกับคำตอบเขาวงกตสิ่งนี้จะจบลงด้วยข้อผิดพลาดหากกระแสข้อมูลเข้ามี จำกัด

หลังจากเปิดตัวโค้ดมันสอดคล้องกับตารางฐานสิบหกต่อไปนี้:

The .no-ops การดำเนินการเริ่มต้นบนเส้นทางสีม่วง

,อ่านไบต์;เขียนไบต์ จากนั้นการประมวลผลจะดำเนินต่อไปบนเส้นทางปลาแซลมอน (ish?) เราต้องการที่&จะรีเซ็ตขอบหน่วยความจำปัจจุบันเป็นศูนย์เช่นที่ IP กระโดดกลับไปที่แถวสีม่วงเมื่อกดปุ่มที่มุมท้ายแถวที่สอง เมื่อพบ,EOF แล้วจะกลับมา-1ซึ่งทำให้เกิดข้อผิดพลาดเมื่อ;พยายามพิมพ์

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

— Martin Ender
แหล่งที่มา

2

เวอร์ชั่น 6 ไบต์นั้นฉลาดและชาญฉลาดมาก การสืบตระกูลของสัตว์เดรัจฉานนั้นยอดเยี่ยมมาก

— ETHproductions

คุณมีลิงค์ไปสู่สัตว์เดรัจฉานของคุณหรือไม่?

— MD XF

@MDXF ฉันไม่ได้เก็บรุ่นต่าง ๆ ไว้รอบตัว แต่มันก็มีการแก้ไขสคริปต์ Ruby นี้อยู่เสมอ

— Martin Ender

36

TeaScript , 0 ไบต์

TeaScript เป็นภาษากอล์ฟที่รวบรัดรวบรวมไว้ใน JavaScript

ในการอัพเดตล่าสุดอินพุตจะถูกเพิ่มโดยนัยเป็นคุณสมบัติแรก

ลองออนไลน์

อีกทางเลือกหนึ่ง 1 ไบต์

xมีอินพุตใน TeaScript เอาท์พุทเป็นนัย

— Downgoat
แหล่งที่มา

ผมกำลังจะโพสต์นี้ :)

— Kritixi Lithos

5

ฮะผมคิดว่า "อีกทางเลือกหนึ่ง" เป็นชื่อภาษา ...

— Quelklef

28

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

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

ฉันเริ่มสร้างภาษานี้เพื่อสร้างภาษาการเขียนโปรแกรมที่ดูเหมือนจะใช้ไม่ได้เท่านั้น มันกลายเป็นว่าการออกกำลังกายที่ดีมากสำหรับปัญหากอล์ฟง่าย ๆ ในนั้น

พื้นฐาน:แต่ละบรรทัดทั้งสองกำหนดโปรแกรมคล้าย Brainfuck ซึ่งทำงานกับซอร์สโค้ดของโปรแกรมอื่น - โปรแกรมแรกเรียกว่าไบรอันและที่สองเรียกว่าชัค มีเพียงไบรอันเท่านั้นที่สามารถอ่านและมีเพียงชัคเท่านั้นที่สามารถเขียนได้ แทนที่จะเป็นลูปของ Brainfuck คุณมี?สิ่งที่ผ่านการควบคุมไปยังโปรแกรมอื่น (และบทบาทของตัวชี้คำสั่งและการเปลี่ยนแปลงหัวเทปเช่นกัน) นอกเหนือจาก Brainfuck คือ{และ}ที่สแกนเทปสำหรับเซลล์ที่ไม่เป็นศูนย์แรก (หรือท้ายซ้าย) นอกจากนี้_จะถูกแทนที่ด้วยไบต์ว่าง

แม้ว่าฉันจะไม่คิดว่ามันดีที่สุด แต่ฉันก็มีความสุขกับการแก้ปัญหานี้ ความพยายามครั้งแรกของฉันคือ 84 ไบต์และหลังจากการตีกอล์ฟหลายครั้งด้วย Sp3000 (และรับแรงบันดาลใจบางอย่างจากความพยายามของเขา) ฉันพยายามทำให้ช้าลงเหลือ 44 ครั้งต่อสองสามครั้ง โดยเฉพาะอย่างยิ่ง+}+เคล็ดลับที่ยอดเยี่ยมคือความคิดของเขา (ดูด้านล่าง)

การอธิบาย

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

สิ่ง#นี้เป็นเพียงตัวยึดตำแหน่งเนื่องจากการควบคุมการสลับไม่ได้ดำเนินการกับเซลล์ที่เราเปิด {<{ตรวจสอบให้แน่ใจว่าหัวเทปอยู่ในเซลล์แรกของ Chuck ,อ่าน byte จาก STDIN หรือ-1ถ้าเรากด EOF ดังนั้นเราจึงเพิ่มมันด้วย+เพื่อทำให้มันเป็นศูนย์สำหรับ EOF และไม่ใช่ศูนย์อื่น

สมมติว่าตอนนี้เรายังไม่อยู่ที่ EOF ดังนั้นเซลล์จะเป็นค่าบวกและ?จะเปลี่ยนการควบคุมเป็นชัค }>ย้ายหัวเทป (บนไบรอัน) ไป+ที่_และ?ผ่านการควบคุมกลับไปที่ไบรอัน

{-ตอนนี้จะลดเซลล์แรกใน Chuck หากยังไม่ได้เป็นศูนย์ ?แต่เราผ่านการควบคุมการโยนอีกครั้งกับ คราวนี้}>ย้ายหัวเทปบน Brian สองเซลล์ทางด้านขวาของเซลล์ที่ไม่เป็นศูนย์ล่าสุด เริ่มแรกอยู่ที่นี่:

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

แต่ต่อมาเราจะมีตัวละครอยู่บ้าง ตัวอย่างเช่นหากเราได้อ่านและพิมพ์abcไปแล้วมันจะมีลักษณะเช่นนี้:

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

โดยที่1s อยู่ที่ 1 ไบต์ (เราจะดูว่ามันเกี่ยวกับอะไรในภายหลัง)

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

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

เมื่อเซลล์อินพุตนั้นว่าง?หลังจากนั้น{-จะไม่เปลี่ยนการควบคุมอีกต่อไป จากนั้น>}<ย้ายหัวเทปบน Chuck ไปที่_และควบคุมสวิตช์เพื่อเรียกใช้ครึ่งหลังของ Chuck แทน

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

คุณอาจสงสัยว่าจะเกิดอะไรขึ้นถ้าตัวละครที่เราอ่านเป็นโมฆะ ในกรณีที่มือถือของตัวเองเขียนขึ้นใหม่จะเป็นศูนย์ แต่เนื่องจากมันในตอนท้ายของเทปของไบรอันและเราไม่สนใจที่สิ้นสุดที่คือเราสามารถละเลยที่ นั่นหมายความว่าถ้าการป้อนข้อมูลเป็นab\0deเทปของไบรอันก็จะดูเหมือน:

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

ในที่สุดเมื่อเรากด EOF สิ่งแรก?บนเทปของไบรอันก็จะไม่เป็น op ณ จุดนี้เรายุติโปรแกรม วิธีการแก้ปัญหาไร้เดียงสาจะย้ายไปยังจุดสิ้นสุดของชัคเทปและสวิทช์ควบคุมเช่นว่า termiantes >}>}<?โปรแกรม: นี่คือที่ความคิดที่ชาญฉลาดของ Sp3000 จริง ๆ บันทึกสามไบต์:

+1เปลี่ยนเซลล์แรกโยนเข้าไป นั่นหมายความว่า}มีจุดเริ่มต้นและค้นหาที่_อยู่ตรงกลางของเทปของชัค แทนที่จะข้ามผ่านมันไปเราก็แค่ปิดช่องว่างด้วยการทำให้มันกลายเป็น a 1ด้วย+เช่นกัน ตอนนี้เรามาดูกันว่าส่วนที่เหลือของรหัสของ Brian เกิดขึ้นกับ Chuck ที่ปรับเปลี่ยนนี้อย่างไร ...

{กลับไปที่เซลล์แรกของ Chuck ตามปกติแล้ว-เปลี่ยนกลับเป็นเซลล์ว่าง นั่นหมายความว่า?ไม่มีการใช้งาน แต่ตอนนี้>}<ซึ่งโดยปกติแล้วจะย้ายหัวเทปไปที่กึ่งกลางของเทปของ Chuck เลื่อนไปทางขวาจนสุดเทปของ Chuck ?แล้วผ่านการควบคุมไปยัง Chuck และยกเลิกรหัส มันเป็นเรื่องดีเมื่อสิ่งต่าง ๆ ได้ผล ... :)

— Martin Ender
แหล่งที่มา

25

Haskell ขนาด 16 ไบต์

main=interact id

interactอ่านอินพุตส่งผ่านไปยังฟังก์ชันที่กำหนดเป็นอาร์กิวเมนต์และพิมพ์ผลลัพธ์ที่ได้รับ idเป็นฟังก์ชั่นตัวตนคือมันส่งกลับค่าของมันไม่เปลี่ยนแปลง ต้องขอบคุณความเกียจคร้านของ Haskell ที่interactสามารถทำงานกับอินพุตที่ไม่มีที่สิ้นสุด

— Nimi
แหล่งที่มา

23

sh + binutils, 3 2 ไบต์

dd

ไม่ค่อยชัดเจนเท่าไหร่ จาก @ Random832

เดิม:

cat

ความเจ็บปวดที่เห็นได้ชัด ... : D

— kirbyfan64sos
แหล่งที่มา

12

ฉันจะทำได้ดีกว่า: dd.

— Random832

ฉันกำลังจะทำแมว ... D:

— ev3commander

1

ใช่มันยอดเยี่ยมและทั้งหมด ... แต่ตัวแทน 170 คนสำหรับการพิมพ์cat???

— MD XF

1

@MDXF แล้วใครจะรู้ว่าตัวแทนจาก segfault เป็นเท่าใด? ;)

— caird coinheringaahing

23

Funciton , 16 ไบต์

╔═╗
╚╤╝

(เข้ารหัสเป็น UTF-16 พร้อม BOM)

การอธิบาย

กล่องส่งคืนเนื้อหาของ STDIN ปลายหลวมเอาท์พุทมัน

— Timwi
แหล่งที่มา

19

รหัสเครื่อง Motorola 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 บิต

— Zach Gates
แหล่งที่มา

1

-1 ไม่มีภาพหน้าจอตัวอย่างหรือลิงก์ทดลองใช้ออนไลน์: P (jk)

— MD XF

2

+1 วิธีเดียวที่ฉันสามารถคิดเพิ่มประสิทธิภาพต่อไปนี้จะเพียงแค่ประสานขาเข้ากับขาออกและนำชิปออกจากซ็อกเก็ตของมัน: P

— Wossname

16

Mornington Crescent , 41 ไบต์

Take Northern Line to Mornington Crescent

ฉันไม่รู้ว่า Mornington Crescent สามารถจัดการกับ null null ได้หรือไม่และการอ่านทั้งหมดจะถูกอ่านก่อนที่โปรแกรมจะเริ่มทำงานเนื่องจากเป็นลักษณะของภาษา

— pppery
แหล่งที่มา

15

Brainfuck, 5 ไบต์

,[.,]

เทียบเท่ากับ pseudocode:

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

สิ่งนี้จัดการกับสตรีมที่ไม่มีที่สิ้นสุด แต่ใช้ไบต์ที่ว่างเป็น EOF ไม่ว่า BF จะสามารถจัดการกับค่า null ได้อย่างถูกต้องจะแตกต่างกันไปจากการนำไปใช้งานหรือไม่

— ลินน์
แหล่งที่มา

1

ยี้! คุณเอาชนะฉันไป 5 นาที!

— kirbyfan64sos

ถ้าตัวละครตัวแรกเป็น NULL จะไม่สามารถทำงานได้อย่างถูกต้อง ดังนั้นมันควรจะถูก+[,.]ต้อง?

— Shelvacu

6

@Shel นี่ใช้ 0x00 เป็น EOF byte ถ้าตัวละครตัวแรกคือ EOF มันจะพิมพ์ออกมาไม่ทำงานตามที่คาดไว้

— Mego

2

"pseudocode" โอ้มาแล้วเห็นได้ชัดว่าเป็นเพียงแค่ยกเลิกการวงเล็บ, เซมิโคลอน -ed C: P

— MD XF

14

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

,.

หากกระแสมี จำกัด นี่จะจบลงด้วยข้อผิดพลาด แต่ผลผลิตทั้งหมดที่เกิดจากข้อผิดพลาดไปที่ STDERR ดังนั้นกระแสออกมาตรฐานถูกต้อง

ในขณะที่ Brainfuck ,อ่านไบต์ (ผลักมันลงบนสแต็กหลักของเขาวงกต) และ.เขียนไบต์ (โผล่จากสแต็กหลักของเขาวงกต)

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

เมื่อเราตี EOF ,ดัน-1แทนและ.โยนข้อผิดพลาดเนื่องจาก-1ไม่ได้เป็นรหัสอักขระที่ถูกต้อง สิ่งนี้อาจเปลี่ยนแปลงได้ในอนาคต แต่ฉันยังไม่ได้ตัดสินใจ

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

,)@
.(

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

— Martin Ender
แหล่งที่มา

13

C, 40 ไบต์

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

— เดนนิส
แหล่งที่มา

main () {ในขณะที่ (255-putchar (getchar ()));} สั้นลงสองไบต์

— เล่นแร่แปรธาตุ

1

น่าเศร้าที่มีการออกก่อนกำหนดใน 0xFF ไบต์และผนวก 0xFF ไบต์ต่อท้ายกับอินพุตหากไม่มีอยู่

— เดนนิส

ประมาณ 36 ไบต์: main () {for (;; putchar (getchar ()));};

— Johan du Toit

@ user2943932 เมื่อมันมาถึง EOF getcharจะส่งกลับ-1ดังนั้นรหัสของคุณจะพิมพ์กระแสที่ไม่สิ้นสุดของ 0xFF ไบต์หลังจากที่ป้อน (จำกัด )

— เดนนิส

12

> <> , 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

หากคุณต้องการมันเพื่อให้ไปจนกว่าคุณจะป้อนข้อมูลให้มากขึ้นแทนที่ด้วย;!

— DanTheMan
แหล่งที่มา

ฉันหวังว่าจะโพสต์ข้อความ> <> คำตอบ ... : P (+1!)

— El'endia Starman

1

io(2 ไบต์) ทำสิ่งเดียวกัน แต่ขัดข้องและเขียนsomething smells fishy...ไปยัง STDERR เมื่อสิ้นสุดการประมวลผลซึ่งได้รับอนุญาต

— ลินน์

@Mauris ล่ามออนไลน์จะแสดงผลลัพธ์เป็นไบต์ว่างแทนการลงท้ายด้วยข้อผิดพลาด

— DanTheMan

11

ชุดประกอบ 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

— kirbyfan64sos
แหล่งที่มา

1

ดังนั้นobjdumpถอดชิ้นส่วนมันเป็นรหัส 32 บิตในขณะที่คุณดูเหมือนจะรวบรวมเป็น 16 บิต เชื่ออะไร เมื่อคุณใช้int 0x80ฉันคิดว่ามันมีความหมายสำหรับ Linux แต่ทำไมคอมไพล์เป็น 16 บิตแล้ว?

— Ruslan

@ Ruslan ฉันไม่ได้ตระหนักถึงมันถูกรวบรวมใน 16 บิต ...

— kirbyfan64sos

11

Universal Lambda , 1 ไบต์

โปรแกรม Universal Lambda เป็นการเข้ารหัสคำแลมบ์ดาในไบนารี่, สับเป็นชิ้นจำนวน 8 บิต, เติมเต็มชิ้นส่วนที่ไม่สมบูรณ์ด้วยบิตใด ๆ , แปลงเป็นสตรีมไบท์

บิตถูกแปลเป็นคำแลมบ์ดาดังนี้:

00 แนะนำสิ่งที่เป็นนามธรรมของแลมบ์ดา
01 แสดงให้เห็นถึงการประยุกต์ใช้สองคำที่ตามมา
111..10, โดยมีการซ้ำnของบิต1, หมายถึงตัวแปรของlambda parent n ; นั่นคือดัชนี De Bruijnในเอกภาพ

โดยการแปลงนี้0010เป็นฟังก์ชั่นตัวตนλa.aซึ่งหมายความว่าโปรแกรมไบต์เดียวใด ๆ ของรูปแบบ0010xxxxเป็นcatโปรแกรม

— ลินน์
แหล่งที่มา

1

แต่!เป็น0x21ไม่ได้0x4_?

— wchargin

แก้ไขแล้ว. --------

— ลินน์

10

PowerShell, 88 41 30 ไบต์

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

_{แก้ไข - ลืมว่าฉันสามารถใช้$inputตัวแปรอัตโนมัติสำหรับการป้อนข้อมูลไปป์ไลน์} ... _{EDIT2 - ไม่จำเป็นต้องทดสอบการมีอยู่ของ$input}

ใช่แล้ว ... STDIN ใน 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นั้นได้ (ในทางทฤษฎี) ควรจะทำงาน

ทำความรู้จักกับ ForEach และ ForEach-Objectบน Microsoft "Hey, Scripting Guy!" บล็อก

ดังนั้นย่อหน้าเหล่านี้จึงอธิบายว่าทำไมจึงif($input){$input}มีอยู่ เรารับพารามิเตอร์อินพุตที่สร้างขึ้นเป็นพิเศษโดยอัตโนมัติหากมีอินพุตไพพ์ไลน์ทดสอบว่ามีอยู่หรือไม่และหากเป็นเช่นนั้น

จากนั้นเราจะรับข้อมูลจากผู้ใช้(read-host)ผ่านสิ่งที่เป็นกระแส STDIN แยกต่างหากและwrite-hostมันกลับออกมาพร้อมกับ-nตั้งค่าสถานะ (ย่อมาจาก-NoNewLine) โปรดทราบว่าสิ่งนี้ไม่สนับสนุนการป้อนความยาวโดยพลการเนื่องจากread-hostจะเสร็จสิ้นเมื่อป้อนบรรทัดเท่านั้น (โดยทางเทคนิคเมื่อผู้ใช้กด "Enter" แต่เทียบเท่ากับการใช้งาน)

วุ้ย.

¹แต่มีตัวเลือกอื่น ๆ :

ตัวอย่างเช่นหากเรากังวลกับการป้อนข้อมูลไปป์ไลน์เพียงอย่างเดียวและเราไม่ต้องการโปรแกรมเต็มรูปแบบคุณสามารถทำสิ่ง| $_ที่ต้องการส่งออกสิ่งที่เป็นอินพุต _{(โดยทั่วไปนั่นค่อนข้างซ้ำซ้อนเนื่องจาก PowerShell มีเอาท์พุทโดยปริยายของสิ่งต่าง ๆ "ทิ้งไว้ข้างหลัง" หลังจากการคำนวณ แต่นั่นเป็นสิ่งที่กัน)}

หากเรากังวลกับอินพุตผู้ใช้แบบโต้ตอบเท่านั้นเราสามารถwrite-host(read-host)-nใช้ได้

นอกจากนี้ฟังก์ชั่นนี้มีคุณสมบัติที่~~แปลกประหลาด~~ในการยอมรับอินพุตบรรทัดคำสั่งเช่น.\simple-cat-program.ps1 "test"จะเติม (และจากนั้นเอาท์พุท) $aตัวแปร

— AdmBorkBork
แหล่งที่มา

อย่าลืมนามแฝงของคุณ!

— Chad Baxter

10

Cubix , 6 5 ไบต์

ตอนนี้จัดการไบต์ว่าง!

@_i?o

Cubix เป็น esolang 2 มิติแบบกองซ้อน Cubix นั้นแตกต่างจาก langings 2D อื่น ๆ ซึ่งซอร์สโค้ดจะถูกล้อมรอบด้านนอกของ cube

ทดสอบออนไลน์! หมายเหตุ: มีการหน่วงเวลา 50 ms ระหว่างการวนซ้ำ

การอธิบาย

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

  @
_ i ? o
  .

ตอนนี้รันโค้ด IP (ตัวชี้คำสั่ง) เริ่มต้นที่ใบหน้าซ้ายสุดชี้ไปทางทิศตะวันออก

อักขระตัวแรกที่พบคือ IP _ซึ่งเป็นกระจกที่เปลี่ยน IP รอบถ้ามันหันไปทางทิศเหนือหรือทิศใต้ ขณะนี้กำลังหันหน้าไปทางทิศตะวันออก ถัดไปคือiอินพุตไบต์จาก STDIN ?เปลี่ยน IP ที่เหลือหากรายการบนสุดเป็นลบหรือถูกถ้าเป็นบวก มีสามเส้นทางที่เป็นไปได้ที่นี่:

หากไบต์อินพุตเป็น -1 (EOF) IP จะเลี้ยวซ้ายและ Hit @ซึ่งจะสิ้นสุดโปรแกรม
หากไบต์ป้อนเป็น 0 (null ไบต์) IP ก็ยังคงตรง outputting oไบต์ด้วย
มิฉะนั้น IP _เลี้ยวขวาเดินทางทั่วใบหน้าล่างและฮิตกระจก มันหมุนไปรอบ ๆ ส่งมันกลับไปที่?ซึ่งหมุนขวาอีกครั้งและส่งไบต์

ฉันคิดว่าโปรแกรมนี้เหมาะสมที่สุด ก่อนที่ Cubix จะสามารถจัดการกับ null null ได้ (EOF คือ 0 ไม่ใช่ -1) โปรแกรมนี้ใช้ได้กับทุกอย่างยกเว้น null null:

.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)

— ETHproductions
แหล่งที่มา

กรุณาอย่าแก้ไขโพสต์โหลในครั้งเดียว คุณกำลังน้ำท่วมหน้าแรก 3 ในแต่ละครั้งไม่ใช่ปัญหา แต่ถ้าคุณต้องทำมากกว่านั้นกรุณาแก้ไขเป็นชุดเล็ก ๆ ทุก ๆ 12 ชั่วโมง

— Martin Ender

@ มาร์ตินขออภัยฉันเพิ่งสังเกตเห็นว่า ฉันจะออกไปข้างนอกในอนาคต

— ETHproductions

9

Vitsy 2 ไบต์

ZZ

zรับอินพุตสแต็กทั้งหมดและส่งไปยังสแต็กของโปรแกรมที่ใช้งานอยู่ Zพิมพ์สแต็กที่แอ็คทีฟทั้งหมดไปยัง STDOUT

วิธีอื่น:

I \ อิลลินอยส์ \ O
I \ Repeat อักขระถัดไปสำหรับความยาวของสแต็กอินพุต
  ฉันหยิบรายการจากอินพุต
   l \ ซ้ำอักขระถัดไปสำหรับความยาวของสแต็กโปรแกรมที่ใช้งานในปัจจุบัน
     เอาท์พุทรายการด้านบนของสแต็กเป็นตัวละคร

— Addison Crump
แหล่งที่มา

2

^ _ ^ มี +1 อยู่แล้ว! :)

— El'endia Starman

สงสารคะแนนโปรดของฉัน!

— Addison Crump

ทำไมต้องลงคะแนน นี่น่าจะเป็นรายการที่ถูกต้องสมบูรณ์

— Conor O'Brien

1

มันเป็นที่ถูกต้องโดยรายละเอียดทั้งหมด

— Addison Crump

9

MarioLANG 11 ไบต์

,<
."
>!
=#

ฉันไม่แน่ใจว่านี่เป็นสิ่งที่ดีที่สุด แต่มันสั้นที่สุดที่ฉันพบ

สิ่งนี้สนับสนุนสตรีมที่ไม่มีที่สิ้นสุดและจะยุติลงด้วยข้อผิดพลาดเมื่อมาถึง EOF (อย่างน้อยการดำเนินการอ้างอิง Ruby)

มีอีกเวอร์ชั่นหนึ่งที่เปลี่ยนมาริโอให้กลายเป็นนินจาที่สามารถกระโดดได้สองเท่า:

,<
.^
>^
==

ในทั้งสองกรณีมาริโอจะเริ่มล้มลงคอลัมน์ซ้ายซึ่ง,อ่านไบต์และ.เขียนไบต์ (ซึ่งมีข้อผิดพลาดที่ EOF เนื่องจาก,ไม่ส่งคืนอักขระที่ถูกต้อง) >รับรองว่ามาริโอเดินไปทางขวา ( =เป็นเพียงพื้นให้เขาเดินไป) จากนั้นเขาก็ขยับขึ้นไม่ว่าจะด้วยการกระโดดสองครั้งด้วย^หรือผ่านลิฟต์ ( "และ#คู่) ก่อนที่<จะบอกให้เขาย้ายกลับไปที่คอลัมน์ด้านซ้าย

— Martin Ender
แหล่งที่มา

8

rs , 0 ไบต์

อย่างจริงจัง. rs เพียงพิมพ์สิ่งที่จะได้รับถ้าสคริปต์ที่ให้นั้นว่างเปล่าอย่างสมบูรณ์

— kirbyfan64sos
แหล่งที่มา

7

GolfScript 3 ไบต์

:n;

โปรแกรมเปล่าสะท้อนเสียงอินพุตมาตรฐาน ภาษาไม่สามารถจัดการกับกระแสข้อมูลไม่สิ้นสุด อย่างไรก็ตามมันจะเพิ่มบรรทัดใหม่ตามที่ @Dennis พูดถึง มันทำได้โดยการตัดทั้งสแต็กในอาร์เรย์และการโทรputsซึ่งถูกกำหนดเป็นprint n printโดยที่nเป็นบรรทัดใหม่ อย่างไรก็ตามเราสามารถกำหนดnให้เป็น STDIN อีกครั้งและล้างสแต็กซึ่งเป็นสิ่งที่:n;ทำ

— ลินน์
แหล่งที่มา

7

รถเสียครึ่งในการจราจรหนาแน่น 9 + 3 = 12 ไบต์

#<
o^<
 v

รถที่เสียครึ่งในการจราจรหนาแน่น (HBCHT) รับอินพุตเป็นบรรทัดคำสั่ง args ดังนั้นให้ทำงานเหมือน

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

โปรดทราบว่า +3 ใช้สำหรับ-sแฟล็กซึ่งเอาต์พุตเป็นตัวอักษร นอกจากนี้ HBCHT ดูเหมือนจะไม่จัดการกับ NUL เนื่องจากศูนย์ทั้งหมดจะถูกดร็อปจากเอาต์พุต (เช่น97 0 98เอาต์พุตเป็นสองตัวอักษรab)

การอธิบาย

ใน HBCHT รถของคุณเริ่มต้นที่และเป้าหมายของคุณคือทางออกo ควบคุมการเคลื่อนไหวของรถในขณะเดียวกันก็ทำการดัดแปลงเทปที่มีลักษณะคล้าย BF ( แปลเป็น) อย่างไรก็ตามตามชื่อภาษารถของคุณสามารถเลี้ยวขวาได้เท่านั้น - ความพยายามใด ๆ ที่จะเลี้ยวซ้ายจะถูกละเว้นอย่างสมบูรณ์ (รวมถึงเอฟเฟกต์หน่วยความจำ) โปรดทราบว่านี่เป็นเพียงการเลี้ยว - รถของคุณสามารถขับไปข้างหน้า / ถอยหลังได้อย่างสมบูรณ์แบบ#^>v<^>v<+>-<

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

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

แก้ไข : ปรากฎว่าล่าม HBCHT ช่วยให้คุณดำเนินการเพียงเส้นทางเดียวผ่านการตั้งค่าบรรทัดคำสั่งเช่น

py -3 hbcht -d left cat.hbc

อย่างไรก็ตามไม่เพียง แต่การตั้งค่าสถานะแพงเกินไปสำหรับคำถามนี้โดยเฉพาะ (อย่างน้อย 5 ไบต์สำหรับ" -d u") ดูเหมือนว่าเส้นทางทั้งหมดยังคงต้องสามารถทำให้จบการทำงานเพื่อให้โค้ดทำงานได้

— SP3000
แหล่งที่มา

7

Minkolang 5 ไบต์

od?.O

ลองที่นี่

การอธิบาย

oอ่านอักขระจากอินพุตและส่งรหัส ASCII ไปยังสแต็ก ( 0หากอินพุตว่าง) dจากนั้นทำซ้ำส่วนบนสุดของสแต็ก (อักขระที่เพิ่งอ่าน) เป็นผ้าใบเงื่อนไขซึ่งกระโดดการเรียนการสอนต่อไปของด้านบนของสแต็คไม่ได้? 0หากอินพุตว่างเปล่าข้อมูล.จะไม่ถูกข้ามและโปรแกรมจะหยุดทำงาน มิฉะนั้นจะOส่งเอาต์พุตด้านบนของสแต็กเป็นอักขระ ธรรมชาติ toroidal ของ Minkolang หมายความว่าสิ่งนี้วนรอบไปที่จุดเริ่มต้น

— El'endia Starman
แหล่งที่มา

2

Grar! คุณเอาชนะภาษาของฉัน! ยอมรับไม่ได้! +1

— Addison Crump

7

INTERCALL , 133 ไบต์

วัด

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

— TuxCrafting
แหล่งที่มา

ดูเหมือนว่าคนที่เล่นกอล์ฟในภาษาต่อต้านการเล่นกอล์ฟอย่างแท้จริง ... 133-116 = 17

— Erik the Outgolfer

@ EʀɪᴋᴛʜᴇGᴏʟғᴇʀเนื่องจากโปรแกรม cat ค่อนข้างง่ายนี่ไม่ใช่กรณีของโปรแกรมทั้งหมด ... codegolf.stackexchange.com/a/82748/53745

— TuxCrafting

คนที่สร้างภาษาที่ตั้งใจจะใช้ตัวเลขโรมัน แต่ถ้าเป็นกรณีที่จะพิมพ์500(ไม่แน่ใจ) มันจะPRINT Dใช่ไหม? (ไม่รวมส่วนหัว)

— Erik the Outgolfer

@ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Nope, InterCall เท่านั้นที่สามารถพิมพ์อักขระ ASCII และใช้กองดังนั้นสำหรับตัวอย่างเช่นการพิมพ์ caracter กับค่า ASCII 20 รหัสหรือPUSH XX<newline>PRINT PUSH XX AND PRINTโอ้และฉันเป็นผู้สร้าง INTERCALL

— TuxCrafting

7

V , 0 ไบต์

ลองออนไลน์!

แนวคิดของ "memory" ของ V เป็นเพียงตัวละครสองมิติขนาดมหึมา ก่อนที่จะรันโปรแกรมใด ๆ อินพุตทั้งหมดที่โหลดลงในอาร์เรย์นี้ (รู้จักในชื่อ "The Buffer") จากนั้นเมื่อสิ้นสุดโปรแกรมใด ๆ ข้อความทั้งหมดในบัฟเฟอร์จะถูกพิมพ์

กล่าวอีกนัยหนึ่งโปรแกรมที่ว่างเปล่าคือโปรแกรมแมว

— DJMcMayhem
แหล่งที่มา

6

Snowman 1.0.2 , 15 chars

(: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

— ลูกบิดประตู
แหล่งที่มา

5

FireType , 7 ไบต์

,
&
_
=

ต้องมีการเปลี่ยนแปลงฉันเพียงแค่ผลักดัน กฎบอกว่า:

แตกต่างจากกฎทั่วไปของเราอย่าลังเลที่จะใช้ภาษา (หรือรุ่นภาษา) แม้ว่าจะใหม่กว่าความท้าทายนี้

ดังนั้นฉันชัดเจน!

— kirbyfan64sos
แหล่งที่มา

5

ฟิชชัน 4 ไบต์

R?J!

มันจะไม่ดีเมื่อคุณเอาชนะโปรแกรมตัวอย่างในพื้นที่เก็บข้อมูลของภาษา? :) สำหรับการอ้างอิงมีโซลูชั่น 7 ไบต์

R?J0;0!

การอธิบาย

ดังนั้นRเริ่มต้นการควบคุมการไหลด้วยอะตอมที่กำลังทำงาน ?อ่านตัวละครจาก STDIN ไปยังมวลของอะตอม ตราบใดที่เรากำลังอ่านตัวละครพลังงานยังคงเป็นศูนย์ดังนั้นJump คือแบบไม่มี op และ!พิมพ์อักขระ อะตอมวนกลับไปที่จุดเริ่มต้น ( Rตอนนี้เป็นแบบไม่มีตัวเลือก) และทำซ้ำกระบวนการทั้งหมด

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

(วิธีแก้ปัญหาจากผู้เขียนภาษาใช้คำสั่ง;เพื่อยกเลิกโปรแกรมซึ่งถูกข้ามไปด้วยสอง0ส่วนอื่น ๆ )

— Martin Ender
แหล่งที่มา

5

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

ไม่มีวิธีการที่แท้จริงในการตรวจหา EOF ดังนั้นการวนซ้ำนี้จึงเหมือนกับคำตอบของ Python

คุณสามารถทำให้หยุดได้อย่างง่ายดายเมื่อกำหนดบรรทัดว่าง (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 ตัวอักษร) นี่เป็นเพราะภายในสตริงถูกแสดงเป็นจำนวนเต็มความแม่นยำที่ไม่เป็นลบโดยพลการและต้องมีตัวอักษรที่ จำกัด ของตัวอักษรเพื่อให้สามารถเข้ารหัสสตริงทั้งหมด

— งานอดิเรกของ Calvin
แหล่งที่มา

โปรแกรมแมวง่าย ๆ

งาน

กฎเพิ่มเติม

แค็ตตาล็อก

sed, 0

Ziim , 222 201 196 185 182 ไบต์

การอธิบาย

Hexagonyขนาด 6 ไบต์

TeaScript , 0 ไบต์

อีกทางเลือกหนึ่ง 1 ไบต์

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

การอธิบาย

Haskell ขนาด 16 ไบต์

sh + binutils, 3 2 ไบต์

เดิม:

Funciton , 16 ไบต์

การอธิบาย

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

การอธิบาย

Mornington Crescent , 41 ไบต์

Brainfuck, 5 ไบต์

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

C, 40 ไบต์

> <> , 7 ไบต์

ชุดประกอบ X86 ขนาด 70 ไบต์

Universal Lambda , 1 ไบต์

PowerShell, 88 41 30 ไบต์

Cubix , 6 5 ไบต์

การอธิบาย

Vitsy 2 ไบต์

MarioLANG 11 ไบต์

rs , 0 ไบต์

GolfScript 3 ไบต์

รถเสียครึ่งในการจราจรหนาแน่น 9 + 3 = 12 ไบต์

การอธิบาย

Minkolang 5 ไบต์

การอธิบาย

INTERCALL , 133 ไบต์

V , 0 ไบต์

Snowman 1.0.2 , 15 chars

FireType , 7 ไบต์

ฟิชชัน 4 ไบต์

การอธิบาย

Shtriped , 20 ไบต์