एक मैट्रिक्स हीरा

Question

एक मैट्रिक्स को देखते हुए, मैट्रिक्स का एक प्रतिनिधित्व आउटपुट करता है जहां शीर्ष बाएं तत्व शीर्ष पर है, विरोधी-विकर्ण केंद्रीय पंक्ति है और नीचे सही तत्व नीचे है।

उदाहरण के लिए, निम्नलिखित मैट्रिक्स पर विचार करें:

1 2 3
4 5 6
7 8 9

इस मैट्रिक्स का डायमंड संस्करण है:

  1
 4 2
7 5 3
 8 6
  9

इनपुट और आउटपुट

एक इनपुट मैट्रिक्स को सूचियों की सूची (या अपनी पसंद की भाषा में कुछ भी समान) के रूप में दिया जाएगा। आउटपुट सूचियों की एक सूची होगी।

मैट्रिसेस में केवल धनात्मक पूर्णांक होंगे।

इनपुट मैट्रिक्स आवश्यक रूप से वर्गाकार नहीं होगा।

इनपुट मैट्रिक्स कम से कम 1 × 1 होगा।

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

Input:  [[1]]
Output: [[1]]

Input:  [[1,2],[3,4]]
Output: [[1],[3,2],[4]]

Input:  [[1,2,3],[4,5,6]]
Output: [[1],[4,2],[5,3],[6]]

Input:  [[11,2,5],[3,99,3],[4,8,15],[16,23,42]]
Output: [[11],[3,2],[4,99,5],[16,8,3],[23,15],[42]]

स्कोरिंग

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

Comments

सम्बंधित

— घातक

संबंधित / सामान्यीकरण। (हालांकि इसे एक ठहाका नहीं माना जाएगा, क्योंकि किसी को भी रैग्ड एरे की अनुमति है और 45 डिग्री से अधिक के किसी भी रोटेशन की आवश्यकता है।)

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

सम्बंधित।

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

Answer 1

जे, 7 बाइट्स

<@|./.

यह एक अनाम क्रिया है जो एक मैट्रिक्स लेता है और एंटीडिओग्नल की एक सूची देता है:

   input =. i.3 4
   input
0 1  2  3
4 5  6  7
8 9 10 11

   <@|./. input
┌─┬───┬─────┬─────┬────┬──┐
│0│4 1│8 5 2│9 6 3│10 7│11│
└─┴───┴─────┴─────┴────┴──┘

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

व्याख्या

• /.प्रत्येक विरोधी विकर्ण के लिए एक फ़ंक्शन लागू करने के लिए J का अंतर्निहित है। दुर्भाग्य से, इन विरोधी विकर्णों को यहां हम क्या चाहते हैं, के विपरीत क्रम में दिया गया है।
• में <@|., हम पहले लागू करते हैं |.जो एंटी-विकर्ण को उलट देता है और फिर <इसे बॉक्स करने के लिए (जो जम्मू में एक रैग्ड सरणी को वापस करने का एकमात्र तरीका है, चूंकि सामान्य सरणियां हमेशा आयताकार होती हैं, इसलिए एंटीडिओगॉन को जीरो के साथ पैड किया जाएगा)।

Comments

वह पागल और सुंदर है। मैं किसी दिन इस भाषा को सीखने में समय लूंगा।

— मशीन

Answer 2

पायथन, 91 बाइट्स

e=enumerate
lambda M:[[r[n-i]for i,r in e(M)if-1<n-i<len(r)][::-1]for n,_ in e(M[1:]+M[0])]

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

---

पायथन + न्यूमपी, 69 बाइट्स

import numpy
lambda M:map(M[::-1].diagonal,range(1-len(M),len(M[0])))

इनपुट के रूप में एक 2D नंबरी सरणी की उम्मीद है और न्यूमपी सरणियों की एक सूची देता है। Ideone पर इसका परीक्षण करें ।

Answer 3

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

ṚŒDṙZL$

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

व्याख्या

Ṛ         Reverse the matrix vertically.
 ŒD       Get its diagonals. However these start from 
          the main diagonal, not the corners.
    ZL$   Get the width of the input matrix.
   ṙ      Rotate the list of diagonals left by that many 
          places to obtain the correct order.

Comments

जेली को नहीं जानते, लेकिन अगर यह यूनिकोड ऑपरेंड की आवश्यकता है तो 7 बाइट्स नहीं है।

— गाइडबोट

@ गिउडोबोट जेली एक कस्टम कोड पेज का उपयोग करता है जो प्रत्येक एकल को बाइट के रूप में समझने वाले 256 वर्णों को एन्कोड करता है।

— डेनिस

Answer 4

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

a=Length;Reverse@#~Diagonal~b~Table~{b,1-a@#,a@#&@@#-1}&

अनाम फ़ंक्शन, नेस्टेड सरणियाँ लेता है।

Comments

आप Length[#]जहाँ है उसके साथ एक को बचा सकते हैं \[Transpose]। और शायद अलियासिंग से एक और Length।

— Sp3000

या Length@#&@@#एएससीआईआई के लिए केवल उसी बाइट की गिनती में।

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

Answer 5

सीजेएम, 17 बाइट्स

{eeSf.*::+W%zSf-}

एक अनाम ब्लॉक (फ़ंक्शन) जो स्टैक पर मैट्रिक्स की अपेक्षा करता है और इसे अपने एंटीडिओग्नल के साथ बदल देता है।

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

यह (Sp3000 द्वारा पाया गया) एक ही बाइट काउंट के लिए काम करता है:

{_,,Sf*\.+W%zSf-}

व्याख्या

यह एक उदाहरण के साथ सबसे अच्छा समझाया गया है। इनपुट पर विचार करें:

[[0  1  2  3]
 [4  5  6  7]
 [8  9 10 11]]

ee    e# Enumerate matrix, turning each row [x ... z] into [i [x ... z]] where
      e# i is the vertical index from the top.

[[0 [0  1  2  3]]
 [1 [4  5  6  7]]
 [2 [8  9 10 11]]]

Sf.*  e# Replace each i with a string of i spaces.

[[""   [0  1  2  3]]
 [" "  [4  5  6  7]]
 ["  " [8  9 10 11]]]

::+   e# Prepend these strings to the rows.

[[0  1  2  3]
 ['  4  5  6  7]
 ['  '  8  9 10 11]]   e# Note that each '  corresponds to a space character.

W%    e# Reverse the rows.

[['  '  8  9 10 11]
 ['  4  5  6  7]
 [0  1  2  3]]

z     e# Zip/transpose.

[[ '  '  0]
 [ '  4  1]
 [ 8  5  2]
 [ 9  6  3]
 [10  7]
 [11]]

Sf-   e# Remove spaces from each row.

[[ 0]
 [ 4  1]
 [ 8  5  2]
 [ 9  6  3]
 [10  7]
 [11]]

Answer 6

पायथन 2, 88 87 बाइट्स

lambda L:[filter(None,x)[::-1]for x in map(None,[],*[i*[0]+r for i,r in enumerate(L)])]

0s पूर्व निर्धारित करें, ज़िप करें, फिर मिथ्या तत्वों को हटा दें। टुपल्स की सूची देता है। यह map(None,...)प्रदर्शन करने के लिए zip_longest (साथ धब्बों के गुम धब्बे None) और filter(None,...)नकली तत्वों को हटाने के लिए उपयोग करता है।

वार्षिक रूप से, हमें यह गारंटी []देने के mapलिए एक अतिरिक्त पंक्ति जोड़ने की आवश्यकता है कि ट्यूपल्स की एक सूची वापस आ गई है, क्योंकि 1x1 मैट्रिक्स के बजाय map(None,*[[1]])रिटर्न । हालांकि अतिरिक्त पंक्ति अलग हो जाती है ।[1][(1,)]filter

(-1 बाइट के लिए @ डेनिस का शुक्रिया)

Answer 7

रूबी, 68 66 बाइट्स

अनाम फ़ंक्शन।

->l{i=-1;k=[];l.map{|r|i-=j=-1;r.map{|e|k[i+j+=1]=[e,*k[i+j]]}};k}

• स्पैट ऑपरेटर कैसे काम करता है, इस वजह से, मैं सरणी जोड़कर 2 बाइट्स बचाने में सक्षम था।

Answer 8

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

#&@@@#&/@GatherBy[Join@@MapIndexed[List,#,{2}],Tr@*Last]&

जहां यूनिकोड चरित्र है जो गणितज्ञ पोस्टफिक्स \[Transpose]ऑपरेटर के रूप में पढ़ता है ।

यह अन्य मैथेमेटिका समाधान की तुलना में थोड़ा लंबा है, लेकिन मुझे लगा कि मैं इसे पोस्ट करूंगा क्योंकि यह Diagonalsबिल्ट-इन का उपयोग नहीं करता है और पूरी तरह से अलग दृष्टिकोण का उपयोग करता है।

व्याख्या

MapIndexed[List,#,{2}]

यह पहले मैट्रिक्स को स्थानांतरित करता है (जैसे कि मैट्रिक्स को चपटा किया गया था, तो एंटिडिएगल्स सही क्रम में दिखाई देते हैं)। फिर हम Listमैट्रिक्स के सेल पर एक साथ इंडेक्स के साथ मैप करते हैं, जो प्रत्येक मैट्रिक्स एलिमेंट iको {i, {x, y}}कहाँ में बदलता है xऔर मैट्रिक्स में एलिमेंट yके कोर्डिनेट होते हैं।

Join@@...

यह सबसे बाहरी आयाम को समतल करता है, जिससे अब हमारे पास कॉलम-प्रमुख क्रम में मैट्रिक्स तत्वों (उनके निर्देशांक के साथ) की एक फ्लैट सूची है।

GatherBy[..., Tr@*Last]

यह उन तत्वों को उनके निर्देशांक के योग द्वारा समूहित करता है। ध्यान दें कि एंटीडिऑग्नल्स निरंतर की रेखाएं हैं x+y, इसलिए यह वास्तव में वह समूह है जो हम चाहते हैं। प्रत्येक समूह के भीतर आदेश संरक्षित है। अब हमें बस फिर से निर्देशांक निकालने की जरूरत है। यह नहीं बल्कि गूढ़ के माध्यम से किया जाता है:

#&@@@#&/@...

यह #&@@@#&प्रत्येक समूह पर फ़ंक्शन को मैप करता है , जो समूह में प्रत्येक तत्व पर लागू होता #& है, और #केवल पहला तर्क है, अर्थात मूल मैट्रिक्स तत्व।

Comments

किसी भी स्पष्टीकरण के रूप में क्यों पढ़ा जाता है \[transpose]?

— 14

@Fatalize यह एक निजी-उपयोग वाला यूनिकोड कोडपॉइंट है, और इस कोडपॉइंट के साथ ग्लिफ़ मैथेमैटिका सहयोगी एक सुपरस्क्रिप्ट है T: reference.wolfram.com/language/ref/character/Transpose.html ... \[Transpose]बस यूनिकोड वर्ण का ASCII लिप्यंतरण है। या तो यूनिकोड चरित्र या गणित में लिप्यंतरण कॉपी करने से काम चल जाएगा।

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

Answer 9

ऑक्टेव, 77 बाइट्स

accumarrayसमारोह के एक छोटे से दुरुपयोग के साथ :

@(M)char(accumarray(((1:size(M,1))+(0:size(M,2)-1)')(:),M(:),[],@(x){num2str(x')}))

यह एक अनाम फ़ंक्शन को परिभाषित करता है। इसका उपयोग करने के लिए, एक परिवर्तनीय या उपयोग करने के लिए असाइन करें ans।

इनपुट :पंक्ति विभाजक के रूप में मैट्रिक्स है । आउटपुट एक सेल सरणी है जिसमें प्रत्येक पंक्ति के लिए एक सरणी होती है (ऑक्टेव दांतेदार सरणियों के बराबर)। यह ऑक्टेव द्वारा सेल एरे के सूचकांकों और प्रत्येक सेल की सामग्री को दिखाते हुए प्रदर्शित किया जाता है। इसे यहाँ आज़माएँ ।

रिजल्ट को अलग दिखाने के लिए और केवल नई बाइट्स : 83 बाइट्स

@(M)char(accumarray(((1:size(M,1))+(0:size(M,2)-1)')(:),M(:),[],@(x){num2str(x')}))

आप इसे यहाँ भी आज़मा सकते हैं ।

Answer 10

जावास्क्रिप्ट (फ़ायरफ़ॉक्स), 86 75 बाइट्स

a=>a.concat(a[0]).slice(1).map((_,i)=>[for(v of a)if(n=v[i--])n].reverse())

@ बाइस धन्यवाद के लिए 11 बाइट्स बचाए!

फ़ायरफ़ॉक्स में काम करता है 30+। सरणी का एक सरणी लेता है।

Comments

अच्छा एल्गोरिथ्म, लेकिन आप a.concat(a[0]).slice(1)सही लंबाई की एक सरणी प्राप्त करने के लिए उपयोग कर सकते हैं । इसके अलावा, [for(of)]ES6 नहीं है; मैं आम तौर पर इसे (फ़ायरफ़ॉक्स 30+) या कुछ ऐसे लिखता हूं।

— नील

@ नील वाह, मुझे थोड़ा मूर्खतापूर्ण लगता है कि उपयोग करने के लिए समझ नहीं आ रहा है concatऔर slice। धन्यवाद!

— 1:81 पर user81655

Answer 11

ऑक्टेव, 63 62 बाइट्स

@DonMue ... @LuisMendo की बदौलत एक बाइट हटा दिया गया !

@(a)cellfun(@(x)x(x>0)',num2cell(spdiags(flipud(a)),1),'un',0)

मैं उबाऊ मार्ग पर चला गया और एंटीडिओग्नल को पिघला दिया।

नमूना विचारधारा पर चलता है ।

Comments

मुझे लगता है कि आप को छोटा कर सकते 'uni'करने के लिए'un'

— लुइस Mendo

@LuisMendo क्यों, हाँ मैं कर सकता हूँ! धन्यवाद! :)

— बीकर

Answer 12

हास्केल, 83 82 बाइट्स

r=zip[0..]
\o->fst$span(any(>0))[reverse[e|(x,t)<-r o,(v,e)<-r t,x+v==a]|a<-[0..]]

nimi ने एक बाइट को बचाया। धन्यवाद!

Answer 13

अजगर, 128 बाइट्स (सुन्न)

(lambda A: (lambda A,S:[[A[U][I-U] for U in range(min(S[1]-1,I),max(I-S[0]+1,0)-1,-1)] for I in range(S[1]+S[0]-1)])(A,A.shape))

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! डिफ़ॉल्ट रूप से, गोल्फ चुनौती को कोड करने के लिए प्रस्तुतियाँ कार्यक्रम या कार्य होने चाहिए और I / O के लिए अनुमोदित विधियों में से एक का उपयोग करना चाहिए । एक स्निपेट जो हार्डकोडेड वेरिएबल में इनपुट की अपेक्षा करता है, उसे अनुमति नहीं है।

— डेनिस

ऐसा लगता है कि आप पहले समाधान का उपयोग lambdaकर सकते हैं जो सिर्फ एक लंबो में उपयोग करता है जिसे आप अपनी सबमिशन के रूप में उपयोग कर सकते हैं।

— एलेक्स ए।

मैं इसे

— लम्बा करूंगा

lambda A:[[A[U][I-U]for U in range(max(I-len(A)+1,0),min(len(A[0])-1,I)+1)]for I in range(len(A+A[0])-1)](जैसा कि आपके मूल संशोधन में है) थोड़ा कम होगा। साथ ही, आपको प्रश्न से अभिविन्यास प्राप्त A[U][I-U]करने के A[I-U][U]लिए बदलना चाहिए ।

— डेनिस

घर पर वापस आने पर मैं इसकी जांच करूंगा। समझ में आता है

— लुइस मूसली

Answer 14

पायथ , 41 17 बाइट्स

tm_<dx+dYk.T+LaYk

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

एक अन्य समस्या के लिए @ Doorknob के समाधान से प्रेरित ।

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

tm_<dx+dYk.T+LaYk
            +L      prepend to each subarray...
              aYk   (Y += ''). Y is initialized to [],
                    so this prepends [''] to the first
                    subarray, ['', ''] to the second, etc.
                    ['' 1  2  3
                     '' '' 4  5  6
                     '' '' '' 7  8  9
                     '' '' '' '' 10 11 12
                     '' '' '' '' '' 13 14 15]
          .T        transpose, giving us
                    ['' '' '' '' ''
                     1  '' '' '' ''
                     2  4  '' '' ''
                     3  5  7  '' ''
                     6  8  10 ''
                     9  11 13
                     12 14
                     15]
 m_<dx+dYk          removes all empty strings in the
                    subarrays while reversing each one
t                   remove the first subarray

---

पिछला प्रयास:

JlQKlhQm_m@@Qk-dk}h.MZ,0-dtKh.mb,tJdUt+JK

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

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

JlQKlhQm_m@@Qk-dk}h.MZ,0-dtKh.mb,tJdUt+JK    input array stored as Q
JlQ                                          J = len(Q)
   KlhQ                                      K = len(Q[0])
       m                            Ut+JK    list for d from 0 to J+K-1:
        _m       }AAAAAAAAAABBBBBBBB             reversed list for k from A to B, where:
                  h.MZ,0-dtK                       A = max(0, d-(K-1))
                       0-dtK                               0  d-(K-1)
                            h.mb,tJd               B = min(J-1, d)
                                 tJd                       J-1  d
          @@Qk-dk                                    Q[k][d-k]

Answer 15

ग्रूवी, 77 73 75

{i->o=[].withDefault{[]};a=0;i.each{b=0;it.each{o[a+b++].add(0,it)};a++};o}

एरे के सरणी को इनपुट के रूप में लेता है और एरे की सरणी देता है।

कोशिश करो

संपादित करें: मैं स्कोर पैदा करने के लिए भूल गया, इसे जोड़ने के बाद स्कोर 75 तक जाता है।