Mensajes

si

[TODO]

Primer consejo al hacer templates... TODO y repito TODO el código de un template tiene que estar en el archivo de cabecera.

La razón es que el compilador utiliza este template para generar el código específico que necesite según se vaya usando en la aplicación.

Es decir, si tu en un programa usas la pila solo para tipos int, se creará código específico únicamente para el tipo int... si usas la pila para int, float y double... se creará una clase específica para cada uno de esos tres tipos.

El código de un template, como tal, no se compila directamente, se genera bajo demanda... el código en el cpp no sirve para nada.

Consejos:

* No uses variables globales... dificultan la lectura del código y pueden causar problemas.

* Las constantes, mejor en mayúsculas.

* Formatea el código en el foro ( el combo que dice GeSHi... elige c o cpp según proceda)

* Elige nombres para las variables que den una idea de cual es su función... para funciones for vale i,j,k... pero lo de auxi, auxj, mat es otro cantar.

* Deberías subdividir un poco más el código...

Dudas:

Que narices se supone que hace este código??

Código (c) [Seleccionar] Expandir


for(k=0;k<n;k++)
        {       auxi=rand()%n;
                auxj=rand()%n;

                if(k==0)
                        mat1[auxi][auxj]=1;
                else if(k==1)
                        mat1[auxi][auxj]=9;
                else if(k==2)
                {       mat1[auxi][auxj]=5;
                        mat1[auxi+1][auxj]=5;
                }
                else if(k==3)
                {       mat1[auxi][auxj]=5;
                        mat1[auxi+1][auxj]=5;
                        mat1[auxi+2][auxj]=5;
                }
         }

Si la idea es poner los obstáculos... que son dos, no entiendo la secuencia que pones ahí... para empezar tienes que poner dos obstáculos, luego el bucle debería ir de 0 a 1, no de 0 a 14... además estás obligando por fuerza a que los obstáculos estén en horizontal.

A ver, tu partes de una matriz de 15x15 en la que todos sus elementos, inicialmente, valen 0... quizás sería más sencillo que la matriz fuese de tipo char... para poder representar caracteres directamente. Así, por ejemplo:

* La matriz aparece inicializada al principio con caracteres de espacio ' '
* Los obstáculos se pueden representar con una 'O', de obstáculo, aunque puedes mirar entre los caracteres ASCII a ver si alguno de los disponibles te gusta más.
* La estela del robot la puedes marcar con una 'X'

Con esto, comprobar si el robot choca contra un obstáculo es tan sencillo como comprobar si las coordenadas a las que se va a mover el robot están etiquetadas con el carácter del obstáculo. Comprobar si el robot choca contra los muros es tan simple como comparar las coordenadas a las que se va a mover el robot con los límites de la matriz... si alguno de los valores es -1 o 15 te has chocado.

A la hora de imprimir la matriz te bastan con ir recorriendo la matriz e imprimir los caracteres que se encuentren en la coordenada correspondiente.

Aún así insisto, no has expuesto ninguna duda y no creo que nadie te vaya a resolver el ejercicio así por las buenas.

Me remito a las reglas del foro... en este foro no se hacen ejercicios... se ayuda en aquellas partes en las que te quedes atascado.

Hacer tareas desde cero es algo que cuesta dinero.

Un saludo.

jajajaja

lo se, lo que pasa es que yo creo que, por un lado, muchísima gente no lee las firmas si la respuesta no les interesa y, por otro lado, así queda más llamativo XD

Sugerencias:

* formatea el texto utilizando las etiquetas que están en el combo GeSHi... elige la opción c o c++ según proceda.

* en el caso de que una parte importante de los campos de una estructura recién creada con new deban ser null, es mejor usar calloc en vez de malloc... calloc inicializa la memoria a cero, con lo que hace parte del trabajo por tí.

* las indirecciones son peligrosas, si te las puedes ahorrar mejor. Me refiero por ejemplo al código siguiente:

Código (c) [Seleccionar] Expandir


void crear_lista(lista *l){
   l->first=(nodo *)malloc(sizeof(nodo));
   if (l->first == NULL){
      printf("Error!\n");
   }else{
      l->last=(nodo *)malloc(sizeof(nodo));
      if (l->last == NULL){
         printf("Error!\n");
      }else{
         l->first->next=l->last;
         l->last->prev=l->first;
         l->first->prev=NULL;
         l->last->next=NULL;
         l->pdi=l->last;
      }
   }

}

l->first->next ... al final este código acaba siendo poco legible y es fácil confundirse.

Queda más limpio si creas primero los nodos usando un puntero propio de nodo... le asignas los valores que procedan y después asocias los nodos a la lista:

Código (c) [Seleccionar] Expandir


void crear_lista(lista *l){
   nodo* first = (nodo*) calloc( 1, sizeof(nodo) );
   nodo* last = (nodo*) calloc(1, sizeof(nodo) );

   if ( first == NULL || last == NULL )
   {
     free( first ); // evitamos lagunas de memoria, tu codigo no controla esto
     free( last ); // evitamos lagunas de memoria, tu codigo no controla esto
     printf( "Error!\n" );
   }
   else
   {
     first->next = last;
     last->prev = first;

     l->first = first;
     l->last = last;
   }
}

Además imagino que la idea es que cada nodo tenga valor... si creas una lista de cero lo normal es que tenga un solo elemento, no dos... además de que deberías poder asignarle un valor a ese elemento:

Código (c) [Seleccionar] Expandir


void crear_lista(lista *l, int valor){
   nodo* first = (nodo*) calloc( 1, sizeof(nodo) );

   if ( first == NULL )
   {
     printf( "Error!\n" );
   }
   else
   {
     nodo->element = valor;
     l->first = first;
     l->last = first;
     l->pdi = first;
   }
}

* La variable pdi no entiendo muy bien cual es su uso... además me parece que sea cual sea su uso puede estar provocando errores:

Código (c) [Seleccionar] Expandir


void insertar_detras(lista *l, int element){
  // ...
   }else{
      temporal->element=element; //1. Asigna el elemento nuevo al temporal (nodo nuevo que hemos creado)
      temporal->next=l->pdi->next; //2. La casilla "next" del nodo temporal apunta al siguiente de la lista
      l->pdi->next=temporal;
      temporal->next->prev=temporal;
   }
}

En ese código no estás actualizando pdi, por ende siempre va a apuntar al primer elmento original, aunque deje de serlo en el futuro... la segunda vez que llames a esta función y sucesivas vas a estar creando una configuración un tanto extraña en tu lista...

Realmente yo creo que pdi no es necesario en absoluto. Tendría sentido si tuvieses que dejar seleccionado un nodo para que las operaciones de insertar delante e insertar detrás se aplicasen sobre el nodo seleccionado... pero para eso tendrías que tener una opción en el menú para seleccionar un elemento que a no ser que sea la 4ª... Voy a presuponer que es realmente así

Código (c) [Seleccionar] Expandir


void insertar_detras(lista *l, int element){
   nodo *temporal;
   temporal=(nodo *)malloc(sizeof(nodo));
   if (temporal == NULL)
   {
      printf("Error!\n");
   }else{
      nodo* previo = l->pdi->prev;
      nodo* siguiente = l->pdi;

      temporal->element=element; //1. Asigna el elemento nuevo al temporal (nodo nuevo que hemos creado)
      temporal->next=siguiente; //ERROR: no es pdi->next, es pdi, ya que vas a insertarlo detras de PDI, no delante
      temporal->prev=previo; // ERROR: no has hecho esta asignacion... luego la lista ya no va a tener valores consistentes

      if ( previo != NULL ) // Puede que el nuevo elemento pase a ser el primero de la lista
        previo->next = temporal; // Otra asignacion no realizada... mas inconsistencias en la lista.

      siguiente->prev = temporal; // Esta asignacion si la has hecho bien
   }
}

Lo siguiente, además, merece una atención aparte:

Código (c) [Seleccionar] Expandir


      temporal->next=l->pdi->next; //2. La casilla "next" del nodo temporal apunta al siguiente de la lista
      l->pdi->next=temporal;
      temporal->next->prev=temporal;


Pasos seguidos:

* temporal->next = pdi->next; --> Mal vamos si temporal tiene que ir antes de pdi lo lógico sería temporal->next = pdi
* l->pdi->next = temporal; --> Seguimos poniendo temporal después de pdi en vez de antes
* temporal->next->prev = temporal; --> O_o no esta mal del todo pero entenderás que la línea es fea de narices.
* YA?? y temporal->prev ?? no debería apuntar a l->pdi ?? aún así insisto en que con esto temporal acaba delante de pdi, no detrás.

Además como al crear los nodos nuevos no estás inicializando la memoria, si te dejas sin asociar algún puntero no te das cuenta porque tendrá valores, aunque sean extraños... con calloc esto no te pasaría.

* Realmente podrías unificar el proceso de inserción, de tal forma que añadir delante y añadir detrás podrían llamar a la misma función... ahorrarías código y quedaría un programa más limpio... pero eso ya te lo dejo a ti.

No se hacen tareas en este foro.

Ahora que por un módico precio te ayudo en lo que sea XD

es más cómodo que te mires la especificación de los correos electrónicos... que tampoco es tan complicada... y te curres un diseño en c++

puedes contactar conmigo por los mensajes privados del foro... suelo prestarles atención cuando veo que tengo sin leer.

En cuanto a los .vbs deberías asegurarte de que la máquina en la que lo vas a correr tiene no solo el intérprete instalado... también tienes que asegurarte de que tu script no lanza una alerta del firewall de windows o de la UAC de windows vista, 7 y 8

porque es un bucle do-while...

en un bucle do-while el contenido del bucle se ejecuta siempre al menos una vez. La razón es que la condición se evalúa al final de cada repetición del bucle.

Si quieres que la condición se ejecute al principio de cada iteración usa un bucle while a secas.

Código (c) [Seleccionar] Expandir


while(sigue==1)
{
  //...
}