Vfrdtyky

I have a 50x50 2D dimensional board with empty cells now. I want to fill 20% cells with 0, 30% cells with 1, 30% cells with 2 and 20% cells with 3. How to randomly throw these 4 numbers onto the board with the percentages?

  import numpy as np

  from numpy import random



  dim = 50

  map = [[" "for i in range(dim)] for j in range(dim)]

  print(map)

One way to get this kind of randomness would be to start with a random permutation of the numbers from 0 to the total number of cells you have minus one.

perm = np.random.permutation(2500)

now you split the permutation according the proportions you want to get and treat the entries of the permutation as the indices of the array.

array = np.empty(2500)

p1 = int(0.2*2500)

p2 = int(0.3*2500)

p3 = int(0.3*2500)

array[perm[range(0, p1)]] = 0

array[perm[range(p1, p1 + p2)]] = 1

array[perm[range(p1 + p2, p3)]] = 2

array[perm[range(p1 + p2 + p3, 2500)]] = 3

array = array.reshape(50, 50)

This way you ensure the proportions for each number.

Since the percentages sum up to 1, you can start with a board of zeros

bsize = 50

board = np.zeros((bsize, bsize))

In this approach the board positions are interpreted as 1D postions, then we need a set of position equivalent to 80% of all positions.

for i, pos in enumerate(np.random.choice(bsize**2, int(0.8*bsize**2), replace=False)):

    # the fisrt 30% will be set with 1

    if i < int(0.3*bsize**2):

        board[pos//bsize][pos%bsize] = 1

    # the second 30% (between 30% and 60%) will be set with 2

    elif i < int(0.6*bsize**2):

        board[pos//bsize][pos%bsize] = 2

    # the rest 20% (between 60% and 80%) will be set with 3

    else:

        board[pos//bsize][pos%bsize] = 3

At the end the last 20% of positions will remain as zeros

As suggested by @alexis in commentaries, this approach could became more simple by using shuffle method from random module:

from random import shuffle

bsize = 50

board = np.zeros((bsize, bsize))



l = list(range(bsize**2))

shuffle(l)



for i, pos in enumerate(l):

        # the fisrt 30% will be set with 1

        if i < int(0.3*bsize**2):

            board[pos//bsize][pos%bsize] = 1

        # the second 30% (between 30% and 60%) will be set with 2

        elif i < int(0.6*bsize**2):

            board[pos//bsize][pos%bsize] = 2

        # the rest 20% (between 60% and 80%) will be set with 3

        elif i < int(0.8*bsize**2):

            board[pos//bsize][pos%bsize] = 3

The last 20% of positions will remain as zeros again.

A different approach (admittedly it's probabilistic so you won't get perfect proportions as the solution proposed by Brad Solomon)

import numpy as np

res = np.random.random((50, 50))



zeros = np.where(res <= 0.2, 0, 0)

ones = np.where(np.logical_and(res <= 0.5, res > 0.2), 1, 0)

twos = np.where(np.logical_and(res <= 0.8, res > 0.5), 2, 0)

threes = np.where(res > 0.8, 3, 0)



final_result = zeros + ones + twos + threes

Running

np.unique(final_result, return_counts=True)

yielded

(array([0, 1, 2, 3]), array([499, 756, 754, 491]))

Here's an approach with np.random.choice to shuffle indices, then filling those indices with repeats of the inserted ints. It will fill the array in the exact proportions that you specify:

import numpy as np

np.random.seed(444)



board = np.zeros(50 * 50, dtype=np.uint8).flatten()



# The "20% cells with 0" can be ignored since that is the default.

#

# This will work as long as the proportions are "clean" ints

# (I.e. mod to 0; 2500 * 0.2 is a clean 500.  Otherwise, need to do some rounding.)



rpt = (board.shape[0] * np.array([0.3, 0.3, 0.2])).astype(int)

repl = np.repeat([1, 2, 3], rpt)



idx = np.random.choice(board.shape[0], size=repl.size, replace=False)



board[idx] = repl

board = board.reshape((50, 50))

Resulting frequencies:

>>> np.unique(board, return_counts=True)

(array([0, 1, 2, 3], dtype=uint8), array([500, 750, 750, 500]))

>>> board

array([[1, 3, 2, ..., 3, 2, 2],

       [0, 0, 2, ..., 0, 2, 0],

       [1, 1, 1, ..., 2, 1, 0],

       ...,

       [1, 1, 2, ..., 2, 2, 2],

       [1, 2, 2, ..., 2, 1, 2],

       [2, 2, 2, ..., 1, 0, 1]], dtype=uint8)

Approach

Flatten the board. Easier to work with indices when the board is (temporarily) one-dimensional.

rpt is a 1d vector of the number of repeats per int. It gets "zipped" together with [1, 2, 3] to create repl, which is length 2000. (80% of the size of the board; you don't need to worry about the 0s in this example.)

The indices of the flattened array are effectively shuffled (idx), and the length of this shuffled array is constrained to the size of the replacement candidates. Lastly, those indices in the 1d board are filled with the replacements, after which it can be made 2d again.