Hacer un programa para adivinar 5 números del 0 al 9

[valentina4you]

Bueno, nuevamente apelo a la ayuda de los que saben C+. Si alguien no leyó el post anterior, me explico. Tengo una materia, programación, en la que el profesor no enseñó una chota en todo el año (hablando mal y pronto) y nos quiere mandar a todos a examen porque no sabemos nada (lógico!). Nos dio como última oportunidad hacer un programa, el cuál claro ninguno tiene la más mínima idea como hacer porque no sabemos nada porque el profesor debe ser el peor del mundo explicando cosas que ni el entiende.

En fin, la cosa es que tengo que hacer este programa y no tengo idea de cómo hacerlo. Es prácticamente hacerlo sin saber absolutamente nada creo que lo único que se es que para hacer "algo" hay que llamar a galerías o librerías (el profesor las llama indiferentemente de cualquier manera). Por eso me gustaría si:
1- Me pudieran facilitar algún material que ayudara a hacer esto
2- Cualquier iniciativa que me puedan tirar de como empezar también sería bienvenida.

Demás está decir que hace tiempo que estoy en el foro y no estoy pidiendo que nadie lo haga por mi.


Coloco lo que puso el profesor:

Hacer un programa que es jugar a adivinar 5 números de 0 al 9.- La idea es que el ordenador elija 5 números no repetidos y nosotros en 10 jugadas como máximo tenemos que adivinar. Las pistas que nos debe dar el programa es si el numero introducido por el usuario esta en el mismo lugar que el creado por el ordenador se imprime $ y si el numero existe pero no esta en el lugar se imprime * en la pantalla.

Ejemplo:
Numero creado por el ordenador 5 3 7 8 4
Jugada primera 6 3 4 1 2 $*
Jugada segunda 5 7 8 4 6 $***

Y así sucesivamente hasta llegar a tener cinco $ o llegar a la decima jugada.
Para hacer esto deben usar vectores o array. Para que el computador genere los números hay que utilizar las instrucciones randomize y random


Como cargar un vector desde pantalla de cinco casilleros

Código C++:

for (i=0;i<5; i++)
{scanf(&#8220;%d”, vector[i]),
flushall);}
 

Como buscar un número en un vector

Código C++:

bandera=0;
for (i=0;i<5; i++)
{if (numero==vector[i]) bandera=1;}
 

Si el número existe la variable bandera va a tener el valor 1. (partimos de la premisa que no hay números repetidos)

Como inicializar un vector si va a contener valores en 0 y 9 entonces pongo en cada casillero el valor -1

Código C++:

for (i=0;i<5; i++)
    vector[i]=-1;
 

Si yo tengo dos vectores con números y quiero saber cuántos están en el mismo lugar:

Código C++:

cantidad=0
for (i=0;i<5; i++)
    if (vec_adivinar[i]==vec_entrado[i]) cantidad=cantidad+1;
 

Vale decir que para mi es chino básico, nunca hicimos nada similar. Sé que las banderas sirven para algo específico porque lo he leído en varios lugares del foro, pero tampoco sé para qué.

Desde ya se agradece cualquier ayudita (me siento como indigente pidiendo moneditas). Igualmente estoy investigando por mis medios también, tratando de aprender todo lo que no nos enseñaron.

Gracias!

[valentina4you]

Nadie sabe hacer esto? :(

[sam90]

Empecemos de apoco. Para empezar asi generamos un numero aleatorio. Primero seteamos la semilla (recordar que los numeros son psudo-aleatorio) con srand. Apartir de ese momento es recomendable llamar a la funcion rand que devuelve un numero aleatorio.(No llames muchas veces a la funcion srand).

Código C:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
int main ()
{
  int n;
  srand ( time(NULL) );
  n = rand() ;
}
 

Podemos usar el operador modulo "%" que devuelve el resto de la division para acotar el numero aleatorio entre 0 y 9.

Código C:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
int aleatorio()
{
      return rand()  % 10; // devuelve entre 0 y 9
}
 
int main ()
{
  int n;
  srand ( time(NULL) );
  n = aleatorio() ;
}
 

Por otro lado defines un vector con cinco numeros:

int numeros[5];

Viendo los apuntes del profe puedes crear esta funcion:

Código C:

int pertenece(int * vector, int numero)
{
    int bandera=0;
    for (i=0;i<5; i++){
        if (numero==vector[i]) 
        bandera=1;
     }
     return bandera;
}
 

Esta funcion devuelve uno si el numero pertenece al vector.

Ahora creemos un ciclo para crear 5 numero aleatorio y que no pertenescan.

Código C:

int i,numeros[5],a;
for (i=0;i<5; i++)
    numeros[i]=-1;
for (i=0;i<5; i++) {
     do {
          a = aleatorio();
     } while (pertenece(numeros,a) == 1  );
      numeros[i] = a;
}
 

Eso es todo para empezar...creo que va a ser un gran impacto si largo todo de cero. Fijate si entiendes o no. Mas o menos te di unos cuantos tips mas. Faltaria retorcar algunas cosas y hacer la parte del juego.

[valentina4you]

Muchas, muchas gracias. Hoy voy a ir con una profesora para que me ayude y voy a llevar estas notas, a ver si junto con esto puedo ir haciendo algo y luego lo vuelvo a postear, a ver que tal consigo hacerlo.

[valentina4you]

Hasta el momento hice esto:

Pero me parece que algo no está bien.

Código C++:

#include <stdlib.h>
#include <conio.h>
#include <iostream.h>
#include <time.h>
void main ()
{
//cargar vector con 5 numeros random//
for (int i=0; i<5, i++) 
    {scanf("%d", v_cargado[i]);
    (flushall);
    v_cargado[i]=random (9);
    // Controlar que no se repita //
    v_cargado[i] != v_cargado[i-1] hasta i=1;
    while (i!=0);}
    // Cargar 5 numeros random del 0 al 9 en un vector y no repita//
{
for (int j=0; j<5, j++)
    {scanf("%d", v_entrado[j]);
    printf("Ingresar un número");
    scanf("%j", &v_entrado[j])}
    if (j<9); //cargar vector para completar y controlar que el numero ingresado sea del 0 al 9//
 
bandera=0
for (j=0;j<5;i++)
    {if (numero==v_entrado[j]) bandera=1;
    printf("*")}
for (j=0;j<5;i++)
    if(v_cargado[i]==v_entrado[j] cantidad=cantidad+1)
    printf("$")
 
    getch();
}
 

Cualquier ayuda es bienvenida! :)
Sam, no he sabido utilizar lo que me has dicho :S entiendo más o menos pero no lo he sabido utilizar. La profe me dijo con respecto a lo que me dijiste tu para cargar un número random de 0 al 9 que con poner la funcion random (9) alcanzaba, no hacía falta hacer restos.
Soy un desastre, que estress...

[Rafael]

A ver. Yo de programación sé lo siguiente:... ya acabé.

Pero como reto de lógica está interesante. A ver si te sirve.

Si fuera un solo número llegamos antes de 10 pasos evidentemente. con la premisa de ir dividiendo el total de numeros a la mitad. No es tan exacto porque no tenemos decimales.
X=8
1) Es más grande o más chico o igual a 5... R. Más grande
2) Es más grande o mas chico que 7.5 mas R. Más grande
3 ) + 0 - que 8.75 R= más chico
4) Resultado = 8.

En este caso si puedes usar un array, probablemente estas preguntas las haces por cada elemento del array y ya... ¿no?

[s00rk]

Bueno ya con lo que t mostre anteriormente en el otro post, ya tenemos lo que es el vector de los 5 numeros aleatorios ahora toca hacer lo que tu dices, la forma mas "sencilla" o por lo menos para mi seri algo asi lo que faltaria hacer

Ocuparemos una variable llamada gano de tipo int en 0 y otra llamada turno puesta en 1

comenzariamos por mostrar el mensaje "Turno [" << turno << "]" y asi mostrariamos el turno en el que va y luego ingresar los 5 numeros luego de esto lo mas preferible seria guardarlos en un vector en su respectiva posicion, y ya ahora solo faltaria buscar estos en el vector original y ver si estan bien ordenadors o si por lo menos existe.

si existe y esta en la misma posicion a la respuesta le agregariamos $ y ademas aumentariamos la variable gano en +1, o si existe pero no es la misma posicion se le agrega *, y en ambos casos quebramos el bucle de busqueda para que vaya con el siguiente.

Al terminar los bucles aumentariamos el turno en + 1 y ya hecho esto, todo esto estaria dentro de otro bucle do{}while()
en donde en el while diria
Gano < 5 y turno <= 10 y asi veriamos si no gano y aun tiene turnos se repetira y ya al terminar todo esto ahora si solo queda ver

si gano es igual a 5 es que gano y le mostramos un mensake de felicitaciones sino pues le mostramos el mensaj de que perdio.

Bueno intenta hacerlo a como tu creas, estó es solamente un idea, si al final no puedes pues te dejo lo que yo hice comentado para que puedas entenderlo mejor n.n

[valentina4you]

Gracias a ambos.
Un colega forista me está ayudando para este trabajo.

Espero poderlo tener pronto y ver de que funcione y al menos pueda entender lo que estoy y me están haciendo.

Gracias, gracias, gacias y mil gracias a los que han dedicado su tiempo.
Cuanto esté terminado (que espero que así sea) haré la captura de pantalla de cómo ha quedado :).

Mil gracias!
Cualquier cosa vuelvo a preguntar.

[s00rk]

Ok, Mucha Suerte n_n*!

Cualquier cosa aqui estamos n_n

Sayo*! (me ire a desayunar ya es un poco tarde xD)

[valentina4you]

No tengo palabras para gradecer el tiempo que se toma la gente en ayudar.
Millones de gracias.

[s00rk]

Bueno como dudo mucho conectarme mañana y asi pues aqui dejo lo que yo hice por si aun tienes dudas y asi no dejarlo por ahi que luego se me olvida jejej

Código C++:

#include <stdio.h>
#include <time.h>
#include <iostream.h>
using namespace std;
 
int main(){
    int V[5]; // Crear nuestro vector de 5 casillas donde guardaremos los numeros aleatorios
    int n; // Aqui guardaremos el numero random que obtengamos con random(9)
    bool existe; // Usaremos para checar si el numero existe en el vector
    
    ///////////////// Llenar el Vector V con numeros aleatorios
    for(int i = 0; i < 5; i++) // Ir de 0 a 4, que son las casillas en el vector
    {
            srand((unsigned)time(0)); // Es utilizado para que luego al llamar rand(), este genere uno diferente, si no colocmos esto, rand() siempre retornara los mismos numeros
            do{
                existe = false; // Ponemos el checador en false
                n = rand() % 10; // Se guarda el numero random en n
                for(int x = 0; x < i; x++) // Recorremos el vector de 0 a i-1( x < i, es lo mismo a poner x <= i-1)
                {
                        if(V[x] == n) // Checamos si el valor del vector en la posicion x es igual a n
                        {
                                existe = true; // Si es asi cambiamos existe a true
                                break; // Y terminamos el bucle for
                        }
                }
            }while(existe); // Hara esto mientras existe == true
            
            V[i] = n; // Guardamos en n en el vector en la posicion i
    }
    ///////////////////////////////////////////////
    
    
    /// Imprimir el Resultado de los numeros aleatorios /////////////
    /// Esto solo lo ponemos por si deceamos saber que numeros son los correctos
    cout << "Resultado" << endl;
    for(int i = 0; i < 5; i++)
    {
            cout << V[i] << endl;
    }
    cout << endl;
    ////////////////////////////////////////////////////////////////
    
    ///////////  Juego     /////////////////////////////////////////
    int R[5]; // Crear nuestro vector de 5 casillas donde guardaremos las respuestas
    int gano; // Con esto checaremos luego si el usuario gano
    int turno = 1; // Total de oportunidades
    string respuesta; // Aqui guardaremos las respuesta de $ y *
    do
    {
            cout << "Oportunidad [" << turno << "]:" << endl; // Imprimimos la oportunidad en la que va
            cin>>R[0];//
            cin>>R[1];//
            cin>>R[2];// Ingresamos cada numero en una casilla del vector R que es de 5 casillas al igual que V
            cin>>R[3];//
            cin>>R[4];//
            respuesta = ""; // Ponemos respuesta vacio ""
            gano = 0; // Ponemos gano en 0
            for(int i = 0; i < 5; i++) // Bucle para recorrer en vector V
            {
                    for(int ii = 0; ii < 5; ii++) // Bucle para recorrer el vector R
                    {
                            if(V[i] == R[ii] && i == ii) // Si el valor de V en la posicion i es igual a el valor de R en la posicion ii y ademas i es igual a ii
                                                         // significa que el valor son lo mismos y ademas estan en la misma posicion
                            {
                                  respuesta += "$"; // Agregamos a respuesta el signo $
                                  gano++; // Aumentamos gano +1
                                  break; // Salimos del Bucle
                            }else if(V[i] == R[ii]){ // O si el valor de V en la posicion i es igual a R en la posicion ii son los mismos, pero i es diferente a ii
                                                     // Significa que los valores son los mismos pero estan en diferentes posiciones
                                                     
                                  respuesta += "*"; // Agregamos a respuesta *
                                  break; // Salimos del Bucle
                            }
                    }
            }
            cout << respuesta << endl; // Imprimimos respuesta que contendra los $ y * , segun el resultado de lo anterior
            turno++; // Aumentamos turno + 1
    }while(gano < 5 && turno <= 10); // Si gano es menor a 5 y turno es menor o igual a 10 se repite lo anterior
    
    cout << endl; // Saltode linea o espacio
    if(gano == 5) // Si gano es igual a 5, significa que el usuario a ganado
    {
          cout << "Usted ha Ganado! ;D" << endl; // Imprimimos mensaje de felicitaciones n_n
    }else{ // Si no
          cout << "Usted ha Perdido u_u" << endl;  // Imprimimos mensaje de que perdio
    }
    ///////////////////////////////////////////////////////////
    
    cin.get();cin.get();
    return 0;
}
 

[Gott]

Yo tambien lo hice!! Aunque un poco mas modularizado y en c++.. Un saludo!!

Código C++:

/* Genera una cadena de numeros que se tiene que adivinar. Por cada 
numero que se acierta se pone una "o" en el lugar. Por cada fallo un "x" */ 
 
#include <iostream> 
#include <cstdlib> 
#include <cstring> 
#include <ctime> 
 
using namespace std; 
 
/* Prototipos de las funciones */ 
int elegirDificultad(void); 
void generarSecuencia(int* cad, int dim); 
bool unico(int* cad, int num); 
bool hayGanador(int* oculto, int dim); 
bool controlar(int* oculto, int* intento, int dim); 
void convertirCadena(char* intento, int* intentoNumerico, int dim); 
 
/* Funcion Principal del Juego */ 
int main(int argc, char* argv[]) { 
   int* oculto;   // Secuencia generada 
   int* intento;   // Secuencia del usuario 
   int dim;      // Dimension de la cadena (Dificultad del juego) 
   srand(time(NULL)); 
    
   cout << "********** ADIVINA EL NUMERO OCULTO **********" << endl; 
   dim = elegirDificultad() + 3;   // Dificultad del juego 
   oculto = new int[dim]; 
    
   generarSecuencia(oculto, dim);   // Genera la secuencia 
   if(!hayGanador(oculto, dim)) {      // Juego 
      cout << endl << "Lo sentimos. Mala suerte. Intentalo mas tarde" << endl; 
   } else { 
      cout << endl << "Felicidades!! Eres un experto. Aumenta la dificultad" << endl; 
   } 
    
   return EXIT_SUCCESS; 
} 
 
/** 
 * Se permite al usuario elegir la dificultad del juego 
 * @return: Dificultad del juego 
*/ 
int elegirDificultad(void) { 
   int dificultad=0; 
   while(dificultad != 1 && dificultad != 2 && dificultad != 3) { 
      cout << "Ingrese la dificultad:" << endl; 
      cout << "1. Facil" << endl << "2. Medio" << endl << "3. Dificil" << endl << endl; 
      cout << "Dificultad: "; 
      cin >> dificultad; 
   } 
   return dificultad; 
} 
 
/** 
 * Genera la secuencia que hay que adivinar 
 * @var_cad: Guarda la cadena generada 
 * @var_dim: Dimension de la cadena generada 
*/ 
void generarSecuencia(int* cad, int dim) { 
   int i, num; 
   int salidos[10]; 
   // Inicializa para el control de repetidos 
   for(i=0; i<10; i++) { 
      salidos[i] = 0; 
   } 
   for(i=0; i<dim; i++) { 
      num = rand() % 9 + 1;   // Genera numeros entre 1-9 
      while(!unico(salidos, num)) {   // Control de repetidos 
         num = rand() % 9 + 1; 
      } 
      salidos[i] = num; 
      cad[i] = num; 
   } 
} 
 
/** 
 * Controla que no existan numeros repetidos en la cadena 
 * @var_cad: Numeros que ya salieron 
 * @var_num: Numero que se quiere insertar 
 * @return: true si puede agregarse, false si no se puede 
*/ 
bool unico(int* cad, int num) { 
   for (int i=0; i<10; i++) { 
      if(cad[i] == num) { 
         return false; 
      } 
   } 
   return true; 
} 
 
/** 
 * Argumento del juego 
 * @var_oculto: Secuencia a adivinar 
 * @var_dim: Dimension de la secuencia 
 * @return: true si hay ganador ; false si no hay 
*/ 
bool hayGanador(int* oculto, int dim) { 
   bool win=false;         // Para ver si hay ganador o no 
   char intento[dim];      // Secuencia del usuario 
   int intentoNumerico[dim]; 
   int numIntentos=0;      // Cantidad de intentos 
   int maxIntentos=dim*2;   // Intentos Maximos 
    
   while(!win && numIntentos < maxIntentos) { 
      cout << endl << "Ingrese el numero de " << dim << " cifras." << endl; 
      cout << "Intento nro: " << ++numIntentos << " de " << maxIntentos << endl; 
      cin >> intento; 
      if(strlen(intento) == dim) { 
         convertirCadena(intento, intentoNumerico, dim); 
         win = controlar(oculto, intentoNumerico, dim); 
      } 
   } 
    
   return win; 
} 
 
/** 
 * Convierte la cadena del usuario a una numerica 
 * @var_intento: Secuencia del usuario 
 * @var_intentoNumerico: Secuencia numerica 
 * @var_dim: Dimension de la secuencia 
*/ 
void convertirCadena(char* intento, int* intentoNumerico, int dim) { 
   for(int i=0; i<dim; i++) { 
      switch(intento[i]) { 
         case '1': 
            intentoNumerico[i] = 1; 
            break; 
         case '2': 
            intentoNumerico[i] = 2; 
            break; 
         case '3': 
            intentoNumerico[i] = 3; 
            break; 
         case '4': 
            intentoNumerico[i] = 4; 
            break; 
         case '5': 
            intentoNumerico[i] = 5; 
            break; 
         case '6': 
            intentoNumerico[i] = 6; 
            break; 
         case '7': 
            intentoNumerico[i] = 7; 
            break; 
         case '8': 
            intentoNumerico[i] = 8; 
            break; 
         case '9': 
            intentoNumerico[i] = 9; 
            break; 
      } 
   } 
} 
 
/** 
 * Controla los aciertos del usuario 
 * @var_oculto: Secuencia a adivinar 
 * @var_intento: Secuencia del usuario 
 * @var_dim: Dimension de la secuencia 
 * @return: true si adivino todo ; false si no acerto 
*/ 
bool controlar(int* oculto, int* intento, int dim) { 
   int aciertosFaltantes=dim; 
   for(int i=0; i<dim; i++) { 
      if(oculto[i] == intento[i]) { 
         cout << "o"; 
         aciertosFaltantes--; 
      } else { 
         cout << "x"; 
      } 
   } 
   cout << endl; 
   return !aciertosFaltantes; 
}
 

[valentina4you]

Ya había logrado resolver este temita. Pero de todas maneras agradezco a los que se tomaron e tiempo para ayudarme. Me quedo con las propuestas que hagan para aprender de lo que hicieron y ver como se pueden usar varias cosas para resolver el mismo problema.