Se me paso lo de la entrada por argumento XD
Editado...

#include <iostream>
 
using std::cout;
using std::endl;
 
int getNum(char* text)
{
    int a=0, cont=0;
    while(text[cont])
    {
        a *= 10;
        a += text[cont++] - '0';
    }
    return a;
}
 
int main(int argc, char** argv)
{
    int num;
    num = getNum(argv[1]);
    for(int i=2;i<=num/2;i++)
        if(!(num%i))
        {
            cout << "No es primo" << endl;
            return 0;
        }
    cout << "Es primo" << endl;
    return 0;
}
 

Reto #2
Realiza un programa que dado un numero n te imprima todas las posibles permutaciones del conjunto 1 a n ordenadas de menor a mayor.

Ejemplo 1:

Entrada

Salida

Ejemplo 2:

Entrada

Salida

#include <iostream>
 
using std::cin;
using std::cout;
using std::endl;
 
int main(void)
{
    int N;
    cin >> N;
    for(int i=0;i<N;i++)
    {
        for(int g=0; g<=i; g++)
            cout << g+1 << " ";
        for(int g=i; g<N; g++)
            cout << 0 << " ";
        cout << endl;
    }
    return 0;
}
 

Reto #4

Dadas las denominaciones de monedas que tienen disponibles y una cantidad de dinero que tienen que dar de cambio con esas denominaciones de monedas (supongan que tienen una infinidad de monedas de cada denominacion y que siempre tienen monedas de $1) escriban un programa que regrese la cantidad MINIMA de monedas necesarias para regresar ese cambio, por ejemplo:

{$1, $2, $5} y cambio de $9
la cantidad minima de monedas es 3 ($5 + $2 + $2 = $9)

{$1, $5, $7} y cambio de $10
la cantidad minima de monedas es 2 ($5 + $5 = $10)

por cierto, te puedo pedir el cambio de $3000 xD

una ves que hagan este problema, muchos se darán cuenta de lo hermosa que es la resolución que le da nuestro cerebro a las cosas.

#include <iostream>
#include <cstdlib>
using std::cin;
using std::cout;
using std::endl;
bool isperfect(const unsigned int& n)
{
    unsigned int suma = 0;
    for(register unsigned int i = 1; i < n; i++)
    if(!(n % i))
    suma += i;
    return(suma == n);
}
int main(int argc, char **argv)
{
    if(argc != 2)
        exit(EXIT_FAILURE);
    for(register unsigned int i = 1; i <= atoi(*(argv + 1)); i++)
    if(isperfect(i) && (i < atoi(*(argv + 1))))
    cout << i << endl;
    return 0;
}

Reto:

Recorrer una matriz bidimensional con un puntero, con recorrer me refiero a mostrar cada uno de sus valores, no me refiero a indexación, sino a mostrar los valores usando aritmética de punteros.

Sí, jaja, es por eso que aún no respondemos :p

Tal ves me di a malentender. En si no seria un reto si se usara el sistema de monedas que usamos cotidianamente, por que simplemente vas quitando la mayor denominación hasta que no puedas mas y empezar con la siguiente y asi sucesivamente, por eso lo del cambio de denominaciones.

limitare un poco el problema, supondríamos que solo existen tres tipos de moneda:
un peso, 5 pesos y 7 pesos nada mas.

ahora has el mismo problema y veras por que empieza a agarrar complejidad XD

el problema sera solo saber cual es el mínimo de monedas para llegar a un numero.

---

Bueno, con el de Leo:

#include <iostream>
 
using namespace std;
 
int main(void)
{
    int mat[5][5];
    for(int i=0; i<5; i++)
        for(int g=0; g<5;g++)
            mat[i][g] = i*g;
    int* a = mat[0];
    for(int i=0;i<25;i++)
    {
        if(!(i%5))
            cout << endl;
        cout << *a++ << " ";
    }
}

te refieres a algo asi?

Buenas, yo me apunto a los retos, alguien puede decirme cuales estan resueltos y cuales no? (aunque los acabaré haciendo todos xD)

Para el de las monedas, el problema surge en que el algoritmo greedy de ir cogiendo siempre las monedas más grandes no minimiza la cantidad de monedas, como se puede ver en el primer ejemplo que se ha puesto.

Una posible solución correcta pero muy ineficiente sería un backtracking probando todas las posibles maneras. Una forma mejor, que dejo a continuación, sería usando programación dinámica, quedando entonces una complejidad polinómica, en concreto O(np), donde n es el número de monedas y p la cantidad. Quizá me haya equivocado en algo, pero creo que es correcto.

#include <iostream>
#include <vector>
using namespace std;
 
const int INF = 1000000000;
 
int dp(int p, vector<int>& M, vector<int>& v) {
    if (p < 0) return INF;
    if (p == 0) return 0; //Caso base
    if (M[p] == -1) {
        M[p] = INF;
        for (int i = 0; i < v.size(); ++i) 
            M[p] = min(M[p], 1 + dp(p - v[i], M, v));
    }
    return M[p];
}
 
int main() {
    int n, p;
    cin >> n;
    vector<int> v(n);
    for (int i = 0; i < n; ++i) cin >> v[i]; //Lectura de las monedas
    cin >> p;
    vector<int> M(p + 1, -1); //Tabla para la dinamica
    cout << dp(p, M, v) << endl;
}