Vous devez écrire un programme ou une fonction qui reçoit un entier en entrée et génère ou renvoie deux entiers dont la somme est la première.

Il y a une autre exigence: aucun nombre ne peut faire partie de la sortie pour deux entrées différentes .

Détails

• Vous devriez être capable de gérer les entrées pour au moins la plage -32768 .. 32767(incluse).
• Si votre type de données ne peut pas gérer des nombres entiers arbitraires, c'est bien, mais votre algorithme devrait fonctionner en théorie pour les grands et les petits nombres arbitraires.

Exemples

Chaque bloc montre une partie d'une solution correcte ou incorrecte au format 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.

C'est le golf de code, donc l'entrée la plus courte gagne.

Pyth, 8 octets

_J^Q3+QJ

Manifestation. Équivalent au code Python 2:

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

Ainsi, la sortie a la forme (-n**3, n+n**3)

Quelques sorties:

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

Celles-ci sont distinctes car les cubes sont suffisamment espacés que l'ajout nà n**3n'est pas suffisant pour traverser l'espace vers le cube suivant: n**3 < n+n**3 < (n+1)**3pour le positif net symétriquement pour le négatif n.

Snowman 0.1.0 , 101 caractères

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

Entrée sur STDIN, sortie séparée par des espaces sur STDOUT.

Cela utilise la même méthode que la réponse de isaacg.

Version commentée avec des nouvelles lignes, pour "lisibilité":

}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

Commentaire sur la toute première solution Snowman sur PPCG: Je pense que mon objectif de conception de rendre mon langage aussi déroutant que possible a été atteint.

En fait, cela aurait pu être beaucoup plus court, mais je suis un idiot et j'ai oublié d'implémenter des nombres négatifs pour la chaîne -> l'analyse des nombres. J'ai donc dû vérifier manuellement s'il y avait un -comme premier caractère et le supprimer si c'est le cas.

Pyth, 15 11 octets

4 octets grâce à @Jakube

*RQ,hJ.aQ_J

Manifestation.

Cela correspond comme suit:

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

Et ainsi de suite, impliquant toujours n^2et n^2 + n, plus ou moins.

APL, 15 octets

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

Cela crée une fonction monadique sans nom qui renvoie la paire -n ^ 3 ( -⍵*3), n + n ^ 3 ( ⍵+⍵*3).

Vous pouvez l' essayer en ligne .

Pyth - 11 10 octets

Multiplie simplement par 10e10 et -10e10 + 1 Merci à @xnor de m'avoir montré que je pouvais utiliser CGpour le nombre.

*CGQ_*tCGQ

Essayez-le en ligne ici .

O , 17 15 9 octets

Utilise quelques nouvelles fonctionnalités de O.

Q3 ^ .Q + p_p

Ancienne version

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

Python 3, 29 27

Modifier: ne répond pas à l'exigence du 2e point "Détails"

Bonus: cela fonctionne de -99998 à 99998 inclus

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

Cela crée une fonction anonyme *, que vous pouvez utiliser en plaçant entre crochets puis en plaçant l'argument entre crochets comme ceci:

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

* Merci à @ vioz- de l'avoir suggéré.

Exemple d'entrée / sortie:

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

J'ai copié sans vergogne la méthode de @ xnor. Il n'y a probablement rien de mieux que cela.

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