Słowa w słowach w słowach w słowach. . .

17

W tej pikselowej czcionce wielkich liter alfabetu wszystkie znaki mają 5 jednostek szerokości i 5 wysokości.

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

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

Jak widać, istnieje również 1 jednostka odstępu między literami i między wierszami. Każda litera może więc zająć do 6 × 6 jednostek miejsca.

Załóżmy, że zamiast używać znaku pełnego bloku ( ) do bezpośredniego formowania kształtów liter, chcieliśmy użyć innych liter w tej samej czcionce . Polega to na 6-krotnym zwiększeniu wymiarów tekstu, dzięki czemu litery wykonane z pełnych bloków mogą być używane jako zamienniki pełnych bloków w większym tekście.

Jeśli to nie miało sensu, mam nadzieję, że ten przykład będzie. Oto A wykonane z B przy użyciu czcionki pikselowej:

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

B są zbudowane z pełnych bloków, a A z B. Zauważ, że B wciąż mają jedną jednostkę między nimi poziomo i pionowo.

Możemy rozszerzyć ten pomysł, używając słów zamiast liter. Oto „WODA” wykonana z „POŻARU”:

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

Zauważ, jak „FIRE” pojawia się wielokrotnie w każdym wierszu i zawsze w porządku, bez względu na to, ile miejsca jest między literami. Trzy najbardziej prawostronne przypadki „POŻARU” zostały wcześnie odcięte ze względu na kształt liter „WODY”.

Tę ideę można rozszerzyć jeszcze bardziej, używając tych słów wykonanych ze słów, aby utworzyć słowa złożone ze słów złożonych ze słów , a nawet słów złożonych ze słów złożonych ze słów . Teoretycznie nie ma ograniczeń.

Inny przykład umieszczałby ten post powyżej limitu 30 000 znaków, ale możesz zobaczyć, co należy rozumieć przez „słowa złożone ze słów utworzonych ze słów”, uruchamiając ten fajny fragment kodu stosu. Po prostu pozostaw parametry domyślne i naciśnij „Idź!”. Powinieneś zobaczyć słowo „PSY” ze słowa „KOT” ze słowa „MYSZ”.

Wpisanie dowolnej listy oddzielonych spacjami słów zawierających tylko wielkie litery w polu tekstowym spowoduje utworzenie pierwszego słowa złożonego z drugiego słowa złożonego z trzeciego, złożonego z czwartego, wykonanego z ... itd.

OSTRZEŻENIE: Wpisanie więcej niż 4, a nawet 3 słów spowoduje powstanie DUŻEGO tekstu i zajmie DŁUGO czasu. Może to spowodować awarię przeglądarki / komputera / samochodu.

Wyzwanie

Celem tego wyzwania jest odzwierciedlenie tego, co robi Fragment stosu przy jak najmniejszej liczbie postaci.

Musisz napisać program, który pobiera oddzielony spacjami ciąg słów zawierający tylko wielkie litery i wypisuje pierwsze słowo „wykonane z” drugiego „wykonane z” trzeciego i tak dalej, używając pikselowej czcionki podanej powyżej.

Pole wyboru „Zwykły ASCII” i funkcje rozmiaru czcionki fragmentu nie muszą być obsługiwane w Twoim programie. Odzwierciedlenie transformacji z list słów do słów utworzonych ze słów jest głównym punktem i jedynym wymogiem.

Detale

  • Dane wejściowe powinny pochodzić ze stdin, wiersza poleceń, lub możesz po prostu napisać funkcję, która pobiera ciąg.

  • Możesz założyć, że dane wejściowe są zawsze prawidłowe, tzn. Ciąg słów złożony z wielkich liter, oddzielonych dokładnie jedną spacją, bez spacji wiodących i końcowych.

  • Dane wyjściowe powinny przejść do standardowego wyjścia (lub podobnej alternatywy) lub do pliku o wybranej nazwie.

  • Wyjście powinno składać się całkowicie ze znakami pustymi kosmicznych , znaków pełnej przestrzeni i nowych linii.

    • Te postacie pusty / pełnej przestrzeń powinna być albo pełna przestrzeń i blok ( , ), lub Okres X ( ., X), odpowiednio.
  • Dane wyjściowe nie powinny zawierać żadnych wiodących kolumn zawierających tylko znaki pustej przestrzeni , chociaż dozwolona jest dowolna kombinacja końcowych znaków pustej przestrzeni w dowolnych wierszach.

    • Jest to dozwolone:

      X...X.XXXXX..
      X...X.X
      X.X.X.XXXX....
      X.X.X.X..
      .X.X..XXXXX..
      
    • Ale to nie jest:

      .X...X.XXXXX..
      .X...X.X
      .X.X.X.XXXX....
      .X.X.X.X..
      ..X.X..XXXXX..
      
  • Nie powinno być żadnych początkowych ani końcowych wierszy zawierających tylko znaki pustej przestrzeni . Pojedynczy znak nowej linii jest opcjonalnie dozwolony.

Oto bardziej przyjazna dla łańcucha wersja czcionki:

.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

Punktacja

To jest więc wygrywa najkrótsze przesłanie w bajtach . Każde wystąpienie pełnego bloku ( ) może być liczone jako 1 bajt zamiast 3, więc przesyłanie, którego używa X, nie ma przewagi.

Hobby Calvina
źródło
5
Można uruchomić poniższy fragment kodu JavaScript (Wj przez pisanie. javascript:W pasku adresu i wklejenie go), aby ASCII tutaj dużo, dużo łatwiejsze do odczytania: $('#question pre').css('line-height',1). Rezultat: i.stack.imgur.com/XmB8C.png
Gałka
1
Lub dołączyć odpowiedzi$('#question pre, .answer pre').css('line-height',1)
Martin Ender
Wiem, że jest trochę za późno, by żartować, ale nie mogłem się oprzeć: i.imgur.com/vAZi1Zt.png .
algorytmshark
Jak przegapiłem to wyzwanie ?!
Magic Octopus Urn

Odpowiedzi:

8

CJam, 171 165 162 161 bajtów

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=

Traktuję jak 1 bajt. Reszta wszystkie znaki znajdują się w zakresie ASCII, więc traktuje je również jako 1 bajt.

Możesz użyć tej pastebin do dokładnego kodu

Przykładowe dane wyjściowe dla danych wejściowych:

FIRST HELLO WORLD

wprowadź opis zdjęcia tutaj

Jak to działa

Po pierwsze

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

jest po prostu wzorem dla każdego z 27 znaków ( A-Zi spacji), który składa się z 0(w Xpozycjach) i 1(w .pozycjach). Po dekodowaniu daje to 27-elementową tablicę tablic 2D o 5 wierszach i 5 kolumnach reprezentujących Xi .dla każdego z 27 znaków. Nazwijmy tę tablicę jako L.

Teraz pozostały kod:

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";

Wypróbuj online tutaj

Optymalizator
źródło
9

Python 3, 437 bajtów

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

Kształty znaków są kodowane w ASCII. Każdy bajt ASCII odpowiada jednemu wierszowi jednego znaku, a bity reprezentują bloki jednostek. Nie jest to bardzo wydajny schemat, ale łatwo jest rozpakować go w maskach bitowych NumPy dla każdej postaci.

Zaczynamy od tablicy 2d 1s. Ma jedną kolumnę dla każdego znaku w pierwszym słowie i pojedynczy wiersz. Następnie dla każdego słowa tworzymy nową tablicę zer, sześć razy wyższą i sześć razy szerszą niż poprzednia tablica. Tam, gdzie poprzednia tablica miała 1, odpowiadająca jej sekcja 6x6 nowej tablicy jest wypełniona maską bitową odpowiedniego znaku.

Oto przykład (z bardzo małą czcionką):

wprowadź opis zdjęcia tutaj

grc
źródło
5

CJam, 181 174 170 bajtów

Wszystkie znaki spoza ASCII nadal znajdują się w rozszerzonym zakresie ASCII, więc można je wszystkie zakodować w jednym bajcie. (Z wyjątkiem , ale ten jest traktowany specjalnie zgodnie ze specyfikacją wyzwania.) Dlatego liczę każdą postać jako bajt.

"Á  :½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 prawdopodobnie zniekształcił niektóre z niedrukowalnych znaków, więc może być konieczne skopiowanie kodu z tej pastebin .

Sprawdź to tutaj.

Pobiera dane wejściowe przez STDIN jako listę słów oddzieloną spacjami. Pierwsze słowo to największa skala. Na przykład:

HOLISM REDUCTIONISM

plony

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

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

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

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

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

Wyjaśnienie

Najpierw przechowujemy tabelę odnośników dla kształtów liter w L:

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

Pierwszy ciąg to tylko skompresowana liczba. Punkty kodowe traktujemy jak cyfry bazowe 257, a następnie przekształcamy wynikową liczbę na binarną. YYbjest 2 jest w bazie 2, więc daje [1 0]. Używamy podstawiania elementu za pomocą, " █"aby zamieniać cyfry w spacje i blokować znaki. Na koniec podzieliliśmy ciąg na wiersze po 5 znaków i ponownie na bloki po 5 wierszy. Wynik jest przechowywany wL i odrzucany ze stosu.

Teraz ogólną ideą jest zacząć od jednego wiersza długości słowa o największej skali. Następnie dla każdego słowa przechodzimy przez istniejącą siatkę i rozwijamy wszystkie bloki do odpowiedniego znaku w następnej mniejszej skali (wstawiając puste wiersze i kolumny do rozdzielenia). Oto przygotowanie danych wejściowych:

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

Najpierw spójrzmy na najbardziej zewnętrzną strukturę pozostałego programu. Następny blok {...}/jest uruchamiany dla każdego słowa i rozwija każdy ze znaków bloku.

{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.";

Na koniec spójrzmy, jak rozwinięta jest jedna linia:

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

Wynik jest drukowany automatycznie na końcu programu.

Martin Ender
źródło