Eingabe: Zwei Ganzzahlen. Vorzugsweise werden Dezimalzahlen verwendet, es können jedoch auch andere Formen von Zahlen verwendet werden. Diese können dem Code in der Standardeingabe, als Argumente für das Programm oder die Funktion oder als Liste übergeben werden.

Ausgabe: Ihre Summe. Verwenden Sie für Ausgabe-Ganzzahlen dasselbe Format wie für Eingabe-Ganzzahlen. Zum Beispiel 5 16würde die Eingabe zur Ausgabe führen 21.

Einschränkungen: Keine Standardlücken bitte. Dies ist Code-Golf , Antwort in der niedrigsten Anzahl von Bytes gewinnt.

Anmerkungen: Dies sollte ziemlich trivial sein, es interessiert mich jedoch zu sehen, wie es implementiert werden kann. Die Antwort kann ein vollständiges Programm oder eine Funktion sein. Bitte geben Sie an, um welches es sich handelt.

Testfälle:

1 2 -> 3
14 15 -> 29
7 9 -> 16
-1 8 -> 7
8 -9 -> -1
-8 -9 -> -17

Oder als CSV:

a,b,c
1,2,3
14,15,29
7,9,16
-1,8,7
8,-9,-1
-8,-9,-17

Bestenliste

var QUESTION_ID=84260,OVERRIDE_USER=8478;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+)(?=[^\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>

Gelee , 1 Byte

+

Probieren Sie es online!

Funktioniert auch in 05AB1E, Actually, APL, Braingolf, ,,, (Kommata), Factor, Forth, Implicit, J, Julia, K, Kdb, Keg, Ly, MATL, Pyke, Deorst und Q.

Minecraft 1.10, 221 Zeichen (nicht konkurrierend)

Sehen Sie, damit müssen wir uns befassen, wenn wir Minecraft-Karten erstellen.

Nebenbei: Es gibt keine Möglichkeit, in Minecraft eine Zeichenfolge einzugeben. Ich betrüge also ein bisschen, indem ich Sie dazu bringe, die Zahlen in das Programm selbst einzugeben. (Es ist einigermaßen gerechtfertigt, da bei einigen Karten, wie z. B. Minecraft Bingo von Lorgon111, Befehle kopiert und in den Chat eingefügt werden müssen, um eine Zahl einzugeben.)

Vielen Dank für den Block Labels MCEdit Filter.

scoreboard objectives add a dummy
scoreboard players set m a 6
scoreboard players set n a 8
scoreboard players operation r a += m a
scoreboard players operation r a += n a
tellraw @a {"score":{"name":"r","objective":"a"}}

Nicht konkurrierend aufgrund von Schwierigkeiten bei der Eingabe, und ich habe keine Ahnung, wie man Bytes in diesem Ding zählt (das Blytes-System ist fehlerhaft für Befehlsblöcke).

Binäre Lambda-Rechnung , 4,125 Bytes

Eingabe und Ausgabe als Kirchenzahlen .

00000000 01011111 01100101 11101101 0

Im Lambda-Kalkül ist es λ m . λ n . λ f . λ x . m f ( n f x ).

De Bruijn-Index : λ λ λ 4 2 (3 2 1)

Die Lambda-Rechnung ist eine prägnante Methode zur Beschreibung einer Abbildung (Funktion).

Zum Beispiel kann diese Aufgabe als λ x geschrieben werden . λ y . x + y

Zu beachten ist, dass dies kein Lambda (Funktion) ist, das zwei Argumente akzeptiert. Dies ist eigentlich ein verschachtelter Lambda. Es verhält sich jedoch wie ein Lambda, das zwei Argumente akzeptiert, sodass es informell als solches beschrieben werden kann. Jedes Lambda enthält formal nur ein Argument.

Wenn wir zum Beispiel dieses Lambda auf 3 und 4 anwenden:

(& lgr; x . & lgr; y . x + y ) 3 4 ≤ (& lgr; y . 3 + y ) 4 ≤ 3 + 4 = 7

Das erste Lambda gibt also tatsächlich ein anderes Lambda zurück.

Kirchenzahlen sind eine Möglichkeit, die zusätzlichen Zeichen zu beseitigen, indem nur Lambda-Symbole und -Variablen übrig bleiben.

Jede Zahl im Kirchensystem ist tatsächlich ein Lambda, das angibt, wie oft die Funktion auf einen Gegenstand angewendet wird.

Sei die Funktion f und der Gegenstand x .

Die Zahl 1 würde also λ f entsprechen . λ x . f x , was bedeutet, dass f genau einmal auf x angewendet wird.

Die Zahl 3 wäre beispielsweise λ f . λ x . f ( f ( f x )), was bedeutet, dass f genau dreimal auf x angewendet wird.

Wenn Sie also zwei Church-Ziffern (z. B. m und n ) addieren , ist dies dasselbe wie das Anwenden von f auf x , m + n .

Wir können beobachten , dass dies die gleichen wie erste Anwendung ist f auf x , n - mal, und dann die Anwendung f auf den resultierenden Punkt m mal.

Zum Beispiel 2 würde bedeuten f(f(x))und 3 würde bedeuten f(f(f(x))), so 2 + 3 sein würde f(f(f(f(f(x))))).

Zur Anwendung f auf x , n - mal, haben wir n f x .

Sie können m und n als Funktionen anzeigen , die informell zwei Argumente annehmen.

Dann wenden wir f erneut auf diesen resultierenden Gegenstand an, m mal: m f ( n f x ).

Dann addieren wir die Kesselplatte zurück, um λ m zu erhalten . λ n . λ f . λ x . m f ( n f x ).

Jetzt müssen wir es in den De Bruijn-Index konvertieren .

Erstens zählen wir den "relativen Abstand" zwischen jeder Variablen zur Lambda-Deklaration. Zum Beispiel hätte das m einen Abstand von 4, weil es als 4 Lambda "vor" deklariert wird. In ähnlicher Weise hätte das n einen Abstand von 3, das f hätte einen Abstand von 2 und das x hätte einen Abstand von 1.

Also schreiben wir es als diese Zwischenform: λ m . λ n . λ f . λ x . 4 2 (3 2 1)

Dann entfernen wir die Variablendeklarationen und hinterlassen: λ λ λ 4 2 (3 2 1)

Jetzt konvertieren wir es in eine binäre Lambda-Rechnung .

Die Regeln sind:

• λ wird 00.
• m n (Gruppierung) wird 01 m n.
• Zahlen i wird 1 i mal + 0, zum Beispiel 4 wird 11110.

λ λ λ λ 4 2 (3 2 1)

Λ λ λ λ 11110 110( 1110 110 10)

Λλλλ 11110 110 0101 111011010

Λλλλ 0101 111101100101111011010

≡ 00 00 00 00 0101 111101100101 111011010

≡ 000000000101111101100101111011010

Common Lisp, 15 Bytes

(+(read)(read))

Stapel Katzen , 8 + 4 = 12 Bytes

]_:]_!<X

Laufen Sie mit den -mnFahnen. Probieren Sie es online!

Golfen in Stack Cats ist sehr intuitiv, so dass dieses Programm mit ein paar Tagen Brute Forcing gefunden wurde. Zum Vergleich: Eine intuitivere, von Menschen geschriebene Lösung, die die *(...)>Vorlage verwendet, ist zwei Byte länger

*(>-_:[:)>

-lnstattdessen mit den Flags (eine Erklärung finden Sie unten in diesem Beitrag).

Erläuterung

Hier ist eine Einführung zu Stack Cats:

• Stack Cats ist eine reversible esoterische Sprache, bei der der Spiegel eines Snippets den Effekt des Original-Snippets aufhebt. Programme müssen auch Spiegelbilder von sich selbst sein - dies bedeutet notwendigerweise, dass gerade Programme entweder No-Ops oder Endlosschleifen sind und alle nicht-trivialen Abschlussprogramme eine ungerade Länge haben (und im Wesentlichen eine Konjugation des zentralen Operators sind).
• Da die Hälfte des Programms immer impliziert ist, kann eine Hälfte mit dem Flag -moder -lweggelassen werden. Hier wird das -mFlag verwendet, so dass das obige halbe Programm tatsächlich zu erweitert wird ]_:]_!<X>!_[:_[.
• Wie der Name schon sagt, ist Stack Cats stapelbasiert, wobei die Stapel ohne Nullen sind (dh Operationen auf einem ansonsten leeren Stapel geben 0 zurück). Stack Cats verwendet tatsächlich ein Stapelband , z. B. <und >bewegt einen Stapel nach links und einen nach rechts.
• Nullen am Boden des Stapels werden verschluckt / entfernt.
• Alle Eingaben werden auf einen anfänglichen Eingabestapel verschoben, wobei die erste Eingabe oben und eine zusätzliche -1 unter der letzten Eingabe steht. Die Ausgabe erfolgt am Ende unter Verwendung des Inhalts des aktuellen Stapels (wobei ein optionales -1 am Ende ignoriert wird). -nbezeichnet numerische E / A.

Und hier ist eine Spur des erweiterten vollständigen Programms ]_:]_!<X>!_[:_[:

    Initial state (* denotes current stack):
      ... [] [-1 b a]* [] [] ...
]   Move one stack right, taking the top element with you
      ... [] [-1 b] [a]* [] ...
_   Reversible subtraction, performing [x y] -> [x x-y] (uses an implicit zero here)
      ... [] [-1 b] [-a]* [] ...
:   Swap top two
      ... [] [-1 b] [-a 0]* [] ...
]   Move one stack right, taking the top element with you
      ... [] [-1 b] [-a] []* ...
_   Reversible subtraction (0-0, so no-op here)
!   Bit flip top element, x -> -x-1
      ... [] [-1 b] [-a] [-1]* ...
<   Move one stack left
      ... [] [-1 b] [-a]* [-1] ...
X   Swap the stack to the left and right
      ... [] [-1] [-a]* [-1 b] ...
>   Move one stack right
      ... [] [-1] [-a] [-1 b]* ...
!   Bit flip
      ... [] [-1] [-a] [-1 -b-1]* ...
_   Reversible subtraction
      ... [] [-1] [-a] [-1 b]* ...
[   Move one stack left, taking the top element with you
      ... [] [-1] [-a b]* [-1] ...
:   Swap top two
      ... [] [-1] [b -a]* [-1] ...
_   Reversible subtraction
      ... [] [-1] [b a+b]* [-1] ...
[   Move one stack left, taking the top element with you
      ... [] [-1 a+b]* [b] [-1] ...

a+bwird dann ausgegeben, wobei die Basis -1 ignoriert wird. Beachten Sie, dass der schwierigste Teil dieser Lösung darin besteht, dass der Ausgabestapel einen -1am unteren Rand haben muss, andernfalls würde ein Ausgabestapel von nur [-1]die Basis -1 ignorieren, und ein Ausgabestapel von [0]würde dazu führen, dass die Basis Null verschluckt wird (aber eine Ausgabe Stapel von [2]würde zum Beispiel gut ausgeben 2).

Nur zum Spaß finden Sie hier die vollständige Liste der verwandten Lösungen mit derselben gefundenen Länge (die Liste ist möglicherweise nicht vollständig):

]_:]^!<X
]_:]_!<X
]_:]!^<X
]_:!]^<X
[_:[^!>X
[_:[_!>X
[_:[!^>X
[_:![^>X

Die *(>-_:[:)>Lösung ist länger, aber intuitiver zu schreiben, da die *(...)>Vorlage verwendet wird. Diese Vorlage wird <(...)*(...)>bei Verwendung mit dem -lFlag erweitert. Dies bedeutet:

<       Move one stack left
(...)   Loop - enter if the top is positive and exit when the top is next positive again
        Since the stack to the left is initially empty, this is a no-op (top is 0)
*       XOR with 1 - top of stack is now 1
(...)   Another loop, this time actually run
>       Move one stack right

Als solches *(...)>bedeutet das Template, dass die erste Schleife übersprungen, aber die zweite ausgeführt wird. Dies ermöglicht eine einfachere Programmierung, da wir uns nicht um die Auswirkungen der Schleife in der anderen Hälfte des Programms kümmern müssen.

In diesem Fall ist das Innere der Schleife:

>       Move one stack right, to the input stack
-       Negate top, [-1 b a] -> [-1 b -a]
_       Reversible subtraction, [-1 b -a] -> [-1 b a+b]
:       Swap top two, [-1 b a+b] -> [-1 a+b b]
[       Move one stack left, taking top of stack with you (removing the top b)
:       Swap top two, putting the 1 on this stack on top again

Das Finale >in der Vorlage bewegt uns dann zurück zum Eingabestapel, wo a+bes ausgegeben wird.

Brain-Flak , 6 Bytes

({}{})

Probieren Sie es online!

Brain-Flak ist eine wirklich interessante Sprache mit zwei Haupteinschränkungen.

1. Die einzigen gültigen Zeichen sind Klammern, dh eines dieser Zeichen:

   (){}[]<>
   

2. Jeder einzelne Satz von Klammern muss vollständig übereinstimmen, sonst ist das Programm ungültig.

Ein Satz von Klammern, zwischen denen sich nichts befindet, wird als "Nilad" bezeichnet. Eine Nilade erzeugt einen bestimmten numerischen Wert, und alle diese Niladen nebeneinander werden addiert. Ein Satz von Klammern mit etwas dazwischen wird als "Monade" bezeichnet. Eine Monade ist eine Funktion, die ein numerisches Argument akzeptiert. Die Klammern innerhalb einer Monade werden also ausgewertet, und das ist das Argument für die Monade. Hier ist ein konkreteres Beispiel.

Der () Nilad ist gleich 1. Also der folgende Brain-Flak-Code:

()()()

Wird mit 3 bewertet. Die () Monade verschiebt den Wert auf dem globalen Stapel in sich. Also folgendes

(()()())

drückt eine 3. Der {}Nullpunkt fügt den Wert oben auf dem Stapel ein. Da immer aufeinanderfolgende Nullen hinzugefügt werden, summiert eine Reihe von Nullen {}alle obersten Elemente auf dem Stapel. Mein Code lautet also im Wesentlichen:

push(pop() + pop())

Minecraft 1.10.x, 924 512 Bytes

Vielen Dank an @ quat für die Reduzierung des Blytecount um 48 Punkte und des Bytecount um 412.

Okay, also, ich habe einige der Ideen aus dieser Antwort genommen und eine eigene Version erstellt, außer dass diese einen nicht negativen Input akzeptieren kann. Eine Version finden Sie hier im Strukturblockformat.

(neue version sieht irgendwie langweilig aus)

Ähnliche Befehle wie die andere Antwort:

scoreboard objectives add a dummy
execute @e[type=Pig] ~ ~ ~ scoreboard players add m a 1
execute @e[type=Cow] ~ ~ ~ scoreboard players add n a 1
scoreboard players operation n a += m a
tellraw @a {"score":{"name":"n","objective":"a"}}

Um Zahlen einzugeben, laichen Sie eine Reihe von Kühen und Schweinen. Kühe repräsentieren den Wert "n" und Schweine den Wert "m". Das Befehlsblock-System tötet nach und nach die Kühe und Schweine und weist die erforderlichen Werte zu.

Diese Antwort setzt voraus, dass Sie sich in einer Welt ohne natürlich vorkommende Kühe oder Schweine befinden und dass die in "n" und "m" gespeicherten Werte bei jedem Lauf gelöscht werden.

Netzhaut , 42 Bytes

\d+
$*
T`1p`-_` |-1+
+`.\b.

^(-)?.*
$1$.&

Probieren Sie es online!

Erläuterung

Das Hinzufügen von Zahlen in unary ist die einfachste Sache der Welt, aber wenn Sie negative Zahlen einführen, werden die Dinge fummelig ...

\d+
$*

Wir beginnen damit, die Zahlen in unäre Zahlen umzuwandeln. Dies geschieht, indem jede Zahl mit \d+abgeglichen und durch ersetzt wird $*. Dies ist eine Retina-spezifische Substitutionsfunktion. Die vollständige Syntax lautet count$*characterund fügt countKopien von ein character. Beides kann weggelassen werden, wenn countstandardmäßig $&(dh die Übereinstimmung selbst) und characterstandardmäßig 1. Für jede Eingabe erhalten nwir also eine nund wir haben immer noch mögliche Minuszeichen sowie das Leerzeichen-Trennzeichen. ZB Eingang 8 -5gibt:

11111111 -11111

Um nun mit negativen Zahlen umgehen zu können, ist es am einfachsten, eine separate -1Ziffer zu verwenden. Wir werden -für diesen Zweck verwenden.

T`1p`-_` |-1+

Diese Phase macht zwei Dinge. Es wird das Leerzeichen, die führenden Minuszeichen, entfernt und das 1s nach einem Minuszeichen in sich -selbst umgewandelt. Dies erfolgt durch Abgleichen |-1+(dh entweder ein Leerzeichen oder eine negative Zahl) und Durchführen einer Transliteration darauf. Die Transliteration geht von 1pbis -_, wird aber hier pauf alle druckbaren ASCII-Zeichen erweitert und _bedeutet Löschen. Also werden 1s in diesen Matches zu -s und Minuspunkte und Leerzeichen werden entfernt. Unser Beispiel sieht nun so aus:

11111111-----

+`.\b.

In dieser Phase wird der Fall behandelt, in dem der Eingang eine positive und eine negative Zahl enthält. Wenn ja, wird es 1s und -s in der Zeichenfolge geben, und wir möchten, dass sie abbrechen. Dies geschieht, indem zwei Zeichen mit einer Wortgrenze zwischen ihnen abgeglichen werden (da 1s als Wortzeichen betrachtet wird und -nicht) und die Übereinstimmung durch nichts ersetzt wird. Das +weist Retina an, dies wiederholt zu tun, bis sich die Saite nicht mehr ändert.

Jetzt haben wir nur noch 1 s oder nur noch - s.

^(-)?.*
$1$.&

Um dies wieder in eine Dezimalzahl umzuwandeln, wird die gesamte Eingabe abgeglichen, wenn möglich wird jedoch eine -In-Gruppe erfasst 1. Wir schreiben die Gruppe zurück 1(um -negative Zahlen vor a zu stellen) und schreiben dann die Länge der Übereinstimmung mit zurück $.&(ebenfalls ein Retina-spezifisches Substitutionsmerkmal).

Dominosteine , 38.000 Bytes oder 37 Kacheln

Dies wird in Tabletop Simulator erstellt . Hier ist ein Video und hier ist die Datei . Es ist ein Standard-Halbaddierer, der aus einem andGatter für den 2^1Platzwert und einem xorGatter für den 2^0Platzwert besteht.

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 nicht gedrückt, um 0 [Grün] anzuzeigen .
  • Eingang B - Dies ist der Übersichtlichkeit halber enthalten (wird nicht zur Gesamtsumme gezählt) und wird gedrückt, um a anzuzeigen, 1und nicht gedrückt, um 0 [Blau] anzuzeigen .
  • Ausgabe - Dies wird zur Gesamtsumme gezählt. Diese Dominosteine ​​erklären die Summe. Die linke ist 2^1und die rechte ist 2^0 [Schwarz] .
• 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

Haskell, 3 Bytes

(+)

Die Klammern stehen hier, da es sich um eine Präfixfunktion handeln muss. Dies ist dasselbe, als würde man einen Abschnitt der Funktion + nehmen, es werden jedoch keine Argumente angewendet. Es funktioniert auch mit einer Vielzahl von Typen, wie z. B. richtig implementierten Vektoren, Matrizen, komplexen Zahlen, Gleitkommazahlen, Doppelwerten, Rationalen und natürlich ganzen Zahlen.

Da dies Haskell ist, erfahren Sie hier, wie Sie dies auf Typebene tun. Dies erfolgt zur Kompilierungszeit anstatt zur Laufzeit:

-- This *type* represents Zero
data Zero
-- This *type* represents any other number by saying what number it is a successor to.
-- For example: One is (Succ Zero) and Two is (Succ (Succ Zero))
data Succ a

-- a + b = c, if you have a and b, you can find c, and if you have a and c you can find b (This gives subtraction automatically!)
class Add a b c | a b -> c, a c -> b

-- 0 + n = n 
instance Add Zero n n
-- If (a + b = c) then ((a + 1) + b = (c + 1))
instance (Add a b c) => Add (Succ a) b (Succ c)

Code aus Haskell Wiki angepasst

Mathematica, 4 2 Bytes

Tr

_{Durchgestrichen 4 ist immer noch regulär 4 ...} Tr bei einer eindimensionalen Liste wird die Summe der Elemente der Liste berechnet.

Gleichstrom, 2 Bytes

+f

Fügt die beiden obersten Elemente des Stapels hinzu (die zuvor entnommen wurden stdin) und kopiert den Inhalt des Stapels in stdout.

BEARBEITEN: Nach weiteren Überlegungen scheint es mehrere Möglichkeiten zu geben, dies abhängig vom gewünschten E / A-Verhalten zu implementieren.

+        # adds top two items and pushes on stack
+n       # adds top two and prints it, no newline, popping it from stack
+dn      # ditto, except leaves result on stack
??+      # takes two inputs from stdin before adding, leaving sum on stack

Ich nehme an, die vollständigste Form für die Summe wäre:

??+p     # takes two inputs, adds, 'peeks'
         #  (prints top value with newline and leaves result on stack)

Warten! In einer Zeile können zwei durch ein Leerzeichen getrennte Zahlen stehen! Das gibt uns:

?+p

Shakespeare Programming Language , 155 152 Bytes

.
Ajax,.
Ford,.
Act I:.
Scene I:.
[Enter Ajax and Ford]
Ajax:
Listen to thy heart
Ford:
Listen to THY heart!You is sum you and I.Open thy heart
[Exeunt]

Ungolfed:

Summing Two Numbers in Verona.

Romeo, a numerical man.
Juliet, his lover and numerical counterpart.

Act I: In which Italian addition is performed.

Scene I: In which our two young lovers have a short chat.

[Enter Romeo and Juliet]

Romeo:
  Listen to thy heart.

Juliet:
  Listen to THY heart! Thou art the sum of thyself and I. Open thy heart.

[Exeunt]

Ich verwende den SPL-Compiler von drsam94 , um dies zu kompilieren. Zu testen:

$ python splc.py sum.spl > sum.c
$ gcc sum.c -o sum.exe
$ echo -e "5\n16" | ./sum
21

Brachylog , 2 Bytes

+.

Erwartet eine Liste mit den beiden Zahlen als Eingabe

Alternativ, wenn Sie die Antwort auf STDOUT:

+w

JavaScript (ES6), 9 Byte

a=>b=>a+b

PHP, 20 Bytes

Diesmal überraschend kurz:

<?=array_sum($argv);

Läuft von der Kommandozeile aus wie:

$ php sum.php 1 2

Cheddar, 3 Bytes

(+)

Dies ist eine coole Funktion von Cheddar, die als "funktionalisierte Operatoren" bezeichnet wird. Der Preis für diese Idee geht an @ CᴏɴᴏʀO'Bʀɪᴇɴ.

Hier sind weitere Beispiele für funktionalisierte Operatoren:

(+)(1,2) // 3
(/)(6,2) // 3
(-)(5)   // -5

Python, 11 3 Bytes

sum

int.__add__

Ein einfacher Spezialoperator.

Geometry Dash - 15 Objekte

Endlich fertig.
15 Objekte sind nicht viel, aber es war immer noch ein Albtraum, dies zu tun (besonders wegen der negativen Zahlen).

Da ich hier 15 Bilder einfügen müsste, um dies zu reproduzieren, habe ich das Level gerade hochgeladen. Die Level-ID lautet 5216804. In der Beschreibung erfahren Sie, wie Sie es ausführen und können es kopieren, da es kopierbar ist.

Erläuterung:

Der Trigger oben links (Instant Count 2) prüfte, ob der erste Addend 0 war. Wenn dies der Fall war, prüfte er, ob der zweite Addend positiv oder negativ war. Wenn es positiv ist, überträgt es den Wert vom zweiten Addend auf die Summe (BF-Stil, unter Verwendung von Schleifen), und wenn es negativ ist, tut es dasselbe.

Der Grund, warum wir prüfen müssen, ob der zweite Addend positiv oder negativ ist, ist, dass wir einen vom zweiten Addend subtrahieren und einen zur Summe addieren oder einen zum zweiten Addend addieren und einen von der Summe subtrahieren müssen.

Wenn der erste Summand nicht Null ist, wird anhand des obigen Prozesses geprüft, ob er positiv oder negativ ist. Nach einer Iteration in der while-Schleife wird geprüft, ob das erste Addend Null ist, und wenn dies der Fall ist, wird der zu Beginn der Erläuterung beschriebene Prozess ausgeführt.

Da Geometry Dash BF bemerkenswert ähnlich ist, können Sie daraus eine BF-Lösung erstellen.

MATL, 1 Byte

s

Akzeptiert ein Array mit zwei Ganzzahlen als Eingabe und summiert sie. Während das einfache Programm von +auch funktioniert, wurde dies bereits für andere Sprachen gezeigt.

Probieren Sie es online

Perl 5.10, 8 Bytes

Die zwei hinzuzufügenden Zahlen müssen sich in zwei separaten Zeilen befinden, damit diese funktionieren:

say<>+<>

Versuchen Sie dieses hier.

Eine mit Eingabe in derselben Zeile ( 14 + 1 Byte für -a Flag )

say$F[0]+$F[1]

Probieren Sie es hier aus!

Eine mit Eingabe in derselben Zeile ( 19 + 1 Byte für -a Flag )

map{$s+=$_}@F;say$s

Versuchen Sie dieses hier.

Eine andere, indem das Standardtrennzeichen des Arrays geändert wird ( 19 + 1 Byte auch für -a Flag )

$"="+";say eval"@F"

Versuchen Sie dieses hier!

Fuzzy Octo Guacamole , 1 Byte

a

Eine Funktion, die Eingaben vom oberen Rand des Stapels entgegennimmt und durch Drücken auf den Stapel ausgibt.

Beispiel läuft in der REPL:

>>> 8 9 :
[8,9]
>>> a :
17

Batch, 25 18 16 Bytes

@cmd/cset/a%1+%2

Bearbeiten: 7 9 Bytes mit meinem Trick aus Alternating Sign Sequence gespeichert .

PowerShell v2 +, 17 Byte

$args-join'+'|iex

Nimmt Eingaben als zwei separate Befehlszeilenargumente entgegen, die im speziellen Array vorbelegt werden $args. Wir bilden mit dem -joinOperator eine Zeichenfolge , indem wir sie zusammen mit einem +in der Mitte verketten und diese Zeichenfolge dann an Invoke-Expression(ähnlich wie eval) weiterleiten.

Vielen Dank an @DarthTwon, der mich daran erinnert hat, dass es bei solch minimalen Programmen mehrere Methoden gibt, Eingaben bei gleicher Bytezahl zu erfassen.

$args[0]+$args[1]
param($a,$b)$a+$b

PowerShell ist nichts, wenn nicht flexibel.

> <> , 7 6 3 Bytes

+n;

Online-Dolmetscher

Oder probieren Sie es auf TIO mit dem Flag -v.

Probieren Sie es online aus

C 35 Bytes

s(x,y){return y?s(x^y,(x&y)<<1):x;}

Was ich hier gemacht habe, ist die definierte Addition ohne die Verwendung von Booleschen oder arithmetischen Operatoren. Dies macht x rekursiv zu den Summenbits von 'xor' und y zu den Übertragsbits von 'und', bis es keinen Übertrag mehr gibt. Hier ist die ungolfed Version:

int sum(int x,int y){
    if(y==0){
        //anything plus 0 is itself
        return x;
    }
    //if it makes you happier imagine there's an else here
    int sumBits=x^y;
    int carryBits=(x&y)<<1;
    return sum(sumBits,carryBits);
}

MATLAB, 4 Bytes

1 Byte entfernt dank @LeakyNun

@sum

Dies ist eine anonyme Funktion, die ein Array annimmt und die Summe angibt. Beispiel Verwendung:

>> f = @sum
f = 
    @sum
>> f([3 4])
ans =
     7

GoLScript , 1 Byte (nicht konkurrierend)

K

Fügt die obersten 2 Zahlen auf dem Stapel hinzu. Das ist es.

Nun, wie man sie auf den Stapel schiebt , ich habe keine Ahnung. Ich glaube nicht, dass es möglich ist. Husten @ CᴏɴᴏʀO'Bʀɪᴇɴ Husten

Shakespeare Programming Language (SPL), 137 - 135 Byte

Gesamtprogramm Golf:

.
A.
B.
Act I
Scene I
[Enter A and B]
A: Listen to your heart!
B: Listen to your heart! You are the sum of me and you. Open your heart! 

Und eine kurze Erklärung:

----
.                                 <- Title, everything before the first 
                                     full stop is considered as the tittle and treated as a comment
----
A.                                <- Dramatis personae. Here are introduced the characters in the play.
                                     |Characters are treated as variables.   
B.                                <--
----
Act I                             <- Acts and scenes are used to divide a program into smaller
                                     chunks in order to be able to refer to them later.
                                     |
Scene I                           <--
----
[Enter A and B]                   <- Characters on stage in the current scene, which are the              
                                     variables the program will have access to.
----
A: Listen to your heart!          <- Line of code. All of them have the same structure
                                     Variable: code. In this case, the concrete sentence
                                    "Listen to your heart!" reads an input number and stores it
                                     on the character (variable) refered to.
B: Listen to your heart!          <- Same as above 
   You are the sum of me and you. <- Sum the values of itself and the caharacter (variable)
                                     refered to.
   Open your heart!               <- Output the value of the character (value) refered to.

Ich bin mir nicht sicher, ob dies der kürzeste Weg ist. Überprüfen Sie die offizielle Seite für weitere Informationen.

Edit 1: Das :After wurde entfernt Act Iund Scene Ies scheint, dass alles nach der römischen Ziffer ignoriert wird, wodurch 2 Bytes gespart werden.

x86_32-Maschinencode, 2 Byte

08048540 <add7>:
 8048540:   01 c8                   add    %ecx,%eax

Unter der Annahme, dass sich die beiden Werte bereits in den Registern ecx und eax befinden, werden durch Ausführen des Befehls add die Werte der beiden Register addiert und das Ergebnis im Zielregister gespeichert.

Sie können das vollständige Programm in C und Inline-Assembly hier sehen . Das Schreiben des Wrappers in C erleichtert das Bereitstellen von Eingaben und das Testen, die eigentliche Additionsfunktion kann jedoch auf diese beiden Bytes reduziert werden.