जांचें कि क्या मैट्रिक्स में सभी गैर-शून्य तत्व जुड़े हुए हैं

Question

इनपुट:

एक मैट्रिक्स जिसमें रेंज [0 - 9] में पूर्णांक होते हैं ।

चुनौती:

निर्धारित करें कि सभी गैर-शून्य तत्व एक दूसरे से लंबवत और / या क्षैतिज रूप से जुड़े हुए हैं।

आउटपुट:

एक सत्य मूल्य अगर सभी जुड़े हुए हैं, और एक झूठा मूल्य है अगर गैर-शून्य तत्व / समूह हैं जो अन्य तत्वों / समूहों से जुड़े नहीं हैं।

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

परीक्षण के मामलों को लाइन से अलग किया जाता है। परीक्षण मामलों को यहां और अधिक सुविधाजनक प्रारूपों ( कुडोस से दादा ) में पाया जा सकता है ।

निम्नलिखित सभी जुड़े हुए हैं और एक सत्य मान वापस करना चाहिए:

0
--- 
0 0
---
1 1 1
0 0 0
---
1 0 0
1 1 1
0 0 1
---
0 0 0 0 0 0
0 0 3 5 1 0
0 1 0 2 0 1
1 1 0 3 1 6
7 2 0 0 3 0
0 8 2 6 2 9
0 0 0 0 0 5

निम्नलिखित सभी जुड़े नहीं हैं, और एक मिथ्या मूल्य वापस करना चाहिए:

0 1
1 0
---
1 1 1 0
0 0 0 2
0 0 0 5
---
0 0 5 2
1 2 0 0
5 3 2 1
5 7 3 2
---
1 2 3 0 0 5
1 5 3 0 1 1
9 0 0 4 2 1
9 9 9 0 1 4
0 1 0 1 0 0

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में सबसे कम सबमिशन जीतता है। स्पष्टीकरण को प्रोत्साहित किया जाता है!

---

इस चुनौती से प्रेरित है ।

Comments

शायद इनपुट में केवल और शून्य (या ट्रूज़ और फ़ाल्स) होने चाहिए, क्योंकि यह अनिवार्य रूप से जुड़े घटकों के बारे में है।

— निकोनिरह

क्या हम 1 डी सरणी और कई कॉलम के रूप में इनपुट ले सकते हैं?

— ओवंस

@ हाँ यकीन है। मैं यह नहीं देख सकता कि यह आपको पहले से जवाब दे चुके अन्य लोगों पर कोई लाभ दे।

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

संबंधित : कितने शून्य आप सभी nonzero तत्वों से जुड़ा बनाने के लिए बदलने की जरूरत है

— dylnan

संबंधित : घटकों की संख्या की गणना करें (लेकिन आसन्न विकर्ण प्रविष्टियों के साथ)।

— मीशा लावरोव

Answer 1

रेटिना 0.8.2 , 80 77 बाइट्स

T`d`@1
1`1
_
+m`^((.)*)(1|_)( |.*¶(?<-2>.)*(?(2)(?!)))(?!\3)[1_]
$1_$4_
^\D+$

इसे ऑनलाइन आज़माएं! संपादित करें: @FryAmTheEggman के लिए 1 बाइट धन्यवाद सहेजा गया। स्पष्टीकरण:

T`d`@1

@एस और 1एस की एक सरणी के लिए सरल ।

1`1
_

एक 1को बदलें _।

+m`^((.)*)(1|_)( |.*¶(?<-2>.)*(?(2)(?!)))(?!\3)[1_]
$1_$4_

_आसन्न 1s से बाढ़ भराव ।

^\D+$

परीक्षण करें कि क्या कोई 1शेष हैं।

Comments

@FryAmTheEggman धन्यवाद, और आपने मुझे एक विचार दिया कि कैसे एक और दो बाइट्स को भी बचाया जाए!

— नील

Answer 2

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

एक बूलियन देता है।

m=>!/[1-9]/.test((g=(y,x=0)=>1/(n=(m[y]||0)[x])&&!z|n?(m[y++][x]=0,z=n)?g(y,x)&g(--y-1,x)&g(y,x+1)||g(y,x-1):g(m[y]?y:+!++x,x):m)(z=0))

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

let f =

m=>!/[1-9]/.test((g=(y,x=0)=>1/(n=(m[y]||0)[x])&&!z|n?(m[y++][x]=0,z=n)?g(y,x)&g(--y-1,x)&g(y,x+1)||g(y,x-1):g(m[y]?y:+!++x,x):m)(z=0))

console.log('[Truthy]')

console.log(f([
  [0]
]))
console.log(f([
  [0,0]
]))
console.log(f([
  [1,1,1],
  [0,0,0]
]))
console.log(f([
  [1,0,0],
  [1,1,1],
  [0,0,1]
]))
console.log(f([
  [0,0,0,0,0,0],
  [0,0,3,5,1,0],
  [0,1,0,2,0,1],
  [1,1,0,3,1,6],
  [7,2,0,0,3,0],
  [0,8,2,6,2,9],
  [0,0,0,0,0,5]
]))

console.log('[Falsy]')

console.log(f([
  [0,1],
  [1,0]
]))
console.log(f([
  [1,1,1,0],
  [0,0,0,2],
  [0,0,0,5]
]))
console.log(f([
  [0,0,5,2],
  [1,2,0,0],
  [5,3,2,1],
  [5,7,3,2]
]))
console.log(f([
  [1,2,3,0,0,5],
  [1,5,3,0,1,1],
  [9,0,0,4,2,1],
  [9,9,9,0,1,4],
  [0,1,0,1,0,0]
]))

टिप्पणी की गई

पुनरावर्ती फ़ंक्शन जी () पहले एक गैर-शून्य सेल की तलाश करता है (जब तक कि विश्व स्तर पर परिभाषित ध्वज z 0 पर सेट है ) और फिर वहां से बाढ़-भरना शुरू होता है (जैसे ही z! = 0 )।

m =>                               // given the input matrix m
  !/[1-9]/.test((                  // test whether there's still a non-zero digit
    g = (y, x = 0) =>              //   after recursive calls to g(), starting at (x=0,y=0):
      1 / (n = (m[y] || 0)[x]) &&  //     n = current cell; if it is defined:
      !z | n ? (                   //       if z is zero or n is non-zero:
          m[y++][x] = 0,           //         we set the current cell to zero
          z = n                    //         we set z to the current cell
        ) ?                        //         if z is non-zero:
          g(y, x) &                //           flood-fill towards bottom
          g(--y - 1, x) &          //           flood-fill towards top
          g(y, x + 1) ||           //           flood-fill towards right
          g(y, x - 1)              //           flood-fill towards left
        :                          //         else:
          g(m[y] ? y : +!++x, x)   //           look for a non-zero cell to start from
      :                            //       else:
        m                          //         return the matrix
    )(z = 0)                       //   initial call to g() + initialization of z
  )                                // end of test()

Answer 3

MATL , 7 बाइट्स

4&1ZI2<

यह एक मैट्रिक्स देता है जिसमें सभी सत्यवादी आउटपुट के रूप में होते हैं , या एक मैट्रिक्स जिसमें कम से कम शून्य होता है, मिथ्या है । इसे ऑनलाइन आज़माएं!

आप पाद लेख पर एक if- elseशाखा जोड़कर सत्यता / झूठ को सत्यापित कर सकते हैं ; यह भी कोशिश करो!

या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

4       % Push 4 (defines neighbourhood)
&       % Alternative input/output specification for next function
1ZI     % bwlabeln with 2 input arguments: first is a matrix (implicit input),
        % second is a number (4). Nonzeros in the matrix are interpreted as
        % "active" pixels. The function gives a matrix of the same size
        % containing positive integer labels for the connected components in 
        % the input, considering 4-connectedness
2<      % Is each entry less than 2? (That would mean there is only one
        % connected component). Implicit display

Comments

ओपी का ध्यान दें: यदि कोई संदेह है: आउटपुट पूरी तरह से ठीक हैं और लिंक किए गए मेटा पोस्ट का पालन करते हैं।

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

यह मेरे दिमाग को उड़ा रहा है कि MATL / matlab एक सरणी संख्या को सत्य IFF मानता है जिसमें कोई शून्य नहीं है। mathworks.com/help/matlab/ref/if.html (पहले की टिप्पणी हटा दी गई)

— 1

@ शेपर (वास्तव में, यह iff है, इसमें कोई शून्य नहीं है और खाली नहीं है ।) मैं भी भ्रमित था जब मुझे पता चला कि कोई भी गैर- रिक्त सरणी अन्य भाषाओं में सत्य है

— लुइस मेंडो

Answer 4

वोल्फ्राम भाषा (गणितज्ञ) , 54 बाइट्स

सहेजे गए 2 बाइट्स user202729 के लिए धन्यवाद।

Max@MorphologicalComponents[#,CornerNeighbors->1<0]<2&

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

Answer 5

सी, 163 बाइट्स

दो बाइट बचाने के लिए @ user202729 का धन्यवाद!

*A,N,M;g(j){j>=0&j<N*M&&A[j]?A[j]=0,g(j+N),g(j%N?j-1:0),g(j-N),g(++j%N?j:0):0;}f(a,r,c)int*a;{A=a;N=c;M=r;for(c=r=a=0;c<N*M;A[c++]&&++r)A[c]&&!a++&&g(c);return!r;}

मैट्रिक्स के माध्यम से लूप्स जब तक यह पहला गैर-शून्य तत्व नहीं पाता है। फिर थोड़ी देर के लिए लूपिंग बंद कर देता है और पाया गया तत्व से जुड़े हर गैर-शून्य तत्व को शून्य पर सेट करता है। फिर बाकी मैट्रिक्स चेकिंग के माध्यम से लूप करता है यदि हर तत्व अब शून्य है।

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

unrolled:

*A, N, M;

g(j)
{
    j>=0 & j<N*M && A[j] ? A[j]=0, g(j+N), g(j%N ? j-1 : 0), g(j-N), g(++j%N ? j : 0) : 0;
}

f(a, r, c) int*a;
{
    A = a;
    N = c;
    M = r;

    for (c=r=a=0; c<N*M; A[c++] && ++r)
        A[c] && !a++ && g(c);

    return !r;
}

Answer 6

पर्ल, 80 79 78 73 70 बाइट्स

के लिए शामिल +2है0a

STDIN पर रिक्त स्थान के बिना इनपुट मैट्रिक्स दें (या वास्तव में किसी भी तरह के व्हाट्सएप द्वारा अलग की गई पंक्तियों के रूप में)

perl -0aE 's%.%$".join"",map chop,@F%seg;s%\b}|/%z%;y%w-z,-9%v-~/%?redo:say!/}/'
000000
003510
010201
110316
720030
082629
000005
^D

पढ़ने के लिए आसान अगर एक फ़ाइल में डाल दिया:

#!/usr/bin/perl -0a
use 5.10.0;
s%.%$".join"",map chop,@F%seg;s%\b}|/%z%;y%w-z,-9%v-~/%?redo:say!/}/

Answer 7

जावा 8, 226 बाइट्स

m->{int c=0,i=m.length,j;for(;i-->0;)for(j=m[i].length;j-->0;)if(m[i][j]>0){c++;f(m,i,j);}return c<2;}void f(int[][]m,int x,int y){try{if(m[x][y]>0){m[x][y]=0;f(m,x+1,y);f(m,x,y+1);f(m,x-1,y);f(m,x,y-1);}}catch(Exception e){}}

इसमें काफी समय लगा, इसलिए मुझे खुशी है कि अब यह काम कर रहा है।

स्पष्टीकरण:

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

m->{                   // Method with integer-matrix parameter and boolean return-type
  int c=0,             //  Amount of non-zero islands, starting at 0
      i=m.length,j;    //  Index integers
  for(;i-->0;)         //  Loop over the rows
    for(j=m[i].length;j-->0;)
                       //   Inner loop over the columns
      if(m[i][j]>0){   //    If the current cell is not 0:
        c++;           //     Increase the non-zero island counter by 1
        f(m,i,j);}     //     Separate method call to flood-fill the matrix
  return c<2;}         //  Return true if 0 or 1 islands are found, false otherwise

void f(int[][]m,int x,int y){
                        // Separated method with matrix and cell input and no return-type
  try{if(m[x][y]>0){    //  If the current cell is not 0:
    m[x][y]=0;          //   Set it to 0
    f(m,x+1,y);         //   Recursive call south
    f(m,x,y+1);         //   Recursive call east
    f(m,x-1,y);         //   Recursive call north
    f(m,x,y-1);}        //   Recursive call west
  }catch(Exception e){}}//  Catch and swallow any ArrayIndexOutOfBoundsExceptions
                        //  (shorter than manual if-checks)

Answer 8

एपीएल (Dyalog यूनिकोड) , 36 बाइट्स ^SBCS

{2≥≢∪0,,(⍉××3⌈/0,,∘0)⍣2⍣≡⍵}××⍴⍴⍳∘≢∘,

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

Answer 9

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

FJṁa@µ«Ḋoµ€ZUµ4¡ÐLFQL<3

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

---

स्पष्टीकरण।

कार्यक्रम प्रत्येक रूपात्मक घटकों को एक अलग संख्या के साथ लेबल करता है, फिर जांचें कि क्या 3 संख्या से कम हैं। (सहित 0)।

मैट्रिक्स में एक पंक्ति पर विचार करें।

«Ḋo   Given [1,2,3,0,3,2,1], return [1,2,3,0,2,1,1].
«     Minimize this list (element-wise) and...
 Ḋ      its dequeue. (remove the first element)
      So min([1,2,3,0,3,2,1],
             [2,3,0,3,2,1]    (deque)
      ) =    [1,2,0,0,2,1,1].
  o   Logical or - if the current value is 0, get the value in the input.
         [1,2,0,0,2,1,1] (value)
      or [1,2,3,0,3,2,1] (input)
      =  [1,2,3,0,2,1,1]

मैट्रिक्स में सभी पंक्ति और स्तंभों के लिए इस फ़ंक्शन को सभी आदेशों में बार-बार लागू करें, अंततः सभी रूपात्मक घटकों का एक ही लेबल होगा।

µ«Ḋoµ€ZUµ4¡ÐL  Given a matrix with all distinct elements (except 0),
               label two nonzero numbers the same if and only if they are in
               the same morphological component.
µ«Ḋoµ          Apply the function above...
     €           for €ach row in the matrix.

      Z        Zip, transpose the matrix.
       U       Upend, reverse all rows in the matrix.
               Together, ZU rotates the matrix 90° clockwise.
         4¡    Repeat 4 times. (after rotating 90° 4 times the matrix is in the
               original orientation)
           ÐL  Repeat until fixed.

और अंत में...

FJṁa@ ... FQL<3   Main link.
F                 Flatten.
 J                Indices. Get `[1,2,3,4,...]`
  ṁ               ṁold (reshape) the array of indices to have the same
                  shape as the input.
   a@             Logical AND, with the order swapped. The zeroes in the input
                  mask out the array of indices.
      ...         Do whatever I described above.
          F       Flatten again.
           Q      uniQue the list.
            L     the list of unique elements have Length...
             <3   less than 3.

Comments

काल्पनिक इनाम अगर आप इसे रैखिक समय में कर सकते हैं। मुझे लगता है कि यह जेली में संभव नहीं है, यहां तक ¦कि ओ (एन) भी लेता है।

— user202729

(अजगर

— पायल के

Answer 10

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

 \m->null.snd.until(null.fst)(\(f,e)->partition(\(b,p)->any(==1)[(b-d)^2+(p-q)^2|(d,q)<-f])e).splitAt 1.filter((/=0).(m!)).indices$m

हल Hitori पहेलियाँ से निकाला गया

indices m(line,cell)इनपुट ग्रिड के स्थानों को सूचीबद्ध करता है ।

filter((/=0).(m!)) गैर-शून्य मान वाले सभी स्थानों को फ़िल्टर करता है।

splitAt 1 एक आराम सूची के बगल में एक एकल सूची में पहले सदस्य से विभाजन।

any(==1)[(b-d)^2+(p-q)^2|(d,q)<-f]बताता (b,p)है कि सीमा को छूता है या नहीं f।

\(f,e)->partition(\(b,p)->touches(b,p)f)e [अभी तक] नहीं छूने वालों से अलग छींटे।

until(null.fst)advanceFrontier इसे दोहराता है जब तक कि आगे कोई आगे नहीं बढ़ सकता।

null.snd परिणाम को देखता है कि क्या सभी स्थानों तक पहुंचना वास्तव में पहुंच गया था या नहीं।

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

Answer 11

ग्रिम , 37 बाइट्स

C=[,0]&<e/\0{/e\0*0$e|CoF^0oX
e`C|:\0

1मैच के लिए और 0बिना किसी मैच के प्रिंट । इसे ऑनलाइन आज़माएं!

व्याख्या

नॉनटर्मिनल C किसी भी गैर-अक्षरी वर्ण से मेल खाता है जो अंग्रेजी पढ़ने के क्रम में मैट्रिक्स के पहले नॉनजो चरित्र से जुड़ा हुआ है।

C=[,0]&<e/\0{/e\0*0$e|CoF^0oX
C=                             A rectangle R matches C if
  [,0]                         it is a single character other than 0
      &                        and
       <                       it is contained in a rectangle S which matches this pattern:
        e/\0{/e\0*0$e           R is the first nonzero character in the matrix:
        e                        S has an edge of the matrix over its top row,
         /0{/                    below that a rectangle of 0s, below that
             e\0*0$e             a row containing an edge, then any number of 0s,
                                 then R (the unescaped 0), then anything, then an edge.
                    |CoF^0oX    or R is next to another match of C:
                     CoF         S is a match of C (with fixed orientation)
                        ^0       followed by R,
                          oX     possibly rotated by any multiple of 90 dergees.

कुछ स्पष्टीकरण: eशून्य चौड़ाई या ऊंचाई की आयत से मेल खाता है जो इनपुट मैट्रिक्स के किनारे का हिस्सा है, और $एक "वाइल्डकार्ड" है जो कुछ भी मेल खाता है। अभिव्यक्ति की e/\0{/e\0*0$eकल्पना इस प्रकार की जा सकती है:

+-e-e-e-e-e-e-e-+
|               |
|      \0{      |
|               |
+-----+-+-------+
e \0* |0|   $   e
+-----+-+-------+

अभिव्यक्ति CoX^0oXवास्तव में के रूप में पार्स है ((CoF)0)oX; oFऔर oXपोस्टफ़िक्स ऑपरेटरों और टोकन साधन के संयोजन क्षैतिज संयोजन कर रहे हैं। ^एक उच्च पूर्वता तो निकटता देता है oXतो रोटेशन पूरे उप-अभिव्यक्ति के लिए लागू होता है। इसके द्वारा घुमाए जाने oFके Cबाद के अभिविन्यास को सही करता है oX; अन्यथा यह पहले नॉनस्टेरो समन्वित मिलान वाले अंग्रेजी पढ़ने के क्रम में मेल खा सकता था।

e`C|:\0
e`       Match entire input against pattern:
    :    a grid whose cells match
  C      C
   |     or
     \0  literal 0.

इसका मतलब है कि सभी नॉनज़रो वर्ण पहले वाले से जुड़े होने चाहिए। ग्रिड :स्पेसिफिक तकनीकी रूप से एक पोस्टफिक्स ऑपरेटर है, लेकिन इसके C|:\0लिए सिंटैक्टिक शुगर है (C|\0):।

Answer 12

पर्ल 5 , 131 129 + 2 ( -ap) = 133 बाइट्स

push@a,[@F,0]}{push@a,[(0)x@F];$\=1;map{//;for$j(0..$#F){$b+=$a[$'][$j+$_]+$a[$'+$_][$j]for-1,1;$\*=$b||!$a[$'][$j];$b=0}}0..@a-2

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

Answer 13

पायथन 2 , 211 163 150 बाइट्स

m,w=input()
def f(i):a=m[i];m[i]=0;[f(x)for x in(i+1,i-1,i+w,i-w)if(x>=0==(i/w-x/w)*(i%w-x%w))*a*m[x:]]
f(m.index((filter(abs,m)or[0])[0]))<any(m)<1>q

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

आउटपुट निकास कोड के माध्यम से है। इनपुट 1d सूची और मैट्रिक्स की चौड़ाई के रूप में है।