Patch di zucca randomizzata

L'altro giorno stavo camminando attraverso una zolla di zucca per una festa di compleanno e ho notato che le vigne di zucca facevano un disegno elegante, con vortici, anelli e rami. Lo simuleremo qui con un po 'di arte ASCII.

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

Regole di costruzione della vite

• C'è solo un vitigno principale, composto esclusivamente da \ / - p q b dpersonaggi.
• La vite viaggia solo da sinistra a destra attraverso lo schermo. In altre parole, supponiamo che tu fossi una formica che inizia dal carattere più a sinistra della vite. Mentre avanzi al prossimo personaggio adiacente sulla vite principale, devi spostare una colonna a destra, mai a sinistra.
• Quando la vite cambia direzione, uno dei p q b dpersonaggi è richiesto per simulare un loop. Le pviti si uniscono da nord-est a est, qda est a sud-est, bda sud-est a est e dda est a nord-est. Si noti che il "cappio" della lettera si collega alla vite orizzontale e lo "stelo" della lettera si collega alla diagonale.
• L'inizio della vite deve essere uno po b(a scelta, non deve essere casuale) e inizia in senso orizzontale. La fine della vite deve essere una qo d(a scelta, non deve essere casuale) e deve terminare in senso orizzontale.
• Si noti che i loop possono essere posizionati immediatamente adiacenti ad altri loop (ad esempio, pdè una sottostringa valida della vite), ma ciò potrebbe rendere più difficile posizionare le zucche in un secondo momento. Potresti averne sempre uno - / \immediatamente dopo un ciclo (come ho fatto nei miei esempi), ma non è necessario.

Regole della zucca

• Le zucche sono composte esclusivamente da (())(questa stringa esatta).
• Dalla vite principale, le zucche sono attaccate da rami. Questi rami possono essere attaccati solo ai p q b dpassanti, sono precisamente uno \o /in lunghezza e si attaccano alla zucca in modo che la "fine" dei rami sia nel mezzo.
• Possono connettersi sopra o sotto la vite principale.
• Gli offshoot possono connettersi andando a "sinistra".
• Solo una zucca può attaccare per germoglio e solo un germoglio per ciclo.

casualità

• Quando si viaggia in orizzontale, la vite ha una probabilità del 50% di continuare in orizzontale, una probabilità del 25% di girare a nord-est e una probabilità del 25% di girare a sud-est.
• Quando si viaggia in diagonale, la vite ha una probabilità del 90% di girare in orizzontale e una probabilità del 10% di continuare in diagonale.
• Devono esserci turni sufficienti per supportare il numero di input di zucche, sebbene siano consentiti più turni.
• Una volta costruita la vite, le zucche possono essere posizionate casualmente in qualsiasi angolo non già occupato da una zucca.
• Le zucche non possono sovrapporsi alla vite o ad altre zucche.

La sfida

Dato un numero di input, genera un patch di zucca randomizzato seguendo le regole sopra. L'esecuzione del codice più volte con lo stesso input dovrebbe produrre risultati diversi. Tutte le possibili patch di zucca per un dato numero di input dovrebbero avere qualche probabilità (non necessariamente uguale) diversa da zero.

Ingresso

Un singolo numero intero che nrappresenta il numero di zucche nella patch, in qualsiasi formato conveniente . Per brevità del codice, si può presumere che l'input sia 0 < n < 256.

Produzione

La patch di zucca risultante, stampata / visualizzata sullo schermo o restituita come stringa / stringa-matrice / ecc.

Regole

• Questo è code-golf quindi si applicano tutte le regole abituali per il golf e vince il codice più breve (in byte).
• Usa la nostra definizione standard di "Casuale".
• È accettabile un programma o una funzione completi.
• Sono vietate le scappatoie standard .
• Gli spazi bianchi / le righe principali e finali sono completamente opzionali.

Esempi

Per l'input n = 3, ecco alcuni esempi VALIDI di una patch di zucca che segue le regole sopra (separate da righe vuote).

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

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

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

Ecco alcuni esempi INVALID di input n = 3, con spiegazioni #.

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

Accetta ncome input

Posiziona sempre i pumkpin sull'esterno degli angoli (casualmente a sinistra / a destra)

Mentre viene costruita la vite, vengono aggiunte le zucche e quando ci sono abbastanza zucche, la vite si ferma.

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

Esempi:

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