copy and cancel int array - c++

Question

I got two arrays, both are sorted. One array is filled with repeating values, the other one filled with values that shall be cancelled in the first array. For example:
int * val = new int[11];
val[0] = 1; val[1] = 1;
val[2] = 2; val[3] = 2; val[4] = 2; val[5] = 2;
val[6] = 3;
val[7] = 4;
val[8] = 5; val[9] = 5; val[10] = 5;
int * invalid = new int[2]; invalid[0] = 2; invalid[1] = 5;
Then the output shall be like this
int * valid = new int[4];
valid[0] = 1; valid[1] = 1;
valid[2] = 3;
valid[3] = 4;
How can I implement this efficiently using a for loop? I want to point out that I do not want to switch to containers like vector or list, because I know there will be comments going in that direction. I explicitly want work with arrays.

Answer 1

If both are sorted, this is just a simple O(N+M) algorithm: start with both arrays at zero index, and increment the one pointing to the smaller value. If you incremented the target array, copy unless it equals the invalid array.
Also, since you are only removing items, you can avoid some copies if you don't have to keep the original data: you can keep a counter how many items you discarded, and copy into the same array to currentIdx-discardedCount if discardedCount is greater than zero.

Answer 2

At first you should count the number of elements in the source array that satisfy the condition and then allocate enough memory for the elements.
Here is a demonstrative program
#include <iostream>
#include <algorithm>
#include <iterator>
int main()
{
const size_t N1 = 11;
const size_t N2 = 2;
int * val = new int[N1] { 1, 1, 2, 2, 2, 2, 3, 4, 5, 5, 5 };
int * invalid = new int[N2] { 2, 5 };
int *valid = nullptr;
auto n = std::count_if( val, val + N1,
[=]( int x ) { return !std::binary_search( invalid, invalid + N2, x ); } );
if ( n )
{
valid = new int[n];
std::copy_if( val, val + N1, valid,
[=]( int x ) { return !std::binary_search( invalid, invalid + N2, x ); } );
}
if ( valid ) std::copy( valid, valid + n, std::ostream_iterator<int>( std::cout, " " ) );
std::cout << std::endl;
return 0;
}
Its output is
1 1 3 4
You can use standard algorithm std::binary search if the invalid array has many elements or you can just write the lambda expression like
[=]( int x ) { return x != invalid[0] && x != invalid[1]; }
For example
#include <iostream>
#include <algorithm>
#include <iterator>
int main()
{
const size_t N1 = 11;
const size_t N2 = 2;
int * val = new int[N1] { 1, 1, 2, 2, 2, 2, 3, 4, 5, 5, 5 };
int * invalid = new int[N2] { 2, 5 };
int *valid = nullptr;
auto is_valid_element = [=]( int x ) { return x != invalid[0] && x != invalid[1]; };
auto n = std::count_if( val, val + N1, is_valid_element );
if ( n )
{
valid = new int[n];
std::copy_if( val, val + N1, valid, is_valid_element );
}
if ( valid ) std::copy( valid, valid + n, std::ostream_iterator<int>( std::cout, " " ) );
std::cout << std::endl;
return 0;
}
The compiler should support C++ 2011.

Answer 3

#include <iostream>
const int SIZE_1 = 11;
const int SIZE_2 = 2;
/*find out if item should be exclude from result array; this take linear time over the size of the invalids array*/
bool doNotInclude(int item, int invalids[], int size)
{
bool remove = false;
for(int i = 0; i < size; i++)
{
if(invalids[i] == item)
{
remove = true;
}
}
return remove;
}
int main() {
//array of values
int * val = new int[SIZE_1] { 1, 5, 2, 2, 2, 2, 3, 4, 1, 5, 5 };
//values to ignore
int * invalid = new int[SIZE_2] { 2, 5 };
//result array
int *valid = new int[SIZE_1];
//keep track of result array current index/ size
int currentIndex = 0;
/*check if elements of input array are in invalids, if not put them in the result array*/
for(int i = 0; i < SIZE_1; i++)
{
if(!doNotInclude(val[i], invalid, SIZE_2))
{
valid[currentIndex] = val[i];
currentIndex++;
}
}
//print result
//currentIndex is now the size of the valid array
for(int n = 0; n < currentIndex; n++)
{
std::cout << valid[n] << ' ';
}
}
This method of doing it is O(N*M) whether the arrays are sorted or not.

Answer 4

Conceptually, an algorithm like this pseudo-code:
int i, j;
j = 0;
for (i=0; i < length(val); i++) {
if (val[i] != VALUE_TO_DELETE) {
val[j++] = val[i];
}
}
... now discard, or ignore, anything in "val" beyond element #j.
We simply iterate through the array, copying anything that is not the value we want to get rid of. i is the cursor used to find values, and j says where to put them.
Values beyond element #j are still there, physically, but you ignore them.
For the sake of completeness, if we are looking for invalid numbers:
int i, j, k;
boolean delete_me;
j = 0;
for (i=0; i < length(val); i++) {
// search the "invalid" list to see if the number is in it
delete_me = false;
for (k = 0; k < length(invalid); k++) {
if (val[i] == invalid[k]) {
delete_me = true;
break; // quit the loop as soon as we know ...
}
}
// copy what is NOT in it
if (!delete_me) { // notice: "if NOT" ...
val[j++] = val[i];
}
}