Kolejne łatwe wyzwanie dla Ciebie.

Twoje zadanie

Napisz program lub funkcję, która pobiera dane wejściowe, która zawiera 3 pary współrzędnych xi y i oblicza pole utworzonego w nich trójkąta. Dla tych, którzy nie pamiętają, jak to obliczyć, możesz go znaleźć tutaj .

Przykład:

1,2,4,2,3,7       # input as x1,y1,x2,y2,x3,y3
7.5               # output

Zobacz na Wolfram Alpha

Kilka uwag:

• Dane wejściowe będą składały się z sześciu podstawowych liczb całkowitych dodatnich.
• Możesz założyć, że dane wejściowe mają dowolny rozsądny format .
• Punkty zawsze będą tworzyć prawidłowy trójkąt.
• Możesz założyć, że dane wejściowe są już zapisane w zmiennej takiej jak t .
• Najkrótszy kod w bajtach wygrywa!

Edycja: Aby uniknąć nieporozumień, uprościłem sposób, w jaki należy postępować z danymi wejściowymi bez narażania żadnego z obecnych kodów.

Pamiętaj, że twój program / funkcja musi wypisać prawidłowy obszar, więc nie może podać liczby ujemnej jako wyniku

CJam, 18 16 bajtów

T(f.-~(+.*:-z.5*

Wypróbuj online w interpretatorze CJam .

Pomysł

Jak wspomniano na Wikipedii , obszar trójkąta [[0 0] [x y] [z w]]można obliczyć jako |det([[x y] [z w]])| / 2 = |xw-yz| / 2.

W przypadku ogólnego trójkąta [[a b] [c d] [e f]]możemy przełożyć jego pierwszy wierzchołek na początek, uzyskując w ten sposób trójkąt[[0 0] [c-a d-b] [e-a f-b]] , którego pole można obliczyć za pomocą powyższej formuły.

Kod

T                  e# Push T.
                   e# [[a b] [c d] [e f]]
   (               e# Shift out the first pair.
                   e# [[c d] [e f]] [a b]
    f.-            e# For [c d] and [e f], perform vectorized
                   e# subtraction with [a b].
                   e# [[c-a d-b] [e-a f-b]]
       ~           e# Dump the array on the stack.
                   e# [c-a d-b] [e-a f-b]
        (+         e# Shift and append. Rotates the second array.
                   e# [c-a d-b] [f-b e-a]
          .*       e# Vectorized product.
                   e# [(c-a)(f-b) (d-b)(e-a)]
            :-     e# Reduce by subtraction.
                   e# (c-a)(f-b) - (d-b)(e-a)
              z    e# Apply absolute value.
                   e# |(c-a)(f-b) - (d-b)(e-a)|
               .5* e# Multiply by 0.5.
                   e# |(c-a)(f-b) - (d-b)(e-a)| / 2

Mathematica, 27 bajtów

Area@Polygon@Partition[t,2]

JavaScript (ES6) 42 .44.

Edytuj zmieniony format wejściowy, mogę zapisać 2 bajty

Anonimowa funkcja, która przyjmuje tablicę jako parametr i zwraca obliczoną wartość.

(a,b,c,d,e,f)=>(a*(d-f)+c*(f-b)+e*(b-d))/2

Przetestuj poniższy fragment kodu w przeglądarce zgodnej z EcmaScript 6.

f=(a,b,c,d,e,f)=>(a*(d-f)+c*(f-b)+e*(b-d))/2

function test()
{
  var v=I.value.match(/\d+/g)
  I.value = v
  R.innerHTML=f(...v)
}

<input id=I onchange="test()"><button onclick="test()">-></button><span id=R></span>

Julia, 32 bajty

abs(det(t[1:2].-t[[3 5;4 6]]))/2

Konstruuje macierz odpowiednich warunków iloczynu krzyżowego, używa detdo uzyskania wartości wynikowej, przyjmuje wartość bezwzględną do czynienia z negatywami, a następnie dzieli przez 2, ponieważ jest to trójkąt, a nie równoległobok.

Matlab / Octave, 26 bajtów

Do tej pory nie wiedziałem o tym wbudowanym =)

polyarea(t(1:2:5),t(2:2:6))

Java, 79 88 bajtów

float f(int[]a){return Math.abs(a[0]*(a[3]-a[5])+a[2]*(a[5]-a[1])+a[4]*(a[1]-a[3]))/2f;}

Po prostu używa podstawowej formuły, nic specjalnego.

Edycja: Zapomniałem wziąć wartość bezwzględną :(

Minkolang 0,8 , 34 bajty

ndndn0g-n1g-n0g-n0g-1R*1R*-$~2$:N.

Ktoś chce trochę jajka n0g?

Wyjaśnienie

Bardzo proste. Używa wzoru |(x2-x1)(y3-y1) - (x3-x1)(y2-y1)|/2.

nd      x1, x1
nd      x1, x1, y1, y1
n0g-    x1, y1, y1, x2-x1
n1g-    x1, y1, x2-x1, y2-y1
n0g-    y1, x2-x1, y2-y1, x3-x1
n0g-    x2-x1, y2-y1, x3-x1, y3-y1
1R*     y3-y1, x2-x1, (y2-y1)(x3-x1)
1R*     (y2-y1)(x3-x1), (y3-y1)(x2-x1)
-       (y2-y1)(x3-x1) - (y3-y1)(x2-x1)
$~      |(y2-y1)(x3-x1) - (y3-y1)(x2-x1)|
2$:     |(y2-y1)(x3-x1) - (y3-y1)(x2-x1)|/2 (float division)
N.      Output as integer and quit.

JayScript , 58 bajtów

Deklaruje anonimową funkcję:

function(a,b,c,d,e,f){return (a*(d-f)+c*(f-b)+e*(b-d))/2};

Przykład:

var nFunct = function(a,b,c,d,e,f){return (a*(d-f)+c*(f-b)+e*(b-d))/2};
print(nFunct(1,2,4,2,3,7));

Ruby, 45 lat

->a,b,p,q,x,y{((a-x)*(q-y)-(p-x)*(b-y)).abs/2}

PHP - 68 88 89 bajtów

Dzięki Martjin za wspaniałe wskazówki!

<?=.5*abs(($t[1]-$t[5])*($t[4]-$t[2])-($t[1]-$t[3])*($t[6]-$t[2]))?>

Aby go użyć, utwórz plik area.phpz tą zawartością, dodatkowy wiersz spełnia założenie, że dane są zapisywane w zmiennejt części specyfikacji, a ␍ na końcu dodaje znak powrotu karetki, dzięki czemu dane wyjściowe są ładne i oddzielone:

<?php $t = $argv; ?>
<?=.5*abs(($t[1]-$t[5])*($t[4]-$t[2])-($t[1]-$t[3])*($t[6]-$t[2]))?>
␍

Następnie podaj współrzędne w wierszu polecenia x₁ y₁ x₂ y₂ x₃ y₃, np

$ php area.php 1 2 4 2 3 7
7.5

Pyth, 34 30 bajtów

KCcQ2c.asm*@hKd-@eKhd@eKtdU3 2

Wypróbuj online.

Działa poprzez obliczenie abs (a * (df) + c * (fb) + e * (bd)) / 2 z wejścia a, b, c, d, e, f.

R, 37 bajtów

cat(abs(det(rbind(matrix(t,2),1))/2))

Konwertuje wektor współrzędnych na matrycę i pinezki w rzędzie 1.
Oblicza wyznacznik i dzieli przez 2.
Zwraca wynik bezwzględny. Jeśli zamówienie zawsze odbywa się zgodnie z ruchem wskazówek zegara abs, nie będzie wymagane.

> t = c(1,2,4,2,3,7)
> cat(det(rbind(matrix(t,2),1))/2)
7.5

Python 2, 48 47 50 bajtów

Bardzo prosty; postępuje zgodnie ze standardowym równaniem:

lambda a,b,c,d,e,f:abs(a*(d-f)+c*(f-b)+e*(b-d))/2.

Inne podobnie proste podejścia są dłuższe:

def a(a,b,c,d,e,f):return abs(a*(d-f)+c*(f-b)+e*(b-d))/2. # 57
lambda t:abs(t[0]*(t[3]-t[5])+t[2]*(t[5]-t[1])+t[4]*(t[1]-t[3]))/2. # 67
def a(t):return abs(t[0]*(t[3]-t[5])+t[2]*(t[5]-t[1])+t[4]*(t[1]-t[3]))/2. # 74

Dostęp Pythona do określonej funkcji odbywa się przez numpy .

Dzięki błotniakowi za 1 bajt i xnor za złapanie błędu.

PHP, 77

Opierając się na odpowiedzi @Yimin Rong, poczułem, że mogę poprawić ją o kilka bajtów, używając list()raczej niż prostych $argvskrótów niektórych zmiennych. Również echonie potrzebuje miejsca, jeśli istnieje separator pomiędzy Echo i rzeczą jest echem.

echo$variable;, echo(4+2);i echo'some string';są równie ważne, podczas gdy echofunction($variable)myli PHP.

Z drugiej strony dodałem również, abs()aby być matematycznie dokładnym, ponieważ niektóre kombinacje wierzchołków dawały „pole ujemne”

list($t,$a,$b,$c,$d,$e,$f)=$argv;echo.5*abs(($a-$e)*($d-$b)-($a-$c)*($f-$b));

Możesz uruchomić go za pomocą CLI

php -r "list($t,$a,$b,$c,$d,$e,$f)=$argv;echo.5*abs(($a-$e)*($d-$b)-($a-$c)*($f-$b));" 1 2 4 2 3 7
7.5

AWK - 51 42 bajtów

AWK nie ma wbudowanego, abswięc używa go sqrt(x^2)do zamiany.

{print sqrt((($1-$5)*($4-$2)-($1-$3)*($6-$2))^2)/2}

Zapisz jako area.awki użyj jako echo x₁ y₁ x₂ y₂ x₃ y₃ | awk -f area.awknp

$ echo 1 2 4 2 3 7 | awk -f area.awk
7.5

PowerShell, 70 bajtów

[math]::Abs(($t[0]-$t[4])*($t[3]-$t[1])-($t[0]-$t[2])*($t[5]-$t[1]))/2

Używa tej samej standardowej formuły co inne rozwiązania. W przypadku pytania zakłada się, że tablica jest wstępnie wypełniona, np $t=(1,2,4,2,3,7). Ale ooof , czy $i ta []składnia zabija ten ...

dc , 52 bajty

Zakłada, że ​​dane wejściowe są rejestrowane t jako: x1 y1 x2 y2 x3 y3z x1u góry tstosu.

1kLtLtsaLtsbLtdscLtltrlalclbltla-*sd-*se-*leld++2/p

1 2 4 2 3 7stStStStStSt #puts coordinates into register t (closest thing dc has to variables) 1kLtLtsaLtsbLtdscLtltrlalclbltla-*sd-*se-*leld++2/p 7.5

Używa następującej formuły dla obszaru:

(x1(y2-y3) + x2(y3-y1) + x3(y1 - y2))/2

I dla szybkiego rozbicia procesu:

• 1k Lt Lt sa Lt sb Lt d sc Lt lt r: ustaw precyzję dziesiętną na 1 miejsce, przenieś części stosu tdo głównego stosu i przenieś różne części stosu głównego do innych rejestrów w celu przechowywania ( dduplikuje górę stosu głównego, rodwraca dwa górne elementy stosu głównego,L/l przesuń / skopiuj z podanego rejestru do głównego,s przenosi górę stosu głównego do danego rejestru)

  Główny: y3 x3 y2 x1

  a y1:, b x2:, c y2:, t:y3

• la lc lb lt laCopy wierzch stosów w rejestrach a, c, b, t, a ado głównego stosu w tej kolejności

  Główny: y1 y3 x2 y2 y1 y3 x3 y2 x1

  a y1:, b x2:, c y2:, t:y3

• - * sd: Oblicz ((y3-y1)*x2)i wynik umieścić w d(rejestry a, b, c, i tnie są już wykorzystywane więc będę upuść je z listy stosy teraz)

  Główny: y2 y1 y3 x3 y2 x1

  re:((y3-y1)*x2)

• - * se - *: Oblicz ((y1-y2)*y3)i ((y2-x3)*x1); przechowywać pierwszy we i zostaw drugi na głównym stosie

  Główny: ((y2-x3)*x1)

  d:, ((y3-y1)*x2)e:((y1-y2)*y3)

• le ld + +: skopiuj górną część rejestru ei ddo głównego stosu, obliczyć sumę wartości z 2 górnych stosów (przesunięcie wyniku z powrotem do głównego stosu) dwukrotnie

  Główny: (((y3-y1)*x2)+((y1-y2)*y3)+((y2-x3)*x1))

  d:, ((y3-y1)*x2)e:((y1-y2)*y3)

• 2 /: przesuń 2 na główny stos, podziel 2. wartości na stosie przez 1. ( di enie są już używane, usuwając je z listy stosów)

  Główny: (((y3-y1)*x2)+((y1-y2)*y3)+((y2-x3)*x1))/2

Zmieniając wartość stosu, widzimy, że jest on równoważny formule na górze tego objaśnienia: (x1(y2-y3) + x2(y3-y1) + x3(y1 - y2))/2

• p: Wydrukuj górę głównego stosu, aby wydrukować.