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>
Antworten:
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
True
oder1False
oder0100%
Tore
644343151132171376761615TL; 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
xor xnor nand
xnor
und hinzugefügtxor
xor
undxnor
). Für das Blockieren auf Tabletop ist nur 1 Domino anstelle von 2 erforderlich.quelle
Hexagony , 89 Bytes
Vielen Dank an FryAmTheEggman für die notwendige Inspiration für die XOR-Lösung.
Alle Programme verwenden
0
für falsch und1
fü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
: FalschIch 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
: UndDies 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ürA = 0
und das grüne Diagramm fürA = 1
:Wie Sie sehen können, wenn das
A
ist0
, dann drucken wir es einfach und beenden (denken Sie daran , dass alle.
No-ops sind). Wenn diesA
jedoch1
der Fall ist, durchläuft die IP die erste Zeile erneut und liestB
und 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: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 BDies 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 Bezeichnung0
to geliefert5
, die in den sechs Ecken des Rasters beginnen und entlang ihrer Kante im Uhrzeigersinn zeigen (und das Programm beginnt immer mit IP0
). Wenn a#
angetroffen wird, wird der aktuelle Wert modulo genommen6
und 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 = 0
ist das Programm ziemlich einfach, weil der Wert immer0
dann#
ist, wenn es auftritt, so dass keine IP-Umschaltung stattfindet:#
tut nichts,?
liestA
(dh tut auch nichts),#
tut immer noch nichts,!
druckt das0
,)
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ügt1
. Wir sehen, dass nach dem?
LesenA
(1
dieses Mal)#
auf die IP umgeschaltet wird, die in der oberen rechten Ecke beginnt. Das heißt?
kann lesenB
(0
). Nun)
inkrementiert das zu1
, so dass die#
in der oberen linken Ecke nichts macht und wir bei IP bleiben1
. Der!
Ausdruck1
und 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
1
und)
erhöht ihn auf2
. Das heißt, die#
in der oberen linken Ecke veranlasst einen weiteren IP-Switch auf IP2
, blau anzuzeigen. Auf diesem Weg erhöhen wir ihn zuerst weiter3
(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ückgegeben0
,!
gedruckt und@
das Programm beendet.Dies ist insbesondere die einzige 6-Byte-Lösung für dieses Gate.
0011
: EINDies ist so einfach, dass wir kein Diagramm benötigen:
?
LiestA
,!
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 ADieser ist viel einfacher als sein "Bruder"
0010
. Der Kontrollfluss ist tatsächlich derselbe, den wir oben für0001
(Und) gesehen haben. Wenn jaA = 0
, dann überquert die IP die untere Zeile und liestB
und druckt diese, bevor sie beendet wird. WennA = 1
dann die IP die erste Zeile erneut durchläuft und ebenfalls liestB
, werden jedoch+
zwei nicht verwendete Speicherflanken hinzugefügt, sodass nur der aktuelle Wert auf zurückgesetzt wird0
, sodass!
immer gedruckt wird0
.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 aus1
), 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
: BWoohoo, ein anderes einfaches: lesen
A
, lesenB
, druckenB
, beenden. Es gibt jedoch tatsächlich Alternativen dazu. DaA
es 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
: XorWie 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 = 0
der Kontrollfluss ziemlich einfach ist (weil wir in diesem Fall nur drucken müssenB
):Wir beginnen auf dem roten Weg.
?
liestA
,<
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.?
liestB
,!
druckt es. Jetzt(
dekrementiert es. Dies ist wichtig, da sichergestellt wird, dass der Wert nicht positiv ist (entweder0
oder-1
jetzt). Das macht IP-Wrap in die rechte Ecke, wo@
das Programm beendet wird.Wenn
A = 1
es etwas kniffliger wird. In diesem Fall möchten wir druckennot 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,B
wenn 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 tauscht0
und1
und daher berechnetnot 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
: OderMehr Kurzschluss.
Der
A = 0
Fall (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ückB
. Es wickelt dann an die großen rechten Ecke, drucktB
mit!
und beendet.Der
A = 1
Fall (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
: NochDies könnte mein Lieblingsprogramm sein, das in dieser Suche gefunden wurde. Das Coolste ist, dass diese Implementierung
nor
tatsä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 ,
1
so dass der#
IP-1
Pfad, 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 a1
, 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 Wert1
der ersten Iteration, sodass die IP in die linke Ecke übergeht und stattdessen auf dem grünen Pfad fortgesetzt wird.!
druckt es einfach aus1
und@
beendet das Programm.Was ist nun, wenn einer der Eingänge ist
1
?Dann
?
liest man das1
irgendwann und)
erhöht es auf2
. 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 die0
auf der unbenutzten Kante und#
wechselt zurück zu IP0
. 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:
1001
: GleichberechtigungDies nutzt auch die bedingte IP-Auswahl sehr geschickt aus. Wir müssen wieder zwischen
A = 0
und unterscheidenA = 1
. Im ersten Fall möchten wir druckennot B
, im zweiten möchten wir druckenB
. DennA = 0
wir unterscheiden auch die beiden Fälle fürB
. Beginnen wir mitA = 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 liestA
mit?
.(
dekrementiert das, so dass wir bekommen-1
und IP in die untere linke Ecke umbrechen. Nun, wie ich bereits sagte,#
nimmt der Wert Modulo6
vor der Auswahl der IP, so dass ein Wert von-1
IP tatsächlich rauskommt5
, der in der linken Ecke auf dem roten Pfad beginnt.?
liestB
,(
dekrementiert das auch so, dass wir auf IP bleiben,5
wenn wir#
erneut schlagen .~
negiert das,-1
so dass die IP in die untere rechte Ecke umbrochen wird, druckt das1
und endet.Wenn dies stattdessen der Fall
B
ist1
, wird der aktuelle Wert0
beim#
zweiten Mal angezeigt, sodass wir wieder zu IP wechseln0
(jetzt auf dem grünen Pfad). Das trifft?
ein drittes Mal, gibt nach0
,!
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 nie5
in erster Linie auf IP . Wir fahren einfach sofort auf dem grünen Weg weiter.?
Jetzt gibt es nicht nur eine Null, sondern kehrtB
stattdessen 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 BDieser ist ziemlich einfach. Der Ausführungspfad ist der horizontale Zweig, den wir bereits
and
früher kennen.??
liestA
und dann sofortB
. Nachdem wir überlegt|
und verzweigt haben, werdenB = 0
wir den untersten Zweig ausführen, in dem)
der Wert erhöht wird, um den1
dann gedruckt wird!
. Auf dem oberen Ast (wennB = 1
) wird?
einfach die Kante zurückgesetzt, auf0
die dann auch durch gedruckt wird!
.Es gibt acht 6-Byte-Programme für dieses Gatter. Vier davon sind ziemlich gleich und verwenden entweder
>
statt|
oder1
statt)
(oder beides):Zwei verwenden ein einzelnes,
?
das aufgrund eines Spiegels zweimal verwendet wird. Die Verneinung geschieht dann wiexor
bei entweder(~
oder~)
.Und schließlich verwenden zwei Lösungen einen bedingten IP-Switch, denn warum auf einfache Weise, wenn der gewundene auch funktioniert:
1011
: B impliziert AHierfür wird ein ziemlich aufwändiges IP-Switching verwendet. Ich werde
A = 1
dieses Mal mit dem Fall beginnen, weil es einfacher ist:Wir beginnen auf dem grauen Pfad, der liest
A
mit?
und trifft dann auf die#
. DaA
ist1
diese IP - Schalter1
(grüner Pfad). Der!
druckt sofort das, die IP bricht nach links oben ab, liestB
(unnötig) und bricht ab.Wenn
A = 0
es ein bisschen interessanter wird. Betrachten wir zuerstA = B = 0
:Diesmal
#
macht der nichts und wir bleiben auf IP0
(roter Pfad von diesem Punkt an).?
liestB
und1
verwandelt es in eine1
. Nachdem wir in die obere linke Ecke gewickelt haben, schlagen wir#
erneut zu, sodass wir schließlich auf dem grünen Pfad landen und1
vor 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ück1
. Jetzt begegnen wir dem1
. 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 dieseB = 1
tatsächlich dem Wert zugeordnet sind11
. Wenn wir also drücken#
, wird dies als Modulo genommen6
,5
und daher wechseln wir zu IP5
(anstatt1
wie 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:
1100
: KeinNur eine einfache lineare: Lesen
A
mit?
, Negieren mit(~
, Drucken mit!
, Beenden mit@
.Es gibt eine alternative Lösung, und die negiert
~)
stattdessen mit:1101
: A impliziert BDies 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
. WennA
ja0
, wird es einfach1
auf den unteren Zweig erhöht und gedruckt. Andernfalls wird die oberste Verzweigung erneut ausgeführt, wobei diese stattdessen?
gelesenB
und 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,
and
und wir können auch wählen zwischen)
und1
: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
)
und1
für einige dieser Optionen:1110
: NandDas letzte komplizierte. Wenn Sie noch lesen, haben Sie es fast geschafft. :) Lass uns zuerst schauen
A = 0
:?
liestA
und 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 jedochA
heißt0
, tut dies nichts.)
erhöht es1
so, dass die IP auf dem unteren Pfad fortgesetzt wird, auf dem das1
gedruckt 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 - Switch1
(grüne Strecke), aber daB
ist0
man zurück zu IP wechseln ,0
wenn wir schlagen#
ein zweites Mal (jetzt blau - Pfad), wo er druckt1
wie zuvor.Schließlich der
A = B = 1
Fall:Dieses Mal, wenn wir
#
das zweite Mal, ist der aktuelle Wert immer noch1
so, 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
1
anstelle von)
:Dann gibt es zwei Lösungen, die Ihnen bei der Menge an IP-Switching helfen:
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):
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:
1111
: WahrSie 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 .
quelle
APL,
222018 BytesDie wahren und falschen Einträge sind vollständige Programme, und die anderen 14 sind Funktionen. (Danke an Adám.)
Probieren Sie es hier aus.
quelle
0
und machen1
.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:
quelle
Jelly , 19 Bytes
Probieren Sie es online!
quelle
¤
und¬
sind 2 Bytes, nicht 1.0 0 1 0 > 1 byte Greater than.
würde dies nicht scheitern, wenn der zweite Eingang negativ wäre?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.
quelle
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 Bitx
an 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 .
false
):001
and
):1001001
A and not B
):0110100
A
):1001
not A and B
):0100
B
):0
xor
):0110110010
or
):0110
nor
):1101001000
xnor
):110101001100
not B
):1100100
B implies A
):110101101000
not A
):11010000
A implies B
):11010011001
nand
):10110100100010
true
):1100
quelle
1
auffalse
erforderlich?0
an das Band anhängen , damit es zuletzt gelöscht werden kann.Python 2, 137 Bytes
Übernimmt Eingaben wie
min(True,False)
(oder alsmin(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 kostspieligelambda
. 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üssel0
dem Wert zu1
. Dieget
Methode 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,0
ist as{0:1}.get(1,0)
mit fehlendem Schlüssel1
und Standard0
. Man kann andere Varianten mit anderen Wörterbüchern bekommen, aber nur diese war die kürzeste.quelle
__lt__
oder verwenden__eq__
? Dies wird die Anzahl der Bytes weiter verringern:int.__gt__
stattlambda a,b:b<1
,int.__eq__
stattlambda a,b:a==b
und so weiterint
s Vergleiche nach auslagertcmp
. Ich habe dies nicht für Python 3not
für0001
,False
- ideonenot
entspricht nicht den Anforderungen einer Funktion, weil Sie nicht tun könnenf=not;f(3,4)
. Die Zeichenfolgenot
funktioniert zufällig, weil die angeblichen Funktionsargumente wie Tupel aussehen, genauso wie3+
sie funktionieren würden3+(4)
, obwohl sie3+
keine Funktion sind, die4
als Eingabe verwendet werden kann.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 ...
quelle
Javascript ES6, 124 Bytes
Ich hasse Lambdas jetzt ernsthaft.
quelle
a=>b=>0
zua=>0
und sagt , dass die Grammatik nennt es ist(a=>0)(a,b)
, nur für die 4 Einträge.Math.min
statta=>b=>a&b
.Math.max
statta=>b=>a|b
.Math.pow
statta=>b=>a>=b
.parseInt
anstelle von tuna=>b=>a>b
.!NaN
=>true
,!!NaN
=>false
Retina ,
6239 Bytes23 Bytes dank @MartinEnder !
Übernimmt die Eingabe als
PQ
.Gibt eine ganze Zahl zwischen
0
bis aus3
.0
ist falsch, andere sind wahr.Erläuterung
Sie sind alle nur reguläre Ausdrücke .
Zum Beispiel
01|10
nur Streichhölzer01
oder10
.In
0000
,2
wird niemals in der Eingabe enthalten sein, entspricht also niemals.In
1111
stimmt es mit der leeren Zeichenfolge überein, die es gibt4
.quelle
^1|0$
sollte nur 1 Zeichenketten entsprechen. Was ist hier los?1
am Anfang der Eingabe] ODER [0
am Ende der Eingabe]. Ich^1|0$
ist schwerer zu lesen als1.|.0
. Scheint das Lesen insgesamt schwieriger zu machenStapel Katzen , 67 + 64 = 131 Bytes
Beachten Sie, dass der +64 die
-nm
Flags auf jedes Programm anwendet .-n
Gibt numerische E / A an und-m
spiegelt 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.()
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 mit0
/1
s 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 Inversef^-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^-1
wog
sich der Center-Operator befindet.Da der halbe Quellcode immer redundant ist, kann er weggelassen werden. Wenn Sie den Code mit dem
-m
Flag ausführen, sollte der Quellcode über das letzte Zeichen gespiegelt werden, um den tatsächlichen Quellcode abzurufen. Zum Beispiel ist das Programm*<X
tatsä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 .quelle
Note that the +64 is from applying the -nm flags to each program.
3 * 16 = 48 oder 2 * 16 = 32, so oder so 64 ist so oder so haiHaskell,
787675 Bytes_#_=2<1
&&
>
pure
<
_#b=b
/=
||
(not.).max
==
_#b=not b
>=
a#_=not a
<=
(not.).min
_#_=1<2
Edit: -1 Byte dank @cole.
quelle
_#_
ist kein Standardoperator!" Und dann wurde mir klar ... Gut gemacht.pure
pure
wurdePrelude
2015 eingeführt und war zum Zeitpunkt dieser Herausforderung verfügbar.Brachylog ,
3634 BytesDies erwartet
0
als falscher Wert und1
als wahrer Wert. Rückgabetrue
oderfalse
. p istInput
und q istOutput
.quelle
Input
undOutput
nach Konvention bezeichnet werden. Sie können jedoch Werte für beide festlegen oder Werte von beiden zurückgeben.Prolog,
147145 Bytes2 Bytes dank @SQB gewonnen
Fragen Sie
x(P,Q).
mitx
dem entsprechenden Buchstaben und abP
undQ
setzen Sie es auf 0 oder 1.Gibt
true
oder zurückfalse
.SWISH-Beispiel mit Tests -
runTest.
zum Ausführen eingeben .quelle
a(2,2).
falsch?a(a,a).
(oder jeder andere Buchstabe) auch unda
ist keine akzeptable Eingabe für die Wahrheit, also ist das gut. Danke für den Vorschlag.NTFJ, 86 Bytes
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 darstellen0x00
oder0x01
ausgeben möchten . Fügen Sie weitere 160 Bytes hinzu, wenn Sie eine0
oder eine1
gedruckte 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 dasp and q
≡not (p nand q)
und dasnot q = q nand 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|:|
.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:
Es gibt jedoch keine Möglichkeit, den Stapel vollständig zu duplizieren. Also, wir gehen zu haben , die jeweils zu bringen
p
,q
nach oben und es duplizieren.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
q
stattp
.14: nicht p oder nicht q
Dies ist nur eine Mimik und.
15: wahr
#
ist das wahre Stück.quelle
:|
?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
quelle
Mathematica, 67 Bytes
Jedes dieser Elemente wird zu einer Funktion ausgewertet, sodass Sie sie wie folgt verwenden können
Ah, wenn in Mathematica nur ganze Zahlen wahr / falsch wären, könnten diese vier längeren erheblich verkürzt werden.
quelle
MATL,
3423 BytesIch 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
/1
für wahr / falsch oderT
/ eingeben.F
.Hier ist ein TryItOnline Beispiel für Testfall 3.
4 Bytes mit
*
forand
und weitere 4 mit>
/<
anstelle von~wY&
/w~Y&
nachdem ich Dennis 'Antwort gesehen habe!quelle
-
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
0
und1
Werte auf dem Stapel und lassen das Ergebnis auf dem Stapel.quelle
Labyrinth , 85 Bytes
Danke an Sp3000 für das Speichern von 2 Bytes.
Bei all diesen Programmen handelt es sich um vollständige Programme, die zwei Ganzzahlen
0
oder1
STDIN lesen (wobei ein beliebiges nicht-stelliges Trennzeichen verwendet wird) und das Ergebnis als0
oder1
an 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:
Beachten Sie, dass ich
#
immer verwende, um es mit zu kombinieren$
, dh um zu berechnenXOR 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-1
oder verwerfen-2
.quelle
IA-32 Maschinencode, 63 Bytes
Hexdump des Codes, bei der Demontage:
Der Code ist länger als er sein könnte, da er eine Standardcodierungskonvention verwendet: Eingabe in
ecx
undedx
, und Ausgabe inal
. Dies kann in C als ausgedrückt werdenEs scheint, dass MS Visual Studio den undokumentierten
SALC
Opcode nicht versteht , daher musste ich seinen Code anstelle des Namens verwenden.Vielen Dank an l4m2 für die Verbesserung einiger Codebeispiele!
quelle
1110 8D4411FE LEA EAX, [ECX+EDX-2]
C 34 Bytes
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)
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.
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
("." print top of stack "cr" ist cariage return)
quelle
C 268 Bytes
Makros scheinen kürzer als Funktionen.
quelle
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
\x01
durch das<SOH>
Steuerzeichen (0x01) ersetzt werden: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:
,
Befehl (Input Byte) verwenden, und nur Chuck kann den Befehl (Input Byte) verwenden.
Befehl (Ausgabebyte) verwenden.[]
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.>
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._
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 FunktionenDiese 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 drucken
1
.0011
,0101
,1010
,1100
: Funktionen in Abhängigkeit von nur einem EingangsJe nachdem, ob wir anfangen
,
oder,,
mitA
oder arbeitenB
. Schauen wir uns das erste Beispiel aussehen0011
(dhA
). Nachdem wir den Wert gelesen haben, setzen wir ihn?
als Bedingung voraus. WennA = 1
, wechselt dies zu Chuck, der den1
Bandkopf 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 wird0
.Um einen der Werte zu negieren, dekrementieren wir ihn einfach mit
-
. Dies verwandelt sich1
in0
und0
in-1
, was von Null verschieden ist und daher in Bezug auf die Wahrheit?
.0001
,0010
,0100
,1000
: Binäre Funktionen mit einem truthy ErgebnisDies 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 ist1
,?
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 die1
Zelle 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 ErgebnisseEine geringfügige Änderung der vorherigen Idee, um das Ergebnis zu negieren (dh drucken,
0
wenn wir alle Brian und1
sonst durchlaufen haben ). Schauen wir uns0111
als Beispiel (ODER) an. Beachten Sie, dass das eingebettete1
Byte ein No-Op ist. Dies beginnt also immer noch mit,?,?
. Wenn einer der beiden Eingänge ist1
, wechseln wir zu Chuck, der den Bandkopf zum Anfang mit zurückbewegt{
. Verschiebt den Bandkopf>.
auf dieses1
Byte 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 die0
.Auch hier erhalten wir leicht die anderen Funktionen, indem wir einen oder beide Eingänge negieren.
0110
,1001
: Binärfunktionen mit zwei wahrheitsgemäßen ErgebnissenDieser 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
0
und1
oder zwischen1
und wählen soll0
. Nehmen wir0110
als Beispiel (XOR):Überlegen Sie
A = 0
. In diesem Fall wollen wir so ausgeben,B
wie es ist.,
liestA
,?
tut nichts>
bewegt sich auf die nächste Zelle (ungleich Null), so dass}
wir zum_
On Chuck gelangen. Hier lesen wirB
mit,
und verwenden?
wieder. WennB
war0
auch, wir sind immer noch auf Brian.>
überspringt die}
auf Chuck und?
schaltet so, dass der in Brian eingebettete Quellcode>.
gedruckt wird0
. WennB
es1
andererseits war, führt Chuck das aus,}
was sich bereits in_
Brians Code bewegt, und gibt stattdessen>.
das1
-byte aus.Wenn
A = 1
ja, wechseln wir sofort zu Chuck, der dann hingerichtet wird}+{>?
. Dies bewirkt, dass_
in Brians Quellcode gewechselt wird, dieser ebenfalls in einen1
mit 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 gelesenB
hatB = 0
, und Chuck>.
die Zelle neben Brian's benutzt,?
wird's1
statt0
. Außerdem überspringtB = 1
Chuck die}
Lücke und bewegt sich bis zum Ende des Bandes, sodass>.
stattdessen eine Null ausgegeben wird. Auf diese Weise drucken wirnot B
.Um Äquivalenz zu implementieren, haben wir sie einfach negiert,
A
bevor 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.quelle
ClojureScript,
88 84 7674 Bytesnil
undfalse
sind 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.quelle
0
falsch?not not(0)
zum Beispiel zu ausFalse
, was der Falsey-Wert ist.#f
,f
,false
, usw.) ist falsch. Alle anderen Werte sind in den meisten funktionalen Sprachen wahr.Brainfuck ,
184178174 BytesDer Ein- / Ausgang verwendet U + 0000 und U + 0001.
quelle
0001
das nicht einfach tun,[,>]<.
(wenn Sie einen Interpreter haben, der es Ihnen ermöglicht, links von der Startzelle zu gehen)?Brain-Flak ,
418, 316 BytesProbieren 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 durchAls 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.
quelle
(<>)
ist genug fürfalse
; Auch(<{}{}>)
ist 8 Bytes(<>)
verlässt die Eingänge und setzt die Null auf den anderen Stapel.<>
Reicht das nicht fürfalse
implizite Nullen? Auch ich denke dasa
kann das leere Programm sein.true
kann sein<>[][]
(speichert keine Bytes, sieht aber cool aus: P).ProgFk ,
18,5 -17,5 BytesDa 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.
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
A
undB
wobei 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.
Dank @LeakyNun ein Byte gespeichert!
quelle
Eigentlich 24 Bytes
Diese Programme nehmen Eingaben als
A\nB
(mit\n
Darstellung einer neuen Zeile) an, wobei B oben auf dem Stapel und A unten verbleibt.False
wird dargestellt durch0
undTrue
wird dargestellt durch eine beliebige positive ganze Zahl.Danke an Leaky Nun für 3 Bytes
quelle