¡Hola!

Puedes hacerlo con un bucle for. Recorres la primera cadena y vas asignándole cada carácter a la cadena2.

Si tienes alguna duda pregunta 

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!

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  

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

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!

Bueno, empiezo poco a poco:

Si en main() llamas a la función y le vas a asignar un valor a una variable a partir de esta, la función debe devolver algo, no ser void (a parte, en la función pones "return;", a pesar de que no devuelves nada y la función es void).

El número no va a ser nunca un '\0', no estás trabajando con cadenas de caracteres...

Ah, y en main() debes pasarle como parámetros a funcionRecursiva la variable f, no el número 0.

Respecto al algoritmo para invertir el número... Podrías averiguar cuántas cifras tiene el número (en otra función), dividiendo entre 10 el número int hasta que te de 0. Entonces, una vez tengas eso, se lo pasas por parámetros a la función recursiva. Entonces, sabiendo, por ejemplo, que el número 123 tiene 3 cifras, puedes hacer esto:

resultado = (num % 10) * 10^2;
num/10;

Así, de forma recursiva, invertirás el número. Seguramente haya alguna forma más sencilla de explicar, pero es lo que se me ha ocurrido ahora mismo  .

Saludos.

¿Qué has intentado? Es para poder ayudarte con tus dudas 

Saludos

Le dije eso porque las dudas que está preguntando son para un trabajo, y por eso en los temas que crea no pone el código entero, y como hace unos días ya le dije que le tenía que asignar memoria dinámica, en el mensaje anterior supuse que ya tenía una función en otra parte del código que lo hiciera.

Saludos!

Sí, yo creo que PHP + html + CSS tienen mucha salida laboral, ya que hoy en día la mayor parte de las empresas tienen webs, y no solo tienen que hacerlas, sino también tienen que editarlas, mantenerlas, solucionar bugs...

De todas formas que te lo confirme alguien, ya que no estoy muy bien informado sobre este tema.

Saludos.

¡Hola!

No funciona bien porque lías las variables. Pones:

 if( texto[i] == ' ' )/* si hay un espacio*/

Sin embargo, en el bucle for de después los espacios se los quitas a palabra, no a texto , por tanto la modificación se hará cuando encuentre un espacio en la cadena original, y no en la que estás editando, y te dará mal. Quedaría así:

for( i = 0 ; texto[i] != '\0' ; i++ )
     {
          if( palabra[i] == ' ' )/* si hay un espacio*/
          {
              for( j = i+1 ; palabra[j] != '\0' ; j++ )
              {
                   palabra[j-1] = palabra[j];
 
              }
        palabra[j-1] = '\0';
          }
 
     }

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!