Dada una palabra que consiste solo en letras minúsculas, haga lo siguiente:

1. Para cada letra, obtenga la factorización prima de su posición en el alfabeto.
2. Para cada factor primo, p , dibuje un diamante de longitud lateral p y pegue la letra en el medio del diamante.
3. El diamante más grande está en el medio, los diamantes más pequeños subsecuentes (del más grande al más pequeño) se alternan entre ir hacia abajo o hacia arriba.

Nota: Para la letra a use una longitud lateral de 1.

Ejemplo: gato

• c : 3 = 3
• a : 1 = 1
• t : 20 = 5 * 2 * 2

El diagrama:

                 .
                . .
               . t .
                . .
                 .
                 .
                . .
   .           .   .
  . .         .     .
 .   .   .   .       .
.  c  . .a. .    t    .
 .   .   .   .       .
  . .         .     .
   .           .   .
                . .
                 .
                 .
                . .
               . t .
                . .
                 .

Ejemplo: perro

• d : 4 = 2 * 2
• o : 15 = 5 * 3
• g : 7 = 7

Diagrama:

                         .
                        . .
           .           .   .
          . .         .     .
         .   .       .       .
  .     .     .     .         .
 . .   .       .   .           .
. d . .    o    . .      g      .
 . .   .       .   .           .
  .     .     .     .         .
  .      .   .       .       .
 . .      . .         .     .
. d .      .           .   .
 . .       .            . .
  .       . .            .
         .   .
        .  o  .
         .   .
          . .
           .

-20% de bonificación si su programa genera un archivo de texto llamado "[su-palabra] .txt". Luego ingrese una palabra real (o frase, en minúsculas y sin espacios) que tenga al menos 20 letras de largo y que nadie más haya elegido aún, y pegue la salida entre ay <pre>a </pre>en su respuesta.

Matlab, 466 393 - 20% = 314,4 bytes

Golfed: (¡Podría ahorrar algunos bytes más, también gracias a la ayuda de @ AndreasDeak!)

function q(W);function z=g(l,c);[x,y]=ndgrid(abs(-l:l));z=0*y;z(~x&~y)=c;z(x+y==l)=46;end;w=W-96;n=numel(w);R=n*26;C=1;A=zeros(2*R);for k=1:n;f=sort(factor(w(k)));C=C+max(f)+1;d=-1;r=R;for F=fliplr(f);v=-F:F;while norm(A(r+v,v+C));r=r+d;end;A(r+v,v+C)=g(F,W(k));d=-d;end;C=C+max(f);end;A=A(find(sum(A,2)),find(sum(A)));f=fopen([W,'.txt'],'w');for k=1:size(A,1);fprintf(f,[A(k,:),'\n']);end;end

También debería funcionar en Octave (código abierto), pero solo con muchas advertencias. Use esta versión si desea probarlo en octava (salida a la consola, en lugar de archivo):

function q(W);function z=g(l,c);[x,y]=ndgrid(abs(-l:l));z=0*y;z(~x&~y)=c;z(x+y==l)=46;end;w=W-96;n=numel(w);R=n*26;C=1;A=zeros(2*R);for k=1:n;f=sort(factor(w(k)));C=C+max(f)+1;d=-1;r=R;for F=fliplr(f);v=-F:F;while norm(A(r+v,v+C));r=r+d;end;A(r+v,v+C)=g(F,W(k));d=-d;end;C=C+max(f);end;A=A(find(sum(A,2)),find(sum(A)));disp([A,'']);end

Ungolfed y explicó:

function q(W)
function z=g(l,c) %get a square matrix for one prime factor
[x,y]=ndgrid(abs(-l:l));
z=0*y;
z(~x&~y)=c;    %character in the middle
z(x+y==l)=46;  %dots
end;
w=W-96;                %convert word to the corresponding indices                  
n=numel(w);
R=n*26;                %keeps track of the main row 
C=1;                   %keeps track of the current column
A=zeros(2*R);          %make a 'canvas' matrix that is way to big 
for k=1:n;
    f=sort(factor(w(k)));          %get all the factors of current character
    C=C+max(f)+1;                  %update current column
    d=-1;                          %search direction
    r=R;
    for F=fliplr(f);              
        v=-F:F;
        while norm(A(r+v,v+C));    %go up or down until there is enough space to write the prime factor
            r=r+d;
        end;
        A(r+v,v+C)=g(F,W(k));     %insert all the prime factors
        d=-d;
    end;
    C=C+max(f);
end;
A=A(find(sum(A,2)),find(sum(A))); %truncate all the unneccessary padding
f=fopen([W,'.txt'],'w');     %write to file
for k=1:size(A,1);
    fprintf(f,[A(k,:),'\n']);
end;

end

La palabra solicitada: (Y aquí como un archivo: (alejar mucho): supercalifragilisticexpialidocious.txt )

                       . . .                   
                      . . . . . .                  
                     . . . . . .                 
                    . . . . . .                
                   . . . . . .               
                  . . . . . .              
                 . . . . . .             
                . . . . . .            
               . . . . . .           
              . . . . . . .          
             . . . . . . . .         
            . . . . . . . . . t. . . . .        
           . . . . . . . . . . . . . . . . . . . . . . . . .       
          . . . . . . . r. . l. . r. . . . l. . . . . X . . . . l. . . . .      
         . . . . . pag . . . . . . . . . . . . . . . . . . . pag . . . . . . . . .     
        . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .    
       . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .   
      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  
     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
    . s .. u .. p .. e .. r .. c ..a .. l .. i .. f .. r ..a .. g .. i .. l .. i .. s. . t .. i .. c .. e .. x .. p .. i ..a .. l .. i .. d .. o .. c .. i .. o .. u .. s .
     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  
       . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .   
        . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .    
         . . . . . pag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . pag . . . . . . . . d. . . . . . . . .     
          . . . . . . . . . l. . . . f. . . . . . . . l. . . . . . . . . X . . . . . . l. . . . . . . . . . . . .      
           . . . . . r. . . . yo . . . . r. . . yo . . . . yo . . . . . . yo . . . . . yo . . . . yo . . . . . yo . . . . . .       
            . . . . . . . . . . . . . . . . . . . . t. . . . . . . . . . . . . . . . . . .        
             . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . o. . . . o. . . . .         
              . . . . . pag . . . . . . . . . . . . . pag . . . . . . . . . . . .          
               . . . u. . . . . . X . . . . . . . . u. . .           
                . . . . . . . . . . . . . . . .            
                 . . . . . . . . . . .             
                  . . . . . . . .              
                   . . . . . .               
                    . . . . . .                
                     . . . . . .                 
                      . . . . . .                  
                       . . .                   

Funciton , no competitivo, 29199 bytes

Disfruté este desafío porque resaltó la dolorosa falta de algunas funciones de biblioteca muy útiles. Incluiré todas esas funciones aquí (y en el recuento de bytes) porque las escribí después de publicar este desafío.

Fuente completa en un solo archivo

Explicación

Como siempre, obtenga una mejor representación ejecutando javascript:(function(){$('pre,code').css({lineHeight:5/4});})()en la consola de su navegador.

① ɹ ⇄Reverso

Como puede saber o no, Funciton viene con una biblioteca llena de funciones para listas , que son valores codificados en un único número entero enorme, así como una biblioteca separada para secuencias evaluadas de manera diferida , que utilizan expresiones lambda (funciones anónimas) en Para ser perezoso. Por supuesto, también hay una biblioteca para funciones de manejo de cadenas.

Para este desafío, necesitaba una función para invertir una cadena, y una función para invertir una secuencia de evaluación diferida. Sorprendentemente, solo tenía uno para las listas, exactamente el que no necesitaba. Así que aquí están las funciones inversas para secuencias perezosas ( ɹ) y para cadenas ( ⇄):

              ╓───╖             ╔════╗ ┌────╖        ╓───╖
              ║ ɹ ║             ║ 21 ╟─┤ >> ╟──┐     ║ ⇄ ║
              ╙─┬─╜             ╚════╝ ╘═╤══╝  │     ╙─┬─╜      ┌──┐
          ┌─────┴─────┐                ┌─┴─╖   ├───────┴────────┤  │
        ┌─┴─╖ ┌───╖   │                │ ⇄ ║   │   ╔════╗ ┌───╖ │  │
      ┌─┤   ╟─┤ ɹ ╟─┐ │                ╘═╤═╝   │   ║ −1 ╟─┤ ≠ ╟─┴┐ │
      │ └─┬─╜ ╘═══╝ │ │                ┌─┴─╖ ┌─┴─╖ ╚════╝ ╘═╤═╝  │ │
      │   │   ┌───╖ │ │                │ ‼ ╟─┤ ? ╟──────────┤    │ │
      │   └───┤ ʬ ╟─┘ │                ╘═╤═╝ ╘═╤═╝  ╔═══╗ ┌─┴─╖  │ │
      │       ╘═╤═╝   │                ┌─┴─╖ ╔═══╗  ║ 0 ╟─┤ ≠ ╟──┘ │
      │ ╔═══╗ ┌─┴─╖   │              ┌─┤ ʃ ╟─╢ 1 ║  ╚═╤═╝ ╘═══╝    │
      └─╢ 0 ╟─┤ ? ╟───┘              │ ╘═╤═╝ ╚═══╝    │            │
        ╚═══╝ ╘═╤═╝                  │   └────────────┘            │
                │                    └─────────────────────────────┘

Las secuencias perezosas que se usan ʬ, que son "agregar un elemento al final de una secuencia perezosa". La cadena que se usa ʃ(subcadena) y ‼(cadena concatenada).

② ṖPrimes

Aunque podría haber hecho la factorización prima simplemente tratando de dividir n por todos los factores en orden, decidí que quería una función de biblioteca que genere números primos. La siguiente función toma un número entero n e implementa el Tamiz de Eratóstenes para generar todos los números primos hasta n . Hace esto como una secuencia perezosa, por lo que generará solo la cantidad de números primos que realmente evalúe.

                                       ╓───╖
                                       ║ Ṗ ║
                                 ╔═══╗ ╙─┬─╜
                                 ║ 0 ║ ┌─┴─╖
                                 ╚═╤═╝ │ ♭ ║
                          ╔═══╗ ┌──┴─╖ ╘═╤═╝
                          ║ 2 ╟─┤ Ṗp ╟───┘
                          ╚═══╝ ╘══╤═╝
    ┌──────────────┐               │
    │              ├─────────────────────────────────────────┐
    │            ┌─┴─╖                                       │
    │          ┌─┤ · ╟────────────────────────────┐   ╓┬───╖ │
    │          │ ╘═╤═╝                            ├───╫┘Ṗp ╟─┤
    │          │   │           ╔═══╗ ┌────╖     ┌─┴─╖ ╙─┬──╜ │
    │          │   │           ║ 1 ╟─┤ >> ╟─────┤ · ╟───┴─┐  │
    │          │   │  ┌───╖    ╚═══╝ ╘══╤═╝     ╘═╤═╝     │  │
    │          │ ┌─┴──┤ ♯ ╟─────┐    ┌──┴─╖ ┌───╖ │       │  │
    │          │ │    ╘═══╝ ┌─┐ │ ┌──┤ Ṗp ╟─┤ ♭ ╟─┴─┐     │  │
    │          │ │          ├─┘ └─┤  ╘══╤═╝ ╘═══╝ ┌─┘     │  │
    │          │ │        ╔═╧═╕ ┌─┴─╖ ┌─┴─╖     ┌─┴─╖     │  │
    │          │ └────────╢   ├─┤ · ╟─┤ ? ╟─────┤ · ╟─┐   │  │
    │          │ ┌───╖    ╚═╤═╛ ╘═╤═╝ ╘═╤═╝     ╘═╤═╝ │   │  │
    │        ┌─┴─┤ ♭ ╟─┐ ┌──┴─╖   │   ┌─┴─╖       │   │   │  │
    │        │   ╘═══╝ └─┤ Ṗp ╟───┘ ┌─┤ ? ╟───────┘   │   │  │
    │ ┌───╖  │  ╔════╗   ╘══╤═╝     │ ╘═╤═╝           │   │  │
  ┌─┴─┤ ÷ ╟──┘  ║ −1 ║   ┌──┴─╖   ╔═╧═╗ │            ┌┴┐  │  │
  │   ╘═╤═╝     ╚══╤═╝ ┌─┤ >> ╟─┐ ║ 0 ║              └┬┘  │  │
  │   ┌─┴─╖ ┌────╖ │   │ ╘════╝ │ ╚═══╝               │   │  │
  │   │ × ╟─┤ << ╟─┘ ┌─┴─┐    ╔═╧═╗                   │   │  │
  │   ╘═╤═╝ ╘══╤═╝  ┌┴┐ ┌┴┐   ║ 1 ╟───────────────────┴─┐ │  │
  └─────┘     ┌┴┐   └┬┘ └┬┘   ╚═══╝                     ├─┘  │
              └┬┘    │   └──────────────────────────────┘    │
             ┌─┴─╖ ┌─┴──╖                                    │
             │ ÷ ╟─┤ << ╟─┐                                  │
             ╘═╤═╝ ╘════╝ ├──────────────────────────────────┘
              ┌┴┐         │
              └┬┘         │
      ╔════╗ ┌─┴──╖       │
      ║ −1 ╟─┤ << ╟───────┘
      ╚════╝ ╘════╝

La función auxiliar Ṗp, toma:

• Un contador en ejecución que sigue disminuyendo hasta llegar a 0.

• El tamiz, que tiene un bit establecido para cada número que ya se sabe que no es primo. Inicialmente, el bit menos significativo representa el número 2, pero lo desplazamos a la derecha con cada iteración.

• Un número n que indica qué número está representado por el bit más bajo del tamiz; esto se incrementa con cada iteración.

En cada iteración, si el bit más bajo del tamiz es 0, hemos encontrado un primo n . Luego usamos la fórmula que ya describí en Rellenar las filas, columnas y diagonales de una cuadrícula NxN para establecer cada n bits -ésimo en el tamiz antes de pasar a la siguiente iteración.

③ ḞFactorización prima

                             ╓───╖
                             ║ Ḟ ║
                             ╙─┬─╜
                       ┌───────┴──────┐
                       │ ┌───╖ ┌────╖ │
                       └─┤ Ṗ ╟─┤ Ḟp ╟─┘
                         ╘═══╝ ╘═╤══╝
                                 │
               ┌────────────────────────────────────────────┐
               │                                     ╓┬───╖ │
       ┌───────┴─┐     ┌───────────────────────┐   ┌─╫┘Ḟp ╟─┘
       │ ╔═══╗ ┌─┴─╖ ┌─┴─╖ ┌───┐ ┌────╖      ┌─┴─╖ │ ╙────╜
       │ ║ 0 ╟─┤   ╟─┤ · ╟─┘┌┐ └─┤ Ḟp ╟──┐ ┌─┤ · ╟─┴──┐
       │ ╚═══╝ └─┬─╜ ╘═╤═╝  └┤   ╘═╤══╝  ├─┘ ╘═╤═╝    │
       │       ┌─┴─┐ ┌─┴─╖ ╔═╧═╕ ┌─┴─╖ ┌─┴─╖ ┌─┴──╖ ┌─┴─╖
       │       │   └─┤ · ╟─╢   ├─┤ ? ╟─┤ · ╟─┤ ÷% ╟─┤ · ╟─┐
       │       │     ╘═╤═╝ ╚═╤═╛ ╘═╤═╝ ╘═╤═╝ ╘═╤══╝ ╘═╤═╝ │
       │       │    ┌──┴─╖   │   ┌─┴─╖ ┌─┴─╖   └──────┘   │
       │       │    │ Ḟp ╟───┘ ┌─┤ ? ╟─┤ ≤ ║              │
       │     ┌─┴─╖  ╘══╤═╝     │ ╘═╤═╝ ╘═╤═╝              │
       └─────┤ · ╟─────┘     ╔═╧═╗ │   ╔═╧═╗              │
             ╘═╤═╝           ║ 0 ║     ║ 2 ║              │
               │             ╚═══╝     ╚═══╝              │
               └──────────────────────────────────────────┘

Esto es bastante sencillo. Simplemente recorra los números primos hasta n y vea cuáles dividen n . Si uno divide n , recuerde continuar con el mismo número primo para que lo devolvamos varias veces si divide n varias veces. Esto devuelve la secuencia vacía para cualquier número menor que 2.

④ ◇ ◆ Genera un diamante

Esta función genera un solo diamante dado un carácter y un radio. Solo usa el personaje para colocarlo en el centro del diamante.

                                   ┌───╖
             ┌─────────────────────┤ ♯ ╟───────────┬─────────┐
             │ ┌───╖ ╔═══╗   ┌───┐ ╘═══╝           │         │
             └─┤ ♫ ╟─╢ 0 ║   │ ┌─┴─╖               │         │
               ╘═╤═╝ ╚═══╝   │ │ ʭ ╟───┐           │         │
               ┌─┴─╖   ┌─────┘ ╘═╤═╝   │           │         │
               │ ɱ ╟───┤ ┌───╖ ┌─┴─╖ ╔═══╗   ╓───╖ │         │
               ╘═╤═╝   └─┤ ɹ ╟─┤ ʓ ╟─╢ 1 ║ ┌─╢ ◇ ╟─┤         │
                 │ ╔═══╗ ╘═══╝ ╘═══╝ ╚═══╝ │ ╙───╜ │         │
                 │ ║ 0 ║                   │     ┌─┴─╖       │
                 │ ╚═╤═╝                   │     │ ♭ ║       │
               ╔═╧═╕ │   ╔════╗            │     ╘═╤═╝       │
           ┌───╢   ├─┘ ┌─╢ 21 ║          ┌─┴─╖   ┌─┴─╖     ┌─┴─┐
           │   ╚═╤═╛   │ ╚════╝ ┌────────┤ · ╟───┤ · ╟─┐ ┌─┴─╖ │
           │   ┌─┴─╖ ┌─┴──╖ ┌───┘        ╘═╤═╝   ╘═╤═╝ ├─┤ = ║ │
           │ ┌─┤ ‼ ╟─┤ >> ║ │              │     ┌─┴─╖ │ ╘═╤═╝ │
           │ │ ╘═══╝ ╘═╤══╝ │              │   ┌─┤ ? ╟─┘   │   │
           │ │   ┌───╖ │ ┌──┘              │   │ ╘═╤═╝     │   │
           │ └─┬─┤ ⇄ ╟─┘ │     ┌─────┐     │   │ ┌─┴─╖     │   │
           │   │ ╘═══╝ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ └─┤ · ╟──┬──┘   │
           │   └───────┤ · ╟─┤ ? ╟─┤ · ╟─┤ ‼ ║   ╘═╤═╝  │      │
           │           ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝   ┌─┴─╖  │      │
           │             └─────┘     └─┬───┘ ┌───┤ … ║  │      │
           │               ┌─────┐     │     │   ╘═╤═╝  │      │
           │            ╔══╧═╗ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ╔═╧══╗ │      │
           │            ║ 32 ║ │ … ╟─┤ ‼ ╟─┤ ‼ ║ ║ 32 ║ │      │
           │            ╚════╝ ╘═╤═╝ ╘═══╝ ╘═╤═╝ ╚════╝ │      │
           │                   ┌─┴─╖       ╔═╧══╗       │      │
           │               ┌───┤ − ╟───┬─┐ ║ 46 ║       │      │
           │             ┌─┴─╖ ╘═══╝   │ │ ╚════╝       │      │
           └─────────────┤ · ╟─────────┘ └──────────────┘      │
                         ╘═╤═╝                                 │
                           └───────────────────────────────────┘

Esto hace un uso intensivo de secuencias perezosas. Así es como funciona:

• Genere la secuencia de enteros de 0 a r (inclusive).

• Para cada número entero α , genere una cadena que consista en espacios ( r - α ) ( …), seguida de un punto, seguido de espacios α , a menos que α = r , en cuyo caso genere un espacio menos y agregue la letra. Ahora tenemos el cuarto superior izquierdo del diamante.

• A cada una de estas cadenas, agregue otra copia de la misma cadena, pero con los caracteres invertidos ( ⇄) y luego el primer carácter eliminado ( >> 21). Ahora tenemos la mitad superior del diamante.

• Tome esta secuencia y agréguele la misma secuencia, pero invertida ( ɹ) y con el primer elemento eliminado ( ʓ). Ahora tenemos todo el diamante.

Ahora tenemos las cuerdas que componen el diamante, pero necesitamos un poco más de información. Necesitamos saber dónde está el centro vertical del diamante. Inicialmente, esto es, por supuesto , r , pero una vez que hayamos agregado otros diamantes a la parte superior e inferior de este, tendremos que realizar un seguimiento de la posición del diamante "central" para que podamos alinear verticalmente las otras pilas de diamantes correctamente. . Lo mismo ocurre con la extensión horizontal del diamante (lo necesita al agregar diamantes a la parte superior e inferior). También decidí hacer un seguimiento de la carta; Lo necesito porque, de lo contrario, la función ⬗(que veremos en la siguiente sección) tendría que tener cuatro parámetros, pero Funciton solo permite tres.

                             ┌─────────────────┐
                             │  ╓───╖          │
                             ├──╢ ◆ ╟──┐       │
                             │  ╙───╜  │       │
                             │   ┌─────┴───┐   │
                           ┌─┴─╖ │ ┌───╖ ┌─┴─╖ │
                         ┌─┤ · ╟─┴─┤ › ╟─┤ › ║ │
                         │ ╘═╤═╝   ╘═╤═╝ ╘═╤═╝ │
                         │ ┌─┴─╖     │   ┌─┴─╖ │
                         │ │ ◇ ╟─────────┤ › ╟─┘
                         │ ╘═╤═╝         ╘═══╝
                         └───┘

Usamos la API de lista ( ›agrega elementos al frente de una lista) para crear una estructura que contiene [ x , y , c , q ], donde x es la coordenada x del centro horizontal del diamante, y es el y- coordenada de la línea de base, c es la letra y q es la secuencia perezosa de cadenas. Esta estructura se utilizará para contener todas las etapas intermedias a partir de ahora.

⑤ ⬗Añadir diamantes verticalmente

Esta función toma una pila de diamantes existente, un radio y un valor booleano que indica si se debe agregar el nuevo diamante a la parte superior (verdadero) o inferior (falso).

                 ┌─────────────────────────────────────────────────┐
               ┌─┴─╖         ┌───────────────────────────┐ ┌───╖ ┌─┴─╖
           ┌───┤ · ╟─────────┘ ╔═══╗ ┌───────────────┐   ├─┤ ‹ ╟─┤ ‹ ║
           │   ╘═╤═╝           ║ 1 ║ │ ╓───╖         │   │ ╘═╤═╝ ╘═╤═╝
           │     │             ╚═╤═╝ └─╢ ⬗ ╟─┐       │ ┌─┴─╖ │   ┌─┴─╖
           │     │ ┌───╖ ┌───╖ ┌─┴──╖  ╙─┬─╜ │       └─┤ · ╟─┘ ┌─┤ ‹ ╟─┐
           │   ┌─┴─┤ + ╟─┤ ♯ ╟─┤ << ║    │   │         ╘═╤═╝   │ ╘═══╝ │
           │   │   ╘═╤═╝ ╘═══╝ ╘═╤══╝    │ ┌─┴─╖         │     │       │
           │   │   ┌─┴─╖         └───────┴─┤ · ╟───┐   ┌─┴─╖   │       │
           │   └───┤ ? ╟─┐                 ╘═╤═╝ ┌─┴───┤ · ╟─┐ │       │
           │       ╘═╤═╝ ├───────────────────┘   │     ╘═╤═╝ │ │       │
           │ ┌───╖ ┌─┴─╖ │               ┌─────┐ │ ┌───╖ │   │ │       │
           └─┤ › ╟─┤ › ║ │       ┌───╖ ┌─┴─╖   │ └─┤ − ╟─┘   │ │       │
             ╘═╤═╝ ╘═╤═╝ │     ┌─┤ ‼ ╟─┤ ‼ ║   │   ╘═╤═╝     │ │       │
               │   ┌─┴─╖ │     │ ╘═╤═╝ ╘═╤═╝ ┌─┴─╖ ┌─┴─╖     │ │       │
               ┌───┤ · ╟─┘     │ ┌─┴─╖   ├───┤ · ╟─┤ … ║     │ │       │
     ┌───┐     │   ╘═╤═╝       └─┤ · ╟───┘   ╘═╤═╝ ╘═╤═╝     │ │       │
     │ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖         ╘═╤═╝         │  ╔══╧═╗     │ │       │
     │ │ ʭ ╟─┤ ? ╟─┤ › ╟─┐ ╔═══╗ ╔═╧═╕         │  ║ 32 ║     │ │       │
     │ ╘═╤═╝ ╘═╤═╝ ╘═══╝ │ ║ 0 ╟─╢   ├─────────┘  ╚════╝     │ │       │
     │ ┌─┘   ┌─┴─╖       │ ╚═══╝ ╚═╤═╛                       │ │       │
     │ └─┬───┤ ʭ ╟─┐   ┌─┴─╖     ┌─┴─╖                       │ │       │
     │ ┌─┴─╖ ╘═══╝ ├───┤ · ╟─────┤ ɱ ║                       │ │       │
     └─┤ · ╟───────┘   ╘═╤═╝     ╘═╤═╝                       │ │       │
       ╘═╤═╝             │       ┌─┴─╖                       │ │       │
         │               └─────┬─┤ ◇ ╟───────────────────────┘ │       │
         │                     │ ╘═══╝                       ┌─┴─╖     │
         │                     └─────────────────────────────┤ · ╟─────┘
         │                                                   ╘═╤═╝
         └─────────────────────────────────────────────────────┘

Esto es bastante sencillo también; utilizar ‹para desempaquetar la estructura; utilizar ◇para generar el nuevo diamante; use ɱ(mapa) para agregar espacios al principio y al final de cada cadena en el nuevo diamante para que todo tenga el mismo ancho; agregar ( ʭ) las nuevas cadenas en la antigua (si es inferior) o la antigua en la nueva (si es superior); y finalmente usar ›para construir la estructura que contiene todos los nuevos valores. En particular, si estamos agregando a la parte inferior, y no cambia, pero si estamos agregando a la parte superior, y debe aumentar en ♯(r << 1)( r es el radio del nuevo diamante).

⑥ ❖Concatenar pilas horizontalmente

Esta es la función más importante de todas. No negaré que fue bastante complicado hacer esto bien. Toma dos pilas y las concatena horizontalmente respetando la alineación vertical correcta.

                           ┌──────────────────────────────────┬───────────────────────┐
                           │     ┌──────────────────┐       ┌─┴─╖                   ┌─┴─╖
                           │     │    ┌───────────┐ └───────┤ · ╟───┬───────────────┤ · ╟─────────────┐
                           │     │  ┌─┴─╖         │         ╘═╤═╝   │               ╘═╤═╝             │
                           │     │  │ ‹ ╟───┐     │         ┌─┴─╖ ┌─┴─╖               │               │
                           │     │  ╘═╤═╝ ┌─┴─╖   └─────────┤ · ╟─┤ · ╟─────────┐     │               │
                           │     │    ├─┐ │ ‹ ╟───┐         ╘═╤═╝ ╘═╤═╝         │     │               │
                           │     │    └─┘ ╘═╤═╝ ┌─┴─╖ ╓───╖ ┌─┴─╖   │           │     │               │
                           │     │          │   │ ‹ ╟─╢ ❖ ╟─┤ ‹ ║   │           │     │               │
                           │     │          │   ╘═╤═╝ ╙───╜ ╘═╤═╝ ┌─┴─╖ ┌─┐     │     │               │
                           │     │          │     │           └───┤ ‹ ║ └─┤     │     │               │
                           │     │          │     │               ╘═╤═╝ ┌─┴─╖   │     │               │
                           │     │          │     │                 └───┤ ‹ ║   │     │               │
                           │     │          │     └─────────────────┐   ╘═╤═╝   │     │               │
                           │     │          │                     ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖             │
                           │     │          │      ┌──────────────┤ · ╟─┤ · ╟─┤ · ╟─┤ · ╟──────┐      │
                           │     │          └──────┤              ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝      │      │
                           │   ┌─┴─╖             ┌─┴─╖            ┌─┴─╖   │     │     │        │      │
                           │ ┌─┤ · ╟─────────────┤ · ╟────────────┤ · ╟───┘     │     │        │      │
                           │ │ ╘═╤═╝             ╘═╤═╝            ╘═╤═╝         │     │        │      │
                           │ │   │                 │         ┌────╖ │         ┌─┴─╖   │        │      │
       ╔═══╗ ┌────╖        │ │   │                 │       ┌─┤ << ╟─┴─────────┤ · ╟─┐ │        │      │
       ║ 1 ╟─┤ << ╟────────┘ │   │                 │       │ ╘═╤══╝           ╘═╤═╝ │ │        │      │
       ╚═══╝ ╘═╤══╝ ╔════╗   │   │               ┌─┴─╖     │ ┌─┴─╖              │   │ │     ┌──┴──┐   │
             ┌─┴─╖  ║ 32 ╟─┐ │   │ ┌─────────────┤ · ╟───┐ │ │ ♯ ║              │   │ │   ┌─┴─╖ ┌─┴─╖ │
             │ ♯ ║  ╚════╝ │ │   └─┤ ┌───╖       ╘═╤═╝   │ │ ╘═╤═╝ ┌───╖ ╔════╗ │   │ │ ┌─┤ ? ╟─┤ < ║ │
             ╘═╤═╝   ┌───╖ │ │     └─┤ − ╟─────────┴─┐   │ │   └───┤ … ╟─╢ 32 ║ │   │ │ │ ╘═╤═╝ ╘═╤═╝ │
               └─────┤ … ╟─┘ │       ╘═╤═╝         ┌─┴─╖ │ └───┐   ╘═╤═╝ ╚════╝ │   │ │ │ ┌─┴─╖   ├───┘
                     ╘═╤═╝   │ ┌───╖ ┌─┴─╖ ┌───────┤ · ╟─┴─┐ ╔═╧═╗ ┌─┴─╖ ┌──────┘   │ │ └─┤ · ╟───┘
                       │   ┌─┴─┤ ʭ ╟─┤ ȶ ║ │ ┌───╖ ╘═╤═╝   │ ║ 1 ║ │ ⁞ ║ │ ┌────────┘ │   ╘═╤═╝
                     ┌─┴─╖ │   ╘═╤═╝ ╘═╤═╝ └─┤ > ╟───┴─┐   │ ╚═══╝ ╘═╤═╝ │ │   ┌──────┘     └────┐
                     │ ⁞ ║ │   ┌─┴─╖ ┌─┴─╖   ╘═╤═╝     │ ┌─┴─╖ ┌───╖ │   │ │ ┌─┴─╖ ┌───╖ ┌───╖ ┌─┴─╖
                     ╘═╤═╝ └───┤ ? ╟─┤ · ╟─────┴─┐     │ │ − ╟─┤ ȶ ╟─┴─┐ │ │ │ + ╟─┤ ♯ ╟─┤ › ╟─┤ › ║
                     ┌─┴─╖     ╘═╤═╝ ╘═╤═╝       │     │ ╘═╤═╝ ╘═╤═╝   │ │ │ ╘═╤═╝ ╘═══╝ ╘═╤═╝ ╘═╤═╝
┌────────────────────┤ · ╟───────┴───┐ └─┐     ┌─┴─╖   └───┘   ┌─┴─╖   │ │ └───┘           │     │
│                    ╘═╤═╝         ┌─┴─╖ │   ┌─┤ · ╟───────────┤ · ╟───┘ │                       │
│ ┌────────────────┐   │   ┌───────┤ · ╟─┘   │ ╘═╤═╝           ╘═╤═╝     │                       │
│ │ ╔════╗ ┌───╖ ┌─┴─╖ └───┤ ┌───╖ ╘═╤═╝     │   │               │     ┌─┴───┐                   │
│ │ ║ 32 ╟─┤ ‼ ╟─┤ · ╟───┐ └─┤ ʭ ╟───┘       │   │             ┌─┴─╖ ┌─┴─╖ ┌─┴─╖                 │
│ │ ╚════╝ ╘═╤═╝ ╘═╤═╝   │   ╘═╤═╝     ┌─────┘   │             │ ʭ ╟─┤ · ╟─┤ ? ╟─┐               │
│ │        ┌─┴─╖ ╔═╧═╕ ╔═╧═╕ ┌─┴─╖   ┌─┴─╖       │             ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ │               │
│ │        │ ‼ ╟─╢   ├─╢   ├─┤ ʑ ╟───┤ ʭ ║     ┌─┴─╖             └─────┘     │   │               │
│ │        ╘═╤═╝ ╚═╤═╛ ╚═╤═╛ ╘═╤═╝   ╘═╤═╝ ┌───┤ · ╟─────────────────────────┘   │               │
│ └──────────┘     │   ╔═╧═╗   │       ├───┘   ╘═╤═╝                             │               │
│                  └───╢ 0 ║ ┌─┴─╖   ┌─┴─╖       └───────────────────────────────┘             ┌─┴─╖ ╔═══╗
│                      ╚═══╝ │ ȶ ╟───┤ · ╟─────────────────────────────────────────────────────┤ › ╟─╢ 0 ║
│                            ╘═╤═╝   ╘═╤═╝                                                     ╘═══╝ ╚═══╝
│                            ┌─┴─╖   ┌─┴─╖
│                      ┌─────┤ ? ╟─┐ │ ɕ ║
│                    ┌─┴─╖   ╘═╤═╝ │ ╘═╤═╝
│            ┌───╖ ┌─┤ < ╟───┬─┘   │   │
└────────────┤ ɕ ╟─┤ ╘═══╝ ┌─┴─╖   │   │
             ╘═══╝ └───────┤ · ╟───┘   │
                           ╘═╤═╝       │
                             └─────────┘

Así es como funciona.

• Primero, para cada pila, genere una secuencia infinita ( ⁞) de cadenas, cada una de las cuales contiene espacios ( …) de acuerdo con el ancho de esa pila.

• Los valores y de las pilas nos dicen cuál necesita "moverse hacia abajo" y en qué medida. Anteponga la secuencia espacial apropiada, truncada ( ȶ) a la longitud correcta ( y1 - y2 o y2 - y1 según corresponda).

• Ahora determine la longitud de cada una de las secuencias de cadenas ( ɕ), que nos dice su altura. Averigua cuál es más alto.

• Agregue las secuencias de espacio infinito a ambas pilas.

• Use zip ( ʑ) para juntarlos. Para cada par de cadenas, concatenelas ( ‼) junto con un espacio adicional en el medio.

• Luego use ȶpara truncar el resultado de eso a la altura más alta. Al hacerlo tan tarde, no tenemos que preocuparnos por cuál de ellos necesita el relleno.

Finalmente, genere la estructura nuevamente. En este punto, ya no necesitamos el carácter en los diamantes, por lo que lo establecemos en 0. El valor de x solo se suma e incrementa (de modo que el ancho de la pila todavía se puede calcular como ♯(x << 1)). El y valor se establece en el más alto de los dos.

⑦ ↯ Iterar sobre caracteres en una cadena

Esta es otra función útil que agregaré a la biblioteca. Dada una cadena, le da una secuencia perezosa que contiene cada código de caracteres.

                                        ╓───╖
                                        ║ ↯ ║
                                        ╙─┬─╜
                           ┌──────────────┴────────────────┐
                           │      ┌─┐          ╔═══╗ ┌───╖ │
                           │      └─┤     ┌────╢ 0 ╟─┤ ≠ ╟─┴─┐
                    ┌──────┴─┐ ┌┐ ╔═╧═╕ ┌─┴─╖  ╚═══╝ ╘═╤═╝   │
                    │        ├─┤├─╢   ├─┤ ? ╟──────────┤     │
                    │        │ └┘ ╚═╤═╛ ╘═╤═╝ ╔════╗ ┌─┴─╖   │
                    │ ╔══════╧══╗ ┌─┴─╖   │   ║ −1 ╟─┤ ≠ ╟───┘
                    │ ║ 2097151 ║ │ ↯ ║       ╚════╝ ╘═══╝
                    │ ╚═════════╝ ╘═╤═╝
                    │             ┌─┴──╖ ╔════╗
                    └─────────────┤ >> ╟─╢ 21 ║
                                  ╘════╝ ╚════╝

andAl insertar una cadena con 2097151 se devuelve el primer carácter. >>ing por 21 lo elimina. Verificamos tanto 0 como -1 por una razón explicada en la página de esolangs ; Esto no es relevante para este desafío, pero quiero que la función de biblioteca sea correcta.

⑧ ⬖Convertir personaje en pila de diamantes

Esta función toma un solo carácter y devuelve la estructura para la pila vertical que representa ese carácter.

                                   ╔════╗
                                   ║ 96 ║  ╓───╖
                                   ╚══╤═╝  ║ ⬖ ║
                        ┌───╖ ┌───╖ ┌─┴─╖  ╙─┬─╜
                    ┌───┤ ɗ ╟─┤ Ḟ ╟─┤ − ║    │
                    │   ╘═╤═╝ ╘═══╝ ╘═╤═╝    │
                    │   ┌─┴─╖         ├──────┘  ┌──┐
                    │   │ ɹ ║         │     ┌───┤  │
                    │   ╘═╤═╝   ┌─────┘     │   │  │
                  ╔═╧═╗ ┌─┴─╖ ┌─┴─╖         │  ┌┴┐ │
                  ║ 1 ╟─┤   ╟─┤ · ╟─────┐ ╔═╧═╕└┬┘ │
                  ╚═══╝ └─┬─╜ ╘═╤═╝   ┌─┴─╢   ├─┘ ┌┴┐
            ┌───────────┐ │     └─┐   │   ╚═╤═╛   └┬┘
          ┌─┴─╖         │ │ ┌───╖ │   └─┐ ╔═╧═╕ ┌──┴─╖ ╔═══╗
    ┌─────┤ · ╟───┐     │ └─┤ ◆ ╟─┘   ┌─┴─╢   ├─┤ << ╟─╢ 1 ║
 ┌──┴─┐   ╘═╤═╝   │     │   ╘═╤═╝     │   ╚═╤═╛ ╘════╝ ╚═╤═╝
 │ ┌──┴─╖ ┌─┴─╖ ╔═╧═╕ ╔═╧═╕ ┌─┴─╖   ┌─┴─╖ ┌─┴─╖        ┌─┴─╖
 │ │ >> ╟─┤ ⬗ ╟─╢   ├─╢   ├─┤ ʩ ╟───┤ · ╟─┤ ʑ ╟────────┤ ⸗ ║
 │ ╘══╤═╝ ╘═╤═╝ ╚═╤═╛ ╚═╤═╛ ╘═╤═╝   ╘═╤═╝ ╘═╤═╝        ╘═╤═╝
 │  ╔═╧═╗  ┌┴┐    │   ╔═╧═╗   │       └─────┘          ╔═╧═╗
 │  ║ 1 ╟─┐└┬┘    └───╢ 0 ║                            ║ 0 ║
 │  ╚═══╝ ├─┘         ╚═══╝                            ╚═══╝
 └────────┘

Esta función es interesante porque necesitábamos que los diamantes se añadieran alternativamente a la parte inferior y superior. Así es como lo hice:

• Primero, reste 96 (entonces se 'a'convierte en 1), obtenga factores primos ( Ḟarriba), use ɗpara agregar el elemento 1 si la secuencia está vacía, y luego invierta ( ɹ) el orden.

• Quite el primer elemento y llame ◆para iniciar la pila.

• Ahora, use ⸗para generar una secuencia perezosa que solo alterna los números 0 y 1 indefinidamente.

• Use ʑ(zip) en eso y en los factores primos restantes. Para cada factor primo, muévelo hacia la izquierda por 1 y orel 0/1 sobre él. Ahora tenemos una secuencia que codifica los números primos y la información superior / inferior.

• Finalmente, use ʩ(doble a la izquierda / agregado). El valor inicial es la pila que generamos desde el primer elemento anterior. Para cada valor ν , llame ⬗(agregue un nuevo diamante) con la pila anterior, el primo ( ν >> 1) y si es superior o inferior ( ν & 1).

⑨ Programa principal

Aquí hacemos el trabajo principal.

                       ┌─────┐
                       │   ┌─┴─╖
                       │   │ ⬖ ║
               ╔═══╗ ╔═╧═╕ ╘═╤═╝
               ║ 0 ╟─╢   ├───┘
               ╚═╤═╝ ╚═╤═╛ ┌───╖ ┌───╖ ╔═══╗
                 └─┐   └───┤ ɱ ╟─┤ ↯ ╟─╢   ║
       ┌─────────┐ └─────┐ ╘═╤═╝ ╘═══╝ ╚═══╝
       │       ┌─┴─╖     │ ┌─┴─╖
       │   ┌───┤ · ╟───┐ └─┤   ╟─┐
       │   │   ╘═╤═╝   │   └─┬─╜ │
       │ ┌─┴─╖ ╔═╧═╕ ╔═╧═╕ ┌─┴─╖ │
       │ │ ❖ ╟─╢   ├─╢   ├─┤ ʩ ╟─┘
       │ ╘═╤═╝ ╚═╤═╛ ╚═╤═╛ ╘═╤═╝
       └───┘   ╔═╧═╗   │   ┌─┴─╖ ┌─┐
               ║ 0 ╟───┘ ┌─┤ ‹ ╟─┴─┘
               ╚═══╝     │ ╘═══╝
                       ┌─┴─╖ ┌─┐
                     ┌─┤ ‹ ╟─┴─┘
                     │ ╘═══╝
      ╔════╗ ┌───╖ ┌─┴─╖ ┌─┐
      ║ 10 ╟─┤ ʝ ╟─┤ ‹ ╟─┴─┘
      ╚════╝ ╘═╤═╝ ╘═══╝
               │

Primero, asigne ( ɱ) sobre los caracteres en la cadena de entrada ( ↯) y convierta cada uno en una pila de diamantes usando ⬖. Quite el primer elemento de eso y doble ( ʩ) sobre el resto para concatenarlos a todos ( ❖). Finalmente, desempaquete la estructura usando ‹para llegar a la secuencia de cadenas y únalas a todas ( ʝ) usando 10 (la nueva línea) como separador.

Salida de ejemplo

Entrada:

crusaders

Salida (tardó 9 segundos en calcularse; no se puede publicar aquí porque el límite de tamaño).