উইকিপিডিয়া থেকে :

এন শিখর ( x ₀ , y ₀ ), ( x ₁ , y ₁ ), ..., ( x _{n - 1} , y _{n − 1} ) দ্বারা সংজ্ঞায়িত একটি অ-স্ব-ছেদকৃত বন্ধ বহুভুজটির সেন্ট্রয়েড হ'ল বিন্দু ( C _x , C _y ), যেখানে

এবং যেখানে এ বহুভুজের স্বাক্ষরিত অঞ্চল,

এই সূত্রগুলিতে, বহুভুজের পরিধিগুলির সাথে অনুভূমিকগুলি তাদের সংক্রমণের অনুসারে সংখ্যাযুক্ত বলে মনে করা হয়। তদ্ব্যতীত, প্রান্তবিন্দু ( এক্স _এন , Y _এন ) হিসেবে (একই গণ্য করা হয় এক্স ₀ , Y ₀ ) অর্থ আমি +1 প্রায় শেষ ক্ষেত্রে আবশ্যক লুপ উপর i = 0 । নোট করুন যে পয়েন্টগুলি যদি ঘড়ির কাঁটার দিক দিয়ে সংখ্যায়িত করা হয় তবে উপরের হিসাবে গণনা করা অঞ্চল A এর নেতিবাচক চিহ্ন থাকবে; তবে সেন্ট্রয়েড স্থানাঙ্কগুলি এই ক্ষেত্রেও সঠিক হবে।

ক্রমানুভূমিকের একটি তালিকা দেওয়া হয়েছে (হয় ঘড়ির কাঁটার দিক থেকে, বা ঘড়ির কাঁটার দিকের দিকের দিকের), শীর্ষকোষ দ্বারা উপস্থাপিত অ-স্ব-ছেদকৃত বন্ধ বহুভুজটির সেন্ট্রয়েড সন্ধান করুন।
- যদি এটি সহায়তা করে তবে আপনি ইনপুটটিকে কেবল সিডাব্লু বা কেবল সিসিডাব্লু হিসাবে ধরে নিতে পারেন। আপনার যদি এটির প্রয়োজন হয় তবে আপনার উত্তরে বলুন।
স্থানাঙ্কগুলির পূর্ণসংখ্যার প্রয়োজন হয় না এবং এতে নেতিবাচক সংখ্যা থাকতে পারে।
ইনপুট সর্বদা বৈধ থাকবে এবং কমপক্ষে তিনটি শীর্ষবিন্দু থাকবে।
ইনপুটগুলি কেবলমাত্র আপনার ভাষার স্থানীয় ভাসমান পয়েন্টের ডেটা টাইপের মতো ফিট করে hand
আপনি ধরে নিতে পারেন ইনপুট সংখ্যায় সর্বদা দশমিক পয়েন্ট থাকবে।
আপনি যে ইনপুট পূর্ণসংখ্যার শেষ অনুমান হতে পারে .বা .0।
আপনি ইনপুট জন্য জটিল নম্বর ব্যবহার করতে পারেন।
আউটপুটটি নিকটতম হাজারতমের কাছে সঠিক হওয়া উচিত।

উদাহরণ

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

একটি সমন্বিত বিমানের প্রতিটি বহুভুজ দেখতে খুব বেশি, এই পৃষ্ঠার "সম্পাদনা" মেনুতে বর্গাকার বন্ধনীগুলি ছাড়াই স্থানাঙ্কগুলি পেস্ট করুন ।

আমি এই বহুভুজ সেন্ট্রয়েড পয়েন্ট ক্যালকুলেটরটি ব্যবহার করে আমার ফলাফলগুলি নিশ্চিত করেছি , যা ভয়াবহ। আমি এমন কোনওটি খুঁজে পেল না যে আপনি একবারে সমস্ত সূচকে ইনপুট করতে পারেন বা -আপনি যখন প্রথমে এটি টাইপ করেন তখন আপনার চিহ্নটি মুছে ফেলার চেষ্টা করেনি । লোকেরা উত্তর দেওয়ার সুযোগ পাওয়ার পরে আমি আপনার পাইথনের সমাধানটি আপনার ব্যবহারের জন্য পোস্ট করব।

code-golf geometry

— mbomb007
সূত্র

প্রথম দুটি সেটের জন্য সমস্ত এক্স এবং ওয়াইয়ের কাজগুলি গড়ে গড়ে তোলার খুব সহজ কৌশল, তবে তৃতীয় নয়। আমি আশ্চর্য হয়েছি কী কী পার্থক্য করে ...

— ETH প্রোডাকশনগুলি

1

@Ethproductions তৃতীয় বহুভুজ উত্তল নয়।

— জংহওয়ান মিন

1

@ ইথ প্রডাকশনগুলি যদি আপনি বহুভুজের সাহায্যে একটি বৃত্তের আনুমানিক অনুমান করেন তবে আপনি সেন্ট্রয়েডকে প্রায়শই প্রভাবিত না করে এবং বহুভুজের উত্তলটি বজায় রেখে প্রায় পয়েন্টের আরও বেশি পয়েন্ট ব্যবহার করে বৃত্তের বিন্দুটির গড় বিন্দুটিকে নির্বিচারে সরিয়ে নিতে পারেন।

— ক্রিশ্চান সিভর্স

2

@ETHproductions বাস্তবিক ন্যুব্জতা হয় না কারণ। সমস্ত xও yএর গড় গড় দেহকে বিতরণ করার পরিবর্তে সমস্ত ওজনকে শীর্ষে রেখে দেয়। প্রথমটি কাজের ক্ষেত্রে ঘটে কারণ এটি নিয়মিত, তাই উভয় পদ্ধতিই প্রতিসম কেন্দ্রে শেষ হয়। দ্বিতীয়টি কাজ করে কারণ ত্রিভুজগুলির জন্য উভয় পদ্ধতিই একই বিন্দুতে নিয়ে যায়।

— টন হসপেল

1

আমরা কি I / O এর জন্য জটিল সংখ্যা ব্যবহার করতে পারি?

— xnor

16

জেলি , 25 24 22 21 18 বাইট

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

সমস্যাটিতে প্রদর্শিত সূত্রটি প্রয়োগ করে।

@ জোনাথন অ্যালান এর সহায়তায় 3 বাইট সংরক্ষণ করা হয়েছে ।

এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস যাচাই করুন।

ব্যাখ্যা

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

— মাইল
সূত্র

আপনি এর ṁL‘$ṡ2মাধ্যমে ṙ1ż@বাżṙ1$

— জোনাথন অ্যালান

@ জোনাথন অ্যালান ধন্যবাদ, এছাড়াও আমি ṙ-żঅদলবদল এড়াতে এবং অন্য একটি বাইট সংরক্ষণ করতে ঘুরতে পারি

— মাইল

ওহ হ্যাঁ অবশ্যই!

— জোনাথন অ্যালান

17

গণিত, 23 বাইট

RegionCentroid@*Polygon

~~নিন যে , জেলি!~~

সম্পাদনা করুন: কেউ জেলিকে সহজভাবে পরাজিত করে না ...

ব্যাখ্যা

Polygon

উল্লিখিত পয়েন্টগুলিতে উল্লম্ব সহ বহুভুজ তৈরি করুন।

RegionCentroid

বহুভুজের সেন্ট্রয়েড সন্ধান করুন।

— জংহওয়ান মিন
সূত্র

2

ঠিক আছে আপনি আমাকে মারলেন, তবে আমার কাছে যা আছে তার চেয়ে সম্ভবত আরও ছোট উপায় আছে, জেলি সম্পর্কে আমার এখনও সম্পূর্ণ ধারণা নেই

— মাইল

3

@ মাইলস ও ... :(

— জুনহওয়ান মিন

4

জে, 29 বাইট

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

সমস্যাটিতে প্রদর্শিত সূত্রটি প্রয়োগ করে।

ব্যবহার

   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

ব্যাখ্যা

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

— মাইল
সূত্র

4

ম্যাক্সিমা, 124 118 116 112 106 বাইট

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

আমি ম্যাক্সিমার সাথে অভিজ্ঞ নই, তাই কোনও ইঙ্গিত স্বাগত।

ব্যবহার:

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

— খ্রিস্টান সিভর্স
সূত্র

3

র‌্যাকেট 420 বাইট

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

পরীক্ষামূলক:

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

আউটপুট:

'(-1.7266666666666677 8.01666666666667)
'(5.8010476997538465 15.067381276150996)

— rnso
সূত্র

3

আর, 129 127 বাইট

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}

নামহীন ফাংশন যা ইনপুট হিসাবে tuples একটি আর তালিকা নিতে। নামযুক্ত সমতুল্য উদাহরণস্বরূপ ব্যবহার করে বলা যেতে পারে:

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

অবহেলিত এবং ব্যাখ্যা

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
}

চূড়ান্ত পদক্ষেপ ( c(sum((x+X)*p),sum((y+Y)*p))/sum(p)*2/6) হ'ল Cxএবং উভয়ই গণনার একটি ভেক্টরাইজড উপায় Cy। জন্য সূত্রে সমষ্টি Cxএবং Cyএকটি ভেক্টর সংরক্ষিত হয় এবং এর ফলে "এ সমষ্টি দ্বারা বিভক্ত A" *2/6। উদাহরণ:

(SUMinCx, SUMinCy) / SUMinA / 3

, এবং তারপরে স্পষ্টভাবে মুদ্রিত।

এটি আর-ফিডেলে চেষ্টা করুন

— Billywob
সূত্র

*2/6সম্ভবত হতে পারে /3?

— mbomb007

@ এমবম্ব ২০০7 এটি অত্যন্ত শ্রমসাধ্যভাবে স্পষ্ট, আমার ধারণা আমি অন্য অংশটি গল্ফ করে আটকে গিয়েছিলাম। /

— শ্রাগ

মার্জিত, আমি sapplyআপনাকে এই তালিকাগুলি ব্যবহার করতে ব্যবহার করতে পছন্দ করি ! এখানে গল্ফ করার সুযোগ থাকতে পারে, আমি নিশ্চিত নই যে মঞ্জুরিযোগ্য ইনপুটটি কতটা নমনীয়। যদি আপনাকে কেবল স্থানাঙ্কগুলির একটি ক্রম যেমন ইনপুট করার অনুমতি দেওয়া হয় c(-15.21,0.8,10.1,-0.3,-0.07,23.55)তবে আপনি নিজের ফাংশনের প্রথম লাইনগুলি প্রতিস্থাপন করে 17 বাইট সংরক্ষণ করতে পারবেন y=l[s<-seq(2,sum(1|l),2)];x=l[-s];। সেই সেটিং হল yপ্রতিটি এমনকি-সূচীবদ্ধ উপাদান হতে l, এবং xযে অদ্ভুত-সূচীবদ্ধ উপাদান যাবে।

— rturnbull

এর চেয়েও ভাল, যদি আমরা কোনও ম্যাট্রিক্স (বা অ্যারে) ইনপুট করতে পারি তবে এর মতো matrix(c(-15.21,0.8,10.1,-0.3,-0.07,23.55),2)আপনার ফাংশনের শুরুটি হতে পারে x=l[1,];y=l[2,];যা 35 বাইট সাশ্রয় করে। (ইনপুট ম্যাট্রিক্স যে কোনও ক্ষেত্রে স্থানান্তরিত হতে পারে x=l[,1];y=l[,2];)) অবশ্যই, সকলের সহজ সমাধান হ'ল যদি xএবং yপয়েন্টগুলি পৃথক ভেক্টর হিসাবে কেবল ইনপুট হয় function(x,y)তবে আমি মনে করি না যে এটি অনুমোদিত ...

— rturnbull

@ আর্টারনবুল আমি মন্তব্যগুলিতে ওপিকে জিজ্ঞাসা করেছি এবং তিনি বিশেষত টিউপসগুলির একটি তালিকা চেয়েছিলেন (অবশ্যই খুব সহজেই আর তেমন অসুবিধে হয়নি) তাই আমি মনে করি না যে ম্যাট্রিক্স পদ্ধতির অনুমতি রয়েছে। এমনকি এটি থাকলেও ইনপুটটি ভেক্টর অংশ (অর্থাত্ c(...)) হতে হবে এবং ম্যাট্রিক্স রূপান্তরটি ফাংশনের অভ্যন্তরে করতে হবে।

— বিলিওব

2

পাইথন, 156 127 বাইট

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

এটি আদর্শ।

এটি প্রতিটি জোড়া পয়েন্টকে [x, y]একটি জটিল সংখ্যা হিসাবে নিয়ে যায় x + y*jএবং ফলস্বরূপ সেন্ট্রয়েডকে একই আকারে জটিল সংখ্যা হিসাবে আউটপুট করে।

পয়েন্টের জোড়ার জন্য [a, b]এবং প্রতিটি জোড় পয়েন্টের জন্য প্রয়োজনীয় [c, d]মানটি a*d - b*cম্যাট্রিক্সের নির্ধারক থেকে গণনা করা যেতে পারে

| a b |
| c d |

জটিল গাণিতিক ব্যবহার করে, জটিল মানগুলি a + b*jএবং c + d*jহিসাবে ব্যবহার করা যেতে পারে

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

লক্ষ্য করুন যে কল্পিত অংশটি নির্ধারকের সমান। এছাড়াও, জটিল মানগুলি ব্যবহার করে অন্যান্য ক্রিয়াকলাপগুলিতে পয়েন্টগুলিকে সহজেই উপাদান হিসাবে যুক্ত করা যায়।

— মাইল
সূত্র

2

আর + এসপি (46 বাইট)

অনুমান spপ্যাকেজ ইনস্টল করা হয়েছে ( https://cran.r-project.org/web/packages/sp/ )

শীর্ষে একটি তালিকা নেয়, (উদাহরণস্বরূপ list(c(0.,0.), c(1.,0.), c(1.,1.), c(0.,1.)))

একটি বহুভুজের "ল্যাপটপ" সেন্ট্রয়েড হ'ল এই সুবিধাটি নিয়ে যায়।

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

— mnel
সূত্র

2

জাভাস্ক্রিপ্ট (ES6), 102

সূত্রটি সোজা বাস্তবায়ন

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]

পরীক্ষা

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>

স্নিপেট প্রসারিত করুন

— edc65
সূত্র

1

পাইথন 2, 153 বাইট

কোনও জটিল সংখ্যা ব্যবহার করে না।

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

এটি অনলাইনে চেষ্টা করুন

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

— mbomb007
সূত্র

1

প্রকৃতপক্ষে, 45 40 39 বাইট

এটি মাইল 'জেলি উত্তরের অনুরূপ একটি অ্যালগরিদম ব্যবহার করে । একটি বিন্দু পণ্য ব্যবহার করে নির্ধারক গণনা করার জন্য আরও একটি ছোট উপায় রয়েছে, তবে বর্তমানে আসলতার ডট পণ্যটির সাথে একটি বাগ রয়েছে যেখানে এটি ফ্লোটের তালিকাগুলির সাথে কাজ করবে না। গল্ফিং পরামর্শ স্বাগত জানাই। এটি অনলাইন চেষ্টা করুন!

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

একটি সংক্ষিপ্ত, প্রতিযোগিতামূলক সংস্করণ

এটি অন্য 24-বাইট সংস্করণ যা জটিল সংখ্যা ব্যবহার করে। এটি অ-প্রতিযোগিতামূলক কারণ এটি এই চ্যালেঞ্জ পরবর্তী সময়ে যে বাগ বাগগুলি স্থির করে তার উপর নির্ভর করে। এটি অনলাইন চেষ্টা করুন!

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

— Sherlock9
সূত্র

1

সি ++ 14, 241 বাইট

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

আউটপুট হেল্পার স্ট্রাক্ট 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};
}

ব্যবহার:

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

— কার্ল ন্যাপ
সূত্র

1

ক্লোজার, 177 156 143 বাইট

আপডেট: কলব্যাকের পরিবর্তে আমি [a b c d 1]একটি ফাংশন হিসাবে ব্যবহার করছি এবং আর্গুমেন্টটি এই ভেক্টরের সূচকগুলির একটি তালিকা। 1গণনা করার সময় একটি সেন্ডিনেল মান হিসাবে ব্যবহৃত হয় A।

আপডেট 2: precalculating না Aএ letব্যবহার (rest(cycle %))ইনপুট ভেক্টর এক পুষিয়ে জন্য।

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

মূল সংস্করণ:

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

কম গল্ফড পর্যায়ে:

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

একটি সহায়ক ফাংশন তৈরি করে Fযা কোনও কলব্যাকের সাথে সংশ্লেষকে কার্যকর করে l। Aকলব্যাকের জন্য নিয়মিত রিটার্ন আসে 1যেখানে এক্স এবং ওয়াই কোঅর্ডিনেটের নিজস্ব ফাংশন রয়েছে। (conj(subvec v 1)(v 0))প্রথম উপাদান ড্রপ এবং শেষ appends, এটা এই ভাবে ট্র্যাক রাখতে সহজ হয় x_iএবং x_(i+1)। সম্ভবত এখনও কিছু পুনরাবৃত্তি মুছে ফেলা উচিত, বিশেষত শেষের দিকে (map F[...।

— NikoNyrh
সূত্র

একটি বহুভুজের সেন্ট্রয়েড সন্ধান করুন

উদাহরণ

জেলি , 25 24 22 21 18 বাইট

ব্যাখ্যা

গণিত, 23 বাইট

ব্যাখ্যা

জে, 29 বাইট

ব্যবহার

ব্যাখ্যা

ম্যাক্সিমা, 124 118 116 112 106 বাইট

র‌্যাকেট 420 বাইট

আর, 129 127 বাইট

পাইথন, 156 127 বাইট

আর + এসপি (46 বাইট)

জাভাস্ক্রিপ্ট (ES6), 102

পাইথন 2, 153 বাইট

Ungolfed:

প্রকৃতপক্ষে, 45 40 39 বাইট

সি ++ 14, 241 বাইট

ক্লোজার, 177 156 143 বাইট