Ví dụ, cổng A and Blà một cổng logic với 2 đầu vào và 1 đầu ra.

Có chính xác 16 người trong số họ, bởi vì:

• mỗi cổng logic có hai đầu vào, có thể là trung thực hoặc falsey, cung cấp cho chúng ta 4 đầu vào có thể
• trong số 4 đầu vào có thể, mỗi đầu vào có thể có đầu ra trung thực và chim ưng
• do đó, có 2 ^ 4 cổng logic có thể, là 16.

Nhiệm vụ của bạn là viết 16 chương trình / chức năng thực hiện tất cả chúng một cách riêng biệt.

Chức năng / chương trình của bạn phải độc lập .

Chúng có giá trị miễn là chúng tạo ra các giá trị trung thực / falsey, nghĩa là bạn có thể triển khai A or Btrong Python như lambda a,b:a+b, ngay cả khi 2được sản xuất cho A=Truevà B=True.

Điểm là tổng số byte được sử dụng cho từng chức năng / chương trình.

Danh sách cổng logic

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)

Trong đó số thứ nhất là đầu ra cho A=false, B=false, số thứ hai là đầu ra cho A=false, B=true, số thứ ba là đầu ra cho A=true, B=false, số thứ tư là đầu ra cho A=true, B=true.

Bảng xếp hạng

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>

Đô-mi-nô , 122.000 byte hoặc 72 gạch

Số đếm byte là kích thước của tập tin lưu đó là 0.122 MB.

Điện toán domino là nguồn cảm hứng. Tôi đã thử nghiệm tất cả những thứ này để đối xứng (và hơn thế nữa!) Thông qua một trò chơi Steam thực tế ảo có tên Tabletop Simulator .

Chi tiết

• Tôi / O
  • Bắt đầu - Điều này được bao gồm cho sự rõ ràng (không được tính vào tổng số) và là những gì 'gọi' hoặc 'thực thi' chức năng. Nên được 'nhấn' sau khi nhập liệu [Vàng] .
  • Đầu vào A - Điều này được bao gồm để rõ ràng (không được tính vào tổng số) và được 'nhấn' để chỉ ra a 1và không được nhấn khác [Xanh] .
  • Đầu vào B - Điều này được bao gồm để rõ ràng (không được tính vào tổng số) và được 'nhấn' để chỉ ra a 1và không được nhấn khác [Blue] .
  • Đầu ra - Điều này được tính vào tổng số. Đó là domino tuyên bố kết quả của cổng logic [Đen] .
• T / F
  • Một domino đầu ra giảm thể hiện kết quả của Truehoặc1
  • Một domino đầu ra đứng thể hiện kết quả của Falsehoặc0
• Nhấn
  • Để cung cấp đầu vào hoặc bắt đầu chuỗi, sinh ra đá cẩm thạch kim loại
  • Đặt cường độ nâng thành 100%
  • Nâng đá cẩm thạch lên trên domino mong muốn
  • Thả đá cẩm thạch

Cổng

• sai, 1
  • 
• và, 6 4
  • 
• A và không B, 4 3
  • 
• A, 1
  • 
• không phải A và B, 4 3
  • 
• B, 1
  • 
• xor, 15 11
  • 
• hoặc, 1
  • 
• cũng không, 3 2
  • 
• xnor, 17 13
  • 
• không phải B, 2
  • 
• B ngụ ý A, 7 6
  • 
• không phải A, 2
  • 
• A ngụ ý B, 7 6
  • 
• không, 16 15
  • 
  • đúng, 1
  • 

TL; DR

Tôi đã chờ đợi / muốn thử thách thân thiện với domino và khi tôi thấy điều này, tôi không thể vượt qua nó. Vấn đề duy nhất là dường như không còn ai sở hữu domino nữa! Vì vậy, cuối cùng tôi đã nhượng bộ và mua Double Tw 12 . Bộ này có 91 ô, cho tôi ý tưởng có một 'lệnh gọi hàm' / bắt đầu domino thay vì phương thức 'trì hoãn thời gian' thông thường (dài). Tín dụng cho lượt quay 90 độ thuộc về kênh dominoesdouble07 .

Sau khi xây dựng những thứ này với domino vật lý, người ta đã thống trị trên meta rằng các giải pháp hợp lệ phải là kỹ thuật số. Vì vậy, tôi đã tạo lại các cổng này trong Tabletop Simulator . Đáng buồn thay, TS và thực tế không đồng ý về vật lý domino. Điều này yêu cầu tôi thêm 11 domino nhưng tôi cũng đã lưu 8. Nhìn chung, domino ảo có hiệu quả hơn x150 về mặt xây dựng và thử nghiệm ( Ctrl+ Z).

Cập nhật

• -9 [17-03-13] Rút ngắnxor xnor nand
• [17-03-04] Đã thêm liên kết vào tệp hội thảo
• +11 [17-03-03] Đã thêm kỹ thuật số xnorvàxor
• -8 [17-03-03] Số hóa tất cả các cổng (ngoại trừ xorvà xnor). Chặn trên Tabletop chỉ cần 1 domino, thay vì 2.
• [16-09-23] Hình ảnh xấu
• -11 [16-09-18] Gần như cắt xor lại một nửa. Cảm ơn @DJMcMayhem cho xnor và Joe cho xor.
• -31 [16-08-31] Cập nhật một số bức ảnh và cạo một số gạch và cắt xor làm đôi
• [16-08-28] Đã thêm hình ảnh

Lục giác , 89 byte

Cảm ơn FryAmTheEggman vì một số nguồn cảm hứng cần thiết cho giải pháp XOR.

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

Tất cả các chương trình sử dụng 0cho sai và 1đúng.

Hãy thử trực tuyến! Đây không phải là bộ thử nghiệm, bạn sẽ phải sao chép trong các chương trình khác nhau và tự nhập liệu.

Giải pháp trên nằm trong phạm vi 2 byte tối ưu (trừ khi chúng ta thư giãn cách giải thích trung thực / giả dối, tôi đoán vậy). Tôi đã để một cuộc tìm kiếm vũ phu kéo dài gần hai ngày trên tất cả các chương trình phù hợp với độ dài 2 bên, tức là tối đa 7 byte (không hoàn toàn là tất cả các chương trình - Tôi đã đưa ra một vài giả định về mọi chương trình hợp lệ cần và không có gì chương trình hợp lệ có thể có). Tìm kiếm đã tìm thấy giải pháp cho 15 trong số 16 cổng có thể - và thường là nhiều hơn chỉ một. Bạn có thể tìm thấy một danh sách tất cả các giải pháp thay thế trong pastebin này , nơi tôi cũng đã nhóm chúng theo hành vi tương đương. Những giải pháp tôi đang trình bày ở trên tôi đã chọn vì chúng là giải pháp đơn giản nhất hoặc thú vị nhất và tôi sẽ thêm giải thích cho chúng vào ngày mai.

Đối với cổng thứ 16: XOR là cổng duy nhất dường như không thể được thực hiện trong 7 byte. Rất tiếc, một tìm kiếm vũ phu trên các chương trình lớn hơn là không khả thi với mã tôi hiện có. Vì vậy, XOR phải được viết bằng tay. Đoạn ngắn nhất tôi tìm thấy cho đến nay là chương trình 10 byte ở trên, dựa trên nỗ lực thất bại (nhưng rất gần) của FryAmTheEggman. Có thể tồn tại một giải pháp 8 byte hoặc 9 byte, nhưng ngoài ra, tất cả các giải pháp đó thực sự phải là tối ưu.

Giải thích

Cảnh báo: tường văn bản. Nếu không có ai quan tâm đến việc các chương trình Hexagony được nén thực sự này hoạt động như thế nào, tôi đã bao gồm các giải thích cho từng chương trình dưới đây. Tôi đã cố gắng chọn giải pháp đơn giản nhất cho mỗi cổng trong trường hợp có nhiều chương trình tối ưu tồn tại, để giữ cho các giải thích ngắn gọn hợp lý. Tuy nhiên, một số người trong số họ vẫn làm hỏng tâm trí, vì vậy tôi nghĩ rằng họ xứng đáng được trau chuốt hơn một chút.

0000: Sai trái

Tôi không nghĩ rằng chúng ta sẽ cần một sơ đồ cho cái này:

 ! @
. . .
 . .

Vì toàn bộ lưới bộ nhớ được khởi tạo thành số không, !chỉ cần in số 0 và @kết thúc chương trình.

Đây cũng là giải pháp 2 byte duy nhất.

0001: Và

 ? .
| @ !
 . .

Điều này về cơ bản thực hiện ngắn mạch . Biểu đồ màu xám bên dưới hiển thị phần đầu của chương trình, trong đó đầu vào đầu tiên được đọc ?và con trỏ lệnh (IP) quấn quanh góc bên trái nơi |gương phản chiếu nó. Bây giờ góc hoạt động như một điều kiện, như vậy có hai đường dẫn thực thi khác nhau tùy thuộc vào giá trị của đầu vào đầu tiên. Biểu đồ màu đỏ hiển thị luồng điều khiển cho A = 0và sơ đồ màu xanh lá cây cho A = 1:

Như bạn có thể thấy, khi Acó 0, chúng ta chỉ cần in nó và chấm dứt (hãy nhớ rằng tất cả .đều là no-op). Nhưng khi Alà 1, sau đó IP đi qua dòng đầu tiên một lần nữa, đọc Bvà in ấn mà thay thế.

Tổng cộng có mười sáu giải pháp 5 byte cho cổng này. Mười bốn trong số đó về cơ bản giống như ở trên, sử dụng >thay thế |hoặc thay thế .bằng một lệnh có hiệu quả là không hoạt động, hoặc đặt ?ở vị trí thứ hai:

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

Và sau đó, có hai giải pháp khác (tương đương với nhau). Những điều này cũng thực hiện logic ngắn mạch tương tự, nhưng các đường dẫn thực hiện hơi điên rồ hơn (và để lại như một bài tập cho người đọc):

?<!@|
?<!@<

0010: A và không B

 # ?
# ! )
 @ .

Điều này cũng thực hiện một hình thức ngắn mạch, nhưng do việc sử dụng #dòng điều khiển phức tạp hơn nhiều. #là một chuyển đổi IP có điều kiện. Hexagony thực sự đến với sáu IP được dán nhãn 0để 5, mà bắt đầu trong vòng sáu góc của lưới điện, chỉ dọc theo cạnh chiều kim đồng hồ của họ (và chương trình luôn bắt đầu với IP 0). Khi #gặp a, giá trị hiện tại được lấy modulo 6và luồng điều khiển tiếp tục với IP tương ứng. Tôi không chắc sự điên rồ nào đã khiến tôi thêm tính năng này, nhưng chắc chắn nó cho phép một số chương trình đáng ngạc nhiên (như chương trình này).

Chúng tôi sẽ phân biệt ba trường hợp. Khi A = 0đó, chương trình khá đơn giản, bởi vì giá trị luôn luôn là 0khi #bắt gặp như vậy mà không IP chuyển đổi diễn ra:

#không làm gì, ?đọc A(tức là cũng không làm gì), #vẫn không làm gì, !in 0, )tăng nó (điều này rất quan trọng, nếu không IP sẽ không nhảy sang dòng thứ ba), @chấm dứt chương trình. Đủ đơn giản. Bây giờ hãy xem xét trường hợp (A, B) = (1, 0):

Đường dẫn màu đỏ vẫn tương ứng với IP 0và tôi đã thêm đường dẫn màu xanh cho IP 1. Chúng tôi thấy rằng sau khi ?đọc A( 1lần này), các #công tắc chuyển sang IP bắt đầu ở góc trên cùng bên phải. Điều đó có nghĩa là ?có thể đọc B( 0). Bây giờ )gia tăng đến mức 1, #ở góc trên bên trái không làm gì cả và chúng tôi vẫn giữ nguyên IP 1. Các !bản in 1và IP bao quanh đường chéo trái. #vẫn không làm gì và @chấm dứt chương trình.

Cuối cùng, trường hợp thực sự kỳ lạ khi cả hai đầu vào là 1:

Lần này, đầu vào thứ hai cũng 1và )tăng nó lên 2. Điều đó có nghĩa là #ở góc trên cùng bên trái khiến một IP khác chuyển sang IP 2, biểu thị bằng màu xanh lam. Trên con đường đó, trước tiên chúng tôi tăng nó hơn nữa 3(mặc dù điều đó không liên quan) và sau đó vượt qua ?lần thứ ba. Vì hiện tại chúng tôi đã nhấn EOF (tức là đầu vào đã hết), ?trả về 0, !in ra và @kết thúc chương trình.

Đáng chú ý, đây là giải pháp 6 byte duy nhất cho cổng này.

0011: A

 ? !
@ . .
 . .

Điều này đủ đơn giản để chúng ta không cần một sơ đồ: ?đọc A, !in nó, @chấm dứt.

Đây là giải pháp 3 byte duy nhất cho cổng này. (Về nguyên tắc, điều đó cũng có thể thực hiện được ,;@, nhưng tìm kiếm không bao gồm ;, vì tôi không nghĩ nó có thể tiết kiệm byte !cho nhiệm vụ này.)

0100: B chứ không phải A

 + ?
| @ !
 ? .

Cái này đơn giản hơn nhiều so với "anh trai" của nó 0010. Luồng điều khiển thực sự giống như chúng ta đã thấy ở trên cho 0001(Và). Nếu A = 0, sau đó IP đi qua dòng dưới, đọc Bvà in trước khi kết thúc. Nếu A = 1sau đó IP đi qua dòng đầu tiên, cũng đọc B, nhưng +thêm hai cạnh bộ nhớ không sử dụng để tất cả những gì nó làm là đặt lại giá trị hiện tại thành 0, để !luôn luôn in 0.

Có khá nhiều lựa chọn thay thế 6 byte cho điều này (tổng cộng 42). Đầu tiên, có rất nhiều giải pháp tương đương như trên. Chúng ta lại có thể chọn tự do giữa |và >, và +có thể được thay thế bằng bất kỳ lệnh nào khác mang lại cho chúng ta một cạnh trống:

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

Ngoài ra, chúng tôi cũng có thể sử dụng ]thay vì ?. ]di chuyển đến IP tiếp theo (tức là chọn IP 1), để chi nhánh này thay vào đó sử dụng lại ?ở góc trên cùng bên phải. Điều đó mang lại cho 18 giải pháp khác:

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

Và sau đó, có sáu giải pháp khác mà tất cả đều hoạt động khác nhau với mức độ điên rồ khác nhau:

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

0101: B

 ? ?
! @ .
 . .

Woohoo, một cách đơn giản khác: đọc A, đọc B, in B, chấm dứt. Thực tế có những lựa chọn thay thế cho điều này. Vì Achỉ là một ký tự duy nhất, chúng ta cũng có thể đọc nó với ,:

,?!@

Và cũng có tùy chọn sử dụng một chiếc ?và sử dụng gương để chạy qua nó hai lần:

?|@!    ?>@!

0110: Xor

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

Như tôi đã nói ở trên, đây là cổng duy nhất không phù hợp với chiều dài 2, vì vậy đây là giải pháp viết tay của FryAmTheEggman và tôi, và rất có khả năng nó không tối ưu. Có hai trường hợp để phân biệt. Nếu A = 0luồng điều khiển khá đơn giản (vì trong trường hợp đó chúng ta chỉ cần in B):

Chúng tôi bắt đầu trên con đường màu đỏ. ?đọc A, <là một nhánh làm lệch hướng 0 bên trái. IP kết thúc ở phía dưới, sau đó _là một gương khác và khi IP chạm vào góc, nó sẽ nằm ở góc trên cùng bên trái và tiếp tục trên đường dẫn màu xanh. ?đọc B, !in nó Bây giờ (giảm nó. Đây là quan trọng vì nó đảm bảo rằng giá trị là không tích cực (nó là một trong hai 0hoặc -1bây giờ). Điều đó làm cho IP bọc đến góc bên phải, nơi @kết thúc chương trình.

Khi A = 1mọi thứ trở nên phức tạp hơn một chút. Trong trường hợp đó, chúng tôi muốn in not B, bản thân nó không quá khó, nhưng đường dẫn thực hiện hơi nhanh.

Lần này, <làm lệch hướng quyền IP và tiếp theo <chỉ hoạt động như một tấm gương. Vì vậy, IP đi qua cùng một đường dẫn ngược lại, đọc Bkhi gặp ?lại. IP kết thúc ở góc bên phải và tiếp tục trên đường dẫn màu xanh lá cây. Nó gặp gỡ tiếp theo (~đó là "sụt lần, nhân với -1", trong đó giao dịch hoán đổi 0và 1và do đó tính not B. \chỉ là một tấm gương và !in kết quả mong muốn. Sau đó ?cố gắng trả về một số khác nhưng trả về số không. IP bây giờ tiếp tục ở góc dưới bên trái trên đường dẫn màu xanh. (giảm, <phản ánh,(giảm lần nữa, để giá trị hiện tại là âm khi IP chạm vào góc. Nó di chuyển qua đường chéo bên phải phía dưới và sau đó nhấn @để kết thúc chương trình.

0111: Hoặc là

 ? <
< @ !
 . .

Ngắn mạch hơn.

Các A = 0trường hợp (đường màu đỏ) là một chút bối rối ở đây. IP bị lệch về bên trái, kết thúc ở góc dưới bên trái, ngay lập tức được phản ánh bởi <và quay trở lại ?để đọc B. Sau đó nó sẽ kết thúc tốt đẹp vào góc rigt, in Bvới !và kết thúc.

Các A = 1trường hợp (đường màu xanh lá cây) là một chút đơn giản hơn. Các <chi nhánh lệch IP đúng, vì vậy chúng tôi chỉ đơn giản là in !, quấn lại phía trên bên trái, và chấm dứt tại @.

Chỉ có một giải pháp 5 byte khác:

\>?@!

Nó hoạt động về cơ bản giống nhau, nhưng các đường dẫn thực thi thực tế khá khác nhau và nó sử dụng một góc để phân nhánh thay vì a <.

1000: Cũng không

 ) \
! # ?
 @ {

Đây có thể là chương trình yêu thích của tôi được tìm thấy trong tìm kiếm này. Điều thú vị nhất là việc triển khai này thực norsự hoạt động với tối đa 5 đầu vào. Tôi sẽ phải tìm hiểu chi tiết về mô hình bộ nhớ một chút để giải thích điều này. Vì vậy, khi làm mới nhanh, mô hình bộ nhớ của Hexagony là một lưới hình lục giác riêng biệt, trong đó mỗi cạnh chứa một giá trị nguyên (ban đầu đều bằng 0). Có một con trỏ bộ nhớ (MP) chỉ ra một cạnh và một hướng dọc theo cạnh đó (sao cho có hai cạnh lân cận phía trước và phía sau cạnh hiện tại, với các hàng xóm bên trái và bên phải có ý nghĩa). Dưới đây là sơ đồ các cạnh chúng ta sẽ sử dụng, với MP bắt đầu như màu đỏ:

Trước tiên chúng ta hãy xem xét trường hợp cả hai đầu vào là 0:

Chúng ta bắt đầu trên con đường màu xám, mà chỉ đơn giản increments cạnh Một để 1sao cho #chuyển sang IP 1đó là con đường màu xanh, bắt đầu ở góc trên bên phải. \không có gì ở đó và ?đọc một đầu vào. Chúng tôi bọc đến góc trên cùng bên trái, nơi )gia tăng đầu vào đó. Bây giờ miễn là đầu vào bằng không, điều này sẽ dẫn đến một 1, do đó #không làm gì cả. Sau đó {di chuyển MP ở phía bên trái, tức là trên phiên đầu tiên từ A đến B . Vì cạnh này vẫn có số 0 ban đầu, IP kết thúc trở lại góc trên cùng bên phải và trên cạnh bộ nhớ mới. Vì vậy, vòng lặp này sẽ tiếp tục miễn là ?đọc số không, di chuyển MP xung quanh hình lục giác từ Bđến C đến D và cứ thế. Không quan trọng là ?trả về 0 vì nó là đầu vào hay vì đó là EOF.

Sau sáu lần lặp thông qua vòng lặp này, {trở về Một . Lần này, cạnh đã giữ giá trị 1từ lần lặp đầu tiên, do đó, IP kết thúc ở góc bên trái và tiếp tục trên đường dẫn màu xanh lá cây thay thế. !chỉ cần in nó 1và @chấm dứt chương trình.

Bây giờ nếu có bất kỳ đầu vào là 1gì?

Sau đó ?đọc nó 1tại một số điểm và )tăng nó lên 2. Điều đó có nghĩa là #bây giờ sẽ chuyển đổi IP một lần nữa và chúng tôi sẽ tiếp tục ở góc bên phải trên đường dẫn màu đỏ. ?đọc một đầu vào khác (nếu có), điều này không thực sự quan trọng và {di chuyển một cạnh hơn nữa. Đây phải là một cạnh không được sử dụng, do đó, nó hoạt động cho tối đa 5 đầu vào. IP kết thúc ở phía trên bên phải, nơi nó được phản ánh ngay lập tức và kết thúc ở góc bên trái. !in 0trên cạnh không sử dụng và #chuyển trở lại IP 0. IP đó vẫn đang chờ đợi trên đường #, đi về phía tây nam (đường dẫn màu xám), vì vậy nó ngay lập tức chạm vào @và chấm dứt chương trình.

Tổng cộng có bảy giải pháp 7 byte cho cổng này. 5 trong số chúng hoạt động tương tự như thế này và chỉ cần sử dụng các lệnh khác để di chuyển đến một cạnh không được sử dụng (và có thể đi xung quanh một hình lục giác khác hoặc theo một hướng khác):

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

Và có một loại giải pháp khác chỉ hoạt động với hai đầu vào, nhưng đường dẫn thực thi của chúng thậm chí còn lộn xộn hơn:

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

1001: Bình đẳng

 ( ~
? / @
 # !

Điều này cũng làm cho việc sử dụng rất thông minh của lựa chọn IP có điều kiện. Chúng ta cần phân biệt lại giữa A = 0và A = 1. Trong trường hợp đầu tiên chúng tôi muốn in not B, trong lần thứ hai chúng tôi muốn in B. Đối với A = 0chúng tôi cũng phân biệt hai trường hợp cho B. Hãy bắt đầu với A = B = 0:

Chúng tôi bắt đầu trên con đường màu xám. (~có thể bỏ qua, IP kết thúc ở góc bên trái (vẫn trên đường dẫn màu xám) và đọc Avới ?. (giảm số đó, vì vậy chúng tôi nhận được -1và bọc IP ở góc dưới bên trái. Bây giờ như tôi đã nói trước đó, #lấy giá trị modulo 6trước khi chọn IP, do đó, giá trị -1thực sự thoát ra IP 5, bắt đầu ở góc bên trái trên đường dẫn màu đỏ. ?đọc B, (giảm dần để chúng ta vẫn ở trên IP 5khi chúng ta nhấn #lại. ~phủ định -1để IP kết thúc ở góc dưới bên phải, in 1và chấm dứt.

Bây giờ nếu Blà 1thay vào đó, giá trị hiện tại sẽ là 0khi chúng ta nhấn #lần thứ hai, vì vậy chúng tôi chuyển về IP 0(nay trên con đường màu xanh lá cây). Điều đó đánh lần ?thứ ba, mang lại 0, !in nó và @chấm dứt.

Cuối cùng, trường hợp A = 1. Lần này, giá trị hiện tại đã bằng không khi chúng ta nhấn #lần đầu tiên, vì vậy điều này không bao giờ chuyển sang IP 5ở vị trí đầu tiên. Chúng tôi chỉ đơn giản là tiếp tục ngay lập tức trên con đường màu xanh lá cây. ?bây giờ không chỉ đưa ra số 0 mà Bthay vào đó trả về . !in nó và @chấm dứt một lần nữa.

Tổng cộng có ba giải pháp 7 byte cho cổng này. Hai cái còn lại hoạt động rất khác nhau (thậm chí là của nhau), và làm cho việc sử dụng thậm chí còn lạ hơn #. Cụ thể, họ đọc một hoặc nhiều giá trị với ,(đọc mã ký tự thay vì số nguyên) và sau đó sử dụng giá trị đó modulo 6 để chọn IP. Đó là các loại hạt đẹp.

),)#?@!

?~#,~!@

1010: Không phải B

 ? ?
| @ !
 ) .

Cái này khá đơn giản. Đường dẫn thực thi là nhánh ngang mà chúng ta đã biết từ andtrước đó. ??Đọc Arồi ngay lập tức B. Sau khi phản ánh tại |và phân nhánh, B = 0chúng ta sẽ thực hiện nhánh dưới cùng, trong đó )tăng giá trị 1mà sau đó được in bằng !. Trên nhánh trên cùng (nếu B = 1), ?chỉ cần đặt lại cạnh 0mà sau đó cũng được in bằng !.

Có tám chương trình 6 byte cho cổng này. Bốn trong số chúng khá giống nhau, sử dụng >thay vì |hoặc 1thay vì )(hoặc cả hai):

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

Hai sử dụng một lần ?được sử dụng hai lần do một tấm gương. Việc phủ định sau đó xảy ra như chúng ta đã làm xorvới một trong hai (~hoặc ~).

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

Và cuối cùng, hai giải pháp sử dụng một chuyển đổi IP có điều kiện, bởi vì tại sao sử dụng cách đơn giản nếu một giải pháp phức tạp cũng hoạt động:

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

1011: B ngụ ý A

 \ #
? ? !
 1 @

Điều này sử dụng một số chuyển đổi IP khá phức tạp. A = 1Lần này tôi sẽ bắt đầu với trường hợp này, vì nó đơn giản hơn:

Chúng ta bắt đầu trên con đường màu xám, mà đọc Avới ?và sau đó chạm #. Vì điều này Alà 1chuyển sang IP 1(đường dẫn màu xanh lá cây). Các !ngay lập tức in đó, IP kết thúc tốt đẹp để phía trên bên trái, đọc B(không cần thiết) và kết thúc.

Khi A = 0mọi thứ trở nên thú vị hơn một chút. Trước tiên hãy xem xét A = B = 0:

Lần này, #không có gì và chúng tôi vẫn ở trên IP 0(đường dẫn màu đỏ từ thời điểm đó trở đi). ?đọc Bvà 1biến nó thành a 1. Sau khi gói vào góc trên cùng bên trái, chúng tôi #lại nhấn , vì vậy cuối cùng chúng tôi sẽ đi trên con đường màu xanh lá cây và in 1như trước, trước khi chấm dứt.

Cuối cùng, đây là (A, B) = (0, 1)trường hợp sai:

Lưu ý rằng tôi đã xóa đường dẫn màu xám ban đầu cho rõ ràng, nhưng chương trình bắt đầu theo cùng một cách và chúng tôi kết thúc trên đường dẫn màu đỏ như trước. Vì vậy, lần này lần thứ hai ?trở lại 1. Bây giờ chúng ta bắt gặp 1. Tại thời điểm này, điều quan trọng là phải hiểu các chữ số thực sự làm gì trong Hexagony (cho đến nay chúng ta chỉ sử dụng chúng trên các số 0): khi gặp một chữ số, giá trị hiện tại được nhân với 10 và sau đó chữ số được thêm vào. Điều này thường được sử dụng để viết các số thập phân nguyên văn vào mã nguồn, nhưng nó có nghĩa là nó B = 1thực sự được ánh xạ tới giá trị 11. Vì vậy, khi chúng tôi nhấn #, điều này được lấy modulo 6để cung cấp 5và do đó chúng tôi chuyển sang IP 5(thay vì 1như trước đây) và tiếp tục trên con đường màu xanh. Đánh?lần thứ ba trả về số 0, do đó !in ra và sau hai lần khác ?, IP kết thúc ở phía dưới bên phải nơi chương trình kết thúc.

Có bốn giải pháp 7 byte cho vấn đề này và tất cả chúng đều hoạt động khác nhau:

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

1100: Không phải A

 ? (
~ ! @
 . .

Chỉ là một tuyến tính đơn giản: đọc Avới ?, phủ định với (~, in với !, chấm dứt với @.

Có một giải pháp thay thế và ~)thay vào đó là phủ nhận :

?~)!@

1101: A ngụ ý B

 ? .
| @ !
 ) .

Điều này đơn giản hơn rất nhiều so với hàm ý ngược lại mà chúng ta vừa nói đến. Đây lại là một trong những chương trình nhánh ngang, giống như chương trình dành cho and. Nếu Acó 0, nó chỉ đơn giản là được tăng lên 1trên nhánh dưới cùng và được in. Mặt khác, nhánh trên cùng được thực hiện lại trong đó ?đọc Bvà sau đó !in nó.

Có một tấn lựa chọn thay thế ở đây (66 giải pháp trong tổng số), chủ yếu là do tự do lựa chọn hiệu quả không-ops. Để bắt đầu, chúng tôi có thể thay đổi giải pháp trên theo tất cả các cách tương tự có thể andvà chúng tôi cũng có thể chọn giữa )và 1:

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

Và sau đó, có một phiên bản khác sử dụng lựa chọn IP có điều kiện, trong đó lệnh đầu tiên có thể được chọn gần như tùy ý và cũng có một lựa chọn giữa )và 1cho một số tùy chọn sau:

"?#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: Không

 ? $
@ # )
 ! <

Cái phức tạp cuối cùng. Nếu bạn vẫn đang đọc, bạn gần như đã làm được. :) Trước A = 0tiên hãy xem :

?đọc Arồi ta đánh $. Đây là lệnh nhảy (như Befunge's #) bỏ qua hướng dẫn tiếp theo để chúng tôi không chấm dứt @. Thay vào đó, IP tiếp tục tại #. Tuy nhiên kể từ khi Alà 0, điều này không làm gì cả. )tăng nó lên 1để IP tiếp tục trên đường dẫn phía dưới nơi 1in. Các <lệch IP ở bên phải, nơi nó kết thúc tốt đẹp vào góc trái và chương trình chấm dứt.

Tiếp theo, khi đầu vào là (A, B) = (1, 0)chúng ta gặp tình huống này:

Đó là về cơ bản giống như trước đây ngoại trừ việc tại #chúng tôi chuyển sang IP 1(đường màu xanh lá cây), nhưng vì Blà 0chúng tôi chuyển về IP 0khi chúng ta nhấn #một lần thứ hai (con đường hiện nay màu xanh), nơi nó in 1như trước đây.

Cuối cùng, A = B = 1trường hợp:

Lần này, khi chúng tôi #lần thứ hai, giá trị hiện tại vẫn còn 1để chúng tôi không thay đổi IP lần nữa. Phản <ánh nó và lần thứ ba chúng tôi đạt ?được số không. Do đó, IP kết thúc ở phía dưới bên trái nơi !in số 0 và chương trình kết thúc.

Có chín giải pháp 7 byte trong tổng số này. Thay thế đầu tiên chỉ đơn giản là sử dụng 1thay vì ):

?$@#1!<

Sau đó, có hai giải pháp giúp bạn thực hiện với số lượng chuyển đổi IP đang diễn ra:

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

Những điều này thực sự đã thổi vào tâm trí tôi: phần thú vị là chuyển mạch IP có thể được sử dụng như một điều kiện hoãn lại. Các quy tắc chuyển đổi IP của ngôn ngữ sao cho IP hiện tại thực hiện một bước nữa trước khi chuyển đổi xảy ra. Nếu bước đó xảy ra để đi qua một góc, thì giá trị hiện tại sẽ quyết định IP nào sẽ tiếp tục nếu chúng ta chuyển trở lại nó. Chính xác điều này xảy ra khi đầu vào là A = B = 1. Mặc dù điều này hoàn toàn phù hợp với cách tôi thiết kế ngôn ngữ, tôi chưa bao giờ nhận thức được ý nghĩa này của thông số kỹ thuật, vì vậy thật tuyệt khi ngôn ngữ của tôi dạy cho tôi một số thủ thuật mới: D.

Sau đó, có một giải pháp thứ ba có số lượng chuyển đổi IP thậm chí còn tệ hơn (mặc dù nó không sử dụng hiệu ứng có điều kiện bị trì hoãn đó):

>?1]#!@

Và sau đó có một cái khác:

?$@#)!<

Và sau đó có bốn giải pháp tương đương, sử dụng một số chuyển mạch IP không có điều kiện và thay vào đó thực hiện tất cả logic thông qua các nhánh và góc:

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

1111: Thật

 1 !
@ . .
 . .

Bạn đã kiếm được cho mình một thứ đơn giản cho đến cuối: đặt cạnh 1, in bằng !, chấm dứt với @. :)

Tất nhiên, có một lựa chọn thay thế:

)!@

Như thường lệ, tất cả các sơ đồ luồng điều khiển được tạo bằng HexagonyColorer của Timwi's và sơ đồ bộ nhớ với EsotericIDE của anh ấy .

APL, 22 20 18 byte

Các mục đúng và sai là các chương trình hoàn chỉnh và 14 mục còn lại là các hàm. (Cảm ơn 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)

Hãy thử nó ở đây.

Cờ vua / người chơi cờ tầm thường trong trò chơi cuối, 70 quân cờ

Lấy cảm hứng từ câu trả lời domino đó, tôi quyết định một trò chơi khác nên có vinh dự này.

Lưu ý rằng tôi đã lấy một vài quy tắc cho cách các mảnh di chuyển. Bởi vì tôi không muốn nghiên cứu các động tác tối ưu cho mọi tình huống, nên các quy tắc cho người da trắng di chuyển rất đơn giản: Tránh xa tầm kiểm soát, nắm bắt thứ hạng cao nhất mà anh ta có thể quay đầu, trong khi mất ít tài liệu nhất có thể và ngừng cầm đồ từ việc thúc đẩy, theo thứ tự ưu tiên đó. Nếu có hai không gian anh ta có thể di chuyển đến, với độ linh hoạt bằng nhau, anh ta có thể di chuyển đến một trong hai (do đó, nếu anh ta có thể di chuyển đến nhiều hơn một hình vuông, chúng có cùng màu). Lưu ý rằng màu trắng sẽ chụp với một cái gì đó ngay cả khi nó bị bắt, nếu mảnh mà nó đang tấn công có giá trị cao hơn cái bị mất. Các giá trị ở đây:pawn<knight=bishop<rook<queen

Đầu vào là một rook có mặt hay không. Lưu ý rằng các rooks chỉ được gắn nhãn với tên A và B khi có vấn đề: nếu cổng hoạt động giống nhau khi các rooks được chuyển đổi, chúng không được dán nhãn.

Đầu ra là màu của vua trắng vuông kết thúc vào: Trắng = 1, đen = 0

Trước những hình ảnh, tôi muốn xin lỗi vì những hình ảnh nghèo nàn. Tôi không giỏi cầm máy ảnh ổn định.

Sai, 4:

VÀ, 4:

A và không phải B, 5 (Tôi nghĩ rằng tôi có thể giảm xuống còn ba, nhưng không có bảng ngay bây giờ):

A, 4:

Không phải A và B, 5 (Tôi nghĩ rằng tôi có thể giảm xuống còn ba, nhưng không có bảng ngay bây giờ):

B 4:

Xor, 5 (Tôi biết một cách để làm cho nó 4, nhưng tôi không có bảng ngay bây giờ):

Hoặc, 4:

Cũng không, 4:

Xnor, 5 (Tôi biết một cách để làm cho nó 4, nhưng tôi không có bảng ngay bây giờ):

Không phải B, 4:

B ngụ ý A, 5 (Tôi nghĩ rằng tôi có thể giảm xuống còn ba, nhưng không có bảng ngay bây giờ):

Không phải A, 4:

A ngụ ý B, 5 (Tôi nghĩ rằng tôi có thể giảm xuống còn ba, nhưng không có bảng ngay bây giờ):

Không, 4:

Đúng, 4:

Thạch , 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.

Hãy thử trực tuyến!

Cổng logic NAND - 31 cổng

Như tác giả của gốc loạt của NAND cổng câu hỏi , tôi không thể bỏ qua cơ hội để sử dụng các cổng để giải quyết một vấn đề cổng logic.

Trong mỗi sơ đồ này, đầu vào trên cùng là A trong khi đầu vào dưới cùng là B.

Thẻ tuần hoàn bitwise , 118 bit = 14,75 byte

Bitwise Cyclic Tag có lẽ là ngôn ngữ hoàn chỉnh Turing đơn giản nhất từng được phát minh. Có một băng chương trình và một băng dữ liệu, cả hai đều bao gồm một danh sách các bit. Băng chương trình được diễn giải theo chu kỳ cho đến khi băng dữ liệu trống, như sau:

• 0: xóa bit đầu tiên khỏi băng dữ liệu.
• 1x: nếu bit đầu tiên của băng dữ liệu là 1, hãy nối bit đó xvào băng dữ liệu.

Chúng tôi khởi tạo băng dữ liệu bằng 1 theo sau là hai bit đầu vào (1 là cần thiết vì không có cách nào để tạo 1 nếu băng dữ liệu hoàn toàn bằng 0) và chúng tôi sử dụng bit dữ liệu bị xóa cuối cùng làm đầu ra của cổng .

• 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

Đưa đầu vào như min(True,False)(hoặc như min(1,0)). Có lợi thế lớn về đầu ra chỉ cần có giá trị Truthy-Falsey đúng. Bất cứ khi nào có thể, sử dụng tích hợp để tránh tốn kém lambda. Tôi đã sử dụng mã để tìm kiếm tích hợp sẵn.

Yêu thích của tôi là {0:1}.get, mà tôi nghĩ bằng tay. Từ điển {0:1}ánh xạ khóa 0đến giá trị 1. getPhương thức của nó lấy một khóa và một mặc định, xuất ra giá trị khớp với khóa hoặc mặc định nếu không có khóa đó. Vì vậy, cách duy nhất để xuất a 0là {0:1}.get(1,0), thiếu khóa 1và mặc định 0. Người ta có thể có các biến thể khác với các từ điển khác nhau, nhưng chỉ có biến thể này là ngắn nhất.

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]

Đi (trò chơi), 33 hòn đá, 73 ngã tư

Nếu domino và cờ vua được chấp nhận, thì đây. Nó không thể quá golf trên một bảng 19x19 Go đầy đủ. Vì vậy, tôi đã sử dụng bảng hình chữ nhật nhỏ. Đầu vào là liệu những viên đá được đánh dấu 1 và 2 có mặt hay không. Đầu ra là liệu màu đen thắng. Nó sử dụng tính điểm theo khu vực, 0,5 komi, superko tình huống, không tự sát. Tất cả màu đen để chơi. Một số được đưa ra nhiều giải pháp.

Trắng thắng (2, 1x5):

➊━━━➋

1 và 2 (3, 2x3):

➊◯➋
┗┷┛

1 chứ không phải 2 (2, 1x5):

╺➊━➁╸

1 (2, 1x5):

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

Không phải 1 và 2 (2, 1x5):

╺➋━➀╸

2 (2, 1x5):

╺➋➀━╸

1 x 2 (2, 2x3):

➀┯➁
┗┷┛

1 hoặc 2 (2, 1x5):

╺➊━➋╸
➀━━━➁

1 cũng không 2 (2, 1x4):

➊━━➋
╺➀➁╸

1 = 2 (2, 1x7):

╺━➀━➁━╸

Không phải 2 (2, 1x3):

➀➁╸

1 hoặc không 2 (2, 1x4):

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

Không phải 1 (2, 1x3)

➁➀╸

Không phải 1 hoặc 2 (2, 1x4):

➁➀━╸

1 và 2 (2, 1x3):

➊━➋

Đen thắng (2, 1x3):

➊➋╸
➀━➁
➊━➁

Trang này đã giúp tôi một chút: http : //www.mathpuheads.com/go.html

Có lẽ ai đó có thể tìm thấy một giải pháp 2 đá cho 1 và 2 trên bảng 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

Tôi thực sự ghét lambdas ngay bây giờ.

Võng mạc , 62 39 byte

23 byte nhờ @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: 

Đưa đầu vào là PQ.

Xuất ra một số nguyên giữa 0đến 3. 0là falsey, những người khác là sự thật.

Giải trình

Tất cả chúng chỉ là regexes .

Ví dụ, 01|10chỉ phù hợp 01hoặc 10.

Trong 0000, 2sẽ không bao giờ có trong đầu vào, vì vậy nó không bao giờ khớp.

Trong 1111, nó phù hợp với chuỗi trống, có 4.

Mèo xếp chồng , 67 + 64 = 131 byte

Lưu ý rằng +64 là từ việc áp dụng các -nmcờ cho mỗi chương trình. -nbiểu thị I / O dạng số và -mphản chiếu mã nguồn qua ký tự cuối cùng - không phải tất cả các lần gửi đều cần các cờ này về mặt kỹ thuật, nhưng để thống nhất và đơn giản, tôi sẽ chấm điểm chúng theo cùng một cách.

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

()trong Stack Mèo kiểm tra xem một phần tử là dương hay không có chủ đích (nghĩa là 0 hoặc âm), vì vậy chúng tôi đang sử dụng phần tử đó cho sự thật / giả mạo tương ứng. Cột thứ hai chỉ dành cho sở thích và liệt kê các cổng tốt nhất có 0/ 1s làm đầu ra (với tổng số điểm 90).

Đầu vào là các bit được phân tách bằng dấu phân cách thông qua STDIN. Hãy thử trực tuyến!

Stack Mèo là một ngôn ngữ bí truyền đảo ngược, nơi các chương trình có sự đối xứng phản chiếu. Đưa ra một đoạn f(ví dụ >[[(!-)/), hình ảnh phản chiếu (ví dụ \(-!)]]<) tính toán nghịch đảo f^-1. Như vậy, ngay cả các chương trình độ dài cũng không làm gì (hoặc bị kẹt trong một vòng lặp vô hạn) và các chương trình không tầm thường duy nhất có độ dài lẻ, tính toán f g f^-1trong đó glà toán tử trung tâm.

Vì một nửa mã nguồn luôn luôn dư thừa, nên nó có thể bị bỏ qua và việc chạy mã với -mcờ cho biết rằng mã nguồn sẽ được nhân đôi qua ký tự cuối cùng để lấy mã nguồn thực tế. Ví dụ, chương trình *<Xthực sự *<X>*là đối xứng.

Chơi golf trong Stack Mèo rất không trực quan, vì vậy các chương trình trên phải được tìm thấy bằng vũ lực. Hầu hết chúng đều phức tạp một cách đáng ngạc nhiên, nhưng tôi sẽ giải thích một vài điều và thêm vào câu trả lời này khi tôi có thời gian. Hiện tại, một số giải thích và giải pháp thay thế cho 0/ 1phiên bản có thể được tìm thấy trên kho Github tại đây .

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

Chỉnh sửa: -1 byte nhờ @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)

Điều này kỳ vọng 0là giá trị giả và 1giá trị trung thực. Trả về truehoặc false. p là Inputvà q là Output.

Prolog, 147 145 byte

Đạt được 2 byte nhờ @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

Truy vấn x(P,Q).bằng xchữ cái thích hợp Pvà Qđược đặt thành 0 hoặc 1.
Trả về truehoặc false.

Ví dụ SWISH bao gồm các bài kiểm tra - nhập runTest.để chạy.

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               #

Hãy thử nó ở đây! Nhưng đọc bên dưới trước.

Đầu vào là ẩn trên ngăn xếp. Kết quả là cho vào stack. Thêm 16 byte (một *đến cuối mỗi) nếu bạn muốn 0x00hoặc 0x01xuất ra đại diện cho 0 và 1. Thêm 160 byte nếu bạn muốn in 0hoặc 1in. (Đặt ~~##~~~#{@trước mỗi *.)

Toán tử nhị phân duy nhất của NTFJ là NAND, vì vậy mỗi toán tử này được viết dưới dạng NAND.

Chúng ta hãy đi qua từng người trong số họ.

0: sai

~

~đại diện cho một bit sai. Đủ đơn giản. Vì đầu vào được ẩn ở dưới cùng của ngăn xếp, nên điều này được để lại ở trên cùng của ngăn xếp.

1: p và q

|:|

NTFJ hoạt động trên một ngăn xếp. :là lệnh cho trùng lặp. Quan sát rằng p and q≡ not (p nand q)và đó 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

(Lưu ý, sau đó, :|có thể nói là phủ định và |:|có thể nói là kết hợp )

2: p và không q

:||:|

Quan sát rằng đây chỉ là một phủ định, :|và kết hợp |:|.

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

3: p

$

$bật một mục từ ngăn xếp. Vậy ... vâng.

4: không phải p và q

#{:||:|

Đây là điều tương tự như 2, ngoại trừ với #{lúc đầu. #đẩy 1 (bit thực) và {xoay ngăn xếp còn lại một lần. Đủ đơn giản.

5: q

#{$

Xoay trái một lần, thả.

6: xor

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

Quan sát:

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

Tuy nhiên, không có cách nào để nhân đôi toàn bộ stack. Vì vậy, chúng ta sẽ phải đưa từng cái p, qlên trên cùng và nhân đôi nó.

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

Và do đó, chúng tôi có xor của chúng tôi.

7: p hoặc q

:|#{:||

Phủ định trên cùng, đưa từ dưới lên trên, phủ định điều đó và kết hợp chúng lại với nhau. Về cơ bản , p or q = (not p) nand (not q).

8: không p và không q

:|#{:||:|

Đây chỉ đơn giản là sự phủ định của 7. Dễ dàng.

9:

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

Đây chỉ là xnor , hoặc không phải xor. Đơn giản trở lại.

10: không q

#{$:|

Phủ định 5.

11: p hay không q

#{:||

Phủ định p, nand. (not p) nand q = not ((not p) and q) = p or (not q) (by De Morgan's laws).

12: không p

$:|

Thả, dừng lại, và phủ nhận.

13: không phải p hay q

:||

Luật của De Morgan để cứu ngày, một lần nữa! Quá trình tương tự như 11, chỉ phủ định qthay vì p.

14: không p hay không q

|

Đây chỉ là một bắt chước nand.

15: đúng

#

# là bit thực sự.

Minecraft, 89 khối

Trong tất cả các ảnh sau, khối màu xanh dành cho Đầu vào A và khối màu cam dành cho Đầu vào B

16. Cổng TRUE - 1 khối

15. Cổng NAND - 1x2x3 = 6 khối

14. A => B - 1x2x3 = 6 khối

13. KHÔNG A - 2 khối

12. B => A - 1x2x3 = 6 khối

11. KHÔNG B - 2 khối

10. XNOR - 1x3x4 = 12 khối

9. BẮC - 1x2x3 = 6 khối

8. HOẶC - 1 khối

7. XOR - 1x3x4 = 12 khối

6. B - 1 khối

5.! A & B - 1x2x5 = 10 khối

4. A - 1 khối

3. A &! B - 1x2x5 = 10 khối

2. VÀ - 2x2x3 = 12 khối

1. SAI - 1 khối

Toán học, 67 byte

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

Mỗi trong số này đánh giá một chức năng, vì vậy bạn có thể sử dụng chúng như

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

À, nếu chỉ các số nguyên là trung thực / giả trong Mathicala, bốn số nguyên dài hơn đó có thể đã được rút ngắn đáng kể.

MATL, 34 23 byte

Tôi hy vọng tôi đã nhận được đơn đặt hàng đúng! Zero là falsey, non-zero là sự thật. Mỗi chức năng có hai đầu vào ngầm định (mặc dù nó có thể bỏ qua một số đầu vào). Đầu vào đầu tiên là A và thứ hai là B. Bạn có thể nhập 0/ 1cho đúng / sai hoặc T/ F.

Dưới đây là ví dụ về TryItOnline cho trường hợp thử nghiệm 3.

Đã lưu 4 byte bằng cách sử dụng *cho andvà 4 byte khác bằng cách sử dụng >/ <thay vì ~wY&/ w~Y&sau khi tôi thấy câu trả lời của 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("máy tính bàn") là một lệnh unix tiêu chuẩn, một máy tính hậu tố dựa trên ngăn xếp. Nó thiếu các hoạt động bit và các toán tử so sánh chỉ có thể được sử dụng để thực thi các macro (không có giá trị byte). Bộ phận nguyên cho một số trong đó.

Các tập lệnh này mong đợi 0và 1các giá trị trên ngăn xếp và để lại kết quả trên ngăn xếp.

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

Mê cung , 85 byte

Cảm ơn Sp3000 đã lưu 2 byte.

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

Tất cả đều là các chương trình đầy đủ, đọc hai số nguyên 0hoặc 1từ STDIN (sử dụng bất kỳ dấu tách không có chữ số nào) và in kết quả dưới dạng 0hoặc 1sang STDOUT.

Hãy thử trực tuyến! (Không phải là bộ kiểm tra, vì vậy bạn sẽ phải thử các chương trình và đầu vào khác nhau theo cách thủ công.)

Về phần giải thích, tất cả đều khá đơn giản. Tất cả các chương trình là tuyến tính và các lệnh được sử dụng thực hiện như sau:

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

Lưu ý rằng tôi đang sử dụng #luôn được sử dụng để kết hợp nó $, tức là để tính toán XOR 1, hay nói cách khác là phủ định logic. Chỉ trong một vài trường hợp tôi mới có thể sử dụng ~thay thế, bởi vì các lần tiếp theo &sẽ loại bỏ tất cả các bit không mong muốn khỏi kết quả -1hoặc -2.

Mã máy IA-32, 63 byte

Hexdump của mã, với sự tháo gỡ:

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;

Mã này dài hơn nó có thể, bởi vì nó sử dụng một quy ước mã hóa tiêu chuẩn: đầu vào ecxvà edxvà đầu ra al. Điều này có thể được thể hiện bằng C là

unsigned char __fastcall func(int, int);

Có vẻ như MS Visual Studio không hiểu SALCopcode không có giấy tờ , vì vậy tôi phải sử dụng mã của nó, thay vì tên.

Cảm ơn bạn l4m2 đã cải thiện một số mẫu mã!

C 34 byte

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

Trong đó n là số hàm để sử dụng, nhưng tôi nghĩ nó sẽ bị từ chối nên tôi đề xuất cái khác:

C 244 byte (sử dụng bộ nhớ)

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ó sử dụng mảng lập chỉ mục kép. n[0][1]Là(A implies B)(0,1)

138 byte

Tôi vừa học Forth. Tôi cho rằng Ansi Forth tương thích vì nó cũng chạy trên 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

Hàm z tạo một hàm mới với tên được cung cấp sau đó đặt số cổng logic từ đỉnh ngăn xếp đến địa chỉ hàm mới. Nó để lại hàm cổng logic (n + 1) tiếp theo trong ngăn xếp cho khai báo tiếp theo.

bạn có thể kiểm tra nó:
Và AB

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

("." In trên cùng của ngăn xếp "cr" là trả về 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 có vẻ ngắn hơn chức năng.

Brian & Chuck , 183 byte

Cảm ơn Sp3000 đã lưu 4 byte.

Một số chương trình có chứa một ký tự không thể in được. Cụ thể, mọi thứ \x01nên được thay thế bằng <SOH>ký tự điều khiển (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
?
#>+.

Đầu vào và đầu ra sử dụng các giá trị byte , vì vậy đầu vào phải là hai byte 0x00 hoặc 0x01 (không có dấu phân cách) và đầu ra sẽ là một byte như vậy. Đây thực sự cũng là định nghĩa hợp lý nhất về sự thật / giả dối đối với B & C bởi vì lệnh điều khiển luồng duy nhất ?coi các số không là giả và mọi thứ khác là sự thật.

Giải thích

Đầu tiên là một mồi B & C nhanh chóng:

• Mỗi chương trình bao gồm hai trường hợp giống như Brainfuck, mỗi trường hợp được viết trên một dòng riêng. Chúng tôi gọi người đầu tiên là Brian và người thứ hai Chuck . Thi hành bắt đầu trên Brian.
• Mỗi băng của chương trình là mã nguồn của chương trình khác và mỗi con trỏ lệnh của chương trình là đầu băng của chương trình khác.
• Chỉ Brian mới có thể sử dụng lệnh ,(byte đầu vào) và chỉ Chuck mới có thể sử dụng. (byte đầu ra).
• []Vòng lặp của Brainfuck không tồn tại. Thay vào đó, luồng điều khiển duy nhất bạn có là ?chuyển đổi điều khiển sang thể hiện khác nếu giá trị hiện tại dưới đầu băng là khác không.
• Ngoài >và <, có {và }đó là về cơ bản tương đương với các đoạn Brainfuck [<]và [>], có nghĩa là, họ di chuyển người đứng đầu băng đến zero vị trí tiếp theo theo hướng đó. Sự khác biệt chính là{ cũng có thể được dừng ở đầu bên trái của băng, bất kể nó có giá trị gì.
• Để thuận tiện, mọi _s trong mã nguồn được thay thế bằng null-byte (vì chúng rất hữu ích trong các chương trình không cần thiết để bắt {và }).

Lưu ý rằng trong tất cả các chương trình, băng của Chuck bắt đầu bằng a #. Điều này thực sự có thể là bất cứ điều gì. ?hoạt động sao cho đầu băng di chuyển một ô trước khi bắt đầu thực thi (để điều kiện tự nó không được thực thi nếu nó là một lệnh hợp lệ). Vì vậy, chúng ta không bao giờ có thể sử dụng ô Chuck đầu tiên cho mã.

Có năm loại chương trình, mà tôi sẽ giải thích chi tiết sau. Hiện tại tôi đang liệt kê chúng ở đây để tăng độ phức tạp.

0000, 1111: Hàm liên tục

?
#>.

?
#>+.

Những điều này rất đơn giản. Chúng tôi chuyển sang Chuck vô điều kiện. Chuck di chuyển đầu băng sang ô không sử dụng sang phải và in trực tiếp hoặc tăng nó trước để in1 .

0011, 0101, 1010, 1100: Chức năng tùy thuộc vào chỉ có một đầu vào

,?\x01+?
#>.

,,?\x01+?
#>.

,,-?\x01+?
#>.

,-?\x01+?
#>.

Tùy thuộc vào việc chúng tôi bắt đầu với ,hoặc ,,chúng tôi làm việc với Ahoặc B. Hãy xem ví dụ đầu tiên 0011(ví dụ A). Sau khi đọc giá trị, chúng tôi sử dụng ?như một điều kiện trên giá trị đó. Nếu A = 1, sau đó, điều này chuyển sang Chuck, người di chuyển đầu băng sang phải và in chữ-nhúng theo đúng nghĩa đen 1. Mặt khác, quyền kiểm soát vẫn thuộc về Brian. Ở đây, 1 byte là không có op. Sau đó, chúng tôi tăng đầu vào tốt +để đảm bảo nó khác không và sau đó chuyển sang Chuck với ?. Lần này, >di chuyển đến một ô không sử dụng ở bên phải và sau đó được in dưới dạng 0.

Để phủ nhận một trong những giá trị, chúng ta chỉ cần giảm giá trị của nó -. Điều này biến 1thành 0và 0thành -1, nó khác không và do đó ?có liên quan đến sự thật.

0001, 0010, 0100, 1000: Chức năng Binary với một kết quả truthy

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

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

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

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

Đây là một phần mở rộng của ý tưởng trước đó để làm việc với hai đầu vào. Hãy xem ví dụ về 1000(NOR). Chúng tôi (có khả năng) đọc cả hai đầu vào với ,?. Nếu một trong số đó là 1, các ?công tắc chuyển sang Chuck. Anh ta di chuyển đầu băng đến cuối cùng }(vào ô trống sau mã của Brian), di chuyển một ô khác bằng >(vẫn bằng 0) và in nó bằng ..

Tuy nhiên, nếu cả hai đầu vào đều bằng 0, thì điều khiển vẫn thuộc về Brian. >sau đó di chuyển đầu băng vào }sao cho lệnh này không được thực thi khi chúng ta chuyển sang Chuck ?. Bây giờ tất cả những gì Chuck làm là >.chỉ di chuyển lên 1-cell và in nó.

Chúng ta có thể dễ dàng có được ba chức năng khác bằng cách phủ định một hoặc cả hai đầu vào theo yêu cầu.

0111, 1011, 1101, 1110: Chức năng Binary với ba kết quả truthy

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

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

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

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

Một sửa đổi nhỏ của ý tưởng trước đó để phủ nhận kết quả (nghĩa là in 0khi chúng tôi chuyển qua tất cả Brian và mặt 1khác). Hãy xem 0111(OR) làm ví dụ. Lưu ý rằng 1-byte được nhúng là không có op, vì vậy điều này vẫn bắt đầu bằng ,?,?. Nếu một trong hai đầu vào là 1chúng ta chuyển sang Chuck, người sẽ di chuyển đầu băng trở lại từ đầu {. >.di chuyển đầu băng vào đó 1-byte và in nó.

Nếu cả hai đầu vào đều bằng 0 thì chúng ta vẫn ở với Brian, di chuyển đầu băng vào {để bỏ qua nó và sau đó chuyển sang Chuck. Khi anh ta thực thi >.lần này, anh ta di chuyển lên ô trống sau mã của Brian và in ra 0.

Một lần nữa, chúng ta dễ dàng có được các chức năng khác bằng cách phủ định một hoặc cả hai đầu vào.

0110, 1001: Hàm nhị phân có hai kết quả trung thực

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

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

Đây là một chút phức tạp hơn. Các chức năng trước đây khá đơn giản vì chúng có thể được ngắn mạch - giá trị của đầu vào đầu tiên có thể quyết định đầu ra và nếu không thì chúng ta xem xét đầu vào khác. Đối với hai chức năng này, chúng ta luôn cần xem xét cả hai đầu vào.

Ý tưởng cơ bản là sử dụng đầu vào đầu tiên để quyết định xem đầu vào thứ hai chọn giữa 0và 1giữa 1và 0. Hãy lấy 0110(XOR) làm ví dụ:

Hãy xem xét A = 0. Trong trường hợp này, chúng tôi muốn đầu ra Bnhư là. ,đọc A, ?không làm gì cả >di chuyển lên ô tiếp theo (khác không) để }đưa chúng ta đến _Chuck. Ở đây, chúng tôi đọc Bvới ,và sử dụng ?lại. Nếu Blà 0tốt, chúng tôi vẫn còn trên Brian. >bỏ qua }Chuck và ?chuyển đổi để >.bản in 0được nhúng trong mã nguồn của Brian. Nếu Blà 1mặt khác, Chuck không thực hiện }trong đó di chuyển vào _trong mã của Brian đã, vì vậy >.sau đó in ra 1-byte để thay thế.

Nếu A = 1, sau đó chúng tôi chuyển sang Chuck ngay lập tức, ai sẽ thực thi }+{>?. Những gì nó làm là di chuyển đến _mã nguồn của Brian, biến nó thành 1tốt +, sau đó quay trở lại điểm bắt đầu {và bỏ qua Brian ?bằng cách di chuyển một ô sang bên phải >trước khi trao lại quyền điều khiển cho anh ta. Lần này, sau khi Brian đọc B, nếu B = 0và Chuck sử dụng >.ô bên cạnh Brian ?sẽ 1thay thế 0. Ngoài ra, khi B = 1, Chuck }bỏ qua những gì được sử dụng là một khoảng trống và di chuyển tất cả đến cuối băng, để >.thay vào đó in ra một số không. Bằng cách này, chúng tôi đang in not B.

Để thực hiện tương đương, chúng tôi chỉ cần phủ định Atrước khi sử dụng nó như một điều kiện. Lưu ý rằng do điều này, chúng tôi cũng cần thêm một cái khác >vào Chuck để bỏ qua điều đó -khi quay trở lại bắt đầu.

ClojureScript, 88 84 76 74 byte

nilvà falselà giả, tất cả các giá trị khác là sự thật. Booleans ép buộc đến 0/1 cho số học và bất đẳng thức. Các hàm có thể lấy sai số lượng đối số.

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

Đầu vào / đầu ra sử dụng U + 0000 và U + 0001.

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

Brain-Flak , 418 , 316 byte

Hãy thử trực tuyến!

Đặt các đầu vào là hai số trên cùng của ngăn xếp khi bắt đầu chương trình (0 cho sai là đúng) và đầu ra là đầu của ngăn xếp ở cuối chương trình (0 cho sai khác là đúng).

sai, 4 byte (Phép lịch sự của Neak Leak )

(<>)

và, 36 byte

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

A và không B, 40 byte

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

A, 6 byte

({}<>)

không phải A và B, 38 byte

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

B, 2 byte

{}

xor, 34 byte

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

hoặc, 6 byte

({}{})

cũng không, 34 byte

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

xnor, 10 byte

({}{}[()])

không phải B, 34 byte

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

B ngụ ý A, 14 byte

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

không phải A, 34 byte

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

A ngụ ý B, 16 byte

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

không, 12 byte

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

đúng, 6 byte

<>(())

Giải trình

Vì hầu hết những thứ này rất giống nhau nên tôi sẽ không giải thích chính xác cách thức hoạt động của từng loại. Tôi cố gắng hết sức để làm cho nó rõ ràng tuy nhiên tất cả mười sáu hoạt động như thế nào.

Đầu tiên là các cổng trả về ba giá trị giống nhau (nghĩa là 2, 3, 5, 8, 9, 12, 14 và 15). Tất cả đều theo cùng một mô hình. Trước tiên, bạn chuyển đổi đầu vào thành một số hai bit với vị trí là twos và B là số. Điều này được thực hiện với đoạn trích này (({}){}{}). Sau đó, bạn trừ đi giá trị của hai bit đầu vào mà bạn muốn tách ({}[value]). (Trong mã thực tế, phép trừ và chuyển đổi được thực hiện trong một bước để lưu byte). Điều này có thể được kết hợp với không nếu cần thiết : (({}<(())>)){{}{}(((<{}>)))}{}{}.

Tiếp theo: và, cũng không, hoặc, xor và xnor. Những công việc tương tự như những người ở trên. Trong thực tế, một số trong số này được bao gồm ở trên, tuy nhiên phương pháp này ngắn hơn. Thủ thuật tôi sử dụng ở đây là mỗi cái tương ứng với tổng của A B. ví dụ xor ước tính là true nếu A + B = 1 và ngược lại là sai. Đầu tiên bạn thêm AB và trừ đi số tiền liên quan. Thể hiện như ({}{}[0,1,2 or 3]). Sau đó, nếu cần thiết tiến hành không

Tiếp theo: A, B, không phải A và không B. Đây là khá nhiều tự giải thích. Chúng tôi bắt đầu bằng cách loại bỏ các giá trị không cần thiết và sau đó chúng tôi hoặc phủ nhận hoặc kết thúc.

Cuối cùng là hai đơn giản: đúng và sai. Đối với những điều này, chúng tôi đẩy giá trị chính xác vào ngăn xếp tắt. Các <>lợi nhuận nilad zero vì vậy chúng tôi có thể tiết kiệm hai byte bằng cách sử dụng công tắc như giá trị zero.

Không phải là giải pháp hiệu quả nhất hiện có (có lẽ là hiệu quả nhất trong Brain-Flak), nhưng tôi đã có rất nhiều niềm vui khi viết những điều này và tôi khuyên bạn nên cố gắng rút ngắn những điều này.

ProgFk , 18,5 17,5 byte

Vì các hướng dẫn của ProgFk được chỉ định bằng các nibble, đoạn mã dưới đây được đưa ra dưới dạng thập lục phân, một cổng logic trên mỗi dòng và có khoảng trắng ở giữa các byte.

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

Giải trình

ProgFk là một esolang dựa trên băng (tương tự Brainfuck) trong đó mỗi ô là một bit và các hướng dẫn được đưa ra dưới dạng nibble (4 byte). Các lệnh hoạt động trên ô được trỏ bởi con trỏ lệnh. Đầu vào được đưa ra trong các ô thứ nhất và thứ hai (với Avà Blà các ô thứ nhất và thứ hai tương ứng) và con trỏ lệnh bắt đầu ở ô thứ nhất. Đầu ra được lưu trữ trong ô đầu tiên.

Mỗi hướng dẫn sử dụng được giải thích dưới đây.

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.

Đã lưu một byte nhờ @LeakyNun!

Trên thực tế, 24 byte

Các chương trình này lấy đầu vào là A\nB( \nđại diện cho một dòng mới), để B ở trên cùng của ngăn xếp, với A bên dưới. Falseđược đại diện bởi 0, và Trueđược đại diện bởi bất kỳ số nguyên dương.

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

Cảm ơn Leaky Nun cho 3 byte