निर्धारित करें कि भूमि बाड़ से पूरी तरह से संलग्न है

Question

बूलियन मानों की दो-आयामी सरणी की कल्पना करें, जहां 0s भूमि के आयताकार भूखंड पर घास के वर्गों का प्रतिनिधित्व करता है और 1s बाड़ का प्रतिनिधित्व करता है।

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

यदि सरणी में घास का कोई भी क्षेत्र पूरी तरह से बाड़ से घिरा हुआ है (जिसका अर्थ है कि आप सरणी में घास के हर दूसरे क्षेत्र तक पहुंचने के लिए एन / ई / डब्ल्यू / एस यात्रा नहीं कर सकते हैं) तो फ़ंक्शन को गलत वापस लौटना चाहिए; अन्यथा, यह सच लौटना चाहिए।

नीचे दो नमूना सरणियों का उपयोग किया जा सकता है जिन्हें आप इनपुट के रूप में उपयोग कर सकते हैं, हालांकि आपका कार्य न केवल इन बल्कि किसी भी 2D सरणी के शयनकक्षों को संभालने में सक्षम होना चाहिए:

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

(should return true)

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

(should return false, since the middle 0 in the top row is fully enclosed)

सबसे छोटा काम कोड जीतता है। एक सप्ताह बीत जाने के बाद मैं विजेता चुनूँगा या 24 घंटे के भीतर कोई नई प्रस्तुतियाँ नहीं करूँगा।

Comments

क्या आप बाइनरी ऑपरेटरों को भी मना कर सकते हैं? मुझे यह देखना अच्छा लगेगा कि लोग क्या करेंगे।

— पियरे अरलाउड

मेरा मानना ​​है कि यह पिछले वर्ष (2012/2013 सीज़न) से यूएसएसीओ समस्या के समान है। कुछ विशाल परीक्षण मामले हैं जिन्हें वहां पहुँचा जा सकता है ...

— apnorton

क्या सरणी का आकार हमेशा 5 * 5 होगा?

— ProgramFOX

@ProgramFOX मान सरणी किसी भी ऊंचाई, किसी भी चौड़ाई हो सकती है। और यकीन है, कुछ भी बूलियन उत्पादन।

— jawns317

3X3 मैट्रिक्स के बारे में क्या 1 1 1; 1 0 1; 1 1 1? केंद्र में एक घास सेल है। नेत्रहीन रूप से केंद्र में घास सेल पूरी तरह से बाड़ से घिरा हुआ है, लेकिन आपकी परिभाषा से यह नहीं है।

— एमोरी

Answer 1

मतलब ४५

input('');c=bwconncomp(~ans,4);c.NumObjects<2

Comments

@ jawns317 मैं यह नहीं देखता कि यह स्वीकृत उत्तर क्यों है। यह एक फ़ंक्शन नहीं है। केवल एक अन्य उत्तर जो फ़ंक्शन नहीं है, स्टड से स्वीकार करता है। यह एक भी ऐसा नहीं करता है।

— टिम सेगिन

मानक इनपुट स्वीकार input('');c=bwconncomp(~ans,4);c.NumObjects<2करना इस तरह से किया जा सकता है, इससे यह 45 वर्ण हो जाएगा।

— डेनिस जहरुद्दीन

Answer 2

एपीएल (39)

{∧/,⊃{⍺∨⊖⍵}/{⍵∨(∧\~⍵)∨⌽∧\⌽~⍵}¨s,⊖¨s←⊂⍵}

उपयोग:

      board1 board2
 0 0 0 0 0  0 1 0 1 0 
 0 1 0 0 0  0 1 1 0 0 
 0 1 1 1 1  0 0 0 0 0 
 0 0 0 0 0  0 0 0 1 0 
 0 0 0 1 1  1 1 1 1 0 
      {∧/,⊃{⍺∨⊖⍵}/{⍵∨(∧\~⍵)∨⌽∧\⌽~⍵}¨s,⊖¨s←⊂⍵} ¨ board1 board2
1 0

Comments

एपीएल का लाभ यह है कि यह लाइन शोर की तरह दिखता है कि कोई भी यह सत्यापित नहीं करना चाहता कि यह सही है।

— टिम सेगिन

@ कोई भी व्यक्ति इसे चलाने और जाँचने के लिए दुभाषिया डाउनलोड कर सकता है।

— गारेथ

@ गैरेथ हाँ, टिप्पणी गाल में जीभ होना चाहिए था।

— टिम सेगिन

@Tim ओह सॉरी। याद किया कि :-(

— गारेथ

Answer 3

गणितज्ञ, ६० ५ char वर्ण

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

---

उपयोग:

f[{{0, 0, 0, 0, 0}, {0, 1, 0, 0, 0}, {0, 1, 1, 1, 1}, {0, 0, 0, 0, 0}, {0, 0, 0, 1, 1}}]

सच

f[{{0, 1, 0, 1, 0}, {0, 1, 1, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 1, 0}, {1, 1, 1, 1, 0}}]

असत्य

Comments

एक ही लंबाईf=Max@WatershedComponents[Image@#,CornerNeighbors->1>2]<2&

— डॉ। बेलिसियस

Answer 4

रूबी, 202 198 193

a=$<.read.split('
').map(&:split)
f=->x,y{a[x][y]=1
[[-1,0],[1,0],[0,-1],[0,1]].map{|o|d,e=x+o[0],y+o[1]
f[d,e]if a[d]&&a[d][e]==?0}}
f[i=a.index{|x|x.index ?0},a[i].index(?0)]
p !(a.join=~/0/)

एक बाढ़-भराव करता है, फिर यह देखने के लिए जांचता है कि क्या कोई 0 शेष हैं।

Comments

अरे नहीं! अगर मैंने पहले अपने कोड का परीक्षण नहीं किया होता तो मैं और तेज़ होता। ;)

— टिम सेगिन

@ टिम लेकिन फिर यह गलत होता! : पी

— दरवाज़े

Answer 5

PHP 147 202 177 165 149 बाइट्स

EDIT I ने मेरे gzip हैक को वास्तविक php समाधान के साथ हराया।

एक छोटे से लंबे .... एक पाठ स्ट्रिंग के रूप में इनपुट, कोई रिक्त स्थान, पंक्तियों newlines द्वारा सीमांकित। यह बाढ़ से भर जाता है cऔर फिर यह देखने के लिए जांचता है कि क्या कोई शून्य बचा है। लूप में मैं उपयोग किए expजाने वाले पुनरावृत्तियों की संख्या पर एक कच्चे ऊपरी बाउंड के रूप में उपयोग करता हूं । मैं कम कोड में डुप्लिकेट मामलों को संभालने के लिए समरूपता का लाभ उठाता हूं

function f($s){$r=strpos;$n=$r($s,'
');$s[$r($s,'0')]=c;for(;$i++<1<<$n;)$s=strrev(ereg_replace('0(.{'.$n.'})?c','c\1c',$s));return!1==$r($s,'0');}

यहाँ एक अनौपचारिक परीक्षण मामला है:

<?php
$s1="00000
01000
01111
00000
00011";

$s2="01010
01100
00000
00010
11110";

function f($s){
    $n=strpos($s,"\n");
    $s[strpos($s,'0')]=c;
    for(;$i<strlen($s);++$i)
        $s=strrev(ereg_replace(
            '0(.{'.$n.'})?c',
            'c\1c'
            ,$s));
    return!1===strpos($s,'0');
}

var_dump(f($s1));
var_dump(f($s2));

Answer 6

एक्सेल VBA, 305 215 बाइट्स

हां, हाहा वीबीए , लेकिन समस्या का मैट्रिक्स स्वभाव एक्सेल में एक व्यावहारिक समाधान पेश करता है दिलचस्प हो सकता है (प्लस किसी ने पहले से ही मेरी अन्य भाषाओं में जवाब प्रस्तुत किया है!)। जाहिर है कि VBA सबसे ज्यादा सक्सेसफुल नहीं होने वाला है, लेकिन मुझे लगता है कि यह वाजिब है।

यह बाढ़ एक मनमाने ढंग से शुरू होने वाले बिंदु से भर जाती है, अगर कोई "घास" छोड़ देता है तो जाँच करता है

R एक वर्कशीट रेंज है जिसमें 1 और 0 फेंस और घास का प्रतिनिधित्व करते हैं जैसा कि समस्या में परिभाषित किया गया है। बोनस, खेल का मैदान आयताकार या सन्निहित नहीं होना चाहिए।

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

उदाहरण के लिए, झूठा वापस आएगा। दाईं ओर शून्य को बाईं ओर शून्य से नहीं पहुँचा जा सकता है। अनियमित क्षेत्र इसे नहीं तोड़ता है।

Function F(R)
L R, R.Find(0)
F = Not IsNumeric(R.Find(0))
End Function

Sub L(R, S As Range)
If S Or IsEmpty(S) Then Exit Sub
S = 1
L R, S.Offset(1, 0)
L R, S.Offset(-1, 0)
L R, S.Offset(0, 1)
L R, S.Offset(0, -1)
End Sub

गोल्फिंग पर कुछ नोट्स।

मुझे लगता है कि यदि आवश्यकता 1 और 0 के संबंध में उलट हो तो कुछ चार्ट को छंटनी की जा सकती है, लेकिन यह पर्याप्त रूप से अयोग्य बनाने के लिए पर्याप्त नहीं है।

VBA एक गुच्छा एक व्हाट्सएप (a = b बनाम a = b) पर जोर देता है, जो चार गिनती में मदद नहीं करता है।

एस को स्पष्ट रूप से एक सीमा के रूप में घोषित किया जाना चाहिए। यदि इसे एक प्रकार से छोड़ दिया जाता है, तो यह एक सीमा के बजाय एक सीमा मूल्य में बदल जाता है।

शायद बाढ़ को शाखा देने का एक बेहतर तरीका? मैं एक पाश के साथ नहीं आ सका जिसने इसे एन / ई / एस / डब्ल्यू भेजने के लिए किसी भी चार्ट को बचाया

संपादित करें: बाढ़ के आधार पर आधार मामले को फिर से खोलना, पुनरावृत्ति को रोकने के बजाय पुनरावृत्ति के बाद आधार मामले में होने पर जाँच करके काफी हद तक बंद करने में कामयाब रहा।

Answer 7

पायथन (219 बाइट्स)

निश्चित रूप से सबसे छोटा नहीं है, लेकिन यह मेरी पहली कोशिश है, इसलिए मुझे इस पर गर्व है:

def f(n):
 m=[int(c) for c in n if c!='\n']
 for i in range(len(m)):
  if m[i]<1:m[i]=2;break
 g(m,n.find('\n'),i);return not 0in m
def g(n,w,i):
 for x in i-w,i-1,i+1,i+w:
  if 0<=x<len(n):
   if n[x]<1:n[x]=2;g(n,w,x)

यह इनपुट 0s & 1s का स्ट्रिंग होना चाहिए जहां पंक्तियों को एक नई पंक्ति (\ n) वर्ण द्वारा सीमांकित किया जाता है।

उदाहरण का उपयोग:

>>> f("00000\n01000\n01111\n00000\n00011")
True
>>> f("01010\n01100\n00000\n00010\n11110")
False

Comments

आप अंतिम दो को जोड़ सकते हैं यदि कथन एक के साथ हैं and, तो मुझे लगता है कि यह कुछ वर्णों को बचाता है

— टिम सेगिन

आप 8 स्थानों के रूप में सारणी का उपयोग कर सकते हैं।

— कोनराड बोरोस्की

Answer 8

पायथन (196)

मानक बाढ़ भराव।

g=raw_input()
m=g.find(' ')
g=g.replace(' ','')
V={}
def D(V,x):
 if V.get(x,0)or g[x]=='1':return
 V[x]=1;[D(V,x+i)for i in 1,-1,m,-m if 0<=x+i<len(g)]
D(V,g.find('0'))
print len(V)==g.count('0')

एसटीडीआईएन के माध्यम से मैट्रिक्स को एक ही स्थान से अलग प्रत्येक पंक्ति के साथ लेता है। उदाहरण के लिए "01010 01100 00000 00010 11110"।

Answer 9

गणितज्ञ 53

f=Max@(Symbol@@Names@"I*`i*B*l")[Image[1-#],0,1>2]<2&

यह आंतरिक फ़ंक्शन को कॉल करता है Image`MorphologicalOperationsDump`imageBinaryLabel, जो इसके समान है MorphologicalComponents।

f[{{0, 0, 0, 0, 0}, {0, 1, 0, 0, 0}, {0, 1, 1, 1, 1}, {0, 0, 0, 0, 0}, {0, 0, 0, 1, 1}}]
f[{{0, 1, 0, 1, 0}, {0, 1, 1, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 1, 0}, {1, 1, 1, 1, 0}}]

सच

असत्य

Answer 10

PHP (286 वर्ण)

रास्ता बहुत लंबा है, मैं शायद लंबा रास्ता तय कर चुका हूँ।

function D($a){$x=count($a);$y=count($a[0]);for($i=0;$i<$x;$i++)$a[$i][-1]=$a[$i][$y]=1;for($j=0;$j<$y;$j++)$a[-1][$j]=$a[$x][$j]=1;for($i=0;$i<$x;$i++){for($j=0;$j<$y;$j++){if($a[$i][$j]!=1){if($a[$i][$j-1]==1&&$a[$i][$j+1]==1&&$a[$i-1][$j]==1&&$a[$i+1][$j]==1)return 0;}}}return 1;}

गैर golfed:

function D($a)
{
$x=count($a);
$y=count($a[0]);
for ($i=0;$i<$x;$i++)
    $a[$i][-1]=$a[$i][$y]=1;
for ($j=0;$j<$y;$j++)
    $a[-1][$j]=$a[$x][$j]=1;
for ($i=0;$i<$x;$i++)
{
    for ($j=0;$j<$y;$j++)
    {
        if ($a[$i][$j] != 1)
        {
            if ($a[$i][$j-1] == 1 && $a[$i][$j+1] == 1 && $a[$i-1][$j] == 1 && $a[$i+1][$j] == 1)
                return 0;
        }
    }
}
return 1;
}

Comments

यह सही नहीं है। यह केवल यह देखने के लिए जाँचता है कि क्या कोई एकल शून्य नहीं है जो चारों ओर से घिरा हुआ है। जीरो को बंद करने के अधिक जटिल तरीके हैं।

— टिम सेग्यूनी

बेशक आप ठीक हैं। मैं बाढ़ के बिना इसे हल करने के लिए एक और रास्ता तलाश रहा था, मुझे लगता है कि मेरी खोज जारी है!

— वीरोस

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

— टिम सेगिन

Answer 11

सी #, 235 बाइट्स

int[][]D;int w,h,n;bool Q(int x,int y){var r=x>=0&&x<w&&y>=0&&y<h&&(D[x][y]++==0);if(r){Q(x-1,y);Q(x+1,y);Q(x,y+1);Q(x,y-1);}return r;}
bool P(int[][]B){D=B;w=D[0].Length;h=D.Length; for(int i=0;i<w*h;i++)if(Q(i%w,i/w))n++;return n==1;}

यह बोर्ड में प्रत्येक सेल को भरने के लिए बाढ़ की कोशिश करता है, यह केवल एक बाढ़ भराव रिटर्न को सच बनाता है।

bool R( int x, int y)
{
    var r = (x >= 0 && x < w && y >= 0 && y < h && D[x, y]++ == 0);
    if (r)
    {
        R(x-1, y);
        R(x+1, y);
        R(x, y+1);
        R(x, y-1);
    }
    return r;
}

public bool Do()
{
    D = Board1;
    w = D.GetLength(0);
    h = D.GetLength(1);
    for (int x = 0; x < w; x++) for (int y = 0; y< h; y++) if (R(x, y)) n++;
    return n == 1;
}

Answer 12

पायथन 2.X + 3.X: 335 चार्जर

golfed:

def f(n):
 x,y=0,0
 z=lambda x,y:y<len(n)and x<len(n[0])and n[x][y]!=1
 while not z(x,y):
  y+=1
  if y==len(n):
   y=0
   x+=1
  if x==len(n[0]):
   return False
 t=set([(x,y)])
 v=set()
 while t:
  (x,y)=t.pop()
  v|=set([(x,y)])
  if z(x+1,y):
   t|=set([(x+1, y)])
  if z(x,y+1):
   t|=set([(x, y+1)])
 return len(v)+sum(map(sum,n))==len(n)*len(n[0])

Ungolfed:

def f(n):
    """In the following filed, starting from a 0: is it possible to
       get to every other 0?

        >>> f([[0,0,0,0,0],\
               [0,1,0,0,0],\
               [0,1,1,1,1],\
               [0,0,0,0,0],\
               [0,0,0,1,1]])
        True
        >>> f([[0,1,0,1,0],\
               [0,1,1,0,0],\
               [0,0,0,0,0],\
               [0,0,0,1,0],\
               [1,1,1,1,0]])
        False
        >>> f([[1,1,1,1,1],\
               [1,1,1,1,1],\
               [1,1,1,1,1],\
               [1,1,1,1,1],\
               [1,1,1,1,1]])
        False
        >>> f([[1,1,1,1,1],\
               [1,1,1,1,1],\
               [1,1,1,1,1],\
               [1,0,1,1,1],\
               [1,1,1,1,1]])
        True
        >>> f([[1,1,1,1,1],\
               [1,1,1,1,1],\
               [0,1,1,1,1],\
               [1,0,1,1,1],\
               [1,1,0,1,1]])
        False
        >>> f([[1,1,1,1,1],\
               [1,1,1,1,1],\
               [1,1,1,1,1],\
               [1,1,1,1,1],\
               [1,1,1,1,0]])
        True
    """
    x, y = 0,0
    isValid = lambda x,y: y<len(n) and x<len(n[0]) and n[x][y] != 1
    for i in range(len(n)*len(n[0])):
        x = i%len(n)
        y = i/len(n)
        if isValid(x,y):
            break

    while not isValid(x,y):
        y += 1
        if y == len(n):
            y = 0
            x += 1
        if x == len(n[0]):
            return False # Problem is not clearly defined here
    toGo=set([(x,y)])
    visited=set()
    while toGo:
        (x,y) = toGo.pop()
        visited |= set([(x,y)])
        if isValid(x+1,y):
            toGo |= set([(x+1, y)])
        if isValid(x,y+1):
            toGo |= set([(x, y+1)])
    return len(visited)+sum(map(sum,n)) == len(n)*len(n[0])

if __name__ == "__main__":
    import doctest
    doctest.testmod()

Comments

क्या आप गोल्फ संस्करण को शीर्ष पर ले जा सकते हैं? कुछ लोगों के पास इस साइट के लिए एक उपयोगकर्ता स्क्रिप्ट है जो कोड के पहले ब्लॉक में वर्णों को गिनता है।

— गारेथ

@ गैरेथ: हो गया ..

— मार्टिन थोमा