Parche de calabaza aleatorizado

Estaba caminando por un huerto de calabazas el otro día para una fiesta de cumpleaños, y noté que las enredaderas de calabaza formaban un patrón ingenioso, con remolinos, bucles y retoños. Vamos a simular eso aquí con algo de arte ASCII.

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

Reglas de construcción de vid

• Solo hay una vid principal, compuesta únicamente de \ / - p q b dpersonajes.
• La vid solo viaja de izquierda a derecha a través de la pantalla. En otras palabras, supongamos que eres una hormiga que comienza en el personaje de la izquierda. A medida que avanzas al siguiente personaje adyacente en la vid principal, debes mover una columna a la derecha, nunca a la izquierda.
• Cuando la vid cambia de dirección, p q b dse requiere uno de los personajes para simular un bucle. Las pvides se unen viajando de noreste a este, qde este a sureste, bde sureste a este y dde este a noreste. Tenga en cuenta que el "bucle" de la letra se conecta a la vid horizontal, y el "tallo" de la letra se conecta a la diagonal.
• El comienzo de la vid debe ser uno de po b(su elección, no tiene que ser al azar), y comienza horizontalmente. El final de la vid debe ser uno de qo d(su elección, no tiene que ser al azar), y debe terminar horizontalmente.
• Tenga en cuenta que los bucles se pueden colocar inmediatamente adyacentes a otros bucles (por ejemplo, pdes una subcadena válida de la vid), pero eso puede hacer que sea más difícil colocar las calabazas más tarde. Es posible que desee tener uno - / \inmediatamente después de un ciclo (como lo hice en mis ejemplos), pero no es obligatorio.

Reglas de calabaza

• Las calabazas se componen únicamente de (())(esta cadena exacta).
• De la vid principal, las calabazas están unidas por ramas. Estas ramas solo se pueden unir a los p q b dbucles, son exactamente una \o /de longitud y se unen a la calabaza para que el "final" de la rama esté en el medio.
• Se pueden conectar por encima o por debajo de la vid principal.
• Las ramas pueden conectarse yendo a la "izquierda".
• Solo se puede unir una calabaza por rama, y ​​solo una por rama.

Aleatoriedad

• Al viajar horizontalmente, la vid tiene una probabilidad del 50% de continuar horizontalmente, una probabilidad del 25% de girar hacia el noreste y una probabilidad del 25% de girar hacia el sureste.
• Al viajar en diagonal, la vid tiene una probabilidad del 90% de girar horizontalmente y una probabilidad del 10% de continuar en diagonal.
• Debe haber suficientes giros para admitir el número de entrada de calabazas, aunque se permiten más giros.
• Una vez que se construye la vid, las calabazas se pueden colocar al azar en cualquier esquina que no esté ocupada por una calabaza.
• Las calabazas no pueden superponerse a la vid u otras calabazas.

El reto

Dado un número de entrada, envíe un parche de calabaza al azar siguiendo las reglas anteriores. Ejecutar el código varias veces con la misma entrada debería producir resultados diferentes. Todos los parches de calabaza posibles para un número de entrada dado deberían tener alguna probabilidad (no necesariamente igual) de que no sea cero.

Entrada

Un entero entero que nrepresenta el número de calabazas en el parche, en cualquier formato conveniente . Por brevedad del código, puede asumir que la entrada es 0 < n < 256.

Salida

El parche de calabaza resultante, ya sea impreso / mostrado en la pantalla o devuelto como una cadena / string-array / etc.

Reglas

• Este es el código de golf, por lo que se aplican todas las reglas habituales para jugar al golf, y gana el código más corto (en bytes).
• Use nuestra definición estándar de "Aleatorio".
• Un programa completo o una función son aceptables.
• Las lagunas estándar están prohibidas.
• Los espacios en blanco iniciales y finales / nuevas líneas son completamente opcionales.

Ejemplos

Para entrada n = 3, aquí hay algunos ejemplos VÁLIDOS de un parche de calabaza siguiendo las reglas anteriores (separadas por líneas nuevas en blanco).

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

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

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

Aquí hay algunos ejemplos inválidos para entrada n = 3, con explicaciones #.

    (()) (())
     /    /
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 bytes

Toma ncomo entrada

Siempre coloca pumkpins en el 'exterior' de las esquinas (aleatoriamente izquierda / derecha)

Mientras se construye la vid, se agregan calabazas, y cuando hay suficientes calabazas allí, la vid se detiene.

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

Ejemplos:

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         (())                
                                                                                              /                              
                                                                                            (())