Diese Aufgabe ist Teil des First Periodic Premier Programming Puzzle Push .
Sie erhalten eine Hierarchie von Elementen im folgenden Format:
2
Hat
1
Gloves
die müssen in Kisten gelegt werden, wie so:
.------------.
| Hat |
| .--------. |
| | Gloves | |
| '--------' |
'------------'
Im Eingabeformat beginnen die Zahlen mit einem Kästchen mit so vielen Elementen, wie die Nummer angibt. Die erste Schachtel enthält zwei Gegenstände (den Hut und die Schachtel mit den Handschuhen), die zweite enthält nur einen einzigen Gegenstand - die Handschuhe.
Wie man sieht, können Kisten auch in Kisten leben. Und sie sind immer abgerundet ... irgendwie (spitze Ecken sind eine Gefahr für Wunden und das würden wir nicht wollen).
Nachfolgend finden Sie die Details für diejenigen, die jeden noch so kleinen Spielraum nutzen möchten, den die Spezifikation bietet. Wohlgemerkt, das Nichtlesen der Spezifikation ist keine Entschuldigung für das Einreichen falscher Lösungen. Ganz am Ende stehen ein Testskript und einige Testfälle.
Spezifikation
Boxen bestehen aus folgenden Zeichen:
|
(U + 007C) wird verwendet, um die vertikalen Kanten zu konstruieren.-
(U + 002D) wird verwendet, um die horizontalen Kanten zu konstruieren.'
(U + 0027) sind die runden unteren Ecken..
(U + 002E) sind die runden oberen Ecken.
Eine Box sieht also so aus:
.--. | | '--'
Beachten Sie, dass Unicode zwar auch runde Ecken und korrekte Box-Zeichen aufweist, diese Aufgabe jedoch nur in ASCII ausgeführt wird. So sehr ich Unicode liebe, so sehr stelle ich fest, dass es Sprachen und Umgebungen gibt, die im vorletzten Jahrzehnt noch nicht ganz angekommen sind.
Boxen können eine Folge von Elementen enthalten, die entweder Text oder andere Elemente sind. Einzelne Elemente in einer Box werden von oben nach unten gerendert. Die Folge A, B, C ergibt sich somit wie folgt:
.---. | A | | B | | C | '---'
Dies gilt natürlich auch für verschachtelte Felder, die genau wie Text ein Element sind. Die Folge A, B, Box (C, Box (D, E)), F würde also wie folgt aussehen:
.-----------. | A | | B | | .-------. | | | C | | | | .---. | | | | | D | | | | | | E | | | | | '---' | | | '-------' | | F | '-----------'
Boxen passen ihre Größe an den Inhalt an und verschachtelte Boxen erstrecken sich immer auf die Größe ihrer Eltern. Vor und nach dem Inhalt befindet sich immer ein Leerzeichen, sodass weder Text noch verschachtelte Felder zu nah am Rand des äußeren Felds sind. Kurz gesagt ist das Folgende falsch:
.---. |Box| '---'
Und das Folgende ist richtig:
.-----. | Box | '-----'
Sieht auch viel schöner aus :-)
Textelemente (siehe Eingabe unten) müssen exakt reproduziert werden.
Es gibt immer eine einzige Top-Level-Box (vgl. XML). Eine Box kann jedoch mehrere andere Boxen enthalten.
Eingang
Die Eingabe erfolgt über die Standardeingabe. zum leichteren Testen wahrscheinlich aus einer Datei umgeleitet.
Die Eingabe erfolgt zeilenweise, wobei jede Zeile entweder ein Textelement darstellt, das in das aktuelle Feld eingefügt werden soll, oder ein neues Feld öffnet.
Jede Zeile wird durch einen Zeilenumbruch abgeschlossen.
Textelemente werden durch eine Zeile markiert, die nicht aus einer Zahl besteht (siehe unten). Text verwendet alphabetische Zeichen, Leerzeichen und Interpunktion (
.,-'"?!()
). Text beginnt oder endet nicht mit einem Leerzeichen und hat immer mindestens ein Zeichen.Ein Kästchen beginnt mit einer einzelnen Zeile mit einer Zahl. Die Zahl gibt die Größe des Kartons an, dh die Anzahl der folgenden Elemente, die darin abgelegt werden:
2 A B
ergibt eine Box mit zwei Textelementen:
.---. | A | | B | '---'
Eine Box enthält immer mindestens einen Artikel.
Das Ende von Feldern ist nicht explizit mit einer Linie markiert. Stattdessen werden Boxen implizit geschlossen, nachdem die angegebene Anzahl von Elementen in sie eingefügt wurde.
Eine Schachtel ist immer nur ein einzelnes Objekt, unabhängig davon, wie viele Objekte sich darin befinden. Z.B
3 A 4 a b c d B
ergibt eine Schachtel mit drei Gegenständen, von denen der zweite eine weitere Schachtel mit vier Gegenständen ist.
Das Verschachteln hat auch keinen Einfluss darauf, dass eine Schachtel nur ein einzelnes Objekt ist.
Grenzen
Die maximale Verschachtelungsstufe beträgt fünf . Dh es sind höchstens fünf Kisten ineinander. Dies schließt den äußersten ein.
Es gibt maximal zehn Artikel pro Karton.
Textelemente haben eine maximale Länge von 100 Zeichen.
Ausgabe
- Die Ausgabe ist das gerenderte Feld, das alle enthaltenen und verschachtelten Elemente gemäß den oben angegebenen Regeln enthält.
- Die Ausgabe sollte auf der Standardausgabe erfolgen und muss genau übereinstimmen. Es ist kein führendes oder nachfolgendes Leerzeichen zulässig.
- Jede Zeile muss mit einem Zeilenumbruch abgeschlossen werden, einschließlich des letzten.
Gewinnbedingung
- Kürzester Code gewinnt (dh bekommt die akzeptierte Antwort).
Probeneingabe 1
3
This is some text!
Oh, more text?
Just text for now, as this is a trivial example.
Beispielausgabe 1
.--------------------------------------------------.
| This is some text! |
| Oh, more text? |
| Just text for now, as this is a trivial example. |
'--------------------------------------------------'
Probeneingabe 2
4
Extreme
nesting
3
of
boxes
4
might
lead
to
2
interesting
1
visuals.
Indeed!
Beispielausgabe 2
.--------------------------.
| Extreme |
| nesting |
| .----------------------. |
| | of | |
| | boxes | |
| | .------------------. | |
| | | might | | |
| | | lead | | |
| | | to | | |
| | | .--------------. | | |
| | | | interesting | | | |
| | | | .----------. | | | |
| | | | | visuals. | | | | |
| | | | '----------' | | | |
| | | '--------------' | | |
| | '------------------' | |
| '----------------------' |
| Indeed! |
'--------------------------'
Probeneingabe 3
1
1
1
1
1
Extreme nesting Part Two
Beispielausgabe 3
.------------------------------------------.
| .--------------------------------------. |
| | .----------------------------------. | |
| | | .------------------------------. | | |
| | | | .--------------------------. | | | |
| | | | | Extreme nesting Part Two | | | | |
| | | | '--------------------------' | | | |
| | | '------------------------------' | | |
| | '----------------------------------' | |
| '--------------------------------------' |
'------------------------------------------'
Probeneingabe 4
3
Foo
2
Bar
Baz
2
Gak
1
Another foo?
Beispielausgabe 4
.----------------------.
| Foo |
| .------------------. |
| | Bar | |
| | Baz | |
| '------------------' |
| .------------------. |
| | Gak | |
| | .--------------. | |
| | | Another foo? | | |
| | '--------------' | |
| '------------------' |
'----------------------'
Skript testen
Da es manchmal schwierig sein kann, die richtigen Details zu ermitteln, haben wir ( Ventero und ich) ein Testskript erstellt, mit dem Sie Ihre Lösung ausführen können, um zu überprüfen, ob sie korrekt ist. Es ist sowohl als PowerShell-Skript als auch als Bash-Skript verfügbar . Invocation ist: <test-script> <program invocation>
.
UPDATE: Die Testskripte wurden aktualisiert. Es gab eine Reihe von Testfällen, die die von mir festgelegten Grenzwerte nicht einhielten. Das PowerShell-Testskript verwendete für die Überprüfung des Ergebnisses nicht die Groß- und Kleinschreibung. Ich hoffe, jetzt ist alles in Ordnung. Die Anzahl der Testfälle wurde auf 156 reduziert, obwohl der letzte jetzt ziemlich ... groß ist.
UPDATE 2: Ich habe meinen Testfallgenerator hochgeladen . In C # geschrieben und auf die .NET 2-Laufzeit ausgerichtet. Es läuft auf Mono. Es kann Leuten helfen, ihre Implementierung zu testen. In Anbetracht der Grenzen der Aufgabe können Sie im schlimmsten Fall Folgendes versuchen:
nb.exe 1 10 10 5 100 100 | my invocation
Dabei werden nur Felder bis zur innersten Ebene generiert und sowohl die maximale Anzahl von Elementen pro Feld als auch die maximale Länge von Textelementen verwendet. Ich habe diesen Testfall jedoch nicht in das Testskript aufgenommen, da er ziemlich groß und die Ausgabe noch größer ist.
UPDATE 3: Ich habe das PowerShell- Testskript aktualisiert, das Fehler auslöst, je nachdem, wie die Zeilenenden im Skript sind und welche Zeilenenden die Lösung ausgibt. Jetzt sollte es für beide agnostisch sein. Entschuldigung nochmal für die Verwirrung.
Antworten:
GolfScript, 125 Zeichen
Verwenden Sie einen ähnlichen Ansatz wie Keith's Lösung .
quelle
Python, 204 Zeichen
P
gibt eine Liste von Tripeln zurück, von denen jedes ein Zeilenpräfix / -suffix (das Suffix ist die Umkehrung des Präfixes), einen Zeilentext und ein Zeilenfüllzeichen enthält. Nachdem alle Tripel berechnet wurden, werden sie mit der richtigen Anzahl von Füllzeichen gedruckt, um alle Zeilen gleich lang zu machen.Ungolfed-Version:
quelle
P
dabei.Ruby 1.9, 174 Zeichen
Etwas ähnlich wie bei Keith .
quelle
APL (78)
quelle
Python -
355314259 Zeichenquelle
Ruby 1.9,
229228226223222quelle
C,
390366363 ZeichenKompilieren mit
gcc -std=gnu99 -w file.c
Nicht einmal in der Nähe von Keiths Version, aber hey, es ist gut, alter C
quelle
160/160 passed
(ich meinte eine Zeichenfolge von 100 Zeichen, die sowieso nicht vorhanden ist)FreeBSD 8.2-RELEASE #5: Sun Feb 27 10:40:25 CET 2011
mitgcc version 4.2.1 20070719 [FreeBSD]
auf x64 hier. Ich werde dann dein Wort für die 160 nehmen :-). Und es sollte tatsächlich einen Testfall mit 100 Zeichen geben (Tests 143–147).sehr funktionelle Python, 460 Zeichen
quelle
|
Zeichen sind nicht richtig verteilt. Es ist sehr ähnlich zu meiner Python-LösungHaskell, 297 Zeichen
Während des Golfspiels ist die Methode ziemlich einfach. Nur Grenzen sind verfügbarer Speicher.
quelle
C # -
1005 859 852782 ZeichenIch muss mir das noch einmal ansehen, da ich sicher bin, dass es verbessert werden kann, aber dies ist mein
ersterdritter Versuch.Ungolf'd:
quelle
var a = 1, b = 2, c = 3;
. Kannst du nicht dasselbe in C machen?var
Aussagen wie diese nicht kombinieren . Sie können nur kombinieren, wenn sie einen expliziten Typ haben, wie er von Joey erwähnt wurdestring b="",e=""
.PHP,
403388306 ZeichenUngolfed:
Ich habe die Präfix-Idee von Keith ausgeliehen (ist das überhaupt erlaubt?), Sonst ist das ziemlich genau so wie das Original. Konnte immer noch nicht unter 300 kommen. Weiter.
quelle
PHP,
806769721653619 ZeichenUngolfed-Version:
quelle
<?
am Anfang noch zu laufender. Dann verwenden Sie anscheinend die maximale Länge aller Textelemente in einem Testfall als Breite für das innerste Feld. Dieser Code besteht nur 118 der Testfälle (getestet unter Linux und FreeBSD). Ich habe keine Ahnung, was Sie mit dem PowerShell-Skript gemacht haben, dass es nicht ausgeführt werden würde :-(. Es aufzurufen, wie espowershell -noprofile -file test.ps1 php boxes.php
eigentlich funktionieren sollte. Aber ich habe kein PHP auf meinem Windows-Computer zum Testen.Java -
681668 ZeichenIm Wesentlichen die gleiche Methode wie der Python-Code von Keith Randall
Ungolfed-Version:
quelle
throws
.break;
)char
Vergleiche durch längeres Betrachten der ASCII-Codes verfeinert werden ... aber ich muss mich auf den Urlaub vorbereitenPerl -
200199 ZeichenGleicher Algorithmus wie Keith Randalls Python (schönes Design, Keith), aber etwas kompakter in dieser Perl-Version.
quelle
$_@_@_
sieht aus wie jemand jagt das DollarzeichenF # - 341 Zeichen
Eine F # -Version von Keith's Lösung. Listen sind standardmäßig unveränderlich, daher fügt diese Version die gesamte rekursive Funktion in eine Liste ein und gibt die Liste zurück, aus der die Elemente mit der
for..do
Schleife und a extrahiert werdenyield!
. Ich konnte keinen Weg finden, das Präfix präzise umzukehren, also habe ich das Suffix einfach an die Tripel angehängt.Zu Ihrer Information, die TryParse-Methode gibt ein double zurück
(bool,int)
.quelle
Clojure - 480 Zeichen
Dies ist mein erstes Clojure-Programm und auch mein erster Clojure-Golfversuch. Daher sollte dies nicht als repräsentativ für Clojure-Lösungen im Allgemeinen angesehen werden. Ich bin sicher, es könnte erheblich verkürzt werden, insbesondere wenn Keith Randalls Methode zum Parsen und Bauen der Boxen auf einmal implementiert würde.
quelle
C # -
472 470 426 422398 Zeichenquelle
goto
! Übrigens können Sie die Klammern um die Lambda-Argumente weglassenz
undv
auf 421 reduzieren.Scala - 475 Zeichen
quelle
C #
1198 1156 1142 689 671634 Zeichenquelle
\n
scheint am Ende zu genügen.Pip , 89 Bytes (nicht konkurrierend)
(Die Sprache ist neuer als die Herausforderung. Außerdem konnte ich APL nicht ganz übertreffen.)
Code ist 87 Bytes, +2 für
-rn
Flags.Probieren Sie es online!
Die Funktion
z
verarbeitet das erste Element der Eingabeliste (g
kopiert in eine globale Variablei
, um innerhalb von Funktionsaufrufen verfügbar zu sein). Wenn dies eine Zahl n ist , ruft es sich selbst n- mal rekursiv auf, füllt die resultierende Zeilenliste zu einem vollständigen Rechteck auf"| " " |"
, fügt jede Zeile ein und fügt.---.
und'---'
Zeilen hinzu , bevor es die neue Liste zurückgibt. Wenn es sich um eine Zeichenfolge handelt, wird sie einfach in eine Liste mit einem Element konvertiert und zurückgegeben. Das Endergebnis wird durch Zeilenvorschub (-n
Flag) getrennt gedruckt . Weitere Details auf Anfrage.quelle
Java (1369 Zeichen inkl. EOLs)
Konnte dies nicht ohne eine Java-Implementierung verlassen. Java soll ausführlicher sein als die Slicks von Python und Ruby, also habe ich mich für eine elegante, rekursive Lösung entschieden.
Die Idee ist ein Baum (Graph) von Objekten (Strings und Boxen), die sich ausgehend von einer "Kopf" Box gegenseitig enthalten. Wenn Sie die Eingabedatei linear analysieren, fügen Sie dem "aktuellen" Feld Zeichenfolgen und Felder hinzu, und während Sie hinzufügen, wird die maximale Länge des Containers angepasst. Wenn ein Container die Anzahl der vordefinierten Elemente erreicht, die Sie aufnehmen können, kehren Sie zum vorherigen Container zurück. Am Ende der Eingabedatei befindet sich ein "head" -Container, für den bereits eine "maxLength" berechnet wurde. Rufen Sie einfach die print () -Methode auf.
Es ist wirklich eine angenehme Lösung, um zu schreiben. Die Frage hat mir sehr gut gefallen. Wie ich bereits erwähnt habe, habe ich mich für Lösungseleganz und nicht für Minimalismus entschieden. Leider hat Java nicht Pythons Print "-" * 4 "----" :-)
Hier ist die ungolfed Version:
quelle