मैट्रिक्स-वेक्टर की गणना करें

14

कम से कम दो तत्वों के पूर्णांक सरणी को देखते हुए, सरणी के मैट्रिक्स-वेक्टर (नीचे परिभाषित) को आउटपुट करें ।

मैट्रिक्स-वेक्टर की गणना करने के लिए , पहले आकार का nएक मैट्रिक्स बनाने के लिए आकार- इनपुट सरणी के माध्यम से घुमाएं n x n, मुख्य विकर्ण के बाद सरणी के पहले तत्व के साथ। यह मैट्रिक्स भाग बनाता है। वेक्टर के लिए, इनपुट ऐरे को लंबवत रूप से फ्लिप करें। फिर सामान्य मैट्रिक्स गुणा करें। आउटपुट वेक्टर परिणाम है।

उदाहरण के लिए,

a = [1, 2, 3]

सबसे पहले, सरणी को दाईं ओर दो बार घुमाएं, प्राप्त करने के लिए [3, 1, 2]और [2, 3, 1], फिर उन्हें एक 3x3मैट्रिक्स बनाने के लिए स्टैक करें

[[1, 2, 3]
 [3, 1, 2]
 [2, 3, 1]]

अगला, वेक्टर बनाने के लिए लंबवत सरणी को फ्लिप करें

[[1, 2, 3]    [[1]
 [3, 1, 2]  x  [2]
 [2, 3, 1]]    [3]]

सामान्य मैट्रिक्स गुणन करें

[[1, 2, 3]    [[1]    [[1+4+9]    [[14]
 [3, 1, 2]  x  [2]  =  [3+2+6]  =  [11]
 [2, 3, 1]]    [3]]    [2+6+3]]    [11]]

और आउटपुट है [14, 11, 11]या [[14], [11], [11]](आपकी पसंद चाहे वह चपटा हो या नहीं)।

उदाहरण # 2

a = [2, 5, 8, 3]

[[2, 5, 8, 3]    [[2]    [[4+25+64+9]     [[102]
 [3, 2, 5, 8]  x  [5]  =  [6+10+40+24]  =  [80]
 [8, 3, 2, 5]     [8]     [16+15+16+15]    [62]
 [5, 8, 3, 2]]    [3]]    [10+40+24+6]]    [80]]

[102, 80, 62, 80]

नियम

  • इनपुट और आउटपुट को आपकी भाषा के मूल पूर्णांक प्रकार में फिट होने के लिए माना जा सकता है।
  • इनपुट और आउटपुट किसी भी सुविधाजनक प्रारूप में दिए जा सकते हैं ।
  • या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
  • यदि संभव हो, तो कृपया ऑनलाइन परीक्षण वातावरण का लिंक शामिल करें ताकि अन्य लोग आपके कोड को आज़मा सकें!
  • मानक खामियों को मना किया जाता है।
  • यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।
code-golf  math  array-manipulation  matrix 
— AdmBorkBork
स्रोत

जवाबों:

8

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

ṙJṚæ.

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

व्याख्या

पहले तो:

जहां हैं पंक्ति वैक्टर और एक है स्तंभ वेक्टर।vkx

यह दर्शाता है कि पंक्तियों और स्तंभों के बीच मैट्रिक्स गुणन सिर्फ डॉट उत्पाद है।

फिर, वास्तव में है घुमाया सही करने के लिए, और है घुमाया सही, आदि के लिएv1v0vkvk-1

एक अन्य कोण से, है घुमाया बाईं ओर, और है घुमाया बाईं, आदि के लिएv1vnvnv1

यह काम किस प्रकार करता है

ṙJṚæ.   input: z (a list of length n)
ṙJ      [rot(z,1), rot(z,2), ..., rot(z,n)] (to the left)
  Ṛ     [rot(z,n), ..., rot(z,2), rot(z,1)]
   æ.   [rot(z,n).z , ..., rot(z,2).z , rot(z,1).z] (dot product)
— लीक नन
स्रोत
3

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

LḶN⁸ṙæ×W€

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

एक फ़ंक्शन जो एक ऊर्ध्वाधर सरणी देता है। एक पूर्ण कार्यक्रम के रूप में ऐसा प्रतीत होता है जैसे यह एक क्षैतिज सरणी देता है। इसके LḶN⁸ṙ×⁸S€बजाय आप एक क्षैतिज सरणी वापस करने के लिए करेंगे ।

— आउटगोल्फ को एरिक करें
स्रोत
2

हास्केल , 49 बाइट्स

f v=sum.zipWith(*)v.fst<$>zip(iterate tail$v++v)v

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

एक इनपुट के लिए v=[1,2]

  • iterate tail$v++v सूची तैयार करता है [[1,2,1,2],[2,1,2],[1,2],[2],[],...]
  • fst<$>zip l vके रूप में ही है take(length v)lऔर पैदावार[[1,2,1,2],[2,1,2]]
  • sum.zipWith(*)v प्रत्येक तत्व पर मैप किया जाता है और वेक्टर-मैट्रिक्स रो उत्पाद प्राप्त करने के लिए।
— Laikoni
स्रोत
मेरे उत्तर की तुलना में बहुत चालाक! मुझे fst<$>zip l vबहुत पसंद है।
— जफर
2

आर , 66 62 बाइट्स

sapply(length(n<-scan()):1,function(i)c(n[-(1:i)],n[1:i])%*%n)

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

— लीक नन
स्रोत
का उपयोग कर Map(function(i)c(n[-(1:i)],n[1:i])%*%n,length(n<-scan()):1)3 बाइट्स कम है; यह सिर्फ मैट्रिसेस की सूची देता है।
— Giuseppe
और एक लूप के लिए for(i in seq(n<-scan()))F=c(c(n[-(1:i)],n[1:i])%*%n,F);F[1:i]एक अजीब आउटपुट प्रारूप वापस किए बिना 61 बाइट्स है।
— Giuseppe
2

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

Most@FoldList[RotateRight,#,1^#].#&

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

-9 एक पेड़ से @ बाइट करें

— J42161217
स्रोत
2
यह अपने आप को फिर से बनाने की तुलना में मैथमैटिक के अपने मैट्रिक्स गुणन का उपयोग करने के लिए कम है Most@FoldList[RotateRight,#,1^#].#&:। (लेकिन के Foldबजाय का उपयोग कर अच्छी चाल Nest!)
— नहीं एक पेड़
1

जे , 14 बाइट्स

+/ .*~#\.1&|.]

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

व्याख्या

+/ .*~#\.1&|.]  Input: array M
      #\.       Length of each suffix, forms the range [len(M), ..., 2, 1]
             ]  Identity, get M
         1&|.   For each 'x' in the suffix lengths, rotate left M  by 'x'
+/ .*~          Dot product with M
— मील की दूरी पर
स्रोत
यह काफी अच्छा है। एक सवाल। जब आप एक भिक्षु बनाने के लिए 1&|.संबंध नहीं बनाते हैं? लेकिन फिर आप उस मोनाड को बाएँ और दाएँ दोनों तरह के आर्गन के साथ इस्तेमाल करते हैं, लेफ्ट के साथ यह निर्धारित करते हैं कि यह कितनी बार लागू होता है। यहाँ क्या चल रहा है? 1|.
— जोनाह
@ जोनाह इसके लिए एक विशेष रूप है &। जब उपयोग किया जाता है u n&f v, तो यह प्रदर्शन कर रहा है (n&f)^:u v। बॉन्ड के निचले भाग को देखें इसके बारे में अधिक पार्स देखने के लिए।
— मील
आह, टीआईएल। क्या वह चीज है जिसका आप अक्सर उपयोग करते हैं?
— योना
@ जोनाह कई मामलों में गोल्फ के लिए उपयोगी है। इस मामले में, यह रैंक का उपयोग करके बाइट्स के बराबर संख्या में किया जा सकता था #\.|."{], लेकिन मैंने सबसे छोटा पोस्ट किया जो मैं विकल्पों की कोशिश करने से पहले पहले आया था।
— मील
1

एपीएल, 17 बाइट्स

(↑¯1⌽(⍳≢)⌽¨⊂)+.×⍪

स्पष्टीकरण:

(↑¯1⌽(⍳≢)⌽¨⊂)+.×⍪

 ↑                      matrix format of
  ¯1⌽                   right rotate by 1 of
     (⍳≢)               the 1..[length N]
         ⌽¨             rotations of
           ⊂            the enclosed input
             +.×        inner product with
                ⍪       1-column matrix of input
— मारीनस
स्रोत
1

भूसी , 11 बाइट्स

mΣ§‡*´ṀKoṫ¢

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

व्याख्या

mΣ§‡*´ṀKoṫ¢  Implicit input, e.g. [1,2,3]
          ¢  Cycle: [1,2,3,1,2,3,...
        oṫ   Tails: [[1,2,3,1,2,3...],[2,3,1,2,3...],[3,1,2,3...]...
     ´ṀK     Replace each element of input with input: [[1,2,3],[1,2,3],[1,2,3]]
   ‡*        Vectorized multiplication (truncated with respect to shortest list)
  §          applied to the last two results: [[1,4,9],[2,6,3],[3,2,6]]
mΣ           Sum of each row: [14,11,11]
— Zgarb
स्रोत
1

सप्तक - 67 48 बाइट्स

इस कोड को 19 बाइट्स से कम करने के लिए लुइस मेंडो का धन्यवाद!

नोट: यह कोड केवल ऑक्टेव में चल सकता है। MATLAB उन कार्यों के अंदर अभिव्यक्तियों का समर्थन नहीं करता है जो एक साथ अभिव्यक्ति का मूल्यांकन करते समय चर बना सकते हैं।

n=numel(a=input(''));a(mod((x=0:n-1)-x',n)+1)*a'

MATLAB में मूल कोड यहां पाया जा सकता है, लेकिन MATLAB के किसी भी संस्करण में चलाया जा सकता है। यह कोड 67 बाइट्स है:

a=input('');n=numel(a)-1;a(mod(bsxfun(@minus,0:n,(0:n)'),n+1)+1)*a'

व्याख्या

  1. a=input('');- मानक इनपुट के माध्यम से उपयोगकर्ता से एक (पंक्ति) वेक्टर प्राप्त करता है। आपको सप्तक रूप में वेक्टर को दर्ज करना होगा (अर्थात[1,2,3] ) ।
  2. n=numel(...); - इनपुट वेक्टर में तत्वों की कुल संख्या प्राप्त करता है।
  3. x=0:n-1- एक पंक्ति वेक्टर बनाता है जो 0ऊपर से बढ़ता हैn-1 जो 1 के चरणों में ।
  4. (x=0:n-1)-x'- निष्पादित करता तो प्रसारण है कि हम एक है n x nमैट्रिक्स ताकि प्रत्येक पंक्ति i0 से तत्वों अप करने के लिए कर रहे हैं n-1पंक्ति में प्रत्येक तत्व के साथ iद्वारा घटाया i।
  5. mod(..., n)+1- यह सुनिश्चित करता है कि कोई भी मान जो कि नकारात्मक आवरण के चारों ओर हो nताकि प्रत्येक पंक्ति iमें वेक्टर हो, जिसमें 0 से लेकर n-1 गोलाकार रूप से iतत्वों द्वारा बाईं ओर स्थानांतरित किया गया हो । हम 1 जोड़ते हैं क्योंकि MATLAB / ऑक्टेव 1 के साथ वैक्टर या मैट्रिसेस को अनुक्रमित करना शुरू करता है।
  6. a(...)- एक n x nमैट्रिक्स बनाता है जहां (4) का उपयोग करते हुए, हम इनपुट वेक्टर के सही सूचकांकों तक पहुंचते हैं (4) प्रत्येक मूल्य से (4) इस प्रकार मैट्रिक्स को प्राप्त करने की आवश्यकता होती है।
  7. (...)*a'- गुणा aकरने से पहले एक कॉलम वेक्टर बनने के लिए ट्रांसपोज़िंग / फ़्लिपिंग द्वारा मैट्रिक्स वेक्टर गुणन करता है।

उदाहरण रन

>> n=numel(a=input(''));a(mod((x=0:n-1)-x',n)+1)*a'
[1,2,3]

ans =

         14.00
         11.00
         11.00

>> n=numel(a=input(''));a(mod((x=0:n-1)-x',n)+1)*a'
[2,5,8,3]

ans =

        102.00
         80.00
         62.00
         80.00

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

— रायरेंग - मोनिका को बहाल करें
स्रोत
आप इसके बजाय निहित विस्तार का उपयोग कर सकते हैं bsxfun। nबिना परिभाषित -1कुछ बाइट्स भी बचाता है। और अगर आप ओक्टेव तक सीमित रखते हैं तो आप फ्लाई पर वेरिएबल्स को असाइन कर सकते हैं aऔर कुछ0:n और बचा सकते हैं । इसके अलावा, यहाँ अधिक बार आओ !! :
— लुइस मेंडो
@LuisMendo आह हाँ। मैं भूल गया कि ऑक्टेव का निहित विस्तार पहले से ही समर्थित है। साथ ही inputफंक्शन के अंदर वेरिएबल को बचाना एक बेहतरीन ट्रिक है। मुझे नहीं लगा कि यह समर्थन कर सकता है। मैंने इसे केवल C या C ++ में अपने अनुभव से देखा है। धन्यवाद!
— रायरेंग - मोनिका जूल
1
@LuisMendo मैं आपके सुझाए गए परिवर्तनों को जल्द ही एक संपादन के रूप में रखूँगा। मैं व्यस्त हो गया हूं, लेकिन मैंने इसे प्राथमिकता नहीं दी है क्योंकि यह प्रविष्टि निश्चित रूप से बाइट की गिनती में कभी नहीं जीतेगी।
— रायरेंग - मोनिका
@LuisMendo बदल गया। बहुत बहुत धन्यवाद :) कोड समझने के लिए समझ गया क्योंकि मैं ऊपर अपना स्पष्टीकरण बदल रहा था।
— रायरेंग - मोनिका जूल 30'17
खुशी है कि मैं मदद कर सकता है :-)
— लुइस मेंडो
0

जावास्क्रिप्ट 79 बाइट्स

एक इनपुट सरणी में ले जाता है और मैट्रिक्स वेक्टर की एक सरणी आउटपुट करता है

a=>(b=[...a],a.map(x=>([...b].reduce((m,n,i)=>m+=n*a[i],0,b.push(b.shift())))))

व्याख्या

a=>(
    b=[...a],                    // copy the input into b
    a.map(x=>(                   // transform a into a new array
        [...b].reduce(           // copy b into a new array and reduce
            (m,n,i)=>m+=n*a[i],  // memo += the element in the array * the ith
                                 // element in a
            0,                   // start memo at 0
            b.push(b.shift())    // shift the first element in b to the end
                                 // not used by reduce, but performing this op
                                 // here saves a few bytes
        )
    ))
)
— asgallant
स्रोत
0

क्लोजर, 80 बाइट्स

#(map(fn[_ c](apply +(map * c %)))%(iterate(fn[c](into[(last c)](butlast c)))%))

iterateएक अनंत अनुक्रम पैदा करता है, लेकिन (take (count %) (iterate ...))इसे रोकने के लिए उपयोग करने के बजाय मैं %एक अतिरिक्त तर्क के रूप में उपयोग करता हूं map।

— NikoNyrh
स्रोत
0

पर्ल 5 , 65 + 1 (-ए) = 66 बाइट्स

@o=@F;for(@o){$r=0;$r+=$_*$F[$i++%@F]for@o;say$r;unshift@F,pop@F}

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

इनपुट वेक्टर को अंतरिक्ष से अलग संख्याओं के रूप में लेता है। आउटपुट सदिश को परिणाम वेक्टर का प्रतिनिधित्व करने वाली संख्याओं को अलग करता है।

— Xcali
स्रोत
0

आम लिस्प, 78 बाइट्स

(lambda(x)(loop as i on(append x x)as y in x collect(reduce'+(mapcar'* i x))))

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

सरणी (इस मामले में एक लिस्प सूची) को दोगुना करें और सब्लिस्ट्स के साथ पुनरावृति करें i( पुनरावृत्ति को रोकने के लिए, उपयोग xके माध्यम से y)। फिर प्रत्येक तत्व के xसाथ प्रत्येक तत्व को गुणा करने के परिणाम के अगले तत्व की गणना करें i(जब छोटी सूची समाप्त हो जाती है तो फिर से रोकना)।

— रेंज़ो
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.