Obbiettivo:

Dati due numeri naturali (numeri interi da 0 a infinito), genera un numero che non è la somma di quei numeri, ma è un numero naturale.

Soluzioni di esempio (TI-Basic):

• A+B+1

• not(A+B)

Soluzioni non valide:

• A+B-1(per gli input 0,0, ritorna -1, il che non è naturale)

• "ABC"( ABCnon è un numero)

Gli appunti:

• L'output deve essere sempre una somma di due numeri naturali (che in realtà è solo un numero naturale)

• -1, undefined, infinity, NaNE messaggi di errore non sono numeri naturali. Per i nostri scopi, 0è naturale (sebbene non tutti i matematici siano d'accordo).

RProgN , 4 3 1 byte

_{Barrato 4 è ancora 4; (}

E

La più semplice delle soluzioni, confronta se A e B sono uguali. Spinge vero, che RProgN vede come 1, se sono uguali, o falso aka 0 altrimenti.

Casi test

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

Provalo online!

Retina , 3 byte

 
1

Provalo online!

(La prima riga ha uno spazio prima della nuova riga. Stack Exchange non è molto bravo a mostrare spazi vuoti finali.)

L'input è i numeri in decimale, separati da uno spazio (ad es 12 34.). Questo programma cambia semplicemente lo spazio in a 1, creando un numero troppo grande per essere la somma dei numeri di input (ha necessariamente almeno 2 cifre in più rispetto a uno dei due, e l'aggiunta di due numeri produce un output con non più di 1 cifra in più del input più ampio).

Python , 13 byte

[(0,0)].count

Provalo online! Accetta input come tupla.

L'uso di un metodo oggetto per la funzione evita la caldaia di a lambda.

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

Qui, l'idea è quella di mappare (0,0)per 1e tutto il resto a 0. Dal momento che 0+0dà solo una somma 0tra i numeri naturali, ciò evita sempre di abbinare la somma.

Se uno potesse emettere un booleano qui, che trovo ombreggiato, un byte potrebbe essere salvato come

(0,0).__ge__

Controlla se la tupla di input è al massimo (0,0), il che è vero solo per (0,0). In Python True==1e False==0. Ancora più sfumato, l'output tramite il codice di uscita e il trattamento come Python Boolen salverebbero due byte:

[(0,0)].pop

Se l'I / O stringa è consentito e gli zeri iniziali sono OK, esiste la soluzione a 8 byte

'1'.join

Questo concatena a1b, che è sempre più grande di a+b.

MATL, et al. 1 byte

=

Accetta due numeri naturali come input e li confronta. Se sono uguali, l'uscita è 1e se non sono uguali l'uscita è 0. Questo è lo stesso approccio della soluzione di @ ATaco.

• MATL

• Jelly (di @ ais523)

• Stacked (di @Conor O'Brien)

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

• J (di @ Adám)

• In realtà (di @Mego)

• Implicito (di @MD XF)

Javascript, 10 byte

x=>y=>!x+y

Prende 2 numeri usando la sintassi del curry in questo modo:

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

Vim, 3 byte / sequenze di tasti

<C-a>gJ

Provalo online!

Si noti che in <C-a>realtà è ctrl-a , che rappresenta byte 0x01.

Mi piace quando Vim (che non è nemmeno un linguaggio di programmazione) può competere con i linguaggi del golf. :) L'ingresso è disponibile in questo formato:

a
b

Questo semplicemente incrementa il primo numero di uno (Questa è la <C-a>parte) e quindi unisce insieme le rappresentazioni di stringa dei due numeri. Per quanto ne so, ciò non dovrebbe mai comportare la somma.

Brain-Flak , 8 byte

({}{}())

Provalo online!

Questa è la risposta più leggibile che io abbia mai scritto. :)

Spiegazione:

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

Soluzioni alternative (anche 8 byte):

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

Esistono molte altre soluzioni che funzionano solo con numeri positivi:

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

Gelatina , 2 byte

+‘

Il + aggiunge i due input insieme quindi l 'incremento della risposta di uno

Provalo online!

TI-Basic, 3 byte

not(max(Ans

Soluzioni alternative:

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

È interessante che tu abbia fatto gli esempi della domanda in TI-Basic, ma hai dimenticato il più breve A=B(o forse dipendeva da noi scoprirlo?)

Brachylog , 2 byte

+<

Provalo online!

Spiegazione

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

Ciò comporterà sempre A+B+1, se Input = [A, B].

Mathematica, 5 byte

1+##&

Emette la somma dei due argomenti più 1. Ad esempio, i 1+##&[2,5]rendimenti 8.

(Nota a margine: Binomialquasi funziona, anche se Binomial[1,0]=1e Binomial[4,2]=6sono controesempi; penso che siano gli unici controesempi, però.)

PHP, 17 byte

<?=1-join($argv);

Esegui in questo modo:

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

Spiegazione

Questo concatena gli argomenti. Il primo argomento (nome dello script) contiene -. In questo modo si ottiene un numero negativo, che annullo con il segno meno. Quindi aggiungo 1, nel caso in cui il primo numero di input sia un 0(0123 = 123).

Perl 6 , 4 byte

!*+*

Una lambda (formata da qualunque-currying ), che aggiunge l'inverso booleano (1 o 0) del primo argomento al secondo argomento.

Provalo online!

Turtlèd , 12 byte

fa numeri molto grandi

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

Provalo online!

Spiegazione:

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

Emette quindi 10 ** (x + y).

PHP, 19 byte

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

Java (OpenJDK 9) , 10 byte

a->b->a-~b

Provalo online!

HODOR , 40 byte (non concorrenti)

Questo è probabilmente il programma più breve che Hodor abbia mai scritto!

Questo è ciò che accade quando non hai niente da fare per una vacanza scolastica di 2 settimane: produci un sacco di lingue di battuta facilmente codificabili che non fanno assolutamente nulla. Yay per le vacanze scolastiche !!!

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

Walder era il nome originale di Hodor ed è quindi necessario per iniziare il programma.

Hodor?! prende un numero da STDIN o un singolo carattere e imposta l'accumulatore sull'input

Hodor aggiungere 1 all'accumulatore

HODOR! genera l'accumulatore come numero

HODOR!!!uccide Hodor! Noooooo!

Questo è lo pseudo codice:

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

SmileBASIC, 4 byte

!A+B

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

R, 13 byte

sum(scan()+1)

Grazie a Jonathan Allan per i suoi contributi!

05AB1E , 1 byte

Q

Funziona come la RProgNrisposta.

Verifica se ae bsono gli stessi. In tal caso, stampa 1. Altrimenti, stampa0

Provalo online!

C 26 24 19 byte

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

Versione non golfata:

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

Spero di aver ottenuto le specifiche giuste. Può sicuramente essere abbreviato !?

@Pavel Grazie per aver salvato 2 byte

@Neil Grazie per il tuo contributo.

MATLAB / Octave, 3 byte

@eq

Accetta due input e verifica l'uguaglianza e i rendimenti 1se sono uguali e 0non.

Demo online

Brainfuck, 12 byte

Soluzione semplice che produce A+B+1.

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

Provalo online

dc , 5 byte

?1n+n

Provalo online!

Input: due numeri naturali separati da uno spazio sullo stdin.

Output: la cifra 1 immediatamente seguita dalla somma dei due numeri, che è un numero maggiore della somma dei due numeri.

Esempio:

Ingresso: 222 333

Produzione: 1555

PHP, 13 byte; (17 senza REPL)

!max($argv)+0

Esempi

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

Per quelli senza uso REPL

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

ed esegui usando

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

Cubix, 9 8 byte

u-~OII/@

Spiegazione

Estesa, questa risposta è simile alla seguente:

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

L'ordine delle istruzioni eseguite è II~-O@

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

Testato per tutte le combinazioni di ingressi in cui entrambi sono nel range 0-100.

Provalo qui .

APL - 4 byte

1++/

Accetta array, somma i suoi elementi e ne aggiunge uno. Test:

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

√ å ı ¥ ® Ï Ø ¿ , 4 byte

II1_

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

Per l'output, aggiungere oalla fine.

Esagonia , 7 byte

?<.!?)@

Provalo online!

O in un formato più leggibile,

 ? <
. ! ?
 ) @

Questo batte l'attuale soluzione Hexagony di 11 byte.

Spiegazione:

Se il primo numero non è 0, il programma prende il seguente percorso:

Questo legge il primo numero e le diramazioni a destra. Quindi legge il secondo numero, seguito dal wrapping e dal tentativo di leggere un terzo, ma questo non esiste quindi legge 0. Viene stampato e il programma è terminato (notare che se a> 0, poiché b non è negativo a + b> 0).

Se il primo numero è 0, il programma inizia con il seguente percorso per iniziare:

Questo legge il primo numero e i rami rimasti. Colpisce l'angolo, prendendo il percorso lungo il bordo nord-ovest perché il numero è 0 e legge il secondo numero. Si avvolge, quindi incrementa il secondo numero e stampa.

Rimbalza contro <, stampando di nuovo il secondo ingresso incrementato. Incrementa il valore e riprende il bordo nord-est, ma questa volta perché il bordo corrente ha un valore non negativo a doppio incremento che è sicuramente positivo. Quindi tenta di ottenere un terzo input, ma riceve invece 0.

Alla fine si avvolge e viene deviato dalla freccia, quindi tenta di leggere un quarto input e ottiene di nuovo 0. Si avvolge e tenta di leggere un quinto input e riceve 0 per l'ultima volta. Questo stampa, si avvolge @e esce.

Nota che b * (10 ^ k + 1) * 10> 0 + b = b dove k è la lunghezza di b in cifre, quindi funziona.

Biliardo , 11 caratteri = 17 byte

⇲
⇲
+
1
+
↥

Implementa x + y + 1. Abbastanza elementare Prende gli input su due linee separate. (A proposito, la lingua è stata leggermente modificata dopo la sfida, ma solo per impedire l'inserimento del prompt, non sono sicuro che questa risposta sia ancora valida).

7 caratteri = 11 byte, non concorrenti

Questo è più breve ma possibile solo dopo un nuovo aggiornamento della lingua:

⇲
⇲
=
$

Questo usa x == y, che è stato spudoratamente rubato dalla soluzione RProgN di @ ATaco [spero che non ti dispiaccia (:]. $All'uscita, vengono emesse quante palline vi sono passate sopra.