Randomisierte Kürbisbeet

Ich ging neulich für eine Geburtstagsfeier durch ein Kürbisbeet und bemerkte, dass die Kürbisreben ein hübsches Muster bildeten, mit Wirbeln, Schleifen und Ablegern. Wir werden das hier mit etwas ASCII-Kunst simulieren.

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

Regeln für den Rebbau

• Es gibt nur eine Hauptrebe, die ausschließlich aus \ / - p q b dZeichen besteht.
• Die Rebe bewegt sich nur von links nach rechts über den Bildschirm. Mit anderen Worten, nehmen Sie an, Sie wären eine Ameise, die mit dem Rebzeichen ganz links beginnt. Wenn Sie zum nächsten benachbarten Zeichen auf der Hauptrebe voranschreiten, müssen Sie eine Spalte nach rechts verschieben - niemals nach links.
• Wenn die Rebe die Richtung ändert, muss eines der p q b dZeichen eine Schleife simulieren. Die pReben verbinden sich von Nordosten nach Osten, qvon Osten nach Südosten, bvon Südosten nach Osten und dvon Osten nach Nordosten. Beachten Sie, dass die "Schleife" des Buchstabens mit der horizontalen Rebe und der "Stiel" des Buchstabens mit der Diagonale verbunden ist.
• Der Beginn der Rebe muss eines von poder sein b(Ihre Wahl muss nicht zufällig sein) und beginnt horizontal. Das Ende der Rebe muss eines von qoder sein d(Ihre Wahl muss nicht zufällig sein) und muss horizontal enden.
• Beachten Sie, dass Schleifen unmittelbar neben anderen Schleifen platziert werden können (z. B. pdist dies eine gültige Teilzeichenfolge der Rebe), was es jedoch schwieriger machen kann, die Kürbisse später zu platzieren. Möglicherweise möchten Sie immer eine von - / \unmittelbar nach einer Schleife haben (wie ich es in meinen Beispielen getan habe), aber es ist nicht erforderlich.

Kürbis-Regeln

• Die Kürbisse bestehen ausschließlich aus (())(genau dieser Schnur).
• Von der Hauptrebe sind die Kürbisse durch Ableger befestigt. Diese Ableger können nur an den p q b dSchlaufen befestigt werden, sind genau eins \oder /lang und werden so am Kürbis befestigt, dass das "Ende" des Ablegers in der Mitte liegt.
• Sie können sich über oder unter der Hauptrebe verbinden.
• Die Ableger können sich nach links verbinden.
• Pro Ableger kann sich nur ein Kürbis und pro Schleife nur ein Ableger festsetzen.

Zufälligkeit

• Bei horizontaler Fortbewegung hat die Rebe eine Chance von 50%, horizontal fortzufahren, eine Chance von 25%, sich nach Nordosten zu drehen, und eine Chance von 25%, sich nach Südosten zu drehen.
• Bei einer diagonalen Bewegung hat die Rebe eine Chance von 90%, sich horizontal zu drehen, und eine Chance von 10%, sich diagonal fortzusetzen.
• Es müssen genügend Windungen vorhanden sein, um die eingegebene Anzahl von Kürbissen zu unterstützen, obwohl mehr Windungen zulässig sind.
• Sobald die Rebe gebaut ist, können Kürbisse zufällig an jeder Ecke platziert werden, die noch nicht von einem Kürbis besetzt ist.
• Kürbisse dürfen die Rebe oder andere Kürbisse nicht überlappen.

Die Herausforderung

Geben Sie anhand der oben angegebenen Regeln ein zufälliges Kürbisfeld aus. Das mehrfache Ausführen des Codes mit derselben Eingabe sollte zu unterschiedlichen Ergebnissen führen. Alle möglichen Kürbisfelder für eine bestimmte Eingabenummer sollten eine (nicht unbedingt gleiche) Wahrscheinlichkeit aufweisen, dass sie nicht Null sind.

Eingang

Eine einzelne Ganzzahl, ndie die Anzahl der Kürbisse im Patch in einem beliebigen Format angibt . Aus Gründen der Kürze des Codes können Sie davon ausgehen, dass die Eingabe wie folgt lautet 0 < n < 256.

Ausgabe

Das resultierende Kürbisfeld wird entweder gedruckt / auf dem Bildschirm angezeigt oder als String / String-Array / etc. Zurückgegeben.

Regeln

• Dies ist Code-Golf, so dass alle üblichen Regeln für das Golfen gelten und der kürzeste Code (in Bytes) gewinnt.
• Verwenden Sie unsere Standarddefinition von "Zufall".
• Ein vollständiges Programm oder eine vollständige Funktion sind akzeptabel.
• Standardlücken sind verboten.
• Führende und nachfolgende Leerzeichen / Zeilenumbrüche sind vollständig optional.

Beispiele

Zur Eingabe n = 3sind hier einige GÜLTIGE Beispiele für einen Kürbisbeet nach den oben genannten Regeln (durch leere Zeilenumbrüche getrennt).

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

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

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

Hier sind einige UNGÜLTIGE Beispiele zur Eingabe n = 3mit Erläuterungen #.

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

Nimmt nals Eingabe

Platziert Pumkpins immer an der Außenseite der Ecken (nach dem Zufallsprinzip links / rechts)

Während die Rebe gebaut wird, werden Kürbisse hinzugefügt, und wenn genug Kürbisse da sind, hört die Rebe auf.

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

Beispiele:

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