Gol:

Dados dos números naturales (enteros de 0 a infinito), genera un número que no es la suma de esos números, sino que es un número natural.

Soluciones de ejemplo (TI-Basic):

• A+B+1

• not(A+B)

Soluciones inválidas:

• A+B-1(para las entradas 0,0, regresa -1, lo que no es natural)

• "ABC"( ABCno es un número)

Notas:

• La salida siempre debe ser una suma de dos números naturales (que en realidad es solo un número natural)

• -1, undefined, infinity, NaNY los mensajes de error no son números naturales. Para nuestros propósitos, 0es natural (aunque no todos los matemáticos están de acuerdo).

RProgN , 4 3 1 Byte

_{Tachado 4 sigue siendo 4; (}

E

La solución más simple, compara si A y B son iguales. Pushes verdadero, que RProgN ve como 1, si son iguales, o falso aka 0 de lo contrario.

Casos de prueba

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

Pruébalo en línea!

Retina , 3 bytes

 
1

Pruébalo en línea!

(La primera línea tiene un espacio antes de la nueva línea. Stack Exchange no es muy bueno para mostrar espacios en blanco al final).

La entrada son los números en decimal, separados por un espacio (p 12 34. Ej .). Este programa simplemente cambia el espacio a a 1, creando un número demasiado grande para ser la suma de los números de entrada (necesariamente tiene al menos 2 dígitos más que cualquiera de los dos, y sumar dos números produce una salida con no más de 1 dígito más que el mayor entrada).

Python , 13 bytes

[(0,0)].count

Pruébalo en línea! Toma la entrada como una tupla.

El uso de un método de objeto para la función evita la repetitiva de a lambda.

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

Aquí, la idea es asignar (0,0)a 1y todo lo demás a 0. Como solo 0+0da una suma de 0entre los números naturales, eso siempre evita hacer coincidir la suma.

Si uno pudiera generar un booleano aquí, lo que me parece sospechoso, un byte podría guardarse como

(0,0).__ge__

Esto comprueba si la tupla de entrada es como máximo (0,0), lo cual solo es cierto para (0,0). En Python, True==1y False==0. Aún más sombrío, la salida a través del código de salida y el tratamiento como un Python Boolen ahorraría dos bytes:

[(0,0)].pop

Si la cadena de E / S está permitida y los ceros iniciales están bien, existe la solución de 8 bytes

'1'.join

Esto concatena a1b, que siempre es más grande que a+b.

MATL y col. 1 byte

=

Acepta dos números naturales como entradas y los compara. Si son iguales, la salida es 1y si no son iguales, la salida es 0. Este es el mismo enfoque que la solución de @ ATaco.

• MATL

• Jalea (por @ ais523)

• Stacked (por @Conor O'Brien)

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

• J (por @ Adám)

• En realidad (por @Mego)

• Implícito (por @MD XF)

Javascript, 10 bytes

x=>y=>!x+y

Toma 2 números usando la sintaxis de curry así:

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

Vim, 3 bytes / pulsaciones de teclas

<C-a>gJ

Pruébalo en línea!

Tenga en cuenta que en <C-a>realidad es ctrl-a , que representa el byte 0x01.

Me encanta cuando vim (que ni siquiera es un lenguaje de programación) puede competir con los lenguajes de golf. :) La entrada viene en este formato:

a
b

Esto simplemente incrementa el primer número en uno (Esta es la <C-a>parte) y luego une las representaciones de cadena de los dos números juntos. Por lo que puedo decir, esto nunca debería resultar en la suma.

Brain-Flak , 8 bytes

({}{}())

Pruébalo en línea!

Esta es la respuesta mental más legible que he escrito. :)

Explicación:

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

Soluciones alternativas (también 8 bytes):

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

Hay muchas otras soluciones que solo funcionan con números positivos:

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

Jalea , 2 bytes

+‘

El + agrega las dos entradas juntas y luego 'incrementa la respuesta en uno

Pruébalo en línea!

TI-Basic, 3 bytes

not(max(Ans

Soluciones alternativas:

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

Es interesante que haya hecho los ejemplos de la pregunta en TI-Basic, pero olvidó el más corto A=B(¿o tal vez fue nuestra decisión averiguarlo?)

Brachylog , 2 bytes

+<

Pruébalo en línea!

Explicación

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

Esto siempre dará como resultado A+B+1, si Input = [A, B].

Mathematica, 5 bytes

1+##&

Da como resultado la suma de los dos argumentos más 1. Por ejemplo, 1+##&[2,5]rendimientos 8.

(Nota al margen: Binomialaunque casi funciona, Binomial[1,0]=1y Binomial[4,2]=6son contraejemplos; sin embargo, creo que son los únicos contraejemplos).

PHP, 17 bytes

<?=1-join($argv);

Corre así:

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

Explicación

Esto solo concatena los argumentos. El primer argumento (nombre del script) contiene -. Entonces eso resulta en un número negativo, que niego con el signo menos. Luego agrego 1, en caso de que el primer número de entrada sea a 0(0123 = 123).

Perl 6 , 4 bytes

!*+*

Una lambda (formada por Whatever-curry ), que agrega el inverso booleano (1 o 0) del primer argumento al segundo argumento.

Pruébalo en línea!

Turtlèd , 12 bytes

hace números muy grandes

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

Pruébalo en línea!

Explicación:

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

Por lo tanto, produce 10 ** (x + y).

PHP, 19 bytes

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

Java (OpenJDK 9) , 10 bytes

a->b->a-~b

Pruébalo en línea!

HODOR , 40 bytes (no competitivos)

¡Este es probablemente el programa más corto que Hodor haya escrito!

Esto es lo que sucede cuando no tienes nada que hacer para unas vacaciones escolares de 2 semanas: produce un montón de idiomas de broma realmente fáciles de codificar que no hacen absolutamente nada. Yay para vacaciones escolares!

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

Walder era el nombre original de Hodor, por lo que es necesario para comenzar el programa.

Hodor?! toma un número de STDIN o un solo carácter y establece el acumulador en la entrada

Hodor agregue 1 al acumulador

HODOR! saca el acumulador como un número

HODOR!!!mata a Hodor! Noooooo!

Este es el pseudocódigo:

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

SmileBASIC, 4 bytes

!A+B

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

R, 13 bytes

sum(scan()+1)

¡Gracias a Jonathan Allan por sus aportes!

05AB1E , 1 byte

Q

Funciona igual que la RProgNrespuesta.

Comprueba si ay bson lo mismo. Si es así, imprime 1. De lo contrario, imprimir0

Pruébalo en línea!

C 26 24 19 bytes

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

Versión sin golf:

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

Espero tener la especificación correcta. ¿Definitivamente se puede acortar?

@Pavel Gracias por guardar 2 bytes

@Neil Gracias por tu aporte.

MATLAB / Octava, 3 bytes

@eq

Acepta dos entradas y verifica la igualdad y los rendimientos 1si son iguales o 0no.

Demo en línea

brainfuck, 12 bytes

Solución simple que da salida A+B+1.

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

Pruébalo en línea

dc , 5 bytes

?1n+n

Pruébalo en línea!

Entrada: Dos números naturales separados por un espacio en stdin.

Salida: el dígito 1 seguido inmediatamente por la suma de los dos números, que es un número mayor que la suma de los dos números.

Ejemplo:

Entrada: 222 333

Salida: 1555

PHP, 13 bytes; (17 REPL-less)

!max($argv)+0

Ejemplos

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

Para aquellos sin uso REPL

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

y correr usando

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

Cubix, 9 8 bytes

u-~OII/@

Explicación

Ampliada, esta respuesta se ve así:

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

El orden de las instrucciones que se ejecutan es II~-O@

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

Probado para todas las combinaciones de entradas donde ambas están en el rango 0-100.

Probarlo aquí .

APL - 4 bytes

1++/

Toma una matriz, suma sus elementos y agrega uno. Prueba:

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

√ å ı ¥ ® Ï Ø ¿ , 4 bytes

II1_

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

Para la salida, agregue oal final.

Hexagonía , 7 bytes.

?<.!?)@

Pruébalo en línea!

O en un formato más legible,

 ? <
. ! ?
 ) @

Esto supera la solución actual de Hexagony de 11 bytes.

Explicación:

Si el primer número no es 0, el programa toma la siguiente ruta:

Esto lee el primer número y se bifurca a la derecha. Luego lee el segundo número, seguido de ajustar e intentar leer un tercero, pero eso no existe, por lo que lee 0. Esto se imprime y el programa termina (tenga en cuenta que si a> 0, ya que b no es negativo a + b> 0).

Si el primer número es 0, el programa toma la siguiente ruta para comenzar:

Esto lee el primer número y las ramas restantes. Toca la esquina, toma la ruta desde el borde noroeste porque el número es 0 y lee el segundo número. Se envuelve, luego incrementa el segundo número e imprime.

Rebota contra el <, imprimiendo la segunda entrada incrementada nuevamente. Incrementa el valor y toma el borde noreste nuevamente, pero esta vez porque el borde actual es un valor no negativo incrementado dos veces que es definitivamente positivo. Luego intenta obtener una tercera entrada, pero recibe 0 en su lugar.

Finalmente se envuelve y se desvía con la flecha, luego intenta leer una cuarta entrada y obtiene 0 nuevamente. Se envuelve e intenta leer una quinta entrada y recibe 0 por última vez. Este se imprime y se envuelve a las @salidas.

Tenga en cuenta que b * (10 ^ k + 1) * 10> 0 + b = b donde k es la longitud de b en dígitos, por lo que esto funciona.

Billar , 11 caracteres = 17 bytes

⇲
⇲
+
1
+
↥

Implementos x + y + 1. Bastante elemental. Toma las entradas en dos líneas separadas. (Por cierto, el idioma se modificó ligeramente después del desafío, pero solo para evitar que ingrese el mensaje, no estoy seguro de si esta respuesta sigue siendo válida).

7 caracteres = 11 bytes, no competitivos

Este es más corto pero solo es posible después de una nueva actualización del idioma:

⇲
⇲
=
$

Este uso x == y, que fue robado descaradamente de la solución RProgN de @ ATaco [espero que no te importe (:]. El $, al salir, muestra cuántas bolas pasaron sobre él.