Having trouble assigning values to an array

It doesn't look to me like your code implements (at least what I'd normally think of as) a counting sort.

So, to give an idea of the general kind of thing you're trying to accomplish, here's a counting sort (that works), but using all sorts of stuff your teacher apparently won't accept, so you can't turn it in directly.

void counting_sort(int* array, unsigned array_len) {
    std::map<int, unsigned> tallies;

    for (unsigned i = 0; i < array_len; i++)
        ++tallies[array[i]];

    unsigned pos = 0;
    for (auto [value, count] : tallies)
        for (int j = 0; j < count; j++)
            array[pos++] = value;
}

We start by walking through the input array, incrementing a count for each value in the input (in this case, just using a map as a sparse array).

Then we walk through the array of counts, and write the appropriate number of each value into the array, in order.

Here's a quick test:

int main() {
    std::vector<int> inputs { 2, 1, 2, 1, 0, 3, 0 };

    counting_sort(inputs.data(), inputs.size());

    for (int i : inputs)
        std::cout << i << ' ';
}

...and here's output from that test:

0 0 1 1 2 2 3

To reiterate the basic idea of the algorithm: we start with an array of counts. We use that to count the number of times each value in the input array occurs. Since it contains counts, each value in it should start out at zero. We walk through values in the input array, and use those to index into the tally array, incrementing the location in the tally array by one when we encounter a value.

When we're done with that, the first item in the array should contain the number of times the lowest value in the input occurred, the second number of times lowest+1 occurred (which may easily be 0), and so on.

Then we walk through the array of tallies. The index we're using is the value that came from the input array, and the value in the tally is the number of times that value occurred. So, we write that value out the appropriate number of times, then proceed to the next. When we reach the end of the array, we're done.

The big difference in your case is how we store the tallies. I've used a map<int, unsigned>, which acts like a sparse array--that is, although it can store a value associated with any int, it only really stores the values we've written there, so any value that wasn't in the input array won't be in our tally either.

To satisfy your teacher's proclivities, when you write it you're apparently going to use new to allocate a block of data using new¹. So you will store all the intermediate values. You want to start with them all set to 0. Then when you encounter an input value, you use it as an index, and increment that value in the tallies array.

Then you'll do just about like above, walking through the tallies array, and writing values back to the input array the proper number of times. Since you started each count at zero, any that weren't present will be written out zero times, which translates to them not being written at all.