उस विचलित पृष्ठभूमि को ट्रिम करें!

Question

जब आप तस्वीर ले रहे हों तो क्या यह गुस्सा नहीं है, लेकिन पृष्ठभूमि छवि के वास्तविक पदार्थ से अलग है? मैं कहूंगा कि यह है। मुझे यह जानने की जरूरत है कि मुझे कितनी फसल लेनी चाहिए ताकि मुझे इस समस्या से छुटकारा मिले! लेकिन - हमेशा की तरह - मैं काफी आलसी हूं, इसलिए मुझे मेरे लिए ऐसा करने की जरूरत है ...

कार्य और नियम

छवि का प्रतिनिधित्व करने वाले एक बाइनरी मैट्रिक्स को देखते हुए, मूल मैट्रिक्स में सभी $1$ एस वाले सबसे छोटे उप-मैट्रिक्स के आयाम (चौड़ाई और ऊंचाई) का उत्पादन करते हैं । एक उप-मैट्रिक्स मूल मैट्रिक्स से आसन्न प्रविष्टियों का एक ब्लॉक है। समान रूप से, यह आसन्न पंक्तियों के सबसेट और मूल के आसन्न स्तंभों के सबसेट को ओवरलैप करके एक नया मैट्रिक्स है।

• यह मैट्रिक्स की चौड़ाई और ऊंचाई को इनपुट के रूप में भी लेने की अनुमति है।
• इनपुट में कम से कम एक $1$ होने की गारंटी है ।
• आप इनपुट ले सकते हैं और किसी भी मानक विधि के माध्यम से आउटपुट प्रदान कर सकते हैं , जबकि ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है। यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स में आप अपनी पसंद की भाषा में कार्य को पूरा करने का प्रयास कर सकते हैं ।

उदाहरण

$$\left[\begin{matrix} \color{red}0&\color{red}0&\color{red}0&\color{red}0&\color{red}0&\color{red}0\\ \color{red}0&\color{blue}1&\color{blue}0&\color{blue}1&\color{blue}0&\color{blue}0\\ \color{red}0&\color{blue}1&\color{blue}1&\color{blue}0&\color{blue}1&\color{blue}1\\ \color{red}0&\color{blue}0&\color{blue}1&\color{blue}0&\color{blue}1&\color{blue}0\\ \color{red}0&\color{red}0&\color{red}0&\color{red}0&\color{red}0&\color{red}0\end{matrix}\right] \longrightarrow \left[\begin{matrix}1&0&1&0&0\\1&1&0&1&1\\0&1&0&1&0\end{matrix}\right]\longrightarrow(5,3)$$

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

इनपुट | उत्पादन

[[0,1,0,0,0,1,0]]
-> (5,1) या (1,5)

[[0,0,0,0,0], [0,1,0,1,0], [0,0,1,0,0]]
-> (3,2) या (2,3)

[[1,1,1,1], [0,0,0,0], [0,0,0,0], [1,0,0,0]]
-> (4,4)

[[0,0,0,0,0,0], [0,1,0,1,0,1], [0,0,0,0,0,0]]
-> (5,1) या (1,5)

[[0,0,0,0,0], [0,1,0,1,0], [0,0,1,0,0], [0,1,0,1,0], [ 0,0,0,0,0]]
- (3,3)

[[0,0,0,0,0,0], [0,1,0,1,0,0], [0,1,1,0,1,1], [0,0,1, 0,1,0], [0,0,0,0,0,0]]
-> (5,3) या (3,5)

Comments

यह बहुत परिचित लगता है ; क्या यह कुछ समय के लिए सैंडबॉक्स में था?

— झबरा

यह वास्तव में लिंक किए गए प्रश्न के बहुत करीब है, लेकिन मुझे लगता है कि इसे दूर का सबसे उपसमुच्चय माना जा सकता है क्योंकि मैट्रिक्स का निर्माण वास्तविक चौड़ाई और ऊंचाई की गणना के लिए बिल्कुल आवश्यक नहीं है। उदाहरण के लिए, एक संभव एल्गोरिथ्म प्रत्येक पंक्ति और स्तंभ के लिए सीमांत शून्य की न्यूनतम संख्या की गणना करना और मूल आयामों से उन्हें घटाना होगा।

— मिस्टर एक्सकोडर

संबंधित - बाउंडिंग बॉक्स को हाइलाइट करें, भाग I: कार्टेशियन ग्रिड

— जोनाथन एलन

Answer 1

MATL , 5 बाइट्स

JYaZy

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

व्याख्या

JYa   % Implicit input. Unpad matrix. This removes outer zeros
Zy    % Size. Implicit display

Comments

सभी मैं देख रहा हूँ याहत्ज़ी ।

— दोष

Answer 2

एपीएल (Dyalog यूनिकोड) , 10 बाइट्स ^SBCS

बेनामी tacit उपसर्ग समारोह।

(1+⌈/-⌊/)⍸

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

⍸ 1s के सूचकांक।

(… ) उस के लिए निम्नलिखित tacit फ़ंक्शन लागू करें:

 ⌊/ न्यूनतम (सबसे कम y समन्वय और सबसे कम x समन्वय)

 ⌈/- अधिकतम माइनस जो (यह हमें सीमा देता है)

 1+ एक प्लस (समावेशी होने के लिए)

Answer 3

ऑक्टेव , 57 56 45 बाइट्स

यहाँ findहैवी लिफ्टिंग: यह findsनॉनज़ेरो प्रविष्टियों की पंक्ति और कोलम इंडेक्स है। फिर हमें बस उन प्रत्येक में से अधिकतम और न्यूनतम (प्लस एक) के बीच अंतर खोजना होगा।

थैंक्स @beaker और @AndrasDeak -1 बाइट के लिए, और @LuisMendo for -11 बाइट्स!

@(a){[I{1:2}]=find(a),cellfun(@range,I)}{2}+1

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

Answer 4

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

def f(a,L=len):exec"a=zip(*a[1-any(a[0]):])[::-1];"*4*L(a[0])*L(a);return L(a[0]),L(a)

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

Answer 5

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

S,§t€0Ẉ

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

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

S,§t€0Ẉ  Main link. Argument: M (matrix)

S        Take the columnwise sum. Let's call the resulting array A.
  §      Take the sum of each row. Let's call the resulting array B.
 ,       Pair; yield [A, B].
   t€0   Trim surrounding zeroes of A and B.
      Ẉ  Widths; yields the lengths of the trimmed arrays.

Answer 6

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

-8 विन्सेंट की मदद से (इनपुट मैट्रिक्स को एक Numpy सरणी के रूप में लें)

lambda a:[len(`a.max(x)`[7::3].strip('0'))for x in 0,1]

एक अनाम फ़ंक्शन {0,1}जो पूर्णांक की एक सूची लौटाता है, पूर्णांक के 2-डी Numpy सरणी को स्वीकार करता है [width,height]।

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

---

63 बाइट्स में नॉन-नेम्पी संस्करण (पूर्णांकों की सूची की सूची को स्वीकार करना {0,1}):

lambda a:[len(`map(max,v)`[1::3].strip('0'))for v in zip(*a),a]

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

कैसे?

एक मैट्रिक्स को देखते हुए a, forप्रत्येक ( v) के स्थानान्तरण zip(*a), औरa स्वयं हम आवश्यक ऊँचाई पाते हैं (यह ट्रांज़ोज़ यह चौड़ाई है)।

मानचित्रण maxभर में vपैदावार शून्य और की एक सूची, का प्रतिनिधित्व करता है, तो की प्रत्येक पंक्ति के vकिसी भी लोगों में शामिल है। इस सूची का स्ट्रिंग निरूपण backticks ( `...`) का उपयोग करके पाया जाता है , यह एक अग्रणी के साथ एक स्ट्रिंग देता है [, फिर शून्य , ( और अंतरिक्ष) द्वारा सीमांकित किया जाता है । हम [1::3]केवल तीन शून्य और लोगों की एक स्ट्रिंग का उपयोग करके तीन के चरणों में सूचकांक एक पर शुरू होने वाले इस स्ट्रिंग को स्लाइस करते हैं, जो हमें stripबाहरी शून्य ( strip('0')) को हटाने के लिए स्ट्रिंग फ़ंक्शन का उपयोग करने की अनुमति देता है ।

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

      a = [[0,0,0,0,0]           map(max,a)                    = [0,1,1]
          ,[0,1,0,0,0]          `map(max,a)`[1::3]             = '011'
          ,[0,0,0,1,0]]         `map(max,a)`[1::3].strip('0')  = '11'
                            len(`map(max,a)`[1::3].strip('0')) = 2

zip(*a) = [(0,0,0)         map(max,zip(*a))                    = [0,1,0,1,0]
          ,(0,1,0)        `map(max,zip(*a))`[1::3]             = '01010'
          ,(0,0,0)        `map(max,zip(*a))`[1::3].strip('0')  = '101'
          ,(0,0,1)    len(`map(max,zip(*a))`[1::3].strip('0')) = 3
          ,(0,0,0)]

    --> [len(`map(max,v)`[1::3].strip('0'))for v in zip(*a),a] = [3,2]

Comments

57 बाइट्स को एक सुरीले सरणी का उपयोग करके।

— विन्सेन्ट

यदि हम इनपुट को एक गैर-निर्मित प्रकार के रूप में लेते हैं, तो क्या हमें ऐसा करने के लिए किसी प्रकार के आयात विवरण की गणना नहीं करनी चाहिए? (यह सिर्फ इतना हो सकता है कि हमें पोस्ट को "अजगर 2 के साथ सुन्न" के रूप में शीर्षक देना होगा - मैं पूरी तरह से निश्चित नहीं हूं) ... यदि आपके पास कुछ समय हो सकता है तो आप उन्नीसवीं बाइट चैट रूम में पूछ सकते हैं?

— जोनाथन एलन

... 55 बाइट भी सही?

— जोनाथन एलन

मैं वास्तव में पीपीसीजी मेटा पर एक स्पष्ट जवाब नहीं पा सका , इसलिए मुझे इस बारे में निश्चित नहीं है। और हाँ, 55 बाइट्स वास्तव में :)

— विन्सेन्ट

मैंने बस पूछा। इस पोस्ट के अनुसार , आयात को शामिल करने की आवश्यकता नहीं है।

— विन्सेन्ट

Answer 7

रेटिना 0.8.2 , 83 बाइट्स

+`^0+¶|¶0+$

+1`((.)*).(¶(?<-2>.)*).(?<=(1)¶.*|(.))
$1$3$4$5
(¶?)*0*(.*1)0*
$#1 $.2

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

+`^0+¶|¶0+$

प्रमुख और अनुगामी शून्य पंक्तियों को हटाएं।

+1`((.)*).(¶(?<-2>.)*).(?<=(1)¶.*|(.))
$1$3$4$5

0आखिरी के ऊपर की तर्ज पर सभी एस निकालें । सभी 1एस दो को हटा दें , लेकिन अगली पंक्ति 1में उस स्थिति में नीचे दिए गए अंकों को बदल दें । यह बिटवाइज़ या एक साथ पंक्तियाँ।

(¶?)*0*(.*1)0*
$#1 $.2

पहले और अंतिम 1 के बीच अंकों की संख्या के रूप में संख्या की संख्या और 1 के रूप में कॉलम की संख्या की गणना करें।

Answer 8

जे , 31 बाइट्स

[:$([:|.@|:}.^:(0=1#.{.))^:4^:_

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

स्पष्टीकरण:

                            ^:_ - repeat until the result stops changing
   (                    )^:4    - repeat 4 times
             ^:(        )       - is
                  1#.           - the sum of
                      {.        - the first row
                 =              - equal 
                0               - to 0
           }.                   - if yes, drop the first row
    [:|.@|:                     - transpose and reverse (rotate 90 degrees) 
[:$                             - what's the shape of the result?

Answer 9

क्यू / केडीबी +, १६ बाइट्स

sum@'(|/;|/')@\:

Answer 10

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

Max@#-Min@#+1&/@(#~Position~1)&

शुद्ध कार्य। पूर्णांक की एक नेस्टेड सूची को इनपुट के रूप में लेता है, और आउटपुट के रूप में दो पूर्णांक (चौड़ाई के बाद की ऊंचाई) की एक सूची देता है। यूनिकोड वर्ण U + F3C7 है \[Transpose]।

Answer 11

आर , 48 46 बाइट्स

function(m)1+diff(apply(which(m>0,T),2,range))

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

Giuseppe द्वारा बचाए गए -2 बाइट्स।

Answer 12

05AB1E , 11 9 बाइट्स

ζ‚Oε0Û0Üg

-2 बाइट्स @ Mr.Xcoder को धन्यवाद ।

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

स्पष्टीकरण:

ζ            # Swap the rows and columns of the (implicit) input-list
 ‚           # Pair it with the (implicit) input-list
  O          # Take the sum of each column and row
   ε         # Map Both the list of column-sums and list of row-sums to:
    0Û       #  Remove all leading zeros
      0Ü     #  Remove all trailing zeros
        g    #  Take the length of the remaining lists

Comments

ζ‚Oε0Û0Üg2 बाइट्स बचाता है।

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

@ Mr.Xcoder आह, बिल्कुल। मैं पहले से ही उस स्वैप के बारे में बहुत खुश नहीं था। विश्वास नहीं कर सकता कि मैंने इस जोड़ी को पहले और योग से करने के बारे में नहीं सोचा था।>>।>

— केविन क्रूज़सेन

Answer 13

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

ŒṪZṀ_ṂƊ€‘

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

Answer 14

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

f x=length.s.reverse.s<$>[foldr(zipWith(:))e x,x]
e=[]:e
s=snd.span(all(<1))

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

Answer 15

जाप, 16 15 बाइट्स

[UUy]®=ðd)ÎaZÌÄ

इसे आज़माएं या सभी परीक्षण मामलों को चलाएं

---

व्याख्या

[   ]               :Create an array containing
 U                  : The input and
  Uy                : The input transposed
     ®              :Map each Z
       ð            : Indices of elements where
        d           :  Any element is truthy (not 0)
      =  )          : Reassign to Z
          Î         : First element
           a        : Absolute difference with
            ZÌ      :  Last element
              Ä     :   Plus 1

Answer 16

रूबी , 60 बाइट्स

->m{[m,m.transpose].map{|x|x.map(&:max).join[/1.*/]=~/0*$/}}

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