Evaluar la relación de aspecto de un triángulo.

35

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

ingrese la descripción de la imagen aquí

dónde

ingrese la descripción de la imagen aquí

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 , por lo que gana la respuesta más corta en bytes.

Fatalizar
fuente
Debería s sea (a + b + c) / 3 ?
costrom
3
@costrom No, la fórmula es correcta. s es el semiperímetro del triángulo . su fórmula no estaría definida para un triángulo equilátero.
Fatalize
¿Puedo obtener flotantes para la entrada o también necesito obtener enteros?
Erik the Outgolfer
@ErikGolfer エ リ ッ ク ゴ ル フ ァ ー Es aceptable ingresar en 42.0lugar de 42.
Fatalize
@Fatalize Gracias. Además, ¿pueden ser todas las entradas 0?
Erik the Outgolfer

Respuestas:

19

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).
Sherlock9
fuente
44
¿6 bytes y todavía quieres sugerencias de golf? :-D
Luis Mendo
1
@LuisMendo Si es posible, seguro: D
Sherlock9
1
"Empujar" no es una terminología correcta; La gelatina no está basada en la pila. Más bien, ⁸÷se apaga de la cadena como una unidad, y debe leerse como dividir el argumento izquierdo inicial por esto , o algo así.
Lynn
1
@ Lynn He estado jugando al golf en realidad durante varios meses. La terminología basada en la pila está firmemente encajada en mi cerebro: D Debería arreglarse ahora.
Sherlock9
56

Jalea , 7 bytes

SH_÷@HP

Pruébalo en línea!

Explicación

ingrese la descripción de la imagen aquí

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.

Lynn
fuente
8
¡Las imágenes se ven geniales! ¡Buen toque!
DavidC
2
Hice la imagen superior más pequeña y convertí la segunda en un enlace (sin juego de palabras).
Lynn
Vi la imagen e inmediatamente pensé: "¡Linda, Lynn!" antes de ver quién lo publicó ;-)
ETHproductions
77
La mejor explicación que he visto de un programa Jelly. Todavía no entiendo, pero más cerca!
Sparr
Corrí la muestra contra el caso de prueba ´6.0,12.0,14.0` y me dio `-0.8888888888888888´ en lugar de 1.575 como se muestra en los casos de prueba. ¿Es un problema con los casos de prueba o su código?
MBaas
13

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).
Dennis
fuente
Ahh, y traté de usar ³⁴⁵como argumentos ...
Erik the Outgolfer
11

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

falla
fuente
Agárreme unos segundos :) ¿Le importaría explicar cómo funciona la fórmula de manera similar a la proporcionada por la pregunta?
Kritixi Lithos
@KritixiLithos Simplemente conéctese s = 1/2(a+b+c)a la fórmula y simplifique: D (por ejemplo s-a = .5*b+.5*c-.5*a, y los tres factores de .5cancelar con 8)
error
55
(a,b,c)=>tiene la misma longitud y cuesta menos bytes llamar;)
ETHproductions
44
Pero me encanta el curry: D
flawr
9

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
Emigna
fuente
8

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
Luis Mendo
fuente
8

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.

Billywob
fuente
7

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)
falla
fuente
6

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
falla
fuente
6

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.

Martin Ender
fuente
5

OCaml, 51 bytes

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

Sí, operadores separados para flotadores ...

shooqie
fuente
5

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)])
Mama Fun Roll
fuente
1
Hmm, ¿por qué "RIP"?
Luis Mendo
Es mucho más largo de lo necesario / esperado
Mama Fun Roll
5

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.
Sherlock9
fuente
5

Minecraft 1.8, 1607 bytes + 85 bloques = 1692 blytes

Advertencia: no golf. Golfed tendrá un máximo de 1 / 3 menos blytes.

Aquí hay una captura de pantalla comentada:

ingrese la descripción de la imagen aquí

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

RudolfJelin
fuente
4

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
Olivier Grégoire
fuente
Siento que estoy (a,b,c)haciendo trampa aquí, porque no contiene información de tipo. En mi opinión, la interfaz lambda implícita (en su caso F) debe contar en la suma total de bytes.
F. George
44
@ mEQ5aNLrK3lqs3kfSa5HbvsTWe0nIu Las Lambdas son muy recomendables. Además, la mayoría de las entradas de Java 8 funcionan así sin ningún comentario. Si no está de acuerdo y considera que hice trampa, lo invito a preguntar formalmente en meta si esta notación es aceptada o no. Mientras tanto, me alineo con las respuestas anteriores de Java 8.
Olivier Grégoire
4

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.

Martin Ender
fuente
Guardar un byte con un gancho .
Zgarb
4

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.

Adán
fuente
Hola Adám, por favor. recuérdame preguntarte sobre ´⊢´ la próxima semana si lo olvido :-)
MBaas
No sé cómo el enlace "fondo" supuestamente pertenece a esta respuesta porque no veo ningún algoritmo en absoluto. Además, ¿puede agregar alguna información sobre el orden de las operaciones? Intenté reproducir esta respuesta en algunos idiomas diferentes con un orden de operaciones variable, pero siempre obtengo una respuesta diferente a la de la pregunta.
gato
@cat Bueno, no estaba destinado a dar el algoritmo, solo para explicar cuál es la relación de aspecto, ya que no existe tal página en Wikipedia. APL es de derecha a izquierda, lo que significa que cada función toma lo que está a su derecha como argumento. Por lo tanto, se puede leer de izquierda a derecha como en la explicación.
Adám
3

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
R. Kap
fuente
3

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)
Timtech
fuente
2

Perl 6 , 44 bytes

->\a,\b,\c{a*b*c/(b+c -a)/(a+c -b)/(a+b -c)}
Brad Gilbert b2gills
fuente
2

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.

Erik el Outgolfer
fuente
2

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
mbomb007
fuente
2

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.

Orión
fuente
2

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)

SeanC
fuente
Ahorraría 6 bytes con el algoritmo de @ SuperJedi224:Public Function r(a,b,c):r=a*b*c/(b+c-a)/(a-b+c)/(a+b-c):End Function
steenbergh
2

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);
WeskerTyrant
fuente
2

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.

Paul Kerrigan
fuente
1

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.

Yo si
fuente