将元素从一个数组复制到另一个C ++

Question

I have looked and looked and am still lost on how to copy or get elements from an array and put them into new arrays ( divide and conquer is the goal).

I have an array that generates 100 random numbers. I need to split the random numbers into 4 smaller arrays obviously containing 25 elements and not have any duplicates. I have read about using pointers, but honestly I don't understand why even use a pointer. Why do I care about another variables address?

I don't know how to do this. Here is my code so far:

#include <iostream>
#include <time.h>
#include <stdlib.h>

using namespace std;


int main()
{
  // Seed the random number generator

  srand(time(NULL));

  //create an array to store our random numbers in

  int Orignumbers[100]    = {};
  // Arrays for the divide and conquer method
  int NumbersA   [25]     = {};
  int NumbersB   [25]     = {};
  int NumbersC   [25]     = {};
  int NumbersD   [25]     = {};


  //Generate the random numbers
  for(int i =0; i < 100; i++)
  {
    int SomeRandomNumber = rand() % 100 + 1;

  // Throw random number into the array

  Orignumbers[i] = SomeRandomNumber;

  }

//  for(int i = 0; i < ) started the for loop for the other arrays, this is where I am stuck!!

  // Print out the random numbers
  for(int i = 0; i < 100; i++)
  {
    cout << Orignumbers[i] << " , ";
  }

}

Answer 1

"divide and conquer" is rather easy; when copying into NumbersA and so forth, you just have to access your Originnumbers with a proper offset, ie 0 , 25 , 50 , and 75 :

for(int i = 0; i < 25; i++) {
    NumbersA[i] = Orignumbers[i];
    NumbersB[i] = Orignumbers[i+25];
    NumbersC[i] = Orignumbers[i+50];
    NumbersD[i] = Orignumbers[i+75];
}

The thing about "no duplicates" is a little bit more tricky. Generating a random sequence of unique numbers is usually solved through "shuffling". Standard library provides functions for that:

#include <random>
#include <algorithm>
#include <iterator>
#include <vector>

int main()
{
    std::random_device rd;
    std::mt19937 g(rd());

    int Orignumbers[100];

    //Generate the random numbers without duplicates
    for(int i =0; i < 100; i++) {
        Orignumbers[i] = i+1;
    }
    std::shuffle(Orignumbers, Orignumbers+100, g);

    // Arrays for the divide and conquer method
    int NumbersA   [25]     = {};
    int NumbersB   [25]     = {};
    int NumbersC   [25]     = {};
    int NumbersD   [25]     = {};


    for(int i = 0; i < 25; i++) {
        NumbersA[i] = Orignumbers[i];
        NumbersB[i] = Orignumbers[i+25];
        NumbersC[i] = Orignumbers[i+50];
        NumbersD[i] = Orignumbers[i+75];
    }

    // Print out the random numbers
    for(int i = 0; i < 100; i++)
    {
        cout << Orignumbers[i] << " , ";
    }

}

Answer 2

As you tagged your question with C++ then forget about old-fashion arrays, let's do it C++ style. You want to split your array into 4 arrays and they should not have duplicate numbers , so you can't have a number 5 times in your original array, because then surely one of your 4 arrays will have a duplicate one, So here is the way I propose to do it :

#include <set>
#include <ctime>
#include <vector>

int main() {
    std::multiset<int> allNums;
    std::srand(unsigned(std::time(0)));

    for (int i = 0; i < 100; ++i) {
        int SomeRandomNumber = std::rand() % 100 + 1;
        if (allNums.count(SomeRandomNumber) < 4) {
            allNums.insert(SomeRandomNumber);
        }
        else {
            --i;
        }
    }
    std::vector<int> vOne, vTwo, vThree, vFour;
    for (auto iter = allNums.begin(); iter != allNums.end(); ++iter) {
        vOne.push_back(*iter);
        ++iter;
        vTwo.push_back(*iter);
        ++iter;
        vThree.push_back(*iter);
        ++iter;
        vFour.push_back(*iter);
    }
    system("pause");
    return 0;
}

EDIT : As you mentioned in the comments, you just want to find a number in an array, so how about this :

for (int i = 0; i < 100; ++i) {
    if (origArray[i] == magicNumber) {
        cout << "magicNumber founded in index " << i << "of origArray";
    }
}

Answer 3

Problem:

The program can't be guaranteed to have no duplicate value as the rand() function can generate any random sequence and that may include the decimal value of 99 for 99 times though probability is very low but chances are .
Example:

for(loop=0; loop<9; loop++) 
printf("%d", Rand()%10);

If looped for 10 times, it may result some values like:

  Output: 6,1,1,1,2,9,1,3,6,9
  Compiled Successfully:

Hence, no certainity that values won't repeat

Possibly Solution:

There could be a solution where you can place the values in OriginalArray and compare the rand() generate values against the OriginalArray values. For first iteration of loop, you can directly assign value to OriginalArray then from 2nd iteration of loop you've to compare rand() value against OriginalArray but insertion time consumption may be higher than O(N ^N ) as rand() function may repeat values.

Possibly Solution:

 #include <iostream>
 #include <time.h>
 #include <stdlib.h>
 using namespace std;
 int main()
 {
   int Orignumbers[100] ;

  int NumbersA [25] ,
    NumbersB [25] , 
    NumbersC [25] , 
    NumbersD [25] ;
    srand(time(NULL));

   for(int i =0; i < 100; i++){
    Orignumbers[i] = rand() % 100+1; 
   for(int loop=0; loop<i; loop++) {
       if(Orignumber[loop] == Orignumber[i] ) {
           i--;
           break;
        }
     }
  }

    //Placing in four different arrays thats maybe needed.
    for(int i = 0; i <25; i++ ) {
    NumbersA[i] = Orignumbers[i];
    NumbersB[i] = Orignumbers[i+25];
    NumbersC[i] = Orignumbers[i+50];
    NumbersD[i] = Orignumbers[i+75];
    } 

    for(int i = 0; i < 99; i++)
    cout << Orignumbers[i] << " , ";
    }

Answer 4

On some situations, even on C++, the use of arrays might be preferable than vectors, for example, when dealing with multidimensional arrays (2D, 3D, etc) that needs to be continuous and ordered on the memory. (eg later access by other applications or faster exporting to file using formats such as HDF5.)

Like Jesper pointed out, you may use Copy and I would add MemCopy to copy the content of an array or memory block into another.

Don't underestimate the importance of pointers, they may solve your problem without the need doing any copy. A bit like Stephan solution but without the need of the index variable "i", just having the pointers initialized at different places on the array. For a very large number of elements, such strategy will save some relevant processing time.