FIFO queue for a 2D array in ANSI C, version 2 This is a modification of my previous version.
I would like advice on improving a FIFO algorithm for a 2D array that I've developed in ANSI C.
I have written code that uses this algorithm for test purposes. Random numbers are put into an array until all elements are full. The program then asks the user what numbers need to go in to the 2D array in order to update it. The code then removes the oldest array, shifts all remaining arrays up by one, and then adds the new array (as input by the user).
I am asking for a review of the FIFO code, fifo_algorithm; the surrounding code is only for testing purposes. I would appreciate any suggestions that only use standard C.
code:
#include &lt;stdint.h&gt;
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

void random_num_input(void);
void print_random_num_input(void);
void print_new_array(void);
void fifo_algorithm(void);

int user_num[5] = { 0 };
uint16_t big_array[10][5] = { 0 };
uint16_t big_array_copy[10][5] = { 0 };
uint16_t array_print[1] = { 0 };
uint8_t count = 0;
int main()
{
    random_num_input();
    printf(&quot;These are the original numbers in the big array:\n&quot;);
    print_random_num_input();
    while (count &lt; 10)
    {
        printf(&quot;Please enter values to swap in:\n&quot;);
        for (int i = 0; i &lt; 5; i++)
        {
            scanf(&quot;%d&quot;, &amp;user_num[i]);
        }
           printf(&quot;\n\n&quot;);
           fifo_algorithm();
        count++;
    }
}
//stores random numbers between 0-255 into big_array and big_array_copy
void random_num_input(void)
{
    for (int j = 0; j &lt; 10; j++)
    {
        for (int i = 0; i &lt; 5; i++)
        {
            big_array[j][i] = rand() % 255;
        }
    }
    
}
//prints the random values within the big_array 
void print_random_num_input(void)
{
    for (int j = 0; j &lt; 10; j++)
    {
        for (int i = 0; i &lt; 5; i++)
        {
            array_print[0] = big_array[j][i];
            printf(&quot;%d,&quot;, array_print[0]);
        }
        printf(&quot;\n&quot;);
    }
}
//This algorithm removes the oldest array in big_array_copy (element 9), shifts every
//element up by 1 and stores the user inputted array into element 0. Thus a fifo that updates
//the 2d array with the user input values every time 
void fifo_algorithm(void)
{
    for (int j = 0; j &lt; 10; j++)
    {
        for (int i = 0; i &lt; 5; i++)
        {
            big_array_copy[j][i] = big_array[j][i];
        }
    }
    for (int k = 0; k &lt; 5; k++)
    {
        big_array_copy[10 - 1][k] = 0;
    }
    for (int j = 9; j &gt; 0; j--)
    {
        for (int i = 0; i &lt; 5; i++)
        {
            big_array_copy[j][i] = big_array[j - 1][i];
        }
    }
    for (int i = 0; i &lt; 5; i++)
    {
        big_array_copy[0][i] = user_num[i];
    }
    print_new_array();
    for (int j = 0; j &lt; 10; j++)
    {
        for (int i = 0; i &lt; 5; i++)
        {
            big_array[j][i] = big_array_copy[j][i];
        }
    }
}
//simply prints the new, updated values in big_array_copy
void print_new_array(void)
{
    printf(&quot;These array values have been swapped:\n &quot;);
    for (int j = 0; j &lt; 10; j++)
    {
        for (int i = 0; i &lt; 5; i++)
        {
            array_print[0] = big_array_copy[j][i];
            printf(&quot;%d,&quot;, array_print[0]);
        }
        printf(&quot;\n&quot;);
    }
}

Thanks
Good formatting
Good use of (u)intN_t types
When printing, use a matching format specifier: printf(&quot;%&quot; PRI16u , array_print[0]);
Avoid naked magic numbers
Define constants for flexibility and clarity
// int user_num[5] = { 0] };
//uint16_t big_array[10][5] = { 0 };

#define BIG_ARRAY_MAXJ 10
#define BIG_ARRAY_MAXI 5
int user_num[BIG_ARRAY_MAXI] = { 0 };
uint16_t big_array[BIG_ARRAY_MAXJ][BIG_ARRAY_MAXI] = { 0 };

Instead of 9, use BIG_ARRAY_MAXJ - 1, etc.
To address the &quot;I could have put macros down to name 5 and 10 but I didn't see how that could be advantageous,&quot; comment: using named constants convey to others, including yourself at a later time, the relationship amongst the many constants and their individual meaning.
Global objects
Typically, it is far better to code for use of local objects than global ones.
Instead of
random_num_input(void)

Pass in a pointer to the array and its dimensions.  If VLA is supported:
random_num_input(int jn, int in, uint16_t a[j][i]) {
  for (int j = 0; j &lt; jn; j++) {
    for (int i = 0; i &lt; in; i++) {
        a[j][i] = rand() % 256;
    }
}

Array indexing
For big arrays, consider size_t instead of int to well handle large arrays.  size_t is the Goldilocks size for array sizing and indexing: not too small, not too big.
For big arrays, likely also need to move to allocated memory rather than fixed sizes.
Comment/code off by 1.
rand() % 255 forms values [0...254], not [0...255].
// stores random numbers between 0-255 into big_array ...
        big_array[j][i] = rand() % 255;

Consider
big_array[j][i] = rand() % 256;
// or 
big_array[j][i] = (uint8_t) rand();

Copying arrays
With arrays of the same dimension and type, as here, could use memcpy().
// for (int j = 0; j &lt; 10; j++) //
//    for (int i = 0; i &lt; 5; i++) {
//        big_array_copy[j][i] = big_array[j][i];
//    }
//}

// if known to be non-overlapping 
memcpy(big_array_copy, big_array, sizeof big_array_copy); 
// else 
memmove(big_array_copy, big_array, sizeof big_array_copy);

Minor: Tidier print
Consider not printing a trailing ','.  Little reason for a global array_print[].  Use the correct portable specifier
    char *sep = &quot;&quot;;
    for (int i = 0; i &lt; BIG_ARRAY_MAXI; i++) {
        printf(&quot;%s%&quot; PRI16u , sep, big_array_copy[j][i]);
        sep = &quot;,&quot;;
    }
    printf(&quot;\n&quot;);