Erläuterung:

Letztes Jahr im Matheunterricht bekamen wir bei den Hausaufgaben gelegentlich diese extrem einfachen, wenn auch ebenso nervigen Fragen, die als Diamant-Rätsel bezeichnet wurden. Dies waren im Grunde genommen Fragen, bei denen wir eine Summe erhalten, und ein Produkt wurde dann gebeten, die beiden Zahlen zu finden, die, wenn sie multipliziert werden, das Produkt ergeben und wenn sie addiert werden, die Summe ergeben. Diese machten mich verrückt, da ich sie (in Algebra I) nur lösen konnte, indem ich nur die Faktoren des Produkts auflistete und dann sah, welche addiert wurden, um die Summe zu ergeben. (Da ich zu der Zeit nicht wusste, wie man Quadratics benutzt) Ganz zu schweigen davon, dass sie nicht gerade die Mathematik herausfordern. Mir ist jedoch gerade eingefallen, dass ich gerade ein Programm hätte schreiben sollen. Das ist heute Ihre Herausforderung! Schreiben Sie ein Programm, mit dem Sie ein Diamant-Puzzle lösen können.

Beispiele Entschuldigung für das verschwommene Bild, es ist das Beste, was ich finden konnte. Ignorieren Sie auch die Zahlen in Blasen. Die Oberseite des Diamanten ist das Produkt, die Unterseite ist die Summe, rechts und links sind die beiden Zahlen. Die Antworten lauten wie folgt: (Dies sind auch Ihre Testfälle.)

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

Regeln:

• Sie dürfen keine vordefinierten Funktionen oder Klassen verwenden, die dies für Sie ausführen.
• Ihr Code muss ein vollständiges Programm oder eine Funktion sein, die die Antworten zurückgibt oder druckt, sobald sie gefunden wurden
• Die Eingabe ist die Summe und das Produkt, die als Funktionsparameter oder Benutzereingabe eingegeben werden

Spezifikationen:

• Nehmen Sie an, dass die beiden Zahlen, die Summe und das Produkt immer eine ganze Zahl sind.
• Die beiden Antworten liegen zwischen -127 und 127.
• Ihre Eingabe besteht aus zwei ganzen Zahlen (Summe und Produkt).

Denken Sie daran, dass dies Codegolf ist, sodass die kürzeste Anzahl an Bytes gewinnt. Bitte benennen Sie Ihre Antwort mit dem standardmäßigen ## Sprachnamen und der Bytezahl

Edit: Doorknob wies auch darauf hin, dass dies im Wesentlichen "Faktor ein Quadrat der Form x ^ 2 + bx + c" ist. Das ist eine andere Art, über diese Herausforderung nachzudenken und sich ihr zu nähern. : D

Jelly , 15 11 10 Bytes

Hð+,_ðH²_½

Probieren Sie es online!

Der folgende Binärcode funktioniert mit dieser Version des Jelly-Interpreters.

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

Idee

Dies beruht auf der Tatsache, dass

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.

Unicorn , 4650 2982 1874 1546

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

Jetzt mit Ziegen, Regenbogen und Funkeln!

Hoffentlich kürzer als Java.

Verwendet eine benutzerdefinierte Codierung, die mit angewendet werden kannApplyEncoding

Erläuterung

Wie funktioniert das??? Mit der Magie der Einhörner (und ein bisschen Code).

Unicorn ist in JavaScript kompiliert

Jeder Abschnitt ist durch ein Leerzeichen getrennt, und jeder Abschnitt repräsentiert ein Zeichen im JavaScript-Code.

Wenn der Abschnitt Einhörner enthält, entspricht das Zeichen des Abschnitts der Länge des Abschnitts, umgerechnet in einen Zeichencode (z. B. wären 32 Einhörner ein Leerzeichen).

Wenn der Abschnitt Ziegen enthält, wird die Länge des Abschnitts verdoppelt und dann in einen Zeichencode umgewandelt.

Wenn die Sonderzeichen des Programms nicht angezeigt werden, sehen Sie hier ein Bild:

Dies ist kein Wettbewerb, da Unicorn hergestellt wurde, nachdem diese Herausforderung veröffentlicht wurde.

JavaScript ES6, 45 39 37 ^* Bytes

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

^{* Danke an Dennis!}

TeaScript, 22 Bytes 30 31

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

Nicht so schlimm. Wäre viel kürzer, wenn ich ein paar Golf-Features wie Unicode-Shortcuts für Einhörner fertig bekommen könnte

Probieren Sie es online aus

MATL , 33 Bytes

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

Gibt die beiden Zahlen in zwei verschiedenen Zeilen aus. Wenn keine Lösung vorhanden ist, wird keine Ausgabe erstellt. Wenn mehrere Lösungen existieren, wird nur das einer Lösung entsprechende Zahlenpaar erzeugt.

Beispiel

Das Folgende wurde in Octave mit dem aktuellen GitHub-Commit des Compilers ausgeführt.

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

Erläuterung

-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

Eine Funktion f, die die Summe und dann das Produkt nimmt.

Meine erste Antwort von Julia. @AlexA., Du solltest stolz auf mich sein.

Vielen Dank an @Dennis und @Alex A. für die Hilfe. Ich muss die 44 streichen.: P

dc, 16

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

Liest Summe dann Produkt aus separaten Zeilen von STDIN. -ve Zahlen müssen mit einem Unterstrich anstelle eines Minuszeichens eingegeben werden. z.B

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

Erläuterung:

Gleiche quadratische Grundlösung für sum = a + bund product = a * b. Dies berechnet die Lösung aals:

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

Und berechnet die Lösung bals:

b = sum - a

Erweitert:

?                   # 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

Das Teilen durch 2 erfolgt zu spät, um eine Verlustgenauigkeit zu vermeiden. Es ist möglich, früher durch 2 zu teilen, dies erfordert jedoch eine gebrochene Genauigkeit, die mehr Zeichen erfordert.

Pyth, 21 18 Bytes

3 Bytes gespart dank @Dennis

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

Testsuite

Mein zweites Pyth-Programm überhaupt, daher kann es wahrscheinlich mit eingebauten Funktionen gespielt werden. Vorschläge sind willkommen!

Wie es funktioniert

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

(Diese Erklärung ist möglicherweise nicht zu 100% richtig. Ich bin mit Pyth nicht sehr vertraut.)

Beachten Sie, dass dies /eine Ganzzahldivision ist. Durch Ersetzen durch ckönnte dies auch für nicht ganzzahlige Eingaben funktionieren.

Java, 82 (69 λ) Bytes mit quadratischer Formel (127 (114 λ) Bytes Brute-Force)

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

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

Weisen Sie Lambda zu java.util.function.BiFunction<Integer, Integer, int[]> und rufen Sie an apply().

Einfacher alter Brute-Force-Ansatz. Hier ist nur die Arbeitsfunktion, und da Java nicht mehrere Werte zurückgeben kann, geben wir ein 2-Element zurückint Array mit mit den erforderlichen Zahlen zurück.

Das vollständige auf Brute-Force-Ansätzen basierende Programm ist zu finden hier auf ideone.com . Die λ-Version finden Sie hier.

Zum Golfen mussten alle unnötigen Zahnspangen entfernt werden.

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

Quadratischer Ansatz: (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};}

λ-erweitert: (Java 8) (s, p) -> {int x = s + (int) Math.sqrt (s * s-4 * p); neues int [] {x / 2, sx / 2} zurückgeben ;}

(Verwendung wie für Brute Force λ oben).

Parameter und Rückgabekriterien sind dieselben wie bei der obigen Brute-Force-Lösung.

Verwendet die gute alte quadratische Formel, die von fast allen anderen Antworten hier verwendet wird, und kann nicht viel weiter abgespielt werden, es sei denn, jemand hilft mir hier. Es ist ziemlich klar, also schließe ich keine ungolfed Version ein.

Das vollständige Programm auf der Basis eines quadratischen Ansatzes finden Sie hier auf ideone.com . Die λ-Version finden Sie hier.

Japt , 28 22 21 20 Bytes

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

Die Eingabe erfolgt in Form von -63 2.

Erläuterung:

• Uund Vsind die beiden Eingänge ( -63und 2im ersten Fall)
• ² quadriert die Zahl
• q extrahiert die Quadratwurzel

APL, 27 21 Bytes

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

Dies ist ein dyadischer Funktionszug, der rechts und links ganze Zahlen akzeptiert und ein Array zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu.

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

Probieren Sie es online aus

6 Bytes gespart dank Dennis!

CJam, 18 Bytes

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

Probieren Sie es online!

Wie es funktioniert

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

Es gibt wahrscheinlich einige Möglichkeiten, dies noch weiter nach unten zu spielen, aber dies sieht so aus, wie es ist, ziemlich gut aus.

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

MathCAD 15. 38 Bytes

Mit einer mathematischen Formel ist die Programmierung in MathCAD einfach. Die Sprache ist sogar für den einfachen Umgang mit komplexen Zahlen ausgelegt. Es gibt jedoch kürzere Sprachen, die das Problem lösen können.

𝔼𝕊𝕄𝕚𝕟 21 Zeichen / 30 Bytes

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

Try it here (Firefox only).

Meh. Dies sollte visuell genug sein, damit Sie auf die Idee kommen; wenn Sie müssen î = input1, í = input2,.

PHP, 62 Bytes

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

Dies könnte ziemlich lange dauern, ist aber ein voll ausgestattetes PHP-Web- "Programm". Akzeptiert die Argumente über die "get" -Anforderung.

Demo .

TI-BASIC, 20 Bytes

Nimmt Qab Ansund Pab Prompt. Rufen Sie gerne an P:prgmNAME.

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