Misalnya, gerbang A and Badalah gerbang logika dengan 2 input dan 1 output.

Tepatnya ada 16 di antaranya, karena:

• setiap gerbang logika membutuhkan dua input, yang bisa berupa benar atau salah, memberi kita 4 input yang mungkin
• dari 4 input yang mungkin, masing-masing dapat memiliki output dari truey dan falsey
• oleh karena itu, ada 2 ^ 4 gerbang logika yang mungkin, yaitu 16.

Tugas Anda adalah menulis 16 program / fungsi yang mengimplementasikan semuanya secara terpisah.

Fungsi / program Anda harus independen .

Mereka valid selama mereka menghasilkan nilai-nilai kebenaran / falsey, yang berarti bahwa Anda dapat mengimplementasikan A or Bdengan Python lambda a,b:a+b, bahkan jika 2diproduksi untuk A=Truedan B=True.

Skor adalah total byte yang digunakan untuk setiap fungsi / program.

Daftar gerbang logika

1. 0,0,0,0 ( false)
2. 0,0,0,1 ( and)
3. 0,0,1,0 ( A and not B)
4. 0,0,1,1 ( A)
5. 0,1,0,0 ( not A and B)
6. 0,1,0,1 ( B)
7. 0,1,1,0 ( xor)
8. 0,1,1,1 ( or)
9. 1,0,0,0 ( nor)
10. 1,0,0,1 ( xnor)
11. 1,0,1,0 ( not B)
12. 1,0,1,1 ( B implies A)
13. 1,1,0,0 ( not A)
14. 1,1,0,1 ( A implies B)
15. 1,1,1,0 ( nand)
16. 1,1,1,1 ( true)

Dimana angka pertama adalah output untuk A=false, B=false, angka kedua adalah output untuk A=false, B=true, angka ketiga adalah output untuk A=true, B=false, angka keempat adalah output untuk A=true, B=true.

Papan peringkat

var QUESTION_ID=82938,OVERRIDE_USER=48934;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+(?:\.\d+)?)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<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="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><div id="language-list"> <h2>Winners 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><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>

Domino , 122.000 byte atau 72 ubin

Jumlah byte adalah ukuran file yang disimpan0.122 MB .

Komputasi domino adalah inspirasi. Saya telah menguji semua ini hingga simetri (dan seterusnya!) Melalui game Steam virtual-reality yang disebut Tabletop Simulator .

Detail

• I / O
  • Mulai - Ini termasuk untuk kejelasan (tidak dihitung terhadap total) dan merupakan apa yang 'dipanggil' atau 'dieksekusi' fungsi. Harus 'ditekan' setelah input diberikan [Kuning] .
  • Input A - Ini termasuk untuk kejelasan (tidak dihitung terhadap total) dan 'ditekan' untuk menunjukkan a 1dan tidak ditekan sebaliknya [Hijau] .
  • Input B - Ini termasuk untuk kejelasan (tidak dihitung terhadap total) dan 'ditekan' untuk menunjukkan a 1dan tidak ditekan sebaliknya [Biru] .
  • Output - Ini dihitung terhadap total. Ini adalah domino yang menyatakan hasil dari gerbang logika [Hitam] .
• T / F
  • Domino output yang jatuh mewakili hasil Trueatau1
  • Domino output berdiri mewakili hasil Falseatau0
• Mendesak
  • Untuk memberi masukan atau memulai rantai, buatlah kelereng logam
  • Atur kekuatan angkat ke 100%
  • Angkat marmer di atas domino yang diinginkan
  • Jatuhkan marmer

Gates

• salah, 1
  • 
• dan, 6 4
  • 
• A dan bukan B, 4 3
  • 
• A, 1
  • 
• bukan A dan B, 4 3
  • 
• B, 1
  • 
• xor, 15 11
  • 
• atau, 1
  • 
• juga, 3 2
  • 
• xnor, 17 13
  • 
• bukan B, 2
  • 
• B menyiratkan A, 7 6
  • 
• bukan A, 2
  • 
• A menyiratkan B, 7 6
  • 
• nand, 16 15
  • 
  • benar, 1
  • 

TL; DR

Saya telah menunggu / menginginkan tantangan ramah-domino dan ketika saya melihat ini, saya tidak bisa melewatkannya. Satu-satunya masalah adalah bahwa ternyata tidak ada yang memiliki kartu domino lagi! Jadi akhirnya saya menyerah dan membeli Double Twelve . Set ini memiliki 91 ubin, yang memberi saya ide untuk memiliki 'panggilan fungsi' / mulai domino daripada metode 'waktu tunda' yang normal (lama). Kredit untuk pergantian 90 derajat adalah milik saluran dominoesdouble07 .

Setelah membangun ini dengan domino fisik, diputuskan pada meta bahwa solusi yang valid harus digital. Jadi saya menciptakan kembali gerbang ini di Simulator Meja . Sayangnya, TS dan kenyataan tidak setuju dengan fisika domino. Ini mengharuskan saya menambahkan 11 kartu domino tetapi saya juga menyelamatkan 8. Secara keseluruhan, kartu domino virtual sekitar x150 lebih efektif dalam hal membangun dan menguji ( Ctrl+ Z).

Memperbarui

• -9 [17-03-13] Dipendekkanxor xnor nand
• [17-03-04] Menambahkan tautan ke file bengkel
• +11 [17-03-03] Menambahkan digital xnordanxor
• -8 [17-03-03] Mendigitalkan semua gerbang (kecuali xordan xnor). Memblokir di Tabletop hanya membutuhkan 1 domino, bukan 2.
• [16-09-23] Gambar menyusut
• -11 [16-09-18] Hampir memotong xor menjadi dua lagi. Terima kasih kepada @DJMcMayhem untuk xnor dan Joe untuk xor.
• -31 [16-08-31] Diperbarui beberapa foto dan mencukur beberapa ubin dan memotong xor menjadi dua
• [16-08-28] Menambahkan gambar

Hexagony , 89 byte

Terima kasih kepada FryAmTheEggman untuk beberapa inspirasi yang diperlukan untuk solusi XOR.

0000 !@
0001 ?.|@!
0010 #?#!)@
0011 ?!@
0100 +?|@!?
0101 ??!@
0110 ?<@!!<_\~(
0111 ?<<@!
1000 )\!#?@{
1001 (~?/@#!
1010 ??|@!)
1011 \#??!1@
1100 ?(~!@
1101 ?.|@!)
1110 ?$@#)!<
1111 1!@

Semua program menggunakan 0false dan 1true.

Cobalah online! Ini bukan test suite, Anda harus menyalin di berbagai program dan memasukkan sendiri.

Solusi di atas adalah dalam 2-byte optimalitas (kecuali kita mengendurkan interpretasi yang benar / salah, saya kira). Aku telah membiarkan sebuah kasar pencarian kekuatan kabur dekat dengan dua hari atas semua program yang masuk ke dalam sisi-panjang 2, yaitu hingga 7 byte (tidak cukup semua program - Saya membuat beberapa asumsi tentang apa yang setiap kebutuhan program yang valid dan apa yang tidak ada program yang valid dapat memiliki). Pencarian menemukan solusi untuk 15 dari 16 kemungkinan gerbang - dan seringkali lebih dari satu. Anda dapat menemukan daftar semua solusi alternatif di pastebin ini di mana saya juga mengelompokkannya berdasarkan perilaku yang setara. Yang saya tunjukkan di atas saya pilih karena mereka adalah solusi paling sederhana atau paling menarik, dan saya akan menambahkan penjelasan untuk mereka besok.

Adapun gerbang ke-16: XOR adalah satu-satunya gerbang yang tampaknya tidak dapat diimplementasikan dalam 7 byte. Pencarian brute force melalui program yang lebih besar sayangnya tidak layak dengan kode yang saya miliki saat ini. Jadi XOR harus ditulis dengan tangan. Yang terpendek yang saya temukan sejauh ini adalah program 10-byte di atas, yang didasarkan pada upaya gagal (tapi sangat dekat) oleh FryAmTheEggman. Ada kemungkinan bahwa solusi 8-byte atau 9-byte ada, tetapi selain itu, semua solusi memang harus optimal.

Penjelasan

Peringatan: dinding teks. Jika ada yang tertarik bagaimana program Hexagony yang sangat padat ini benar-benar bekerja, saya telah menyertakan penjelasan untuk masing-masingnya di bawah ini. Saya telah mencoba untuk memilih solusi paling sederhana untuk setiap gerbang dalam kasus di mana ada lebih dari satu program optimal, agar penjelasannya cukup singkat. Namun, beberapa dari mereka masih merusakkan pikiran, jadi saya pikir mereka pantas mendapatkan penjelasan lebih lanjut.

0000: Salah

Saya tidak berpikir kita akan membutuhkan diagram untuk yang ini:

 ! @
. . .
 . .

Karena seluruh kotak memori diinisialisasi ke nol, !cukup cetak nol dan @akhiri program.

Ini juga satu-satunya solusi 2-byte.

0001: Dan

 ? .
| @ !
 . .

Ini pada dasarnya menerapkan hubungan arus pendek . Diagram abu-abu di bawah ini menunjukkan awal program, di mana input pertama dibaca dengan ?dan penunjuk instruksi (IP) membungkus ke sudut kiri di mana |cermin memantulkannya. Sekarang sudut bertindak sebagai kondisional, seperti ada dua jalur eksekusi yang berbeda tergantung pada nilai input pertama. Diagram merah menunjukkan aliran kontrol untuk A = 0dan diagram hijau untuk A = 1:

Seperti yang Anda lihat, ketika Aada 0, maka kita cukup mencetaknya dan mengakhiri (ingat bahwa semua .adalah tanpa operasi). Tapi ketika Aadalah 1, maka IP melintasi baris pertama lagi, membaca Bdan pencetakan yang sebaliknya.

Total ada enam belas solusi 5-byte untuk gerbang ini. Empat belas dari mereka pada dasarnya sama dengan yang di atas, baik menggunakan >alih-alih |atau mengganti .dengan perintah yang secara efektif no-op, atau menempatkan ?di posisi kedua:

?.|@!    .?|@!    ?=|@!    =?|@!    ?_|@!    _?|@!    ?0|@!
?.>@!    .?>@!    ?=>@!    =?>@!    ?_>@!    _?>@!    ?0>@!

Dan kemudian ada dua solusi lain (yang setara satu sama lain). Ini juga menerapkan logika hubungan pendek yang sama, tetapi jalur eksekusi agak lebih gila (dan dibiarkan sebagai latihan bagi pembaca):

?<!@|
?<!@<

0010: A dan bukan B

 # ?
# ! )
 @ .

Ini juga mengimplementasikan bentuk hubungan arus pendek, tetapi karena penggunaan #aliran kontrol jauh lebih sulit. #adalah saklar IP bersyarat. Hexagony sebenarnya berasal dengan enam IP berlabel 0untuk 5, yang dimulai pada enam sudut grid, menunjuk sepanjang tepi searah jarum jam mereka (dan program selalu dimulai dengan IP 0). Ketika a #ditemui, nilai saat ini diambil modulo 6, dan aliran kontrol berlanjut dengan IP yang sesuai. Saya tidak yakin apa yang cocok dengan kegilaan membuat saya menambahkan fitur ini, tetapi tentu saja memungkinkan untuk beberapa program mengejutkan (seperti ini).

Kami akan membedakan tiga kasus. Kapan A = 0, program ini cukup sederhana, karena nilainya selalu 0ketika #ditemui sehingga tidak ada IP-switching yang terjadi:

#tidak melakukan apa-apa, ?membaca A(yaitu juga tidak melakukan apa-apa), #masih tidak melakukan apa-apa, !mencetak 0, )menambahnya (ini penting, jika IP tidak akan melompat ke baris ketiga), @mengakhiri program. Cukup sederhana. Sekarang mari kita perhatikan kasusnya (A, B) = (1, 0):

Jalur merah masih sesuai dengan IP 0, dan saya telah menambahkan jalur hijau untuk IP 1. Kami melihat bahwa setelah ?membaca A( 1kali ini), #beralih ke IP yang dimulai di sudut kanan atas. Itu artinya ?bisa membaca B( 0). Sekarang )menambahkan itu ke 1, sehingga #di sudut kiri atas tidak melakukan apa-apa dan kami tetap dengan IP 1. The !cetakan yang 1dan IP membungkus di sekitar diagonal kiri. #masih tidak melakukan apa-apa dan @menghentikan program.

Akhirnya, kasus yang sangat aneh di mana kedua input adalah 1:

Kali ini, input kedua juga 1dan )menambahnya 2. Itu berarti #di sudut kiri atas menyebabkan lain beralih IP ke IP 2, menunjukkan warna biru. Di jalur itu, pertama-tama kita menambahnya lebih jauh 3(meskipun itu tidak relevan) dan kemudian melewati yang ?ketiga kalinya. Karena kita sekarang telah menekan EOF (yaitu input habis), ?mengembalikan 0, !mencetak itu, dan @mengakhiri program.

Khususnya, ini adalah satu-satunya solusi 6-byte untuk gerbang ini.

0011: SEBUAH

 ? !
@ . .
 . .

Ini cukup sederhana sehingga kita tidak memerlukan diagram: ?membaca A, !mencetak, @mengakhiri.

Ini adalah satu-satunya solusi 3-byte untuk gerbang ini. (Pada prinsipnya, itu juga mungkin dilakukan ,;@, tetapi pencarian tidak termasuk ;, karena saya tidak berpikir itu bisa menghemat byte !untuk tugas ini.)

0100: B dan bukan A

 + ?
| @ !
 ? .

Yang ini jauh lebih sederhana daripada "saudara" nya 0010. Aliran kontrol sebenarnya sama seperti yang telah kita lihat di atas untuk 0001(Dan). Jika A = 0, maka IP akan melintasi garis bawah, membaca Bdan mencetaknya sebelum mengakhiri. Jika A = 1kemudian IP melintasi baris pertama lagi, juga membaca B, tetapi +menambahkan dua tepi memori yang tidak digunakan sehingga semua yang dilakukannya adalah mereset nilai saat ini 0, sehingga !selalu dicetak 0.

Ada cukup banyak alternatif 6-byte untuk ini (totalnya 42). Pertama, ada satu ton solusi yang setara dengan yang di atas. Kita dapat kembali memilih antara |dan >, dan +dapat diganti dengan perintah lain yang memberi kita keunggulan kosong:

"?|@!?    &?|@!?    '?|@!?    *?|@!?    +?|@!?    -?|@!?    ^?|@!?    {?|@!?    }?|@!?
"?>@!?    &?>@!?    '?>@!?    *?>@!?    +?>@!?    -?>@!?    ^?>@!?    {?>@!?    }?>@!?

Selain itu, kita juga bisa menggunakan ]bukan ?. ]pindah ke IP berikutnya (yaitu memilih IP 1), sehingga cabang ini malah menggunakan kembali ?di sudut kanan atas. Itu memberi 18 solusi lain:

"?|@!]    &?|@!]    '?|@!]    *?|@!]    +?|@!]    -?|@!]    ^?|@!]    {?|@!]    }?|@!]
"?>@!]    &?>@!]    '?>@!]    *?>@!]    +?>@!]    -?>@!]    ^?>@!]    {?>@!]    }?>@!]

Dan kemudian ada enam solusi lain yang semuanya bekerja secara berbeda dengan berbagai tingkat kegilaan:

/[<@!?    ?(#!@]    ?(#>@!    ?/@#/!    [<<@!?    [@$\!?

0101: B

 ? ?
! @ .
 . .

Woohoo, satu lagi yang sederhana: baca A, baca B, cetak B, hentikan. Sebenarnya ada alternatif untuk ini. Karena Ahanya satu karakter, kita juga dapat membacanya dengan ,:

,?!@

Dan ada juga opsi untuk menggunakan satu ?dan menggunakan cermin untuk menjalankannya dua kali:

?|@!    ?>@!

0110: Xor

  ? < @
 ! ! < _
\ ~ ( . .
 . . . .
  . . .

Seperti yang saya katakan di atas, ini adalah satu-satunya gerbang yang tidak akan cocok dengan sisi panjang 2, jadi ini solusi tulisan tangan oleh FryAmTheEggman dan saya sendiri, dan ada peluang bagus bahwa itu tidak optimal. Ada dua kasus untuk dibedakan. Jika A = 0aliran kontrolnya cukup sederhana (karena dalam hal ini kita hanya perlu mencetak B):

Kami mulai di jalur merah. ?berbunyi A, <adalah cabang yang membelokkan nol kiri. IP membungkus ke bawah, lalu _cermin lain, dan ketika IP menyentuh sudut, itu membungkus ke sudut kiri atas dan berlanjut di jalur biru. ?membaca B, !mencetaknya. Sekarang (dekrementasi. Ini penting karena memastikan nilainya tidak positif (baik sekarang 0atau -1sekarang). Itu membuat IP wrap ke sudut kanan, tempat @mengakhiri program.

Ketika A = 1segalanya menjadi sedikit rumit. Dalam hal ini kami ingin mencetak not B, yang dengan sendirinya tidak terlalu sulit, tetapi jalur eksekusi agak trippy.

Kali ini, <IP membelokkan ke kanan dan selanjutnya <hanya bertindak sebagai cermin. Jadi IP melewati jalur yang sama secara terbalik, membaca Bketika bertemu ?lagi. IP membungkus ke sudut kanan dan melanjutkan di jalur hijau. Ini pertemuan berikutnya (~yang "penurunan, kalikan dengan -1", yang swap 0dan 1dan karena itu menghitung not B. \hanyalah sebuah cermin dan !mencetak hasil yang diinginkan. Kemudian ?cobalah untuk mengembalikan nomor lain tetapi mengembalikan nol. IP sekarang berlanjut di sudut kiri bawah di jalur biru. (decrements, <mencerminkan,(menurun lagi, sehingga nilai saat ini negatif ketika IP menyentuh sudut. Bergerak melintasi diagonal kanan bawah dan akhirnya hits @untuk menghentikan program.

0111: Atau

 ? <
< @ !
 . .

Lebih banyak korsleting.

The A = 0kasus (jalur merah) adalah sedikit membingungkan di sini. IP dibelokkan ke kiri, membungkus ke sudut kiri bawah, langsung tercermin oleh <dan kembali ?ke membaca B. Kemudian membungkus ke sudut rigt, mencetak Bdengan !dan berakhir.

The A = 1kasus (jalur hijau) adalah sedikit lebih sederhana. The <cabang mengalihkan IP yang tepat, jadi kami hanya mencetak !, membungkus kembali ke kiri atas, dan berakhir pada @.

Hanya ada satu solusi 5-byte lainnya:

\>?@!

Ini bekerja pada dasarnya sama, tetapi jalur eksekusi yang sebenarnya sangat berbeda dan menggunakan sudut untuk percabangan bukannya a <.

1000: Juga

 ) \
! # ?
 @ {

Ini mungkin program favorit saya yang ditemukan dalam pencarian ini. Yang paling keren adalah implementasi ini norbenar - benar berfungsi hingga 5 input. Saya harus masuk ke detail model memori sedikit untuk menjelaskan yang ini. Jadi sebagai penyegaran cepat, model memori Hexagony adalah kisi heksagonal terpisah, di mana setiap sisi memegang nilai integer (awalnya semuanya nol). Ada penunjuk memori (MP) yang menunjukkan tepi dan arah sepanjang tepi itu (sedemikian rupa sehingga ada dua tepi tetangga di depan dan di belakang tepi saat ini, dengan tetangga kiri dan kanan yang berarti). Berikut adalah diagram tepi yang akan kami gunakan, dengan MP dimulai seperti yang ditunjukkan dengan warna merah:

Pertama mari kita perhatikan kasus di mana kedua input berada 0:

Kita mulai di jalur abu-abu, yang hanya menambah tepi A ke 1sehingga #beralih ke IP 1yang merupakan jalur biru, mulai dari sudut kanan atas. \tidak melakukan apa pun di sana dan ?membaca input. Kami membungkus ke sudut kiri atas tempat )penambahan input itu. Sekarang selama inputnya nol, ini akan menghasilkan a 1, sehingga #tidak melakukan apa-apa. Kemudian {bergerak MP ke kiri, yaitu pada iterasi pertama dari A ke B . Karena tepi ini masih memiliki nol awal IP membungkus kembali ke sudut kanan atas dan di tepi memori baru. Jadi loop ini akan terus berlanjut selama ?membaca nol, menggerakkan MP di sekitar segi enam dari Bke C ke D dan seterusnya. Tidak masalah apakah ?mengembalikan nol karena input atau karena EOF.

Setelah enam iterasi melalui loop ini, {kembali ke A . Kali ini, ujung sudah memegang nilai 1dari iterasi pertama, sehingga IP membungkus ke sudut kiri dan melanjutkan pada jalur hijau sebagai gantinya. !hanya mencetak itu 1dan @menghentikan program.

Sekarang bagaimana jika ada input 1?

Kemudian ?bacalah itu 1di beberapa titik dan )tambahkan ke 2. Itu berarti #sekarang akan beralih IP lagi dan kami akan melanjutkan di sudut kanan di jalur merah. ?membaca input lain (jika ada), yang tidak terlalu penting dan {bergerak lebih jauh. Ini harus menjadi tepi yang tidak digunakan, oleh karena itu ini berfungsi hingga 5 input. IP membungkus ke kanan atas di mana itu segera tercermin dan membungkus ke sudut kiri. !mencetak 0pada tepi yang tidak digunakan dan #beralih kembali ke IP 0. IP itu masih menunggu di sekitar #, menuju barat daya (jalur abu-abu), sehingga segera menyentuh @dan mengakhiri program.

Secara total ada tujuh solusi 7-byte untuk gerbang ini. 5 dari mereka bekerja sama seperti ini dan hanya menggunakan perintah lain untuk pindah ke tepi yang tidak digunakan (dan dapat berjalan di sekitar segi enam yang berbeda atau ke arah yang berbeda):

)\!#?@"    )\!#?@'    )\!#?@^    )\!#?@{    )\!#?@}

Dan ada satu kelas solusi lain yang hanya bekerja dengan dua input, tetapi jalur eksekusi yang sebenarnya lebih berantakan:

?]!|<)@    ?]!|<1@

1001: Kesetaraan

 ( ~
? / @
 # !

Ini juga sangat cerdas dalam menggunakan pemilihan IP bersyarat. Kita perlu membedakan lagi antara A = 0dan A = 1. Dalam kasus pertama kita ingin mencetak not B, dalam kasus kedua kita ingin mencetak B. Karena A = 0kami juga membedakan dua kasus untuk B. Mari kita mulai dengan A = B = 0:

Kami mulai di jalur abu-abu. (~dapat diabaikan, IP membungkus ke sudut kiri (masih di jalur abu-abu) dan membaca Adengan ?. (decrements itu, jadi kita dapatkan -1dan bungkus IP ke sudut kiri bawah. Sekarang seperti yang saya katakan sebelumnya, #ambil modulo nilai 6sebelum memilih dia IP, jadi nilai -1IP benar-benar keluar 5, yang dimulai di sudut kiri di jalur merah. ?berbunyi B, (mengurangi itu juga sehingga kita tetap di IP 5ketika kita menekan #lagi. ~meniadakan -1sehingga IP membungkus ke sudut kanan bawah, mencetak 1dan berakhir.

Sekarang jika Badalah 1sebaliknya, nilai saat akan 0ketika kita memukul #kedua kalinya, jadi kami beralih kembali ke IP 0(sekarang jalan hijau). Itu memukul ?untuk ketiga kalinya, menghasilkan 0, !mencetaknya, dan @berakhir.

Akhirnya, kasusnya dimana A = 1. Kali ini nilai saat ini sudah nol ketika kami menekan #untuk pertama kalinya, jadi ini tidak pernah beralih ke IP 5di tempat pertama. Kami hanya melanjutkan langsung di jalur hijau. ?sekarang tidak hanya memberikan nol tetapi Bmalah mengembalikannya . !mencetaknya dan @berakhir lagi.

Total ada tiga solusi 7-byte untuk gerbang ini. Dua lainnya bekerja sangat berbeda (bahkan dari satu sama lain), dan membuat penggunaan lebih aneh #. Secara khusus mereka membaca satu atau lebih nilai dengan ,(membaca kode karakter alih-alih bilangan bulat) dan kemudian menggunakan nilai itu modulo 6 untuk memilih IP. Ini sangat gila.

),)#?@!

?~#,~!@

1010: Tidak b

 ? ?
| @ !
 ) .

Yang ini cukup sederhana. Jalur eksekusi adalah cabang horizontal yang sudah kita ketahui andsebelumnya. ??membaca Adan kemudian segera B. Setelah merefleksikan |dan bercabang, karena B = 0kita akan mengeksekusi cabang bawah, di mana )menambah nilai 1yang kemudian dicetak oleh !. Di cabang atas (jika B = 1) ?cukup mengatur ulang tepi 0yang kemudian dicetak oleh !.

Ada delapan program 6-byte untuk gerbang ini. Empat dari mereka hampir sama, menggunakan >bukan |atau 1bukan )(atau keduanya):

??>@!)    ??>@!1    ??|@!)    ??|@!1

Dua menggunakan satu ?yang digunakan dua kali karena cermin. Negasi kemudian terjadi seperti yang kita lakukan xordengan (~atau ~).

?>!)~@    ?>!~(@

Dan akhirnya, dua solusi menggunakan saklar IP bersyarat, karena mengapa menggunakan cara sederhana jika yang berbelit-belit juga berfungsi:

??#)!@    ??#1!@

1011: B menyiratkan A

 \ #
? ? !
 1 @

Ini menggunakan beberapa IP switching yang agak rumit. Saya akan mulai dengan A = 1kasing kali ini, karena lebih sederhana:

Kita mulai pada jalur abu-abu, yang berbunyi Adengan ?dan kemudian klik #. Sejak Aadalah 1ini beralih ke IP 1(jalur hijau). The !segera mencetak itu, IP membungkus ke kiri atas, membaca B(tidak perlu) dan berakhir.

Ketika A = 0segalanya menjadi sedikit lebih menarik. Pertama mari kita pertimbangkan A = B = 0:

Kali ini, #tidak melakukan apa-apa dan kami tetap di IP 0(jalur merah sejak saat itu dan seterusnya). ?membaca Bdan 1mengubahnya menjadi 1. Setelah membungkus ke sudut kiri atas, kami menekan #lagi, jadi kami berakhir di jalur hijau, dan mencetak 1seperti sebelumnya, sebelum mengakhiri.

Akhirnya, inilah (A, B) = (0, 1)yang salah:

Perhatikan bahwa saya telah menghapus jalur abu-abu awal untuk kejelasan, tetapi program dimulai dengan cara yang sama, dan kita berakhir di jalur merah seperti sebelumnya. Jadi kali ini yang kedua ?kembali 1. Sekarang kita temui 1. Pada titik ini, penting untuk memahami apa yang sebenarnya dilakukan digit dalam Hexagony (sejauh ini kami hanya menggunakannya pada nol): ketika digit dijumpai, nilai saat ini dikalikan dengan 10 dan kemudian digit ditambahkan. Ini biasanya digunakan untuk menulis angka desimal kata demi kata ke dalam kode sumber, tetapi itu berarti bahwa B = 1sebenarnya dipetakan ke nilai 11. Jadi ketika kita menekan #, ini diambil modulo 6untuk diberikan 5dan karenanya kita beralih ke IP 5(bukan 1seperti sebelumnya) dan melanjutkan di jalur biru. Memukul?ketiga kalinya mengembalikan nol, sehingga !mencetak itu, dan setelah dua yang lain ?, IP membungkus ke kanan bawah di mana program berakhir.

Ada empat solusi 7-byte untuk ini dan mereka semua bekerja secara berbeda:

#)/!?@$    <!?_@#1    \#??!1@    |/)#?@!

1100: Tidak a

 ? (
~ ! @
 . .

Hanya yang linier sederhana: baca Adengan ?, negasikan dengan (~, cetak dengan !, akhiri dengan @.

Ada satu solusi alternatif, dan itu meniadakan dengan ~):

?~)!@

1101: A menyiratkan B

 ? .
| @ !
 ) .

Ini jauh lebih sederhana daripada implikasi sebaliknya yang baru saja kita bicarakan. Lagi-lagi ini adalah salah satu program cabang horizontal, seperti untuk and. Jika Aadalah 0, itu hanya akan bertambah untuk 1di cabang bawah dan dicetak. Kalau tidak, cabang teratas dieksekusi lagi di mana ?membaca Bdan kemudian !mencetaknya.

Ada banyak alternatif di sini (total 66 solusi), sebagian besar karena pilihan bebas dari no-op yang efektif. Sebagai permulaan kami dapat memvariasikan solusi di atas dengan semua cara yang sama yang kami bisa lakukan anddan kami juga dapat memilih antara )dan 1:

?.|@!)    .?|@!)    ?=|@!)    =?|@!)    ?_|@!)    _?|@!)    ?0|@!)
?.|@!1    .?|@!1    ?=|@!1    =?|@!1    ?_|@!1    _?|@!1    ?0|@!1
?.>@!)    .?>@!)    ?=>@!)    =?>@!)    ?_>@!)    _?>@!)    ?0>@!)
?.>@!1    .?>@!1    ?=>@!1    =?>@!1    ?_>@!1    _?>@!1    ?0>@!1

Dan kemudian ada versi yang berbeda menggunakan pemilihan IP bersyarat, di mana perintah pertama dapat dipilih hampir secara sewenang-wenang, dan ada juga pilihan antara )dan 1untuk beberapa opsi tersebut:

"?#1!@    &?#1!@    '?#1!@    )?#1!@    *?#1!@    +?#1!@    -?#1!@    .?#1!@    
0?#1!@    1?#1!@    2?#1!@    3?#1!@    4?#1!@    5?#1!@    6?#1!@    7?#1!@    
8?#1!@    9?#1!@    =?#1!@    ^?#1!@    _?#1!@    {?#1!@    }?#1!@

"?#)!@    &?#)!@    '?#)!@              *?#)!@    +?#)!@    -?#)!@    
0?#)!@              2?#)!@              4?#)!@              6?#)!@    
8?#)!@                        ^?#)!@    _?#)!@    {?#)!@    }?#)!@

1110: Nand

 ? $
@ # )
 ! <

Yang rumit terakhir. Jika Anda masih membaca, Anda hampir berhasil. :) Mari kita lihat A = 0dulu:

?membaca Adan kemudian kami menekan $. Ini adalah perintah lompatan (seperti perintah Befunge #) yang melompati instruksi selanjutnya sehingga kita tidak mengakhiri @. Sebaliknya IP berlanjut di #. Namun sejak Aitu 0, ini tidak melakukan apa-apa. )menambahnya 1sehingga IP melanjutkan di jalur bawah di mana 1dicetak. The <mengalihkan IP ke kanan di mana ia membungkus ke sudut kiri dan program berakhir.

Selanjutnya, ketika inputnya (A, B) = (1, 0)kita dapatkan situasi ini:

Ini pada dasarnya sama seperti sebelumnya, kecuali bahwa pada #kita beralih ke IP 1(jalur hijau), tapi karena Bini 0kita beralih kembali ke IP 0ketika kita memukul #kedua kalinya (jalan sekarang biru), di mana ia mencetak 1seperti sebelumnya.

Akhirnya, A = B = 1kasusnya:

Kali ini, saat kami #kedua kalinya, nilai saat ini masih 1sehingga kami tidak mengubah IP lagi. Yang <memantulkannya dan ketiga kalinya kami menekan ?kami mendapat nol. Oleh karena itu IP membungkus ke kiri bawah di mana !mencetak nol dan program berakhir.

Ada sembilan solusi 7-byte total untuk ini. Alternatif pertama hanya menggunakan 1bukannya ):

?$@#1!<

Lalu ada dua solusi yang akan membantu Anda dengan jumlah IP switching yang terjadi:

)?#_[!@    1?#_[!@

Ini benar-benar mengejutkan saya: bagian yang menarik adalah bahwa IP switching dapat digunakan sebagai persyaratan yang ditangguhkan. Aturan IP-switching bahasa adalah sedemikian rupa sehingga IP saat ini membuat langkah lain sebelum beralih terjadi. Jika langkah itu terjadi melalui sudut, maka nilai saat ini memutuskan cabang IP yang akan dilanjutkan jika kita pernah beralih kembali ke sana. Persisnya ini terjadi ketika input A = B = 1. Meskipun ini semua konsisten dengan bagaimana saya mendesain bahasa, saya tidak pernah menyadari implikasi dari spesifikasi ini, jadi bagus ketika bahasa saya mengajarkan saya beberapa trik baru: D.

Lalu ada solusi ketiga yang jumlah IP switching-nya bahkan lebih buruk (walaupun tidak menggunakan efek kondisional yang ditunda):

>?1]#!@

Dan kemudian ada satu lagi:

?$@#)!<

Dan kemudian ada empat solusi setara ini, yang memang menggunakan beberapa IP switching non-kondisional dan sebaliknya menerapkan semua logika melalui cabang dan sudut:

]<?<@!)    ]<?<@!1    ]|?<@!)    ]|?<@!1

1111: Benar

 1 !
@ . .
 . .

Anda telah mendapatkan sendiri sesuatu yang sederhana untuk akhir: mengatur untuk 1, mencetak dengan !, mengakhiri dengan @. :)

Tentu saja, ada satu alternatif:

)!@

Seperti biasa, semua diagram alir kontrol dibuat dengan HexagonyColorer Timwi dan diagram memori dengan EsotericIDE- nya .

APL, 22 20 18 byte

Entri benar dan salah adalah program yang lengkap, dan 14 lainnya adalah fungsi. (Terima kasih kepada Adám.)

0000 false              0 (complete program)
0001 p and q            ∧
0010 p and not q        >
0011 p                  ⊣
0100 not p and q        <
0101 q                  ⊢
0110 xor                ≠
0111 p or q             ∨
1000 not p and not q    ⍱
1001 eq                 =
1010 not q              ~⊢
1011 p or not q         ≥
1100 not p              ~⊣
1101 not p or q         ≤
1110 not p or not q     ⍲
1111 true               1 (complete program)

Coba di sini.

Pemain catur / catur biasa-biasa saja di endgame, 70 buah

Terinspirasi oleh jawaban domino itu, saya memutuskan game lain harus mendapat kehormatan ini.

Perhatikan bahwa saya mengambil beberapa aturan tentang bagaimana potongan-potongan itu bergerak. Karena saya tidak merasa ingin mempelajari gerakan optimal untuk setiap situasi, aturan untuk gerakan kulit putih sederhana: Tetap tak terkendali, tangkap bagian peringkat tertinggi yang bisa dia putar, sambil kehilangan bahan sesedikit mungkin, dan hentikan gadai dari mempromosikan, dalam urutan prioritas itu. Jika ada dua ruang yang dapat ia pindahkan, dengan tingkat kesukaan yang sama, ia dapat pindah ke salah satu (maka dalam hal ini, jika ia dapat pindah ke lebih dari satu kotak, mereka memiliki warna yang sama). Perhatikan bahwa putih akan ditangkap dengan sesuatu bahkan jika itu ditangkap, jika bagian yang diserang lebih tinggi nilainya daripada yang hilang. Nilai ada di sini:pawn<knight=bishop<rook<queen

Masukan adalah apakah ada benteng atau tidak. Perhatikan bahwa rook hanya diberi label dengan nama A dan B ketika itu penting: jika gerbang berperilaku sama ketika rooks diaktifkan, mereka tidak diberi label.

Outputnya adalah warna raja putih persegi berakhir pada: Putih = 1, hitam = 0

Sebelum foto, saya ingin meminta maaf untuk gambar yang buruk. Saya tidak pandai memegang kamera dengan stabil.

Salah, 4:

DAN, 4:

A dan bukan B, 5 (saya pikir saya bisa mendapatkan ini hingga tiga, tetapi tidak memiliki papan sekarang):

A, 4:

Bukan A dan B, 5 (saya pikir saya bisa mendapatkan ini hingga tiga, tetapi tidak memiliki papan sekarang):

B, 4:

Xor, 5 (Saya tahu cara membuatnya 4, tapi saya tidak memiliki papan sekarang):

Atau, 4:

Juga, 4:

Xnor, 5 (Saya tahu cara membuatnya 4, tapi saya tidak memiliki papan sekarang):

Bukan B, 4:

B menyiratkan A, 5 (saya pikir saya bisa mendapatkan ini hingga tiga, tetapi tidak memiliki papan sekarang):

Bukan A, 4:

A menyiratkan B, 5 (saya pikir saya bisa mendapatkan ini hingga tiga, tetapi tidak memiliki papan sekarang):

Nand, 4:

Benar, 4:

Jelly , 19 byte

0 0 0 0 ¤  1 byte  Empty niladic chain. Returns default argument 0.
0 0 0 1 &  1 byte  Bitwise AND.
0 0 1 0 >  1 byte  Greater than.
0 0 1 1    0 bytes Empty link. Returns left argument.
0 1 0 0 <  1 byte  Less than.
0 1 0 1 ị  1 byte  At-index (x,y -> [y][x]). Returns right argument.
0 1 1 0 ^  1 byte  Bitwise XOR.
0 1 1 1 |  1 byte  Bitwise OR.
1 0 0 0 |¬ 2 byte  Logical NOT of bitwise OR.
1 0 0 1 =  1 byte  Equals.
1 0 1 0 ¬} 2 bytes Logical NOT of right argument.
1 0 1 1 *  1 byte  Exponentiation.
1 1 0 0 ¬  1 byte  Logical NOT of left argument.
1 1 0 1 >¬ 2 bytes Logical NOT of greater than.
1 1 1 0 &¬ 2 bytes Logical NOT of bitwise AND.
1 1 1 1 !  1 byte  Factorial.

Cobalah online!

Gerbang logika NAND - 31 gerbang

Sebagai pencipta asli seri dari NAND gerbang pertanyaan , saya tidak bisa melewatkan kesempatan untuk menggunakan gerbang ini untuk memecahkan masalah lain gerbang logika.

Di masing-masing diagram ini, input atas adalah A sedangkan input bawah adalah B.

Tag Bitwise Cyclic , 118 bit = 14,75 byte

Bitwise Cyclic Tag mungkin adalah bahasa lengkap Turing-lengkap yang pernah dibuat. Ada rekaman program dan rekaman data, keduanya terdiri dari daftar bit. Pita program ditafsirkan secara siklis sampai rekaman data kosong, sebagai berikut:

• 0: hapus bit pertama dari rekaman data.
• 1x: jika bit pertama dari rekaman data adalah 1, tambahkan bit xke rekaman data.

Kami menginisialisasi rekaman data dengan angka 1 diikuti oleh dua bit input (angka 1 diperlukan karena tidak ada cara untuk membuat angka 1 jika pita data seluruhnya terdiri dari 0s), dan kami menggunakan bit data akhir yang dihapus sebagai keluaran gerbang. .

• 0,0,0,0 ( false):001
• 0,0,0,1 ( and):1001001
• 0,0,1,0 ( A and not B):0110100
• 0,0,1,1 ( A):1001
• 0,1,0,0 ( not A and B):0100
• 0,1,0,1 ( B):0
• 0,1,1,0 ( xor):0110110010
• 0,1,1,1 ( or):0110
• 1,0,0,0 ( nor):1101001000
• 1,0,0,1 ( xnor):110101001100
• 1,0,1,0 ( not B):1100100
• 1,0,1,1 ( B implies A):110101101000
• 1,1,0,0 ( not A):11010000
• 1,1,0,1 ( A implies B):11010011001
• 1,1,1,0 ( nand):10110100100010
• 1,1,1,1 ( true):1100

Python 2, 137 byte

[].sort
min
int.__rshift__
round
range
{}.get
cmp
max
lambda a,b:a<1>b
lambda a,b:a==b
lambda a,b:b<1
pow
{0:1,1:0}.get
{0:1}.get
lambda a,b:a+b<2
slice

Mengambil input seperti min(True,False)(atau sebagai min(1,0)). Mengambil keuntungan besar dari keluaran hanya perlu memiliki nilai Truthy-Falsey yang tepat. Kapan pun memungkinkan, gunakan built-in untuk menghindari yang mahal lambda. Saya menggunakan kode untuk mencari built-in yang berfungsi.

Yang favorit saya adalah {0:1}.get, yang saya pikirkan dengan tangan. Kamus {0:1}memetakan kunci 0ke nilai 1. Its getmetode mengambil kunci dan default, keluaran nilai yang cocok dengan kunci, atau default jika tidak ada kunci seperti. Jadi, satu-satunya cara untuk menghasilkan a 0adalah dengan {0:1}.get(1,0), dengan kunci yang hilang 1dan default 0. Orang bisa mendapatkan varian lain dengan kamus yang berbeda, tetapi hanya yang ini yang terpendek.

built_in_names = list(__builtins__) 

object_names = ["int","(0)","(1)"] + \
["True","False","0L","1L","0j","1j"] + \
["str", "''", "'0'","'1'","'a'"] + \
["list", "[]", "[0]", "[1]","['']","[[]]","[{}]"] + \
["set","set()","{0}","{1}","{''}"] + \
["dict","{}","{0:0}","{0:1}","{1:0}","{1:1}","{0:0,1:0}", "{0:0,1:1}","{0:1,1:0}","{0:1,1:1}"] + \
["id"]

object_method_names = [object_name+"."+method_name 
for object_name in object_names 
for method_name in dir(eval(object_name))]

additional_func_names = [
"lambda a,b:0",
"lambda a,b:1",
"lambda a,b:a",
"lambda a,b:b",
"lambda a,b:b<1",
"lambda a,b:a<1",
"lambda a,b:a+b",
"lambda a,b:a*b",
"lambda a,b:a==b",
"lambda a,b:a-b",
"lambda a,b:a<=b",
"lambda a,b:a>=b", 
"lambda a,b:a>b", 
"lambda a,b:a<b", 
"lambda a,b:a<1>b", 
"lambda a,b:a+b<2"]

func_names = built_in_names + object_method_names + additional_func_names

t=True
f=False

cases = [(f,f),(f,t),(t,f),(t,t)]

def signature(func):
    table = [bool(func(x,y)) for x,y in cases]
    table_string = ''.join([str(int(val)) for val in table])
    return table_string

d={}

for func_name in func_names:
    try:
        func = eval(func_name) 
        result = signature(func)
        if result not in d or len(func_name)<len(d[result]):
            d[result]=func_name
    except:
        pass

total_length = sum(len(func) for sig,func in d.items())

print total_length
print

for sig in sorted(d):
    print d[sig]

Go (game), 33 batu, 73 persimpangan

Jika domino dan catur dapat diterima, maka ini. Tidak bisa terlalu golf dengan papan Go 19x19 penuh. Jadi saya menggunakan papan persegi panjang kecil. Masukan adalah apakah batu bertanda 1 dan 2 ada. Outputnya adalah apakah hitam menang. Ini menggunakan penilaian area, 0,5 komi, superko situasional, tidak bunuh diri. Semua hitam untuk dimainkan. Beberapa diberikan beberapa solusi.

Kemenangan putih (2, 1x5):

➊━━━➋

1 dan 2 (3, 2x3):

➊◯➋
┗┷┛

1 dan bukan 2 (2, 1x5):

╺➊━➁╸

1 (2, 1x5):

╺➊➁━╸ 
╺➊━━➁
➀━➁━╸

Bukan 1 dan 2 (2, 1x5):

╺➋━➀╸

2 (2, 1x5):

╺➋➀━╸

1 xor 2 (2, 2x3):

➀┯➁
┗┷┛

1 atau 2 (2, 1x5):

╺➊━➋╸
➀━━━➁

1 atau 2 (2, 1x4):

➊━━➋
╺➀➁╸

1 = 2 (2, 1x7):

╺━➀━➁━╸

Bukan 2 (2, 1x3):

➀➁╸

1 atau tidak 2 (2, 1x4):

➀➁━╸
➀━➁╸
╺➊➁╸
➋➊━╸
➋━➊╸

Bukan 1 (2, 1x3)

➁➀╸

Bukan 1 atau 2 (2, 1x4):

➁➀━╸

1 dan 2 (2, 1x3):

➊━➋

Kemenangan hitam (2, 1x3):

➊➋╸
➀━➁
➊━➁

Halaman ini sedikit membantu saya: http://www.mathpuzzle.com/go.html

Mungkin seseorang dapat menemukan solusi 2 batu untuk 1 dan 2 pada papan 1x9 ...

Javascript ES6, 124 byte

a=>0
Math.min
parseInt
a=>a
a=>b=>a<b
a=>b=>b
a=>b=>a^b
Math.max
a=>b=>~a&~b
a=>b=>a==b
a=>b=>~b
Math.pow
a=>~a
a=>b=>a<=b
a=>b=>~a|~b
a=>1

Saya sangat membenci lambda sekarang.

Retina , 62 39 byte

23 byte berkat @MartinEnder !

0000 false              1 byte : 2
0001 p and q            2 bytes: 11
0010 p and not q        2 bytes: 10
0011 p                  2 bytes: ^1
0100 not p and q        2 bytes: 01
0101 q                  2 bytes: 1$
0110 xor                5 bytes: 01|10
0111 p or q             1 byte : 1
1000 not p and not q    2 bytes: 00
1001 xnor               5 bytes: (.)\1
1010 not q              2 bytes: 0$
1011 p or not q         5 bytes: ^1|0$
1100 not p              2 bytes: ^0
1101 not p or q         5 bytes: ^0|1$
1110 not p or not q     1 byte : 0
1111 true               0 bytes: 

Mengambil input sebagai PQ.

Menghasilkan bilangan bulat antara 0hingga 3. 0adalah falsey, yang lain adalah kebenaran.

Penjelasan

Mereka semua hanya regex .

Misalnya, 01|10hanya cocok 01atau 10.

Di 0000, 2tidak akan pernah ada di input, jadi tidak pernah cocok.

Di 1111, itu cocok dengan string kosong, yang ada 4.

Stack Cats , 67 + 64 = 131 bytes

Perhatikan bahwa +64 berasal dari penerapan -nmflag ke setiap program. -nmenunjukkan angka I / O, dan -mmencerminkan kode sumber di seluruh karakter terakhir - tidak semua pengiriman membutuhkan tanda ini secara teknis, tetapi untuk konsistensi dan kesederhanaan saya membuat skor dengan cara yang sama.

-2 -2 -3 -3     !I                0 0 0 0     <I!+
-4 -4 -4  1     |!T*I             0 0 0 1     [>I=I_
-4 -4  3 -2     *I*_              0 0 1 0     :I*=I:
-2 -2  3  3     T*I               0 0 1 1     [<!>X
-2  1 -2 -2     _*T*I             0 1 0 0     *|!TI:
-2  1 -3  1     !-|_I             0 1 0 1     <!I!>X
-2  3  3 -2     ^T*I              0 1 1 0     ^:]<_I
-2  3  3  3     -_T*I             0 1 1 1     *I<-I!
 2 -3 -3 -3     -*|_I             1 0 0 0     ^{!:}I_
 2 -3 -3  2     _|*I              1 0 0 1     _|[<I!:
 1 -2  1 -2     :]I*:             1 0 1 0     _!:|]X
 1 -2  1  1     *I\<X             1 0 1 1     *>I>!I
 2  2 -3 -3     -*I               1 1 0 0     I^:!
 2  2 -3  2     _*I_              1 1 0 1     |I|^:!
 1  2  2 -1     |!:^I             1 1 1 0     -I*<*I
 1  1  1  1     *<X               1 1 1 1     +I+

()di Stack Cats memeriksa apakah suatu elemen positif atau tidak positif (yaitu 0 atau negatif), jadi kami menggunakannya untuk masing-masing kebenaran / kepalsuan. Kolom kedua hanya untuk minat, dan daftar gerbang terbaik dengan 0/ 1s sebagai output (dengan skor total 90).

Input adalah bit yang dipisahkan oleh pembatas melalui STDIN. Cobalah online!

Stack Cats adalah bahasa esoterik yang dapat dibalik, di mana program memiliki simetri reflektif. Diberikan potongan f(misalnya >[[(!-)/), gambar cermin (misalnya \(-!)]]<) menghitung kebalikannya f^-1. Dengan demikian, bahkan program panjang tidak melakukan apa-apa (atau terjebak dalam loop tak terbatas), dan satu-satunya program non-sepele memiliki panjang ganjil, menghitung di f g f^-1mana goperator pusat.

Karena separuh kode sumber selalu berlebihan, ia dapat ditinggalkan, dan menjalankan kode dengan -mbendera menunjukkan bahwa kode sumber harus dicerminkan pada karakter terakhir untuk mengambil kode sumber yang sebenarnya. Misalnya, programnya *<Xsebenarnya *<X>*, yang simetris.

Golf di Stack Cats sangat tidak intuitif, sehingga program di atas harus ditemukan dengan kekerasan. Kebanyakan dari mereka sangat kompleks, tetapi saya akan menjelaskan beberapa dan menambahkan jawaban ini ketika saya punya waktu. Untuk saat ini, beberapa penjelasan dan solusi alternatif untuk 0/ 1versi dapat ditemukan di repositori Github di sini .

Haskell, 78 76 75 byte

1. _#_=2<1
2. &&
3. >
4. pure
5. <
6. _#b=b
7. /=
8. ||
9. (not.).max
10. ==
11. _#b=not b
12. >=
13. a#_=not a
14. <=
15. (not.).min
16. _#_=1<2

Sunting: -1 byte berkat @cole.

Brachylog , 36 34 byte

0000 false              \     Backtrack (always false)
0001 p and q            1.    Unify input and output with 1
0010 p and not q        >.    Input > Output
0011 p                  1     Unify input with 1
0100 not p and q        <.    Input < Output
0101 q                  ,1.   Unify output with 1
0110 xor                '.    Input and output cannot unify
0111 p or q             1;1.  Unify input with 1 or unify output with 1
1000 not p and not q    0.    Unify input and output with 0
1001 eq                 .     Unify input with output
1010 not q              ,0.   Unify output with 0
1011 p or not q         >=.   Input >= Output
1100 not p              0     Unify input with 0
1101 not p or q         <=.   Input <= Output
1110 not p or not q     0;0.  Unify input with 0 or unify output with 0
1111 true                     Empty program (always true)

Ini mengharapkan 0nilai palsu dan 1nilai kebenaran. Pengembalian trueatau false. p adalah Inputdan q adalah Output.

Prolog, 147 145 byte

Memperoleh 2 byte berkat @SQB

a(a,a).       % 0000 false
b(1,1).       % 0001 P and Q
c(1,0).       % 0010 P and not Q
d(1,_).       % 0011 P
e(0,1).       % 0100 not P and Q
f(_,1).       % 0101 Q
g(P,Q):-P\=Q. % 0110 P xor Q
h(1,_).       % 0111 P or Q
h(0,1).
i(0,0).       % 1000 not P and not Q
j(P,P).       % 1001 P == Q                 
k(_,0).       % 1010 not Q
m(P,Q):-P>=Q. % 1011 P or not Q
n(0,_).       % 1100 not P              
r(P,Q):-P=<Q. % 1101 not P or Q         
s(0,_).       % 1110 not P or not Q
s(1,0).
t(_,_).       % 1111 true

Permintaan x(P,Q).dengan xmenjadi huruf yang sesuai Pdan Qdiatur ke 0 atau 1.
Mengembalikan trueatau false.

Contoh SWISH termasuk tes - masuk runTest.untuk menjalankan.

NTFJ, 86 byte

0000 false              ~
0001 p and q            |:|
0010 p and not q        :||:|
0011 p                  $
0100 not p and q        #{:||:|
0101 q                  #{$
0110 xor                :#{:#{:||#}:|||
0111 p or q             :|#{:||
1000 not p and not q    :|#{:||:|
1001 eq                 :#{:#{:||#}:|||:|
1010 not q              #{$:|
1011 p or not q         #{:||
1100 not p              $:|
1101 not p or q         :||
1110 not p or not q     |
1111 true               #

Coba di sini! Tapi baca dulu di bawah ini.

Input tersirat pada stack. Hasilnya biarkan di stack. Tambahkan 16 byte (satu *ke akhir masing-masing) jika Anda ingin 0x00atau 0x01untuk output yang mewakili 0 dan 1. Tambahkan 160 byte tambahan jika Anda ingin 0atau 1dicetak. (Letakkan ~~##~~~#{@sebelum masing-masing *.)

Satu-satunya operator biner NTFJ adalah NAND, sehingga masing-masing ditulis dalam bentuk NAND.

Mari kita telusuri masing-masing.

0: salah

~

~mewakili bit yang salah. Cukup sederhana. Karena input tersirat di bagian bawah tumpukan, ini dibiarkan di atasnya.

1: p dan q

|:|

NTFJ beroperasi pada stack. :adalah perintah untuk duplikat. Amati p and q≡ not (p nand q)dan itu not q = q nand q.

Command | Stack
        | p q
   |    | (p nand q)
   :    | (p nand q) (p nand q)
   |    | (p nand q) nand (p nand q)
        | => not (p nand q)
        | => p and q

(Catatan, kemudian, :|bisa dikatakan negasi dan |:|bisa dikatakan konjungsi )

2: p dan bukan q

:||:|

Perhatikan bahwa ini hanya negasi, :|dan konjungsi |:|.

Command | Stack
        | p q
  :|    | p (not q)
  |:|   | p and (not q)

3: hal

$

$muncul item dari tumpukan. Jadi ... ya.

4: bukan p dan q

#{:||:|

Ini sama dengan 2, kecuali dengan #{di awal. #mendorong 1 (bit sebenarnya) dan {memutar tumpukan ke kiri satu kali. Cukup sederhana.

5: q

#{$

Putar ke kiri satu kali, jatuhkan.

6: xor

:#{:#{:||#}:|||

Mengamati:

p xor q = (p and (not q)) or ((not p) and q)                ; by experimentation (trust me)
        = (not ((not p) nand q)) or (not (p nand (not q)))  ; by definition of nand
        = not (((not p) nand q) and (p nand (not q)))       ; by De Morgan's laws
        = ((not p) nand q) nand (p nand (not q))            ; by definition of nand

Namun, tidak ada cara untuk menggandakan tumpukan seluruhnya. Jadi, kita harus membawa masing-masing p, qke atas dan menduplikasinya.

Command | Stack
        | p q
   :    | p q q
  #{    | q q p
   :    | q q p p
  #{    | q p p q
  :|    | q p p (not q)
   |    | q p (p nand (not q))
  #}    | (p nand (not q)) q p
  :|    | (p nand (not q)) q (not p)
   |    | (p nand (not q)) (q nand (not p))
   |    | (p nand (not q)) nand (q nand (not p))

Dan dengan demikian, kita memiliki xor kita.

7: p atau q

:|#{:||

Meniadakan atas, membawa bawah ke atas, meniadakan itu, dan mengumpulkan mereka Pada dasarnya p or q = (not p) nand (not q),.

8: bukan p dan bukan q

:|#{:||:|

Ini hanyalah negasi dari 7. Mudah.

9: eq

:#{:#{:||#}:|||:|

Ini hanya xnor , atau bukan xor. Sederhana lagi.

10: bukan q

#{$:|

Negasi 5.

11: p atau tidak q

#{:||

Meniadakan p, nand. (not p) nand q = not ((not p) and q) = p or (not q) (by De Morgan's laws).

12: tidak hal

$:|

Jatuhkan, berhenti, dan negasikan.

13: bukan p atau q

:||

Hukum De Morgan untuk menyelamatkan hari, lagi! Proses yang sama dengan 11, hanya meniadakan qbukannya p.

14: bukan p atau tidak q

|

Ini hanya meniru nand.

15: benar

#

# adalah bit yang benar.

Minecraft, 89 blok

Di semua foto berikut, blok biru untuk Input A dan blok oranye untuk Input B

16. Gerbang yang BENAR - 1 blok

15. Gerbang NAND - 1x2x3 = 6 blok

14. A => B - 1x2x3 = 6 blok

13. BUKAN A - 2 blok

12. B => A - 1x2x3 = 6 blok

11. TIDAK B - 2 blok

10. XNOR - 1x3x4 = 12 blok

9. NOR - 1x2x3 = 6 blok

8. ATAU - 1 blok

7. XOR - 1x3x4 = 12 blok

6. B - 1 blok

5.! A&B - 1x2x5 = 10 blok

4. A - 1 blok

3. A &! B - 1x2x5 = 10 blok

2. DAN - 2x2x3 = 12 blok

1. SALAH-1 blok

Mathematica, 67 byte

0>1&
And
#&&!#2&
#&
!#&&#2&
#2&
Xor
Or
Nor
Xnor
!#2&
#||!#2&
!#&
!#||#2&
Nand
1>0&

Masing-masing mengevaluasi fungsi, sehingga Anda dapat menggunakannya seperti

#&&!#2&[True, False]
Xor[True, False]

Ah, jika hanya bilangan bulat yang benar / salah dalam Mathematica, empat yang lebih panjang itu bisa dipersingkat.

MATL, 34 23 byte

Saya harap saya mendapat pesanan baik-baik saja! Nol adalah falsey, bukan-nol adalah benar. Setiap fungsi mengambil dua input implisit (meskipun mungkin mengabaikan beberapa input). Input pertama adalah A, dan yang kedua adalah B. Anda dapat memasukkan 0/ 1untuk true / false, atau T/ F.

Berikut adalah contoh TryItOnline untuk test case 3.

Disimpan 4 byte dengan menggunakan *for and, dan 4 lainnya dengan menggunakan >/ <bukannya ~wY&/ w~Y&setelah saya melihat jawaban Dennis!

1.  0,0,0,0 0 (ignores input, just returns a zero)
2.  0,0,0,1 * (and)
3.  0,0,1,0 < (not-A and B)
4.  0,0,1,1 D (A)
5.  0,1,0,0 > (not-B and A)
6.  0,1,0,1 xD (discard A, display B)
7.  0,1,1,0 Y~ (xor)
8.  0,1,1,1 + (or)
9.  1,0,0,0 +~ (not-or)
10. 1,0,0,1 = (A=B)
11. 1,0,1,0 x~ (not-B)
12. 1,0,1,1 <~ (not-B or A)
13. 1,1,0,0 ~ (not-A)
14. 1,1,0,1 ~+ (not-A or B)
15. 1,1,1,0 *~ (not(A and B))
16. 1,1,1,1 1 (just returns 1)

dc, 37 byte

dc("desk calculator") adalah perintah unix standar, kalkulator postfix berbasis stack. Ini tidak memiliki operasi bit, dan operator perbandingan hanya dapat digunakan untuk menjalankan makro (yang tidak sebanding dengan byte). Divisi integer menutupi sebagian dari itu.

Script ini mengharapkan 0dan memberi 1nilai pada stack, dan meninggalkan hasilnya pada stack.

0,0,0,0 (false)              0
0,0,0,1 (and)                *         a*b
0,0,1,0                      -1+2/     (a-b+1)/2
0,0,1,1 (A)                  r         reverse a, b: a now on top
0,1,0,0                      -1-2/     (a-b-1)/2
0,1,0,1 (B)                            (0 bytes) do nothing: b on top
0,1,1,0 (xor)                -         a-b
0,1,1,1 (or)                 +         a+b                  
1,0,0,0 (nor)                +v1-      sqrt(a+b) -1
1,0,0,1 (xnor)               +1-       a+b-1
1,0,1,0 (not B)              1-        b-1
1,0,1,1 (if B then A)        -1+       a-b+1
1,1,0,0 (not A)              r1-       a-1
1,1,0,1 (if A then B)        -1-       a-b-1            
1,1,1,0 (nand)               *1-       a*b - 1
1,1,1,1 (true)               1

Labirin , 85 byte

Terima kasih kepada Sp3000 untuk menghemat 2 byte.

!@
??&!@
??~&!@
?!@
?~?&!@
??!@
??$!@
??|!@
??|#$!@
??$#$!@
?#?$!@
?#?$|!@
?#$!@
?#$?|!@
??&#$!@
1!@

Semua ini adalah program lengkap, membaca dua bilangan bulat 0atau 1dari STDIN (menggunakan pemisah non-digit), dan mencetak hasilnya sebagai 0atau 1ke STDOUT.

Cobalah online! (Bukan test suite, jadi Anda harus mencoba berbagai program dan input secara manual.)

Adapun penjelasan, ini semua cukup mudah. Semua program bersifat linier, dan perintah yang digunakan melakukan hal berikut:

?   Read integer from STDIN and push.
!   Pop integer and write to STDOUT.
@   Terminate program.
&   Bitwise AND of top two stack items.
|   Bitwise OR of top two stack items.
$   Bitwise XOR of top two stack items.
~   Bitwise NOT of top stack item.
#   Push stack depth (which is always 1 when I use it in the above programs).
1   On an empty stack, this pushes 1.

Perhatikan bahwa saya menggunakan #selalu digunakan untuk menggabungkannya $, yaitu untuk menghitung XOR 1, atau dengan kata lain untuk negasi logis. Hanya dalam beberapa kasus saya dapat menggunakan ~sebagai gantinya, karena selanjutnya &membuang semua bit yang tidak diinginkan dari hasil -1atau -2.

Kode mesin IA-32, 63 byte

Hexdump kode, dengan pembongkaran:

0000  33 c0     xor eax, eax;
      c3        ret;

0001  91        xchg eax, ecx;
      23 c2     and eax, edx;
      c3        ret;

0010  3b d1     cmp edx, ecx;
      d6        _emit 0xd6;
      c3        ret;

0011  91        xchg eax, ecx;
      c3        ret;

0100  3b ca     cmp ecx, edx;
      d6        _emit 0xd6;
      c3        ret;

0101  92        xchg eax, edx;
      c3        ret;

0110  91        xchg eax, ecx;
      33 c2     xor eax, edx;
      c3        ret;

0111  8d 04 11  lea eax, [ecx + edx];
      c3        ret;

1000  91        xchg eax, ecx; // code provided by l4m2
      09 d0     or eax, edx;
      48        dec eax;
      c3        ret;

1001  3b ca     cmp ecx, edx;
      0f 94 c0  sete al;
      c3        ret;

1010  92        xchg eax, edx;
      48        dec eax;
      c3        ret;

1011  39 d1     cmp ecx, edx; // code provided by l4m2
      d6        _emit 0xd6;
      40        inc aex;
      c3        ret;

1100  91        xchg eax, ecx;
      48        dec eax;
      c3        ret;

1101  3b d1     cmp edx, ecx; // code inspired by l4m2
      d6        _emit 0xd6;
      40        inc aex;
      c3        ret;

1110  8d 44 11 fe   lea eax, [ecx+edx-2] // code provided by l4m2
      c3        ret;

1111  91        xchg eax, ecx;
      40        inc eax;
      c3        ret;

Kode lebih panjang dari yang seharusnya, karena menggunakan konvensi pengkodean standar: input ecxdan edx, dan output dalam al. Ini dapat dinyatakan dalam C sebagai

unsigned char __fastcall func(int, int);

Tampaknya MS Visual Studio tidak memahami SALCopcode tidak berdokumen , jadi saya harus menggunakan kodenya, bukan nama.

Terima kasih l4m2 untuk meningkatkan beberapa contoh kode!

C 34 byte

#define g(n,a,b)((n-1)>>3-b-2*a)&1

Di mana n adalah nomor fungsi untuk digunakan, tapi saya pikir itu akan ditolak jadi saya usulkan yang lain ini:

C 244 byte (menggunakan memori)

typedef int z[2][2];
z a={0,0,0,0};
z b={0,0,0,1};
z c={0,0,1,0};
z d={0,0,1,1};
z e={0,1,0,0};
z f={0,1,0,1};
z g={0,1,1,0};
z h={0,1,1,1};
z i={1,0,0,0};
z j={1,0,0,1};
z k={1,0,1,0};
z l={1,0,1,1};
z m={1,1,0,0};
z n={1,1,0,1};
z o={1,1,1,0};
z p={1,1,1,1};

menggunakan array indeks ganda. n[0][1]aku s(A implies B)(0,1)

Sebanyak 138 byte

Saya baru belajar Forth. Saya kira itu Ansi Forth kompatibel karena dijalankan juga di gforth.

: z create dup , 1+ does> @ -rot 3 swap - swap 2* - rshift 1 and ; 
0 
z a z b z c z d z e z f z g z h z i z j z k z l z m z n z o z p 
drop

Fungsi z membuat fungsi baru dengan nama yang disediakan kemudian memasukkan nomor gerbang logika dari atas tumpukan ke alamat fungsi baru. Ini meninggalkan fungsi gerbang logika (n +1) berikutnya di stack untuk deklarasi berikutnya.

Anda dapat mengujinya:
Dan AB

0 0 b . cr 
0 1 b . cr
1 0 b . cr 
1 1 b . cr   

("." cetak bagian atas tumpukan "cr" adalah pengembalian cariage)

C, 268 byte

#define c(a,b)0      // 0000 
#define d(a,b)a&b    // 0001 
#define e(a,b)a>b    // 0010 
#define f(a,b)a      // 0011 
#define g(a,b)a<b    // 0100 
#define h(a,b)b      // 0101 
#define i(a,b)a^b    // 0110 
#define j(a,b)a|b    // 0111 
#define k(a,b)!b>a   // 1000 
#define l(a,b)a==b   // 1001 
#define m(a,b)!b     // 1010 
#define n(a,b)!b|a   // 1011 
#define o(a,b)!a     // 1100 
#define p(a,b)!a|b   // 1101 
#define q(a,b)!b|!a  // 1110 
#define r(a,b)1      // 1111 

Macro tampak lebih pendek dari fungsi.

Brian & Chuck , 183 byte

Terima kasih kepada Sp3000 untuk menghemat 4 byte.

Beberapa program berisi karakter yang tidak patut dicetak. Secara khusus, setiap \x01harus diganti dengan <SOH>karakter kontrol (0x01):

0000
?
#>.
0001
,-?,-?>?\x01
#}>.
0010
,-?,?>?\x01
#}>.
0011
,?\x01+?
#>.
0100
,?,-?>?\x01
#}>.
0101
,,?\x01+?
#>.
0110
,?>},?>?_\x01
#}+{>?_}>.
0111
,\x01?,?>?
#{>.
1000
,?,?>?\x01
#}>.
1001
,-?>},?>?_\x01
#}+{>>?_}>.
1010
,,-?\x01+?
#>.
1011
,\x01?,-?>?
#{>.
1100
,-?\x01+?
#>.
1101
,\x01-?,?>?
#{>.
1110
,\x01-?,-?>?
#{>.
1111
?
#>+.

Input dan output menggunakan nilai byte , jadi input harus dua byte 0x00 atau 0x01 (tanpa pemisah) dan output akan menjadi satu byte tersebut. Ini sebenarnya juga merupakan definisi paling masuk akal dari kebenaran / kepalsuan untuk B&C karena satu-satunya perintah aliran kontrol ?menganggap nol sebagai kepalsuan dan segala sesuatu yang lain benar.

Penjelasan

Pertama primer B&C cepat:

• Setiap program terdiri dari dua contoh seperti Brainfuck, masing-masing ditulis pada barisnya sendiri. Kami memanggil yang pertama Brian dan yang kedua Chuck . Eksekusi dimulai pada Brian.
• Rekaman setiap program adalah kode sumber program lain, dan penunjuk instruksi masing-masing program adalah kepala tape program lainnya.
• Hanya Brian yang dapat menggunakan perintah ,(byte input) dan hanya Chuck yang dapat menggunakan perintah .(byte keluaran).
• []Loop Brainfuck tidak ada. Alih-alih, satu-satunya aliran kontrol yang Anda miliki adalah ?yang mengalihkan kontrol ke instance lain jika jika nilai saat ini di bawah head tape adalah nol.
• Selain >dan <, ada {dan }yang pada dasarnya setara dengan cuplikan Brainfuck [<]dan [>], yaitu, mereka memindahkan kepala kaset ke posisi nol berikutnya ke arah itu. Perbedaan utama adalah bahwa hal itu {juga dapat dihentikan di ujung kiri kaset, terlepas dari apa nilainya.
• Untuk kenyamanan, setiap _s dalam kode sumber diganti dengan null-byte (karena ini sangat berguna dalam program nontrivial untuk menangkap {dan }).

Perhatikan bahwa dalam semua program, rekaman Chuck dimulai dengan a #. Ini bisa jadi apa saja. ?berfungsi sedemikian rupa sehingga kepala kaset bergerak satu sel sebelum memulai eksekusi (sehingga kondisi itu sendiri tidak dieksekusi jika kebetulan itu adalah perintah yang valid). Jadi kita tidak akan pernah bisa menggunakan sel pertama Chuck untuk kode.

Ada lima kelas program, yang akan saya jelaskan nanti. Untuk sekarang saya daftar mereka di sini dalam rangka meningkatkan kompleksitas.

0000, 1111: Fungsi konstan

?
#>.

?
#>+.

Ini sangat sederhana. Kami beralih ke Chuck tanpa syarat. Chuck memindahkan kepala kaset ke sel yang tidak digunakan ke kanan dan mencetaknya secara langsung, atau menambahkannya terlebih dahulu untuk dicetak 1.

0011, 0101, 1010, 1100: Fungsi tergantung hanya pada satu input

,?\x01+?
#>.

,,?\x01+?
#>.

,,-?\x01+?
#>.

,-?\x01+?
#>.

Bergantung pada apakah kita mulai dengan ,atau ,,sedang kita kerjakan Aatau B. Mari kita lihat contoh pertama 0011(yaitu A). Setelah membaca nilai, kami menggunakan ?sebagai syarat pada nilai itu. Jika A = 1, maka ini beralih ke Chuck, yang menggerakkan kepala kaset ke kanan dan mencetak 1-byte yang tertanam secara harfiah . Kalau tidak, kontrol tetap ada pada Brian. Di sini, 1-byte adalah no-op. Lalu kami menambah input dengan baik +untuk memastikan itu bukan nol dan kemudian beralih ke Chuck ?. Kali ini, >pindah ke sel yang tidak digunakan ke kanan yang kemudian dicetak sebagai 0.

Untuk meniadakan salah satu nilai, kita cukup menguranginya -. Ini berubah 1menjadi 0dan 0menjadi -1, yang tidak nol dan karenanya benar sejauh ?yang bersangkutan.

0001, 0010, 0100, 1000: Fungsi Biner dengan satu hasil truthy

,-?,-?>?\x01
#}>.

,-?,?>?\x01
#}>.

,?,-?>?\x01
#}>.

,?,?>?\x01
#}>.

Ini adalah perpanjangan dari ide sebelumnya untuk bekerja dengan dua input. Mari kita lihat contoh 1000(NOR). Kami (berpotensi) membaca kedua input dengan ,?. Jika salah satunya adalah 1, ?beralih ke Chuck. Dia memindahkan kepala kaset ke ujung dengan }(ke sel kosong setelah kode Brian), memindahkan sel lain dengan >(masih nol) dan mencetaknya dengan ..

Namun, jika kedua input adalah nol, maka kontrol masih dengan Brian. >lalu pindahkan head tape ke }sedemikian rupa sehingga perintah ini tidak dijalankan ketika kita beralih ke Chuck ?. Sekarang semua yang dilakukan Chuck adalah >.yang hanya bergerak ke 1-sel dan mencetaknya.

Kita dapat dengan mudah mendapatkan tiga fungsi lainnya dengan meniadakan satu atau kedua input sesuai kebutuhan.

0111, 1011, 1101, 1110: Fungsi Biner dengan tiga hasil truthy

,\x01?,?>?
#{>.

,\x01?,-?>?
#{>.

,\x01-?,?>?
#{>.

,\x01-?,-?>?
#{>.

Sebuah modifikasi kecil dari ide sebelumnya untuk meniadakan hasil (yaitu cetak 0ketika kita telah melewati semua Brian dan 1sebaliknya). Mari kita lihat 0111(OR) sebagai contoh. Perhatikan bahwa 1-byte tertanam adalah no-op, jadi ini masih dimulai dengan ,?,?. Jika salah satu input 1kita beralih ke Chuck, yang memindahkan kepala kaset kembali ke awal dengan {. >.memindahkan kepala kaset ke 1-byte itu dan mencetaknya.

Jika kedua input nol maka kita tetap dengan Brian, pindahkan head tape ke {untuk melewati itu dan kemudian beralih ke Chuck. Ketika dia mengeksekusi >.kali ini dia bergerak ke sel kosong setelah kode Brian dan mencetak 0.

Sekali lagi, kami dengan mudah mendapatkan fungsi-fungsi lain dengan meniadakan satu atau kedua input.

0110, 1001: Fungsi biner dengan dua hasil yang benar

,?>},?>?_\x01
#}+{>?_}>.

,-?>},?>?_\x01
#}+{>>?_}>.

Yang ini agak rumit. Fungsi sebelumnya cukup sederhana karena dapat dihubung pendek - nilai input pertama dapat menentukan output, dan jika tidak maka kita melihat input lainnya. Untuk dua fungsi ini, kita selalu perlu melihat kedua input.

Ide dasarnya adalah menggunakan input pertama untuk memutuskan apakah input kedua memilih antara 0dan 1atau antara 1dan 0. Mari kita ambil 0110(XOR) sebagai contoh:

Pertimbangkan A = 0. Dalam hal ini kami ingin menampilkan Bapa adanya. ,berbunyi A, ?tidak melakukan apa-apa. >bergerak ke sel (bukan nol) berikutnya sehingga }membawa kita ke _pada Chuck. Di sini, kami membaca Bdengan ,dan menggunakan ?lagi. Jika Bitu 0juga, kami masih pada Brian. >melompati }Chuck dan ?beralih sehingga >.mencetak 0tertanam dalam kode sumber Brian. Jika Bberada 1di sisi lain, Chuck mengeksekusi }yang bergerak ke _dalam kode Brian, jadi >.kemudian mencetak 1-byte sebagai gantinya.

Jika A = 1, maka kita langsung beralih ke Chuck, siapa yang akan mengeksekusi }+{>?. Apa yang dilakukan adalah pindah ke _dalam kode sumber Brian, mengubahnya menjadi 1juga dengan +, kemudian bergerak kembali ke awal {dan melompati Brian ?dengan memindahkan satu sel ke kanan dengan >sebelum menyerahkan kontrol kembali kepadanya. Kali ini, setelah Brian membaca ini B, jika B = 0, dan Chuck menggunakan >.sel sebelah Brian ?akan 1bukannya 0. Juga, ketika B = 1, Chuck }melompati apa yang seharusnya menjadi celah dan bergerak sampai ke ujung kaset, sehingga >.mencetak angka nol sebagai gantinya. Dengan cara ini kita mencetak not B.

Untuk menerapkan kesetaraan, kami cukup menegasikan Asebelum menggunakannya sebagai syarat. Perhatikan bahwa karena ini, kita juga perlu menambahkan yang lain >ke Chuck untuk melewati itu -juga ketika kembali ke awal.

ClojureScript, 88 84 76 74 byte

nildan falsepalsu, semua nilai lain adalah benar. Booleans memaksa ke 0/1 untuk aritmatika dan ketidaksetaraan. Fungsinya dapat mengambil jumlah argumen yang salah.

0000   nil?            ; previously: (fn[]nil)
0001   and
0010   <
0011   true?           ; previously: (fn[x]x)
0100   >
0101   (fn[x y]y)
0110   not=
0111   or
1000   #(= 0(+ % %2))
1001   =
1010   #(not %2)
1011   <=
1100   not
1101   >=
1110   #(= 0(* % %2))
1111   /               ; previously: (fn[]4), inc

Brainfuck , 184 178 174 byte

Input / output menggunakan U + 0000 dan U + 0001.

0000 .
0001 ,[,[->+<]]>.
0010 ,[,-[+>+<]]>.
0011 ,.
0100 ,-[,[->+<]]>.
0101 ,,.
0110 ,>,[-<->]<[>>+<]>.
0111 ,-[,-[+>-<]]>+.
1000 ,-[,-[+>+<]]>.
1001 ,>,[-<->]<[>>-<]>+.
1010 ,,-[+>+<]>.
1011 ,-[,[->-<]]>+.
1100 ,-[+>+<]>.
1101 ,[,-[+>-<]]>+.
1110 ,[,[->-<]]>+.
1111 +.

Brain-Flak , 418 , 316 byte

Cobalah online!

Biarkan input menjadi dua angka teratas pada stack pada awal program (nol untuk false salah untuk true) dan output menjadi atas tumpukan di akhir program (nol untuk false else untuk true).

false, 4 bytes (Sumber Leaky Nun )

(<>)

dan, 36 byte

(({}{}[(())()])){{}{}(((<{}>)))}{}{}

A dan bukan B, 40 byte

((({}){}{}[(())()])){{}{}(((<{}>)))}{}{}

A, 6 byte

({}<>)

bukan A dan B, 38 byte

((({}){}{}[(())])){{}{}(((<{}>)))}{}{}

B, 2 byte

{}

xor, 34 byte

(({}{}[(())])){{}{}(((<{}>)))}{}{}

atau, 6 byte

({}{})

atau 34 byte

(({}{}<(())>)){{}{}(((<{}>)))}{}{}

xnor, 10 byte

({}{}[()])

bukan B, 34 byte

{}(({}<(())>)){{}{}(((<{}>)))}{}{}

B menyiratkan A, 14 byte

(({}){}{}[()])

bukan A, 34 byte

(({}<{}(())>)){{}{}(((<{}>)))}{}{}

A menyiratkan B, 16 byte

(({}){}{}[()()])

nand, 12 byte

({}{}[()()])

true, 6 byte

<>(())

Penjelasan

Karena sebagian besar sangat mirip, saya tidak akan menjelaskan dengan tepat bagaimana masing-masing bekerja. Saya mencoba yang terbaik untuk memperjelas bagaimana semua enam belas bekerja.

Pertama adalah gerbang yang mengembalikan tiga dari nilai yang sama (yaitu 2, 3, 5, 8, 9, 12, 14, dan 15). Semua ini mengikuti pola yang sama. Pertama, Anda mengubah input menjadi angka dua bit dengan tempat as dua dan B sebagai yang. Ini dilakukan dengan potongan ini (({}){}{}). Anda kemudian kurangi nilai input dua bit yang ingin Anda isolasi ({}[value]). (Dalam kode aktual, pengurangan dan konversi dilakukan dalam satu langkah untuk menghemat byte). Hal ini dapat dikombinasikan dengan tidak jika diperlukan: (({}<(())>)){{}{}(((<{}>)))}{}{}.

Selanjutnya: dan, atau, atau, xor, dan xnor. Ini bekerja sama dengan yang di atas. Sebenarnya beberapa di antaranya termasuk di atas, namun metode ini lebih pendek. Trik yang saya gunakan di sini adalah bahwa masing-masing ini sesuai dengan jumlah A B. misalnya xor bernilai true jika A + B = 1 dan false jika tidak. Pertama, Anda tambahkan AB dan kurangi jumlah yang relevan. Dinyatakan sebagai ({}{}[0,1,2 or 3]). Lalu jika perlu lakukan yang tidak

Selanjutnya: A, B, bukan A dan bukan B. Ini cukup jelas. Kita mulai dengan menghapus nilai yang tidak perlu dan kemudian kita meniadakan atau menyelesaikannya.

Terakhir adalah dua simpletons: true dan false. Untuk ini, kami mendorong nilai yang benar ke tumpukan off. The <>pengembalian nilad nol sehingga kita bisa menghemat dua byte dengan menggunakan saklar sebagai nilai nol.

Bukan solusi yang paling efisien di luar sana (mungkin yang paling efisien di Brain-Flak), tapi saya sangat senang menulis ini dan saya mohon Anda untuk mencoba mempersingkat ini.

ProgFk , 18,5 17,5 byte

Karena instruksi ProgFk ditentukan dalam nibbles, kode di bawah ini diberikan dalam heksadesimal, satu gerbang logika per baris dan dengan spasi di antara byte.

3
E1
DE 2D
<empty>
DE 1
1
E3
E2
E2 D
E3 D
1D
DE 2
D
DE 1D
E1 D
4

Penjelasan

ProgFk adalah esolang berbasis tape (mirip dengan Brainfuck) di mana setiap sel sedikit dan instruksi diberikan sebagai nibble (4 byte). Instruksi beroperasi pada sel yang ditunjuk oleh penunjuk instruksi. Input diberikan dalam sel pertama dan kedua (dengan Adan Bmenjadi sel pertama dan kedua masing-masing), dan penunjuk instruksi dimulai pada sel pertama. Output disimpan di sel pertama.

Setiap instruksi yang digunakan dijelaskan di bawah ini.

1   Increment the instruction pointer.
2   Decrement the instruction pointer.
3   Set the current bit to 0.
4   Set the current bit to 1.
D   Perform a NOT on the current bit.
E   The next instruction is an extended instruction.

Extended instructions:
1   Set the current bit to the current bit AND the next bit.
2   Set the current bit to the current bit OR the next bit.
3   Set the current bit to the current bit XOR the next bit.
6   Swap the current bit and the next bit.

Menyimpan satu byte berkat @LeakyNun!

Sebenarnya, 24 byte

Program-program ini mengambil input sebagai A\nB(dengan \nmewakili baris baru), yang meninggalkan B di atas tumpukan, dengan A di bawah. Falsediwakili oleh 0, dan Truediwakili oleh bilangan bulat positif.

é0  (false: clear stack, push 0)
*   (and: multiply)
<   (A and not B: less-than)
X   (A: discard B)
>   (B and not A: greater-than)
@X  (B: discard A)
^   (A xor B: xor)
|   (A or B: or)
|Y  (A nor B: or, boolean negate)
=   (A xnor B: equals)
@XY (not B: discard A, boolean negate B)
≤   (if B then A: less-than-or-equal)
XY  (not A: discard B, boolean negate)
≥   (if A then B: greater-than-or-equal)
*Y  (A nand B: multiply, boolean negate)
é1  (true: clear stack, push 1)

Terima kasih kepada Leaky Nun selama 3 byte