Question

After searching through the web I didn’t found an answer to help me.
My program is in C.

I have a list of items (for example : 37 a, 22 b, 29 c, 13 d, 19 e, 2 f and 0 g) and I have to randomly place all those items on a map (in my case, an int[height][lenght][7]).
I thought to use a rand to place items and to loop until the whole items are placed but it uses way too much time and ressources.

Is there a way to place them easily and properly ?

Here is my code:

/* allocates the tab in order to place the ressources/items */
void            create_map(t_world *world)   
{
  unsigned int  x;
  unsigned int  y;

  x = 0;
  world->map = xmalloc(world->height * sizeof(int**));
  while (x < world->height)
    {
      y = 0;
      world->map[x] = xmalloc(world->lenght * sizeof(int*));
      while (y < world->lenght)
        {
          world->map[x][y] = xmalloc(7 * sizeof(int));
          bzero(world->map[x][y], 7);
          ++y;
        }
  ++x;
    }
}

/* base defining the number of required item */
t_elevation elevation_tab[] =
{
  {1, {0, 1, 0, 0, 0, 0, 0} },
  {2, {0, 1, 1, 1, 0, 0, 0} },
  {2, {0, 2, 0, 1, 0, 2, 0} },
  {4, {0, 1, 1, 2, 0, 1, 0} },
  {4, {0, 1, 2, 1, 3, 0, 0} },
  {6, {0, 1, 2, 3, 0, 1, 0} },
  {6, {0, 2, 2, 2, 2, 2, 1} }
};

/* calculates the number of item required */
unsigned int    *calc_elevation(t_world *world)
{
  unsigned int  i;
  unsigned int  pos;
  unsigned int  *tab;

  i = 0;
  tab = xmalloc(7 * sizeof(int));
  bzero(tab, 7);
  while (i < 7)
  {
    pos = 0;
    while (pos < 7)
    {
      tab[pos] += (world->population /
               elevation_tab[i].required_players +
               world->population %
               elevation_tab[i].required_players) *
        (elevation_tab[i].required_ressources[pos]);
      ++pos;
    }
  ++i;
  }
  return (tab);
}
void            place_ressources(t_world *world, unsigned int *ressources)
{
//here is my missing code
}

/*First called function*/
void            create_world(t_param *params, t_world *world)
{
  unsigned int  *ressources_needed;

  world->lenght = params->lenght;
  world->height = params->height;
  world->population = params->team_size * 2;
  create_map(world);
  ressources_needed = calc_elevation(world);
  place_ressources(world, ressources_needed);
  show_map(world);
  world->players = NULL;
  free(ressources_needed);
}

The world is a grid of a certain size decided by the user with heigth and lenght. Each case of the grid has a int[7] delivering the amount of each item. So I can place multiples item on the same case.

Answer 1

I can think of 2 possible ways to solve this problem, but its going to depend on how many items need to be processed.

The first thing i thought of was a solution resembling how to shuffle a deck of cards in a computer program. Take the first element, and randomly generate x, y coords. Take the next element and generate x, y coordinates. If there is no item there, place the item in that position, otherwise generate new x, y coords. Continue this for all elements to be placed.

The other thing i can think of is if you can somehow keep track of which world tiles have been used so randomly generated coordinates are not duplicated.

The fact that your world object is a 3d array is what is exponentially increasing computations. Is it absolutely necessary? Granted i dont really know exactly what context your program is being designed for