स्तंभों से ब्लॉक-विकर्ण मैट्रिक्स

Question

स्टैक ओवरफ्लो में इस सवाल से प्रेरित होकर ।

एक मैट्रिक्स को देखते हुए A, एक मैट्रिक्स बनाने Bऐसी है कि के कॉलम Aएक ब्लॉक विकर्ण फैशन में व्यवस्थित कर रहे हैं। उदाहरण के लिए, दिया गया

1 2 3
4 5 6

आउटपुट होगा

1 0 0
4 0 0
0 2 0
0 5 0
0 0 3
0 0 6

नियम

इनपुट और आउटपुट 2 डी सरणियों, नेस्टेड सरणियों या पंक्तियों और स्तंभों के लिए अलग-अलग विभाजकों के साथ हो सकते हैं।

इनपुट (मैट्रिक्स A) में नंबर धनात्मक पूर्णांक होंगे।

जब तक आउटपुट में शून्य को कुछ उचित तरीके से प्रदर्शित किया जाता है, तब तक एकरूप प्रारूप की अनुमति दी जाती है। उदाहरण के लिए, प्रत्येक संख्या को संलग्न करने के लिए उद्धरण चिह्नों का उपयोग करके उपरोक्त परिणाम प्रदर्शित किया जा सकता है:

'1' '' ''
'1111' '' ''
'' '11' ''
'' '11111' ''
'' '' '111'
'' '' '111111'

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

इनपुट आउटपुट:

1 2 3
4 5 6

1 0 0
4 0 0
0 2 0
0 5 0
0 0 3
0 0 6


10 20

10  0
 0 20    


10
20

10
20


  1   2   3
 10  20  30
100 200 300

  1   0   0
 10   0   0
100   0   0
  0   2   0
  0  20   0
  0 200   0
  0   0   3
  0   0  30
  0   0 300

 2  4
 6  8
10 12

 2  0
 6  0
10  0
 0  4
 0  8
 0 12

Comments

क्या A के सभी नंबर अलग होंगे?

— 1:25 बजे

@ N @ नहीं, वे समान हो सकते हैं

— लुइस

Answer 1

MATL , 6 बाइट्स

"@N$Yd

भाषा / संकलक के वर्तमान संस्करण (13.0.0) में काम करता है ।

इनपुट का निम्न रूप है, पंक्ति विभाजक के रूप में अर्धविराम और प्रत्येक पंक्ति के भीतर स्तंभ विभाजक के रूप में अल्पविराम या स्थान:

[1, 2, 3; 4, 5, 6]

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

व्याख्या

"         % implicitly input 2D array and loop over its columns
  @       %   push column
  N$Yd    %   build block-diagonal matrix from all stack contents. Stack contents are
          %   a single column in the first iteration, or a partially built 2D array
          %   and a new column in all other iterations
          % end loop
          % implicit display

काम का उदाहरण

इनपुट पर विचार करें [1 2 3; 4 5 6]। लूप के लिए शुरुआत "इनपुट के प्रत्येक कॉलम के साथ होती है। प्रत्येक पुनरावृत्ति के भीतर, @स्टैक पर वर्तमान कॉलम को धक्का देता है। तो पहले पुनरावृत्ति में यह धक्का देता है [1; 4]। N$निर्दिष्ट करता है कि सभी स्टैक सामग्री का उपयोग निम्न फ़ंक्शन के इनपुट के रूप में किया जाएगा Yd।

यह फ़ंक्शन (MATLAB के अनुरूप blkdiag) एक ब्लॉक विकर्ण मैट्रिक्स (2 डी) का उत्पादन करने के लिए इसके इनपुट "तिरछे समवर्ती"। इसलिए पहले पुनरावृत्ति में Ydयह एक इनपुट लेता है और उस इनपुट के बराबर आउटपुट उत्पन्न करता है [1; 4], जिसे स्टैक पर छोड़ दिया जाता है।

दूसरे पुनरावृत्ति में इनपुट के दूसरे स्तंभ [2; 5]को धक्का दिया जाता है। अब Ydदो 2 × 1 इनपुट लेता है, अर्थात् [1; 4]और [2; 5]4 × 2 सरणी का उत्पादन करता है [1 0; 4 0; 0 2; 0 5]।

तीसरे पुनरावृत्ति Ydमें बाद के 4 × 2 सरणी और इनपुट के तीसरे कॉलम को लेता है [3; 6], और अंतिम परिणाम उत्पन्न करता है [1 0 0; 4 0 0; 0 2 0; 0 5 0; 0 0 3; 0 0 6]।

Answer 2

ईएस 6, 65 बाइट्स

a=>[].concat(...a[0].map((_,i)=>a.map(b=>b.map((c,j)=>i-j?0:c))))

इनपुट के रूप में लेता है और आउटपुट के रूप में रिटर्न देता है।

Comments

@WashingtonGuedes आंतरिक मानचित्र मूल 2 डी सरणी की एक प्रति देता है, लेकिन एक कॉलम शून्य हो जाता है। इन प्रतियों को तब बाहरी 3 डी ऐरे के तत्वों के बजाय समेटना होगा।

— नील

Answer 3

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

Infixआईएनजी के लिए @Seeq को क्रेडिट Flatten।

Transpose[DiagonalMatrix/@#]~Flatten~1&

इनपुट {}ब्रैकेट्स द्वारा सीमांकित पंक्ति वैक्टर की एक सूची है । इसलिए प्रारंभिक उदाहरण द्वारा दर्शाया गया है

{{1,2,3},{4,5,6}}

एक सरणी उत्पन्न करें DiagonalMatrixजहां हर एक में इनपुट की पंक्तियों (3-डी सरणी) से विकर्ण तत्व होते हैं। Transposeइसलिए Flattenऑपरेशन वांछित मैट्रिक्स (अब 2-डी सरणी) देने के लिए सही ब्रैकेट जोड़े निकालता है।

Comments

DiagonalMatrix/@#काम नहीं करेगा ? और, विस्तार से,Transpose[DiagonalMatrix/@#]~Flatten~1&

— बजे

अच्छी पकड़ है, मेरा इरादा इसे ठीक करने के बाद है। Infix Flattenहालांकि उपयोग करने के लिए नहीं सोचा था । +1।

— आईपीओलर

Answer 4

अजगर, १,

s.em.>+dm0thQkbCQ

इसे ऑनलाइन आज़माएं या टेस्ट सूट चलाएं ।

आप j2D सरणी की कल्पना करने में सहायता के लिए एक अग्रणी जोड़ सकते हैं ।

Answer 5

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

ZLR’×L0ẋ;"Zz0

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

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

ZLR’×L0ẋ;"Zz0  Main link. Input: M (matrix)

Z              Transpose M.
 L             Get the length of the result. This yields the number of M's columns.
  R            Range; for m columns, yield [1, ..., m].
   ’           Decrement to yield [0, ..., m-1].
    ×L         Multiply each by the length (number of rows) of M.
               This yields [0, n, ..., n(m-1)], where n is the number of rows.
      0ẋ       Push a list of lists of zeroes.
               First element is [], last is n(m-1) zeroes.
        ;"Z    Prepend the kth vector of zeroes to the kth column of M.
           z0  Zip, filling the non-rectangular 2D array with zeroes.

Answer 6

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

Join@@@ReplacePart[Table[0,#2/#3]~Table~#3~Table~#3,Table[{n,n}->#[[n]],{n,#3}]]&[Length@#,Length@Flatten@#,#]&

Comments

इनपुट सिंटैक्स क्या है? मानक एमएमए मैट्रिक्स नोटेशन का उपयोग करते समय यह फेंकता है Tableऔर Partमिश्रित आयामों की एक सरणी में परिणाम होता है।

— आईपीओलर

Answer 7

रूबी, 81 78 76 62 बाइट्स

->a{i=-1;a[0].flat_map{i+=1;a.map{|b|x=b.map{0};x[i]=b[i];x}}}

आहें सूचकांक के मैन्युअल ट्रैक रखने से भी कम है with_index।

->a{
i=-1;            # index of the flat_map
a[0]             # duplicate all rows as many times as necessary
.flat_map{       # we're wrapping each "group" of original rows with yet another
                 #  array, so we need to flat_map to get rid of those
i+=1;            # increment the index of the current subarray
a.map{|b|        # for each sub-subarray (these are the rows)...
x=b.map{0};      # zero everything out
x[i]=b[i];       # replace the desired elements
x}}}             # finally, return the modified array

Answer 8

आर, 41 बाइट्स

pryr::f(Matrix::.bdiag(plyr::alply(a,2)))

मान लेते हैं pryr, Matrixऔर plyrपैकेज स्थापित होते हैं।

यह एक फ़ंक्शन बनाता है जो 2D सरणी (ए) लेता है और एक "स्पार्समैट्रिक्स" लौटाता है जहां (जहां 0 का प्रतिनिधित्व किया जाता है .)

(a=matrix(1:6,ncol=3))
#      [,1] [,2] [,3]
# [1,]    1    3    5
# [2,]    2    4    6
pryr::f(Matrix::.bdiag(plyr::alply(a,2)))(a)
# 6 x 3 sparse Matrix of class "dgTMatrix"
#          
# [1,] 1 . .
# [2,] 2 . .
# [3,] . 3 .
# [4,] . 4 .
# [5,] . . 5
# [6,] . . 6

स्पष्टीकरण:

plyr::alply(a,2)प्रत्येक कॉलम aऔर रिटर्न इन परिणामों को एक सूची में जोड़ता है

Matrix::.bdiag(lst) मैट्रिसेस की सूची से ब्लॉक विकर्ण मैट्रिक्स बनाता है

pryr::f एक समारोह बनाने के लिए एक आशुलिपिक तरीका है।

R59 बाइट्स में एक पूरी तरह से आधार समाधान (@ पाइकोट मैटलैब जवाब के तर्क का उपयोग करके):

function(a){l=dim(a);diag(l[2])%x%matrix(1,nrow=l[1])*c(a)}

Answer 9

MATLAB, 69 68 बाइट्स

   function h=d(a)
   [r,c]=size(a);h=repmat(a,c,1).*kron(eye(c),~~(1:r)')

एक बाइट का मुंडन किया गया: लुइस मेंडो को धन्यवाद :)

Answer 10

APL (Dyalog Classic) , 11 बाइट्स

⍉⍪⍉↑(0,⊢)\⎕

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