Explicação:

No ano passado, na aula de matemática, nos trabalhos de casa, ocasionalmente, recebíamos essas perguntas extremamente simples, embora igualmente irritantes, chamadas quebra-cabeças de diamante. Essas eram basicamente perguntas nas quais receberíamos uma soma, e um produto foi solicitado a encontrar os dois números que, quando multiplicados, dão o produto e, quando adicionados, dão a soma. Isso me deixou louco, já que a única maneira de saber como resolvê-los (em Álgebra I) era apenas listar os fatores do produto e depois ver quais foram adicionados para fazer a soma. (Como eu não sabia usar Quadratics na época). Sem mencionar, eles não eram exatamente um desafio matemático. No entanto, ocorreu-me que eu deveria ter acabado de escrever um programa. Então esse é o seu desafio hoje! Escreva um programa que possa resolver um quebra-cabeça de diamante.

Exemplos Desculpas pela imagem embaçada, é o melhor que pude encontrar. Além disso, ignore os números em bolhas. A parte superior do diamante é o produto, a parte inferior é a soma, a direita e a esquerda são os dois números. As respostas são as seguintes: (Esses também são seus casos de teste)

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

Regras:

• Você não pode usar nenhuma função ou classe predefinida que realize isso para você.
• Seu código deve ser um programa completo ou função que retorne ou imprima as respostas assim que as encontrar
• A entrada é a soma e o produto, que são inseridos como parâmetros de função ou como entrada do usuário

Especificações:

• Suponha que os dois números, a soma e o produto sempre sejam um número inteiro.
• As duas respostas estarão entre -127 e 127.
• Sua entrada será dois números inteiros (soma e produto).

Lembre-se de que isso é código-golfe, e a menor contagem de bytes vence. Nomeie sua resposta com o padrão ## Nome do idioma, contagem de bytes

Edit: Além disso, Maçaneta apontou que este é essencialmente "fator a quadrático da forma x ^ 2 + bx + c". Essa é outra maneira de pensar e abordar esse desafio. : D

Geléia , 15 11 10 bytes

Hð+,_ðH²_½

Experimente online!

O código binário a seguir funciona com esta versão do interpretador Jelly.

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

Idéia

Isso se baseia no fato 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.

Unicórnio , 4650 2982 1874 1546

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

Agora com cabras, arco-íris e brilhos!

Esperançosamente mais curto que Java.

Usa uma codificação personalizada que pode ser aplicada comApplyEncoding

Explicação

Como é que isso funciona??? Com a magia dos unicórnios (e um pouco de código).

Unicorn é compilado em JavaScript

Cada seção é separada por um espaço e cada seção representa um caractere no código JavaScript.

Se a seção contiver unicórnios, o caractere da seção será o comprimento da seção, convertido em um código de char (por exemplo, 32 unicórnios seriam um espaço)

Se a seção contiver cabras, o comprimento da seção será dobrado e depois convertido em um código de char.

Se os caracteres especiais do programa não aparecerem, aqui está uma figura:

Isso não é competitivo porque o Unicorn foi criado após o lançamento deste desafio.

JavaScript ES6, 45 39 37 ^* bytes

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

^{* Obrigado ao Dennis!}

TeaScript, 22 bytes 30 31

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

Não é tão ruim assim. Seria muito menor se eu pudesse obter alguns recursos de golfe terminados anteriormente, como unicórnio atalhos unicode

Experimente online

MATL , 33 bytes

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

Produz os dois números em duas linhas diferentes. Se não houver solução, ela não produzirá saída. Se existirem várias soluções, produz apenas o par de números correspondente a uma solução.

Exemplo

O seguinte foi executado no Octave com o commit atual do GitHub do compilador.

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

Explicação

-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

Uma função f que recebe a soma e depois o produto.

Minha primeira resposta de Julia. @AlexA., Você deve se orgulhar de mim.

Obrigado @Dennis e @Alex A. por toda a ajuda. Eu tenho que atravessar o 44.: P

dc, 16

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

Lê a soma e o produto de linhas separadas de STDIN. números -ve devem ser inseridos com um sublinhado em vez de um sinal de menos. por exemplo

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

Explicação:

A mesma solução quadrática básica para sum = a + be product = a * b. Isso calcula a solução acomo:

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

E calcula a solução 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

A divisão por 2 é feita tarde para evitar a precisão da perda. É possível dividir por 2 anteriormente, mas isso requer precisão fracionada, que precisa de mais caracteres.

Pitão, 21 18 bytes

Guardado 3 bytes graças a @Dennis

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

Suíte de teste

Meu segundo programa Pyth de todos os tempos, por isso provavelmente pode ser jogado com built-ins. Sugestões são bem-vindas!

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

(Essa explicação pode não estar 100% correta; não estou muito familiarizado com Pyth.)

Observe que /é a divisão inteira. Ao substituí-lo c, poderíamos fazer isso funcionar com entradas não inteiras também.

Java, 82 (69 λ) bytes com fórmula quadrática (127 (114 λ) bytes força bruta)

Força Bruta: (Baunilha, 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;}

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

Atribua lambda java.util.function.BiFunction<Integer, Integer, int[]>e ligue apply().

Abordagem simples de força bruta. Apenas a função de trabalho está aqui e, como o Java não pode retornar vários valores, retornamos uma intmatriz de 2 elementos com os números necessários.

O programa completo de abordagem da força bruta pode ser encontrado aqui em ideone.com , com a versão λ aqui.

Jogar golfe envolvia remover todos os aparelhos desnecessários.

Ungolfed:

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

Abordagem quadrática: (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};}

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

(Uso como para força bruta λ acima).

Os parâmetros e critérios de retorno são os mesmos da solução de força bruta acima.

Usa a boa e velha fórmula quadrática usada por quase todas as outras respostas aqui, e não pode ser reduzida ainda mais, a menos que alguém me ajude aqui. Está bem claro, então não incluo uma versão não destruída.

O programa baseado em abordagem quadrática completo está aqui em ideone.com , com a versão λ aqui.

Japt , 28 22 21 20 bytes

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

A entrada é feita na forma de -63 2.

Explicação:

• Ue Vsão as duas entradas ( -63e 2no primeiro caso)
• ² esquadrinha o número
• q extrai a raiz quadrada

APL, 27 21 bytes

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

Este é um trem de funções diádicas que aceita números inteiros à direita e à esquerda e retorna uma matriz. Para chamá-lo, atribua-o a uma variável.

Ungolfed:

                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

Experimente online

Economizou 6 bytes graças a Dennis!

CJam, 18 bytes

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

Experimente online!

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

Python 3, 49 44 bytes

Provavelmente, existem algumas maneiras de jogar isso ainda mais, mas isso parece muito bom.

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

MathCAD 15. 38 bytes

Com uma fórmula matemática, a programação no MathCAD é fácil. A linguagem foi projetada para lidar com números complexos com facilidade. No entanto, existem idiomas mais curtos que podem resolver o problema.

, 21 caracteres / 30 bytes

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

Try it here (Firefox only).

Meh. Isso deve ser visual o suficiente para vocês entenderem a idéia; no entanto, se você precisar î = input1, í = input2,.

PHP, 62 bytes

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

Isso pode ser bastante longo, mas ter um programa PHP completo para a web. Aceita os argumentos por meio da solicitação "get".

Demo .

TI-BASIC, 20 bytes

Toma Qde Anse Pde Prompt. Ligue como P:prgmNAME.

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