Tạo Mazes hình ảnh

20

Thử thách

Viết chương trình / chức năng chấp nhận "hình ảnh" và xuất ra một mê cung hình ảnh được hình thành từ hình ảnh đó.

Đầu vào

Chương trình của bạn nên chấp nhận hai đối số:

  • Tôi, hình ảnh để tạo thành mê cung từ
  • S, một boolean chỉ định có hay không hiển thị giải pháp cho mê cung

Tôi được đưa ra dưới hình thức sau:

.......
.#####.
.#####.
#######
.#####.
.#####.
.......

trong đó #các ô được bao gồm trong đường dẫn giải pháp và .là các ô được loại trừ. Bạn có thể trao đổi trên các .'s, #' s và dòng mới với bất kỳ ký tự lựa chọn của bạn miễn là chúng khác nhau từ mỗi khác. Ngoài ra, bạn có thể chấp nhận một bitmap thực tế của hình ảnh đầu vào.

Đầu ra

Mê cung kết quả của bạn phải ở dạng sau:

###############
#             #
# ### ####### #
# #.........# #
# #.#######.# #
# #.#.......# #
###.#.#########
....#.#........
#####.#.#######
#  ...#.....  #
# #.#######.# #
# #.........# #
# ####### ### #
#   #       # #
###############

trong đó #biểu thị các bức tường, .biểu thị các phần của đường dẫn là một phần của giải pháp và các khoảng trắng là các đường dẫn được loại trừ khỏi giải pháp. Các .dấu có thể được thay thế bằng dấu cách nếu S sai. Một lần nữa, các ký tự có thể được hoán đổi với các ký tự khác mà bạn chọn hoặc bạn có thể xuất ra một bitmap thực tế của mê cung với giải pháp được tô sáng.

Chi tiết bổ sung

  • Đường dẫn phải rộng một ô (không thể có không gian trống khổng lồ là đường dẫn)
  • Mê cung không được chứa bất kỳ vòng lặp nào
  • Mê cung phải được kết nối đầy đủ (tất cả các ô phải có thể truy cập từ lối vào / lối ra)
  • Mê cung phải được bao quanh bởi các bức tường (trừ khi nó là lối vào / lối ra)
  • Đường dẫn giải pháp không được bao gồm ngõ cụt
  • Phải có chính xác 1 lối vào và 1 lối ra cho mê cung
  • Lối vào và lối ra phải được căn chỉnh theo cạnh của lưới và liền kề với một ô có trong đường dẫn giải pháp
  • Bạn có thể chọn nơi đặt lối vào và lối ra
  • Bạn có thể cho rằng một đường dẫn hợp lệ có thể được hình thành từ hình ảnh đầu vào đã cho

(Đã thêm để làm rõ) Sơ đồ bên dưới hiển thị cách đường dẫn giải pháp tương quan với hình ảnh đầu vào:

Input (I): |    Output:            |    Corresponding Cells: 
           |                       |    (@'s denote #'s from I)
           |                       |
.......    |    ###############    |    ###############
.#####.    |    #             #    |    #             #
.#####.    |    # ### ####### #    |    # ### ####### #
#######    |    # #.........# #    |    # #@.@.@.@.@# #
.#####.    |    # #.#######.# #    |    # #.#######.# #
.#####.    |    # #.#.......# #    |    # #@#@.@.@.@# #
.......    |    ###.#.#########    |    ###.#.#########
           |    ....#.#........    |    .@.@#@#@.@.@.@.
           |    #####.#.#######    |    #####.#.#######
           |    #  ...#.....  #    |    #  @.@#@.@.@  #
           |    # #.#######.# #    |    # #.#######.# #
           |    # #.........# #    |    # #@.@.@.@.@# #
           |    # ####### ### #    |    # ####### ### #
           |    #   #       # #    |    #   #       # #
           |    ###############    |    ###############
           |                       |

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

Ví dụ tưới nước từ Wikipedia :

Đầu vào:

..................
..................
.......####.......
......##..##......
.....##....##....#
.....#......#...##
.#############.##.
##..############..
#...###########...
#...##########....
#...##########....
#...##########....
#...##########....
....##########....
....##########....
....##########....
..................
..................

Đầu ra (S = false):

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

Đầu ra (S = true):

#####################################
#   #     #   #   #     #           #
# ### ### ### # # ##### ### ### ### #
#     # #   # # #         # #   # # #
# ### # ##### # ########### # ### # #
# # #         #.......    # # #   # #
# # # ### #####.# ###.### # ### ### #
#   # # #   #...# # #...# #   # #   #
# ### # #####.##### ###.##### # # ###
# #   #    ...#   #   #...    # # #..
### #######.### ### # ###.##### ###.#
#   #     #.#   #   #   #.#   # #...#
# ### #####.# ### #######.# # # #.# #
# #.......#.............#...# #...# #
# #.#####.#############.###.###.### #
#...#   #.......#.....#...#.#...# # #
#.### # #######.#.###.###.#.#.### # #
#.# # #  .......#...#.#...#...#     #
#.# # ###.#########.#.#.##### # #####
#.#   # #.#.......#.#...#...# # #   #
#.##### #.#.#####.#.#####.#.# ### # #
#.      #.#...#...#.#.....#.#   # # #
#.### ###.###.#.###.#.#####.####### #
#.  # # #.....#.#...#.#.....  #     #
#.# # # #######.#.###.#.##### # ### #
..# # # #...#...#.....#.....# #   # #
### # # #.#.#.#############.# ### # #
#   # # #.#...#.........#...# #   # #
##### # #.#####.#######.#.### ##### #
#     # #.#...#.......#.#...#       #
##### # #.#.#.#######.#.###.#########
#     #  ...#.........#.....  #     #
# ### ######### ############# # #####
# # #   #     # #       #     #     #
# # ######### # ####### ####### ### #
#             #                 #   #
#####################################

Ví dụ về bitmap (cùng mê cung như trên):

Đầu vào: Ảnh bitmap đầu vàoĐầu ra (S = false): Giải pháp bitmap đầu ra không được làm nổi bậtĐầu ra (S = true):Giải pháp bitmap đầu ra được tô sáng

code-golf  ascii-art  graphical-output  path-finding  maze 
— Dendrobium
nguồn
4
Chỉ có thể là tôi, nhưng tôi không thấy hình ảnh đầu vào trong mê cung đầu ra.
— Mike Bufardeci
@ mike-bufardeci Đã thêm một sơ đồ hiển thị hình ảnh đầu vào trong mê cung đầu ra. Mong rằng sẽ giúp!
— Dendrobium
2
Dường như không có một quy tắc nào yêu cầu mê cung được kết nối. Đây sẽ là một giải pháp hợp lệ? Dường như cũng không có một quy tắc nào là lưới phải được bao quanh bởi các bức tường (trừ khi mọi bức tường không được coi là lối vào hoặc lối ra). Đây sẽ là một giải pháp hợp lệ?
— Martin Ender
1
Ngoài ra, xin vui lòng thêm một số trường hợp thử nghiệm.
— flawr
@ MartinBüttner Mê cung cần được kết nối đầy đủ và được bao quanh bởi các bức tường, chỉnh sửa câu hỏi làm rõ những điểm này.
— Dendrobium

Câu trả lời:

10

Python 3, 1599 byte

Tôi thấy đây là một dự án thú vị và rất thú vị (và hơi dài dòng). Khi tôi nhìn thấy điều này, tôi đã nhớ lại mùa hè tôi dành riêng để viết và cải thiện thuật toán tạo mê cung và ngay lập tức phải làm việc này.

Sau một thời gian, tôi đã có một bản nháp ban đầu dài khoảng 6000 byte và tôi đã dành vài giờ tiếp theo để cô đọng nó vào chương trình sau:

import math,random;R=range;L=len;T=sorted;P=print;N=random.randint
def M(I,S):
 I=I.rsplit('\n');s=[0]*(1+L(I[0])*2);G=[s]
 for i in R(L(I)):
  r=[0]
  for x in I[i]:r+=x,0
  G+=[r];s=[0]*(1+L(I[0])*2);G+=[s]
 c=E(G,L(G[0])-2,-2);G[c][L(G[0])-1]=1;e=[c,L(G[0])-2];c=E(G,1,2);G[c][0]=1;G[c][1]=1;s=[c,1]
 while s!=e:
  o=[];Q(G,s,e,-2,0,o,0);Q(G,s,e,0,2,o,1);Q(G,s,e,2,0,o,2);Q(G,s,e,0,-2,o,3);o=T(o,key=lambda x:(x[2],-x[1]))[0][0]
  if o==0:G[s[0]-1][s[1]]=1;s[0]-=2
  elif o==1:G[s[0]][s[1]+1]=1;s[1]+=2
  elif o==2:G[s[0]+1][s[1]]=1;s[0]+=2
  else:G[s[0]][s[1]-1]=1;s[1]-=2
  G[s[0]][s[1]]=1
 s=0
 while not s:
  r=N(1,(L(G)-1)/2)*2-1;c=N(1,(L(G[0])-1)/2)*2-1
  if G[r][c]in[1,2]:
   o=[];F(G,r-2,c,o,0);F(G,r,c+2,o,1);F(G,r+2,c,o,2);F(G,r,c-2,o,3)
   try:
    if o[0]==0:G[r-1][c]=2;G[r-2][c]=2
    elif o[0]==1:G[r][c+1]=2;G[r][c+2]=2
    elif o[0]==2:G[r+1][c]=2;G[r+2][c]=2
    else:G[r][c-1]=2;G[r][c-2]=2
   except:0
  s=1
  for x in G:
   if'.'in x:s=0;break
 *s,='#  '
 if S:s[1]='.'
 for x in G:
  for y in x:P(s[y],end='')
  P()
def Q(G,s,e,x,y,o,a,n=0):
 c=lambda x,y:G[s[0]+x][s[1]+y]is'#'
 try:
  if c(x,y):
   try:n+=c(2*x,2*y)
   except:0
   try:n+=c(x+abs(x)-2,y+abs(y)-2)
   except:0
   try:n+=c(x-abs(x)+2,y-abs(y)+2)
   except:0
   o+=[[a,math.sqrt((s[0]+x-e[0])**2+(s[1]+y-e[1])**2),n]]
 except:0
def F(G,r,c,o,a):
 try:
  if G[r][c] is'.':o+=[a]
 except:0
def E(G,y,z,d='#'):
 c=[]
 for x in R(1,L(G)-1,2):
  n=0
  try:n+=G[x-2][y]==d
  except:0
  try:n+=G[x+2][y]==d
  except:0
  n+=G[x][y+z]==d
  if G[x][y]==d:c+=[[x,n]]
 if L(c)>1:c=T(c,key=lambda x:x[1])
 return c[0][0]

Cái mà không nhạy cảm khi nhìn vào như một mê cung nghệ thuật ascii là ...

Điều đáng chú ý là, vì hàm ngẫu nhiên không được sử dụng cho đến sau khi tìm thấy đường dẫn chính xác, cho dù đầu vào được đưa ra bao nhiêu lần, thì tuyến đường từ đầu đến cuối sẽ giống nhau và trong khi chương trình này thực hiện làm việc cho các ví dụ trên, đôi khi nó sẽ không thể tìm ra giải pháp nếu nó 'tự lái vào tường' để nói.

Khi chạy các ví dụ trên, nó đưa ra điều này:

>>> M('''.......
.#####.
.#####.
#######
.#####.
.#####.
.......''',True)
###############
# # #   # #   #
# # # ### # # #
# #...#.....# #
# #.#.#.###.###
#  .#.#.#...# #
###.#.#.#.### #
....#.#.#.#....
# ###.#.#.#.###
# #...#.#.#.  #
# #.###.#.#.# #
# #.....#...# #
### ####### # #
#         # # #
###############
>>>

điều này:

>>> M('''..................
..................
.......####.......
......##..##......
.....##....##....#
.....#......#...##
.#############.##.
##..############..
#...###########...
#...##########....
#...##########....
#...##########....
#...##########....
....##########....
....##########....
....##########....
..................
..................''',False)
#####################################
# #     #   # # #   # #   # # # # # #
# ### ##### # # # ### # ### # # # # #
#   # # #   #   # # # #   # # #   # #
### # # ### # ### # # # ### # ### # #
# #     #   # #         # # # # # # #
# ### ##### # # ##### ### # # # # # #
# # #   #   #     # #   # # # # # # #
# # # ##### # ##### ### # # # # # # #
# # # #         # # #         #      
# # # # # # ##### # ### # ######### #
# #   # # # #   # # # # # # # # #   #
# # ####### # ### # # ### # # # # # #
#         # #           #   #     # #
### ##### # # ######### ### ### ### #
#     #   # # #   #   #     #   # # #
# ### ### # # # # # # ####### ### # #
#   # #   # # # # # # #   #       # #
# ##### # # # # # # # # # # # ##### #
#   #   # # # # # # # # #   #     # #
# ####### # # # # # # # #############
#   #     # # # # # # #         #   #
# ####### # # # # # # ##### ##### # #
#   #     # # # # # #           # # #
# ### ### # # # # # ######### ### ###
    # #   # # # # #         #   #   #
# ### # # # # # # ######### ##### ###
#   # # # # # # #                 # #
# # # ### # # # ################### #
# # # # # # # #               #     #
# ### # # # # ############# ### ### #
# # # #     #                     # #
# # ##### # # # ##### # # ##### ### #
# # #     # # #     # # #     #   # #
### ##### # ### # # # ##### # ### # #
#         #   # # # #     # #   # # #
#####################################
>>>

và cái này:

>>> M('''..................
..................
.......####.......
......##..##......
.....##....##....#
.....#......#...##
.#############.##.
##..############..
#...###########...
#...##########....
#...##########....
#...##########....
#...##########....
....##########....
....##########....
....##########....
..................
..................''',True)
#####################################
#     #     # #   # # # # # # #     #
##### # # ### ### # # # # # # ### # #
# # # # # # # #     # # # # # # # # #
# # # ### # # ##### # # # # # # # ###
#   # #   # # #.......# #     #   # #
### # ### # # #.#####.# # ####### # #
#   # #   # #...#   #...#   # #   # #
### # ### # #.# # ### #.# ### ### # #
# # # # # #...# #   # #...  # #   #..
# # # # # #.# ### #######.### ### #.#
# #     #  .# #   # # #  .    # #...#
# # #######.##### # # ###.##### #.# #
#  .......#.#...........#...# #...# #
###.# ###.#.#.#########.###.# #.### #
#...# #  .#.#.#...#...#.....#...  # #
#.#######.#.#.#.#.#.#.#######.#######
#.    #  .#.#.#.#.#.#.#...#...#     #
#.#######.#.#.#.#.#.#.#.#.#.### #####
#.    #  .#.#.#.#.#.#.#.#...        #
#.#######.#.#.#.#.#.#.#.#############
#.    # #.#.#.#.#.#.#.#.....        #
#.##### #.#.#.#.#.#.#.#####.#########
#.  #    .#.#.#.#.#.#.......  # #   #
#.# # ###.#.#.#.#.#.########### # ###
..# # #  .#.#.#.#.#.........#   # # #
# # #####.#.#.#.#.#########.# ### # #
# # #    .#.#.#.#...........        #
#########.#.#.#.############### #####
#   #    .#.#.#.............# #     #
### # ###.#.#.#############.# ##### #
#     #  ...#...............      # #
##### # # ### # # # # ### # # ##### #
#     # #   # # # # #   # # #   #   #
####### # ### # # # ##### # ####### #
#       # #   # # #     # #       # #
#####################################
>>>

Đối với bất kỳ ai muốn thử tự chạy chương trình này, hãy sử dụng lệnh M(Image, Show solution). Tôi khuyên bạn nên sử dụng dấu ngoặc kép để nhập hình ảnh vì nếu không sẽ có nhiều dấu gạch chéo ngược hoặc ký tự dòng mới liên quan.

— Vô danh không có người cứu hộ
nguồn
1
Biệt danh chính xác: p
— Fatalize
1
Công việc tốt đẹp! Một số mẹo: Sử dụng 0thay vì pass, l.append(a);l.append(b)-> l+=a,b, l.append(a)-> l+=[a], có thể đáng để gán '#'cho một biến và def E(G,y,z):\n c=[]->def E(G,y,z,c=[]):
— Loovjo
1
Ngoài ra, if G[r][c]==1 or G[r][c]==2:-> if 0<G[r][c]<3:, s=[0]\n for x in R(L(I[0])*2):s+=[0]-> s=[0]*(1+L(I[0])*2)và (tôi nghĩ rằng, chưa thử nghiệm nó) G=[s]-> *G=s.
— Loovjo
@Loovjo Cám ơn những lời khuyên, những except:0, l+=a,bvà s=[0]*(1+L(I[0])*2)thực sự đã giúp. Thật không may, vì bất kỳ lý do gì, việc gán c trong lệnh gọi hàm không đặt lại nó qua nhiều cuộc gọi có nghĩa là nó đã ngừng hoạt động, G [r] [c] có thể là một chuỗi vì vậy tôi không thể sử dụng <hoặc> trên nó và * G = s đã cho tôi một lỗi cú pháp. Tuy nhiên, lời khuyên tuyệt vời.
— Anonymous No Lifer
1
@AnonymousNoLifer Không có vấn đề. Ngoài ra, nếu G[r][c]có thể là một chuỗi, G[r][c]in[1,2]nên làm việc.
— Loovjo
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookie và Chính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.