Tema: Hacer un programa para adivinar 5 números del 0 al 9
Ver Mensaje Individual
  #12 (permalink)  
Antiguo 21/11/2011, 07:23
Gott
 
Fecha de Ingreso: febrero-2011
Ubicación: Paraguay
Mensajes: 59
Antigüedad: 13 años, 8 meses
Puntos: 1
Respuesta: Hacer un programa para adivinar 5 números del 0 al 9
Yo tambien lo hice!! Aunque un poco mas modularizado y en c++.. Un saludo!!
Código C++: 
Ver original
  1. /* Genera una cadena de numeros que se tiene que adivinar. Por cada 
  2. numero que se acierta se pone una "o" en el lugar. Por cada fallo un "x" */ 
  3.  
  4. #include <iostream> 
  5. #include <cstdlib> 
  6. #include <cstring> 
  7. #include <ctime> 
  8.  
  9. using namespace std; 
  10.  
  11. /* Prototipos de las funciones */ 
  12. int elegirDificultad(void); 
  13. void generarSecuencia(int* cad, int dim); 
  14. bool unico(int* cad, int num); 
  15. bool hayGanador(int* oculto, int dim); 
  16. bool controlar(int* oculto, int* intento, int dim); 
  17. void convertirCadena(char* intento, int* intentoNumerico, int dim); 
  18.  
  19. /* Funcion Principal del Juego */ 
  20. int main(int argc, char* argv[]) { 
  21.    int* oculto;   // Secuencia generada 
  22.    int* intento;   // Secuencia del usuario 
  23.    int dim;      // Dimension de la cadena (Dificultad del juego) 
  24.    srand(time(NULL)); 
  25.     
  26.    cout << "********** ADIVINA EL NUMERO OCULTO **********" << endl; 
  27.    dim = elegirDificultad() + 3;   // Dificultad del juego 
  28.    oculto = new int[dim]; 
  29.     
  30.    generarSecuencia(oculto, dim);   // Genera la secuencia 
  31.    if(!hayGanador(oculto, dim)) {      // Juego 
  32.       cout << endl << "Lo sentimos. Mala suerte. Intentalo mas tarde" << endl; 
  33.    } else { 
  34.       cout << endl << "Felicidades!! Eres un experto. Aumenta la dificultad" << endl; 
  35.    } 
  36.     
  37.    return EXIT_SUCCESS; 
  38. } 
  39.  
  40. /** 
  41.  * Se permite al usuario elegir la dificultad del juego 
  42.  * @return: Dificultad del juego 
  43. */ 
  44. int elegirDificultad(void) { 
  45.    int dificultad=0; 
  46.    while(dificultad != 1 && dificultad != 2 && dificultad != 3) { 
  47.       cout << "Ingrese la dificultad:" << endl; 
  48.       cout << "1. Facil" << endl << "2. Medio" << endl << "3. Dificil" << endl << endl; 
  49.       cout << "Dificultad: "; 
  50.       cin >> dificultad; 
  51.    } 
  52.    return dificultad; 
  53. } 
  54.  
  55. /** 
  56.  * Genera la secuencia que hay que adivinar 
  57.  * @var_cad: Guarda la cadena generada 
  58.  * @var_dim: Dimension de la cadena generada 
  59. */ 
  60. void generarSecuencia(int* cad, int dim) { 
  61.    int i, num; 
  62.    int salidos[10]; 
  63.    // Inicializa para el control de repetidos 
  64.    for(i=0; i<10; i++) { 
  65.       salidos[i] = 0; 
  66.    } 
  67.    for(i=0; i<dim; i++) { 
  68.       num = rand() % 9 + 1;   // Genera numeros entre 1-9 
  69.       while(!unico(salidos, num)) {   // Control de repetidos 
  70.          num = rand() % 9 + 1; 
  71.       } 
  72.       salidos[i] = num; 
  73.       cad[i] = num; 
  74.    } 
  75. } 
  76.  
  77. /** 
  78.  * Controla que no existan numeros repetidos en la cadena 
  79.  * @var_cad: Numeros que ya salieron 
  80.  * @var_num: Numero que se quiere insertar 
  81.  * @return: true si puede agregarse, false si no se puede 
  82. */ 
  83. bool unico(int* cad, int num) { 
  84.    for (int i=0; i<10; i++) { 
  85.       if(cad[i] == num) { 
  86.          return false; 
  87.       } 
  88.    } 
  89.    return true; 
  90. } 
  91.  
  92. /** 
  93.  * Argumento del juego 
  94.  * @var_oculto: Secuencia a adivinar 
  95.  * @var_dim: Dimension de la secuencia 
  96.  * @return: true si hay ganador ; false si no hay 
  97. */ 
  98. bool hayGanador(int* oculto, int dim) { 
  99.    bool win=false;         // Para ver si hay ganador o no 
  100.    char intento[dim];      // Secuencia del usuario 
  101.    int intentoNumerico[dim]; 
  102.    int numIntentos=0;      // Cantidad de intentos 
  103.    int maxIntentos=dim*2;   // Intentos Maximos 
  104.     
  105.    while(!win && numIntentos < maxIntentos) { 
  106.       cout << endl << "Ingrese el numero de " << dim << " cifras." << endl; 
  107.       cout << "Intento nro: " << ++numIntentos << " de " << maxIntentos << endl; 
  108.       cin >> intento; 
  109.       if(strlen(intento) == dim) { 
  110.          convertirCadena(intento, intentoNumerico, dim); 
  111.          win = controlar(oculto, intentoNumerico, dim); 
  112.       } 
  113.    } 
  114.     
  115.    return win; 
  116. } 
  117.  
  118. /** 
  119.  * Convierte la cadena del usuario a una numerica 
  120.  * @var_intento: Secuencia del usuario 
  121.  * @var_intentoNumerico: Secuencia numerica 
  122.  * @var_dim: Dimension de la secuencia 
  123. */ 
  124. void convertirCadena(char* intento, int* intentoNumerico, int dim) { 
  125.    for(int i=0; i<dim; i++) { 
  126.       switch(intento[i]) { 
  127.          case '1': 
  128.             intentoNumerico[i] = 1; 
  129.             break; 
  130.          case '2': 
  131.             intentoNumerico[i] = 2; 
  132.             break; 
  133.          case '3': 
  134.             intentoNumerico[i] = 3; 
  135.             break; 
  136.          case '4': 
  137.             intentoNumerico[i] = 4; 
  138.             break; 
  139.          case '5': 
  140.             intentoNumerico[i] = 5; 
  141.             break; 
  142.          case '6': 
  143.             intentoNumerico[i] = 6; 
  144.             break; 
  145.          case '7': 
  146.             intentoNumerico[i] = 7; 
  147.             break; 
  148.          case '8': 
  149.             intentoNumerico[i] = 8; 
  150.             break; 
  151.          case '9': 
  152.             intentoNumerico[i] = 9; 
  153.             break; 
  154.       } 
  155.    } 
  156. } 
  157.  
  158. /** 
  159.  * Controla los aciertos del usuario 
  160.  * @var_oculto: Secuencia a adivinar 
  161.  * @var_intento: Secuencia del usuario 
  162.  * @var_dim: Dimension de la secuencia 
  163.  * @return: true si adivino todo ; false si no acerto 
  164. */ 
  165. bool controlar(int* oculto, int* intento, int dim) { 
  166.    int aciertosFaltantes=dim; 
  167.    for(int i=0; i<dim; i++) { 
  168.       if(oculto[i] == intento[i]) { 
  169.          cout << "o"; 
  170.          aciertosFaltantes--; 
  171.       } else { 
  172.          cout << "x"; 
  173.       } 
  174.    } 
  175.    cout << endl; 
  176.    return !aciertosFaltantes; 
  177. }