Spiegazione:

L'anno scorso, durante le lezioni di matematica, a volte facevamo queste domande estremamente semplici, sebbene ugualmente fastidiose, chiamate puzzle di diamanti. Queste erano fondamentalmente domande su dove ci sarebbe stata data una somma, e poi a un prodotto veniva chiesto di trovare i due numeri che una volta moltiplicati danno il prodotto e quando aggiunti danno la somma. Ciò mi ha fatto impazzire, poiché l'unico modo in cui sapevo come risolverli (in Algebra I) era semplicemente elencare i fattori del prodotto, quindi vedere quali aggiunti per fare la somma. (Dal momento che non sapevo come usare Quadratics in quel momento) Per non parlare del fatto che non stavano esattamente sfidando la matematica. Tuttavia, mi è appena venuto in mente che avrei dovuto scrivere un programma. Questa è la tua sfida oggi! Scrivi un programma in grado di risolvere un rompicapo con diamanti.

Esempi Mi scuso per l'immagine sfocata, è la migliore che ho trovato. Inoltre, ignora i numeri in bolle. La parte superiore del diamante è il prodotto, la parte inferiore è la somma, la destra e la sinistra sono i due numeri. Le risposte sono le seguenti: (Questi sono anche i tuoi casi di test)

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

Regole:

• Non è possibile utilizzare funzioni o classi predefinite che lo realizzano.
• Il codice deve essere un programma completo o una funzione che restituisce o stampa le risposte una volta trovate
• L'input è la somma e il prodotto, che vengono immessi come parametri di funzione o input dell'utente

specifiche tecniche:

• Supponiamo che i due numeri, la somma e il prodotto saranno sempre numeri interi.
• Le due risposte saranno entrambe comprese tra -127 e 127.
• Il tuo input sarà di due numeri interi (somma e prodotto).

Ricorda che si tratta di code-golf, quindi vince il conteggio dei byte più breve. Assegna un titolo alla risposta con il nome lingua standard ##, il conteggio byte

Modifica: Inoltre, Doorknob ha sottolineato che questo è essenzialmente "un fattore quadratico di forma x ^ 2 + bx + c". Questo è un altro modo di pensare e affrontare questa sfida. : D

Gelatina , 15 11 10 byte

Hð+,_ðH²_½

Provalo online!

Il seguente codice binario funziona con questa versione dell'interprete Jelly.

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

Idea

Questo si basa sul fatto che

Codice

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.

Unicorno , 4650 2982 1874 1546

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

Ora con capre, arcobaleni e scintillii!

Si spera più corto di Java.

Utilizza una codifica personalizzata che può essere applicata conApplyEncoding

Spiegazione

Come funziona??? Con la magia degli unicorni (e un piccolo codice).

Unicorn è compilato in JavaScript

Ogni sezione è separata da uno spazio e ogni sezione rappresenta un carattere nel codice JavaScript.

Se la sezione contiene unicorni, il carattere della sezione è la lunghezza della sezione, convertita in un codice char (ad es. 32 unicorni sarebbero uno spazio)

Se la sezione contiene capre, la lunghezza della sezione viene raddoppiata e quindi convertita in un codice char.

Se i caratteri speciali del programma non vengono visualizzati, ecco un'immagine:

Questo non è in competizione perché Unicorn è stato realizzato dopo che questa sfida è stata pubblicata.

JavaScript ES6, 45 39 37 ^* byte

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

^{* Grazie a Dennis!}

TeaScript, 22 byte 30 31

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

Non così male. Sarebbe molto più breve se potessi ottenere alcune funzionalità di golf finite prima come scorciatoie unicorno unicorno

Provalo online

MATL , 33 byte

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

Emette i due numeri in due righe diverse. Se non esiste alcuna soluzione, non produce alcun output. Se esistono diverse soluzioni produce solo la coppia di numeri corrispondenti a una soluzione.

Esempio

Quanto segue è stato eseguito in Octave con il commit GitHub corrente del compilatore.

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

Spiegazione

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

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

Una funzione f che prende la somma e quindi il prodotto.

La mia prima risposta di Julia. @AlexA., Dovresti essere orgoglioso di me.

Grazie @Dennis e @Alex A. per tutto l'aiuto. Devo cancellare il 44.: P

dc, 16

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

Legge la somma quindi il prodotto da righe separate di STDIN. -ve i numeri devono essere inseriti con un trattino basso anziché un segno meno. per esempio

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

Spiegazione:

Stessa soluzione quadratica di base per sum = a + be product = a * b. Questo calcola la soluzione acome:

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

E calcola la soluzione bcome:

b = sum - a

Allargato:

?                   # 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 divisione per 2 viene eseguita in ritardo per prevenire la precisione delle perdite. È possibile dividere per 2 prima, ma ciò richiede una precisione frazionata che richiede più caratteri.

Pyth, 21 18 byte

Salvato 3 byte grazie a @Dennis

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

Suite di test

Il mio secondo programma Pyth di sempre, quindi probabilmente può essere giocato a golf con built-in. I suggerimenti sono benvenuti!

Come funziona

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

(Questa spiegazione potrebbe non essere corretta al 100%; non ho molta familiarità con Pyth.)

Si noti che /è una divisione intera. Sostituendolo con c, potremmo farlo funzionare anche con input non interi.

Java, 82 (69 λ) byte con formula quadratica (127 (114 λ) byte forza bruta)

Brute-Force: (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;}

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

Assegna lambda a java.util.function.BiFunction<Integer, Integer, int[]>e chiama apply().

Semplice approccio alla forza bruta. Solo la funzione di lavoro è qui e poiché Java non può restituire più valori, restituiamo un intarray di 2 elementi con i numeri richiesti.

L'intero programma basato sulla forza bruta può essere trovato qui su ideone.com , con la versione λ qui.

Giocare a golf ha comportato la rimozione di tutti gli apparecchi non necessari.

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

Approccio quadratico: (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};}

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

(Uso come per la forza bruta λ sopra).

I parametri e i criteri di ritorno sono gli stessi della soluzione di forza bruta sopra.

Utilizza la buona vecchia formula quadratica usata da quasi tutte le altre risposte qui, e non può essere ulteriormente approfondita a meno che qualcuno non mi aiuti. È abbastanza chiaro, quindi non includo una versione non giocata.

L'intero programma basato sull'approccio quadratico è qui su ideone.com , con la versione λ qui.

Japt , 28 22 21 20 byte

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

L'input viene effettuato sotto forma di -63 2.

Spiegazione:

• Ue Vsono i due ingressi ( -63e 2nel primo caso)
• ² piazza il numero
• q estrae la radice quadrata

APL, 27 21 byte

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

Questo è un treno di funzioni diadico che accetta numeri interi a destra e a sinistra e restituisce un array. Per chiamarlo, assegnarlo a una variabile.

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

Provalo online

6 byte salvati grazie a Dennis!

CJam, 18 byte

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

Provalo online!

Come funziona

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 byte

Probabilmente ci sono alcuni modi per giocare ancora più a fondo, ma questo sembra abbastanza buono come è.

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

MathCAD 15. 38 byte

Con una formula matematica, la programmazione in MathCAD è semplice. La lingua è persino progettata per gestire con facilità numeri complessi. Tuttavia ci sono lingue più brevi che possono risolvere il problema.

𝔼𝕊𝕄𝕚𝕟, 21 caratteri / 30 byte

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

Try it here (Firefox only).

Meh. Questo dovrebbe essere abbastanza visivo per tutti voi per avere l'idea; tuttavia, se è necessario î = input1, í = input2,.

PHP, 62 byte

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

Potrebbe essere piuttosto lungo, ma essendo un "programma" web completo di PHP. Accetta gli argomenti tramite la richiesta "get".

Demo .

TI-BASIC, 20 byte

Prende Qda Anse Pda Prompt. Chiama come P:prgmNAME.

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