Слова внутри слов внутри слов внутри слов. , ,

В этом пиксельном шрифте прописных букв алфавита все символы имеют ширину 5 единиц и высоту 5.

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

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

Как видно, между буквами и между строками есть 1 единица пробела. Таким образом, каждая буква может занимать до 6 × 6 единиц пространства.

Предположим, что вместо использования символа full block ( █) для непосредственного формирования формы букв мы хотели использовать другие буквы того же шрифта . Это включает в себя увеличение размеров текста в 6 раз, чтобы буквы, сделанные из полных блоков, можно было использовать в качестве замены полных блоков в большом тексте.

Если это не имеет смысла, надеюсь, этот пример будет. Вот A, сделанный из B с использованием пиксельного шрифта:

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

B сделаны из полных блоков, а A состоит из B. Обратите внимание, что B все еще имеют одну единицу между ними по горизонтали и вертикали.

Мы можем расширить эту идею, используя слова вместо букв. Вот "ВОДА" из "ОГНЯ":

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

Обратите внимание, как «ОГОНЬ» появляется несколько раз в каждой строке и всегда в порядке, независимо от того, сколько места находится между буквами. Три из самых правых экземпляров «ОГНЯ» были отключены рано из-за того, как буквы «ВОДЫ» имеют форму.

Эту идею можно расширить еще больше, используя эти слова из слов, чтобы составить слова из слов, из слов или даже из слов, состоящих из слов, составленных из слов . Там нет предела теоретически.

В другом примере этот пост будет превышать ограничение в 30 тыс. Символов, но вы можете увидеть, что подразумевается под «словами, составленными из слов из слов», запустив этот изящный фрагмент стека. Просто оставьте параметры по умолчанию и нажмите «Go!». Вы должны увидеть слово «СОБАКА» из слова «КОШКА» из слова «МЫШЬ».

Показать фрагмент кода

alphabet = {A:[[0,1,1,1,0,0],[1,0,0,0,1,0],[1,1,1,1,1,0],[1,0,0,0,1,0],[1,0,0,0,1,0],[0,0,0,0,0,0]],C:[[0,1,1,1,0,0],[1,0,0,0,1,0],[1,0,0,0,0,0],[1,0,0,0,1,0],[0,1,1,1,0,0],[0,0,0,0,0,0]],B:[[1,1,1,1,0,0],[1,0,0,0,1,0],[1,1,1,1,0,0],[1,0,0,0,1,0],[1,1,1,1,0,0],[0,0,0,0,0,0]],E:[[1,1,1,1,1,0],[1,0,0,0,0,0],[1,1,1,1,0,0],[1,0,0,0,0,0],[1,1,1,1,1,0],[0,0,0,0,0,0]],D:[[1,1,1,1,0,0],[1,0,0,0,1,0],[1,0,0,0,1,0],[1,0,0,0,1,0],[1,1,1,1,0,0],[0,0,0,0,0,0]],G:[[0,1,1,1,1,0],[1,0,0,0,0,0],[1,0,0,1,1,0],[1,0,0,0,1,0],[0,1,1,1,1,0],[0,0,0,0,0,0]],F:[[1,1,1,1,1,0],[1,0,0,0,0,0],[1,1,1,1,0,0],[1,0,0,0,0,0],[1,0,0,0,0,0],[0,0,0,0,0,0]],I:[[1,1,1,1,1,0],[0,0,1,0,0,0],[0,0,1,0,0,0],[0,0,1,0,0,0],[1,1,1,1,1,0],[0,0,0,0,0,0]],H:[[1,0,0,0,1,0],[1,0,0,0,1,0],[1,1,1,1,1,0],[1,0,0,0,1,0],[1,0,0,0,1,0],[0,0,0,0,0,0]],K:[[1,0,0,0,1,0],[1,0,0,1,0,0],[1,1,1,0,0,0],[1,0,0,1,0,0],[1,0,0,0,1,0],[0,0,0,0,0,0]],J:[[0,0,0,0,1,0],[0,0,0,0,1,0],[0,0,0,0,1,0],[1,0,0,0,1,0],[0,1,1,1,0,0],[0,0,0,0,0,0]],M:[[1,0,0,0,1,0],[1,1,0,1,1,0],[1,0,1,0,1,0],[1,0,0,0,1,0],[1,0,0,0,1,0],[0,0,0,0,0,0]],L:[[1,0,0,0,0,0],[1,0,0,0,0,0],[1,0,0,0,0,0],[1,0,0,0,0,0],[1,1,1,1,1,0],[0,0,0,0,0,0]],O:[[0,1,1,1,0,0],[1,0,0,0,1,0],[1,0,0,0,1,0],[1,0,0,0,1,0],[0,1,1,1,0,0],[0,0,0,0,0,0]],N:[[1,0,0,0,1,0],[1,1,0,0,1,0],[1,0,1,0,1,0],[1,0,0,1,1,0],[1,0,0,0,1,0],[0,0,0,0,0,0]],Q:[[0,1,1,1,0,0],[1,0,0,0,1,0],[1,0,0,0,1,0],[1,0,0,1,1,0],[0,1,1,1,1,0],[0,0,0,0,0,0]],P:[[1,1,1,1,0,0],[1,0,0,0,1,0],[1,1,1,1,0,0],[1,0,0,0,0,0],[1,0,0,0,0,0],[0,0,0,0,0,0]],S:[[0,1,1,1,1,0],[1,0,0,0,0,0],[0,1,1,1,0,0],[0,0,0,0,1,0],[1,1,1,1,0,0],[0,0,0,0,0,0]],R:[[1,1,1,1,0,0],[1,0,0,0,1,0],[1,1,1,1,0,0],[1,0,0,1,0,0],[1,0,0,0,1,0],[0,0,0,0,0,0]],U:[[1,0,0,0,1,0],[1,0,0,0,1,0],[1,0,0,0,1,0],[1,0,0,0,1,0],[0,1,1,1,0,0],[0,0,0,0,0,0]],T:[[1,1,1,1,1,0],[0,0,1,0,0,0],[0,0,1,0,0,0],[0,0,1,0,0,0],[0,0,1,0,0,0],[0,0,0,0,0,0]],W:[[1,0,0,0,1,0],[1,0,0,0,1,0],[1,0,1,0,1,0],[1,0,1,0,1,0],[0,1,0,1,0,0],[0,0,0,0,0,0]],V:[[1,0,0,0,1,0],[1,0,0,0,1,0],[0,1,0,1,0,0],[0,1,0,1,0,0],[0,0,1,0,0,0],[0,0,0,0,0,0]],Y:[[1,0,0,0,1,0],[0,1,0,1,0,0],[0,0,1,0,0,0],[0,0,1,0,0,0],[0,0,1,0,0,0],[0,0,0,0,0,0]],X:[[1,0,0,0,1,0],[0,1,0,1,0,0],[0,0,1,0,0,0],[0,1,0,1,0,0],[1,0,0,0,1,0],[0,0,0,0,0,0]],Z:[[1,1,1,1,1,0],[0,0,0,1,0,0],[0,0,1,0,0,0],[0,1,0,0,0,0],[1,1,1,1,1,0],[0,0,0,0,0,0]]}

empty = ['\xA0', '.']
full = ['\u2588', 'X']
w = 6
h = 6

function makeGrid(height, width) {
    var grid = new Array(height)
    for(var y = 0; y < height; y++) {
        grid[y] = new Array(width)
    }
    return grid
}

function unfoldGrid(grid) {
    var newGrid = makeGrid(h * grid.length, w * grid[0].length)
    for (var y = 0; y < newGrid.length; y++) {
        for (var x = 0; x < newGrid[0].length; x++) {
            var yf = Math.floor(y / h), xf = Math.floor(x / w)
            if (grid[yf][xf] != 0) {
                newGrid[y][x] = grid[yf][xf][y % h][x % w]
            } else {
                newGrid[y][x] = 0
            }
        }
    }    
    return newGrid
}

function makeWords(words, empty, full) {
    var grid = makeGrid(1, words[0].length)
    for (var i = 0; i < words[0].length; i++) {
        grid[0][i] = alphabet[words[0][i]]
    }
    console.log(grid.length)
        console.log(grid[0].length)
    grid = unfoldGrid(grid)
    
        console.log(grid.length)
        console.log(grid[0].length)
    for(var i = 1; i < words.length; i++) {
        for (var y = 0; y < grid.length; y++) {
            var offset = 0
            for (var x = 0; x < grid[0].length; x++) {
                if (grid[y][x]) {
                    grid[y][x] = alphabet[words[i][offset++ % words[i].length]]
                }
            }
        }
        grid = unfoldGrid(grid)
    }
    
    var output = ''
    
    var height = Math.pow(h, words.length) - (Math.pow(h, words.length) - 1) / (h - 1)
    var width = words[0].length * Math.pow(w, words.length) - (Math.pow(w, words.length) - 1) / (w - 1)
    
    for (var y = 0; y < height; y++) {
        for (var x = 0; x < width; x++) {
            output += grid[y][x] ? full : empty                                    
        }
        if (y + 1 != height) {
            output += '\r\n'
        }
    }
    
    return output
}

function go() {
    plain = document.getElementById('plain').checked ? 1 : 0
    document.getElementById('canvas').value = makeWords(document.getElementById('words').value.split(' '), empty[plain], full[plain])
    resize()
}

function resize() {
    document.getElementById('canvas').style.fontSize = document.getElementById('size').value
}

function zoom(magnify) {
    canvas = document.getElementById('canvas')
    match = canvas.style.fontSize.match(/^(\d+(?:\.\d+)?)(.*)$/)
    if (match !== null) {
        number = parseFloat(match[1])
        unit = match[2]
        canvas.style.fontSize = document.getElementById('size').value = (number + (magnify ? 0.1 : -0.1)) + unit
    }
}

#canvas {
    font-family: Consolas, "Courier New", sans-serif;
    white-space: nowrap; overflow: auto;
    width: 6in;
    height: 3in;
}

<p>Words: <input type='text' id='words' value='DOG CAT MOUSE'> <button type='button' onclick='go()'>Go!</button> Plain ASCII <input type='checkbox' id='plain'></p>
<p>Font Size: <input type='text' id='size' value='0.4mm'> <button type='button' onclick='resize()'>Resize</button> <button type='button' onclick='zoom(1)'>+</button> <button type='button' onclick='zoom(0)'>-</button> (use any unit: in, cm, mm, em, pt, px)</p>
<textarea id='canvas'></textarea>

Развернуть фрагмент

Ввод любого разделенного пробелами списка слов, содержащих только заглавные буквы в текстовом поле, приведет к получению первого слова, составленного из второго слова, изготовленного из третьего, изготовленного из четвертого, изготовленного из ... и т. Д.

ПРЕДУПРЕЖДЕНИЕ. Ввод более 4 или даже 3 слов приведет к появлению ОЧЕНЬ большого количества текста и займёт ДОЛГОЕ время. Это может привести к сбою вашего браузера / компьютера / автомобиля.

Вызов

Цель этого задания - отразить действия фрагмента стека с наименьшим количеством символов.

Вы должны написать программу, которая принимает строку слов, разделенных пробелами, содержащую только заглавные буквы, и выводит первое слово, «сделанное из», второе, «сделанное из» третьего и т. Д., Используя приведенный выше пиксельный шрифт.

Флажок «Простой ASCII» и функции размера шрифта фрагмента не должны поддерживаться в вашей программе. Зеркальное отражение преобразования списков слов в слова, составленные из слов, является главным и единственным требованием.

Детали

Входные данные должны поступать из стандартного ввода, командной строки, или вы можете просто написать функцию, которая принимает строку.
Вы можете предположить, что ввод всегда действителен, то есть строка слов, состоящая из заглавных букв, разделенных ровно одним пробелом, без начальных или конечных пробелов.
Вывод должен идти в стандартный вывод (или аналогичную альтернативу) или в файл с именем по вашему выбору.
Вывод должен состоять исключительно из символов пробела , пробела и символов новой строки.
- В пустой / полный пробелы должны быть либо пробел и полный блок ( , █) соответственно, или период и Х ( ., X) соответственно.
Вывод не должен содержать никаких начальных столбцов, содержащих только символы пробела , хотя допускается любая комбинация конечных символов пробела в любых строках.
- Так что это разрешено:
```
X...X.XXXXX..
X...X.X
X.X.X.XXXX....
X.X.X.X..
.X.X..XXXXX..
```
- Но это не так:
```
.X...X.XXXXX..
.X...X.X
.X.X.X.XXXX....
.X.X.X.X..
..X.X..XXXXX..
```
Не должно быть начальных или конечных строк, содержащих только символы пробела . Один трейлинг-перевод строки разрешен.

Вот более дружественная к строке версия шрифта:

.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

счет

Это код-гольф, поэтому выигрывает самое короткое представление в байтах . Любой экземпляр полного block ( █) может быть посчитан как 1 байт вместо 3, так что использование, которое использует X, не имеет преимущества.

code-golf ascii-art kolmogorov-complexity Кальвин Хобби
источник

Вы можете выполнить следующую Фрагмент кода JavaScript (напр путем ввода. javascript:В строке URL и вставить его) , чтобы сделать ASCII искусство здесь много, гораздо легче читать: $('#question pre').css('line-height',1). Результат: i.stack.imgur.com/XmB8C.png

Ручка двери

Или включить ответы$('#question pre, .answer pre').css('line-height',1)

Мартин Эндер

Я знаю, что уже слишком поздно, чтобы шутить, но я не удержался: i.imgur.com/vAZi1Zt.png .

алгоритмический

Как я пропустил этот вызов ?!

Волшебная Осьминог Урна

Ответы:

CJam, 171 165 162 161 байт

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=

Я лечу █как 1 байт. Остальные все символы находятся в пределах ASCII-диапазона, поэтому они рассматриваются как 1 байт.

Вы можете использовать этот pastebin для точного кода

Пример вывода для ввода:

FIRST HELLO WORLD

введите описание изображения здесь

Как это устроено

Прежде всего

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

это просто шаблон для каждого из 27 символов ( A-Zи пробела), который состоит из 0(в Xпозициях) и 1(в .позициях). После декодирования это дает массив из 27 элементов двумерных массивов из 5 строк и 5 столбцов, представляющих Xи .для каждого из 27 символов. Давайте назовем этот массив как L.

Теперь оставшийся код:

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

Попробуйте это онлайн здесь

оптимизатор
источник

Python 3, 437 байт

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

Формы символов закодированы в ASCII. Каждый байт ASCII соответствует одной строке одного символа с битами, представляющими единичные блоки. Это не очень эффективная схема, но ее легко распаковать в битовые маски NumPy для каждого символа.

Мы начнем с двухмерного массива 1 с. Он имеет один столбец для каждого символа в первом слове и одну строку. Затем для каждого слова мы создаем новый массив с нулями, который в шесть раз выше и в шесть раз шире предыдущего массива. Если предыдущий массив имел 1, соответствующий раздел 6x6 нового массива заполняется битовой маской соответствующего символа.

Вот пример (с очень маленьким шрифтом):

введите описание изображения здесь

GRC
источник

CJam, 181 174 170 байт

Все эти не-ASCII-символы все еще находятся в расширенном диапазоне ASCII, поэтому все они могут быть закодированы одним байтом. (За исключением █, но этот обрабатывается специально в соответствии со спецификацией вызова.) Поэтому я считаю каждый символ байтом.

"Á  :½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, вероятно, исказил некоторые непечатаемые символы, поэтому вам, возможно, придется скопировать код из этой вставки .

Проверьте это здесь.

Принимает ввод через STDIN как разделенный пробелами список слов. Первое слово - самый большой масштаб. Например:

HOLISM REDUCTIONISM

доходность

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

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

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

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

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

объяснение

Во-первых, мы храним таблицу поиска для форм букв в L:

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

Первая строка просто сжатое число. Мы рассматриваем кодовые точки как базовые 257 цифр, а затем конвертируем полученное число в двоичное. YYb2 находится в базе 2, так что дает [1 0]. Мы используем замену элементов с, " █"чтобы превратить цифры в пробелы и блокировать символы. Наконец, мы разбиваем строку на строки по 5 символов и снова на блоки по 5 строк. Результат сохраняется Lи удаляется из стека.

Теперь общая идея состоит в том, чтобы начать с одной строки █длины слова самого большого масштаба. И затем для каждого слова мы проходим через существующую сетку и расширяем все блоки до соответствующего символа в следующем меньшем масштабе (вставляя пустые строки и столбцы для разделения). Вот входная подготовка:

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

Давайте сначала посмотрим на внешнюю структуру оставшейся программы. Следующий блок {...}/запускается для каждого слова и расширяет каждый из символов блока.

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

Наконец, давайте посмотрим, как раскрывается одна строка:

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

Результат распечатывается автоматически в конце программы.

Мартин Эндер
источник