Étant donné un entier positif N ("viralité"), votre programme devrait créer un dessin ASCII d'un arbre avec deux branches de longueur N s'étendant vers le bas et / ou vers la droite à partir du coin supérieur gauche.

La direction prise par chaque branche après le premier astérisque peut être vers la droite ou vers le bas, et ce choix doit être fait au hasard ¹ à chaque étape suivante.

Par exemple, étant donné une entrée de 5, la sortie pourrait ressembler à:

***
* ***
**
 **

Les deux branches sont autorisées à se toucher (sur les cellules adjacentes), mais ne se chevauchent pas (sur la même cellule), de sorte que les éléments suivants ne seraient pas autorisés:

***
* *
*****
  *
  *

Exemples

Pour l'entrée 1, la seule sortie possible est:

**
*

(Ceci sera présent dans toutes les sorties valides, car le fait que les deux branches empruntent le même chemin entraîneraient leur chevauchement.)

Les sorties possibles pour une entrée 3comprennent:

***
* *
**

**
***
*
*

Pour l'entrée 7:

****
*  **
*   **
*
***
  *

Pour l'entrée 10:

****
*  *      
*********
  *
  *****

Il s'agit de code-golf , donc la réponse valide la plus courte (en octets) l'emporte.

^{1. Cela devrait être uniformément aléatoire (c'est-à-dire une chance 50/50 de chaque direction), ou aussi proche de l'uniformément aléatoire que vous pouvez obtenir sur du matériel normal.}

CJam , 58 51 octets

[TT]{_2_m*\f.+{:-},mR}ri*]ee{~\)S*\{'*t}/}%::a:.+N*

Essayez-le en ligne!

L'idée de base est que nous commençons par [0 0]puis ajoutons à plusieurs reprises 0 ou 1 à chaque élément (en veillant à ce qu'ils ne soient jamais égaux sauf au début pour éviter le chevauchement), en collectant tous les résultats intermédiaires.

[[0 0] [0 1] [0 2] [0 2] [1 3]]

Nous créons ensuite un grand tableau de tableaux où chaque sous-tableau contient des *indices donnés par la paire correspondante dans le tableau d'origine et des espaces partout ailleurs.

["*"
 "**"
 "* *"
 "* * "
 " * * "]

Cela donne des tranches diagonales de la matrice de sortie (où le déplacement de gauche à droite correspond au déplacement de haut en bas à droite dans la matrice réelle).

On peut alors utiliser ::a:.+pour "dé-diagonaliser" et obtenir les lignes résultantes:

[ "**** "
  "*  *"
  "** "
  " *"
  ""     ]

Fusain , 31 24 octets

Ｆ²«Ｊ⁰¦⁰Ｆ⊕θ«¿ι*↓*≔‽²ι¿ＫＫ↗

Essayez-le en ligne! Le lien est vers la version détaillée du code. À l'origine, je pensais qu'il serait plus facile de faire la première étape au hasard, mais il s'est avéré être plus golfeur pour rendre la première branche prévisible. Explication:

Ｆ²«

Boucle deux fois, en utilisant la variable d'index i. (Cela itère en fait sur une liste implicite, il est donc sûr de muter ià l'intérieur de la boucle.)

Ｊ⁰¦⁰

Aller à l'origine de la toile.

Ｆ⊕θ«

N+1Temps de boucle .

¿ι*↓*

Imprimez a *, mais laissez le curseur à droite ou en dessous du curseur en fonction de la valeur de i.

‽²ι

Rendre aléatoire la valeur de ipour la prochaine itération de la boucle interne.

¿ＫＫ↗

Si le caractère actuel est un *, cela signifie que nous sommes la deuxième branche et que nous sommes descendus au lieu de droite, alors montez à droite pour corriger cela. (La première branche commence toujours vers le bas, de sorte que la deuxième branche sera toujours au-dessus, ce qui signifie que nous devons seulement vérifier une collision verticale.)

Java 10, 273 272 268 239 octets

n->{var c=new char[++n][n];for(var d:c)java.util.Arrays.fill(d,' ');for(int i=0,j=0,k=0,l=0,r=0,s=0,t=0,u=0;n-->0;){c[i+=r][j+=s]=c[k+=t][l+=u]=42;do{r=t=2;r*=Math.random();t*=Math.random();s=r^1;u=t^1;}while(i+r==k+t&j+s==l+u);}return c;}

Essayez-le en ligne ici .

Merci à Kevin Cruijssen d' avoir joué au golf 29 octets.

Version non golfée:

n -> { // lambda taking an int as argument
    var c = new char[++n][n]; // the output; increment the virality since the root does not count
    for(var d : c) // for every line
        java.util.Arrays.fill(d,' '); // initialize it with spaces
    for(int i = 0, j = 0, // coordinates of the first branch
            k = 0, l = 0, // coordinates of the second branch
            r = 0, s = 0, // offsets for the first branch, one will be 0 and the other 1 always except for the first '*' where the two branches overlap
            t = 0, u = 0; // offsets for the second branch, one will be 0 and the other 1 always except for the first '*' where the two branches overlap
        n-- > 0; ) { // decrement virality and repeat as many times
        c[i+=r][j+=s] = c[k+=t][l+=u] = 42; // move according to offsets and place an '*' for each branch, 42 is ASCII code
        do { // randomly pick offsets for both branches
            r = t = 2; // Math.random() provides results in [0,1)
            r *= Math.random(); // flip a coin for the first branch
            t *= Math.random(); // flip another coin for the second
            s = r^1; // set s to 0 if r=1, to 1 if r=0
            u = t^1; // set u to 0 if t=1, to 1 if t=0
        } while(i+r==k+t&j+s==l+u); // repeat if the branches overlap
    }
    return c; // return the output
}

Perl 5 , 208 124 122 122 118 octets

118 octets sans retour à la ligne, indentation et commentaires. Prend N de stdin:

@b=1..2;                            #number of branches is 2
for(1..<>){                         #add length <> (the input) to each branch
  ($x,$y)=@$_                       #get where current branch has its tip now
 ,.5>rand?$x++:$y++                 #increase either x or y
 ,$o[$y][$x]++&&redo                #try again if that place is already occupied
 ,$_=[$x,$y]                        #register new tip of current branch
   for@b                            #...and do all that for each branch 
}
say map$_||!$i++?'*':$",@$_ for@o;  #output the branches

Essayez-le en ligne!

Python 2 , 204 octets

from random import*
N=input()
s=eval(`[[' ']*-~N]*-~N`)
s[0][0]='*'
I=x,y=1,0
J=X,Y=0,1
exec"s[y][x]=s[Y][X]='*';i,j,k,l=choice((J+I,I+I,I+J,J+J)[x-2<X:]);x+=i;y+=j;X+=k;Y+=l;"*N
for i in s:print`i`[2::5]

Essayez-le en ligne!

Perl 5 -a , 97 96 93 92 octets

N'a pas de biais diagonal droit, bas ou off.

#!/usr/bin/perl -a
@;=[1];map{$x=$y=0;map++(.5<rand?$x:$y)*$;[$y][$x]++&&redo,1.."@F"}1,2;say+($","*")[@$_]for@

Essayez-le en ligne!

PHP, 118 octets

for($r="*",$w=$argn+2;$argn--;$r[$q+=rand(0,$r[$q+1]<"*")?:$w]=$r)$r[$p+=rand(!$i++,1)?:$w]=$r;echo wordwrap($r,$w-1);

nécessite PHP 5.4 ou une version ultérieure pour l'opérateur Elvis. Remplacez ?:par ?1:pour l'ancien PHP.

Exécuter en tant que pipe avec -nRou l' essayer en ligne .

Rouge , 195 190 octets

func[n][g: func[s][i: 0 d: s while[i < n][b/(d): #"*"until[r: 1 if 1 = random 2[r: n + 1]b/(d + r) =#" "]d: d + r
i: i + 1]]b:""loop n[loop n[append b" "]append b"^/"]b/1: #"*"g n + 2 g 2 b]

Essayez-le en ligne!

Lisible:

f: func[n][
    g: func[s][
        i: 0
        d: s
        while[i < n][
            b/(d): #"*"
            until[
                r: 1 if 1 = random 2[r: n + 1]
                b/(d + r) = #" "
            ]
            d: d + r
            i: i + 1
        ]
    ]
    b: ""
    loop n[loop n[append b " "]append b "^/"]
    b/1: #"*"
    g n + 2
    g 2
    b
]

Gelée , 50 43 41 octets

2ḶẊ⁸С+\‘Ṗ
⁸ÇU;Ǥ⁻Q$¿
‘,þ`⁼€þÇS+»þ`Ị$ị⁾* 

Essayez-le en ligne!

C'était vraiment amusant à écrire. Il pourrait y avoir une méthode beaucoup plus optimale. Il y a probablement aussi du golf à faire avec cette méthode.

Juste après avoir posté cela, j'ai réalisé que je pouvais utiliser à la ,þ`place de aþ,""oþ`Ɗ.

R , 148 142 octets

n=scan();`~`=sample;o=r=k=1;l=c(1,n);for(i in 1:n){r=r+l~1;t=l~1;k=k+"if"(k+t-r,t,l[l!=t]);o=c(o,r,k)};write(c(" ","*")[1:n^2%in%o+1],1,n,,"")

Essayez-le en ligne!

De plus, bien qu'il ne réponde pas aux spécifications de sortie, vous pouvez distinguer les deux branches: Essayez-le en ligne!

Explication:

En partant de l'index 1, nous sélectionnons au hasard un mouvement à droite ou à gauche pour la branche ren ajoutant nou 1, respectivement. Ensuite, nous sélectionnons un autre mouvement à droite ou à gauche pour la branche k, et si elle se croisait où rva, nous sélectionnons l'autre direction. Ensuite, nous utilisons ret kcomme indices dans m, définissant ces valeurs comme "*". En itérant les n-1temps, nous imprimons ensuite le résultat.

Gelée , 39 38 octets

ḣ2+\€Ẏ
2Rd¤ṗẊÇ⁻Q$$¿Ç0,0ṭ‘Ṭ€×þ/$€Sị⁾* Y

Essayez-le en ligne!

Bien qu'apparemment sans rapport, il dest utile ici d'enregistrer un octet (par rapport à mon approche précédente).

Python 2 , 191 187 176 176 octets

from random import*
n=input()
p,q=c=1,1j;s={p,q,0}
exec'z=choice(c);q,p=p+[z,1+1j-z][p+z in s],q;s|={q};'*2*~-n
R=range(n+1)
for y in R:print''.join(' *'[y+x*1jin s]for x in R)

Essayez-le en ligne!

Python a un support natif pour les nombres complexes du formulaire a+bj; cela rend certains problèmes 2-D un peu plus faciles à résoudre ...