La primavera è arrivata di recente ed è quasi l'ora in cui i fiori iniziano a germogliare. Quindi voglio che tu li aiuti a crescere.

Il tuo compito:

Dati due numeri me fiori di noutput mposizionati casualmente su una n*ngriglia.

Un singolo fiore si presenta così:

&
|

La posizione di un fiore è definita da dove si &trova. Quando si posizionano in modo casuale due fiori, non è possibile trovarne due nello stesso posto. Se un fiore si &sovrappone a quello di un altro |, visualizza il &. La fila inferiore di fiori non può contenere alcuno &.

L'input può essere un numero o una stringa, tramite uno dei metodi standard.

L'output può essere un elenco di stringhe, ciascuna stringa che rappresenta una riga della griglia o una stringa delimitata che segue la stessa linea guida dell'elenco. Metodi di output standard. Sono consentiti i wilingvers finali e puoi usare le schede per separare i tuoi fiori. Si noti che ogni griglia deve essere completamente riempita, con spazi o qualcosa del genere.

Si noti che l'ingresso sarà sempre valida, si sarà sempre in grado di adattarsi legalmente i mfiori in nda nrete.

Casi test:

Poiché è possibile garantire solo casi di test molto stretti, a causa dell'intero bit di "posizionamento casuale", sarà l'unico tipo di caso di test con una risposta fornita. Ma proverò tutti gli invii online per assicurarmi che siano validi anche usando alcuni casi di test.

L'input per i casi di test è indicato nel modulo m, n.

Input: 2, 2
Output:

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

&&&
&&&
|||

Si noti che la nuova riga dopo la parola Output:nei casi di test è facoltativa.

Altri casi di test:

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

Code golf vince il codice più corto!

Grazie a ComradeSparklePony per aver raccolto questa sfida e averla pubblicata nella confezione regalo di Babbo Natale segreto !. Posta sandbox

Gelatina , 33 byte

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

Provalo online!

Come?

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

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

accetta input dagli argomenti della riga di comando; eseguirlo -nro testarlo online .

abbattersi

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 byte

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

Provalo online!

Come?

Prende input()da STDIN e decomprime la tupla fornita (una stringa separata da numeri interi decimali come 3,6) in ne m.

Crea una n*(n-1)"aiuola" lunga , unidimensionale ordinata, bconcatenando:
- un elenco contenente un "fiore" [1]ripetuto m; e
- un elenco contenente uno "spazio" volte [0]ripetute n*~-n-m*.

* L'operatore tadpole ~( ~x=-1-x) salva 2 byte con n*~-n-mal posto dell'aspetto più normale n*(n-1)-m.

Mescola (usando randomla shufflefunzione) questa aiuola per posizionare i fiori e gli spazi in modo casuale tra le n*(n-1)posizioni.

Passa attraverso le righe indicizzate a 0 re printsciascuna a sua volta per creare un'aiuola bidimensionale da quella monodimensionale ...

L'ultima n*naiuola bidimensionale ( ) ha steli, suna fila sotto i capolini f, se e solo se non ci sono capolini da mostrare. Ciò è ottenuto da XORing ( ^) fcon -sdove fe ssono le 1s e 0s di prima e usando il risultato per indicizzare nella stringa di lunghezza 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.

Per ottenere fe sla zipfunzione viene utilizzata con due copie dell'aiuola monodimensionale, una con nspazi finali (i capolini) e una con nspazi iniziali (gli steli). Il tutto viene creato per ogni riga (per salvare i byte) e la riga richiesta viene tagliata usando [r*n:r*n+n].

Python 2 , 184 179 byte

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

Provalo online!

Python 2 , 129 byte

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

Provalo online!

Genera la stringa di output un carattere alla volta. Seleziona in modo casuale se la cella corrente è un fiore con probabilità uguale al numero mdi fiori rimanenti diviso per il numero di spazi rimanenti. Aggiunge una nuova riga ogni ncarattere. Una cella vuota viene riempita con uno stelo |se il simbolo ndalla fine è a &.

PHP, 111 byte

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

Versione online

-1 byte per una Newline fisica

una soluzione 115 byte utilizzando 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];

In questo modo con 137 byte mescola la prima parte della stringa

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 byte

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>

Spiegazione: Crea una matrice che rappresenta la griglia di fiori più nuove righe. Cerca in modo ricorsivo in modo casuale quadrati vuoti in cui posizionare i fiori fino a raggiungere il numero desiderato di fiori. Infine, gli steli dei fiori vengono generati dove c'è spazio per loro.

Carbone , 27 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

Ｎθ

Input n.

↷

Modificare la direzione di stampa predefinita verso il basso.

ＦＮ«

Inseriscilo me ripetilo più volte.

Ｊ‽θ‽⊖θ

Passa a una posizione casuale sulla griglia.

Ｗ⁼ＫＫ&Ｊ‽θ‽⊖θ

Se c'è già un fiore, continua a saltare in posizioni casuali fino a quando non viene trovato un punto adatto.

&

Stampa il capolino.

¬ＫＫ

Stampa il gambo se non c'è già un capolino sotto.