/
Inicio :: Foros

 F.A.Q.F.A.Q.                  Conéctese para revisar sus mensajesConéctese para revisar sus mensajes   

juzgar codigo

 
      Índice del Foro elrincondelc.com -> Principiantes C/C++
Ver tema anterior :: Ver siguiente tema  
AutorMensaje
polly



Registrado: 19 Jul 2007
Mensajes: 61

MensajePublicado: 08/09/2007 4:52 am
Título: juzgar codigo

buenas , cuelgo aqui mi codigo para que me den consejos , saber que cosas deberia mejorar en el o que cosas deberia evitar , es el juego de hunde la flota , se que ees muy sencillo , por otra parte llevare masomenos 1 mes con el leng de prog C ,

gracias





PD : no hay prisas XD
_________________
R.I.P Kurt Cobain
-------------------------
Volver arriba
rir3760



Registrado: 01 Oct 2004
Mensajes: 3657
Ubicación: Mexico

MensajePublicado: 08/09/2007 6:40 am
Título:

Tienes mas posibilidades de que alguien te ayude si colocas directamente el codigo fuente de tu program en lugar de utilizar un "servicio" como megaupload, en este momento al tratar de bajar el archivo aparece el (usual) mensaje:
Cita:
Unfortunately, all available bandwidth is currently reserved for our premium customers. Therefore, free downloads will be unavailable for the next 8 hours.

We're working on adding more capacity for free users and would like to apologize for the inconvenience.

Your Megaupload Team


Un saludo
_________________
The capacity to learn is a gift;
The ability to learn is a skill;
The willingness to learn is a choice.
--
Rebec of Ginaz
Volver arriba
polly



Registrado: 19 Jul 2007
Mensajes: 61

MensajePublicado: 08/09/2007 6:57 am
Título:

ok ,

Código:

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define N 6
#define M 6

//   JUEGO DE LOS BARCOS
//   JUEGO POR TURNOS
//  basado en 2 tablas (6x6)
//  los barcos se marcaran en la tabla con 'B'
//  los puntos restantes se marcaran con '.'
//  si se acierta , mostrar por pantalla y cubrir el barco con 'X'
//  si no se acierta , dejar paso a la maquina
//  el juego acaba cuando se hayan hundido los barcos del contrario   

// LAS COORDENADAS SE INTRODUCEN ASI: 1 2   


int**gen_tabla_pc(int**tabla_pc,int**tabla_copia,int*numero);
int**gen_tabla_jugador(int**tabla_jugador);
void mostrar(int**tabla_pc,int barks,int**tabla_copia,int**tabla_jugador,int aux,int numero);
void mostrar2(int**tabla_jugador);
void interfaz(int**tabla_pc,int**tabla_jugador,int**,int*,int aux,int numero);
void IA(int**tabla_pc,int**tabla_jugador,int,int**,int*aux,int numero);
void detecta(int**,int,int**,int,int numero,int**tabla_pc);


int main()
{
   int numero=0;
   int aux=0;
   int**tabla_copia;
   int**tabla_pc;         // TABLA DE BARCOS DEL PC
   int**tabla_1;         
   int**tabla_2;         // TABLA DE BARCOS DEL JUGADOR
   int**tabla_jugador;
   int i,j,k;
   int barks=0; // NUMERO DE BARCOS
   srand(time(NULL));
   tabla_copia=(int**)malloc(N*sizeof(int*));
   for(i=0;i<N;i++)
      tabla_copia[i]=(int*)malloc(N*sizeof(int));
   for(j=0;j<N;j++)
      for(k=0;k<M;k++)
         tabla_copia[j][k]=0;

   tabla_pc=gen_tabla_pc(tabla_1,tabla_copia,&numero);     //tabla generada (oculta) para el pc
   tabla_jugador=gen_tabla_jugador(tabla_2);           //MI TABLA
   
   
   mostrar(tabla_pc,barks,tabla_copia,tabla_jugador,aux,numero);
   printf("\n\n==============================================\n\n");
   mostrar2(tabla_jugador);
   
   interfaz(tabla_pc,tabla_jugador,tabla_copia,&barks,aux,numero);
         return 0;
}



int** gen_tabla_pc(int**tabla_1,int**tabla_copia,int*numero)
{
   int i;
   int j,k;
   int number=0;
   
   tabla_1=(int**)malloc(N*sizeof(int*));
   for(i=0;i<N;i++)
      tabla_1[i]=(int*)malloc(N*sizeof(int));
   for(j=0;j<N;j++)
      for(k=0;k<M;k++)
         tabla_1[j][k]=tabla_copia[j][k]=rand()%5;   //COPIA DE TABLA_1
   
   int l,o;
   for(l=0;l<N;l++)
      for(o=0;o<M;o++)
      {   
         if(tabla_1[l][o]==1)
        number++;         
         tabla_1[l][o]='.';
      }
   *numero=number;
 
         printf("\t\tNumero de barcos del pc: %d\n\n",number); 
 
   return tabla_1;
}

void mostrar(int**tabla_pc,int barks,int**tabla_copia,int**tabla_jugador,int aux,int numero)
{
   int i,j;
   int a,b;
   printf("\t\tBARCOS ENEMIGOS\n\n");
   detecta(tabla_copia,barks,tabla_jugador,aux,numero,tabla_pc);
   for(i=0;i<N;i++)
      for(j=0;j<M;j++)
            printf("   %c %s",tabla_pc[i][j],(j==N-1?"\n":"   "));
   
}

void mostrar2(int**tabla_jugador)
{
   int i,j;
   printf("\t\tBARCOS ALIADOS\n\n");
   for(i=0;i<N;i++)
      for(j=0;j<M;j++)
         printf("   %c %s",tabla_jugador[i][j],(j==N-1?"\n":"   "));
}

int**gen_tabla_jugador(int**tabla_2)
{
   int b;
   int l;
   int h;
   int coor1,coor2;   
   int i;
   int j,k;
   tabla_2=(int**)malloc(N*sizeof(int*));
   for(i=0;i<N;i++)
      tabla_2[i]=(int*)malloc(N*sizeof(int));
   for(j=0;j<N;j++)
      for(k=0;k<M;k++)
         tabla_2[j][k]=rand()%5;
   int z,x;
   for(z=0;z<N;z++)
      for(x=0;x<M;x++)
         tabla_2[z][x]='.';
   
   printf("\t\tCuantos barcos:");
   scanf("%d",&b);
   for(l=1;l<=b;l++)
   {
      printf("Introduce las coordenadas del %d barco: ",l);
      scanf("%d  %d",&coor1,&coor2);
      tabla_2[coor1][coor2]='B';
     
   }
   
   return tabla_2;
}

void interfaz(int**tabla_pc,int**tabla_jugador,int**tabla_copia,int*barks,int aux,int numero)
{
   int coor1,coor2;
   int i,j;
   int sig;
   int temporal2;
   do{
   printf("Introduce coordenadas: ");
   scanf("%d %d",&coor1,&coor2);
   if( tabla_copia[coor1][coor2]==1)
   {   sig=1;
   temporal2=1;
   }
   else
      sig=0;
   
   *barks=temporal2;

   if (sig==1)
   {
      tabla_pc[coor1][coor2]='X';
      system("clear");
      mostrar(tabla_pc,temporal2,tabla_copia,tabla_jugador,aux,numero);
   detecta(tabla_copia,*barks,tabla_jugador,aux,numero,tabla_pc);

      printf("\n\n=================================================\n\n");
      printf("HAS ACERTADO, CONTINUA\n");
      printf("\n\n=================================================\n\n");
      mostrar2(tabla_jugador);
   }

   else if(sig==0)
   {
      system("clear");
      mostrar(tabla_pc,temporal2,tabla_copia,tabla_jugador,aux,numero);
//detecta(tabla_copia,*barks,tabla_jugador,aux,numero,tabla_pc);

      printf("\n\n=================================================\n\n");
      printf("HAS FALLADO ,TURNO DEL ORDENADOR\n");
      printf("\n\n=================================================\n\n");
      mostrar2(tabla_jugador);
      IA(tabla_pc,tabla_jugador,temporal2,tabla_copia,&aux,numero);
   }
   }while(sig==1);
}


void IA(int**tabla_pc,int**tabla_jugador,int barks,int**tabla_copia,int*aux,int numero)
{
   int i,j;
   int sig;
   int alea1,alea2;
   int temporal;
   srand(time(NULL));
   
   alea1=rand()%5;     //  COORDENADA X ALEATORIA
   alea2=rand()%5;     // COORDENADA Y ALEATORIA
   printf("\t\t TURNO DEL ORDENADOR\n\n");
   system("sleep 1.2");
   for(i=0;i<N;i++)
      for(j=0;j<M;j++)
      {   if (tabla_jugador[alea1][alea2]=='B')
         {
                  sig=1;
                  *aux=1;
         }
         else
            sig=0;
      }
   *aux=temporal;
   if (sig==1)
   {   
     
      tabla_jugador[alea1][alea2]='X';
      system("clear");
      mostrar(tabla_pc,barks,tabla_copia,tabla_jugador,temporal,numero);
      printf("\n\n=================================================\n\n");
      printf("EL PC HA ACERTADO\n");
      printf("\n\n=================================================\n\n");
      mostrar2(tabla_jugador);
      system("sleep 1.2");
      IA(tabla_pc,tabla_jugador,barks,tabla_copia,&temporal,numero);
   }
   
   else if  (sig==0)
   {
      system("clear");
      mostrar(tabla_pc,barks,tabla_copia,tabla_jugador,temporal,numero);
      printf("\n\n=================================================\n\n");
      printf("EL PC HA FALLADO, TU TURNO\n");
      printf("\n\n=================================================\n\n");
      mostrar2(tabla_jugador);
      interfaz(tabla_pc,tabla_jugador,tabla_copia,&barks,temporal,numero);

   }
}


void detecta(int**tabla_copia,int barks,int**tabla_jugador,int aux,int numero,int**tabla_pc)
{
   int i,j;
   int num=0;
   int total=0;
   for(i=0;i<N;i++)
      for(j=0;j<M;j++)
         if( tabla_pc[i][j]=='X')
            num++;
      
   total=numero-num;
   //printf("\n\t\tNumero de barcoos: %d-%d=%d\n",numero,num,total);
   printf("\n\t\tNumero de barcos: %d\n",total);

   if(total==0)
   {
      printf("\t\tHAS GANADO\n\n");
      exit(-1);
   }

   int a,b;
   int num2=0;
   for(a=0;a<N;a++)
      for(b=0;b<M;b++)
         if (tabla_jugador[a][b]=='B')
            num2++;
   if(aux==1)
      num2--;
   
   if(num2==0)
   {
      printf("\t\tHA GANADO EL PC\n\n");
      exit(-1);
   }
   

}




_________________
R.I.P Kurt Cobain
-------------------------
Volver arriba
rir3760



Registrado: 01 Oct 2004
Mensajes: 3657
Ubicación: Mexico

MensajePublicado: 08/09/2007 8:53 am
Título:

Algunos comentarios sobre tu programa:

* Si bien "int main()" es correcto se prefiere la forma "int main(void)" ya que es mas explicita, por la misma razon para terminar el programa por una salida con exito se prefiere "return EXIT_SUCCESS;".

* En C no es necesario la conversion explicita o casting cuando se llama a las funciones malloc/calloc/realloc o cualquier otra que retorne un valor de tipo "void *".

En el caso particular de malloc el idioma o convencion informal es:
Código:
p = malloc(N * sizeof *p);

Donde p es el puntero donde guardaremos la direccion en memoria del bloque reservado por la funcion y N es el numero de elementos en el bloque.

Tomando el primer uso de malloc en tu programa:
Código:
tabla_copia = (int**)malloc(N * sizeof(int*));

Seria mejor cambiarlo a:
Código:
tabla_copia = malloc(N * sizeof *tabla_copia);


* En tu programa falta la validacion en caso de errores, por ejemplo en las llamadas a malloc no verificas si el valor devuelto es NULL, esto significaria un error critico y deberias modificar tu programa para que este "termine graciosamente" en caso de un error como el mencionado.

* En la funcion gen_tabla_jugador:
Código:
for (j = 0; j < N; j++)
   for (k = 0; k < M; k++)
      tabla_2[j][k] = rand() % 5;

int z, x;
for (z = 0; z < N; z++)
   for (x = 0; x < M; x++)
      tabla_2[z][x] = '.';

El primer par de bucles asigna un valor aleatorio pero el segundo asigna el valor '.' a todos los elementos, en otras palabras el primer par de bucles es superfluo y deberias eliminarlo.

* En la funcion "mostrar" declaras la variables "a" y "b" pero no las utilizas y por lo mismo seria mejor eliminarlas.

* En la funcion "gen_tabla_jugador" declara la variable "h" pero no la utilizas y por lo mismo seria mejor eliminarla.

* En la funcion "interfaz" declaras la variables "i" y "j" pero no las utilizas y por lo mismo seria mejor eliminarlas.

Un saludo
_________________
The capacity to learn is a gift;
The ability to learn is a skill;
The willingness to learn is a choice.
--
Rebec of Ginaz
Volver arriba
cheroky



Registrado: 22 Sep 2005
Mensajes: 1372
Ubicación: En ecx esperando un call

MensajePublicado: 08/09/2007 11:22 am
Título:

Tampoco liberas la memoria asignada mediante free.

Bien prodrias usar arrays estaticos y/o/u automaticos.

En estas rutinas de la funcion gen_tabla_pc

Código:
int** gen_tabla_pc(int**tabla_1,int**tabla_copia,int*numero)
{
/*      */
   int number=0;
/*     */
 number++;         
         tabla_1[l][o]='.'; 
      }
   *numero=number;
 
         printf("\t\tNumero de barcos del pc: %d\n\n",number); 
 /*     */

usas number como variable de paso, siendo innecesario, nada impide que uses le puntero directamente.
Código:
int** gen_tabla_pc(int**tabla_1,int**tabla_copia,int*numero)
{
/*     */
   
  *numero = 0;

/*     */
 
  *numero++;         
         tabla_1[l][o]='.'; 
      }
 
 
         printf("\t\tNumero de barcos del pc: %d\n\n",*numero); 
 /*     */


En otro orden de cosas, personalmente prefiero que la salidas de consola (printf, puts y mensajes) se gestionen fuera de las funciones que procesan el programa, si bien requiere mas codigo, el maintaner o update es mucho mas comodo. Si determinada funcion recrea un algoritmo generico y vas a reutilizar ese codigo, los "rotulos de consola" que tuviera son muy antiesteticos. Implementa la interfaz del juego lo mas encapsulada que puedas.


S2.
_________________
- Explícito es mejor que implícito.
- Simple es mejor que complejo.
- Complejo es mejor que complicado.
- Plano es mejor que anidado.
- Ralo es mejor que denso.
Volver arriba
polly



Registrado: 19 Jul 2007
Mensajes: 61

MensajePublicado: 09/09/2007 2:01 am
Título:

gracias a todos , tomare en cuenta las correciones
_________________
R.I.P Kurt Cobain
-------------------------
Volver arriba
      Índice del Foro elrincondelc.com -> Principiantes C/C++
Página 1 de 1Todas las horas están en GMT - 8 Horas

 
No puede crear mensajes
No puede responder temas
No puede editar sus mensajes
No puede borrar sus mensajes
No puede votar en encuestas

(c) ElRincondelC.com

Un proyecto de UrlanHeat.com