Berechnen Sie bei drei Seitenlängen eines Dreiecks dessen Seitenverhältnis AR mit der folgenden Formel:

woher

Je näher ein Dreieck an der Gleichgewichtsverteilung ist, desto näher ist es an 1seinem Seitenverhältnis. Das Seitenverhältnis ist größer oder gleich 1für gültige Dreiecke.

Eingänge

Die Eingabe besteht aus drei reellen positiven Zahlen, die bei Bedarf in eine Liste oder Ähnliches eingeschlossen werden können.

Ihr Programm muss unabhängig von der Reihenfolge, in der die drei Seitenlängen eingegeben werden, denselben Wert ausgeben.

Diese drei Zahlen wird immer gültig sidelengths eines Dreiecks (entarteten Dreiecke wie ein mit sidelengths 1, 1und 2wird nicht als Eingabe gegeben werden). Sie brauchen sich keine Gedanken über Gleitkommaungenauigkeiten zu machen, wenn die Werte einem entarteten Dreieck extrem nahe kommen (z. B. ist es akzeptabel, dass Ihr Programm division by 0bei der Eingabe Fehler macht [1, 1, 1.9999999999999999]).

Die Eingabe kann durch STDINein Funktionsargument oder etwas Ähnliches erfolgen.

Ausgänge

Die Ausgabe ist eine reelle Zahl, die größer oder gleich 1der in Ihrer Sprache akzeptablen Standardgenauigkeit ist.

Die Ausgabe kann auf STDOUTeine Funktion oder auf eine ähnliche Weise gedruckt oder von dieser zurückgegeben werden.

Testfälle

Inputs                   Output

  1      1      1         1
  3      4      5         1.25
 42     42   3.14         ≈ 6.9476
 14      6     12         1.575
  6     12     14         1.575
0.5    0.6    0.7         ≈ 1.09375

Wertung

Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.

Gelee , 6 Bytes

Diese Antwort basiert auf der 05AB1E-Antwort von Emigna . Vielen Dank an Dennis und Lynn für ihre Hilfe, um diese Antwort herauszufinden. Golfvorschläge willkommen! Probieren Sie es online!

S_Ḥ⁸÷P

Ungolfing

           Implicit argument [a, b, c].
S          Take the sum, a+b+c or 2*s
  Ḥ        Take the double, [2*a, 2*b, 2*c].
 _         Vectorized subtract, giving us [2*(s-a), 2*(s-b), 2*(s-c)].
   ⁸÷      Vectorized divide the initial left argument, the input [a, b, c],
             by [2*(s-a), 2*(s-b), 2*(s-c)].
     P     Take the product giving us the aspect ratio, abc/8(s-a)(s-b)(s-c).

Gelee , 7 Bytes

SH_÷@HP

Probieren Sie es online!

Erläuterung

Lasst uns diese Kette lesen:

• Das implizite Argument ist eine Liste [a, b, c].

• Zuerst lesen wir S. Dies nimmt die Summe: a + b + c.

• Dann lesen wir H. Dies halbiert es: (a + b + c)/2. (Dies ist s.)

• Dann lesen wir eine Dyade _(subtrahieren), gefolgt von einer anderen Dyade. Dies ist ein Haken : Es fehlt ein richtiges Argument, so dass es das Argument für diese Kette erhält [a, b, c]und uns gibt [s-a, s-b, s-c]. (Dies ist das fünfte Kettenmuster in der Tabelle hier .)

• Dann lesen wir das Dyad-Monad-Paar ÷@H. Dies ist eine Gabelung : Wird die ÷@Division mit den Argumenten gespiegelt und Hhalbiert, so erhält unser Arbeitswert Hdas Argument für diese Kette ÷dadurch. Dies vektorisiert; wir bleiben mit [(a/2)/(s-a), (b/2)/(s-b), (c/2)/(s-c)]. (Dies ist das zweite Kettenmuster in der Tabelle hier .)

• Schließlich nehmen wir das Produkt mit Pund holen es uns abc/(8(s-a)(s-b)(s-c)).

Zeigen Sie ein baumartiges Diagramm an, in dem dargestellt ist, wie die Verknüpfungen zusammenpassen.

Gelee , 6 Bytes

S÷_2Pİ

Probieren Sie es online!

Wie es funktioniert

S÷_2Pİ  Main link. Argument: [a, b, c]

S       Sum; compute 2s := a + b + c.
 ÷      Divide; yield [2s ÷ a, 2s ÷ b, 2s ÷ c].
  _2    Subtract 2; yield [2s ÷ a - 2, 2s ÷ b - 2, 2s ÷ c - 2].
    P   Product; yield (2s ÷ a - 2)(2s ÷ b - 2)(2s ÷ c - 2).
     İ  Invert; yield 1 ÷ (2s ÷ a - 2)(2s ÷ b - 2)(2s ÷ c - 2).

JavaScript, 38 Bytes

Dies ist ein ( Curry- ) Lambda:

a=>b=>c=>a*b*c/(b+c-a)/(a+c-b)/(a+b-c)

(Wenn Sie es einer Variablen zuweisen, müssen Sie fes wie folgt aufrufen f(3)(4)(5))

05AB1E , 11 7 Bytes

05AB1E verwendet die CP-1252- Codierung.

O¹·-¹/P

Probieren Sie es online!

Erläuterung

O         # sum input
 ¹        # push input again
  ·       # multiply by 2
   -      # subtract from sum
    ¹/    # divide by input
      P   # product

MATL , 8 7 Bytes

tsGE-/p

Probieren Sie es online!

Erläuterung

Verwenden wir [3 4 5]als Beispiel die Eingabe

t    % Take input implicitly. Duplicate
     % STACK: [3 4 5], [3 4 5]
s    % Sum of array
     % STACK: [3 4 5], 12
G    % Push input again
     % STACK: [3 4 5], 12, [3 4 5]
E    % Multiply by 2, element-wise
     % STACK: [3 4 5], 12, [6 8 10]
-    % Subtract, element-wise
     % STACK: [3 4 5], [6 4 2]
/    % Divide, element-wise
     % STACK: [0.5 1 2.5]
p    % Product of array. Implicitly display
     % STACK: 1.25

R 34 29 Bytes

x=scan();prod(x/(sum(x)-2*x))

Liest die Eingabe von stdin und speichert sie als R-Vektor x. Verwenden Sie dann die Vektorisierung von R, um den Nenner zu bilden.

Haskell, 36 Bytes

Dies definiert die Funktion, #die drei Argumente akzeptiert.

(a#b)c=a*b*c/(b+c-a)/(a+c-b)/(a+b-c)

Sie müssen es wie folgt aufrufen: (3#4)5

Ein bisschen länger, aber vielleicht besser zum Golfen:

p=product
f v=p v/p((sum v-).(2*)<$>v)

MATLAB, 64 38 25 Bytes

Dies ist eine beliebige Funktion, die die folgende Formel implementiert:

@(v)prod(v./(sum(v)-2*v))

Es wird angenommen, dass die Eingabe eine Liste von drei Werten ist, z [3,4,5]. Dieses Beispiel wird in der folgenden Erläuterung verwendet:

             sum(v)        = 3+4+5 = 12
             sum(v)-2*v    = 12 - 2*[3,4,5] = 12 - [6,8,10] = [6,4,2]
         v./(sum(v)-2*v))  = [3,4,5] ./ [6,4,2] = [0.5,1,2.5]
    prod(v./(sum(v)-2*v))  = 0.5 * 1 * 2.5 = 1.25

Mathematica, 20 Bytes

1##&@@(#/(Tr@#-2#))&

Nimmt die Eingabe als eine Liste von drei Werten auf, die als #innerhalb der Funktion bezeichnet wird. Tr@ist der kürzeste Weg, um eine Liste zu summieren (zu erhalten 2s) und 1##&@@(...)die drei Faktoren i/(2s-2i)für iin zu multiplizieren a, b, c.

Wenn die Eingaben Ganzzahlen oder rationale Zahlen sind, erhalten Sie ein genaues Ergebnis.

Python 3 , 42 Bytes

lambda a,b,c:a*b*c/(b+c-a)/(a+c-b)/(a+b-c)

Probieren Sie es online!

OCaml, 51 Bytes

fun a b c->a*.b*.c/.(b+.c-.a)/.(a+.c-.b)/.(a+.b-.c)

Yay, separate Operatoren für Schwimmer ...

Wunder , 48 Bytes

@@@prod[#0#1#2/1- +#1#0#2/1- +#2#0#1/1- +#2#1#0]

RUHE IN FRIEDEN

Verwendung:

(((@@@prod[#0#1#2/1* * - +#1#0#2- +#2#0#1- +#2#1#0])3)4)5

Erläuterung

Funktionsaufrufe sind in Wonder im Vergleich zu Infix-Operatoren in anderen Sprachen teuer. Aus diesem Grund habe ich alle Begriffe in einem Array enthalten und das Ergebnis erhalten, anstatt jeden einzelnen Begriff zu multiplizieren. Der Code würde ungefähr so ​​aussehen:

(a,b,c)=>product([a,b,c,1/(b+c-a),1/(a+c-b),1/(a+b-c)])

Eigentlich , 10 8 Bytes

Diese Antwort basiert auf Dennis 'hervorragender Gelee-Antwort . Golfvorschläge willkommen! Probieren Sie es online!

;Σ♀/♂¬πì

Ungolfing

     Implicit input [a, b, c].
;    Duplicate [a, b, c].
Σ    sum() to get twice the semiperimeter, 2*s.
♀/   Vectorized divide 2*s by [a, b, c] to get [2*s/a, 2*s/b, 2*s/c].
♂¬   Vectorized subtract 2 to get [2*s/a-2, 2*s/b-2, 2*s/c-2].
π    Get the product of the above to get 8*(s/a-1)*(s/b-1)*(s/c-1).
     This is the same as 8(s-a)(s-b)(s-c)/abc.
ì    Invert to get the aspect ratio, abc/8(s-a)(s-b)(s-c).
     Implicit return.

Minecraft 1.8, 1607 Bytes + 85 Blöcke = 1692 Blytes

Warnung: Nicht golfen. Golfed nimmt bis zu ¹ / ₃ weniger blytes.

Hier ist ein kommentierter Screenshot:

• Die Eingänge sind a, bund cund der Ausgang istfin

• finund alle anderen Variablen in Minecraft sind ganze Zahlen, daher beträgt die Standardgenauigkeit von Minecraft 0 Dezimalstellen

• Der grüne Rand: Die Befehlsblöcke auf der linken Seite werden nach den Befehlsblöcken auf der rechten Seite aktiviert, bei denen es sich nur um variable Initialisierungen handelt.

• Der Hebel (grau-braunes Rechteck unten rechts) ist der Apparateauslöser

• Es nimmt so viel Zeit in Anspruch, weil Minecraft mit Variablen umgeht . Eine sehr vereinfachte Übersicht:

  • /scoreboard objectives add name dummyerstellt eine neue Variable mit dem Namen " name"

  • /scoreboard players set @p name numbersetzt die Variable nameauf number. Zahl muss eine reelle Zahl sein, keine Variable.

  • /scoreboard players operation @p name += @p name2Inkremente namevon name2. name2muss eine Variable sein, keine Zahl.

    • -=, /=, *=, =Und kann stattdessen verwendet werden , +=zu dekrementieren, Multiplizieren, Dividieren, usw.

• Ich werde hier nicht alle 43 Befehle posten. Es würde mir helfen, Golf zu spielen, aber es würde mir auch helfen, verrücktes Copypasting zu betreiben

• Wenn 1.9-Befehlsblöcke verwendet würden, würde die Lösung (mindestens) 42 Blöcke weniger verwenden. Wenn Ein-Buchstaben-Variablen verwendet würden, würden fast 200 Bytes gespeichert.

Java, 38 Bytes

(a,b,c)->a*b*c/(b+c-a)/(a-b+c)/(a+b-c)

Testen und ungolfed

public class Pcg101234 {
  interface F {
    double f(double a, double b, double c);
  }
  public static void main(String[] args) {
    F f = (a,b,c)->a*b*c/(b+c-a)/(a-b+c)/(a+b-c);

    System.out.println(f.f(1,1,1));
    System.out.println(f.f(3,4,5));
    System.out.println(f.f(42,42,3.14));
    System.out.println(f.f(14,6,12));
    System.out.println(f.f(6,12,14));
    System.out.println(f.f(0.5,0.6,0.7));
  }
}

Probier es aus!

Ausgabe

1.0
1.25
6.947606226693615
1.575
1.575
1.09375

Qualle , 17 16 Bytes

Vielen Dank an Zgarb für das Speichern von 1 Byte.

p%/*-)/+i
    2%

Probieren Sie es online!

Erläuterung

Dies basiert auf der gleichen reziproken Formel wie Dennis 'Antwort .

In traditionellerer funktionaler Notation lautet das obige Programm wie folgt:

print(
  1 / fold(
    multiply,
    fold(add, i) / i - 2
  )
)

Wo iist die Eingabeliste? Beachten Sie, dass fold(multiply, ...)nur das Produkt und fold(add, ...)die Summe berechnet werden , sodass wir dies weiter vereinfachen können, um:

print(1 / product(sum(i) / i - 2))

Die sum(i) / iImplementierung erfolgt über den Hook, )/+der eine neue unäre Funktion definiert, mit der beide Schritte gleichzeitig ausgeführt werden können.

Dyalog APL , 10 9 Bytes

×/⊢÷+/-+⍨

Dies ist ein anonymer Funktionszug (eine Spitze einer Gabel einer Gabel einer Gabel), was bedeutet, dass jede Unterfunktion auf das Argument innerhalb der folgenden Struktur angewendet wird:

 ┌─┴─┐          
×/ ┌─┼───┐      
   ⊢ ÷ ┌─┼──┐  
      +/ - +⍨

TryAPL online!

×/ das Produkt von

⊢ die Argumente

÷ geteilt durch

+/ die Summe der Argumente

- Minus

+⍨ die Argumente verdoppelten sich

Mathematischer Hintergrund.

ngn hat ein Byte rasiert.

2sable , 6 Bytes

Ein Port von Dennis 'Jelly Antwort .

Os/ÍPz

Verwendet die CP-1252- Codierung. Probieren Sie es online!

Gleichstrom, 49 Bytes

5k?dsa?dsb?dsc++2/sslalblc**lsla-lslb-lslc-8***/p

Eine direkte Umsetzung der angegebenen Formel. Fordert beim Aufruf in drei separaten Zeilen zur Eingabe der drei Eingaben auf und gibt einen Gleitkommawert mit 5 Nachkommastellen zur nächsten Zeile aus.

Erläuterung

5k                                                # Set the output precision to 5 digits after the decimal
  ?dsa                                            # Prompt for first input value on first line, duplicate it, and then store it in register `a`
      ?dsb                                        # Prompt for second input, duplicate it, and store it in register `b`
          ?dsc                                    # Prompt for third input, duplicate it, and store it in register `c`
              ++2/ss                              # Sum up the 3 values on the main stack, then divide sum by 2 and store the result in register `s`
                    lalblc**                      # Copy all three values from registers `a`,`b`,`c` onto the main stack, find their product, and push result to top of main stack
                            lsla-                 # Copy value from register `s` onto main stack, subtract register `a`'s value from it, and push result to main stack
                                 lslb-            # Copy value from register `s` onto main stack, subtract register `b`'s value from it, and push result to main stack
                                      lslc-       # Copy value from register `s` onto main stack, subtract register `c`'s value from it, and push result to main stack
                                           8***   # Find the product of the top three values and 8 and then push the result to main stack
                                               /p # Divide the second to top value (a*b*c) by the top of stack value (8*(s-a)*(s-b)*(s-c)), push the result to the main stack, and then output the result to STDOUT

TI-Basic, 11 Bytes

Die Eingabe sollte in Form einer Liste erfolgen {A B C}.

prod(Ans)/prod(sum(Ans)-2Ans

Vielleicht hilft dieses Bild (denken Sie daran 2s = a+b+c ):

      abc abc abc prod (Ans)
---------------- = --------------------- = ----------- -------- = -------------------
8 (sa) (sb) (sc) (2s-2a) (2s-2b) (2s-2c) (a + b + c) (1-2 {a, b, c}) Produkt (Summe (Ans) -2Ans)

Perl 6 , 44 Bytes

->\a,\b,\c{a*b*c/(b+c -a)/(a+c -b)/(a+b -c)}

Python, 55 Bytes

def f(x,y,z):s=x+y+z;return 1/((s/x-2)*(s/y-2)*(s/z-2))

Dank an Dennis . Ich habe gerade portiert. In Python eine viel vernachlässigte Sprache.

Viertens 83 Bytes

Angenommen, die Gleitkommaparameter beginnen auf dem Gleitkommastapel. Lässt das Ergebnis auf dem Gleitkommastapel. Die Verwendung des Stacks für params / return ist der Standard für Forth.

: p 3 fpick ;
: T p p p ;
: f 0 s>f T f- f+ f- T f+ f- f* T f- f- f* 1/f f* f* f* ;

Online testen - enthält alle Testfälle

Verwendet die Formel a*b*c * 1/ ( -(a+b-c) * -(b+c-a) * (a+c-b) ). Fast das gesamte Programm verwendet nur den Gleitkommastapel. Die Ausnahme ist die 3in 3 fpick. Dieses Programm benötigt einen unterstützten Interpreter fpick(Ideone funktioniert, repl.it nicht).

Erklärung: etwas weniger golfen

\ 3 fpick takes the 3rd element (0-indexed) and pushes a copy
\ Used to copy parameters on the stack over another number 'x' ( a b c x -> a b c x a b c )
: f3p 3 fpick 3 fpick 3 fpick ;

: f                     \ define a function f
0 s>f f3p f- f+ f-      \ push a zero, copy params, compute 0-(a+b-c)
                        \ the zero allows me to copy (I need an 'x' to jump over)
f3p f+ f- f*            \ copy params and compute -(b+c-a), multiply by previous result
                        \ the negatives miraculously cancel
f3p f- f- f*            \ copy and compute (a+c-b), multiply by previous result
1/f f* f* f* ;          \ take the reciprocal and multiply by a*b*c
                        \ the result is left on the floating point stack

ised : 19 Bytes

@*$1/@*{@+$1-2.*$1}

Nennen wir es als ised --l 'inputfile.txt' '@*$1/@*{@+$1-2.*$1}' wo inputfile.txteine Datei mit Zwischenraum getrennt Array sein kann, oder -aus Rohr / stdin zu empfangen.

Unicode-Version (gleiche Bytecount aber 3 Zeichen weniger):

Π$1/Π{Σ$1-2.*$1}

isedVerschwendet leider eine Menge Zeichen für die Syntax der Eingabeargumente.

VBA, 76

Function r(a,b,c)
s=(a+b+c)/2:r=(a*b*c)/(8*(s-a)*(s-b)*(s-c))
End Function

Mit anrufen

r (3,4,5)

oder in excel mit

= r (5,12,13)

82 Bytes

void ar(double a,double b,double c)=>Console.Write(a*b*c/(b+c-a)/(a+c-b)/(a+b-c));

Verwendung:

ar(42, 42, 3.14);

Pyke, 12 Bytes

1QFQsR/tt)B/

Probieren Sie es hier aus!

Nun, BlueEyedBeast, du hattest deine Chance. Ich habe hier einen guten Algorithmus verwendet .

k, 19 Bytes

{(*/x)%8*/-x-+/x%2}

Wertet von rechts nach links aus - Teilen Sie die Liste x durch 2, addieren Sie das Ergebnis und subtrahieren Sie es vom ursprünglichen x. Negieren Sie die Antwort und erhalten Sie das Produkt des Ergebnisses und 8. Das Ergebnis ist der Nenner, der Zähler ist das Produkt der Liste.

Lua, 45 Bytes

a,b,c=...print(a*b*c/(b+c-a)/(a+c-b)/(a+b-c))

Stark basierend auf der JavaScript-Antwort.