Beispielsweise ist das Gatter A and Bein Logikgatter mit 2 Eingängen und 1 Ausgang.

Es sind genau 16, weil:

• Jedes logische Gatter nimmt zwei Eingänge, die wahr oder falsch sein können, und gibt uns 4 mögliche Eingänge
• Von den 4 möglichen Eingaben kann jede eine Ausgabe von Wahrhaftigkeit und Falschheit haben
• daher gibt es 2 ^ 4 mögliche logische Gatter, also 16.

Ihre Aufgabe ist es, 16 Programme / Funktionen zu schreiben, die alle separat implementieren.

Ihre Funktionen / Programme müssen unabhängig sein .

Sie sind gültig, solange sie Truthy / Falsey-Werte ausgeben. Dies bedeutet, dass Sie sie A or Bin Python als implementieren können lambda a,b:a+b, auch wenn 2sie für A=Trueund erstellt wurden B=True.

Score ist die Gesamtzahl der Bytes, die für jede Funktion / jedes Programm verwendet werden.

Liste der Logikgatter

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)

Wo die erste Zahl die Ausgabe für ist A=false, B=false, ist die zweite Zahl die Ausgabe für A=false, B=true, ist die dritte Zahl die Ausgabe für A=true, B=false, ist die vierte Zahl die Ausgabe für A=true, B=true.

Bestenliste

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>

Dominosteine , 122.000 Bytes oder 72 Kacheln

Die Byte - Zählung ist die Größe der gespeicherten Datei , die ist 0.122 MB.

Domino-Computing war die Inspiration. Ich habe all dies bis zur Symmetrie (und darüber hinaus!) Mit einem Virtual-Reality-Steam-Spiel namens Tabletop Simulator getestet .

Einzelheiten

• I / O
  • Start - Dies ist der Übersichtlichkeit halber enthalten (wird nicht zur Gesamtsumme gezählt) und ist das, was die Funktion "aufruft" oder "ausführt". Sollte nach Eingabe von [Gelb] gedrückt werden .
  • Eingang A - Dies ist der Übersichtlichkeit halber enthalten (wird nicht zur Gesamtsumme gezählt) und wird gedrückt, um a anzuzeigen, 1und ansonsten nicht gedrückt [Grün] .
  • Eingang B - Dies ist der Übersichtlichkeit halber enthalten (wird nicht zur Gesamtsumme gezählt) und wird gedrückt, um a anzuzeigen, 1und ansonsten nicht gedrückt [Blau] .
  • Ausgabe - Dies wird zur Gesamtsumme gezählt. Es ist der Domino, der das Ergebnis des Logikgatters [Schwarz] deklariert .
• T / F
  • Ein gefallener Output-Domino repräsentiert ein Ergebnis von Trueoder1
  • Ein stehender Ausgabedomino repräsentiert ein Ergebnis von Falseoder0
• Drücken Sie
  • Um Input zu geben oder die Kette zu starten, laichen Sie den Metallmarmor
  • Stellen Sie die Auftriebskraft auf 100%
  • Heben Sie den Marmor über den gewünschten Domino
  • Lass den Marmor fallen

Tore

• falsch, 1
  • 
• und 6 4
  • 
• A und nicht B, 4 3
  • 
• A, 1
  • 
• nicht A und B, 4 3
  • 
• B, 1
  • 
• xor, 15 11
  • 
• oder 1
  • 
• noch 3 2
  • 
• xnor, 17 13
  • 
• nicht B, 2
  • 
• B impliziert A, 7 6
  • 
• nicht A, 2
  • 
• A impliziert B, 7 6
  • 
• und, 16 15
  • 
  • wahr, 1
  • 

TL; DR

Ich hatte auf eine domino-freundliche Herausforderung gewartet / gewollt und als ich das sah, konnte ich es nicht verpassen. Das einzige Problem war, dass anscheinend niemand mehr Dominosteine ​​besitzt! Also gab ich schließlich nach und kaufte ein Double Twelve . Dieses Set hat 91 Kacheln, was mich auf die Idee brachte, anstelle der normalen (langen) "Zeitverzögerungsmethode" einen "Funktionsaufruf" / "Domino starten" zu haben. Das Guthaben für die 90-Grad-Drehung gehört zum Kanal von dominoesdouble07 .

Nachdem diese mit physischen Dominosteinen erstellt wurden, wurde gemäß Meta festgelegt, dass gültige Lösungen digital sein sollten. Also habe ich diese Tore in Tabletop Simulator neu erstellt . Leider stimmen TS und Realität in Bezug auf die Dominophysik nicht überein. Dafür musste ich 11 Dominosteine ​​hinzufügen, aber ich habe auch 8 gespart. Insgesamt sind virtuelle Dominosteine ​​in Bezug auf das Bauen und Testen ( Ctrl+ Z) um ca. x150 effektiver .

Aktualisieren

• -9 [17-03-13] Verkürztxor xnor nand
• [17-03-04] Link zur Workshop-Datei hinzugefügt
• +11 [17-03-03] Digital xnorund hinzugefügtxor
• -8 [17-03-03] Alle Tore digitalisiert (außer xorund xnor). Für das Blockieren auf Tabletop ist nur 1 Domino anstelle von 2 erforderlich.
• [16-09-23] Verkleinerte Bilder
• -11 [16-09-18] Xor wieder fast halbieren. Danke an @DJMcMayhem für xnor und Joe für xor.
• -31 [16-08-31] Einige Bilder aktualisiert und einige Kacheln rasiert und xor in zwei Hälften geschnitten
• [16-08-28] Bilder hinzugefügt

Hexagony , 89 Bytes

Vielen Dank an FryAmTheEggman für die notwendige Inspiration für die XOR-Lösung.

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

Alle Programme verwenden 0für falsch und 1für wahr.

Probieren Sie es online! Dies ist keine Testsuite, Sie müssen die verschiedenen Programme und Eingaben selbst kopieren.

Die obige Lösung liegt innerhalb von 2 Bytes der Optimalität (es sei denn, wir lockern die wahrheitsgemäße / falsche Interpretation, denke ich). Ich habe für eine enge über alle Programme bis zwei Tagen eine Brute - Force - Suche laufen lassen , die 2 in Seitenlänge passen, dh bis zu 7 Bytes (nicht ganz alle Programme - ich einige Annahmen darüber , was jeweils gültigen Programm Bedürfnisse gemacht und was nicht gültiges Programm haben könnte). Die Suche ergab Lösungen für 15 der 16 möglichen Tore - und oft viel mehr als nur eines. In diesem Pastebin finden Sie eine Liste aller alternativen Lösungen, die ich auch nach gleichem Verhalten gruppiert habe. Die oben gezeigten habe ich ausgewählt, weil sie entweder die einfachste oder die interessanteste Lösung sind, und ich werde morgen Erklärungen für sie hinzufügen.

Was das 16. Gatter betrifft: XOR ist das einzige Gatter, das anscheinend nicht in 7 Bytes implementiert werden kann. Eine Brute-Force-Suche über größere Programme ist mit dem Code, den ich derzeit habe, leider nicht möglich. Also musste XOR von Hand geschrieben werden. Das kürzeste, das ich bisher gefunden habe, ist das obige 10-Byte-Programm, das auf einem fehlgeschlagenen (aber sehr knappen) Versuch von FryAmTheEggman basiert. Es ist möglich, dass eine 8-Byte- oder 9-Byte-Lösung vorhanden ist, aber ansonsten sollten alle Lösungen in der Tat optimal sein.

Erklärungen

Warnung: Textwand. Falls Sie sich nicht dafür interessieren, wie diese hochkomprimierten Hexagony-Programme tatsächlich funktionieren, haben wir nachfolgend Erläuterungen zu den einzelnen Programmen aufgeführt. Ich habe versucht, für jedes Gatter die einfachste Lösung zu wählen, wenn mehr als ein optimales Programm existiert, um die Erklärungen einigermaßen kurz zu halten. Einige von ihnen verwirren jedoch immer noch den Verstand, weshalb ich der Meinung war, dass sie etwas mehr Ausarbeitung verdienen.

0000: Falsch

Ich glaube nicht, dass wir dafür ein Diagramm brauchen:

 ! @
. . .
 . .

Da das gesamte Speicherraster mit Nullen initialisiert ist, wird !einfach eine Null ausgegeben und @das Programm beendet.

Dies ist auch die einzige 2-Byte-Lösung.

0001: Und

 ? .
| @ !
 . .

Dies führt im Grunde genommen zu einem Kurzschluss . Das graue Diagramm unten zeigt den Beginn des Programms, bei dem die erste Eingabe gelesen wird ?und der Anweisungszeiger (IP) in die linke Ecke übergeht, in der der |Spiegel sie widerspiegelt. Jetzt fungiert die Ecke als Bedingung, sodass es je nach Wert der ersten Eingabe zwei verschiedene Ausführungspfade gibt. Das rote Diagramm zeigt den Kontrollfluss für A = 0und das grüne Diagramm für A = 1:

Wie Sie sehen können, wenn das Aist 0, dann drucken wir es einfach und beenden (denken Sie daran , dass alle .No-ops sind). Wenn dies Ajedoch 1der Fall ist, durchläuft die IP die erste Zeile erneut und liest Bund druckt diese stattdessen aus.

Insgesamt gibt es 16 5-Byte-Lösungen für dieses Gatter. Vierzehn davon sind im Wesentlichen die gleichen wie oben, entweder indem Sie >anstelle von |oder durch .einen Befehl ersetzen , der praktisch ein No-Op ist, oder indem Sie ?die zweite Position einnehmen:

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

Und dann gibt es zwei andere Lösungen (die einander äquivalent sind). Diese implementieren ebenfalls die gleiche Kurzschlusslogik, aber die Ausführungspfade sind etwas verrückter (und dem Leser als Übung überlassen):

?<!@|
?<!@<

0010: A und nicht B

 # ?
# ! )
 @ .

Dies führt auch zu einer Art Kurzschluss, der jedoch aufgrund der Verwendung des #Kontrollflusses viel schwieriger ist. #ist ein bedingter IP-Switch. Hexagony wird mit sechs IPs mit der Bezeichnung 0to geliefert 5, die in den sechs Ecken des Rasters beginnen und entlang ihrer Kante im Uhrzeigersinn zeigen (und das Programm beginnt immer mit IP 0). Wenn a #angetroffen wird, wird der aktuelle Wert modulo genommen 6und der Steuerungsfluss mit der entsprechenden IP fortgesetzt. Ich bin mir nicht sicher, welche Wahnsinnsanpassung mich veranlasst hat, diese Funktion hinzuzufügen, aber sie ermöglicht sicherlich einige überraschende Programme (wie dieses).

Wir werden drei Fälle unterscheiden. Wann A = 0ist das Programm ziemlich einfach, weil der Wert immer 0dann #ist, wenn es auftritt, so dass keine IP-Umschaltung stattfindet:

#tut nichts, ?liest A(dh tut auch nichts), #tut immer noch nichts, !druckt das 0, )inkrementiert es (das ist wichtig, sonst springt die IP nicht in die dritte Zeile), @beendet das Programm. Einfach genug. Betrachten wir nun den Fall (A, B) = (1, 0):

Der rote Pfad entspricht immer noch IP 0, und ich habe den grünen Pfad für IP hinzugefügt 1. Wir sehen, dass nach dem ?Lesen A( 1dieses Mal) #auf die IP umgeschaltet wird, die in der oberen rechten Ecke beginnt. Das heißt ?kann lesen B( 0). Nun )inkrementiert das zu 1, so dass die #in der oberen linken Ecke nichts macht und wir bei IP bleiben 1. Der !Ausdruck 1und die IP-Adresse werden um die linke Diagonale gewickelt. #tut immer noch nichts und @beendet das Programm.

Schließlich der wirklich seltsame Fall, in dem beide Eingaben sind 1:

Diesmal ist auch der zweite Eingang 1und )erhöht ihn auf 2. Das heißt, die #in der oberen linken Ecke veranlasst einen weiteren IP-Switch auf IP 2, blau anzuzeigen. Auf diesem Weg erhöhen wir ihn zuerst weiter 3(obwohl das irrelevant ist) und übergeben ihn dann ?ein drittes Mal. Da wir jetzt auf EOF geklickt haben (dh die Eingabe ist erschöpft), wird das ?zurückgegeben 0, !gedruckt und @das Programm beendet.

Dies ist insbesondere die einzige 6-Byte-Lösung für dieses Gate.

0011: EIN

 ? !
@ . .
 . .

Dies ist so einfach, dass wir kein Diagramm benötigen: ?Liest A, !druckt und @beendet es.

Dies ist die einzige 3-Byte-Lösung für dieses Gate. (Im Prinzip wäre es auch möglich ,;@, aber die Suche schloss nicht ein ;, da ich glaube, dass es !für diese Aufgabe niemals Bytes einsparen kann .)

0100: B und nicht A

 + ?
| @ !
 ? .

Dieser ist viel einfacher als sein "Bruder" 0010. Der Kontrollfluss ist tatsächlich derselbe, den wir oben für 0001(Und) gesehen haben. Wenn ja A = 0, dann überquert die IP die untere Zeile und liest Bund druckt diese, bevor sie beendet wird. Wenn A = 1dann die IP die erste Zeile erneut durchläuft und ebenfalls liest B, werden jedoch +zwei nicht verwendete Speicherflanken hinzugefügt, sodass nur der aktuelle Wert auf zurückgesetzt wird 0, sodass !immer gedruckt wird 0.

Es gibt ziemlich viele 6-Byte-Alternativen dazu (insgesamt 42). Erstens gibt es eine Menge Lösungen, die den oben genannten entsprechen. Wir können wieder frei zwischen |und wählen >und +können durch jeden anderen Befehl ersetzt werden, der uns eine leere Kante gibt:

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

Darüber hinaus können wir ]stattdessen auch verwenden ?. ]wechselt zur nächsten IP (dh wählt IP aus 1), so dass dieser Zweig stattdessen die ?in der oberen rechten Ecke wiederverwendet . Das ergibt weitere 18 Lösungen:

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

Und dann gibt es noch sechs andere Lösungen, die alle unterschiedlich funktionieren und unterschiedlich verrückt sind:

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

0101: B

 ? ?
! @ .
 . .

Woohoo, ein anderes einfaches: lesen A, lesen B, drucken B, beenden. Es gibt jedoch tatsächlich Alternativen dazu. Da Aes sich nur um ein einzelnes Zeichen handelt, können wir es auch lesen mit ,:

,?!@

Es besteht auch die Möglichkeit, einen einzelnen ?und einen Spiegel zu verwenden, um ihn zweimal zu durchlaufen:

?|@!    ?>@!

0110: Xor

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

Wie ich oben sagte, war dies das einzige Tor, das nicht in Seitenlänge 2 passte, also eine handschriftliche Lösung von FryAmTheEggman und mir, und es besteht die gute Chance, dass es nicht optimal ist. Es sind zwei Fälle zu unterscheiden. Wenn A = 0der Kontrollfluss ziemlich einfach ist (weil wir in diesem Fall nur drucken müssen B):

Wir beginnen auf dem roten Weg. ?liest A, <ist ein Zweig, der die Null nach links ablenkt. Die IP-Adresse wird nach unten umgebrochen und ist dann _ein weiterer Spiegel. Wenn die IP-Adresse die Ecke erreicht, wird sie nach links oben umgebrochen und auf dem blauen Pfad fortgesetzt. ?liest B, !druckt es. Jetzt (dekrementiert es. Dies ist wichtig, da sichergestellt wird, dass der Wert nicht positiv ist (entweder 0oder -1jetzt). Das macht IP-Wrap in die rechte Ecke, wo @das Programm beendet wird.

Wenn A = 1es etwas kniffliger wird. In diesem Fall möchten wir drucken not B, was an sich nicht allzu schwierig ist, aber der Ausführungspfad ist etwas trippelig.

Diesmal <lenkt der die IP rechts ab und fungiert dann <nur noch als Spiegel. Die IP durchläuft also denselben Pfad in umgekehrter Reihenfolge und liest, Bwenn sie ?erneut auf sie trifft . Die IP wickelt sich in der rechten Ecke um und fährt auf dem grünen Pfad fort. Als nächstes (~wird festgestellt, was "Dekrement, Multiplikation mit -1" ist, was tauscht 0und 1und daher berechnet not B. \ist nur ein Spiegel und !druckt das gewünschte Ergebnis. Dann ?versucht eine andere Nummer zurück , sondern gibt Null zurück. Die IP wird nun in der unteren linken Ecke des blauen Pfads fortgesetzt. (dekrementiert, <reflektiert,(verringert sich erneut, so dass der aktuelle Wert negativ ist, wenn die IP die Ecke trifft. Es bewegt sich über die untere rechte Diagonale und trifft schließlich, @um das Programm zu beenden.

0111: Oder

 ? <
< @ !
 . .

Mehr Kurzschluss.

Der A = 0Fall (der rote Pfad) ist hier etwas verwirrend. Die IP wird nach links abgelenkt, in die untere linke Ecke umbrochen, wird sofort von der reflektiert <und kehrt zum ?zu lesenden zurück B. Es wickelt dann an die großen rechten Ecke, druckt Bmit !und beendet.

Der A = 1Fall (der grüne Weg) ist etwas einfacher. Der <Zweig lenkt die IP nach rechts um, also drucken wir sie einfach aus !, brechen nach links oben zurück und enden bei @.

Es gibt nur eine andere 5-Byte-Lösung:

\>?@!

Es funktioniert im Wesentlichen gleich, aber die tatsächlichen Ausführungspfade sind sehr unterschiedlich und es wird eine Ecke zum Verzweigen anstelle von a verwendet <.

1000: Noch

 ) \
! # ?
 @ {

Dies könnte mein Lieblingsprogramm sein, das in dieser Suche gefunden wurde. Das Coolste ist, dass diese Implementierung nortatsächlich für bis zu 5 Eingänge funktioniert. Ich muss ein wenig auf die Details des Speichermodells eingehen, um dieses zu erklären. Zur schnellen Auffrischung ist das Speichermodell von Hexagony ein separates hexagonales Gitter, in dem jede Kante einen ganzzahligen Wert enthält (anfangs alle Nullen). Es gibt einen Speicherzeiger (MP), der eine Kante und eine Richtung entlang dieser Kante angibt (so dass sich zwei benachbarte Kanten vor und hinter der aktuellen Kante befinden, mit sinnvollen linken und rechten Nachbarn). Hier ist ein Diagramm der Kanten, die wir verwenden werden, wobei der MP wie in Rot angezeigt beginnt:

Betrachten wir zunächst den Fall, in dem beide Eingaben wie folgt lauten 0:

Wir beginnen auf dem grauen Pfad, der einfach die Kante A inkrementiert , 1so dass der #IP- 1Pfad, der der blaue Pfad ist, in der rechten oberen Ecke beginnt. \tut dort nichts und ?liest eine Eingabe. Wir springen in die linke obere Ecke, wo )diese Eingabe erhöht wird. Solange die Eingabe null ist, führt dies zu a 1, sodass #nichts unternommen wird. Dann {bewegt sich der MP auf der linken Seite, also auf der ersten Iteration von A zu B . Da diese Kante noch ihre anfängliche Null hat, springt die IP zurück in die obere rechte Ecke und auf eine neue Speicherkante. Diese Schleife wird also so lange fortgesetzt, wie ?Nullen gelesen werden und der MP von B um das Sechseck verschoben wirdzu C zu D und so weiter. Es spielt keine Rolle, ob ?eine Null zurückgegeben wird, weil es sich um eine Eingabe oder um eine EOF handelt.

Kehrt nach sechs Iterationen durch diese Schleife {zu A zurück . Diesmal enthält die Kante bereits den Wert 1der ersten Iteration, sodass die IP in die linke Ecke übergeht und stattdessen auf dem grünen Pfad fortgesetzt wird. !druckt es einfach aus 1und @beendet das Programm.

Was ist nun, wenn einer der Eingänge ist 1?

Dann ?liest man das 1irgendwann und )erhöht es auf 2. Das heißt #, jetzt werden die IPs wieder gewechselt und wir fahren in der rechten Ecke auf dem roten Pfad fort. ?Liest eine andere Eingabe (falls vorhanden), die keine Rolle spielt, und {verschiebt eine Kante weiter. Dies muss eine nicht verwendete Flanke sein, daher funktioniert dies für bis zu 5 Eingänge. Die IP-Adresse wird rechts oben umbrochen, wo sie sofort wiedergegeben wird, und in der linken Ecke. !druckt die 0auf der unbenutzten Kante und #wechselt zurück zu IP 0. Diese IP wartete noch auf dem #nach Südwesten gehenden (grauen Pfad), sodass sie sofort die trifft @und das Programm beendet.

Insgesamt gibt es sieben 7-Byte-Lösungen für dieses Gate. 5 von ihnen funktionieren genauso und verwenden einfach andere Befehle, um zu einer nicht verwendeten Kante zu gelangen (und können um ein anderes Sechseck oder in eine andere Richtung laufen):

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

Und es gibt noch eine andere Lösungsklasse, die nur mit zwei Eingängen funktioniert, deren Ausführungspfade jedoch noch unübersichtlicher sind:

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

1001: Gleichberechtigung

 ( ~
? / @
 # !

Dies nutzt auch die bedingte IP-Auswahl sehr geschickt aus. Wir müssen wieder zwischen A = 0und unterscheiden A = 1. Im ersten Fall möchten wir drucken not B, im zweiten möchten wir drucken B. Denn A = 0wir unterscheiden auch die beiden Fälle für B. Beginnen wir mit A = B = 0:

Wir beginnen auf dem grauen Weg. (~ignoriert werden kann, bricht die IP in die linke Ecke (immer noch auf dem grauen Pfad) und liest Amit ?. (dekrementiert das, so dass wir bekommen -1und IP in die untere linke Ecke umbrechen. Nun, wie ich bereits sagte, #nimmt der Wert Modulo 6vor der Auswahl der IP, so dass ein Wert von -1IP tatsächlich rauskommt 5, der in der linken Ecke auf dem roten Pfad beginnt. ?liest B, (dekrementiert das auch so, dass wir auf IP bleiben, 5wenn wir #erneut schlagen . ~negiert das, -1so dass die IP in die untere rechte Ecke umbrochen wird, druckt das 1und endet.

Wenn dies stattdessen der Fall Bist 1, wird der aktuelle Wert 0beim #zweiten Mal angezeigt, sodass wir wieder zu IP wechseln 0(jetzt auf dem grünen Pfad). Das trifft ?ein drittes Mal, gibt nach 0, !druckt es aus und @endet.

Schließlich der Fall, wo A = 1. Diesmal ist der aktuelle Wert bereits Null, wenn wir #zum ersten Mal drücken, daher wechselt dieser Wert nie 5in erster Linie auf IP . Wir fahren einfach sofort auf dem grünen Weg weiter. ?Jetzt gibt es nicht nur eine Null, sondern kehrt Bstattdessen zurück. !druckt es aus und @bricht es erneut ab.

Insgesamt gibt es drei 7-Byte-Lösungen für dieses Gate. Die beiden anderen arbeiten sehr unterschiedlich (sogar voneinander) und machen noch seltsamer Gebrauch davon #. Insbesondere lesen sie einen oder mehrere Werte mit ,(Lesen eines Zeichencodes anstelle einer ganzen Zahl) und verwenden dann diesen Wert modulo 6, um eine IP auszuwählen. Es ist ziemlich verrückt.

),)#?@!

?~#,~!@

1010: Nicht B

 ? ?
| @ !
 ) .

Dieser ist ziemlich einfach. Der Ausführungspfad ist der horizontale Zweig, den wir bereits andfrüher kennen. ??liest Aund dann sofort B. Nachdem wir überlegt |und verzweigt haben, werden B = 0wir den untersten Zweig ausführen, in dem )der Wert erhöht wird, um den 1dann gedruckt wird !. Auf dem oberen Ast (wenn B = 1) wird ?einfach die Kante zurückgesetzt, auf 0die dann auch durch gedruckt wird !.

Es gibt acht 6-Byte-Programme für dieses Gatter. Vier davon sind ziemlich gleich und verwenden entweder >statt |oder 1statt )(oder beides):

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

Zwei verwenden ein einzelnes, ?das aufgrund eines Spiegels zweimal verwendet wird. Die Verneinung geschieht dann wie xorbei entweder (~oder ~).

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

Und schließlich verwenden zwei Lösungen einen bedingten IP-Switch, denn warum auf einfache Weise, wenn der gewundene auch funktioniert:

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

1011: B impliziert A

 \ #
? ? !
 1 @

Hierfür wird ein ziemlich aufwändiges IP-Switching verwendet. Ich werde A = 1dieses Mal mit dem Fall beginnen, weil es einfacher ist:

Wir beginnen auf dem grauen Pfad, der liest Amit ?und trifft dann auf die #. Da Aist 1diese IP - Schalter 1(grüner Pfad). Der !druckt sofort das, die IP bricht nach links oben ab, liest B(unnötig) und bricht ab.

Wenn A = 0es ein bisschen interessanter wird. Betrachten wir zuerst A = B = 0:

Diesmal #macht der nichts und wir bleiben auf IP 0(roter Pfad von diesem Punkt an). ?liest Bund 1verwandelt es in eine 1. Nachdem wir in die obere linke Ecke gewickelt haben, schlagen wir #erneut zu, sodass wir schließlich auf dem grünen Pfad landen und 1vor dem Beenden wie zuvor drucken .

Schließlich ist hier (A, B) = (0, 1)der falsche Fall:

Beachten Sie, dass ich den anfänglichen grauen Pfad aus Gründen der Übersichtlichkeit entfernt habe, das Programm jedoch auf die gleiche Weise beginnt und wir wie zuvor auf dem roten Pfad landen. Diesmal ?kehrt die Sekunde zurück 1. Jetzt begegnen wir dem 1. An dieser Stelle ist es wichtig zu verstehen, was Ziffern in Hexagony tatsächlich tun (bisher haben wir sie nur für Nullen verwendet): Wenn eine Ziffer angetroffen wird, wird der aktuelle Wert mit 10 multipliziert und dann die Ziffer hinzugefügt. Dies wird normalerweise verwendet, um Dezimalzahlen wörtlich in den Quellcode zu schreiben. Dies bedeutet jedoch, dass diese B = 1tatsächlich dem Wert zugeordnet sind 11. Wenn wir also drücken #, wird dies als Modulo genommen 6, 5und daher wechseln wir zu IP 5(anstatt 1wie zuvor) und fahren auf dem blauen Pfad fort. Schlagen?Ein drittes Mal gibt eine Null zurück, also wird diese !ausgegeben, und nach zwei weiteren ?wird die IP rechts unten umgebrochen, wo das Programm endet.

Hierfür gibt es vier 7-Byte-Lösungen, die alle unterschiedlich funktionieren:

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

1100: Kein

 ? (
~ ! @
 . .

Nur eine einfache lineare: Lesen Amit ?, Negieren mit (~, Drucken mit !, Beenden mit @.

Es gibt eine alternative Lösung, und die negiert ~)stattdessen mit:

?~)!@

1101: A impliziert B

 ? .
| @ !
 ) .

Dies ist viel einfacher als die gegenteilige Implikation, über die wir gerade gesprochen haben. Es ist wieder eines dieser horizontalen Zweigprogramme, wie das für and. Wenn Aja 0, wird es einfach 1auf den unteren Zweig erhöht und gedruckt. Andernfalls wird die oberste Verzweigung erneut ausgeführt, wobei diese stattdessen ?gelesen Bund dann !gedruckt wird.

Es gibt hier eine Menge Alternativen (insgesamt 66 Lösungen), hauptsächlich aufgrund der freien Wahl der effektiven No-Ops. Zunächst können wir die obige Lösung auf die gleiche Weise variieren, wie wir es könnten, andund wir können auch wählen zwischen )und 1:

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

Und dann gibt es eine andere Version mit bedingter IP-Auswahl, bei der der erste Befehl fast willkürlich ausgewählt werden kann, und es gibt auch eine Auswahl zwischen )und 1für einige dieser Optionen:

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

 ? $
@ # )
 ! <

Das letzte komplizierte. Wenn Sie noch lesen, haben Sie es fast geschafft. :) Lass uns zuerst schauen A = 0:

?liest Aund dann schlagen wir zu $. Dies ist ein Sprungbefehl (wie der von Befunge #), der den nächsten Befehl überspringt, damit wir nicht mit dem Befehl enden @. Stattdessen geht die IP weiter bei #. Da jedoch Aheißt 0, tut dies nichts. )erhöht es 1so, dass die IP auf dem unteren Pfad fortgesetzt wird, auf dem das 1gedruckt wird. Das <lenkt die IP nach rechts um, wo sie in die linke Ecke übergeht und das Programm beendet wird.

Als nächstes, wenn die Eingabe ist, erhalten (A, B) = (1, 0)wir diese Situation:

Es ist im Wesentlichen die gleiche wie zuvor , außer dass bei der #wir auf IP - Switch 1(grüne Strecke), aber da Bist 0man zurück zu IP wechseln , 0wenn wir schlagen #ein zweites Mal (jetzt blau - Pfad), wo er druckt 1wie zuvor.

Schließlich der A = B = 1Fall:

Dieses Mal, wenn wir #das zweite Mal, ist der aktuelle Wert immer noch 1so, dass wir die IP nicht erneut ändern. Das <spiegelt es wieder und beim dritten Mal ?bekommen wir eine Null. Daher wird die IP nach links unten umgebrochen, wo !die Null ausgegeben wird und das Programm endet.

Insgesamt gibt es dafür neun 7-Byte-Lösungen. Die erste Alternative verwendet einfach 1anstelle von ):

?$@#1!<

Dann gibt es zwei Lösungen, die Ihnen bei der Menge an IP-Switching helfen:

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

Dies hat mich wirklich umgehauen: Der interessante Teil ist, dass IP-Switching als verzögerte Bedingung verwendet werden kann. Die IP-Switching-Regeln der Sprache sehen vor, dass die aktuelle IP einen weiteren Schritt ausführt, bevor der Switch ausgeführt wird. Wenn dieser Schritt durch eine Ecke geht, entscheidet der aktuelle Wert darüber, auf welchem ​​Zweig die IP fortgesetzt wird, wenn wir jemals wieder dorthin wechseln. Genau das passiert, wenn die Eingabe ist A = B = 1. Obwohl dies alles im Einklang mit der Art und Weise steht, wie ich die Sprache entworfen habe, war mir diese Implikation der Spezifikation nie bewusst. Daher ist es schön, wenn mir meine Sprache einige neue Tricks beibringt: D.

Dann gibt es noch eine dritte Lösung, deren IP-Switching noch schlimmer ist (obwohl sie diesen aufgeschobenen bedingten Effekt nicht nutzt):

>?1]#!@

Und dann gibt es noch einen:

?$@#)!<

Und dann gibt es diese vier äquivalenten Lösungen, die eine nicht-bedingte IP-Umschaltung verwenden und stattdessen die gesamte Logik über Verzweigungen und Ecken implementieren:

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

1111: Wahr

 1 !
@ . .
 . .

Sie haben sich am Ende etwas Einfaches verdient: Kante setzen auf 1, drucken mit !, beenden mit @. :)

Natürlich gibt es eine Alternative:

)!@

Wie üblich alle mit Timwis HexagonyColorer erstellten Kontrollflussdiagramme und das Speicherdiagramm mit seinem EsotericIDE .

APL, 22 20 18 Bytes

Die wahren und falschen Einträge sind vollständige Programme, und die anderen 14 sind Funktionen. (Danke an 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)

Probieren Sie es hier aus.

Schach / mittelmäßiger Schachspieler im Endspiel, 70 Teile

Inspiriert von dieser Domino-Antwort entschied ich, dass ein anderes Spiel diese Ehre haben sollte.

Beachten Sie, dass ich einige Regeln für die Bewegung der Teile festgelegt habe. Da ich keine Lust habe, die optimalen Züge für jede Situation zu studieren, sind die Regeln für den Zug der Weißen einfach: Bleiben Sie außer Kontrolle, nehmen Sie die bestmögliche Figur in diesem Zug ein, während Sie so wenig Material wie möglich verlieren, und stoppen Sie einen Bauern von der Förderung in dieser Reihenfolge der Priorität. Wenn es zwei Felder gibt, zu denen er sich bewegen kann, kann er sich mit gleicher Gunst zu beiden bewegen (daher haben sie in diesen, wenn er sich zu mehr als einem Feld bewegen kann, die gleiche Farbe). Beachten Sie, dass Weiß mit etwas fängt, auch wenn es gefangen genommen wird, wenn die angreifende Figur einen höheren Wert hat als die verlorene. Werte sind hier:pawn<knight=bishop<rook<queen

Die Eingabe ist, ob ein Turm vorhanden ist oder nicht. Beachten Sie, dass Türme nur dann mit den Namen A und B beschriftet werden, wenn es darauf ankommt: Wenn sich das Tor beim Wechseln der Türme gleich verhält, werden sie nicht beschriftet.

Die Ausgabe ist die Farbe des Quadrats, an dem der weiße König endet: Weiß = 1, Schwarz = 0

Vor den Bildern möchte ich mich für schlechte Bilder entschuldigen. Ich bin nicht besonders gut darin, eine Kamera ruhig zu halten.

Falsch, 4:

UND, 4:

A und nicht B, 5 (ich glaube, ich kann das auf drei bringen, habe aber gerade kein Board):

A, 4:

Nicht A und B, 5 (Ich glaube, ich kann das auf drei bringen, aber ich habe gerade kein Board):

B, 4:

Xor, 5 (Ich kenne einen Weg, um es 4 zu machen, aber ich habe das Board gerade nicht):

Oder 4:

Noch 4:

Xnor, 5 (Ich kenne einen Weg, um es 4 zu machen, aber ich habe das Board gerade nicht):

Nicht B, 4:

B impliziert A, 5 (ich denke, ich kann das auf drei reduzieren, habe aber momentan keine Karte):

Nicht A, 4:

A impliziert B, 5 (ich glaube, ich kann das auf drei reduzieren, habe aber momentan keine Karte):

Nand, 4:

Richtig, 4:

Jelly , 19 Bytes

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.

Probieren Sie es online!

NAND-Logikgatter - 31 Gatter

Als Schöpfer der ursprünglichen Reihe von NAND- Gatter- Fragen konnte ich die Gelegenheit nicht verpassen, diese Gatter zu verwenden, um ein anderes Logikgatter-Problem zu lösen.

In jedem dieser Diagramme ist der obere Eingang A, während der untere Eingang B ist.

Bitweises zyklisches Tag , 118 Bit = 14,75 Byte

Bitwise Cyclic Tag ist vielleicht die einfachste Turing-Komplett-Sprache, die jemals entwickelt wurde. Es gibt ein Programmband und ein Datenband, die beide aus einer Liste von Bits bestehen. Das Programmband wird zyklisch so lange interpretiert, bis das Datenband leer ist:

• 0: löscht das erste Bit vom Datenband.
• 1x: Wenn das erste Bit des Datenbands 1 ist, hängen Sie das Bit xan das Datenband an.

Wir initialisieren das Datenband mit einer 1, gefolgt von den beiden Eingangsbits (die 1 ist erforderlich, da es keine Möglichkeit gibt, eine 1 zu erstellen, wenn das Datenband vollständig aus Nullen besteht), und wir verwenden das endgültig gelöschte Datenbit als Ausgangssignal des Gatters .

• 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 Bytes

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

Übernimmt Eingaben wie min(True,False)(oder als min(1,0)). Nutzt die Vorteile von Ausgaben, die nur den richtigen Truthy-Falsey-Wert haben müssen. Wann immer möglich, verwendet ein eingebautes, um eine kostspielige lambda. Ich habe Code verwendet, um nach integrierten Funktionen zu suchen, die funktionieren.

Mein Favorit ist {0:1}.get, woran ich von Hand gedacht habe. Das Wörterbuch {0:1}ordnet den Schlüssel 0dem Wert zu 1. Die getMethode verwendet einen Schlüssel und einen Standardwert und gibt den Wert aus, der mit dem Schlüssel übereinstimmt, oder den Standardwert, wenn es keinen solchen Schlüssel gibt. Die einzige Möglichkeit, ein auszugeben, 0ist as {0:1}.get(1,0)mit fehlendem Schlüssel 1und Standard 0. Man kann andere Varianten mit anderen Wörterbüchern bekommen, aber nur diese war die kürzeste.

built_in_names = list(__builtins__) 

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

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

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

func_names = built_in_names + object_method_names + additional_func_names

t=True
f=False

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

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

d={}

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

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

print total_length
print

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

Go (Spiel), 33 Steine, 73 Kreuzungen

Wenn Domino und Schach akzeptabel sind, dann ist dies. Auf einem 19x19 Go Board kann es nicht zu golfen sein. Also habe ich kleine rechteckige Bretter verwendet. Die Eingabe ist, ob die mit 1 und 2 markierten Steine ​​vorhanden sind. Die Ausgabe ist, ob Schwarz gewinnt. Es verwendet Area Scoring, 0,5 Komi, situative Superko, kein Selbstmord. Alles schwarz zu spielen. Einige erhalten mehrere Lösungen.

Weiß gewinnt (2, 1x5):

➊━━━➋

1 und 2 (3, 2x3):

➊◯➋
┗┷┛

1 und nicht 2 (2, 1x5):

╺➊━➁╸

1 (2, 1x5):

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

Nicht 1 und 2 (2, 1x5):

╺➋━➀╸

2 (2, 1x5):

╺➋➀━╸

1 x oder 2 (2, 2x3):

➀┯➁
┗┷┛

1 oder 2 (2, 1x5):

╺➊━➋╸
➀━━━➁

1 oder 2 (2, 1x4):

➊━━➋
╺➀➁╸

1 = 2 (2, 1x7):

╺━➀━➁━╸

Nicht 2 (2, 1x3):

➀➁╸

1 oder nicht 2 (2, 1x4):

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

Nicht 1 (2, 1x3)

➁➀╸

Nicht 1 oder 2 (2, 1x4):

➁➀━╸

1 und 2 (2, 1x3):

➊━➋

Schwarz gewinnt (2, 1x3):

➊➋╸
➀━➁
➊━➁

Diese Seite hat mir ein bisschen geholfen: http://www.mathpuzzle.com/go.html

Vielleicht könnte jemand eine 2-Stein-Lösung für 1 und 2 auf einem 1x9-Brett finden ...

Javascript ES6, 124 Bytes

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

Ich hasse Lambdas jetzt ernsthaft.

Retina , 62 39 Bytes

23 Bytes dank @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: 

Übernimmt die Eingabe als PQ.

Gibt eine ganze Zahl zwischen 0bis aus3 . 0ist falsch, andere sind wahr.

Erläuterung

Sie sind alle nur reguläre Ausdrücke .

Zum Beispiel 01|10nur Streichhölzer 01oder10 .

In 0000,2 wird niemals in der Eingabe enthalten sein, entspricht also niemals.

In 1111stimmt es mit der leeren Zeichenfolge überein, die es gibt 4.

Stapel Katzen , 67 + 64 = 131 Bytes

Beachten Sie, dass der +64 die -nmFlags auf jedes Programm anwendet . -nGibt numerische E / A an und -mspiegelt den Quellcode über das letzte Zeichen hinweg - nicht alle Übermittlungen benötigen diese Flags technisch, aber aus Gründen der Konsistenz und Einfachheit bewerte ich sie alle gleich.

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

()in Stack Cats prüft, ob ein Element positiv oder nicht positiv ist (dh 0 oder negativ), also verwenden wir das für Truthy / Falsy. Die zweite Spalte ist nur zur Information und listet die besten Gates mit 0/ 1s als Outputs auf (mit einer Gesamtpunktzahl von 90).

Die Eingabe erfolgt durch Trennzeichen getrennte Bits über STDIN. Probieren Sie es online!

Stack Cats ist eine reversible esoterische Sprache, in der Programme eine reflektierende Symmetrie aufweisen. Bei einem gegebenen Snippet f( >[[(!-)/zB \(-!)]]<) berechnet das Spiegelbild (zB ) die Inverse f^-1. Programme mit gerader Länge tun also nichts (oder bleiben in einer Endlosschleife stecken), und die einzigen nicht-trivialen Programme haben eine ungerade Länge und berechnen, f g f^-1wog sich der Center-Operator befindet.

Da der halbe Quellcode immer redundant ist, kann er weggelassen werden. Wenn Sie den Code mit dem -mFlag ausführen, sollte der Quellcode über das letzte Zeichen gespiegelt werden, um den tatsächlichen Quellcode abzurufen. Zum Beispiel ist das Programm *<Xtatsächlich*<X>* , was symmetrisch ist.

Golfen in Stack Cats ist höchst unintuitiv, daher mussten die oben genannten Programme mit brachialer Gewalt gefunden werden. Die meisten von ihnen sind überraschend komplex, aber ich werde ein paar erklären und diese Antwort ergänzen, wenn ich Zeit habe. Im Moment finden Sie einige Erklärungen und alternative Lösungen für die 0/ 1-Versionen im Github-Repository hier .

Haskell, 78 76 75 Bytes

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

Edit: -1 Byte dank @cole.

Brachylog , 36 34 Bytes

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)

Dies erwartet 0als falscher Wert und 1als wahrer Wert. Rückgabe trueoder false. p ist Inputund q ist Output.

Prolog, 147 145 Bytes

2 Bytes dank @SQB gewonnen

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

Fragen Sie x(P,Q).mit xdem entsprechenden Buchstaben und ab Pund Qsetzen Sie es auf 0 oder 1.
Gibt trueoder zurück false.

SWISH-Beispiel mit Tests - runTest.zum Ausführen eingeben .

NTFJ, 86 Bytes

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               #

Probieren Sie es hier aus!Aber lesen Sie zuerst unten.

Die Eingabe erfolgt implizit im Stapel. Ergebnis wird gestapelt. Fügen Sie 16 Bytes hinzu (jeweils eins *am Ende), wenn Sie 0 und 1 darstellen 0x00oder 0x01ausgeben möchten . Fügen Sie weitere 160 Bytes hinzu, wenn Sie eine 0oder eine 1gedruckte Ausgabe wünschen . ( ~~##~~~#{@Vor jeden stellen *.)

NTFJs einziger binärer Operator ist NAND, daher ist jeder dieser Operatoren in NAND-Form geschrieben.

Lassen Sie uns jeden von ihnen durchgehen.

0: falsch

~

~repräsentiert ein falsches Bit. Einfach genug. Da die Eingabe am unteren Rand des Stapels impliziert ist, wird diese am oberen Rand belassen.

1: p und q

|:|

NTFJ arbeitet auf einem Stapel. :ist der Befehl zum Duplizieren. Beobachten Sie das p and q≡ not (p nand q)und das 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

(Beachten Sie , dann, :|kann gesagt werden , daß die Negation und |:|kann gesagt werden , daß Verbindung )

2: p und nicht q

:||:|

Beachten Sie, dass dies nur eine Verneinung :|und eine Konjunktion ist |:|.

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

3: p

$

$Knallt einen Gegenstand vom Stapel. Also ... ja.

4: nicht p und q

#{:||:|

Dies ist dasselbe wie 2, außer mit #{am Anfang. #drückt 1 (das wahre Bit) und{ dreht den Stapel einmal nach links. Einfach genug.

5: q

#{$

Einmal nach links drehen, fallen lassen.

6: xor

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

Beobachten:

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

Es gibt jedoch keine Möglichkeit, den Stapel vollständig zu duplizieren. Also, wir gehen zu haben , die jeweils zu bringen p, qnach oben und es duplizieren.

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

Und so haben wir unsere xor.

7: p oder q

:|#{:||

Negieren Sie oben, bringen Sie unten nach oben, negieren Sie das und nanden Sie sie zusammen. Grundsätzlich p or q = (not p) nand (not q).

8: nicht p und nicht q

:|#{:||:|

Dies ist einfach die Verneinung von 7. Einfach.

9: Gl

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

Dies ist nur xnor oder nicht xor. Wieder einfach.

10: nicht q

#{$:|

Verneinung von 5.

11: p oder nicht q

#{:||

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

12: nicht p

$:|

Ablegen, anhalten und negieren.

13: nicht p oder q

:||

De Morgans Gesetze, um den Tag wieder zu retten! Gleicher Vorgang wie 11, nur negieren qstattp .

14: nicht p oder nicht q

|

Dies ist nur eine Mimik und.

15: wahr

#

# ist das wahre Stück.

Minecraft, 89 Blocks

In allen folgenden Fotos stehen blaue Blöcke für Eingang A und orange Blöcke für Eingang B

16. WAHRES Gatter - 1 Blöcke

15. NAND-Gatter - 1x2x3 = 6 Blöcke

14. A => B - 1x2x3 = 6 Blöcke

13. NICHT A - 2 Blöcke

12. B => A - 1x2x3 = 6 Blöcke

11. NICHT B - 2 Blöcke

10. XNOR - 1x3x4 = 12 Blöcke

9. NOR - 1x2x3 = 6 Blöcke

8. ODER - 1 Blöcke

7. XOR - 1x3x4 = 12 Blöcke

6. B - 1 Blöcke

5.! A & B - 1x2x5 = 10 Blöcke

4. A - 1 Blöcke

3. A &! B - 1x2x5 = 10 Blöcke

2. AND - 2x2x3 = 12 Blöcke

1. FALSE-1-Blöcke

Mathematica, 67 Bytes

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

Jedes dieser Elemente wird zu einer Funktion ausgewertet, sodass Sie sie wie folgt verwenden können

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

Ah, wenn in Mathematica nur ganze Zahlen wahr / falsch wären, könnten diese vier längeren erheblich verkürzt werden.

MATL, 34 23 Bytes

Ich hoffe, ich habe die Bestellung in Ordnung! Null ist falsch, Nicht-Null ist wahr. Jede Funktion nimmt zwei implizite Eingaben entgegen (obwohl einige Eingaben möglicherweise ignoriert werden). Die erste Eingabe ist A und die zweite ist B. Sie können 0/ 1für wahr / falsch oder T/ eingeben.F .

Hier ist ein TryItOnline Beispiel für Testfall 3.

4 Bytes mit *for andund weitere 4 mit >/ <anstelle von ~wY&/ w~Y&nachdem ich Dennis 'Antwort gesehen habe!

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)

Gleichstrom, 37 Bytes

dc("Tischrechner") ist ein Standard-Unix-Befehl, ein stapelbasierter Postfix-Rechner. Es fehlen Bitoperationen, und Vergleichsoperatoren können nur zum Ausführen von Makros verwendet werden (was die Bytes nicht wert ist). Die Ganzzahldivision macht einen Teil davon wieder wett.

Diese Skripte erwarten 0und 1Werte auf dem Stapel und lassen das Ergebnis auf dem Stapel.

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

Labyrinth , 85 Bytes

Danke an Sp3000 für das Speichern von 2 Bytes.

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

Bei all diesen Programmen handelt es sich um vollständige Programme, die zwei Ganzzahlen 0oder 1STDIN lesen (wobei ein beliebiges nicht-stelliges Trennzeichen verwendet wird) und das Ergebnis als 0oder 1an STDOUT ausgeben.

Probieren Sie es online!(Keine Testsuite, daher müssen Sie verschiedene Programme und Eingaben manuell ausprobieren.)

Die Erklärungen sind allesamt recht einfach. Alle Programme sind linear und die verwendeten Befehle führen Folgendes aus:

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

Beachten Sie, dass ich #immer verwende, um es mit zu kombinieren $, dh um zu berechnen XOR 1, oder mit anderen Worten für die logische Negation. Nur in wenigen Fällen konnte ich ~stattdessen verwenden, da die nachfolgenden &alle unerwünschten Bits aus dem resultierenden -1oder verwerfen -2.

IA-32 Maschinencode, 63 Bytes

Hexdump des Codes, bei der Demontage:

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;

Der Code ist länger als er sein könnte, da er eine Standardcodierungskonvention verwendet: Eingabe in ecxund edx, und Ausgabe in al. Dies kann in C als ausgedrückt werden

unsigned char __fastcall func(int, int);

Es scheint, dass MS Visual Studio den undokumentierten SALCOpcode nicht versteht , daher musste ich seinen Code anstelle des Namens verwenden.

Vielen Dank an l4m2 für die Verbesserung einiger Codebeispiele!

C 34 Bytes

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

Wobei n die zu verwendende Funktionsnummer ist, aber ich denke, es würde abgelehnt, also schlage ich diese andere vor:

C 244 Bytes (mit Speicher)

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

Es wird ein doppelt indiziertes Array verwendet. n[0][1]ist(A implies B)(0,1)

Viertens 138 Bytes

Ich habe gerade Forth gelernt. Ich nehme an, das ist Ansi Forth kompatibel, da es auch auf gforth läuft.

: 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

Die Funktion z erstellt eine neue Funktion mit dem angegebenen Namen und setzt die Logikgatternummer von der Stapelspitze auf die neue Funktionsadresse. Es belässt die nächste (n + 1) Logikgatterfunktion im Stapel für die nächste Deklaration.

Sie können es testen:
Und AB

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

("." print top of stack "cr" ist cariage return)

C 268 Bytes

#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 

Makros scheinen kürzer als Funktionen.

Brian & Chuck , 183 Bytes

Danke an Sp3000 für das Speichern von 4 Bytes.

Einige der Programme enthalten ein nicht druckbares Zeichen. Insbesondere sollte jeder \x01durch das <SOH>Steuerzeichen (0x01) ersetzt werden:

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

Die Eingabe und Ausgabe verwendet Bytewerte , daher sollte die Eingabe zwei 0x00- oder 0x01-Bytes (ohne Trennzeichen) und die Ausgabe ein solches Byte sein. Dies ist tatsächlich auch die sinnvollste Definition von Wahrhaftigkeit / Falschheit für B & C, da dies der einzige Kontrollflussbefehl ist? Nullen als falsch und alles andere als wahr ansieht.

Erklärungen

Zuerst eine kurze B & C-Grundierung:

• Jedes Programm besteht aus zwei Brainfuck-ähnlichen Instanzen, von denen jede in einer eigenen Zeile geschrieben ist. Wir nennen den ersten Brian und den zweiten Chuck . Die Hinrichtung beginnt bei Brian.
• Das Band jedes Programms ist der Quellcode des anderen Programms, und der Befehlszeiger jedes Programms ist der Bandkopf des anderen Programms.
• Nur Brian kann den ,Befehl (Input Byte) verwenden, und nur Chuck kann den Befehl (Input Byte) verwenden. Befehl (Ausgabebyte) verwenden.
• Brainfucks []Schleife existiert nicht. Stattdessen besteht der einzige Steuerungsfluss darin, ?die Steuerung auf die andere Instanz umzuschalten, wenn der aktuelle Wert unter dem Bandkopf ungleich Null ist.
• Zusätzlich zu >und <gibt es {und, }die im Wesentlichen den Brainfuck-Ausschnitten entsprechen, [<]und [>]sie bewegen den Bandkopf in diese Richtung zur nächsten Nullposition. Der Hauptunterschied besteht darin, dass {auch am linken Ende des Bandes angehalten werden kann, unabhängig davon, welchen Wert es hat.
• Der Einfachheit halber werden alle _s im Quellcode durch Null-Bytes ersetzt (da diese in nicht-trivialen Programmen sehr nützlich sind, um {und abzufangen }).

Beachten Sie, dass in allen Programmen das Band von Chuck mit a beginnt #. Das könnte wirklich alles sein. ?Arbeitet so, dass der Bandkopf eine Zelle vor dem Start der Ausführung verschiebt (sodass die Bedingung selbst nicht ausgeführt wird, wenn es sich zufällig um einen gültigen Befehl handelt). Wir können also niemals die erste Zelle von Chuck für Code verwenden.

Es gibt fünf Klassen von Programmen, die ich später genauer erläutern werde. Im Moment liste ich sie hier in der Reihenfolge der zunehmenden Komplexität auf.

0000, 1111: Konstante Funktionen

?
#>.

?
#>+.

Diese sind sehr einfach. Wir wechseln bedingungslos zu Chuck. Chuck bewegt den Bandkopf in die nicht verwendete Zelle nach rechts und druckt ihn entweder direkt oder inkrementiert ihn zuerst, um zu drucken1 .

0011, 0101, 1010, 1100: Funktionen in Abhängigkeit von nur einem Eingangs

,?\x01+?
#>.

,,?\x01+?
#>.

,,-?\x01+?
#>.

,-?\x01+?
#>.

Je nachdem, ob wir anfangen ,oder ,,mit Aoder arbeiten B. Schauen wir uns das erste Beispiel aussehen 0011(dh A). Nachdem wir den Wert gelesen haben, setzen wir ihn ?als Bedingung voraus. Wenn A = 1, wechselt dies zu Chuck, der den 1Bandkopf nach rechts bewegt und das buchstäblich eingebettete Byte druckt. Ansonsten bleibt die Kontrolle über Brian. Hier ist das 1-Byte ein No-Op. Dann inkrementieren wir die Eingabe mit +, um sicherzustellen, dass sie nicht Null ist, und wechseln dann mit zu Chuck ?. Verschiebt sich dieses Mal >in eine nicht verwendete Zelle rechts, die dann als gedruckt wird 0.

Um einen der Werte zu negieren, dekrementieren wir ihn einfach mit -. Dies verwandelt sich 1in 0und 0in -1, was von Null verschieden ist und daher in Bezug auf die Wahrheit ?.

0001, 0010, 0100, 1000: Binäre Funktionen mit einem truthy Ergebnis

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

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

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

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

Dies ist eine Erweiterung der vorherigen Idee, um mit zwei Eingängen zu arbeiten. Schauen wir uns das Beispiel von 1000(NOR) an. Wir lesen beide Eingaben (potentiell) mit ,?. Wenn einer von diesen ist 1, ?wechselt der zu Chuck. Er bewegt den Bandkopf zum Ende mit }(auf die leere Zelle nach Brians Code), bewegt eine andere Zelle mit >(immer noch Null) und druckt sie mit ..

Wenn jedoch beide Eingänge Null sind, liegt die Kontrolle weiterhin bei Brian. >Bewegt dann den Bandkopf so auf }, dass dieser Befehl nicht ausgeführt wird, wenn wir zu Chuck mit wechseln ?. Alles, was Chuck jetzt tut, ist, >.dass er sich nur auf die 1Zelle bewegt und diese druckt.

Wir können die anderen drei Funktionen leicht erhalten, indem wir einen oder beide Eingänge nach Bedarf negieren.

0111, 1011, 1101, 1110: Binäre Funktionen mit drei truthy Ergebnisse

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

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

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

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

Eine geringfügige Änderung der vorherigen Idee, um das Ergebnis zu negieren (dh drucken, 0wenn wir alle Brian und 1sonst durchlaufen haben ). Schauen wir uns 0111als Beispiel (ODER) an. Beachten Sie, dass das eingebettete 1Byte ein No-Op ist. Dies beginnt also immer noch mit ,?,?. Wenn einer der beiden Eingänge ist 1, wechseln wir zu Chuck, der den Bandkopf zum Anfang mit zurückbewegt {. Verschiebt den Bandkopf >.auf dieses 1Byte und druckt es aus.

Wenn beide Eingänge Null sind, bleiben wir bei Brian, schieben den Bandkopf auf {, überspringen ihn und wechseln dann zu Chuck. Wenn er >.diesmal ausführt, geht er nach Brians Code in die leere Zelle und druckt die 0.

Auch hier erhalten wir leicht die anderen Funktionen, indem wir einen oder beide Eingänge negieren.

0110, 1001: Binärfunktionen mit zwei wahrheitsgemäßen Ergebnissen

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

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

Dieser ist etwas kniffliger. Die vorherigen Funktionen waren relativ einfach, da sie kurzgeschlossen werden können - der Wert der ersten Eingabe kann die Ausgabe bestimmen, und wenn dies nicht der Fall ist, schauen wir uns die andere Eingabe an. Für diese beiden Funktionen müssen wir immer beide Eingänge betrachten.

Die Grundidee besteht darin, anhand der ersten Eingabe zu entscheiden, ob die zweite Eingabe zwischen 0und 1oder zwischen 1und wählen soll 0. Nehmen wir 0110als Beispiel (XOR):

Überlegen Sie A = 0. In diesem Fall wollen wir so ausgeben, Bwie es ist. ,liest A, ?tut nichts >bewegt sich auf die nächste Zelle (ungleich Null), so dass }wir zum _On Chuck gelangen. Hier lesen wir Bmit ,und verwenden ?wieder. Wenn Bwar 0auch, wir sind immer noch auf Brian. >überspringt die }auf Chuck und? schaltet so, dass der in Brian eingebettete Quellcode >.gedruckt wird 0. Wenn Bes 1andererseits war, führt Chuck das aus, }was sich bereits in _Brians Code bewegt, und gibt stattdessen >.das 1-byte aus.

Wenn A = 1ja, wechseln wir sofort zu Chuck, der dann hingerichtet wird }+{>?. Dies bewirkt, dass _in Brians Quellcode gewechselt wird, dieser ebenfalls in einen 1mit umgewandelt wird +, dann zum Anfang zurückgewechselt wird {und Brians übersprungen ?wird, indem eine Zelle nach rechts verschoben wird, >bevor die Steuerung an ihn zurückgegeben wird. Diesmal, nachdem Brian's gelesen Bhat B = 0, und Chuck >.die Zelle neben Brian's benutzt, ?wird's 1statt 0. Außerdem überspringt B = 1Chuck die }Lücke und bewegt sich bis zum Ende des Bandes, sodass >.stattdessen eine Null ausgegeben wird. Auf diese Weise drucken wir not B.

Um Äquivalenz zu implementieren, haben wir sie einfach negiert, Abevor wir sie als Bedingung verwendeten. Aus diesem Grund müssen wir >Chuck auch einen weiteren hinzufügen, um dies zu überspringen, -wenn wir zum Start zurückkehren.

ClojureScript, 88 84 76 74 Bytes

nilund falsesind falsch, alle anderen Werte sind wahr. Boolesche Werte erzwingen 0/1 für Arithmetik und Ungleichungen. Funktionen können die falsche Anzahl von Argumenten annehmen.

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 Bytes

Der Ein- / Ausgang verwendet U + 0000 und U + 0001.

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

Brain-Flak , 418 , 316 Bytes

Probieren Sie es online!

Lassen Sie die Eingaben die oberen zwei Zahlen auf dem Stapel zu Beginn des Programms sein (Null für falsche Eins für wahr) und die Ausgabe am Ende des Programms die oberste Stelle des Stapels sein (Null für falsch, sonst für wahr).

false, 4 Bytes (Mit freundlicher Genehmigung von Leaky Nun )

(<>)

und 36 Bytes

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

A und nicht B, 40 Bytes

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

A, 6 Bytes

({}<>)

nicht A und B, 38 Bytes

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

B, 2 Bytes

{}

xoder 34 Bytes

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

oder 6 Bytes

({}{})

noch 34 Bytes

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

xnoder 10 Bytes

({}{}[()])

nicht B, 34 Bytes

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

B impliziert A, 14 Bytes

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

nicht A, 34 Bytes

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

A impliziert B, 16 Bytes

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

und 12 Bytes

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

wahr, 6 Bytes

<>(())

Erläuterung

Da die meisten davon sehr ähnlich sind, werde ich nicht genau erklären, wie sie funktionieren. Ich gebe mein Bestes, um zu verdeutlichen, wie alle 16 funktionieren.

Erstens sind es die Gates, die drei mit demselben Wert zurückgeben (dh 2, 3, 5, 8, 9, 12, 14 und 15). Diese folgen alle dem gleichen Muster. Zuerst konvertieren Sie den Eingang in eine Zwei-Bit-Zahl mit a als Zweierstelle und B als Einsen. Dies geschieht mit diesem Snippet (({}){}{}). Anschließend subtrahieren Sie den Wert des Zwei-Bit-Eingangs, den Sie isolieren möchten ({}[value]). (Im eigentlichen Code werden die Subtraktion und die Konvertierung in einem Schritt durchgeführt, um Bytes zu sparen). Dies kann mit einem nicht kombiniert werden , wenn nötig: (({}<(())>)){{}{}(((<{}>)))}{}{}.

Weiter oben: und, noch oder, xor und xnor. Diese funktionieren ähnlich wie oben. Einige davon sind oben aufgeführt, diese Methode ist jedoch kürzer. Der Trick, den ich hier verwendet habe, ist, dass diese jeweils einer Summe von A B entsprechen. Beispiel: xor ergibt true, wenn A + B = 1, andernfalls false. Zuerst addieren Sie AB und subtrahieren den entsprechenden Betrag. Ausgedrückt als ({}{}[0,1,2 or 3]). Führen Sie dann ggf. ein Nein durch

Als nächstes: A, B, nicht A und nicht B. Diese sind so ziemlich selbsterklärend. Zuerst entfernen wir den unnötigen Wert und dann negieren wir ihn oder beenden ihn.

Zuletzt sind die zwei Simpletons: wahr und falsch. Für diese pushen wir den korrekten Wert auf den Off-Stack. Der <>Nullpunkt gibt Null zurück, sodass wir zwei Bytes sparen können, indem wir den Schalter als Nullwert verwenden.

Es ist nicht die effizienteste Lösung (vielleicht die effizienteste in Brain-Flak), aber ich hatte viel Spaß beim Schreiben und ich flehe Sie an, diese zu verkürzen.

ProgFk , 18,5 - 17,5 Bytes

Da die Anweisungen von ProgFk in Halbbytes angegeben sind, wird der folgende Code hexadezimal, mit einem Logikgatter pro Zeile und mit Leerzeichen zwischen den Bytes angegeben.

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

Erläuterung

ProgFk ist ein bandbasierter Esolang (ähnlich wie Brainfuck), bei dem jede Zelle ein Bit ist und Anweisungen als Nibbles (4 Bytes) angegeben werden. Befehle wirken auf die Zelle, auf die der Befehlszeiger zeigt. Die Eingabe wird in den ersten und zweiten Zellen gegeben (mit Aund Bwobei den ersten und zweiten Zellen jeweils), und der Befehlszeiger beginnt bei der ersten Zelle. Die Ausgabe wird in der ersten Zelle gespeichert.

Jeder verwendete Befehl wird unten erklärt.

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.

Dank @LeakyNun ein Byte gespeichert!

Eigentlich 24 Bytes

Diese Programme nehmen Eingaben als A\nB(mit \nDarstellung einer neuen Zeile) an, wobei B oben auf dem Stapel und A unten verbleibt. Falsewird dargestellt durch 0und Truewird dargestellt durch eine beliebige positive ganze Zahl.

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

Danke an Leaky Nun für 3 Bytes