9

यह प्रश्न एक ग्रिड में सबसे बड़े वर्ग के समान है ।

चुनौती

के एक मैट्रिक्स को देखते हुए 1और 0एक स्ट्रिंग स्वरूप में "xxxx,xxxxx,xxxx,xx.."या सरणी प्रारूप ["xxxx","xxxx","xxxx",...], आप एक समारोह है कि सबसे बड़ा वर्ग submatrix कि सभी शामिल हैं के क्षेत्र को निर्धारित करता है पैदा करेगा 1।

एक वर्ग सबमेट्रिक्स समान चौड़ाई और ऊंचाई में से एक है, और आपके फ़ंक्शन को सबसे बड़े सबमेट्रिक्स के क्षेत्र को वापस करना चाहिए जिसमें केवल शामिल हैं 1।

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

यह देखते हुए "10100,10111,11111,10010", यह निम्नलिखित मैट्रिक्स की तरह दिखता है:

१ ० १ १ ० ०

१ ० १ १ १ १

१ १ १ १ १ १

१ ० ० १ १ ०

आप 1बड़े आकार के 2x2 का सबसे बड़ा वर्ग सबमेट्रिक्स बनाकर देख सकते हैं , इसलिए आपके प्रोग्राम को वह क्षेत्र वापस करना चाहिए जो 4 है।

नियम

Submatrix समान चौड़ाई और ऊंचाई में से एक होना चाहिए
सबमेट्रिक्स में केवल मान शामिल होने चाहिए 1
आपके फ़ंक्शन को सबसे बड़े सबमेट्रिक्स का क्षेत्र वापस करना होगा
यदि कोई सबमेट्रिक्स नहीं मिला है, तो वापस लौटें 1
आप की संख्या की गणना submatrix के क्षेत्रफल की गणना कर सकते हैं 1submatrix में

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

इनपुट: "10100,10111,11111,10010" आउटपुट: 4

इनपुट: "0111,1111,1111,1111" आउटपुट: 9

इनपुट "0111,1101,0111" आउटपुट: 1

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

code-golf matrix

— लुइस फेलिप डी जीसस मुनोज
स्रोत

3

स्ट्रिंग प्रारूप क्यों?

— स्टीवी ग्रिफिन

3

क्या हम इनपुट को बाइनरी (न्यूमेरिक) मैट्रिक्स के रूप में ले सकते हैं?

— स्टिव ग्रिफिन

5

[०] के लिए अभी भी १ आउटपुट की आवश्यकता है?

— l4m2

6

इसके बारे में लटकाएं, 1 वापस क्यों करें जब कोई सब -1 सब-मैट्रिक्स नहीं मिला है, तो 0 अधिक अर्थ नहीं देगा? (अन्यथा यह केवल एक विशेष मामला है)

— जोनाथन एलन

2

जैसा कि यह खड़ा है मुझे लगता है कि यदि आप चश्मा बदल देते हैं तो दोनों उत्तर देने वाले को बुरा नहीं लगेगा और मैं दृढ़ता से ऐसा करने की सलाह देता हूं क्योंकि 1 लौटने का कोई मतलब नहीं है और यह सबमिशन को अधिक दिलचस्प नहीं बनाता है।

— ।

2

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

_{+2 नो-ऑल -1 सबलिस्ट वर्तमान आउटपुट को संभालने के लिए}

ẆZṡ¥"L€$ẎȦÐfL€Ṁ²»1

इसे ऑनलाइन आज़माएं! या परीक्षण-सूट देखें

कैसे?

ẆZṡ¥"L€$ẎȦÐfL€Ṁ²»1 - Link: list of lists of 1s and 0s
Ẇ                  - all slices (lists of "rows") call these S = [s1,s2,...]
       $           - last two links as a monad:
     L€            -   length of each (number of rows in each slice) call these X = [x1, x2, ...]
    "              -   zip with (i.e. [f(s1,x1),f(s2,x2),...]):
   ¥               -     last two links as a dyad:
 Z                 -       transpose (get the columns of the current slice)
  ṡ                -       all slices of length xi (i.e. squares of he slice)
        Ẏ          - tighten (to get a list of the square sub-matrices)
          Ðf       - filter keep if:
         Ȧ         -   any & all (all non-zero when flattened?)
            L€     - length of €ach (the side length)
              Ṁ    - maximum
               ²   - square (the maximal area)
                »1 - maximum of that and 1 (to coerce a 0 found area to 1)

— जोनाथन एलन
स्रोत

बहुत बढ़िया। क्या आप कुछ स्पष्टीकरण जोड़ सकते हैं?

— लुइस फेलिप डी जीसस मुनोज़

मैं करूंगा, मैं पहले छोटे से सोचने की कोशिश कर रहा हूं ...

— जोनाथन एलन

@ Mr.Xcoder मैंने अब के लिए आवश्यकता को संभालने के लिए अपडेट किया है

— जोनाथन एलन

5

हास्केल , 113 121 118 117 बाइट्स

x!s=[0..length x-s]
t#d=take t.drop d
f x=last$1:[s*s|s<-min(x!0)$x!!0!0,i<-x!!0!s,j<-x!s,all(>'0')$s#i=<<(s#j)x,s>0]

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

_{-3 बाइट्स लाईकोनी के लिए धन्यवाद !}

_{-1 बाइट की बदौलत लिन !}

_{सभी-1 एस उप-मैट्रिक्स के लिए 1 वापस करने की हास्यास्पद आवश्यकता के लिए +8 बाइट्स ।।}

स्पष्टीकरण / Ungolfed

निम्नलिखित हेल्पर फंक्शन सिर्फ xउनके द्वारा क्षय करने की अनुमति के लिए ऑफसेट बनाता है s:

x!s=[0..length x-s]

x#yyतत्वों को सूची से हटा देगा और फिर ले जाएगा x:

t#d=take t.drop d

फ़ंक्शन fक्रम में उप-मैट्रिसेस के लिए सभी संभावित आकारों पर लूप करता है, संबंधित आकार के प्रत्येक उप-मैट्रिक्स को उत्पन्न करता है, परीक्षण करता है कि क्या इसमें केवल '1's है और आकार को संग्रहीत करता है। इस प्रकार समाधान सूची में अंतिम प्रविष्टि होगी:

--          v prepend a 1 for no all-1s submatrices
f x= last $ 1 : [ s*s
                -- all possible sizes are given by the minimum side-length
                | s <- min(x!0)$x!!0!0
                -- the horizontal offsets are [0..length(x!!0) - s]
                , i <- x!!0!s
                -- the vertical offsets are [0..length x - s]
                , j <- x!s
                -- test whether all are '1's
                , all(>'0') $
                -- from each row: drop first i elements and take s (concatenates them to a single string)
                              s#i =<<
                -- drop the first j rows and take s from the remaining
                                      (s#j) x
                -- exclude size 0...........................................
                , s>0
                ]

— ბიმო
स्रोत

4

हास्केल , 99 97 बाइट्स

b s@((_:_):_)=maximum$sum[length s^2|s==('1'<$s<$s)]:map b[init s,tail s,init<$>s,tail<$>s]
b _=1

जाँच करता है कि क्या इनपुट सिर्फ लोगों का एक वर्ग मैट्रिक्स है s==('1'<$s<$s), अगर यह है, तो उत्तर ^ 2 है, बाकी 0. फिर पहले / अंतिम कॉलम / पंक्ति को पुनरावर्ती रूप से काटता है और अधिकतम मूल्य लेता है जो इसे कहीं भी पाता है।

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

— Angs
स्रोत

3

के (ngn / k) , ३३ २tes बाइट्स

{*/2#+/|/',/'{0&':'0&':x}\x}

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

— NGN
स्रोत

मुझे कभी नहीं पता था कि आपके पास K संस्करण था!

— Zacharý

3

जे , 33 27 बाइट्स

-6 बाइट्स FrownyFrog के लिए धन्यवाद!

[:>./@,,~@#\(#**/)@,;._3"$]

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

स्पष्टीकरण:

मैं अपने स्पष्टीकरण में पहले परीक्षण के मामले का उपयोग करूंगा:

    ] a =. 3 5$1 0 1 0 0 1 0 1 1 1 1 1 1 1 1 1 0 0 1 0
1 0 1 0 0
1 0 1 1 1
1 1 1 1 1

मैं 1 से इनपुट की पंक्तियों की संख्या के साथ सभी संभव वर्ग सबमेट्रिसेस उत्पन्न करता हूं।

,~@#\इनपुट ,.के क्रमिक उपसर्गों #\की लंबाई को टांके लगाकर उपमाओं के आकार के लिए जोड़े की एक सूची बनाता है :

   ,~@#\ a
1 1
2 2
3 3

तब मैं उन्हें x u ;. _3 yइनपुट को सबमेट्रिसेस में काटने के लिए उपयोग करता हूं । मेरे पास पहले से ही x(आकारों की सूची) है; yसही तर्क ](इनपुट) है।

 ((,~@#\)<;._3"$]) a
┌─────┬─────┬─────┬───┬─┐
│1    │0    │1    │0  │0│
│     │     │     │   │ │
│     │     │     │   │ │
├─────┼─────┼─────┼───┼─┤
│1    │0    │1    │1  │1│
│     │     │     │   │ │
├─────┼─────┼─────┼───┼─┤
│1    │1    │1    │1  │1│
└─────┴─────┴─────┴───┴─┘

┌─────┬─────┬─────┬───┬─┐
│1 0  │0 1  │1 0  │0 0│ │
│1 0  │0 1  │1 1  │1 1│ │
│     │     │     │   │ │
├─────┼─────┼─────┼───┼─┤
│1 0  │0 1  │1 1  │1 1│ │
│1 1  │1 1  │1 1  │1 1│ │
├─────┼─────┼─────┼───┼─┤
│     │     │     │   │ │
└─────┴─────┴─────┴───┴─┘

┌─────┬─────┬─────┬───┬─┐
│1 0 1│0 1 0│1 0 0│   │ │
│1 0 1│0 1 1│1 1 1│   │ │
│1 1 1│1 1 1│1 1 1│   │ │
├─────┼─────┼─────┼───┼─┤
│     │     │     │   │ │
│     │     │     │   │ │
├─────┼─────┼─────┼───┼─┤
│     │     │     │   │ │
└─────┴─────┴─────┴───┴─┘

प्रत्येक सबमेट्रिक्स के लिए मैं जांचता हूं कि क्या यह पूरी तरह से 1s से मिलकर बनता है: (#**/)@,- मैट्रिक्स को समतल करें, और अपने उत्पाद द्वारा आइटमों की संख्या को बदल दें। यदि सभी आइटम 1s हैं, तो परिणाम उनकी राशि होगा, अन्यथा - 0:

   (#**/)@, 3 3$1 0 0 1 1 1 1 1 1
0
   (#**/)@, 2 2$1 1 1 1
4 

   ((,~@#\)(+/**/)@,;._3"$]) a
1 0 1 0 0
1 0 1 1 1
1 1 1 1 1

0 0 0 0 0
0 0 4 4 0
0 0 0 0 0

0 0 0 0 0
0 0 0 0 0
0 0 0 0 0

अंत में मैं प्रत्येक सबमेट्रिक्स के परिणामों की सूची को समतल करता हूं और अधिकतम पाता हूं:

>./@,

   ([:>./@,,~@#\(+/**/)@,;._3"$]) a
4

— गैलेन इवानोव
स्रोत

1

,~@#\और "1 2->"$

— फ्रोवनीफ्रॉग

@FrownyFrog धन्यवाद! मुझे पता नहीं था"$

— गैलेन इवानोव

1

#1s को जोड़ने से कम है।

— FrownyFrog

@ FrownyFrog हम्म, यह वास्तव में है। अच्छा है धन्यवाद!

— गेलन इवानोव

3

एपीएल (डायलॉग यूनिकोड) , 35 34 32 बाइट्स

{⌈/{×⍨⍵×1∊{∧/∊⍵}⌺⍵ ⍵⊢X}¨⍳⌊/⍴X←⍵}

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

Adám के SBCS में सभी वर्ण हैं

अंततः आ रहा स्पष्टीकरण!

— जाकारी
स्रोत

2

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

%`$
,;#
+%(`(\d\d.+;#)#*
$1¶$&¶$&#
\G\d(\d+,)|\G((;#+¶|,)\d)\d+
$1$2
)r`((11)|\d\d)(\d*,;?#*)\G
$#2$3
1,
#
Lv$`(#+).*;\1
$.($.1*$1
N`
-1G`
^$
1

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। इनपुट को अल्पविराम द्वारा अलग किए गए तार के रूप में लेता है। स्पष्टीकरण:

%`$
,;#

एक जोड़े ,एक अंतिम स्ट्रिंग समाप्त करने के लिए, ;से तार को अलग करने #और एक #एक काउंटर के रूप में।

+%(`
)

ब्लॉक को तब तक दोहराएं जब तक कि अधिक सबसिस्टम न हो जाएं (क्योंकि प्रत्येक स्ट्रिंग अब केवल एक अंक लंबा है)।

(\d\d.+;#)#*
$1¶$&¶$&#

पहली पंक्ति पर काउंटर को 1 पर सेट करना और अंतिम पंक्ति में इसे बढ़ाना, लाइन को तीन गुना करना।

\G\d(\d+,)|\G((;#+¶|,)\d)\d+
$1$2

पहली पंक्ति पर, प्रत्येक स्ट्रिंग के पहले अंक को हटाएं, जबकि दूसरी पंक्ति पर, सभी अंकों को हटाएं लेकिन पहला।

r`((11)|\d\d)(\d*,;?#*)\G
$#2$3

तीसरी पंक्ति में, बिटवाइज़ और पहले दो अंक एक साथ।

1,
#

इस बिंदु पर, प्रत्येक पंक्ति में दो मान होते हैं, a) एक क्षैतिज चौड़ाई काउंटर और b) प्रत्येक स्ट्रिंग से ली गई बिटवाइज़ और उसमें से कई बिट्स। किसी भी बचे हुए 1s को कन्वर्ट करें #ताकि उनकी तुलना काउंटर से की जा सके।

Lv$`(#+).*;\1
$.($.1*$1

बिट्स (लंबवत) के किसी भी रन का पता लगाएं जो काउंटर से (क्षैतिज रूप से) मेल खाता है 1, मूल इनपुट में एस के वर्गों के अनुरूप है , और लंबाई वर्ग।

N`

संख्यात्मक रूप से क्रमबद्ध करें।

-1G`

सबसे बड़ा लो।

^$
1

विशेष — शून्य मैट्रिक्स।

— नील
स्रोत

2

जावास्क्रिप्ट, 92 बाइट्स

a=>(g=w=>a.match(Array(w).fill(`1{${w}}`).join(`..{${W-w}}`))?w*w:g(w-1))(W=a.indexOf`,`)||1

कोड स्निपेट दिखाएं

f=
a=>(g=w=>a.match(Array(w).fill(`1{${w}}`).join(`..{${W-w}}`))?w*w:g(w-1))(W=a.indexOf`,`)||1
console.log(f('0111,1111,1111,1111'));
console.log(f('10100,10111,11111,10010'));
console.log(f('0111,1101,0111'));

स्निपेट का विस्तार करें

— TSH
स्रोत

2

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

×⍨{1∊⍵:1+∇2×/2×⌿⍵⋄0}

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

— NGN
स्रोत

प्रत्यावर्तन! अच्छा!

— ज़ाचरी

@ Zacharý धन्यवाद। वास्तव में, मैं पुनरावृत्ति के बजाय एक सनक के लिए कश्मीर के f \ x जैसा कुछ पसंद करूंगा, जो कि अभिसरण तक (x; fx; ffx; ...) है, लेकिन APL (अभी तक) में कोई समान नहीं है। इसे ing के साथ करने से बहुत सारे बाइट्स होते हैं।

— ngn

2

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

@ एक अतिरिक्त अक्षमता की लागत को इंगित करने के लिए @etene को श्रेय।

lambda s:max(i*i for i in range(len(s))if re.search(("."*(s.find(',')-i+1)).join(["1"*i]*i),s))or 1
import re

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

इनपुट को अल्पविराम से अलग स्ट्रिंग के रूप में लेता है। यह एक रेगेक्स-आधारित दृष्टिकोण है जो 111.....111.....111वर्ग के सभी संभावित आकारों के लिए फार्म के पैटर्न के खिलाफ इनपुट स्ट्रिंग के मिलान की कोशिश करता है ।

मेरी गणना में, एक अनाम लंबोदर के साथ ऐसा करना परिभाषित कार्य या पूर्ण कार्यक्रम की तुलना में सिर्फ एक बालक छोटा है। or 1अंत में भाग अजीब बढ़त मामले में, जहां हम चाहिए उत्पादन को संभालने के लिए केवल आवश्यक है 1, अगर वहाँ इनपुट में कोई होते हैं।

— किरिल एल।
स्रोत

2

पायथन 2 , 116 115 117 109 बाइट्स

@Kirill को मेरी मदद करने के लिए श्रेय यह गोल्फ और भी अधिक और अपने चतुर और प्रारंभिक समाधान के लिए

संपादित करें : लैम्ब्डा का उपयोग करके 1 बाइट को गॉकेट किया गया, मुझे नहीं पता था कि इसे एक वैरिएबल को असाइन करना बाइट काउंट की ओर नहीं गिना जाता।

संपादित करें 2 : किरिल ने बताया कि मेरा समाधान उन मामलों के लिए काम नहीं करता है जहां इनपुट में केवल 1एस होता है , मुझे इसे ठीक करना था और दो कीमती बाइट्स खो दिया था ...

संपादित 3 : किरिल के लिए और अधिक गोल्फ धन्यवाद

अल्पविराम से अलग स्ट्रिंग लेता है, पूर्णांक देता है।

lambda g:max(i*i for i in range(len(g))if re.search(("."*(g.find(",")+1-i)).join(["1"*i]*i),g))or 1
import re

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

मुझे स्वतंत्र रूप से एक उत्तर मिला जो कि किरिल के एक के करीब है, यानी रेगेक्स आधारित, सिवाय इसके कि मैं उपयोग करता हूं re.search ~~और एdef~~ ।

यह एक वृहद रूप से बड़े वर्ग से मेल करने के लिए प्रत्येक लूप के दौरान बनाए गए रेगेक्स का उपयोग करता है और सबसे बड़ा या 1 देता है।

— etene
स्रोत

1

अच्छा है, मैं किसी भी तरह से if"निश्चित रूप से बहुत लंबा" के रूप में दृष्टिकोण को स्वचालित रूप से खारिज कर देता हूं , लेकिन फिर मैच से बाहर एक बूल मूल्य बनाने के लिए कुछ और तरीका बनाना पड़ा। दुर्भाग्य से, आपका समाधान एक बिंदु याद करता है - आपके पास बस नहीं हो सकता है range(l)- यह उस मामले को याद करेगा जब कोई शून्य नहीं हैं। जैसे, 2nd टेस्ट केस लें और इसे सभी 1s करें - यह 16 हो जाना चाहिए, 9. नहीं

— Kirill L.

धिक्कार है, मैंने सभी ज़ीरो के साथ परीक्षण के बारे में सोचा लेकिन सभी के साथ नहीं (चुनौती में उल्लेख नहीं किया गया ...)। मैं कुछ बनाने की कोशिश करूंगा।

— इथेन

@KirillL। वैसे, आप तेज़ हैं! मैं अभी भी अपने जवाब पर काम कर रहा था जब आपने अपना पोस्ट किया था और थोड़ा चकरा गया था (और गर्व!) जब मैंने देखा कि हमारे दृष्टिकोण समान थे ... यहां का स्तर प्रभावशाली है।

— इथेन

1

नकल से छुटकारा पाकर कुछ और बाइट्स हासिल की find। अब क्योंकि हमारे कोड अब समान नहीं हैं, मेरा सुझाव है कि हम कम से कम एक दूसरे से स्पष्ट गलतियों को ठीक करें - आपके मामले में अतिरिक्त बाइट ("1"*i,)सूची के बजाय टपल का उपयोग करने से आती है ।

— किरिल एल।

धन्यवाद, हाँ बेकार टपल मेरे हिस्से पर बहुत बेवकूफ है। और अतिरिक्त findभी, जो आप के लिए चतुर था।

— इथेन

2

रूबी `-n` , 63 बाइट्स

p (1..l=$_=~/,|$/).map{|i|/#{[?1*i]*i*(?.*(l-i+1))}/?i*i:1}.max

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

मेरे पायथन जवाब का रूबी संस्करण । एक पूर्ण कार्यक्रम के रूप में गोल्फर। वैकल्पिक रूप से, एक अनाम लंबोदर:

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

->s{(1..l=s=~/,|$/).map{|i|s=~/#{[?1*i]*i*(?.*(l-i+1))}/?i*i:1}.max}

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

— किरिल एल।
स्रोत

1

पर्ल 6 , 61 60 58 बाइट्स

{(^$_ X.. ^$_).max({[~&](.[|$^r||*])~~/$(1 x$r)/&&+$r})²}

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

— nwellnhof
स्रोत

1

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

def f(m):j=''.join;L=j(m);k=map(j,zip(*m));return len(L)and max(len(L)*(len(m)**2*'1'==L),f(k[1:]),f(k[:-1]),f(m[1:]),f(m[:-1]))

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

बचाया

-10 बाइट्स ओव्स के लिए धन्यवाद

— TFeld
स्रोत

1

क्लोजर, 193 बाइट्स

#(apply max(for [f[(fn[a b](take-while seq(iterate a b)))]R(f next %)R(f butlast R)n[(count R)]c(for[i(range(-(count(first R))n -1)):when(apply = 1(for[r R c(subvec r i(+ i n))]c))](* n n))]c))

वाह, बातें बढ़ी: ओ

कम गोल्फ वाला:

(def f #(for [rows (->> %    (iterate next)    (take-while seq)) ; row-postfixes
              rows (->> rows (iterate butlast) (take-while seq)) ; row-suffixes
              n    [(count rows)]
              c    (for[i(range(-(count(first rows))n -1)):when(every? pos?(for [row rows col(subvec row i(+ i n))]col))](* n n))] ; rectangular subsections
          c))

— NikoNyrh
स्रोत

सबसे बड़ा वर्ग

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

कैसे?

हास्केल , 113 121 118 117 बाइट्स

स्पष्टीकरण / Ungolfed

हास्केल , 99 97 बाइट्स

के (ngn / k) , ३३ २tes बाइट्स

जे , 33 27 बाइट्स

स्पष्टीकरण:

एपीएल (डायलॉग यूनिकोड) , 35 34 32 बाइट्स

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

जावास्क्रिप्ट, 92 बाइट्स

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

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

पायथन 2 , 116 115 117 109 बाइट्स

रूबी -n , 63 बाइट्स

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

पर्ल 6 , 61 60 58 बाइट्स

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

क्लोजर, 193 बाइट्स

रूबी `-n` , 63 बाइट्स