A primavera chegou recentemente e é quase o momento em que as flores começam a brotar. Então, eu quero que você os ajude a crescer.

Sua tarefa:

Dados dois números,, me n, produzem mflores colocadas aleatoriamente em uma n*ngrade.

Uma única flor fica assim:

&
|

A posição de uma flor é definida por onde ela &está. Ao colocar duas flores aleatoriamente, duas não podem estar no mesmo lugar. Se uma flor se &sobrepõe a outra |, exiba &. A linha inferior das flores não pode conter nenhuma &.

A entrada pode ser como um número ou uma sequência, através de qualquer um dos métodos padrão.

A saída pode ser uma lista de cadeias, cada uma representando uma linha da grade ou uma cadeia delimitada, seguindo as mesmas diretrizes da lista. Métodos padrão de saída. Rastrear o que for permitido é permitido, e você pode usar as guias para separar suas flores. Observe que toda grade deve ser completamente preenchida, com espaços ou algo assim.

Note-se que a entrada será sempre válido, você sempre será capaz de ajustar legalmente as mflores no npor ngrade.

Casos de teste:

Como apenas casos de teste muito restritos podem ser garantidos, devido a todo o bit de "posicionamento aleatório", esse será o único tipo de caso de teste com uma resposta fornecida. Mas tentarei todos os envios on-line para garantir que eles também sejam válidos usando alguns casos de teste.

Entrada para os casos de teste é dado em forma m, n.

Input: 2, 2
Output:

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

&&&
&&&
|||

Observe que a nova linha após a palavra Output:nos casos de teste é opcional.

Outros casos de teste:

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

Código de golfe para ganhar o menor código!

Obrigado a ComradeSparklePony por fazer esse desafio e publicá-lo na caixa de presente do Papai Noel Secreto !. Postagem em sandbox

Gelatina , 33 bytes

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

Experimente online!

Quão?

²‘;⁹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];

recebe entrada de argumentos de linha de comando; executar -nrou testá-lo online .

demolir

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

Experimente online!

Quão?

Retira input()de STDIN e descompacta a tupla fornecida (uma sequência separada por vírgula de números inteiros decimais como 3,6) em ne m.

Cria um n*(n-1)"canteiro de flores" comprido e unidimensional b, concatenando:
- uma lista contendo uma "flor" [1]repetidas mvezes; e
- uma lista contendo um "espaço" [0]repetido n*~-n-mvezes *.

* O operador girino ~( ~x=-1-x) economiza 2 bytes n*~-n-mno lugar da aparência mais normal n*(n-1)-m.

Embaralha (usando randoma shufflefunção) este canteiro para colocar as flores e os espaços aleatoriamente entre as n*(n-1)posições.

Passa pelas linhas indexadas em 0 re, printscada uma por sua vez, para criar um canteiro de flores bidimensional a partir da única ...

O n*ncanteiro final bidimensional ( ) possui hastes,, suma linha abaixo das cabeças de flores f, se e somente se não houver uma cabeça de flor para mostrar. Isto é conseguido por XORing ( ^) fcom -sonde fe ssão os 1s e 0s desde antes e utilizando o resultado de índice para a cadeia de comprimento 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 obter fe sa zipfunção é usada com duas cópias do canteiro unidimensional, uma com nespaços à direita (as cabeças das flores) e outra com nespaços à frente (as hastes). A coisa toda é criada para cada linha (para salvar bytes), e a linha necessária é cortada 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

Experimente online!

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

Experimente online!

Gera a string de saída, um caractere por vez. Escolhe aleatoriamente se a célula atual é uma flor com probabilidade igual ao número mde flores restantes dividido pelo número de espaços restantes. Adiciona uma nova linha a todos os ncaracteres. Uma célula em branco é preenchida com uma haste |se o símbolo ndo final for 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];

Versão Online

-1 Byte para uma nova linha física

uma solução de 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];

Dessa maneira, com 137 bytes, embaralha a primeira parte da string

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>

Explicação: Cria uma matriz que representa a grade de flores mais novas linhas. Recursivamente procura aleatoriamente quadrados vazios para colocar flores até que o número desejado de flores seja atingido. Finalmente, as hastes das flores são geradas onde há espaço para elas.

Carvão , 27 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

Ｎθ

Entrada n.

↷

Altere a direção de impressão padrão para baixo.

ＦＮ«

Entrada me loop que muitas vezes.

Ｊ‽θ‽⊖θ

Ir para um local aleatório na grade.

Ｗ⁼ＫＫ&Ｊ‽θ‽⊖θ

Se já houver uma flor, continue pulando para locais aleatórios até encontrar um local adequado.

&

Imprima a cabeça da flor.

¬ＫＫ

Imprima o talo se ainda não houver uma cabeça de flor abaixo.