Resim Labirentleri Oluşturma

20

Meydan okuma

Bir "görüntüyü" kabul eden ve bu görüntüden oluşturulmuş bir resim labirenti veren bir program / işlev yazın .

Giriş

Programınız iki argümanı kabul etmelidir:

  • Ben, labirenti oluşturan görüntü
  • S, çözümün labirente gösterilip gösterilmeyeceğini belirten bir boolean

Ben aşağıdaki biçimde verilir:

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

burada #çözelti yoluna dahil .edilecek hücreler ve hariç tutulacak hücrelerdir. Dışarı takas olabilir .'s, #' nin ve sizin yeter ki birbirinden farklı olarak seçme herhangi bir karakterle yeni satırların. Alternatif olarak, giriş görüntüsünün gerçek bir bitmap'ini kabul edebilirsiniz.

Çıktı

Ortaya çıkan labirentiniz aşağıdaki biçimde olmalıdır:

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

burada #duvarlar, .yolun çözümün bir parçası olan kısımları ve boşluklar da çözümün dışında tutulan yollardır. .Var S yanlış ise, boşluklar ile ikame edilebilir. Yine, karakterler seçtiğiniz diğer karakterlerle değiştirilebilir veya çözüm vurgulanmış olarak labirentin gerçek bir bit eşlemini çıktılayabilirsiniz.

ek detaylar

  • Yollar bir hücre genişliğinde olmalıdır (yolun dev boş havuzu olamaz)
  • Labirent döngü içermemelidir
  • Labirent tamamen bağlı olmalıdır (tüm hücreler giriş / çıkıştan erişilebilir olmalıdır)
  • Labirent duvarlarla çevrili olmalıdır (giriş / çıkış olmadığı sürece)
  • Çözüm yolu çıkmaz noktaları içermemelidir
  • Labirent için tam 1 giriş ve 1 çıkış olmalıdır
  • Giriş ve çıkış, ızgaranın kenarına hizalanmalı ve çözelti yolunda bulunan bir hücreye bitişik olmalıdır
  • Giriş ve çıkışın nereye yerleştirileceğini seçebilirsiniz
  • Belirli bir giriş görüntüsünden geçerli bir yol oluşturulabileceğini varsayabilirsiniz.

(Açıklama için eklendi) Aşağıdaki şemada, çözüm yolunun giriş görüntüsüyle nasıl ilişkilendirildiği gösterilmektedir:

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

Test Durumları

Sulama Wikipedia'dan örnek olabilir :

Giriş:

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

Çıktı (S = yanlış):

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

Çıktı (S = doğru):

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

Bitmap örneği (yukarıdakiyle aynı labirent):

Giriş: Giriş bitmap'iÇıkış (S = yanlış): Çıktı bitmap çözümü vurgulanmamışÇıkış (S = doğru):Çıktı bitmap çözümü vurgulanır

code-golf  ascii-art  graphical-output  path-finding  maze 
— Dendrobium
kaynak
4
Sadece ben olabilirim, ama çıkış labirentinde giriş resmini görmüyorum.
— Mike Bufardeci
@ mike-bufardeci Çıktı labirentindeki girdi resmini gösteren bir diyagram eklendi. Umarım yardımcı olur!
— Dendrobium
2
Labirentin bağlı olmasını gerektiren bir kural yok gibi görünüyor. Bu geçerli bir çözüm olabilir mi? Ayrıca, ızgaranın duvarlarla çevrili olması gerektiğine dair bir kural görünmemektedir (her duvar olmayan bir giriş veya çıkış olarak düşünülmedikçe). Bu geçerli bir çözüm olabilir mi?
— Martin Ender
1
Ayrıca, lütfen biraz daha test örneği ekleyin.
— flawr
@ MartinBüttner Labirent tamamen birbirine bağlanmalı ve duvarlarla çevrili olmalı, bu noktaları netleştiren soru düzeltilmelidir.
— Dendrobium

Yanıtlar:

10

Python 3, 1599 Bayt

Bunu eğlenceli bir proje olarak buldum ve çok ilginç (ve biraz uzun). Bunu gördüğümde, sadece bir labirent oluşturma algoritması yazmak ve geliştirmek için harcadığım yaz hatırlatıldı ve anında bunun üzerinde çalışmaya başladım.

Bir süre sonra 6000 bayt uzunluğunda bir ilk taslak hazırladım ve sonraki birkaç saati aşağıdaki programa yoğunlaştırarak geçirdim:

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]

Bir ascii-sanat labirenti gibi bakmak mantıklı olmayan ...

Rastgele fonksiyonun doğru yol bulunana kadar kullanılmadığından, aynı girişin kaç kez verildiğine bakılmaksızın, baştan sona rotanın aynı olacağını ve bu programın Yukarıdaki örnekler için işe yarar, bazen 'kendini bir duvara sürüklerse' bir çözüm bulamaz.

Yukarıdaki örnekleri çalıştırırken bunu verir:

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

bu:

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

ve bu:

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

Bu programı kendileri çalıştırmayı denemek isteyen herkes için komutu kullanın M(Image, Show solution). Resmi girmek için üçlü tırnak işaretlerini kullanmanızı öneririm, aksi takdirde çok fazla ters eğik çizgi veya yeni satır karakteri olacak.

— İsimsiz Lifer Yok
kaynak
1
Doğru takma ad: p
— 17'de Fatalize
1
İyi iş! Bazı ipuçları: -> , -> 0yerine kullanın pass, bir değişkene atamaya değer olabilir ve ->l.append(a);l.append(b)l+=a,bl.append(a)l+=[a]'#'def E(G,y,z):\n c=[]def E(G,y,z,c=[]):
— Loovjo
1
Ayrıca, 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)ve (Sanırım test etmedim) G=[s]-> *G=s.
— Loovjo
@Loovjo Tavsiye için teşekkürler except:0, l+=a,bve s=[0]*(1+L(I[0])*2)gerçekten yardımcı oldu. Ne yazık ki, herhangi bir nedenle, işlev çağrısında c atamak, çalışmayı durdurduğu anlamına gelen birden fazla çağrıda sıfırlamaz, G [r] [c] bir dize olabilir, bu yüzden üzerinde <veya> kullanamam ve * G = s bana bir sözdizimi hatası verdi. Yine de, büyük tavsiye.
— İsimsiz Hayır Lifer
1
@AnonymousNoLifer Sorun yok. Ayrıca, eğer G[r][c]bir dize olabilir, G[r][c]in[1,2]çalışması gerekir.
— Loovjo
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.