Eingang
- Eine binäre Matrix die die Wände eines Dungeons darstellt.
- Die Position des Spielers im Dungeon.
- Die Richtung , in die der Spieler gerade schaut (0 = Nord, 1 = Ost, 2 = Süd, 3 = West)
Ausgabe
Eine Pseudo-3D-Darstellung der Wände, die sich im Sichtfeld des Players befinden, als ASCII-Grafik mit Zeichen.
Nachfolgend finden Sie einige mögliche Ausgaberahmen sowie die entsprechende Karte und den Kompass, um den Überblick zu behalten (das Zeichnen der Karte und des Kompasses ist jedoch nicht Teil der Herausforderung).
Spezifikation
Sichtfeld
Der Spieler hat Wände in seinem Sichtfeld, die von bis beschriftet sind . Unten sind die Positionen der Wände in Bezug auf den Spieler (in Gelb) in alle möglichen Richtungen angegeben.
Die Wände zeichnen
Die gesamte Ausgabe wird mit 7 verschiedenen Zeichen gezogen: " "
, "'"
, "."
, "|"
, "-"
, "_"
und ":"
.
Da eine detaillierte Darstellung der Wandformen im Körper dieser Herausforderung zu langwierig wäre, werden sie stattdessen in folgendem TIO-Link bereitgestellt:
Die Zeichen, die nicht Teil einer bestimmten Wand sind, sind "?"
in diesen Diagrammen mit einem gekennzeichnet . Sie müssen als "transparente" Zeichen behandelt werden, die überhaupt nicht gezeichnet werden. Auf der anderen Seite sind alle Leerzeichen innerhalb einer Wand „fest“ und müssen alle anderen Zeichen überschreiben, die zuvor dort gezeichnet wurden.
Regeln
Über die Eingabe
- Sie können entweder 0-indexierte oder 1-indexierte Koordinaten verwenden.
- Sie können 4 verschiedene Werte Ihrer Wahl für die Richtungen verwenden.
- Sie können davon ausgehen, dass sich immer umlaufende Wände an den Rändern befinden.
- Der Spieler befindet sich garantiert auf einem leeren Feld.
- Die Eingabe ist garantiert gültig.
Über die Ausgabe
- Die Wände müssen genau wie beschrieben gezeichnet werden.
- Das Ausgabeformat ist jedoch auch flexibel: einzelner String, Array von Strings, Matrix von Zeichen usw.
- Führende und nachfolgende Leerzeichen sind zulässig, solange sie konsistent sind.
Das ist Code-Golf .
Testfälle
Alle Testfälle verwenden die folgende Matrix:
[ [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],
[ 1, 0, 1, 1, 1, 0, 0, 0, 0, 1 ],
[ 1, 0, 1, 0, 1, 0, 0, 1, 0, 1 ],
[ 1, 0, 0, 0, 0, 0, 1, 1, 0, 1 ],
[ 1, 0, 0, 1, 0, 0, 0, 1, 0, 1 ],
[ 1, 0, 0, 1, 1, 0, 1, 1, 0, 1 ],
[ 1, 1, 1, 1, 0, 0, 0, 0, 0, 1 ],
[ 1, 0, 0, 0, 0, 0, 0, 0, 0, 1 ],
[ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ] ]
x=3, y=3, d=0
x=6, y=4, d=3
x=4, y=4, d=1
x=1, y=5, d=2
x=7, y=7, d=3
x=6, y=6, d=1
x=8, y=1, d=2
x=7, y=6, d=1
Erwartete Ergebnisse:
------------------------------ ------------------------------
x=3, y=3, d=0: x=6, y=4, d=3:
------------------------------ ------------------------------
__ __ '. .'
|'. .'| | |
| '.--------------.' | |----. |
| | | | | | '.--------. |
| | | | | | | | |
| | | | | | | | |
| | | | | | .'--------' |
| .'--------------'. | |----' |
__|.' '.|__ | |
.' '.
------------------------------ ------------------------------
x=4, y=4, d=1: x=1, y=5, d=2:
------------------------------ ------------------------------
.' __ ________________________ .'
| | |
-------. .----| | |
| '.--------.' | | | |
| | | | | | |
| | | | | | |
| .'--------'. | | | |
-------' '----| | |
| __|________________________|
'. '.
------------------------------ ------------------------------
x=7, y=7, d=3: x=6, y=6, d=1:
------------------------------ ------------------------------
'. '.
|'. |'.
| '. | '.
| | '. .- | |--.--------.--------.-
| | |: :| | | | | |
| | |: :| | | | | |
| | .' '- | |--'--------'--------'-
| .' | .'
|.' |.'
.' .'
------------------------------ ------------------------------
x=8, y=1, d=2: x=7, y=6, d=1:
------------------------------ ------------------------------
'. __ '.
|'. .'| |
| '. .' | |----.--------------.-------
| | '. .' | | | | |
| | |: :| | | | | |
| | |: :| | | | | |
| | .' '. | | | | |
| .' '. | |----'--------------'-------
|.' '.|__ |
.' .'
Verwandte Herausforderung:
Diese Herausforderung von 2013 ist eng miteinander verbunden. Es hat jedoch ein anderes Gewinnkriterium (Code-Challenge), eine viel lockerere Spezifikation der Ausgabe und erfordert interaktive E / A.
quelle
Antworten:
Sauber (mit Snappy ),
800785670644 Bytes460402 Byte Code +360Zeichenfolgenliteral mit 242 Byte(hier und in TIO mit Escapezeichen versehen, da UTF-8 nicht gültig)
Hier können Sie die Länge des Literal überprüfen .
Probieren Sie es online!
Schnelle Komprimierung funktioniert in diesem Fall eigentlich recht gut, obwohl sie auf die Geschwindigkeit ausgerichtet ist, da die zu komprimierende Zeichenfolge so viele einzelne Zeichen enthält.
Die unkomprimierte Saite (mit
#
ersetzt mit\n
der Klarheit halber) ist:Diese Codiert den linksseitigen Versionen der verschiedenen Bildschirmkomponenten mit
!
anstelle von Zeilenumbrüchen, und~
statt?
, die dann mit rechts aufgefüllt ,~
bevor sie sich zu 30 Zeichen und ihr Line-Umkehrungen zu einer Lookup - Liste haben.Der Rest des Codes behandelt einfach die Koordinatensuche, wobei Fälle außerhalb des gültigen Bereichs ignoriert werden.
quelle
Python 2 ,
864854848826810 BytesProbieren Sie es online!
quelle
Kohle ,
500332 BytesProbieren Sie es online! Link ist eine ausführliche Version des Codes. Ich fürchte, ein etwas langweiliger Ansatz; viel Druck von komprimierten String-Literalen. Erläuterung:
Pad das Array mit zwei zusätzlichen
0
s auf jeder Seite.Schneiden Sie einen
7x7
Unterabschnitt des Arrays zentriert auf die angegebenen Koordinaten.Drehen Sie das Array entsprechend der angegebenen Richtung.
(Leerzeichen beachten) Zeichnen Sie ein leeres
30×10
Feld, damit die Ausgabe immer eine einheitliche Größe hat.Zeichne jede Hälfte einzeln und reflektiere dazwischen.
Nehmen Sie ein Array von Wanddeskriptoren, aufgeteilt in Teile von (Zeichenfolge, y-Koordinate, x-Koordinate), filtern Sie nach den Teilen, die eine Wand an der relevanten Position in der relevanten Hälfte des Arrays aufweisen, und ziehen Sie eine Schleife über die Wände. Die Position wird berechnet, indem 12 Wände aus dem Array extrahiert und mit dem Chunk-Index indiziert werden, da dies besser ist, als die Wand direkt mit dem Chunk-Index zu lokalisieren.
Springe zu den Koordinaten der Wand und drucke sie aus. Beachten Sie, dass durch Spiegeln die X-Koordinaten von
[0, 30)
bis negiert werden ,(-30, 0]
sodass die Zeichenfläche bei einem Durchgang effektiv um 29 Zeichen nach links verschoben wird.quelle
Ruby ,
412 391 385383 BytesProbieren Sie es online!
Nimmt Eingaben als Array von Wahrheits- / Falsch-Werten (Anmerkung
0
ist in Ruby wahr, abernil
falsch.)Gibt ein Array von Zeichen aus.
Erläuterung
Die Blöcke werden von vorne nach hinten gezeichnet, wobei der Abstand
n
abnimmt und die Position von Seite zu Seitem
durch-1,1,0
links, rechts und in der Mitte wechselt. Der mittlere Block E in der am weitesten entfernten Reihe wird tatsächlich zweimal gezeichnet, da sowohl die Blöcke A / B als auch die Blöcke C / D überprüft werden müssen.n,m
undd
verwendet , um die zu modifizierenx
undy
Werte - Array zu suchena
. Wennx
außerhalb des Bereichsnil
für eine Zelle außerhalb des Bereichs zurückgegeben wird und kein Fehler ausgegebeny
wird,nil
wird für die Zeile jedoch ein Wert außerhalb des Bereichs zurückgegeben, und Ruby gibt einen Typfehler aus, wenn nach der Zelle gesucht wird. Um dies zu vermeiden, wird das Array vor dem Suchen in vertikaler Richtung verdreifacht. Wenn ein wahrer Wert gefunden wird, wird ein Block gezeichnet.Die Ausgabe besteht aus einem Array
b
von 10-Element-Arrays, die die Spalten der Ausgabe darstellen, und wird am Ende der Funktion in 10 Zeilen transponiert. Die gesamte Vorderseite aller Blöcke wird gezeichnet (unabhängig davon, ob sie im Ansichtsfenster angezeigt werden oder nicht), sodass zusätzlicher Platz im Array erforderlich ist, um Fehler außerhalb des Bereichs zu vermeiden. Der Wertebereichj
im Ansichtsfenster reicht von-15
bis+14
, dies wird beim Speichern im Array um 15 versetzt, um einen Bereich von0
bis anzugeben29
. Für jeden gezogenen Block werden drei Werte berechnet:p
undq
für die linke und rechte Ecke der Vorderwand bzw.r
für die Rückseite der Seitenwand.j
wird vom Minimum zum Maximum dieser drei Werte iteriert, wobei die Spalten der Reihe nach gezeichnet werden.Es gibt drei Arten von Linien: horizontal
-
oder_
vertikal|
oder:
diagonal mit sich wiederholendem" .'"
Muster. Wobeip < j < q
Spalten, die Leerzeichen enthalten, mit-
oder_
gezeichnet werden, um die Vorderseite zu bilden. Befindetj
sich eine Spalte außerhalb dieses Bereichs, enthält sie Leerzeichen|
oder:
ist mit Symbolen von begrenztt=" .'"
, um die Kanten und / oder die Seitenfläche zu bilden. Dies wird durch die Variable verwaltet ,k=j
woj
positiv ist oderk=-j-1
woj
ist negativ. Die Anzahl der Zeichen zwischen der oberen und der unteren Groß- / Kleinschreibung beträgtk/3*2
. Um die Außenkanten der am weitesten entfernten Blöcke richtig handhaben zu könnenn=3
,k
muss modulo 9 gewählt werden, dies darf jedoch nicht für kleinere Werte von erfolgenn
.k
wird daher modulo genommen36/-~n
, wo sich-~n
auswertetn+1
.Ungolfed Code
quelle