58

Thử thách của bạn được đưa ra một đầu vào của bố trí nhà tù để tìm ra liệu bất kỳ tù nhân nào có thể trốn thoát.

Đầu vào

Đầu vào có thể ở bất kỳ định dạng hợp lý như một chuỗi, mảng, mảng của mảng, vv Các đầu vào sẽ bao gồm ba nhân vật, trong trường hợp này #, Pvà không gian. Đầu vào sẽ không nhất thiết phải chứa cả ba ký tự.

#: Bức tường
P: Một người tù nhân
không gian: Một không gian trống

Một ví dụ đầu vào sẽ giống như:

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

Đầu ra

Giá trị trung thực / falsey của nhà tù có an toàn hay không. Nhà tù chỉ an toàn nếu nó có thể giam giữ tất cả các tù nhân. Nếu bất kỳ tù nhân nào có thể trốn thoát thì không an toàn.

Một tù nhân có thể trốn thoát nếu họ không được bao bọc hoàn toàn bởi một bức tường. Một nối chéo được bao kín hoàn toàn.

Các trường hợp thử nghiệm

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

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

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

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

P             Falsey

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

— TheLethalCoder
nguồn

8

Tôi có cảm giác đây là một bản sao hoặc ít nhất là một thử thách tương tự. Dù sao thử thách tốt.

— John Dvorak

2

@JanDvorak Có thể nhưng với Google Fu giới hạn của tôi, tôi không thể tìm thấy bản sao.

— TheLethalCoder

2

có liên quan (Lấp đầy lưới 2D)

— Esolanging Fruit

3

Sẽ rất tốt nếu có các ví dụ Falsey trong đó cả hai chuyển động ngang và dọc được yêu cầu để thoát ra.

— xnor

2

@tfbninja Không thực sự là một bản sao. Người ta yêu cầu cố gắng để chương trình ngoại suy từ dữ liệu đã cho để xác định xem từ đó có trong hộp không. Đây là bản lấp đầy BFS để xem liệu có không gian không bị che khuất giữ các giá trị được đánh dấu.

— HyperNeutrino

54

Ốc , 13 byte

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

Hãy thử trực tuyến!

In 0cho các nhà tù không an toàn và kích thước của hộp giới hạn của đầu vào cho các nhà tù an toàn.

Ý tưởng là để đảm bảo rằng chúng ta không thể tìm thấy một đường dẫn từ một Pđến một ô ngoài giới hạn ( ~) chỉ di chuyển trực giao ( o) qua các không gian. Đây tlà một dịch chuyển tức thời để bất kể nơi nào chúng tôi thử trận đấu, nó sẽ cố gắng tìm tất cả các vị trí bắt đầu có thể để tìm a P.

— Martin Ender
nguồn

23

Công cụ phù hợp.

— Jonathan Allan

16

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

Công cụ và cách tiếp cận hoàn toàn sai, nhưng dù sao ...

7 byte (và hơn thế nữa) được lưu với các mẹo hữu ích từ TheLethalCoder.
4 byte được lưu bằng cách trả về một số nguyên.
Thêm 4 byte được lưu cảm ơn (một lần nữa) vào TheLethalCoder bằng cách thay thế ' 'bằng 32trong các so sánh.
RẤT NHIỀU byte được lưu bằng cách cấu trúc lại mã.
Thêm 13 byte nhờ (đoán ai?) TheLethalCoder. :) Tôi tiếp tục quên lời khuyên của anh ấy và anh ấy cứ nhắc tôi.

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

Hãy thử trực tuyến!

Về cơ bản, tôi mở rộng các vị trí của P mỗi khi có khoảng trắng xung quanh cho đến khi chạm tới (hoặc không) đường viền của bố cục.

Một số giấy phép:

Tôi sử dụng char[][]như là một đầu vào cho bố trí.
Trả về 0là không an toàn và 1an toàn.

— Charlie
nguồn

Bạn không thể lấy thêm đầu vào cho chức năng để bạn có thể giả sử kích thước ... Trừ khi bạn có thể tìm thấy một bài đăng meta để thuyết phục tôi bằng cách khác.

— TheLethalCoder

1>0và 1<0ngắn hơn truevà false.

— TheLethalCoder

1

Có thể ==0trở thành <1? Bạn có ít nhất 1 byte khoảng trắng không liên quan. Bạn có thể loại bỏ các new[]s? (Không phải lúc nào cũng hoạt động nhưng đôi khi không thích trong int[] n = {1,2,3};).

— TheLethalCoder

1

{m[x][y]= p; c.Push(new[]->{m[x][y]=p;c.Push(new[]

— TheLethalCoder

1

Bạn có thể so sánh chars để ints vì vậy tôi tin rằng bạn có thể thay thế ==' 'để ==32tiết kiệm byte. Bạn cũng có thể làm điều này trên các so sánh tương tự.

— TheLethalCoder

15

Perl 5 , 69 byte

-10 byte nhờ @Grimy .

-2 byte nhờ @Neil .

77 byte mã + -p0cờ.

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

Hãy thử trực tuyến!

Một số giải thích ngắn gọn :
Ý tưởng là đặt Pmọi nơi mà các tù nhân có thể đi. Nếu bất kỳ Pnằm trên dòng đầu tiên / cuối cùng, hoặc cột đầu tiên / cuối cùng, thì các tù nhân có thể đến đó và trốn thoát, điều đó có nghĩa là nhà tù không an toàn.
s/(P| )(.{@{-}})?(?!\1)(?1)/P$2P/sthay thế một khoảng trắng ở bên phải hoặc dưới a Pbằng một Phoặc một khoảng trắng ở bên trái hoặc trên đỉnh của a P.
Cuối cùng, /\A.*P|P.*\Z|^P|P$/mkiểm tra xem một dòng bắt đầu hoặc kết thúc bằng a P, hoặc nếu có một Pdòng đầu tiên hoặc dòng cuối cùng.

— Dada
nguồn

phương pháp tuyệt vời bằng cách sử dụng regexps! (nhưng có lẽ RẤT đắt khi không gian phát triển)

— Olivier Dulac

Trên thực tế, nó không phải là không hiệu quả. Đặc biệt, nó không yêu cầu quay lại nhiều, không có *hoặc +, trận đấu dài nhất có thể làm là kích thước của một dòng ... Tất nhiên bây giờ nếu bạn so sánh với một cách tiếp cận thủ công hơn, ví dụ dựa trên mảng , vâng, nó khá kém hiệu quả!

— Dada

1

-6 byte bằng cách hợp nhất hai thay thế : s/P(.{@{-}})? | (.{@{-}})?P/P$1$2P/s.

— Grimmy

1

-2 byte bằng cách chơi golf thay thế hợp nhất : s/(P| )(.{@{-}})?(?!\1)(?1)/P$2P/s.

— Grimmy

2

@Grimy chơi golf rất hay của regex! Cảm ơn :)

— Dada

7

JavaScript (ES6), 134 133 byte

Đưa đầu vào như một mảng các mảng ký tự. Trả về 0(không an toàn) hoặc 1(an toàn).

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

Các trường hợp thử nghiệm

Hiển thị đoạn mã

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

Mở rộng đoạn trích

— Arnauld
nguồn

Có thể &&chỉ là &?

— TheLethalCoder

@TheLethalCoder Không phải cái đầu tiên, nhưng cái thứ hai có thể được thay thế bằng |. Cảm ơn!

— Arnauld

Không biết toán tử lây lan làm việc trên chuỗi. Mát mẻ!

— aebabis

6

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)

Đưa đầu vào dưới dạng một chuỗi hình chữ nhật được phân cách bằng dòng mới. Trả về 0 cho không an toàn và 1 cho an toàn. Dựa trên câu trả lời của tôi để phát hiện ra các lâu đài thất bại , mặc dù sẽ hiệu quả hơn khi kiểm tra một tù nhân trốn thoát ở mỗi bước, thay vì một khi họ đã khám phá xong nhà tù.

— Neil
nguồn

2

Octave, 64 55 byte

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

Hãy thử trực tuyến!

hoặc là

Xác nhận tất cả các trường hợp thử nghiệm!

Giải trình:

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

— rahnema1
nguồn

2

APL (Dyalog Classic) , 40 byte

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

Hãy thử trực tuyến!

'# '⍳⍵mã hóa '#', ' ', 'P'như 0 1 2

(⌽1,⍉)⍣4 bao quanh với 1s

(××{1⊃⌈/⍵,⍉⍵}⌺3 3)⍣≡ Lấp đầy vùng lân cận lấp đầy các ô khác không

⊃2≠ chúng ta không có số 2 ở trên cùng bên trái?

— ngn
nguồn

1

Stax , 35 byte ^CP437

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

Hãy thử trực tuyến!

Chắc chắn ngôn ngữ chơi golf mà không có nội bộ để xử lý việc tìm đường cũng có thể làm điều này!

Giải trình

Sử dụng định dạng giải nén để giải thích.

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

— Weijun Chu
nguồn

1

SmileBASIC, 154 146 byte

Tôi đã hy vọng một câu trả lời bằng cách sử dụng lũ lụt sẽ ngắn hơn thế này.

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

Thay thế 31bằng ký tự ASCII tương ứng.

— 12Me21
nguồn

Nhà tù của tôi có an toàn không?

Ốc , 13 byte

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

Perl 5 , 69 byte

JavaScript (ES6), 134 133 byte

Các trường hợp thử nghiệm

JavaScript (ES6), 121 byte

Octave, 64 55 byte

APL (Dyalog Classic) , 40 byte

Stax , 35 byte CP437

Giải trình

SmileBASIC, 154 146 byte

Stax , 35 byte ^CP437