C function to memcpy part of the array to another reallocated part of the array

Question

I need to take a part of an Array, let's say:

32 64 66 69 72 78 81 87 94 95 1 2 4 8 16

realloc a new memory from the end of the array, take the part from 32 to 95 using memcpy to copy it after 16, rearrange the array and return the value of k (k is the size of the first group- 32 to 95, which is 10).
So the output should be:

1 2 4 8 16 32 64 66 69 72 78 81 87 94 95

I've written this code, which doesn't work, Anyone help please :(

int arrangeArray(int** arr, int n)
{
    // your code:
    int i, k = 0, rest = 0;
    for (i = 0; i < n-1;)
    {
        if (arr[i] < arr[++i])
            k++;
    }
    rest = n - k;
    *arr = (int*)realloc(*arr, (n + rest)*sizeof(int));
    memcpy((*arr)+rest, *arr, n*sizeof(int));
    k += rest;
    memcpy(*arr, (*arr) + k, rest * sizeof(int));
    *arr = (int*)realloc(*arr, n * sizeof(int));
    return k;
}

I have just opened this account, so no idea what are you talking about — Nir Ben Ishay, Mar 23 '22 at 19:12
This question looks very similar: https://stackoverflow.com/questions/71578550/realloc-triggeres-a-breakpoint — Barmar, Mar 23 '22 at 19:13
You should break out of the loop when the `if` condition fails so you stop incrementing `k`. — Barmar, Mar 23 '22 at 19:16
You shouldn't use `realloc`. Just `malloc` another buffer, and `memcpy` the two pieces into it. Then `free` the original buffer. — user3386109, Mar 23 '22 at 19:17
What do you mean by "rearrange the array"? Do you mean sort it? — Barmar, Mar 23 '22 at 19:18
Yes. sort it. And they want me to use Realloc specifically in the question — Nir Ben Ishay, Mar 23 '22 at 19:19
Can you use `memmove()`? After you copy the beginning part to the end, you can move everything down then realloc it to the original size. — Barmar, Mar 23 '22 at 19:21
Unfortunately, no. The assignment specified memcpy() and realloc() only. — Nir Ben Ishay, Mar 23 '22 at 19:24
Then you have a problem, because `memcpy()` can't be used with overlapping source and destination. — Barmar, Mar 23 '22 at 19:26
Then the solution is to double the size of the buffer. Your input array has 15 elements, so `realloc` it to make it 30 elements. Then copy the two chunks into the new memory, copy the whole thing back to the start, and `realloc` back to 15 elements. — user3386109, Mar 23 '22 at 19:31
Thank you so much for the help, I hope we can manage to find a way to solve this :/ — Nir Ben Ishay, Mar 23 '22 at 19:31
@user3386109 Is it to much to ask for the code of it? Im lost after mine. Only if you got time for it, of course. Much thanks — Nir Ben Ishay, Mar 23 '22 at 19:38

Barmar · Answer 1 · 2022-03-23T20:21:22.003

First, you have a problem with your calculation of k:

Put the increment of i in the for header. It's confusing to do it in the if statement -- at first I thought you had an infinite loop because you weren't incrementing.
Break out of the for loop when the condition fails.
arr[i] should be (*arr)[i].
You need to initialize k = 1 so that the last element in the first group is counted.

Since memcpy() doesn't allow overlapping source and destination, you should double the allocation, rather than just adding enough for k elements. Duplicate the entire array, then copy the portions in the rearranged order back to the beginning.

int arrangeArray(int** arr, int n)
{
    // your code:
    int k = 1, rest;
    for (int i = 0; i < n-1; i++)
    {
        if ((*arr)[i] < (*arr)[i+1]) {
            k++;
        } else {
            break;
        }
    }
    rest = n - k;
    *arr = realloc(*arr, 2 * n * sizeof(int)); // reallocate to double the size
    memcpy((*arr)+n, *arr, n*sizeof(int)); // duplicate the array
    memcpy(*arr, *arr + n + k, rest * sizeof(int)); // copy the rest to the beginning
    memcpy(*arr + rest, *arr + n, k * sizeof(int)); // copy the beginning to the end
    *arr = realloc(*arr, n * sizeof(int)); // reallocate back to the original size
    return k;
}

C function to memcpy part of the array to another reallocated part of the array

1 Answers1