Foros Club Delphi

Foros Club Delphi (https://www.clubdelphi.com/foros/index.php)
-   C++ Builder (https://www.clubdelphi.com/foros/forumdisplay.php?f=13)
-   -   como guardar una palabra de un archivo .txt (https://www.clubdelphi.com/foros/showthread.php?t=87174)

jcdca 24-11-2014 17:28:05
como guardar una palabra de un archivo .txt
 
necesito sacar una palabra de un archivo .txt con el siguiente formato:
QUESO;5
PLANCHA;4
TORTUGA;9
ZAPATO;6
HORMIGA;1
UNIVERSIDAD;3
TECLADO;8
INFORMATICA;7
INGENIERIA;2
LETRERO;10


el numero es el orden en como debo sacarla, y guardala en una variable. COMO LO HARIA? ESTO SERIA PARA EL LENGUAJE C

Casimiro Noteví 24-11-2014 17:30:58
¿Y qué parte no sabes?, ¿qué codigo tienes?, ¿dónde tienes el problema?

jcdca 24-11-2014 17:38:37
yo leo el archivo, pero lo leo por caracteres, pero cuando trato de poner cada caracter en una sola variable no puedo, no se hacerlo en c.

Código PHP:
void tomarpalabra(){
     system ("color b");
     system("cls");
     int cantidad;
     char caracter,palabra;     
     printf("\n\t\t\t  ¿Con cuantas palabras desea jugar? ");  
     scanf("%d",&cantidad);
     FILE *archivo;
     archivo= fopen("prueba.txt","r"); 
     if (archivo== NULL){
            printf("lel archivo no se encuentra");}
            else{                
                while (feof(archivo)==0){
                   if (caracter!=";"){
                     caracter=fgetc(archivo);
                     palabra+=caracter;}
                  else{
                       break;}
                    } }  
     printf("\n %s",palabra);                 
     getch();    
    } 
todavia falta validar algunas cosas, como los numero y eso, pero cuando logre guardar una palabra en la variable ya hare esa parte, me interesa es guardar una palabra al menos, ya despues me encargo del orden.... el programa corre, pero al momento de imprimir la palabra printf("\n %s",palabra) me da un error y se sale. no se porque las librerias que tengo son:
Código PHP:
#include <stdio.h>
#include <stdlib.h>   
#include <string.h> 

Casimiro Noteví 24-11-2014 17:51:23
Cita:
Empezado por jcdca (Mensaje 485430)
me da un error y se sale.
¿Y qué error es?

Por cierto, bienvenido a clubdelphi, ¿ya leiste nuestra guía de estilo?, gracias por tu colaboración :)

Recuerda poner los tags al código fuente, ejemplo:



Gracias :)

jcdca 24-11-2014 18:15:25
1 Archivos Adjunto(s)
esa es la imagen, me sale una ventana emergente.

Casimiro Noteví 24-11-2014 18:27:17
Depúralo paso a paso para encontrar la línea que te da el problema.

aguml 24-11-2014 18:58:06
Tienes varios fallos:

Código PHP:
palabra+=caracter; 
Eso no está bien porque usas para guardar la cadena una variable char y no un array. No lo he probado pero pon por ejemplo:

Código PHP:
char palabra[50]; 
Ademas tampoco se puede concatenar asi un array de caracteres ya que lo que haces es incrementar el valor de palabra[0]. Usa strcat para concatenar cada caracter o usa un indice que irias incrementando para ir copiando cada caracter uno tras otro. Por ejemplo:

Código PHP:
char palabra[50];
int indice = 0;

while(!feof(fichero)){
    caracter = fgetc();
    palabra[indice] = caracter;
    indice++;
    if(caracter == ';')
        break;
}
palabra[indice] = '\0'; 
Ojo, no está probado pero la idea es esa.

aguml 24-11-2014 19:29:36
Esto está probado y hace lo que quieres aunque yo en este caso usaria mejor fscanf y me quitaba de lios de leer caracter a caracter pero bueno:

Código PHP:
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char* argv[])
{
   int cantidad, x, indice;
   char caracter;
   char palabra[50];
   FILE *archivo;

   printf("\n\t\t Indique el numero de palabras a usar: ");
   scanf("%d",&cantidad);

   archivo= fopen("prueba.txt","r");

   if (archivo== NULL){
      printf("\nEl archivo no se encuentra.\n");}
   else{
      for(x = 0; x < cantidad; x++)
      {
         indice=0;
         while (!feof(archivo)){

            do{
               caracter = fgetc(archivo);
            }while(caracter == '\n');

            if (caracter != ';'){
               palabra[indice] = caracter;
               indice++;
            }else{
               palabra[indice] = '\0';
               printf("\n %s",palabra);
               break;
            }
         }
      }
   }
   printf("\n\n");
   system("PAUSE");;

   return 0;
}
//--------------------------------------------------------------------------- 

ecfisa 24-11-2014 23:16:07
Hola jcdca.
Cita:
Empezado por jcdca (Mensaje 485426)
necesito sacar una palabra de un archivo .txt con el siguiente formato:
QUESO;5
PLANCHA;4
TORTUGA;9
ZAPATO;6
HORMIGA;1
UNIVERSIDAD;3
TECLADO;8
INFORMATICA;7
INGENIERIA;2
LETRERO;10

el numero es el orden en como debo sacarla, y guardala en una variable. COMO LO HARIA? ESTO SERIA PARA EL LENGUAJE C
No me quedó muy claro lo que solicitas...
Pero te pongo un ejemplo que lee el archivo, separa las palabras de los números tomando en cuenta el delimitador ";" y va almacenando las palabras en un arreglo cuyo índice está dado por el número leido:
Código PHP:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_WORDS 1024

int main()
{
  FILE *fp;
  char vstr[MAX_WORDS][30] = {0};
  char cad[40], aux[30], num[10], *ch;
  int  i, ix;

  if ((fp = fopen("Archivo.TXT", "rt")) == NULL) {
    perror("Error");
    fclose(fp);
    return 1;
  }

  while ( !feof(fp) ) {
    fgets(cad, 40, fp);    
    ch = strchr(cad, ';');
    strncpy(aux, cad, ch-cad);
    aux[ch-cad]= '\0';
    strncpy(num, cad+(ch-cad+1), 10);
    num[10]= '\0';
    strcpy(vstr[atoi(num)], aux);
  }
  fclose(fp);

  for(i = 0; i < MAX_WORDS; i++)
    if (strlen(vstr[i]) > 0) printf("%d %s\n", i, vstr[i]);

  getchar();
  return 0;
} 
Saludos :)

jcdca 25-11-2014 02:42:01
listo gracias, son unos genios jeje... es que nunca había usado el lenguaje c y hay cosas que se me complican todavía... ya me corre bien ;) gracias a todos.. era eso de concatenar así: palabra+=caracter; lo puse como me dijeron con un indice y corre, pero ahora tengo otra duda, estoy tratando de que imprima solo una palabra, por ejemplo:
QUESO;5
PLANCHA;4
TORTUGA;9
ZAPATO;6
HORMIGA;1
UNIVERSIDAD;3
TECLADO;8
INFORMATICA;7
INGENIERIA;2
LETRERO;10

de esa lista que les di antes también, yo leo carácter por carácter, guardando la palabra, hasta llegar al punto y coma, cuando llego al punto y coma leo el numero y con un if lo comparo con el numero 1, para ver si es la primera palabra que en este caso seria hormiga, si no es la primera, borro la palabra y sigo buscando hasta conseguirla. asi tengo el código:

else
{ caracter = fgetc(archivo); //esto me lee el numero que esta al lado del punto y coma
int aux = (int) (caracter - 48); //esto me convierte ese numero en entero
if (aux==x) //esto me compara ese numero con x, que en este caso es 1
{palabra[i] = '\0';
printf("\n %s",palabra); getch(); break;
}else {}


el código así si funciona, pero me imprime todas las palabras hasta llegar a la primera, QUESOPLANCHATORTUGAZAPATOHORMIGA y se detiene cuando llega a la primera... la cosa es que necesito vaciar la variable para que no me las guarde todas, si no solo la ultima palabra... esa parte de vaciar tendría que ponerla en el ultimo else si no me equivoco... intente poniendo en el else esto: *palabra = '\0';, y nada, si pongo eso no me imprime nada de nada, no me da error pero tampoco me imprime.... también intente con palabra[0]=0; y lo mismo no imprime nada. probé también poniendo palabra[i] = '\0'; en el else y no hace nada, me sigue imprimiendo todas las palabras hasta la llegar a la primera.. y con la funcion memset() me da un error no se si es que me falta alguna librería o algo.

el getch(); es solo para que se detenga y ver si imprimia algo. y el break es para romper el ciclo, que imagino que ya lo saben, pero bueno jeje

ecfisa 25-11-2014 03:17:46
Hola jcdca.

Por favor, cuando incluyas código en tus mensajes usa las etiquetas como indica la siguiente imágen:


Saludos y gracias por tu colaboración :)

aguml 25-11-2014 11:34:07
Creo que te complicas mucho la vida, yo usaria archivos con registros de tamaño fijo.
En este ejemplo puedes ver como crear un archivo secuencial y lo relleno y luego busco en el tanto por nombre como por numero de registro. Es mucho mas sencillo de manejar.

Código PHP:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define TAM_MAX_PALABRA 50
int main(int argc, char* argv[])
{
   struct{
      char palabra[TAM_MAX_PALABRA];
      int index;
   }registro;

   char nombre[TAM_MAX_PALABRA];
   int cantidad, x, indice, encontrada, nread, salir=0;
   char caracter;
   FILE *archivo;

   //ZONA DONDE CREO EL ARCHIVO SECUENCIAL Y LO RELLENO CON LOS REGISTROS
   printf("\nIndique el numero de palabras a usar: ");
   scanf("%d",&cantidad);

   archivo = fopen("prueba.txt","w"); //Abro el fichero para escritura

   if(archivo != NULL){ //Si el archivo se ha abierto correctamente...
      for(x = 0; x < cantidad; x++){
         printf("\n\nIntroduce el nombre del registro %d: ", x);
         fflush(stdin); //Limpiamos el buffer de entrada
         fgets(registro.palabra,TAM_MAX_PALABRA,stdin); //es mas recomendable ya que permite guardar cadenas con espacios
         printf("\nIntroduce el numero del registro %d: ", x);
         scanf("%d",&registro.index);

         fwrite(&registro,sizeof(registro),1,archivo); //Guardo el registro
      }
      fclose(archivo); //Cierro el archivo
   }

   //ZONA DONDE BUSCO EL REGISTRO DESEADO
   archivo= fopen("prueba.txt","r");

   if (archivo== NULL){
      printf("\nEl archivo no se encuentra.\n");
   }else{
      do{
         //Mostramos el menú y esperamos hasta que se elija una opcion correcta
         system("CLS"); //Limpiamos la pantalla
         printf("\n\nELIGE EL TIPO DE BUSQUEDA\n");
         printf("-------------------------\n\n");
         printf("\t1.Por indice\n");
         printf("\t2.Por nombre\n");
         printf("\t3.Salir\n\n");
         printf("\tOpcion: ");
         scanf("%d",&x);

         switch(x)
         {
            case 1:
               printf("\nElige el indice a buscar: ");
               scanf("%d",&indice);
               break;

            case 2:
               printf("\nElige el nombre a buscar: ");
               fflush(stdin); //Limpiamos el buffer de entrada
               fgets(nombre,TAM_MAX_PALABRA,stdin); //es mas recomendable ya que permite guardar cadenas con espacios
               break;

            case 3:
               salir = 1;
               break;

            default:
               printf("\n\tValor introducido incorrecto.");
               printf("\n\tPulse Intro para continuar.");
               fflush(stdin); //Limpiamos el buffer de entrada
               getchar(); //Esperamos a que se pulse intro
         }
      }while(x < 1 || x > 3); //Si elegimos una opcion correcta saldremos del bucle

      if(salir == 0){
         encontrada = 0;

         while (!feof(archivo)){
            nread = fread(&registro,sizeof(registro),1,archivo);

            if(nread == 0) //Si no lee mas registros es porque llegamos al final
               break;

            switch(x)
            {
               case 1:
                  if(indice == registro.index){
                     printf("\nPalabra encontrada: %s", registro.palabra);
                     encontrada = 1;
                  }
                  break;

               case 2:
                  if(strcmp(nombre, registro.palabra) == 0){
                     printf("\nPalabra encontrada. Registro: %d", registro.index);
                     encontrada = 1;
                  }
                  break;
            }
         }

         if(encontrada == 0)
            printf("\nPalabra no encontrada.");

         fclose(archivo); //Cerramos el archivo
         printf("\n\n");
         system("PAUSE");
      }
   }
   return 0;
}
//--------------------------------------------------------------------------- 

jcdca 25-11-2014 20:44:10
ya pude hacerlo, pero ahora tengo otro problemita :) recorro el archivo y saco las palabras en orden, y llamo a la funcion insertarenlista para meter todas las palabras en orden en una lista, al parecer si la llena o eso creo yo, pero al momento de imprimirla me muestra simbolos extraños, no se si es que la lleno mal, o que la imprimo mal o lo que sea, alguien sabe que tengo mal?

Código PHP:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct nodo
{
  char palabra[30];
  struct nodo*sig;
};

typedef struct nodo listaPalabra;

listaPalabra * crearLista(listaPalabra *inicio)
{
   inicio=NULL;
   return inicio;
}

listaPalabra *insertarEnLista(char palabra[30],listaPalabra *inicio)
{
       listaPalabra *nuevoNodo;
       listaPalabra *aux;
       
       nuevoNodo=(listaPalabra*)malloc(sizeof(listaPalabra));
       nuevoNodo->palabra[30]=palabra[30];
       nuevoNodo->sig=NULL;
       
              
       
       if (inicio == NULL)
       {
             inicio=nuevoNodo;                  
       }
       else
       {
           aux=inicio;
           
           while (aux->sig !=NULL)
           {
                 aux=aux->sig;                 
           }           
           aux->sig=nuevoNodo;           
       }  
       return inicio;    
}

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


void Jugar(){
     system ("color b");
     system("cls");
     int cantidad,i,j,aux,x,indice;
     char caracter,palabra[30];   
     printf("\n\t\t\t  ¿Con cuantas palabras desea jugar? ");  
     scanf("%d",&cantidad);
     x=1; i=1; j=0;
     listaPalabra*lista;
     lista=crearLista(lista);
     while (i<=cantidad)
     {
       FILE *archivo;
       archivo= fopen("prueba.txt","r"); 
       if (archivo== NULL)
       {
            printf("El archivo no se encuentra");}
            else
            {                          
                while (feof(archivo)==0)
                {
                       do
                       { 
                         caracter=fgetc(archivo);
                       }while(caracter=='\n');
                     
                   if (caracter!=';')
                   {                      
                      palabra[j]=caracter;
                      j++;
                   }
                  else
                  {
                     caracter=fgetc(archivo);
                     aux= (int)(caracter-48);                     
                     if (aux==i)
                     {                                                         
                        lista=insertarEnLista(palabra,lista); 
                        imprimir(lista);      
                      }                                          
                      indice=0;
                      while (indice<20)
                      {
                         palabra[indice]=0;
                         indice++;
                      }
                      j=0;
                       
                  } 
            }  
                close(archivo);
            } 
       
       i++;
     }
                                    
     getch();    
     }



void menu()
{char resp;

  do
  { system ("color b"); 
       system("cls");
    printf("\n\n\t\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
     resp=getch();

    while (resp<'0' || resp>'1');
    switch(resp)
     { case '1': Jugar();
         break;
      case '0': 
         break;
     }
  }
  while(resp!='0');
}


   
int main()
{
 menu();

 return(0);
} 

aguml 25-11-2014 21:53:54
lo he mirado por encima en el movil y la verdad es que no tiene mucho que ver con lo que mostrabas antes pero a simple vista, en la funcion que añade nuevos registros veo "nuevoNodo->palabra[30]=palabra[30]; " y eso está mal. Lo que haces es copiar el caracter 30 y solo ese. Puedes optar por usar strcpy, strncpy, o un bucle que copie todo el array pero no se puede copiar una cadena con un simple igual ya que lo que haces en realidad es asignar la direccion y no su contenido y al cambiar el contenido del array cambia en ambos.

jcdca 25-11-2014 22:59:06
Para que sepan esto es lo que tengo que hacer:

Consiste en un juego donde el usuario deberá adivinar un conjunto de palabras las cuales serán cargadas desde un archivo con formato txt (su formato será indicado más adelante en el presente documento).
El juego consiste en que una vez cargue una lista de palabras a adivinar por el usuario, este deberá ir ingresando letras por el teclado, en caso de que la letra introducida pertenezca a la palabra deberá mostrarse por pantalla, en caso contrario, deberá restarle una vida.
Durante la partida el usuario podrá equivocarse cinco (5) veces máximo, luego de cometer este número de equivocaciones, la partida se dará por terminada y se le deberá notificar dicha situación, dándole la oportunidad de iniciar una nueva.
Al iniciar una partida se le deberá preguntar al usuario cuantas palabras desea que tenga la partida, siendo el mínimo 3 y el máximo 10, se leerán las todas las palabras que contenga el archivo y se mostrará dicho número introducido por el usuario siguiendo el orden que se muestra en la sección de estructura del archivo.
Las letras introducidas indican las teclas que van presionando los usuarios (deben omitirse los caracteres especiales tales como ñ, á, #, etc. Así como números 123456789, el número cero (0) si debe de leerse al ser introducido por teclado ya que será interpretado como la instrucción para finalizar la partida por parte del jugador.
Al finalizar la partida, debe de preguntársele al usuario nuevamente el número de palabras a ser mostradas, leerse la totalidad del archivo, ordenarlas según el formato y desplegar la cantidad de palabras indicadas por el usuario.
Para la lista de palabras a ser mostradas durante la partida deberá utilizarse obligatoriamente una lista u otro conjunto de manejo dinámico, bajo ningún concepto se permite utilizar arreglos para tal fin, el equipo que utilice este elemento para mostrar las palabras a ser utilizadas en la partida será reprobado lamentablemente con una nota de 01 en dicha entrega.
Las letras restantes, indican el resto de letras del abecedario que el usuario puede introducir todavía para la palabra que se muestra en pantalla.
Cada vez que se pase a una nueva palabra, la lista de letras introducidas y restantes deben reiniciarse, en el caso de las introducidas ponerse en blanco, en caso de las restantes, mostrar todo el abecedario (Omitir la letra ñ).
La siguiente línea de la interfaz deberá mostrar la palabra por la que va el jugador de las 10 cargadas.
Las vidas restantes, 5 en total, deberán mostrarse en pantalla con algún símbolo, corazón por ejemplo, cada vez que el usuario se equivoque, es decir introduzca una letra que no pertenezca a la palabra en pantalla se le restará una vida de las 5 disponibles.
Es importante resaltar que las vidas del usuario son para toda la partida, no por palabra, razón por la cual las mismas no deben reiniciarse al pasar a la siguiente palabra como si ocurre con las listas de letras introducidas y letras restantes.
Por último, como de indico anteriormente, debe mostrarse la opción para salir de la partida, es decir la tecla 0, si el usuario introduce dicho carácter, la partida deberá terminar y volver a leerse el archivo de 10 palabras ordenadas según se indique en la estructura del mismo.
En caso de que el usuario logre pasar las 10 palabras de la partida, el juego deberá notificarle que ha concluido con éxito la misma, felicitándolo y volviendo a iniciarse una nueva partida una vez el usuario haya culminado la misma.

Ya llene la lista con las palabras del archivo, ahora quiero sacar una por una para comparar las letras de la palabra con las introducidas por el usuario

aguml 26-11-2014 09:05:51
a ver, cuando trabajas con listas, al crearla, guardas en un puntero la direccion al primer miembro de la lista y luego simplemente usas una nueva estructura de ese tipo a la que le asignas la direccion de ese puntero y tendras al primer miembro, para leer el siguiente le asignas al puntero la direccion que contiene next en tu caso y asi hasta que next sea null. Si pones todo el proyecto te podremos ayudar mas eficientemente ya que si no nos tocaria adivinar cosas. Un detalle, si usas malloc no te olvides de usar free para liberar la memoria de todos sus miembros.

aguml 26-11-2014 10:43:39
Aqui se explica bien claro y sencillo el funcionamiento de las listas enlazadas simples que es lo que estás usando: http://es.kioskea.net/faq/2842-la-lista-enlazada-simple

PD: No te vamos a hacer el trabajo pero si pones tu codigo y nos dices en que fallas pues te podriamos ayudar jejeje.

jcdca 26-11-2014 17:31:20
Cita:
Empezado por aguml (Mensaje 485573)

PD: No te vamos a hacer el trabajo pero si pones tu codigo y nos dices en que fallas pues te podriamos ayudar jejeje.
jajaja claro que no me van a hacer el trabajo, la idea es hacerlo yo y aprender jeje, yo puse lo que me mandaron para que supieran mas o menos que es lo que trato de hacer y sea mas fácil al ayudarme, porque vi que hay algunas preguntas que hice que no entendían, entonces por eso mande el enunciado, estoy tratando de hacer un juego de el ahorcado pero con las instrucciones que me dieron.... la duda anterior ya la resolví gracias... déjenme adelantar y acomodar un poco mas el código y se los paso junto con las dudas que se me presentaron ;)

jcdca 27-11-2014 06:37:58
bueno aquí esta el código

Código PHP:
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 

void desarrollo(int cantidad, int i);

struct nodo 
{ 
  char palabra[30]; 
  struct nodo*sig; 
}; 

typedef struct nodo listaPalabra; 

char variable[30];

listaPalabra * crearLista(listaPalabra *inicio) 
{ 
   inicio=NULL; 
   return inicio; 
} 

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;     
} 

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

listaPalabra *buscarPalabra (listaPalabra *lista)
{
     if (lista != NULL)
     {                   
            listaPalabra *auxiliar;                   
            auxiliar = lista;                   
            strcpy(variable,lista->palabra);                   
            lista = lista->sig;
     }       
     return lista;     
}

void Jugar()
 { 
     system ("color b"); 
     system("cls"); 
     int cantidad,i,j,aux,x,indice,z; 
     char caracter,palabra[30];    
     printf("\n\n\t\tCon cuantas palabras desea jugar? (3 a 10)\n");   
     scanf("%d",&cantidad); 
     do
     {
        if((cantidad<3) || (cantidad>10))
        {
           system("cls"); 
           printf("\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"); 
           scanf("%d",&cantidad);    
        }
     }while((cantidad<3) || (cantidad>10));
     x=1; i=1; j=0; 
     listaPalabra*lista; 
     lista=crearLista(lista); 
     while (i<=cantidad) 
     { 
       FILE *archivo; 
       archivo= fopen("prueba.txt","r");  
       if (archivo== NULL) 
       { 
            printf("El archivo no se encuentra");
       } 
            else 
            {                           
                while (feof(archivo)==0) 
                { 
                     do 
                     {  
                      caracter=fgetc(archivo); 
                     }while(caracter=='\n'); 
                      
                    if (caracter!=';') 
                    {                       
                       palabra[j]=caracter; 
                       j++; 
                    } 
                   else 
                   { 
                      caracter=fgetc(archivo); 
                      aux= (int)(caracter-48);                      
                      if (aux==i) 
                      {                                                          
                         lista=insertarEnLista(palabra,lista); 
                      }                                           
                      indice=0; 
                      while (indice<20) 
                      { 
                          palabra[indice]=0; 
                          indice++; 
                      } 
                      j=0;                        
                   }  
                }   
                close(archivo); 
            }          
       i++; 
     }      
    for(z = 1; z <=cantidad; z++)
    {
         lista=buscarPalabra(lista);
         desarrollo(cantidad,z);         
    }
     getch();     
 } 

void desarrollo(int cantidad, int i)
{
    int vidas=6,cont=0,indice=0,contador=0,adivino;
    char letra,palabra[30],introducidas[52],restantes[52],aux[52]="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";
    printf("%s\n",variable);
    while (indice < (strlen(variable))*2)
    {
        palabra[indice]='_';
        palabra[indice+1]=' '; 
        indice+=2;
    }
    indice=0;
    while (indice<52) 
    { 
         introducidas[indice]=0; 
         indice++; 
    } 
    indice=0;
    strcpy(restantes,aux);
      while((vidas > 0) && (cont < strlen(variable)))
    {       
        system("cls");
        printf("%s",variable);
        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)= ",vidas);
        contador=0;        
        while (contador<vidas)
        {
            printf(" * "); 
            contador++;
        }        
        printf("\n\n\n     Salir de la partida tecla(0)");
        printf("\n\n\n\n\t                          Ingrese letra\n");
        scanf("%c",&letra);
        adivino=0;
        contador=0;
        while (contador < strlen(variable))
        {         
           if(letra==variable[contador])
           {
                  palabra[contador*2]=letra; 
               adivino=1;
               break;        
           }           
           contador++;
        }
        if (adivino==0)
        {
            vidas--;
        }
        introducidas[indice]=letra;
        introducidas[indice+1]="-";
        indice+=2;
        cont++;
    }    
}

void menu() 
{char resp; 
  do 
  { system ("color b");  
       system("cls"); 
    printf("\n\n\t\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 
      resp=getch(); 
      while (resp<'0' || resp>'1'); 
      switch(resp) 
      { 
          case '1': Jugar(); 
                    break; 
          case '0':  
                    break; 
      } 
  } 
  while(resp!='0'); 
} 
    
int main() 
{ 
    menu(); 
    return(0); 
} 
eso es lo que tengo por ahora, todavía le faltan algunas cosas y acomodar algunos detalles, ahora les dijo mis dudas e inconvenientes, en la función desarrollo, tengo declarado la variable vidas, y le puse un valor de 6, cuando realmente son 5 vidas, porque hice eso? porque depure el código y fui paso a paso a ver porque fallaba y resulta que la primera vez que pasa por estas instrucciones:

Código PHP:
   printf("\n\n\n\n\t                          Ingrese letra\n");
        scanf("%c",&letra);
        adivino=0;
        contador=0; 
no se detiene a esperar a que el usuario introduzca una letra, si no que sigue de largo y lógicamente me quita una vida,y ademas me llena de basura la variable introducidas, porque letra no tiene ningún valor, la segunda vez que pasa si se detiene, pensé que solo era al principio y ya, pero lo hace cada vez que introduzco una letra... entonces adivine o no la letra me quita una vida, porque pasa dos veces antes de detenerse a leer la letra y no entiendo porque, y estoy completamente seguro que sigue de largo la primera vez porque como dije lo depure y vi paso por paso y vi como siguió de largo, como si la primera vez no existiera el scanf, entonces esa es mi primera duda.. alguien sabe porque pasa eso?... realmente esto es solo por curiosidad, porque igual eso lo pondré en un ciclo que me valide que el usuario introduzca letras y no números o otros caracteres, pero igual me surge la curiosidad jeje, porque me parece raro que haga eso.... y la segunda duda es que cuando introduzco una letra en mayúscula si me la detecta en la palabra, pero si la pongo en minúscula no, es decir si la palabra es HORMIGA e introduzco H me la escribe, si introduzco h no me la escribe, porque las palabras del documento.txt están en mayúsculas, hay alguna función que me pueda pasar la letra que introduce el usuario a mayúscula? así introduzca la letra en minúscula o mayúscula de todas forma me la detectaría.... y tercera y ultima duda jeje, quiero pasar un valor por referencia en este caso es el valor de la variable vidas, porque? porque si la declaro dentro de esa función cada vez que sea una nueva palabra me la va a volver a poner en 6, y en el enunciado que les mande dice que no puedo hacer eso, que las vidas no se reinician, que son para toda la partida, yo crei que era asi:

Código PHP:
 void desarrollo(int *vidas){códigos}  //declaración de la función

int main(){int vidas=6;   desarrollo(&vidas)} // llamado de la función 
pasandole a la función la dirección, y que esta tomara el valor que esta dentro de esta dirección, pero me da error, no es así como se hace?
podría declarar la variable fuera de todas las funciones y me serviría, pero no quiero eso, quiero pasarla por referencia, porque ya lo he intentado varias veces y no me sale...

bueno esas son mis tres dudas por ahora, porque ignora el scanf la primera vez, como paso minusculas a mayusculas y como paso por referencia..
y desde ya, gracias por la ayuda ;)

aguml 27-11-2014 08:24:48
lo del scanf seguramente es porque el flujo de entrada contiene datos, limpialo antes del scanf con un fflush(stdin). Para pasar de minusculas a mayusculas simplemente asegurate que sea una letra en minusculas con un condicional y si lo es le restas 32. Para lo de las vidas si pasasla direccion luego para acceder a su contenido haz *vidas. Pon el asterisco delante. Lee informacion sobre el uso de punteros. No entiendo como te mandan algo tan complejo sin tener claro el uso de punteros, filas, flujo... Dentro de un rato veo tu codigo a ver si veo algo raro.

aguml 27-11-2014 19:50:50
Mira, esto lo hice yo pero igual te sirve para apoyarte y ver en que te falla a ti:
Código PHP:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define SIZE_MAX_PALABRA 30
#define SIZE_MAX_ALFABETO 27
//-----------------------------------------------------------------------------
/* DEFINICION DE TIPOS */
typedef struct ElementoLista
{
  char *palabra;
  int indice;
  struct ElementoLista *sig;
}Elemento;

typedef struct ListaIdentificar {
   Elemento *inicio;
   Elemento *fin;
   int nElementos;
}Lista;
//-----------------------------------------------------------------------------

/* PROTOTIPOS DE FUNCIONES */
void Inicializacion (Lista *lista);
int InsertarEnLista (Lista *lista, Elemento * actual, char *palabra, int indice);
int Sup_inicio (Lista *lista);
void DestruirLista (Lista *lista);
void Imprimir (Lista *lista);
void PreguntarPalabras(Lista *lista, int nPalabras);
int Menu(void);
void Jugar(void);
void Swap(Elemento *primero, Elemento *segundo);
void OrdenarLista(Lista *lista);
void LimpiarCadena(char *cadena, int size);
void PasarAMayusculas(char *cadena, int size);
void ActualizarLetrasIntroducidas(char *cadena, int size, char caracter);
int ActualizarLetrasRestantes(char *cadena, int size, char caracter);
int ActualizarMascara(char *mascara, char *palabra, int size, char caracter);
int LlenarLista(FILE *archivo, Lista *lista);
//-----------------------------------------------------------------------------

int main()
{
   int retval;

   do{
      retval = Menu();

      switch(retval)
      {
         case 1:
            Jugar();
            break;
      }
   }while(retval != 0);

   return(0);
}
//-----------------------------------------------------------------------------

void Inicializacion (Lista *lista)
{
   lista->inicio=NULL;
   lista->fin=NULL;
   lista->nElementos=0;
}
//-----------------------------------------------------------------------------

/*inserción en la lista */
int InsertarEnLista (Lista *lista, Elemento *actual, char *palabra, int indice)
{
   Elemento *nuevo_elemento;

   if ((nuevo_elemento = (Elemento *) malloc (sizeof (Elemento))) == NULL)
      return -1;

   if ((nuevo_elemento->palabra = (char *) malloc (SIZE_MAX_PALABRA * sizeof (char))) == NULL)
      return -1;

   strcpy (nuevo_elemento->palabra, palabra);
   nuevo_elemento->indice = indice;

   if(actual != NULL)
      actual->sig = nuevo_elemento;
   nuevo_elemento->sig = NULL;

   if(lista->inicio == NULL)
      lista->inicio = nuevo_elemento;
   lista->fin = nuevo_elemento;
   lista->nElementos++;
   return 0;
}
//-----------------------------------------------------------------------------

/* eliminación al inicio de la lista */
int Sup_inicio (Lista *lista)
{
   Elemento *sup_elemento;

   if (lista->nElementos == 0)
      return -1;
   sup_elemento = lista->inicio;
   lista->inicio = lista->inicio->sig;

   if (lista->nElementos == 1)
      lista->fin = NULL;
   free (sup_elemento->palabra);
   free (sup_elemento);
   lista->nElementos--;
   return 0;
}
//-----------------------------------------------------------------------------

/* destruir la lista */
void DestruirLista (Lista *lista)
{
   while (lista->nElementos > 0)
      Sup_inicio (lista);
}
//-----------------------------------------------------------------------------

/* visualización de la lista */
void Imprimir (Lista *lista)
{
   Elemento *actual;

   actual = lista->inicio;
   while (actual != NULL){
      printf ("%s\n", actual->palabra);
      actual = actual->sig;
   }
}
//-----------------------------------------------------------------------------

void LimpiarCadena(char *cadena, int size)
{
   int indice;

   for(indice = 0; indice < size; cadena[indice++] = '\0');
}
//-----------------------------------------------------------------------------

void PasarAMayusculas(char *cadena, int size)
{
   int indice;

   for(indice=0; indice < size;indice++)
   {
      if(cadena[indice] >= 'a' && cadena[indice] <= 'z')
         cadena[indice] -= 32;
   }
}
//-----------------------------------------------------------------------------

int ActualizarLetrasRestantes(char *cadena, int size, char caracter)
{
   int indice, j;
   char *aux;

   if ((aux = (char *) malloc ((size) * sizeof (char))) == NULL)
      return -1;

   //Buscamos el caracter introducido en el array con los caracteres restantes
   //Si lo encuentra lo omite y si es otro lo copia a un array auxiliar
   for(indice=0,j=0; indice < size;indice++)
   {
      if(cadena[indice] != caracter)
      {
         aux[j]=cadena[indice];
         j++;
      }
   }

   //Si se encontró j será menor que indice con lo que finalizo la cadena auxiliar y
   //copio el contenido de la variable auxiliar a la cadena a mostrar con los
   //caracteres restantes
   if(j < indice)
   {
      aux[j] = '\0';
      strcpy(cadena, aux);
   }
   free(aux);

   return 0;
}
//-----------------------------------------------------------------------------

void ActualizarLetrasIntroducidas(char *cadena, int size, char caracter)
{
   int indice;

   //Recorro los caracteres introducidos en busca del nuevo caracter
   for(indice=0; indice < size; indice++)
      if(cadena[indice] == caracter){
         break;
      }

   //Si se ha introducido un nuevo caracter y no está en la lista
   //le añado el nuevo caracter
   if(size == indice)
      cadena[size] = caracter;
}
//-----------------------------------------------------------------------------

int ActualizarMascara(char *mascara, char *palabra, int size, char caracter)
{
   int indice, aciertos=0, encontrada=0;

   for(indice=0; indice < size && size != 0; indice++)
      if(mascara[indice] == caracter)
         encontrada++;

   if(encontrada > 0){
      aciertos=0;
   }else{
      //Busco el caracter introducido en la palabra y si se encuentra lo quito de la palabra
      for(indice=0; indice < size && size != 0; indice++)
      {
         if(palabra[indice] == caracter)
         {
            mascara[indice] = palabra[indice];
            aciertos++;
         }
      }
   }
   return aciertos;
}
//-----------------------------------------------------------------------------

void PreguntarPalabras(Lista *lista, int nPalabras){
   const char letrasValidas[SIZE_MAX_ALFABETO] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
   int vidas = 5, indice, largoPalabra, largoIntroducidas, largoRestantes, aciertos;
   int contador=0, encontrados, salir = 0;
   char palabra[SIZE_MAX_PALABRA], auxPalabra[SIZE_MAX_PALABRA];
   char letrasIntroducidas[SIZE_MAX_ALFABETO], letrasRestantes[SIZE_MAX_ALFABETO];
   char caracter;
   Elemento *actual = lista->inicio;

   do{
      //Limpio los 3 arrays (Se puede usar en su lugar memset)
      LimpiarCadena(letrasRestantes,SIZE_MAX_ALFABETO);
      LimpiarCadena(letrasIntroducidas,SIZE_MAX_ALFABETO);
      LimpiarCadena(auxPalabra,SIZE_MAX_PALABRA);

      //Inicializo las variables que se necesiten
      strcpy(letrasRestantes,letrasValidas);
      strcpy(palabra,actual->palabra);
      largoPalabra = strlen(palabra);
      encontrados = 0;

      //Si hay algun caracter en minusculas en la palabra lo paso a mayusculas
      PasarAMayusculas(palabra,largoPalabra);

      //Muestro la mascara para que se vea cuantos caracteres tiene (Se puede hacer con memset)
      for(indice=0; indice < largoPalabra;indice++)
      {
         auxPalabra[indice] = '-';
      }

      //Mientras no lleguemos al final de la lista y tengamos vidas seguimos
      while (actual != NULL && vidas > 0){
         do{ //Este bucle es para descartar todos los caracteres no permitidos
            //Muestro la informacion
            system("CLS");
            printf("\n%c: %d", 3, vidas);
            printf("\nLetras introducidas: %s",letrasIntroducidas);
            printf("\nLetras restantes: %s",letrasRestantes);
            printf("\nNumero de palabras solucionadas: %d",contador);
            printf("\n%s\n\n",auxPalabra);
            printf("Introduce una letra (0 para salir): ");
            fflush(stdin); //limpio el flujo de entrada
            caracter = getchar(); //Pido el caracter

            //Si el caracter introducido esta en minusculas lo paso a mayusculas
            PasarAMayusculas(&caracter,1);

         }while((caracter < 'A' || caracter > 'Z') && caracter != '0');

         //Si se introdujo 0 salimos del juego
         if(caracter == '0')
         {
            salir=1;
            printf("\n\nSalida forzada por el usuario.\n\n");
            break;
         }

         largoRestantes = strlen(letrasRestantes);

         ActualizarLetrasRestantes(letrasRestantes,largoRestantes, caracter);

         //Busco el caracter introducido en la palabra y si se encuentra lo quito de la palabra
         encontrados += aciertos = ActualizarMascara(auxPalabra, palabra, largoPalabra, caracter);

         //Si se ha encontrado el caracter le resto el numero de caracteres encontrados
         //al largo de la palabra e inicializo la variable de encontrados
         //Si no se encuentra resto una vida
         if(aciertos == 0){
            vidas--;
         }

         largoIntroducidas = strlen(letrasIntroducidas);

         ActualizarLetrasIntroducidas(letrasIntroducidas,largoIntroducidas, caracter);

         //Si el largo de la palabra es 0 es porque ya se metieron todos
         //los caracteres de dicha palabra asi que la muestro y obtengo
         //la siguiente palabra
         if(largoPalabra == encontrados){
            contador++;
            system("CLS");
            printf("\n%c: %d", 3, vidas);
            printf("\nLetras introducidas: %s",letrasIntroducidas);
            printf("\nLetras restantes: %s",letrasRestantes);
            printf("\nNumero de palabras solucionadas: %d",contador);
            printf ("\n\n%s    Solucionada!!!\n\n", palabra);
            actual = actual->sig;
            system("PAUSE");
            break;
         }

         //Si no hay vidas hemos perdido asi que lo indico y salimos
         if(vidas == 0)
         {
            salir = 1;
            system("CLS");
            printf("\n%c: %d", 3, vidas);
            printf("\nLetras introducidas: %s",letrasIntroducidas);
            printf("\nLetras restantes: %s",letrasRestantes);
            printf("\nNumero de palabras solucionadas: %d",contador);
            printf("\n\nPartida finalizada.\n\n");
         }
      }

      //Si son iguales es porque ya solucionamos todas las palabras
      //solicitadas asi que hemos ganado
      if(nPalabras == contador)
      {
         printf("\n\nHas ganado.\n\n");
         salir = 1;
      }
   }while(salir != 1);
}
//-----------------------------------------------------------------------------
//Intercambia el contenido de dos elementos de la lista
void Swap(Elemento *primero, Elemento *segundo)
{
   char auxPalabra[SIZE_MAX_PALABRA];
   int auxIndice;

   strcpy(auxPalabra, primero->palabra);
   strcpy(primero->palabra, segundo->palabra);
   strcpy(segundo->palabra, auxPalabra);

   auxIndice = primero->indice;
   primero->indice = segundo->indice;
   segundo->indice = auxIndice;
}
//-----------------------------------------------------------------------------

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

   for (j=0, actual=lista->inicio; actual != NULL && j < lista->nElementos-1; actual= actual->sig, j++)
   {
      for (i=0, auxiliar = lista->inicio; i < (lista->nElementos-1-j) && auxiliar->sig != NULL; i++, auxiliar = auxiliar->sig)
      {
         if (auxiliar->indice >= auxiliar->sig->indice)
         {
            Swap(auxiliar,auxiliar->sig);
         }
      }
   }
}
//-----------------------------------------------------------------------------

int LlenarLista(FILE *archivo, Lista *lista)
{
   int finLectura=0,j,indice,contador;
   char caracter,palabra[SIZE_MAX_PALABRA];

   contador = 0;
   j=0;

   while( finLectura != 1)
   {
      LimpiarCadena(palabra, SIZE_MAX_PALABRA);

      while (!feof(archivo)){
         do{
            caracter=fgetc(archivo);
         }while(caracter=='\n');

         if (caracter!=';'){
            palabra[j]=caracter;
            j++;
         }else{
            j=0;

            //FGETC NO SIRVE YA QUE SOLO CAPTURA UN CARACTER
            //¿Y SI EL NUMERO ES POR EJEMPLO 10, O 150, O CUALQUIER OTRO QUE TENGA UN 1 DELANTE?
            fscanf(archivo,"%d",&indice);

            if(InsertarEnLista(lista,lista->fin, palabra, indice) == -1){
               printf("\nError al insertar un elemento a la lista. Pulsa intro para salir.\n\n");
               system("PAUSE");
               return -1;
            }
            contador++;

            LimpiarCadena(palabra,SIZE_MAX_PALABRA);
         }
      }
      finLectura++;
   }
   return contador;
}
//-----------------------------------------------------------------------------

//Version ordenando la lista despues de haberla obtenido entera desordenada
void Jugar(){
   int cantidad,error,contador;
   char caracter;
   Lista *lista;
   FILE *archivo;
   
   if ((lista = (Lista *) malloc (sizeof (Lista))) != NULL){
      Inicializacion(lista);
      do{
         system ("color b");
         system("cls");
         printf("\n\t\t\t  ¿Con cuantas palabras desea jugar? ");
         scanf("%d",&cantidad);
         if(cantidad < 3 || cantidad > 10){
            error = 1;
            printf("\nTiene que ser un valor comprendido entre 3 y 10\n");
            system("PAUSE");
         }else{
            error = 0;
         }
      }while(error==1);

      archivo= fopen("prueba.txt","r");

      if (archivo== NULL){
         printf("El archivo no se encuentra");
      }else{
         //Lleno la lista con todas las palabras del archivo indicado
         contador = LlenarLista(archivo, lista);

         fclose(archivo);

         //Si se obtuvieron el numero de palabras indicadas...
         if(contador >= cantidad)
         {
            OrdenarLista(lista);
            PreguntarPalabras(lista, cantidad);
            system("PAUSE");
            system("CLS");

            //Imprimimos la lista de palabras
            printf("\nLista de palabras:");
            printf("\n-----------------\n\n");
            Imprimir(lista);
         }else{
            printf("\nHay menos palabras en el archivo que las deseadas\n\n");
         }
      }
      DestruirLista(lista);
      free(lista);
   }
   printf("\n");
   system("PAUSE");
}
//-----------------------------------------------------------------------------

/*
//Version obteniendo la lista ya ordenada
void Jugar(){
   int cantidad,i,j,aux,indice,error,contador;
   char caracter,palabra[SIZE_MAX_PALABRA];
   Lista *lista;
   FILE *archivo;
   int finLecturaOrdenada=0;
   
   if ((lista = (Lista *) malloc (sizeof (Lista))) != NULL){
      Inicializacion(lista);
      do{
         system ("color b");
         system("cls");
         printf("\n\t\t\t  ¿Con cuantas palabras desea jugar? ");
         scanf("%d",&cantidad);
         if(cantidad < 3 || cantidad > 10){
            error = 1;
            printf("\nTiene que ser un valor comprendido entre 3 y 10\n");
            system("PAUSE");
         }else{
            error = 0;
         }
      }while(error==1);

      archivo= fopen("prueba.txt","r");
      if (archivo== NULL)
      {
         printf("El archivo no se encuentra");
      }else{
         contador = 1;
         i=1,j=0;
         while( finLecturaOrdenada != 2)
         {
            for(indice = 0; indice < SIZE_MAX_PALABRA; palabra[indice++] = '\0');

            while (!feof(archivo)){
               do{
                  caracter=fgetc(archivo);
               }while(caracter=='\n');

               if (caracter!=';'){
                  palabra[j]=caracter;
                  j++;
               }else{
                  j=0;

                  //FGETC NO SIRVE YA QUE SOLO CAPTURA UN CARACTER
                  //¿Y SI EL NUMERO ES POR EJEMPLO 10, O 150, O CUALQUIER OTRO QUE TENGA UN 1 DELANTE?
                  fscanf(archivo,"%d",&aux);
                  if (aux==i){
                     if(InsertarEnLista(lista,lista->fin,palabra,aux) == -1){
                        printf("\nError al insertar un elemento a la lista. Pulsa intro para salir.\n\n");
                        system("PAUSE");
                        return;
                     }
                     finLecturaOrdenada = 0;
                     fseek(archivo,0,0); //SI ENCUENTRO EL VALOR DESEADO DE INDICE ME POSICIONO AL PRINCIPIO PARA BUSCAR EL SIGUIENTE
                     contador++;
                     break;
                  }

                  for(indice = 0; indice < SIZE_MAX_PALABRA; palabra[indice++] = '\0');
               }
            }
            finLecturaOrdenada++;
            i++; //incrementamos el indice para obtener los registros ordenados

            if(i>contador){
               printf("\nHay menos palabras en el archivo que las deseadas\n\n");
               break;
            }
         }
         fclose(archivo);

         //Si se obtuvieron el numero de palabras indicadas...
         if(contador > cantidad)
         {
            PreguntarPalabras(lista, cantidad);

            system("CLS");

            //Imprimimos la lista de palabras
            printf("\nLista de palabras:\n"
                "---------------\n\n");
            Imprimir(lista);
         }
      }
      DestruirLista(lista);
      free(lista);
   }
   printf("\n");
   system("PAUSE");
}
//-----------------------------------------------------------------------------
*/

int Menu()
{
   char resp;

   system ("color b");
   system("cls");
   printf("\n\n\t\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\n");
   printf("\t\t\t\t Opcion: ");

   resp=getchar();

   return (resp - 48); //Devuelvo su valor entero
}
//----------------------------------------------------------------------------- 
Por cierto, para ordenar la lista hice algo que no me gustó mucho pero no encontré otro modo ya que intenté intercambiando los punteros de la lista pero entonces se descuadraba la lista porque Sig apuntaba a donde no debia y despues de darle mil vueltas decidí hacerlo así pero si alguien me explica como hacerlo intercambiando los registros de la lista pues creo que sería mejor solucion.

jcdca 29-11-2014 05:10:55
eres un genio jeje, gracias, me ayudaste mucho ;) de verdad te lo agradezco. te debo una ;) jeje

aguml 01-12-2014 12:40:59
Otra forma que se me ocurrio de ordenar una lista simple:

Código PHP:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define SIZE_MAX_PALABRA 30
#define SIZE_MAX_ALFABETO 27
//-----------------------------------------------------------------------------
/* DEFINICION DE TIPOS */
typedef struct ElementoLista
{
  char *palabra;
  int indice;
  struct ElementoLista *sig;
}Elemento;

typedef struct ListaIdentificar {
   Elemento *inicio;
   Elemento *fin;
   int nElementos;
}Lista;
//-----------------------------------------------------------------------------

/* PROTOTIPOS DE FUNCIONES */
void Inicializacion (Lista *lista);
int InsertarEnLista (Lista *lista, Elemento * actual, char *palabra, int indice);
int Sup_en_lista (Lista *lista, int pos);
int Sup_inicio (Lista *lista);
void DestruirLista (Lista *lista);
void Imprimir (Lista *lista);
void PreguntarPalabras(Lista *lista, int nPalabras);
int Menu(void);
void Jugar(void);
int OrdenarLista(Lista *lista);
void LimpiarCadena(char *cadena, int size);
void PasarAMayusculas(char *cadena, int size);
void ActualizarLetrasIntroducidas(char *cadena, int size, char caracter);
int ActualizarLetrasRestantes(char *cadena, int size, char caracter);
int ActualizarMascara(char *mascara, char *palabra, int size, char caracter);
int LlenarLista(FILE *archivo, Lista *lista);
//-----------------------------------------------------------------------------

int main()
{
   int retval;

   do{
      retval = Menu();

      switch(retval)
      {
         case 1:
            Jugar();
            break;
      }
   }while(retval != 0);

   return(0);
}
//-----------------------------------------------------------------------------

void Inicializacion (Lista *lista)
{
   lista->inicio=NULL;
   lista->fin=NULL;
   lista->nElementos=0;
}
//-----------------------------------------------------------------------------

/*inserción en la lista */
int InsertarEnLista (Lista *lista, Elemento *actual, char *palabra, int indice)
{
   Elemento *nuevo_elemento;

   if ((nuevo_elemento = (Elemento *) malloc (sizeof (Elemento))) == NULL)
      return -1;

   if ((nuevo_elemento->palabra = (char *) malloc (SIZE_MAX_PALABRA * sizeof (char))) == NULL)
      return -1;

   strcpy (nuevo_elemento->palabra, palabra);
   nuevo_elemento->indice = indice;

   if(actual != NULL)
      actual->sig = nuevo_elemento;
   nuevo_elemento->sig = NULL;

   if(lista->inicio == NULL)
      lista->inicio = nuevo_elemento;
   lista->fin = nuevo_elemento;
   lista->nElementos++;
   return 0;
}
//-----------------------------------------------------------------------------

/* eliminar un elemento después de la posición solicitada */
int Sup_en_lista (Lista * lista, int pos)
{
   int i;
   Elemento *actual;
   Elemento *sup_elemento;

   if (lista->nElementos <= 1 || pos < 1 || pos >= lista->nElementos)
      return -1;

   actual = lista->inicio;
   for (i = 1; i < pos; ++i)
      actual = actual->sig;
   sup_elemento = actual->sig;
   actual->sig = actual->sig->sig;
   if(actual->sig == NULL)
      lista->fin = actual;
   free (sup_elemento->palabra);
   free (sup_elemento);
   lista->nElementos--;
   return 0;
}
//-----------------------------------------------------------------------------

/* eliminación al inicio de la lista */
int Sup_inicio (Lista *lista)
{
   Elemento *sup_elemento;

   if (lista->nElementos == 0)
      return -1;
   sup_elemento = lista->inicio;
   lista->inicio = lista->inicio->sig;

   if (lista->nElementos == 1)
      lista->fin = NULL;
   free (sup_elemento->palabra);
   free (sup_elemento);
   lista->nElementos--;
   return 0;
}
//-----------------------------------------------------------------------------

/* destruir la lista */
void DestruirLista (Lista *lista)
{
   while (lista->nElementos > 0)
      Sup_inicio (lista);
}
//-----------------------------------------------------------------------------

/* visualización de la lista */
void Imprimir (Lista *lista)
{
   Elemento *actual;

   actual = lista->inicio;
   while (actual != NULL){
      printf ("%s\n", actual->palabra);
      actual = actual->sig;
   }
}
//-----------------------------------------------------------------------------

void LimpiarCadena(char *cadena, int size)
{
   int indice;

   for(indice = 0; indice < size; cadena[indice++] = '\0');
}
//-----------------------------------------------------------------------------

void PasarAMayusculas(char *cadena, int size)
{
   int indice;

   for(indice=0; indice < size;indice++)
   {
      if(cadena[indice] >= 'a' && cadena[indice] <= 'z')
         cadena[indice] -= 32;
   }
}
//-----------------------------------------------------------------------------

int ActualizarLetrasRestantes(char *cadena, int size, char caracter)
{
   int indice, j;
   char *aux;

   if ((aux = (char *) malloc ((size) * sizeof (char))) == NULL)
      return -1;

   //Buscamos el caracter introducido en el array con los caracteres restantes
   //Si lo encuentra lo omite y si es otro lo copia a un array auxiliar
   for(indice=0,j=0; indice < size;indice++)
   {
      if(cadena[indice] != caracter)
      {
         aux[j]=cadena[indice];
         j++;
      }
   }

   //Si se encontró j será menor que indice con lo que finalizo la cadena auxiliar y
   //copio el contenido de la variable auxiliar a la cadena a mostrar con los
   //caracteres restantes
   if(j < indice)
   {
      aux[j] = '\0';
      strcpy(cadena, aux);
   }
   free(aux);

   return 0;
}
//-----------------------------------------------------------------------------

void ActualizarLetrasIntroducidas(char *cadena, int size, char caracter)
{
   int indice;

   //Recorro los caracteres introducidos en busca del nuevo caracter
   for(indice=0; indice < size; indice++)
      if(cadena[indice] == caracter){
         break;
      }

   //Si se ha introducido un nuevo caracter y no está en la lista
   //le añado el nuevo caracter
   if(size == indice)
      cadena[size] = caracter;
}
//-----------------------------------------------------------------------------

int ActualizarMascara(char *mascara, char *palabra, int size, char caracter)
{
   int indice, aciertos=0, encontrada=0;

   for(indice=0; indice < size && size != 0; indice++)
      if(mascara[indice] == caracter)
         encontrada++;

   if(encontrada > 0){
      aciertos=0;
   }else{
      //Busco el caracter introducido en la palabra y si se encuentra lo quito de la palabra
      for(indice=0; indice < size && size != 0; indice++)
      {
         if(palabra[indice] == caracter)
         {
            mascara[indice] = palabra[indice];
            aciertos++;
         }
      }
   }
   return aciertos;
}
//-----------------------------------------------------------------------------

void PreguntarPalabras(Lista *lista, int nPalabras){
   const char letrasValidas[SIZE_MAX_ALFABETO] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
   int vidas = 5, indice, largoPalabra, largoIntroducidas, largoRestantes, aciertos;
   int contador=0, encontrados, salir = 0;
   char palabra[SIZE_MAX_PALABRA], auxPalabra[SIZE_MAX_PALABRA];
   char letrasIntroducidas[SIZE_MAX_ALFABETO], letrasRestantes[SIZE_MAX_ALFABETO];
   char caracter;
   Elemento *actual = lista->inicio;

   do{
      //Limpio los 3 arrays (Se puede usar en su lugar memset)
      LimpiarCadena(letrasRestantes,SIZE_MAX_ALFABETO);
      LimpiarCadena(letrasIntroducidas,SIZE_MAX_ALFABETO);
      LimpiarCadena(auxPalabra,SIZE_MAX_PALABRA);

      //Inicializo las variables que se necesiten
      strcpy(letrasRestantes,letrasValidas);
      strcpy(palabra,actual->palabra);
      largoPalabra = strlen(palabra);
      encontrados = 0;

      //Si hay algun caracter en minusculas en la palabra lo paso a mayusculas
      PasarAMayusculas(palabra,largoPalabra);

      //Muestro la mascara para que se vea cuantos caracteres tiene (Se puede hacer con memset)
      for(indice=0; indice < largoPalabra;indice++)
      {
         auxPalabra[indice] = '-';
      }

      //Mientras no lleguemos al final de la lista y tengamos vidas seguimos
      while (actual != NULL && vidas > 0){
         do{ //Este bucle es para descartar todos los caracteres no permitidos
            //Muestro la informacion
            system("CLS");
            printf("\n%c: %d", 3, vidas);
            printf("\nLetras introducidas: %s",letrasIntroducidas);
            printf("\nLetras restantes: %s",letrasRestantes);
            printf("\nNumero de palabras solucionadas: %d",contador);
            printf("\n%s\n\n",auxPalabra);
            printf("Introduce una letra (0 para salir): ");
            fflush(stdin); //limpio el flujo de entrada
            caracter = getchar(); //Pido el caracter

            //Si el caracter introducido esta en minusculas lo paso a mayusculas
            PasarAMayusculas(&caracter,1);

         }while((caracter < 'A' || caracter > 'Z') && caracter != '0');

         //Si se introdujo 0 salimos del juego
         if(caracter == '0')
         {
            salir=1;
            printf("\n\nSalida forzada por el usuario.\n\n");
            break;
         }

         largoRestantes = strlen(letrasRestantes);

         ActualizarLetrasRestantes(letrasRestantes,largoRestantes, caracter);

         //Busco el caracter introducido en la palabra y si se encuentra lo quito de la palabra
         encontrados += aciertos = ActualizarMascara(auxPalabra, palabra, largoPalabra, caracter);

         //Si se ha encontrado el caracter le resto el numero de caracteres encontrados
         //al largo de la palabra e inicializo la variable de encontrados
         //Si no se encuentra resto una vida
         if(aciertos == 0){
            vidas--;
         }

         largoIntroducidas = strlen(letrasIntroducidas);

         ActualizarLetrasIntroducidas(letrasIntroducidas,largoIntroducidas, caracter);

         //Si el largo de la palabra es 0 es porque ya se metieron todos
         //los caracteres de dicha palabra asi que la muestro y obtengo
         //la siguiente palabra
         if(largoPalabra == encontrados){
            contador++;
            system("CLS");
            printf("\n%c: %d", 3, vidas);
            printf("\nLetras introducidas: %s",letrasIntroducidas);
            printf("\nLetras restantes: %s",letrasRestantes);
            printf("\nNumero de palabras solucionadas: %d",contador);
            printf ("\n\n%s    Solucionada!!!\n\n", palabra);
            actual = actual->sig;
            system("PAUSE");
            break;
         }

         //Si no hay vidas hemos perdido asi que lo indico y salimos
         if(vidas == 0)
         {
            salir = 1;
            system("CLS");
            printf("\n%c: %d", 3, vidas);
            printf("\nLetras introducidas: %s",letrasIntroducidas);
            printf("\nLetras restantes: %s",letrasRestantes);
            printf("\nNumero de palabras solucionadas: %d",contador);
            printf("\n\nPartida finalizada.\n\n");
         }
      }

      //Si son iguales es porque ya solucionamos todas las palabras
      //solicitadas asi que hemos ganado
      if(nPalabras == contador)
      {
         printf("\n\nHas ganado.\n\n");
         salir = 1;
      }
   }while(salir != 1);
}
//-----------------------------------------------------------------------------

//Ordena el contenido de la lista
int OrdenarLista(Lista *lista)
{
   int j,pos,retval;
   Elemento *actual,*menor;
   Lista *listaAux;

   if(lista->nElementos > 1){
      //Reservo memoria para la lista auxiliar que usaré para ordenar la lista
      if ((listaAux = (Lista *) malloc (sizeof (Lista))) == NULL){
         retval = -1; //Valor de retorno que indica que no se pudo obtener suficiente memoria
      }else{
         //Inicializo la lista auxiliar
         Inicializacion(listaAux);

         //Mientras que el número de elementos sea mayor que 1...
         while(lista->nElementos > 1){
            menor = lista->inicio; //le asigno al puntero de tipo Elemento la direccion de inicio de la lista
            pos=0; //inicializo la variable para saber la posicion del elemento anterior al de menor indice

            //Recorro todos los elementos en busca del que tenga menor indice
            for (j=1, actual=lista->inicio; j < lista->nElementos; j++, actual=actual->sig)
            {
               //Si el indice del actual es mayor que el del siguiente...
               if(menor->indice > actual->sig->indice){
                  menor = actual->sig; //Asigno a menor la direccion del elemento siguiente
                  pos = j; //Asigno a pos la posicion del elemento anterior al que tiene el indice menor
               }
            }
            //Inserto el elemento menor en la lista auxiliar
            InsertarEnLista(listaAux, listaAux->fin, menor->palabra, menor->indice);

            if(pos==0){ //Si pos es 0 es porque es el primer elemento de la lista
               Sup_inicio(lista); //Elimino al primer elemento de la lista
            }else{ //Si pos es diferente de 0...
               Sup_en_lista(lista,pos); //Elimino el elemento que está despues de la posicion pos
            }
         }

         if(lista->nElementos == 1){ //Si hay un solo elemento en la lista...
            //Inserto ese elemento en la lista auxiliar ya que es el último que falta por ordenar y el que tiene mayor indice
            InsertarEnLista(listaAux, listaAux->fin, lista->inicio->palabra, lista->inicio->indice);
            Sup_inicio(lista); //Elimino el elemento que queda para limpiar la lista
         }

         //Recorro la lista auxiliar para rellenar la lista
         for(j=0, actual=listaAux->inicio; j < listaAux->nElementos; j++, actual=actual->sig)
            InsertarEnLista(lista, lista->fin, actual->palabra, actual->indice);

         DestruirLista(listaAux); //Libero la memoria de los elementos de la lista auxiliar
         free(listaAux); //Libero la memoria de la lista auxiliar
         retval=0; //Valor de retorno que indica que todo fue bien
      }
   }else{
      retval = -2; //Valor de retorno que indica que el numero de elementos de la lista no es correcto
   }
   return retval;
}
//-----------------------------------------------------------------------------

int LlenarLista(FILE *archivo, Lista *lista)
{
   int finLectura=0,j,indice,contador;
   char caracter,palabra[SIZE_MAX_PALABRA];

   contador = 0;
   j=0;

   while( finLectura != 1)
   {
      LimpiarCadena(palabra, SIZE_MAX_PALABRA);

      while (!feof(archivo)){
         do{
            caracter=fgetc(archivo);
         }while(caracter=='\n');

         if (caracter!=';'){
            palabra[j]=caracter;
            j++;
         }else{
            j=0;

            //FGETC NO SIRVE YA QUE SOLO CAPTURA UN CARACTER
            //¿Y SI EL NUMERO ES POR EJEMPLO 10, O 150, O CUALQUIER OTRO QUE TENGA UN 1 DELANTE?
            fscanf(archivo,"%d",&indice);

            if(InsertarEnLista(lista,lista->fin, palabra, indice) == -1){
               printf("\nError al insertar un elemento a la lista. Pulsa intro para salir.\n\n");
               system("PAUSE");
               return -1;
            }
            contador++;

            LimpiarCadena(palabra,SIZE_MAX_PALABRA);
         }
      }
      finLectura++;
   }
   return contador;
}
//-----------------------------------------------------------------------------

//Version ordenando la lista despues de haberla obtenido entera desordenada
void Jugar(){
   int cantidad,error,contador;
   char caracter;
   Lista *lista;
   FILE *archivo;
   
   if ((lista = (Lista *) malloc (sizeof (Lista))) != NULL){
      Inicializacion(lista);
      do{
         system ("color b");
         system("cls");
         printf("\n\t\t\t  ¿Con cuantas palabras desea jugar? ");
         scanf("%d",&cantidad);
         if(cantidad < 3 || cantidad > 10){
            error = 1;
            printf("\nTiene que ser un valor comprendido entre 3 y 10\n");
            system("PAUSE");
         }else{
            error = 0;
         }
      }while(error==1);

      archivo= fopen("prueba.txt","r");

      if (archivo== NULL){
         printf("El archivo no se encuentra");
      }else{
         //Lleno la lista con todas las palabras del archivo indicado
         contador = LlenarLista(archivo, lista);

         fclose(archivo);

         //Si se obtuvieron el numero de palabras indicadas...
         if(contador >= cantidad)
         {
            OrdenarLista(lista);
            PreguntarPalabras(lista, cantidad);
            system("PAUSE");
            system("CLS");

            //Imprimimos la lista de palabras
            printf("\nLista de palabras:");
            printf("\n-----------------\n\n");
            Imprimir(lista);
         }else{
            printf("\nHay menos palabras en el archivo que las deseadas\n\n");
         }
      }
      DestruirLista(lista);
      free(lista);
   }
   printf("\n");
   system("PAUSE");
}
//-----------------------------------------------------------------------------

int Menu()
{
   char resp;

   system ("color b");
   system("cls");
   printf("\n\n\t\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\n");
   printf("\t\t\t\t Opcion: ");

   resp=getchar();

   return (resp - 48); //Devuelvo su valor entero
}
//----------------------------------------------------------------------------- 
Utilizo una lista auxiliar en la cual guardo los elementos ya ordenados y los voy eliminando de la lista principal. Luego copio todo ya ordenado en la lista principal y libero la memoria ocupada por la lista auxiliar.
Si consigues un método mejor compartelo aquí por favor, estoy interesado ya que nunca se me ocurrio ordenar una lista enlazada y he visto que es algo complejo de hacer.

aguml 03-12-2014 10:28:47
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 05-12-2014 16:01:21
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 05-12-2014 17:32:18
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 05-12-2014 17:57:19
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 06-12-2014 21:20:15
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 06-12-2014 22:18:53
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 06-12-2014 22:32:28
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.
Código:
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 06-12-2014 23:04:06
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 ;)

jcdca 07-12-2014 04:26:18
bueno aquí esta, puse en verde lo que le agregue... el problema era que cuando llega al final del archivo, el entra en el ciclo donde se valida que caracter sea distinto de \n... y después de ese ciclo, hay un if que valida el punto y coma, pero como es el final del archivo a caracter en ese momento le agraga '377' porque ya no hay nada en el archivo, y cuando vuelvo a abrir el archivo tengo que limpiar la variable palabra para que no tenga ese '377', solo pasa con la palabra que esta al principio porque para las demás si limpiaba la palabra, pero antes de empezar ese ciclo no la limpiaba, por eso el error... era una tontería jeje, pero bueno suele pasar. acomode las variables, lo tenia así en varios sitios, no me di cuenta.Gracias ;)

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,listaPalabra *listaAux);
    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,listaPalabra *listaAux);
    void mensajePerder(listaPalabra *listaAux);
    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');  
}  

/* FUNCION PARA CARGAR ARCHIVO Y LLENAR LISTA PARA JUGAR */
    void Jugar() 
     {       
         int cantidad,i,j,aux,x,indice,z,conseguido,listaLlena=0,nuevoNumero,comprobarNumero,continuar=0;  
         char caracter,palabra[30];
         
         system ("color b");  
         system("cls"); 
                  
        // 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 
               [color="lime"] limpiarCadena(palabra,SIZE_MAX_PALABRA);
                j=0;[/color]                                         
                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);
                          if (aux==i)  // SE COMPARA EL NUMERO DE LA PALABRA CON EL NUMERO QUE ESTAMOS BUSCANDO
                          {                                                            
                             fflush(stdin);
                            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
                }    
                fclose(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,listaAux);   //LA VARIABLE Z ES USADA SOLO PARA SABER EN QUE PALABRA ESTAMOS E IMPRIMIRLO POR PANTALLA       
        }      
        modificarArchivo(listaAux);           
    }      

/* 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) 
    { 
         if (lista != NULL) 
         {
            char aux[25];                
            listaPalabra *auxiliar;                    
            auxiliar = lista; 
            limpiarCadena(variable,SIZE_MAX_PALABRA);                           
            strcpy(variable,lista->palabra);          
            lista = lista->sig;            
         }            
         return lista;      
    } 
    
/* FUNCION QUE DESARROLLA LA PARTIDA DEL JUEGO */
    void desarrollo(int cantidad, int i,listaPalabra *listaAux) 
    {         
        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   ";
        
        system("color a"); 
         
        // INICIALIZAR VARIABLES EN SU VALOR ORIGINAL 
        limpiarCadena(palabra,SIZE_MAX_PALABRA);  //PARA ASI INICIAR LA PALABRA NUEVA EN BLANCO
        limpiarCadena(introducidas,SIZE_MAX_ALFABETO);//PARA ASI INICIAR LA PALABRA NUEVA EN BLANCO
        strcpy(restantes,aux);//PARA ASI INICIAR LA PALABRA NUEVA CON TODAS LAS LETRAS DEL ABECEDARIO
    
        // BUCLE PARA LLENAR LA PALABRA DE RAYAS Y ESPACIOS 
           for (indice=0;indice < (strlen(variable))*2;indice+=2) 
        { 
            palabra[indice]=95;  //RAYAS EN CODIGO ASCII
            palabra[indice+1]=32; //ESPACIO EN BLANCO EN CODIGO ASCII
        }             
        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); //ENTRADA DE DATOS NOS DEVOLVERA LA LETRA INTRODUCIDA POR EL USUARIO
           
           // BUCLE QUE VALIDA QUE YA HALLAS METIDO ESA LETRA 
            for (contador=0,encontrada=0;contador<25;contador++)
            {     
                  if (letra==introducidas[contador])
                  {
                     encontrada=1;           //SI ENCONTRADA ES =1  ENTONCES NO SE TE QUITARA UNA VIDA, PORQUE YA METISTE LA LETRA ANTES
                     break;                  // Y TAMPOCO SE EJECUTARAN LAS INSTRUCCIONES SIGUIENTES
                  }
            }
        
            // 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;  //ASIGNAMOS LA LETRA EN LA POSICION DE LA PALABRA POR DOS(POR QUE SON DOS CARACTERES POR PALABRA, ESPACIO Y RAYA)
                       adivino=1;                  //Y A ADIVINO LE ASIGNAMOS UNO PARA QUE NO RESTE UNA VIDA
                       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(listaAux);  
           }    
    
        // CONDICIONAL PARA CUANDO ADIVINES TODAS LAS PALABRAS Y AUN TENGAS VIDAS 
        if ((i == cantidad) && (vida >0)) 
        {    
             mensajeGanar(cantidad,listaAux);
        }
    }
    
/* 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,listaPalabra *listaAux)
    { 
        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();
               fflush(stdin);
               if (resp>=97 && resp<=122)
               { 
                   resp-=32;
               }
       }while ((resp>=00 && resp<=77) || (resp>=79 && resp<=82)||(resp>=84 && resp<=255));
       switch(resp)  
       {  
               case 'S': modificarArchivo(listaAux);
                      Jugar();   
                      break;  
            case 'N': vida--;  
                      break;  
       } 
    }

/* FUNCION PARA MOSTRAR MENSAJE POR PERDER */
    void mensajePerder(listaPalabra *listaAux)
    {  
        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();
               fflush(stdin);
               if (resp>=97 && resp<=122)
               { 
                   resp-=32;
               }
               }while ((resp>=00 && resp<=77) || (resp>=79 && resp<=82)||(resp>=84 && resp<=255));
               switch(resp)  
               {  
                  case 'S': modificarArchivo(listaAux); 
                            Jugar(); 
                          break;  
                  case 'N': vida--;  
                          break;  
               } 
       }
    }
    
//FUNCION PARA MODIFICAR EL ARCHIVO DE TEXTO
      void modificarArchivo(listaPalabra *listaAux)
      {
          int numeroNuevo,i,continuar=1,j=0,contador;
          char numero,comprobarNumero[10];
          limpiarCadena(comprobarNumero,10);
          FILE *archivo1;                               //CREAMOS VARIABLE TIPO TEXTO
          archivo1= fopen("listaDePalabras.txt","w");   //ABRIMOS EL ARCHIVO EN MODO ESCRITURA
          for (contador=0;contador<10; contador++)      //CICLO QUE SE EJECUTA 10 VECES(LAS 10 PALABRAS)
          {      
                 listaAux=buscarPalabra(listaAux);         //BUSCAMOS LA PALABRA EN LA LISTA AUXILIAR 
            do
              {          
                numeroNuevo=(rand() % 10);            //GENERAMOS UN NUMERO ALETROIO MOD 10(ENTRE 0 Y 9)
                numero= (char)(numeroNuevo+48);       //CAMBIAMOS EL NUMERO A CHAR
                continuar=1;
                for (i=0; i<strlen(comprobarNumero);i++) //CILO HASTA QUE SE ACABE LA VARIABLE COMPROBARNUMERO(CONTIENE LOS NUMEROS QUE YA SALIERON)
                {
                    if (comprobarNumero[i]==numero)  //SI EL NUMERO SE ENCUENTRA EN LA CADENA, ES PORQUE YA SALIO ANTES
                    {
                        continuar=0;                  //COMO YA SALIO ANTES SE ASIGNA CERO A CONTINUAR PARA QUE SE REPITA EL CICLO    
                    }                    
                }
               }while(continuar==0);    // SE REPITE EL CICLO SOLO SI EL NUMERO YA SALIO
            fprintf(archivo1,"%s;%i\n",variable,numeroNuevo+1); //SE ESCRIBE EN EL ARCHIVO LA PALABRA,EL ;, Y EL NUMERO ALETORIO MAS 1(SE SUMA UNO PORQUE EL NUMERO GENERADO ES ENTRE 0 Y 9)
            comprobarNumero[j]=numero;               //SE GUARDA EL NUMERO GENERADO EN LA VARIABLE
            j++;                                    //SE SUMA LA VARIABLE QUE INDICA LA POSICION DE LA VARIABLE COMPROBARNUMERO
        }
        fclose(archivo1);  //CERRAMOS EL ARCHIVO             
      } 

jcdca 07-12-2014 04:28:28
jajaja no me lo puso en verde, bueno lo que esta encerrado entre el codigo que dice color="lime" eso es lo que agregue jejeje.


La franja horaria es GMT +2. Ahora son las 04:15:41.

Powered by vBulletin® Version 3.6.8
Copyright ©2000 - 2026, Jelsoft Enterprises Ltd.
Traducción al castellano por el equipo de moderadores del Club Delphi