Salah satu tugas standar yang paling umum (terutama ketika menampilkan bahasa pemrograman esoterik) adalah untuk mengimplementasikan "program cat" : membaca semua STDIN dan mencetaknya ke STDOUT. Meskipun ini dinamai setelah utilitas shell Unix cat, tentu saja jauh lebih kuat daripada yang asli, yang biasanya digunakan untuk mencetak (dan menyatukan) beberapa file yang dibaca dari disk.

Tugas

Anda harus menulis program lengkap yang membaca isi dari aliran input standar dan menulisnya kata demi kata ke aliran output standar. Jika dan hanya jika bahasa Anda tidak mendukung input standar dan / atau aliran keluaran (sebagaimana dipahami dalam sebagian besar bahasa), Anda dapat menggunakan istilah-istilah ini sebagai yang paling dekat dengan bahasa Anda (misalnya JavaScript promptdan alert). Ini adalah satu - satunya bentuk I / O yang dapat diterima, karena antarmuka lain sebagian besar akan mengubah sifat tugas dan membuat jawaban menjadi jauh lebih tidak sebanding.

Keluaran harus mengandung input dan tidak ada yang lain . Satu-satunya pengecualian untuk aturan ini adalah output konstan dari juru bahasa Anda yang tidak dapat ditekan, seperti salam, kode warna ANSI atau lekukan. Ini juga berlaku untuk mengikuti baris baru. Jika input tidak mengandung baris tambahan, output juga tidak boleh termasuk! (Satu-satunya pengecualian adalah jika bahasa Anda benar-benar selalu mencetak baris baru setelah eksekusi.)

Keluaran ke aliran kesalahan standar diabaikan, selama arus keluaran standar berisi keluaran yang diharapkan. Secara khusus, ini berarti program Anda dapat diakhiri dengan kesalahan setelah mencapai ujung aliran (EOF), asalkan tidak mencemari aliran keluaran standar. Jika Anda melakukan ini, saya sarankan Anda untuk menambahkan versi bebas kesalahan ke jawaban Anda juga (untuk referensi).

Karena ini dimaksudkan sebagai tantangan dalam setiap bahasa dan bukan antar bahasa, ada beberapa aturan khusus bahasa:

• Jika mungkin dalam bahasa Anda untuk membedakan byte nol dalam aliran input standar dari EOF, program Anda harus mendukung byte nol seperti byte lainnya (yaitu, mereka juga harus ditulis ke aliran output standar).
• Jika memungkinkan dalam bahasa Anda untuk mendukung aliran input tak terbatas sewenang - wenang (yaitu jika Anda dapat mulai mencetak byte ke output sebelum Anda menekan EOF dalam input), program Anda harus bekerja dengan benar dalam kasus ini. Sebagai contoh yes | tr -d \\n | ./my_catharus mencetak aliran tak terbatas ys. Terserah kepada Anda seberapa sering Anda mencetak dan menyiram aliran output standar, tetapi harus dijamin akan terjadi setelah waktu yang terbatas, terlepas dari aliran (ini berarti, khususnya, bahwa Anda tidak dapat menunggu karakter tertentu seperti linefeed sebelum mencetak).

Harap tambahkan catatan pada jawaban Anda tentang perilaku pasti berkenaan dengan null-byte, aliran tak terbatas, dan output asing.

Aturan tambahan

• Ini bukan tentang menemukan bahasa dengan solusi terpendek untuk ini (ada beberapa di mana program kosong melakukan trik) - ini adalah tentang menemukan solusi terpendek dalam setiap bahasa. Karenanya, tidak ada jawaban yang akan ditandai sebagai diterima.

• Kiriman dalam kebanyakan bahasa akan dinilai dalam byte dalam pengkodean yang sudah ada sebelumnya, biasanya (tetapi tidak harus) UTF-8.

  Beberapa bahasa, seperti Folder , agak sulit untuk dinilai. Jika ragu, silakan tanyakan di Meta .

• Jangan ragu untuk menggunakan bahasa (atau versi bahasa) meskipun itu lebih baru dari tantangan ini. Bahasa yang ditulis khusus untuk mengirimkan jawaban 0-byte untuk tantangan ini adalah permainan yang adil tetapi tidak terlalu menarik.

  Perhatikan bahwa harus ada juru bahasa sehingga pengajuan dapat diuji. Diperbolehkan (dan bahkan dianjurkan) untuk menulis sendiri penerjemah ini untuk bahasa yang sebelumnya tidak diterapkan.

  Juga mencatat bahwa bahasa yang harus memenuhi kriteria kami biasa untuk bahasa pemrograman .

• Jika bahasa pilihan Anda adalah varian sepele dari bahasa lain (yang berpotensi lebih populer) yang sudah memiliki jawaban (pikirkan dialek BASIC atau SQL, cangkang Unix atau turunan Brainfuck sepele seperti Headecks atau Unary), pertimbangkan untuk menambahkan catatan ke jawaban yang ada bahwa solusi yang sama atau sangat mirip juga merupakan yang terpendek dalam bahasa lain.

• Kecuali jika telah ditolak sebelumnya, semua aturan standar kode-golf berlaku, termasuk http://meta.codegolf.stackexchange.com/q/1061 .

Sebagai catatan tambahan, tolong jangan turunkan jawaban yang membosankan (tapi valid) dalam bahasa di mana tidak banyak bermain golf; ini masih berguna untuk pertanyaan ini karena mencoba mengkompilasi katalog selengkap mungkin. Namun, lakukan sebagian besar pilihan jawaban dalam bahasa di mana penulis benar-benar harus berusaha kode golf.

Katalog

Cuplikan Stack di bagian bawah posting ini menghasilkan katalog dari jawaban a) sebagai daftar solusi terpendek per bahasa dan b) sebagai leaderboard keseluruhan.

Untuk memastikan bahwa jawaban Anda muncul, silakan mulai jawaban Anda dengan tajuk utama, menggunakan templat Penurunan harga berikut:

## Language Name, N bytes

di mana Nukuran kiriman Anda. Jika Anda meningkatkan skor Anda, Anda bisa menyimpan skor lama di headline, dengan mencoretnya. Misalnya:

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

Jika Anda ingin memasukkan beberapa angka dalam tajuk Anda (mis. Karena skor Anda adalah jumlah dari dua file atau Anda ingin membuat daftar penalti penterjemah secara terpisah), pastikan bahwa skor aktual adalah angka terakhir di tajuk:

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

Anda juga dapat membuat nama bahasa menjadi tautan yang kemudian akan muncul di cuplikan:

## [><>](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>

sed, 0

Program kosong sedmelakukan persis apa yang diperlukan di sini:

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

Ziim , 222 201 196 185 182 byte

    ↓ ↓

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

   ⤡

Ini mungkin tidak akan ditampilkan dengan benar di browser Anda, jadi di sini adalah diagram kode:

Saya tidak bisa memikirkan struktur yang lebih sederhana untuk menyelesaikan masalah dalam Ziim, tapi saya yakin kode yang sebenarnya masih cukup golf.

Ziim tidak mungkin menangani aliran yang tidak terbatas karena hanya mungkin untuk mencetak apa pun di akhir program.

Penjelasan

Karena Ziim memiliki model aliran kontrol deklaratif yang agak unik, algoritma pseudocode imperatif tidak akan memotongnya di sini. Sebagai gantinya, saya akan menjelaskan dasar-dasar Ziim dan menyajikan struktur rapi dari kode di atas (dengan cara grafis yang serupa) sebagai seni ASCII.

Aliran kendali dalam Ziim terjadi di semua tempat: setiap panah yang tidak diarahkan oleh panah lain akan menginisialisasi "utas" yang diproses secara terpisah dari yang lain (tidak benar-benar paralel, tetapi tidak ada jaminan untuk urutan mana mereka diproses dalam , kecuali Anda menyinkronkannya melalui gabungan). Setiap utas tersebut menyimpan daftar digit biner, mulai dari {0}. Sekarang setiap panah dalam kode adalah semacam perintah yang memiliki satu atau dua input dan satu atau dua output. Perintah yang tepat tergantung pada berapa banyak panah yang menunjuk padanya dari mana orientasi.

Berikut adalah daftar perintah, di mana m -> nmenunjukkan bahwa perintah tersebut mengambil minput dan menghasilkan noutput.

• 1 -> 1, no-op : cukup arahkan utas.
• 1 -> 1, invert : meniadakan setiap bit di utas (dan juga mengalihkannya).
• 1 -> 1, baca : mengganti nilai utas dengan bit berikutnya dari STDIN, atau dengan daftar kosong jika kami telah menekan EOF.
• 2 -> 1, concatenate : ini adalah satu-satunya cara untuk menyinkronkan utas. Ketika utas menyentuh satu sisi panah, itu akan ditangguhkan hingga utas lainnya menyentuh sisi lain. Pada saat itu mereka akan disatukan menjadi satu utas dan melanjutkan eksekusi.
• 2 -> 1, label : ini adalah satu-satunya cara untuk bergabung dengan jalur eksekusi yang berbeda. Ini hanyalah no-op yang memiliki dua input yang memungkinkan. Jadi utas yang memasukkan "label" melalui salah satu rute hanya akan diarahkan ke arah yang sama.
• 1 -> 2, bagi : mengambil utas tunggal, dan mengirim dua salinan ke arah yang berbeda.
• 1 -> 1, Isero? : mengkonsumsi bit pertama dari utas, dan mengirimkan utas di salah satu dari dua arah tergantung pada apakah bit itu 0 atau 1.
• 1 -> 1, isEmpty? : mengkonsumsi seluruh daftar (yaitu menggantinya dengan daftar kosong), dan mengirimkan utas dalam salah satu dari dua arah tergantung pada apakah daftar itu sudah kosong atau tidak.

Maka dengan itu dalam pikiran, kita dapat mengetahui strategi umum. Menggunakan concatenate, kami ingin berulang kali menambahkan bit baru ke string yang mewakili seluruh input. Kita cukup melakukan ini dengan mengulangi keluaran concatenate kembali ke salah satu inputnya (dan kita inisialisasi ini ke daftar kosong, dengan menghapus a {0}dengan isEmpty? ). Pertanyaannya adalah bagaimana kita dapat menghentikan proses ini.

Selain menambahkan bit saat ini kami juga akan menambahkan 0 atau 1 yang menunjukkan apakah kami telah mencapai EOF. Jika kami mengirim string kami melalui isZero? , itu akan menghilangkan bit itu lagi, tetapi mari kita bedakan akhir dari stream, dalam hal ini kita cukup membiarkan thread meninggalkan tepi grid (yang menyebabkan Ziim mencetak konten thread ke STDOUT dan menghentikan program) .

Apakah kita sudah mencapai EOF atau tidak dapat ditentukan dengan menggunakan isEmpty? pada salinan input.

Inilah diagram yang saya janjikan:

              +----------------------------+   {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 --------------------+

Beberapa catatan tentang di mana mulai membaca:

• Di {0}sudut kiri atas adalah pemicu awal yang memulai loop input.
• The {0}ke arah sudut kanan atas segera dibersihkan untuk daftar kosong sebuah mewakili string awal yang akan kita secara bertahap mengisi dengan input.
• Dua {0}s lainnya dimasukkan ke dalam loop "produser" (satu terbalik, satu tidak), untuk memberi kita pasokan tak terbatas 0s dan 1s yang perlu kita tambahkan ke string.

Hexagony , 6 byte

Dulu 3 byte (lihat di bawah), tetapi versi itu tidak berfungsi sejak pembaruan bahasa terbaru. Karena saya tidak pernah secara sengaja memperkenalkan kesalahan yang digunakan versi, saya memutuskan untuk tidak menghitungnya.

Solusi bebas kesalahan (yaitu yang bekerja dengan juru tetap) ternyata jauh lebih rumit. Saya mengalami kesulitan untuk meremasnya menjadi kotak 2x2, tapi saya menemukan satu solusi sekarang, walaupun saya membutuhkan 7 byte penuh :

<)@,;.(

Setelah dibuka, kami mendapatkan:

Karena tepi memori awal adalah 0, <tanpa syarat membelokkan pointer instruksi ke diagonal Timur-Timur, di mana ia membungkus ke jalur abu-abu. Ini .adalah no-op. Sekarang ,membaca satu byte, )menambahkannya sedemikian sehingga byte yang valid (termasuk null byte) adalah positif dan EOF adalah 0.

Jadi pada EOF, IP membungkus ke jalur merah, di mana @mengakhiri program. Tetapi jika kita masih membaca byte, maka IP yang membungkus ke jalur hijau sebaliknya (mengurangi tepi ke nilai asli, sebelum ;mencetaknya ke STDOUT. IP sekarang membungkus tanpa syarat kembali ke jalur abu-abu, mengulangi prosesnya.

Setelah menulis skrip brute force untuk jawaban Truth Machine saya, saya mengaturnya untuk mencari solusi 6-byte bebas kesalahan untuk program cat juga. Yang mengherankan, ia memang menemukan satu - ya, tepat satu solusi dalam semua program Hexagony 6-byte yang mungkin. Setelah 50 solusi dari mesin kebenaran, itu cukup mengejutkan. Ini kodenya:

~/;,@~

Berlangsung:

Penggunaan ~(negasi unary) bukannya ()menarik, karena a) itu adalah no-op pada nol, b) ia menukar sisi cabang, c) dalam beberapa kode satu ~dapat digunakan dua kali untuk membatalkan operasi dengan dirinya sendiri . Jadi inilah yang terjadi:

Pertama kali (jalur ungu) kami melewati ~itu adalah no-op. The /mencerminkan IP ke North-West diagonal. Jalur abu-abu sekarang membaca karakter dan mengalikan kode karakternya dengan -1. Ini mengubah EOF ( -1) menjadi nilai kebenaran (positif) dan semua karakter yang valid menjadi nilai palsu (tidak positif). Dalam kasus EOF, IP mengambil jalur merah dan kode berakhir. Dalam kasus karakter yang valid, IP mengambil jalur hijau, tempat ~membatalkan negasi dan ;mencetak karakter. Ulangi.

Akhirnya, di sini adalah versi 3-byte yang digunakan untuk bekerja dalam interpreter Hexagony versi asli.

,;&

Seperti jawaban Labirin, ini berakhir dengan kesalahan jika aliran input terbatas.

Setelah membuka kode, kode tersebut terkait dengan kisi heks berikut:

Tidak .ada op. Eksekusi dimulai di jalur ungu.

,membaca satu byte, ;menulis satu byte. Kemudian eksekusi berlanjut di jalur salmon (ish?). Kita perlu &mengatur ulang tepi memori saat ini ke nol, sehingga IP melompat kembali ke baris ungu ketika menekan sudut di akhir baris kedua. Sekali ,klik EOF itu akan kembali -1, yang menyebabkan kesalahan ketika ;mencoba untuk mencetaknya.

Diagram yang dihasilkan dengan Timwi menakjubkan 's HexagonyColorer .

TeaScript , 0 byte

TeaScript adalah bahasa golf ringkas yang disusun untuk JavaScript

Dalam pembaruan terbaru input secara implisit ditambahkan sebagai properti pertama.

Cobalah online

Atau, 1 byte

x

xberisi input dalam TeaScript. Output tersirat

Brian & Chuck , 44 byte

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

Saya awalnya membuat bahasa ini untuk Membuat bahasa pemrograman yang hanya tampaknya tidak dapat digunakan . Ternyata menjadi latihan yang sangat bagus untuk golf masalah sederhana di dalamnya.

Dasar-Dasar: Masing-masing dari dua baris mendefinisikan program seperti Brainfuck yang beroperasi pada kode sumber program lain - program pertama disebut Brian dan yang kedua disebut Chuck. Hanya Brian yang bisa membaca dan hanya Chuck yang bisa menulis. Alih-alih loop Brainfuck Anda memiliki ?yang melewati kontrol ke program lain (dan peran pointer instruksi dan perubahan head tape juga). Tambahan untuk Brainfuck adalah {dan }yang memindai rekaman itu untuk sel non-nol pertama (atau ujung kiri). Juga, _diganti dengan byte nol.

Meskipun saya pikir ini belum optimal, saya cukup senang dengan solusi ini. Upaya pertama saya adalah 84 byte, dan setelah beberapa sesi bermain golf dengan Sp3000 (dan mengambil beberapa inspirasi dari usahanya), saya berhasil membuatnya perlahan menjadi 44, beberapa byte pada suatu waktu. Terutama +}+trik cemerlang adalah idenya (lihat di bawah).

Penjelasan

Input dibaca ke dalam sel pertama pada pita Chuck, lalu dengan susah payah disalin ke ujung pita Brian, di mana ia dicetak. Dengan menyalinnya ke akhir, kita dapat menyimpan byte pada pengaturan karakter sebelumnya ke nol.

Ini #hanyalah pengganti, karena kontrol beralih tidak mengeksekusi sel yang kita aktifkan. {<{memastikan bahwa kepala kaset ada di sel pertama Chuck. ,membaca byte dari STDIN atau -1jika kita menekan EOF. Jadi kami menambahkan bahwa dengan +membuatnya nol untuk EOF dan bukan nol sebaliknya.

Mari kita asumsikan untuk saat ini kita belum di EOF. Jadi selnya positif dan ?akan beralih kontrol ke Chuck. }>bergerak pita kepala (atas Brian) ke +dalam _dan ?melewati kontrol kembali ke Brian.

{-sekarang mengurangi sel pertama pada Chuck. Jika belum nol, kami memberikan kontrol kepada Chuck lagi ?. Kali ini }>memindahkan kepala kaset pada Brian dua sel di kanan sel non-nol terakhir. Awalnya ada di sini:

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

Tapi nanti, kita sudah memiliki beberapa karakter di sana. Misalnya, jika kita sudah membaca dan mencetak abc, maka akan terlihat seperti ini:

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

Di mana 1s sebenarnya 1-byte (kita akan lihat apa itu nanti).

Sel ini akan selalu nol, jadi kali ? ini tidak akan mengubah kontrol. >bergerak sel lain ke kanan dan +menambah sel itu. Inilah sebabnya mengapa karakter pertama dalam input berakhir tiga sel di sebelah kanan ?(dan masing-masing berikutnya tiga sel lebih jauh ke kanan).

<<<bergerak kembali ke karakter terakhir dalam daftar itu (atau ?jika itu adalah karakter pertama), dan {>kembali ke +pada rekaman Brian untuk mengulangi pengulangan, yang secara perlahan mentransfer sel input ke akhir rekaman Brian.

Setelah sel input kosong, ?after {-tidak akan beralih kontrol lagi. Kemudian >}<gerakkan kepala kaset pada Chuck ke _dan aktifkan kontrol sedemikian rupa sehingga babak kedua Chuck dieksekusi sebagai gantinya.

}>>pindah ke sel yang sekarang telah kita tulis melewati akhir rekaman Brian, yang merupakan byte yang telah kita baca dari STDIN, jadi kita mencetaknya kembali dengan .. Agar }dapat melewati karakter baru ini pada pita, kita perlu menutup celah dua byte nol, jadi kita menambahkannya 1dengan <+<+(jadi itu sebabnya ada 1-byte antara karakter aktual pada rekaman akhir). Akhirnya {<{bergerak kembali ke awal rekaman Brian dan ?memulai semuanya dari awal.

Anda mungkin bertanya-tanya apa yang terjadi jika karakter yang kita baca adalah null-byte. Dalam hal itu sel yang baru ditulis itu sendiri akan menjadi nol, tetapi karena itu pada akhir rekaman Brian dan kami tidak peduli di mana akhir itu, kita bisa mengabaikannya. Itu berarti jika inputnya adalah ab\0de, maka rekaman Brian akan benar-benar tampak seperti:

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

Akhirnya, begitu kita menekan EOF yang pertama ?pada rekaman Brian akan menjadi no-op. Pada titik ini kami mengakhiri program. Solusi naif akan pindah ke akhir rekaman dan beralih kontrol Chuck, seperti bahwa termiantes Program: >}>}<?. Di sinilah ide pintar Sp3000 menghemat tiga byte:

+mengubah sel pertama Chuck menjadi 1. Itu berarti }memiliki titik awal dan menemukan _di tengah pita Chuck. Alih-alih melewatinya, kita cukup menutup celah dengan mengubahnya menjadi 1dengan +juga. Sekarang mari kita lihat apa yang terjadi dengan sisa kode Brian dengan Chuck yang dimodifikasi ini ...

{kembali ke sel pertama Chuck seperti biasa, dan -mengubahnya kembali menjadi nol-byte. Itu berarti itu ?adalah no-op. Tapi sekarang >}<, yang biasanya memindahkan kepala kaset ke tengah kaset Chuck, bergerak melewatinya ke akhir kaset Chuck dan ?kemudian memberikan kontrol ke Chuck, mengakhiri kode. Sangat menyenangkan ketika semuanya berhasil ... :)

Haskell, 16 byte

main=interact id

interactmembaca input, meneruskannya ke fungsi yang diberikan sebagai argumennya dan mencetak hasil yang diterimanya. idadalah fungsi identitas, yaitu mengembalikan inputnya tidak berubah. Berkat kemalasan Haskell interactdapat bekerja dengan input yang tak terbatas.

sh + binutils, 3 2 byte

dd

Yah, tidak begitu jelas. Dari @ Random832

Asli:

cat

Yang sangat menyakitkan ...: D

Funciton , 16 byte

╔═╗
╚╤╝

(Dikodekan sebagai UTF-16 dengan BOM)

Penjelasan

Kotak mengembalikan konten STDIN. Ujung longgar output itu.

Kode Mesin Motorola MC14500B , 1,5 byte

Ditulis dalam heksadesimal:

18F

Ditulis dalam biner:

0001 1000 1111

Penjelasan

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

Opcode masing-masing 4 bit.

Mornington Crescent , 41 byte

Take Northern Line to Mornington Crescent

Saya tidak tahu apakah Mornington Crescent dapat menangani byte nol, dan semua input dibaca sebelum program dimulai, karena itu adalah sifat dari bahasa tersebut.

Brainfuck, 5 byte

,[.,]

Setara dengan kodesemu:

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

Ini menangani aliran tanpa batas, tetapi memperlakukan byte nol sebagai EOF. Apakah BF dapat menangani byte nol dengan benar bervariasi dari implementasi ke implementasi, tetapi ini mengasumsikan pendekatan yang paling umum.

Labirin , 2 byte

,.

Jika aliran terbatas, ini akan diakhiri dengan kesalahan, tetapi semua output yang dihasilkan oleh kesalahan tersebut masuk ke STDERR, sehingga aliran keluaran standar sudah benar.

Seperti dalam Brainfuck ,membaca byte (mendorongnya ke tumpukan utama Labyrinth) dan .menulis byte (muncul dari tumpukan utama Labyrinth).

Alasan loop ini adalah karena keduanya ,dan ."buntu" di labirin (sangat sepele) yang diwakili oleh kode sumber, sehingga penunjuk instruksi hanya berbalik di tempat dan bergerak kembali ke perintah lain.

Saat kami menekan EOF, alih-alih ,mendorong -1dan .melempar kesalahan karena -1bukan kode karakter yang valid. Ini mungkin benar-benar berubah di masa depan, tetapi saya belum memutuskan ini.

Sebagai referensi, kita dapat menyelesaikan ini tanpa kesalahan dalam 6 byte sebagai berikut

,)@
.(

Di sini, )kenaikan byte yang kita baca, yang memberi 0pada EOF dan sesuatu yang positif sebaliknya. Jika nilainya 0, IP bergerak lurus, menekan @yang menghentikan program. Jika nilainya positif, IP akan mengambil belokan kanan ke arah (mana yang menurunkan bagian atas tumpukan kembali ke nilai aslinya. IP sekarang di sudut dan hanya akan terus berbelok ke kanan, mencetak dengan ., membaca byte baru dengan ., sebelum menyentuh garpu )sekali lagi.

C, 40 byte

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

> <> , 7 byte

i:0(?;o

Coba di sini . Penjelasan:

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

Jika Anda ingin terus berjalan sampai Anda memberikan lebih banyak input, ganti ;dengan !.

Perakitan X86, 70 byte

Disassembly dengan 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

Sumber:

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

Universal Lambda , 1 byte

!

Program Universal Lambda adalah pengkodean istilah lambda dalam biner, dipotong-potong menjadi 8 bit, melapisi potongan yang tidak lengkap dengan bit apa pun , dikonversi ke aliran byte.

Bit diterjemahkan ke dalam istilah lambda sebagai berikut:

• 00 memperkenalkan abstraksi lambda.
• 01 mewakili aplikasi dari dua istilah berikutnya.
• 111..10, dengan n pengulangan bit 1, merujuk ke variabel lambda induk ke- n ; yaitu indeks De Bruijn di unary.

Dengan konversi ini, 0010adalah fungsi identitas λa.a, yang berarti program byte tunggal dari formulir 0010xxxxadalah catprogram.

PowerShell, 88 41 30 Bytes

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

_{EDIT - lupa bahwa saya dapat menggunakan $inputvariabel otomatis untuk input pipa} ... _{EDIT2 - tidak perlu menguji keberadaannya$input}

Ya, jadi ... STDIN di PowerShell adalah ... aneh, bisa kita katakan. Dengan asumsi bahwa kami perlu menerima masukan dari semua jenis STDIN, ini adalah salah satu jawaban yang mungkin untuk katalog ini, dan saya yakin ada yang lain. ¹

Input pipeline di PowerShell tidak berfungsi seperti yang Anda pikirkan. Karena pemipaan di PowerShell adalah fungsi dari bahasa, dan bukan fungsi dari lingkungan / shell (dan PowerShell sebenarnya bukan semata - mata bahasa), ada beberapa kebiasaan untuk perilaku.

Sebagai permulaan, dan yang paling relevan dengan entri ini, pipa tidak dievaluasi secara instan (sebagian besar waktu). Artinya, jika kita miliki command1 | command2 | command3di shell kita, command2tidak akan mengambil input atau mulai memproses sampai command1selesai ... kecuali jika Anda merangkum Anda command1dengan ForEach-Object... yang berbeda dari ForEach. _{(Meskipun ForEachalias untuk ForEach-Object, tapi itu masalah terpisah, karena saya berbicara ForEachsebagai pernyataan, bukan alias)}

Ini berarti bahwa sesuatu seperti yes | .\simple-cat-program.ps1(meskipun yestidak benar-benar ada, tetapi apa pun) tidak akan berhasil karena yestidak akan pernah lengkap. Jika kita bisa melakukan ForEach-Object -InputObject(yes) | .\simple-cat-program.ps1itu seharusnya (secara teori) bekerja.

Mengenal ForEach dan ForEach-Object di Microsoft "Hei, Scripting Guy!" blog.

Jadi, semua paragraf itu menjelaskan mengapa if($input){$input}ada. Kami mengambil parameter input yang khusus dibuat secara otomatis jika input pipa hadir, uji apakah ada, dan jika demikian, outputkan.

Kemudian, kami mengambil input dari pengguna (read-host)melalui apa yang pada dasarnya merupakan aliran STDIN yang terpisah, dan write-hostkembali, dengan -nbendera (kependekan dari -NoNewLine). Perhatikan bahwa ini tidak mendukung input panjang sewenang-wenang, karena read-hosthanya akan selesai ketika umpan baris dimasukkan (secara teknis ketika pengguna menekan "Enter", tetapi setara secara fungsional).

Fiuh.

¹ Tetapi ada opsi lain:

Sebagai contoh, jika kita prihatin dengan hanya masukan pipa, dan kita tidak memerlukan program penuh, Anda bisa melakukan sesuatu seperti | $_yang akan hanya output apa pun masukan. _{(Secara umum, itu agak berlebihan, karena PowerShell memiliki keluaran implisit dari hal-hal "tertinggal" setelah perhitungan, tapi itu samping.)}

Jika kita hanya peduli dengan input pengguna interaktif, kita bisa menggunakan adil write-host(read-host)-n.

Selain itu, fungsi ini memiliki fitur unik untuk menerima input baris perintah, misalnya .\simple-cat-program.ps1 "test"akan mengisi (dan kemudian mengeluarkan) $avariabel.

Cubix , 6 5 byte

Sekarang menangani byte nol!

@_i?o

Cubix adalah esolang 2 dimensi, berbasis tumpukan. Cubix berbeda dari langs 2D lain dalam hal kode sumber dililitkan di luar kubus.

Uji secara online! Catatan: ada penundaan 50 ms antara iterasi.

Penjelasan

Hal pertama yang dilakukan penerjemah adalah menemukan kubus terkecil yang sesuai dengan kode tersebut. Dalam hal ini, panjang tepi adalah 1. Kemudian kode diisi dengan no-ops .hingga keenam sisi terisi. Spasi dihapus sebelum diproses, jadi kode ini identik dengan yang di atas:

  @
_ i ? o
  .

Sekarang kodenya dijalankan. IP (penunjuk instruksi) dimulai pada wajah paling kiri, menunjuk ke timur.

Karakter pertama yang ditemui IP adalah _, yang merupakan cermin yang mengubah IP sekitar jika menghadap ke utara atau selatan; saat ini menghadap ke timur, jadi ini tidak melakukan apa-apa. Selanjutnya adalah i, yang memasukkan byte dari STDIN. ?belokkan IP ke kiri jika item teratas negatif, atau kanan jika positif. Ada tiga kemungkinan jalur di sini:

• Jika byte yang dimasukkan adalah -1 (EOF), IP belok kiri dan klik @, yang mengakhiri program.
• Jika byte yang dimasukkan adalah 0 (byte nol), IP akan terus lurus, menghasilkan byte dengan o.
• Jika tidak, IP berbelok ke kanan, bergerak melintasi permukaan bawah dan menyentuh cermin _. Ini memutarnya, mengirimkannya kembali ke ?, yang mengubahnya lagi dan menghasilkan byte.

Saya pikir program ini optimal. Sebelum Cubix dapat menangani byte nol (EOF adalah 0, bukan -1), program ini bekerja untuk semuanya kecuali byte nol:

.i!@o

Saya telah menulis brute-forcer untuk menemukan semua program kucing 5-byte. Meskipun dibutuhkan ~ 5 menit untuk menyelesaikannya, versi terbaru telah menemukan 5 program:

@_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)

Vitsy, 2 byte

zZ

zmendapatkan semua tumpukan input dan mendorongnya ke tumpukan program yang aktif. Zmencetak semua tumpukan aktif ke STDOUT.

Metode alternatif:

I \ il \ O
I \ Ulangi karakter berikutnya untuk panjang input tumpukan.
  i Ambil item dari input.
   l \ Ulangi karakter berikutnya untuk panjang tumpukan program yang sedang aktif.
     O Keluarkan item teratas dari tumpukan sebagai karakter.

MarioLANG , 11 byte

,<
."
>!
=#

Saya tidak sepenuhnya yakin ini optimal, tetapi ini adalah yang terpendek yang saya temukan.

Ini mendukung aliran yang tak terbatas dan akan diakhiri dengan kesalahan saat mencapai EOF (setidaknya implementasi referensi Ruby tidak).

Ada versi lain dari ini yang mengubah Mario menjadi ninja yang dapat melipatgandakan melompat:

,<
.^
>^
==

Dalam kedua kasus tersebut, Mario mulai jatuh ke kolom kiri, di mana ,membaca byte dan .menulis byte (yang melempar kesalahan pada EOF karena ,tidak mengembalikan karakter yang valid). >memastikan bahwa Mario berjalan ke kanan ( =hanya tanah baginya untuk berjalan). Kemudian dia bergerak ke atas, baik melalui lompatan ganda dengan ^atau melalui lift ( "dan #pasangan) sebelum <memberitahu dia untuk pindah kembali ke kolom kiri.

rs , 0 byte

Serius. rs hanya mencetak apa saja jika skrip yang diberikan benar-benar kosong.

GolfScript, 3 byte

:n;

Program kosong menggemakan input standar. Bahasa tidak mungkin menangani aliran yang tak terbatas. Namun, itu menambahkan baris baru, seperti yang disebutkan @Dennis. Itu melakukannya dengan membungkus seluruh tumpukan dalam array dan panggilan puts, yang didefinisikan sebagai print n print, di mana nbaris baru. Namun, kita dapat mendefinisikan kembali nmenjadi STDIN, dan kemudian mengosongkan tumpukan, dan memang itulah yang :n;dilakukan.

Mobil Setengah Rusak dalam Lalu Lintas Berat , 9 + 3 = 12 byte

#<
o^<
 v

Mobil Setengah Rusak di Lalu Lintas Berat (HBCHT) mengambil input sebagai argumen baris perintah, jadi jalankan seperti

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

Perhatikan bahwa +3 untuk -sbendera, yang ditampilkan sebagai karakter. Juga, HBCHT tampaknya tidak menangani NUL, karena semua nol dijatuhkan dari output (misalnya 97 0 98adalah output sebagai dua karakter ab).

Penjelasan

Di HBCHT, mobil Anda mulai di odan tujuan Anda adalah pintu keluar #. ^>v<mengarahkan gerakan mobil, sementara secara bersamaan memodifikasi pita seperti BF ( ^>v<diterjemahkan ke +>-<). Namun, seperti yang disarankan oleh nama bahasa, mobil Anda hanya dapat berbelok ke kanan - segala upaya untuk belok kiri diabaikan sepenuhnya (termasuk efek ingatannya). Perhatikan bahwa ini hanya untuk belok - mobil Anda benar-benar mampu melaju ke depan / membalikkan arah.

Bagian menarik lainnya tentang HBCHT adalah bahwa arah awal mobil Anda diacak, dan kisi-kisi adalah toroidal. Jadi kita hanya perlu mobil untuk sampai ke pintu keluar tanpa mengubah rekaman untuk keempat arah awal:

• Atas dan ke bawah sangat mudah, langsung menuju ke pintu keluar.

• Untuk kiri, kami bungkus dan jalankan <dan tambahkan ^. Kami tidak dapat belok kiri di berikutnya <sehingga kami membungkus dan mengurangi dengan v, meniadakan kenaikan sebelumnya. Karena kita menuju ke bawah sekarang, kita dapat belok kanan di <dan keluar, setelah memindahkan pointer dua kali dan tidak mengubah nilai sel.

• Untuk kanan, kami melakukan hal yang sama seperti kiri tetapi lewati dulu ^karena kami tidak bisa belok kiri.

Sunting : Ternyata penerjemah HBCHT membiarkan Anda mengeksekusi hanya satu jalur tunggal melalui flag baris perintah, misalnya

py -3 hbcht -d left cat.hbc

Namun, tidak hanya flag yang terlalu mahal untuk pertanyaan khusus ini (setidaknya 5 byte untuk " -d u"), tampaknya semua jalur masih harus dapat membuatnya ke pintu keluar untuk mengeksekusi kode.

Minkolang , 5 byte

od?.O

Coba di sini.

Penjelasan

omembaca karakter dari input dan mendorong kode ASCII ke stack ( 0jika input kosong). dkemudian menggandakan bagian atas tumpukan (karakter yang baru saja dibaca). ?adalah trampolin bersyarat, yang melompat instruksi berikutnya dari puncak tumpukan tidak 0. Jika input kosong, maka .tidak melompat dan program berhenti. Jika tidak, Ooutput atas tumpukan sebagai karakter. Sifat toroidal Minkolang berarti bahwa ini berputar ke awal.

INTERCALL , 133 byte

wat

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

V , 0 byte

Cobalah online!

Gagasan V tentang "memori" hanyalah deretan karakter 2D raksasa. Sebelum program dijalankan, semua input dimasukkan ke dalam array ini (dikenal sebagai "Penyangga"). Kemudian, di akhir program apa pun, semua teks dalam buffer dicetak.

Dengan kata lain, program kosong adalah program kucing.

Snowman 1.0.2 , 15 karakter

(:vGsP10wRsp;bD

Diambil langsung dari examplesdirektori Snowman . Membaca garis, mencetak garis, membaca garis, mencetak garis ...

Perhatikan bahwa karena detail implementasi, ketika STDIN kosong, vgakan mengembalikan hal yang sama seperti untuk baris kosong. Oleh karena itu, ini akan berulang kali mencetak baris baru dalam loop tak terbatas setelah STDIN ditutup. Ini mungkin diperbaiki di versi mendatang.

Penjelasan kode:

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

FireType , 7 byte

,
&
_
=

Membutuhkan beberapa perubahan yang baru saja saya dorong . Aturan mengatakan:

Tidak seperti aturan kami yang biasa, jangan ragu untuk menggunakan bahasa (atau versi bahasa) meskipun itu lebih baru daripada tantangan ini.

jadi saya jelas!

Fisi , 4 byte

R?J!

Bukankah itu menyenangkan ketika Anda mengalahkan sampel program dalam repositori bahasa sendiri? :) Untuk referensi, ia memiliki solusi 7-byte

R?J0;0!

Penjelasan

Jadi, mulailah Raliran kontrol dengan atom yang berjalan benar. ?membaca karakter dari STDIN ke dalam massa atom. Selama kita membaca karakter, energinya tetap nol, jadi Jump adalah no-op dan !mencetak karakter. Atom loop kembali ke awal ( Rsekarang adalah no-op) dan mengulangi seluruh proses.

Ketika kita menekan EOF, ?akan mengatur energi atom 1, jadi Jump sekarang akan melewatkan perintah cetak. Tetapi ketika sebuah atom mengenai ? setelah EOF telah dikembalikan, itu akan menghancurkan atom sebagai gantinya, yang mengakhiri program.

(Solusi dari penulis bahasa menggunakan eksplisit ;untuk mengakhiri program, yang dilewati dengan dua- 0portal sebaliknya.)

Shtriped , 20 byte

e )
"
 r )
 s )
 "
"

Ini menunjukkan bahwa hampir semua string ASCII yang dapat dicetak adalah pengidentifikasi yang valid di Shtriped.

Bagaimana itu bekerja:

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

Tidak ada cara nyata untuk mendeteksi EOF, jadi loop ini selamanya seperti jawaban Python .

Anda dapat dengan mudah membuatnya berhenti ketika baris kosong diberikan (30 byte):

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

Perhatikan bahwa Shtriped I / O hanya mendukung ASCII yang dapat dicetak , tab, feed garis, carriage return, tab vertikal, dan form feed (total 100 karakter). Ini karena secara internal, string direpresentasikan sebagai integer presisi arbitrer non-negatif, dan harus ada alfabet karakter yang terbatas untuk dapat menyandikan semua string.