Bueno la teoría era:
Diferencias entre compilación y linkeo

Después un verdadero y falso de punteros.
Preguntaba sobre fork
y había una mas que no entendí.


En la teórica básicamente era de listas (se podía elegir usar pila, cola, simple, doble, circular, etc), sockets (el servidor que recibia estructuras) y nada mas.

La idea era un programa inteligente(o algo asi) que recibia datos de un usuario (codigo, operacion y estado) era el codigo de un aparato, la operacion (no me acuerdo que era) y el estado si era prendido o apagado.
Lo importante era que recibias datos hasta que veía un FFFFFF (NULL) tenias que meterlo en una lista e ir imprimiendo cada vez que recibias un dato cuantos aparatos estaban encendidos y que codigo y operacion tenían.
Tenias que manejar otras dos listas dinámicas paralelas, la idea era que una la ordenabas por código y otra por llegada(operación).
Después tenias que borrar las listas antes de cerrar el programa y tenias que guardar en un archivo todas las cosas funcionando para poder operar mas tarde cuando se volvia a abrir el archivo.

Lo importante era que recibias una estructura de tres bloques y tenias que pasarlo a una nueva que era la que se usaba de nodo.

En si no era difícil, tenía cosas clásicas el final, lo IMPORTANTE era que el enunciado era MUY claro dentro de todo, no necesitaron ni explicarlo, era un final accesible si sabías socket y ordenar una lista.
El resto era sentarse y ser lo mas ordenado posible.

El final lo armo lage.

Mucha suerte, si hay algo que no se entiendan me preguntan cuanto antes y veo si me acuerdo como para ayudarlos!

PD: Aprobé ^^

---

anonimail

Fork? Wtf?

DESCRIPTION
fork() creates a new process by duplicating the calling process. The
new process, referred to as the child, is an exact duplicate of the
calling process, referred to as the parent, except for the following
points:


Es como el select... Yo ni idea, no la conteste, de todas formas con un teórico te aprobaban...
Yo hice 2 de 4 y me aprobaron re tranqui...
Si sabes bien la práctica la teoría te la ven así nomas(?)

Mal, yo las teoricas las contesté "con mis palabras" (obviamente utilizando vocabulario adecuado sin tirar fruta ni meterme en detalles muy específicos), eso sí, a la práctica con todo.

Si, igual estaba buena la fecha para presentarse, era largo pero tenia un enunciado RE lindo como deberían ser siempre jajaja...

El ultimo de teoría decía mas o menos:
Que formato representa un entero en la PC. Esta entre -65535 y 65535.

La verdad no tengo ni idea.

Y lo de la práctica tiene un misterioso parecido con este post:
http://www.utnianos.com.ar/foro/tema-seg...fo-i-final

JAJAJA es verdad, la única diferencia es que se pedía que tengas 2 listas ordenadas y imprimas cada vez que llegaba un dato una lista jaja.
Por mi parte lo resolví agregando a mi función de ordenar: If(tipo == 1) ordear por codigo; else ordenar por operacion...
y antes a eso hacia: lista_operacion = *lista , lista_codigo = *lista entonces mandaba una de las nuevas listas...
Y lista la use para: listar, imprimir y eliminar jaja.

Cursé con lage y mira mi segundo parcial jajaja es lo mismo casi!!! claramente lo hizo el al final que tipo pancho jaja
http://www.utnianos.com.ar/foro/tema-seg...#pid293372

Asi tendrian que ser los enunciados de todos los finales, los otros enunciados parecen una carrera de obstaculos.

Jajajaja, es que al final de cuentas lo importante es programar, en dos horas es imposible entender lo que te piden y programar -_-

De todas formas, tiempo dieron banda, cuando me fui todavía algunos estaban escribiendo xd

Feer, una pregunta del enunciado y otra sobre la corrección:

¿Cómo recibís el FFFFFF para terminar, de qué manera?
¿Son muy estrictos cuando te miran el código?

Si llegás a tener un "borrador" de cómo escribiste el fuente del programa, me vendría bárbaro para tener una idea de cómo es la onda

Gracias y espero tu respuesta!

Hola, yo interprete que la cadena se cortaba cuando mandaba un NULL , entonces hacía algo así:

 listen = Open_conection(&my_addr);

   if(listen == -1){

			puts("Error al abrir conexion");

         return(-1);

      }

   while(recibiendo){

      socket = Aceptar_pedidos(listen);

      while(continuar){

      	d_recibido = read(socket, nombre,sizeof(char)*50);

   		if(d_recibido>0){

      		strcpy(buffer.nombre,nombre);

         	buffer.prev = NULL;

            buffer.prox = NULL;

      		insertar_ordenado(&lista, &buffer);

   		}

   		else{

   			puts("Socket desconectado\n");

         	close(socket);

      		recibiendo = 0;

            continuar = 0;

   		}

      }

Pero con los datos del final, en la parte que hago el read, copiaba lo que venia en una estructura (le pregunte si podía hacer que los tres datos lleguen juntitos en una struct y me dijo que si) en otra estructura "NODO" y eso lo mandaba a una lista.
Luego hacía:

lista_orden_codigo = lista;
lista_orden_operacion = lista;

y después:

ordenar_lista(lista_orden_codigo,1) o ordenar_lista(lista_orden_operacion,0)
Adentro del ordenar tenia un if que comprobaba si era por codigo o operacion y iba a lo que correspondía.
Luego imprimia lista con: imprimir_lista(lista) donde era:

while(lista!=null)
if(lista->estado == funcionando)
imprimir...

Y después cuando dejaba de recibir hacía un: guardar_archivo(lista) y ahí nuevamente guardaba los que estaban funcionando...
Despues cerraba archivos, y wala!

El miércoles rindo info II y estoy bastante apretado de tiempos, pero el jueves me lo resuelvo entero, lo mejor posible y lo subo, si es que todavía te interesa...

[\h]

En cuanto a la correción, no se porque no vi ni el final corregido, ni cuando me lo corregían pero no tardaron mas de 10 minutos o 15.. ponele que fui al baño, me lave las manos volví, 5 minutos y me devolvieron el examen...
Me saqué 7 y me falto el teórico del fork y el teórico del numero que nunca entendí...
La práctica la tenía "bastante" clara y la resolví sin dudar, por lo que creo que estaba bastante bien.

Saludos!

Muchas gracias! Lo estuve viendo y me vino bien.

No te hagas drama, rendí tranquilo y si después tenés tiempo de ampliarlo un poco más, estaría joya!!! Veo que te lo tomaron con sockets... ¿No es así? El problema que tengo es que entiendo y manejo los conceptos, pero veo los finales que toman y a veces me marea lo que piden y no se por dónde encararlo

Suerte en Info II y contame cómo te fue!

Si yo tengo el mismo problema, me fui de casa esperando que me toqué para programar algo largo y difícil pero de enunciado fácil y me vino un enunciado largo pero que tenía bien especificado que había que resolver!
Y lo único poco entendible lo pregunte y los profesores lo contestaron con la mejor onda del mundo!!!

Dale gracias, el miércoles me paso por acá a comentar y si puedo ya me traigo alguna solución a este final

diegomsaiz

Me paso a proponer una solución...
La hice rápida por ahí tiene errores, pero queda como primera versión por si alguién la quiere como referencia...

 

/**

 * \brief Resolución del final 19/02/13.

 * \author Feer - utnianos.com.ar

 * \versión 1.0.1

 */



/********

INCLUDES

********/



#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "sock-lib.h"



/*******

DEFINES

*******/



#define ORDEN 1

#define CODIGO 1

#define ENCENDIDO 1



typedef struct dato_recibido{

	int codigo;

   int operacion;

   int estado;

}DATO_RECIBIDO;



typedef struct nuevo_nodo{

	int codigo;

   int operacion;

   int estado;

   struct nuevo_nodo *siguiente;

}NODO;





int agregar_principio(NODO **lista, NODO dato);

void imprimir_lista(NODO *lista);

void GuardarArchivo(NODO *lista);

int eliminar_lista(NODO **lista);







/**

 * \fn int main(void)

 * \brief Función principal del sistema.

 * \author Feer - utnianos.com.ar

 * \return 0 si salio todo bien.

 */



int main(void){



	NODO *lista = NULL;

   NODO buffer;

   int continuar;

   struct sockaddr_in my_addr;

   int recibiendo = 1;

   int d_recibido = 0;

	int listen; //El socket que escucha retorna de open_conection.

   int socket; //El socket del server que recibe los datos nuevos.

	DATO_RECIBIDO nuevo_dato;

   NODO nuevo_nodo;



   listen = Open_conection(&my_addr);

   if(listen == -1){

			puts("Error al abrir conexion");

         return(-1);

      }

   while(recibiendo){

      socket = Aceptar_pedidos(listen);

      while(continuar){

      	d_recibido = read(socket, nuevo_dato,sizeof(NODO));

   		if(d_recibido>0){



         /***************** GUARDO EN NODO LOS DATOS RECIBIDOS ***********/

         	nuevo_nodo.codigo = nuevo_dato.codigo;

            nuevo_nodo.operacion = nuevo_dato.operacion;

            nuevo_nodo.estado = nuevo_dato.estado;

            nuevo_nodo.siguiente = NULL;

            insertar_nodo(&lista, dato);

         	imprimir_lista(lista); //Imprime los que estan encendidos solamente.

            lista_codigo = lista;

            lista_orden  = lista;

            ordear_lista_orden(&lista_orden,ORDEN); //ORDEN DEFINE 1

            ordenar_lista_codigo(&lista_codigo,CODIGO); //CODIGO DEFINE 0

   		}

   		else{

   			puts("Socket desconectado\n");

         	close(socket);

      		recibiendo = 0;

            continuar = 0;

   		}

      }

   }

   guardar_datos(lista);

   elimiar_lista(&lista);

   close(listen);

   return(0);

}



/**

 * \fn int agregar_principio(NODO **lista, NODO dato)

 * \brief Inserta en una nueva lista el valor que voy recibiendo en los nodos.

 * \author Feer - utnianos.com.ar

 * \param **lista puntero a la lista que esta ordenada

 * \param NODO dato contenido contenido a agregar a la lista.

 * \return -1 si salio mal, 1 si salio bien.

 */



int agregar_principio(NODO **lista, NODO dato){



	NODO *nuevo_elemento; //En esta estructura guardo mi nuevo dato.

	

	nuevo_elemento = (NODO*) malloc (sizeof(NODO));

	if(nuevo_elemento == NULL){

		printf("Error en memoria");

		return(-1);

	}

   /************ LLENO ESTRUCTURA **************/

   

   nuevo_elemento->codigo = dato.codigo;

   nuevo_elemento->operacion = dato.operacion;

   nuevo_elemento->estado = dato.estado;

	nuevo_elemento->siguiente = NULL;



	if(*lista == NULL){ //Si no hay una lista todavia armada...



		*lista = nuevo_elemento;

		return(1);

	}else{  //Si hay lista creada.



		nuevo_elemento->siguiente = *lista;

		*lista = nuevo_elemento;

	}

	return(1);

}



/**

 * \fn int void imprimir_lista(NODO *lista)

 * \brief Imprime nodos en estado activo.

 * \author Feer - utnianos.com.ar

 * \param **lista puntero a la lista.

 */



void imprimir_lista(NODO *lista){



	if(lista == NULL){

		printf("No hay elementos en la lista\r\n");

	}

	else{

		do{

      	if(estado == ENCENDIDO){ //ENCENDIDO = 1 define.

				printf("Operacion: %d\tCodigo: %d\r\n",lista->operacion,lista->codigo);

         }

			lista = lista->siguiente;

		}while(lista != NULL);

	}

}



/**

 * \fn void GuardarArchivo(NODO *lista)

 * \brief Guarda en un archivo la lista para poder ser reutilizada.

 * \author Feer - utnianos.com.ar

 * \param *lista puntero a la lista.

 */



void GuardarArchivo(NODO *lista){



	FILE *fp;

	NODO nodo;

	NODO *aux = lista;



	fp = fopen(PATH_DATOS,"w+");

	if(fp == NULL){

		printf("%s",strerror(errno));

	}

	if((lista == NULL)){                   //Si la lista esta vacia.

		puts("No hay datos a almacenar");

		fclose(fp);                          //Cierro el archivo

		return;

	}

	while(aux != NULL){                  //Mientras hay nodos

         if(estado == ENCENDIDO){

         	fwrite(aux,sizeof(NODO),1,fp); //Guardo los nodos en el archivo.

         }

         aux = aux->siguiente;        //Paso al siguiente nodo

 	}

	fclose(fp);                            //Cierro el archivo.

}



/**

 * \fn int eliminar_lista(NODO **lista)

 * \brief Inserta en una nueva lista el valor que voy recibiendo en los nodos.

 * \author Feer - utnianos.com.ar

 * \param *lista puntero a la lista.

 * \return 0 si salio todo bien.

 */



int eliminar_lista(NODO **lista){



	NODO *aux,*aux_liberar;

	

	aux = *lista;

	if(aux == NULL){

		return(0);

	}

	do{

		aux_liberar = aux;

		aux = aux->siguiente;

		free(aux_liberar);

	}while(aux!=NULL);

	return(0);

}



/**

 * \fn void ordenar_lista(NODO **lista,int tipo_orden)

 * \brief Ordena la lista.

 * \author Feer - utnianos.com.ar

 * \param **lista puntero a lista a ordenar

 * \param tipo_orden orden de ordenamiento que quiero.

 */



void ordenar_lista(NODO **lista,int tipo_orden){



	NODO *listaordenada = NULL; //aca guardo la lista como la voy ordenando.

	NODO *aux;           //Este es para recorrer la lista y no perder la referencia.

	NODO buffer;       //contiene el valor que saco de la lista para ubicar en la nueva ordenada.



	aux = *lista;

	while(aux!=NULL){

		contenido = eliminar_primer_nodo(&aux);

      if(tipo_orden = ORDEN){

			insertar_ordenado_orden(&listaordenada, buffer);

      }

      else{

      	insertar_ordenado_codigo(&listaordenada, buffer);

	}

	*lista = listaordenada;



}



/**

 * \fn int insertar_ordenado_orden(DATO **listaordenada,NODO buffer)

 * \brief Inserta de forma ordenada los elementos por orden de llegada.

 * \author Feer - utnianos.com.ar

 * \param **listaordenada puntero a la lista que esta ordenada

 * \param buffer contenido a guardar en el nodo de la lista ordenada

 * \return -1 si salio mal, 1 si salio bien.

 */



int insertar_ordenado_orden(DATO **listaordenada,NODO buffer){



	NODO *nuevo_nodo = NULL;  //nodo para el nuevo dato.

	NODO *aux = NULL;         //para recorrer la lista sin perder la referencia de la lista.

	NODO *ant = NULL;         //para recorrer la lista y poder realizar el agregado de nodo.



	nuevo_nodo = (NODO *) malloc(sizeof(NODO));

	if(nuevo_nodo == NULL){

		printf("Error al pedir memoria");

		return(-1);

	}



	nuevo_nodo->valor = contenido;

	nuevo_nodo->siguiente = NULL;



	if(*listaordenada == NULL){  //Si todavia no ingrese ningun nodo..

		*listaordenada = nuevo_nodo;

		return(1);

	}

	else{  //Si ya habia ingresado nodos...

		aux = *listaordenada;



		while((aux != NULL)&&((aux->orden) < buffer.orden)){  //mientras contenido no supere al valor del nodo actual.

			ant = aux;

			aux = aux->siguiente;     //apunto al siguiente nodo.

		}



		if(ant == NULL){                     //Si se mete al principio de la lista.

			nuevo_nodo->siguiente = *listaordenada;

			*listaordenada = nuevo_nodo;

		}



		else{                               //Si se mete en el medio de la lista.

			ant->siguiente = nuevo_nodo;

			nuevo_nodo->siguiente = aux;

		}

		return(1);

	}

}



/**

 * \fn int insertar_ordenado_orden(DATO **listaordenada,NODO buffer)

 * \brief Inserta de forma ordenada los elementos por código.

 * \author Feer - utnianos.com.ar

 * \param **listaordenada puntero a la lista que esta ordenada

 * \param buffer contenido a guardar en el nodo de la lista ordenada

 * \return -1 si salio mal, 1 si salio bien.

 */



int insertar_ordenado_codigo(DATO **listaordenada,NODO buffer){



	NODO *nuevo_nodo = NULL;  //nodo para el nuevo dato.

	NODO *aux = NULL;         //para recorrer la lista sin perder la referencia de la lista.

	NODO *ant = NULL;         //para recorrer la lista y poder realizar el agregado de nodo.



	nuevo_nodo = (NODO *) malloc(sizeof(NODO));

	if(nuevo_nodo == NULL){

		printf("Error al pedir memoria");

		return(-1);

	}



	nuevo_nodo->valor = contenido;

	nuevo_nodo->siguiente = NULL;



	if(*listaordenada == NULL){  //Si todavia no ingrese ningun nodo..

		*listaordenada = nuevo_nodo;

		return(1);

	}

	else{  //Si ya habia ingresado nodos...

		aux = *listaordenada;



		while((aux != NULL)&&((aux->codigo) < buffer.codigo)){  //mientras contenido no supere al valor del nodo actual.

			ant = aux;

			aux = aux->siguiente;     //apunto al siguiente nodo.

		}



		if(ant == NULL){                     //Si se mete al principio de la lista.

			nuevo_nodo->siguiente = *listaordenada;

			*listaordenada = nuevo_nodo;

		}



		else{                               //Si se mete en el medio de la lista.

			ant->siguiente = nuevo_nodo;

			nuevo_nodo->siguiente = aux;

		}

		return(1);

	}

}



/**

 * \fn int eliminar_primer_nodo(DATO **aux)

 * \brief Elimina el primer elemento de la lista.

 * \author Feer - utnianos.com.ar

 * \param aux puntero al inicio de la lista a ordenar

 * \return Primer elmento de la lista.

 */



int eliminar_primer_nodo(DATO **aux){



	DATO *cambio_posicion = NULL; //para no tener problemas con el asterisco de aux.

	DATO *temp = NULL;            //para el free.

	NODO buffer;                  //contenido del nodo de lista.



	cambio_posicion = *aux;

	temp = *aux;

	buffer = cambio_posicion;

	*aux = cambio_posicion->siguiente;

	free(temp);

	return(buffer);

}

Saludos!