Remendo aleatório da abóbora

Eu estava andando por um canteiro de abóboras no outro dia para uma festa de aniversário e notei as videiras de abóboras fazendo um padrão bacana, com giros, loops e ramificações. Vamos simular isso aqui com alguma arte ASCII.

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

Regras de construção do Vine

• Existe apenas uma videira principal, composta apenas por \ / - p q b dcaracteres.
• A videira viaja apenas da esquerda para a direita na tela. Em outras palavras, suponha que você fosse uma formiga começando com o caráter de videira mais à esquerda. À medida que avança para o próximo caractere adjacente na videira principal, você deve mover uma coluna para a direita - nunca para a esquerda.
• Quando a videira muda de direção, um dos p q b dcaracteres é necessário para simular um loop. As pjunções de videiras viajam de nordeste a leste, qde leste a sudeste, bde sudeste a leste e dde leste a nordeste. Observe que o "loop" da letra se conecta à videira horizontal e o "tronco" da letra se conecta à diagonal.
• O início da videira deve ser um de pou b(sua escolha, não precisa ser aleatório) e começa na horizontal. O final da videira deve ser um de qou d(sua escolha, não precisa ser aleatório) e deve terminar horizontalmente.
• Observe que os loops podem ser colocados imediatamente adjacentes a outros loops (por exemplo, pdé um substring válido da videira), mas isso pode dificultar a colocação posterior das abóboras. Você pode querer sempre ter um - / \imediatamente após um loop (como eu fiz nos meus exemplos), mas não é necessário.

Regras de abóbora

• As abóboras são compostas apenas por (())(essa seqüência exata).
• A partir da videira principal, as abóboras são anexadas por ramificações. Essas ramificações só podem ser conectadas às p q b dalças, têm precisamente uma \ou mais /de comprimento e são presas à abóbora, de modo que o "final" da ramificação esteja no meio.
• Eles podem se conectar acima ou abaixo da videira principal.
• As ramificações podem se conectar indo para a "esquerda".
• Apenas uma abóbora pode ser anexada por ramificação e apenas uma ramificação por loop.

Aleatoriedade

• Ao viajar horizontalmente, a videira tem 50% de chance de continuar horizontalmente, 25% de chance de virar para o nordeste e 25% de chance de virar para o sudeste.
• Ao viajar na diagonal, a videira tem 90% de chance de virar horizontal e 10% de chance de continuar na diagonal.
• Deve haver turnos suficientes para suportar o número de entrada de abóboras, embora mais turnos sejam permitidos.
• Depois que a videira é construída, as abóboras podem ser colocadas aleatoriamente em qualquer canto que ainda não esteja ocupado por uma abóbora.
• As abóboras não podem se sobrepor à videira ou a outras abóboras.

O desafio

Dado um número de entrada, imprima uma plantação de abóbora aleatória seguindo as regras acima. A execução do código várias vezes com a mesma entrada deve gerar resultados diferentes. Todos os patches de abóbora possíveis para um determinado número de entrada devem ter alguma chance (não necessariamente igual) diferente de zero.

Entrada

Um único inteiro nrepresentando o número de abóboras no patch, em qualquer formato conveniente . Para uma brevidade do código, você pode assumir que a entrada é 0 < n < 256.

Resultado

O patch de abóbora resultante, impresso / exibido na tela ou retornado como uma string / string-array / etc.

Regras

• Este é o código-golfe, pelo que todas as regras usuais do golfe se aplicam e o código mais curto (em bytes) vence.
• Use nossa definição padrão de "Aleatório".
• Um programa ou função completo são aceitáveis.
• As brechas padrão são proibidas.
• Os espaços em branco iniciais / finais / novas linhas são completamente opcionais.

Exemplos

Para entrada n = 3, aqui estão alguns exemplos VÁLIDOS de uma plantação de abóbora seguindo as regras acima (separadas por novas linhas em branco).

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

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

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

Aqui estão alguns exemplos INVALID para entrada n = 3, com explicações #.

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

Sempre coloca pumkpins no 'lado de fora' dos cantos (aleatoriamente esquerda / direita)

Enquanto a videira é construída, as abóboras são adicionadas e, quando há bastante abóboras, a videira para.

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

Exemplos:

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