Patch de citrouille aléatoire

L'autre jour, je me promenais dans une parcelle de citrouille pour une fête d'anniversaire et j'ai remarqué que les vignes de citrouille faisaient un motif astucieux, avec des tourbillons, des boucles et des ramifications. Nous allons simuler cela ici avec de l'art ASCII.

          (())
            \
   p--q      p-----q
  /    \    /       \
(())    b--d       (())

Règles de construction de la vigne

• Il n'y a qu'une seule vigne principale, composée uniquement de \ / - p q b dpersonnages.
• La vigne ne se déplace que de gauche à droite à travers l'écran. En d'autres termes, supposons que vous étiez une fourmi à partir du caractère de vigne le plus à gauche. Au fur et à mesure que vous progressez vers le caractère adjacent suivant sur la vigne principale, vous devez déplacer une colonne vers la droite - jamais vers la gauche.
• Lorsque la vigne change de direction, l'un des p q b dpersonnages est requis pour simuler une boucle. Les pvignes se joignent au nord-est à l'est, l' qest à sud-est, le bsud-est à l'est et l' dest à nord-est. Notez que la "boucle" de la lettre se connecte à la vigne horizontale, et la "tige" de la lettre se connecte à la diagonale.
• Le début de la vigne doit être l'un des pou b(votre choix, ne doit pas être aléatoire) et commence horizontalement. La fin de la vigne doit être une qou d(votre choix, ne doit pas être aléatoire), et doit se terminer horizontalement.
• Notez que les boucles peuvent être placées immédiatement à côté d'autres boucles (par exemple, pdest une sous-chaîne valide de la vigne), mais cela peut rendre plus difficile le placement des citrouilles plus tard. Vous voudrez peut-être toujours en avoir un - / \immédiatement après une boucle (comme je l'ai fait dans mes exemples), mais ce n'est pas obligatoire.

Règles de la citrouille

• Les citrouilles sont composées uniquement de (())(cette chaîne exacte).
• De la vigne principale, les citrouilles sont attachées par des ramifications. Ces ramifications ne peuvent être attachées qu'aux p q b dboucles, sont précisément une \ou /en longueur, et se fixent à la citrouille de sorte que la "fin" de la ramification soit au milieu.
• Ils peuvent se connecter au-dessus ou en dessous de la vigne principale.
• Les ramifications peuvent se connecter en allant vers la «gauche».
• Une seule citrouille peut être attachée par rejeton, et un seul rejeton par boucle.

Randomness

• Lorsqu'elle se déplace horizontalement, la vigne a 50% de chances de continuer horizontalement, 25% de chances de tourner vers le nord-est et 25% de chances de tourner vers le sud-est.
• Lors d'un déplacement en diagonale, la vigne a 90% de chances de tourner horizontalement et 10% de chances de continuer en diagonale.
• Il doit y avoir suffisamment de tours pour supporter le nombre d'entrée de citrouilles, bien que plus de tours soient autorisés.
• Une fois la vigne construite, les citrouilles peuvent être placées au hasard dans n'importe quel coin qui n'est pas déjà occupé par une citrouille.
• Les citrouilles ne peuvent pas chevaucher la vigne ou d'autres citrouilles.

Le défi

Étant donné un numéro d'entrée, sortez un patch de citrouille aléatoire en suivant les règles ci-dessus. L'exécution du code plusieurs fois avec la même entrée devrait donner des résultats différents. Tous les patchs de citrouille possibles pour un nombre d'entrée donné devraient avoir une chance (pas nécessairement égale) non nulle de se produire.

Contribution

Un entier unique nreprésentant le nombre de citrouilles dans le patch, dans n'importe quel format pratique . Pour la brièveté du code, vous pouvez supposer que l'entrée est 0 < n < 256.

Production

Le patch de citrouille résultant, soit imprimé / affiché à l'écran, soit renvoyé sous forme de chaîne / chaîne de chaînes / etc.

Règles

• Il s'agit de code-golf, donc toutes les règles habituelles pour le golf s'appliquent et le code le plus court (en octets) l'emporte.
• Utilisez notre définition standard de "aléatoire".
• Un programme complet ou une fonction sont acceptables.
• Les failles standard sont interdites.
• Les espaces / sauts de ligne de début et de fin sont tous complètement facultatifs.

Exemples

Pour la saisie n = 3, voici quelques exemples valides d'un patch de citrouille suivant les règles ci-dessus (séparés par des retours à la ligne vides).

          (())
            \
   p--q      p-----q
  /    \    /       \
(())    b--d       (())

(()) (())
  \   /
   b-q (())
      \ /
       b-q

p-----------------------q (())
                       / \ /
                     (()) b-q
                           /
                         (())

Voici quelques exemples INVALIDES d'entrée n = 3, avec des explications #.

    (()) (())
     /    /
p---q----q
 \
(())
# The vine continued horizontally after a loop was placed.

(()(())
  \ /
   p---q
        \
       (())
# The pumpkins are both overlapping and sprouting from the same loop.

p----------------q
 \      \         \
(())   (())      (())
# The pumpkin is attached to the middle of the vine, not at a loop.

Python 2, 819 octets

Prend nen entrée

Place toujours les pumkpins à l'extérieur des coins (au hasard à gauche / à droite)

Pendant que la vigne est construite, des citrouilles sont ajoutées et lorsque suffisamment de citrouilles sont là, la vigne s'arrête.

r=lambda:__import__('random').random()
s=1
v=[s]*4
U=[-9]
D=[-9]
i=input()
while len(U)+len(D)<i+2:s=[[0,1][r()<.9],[[0,2][r()<.5],1][r()<.5],[2,1][r()<.9]][s];exec['',[['','U+=[len(v)]'][U[-1]<len(v)-7],'',['','D+=[len(v)]'][D[-1]<len(v)-7]][v[-1]-s+1]][r()<.8];v+=[s]*[1,2][v[-1]!=s]
v+=[1]*5
m=M=s=0
for i in v:s+=i-1;m=[m,s][m>s];M=[M,s][M<s]
R=[[' ']*(M-m+5)for x in v]
m=-m+2
R[2][m]='p'
for x in range(3,len(v)-3):X=v[x-1];R[x][m]='/d p-b q\\'[v[x]*3+X];m+=v[x]-1
R[-3][m]='q'
M=[len(a)-len(a.lstrip())for a in map(''.join,R)]
R=map(list,zip(*R))
B,L,a='-/U'
K="\\"*4
W="""exec("for p in "+a+"[1:]:x=M[p];b=r()<.5;exec('R[x"+B+"1][p'+['+1]=\\""+L+"\\"','-1]=\\""+K+"\\"'][b]);i=p-[0,3][b];l='(';exec('R[x"+B+"2][i]=l;i+=1;'*2+'l=\\")\\";')*2")"""
exec W+";B,a='+D';L,K=K,L;"+W
for x in R:print''.join(map(str,x))

Exemples:

n=4

                (())   
                 /     
                p---q  
 (())          /       
   \       p--d        
  p-q     /    \       
     \   /    (())     
      b-d              
       \               
      (())             

n=20

                            (())                                                                                             
                              \                                                                                              
                            p--q                                                                                             
                           /    \                                                                                            
                          /      b--q                                                                                        
           (())     p----d      /    \                                                                                       
  (())       \     /          (())    b-q (())                                                                               
    \         p---d                      \  \                                                                                
  p--q       /     \                      b--q                                                                               
      \     /     (())                   /    \                        (())                                           (())   
       b---d                           (())    b-q                       \                                             /     
        \                                         \          (())         p-q                                         p---q  
       (())                                        \           \         /   \                                       /       
                                                    b-----------q     p-d     b-q                            (())p--d        
                                                                 \   /       /   \                            / /    \       
                                                                  b-d      (())   b-q   (())  (())   p-q     p-d    (())     
                                                                   /                 \   /      \   /   \   /                
                                                                 (())                 b-q        p-d     b-d                 
                                                                                       \ \      /         \                  
                                                                                      (())b----d         (())                
                                                                                              /                              
                                                                                            (())