In dieser pixeligen Schriftart aus Großbuchstaben des Alphabets sind alle Zeichen 5 Einheiten breit und 5 hoch.
███ ████ ███ ████ █████ █████ ████ █ █ █████ █ █ █ █ █ █
█ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ ██ ██
█████ ████ █ █ █ ████ ████ █ ██ █████ █ █ ███ █ █ █ █
█ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █
█ █ ████ ███ ████ █████ █ ████ █ █ █████ ███ █ █ █████ █ █
█ █ ███ ████ ███ ████ ████ █████ █ █ █ █ █ █ █ █ █ █ █████
██ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █
█ █ █ █ █ ████ █ █ ████ ███ █ █ █ █ █ █ █ █ █ █ █
█ ██ █ █ █ █ ██ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █
█ █ ███ █ ████ █ █ ████ █ ███ █ █ █ █ █ █ █████
Es gibt auch 1 Einheit Abstand zwischen Buchstaben und zwischen Zeilen, wie zu sehen ist. So kann jeder Buchstabe bis zu 6 × 6 Einheiten Platz einnehmen.
Angenommen, Sie verwenden nicht das vollständige Blockzeichen ( █
), um die Formen der Buchstaben direkt zu bilden , sondern möchten andere Buchstaben in derselben Schriftart verwenden . Dabei wird der Text um das Sechsfache vergrößert, sodass Buchstaben aus Vollblöcken als Vollblockersatz im größeren Text verwendet werden können.
Wenn das hoffentlich keinen Sinn ergeben hat, wird es dieses Beispiel tun. Hier ist ein A aus B mit der pixeligen Schrift:
████ ████ ████
█ █ █ █ █ █
████ ████ ████
█ █ █ █ █ █
████ ████ ████
████ ████
█ █ █ █
████ ████
█ █ █ █
████ ████
████ ████ ████ ████ ████
█ █ █ █ █ █ █ █ █ █
████ ████ ████ ████ ████
█ █ █ █ █ █ █ █ █ █
████ ████ ████ ████ ████
████ ████
█ █ █ █
████ ████
█ █ █ █
████ ████
████ ████
█ █ █ █
████ ████
█ █ █ █
████ ████
Die B bestehen aus vollen Blöcken und die A bestehen aus B. Beachten Sie, dass die B noch eine Einheit horizontal und vertikal zwischen sich haben.
Wir können diese Idee erweitern, indem wir Wörter anstelle von Buchstaben verwenden. Hier ist "WASSER" aus "FEUER":
█████ █████ ████ █████ █████ █████ ████ █████ █████ █████ ████ █████ █████ █████ ████ █████ █████ █████ ████
█ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █
████ █ ████ ████ ████ █ ████ ████ ████ █ ████ ████ ████ █ ████ ████ ████ █ ████
█ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █
█ █████ █ █ █████ █ █████ █ █ █████ █ █████ █ █ █████ █ █████ █ █ █████ █ █████ █ █
█████ █████ ████ █████ █████ █████ ████ █████
█ █ █ █ █ █ █ █ █ █
████ █ ████ ████ ████ █ ████ ████
█ █ █ █ █ █ █ █ █ █
█ █████ █ █ █████ █ █████ █ █ █████
█████ █████ ████ █████ █████ █████ ████ █████ █████ █████ ████ █████ █████ █████ ████ █████ █████
█ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █
████ █ ████ ████ ████ █ ████ ████ ████ █ ████ ████ ████ █ ████ ████ ████
█ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █
█ █████ █ █ █████ █ █████ █ █ █████ █ █████ █ █ █████ █ █████ █ █ █████ █
█████ █████ ████ █████ █████ █████ ████ █████ █████
█ █ █ █ █ █ █ █ █ █ █
████ █ ████ ████ ████ █ ████ ████ ████
█ █ █ █ █ █ █ █ █ █ █
█ █████ █ █ █████ █ █████ █ █ █████ █
█████ █████ ████ █████ █████ █████ ████ █████ █████ █████ ████ █████
█ █ █ █ █ █ █ █ █ █ █ █ █ █ █
████ █ ████ ████ ████ █ ████ ████ ████ █ ████ ████
█ █ █ █ █ █ █ █ █ █ █ █ █ █ █
█ █████ █ █ █████ █ █████ █ █ █████ █ █████ █ █ █████
Beachten Sie, wie "FEUER" in jeder Zeile wiederholt und immer in der richtigen Reihenfolge angezeigt wird, unabhängig davon, wie viel Platz zwischen den Buchstaben ist. Drei der am weitesten rechts stehenden Fälle von "FIRE" wurden vorzeitig unterbrochen, da die Buchstaben von "WATER" so geformt sind.
Diese Idee kann noch erweitert werden, indem diese Wörter aus Wörtern verwendet werden , um Wörter aus Wörtern oder Wörter aus Wörtern zu bilden . Theoretisch gibt es keine Grenzen.
Ein anderes Beispiel würde diesen Beitrag über die Grenze von 30.000 Zeichen setzen, aber Sie können sehen, was unter "Wörter aus Wörtern aus Wörtern" zu verstehen ist, indem Sie dieses raffinierte Stapel-Snippet ausführen. Belassen Sie einfach die Standardeinstellungen der Parameter und klicken Sie auf "Los!". Sie sollten das Wort "DOG" aus dem Wort "CAT" aus dem Wort "MOUSE" sehen.
Wenn Sie eine durch Leerzeichen getrennte Liste von Wörtern mit nur Großbuchstaben in das Textfeld eingeben, wird das erste Wort aus dem zweiten Wort aus dem dritten Wort aus dem vierten Wort aus dem ... usw. erzeugt.
WARNUNG: Wenn Sie mehr als 4 oder sogar 3 Wörter eingeben, wird VIEL Text erzeugt und es dauert lange. Möglicherweise stürzt Ihr Browser / Computer / Auto ab.
Herausforderung
Das Ziel dieser Herausforderung ist es, das zu spiegeln, was das Stapel-Snippet mit der geringsten Anzahl von Zeichen tut.
Sie müssen ein Programm schreiben, das eine durch Leerzeichen getrennte Folge von Wörtern enthält, die nur Großbuchstaben enthalten, und das erste Wort "aus" dem zweiten "aus" dem dritten usw. mit der oben angegebenen pixeligen Schriftart ausgibt.
Das Kontrollkästchen "Nur ASCII" und die Schriftgrößenfunktionen des Snippets müssen in Ihrem Programm nicht unterstützt werden. Das Spiegeln der Transformation von Wortlisten zu Wörtern, die aus Wörtern bestehen, ist der Hauptpunkt und die einzige Voraussetzung.
Einzelheiten
Die Eingabe sollte von stdin, der Befehlszeile, kommen, oder Sie können einfach eine Funktion schreiben, die eine Zeichenfolge akzeptiert.
Sie können davon ausgehen, dass die Eingabe immer gültig ist, dh eine Folge von Wörtern aus Großbuchstaben, die durch genau ein Leerzeichen ohne führende oder nachfolgende Leerzeichen getrennt sind.
Die Ausgabe sollte nach stdout (oder einer ähnlichen Alternative) oder in eine Datei mit dem Namen Ihrer Wahl erfolgen.
Die Ausgabe sollte vollständig aus Leerzeichen , Leerzeichen und Zeilenumbrüchen bestehen.
- Die Leerzeichen / Zeichen mit vollem Leerzeichen sollten entweder ein Leerzeichen bzw. ein voller Block (
,
█
) oder ein Punkt und ein X (.
,X
) sein.
- Die Leerzeichen / Zeichen mit vollem Leerzeichen sollten entweder ein Leerzeichen bzw. ein voller Block (
Die Ausgabe sollte keine führenden Spalten enthalten, die nur Leerzeichen enthalten. Es ist jedoch jede Kombination von Leerzeichen am Ende einer Zeile zulässig.
Das ist also erlaubt:
X...X.XXXXX.. X...X.X X.X.X.XXXX.... X.X.X.X.. .X.X..XXXXX..
Das ist aber nicht:
.X...X.XXXXX.. .X...X.X .X.X.X.XXXX.... .X.X.X.X.. ..X.X..XXXXX..
Es sollten keine führenden oder nachfolgenden Zeilen vorhanden sein, die nur Leerzeichen enthalten . Eine einzelne nachgestellte Zeile ist optional zulässig.
Hier ist eine string-freundlichere Version der Schriftart:
.XXX.
X...X
XXXXX
X...X
X...X
XXXX.
X...X
XXXX.
X...X
XXXX.
.XXX.
X...X
X....
X...X
.XXX.
XXXX.
X...X
X...X
X...X
XXXX.
XXXXX
X....
XXXX.
X....
XXXXX
XXXXX
X....
XXXX.
X....
X....
.XXXX
X....
X..XX
X...X
.XXXX
X...X
X...X
XXXXX
X...X
X...X
XXXXX
..X..
..X..
..X..
XXXXX
....X
....X
....X
X...X
.XXX.
X...X
X..X.
XXX..
X..X.
X...X
X....
X....
X....
X....
XXXXX
X...X
XX.XX
X.X.X
X...X
X...X
X...X
XX..X
X.X.X
X..XX
X...X
.XXX.
X...X
X...X
X...X
.XXX.
XXXX.
X...X
XXXX.
X....
X....
.XXX.
X...X
X...X
X..XX
.XXXX
XXXX.
X...X
XXXX.
X..X.
X...X
.XXXX
X....
.XXX.
....X
XXXX.
XXXXX
..X..
..X..
..X..
..X..
X...X
X...X
X...X
X...X
.XXX.
X...X
X...X
.X.X.
.X.X.
..X..
X...X
X...X
X.X.X
X.X.X
.X.X.
X...X
.X.X.
..X..
.X.X.
X...X
X...X
.X.X.
..X..
..X..
..X..
XXXXX
...X.
..X..
.X...
XXXXX
Wertung
Dies ist Code-Golf, also gewinnt die kürzeste Einsendung in Bytes . Jede Instanz eines vollständigen Blocks ( █
) kann als 1 Byte statt als 3 Byte gezählt werden, sodass Übermittlungen, die verwendet werden X
, keinen Vorteil haben.
quelle
javascript:
in der URL - Leiste und Einfügen) hier viel die ASCII - Kunst zu machen, viel einfacher zu lesen:$('#question pre').css('line-height',1)
. Ergebnis: i.stack.imgur.com/XmB8C.png$('#question pre, .answer pre').css('line-height',1)
Antworten:
CJam,
171 165 162161 BytesIch behandle
█
als 1 Byte. Alle Zeichen liegen im ASCII-Bereich und werden daher auch als 1 Byte behandelt.Sie können dieses Pastebin für den genauen Code verwenden
Beispielausgabe für Eingabe:
Wie es funktioniert
Vor allem
ist einfach das Muster für jedes der 27 Zeichen (
A-Z
und Leerzeichen), das aus0
(anX
Positionen) und1
(an.
Positionen) besteht. Nach der Decodierung ergibt dies eine 27 - Element - Array von 2D - Arrays aus 5 Reihen und 5 Spalten repräsentierenX
und.
für jede der 27 Zeichen. Nennen wir dieses Array alsL
.Nun der restliche Code:
Probieren Sie es hier online aus
quelle
Python 3, 437 Bytes
Die Zeichenformen sind in ASCII kodiert. Jedes ASCII-Byte entspricht einer Zeile mit einem Zeichen, wobei Bits Einheitenblöcke darstellen. Es ist kein sehr effizientes Schema, aber es ist einfach, die NumPy-Bitmasken für jedes Zeichen zu entpacken.
Wir beginnen mit einem 2d-Array von 1s. Es hat eine Spalte für jedes Zeichen im ersten Wort und eine einzelne Zeile. Dann erstellen wir für jedes Wort ein neues Array von Nullen, sechsmal höher und sechsmal breiter als das vorherige Array. Wenn das vorherige Array eine 1 hatte, wird der entsprechende 6 × 6-Abschnitt des neuen Arrays mit der Bitmaske des entsprechenden Zeichens gefüllt.
Hier ist ein Beispiel (mit einer extrem kleinen Schrift):
quelle
CJam,
181174170 BytesAlle diese Nicht-ASCII-Zeichen befinden sich immer noch im erweiterten ASCII-Bereich, sodass sie alle in einem Byte codiert werden können. (Mit Ausnahme der
█
, die aber speziell gemäß der Herausforderungsspezifikation behandelt wird.) Daher zähle ich jedes Zeichen als Byte.Stack Exchange hat wahrscheinlich einige der nicht druckbaren Zeichen entstellt, sodass Sie möglicherweise den Code aus diesem Pastebin kopieren müssen .
Teste es hier.
Übernimmt die Eingabe über STDIN als durch Leerzeichen getrennte Liste von Wörtern. Das erste Wort ist die größte Skala. Zum Beispiel:
Ausbeuten
Erläuterung
Zunächst speichern wir eine Nachschlagetabelle für Buchstabenformen in
L
:Die erste Zeichenfolge ist nur eine komprimierte Zahl. Wir behandeln die Codepunkte als Basis-257-Ziffern und konvertieren dann die resultierende Zahl in eine Binärzahl.
YYb
ist 2 ist in der Basis 2, so gibt es[1 0]
. Wir verwenden die Elementsubstitution mit" █"
, um die Ziffern in Leerzeichen und Blockzeichen umzuwandeln. Zuletzt teilen wir den String in Zeilen mit 5 Zeichen und wieder in Blöcke mit 5 Zeilen. Das Ergebnis wird imL
Stapel gespeichert und vom Stapel verworfen.Nun besteht die allgemeine Idee darin, mit einer einzelnen Zeile
█
der Länge des Wortes der größten Skala zu beginnen. Und dann gehen wir für jedes Wort das vorhandene Raster durch und erweitern alle Blöcke auf das entsprechende Zeichen in der nächst kleineren Skala (während leere Zeilen und Spalten zur Trennung eingefügt werden). Hier ist die Eingabevorbereitung:Schauen wir uns zuerst die äußerste Struktur des verbleibenden Programms an. Der nächste Block
{...}/
wird für jedes Wort ausgeführt und erweitert jedes der Blockzeichen.Schauen wir uns zum Schluss an, wie eine einzelne Zeile erweitert wird:
Das Ergebnis wird am Ende des Programms automatisch ausgedruckt.
quelle