Dadas tres longitudes laterales de un triángulo, evalúa su relación de aspecto AR dada la siguiente fórmula:

dónde

Cuanto más cercano a la equilateralidad es un triángulo, más cerca está 1su relación de aspecto. La relación de aspecto es mayor o igual que 1para triángulos válidos.

Entradas

La entrada es tres números positivos reales que se pueden encapsular en una lista o algo similar si es necesario.

Su programa debe generar el mismo valor sin importar el orden en que se ingresen las tres longitudes laterales.

Esos tres números siempre serán longitudes laterales válidas de un triángulo (triángulos degenerados como uno con longitudes laterales 1, 1y 2no se darán como entrada). No debe preocuparse por las imprecisiones de coma flotante cuando los valores se vuelven extremadamente cercanos a un triángulo degenerado (por ejemplo, es aceptable que su programa produzca un error division by 0de entrada [1, 1, 1.9999999999999999]).

La entrada se puede dar a través STDIN, como un argumento de función, o algo similar.

Salidas

La salida es un número real mayor o igual 1con la precisión estándar que es aceptable en su idioma.

La salida puede imprimirse STDOUT, devolverse desde una función o algo similar.

Casos de prueba

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

Tanteo

Este es el código de golf , por lo que gana la respuesta más corta en bytes.

Jalea , 6 bytes

Esta respuesta se basa en la respuesta 05AB1E de Emigna . Muchas gracias a Dennis y Lynn por su ayuda para resolver esta respuesta. Sugerencias de golf bienvenidas! Pruébalo en línea!

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

Jalea , 7 bytes

SH_÷@HP

Pruébalo en línea!

Explicación

Leamos esta cadena:

• El argumento implícito es una lista [a, b, c].

• Primero leemos S. Esto toma la suma: a + b + c.

• Entonces, leemos H. Esto reduce a la mitad que: (a + b + c)/2. (Esto es s)

• Luego, leemos una díada _(resta), seguida de otra díada. Este es un gancho : carece de un argumento correcto, por lo que recibe el argumento de esta cadena, [a, b, c]dándonos [s-a, s-b, s-c]. (Este es el quinto patrón de cadena en la tabla aquí ).

• Luego, leemos el par de díadas y mónadas ÷@H. Esto es una bifurcación : ÷@es una división con los argumentos invertidos, y Hse divide por la mitad, por lo que nuestro valor de trabajo obtiene Hel argumento de esta cadena ÷. Esto vectoriza; nos quedamos con [(a/2)/(s-a), (b/2)/(s-b), (c/2)/(s-c)]. (Este es el segundo patrón de cadena en la tabla aquí ).

• Finalmente, tomamos el producto Py nos llevamos abc/(8(s-a)(s-b)(s-c)).

Vea un gráfico en forma de árbol de cómo se unen los enlaces.

Jalea , 6 bytes

S÷_2Pİ

Pruébalo en línea!

Cómo funciona

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

Esta es una lambda (al curry ):

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

(Si lo asigna a una variable f, deberá llamarlo así f(3)(4)(5))

05AB1E , 11 7 bytes

05AB1E utiliza codificación CP-1252 .

O¹·-¹/P

Pruébalo en línea!

Explicación

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

MATL , 8 7 bytes

tsGE-/p

Pruébalo en línea!

Explicación

Usemos la entrada [3 4 5]como ejemplo

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

Lee la entrada de la entrada estándar y tienda como el R-vector x. Luego, utilice la vectorización de R para formar el denominador.

Haskell, 36 bytes

Esto define la función #que toma tres argumentos.

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

Tienes que llamarlo de la siguiente manera: (3#4)5

Un poco más largo pero quizás más golfable:

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

MATLAB, 64 38 25 bytes

Esta es una función anónima que implementa la fórmula como se proporciona:

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

Se supone que la entrada es una lista de tres valores, por ejemplo [3,4,5]. Este ejemplo se usa en la siguiente explicación:

             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#))&

Toma la entrada como una lista de tres valores, que se conoce como #dentro de la función. Tr@es la forma más corta de sumar una lista (para obtener 2s) y 1##&@@(...)multiplica los tres factores i/(2s-2i)para iin a, b, c.

Si las entradas son números enteros o racionales, obtendrá un resultado exacto.

Python 3 , 42 bytes

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

¡Pruébelo en línea!

OCaml, 51 bytes

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

Sí, operadores separados para flotadores ...

Preguntarse , 48 bytes

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

Q.E.P.D

Uso:

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

Explicación

Las llamadas a funciones son costosas en Wonder en comparación con los operadores infijos en otros idiomas. Debido a esto, contuve todos los términos en una matriz y obtuve el producto del resultado en lugar de multiplicar cada término. El código sería equivalente a algo como:

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

En realidad , 10 8 bytes

Esta respuesta se basa en la excelente respuesta Jelly de Dennis . Sugerencias de golf bienvenidas! Pruébalo en línea!

;Σ♀/♂¬πì

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 bloques = 1692 blytes

Advertencia: no golf. Golfed tendrá un máximo de ¹ / ₃ menos blytes.

Aquí hay una captura de pantalla comentada:

• Las entradas son a, by c, y la salida esfin

• fin, y todas las demás variables en Minecraft son enteros, por lo que la precisión estándar de Minecraft es 0 puntos decimales

• El borde verde: los bloques de comandos de la izquierda se activarán después de los de la derecha, que son solo inicializaciones variables.

• La palanca (rectángulo gris-marrón en la parte inferior derecha) es el disparador del artilugio

• Ocupa mucho debido a la forma en que Minecraft maneja las variables . Una visión general muy simplificada:

  • /scoreboard objectives add name dummycrea una nueva variable llamada " name"

  • /scoreboard players set @p name numberestablece la variable namea number. El número debe ser un número real, no una variable.

  • /scoreboard players operation @p name += @p name2incrementos namepor name2. name2debe ser una variable, no un número.

    • -=, /=, *=, =Y más puede utilizarse en lugar +=de decremento, multiplicar, dividir, etc.

• No voy a publicar todos los 43 comandos aquí. Esto ayudaría a jugar golf, pero también me volvería loco.

• Si se usarían 1.9 bloques de comando, la solución (al menos) usaría 42 bloques menos. Si se usaran variables de una letra, se guardarían casi 200 bytes.

Java, 38 bytes

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

Prueba y sin golf

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

¡Pruébalo!

Salida

1.0
1.25
6.947606226693615
1.575
1.575
1.09375

Medusa , 17 16 bytes

Gracias a Zgarb por guardar 1 byte.

p%/*-)/+i
    2%

Pruébalo en línea!

Explicación

Esto se basa en la misma fórmula recíproca que la respuesta de Dennis .

En la notación funcional más tradicional, el programa anterior dice lo siguiente:

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

¿Dónde iestá la lista de entrada? Tenga en cuenta que fold(multiply, ...)solo calcula el producto y fold(add, ...)la suma, por lo que podemos simplificar aún más esto para:

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

El sum(i) / ise implementa a través del gancho )/+que define una nueva función unaria para realizar ambos pasos a la vez.

Dyalog APL , 10 9 bytes

×/⊢÷+/-+⍨

Este es un tren de funciones anónimo (encima de una bifurcación de una bifurcación de una bifurcación), lo que significa que cada subfunción se aplica al argumento, dentro de la siguiente estructura:

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

TryAPL en línea!

×/ el producto de

⊢ los argumentos

÷ dividido por

+/ la suma de los argumentos

- menos

+⍨ los argumentos se duplicaron (literalmente se agregaron a sí mismos)

Fondo matemático

ngn se afeitó un byte.

2sable , 6 bytes

Un puerto de Dennis 'Jelly responde .

Os/ÍPz

Utiliza la codificación CP-1252 . Pruébalo en línea!

cc, 49 bytes

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

Una implementación directa de la fórmula dada. Solicita las tres entradas al invocar en tres líneas separadas y genera un valor de punto flotante con 5 dígitos después del punto decimal a la siguiente línea.

Explicación

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

La entrada debe tener la forma de una lista, como {A B C}.

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

Quizás esta ayuda visual (recuerde eso 2s = a+b+c):

      abc abc abc prod (Respuesta)
---------------- = --------------------- = ----------- -------- = -------------------
8 (sa) (sb) (sc) (2s-2a) (2s-2b) (2s-2c) (a + b + c) (1-2 {a, b, c}) prod (suma (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))

Crédito a Dennis . Acabo de portar. En Python, un lenguaje muy descuidado.

Adelante, 83 bytes

Asume que los parámetros de coma flotante comienzan en la pila de coma flotante. Deja el resultado en la pila de coma flotante. Usar el stack para params / return es el estándar para 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* ;

Pruébelo en línea : contiene todos los casos de prueba

Utiliza la fórmula a*b*c * 1/ ( -(a+b-c) * -(b+c-a) * (a+c-b) ). Casi todo el programa usa solo la pila de coma flotante. La excepción es 3en3 fpick . Este programa requiere un intérprete que admita fpick(Ideone funciona, repl.it no).

Explicación: un poco menos golfizado

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

Llámalo como ised --l 'inputfile.txt' '@*$1/@*{@+$1-2.*$1}' dondeinputfile.txt puede haber un archivo con una matriz separada por espacios, o- para recibir de pipe / stdin.

Versión Unicode (mismo bytecount pero 3 caracteres menos):

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

Desafortunadamente, iseddesperdicia muchos caracteres por su sintaxis de argumento de entrada.

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

Llamar con

? r (3,4,5)

o en sobresalir con

= r (5,12,13)

C #, 82 bytes

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

Uso:

ar(42, 42, 3.14);

Pyke, 12 bytes

1QFQsR/tt)B/

Pruébalo aquí!

Bueno, BlueEyedBeast, tuviste tu oportunidad. Usé un buen algoritmo aquí.

k, 19 bytes

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

Evalúa de derecha a izquierda: divida la lista x por 2, sume el resultado y reste de la x original. Negar la respuesta y obtener el producto del resultado y 8. El resultado es el denominador, el numerador es el producto de la lista.

Lua, 45 bytes

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

Muy basado en la respuesta de JavaScript.