Aus Wikipedia :

Der Schwerpunkt eines geschlossenen Polygons, das sich nicht selbst schneidet und durch n Eckpunkte ( x ₀ , y ₀ ), ( x ₁ , y ₁ ), ..., ( x _{n - 1} , y _{n - 1} ) definiert ist, ist der Punkt ( C _x , C _y ), an dem

und wo A die Fläche des Polygons ist,

In diesen Formeln wird angenommen, dass die Eckpunkte in der Reihenfolge ihres Auftretens entlang des Umfangs des Polygons nummeriert sind. Außerdem wird angenommen, dass der Scheitelpunkt ( x _n , y _n ) derselbe ist wie ( x ₀ , y ₀ ), was bedeutet, dass i + 1 im letzten Fall auf i = 0 umlaufen muss . Beachten Sie, dass der Bereich A , der wie oben berechnet wurde, ein negatives Vorzeichen hat , wenn die Punkte im Uhrzeigersinn nummeriert werden. Die Schwerpunktkoordinaten sind jedoch auch in diesem Fall korrekt.

• Suchen Sie anhand einer Liste von Eckpunkten in der angegebenen Reihenfolge (entweder im oder gegen den Uhrzeigersinn) den Schwerpunkt des geschlossenen Polygons, das sich nicht selbst schneidet und durch die Eckpunkte dargestellt wird.
  • Wenn dies hilft, können Sie davon ausgehen, dass die Eingabe nur im Uhrzeigersinn oder nur im Gegenuhrzeigersinn erfolgt. Sagen Sie dies in Ihrer Antwort, wenn Sie dies benötigen.
• Die Koordinaten müssen keine ganzen Zahlen sein und können negative Zahlen enthalten.
• Die Eingabe ist immer gültig und enthält mindestens drei Eckpunkte.
• Es müssen nur Eingaben verarbeitet werden, die zum nativen Gleitkomma-Datentyp Ihrer Sprache passen.
• Sie können davon ausgehen, dass Eingabenummern immer einen Dezimalpunkt enthalten.
• Sie können davon ausgehen, dass ganze Zahlen mit .oder enden .0.
• Sie können komplexe Zahlen für die Eingabe verwenden.
• Die Ausgabe sollte auf das nächste Tausendstel genau sein.

Beispiele

[(0.,0.), (1.,0.), (1.,1.), (0.,1.)]        -> (0.5, 0.5)
[(-15.21,0.8), (10.1,-0.3), (-0.07,23.55)]  -> -1.727 8.017
[(-39.00,-55.94), (-56.08,-4.73), (-72.64,12.12), (-31.04,53.58), (-30.36,28.29), (17.96,59.17), (0.00,0.00), (10.00,0.00), (20.00,0.00), (148.63,114.32), (8.06,-41.04), (-41.25,34.43)]   -> 5.80104769975, 15.0673812762

Um jedes Polygon in einer Koordinatenebene anzuzeigen, fügen Sie die Koordinaten ohne eckige Klammern in das Menü "Bearbeiten" dieser Seite ein .

Ich habe meine Ergebnisse mit diesem schrecklichen Polygon Centroid Point Calculator bestätigt . Ich habe keine gefunden, bei der Sie alle Scheitelpunkte gleichzeitig eingeben können oder bei der nicht versucht wurde, Ihr -Vorzeichen bei der ersten Eingabe zu löschen . Ich werde meine Python-Lösung für Sie bereitstellen, nachdem die Benutzer die Möglichkeit hatten, eine Antwort zu geben.

Gelee , 25 24 22 21 18 Bytes

S×3÷@×"
ṙ-żµÆḊçS€S

Wendet die im Problem gezeigte Formel an.

3 Bytes mit Hilfe von @ Jonathan Allan gespeichert .

Probieren Sie es online! oder Überprüfen Sie alle Testfälle.

Erläuterung

S×3÷@×"  Helper link. Input: determinants on LHS, sum of pairs on RHS
S        Sum the determinants
 ×3      Multiply by 3
     ×"  Vectorized multiply between determinants and sums
   ÷@    Divide that by the determinant sum multipled by 3 and return

ṙ-żµÆḊçS€S  Main link. Input: 2d list of points
ṙ-          Rotate the list of points by 1 to the right
  ż         Interleave those with the original points
            This creates all overlapping slices of length 2
   µ        Start new monadic chain
    ÆḊ      Get the determinant of each slice
       S€   Get the sum of each slice (sum of pairs of points)
      ç     Call the helper link
         S  Sum and return

Mathematica, 23 Bytes

RegionCentroid@*Polygon

Nehmen DAS , Jelly!

Edit: Man schlägt Jelly nicht einfach ...

Erläuterung

Polygon

Generieren Sie an den angegebenen Punkten ein Polygon mit Eckpunkten.

RegionCentroid

Finden Sie den Schwerpunkt des Polygons.

J, 29 Bytes

2+/@(+/\(*%3*1#.])-/ .*\)],{.

Wendet die im Problem gezeigte Formel an.

Verwendung

   f =: 2+/@(+/\(*%3*1#.])-/ .*\)],{.
   f 0 0 , 1 0 , 1 1 ,: 0 1
0.5 0.5
   f _15.21 0.8 , 10.1 _0.3 ,: _0.07 23.55
_1.72667 8.01667
   f _39 _55.94 , _56.08 _4.73 , _72.64 12.12 , _31.04 53.58 , _30.36 28.29 , 17.96 59.17 , 0 0 , 10 0 , 20 0 , 148.63 114.32 , 8.06 _41.04 ,: _41.25 34.43
5.80105 15.0674

Erläuterung

2+/@(+/\(*%3*1#.])-/ .*\)],{.  Input: 2d array of points P [[x1 y1] [x2 y2] ...]
                           {.  Head of P
                         ]     Get P
                          ,    Join, makes the end cycle back to the front
2                              The constant 2
2                      \       For each pair of points
                  -/ .*        Take the determinant
2    +/\                       Sum each pair of points
         *                     Multiply the sum of each pair by its determinant
          %                    Divide each by
             1#.]              The sum of the determinants
           3*                  Multiplied by 3
 +/@                           Sum and return

Maxima, 124 118 116 112 106 Byte

f(l):=(l:endcons(l[1],l),l:sum([3,l[i-1]+l[i]]*determinant(matrix(l[i-1],l[i])),i,2,length(l)),l[2]/l[1]);

Ich habe keine Erfahrung mit Maxima, daher sind alle Hinweise willkommen.

Verwendung:

(%i6) f([[-15.21,0.8], [10.1,-0.3], [-0.07,23.55]]);
(%o6)              [- 1.726666666666668, 8.016666666666668]

Schläger 420 Bytes

(let*((lr list-ref)(getx(lambda(i)(lr(lr l i)0)))(gety(lambda(i)(lr(lr l i)1)))(n(length l))(j(λ(i)(if(= i(sub1 n))0(add1 i))))
(A(/(for/sum((i n))(-(*(getx i)(gety(j i)))(*(getx(j i))(gety i))))2))
(cx(/(for/sum((i n))(*(+(getx i)(getx(j i)))(-(*(getx i)(gety(j i)))(*(getx(j i))(gety i)))))(* 6 A)))
(cy(/(for/sum((i n))(*(+(gety i)(gety(j i)))(-(*(getx i)(gety(j i)))(*(getx(j i))(gety i)))))(* 6 A))))
(list cx cy))

Ungolfed:

(define(f l)
  (let* ((lr list-ref)
         (getx (lambda(i)(lr (lr l i)0)))
         (gety (lambda(i)(lr (lr l i)1)))
         (n (length l))
         (j (lambda(i) (if (= i (sub1 n)) 0 (add1 i))))
         (A (/(for/sum ((i n))
                (-(* (getx i) (gety (j i)))
                  (* (getx (j i)) (gety i))))
              2))
         (cx (/(for/sum ((i n))
                 (*(+(getx i)(getx (j i)))
                   (-(*(getx i)(gety (j i)))
                     (*(getx (j i))(gety i)))))
               (* 6 A)))
         (cy (/(for/sum ((i n))
                 (*(+(gety i)(gety (j i)))
                   (-(*(getx i)(gety (j i)))
                     (*(getx (j i))(gety i)))))
               (* 6 A))))
    (list cx cy)))

Testen:

(f '[(-15.21 0.8)  (10.1 -0.3)  (-0.07 23.55)] ) 
(f '[(-39.00 -55.94)  (-56.08 -4.73)  (-72.64 12.12)  (-31.04 53.58) 
     (-30.36 28.29)  (17.96 59.17)  (0.00 0.00)  (10.00 0.00)  
     (20.00 0.00) (148.63 114.32)  (8.06 -41.04)  (-41.25 34.43)])

Ausgabe:

'(-1.7266666666666677 8.01666666666667)
'(5.8010476997538465 15.067381276150996)

R, 129 127 Bytes

function(l){s=sapply;x=s(l,`[`,1);y=s(l,`[`,2);X=c(x[-1],x[1]);Y=c(y[-1],y[1]);p=x*Y-X*y;c(sum((x+X)*p),sum((y+Y)*p))/sum(p)/3}

Unbenannte Funktion, die eine R-Liste von Tupeln als Eingabe verwendet. Das benannte Äquivalent kann aufgerufen werden mit zB:

f(list(c(-15.21,0.8),c(10.1,-0.3),c(-0.07,23.55)))

Ungolfed und erklärte

f=function(l){s=sapply;                           # Alias for sapply
              x=s(l,`[`,1);                       # Split list of tuples into vector of first elements
              y=s(l,`[`,2);                       # =||= but for second element 
              X=c(x[-1],x[1]);                    # Generate a vector for x(i+1)
              Y=c(y[-1],y[1]);                    # Generate a vector for y(i+1)
              p=x*Y-X*y;                          # Calculate the outer product used in both A, Cx and Cy
              c(sum((x+X)*p),sum((y+Y)*p))/sum(p)/3    # See post for explanation
}

Der letzte Schritt ( c(sum((x+X)*p),sum((y+Y)*p))/sum(p)*2/6) ist eine vektorisierte Methode zur Berechnung von Cxund Cy. Die Summe in den Formeln für Cxund Cywird in einem Vektor gespeichert und folglich durch die "Summe in A" dividiert *2/6. Z.B:

(SUMinCx, SUMinCy) / SUMinA / 3

und dann implizit gedruckt.

Probieren Sie es auf R-Geige

Python, 156 127 Bytes

def f(p):n=len(p);p=p+p[:1];i=s=0;exec'd=(p[i].conjugate()*p[i+1]).imag;s+=d;p[i]=(p[i]+p[i+1])*d;i+=1;'*n;print sum(p[:n])/s/3

Ungolfed:

def f(points):
  n = len(points)
  points = points + [points[0]]
  determinantSum = 0
  for i in range(n):
    determinant = (points[i].conjugate() * points[i+1]).imag
    determinantSum += determinant
    points[i] = (points[i] + points[i+1]) * determinant
  print sum(points[:n]) / determinantSum / 3

Ideone es.

Dies nimmt jedes Punktepaar [x, y]als komplexe Zahlx + y*j und gibt den resultierenden Schwerpunkt als komplexe Zahl im gleichen Format aus.

Für das Punktepaar [a, b]und [c, d]kann der Wert, a*d - b*cder für jedes Punktepaar benötigt wird, aus der Determinante der Matrix berechnet werden

| a b |
| c d |

Mit komplexer Arithmetik können die komplexen Werte a + b*jund c + d*jals verwendet werden

conjugate(a + b*j) * (c + d*j)
(a - b*j) * (c + d*j)
(a*c + b*d) + (a*d - b*c)*j

Beachten Sie, dass der Imaginärteil der Determinante entspricht. Durch die Verwendung komplexer Werte können die Punkte auch in anderen Operationen auf einfache Weise komponentenweise summiert werden.

R + sp (46 Bytes)

Angenommen, das spPaket ist installiert ( https://cran.r-project.org/web/packages/sp/ )

Nimmt eine Liste von Scheitelpunkten auf (zum Beispiel list(c(0.,0.), c(1.,0.), c(1.,1.), c(0.,1.)) )

Nutzt die Tatsache aus, dass das "Labpt" eines Polygons der Schwerpunkt ist.

function(l)sp::Polygon(do.call(rbind,l))@labpt

JavaScript (ES6), 102

Direkte Umsetzung der Formel

l=>[...l,l[0]].map(([x,y],i)=>(i?(a+=w=t*y-x*u,X+=(t+x)*w,Y+=(u+y)*w):X=Y=a=0,t=x,u=y))&&[X/3/a,Y/3/a]

Prüfung

f=
l=>[...l,l[0]].map(([x,y],i)=>(i?(a+=w=t*y-x*u,X+=(t+x)*w,Y+=(u+y)*w):X=Y=a=0,t=x,u=y))&&[X/3/a,Y/3/a]

function go()
{
  var c=[],cx,cy;
  // build coordinates array
  I.value.match(/-?[\d.]+/g).map((v,i)=>i&1?t[1]=+v:c.push(t=[+v]));
  console.log(c+''),
  [cx,cy]=f(c);
  O.textContent='CX:'+cx+' CY:'+cy;
  // try to display the polygon
  var mx=Math.max(...c.map(v=>v[0])),
    nx=Math.min(...c.map(v=>v[0])),
    my=Math.max(...c.map(v=>v[1])),
    ny=Math.min(...c.map(v=>v[1])),  
    dx=mx-nx, dy=my-ny,
    ctx=C.getContext("2d"),
    cw=C.width, ch=C.height,
    fx=(mx-nx)/cw, fy=(my-ny)/ch, fs=Math.max(fx,fy)
  C.width=cw
  ctx.setTransform(1,0,0,1,0,0);
  ctx.beginPath();
  c.forEach(([x,y],i)=>ctx.lineTo((x-nx)/fs,(y-ny)/fs));
  ctx.closePath();
  ctx.stroke();
  ctx.fillStyle='#ff0000';
  ctx.fillRect((cx-nx)/fs-2,(cy-ny)/fs-2,5,5);
}
go()

#I { width:90% }
#C { width:90%; height:200px;}

<input id=I value='[[-15.21,0.8], [10.1,-0.3], [-0.07,23.55]]'>
<button onclick='go()'>GO</button>
<pre id=O></pre>
<canvas id=C></canvas>

Python 2, 153 Bytes

Verwendet keine komplexen Zahlen.

P=input()
A=x=y=0;n=len(P)
for i in range(n):m=-~i%n;a=P[i][0];b=P[i][1];c=P[m][0];d=P[m][1];t=a*d-b*c;A+=t;x+=t*(a+c);y+=t*(b+d)
k=1/(3*A);print x*k,y*k

Probieren Sie es online aus

Ungolfed:

def centroid(P):
    A=x=y=0
    n=len(P)
    for i in range(n):
        m=-~i%n
        x0=P[i][0];y0=P[i][1]
        x1=P[m][0];y1=P[m][1]
        t = x0*y1 - y0*x1
        A += t/2.
        x += t * (x0 + x1)
        y += t * (y0 + y1)
    k = 1/(6*A)
    x *= k
    y *= k
    return x,y

Eigentlich 45 40 39 Bytes

Dies verwendet einen Algorithmus, der der Meilen-Gelee-Antwort ähnlich ist . Es gibt eine kürzere Möglichkeit, Determinanten mit einem Punktprodukt zu berechnen, aber derzeit gibt es einen Fehler mit dem Punktprodukt von Actually, bei dem es nicht mit Float-Listen funktioniert. Golfvorschläge sind willkommen. Probieren Sie es online!

;\Z♂#;`i¥`M@`i│N@F*)F@N*-`M;Σ3*)♀*┬♂Σ♀/

Ungolfing

         Implicit input pts.
;\       Duplicate pts, rotate right.
Z        Zip rot_pts and pts together.
♂#       Convert the iterables inside the zip to lists
         (currently necessary due to a bug with duplicate)
;        Duplicate the zip.
`...`M   Get the sum each pair of points in the zip.
  i        Flatten the pair to the stack.
  ¥        Pairwise add the two coordinate vectors.
@        Swap with the other zip.
`...`M   Get the determinants of the zip.
  i│       Flatten to stack and duplicate entire stack.
           Stack: [a,b], [c,d], [a,b], [c,d]
  N@F*)    Push b*c and move it to BOS.
  F@N*     Push a*d.
  -        Get a*d-b*c.
;Σ3*)    Push 3 * sum(determinants) and move it to BOS.
♀*       Vector multiply the determinants and the sums.
┬        Transpose the coordinate pairs in the vector.
♂Σ       Sum the x's, then the y's.
♀/       Divide the x and y of this last coordinate pair by 3*sum(determinants).
         Implicit return.

Eine kürzere, nicht wettbewerbsfähige Version

Dies ist eine weitere 24-Byte-Version, die komplexe Zahlen verwendet. Es ist nicht wettbewerbsfähig, da es auf Fehlerbehebungen beruht, die diese Herausforderung nachholen. Probieren Sie es online!

;\│¥)Z`iá*╫@X`M;Σ3*)♀*Σ/

Ungolfing

         Implicit input a list of complex numbers, pts.
;\       Duplicate pts, rotate right.
│        Duplicate stack. Stack: rot_pts, pts, rot_pts, pts.
¥)       Pairwise sum the two lists of points together and rotate to BOS.
Z        Zip rot_pts and pts together.
`...`M   Map the following function over the zipped points to get our determinants.
  i        Flatten the list of [a+b*i, c+d*i].
  á        Push the complex conjugate of a+bi, i.e. a-b*i.
  *        Multiply a-b*i by c+d*i, getting (a*c+b*d)+(a*d-b*c)*i.
           Our determinant is the imaginary part of this result.
  ╫@X      Push Re(z), Im(z) to the stack, and immediately discard Re(z).
           This map returns a list of these determinants.
;        Duplicate list_determinants.
Σ3*)     Push 3 * sum(list_determinants) and rotate that to BOS.
♀*Σ      Pairwise multiply the sums of pairs of points and the determinants and sum.
/        Divide that sum by 3*sum(list_determinants).
         Implicit return.

C ++ 14, 241 Bytes

struct P{float x;float y;};
#define S(N,T)auto N(P){return 0;}auto N(P a,P b,auto...V){return(T)*(a.x*b.y-b.x*a.y)+N(b,V...);}
S(A,1)S(X,a.x+b.x)S(Y,a.y+b.y)auto f(auto q,auto...p){auto a=A(q,p...,q)*3;return P{X(q,p...,q)/a,Y(q,p...,q)/a};}

Ausgabe ist die Hilfsstruktur P ,

Ungolfed:

 //helper struct
struct P{float x;float y;};

//Area, Cx and Cy are quite similar
#define S(N,T)\  //N is the function name, T is the term in the sum
auto N(P){return 0;} \   //end of recursion for only 1 element
auto N(P a,P b,auto...V){ \ //extract the first two elements
  return (T)*(a.x*b.y-b.x*a.y) //compute with a and b
         + N(b,V...); \        //recursion without first element
}

//instantiate the 3 formulas
S(A,1)
S(X,a.x+b.x)
S(Y,a.y+b.y)


auto f(auto q,auto...p){
  auto a=A(q,p...,q)*3; //q,p...,q appends the first element to the end
  return P{X(q,p...,q)/a,Y(q,p...,q)/a};
}

Verwendung:

f(P{0.,0.}, P{1.,0.}, P{1.,1.}, P{0.,1.})
f(P{-15.21,0.8}, P{10.1,-0.3}, P{-0.07,23.55})

Clojure, 177 156 143 Bytes

Update: Anstelle eines Rückrufs verwende ich [a b c d 1]als Funktion und das Argument ist nur eine Liste von Indizes zu diesem Vektor. 1wird bei der Berechnung als Sentinel-Wert verwendet A.

Update 2: Nicht vorberechnen Aum let, (rest(cycle %))um Eingabevektoren um eins versetzt zu bekommen.

#(let[F(fn[I](apply +(map(fn[[a b][c d]](*(apply +(map[a b c d 1]I))(-(* a d)(* c b))))%(rest(cycle %)))))](for[i[[0 2][1 3]]](/(F i)(F[4])3)))

Originalfassung:

#(let[F(fn[L](apply +(map(fn[[a b][c d]](*(L[a b c d])(-(* a d)(* c b))))%(conj(subvec % 1)(% 0)))))A(*(F(fn[& l]1))3)](map F[(fn[v](/(+(v 0)(v 2))A))(fn[v](/(+(v 1)(v 3))A))]))

Bei weniger Golfplätzen:

(def f (fn[v](let[F (fn[l](apply +(map
                                    (fn[[a b][c d]](*(l a b c d)(-(* a d)(* c b))))
                                    v
                                    (conj(subvec v 1)(v 0)))))
                  A (* (F(fn[& l] 1)) 3)]
                [(F (fn[a b c d](/(+ a c)A)))
                 (F (fn[a b c d](/(+ b d)A)))])))

Erstellt eine Hilfsfunktion, Fdie die Summierung bei jedem Rückruf implementiert l. Denn Ader Rückruf kehrt ständig zurück, 1während die X- und Y-Koordinaten ihre eigenen Funktionen haben. (conj(subvec v 1)(v 0))Löscht das erste Element und hängt es an das Ende an. Auf diese Weise ist es einfach, den Überblick über x_iund zu behalten x_(i+1). Vielleicht gibt es noch einige Wiederholungen, die beseitigt werden müssen, insbesondere beim letzten Mal (map F[....