È necessario scrivere un programma o una funzione che riceve un numero intero come input e genera o restituisce due numeri interi la cui somma è la prima.

C'è un ulteriore requisito: nessun numero può far parte dell'uscita per due ingressi diversi .

Dettagli

• Dovresti essere in grado di gestire gli input almeno per l'intervallo -32768 .. 32767(incluso).
• Se il tuo tipo di dati non è in grado di gestire numeri interi arbitrari, va bene ma in teoria il tuo algoritmo dovrebbe funzionare per numeri grandi e piccoli arbitrari.

Esempi

Ogni blocco mostra una parte di una soluzione corretta o errata nel formato di input => output.

1 => 6 -5
2 => -2 4
15 => 20 -5

Incorrect, as `-5` is used in two outputs.

-5 => -15 10
0 => 0 0
1 => 5 6
2 => -5 7

Incorrect, as `5 + 6` isn't `1`.

-1 => -1 0
0 => 6 -6
2 => 1 1

Can be correct if other outputs doesn't collide.

Questo è il codice golf, quindi vince l'ingresso più breve.

Pyth, 8 byte

_J^Q3+QJ

Dimostrazione. Equivalente al codice Python 2:

Q=input()
J=Q**3
print -J
print Q+J

Quindi, l'output ha forma (-n**3, n+n**3)

Alcune uscite:

-5 (125, -130)
-4 (64, -68)
-3 (27, -30)
-2 (8, -10)
-1 (1, -2)
 0 (0, 0)
 1 (-1, 2)
 2 (-8, 10)
 3 (-27, 30)
 4 (-64, 68)
 5 (-125, 130)

Questi sono distinti perché i cubi sono abbastanza distanziati che l'aggiunta na n**3non è sufficiente per attraversare il gap al cubo successivo: n**3 < n+n**3 < (n+1)**3per positivo ne simmetricamente per negativo n.

Pupazzo di neve 0.1.0 , 101 caratteri

}vg0aa@@*45,eQ.:?}0AaG0`NdE`;:?}1;bI%10sB%nM2np`*`%.*#NaBna!*+#@~%@0nG\]:.;:;bI~0-NdEnMtSsP" "sP.tSsP

Input su STDIN, output separato da spazio su STDOUT.

Questo utilizza lo stesso metodo della risposta di isaacg.

Versione commentata con newline, per "leggibilità":

}vg0aa          // get input, take the first char
@@*45,eQ.       // check if it's a 45 (ASCII for -) (we also discard the 0 here)
// this is an if-else
:               // (if)
  ?}0AaG        // remove first char of input (the negative sign)
  0`NdE`        // store a -1 in variable e, set active vars to beg
;
:               // (else)
  ?}1           // store a 1 in variable e, set active vars to beg
;bI             // active variables are now guaranteed to be beg
%10sB           // parse input as number (from-base with base 10)
%nM             // multiply by either 1 or -1, as stored in var e earlier
2np`*`          // raise to the power of 2 (and discard the 2)
%.              // now we have the original number in b, its square in d, and
                //   active vars are bdg
*#NaBna!*+#     // add abs(input number) to the square (without modifying the
                //   input variable, by juggling around permavars)
@~%@0nG\]       // active vars are now abcfh, and we have (0>n) in c (where n is
                //   the input number)
:.;:;bI         // if n is negative, swap d (n^2) and g (n^2+n)
~0-NdEnM        // multiply d by -1 (d is n^2 if n is positive, n^2+n otherwise)
tSsP            // print d
" "sP           // print a space
.tSsP           // print g

Commento sulla prima soluzione di Snowman su PPCG: penso che il mio obiettivo di progettazione di rendere il mio linguaggio il più confuso possibile sia stato raggiunto.

Questo in realtà avrebbe potuto essere molto più breve, ma io sono un idiota e ho dimenticato di implementare numeri negativi per la stringa -> analisi dei numeri. Quindi ho dovuto controllare manualmente se c'era un -primo carattere e rimuoverlo in tal caso.

Pyth, 15 11 byte

4 byte grazie a @Jakube

*RQ,hJ.aQ_J

Dimostrazione.

Questa mappa come segue:

0  -> 0, 0
1  -> 2, -1
-1 -> -2, 1
2  -> 6, -4
-2 -> -6, 4

E così via, coinvolgendo sempre n^2e n^2 + n, più o meno.

APL, 15 byte

{(-⍵*3)(⍵+⍵*3)}

Questo crea una funzione monadica senza nome che restituisce la coppia -n ^ 3 ( -⍵*3), n + n ^ 3 ( ⍵+⍵*3).

Puoi provarlo online .

Pyth - 11 10 byte

Si moltiplica solo per 10e10 e -10e10 + 1 Grazie a @xnor per avermi mostrato che avrei potuto usare CGper il numero.

*CGQ_*tCGQ

Provalo online qui .

O , 17 15 9 byte

Utilizza alcune nuove funzionalità di O.

Q3 ^ .Q + p_p

Versione precedente

[I # .Z3 ^ * \ Z3 ^) _ *] o

Python 3, 29 27

Modifica: non soddisfa i requisiti nel secondo punto "Dettagli"

Bonus: funziona da -99998 a 99998 inclusi

lambda n:[99999*n,-99998*n]

Questo crea una funzione anonima *, che puoi usare racchiudendo tra parentesi e quindi posizionando l'argomento tra parentesi in questo modo:

(lambda n:[99999*n,-99998*n])(arg)

* Grazie a @ vioz- per avermi suggerito questo.

Esempio di input / output:

>>> (lambda n:[99999*n,-99998*n])(1)
[99999, -99998]
>>> (lambda n:[99999*n,-99998*n])(2)
[199998, -199996]
>>> (lambda n:[99999*n,-99998*n])(0)
[0, 0]
>>> (lambda n:[99999*n,-99998*n])(-1)
[-99999, 99998]
>>> (lambda n:[99999*n,-99998*n])(-2)
[-199998, 199996]
>>> (lambda n:[99999*n,-99998*n])(65536)
[6553534464, -6553468928]

Haskell, 16 byte

Ho spudoratamente copiato il metodo di @ xnor. Probabilmente non c'è molto meglio di questo.

f x=(-x^3,x^3+x)