1) If the declartion of your array was done in this way:

int A[20];

Your array could not be deleted because it's allocated statically

2) If the declartion of your array was done in this way:

int *A=malloc(20 * sizeof(int));
//or
int *A=calloc(20, sizeof(int));

Your array could be deleted with free(A) because it's allocated dynamically

There are really two separate issues. The first is keeping the elements of the array in proper order so that there are no "holes" after removing an element. The second is actually resizing the array itself.

Arrays in C are allocated as a fixed number of contiguous elements. There is no way to actually remove the memory used by an individual element in the array, but the elements can be shifted to fill the hole made by removing an element. For example:

void remove_element(array_type *array, int index, int array_length)
{
   int i;
   for(i = index; i < array_length - 1; i++) array[i] = array[i + 1];
}

Statically allocated arrays can not be resized. Dynamically allocated arrays can be resized with realloc(). This will potentially move the entire array to another location in memory, so all pointers to the array or to its elements will have to be updated. For example:

remove_element(array, index, array_length);  /* First shift the elements, then reallocate */
array_type *tmp = realloc(array, (array_length - 1) * sizeof(array_type) );
if (tmp == NULL && array_length > 1) {
   /* No memory available */
   exit(EXIT_FAILURE);
}
array_length = array_length - 1;
array = tmp;

realloc() will return a NULL pointer if the requested size is 0, or if there is an error. Otherwise, it returns a pointer to the reallocated array. The temporary pointer is used to detect errors when calling realloc() because instead of exiting, it is also possible to just leave the original array as it was. When realloc() fails to reallocate an array, it does not alter the original array.

Note that both of these operations will be fairly slow if the array is large or if a lot of elements are removed. There are other data structures like linked lists and hashes that can be used if efficient insertion and deletion is a priority.

From your description and code, by "delete" you probably mean shift the values to remove the given element and shorten the list by reducing the total count.

In your example, pos and count would be/should be the similar (off by 1?) .

The limit for your for loop isn't N - count. It is N - 1

So, you want:

for (i = pos; i < (N - 1); i++) {
    A[i] = A[i + 1];
}
N -= 1;

To do a general delete, given some criteria (a function/macro that matches on element(s) to delete, such as match_for_delete below), you can do the match and delete in a single pass on the array:

int isrc = 0;
int idst = 0;

for (;  isrc < N;  ++isrc) {
    if (match_for_delete(A,isrc,...))
        continue;

    if (isrc > idst)
        A[idst] = A[isrc];

    ++idst;
}

N = idst;