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 :

function visualize() {
  var vin = document.getElementById('visualize-in');
  var vout = document.getElementById('visualize-out');
  var n = Number(vin.value);
  if (n < 0) n = 0;
  var line = '-'.repeat(4 * n + 3);
  var bars = function(k) { return '   |'.repeat(k).substr(2); };
  var img = [line, bars(n), line, bars(n + 1)];
  for (var i = n; i > 0; --i) img.push(bars(i) + '----');
  vout.innerHTML = img.join('\n') + '\n |';
}

<label for="visualize-in">n&nbsp;<input style="width:50px;" type="number" id="visualize-in" name="visualize-in" onchange="visualize()"/></label>
<pre style="background-color: #eff0f1" id="visualize-out"></pre>

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

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.

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>

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

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