¿Comor?

¿Y si cojo un elemento del principio? ¿No puede adceder a los finales?

Quiero ver una implementación ^^

Pues revisalo porque he vuelto a copypastear tu código y me lo hace bien

De hecho, incluso lo he hecho con strings y he comparado salidas. Son identicas:

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cctype>
#include <string>
using namespace std;
 
class EsBlanco
{
public:
    bool operator() (const char& c) const
    {
        return std::isspace(c);
    }
};
 
int main()
{
    string s = "4539 4512 0398 7356";
    string b = s;
 
    char *letras = new char [s.length() + 1];
    strcpy (letras, s.c_str());
 
    char * inicio = letras;
    char * fin = letras + s.length();
 
    fin = std::remove_if(inicio,fin,EsBlanco()); // metodo por char*
    b = string(s.begin(),std::remove_if(s.begin(),s.end(),EsBlanco())); // metodo por strings
 
    *fin = 0; // caracter nulo
 
    string a = inicio;
 
    if (a == b) cout<<"Funciono!"<<endl;
    else cout<<"No funciono! :("<<endl;
 
    cout<<b<<endl;
    for (char * p = inicio; p != fin; ++p)
        cout  << *p;
    return 0;
}

Ambos metodos me generan la misma salida. No consigo generar tu error...

¿Y después lo vuelves a copiar en el array original?

Pero estás duplicando el array así... Para eso intercambias y ya esta.

Por supuesto, pero siempre se busca la máxima eficiencia.

Suponte un servidor de poker con millones de usuarios, dado que tienes que hacer millones de mezclas conviene perder el menor tiempo posible.

Y confiar en el "azar" no suele ser muy buena práctica. Es una buena costumbre garantizar que el algoritmo termine en tiempo finito incluso en el peor caso posible, nos ayudará a evitarnos algunos errores "oscuros".

Como curiosidad de algoritmos basados en el azar, tenemos un algoritmo de ordenación que usa una técnica similar: El bogosort (o stupidsort). Que viene a ser el siguiente:

Dado un conjunto de números desordenados:
     1º Comprobar que esten ordenados, si lo estan termina.
     2º Mezclar los numeros aleatoriamente.

Y aquí una implementación de este algoritmo en C++:

#include <iostream>
#include <algorithm>
#include <ctime>
#include <iterator>
using namespace std;
 
void bogo_sort(vector<int>&);
 
int main()
{
    vector<int> Numeros;
    srand(time(NULL));
    int N;
 
    cout<<"Introduzca numero de elementos a ordenar: ";
    cin>>N;
 
    Numeros.resize(N);
 
    for (int i = 0; i < 10;i++) // 10 intentos
    {
        generate(Numeros.begin(),Numeros.end(),rand); // relleno el vector de numeros aleatorios
 
          // Muestra los numeros generados por pantalla:
//        copy(Numeros.begin(),Numeros.end(), ostream_iterator<int>(cout, " ")); 
 
        time_t inicio = clock();
 
        bogo_sort(Numeros);
 
        time_t fin = clock();
 
        cout<<(double)(fin-inicio)/(CLOCKS_PER_SEC)<<"s en ordenar "<<N<<" elementos"<<endl;
 
        // muestra los numeros ordenados por pantalla
//        copy(Numeros.begin(),Numeros.end(), ostream_iterator<int>(cout, " "));
 
       // cout<<endl;
    }
    return 0;
}
 
bool enOrden(vector<int> &x) {return adjacent_find(x.begin(), x.end(), greater<int>()) == x.end();}
 
void bogo_sort(vector<int> &Numeros)
{
    while (!enOrden(Numeros))
    {
        random_shuffle(Numeros.begin(),Numeros.end());
    }
}
 

Dile que genere 10 elementos. A mí los tiempos me salen muy dispares (desde 0,063 hasta 5 segundos). Eso en rangos pequeños, cuanto mayor sea el rango, mayor será la dispersión.

En resumen, trabajar basado en la suerte nos da unos programas muy impredecibles y inestables. A mí personalmente no me gusta nada

No hace falta crear una clase para eso. Puedes hacerlo en una función directamente (Y para un char no hace falta una referencia):

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cctype>
#include <string>
using namespace std;
 
bool EsBlanco(const char c)
{
    return std::isspace(c);
}
 
int main()
{
    string s = "4539 4512 0398 7356";
    char *letras = new char [s.length() + 1];
    strcpy (letras, s.c_str());
 
    char * inicio = letras;
    char * fin = letras + s.length();
 
    fin = std::remove_if(inicio,fin,EsBlanco);
 
    for (char * p = inicio; p != fin; ++p)
        cout  << *p;
    return 0;
}
 

En cuanto al error, a mí me imprime el resultado correcto

De todas formas no entiendo porque usas char*. Con lo facil que sería hacerlo en el mismo string:

string s = "4539 4512 0398 7356";
remove_if(s.begin(),s.end(),EsBlanco);
 
cout<<s<<endl;

Tienes razón Rir, que fallo más tonto

De todas formas, no me gusta ese modo de barajar como ya dije. Me parece mas natural de este modo:

1º Te generas el mazo ordenado.
2º Coges dos elementos al azar y los intercambias
3º Repites el paso 2 tantas veces como creas necesario. Para un mazo tienes de sobra con 1000 iteraciones.

De hecho en C++ (que no C) puedes hacer los dos ultimos pasos en un sola función:
http://www.cplusplus.com/reference/algorithm/random_shuffle/

Esa funcion da problemas, es muy probable que el mazo generado tenga 2 cartas identicas.

Lo ideal esque generes el mazo ordenado y luego hagas intercambios aleatorios.

En cuanto a la pregunta, el primer corchete es opcional. Puedes ponerlo o no, el segundo corchete es necesario para que el compilador traduzca los dos [][] en uno solo.

Pues porque en el primer caso, el retorno que has puesto en primo no tiene sentido. Además tampoco lo compruebas ni nada.

Lo ideal esque devuelvas un 1 si es primo y 0 si no lo es. Después lo compruebas con un if y listo:

for(x = 1; x <= 100; x++)
    if (primo(x)) printf("%d\n",x);

Por cierto sobre los numeros primos:
http://foro.elhacker.net/programacion_cc/codigo_para_calcular_los_numeros_primos-t405451.0.html

Eso es porque lo estas probando desde el codeblocks.

Prueba a ejecutar el exe directamente.

  int a[n];
 
      printf("\n");
 
           for(i=0; i<n; i++){
               a=(rand()%(max-min)+min+1);

Aclarate, a es una variable o un arreglo?

Sobre los numeros primos:
http://foro.elhacker.net/programacion_cc/codigo_para_calcular_los_numeros_primos-t405451.0.html