Bir üçgenin üç yan uzunluğu göz önüne alındığında, en boy oranı AR'yi aşağıdaki formülü vererek değerlendirin :

nerede

Eşkenarlığa bir üçgen ne kadar yakınsa, 1en boy oranı o kadar yakındır . En boy oranı 1geçerli üçgenler için daha büyük veya eşit .

Girdiler

Giriş, bir listede kapsüllenebilecek üç gerçek pozitif sayı veya gerekirse benzer bir şeydir.

Programın, üç yan boyun girildiği sıra ne olursa olsun aynı değeri vermelidir.

Bu üç sayı her zaman geçerli bir üçgenin sidelengths olacaktır (sidelengths ile biri gibi dejenere üçgenler 1, 1ve 2giriş olarak verilmeyecek). Değerler dejenere bir üçgene son derece yaklaştığında kayan nokta yanlışlıkları konusunda endişelenmenize gerek yoktur (örneğin, programınızın division by 0giriş hatası yapması kabul edilebilir [1, 1, 1.9999999999999999]).

Girdi, STDINbir işlev argümanı veya benzer bir şey olarak verilebilir .

çıktılar

Çıktı, 1sizin dilinizde kabul edilebilir standart doğruluk oranına eşit veya daha büyük olan gerçek bir sayıdır .

Çıktı, STDOUTbir işlevden veya benzeri bir şeyden yazdırılabilir .

Test durumları

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

puanlama

Bu kod golf , yani bayt cinsinden en kısa cevap kazanır.

Jöle , 6 bayt

Bu cevap Emigna'nın 05AB1E cevabına dayanmaktadır . Dennis ve Lynn'e bu cevabı bulmadaki yardımları için çok teşekkürler. Golf önerileri hoş geldiniz! Çevrimiçi deneyin!

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

Jöle , 7 bayt

SH_÷@HP

Çevrimiçi deneyin!

açıklama

Bu zinciri okuyalım:

• Örtük argüman bir listedir [a, b, c].

• İlk önce okuduk S. Bu toplamını alır: a + b + c.

• Sonra okuduk H. İşte bu yarıya: (a + b + c)/2. (Bu s.)

• Sonra bir dyad _(çıkarma), ardından başka bir dyad okuruz . Bu bir kanca : doğru bir argümandan yoksun, bu yüzden [a, b, c]bize vererek , bu zincirin argümanını alıyor [s-a, s-b, s-c]. (Buradaki tablodaki beşinci zincir şeklidir .)

• Sonra dyad-monad çiftini okuduk ÷@H. Bu bir çatal : ÷@ters çevrilen argümanlarla bölünmüş ve Hyarıya bölünmüş durumda, bu nedenle çalışma değerimiz Hbu zincirin argümanını elde ÷ediyor. Bu vektörleşir; biz ayrıldık [(a/2)/(s-a), (b/2)/(s-b), (c/2)/(s-c)]. (Bu, buradaki tablodaki ikinci zincir şeklidir .)

• Sonunda ürünü alıp Pgötürüyoruz abc/(8(s-a)(s-b)(s-c)).

Bağlantıların nasıl bir araya geldiğinin ağaç benzeri bir grafiğini görüntüleyin.

Jöle , 6 bayt

S÷_2Pİ

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

Bu bir ( körili ) lambdadır:

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

(Bir değişkene fatadıysanız, şöyle çağırmanız gerekir f(3)(4)(5))

05AB1E , 11 7 bayt

05AB1E, CP-1252 kodlamasını kullanır .

O¹·-¹/P

Çevrimiçi deneyin!

açıklama

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

MATL , 8 7 bayt

tsGE-/p

Çevrimiçi deneyin!

açıklama

Girdiyi [3 4 5]örnek olarak kullanalım.

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 bayt

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

Stdin'den giriş okur ve R-vektörü olarak saklar x. Ardından, paydayı oluşturmak için R'nin vektörünü kullanın.

Haskell, 36 bayt

Bu, #üç argüman alan işlevi tanımlar .

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

Aşağıdaki gibi çağırmanız gerekir: (3#4)5

Biraz daha uzun ama belki daha fazla golf oynayabilir:

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

MATLAB, 64 3825 bayt

Bu, sağlanan formülü uygulayan önemli bir fonksiyondur:

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

Örneğin, girişin üç değerin bir listesi olduğunu varsayar [3,4,5]. Bu örnek aşağıdaki açıklamada kullanılmıştır:

             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 bayt

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

Girdiyi #, işlev içinde adlandırılan üç değerin bir listesi olarak alır . Tr@listesini toplamak için en kısa yoldur elde etmek için ( 2s) ve 1##&@@(...)çoğalır üç faktörü i/(2s-2i)için ide a, b, c.

Girişler tamsayılar veya rasyonel sayılarsa, kesin bir sonuç alırsınız.

Python 3 , 42 bayt

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

Çevrimiçi Deneyin!

OCaml, 51 bayt

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

Yay, şamandıralar için ayrı operatörler ...

Wonder , 48 bayt

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

HUZUR İÇİNDE YATSIN

Kullanımı:

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

açıklama

İşlev çağrıları, diğer dillerdeki giriş operatörleriyle karşılaştırıldığında Wonder'de pahalıdır. Bu nedenle, bir dizideki tüm terimleri içeriyordum ve her terimi çarpmak yerine sonucun bir sonucunu elde ettim. Kod şöyle bir şeye eşittir:

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

Aslında , 10 8 bayt

Bu cevap Dennis'in mükemmel Jelly cevabına dayanıyor . Golf önerileri hoş geldiniz! Çevrimiçi deneyin!

;Σ♀/♂¬πì

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 bayt + 85 blok = 1692 blyte

Uyarı: Golf değil . Golfed kadar sürecektir ¹ / ₃ daha az blytes.

İşte bir yorum ekran görüntüsü:

• Girişler a, bve cve çıkışıfin

• finMinecraft'taki diğer tüm değişkenler tamsayıdır, bu nedenle standart Minecraft doğruluğu 0 ondalık sayıdır.

• Yeşil sınır: Soldaki komut blokları, sadece değişken başlatma olan sağdaki bloklardan sonra etkinleşecektir.

• Kol (sağ altta gri-kahverengi dikdörtgen) kontrol tetikleyicisidir

• Minecraft'ın değişkenleri ele almasından dolayı çok fazla zaman alıyor . Çok basitleştirilmiş bir bakış:

  • /scoreboard objectives add name dummy" name" adında yeni bir değişken yaratır

  • /scoreboard players set @p name numberdeğişkeni nameolarak ayarlar number. Sayı değişken değil gerçek bir sayı olmalıdır.

  • /scoreboard players operation @p name += @p name2artışlarla namegöre name2. name2değişken değil, sayı olmalı.

    • -=, /=, *=, =Ve daha yerine kullanılabilecek +=eksiltme, çarpın, bölün, vb

• Buradaki 43 emri buraya göndermeyeceğim. Bunun golf oynamasına yardımcı olur, ama aynı zamanda beni çılgın kopyalamaya yönlendirirdi.

• 1.9 komut bloğu kullanılacaksa, çözüm (en azından) 42 blok daha az kullanacaktır. Bir harfli değişkenler kullanılacaksa, yaklaşık 200 bayt kaydedilir.

Java, 38 bayt

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

Test ve iğrenç

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

Dene!

Çıktı

1.0
1.25
6.947606226693615
1.575
1.575
1.09375

Denizanası , 17 16 bayt

1 bayt tasarruf için Zgarb teşekkürler.

p%/*-)/+i
    2%

Çevrimiçi deneyin!

açıklama

Bu Dennis'in cevabıyla aynı karşılıklı formüle dayanıyor .

Daha geleneksel işlevsel gösterimlerde, yukarıdaki program aşağıdakileri okur:

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

iGiriş listesi nerede . Not fold(multiply, ...)sadece ürünü ve hesaplar fold(add, ...)daha ayrıntılı için bu basitleştirmek böylece toplamı:

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

Her iki basamağı bir kerede yapmak için yeni bir unary işlevi tanımlayan sum(i) / ikanca ile uygulanır )/+.

Dyalog APL , 10 9 bayt

×/⊢÷+/-+⍨

Bu, anonim bir fonksiyon dizisidir (bir çatalın çatalının bir çatalının tepesinde), yani her alt fonksiyonun argümana aşağıdaki yapı içerisinde uygulandığı anlamına gelir:

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

TryAPL çevrimiçi!

×/ ürünü

⊢ argümanlar

÷ bölü

+/ Argümanların toplamı

- eksi

+⍨ tartışmalar iki katına çıktı (lit. kendilerine eklendi)

Matematiksel arka plan

ngn bir baytı traş etti.

2sable , 6 bayt

Dennis'in Jelly cevabının limanı .

Os/ÍPz

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin!

dc, 49 bayt

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

Verilen formülün doğrudan uygulanması. Üç ayrı hatta çağrı yapıldığında üç giriş yapılmasını ister ve ondalık basamağın ardından bir sonraki satıra 5 basamaklı bir kayan nokta değeri verir.

açıklama

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 bayt

Giriş, bir liste biçiminde olmalıdır {A B C}.

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

Belki bu görsel yardımcı olacaktır (bunu hatırlayın 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 (toplam (Ans) -2Ans)

Perl 6 , 44 bayt

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

Python, 55 bayt

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

Dennis’e kredi ver . Yeni taşıdım. Python'da çok ihmal edilen bir dil.

İleri, 83 bayt

Kayan nokta parametrelerinin kayan nokta yığında başladığını varsayar. Sonucu kayan nokta yığında bırakır. Params / return için yığının kullanılması, Forth için standarttır.

: 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* ;

Çevrimiçi deneyin - tüm test durumlarını içerir

Formülü kullanır a*b*c * 1/ ( -(a+b-c) * -(b+c-a) * (a+c-b) ). Neredeyse tüm program sadece kayan nokta yığınını kullanıyor. İstisnadır 3içinde 3 fpick. Bu program destekleyen bir tercüman gerektirir fpick(Ideone çalışır, repl.it yapmaz).

Açıklama: biraz daha az golf oynadı

\ 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

İsed : 19 bayt

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

Olarak ara ised --l 'inputfile.txt' '@*$1/@*{@+$1-2.*$1}' burada inputfile.txtboşlukla ayrılmış bir dizi ile bir dosya olabilir, ya da -boru / stdin'den almak için.

Unicode sürümü (aynı bytecount, ancak 3 karakter daha az):

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

Ne yazık ki, isedgirdi argümanı sözdizimi için çok fazla para harcıyor.

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

İle ara

? R (3,4,5)

veya ile mükemmel

= R (5,12,13)

C #, 82 bayt

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

Kullanımı:

ar(42, 42, 3.14);

Pyke, 12 bayt

1QFQsR/tt)B/

Burada dene!

BlueEyedBeast, şansın vardı. Burada iyi bir algoritma kullandım .

k, 19 bayt

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

Sağdan sola değerlendirir - x listesini 2'ye bölün, sonucu toplayın ve orijinal x'den çıkarın. Cevabı olumsuz ve sonucun ürünü ve 8 olsun. Sonuç payda, pay listenin ürünüdür.

Lua, 45 bayt

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

JavaScript cevabına dayanarak yoğun olarak.