2d सरणी में सबसे बड़ा आयत

Question

इनपुट

बोर्ड: एक 2 डी कंटेनर (मैट्रिक्स, सूचियों की सूची, आदि) जैसे पत्र:

  ["B", "C", "C", "C", "C", "B", "B", "C", "A", "A"],
  ["B", "A", "C", "B", "B", "A", "B", "B", "A", "A"],
  ["B", "C", "B", "C", "A", "A", "A", "B", "C", "B"],
  ["B", "B", "B", "A", "C", "B", "A", "C", "B", "A"],
  ["A", "A", "A", "C", "A", "C", "C", "B", "A", "C"],
  ["A", "B", "B", "A", "A", "C", "B", "C", "C", "C"],
  ["C", "B", "A", "A", "C", "B", "B", "C", "A", "A"]

यदि आप उन सूचियों की सूची चुनते हैं, तो आप मान सकते हैं कि सभी उपनलिस्ट एक ही लंबाई के हैं।

नियम

• एक वैध आयत बनाने के लिए आपको एक ही 'अक्षर' वाले सभी आयत कोनों की आवश्यकता होती है।
• उदाहरण, X bellow के साथ नमूना बोर्ड देखें । आप 'X' को (1,0) ऑन (4,0) ऑन (1,3) और ऑन (4,3) भी देख सकते हैं, तो आपके पास इसका मतलब है [1,0,4,3] (1,0) (4,3) में:

X के साथ नमूना बोर्ड :

  ["B", "X", "C", "C", "X", "B", "B", "C", "A", "A"],
  ["B", "A", "C", "B", "B", "A", "B", "B", "A", "A"],
  ["B", "C", "B", "C", "A", "A", "A", "B", "C", "B"],
  ["B", "X", "B", "A", "X", "B", "A", "C", "B", "A"],
  ["A", "A", "A", "C", "A", "C", "C", "B", "A", "C"],
  ["A", "B", "B", "A", "A", "C", "B", "C", "C", "C"],
  ["C", "B", "A", "A", "C", "B", "B", "C", "A", "A"]

• लक्ष्य सबसे बड़े क्षेत्र के साथ आयत या आयतों में से एक को खोजने के लिए है, इसकी गणना (दाएं-बाएं + 1) * (नीचे-शीर्ष + 1)
• यदि एक ही अधिकतम क्षेत्र के साथ कई आयतें हैं, तो कोई भी आउटपुट। वैकल्पिक रूप से एक (शीर्ष समन्वय, बाएं समन्वय, सही समन्वय, निचला समन्वय) lexicographically सबसे छोटा।
• आयतों में बोर्ड के किनारे के समानांतर किनारे होने चाहिए।
• प्रत्येक अक्षर A से Z तक (दोनों शामिल हैं) एक मुद्रण योग्य ASCII चार्ट है।

उत्पादन

आउटपुट सबसे बड़े क्षेत्र के आयताकार कोनों के बाएं-ऊपर और दाएं-नीचे की स्थिति होना चाहिए। पहला नमूना "बोर्ड" के लिए बड़ा वर्ग पीला एक है:

और उत्तर होना चाहिए:

[१, १, 8, ४]

एक दूसरा उदाहरण परीक्षण मामला

का इनपुट:

["C", "D", "D", "D", "A", "A"],
["B", "D", "C", "D", "A", "A"],
["B", "D", "D", "C", "A", "C"],
["B", "D", "B", "C", "A", "C"]

एक क्षेत्र छह आयतों की पहचान करने वाली इन तीन समन्वय सूचियों में से एक का उत्पादन करना चाहिए:

[१, ०, २, २]
[१, ०, ३, १]
[३, २, ५, ३]

यह सवाल स्टैक ओवरफ्लो पर शीर्षक के साथ पोस्ट किया गया है: चार समान कोनों द्वारा गठित 2 डी सरणी में सबसे बड़ी आयत कैसे ढूंढें? और इस असभ्य जेएस समाधान के साथ (मैं "अशिष्ट" कह सकता हूं क्योंकि मेरा कोड है;):

ठीक है, मेरी पहली पोस्ट है, कृपया मेरे साथ सहनशील बनें। मैं आपको क्विज़ को बेहतर बनाने के लिए कहूंगा।

Comments

नमस्ते, PPCG में आपका स्वागत है! यह एक अच्छी चुनौती है, लेकिन लगता है कि जीत की कोई कमी है। आमतौर पर, यहां पोस्ट को [कोड-गोल्फ] टैग किया जाता है, जिसका अर्थ है कि सबसे छोटा कोड (बाइट्स में) जीतता है।

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

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

— गेहूं जादूगर

कुछ उत्तर आपके उदाहरणों में देखे गए (पहले, ऊपर, बाएं, नीचे, दाएं) के बजाय "पहले" आयत (यानी, ऊपर, बाएं, नीचे, दाएं) के क्रम में निर्देशांक को आउटपुट करते हैं। यह ठीक है?

— नीमी

कम सख्त आउटपुट स्वरूप आमतौर पर अधिक उत्तरों को प्रोत्साहित करते हैं, इसलिए कुछ ऐसा ((left,top),(right,bottom))होना चाहिए जो ठीक भी हो। मैंने अपना उत्तर और उत्तर तब हटा दिया जब प्रश्न पूरी तरह से परिष्कृत हो गया।

— Angs

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

— गेहूं जादूगर

Answer 1

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

lambda x,e=enumerate:min(((a-c)*(d-b),b,a,d,c)for a,y in e(x)for c,k in e(x)for b,g in e(y)for d,h in e(y)if g==h==k[b]==k[d])[1:]

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

Comments

हाय @ovs, आपके लिए और असुविधाजनक है अगर मैं क्षेत्र को बदलने के लिए नियम को बदल देता हूं: (x2-X1 + 1) × (y2-y1 + 1) जैसा कि Angs ने सुझाव दिया था?

— दानीहप

मैं अधिक उत्तरों को प्रोत्साहित करने के लिए कुछ नियमों को शिथिल करना चाहूंगा। क्या मैं?

— दानीहप

@danihp आगे बढ़ो। यह मेरे उत्तर को अमान्य नहीं करता है, है ना?

— ओवर्स

नहीं, आपका जवाब सही है! अच्छा लगा।

— danihp

Answer 2

रेटिना , 163 162 बाइट्स

Lw$`(?<=(.*\n)*((.)*))(?=(.))((.)*(?<=(.*))\4)((.*\n)*((?>(?<-3>.)*)(?=\4)(?>(?<-6>.)*))\4)?
$.7,$#1,$.2,-$.($5$#9*$5),$.2,$#1,$.7,$.($#1*_$#9*
4{N`
)m`^.*?,

0G`

इसे ऑनलाइन आज़माएं! संपादित करें: सहेजे गए 1 बाइट क्योंकि अनुगामी )मिलान मिलान $.(निहित है। स्पष्टीकरण:

Lw$`(?<=(.*\n)*((.)*))(?=(.))((.)*(?<=(.*))\4)((.*\n)*((?>(?<-3>.)*)(?=\4)(?>(?<-6>.)*))\4)?

यह नियमित अभिव्यक्ति आयतों से मेल खाती है। समूह निम्नानुसार हैं: 1) शीर्ष पंक्ति (कैप्चर काउंट के रूप में) 2) बाएं कॉलम (लंबाई के रूप में) 3) बाएं कोनों को संरेखित करने के लिए संतुलित करना 4) कोनों के लिए पत्र 5) चौड़ाई + 1 (लंबाई के रूप में) 6) संतुलन सही कोनों को सुनिश्चित करने के लिए 7) राइट कॉलम (लंबाई के रूप में) 8) अप्रयुक्त 9) ऊंचाई (कैप्चर काउंट के रूप में)। wविकल्प सुनिश्चित करता है कि आयतों के सभी संभव चौड़ाई प्रत्येक दिए गए शीर्ष के लिए मिलान किया जाता है कोने छोड़ दिया है। $विकल्प सूचियों निम्नलिखित प्रतिस्थापन पद्धति का उपयोग कर परिणाम है।

$.7,$#1,$.2,-$.($5$#9*$5),$.2,$#1,$.7,$.($#1*_$#9*

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

4{N`

फिर चार संख्यात्मक प्रकार का प्रदर्शन किया जाता है।

)m`^.*?,

सॉर्ट कॉलम को प्रत्येक प्रकार के बाद हटा दिया जाता है।

0G`

पहली प्रविष्टि इसलिए अब वांछित परिणाम है।

नोट: किसी दिए गए क्षेत्र की आयत के चुनाव पर प्रतिबंध के बाद से ढील दी गई है और निम्नलिखित 144 143-बाइट संस्करण एक लम्बी आयत के बजाय एक व्यापक पसंद करते हैं:

Lw$`(?<=(.*\n)*((.)*))(?=(.))((.)*(?<=(.*))\4)((.*\n)*((?>(?<-3>.)*)(?=\4)(?>(?<-6>.)*))\4)?
-$.($5$#9*$5);$.2,$#1,$.7,$.($#1*_$#9*
N`
0G`
.*;

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

Comments

लेक्सोग्राफ़िक-मिनट की आवश्यकता को विफल करता है (उदाहरण के लिए ओपी में जोड़े गए परीक्षण मामले की कोशिश करें) (शायद आउटपुट गलत क्रम में भी हो सकता है ??) टीआईओ

— जोनाथन एलन

(... हाँ, उत्पादन में पहले दो मूल्य मेरे विचार से गलत तरीके से हैं)

— जोनाथन एलन

मैंने बस कुछ प्रतिबंधों (लेक्सिकोग्राफिक-मिन आवश्यकता) को आराम दिया। मुझे आशा है कि आपके लिए कोई समस्या नहीं होगी।

— दानीहप

... इसके लिए अब लाइनों और बिंदुओं का मिलान करना होगा।

— योनातन एलन

लेक्सिकोग्राफिक ऑर्डर को ठीक करने में 20 बाइट्स का खर्च आता है :-( और मैंने देखा कि एरिया कैलकुलेशन बदल गया है, जिसकी कीमत 2 बाइट्स है, लेकिन मुझे नहीं पता कि @JonathanAllan का मतलब पॉइंट्स के बारे में क्या है।

— नील

Answer 3

जेली , (27?)  29  28 बाइट्स

^{27 यदि 1-आधारित अनुक्रमण की अनुमति है - अनुगामी निकालें ’}

Fṙ1s2;Uœị³EaZI‘P
ZLpLŒċÇÞṪF’

एक पूरा कार्यक्रम।

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

कैसे?

Fṙ1s2;Uœị³EaZI‘P - Link 1, areaOrZero: list of pairs [[b,l],[t,r]]
F                - flatten the input                 [b,l,t,r]
 ṙ1              - rotate left one                   [l,t,r,b]
   s2            - split into twos                   [[l,t],[r,b]]
      U          - upend the input                   [[l,b],[r,t]]
     ;           - concatenate                       [[l,t],[r,b],[l,b],[r,t]]
         ³       - program's input
       œị        - multidimensional index into
          E      - all equal?                       X
            Z    - transpose the input              [[b,t],[l,r]]
           a     - logical AND (vectorises)         (if not X we now have [[0,0],[0,0]]
             I   - incremental differences          [t-b,r-l] (or [0,0] if not X)
              ‘  - increment (vectorises)           [t-b+1,r-l+1] (or [1,1] if not X)
               P - product                          area (or 1 if not X)

ZLpLŒċÇÞṪF’ - Main link: list of lists
Z           - transpose the input
 L          - length
   L        - length of the input
  p         - Cartesian product
    Œċ      - pairs with replacement
       Þ    - (stable) sort by:
      Ç     -   last link (1) as a monad
        Ṫ   - tail (note that the rightmost pre-sort represents the bottom-right 1x1
            -       so cannot be superseded by a non-matching rectangle)
         F  - flatten
          ’ - decrement (vectorises) (to get to 0-based indexing)

Answer 4

पर्ल 6 , 83 73 बाइट्स

{([X] (^$^a[0]X ^$a)xx 2).max:{[eq] $a[.[*;1];.[*;0]]and[*] 1 X-[Z-] $_}}

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

सूचियों की सूची लौटाता है ((x0 y0) (x1 y1))।

व्याख्या

{
  ([X]                   # Cross product of corner pairs.
    (^$^a[0]             # Range of x coords.
     X                   # Cross product of coords.
     ^$a                 # Range of y coords.
    )xx 2                # Duplicate list.
  ).max:                 # Find maximum of all ((x0 y0) (x1 y1)) lists
  {                      # using the following filter.
    [eq]                 # All letters equal?
      $a[.[*;1];.[*;0]]  # Multidimensional subscript with y and x coord pairs.
    and                  # Stop if false.
    [*]                  # Multiply
      1 X-[Z-] $_        # for each axis 1 - (c0 - c1) == c1 - c0 + 1.
  }
}

Answer 5

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

import Data.Array
o=assocs
f r=snd$maximum[((c-a+1)*(d-b+1),[a,b,c,d])|((a,b),x)<-o r,((c,d),y)<-o r,x==y,r!(a,d)==r!(c,b),x==r!(a,d),a<=c,b<=d]

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

Comments

आप हटा सकते हैं b<=d, जब तक आप रखते हैं a<=c।

— गेहूं जादूगर

@ovs वास्तव में है कि या तो काम नहीं (उदाहरण मैं TIO जोड़ा ) देखें

— जोनाथन एलन

@nimi: मैं तर्क दे सकता हूं कि यह केवल इनपुट ट्रांसपोज़ करने का मामला है।

— Angs

मेरे लिए ठीक है। आप इनपुट ट्रांसपोज़ कर सकते हैं।

— दानीहप

Answer 6

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

XLṭLp`€p/⁺œị€EɗÐfI‘PɗÞ0Ṫ

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

⁺ उपयोगी साबित होता है।

आउटपुट स्वरूप: [ऊपर, नीचे], [बाएं, दाएं] । 1-अनुक्रमण।

Answer 7

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

-1 बाइट @ l4m2
के लिए धन्यवाद -1 बाइट थैंक्स टू @tsh +2 बाइट्स नए आयत स्कैंडल
नियम का पालन करने के लिए

तार के एक मैट्रिक्स के रूप में इनपुट लेता है। 0-अनुक्रमित निर्देशांक लौटाता है: [x0, y0, X1, y1] ।

a=>a.map(b=(r,y)=>r.map((v,x)=>a.map((R,Y)=>R.map((V,X)=>V+R[x]+r[X]!=v+v+v|(A=(x+~X)*(y+~Y))<b||(o=[x,y,X,Y],b=A)))))&&o

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

Comments

a=>a.map(b=(r,y)=>r.map((v,x)=>a.map((R,Y)=>R.map((V,X)=>V+R[x]+r[X]!=v+v+v|(A=(X-x)*(Y-y))<=b||(o=[x,y,X,Y],b=A)))))&&o

— l4m2

यदि एक ही अधिकतम क्षेत्र के साथ कई आयतें हैं, तो कोई भी आउटपुट ; शायद (A=...)<=b-> (A=...)<b?

— tsh

@tsh यह अब वास्तव में सुरक्षित है। धन्यवाद!

— अरनुलद

Answer 8

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

a⊃⍨⊃⍒×/1+-/↑2 2∘⍴¨a←⍸≢¨↑∘.(∩¨)⍨∘.∩¨⍨↓⎕

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

Answer 9

जावा 8, 208 205 बाइट्स

m->{int r=0,R[]={},i=m.length,j,y,z,u,t,T;for(;i-->0;)for(j=m[i].length;j-->0;)for(y=i*j;y-->0;)if((T=m[i][j])==m[u=y/j][z=y%j]&T==m[i][z]&T==m[u][j]&r<(t=(i-u)*(j-z))){r=t;R=new int[]{z,u,j,i};}return R;}

निश्चित रूप से गोल्फ हो सकता है .. मैं अब चार तीन नेस्टेड-लूप का उपयोग करने का सबसे स्पष्ट दृष्टिकोण का उपयोग करता हूं ।

-3 बाइट्स @ceilingcat को एक लूप में पंक्तियों और स्तंभों के आंतरिक छोरों के संयोजन के लिए धन्यवाद ।

स्पष्टीकरण:

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

m->{                         // Method with char-matrix parameter and int-array return-type
  int r=0,                   //  Largest area found, starting at 0
      R[]={},                //  Result coordinates, starting empty
      i=m.length,j,          //  x,y indices of the first corner
      y,z,                   //  x,y indices of the second corner
      u,t,T;                 //  Temp integers to reduce bytes
  for(;i-->0;)               //  Loop `i` over the rows
    for(j=m[i].length;j-->0;)//   Inner loop `j` over the columns
      for(y=i*j;y-->0;)      //    Inner loop over the rows and columns
        if((T=m[i][j])==m[u=y/j][z=y%j]
                             //      If the values at coordinates [i,j] and [y,z] are equal
           &T==m[i][z]       //      as well as the values at [i,j] and [i,z]
           &T==m[u][j]       //      as well as the values at [i,j] and [y,j]
           &r<(t=(i-u)*(j-z))){
                             //      And the current area is larger than the largest
          r=t;               //       Set `r` to this new largest area
          R=new int[]{z,u,j,i};}
                             //       And save the coordinates in `R`
  return R;}                 //  Return the largest rectangle coordinates `R`