Из массива в массив перенести числа (элементы массива)

#include <string>
#include <iostream>
#include <sstream>
#include <time.h>
#include <stdlib.h>
int main( ) {
    int JJ[100], NN[100];
    std::stringstream ss;
    srand( time( NULL ) );
    std::cout << "JJ array:\n";
    for ( size_t i = 0; i < 100; std::cout << ( JJ[i] = rand( ) % 100 ) << ( ( i + 1 ) % 10 == 0 && i > 0 ? "\n" : "\t" ), ++i );
    std::cout << "\nNN array:\n";
    for ( size_t i = 0, pass = 1, j = 0; i < 100;
        std::cout << ( ( pass > 0 ? ( JJ[i] % 2 ) > 0 : ( JJ[i] % 2 ) == 0 ) ? ( ( std::stringstream & )( ss << ( NN[j] = JJ[i] ) ) ).str( ) : std::string( "" ) ),
        std::cout << ( ( NN[j] == JJ[i] ? ++j : 7 ) % 10 == 0 && j > 0 ? "\n" : "" ) << ( NN[j] == JJ[i] && ( j + 1 ) % 10 != 0 ? "\t" : "" ),
        ++i, ss.str( "" ), ( i == 100 && pass > 0 ) ? i = pass = 0 : 0 );
    system( "pause" );
    return 0;
}

bool myFunc (int n)
{
    return n % 2 != 0;
}
 
// ...
    std::copy(std::begin(JJ), std::end(JJ), std::begin(NN));
    std::stable_partition(NN, NN + 100, myFunc); // Делает то, что нужно по заданию

#include <cstdio>
#include <ctime>
 
#include <iostream>
#include <iomanip>
#include <algorithm>
 
const int SIZE = 100;
 
int main ( ) {
  int JJ[SIZE], NN[SIZE];
  srand(time(NULL));
 
  std::generate( std::begin(JJ), std::end(JJ), [] () {
      return rand() % 10000;
  });
 
  std::copy( std::begin(JJ), std::end(JJ), std::begin(NN) );
  std::stable_partition( std::begin(NN), std::end(NN), [] (int item) {
    return item % 2 == 0;
  });
 
  int count = 0;
 
  std::for_each( std::begin(NN), std::end(NN), [&count] (int item) mutable {
    std::cout << std::right << std::setw(8) << item;
    if (count % 10 == 9) std::cout << std::endl;
    ++count;
  });
  return 0;
}

#include <cstdio>
#include <ctime>
 
#include <iostream>
#include <iomanip>
#include <algorithm>
 
const int SIZE = 100;
 
class printer {
  std::ostream *out;
  int max_count, width;
 
  int count;
  public:
    printer(std::ostream& out, int max_count, int width) : out(&out), max_count(max_count), width(width), count(0) {}
 
    template<class data>
    void operator () (data val) {
      *out << std::right << std::setw(width) << val;
      if (count % max_count == max_count - 1) *out << std::endl;
      ++count; 
    }
};
 
int main ( ) {
  int JJ[SIZE], NN[SIZE];
  srand(time(NULL));
 
  std::generate( std::begin(JJ), std::end(JJ), [] () {
      return rand() % 10000;
  });
 
  std::copy( std::begin(JJ), std::end(JJ), std::begin(NN) );
  std::stable_partition( std::begin(NN), std::end(NN), [] (int item) {
    return item % 2 == 0;
  });
 
  printer main_printer(std::cout, 10, 8);
 
  std::for_each( std::begin(NN), std::end(NN), main_printer);
  return 0;
}

  std::stable_partition( std::begin(NN), std::end(NN), [] (int item) {
    return item % 2 != 0;
  });

#include <cstdio>
#include <ctime>
#include <cstdlib>
 
int main ( ) {
  const int SIZE = 100;
  int JJ[SIZE], NN[SIZE];
  srand(time(NULL));
 
  // Заполняем JJ
  for (int i = 0; i < SIZE; ++i) {
    JJ[i] = rand() % 10000;
  }
 
  int cursor = 0;
  // Переносим нечётные в NN
  for (int i = 0; i < SIZE; ++i) {
    if (JJ[i] % 2 != 0) {
      NN[cursor] = JJ[i];
      ++cursor;
    }
  }
 
  // Переносим чётные в NN
  for (int i = 0; i < SIZE; ++i) {
    if (JJ[i] % 2 == 0) {
      NN[cursor] = JJ[i];
      ++cursor;
    }
  }
 
  // Выводим
  for (int i = 0; i < SIZE; ++i) {
    printf("%8i", NN[i]);
    if (i % 10 == 9) printf("\n");
  }
 
 
  return 0;
}

#pragma hdrstop
#pragma argsused
 
#include <tchar.h>
#include <stdio.h>
#include <conio.h>
 
#include <iostream>
#include <iomanip>;
#include <algorithm>
#include <iterator>
 
bool myFunc(int n)
{
    return n % 2 != 0;
}
 
void print_arr(int *arr)
{
    for (int i = 0; i < 10; i++)
    {
        for (int j = 0; j < 10; j++)
            std::cout << std::setw(5) << arr[10 * i + j];
        std::cout << "\n";
    }
}
 
int _tmain(int argc, _TCHAR* argv[])
{
    srand(time(0));
 
    const int arr_size = 100;
    int JJ[arr_size], NN[arr_size];
 
    for (size_t i = 0; i < arr_size; i++) JJ[i] = rand() % 100;
 
    std::cout << "JJ:\n"; print_arr(JJ);
 
    std::copy(JJ, JJ + arr_size, NN);
    std::stable_partition(NN, NN + arr_size, myFunc); // Делает то, что нужно по заданию
 
    std::cout << "NN:\n"; print_arr(NN);
    getch();
 
    return 0;
}

#include <cstdio>
#include <ctime>
#include <cstdlib>
 
int main ( ) {
  const int SIZE = 100;
  int JJ[SIZE], NN[SIZE];
  srand(time(NULL));
 
   for (int i = 0; i < SIZE; ++i) {
    JJ[i] = rand() % 100;
  }
 
  int cursor = 0;
   for (int i = 0; i < SIZE; ++i) {
    if (JJ[i] % 2 != 0) {
      NN[cursor] = JJ[i];
      ++cursor;
    }
  }
 
  for (int i = 0; i < SIZE; ++i) {
    if (JJ[i] % 2 == 0) {
      NN[cursor] = JJ[i];
      ++cursor;
    }
  }
  
   for (int i = 0; i < SIZE; ++i) {
    printf("%8i", NN[i]);
    if (i % 10 == 9) printf("\n");
  }
 
 
  return 0;
}