ตัวอย่างเช่น gate A and Bเป็นเกตตรรกะที่มี 2 อินพุตและ 1 เอาต์พุต

มีทั้งหมด 16 รายการเพราะ:

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

งานของคุณคือการเขียน 16 โปรแกรม / ฟังก์ชั่นซึ่งใช้งานทั้งหมดแยกต่างหาก

ฟังก์ชั่น / โปรแกรมของคุณต้องเป็นอิสระ

พวกเขามีความถูกต้องตราบเท่าที่พวกเขาส่งออกค่า truthy / falsey หมายความว่าคุณสามารถใช้A or Bในหลามเป็นlambda a,b:a+bแม้ว่า2จะผลิตเพื่อการและA=TrueB=True

คะแนนคือไบต์ทั้งหมดที่ใช้สำหรับแต่ละฟังก์ชั่น / โปรแกรม

รายการของประตูตรรกะ

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)

ในกรณีที่จำนวนแรกคือการส่งออกสำหรับA=false, B=falseจำนวนที่สองคือการส่งออกสำหรับA=false, B=trueจำนวนที่สามคือการส่งออกสำหรับจำนวนที่สี่คือผลลัพธ์สำหรับA=true, B=falseA=true, B=true

ลีดเดอร์บอร์ด

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>

โดมิโน 122,000 ไบต์หรือ 72 ไทล์

นับไบต์มีขนาดของไฟล์ที่บันทึกไว้0.122 MBซึ่งเป็น

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

รายละเอียด

• I / O
  • เริ่ม - สิ่งนี้ถูกรวมไว้เพื่อความชัดเจน (ไม่นับรวมต่อ) และเป็นสิ่งที่ 'เรียก' หรือ 'เรียกใช้' ฟังก์ชั่น ควรจะ 'กด' หลังจากการป้อนข้อมูลจะได้รับ[เหลือง]
  • ใส่ - นี้จะรวมเพื่อความชัดเจน (ไม่นับรวม) และ 'กด' เพื่อชี้ให้เห็น1และไม่ได้กดอย่างอื่น[สีเขียว]
  • อินพุต B - นี้จะรวมเพื่อความชัดเจน (ไม่นับรวม) และ 'กด' เพื่อชี้ให้เห็น1และไม่ได้กดอย่างอื่น[สีน้ำเงิน]
  • เอาท์พุท - นี่จะนับรวมต่อทั้งหมด มันเป็นโดมิโนที่ประกาศผลมาจากประตูตรรกะ[สีดำ]
• T / F
  • โดมิโนเอาต์พุตที่ลดลงแสดงถึงผลลัพธ์ของTrueหรือ1
  • โดมิโนขาออกที่ยืนแสดงถึงผลลัพธ์ของFalseหรือ0
• การกด
  • หากต้องการป้อนหรือเริ่มต้นโซ่ให้วางหินอ่อนโลหะ
  • ตั้งค่าความแข็งแรงของลิฟต์เป็น 100%
  • ยกหินอ่อนขึ้นเหนือโดมิโนที่ต้องการ
  • วางหินอ่อน

เกตส์

• เท็จ 1
  • 
• และ6 4
  • 
• A และไม่ใช่ B, 4 3
  • 
• A, 1
  • 
• ไม่ใช่ A และ B, 4 3
  • 
• B, 1
  • 
• xor, 15 11
  • 
• หรือ 1
  • 
• และ, 3 2
  • 
• xnor, 17 13
  • 
• ไม่ใช่ B, 2
  • 
• B หมายถึง A, 7 6
  • 
• ไม่ใช่ A, 2
  • 
• A หมายถึง B, 7 6
  • 
• nand, 16 15
  • 
  • จริง 1
  • 

TL; DR

ฉันรอ / ต้องการความท้าทายที่เป็นมิตรกับโดมิโนและเมื่อฉันเห็นสิ่งนี้ฉันก็ไม่สามารถผ่านมันไปได้ ปัญหาเดียวคือเห็นได้ชัดว่าไม่มีใครเป็นเจ้าของโดมิโนอีกต่อไป! ดังนั้นในที่สุดผมให้ในและซื้อสิบสองคู่ ชุดนี้มี 91 แผ่นซึ่งทำให้ฉันมีความคิดว่ามี 'การเรียกใช้ฟังก์ชั่น' / เริ่มโดมิโนแทนวิธีปกติ (ยาว) 'การหน่วงเวลา' สินเชื่อเพื่อเปิด 90 องศาเป็นช่อง dominoesdouble07 ของ

หลังจากสร้างสิ่งเหล่านี้ด้วยโดมิโนทางกายภาพมันถูกปกครองโดยเมตาว่าโซลูชั่นที่ถูกต้องควรเป็นระบบดิจิตอล ดังนั้นผมจึงสร้างประตูเหล่านี้ในโต๊ะจำลอง น่าเสียดายที่ TS และความเป็นจริงไม่เห็นด้วยกับฟิสิกส์โดมิโน สิ่งนี้ทำให้ฉันต้องเพิ่มโดมิโน 11 อัน แต่ฉันก็ช่วยได้เช่นกัน 8. โดยรวมโดมิโนเสมือนนั้นมีประสิทธิภาพมากกว่า x150 ในแง่ของการสร้างและการทดสอบ ( Ctrl+ Z)

ปรับปรุง

• -9 [17-03-13] สั้นลงxor xnor nand
• [17-03-04] เพิ่มลิงค์ไปยังไฟล์เวิร์กช็อป
• +11 [17-03-03] เพิ่มดิจิตอลxnorและxor
• -8 [17-03-03] แปลงเป็นประตูดิจิทัลทั้งหมด (ยกเว้นxorและxnor) การบล็อกบนโต๊ะต้องใช้โดมิโน 1 อันแทนที่จะเป็น 2
• [16-09-23] หดภาพ
• -11 [16-09-18] เกือบครึ่งหนึ่งของแฮคเกอร์อีกครั้ง ขอบคุณ@DJMcMayhemสำหรับ xnor และJoeสำหรับ xor
• -31 [16-08-31] Updated ภาพบางส่วนและโกนกระเบื้องบางส่วนและตัดxorในช่วงครึ่งปี
• [16-08-28] เพิ่มรูปภาพ

Hexagony , 89 ไบต์

ขอบคุณ FryAmTheEggman สำหรับแรงบันดาลใจที่จำเป็นสำหรับโซลูชั่น XOR

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

โปรแกรมทั้งหมดใช้0สำหรับเท็จและ1เป็นจริง

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

วิธีการแก้ปัญหาข้างต้นอยู่ในระยะ 2 ไบต์ของการเพิ่มประสิทธิภาพ (เว้นแต่เราจะผ่อนคลายการตีความความจริง / เท็จฉันเดา) ผมเคยให้เรียกใช้การค้นหาแรงเดรัจฉานใกล้เคียงกับสองวันผ่านโปรแกรมทั้งหมดที่เหมาะสมในด้านความยาว 2 คือถึง 7 ไบต์ (ไม่ค่อนข้างโปรแกรมทั้งหมด - ฉันทำสมมติฐานไม่กี่ในสิ่งที่ทุกความต้องการโปรแกรมที่ถูกต้องและสิ่งที่ไม่มี โปรแกรมที่ถูกต้องอาจมี) การค้นหาพบวิธีแก้ปัญหาสำหรับประตูที่เป็นไปได้ 15 จาก 16 ประตู - และมักจะมากกว่าหนึ่งประตู คุณสามารถค้นหารายการโซลูชันทางเลือกทั้งหมดใน pastebin นี้ซึ่งฉันได้จัดกลุ่มพวกเขาด้วยพฤติกรรมที่เท่าเทียมกัน รายการที่ฉันแสดงไว้ด้านบนที่ฉันเลือกเนื่องจากเป็นวิธีที่ง่ายที่สุดหรือน่าสนใจที่สุดและฉันจะเพิ่มคำอธิบายสำหรับพวกเขาในวันพรุ่งนี้

สำหรับเกตที่ 16: XOR เป็นเกทตัวเดียวที่ไม่สามารถใช้งานได้ใน 7 ไบต์ การค้นหากำลังดุร้ายในโปรแกรมที่มีขนาดใหญ่กว่านั้นไม่น่าเป็นไปได้ที่จะใช้รหัสที่ฉันมีอยู่ในปัจจุบัน ดังนั้นต้องเขียนด้วยมือ XOR สั้นที่สุดที่ฉันได้พบคือโปรแกรม 10 ไบต์ข้างต้นซึ่งขึ้นอยู่กับความพยายามที่ล้มเหลว (แต่ใกล้มาก) โดย FryAmTheEggman เป็นไปได้ว่ามีวิธีแก้ปัญหา 8 ไบต์หรือ 9 ไบต์อยู่ แต่นอกเหนือจากนั้นโซลูชันทั้งหมดควรเหมาะสมที่สุด

คำอธิบาย

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

0000: เท็จ

ฉันไม่คิดว่าเราจะต้องการไดอะแกรมสำหรับอันนี้:

 ! @
. . .
 . .

เนื่องจากตารางหน่วยความจำทั้งหมดถูกกำหนดค่าเริ่มต้นเป็นศูนย์!เพียงพิมพ์ศูนย์และ@ยุติโปรแกรม

นี่เป็นโซลูชัน 2 ไบต์เท่านั้น

0001: และ

 ? .
| @ !
 . .

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

อย่างที่คุณเห็นเมื่อAเป็น0แล้วเราก็พิมพ์และยุติ (จำไว้ว่าทั้งหมด.ไม่มี ops) แต่เมื่อAเป็น1เช่นนั้น IP จะข้ามแถวแรกอีกครั้งโดยอ่านBและพิมพ์แทน

โดยรวมมีโซลูชั่น 5 ไบต์สิบหกสำหรับประตูนี้ สิบสี่ของเหล่านั้นเป็นหลักเช่นเดียวกับข้างต้นไม่ว่าจะใช้>แทน|หรือแทนที่.ด้วยคำสั่งที่มีประสิทธิภาพไม่มี op หรือวาง?ในตำแหน่งที่สอง:

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

และมีวิธีแก้ปัญหาอื่นอีกสองวิธี (ซึ่งเทียบเท่ากัน) สิ่งเหล่านี้ยังใช้ตรรกะการลัดวงจรเช่นเดียวกัน แต่พา ธ การประมวลผลนั้นค่อนข้างบ้าคลั่ง (และปล่อยให้เป็นแบบฝึกหัดสำหรับผู้อ่าน):

?<!@|
?<!@<

0010: A และไม่ใช่ B

 # ?
# ! )
 @ .

สิ่งนี้ยังใช้รูปแบบของการลัดวงจร แต่เนื่องจากการใช้#การควบคุมการไหลเป็นเรื่องที่ยุ่งยากมาก #เป็นสวิตช์ IP แบบมีเงื่อนไข Hexagony จริงมาพร้อมกับหก IP ที่มีป้ายกำกับ0การ5ซึ่งเริ่มต้นในช่วงหกมุมของตารางชี้ไปตามขอบตามเข็มนาฬิกาของพวกเขา (และโปรแกรมที่มักจะเริ่มต้นด้วย IP 0) เมื่อ#พบa ค่าปัจจุบันจะได้รับ modulo 6และการควบคุมการไหลยังคงดำเนินต่อไปตาม IP ที่สอดคล้องกัน ฉันไม่แน่ใจว่าบ้าอะไรที่ทำให้ฉันเพิ่มฟีเจอร์นี้ แต่มันช่วยให้มีโปรแกรมที่น่าแปลกใจบางอย่าง (เช่นนี้)

เราจะแยกความแตกต่างสามกรณี เมื่อA = 0ใดที่โปรแกรมนั้นค่อนข้างง่ายเนื่องจากค่าจะเกิดขึ้นเสมอ0เมื่อ#พบว่าไม่มีการสลับ IP:

#ไม่ทำอะไรเลย?อ่านA(คือยังไม่ทำอะไรเลย) #ยังคงไม่ทำอะไรเลย, !พิมพ์0, )เพิ่มมัน (นี้เป็นสิ่งสำคัญมิฉะนั้น IP จะไม่ข้ามไปยังบรรทัดที่สาม) @สิ้นสุดโปรแกรม เรียบง่ายพอสมควร ตอนนี้ลองพิจารณากรณี(A, B) = (1, 0):

เส้นทางสีแดงยังคงสอดคล้องกับทรัพย์สินทางปัญญาและฉันได้เพิ่มเส้นทางสีเขียวสำหรับไอพี0 1เราเห็นว่าหลังจาก?อ่านA( 1เวลานี้) #สวิตช์จะเป็น IP ที่เริ่มต้นที่มุมขวาบน นั่นหมายความว่า?สามารถอ่านB( 0) ตอนนี้)เพิ่มที่1เช่นว่าในมุมซ้ายด้านบนไม่ทำอะไรเลยและเรายังคงอยู่กับทรัพย์สินทางปัญญา# 1งาน!พิมพ์1และ IP นั้นล้อมรอบด้วยเส้นทแยงมุมด้านซ้าย #ยังคงทำอะไรและ@ยกเลิกโปรแกรม

ในที่สุดกรณีแปลก ๆ จริงๆที่อินพุตทั้งสองคือ1:

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

โดยเฉพาะอย่างยิ่งนี่เป็นโซลูชัน 6 ไบต์เดียวสำหรับเกตนี้

0011: A

 ? !
@ . .
 . .

นี้เป็นเรื่องง่ายพอที่เราจะไม่ต้องแผนภาพ: ?อ่านA, !พิมพ์มัน@ยุติ

นี่เป็นโซลูชัน 3 ไบต์เท่านั้นสำหรับเกตนี้ (ตามหลักการแล้วอาจเป็นไปได้ที่จะทำ,;@แต่การค้นหาไม่ได้รวม;ไว้เพราะฉันไม่คิดว่าจะสามารถบันทึกไบต์!สำหรับงานนี้ได้)

0100: B และไม่ใช่ A

 + ?
| @ !
 ? .

อันนี้ง่ายกว่า "พี่ชาย" ของ0010มันมาก การควบคุมการไหลนั้นเหมือนกันกับที่เราเคยเห็นข้างต้นสำหรับ0001(และ) ถ้าหากA = 0IP นั้นเลื่อนผ่านบรรทัดล่างให้อ่านBและพิมพ์ก่อนสิ้นสุด หากA = 1IP ผ่านเข้าไปในบรรทัดแรกอีกครั้งให้อ่านBด้วยเช่นกัน แต่การ+เพิ่มหน่วยความจำที่ไม่ได้ใช้จะทำให้เกิดการรีเซ็ตค่าปัจจุบันเป็น0ดังนั้นจึง!พิมพ์0ทุกครั้ง

มีตัวเลือก 6-byte ค่อนข้างมากสำหรับเรื่องนี้ (ทั้งหมด 42 ตัว) ครั้งแรกมีวิธีแก้ปัญหามากมายที่เทียบเท่ากับข้างต้น เราสามารถเลือกได้อย่างอิสระระหว่าง|และอีกครั้ง>และ+สามารถถูกแทนที่ด้วยคำสั่งอื่น ๆ ที่ให้ขอบว่างเปล่ากับเรา:

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

นอกจากนี้เรายังสามารถใช้แทน] ย้ายไปที่ IP ถัดไป (เช่นเลือก IP ) เพื่อให้สาขานี้กลับมาใช้ซ้ำที่มุมบนขวา นั่นให้โซลูชันอีก 18 ข้อ:?]1?

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

และมีวิธีแก้ปัญหาอื่นอีกหกวิธีที่ทำงานแตกต่างกันไปตามระดับความบ้าคลั่งที่แตกต่างกัน:

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

0101: B

 ? ?
! @ .
 . .

Woohoo อีกวิธีง่าย ๆ : อ่านAอ่านBพิมพ์Bยุติ แม้ว่าจะมีทางเลือกอื่นสำหรับสิ่งนี้ เนื่องจากAเป็นเพียงอักขระเดียวเราจึงสามารถอ่านได้ด้วย,:

,?!@

และยังมีตัวเลือกในการใช้ซิงเกิ้ล?และใช้มิเรอร์เพื่อวิ่งผ่านมันสองครั้ง:

?|@!    ?>@!

0110: Xor

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

อย่างที่ฉันบอกไว้ข้างต้นนี่เป็นประตูเดียวที่ไม่พอดีกับความยาวด้าน 2 ดังนั้นนี่เป็นคำตอบที่เขียนด้วยลายมือโดย FryAmTheEggman และตัวฉันเองและมีโอกาสดีที่มันไม่เหมาะสม มีสองกรณีที่จะแยกแยะ หากA = 0โฟลวการควบคุมนั้นค่อนข้างง่าย (เพราะในกรณีนั้นเราจำเป็นต้องพิมพ์เท่านั้นB):

เราเริ่มต้นบนเส้นทางสีแดง ?อ่านA, <เป็นสาขาที่ deflects ซ้ายศูนย์ IP แรปไปที่ด้านล่างจากนั้น_เป็นอีกมิรเรอร์และเมื่อ IP ชนมุมมันก็จะไปที่มุมซ้ายบนและยังคงอยู่บนเส้นทางสีน้ำเงิน ?อ่านB, !พิมพ์มัน ตอนนี้(ลดลงมัน สิ่งนี้มีความสำคัญเนื่องจากช่วยให้มั่นใจได้ว่าค่าจะไม่เป็นบวก (เป็นอย่างใดอย่างหนึ่ง0หรือ-1ตอนนี้) นั่นทำให้ IP wrap ไปที่มุมขวาซึ่ง@จะยุติโปรแกรม

เมื่อA = 1สิ่งต่าง ๆ มีความซับซ้อนมากขึ้น ในกรณีนั้นเราต้องการพิมพ์not Bซึ่งในตัวมันเองไม่ยากเกินไป แต่เส้นทางการประมวลผลนั้นค่อนข้างเร็ว

คราวนี้การ<เบี่ยงเบน IP ไปทางขวาจากนั้น<ก็ทำหน้าที่เหมือนกระจกเงา ดังนั้น IP จะข้ามเส้นทางเดียวกันในทางกลับกันโดยอ่านBเมื่อพบ?อีกครั้ง IP ล้อมรอบไปที่มุมขวาและดำเนินการต่อบนเส้นทางสีเขียว มันเผชิญหน้าต่อไป(~ซึ่งก็คือ "พร่องคูณด้วย -1" ซึ่งสัญญาแลกเปลี่ยน0และจึงคำนวณ1 เป็นเพียงกระจกเงาและพิมพ์ผลลัพธ์ที่ต้องการ จากนั้นพยายามส่งคืนหมายเลขอื่น แต่ส่งกลับศูนย์ ตอนนี้ IP ยังคงอยู่ที่มุมล่างซ้ายบนเส้นทางสีน้ำเงิน การลดลงสะท้อนให้เห็นถึงnot B\!?(<(ลดลงอีกครั้งเพื่อให้ค่าปัจจุบันเป็นลบเมื่อ IP เข้ามุม มันเคลื่อนที่ข้ามเส้นทแยงมุมขวาล่างและจากนั้นก็เข้า@สู่โปรแกรมเพื่อยุติโปรแกรม

0111: หรือ

 ? <
< @ !
 . .

การลัดวงจรมากขึ้น

A = 0กรณี (เส้นทางสีแดง) เป็นบิตสับสนที่นี่ IP ที่ได้รับการเบี่ยงเบนทางซ้าย, wraps ไปที่มุมซ้ายด้านล่างได้รับผลโดยทันที<และกลับไปอ่าน? Bจากนั้นจะไปที่มุมที่ถูกต้องพิมพ์Bด้วย!และสิ้นสุด

A = 1กรณี (เส้นทางสีเขียว) เป็นบิตง่าย <สาขา deflects IP ที่ถูกต้องเพื่อให้เราเพียงแค่พิมพ์ห่อกลับไปที่ด้านบนซ้ายและสิ้นสุดที่!@

มีโซลูชัน 5 ไบต์อื่น ๆ เพียงตัวเดียว:

\>?@!

มันทำงานเป็นหลักเหมือนกัน <แต่เส้นทางการดำเนินการที่เกิดขึ้นจริงมีความแตกต่างกันมากและจะใช้มุมสำหรับการแตกแขนงแทน

1000: หรือ

 ) \
! # ?
 @ {

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

ก่อนอื่นมาพิจารณากรณีที่อินพุตทั้งสอง0:

เราเริ่มต้นบนเส้นทางสีเทาซึ่งก็เพิ่มขอบไปเพื่อให้สวิทช์ IP ซึ่งเป็นเส้นทางสีฟ้าเริ่มต้นในมุมขวาบน ไม่ทำอะไรเลยและอ่านอินพุต เราตัดไปที่มุมบนซ้ายที่เพิ่มอินพุตนั้น ทีนี้ตราบใดที่อินพุตมีค่าเป็นศูนย์สิ่งนี้จะส่งผลให้ a ดังนั้นมันจะไม่ทำอะไรเลย จากนั้นย้าย MP ไปทางซ้ายเช่นในประโยคแรกจากไปB เนื่องจากขอบนี้ยังคงมีค่าเริ่มต้นเป็นศูนย์ IP จะย้อนกลับไปที่มุมขวาบนและบนขอบหน่วยความจำใหม่ ดังนั้นการวนซ้ำนี้จะดำเนินต่อไปตราบเท่าที่อ่านค่าศูนย์เคลื่อนที่ MP ไปรอบ ๆ รูปหกเหลี่ยมจากB1#1\?)1#{?ถึงCถึงDและอื่น ๆ ไม่สำคัญว่าจะ?ส่งกลับค่าศูนย์เนื่องจากเป็นอินพุตหรือเพราะ EOF

หลังจากหกซ้ำผ่านวงนี้{กลับไป เวลานี้ขอบจะเก็บค่าจากการวนซ้ำครั้งแรกดังนั้น IP จะแรปที่มุมซ้ายและดำเนินการต่อบนเส้นทางสีเขียวแทน เพียงพิมพ์และยกเลิกโปรแกรม1!1@

ตอนนี้จะเกิดอะไรขึ้นถ้าอินพุตใด ๆ เป็น1อย่างไร

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

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

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

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

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

1001: ความเท่าเทียมกัน

 ( ~
? / @
 # !

นอกจากนี้ยังทำให้การใช้งานการเลือก IP ตามเงื่อนไขอย่างชาญฉลาด เราจำเป็นต้องแยกแยะความแตกต่างอีกครั้งระหว่างและA = 0 A = 1ในกรณีแรกเราต้องการที่จะพิมพ์ในครั้งที่สองที่เราต้องการที่จะพิมพ์not B Bสำหรับเรายังแยกแยะความแตกต่างของทั้งสองกรณีA = 0 Bเริ่มจากA = B = 0:

เราเริ่มต้นบนเส้นทางสีเทา (~สามารถปฏิเสธ IP ที่ตัดไปที่มุมซ้าย (ยังคงอยู่บนเส้นทางสีเทา) และอ่านด้วยA การลดลงนั่นคือเราได้รับและตัด IP ไปที่มุมล่างซ้าย ตอนนี้เหมือนที่ฉันพูดก่อนหน้านี้ใช้โมดูโลค่าก่อนที่จะเลือกเขา IP ดังนั้นมูลค่าที่แท้จริงของการออก IP ซึ่งเริ่มต้นที่มุมซ้ายบนเส้นทางสีแดง อ่าน, decrements ว่าเป็นอย่างดีเพื่อให้เรายังคงอยู่บน IP เมื่อเราตีอีกครั้ง negates เพื่อให้ IP ตัดไปที่มุมขวาล่างพิมพ์และยุติ?(-1#6-15?B(5#~-11

ตอนนี้ถ้าBเป็น1แทนค่าปัจจุบันจะเป็น0เมื่อเรากด#ครั้งที่สองดังนั้นเราจึงเปลี่ยนกลับไปเป็น IP 0(ตอนนี้บนเส้นทางสีเขียว) ที่นิยม?เป็นครั้งที่สามที่ให้ผลผลิต0, !การพิมพ์และ@สิ้นสุด

A = 1สุดท้ายกรณีที่ ครั้งนี้มูลค่าปัจจุบันเป็นศูนย์อยู่แล้วเมื่อเราตี#เป็นครั้งแรกดังนั้นสิ่งนี้ไม่เคยเปลี่ยนเป็น IP 5ในสถานที่แรก เราเพียงดำเนินการต่อทันทีบนเส้นทางสีเขียว ?ตอนนี้ไม่เพียงแค่ให้ศูนย์ แต่กลับมาBแทน !พิมพ์และ@ยุติอีกครั้ง

โดยรวมมีโซลูชัน 7 ไบต์สามรายการสำหรับประตูนี้ อีกสองคนทำงานแตกต่างกันมาก (แม้จะมาจากคนอื่น) และใช้ประโยชน์จาก#มัน โดยเฉพาะอย่างยิ่งพวกเขาอ่านค่าอย่างน้อยหนึ่งค่าด้วย,(อ่านรหัสตัวอักษรแทนจำนวนเต็ม) จากนั้นใช้ค่าโมดูล่า 6 เพื่อเลือก IP มันเป็นถั่วสวย

),)#?@!

?~#,~!@

1010: ไม่ข

 ? ?
| @ !
 ) .

อันนี้ค่อนข้างง่าย เส้นทางการดำเนินการเป็นสาขาแนวนอนที่เรารู้มาandก่อนหน้านี้ ??อ่านและจากนั้นทันทีA Bหลังจากที่สะท้อนให้เห็นถึงที่|และแตกแขนงสำหรับB = 0เราจะดำเนินการตามสาขาด้านล่างที่)เพิ่มมูลค่าให้กับที่จะพิมพ์โดย1 !ในสาขาด้านบน (ถ้ามีB = 1) ?เพียงแค่ตั้งค่าขอบเพื่อที่แล้วยังพิมพ์โดย0!

มีโปรแกรมขนาด 6 ไบต์แปดรายการสำหรับประตูนี้ สี่ของพวกเขาจะสวยมากเหมือนกันโดยใช้>แทน|หรือ1แทน)(หรือทั้งสอง):

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

สองใช้หนึ่งเดียว?ที่ใช้สองครั้งเนื่องจากกระจก ปฏิเสธแล้วที่เกิดขึ้นในขณะที่เราได้สำหรับxorทั้งสองหรือ(~~)

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

และในที่สุดโซลูชันทั้งสองใช้สวิตช์ IP แบบมีเงื่อนไขเนื่องจากเหตุใดจึงใช้วิธีง่าย ๆ ถ้าวิธีที่ซับซ้อนก็ใช้ได้เช่นกัน:

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

1011: B หมายถึง A

 \ #
? ? !
 1 @

วิธีนี้ใช้การสลับ IP ค่อนข้างซับซ้อน ฉันจะเริ่มต้นด้วยA = 1กรณีนี้เพราะมันง่ายกว่า:

เราเริ่มต้นบนเส้นทางสีเทาซึ่งอ่านAด้วยแล้วฮิต? #ตั้งแต่Aเป็น1นี้สลับไป IP 1(เส้นทางสีเขียว) !ทันทีพิมพ์นั้น IP wraps ไปทางซ้ายด้านบนอ่านB(ไม่จำเป็น) และสิ้นสุดลง

เมื่อA = 0สิ่งต่าง ๆ น่าสนใจยิ่งขึ้น ก่อนอื่นให้พิจารณาA = B = 0:

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

ในที่สุดนี่คือ(A, B) = (0, 1)กรณีเท็จ:

โปรดทราบว่าฉันได้ลบเส้นทางสีเทาเริ่มต้นเพื่อความกระจ่างแจ้ง แต่โปรแกรมเริ่มต้นด้วยวิธีเดียวกันและเราก็จบลงบนเส้นทางสีแดงเหมือนเมื่อก่อน ดังนั้นครั้งนี้ที่สองผลตอบแทน? ตอนนี้เราพบ1 1ณ จุดนี้สิ่งสำคัญคือต้องเข้าใจว่าตัวเลขจริง ๆ ทำอะไรใน Hexagony (จนถึงตอนนี้เราใช้มันเป็นศูนย์เท่านั้น): เมื่อพบตัวเลขค่าปัจจุบันจะถูกคูณด้วย 10 แล้วจึงเพิ่มตัวเลข นี้จะใช้ตามปกติในการเขียนตัวเลขทศนิยมคำต่อคำลงในซอร์สโค้ด แต่มันหมายความว่าเป็นแมปจริงค่าB = 1 11ดังนั้นเมื่อเราเข้าชม#สิ่งนี้จะถูกนำ6ไปใช้เพื่อให้5และด้วยเหตุนี้เราจึงเปลี่ยนเป็น IP 5(แทนที่จะ1เป็นก่อนหน้านี้) และดำเนินการต่อในเส้นทางสีน้ำเงิน กดปุ่ม?ครั้งที่สามจะคืนค่าศูนย์ดังนั้นจึง!พิมพ์ออกมาและหลังจากนั้นอีกสอง?IP IP จะตัดที่ด้านล่างขวาที่โปรแกรมยกเลิก

มีโซลูชั่นขนาด 7 ไบต์สี่ตัวสำหรับสิ่งนี้และทั้งหมดทำงานต่างกัน:

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

1100: ไม่ใช่ A

 ? (
~ ! @
 . .

เพียงแค่เส้นง่ายๆ: อ่านAด้วย?, ลบล้างด้วยการ(~พิมพ์กับยุติด้วย!@

มีทางเลือกหนึ่งทางเลือกและนั่นก็คือการปฏิเสธด้วย~):

?~)!@

1101: A แปลว่า B

 ? .
| @ !
 ) .

นี้เป็นจำนวนมากง่ายกว่าความหมายตรงข้ามเราก็พูดคุยเกี่ยวกับ andมันเป็นอีกครั้งหนึ่งในบรรดาโปรแกรมสาขาแนวนอนเช่นหนึ่งสำหรับ ถ้าAเป็น0เช่นนั้นก็จะได้รับการเพิ่มขึ้น1ที่สาขาด้านล่างและพิมพ์ มิฉะนั้นสาขาด้านบนจะถูกดำเนินการอีกครั้งโดยที่?จะอ่านBแล้ว!พิมพ์ออกมาแทน

มีเป็นตันของทางเลือกที่นี่ (66 การแก้ปัญหาในทั้งหมด) ส่วนใหญ่เนื่องจากการเลือกฟรีของที่มีประสิทธิภาพไม่มี Ops สำหรับการเริ่มต้นเราสามารถแตกต่างกันไปการแก้ปัญหาดังกล่าวข้างต้นในทุกรูปแบบเดียวกับที่เราจะทำได้andและเรายังสามารถเลือกระหว่าง)และ1:

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

จากนั้นจะมีเวอร์ชั่นอื่นโดยใช้การเลือก IP แบบมีเงื่อนไขโดยที่คำสั่งแรกสามารถเลือกได้เกือบทุกข้อและยังมีตัวเลือกระหว่าง)และ1สำหรับตัวเลือกบางตัว:

"?#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

 ? $
@ # )
 ! <

อันซับซ้อนอันสุดท้าย หากคุณยังอ่านอยู่แสดงว่าคุณเกือบทำแล้ว :) มาดูA = 0กันก่อน:

?อ่านแล้วเราตีA $นี่คือคำสั่งกระโดด (เช่น Befunge ของ#) @ซึ่งข้ามการเรียนการสอนต่อไปเพื่อให้เราไม่ยุติบน แทนที่จะ IP #คงที่ อย่างไรก็ตามตั้งแต่Aเป็น0นี้ไม่ได้ทำอะไร )เพิ่มขึ้นเพื่อ1ให้ IP ดำเนินการต่อบนพา ธ ด้านล่างที่1พิมพ์ <เบน IP ไปทางขวาที่มันตัดไปที่มุมซ้ายและสิ้นสุดโปรแกรม

ถัดไปเมื่อ(A, B) = (1, 0)เราได้รับอินพุต:

มันเป็นหลักเช่นเดียวกับก่อนยกเว้นว่าที่#เราเปลี่ยนไป IP 1(เส้นทางสีเขียว) แต่เนื่องจากBเป็น0เราเปลี่ยนกลับไป IP 0เมื่อเราตี#เป็นครั้งที่สอง (ตอนนี้เส้นทางสีฟ้า) ที่จะพิมพ์1เป็นมาก่อน

ในที่สุดA = B = 1กรณี:

ครั้งนี้เมื่อเรา#เป็นครั้งที่สองมูลค่าปัจจุบันยังคงอยู่1เพื่อให้เราไม่เปลี่ยน IP อีกครั้ง การ<สะท้อนกลับและครั้งที่สามที่เราไปถึง?เราจะได้ศูนย์ ดังนั้น IP จะตัดไปที่ด้านล่างซ้ายซึ่งจะ!พิมพ์ศูนย์และโปรแกรมจะสิ้นสุด

มีโซลูชั่นทั้งหมด 7 ไบต์ที่รวมอยู่ในนี้ ทางเลือกแรกใช้1แทน):

?$@#1!<

จากนั้นมีวิธีแก้ปัญหาสองประการที่จะนำไปสู่การเปลี่ยนแปลง IP ของคุณ:

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

สิ่งเหล่านี้ทำให้ใจฉัน: ส่วนที่น่าสนใจคือการสลับ IP สามารถใช้เป็นเงื่อนไขที่เลื่อนออกไป กฎการสลับ IP ของภาษานั้นทำให้ IP ปัจจุบันทำอีกก้าวหนึ่งก่อนที่สวิตช์จะเกิดขึ้น หากขั้นตอนนั้นเกิดขึ้นเมื่อผ่านมุมหนึ่งค่าปัจจุบันจะตัดสินใจว่าสาขาใดที่ IP จะดำเนินการต่อไปหากเราเปลี่ยนกลับไปเป็นระดับเดิม A = B = 1ตรงนี้เกิดขึ้นเมื่อเข้าเป็น แม้ว่าทั้งหมดนี้จะสอดคล้องกับวิธีการออกแบบภาษาของฉัน แต่ฉันไม่เคยตระหนักถึงความหมายของสเป็คนี้ดังนั้นจึงเป็นเรื่องที่ดีเมื่อภาษาของฉันสอนเทคนิคใหม่ให้ฉัน: D

จากนั้นมีโซลูชันที่สามซึ่งจำนวนการสลับ IP ยิ่งแย่ลง (แม้ว่าจะไม่ได้ใช้ประโยชน์จากเงื่อนไขที่เลื่อนออกไป):

>?1]#!@

แล้วมีอีกหนึ่ง:

?$@#)!<

จากนั้นก็มีวิธีแก้ปัญหาที่เทียบเท่ากันทั้งสี่นี้ซึ่งใช้การสลับ IP แบบไม่มีเงื่อนไขและใช้ตรรกะทั้งหมดผ่านสาขาและมุม:

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

1111: จริง

 1 !
@ . .
 . .

คุณได้รับสิ่งที่ตัวเองที่ง่ายสำหรับการสิ้นสุด: ตั้งขอบ1พิมพ์กับยุติด้วย! @:)

แน่นอนว่ามีทางเลือกหนึ่ง:

)!@

ตามปกติทุกแผนภาพการควบคุมการไหลที่สร้างขึ้นด้วย Timwi ของHexagonyColorerและแผนภาพหน่วยความจำของเขาEsotericIDE

APL, 22 20 18 ไบต์

รายการจริงและเท็จเป็นโปรแกรมที่สมบูรณ์และอีก 14 รายการเป็นฟังก์ชัน (ขอบคุณ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)

ลองที่นี่

ผู้เล่นหมากรุก / หมากรุกทั่วไปในเกม endgame จำนวน 70 ชิ้น

ฉันคิดว่าเกมอื่นควรมีเกียรตินี้

โปรดทราบว่าฉันใช้กฎบางอย่างสำหรับวิธีการย้ายชิ้น เพราะฉันไม่รู้สึกว่าศึกษาการเคลื่อนไหวที่ดีที่สุดสำหรับทุกสถานการณ์กฎสำหรับการเคลื่อนไหวของคนผิวขาวนั้นง่าย: ให้พ้นจากการตรวจจับชิ้นที่มีอันดับสูงสุดที่เขาสามารถหมุนได้ในขณะที่สูญเสียวัสดุน้อยที่สุด จากการส่งเสริมตามลำดับความสำคัญ หากมีสองช่องว่างที่เขาสามารถย้ายไปได้โดยมีความชอบเท่ากันเขาสามารถย้ายไปที่ใดก็ได้ (ด้วยเหตุนี้ถ้าหากเขาสามารถย้ายไปยังมากกว่าหนึ่งตารางพวกเขาจะมีสีเดียวกัน) โปรดทราบว่าสีขาวจะจับภาพด้วยบางสิ่งแม้ว่าจะถูกดักจับถ้าชิ้นส่วนที่โจมตีมีค่าสูงกว่าชิ้นที่หายไป ค่าอยู่ที่นี่:pawn<knight=bishop<rook<queen

การป้อนข้อมูลไม่ว่าจะเป็นโกงหรือไม่ โปรดทราบว่า rooks จะมีป้ายกำกับชื่อ A และ B เฉพาะเมื่อสำคัญ: หากประตูทำงานเหมือนกันเมื่อเปลี่ยน rooks จะไม่มีการระบุชื่อ

ผลลัพธ์คือสีของราชาขาวสี่เหลี่ยมจัตุรัสสิ้นสุดลงที่: ขาว = 1, ดำ = 0

ก่อนภาพฉันต้องการขอโทษสำหรับภาพที่ไม่ดี ฉันไม่ค่อยถนัดเรื่องกล้องมากนัก

เท็จ, 4:

และ, 4:

A และไม่ใช่ B, 5 (ฉันคิดว่าฉันสามารถลดได้ถึงสาม แต่ตอนนี้ยังไม่มีบอร์ด):

A, 4:

ไม่ใช่ A และ B, 5 (ฉันคิดว่าฉันจะเอามันลงไปได้สามอัน แต่ตอนนี้ยังไม่มีบอร์ด):

B, 4:

Xor, 5 (ฉันรู้วิธีที่จะทำให้มัน 4 แต่ตอนนี้ฉันไม่มีบอร์ด):

หรือ 4:

หรือ 4:

Xnor, 5 (ฉันรู้วิธีที่จะทำให้มัน 4 แต่ตอนนี้ฉันไม่มีบอร์ด):

ไม่ใช่ B, 4:

B หมายถึง A, 5 (ฉันคิดว่าฉันจะเอามันลงไปได้สามอัน แต่ตอนนี้ยังไม่มีบอร์ด):

ไม่ใช่ A, 4:

A หมายถึง B, 5 (ฉันคิดว่าฉันสามารถลดมันลงเหลือสาม แต่ตอนนี้ยังไม่มีบอร์ด):

Nand, 4:

จริง 4:

เยลลี่ขนาด 19 ไบต์

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.

ลองออนไลน์!

ประตูตรรกะ NAND - 31 ประตู

ในฐานะที่เป็นผู้สร้างของเดิม ชุด ของ NAND ประตู คำถามฉันไม่สามารถผ่านขึ้นโอกาสที่จะใช้ประตูเหล่านี้ในการแก้ปัญหาตรรกะประตูอีก

ในแต่ละแผนภาพเหล่านี้อินพุตด้านบนคือ A ในขณะที่อินพุตด้านล่างคือ B

แท็ก Cyclicบิต, 118 บิต = 14.75 ไบต์

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

• 0: ลบบิตแรกออกจาก data tape
• 1x: ถ้าบิตแรกของ data data เป็น 1 ให้ผนวก bit xเข้ากับ data tape

เราเริ่มต้น data tape ด้วย 1 ตามด้วยสอง input bits (1 จำเป็นเพราะไม่มีวิธีการสร้าง 1 หาก data tape ประกอบด้วย 0 ทั้งหมด) และเราใช้ bit data สุดท้ายที่ถูกลบเป็นเอาต์พุตของ gate .

• 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 ไบต์

[].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

ใช้อินพุตเช่นmin(True,False)(หรือเป็นmin(1,0)) รับประโยชน์อย่างมากจากผลลัพธ์เพียงต้องการค่า Truthy-Falsey ที่ถูกต้องเท่านั้น lambdaเมื่อใดก็ตามที่เป็นไปได้ใช้ในตัวเพื่อหลีกเลี่ยงการเสียค่าใช้จ่าย ฉันใช้รหัสเพื่อค้นหาบิวด์อินที่ใช้งานได้

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

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]

ไป (เกม), 33 ก้อน, 73 แยก

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

สีขาวชนะ (2, 1x5):

➊━━━➋

1 และ 2 (3, 2x3):

➊◯➋
┗┷┛

1 และไม่ใช่ 2 (2, 1x5):

╺➊━➁╸

1 (2, 1x5):

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

ไม่ใช่ 1 และ 2 (2, 1x5):

╺➋━➀╸

2 (2, 1x5):

╺➋➀━╸

1 xor 2 (2, 2x3):

➀┯➁
┗┷┛

1 หรือ 2 (2, 1x5):

╺➊━➋╸
➀━━━➁

1 หรือ 2 (2, 1x4):

➊━━➋
╺➀➁╸

1 = 2 (2, 1x7):

╺━➀━➁━╸

ไม่ใช่ 2 (2, 1x3):

➀➁╸

1 หรือไม่ 2 (2, 1x4):

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

ไม่ใช่ 1 (2, 1x3)

➁➀╸

ไม่ใช่ 1 หรือ 2 (2, 1x4):

➁➀━╸

1 nand 2 (2, 1x3):

➊━➋

ผู้ชนะสีดำ (2, 1x3):

➊➋╸
➀━➁
➊━➁

หน้านี้ช่วยฉันได้เล็กน้อย: http://www.mathpuzzle.com/go.html

บางทีใครบางคนสามารถหาวิธีแก้ปัญหา 2 หินสำหรับ 1 และ 2 บนกระดาน 1x9 ...

Javascript ES6, 124 ไบต์

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

ฉันเกลียดลูกแกะตอนนี้อย่างจริงจัง

เรติน่า , 62 39 ไบต์

23 ไบต์ขอบคุณ@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: 

PQจะเข้าเป็น

เอาท์พุทเป็นจำนวนเต็มระหว่างการ0 เป็นคนโกหกคนอื่นเป็นจริง30

คำอธิบาย

พวกเขาทั้งหมดเพียงregexes

ยกตัวอย่างเช่น01|10เพียงแค่ตรงหรือ0110

ใน0000, 2ไม่เคยจะเป็นในการป้อนข้อมูลดังนั้นจึงไม่ตรงกับ

ในมันตรงกับสตริงว่างที่มีอยู่11114

Stack Cats , 67 + 64 = 131 ไบต์

โปรดทราบว่า +64 มาจากการใช้-nmแฟล็กกับแต่ละโปรแกรม -nระบุ I / O ที่เป็นตัวเลขและทำมิร-mเรอร์ซอร์สโค้ดสำหรับอักขระสุดท้ายไม่ใช่การส่งทั้งหมดที่ต้องการแฟล็กเหล่านี้ทางเทคนิค แต่เพื่อความมั่นคงและความเรียบง่าย

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

()ใน Stack Cats ตรวจสอบว่าองค์ประกอบนั้นเป็นค่าบวกหรือไม่เชิงลบ (เช่น 0 หรือลบ) ดังนั้นเราจึงใช้มันเพื่อความจริง / เท็จตามลำดับ คอลัมน์ที่สองเป็นที่สนใจและแสดงรายการประตูที่ดีที่สุดด้วย0/ 1s เป็นผลลัพธ์ (ด้วยคะแนนรวม 90)

อินพุตเป็นบิตคั่นด้วยตัวคั่นผ่าน STDIN ลองออนไลน์!

Stack Cats เป็นภาษาลึกลับที่ย้อนกลับได้ซึ่งโปรแกรมมีความสมมาตรไตร่ตรอง ได้รับข้อมูลเท่านั้นf(เช่น>[[(!-)/) ภาพสะท้อน (เช่น\(-!)]]<) f^-1คำนวณผกผัน เป็นเช่นนี้แม้กระทั่งโปรแกรมความยาวไม่ทำอะไรเลย (หรือได้รับการติดอยู่ในวง จำกัด ) และโปรแกรมที่ไม่น่ารำคาญเพียงมีความยาวแปลกคอมพิวเตอร์f g f^-1ที่gเป็นผู้ดำเนินการศูนย์

เนื่องจากซอร์สโค้ดครึ่งหนึ่งมีการซ้ำซ้อนอยู่เสมอจึงสามารถปล่อยทิ้งไว้และรันโค้ดที่มี-mแฟล็กบ่งชี้ว่าซอร์สโค้ดควรถูกมิรเรอร์ผ่านอักขระตัวสุดท้ายเพื่อดึงซอร์สโค้ดจริง ตัวอย่างเช่นโปรแกรม*<Xเป็นจริง*<X>*ซึ่งเป็นสมมาตร

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

Haskell, 78 76 75 ไบต์

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

แก้ไข: -1 ไบต์ขอบคุณ @cole

Brachylog , 36 34 ไบต์

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)

สิ่งนี้คาดว่าจะ0เป็นค่าเท็จและ1เป็นความจริง ผลตอบแทนหรือtrue falseP คือInputและ Q Outputเป็น

เปิดฉาก147 145 ไบต์

รับ 2 ไบต์ด้วย @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

แบบสอบถามx(P,Q).กับxการเป็นตัวอักษรที่เหมาะสมและPและQการตั้งค่าเป็น 0 หรือ 1
ผลตอบแทนหรือtruefalse

ตัวอย่าง SWISH รวมถึงการทดสอบ - ป้อนrunTest.เพื่อเรียกใช้

NTFJ, 86 ไบต์

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               #

ลองที่นี่! แต่อ่านด้านล่างก่อน

อินพุตมีความหมายในสแต็ก ผลลัพท์ที่ได้คือ เพิ่ม 16 ไบต์ (หนึ่ง*ถึงส่วนท้ายของแต่ละรายการ) หากคุณต้องการ0x00หรือ0x01ส่งออกแทน 0 และ 1 เพิ่ม 160 ไบต์เพิ่มเติมถ้าคุณต้องการ0หรือ1พิมพ์ (ใส่~~##~~~#{@ก่อนหน้า*)

ตัวดำเนินการไบนารีเดียวของ NTFJ คือ NAND ดังนั้นแต่ละตัวจะเขียนในรูปแบบ NAND

มาแต่ละคนกัน

0: เท็จ

~

~แสดงถึงบิตเท็จ เรียบง่ายพอสมควร เนื่องจากอินพุตมีความหมายที่ด้านล่างของสแต็กนี่จึงเหลือที่ด้านบนของมัน

1: p และ q

|:|

NTFJ ทำงานกับสแต็ก :เป็นคำสั่งที่ซ้ำกัน สังเกตว่าp and q≡ และว่าnot (p nand q)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

(หมายเหตุจากนั้น:|สามารถกล่าวได้ว่าเป็นการปฏิเสธและ|:|สามารถกล่าวได้ว่าเป็นการรวม )

2: p และไม่ใช่ q

:||:|

สังเกตที่ว่านี้เป็นเพียงแค่การปฏิเสธและร่วม:||:|

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

3: p

$

$ดึงไอเท็มออกจากสแต็ก ดังนั้น ... ใช่

4: ไม่ใช่ p และ q

#{:||:|

นี่เป็นสิ่งเดียวกับ 2 ยกเว้น#{ตอนต้น #ผลัก 1 (บิตจริง) และ{หมุนสแต็กทางซ้ายหนึ่งครั้ง เรียบง่ายพอสมควร

5: q

#{$

หมุนไปทางซ้ายหนึ่งครั้งแล้วปล่อย

6: xor

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

สังเกต:

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

อย่างไรก็ตามไม่มีวิธีการทำซ้ำสแต็คทั้งหมด ดังนั้นเราจะต้องนำแต่ละpส่วนqไปด้านบนและทำซ้ำ

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

และเรามีแฮคเกอร์ของเรา

7: p หรือ q

:|#{:||

ปฏิเสธด้านบนนำด้านล่างขึ้นด้านบนคัดค้านและรวมเข้าด้วยกัน โดยพื้นฐานแล้ว, p or q = (not p) nand (not q).

8: ไม่ใช่ p และไม่ใช่ q

:|#{:||:|

นี่เป็นเพียงการปฏิเสธของ 7 ง่าย

9: eq

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

นี่เป็นแค่xnorหรือไม่ใช่ xor ง่ายอีกครั้ง

10: ไม่ใช่ q

#{$:|

การปฏิเสธของ 5

11: p หรือไม่ q

#{:||

ลบล้าง p, nand (not p) nand q = not ((not p) and q) = p or (not q) (by De Morgan's laws).

12: ไม่ p

$:|

ปล่อยหยุดและลบล้าง

13: ไม่ใช่ p หรือ q

:||

กฎหมายของเดอมอร์แกนเพื่อช่วยวันนี้อีกครั้ง! กระบวนการเช่นเดียวกับ 11 เพียงกวนแทนqp

14: ไม่ใช่ p หรือไม่ใช่ q

|

นี่เป็นเพียงเลียนแบบ

15: จริง

#

# เป็นบิตที่แท้จริง

Minecraft, 89 บล็อก

ในภาพถ่ายทั้งหมดต่อไปนี้บล็อกสีน้ำเงินใช้สำหรับอินพุต A และบล็อกสีส้มใช้สำหรับอินพุต B

16. ประตู TRUE - 1 ช่วงตึก

15. เกต NAND - 1x2x3 = 6 บล็อค

14. A => B - 1x2x3 = 6 ช่วงตึก

13. Not A - 2 blocks

12. B => A - 1x2x3 = 6 ช่วงตึก

11. NOT B - 2 ช่วงตึก

10. XNOR - 1x3x4 = 12 ช่วงตึก

9. NOR - 1x2x3 = 6 ช่วงตึก

8. หรือ - 1 บล็อก

7. XOR - 1x3x4 = 12 ช่วงตึก

6. B - 1 ช่วงตึก

5. ! A&B - 1x2x5 = 10 ช่วงตึก

4. A - 1 บล็อก

3. A &! B - 1x2x5 = 10 ช่วงตึก

2. AND - 2x2x3 = 12 ช่วงตึก

1. FALSE- 1 บล็อก

Mathematica, 67 ไบต์

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

แต่ละค่าเหล่านี้ประเมินเป็นฟังก์ชันเพื่อให้คุณสามารถใช้เช่น

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

อ้าถ้าเพียงจำนวนเต็มเท่านั้นที่เป็นความจริง / เท็จใน Mathematica สี่คนนั้นอาจจะสั้นลงอย่างมาก

MATL, 34 23 ไบต์

ฉันหวังว่าฉันจะได้รับคำสั่งซื้อถูกต้อง! ศูนย์คือความเท็จไม่เป็นศูนย์คือความจริง แต่ละฟังก์ชั่นใช้สองอินพุตโดยปริยาย (แม้ว่ามันอาจจะไม่สนใจบางอินพุต) อินพุตแรกคือ A, และสองคือ B. คุณสามารถป้อนข้อมูล0/ 1สำหรับจริง / เท็จหรือ/TF

นี่คือตัวอย่างTryItOnlineสำหรับกรณีทดสอบ 3

บันทึกไว้ 4 ไบต์โดยใช้*สำหรับandและอีก 4 รายการโดยใช้>/ <แทน~wY&/ w~Y&หลังจากที่ฉันเห็นคำตอบของเดนนิส!

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 ไบต์

dc("desk calculator") เป็นคำสั่ง unix มาตรฐานซึ่งเป็นเครื่องคิดเลข postfix แบบกองซ้อน มันไม่มีการดำเนินงานบิตและผู้ประกอบการเปรียบเทียบสามารถใช้ในการดำเนินการแมโคร (ซึ่งไม่คุ้มค่าไบต์) การแบ่งจำนวนเต็มทำขึ้นสำหรับบางสิ่ง

สคริปต์เหล่านี้คาดหวัง0และ1ค่าบนสแต็กและปล่อยผลลัพธ์ไว้บนสแต็ก

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

เขาวงกต , 85 ไบต์

ขอบคุณ Sp3000 สำหรับการบันทึก 2 ไบต์

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

ทั้งหมดนี้เป็นโปรแกรมเต็มรูปแบบอ่านจำนวนเต็มสองจำนวน0หรือ1จาก STDIN (โดยใช้ตัวคั่นที่ไม่ใช่ตัวเลขใด ๆ ) และพิมพ์ผลลัพธ์เป็น0หรือ1ไปที่ STDOUT

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

สำหรับคำอธิบายทั้งหมดนี้ค่อนข้างตรงไปตรงมา โปรแกรมทั้งหมดเป็นแบบเส้นตรงและคำสั่งที่ใช้ทำดังต่อไปนี้:

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

โปรดทราบว่าฉันกำลังใช้#อยู่เสมอเพื่อรวมเข้าด้วย$กันเช่นเพื่อคำนวณXOR 1หรือกล่าวอีกนัยหนึ่งสำหรับการปฏิเสธเชิงตรรกะ เพียง แต่ในบางกรณีคือผมสามารถที่จะใช้~แทนเพราะต่อมา&ทิ้งทุกบิตที่ไม่พึงประสงค์จากการที่เกิดขึ้นหรือ-1-2

รหัสเครื่อง IA-32 ขนาด 63 ไบต์

Hexdump ของรหัสด้วยการถอด:

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;

รหัสนานกว่ามันอาจจะเป็นเพราะใช้การประชุมมาตรฐานการเข้ารหัส: การป้อนข้อมูลในecxและและการส่งออกในedx alสิ่งนี้อาจแสดงใน C เป็น

unsigned char __fastcall func(int, int);

ดูเหมือนว่า MS Visual Studio ไม่เข้าใจSALCopcode ที่ไม่มีเอกสารดังนั้นฉันต้องใช้รหัสแทนชื่อ

ขอบคุณl4m2สำหรับการปรับปรุงตัวอย่างโค้ด!

C 34 ไบต์

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

โดยที่ n คือหมายเลขฟังก์ชันที่ใช้ แต่ฉันคิดว่ามันจะถูกปฏิเสธดังนั้นฉันจึงเสนออีกอันนี้:

C 244 ไบต์ (ใช้หน่วยความจำ)

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};

มันใช้อาร์เรย์ทำดัชนีสองครั้ง n[0][1]คือ(A implies B)(0,1)

มา 138 ไบต์

ฉันเพิ่งเรียนรู้มา ฉันคิดว่ามันเข้ากันได้กับ Ansi Forth ในขณะที่มันทำงานบน 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

ฟังก์ชั่น z สร้างฟังก์ชั่นใหม่ด้วยชื่อที่ให้ไว้จากนั้นใส่หมายเลขเกตทางตรรกะจากด้านบนของสแต็กไปยังที่อยู่ฟังก์ชันใหม่ มันปล่อยให้ฟังก์ชันเกตเกตตรรกะ (n + 1) ถัดไปในสแต็กสำหรับการประกาศครั้งถัดไป

คุณสามารถทดสอบได้:
และ AB

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

("." พิมพ์ด้านบนของสแต็ก "cr" คือการส่งคืน cariage)

C, 268 ไบต์

#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 

มาโครดูเหมือนสั้นกว่าฟังก์ชั่น

Brian & Chuck , 183 ไบต์

ขอบคุณ Sp3000 สำหรับการบันทึก 4 ไบต์

บางโปรแกรมมีอักขระที่ไม่สามารถพิมพ์ได้ โดยเฉพาะอย่างยิ่งทุกคน\x01ควรถูกแทนที่ด้วย<SOH>อักขระควบคุม (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
?
#>+.

อินพุตและเอาต์พุตใช้ค่าไบต์ดังนั้นอินพุตควรเป็นสอง 0x00 หรือ 0x01 ไบต์ (ไม่มีตัวคั่น) และเอาต์พุตจะเป็นหนึ่งไบต์ดังกล่าว นี่เป็นคำจำกัดความที่สมเหตุสมผลที่สุดของความจริง / ความเท็จสำหรับ B&C เพราะคำสั่งการควบคุมการไหลเพียงอย่างเดียว?ถือว่าศูนย์เป็นเท็จและทุกอย่างเป็นความจริง

คำอธิบาย

ก่อนรองพื้น B&C อย่างรวดเร็ว:

• ทุกโปรแกรมประกอบด้วยอินสแตนซ์ที่เหมือน Brainfuck สองรายการแต่ละรายการเขียนในบรรทัดของตนเอง เราเรียกคนแรกที่ไบรอันและครั้งที่สองหนึ่งโยน การประหารเริ่มต้นที่ไบรอัน
• เทปของแต่ละโปรแกรมเป็นซอร์สโค้ดของโปรแกรมอื่นและตัวชี้คำแนะนำของแต่ละโปรแกรมคือหัวเทปของโปรแกรมอื่น
• มีเพียงไบรอันเท่านั้นที่สามารถใช้,คำสั่ง (อินพุตไบต์) และเฉพาะชัคเท่านั้นที่สามารถใช้.คำสั่ง (เอาต์พุตไบต์)
• การ[]วนรอบของ Brainfuck ไม่มีอยู่ แทนกระแสควบคุมเดียวที่คุณมีคือ?สวิตช์ที่ควบคุมไปยังอินสแตนซ์อื่นถ้าค่าปัจจุบันภายใต้ส่วนหัวเทปไม่ใช่ศูนย์
• นอกจาก>และ<ยังมี{และ}สิ่งที่เทียบเท่ากับตัวอย่าง Brainfuck [<]และ[>]นั่นคือพวกเขาย้ายหัวเทปไปยังตำแหน่งศูนย์ถัดไปในทิศทางนั้น ความแตกต่างที่สำคัญคือ{สามารถหยุดที่ด้านซ้ายของเทปโดยไม่คำนึงถึงค่าที่มี
• เพื่อความสะดวก_s ใด ๆในซอร์สโค้ดจะถูกแทนที่ด้วย null-bytes (เนื่องจากสิ่งเหล่านี้มีประโยชน์มากในโปรแกรมที่ไม่เกี่ยวกับการจับ{และ})

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

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

0000, 1111: ฟังก์ชั่นคงที่

?
#>.

?
#>+.

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

0011, 0101, 1010, 1100: ฟังก์ชั่นขึ้นอยู่กับเพียงหนึ่งการป้อนข้อมูล

,?\x01+?
#>.

,,?\x01+?
#>.

,,-?\x01+?
#>.

,-?\x01+?
#>.

ขึ้นอยู่กับว่าเราเริ่มต้นด้วย,หรือ,,เรากำลังทำงานร่วมกับหรือA Bลองดูตัวอย่างแรก0011(เช่นA) หลังจากอ่านค่าเราจะใช้?เป็นเงื่อนไขกับค่านั้น หากA = 1สิ่งนี้สลับไปที่ Chuck ซึ่งจะย้ายหัวเทปไปทางขวาและพิมพ์1ไบต์ที่ฝังตัวแท้จริง มิฉะนั้นการควบคุมยังคงอยู่ในไบรอัน ที่นี่ 1 ไบต์คือไม่มีการเปิด จากนั้นเราก็เพิ่มการป้อนข้อมูลที่ดีกับ+ที่จะทำให้แน่ใจว่ามันไม่ใช่ศูนย์และจากนั้น?สลับไปโยนด้วย เวลานี้,>0จะย้ายไปที่เซลล์ที่ไม่ได้ใช้ไปทางขวาซึ่งจะถูกพิมพ์แล้ว

-เพื่อที่จะเมื่อตะกี้หนึ่งของค่าเราก็พร่องมันด้วย สิ่งนี้เปลี่ยน1เป็น0และ0กลายเป็น-1ซึ่งไม่เป็นศูนย์และด้วยเหตุนี้ความจริงจึงเป็นเท่าที่?เกี่ยวข้อง

0001, 0010, 0100, 1000: ฟังก์ชั่นไบนารีที่มีผล truthy หนึ่ง

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

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

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

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

นี่เป็นส่วนขยายของแนวคิดก่อนหน้าเพื่อทำงานกับอินพุตสองตัว ลองดูตัวอย่างของ1000(NOR) เรา (อาจ) ,?อ่านปัจจัยการผลิตทั้งที่มี หากทั้งสองของผู้ที่เป็น1ที่?สวิทช์ที่จะโยน เขาย้ายหัวเทปไปยังจุดสิ้นสุดด้วย}(ไปยังเซลล์ว่างหลังจากรหัสของ Brian) ย้ายเซลล์อื่นด้วย> (ยังคงเป็นศูนย์) .และพิมพ์ด้วย

อย่างไรก็ตามถ้าอินพุตทั้งสองเป็นศูนย์การควบคุมจะยังคงอยู่กับไบรอัน >แล้วย้ายหัวเทปลงบน}ดังกล่าวว่าคำสั่งนี้ไม่ได้?ดำเนินการเมื่อเราเปลี่ยนไปโยนด้วย ตอนนี้สิ่งที่ Chuck ทำก็คือ>.เคลื่อนไปยัง1เซลล์ -cell เท่านั้นและพิมพ์ออกมา

เราสามารถรับฟังก์ชั่นอื่น ๆ อีกสามฟังก์ชั่นได้อย่างง่ายดายโดยลบอินพุตหนึ่งหรือทั้งสองอย่างตามต้องการ

0111, 1011, 1101, 1110: ฟังก์ชั่นไบนารีที่มีผล truthy สาม

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

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

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

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

การเปลี่ยนแปลงเล็กน้อยของแนวคิดก่อนหน้านี้เพื่อลบล้างผลลัพธ์ (เช่นพิมพ์0เมื่อเราผ่าน Brian ทั้งหมดและ1อื่น ๆ ) ลองดูที่0111(OR) เป็นตัวอย่าง โปรดทราบว่าฝัง1ไบต์คู่คือไม่มี-op ,?,?ดังนั้นนี้ยังคงเริ่มต้นด้วย ถ้าใส่อย่างใดอย่างหนึ่งคือเราเปลี่ยนไปโยนที่ย้ายหัวเทปกลับไปเริ่มต้นด้วย1{>.ย้ายส่วนหัวของเทปไปที่ - 1ไบต์และพิมพ์

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

อีกครั้งเราสามารถรับฟังก์ชั่นอื่น ๆ ได้อย่างง่ายดายโดยลบอินพุตหนึ่งหรือทั้งสอง

0110, 1001: ฟังก์ชันไบนารีพร้อมผลลัพธ์สองรายการจริง

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

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

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

ความคิดพื้นฐานคือการใช้การป้อนข้อมูลแรกที่จะตัดสินใจว่าการป้อนข้อมูลที่สองเลือกระหว่าง0และ1หรือระหว่างและ1 0ไปกันเถอะ0110ยกตัวอย่าง (XOR):

A = 0พิจารณา ในกรณีนี้เราต้องการส่งออกBตามที่เป็นอยู่ ,อ่านA, ?ไม่ทำอะไรเลย >ย้ายไปยังเซลล์ถัดไป (ไม่ใช่ศูนย์) เพื่อที่}จะนำเราไปสู่_บนชัค ที่นี่เราอ่านBด้วย,และใช้?อีกครั้ง ถ้าBเป็น0เช่นนั้นเรายังคงอยู่ในไบรอัน >ข้าม}Chuck และ?สวิตช์เพื่อ>.พิมพ์0ฝังในซอร์สโค้ดของ Brian หากBอยู่1ในมืออื่น ๆ ชัคจะรันสิ่ง}ที่ย้ายเข้าไป_ในรหัสของไบรอันแล้วดังนั้น>.จึงพิมพ์1-byte แทน

หากแล้วเราจะเปลี่ยนไปโยนทันทีที่จะดำเนินการA = 1 }+{>?สิ่งนี้จะย้ายไปที่_ซอร์สโค้ดของไบรอันเปลี่ยนเป็นให้1เป็นอย่างดีด้วย+จากนั้นย้ายกลับไปที่จุดเริ่มต้น{และข้ามไบรอัน?โดยการย้ายเซลล์หนึ่งไปทางขวาด้วย>ก่อนที่จะมอบการควบคุมกลับมาให้เขา เวลานี้หลังจากที่ไบรอันอ่านของBถ้าB = 0และชัคใช้>.เซลล์ที่อยู่ติดกับไบรอัน?จะเป็นแทน1 0ยิ่งไปกว่านั้นเมื่อB = 1ชัค}กระโดดข้ามสิ่งที่เคยเป็นช่องว่างและเลื่อนไปจนสุดปลายเทปเพื่อ>.พิมพ์เป็นศูนย์แทน not Bวิธีนี้เรากำลังพิมพ์

เพื่อที่จะใช้งานความเท่าเทียมกันเราเพียงแค่ปฏิเสธAก่อนที่จะใช้มันเป็นเงื่อนไข โปรดทราบว่าเนื่องจากสิ่งนี้เราต้องเพิ่มอีกตัว>ใน Chuck เพื่อข้ามไป-เช่นกันเมื่อย้ายกลับไปที่จุดเริ่มต้น

ClojureScript, 88 84 76 74 ไบต์

nilและfalseเป็นเท็จค่าอื่น ๆ ทั้งหมดเป็นความจริง บูลีนบีบบังคับให้ 0/1 สำหรับเลขคณิตและอสมการ ฟังก์ชันสามารถรับจำนวนอาร์กิวเมนต์ที่ไม่ถูกต้อง

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 ไบต์

อินพุต / เอาต์พุตใช้ U + 0000 และ U + 0001

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

Brain-Flak , 418 , 316 ไบต์

ลองออนไลน์!

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

false, 4 ไบต์ (ความอนุเคราะห์ของLeaky Nun )

(<>)

และ 36 ไบต์

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

A และไม่ใช่ B, 40 ไบต์

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

A, 6 ไบต์

({}<>)

ไม่ใช่ A และ B, 38 ไบต์

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

B, 2 ไบต์

{}

xor, 34 ไบต์

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

หรือ 6 ไบต์

({}{})

และ 34 ไบต์

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

xnor, 10 ไบต์

({}{}[()])

ไม่ใช่ B, 34 ไบต์

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

B หมายถึง A, 14 ไบต์

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

ไม่ใช่ A, 34 ไบต์

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

A หมายถึง B, 16 ไบต์

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

nand 12 ไบต์

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

จริง, 6 ไบต์

<>(())

คำอธิบาย

เนื่องจากสิ่งเหล่านี้ส่วนใหญ่คล้ายกันมากฉันจะไม่อธิบายอย่างชัดเจนถึงวิธีการทำงานของแต่ละคน ฉันพยายามทำให้ดีที่สุดเพื่อให้ชัดเจน แต่วิธีทั้งหมดสิบหกทำงาน

ประการแรกคือประตูที่คืนค่าสามค่าเดียวกัน (เช่น 2, 3, 5, 8, 9, 12, 14 และ 15) ทั้งหมดเหล่านี้เป็นไปตามรูปแบบเดียวกัน ก่อนอื่นคุณจะแปลงอินพุตเป็นตัวเลขสองบิตโดยใช้เป็นสองเท่าและ B แทนค่า สิ่งนี้ทำได้ด้วยตัวอย่าง(({}){}{})นี้ ({}[value])จากนั้นคุณลบค่าของการป้อนข้อมูลสองบิตที่คุณต้องการที่จะแยก (ในรหัสจริงการลบและการแปลงเสร็จในขั้นตอนเดียวเพื่อบันทึกไบต์) (({}<(())>)){{}{}(((<{}>)))}{}{}นี้สามารถใช้ร่วมกับไม่ถ้าจำเป็น:

ถัดไป: และ, หรือ, หรือ, xor, และ xnor งานเหล่านี้คล้ายกับรายการด้านบน ในความเป็นจริงสิ่งเหล่านี้มีอยู่ด้านบนอย่างไรก็ตามวิธีนี้สั้นกว่า เคล็ดลับที่ฉันใช้ที่นี่คือสิ่งเหล่านี้สอดคล้องกับผลรวมของ A B. เช่น xor ประเมินว่าเป็นจริงถ้า A + B = 1 และเท็จอย่างอื่น ขั้นแรกคุณเพิ่ม AB และลบจำนวนที่เกี่ยวข้อง ({}{}[0,1,2 or 3])แสดงเป็น จากนั้นหากจำเป็นต้องดำเนินการไม่

ถัดไป: A, B, ไม่ใช่ A และไม่ใช่ B เหล่านี้เป็นคำอธิบายที่ค่อนข้างชัดเจน เราเริ่มต้นด้วยการลบค่าที่ไม่จำเป็นออกไปจากนั้นก็ลบล้างหรือทำให้เสร็จ

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

ไม่ใช่ทางออกที่มีประสิทธิภาพมากที่สุด (อาจเป็น Brain-Flak ที่มีประสิทธิภาพมากที่สุด) แต่ฉันสนุกมากที่ได้เขียนสิ่งเหล่านี้และฉันขอร้องให้คุณลองย่อสิ่งเหล่านี้

ProgFk , 18.5 17.5 ไบต์

ตามที่ระบุไว้ในคำแนะนำของ ProgFk nibbles รหัสด้านล่างจะได้รับในเลขฐานสิบหกประตูตรรกะหนึ่งบรรทัดต่อบรรทัดและมีช่องว่างระหว่างไบต์

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

คำอธิบาย

ProgFkเป็นesolang ที่อิงกับเทป (คล้ายกับ Brainfuck) ซึ่งแต่ละเซลล์มีบิตและคำแนะนำจะได้รับเป็น nibbles (4 ไบต์) คำสั่งทำงานบนเซลล์ที่ชี้โดยตัวชี้คำสั่ง อินพุตถูกกำหนดในเซลล์แรกและเซลล์ที่สอง (โดยมีAและBเป็นเซลล์แรกและเซลล์ที่สองตามลำดับ) และตัวชี้คำสั่งจะเริ่มที่เซลล์แรก เอาต์พุตถูกเก็บไว้ในเซลล์แรก

คำสั่งที่ใช้แต่ละคำอธิบายไว้ด้านล่าง

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.

บันทึกเป็นไบต์ด้วย @LeakyNun!

ที่จริงแล้ว 24 ไบต์

โปรแกรมเหล่านี้รับอินพุตเป็นA\nB(โดย\nแสดงถึงบรรทัดใหม่) ซึ่งปล่อยให้ B อยู่ด้านบนของสแต็กโดยมี A ด้านล่าง Falseถูกแทนด้วย0และTrueแสดงด้วยจำนวนเต็มบวกใด ๆ

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

ขอบคุณ Leaky Nun นาน 3 ไบต์