Dado un número entero positivo N ("viralidad"), su programa debe crear un dibujo ASCII de un árbol con dos ramas de longitud N que se extiendan hacia abajo y / o hacia la derecha desde la esquina superior izquierda.

La dirección tomada por cada rama después del primer asterisco puede ser hacia la derecha o hacia abajo, y esta elección debe hacerse al azar ¹ en cada paso siguiente.

Por ejemplo, dada una entrada de 5, la salida podría verse así:

***
* ***
**
 **

Las dos ramas pueden tocar (estar en celdas adyacentes), pero no superponerse (estar en la misma celda), por lo que no se permitiría lo siguiente:

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

Ejemplos

Para la entrada 1, la única salida posible es:

**
*

(Esto estará presente en todas las salidas válidas, ya que hacer que las dos ramas tomen el mismo camino provocaría que se superpongan).

Las salidas posibles para una entrada de 3incluyen:

***
* *
**

**
***
*
*

Para entrada 7:

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

Para entrada 10:

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

Este es el código de golf , por lo que gana la respuesta válida más corta (en bytes).

^{1. Esto debería ser aleatorio de manera uniforme (es decir, una probabilidad de 50/50 de cada dirección), o tan aleatorio como sea posible en un hardware normal.}

CJam , 58 51 bytes

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

Pruébalo en línea!

La idea básica es que comencemos [0 0]y luego agreguemos repetidamente 0 o 1 a cada elemento (asegurándonos de que nunca sean iguales excepto al principio para evitar la superposición), recopilando todos los resultados intermedios.

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

Luego creamos una gran variedad de matrices donde cada subconjunto contiene *índices dados por el par correspondiente en la matriz original y espacios en cualquier otro lugar.

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

Esto produce cortes diagonales de la matriz de salida (donde moverse de izquierda a derecha corresponde a moverse de arriba a derecha a abajo a la izquierda en la matriz real).

Luego podemos usar ::a:.+para "des-diagonalizar" y obtener las líneas resultantes:

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

Carbón , 31 24 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Originalmente pensé que sería más fácil hacer que el primer paso fuera aleatorio, pero resultó ser más golfista hacer que la primera rama fuera predecible. Explicación:

Ｆ²«

Bucle dos veces, utilizando la variable de índice i. (Esto en realidad itera sobre una lista implícita, por lo que es seguro mutar identro del bucle).

Ｊ⁰¦⁰

Salta al origen del lienzo.

Ｆ⊕θ«

N+1Tiempos de bucle .

¿ι*↓*

Imprima a *, pero deje el cursor a la derecha o debajo del cursor según el valor de i.

‽²ι

Aleatorice el valor de ipara la próxima iteración del bucle interno.

¿ＫＫ↗

Si el personaje actual es un *, esto significa que somos la segunda rama y bajamos en lugar de la derecha, así que sube a la derecha para corregir eso. (La primera rama siempre comienza hacia abajo, por lo que la segunda rama siempre estará por encima de ella, lo que significa que solo necesitamos verificar una colisión vertical).

Java 10, 273 272 268 239 bytes

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;}

Pruébelo en línea aquí .

Gracias a Kevin Cruijssen por jugar al golf 29 bytes.

Versión sin golf:

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 118 bytes

118 bytes sin líneas nuevas, sangría y comentarios. Toma 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

Pruébalo en línea!

Python 2 , 204 bytes

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]

Pruébalo en línea!

Perl 5 -a , 97 96 93 92 bytes

No tiene sesgo diagonal derecha, abajo o fuera.

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

Pruébalo en línea!

PHP, 118 bytes

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

requiere PHP 5.4 o posterior para el operador de Elvis. Reemplazar ?:con ?1:PHP anterior.

Ejecutar como tubería -nRo probarlo en línea .

Rojo , 195 190 bytes

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]

Pruébalo en línea!

Legible:

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
]

Jalea , 50 43 41 bytes

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

Pruébalo en línea!

Fue muy divertido escribirlo. Podría haber algún método mucho más óptimo. Probablemente también hay algo de golf que hacer dentro de este método.

Justo después de publicar esto, me di cuenta de que podía usarlo en ,þ`lugar de aþ,""oþ`Ɗ.

R , 148 142 bytes

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

Pruébalo en línea!

Además, aunque no cumple con las especificaciones de salida, puede distinguir las dos ramas: ¡ Pruébelo en línea!

Explicación:

Comenzando desde el índice 1, seleccionamos aleatoriamente un movimiento hacia la derecha o hacia la izquierda para la rama ragregando no 1, respectivamente. Luego seleccionamos otro movimiento hacia la derecha o hacia la izquierda para la rama k, y si se cruzara a donde rva, seleccionamos la otra dirección. Luego usamos ry kcomo índices en m, estableciendo esos valores como "*". Iterando n-1tiempos, imprimimos el resultado.

Jalea , 39 38 bytes

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

Pruébalo en línea!

Aunque aparentemente no destá relacionado, es útil aquí para guardar un byte (sobre mi enfoque anterior).

Python 2 , 191 187 176 bytes

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)

Pruébalo en línea!

Python tiene soporte nativo para números complejos del formulario a+bj; Esto hace que algunos problemas 2D sean un poco más manejables ...