Debe escribir un programa o función que reciba un número entero como entrada y salida o que devuelva dos enteros cuya suma sea la primera.

Hay un requisito adicional: ningún número puede ser parte de la salida para dos entradas diferentes .

Detalles

• Debería poder manejar entradas para al menos el rango -32768 .. 32767(inclusive).
• Si su tipo de datos no puede manejar números enteros arbitrarios, está bien, pero su algoritmo debería funcionar para números arbitrarios grandes y pequeños en teoría.

Ejemplos

Cada bloque muestra una parte de una solución correcta o incorrecta en el formato de 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.

Este es el código de golf por lo que gana la entrada más corta

Pyth, 8 bytes

_J^Q3+QJ

Demostración. Equivalente al código Python 2:

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

Entonces, la salida tiene forma (-n**3, n+n**3)

Algunas salidas:

-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)

Estos son distintas porque cubos están lo suficientemente espaciadas que la adición na n**3no es suficiente para cruzar la brecha a la siguiente cubo: n**3 < n+n**3 < (n+1)**3para el positivo n, y simétricamente para el negativo n.

Muñeco de nieve 0.1.0 , 101 caracteres

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

Entrada en STDIN, salida separada por espacios en STDOUT.

Esto usa el mismo método que la respuesta de Isaac.

Versión comentada con nuevas líneas, para "legibilidad":

}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

Comentario sobre la primera solución de Snowman en PPCG: creo que se ha logrado mi objetivo de diseño de hacer que mi lenguaje sea lo más confuso posible.

En realidad, esto podría haber sido mucho más corto, pero soy un idiota y olvidé implementar números negativos para el análisis de cadena -> número. Así que tuve que verificar manualmente si había un -como primer carácter y eliminarlo si es así.

Pyth, 15 11 bytes

4 bytes gracias a @Jakube

*RQ,hJ.aQ_J

Demostración.

Esto se asigna de la siguiente manera:

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

Y así, en adelante, siempre involucrando n^2y n^2 + n, más o menos.

APL, 15 bytes

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

Esto crea una función monádica sin nombre que devuelve el par -n ^ 3 ( -⍵*3), n + n ^ 3 ( ⍵+⍵*3).

Puedes probarlo en línea .

Pyth - 11 10 bytes

Simplemente se multiplica por 10e10 y -10e10 + 1 Gracias a @xnor por mostrarme que podría usar CGel número.

*CGQ_*tCGQ

Pruébelo en línea aquí .

O , 17 15 9 bytes

Utiliza algunas características nuevas de O.

Q3 ^ .Q + p_p

Versión antigua

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

Pitón 3, 29 27

Editar: no cumple con el requisito en la segunda viñeta "Detalles"

Bonificación: funciona desde -99998 hasta 99998 inclusive

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

Esto crea una función anónima *, que puede usar entre corchetes y luego colocando el argumento entre paréntesis después de esta manera:

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

* Gracias a @ vioz- por sugerir esto.

Ejemplo de entrada / salida:

>>> (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 bytes

Copié descaradamente el método de @xnor. Probablemente no haya mucho mejor que esto.

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