Ihre Herausforderung wird durch Eingabe eines Gefängnislayouts beantwortet, um herauszufinden, ob einer der Gefangenen fliehen kann.

Eingang

Eingabe kann in jedem angemessenen Format sein , wie beispielsweise eine Kette, ein Array Array von Arrays usw. Die Eingabe wird von drei Zeichen bestehen, in diesem Fall #, Pund Raum. Die Eingabe muss nicht alle drei Zeichen enthalten.

• #: Eine Mauer
• P: Ein Gefangener
• Raum: Ein leerer Raum

Eine Beispieleingabe sieht folgendermaßen aus:

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

Ausgabe

Ein wahrer / falscher Wert, der angibt, ob das Gefängnis sicher ist oder nicht. Das Gefängnis ist nur dann sicher, wenn es alle Gefangenen aufnehmen kann. Wenn ein Gefangener entkommen kann, ist dies nicht sicher.

Ein Gefangener kann fliehen, wenn er nicht vollständig von einer Mauer umschlossen ist. Eine diagonale Verbindung ist vollständig gekapselt.

Testfälle

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

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

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

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

P             Falsey

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

Schnecken , 13 Bytes

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

Probieren Sie es online!

Druckt 0für unsichere Gefängnisse und die Größe des Begrenzungsrahmens der Eingabe für sichere Gefängnisse.

Damit soll sichergestellt werden, dass wir keinen Pfad von einer PZelle zu einer Zelle außerhalb der Grenzen finden ( ~), der sich nur orthogonal ( o) durch Räume bewegt . Das tist ein Teleport, so dass egal wo wir das Match versuchen es versucht alle möglichen Startpositionen zu finden P.

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

Das absolut falsche Werkzeug und Ansatz, aber trotzdem ...

• Mit den nützlichen Tipps von TheLethalCoder werden 7 Bytes (und mehr) gespart.
• 4 Bytes werden durch die Rückgabe einer Ganzzahl gespeichert.
• 4 weiteres Bytes gespeichert Dank (wieder) zu TheLethalCoder durch den Austausch ' 'mit 32in dem Vergleichen.
• VIELE Bytes, die durch das Refactoring des Codes eingespart wurden.
• 13 weitere Bytes dank TheLethalCoder. :) Ich vergesse immer wieder seine Trinkgelder und er erinnert mich immer wieder daran.

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

Probieren Sie es online!

Grundsätzlich erweitere ich die Positionen der Ps, wenn ein weißer Bereich vorhanden ist, bis er den Rand des Layouts erreicht (oder nicht).

Einige Lizenzen:

• Ich benutze ein char[][]als Eingabe für das Layout.
• Kehrt 0als unsicher und 1als sicher zurück.

Perl 5 , 69 Bytes

-10 Bytes dank @Grimy .

-2 Bytes dank @Neil .

77 Byte Code + -p0Flags.

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

Probieren Sie es online!

Einige kurze Erklärungen:
Die Idee ist, einen Püberall dort zu platzieren, wo die Gefangenen hinkommen können. Befindet sich einer Pin der ersten / letzten Zeile oder in der ersten / letzten Spalte, können die Gefangenen dorthin und dorthin fliehen, was bedeutet, dass das Gefängnis nicht sicher ist.
s/(P| )(.{@{-}})?(?!\1)(?1)/P$2P/sErsetzt ein Leerzeichen rechts von oder unter a Pdurch a Poder ein Leerzeichen links oder über a P.
Prüft /\A.*P|P.*\Z|^P|P$/mabschließend, ob eine Zeile mit einem beginnt oder endet Poder ob sich Pin der ersten oder letzten Zeile ein befindet.

JavaScript (ES6), 134 133 Byte

Nimmt die Eingabe als Array von Arrays von Zeichen. Gibt 0(unsicher) oder 1(sicher) zurück.

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

Testfälle

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 Byte

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)

Übernimmt die Eingabe als durch Zeilenumbrüche getrennte rechteckige Zeichenfolge. Gibt 0 für unsicher und 1 für sicher zurück. Basierend auf meiner Antwort auf Detect Failing Castles , obwohl es effizienter wäre, bei jedem Schritt nach einem entkommenen Gefangenen zu suchen, als wenn sie die Erkundung des Gefängnisses beendet hätten.

Oktave, 64-55 Bytes

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

Probieren Sie es online!

oder

Überprüfen Sie alle Testfälle!

Erläuterung:

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 Byte

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

Probieren Sie es online!

'# '⍳⍵kodieren '#', ' ', 'P'wie 0 1 2

(⌽1,⍉)⍣4 umgeben mit 1s

(××{1⊃⌈/⍵,⍉⍵}⌺3 3)⍣≡ max-of-neighbours füllen sich mit Zellen ungleich null

⊃2≠ Haben wir oben links keine 2?

Stax , 35 Bytes ^CP437

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

Probieren Sie es online!

Sicherlich kann dies auch eine Golfsprache sein, die nicht über eine interne Wegfindung verfügt!

Erläuterung

Verwendet das entpackte Format zur Erklärung.

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

Ich hatte gehofft, eine Antwort mit Flood Fill würde kürzer sein.

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

Ersetzen Sie 31durch das entsprechende ASCII-Zeichen.