Explicación:

El año pasado en la clase de matemáticas, en la tarea, ocasionalmente recibíamos estas preguntas extremadamente simples, aunque igualmente molestas, llamadas rompecabezas de diamantes. Estas eran básicamente preguntas en las que se nos daría una suma, y ​​luego se le pedía a un producto que encontrara los dos números que, cuando se multiplicaban, daban el producto, y cuando se sumaban, daban la suma. Esto me volvió loco, ya que la única forma en que sabía cómo resolverlos (en Álgebra I) era simplemente enumerar los factores del producto y luego ver cuáles sumaban para hacer la suma. (Como no sabía cómo usar Quadratics en ese momento) Sin mencionar que no eran exactamente un desafío matemático. Sin embargo, se me ocurrió que debería haber escrito un programa. ¡Ese es tu desafío hoy! Escribe un programa que pueda resolver un rompecabezas de diamantes.

Ejemplos Disculpas por la imagen borrosa, es lo mejor que pude encontrar. Además, ignore los números en burbujas. La parte superior del diamante es el producto, la parte inferior es la suma, la derecha y la izquierda son los dos números. Las respuestas son las siguientes: (Estos también son sus casos de prueba)

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

Reglas:

• No puede utilizar ninguna función o clase predefinida que logre esto por usted.
• Su código debe ser un programa completo o una función que devuelva o imprima las respuestas una vez que las encuentre
• La entrada es la suma y el producto, que se ingresan como parámetros de función o entrada del usuario

Presupuesto:

• Suponga que los dos números, la suma y el producto siempre serán un número entero.
• Las dos respuestas estarán entre -127 y 127.
• Su entrada será dos enteros (Suma y Producto).

Recuerde que esto es código golf, por lo que gana el conteo de bytes más corto. Titula tu respuesta con el ## nombre de idioma estándar, recuento de bytes

Editar: Además, Doorknob señaló que esto es esencialmente "factorizar un cuadrático de forma x ^ 2 + bx + c". Esa es otra forma de pensar y abordar este desafío. :RE

Jalea , 15 11 10 bytes

Hð+,_ðH²_½

Pruébalo en línea!

El siguiente código binario funciona con esta versión del intérprete Jelly.

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

Idea

Esto se basa en el hecho de que

Código

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.

Unicornio , 4650 2982 1874 1546

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

¡Ahora con cabras, arcoiris y destellos!

Esperemos que sea más corto que Java.

Utiliza una codificación personalizada que se puede aplicar conApplyEncoding

Explicación

¿¿¿Como funciona esto??? Con la magia de los unicornios (y un pequeño código).

Unicornio está compilado en JavaScript

Cada sección está separada por un espacio, y cada sección representa un carácter en el código JavaScript.

Si la sección contiene unicornios, el carácter de la sección es la longitud de la sección, convertida en un código char (por ejemplo, 32 unicornios serían un espacio)

Si la sección contiene cabras, la longitud de la sección se duplica y luego se convierte en un código char.

Si los caracteres especiales del programa no se muestran, aquí hay una imagen:

Esto no compite porque Unicornio se creó después de que se publicó este desafío.

JavaScript ES6, 45 39 37 ^* bytes

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

^{* Gracias a Dennis!}

TeaScript, 22 bytes 30 31

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

No esta tan mal. Sería mucho más corto si pudiera obtener algunas características de golf terminadas antes, como los accesos directos unicode de unicornio

Pruébalo en línea

MATL , 33 bytes

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

Emite los dos números en dos líneas diferentes. Si no existe una solución, no produce salida. Si existen varias soluciones, produce solo el par de números correspondientes a una solución.

Ejemplo

Lo siguiente se ejecutó en Octave con la confirmación actual de GitHub del compilador.

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

Explicación

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

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

Una función f que toma la suma y luego el producto.

Mi primera respuesta de Julia. @AlexA., Deberías estar orgulloso de mí.

Gracias @Dennis y @Alex A. por toda la ayuda. Tengo que tachar el 44.: P

dc, 16

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

Lee la suma y luego el producto de líneas separadas de STDIN. -ve números deben ingresarse con un guión bajo en lugar de un signo menos. p.ej

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

Explicación:

La misma solución cuadrática básica para sum = a + by product = a * b. Esto calcula la solución acomo:

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

Y calcula la solución bcomo:

b = sum - a

Expandido:

?                   # 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 división por 2 se hace tarde para evitar la pérdida de precisión. Es posible dividir por 2 antes, pero esto requiere una precisión fraccional que necesita más caracteres.

Pyth, 21 18 bytes

Guardado 3 bytes gracias a @Dennis

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

Banco de pruebas

Mi segundo programa de Pyth, por lo que probablemente pueda jugar golf con funciones integradas. ¡Sugerencias son bienvenidas!

Cómo funciona

,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.

(Esta explicación puede no ser 100% correcta; no estoy muy familiarizado con Pyth).

Tenga en cuenta que /es la división de enteros. Al reemplazarlo por c, podríamos hacer que esto funcione también con entradas no enteras.

Java, 82 (69 λ) bytes con fórmula cuadrática (fuerza bruta de 127 (114 λ) bytes)

Fuerza bruta: (Vanilla, 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;}

λ mejorado: (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;}

Asignar lambda a java.util.function.BiFunction<Integer, Integer, int[]>y llamarapply() .

Enfoque simple de fuerza bruta. Solo la función de trabajo está aquí, y dado que Java no puede devolver múltiples valores, devolvemos un elemento de 2int matriz de con los números requeridos.

El programa completo basado en el enfoque de fuerza bruta se puede encontrar aquí en ideone.com , con la versión λ aquí.

Jugar al golf implicaba eliminar todos los aparatos innecesarios.

Sin 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;}

Enfoque cuadrático: (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};}

λ-mejorado: (Java 8) (s, p) -> {int x = s + (int) Math.sqrt (s * s-4 * p); devuelve nuevo int [] {x / 2, sx / 2} ;}

(Uso como para fuerza bruta λ arriba).

Los parámetros y los criterios de retorno son los mismos que la solución de fuerza bruta anterior.

Utiliza la buena fórmula cuadrática usada por casi todas las otras respuestas aquí, y no se puede jugar mucho más a menos que alguien me ayude aquí. Está bastante claro, así que no estoy incluyendo una versión sin golf.

El programa basado en el enfoque cuadrático completo está aquí en ideone.com , con la versión λ aquí.

Japt , 28 22 21 20 bytes

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

La entrada se realiza en forma de -63 2 .

Explicación:

• Uy Vson las dos entradas ( -63y 2en el primer caso)
• ² cuadra el número
• q extrae la raíz cuadrada

APL, 27 21 bytes

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

Este es un tren de funciones diádicas que acepta enteros a la derecha e izquierda y devuelve una matriz. Para llamarlo, asígnelo a una variable.

Sin 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

Pruébalo en línea

¡Guardado 6 bytes gracias a Dennis!

CJam, 18 bytes

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

Pruébalo en línea!

Cómo funciona

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.

Pitón 3, 49 44 bytes

Probablemente hay algunas formas de jugar golf aún más lejos, pero esto se ve bastante bien como está.

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

MathCAD 15. 38 Bytes

Con una fórmula matemática, programar en MathCAD es fácil. El lenguaje incluso está diseñado para manejar números complejos con facilidad. Sin embargo, hay idiomas más cortos que pueden resolver el problema.

𝔼𝕊𝕄𝕚𝕟, 21 caracteres / 30 bytes

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

Try it here (Firefox only).

Meh Esto debería ser lo suficientemente visual para que todos ustedes puedan entender la idea; Sin embargo, si es necesario, î = input1, í = input2.

PHP, 62 bytes

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

Esto podría ser bastante largo pero ser un "programa" web PHP completo. Acepta los argumentos a través de la solicitud "get".

Demostración .

TI-BASIC, 20 bytes

Toma Qde Ansy Pde Prompt. Llama como P:prgmNAME.

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