Wörter innerhalb von Wörtern innerhalb von Wörtern. . .

17

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 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 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.

Calvins Hobbys
quelle
5
Sie können folgende JavaScript - Schnipsel (ex durch Tippen. Laufen 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
Türknauf
1
Oder um die Antworten einzuschließen$('#question pre, .answer pre').css('line-height',1)
Martin Ender
Ich weiß, dass es etwas zu spät ist, um diesen Witz zu machen, aber ich konnte nicht widerstehen: i.imgur.com/vAZi1Zt.png .
Algorithmushai
Wie habe ich diese Herausforderung verpasst ?!
Magic Octopus Urn

Antworten:

8

CJam, 171 165 162 161 Bytes

qS/_0=,0a*a\{{W:I;{'[{RI):I=}?i65-"c¿»ÐòO*4Õ]%ÐÎ<à IX]{-ïèq=ô}s×o)½2~û³'é¨1ÃlØeúN!Ö3~4ÜË|ÕÇäaepý®"255b2b5/5/=}%z1af*}%R,1a*a*}fR2a*"█ 
"f=

Ich 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:

FIRST HELLO WORLD

Bildbeschreibung hier eingeben

Wie es funktioniert

Vor allem

"c¿»ÐòO*4Õ]%ÐÎ<à IX]{-ïèq=ô}s×o)½2~û³'é¨1ÃlØeúN!Ö3~4ÜË|ÕÇäaepý®"255b2b5/5/

ist einfach das Muster für jedes der 27 Zeichen ( A-Zund Leerzeichen), das aus 0(an XPositionen) und 1(an .Positionen) besteht. Nach der Decodierung ergibt dies eine 27 - Element - Array von 2D - Arrays aus 5 Reihen und 5 Spalten repräsentieren Xund .für jede der 27 Zeichen. Nennen wir dieses Array als L.

Nun der restliche Code:

qS/                      "Read the input and split it on space to get array Q";
   _0=                   "Get a copy of the first element of the above array";
      ,0a*               "Create an array filled with 0 with length of the first element";
          a\             "Wrap that array in another array and swap to get Q on top";
{  ...  }fR              "This is a for each loop on the array Q with R having the";
                         "current element value in each loop";
 {...}%                  "In the first iteration, the 0 array we created will be the";
                         "only thing on stack, in subsequent iterations, the result";
                         "of previous iteration will be on stack";
  W:I;                   "Initialize variable I with -1";
      {...}%             "Run this block on each element of the current array";
{'[{RI):I=}?i65-L=}%     "This is the above code block. In each iteration, we figure";
                         "out what character needs to be be put at the current index";
                         "Then we get the pattern of 0 and 1 for that character";
 '[{      }?             "Stack contains either 0 or 1. If it is 1, we want to leave";
                         "that index blank, so we put pattern of '[ which is 5X5 spaces";
    RI_:I=               "When we do not want a blank character, we get the next"
                         "character from R to fill the non empty space";
            i65-         "Convert A-Z  to 0-27 notation";
                L=       "Get the corresponding pattern from the pattern array L";
z1af*                    "After the above iterations, for each line of the previous";
                         "iteration's output, we get a vertical 2D array for next";
                         "iteration. We transpose it and join each character in";
                         "this line using a space";
      R,1a*a*            "After getting all lines from current iteration, we join them";
                         "with one full line of space characters";

 2a*                     "After all iterations, we have the 0 1 based 2D array for the";
                         "final output ASCII with each row representing a line. We join";
                         "these lines with 2, to get a 0 1 2 based array";
     "█                  "A brick, a space and a newline. Mapping 1 to 1 with 0 1 2";
"                        "based array";
 f=                      "For each of the 0 1 2 based array element, convert them to";
                         "one of the brick, space and new line character";

Probieren Sie es hier online aus

Optimierer
quelle
9

Python 3, 437 Bytes

from numpy import*
s=input().split()
d=fromstring('NONO__^Q_PQAQQNONO^_QQQQQ_QQQQAAAQDPIA[SQQQQADQQQJJH_OAQOOY_DPGAUUQOQONDQJUDDDQQQQAAQQDQIAQYQAYIPDQJUJDBQONO_A^Q_NQ_QQNA^QODNDJQD_',byte)[:,None]>>arange(5)&1
b=0
x=1
y=len(s[0])
n=[[1]*y]
for w in s:
 g=n;b+=x;x*=6;n=zeros((x,x*y),int);i=-6
 for q in g:
  o=j=0;i+=6
  for p in q:n[i:i+5,j:j+5]|=d[ord(w[o%len(w)])-65::26]*p;o+=p;j+=6
for r in n[:-b]:print(''.join(' █'[x] for x in r))

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):

Bildbeschreibung hier eingeben

grc
quelle
5

CJam, 181 174 170 Bytes

Alle 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.

"Á  :½A%õ­Íú£à˪ë8!Õ*j4¶fVËa¡ùÔ¯{+ÛyéâõKn#@?
9Ôia)(Ñç;~LÒª"257b2bYYb" █"er5/5/:L;lS/_0=,'█*a\{f{W:T;\{' ={S5*a5*}{T):T1$='A-L=}?\}%W<zSf*}Sa*}/N*

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:

HOLISM REDUCTIONISM

Ausbeuten

████                    █████             ████  █   █  ███              █████                               █████  ███  █   █ █████  ████             █   █ ████  █████ ████        █   █                    ███ 
█   █                   █                 █   █ █   █ █   █               █                                   █   █   █ ██  █   █   █                 ██ ██ █   █ █     █   █       █   █                   █   █
████                    ████              █   █ █   █ █                   █                                   █   █   █ █ █ █   █    ███              █ █ █ ████  ████  █   █       █   █                   █    
█  █                    █                 █   █ █   █ █   █               █                                   █   █   █ █  ██   █       █             █   █ █  █  █     █   █       █   █                   █   █
█   █                   █████             ████   ███   ███                █                                 █████  ███  █   █ █████ ████              █   █ █   █ █████ ████         ███                     ███ 

████                    █████       ████                    █   █        ███                                            █████                   █████                                ███  █   █       █████  ████
█   █                   █           █   █                   █   █       █   █                                             █                       █                                 █   █ ██  █         █   █    
████                    ████        █   █                   █   █       █                                                 █                       █                                 █   █ █ █ █         █    ███ 
█  █                    █           █   █                   █   █       █   █                                             █                       █                                 █   █ █  ██         █       █
█   █                   █████       ████                     ███         ███                                              █                     █████                                ███  █   █       █████ ████ 

████  █████ ████  █   █  ███        █████                   █████        ███                                            █   █                         █████  ████ █   █             ████        █████       ████ 
█   █ █     █   █ █   █ █   █         █                       █         █   █                                           ██  █                           █   █     ██ ██             █   █       █           █   █
████  ████  █   █ █   █ █             █                       █         █   █                                           █ █ █                           █    ███  █ █ █             ████        ████        █   █
█  █  █     █   █ █   █ █   █         █                       █         █   █                                           █  ██                           █       █ █   █             █  █        █           █   █
█   █ █████ ████   ███   ███          █                     █████        ███                                            █   █                         █████ ████  █   █             █   █       █████       ████ 

████                    █████       ████                    █   █        ███                                            █████                                           █████        ███                    █   █
█   █                   █           █   █                   █   █       █   █                                             █                                               █         █   █                   ██  █
████                    ████        █   █                   █   █       █                                                 █                                               █         █   █                   █ █ █
█  █                    █           █   █                   █   █       █   █                                             █                                               █         █   █                   █  ██
█   █                   █████       ████                     ███         ███                                              █                                             █████        ███                    █   █

████                    █████             ████  █   █  ███              █████ █████  ███  █   █ █████        ████ █   █ ████  █████ ████        █   █  ███  █████ █████              ███                    █   █
█   █                   █                 █   █ █   █ █   █               █     █   █   █ ██  █   █         █     ██ ██ █   █ █     █   █       █   █ █   █   █     █               █   █                   ██  █
████                    ████              █   █ █   █ █                   █     █   █   █ █ █ █   █          ███  █ █ █ ████  ████  █   █       █   █ █       █     █               █   █                   █ █ █
█  █                    █                 █   █ █   █ █   █               █     █   █   █ █  ██   █             █ █   █ █  █  █     █   █       █   █ █   █   █     █               █   █                   █  ██
█   █                   █████             ████   ███   ███                █   █████  ███  █   █ █████       ████  █   █ █   █ █████ ████         ███   ███    █   █████              ███                    █   █

Erläuterung

Zunächst speichern wir eine Nachschlagetabelle für Buchstabenformen in L:

"Á  :½A%õ­Íú£à˪ë8!Õ*j4¶fVËa¡ùÔ¯{+ÛyéâõKn#@?
9Ôia)(Ñç;~LÒª"257b2bYYb" █"er5/5/: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. YYbist 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 im LStapel 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:

lS/_0=,'█*a\
lS/          "Read input, split on spaces.";
   _0=       "Duplicate and get first word.";
      ,'█*   "Get length repeat █ that many times.";
          a  "Wrap in array, to make the grid two-dimensional.";
           \ "Swap with word list.";

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.

{f{...}Sa*}/N*
{         }/   "Process each word in the input.";
 f{...}        "Map this block onto each line of the grid, passing in the current word as well.";
       Sa*     "Since each original line will be turned into 5 lines, the grid is still grouped
                into blocks of 5 lines. We join them together with empty lines as required.";
            N* "Join all lines together with newlines.";

Schauen wir uns zum Schluss an, wie eine einzelne Zeile erweitert wird:

W:T;\{' ={S5*a5*}{T):T1$='A-L=}?\}%
W:T;                                "Store -1 in T.";
    \                               "Swap word with line.";
     {                           }% "Map this block onto each character.";
      ' =                           "Check if the character is a space.";
         {      }{            }?    "If it is, run the first block, otherwise the second.";
          S5*                       "Create a string of five spaces.";
             a5*                    "Create an array of five such strings.";
                  T):T              "Push T, increment, store in T.";
                      1$=           "Copy the word and access the T'th character, cyclically.";
                         'A-        "Subtract A from the letter.";
                            L=      "Use the result to get the character shape from L.";
                                \   "Swap resulting block with word.";

"At this point each character is replaced with a 5x5 array of new characters.
 So we actually have a 3D array right now. Since we used a map operation, the
 current word will also be at the end of the array, which we need to get rid off.";

W<zSf*
W<     "Discard last array element - the current word.";
  z    "Zip or transpose the top two levels of the array.";
   Sf* "Join each line together with spaces.";

Das Ergebnis wird am Ende des Programms automatisch ausgedruckt.

Martin Ender
quelle