Mensajes

tienes que capturar un string y luego intentar convertirlo a int... si la conversión no es satisfactoria muestras un mensaje de error y repites el proceso.

Simplemente la use para saber si cuando el objeto se mueva a la posicion siguiente no haya obstaculo '#' o no esté ya su simbolo (indicando que ya paso por alli), pero como dije, los problemas de recursividad me cuestan pensarlos.

Pero te das cuenta de que así impides que tu algoritmo pueda dar la vuelta tras meterse por el pasillo equivocado, no?

Código [Seleccionar] Expandir


0123456789
##########
      XXX#
##########

Si tu algoritmo empieza en la posición 6 y tira hacia la derecha... llega a 8 y jaque mate, no tiene salida... a no ser que pueda dar la vuelta.

Código (cpp) [Seleccionar] Expandir


using namespace std;

typedef struct
{
    int estaEnInicio, estaEnFinal; //----- Para saber cuantas veces nuestro objeto ha estado en el inicio y si esta en el final
    char simbolo;
    int pos_x; //------------------------- Coordenada del objeto en X
    int pos_y; //------------------------- Coordenada del objeto en Y
}Objeto;

C++ y C en el mismo código ??? Entiendo que al final te has decantado por C porque no hay includes de C++, en tal caso deberías quitar el using namespace.

Si quieres usar C++ has de saber que el typedef no es necesario en este caso, las estructuras en C++ se usan igual que las clases ( es decir, sin poner el struct ) y sin necesidad de typedefs.

Otra cosa, la función recorrerLaberinto es un poco infernal, no?? usas recurrencia y un while a la vez... hay que tener bastante cuidado con esas cosas porque se puede pasar de vueltas la función. Sinceramente no creo que sea necesario para este caso que la función sea recursiva. Con un while ( !salida_encontrada ) { codigo } puedes resolver el ejercicio.

El problema de la recurrencia es que para determinados laberintos te puedes encontrar con que el número de pasos necesarios para salir desde una posición determinada sea superior al tamaño de la pila... en cuyo caso vas a tener un casque.

Otra cosilla. En el siguiente código:

Código (c) [Seleccionar] Expandir

if( laberinto[obj->pos_x][obj->pos_y + 1] != '#' && laberinto[obj->pos_x][obj->pos_y + 1] != obj->simbolo )

Se supone que "simbolo" es el caracter que representa tu posición actual, no? en ese caso... ¿Cómo es posible que puedas estar en obj->pos_y y en obj->pos_y+1 a la vez?

Y para terminar:

Código (c) [Seleccionar] Expandir

    if( obj->estaEnInicio > 1 )
        printf("\n\n\nNo hay salida en este laberinto.");

No creo que esta sea el chequeo correcto. Habría que tener en cuenta también la dirección en la que te estás moviendo... tu ponte que inicias el algoritmo en un cruce de caminos y se dirige primero hacia un pasillo cerrado... al volver a pasar por el cruce dirás, erroneamente, que no tiene salida.

* Si usas C++ no pongas includes de C ( los que acaban en .h) y más aún si estos includes no son necesarios.

* Deberías utilizar el mismo tipo de dato en las diferentes matrices:

Código (cpp) [Seleccionar] Expandir


void REDIMENCIONAR_f(int MDlistripR[3][100])
{
    int k;
    float aux[3][100];
    for (k=0;k<=(MDlistripR[0][2]+1);k++)
    {
        aux[k][0]=MDlistripR[k][0];
        aux[k][1]=MDlistripR[k][1];
        aux[k][2]=MDlistripR[k][2];
    }
}

Ahí recibes una matriz de tipo int y la copias en... una matriz de tipo float?? además, aux se pierde una vez sales de la función. Esta función por ejemplo no hace nada productivo.

* La definición de matriz es valores=cifras*columnas. Dicho esto, no tiene ningún sentido el tratamiento que le das en partes del código como:

Código (cpp) [Seleccionar] Expandir


   cout<<"\nIngrese numero de Filas";
   cin>>NF;
   cout<<"\nIngrese numero de Columnas";
   cin>>NC;
   cout<<"\nIngrese numero de Datos";
   cin>>ND;

o:

Código (cpp) [Seleccionar] Expandir


for(i=1;i<=MDlistrip[0][3]+1;i++)
    {
           cout<<"\nIngrese Filas";
           cin>>MDlistrip[i][0];
           cout<<"\nIngrese Columnas";
           cin>>MDlistrip[i][1];
           cout<<"\nIngrese Dato";
           cin>>MDlistrip[i][2];  
    }

Si tu programa maneja dos matrices deberías diseñar una estructura que gestione la matriz y utilizarla para manejar las dos matrices. No se, algo tal que:

Código (cpp) [Seleccionar] Expandir


struct Matriz
{
 int filas;
 int columnas;
 int* datos;
};

// Sin memoria dinámica
struct Matriz2
{
 int filas;
 int columnas;
 int datos[MAX_FILAS][MAX_COLUMNAS];


O, si quieres aprovechar un poco las capacidades de programación orientada a objetos:

Código (cpp) [Seleccionar] Expandir


class Matriz
{
 public:
   Matriz( int filas, int columnas );

   ~Matriz( );

   void SetDato( int fila, int columna, int dato );

   int Dato( int fila, int columna ) const;

   int Filas( ) const;

   int Columnas( ) const;

 private:

   int _filas;
   int _columnas;

   // Esta se puede sustituir por una matriz fija para evitar el uso de memoria dinamica
   int* _datos;
};

Tú estás creando una matriz de una forma muy extraña que no te garantiza celdas duplicadas o inexistentes y que, además, no te permite trabajar con dos matrices para hacer las operaciones básicas.

En serio, no termino de entender por qué generas una terna( fila, columna, dato ). ¿Qué sucede si el usuario repite los valores de fila y columna? ¿Y si hay una dupla fila-columna que se olvida de indicar? ¿Y si tengo, por ejemplo, una matriz de 2x2 e intento rellenar un dato de la fila 4, columna 20? ¿Y si indico una fila / columna negativa?

El modelo que propones es demasiado propenso a errores y es bastante complejo de gestionar y de usar. Hay formas mucho más sencillas:

Código (cpp) [Seleccionar] Expandir


#include <iostream>

#define MAX_FILAS 20
#define MAX_COLUMNAS 20

struct Matriz
{
 int filas;
 int columnas;
 int datos[MAX_FILAS][MAX_COLUMNAS];

 Matriz( ) : filas( 0 ), columnas( 0 )
 { }
};

Matriz Sumar( const Matriz& matriz1, const Matriz& matriz2 )
{
 Matriz resultado;

 if ( matriz1.filas == matriz2.filas && matriz1.columnas == matriz2.columnas )
 {
   resultado.filas = matriz1.filas;
   resultado.columnas = matriz1.columnas;

   for ( int i=0; i<resultado.filas; i++ )
   {
     for ( int j=0; j<resultado.columnas; j++ )
       resultado.datos[ i ][ j ] = matriz1.datos[ i ][ j ] + matriz2.datos[ i ][ j ];
   }
 }

 return resultado;
}

void Imprimir( const Matriz& matriz )
{
 for ( int i = 0; i < matriz.filas; i++ )
 {
   for ( int j = 0; j < matriz.columnas; j++ )
     std::cout << matriz.datos[ i ][ j ] << " ";

   std::cout << std::endl;
 }
}

int main( )
{
 Matriz matriz1, matriz2;

 matriz1.filas = 2;
 matriz1.columnas = 2;

 for ( int i=0; i<matriz1.filas; i++ )
 {
   for ( int j=0; j<matriz1.columnas; j++ )
     matriz1.datos[ i ][ j ] = j - i;
 }

 matriz2.filas = 2;
 matriz2.columnas = 2;
 for ( int i=0; i<matriz1.filas; i++ )
 {
   for ( int j=0; j<matriz2.columnas; j++ )
     matriz2.datos[ i ][ j ] = 2* i + j;
 }

 // Sumamos las matrices
 if ( matriz1.filas == matriz2.filas && matriz1.columnas == matriz2.columnas )
 {
   Matriz resultado;
   resultado.filas = matriz1.filas;
   resultado.columnas = matriz1.columnas;

   for ( int i=0; i<resultado.filas; i++ )
   {
     for ( int j=0; j<resultado.columnas; j++ )
       resultado.datos[ i ][ j ] = matriz1.datos[ i ][ j ] + matriz2.datos[ i ][ j ];
   }
 }

 Matriz resultado = Sumar( matriz1, matriz2 );

 std::cout << "Matriz1:" << std::endl;
 Imprimir( matriz1 );

 std::cout << "Matriz2:" << std::endl;
 Imprimir( matriz2 );

 std::cout << "Resultado:" << std::endl;
 Imprimir( resultado );
 return 0;
}

Aún así, insisto, queda mejor con clases que con estructuras... pero creo que es preferible que te manches un poco las manos y no dártelo todo hecho

El código francamente es mejorable:

* En C++ se suele emplear const en vez de defines

* Deberías tabular el código para hacerlo legible.

* La clase víbora no debería encargarse de cosas que no dependiesen de la propia vibora, como "generar la comida"

* Ya que usas coordenadas, ¿qué tal usar una clase para encapsular las coordenadas?

* ¿Por qué usas malloc en vez de new?

* ¿Y los correspondientes free?

* La interfaz del usuario debería ser independiente del código del juego.

Código (cpp) [Seleccionar] Expandir



class Punto
{
 public:
   Punto( int x, int y );

   int X( ) const;
   int Y( ) const;

 private:
   int _x;
   int _y;
};

class Tamano
{
 public:
   Tamano( int ancho, int alto );

   int Ancho( ) const;
   int Alto( ) const;

 private:

   int _alto;
   int _alto;
}

class Rectangulo
{
 public:
   Rectangulo( const Punto& punto, const Tamano& tamano );

   Punto EsqSupIzq( ) const;
   Punto EsqSupDer( ) const;
   Punto EsqInfIzq( ) const;
   Punto EsqInfDer( ) const;

   Tamano Tamano( ) const;

   // Verifica si el punto se encuentra dentro del rectangulo o no
   bool EstaDentro( const Punto& punto );

 private:

   Punto _origen;
   Tamano _tamano;
};

class Vibora
{
 public:
   enum Direccion
   {
     Arriba, Abajo, Derecha, Izquierda
   };

   Vibora( const Punto& inicio, Direccion direccion );

   // Obtiene las coordenadas del cuerpo de la serpiente... la primera coordenada es la cabeza
   std::vector< Punto > Cuerpo( ) const;

   // Permite cambiar la direccion en la que se mueve la serpiente
   void SetDireccion( Direccion direccion );

   // Mueve la serpiente en la direccion establecida
   void Mover( );

   // Se llama cuando la serpiente come una fruta, hace que su tamaño crezca
   void Comer( );

 private:

   std::vector< Punto > _cuerpo;
   Direccion _direccion;
};

class Juego
{
 public:
 
   // El parametro indica el tamaño del tablero de juego
   Juego( Tamano tamano, int nivel );

   // Inicia el algoritmo de juego
   void Jugar( );

 private:

   // Posicion de la comida ( si no se admite mas de una por vez se puede quitar el vector )
   std::vector< Point > _comida;

   // Serpiente del juego
   Serpiente _serpiente;

   // Tamaño del tablero de juego
   Tamano _tablero;

   // Para controlar la velocidad de juego
   int _nivel;

   // Comprueba si el usuario ha pulsado una tecla para cambiar de direccion
   void ComprobarTecla( );

   // Pinta el tablero de juego
   void PintarTablero( );

   // Pinta la serpiente
   void PintarSerpiente( );

   // Coloca una nueva pieza de comida
   void CrearComida( );
};

El diseño que te presento tiene una estructura más definida y organizada, además permite reutilizar código.

Te están pidiendo, simplemente, que generes matrices aleatorias de 21x21 con 0 y 1.

los 0 los representas con huecos y los 1 con asteriscos.

* Tienes que pedir un número al usuario
* Ese numero se lo pasas a una funcion llamada funcioRe que tienes que implementar con las siguientes reglas:
    1. Si n es 1, entonces escribes el valor de n  (es decir, 1 ) por pantalla y haces que la función retorne 1
    2. Si n es par, escribes el valor de n, calculas la mitad de n y llamas a funcioRe con el valor calculado.
    3. Si n no es par y no es 1, calculas 3n+1 y llamas a funcioRe con el valor calculado.
    4. Dado que lo que se quiere es contar el número de saltos, en los casos 2 y 3 habrá que hacer retornar el valor devuelto por la llamada a funcioRe más uno.
* Una vez el codigo vuelve al main tienes que imprimir el número total de llamadas recursivas que ha habido.

Si lo que quiere es código... antes tienes que hacer un aporte que demuestre un mínimo de trabajo.

El caso es que aquí se resuelven dudas donde te hayas atascado... no se hacen trabajos.

El script es bastante tonto y se pueden encontrar todo dedicando 5 minutos en google.

En cualquier caso, deberías plantearte aprender programación Web, ya que no tiene sentido que dediques tiempo a crear cosas que ni entiendes ni sabes como mantener.

yo de hecho no me había topado nunca con esa sintaxis. si cuando digo que programar es un arte en el que no se deja de aprender...

En efecto, pero eso es en C.

Exacto. No puedes pretender crear un fichero con ofstream y escribir su contenido con fwrite.