Su desafío recibe una entrada del diseño de la prisión para determinar si alguno de los prisioneros puede escapar.

Entrada

La entrada puede estar en cualquier formato razonable, como una cadena, matriz, matriz de matrices, etc. La entrada constará de tres caracteres, en este caso #, Py espacio. La entrada no contendrá necesariamente los tres caracteres.

• #: Una pared
• P: Un prisionero
• espacio: un espacio vacío

Un ejemplo de entrada se verá así:

#####
#   #
# P #
#   #
#####

Salida

Un valor verdadero / falso de si la prisión es segura o no. La prisión solo es segura si puede contener a todos los prisioneros. Si algún prisionero puede escapar, no es seguro.

Un prisionero puede escapar si no está completamente cercado por una pared. Una unión diagonal está completamente cerrada.

Casos de prueba

############# Truthy
# P #  P#   #
#   #   # P #
#############

############# Truthy
# P    P    #
#   #   # P #
#############

############# Falsey
# P #  P#   #
#   #   # P #
########## ##

####          Truthy
#   #
 #   #
  # P ####
  ####

P             Falsey

###           Falsey
# #
# #
### P

Caracoles , 13 bytes

!(t\P(o\ ),o~

Pruébalo en línea!

Imprime 0para prisiones inseguras y el tamaño del cuadro delimitador de la entrada para prisiones seguras.

La idea es asegurarnos de que no podamos encontrar una ruta desde una Pcelda fuera de los límites ( ~) moviéndose solo ortogonalmente ( o) a través de espacios. El tes un teletransporte para que, independientemente de dónde intentemos el partido, intente todas las posiciones iniciales posibles para encontrar a P.

C # (.NET Core) , 485 480 474 470 421 408 bytes

La herramienta y el enfoque absolutamente incorrectos, pero no obstante ...

• 7 bytes (y más) guardados con los consejos útiles de TheLethalCoder.
• 4 bytes guardados al devolver un entero.
• 4 bytes más guardados gracias (una vez más) a TheLethalCoder al reemplazar ' 'con 32en las comparaciones.
• MUCHOS bytes guardados al refactorizar el código.
• 13 bytes más gracias a (¿adivina quién?) TheLethalCoder. :) Sigo olvidando sus consejos y él me los sigue recordando.

m=>{var p='P';int a=m.Length,b=m[0].Length,i=0,j,x,y;var c=new System.Collections.Stack();for(;i<a;i++)for(j=0;j<b;j++)if(m[i][j]==p)c.Push(new[]{i,j});while(c.Count>0){var t=(int[])c.Pop();x=t[0];y=t[1];if(x<1|x>a-2|y<1|y>b-2)return 0;foreach(var v in new[]{-1,1}){var z=x>0&x<a-1&y>0&y<b-1;if(z&m[x+v][y]==32){m[x][y]=p;c.Push(new[]{x+v,y});}if(z&m[x][y+v]==32){m[x][y]=p;c.Push(new[]{x,y+v});}}}return 1;}

Pruébalo en línea!

Básicamente amplío las posiciones de las P cada vez que hay un espacio en blanco alrededor hasta que alcanza (o no) el borde del diseño.

Algunas licencias:

• Yo uso a char[][]como entrada para el diseño.
• Vuelve 0como inseguro y 1tan seguro.

Perl 5 , 69 bytes

-10 bytes gracias a @Grimy .

-2 bytes gracias a @Neil .

77 bytes de código + -p0banderas.

/
/;$_=s/(P| )(.{@{-}})?(?!\1)(?1)/P$2P/s?redo:!/\A.*P|P.*\Z|^P|P$/m

Pruébalo en línea!

Algunas explicaciones breves :
la idea es poner un lugar Pdonde los prisioneros puedan ir. Si alguno Pestá en la primera / última línea, o en la primera / última columna, entonces los prisioneros pueden ir allí y escapar, lo que significa que la prisión no está segura.
s/(P| )(.{@{-}})?(?!\1)(?1)/P$2P/sreemplaza un espacio a la derecha o debajo de a Pcon a P, o un espacio a la izquierda o encima de a P.
Finalmente, /\A.*P|P.*\Z|^P|P$/mverifica si una línea comienza o termina con a P, o si hay una Pen la primera o la última línea.

JavaScript (ES6), 134 133 bytes

Toma entrada como una matriz de matrices de caracteres. Devoluciones 0(inseguras) o 1(seguras).

f=a=>a.map((r,y)=>r.map((c,x)=>c>'O'&&[-1,1,0,0].map((X,i)=>(R=a[y+1-'1102'[i]])&&R[X+=x]?R[X]<'!'?R[o=2,X]=c:0:o=0)),o=1)|o&2?f(a):o

Casos de prueba

f=a=>a.map((r,y)=>r.map((c,x)=>c>'O'&&[-1,1,0,0].map((X,i)=>(R=a[y+1-'1102'[i]])&&R[X+=x]?R[X]<'!'?R[o=2,X]=c:0:o=0)),o=1)|o&2?f(a):o

console.log(f([
  [...'#############'],
  [...'# P #  P#   #'],
  [...'#   #   # P #'],
  [...'#############']
]))

console.log(f([
  [...'#############'],
  [...'# P    P    #'],
  [...'#   #   # P #'],
  [...'#############']
]))

console.log(f([
  [...'#############'],
  [...'# P #  P#   #'],
  [...'#   #   # P #'],
  [...'########## ##']
]))

console.log(f([
  [...'####'],
  [...'#   #'],
  [...' #   #'],
  [...'  # P ####'],
  [...'  ####']
]))

console.log(f([
  [...'P']
]))

console.log(f([
  [...'###'],
  [...'# #'],
  [...'# #'],
  [...'### P']
]))

JavaScript (ES6), 121 bytes

f=s=>s==(s=s.replace(eval('/( |P)([^]{'+s.search`
`+'})?(?!\\1)[ P]/'),'P$2P'))?!/^.*P|P.*$/.test(s)&!/^P|P$/m.test(s):f(s)

Toma la entrada como una cadena rectangular delimitada por nueva línea. Devuelve 0 para inseguro y 1 para seguro. Según mi respuesta a Detect Failing Castles , aunque sería más eficiente evaluar a un prisionero fugitivo en cada paso, en lugar de una vez que hubieran terminado de explorar la prisión.

Octava, 64 55 bytes

@(a,z=padarray(a,[1 1]))~nnz(bwfill(z==35,1,1,4)&z>35);

Pruébalo en línea!

o

¡Verifique todos los casos de prueba!

Explicación:

z=padarray(a,[1 1])       %add a boundary(of 0s) around the scene
F = bwfill(z==35,1,1,4)   %flood fill the prison starting from the boundary
~nnz(F&z>35);             %if position of at least a prisoner  is filled then the prison is not secure 

APL (Dyalog Classic) , 40 bytes

{⊃2≠(××{1⊃⌈/⍵,⍉⍵}⌺3 3)⍣≡(⌽1,⍉)⍣4⊢'# '⍳⍵}

Pruébalo en línea!

'# '⍳⍵codificar '#', ' ', 'P'como 0 1 2

(⌽1,⍉)⍣4 rodear con 1s

(××{1⊃⌈/⍵,⍉⍵}⌺3 3)⍣≡ relleno de inundación máximo de vecinos de celdas distintas de cero

⊃2≠ ¿No tenemos un 2 en la parte superior izquierda?

Stax , 35 bytes ^CP437

ä¬my■╡╤▲l@┤êr*⌠\¶ƒläå─▄¶√¿ [Uy⌠Só4↔

Pruébalo en línea!

¡Seguramente el lenguaje de golf sin un interno para manejar la búsqueda de caminos también puede hacer esto!

Explicación

Utiliza el formato desempaquetado para explicar.

zLz]Y+Mys+y+{{{" P|P ""PP"Rm}Y!My!Mgphh' =
zLz]Y+Mys+y+                                  Surround the original matrix with four borders of whitespaces
            {                      gp         Iterate until a fixed point is found, return the single fixed point
             {              }Y!               Store the block in register Y and execute it
              {" P|P ""PP"Rm                  For each row, flood every space adjacent to a P with P.
                               My!            Transpose the matrix and do the flooding again
                                     hh' =    The final matrix has a space on the upper left corner that has not been flooded by P 

SmileBASIC, 154 146 bytes

Esperaba que una respuesta usando el relleno de inundación fuera más corta que esto.

DEF S P
FOR J=0TO 1X=1Y=1FOR I=0TO LEN(P)-1GPSET X,Y,-(P[I]=="#")GPAINT X,Y,-1,-J*(P[I]>@A)X=X*(P[I]>"31")+1INC Y,X<2NEXT
NEXT?!GSPOIT(0,0)GCLS
END

Reemplace 31con el carácter ASCII correspondiente.