20

यहां सोमवार सुबह की चुनौती है ...

कम से कम बाइट्स में एक फ़ंक्शन या प्रोग्राम लिखें:

इनपुट के रूप में [x,y]निर्देशांक की एक सूची लेता है
[x,y]निर्देशांक के संबंधित जनसमूह की सूची को इनपुट के रूप में लेता है
के रूप में द्रव्यमान की गणना केंद्र आउटपुट करता है [xBar,yBar]।

ध्यान दें:

इनपुट को किसी भी रूप में लिया जा सकता है, जब तक कि एक सरणी का उपयोग किया जाता है।

द्रव्यमान के केंद्र की गणना निम्न सूत्र द्वारा की जा सकती है:

सादा अंग्रेजी में...

खोजने के लिए xBar, प्रत्येक द्रव्यमान को उसके संबंधित x द्वारा गुणा करें, परिणामी सूची को योग करें, और इसे सभी द्रव्यमानों के योग से विभाजित करें।
खोजने के लिए yBar, प्रत्येक द्रव्यमान को उसके संबंधित y द्वारा गुणा करें, परिणामी सूची को योग करें, और इसे सभी द्रव्यमानों के योग से विभाजित करें।

तुच्छ अजगर 2.7 उदाहरण:

def center(coord, mass):
    sumMass = float(reduce(lambda a, b: a+b, mass))
    momentX = reduce(lambda m, x: m+x, (a*b for a, b in zip(mass, zip(*coord)[0])))
    momentY = reduce(lambda m, y: m+y, (a*b for a, b in zip(mass, zip(*coord)[1])))
    xBar = momentX / sumMass
    yBar = momentY / sumMass
    return [xBar, yBar]

परीक्षण के मामलों:

> center([[0, 2], [3, 4], [0, 1], [1, 1]], [2, 6, 2, 10])
[1.4, 2.0]

> center([[3, 1], [0, 0], [1, 4]], [2, 4, 1])
[1.0, 0.8571428571428571]

यह कोड-गोल्फ है, इसलिए सबसे कम संख्या में बाइट्स जीतती हैं!

code-golf arithmetic array-manipulation

— मि। पब्लिक
स्रोत

चूंकि यह सिर्फ "वैक्टर के एक भारित औसत की गणना करता है" अगर हम इसे पहले नहीं किया है तो मुझे काफी आश्चर्य होगा। (फिलहाल, मुझे कुछ भी नहीं मिल रहा है।)

— मार्टिन एंडर

@ MartinBüttner मैंने भी देखा, और कोई भी नहीं मिला। यदि यह एक द्वैध है, तो इसे बंद करने के लिए स्वतंत्र महसूस करें।

— मिस्टर पब्लिक

क्या अन्य क्रम में इनपुट लिया जा सकता है? या रूप में [x,y,m],[x,y,m]...:?

— FryAmTheEggman

@FryAmTheEggman मान्य इनपुट के लिए प्रश्न संपादित किया गया।

— मिस्टर पब्लिक

@Mrublic: क्या के बारे में [(x1,y1,m1), (x2,y2,m2)], जैसे tuples की एक सूची? या इससे कोई फर्क नहीं पड़ता कि क्या तर्क तुक, सूची या सरणियाँ हैं? तीन सूचियों / सरणियों के बारे में क्या?

— ज़ेटा

21

MATL , 6 5 बाइट्स

ys/Y*

इनपुट प्रारूप जनता के साथ एक पंक्ति वेक्टर है, फिर निर्देशांक (जिसमें रिक्त स्थान या अल्पविराम वैकल्पिक हैं) के साथ एक दो-स्तंभ मैट्रिक्स।

पहला उदाहरण:
```
[2, 6, 2, 10]
[0,2; 3,4; 0,1; 1,1]
```
दूसरा उदाहरण:
```
[2, 4, 1]
[3,1; 0,0; 1,4]
```

इसे ऑनलाइन आज़माएं!

व्याख्या

आइए mवेक्टर के द्रव्यमान (पहले इनपुट) और cनिर्देशांक के मैट्रिक्स (दूसरे इनपुट) को निरूपित करें ।

y     % implicitly take two inputs. Duplicate the first.
      % (Stack contains, bottom to top: m, c, m)
s     % sum of m.
      % (Stack: m, c, sum-of-m)
/     % divide.
      % (Stack: m, c-divided-by-sum-of-m)
Y*    % matrix multiplication.
      % (Stack: final result)
      % implicitly display

— लुइस मेंडो
स्रोत

yबहुत उपयोगी है !! +1

— डेविड

@ डेविड हाँ! निहित इनपुट के साथ संयुक्त, यह इस मामले में बहुत सी चीजें करता है :-)

— लुइस मेंडो

7

गणितज्ञ, 10 बाइट्स

#.#2/Tr@#&

उदाहरण:

In[1]:= #.#2/Tr@#&[{2,6,2,10},{{0,2},{3,4},{0,1},{1,1}}]

Out[1]= {7/5, 2}

— alephalpha
स्रोत

1

मैंने कभी इस्तेमाल नहीं किया Dot। लेकिन मैं ऊपर आपके उपयोग को देखने के बाद करूंगा!

— डेविड मार्क

7

मठकाद, 19 "बाइट्स"

डेटा इनपुट के लिए Mathcad की तालिकाओं का उपयोग करता है
अक्ष समन्वय और द्रव्यमान को गुणा करने के लिए मथकड के अंतर्निर्मित वेक्टर स्केलर उत्पाद का उपयोग करता है
कुल द्रव्यमान के लिए मथकड के अंतर्निर्मित समन ऑपरेटर का उपयोग करता है

जैसा कि Mathcad एक 2D "व्हाइटबोर्ड" और विशेष ऑपरेटर (जैसे, समन ऑपरेटर, इंटीग्रल ऑपरेटर) का उपयोग करता है, और XML प्रारूप में बचाता है, एक वास्तविक वर्कशीट में कई सौ (या अधिक) वर्ण हो सकते हैं। कोड गोल्फ के प्रयोजनों के लिए, मैंने उन पात्रों या ऑपरेटरों की संख्या होने के लिए एक मैथेकड "बाइट काउंट" लिया है जिसे उपयोगकर्ता को वर्कशीट बनाने के लिए दर्ज करना होगा।

चुनौती का पहला (प्रोग्राम) संस्करण इस परिभाषा का उपयोग करते हुए 19 "बाइट्स" लेता है और फ़ंक्शन संस्करण 41 "बाइट्स" लेता है।

— स्टुअर्ट ब्रुफ़
स्रोत

3

पहली बार मैंने कभी यहाँ एक Matcad समाधान देखा है। बहुत अच्छा। +1।

— रायरेंग - मोनिका

शुक्रिया, रेयरेंग। यह शायद इसलिए है क्योंकि यह "कोर्स" पर कुछ "छेद" कर रही एक चुनौती का एक हिस्सा है, यह देखते हुए कि Mathcad में केवल मूल स्ट्रिंग फ़ंक्शन हैं और मानव-पठनीय, पाठ-केवल स्रोत कोड नहीं है।

— स्टुअर्ट ब्रुफ़

6

MATLAB / ऑक्टेव, 18 16 बाइट्स

2 बाइट निकालने के लिए उपयोगकर्ता बीकर और डॉन मूसली को धन्यवाद!

यह देखते हुए कि निर्देशांक एक N x 2मैट्रिक्स में हैं xजहां पहला कॉलम X निर्देशांक है और दूसरा स्तंभ Y निर्देशांक है, और जनता एक 1 x Nमैट्रिक्स y(या एक पंक्ति वेक्टर) में हैं:

@(x,y)y*x/sum(y)

इस कोड की व्याख्या काफी सीधे आगे है। यह एक अनाम फ़ंक्शन है जो दो इनपुट में लेता है xऔर y। हम मैट्रिक्स-वेक्टर गुणा का उपयोग करके एक रैखिक बीजगणित दृष्टिकोण में भारित योग (प्रत्येक समन्वय की अंश अभिव्यक्ति) करते हैं। सदिश लेकरyजनता को और xमैट्रिक्स-वेक्टर गुणा द्वारा निर्देशांक के मैट्रिक्स के साथ इसे गुणा करके , आप दोनों निर्देशांक के भारित योग की गणना व्यक्तिगत रूप से करेंगे, फिर हम इनमें से प्रत्येक निर्देशांक को जनता के योग द्वारा विभाजित करते हैं, इस प्रकार वांछित केंद्र का पता लगाते हैं। द्रव्यमान क्रमशः प्रत्येक समन्वय के लिए 1 x 2 पंक्ति वेक्टर के रूप में वापस आया।

उदाहरण चलता है

>> A=@(x,y)y*x/sum(y)

A = 

    @(x,y)y*x/sum(y)

>> x = [0 2; 3 4; 0 1; 1 1];
>> y = [2 6 2 10];
>> A(x,y)

ans =

    1.4000    2.0000

>> x = [3 1; 0 0; 1 4];
>> y = [2 4 1];
>> A(x,y)

ans =

    1.0000    0.8571

इसे ऑनलाइन आज़माएं!

https://ideone.com/BzbQ3e

— रायरेंग - मोनिका को बहाल करें
स्रोत

1

आप हटा सकते हैं ;, और 'इनपुट प्रारूप ( xपंक्ति वेक्टर के रूप में) को ठीक से चुनकर

— लुइस मेंडू

@DonMuesli धन्यवाद :) बाईट काउंट को 2 से

— घटाया -

6

जेली, 6 बाइट्स

S÷@×"S

या

÷S$×"S

इनपुट दो कमांड-लाइन तर्कों के माध्यम से है, जनता पहले, निर्देशांक दूसरा।

इसे ऑनलाइन आज़माएं!

व्याख्या

S       Sum the masses.
   x"   Multiply each vector by the corresponding mass.
 ÷@     Divide the results by the sum of masses.
     S  Sum the vectors.

या

÷S$     Divide the masses by their sum.
   ×"   Multiply each vector by the corresponding normalised mass.
     S  Sum the vectors.

— मार्टिन एंडर
स्रोत

6

जूलिया, 25 17 बाइट्स

f(c,m)=m*c/sum(m)

स्पष्ट दृष्टिकोण याद किया: / कॉल की तरह f([3 1;0 0;1 4], [2 4 1])।

— Sp3000
स्रोत

5

CJam, 14 बाइट्स

{_:+df/.f*:.+}

एक अनाम फ़ंक्शन समन्वित जोड़े की सूची और ढेर पर जनता की सूची की उम्मीद करता है (उस क्रम में) और उनके स्थान पर द्रव्यमान का केंद्र छोड़ देता है।

इसका परीक्षण यहां करें।

व्याख्या

_    e# Duplicate list of masses.
:+d  e# Get sum, convert to double.
f/   e# Divide each mass by the sum, normalising the list of masses.
.f*  e# Multiply each component of each vector by the corresponding weight.
:.+  e# Element-wise sum of all weighted vectors.

— मार्टिन एंडर
स्रोत

5

पर्ल 6, 36 33 30 बाइट्स

{[Z+](@^a Z»*»@^b) X/sum @b}

— हॉटकी
स्रोत

4

गंभीरता से, 16 बाइट्स

╩2└Σ;╛2└*/@╜2└*/

के रूप में इनपुट लेता है [x-coords]\n[y-coords]\n[masses], और आउटपुट के रूप मेंxbar\nybar

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

╩2└Σ;╛2└*/@╜2└*/
╩                 push each line of input into its own numbered register
 2└Σ;             push 2 copies of the sum of the masses
     ╛2└*/        push masses and y-coords, dot product, divide by sum of masses
          @       swap
           ╜2└*/  push masses and x-coords, dot product, divide by sum of masses

— मै जाऊं
स्रोत

3

हास्केल, 55 50 बाइट्स

z=zipWith
f a=map(/sum a).foldr1(z(+)).z(map.(*))a

यह एक बाइनरी फ़ंक्शन को परिभाषित करता है f, जिसका उपयोग निम्नानुसार किया जाता है:

> f [1,2] [[1,2],[3,4]]
[2.3333333333333335,3.333333333333333]

देखें कि यह दोनों परीक्षण मामलों को पास करता है।

व्याख्या

हास्केल बहुआयामी सूचियों के प्रसंस्करण के लिए अच्छी तरह से अनुकूल नहीं है, इसलिए मैं यहां कुछ हुप्स के माध्यम से कूद रहा हूं। पहली पंक्ति के लिए एक छोटा उर्फ परिभाषित करता है zipWith, जिसकी हमें दो बार आवश्यकता होती है। मूल रूप से, fएक ऐसा कार्य है जो वज़न की सूची लेता है aऔर उत्पादन करता है f a, एक ऐसा कार्य जो पदों की सूची लेता है और बड़े पैमाने पर केंद्र का निर्माण करता है। f aतीन कार्यों की एक रचना है:

z(map.(*))a      -- First sub-function:
z         a      --   Zip the list of positions with the mass list a
  map.(*)        --   using the function map.(*), which takes a mass m
                 --   and maps (*m) over the corresponding position vector
foldr1(z(+))     -- Second sub-function:
foldr1           --   Fold (reduce) the list of mass-times-position vectors
       z(+)      --   using element-wise addition
map(/sum a)      -- Third sub-function:
map              --   Map over both coordinates:
   (/sum a)      --     Divide by the sum of all masses

— Zgarb
स्रोत

3

जावास्क्रिप्ट (ईएस 6), 60 बाइट्स

a=>a.map(([x,y,m])=>{s+=m;t+=x*m;u+=y*m},s=t=u=0)&&[t/s,u/s]

(X, y, मास) "triples" की एक सरणी स्वीकार करता है और "tuple" लौटाता है।

— नील
स्रोत

क्या कोष्ठक [x,y,m]आवश्यक हैं? iirc, वे आवश्यक नहीं हैं यदि तीर फ़ंक्शन के लिए केवल एक इनपुट तर्क है।

— पैट्रिक रॉबर्ट्स

@PatrickRoberts हां, वे सभी मामलों में आवश्यक हैं, सिवाय इसके कि एक तुच्छ एक मानक तर्क का एक।

— नील

3

आर, 32 25 बाइट्स

function(a,m)m%*%a/sum(m)

मैट्रिक्स बीजगणित पर स्विच द्वारा संपादित -7 बाइट्स (धन्यवाद @ Sp3000 जूलिया उत्तर)

एक सरणी (2 कॉलम, x, y के साथ मैट्रिक्स) को निर्देशांक और mभार के वेक्टर के रूप में पास करें , आवश्यक निर्देशांक के साथ एक सरणी देता है

— mnel
स्रोत

2

PHP, 142 बाइट्स

function p($q,$d){return$q*$d;}function c($f){$s=array_sum;$m=array_map;$e=$f[0];return[$s($m(p,$e,$f[1]))/$s($e),$s($m(p,$e,$f[2]))/$s($e)];}

एक्स्प्लोडेड वीयू

function p($q, $d) {
  return $q * $d;
}

function c($f) {
  $s = array_sum;
  $m = array_map;
  $e = $f[0];
  return [ $s($m(p,$e,$f[1])) / $s($e),
           $s($m(p,$e,$f[2])) / $s($e) ];
}

आवश्यक इनपुट

Array[Array]: [ [ mass1, mass2, ... ],
                [ xpos1, xpos2, ... ],
                [ ypos1, ypos2, ... ] ]

वापसी

Array: [ xbar, ybar ]

p()समारोह एक बुनियादी नक्शा प्रत्येक गुणा है, [m]इसी के साथ मूल्य [x]या [y]मूल्य। c()समारोह में ले जाता है Array[Array], प्रस्तुत करता है array_sumऔर array_mapअंतरिक्ष के लिए काम करता है, तो गणना Σmx/ΣmऔरΣmy/Σm ।

अंतरिक्ष के लिए एक फ़ंक्शन में गणना को स्वयं चालू करना संभव हो सकता है, देखेंगे।

— ricdesi
स्रोत

2

मथकड, 8 "बाइट्स"

मुझे नहीं पता कि मैं अपने पिछले उत्तर में क्या सोच रहा था। यहां मैट्रिक्स गुणा का उचित उपयोग करने का एक छोटा तरीका है। चर p में डेटा होता है - यदि चर कुल की ओर गिनता है, तो एक और 2 "बाइट्स" जोड़ें (इनपुट तालिका का निर्माण = 1 बाइट, चर नाम = 1 बाइट)।

— स्टुअर्ट ब्रुफ़
स्रोत

1

पायथन 3, 63 बाइट्स

lambda a,b:[sum(x*y/sum(b)for x,y in zip(L,b))for L in zip(*a)]

सूचियों पर वेक्टर संचालन लंबा है: /

यह एक अनाम लंबो फ़ंक्शन है - इसे एक नाम दें और जैसे कॉल करें f([[0,2],[3,4],[0,1],[1,1]],[2,6,2,10])।

— Sp3000
स्रोत

1

पायथन 3, 95 90 88 बाइट्स

समाधान

lambda c,m:list(map(sum,zip(*[[i[0]*j/sum(m),i[1]*j/sum(m)]for i,j in zip(*([c,m]))])))

परिणाम

>>> f([[0,2],[3,4],[0,1],[1,1]],[2,6,2,10])
[1.3999999999999999, 2.0]
>>> f([[3,1],[0,0],[1,4]],[2,4,1])
[1.0, 0.8571428571428571]

@ बगर 2 बाइट्स बचाने के लिए धन्यवाद

मनोरंजन के लिए एक पुनरावर्ती समाधान (95 बाइट्स)

f=lambda c,m,x=0,y=0,s=0:f(c[1:],m[1:],x+c[0][0]*m[0],y+c[0][1]*m[0],s+m[0])if c else[x/s,y/s]

परिणाम

>>> f([[0,2],[3,4],[0,1],[1,1]],[2,6,2,10])
[1.4, 2.0]
>>> f([[3,1],[0,0],[1,4]],[2,4,1])
[1.0, 0.8571428571428571]

— एर्वान
स्रोत

2

मुझे लगता है कि *([c]+[m])इसे छोटा किया जा सकता है *[c,m]।

— ज़र्गब

0

Axiom, 158 बाइट्स

c(a:List List Float):List Float==(x:=y:=m:=0.;for i in 1..#a repeat(~index?(3,a.i)=>return[];x:=x+a.i.3*a.i.1;y:=y+a.i.3*a.i.2;m:=m+a.i.3);m=0.=>[];[x/m,y/m])

यह ungolf

-- Input List of Coordinate and masses as [[xi,yi,mi]]
-- Return center of mass for the list a as [x,y] Float coordinates
-- or [] if some error occur [for example masses are all 0]
cc(a:List List Float):List Float==
    x:=y:=m:=0.
    for i in 1..#a repeat
         ~index?(3,a.i)=>return []
         x:=x+a.i.3*a.i.1
         y:=y+a.i.3*a.i.2
         m:=m+a.i.3
    m=0.=>return []
    return[x/m,y/m]

परिणाम

(21) -> c([[0,2,2],[3,4,6],[0,1,2],[1,1,10]])
   (21)  [1.4,2.0]
                                                         Type: List Float
(22) -> c([[3,1,2],[0,0,4],[1,4,1]])
   (22)  [1.0,0.8571428571 4285714286]
                                                         Type: List Float

— RosLuP
स्रोत

0

k, 13 बाइट्स

{(+/x*y)%+/y}

इसे ऑनलाइन आज़माएं!

— zgrep
स्रोत

निर्देशांक और उनके द्रव्यमान की एक सूची से द्रव्यमान का केंद्र

MATL , 6 5 बाइट्स

व्याख्या

गणितज्ञ, 10 बाइट्स

मठकाद, 19 "बाइट्स"

MATLAB / ऑक्टेव, 18 16 बाइट्स

2 बाइट निकालने के लिए उपयोगकर्ता बीकर और डॉन मूसली को धन्यवाद!

उदाहरण चलता है

इसे ऑनलाइन आज़माएं!

जेली, 6 बाइट्स

व्याख्या

जूलिया, 25 17 बाइट्स

CJam, 14 बाइट्स

व्याख्या

पर्ल 6, 36 33 30 बाइट्स

गंभीरता से, 16 बाइट्स

हास्केल, 55 50 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 6), 60 बाइट्स

आर, 32 25 बाइट्स

PHP, 142 बाइट्स

मथकड, 8 "बाइट्स"

पायथन 3, 63 बाइट्स

पायथन 3, 95 90 88 बाइट्स

समाधान

परिणाम

Axiom, 158 बाइट्स

k, 13 बाइट्स