Défi

Inspirés par ce défi et le méchant ouragan Matthew , nous allons générer dynamiquement des éclairs.

n = 15:

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

Contribution

Entier positif ndétermine la profondeur de la foudre.

Règles et contraintes

• /et \doit être utilisé
• La probabilité guidant la direction de la foudre est la suivante:

  • 25% se divise en 2 chemins
  • 25% Le chemin atteint l'impasse
  • 25% va à gauche
  • 25% va bien
  • Il y a quelques exceptions concernant le chevauchement et l'impasse ci-dessous:

• Le code ne doit pas être déterministe, un nouvel éclair doit être généré aléatoirement à chaque fois
• Les boulons ne doivent pas se chevaucher: par exemple, s'il y a déjà un boulon à gauche du boulon actuel, le boulon actuel doit soit se terminer, soit aller à droite, mais pas aller à gauche ou se scinder (la probabilité s'applique toujours, dans ce cas, il devient 50% fin / 50% à droite)
• S'il n'existe pas un autre chemin de partage disponible, le chemin ne doit pas se terminer: par exemple au début quand il n'y a qu'un seul chemin, le chemin ne doit pas se terminer jusqu'à ce qu'il se divise, s'applique également lorsqu'il y a plusieurs chemins mais tous sauf un chemin sont morts , (la probabilité devient 33% divisée / 33% gauche / 33% droite) votre objectif est d'atteindre le bas
• Des espaces peuvent être ajoutés sur la gauche (tout ce dont vous avez besoin ne devrait être que de la hauteur-1)
• Cependant, vous voulez générer le boulon qui vous appartient, vous pouvez aller de bas en haut, de gauche à droite, etc. Tant que toutes les règles ci-dessus sont satisfaites

Un autre exemple

n = 10

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

Restez en sécurité et amusez-vous au golf! Veuillez jouer au golf de manière responsable uniquement lorsque vous êtes dans une zone sûre !!

Perl, 92 90 89 84 octets

Comprend +1 pour -n

Donnez de la hauteur sur STDIN:

perl -M5.010 bolt.pl <<< 15

bolt.pl:

#!/usr/bin/perl -n
map{$_=$;until$;=$_,s/.6|3.?/53|16*rand/eg,/3|6/>/36/;say y|3615|\\/ |r}(1x$_.6)x$_

Explication

Si vous appelez le décalage du point de départ 0 (un point est au coin d'une case de caractère), alors sur la ligne suivante, vous pouvez être allé à gauche ou à droite (ou non) et vous pouvez vous retrouver avec des points sur les décalages -1,1. La ligne suivante donne -2,0,2les décalages possibles, etc. Ils diffèrent tous par 2. Si vous appelez ensuite le caractère en bas à gauche d'un point pair et le caractère en bas à droite impair, vous pouvez étendre cela à l'attribution de pair ou impair à chaque position de caractère sur une rangée telle que l'alternance paire et impaire (en fait, tout l'avion est carrelé en damier). Une position paire peut avoir un /ou , une position impaire peut avoir un \ou .

Le caractère juste avant a /est dans une position étrange, il pourrait donc être soit \ou , mais \/est interdit, donc seul est possible. De même, le caractère après a \ doit être un (en supposant que la ligne est remplie avec suffisamment d'espaces à gauche et à droite pour que les limites de ligne ne soient pas un problème). Ainsi, un éclair continue sur la ligne suivante toujours directement en dessous de a \ou en dessous de a /. Dans les deux cas , le point le plus bas se trouve au milieu et la rangée suivante peut avoir l' une , /, \ou /\directement en dessous du sommet 2 caractères. Donc, pour générer la ligne suivante, je peux simplement remplacer tout \ou/par l'une de ces 4 extensions avec une probabilité égale (vous pouvez également remplacer indépendamment le premier caractère par ou /et le deuxième caractère par ou \). En perl, vous pouvez le faire avec quelque chose comme:

s#\\ | /#("  "," \\","/ ","/\\")[rand 4]#eg

Si la ligne résultante contient cependant \/(interdit rejoindre) ou non /ou \à tous (dies de boulons et ne parvient pas à fond) , le résultat est invalide. Dans ce cas, je jette toute la rangée et j'essaye simplement à nouveau. Une continuation valide existe toujours et si vous essayez assez souvent, une sera trouvée (par exemple, tout meurt à l'exception d'un flux). Il s'agit d'une distribution de probabilité légèrement différente de l'algorithme anti-chevauchement suggéré, mais je pense que c'est en fait mieux car il n'a pas de biais directionnel. La validité peut être testée de manière golfique en utilisant

m#\\|/#>m#\\/#

Le problème ici est que la substitution aléatoire est tellement looooong et que toutes ces \échappées mangent aussi des octets. J'ai donc décidé de créer mes lignes à l'aide de chaînes de chiffres et de remplacer les chiffres appropriés par , /et \juste avant l'impression. Le remplacement aléatoire de base est

53|16*rand

ce qui donne un de 53, 55, 61ou 63avec une probabilité égale. J'interprète ensuite 5et 1comme , 3comme \et 6comme /. Cela explique l'impression de la ligne:

say y|3615|\\/ |r

Dans une compétition de golf sérieuse, je commencerais maintenant à explorer systématiquement des formules magiques alternatives, mais cela devrait être assez bon (dans les 3 octets optimaux)

Le reste des composantes du programme:

1x$_.6

Cela initialise $_(voir la carte suivante) les espaces de hauteur suivis de a /. Il s'agit d'une ligne invisible au-dessus de la première en cours d'impression et garantit que le champ est suffisamment large pour que le boulon ne puisse jamais manquer d'espace à gauche

map{ ... ; say ...}(1x$_.6)x$_

Je vais traiter cette même hauteur initiale de chaîne en imprimant une nouvelle ligne à chaque fois

$_=$;until$;=$_,...

Enregistrez la ligne actuelle dans $;. Si le remplacement s'avère invalide, restaurez $_depuis$;

s/.6|3.?/53|16*rand/eg

Faites la substitution réelle. Je n'ai pas à vérifier ce qui est avant /ou après \car ce doit être un espace. Ceci est pratique car l'espace peut être représenté par 1ou 5. Étant donné que j'ai seulement rempli la chaîne à gauche, l'espace après le \peut encore être absent, alors rendez ce caractère facultatif

/3|6/>/36/

Vérifiez si la nouvelle ligne est valide

JavaScript (ES6), 154 octets

f=(n,r=[],s=" ".repeat(n)+"/",t=s.replace(/ \/|\\ |\\$/g,_=>"  /  \\/\\".substr(Math.random()*8&6,2)))=>n?/^ +$|\\\//.test(t)?f(n,r,s):f(n-1,[...r,t],t):r

<input type="number" min=1 oninput=o.textContent=f(this.value).join`\n`><pre id=o>

J'ai eu du mal avec l'implémentation jusqu'à ce que je voie la réponse de @ TonHospel, à quel point elle a simplement dégénéré en port. Exemple de sortie:

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