Un autre défi facile pour vous.

Ta tâche

Écrivez un programme ou une fonction qui prend l'entrée, qui contient 3 paires de coordonnées x et y et calcule l'aire du triangle formé à l'intérieur. Pour ceux qui ne se souviennent pas comment le calculer, vous pouvez le trouver ici .

Exemple:

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

À voir chez Wolfram Alpha

Quelques considérations:

• L'entrée sera six entiers positifs de base 10.
• Vous pouvez supposer que l'entrée est dans un format raisonnable .
• Les points formeront toujours un triangle valide.
• Vous pouvez supposer que l'entrée est déjà stockée dans une variable telle que t.
• Le code le plus court en octets gagne!

Edit: Pour éviter toute confusion, j'ai simplifié la façon dont l'entrée doit être traitée sans compromettre aucun des codes actuels.

N'oubliez pas que votre programme / fonction doit sortir une zone valide, donc il ne peut pas donner un nombre négatif en sortie

CJam, 18 16 octets

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

Essayez-le en ligne dans l' interpréteur CJam .

Idée

Comme mentionné sur Wikipedia , l'aire du triangle [[0 0] [x y] [z w]]peut être calculée comme |det([[x y] [z w]])| / 2 = |xw-yz| / 2.

Pour un triangle générique [[a b] [c d] [e f]], nous pouvons traduire son premier sommet à l'origine, obtenant ainsi le triangle [[0 0] [c-a d-b] [e-a f-b]], dont l'aire peut être calculée par la formule ci-dessus.

Code

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 octets

Area@Polygon@Partition[t,2]

JavaScript (ES6) 42 .44.

Modifier le format d'entrée modifié, je peux enregistrer 2 octets

Une fonction anonyme qui prend le tableau comme paramètre et renvoie la valeur calculée.

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

Testez l'exécution de l'extrait ci-dessous dans un navigateur compatible 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 octets

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

Construit une matrice des termes appropriés d'un produit croisé, utilise detpour obtenir la valeur résultante, prend la valeur absolue pour traiter les négatifs, puis divise par 2 car c'est un triangle et non un parallélogramme.

Matlab / Octave, 26 octets

Je n'en savais rien jusqu'ici =)

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

Java, 79 88 octets

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

Utilise simplement la formule de base, rien de spécial.

Edit: J'ai oublié de prendre la valeur absolue :(

Minkolang 0,8 , 34 octets

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

Quelqu'un veut de l'oeuf n0g?

Explication

Très simple. Utilise la formule |(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 octets

Déclare une fonction anonyme:

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

Exemple:

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

Rubis, 45

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

PHP - 68 88 89 octets

Merci à Martjin pour quelques bons conseils!

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

Pour l'utiliser, créez un fichier area.phpavec ce contenu, la ligne supplémentaire répond à l' hypothèse que les données sont enregistrées dans unet partie variable des spécifications, et le ␍ à la fin ajoute un retour chariot afin que la sortie soit agréable et séparée:

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

Fournissez ensuite les coordonnées sur la ligne de commande x₁ y₁ x₂ y₂ x₃ y₃, par exemple

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

Pyth, 34 30 octets

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

Essayez-le en ligne.

Fonctionne en calculant abs (a * (df) + c * (fb) + e * (bd)) / 2 à partir de l'entrée a, b, c, d, e, f.

R, 37 octets

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

Convertit le vecteur de coordonnées en une matrice et colle sur une rangée de 1.
Calcule le déterminant et divise par 2.
Renvoie le résultat absolu. Si la commande était toujours dans le sens horaire, abselle ne serait pas requise.

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

Python 2, 48 47 50 octets

Très simple; suit l'équation standard:

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

Les autres approches, tout aussi simples, sont plus longues:

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

L'accès de Python à une fonction déterminée se fait par numpy .

Merci à muddyfish pour 1 octet et xnor pour avoir attrapé une erreur.

PHP, 77

Sur la base de la réponse de @Yimin Rong, j'ai senti que je pouvais l'améliorer de quelques octets en utilisant list()plutôt que directement $argvpour abréger certaines variables. Aussiecho pas non plus besoin d'espace s'il y a un délimiteur entre l'écho et la chose en écho.

echo$variable;,, echo(4+2);et echo'some string';sont également valables alors queechofunction($variable) confond PHP.

D'un autre côté, j'ai également ajouté abs()pour être mathématiquement précis, car certaines combinaisons de sommets ont produit une "zone négative"

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

Vous pouvez l'exécuter 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 octets

AWK n'a pas intégré, absdonc en utilisantsqrt(x^2) pour remplacer.

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

Enregistrer sous area.awket utiliser sous echo x₁ y₁ x₂ y₂ x₃ y₃ | awk -f area.awk, par exemple

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

PowerShell, 70 octets

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

Utilise la même formule standard que les autres solutions. Par la question, suppose que le tableau est pré-rempli, par exemple $t=(1,2,4,2,3,7). Mais ouf , la syntaxe $et []tue-t-elle celui-ci ...

dc , 52 octets

Suppose que l'entrée est dans le registre t comme: x1 y1 x2 y2 x3 y3avec x1en haut de tla pile.

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

Cela utilise la formule suivante pour la zone:

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

Et pour une ventilation rapide du processus:

• 1k Lt Lt sa Lt sb Lt d sc Lt lt r: définissez la précision décimale à 1 place, déplacez des parties de la pile dans tla pile principale et déplacez diverses parties de la pile principale vers d'autres registres pour le stockage ( dduplique le haut de la pile principale, rinverse les deux éléments supérieurs de la pile principale, L/ldéplacez / copie du registre donné au principal,s déplace le haut de la pile principale vers le registre donné)

  Principale: y3 x3 y2 x1

  a:, y1b:, x2c y2:, t:y3

• la lc lb lt la: Copier la partie supérieure des piles de registres a, c, b, t, et ade la pile principale dans cet ordre

  Principale: y1 y3 x2 y2 y1 y3 x3 y2 x1

  a:, y1b:, x2c y2:, t:y3

• - * sd: Calculate ((y3-y1)*x2)et le résultat mis en d(registres a, b, cet tne sont plus utilisés donc je vais les déposer dans la liste des piles maintenant)

  Principale: y2 y1 y3 x3 y2 x1

  ré:((y3-y1)*x2)

• - * se - *: calculer ((y1-y2)*y3)et ((y2-x3)*x1); stocker l'ancien danse et laisser ce dernier sur la pile principale

  Principale: ((y2-x3)*x1)

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

• le ld + +: copier le haut du registre eet ddans la pile principale, calculer la somme des 2 valeurs de pile supérieures (repousser le résultat dans la pile principale) deux fois

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

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

• 2 /: poussez 2 sur la pile principale, divisez les 2ème valeurs de la pile par la 1ère ( det ene sont plus utilisées, supprimez-les de la liste des piles)

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

En réorganisant la valeur sur la pile, nous pouvons voir qu'elle est équivalente à la formule en haut de cette explication: (x1(y2-y3) + x2(y3-y1) + x3(y1 - y2))/2

• p: Imprimer le haut de la pile principale pour la sortie.