मैट्रिसेस की सूची के लिए मेरी सूचना को ठीक करें, भाग 1

Question

कभी-कभी, मेरे कोड में निरंतर मैट्रिसेस की सूची होती है:

[ [[1, 0],
   [0, 1]],

  [[1, 0],
   [0,-1]],

  [[0, 1],
   [1, 0]],

  [[0,-1],
   [1, 0]] ]

यह स्क्रीन रियल एस्टेट का एक भयानक उपयोग है। मैं बहुत उन्हें एक दूसरे के बगल में लिखना चाहते हैं:

[   [[1, 0],    [[1, 0],    [[0, 1],    [[0,-1],
     [0, 1]],    [0,-1]],    [1, 0]],    [1, 0]]   ]

आपको पता चलेगा कि यह अभी भी एक वाक्यात्मक रूप से मान्य नेस्टेड सूची है, यह अब केवल आयताकार नहीं है और इसकी एक बहुत अलग संरचना है (विशेष रूप से, यह हर बार जब मैं 1x1 से बड़ा मैट्रिक्स जोड़ता हूं, तो यह गहरा हो जाता है)। हालांकि, इस नई सूची से मैट्रिसेस की प्रारंभिक सूची को फिर से बनाना संभव है।

ताकि मैं भविष्य में इस वाक्यविन्यास का उपयोग कर सकूं, मुझे आपको कुछ कोड लिखने की आवश्यकता है जो सरणियों को एक क्षैतिज व्यवस्था में लिखे गए मेट्रिसेस की सूची में लिखते हैं।

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

[[[1, 0], [[1, 0], [[0, 1], [[0,-1], [0, 1]], [0,-1]], [1, 0]], [1, 0]]]

और आउटपुट निम्न सरणी या उसके स्ट्रिंग प्रतिनिधित्व होना चाहिए (फिर से, कोई और लेआउट की आवश्यकता नहीं है):

[[[1, 0], [0, 1]], [[1, 0], [0,-1]], [[0, 1], [1, 0]], [[0,-1], [1, 0]]]

यह दो-भाग की चुनौती का पहला और आसान हिस्सा है। इस एक में, आप मान सकते हैं कि सभी मैट्रिस वर्ग हैं और समान आयाम हैं और वे एक दूसरे के बगल में ठीक से संरेखित हैं। दूसरे भाग में हम इन धारणाओं को शिथिल करेंगे।

नियम

इनपुट एक नेस्टेड सूची या इसकी कैनोनिकल स्ट्रिंग प्रतिनिधित्व (आपकी पसंद की भाषा में) होगी, और आपको परिणाम उसी प्रारूप में होना चाहिए। परिणाम में हमेशा कम से कम एक मैट्रिक्स होगा, और मैट्रिक्स 1x1 जितना छोटा हो सकता है। मेट्रिसेस में केवल 128 से कम निरपेक्ष मान वाले पूर्णांक (हस्ताक्षरित) होंगे।

आप एक प्रोग्राम या फ़ंक्शन लिख सकते हैं और इनपुट प्राप्त करने और आउटपुट प्रदान करने के किसी भी मानक तरीके का उपयोग कर सकते हैं।

आप किसी भी प्रोग्रामिंग भाषा का उपयोग कर सकते हैं , लेकिन ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है।

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

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

प्रत्येक परीक्षण के मामले में एक) सूची मैट्रिसेस एक दूसरे के बगल में रखी होती हैं क्योंकि वे कोड में होंगे (यह आपका इनपुट नहीं है ), बी) बाहरी व्हाट्सएप ( यह आपका इनपुट है) के बिना गैर- सूचीबद्ध सूची , सी) अपेक्षित उत्पादन।

Pretty: [ [[0]] ]
Input:  [[[0]]]
Output: [[[0]]]

Pretty: [  [[-1]],  [[0]],  [[1]]  ]
Input:  [[[-1]],[[0]],[[1]]]
Output: [[[-1]],[[0]],[[1]]]

Pretty: [  [[1, 0],   [[1, 0],   [[0, 1],   [[0,-1],
            [0, 1]],   [0,-1]],   [1, 0]],   [1, 0]]  ]
Input:  [[[1,0],[[1,0],[[0,1],[[0,-1],[0,1]],[0,-1]],[1,0]],[1,0]]]
Output: [[[1,0],[0,1]],[[1,0],[0,-1]],[[0,1],[1,0]],[[0,-1],[1,0]]]

Pretty: [  [[1, 0, 0],   [[ 127,  63,   31],   [[1, 0, 0],   [[0, 0, 0],
            [0, 1, 0],    [  15,   0,  -15],    [0, 0, 1],    [0, 0, 0],
            [0, 0, 1]],   [ -31, -63, -127]],   [0, 1, 0]],   [0, 0, 0]]  ]
Input:  [[[1,0,0],[[127,63,31],[[1,0,0],[[0,0,0],[0,1,0],[15,0,-15],[0,0,1],[0,0,0],[0,0,1]],[-31,-63,-127]],[0,1,0]],[0,0,0]]]
Output: [[[1,0,0],[0,1,0],[0,0,1]],[[127,63,31],[15,0,-15],[-31,-63,-127]],[[1,0,0],[0,0,1],[0,1,0]],[[0,0,0],[0,0,0],[0,0,0]]]

Comments

मुझे लगता है कि मुझे पता है कि इस चुनौती ने क्या प्रेरित किया ...

— नील

है [([1, 0], [0, 1]), ([1, 0], [0, -1]), ([0, 1], [1, 0]), ([0, -1], [1, 0])]तीसरे testcase के लिए मान्य उत्पादन? यह मिश्रित सूची और टपल है।

— १17

@ नो, सॉरी। चूंकि इनपुट और आउटपुट फॉर्मेट का मेल होना चाहिए, इसलिए संबंधित इनपुट होगा [([1,0], ([1, 0}, ...और इससे आपको अतिरिक्त जानकारी मिलेगी।

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

@ नील ने इस चुनौती से क्या प्रेरित किया?

— बजे के दौरान केयर्ड सिक्काहिंगाहिंग

@RandomUser सभी चीजों को गोल्फ करने की इच्छा। स्क्रीन अचल संपत्ति जीत की कम से कम राशि!

— डेनिस

Answer 1

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

Fðs⁹œsZµḢḢL

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

पृष्ठभूमि

ज्यादातर चीजों की तरह, यह चुनौती आसान है जब आप यह समझ लेते हैं कि आपको क्या करना है। और मैंने अंततः तीन विलोपन और एक रोलबैक के बाद किया ...

सबसे पहले, हमें मेट्रिसेस के आयामों का पता लगाना चाहिए। यह कहा गया की तुलना में आसान है: पहले तत्व का पहला तत्व पहले आउटपुट मैट्रिक्स की पहली पंक्ति है, इसलिए इसकी लंबाई वर्ग आउटपुट मैट्रिक्स के स्तंभों की संख्या के बराबर है।

उदाहरण के लिए, यदि इनपुट है

[  [[1, 0, 0],   [[ 127,  63,   31],   [[1, 0, 0],   [[0, 0, 0],
    [0, 1, 0],    [  15,   0,  -15],    [0, 0, 1],    [0, 0, 0],
    [0, 0, 1]],   [ -31, -63, -127]],   [0, 1, 0]],   [0, 0, 0]]  ]

पहले तत्व का पहला तत्व है [1, 0, 0], जिसकी लंबाई first = 3 है ।

यदि हम इनपुट को समतल करते हैं और इसे उस लंबाई के टुकड़ों में विभाजित करते हैं, तो हमें आउटपुट मैट्रिसेस की सभी पंक्तियाँ मिलती हैं, भले ही वह गलत क्रम में हो। हमारे उदाहरण इनपुट के लिए, यह देता है

[  [1, 0, 0], [127,  63,   31], [1, 0, 0], [0, 0, 0],
   [0, 1, 0], [ 15,  0,   -15], [0, 0, 1], [0, 0, 0],
   [0, 0, 1], [-31, -63, -127], [0, 1, 0], [0, 0, 0]  ]

अंतिम आउटपुट प्राप्त करने के लिए, हम पहले में पंक्ति सरणी विभाजित चाहिए ℓ समान लंबाई के टुकड़े। हमारे उदाहरण इनपुट के लिए, यह देता है

[ [[1, 0, 0], [127,  63,   31], [1, 0, 0], [0, 0, 0]],
  [[0, 1, 0], [ 15,  0,   -15], [0, 0, 1], [0, 0, 0]],
  [[0, 0, 1], [-31, -63, -127], [0, 1, 0], [0, 0, 0]] ]

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

[
 [[1, 0, 0],
  [0, 1, 0],
  [0, 0, 1]],

 [[127,  63,   31],
  [ 15,   0,  -15],
  [-31, -63, -127]],

 [[1, 0, 0],
  [0, 0, 1],
  [0, 1, 0]],

 [[0, 0, 0],
  [0, 0, 0],
  [0, 0, 0]]
]

जैसी इच्छा।

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

Fðs⁹œsZµḢḢL  Monadic link. Argument: A (ragged array)


F            Monadic chain. Argument: A

F            Flatten A. This yields the vector V.


       µḢḢL  Monadic chain. Argument: A

        Ḣ    Head; retrieve the first element of A.
         Ḣ   Head; retrieve the first element of the first element of A.
          L  Compute ℓ, the length of the resulting array.


 ðs⁹œsZ      Dyadic chain. Left argument: V. Right argument: ℓ

  s⁹         Split V into chunks of length ℓ.
    œs       Split the result into ℓ chunks of equal length.
      Z      Zip/transpose the result.

Answer 2

पायथ , 12 बाइट्स

CcJlhhQc.nQJ

यह मेरे जेली उत्तर का एक बंदरगाह है।

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

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

पाइथ इस कार्यक्रम को इस प्रकार से प्रस्तुत करता है (छद्म-कोड)।

C(c(J = l(h(h(Q))), c(.n(Q), J)))

Q एक वैरिएबल है जो इनपुट रखता है। J एक अपरिभाषित चर है।

पहले J में QJ = l(h(h(Q))) के सिर की लंबाई (पहला तत्व) को संग्रहीत करता है ।

फिर, क्यू को.n(Q) समतल करता है , और परिणाम को लंबाई J के टुकड़ों में विभाजित करता है ।c(..., J)

बाद में, जे टुकड़ों c(J, ...)में परिणाम को विभाजित करता है ।

अंत में, C(...)परिणाम को स्थानांतरित करता है।

Comments

sancta mater dei

— लीक नून

Answer 3

पायथ , 29 बाइट्स

.xj\,sCcJh-UJ:z"\B,"3x\[@R1Jz

परीक्षण सूट।

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

.xj\,sCcJh-UJ:z"\B,"3x\[@R1Jz

              z        input
             :      3  split at matches of the following regex
               "\B,"   /\B,/
            J          store at J
           U           [1,2,...,len(J)]

                           J  J
                        @R1   take the second character of each
                              substring in J
                     x\[      indices of all occurrences of "["

          -   filter away the elements in ^ from the
              elements in ^^ to find the first substring
              which does not start with "[["
         h    the first element
              note: this will generate an error if
              all substrings start with "[[", e.g. in the
              first example. We will deal with the error later.
       cJ     split J in groups of the specified length
      C       transpose                             ^
     s        flatten                               |
  j\,         join with ","                         |
.x            if the above code generated an error (|), return
              the following instead:
                            z      the input

कलन विधि

चलिए इनपुट पर काम करते हैं [[[1,0],[[1,0],[[0,1],[[0,-1],[0,1]],[0,-1]],[1,0]],[1,0]]]।

हम यहां शुद्ध स्ट्रिंग ऑपरेशन का उपयोग करेंगे।

सबसे पहले, हम इनपुट को अल्पविराम में विभाजित करते हैं जो सबसे गहरी सूची का हिस्सा नहीं है (यह रेगेक्स में विभाजित करके किया जाता है \B,):

[[[1,0]
[[1,0]
[[0,1]
[[0,-1]
[0,1]]
[0,-1]]
[1,0]]
[1,0]]]

फिर, हम पहले प्रतिस्थापन के सूचकांक को ढूंढते हैं जो इसके साथ शुरू नहीं होता है [[(यह जांच करके किया जाता है कि क्या सूचकांक में चरित्र 1है [)। इस मामले में, यह है4 , क्योंकि इंडेक्स 4 में सबस्ट्रिंग वह है [0,1]]जो इसके साथ शुरू नहीं होता है [[।

फिर, हम सबस्ट्रिंग को 4 के समूहों में समूहित करते हैं, और फिर स्थानांतरित करते हैं:

[[[1,0]
[0,1]]
[[1,0]
[0,-1]]
[[0,1]
[1,0]]
[[0,-1]
[1,0]]]

और फिर हम उन्हें अल्पविराम से जोड़ते हैं:

[[[1,0],[0,1]],[[1,0],[0,-1]],[[0,1],[1,0]],[[0,-1],[1,0]]]

Comments

आप सिर्फ डेनिस द्वारा बड़े पैमाने पर बहिर्गमन कर रहे थे ।

— एरिक द आउटग्राफर

Answer 4

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

f=(a,n=1)=>a[0][n]?a[0][n][0][0]?f(a,n+1,a[0].splice(n,1,...a[0][n])):n>1?[...Array(n)].map((_,i)=>a[0].filter((_,j)=>j%n==i)):a:a

चार मामले हैं:

• 1 × n सरणी, जो अभी लौटा है (यह पहला परीक्षण है, लेकिन उलटा है)
• एक m ​​× n सरणी जिसे अभी तक चपटा नहीं किया गया है, जिसे हम एक nही समय में एक चरण में गिनकर पुनरावृत्ति करते हैं।
• एक m ​​× n सरणी जिसे चपटा किया गया है, जहां हम प्रत्येक nवें तत्व को फ़िल्टर करते हैं ।
• एक एम × 1 एरे, जो अभी लौटा है

Answer 5

05AB1E , 11 बाइट्स

डेनिस के जवाब का एक बंदरगाह । कोड:

¬¬g¹˜sô¬gäø

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

Answer 6

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

l=Length;(m=l@#[[1,1]];n=l@Flatten@#/m;Table[Partition[#~ArrayReshape~{n,m},n/m][[j,i]],{i,n/m},{j,m}])&

इनपुट

{{{1, 0}, {{1, 0}, {{0, 1}, {{0, -1}, {0, 1}}, {0, -1}}, {1, 0} }, {1, 0}}}

उत्पादन

{{{1, 0}, {0, 1}}, {{1, 0}, {0, -1}}, {{0, 1}, {1, 0}}, {{0, -1 }, {1, 0}}}

इनपुट

{{{1, 0, 0}, {{127, 63, 31}, {{1, 0, 0}, {{0, 0, 0}, {0, 1, 0}, {15, 0,} -15}, {0, 0, 1}, {0, 0, 0}, {0, 0, 1}}, {-31, -63, -127}}, {0, 1, 0}}, {, 0, 0, 0}}

उत्पादन

{{{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}, {{127, 63, 31}, {15, 0, -15}, {-31, - 63, -127}}, {{1, 0, 0}, {0, 0, 1}, {0, 1, 0}}, {{0, 0, 0}, {0, 0, 0},} {, 0, 0, 0}}

{{{0}}} और {{{-1}}, {{0}}, {{1}}} काम भी

-11 बाइट्स मार्टिन एंडर को धन्यवाद