एक 2d सरणी के आसपास के शून्य निकालें

Question

यह इस प्रश्न का 2-आयामी संस्करण है ।

एक गैर-खाली 2-आयामी सरणी / मैट्रिक्स दिया गया जिसमें केवल गैर-नकारात्मक पूर्णांक हैं:

$$\begin{bmatrix} {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \\ {\color{Red}0} & {\color{Red}0} & 0 & 1 & 0 \\ {\color{Red}0} & {\color{Red}0} & 0 & 0 & 1 \\ {\color{Red}0} & {\color{Red}0} & 1 & 1 & 1 \\ {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \end{bmatrix}$$

आसपास के शून्य हटाए गए सरणी के साथ आउटपुट करें, यानी आसपास के शून्य के बिना सबसे बड़ा सन्निहित उपरि:

$$\begin{bmatrix} 0 & 1 & 0 \\ 0 & 0 & 1 \\ 1 & 1 & 1 \end{bmatrix}$$

उदाहरण:

$$\begin{bmatrix} {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \\ {\color{Red}0} & {\color{Red}0} & 0 & 1 & 0 \\ {\color{Red}0} & {\color{Red}0} & 0 & 0 & 1 \\ {\color{Red}0} & {\color{Red}0} & 1 & 1 & 1 \\ {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \end{bmatrix} \mapsto \begin{bmatrix} 0 & 1 & 0 \\ 0 & 0 & 1 \\ 1 & 1 & 1 \end{bmatrix}$$

Input:
[[0, 0, 0, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1], [0, 0, 1, 1, 1], [0, 0, 0, 0, 0]]

Output:
[[0, 1, 0], [0, 0, 1], [1, 1, 1]]

$$\begin{bmatrix} {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \\ {\color{Red}0} & 0 & 0 & 3 \\ {\color{Red}0} & 0 & 0 & 0 \\ {\color{Red}0} & 5 & 0 & 0 \\ {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \end{bmatrix} \mapsto \begin{bmatrix} 0 & 0 & 3 \\ 0 & 0 & 0 \\ 5 & 0 & 0 \end{bmatrix}$$

Input:
[[0, 0, 0, 0], [0, 0, 0, 3], [0, 0, 0, 0], [0, 5, 0, 0], [0, 0, 0, 0]]

Output:
[[0, 0, 3], [0, 0, 0], [5, 0, 0]]

$$\begin{bmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \end{bmatrix} \mapsto \begin{bmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \end{bmatrix}$$

Input:
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Output:
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

$$\begin{bmatrix} {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \\ {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \\ {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \end{bmatrix} \mapsto \begin{bmatrix} \end{bmatrix}$$

Input:
[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

Output:
[]

$$\begin{bmatrix} {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \\ 1 & 1 & 1 & 1 \\ {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \end{bmatrix} \mapsto \begin{bmatrix} 1 & 1 & 1 & 1 \end{bmatrix}$$

Input:
[[0, 0, 0, 0], [1, 1, 1, 1], [0, 0, 0, 0]]

Output:
[[1, 1, 1, 1]]

$$\begin{bmatrix} {\color{Red}0} & 1 & {\color{Red}0} & {\color{Red}0} \\ {\color{Red}0} & 1 & {\color{Red}0} & {\color{Red}0} \\ {\color{Red}0} & 1 & {\color{Red}0} & {\color{Red}0} \end{bmatrix} \mapsto \begin{bmatrix} 1 \\ 1 \\ 1 \end{bmatrix}$$

Input:
[[0, 1, 0, 0], [0, 1, 0, 0], [0, 1, 0, 0]]

Output:
[[1], [1], [1]]

$$\begin{bmatrix} 1 & 1 & 1 & 1 \\ 1 & 2 & 3 & 1 \\ 1 & 1 & 1 & 1 \end{bmatrix} \mapsto \begin{bmatrix} 1 & 1 & 1 & 1 \\ 1 & 2 & 3 & 1 \\ 1 & 1 & 1 & 1 \end{bmatrix}$$

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

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

Comments

@ मैथ गैर-गूढ़ भाषा में कुछ भी मुश्किल नहीं है। :)बस इसे छोटा करना मुश्किल है।

— user202729

क्या हम अंतिम परीक्षण के मामले के लिए एक खाली मैट्रिक्स के बजाय एक गलत आउटपुट दे सकते हैं?

— सूंदर -

इसके अलावा, यदि आउटपुट एक गैर-वर्ग मैट्रिक्स हो सकता है, तो कृपया उसके लिए एक परीक्षण मामला जोड़ें।

— सूंदर -

एक परीक्षण का मामला जिसने मेरा पहला सबमिशन तोड़ दिया: [[0, 0, 0, 0], [0, 0, 0, 0], [1, 1, 1, 1], [0, 0, 0, 0]](एक चौड़ाई / ऊँचाई होने का परिणाम 1)

— कॉनर ओ'ब्रायन

अरे, क्या टेस्ट केस को करना संभव है $$\begin{bmatrix}1&1&1&1\\1&2&3&1\\1&1&1&1\end{bmatrix}$$

— बीटा

Answer 1

MATL , 3 बाइट्स

JYa

इसे ऑनलाइन आज़माएं! या सभी प्रकार के परीक्षण की पुष्टि ।

व्याख्या

J      % Push 1j
Ya     % With complex 2nd input, this unpads the matrix in the
       % 1st input (implicit). The unpad value is 0 by default
       % Display (implicit)

Comments

"जया जया जया जया"

— ब्रेन गाइडर

मुझे पसंद है कि कैसे सिर्फ आधा कोड है (implicit)।

— जुंगह्वान मिन

Answer 2

वोल्फ्राम भाषा (गणितज्ञ) , 42 बाइट्स

#&@@CellularAutomaton[{,{},0{,}},{#,0},0]&

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

सेलुलर ऑटोमेटा वास्तव में जीवन , ब्रह्मांड और सब कुछ का जवाब है । ¹

कैसे?

CellularAutomatonएक इनपुट सरणी और एक वैकल्पिक पृष्ठभूमि मान स्वीकार करता है। इस प्रकार, {#,0}निर्दिष्ट करता है कि सेल्यूलर ऑटोमेटन नियम को इनपुट पर लागू किया जाना चाहिए, जो कि एक पृष्ठभूमि है 0।

यहां एक साफ-सुथरी बात यह है कि CellularAutomatonउत्पादन इतना है कि पृष्ठभूमि कोशिकाओं की कोई सीमा मौजूद नहीं है (क्योंकि अन्यथा उत्पादन एक अनंत विमान पर स्थित है)।

कोड नियम लागू करता है {Null, {}, {0, 0}}- Nullप्रत्येक सेल के 0-त्रिज्या पड़ोसी (यानी केवल केंद्र: सेल स्वयं) के लिए सिर को लागू करना - बिल्कुल 0समय। इसका परिणाम मूल इनपुट है, लेकिन पृष्ठभूमि को हटा दिया गया है (यानी आसपास के 0एस बाहर फसल )।

---

^{1. मेरे उत्तर का बायटेकाउंट देखें? ;)}

Comments

अच्छा बिल्टिन एब्यूज ... अच्छी तरह से मैथेमेटिका में बिल्ट-इन है, बस सीधे उजागर नहीं किया गया है।

— user202729

कोई XKCD 505 संदर्भ नहीं?

— फलों के जूल

सेल्युलर ऑटोमेटा और अंतिम उत्तर के लिए +1।

— HighlyRadioactive

Answer 3

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

(a,z)=>(g=A=>A.slice(A.map(m=M=(r,i)=>M=(z?a:r).some(n=>z?n[i]:n)?1/m?i:m=i:M)|m,M+1))(a).map(z=g)

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

कैसे?

की कमी दूर करने के लिए एक ज़िप में निर्मित, हम एक समारोह को परिभाषित ग्राम () है कि या तो पंक्तियों या इनपुट मैट्रिक्स के कॉलम पर काम करने में सक्षम है एक [] , वैश्विक ध्वज के मूल्य के आधार जेड ।

g () गैर-खाली पंक्तियों (यदि z अपरिभाषित है) यान्यूनतम-खाली कॉलम (यदि z परिभाषित है)के न्यूनतम सूचकांक m और अधिकतम सूचकांक M की तलाश करता हैऔरमैट्रिक्सके संबंधित स्लाइस को स्वयं या दी गई पंक्ति मेंलौटाता हैमैट्रिक्स का।

संक्षेप में:

• हम पहले z को अपरिभाषित के साथ मैट्रिक्स पर g () लगाकर पंक्तियों को हटाते हैं
• फिर हम z परिभाषित के साथ प्रत्येक पंक्ति पर g () को लागू करके कॉलम निकालते हैं , जो इसके बजाय असामान्य होता है.map(z=g)

टिप्पणी की गई

(a, z) => (               // a[] = input matrix; z is initially undefined
  g = A =>                // g() = function taking A = matrix or row
    A.slice(              //   eventually return A.slice(m, M + 1)
      A.map(m = M =       //     initialize m and M to non-numeric values
        (r, i) =>         //     for each row or cell r at position i in A:
        M = (z ? a : r)   //       iterate on either the matrix or the row
        .some(n =>        //       and test whether there's at least one
          z ? n[i] : n    //       non-zero cell in the corresponding column or row
        ) ?               //       if so:
          1 / m ? i       //         update the maximum index M (last matching index)
                : m = i   //         and minimum index m (first matching index)
        :                 //       otherwise:
          M               //         let M (and m) unchanged
      ) | m,              //     end of map(); use m as the first parameter of slice()
      M + 1               //     use M+1 as the second parameter of slice()
    )                     //   end of slice()
  )(a)                    // invoke g() on the matrix with z undefined
  .map(z = g)             // invoke g() on each row of the matrix with z defined

Comments

यह प्रभावशाली है।

— जैक हेल्स

@ जेक, अरनुलद एक अलग आयाम में रहता है। लेकिन अगर आप बेहद भाग्यशाली हैं, तो आप कभी-कभार ऐसी तरकीब खोज सकते हैं जिससे वह चूक गया हो और एक छोटा समाधान पोस्ट कर दे। इस प्रक्रिया में, आप जावास्क्रिप्ट की बहुत गहरी समझ विकसित करेंगे।

— रिक हिचकॉक

@RickHitchcock मैं कोड पैटर्न मान्यता में उतना अच्छा नहीं हूं और मैं नियमित रूप से बहुत सारी चीजों को याद कर रहा हूं, भले ही मैंने उन्हें पहले देखा हो। इस विशिष्ट उदाहरण में, मैं के पुनर्प्रयोग पर ध्यान केंद्रित किया गया था जी () और अद्यतन के रास्ते पर काफी एक स्पष्ट अनुकूलन याद मीटर और एम (-9 बाइट्स)। मैं इस बात से पूरी तरह सहमत हूं कि किसी भाषा की सूक्ष्मता के बारे में बहुत कुछ सीखने के लिए कोड-गोल्फिंग एक शानदार (और मजेदार) तरीका है।

— अरनुलद

Answer 4

हास्केल , 62 61 बाइट्स

f.f.f.f
f=reverse.foldr(zipWith(:))e.snd.span(all(<1))
e=[]:e

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

foldr(zipWith(:))eसाथ e=[]:eएक है थोड़ा कमtranspose है, और snd.span(all(<1))सूची की एक सूची से शून्य की अग्रणी सूचियों चला जाता है। के रूप में transposeके बाद reverseपर एक 2D सूची 90 से एक रोटेशन के बराबर होती है °, कोड f.f.f.fसिर्फ चार गुना है शून्य और घुमाने के अग्रणी सूचियों ड्रॉप ।

Answer 5

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

V2=.sCQ]m0Q;Q

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

Comments

मुझे लगता है कि =_CQ इसके स्थान पर काम करेंगे =Q_CQ।

— श्री एक्सकोडर

Answer 6

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

œr€0z0Uµ4¡

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

Answer 7

ब्रेकीलॉग , 24 22 20 19 बाइट्स

{s.h+>0∧.t+>0∧}\↰₁\

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

परिणाम मैट्रिक्स को सरणियों के एक सरणी के रूप में आउटपुट करता है, या खाली आउटपुट के लिए गलत है।

(इनलाइन विधेय के सुझाव के लिए @ फ़ेटलाइज़ के लिए धन्यवाद और 1 बाइट की बचत करें।)

व्याख्या

समर्पित करें 0 (मुख्य):

{...}     Define and call predicate 1 to remove all-zero rows
  \       Transpose the result
   ↰₁     Call pred 1 again, now to remove all-zero columns
     \    Transpose the result to have correct output orientation

1 समर्पित करें:

?s.h+>0∧.t+>0∧
  .           output is
 s              a subsequence of the rows of
?              the input (implicit)
   h          also, output's head element (first row)
    +>0        has a sum > 0 (i.e. has at least one non-zero value)
       ∧.t+>0  and similarly the output's tail element (last row)
∧              (don't implicitly unify that 0 with the output)

Comments

पहली विधेय इनलाइन लिखना 1 बाइट छोटी है {s.h+>0∧.t+>0∧}\↰₁\ :। (यह बहुत ज्यादा किसी भी Brachylog उत्तर के लिए सच है, नई लाइनों पर भविष्यवाणी वास्तव में केवल तभी लागू की जाती है यदि आप अधिक पठनीय चीजें लिखना चाहते हैं)।

— जूल

@Fatalize धन्यवाद, अद्यतन (अंत में!)। मैंने कभी नहीं सोचा कि कैसे इनलाइन विधेय वाक्य रचना एक परिभाषा और विधेय अनुप्रयोग है, बहुत अच्छा है।

— सूंदर -

Answer 8

आर , 96 100 97 बाइट्स

function(m)m[~m,~t(m),drop=F]
"~"=function(x,z=seq(r<-rowSums(x)))z>=min(y<-which(r>0))&z<=max(y)

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

~सहायक एक गैर नकारात्मक वेक्टर और रिटर्न के साथ एक वेक्टर लेता है FALSEके लिए "बाहरी" 0वेक्टर की है और TRUEसकारात्मक और किसी भी "आंतरिक" के लिए 0है। यह फ़ंक्शन इनपुट मैट्रिक्स की पंक्ति और कॉलम रकम पर लागू होता है।

~और ! ऑपरेटरों के आर के पार्सर उपचार का उपयोग करें।

@ DigEmAll की टिप्पणी के अनुसार सही किया गया, लेकिन कुछ बाइट्स के साथ @ J.Doe से वापस

Comments

मुझे लगता है कि आपको मेरे अनुसार जोड़ना चाहिए drop=F, अन्यथा ये 2 परीक्षण पंक्ति और स्तंभ के बजाय एक वेक्टर लौटाएंगे: इसे ऑनलाइन आज़माएं!

— digEmAll

97 बाइट्स के साथ drop=F। अभी भी एक टन के नीचे!

— जे। ओडो

Answer 9

आर , 89 79 बाइट्स

function(m,y=apply(which(m>0,T),2,range)){y[!1/y]=0;m[y:y[2],y[3]:y[4],drop=F]}

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

परीक्षण मामलों के कोड के लिए @ngm, और 10 बाइट बचाने के लिए @ जे। धन्यवाद!

• मुझे drop=Fडिफ़ॉल्ट आर व्यवहार को वैक्टर में एकल पंक्ति / कॉल मैट्रिक्स के कारण पैरामीटर जोड़ना पड़ा ...

Comments

मैंने ध्यान नहीं दिया कि मेरा पिछला कोड ऑल-जीरो मामलों को

— फेल

काश मैं यह +2 कर पाता। फेवेनम का वास्तव में अच्छा उपयोग।

— JayCe

79 बाइट्सrange इंडेक्सेशन का उपयोग और

— ट्विकिंग

@ J.Doe: रेंज, बिल्कुल! महान विचार धन्यवाद!

— डाइजेक्सिल

Answer 10

एपीएल (डायलॉग क्लासिक) , 17 15 बाइट्स

{⍉⌽⍵⌿⍨∨\∨/×⍵}⍣4

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

Answer 11

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

इनपुट को संशोधित करके लौटाता है। एक सूची को इनपुट के रूप में पारित किया जाना चाहिए।

def f(a):exec'while a and 1>sum(a[-1]):a.pop()\na[:]=zip(*a)[::-1]\n'*4

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

---

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

यह भी इनपुट को संशोधित करता है, लेकिन यह काम करता है ...।

def f(a):exec'while a and 1>sum(a[-1]):a.pop()\na=zip(*a)[::-1]\n'*4;return a

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

Answer 12

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 66 बाइट्स

If[Max@#>0,ImageCrop@Image[#~ArrayPad~1,r="Real"]~ImageData~r,{}]&

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

अब जीरो के साथ एरे को पेड करके काम करता है (धन्यवाद @ जुंगह्वानमीन)!

4 बाइट बचाने के लिए @JungHwanMin को दूसरा धन्यवाद

Answer 13

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

Ṗ§Ṫ¬ȧƲ¿UZµ4¡

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

एक समारोह के रूप में।

Answer 14

वोल्फ्राम भाषा (गणितज्ञ) , 48 बाइट्स

Nest[Reverse@Thread@#//.{{0..},a___}->{a}&,#,4]&

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

इसे सामान्य तरीके से करना।

Comments

दुर्भाग्य से \[Transpose]यहाँ काम नहीं कर सकता।

— user202729

Answer 15

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

!5¡(T0mo↔↓¬

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

मुझे लगता है कि !5¡भाग को छोटा करके कुछ बाइट्स को बंद किया जा सकता है ।

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

!5¡(

$5^{\text{th}}$

mo↔↓¬

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

T0

स्थानांतरण, लापता प्रविष्टियों को 0 से बदल रहा है ।

Answer 16

रेटिना , 87 बाइट्स

/.\[(?!0,)/^+`\[0, 
[
/(?<! 0)]./^+`, 0]
]
\[(\[0(, 0)*], )+
[
(, \[0(, 0)*])+]|\[0]]
]

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

/.\[(?!0,)/^+`

कम से कम एक पंक्ति शून्य से शुरू नहीं होती है ...

\[0, 
[

... प्रत्येक पंक्ति से अग्रणी शून्य निकालें।

/(?<! 0)]./^+`

जब तक कम से कम एक पंक्ति शून्य के साथ समाप्त नहीं होती है ...

, 0]
]

... प्रत्येक पंक्ति से अनुगामी शून्य निकालें।

\[(\[0(, 0)*], )+
[

शून्य की अग्रणी पंक्तियों को हटा दें।

(, \[0(, 0)*])+]|\[0]]
]

शून्य या अंतिम शेष शून्य की पंक्तियों को निकालें।

Comments

@ हिचकी यह संवेदनशील स्वरूप है, रिक्त स्थान में जोड़ें: इसे ऑनलाइन आज़माएं!

— नील

Answer 17

चारकोल , 48 बाइट्स

Ｆ⁴«Ｗ∧θ¬Σ§θ±¹Σ⊟θ¿θ≔⮌Ｅ§θ⁰Ｅ觧θνλθ»⪫[]⪫Ｅθ⪫[]⪫ι, ¦, 

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। प्रारूपण के लिए 15 बाइट्स शामिल हैं। स्पष्टीकरण:

Ｆ⁴«

4 बार दोहराएं।

Ｗ∧θ¬Σ§θ±¹

दोहराएँ, जबकि सरणी खाली नहीं है, लेकिन इसकी अंतिम पंक्ति शून्य पर है ...

Σ⊟θ

सरणी से अंतिम पंक्ति निकालें और इसकी राशि की लंबाई की एक पंक्ति प्रिंट करें, अर्थात कुछ भी नहीं।

¿θ≔⮌Ｅ§θ⁰Ｅ觧θνλθ»

यदि सरणी खाली नहीं है, तो उसे स्थानांतरित करें।

⪫[]⪫Ｅθ⪫[]⪫ι, ¦, 

प्रदर्शन के लिए सरणी को अच्छी तरह से प्रारूपित करें। (मानक आउटपुट Ｉθइसके बजाय होगा ।)

Answer 18

जावास्क्रिप्ट, 144 140 129 129 बाइट्स

w=>(t=w=>(q=(s=w=>w.some((r,j)=>r.find(e=>e,i=j))?w.slice(i).reverse():[[]])(s(w)))[0].map((e,j)=>q.map((e,i)=>q[i][j])))(t(w))

140 -> 129 बाइट्स, धन्यवाद @ अरनल्ड

कलन विधि

• दो बार करें:
  • पहली गैर-शून्य पंक्ति खोजें
  • पूर्ववर्ती पंक्तियों को स्लाइस करें
  • रिवर्स
  • पहली गैर-शून्य पंक्ति खोजें
  • पूर्ववर्ती पंक्तियों को स्लाइस करें
  • रिवर्स
  • खिसकाना

f = w=>(t=w=>(q=(s=w=>w.some((r,j)=>r.find(e=>e,i=j))?w.slice(i).reverse():[[]])(s(w)))[0].map((e,j)=>q.map((e,i)=>q[i][j])))(t(w));

w1 = [[0, 0, 0, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1], [0, 0, 1, 1, 1], [0, 0, 0, 0, 0]];
w2 = [[0, 0, 0, 0], [0, 0, 0, 3], [0, 0, 0, 0], [0, 5, 0, 0], [0, 0, 0, 0]];
w3 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
w4 = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]];

console.log(f(w1).join("\n"));
console.log(f(w2).join("\n"));
console.log(f(w3).join("\n"));
console.log(f(w4));

Comments

आप (अब एकल) मुख्य फ़ंक्शन तर्क के आसपास कोष्ठक से छुटकारा पाने के लिए हेल्पर फ़ंक्शन घोषणाओं को पुन: उपयोग करने के बजाय 7 बाइट्स बचा सकते हैं। some/somefindIndex/find

— अरनुलद

मुझे लगता है कि आप 4 और बाइट्स को एस रिटर्न करके बचा सकते हैं, [[]]ताकि टी को चालू करने की गारंटी दी जा सके w[0]।

— अरनुलद

Answer 19

पायथन 2 , 118 116 बाइट्स

f=lambda a,n=4,s=sum:n and f(zip(*a[max(i for i in range(len(a))if s(s(a[:i],()))<1):][::-1]),n-1)or(s(s(a,()))>0)*a

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

---

बचाया:

• -2 बाइट्स, शुकी के लिए धन्यवाद

Comments

आप s=sum

— लैम्बडा

Answer 20

PHP (> = 5.4), 200 194 186 184 बाइट्स

(-6 बाइट्स nullखाली सरणी के बजाय लौटकर )

(-8 बाइट्स टाइटस को धन्यवाद )

( टाइटस के संदर्भ में कॉलिंग के साथ -2 बाइट्स )

function R(&$a){$m=$n=1e9;foreach($a as$r=>$R)foreach($R as$c=>$C)if($C){$m>$r&&$m=$r;$M>$r||$M=$r;$n>$c&&$n=$c;$N>$c||$N=$c;}for(;$m<=$M;)$o[]=array_slice($a[$m++],$n,$N-$n+1);$a=$o;}

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

कैसे?

पंक्तियों ( $mऔर $M) और स्तंभों ( $nऔर $N) के लिए न्यूनतम और अधिकतम सूचकांक ढूँढता है और इनपुट को एक उप सरणी से बदल देता $m,$nहै $M,$N(यह संदर्भ द्वारा एक कॉल है)।

Comments

11 बाइट्स के साथ 6 बाइट्स बचाएंif($C){$m>$r&&$m=$r;$M>$r||$M=$r;$n>$c&&$n=$c;$N>$c||$N=$c;}

— टाइटस

... और दो बाइट्सwhile($m<=$M)$o[]=array_slice($a[$m++],$n,$N-$n+1);

— टाइटस

@ टिट्स: महान सुझावों के लिए धन्यवाद। का उपयोग करने का चाल प्यार किया &&और ||और मैं कर रहा हूँ यकीन है कि मैं अच्छी तरह से अन्य स्थानों में है कि चाल का उपयोग करने में सक्षम हो जाएगा।

— Night2

आप संदर्भ द्वारा कॉल के साथ एक और दो बाइट्स बचा सकते हैं: के $a=बजाय return।

— टाइटस

Answer 21

ऑक्टेव, 48 49 बाइट्स

@(a)sparse(1-min([x y v]=find(a))+x,1-min(y)+y,v)

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

नॉनज़रो पॉइंट ढूंढें और उन्हें एक नए विरल मैट्रिक्स में पुनर्व्यवस्थित करें।

Comments

@alephalpha उत्तर अपडेट किया गया!

— rahnema1

Answer 22

के (ngn / k) , 22 बाइट्स

{4{+|(+/&\~+/x)_'x}/x}

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

Answer 23

जे , 24 बाइट्स

(|.@|:@}.~0=+/@{.)^:4^:_

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

व्याख्या

(|.@|:@}.~0=+/@{.)^:4^:_
            +/                sum
              @               of
               {.             the first row
          0=                  is zero? (1 = true, 0 = false)
       }.~                    chop off that many rows from the front
 |.@|:@                       rotate by 90 deg (transpose then reverse)
(                )^:4         repeat this process 4 times (rotating a total of 360 deg)
                     ^:_      fixpoint - repeat until no change

Answer 24

रूबी , 73 63 बाइट्स

->a{4.times{_,*a=a while a[0]&.sum==0;a=a.reverse.transpose};a}

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

संपादित करें: सरलीकृत, यह भी पिछले संस्करण सभी के लिए दुर्घटनाग्रस्त हो गया 0रों

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

• 4 बार करें:
  • जबकि वहाँ एक पहली पंक्ति है पहली पंक्ति को हटा कर उसे से भरा हुआ है 0रों
  • 90 ° द्वारा सरणी को दक्षिणावर्त घुमाएं
• सरणी वापस करें

Comments

लिंक सही है, लेकिन कोड ब्लॉक में आपका जवाब &.sum<0इसके बजाय कहता है &.sum<1।

— कॉनर ओ'ब्रायन

@ मेरी खराब, नया संस्करण खाली सरणी के लिए काम नहीं किया (nil <1)। वैसे भी ध्यान देने के लिए धन्यवाद

— असोन तुहिद

Answer 25

ऑक्टेव , 78 74 बाइट्स

function x=f(x)
for k=1:nnz(~x)*4,x=rot90(x);x=x(:,~~cumsum(any(x,1)));end

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

व्याख्या

यह मैट्रिक्स को 90डिग्री से घुमाता है ( x=rot90(x)) पर्याप्त संख्या में ( for k=1:... end)। रोटेशन की संख्या कई है 4, इसलिए अंतिम मैट्रिक्स में मूल अभिविन्यास है। विशेष रूप से, घूर्णन 4की संख्या मैट्रिक्स ( nnz(~x)*4) में शून्य की संख्या है ।

प्रत्येक घुमाव के लिए, यदि बाईं ओर एक या एक से अधिक कॉलम होते हैं, जिसमें केवल शून्य होते हैं, तो उन्हें हटा दिया जाता है ( x=x(:,~~cumsum(any(x,1))))।

इस प्रक्रिया के बाद मैट्रिक्स का क्या अवशेष फ़ंक्शन ( function x=f(x)) द्वारा आउटपुट है ।

Answer 26

स्टेक्स , 14 बाइट्स

Ç·W≈y§╗♦º{¬║8•

इसे चलाएं और डीबग करें

वैकल्पिक, 14 बाइट्स भी

Ç·W≈x≈ƒHq♣☻»íÅ

इसे चलाएं और डीबग करें

Answer 27

PHP, 188 बाइट्स

function f(&$a){for($s=array_shift;!max($a[0]);)$s($a);for($p=array_pop;!max(end($a));)$p($a);for($w=array_walk;!max(($m=array_map)(reset,$a));)$w($a,$s);while(!max($m(end,$a)))$w($a,$p);}

संदर्भ द्वारा कॉल करें।

टूट - फूट

// call by reference
function f(&$a)
{
    // while first row is all zeroes, remove it
    while(!max($a[0]))array_shift($a);
    // while last row is all zeroes, remove it
    while(!max(end($a)))array_pop($a);
    // while first column is all zeroes, remove it
    while(!max(array_map(reset,$a)))array_walk($a,array_shift);
    // while last column is all zeroes, remove it
    while(!max(array_map(end,$a)))array_walk($a,array_pop);
}

Answer 28

क्लीन , 73 बाइट्स

import StdEnv,StdLib
$ =dropWhile(all((>)1))o reverse o transpose

$o$o$o$

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

लाइकोनी के हास्केल जवाब के समान ।

Answer 29

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

lambda a,l=1:a if l>4else([a.pop()for b in a if sum(a[-1])<1],f(zip(*a[::-1]),l+1))[1]

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

सूचियों की सूची लेता है, टुपल्स की सूची देता है।

व्याख्या

सूची समझ से बाहर बिल्ली का दुरुपयोग। यह समतुल्य विस्तारित कोड है:

def f(a,l=1):
    # after 4 rotations, the list is back in its original orientation, return
    if l > 4:
        return a
    else:
        # helper variable to store return values
        ret = []
        # "trim" all rows from "bottom" of list that only contain 0s
        # since we are always checking le that item in the list, don't need range(len(a))
        # since we are only removing at most one item per iteration, will never try to remove more than len(a) items
        # brackets surrounding generator force it to be consumed make a list, and therefore actually pop() list items
        ret.append([a.pop() for b in a if sum(a[-1]) < 1])
        # rotate the array, increase the number of rotations, and recursively call this function on the new array/counter
        ret.append(f(zip(*a[::-1]), l + 1)))
        # we only put both items in a list in order to stay in the one-line lambda format
        # discard the popped items and return the value from the recursive call
        return ret[1]

Answer 30

जाप -h , 23 11 बाइट्स

4Æ=sUb_dà z

कोशिश करो

---

व्याख्या

                :Implicit input of 2D-array U
4Æ              :Map the range [0,4)
   s            :  Slice U from
    Ub          :   The first index in U where
      _dà      :    Any element is truthy (not zero)
          z     :  Rotate 90 degrees
  =             :  Reassign to U for the next iteration
                :Implicitly output the last element