Écrivez un programme ou une fonction qui prend un entier positif N (via stdin / ligne de commande / fonction arg) et imprime ou retourne une représentation sous forme de chaîne d'une marche aléatoire bidimensionnelle de N pas de longueur, tirée de barres obliques: / \(plus les espaces et nouvelles lignes pour l'espacement).

Une marche aléatoire 2D commence à l'origine d'un réseau entier infini . Puis N fois de façon répétée, une direction cardinale (haut, bas, gauche, droite) est choisie uniformément au hasard et le promeneur se déplace d'une unité dans cette direction. Le chemin résultant est la marche aléatoire.

Voici une marche aléatoire pour N = 6. Notez qu'il revient sur lui-même lorsqu'il atteint (-1, 3).

Pour dessiner cela avec des barres obliques, nous devons essentiellement faire pivoter le tout à 45 ° dans le sens horaire. Les axes et les points de début et de fin ne sont pas dessinés dans la version barre oblique.

/
\
 \
 /\

Une marche plus complexe comme celle-ci (N = 20, bien qu'il n'y ait aucun moyen de le dire):

Deviendrait ceci:

     /
/\/ /\
\/\/
/\/
\/

Votre programme doit générer ce type de versions slash de promenades aléatoires. Vous devez choisir au hasard chaque nouvelle direction prise par la marche, de sorte que chaque exécution du programme pour un certain N produira presque certainement une marche différente. (La pseudo-aléatoire est très bien.)

Il ne doit jamais y avoir de lignes vides au-dessus ou en dessous des barres obliques les plus basses et les plus élevées (à l'exception d'une nouvelle ligne de fin facultative), et il ne doit jamais y avoir de colonnes d'espaces vides avant ou après les barres obliques les plus à gauche et à droite.

Donc pour N = 1, la sortie est toujours /ou \, mais jamais quelque chose comme:

   
 / 

Les espaces de fin sont autorisés tant qu'ils ne dépassent pas la colonne de la barre oblique la plus à droite.

La soumission avec le moins d'octets est gagnante. Voici un compteur d'octets pratique.

Pyth, 74 octets

K0VQJO2=GO2 XH,-ZJ-KG@"\/"xJG-=ZtyJ-=KtyG;=YmrhSdheSdCHjbclhYsmh@XkH\ k.xY

Une traduction encore plus optimisée de la réponse d'Uri Zarfaty.

Python 2, 300 285 257 246 236 octets

Quelque chose pour lancer les choses. Il devrait être possible de réduire davantage cette baisse. Merci @Maltysen d'avoir rasé 10 octets.

from random import*
N=input()
x=y=0;G={}
exec'n=randrange(4);l=n<2;u=n&1;G[(x-l,y-u)]="\\/"[l^u];x-=2*l-1;y-=2*u-1;'*N
f=lambda i:range(min(x[i]for x in G),max(x[i]for x in G)+1)
for i in f(0):print"".join(G.get((i,j)," ")for j in f(1))

Génère la sortie de marche dans un dictionnaire G de tuples (x, y) visités, mettant à jour notre emplacement au fur et à mesure. Chaque étape aléatoire n est à la fois u / d (u) et l / r (l).

PHP 5.5 - 209 octets

<?for(;$X[]=$x+=1-2*$l,$Y[]=$y+=1-2*$u,$i++<$argv[1];){$m[$y-$u=$n&1][$x-$l=($n=rand(0,3))<2]='\\/'[$u^$l];}for($y=min($Y);$y<max($Y);$y++){for($x=min($X);$x<max($X);$x++)$s.=$m[$y][$x]?:' ';$s.="\n";}echo$s;

Non golfé:

<?
for (; $X[] = $x += 1 - 2 * $l, $Y[] = $y += 1 - 2 * $u, $i++ < $argv[1];) {
    $m[$y - $u = $n & 1][$x - $l = ($n = rand(0, 3)) < 2] = '\\/'[$u ^ $l];
}
for ($y = min($Y); $y < max($Y); $y++) {
    for ($x = min($X); $x < max($X); $x++) {
        $s .= $m[$y][$x] ? : ' ';
    }
    $s .= "\n";
}
echo $s;

J'ai commencé à travailler sur une réponse PHP à partir de zéro, mais le code final ressemblait trop au travail de @Uri Zarfaty, donc je n'ai vraiment pas eu le culot de le poster. J'ai fini par porter cette réponse avec quelques modifications à la place. Pousse les valeurs x / y $Xet les $Ytableaux pour déterminer min / max dans la boucle de sortie.

Usage:

php golf.php 200

Pyth - 89

Il s'agit essentiellement d'une traduction de la réponse d'Uri Zarfaty, bien que j'aie fait quelques optimisations.

KZVQJO4=G<J2=b.&J1 XH,-KG-Zb@"\\/".|Gb-=KtyG-=Ztyb)LrhSm@dbHheSm@kbHFNy0jkm?@H,Nb},NbHdy1

Explication à venir.

Essayez-le ici .