Mesin kebenaran (kredit diberikan kepada orang ini karena telah membuatnya) adalah program yang sangat sederhana yang dirancang untuk menunjukkan I / O dan mengontrol aliran suatu bahasa. Inilah yang dilakukan mesin kebenaran:

• Mendapat angka (0 atau 1) dari STDIN.

• Jika angka itu 0, cetak 0 dan hentikan.

• Jika angka itu adalah 1, cetak 1 selamanya.

Tantangan

Tulis mesin kebenaran seperti dijelaskan di atas dalam bahasa pilihan Anda. Mesin kebenaran harus merupakan program lengkap yang mengikuti aturan-aturan ini:

• mengambil masukan dari STDIN atau alternatif yang dapat diterima
  • Jika bahasa Anda tidak dapat mengambil input dari STDIN, itu mungkin mengambil input dari variabel yang dikodekan atau setara yang sesuai dalam program
• harus menampilkan ke STDOUT atau alternatif yang dapat diterima
  • Jika bahasa Anda tidak mampu menghasilkan karakter 0atau 1, byte atau I / O unary dapat diterima.
• ketika inputnya 1, ia harus terus mencetak 1dan hanya berhenti jika program mati atau kehabisan memori

• output hanya harus berupa 0diikuti oleh satu atau tanpa baris atau spasi baru, atau tanpa batas 1dengan masing-masing 1diikuti oleh salah satu atau tanpa baris atau spasi baru. Tidak ada output lain yang dapat dihasilkan, kecuali output konstan dari juru bahasa Anda yang tidak dapat ditekan (seperti salam, kode warna ANSI atau lekukan). Penggunaan baris baru atau spasi Anda harus konsisten: misalnya, jika Anda memilih untuk menghasilkan 1dengan baris baru setelah itu semua 1harus memiliki baris baru setelahnya.

• jika dan hanya jika bahasa Anda tidak dapat diakhiri pada input, 0maka dapat diterima kode untuk memasukkan loop tak terbatas di mana tidak ada yang dihasilkan.

Karena ini adalah katalog, bahasa yang dibuat setelah tantangan ini diizinkan untuk bersaing. 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. Selain itu, semua aturan standar kode-golf harus dipatuhi. Kiriman dalam kebanyakan bahasa akan dinilai dalam byte dalam pengkodean yang sudah ada sebelumnya (biasanya UTF-8).

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 dapat 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 hukuman penterjemah secara terpisah), pastikan bahwa skor sebenarnya 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: 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 byte

Ini mengejutkan rumit, dan saya tidak yakin itu optimal ...

<.@!$?

Setelah mengisi dan membuka kode, ini mewakili kisi hex berikut:

Ini menggunakan aliran kontrol yang sama seperti program kucing bebas kesalahan saya baru-baru ini , bergerak bersama anti-diagonal. Untuk mencapai itu kita mulai dengan membelokkan penunjuk instruksi (IP) ke kiri, di mana jalur ungu membungkus di sekitar sudut kiri bawah.

?membaca input sebagai integer. !mencetaknya kembali. .hanyalah sebuah no-op. Sekarang sudut kisi bertindak sebagai cabang:

Jika inputnya adalah 0, IP akan melanjutkan sepanjang jalur merah, yang dengan mudah mengakhiri program dengan @.

Jika inputnya adalah 1, IP akan melanjutkan di jalur hijau. Sekali lagi, .hanya no-op, tetapi $setara dengan trampolin Befunge: ia melompati instruksi selanjutnya. Setelah membungkus, instruksi selanjutnya adalah ?, tetapi karena $eksekusi sebenarnya berlanjut di jalur biru, dimulai dengan !mencetak salinan lain dari 1. Loop yang hanya berisi !..$ini sekarang diulang tanpa batas.

Sebuah studi tentang aliran kontrol dalam Hexagony ...

Saya percaya solusi di atas optimal. Saya telah menulis brute forcer, yang memeriksa semua program Hexagony 6-byte, yang masing-masing berisi setidaknya satu ?!@(yang diperlukan; Saya juga telah memeriksa :dan %menggantikannya @dengan kesalahan pembagian-oleh-nol, tetapi itu tidak membantu). Cek mencetak semua program yang a) menghasilkan 0input on 0dan terminasi dan b) menghasilkan setidaknya dua 1s (dan tidak ada yang lain) dan tidak berhenti dalam 60 tick pertama dari program (200 ticks untuk solusi 5-byte) . Saya ragu bahwa solusi yang valid akan membutuhkan lebih dari 200 kutu untuk mencetak yang pertama 0atau yang kedua dengan benar 1pada kotak kecil seperti itu, jadi saya rasa saya tidak melewatkan solusi potensial.

Pencarian tidak menghasilkan hasil apa pun untuk 5 byte, tetapi 57 hasil untuk 6 byte (menggunakan @; tidak perlu mengakhiri dengan kesalahan jika kita dapat menyelesaikannya dengan bersih dalam jumlah byte yang sama). Dari mereka 57 hanya 6 yang positif palsu yang benar-benar dicetak hanya dua 1s dan kemudian memasuki loop tanpa batas tanpa mencetak lagi. Satu solusi terdaftar dua kali karena mengandung dua !perintah. Itu meninggalkan tepat 50 solusi yang valid.

Ada sejumlah kemunduran di antara solusi di mana satu atau dua karakter tidak substansial, misalnya karena mereka sebenarnya tidak bisa digunakan. Solusi dapat dikelompokkan menjadi 23 set program yang benar-benar berbeda (dalam beberapa kasus, hanya ada perbedaan karakter tunggal antara dua set, tetapi mengubah aliran kontrol secara substansial, jadi saya sudah menghitungnya secara terpisah). Dua kelompok bahkan menggunakan banyak petunjuk instruksi dengan cara yang sangat tidak terduga. Karena saya tidak akan pernah menemukan sebagian besar cara-cara ini untuk menggunakan cabang dan cermin, mereka membuat studi yang sangat menarik tentang aliran kontrol macam apa yang mungkin ada di Hexagony, dan saya pasti telah mempelajari beberapa trik baru untuk golf masa depan.

The keseluruhan aliran kontrol hampir selalu sama: membaca nomor, mencetaknya. Jika itu 0menemukan cara untuk @, jika tidak terus melalui perulangan !sambil mempertahankan nilai tepi 1. Ada empat pengecualian penting:

• Satu solusi (satu dengan dua !) mencetak dua 1per per iterasi melalui kisi, sehingga mencetak sekitar dua kali lebih cepat dari mayoritas program. Saya sudah menandai yang ini dengan di x2bawah ini.
• Beberapa solusi (yang berisi a o) ganti 1dengan a 111(kode karakter o), sehingga mereka mencetak tiga 1 s per iterasi, membuat mereka mencetak sekitar tiga kali lebih cepat dari mayoritas program. Saya sudah menandai ini dengan di x3bawah ini.
• Dua solusi menambahkan sebuah 1dengan nilai tepi dalam setiap iterasi (jadi 1-> 11-> 111-> ...). Mereka mencetak dengan sangat cepat, tetapi pada akhirnya mereka akan kehabisan memori. Saya sudah menandai ini dengan di OoMbawah ini.
• Dua solusi memasuki loop yang sangat ketat yang hanya memantul ke depan dan ke belakang !, mencetak setiap centang lainnya (bukan setiap 5 atau lebih), yang membuatnya sedikit lebih cepat (dan lebih rapi). Saya sudah menandai ini dengan di ><bawah ini.

Jadi di sini adalah seluruh kebun binatang:

#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

Berikut ini adalah langkah-langkah singkat untuk beberapa kelompok yang lebih representatif. Khususnya kelompok 10 dan 23 patut dicoba. Ada banyak jalan lain yang menarik dan terkadang berbelit-belit di kelompok lain, tapi saya pikir saya sudah cukup bosan pada akhir ini. Bagi siapa pun yang benar-benar ingin belajar Hexagony, ini pasti patut diselidiki, karena mereka menunjukkan kemungkinan penggunaan cermin yang lebih banyak $.

Grup 1

Yang ini tidak lebih rumit dari solusi asli saya, tetapi jalan menuju ke arah yang berbeda. Ini juga memungkinkan untuk variasi jumlah terbesar dalam sel tunggal, karena hak-no-op paling kanan dapat diganti dengan 5 perintah berbeda yang masih menjadikan ini valid tanpa mengubah struktur:

Grup 2

Yang ini cukup menarik, karena hanya bergerak secara horizontal. Setelah membungkus ke >, IP membalikkan segera, mengambil cabang di sudut. Tidak sepenuhnya terlihat diagram, tetapi dalam kasus 1kita melintasi baris pertama lagi, tapi mundur kali ini. Ini juga berarti kita bertemu ?lagi, yang sekarang kembali 0(EOF). Ini diperbaiki dengan )(kenaikan) untuk tetap mencetak 1s. Ini juga memiliki 5 variasi, seperti )bisa juga 1atau o, dan >bisa juga |:

Grup 3

Yang ini terlihat hampir identik dengan yang sebelumnya tetapi sangat berantakan. Hingga memukul |dan kemudian melintasi baris bawah atau atas itu sama. Tapi dalam kasus loop, yang $sekarang melompat di atas ) ke cermin. Jadi kita mengikuti jalan pirus ke kanan, sekarang tekan kenaikan, lewati @sebelum kita membungkus | lagi dan kemudian kembali ke jalur hijau di atas.

Grup 4

Saya pikir ini sangat bagus:

The _cermin di sudut kanan atas pada awalnya tidak-op, jadi kami mencetak dengan !dan memukul <. The 0path sekarang hits cermin horisontal dan berakhir. The 1path mengambil lintasan benar-benar menarik meskipun: itu mengalihkan ke bawah, membungkus dengan !, akan diarahkan menuju horizontal dan kemudian membungkus kembali ke ! lagi . Kemudian terus bergerak dalam bentuk belah ketupat ini, mencetak dua kali per iterasi (setiap centang ketiga).

Grup 8

Ini adalah salah satu dari dua solusi dengan lingkaran pencetakan yang sangat ketat:

The <bertindak sebagai cabang. Setelah membungkus dua kali, 0klik @. 1di sisi lain, pertama melewatkan ?, kemudian >mengirimkannya ke $lagi, sehingga melewatkan @. Kemudian IP membungkus ke dalam jalur pirus, di mana ia memantul bolak-balik antara >dan <(membungkus tepi di antara).

Grup 10

Salah satu dari dua kelompok yang menggunakan petunjuk instruksi lain, dan itu benar-benar indah. Hexagony memiliki 6 - masing-masing dimulai dari sudut yang berbeda di sepanjang tepi searah jarum jam, tetapi hanya satu dari mereka yang aktif pada suatu waktu.

Seperti biasa, kita baca bersama ?. Sekarang ~adalah negasi unary: itu mengubah 1a -1. Selanjutnya, kita tekan tombol #. Ini adalah salah satu cara untuk beralih di antara IP: dibutuhkan nilai edge modulo 6 saat ini dan beralih ke IP yang sesuai (IP diberi nomor dari 0arah searah jarum jam). Jadi jika inputnya adalah 0, maka IP tetap sama, dan berjalan membosankan langsung ke depan !@. Tetapi jika inputnya adalah 1, maka nilai saat ini adalah -1yang mana 5 (mod 6). Jadi kami beralih ke IP yang dimulai pada sel yang sama (jalur hijau). Sekarang #adalah no-op dan ?atur tepi memori 0. )peningkatan jadi !cetak a 1. Sekarang kita menekan ~lagi untuk memastikan itu#masih merupakan no-op (sebagai lawan mengalihkan kami ke IP 1 yang akan menghentikan program). Sangat membingungkan bagaimana semuanya cocok dalam program kecil ini.

Grup 22

Sebagai catatan, ini adalah grup tempat solusi asli saya. Ini juga merupakan grup terbesar, karena no-op dapat berada di dua tempat yang berbeda, dan ada beberapa pilihan untuk perintah aktual (efektif no-op).

Grup 23

Ini adalah grup lain yang menggunakan banyak IP. Sebenarnya yang ini menggunakan 3 IP berbeda. Sudut kanan atas agak berantakan, tapi saya akan mencoba memandu Anda melalui ini:

Jadi, awal yang pernah Anda lihat sebelumnya: <membelokkan Utara-Timur, ?membaca input. Sekarang ]adalah cara lain untuk mengubah antara IP: tangan mengontrol ke IP berikutnya dalam urutan searah jarum jam. Jadi kami beralih kontrol ke jalur pirus yang (saya tahu sulit untuk dilihat) dimulai di sudut Timur Laut menuju Tenggara. Itu segera tercermin oleh <sehingga membungkus ke sudut Tenggara, pergi ke Barat Laut. Itu juga hits ]jadi kami beralih ke IP berikutnya . Ini adalah jalan kelabu yang dimulai di sudut Timur, menuju Barat Daya. Ini mencetak input, kemudian membungkus ke sudut Utara-Timur. <membelokkan jalur ke horizontal, di mana itu tercermin oleh yang lain < . Sekarang tangan kanan<bertindak sebagai cabang: jika inputnya adalah 0, IP bergerak Utara-Timur, dan membungkus ke @. Jika inputnya adalah 1, IP bergerak ke !, membungkus ke kiri-ke <mana di mana itu tercermin ... sekarang di sudut, itu membungkus kembali ke !, akan dibelokkan ke kanan <, tercermin oleh kiri <dan jalan dimulai lebih...

Cukup berantakan, tapi berantakan indah. :)

Diagram yang dihasilkan dengan Timwi ini menakjubkan HexagonyColorer .

Kode Mesin Motorola MC14500B , 2 byte

Dalam hex:

58EC

Penjelasan:

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 adalah mikrokontroler 1-bit; ia memiliki satu register 1-bit dan bus data 1-bit. Karena opcode masing-masing 4 bit, hanya ada enam belas; setengah dari mereka melakukan operasi logis antara register dan bit pada bus data.

Instruksi lompat menetapkan bendera lompat; ketika tidak ada alamat yang diberikan, adalah umum untuk mengatur penghitung program ke 0. Jika bit input nol, prosesor tidak akan melompat. Jika bit input adalah 1, prosesor akan melompat kembali ke awal; karena kita ORmenggunakan input, tidak masalah apa sinyal input setelahnya — register kemudian akan menjadi 1 selamanya.

Seperti konvensional, register diinisialisasi ke 0.

Daftar opcodes dapat ditemukan di lembar data, atau di sini .

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

Tidak benar-benar kompetitif, tetapi untuk bersenang-senang. Tidak mendukung stdin, ganti @NO PROBLEMOdengan dengan @I LIEDnilai nol. @No Problemoadalah 1.

Jalankan dengan (dengan asumsi file adalah truthmachine.arnoldc):

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

Minecraft, 18 Bytes (Versi MC 15w45a)

Seperti yang Anda lihat, ada tuas yang diarahkan ke blok perintah berulang, yang memiliki perintah say 1di dalamnya. Ada sinyal pembalik obor di atas itu, yang mengarahkan daya ke blok perintah sekali pakai dengan perintah say 0di dalamnya.

Setiap kali saklar diarahkan ke kebenaran, blok repeater menggunakan kode say 1untuk keluaran tak terhingga 1. Ketika tuas dialihkan ke false, itu menghasilkan satu 0.

Perhatikan bahwa ini menghasilkan a [@]secara default. Jika Anda benar - benar hanya ingin 1s dan nol, ini menjadi 34 byte, di mana kode di blok perintah berada tellraw @a [1]dan tellraw @a [0]. Ini menggunakan hitungan byte yang disarankan @Cᴏɴᴏʀ O'Bʀɪᴇɴ untuk MC seperti yang dapat ditemukan di Meta .

Utilitas Bash + GNU, 13

grep 0||yes 1

Bash, 35

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

Ruby, 20

print while/1/||gets

Jalankan dari baris perintah untuk menghindari peringatan, seperti

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

Penjelasan:

Kurang golf, ini

while /1/ || gets
  print
end

Ketika Regexp digunakan dalam kondisi, ia mengevaluasi sebagai falsey kecuali variabel $_tersebut diisi dan cocok dengan pola. Pada saat pertama kali melalui loop, $_kosong sehingga kita jatuh ke gets, yang menetapkan nilai $_ke baris dibaca dari STDIN. printtanpa cetakan argumen $_. Sekarang kita mengevaluasi persyaratan lagi. Jika kita membaca dalam 1, kita mengalami hubungan pendek dan hanya mencetak 1 lagi, dan seterusnya selamanya. Kalau tidak, kita gagal gets, tetapi karena tidak ada input baris kedua, getsmengembalikan nil, sehingga loop berakhir.

Microscript, 3 byte

i{p

Yang terpendek yang saya tahu.

Penjelasan:

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

Microscript memiliki pencetakan implisit register 1 pada saat penghentian, yang merupakan alasan mengapa input 0dicetak sekali.

Kode Mesin Turing, 32 byte

Menggunakan sintaks tabel aturan ditemukan di sini.

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

JavaScript, 28 byte

Untuk loop seringkali lebih pendek dari loop sementara.

alert(x)mengembalikan undefined, yang palsu, sehingga bitwise atau operator |, melemparkannya ke 0. Dengan demikian, jika xada "0", waspada sekali, jika tidak teruskan. Penggunaan alertuntuk STDOUT seperti jawaban ini .

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

Python 2, 29 byte

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

Ini diakhiri dengan kesalahan pembagian aktif 0, yang diizinkan secara default .

Brainfuck, 41 36 31 30 byte

Dipersingkat dengan mencetak sekali setelah input dan dengan bantuan dari Ethan dan pengguna 46915.

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

Versi sebelumnya: Kurangi 48 dari input, dan jika bukan nol, tambahkan 1 ke 48 untuk mencetak ASCII 1selamanya, jika tidak cetak 0.

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

Saya menjalankannya di sini , tetapi karena buffered output, Anda tidak dapat melihat output apa pun karena program tidak pernah berakhir 1.

Sunting: Saya lupa mencetak 0pada input 0. Diperbaiki sekarang Saya suka >.<wajah - wajah di akhir.

Piet, 27 18 16 kode

(Codel adalah nama mewah untuk piksel yang digunakan untuk menghindari kebingungan ketika gambar diregangkan untuk dilihat. Saya menghitung codel alih-alih byte karena skrip piet disimpan sebagai gambar, sehingga ukuran fisiknya dapat bervariasi. Saya pikir format file yang ideal akan menghemat piet ini seefisien mungkin akan membutuhkan 11 byte. Dalam praktiknya, file gif kecil saya adalah 62 byte, dengan data palet optimal. Katakan apakah saya harus menggunakan ini sebagai ukuran entri saya dan bukan jumlah codel.)

Gambar asli:

Diperbesar:

Dalam piet, perbedaan antara dua warna adalah apa yang menentukan perintah mana yang berjalan, jadi melihat warna yang sama dua kali tidak berarti ia melakukan tindakan yang sama. Eksekusi dimulai di codel kiri atas. Kemudian bergerak secara horizontal, melakukan hal berikut:

1. Baca nomor dan letakkan di tumpukan
2. Gandakan bagian atas tumpukan
3. Pop dan output bagian atas tumpukan
4. Letakkan bagian atas tumpukan dan putar searah jarum jam beberapa kali.

Jika inputnya 1, kursor kemudian bergerak ke bawah ke dalam kode kapur, yang mendorong 1 pada tumpukan. Kemudian eksekusi terus ke kiri. Ketika kursor beralih dari warna ke putih dan dari putih ke warna, tidak ada yang terjadi. Karena hitam juga dianggap sebagai dinding, kursor akhirnya akan kembali ke kode kapur di baris paling atas, dan mengulangi semuanya dari langkah 2.

Namun, jika inputnya adalah 0, kursor tidak akan pernah turun dan akan berakhir di J biru di sebelah kanan (pun intended, itu sepadan), jika itu akan tetap terjebak (karena bagian atas, kanan, kiri dan sisi bawah blok berbentuk J ini di sebelah kode hitam atau tepi gambar). Karena kursor terperangkap, eksekusi berakhir.

Nilai yang tidak terduga:
Jika pengguna menulis nomor lain, itu masih akan dicetak, maka kursor akan berputar lebih atau kurang kali berdasarkan nilai.

• Kelipatan 4 atau 0: eksekusi berlanjut secara horizontal dan berakhir.
• Kelipatan 3: Karena naik tidak mungkin, kursor segera berputar searah jarum jam dan berlanjut secara horizontal, lalu berakhir.
• Kelipatan 2 dan bukan kelipatan 4: kursor berputar dan mulai bergerak ke kiri. Untungnya, semua ini dilakukan adalah melakukan banyak operasi yang tidak mempengaruhi aliran program dan akhirnya mengosongkan tumpukan. Ketika suatu operasi tidak dapat dilakukan karena stack kosong, itu hanya diabaikan. Ketika menyentuh sudut kiri atas, kursor tidak punya tempat lain untuk pergi tetapi ke kanan lagi, secara efektif memulai kembali program.
• Nilai-nilai lain: Kursor turun seperti jika dengan 1, yang membuatnya mencetak 1 selamanya. Jika inputnya 5, outputnya akan5111111111111...

Nilai non-integer apa pun akan menghentikan program. Eksekusi akan berlanjut secara normal, tetapi semua operasi akan diabaikan karena tidak ada dalam stack. Jadi sedikit banyak, program tidak pernah crash - baik berhenti secara normal atau berulang selamanya.

Versi ramah PietDev

PietDev (Piet IDE online yang sangat mendasar) tampaknya memiliki masalah dengan codel putih jadi saya membuat versi baru yang secara manual memutar kembali alih-alih mengandalkan rotasi otomatis codel putih yang tepat. Dan saya bahkan tidak perlu menggunakan warna baru! Jika Anda ingin mengujinya, pastikan Anda menggambar batas hitam di sekitar kode karena PietDev tidak mendukung ukuran program khusus.

Versi yang lebih lama

Versi pertama tidak mendorong 1 kembali ke tumpukan dan sebaliknya kembali ke instruksi duplikasi sebelumnya. Itu juga memiliki codel dekoratif tidak berguna.

Lalu aku punya ide untuk mendorong 1 pada tumpukan untuk menghapus garis kosong. Sangat lucu bagaimana saya memikirkannya berkat kode dekoratif saya.

Kemudian saya menyadari bahwa saya memiliki dup eksternal yang tidak diperlukan lagi, dan saya mengurangi jumlah warna untuk disimpan pada data palet pada gambar. Saya juga menyingkirkan codel dekoratif tunggal karena saya tidak tahu.

Pyth, 4 3 2

Wp

Ada sebuah ada! trailing space (terima kasih isaac :)). Ruang yang digunakan untuk membuat kompilasi while, tetapi Pyth sejak itu telah diperbarui. Biasanya itu akan mendiskualifikasi menggunakannya, tetapi karena ini adalah katalog itu harus valid.

Penjelasan:

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

Chip , 6 byte

e*faAs

Chip adalah bahasa 2D yang berperilaku sedikit seperti sirkuit terintegrasi. Dibutuhkan input, satu byte pada satu waktu, dan membagi bit ke elemen input individual. Output menjahit nilai-nilai elemen output kembali bersama menjadi byte.

Mari kita uraikan ini:

*adalah sinyal sumber, itu akan mengirim nilai sebenarnya ke semua elemen yang berdekatan. edan fsesuai dengan bit kelima dan keenam dari output. Jadi, e*fmenghasilkan biner 00110000, yaitu ASCII char "0".

Sekarang, Aadalah bit input apertama dan bit output pertama, jadi aAsalin bit itu dari input ke output. Jadi, ketika dikombinasikan dengan e*f, input ASCII "0" menghasilkan "0", dan "1" menghasilkan "1". (Tidak ada interaksi antara fdan a, karena keduanya tidak menghasilkan sinyal apa pun.)

Pada sakhirnya, ketika diaktifkan oleh sinyal yang benar, akan mencegah input dari maju ke byte berikutnya, yang berarti bahwa semuanya akan berjalan lagi dengan input yang sama.

Karena byte pertama "0" adalah nol, itu tidak akan mengaktifkan elemen ini dan program akan mencetak "0", dan dengan demikian menghabiskan inputnya, yang memungkinkannya untuk berhenti. "1", bagaimanapun, mengaktifkan elemen ini, yang berarti bahwa "1" adalah output, tetapi tidak dikonsumsi pada input, memungkinkan siklus untuk mengulang tanpa batas.

Jika nilai 0x0 dan 0x1 digunakan untuk output, daripada ASCII, kita bisa menghilangkan e*fbagian tersebut, yang hanya menghasilkan 3 byte :

aAs

Jika nol harus mengakhiri sendiri, daripada mengharapkan stdin untuk menutup, kita mendapatkan yang berikut, yang membalikkan byte pertama dengan ~, dan meneruskan hasilnya ke t, yang mengakhiri program ( 10 byte ):

aA~te*f
 s

( tjuga tidak menghasilkan sinyal, sehingga tidak ada interaksi antara tdan e.)

Brainbool , 5 byte

,.[.]

Brainbool adalah Brainfuck, tetapi hanya beroperasi pada bit, dan apakah I / O melalui 0dan 1karakter.

LOLCODE, 119 byte

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

Tidak Terkumpul:

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 byte

Pandangan berbeda tentang bagaimana melakukannya dalam C.

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

cdefault ke suatu intnilai 1. gets(&c)mendapat string dari stdin, di sini mengalahkan nilai c, peretasan karena cbukan char*. putchar(c)mencetak nilai cke stdout, dan mengembalikan c. Karena '0'48 dan '1'49 di ASCII, kita bisa menggunakan bit terakhir ( &1) untuk menentukan yang mana. Jika ya '0', loop akan putus. Kalau tidak, itu akan berlangsung selamanya.

Kompilasi (dengan peringatan tentang gets) dan berjalan gcc-4.8di Linux.

Labirin , 7 byte

 ?+
@!:

Labyrinth adalah bahasa berbasis stack 2D di mana aliran kontrol bergantung pada tanda elemen teratas stack, diperiksa setelah setiap instruksi. Eksekusi mulai bergerak ke kanan dari instruksi pertama yang valid di baris atas, yang di sini adalah ?.

Instruksi yang relevan adalah:

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

Jika inputnya adalah 0, IP membaca input dengan ?, menambahkan dua teratas stack ( 0 + 0 = 0), kemudian menduplikasi :dan mengeluarkan !nilai 0. Di sini kita menemukan persimpangan tunggal dalam program, dan harus memeriksa bagian atas stack untuk menentukan ke mana harus pergi. Karena yang teratas adalah 0, kami bergerak maju dan berakhir dengan @.

Di sisi lain, jika inputnya adalah 1, kita melakukan instruksi yang sama seperti sebelumnya (tetapi menghasilkan 1) sebelum mencapai persimpangan di !. Sekarang bagian atas tumpukan positif, menyebabkan kita berbelok ke kanan ke ?. Pada EOF Labyrinth menekan 0, jadi kita lakukan 0 + 1 = 1pada +, duplikat :, dan keluaran !. Sekali lagi kita memiliki 1 di bagian atas tumpukan dan loop berlanjut.

Untuk bonus, inilah solusi 7 byte @ MartinBüttner, yang beroperasi dengan cara yang sama:

?+!@
1!

Perhatikan bahwa, tidak seperti kebanyakan bahasa lainnya, 1sebenarnya muncul ntumpukan dan dorongan n*10 + 1, membuat penumpukan jumlah besar menjadi mudah. Namun, karena bagian atas tumpukan kosong pada titik itu, tidak ada bedanya dengan hanya mendorong 1.

> <> , 7 byte

i2%:n:,

Ini menggunakan fakta bahwa> <> mendorong -1 pada EOF, yaitu 1 mod 2. Ini juga menggunakan divide by 0 untuk terminasi (yang tampaknya oke karena konsensusnya adalah bahwa output STDERR diabaikan).

Hanya untuk referensi, keluar dengan bersih tanpa kesalahan adalah byte tambahan:

i2%:n?!;

APL, 6 byte

→⎕←⍣⍲⎕

Penjelasan:

     ⎕ 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 byte

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

Di sini, <SOH>harus diganti dengan karakter kontrol yang sesuai (0x01).

Penjelasan

Ide dasarnya adalah untuk mengurangi kode karakter dari input (48 atau 49) dari ppada akhir Chuck, yang akan memberikan ?(yang merupakan perintah yang valid) atau @yang merupakan no-op.

,membaca karakter input ke dalam sel pertama Chuck (ditandai dengan _). Kami ingin mengurangi nilai ini menjadi 0dalam satu lingkaran, sambil membuat beberapa perubahan lain:

}<pindah ke pdan -menurunkannya. Kemudian {bergerak kembali ke -pengurangan sel input juga. Selama ini belum nol, ?berikan kontrol pada Chuck. Sekarang, >gerakkan selotip Brian di satu sel ke kanan (yang diinisialisasi 1) dan +tambahkan itu. Kemudian kita atur ulang loop dengan {?.

Pada saat sel pertama pada Chuck hits 0, <SOH>sel akan bertambah ke karakter yang telah kita baca dari STDIN dan pakan ?untuk input 1atau @untuk input 0.

Sekarang ?tidak beralih kontrol lagi. The 0atau 1setelah itu adalah no-op, seperti nol-byte (diwakili oleh _). {pindah kembali ke sel pertama Chuck dan +menambahkannya untuk memastikan bahwa itu positif, sehingga ?tangan mengendalikan Chuck.

Kali ini >+menambah sel setelah akhir rekaman awal Brian. Sel itu adalah sampah tetapi kita tidak akan pernah menggunakannya. Sekarang {tidak memindai sampai ke bagian depan kaset Brian, tetapi hanya ke _. Karenanya ?adalah no-op karena sel saat ini nol. Kemudian <.pindahkan satu ke kiri (salinan karakter input) dan cetak.

Akhirnya, kami menemukan ?atau @. Jika inputnya 0dan sel ini adalah @no-op dan program berakhir. Tetapi jika inputnya adalah 1dan sel ini ?kita serahkan ke Brian yang {+?akan mengatur ulang loop pada Chuck, dan sekarang kita mencetak 1selamanya (sampai bilangan bulat di sel pada akhir rekaman Brian tidak masuk ke dalam memori. lebih lanjut, saya kira ...).

Bonus

Sp3000 dan saya bermain golf selama beberapa hari. Kami memulai sekitar 40 byte dan tiba di dua solusi yang sama sekali berbeda, tetapi terikat pada 26 byte. Hanya ketika saya mulai menulis penjelasan untuk saya, apakah solusi 21-byte di atas terjadi pada saya. Banyak terima kasih kepada Sp karena telah melontarkan ide dan mengajarkan satu sama lain beberapa trik golf di B&C. :)

Ini adalah solusi 26 byte-nya:

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

Dan ini milik saya:

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

Di mana ®byte dengan nilai 174 (mis. Simpan saja file tersebut sebagai ISO 8859-1).

Pada core mine bekerja sama dengan solusi 21-byte, yaitu ®menjadi }untuk input 1dan ~(no-op) untuk input 0, tetapi pelaksanaannya jauh kurang elegan.

Solusinya cukup rapi karena kode sumbernya hanya ASCII dan tidak memerlukan perulangan untuk memproses input. Alih-alih, ----berubah 1menjadi -dan 0menjadi ,(larangan untuk Chuck). Itu -kemudian akan mengubah yang pertama ?pada rekaman Brian menjadi >, sehingga menciptakan aliran kontrol yang berbeda untuk 1-case.

Tag Cyclic Bitwise , 3 bit atau <1 byte

Tag Bitwise Cyclic adalah salah satu bahasa lengkap Turing-lengkap di luar sana. Ia bekerja dengan dua bitstring, program dan data . Bit-bit program dibaca secara siklikal dan diinterpretasikan sebagai berikut:

• 0: Hapus bit data pertama (dan hasilkan, dalam implementasi yang memiliki keluaran).
• 1x: Jika bit data pertama adalah 1, tambahkan x(mewakili salah satu 0atau 1) ke akhir data. (Jika bit data pertama adalah 0, jangan lakukan apa-apa.)

Program berjalan sampai string data kosong.

Mesin kebenaran

110

Ketika string data diatur ke 0:

• 11tidak menambahkan apa pun karena bit data pertama tidak 1.
• 0menghapus / output 0.
• String data sekarang kosong dan program berhenti.

Ketika string data diatur ke 1:

• 11menambahkan a 1.
• 0menghapus / output 1.
• String data kembali ke satu 1dan program kembali ke tempat awalnya, jadi kami mengulang selamanya.

GNU sed, 10

:;/1/{p;b}

Penjelasan

• : tentukan label tanpa nama
• /1/Jika input cocok dengan regex 1, maka
• p cetak ruang pola (yaitu 1)
• b dan melompat kembali ke label yang tidak disebutkan namanya (selamanya)
• Jika input bukan 1 (yaitu 0), maka ruang pola dicetak tidak dimodifikasi dan program berakhir.

Serius , 4 3 byte

_{Dicoret 4 masih 4 :(}

,W■

,membaca nilai dari STDIN. Wmemulai loop yang berjalan sementara nilai di atas tumpukan benar, dengan tubuh ■. ■mencetak elemen tumpukan atas tanpa muncul. Loop tertutup secara implisit di EOF.

Pada input 0, loop tidak pernah dieksekusi (karena 0adalah falsey), dan program berakhir pada EOF, secara otomatis muncul dan mencetak setiap nilai pada stack. Pada masukan dari 1(atau nilai yang tidak 0, ""atau []), loop berjalan jauh.

Dalam Sebenarnya , pimpinan ,tidak diperlukan (berkat input tersirat), sehingga skor turun menjadi 2 byte.

Thue, 34 byte

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

Penjelasan:

1::=12 Contoh dari substring "1" dapat menjadi "12"

2::=~1 Contoh dari substring "2" dapat dihapus, mencetak "1"

0::=~0 Contoh dari substring "0" dapat dihapus, mencetak "0"

@::=::: Contoh dari substring "@" dapat diganti dengan string dari input

::= Daftar akhir aturan substitusi

@ String awal adalah "@"

Arnold C, 134 byte

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

Meskipun ini tidak menghibur seperti jawaban ArnoldC lainnya , itu golf . Sebagai contoh, lekukan tidak perlu, begitu juga makro @NO PROBLEMOdan @I LIED.

Diuji dengan versi bahasa ini , yang tidak dapat menerima input.

Cubix , 5 6 byte

Cubix adalah @ETHproduksi bahasa 2 dimensi baru di mana perintah dililitkan di sekitar permukaan kubus. Penerjemah online Berkat @ETHproduk untuk penghematan.

!I\@O

Ini akhirnya diperluas ke kubus

  !
I \ @ O
  .

Ini dimulai dengan Iperintah. Masukkan bilangan bulat ke tumpukan.
\, mengarahkan ulang penunjuk instruksi ke bawah pada no op.
O, menampilkan nilai numerik atas tumpukan.
!, lewati perintah berikutnya ( @) jika bagian atas tumpukan benar. Ini akan melompat \redirect jika 1
\, mengarahkan ulang pointer instruksi ke @program keluar.

Ini mengambil keuntungan dari fakta bahwa stack tidak muncul oleh O ? !perintah.

Foo , 6 byte

&1($i)

Input hardcoded sebagai karakter kedua, karena Foo tidak memiliki input STDIN. Bukankah kita sepakat bahwa Foo luar biasa sekarang? :)

Penjelasan

&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 byte

print while$_

Jalankan seperti ini:

echo -n NUM | perl -p truth.pl

Terima kasih kepada ThisSuitIsBlackNot (yang jauh lebih baik di golf daripada saya) untuk bermain golf lima byte.

> <> , 6 byte

::n?!;

Dorong input pada tumpukan untuk memulai

:        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