Foro de elhacker.net

Hola a tod@s, esta mañana he intentado crear en C un generador de diccionario, en plan que tu le dices de 5 caracteres y en teoría debería de ir desde "aaaaa" hasta "zzzzz" pero me ha sido un infierno, he probado de todo, he concatenado 3 fors que fueran desplazando la posicion he hecho de todo y no lo he conseguido, no quiero que me deis el código para ver como se hace (no me gusta que me den el trabajo hecho, y tampoco estaría bien pediros eso), solo quiero saber si realmente, es tan dificil o si realmente soy malo programando por que es que me ha frustado muchísimo.

Hice algo así en batch cuando tenía 15 años pero eran un montón de for anidados y digamos que el método no era muy "elegante" pero funcionar funcionaba, el caso es que ahora que "en teoría" se C me habría gustado conseguirlo, pero es que me he tirado horas delante del PC y solo he conseguido pillarme un cabreo.

Si no entendí mal, lo que estás buscando, es hacer combinaciones, que se usa en matemáticas, empezá buscando sobre desarrollo de combinaciones y permutaciones.

Bueno, ese programa que pides es algo bastante simple... No diré que eres malo programando, sino simplemente que aun estás muy verde y necesitas practicar mucho.

Saludos, y no te desanimes!

He encontrado este código en internet:

#include <stdio.h>
 
#include <stdlib.h>
 
#include <string.h>
 
 
 
int main(int argc, char *argv[])
 
{       if(argc < 2 || !strcmp(argv[1], "-h")) //Texto de ayuda
 
        {
 
                puts("HELP: \nsintax: dic [len_dic] (optional)[list]");
 
                return 1;
 
        }
 
 
 
        int len=0, cont=atoi(argv[1]), *cad, i, ver=1; //Declaracion
 
        cad=(int *)malloc(sizeof(int) * atoi(argv[1])); //Reserva de memoria para un array int
 
        memset((int *)cad,0,sizeof(int) * atoi(argv[1]));//Inicializamos el array a 0
 
        char *lst;//Declaracion de la lista que contendra las posibilidades
 
 
 
        if(argc < 3) //Comprobamos el numero de parametros introducidos para hacer una cosa u otra
 
        {
 
                lst=(char *)malloc(strlen("abcdefghijklmnopqrstuvwxyz")+1);
 
                strcpy(lst, "abcdefghijklmnopqrstuvwxyz");
 
        }
 
        else if(argc == 3)
 
        {
 
 
 
                        lst=(char *)malloc(strlen(argv[2])+1);
 
                        if(!lst)
 
                        {
 
                                puts("No se pudo reservar la memoria");
 
                                return 1;
 
                        }
 
                        strcpy(lst, argv[2]);
 
        }
 
 
 
        while(len+1<=cont)//Comienza el ciclo de generacion
 
        {
 
                if(lst[cad[0]]!='\0')
 
                {
 
                        for(i=0;i<=len;i++)
 
                        {
 
                                putchar(lst[cad[i]]);                   
 
                        }
 
                        putchar('\n');
 
                }
 
                if(lst[cad[0]]!='\0')
 
                {
 
                        cad[0]++;
 
                }
 
                else
 
                {
 
            ver=0;
 
                        for(i=0;i<=len;i++)
 
                        {
 
                                if(lst[cad[i]]=='\0')
 
                                {
 
                                        cad[i]=0;
 
                                        cad[i+1]++;
 
                                }
 
                                else
 
                                {
 
                                        ver=1;
 
                                }
 
                        }
 
                }
 
                if(ver==0)
 
                {
 
                        len++;
 
                        for(i=0;i<=len;i++)
 
                        {
 
                                cad[i]=0;
 
                        }
 
                        ver=1;
 
                }
 
        }
 
        free(lst);
 
        free(cad);
 
        return 0;
 
}

Funciona a la perfección y se ve muy simple, pero sinceramente aunque me guste la programación creo que novoy a valer para esto, por que este código ya digo, tiene pinta de ser muy simple, pero me hago un lio y no entiendo nada.

Hay que tener bastante experiencia para leer código de otra persona, al principio no es fácil, no te rindas a la primera. Intenta simplificar los problemas para no frustrarte.

En vez de intentar con 5 caracteres empieza con 2, por ejemplo, y un diccionario más pequeño:

Ese método es el que yo usé hace años en batch, y funciona bien, el problema está en que quiero que sea modular, es decir, quiero poder elegir el número de caracteres, además el problema de ese método es que para por ejemplo 10 caracteres necesitas 10 fors anidados.

Gracias por tus animos, me he frustado mucho y llevo un mal dia.

El código se quedaría así, es una chorrada yo lo quería hacer mucho más elegante:

#include <stdio.h>
 
#include <stdlib.h>
 
#include <string.h>
 
 
 
int main(int argc, char *argv[]) {
 
    char caracteres[]="abcdefghijklmnopqrstuvwxyz";
 
    int x, y;
 
    for(x=0;x<strlen(caracteres);x++) {
 
        for(y=0;y<strlen(caracteres);y++) {
 
            printf("%c%c\n", caracteres[x], caracteres[y]);
 
 
 
 
        }
 
 
 
 
    }
 
 
 
 
}

PD: ¿ Alguien me explica un método más elegante y sobretodo, más reutilizable donde pueda elegir el número de caracteres, o por lo menos, explicarme el código de arriba que he puesto ?.

Te doy una idea y te mejoro el concepto:
Se llama generar permutaciones de un grupo.
Dado un grupo A = { 'a','b','c' } todas las permutaciones de dos valores con repeticion, no hace falta hacer tres bucles.
Te paso un pedacito de codigo que me robe de stackoverflow porque no estoy encasa:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
unsigned powu(unsigned base, unsigned exp){
    unsigned result = 1;
    while(exp > 0){
        if(exp & 1)
            result *= base;
        base = base * base;
        exp >>=1;
    }
    return result;
}
 
int main(int argc, char *argv[]){
    if(argc != 3){
        fprintf(stderr, "Usage : RepeatedPermutation abcd 3\n");
        return -1;
    }
    char *list = argv[1];
    unsigned gp_len = atoi(argv[2]);
    unsigned list_len = strlen(list);
    char *gp = calloc(gp_len+1, sizeof(char));
    int total_n = powu(list_len, gp_len);
    int i, j;
    for(i=0;i<total_n;++i){
        int n = i;
        for(j=0;j<gp_len;++j){
            gp[gp_len -j -1] = list[n % list_len];
            n /= list_len;
        }
        printf("[%s]\n", gp);
    }
    free(gp);
    return 0;
}
 

No hace falta que te lo comente, pero si necesitas explicacion de algo me decis..

Para dejar mi miga de pan, os dejo un simple ejemplo de como generar el diccionario y a su vez guardarlo en un archivo:

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
 
int main() {
	FILE * lpstFilePointer = NULL;
	char lpszFilePath[256];
	char *lpString = NULL;
	int nNumCharacters = 0;
 
	std::cout << "Cuantos caracteres necesitas? ";
	std::cin >> nNumCharacters;
 
	std::cout << "Donde deseas guardar los datos? ";
	std::cin >> lpszFilePath;
 
	lpstFilePointer = fopen((const char *)lpszFilePath, "w");
 
	if(lpstFilePointer == NULL) {
		std::cout << "Error al abrir el archivo en la ruta '" << lpszFilePath << "'. El programa se va a cerrar";
		std::cin.get();
		return 1;
	}
 
	lpString = new char[nNumCharacters];
 
	if(lpString == NULL) {
		std::cout << "Error al declarar la cadena temporal para generar el diccionario.";
		std::cin.get();
		return 1;
	}
 
	for(int i = 0; i <= (int)pow(26, nNumCharacters); i++) {
		itoa(i, lpString, 26);
 
		for(int e = 0; e < nNumCharacters; e++) {
			if(lpString[e] != 0) {
				if(lpString[e] <= 57)
					lpString[e] += 49;
				else
					lpString[e] += 10;
			}
		}
 
		fputs(lpString, lpstFilePointer);
		fputc('\n', lpstFilePointer);
	}
 
	std::cout << "El programa ha finalizado el proceso.";
	fclose(lpstFilePointer);
	std::cin.get();
	return 0;
}

Muchas gracias, me ha servido de mucho, solo unos cuantos detalles:

- Para que sirven los operadores ">>" y el operador "&" (este último lo había visto pero solo como "&&")
- Me gustaría que, si no es mucho pedir, me explicaras o me pasaras algún enlace que explique, el algoritmo (la fórmula) para las permutaciones con repetición de grupo ( que es lo que me has dicho ), lo he estado buscando yo por mi cuenta, pero solo encuentro con números y no se como aplicarlo a esto (leo el código pero si no se la fórmula "original" me cuesta un poco leerlo, aunque es bastante claro)

Saludos y gracias por la ayuda.

La verdad que http://www.vitutor.com/pro/1/a_6.html (http://www.vitutor.com/pro/1/a_6.html) es todo lo que necesite para entenderlo..
Pero al caso, << es para para correr el numero binario tantos como son necesarios hacia el lado que indica el simbolo, o sea, >> es su operacion contraria.
Si estuvieramos en C++ esto significaria el desplazamiento de flujo que funciona distinto dependiendo del tipo/clase

En cuanto al algoritmo de generacion, la parte mas complicada es la de seleccionar la posicion a la cual incrementar al siguiente elemento del grupo..

Fijate si con la lectura que te pase lo entendes sino te lo comento..

Gracias por ayudarme :)

La lectura que me has pasado, pone una fórmula para calcular el número de posibilidades, pero aún no se como haces para "calcular" cada posibilidad, así que si puedes comentármelo mejor.

PD: ¿ Y para que sirve "&" en vez de "&&" ?.

Saludos.

*El operador >> sirve para lo que se denomina 'Desplazamiento de Bits' Esto sirve para lo que su nombre dice. Me explico con un ejemplo: tenemos una variable de tipo entero (int) cuyo valor es 12. Dicho numero en binario es 1100. Si hacemos la siguiente operación...

varialbe = variable >> 1

entonces estamos desplazando todos los bits un lugar, dando como resultado el numero en binario 0110. El 1 que estaba en cuarto lugar ha pasado al tercer lugar. El 1 que estaba en tercer lugar ha pasado al segundo lugar... y así sucesivamente. Si hubiéramos hecho esto...

variable = variable >> 2

entonces daría como resultado 0011 en binario

*El operador & es parecido al |. Lo que hace es multiplicar bit a bit dos valores. Por ejemplo, tenemos los valores 011010 y 110011 (en binario). Si hacemos 011010 & 110011 obtendremos 010010.
Empezamos de derecha a izquierda: El primer bit está determinado por la operación 1 * 0, por lo que vale 0. El segundo bit está determinado por la operación 1 * 1, por lo que vale 1 y así sucesivamente

Gracias, me ha servido de ayuda.

Bien, he regresado xD
Vengo a explicarte por que se usa asi el tema de la posicion:
Examinemos el codigo si?
Lo primero que hacemos es guardar el valor de i, que es el indicador del numero de combinacion general en la que estamos.
Luego entrmos en el for que hace las combinaciones.
El orden se determina por

            gp[gp_len -j -1] = list[n % list_len];
            n /= list_len;
 

gp -> grupo, gp_len -> largo del grupo, j-> posicion actual en el grupo, -1 porque el indice esta basado en ceros
list es la lista de elementos permutables en el grupo.
Entonces:
para cada elemento de gp le en la posicion donde estamos en el bucle (-1) se da el valor del elemento del grupo en relacion al largo del grupo de elementos intercambiables en el round actual (round = valor de i), luego se ajusta n con el largo del grupo deseado.

Esto es asi dado que cada permutacion tiene asociado un numero, si "0000" es 0, "0001" es 1, y "AAAA" es X

No se explicarme muy bien, tendria que agarrar latex y escribirte la formula algebraica de generacion de permutaciones.

Basicamente es que tenes un grupo vacio de universo hasta X elementos.
De tal manera que vas a seleccionar dependiendo del numero un elemento Y para meterlo y puede ser biyectiva(es decir tener dos valores iguales dentro del grupo X partiendo del mismo elemento en Y)

Vale, creo que ya lo he entendido, el problema para mi no es C, es más bien el algoritmo matemático ya que tampoco es que sepa yo muchas mates pero bueno lo que es el código lo entiendo.

Muhas gracias por tu tiempo :)