Trong thế giới nghệ thuật ASCII, có nước, tường băm và cơ chế chữ.

Bạn đang ở trong một căn phòng được tạo thành từ những bức tường băm ( #bảng hiệu):

#######
#     #
#     #
#     #
# ### #
#     #
#######

Bạn lắp đặt nguồn nước S ( Sbiển báo) và bể nước E ( Ebiển báo) có thể nhận nước từ mọi hướng, nhưng bạn chỉ có một nguồn S và một bể E.

#######
#  S  #
#     #
#     #
# ### #
#  E  #
#######

Vì vậy, bạn phải chọn một cách khôn ngoan nơi đặt nguồn. Đó là nơi bạn thực hiện các kỹ năng chơi gôn của mình.

Nhiệm vụ

Bạn nhận được một đầu vào bao gồm một chuỗi đại diện cho một phòng có nguồn và bể:

#######
#  S  #
#     #
#     #
# ### #
#  E  #
#######

Bạn phải tìm hiểu xem cuối cùng nước có đến bể không. Nước chảy xuống, nếu có thể, khác bên trái và bên phải, nếu có thể. Nước không tích tụ vì nó không đi lên.

Vì vậy, đối với đầu vào trên, kết quả là:

#######
#  *  #
#  *  #
#*****#
#*###*#
#**O**#
#######

Nước hạnh phúc đến bể, vì vậy bạn phải xuất ra một giá trị trung thực.

Nhưng nếu nước không đến bể:

#######
#S    #
#     #
#  E  #
# ### #
#     #
#######

#######
#*    #
#*    #
#* X  #
#*### #
#*****#
#######

Sau đó, bạn phải xuất ra một giá trị giả.

Viết chương trình để quyết định xem nước cuối cùng có đến bể không. Mã của bạn nên càng ngắn càng tốt.

Giả định

• Giả sử rằng đầu vào luôn hợp lệ (toàn bộ phòng là một khu vực hình chữ nhật kèm theo S và E).

• Giả sử chỉ có một phòng được cung cấp làm đầu vào.

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

Chương trình của bạn sẽ trả về giá trị trung thực cho các trường hợp kiểm tra sau:

#######
#  S  #
#     #
#     #
# ### #
#  E  #
#######

#######
#  S  #
#     #
#  E  #
#     #
#     #
#######

#######
#     #
#     #
# SE  #
# ### #
#     #
#######

###############################################
#                      S                      #
#                                             #
#                                             #
#                                             #
#               ###############               #
#                                             #
#  ##################     ##################  #
#                                             #
#                                             #
#                    #####                    #
#                      E                      #
###############################################

#######
#  S  #
#     #
#     #
# ### #
#   # #
### ###
## E ##
#     #
#######

Nhưng một giá trị giả cho các trường hợp thử nghiệm sau:

#######
#S    #
#     #
#  E  #
# ### #
#     #
#######

#######
#     #
# SE  #
#     #
#     #
#     #
#######

#######
#     #
#  E  #
#     #
#  S  #
#     #
#######

####################################
#                                  #
#                                  #
#                                  #
#S             #                  E#
####################################

Phòng thứ hai đến cuối cùng trong danh mục Đúng và phòng cuối cùng trong danh mục Sai đã bị đánh cắp một cách đáng xấu hổ mượn từ Koth: Jump and Run của Manu (người đã xóa bài đăng hộp cát).

Căn phòng cuối cùng trong danh mục True là từ câu trả lời của Martin Buttner ở Retina .

Ốc , 20 byte

\S{d(=\#n)?^#},!(t\E

In 0cho giá trị falsey và 1cho giá trị trung thực.

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

• \Strận đấu Skhi bắt đầu
• d đặt hướng xuống
• {...}, phù hợp với những thứ trong niềng răng 0 lần trở lên
• =\#là một khẳng định thành công nếu có một #char trước con ốc, nhưng không di chuyển nó
• n quay 90 độ theo hai hướng
• (...)? khớp với mẫu trong ngoặc 0 hoặc 1 lần
• \ ​ phù hợp với một không gian và di chuyển con ốc lên nó
• !(... là một khẳng định tiêu cực
• t dịch chuyển tức thời đến bất kỳ ô vuông nào chưa từng có trong lưới
• \E kết quả phù hợp E

Trượt , 20 + 2 = 22 byte

S>( ^4|^4(?|`#)^T)*E

Vì vậy, Trượt vẫn bị phá vỡ như mọi khi, nhưng lần đầu tiên đây là một thử thách mà nó thực sự có thể làm. Nó chưa bao giờ thực sự được thiết kế để trở thành golf như vậy, vì vậy nó sẽ không bao giờ đánh bại Ốc sên ở bất cứ điều gì: P

Cần rcờ (không có ô lặp lại) để chấm dứt.

Hãy thử trực tuyến . Đầu ra là con đường thực hiện cho sự thật, trống rỗng cho sự giả dối.

S                 Match S
>                 Rotate pointer downward
(                 Either...
 <space>^4          Match a space and point downwards
 |                  or
 ^4                 Point downwards
 (?|`#)             Match # below then reset pointer
 ^T                 Either turn left or right
)*                ... 0+ times
E                 Match E

Võng mạc , 87 byte

Số lượng byte giả định mã hóa ISO 8859-1.

+mT`E `S`(?<=^(?(1)!)(?<-1>.)*S.*¶(.)*)[E ]|.?S(?=(.)*¶.*#(?<-2>.)*(?(2)!)$)[E ]?
M`E
0

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

Có thể xử lý chuỗi 2D nhiều như vậy trong Retina (hay nói chung là regex .NET), nó không chính xác ngắn gọn ...

Giải trình

+mT`E `S`(?<=^(?(1)!)(?<-1>.)*S.*¶(.)*)[E ]|.?S(?=(.)*¶.*#(?<-2>.)*(?(2)!)$)[E ]?

Đây là một vùng lũ, đánh dấu tất cả các tế bào được tiếp cận bởi nước S. Nó như vậy bằng cách kết hợp các ký tự có thể đạt được và sau đó chuyển ngữ họ Svới T-mode. Lấp đầy này đi qua cả không gian và E. Lúc +bắt đầu lặp lại điều này cho đến khi đầu ra ngừng thay đổi.

Đối với regex thực tế có hai trường hợp riêng biệt:

(?<=^(?(1)!)(?<-1>.)*S.*¶(.)*)[E ]

Cái này khớp với một khoảng trắng hoặc Echính xác là một ô bên dưới một ô S. Việc khớp dọc được thực hiện bằng cách đếm tiền tố trên dòng hiện tại bằng cách sử dụng các nhóm cân bằng để chúng tôi có thể đảm bảo rằng vị trí ngang là như nhau. Cái này chăm sóc nước rơi.

.?S(?=(.)*¶.*#(?<-2>.)*(?(2)!)$)[E ]?

Điều này rất giống nhau: nó khớp với một Svà nếu có sẵn ký tự trước và sau nó, với điều kiện là ký tự trực tiếp bên dưới Slà a #. Điều này chăm sóc nước lan dọc theo mặt đất.

Khi chúng ta hoàn thành, rất dễ dàng để xác định xem nước có đạt được hay không E. Nếu có, thì Eđã bị xóa khỏi chuỗi trong vùng lũ và nếu không Ethì vẫn còn đó. Vì vậy, hãy đếm số Es:

M`E

Nhưng bây giờ, điều đó 0(mà tôi cho là giả mạo) đối với các trường hợp thử nghiệm trung thực và 1(mà tôi cho là trung thực) đối với các trường hợp thử nghiệm giả. Chúng ta có thể đảo ngược điều này rất dễ dàng bằng cách đếm số 0s trong kết quả này:

0

Làm xong.