como guardar una palabra de un archivo .txt

[aguml]

Bueno, el uso de una lista auxiliar no era eficiente porque hay varias iteraciones y por el uso doble de memoria así que despues de mucho darle vueltas y mucha ayuda para entender como hacerlo con punteros he conseguido hacerlo intercambiando los punteros de la lista:

Código PHP:

//Intercambia el contenido de dos elementos de la lista y nos devuelve el puntero al primero
//Hay que hacer que los punteros sig apunten adonde deben ya que si no es así la lista se
//rompería. Para eso uso sigAux para, una vez intercambiados los elementos, intercambiar
//sus punteros sig
Elemento * Swap(Elemento *primero, Elemento *segundo)
{
   Elemento *aux, *sigAux;

   aux = primero;
   sigAux = segundo->sig;
   primero = segundo;
   segundo = aux;
   segundo->sig = sigAux;
   primero->sig = segundo;

   return primero;
}
//-----------------------------------------------------------------------------

//Ordena el contenido de la lista
void OrdenarLista(Lista *lista)
{
   int i,j;
   Elemento *actual, *anterior;

   for (i=1; i < lista->nElementos; i++)
   {
      for (j=0, actual = lista->inicio, anterior = NULL; j < lista->nElementos-(i); j++, actual = actual->sig)
      {
         if (actual->indice >= actual->sig->indice)
         {
            //Si el elemento actual es el primero de la lista pongo al que apunta el puntero
            //sig del actual como inicio ya que serán intercambiados
            if(actual == lista->inicio)
               lista->inicio = actual->sig;

            //Si el puntero sig de actual es el mismo que el fin de la lista pongo al actual
            //como fin ya que voy a intercambiarlos
            if(actual->sig == lista->fin)
               lista->fin = actual;

            //Intercambio los elementos
            actual = Swap(actual,actual->sig);

            //Si anterior es igual a NULL será porque actual es el primer elemento de la lista
            //y por lo tanto no existe un elemento anterior
            //Si no es NULL actualizo el puntero sig del elemento anterior al nuevo elemento
            //actual despues del intercambio
            if(anterior != NULL)
               anterior->sig = actual;
         }
         //Guardo el puntero al elemento actual para la siguiente pasada
         anterior = actual;
      }
   }
} 


Espero que al menos le sirva a alguien tanto esfuerzo jejeje.

[jcdca]

bueno, ya esta casi hecho... esta todo listo, pero tengo un inconveniente, cuando recorro el archivo por primera vez y lleno la lista va bien, pero cuando lo hago la segunda vez, la primera palabra del .txt me la agrega a la lista con un espacio en blanco, o eso creo, es un caracter mas al principio, no estoy seguro de que sea un espacio. codigo= funciona todo bien, como lo tengo que entregar, menos lo que les digo de la palabra... y sin modificar el texto igualmente me agrega el caracter, no se si es cuando abro el archivo en modo lectura, que crea un caracter para poder leerlo o algo, veanlo ustedes a ver si saben que es.

Código PHP:

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h> 

#define SIZE_MAX_PALABRA 30
#define SIZE_MAX_ALFABETO 55

/* DEFINICION DE TIPOS */
    struct nodo  
    {  
         char palabra[30];  
         struct nodo*sig;  
    };  

    typedef struct nodo listaPalabra;  

/* DEFINICION DE VARIABLES GLOBALES */
    char variable[30];
    int vida =5; 
 
/* PROTOTIPOS DE FUNCIONES */
    void menu();
    void Jugar(); 
    listaPalabra * crearLista(listaPalabra *inicio);
    listaPalabra *insertarEnLista(char palabra[30],listaPalabra *inicio);
    listaPalabra *buscarPalabra (listaPalabra *lista);
    void desarrollo(int cantidad, int i);
    void limpiarCadena(char *cadena,int size);    
    int validarCantidad(int *cantidad);
    char entradaDatos(char palabra[], char introducidas[],char restantes[], int cantidad, int i,char letra);    
    void interfaz(char palabra[], char introducidas[],char restantes[], int cantidad, int i);
    void mensajeGanar(int cantidad);
    void mensajePerder();
    void modificarArchivo(listaPalabra *listaAux);

/* FUNCION PRINCIPAL */
    int main()  
    {  
        menu();  
        return(0);  
    }  
    
/* FUNCION PARA MOSTRAR EL MENU PRINCIPAL */
void menu()  
{char resp;  
  do  
  { system ("color 3");   
    system("cls");  
    printf("\n\n\t\t      * * * * * MENU DE OPCIONES * * * * *");  
    printf("\n\t\t---------------------------------------------------");  
    printf("\n\t\t\t      Juego de el ahorcado ");  
    printf("\n\t\t---------------------------------------------------\n\n\n\n");  
    printf("\t\t\t\t   (1) Jugar \n");  
    printf("\t\t\t\t   (0) salir\n");  
    do 
    {   
        fflush(stdin);
        resp=getch();  
    }while (resp < '0' || resp > '1');  
      switch(resp)  
      {  
          case '1': Jugar();  
                    break;  
          case '0': system("cls");
                 printf("\n\n\n\n    **    *  *****  ******       **       ** ******  **    **  *****  ******    ");
                 printf("    * *   *  *   *  **            **     **  **      * *  * *  *   *  **        ");
                 printf("    *  *  *  *   *   ***           **   **   ****    *  **  *  *   *   ***      ");
                 printf("    *   * *  *   *     ***          ** **    **      *      *  *   *     ***    ");
                 printf("    *    **  *****  ******           ***     ******  *      *  *****  ******    ");  
                    break;  
      }  
  }  
  while(resp!='0');  
}  

void imprimir (listaPalabra *lista)
{
     listaPalabra *auxiliar;
     auxiliar = lista;
     
     while (auxiliar != NULL)
     {
           printf("%s la lista:\n",auxiliar->palabra);
           auxiliar = auxiliar->sig;
     }
     
     return;
}

/* FUNCION PARA CARGAR ARCHIVO Y LLENAR LISTA PARA JUGAR */
    void Jugar() 
     {  
        system ("color b");  
         system("cls");  
         int cantidad,i,j,aux,x,indice,z,conseguido,listaLlena=0,nuevoNumero,comprobarNumero,continuar=0;  
         char caracter,palabra[30];
                  
        // PEDIMOS CANTIDAD DE PALABRAS Y SE VALIDA QUE SEA ENTRE 3 Y 10 
         printf("\n\n\n\n\n\n\t\tCon cuantas palabras desea jugar? (3 a 10)\n"); 
         cantidad=validarCantidad(&cantidad);      
         // INICIALIZAMOS VARIABLES Y LISTA, Y LIMPIAMOS PALABRA 
         x=1; j=0; vida=5;
         listaPalabra*lista;
        listaPalabra*listaAux; 
        limpiarCadena(palabra,SIZE_MAX_PALABRA); 
         lista=crearLista(lista);
         listaAux=crearLista(listaAux);
         
         //lista=crearLista(listaAux);
        // BUCLE QUE RECORRE DEPENDIENDO DE LA CANTIDAD DE PALABRAS QUE EL USUARIO DESEE, Y LAS ALMACENA EN UNA LISTA  
         for (i=1;i<=cantidad;i++)  
         {  
             conseguido=0;
               FILE *archivo;  
               archivo= fopen("listaDePalabras.txt","r");   
               if (archivo== NULL)  
               {  
                printf("El archivo no se encuentra"); // VALIDADACION DE QUE EXISTA EL ARCHIVO
               }  
            else  
            {    // BUCLE HASTA EL FINAL DEL ARCHIVO                         
                while (feof(archivo)==0)  
                {  
                    do  // BUCLE QUE VALIDA QUE EL CARACTER NO SEA UN SALTO DE LINEA  
                    {   
                     caracter=fgetc(archivo);  
                    }while((caracter=='\n'));  
                       
                    if (caracter!=';') // CONDICIONAL QUE VALIDA QUE AUN NO SE HA LLEGADO AL PUNTO Y COMA  
                    {                        
                        palabra[j]=caracter;  // MIENTRAS NO SE LLEGUE AL PUNTO Y COMA, GUARDA EL CARACTER EN PALABRA
                        j++;  
                    }  
                    else  
                    {   
                        fscanf(archivo,"%d",&aux);
                        //caracter=fgetc(archivo);  // SI SE LLEGO AL PUNTO Y COMA, SE LEE EL SIGUIENTE CARACTER QUE SERIA EL NUMERO
                        //aux= (int)(caracter-48);   // SE CONVIERTE ESTE NUMERO EN ENTERO
                        if (caracter=fgetc(archivo)!='\n')  // Y SE PREGUNTA SI HAY UN SALTO DE LINEA, PORQUE DE NO HABERLO ES DECIR QUE ES EL NUMERO 10
                        {
                               aux*=10;        // SI HAY SALTO DE LINEA SE MULTIPLICA EL AUX POR 10, Y NOS QUEDARIA EL NUMERO 10 GUARDADO EN AUX.                         
                          }                   // OJO!!! ESTO SE HIZO ASI PORQUE SOLO TRABAJAREMOS CON 10 PALABRAS, SI HAY MAS DE 10, ESTA FORMA NO FUNCIONARA   
                          if (aux==i)  // SE COMPARA EL NUMERO DE LA PALABRA CON EL NUMERO QUE ESTAMOS BUSCANDO
                          {                                                            
                             lista=insertarEnLista(palabra,lista);    // SI ES EL NUMERO QUE BUSCAMOS, SE GUARDA EN LA LISTA        
                            conseguido=1;                                                            
                          }
                         if (listaLlena==0) {      // ESTE CONDICIONAL LLENA UNA LISTA AUXILIAR QUE SERA USADA PARA LLENAR EL ARCHIVO .TXT
                        listaAux=insertarEnLista(palabra,listaAux);    //ESTE IF SE EJECUTA SOLO LA PRIMERA VEZ DEL CICLO, YA LUEGO NO ENTRA MAS
                      }                                    
                          limpiarCadena(palabra,SIZE_MAX_PALABRA); // SE LIMPIA LA PALABRA PARA ASI PODER ALMACENAR LA SIGUIENTE
                          j=0;                         
                    }                       
                }
                listaLlena=1; // ESTA ASIGNACION ES PARA QUE NO SE LLENE MAS LA LISTA AUXILIAR
                if (conseguido==0)   // valida que realmente halla la cantidad de palabras correctas
                {
                    printf("\n Disculpe pero hay menos palabras que las deseadas, verifique el archivo \n\n\n\n"); //se avisa al usuario del error
                    vida=-1;        // se asigna -1 para que no continue con el juego y regrese al menu principal
                    system ("PAUSE");  // se hace una pausa para que el usuario lea el mensaje
                    break;             // se rompe el ciclo
                }    
                close(archivo);  // CERRAMOS EL ARCHIVO
            }  
          }              
          // BUCLE PARA BUSCAR PALABRA POR PALABRA Y LLAMAR A DESARROLLO 
          
        for(z = 1; z <=cantidad; z++) 
         { 
               lista=buscarPalabra(lista);   
             desarrollo(cantidad,z);   //LA VARIABLE Z ES USADA SOLO PARA SABER EN QUE PALABRA ESTAMOS E IMPRIMIRLO POR PANTALLA       
        }      
        modificarArchivo(listaAux);           
    }  
    
      void modificarArchivo(listaPalabra *listaAux)
      {
          int numeroNuevo,i,continuar=1,j=0,contador;
          char numero,comprobarNumero[10];
          FILE *archivo1;
          archivo1= fopen("listaDePalabras.txt","w");
          for (contador=0;contador<10; contador++)
          {      
                 listaAux=buscarPalabra(listaAux);
            do
              {          
                numeroNuevo=(rand() % 10);
                numero= (char)(numeroNuevo+48);
                continuar=1;
                for (i=0; i<strlen(comprobarNumero);i++)
                {
                    if (comprobarNumero[i]==numero)
                    {
                        continuar=0;                        
                    }                    
                }
               }while(continuar==0);
            fprintf(archivo1,"%s%s%i\n",variable,";",numeroNuevo+1); 
            comprobarNumero[j]=numero;
            j++;
        }
        fclose(archivo1);
             
      }

/* FUNCION INICIALIZAR LISTA */
    listaPalabra * crearLista(listaPalabra *inicio)  
    {  
           inicio=NULL;  
           return inicio;  
    } 
 
/* FUNCION PARA INSERTAR EN LISTA */
    listaPalabra *insertarEnLista(char palabra[30],listaPalabra *inicio)  
    {  
        listaPalabra *nuevoNodo;  
        listaPalabra *aux;  
         
        nuevoNodo=(listaPalabra*)malloc(sizeof(listaPalabra));  
        strcpy(nuevoNodo->palabra,palabra); 
        nuevoNodo->sig=NULL;      
         
        if (inicio == NULL)  
        {  
            inicio=nuevoNodo;                    
        }  
        else  
        {  
            aux=inicio;              
            while (aux->sig !=NULL)  
            {  
                  aux=aux->sig;                   
            }             
            aux->sig=nuevoNodo;             
        }    
        return inicio;      
    }
    
/* FUNCION PARA RECORRER LISTA EN BUSCA DE LA PALABRA */
    listaPalabra *buscarPalabra (listaPalabra *lista) 
    { 
        //int indice;
         if (lista != NULL) 
         {
            char aux[25];                
            listaPalabra *auxiliar;                    
            auxiliar = lista;                            
            strcpy(variable,lista->palabra);          
            lista = lista->sig;            
         }            
         return lista;      
    } 
    
/* FUNCION QUE DESARROLLA LA PARTIDA DEL JUEGO */
    void desarrollo(int cantidad, int i) 
    { 
        system("color a");
        int cont=0,indice,contador=0,adivino,encontrada; 
        char letra,resp,palabra[50],introducidas[55],restantes[55];
        char aux[55]="A-B-C-D-E-F-G-H-I-J-K-L-M-N-O-P-Q-R-S-T-U-V-W-X-Y-Z   "; 
         
        // INICIALIZAR VARIABLES EN SU VALOR ORIGINAL 
        limpiarCadena(palabra,SIZE_MAX_PALABRA);
        limpiarCadena(introducidas,SIZE_MAX_ALFABETO);
        strcpy(restantes,aux);
    
        // BUCLE PARA LLENAR LA PALABRA DE RAYAS Y ESPACIOS 
           for (indice=0;indice < (strlen(variable))*2;indice+=2) 
        { 
            palabra[indice]=95; 
            palabra[indice+1]=32; 
        }             
        indice=0;
    
        // BUCLE QUE SE MANTIENE DURATE TODA LA PALABRA O LA PARTIDA, HASTA QUE LA PALABRA NO ACABE O LAS VIDAS NO SE ACABEN 
        while((vida > 0) && (cont < strlen(variable))) 
        {                      
            letra=entradaDatos(palabra,introducidas,restantes,cantidad,i,letra);
           
           // BUCLE QUE VALIDA QUE YA HALLAS METIDO ESA LETRA 
            for (contador=0,encontrada=0;contador<25;contador++)
            {     
                  if (letra==introducidas[contador])
                  {
                     encontrada=1;
                     break;
                  }
            }
        
            // BUCLE QUE ACTUALIZA LAS LETRAS EN RESTANTES
            for (contador=0;(contador<52) && (encontrada==0);contador++)
            {
                  if (restantes[contador]==letra)
                  {
                      while(contador<52)
                      {                           
                          restantes[contador]=restantes[contador+2];
                          restantes[contador+1]=restantes[contador+3];
                          contador++;
                      }
                      break;
                   }   
            }    
        
             // BUCLE QUE INTERCAMBIA LA RAYA POR LA LETRA EN CASO DE QUE SI ADIVINE LA LETRA     
            for (contador=0,adivino=0;(contador < strlen(variable)) && (encontrada==0);contador++) 
            {          
                   if(letra==variable[contador]) 
                   { 
                       palabra[contador*2]=letra;  
                       adivino=1; 
                       cont++;        
                   }         
            }             
        
            // CONDICIONAL QUE AGRAGA LA LETRA A INTRODUCIDAS  
            if (encontrada==0)
            {
                   introducidas[indice]=letra; 
                   introducidas[indice+1]=45;
                   indice+=2;
            }           
            
            // CONDICIONAL QUE QUITA UNA VIDA, SI NO ADIVINO Y SI LA LETRA NO HA SIDO INTRODUCIDA AUN 
            if ((adivino==0) && (encontrada==0)) 
            { 
                vida--; 
            }              
        }
    
        // CONDICIONAL PARA CUANDO PIERDAS TODDAS LAS VIDAS, MUESTRE MENSAJE 
        if (vida==0)
        {
               mensajePerder();  
           }    
    
        // CONDICIONAL PARA CUANDO ADIVINES TODAS LAS PALABRAS Y AUN TENGAS VIDAS 
        if ((i == cantidad) && (vida >0)) 
        {    
             mensajeGanar(cantidad);
        }
    }
    
/* FUNCION PARA LIMPIAR LAS CADENAS NECESARIAS */
    void limpiarCadena(char *cadena,int size)
    {
        int indice;
        for(indice = 0; indice < size; cadena[indice++] = '\0');  
    }

/* FUNCION PARA VALIDAR LA CANTIDAD DE PALABRAS INTRODUCIDAS POR EL USUARIO */
    int validarCantidad(int *cantidad)
    {
        int continuar=0;
        while (continuar==0)
        {                        
            fflush(stdin);  
            if (scanf("%d",cantidad))
            {                     
                 if((*cantidad < 3) || (*cantidad > 10)) 
                    {
                        system("cls");
                        printf("\n\n\n\n\n\n\t\tCon cuantas palabras desea jugar? (3 a 10)");       
                           printf("\n\n\t   Debe introducir un numero comprendido entre 3 y 10 \n");               
                    }
                    else 
                    {
                        continuar=1;
                    }                          
            }
            else
            {
                  system("cls");
                printf("\n\n\n\n\n\n\t\tCon cuantas palabras desea jugar? (3 a 10)");       
                   printf("\n\n\t             Debe introducir unicamente numeros \n");    
            }
        }
         return *cantidad;
    }

/* FUNCION VALIDAR ENTRADA DE DATOS */
    char entradaDatos(char palabra[], char introducidas[],char restantes[], int cantidad, int i,char letra)
    { 
        char resp;
         do
        {                     
            interfaz(palabra,introducidas,restantes,cantidad,i);
            fflush(stdin);
            letra=getch();
            if (letra>=97 && letra<=122)
            { 
               letra-=32; 
            }
            if (letra==48)
            {
              do
              {    
                 fflush(stdin);            
                printf("\n Esta seguro de abandonar la partida? S/N");
                fflush(stdin);
                resp=getch();
                if (resp>=97 && resp<=122)
                { 
                   resp-=32;
                }
                if (resp=='S') 
                {            
                    vida=-1;
                }
                if (resp=='N') 
                {
                      letra=00;
                }
              }
            while ((resp>00 && resp<=77) || (resp>=79 && resp<=82)||(resp>=84 && resp<=255));
            }
        }while((letra>=00 && letra<=47) || (letra>=49 && letra<=64) || (letra>=91 && letra<=255));
        return letra;    
    }

/* FUNCION PARA MOSTRAR INTERFAZ PRINCIPAL DEL JUEGO */
    void interfaz(char palabra[], char introducidas[],char restantes[], int cantidad, int i)
    {
          int contador;
          system("cls"); 
            printf("\n\n\n      %s \n\n",palabra);         
               printf("\n\n     Letras introducidas= %s",introducidas); 
             printf("\n\n     Letras restantes= %s",restantes);  
              printf("\n\n     palabra %i de %i ",i,cantidad); 
              printf("\n\n\n     Vidas(%i)= ",vida); 
             contador=0;         
            while (contador<vida) 
            {  
                printf(" %c ",3);  
                contador++; 
            }          
            printf("\n\n\n     Salir de la partida tecla(0)"); 
            printf("\n\n\n\n\t                          Ingrese letra\n");
    }
    
/* FUNCION PARA MOSTRAR MENSAJE POR GANAR */
    void mensajeGanar(int cantidad)
    { char resp;    
        do
           {
               system("cls");system("color b"); 
               printf("\n\n\n    ******     ***     ***    **     ***     ******  ******** ******     ");
               printf("\n    **        ** **    ** **  **    ** **    ***        **    **       ");
               printf("\n    ** ***   **   **   **  ** **   **   **     **       **    ***       ");
               printf("\n    **   *  ** *** **  **   ****  ** *** **     ***     **    **        ");
               printf("\n    ****** **       ** **    *** **       ** ******     **    ******     ");
               printf("\n\n\n              FELICIDADES!!! Logro adivinar las %i palabras",cantidad);
               printf("\n\n                      Desea volver a jugar? S/N \n\n");
                  fflush(stdin);
               resp=getch();
               if (resp>=97 && resp<=122)
               { 
                   resp-=32;
               }
       }while ((resp>=00 && resp<=77) || (resp>=79 && resp<=82)||(resp>=84 && resp<=255));
       switch(resp)  
       {  
               case 'S': Jugar();   
                      break;  
            case 'N': vida--;  
                      break;  
       } 
    }

/* FUNCION PARA MOSTRAR MENSAJE POR PERDER */
    void mensajePerder()
    {  char resp;
        if(vida!=-1)
           {
           do
           {
               system("cls"); 
               printf("\n\n\n\n  ******     ***     ***     ***  ******     ******* **       ** ****** ******* ");
               printf("  **        ** **    ** ** ** **  **         **   **  **     **  **     **   ** ");
               printf("  ** ***   **   **   **  ***  **  ****       **   **   **   **   ****   ******  ");
               printf("  **   *  ** *** **  **       **  **         **   **    ** **    **     **   ** ");
               printf("  ****** **       ** **       **  ******     *******     ***     ****** **    **"); 
            printf("\n\n                 lo siento! mejor suerte para la proxima ;) \n\n"); 
               printf("\n\n                         Desea volver a jugar? S/N \n\n");
                  fflush(stdin);
               resp=getch();
               if (resp>=97 && resp<=122)
               { 
                   resp-=32;
               }
               }while ((resp>=00 && resp<=77) || (resp>=79 && resp<=82)||(resp>=84 && resp<=255));
               switch(resp)  
               {  
                  case 'S': Jugar(); 
                          break;  
                  case 'N': vida--;  
                          break;  
               } 
       }
    } 


[aguml]

sin verlo en el depurador no puedo decirte pero tiene toda la pinta de que al terminar la primera vez se queda algo residual en el flujo de entrada. Prueba a poner un fflush(stdin) antes de la funcion que rellena la lista. Seguramente no sea un espacio sino un salto de pagina o eof o algo asi.

[aguml]

mira, estoy en la calle viendolo desde el movil pero creo que di con el fallo. Tienes dos funciones, ganar y perder o algo asi donde muestras el mensaje de que gana o pierde y luego preguntas si quiere jugar una nueva partida y usas un fgetch para obtener la respuesta. Pon un fflush(stdin) despues de ese fgetch en ambas funciones y si tienes mas comprobaciones de ese estilo en otras funciones haz igual. ¿Cual es el problema? fgetch() captura un caracter pero tu en realidad introduces 2, el que deseas y el intro que es un salto de linea. Asegurate siempre de si es necesario un fflush detras de un getch o fgetch (será necesario siempre que se tenga que ntroducir un caracter por teclado y pulsar intro. Ya nos cuentas si se solucionó. Por cierto, si el trabajo tiene que ser en C, no puede haber declaraciones de variables en cualquier sitio, eso se permite en c++ pero en c no.

[jcdca]

si tienes razón no es un espacio en blanco, pensé que si porque cuando imprimía la lista para ver que pasaba, una de las palabras salia mas separada del margen que las otras por eso pensé que era un espacio, pero no lo es, ya lo comprobé, puse el fflush que me dijiste cuando relleno la lista, pero nada, sigue poniéndome ese carácter, no se que pueda ser jeje

y en cuanto a los fflush que me dices que faltan en la parte de mostrar los mensajes si gane o perdí, debe ser que lo viste mal, si los tengo, o sea que eso tampoco es. y los de las variables en cualquier lugar imagino que te refierieres a la que declaro como globales fuera de las funciones no? o a alguna que tengo en medio de alguna sentencia o algo así?

[jcdca]

lo depure y la segunda vez que pasa, con la palabara queso, que es la primera del archivo me la agrega con '377QUESO' y no se porque hace eso, la variable que contiene la palabra se llama justamente así, variable, y la limpio antes de agregar la nueva palabra, es decir que ya se bebe guardar así con esos números en la lista, pero cuando yo lo guardo en la lista, la guardo con una variable llamada palabra, esa también la limpio, y esa palabra la lleno con la variable caracter que es la que recorre el archivo, y esa variable caracter la valide con un ciclo, del cual no se sale si caracter es algo distinto a una letra o un punto y como, es decir lo único que puede a ver en esa palabra son letras, como llegan esos numero no se jejeje

[aguml]

Antes de nada pido perdon a los admins por lo que voy a hacer pero el movil en esta web no me deja poner saltos de linea y supongo que es por algun script.

printf("\n                                                                         "); 

printf("\n\n\n              FELICIDADES!!! Logro adivinar las %i palabras",cantidad); 

printf("\n\n                      Desea volver a jugar? S/N \n\n"); 

fflush(stdin); 

resp=getch(); 

if (resp>=97 && resp<=122)
   resp-=32;
while ((resp>=00 && resp<=77) || (resp>=79 && resp<=82)||(resp>=84 && resp<=255)); 

  switch(resp)   



justo despues del getch necesitas un fflush para limpiar el flujo de entrada ya que al salir del while tendras un '\n' residual que se meterá en el primer lugar que solicites info con un scanf o getch. En la de perdiste igual. Lo otro, cuando yo creo un proyecto de C y pego tu codigo saltan las alarmas, en C no puedes declarar variables en cualquier sitio, en una funcion cambias el color del texto de la consola y luego declaras una variable. A mi en C no me deja ni compilar ya que eso no se permite.

[jcdca]

aa ok no sabia que despues habia que poner otro, pense que solo era antes del getch, bueno ya se lo pongo y lo de la variable, debe ser que se me paso, voy a revisar todo el codigo a ver, no sabia eso de c pero igual yo siempre las coloco al principio de la funcion por costumbre, debe ser que se me paso, y ya solucione lo del problema de la palabra, ya les dijo que era y les paso el codigo final