Objectif:

Étant donné deux nombres naturels (entiers de 0 à l'infini), génère un nombre qui n'est pas la somme de ces nombres, mais qui est un nombre naturel.

Exemple de solutions (TI-Basic):

• A+B+1

• not(A+B)

Solutions non valides:

• A+B-1(pour les entrées 0,0, ça retourne -1, ce qui n'est pas naturel)

• "ABC"( ABCn'est pas un nombre)

Remarques:

• La sortie doit toujours être une somme de deux nombres naturels (qui est en fait juste un nombre naturel)

• -1, undefined, infinity, NaNEt les messages d'erreur ne sont pas des nombres naturels. Pour nos besoins, 0c'est naturel (bien que tous les mathématiciens ne soient pas d'accord).

RProgN , 4 3 1 Byte

_{4 sont encore barrés sur 4 (}

E

La plus simple des solutions, compare si A et B sont égaux. Pousse vrai, ce que RProgN voit comme 1, s'ils sont identiques, ou faux aka 0 sinon.

Cas de test

0+0 = 1
1+0 = 0
0+1 = 0
1+1 = 1

Essayez-le en ligne!

Rétine , 3 octets

 
1

Essayez-le en ligne!

(La première ligne a un espace avant la nouvelle ligne. Stack Exchange ne montre pas très bien les espaces de fin.)

L'entrée est le nombre en décimal, séparé par un espace (par exemple 12 34). Ce programme change simplement l'espace en a 1, créant un nombre trop grand pour être la somme des nombres en entrée (il a nécessairement au moins 2 chiffres de plus que l'un ou l'autre, et ajouter deux nombres produit une sortie avec pas plus d'un chiffre que le entrée plus grande).

Python , 13 octets

[(0,0)].count

Essayez-le en ligne! Prend l'entrée comme un tuple.

L'utilisation d'une méthode d'objet pour la fonction évite le passe-partout d'un lambda.

lambda a,b:a-~b   # 15 bytes

Ici, l’idée est de mapper (0,0)vers 1et tout le reste 0. Puisque ne 0+0donne qu'une somme 0parmi des nombres naturels, cela évite toujours de faire correspondre la somme.

Si on pouvait sortir un booléen ici, ce que je trouve louche, un octet pourrait être sauvegardé en tant que

(0,0).__ge__

Ceci vérifie si le tuple d'entrée est au maximum (0,0), ce qui n'est vrai que pour (0,0). En Python, True==1et False==0. De manière encore plus obscure, sortir par le code de sortie et le traiter comme un booléen Python économiserait deux octets:

[(0,0)].pop

Si la chaîne d'E / S est autorisée et que les zéros au début sont corrects, il existe une solution à 8 octets.

'1'.join

Cela concatène a1b, ce qui est toujours plus gros que a+b.

MATL et al. 1 octet

=

Accepte deux nombres naturels comme entrées et les compare. S'ils sont égaux, la sortie l'est 1et s'ils ne sont pas égaux, la sortie l'est 0. C'est la même approche que la solution de @ ATaco.

• MATL

• Gelée (par @ ais523)

• Stacked (par @Conor O'Brien)

• APL (Dyalog APL) (par @ Adám)

• J (par @ Adám)

• En fait (par @Mego)

• Implicite (par @MD XF)

Javascript, 10 octets

x=>y=>!x+y

Prend 2 nombres en utilisant la syntaxe de currying comme ceci:

(x=>y=>!x+y)(0)(0) // 1

Vim, 3 octets / frappes

<C-a>gJ

Essayez-le en ligne!

Notez que <C-a>est en fait ctrl-un , ce qui représente l' octet 0x01.

J'adore quand vim (qui n'est même pas un langage de programmation) peut rivaliser avec les langages de golf. :) L'entrée se présente sous ce format:

a
b

Cela incrémente simplement le premier nombre de un (c'est la <C-a>partie), puis joint les représentations sous forme de chaîne des deux nombres. Autant que je sache, cela ne devrait jamais aboutir à la somme.

Brain-Flak , 8 octets

({}{}())

Essayez-le en ligne!

C’est la réponse la plus lisible que je n’ai jamais faite à propos du cerveau. :)

Explication:

(      )    # Push the sum of all the following:
 {}         #   The first input
   {}       #   The second input
     ()     #   and one

Solutions alternatives (également 8 octets):

({}[]{})    # Sum + 1
([]{}{})    # Sum + 2

Il y a beaucoup d'autres solutions qui ne fonctionnent qu'avec des nombres positifs:

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

Gelée , 2 octets

+‘

Le + additionne les deux entrées puis le 'incrémente la réponse d'une unité

Essayez-le en ligne!

TI-Basic, 3 octets

not(max(Ans

Solutions alternatives:

10^(sum(Ans         3 bytes @DestructibleWatermelon
not(sum(Ans         3 bytes
1+sum(Ans           4 bytes
Input :X=Y          5 bytes @ATaco
Input :X+not(Y      6 bytes
Input :not(X+Y      6 bytes
Input :10^(X+Y      6 bytes
Input :X+Y+1        7 bytes
Input :not(max(X,Y  7 bytes
Ans(1)=Ans(2        8 bytes
Ans(1)+not(Ans(2    9 bytes
not(Ans(1)+Ans(2    9 bytes

Il est intéressant de noter que vous avez créé les exemples de la question dans TI-Basic, mais vous avez oublié le plus court A=B(ou peut-être que c'était à nous de le découvrir?)

Brachylog , 2 octets

+<

Essayez-le en ligne!

Explication

+     The sum of the elements in the Input...
 <    ...is strictly less than the Output
      (implicitely label the output with an integer respecting this constraint)

Cela aura toujours comme conséquence A+B+1, si Input = [A, B].

Mathematica, 5 octets

1+##&

Affiche la somme des deux arguments plus 1. Par exemple, 1+##&[2,5]donne 8.

(Note latérale: Cela Binomialfonctionne presque, bien Binomial[1,0]=1que ce Binomial[4,2]=6soient des contre-exemples; je pense que ce sont les seuls contre-exemples, cependant.)

PHP, 17 octets

<?=1-join($argv);

Courez comme ça:

echo '<?=1-join($argv);' | php -- 0 0
> 1

Explication

Cela ne fait que concaténer les arguments. Le premier argument (nom du script) contient -. Cela donne donc un nombre négatif que je nie avec le signe moins. Ensuite, j'ajoute 1, juste au cas où le premier numéro entré est un 0(0123 = 123).

Perl 6 , 4 octets

!*+*

Un lambda (formé par Whatever-currying ), qui ajoute l'inverse booléen (1 ou 0) du premier argument au second argument.

Essayez-le en ligne!

Tortue , 12 octets

fait de très grands nombres

'1?:?:[1'0l]

Essayez-le en ligne!

Explication:

'1                write one on the starting grid square
  ?:?:            take a number, move right that many (repeat)
      [1   ]      while not on a grid square with a one on it
        '0l       put a zero on that square, move left
[implicit output of grid]

Il délivre donc 10 ** (x + y).

PHP, 19 octets

1<?=max([0]+$argv);

Java (OpenJDK 9) , 10 octets

a->b->a-~b

Essayez-le en ligne!

HODOR , 40 octets (non concurrents)

C'est probablement le programme le plus court jamais écrit par Hodor!

C’est ce qui se produit lorsque vous n’avez rien à faire pendant les vacances scolaires de deux semaines: créez un ensemble de langages de plaisanterie très facilement codés qui ne font absolument rien. Yay pour les vacances scolaires !!!

Walder
Hodor?!
Hodor?!
Hodor HODOR!
HODOR!!!

Walder était le nom original de Hodor et est donc nécessaire pour commencer le programme.

Hodor?! prend un numéro de STDIN ou un seul caractère et définit l'accumulateur sur l'entrée

Hodor ajouter 1 à l'accumulateur

HODOR! sort l'accumulateur sous forme de nombre

HODOR!!!tue Hodor! Noooooo!

C'est le pseudo code:

Take input
Take input
Add 1 to sum(inputs)
Output value

SmileBASIC, 4 octets

!A+B

pas (A) + B
1+1=2 -> !1+1 -> 0+1=1
0+1=1 -> !0+1 -> 1+1=2

R, 13 octets

sum(scan()+1)

Merci à Jonathan Allan pour ses contributions!

05AB1E , 1 octet

Q

Fonctionne comme la RProgNréponse.

Vérifie si aet bsont les mêmes. Si oui, imprimez 1. Sinon, imprimez0

Essayez-le en ligne!

C 26 24 19 octets

f(c,d){return!c+d;}

Version non-golfée:

int f(int c,int d)
{
   return !c+d; 
}

J'espère que j'ai bien spécifié les spécifications. Peut certainement être raccourci !?

@Pavel Merci d'avoir économisé 2 octets

@ Neil Merci pour votre contribution.

MATLAB / Octave, 3 octets

@eq

Accepte deux entrées et vérifie l’égalité et donne les rendements 1s’ils sont égaux et 0autres.

Démo en ligne

brainfuck, 12 octets

Solution simple qui produit A+B+1.

,>,[-<+>]<+.

Essayez-le en ligne

dc , 5 octets

?1n+n

Essayez-le en ligne!

Entrée: deux nombres naturels séparés par un espace sur stdin.

Sortie: Le chiffre 1 immédiatement suivi de la somme des deux nombres, qui est un nombre supérieur à la somme des deux nombres.

Exemple:

Contribution: 222 333

Sortie: 1555

PHP, 13 octets; (17 REPL-moins)

!max($argv)+0

Exemples

[0,0] -> 1
[0,1] -> 0
[1,0] -> 0

Pour ceux sans REPL utiliser

<?=!max($argv)+0;

et courir en utilisant

echo '<?=!max($argv)+0;' | php -- 0 0

Cubix, 9 8 octets

u-~OII/@

Explication

Développé, cette réponse ressemble à ceci:

    u -
    ~ O
I I / @ . . . .
. . . . . . . .
    . .
    . .

L'ordre des instructions qui sont exécutées est II~-O@

II~-O@
I      # First input
   -   # Minus
 I~    # NOT(second input)
    O  # Output as integer
     @ # End program

Testé pour toutes les combinaisons d'entrées où les deux sont dans la plage 0-100.

Essayez ici .

APL - 4 octets

1++/

Prend array, somme ses éléments et en ajoute un. Tester:

 1++/1 2  
4
 1++/1 0
2

√ å ı ¥ ® Ï Ø ¿ , 4 octets

II1_

II   Take 2 inputs and push to the stack
  1  Push 1 to the stack
   _ Push the sum of the stack

Pour sortir, ajouter oà la fin.

Hexagonie , 7 octets

?<.!?)@

Essayez-le en ligne!

Ou dans un format plus lisible,

 ? <
. ! ?
 ) @

Cela bat la solution actuelle de Hexagony de 11 octets.

Explication:

Si le premier nombre n'est pas 0, le programme suit le chemin suivant:

Cela lit le premier numéro et branche à droite. Ensuite, il lit le deuxième numéro, suivi d'un retour à la ligne et d'une tentative d'en lire un troisième, mais il n'existe pas et lit donc 0. Il est imprimé et le programme est terminé (notez que si a> 0, puisque b est non négatif, a + b> 0).

Si le premier nombre est 0, le programme suit le chemin suivant:

Ceci lit le premier numéro et les branches à gauche. Il frappe le coin, prenant la route le long du bord nord-ouest parce que le nombre est 0 et lit le deuxième nombre. Il encapsule puis incrémente le deuxième nombre et s'imprime.

Il rebondit sur le <, imprimant à nouveau la deuxième entrée incrémentée. Il incrémente la valeur et reprend le bord nord-est, mais cette fois-ci, le bord actuel est une valeur non négative incrémentée deux fois, qui est définitivement positive. Il essaie ensuite d'obtenir une troisième entrée, mais reçoit 0 à la place.

Finalement, il encapsule et est détourné par la flèche, puis tente de lire une quatrième entrée et obtient à nouveau 0. Il encapsule et tente de lire une cinquième entrée et reçoit 0 pour la dernière fois. Cela l’imprime et s’enveloppe jusqu’à la @sortie.

Notez que b * (10 ^ k + 1) * 10> 0 + b = b où k est la longueur de b en chiffres, donc cela fonctionne.

Billard , 11 caractères = 17 octets

⇲
⇲
+
1
+
↥

Implements x + y + 1. Assez élémentaire. Il prend les entrées sur deux lignes distinctes. (Au fait, la langue a été légèrement modifiée après le challenge, mais uniquement pour empêcher la saisie de l'invite, sans savoir si cette réponse est toujours valide).

7 caractères = 11 octets, non en compétition

Celui-ci est plus court mais n'est possible qu'après une nouvelle mise à jour de la langue:

⇲
⇲
=
$

Ceci utilise x == y, qui a été volé sans vergogne de la solution RProgN de @ ATaco [espérons que cela ne vous dérange pas (:]. Le $, à la sortie, affiche le nombre de balles passées dessus.