20

Dato 2 numeri interi non negativi come input, emette un numero intero non negativo che non può essere creato attraverso nessun operatore matematico sui 2 input.

Ad esempio, dati input 2e 3, 6, 0, 5, 1, 9, 8, 23, 2sono tutti output non validi.

Le operazioni che devono essere prese in considerazione sono:

Addition        (a + b)
Subtraction     (a - b) and (b - a)
Multiplication  (a * b)
Division        (a / b) and (b / a)
Modulus         (a % b) and (b % a)
Exponentiation  (a ** b) and (b ** a)
Bitwise OR      (a | b)
Bitwise XOR     (a ^ b)
Bitwise AND     (a & b)
Concatenation   (a.toString() + b.toString()) and (b.toString() + a.toString())

Nei casi in cui un'operazione porterebbe a un numero intero (come 2/3), sempre piano. Così2 / 3 = 0

Supponiamo che qualsiasi operazione non valida (come la divisione per 0) abbia come risultato 0.

Ingresso

2 numeri interi non negativi.

Sono accettati i metodi I / O standard

Puoi supporre che l'input sia sempre all'interno di un intervallo gestibile per la tua lingua, tuttavia ricorda che le scappatoie standard si applicano ancora.

Produzione

Qualsiasi numero intero non negativo che non può essere creato tramite nessuna delle operazioni sopra descritte sui 2 ingressi.

Casi test

Input  -> Invalid outputs
2, 3   -> 0, 1, 2, 3, 5, 6, 8, 9, 23, 32
0, 0   -> 0
17, 46 -> 0, 2, 12, 17, 29, 63, 782, 1746, 4617, 18487710785295216663082172416, 398703807810572411498315063055075847178723756123452198369
6, 6   -> 0, 1, 6, 12, 36, 66, 46656
1, 1   -> 0, 1, 2, 11

punteggio

Si tratta di code-golf quindi vince il minor numero di byte!

— Skidsdev
fonte

Correlati

— Skidsdev

Penso che l'unico modo per risolverlo sia quello di trovare un numero primo che sia maggiore di (a + b)

— Dead Possum

1

@DeadPossum sarebbe sicuramente una soluzione valida, anche se forse non l'unica, o la più golfistica;)

— Skidsdev,

Scommetto che esiste un linguaggio stravagante che può farlo in pochi byte: D

— Dead Possum,

16

estraneo

— HyperNeutrino,

20

Retina , 3 byte

.
1

Provalo online!

Accetta input separati da spazio (o qualsiasi singolo carattere non di nuova riga)

Sostituisce tutte le cifre con 1e unisce i numeri risultanti con un altro 1.

Prova di correttezza

Per gentile concessione di Martin Ender

Questa operazione calcola un risultato con una cifra in più rispetto al numero di cifre dei due numeri insieme; l'unica operazione che potrebbe produrre un risultato così grande è l'espiazione.
Il risultato è una repunit (un numero le cui cifre sono tutte 1).
"È noto [sic] che [...] una repunit nella base 10 non può [...] essere un potere perfetto." Ciò significa che neanche questo risultato può essere prodotto dall'esponenziazione.

— Leo
fonte

tecnicamente questo non sta unendo i numeri risultanti con un altro 1, sta semplicemente prendendo l'input come una stringa di 2 numeri separati da spazio e sostituendo ogni carattere con un 1. Ma detto questo non riesco a trovare alcun esempio che provi che ti sbagli. .. ancora

— Skidsdev

@Mayube ovviamente lo fa, e come tale potrebbe funzionare con qualsiasi stringa, non solo una composta da due numeri separati da un singolo spazio. La mia spiegazione è in termini di astrazione dei "due numeri di input".

— Leone,

2

"È noto [sic] che [...] una repunit nella base 10 non può [...] essere un potere perfetto." Nessuna operazione nella lista data diversa dall'esponenziazione può comportare più cifre rispetto al numero totale di cifre di input, quindi questo dovrebbe essere valido.

— Martin Ender,

Brutto sfacciato! +1

— Finanzi la causa di Monica

Funziona anche in QuadR !

— Adám,

11

Gelatina , 3 byte

+Æn

Provalo online!

Spiegazione:

+Æn Arguments: x, y
+                            x + y.
 Æn Find a prime larger than

— Erik the Outgolfer
fonte

Penso che questo sia valido ...

— Erik the Outgolfer,

Suppongo che sommi l'input e produca il primo primo maggiore della somma?

— Skidsdev,

1

@DeadPossum Stavo per scriverne uno. Spero di averlo giocato bene.

— Erik the Outgolfer,

1

Il postulato di Bertrand dovrebbe essere quasi abbastanza buono per dimostrare i lavori di concatenazione. Concatenando con il numero più piccolo b a destra abbiamo a..b> = 10a> 4a> 2 (a + b) e concatenando con il numero più piccolo b a sinistra abbiamo b..a> (b + 1) un. L'unico caso interessante non piccolo qui dovrebbe essere b = 1, dove abbiamo 1..a> 2a = 2 (a + b) - 2. Il punto in cui questo limite è il più stretto è per a = 9 .... 9. Questo è l'unico caso non piccolo che potrebbe costituire un problema per il postulato di Bertrand. Tuttavia, ci sono risultati migliori come mathoverflow.net/questions/2724

— tehtmi

1

Immagino che esista una versione del postulato di Bertrand the proves n <p <2n - 2 che dovrebbe funzionare per tutto. Stavo pensando n <p <2n.

— tehtmi,

9

Python 2 , 8 byte

'1'.join

Provalo online!

Prende un elenco di due stringhe numeriche come input, genera una singola stringa numerica. Concatena i numeri con a1 al centro.

Il risultato ha troppe cifre per tutto tranne che per esponente. Si noti che l'output per (x,y)ha una cifra in più di xe ycombinata, a meno che xo ysia 0. Per l'esponente, controlliamo di verificare che ciò significhix**y non corrisponda mai.

Se x è 0 o 1, lo è anche x**y, che è troppo piccolo
Se y<=1allorax**y<=x è troppo piccolo
Se y==2, quindi x**2deve avere altre due cifre rispetto a x. Questo succede x=316e non possiamo controllare nessuno di questi lavori.
Se y==3, quindi x**3deve avere altre due cifre rispetto a x. Questo succede fino a x=21. Possiamo verificare che nessuno di questi funzioni.
Se 3<y<13, quindi x**ydiventa rapidamente troppo lungo. È plausibile che abbia il giusto numero di cifre x<=25e possiamo verificarle.
Se y>=14, allora x**yè troppo lungo anche per il più piccolo possibile x==2.

— XNOR
fonte

7

CJam (7 caratteri)

{+))m!}

Questo crea un numero (a+b+2)! che è più grande del più grande numero correlato in quasi tutti i casi.

E 'abbastanza ovvio che il maggior numero relativo deve essere uno dei a ** b, b ** a, concat(a, b), concat(b, a) .

Se consideriamo i logaritmi, lo troviamo

log(a ** b) = b log a
log(concat(a, b)) ~= (log a) + log (b)
log((a + b + 2)!) ~= (a + b + 2) log (a + b + 2) - (a + b + 2)

Quindi asintoticamente è più grande e dobbiamo solo preoccuparci di alcuni piccoli casi. In effetti, l'unico caso per cui l'output del valore non è maggiore di tutti i numeri correlati è 0, 1(o 1, 0), per il quale fornisce 6e il numero correlato più grande è 10.

— Peter Taylor
fonte

3

JavaScript (ES6), 15 byte

Accetta input nella sintassi del curry.

a=>b=>a*a+b*b+2

a² + b² + 1 fallirebbe per molte voci come 3² + 5² + 1 = 35 o 7² + 26² + 1 = 726 (concatenazione). a² + b² + 2 dovrebbe essere sicuro. Questo è stato accuratamente testato per 0 ≤ a ≤ b ≤ 50000 .

dimostrazione

Mostra snippet di codice

let f =

a=>b=>a*a+b*b+2

for(a = 0; a < 5; a++) {
  for(b = a; b < 5; b++) {
    console.log(a, b, f(a)(b));
  }
}

for(i = 0; i < 10; i++) {
  a = Math.random() * 1000 | 0;
  b = Math.random() * 1000 | 0;
  console.log(a, b, f(a)(b));
}

Espandi frammento

— Arnauld
fonte

1

Questo dovrebbe essere al sicuro dalla concatenazione. Sia b il numero concatenato a destra. Fissando b, possiamo risolvere un'equazione quadratica per a: a ^ 2 + b ^ 2 + 2 - 10 ^ k * a - b = 0. Il discriminante del quadratico deve essere un quadrato perfetto affinché questa equazione abbia una soluzione intera . Il discriminante è 10 ^ 2k - 4 (b ^ 2 - b + 2) = 10 ^ 2k - (2b - 1) ^ 2 - 7. Considera il modulo 9. k non ha importanza e non otteniamo mai un residuo quadratico per b.

— tehtmi,

3

Python, 115 95 79 byte

Stupida soluzione semplice. Sentiti libero di superarmi.

x,y=input()
f=lambda x,y:[x+y,x*y,x**y,int(`x`+`y`)]
print max(f(x,y)+f(y,x))+1

+12 byte a causa di stupidi x/0.
-20 byte grazie a @RobinJames
-16 byte grazie a @tehtmi

— HyperNeutrino
fonte

x / y se y 0 sarà minore o uguale a x * y per x, y non negativo, quindi penso che si possano avere quei 12 byte indietro più un altro 3

— Robin James Kerrison,

@RobinJames Ah sì, sono stupido. Grazie.

— HyperNeutrino,

1

Penso che dovresti essere in grado di rimuovere più casi: 1) x - y <= x <= x + y; 2) x% y <= y <= x + y; 3,4,5) x | y = x ^ y + x & y <= x ^ y + 2 * (x & y) = x + y. (Per quest'ultimo, XOR è come aggiungere senza carry e AND sta trovando i bit che porterebbe. OR sta prendendo (1, 1) -> 1 invece di (1,1) -> 2 come in aggiunta reale.)

— tehtmi,

2

Python, 27 byte

lambda a,b:(a+b+9)**(a+b+9)

Emette un numero maggiore di tutti i numeri correlati.

Provalo online!

-1 byte grazie a Kevin Cruijssen.
-2 byte grazie a Dead Possum.

— Ankoganit
fonte

Il tuo link TIO è vuoto. Inoltre, penso che puoi rimuovere lo spazio dopo :se non sbaglio.

— Kevin Cruijssen,

@KevinCruijssen Whoops, risolto il problema, grazie!

— Ankoganit,

Puoi rimuovere f=- un lambda senza nome è accettabile

— Dead Possum

@DeadPossum Non lo sapevo, grazie!

— Ankoganit,

Probabilmente potresti fare con sbarazzarti di almeno uno dei due nove (e il corrispondente +), ma non ne sono del tutto sicuro.

— Theo,

2

Python 2, 25 byte

lambda x,y:int(`x`+`y`)+3

Concatena e aggiunge 3

Provalo online

— TFeld
fonte

Funziona se xey sono entrambi 3?

— Robert Benson,

@RobertBenson Dovresti farlo, certo che non puoi fare 36 dal 3 e 3

— Skidsdev

Questo probabilmente mi va bene. La concatenazione inversa deve avere un diverso modulo modulo 9. Per l'espiazione, ci sono solo un numero finito di casi da considerare prima che il risultato dell'espiazione abbia troppe cifre lungo le linee della risposta Python di xnor. Non ho visto alcun conflitto (né per +1, sebbene +2 abbia 2 ** 6 = 62 + 2).

— tehtmi,

@tehtmi +1 ha esito negativo su x = y = 0 Il collegamento di prova online collega tutte le combinazioni di xey nell'intervallo [0,400]

— TFeld

2

JS (ES6), 12 byte

x=>x.join`1`

Stesso algoritmo di questa risposta Python . Accetta input come una matrice di ints.

1

Braingolf , 4 byte

9&+^

Provalo online!(Intestazione e piè di pagina sono interprete, il codice è il codice braingolf reale, gli arg sono input)

Uscite (a+b+9)**(a+b+9)

Dai miei test non sono riuscito a trovare coppie su cui questo non funziona.

— Skidsdev
fonte

1

Python 2 , 19 byte

lambda x,y:x+9<<y+9

Provalo online!

Sono abbastanza sicuro che il bit shift funzioni per tutti i casi, ma non ci sono al 100%. Ad ogni modo, salva alcuni byte rispetto alla versione esponenziale.

— KSmarts
fonte

1

J , 5 byte

Solo una traduzione di Jelly .

4 p:+

Provalo online!

— Adamo
fonte

1

APL (Dyalog) , 4 byte

Algoritmo preso da qui .

!2++

Provalo online!

! fattoriale di

2+¨ due più

+ la somma

Funziona anche in J.

— Adamo
fonte

1

QBIC , 8 byte

Amico, tanti modi fantastici per prendere questi numeri e ottenere un numero non correlato. Ho dovuto provare alcuni, per vedere come QBIC avrebbe tenuto il passo. La più breve è una porta della risposta Python di xnor, concatenando i numeri con un 1 nel mezzo:

?;+@1`+;

Tutti, un porto della Retina di Leo risponde:

[0,_l;|+_l;||Z=Z+@1

Trovare il prossimo primo più grande:

c=:+:+1≈µc|+1|c=c+1]?c

— steenbergh
fonte

1

sed , 6 byte

s/ /1/

Provalo online!

L'input avviene tramite stdin nella forma "x y", l'output è stdout.

Porta di questa risposta Python , che include la prova della correttezza. Mille grazie a xnor per un metodo così semplice.

— Kevin
fonte

1

Java 8, 15 byte

a->b->a*a+b*b+2

Port da @Arnauld sorprendente risposta s' JavaScript (ES6) .
Provalo qui.

Approccio diretto ( ~~177~~ 170 byte ):

a->b->{int r=1;for(;a+b==r|a-b==r|a*b==r|(b>0?a/b==r|a%b==r:0>1)|Math.pow(a,b)==r|(a|b)==r|(a^b)==r|(a&b)==r|new Integer(""+a+b)==r|new Integer(""+b+a)==r;r++);return r;}

Provalo qui.

— Kevin Cruijssen
fonte

1

05AB1E , 2 4 byte

+ØDm

Provalo online!

Come la risposta di Jelly, trova un numero primo dopo la somma. Un byte più corto :)

EDIT : ora lo eleva al proprio potere a sufficienza per l'eccezione.

— Neil A.
fonte

In realtà non è lo stesso algoritmo, questo trova a+bil primo, mentre il mio trova il primo più piccolo di a+b.

— Erik the Outgolfer,

Ad ogni modo, dovrebbe funzionare.

— Neil A.

3

Non riesce per 6443, 3 (che dà il primo 64433, la concatenazione).

— Tehtmi,

@tehtmi è corretto, questo non riesce.

— Skidsdev,

Vedi la mia modifica, dovrebbe funzionare ora

— Neil A.

1

Brachylog , 3 byte

+<ṗ

Provalo online!

Niente di nuovo qui.

       The output
  ṗ    is a prime number
 <     which is strictly greater than
+      the sum of the elements of
       the input.

Ora, per capire come trovare una stringa non correlata ...

— Stringa non correlata
fonte

Trova un numero non correlato

Ingresso

Produzione

Casi test

punteggio

Retina , 3 byte

Prova di correttezza

Gelatina , 3 byte

Python 2 , 8 byte

CJam (7 caratteri)

JavaScript (ES6), 15 byte

dimostrazione

Python, 115 95 79 byte

Python, 27 byte

Python 2, 25 byte

JS (ES6), 12 byte

Braingolf , 4 byte

Python 2 , 19 byte

J , 5 byte

APL (Dyalog) , 4 byte

QBIC , 8 byte

sed , 6 byte

Java 8, 15 byte

05AB1E , 2 4 byte

Brachylog , 3 byte