Explication:

L'année dernière, en cours de mathématiques, sur les devoirs, nous obtenions parfois ces questions extrêmement simples, bien que tout aussi ennuyeuses, appelées puzzles de diamants. C'étaient essentiellement des questions où l'on nous donnerait une somme, et un produit devait ensuite trouver les deux nombres qui, multipliés, donnent le produit et, lorsqu'ils sont ajoutés, donnent la somme. Cela m'a rendu fou, car la seule façon dont je savais comment les résoudre (dans Algèbre I) était de simplement lister les facteurs du produit puis de voir ceux qui étaient ajoutés pour faire la somme. (Comme je ne savais pas comment utiliser Quadratics à l'époque) Sans parler, ils n'étaient pas vraiment un défi mathématique. Cependant, il m'est venu à l'esprit que j'aurais dû écrire un programme. Voilà donc votre défi aujourd'hui! Écrivez un programme qui peut résoudre un puzzle en diamant.

Exemples Excuses pour l'image floue, c'est la meilleure que j'ai pu trouver. En outre, ignorez les nombres dans les bulles.Le haut du diamant est le produit, le bas est la somme, la droite et la gauche sont les deux nombres. Les réponses sont les suivantes: (Ce sont aussi vos cas de test)

1. 9, -7
2. -2, -1
3. 5, 8
4. -9, -9

Règles:

• Vous ne pouvez pas utiliser de fonctions ou de classes prédéfinies qui accomplissent cela pour vous.
• Votre code doit être un programme complet ou une fonction qui retourne ou imprime les réponses une fois qu'il les trouve
• L'entrée est la somme et le produit, qui sont entrés en tant que paramètres de fonction ou entrée utilisateur

Caractéristiques:

• Supposons que les deux nombres, la somme et le produit seront toujours un entier.
• Les deux réponses seront toutes deux comprises entre -127 et 127.
• Votre entrée sera composée de deux entiers (Sum et Product).

N'oubliez pas qu'il s'agit de golf de code, donc le nombre d'octets le plus court l'emporte. Veuillez titrer votre réponse avec le ## Nom de la langue standard, Nombre d'octets

Edit: Aussi, Doorknob a souligné qu'il s'agit essentiellement de "factoriser un quadratique de forme x ^ 2 + bx + c". C'est une autre façon de penser et d'aborder ce défi. :RÉ

Gelée , 15 11 10 octets

Hð+,_ðH²_½

Essayez-le en ligne!

Le code binaire suivant fonctionne avec cette version de l'interpréteur Jelly.

0000000: 48 98 2b 2c 5f 98 48 8a 5f 90  H.+,_.H._.

Idée

Ceci est basé sur le fait que

Code

Hð+,_ðH²_½    Left input: s -- Right input: p

 ð   ð        This is a link fork. We define three links, call the left and right
              link with the input as arguments, then the middle link with the
              results as arguments.

H             Left link, dyadic. Arguments: s p

H             Halve the left input.

     ðH²_½    Right link, dyadic. Arguments: s p

      H       Halve the left input.
       ²      Square the result.
        _     Hook; subtract the right input from the result.
         ½    Apply square root to the difference.

 ð+,_         Middle link, dyadic. Arguments: (results of the previous links)

  +           Compute the sum of the results.
    _         Compute the difference of the results.
   ,          Pair.

Licorne , 4650 2982 1874 1546

[ ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨ 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 ( 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨ 🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 ( ) ) 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 2 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨ 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 ( 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 ✨✨✨✨✨✨✨ 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 4 🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨ 🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 ( ) ) 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤 ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨ ]

Maintenant avec des chèvres, des arcs-en-ciel et des étincelles!

Si tout va bien plus court que Java.

Utilise un encodage personnalisé qui peut être appliqué avecApplyEncoding

Explication

Comment cela marche-t-il??? Avec la magie des licornes (et un peu de code).

La licorne est compilée en JavaScript

Chaque section est séparée par un espace et chaque section représente un caractère dans le code JavaScript.

Si la section contient des licornes, le caractère de la section est la longueur de la section, convertie en un code de caractère (par exemple, 32 licornes seraient un espace)

Si la section contient des chèvres, la longueur de la section est doublée puis convertie en code char.

Si les caractères spéciaux du programme ne s'affichent pas, voici une image:

Ce n'est pas une compétition car Unicorn a été créé après la publication de ce défi.

JavaScript ES6, 45 39 37 ^* octets

(q,p)=>[x=p/2+Math.sqrt(p*p/4-q),p-x]

^{* Merci à Dennis!}

TeaScript, 22 octets 30 31

[d=y/2+$s(y*y/4-x),y-d

Pas si mal. Serait beaucoup plus court si je pouvais obtenir des fonctionnalités de golf terminées plus tôt, telles que des raccourcis Unicode de licorne

Essayez-le en ligne

MATL , 33 octets

-100:100t!2$t+i=bb*i=&2#2$1fv101-

Sort les deux nombres sur deux lignes différentes. Si aucune solution n'existe, elle ne produit aucune sortie. S'il existe plusieurs solutions, il ne produit que la paire de nombres correspondant à une solution.

Exemple

Ce qui suit a été exécuté dans Octave avec la validation GitHub actuelle du compilateur.

>> matl -r '-100:100t!2$t+i=bb*i=&2#2$1fv101-'
> 2
> -63
 9
-7

Explication

-100:100           % row vector -100, -99, ..., 100
t!                 % duplicate and transpose into column vector
2$t                % duplicate the two vectors
+                  % sum with singleton expansion (all combinations)
i=                 % does it equal input? Produces logical matrix
bb                 % move the two vectors to top
*                  % multiply with singleton expansion (all combinations)
i=                 % does it equal input? Produces logical matrix
&                  % logical "and"
2#2$1f             % find row and column of the first "true" value in logical matrix
v101-              % concatenate vertically and subtract 101

Julia, 46 44 32 octets

f(b,c)=(x=b+√(b^2-4c))/2,b-x/2

Une fonction f qui prend la somme puis le produit.

Ma première réponse Julia. @AlexA., Vous devriez être fier de moi.

Merci @Dennis et @Alex A. pour toute l'aide. Je dois barrer le 44.: P

dc, 16

?ddd*?4*-v+2/p-p

Lit la somme puis le produit à partir de lignes distinctes de STDIN. Les nombres -ve doivent être entrés avec un trait de soulignement au lieu d'un signe moins. par exemple

$ { echo 2; echo _63; } | dc -e'?ddd*?4*-v+2/p-p'
9
-7
$ 

Explication:

Même solution quadratique de base pour sum = a + bet product = a * b. Cela calcule la solution acomme:

a = [ sum + √( sum² - 4 * product ) ] / 2

Et calcule la solution bcomme:

b = sum - a

Étendu:

?                   # push sum to stack
 ddd                # duplicate 3 times (total 4 copies)
    *               # sum squared
     ?              # push product to stack
      4*            # multiply by 4
        -           # subtract (4 * product) from (sum squared)
         v          # take square root of (sum squared) - (4 * product)
          +         # add sum to square root of (sum squared) - (4 * product)
           2/       # divide by 2 to give solution a
             p      # print with newline and without pop
              -     # subtract solution a from sum to give solution b
               p    # print with newline and without pop

La division par 2 est effectuée tardivement pour éviter la perte de précision. Il est possible de diviser par 2 plus tôt, mais cela nécessite une précision fractionnaire qui nécessite plus de caractères.

Pyth, 21 18 octets

Sauvegardé 3 octets grâce à @Dennis

,J/+@-^Q2*4E2Q2-QJ

Suite de tests

Mon deuxième programme Pyth jamais, donc il peut probablement être joué avec des modules intégrés. Les suggestions sont les bienvenues!

Comment ça marche

,J/+@-^Q2*4E2Q2-QJ   Implicit: Q = first line of input
,                    Create and output a list of these items:
 J                     Set variable J to the result of these operations:
      ^Q2                Square Q.
     -   *4E             Subtract 4*(next line of input).
    @       2            Take the square root.
   +         Q           Add Q.
  /           2          Divide by 2.
                       The list is currently [J].
               -QJ     Push Q-J; the list is now [J, Q-J].
                     EOF; list is sent to output.

(Cette explication peut ne pas être correcte à 100%; je ne connais pas très bien Pyth.)

Notez que /c'est une division entière. En le remplaçant par c, nous pourrions également faire fonctionner cela avec des entrées non entières.

Java, 82 (69 λ) octets avec formule quadratique (127 (114 λ) octets force brute)

Brute-Force: (Vanille, Java 7)

int[] n(int s,int p){for(int a=-100;a<=100;a++)for(int b=-100;b<=100;b++) if(a+b==s&&a*b==p)return new int[]{a,b};return null;}

Amélioré λ: (Java 8)

(s,p)->{for(int a=-100;a<=100;a++)for(int b=-100;b<=100;b++) if(a+b==s&&a*b==p)return new int[]{a,b};return null;}

Attribuez lambda à java.util.function.BiFunction<Integer, Integer, int[]>et appelez apply().

Vieille approche brute par force brute. Seule la fonction de travail est là, et comme Java ne peut pas retourner plusieurs valeurs, nous renvoyons un inttableau à 2 éléments avec les nombres requis.

Le programme basé sur l'approche par force brute complète peut être trouvé ici sur ideone.com , avec la version λ ici.

Jouer au golf consistait à retirer toutes les bretelles inutiles.

Non golfé:

int[] n(int s,int p){//sum and product as function parameters,in that order
    for(int a=-100;a<=100;a++){//iterate first no. from -100 to 100
        for(int b=-100;b<=100;b++){//iterate second no. from -100 to 100
            //if the 2 nos. satisfy the diamond-puzzle condition, 
            //pack them in an int array and return them
            if(a+b==s&&a*b==p)return new int[]{a,b};}
     }//if no such pair exists, return null
return null;}

Approche quadratique: (Vanilla, Java 7)

int[] n(int s,int p){int x=s+(int)Math.sqrt(s*s-4*p);return new int[]{x/2,s-x/2};}

Amélioré λ: (Java 8) (s, p) -> {int x = s + (int) Math.sqrt (s * s-4 * p); retourne new int [] {x / 2, sx / 2} ;}

(Utilisation comme pour la force brute λ ci-dessus).

Les paramètres et les critères de retour sont les mêmes que la solution de force brute ci-dessus.

Utilise la bonne vieille formule quadratique utilisée par presque toutes les autres réponses ici, et ne peut pas être approfondie beaucoup moins que quelqu'un ne m'aide ici. C'est assez clair, donc je n'inclus pas de version non golfée.

Le programme basé sur l'approche quadratique complète est ici sur ideone.com , avec la version λ ici.

Japt , 28 22 21 20 octets

[X=V/2+(V²/4-U ¬V-X]

L'entrée se fait sous la forme de -63 2.

Explication:

• Uet Vsont les deux entrées (-63 et 2dans le premier cas)
• ² met le nombre au carré
• q extrait la racine carrée

APL, 27 21 octets

h(+,-).5*⍨⊣-⍨h×h←.5×⊢

Il s'agit d'un train de fonctions dyadiques qui accepte des entiers à droite et à gauche et renvoie un tableau. Pour l'appeler, affectez-le à une variable.

Non golfé:

                h←.5×⊢       ⍝ Define a train h for halving the input
              h×             ⍝ b^2/4
          ⊣-⍨                ⍝ b^2/4 - c
      .5*⍨                   ⍝ sqrt(b^2/4 - c)
h(+,-)                       ⍝ Return the halved pair

Essayez-le en ligne

6 octets enregistrés grâce à Dennis!

CJam, 18 octets

q~2d/_2#@-mq_2$+p-

Essayez-le en ligne!

Comment ça marche

q~                  e# Read an evaluate all input. STACK: product sum
  2d/               e# Divide the sum by 2.0.
     _              e# Push a copy of the result.
      2#            e# Square the copy.
        @-          e# Rotate the product on top and subtract it from the square.
          mq        e# Apply square root.
            _2$     e# Push copies of the root and the halved sum.
               +p   e# Add and print.
                 -  e# Subtract the originals.

Python 3, 49 44 octets

Il existe probablement quelques façons de jouer au golf encore plus loin, mais cela semble assez bon tel quel.

def f(s,p):s/=2;d=(s*s-p)**.5;return s+d,s-d

MathCAD 15. 38 octets

Avec une formule mathématique, la programmation dans MathCAD est facile. Le langage est même conçu pour gérer facilement des nombres complexes. Cependant, il existe des langues plus courtes qui peuvent résoudre le problème.

𝔼𝕊𝕄𝕚𝕟, 21 caractères / 30 octets

[x=í/2+√ í²/4-î⦆,í-x]

Try it here (Firefox only).

Meh. Cela devrait être assez visuel pour que vous puissiez tous avoir l'idée; cependant, si vous devez î = input1, í = input2,.

PHP, 62 octets

<?=($x=($p=$_GET[p])/2+sqrt($p*$p/4-$q=$_GET[q]))." ".($p-$x);

Cela pourrait être assez long mais être un "programme" web PHP complet. Accepte les arguments via la requête "get".

Démo .

TI-BASIC, 20 octets

Prend Qde Anset Pde Prompt. Appelez comme P:prgmNAME.

Prompt P
P/2+√(P²/4-Ans
{Ans,P-Ans