Visualize numerais da igreja

9

fundo

Visualização de termos do cálculo λ

O famoso lambda-malabarista (e jogador de código ) John Tromp criou uma visualização interessante dos termos no λ-cálculo. Nas suas palavras:

abstrações (lambdas) são representadas por linhas horizontais, variáveis ​​por linhas verticais que emanam de sua lambda de ligação e aplicativos por links horizontais conectando as variáveis ​​mais à esquerda.

Por exemplo, o termo lambda λf.λx.f (f (f (fx))) corresponde à visualização:

-------------------
 |   |   |   |
-------------------
 |   |   |   |   |
 |   |   |   |----
 |   |   |----
 |   |----
 |----
 |

Leia de cima para baixo:

  • A primeira linha horizontal representa o primeiro λ.
  • As quatro linhas descendentes representam os f s no corpo.
  • Da mesma forma, a segunda linha horizontal representa o segundo λ e a única nova linha que desce dela representa o x no corpo.
  • A linha f mais à direita e a linha x são conectadas por uma linha horizontal que representa um aplicativo (f x) .
  • A próxima aplicação é (f (f x)) , etc.

Numerais da igreja

Os numerais da igreja são uma sequência específica de termos no cálculo λ, assumindo o seguinte padrão:

0 = λf. λx. x
1 = λf. λx. f x
2 = λf. λx. f (f x)
3 = λf. λx. f (f (f x))
...

Tarefa

Dado um número de entrada n , imprima algumas artes ASCII que visualizem o n- ésimo número da Igreja. Por exemplo, o exemplo acima é o resultado desejado quando dado n = 4 . Para n = 0 , imprima:

---

---
 |
 |

Casos de teste

Sua resposta deve gerar exatamente o mesmo texto (novas linhas à direita do módulo) que esse snippet de pilha para todas as entradas inteiras n ≥ 0 :

Isso é , então o código mais curto em bytes vence.

Lynn
fonte
Seu snippet me dá um erro.
Leaky Nun
@LeakyNun qual navegador? Alguns navegadores não suportam .repeat.
Conor O'Brien
São permitidos espaços à direita?
Loovjo 6/06/16
Não, apenas novas linhas à direita. (Este é à la golf anarquia, e eu sinto que é o melhor conjunto de regras para ascii-art desafios.)
Lynn

Respostas:

4

Retina , 74 67 63 bytes

A contagem de bytes assume a codificação ISO 8859-1.

.
 |  
^
$.'$*----¶
\z
¶$` |
+`(.+\|) .+$
$&¶$1----
$
¶ |
  ¶
¶

A entrada é unária , usando qualquer caractere, exceto os feeds de linha como dígito.

Experimente online!

Explicação

.
 |  

Começamos transformando cada dígito unário em | (observe os espaços à direita). Isso nos fornece a segunda linha da saída (mais dois espaços à direita, se a entrada for pelo menos 1).

^
$.'$*----¶

Combinamos o início da string para preceder a primeira linha. Isso é feito usando alguns recursos de substituição específicos da Retina. $*repete o personagem à direita tantas vezes quanto o seu argumento esquerdo. $.'avalia o número de caracteres à direita da partida. Como a correspondência é apenas o começo da sequência, isso fornece quantos -caracteres houver na sequência e ---acrescenta mais três. O é um alias para um avanço de linha. Então agora temos as duas primeiras linhas.

\z
¶$` |

Agora anexamos as próximas duas linhas. Fazemos isso combinando o final da string e anexando um avanço de linha, a string inteira novamente e, em seguida, |para acertar a quarta linha.

+`(.+\|) .+$
$&¶$1----

Hora das aplicações. O líder +faz com que a Retina repita esse estágio até que a saída pare de mudar (nesse caso, porque o regex não corresponde muito). A regex corresponde à última linha inteira, desde que contenha |um espaço a seguir. Capturamos tudo até o |(que será o penúltimo) do grupo 1. Escrevemos a linha de volta com $&, um avanço de linha, depois o grupo 1 (eliminando assim o último |) e depois ----.

$
¶ |

Isso apenas adiciona a linha final contendo apenas uma única |.

  ¶
¶

Finalmente, precisamos nos livrar dos espaços à direita na segunda linha.

Martin Ender
fonte
2

JavaScript (ES6), 112 bytes

f=
n=>`${d=`-`.repeat(n*4+3)}
${(b=` |  `.repeat(n)).slice(0,-2)}
${d}
${b} |
${b.replace(/ \|  /g,`$' |----
`)} |`
;
<input id=i type=number min=0 oninput=o.textContent=f(this.value)>
<pre id=o></pre>

Neil
fonte
Todas as novas linhas são necessárias? Além disso, é f=necessário?
precisa saber é o seguinte
@NoOneIsHere As novas linhas fazem parte da sequência de modelos. A f=não é parte da resposta, ele só é necessário para o trecho, e não é contado como parte do total de bytes.
Neil
2

Python, 201 bytes

from pylab import*
n=input()
p=array(list(' -|\n'))
a=zeros((n+5,n*4+4),int)
for k in range(n):l=4*k+5;a[:-k-1,l]=2;a[-k-2,l-3:l+1]=1
a[:,1]=2
a[1,-3]=0
a[0]=a[2]=1
a[:,-1]=3
print''.join(ravel(p[a]))
user2070206
fonte
1

Python 2, 138 bytes

def f(n,a=1):
 if ~n:b="---\n";c=" |";d="  "+c;print("-"*n*4+b+c*(n>0)+d*(n-1)+"\n"+"-"*n*4+b+c+d*n+"\n")*a+c+d*(n-1)+"-"*4*(n>0);f(n-1,0)

A função contém um parâmetro extra, mas é apenas para uso interno. Ele tem um valor padrão e deve ser omitido ao chamar a função. Espero que isso não viole as regras.

A função desenha as 5 primeiras linhas e depois se chama recursivamente para desenhar as linhas restantes.

Experimente online

Chuck Morris
fonte