La primavera ha llegado recientemente, y es casi el momento en que las flores comienzan a brotar. Entonces quiero que los ayudes a crecer.

Tu tarea:

Dados dos números,, my n, mflores de salida colocadas al azar en una n*ncuadrícula.

Una sola flor se ve así:

&
|

La posición de una flor se define por dónde &está. Al colocar dos flores al azar, no puede haber dos en el mismo lugar. Si una flor se &superpone a otra |, muestre el &. La fila inferior de flores puede no contener ninguna &.

La entrada puede ser como un número o una cadena, a través de cualquiera de los métodos estándar.

La salida puede ser una lista de cadenas, cada cadena representando una fila de la cuadrícula, o una cadena delimitada siguiendo la misma guía que la lista. Métodos estándar de salida. Se permiten los rastros de lo que sea, y puede usar pestañas para separar sus flores. Tenga en cuenta que cada cuadrícula debe estar completamente llena, con espacios o algo así.

Tenga en cuenta que la entrada siempre será válida, siempre será capaz de encajar jurídicamente las mflores al npor ncuadrícula.

Casos de prueba:

Dado que solo se pueden garantizar casos de prueba muy ajustados, debido a todo el bit de "ubicación aleatoria", ese será el único tipo de caso de prueba con una respuesta proporcionada. Pero intentaré todas las presentaciones en línea para asegurarme de que sean válidas utilizando algunos casos de prueba también.

La entrada para los casos de prueba se da en el formulario m, n.

Input: 2, 2
Output:

&&
||
--------------
Input: 6, 3
Output:

&&&
&&&
|||

Tenga en cuenta que la nueva línea después de la palabra Output:en los casos de prueba es opcional.

Otros casos de prueba:

1. 1, 10
2. 0, 100
3. 5, 8
4. 6, 3

¡Golf de código para que el código más corto gane!

¡Gracias a ComradeSparklePony por hacer este desafío y publicarlo en la caja de regalo de Secret Santa's !. Publicación de sandbox

Jalea , 33 bytes

²‘;⁹R¤ṬṖs⁸×’¤Ẋ€ṙ2B¤F€ZḄị“&|& ”s⁸Y

Pruébalo en línea!

¿Cómo?

²‘;⁹R¤ṬṖs⁸×’¤Ẋ€ṙ2B¤F€ZḄị“&|& ”s⁸Y - Main link: n, m        e.g. 3, 2
²                                 - square n                    9
 ‘                                - increment                   10
     ¤                            - nilad followed by link(s) as a nilad:
   ⁹                              -     link's right argument   2
    R                             -     range                   [1,2]
  ;                               - concatenate                 [10,1,2]
      Ṭ                           - untruth (1s at indexes)     [1,1,0,0,0,0,0,0,0,1]
       Ṗ                          - pop                         [1,1,0,0,0,0,0,0,0]
            ¤                     - nilad followed by link(s) as a nilad:
         ⁸                        -     link's left argument    3
           ’                      -     decrement               2
          ×                       -     multiply                6
        s                         - split into chunks           [[1,1,0,0,0,0],[0,0,0]]
             Ẋ€                   - shuffle €ach       (maybe:) [[0,1,0,0,1,0],[0,0,0]]
                  ¤               - nilad followed by link(s) as a nilad:
                2B                -     2 in binary             [1,0]
               ṙ                  - rotate (vectorises)         [[[0,0,0],[0,1,0,0,1,0]],[[0,1,0,0,1,0],[0,0,0]]]
                   F€             - flatten €ach                [[0,0,0,0,1,0,0,1,0],[0,1,0,0,1,0,0,0,0]]
                     Z            - transpose                   [[0,0],[0,1],[0,0],[0,0],[1,1],[0,0],[0,0],[1,0],[0,0]]
                      Ḅ           - from binary (vectorises)    [0,1,0,0,3,0,0,2,0]
                        “&|& ”    - literal                     ['&','|','&',' ']
                       ị          - index into                  [' ','&',' ',' ','&',' ',' ','|',' ']
                               ⁸  - link's left argument        3
                              s   - split into chunks           [[' ','&',' '],[' ','&',' '],[' ','|',' ']]
                                Y - join with newlines          [' ','&',' ','\n',' ','&',' ','\n',' ','|',' ']
                                  - implicit print

PHP (> = 7.1), 135 131 128 116 110 109 bytes

for([,$m,$n]=$argv,$z=$q=$n*$n;$q;)echo" |&"[$m&&rand(0,--$z-$n)<$m?$s[$q]=2+!$m--:$s[$q+$n]/2],"
"[--$q%$n];

toma datos de los argumentos de la línea de comandos; ejecutarlo -nro probarlo en línea .

Descompostura

for([,$m,$n]=$argv,     # import arguments
    $z=$q=$n*$n;        # $q = number of total fields, $z-$n = available for flowers
    $q;                 # loop $q down to 0
)   
    echo" |&"[              # print:
        $m&&rand(0,--$z-$n)<$m  # if (probability $m/($z-$n)), decrement $z
            ?$s[$q]=2+!$m--     # then index 2 (flower), set $s[$q], decrement $m
            :$s[$q+$n]/2        # else if flower above, then 1 (stalk), else 0 (space)
        ],
        "\n"[--$q%$n]           # print newline every $n characters
    ;

Python 2 , 150 bytes

from random import*
n,m=input()
b=[1]*m+[0]*(n*~-n-m)
shuffle(b)
for r in range(n):print''.join(' &|'[f^-s]for s,f in zip([0]*n+b,b+[0]*n)[r*n:r*n+n])

Pruébalo en línea!

¿Cómo?

Toma input()de STDIN y desempaqueta la tupla proporcionada (una cadena separada por comas de enteros decimales como 3,6) en ny m.

Crea un n*(n-1)"macizo de flores" ordenado, unidimensional b, concatenando:
- una lista que contiene una "flor" [1]repetidas mveces; y
- una lista que contiene un "espacio" [0]repetido n*~-n-mveces *.

* El operador renacuajo ~( ~x=-1-x) guarda 2 bytes n*~-n-men lugar del aspecto más normal n*(n-1)-m.

Baraja (usando randomla shufflefunción de) este cantero para colocar las flores y espacios al azar entre las n*(n-1)posiciones.

Recorre las filas indexadas en 0 r, y printscada una a su vez para crear un macizo de flores bidimensional a partir del unidimensional ...

El último n*nmacizo de flores bidimensional ( ) tiene tallos, suna fila debajo de las cabezas de flores f, si y solo si no hay cabeza de flor para mostrar. Esto se consigue mediante XORing ( ^) fcon -sdonde fy sson los 1s y 0s de antes y utilizando el resultado para indexar en la cadena de longitud 3 ' &|':

f   s   f^-s   ' &|'[f^-s]
0   0    0     ' '
0   1   -1     '|'  < negative indexing used here
1   0    1     '&'
1   1   -2     '&'  < ...and here.

Para obtener fy sla zipfunción se usa con dos copias del macizo de flores unidimensional, una con nespacios finales (las cabezas de las flores) y otra con nespacios iniciales (los tallos). Todo se crea para cada fila (para guardar bytes), y la fila requerida se divide usando [r*n:r*n+n].

Python 2 , 184 179 bytes

from random import*
m,n=input()
s,a=' &'
l=[s]*n*-~n
while s.count(a)<m:x=randrange(n*n-n);l[x]=a;l[x+n]='|&'[l[x+n]==a];s='\n'.join(''.join(l[i*n:][:n])for i in range(n))
print s

Pruébalo en línea!

Python 2 , 129 bytes

from random import*
n,m=input();d=n*n-n
s=''
while d+n:b=0<random()*d<m;m-=b;d-=1;s+=' |&'[-b|(s[~n:-n]=='&')]+'\n'[d%n:]
print s

Pruébalo en línea!

Genera la cadena de salida un carácter a la vez. Elige aleatoriamente si la celda actual es una flor con una probabilidad igual al número mde flores restantes dividido por el número de espacios restantes. Agrega una nueva línea a cada npersonaje. Una celda en blanco se llena con un tallo |si el símbolo ndel final es a &.

PHP, 111 bytes

for([,$b,$s]=$argv;$i<$s**2;)echo${+$i}="| &"[(rand(1,$s**2-$s-$i)>$b?0:$b--)>0?2:${$i-$s}!="&"],"\n"[++$i%$s];

Versión en línea

-1 Byte para una nueva línea física

una solución 115 Bytes usando max

for([,$b,$s]=$argv;$i<$s**2;)echo${+$i}="&| "[rand(1,max($s**2-$s-$i,1))>$b?1+(${$i-$s}!="&"):!$b--],"\n"[++$i%$s];

De esta manera, con 137 bytes baraja la primera parte de la cadena

for([,$b,$s]=$argv,$a=str_shuffle(($p=str_pad)($p("",$b,_),$s**2-$s));$i<$s**2;)echo$a[$i]<_?" |"[$a[$i-$s]==_&$i>=$s]:"&","\n"[++$i%$s];

JavaScript (ES6), 157 bytes

f=(n,m,a=[...(` `.repeat(n)+`
`).repeat(n)],r=Math.random()*-~n*~-n|0)=>m?(a[r]==` `?a[m--,r]=`&`:0,f(n,m,a)):a.map((c,i)=>c==` `&&a[i+~n]==`&`?`|`:c).join``

<div oninput=o.textContent=f(n.value,m.value)><input id=n type=number min=2 value=2><input id=m type=number min=1><pre id=o>

Explicación: Crea una matriz que representa la cuadrícula de flores más líneas nuevas. Recursivamente busca aleatoriamente cuadrados vacíos en los que colocar flores hasta alcanzar el número deseado de flores. Finalmente se generan los tallos de las flores donde hay espacio para ellas.

Carbón , 27 bytes

Ｎθ↷ＦＮ«Ｊ‽θ‽⊖θＷ⁼ＫＫ&Ｊ‽θ‽⊖θ&¬ＫＫ

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｎθ

Entrada n.

↷

Cambie la dirección de impresión predeterminada hacia abajo.

ＦＮ«

Entrada my bucle que muchas veces.

Ｊ‽θ‽⊖θ

Salta a una ubicación aleatoria en la cuadrícula.

Ｗ⁼ＫＫ&Ｊ‽θ‽⊖θ

Si ya hay una flor, salta a ubicaciones aleatorias hasta encontrar un lugar adecuado.

&

Imprime la cabeza de la flor.

¬ＫＫ

Imprima el tallo si aún no hay una cabeza de flor debajo.