क्या आप आयतों की संख्या गिन सकते हैं?


21

मेरा पसंदीदा गणितीय अतीत एक आयताकार ग्रिड तैयार करना है, फिर उस ग्रिड में दिखाई देने वाले सभी आयतों का पता लगाना है। यहाँ, इस प्रश्न को लें, और अपने लिए उद्यम करें!

क्या आप आयतों की संख्या गिन सकते हैं?

+-----+-----+-----+-----+
|     |     |     |     |
|     |     |     |     |
+-----+-----+-----+-----+
|     |     |     |     |
|     |     |     |     |
+-----+-----+-----+-----+
|     |     |     |     |
|     |     |     |     |
+-----+-----+-----+-----+
|     |     |     |     |
|     |     |     |     |
+-----+-----+-----+-----+

इस 4 x 4 minichess बोर्ड के लिए आयतों की कुल संख्या बिल्कुल है

100

क्या आप सही थे?

संबंधित गणित: 8 × 8 बिसात पर कितने आयत हैं?

चुनौती

सबसे छोटा फ़ंक्शन / प्रोग्राम लिखें जो एक गैर-टॉरॉइडल ग्रिड / छवि पर दिखाई देने वाले आयतों की कुल संख्या को गिनता है ।

संबंधित चुनौतियां: अद्वितीय आयतें गिनें! , एक 2D बाइट सरणी में आयतों की संख्या का पता लगाएं

इनपुट प्रारूप

आपका फ़ंक्शन या प्रोग्राम टेक्स्ट-आधारित इनपुट या ग्राफ़िकल इनपुट के साथ काम करना चुन सकता है।

पाठ-आधारित इनपुट

ग्रिड एक हो जाएगा मीटर -by- n ( मीटर पंक्तियाँ, एन कॉलम) ASCII निम्न वर्णों से मिलकर ग्रिड:

  • रिक्त स्थान,
  • - एक क्षैतिज रेखा खंड के कुछ हिस्सों के लिए,
  • | एक ऊर्ध्वाधर रेखा खंड के कुछ हिस्सों के लिए, और
  • + कोनों के लिए।

आप इस ASCII ग्रिड को अपने प्रोग्राम / फ़ंक्शन के इनपुट / तर्क के रूप में पेश कर सकते हैं

  • लाइन-ब्रेक द्वारा सीमांकित एक भी स्ट्रिंग,
  • एक स्ट्रिंग के बिना newlines लेकिन एक या दो पूर्णांक के साथ ग्रिड के आयाम एन्कोडिंग, या
  • तार की एक सरणी।

नोट: पाठ-आधारित इनपुट में कम से कम 1 पंक्ति और कम से कम 1 कॉलम होता है।

ग्राफिकल इनपुट

वैकल्पिक रूप से, ग्रिड 5 * n पिक्सेल चौड़े और 5 * m पिक्सेल उच्च के सफेद और सफेद PNG चित्र के रूप में एन्कोड किए गए हैं । प्रत्येक छवि में 5 px * 5 px ब्लॉक होते हैं जो ASCII इनपुट के अनुरूप होते हैं :

  • रिक्त स्थान को सफेद ब्लॉकों में बदल दिया जाता है। इन ब्लॉकों को व्हाट्सएप ब्लॉक कहा जाता है ।
  • लाइन खंडों और कोनों को गैर- सफेद ब्लॉक में परिवर्तित किया जाता है। ऐसे ब्लॉकों का केंद्र पिक्सेल काला है।
  • संपादित करें: यदि दो कोनों (एएससीआईआई इनपुट में) एक लाइन सेगमेंट से जुड़े हैं, तो संबंधित ब्लॉक केंद्र (ग्राफिकल इनपुट में) एक काली रेखा से भी जुड़े होने चाहिए।

इसका मतलब है कि प्रत्येक ब्लॉक को केवल कृपया नीली सीमाओं को अनदेखा करें। (बड़ी छवि के लिए यहां क्लिक करें) से चुना जा सकता है ।

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

आउटपुट स्वरूप

यदि आप कोई प्रोग्राम लिख रहे हैं, तो उसे इनपुट में आयतों की कुल संख्या को दर्शाने वाला एक गैर-नकारात्मक नंबर दिखाना होगा।

यदि आप एक फ़ंक्शन लिख रहे हैं, तो इसे इनपुट में आयतों की कुल संख्या को इंगित करते हुए एक गैर-नकारात्मक संख्या भी लौटानी चाहिए।

उदाहरण मामलों

केस 1, ग्राफिक: मामला एक( 30 px * 30 px), ASCII: ( 6 पंक्तियाँ, 6 कॉल)

+--+  
|  |  
| ++-+
+-++ |
  |  |
  +--+

अपेक्षित उत्पादन: 3

केस 2, ग्राफिक: केस 2( 20 px * 20 px), ASCII: ( 4 पंक्तियाँ, 4 कॉल)

++-+
|+++
+++|
+-++

अपेक्षित उत्पादन: 6

केस 3, ग्राफिक: केस 3( 55 px * 40 px), ASCII: ( 8 पंक्तियाँ, 11 बछड़े)

  +++--+   
+-+++  |   
|  |  ++--+
+--+--++ ++
      |  ||
      |  ||
++    +--++
++         

अपेक्षित उत्पादन: 9

केस 4, ग्राफिक: केस 4( 120 px * 65 px), ASCII: ( 13 पंक्तियाँ, 24 कोल्स)

+--+--+ +--+  +--+  +--+
|  |  | |  |  |  |  |  |
+--+--+ |  |  |  |  |  |
|  |  | +--+--+--+--+--+
+--+--+    |  |  |  |   
           |  |  |  | ++
+-+-+-+-+  +--+  +--+ ++
| | | | |
+-+-+-+-+-+-+-+-+-+-+-+
| | | | | | | | | | | |
+-+-+-+-+-+-+-+-+-+-+-+
| | | | | | | | | | | |
+-+-+-+-+-+-+-+-+-+-+-+

अपेक्षित उत्पादन: 243

प्रकरण 5, ग्राफिक: केस 5( 5 पिक्सल * 5 । पिक्सल हाँ, यह है वहाँ!), ASCII: बस एक जगह।

अपेक्षित उत्पादन: 0

केस 6, ग्राफिक: केस 6( 35 px * 20 px), ASCII: ( 4 पंक्तियाँ, 7 कॉल)

+--+--+
|++|++|
|++|++|
+--+--+

अपेक्षित उत्पादन: 5

मान्यताओं

जीवन को आसान बनाने के लिए, आपको गारंटी दी जाती है कि:

  • किया जा रहा गैर toroidal , ग्रिड या तो क्षैतिज या अनुलंब रूप लपेट नहीं करता है।
  • कोई ढीला छोर नहीं है, उदाहरण के लिए +--- या +- -+। सभी लाइन खंडों के दो छोर हैं।
  • उस समय मिलने वाली दो रेखाएं +उस बिंदु पर एक दूसरे को प्रतिच्छेद करती हैं।
  • आपको अमान्य इनपुट के बारे में चिंता करने की आवश्यकता नहीं है।

मानक खामियों के खिलाफ नियम लागू होते हैं। कृपया वर्गों को आयतों के रूप में मानें। वैकल्पिक रूप से, आप ग्रिड की प्रत्येक पंक्ति पर अनुगामी रिक्त स्थान को हटा सकते हैं।

यह , इसलिए अपनी प्रविष्टि को यथासंभव छोटा बनाएं। पाठ-आधारित और चित्रमय समाधान एक साथ प्रतिस्पर्धा करेंगे।

लीडरबोर्ड


क्या मोनोक्रोम बिटमैप की अनुमति है?
user202729

@ user202729 हाँ। यदि आप गैर-पीएनजी छवियों के साथ काम करना चुनते हैं, तो कृपया उत्तर में निर्दिष्ट करें।
उन्माद ली

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

@Zgarb यह वैध इनपुट है। मैं पोस्ट भी संपादित करूँगा।
उन्माद ली

क्या कोई कारण है जो आपने अपेक्षित आउटपुट को बिगाड़ने में लगा दिया है? ऐसा लगता है कि यह आपके कोड को थोड़ा अधिक कष्टप्रद बना देता है।
FryAmTheEggman

जवाबों:


4

ग्रिम , 31 28 बाइट्स

T=\+[+\-]*\+/[+|]/+$
n`T&To2

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

ASCII प्रारूप में इनपुट लेता है।

व्याख्या

जमीनी वाक्यविन्यास नियमित अभिव्यक्तियों के बहुत करीब है। प्रत्येक पंक्ति एक पैटर्न को परिभाषित करती है जो वर्णों की आयत से मेल खा सकती है या नहीं भी हो सकती है। Tएक आयत से मेल खाता है जिसकी शीर्ष पंक्ति और बाएँ स्तंभ वैध दिखते हैं।

T=\+[+\-]*\+/[+|]/+$
T=                    Define T as
  \+[+\-]*\+          a row that matches this regex
            /         and below that
             [+|]/+   a column of + or |
                   $  with anything to its right.

दूसरी पंक्ति "मुख्य कार्यक्रम" है।

n`T&To2
n`       Print number of rectangles that match
  T      the pattern T
   &     and
    To2  T rotated 180 degrees.

6

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

g=a=>Math.max(...b=a.map(a=>a.length))-Math.min(...b)?``:f(a);f=
a=>a.map((b,i)=>[...b].map((_,j)=>n+=a.join`
`.split(eval(`/\\+(?=[-+]{${j}}\\+[^]{${l=b.length+~j}}([|+].{${j}}[|+][^]{${l}}){${i}}\\+[-+]{${j}}\\+)/`)).length>>1),n=0)|n
<textarea rows=8 cols=8 oninput=o.textContent=g(this.value.split`\n`)></textarea><pre id=o>

समान लंबाई के तारों के एक सरणी के रूप में इनपुट लेता है। स्पष्टीकरण: नियमित अभिव्यक्ति की एक श्रृंखला बनाता है जो सभी संभावित चौड़ाई और ऊंचाइयों (और कुछ असंभव चौड़ाई और ऊंचाई, लेकिन आपके लिए कोड गोल्फ है) के आयतों से मेल खाता है और गिनता है कि वे सभी कितने मैचों का उत्पादन करते हैं। क्योंकि regexp में एक कैप्चरिंग ग्रुप है, जो मैचों के लिए splitलौटता 2n+1है n, इसलिए मैं मैचों की संख्या प्राप्त करने के लिए 1 से सही बदलाव करता हूं, क्योंकि यह ग्रुप को नॉन-कैप्चरिंग बनाने के लिए एक बाइट बचाता है।


हम्म, कोड स्निपेट मेरे लिए काम नहीं कर रहा है [फ़ायरफ़ॉक्स 54.0.1 (32 बिट) या क्रोम 60.0.3112.90 (64 बिट) दोनों विंडोज़ (64 बिट) पर।
जोनाथन एलन

स्निपेट यह सफारी पर काम नहीं करता है [मैक (64 बिट)]।
श्री Xcoder

2
ऐसा लगता है कि हमें टेक्स्ट एरिया में सामान चिपकाना है। प्रति पंक्ति वर्णों की समान संख्या आवश्यक है।
उन्माद ली

आह, मैं देख रहा हूँ, अच्छी जगह @FamLi!
जोनाथन एलन

4

जे , 103 95 86 80 80 76 70 बाइट्स

[:+/@,]*/@('-|++'*/@(e.,&'+')~&>]({.,{:)&.>@;|:;{.;{:);._3"$~2+$#:i.@$

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

अनुगामी रिक्त स्थान के साथ तार के एक सरणी के रूप में इनपुट लेता है (ताकि प्रत्येक स्ट्रिंग समान आकार हो)। पूर्ण सबरेरे ऑपरेटर ;._3का उपयोग करता है 2 x 2 से बड़ा हर संभव सबर्रे आकार पर पुनरावृति करने के लिए, और मान्य आयतों वाले सबरेज़ को गिना जाता है। सभी परीक्षण मामलों को लगभग तुरंत पूरा करता है।


1
@FamLi धन्यवाद। फ़ंक्शन इनपुट को स्ट्रिंग की एक सरणी के रूप में प्राप्त कर रहा है, लेकिन मैंने प्रत्येक सरणी को एक फ्लैट स्ट्रिंग के रूप में एन्कोड किया, इससे पहले कि मैं फ़ंक्शन में एक तर्क के रूप में उपयोग करने के लिए उन्हें प्रत्येक चर में संग्रहीत करता हूं।
मील

आह ... आपके स्पष्टीकरण के लिए धन्यवाद।
ली ली

@ मीलों अच्छा। जब आप इनपुट को स्ट्रिंग्स की सरणी कहते हैं, तो क्या इनपुट 1 स्टिंग की प्रत्येक पंक्ति है?
जोनाह

@ जोना स्ट्रिंग्स जे में सिर्फ चर के सरणियाँ हैं, इसलिए इनपुट वास्तव में 2d सरणी का वर्ण है।
मील

3

गणितज्ञ, 136 134 132 बाइट्स

S=Tr@*Flatten;S@Table[1-Sign@S@{d[[{i,j},k;;l]],d[[i;;j,{k,l}]]},{i,($=Length)[d=ImageData@#]},{j,i+1,$@d},{k,w=$@#&@@d},{l,k+1,w}]&

उपयोग: (पुराने 136-बाइट संस्करण के लिए, लेकिन नया संस्करण मूल रूप से समान है)

_

ध्यान दें:

  • यह समय ओ (एम 2 एन 2 अधिकतम (एम, एन)) में चलता है , इसलिए केवल छोटे इनपुट का उपयोग करें।
  • यद्यपि यह बाइनरी छवियों के साथ काम करने वाला है, जाहिर है कि यह गैर-बाइनरी छवियों के साथ काम कर सकता है। (लेकिन काले रंग की पहचान शून्य होनी चाहिए)
  • जरूरी नहीं कि ग्राफिक्स का निर्माण 5x5 ब्लॉक के साथ किया जाए, ब्लॉक छोटे हो सकते हैं।
  • @*संस्करण 10 में नया है। पुराने संस्करणों में, Tr~Composition~Flattenइसके बजाय का उपयोग करें Tr@*Flatten

MMA के किस संस्करण में यह है? 9.0 में, इसका जवाब है"Tr@" cannot be followed by "*Flatten".
उन्माद Li

1
@FamLi 10.0। हां, @*(शॉर्टहैंड के लिए Composition) संस्करण 10 में नया है
user202729

1
तुम सिर्फ इस्तेमाल क्यों नहीं करते RectangleCount[]?
MCMastery

2
@MCMastery Mathematica बहुत सारे बिल्ट-इन होने के लिए प्रसिद्ध है, लेकिन यह एक नहीं है।
user202729

@ user202729 lol yep, im jk
MCMastery

2

जेली ,  60 53 52 51  50 बाइट्स

ÑFQe⁹ṚẆ;W¤
Ḣ,Ṫ
=”+ÇÇ€Ạȧ1ŀ
Zç⁾+-ȧç⁾+|$
Ẇ;"/€Ẇ€Ç€€FS

एक पूर्ण प्रोग्राम स्ट्रिंग्स (समान लंबाई की पंक्तियों) की सूची को स्वीकार करता है और गिनती को प्रिंट करता है।

इसे ऑनलाइन आज़माएं!
... या आसानी से कॉपी और चिपकाने वाले इनपुट के लिए इस पूर्ण कार्यक्रम (लाइनों को विभाजित करने के लिए एक अतिरिक्त बाइट के साथ) का उपयोग करें
- ध्यान दें कि प्रोग्राम के सही ढंग से कार्य करने के लिए लाइनों को अनुगामी स्थान समाहित करना आवश्यक है।

कैसे?

ÑFQe⁹ṚẆ;W¤   - Link 1, sidesAreValid?: list of lists, area; list allowedSideCharacters
Ñ            - call the next link (2) as a monad (get the sides in question
             -   note: these sides do not include the corners since the area was modified
             -   to not include the other sides by the first call to link 2 inside link 3.
 F           - flatten into a single list
  Q          - de-duplicate (unique characters)
         ¤   - nilad followed by link(s) as a nilad:
    ⁹        -   right argument (either "+-"                or "+|"               )
     Ṛ       -   reverse        (either "-+"                or "|+"               )
      Ẇ      -   all sublists   (either ["-","+","-+"]      or ["|","+","|+"]     )
        W    -   wrap           (either ["+-"]              or ["+|"]             )
       ;     -   concatenate    (either ["-","+","-+","+-"] or ["|","+","|+","+|"])
   e         - exists in?

Ḣ,Ṫ          - Link 2, topAndTail helper: list
Ḣ            - head (get the first element and modify the list)
  Ṫ          - tail (get the last element and modify the list)
 ,           - pair (the elements together)

=”+ÇÇ€Ạȧ1ŀ   - Link 3, isPartlyValid?: list of lists, area; list allowedSideCharacters
=”+          - equal to '+'? (vectorises across the whole area, 1 if so, 0 otherwise)
   Ç         - call the last link (2) as a monad (gets the values for two edges)
    Ç€       - call the last link (2) as a monad for €ach (...values for the four corners)
      Ạ      - all? (all corners are '+' 1 if so, 0 if not)
        1ŀ   - call link number 1 as a dyad with sideCharacters as the right argument
             -    ...and the modified area on the left
       ȧ     - logical and (both all corners are '+' and the sides in question look right)

Zç⁾+-ȧç⁾+|$  - Link 4, isValidSquare?: list of lists, area
Z            - transpose
 ç⁾+-        - call the last link (3) as a dyad with right argument "+-"
          $  - last two links as a monad:
      ç⁾+|   -   call the last link (3) as a dyad with right argument "+|"
     ȧ       - logical and (1 if so 0 otherwise)

Ẇ;"/€Ẇ€Ç€€FS - Main Link: list of lists of characters, rows
Ẇ            - all sublists (= all non-zero length runs of rows)
   /€        - reduce €ach by:
  "          -   zip with:
 ;           -     concatenation (= all non-zero length vertical edges)
     Ẇ€      - all sublists for €ach (= all possible areas)
       Ç€€   - call the last link (4) as a monad for €ach for €ach (for each area)
          F  - flatten
           S - sum

2

पर्ची , 32 29 बाइट्स

$a([+`-]*`+>[+`|]*`+>){2}$A

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

कोड के 27 बाइट्स + nऔर oझंडे के लिए 2 बाइट्स । प्रश्न में दिए गए एक ही प्रारूप में इनपुट लेता है (यानी लाइनों के न्यूलाइन-सीमांकित ब्लॉक)।


2

हास्केल, 180 167 166 बाइट्स

l=length
a%b=[a..b-1]
h c a g b=all(`elem`c)$g<$>[a..b]
f s|(#)<-(!!).(s!!)=sum[1|y<-1%l s,x<-1%l(s!!0),i<-0%y,j<-0%x,h"+|"i(#x)y,h"+-"j(y#)x,h"+|"i(#j)y,h"+-"j(i#)x]

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

चार नेस्टेड छोरों के साथ सभी संभव कोने के पदों के माध्यम से जाओ और जांचें कि क्या उनके बीच की रेखाओं पर सभी चार्ट +-(क्षैतिज) या +|(ऊर्ध्वाधर) से मिलकर हैं ।


1

जेली , 41 39 34 33 बाइट्स

,Z;.ị$⁺€ḟ€"⁾-|Fḟ”+
ẆḊÐfZ€µ⁺€ẎÇÐḟL

इसे ऑनलाइन आज़माएं! या सभी मामलों को देखें।

जे में मेरे उत्तर के आधार पर ।

व्याख्या

,Z;.ị$⁺€ḟ€"⁾-|Fḟ”+  Helper. Input: 2d array of characters
 Z                  Transpose
,                   Pair
  ;                   Concatenate with
     $                The tail and head
   .ị                   Select at index 0.5 -> Select at index 0 and 1
                        Jelly uses 1-based modular indexing, so
                        0 means to select the tail
      ⁺€              Repeat on each - This selects the last and first rows,
                      last and first columns, and the 4 corners
           ⁾-|       The string array ['-', '|']
          "          Vectorize
        ḟ€             Filter each
              F      Flatten
                ”+   The character '+'
               ḟ

ẆḊÐfZ€µ⁺€ẎÇÐḟL  Main. Input: 2d array of characters
      µ         Combine into a monad
Ẇ                 Generate all sublists
  Ðf              Filter for the values that are truthy (non-empty)
 Ḋ                  Dequeue
    Z€            Transpose each
       ⁺€       Repeat on each
         Ẏ      Tighten, join all lists on the next depth
          ÇÐḟ   Discard the values where executing the helper returns truthy
             L  Length

अब यह अंततः 34 बाइट्स पर प्रतिस्पर्धात्मक रूप से कम महसूस करना शुरू कर रहा है।
मील
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.