Vale,gracias.Lo probarè y si tengo una dudo le pregunto.

Buenas,

Vamos a ver, tengo que hacer el juego del bingo en Java.Ya lo tengo casi hecho.Pero,en el modulo jugar tengo un problema.No se como hacer para que los numeros que vaya sacando no se repitan en el array.Tengo idea de que es con un for.Pero no se hacerlo me podiais ayudar.

Este es mi modulo jugar:

while (!VerSiFin()) {
         //Generar numero aleatorio
         numAleatorio=(int) (Math.random()*90+1);
         //Llamada al modulo resolver
         resolver(numAleatorio);
         //Llamada al modulo mostrar
         mostrar();
         //Ahora debo hacer un for para que comparar que no se repita un numero
      }

Te voy a enviar el programa completo.

---

Es todo lo que está en rojo
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
CÓDIGO:

//Adición de librerias

//Adición de sentencias de entrada y salida: cin y cout
#include <iostream>
//Adición de colores
#include <conio2.h>
//Manejo de ficheros
#include <fstream.h>
//Adición de sonidos al juego
#include <windows.h>
//Sentencia para evitar el std::cout y el std::cin
using namespace std;
//Definición de constantes
#define N 10
#define maxcar 20
#define M 30 //Para los puntos extra
#define maxronda 10

//Definición de tipo de dato de los siguientes vectores y de registros como:datos_jugador y numeroypuntos
typedef int aleatorios_juego[N];
typedef int numeros_introducidos[N];
typedef int fibonacci_puntos[N];
typedef char vector_nick[maxcar];
typedef struct{
   int codigo;
   vector_nick nombre;
   int partidas;
   int puntuacion_ultima;
   int puntuacion_max;
   int veces_final;
}datos_jugador;
typedef struct {
   aleatorios_juego al;
   fibonacci_puntos punt_fib;

}numerosypuntos;


//Prototipo modulos
void presentacion();
int menu();
numerosypuntos inicializar();
void mostrar_aleatorios_prueba(numerosypuntos  n);
void asteriscos();
datos_jugador introducir_datos();
void visualizar_datos(datos_jugador j);
void introducir_datos_fichero(datos_jugador j,ofstream & escritura_jugadores);
bool existencia_jugador_fichero (datos_jugador & j, ifstream & lectura_jugadores, int codigoint);
void jugar (datos_jugador & j,numerosypuntos n);
void carga_colores_sonidos_numeros(numerosypuntos n);
void instrucciones_juego(const numerosypuntos n);
void actualizar_fichero(ofstream & escritura_jugadores, datos_jugador j);
bool ronda(int numero_ronda, numerosypuntos n, datos_jugador & j, numeros_introducidos ni);
int calculo_fibonacci(int n);

//Main
int main() {

   //Declaracion variable jug perteneciente al registro datos_jugador
   datos_jugador jug;
   //Declaracion variable nu perteneciente al registro numerosypuntos
   numerosypuntos nu;
   //Declaracion de variable para el menu
   int opc;
   //Declaracion ficheros de lectura y escritura
   ifstream lectura_jugadores;
   ofstream escritura_jugadores;
   //Declaracion de variables para modulos
   int cod;
    int n_ronda;

    //Llamada al modulo presentación
   presentacion();
   //Se almacena el modulo menu en la variable opc para que pueda devolver una opcion el modulo menu
   opc=menu();

   //While para seleccionar las opciones del menu
   while(opc!=10){
      //Se le asigna el valor de 1 a la variable n_ronda
      n_ronda=1;
      switch(opc){
      case 1:
         //Muestra por pantalla que inicializara los aleatorios y los puntos para jugar
         cout<<"Inicializamos el conjunto de aleatorios de enteros y puntos para jugar."<<endl;
         //La llamada al módulo inicializar() se almacena en la variable nu,
         //ya que es una función y devuelve algo
         nu=inicializar();
         //Llamada al modulo asteriscos
         asteriscos();
         break;
      case 2:
         //Muestra por pantalla que introduzcas tus datos
         cout<<"Introduce tus datos :"<<endl;
         //La llamada al módulo introducir_datos() se almacena en la variable jug,
         //ya que es una función y devuelve algo
         jug=introducir_datos();
         //Llamada al modulo asteriscos
         asteriscos();
         break;
      case 3:
         //Muestra por pantalla que se van a comprobar los aleatorios generados
         cout<<"Comprobaremos los aleatorios generados."<<endl;
         //Llamada al módulo mostrar_aleatorios_prueba
         //Se le pasa la variable nu,ya que es un procedimiento.La variable nu esta en el programa principal
         mostrar_aleatorios_prueba(nu);
         //Llamada al modulo asteriscos
         asteriscos();
         break;
      case 4:
         //Muestra por pantalla que van a mostrar los datos introducidos del jugador
         cout<<"Estos son los datos del jugador :"<<endl;
         //Llamada al módulo asteriscos
         asteriscos();
         //Llamada al módulo visualizar_datos
         //Se le pasa la variable jug,ya que es un procedimiento.La variable jug esta en el programa principal
         visualizar_datos(jug);
         //Llamada al modulo asteriscos
         asteriscos();
         break;
      case 5:
         //Muestra por pantalla que se van a introducir los datos del jugador en el fichero
         cout<<"Introducimos los datos del jugador en el fichero ""simon.txt"""<<endl;
         //Llamada al módulo introducir_datos_fichero
         //Se le pasa la variable jug y el fichero de escrituta:escritura_jugadores para añadir los datos de  los jugadores en el fichero,
         //ya que es un procedimiento.La variable jug esta en el programa principal
         introducir_datos_fichero(jug,escritura_jugadores);
         //Muestra por pantalla que los datos han sido introducidos correctamente
         cout<<"Los datos han sido introducidos al fichero satisfactoriamente ."<<endl;
         break;
      case 6:
         //Muestra por pantalla que se comprobará si el jugador introducido esta en el fichero
         cout<<"Comprobamos si el jugador introducido está disponible en el fichero :"<<endl;
         //Muestra por pantalla que introduzcas el codigo del jugador para buscarlo en el fichero
         cout<<"Introduce codigo del jugador para localizar :"<<endl;
         //Se introduce por teclado el codigo del jugador a buscar
         cin>>cod;

         //If para comprobar si el jugador existe en el fichero,después de haber introducido el codigo del jugador
         if(existencia_jugador_fichero (jug,lectura_jugadores,cod))
         {
            cout<<"El jugador con codigo:  "<<cod<<"  existe en el fichero."<<endl;

         }
         else{
            cout<<"El jugador con codigo:   "<<cod<<"  no existia y lo hemos creado."<<endl;
         }
         //Llamada al modulo asterisco
         asteriscos();
         break;
      case 7:
         //Llamada al módulo instrucciones_juego
         //Se le pasa la variable nu,ya que es un procedimiento.La variable nu esta en el programa principal
         instrucciones_juego(nu);
         //Llamada al modulo asterisco
         asteriscos();
         break;
      case 8:
         //Se añade el color azul claro
         textcolor(LIGHTBLUE);
         //Muestra por pantalla un mensaje de bienvenida
         cout<<"¡¡BIENVENIDO/A AL JUEGO DEL SIMON:   "<<   jug.nombre  <<endl;
         //Se añade el tiempo de retraso
         Sleep(2000);
         //Llamaada al módulo jugar
         //Se le pasa la variable jug y la variable nu,ya que es un procedimiento.La variable jug y nu estan en el programa principal
         jugar(jug,nu);
         break;
      case 9:
         //Llamada al módulo actualizar_fichero
         //Se le pasa el fichero escritura_jugadores y la variable jug ,ya que es un procedimiento.La variable jug y el fichero estan en el programa principal
         actualizar_fichero(escritura_jugadores,jug);
         //Llamada al modulo asterisco
         asteriscos();
         break;

      }
      //Denuevo se vuelve a llamar al modulo menu junto a su variable de almacenamiento opc, ya que se debe volver a mostrar el menu para poder elegir otra opcion
      opc=menu();
   }
   //Al salir del juego
   //Muestra por pantalla un mensaje de que viciarse es malo
   cout<<"Eso, ¡sin viciarse que eso es malo!"<<endl;
   system("PAUSE");

   return 0;
}
//Definición de modulos
//Modulo 1.Presentación : Mostrara unos mensajes de bienvendida al juego
void presentacion()
{
   //Se añade el color amarillo a los mensajes de bienvenida
   textcolor(YELLOW);
   //Muestra por pantalla los mensajes de bienvenida
   cout<<"***********************************************************************************************"<<endl;
   cout<<"******************************  BIENVENIDO/A LA PRACTICA FINAL DE FP       ********************"<<endl;
   cout<<"******************************            CURSO 2015/16                    ********************"<<endl;
   cout<<"******************************          JUEGO 'SUPER SIMON'                ********************"<<endl;
   cout<<"******************************    REALIZADO POR: LEANDRO & TOMAS & RICARDO ********************"<<endl;
   cout<<"***********************************************************************************************"<<endl;
   //Banda sonora al iniciar el juego
   Beep (330,100);Sleep(100);
   Beep (330,100);Sleep(300);
   Beep (330,100);Sleep(300);
   Beep (262,100);Sleep(100);
   Beep (330,100);Sleep(300);
   Beep (392,100);Sleep(700);
   Beep (196,100);Sleep(700);

}
//Modulo 2.Menu: Mostrara las opcione a elegir
int menu()
{
   //Se añade el color blanco a las opciones a elegir
   textcolor(WHITE);
   //Declaracion de variable opcion
   int opcion;
   //Muestra por pantalla las opciones a elegir
   cout<<"1.INICIALIZAR NUMEROS ALEATORIOS Y PUNTOS."<<endl;
   cout<<"2.INICIALIZAR JUGADOR NUEVO."<<endl;
   cout<<"3.VISUALIZAR NUMEROS ALEATORIOS(SOLO PARA PRUEBAS): BAJO CONTRASEÑA."<<endl;
   cout<<"4.VISUALIZAR LOS DATOS DEL JUGADOR."<<endl;
   cout<<"5.INTRODUCIR JUGADOR EN EL FICHERO."<<endl;
   cout<<"6.COMPROBACION DE LA EXISTENCIA DEL JUGADOR EN EL FICHERO."<<endl;
   cout<<"7.INSTRUCCIONES DEL JUEGO (MÓDULO EXTRA AÑADIDO POR NOSOTROS)"<<endl;
   cout<<"8.JUGAR AL JUEGO."<<endl;
   cout<<"9.ACTUALIZAR DATOS DEL FICHERO DE JUGADORES."<<endl;
   cout<<"10.SALIR DEL PROGRAMA."<<endl;
   //Muestra por pantalla que introduzcas un numero del 1 al 10
   cout<<"Introduce opcion de 1 a 10 :"<<endl;
   //Se introduce la opcion deseada
   cin>>opcion;
   //While para controlar que el que haya elejido la opcion la haya introducido correctamente
   //Sino se ha introducido correctamente mostrara un mensaje de error
   while(opcion<1 || opcion>10)
   {
      //Muestra un mensaje de error y que vuelvas a elegir una opcion
      cout<<"Error, opción introducida no es valida. Introduce una opcion de 1 a 9 :"<<endl;
      //Se introduce la opcion deseada
      cin>>opcion;
   }
   //El modulo devuelve una opcion.Es decir, la opción elegida
   return opcion;
}

//Modulo 3.Inicializar: (Inicialiazará los datos del jugador ,si es nuevo)
//Calculará el Fibonacci y mostrará un mensaje de que se an inicializado correctamente los aleatorio y los puntos
numerosypuntos inicializar()
{
   //Declaración de variable n del registro numerosypuntos
   numerosypuntos n;
   //Inicialización de la semilla aleatoria
   srand(time(NULL));
   //For para ir recorriendo el vector
   for(int i=0;i<N;i++)
   {
      //Fórmula para ir calculando numeros aleatorios entres 0 y 10
      n.al=rand()%11;
   }
   //For para ir recorriendo el vector
   for(int i=0;i<N;i++)
   {
      //Fórmula para calcular el Fibonacci
      n.punt_fib=calculo_fibonacci(i);

   }
   //Muestra por pantalla un mensaje de que los aleatorios y los puntos han sido inicializados satisfactoriamente
   cout<<"Aleatorios y puntos inicializados satisfactoriamente:)"<<endl;
   //El módulo devuelve los numeros aleatorios y los puntos Fibonacci*
   return n;
}
//Modulo 3.Mostrar_aleatorios_prueba: Mostrará los números aleatorios del vector del juego(sólo el adminustrador del juego puede verlos)
//Habrá que introducir una clave para ver los aleatorios
void mostrar_aleatorios_prueba(const numerosypuntos n)
{
   //Contraseña: 12345
   //Declaracion de variable contraseña
   int contrasena;
   //Muestra por pantalla un mensaje de que mostrará los aleatorios,pero si antes has introducido la contraseña
   cout<<"Mostraremos el vector con todos los aleatorios, pero antes, INTRODUZCA SU CONTRASEÑA :"<<endl;
   //Se introduce la contraseña que debe ser correcta para poder ver los aleatorios
   cin>>contrasena;
   //While para controlar que el que haya introducido la contraseña la haya introducido correctamente
   //Sino se ha introducido correctamente mostrara un mensaje de error
   while(contrasena!=12345){
      cout<<"Error, contraseña incorrecta. Introduzca de nuevo la contraseña :"<<endl;
      //Se vuelve a introducir la contraseña que debe ser correcta para poder ver los aleatorios
      cin>>contrasena;
   }
   //Muestra por pantalla un mensaje para mostrar los aleatorios del vector
   cout<<"Aquí están los aleatorios generados en el vector :"<<endl;
   //For para recorrer el vector
   for(int i=0;i<N;i++)
   {
      //Muestra por pantalla un mensaje para mostrar los aleatorios(n.al) en función de la posición i del vector
      cout<<"El numero :   "<< i <<  "    es     :"<<    n.al<<endl;
   }
   //For para recorrer el vector
   for(int i=0;i<N;i++)
   {
      //Muestra por pantalla un mensaje para los numeros Fibonacci(n.punt_fib) en función de la posición i del vector
      cout<<"En la posicion fibonacci :  "<<i<<"   se encuentrar los puntos:   "<<n.punt_fib<<endl;
   }
}
//Modulo 4.Asteriscos: Mostrará una línea de asteriscos
void asteriscos()
{
   cout<<"**************************************************************************************"<<endl;
}
//Modulo 5.Calculo_fibonacci: Calculará la sucesión Fibonacci
int calculo_fibonacci(int n)
{
   //Declaración de variable fib que será devuelta por el módulo
   int fib;
   //If para controlar que si el numero pasado n es 0 o 1 la variable Fibonacci valdrá 1
   //Sino se calculará el Fibonaccion con la fórmula de debajo del else
   if((n==0)||(n==1))
   {
      fib=1;
   }
   else{
      //No la entiendo
      fib=(calculo_fibonacci(n-2)+calculo_fibonacci(n-1));
   }
   //El módulo devuelve un entero que será el Fibonacci*
   return fib;

}
//Modulo 6.Introducir_datos: Mostrará los datos del jugador
datos_jugador introducir_datos(){
   //Declaración de variable j del registro datos_jugador
   datos_jugador j;
   //Muestra por pantalla un mensaje de que introduzcas el codigo del jugador a registrar
   cout<<"Introduce el codigo del jugador :"<<endl;
   //Se introduce el codigo
   cin>>j.codigo;
   //Muestra por pantalla un mensaje de que introduzcas el nombre del jugador a registrar
   cout<<"Introduce el nombre del jugador :"<<endl;
   //Se introduce el nombre
   cin>>j.nombre;
   //Incicializo las partidas,puntuacion ultima,puntiacion maxima y veces final a 0
   j.partidas=0;
   j.puntuacion_ultima=0;
   j.puntuacion_max=0;
   j.veces_final=0;
   //El módulo devuelve los datos del jugador, que serían los datos introducidos
   return j;
}
//Modulo 7.Visualizar_datos: Visualizará los datos del jugador
void visualizar_datos(const datos_jugador j)
{
   //Muestra por pantalla etsos mensajes que son los datos del jugador
   cout<<"El código del jugador es  :    "<< j.codigo<<endl;
   cout<<"EL nombre del jugador es  :    "<< j.nombre <<endl;
   cout<<"El jugador   :   "<< j.nombre  <<"    lleva   :"<< j.partidas << "   jugadas  ."<<endl;
   cout<<"El jugador   :   "<< j.nombre << "  consiguó un total de   :   "<<j.puntuacion_ultima << "    puntos la última vez que jugó. "<<endl;
   cout<<"El jugador   :   "<<j.nombre<< "   ha conseguido una puntuación maxima de :  "<<j.puntuacion_max<< "  puntos."<<endl;
   cout<<"El jugador   :   "<<j.nombre<< "   ha llegado al final del juego  :   "<<j.veces_final<<"  veces."<<endl;
}
//Módulo 8.Introducir_datos_fichero : Se almacenarán los datos en el fichero
void introducir_datos_fichero(datos_jugador j,ofstream & escritura_jugadores)
{
   //Muestra por pantalla etsos mensajes que son los datos del jugador
   cout<<"Vamos a guardar los datos del jugador en el fichero de texto : simon.txt."<<endl;
   //Se abre el fichero para escribir sobre él
   escritura_jugadores.open("simon.txt");
   //If para comprobar que si el fichero se ha abierto correctamente,se alamacenen los datos en el fichero
   //Si se abre mal mostrará un mensaje de error
   if(escritura_jugadores.fail())
   {
      cout<<"Error en la apertura del fichero simon.txt, lo sentimos."<<endl;
   }
   else
   {
      escritura_jugadores<<j.codigo<<endl;
      escritura_jugadores<<j.nombre<<endl;
      escritura_jugadores<<j.partidas<<endl;
      escritura_jugadores<<j.puntuacion_ultima<<endl;
      escritura_jugadores<< j.puntuacion_max <<endl;
      escritura_jugadores<< j.veces_final<<endl;


   }
   //Se cierra el fichero para que no se vuelva corrupto y para que se guarden los datos
   escritura_jugadores.close();
}
//Módulo 8.Existencia_jugador_fichero: Se verificará si los datos del jugador están en el fichero
bool existencia_jugador_fichero (datos_jugador & j, ifstream & lectura_jugadores, int codigoint)
{
   //Declaración de variable existe que será devuelta por el módulo, y está puesta a false
   bool existe=false;
   //Se abre el fichero para leer lo que hay dentro
   lectura_jugadores.open("simon.txt");
   //If para comprobar que si el fichero se ha abierto correctamente,se alamacenen los datos en el fichero
   //Si se abre mal mostrará un mensaje de error
   if(lectura_jugadores.fail())
   {
      cout<<"Lo sentimos, se ha producido un error en la lectura del fichero."<<endl;

   }
   else
   {
      //Sino hace una lectura anticipada con el codigo del jugador
      //y luego se leen los demas datos y se muestran por pantalla
      lectura_jugadores>>j.codigo;
      //While para controlar que si existe el jugador y no se ha llegado a fin de fichero
      //se mostraran por pantalla los datos del juagdor
      while(!lectura_jugadores.eof()&& existe==false)
      {
         //If para controlar que si el codigo del jugador es igual al codigo introducido
         //y existe, se mostrarán los datos del jugador
         if(codigoint==j.codigo)
         {
            existe=true;
         }
         lectura_jugadores>>j.nombre;
         lectura_jugadores>>j.partidas;
         lectura_jugadores>>j.puntuacion_max;
         lectura_jugadores>>j.puntuacion_ultima;
         lectura_jugadores>>j.veces_final;
         lectura_jugadores>>j.codigo;
      }
      //If para controlar que si el jugador no existe,tengas que meter los datos de nuevo
      if(existe==false)
      {
         //Llamada al modulo introducir_datos que se almacenará en la variable j del registro datos_jugador
         j=introducir_datos();
      }

      //Muestra por pantalla un mensaje de que se han leído los datos correctamente
      cout<<"Datos leídos correctamente..."<<endl;
      if(codigoint==j.codigo)
      {
         //Muestra por pantalla un mensaje de que el jugador tal si existe en el fichero
         cout<<"El jugador con codigo  :    "<< codigoint <<"   sí existe en el fichero."<<endl;
      }
      else
      {
         //Muestra por pantalla un mensaje de que el jugador con codigo tal no existe en el fichero
         cout<<"El jugador con codigo  :  "<< codigoint <<"   no existe en el fichero."<<endl;
      }
   }
   //Se cierra el fichero de lectura
   lectura_jugadores.close();
   //El módulo devuelve un booleano
   return existe;
}
//Módulo 9.Carga_colores_sonidos_numeros: Se cargarán los colores y sonidos por cada numero
void carga_colores_sonidos_numeros(numerosypuntos n)
{
   //For para recorrer el vector
   for(int cont=0;cont<N;cont++)
   {
   //If para aplicarle a cada numero aleatorio un color y un sonido distinto
   if(n.al[cont]==0){
      textcolor(1);
      Beep(500,200);
   }
   if(n.al[cont]==1){
      textcolor(2);
      Beep(200,101);
   }
   if(n.al[cont]==2){
      textcolor(3);
      Beep(797,145);
   }
   if(n.al[cont]==3){
      textcolor(4);
      Beep(567,189);
   }
   if(n.al[cont]==4){
      textcolor(5);
      Beep(345,200);
   }
   if(n.al[cont]==5){
      textcolor(6);
      Beep(200,400);
   }
   if(n.al[cont]==6){
      textcolor(7);
      Beep(320,134);
   }
   if(n.al[cont]==7){
      textcolor(8);
      Beep(302,211);
   }
   if(n.al[cont]==8){
      textcolor(9);
      Beep(211,400);
   }
   if(n.al[cont]==9){
      textcolor(10);
      Beep(322,1000);
   }
   if(n.al[cont]==10){
      textcolor(11);
      Beep(233,544);
   }
   }//Fin for
}

//Módulo 10.Jugar: Permitirá jugar el juego
void jugar (datos_jugador & j,numerosypuntos n)
{
   //Declaración de variable ni del registro numeros_introducidos
   numeros_introducidos ni;
   //Declaración de un contador y se inicializa a 1
   int num_ronda=1;
   //Declaración de variable booleana
   bool controlador=true;
   //While para comprobar que la variable controlador se cumpla y que el numero de ronda sea menor que el maximo de rondas
   while(controlador==true && num_ronda<maxronda)
   {

      //Se comprueba que la ronda sea la correcta y se aumente en una unidad
      controlador=ronda(num_ronda,n,j, ni);
      //Contador para pasar a la siguiente ronda
      num_ronda++;


   }
   //If para controlar que si la variable controlador se cumple
   //Se mostrará por pantalla que has pasado a la siguiente ronda,entre otras cosas.
   if(controlador==true)
   {
      cout<<"¡¡FELICIDADES!! Has logrado pasar la ronda 10."<<endl;
      cout<<"¡¡TE LLEVAS UN BONUS DE 30 PUNTOS POR ACABARTE EL JUEGO!!"<<endl;
            cout<<"Llevas una puntuacion total de   :  "<<j.puntuacion_ultima<<endl;
            j.veces_final++;
            j.partidas++;
            cout<<"ENHORABUENA, ¡¡¡ERES UN AUTÉNTICO GENIO!!! HAS CONSEGUIDO ACABARTE EL JUEGO."<<endl;
            cout<<"**********************¡¡¡FIN DEL JUEGO!!!*************************************"<<endl;
            Sleep(4000);
   }
   //Sino se cumple se mostrará un mensaje de que has perdido
   else
   {
      cout<<"Has perdido."<<endl;
      Sleep(4000);
      asteriscos();
   }
}
//Módulo 11.Ronda: Mostrará los números de cada ronda
bool ronda(int numero_ronda, numerosypuntos n, datos_jugador & j, numeros_introducidos ni)
{
   //Declaración de variable booleana controlador
   bool controlador=true;
   //Declaración variable contador y se inicializa a cero
   int cont=0;

   //For para recorrer el vector
   for(int i=0;i<numero_ronda;i++)
   {
   //Se limpia la pantalla
   clrscr();
   //Llamada al módulo carga_colores_sonidos_numeros
   carga_colores_sonidos_numeros(n);
   //Muestra por pantalla los numeros aleatorios
   cout<<n.al<<"  ";
   Sleep(1500);
   textcolor(WHITE);

   }
   cout<<"Esperamos 5 segundos a que memorices el contenido..."<<endl;
   Sleep(5000);//Espero 5 segundos
   clrscr();
   for(int i=0;i<numero_ronda;i++)
   {
   cout<<"Introduce los numeros que has visto :"<<endl;
   cin>>ni;
   }

   while(controlador==true && cont<numero_ronda)
   {
      if(n.al[cont]!=ni[cont])
         {
            controlador=false;
            j.partidas++;
            j.puntuacion_ultima=j.puntuacion_ultima-M/3;
            j.puntuacion_max=j.puntuacion_ultima;
            cout<<"Tu puntuacion es de :   "<<j.puntuacion_max<<endl;

         }
         else{
            controlador=true;
            j.puntuacion_ultima=n.punt_fib[cont];
            cout<<"¡¡FELICIDADES!! Has logrado pasar la ronda:  "<<cont+1<<endl;
            cout<<"Llevas una puntuacion total de   :  "<<j.puntuacion_ultima<<endl;

            cout<<"******************RONDA:  "<<cont+2<<"*************************************"<<endl;
            Sleep(4000);
         }
    cont++;
   }
   return controlador;
}


void instrucciones_juego(const numerosypuntos n)
{
   textcolor(LIGHTRED);
   cout<<"******************************************************************************************************************************"<<endl;
   cout<<"*********************************************INSTRUCCIONES DEL JUEGO**********************************************************"<<endl;
   cout<<"******************************************************************************************************************************"<<endl;
   textcolor(WHITE);
   cout<<"1.-Aparecera un numero en la pantalla."<<endl;
   cout<<"2.-Deberas memorizar el numero bien, tienes 5 segundos para hacerlo."<<endl;
   cout<<"3.-Despues, deberas introducir ese mismo numero correctamente, si no lo haces el juego terminará y perderas. Tu puntuación sera de -10."<<endl;
   cout<<"4.-Si aciertas, iras progresando en el juego, pasaras de ronda. Aparecera el numero que aparecio anteriormente, mas otro nuevo. Asi sera hasta que termines las 10 rondas o pierdas."<<endl;
   cout<<"5.-Los puntajes son los siguientes (RONDA 0 ES LA RONDA 1, RONDA 9 ES LA RONDA 10)"<<endl;
   for(int i=0;i<N;i++)
   {
      cout<<"Si superas la ronda:  "<<i<<"  te llevas:    "<<n.punt_fib<<"  puntos."<<endl;
   }
   cout<<"6.-Si consigues llegar a la mitad del juego (ronda 5), recibiras una bonificación extra de 15 puntos."<<endl;
   cout<<"7.-Si consigues acabar el juego (ronda 10), recibiras una bonificacion extra de 30 puntos. "<<endl;
   textcolor(LIGHTRED);
   cout<<"**************************************¡¡A JUGAR!!*****************************************************************************"<<endl;
   Beep (330,100);Sleep(100);
   Beep (330,100);Sleep(300);
   Beep (330,100);Sleep(300);
   Beep (262,100);Sleep(100);
   Beep (330,100);Sleep(300);
   Beep (392,100);Sleep(700);
   Beep (196,100);Sleep(700);
   textcolor(WHITE);

}

void actualizar_fichero(ofstream & escritura_jugadores, datos_jugador j)
{
   escritura_jugadores.open("simon.txt");
   if(escritura_jugadores.fail())
   {
      cout<<"Error en la apertura del fichero de escritura."<<endl;
   }
   else
   {
      escritura_jugadores<<j.codigo<<" ";
      escritura_jugadores<<j.nombre<<" ";
      escritura_jugadores<<j.partidas<<" ";
      escritura_jugadores<<j.puntuacion_ultima<<" ";
      escritura_jugadores<< j.puntuacion_max <<" ";
      escritura_jugadores<< j.veces_final<<endl;

   }
   escritura_jugadores.close();
   cout<<"Fichero actualizado correctamente."<<endl;
}

Gracias, ya he solucionado mi problema.

Buenas, como hago para que este módulo sea más eficiente?

CÓDIGO:

void carga_colores_sonidos_numeros(numerosypuntos n)
{
   //For para recorrer el vector
   for(int cont=0;cont<N;cont++)
   {

   if(n.al[cont]==0){
      textcolor(1);
      Beep(500,200);
   }
   if(n.al[cont]==1){
      textcolor(2);
      Beep(200,101);
   }
   if(n.al[cont]==2){
      textcolor(3);
      Beep(797,145);
   }
   if(n.al[cont]==3){
      textcolor(4);
      Beep(567,189);
   }
   if(n.al[cont]==4){
      textcolor(5);
      Beep(345,200);
   }
   if(n.al[cont]==5){
      textcolor(6);
      Beep(200,400);
   }
   if(n.al[cont]==6){
      textcolor(7);
      Beep(320,134);
   }
   if(n.al[cont]==7){
      textcolor(8);
      Beep(302,211);
   }
   if(n.al[cont]==8){
      textcolor(9);
      Beep(211,400);
   }
   if(n.al[cont]==9){
      textcolor(10);
      Beep(322,1000);
   }
   if(n.al[cont]==10){
      textcolor(11);
      Beep(233,544);
   }
   }//Fin for
}

El módulo "leerdatos" se supone que es mostrar por pantalla los datos que tengo en el fichero.El problema es que no me muestra nada.ftp://
Coómo hago para queme lo muestre???

CÓDIGO:

 
//Diseña un programa en el que se muestren las comunidades autonomas de españa y ciudades autonomas
//Modulo para:
//1.Introducucir comunidades y ciudades autonomas por orden alfabetico
//2.Mostrar ciudad o comunidad autonoma
//3.Introducri todas las comunidades y ciudades autonomas pot orden alfabetico
//4.Mostrar comunidades y ciudades autonomas por orden alfabetico
//5.Mostrar cuales comunidades y ciudades autonomas cuales estan la peninsula
//6.Mostrar cuales comunidades y ciudades autonomas  estan fuera de la peninsula
//7.Salir
//NOTA:Las comunidades autonomas son: Andalucía,Aragón,Principado de Asturias,Islas Baleares,Canarias,Cantabria,Casatilla-La Mancha,Castilla y León,Cataluña,Comunidad Valenciana,
//Extremadura,Galicia,La Rioja,Comunidad de Madrid,Comunidad Foral de Navarra,País Vasco y Región de Murcia
//Las ciudades autonomas son: Ceuta y Melilla
//Usar Vectores,Regristros y ficheros
#include <iostream>
#include<fstream>
using namespace std;
//Definimos las constantes
#define N 2
//Defino el tipo de dato cadena para el registro comunidadyciudades
typedef char cadena[30];
//Definimos un tipo de registro comunidadesyciudades
typedef struct {
	int enumeracion;
	cadena nombre;
	float precio;
 
}cochelujoso;
//Defino el tipo de vector que se llamara vectorciudadesycomunidades y contendra el registro comunidadesyciudades
typedef cochelujoso vectorcoches[N];
//Prototipos modulos
void introducircoche(vectorcoches v);
void mostrarcoche(vectorcoches v);
void ventacoche(int numerolista,const vectorcoches v);
void almacenarcoche(const vectorcoches v);
void leerdatos(vectorcoches v);
 
int menu();
 
int main() {
	//Declaro el tipo de datos vector
	vectorcoches v;
	//Declaro variables
	bool salir;
	salir=false;
	bool introducido;
	introducido=false;
	int nhumerolista;
//Llamada la modulo menu
while(salir==false){
	switch(menu()){
	case 1: introducircoche(v);
	introducido=true;
	break;
	case 2:
		if(introducido==true){
		mostrarcoche(v);
	}
	else
	{
		cout<<"Introducir los datos del coche"<<endl;
	}
	break;
	case 3:
	cout<<"Introduce la enumeracion del coche que se va a vender"<<endl;
	cin>>nhumerolista;
	ventacoche(nhumerolista,v);
	break;
	case 4: almacenarcoche(v);
	break;
	case 5: leerdatos(v);
	break;
	case 6:
	cout<<"Usted ha salido.Gracias por usar este programa"<<endl;
	salir=true;
 
 
	break;
 
}
}
 
	return 0;
}
void introducircoche(vectorcoches v)
{
	for(int i=0;i<N;i++)
	{
		cout<<"Introduce el numero del coche"<<endl;
		cin>>v[i].enumeracion;
		while(v[i].enumeracion<1||v[i].enumeracion>18)
						{
							cout<<"Error, la enumeracion debe ser >=1 o <=18"<<endl;
							cin>>v[i].precio;
						}
		cout<<"Introduce nombre del producto"<<endl;
		cin>>v[i].nombre;
		cout<<"Introduce el precio"<<endl;
		cin>>v[i].precio;
		while(v[i].precio<=0)
				{
					cout<<"Error, el precio debe ser >0"<<endl;
					cin>>v[i].precio;
				}
 
 
}
}
void mostrarcoche(vectorcoches v){
	for(int i=0;i<N;i++){
		cout<<"La enumeracion del coche es:"<<v[i].enumeracion<<endl;
		cout<<"La marca del coche es:"<<v[i].nombre<<endl;
		cout<<"El precio de coche es:"<<v[i].precio<<endl;
	}
 
}
void ventacoche(int numerolista,const vectorcoches v){
	int i=0;
	while(i<N){
		if(v[i].enumeracion==numerolista){
			cout<<"El coche es:"<<" "<<v[i].nombre<<endl;
			cout<<"El precio del coche es:"<<v[i].precio<<" "<<"euros"<<endl;
		}
		i++;
		}
	}
void almacenarcoche(const vectorcoches v ){
ofstream salida;
salida.open("Coches.txt");
if(salida.fail()){
	cout<<"Error.No he podido abrir el fichero"<<endl;
}
else{
	cout<<"El fichero se abrio correctamente"<<endl;
}
for(int i=0;i<N;i++){
	salida<<v[i].enumeracion<<" "<<v[i].nombre<<" ";
	salida<<v[i].precio<<" "<<endl;
}
 
salida.close();
}
void leerdatos(vectorcoches v){
ifstream entrada;
entrada.open("Coches.txt");
if(!entrada.fail()){
	for(int i=0;i<N;i++){
		entrada>>v[i].enumeracion;
		entrada>>v[i].nombre;
		entrada>>v[i].precio;
	}
}
}
 
int menu(){
	int opcion;
	cout<<"1.Introducir los datos coches"<<endl;
	cout<<"2.Mostrar los datos de los coches"<<endl;
	cout<<"3.Simulacion venta de algun coche"<<endl;
	cout<<"4.Almacenar los datos en el fichero de texto"<<endl;
	cout<<"5.Leer los datos del fichero de texto"<<endl;
	cout<<"6.Salir"<<endl;
	cin>>opcion;
	while(opcion<1||opcion>6){
		cout<<"Error.Introduce una opcion que sea correcta"<<endl;
		cin>>opcion;
	}
	return opcion;
}
 

[MOD] Para publicar cóigo, usar etiquetas GeSHi.

Dim tpautas(14) As string
tpautas(1) = "Proporcione   alternativas   equivalentes   al   contenido   visual   y   auditivo"
        tpautas(2) = "No   se   basa   sólo   en   el   color"
        tpautas(3) = "Utilice   marcadores   y   hojas   de   estilos   u   hágalo   apropiadamente"
        tpautas(4) = "Identifique   el   idioma   original   usado"
        tpautas(5) = "Cree   tablas   que   se   transformen   correctamente"
        tpautas(6) = "Asegure    que    las    páginas    que    incorporan    nuevas    tecnologías         se    transformen correctamente"
        tpautas(7) = "Asegure    al    usuario    el    control    sobre    los    cambios    de    los    contenidos    tempodependientes"
        tpautas(8) = "Asegure   la   accesibilidad   directa   de   las   interfaces   de   usuario   incrustadas"
        tpautas(9) = "Diseñe   para   la   independencia   del   dispositivo"
        tpautas(10) = "Utilice   soluciones   provisionales"
        tpautas(11) = "Utilice   las   tecnologías   y   pautas   W3C"
        tpautas(12) = "Proporcione   información   de   contexto   y   orientación"
        tpautas(13) = "Proporcione   mecanismos   claros   de   navegación"
        tpautas(14) = "Asegure   que   los   documentos   sean   claros   y   simples"

NOTA: TENGO QUE LLAMAR A AL PRIMERA PAUTA PARA ESCRIBIRLA EN UNA CAJA[/font]

Lo he hecho con while porque la profesora me dijo que había que hacerlo con while,y luego me dijo que el numero que debo adivinar debe generarse aleatoriamente en pantalla y tiene que ser un numero aleatorio de 1 hasta N(por ejemplo de 1 hasta 10).Mi problema es que cuando porngo el numero adivinado, no me muestra el mensaje de correcto, sino que dice que meta otro numero.

código probado en el software Eclipse Indigo C++

código:

//Construir un programa que simule el siguiente juego entre los jugadores A (advino) y P (pensador):
//P piensa un número comprendido entre 1 y N ,
//y A trata de adivinarlo, mediante tanteos sucesivos, hasta dar con él. Por cada tanteo de A, P
//da una respuesta orientativa de entre las siguientes:
//Fallaste. El número pensado es menor que el tuyo.
//Fallaste. Mi número es mayor.
//Acertaste al fin.
//Mejoras:
//Debe acertar en el número de jugadas que se introduzca por teclado.
//Se debe ejecutar tantas veces como quiera el usuario.
#include <iostream>
using namespace std;
#define NUMMAX 11
#define NUMMIN 1

int main() {
   int numero,numeroaadivinar,numeromaximo,numeroaleatorio;
   srand(time(NULL));
   numeroaleatorio=rand();
   cout<<"El numero aleatorio es:"<<(numeroaleatorio=1+rand()%(NUMMAX-1))<<endl;

   while((rand()%NUMMAX)!=numero){
      cout<<"Introduce un numero entre 1 y 10"<<endl;
            cin>>numero;
            if((numeroaleatorio<numero){
                     cout<<"Fallaste.El numero pensado es menor que el tuyo"<<endl;
                  }
            if((numeroaleatorio>numero){
               cout<<"Fallaste.Mi numero es mayor que el tuyo"<<endl;
            }


   }

   cout<<"Correcto.Has adivinado el numero"<<endl;

   return 0;
}

Buenas,Tengo que realizar este ejercicio.Lo he hecho con un if,Pero en el ejercicio necesito adivinar el numero;tantas veces ,hasta adivinar dicho numero.

Creo que debería usar un bucle do while¿Qué os parece?

Este es el codigo:

//Construir un programa que simule el siguiente juego entre los jugadores A (advino) y P (pensador):
//P piensa un número comprendido entre 1 y N ,
//y A trata de adivinarlo, mediante tanteos sucesivos, hasta dar con él. Por cada tanteo de A, P
//da una respuesta orientativa de entre las siguientes:
//Fallaste. El número pensado es menor que el tuyo.
//Fallaste. Mi número es mayor.
//Acertaste al fin.
//Mejoras:
//Debe acertar en el número de jugadas que se introduzca por teclado.
//Se debe ejecutar tantas veces como quiera el usuario.
#include <iostream>
using namespace std;

int main() {
   int numeromaximo,numero,numeroaadivinar;
   cout<<"Entre 1 y que, quieres el numero?"<<endl;
   cin>>numeromaximo;
   cout<<"Introduce el numero que el jugador P(pensador)debe adivinar"<<endl;
   cin>>numeroaadivinar;
   cout << "Jugador P(pensador),piensa y di un numero ENTRE 1 Y"<<" "<<numeromaximo<<" para que jugador A (adivino)  lo adivine:" << endl;
   cin>>numero;
   if(numero>=1 || numero<=numeromaximo){
      cout<<"Correcto.Has dicho un numero entre 1 y "<<" "<<numeromaximo<<endl;
      if(numero==numeroaadivinar){
         cout<<"Has adivinado el numero.Es el numero:"<<" "<<numeroaadivinar<<endl;

      }
      else{
         cout<<"pero has introducido un numero fallido"<<endl;
      }
   }
   return 0;
}

Vale,gracias ya lo he probado.