पृष्ठभूमि

मैं जमीन का एक प्लॉट खरीदना चाहता हूं और उस पर अपना घर बनाना चाहता हूं। मेरा घर आयताकार होना चाहिए, और जितना संभव हो उतना बड़ा; हालाँकि, उपलब्ध भूखंडों में बहुत सारे चट्टानी क्षेत्र हैं जिन पर मैं निर्माण नहीं कर सकता, और मुझे भूखंडों पर एक संभावित घर की फिटिंग करने में परेशानी हो रही है। मैं चाहता हूं कि आप एक कार्यक्रम लिखें, जो मेरे लिए भूखंडों का विश्लेषण करे।

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

आपका इनपुट किसी भी उचित प्रारूप में, कम से कम 1 × 1 आकार का, एक आयताकार 2D सरणी है। सरणी भूमि के एक भूखंड का प्रतिनिधित्व करती है; 1s "अच्छे" क्षेत्र हैं जहां मैं अपना घर बना सकता हूं, और 0"चट्टानी" क्षेत्र हैं जहां घर नहीं बनाया जा सकता है।

आपका आउटपुट 1इनपुट सरणी में एस के एक ठोस आयत का अधिकतम क्षेत्र होगा । यह उस भूखंड पर निर्मित सबसे बड़े घर के क्षेत्र का प्रतिनिधित्व करता है। ध्यान दें कि यदि 1इनपुट में कोई s नहीं हैं , तो आउटपुट है 0।

उदाहरण

इनपुट पर विचार करें

101
011
111

1S का सबसे बड़ा आयत निचले दाएं कोने में 2 × 2 आयत है। इसका मतलब है कि सही आउटपुट है 4।

नियम और स्कोरिंग

आप एक पूर्ण कार्यक्रम या एक फ़ंक्शन लिख सकते हैं। सबसे कम बाइट गिनती जीतता है, और मानक खामियों को रोक दिया जाता है।

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

code-golf array-manipulation optimization

— Zgarb
स्रोत

8

बुलडोजर, 4 बाइट्स plow:।

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

1

क्या यह ठीक है अगर मेरा समाधान केवल 30 × 30 तक के आयतों के लिए काम करता है?

— नील

1

@ नहीं, यह (कम से कम सैद्धांतिक रूप से) बड़े इनपुट के बारे में काम करना चाहिए क्योंकि आपकी भाषा संभाल सकती है।

— जरगब

1

मैं कुछ डरपोक सा काम करने की उम्मीद कर रहा था, लेकिन उस मामले में मैं परेशान नहीं होगा।

— नील

1

क्या रोटेशन के लिए समाधान की आवश्यकता है?

13

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

ṡṂ€€×"
‘×¥\ç"Ụ€FṀ

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

पृष्ठभूमि

बता दें कि M बिट्स का एक मैट्रिक्स है

0 0 0 1 1 0 0 0 0
1 1 0 1 1 0 0 1 0
1 1 0 1 1 1 1 1 0
1 1 0 0 1 1 1 0 0
0 1 0 0 1 1 1 1 1
1 1 1 1 1 1 1 1 1
1 1 1 1 0 1 1 1 0

हम M के प्रत्येक कॉलम में 1 बिट्स की संख्या की गणना करके शुरू करते हैं , हर बार जब हम 0 बिट का सामना करते हैं तो गिनती को रीसेट करते हैं ।

हमारे उदाहरण मैट्रिक्स के लिए, यह देता है

0 0 0 1 1 0 0 0 0
1 1 0 2 2 0 0 1 0
2 2 0 3 3 1 1 2 0
3 3 0 0 4 2 2 0 0
0 4 0 0 5 3 3 1 1
1 5 1 1 6 4 4 2 2
2 6 2 2 0 5 5 3 0

अगला, हम प्रत्येक पंक्ति के सभी सन्निहित उपविदों की गणना करते हैं। हम लंबाई के सभी स्लाइस उत्पन्न करके इस लक्ष्य को हासिल कश्मीर , जहां कश्मीर के बीच भिन्न होता है 1 और प्रत्येक पंक्ति में प्रविष्टियों की संख्या।

प्रथागत पंक्ति के लिए, यह देता है

[1], [5], [1], [1], [6], [4], [4], [2], [2]
[1, 5], [5, 1], [1, 1], [1, 6], [6, 4], [4, 4], [4, 2], [2, 2]
[1, 5, 1], [5, 1, 1], [1, 1, 6], [1, 6, 4], [6, 4, 4], [4, 4, 2], [4, 2, 2]
[1, 5, 1, 1], [5, 1, 1, 6], [1, 1, 6, 4], [1, 6, 4, 4], [6, 4, 4, 2], [4, 4, 2, 2]
[1, 5, 1, 1, 6], [5, 1, 1, 6, 4], [1, 1, 6, 4, 4], [1, 6, 4, 4, 2], [6, 4, 4, 2, 2]
[1, 5, 1, 1, 6, 4], [5, 1, 1, 6, 4, 4], [1, 1, 6, 4, 4, 2], [1, 6, 4, 4, 2, 2]
[1, 5, 1, 1, 6, 4, 4], [5, 1, 1, 6, 4, 4, 2], [1, 1, 6, 4, 4, 2, 2]
[1, 5, 1, 1, 6, 4, 4, 2], [5, 1, 1, 6, 4, 4, 2, 2]
[1, 5, 1, 1, 6, 4, 4, 2, 2]

इसके बाद, हम प्रत्येक स्लाइस को उसकी न्यूनतम और उसकी लंबाई के उत्पाद के लिए मैप करते हैं। प्रत्येक स्लाइस के लिए, यह अधिकतम ऊंचाई के 1 बिट्स के आयत के क्षेत्र की गणना करता है जिसमें नीचे की पंक्ति के रूप में दिए गए स्लाइस हैं।

हमारे उदाहरण मैट्रिक्स की पारगम्य पंक्ति की लंबाई 3 के स्लाइस के लिए, यह देता है

3 3 3 3 12 6 6

सभी करने के लिए छोड़ दिया है कि सभी पंक्तियों के सभी स्लाइस में अधिकतम ले रहा है।

हमारे उदाहरण मैट्रिक्स के लिए, यह 12 देता है ।

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

‘×¥\ç"Ụ€FṀ  Main link. Argument: M (2D list of bits)

   \        Reduce the columns of M by the link to the left.
  ¥           Combine the two atoms to the left into a dyadic chain.
‘               Increment the left argument.
 ×              Multiply the result with the right argument.
      Ụ€    Grade up each; yield the indices of each row of M, sorted by their
            values. The order is not important here; we just need the indices.
    ç"      Apply the helper link to each element of the result to the left and
            the corresponding element of the result to the right.
        F   Flatten the resulting, nested list.
         Ṁ  Extract the maximum.


ṡṂ€€×"      Helper link. Arguments: R (row), X (indices of R)

ṡ           For each k in X, split R into overlapping slices of length k.
 Ṁ€€        Compute the minimum of each individual slice.
    ×"      Multiply the minima of all slices of length k by k.

— डेनिस
स्रोत

7

मुझे नहीं पता था कि यह अमीर, डेनिस कहाँ है। € $ € $

— orlp

5

सब पैसेका खेल है। $ 2 बाइट्स के लिए $ का आदान-प्रदान।

— डेनिस

1

हमारी माँ पृथ्वी पर आप हमेशा इस तरह से चतुर दृष्टिकोण के साथ कैसे आती हैं?

— लीक नून

क्योंकि एक बस डेनिस से बाहर नहीं निकलता है!

— ग्रिफ़ॉन -

6

MATL, 32 31 27 बाइट्स

n:"@:"@1M2$ltntG4$bZ+=a*vX>

यह एक ब्रूट-बल 2D कनवल्शन-आधारित दृष्टिकोण का उपयोग करता है। सभी संभावित आयत आकार इलाके के साथ बनाए और सजाए गए हैं। सभी दृढ़ संकल्पों का अधिकतम परिणाम अधिकतम आयत क्षेत्र है।

क्योंकि आदेश बाइट्स को बचाने के लिए, मैं के बीच सभी आयतों के लिए कर्नेल बनाने यह एक बहुत ही अक्षम समाधान है [1, 1]और [numel(input) numel(input)]नहीं बल्कि वास्तव में पंक्तियों की संख्या निर्धारित करने से / इनपुट में स्तंभों उचित आयत आयाम पर्वतमाला निर्धारित करने के लिए।

का उपयोग करने Mऔर छोड़ने के सुझाव के लिए @Luis को धन्यवाद ]]।

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

व्याख्या

        % Implicitly grab input as a 2D numeric array
n       % Compute the number of elements in the input (over estimation of max kernel size)
:       % Create array 1:n
"       % For each value
  @     % Current loop index
  :     % Create an array from 1:(current_index)
  "     % For each of these values   
    @   % Push the current index onto the stack
    1M  % Grab the input to the previous function call (the outer index)
    2$l % Create an array of 1's whose dimensions are specified by top two stack elements
    tn  % Duplicate this array and compute number of elements
    t   % Duplicate this number
    G   % Explicitly grab input
    4$b % Bubble up the 4th element from the stack (the kernel)
    Z+  % Perform 2D convolution of this kernel and the input
    =a  % Determine if any convolution result (in each column) is equal to the area of the kernel.
        % This yields a row vector
    *   % Multiply the logical result by the area
    v   % Vertically concatenate all results (forces the row vectors above to be column vectors)
    X>  % Compute the maximum yielding the largest area
        % Implicitly display the result.

— Suever
स्रोत

5

जूलिया, 83 60 57 53 बाइट्स

!M=M⊆1?sum(M):maximum(t->!rotr90(M,t)[2:end,:],0:3)

इसे ऑनलाइन आज़माएं! अंतिम परीक्षण मामला TIO की समय सीमा से अधिक है, लेकिन मैंने इसे स्थानीय रूप से सत्यापित किया है।

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

पहले ! यह जांचता है कि उसके मैट्रिक्स तर्क M में पूरी तरह से 1 है ।

यदि हां, तो ! एम की प्रविष्टियों का योग लौटाता है , जो अपने क्षेत्र के बराबर है।
अगर नहीं ! निम्नलिखित कार्य करता है:
1. घुमाएँ एम द्वारा 0 डिग्री , 90 डिग्री , 180 डिग्री और 270 ° दक्षिणावर्त।
2. चार घुमावों में से प्रत्येक की पहली पंक्ति को हटा दें, प्रभावी रूप से शीर्ष पंक्ति, नीचे की पंक्ति, बाएं स्तंभ और एम के सबसे दाहिने स्तंभ में से एक को हटा दें ।
3. प्रत्येक उपमा पर स्वयं को पुनरावर्ती कहें।
4. पुनरावर्ती कॉल से अधिकतम वापसी मान लौटाएं।

— डेनिस
स्रोत

4

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

a=>a.map((b,i)=>a.slice(i).map((c,j)=>c.map((d,k)=>(n=(b[k]&=d)&&n+j+1)>r?r=n:0,n=0),c=[]),r=0)|r

बिट्स टिड्डिंग अभी भी जीतता है। पूर्णांकों की एक सारणी को स्वीकार करता है। Ungolfed:

function rect(array) {
    var max = 0;
    for (var i = 0; i < array.length; i++) {
        var bits = array[i];
        for (var j = 0; i + j < array.length;) {
            var row = array[i + j];
            j++;
            var size = 0;
            for (var k = 0; k < row.length; k++) {
                if (!row[k]) bits[k] = 0;
                size = ones[k] ? size + j : 0;
                if (size > max) max = size;
            }
        }
    }
    return max;
}

सरणी को अन्य उत्तरों के अनुसार पंक्तियों द्वारा कटा हुआ है, इसलिए पंक्तियों की प्रत्येक संभावित सीमा खत्म हो गई है। पंक्तियों की एक श्रृंखला को देखते हुए, अगला कदम उपलब्ध आयतों को मापना है। यह बिट्स को एक साथ बिटिंग द्वारा एंडिंग द्वारा प्राप्त किया जाता है; परिणाम बिट्स की एक सूची है जो पंक्तियों की पूरी श्रृंखला में सेट की गई थी। यह तब पंक्ति में सेट बिट्स की अधिकतम लंबाई को खोजने के लिए रहता है और रेंज की ऊंचाई से गुणा करता है। बेशर्मी से @ ed65 से चुराया गया टेस्ट:

f=
a=>a.map((b,i)=>a.slice(i).map((c,j)=>c.map((d,k)=>(n=(b[k]&=d)&&n+j+1)>r?r=n:0,n=0),c=[]),r=0)|r

// test cases as strings, converted to 2d arrays
result.textContent = [
  ['0', 0],
  ['1', 1], 
  ['00 00', 0],
  ['01 10', 1],
  ['01 11', 2],
  ['111 010 111', 3],
  ['101 011 111', 4],
  ['0111 1110 1100', 4],
  ['1111111 1110111 1011101', 7],
  ['111011000 110111100 001111110 011111111 001111110 000111100 000011000', 20],
  ['000110000 110110010 110111110 110011100 010011111 111111111 111101110', 12]
].map(t => t[0].replace(/ /g, '\n') + '\n' + t[1] + '\n' + f(t[0].split` `.map(r => [...r]))).join`\n\n`

<pre id=result></pre>

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

— नील
स्रोत

1

मैं उत्थान करूंगा, लेकिन जैसा कि आपकी प्रतिष्ठा बाइनरी में 10000000000000 है, मुझे लगता है कि मैं इसे थोड़ी देर छोड़ दूंगा।

— लेवल रिवर सेंट

im इसे

— गड़बड़ाने की

4

पायथन 2.7, 93 91 89 81 79 बाइट्स

f=lambda M,t=1:max(f(M[1:]),f(zip(*M)[::-1],t+1))if`t/3`in`M`else`M`.count(`t`)

इनपुट tuples की एक सूची है। यहाँ छोटे परीक्षण के मामलों की जाँच करें और बड़े परीक्षण के मामलों की यहाँ ।

संस्मरण के बिना, अंतिम दो परीक्षण मामले Ideone की समय सीमा से अधिक हो जाते हैं, क्योंकि उन्हें आवश्यकता होती है, सम्मान ।, 1,530,831,935 और 2,848,806,121 कॉल करने के लिए f , जिसमें मेरी मशीन पर 39 और 72 मिनट लगते हैं।

कलन विधि

किसी दिए गए मैट्रिक्स M के लिए , सामान्य विचार शीर्ष पंक्तियों को हटाकर M के सभी उपमात्राओं पर पुनरावृति करना है और क्वार्टर को घुमाते हुए वामावर्त मुड़ता है, जो सामने वाले उपमाओं के आकारों पर नज़र रखता है, जिसमें पूरी तरह से 1 बिट्स होते हैं।

उपरोक्त विचार के एक सीधी पुनरावर्ती कार्यान्वयन को पूरा करने से एक फ़ंक्शन f (M) होता है जो निम्न कार्य करता है।

यदि M में कोई 0 बिट्स नहीं है, तो उसकी संख्या 1 बिट्स वापस करें।
यदि हम M को दो बार पहले ही घुमा चुके हैं और इसमें कोई 1 बिट नहीं है, तो 0 लौटाएँ ।
यदि हम M को पहले ही पाँच बार घुमा चुके हैं, तो 0 लौटाएँ ।
रिकर्सिवली कॉल च पर एम इसके शीर्ष पंक्ति के बिना।
एम पर फिर से कॉल एफ ने एक चौथाई मोड़ काउंटरक्लॉकवाइज घुमाया।
पुनरावर्ती कॉल से अधिकतम वापसी मान लौटाएं।

कोड

कार्यान्वयन में, हम एक अतिरिक्त समारोह तर्क का उपयोग टी कि करने के लिए डिफ़ॉल्ट 1 कितनी बार हम इस विशेष मैट्रिक्स पहले से ही घुमाया है का ट्रैक रखने के। यह परीक्षण के द्वारा चरण 1 से 3 में संघनक की अनुमति देता है `t/3`in`M`और `M`.count(`t`)यदि परीक्षण विफल हो जाता है तो वापस लौटता है।

यदि t = 1 है , तो हमने इस शाखा में इस विशेष सबमेट्रिक्स को पहले घुमाया नहीं है।

t / 3 = 0 , इसलिए M के स्ट्रिंग प्रतिनिधित्व में सही iff `t/3`in`M`लौटेगा , जिसमें वर्ण 0 है ।

यह नहीं है, हम वापसी करता है `M`.count(`t`), समय की संख्या चरित्र 1 की स्ट्रिंग प्रतिनिधित्व में प्रकट होता है एम ।

ध्यान दें कि 0 बिट्स के बिना एक मैट्रिक्स केवल तभी हो सकता है यदि t = 1 , क्योंकि हम इस मामले में पुनरावृत्ति नहीं करते हैं।
यदि 3 this t , 5 है , तो हमने पहले इस विशेष सबमेट्रिक्स को इस शाखा में कम से कम दो बार घुमाया है।

t / 3 = 1 , इसलिए स्ट्रिंग के प्रतिनिधित्व का सही iff `t/3`in`M`लौटाएगा M जिसमें चरित्र 1 शामिल है ।

यदि ऐसा नहीं होता है, तो हम वापस जाने के 0 के रूप में की `M`.count(`t`), समय की संख्या की स्ट्रिंग प्रतिनिधित्व टी (यानी, चरित्र 3 , 4 या 5 ) की स्ट्रिंग प्रतिनिधित्व में प्रकट होता है एम ।
अगर t = 6 , हमने पहले इस शाखा में इस विशेष सबमेट्रिक्स को पांच बार घुमाया है।

t / 3 = 2 , इसलिए गलत`t/3`in`M` लौटेगा , क्योंकि M का स्ट्रिंग प्रतिनिधित्व वर्ण 2 नहीं है ।

हम वापस जाने के 0 के रूप में की `M`.count(`t`), कई बार चरित्र की संख्या 6 की स्ट्रिंग प्रतिनिधित्व में प्रकट होता है एम ।

अगर एफ पहले ही वापस नहीं आया, तो शेष चरणों को निष्पादित किया जाता है।

f(M[1:])M पर f अपनी शीर्ष पंक्ति के बिना कॉल करता है । चूंकि टी निर्दिष्ट नहीं है, यह 1 को डिफॉल्ट करता है, यह दर्शाता है कि यह पहली बार एफ है मुठभेड़ों इस शाखा में इस विशेष submatrix।
f(zip(*M)[::-1],t+1)M पर f कॉल करता है घुमाया एक चौथाई मोड़ वामावर्त, incrementing t उस समय का ट्रैक रखने के लिए जब हमने इस शाखा में इस विशेष सबमेट्रिक्स को घुमाया है।

तिमाही बारी की पंक्तियों ज़िप करने से प्राप्त किया जाता है एम एक दूसरे के साथ के लिए इसी तत्वों की tuples लौटने, एम , के पंक्तियों इस प्रकार transposing एम , तो पंक्तियों का क्रम पीछे (यानी, विपरीत नीचे और उपाध्यक्ष पर शीर्ष पंक्ति रखने )।
अंत maxमें पुनरावर्ती कॉल से वापसी मूल्यों का अधिकतम लाभ उठाता है।

— डेनिस
स्रोत

हम्म उन सभी प्रस्तुतियाँ प्रतिष्ठित विचार हैं? बहुत आकर्षक, जिप फंक्शन क्या करता है?

— अब्रीराम

zipइसके तर्कों के संबंधित तत्वों के टपल्स की सूची देता है। अनपैक्ड 2 डी सूची (मैट्रिक्स) के साथ *M, यह अनिवार्य रूप से पंक्तियों और स्तंभों को स्थानांतरित zip(*M[::-1])करता है , इसलिए एक 90 ° रोटेशन दक्षिणावर्त करता है।

— डेनिस

thx, अजगर एक आकर्षण है, मैं इसे किसी दिन सीखूंगा।

— अब्राहम

2

जावास्क्रिप्ट (ईएस 6), 154 176

संपादित करने के लिए थोड़ा छोटा करने की कोशिश की, लेकिन @ नील के समाधान के खिलाफ प्रतिस्पर्धा नहीं कर सकते

हर संभव आयत आज़माएं, अधिकतम आकार वापस करें। शायद मैटल जवाब का एक ही एल्गोरिदम, सिर्फ 6 बार लंबा।
पूर्णांक के 2d सरणी के रूप में इनपुट

g=>g.map((r,i)=>r.map((x,j)=>v=s(r,j,(_,l)=>s(g,i,(_,k)=>!s(g,k,r=>s(r,l,x=>!x,l+j+1),k+i+1)))&(t=-~i*-~j)>v?t:v),s=(a,i,l,j)=>a.slice(i,j).some(l),v=0)|v

कम गोल्फ वाला

यह मूल एल्गोरिथ्म है, गोल्फ संस्करण में लूप्स के लिए सरणी ट्रैवर्सिंग फ़ंक्शन के बहुत सारे दुरुपयोग हैं

g=>{
  v = 0
  for(i = h = g.length; i; i--)
    for(j = w = g[0].length; j; j--)
    {
      p = true
      for(k=0; p && k <= h-i; k++)
        for(l=0; p && l <= w-j; j++)
          p = g.slice(k, k+i).some(r=>r.slice(l, l+j).some(x=>!x));
      if (!p && i*j<v)
        v = i*j
    }
  return v
}

परीक्षा

f=g=>g.map((r,i)=>r.map((x,j)=>v=s(r,j,(_,l)=>s(g,i,(_,k)=>!s(g,k,r=>s(r,l,x=>!x,l+j+1),k+i+1)))&(t=-~i*-~j)>v?t:v),s=(a,i,l,j)=>a.slice(i,j).some(l),v=0)|v

console.log=(...x)=>O.textContent+=x+'\n'

// test cases as strings, converted to 2d arrays
;[
  ['0',0],['1',1],['00 00',0],['01 10',1],['01 11',2],
  ['111 010 111',3],['101 011 111',4],
  ['0111 1110 1100',4],['1111111 1110111 1011101',7],
  ['111011000 110111100 001111110 011111111 001111110 000111100 000011000',20],
  ['000110000 110110010 110111110 110011100 010011111 111111111 111101110',12]
].forEach(t=>{
  var k=t[1]
  var p=t[0].split` `.map(r=>[...r].map(x=>+x))
  var r=f(p)
  console.log((r==k?'OK':'KO')+' '+r+(r==k?'':' expected '+k)+'\n'+p.join`\n`+'\n')
  })

<pre id=O></pre>

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

— edc65
स्रोत

2

एपीएल (Dyalog विस्तारित) , 27 23 20 बाइट

Adám और ngn द्वारा -3 बाइट्स

{⌈/∊(×/×⍵⍷⍨⍴∘1)¨⍳⍴⍵}

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

{⌈/∊(×/×⍵⍷⍨⍴∘1)¨⍳⍴⍵}    Monadic function taking an argument ⍵:
                 ⍳⍴⍵     Indices: e.g. for a 3x7 array
                                       (1 1) (1 2) ...  (1 7)
                                       (2 1) (2 2)  ... (2 7)
                                       (3 1) (3 2)  ... (3 7)
    (×/×⍵⍷⍨⍴∘1)         Helper fn: Takes ⍵ and x (e.g. (2 2))
            ⍴∘1             Make an array of 1s of shape x. Call it a.
        ⍵⍷⍨                 All places where a exists in x
     ×/                      Product of x's dims (size of a)
       ×                 Size of a where a is in ⍵, and 0 elsewhere.
    (×/×⍵⍷⍨⍴∘1)¨        Call the helper function on x and each (¨) index.
                            We now have a nested list containing sizes of blocks in ⍵
                            and many 0s.
   ∊                        Flatten
 ⌈/                        Find the maximum value.

— lirtosiast
स्रोत

{⌈/,(×/×1∊⍵⍷⍨⍴∘1)¨⍳⍴⍵}छोटा और सरल है (विस्तारित की आवश्यकता नहीं है)।

— एडम

1

@lirtosiast @ Adám{⌈/∊(×/×⍵⍷⍨⍴∘1)¨⍳⍴⍵}

— ngn

2

ब्रेजलॉग , २० 17 15 बाइट्स

2 बाइट्स के लिए क्रॉपेब का धन्यवाद

{s\sc≡ᵛ¹l}ᶠ⌉|hh

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

व्याख्या

{        }ᶠ      Find all possible outputs of the following predicate:
 s                Find a sublist of the array (i.e. remove 0 or more rows from the top
                  and/or bottom)
  \               Transpose the array
   s              Find a sublist again
                  The result is some sub-rectangle of the array
    c             Concatenate all the rows in that rectangle into one list
     ≡ᵛ¹          Verify that all the elements are 1
        l         Get the length (i.e. how many 1's make up the rectangle)
                 Now we have a list of the sizes of all possible 1-rectangles
           ⌉     Take the maximum

            |    If no 1-rectangles could be found:
             hh   Take the head of the head of the array (i.e. the top left element)
                 Since the array contains no 1's in this case, this will give 0

— DLosc
स्रोत

aas यह ऑनलाइन कोशिश

— क्रॉपेब

1

आर , 129 122 बाइट्स

function(M,D=dim(M),L=`for`){L(i,1:D,L(j,1:D[2],L(r,0:(D-i),L(c,0:(D[2]-j),F<-max(F,i*j*(i*j==sum(M[r+1:i,c+1:j])))))))
F}

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

सादा और सरल जानवर बल दृष्टिकोण।

अनियंत्रित कोड और स्पष्टीकरण:

function(M){                       # M is the matrix of 0/1
n = 0                              # n is the biggest rectangle found
R=nrow(M)
C=ncol(M)
for(i in 1:R)                      # for each possible num of rows of the rectangle
  for(j in 1:C)                    # for each possible num of cols of the rectangle
    for(r in 0:(R-i))              # for each possible position offset on the rows
      for(c in 0:(C-j){            # for each possible position offset on the cols

         subM = M[1:i+r,1:j+c]     # sub-set the matrix given the size of rectangle and offsets

         if(sum(subM)==i*j)        # if sub-matrix is full of 1's
            rec = i*j              # (i.e. nrow*ncol == sum of values in sub-matrix)
         else                      # store the rectangle area
            rec = 0                # otherwise store 0

         n = max(n,rec)            # keep the maximum rectangle found
      }
}

— digEmAll
स्रोत

1

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

π└ÿ§L▓═J║φ§╦╢9

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

— पुनरावर्ती
स्रोत

0

मतलाब 106 बाइट्स

x=input('');[n,k]=size(x);r=0;for p=1:n;for m=1:k;r=max([p*m*(any(conv2(x,ones(p,m))==p*m)),r]);end;end;r

Ungolfed:

x=input(''); %//Take input
[n,k]=size(x); %//Determine array size
r=0; %//Variable for output. Initially zero
for p=1:n; %// Loop through the columns
    for m=1:k; %// Loop through the rows
        r=max([p*m*(any(conv2(x,ones(p,m))==p*m)),r]);%//See explanation below
    end;
end;
r %//Display result

लूप में ऑपरेशन conv2()इनपुट सरणी के 2 डी कनवल्शन के साथ शुरू होता p*mहै। ==p*mचेक करता है कि परिणामी सरणी में एक तत्व समान है p*m। इसी तत्व को बदल दिया जाता है 1, अन्य सभी तत्वों को बदल दिया जाता है 0। any()सरणी को वेक्टर में बदल देता है। कम से कम एक नॉनज़रो प्रविष्टि वाले कॉलम को 1अन्यथा चालू कर दिया जाता है 0। p*m*()पलता द्वारा वेक्टर p*mजिससे सभी मोड़ 1में -s p*m। [__,r]वर्ग कोष्ठक प्राप्त परिणाम को पिछले अधिकतम क्षेत्र के साथ संगृहीत करता है r। अंत max()में, परिणामी वेक्टर में अधिकतम मूल्य पाता है।

— brainkz
स्रोत

फ़ंक्शन कोई भी क्या करता है?

— अब्राहम

@ 2 डी सरणी में प्रत्येक स्तंभ के लिए Agawa001 any()रिटर्न 1अगर कॉलम में एक गैर-तत्व शामिल है और 0अन्यथा।

— ब्रिंकज

0

मैटलैब (222)(209)

दरअसल, यह समाधान मुझे वास्तविक समान भाषा के समाधान के दोहरे आकार के लिए शर्म की बात है लेकिन ... दोषपूर्ण, मैं इसे 6 घंटे के लिए सोच रहा था! और चाल डेनिस और नील के उत्तरों से थोड़ा अलग है।

    function p=g(x,a,u,i,j),i=i+~u;j=j+u;p=0;if(j*u+i*~u>=size(a,2-u))return;end,x=circshift(x,[0-u -1+u]),a=(x+a).*~~x.*~~a;for h=0+u:1,p=max([p,reshape(a(1:end-j,1:end-i),1,[]),g(~u*(a*h+x*~h)+u*x,a,h,i,j)]);end

फ़ंक्शन को कहा जाता है

y=[1 1 1 0 1 1 0 0 0;
1 1 0 1 1 1 1 0 0;
0 0 1 1 1 1 1 1 0;
0 1 1 1 1 1 1 1 1;
0 0 1 1 1 1 1 1 0;];
t=g(y,y,[],0,0,0);t,

यदि फ़ंक्शन के डिम्प्शन, मैट्रिक्स में अधिक लंबाई के साथ अधिक बाइट्स बचा सकता है, तो अधिक गोल्फिंग जारी है।
यह कैसे आगे बढ़ता है?

यह एल्गोरिथ्म वास्तविक मैट्रिक्स को स्वयं को बाईं दिशा में स्थानांतरित करने के लिए जोड़ता है, थोड़ा सा चक्कर (और) के साथ। किसी भी अवस्था में परिणामी मैट्रिक्स को प्रारंभिक के रूप में सेट किया जाता है और खुद को बार-बार स्थानांतरित करने के लिए जोड़ा जाता है, फिर नए मैट्रिक्स के साथ शुरुआत से फिर से खोलें। इस ऑपरेशन द्वारा उत्पन्न सभी मैट्रिसेस के सभी उप-तत्वों (original_matrix+shifted_matrix)&shifted_and_original_matrices)को आउटपुट में अधिकतम किया जाता है।

उदाहरण:

     1 1 1         1 1 0                      2 2 0                  0 2 0                        0 4 0
 M0= 0 1 1  M0<<1= 1 1 0  M1=(M0+M0<<1)&both= 0 2 0    shift(M1,up)= 2 0 0  M2=(M1+sh(M1,u)&both= 0 0 0  
     1 1 0         1 0 0                      2 0 0                  0 0 0                        0 0 0
                        2 0 0                               4 0 0
 M3=(M0<<1+M0<<2)&both= 2 0 0 , M4=(M3+shift(M3,up))&both=  0 0 0
                        0 0 0                               0 0 0

                3 0 0                             
 M5=(M1+M0<<2)= 0 0 0 , M6=(M5+shift(M5,up))&both=zeros(3,3).
                0 0 0

 Max_of_all_values=Max(0,1,2,3,4)=4

— Abr001am
स्रोत

0

जाप , 30 बाइट्स

®åÏ*°X}ÃÕ®£ZãYÄÃm®rm *Zl}Ãc rw

सभी परीक्षण मामलों की कोशिश करो

डेनिस के जेली उत्तर का लगभग एक बंदरगाह। परीक्षण के मामले केवल संख्याओं के 2 डी सरणियां हैं, इसका उपयोग करके प्रश्न के प्रारूप से परिवर्तित किया गया है ।

स्पष्टीकरण:

®      Ã                          #For each row:
 å    }                           # Replace each number with this running total:
    °X                            #  Increment the previous total
  Ï*                              #  Multiply it by the current number
        Õ                         #Transpose rows and columns
         ®               Ã        #For each column:
          £    Ã                  # Iterate over the range [0..length) as Y:
           ZãYÄ                   #  Get the subsections of that column with length Y+1
                m®      }         # For each subsection:
                  rm              #  Get the minimum
                     *Zl          #  Multiply it by the length
                          c       #Flatten everything to a single list of possible rectangle sizes
                            rw    #Get the maximum

— कामिल दकरी
स्रोत

0

जे , 38 बाइट्स

,"0/&(1+i.)/@$>./@,@:((#**/)@,;._3"$)]

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

किस तरह

,"0/&(1 + i.)/@$ >./@,@:((# * */)@,;._3"$) ]
              @$                             NB. pass the shape of
                                             NB. the input (rows, cols)
                                             NB. to...
,"0/&(1 + i.)/                               NB. this verb, which will
    &(1 + i.)/                               NB. will first create 2
                                             NB. lists: 1...num rows
                                             NB. and 1...num cols.
,"0/                                         NB. and then creat a cross
                                             NB. of every possible 
                                             NB. concatenation of the two,
                                             NB. giving us all possible 
                                             NB. rectangle sizes. pass 
                                             NB. that and...
                                           ] NB. the original input
                 >./@,@:((# * */)@,;._3"$)   NB. to this verb, which
                                   ;._3"$    NB. will take every 
                                             NB. possible rectangle of
                                             NB. every size,
                                 @,          NB. flatten it and...
                         (# * */)            NB. multiply the size of
                                             NB. the list by the list's 
                                             NB. product, yielding the
                                             NB. size of the list if it's
                                             NB. all ones, zero otherwise.
                     ,@:                     NB. Flatten all those results
                                             NB. into one big list
                 >./@                        NB. and take the max.

— जोनाह
स्रोत

1s की अधिकतम आयत ज्ञात करें

पृष्ठभूमि

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

उदाहरण

नियम और स्कोरिंग

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

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

पृष्ठभूमि

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

MATL, 32 31 27 बाइट्स

जूलिया, 83 60 57 53 बाइट्स

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

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

पायथन 2.7, 93 91 89 81 79 बाइट्स

कलन विधि

कोड

जावास्क्रिप्ट (ईएस 6), 154 176

एपीएल (Dyalog विस्तारित) , 27 23 20 बाइट

ब्रेजलॉग , २० 17 15 बाइट्स

व्याख्या

आर , 129 122 बाइट्स

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

मतलाब 106 बाइट्स

मैटलैब (222)(209)

जाप , 30 बाइट्स

जे , 38 बाइट्स

किस तरह