당신에게 또 다른 쉬운 도전.

당신의 작업

3 쌍의 x 및 y 좌표를 포함하고 그 안에 형성된 삼각형의 면적을 계산하는 입력을받는 프로그램 또는 함수를 작성하십시오. 계산 방법을 기억하지 못하는 사람들은 여기에서 찾을 수 있습니다 .

예:

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

Wolfram Alpha 에서보십시오

몇 가지 고려 사항 :

• 입력은 6 개의 기본 10 양수입니다.
• 입력이 합리적인 형식 이라고 가정 할 수 있습니다 .
• 점은 항상 유효한 삼각형을 형성합니다.
• 입력이 이미와 같은 변수에 저장되어 있다고 가정 할 수 있습니다 t.
• 바이트 단위의 가장 짧은 코드가 이깁니다!

편집 : 혼란을 피하기 위해 현재 코드를 손상시키지 않고 입력을 처리하는 방법을 단순화했습니다.

프로그램 / 기능이 유효한 영역을 출력해야하므로 출력으로 음수를 줄 수 없습니다.

CJam, 18 16 바이트

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

CJam 통역사 에서 온라인으로 사용해보십시오 .

생각

Wikipedia 에서 언급했듯이 삼각형의 면적은 [[0 0] [x y] [z w]]로 계산할 수 있습니다 |det([[x y] [z w]])| / 2 = |xw-yz| / 2.

일반 삼각형의 [[a b] [c d] [e f]]경우 첫 번째 정점을 원점으로 변환하여 삼각형을 구할 [[0 0] [c-a d-b] [e-a f-b]]수 있으며, 그 면적은 위의 공식으로 계산할 수 있습니다.

암호

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 바이트

Area@Polygon@Partition[t,2]

자바 스크립트 (ES6) 42 .44.

편집 입력 형식이 변경되었습니다. 2 바이트를 저장할 수 있습니다

배열을 매개 변수로 사용하고 계산 된 값을 반환하는 익명 함수입니다.

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

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>

줄리아, 32 바이트

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

교차 곱의 적절한 항에 대한 행렬을 구성하고 det결과 값을 얻는 데 사용 하고 음수를 처리하기 위해 절대 값을 사용한 다음 평행 사변형이 아닌 삼각형이므로 2로 나눕니다.

Matlab / Octave, 26 바이트

나는 지금까지 내장 된 것에 대해 몰랐다 =)

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

자바, 79 88 바이트

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

기본 공식 만 사용하십시오. 특별한 것은 없습니다.

편집 : 절대 값을 잊어 버렸습니다 :(

Minkolang 0.8 , 34 바이트

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

누구 계란 좀 원해 n0g?

설명

매우 간단합니다. 수식을 사용합니다 |(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 bytes

익명 함수를 선언합니다 :

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

예:

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

루비, 45

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

PHP – 68 88 89 bytes

Thanks to Martjin for some great pointers!

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

To use it, create a file area.php with this content, the extra line meets the assume the data is saved in a variable t part of the specs, and the ␍ at the end adds a carriage return so the output is nice and separated:

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

Then provide the coordinates on the command line as x₁ y₁ x₂ y₂ x₃ y₃, e.g.

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

Pyth, 34 30 bytes

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

Try it online.

Works by calculating abs(a*(d-f) + c*(f-b) + e*(b-d))/2 from input a,b,c,d,e,f.

R, 37 bytes

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

Converts the vector of coordinates into a matrix and tacks on a row of 1's.
Calculates the determinant and divides by 2.
Returns the absolute result. If the order was always clockwise the abs would not be required.

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

Python 2, 48 47 50 bytes

Very simple; follows the standard equation:

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

The other, similarly simple approaches are longer:

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

Python's access to a determinate function is through numpy.

Thanks to muddyfish for 1 byte and xnor for catching an error.

PHP, 77

Based on @Yimin Rong's answer, I felt I could improve upon it by a few bytes by using list() rather than straight $argv to abbreviate some variables. Also echo doesn't need a space if there is delimiter between echo and the thing being echoed.

echo$variable;, echo(4+2);, and echo'some string'; are equally valid whereas echofunction($variable) confuses PHP.

On the other hand, I also added abs() to be mathematically accurate, since some combinations of vertices yielded "negative area"

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

You can run it via 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 bytes

AWK has no built-in abs so using sqrt(x^2) to substitute.

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

Save as area.awk and use as echo x₁ y₁ x₂ y₂ x₃ y₃ | awk -f area.awk, e.g.

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

PowerShell, 70 Bytes

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

Uses the same standard formula as other solutions. Per the question, assumes the array is pre-populated, e.g. $t=(1,2,4,2,3,7). But ooof, does the $ and [] syntax kill this one...

dc, 52 bytes

Assumes the input is in register t as: x1 y1 x2 y2 x3 y3 with x1 at the top of t's stack.

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

This uses the following formula for area:

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

And for a quick breakdown of the process:

• 1k Lt Lt sa Lt sb Lt d sc Lt lt r: set decimal precision to 1 place, move parts of the stack in t to the main stack and move various parts of the main stack to other registers for storage (d duplicates the top of main stack, r reverses the top two elements of main stack, L/l move/copy from the given register to main, s moves top of main stack to the given register)

  Main: y3 x3 y2 x1

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

• la lc lb lt la: copy the top of the stacks in registers a, c, b, t, and a to the main stack in that order

  Main: y1 y3 x2 y2 y1 y3 x3 y2 x1

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

• - * sd: calculate ((y3-y1)*x2) and put result in d (registers a, b, c, and t are no longer used so I'll drop them from the list of stacks now)

  Main: y2 y1 y3 x3 y2 x1

  d:((y3-y1)*x2)

• - * se - *: compute ((y1-y2)*y3) and ((y2-x3)*x1); store the former in e and leave the latter on the main stack

  Main: ((y2-x3)*x1)

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

• le ld + +: copy top of register e and d to the main stack, calculate sum of top 2 stack values (pushing result back to main stack) twice

  Main: (((y3-y1)*x2)+((y1-y2)*y3)+((y2-x3)*x1))

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

• 2 /: push 2 onto main stack, divide 2nd values on stack by the 1st (d and e are no longer used, dropping them from list of stacks)

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

Rearranging the value on the stack we can see it's equivalent to the formula at the top of this explanation: (x1(y2-y3) + x2(y3-y1) + x3(y1 - y2))/2

• p: Print top of main stack to output.