Função , não competitiva, 29199 bytes
Eu gostei desse desafio porque destacava a falta dolorida de algumas funções muito úteis da biblioteca. Incluírei todas essas funções aqui (e na contagem de bytes) porque as escrevi após o lançamento deste desafio.
Fonte completa em um único arquivo
Explicação
Como sempre, obtenha uma melhor renderização executando javascript:(function(){$('pre,code').css({lineHeight:5/4});})()no console do navegador.
① ɹ ⇄Reverso
Como você pode ou não saber, o Funciton vem com uma biblioteca cheia de funções para listas , que são valores codificados em um único número inteiro humongoso, além de uma biblioteca separada para sequências avaliadas preguiçosamente , que usam expressões lambda (funções anônimas) em para ser preguiçoso. Claro que também há uma biblioteca para funções de manipulação de strings.
Para esse desafio, eu precisava de uma função para reverter uma string e uma função para reverter uma sequência avaliada preguiçosamente. Surpreendentemente, eu só tinha um para listas - exatamente o que eu não precisava. Então, aqui estão as funções reversas para sequências preguiçosas ( ɹ) e para strings ( ⇄):
╓───╖ ╔════╗ ┌────╖ ╓───╖
║ ɹ ║ ║ 21 ╟─┤ >> ╟──┐ ║ ⇄ ║
╙─┬─╜ ╚════╝ ╘═╤══╝ │ ╙─┬─╜ ┌──┐
┌─────┴─────┐ ┌─┴─╖ ├───────┴────────┤ │
┌─┴─╖ ┌───╖ │ │ ⇄ ║ │ ╔════╗ ┌───╖ │ │
┌─┤ ╟─┤ ɹ ╟─┐ │ ╘═╤═╝ │ ║ −1 ╟─┤ ≠ ╟─┴┐ │
│ └─┬─╜ ╘═══╝ │ │ ┌─┴─╖ ┌─┴─╖ ╚════╝ ╘═╤═╝ │ │
│ │ ┌───╖ │ │ │ ‼ ╟─┤ ? ╟──────────┤ │ │
│ └───┤ ʬ ╟─┘ │ ╘═╤═╝ ╘═╤═╝ ╔═══╗ ┌─┴─╖ │ │
│ ╘═╤═╝ │ ┌─┴─╖ ╔═══╗ ║ 0 ╟─┤ ≠ ╟──┘ │
│ ╔═══╗ ┌─┴─╖ │ ┌─┤ ʃ ╟─╢ 1 ║ ╚═╤═╝ ╘═══╝ │
└─╢ 0 ╟─┤ ? ╟───┘ │ ╘═╤═╝ ╚═══╝ │ │
╚═══╝ ╘═╤═╝ │ └────────────┘ │
│ └─────────────────────────────┘
As sequências preguiçosas usadas ʬ, que são "anexam um elemento ao final de uma sequência preguiçosa". A string usada ʃ(substring) e ‼(concatenada).
② ṖPrimes
Embora eu pudesse ter feito a fatoração primária apenas tentando dividir n por todos os fatores em ordem, decidi que queria uma função de biblioteca que gere números primos. A função a seguir pega um número inteiro n e implementa a Peneira de Eratóstenes para gerar todos os números primos até n . Isso é feito como uma sequência lenta, gerando apenas o número de primos que você avaliar.
╓───╖
║ Ṗ ║
╔═══╗ ╙─┬─╜
║ 0 ║ ┌─┴─╖
╚═╤═╝ │ ♭ ║
╔═══╗ ┌──┴─╖ ╘═╤═╝
║ 2 ╟─┤ Ṗp ╟───┘
╚═══╝ ╘══╤═╝
┌──────────────┐ │
│ ├─────────────────────────────────────────┐
│ ┌─┴─╖ │
│ ┌─┤ · ╟────────────────────────────┐ ╓┬───╖ │
│ │ ╘═╤═╝ ├───╫┘Ṗp ╟─┤
│ │ │ ╔═══╗ ┌────╖ ┌─┴─╖ ╙─┬──╜ │
│ │ │ ║ 1 ╟─┤ >> ╟─────┤ · ╟───┴─┐ │
│ │ │ ┌───╖ ╚═══╝ ╘══╤═╝ ╘═╤═╝ │ │
│ │ ┌─┴──┤ ♯ ╟─────┐ ┌──┴─╖ ┌───╖ │ │ │
│ │ │ ╘═══╝ ┌─┐ │ ┌──┤ Ṗp ╟─┤ ♭ ╟─┴─┐ │ │
│ │ │ ├─┘ └─┤ ╘══╤═╝ ╘═══╝ ┌─┘ │ │
│ │ │ ╔═╧═╕ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ │ │
│ │ └────────╢ ├─┤ · ╟─┤ ? ╟─────┤ · ╟─┐ │ │
│ │ ┌───╖ ╚═╤═╛ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ │ │ │
│ ┌─┴─┤ ♭ ╟─┐ ┌──┴─╖ │ ┌─┴─╖ │ │ │ │
│ │ ╘═══╝ └─┤ Ṗp ╟───┘ ┌─┤ ? ╟───────┘ │ │ │
│ ┌───╖ │ ╔════╗ ╘══╤═╝ │ ╘═╤═╝ │ │ │
┌─┴─┤ ÷ ╟──┘ ║ −1 ║ ┌──┴─╖ ╔═╧═╗ │ ┌┴┐ │ │
│ ╘═╤═╝ ╚══╤═╝ ┌─┤ >> ╟─┐ ║ 0 ║ └┬┘ │ │
│ ┌─┴─╖ ┌────╖ │ │ ╘════╝ │ ╚═══╝ │ │ │
│ │ × ╟─┤ << ╟─┘ ┌─┴─┐ ╔═╧═╗ │ │ │
│ ╘═╤═╝ ╘══╤═╝ ┌┴┐ ┌┴┐ ║ 1 ╟───────────────────┴─┐ │ │
└─────┘ ┌┴┐ └┬┘ └┬┘ ╚═══╝ ├─┘ │
└┬┘ │ └──────────────────────────────┘ │
┌─┴─╖ ┌─┴──╖ │
│ ÷ ╟─┤ << ╟─┐ │
╘═╤═╝ ╘════╝ ├──────────────────────────────────┘
┌┴┐ │
└┬┘ │
╔════╗ ┌─┴──╖ │
║ −1 ╟─┤ << ╟───────┘
╚════╝ ╘════╝
A função auxiliar,, Ṗpassume:
Um contador em execução que continua diminuindo até atingir 0.
A peneira, que possui um bit definido para cada número que já é conhecido como não primo. Inicialmente, o bit menos significativo representa o número 2, mas mudamos esse direito a cada iteração.
Um número n que indica qual número é representado pelo bit mais baixo da peneira; isso é incrementado a cada iteração.
A cada iteração, se o bit mais baixo da peneira for 0, encontramos um n primo . Em seguida, usamos a fórmula que eu já descrevi em Preencher as linhas, colunas e diagonais de uma grade NxN para definir cada n- ésimo bit na peneira antes de passar para a próxima iteração.
③ ḞFatoração primária
╓───╖
║ Ḟ ║
╙─┬─╜
┌───────┴──────┐
│ ┌───╖ ┌────╖ │
└─┤ Ṗ ╟─┤ Ḟp ╟─┘
╘═══╝ ╘═╤══╝
│
┌────────────────────────────────────────────┐
│ ╓┬───╖ │
┌───────┴─┐ ┌───────────────────────┐ ┌─╫┘Ḟp ╟─┘
│ ╔═══╗ ┌─┴─╖ ┌─┴─╖ ┌───┐ ┌────╖ ┌─┴─╖ │ ╙────╜
│ ║ 0 ╟─┤ ╟─┤ · ╟─┘┌┐ └─┤ Ḟp ╟──┐ ┌─┤ · ╟─┴──┐
│ ╚═══╝ └─┬─╜ ╘═╤═╝ └┤ ╘═╤══╝ ├─┘ ╘═╤═╝ │
│ ┌─┴─┐ ┌─┴─╖ ╔═╧═╕ ┌─┴─╖ ┌─┴─╖ ┌─┴──╖ ┌─┴─╖
│ │ └─┤ · ╟─╢ ├─┤ ? ╟─┤ · ╟─┤ ÷% ╟─┤ · ╟─┐
│ │ ╘═╤═╝ ╚═╤═╛ ╘═╤═╝ ╘═╤═╝ ╘═╤══╝ ╘═╤═╝ │
│ │ ┌──┴─╖ │ ┌─┴─╖ ┌─┴─╖ └──────┘ │
│ │ │ Ḟp ╟───┘ ┌─┤ ? ╟─┤ ≤ ║ │
│ ┌─┴─╖ ╘══╤═╝ │ ╘═╤═╝ ╘═╤═╝ │
└─────┤ · ╟─────┘ ╔═╧═╗ │ ╔═╧═╗ │
╘═╤═╝ ║ 0 ║ ║ 2 ║ │
│ ╚═══╝ ╚═══╝ │
└──────────────────────────────────────────┘
Isso é bastante direto. Basta percorrer os primos até n e ver quais dividem n . Se alguém dividir n , lembre-se de continuar com o mesmo primo, para que o retornemos várias vezes se ele dividir n várias vezes. Isso retorna a sequência vazia para qualquer número menor que 2.
④ ◇ ◆Gere um diamante
Esta função gera um único diamante, dado um caractere e um raio. Ele usa apenas o personagem para colocá-lo no centro do diamante.
┌───╖
┌─────────────────────┤ ♯ ╟───────────┬─────────┐
│ ┌───╖ ╔═══╗ ┌───┐ ╘═══╝ │ │
└─┤ ♫ ╟─╢ 0 ║ │ ┌─┴─╖ │ │
╘═╤═╝ ╚═══╝ │ │ ʭ ╟───┐ │ │
┌─┴─╖ ┌─────┘ ╘═╤═╝ │ │ │
│ ɱ ╟───┤ ┌───╖ ┌─┴─╖ ╔═══╗ ╓───╖ │ │
╘═╤═╝ └─┤ ɹ ╟─┤ ʓ ╟─╢ 1 ║ ┌─╢ ◇ ╟─┤ │
│ ╔═══╗ ╘═══╝ ╘═══╝ ╚═══╝ │ ╙───╜ │ │
│ ║ 0 ║ │ ┌─┴─╖ │
│ ╚═╤═╝ │ │ ♭ ║ │
╔═╧═╕ │ ╔════╗ │ ╘═╤═╝ │
┌───╢ ├─┘ ┌─╢ 21 ║ ┌─┴─╖ ┌─┴─╖ ┌─┴─┐
│ ╚═╤═╛ │ ╚════╝ ┌────────┤ · ╟───┤ · ╟─┐ ┌─┴─╖ │
│ ┌─┴─╖ ┌─┴──╖ ┌───┘ ╘═╤═╝ ╘═╤═╝ ├─┤ = ║ │
│ ┌─┤ ‼ ╟─┤ >> ║ │ │ ┌─┴─╖ │ ╘═╤═╝ │
│ │ ╘═══╝ ╘═╤══╝ │ │ ┌─┤ ? ╟─┘ │ │
│ │ ┌───╖ │ ┌──┘ │ │ ╘═╤═╝ │ │
│ └─┬─┤ ⇄ ╟─┘ │ ┌─────┐ │ │ ┌─┴─╖ │ │
│ │ ╘═══╝ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ └─┤ · ╟──┬──┘ │
│ └───────┤ · ╟─┤ ? ╟─┤ · ╟─┤ ‼ ║ ╘═╤═╝ │ │
│ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ┌─┴─╖ │ │
│ └─────┘ └─┬───┘ ┌───┤ … ║ │ │
│ ┌─────┐ │ │ ╘═╤═╝ │ │
│ ╔══╧═╗ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ╔═╧══╗ │ │
│ ║ 32 ║ │ … ╟─┤ ‼ ╟─┤ ‼ ║ ║ 32 ║ │ │
│ ╚════╝ ╘═╤═╝ ╘═══╝ ╘═╤═╝ ╚════╝ │ │
│ ┌─┴─╖ ╔═╧══╗ │ │
│ ┌───┤ − ╟───┬─┐ ║ 46 ║ │ │
│ ┌─┴─╖ ╘═══╝ │ │ ╚════╝ │ │
└─────────────┤ · ╟─────────┘ └──────────────┘ │
╘═╤═╝ │
└───────────────────────────────────┘
Isso faz uso pesado de sequências preguiçosas. Veja como funciona:
Gere a sequência de números inteiros de 0 a r (inclusive).
Para cada um desses inteiros α , gere uma sequência composta por espaços ( r - α ) ( …), seguidos por um ponto, seguidos por espaços α - a menos que α = r , nesse caso gere um espaço a menos e anexe a letra. Agora temos o quarto superior esquerdo do diamante.
Para cada uma dessas cadeias, acrescente outra cópia da mesma cadeia, mas com os caracteres invertidos ( ⇄) e, em seguida, o primeiro caractere removido ( >> 21). Agora temos a metade superior do diamante.
Pegue esta sequência e acrescente a mesma sequência, mas invertida ( ɹ) e com o primeiro elemento removido ( ʓ). Agora temos o diamante inteiro.
Agora temos as cordas que compõem o diamante, mas precisamos de um pouco mais de informação. Precisamos saber onde está o meio vertical do diamante. Inicialmente, é claro que r , mas depois que anexamos outros diamantes na parte superior e inferior, precisaremos acompanhar a posição do diamante "médio" para poder alinhar verticalmente as outras pilhas de diamantes corretamente . O mesmo vale para a extensão horizontal do diamante (é necessário isso ao anexar diamantes na parte superior e inferior). Eu também decidi acompanhar a carta; Eu preciso disso porque, caso contrário, a função ⬗(que abordaremos na próxima seção) teria que ter quatro parâmetros, mas o Funciton permite apenas três.
┌─────────────────┐
│ ╓───╖ │
├──╢ ◆ ╟──┐ │
│ ╙───╜ │ │
│ ┌─────┴───┐ │
┌─┴─╖ │ ┌───╖ ┌─┴─╖ │
┌─┤ · ╟─┴─┤ › ╟─┤ › ║ │
│ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ │
│ ┌─┴─╖ │ ┌─┴─╖ │
│ │ ◇ ╟─────────┤ › ╟─┘
│ ╘═╤═╝ ╘═══╝
└───┘
Usamos a API da lista ( ›adiciona elementos à frente de uma lista) para criar uma estrutura contendo [ x , y , c , q ], em que x é a coordenada x do centro horizontal do diamante, y é o y- coordenada da linha de base, c é a letra e q é a sequência lenta de seqüências de caracteres. Essa estrutura será usada para conter todos os estágios intermediários a partir de agora.
Pend ⬗Anexe diamantes verticalmente
Essa função utiliza uma pilha de diamantes existente, um raio e um booleano indicando se o novo diamante deve ser adicionado ao topo (verdadeiro) ou ao fundo (falso).
┌─────────────────────────────────────────────────┐
┌─┴─╖ ┌───────────────────────────┐ ┌───╖ ┌─┴─╖
┌───┤ · ╟─────────┘ ╔═══╗ ┌───────────────┐ ├─┤ ‹ ╟─┤ ‹ ║
│ ╘═╤═╝ ║ 1 ║ │ ╓───╖ │ │ ╘═╤═╝ ╘═╤═╝
│ │ ╚═╤═╝ └─╢ ⬗ ╟─┐ │ ┌─┴─╖ │ ┌─┴─╖
│ │ ┌───╖ ┌───╖ ┌─┴──╖ ╙─┬─╜ │ └─┤ · ╟─┘ ┌─┤ ‹ ╟─┐
│ ┌─┴─┤ + ╟─┤ ♯ ╟─┤ << ║ │ │ ╘═╤═╝ │ ╘═══╝ │
│ │ ╘═╤═╝ ╘═══╝ ╘═╤══╝ │ ┌─┴─╖ │ │ │
│ │ ┌─┴─╖ └───────┴─┤ · ╟───┐ ┌─┴─╖ │ │
│ └───┤ ? ╟─┐ ╘═╤═╝ ┌─┴───┤ · ╟─┐ │ │
│ ╘═╤═╝ ├───────────────────┘ │ ╘═╤═╝ │ │ │
│ ┌───╖ ┌─┴─╖ │ ┌─────┐ │ ┌───╖ │ │ │ │
└─┤ › ╟─┤ › ║ │ ┌───╖ ┌─┴─╖ │ └─┤ − ╟─┘ │ │ │
╘═╤═╝ ╘═╤═╝ │ ┌─┤ ‼ ╟─┤ ‼ ║ │ ╘═╤═╝ │ │ │
│ ┌─┴─╖ │ │ ╘═╤═╝ ╘═╤═╝ ┌─┴─╖ ┌─┴─╖ │ │ │
┌───┤ · ╟─┘ │ ┌─┴─╖ ├───┤ · ╟─┤ … ║ │ │ │
┌───┐ │ ╘═╤═╝ └─┤ · ╟───┘ ╘═╤═╝ ╘═╤═╝ │ │ │
│ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ╘═╤═╝ │ ╔══╧═╗ │ │ │
│ │ ʭ ╟─┤ ? ╟─┤ › ╟─┐ ╔═══╗ ╔═╧═╕ │ ║ 32 ║ │ │ │
│ ╘═╤═╝ ╘═╤═╝ ╘═══╝ │ ║ 0 ╟─╢ ├─────────┘ ╚════╝ │ │ │
│ ┌─┘ ┌─┴─╖ │ ╚═══╝ ╚═╤═╛ │ │ │
│ └─┬───┤ ʭ ╟─┐ ┌─┴─╖ ┌─┴─╖ │ │ │
│ ┌─┴─╖ ╘═══╝ ├───┤ · ╟─────┤ ɱ ║ │ │ │
└─┤ · ╟───────┘ ╘═╤═╝ ╘═╤═╝ │ │ │
╘═╤═╝ │ ┌─┴─╖ │ │ │
│ └─────┬─┤ ◇ ╟───────────────────────┘ │ │
│ │ ╘═══╝ ┌─┴─╖ │
│ └─────────────────────────────┤ · ╟─────┘
│ ╘═╤═╝
└─────────────────────────────────────────────────────┘
Isso também é bastante direto; use ‹para descompactar a estrutura; use ◇para gerar o novo diamante; use ɱ(map) para adicionar espaços no início e no final de cada string no novo diamante, para que todos tenham a mesma largura; acrescente ( ʭ) as novas strings no antigo (se inferior) ou o antigo no novo (se superior); e finalmente use ›para construir a estrutura que contém todos os novos valores. Em particular, se estamos anexando ao fundo, y não muda, mas se estamos anexando ao topo, y deve aumentar em ♯(r << 1)( r é o raio do novo diamante).
⑥ ❖Concatene pilhas horizontalmente
Esta é a maior função de todas elas. Não vou negar que foi bastante complicado acertar isso. Ele pega duas pilhas e as concatena horizontalmente, respeitando o alinhamento vertical correto.
┌──────────────────────────────────┬───────────────────────┐
│ ┌──────────────────┐ ┌─┴─╖ ┌─┴─╖
│ │ ┌───────────┐ └───────┤ · ╟───┬───────────────┤ · ╟─────────────┐
│ │ ┌─┴─╖ │ ╘═╤═╝ │ ╘═╤═╝ │
│ │ │ ‹ ╟───┐ │ ┌─┴─╖ ┌─┴─╖ │ │
│ │ ╘═╤═╝ ┌─┴─╖ └─────────┤ · ╟─┤ · ╟─────────┐ │ │
│ │ ├─┐ │ ‹ ╟───┐ ╘═╤═╝ ╘═╤═╝ │ │ │
│ │ └─┘ ╘═╤═╝ ┌─┴─╖ ╓───╖ ┌─┴─╖ │ │ │ │
│ │ │ │ ‹ ╟─╢ ❖ ╟─┤ ‹ ║ │ │ │ │
│ │ │ ╘═╤═╝ ╙───╜ ╘═╤═╝ ┌─┴─╖ ┌─┐ │ │ │
│ │ │ │ └───┤ ‹ ║ └─┤ │ │ │
│ │ │ │ ╘═╤═╝ ┌─┴─╖ │ │ │
│ │ │ │ └───┤ ‹ ║ │ │ │
│ │ │ └─────────────────┐ ╘═╤═╝ │ │ │
│ │ │ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ │
│ │ │ ┌──────────────┤ · ╟─┤ · ╟─┤ · ╟─┤ · ╟──────┐ │
│ │ └──────┤ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ │ │
│ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ │ │ │ │ │
│ ┌─┤ · ╟─────────────┤ · ╟────────────┤ · ╟───┘ │ │ │ │
│ │ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ │ │ │ │
│ │ │ │ ┌────╖ │ ┌─┴─╖ │ │ │
╔═══╗ ┌────╖ │ │ │ │ ┌─┤ << ╟─┴─────────┤ · ╟─┐ │ │ │
║ 1 ╟─┤ << ╟────────┘ │ │ │ │ ╘═╤══╝ ╘═╤═╝ │ │ │ │
╚═══╝ ╘═╤══╝ ╔════╗ │ │ ┌─┴─╖ │ ┌─┴─╖ │ │ │ ┌──┴──┐ │
┌─┴─╖ ║ 32 ╟─┐ │ │ ┌─────────────┤ · ╟───┐ │ │ ♯ ║ │ │ │ ┌─┴─╖ ┌─┴─╖ │
│ ♯ ║ ╚════╝ │ │ └─┤ ┌───╖ ╘═╤═╝ │ │ ╘═╤═╝ ┌───╖ ╔════╗ │ │ │ ┌─┤ ? ╟─┤ < ║ │
╘═╤═╝ ┌───╖ │ │ └─┤ − ╟─────────┴─┐ │ │ └───┤ … ╟─╢ 32 ║ │ │ │ │ ╘═╤═╝ ╘═╤═╝ │
└─────┤ … ╟─┘ │ ╘═╤═╝ ┌─┴─╖ │ └───┐ ╘═╤═╝ ╚════╝ │ │ │ │ ┌─┴─╖ ├───┘
╘═╤═╝ │ ┌───╖ ┌─┴─╖ ┌───────┤ · ╟─┴─┐ ╔═╧═╗ ┌─┴─╖ ┌──────┘ │ │ └─┤ · ╟───┘
│ ┌─┴─┤ ʭ ╟─┤ ȶ ║ │ ┌───╖ ╘═╤═╝ │ ║ 1 ║ │ ⁞ ║ │ ┌────────┘ │ ╘═╤═╝
┌─┴─╖ │ ╘═╤═╝ ╘═╤═╝ └─┤ > ╟───┴─┐ │ ╚═══╝ ╘═╤═╝ │ │ ┌──────┘ └────┐
│ ⁞ ║ │ ┌─┴─╖ ┌─┴─╖ ╘═╤═╝ │ ┌─┴─╖ ┌───╖ │ │ │ ┌─┴─╖ ┌───╖ ┌───╖ ┌─┴─╖
╘═╤═╝ └───┤ ? ╟─┤ · ╟─────┴─┐ │ │ − ╟─┤ ȶ ╟─┴─┐ │ │ │ + ╟─┤ ♯ ╟─┤ › ╟─┤ › ║
┌─┴─╖ ╘═╤═╝ ╘═╤═╝ │ │ ╘═╤═╝ ╘═╤═╝ │ │ │ ╘═╤═╝ ╘═══╝ ╘═╤═╝ ╘═╤═╝
┌────────────────────┤ · ╟───────┴───┐ └─┐ ┌─┴─╖ └───┘ ┌─┴─╖ │ │ └───┘ │ │
│ ╘═╤═╝ ┌─┴─╖ │ ┌─┤ · ╟───────────┤ · ╟───┘ │ │
│ ┌────────────────┐ │ ┌───────┤ · ╟─┘ │ ╘═╤═╝ ╘═╤═╝ │ │
│ │ ╔════╗ ┌───╖ ┌─┴─╖ └───┤ ┌───╖ ╘═╤═╝ │ │ │ ┌─┴───┐ │
│ │ ║ 32 ╟─┤ ‼ ╟─┤ · ╟───┐ └─┤ ʭ ╟───┘ │ │ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ │
│ │ ╚════╝ ╘═╤═╝ ╘═╤═╝ │ ╘═╤═╝ ┌─────┘ │ │ ʭ ╟─┤ · ╟─┤ ? ╟─┐ │
│ │ ┌─┴─╖ ╔═╧═╕ ╔═╧═╕ ┌─┴─╖ ┌─┴─╖ │ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ │ │
│ │ │ ‼ ╟─╢ ├─╢ ├─┤ ʑ ╟───┤ ʭ ║ ┌─┴─╖ └─────┘ │ │ │
│ │ ╘═╤═╝ ╚═╤═╛ ╚═╤═╛ ╘═╤═╝ ╘═╤═╝ ┌───┤ · ╟─────────────────────────┘ │ │
│ └──────────┘ │ ╔═╧═╗ │ ├───┘ ╘═╤═╝ │ │
│ └───╢ 0 ║ ┌─┴─╖ ┌─┴─╖ └───────────────────────────────┘ ┌─┴─╖ ╔═══╗
│ ╚═══╝ │ ȶ ╟───┤ · ╟─────────────────────────────────────────────────────┤ › ╟─╢ 0 ║
│ ╘═╤═╝ ╘═╤═╝ ╘═══╝ ╚═══╝
│ ┌─┴─╖ ┌─┴─╖
│ ┌─────┤ ? ╟─┐ │ ɕ ║
│ ┌─┴─╖ ╘═╤═╝ │ ╘═╤═╝
│ ┌───╖ ┌─┤ < ╟───┬─┘ │ │
└────────────┤ ɕ ╟─┤ ╘═══╝ ┌─┴─╖ │ │
╘═══╝ └───────┤ · ╟───┘ │
╘═╤═╝ │
└─────────┘
Aqui está como isso funciona.
Primeiro, para cada pilha, gere uma sequência infinita ( ⁞) de cadeias, cada uma contendo espaços ( …) de acordo com a largura dessa pilha.
Os valores y das pilhas nos dizem qual deles precisa "descer" e quanto. Anexe a sequência espacial apropriada, truncada ( ȶ) no comprimento certo ( y1 - y2 ou y2 - y1, conforme apropriado).
Agora determine o comprimento de cada uma das seqüências de strings ( ɕ), o que nos indica sua altura. Descubra qual é o mais alto.
Anexe as seqüências de espaço infinito às duas pilhas.
Use zip ( ʑ) para juntá-los. Para cada par de cadeias, concatene-as ( ‼) junto com um espaço extra no meio.
Em seguida, use ȶpara truncar o resultado disso para a altura mais alta. Ao fazer isso tarde, não precisamos nos preocupar com qual deles precisa do preenchimento.
Por fim, gere a estrutura novamente. Nesse ponto, não precisamos mais do caractere nos diamantes, portanto, definimos como 0. O valor x é apenas somado e incrementado (para que a largura da pilha ainda possa ser calculada como ♯(x << 1)). O valor y é definido como o mais alto dos dois.
⑦ ↯iterar caracteres em uma string
Esta é outra função útil que adicionarei à biblioteca. Dada uma sequência, ela fornece uma sequência lenta que contém cada código de caractere.
╓───╖
║ ↯ ║
╙─┬─╜
┌──────────────┴────────────────┐
│ ┌─┐ ╔═══╗ ┌───╖ │
│ └─┤ ┌────╢ 0 ╟─┤ ≠ ╟─┴─┐
┌──────┴─┐ ┌┐ ╔═╧═╕ ┌─┴─╖ ╚═══╝ ╘═╤═╝ │
│ ├─┤├─╢ ├─┤ ? ╟──────────┤ │
│ │ └┘ ╚═╤═╛ ╘═╤═╝ ╔════╗ ┌─┴─╖ │
│ ╔══════╧══╗ ┌─┴─╖ │ ║ −1 ╟─┤ ≠ ╟───┘
│ ║ 2097151 ║ │ ↯ ║ ╚════╝ ╘═══╝
│ ╚═════════╝ ╘═╤═╝
│ ┌─┴──╖ ╔════╗
└─────────────┤ >> ╟─╢ 21 ║
╘════╝ ╚════╝
anduma sequência de caracteres com 2097151 retorna o primeiro caractere. >>21 por removê-lo. Verificamos ambos 0 e -1 por uma razão explicada na página esolangs ; isso não é relevante para esse desafio, mas quero que a função de biblioteca esteja correta.
⑧ ⬖Converter caractere em diamante
Essa função usa um único caractere e retorna a estrutura para a pilha vertical que representa esse caractere.
╔════╗
║ 96 ║ ╓───╖
╚══╤═╝ ║ ⬖ ║
┌───╖ ┌───╖ ┌─┴─╖ ╙─┬─╜
┌───┤ ɗ ╟─┤ Ḟ ╟─┤ − ║ │
│ ╘═╤═╝ ╘═══╝ ╘═╤═╝ │
│ ┌─┴─╖ ├──────┘ ┌──┐
│ │ ɹ ║ │ ┌───┤ │
│ ╘═╤═╝ ┌─────┘ │ │ │
╔═╧═╗ ┌─┴─╖ ┌─┴─╖ │ ┌┴┐ │
║ 1 ╟─┤ ╟─┤ · ╟─────┐ ╔═╧═╕└┬┘ │
╚═══╝ └─┬─╜ ╘═╤═╝ ┌─┴─╢ ├─┘ ┌┴┐
┌───────────┐ │ └─┐ │ ╚═╤═╛ └┬┘
┌─┴─╖ │ │ ┌───╖ │ └─┐ ╔═╧═╕ ┌──┴─╖ ╔═══╗
┌─────┤ · ╟───┐ │ └─┤ ◆ ╟─┘ ┌─┴─╢ ├─┤ << ╟─╢ 1 ║
┌──┴─┐ ╘═╤═╝ │ │ ╘═╤═╝ │ ╚═╤═╛ ╘════╝ ╚═╤═╝
│ ┌──┴─╖ ┌─┴─╖ ╔═╧═╕ ╔═╧═╕ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖
│ │ >> ╟─┤ ⬗ ╟─╢ ├─╢ ├─┤ ʩ ╟───┤ · ╟─┤ ʑ ╟────────┤ ⸗ ║
│ ╘══╤═╝ ╘═╤═╝ ╚═╤═╛ ╚═╤═╛ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝
│ ╔═╧═╗ ┌┴┐ │ ╔═╧═╗ │ └─────┘ ╔═╧═╗
│ ║ 1 ╟─┐└┬┘ └───╢ 0 ║ ║ 0 ║
│ ╚═══╝ ├─┘ ╚═══╝ ╚═══╝
└────────┘
Essa função é interessante porque precisávamos que os diamantes fossem anexados alternadamente ao fundo e ao topo. Aqui está como eu fiz isso:
Primeiro, subtraia 96 (assim 'a'se torna 1), obtenha os fatores primos ( Ḟacima), use ɗpara adicionar o elemento 1 se a sequência estiver vazia e depois inverta ( ɹ) a ordem.
Retire o primeiro elemento e ligue ◆para iniciar a pilha.
Agora, use ⸗para gerar uma sequência lenta que apenas alterna os números 0 e 1 indefinidamente.
Use ʑ(zip) nisso e nos demais fatores primos. Para cada fator primo, mova-o para a esquerda por 1 e oro 0/1 para ele. Agora temos uma sequência que codifica os números primos e as informações superior / inferior.
Por fim, use ʩ(dobre à esquerda / agregado). O valor inicial é a pilha que geramos a partir do primeiro elemento acima. Para cada valor ν , chame ⬗(acrescente um novo diamante) com a pilha anterior, a prime ( ν >> 1) e se superior ou inferior ( ν & 1).
⑨ Programa principal
Aqui nós fazemos o trabalho principal.
┌─────┐
│ ┌─┴─╖
│ │ ⬖ ║
╔═══╗ ╔═╧═╕ ╘═╤═╝
║ 0 ╟─╢ ├───┘
╚═╤═╝ ╚═╤═╛ ┌───╖ ┌───╖ ╔═══╗
└─┐ └───┤ ɱ ╟─┤ ↯ ╟─╢ ║
┌─────────┐ └─────┐ ╘═╤═╝ ╘═══╝ ╚═══╝
│ ┌─┴─╖ │ ┌─┴─╖
│ ┌───┤ · ╟───┐ └─┤ ╟─┐
│ │ ╘═╤═╝ │ └─┬─╜ │
│ ┌─┴─╖ ╔═╧═╕ ╔═╧═╕ ┌─┴─╖ │
│ │ ❖ ╟─╢ ├─╢ ├─┤ ʩ ╟─┘
│ ╘═╤═╝ ╚═╤═╛ ╚═╤═╛ ╘═╤═╝
└───┘ ╔═╧═╗ │ ┌─┴─╖ ┌─┐
║ 0 ╟───┘ ┌─┤ ‹ ╟─┴─┘
╚═══╝ │ ╘═══╝
┌─┴─╖ ┌─┐
┌─┤ ‹ ╟─┴─┘
│ ╘═══╝
╔════╗ ┌───╖ ┌─┴─╖ ┌─┐
║ 10 ╟─┤ ʝ ╟─┤ ‹ ╟─┴─┘
╚════╝ ╘═╤═╝ ╘═══╝
│
Primeiro, mapeie ( ɱ) sobre os caracteres na sequência de entrada ( ↯) e transforme cada um em uma pilha de diamantes usando ⬖. Retire o primeiro elemento e dobre ( ʩ) sobre o resto para concatená-los todos ( ❖). Por fim, descompacte a estrutura usando ‹para chegar à sequência de strings e junte todas elas ( ʝ) usando 10 (a nova linha) como separador.
Saída de exemplo
Entrada:
crusaders
Saída (demorou 9 segundos para calcular; não é possível postar aqui porque o limite de tamanho).