给定三角形的三个边长，请使用以下公式评估其长宽比AR：

哪里

三角形越接近等边，则1其纵横比越接近。长宽比大于或等于1有效三角形。

输入项

输入的是三个实数正数，可以将其封装在列表中，也可以根据需要封装任何类似的数字。

无论输入三个边长的顺序如何，程序都必须输出相同的值。

这三个数字将始终是一个三角形的有效sidelengths（退化三角形像一个与sidelengths 1，1并且2将不给出作为输入）。当值变得非常接近简并三角形时，您不必担心浮点数不准确（例如，您的程序会division by 0因输入错误而接受[1, 1, 1.9999999999999999]）。

输入可以通过STDIN，作为函数参数或任何类似参数给出。

产出

输出是大于或等于1您的语言可接受的标准精度的实数。

输出可以打印到STDOUT，从函数返回或类似的东西。

测试用例

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

计分

这是代码高尔夫球，因此最短的答案以字节为单位。

果冻，6个字节

该答案基于Emigna的05AB1E答案。非常感谢Dennis和Lynn为找出答案提供的帮助。欢迎打高尔夫球！在线尝试！

S_Ḥ⁸÷P

开球

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

果冻，7个字节

SH_÷@HP

在线尝试！

说明

让我们阅读以下链：

• 隐式参数是一个列表[a, b, c]。

• 首先我们阅读S。这需要总和：a + b + c。

• 然后，我们阅读H。这减半它：(a + b + c)/2。（这是s。）

• 然后，我们读取一个二元组_（减法），然后读取另一个二元组。这是一个钩子：它缺少正确的论据，因此它接收到此链的论据[a, b, c]，给了我们[s-a, s-b, s-c]。（这是此表中的第五个链模式。）

• 然后，我们阅读dyad-monad对÷@H。这是一个fork：÷@被除法，参数倒置，并且H减半，因此我们的工作值将H在该链的参数÷之后。向量化；我们留下了[(a/2)/(s-a), (b/2)/(s-b), (c/2)/(s-c)]。（这是此表中的第二个链模式。）

• 最后，我们的产品P，让我们的abc/(8(s-a)(s-b)(s-c))。

查看链接如何组合在一起的树状图。

果冻，6个字节

S÷_2Pİ

在线尝试！

怎么运行的

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个字节

这是（咖喱）lambda：

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

（如果将其分配给变量f，则需要像那样调用它f(3)(4)(5)）

05AB1E，11 7字节

05AB1E使用CP-1252编码。

O¹·-¹/P

在线尝试！

说明

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

MATL，8 7字节

tsGE-/p

在线尝试！

说明

让我们以输入[3 4 5]为例

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字节

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

从stdin读取输入并将其存储为R-vector x。然后利用R的向量化形成分母。

Haskell，36个字节

这定义了#带有三个参数的函数。

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

您必须按以下方式调用它： (3#4)5

更长一点，但也许更适合打高尔夫球：

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

MATLAB，64 38 25字节

这是一个实现所提供公式的统一函数：

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

它假定输入是三个值的列表，例如[3,4,5]。此示例用于以下说明：

             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个字节

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

将输入作为三个值的列表，这#在函数内部称为。Tr@是总结列表中的最短路径（获得2s）并1##&@@(...)乘以三个因素i/(2s-2i)对于i在a, b, c。

如果输入是整数或有理数，则将得到精确的结果。

Python 3，42个字节

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

在线尝试！

OCaml，51个字节

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

是的，浮子的单独运算符...

不可思议，48个字节

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

RIP

用法：

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

说明

与其他语言中的中缀运算符相比，在Wonder中，函数调用的成本很高。因此，我将所有项包含在数组中，并得到结果的乘积，而不是将每个项相乘。该代码等效于：

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

实际上，10 8个字节

该答案基于Dennis出色的Jelly答案。欢迎打高尔夫球！在线尝试！

;Σ♀/♂¬πì

开球

     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字节+ 85个块= 1692个blytes

警告：不打高尔夫球。Golfed将需要最多¹ / ₃以下blytes。

这是评论的屏幕截图：

• 输入为a，b和c，输出为fin

• fin，并且Minecraft中的所有其他变量都是整数，因此Minecraft的标准精度为0个小数点

• 绿色边框：左边的命令块将在右边的命令块之后激活，这只是变量初始化。

• 操纵杆（右下方的灰褐色矩形）是触发装置

• 由于Minecraft处理变量的方式，它占用了很多时间。非常简单的概述：

  • /scoreboard objectives add name dummy创建一个名为“ name” 的新变量

  • /scoreboard players set @p name number将变量设置name为number。数字必须是实数，而不是变量。

  • /scoreboard players operation @p name += @p name2递增name的name2。name2必须是变量，而不是数字。

    • -=，/=，*=，=和更可替代地使用+=到递减，乘法，除法等

• 我不会在这里发布所有43条命令。这将有助于打高尔夫球，但也会帮助我疯狂复制粘贴

• 如果将使用1.9命令块，则解决方案将（至少）减少使用42个块。如果使用一个字母的变量，将节省近200个字节。

Java，38个字节

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

测试和取消高尔夫

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

测试一下！

输出量

1.0
1.25
6.947606226693615
1.575
1.575
1.09375

水母，17 16字节

感谢Zgarb节省了1个字节。

p%/*-)/+i
    2%

在线尝试！

说明

这是基于与丹尼斯答案相同的倒数公式。

用更传统的功能表示法，以上程序的内容如下：

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

i输入列表在哪里。请注意，fold(multiply, ...)仅计算乘积和fold(add, ...)之和，因此我们可以进一步简化为：

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

在sum(i) / i经由钩实现)/+定义一个新的一元函数同时做两个步骤。

Dyalog APL，10 9 字节

×/⊢÷+/-+⍨

这是一个匿名函数系列（在fork的fork中，在fork的顶部），意味着每个子函数都应用于以下结构中的参数：

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

在线尝试APL！

×/ 的产品

⊢ 论点

÷ 除以

+/ 参数的总和

- 减去

+⍨ 参数加倍（点亮。加到自己身上）

数学背景。

ngn剃了一个字节。

2sable，6个字节

的端口丹尼斯果冻答案。

Os/ÍPz

使用CP-1252编码。在线尝试！

dc，49个字节

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

直接给出给出的公式。在三个单独的行上调用时提示输入三个输入，并输出小数点后5位数字的浮点值到下一行。

说明

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个字节

输入应采用列表形式，例如{A B C}。

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

也许这种视觉效果会有所帮助（请记住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}）prod（sum（Ans） -2Ans）

Perl 6，44个字节

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

Python，55个字节

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

感谢丹尼斯。我刚刚移植。在Python中，这是一种被忽视的语言。

四十三字节

假定浮点参数从浮点堆栈开始。将结果保留在浮点堆栈上。将堆栈用于参数/返回是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* ;

在线尝试 -包含所有测试用例

使用公式a*b*c * 1/ ( -(a+b-c) * -(b+c-a) * (a+c-b) )。整个程序几乎只使用浮点堆栈。3in 是例外3 fpick。该程序需要一个支持的解释器fpick（Ideone有效，repl.it不起作用）。

说明： 打高尔夫球少一点

\ 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个字节

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

将该文件称为ised --l 'inputfile.txt' '@*$1/@*{@+$1-2.*$1}' 哪里inputfile.txt可以是带有空格分隔的数组的文件，也-可以从pipe / stdin接收。

Unicode版本（相同的字节数，但少3个字符）：

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

不幸的是，ised它的输入参数语法浪费了很多字符。

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

致电

r（3,4,5）

或与

= r（5,12,13）

C＃，82个字节

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

用法：

ar(42, 42, 3.14);

Pyke，12个字节

1QFQsR/tt)B/

在这里尝试！

好吧，BlueEyedBeast，您有机会。我在这里使用了一个很好的算法。

k，19个字节

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

从右到左求值-将列表x除以2，将结果相加并从原始x中减去。否定答案，得到结果与8的乘积。结果是分母，分子是列表的乘积。

Lua，45个字节

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

很大程度上基于JavaScript答案。