Contexte

Visualisation des termes λ-calcul

Le célèbre jongleur lambda (et golfeur de code ) John Tromp a imaginé une visualisation intéressante des termes du λ-calcul. Dans ses mots:

les abstractions (lambdas) sont représentées par des lignes horizontales, les variables par des lignes verticales émanant de leur lambda de liaison et les applications par des liens horizontaux reliant les variables les plus à gauche.

Par exemple, le terme lambda λf.λx.f (f (f (fx))) correspond à la visualisation:

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

Lisez-le de haut en bas:

• La première ligne horizontale représente le premier λ.
• Les quatre lignes qui en descendent représentent les f s dans le corps.
• De même, la deuxième ligne horizontale représente le deuxième λ, et la seule nouvelle ligne en descendant représente le x dans le corps.
• La ligne f la plus à droite et la ligne x sont reliées par une ligne horizontale représentant une application (f x) .
• L'application suivante est (f (f x)) , et cetera.

Chiffres d'église

Les chiffres de l'Église sont une séquence spécifique de termes dans le λ-calcul, prenant le modèle suivant:

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

Tâche

Étant donné un numéro d'entrée n , imprimez un art ASCII qui visualise le n e chiffre de l'Église. Par exemple, l'exemple ci-dessus est votre sortie cible lorsque n = 4 . Pour n = 0 , imprimez:

---

---
 |
 |

Cas de test

Votre réponse doit générer exactement le même texte (sauts de ligne modulo) que cet extrait de pile pour toutes les entrées entières 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>

Il s'agit de code-golf , donc le code le plus court en octets l'emporte.

Rétine , 74 67 63 octets

Le nombre d'octets suppose un codage ISO 8859-1.

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

L'entrée est unaire , en utilisant n'importe quel caractère à l'exception des sauts de ligne comme chiffre.

Essayez-le en ligne!

Explication

.
 |  

Nous commençons par transformer chaque chiffre unaire en | (notez les espaces de fin). Cela nous donne la deuxième ligne de la sortie (plus deux espaces de fin si l'entrée est au moins 1).

^
$.'$*----¶

Nous faisons correspondre le début de la chaîne afin d'ajouter la première ligne. Cela se fait à l'aide de certaines fonctionnalités de substitution spécifiques à Retina. $*répète le personnage de droite autant de fois que son argument gauche. $.'évalue le nombre de caractères à droite de la correspondance. Comme la correspondance n'est que le début de la chaîne, cela donne autant -de caractères que la chaîne et en ---ajoute trois de plus. Le ¶est un alias pour un saut de ligne. Alors maintenant, nous avons les deux premières lignes.

\z
¶$` |

Maintenant, nous ajoutons les deux lignes suivantes. Nous faisons cela en faisant correspondre la fin de la chaîne et en ajoutant un saut de ligne, la chaîne entière à nouveau, puis |pour obtenir la quatrième ligne à droite.

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

Temps pour les candidatures. Le début +fait que Retina répète cette étape jusqu'à ce que la sortie cesse de changer (dans ce cas parce que l'expression régulière ne correspond plus). L'expression régulière correspond à la dernière ligne entière, à condition qu'elle contienne un |suivi par un espace. Nous capturons tout jusqu'au |(qui sera l'avant-dernier) en groupe 1. Nous écrivons la ligne avec $&un saut de ligne, puis le groupe 1 (supprimant ainsi le dernier |), puis ----.

$
¶ |

Cela ajoute simplement la dernière ligne contenant un seul |.

  ¶
¶

Enfin, nous devons nous débarrasser des espaces de fin sur la deuxième ligne.

JavaScript (ES6), 112 octets

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 octets

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 octets

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)

La fonction contient un paramètre supplémentaire, mais elle est réservée à un usage interne. Il a une valeur par défaut et doit être omis lors de l'appel de la fonction. J'espère que cela ne viole pas les règles.

La fonction dessine les 5 premières lignes, puis s'appelle récursivement pour dessiner les lignes restantes.

Essayez-le en ligne