Herausforderung
Schreiben Sie ein Programm / eine Funktion, die ein "Bild" akzeptiert und ein aus diesem Bild gebildetes Bildlabyrinth ausgibt .
Eingang
Ihr Programm sollte zwei Argumente akzeptieren:
- Ich, das Bild, aus dem sich das Labyrinth zusammensetzt
- S, ein Boolescher Wert, der angibt, ob die Lösung für das Labyrinth angezeigt werden soll oder nicht
Ich werde in der folgenden Form gegeben:
.......
.#####.
.#####.
#######
.#####.
.#####.
.......
Dabei handelt #
es sich um Zellen, die in den Lösungspfad aufgenommen werden sollen, und .
um Zellen, die ausgeschlossen werden sollen. Sie können die Swap .
‚s, #
‘ s und neue Zeilen mit jedem Charakter Ihrer solange sie voneinander unterscheiden zu wählen. Alternativ können Sie eine tatsächliche Bitmap des Eingabebildes akzeptieren.
Ausgabe
Das resultierende Labyrinth sollte die folgende Form haben:
###############
# #
# ### ####### #
# #.........# #
# #.#######.# #
# #.#.......# #
###.#.#########
....#.#........
#####.#.#######
# ...#..... #
# #.#######.# #
# #.........# #
# ####### ### #
# # # #
###############
wo #
‚s bezeichnen die Wände, .
‘ s bezeichnen die Abschnitte des Weges, der ein Teil der Lösung sind, und Zwischenräume sind Pfade von der Lösung ausgeschlossen. Die .
's können durch Leerzeichen ersetzt werden, wenn S falsch ist. Auch hier können Zeichen mit anderen Zeichen Ihrer Wahl ausgetauscht werden, oder Sie können eine tatsächliche Bitmap des Labyrinths mit der hervorgehobenen Lösung ausgeben.
Zusätzliche Details
- Die Pfade müssen eine Zelle breit sein (der Pfad darf kein riesiger Pool von leeren Räumen sein)
- Das Labyrinth darf keine Schleifen enthalten
- Das Labyrinth muss vollständig verbunden sein (alle Zellen müssen vom Eingang / Ausgang aus erreichbar sein)
- Das Labyrinth muss von Mauern umgeben sein (es sei denn, es ist ein Eingang / Ausgang)
- Der Lösungspfad darf keine Sackgassen enthalten
- Es muss genau 1 Eingang und 1 Ausgang für das Labyrinth geben
- Der Eingang und der Ausgang müssen am Rand des Gitters und neben einer im Lösungspfad enthaltenen Zelle ausgerichtet sein
- Sie können wählen, wo der Eingang und der Ausgang platziert werden
- Sie können davon ausgehen, dass aus dem angegebenen Eingabebild ein gültiger Pfad gebildet werden kann
(Zur Verdeutlichung hinzugefügt) Das folgende Diagramm zeigt, wie der Lösungspfad mit dem Eingabebild korreliert:
Input (I): | Output: | Corresponding Cells:
| | (@'s denote #'s from I)
| |
....... | ############### | ###############
.#####. | # # | # #
.#####. | # ### ####### # | # ### ####### #
####### | # #.........# # | # #@.@.@.@.@# #
.#####. | # #.#######.# # | # #.#######.# #
.#####. | # #.#.......# # | # #@#@.@.@.@# #
....... | ###.#.######### | ###.#.#########
| ....#.#........ | .@.@#@#@.@.@.@.
| #####.#.####### | #####.#.#######
| # ...#..... # | # @.@#@.@.@ #
| # #.#######.# # | # #.#######.# #
| # #.........# # | # #@.@.@.@.@# #
| # ####### ### # | # ####### ### #
| # # # # | # # # #
| ############### | ###############
| |
Testfälle
Gießkanne zB aus Wikipedia :
Eingang:
..................
..................
.......####.......
......##..##......
.....##....##....#
.....#......#...##
.#############.##.
##..############..
#...###########...
#...##########....
#...##########....
#...##########....
#...##########....
....##########....
....##########....
....##########....
..................
..................
Ausgabe (S = falsch):
#####################################
# # # # # # #
# ### ### ### # # ##### ### ### ### #
# # # # # # # # # # #
# ### # ##### # ########### # ### # #
# # # # # # # # #
# # # ### ##### # ### ### # ### ### #
# # # # # # # # # # # # #
# ### # ##### ##### ### ##### # # ###
# # # # # # # # #
### ####### ### ### # ### ##### ### #
# # # # # # # # # # #
# ### ##### # ### ####### # # # # # #
# # # # # # # #
# # ##### ############# ### ### ### #
# # # # # # # # # #
# ### # ####### # ### ### # # ### # #
# # # # # # # # # #
# # # ### ######### # # ##### # #####
# # # # # # # # # # # #
# ##### # # ##### # ##### # # ### # #
# # # # # # # # # # #
# ### ### ### # ### # ##### ####### #
# # # # # # # # # #
# # # # ####### # ### # ##### # ### #
# # # # # # # # # # #
### # # # # # ############# # ### # #
# # # # # # # # # # #
##### # # ##### ####### # ### ##### #
# # # # # # # # #
##### # # # # ####### # ### #########
# # # # # #
# ### ######### ############# # #####
# # # # # # # # #
# # ######### # ####### ####### ### #
# # # #
#####################################
Ausgabe (S = wahr):
#####################################
# # # # # # #
# ### ### ### # # ##### ### ### ### #
# # # # # # # # # # #
# ### # ##### # ########### # ### # #
# # # #....... # # # # #
# # # ### #####.# ###.### # ### ### #
# # # # #...# # #...# # # # #
# ### # #####.##### ###.##### # # ###
# # # ...# # #... # # #..
### #######.### ### # ###.##### ###.#
# # #.# # # #.# # #...#
# ### #####.# ### #######.# # # #.# #
# #.......#.............#...# #...# #
# #.#####.#############.###.###.### #
#...# #.......#.....#...#.#...# # #
#.### # #######.#.###.###.#.#.### # #
#.# # # .......#...#.#...#...# #
#.# # ###.#########.#.#.##### # #####
#.# # #.#.......#.#...#...# # # #
#.##### #.#.#####.#.#####.#.# ### # #
#. #.#...#...#.#.....#.# # # #
#.### ###.###.#.###.#.#####.####### #
#. # # #.....#.#...#.#..... # #
#.# # # #######.#.###.#.##### # ### #
..# # # #...#...#.....#.....# # # #
### # # #.#.#.#############.# ### # #
# # # #.#...#.........#...# # # #
##### # #.#####.#######.#.### ##### #
# # #.#...#.......#.#...# #
##### # #.#.#.#######.#.###.#########
# # ...#.........#..... # #
# ### ######### ############# # #####
# # # # # # # # #
# # ######### # ####### ####### ### #
# # # #
#####################################
Bitmap-Beispiel (dasselbe Labyrinth wie oben):
quelle
Antworten:
Python 3, 1599 Bytes
Ich fand das ein lustiges Projekt und sehr interessant (und etwas langwierig). Als ich das sah, erinnerte ich mich an den Sommer, in dem ich ausschließlich einen Algorithmus zur Erzeugung von Labyrinthen geschrieben und verbessert hatte, und musste sofort daran arbeiten.
Nach einer Weile hatte ich einen ersten Entwurf mit einer Länge von ca. 6000 Byte und verbrachte die nächsten Stunden damit, ihn in das folgende Programm umzuwandeln:
Was ungefähr so unsinnig anzusehen ist, wie ein Ascii-Art-Labyrinth ...
Es ist erwähnenswert, dass, da die Zufallsfunktion erst verwendet wird, nachdem der richtige Pfad gefunden wurde, unabhängig davon, wie oft dieselbe Eingabe erfolgt, die Route vom Anfang bis zum Ende dieselbe ist und während dies bei diesem Programm der Fall ist Arbeiten Sie für die obigen Beispiele, wird es manchmal nicht möglich sein, eine Lösung zu finden, wenn es sich sozusagen selbst in eine Wand stößt.
Wenn Sie die obigen Beispiele ausführen, erhalten Sie Folgendes:
Dies:
und das:
Verwenden Sie den Befehl, wenn Sie versuchen möchten, dieses Programm selbst auszuführen
M(Image, Show solution)
. Ich würde empfehlen, die dreifachen Anführungszeichen zu verwenden, um das Bild einzugeben, da es sonst viele Back-Slashes oder Newline-Zeichen gibt.quelle
0
stattpass
,l.append(a);l.append(b)
->l+=a,b
,l.append(a)
->l+=[a]
, könnte es sich lohnen, die Zuordnung'#'
zu einer Variablen, unddef E(G,y,z):\n c=[]
->def E(G,y,z,c=[]):
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)
und (ich glaube, ich habe es nicht getestet)G=[s]
->*G=s
.except:0
,l+=a,b
unds=[0]*(1+L(I[0])*2)
wirklich geholfen hat. Aus irgendeinem Grund führt die Zuweisung von c im Funktionsaufruf nicht dazu, dass es bei mehreren Aufrufen zurückgesetzt wird, was bedeutet, dass es nicht mehr funktioniert * G = s hat mir einen Syntaxfehler gegeben. Trotzdem toller Rat.G[r][c]
sich um eine Zeichenfolge handeln kann,G[r][c]in[1,2]
sollte dies funktionieren.