SUDOKU (No se el numero de reto...)

Ya esta.

/*
 * Linea de comandos: Nombre programa fichero
 *
 * El fichero debe tener el siguiente formato:
 *  - 9 filas con 9 numeros separados por espacios
 *  - Los numeros que vengan dados en el sudoku se escribiran en la posicion que corresponde
 *  - Las casillas vacias del sudoku se indicaran con ceros
 *  - Todas las filas deben acabar en un salto de linea
 *  - Cuanquier linea que siga a las 9 primeras sera ignorada.
 *
 *
 * Salida: Muestra como mucho 2 soluciones (las suficientes para que el contenido del fichero no sea un sudoku correcto)
 * y sino indica que no hay solucion.
 *
 */
 
 
#include <iostream>
#include <cstdio>
#include <cstring>
 
using namespace std;
 
class Sudoku
{
    public:
        Sudoku();
 
        bool cargar(char *nombrefichero);
        bool solucionar();
        bool solucion_unica();
        inline bool esta_solucionado(){return solucionado;};
 
        friend ostream& operator <<(ostream &out,Sudoku &s);
 
    private:
 
        bool correcto(int fila, int columna, int valor);
        bool resolver(int fila, int columna);
        bool multiples_soluciones(int fila, int columna);
 
        int tabla[9][9];
        bool solucionado;
};
 
Sudoku::Sudoku()
{
    for(int i = 0 ; i < 81 ; i++)
        tabla[i / 9][i % 9] = 0;
 
    solucionado = false;
}
 
bool Sudoku::cargar(char *nombrefichero)
{
    int i;
    char fila[19]; //los 9 numeros + 8 espacios + 1 salto de linea + '\0';
    FILE *f;
 
    if(!(f = fopen(nombrefichero,"r")))
        return false;
 
    for(i = 0 ; i < 9 ; i++)
    {
        fgets(fila,19,f);
 
        if(strlen(fila) < 18 || fila[strlen(fila) - 1] != '\n') //formato incorrecto
        {
            for(int j = 0 ; j < i ; i++) //anulamos la lectura que habia hasta el momento
                memset(tabla[j] , 0 , 9 * sizeof(int));
 
            fclose(f);
 
            return false;
        }
 
        for(int j = 0 ; j < 9 ; j++)
        {
            if(fila[2 * i] < '0' || fila[2 * i] > '9')//Si las posiciones pares no son un numero
            {
                for(int k = 0 ; k < i ; k++) //anulamos la lectura que habia hasta el momento
                    memset(tabla[k],0,9*sizeof(int));
 
                fclose(f);
 
                return false;
            }
 
            if(fila[2 * i + 1] != ' ' && fila[2 * i + 1] != '\n')//Si las posiciones impares no son ni espacio ni \n
            {
                for(int k = 0 ; k < i ; k++) //anulamos la lectura que habia hasta el momento
                    memset(tabla[k],0,9*sizeof(int));
 
                fclose(f);
 
                return false;
            }
        }
 
        //traducimos la fila para el algoritmo
        for(int j = 0 ; j < 9 ; j++)
            tabla[i][j] = fila[2 * j] - '0';
    }
 
    fclose(f);
 
    return true;
}
 
bool Sudoku::solucionar()
{
    return resolver(0,0);
}
 
bool Sudoku::solucion_unica()
{
    return !multiples_soluciones(0,0);
}
 
bool Sudoku::correcto(int fila, int columna, int valor)
{
    for(int i = 0 ; i < 9 ; i++)
    {
        if(tabla[i][columna] == valor)
            return false;
 
        if(tabla[fila][i] == valor)
            return false;
 
        if(tabla[3 * (fila / 3) + i / 3][3 * (columna / 3) + i % 3] == valor)
            return false;
    }
 
    return true;
}
 
bool Sudoku::resolver(int fila, int columna)
{
    if(fila == 9)
    {
        solucionado = true;
        return true;
    }
 
    if(tabla[fila][columna] != 0) //Si tenemos un numero original
    {
        if(resolver((9 * fila + columna + 1) / 9, (9 * fila + columna + 1) % 9)) //pasamos a resolver la siguiente posicion
            return true;
    }
    else
    {
        //probamos cada uno de los numeros
        for(int i = 1 ; i <= 9 ; i++)
        {
            if(correcto(fila,columna,i)) //Si es corrector en la posicion dada
            {
                tabla[fila][columna] = i; //Marcamos la casilla con el numero
 
                //Y pasamos a resolver la siguiente posicion
                if(resolver((9 * fila + columna + 1) / 9, (9 * fila + columna + 1) % 9))
                    return true;
            }
        }
 
        tabla[fila][columna] = 0; //Volvemos a dejar vacia la posicion actual
    }
 
    return false;
}
 
bool Sudoku::multiples_soluciones(int fila, int columna)
{
    if(fila == 9)
    {
        if(!solucionado)
        {
            cout << *this << endl;
            solucionado = true;
            return false;
        }
        cout << *this << endl;
        return true;
    }
 
    if(tabla[fila][columna] != 0) //Si tenemos un numero original
    {
        if(multiples_soluciones((9 * fila + columna + 1) / 9, (9 * fila + columna + 1) % 9)) //pasamos a resolver la siguiente posicion
            return true;
    }
    else
    {
        //probamos cada uno de los numeros
        for(int i = 1 ; i <= 9 ; i++)
        {
            if(correcto(fila,columna,i)) //Si es corrector en la posicion dada
            {
                tabla[fila][columna] = i; //Marcamos la casilla con el numero
 
                //Y pasamos a resolver la siguiente posicion
                if(multiples_soluciones((9 * fila + columna + 1) / 9, (9 * fila + columna + 1) % 9))
                    return true;
            }
        }
 
        tabla[fila][columna] = 0; //Volvemos a dejar vacia la posicion actual
    }
 
    return false;
}
 
ostream& operator <<(ostream &out,Sudoku &s)
{
    for(int i = 0 ; i < 9 ; i++)
    {
        if(!(i % 3))
            out << endl;
 
        for(int j = 0 ; j < 9 ; j++)
        {
            if(!(j % 3))
                out << ' ';
 
            out << s.tabla[i][j] << ' ';
        }
 
        out << endl;
    }
 
    return out;
}
 
int main(int argc, char *argv[])
{
    Sudoku sudoku;
 
    if(argc != 2)
    {
        cout << argv[0] << " fichero";
        return -1;
    }
 
    if(!sudoku.cargar(argv[1]))
    {
        cout << "Error en carga de fichero." << endl;
        return -1;
    }
 
    if(sudoku.solucion_unica() && sudoku.esta_solucionado())
    {
        cout << "El sudoku tiene una unica solucion:" << endl;
    }
    else if(sudoku.esta_solucionado())
        cout << "El fichero no contiene un sudoku correcto. Tiene mas de una solucion." << endl;
    else
        cout << "El sudoku no tiene solucion." << endl;
 
    return 0;
}
 

¡Buenas!

rand() te genera una sucesion de numeros pseudoaleatorios. Es decir, si la llamas sin haber llamado a srand() siempre te generara la misma secuencia de numeros.

srand() hace que esa secuencia empiece por otro numero de la sucesion. Por lo tanto, si a srand le pasas una constante, la secuencia de numeros que genera rand() sera distina (en principio) de la que genera sin haber llamado a srand, pero al haber inicializado srand la secuencia que generara rand a un valor constante (fijo), seguiran repitiendose los mismos valores en las mismas posiciones.

Para evitar que la sucesion de numeros aleatorios sea siempre la misma, puedes utilizar como semilla un valor mas o menos aleatorio, como por ejemplo el valor devuelto pot la funcion time (que se encuentra en time.h o ctime), con parametro NULL, que devuelve el numero de segundos que han pasado desde 1900 (o algun otro año, no lo se) hasta el momento en el que se ejecuta el programa. Asi, cada vez que ejecutes el programa este valor sera diferente, y por lo tanto la sucesion que generara rand() tambien sera distinta.

¡Saludos!

12.

//linea de comandos nombreprograma numero
//salida: un rombo de 2 * n - 1 lineas
 
#include <cstdio>
 
using namespace std;
 
unsigned int absoluto(int x)
{
    return (x < 0 ? -x : x);
}
 
int main(int argc, char *argv[])
{
    int n;
 
    if(argc != 2)
    {
        printf("%s numero\n",argv[0]);
        return -1;
    }
 
    for(int i = 0 ; argv[1][i] ; i++)
        if(argv[1][i] < '0' || argv[1][i] > '9')
        {
            printf("%s numero\n",argv[0]);
            return -1;
        }
 
    sscanf(argv[1],"%d",&n);
 
    for(int i = 0 ; i < 2 * n - 1 ; i++)
    {
        printf("%*s",absoluto(n - (i + 1)) + 1, " ");
 
        for(int j = 0 ; j < 2 * (n - 1 - (absoluto(n - 1 - i))) + 1 ; j++)
            printf("*");
 
        printf("\n");
    }
 
    return 0;
}
 

PD: He corregido el de las fechas, que habia un gran error.

¡Saludos!

EI: juntando mensajes.


El problema dice leer el contenido de un archivo. No que haya que mostrarlo por pantalla.

11. Lo he probado y me funciona. De todas formas no he probado todos los casos (es imposible, o me lo parece a mi). Si encontrais algun error en el codigo u os falla para alguna fecha avisad.

¡Saludos!

¡Ah! No he puesto muchos comentarios. Ahora repaso el codigo y añado los comentarios que crea que faltan para que el codigo sea claro o seguible.

¡Saludos!

#include <iostream>
#include <ctime>
 
#define bisiesto(X) (((!((X) % 4)) && ((X) % 100)) || ((!((X) % 100)) && (!((X) % 400))))
 
using namespace std;
 
class Fecha
{
    public:
        Fecha();
        Fecha(int dia, int mes, int año);
        Fecha(const Fecha &original);
 
        bool set(int dia, int mes, int año);
        bool setD(int dia);
        bool setM(int mes);
        bool setA(int año);
 
        int getD() const;
        int getM() const;
        int getA() const;
 
        //calcula la diferencia en dias entre la fehca mayo y la menor
        friend unsigned long dif(Fecha &f1, Fecha &f2);
 
        //compara fechas -1 si la primera es menor 0 si son iguales y 1 si la segunda es mayor
        friend int cmp(Fecha &f1, Fecha &f2);
 
    private:
 
        //calcula los dias hasta el año cero (si año < 0) o desde el año cero (si año >= 0)
        long int dias() const;
 
        int dia;
        int mes;
        int año;
};
 
Fecha::Fecha()
{
    //struct proporcionado por ctime para manejar fechas
    struct tm *fecha;
 
    //tipo de dato definido en ctime para manejar fechas
    time_t t;
 
    t = time(NULL);
 
    fecha = localtime(&t);
 
    dia = fecha->tm_mday;
    mes = fecha->tm_mon + 1; //0 <= tm_mon <= 11
    año = fecha->tm_year + 1900; //tm_year es medido desde 1900
}
 
Fecha::Fecha(int d, int m, int a)
{
    int dias[] = {31,28,31,30,31,30,31,31,30,31,30,31};
 
    año = a;
 
    if(m < 1 || m > 12)
        m = 1;
 
    if(m == 2)
    {
        if(d > 29)
            d = 1;
        if(d == 29 && !bisiesto(año))
            d = 1;
    }
    else
        if(d > dias[m - 1])
            d = 1;
 
    mes = m;
    dia = d;
}
 
Fecha::Fecha(const Fecha &original)
{
    this->dia = original.dia;
    this->mes = original.mes;
    this->año = original.año;
}
 
bool Fecha::set(int d, int m, int a)
{
    //copia miembro a miembro (no hay problemas ya que no hay punteros)
    *this = Fecha(d,m,a);
 
    return true;
}
 
bool Fecha::setD(int d)
{
    int diasmes[] = {31,28,31,30,31,30,31,31,30,31,30,31};
 
    if(d < 1)
        return false;
 
    if(mes == 2)
    {
        if(d > 29)
            return false;
 
        if(d == 29 && !bisiesto(año))
            return false;
    }
    else
        if(d > diasmes[mes - 1])
            return false;
 
    dia = d;
 
    return true;
}
 
bool Fecha::setM(int m)
{
    int diasmes[] = {31,28,31,30,31,30,31,31,30,31,30,31};
 
    if(m < 1 || m > 12)
        return false;
 
    if(m == 2)
    {
        if(dia > 29)
            return false;
 
        if(dia == 29 && !bisiesto(año))
            return false;
    }
    else
        if(dia > diasmes[m - 1])
            return false;
 
    mes = m;
 
    return true;
}
 
bool Fecha::setA(int a)
{
    if(mes == 2 && dia == 29 && !bisiesto(a))
        return false;
 
    año = a;
 
    return true;
}
 
int Fecha::getD() const
{
    return dia;
}
 
int Fecha::getM() const
{
    return mes;
}
 
int Fecha::getA() const
{
    return año;
}
 
unsigned long dif(Fecha &f1, Fecha &f2)
{
    //si la primera fecha es menor devolvemos la diferencia evaluada en orden inverso
    if(cmp(f1,f2) < 0)
        return dif(f2,f1);
 
    return f1.dias() - f2.dias();
}
 
long int Fecha::dias() const
{
    int diasmes[] = {31,28,31,30,31,30,31,31,30,31,30,31};
    unsigned long ndias = 0;
 
    //pasamos la fecha a dias desde el año cero o hasta el año cero:
    ndias = 365 * año;
 
    for(int i = 0 ; i < mes ; i++)
        ndias += diasmes[i];
 
    ndias += dia;
 
    //arreglamos los bisiestos:
    if(año < 0)
    {
        if(mes > 2 || (mes == 2 && dia == 29))
        {
            for(int i = año + 1 ; i < 0 ; i++)
                if(bisiesto(i))
                    ndias++;
        }
        else
        {
            for(int i = año ; i < 0 ; i++)
                if(bisiesto(i))
                    ndias++;
        }
    }
    else
    {
        if(mes > 2)
        {
            for(int i = año ; i >= 0 ; i--)
                if(bisiesto(i))
                    ndias++;
        }
        else
        {
            for(int i = año - 1 ; i >= 0 ; i--)
                if(bisiesto(i))
                    ndias++;
        }
    }
 
    return ndias;
}
 
int cmp(Fecha &f1,Fecha &f2)
{
    if(f1.año < f2.año)
        return -1;
 
    if(f1.año > f2.año)
        return 1;
 
    if(f1.mes < f2.mes)
        return -1;
 
    if(f1.mes > f2.mes)
        return 1;
 
    if(f1.dia < f2.dia)
        return -1;
 
    if(f1.dia > f2.dia)
        return 1;
 
    return 0;
}
 
void leer_datos_cumpleanios(Fecha &cumpleanios)
{
    int dia,mes,año;
 
    //ponemos el dia a uno para evitar errores estableciendo el mes
    cumpleanios.setD(1);
 
    cout << "Introducir a" << (char)164 << "o de nacimiento: ";
    cin >> año;
 
    //si el primer caracter no es numerico no se leeran datos y cin dara error
    while(cin.fail())
    {
        //reseteamos los flags de cin
        cin.clear();
 
        //y terminamos de leer los datos de la entrada
        while(cin.get() != '\n');
 
        cout << "Introducir a" << (char)164 << "o de nacimiento: ";
        cin >> año;
    }
 
    //terminamos de leer los datos de la entrada
    while(cin.get() != '\n');
 
    cumpleanios.setA(año);
 
    do{
        cout << "Introducir mes de nacimiento (1 - 12): ";
        cin >> mes;
 
        while(cin.fail())
        {
            cin.clear();
 
            while(cin.get() != '\n');
 
            cout << "Introducir mes de nacimiento (1 - 12): ";
            cin >> mes;
        }
 
        while(cin.get() != '\n');
 
    }while(!cumpleanios.setM(mes));
 
    do{
        cout << "Introducir dia de nacimiento: ";
        cin >> dia;
 
        while(cin.fail())
        {
            cin.clear();
 
            while(cin.get() != '\n');
 
            cout << "Introducir dia de nacimiento: ";
            cin >> dia;
        }
 
        while(cin.get() != '\n');
 
    }while(!cumpleanios.setD(dia));
}
 
//se trata de ajustar los datos de la fecha de nacimiento al siguiente cumpleaños
void ajustar_datos_cumpleanios(Fecha &cumpleanios)
{
    Fecha actual;
 
    //si el mes del cumpleaños es menor que el actual, hay que pasar al año siguiente
    if(cumpleanios.getM() < actual.getM())
    {
        if(cumpleanios.getM() == 2 && cumpleanios.getD() == 29 && !bisiesto(actual.getA() + 1))
        {
            cumpleanios.set(1,3,actual.getA() + 1);
        }
        else
        {
            cumpleanios.setA(actual.getA() + 1);
        }
    }
    if(cumpleanios.getM() == actual.getM())
    {
        //Si el mes del cumpleaños es el mismo que el actual y el dia es menor que el actual, hay que pasar al año siguiente
        if(cumpleanios.getD() < actual.getD()) //no hay problemas con bisiestos
            cumpleanios.setA(actual.getA() + 1);
        else //en otro caso aun no se ha superado la fecha de cumpleaños en el año actual
            cumpleanios.setA(actual.getA());
 
    }
    else//en otro caso aun no se ha superado la fecha de cumpleaños en el año actual
        cumpleanios.setA(actual.getA());
 
}
 
int main(int argc, char *argv[])
{
    int diasmes[] = {31,28,31,30,31,30,31,31,30,31,30,31};
    Fecha actual,cumpleanios;
    unsigned long diferencia;
 
    leer_datos_cumpleanios(cumpleanios);
    ajustar_datos_cumpleanios(cumpleanios);
 
    diferencia = dif(actual,cumpleanios);
 
    cout << "Faltan " ;
 
    int contador = 0;
 
    //vamos contando los meses considerando que pasa un mes al pasar tantos dias como tenga el mes que consideramos
    //ej: de enero a febrero 1 mes es que pasen 31 dias, de febrero a marzo 28 ...
    for(int i = actual.getM() - 1 ; diferencia >= diasmes[i % 12] ; i++)
    {
        diferencia -= diasmes[i % 12];
        contador++;
    }
 
    cout << contador << " meses, " << (diferencia / 7) << " semanas y " << (diferencia % 7) \
    << " dias para tu cumplea" << (char)164 << "os." << endl;
 
    cout << endl;
    cout << "ACLARACION RECUENTO MESES:" << endl;
    cout << "De enero a febrero un mes son 31 dias" << endl;
    cout << "De febrero a marzo un mes son 28 dias" << endl;
    cout << "De marzo a abril un mes son 31 dias" << endl;
    cout << "De abril a mayo un mes son 30 dias" << endl;
    cout << "..." << endl;
 
    return 0;
}
 

1. b.

//Linea de comandos: nombre programa cadena.
//Salida: Numero de caracteres.
 
#include <iostream>
#include <string>
 
using namespace std;
 
int main(int argc, char *argv[])
{
    if(argc != 2)
    {
        cerr << argv[0] << " cadena";
        return -1;
    }
 
    cout << string(argv[1]).length();
 
    return 0;
}
 

10.

// Llinea de comandos: programa cadena
// Salida: La cadena invertida
 
#include <iostream>
 
using namespace std;
 
int main(int argc, char *argv[])
{
    if(argc != 2)
    {
        cerr << argv[0] << " cadena" << endl;
        return -1;
    }
 
    if(!(*argv[1]))
        return 0;
 
    argv[1]++;
 
    main(argc,argv);
 
    cout << *(--argv[1]);
 
    return 0;
}
 

¡Buenas!

¿En el de las espirales que hay que hacer? ¿Calcular el numero de espirales? ¿Dibujarlas? Si es lo ultimo, ¿Que criterio hay que seguir para dibujarlas? ¿Cuantas hay que dibujar? ¿Una? ¿Todas las que se pueda?

¡Saludos!

8.

El crackeador de MD5. Compilado utilizando g++ funciona (probad con cadenas cortas y con minusculas). Supongo que podria fallar con otros compiladores o versiones de g++ distintas de la que tengo, a fin de cuentas no deja de ser un popurri de unos cuantos codigos que tenia hechos anteriormente. Mi version de g++ considera unsigned long de 32 bits y unsigned long long de 64. Tampoco se si funcionara en todos los casos, lo que si puedo asegurar es que con cadenas cortas y de minusculas funciona...

/*
 * Linea de comandos:
 *      nombreprograma hash
 * Salida: Cadena cuyo hash MD5 es el que se ha recibido
 *
 *
 * Dada una cadena MD5 devuelve una cadena de digitos hexadecimales de 32 bytes
 *
 *
 * Considerando como conjunto de salida las cadenas de digitos hexadecimales de 32 bytes,
 * MD5 sera por lo tanto suprayectiva y tendra que existir al menos una cadena de 32 bytes
 * hexadecimales cuya imagen sea el valor que recibimos como parametro.
 *
 */
 
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <iostream>
 
using namespace std;
 
#ifndef ULL_MAX
    #define ULL_MAX 0xFFFFFFFFFFFFFFFFULL
#endif
/*
 *
 * Calcula el MD5 del input y devuelve una cadena dinamica que lo contiene.
 *
 */
 
char* md5(char *input, unsigned long  long len);
 
/* Ajusta la cadena a una longitud multiplo de 512 - 64 bits y añade la longitud en 64 bits */
unsigned long long md5_ajustar_datos(char **datos, unsigned long  long len);
 
unsigned long md5_extraer_submensaje(char *m , unsigned long sub , unsigned long bloque);
 
unsigned long md5FF(unsigned long *a,unsigned long b,unsigned long c,unsigned long d,unsigned long m,unsigned long s,unsigned long t);
unsigned long md5GG(unsigned long *a,unsigned long b,unsigned long c,unsigned long d,unsigned long m,unsigned long s,unsigned long t);
unsigned long md5HH(unsigned long *a,unsigned long b,unsigned long c,unsigned long d,unsigned long m,unsigned long s,unsigned long t);
unsigned long md5II(unsigned long *a,unsigned long b,unsigned long c,unsigned long d,unsigned long m,unsigned long s,unsigned long t);
 
#define MD5_LONGITUD 32
 
#define md5_extraer_submensaje(m , sub , bloque) (((unsigned long*)(m))[(bloque) * 16 + (sub)])
 
#define md5F(X,Y,Z)(((X) & (Y)) | ((~(X)) & (Z)))
#define md5G(X,Y,Z)(((X) & (Z)) | ((Y) & (~(Z))))
#define md5H(X,Y,Z)((X) ^ (Y) ^ (Z))
#define md5I(X,Y,Z)((Y) ^ ((X) | (~(Z))))
 
char* md5(char *input, unsigned long long len)
{
    unsigned long reg[4], aux_reg[4], bloque = 0, i, j;
    unsigned long long longitud;
    char *aux;
 
    if(!(aux = (char*) malloc(len * sizeof(char))))
        return NULL;
 
    memmove(aux , input , len * sizeof(char));
 
    if(!(longitud = md5_ajustar_datos(&aux , len)))
    {
        free(aux);
        return NULL;
    }
 
    reg[0] = 0x67452301UL;
    reg[1] = 0xEFCDAB89UL;
    reg[2] = 0x98BADCFEUL;
    reg[3] = 0x10325476UL;
 
    /* mientras haya bloques de 64 bytes (512 bits) */
    while(longitud)
    {
        for(i = 0 ; i < 4 ; i++)
            aux_reg[i] = reg[i];
 
        md5FF( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,0,bloque) ,7LU ,3614090360LU);
        md5FF( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,1,bloque) ,12LU ,3905402710LU);
        md5FF( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,2,bloque) ,17LU ,606105819LU);
        md5FF( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,3,bloque) ,22LU ,3250441966LU);
        md5FF( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,4,bloque) ,7LU ,4118548399LU);
        md5FF( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,5,bloque) ,12LU ,1200080426LU);
        md5FF( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,6,bloque) ,17LU ,2821735955LU);
        md5FF( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,7,bloque) ,22LU ,4249261313LU);
        md5FF( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,8,bloque) ,7LU ,1770035416LU);
        md5FF( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,9,bloque) ,12LU ,2336552879LU);
        md5FF( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,10,bloque) ,17LU ,4294925233LU);
        md5FF( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,11,bloque) ,22LU ,2304563134LU);
        md5FF( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,12,bloque) ,7LU ,1804603682LU);
        md5FF( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,13,bloque) ,12LU ,4254626195LU);
        md5FF( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,14,bloque) ,17LU ,2792965006LU);
        md5FF( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,15,bloque) ,22LU ,1236535329LU);
 
        md5GG( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,1,bloque) ,5LU ,4129170786LU);
        md5GG( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,6,bloque) ,9LU ,3225465664LU);
        md5GG( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,11,bloque) ,14LU ,643717713LU);
        md5GG( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,0,bloque) ,20LU ,3921069994LU);
        md5GG( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,5,bloque) ,5LU ,3593408605LU);
        md5GG( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,10,bloque) ,9LU ,38016083LU);
        md5GG( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,15,bloque) ,14LU ,3634488961LU);
        md5GG( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,4,bloque) ,20LU ,3889429448LU);
        md5GG( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,9,bloque) ,5LU ,568446438LU);
        md5GG( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,14,bloque) ,9LU ,3275163606LU);
        md5GG( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,3,bloque) ,14LU ,4107603335LU);
        md5GG( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,8,bloque) ,20LU ,1163531501LU);
        md5GG( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,13,bloque) ,5LU ,2850285829LU);
        md5GG( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,2,bloque) ,9LU ,4243563512LU);
        md5GG( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,7,bloque) ,14LU ,1735328473LU);
        md5GG( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,12,bloque) ,20LU ,2368359562LU);
 
        md5HH( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,5,bloque) ,4LU ,4294588738LU);
        md5HH( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,8,bloque) ,11LU ,2272392833LU);
        md5HH( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,11,bloque) ,16LU ,1839030562LU);
        md5HH( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,14,bloque) ,23LU ,4259657740LU);
        md5HH( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,1,bloque) ,4LU ,2763975236LU);
        md5HH( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,4,bloque) ,11LU ,1272893353LU);
        md5HH( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,7,bloque) ,16LU ,4139469664LU);
        md5HH( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,10,bloque) ,23LU ,3200236656LU);
        md5HH( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,13,bloque) ,4LU ,681279174LU);
        md5HH( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,0,bloque) ,11LU ,3936430074LU);
        md5HH( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,3,bloque) ,16LU ,3572445317LU);
        md5HH( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,6,bloque) ,23LU ,76029189LU);
        md5HH( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,9,bloque) ,4LU ,3654602809LU);
        md5HH( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,12,bloque) ,11LU ,3873151461LU);
        md5HH( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,15,bloque) ,16LU ,530742520LU);
        md5HH( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,2,bloque) ,23LU ,3299628645LU);
 
        md5II( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,0,bloque) ,6LU ,4096336452LU);
        md5II( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,7,bloque) ,10LU ,1126891415LU);
        md5II( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,14,bloque) ,15LU ,2878612391LU);
        md5II( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,5,bloque) ,21LU ,4237533241LU);
        md5II( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,12,bloque) ,6LU ,1700485571LU);
        md5II( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,3,bloque) ,10LU ,2399980690LU);
        md5II( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,10,bloque) ,15LU ,4293915773LU);
        md5II( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,1,bloque) ,21LU ,2240044497LU);
        md5II( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,8,bloque) ,6LU ,1873313359LU);
        md5II( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,15,bloque) ,10LU ,4264355552LU);
        md5II( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,6,bloque) ,15LU ,2734768916LU);
        md5II( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,13,bloque) ,21LU ,1309151649LU);
        md5II( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,4,bloque) ,6LU ,4149444226LU);
        md5II( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,11,bloque) ,10LU ,3174756917LU);
        md5II( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,2,bloque) ,15LU ,718787259LU);
        md5II( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,9,bloque) ,21LU ,3951481745LU);
 
 
        for(i = 0 ; i < 4 ; i++)
            reg[i] += aux_reg[i];
 
        bloque++;
        longitud -= 64; /* descontamos un bloque de 64 bytes, 512 bits */
    }
 
    free(aux);
 
    if(!(aux = (char*) malloc(33 * sizeof(char))))
        return NULL;
 
    aux[0] = '\0';
 
    for(i = 0 ; i < 4 ; i++)
        for(j = 0 ; j < 4 ; j++)
            sprintf(aux,"%s%02X",aux,(unsigned char)((char*)&(reg[i]))[j]);
 
    return aux;
}
 
unsigned long long md5_ajustar_datos(char **datos, unsigned long long len)
{
    unsigned long long new_len;
    char *aux;
    int c = 0;
 
    /* si longitud en bits es mayor que ULL_MAX */
    if(len > ULL_MAX / 8)
        return 0; /* devolvemos falso */
 
    if(64 - (len % 64) > 8)
    {
        if(ULL_MAX - (64 - (len % 64)) >= len)
            new_len = len + (64 - (len % 64));
        else
            return 0;
    }
    else
    {
        if(ULL_MAX - 64 - (64 - (len % 64)) >= len)
            new_len = len + 64 + (64 - (len % 64));
        else
            return 0;
    }
 
    if(!(aux = (char*) realloc(*datos , new_len * sizeof(char))))
        return 0;
 
    (*datos) = aux;
 
    c = 1 << 7;
 
    memset((*datos) + len , c , sizeof(char));
    memset((*datos) + len + 1 , 0 , (new_len - len - 1) * sizeof(char));
 
    /* pasamos la longitud de bytes a bits */
    len *= 8;
 
    memcpy((*datos) + new_len - 8 , &len , 8 * sizeof(char));
 
    return new_len;
}
 
unsigned long md5FF(unsigned long *a,unsigned long b,unsigned long c,unsigned long d,unsigned long m,unsigned long s,unsigned long t)
{
    unsigned long aux;
 
    aux = (*a + md5F(b, c, d) + m + t);
 
    *a = b + ((aux << s) | (aux >> (32 - s)));
 
    return *a;
}
 
unsigned long md5GG(unsigned long *a,unsigned long b,unsigned long c,unsigned long d,unsigned long m,unsigned long s,unsigned long t)
{
    unsigned long aux;
 
    aux = (*a + md5G(b, c, d) + m + t);
 
    *a = b + ((aux << s) | (aux >> (32 - s)));
 
    return *a;
}
 
unsigned long md5HH(unsigned long *a,unsigned long b,unsigned long c,unsigned long d,unsigned long m,unsigned long s,unsigned long t)
{
    unsigned long aux;
 
    aux = (*a + md5H(b, c, d) + m + t);
 
    *a = b + ((aux << s) | (aux >> (32 - s)));
 
    return *a;
}
 
unsigned long md5II(unsigned long *a,unsigned long b,unsigned long c,unsigned long d,unsigned long m,unsigned long s,unsigned long t)
{
    unsigned long aux;
 
    aux = (*a + md5I(b, c, d) + m + t);
 
    *a = b + ((aux << s) | (aux >> (32 - s)));
 
    return *a;
}
 
 
int MD5_bruteforce(string MD5,unsigned long longitud)
{
    static string cadena;
    static unsigned long posicion = 0;
    static char* alfabeto = "abcdefghijklmnopqrstuvwxyz"; //con este alfabeto abarcamos el espacio imagen en menos iteraciones
 
    if(posicion == longitud)
    {
        //si hemos llegado a la ultima posicion almacenamos la variacion
        if(string(md5((char*)cadena.c_str(), cadena.length())) == MD5)
        {
            cout << cadena;
            return 1;
        }
 
        return 0;
    }
 
    //si es la primera llamada damos la longitud deseada a la cadena
    if(posicion == 0)
        cadena.resize(longitud);
 
    //para cada uno de los caracteres del alfabeto
    for(int i = 0 ; alfabeto[i] ; i++)
    {
        cadena[posicion] = alfabeto[i]; //asignamos a la posicion correspondiente el caracter del alfabeto.
 
        //avanzamos una posicion
        posicion++;
 
        //y calculamos el siguiente caracter
        if(MD5_bruteforce(MD5,longitud))
        {
            posicion = 0;
            cadena.resize(0);
            return 1;
        }
 
        //volvemos a la posicion original
        posicion--;
    }
 
    //posicion termina a cero para la siguiente llamada
    if(!posicion)
        cadena.resize(0);
 
    return 0;
}
 
int main(int argc, char *argv[])
{
    string MD5;
 
    if(argc != 2)
    {
        cout << argv[0] << " MD5_hash" << endl;
        return -1;
    }
 
    if(strlen(argv[1]) != 32)
    {
        cout << argv[0] << " MD5_hash" << endl;
        return -1;
    }
 
    for(int i = 0 ; i < 32 ; i++)
    {
        argv[1][i] = toupper(argv[1][i]);
 
        if(!((argv[1][i] >= '0' && argv[1][i] <= '9') || (argv[1][i]>= 'A' && argv[1][i]<='Z')))
        {
            cout << argv[0] << " MD5_hash" << endl;
            return -1;
        }
    }
 
    MD5 = argv[1];
 
 
    if(string(md5("",0)) != MD5)
    {
        for(int i = 1 ; i < 32 ; i++)
            if(MD5_bruteforce(MD5,i))
                break;
    }
    else
        cout <<"Cadena vacia" << endl;
 
    return 0;
}
 

¡Buenas!

¿A que te refieres con un crackeador de MD5? ¿A redibir como argumento un hash y generar una cadena que de el mismo hash?

¡Buenas!

#include <stdio.h>
#include <stdlib.h>
 
int main(int argc, char *argv[])
{
    FILE *f;
    char *contenido;
    unsigned long longitud;
 
    f=fopen("algunfichero","rb");
 
    fseek(f,0,SEEK_END);
 
    if(!(contenido = (char*) malloc(longitud = ftell(f))))
        return -1;
 
    fseek(f,0,SEEK_SET);
 
    fread(contenido,longitud,1,f);
 
    fclose(f);
 
    free(contenido);
 
    return 0;
}
 

Prueba ahora, que en C++ me parece que no se puede asignar un punter void a un puntero no void. Obliga a hacer el cast.

¡Saludos!

+1