Уявіть двовимірний масив булевих значень, де 0 являють собою квадрати трави на прямокутній ділянці землі, а 1s - огорожі.

Напишіть функцію, яка приймає 2D масив як вхідний і визначає, чи можете ви переходити з будь-якої однієї області трави до будь-якої іншої ділянки трави, використовуючи лише рухи північ / схід / захід / південь, не бігаючи в огорожу.

Якщо будь-яка ділянка трави в масиві повністю закрита огорожами (це означає, що ви не можете подорожувати N / E / W / S, щоб дістатися до будь-якої іншої ділянки трави в масиві), функція повинна повертати помилкове значення; інакше вона повинна повернути справжню.

Нижче наведено два зразкових масиви, які можна використовувати як вхідні дані, хоча ваша функція повинна вміти обробляти не лише ці, а й будь-який 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 годин.

Матлаб 45

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

APL (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

Математика, 60 58 символів

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}}]

помилковий

Рубі, 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-х.

PHP 147 202 177 165 149 байт

EDIT Я побив мій хакер gzip справжнім рішенням php.

Трохи довгий .... введення як текстовий рядок, без пробілів, рядків, розділених новими рядками. Він заливається залишком cs, а потім перевіряє, чи не залишилося нулів. У циклі я використовую 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));

Excel VBA, 305 215 байт

Так, ха-ха VBA , але матричний характер проблеми вказує на практичне рішення в Excel може бути цікавим (Плюс хтось уже подав відповідь на інших мовах!). Очевидно, що VBA не буде найбільш лаконічним, але я думаю, що це розумно.

Ця повінь заповнюється з довільної початкової точки, після чого перевіряється, чи залишилася якась "трава"

R - діапазон робочих аркушів з позначками 1 і 0, що представляють собою огорожі та траву, як визначено в задачі. Бонус, ігрове поле не повинно бути прямокутним або навіть суміжним.

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

Наприклад, повернеться False. Нулі справа не можна досягти з нулів зліва. Неправильне поле не порушує його.

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 vs a = b), що не допомагає рахувати символи.

S потрібно чітко оголосити як діапазон. Якщо він залишив варіант, він перетворюється на значення діапазону, а не діапазон.

Може бути кращим способом розгалужити повінь? Я не міг придумати цикл, який врятував будь-які символи, щоб надіслати його N / E / S / W

Редагувати: змінити базовий корпус на заливці, вдалося трохи відрізати, перевіривши, чи він знаходиться в базовому випадку після рекурсії, а не запобігти рекурсії.

Python (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)

Його вхід повинен бути рядком 0 і 1, де рядки розмежовані символом нового рядка (\ n).

Приклад використання:

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

Пітон (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')

Бере матрицю через STDIN з кожним рядком, розділеним одним пробілом. Наприклад "01010 01100 00000 00010 11110".

Математика 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}}]

Правда

помилковий

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;}

Не гольф:

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;
}

C #, 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;
}

Python 2.X + 3.X: 335 символів

Гольф:

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])

Безголівки:

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()