Entrée: deux entiers. De préférence des nombres entiers décimaux, mais d'autres formes de nombres peuvent être utilisées. Celles-ci peuvent être attribuées au code en entrée standard, sous forme d'arguments au programme ou à la fonction ou sous forme de liste.

Sortie: leur somme. Utilisez le même format pour les entiers en sortie que pour les entiers en entrée. Par exemple, l'entrée 5 16mènerait à la sortie 21.

Restrictions: Aucune lacune standard s'il vous plaît. C'est code-golf , répondez en nombre d'octets le plus bas.

Notes: Cela devrait être assez trivial, mais je suis intéressé de voir comment cela peut être implémenté. La réponse peut être un programme complet ou une fonction, mais veuillez identifier lequel.

Cas de test:

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

Ou en tant que CSV:

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

Classement

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>

Gelée , 1 octet

+

Essayez-le en ligne!

Fonctionne également dans 05AB1E, APL, Braingolf, ,,, (Commata), Factor, Forth, Implicite, J, Julia, K, KDB +, Keg, Ly, MATL, Pyke, Deorst et Q.

Minecraft 1.10, 221 caractères (non-concurrents)

Vous voyez, c’est ce que nous devons gérer lorsque nous créons des cartes Minecraft.

De côté: il n'y a aucun moyen de prendre une entrée de chaîne dans Minecraft, alors je triche un peu en vous faisant entrer les nombres dans le programme lui-même. (C'est un peu justifiable car de nombreuses cartes, comme Minecraft Bingo de Lorgon111, vous obligent à copier et coller des commandes dans le chat afin de saisir un numéro.)

Merci beaucoup pour le filtre MCEdit Block Labels .

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

Non compétitif en raison de difficultés d'entrée et je ne sais pas comment compter les octets dans cette chose (le système de blytes est défectueux pour les blocs de commande).

Calcul lambda binaire , 4.125 octets

Entrée et sortie sous forme de chiffres d'église .

00000000 01011111 01100101 11101101 0

Dans le lambda calcul , il s'agit de λ m . λ n . λ f . λ x . m f ( n f x ).

Indice de Bruijn : λ λ λ λ 4 2 (3 2 1)

Le lambda calcul est une manière concise de décrire une cartographie (fonction).

Par exemple, cette tâche peut être écrite sous la forme de λ x . λ y . x + y

La chose à noter est que ce n'est pas une lambda (fonction) qui prend deux arguments. C'est en fait un lambda imbriqué. Cependant, il se comporte comme un lambda qui prend deux arguments et peut donc être décrit de manière informelle en tant que tel. Chaque lambda ne prend officiellement qu'un seul argument.

Par exemple, si nous appliquons ce lambda à 3 et 4:

(λ x . λ y . x + y ) 3 4 (λ y . 3 + y ) 4 3 + 4 = 7

Ainsi, le premier lambda renvoie en réalité un autre lambda.

Les chiffres d'église sont un moyen de supprimer les signes supplémentaires en ne laissant que des symboles et des variables lambda.

Chaque numéro dans le système de l'église est en fait un lambda qui spécifie combien de fois la fonction est appliquée à un élément.

Laissez la fonction être f et l'élément soit x .

Donc, le nombre 1 correspondrait à λ f . λ x . f x , ce qui signifie appliquer f à x exactement une fois.

Le nombre 3, par exemple, serait λ f . λ x . f ( f ( f x )), ce qui signifie appliquer f à x exactement trois fois.

Par conséquent, ajouter deux chiffres d'église (par exemple, m et n ) ensemble, revient à appliquer f à x , m + n fois.

Nous pouvons observer que cela revient à appliquer d'abord f à x , n fois, puis à appliquer f à l'élément résultant m fois.

Par exemple, 2 signifierait f(f(x))et 3 signifierait f(f(f(x))), donc 2 + 3 serait f(f(f(f(f(x))))).

Pour appliquer f à x , n fois, nous avons n f x .

Vous pouvez voir m et n comme des fonctions prenant deux arguments, de manière informelle.

Ensuite, nous appliquons à nouveau f à cet élément résultant, m fois: m f ( n f x ).

Ensuite, nous rajoutons le passe-partout pour obtenir λ m . λ n . λ f . λ x . m f ( n f x ).

Maintenant, nous devons le convertir en index De Bruijn .

Premièrement, nous comptons la "distance relative" entre chaque variable à la déclaration lambda. Par exemple, le m aurait une distance de 4 car il est déclaré 4 lambdas "il y a". De même, le n aurait une distance de 3, le f aurait une distance de 2 et le x aurait une distance de 1.

Donc, nous l’écrivons sous cette forme intermédiaire: λ m . λ n . λ f . λ x . 4 2 (3 2 1)

Ensuite, nous supprimons les déclarations de variables, nous laissant avec: λ λ λ λ 4 2 (3 2 1)

Maintenant, nous le convertissons en calcul lambda binaire .

Les règles sont:

• λ devient 00.
• m n (groupement) devient 01 m n.
• les nombres i deviennent 1 i fois + 0, par exemple 4 devient 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 octets

(+(read)(read))

Stack Cats , 8 + 4 = 12 octets

]_:]_!<X

Courez avec les -mndrapeaux. Essayez-le en ligne!

Le golf chez Stack Cats est hautement contre-intuitif, ce programme a donc été trouvé avec quelques jours de forçage brutal. À des fins de comparaison, une solution plus intuitive, écrite en utilisant le *(...)>modèle, prend deux octets de plus

*(>-_:[:)>

avec les -lndrapeaux à la place (voir le bas de cet article pour une explication).

Explication

Voici une introduction à Stack Cats:

• Stack Cats est un langage ésotérique réversible dans lequel le miroir d'un extrait annule l'effet de l'extrait d'origine. Les programmes doivent également être des images miroir de lui-même - cela signifie nécessairement que les programmes de longueur pair sont des no-ops ou des boucles infinies, et que tous les programmes de fin non triviaux ont une longueur impaire (et sont essentiellement une conjugaison de l'opérateur central).
• Comme la moitié du programme est toujours implicite, une moitié peut être omise avec le drapeau -mou -l. Ici, le -mdrapeau est utilisé, ainsi le demi-programme ci-dessus s’étend en réalité ]_:]_!<X>!_[:_[.
• Comme son nom l'indique, Stack Cats est basé sur une pile, les piles étant sans fond avec des zéros (c'est-à-dire, les opérations sur une pile autrement vide renvoient 0). Stack Cats utilise en fait une bande de piles, par exemple <et >déplacer une pile gauche et une pile droite , respectivement.
• Les zéros au bas de la pile sont avalés / enlevés.
• Toutes les entrées sont placées dans une pile d’entrée initiale, avec la première entrée en haut et un extra -1 en dessous de la dernière entrée. La sortie est effectuée à la fin, en utilisant le contenu de la pile actuelle (avec un -1 facultatif en bas ignoré). -ndésigne les entrées / sorties numériques.

Et voici une trace du programme complet étendu ]_:]_!<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+best alors sorti, avec la base -1 ignorée. Notez que la partie la plus délicate de cette solution est que la pile de sortie doit avoir un -1en bas, sinon une pile de sortie [-1]ignorerait simplement la base -1, et une pile de sortie [0]provoquerait l’ingestion du zéro de base (mais une sortie pile de [2], par exemple, produirait 2très bien).

Juste pour le plaisir, voici la liste complète des solutions associées de la même longueur que celle trouvée (la liste n'est peut-être pas complète):

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

La *(>-_:[:)>solution est plus longue, mais son écriture est plus intuitive car elle utilise le *(...)>modèle. Ce modèle se développe <(...)*(...)>lorsque utilisé avec le -ldrapeau, ce qui signifie:

<       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

En tant que tel, le *(...)>modèle signifie que la première boucle est ignorée mais que la seconde est exécutée. Cela permet une programmation plus simple, car nous n'avons pas à nous soucier des effets de la boucle dans l'autre moitié du programme.

Dans ce cas, l'intérieur de la boucle est:

>       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

La finale >dans le modèle nous ramène ensuite à la pile d’entrée, où elle a+best sortie.

Cerveau-flak , 6 octets

({}{})

Essayez-le en ligne!

Brain-flak est une langue vraiment intéressante avec deux restrictions majeures.

1. Les seuls caractères valides sont les crochets, c’est-à-dire l’un de ces caractères:

   (){}[]<>
   

2. Chaque ensemble de crochets doit correspondre parfaitement, sinon le programme est invalide.

Un ensemble de crochets sans rien entre eux s'appelle un "nilad". Un nilad crée une certaine valeur numérique, et tous ces nilads côte à côte sont additionnés. Un ensemble de crochets avec quelque chose entre eux s'appelle une "monade". Une monade est une fonction qui prend un argument numérique. Ainsi, les parenthèses à l'intérieur d'une monade sont évaluées, et c'est l'argument de la monade. Voici un exemple plus concret.

Le () nilad est égal à 1. Donc, le code suivant:

()()()

Est évalué à 3. La () monade pousse la valeur à l'intérieur de celle-ci sur la pile globale. Donc ce qui suit

(()()())

appuie sur 3. Le {}nilad affiche la valeur en haut de la pile. Comme les nilads consécutifs sont toujours ajoutés, une chaîne de {}somme additionne tous les éléments supérieurs de la pile. Donc, mon code est essentiellement:

push(pop() + pop())

Minecraft 1.10.x, 924 512 octets

Merci à @ quat pour avoir réduit de 48 points le nombre de blytec et de 412 le nombre de compteurs.

Bon, alors, j'ai repris certaines des idées de cette réponse et en ai fait une version personnelle, sauf que celle-ci est capable d'accepter des entrées non négatives. Une version peut être trouvée ici au format bloc de structure.

(nouvelle version semble un peu ennuyeux tbh)

Des commandes similaires à celles de l'autre réponse:

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

Pour entrer des nombres, apparaissez dans un certain nombre de vaches et de cochons. Les vaches représenteront la valeur "n" et les porcs, la valeur "m". Le système de bloc de commande va progressivement tuer les vaches et les porcs et attribuer des valeurs si nécessaire.

Cette réponse suppose que vous vous trouvez dans un monde sans vaches ni porcs naturels et que les valeurs stockées dans "n" et "m" sont effacées à chaque passage.

Retina , 42 octets

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

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

Essayez-le en ligne!

Explication

L'ajout de nombres en unaire est la chose la plus facile au monde, mais une fois que vous introduisez des nombres négatifs, les choses se compliquent ...

\d+
$*

Nous commençons par convertir les nombres en unaires. Cela se fait en faisant correspondre chaque numéro avec \d+et en le remplaçant par $*. Ceci est une fonctionnalité de substitution spécifique à Retina. La syntaxe complète est count$*characteret insère des countcopies de character. Ces deux options peuvent être omises là où les countvaleurs par défaut $&(c’est- à -dire le match lui-même) et par characterdéfaut 1. Donc, pour chaque entrée, nnous en avons n, et nous avons toujours des signes moins potentiels, ainsi que le séparateur d'espace. Par exemple, l'entrée 8 -5donne:

11111111 -11111

Maintenant, pour traiter les nombres négatifs, il est plus simple d'utiliser un -1chiffre séparé . Nous allons utiliser -à cette fin.

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

Cette étape fait deux choses. Il supprime l'espace, les signes moins, et transforme le 1s après un signe moins en -eux-mêmes. Cela se fait en faisant correspondre |-1+(c’est-à-dire un espace ou un nombre négatif) et en effectuant une translittération sur celui-ci. La translittération va de 1pà -_, mais ici, ps'étend à tous les caractères imprimables ASCII et _signifie supprimer. Alors, 1dans ces matches, -s deviennent des s et des inconvénients et les espaces sont supprimés. Notre exemple ressemble maintenant à ceci:

11111111-----

+`.\b.

Cette étape traite le cas où il y a un nombre positif et un nombre négatif dans l'entrée. Si c'est le cas, il y aura 1s et -s dans la chaîne et nous voulons qu'ils annulent. Ceci est fait en faisant correspondre deux caractères avec une limite de mot entre eux (puisque 1s est considéré comme un caractère de mot et -n'est pas), et en remplaçant la correspondance par rien. Le système +demande à Retina de le répéter jusqu'à ce que la chaîne cesse de changer.

Maintenant, il ne nous reste que 1 s ou seulement - s.

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

Pour reconvertir cette valeur en décimal, nous faisons correspondre l’entrée entière, mais si possible, nous capturons un -groupe 1. Nous écrivons un groupe 1(pour ajouter un -nombre négatif) puis nous écrivons la longueur de la correspondance avec $.&(également une fonctionnalité de substitution spécifique à la rétine).

Dominos , 38 000 octets ou 37 tuiles

Ceci est créé dans Simulateur de table . Voici une vidéo et voici le fichier . Il s'agit d'un demi-additionneur standard, composé d'une andporte pour la 2^1valeur de position et d'une xorporte pour la 2^0valeur de position.

Détails

• I / O
  • Début - Ceci est inclus pour plus de clarté (ne compte pas dans le total) et est ce que "appelle" ou "exécute" la fonction. Devrait être 'appuyé' après que l'entrée soit donnée [Jaune] .
  • Entrée A - Ceci est inclus pour plus de clarté (ne compte pas dans le total) et est 'appuyé' pour indiquer un 1et non pressé pour 0 [Vert] .
  • Entrée B - Ceci est inclus pour plus de clarté (ne compte pas dans le total) et est «appuyé» pour indiquer un 1et non pressé pour 0 [Bleu] .
  • Sortie - Ceci est compté dans le total. Ces dominos déclarent la somme. La gauche est 2^1et la droite est 2^0 [noir] .
• Pressage
  • Pour entrer ou démarrer la chaîne, faire apparaître la bille en métal
  • Réglez la force de portance à 100%
  • Soulevez le marbre au-dessus du domino désiré
  • Laisser tomber le marbre

Haskell, 3 octets

(+)

Les parenthèses sont ici car il doit s'agir d'une fonction de préfixe. Cela revient à prendre une section de la fonction +, mais aucun argument n'est appliqué. Il fonctionne également sur un large éventail de types, tels que les vecteurs, les matricies, les nombres complexes, les flotteurs, les doubles, les rationnels et, bien entendu, les nombres entiers correctement implémentés.

Comme il s'agit de Haskell, voici comment procéder au niveau du type. Cela se fera lors de la compilation au lieu de l'exécution:

-- 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 adapté de Wiki Haskell

Mathematica, 4 2 octets

Tr

_{4 barré est encore régulier 4 ...} Tr appliqué à une liste unidimensionnelle prend la somme des éléments de cette liste.

Langage de programmation Shakespeare , 155 152 octets

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

J'utilise le compilateur SPL drsam94 pour compiler ce. Tester:

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

Brachylog , 2 octets

+.

Attend une liste avec les deux nombres en entrée

Alternativement, si vous voulez la réponse à STDOUT:

+w

dc, 2 octets

+f

Ajoute les deux premiers éléments de la pile (précédemment extraits de stdin), puis vide le contenu de la pile dans stdout.

EDIT: Après mûre réflexion, il semble que cela puisse être implémenté de plusieurs façons, en fonction du comportement d’ entrée / sortie souhaité.

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

Je suppose que la forme la plus complète pour la somme serait la suivante:

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

Attendez! Deux numéros peuvent être pris sur la même ligne, séparés par un espace! Cela nous donne:

?+p

JavaScript (ES6), 9 octets

a=>b=>a+b

PHP, 20 octets

Étonnamment court cette fois-ci:

<?=array_sum($argv);

Fonctionne depuis la ligne de commande, comme:

$ php sum.php 1 2

Cheddar, 3 octets

(+)

Ceci est une fonctionnalité intéressante de Cheddar appelée "opérateurs fonctionnels". Le mérite de cette idée va à @ CᴏɴᴏʀO'Bʀɪᴇɴ.

Voici d'autres exemples d'opérateurs fonctionnalisés:

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

Python, 11 3 octets

sum

int.__add__

Un simple opérateur spécial.

Geometry Dash - 15 objets

Finalement fait.
15 objets ne sont pas beaucoup, mais c'était toujours un cauchemar de le faire (surtout à cause des nombres négatifs).

Parce que je devrais insérer 15 images ici pour savoir comment reproduire cela, je viens de télécharger le niveau. L'ID de niveau est 5216804. La description vous explique comment l'exécuter et vous pouvez le copier car il est copiable.

Explication:

Le déclencheur situé en haut à gauche (Instant Count 2) vérifiait si le premier ajout était 0. Si c'était le cas, il vérifiait si le deuxième ajout était positif ou négatif. S'il était positif, il transférait la valeur du deuxième ajout à la somme (style BF, utilisation de boucles) et s'il était négatif, il ferait la même chose.

La raison pour laquelle nous devons vérifier si le deuxième ajout est positif ou négatif est qu’il faudrait soustraire un du deuxième ajout et en ajouter un à la somme ou en ajouter un au deuxième ajout et soustraire un de la somme, respectivement.

Si le premier ajout n'est pas nul, il vérifie s'il est positif ou négatif en utilisant le processus ci-dessus. Après une itération dans la boucle while, il vérifie si le premier ajout est égal à zéro et si c'est le cas, il effectue le processus décrit au début de l'explication.

Puisque Geometry Dash est remarquablement similaire à BF, vous pouvez en faire une solution.

MATL, 1 octet

s

Accepte un tableau de deux entiers en entrée et les additionne. Bien que le programme simple +fonctionne aussi, cela a déjà été montré pour d'autres langues.

Essayez-le en ligne

Perl 5.10, 8 octets

Les deux numéros à ajouter doivent figurer sur 2 lignes distinctes pour que celle-ci fonctionne:

say<>+<>

Essayez celui-ci ici.

Un avec entrée sur la même ligne ( 14 + 1 octets pour -a flag )

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

Essayez-le ici!

Un avec entrée sur la même ligne ( 19 + 1 octets pour -a flag )

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

Essayez celui-ci ici.

Un autre, en changeant le séparateur par défaut de réseau ( 19 + 1 octets pour -a drapeau ainsi)

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

Essayez celui-ci ici!

Fuzzy Octo Guacamole , 1 octet

a

Une fonction qui prend les entrées du haut de la pile et les sorties en poussant vers la pile.

Exemple exécuté dans le REPL:

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

Lot, 25 18 16 octets

@cmd/cset/a%1+%2

Edit: sauvegardé 7 9 octets en utilisant mon astuce de Séquence de signe alternée .

PowerShell v2 +, 17 octets

$args-join'+'|iex

Prend les entrées en tant que deux arguments de ligne de commande distincts, qui sont pré-remplis dans le tableau spécial $args. Nous formons une chaîne avec l' -joinopérateur en les concaténant avec un +au milieu, puis canalisons cette chaîne vers Invoke-Expression(similaire à eval).

Merci à @DarthTwon de m'avoir rappelé que, lorsqu’il s’agit de programmes aussi minimes, il existe de nombreuses méthodes de saisie des entrées avec le même nombre d’octets.

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

PowerShell n'est rien si ce n'est flexible.

> <> , 7 6 3 octets

+n;

Interprète en ligne

Ou essayez-le sur TIO avec le drapeau -v.

Essayez-le en ligne

C, 35 octets

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

Ce que j'ai fait ici est une addition définie sans utilisation d'opérateurs booléens ou arithmétiques. Cela fait récursivement x les bits de somme par 'xor', et y les bits de retenue par 'et' jusqu'à ce qu'il n'y ait plus de retenue. Voici la version non-golfée:

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 octets

1 octet supprimé grâce à @LeakyNun

@sum

C'est une fonction anonyme qui prend un tableau et donne la somme. Exemple d'utilisation:

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

GoLScript , 1 octet (non concurrentiel)

K

Ajoute les 2 premiers chiffres de la pile. C'est ça.

Maintenant, comment les pousser sur la pile, je n'ai aucune idée. Je ne pense pas que ce soit possible .. toux @ toux CᴏɴᴏʀO'Bʀɪᴇɴ

Langage de programmation Shakespeare (SPL), 137 135 octets

Programme complet, joué au 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! 

Et une brève explication:

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

Je ne suis pas sûr que ce soit la plus courte possible. Consultez la page officielle pour plus d'informations.

Éditer 1: Suppression de l’ :après Act Iet Scene Icar il semble que tout ce qui suit le chiffre romain est ignoré, ce qui permet d’économiser 2 octets.

x86_32 code machine, 2 octets

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

En supposant que les deux valeurs figurent déjà dans les registres ecx et eax, l'exécution de l'instruction add ajoutera les valeurs des deux registres et stockera le résultat dans le registre de destination.

Vous pouvez voir le programme complet écrit en C et assemblage en ligne ici . L'écriture du wrapper en C facilite la fourniture d'entrées et la réalisation de tests, mais la fonction d'ajout réelle peut être réduite à ces deux octets.