Từ Wikipedia :

Trọng tâm của một đa giác khép kín không tự giao nhau được xác định bởi n đỉnh ( x ₀ , y ₀ ), ( x ₁ , y ₁ ), ..., ( x _{n - 1} , y _{n 1} ) là điểm ( C _x , C _y ), trong đó

và ở đâu A là khu vực đã ký của đa giác,

Trong các công thức này, các đỉnh được giả sử được đánh số theo thứ tự xuất hiện dọc theo chu vi của đa giác. Hơn nữa, đỉnh ( x _n , y _n ) được giả sử giống với ( x ₀ , y ₀ ), nghĩa là i + 1 trong trường hợp cuối cùng phải lặp lại với i = 0 . Lưu ý rằng nếu các điểm được đánh số theo thứ tự theo chiều kim đồng hồ, khu vực A , được tính như trên, sẽ có dấu âm; nhưng tọa độ centroid sẽ đúng ngay cả trong trường hợp này.

• Đưa ra một danh sách các đỉnh theo thứ tự (theo chiều kim đồng hồ hoặc ngược chiều kim đồng hồ), tìm tâm của đa giác khép kín không tự giao nhau được biểu thị bởi các đỉnh.
  • Nếu nó hữu ích, bạn có thể giả sử đầu vào chỉ là CW hoặc chỉ CCW. Nói như vậy trong câu trả lời của bạn nếu bạn yêu cầu điều này.
• Các tọa độ không bắt buộc phải là số nguyên và có thể chứa các số âm.
• Đầu vào sẽ luôn hợp lệ và chứa ít nhất ba đỉnh.
• Các đầu vào chỉ cần được xử lý phù hợp với kiểu dữ liệu dấu phẩy động gốc của ngôn ngữ của bạn.
• Bạn có thể cho rằng các số đầu vào sẽ luôn chứa một dấu thập phân.
• Bạn có thể giả sử rằng số nguyên đầu vào kết thúc bằng .hoặc.0 .
• Bạn có thể sử dụng số phức cho đầu vào.
• Đầu ra phải chính xác đến một phần nghìn gần nhất.

Ví dụ

[(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

Quá nhìn thấy từng đa giác trên mặt phẳng tọa độ, dán tọa độ mà không có dấu ngoặc vuông trong menu "Chỉnh sửa" của trang này .

Tôi đã xác nhận kết quả của mình bằng Máy tính điểm đa giác Centroid này , điều này thật tồi tệ. Tôi không thể tìm thấy một cái mà bạn có thể nhập tất cả các đỉnh cùng một lúc, hoặc nó không cố xóa -dấu hiệu của bạn khi bạn nhập nó trước. Tôi sẽ đăng giải pháp Python của tôi để bạn sử dụng sau khi mọi người có cơ hội trả lời.

Thạch , 25 24 22 21 18 byte

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

Áp dụng công thức thể hiện trong bài toán.

Đã lưu 3 byte với sự giúp đỡ từ @ Jonathan Allan.

Hãy thử trực tuyến! hoặc là Xác minh tất cả các trường hợp thử nghiệm.

Giải trình

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

Toán học, 23 byte

RegionCentroid@*Polygon

Hãy THẬT , Jelly!

Chỉnh sửa: Một người không chỉ đơn giản là đánh bại Jelly ...

Giải trình

Polygon

Tạo một đa giác với các đỉnh tại các điểm được chỉ định.

RegionCentroid

Tìm trọng tâm của đa giác.

J, 29 byte

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

Áp dụng công thức thể hiện trong bài toán.

Sử dụng

   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

Giải trình

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

Tôi không có kinh nghiệm với Maxima, vì vậy mọi gợi ý đều được chào đón.

Sử dụng:

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

Vợt 420 byte

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

Ung dung:

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

Kiểm tra:

(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)])

Đầu ra:

'(-1.7266666666666677 8.01666666666667)
'(5.8010476997538465 15.067381276150996)

R, 129 127 byte

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}

Hàm không tên lấy danh sách R của các bộ dữ liệu làm đầu vào. Tương đương có tên có thể được gọi bằng cách sử dụng, vd:

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

Ung dung và giải thích

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
}

Bước cuối cùng ( c(sum((x+X)*p),sum((y+Y)*p))/sum(p)*2/6) là một cách tính toán véc tơ cả Cxvà Cy. Tổng trong các công thức cho Cxvà Cyđược lưu trữ trong một vectơ và do đó được chia cho "tổng trong A" *2/6. Ví dụ:

(SUMinCx, SUMinCy) / SUMinA / 3

, và sau đó in ngầm.

Hãy thử nó trên R-fiddle

Python, 156 127 byte

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

Ung dung:

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

Có nghĩa là nó.

Điều này lấy mỗi cặp điểm [x, y]là một số phức x + y*jvà đưa ra kết quả là một số phức có cùng định dạng.

Đối với cặp điểm [a, b]và [c, d], giá trị a*d - b*ccần thiết cho mỗi cặp điểm có thể được tính từ yếu tố quyết định của ma trận

| a b |
| c d |

Sử dụng số học phức tạp, các giá trị phức tạp a + b*jvà c + d*jcó thể được sử dụng như

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

Lưu ý rằng phần tưởng tượng là tương đương với phần xác định. Ngoài ra, sử dụng các giá trị phức tạp cho phép các điểm dễ dàng được tóm tắt thành phần khôn ngoan trong các hoạt động khác.

R + sp (46 byte)

Giả sử spgói được cài đặt ( https://cran.r-project.org/web/packages/sp/ )

Đưa ra một danh sách các đỉnh, (ví dụ list(c(0.,0.), c(1.,0.), c(1.,1.), c(0.,1.)))

Tận dụng lợi thế của "labpt" của Đa giác là trọng tâm.

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

JavaScript (ES6), 102

Thực hiện thẳng công thức

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]

Kiểm tra

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 byte

Sử dụng không có số phức.

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

Dùng thử trực tuyến

Ung dung:

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

Thật ra, 45 40 39 byte

Này sử dụng một thuật toán tương tự như Jelly câu trả lời dặm . Có một cách ngắn hơn để tính toán các yếu tố quyết định bằng cách sử dụng một sản phẩm chấm, nhưng hiện tại có một lỗi với sản phẩm dấu chấm trên thực tế, nơi nó không hoạt động với danh sách các số float. Gợi ý chơi golf chào mừng. Hãy thử trực tuyến!

;\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.

Một phiên bản ngắn hơn, không cạnh tranh

Đây là một phiên bản 24 byte khác sử dụng số phức. Nó không cạnh tranh bởi vì nó phụ thuộc vào các bản sửa lỗi đã hoãn thử thách này. Hãy thử trực tuyến!

;\│¥)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 byte

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

Đầu ra là cấu trúc trợ giúp P,

Ung dung:

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

Sử dụng:

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 byte

Cập nhật: Thay vì gọi lại tôi đang sử dụng [a b c d 1]như một hàm và đối số chỉ là một danh sách các chỉ mục cho vectơ này. 1được sử dụng làm giá trị sentinel khi tính toán A.

Cập nhật 2: Không tính toán Atrước let, sử dụng (rest(cycle %))để lấy các vectơ đầu vào bù cho một.

#(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)))

Phiên bản gốc:

#(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))]))

Ở giai đoạn ít chơi gôn:

(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)))])))

Tạo một hàm trợ giúp Fthực hiện phép tính tổng với bất kỳ cuộc gọi lại nào l. Đối với Acác cuộc gọi lại trả về liên tục 1trong khi tọa độ X và Y có chức năng riêng của họ. (conj(subvec v 1)(v 0))bỏ phần tử đầu tiên và nối vào cuối, theo cách này rất dễ để theo dõi x_ivà x_(i+1). Có lẽ vẫn còn một số sự lặp lại để được loại bỏ, đặc biệt là cuối cùng (map F[....