क्या पहाड़ के छल्ले हैं?

Question

चुनौती

धनात्मक पूर्णांक के एक मैट्रिक्स को देखते हुए, निर्धारित करें कि क्या कोई "रिंग" पहाड़ों की है। इस चुनौती के लिए औपचारिक परिभाषा है: धनात्मक पूर्णांक का एक मैट्रिक्स दिया गया, क्या कोई धनात्मक पूर्णांक nहै जिसके लिए मैट्रिक्स में कोशिकाओं का एक बंद वलय है जो कड़ाई से nइस तरह से अधिक है कि रिंग में संलग्न सभी कोशिकाएं उससे कम या बराबर हैं को n।

आइए एक सत्य उदाहरण लें:

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

अगर हम इसके लिए तैयार nहैं 2:

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

जैसा कि हम स्पष्ट रूप से देख सकते हैं, 1किनारे के किनारे एक अंगूठी बनाते हैं।

हम एक अंगूठी को कोशिकाओं के एक आदेशित संग्रह के रूप में परिभाषित करते हैं जहां संग्रह में आसन्न कोशिकाएं ग्रिड पर आसन्न (किनारे या कोने) भी होती हैं। इसके अतिरिक्त, रिंग में कम से कम 1 कक्ष होना चाहिए; यह है कि संग्रह में कोशिकाओं को छोड़कर पूरे मैट्रिक्स को केवल बीएफएस-फ्लडफिल से किनारे करने का प्रयास किया जा रहा है और संग्रह में किसी भी सेल को ट्रेस करना कभी भी कम से कम एक सेल को याद नहीं करना चाहिए।

ट्रू टेस्ट केस

4 7 6 5 8 -> 1 1 1 1 1
6 2 3 1 5 -> 1 0 0 0 1 (n = 3)
6 3 2 1 5 -> 1 0 0 0 1
7 5 7 8 6 -> 1 1 1 1 1

1 3 2 3 2
1 6 5 7 2
1 7 3 7 4
1 6 8 4 6

1 3 1
3 1 3
1 3 1

7 5 8 7 5 7 8 -> if you have n = 4, you get an interesting ridge shape around the top and right of the grid
8 4 4 2 4 2 7
6 1 8 8 7 2 7
5 4 7 2 5 3 5
5 6 5 1 6 4 5
3 2 3 2 7 4 8
4 4 6 7 7 2 5
3 2 8 2 2 2 8
2 4 8 8 6 8 8

5 7 6 8 6 8 7 -> there is an island in the outer ring (n = 4), but the island is a ring
5 3 2 4 2 4 7
6 3 7 8 5 1 5
8 2 5 2 8 2 7
8 3 8 8 8 4 7
6 1 4 1 1 2 8
5 5 5 5 7 8 7

150 170 150
170 160 170
150 170 150

मिथ्या परीक्षण मामले

1 2 3 2 1 -> this is just a single mountain if you picture it graphcially
2 3 4 3 2
3 4 5 4 3
2 3 4 3 2
1 2 3 2 1

4 5 4 3 2 -> this is an off-centered mountain
5 6 5 4 3
4 5 4 3 2
3 4 3 2 1

1 1 1 1 1 -> this is four mountains, but they don't join together to form a ring
1 2 1 2 1
1 1 1 1 1
1 2 1 2 1
1 1 1 1 1

3 3 3 3 3 -> there is a ring formed by the `3`s, but the `4` in the middle is taller so it doesn't qualify as a mountain ring
3 1 1 1 3
3 1 4 1 3
3 1 1 1 3
3 3 3 3 3

3 4 4 4 3
4 4 3 4 4
3 3 3 3 4
4 4 3 4 4
3 4 4 4 3

1  2  3  4  5
6  7  8  9  10
11 12 13 14 15
16 17 18 19 20
22 23 24 25 26

नियम

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

Comments

क्या के लिए nतीसरे "truthy" परीक्षण का मामला वास्तव में truthy है? [१,२] ?

— एरिक आउटोलॉफ़र

@EriktheOutgolfer 3s की रिंग कोने से सटे हुए हैं। तो हाँ।

— user202729

Answer 1

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

Ẇ€Z$⁺Ẏµ,ZẈ>2ẠµƇµḊṖZƊ⁺FṀ<,Z.ịḊṖ$€Ɗ€ƊȦ)Ṁ

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

आउटपुट 1 अगर मैट्रिक्स में पर्वत श्रृंखलाएं हैं, तो 0 अन्यथा।

यह कैसे काम करता है (थोड़ा पुराना)

मैं कोड को छोटा करने में सक्षम हो सकता हूं, इसलिए यह अनुभाग संभवतः भारी संपादन से गुजरना होगा।

सहायक लिंक

,Z.ịḊṖ$€Ɗ€ – Helper link. Let S be the input matrix.
,Z         – Pair S with its transpose.
        Ɗ€ – For each matrix (S and Sᵀ), Apply the previous 3 links as a monad.
  .ị       – Element at index 0.5; In Jelly, the ị atom returns the elements at
             indices floor(x) and ceil(x) for non-integer x, and therefore this
             returns the 0th and 1st elements. As Jelly is 1-indexed, this is the
             same as retrieving the first and last elements in a list.
    ḊṖ$€   – And for each list, remove the first and last elements.

उदाहरण के लिए, फ़ॉर्म में एक मैट्रिक्स दिया गया है:

A(1,1) A(1,2) A(1,3) ... A(1,n)
A(2,1) A(2,2) A(2,3) ... A(2,n)
A(3,1) A(3,2) A(3,3) ... A(3,n)
...
A(m,1) A(m,2) A(m,3) ... A(m,n)

यह सरणियाँ लौटाता है (ऑर्डर मायने नहीं रखता):

A(1,2), A(1,3), ..., A(1,n-1)
A(m,2), A(m,3), ..., A(m,n-1)
A(2,1), A(3,1), ..., A(m-1,1)
A(2,n), A(3,n), ..., A(m-1,n)

लंबी कहानी छोटी, यह सबसे बाहरी पंक्तियों और स्तंभों को उत्पन्न करता है, जिसके कोनों को हटा दिया जाता है।

मुख्य कड़ी

Ẇ€Z$⁺Ẏµ,ZẈ>2ẠµƇµḊṖZƊ⁺FṀ<ÇȦ)Ṁ – Main link. Let M be the input matrix.
Ẇ€                           – For each row of M, get all its sublists.
  Z$                         – Transpose and group into a single link with the above.
    ⁺                        – Do twice. So far, we have all contiguous sub-matrices.
     Ẏ                       – Flatten by 1 level.
      µ      µƇ              – Filter-keep those that are at least 3 by 3:
       ,Z                      – Pair each sub-matrix S with Sᵀ.
         Ẉ                     – Get the length of each (no. rows, no. columns).
          >2                   – Element-wise, check if it's greater than 2.
            Ạ                  – All.
               µ          )  – Map over each sub-matrix S that's at least 3 by 3
                ḊṖ           – Remove the first and last elements.
                  ZƊ         – Zip and group the last 3 atoms as a single monad.
                    ⁺        – Do twice (generates the inner cells).
                     FṀ      – Flatten, and get the maximum.
                       <Ç    – Element-wise, check if the results of the helper
                               link are greater than those in this list.
                         Ȧ   – Any and all. 0 if it is empty, or contains a falsey
                               value when flattened, else 1.
                           Ṁ – Maximum.

Answer 2

क्लीन , 224 ... 161 बाइट्स

import StdEnv,StdLib
p=prod
~ =map
^ =reverse o$
@ =transpose o~(^o^)
$l=:[h:t]|h>1=l=[1: $t]
$e=e
?m=p[p(~p(limit(iterate(@o@)(~(~(\a|a>b=2=0))m))))\\n<-m,b<-n]

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

फ़ंक्शन को परिभाषित करता है ? :: [[Int]] -> Int, 0अगर कोई अंगूठी है, और 1अन्यथा।

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

Answer 3

जावास्क्रिप्ट (Node.js) , 302 बाइट्स

a=>a.some((b,i)=>b.some((n,j)=>(Q=(W=(i,j,f)=>[a.map((b,I)=>b.map((t,J)=>I==i&J==j)),...a+0].reduce(A=>A.map((b,I)=>b.map((t,J)=>f(I)(J)&&(A[I-1]||b)[J]|(A[I+1]||b)[J]|b[J-1]|b[J+1]|t))))(i,j,I=>J=>a[I][J]<=n)).some((b,i)=>b.some((d,j)=>d&&!i|!j|!Q[i+1]|b[j+1]==b.b))<!/0/.test(W(0,0,I=>J=>!Q[I][J]))))

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

यदि किसी बिंदु से बहने वाली सीमा तक नहीं पहुंच सकता है, तो चेक करता है, जबकि सीमा हर बिंदु तक चल सकती है