Foro de elhacker.net

hola amigos

les pido ayuda con algo que vi desde hace mucho, es como realizar un generador que muestre como resultado:

AAAAA
AAAAB
AAAAC
.........
.........
ZZZZZ

y algo mucho mas desafiante que no pude ni encontrar partes en internet y bueno mi conocimiento no es tan amplio pero decearia aprender a poder generar un..


AAAAA00000
AAAAA00001
AAAAA00002
....
....
....
AAAAB00000
AAAAB00001
....
.....
ZZZZZ99999

solo pude sacar cuantos resultados tendre :-( (son 14348907000000 posibles combinaciones)


una ayudita porfavor enserio me mata la curiosidad de aprender a hacer un contador o generador de ese tipo, y gracias de antemano por todo

Al ver este tema, me ha parecido interesante y he creado uno del primer tipo que pides (solo con letras).

Por ahora solo tiene todas las posibles combinaciones de cinco caracteres comprendidos entre la 'A' a 'Z'. Después lo mejoraré para que acepte números y para que sea de n caracteres. Eso sí, creo que el programa no es muy eficiente, así que también tengo que corregir este punto.

#include <stdio.h>
 
void PrimeraLetra(char *Letras, int n)
{
    printf("%s\n", Letras);
    Letras[n]++;
    if(Letras[n] <= 90) PrimeraLetra(Letras, n);
    else Letras[n] = 65;
}
 
void SegundaLetra(char *Letras, int n)
{
    PrimeraLetra(Letras, n);
    Letras[n-1]++;
    if(Letras[n-1] <= 90) SegundaLetra(Letras, n);
    else Letras[n-1] = 65;
}
 
void TerceraLetra(char *Letras, int n)
{
    SegundaLetra(Letras, n);
    Letras[n-2]++;
    if(Letras[n-2] <= 90) TerceraLetra(Letras, n);
    else Letras[n-2] = 65;
}
 
void CuartaLetra(char *Letras, int n)
{
    TerceraLetra(Letras, n);
    Letras[n-3]++;
    if(Letras[n-3] <= 90) CuartaLetra(Letras, n);
    else  Letras[n-3] = 65;
}
 
void QuintaLetra(char *Letras, int n)
{
    CuartaLetra(Letras, n);
    Letras[n-4]++;
    if(Letras[n-4] <= 90) QuintaLetra(Letras, n);
    else Letras[n-4] = 65;
}
 
int main()
{
    char Letras[] = "AAAAA";
    QuintaLetra(Letras, 4);
    return 0;
}
 

Si tienes alguna duda pregunta  :D

Saludos.

Una pregunta 90 y 65 que indican?¿

Se me olvidó poner un comentario para explicarlo. 65 es el valor ASCII del carácter 'A', y 90 el del carácter 'Z'.

Sé que también se podría poner así:

if(Letras[n] <= 'Z') PrimeraLetra(Letras, n);

Pero he cogido la costumbre de poner el valor en ASCII.

Gracias SXF es muy bueno, para agregar los números sería un buen desafío ya que tendríamos que unificar todo el método "LETRA X Número" gracias de nuevo SXF me daba curiosidad saber como genera ese tipo de código, dime algo más vi en algunos códigos que guardan lo que imprimen en pantalla con una extensión ".txt" como hacen eso???

He editado mi código para que puedas poner todo en un archivo. Aquí te lo dejo:

#include <stdio.h>
 
FILE *fp;
 
void PrimeraLetra(char *Letras, int n)
{
    printf("%s\n", Letras); //Imprimimos
    fputs(Letras, fp);
    fputc('\n', fp);
    Letras[n]++; //Pasamos al siguiente carácter [al siguiente valor ASCII]
    if(Letras[n] <= 90) PrimeraLetra(Letras, n); /*90 es el valor ASCII de  'Z'. Si no se ha superado
                                                                                  ese valor, significa que el nuevo carácter está
                                                                                  comprendido entre la 'A' y la 'Z', y, por tanto, es
                                                                                  un carácter de los que queremos generar. Así, llamamos
                                                                                  a la función de nuevo.*/
    else Letras[n] = 65;
}
 
void SegundaLetra(char *Letras, int n) //Algo similar a la función anterior.
{
    PrimeraLetra(Letras, n);
    Letras[n-1]++;
    if(Letras[n-1] <= 90) SegundaLetra(Letras, n);
    else Letras[n-1] = 65;
}
 
void TerceraLetra(char *Letras, int n)
{
    SegundaLetra(Letras, n);
    Letras[n-2]++;
    if(Letras[n-2] <= 90) TerceraLetra(Letras, n);
    else Letras[n-2] = 65;
}
 
void CuartaLetra(char *Letras, int n)
{
    TerceraLetra(Letras, n);
    Letras[n-3]++;
    if(Letras[n-3] <= 90) CuartaLetra(Letras, n);
    else  Letras[n-3] = 65;
}
 
void QuintaLetra(char *Letras, int n)
{
    CuartaLetra(Letras, n);
    Letras[n-4]++;
    if(Letras[n-4] <= 90) QuintaLetra(Letras, n);
    else Letras[n-4] = 65;
}
 
int main()
{
    char Letras[] = "AAAAA";
    fp = fopen("combinacion.txt", "w");
    QuintaLetra(Letras, 4);
    fclose(fp);
    return 0;
}
 

Las funciones que he utilizado, para que veas cómo lo he hecho, son:

fopen (http://www.cplusplus.com/reference/clibrary/cstdio/fopen/), fclose (http://www.cplusplus.com/reference/clibrary/cstdio/fclose/), fputc (http://www.cplusplus.com/reference/clibrary/cstdio/fputc/), fputs (http://www.cplusplus.com/reference/clibrary/cstdio/fputs/)

Cuando vaya editando el código iré poniéndolo, a ver si después lo hago más eficiente y además meto los números.

Saludos.

He terminado el código para que muestre todas las combinaciones posibles desde AAAAA00000 hasta ZZZZZ99999.

El algoritmo está bien, sin embargo, es tan ineficiente que a mitad del programa me sale un mensaje que dice "Generador.exe dejó de funcionar. Windows está buscando una solución al problema", pulso en aceptar y se cierra el programa...

#include <stdio.h>
 
FILE *fp;
 
void numeros(char *Letras, int n)
{
    printf("%s\n", Letras); //Imprimimos
    fputs(Letras, fp);
    fputc('\n', fp);
 
    Letras[n+5]++;
 
    if(Letras[n+2] > 57)
    {
        Letras[n+2] = 48;
        Letras[n+1]++;
    }
    else if(Letras[n+3] > 57)
    {
        Letras[n+3] = 48;
        Letras[n+2]++;
    }
    else if (Letras[n+4] > 57)
    {
        Letras[n+4] = 48;
        Letras[n+3]++;
    }
    else if(Letras[n+5] > 57)
    {
        Letras[n+5] = 48;
        Letras[n+4]++;
    }
    if(Letras[n+1] <= 57) numeros(Letras, n);
 
}
 
void PrimeraLetra(char *Letras, int n)
{
 
    numeros(Letras, n);
    Letras[n]++; //Pasamos al siguiente carácter [al siguiente valor ASCII]
    if(Letras[n] <= 90) PrimeraLetra(Letras, n); /*90 es el valor ASCII de  'Z'. Si no se ha superado
                                                                                  ese valor, significa que el nuevo carácter está
                                                                                  comprendido entre la 'A' y la 'Z', y, por tanto, es
                                                                                  un carácter de los que queremos generar. Así, llamamos
                                                                                  a la función de nuevo.*/
    else Letras[n] = 65;
}
 
void SegundaLetra(char *Letras, int n) //Algo similar a la función anterior.
{
    PrimeraLetra(Letras, n);
    Letras[n-1]++;
    if(Letras[n-1] <= 90) SegundaLetra(Letras, n);
    else Letras[n-1] = 65;
}
 
void TerceraLetra(char *Letras, int n)
{
    SegundaLetra(Letras, n);
    Letras[n-2]++;
    if(Letras[n-2] <= 90) TerceraLetra(Letras, n);
    else Letras[n-2] = 65;
}
 
void CuartaLetra(char *Letras, int n)
{
    TerceraLetra(Letras, n);
    Letras[n-3]++;
    if(Letras[n-3] <= 90) CuartaLetra(Letras, n);
    else  Letras[n-3] = 65;
}
 
void QuintaLetra(char *Letras, int n)
{
    CuartaLetra(Letras, n);
    Letras[n-4]++;
    if(Letras[n-4] <= 90) QuintaLetra(Letras, n);
    else Letras[n-4] = 65;
}
 
int main()
{
    char Letras[] = "AAAAA00000";
    fp = fopen("combinacion.txt", "w");
    QuintaLetra(Letras, 4);
 
    fclose(fp);
    return 0;
}
 

Me parece a mí que la dificultad de este problema está más en la eficiencia... Al menos tenemos ya para que nos haga desde AAAAA hasta ZZZZZ...

Saludos!

muchas gracias DickGumshoe lo estoy probando, mira yo encontre este codigo dame tu opinion de que tal esta:

{
char a,b,c,d,e,n1,n2,n3,n4,n5;

  for(a = 'A'; a<= 'Z'; a++)
   for(b = 'A'; b <= 'Z'; b++)
    for(c = 'A'; c <= 'Z'; c++)
     for(d = 'A'; d <= 'Z'; d++)
      for(e = 'A'; e <= 'Z'; e++)
       for(n1 = 0; n1 < 10; n1++)
        for(n2 = 0; n2 < 10; n2++)
         for(n3 = 0; n3 < 10; n3++)
          for(n4 = 0; n4 < 10; n4++)
           for(n5 = 0; n5 < 10; n5++)
             printf("%c%c%c%c%c%d%d%d%d%d\n",a,b,c,d,e,n1,n2,n3,n4,n5);
}



y una ultima pregunta como se utiliza para guardar lo que se imprime en pantalla en un ".txt"

probando tu codigo me di cuenta que imprime de esta manera:

AAAAIW:0232
AAAAIX:0233
AAAAIY:0234
AAAAIZ:0235


deberia de imprimir

AAAAIW00232
AAAAIW00233
AAAAIW00234
AAAAIW00235
AAAAIW00236
AAAAIW00237

se salta muchas combinaciones existentes
muchas gracias

Ese código debe salir también, pero yo hice el programa a mi manera porque me pareció muy típico eso de hacer tantos for anidados, y me gustó hacerlo de otra forma, con recursividad.

Eso sí, en ese código las variables n1, n2, n3, n4 y n5 son char, no debes imprimirlas como %d, y en el bucle for no es desde 0 hasta 9, sino que tienes que hacer desde 48 hasta 57 (valor ASCII de 0 y 9, respectivamente).

Para imprimirlo en un .txt tienes que declarar una variable así:

FILE *nombre_variable;

Entonces, para editar el .txt, eliges un nombre y el modo en que lo vas a abrir:

nombre_variable = fopen ("nombre_archivo.txt", "w");

En este caso es un .txt, pero también puedes poner .dat o la extensión que quieras. El modo en que abrimos el archivo es "w", (write, escritura). Pero hay muchos más. Para conocerlos, puedes ver el enlace que te pasé en un mensaje anterior con la función fopen() explicada.

Ya usas la función fputs() para poner una cadena en el fichero (también te pasé el enlace a cómo usarla).

Y para cerrar el fichero, poner:

fclose(nombre_variable);

A ver si conseguimos que nos salga (aunque el algoritmo mío está bien, pero no llega a terminar, no sé por qué, a ver si alguien me puede comentar por qué...)

Saludos!

probando tu codigo me di cuenta que imprime de esta manera:

AAAAIW:0232
AAAAIX:0233
AAAAIY:0234
AAAAIZ:0235


deberia de imprimir

AAAAIW00232
AAAAIW00233
AAAAIW00234
AAAAIW00235
AAAAIW00236
AAAAIW00237

se salta muchas combinaciones existentes ademas no genera el .txt
muchas gracias

Mi código no se salta ninguna combinación (aunque, como ya he dicho, se para en un momento determinado por la ineficiencia) y además lo imprime bien  :huh:

EDITO: Además, genera el .txt... Sigo comprobando pero no encuentro errores...

https://foro.elhacker.net/programacion_cc/brute_force_by_n0body-t278082.0.html
No se muy bien como va eso de recursividad e iteracion, pero tengo entendido por el post que eso es un generador recursivo. En el recopilatorio de sources interesantes hay otro iterativo, creo.

Saludos.

Gracias por el link! Es algo parecido, pero no exactamente igual.

Por cierto, ¡he editado el programa y ya va bien y es más eficiente! Lo que he modificado es la función numeros(). Ya no tiene mil y una condiciones, y el programa va perfecto (al menos por ahora no se me ha calado como otras veces, va escribiendo todo en el fichero correctamente, imprimiendo todo bien por pantalla... Aquí lo dejo:

#include <stdio.h>
 
FILE *fp;
 
void numeros(char *Letras, int n)
{
 int i;
 for(i=0;i<100000;i++)
 {
     printf("%s%.5d\n",Letras, i);
     fprintf(fp, "%s%.5d\n", Letras, i);
 }
 
}
 
void PrimeraLetra(char *Letras, int n)
{
 
    numeros(Letras, n);
    Letras[n]++; //Pasamos al siguiente carácter [al siguiente valor ASCII]
    if(Letras[n] <= 90) PrimeraLetra(Letras, n); /*90 es el valor ASCII de  'Z'. Si no se ha superado
                                                                                  ese valor, significa que el nuevo carácter está
                                                                                  comprendido entre la 'A' y la 'Z', y, por tanto, es
                                                                                  un carácter de los que queremos generar. Así, llamamos
                                                                                  a la función de nuevo.*/
    else Letras[n] = 65;
}
 
void SegundaLetra(char *Letras, int n) //Algo similar a la función anterior.
{
    PrimeraLetra(Letras, n);
    Letras[n-1]++;
    if(Letras[n-1] <= 90) SegundaLetra(Letras, n);
    else Letras[n-1] = 65;
}
 
void TerceraLetra(char *Letras, int n)
{
    SegundaLetra(Letras, n);
    Letras[n-2]++;
    if(Letras[n-2] <= 90) TerceraLetra(Letras, n);
    else Letras[n-2] = 65;
}
 
void CuartaLetra(char *Letras, int n)
{
    TerceraLetra(Letras, n);
    Letras[n-3]++;
    if(Letras[n-3] <= 90) CuartaLetra(Letras, n);
    else  Letras[n-3] = 65;
}
 
void QuintaLetra(char *Letras, int n)
{
    CuartaLetra(Letras, n);
    Letras[n-4]++;
    if(Letras[n-4] <= 90) QuintaLetra(Letras, n);
    else Letras[n-4] = 65;
}
 
int main()
{
    char Letras[] = "AAAAA";
    fp = fopen("combinacion.txt", "w");
    QuintaLetra(Letras, 4);
 
    fclose(fp);
    return 0;
}
 

¡A ver si me animo y sigo editándolo para hacerlo aún mejor!

Saludos!

FILE *fp;
 
void numeros(char *Letras, int n)
{
 int i;
 for(i=0;i<100000;i++)
 {
     printf("%s%.5d\n",Letras, i);
     fprintf(fp, "%s%.5d\n", Letras, i);
 }
 
}
 

No termino de entender porque debe haber printf y fprint??? no es suficiente imprimir el valor en el archivo?? (fprint)? o eso solo imprime el valor en el archivo más no proporciona una salida en consola??

y sobre el archivo combinacion.txt, en donde se crea?????? al cerrarse el archivo se elimina???

Es increible el tiempo que tomo para imprimir todos los caracteres desde "AAAAA" hasta "ZZZZZ", el primer intento tuyo hizo que se bloqueara la terminal, con el fp (hey esa es otra, porque debe referenciarse *fp??) funciono mejor, aunque pues viendo el código, pues todas las funciones de quinta hasta primera letra se parecen bastante.  No soy un experto, pero intentare aligerar tanta linea.


---------------------------------------------------------------------------------------------------

Editado: Viejo me salieron nuevas dudas modificando un poco el código, viejo, quise imprimir desde "AAAAA" hasta "FFFFF", y me surgio una duda pues me salian valores númericos cuando salia en terminal, mirando la funcion numeros(char *Letras, int n) me encontre que imprimes el caracter junto con ".5%d" que es el valor numerico que representa el caracter, porque haces eso??? es por referencia?? pero si solo lo estas imprimiendo?? y porque no salia ese caracter en el codigo original??


por ende lo deje así:

#include <stdio.h>
 
FILE *fp;
 
void numeros(char *Letras, int n)
{
 int i;
 for(i=0;i<1;i++)
 {
     printf("%s\n",Letras, i);
     fprintf(fp, "%s%.5d\n", Letras, i);
 }
 
}
 
void PrimeraLetra(char *Letras, int n)
{
 
    numeros(Letras, n);
    Letras[n]++; 
    if(Letras[n] <= 70) PrimeraLetra(Letras, n);
    else Letras[n] = 65;
}
 
void SegundaLetra(char *Letras, int n) 
{
    PrimeraLetra(Letras, n);
    Letras[n-1]++;
    if(Letras[n-1] <= 70) SegundaLetra(Letras, n);
    else Letras[n-1] = 65;
}
 
void TerceraLetra(char *Letras, int n)
{
    SegundaLetra(Letras, n);
    Letras[n-2]++;
    if(Letras[n-2] <= 70) TerceraLetra(Letras, n);
    else Letras[n-2] = 65;
}
 
void CuartaLetra(char *Letras, int n)
{
    TerceraLetra(Letras, n);
    Letras[n-3]++;
    if(Letras[n-3] <= 70) CuartaLetra(Letras, n);
    else  Letras[n-3] = 65;
}
 
void QuintaLetra(char *Letras, int n)
{
    CuartaLetra(Letras, n);
    Letras[n-4]++;
    if(Letras[n-4] <= 70) QuintaLetra(Letras, n);
    else Letras[n-4] = 65;
}
 
int main()
{
    char Letras[] = "AAAAA";
    fp = fopen("combinacion.txt", "w");
    QuintaLetra(Letras, 4);
 
    fclose(fp);
    return 0;
}
 
 

Aun estoy mirando las formas de reducir el codigo...

Imprimir hasta "ZZZZZ" toma demasiado tiempo XD

Pongo printf y fprintf porque fprintf no imprime en consola, y es bueno ir viendo por dónde va.

El archivo se crea en la misma carpeta donde ejecutas el .exe, y no se borra (a no ser que lo hagas tú manualmente).

Al nombre de la variable le he puesto fp, pero puedes ponerle cualquier otro nombre. A mí se me ocurre cómo poder simplificar un poco el código, pero para ello necesitaré poner en una función muchos condicionales. Lo intentaré, a ver qué pasa...

Saludos!

ah! como pensaba imprime en el archivo verdad???

pues jajaj yo lo compilo desde emacs en linux mint asi que pues...
pero es verdad se crea contiguo al compilado, antes no lo veia, pero ya todo va bien, aunque mira como imprime:


no entiendo esos numeros... de verdad que no me queda claro, es un dword o algo??



no si yo se que es un nombre, pero mi pregunta es porque se define como un tipo FILE *tp, porque se usa como una referencia?? es un archivo apuntando a algo, o que significa??

muchos condicionales...muchos condicionales???? ummmmmmmmm yo estaba pensando en recursividad, aun no me funciona, pero sigo viendo.

Cuando imprimia TODO, la cpu llego a un 60% de uso (quede o.O cuando vi esto!) y me pregunto porque llego a ese punto?? parece que en memoria no consumio tanto.

Sí, imprime en el archivo.

File *fp es un puntero porque el programa necesita un puntero a un archivo para leer de este mismo o escribir en él.

¿Eso te imprime? A mí me imprime:

AAAAA00000
AAAAA00001
...
ZZZZZ99999

Y mientras el programa está en ejecución, llega al 100% de la CPU (y eso que tengo 6GB de RAM...), y sin embargo, ahora que estoy usando bastantes programas a la vez, estoy usando un 9%...

A ver si conseguimos hacer más eficiente el programa! Es un reto bastante divertido  :D

Por cierto y como que 14348907000000 ?¿ si solo se ha generado 7777 combinaciones con el programa.

Ese es el problema de usar tanta recursividad  el programa hace demasiado llamadas en foma de arbol, si se hiciera iterativo en ves de recursivo....

¿7777 combinaciones? Son demasiado pocas. A mí me hace todas (comprobado desde el fichero que genera) y son muchísimas más...

Edito:

Hay 2,75854735 × 10¹⁵ combinaciones, creo.

Saludos!

jajaj seeee 7777 es algo minusculo realmente.


lo deje a

para no imprimir esos numeros, pues no entiendo porque lo dejaste, alguna info sobre el porque debe hacerse seria de gran ayuda.
Je en esta tarde me dedique a dormir por el cansancio que tenia, y hasta hace poco tengo que mirar otras cosas, pero me voy a dedicar a hacer este problema, como dices, es algo divertido mirar como podria dejar mejor el funcionamiento, si la recursividad es algo, ummm como decirlo, jodido, pero vale la pena entenderlo.

una pregunta asi por curiosidad... cuanto os dura el programa ejecutandose y cuanto os ocupa el archivo generado?

lo pregunto porque yo para hacer esta combinacion mas corta "AAAA000 hasta ZZZZ9999" llevaba unos 20 minutos o mas y 35GB de archivo cuando le he dado a cancelar. no se si me he liado haciendo el programa o que...

gracias!

te dejo este codigo en vb6...

http://foro.elhacker.net/programacion_visual_basic/palabras_aleatorias_sin_repeticion_ayuda-t296715.0.html

en si la parte que genera las combinaciones es este... muy simple y corto verdad?...

 
Private Sub CombinateString(ByRef Str_String As String, Optional ByRef str_Fix As String, Optional ByRef Cancel As Boolean)
Dim Lng_LenStr                                  As Long
Dim Lng_LenStrIndex                             As Long
    If Cancel Then Exit Sub
    Lng_LenStr = Strings.Len(Str_String)
    If Lng_LenStr <> 1 Then
        For Lng_LenStrIndex = 1 To Lng_LenStr
            Call CombinateString(Strings.Left$(Str_String, Lng_LenStrIndex - 1) & Strings.Mid$(Str_String, Lng_LenStrIndex + 1), str_Fix & Strings.Mid$(Str_String, Lng_LenStrIndex, 1), Cancel)
        Next
    Else
        RaiseEvent StrOuput(str_Fix & Str_String, Cancel) ' <--- este en C++ seria un callback a un proceso X el cual otendria por un parametro la cadena combinada, se ejecutaria N veces... el segundo parametro seria una variable booleana para cancelar el generador de cadenas (combinaciones)...
    End If
End Sub
 
 

En unos segundos te lo subo en C++.

Duñlces Lunas.

creo que la cague en mi post anterior... te dejo la funcion que hace lo que tu quieres.

 
#include <iostream>
using namespace std;
 
string &AddWord(string &text) {
    string::reverse_iterator it = text.rbegin();
    for (; it != text.rend(); it++) {
        ++(*it);
        if (tolower(*it) >= 'a' && tolower(*it) <= 'z') break;
        (*it) = (islower(*it))? 'a': 'A';
    }
    return text;
}
 
int main() {
    string text = "ZZZx";
    cout << AddWord(text) << endl;
    cout << AddWord(text) << endl;
    cout << AddWord(text) << endl;
    cout << AddWord(text) << endl;
    cout << AddWord(text) << endl;
    cout << AddWord(text) << endl;
    cout << AddWord(text) << endl;
    cout << AddWord(text) << endl;
    cout << AddWord(text) << endl;
    cin.get();
    return 0;
}
 
 

y aquí el de las permutaciones del post anterior...

 
#include <iostream>
using namespace std;
 
size_t permutaciones (string text, string textFix, void (*callback)(string, bool), bool cancel = false) {
    size_t ret = 0;
    if (cancel) return ret;
    if (text.size()) {
        for (register size_t i = 0; i < text.size(); i++) {
            ret += permutaciones (text.substr(0, i) + text.substr(i + 1), textFix + text.substr(i, 1), callback, cancel);
            if (cancel) return ret;
        }
    } else {
        callback(textFix + text, cancel);
    }
    return ret;
}
 
void showWord(string text, bool cancel) {
    cout << text << endl;
}
 
int main() {
    permutaciones ("hola", "", showWord);
    cin.get();
    return 0;
}
 
 

Dulces Lunas!¡.

El %.5d debe ponerse porque en esta versión del código para mejorar la eficiencia hice que los números fueran separados de las letras.


El tiempo exacto no lo sé, pero sí que tarda muchísimo en finalizar y ocupa también mucho... ¿Será malo para el ordenador?  :-[

Gracias por el código, BlackZeroX (Astaroth). Ahora los miro!

Saludos!

EDITO: Finalmente son 1 188 125 718 624 combinaciones posibles!

11881125718624 combinaciones a 10 caracteres por combinacion, 118811257186240 x sizeof(char) = 118811257186240 bytes no es asi?

Saludos.

PD: Si hicieses un programa que crease varios fork() haciendo eso mismo, podrias colapsar un superordenador  :xD :xD

Sí... Demasiada memoria ocupa...

Ahora me pongo a ver qué puedo hacer para mejorarlo, pero creo que no hay mucho que hacer salvo reducir el código..., porque las combinaciones, queramos o no, van a ser 11881125718624, y como dice daniyo eso serían 11881125718624 bytes... Bueno, ya veré sobre la marcha qué hago  :xD

Saludos!

Te ha faltado un cero, piensa que son 10 caracteres por combinacion. 118811257186240  bytes = 116026618345,9375 KB = 113307244,47845459 MB = 110651,605935991 GB = 108,058208922 TB
 :o :o :o :o :o :o :o :o :o :o :o :o :o :o :o :o :o :o :o :o :o :o :o :o :o :o :o :o

Creo que esta bien...

Sí, copié mal tu resultado, pero sí que lleva el 0.

¿¿¡¡108,058208922 TB!!??  Por lo tanto, es imposible hacer el programa para ejecutarse en un ordenador "normal", ¿no? Aunque el mío sea bastante potente dudo que tenga 108,05 TB xD...

Saludos  :-[

jejej había compilado el otro còdigo ... con razón ya me parecía extraño...

Si compilaste el primer código que puse yo deberían haberte salido 11 881 376 combinaciones... Qué raro...

.
La cantidad de combinaciones desde A-Z (sin contar la Ñ) en una cadena de 10 segun este algoritmo es de (26 ^ 10) = 141167095653376 combinaciones posibles desde AAAAAAAAAA hasta ZZZZZZZZZZ.

Dulces Lunas!¡.

Pero en el código que va de la A a la Z es de cinco caracteres por combinación, y por lo tanto es de 26⁵= 11881376 combinaciones posibles.

Por cierto, a espera de que alguien conteste si es posible hacer el programa para ejecutarlo en un ordenador "normal", dejo la última versión que he hecho. En esta reduzco la extensión del código, le quito la mayor parte de las funciones recursivas y mejoro la eficiencia:

#include <stdio.h>
 
FILE *fp;
 
void numeros(char *Letras, int n)
{
 int i;
 for(i=0;i<100000;i++)
 {
     printf("%s%.5d\n",Letras, i);
     fprintf(fp, "%s%.5d\n", Letras, i);
 }
}
 
void Generador(char *Letras, int n)
{
    int count, resta=1, llamada;
    while(llamada != 5)
    {
        numeros(Letras, n);
        count = n;
        Letras[n]++;
        llamada = 0;
        while(count >= 0)
        {
            if(Letras[count] > 90)
            {
                Letras[count] = 65;
                Letras[n-resta]++;
                llamada++;
            }
            count--;
            resta++;
        }
    }
}
int main()
{
    char Letras[] = "AAAAA";
    fp = fopen("combinacion.txt", "w");
    Generador(Letras, 4);
    fclose(fp);
    return 0;
}
 

Saludos!

Queda claro que la cantidad esta dada por 26^N y debido a esto le hice una modificación a mi código...

http://foro.elhacker.net/programacion_cc/como_hacer_un_generador-t366597.0.html;msg1765220#msg1765220

 
#include <iostream>
#include <cmath>
using namespace std;
 
inline string &addWord(string &text) {
    string::reverse_iterator it = text.rbegin();
    for (; it != text.rend(); it++) {
        ++(*it);
        if (tolower(*it) >= 'a' && tolower(*it) <= 'z') break;
        (*it) = (islower(*it))? 'a': 'A';
    }
    return text;
}
 
size_t addAllWord(string text, void (*callback)(string&, bool&) = NULL) {
    bool cancel = false;
    register size_t i = 0, lim = pow(26, text.size());
    if (!callback) return lim;
    for (;(i < lim) && (cancel ==false); i++) {
        callback(addWord(text), cancel);
    }
    return i;
}
 
void showWords(string& text, bool& cancel) {
    cout << text << endl;
}
 
int main() {
    string text = "ZZZx";
    cout << addAllWord(text, showWords) << endl;
    cin.get();
    return 0;
}
 
 

DickGumshoe, yo supongo que si se puede ejecutar en un ordenador "normal", sin salida por consola y sin almacenar el resultado en un archivo de texto claro >:D No en serio, quiza se pueda hacer con combinaciones de 4 o 5, a lo sumo 6 caracteres.

Saludos.

siempre se queda muuuuy lento cuando va como en "FMMMM" ummm supongo que un core 2 duo tambien demora bastante para esta tarea  :xD :xD

el codigo en visual es nuevo para mi, porque apenas si se algo de basic, y absolutamente nada de .NET o C#.


ouch ouch ouch, es en serio?????? ouch ouch ouch.


pues eso hice, lo deje en 5 caracteres, y de 'A' hasta 'F' funciona sin problemas. me podrian explicar como hicieron el calculo de permutaciones?? el clasico nCr???

Daniyo, como bien dices, uno de 5 caracteres sí es posible ejecutarlo en un ordenador "normal", ya que el primer código que puse en este tema era de combinaciones desde AAAAA hasta ZZZZZ, y funcionaba perfectamente.

jaime.urizar (el autor del tema): Por lo que parece generar todas las combinaciones posibles desde AAAAA00000 hasta ZZZZZ99999 (sin mezclar letras y números) es imposible en un ordenador "normal". Pero eso no quiere decir que no tengamos bien el código, que era la finalidad del tema, y entonces supongo que nos quedaremos con el último, que es el más corto y eficiente:

#include <stdio.h>
 
FILE *fp;
 
void numeros(char *Letras, int n)
{
 int i;
 for(i=0;i<100000;i++)
 {
     printf("%s%.5d\n",Letras, i);
     fprintf(fp, "%s%.5d\n", Letras, i);
 }
}
 
void Generador(char *Letras, int n)
{
    int count, resta=1, llamada;
    while(llamada != 5)
    {
        numeros(Letras, n);
        count = n;
        Letras[n]++;
        llamada = 0;
        while(count >= 0)
        {
            if(Letras[count] > 90)
            {
                Letras[count] = 65;
                Letras[n-resta]++;
                llamada++;
            }
            count--;
            resta++;
        }
    }
}
int main()
{
    char Letras[] = "AAAAA";
    fp = fopen("combinacion.txt", "w");
    Generador(Letras, 4);
    fclose(fp);
    return 0;
}
 

Saludos!

EDITO:

Dato000, no había visto tu mensaje. Te explico:

Para todas las combinaciones posibles entre de 5 caracteres usando las letras del abecedario sin contar la 'Ñ', lo calculamos haciendo 26⁵=11881376 combinaciones posibles.

Así, como para cada combinación de letras la repetimos 99999 veces (en el código que va desde AAAAA00000 hasta ZZZZZ99999), multiplicamos las combinaciones posibles desde AAAAA hasta ZZZZZ por 99999 (11881376 * 99999 = 1188125718624 combinaciones en total).

Saludos!

* No digas imposible por que si se puede.
* Tu código Tiene Bastantes errores... revisa-lo con el mio y veras la diferencia... (cuando llega a por ejemplo AAAAZ se devuelve a AAAAA)...
http://foro.elhacker.net/programacion_cc/como_hacer_un_generador-t366597.0.html;msg1765302#msg1765302
* En el tema de los núcleos se tendría que separar La cadena en N donde N es la cantidad de núcleos, a su vez crear N hilos... esto es un poco mas tedioso por mi parte lo dejo asi.

Bueno mi código ya funciona al 100%

Dulces Lunas!¡.

Pero el tuyo no va de AAAAA00000 hasta ZZZZZ99999, ¿no?

Digo que es imposible porque al final hemos quedado en que se necesitaban 108,058208922 TB, ¿no?

EDITO: ¿Qué error tiene el mío? Hasta donde he probado funciona perfectamente...

La problemática de almacenamiento es despreciable... lee bien lo que se quiere.


Dulces Lunas!¡.

me gustaria a mi tambien compartir el codigo que he hecho, seguramente para nada sea el mas eficiente pero me gustaria saber como podria optimizarlo. genera la combinacion de AAAAA00000 a ZZZZZ99999 (no en el orden tipico).

#include <stdio.h>
 
#define NUM 5 //numero de letras
 
void cambiar_letras(char* letras, int* pos);
 
int main(int argc, char** argv)
{
	FILE *fd;
	char letras[]="AAAAA";
	int posLet=0, i;
 
	fd=fopen("diccionario.txt", "w");
 
	while (posLet < NUM)
	{
		for (i=0; i<100000; i++)
			fprintf(fd, "%s%.5d\n", letras, i);
 
		cambiar_letras(letras, &posLet);
	}
 
	fclose(fd);
	return 0;
}
 
void cambiar_letras(char* letras, int* pos)
{
	int i;
 
	for (i=0; i<=*pos && *pos<=NUM; i++) 
	{
		if (letras[i] < 'Z') {
			(letras[i])++;
			break;
		} else { 
			letras[i]='A';
			if ( i==*pos && (letras[i+1]=='A' || letras[i+1]=='\0') )
				(*pos)++;
		}
	}
}

pd. gracias DickGumshoe por el especificador de formato %.5d en los enteros, no tenia ni idea de que podia representarse el 1 como 00001.

.

Pero después nos pide cómo almacenarlo en un .txt... y por tanto es imposible (o eso creo xD).

Por cierto, estoy volviendo a hacer una modificación de mi código que he encontrado un error...

Saludos!

si tienes un error cambia tu limite del for y veras...

* No es imposible, solo se tendrían que usar varios HDD y a su vez varios archivos...

Dulces Lunas!¡.

No me refería a eso... El límite del for lo tengo puesto así porque el programa es para generar hasta 99999. Claro que si cambio el límite y pongo más saldrá mal, pero porque pongo %.5d, no por otra cosa...

Sí, eso de usar varios archivos es una buena idea!

Saludos!

Yo te decía que cambiaras el limite para que vieras tu error...

Dulces Lunas!¡.

He cambiado el código arreglando errores:

#include <stdio.h>
 
FILE *fp;
 
void numeros(char *Letras, int n)
{
 int i;
 for(i=0;i<100000;i++)
 {
     printf("%s%.5d\n",Letras, i);
     fprintf(fp, "%s%.5d\n", Letras, i);
 }
}
 
void Generador(char *Letras, int n)
{
    int count, resta=1, llamada;
    while(llamada != 5)
    {
        numeros(Letras, n);
        count = n;
        Letras[n]++;
        llamada = 0;
        while(count >= 0)
        {
            if(Letras[count] > 90)
            {
                Letras[count] = 65;
                Letras[count-1]++;
                llamada++;
            }
            count--;
            resta++;
        }
    }
}
int main()
{
    char Letras[] = "AAAAA";
    fp = fopen("combinacion.txt", "w");
    Generador(Letras, 4);
    fclose(fp);
    return 0;
}
 

¿Te referías a ese error?

Saludos.

.
En efecto ese era el error... y como no me quiero quedar atras con los numeros aqui lo dejo ya completo:

 
#include <iostream>
#include <iomanip>
#include <cmath>
 
using namespace std;
 
inline string &addWord(string &text) {
    string::reverse_iterator it = text.rbegin();
    for (; it != text.rend(); it++) {
        ++(*it);
        if (tolower(*it) >= 'a' && tolower(*it) <= 'z') break;
        (*it) = (islower(*it))? 'a': 'A';
    }
    return text;
}
 
size_t addAllWord(string text, void (*callback)(string&, bool&) = NULL) {
    bool cancel = false;
    register size_t i = 0, lim = pow(26, text.size());
    if (!callback) return lim;
    for (;(i < lim) && (cancel ==false); i++) {
        callback(addWord(text), cancel);
    }
    return i;
}
 
void showWords(string& text, bool& cancel) {
    for (register int i = 0; i <= 9999; i++) {
        cout << text << setw(4) << setfill('0') << i << endl;
    }
}
 
int main() {
    string text = "ZZZx";
    cout << addAllWord(text, showWords) << endl;
    cin.get();
    return 0;
}
 
 

Dulces Lunas!¡.

Bueno, entonces ya tenemos varios códigos que generan lo que se pedía en el tema  :D

BlackZeroX (Astaroth), con lo de imposible en un ordenador normal me refería a uno cualquiera, sin discos duros extras ni nada...

Saludos y gracias por avisar del error!

EDITO:

Bueno, creo que ya, a no ser que el autor del tema diga lo contrario, su duda ya está solucionada.

Aqui el primero de DickGumshoe

#include <stdio.h>
 
FILE *fp;
 
void numeros(char *Letras, int n)
{
 int i;
 for(i=0;i<100000;i++)
 {
     printf("%s%.5d\n",Letras, i);
     fprintf(fp, "%s%.5d\n", Letras, i);
 }
}
 
void Generador(char *Letras, int n)
{
    int count, resta=1, llamada;
    while(llamada != 5)
    {
        numeros(Letras, n);
        count = n;
        Letras[n]++;
        llamada = 0;
        while(count >= 0)
        {
            if(Letras[count] > 90)
            {
                Letras[count] = 65;
                Letras[count-1]++;
                llamada++;
            }
            count--;
            resta++;
        }
    }
}
int main()
{
    char Letras[] = "AAAAA";
    fp = fopen("combinacion.txt", "w");
    Generador(Letras, 4);
    fclose(fp);
    return 0;
}
 

Otra solución aportada por BlackZeroX

 
#include <iostream>
#include <iomanip>
#include <cmath>
 
using namespace std;
 
inline string &addWord(string &text) {
    string::reverse_iterator it = text.rbegin();
    for (; it != text.rend(); it++) {
        ++(*it);
        if (tolower(*it) >= 'a' && tolower(*it) <= 'z') break;
        (*it) = (islower(*it))? 'a': 'A';
    }
    return text;
}
 
size_t addAllWord(string text, void (*callback)(string&, bool&) = NULL) {
    bool cancel = false;
    register size_t i = 0, lim = pow(26, text.size());
    if (!callback) return lim;
    for (;(i < lim) && (cancel ==false); i++) {
        callback(addWord(text), cancel);
    }
    return i;
}
 
void showWords(string& text, bool& cancel) {
    for (register int i = 0; i <= 9999; i++) {
        cout << text << setw(4) << setfill('0') << i << endl;
    }
}
 
int main() {
    string text = "ZZZx";
    cout << addAllWord(text, showWords) << endl;
    cin.get();
    return 0;
}
 
 

Y otra alternativa aportada por xiruko

#include <stdio.h>
 
#define NUM 5 //numero de letras
 
void cambiar_letras(char* letras, int* pos);
 
int main(int argc, char** argv)
{
	FILE *fd;
	char letras[]="AAAAA";
	int posLet=0, i;
 
	fd=fopen("diccionario.txt", "w");
 
	while (posLet < NUM)
	{
		for (i=0; i<100000; i++)
			fprintf(fd, "%s%.5d\n", letras, i);
 
		cambiar_letras(letras, &posLet);
	}
 
	fclose(fd);
	return 0;
}
 
void cambiar_letras(char* letras, int* pos)
{
	int i;
 
	for (i=0; i<=*pos && *pos<=NUM; i++) 
	{
		if (letras[i] < 'Z') {
			(letras[i])++;
			break;
		} else { 
			letras[i]='A';
			if ( i==*pos && (letras[i+1]=='A' || letras[i+1]=='\0') )
				(*pos)++;
		}
	}
}

EXCELENTES SOLUCIONES, REALMENTE ESTAN A OTRO NIVEL.

¡Buenas!

Viendo que hay tantos codigos, aqui dejo uno mas. XD

#include <stdio.h>
 
int main(int argc, char *argv[])
{
    int i,numero;
    FILE *f;
    char letras[] = "AAAAA";
 
    f = fopen("diccionario.txt","w");
 
    do{
        for(numero = 0 ; numero < 100000 ; numero ++)
            fprintf(f,"%s%05d\n",letras,numero);
 
        letras[4]++;
 
        if(letras[4] - 1 == 'Z')
            for(i = 4 ; i  > 0 ; i--)
                if(letras[i] - 1 == 'Z')
                {
                    letras[i - 1]++;
                    letras[i] = 'A';
                }
    }while(letras[0] - 1 != 'Z');
 
    fclose(f);
 
    return 0;
}
 

¡Saludos!

ummm uno sin llamada de funciones, funciona sin problemas, pero lo detuve cuando el archivo.txt estaba en 2.1 GB... :silbar: :silbar:

Lo malo es que eso no tiene remedio... (sin discos duros ni cosas extras).

Bueno, gracias a tu post-resumen el autor del tema podrá ver todas las soluciones aportadas  fácilmente.  ;)

Saludos!

ufffff el code de do-while si que lo hace rapido¡¡ muy bueno,aunque los demás también están muy bien.

lo que pasa es que no imprime nada en terminal, asi que solo escribiendo en disco le rinde más. Pero si uno no detiene el proceso se llena el disco, es como si fuera un gusano XDD