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!

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

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.

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.

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!

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!

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...

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!

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!

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

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