/*
6x02-Lista_enlazadas_desordenadas
01/02/2012

Repite el ejercicio anterior usando una lista (no ordenada), que implemente una operación de ordenarLista.
Se almacenarán los números desordenados en la lista y luego se aplicará la operación implementada.
*/

// Estructuras de datos:
struct SORTEO
{
	int numero;		// Numero de boleto
	int cuantia;	// Importe del premio
};
struct NODO
{
	struct SORTEO elemento;	// Información contenida en cada nodo de la lista.
	struct NODO *puntero;	// Puntero al siguiente nodo de la lista.
};

// Constantes:
#define NUMEROS 10

// Librerias:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
//#include "listas.h"

// FUNCION QUE INSERTA NODOS AL FINAL DE LA LISTA:
void listaInsertAlFinal( struct NODO **lista, struct SORTEO *cupon )
{
	/*
	Precondición:
					Se ha de recibir un puntero de tipo struct NODO al primer nodo de la lista. Este podrá valer NULL la primera vez o la dirección de memoria que corresponda.
					  El puntero además es un "doble puntero" ya que es necesario poder modificarlo.
					También se ha de recibir un puntero a una estructura de tipo SORTEO con la información a insertar en la lista.
	Poscondición:
					Se inserta la información contenida en "cupon" en un Nodo nuevo perteneciente a "lista", la inserción se realiza siempre al final de la lista.
	*/

	struct NODO *temp 		= (struct NODO *)malloc(sizeof(struct NODO));	// Se define un puntero temporal de tipo NODO que apunta a la memoria solicitada al sistema.
	struct NODO *anterior 	= NULL;											// Se crea otro puntero de tipo NODO, este apuntando a NULL
	struct NODO *siguiente 	= *lista;										// Y un tercer puntero de tipo NODO que apunta al primer nodo de la lista.

	// En la primera inserción "lista" no apuntara a nada, por lo que se inserta el primer nodo y se hace que "lista" apunte a él.
	if( *lista == NULL )
	{
		temp->elemento	= *cupon;
		temp->puntero	= NULL;

		*lista = temp;
	}
	  // Cuando la lista ya tenga un elemento...
	else
	{

		// Se recorren todos los Nodos de la lista hasta llegar al final.
		while( siguiente != NULL )
		{
			anterior = siguiente;
			siguiente = siguiente->puntero;
		};

		// Se agrega el nuevo Nodo al final de la lista.
		if( siguiente == NULL )
		{
			temp->elemento	= *cupon;	// Se guarda la estructura de datos (cupon) en la estructura del nuevo Nodo.
			temp->puntero	= NULL;		// Como la inserción es al final de la lista el puntero del Nodo no a puntara a ningún otro Nodo.

			anterior->puntero = temp;	// Se modifica el puntero del Nodo anterior para que apunte al nuevo Nodo.
		};

	};

};

// FUNCION QUE ORDENA LOS NODOS DE UNA LISTA DE FORMA ASCENDENTE:
void listaOrdenarAscendente( struct NODO **lista )
{
	/*
	Precondición:
					Se ha de recibir un puntero de tipo struct NODO al primer nodo de la lista. Este podrá valer NULL la primera vez o la dirección de memoria que corresponda.
	Poscondición:
					La función se encarga de ordenar de forma ascendente cada Nodo de la lista según el numero de cupón que contengan dichos nodos.
					El método usado para ordenar los nodos es mediante el método de la burbuja, de modo que se necesitan dos bucles,
					  el segundo se encarga de ordenar el nodoA y el nodoB en la primera iteración, después el nodoB y el nodoC en la segunda iteración, luego el nodoC y el nodoD, etc.
					  de modo que se van arrastrando los números pequeños hacia el principio de la lista, una vez recorrida entera el segundo bucle se encarga de recorrerla de nuevo, así tantas veces como nodos tiene la lista.
					Finalmente la lista queda ordenada completamente.
					Esquema gráfico: http://goo.gl/I54uV
	*/

	struct NODO *p_nodoAnt2_nodoAnt1	= NULL;							// Es(sera) el puntero del puntero que apunta al nodoA (es necesario para modificar el puntero que apunta a A)
	struct NODO *p_nodoAnt1_nodoA		= *lista;						// Es el puntero que apunta al nodoA
	struct NODO *p_nodoA_nodoB			= p_nodoAnt1_nodoA->puntero;	// Es el puntero del nodoA y apunta al nodoB
	struct NODO *p_nodoB_sig			= p_nodoA_nodoB->puntero;		// Es el puntero del nodoB que apunta al siguiente nodo.

	struct NODO *temporal				= NULL;							// Puntero temporal de intercambio.
	struct NODO *iteracion				= *lista;						// Es el puntero que va avanzando en la lista en cada iteración del primer bucle, es necesario para saber cuando detener el bucle.

	int salirBucle1; // Variables "booleanas" para indicar cuando se ha de salir de los bucles.
	int salirBucle2;

	// Si la lista contiene Nodos se ordenan:
	if( *lista != NULL )
	{

		salirBucle1 = 0;

		// La lista se ha de recorrer tantas veces como Nodos tenga:
		while( !salirBucle1 )
		{

			// Si "iteracion" es NULL se cambia el estado de "salirBucle1" para salir del primer bucle una vez se haya hecho una ultima vez el bucle 2.
			// En caso contrario iteración avanza un nodo de la lista.
			if( iteracion == NULL )
				salirBucle1 = 1;
			else
				iteracion = iteracion->puntero;

			salirBucle2 = 0;

			// Cada vez que se recorre la lista se ordenan dos Nodos:
			while( !salirBucle2 )
			{

				// Si se va a ordenar el primer Nodo con el segundo...
				if( p_nodoAnt1_nodoA == *lista )
				{
					// Si el NodoA es mayor que el nodoB, se cambian de orden:
					if( p_nodoAnt1_nodoA->elemento.numero   >   p_nodoA_nodoB->elemento.numero )
					{
						// Se intercambia el NodoA con el NodoB:
						*lista						= p_nodoA_nodoB;
						temporal					= p_nodoB_sig;
						p_nodoA_nodoB->puntero		= p_nodoAnt1_nodoA;
						p_nodoAnt1_nodoA->puntero	= temporal;

						// Se actualizan los punteros para que cada uno apunte segun su nombre correspondiente:
						p_nodoAnt1_nodoA			= *lista;
						p_nodoA_nodoB				= p_nodoAnt1_nodoA->puntero;
						p_nodoB_sig					= p_nodoA_nodoB->puntero;
					};

				}
				  // Si se van a ordenar nodos intermedios de la lista...
				else if( p_nodoB_sig != NULL )
				{

					if( p_nodoAnt1_nodoA->elemento.numero   >   p_nodoA_nodoB->elemento.numero )
					{
						// Se intercambian los punteros:
						p_nodoAnt2_nodoAnt1->puntero	= p_nodoA_nodoB;
						temporal						= p_nodoB_sig;
						p_nodoA_nodoB->puntero			= p_nodoAnt1_nodoA;
						p_nodoAnt1_nodoA->puntero		= temporal;

						// Se actualizan los punteros para que cada uno apunte segun su nombre correspondiente:
						p_nodoAnt1_nodoA				= p_nodoAnt2_nodoAnt1->puntero;
						p_nodoA_nodoB					= p_nodoAnt1_nodoA->puntero;
						p_nodoB_sig						= p_nodoA_nodoB->puntero;
					};

				}
				  // Si se va a ordenar el penultimo y ultimo nodo...
				else if( p_nodoB_sig == NULL )
				{

					if( p_nodoAnt1_nodoA->elemento.numero   >   p_nodoA_nodoB->elemento.numero )
					{
						// Se intercambian los punteros:
						p_nodoAnt2_nodoAnt1->puntero	= p_nodoA_nodoB;
						p_nodoA_nodoB->puntero			= p_nodoAnt1_nodoA;
						p_nodoAnt1_nodoA->puntero		= NULL;

						// Se actualizan los punteros para que cada uno apunte segun su nombre correspondiente:
						p_nodoAnt1_nodoA				= p_nodoAnt2_nodoAnt1->puntero;
						p_nodoA_nodoB					= p_nodoAnt1_nodoA->puntero;
						p_nodoB_sig						= NULL;
					}

					// Ya se han ordenado los dos últimos Nodos y ahora se para el bucle2:
					salirBucle2 = 1;

				};

				// Mientras el nodoB siga apuntando a otro nodo, se modifican todos los punteros para que apunten al siguiente nodo:
				if( p_nodoB_sig != NULL )
				{
					p_nodoAnt2_nodoAnt1	= p_nodoAnt1_nodoA;
					p_nodoAnt1_nodoA	= p_nodoAnt1_nodoA->puntero;
					p_nodoA_nodoB		= p_nodoA_nodoB->puntero;
					p_nodoB_sig			= p_nodoB_sig->puntero;
				};

			}; // Fin primer bucle

			// Al parar el segundo bucle hay que resetear los punteros al valor original.
			p_nodoAnt2_nodoAnt1		= NULL;
			p_nodoAnt1_nodoA		= *lista;
			p_nodoA_nodoB			= p_nodoAnt1_nodoA->puntero;
			p_nodoB_sig				= p_nodoA_nodoB->puntero;

		}; // Fin segundo bucle

	};// Fin del if

}; // fin de la funcion

// FUNCION QUE LIBERA LA MEMORIA USADA POR UNA LISTA:
void listaLiberaRam( struct NODO **lista )
{
	/*
	Precondición:
					Se ha de recibir un puntero de tipo struct NODO al primer nodo de la lista.
	Poscondición:
					Se borran todos los nodos de esa lista hasta llegar a NULL.
	*/

	struct NODO *actual, *siguiente;
	actual = *lista;

	while(actual != NULL)
	{
		siguiente = actual->puntero;
		free(actual);
		actual = siguiente;
	};

	*lista = NULL;

};

// Función que genera números aleatorios con sus premios aleatorios respectivos y los guarda en "fichero.dat":
void generaDat()
{
	/*
	Poscondición:
					La función se encarga de generar estructuras con números aleatorios que son guardados en un fichero secuencial.
					  El numero de estructuras a guardar viene dado por la constante NUMEROS.
	*/

	FILE *ficheroBin = fopen( "sorteo.dat", "w" );
	struct SORTEO cupon;
	int i;

	srand((unsigned int)time(NULL));

	for( i=0; i < NUMEROS; i++ )
	{
		cupon.numero  = rand()%100000;
		cupon.cuantia = rand()%1000;

		fwrite( &cupon, sizeof(struct SORTEO), 1, ficheroBin );
	};

	fclose( ficheroBin );
};

// Funciona que pasa el contenido de "fichero.dat" a "fichero.txt":
void mostrarDat()
{
	/*
	Poscondición:
					Se pasa todo el contenido del fichero secuencial a un fichero de texto.
	*/

	FILE *ficheroBin = fopen( "sorteo.dat", "r" );
	FILE *ficheroText;
	struct SORTEO cupon;

	if( ficheroBin == NULL )
		printf( "Genere rimero el fichero \"sorteo.dat\"\n" );
	else
	{
		ficheroText = fopen( "sorteo.txt", "w" );

		fread( &cupon, sizeof(struct SORTEO), 1, ficheroBin );

		while( !feof(ficheroBin) )
		{
			fprintf( ficheroText, "%i\t%i\n", cupon.numero, cupon.cuantia );
			fread( &cupon, sizeof(struct SORTEO), 1, ficheroBin );
		};

		fclose( ficheroBin );
		fclose( ficheroText );

	};

};

main()
{
	struct NODO *lista = NULL;
	struct NODO *temp;
	struct SORTEO cupon;
	FILE *fichOriginal, *fichOrdenDat, *fichOrdenTxt;
	char opcion;

	printf( "Eliga una opcion:\n" );
	printf( "1. Ordenar el fichero \"sorteo.dat\" mediante listas\n" );
	printf( "2. Generar \"sorteo.dat\"\n" );
	printf( "3. Pasar fichero \"sorteo.dat\" a \"sorteo.txt\"\n" );
	do{
		scanf( "%c", &opcion );
	} while( opcion < '1'  ||  opcion > '3' );

	if( opcion == '2' )
		generaDat();
	else if( opcion == '3' )
		mostrarDat();
	else if( opcion == '1' )
	{

		fichOriginal = fopen("sorteo.dat", "r");

		// Se comprueba que el fichero secuencial con el que se ha de trabajar exista:
		if( fichOriginal == NULL )
			printf( "Necesita el fichero \"sorteo.dat\", generelo primero\n" );
		else
		{

			// Se recorre cada estructura del fichero secuencial y se inserta en una estructura de datos dinamica de tipo lista:
			fread( &cupon, sizeof(struct SORTEO), 1, fichOriginal );

			while( !feof(fichOriginal) )
			{
				listaInsertAlFinal( &lista, &cupon );						// Se crea un nuevo nodo para el estruct leido y se inserta en la lista.
				fread( &cupon, sizeof(struct SORTEO), 1, fichOriginal );	// Se lee la siguiente estructura de datos a guardar en la lista.
			};
			fclose(fichOriginal);

			// Se ordena la lista:
			listaOrdenarAscendente( &lista );

			// Se imprime el contenido de la lista en unos ficheros:
			fichOrdenDat = fopen("sorteoOrdenado.dat", "w");
			fichOrdenTxt = fopen("sorteoOrdenado.txt", "w");
			temp = lista;

			while( temp != NULL )
			{
				fwrite( &temp, sizeof(struct SORTEO), 1, fichOrdenDat );
				fprintf( fichOrdenTxt, "%i\t%i\n", temp->elemento.numero, temp->elemento.cuantia );
				temp = temp->puntero;
			};
			fclose(fichOrdenDat);
			fclose(fichOrdenTxt);

			// Ya se ha finalizado el programa, pero antes de terminar del todo hay que liberar toda la memoria RAM usada:
			listaLiberaRam( &lista );

		};

	};

	printf( "  Operación finalizada.\n" );

};

/*
6x01-Listas_ordenadas_al_instante
25/01/2012

Implementa una lista ordenada con las operaciones vistas en clase. Utilízala para almacenar en ella todos los datos que hay en un fichero (por ejemplo, uno de resultados de un sorteo de lotería de Navidad, que tenga números premiados y premio que corresponde, que esté desordenado, y usando como criterio de orden los números), y posteriormente guarda la lista ordenada
en otro fichero.
*/

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define NUMEROS 10

struct SORTEO
{
	int numero;		// Numero de boleto
	int cuantia;	// Importe del premio
};

struct NODO
{
	struct SORTEO elemento;	// Información contenida en cada nodo de la lista.
	struct NODO *puntero;	// Puntero al siguiente nodo de la lista.
};

void insertarEnListaOrdenada( struct NODO **lista, struct SORTEO *cupon )
{
	/*
	Precondición:
					Se ha de recibir un puntero de tipo struct NODO al primer nodo de la lista. Este podrá valer NULL la primera vez o la dirección de memoria que corresponda.
					  El puntero además es un "doble puntero" ya que es necesario poder modificarlo.
					También se ha de recibir un puntero a una estructura de tipo SORTEO con la información a insertar en la lista.
	Poscondición:
					Se inserta la información contenida en "cupon" en un Nodo nuevo perteneciente a "lista", la inserción se realiza con orden ascendente según el "numero" de la estructura "cupon"
	*/

	struct NODO *temp 		= (struct NODO *)malloc(sizeof(struct NODO));	// Se define un puntero temporal de tipo NODO que apunta a la memoria solicitada al sistema.
	struct NODO *anterior 	= NULL;											// Se crea otro puntero de tipo NODO, este apuntando a NULL
	struct NODO *siguiente 	= *lista;										// Y un tercer puntero de tipo NODO que apunta al primer nodo de la lista.

	// En la primera inserción "lista" no apuntara a nada, por lo que se inserta el primer nodo y se hace que "lista" apunte a él.
	if( *lista == NULL )
	{
		temp->elemento	= *cupon;
		temp->puntero	= NULL;

		*lista = temp;
	}
	  // Cuando la lista ya tenga al un elemento...
	else
	{

		// Se han de recorrer todos los nodos para comprobar que el orden es correcto, es decir, con orden ascendente:
		//  De modo que se compara el numero del nodo al cual apunta "siguiente" con el numero del cupón que se quiere insertar.
		//  Si se cumple la condición, se guarda en "anterior" el puntero actual, y en "siguiente" se guarda el puntero del nodo siguiente de la lista
		//  En caso de que termine la lista "siguiente" valdrá NULL y "anterior" valdrá N-1 (el ultimo puntero valido)
		while(  siguiente != NULL   &&   siguiente->elemento.numero < cupon->numero )
		{
			anterior = siguiente;
			siguiente = siguiente->puntero;
		};

		// Si durante la lectura de la lista se llega al final sin encontrar un numero mayor, entonces se inserta el nuevo nodo al final de la lista.
		if( siguiente == NULL )
		{
			temp->elemento	= *cupon;	// Se guarda la estructura de datos (cupón) en la estructura del nuevo Nodo.
			temp->puntero	= NULL;		// Como la inserción es al final de la lista el puntero del Nodo no a puntara a ningún otro Nodo.

			anterior->puntero = temp;	// Se modifica el puntero del Nodo anterior para que apunte al nuevo Nodo.
		}
		  // En cambio, si recorriendo la lista se encuentra un numero mayor, se deberá insertar el nuevo nodo antes.
		else
		{
			// Ahora pueden darse dos casos:

			// Que el nodo a insertar sea el primero de todos, por lo tanto hay que modificar el puntero de "lista" para que apunte al nuevo Nodo:
			if( *lista == siguiente )
			{
				temp->elemento	= *cupon;
				temp->puntero	= siguiente;

				*lista = temp;
			}
			  // O que este entre dos nodos, por lo que se modificara el puntero del anterior Nodo para que apunte al nuevo Nodo:
			else
			{
				temp->elemento = *cupon;
				temp->puntero = siguiente;

				anterior->puntero = temp;
			};

		};

	};

};

void borrarLista( struct NODO **lista )
{
	/*
	Precondición:
					Se ha de recibir un puntero de tipo struct NODO al primer nodo de la lista.
	Poscondición:
					Se borran todos los nodos de esa lista hasta llegar a NULL.
	*/

	struct NODO *actual, *siguiente;
	actual = *lista;

	while(actual != NULL)
	{
		siguiente = actual->puntero;
		free(actual);
		actual = siguiente;
	};

	*lista = NULL;

};

// Función que genera números aleatorios con sus premios aleatorios respectivos y los guarda en "fichero.dat":
void generaDat()
{
	/*
	Poscondición:
					La función se encarga de generar estructuras con números aleatorios que son guardados en un fichero secuencial.
					  El número de estructuras a guardar viene dado por la constante NUMEROS.
	*/

	FILE *ficheroBin = fopen( "sorteo.dat", "w" );
	struct SORTEO cupon;
	int i;

	srand((unsigned int)time(NULL));

	for( i=0; i < NUMEROS; i++ )
	{
		cupon.numero  = rand()%100000;
		cupon.cuantia = rand()%1000;

		fwrite( &cupon, sizeof(struct SORTEO), 1, ficheroBin );
	};

	fclose( ficheroBin );
};

// Funcion que pasa el contenido de "fichero.dat" a "fichero.txt":
void mostrarDat()
{
	/*
	Poscondición:
					Se pasa todo el contenido del fichero secuencial a un fichero de texto.
	*/

	FILE *ficheroBin = fopen( "sorteo.dat", "r" );
	FILE *ficheroText;
	struct SORTEO cupon;

	if( ficheroBin == NULL )
		printf( "Genere rimero el fichero \"sorteo.dat\"\n" );
	else
	{
		ficheroText = fopen( "sorteo.txt", "w" );

		fread( &cupon, sizeof(struct SORTEO), 1, ficheroBin );

		while( !feof(ficheroBin) )
		{
			fprintf( ficheroText, "%i\t%i\n", cupon.numero, cupon.cuantia );
			fread( &cupon, sizeof(struct SORTEO), 1, ficheroBin );
		};

		fclose( ficheroBin );
		fclose( ficheroText );

	};

};

main()
{
	struct NODO *lista = NULL;
	struct NODO *temp;
	struct SORTEO cupon;
	FILE *fichOriginal, *fichOrdenDat, *fichOrdenTxt;
	char opcion;

	printf( "Elija una opción:\n" );
	printf( "1. Ordenar el fichero \"sorteo.dat\" mediante listas\n" );
	printf( "2. Generar \"sorteo.dat\"\n" );
	printf( "3. Pasar fichero \"sorteo.dat\" a \"sorteo.txt\"\n" );
	do{
		scanf( "%c", &opcion );
	} while( opcion < '1'  ||  opcion > '3' );

	if( opcion == '2' )
		generaDat();
	else if( opcion == '3' )
		mostrarDat();
	else if( opcion == '1' )
	{

		fichOriginal = fopen("sorteo.dat", "r");

		// Se comprueba que el fichero secuencial con el que se ha de trabajar exista:
		if( fichOriginal == NULL )
			printf( "Necesita el fichero \"sorteo.dat\", genérelo primero\n" );
		else
		{

			// Se recorre todo el fichero, en cada iteración se lee una estructura y se pasa a la función que la guarda en un nuevo Nodo de la lista.
			  // Se lee la primera estructura del fichero y se guarda en la estructura "temporal" de tipo "SORTEO"
			  fread( &cupon, sizeof(struct SORTEO), 1, fichOriginal );

			while( !feof(fichOriginal) )
			{
				insertarEnListaOrdenada( &lista, &cupon );					// Se crea un nuevo nodo para el estruct leido y se inserta en la lista.
				fread( &cupon, sizeof(struct SORTEO), 1, fichOriginal );	// Se lee la siguiente estructura de datos a guardar en la lista.
			};
			fclose(fichOriginal);

			// Hasta aquí ya se ha leído todo el fichero y se han introducido sus estructuras en cada Nodo de la lista de forma ordenada, ahora hay que pasarlos al fichero de destino.

			fichOrdenDat = fopen("sorteoOrdenado.dat", "w");
			fichOrdenTxt = fopen("sorteoOrdenado.txt", "w");
			temp = lista;

			while( temp != NULL )
			{
				fwrite( &temp, sizeof(struct SORTEO), 1, fichOrdenDat );
				fprintf( fichOrdenTxt, "%i\t%i\n", temp->elemento.numero, temp->elemento.cuantia );
				temp = temp->puntero;
			};
			fclose(fichOrdenDat);

			// Ya se ha finalizado el programa, pero antes de terminar del todo hay que liberar toda la memoria RAM usada:
			borrarLista( &lista );

		};

	};

	printf( "  Operación finalizada.\n" );

};

/*
5x07-Torres_de_Hanoi_parte_2
24/01/2012

Escribe un programa (se recomienda que sea recursivo) que dé solución al problema de las torres de Hanoi.
El enunciado es el siguiente: Se dispone de una torre formada por varios discos de diferentes diámetros denominada torre O (origen), donde cada disco es de diámetro inferior a todos los que están por debajo. Se dispone de otras dos torres para dejar discos, una denominada torre A (auxiliar) y otra torre D (destino).
El problema consiste en pasar todos los discos de la torre O a la torre D respetando dos normas muy simples:

Los discos se pasan de una torre a otra de uno en uno.
Nunca un disco de mayor diámetro puede estar sobre otro de menor diámetro.
Se preguntará al inicio del programa por el tamaño de la torre O (entendiendo que tendrá el número de discos indicados, con algún límite preestablecido).
Las torres A y D estarán inicialmente vacías.
Se debe ofrecer la solución que da el programa a este problema paso a paso, mostrando el resultado de una forma gráfica. El inicio podría ser algo así:

			*
		   ***
		  *****
		 *******
		*********
	   ===========		==========		==========
			O				A				D
*/
/*
	Formula para calcular movimientos mínimos necesarios:
	m = 2^n -1

http://www.rodoval.com/heureka/hanoi/

*/

#include <stdio.h>
#include <stdlib.h>

void imprime( int *tab, int fil, int col, int ultNum )
{
	/*
	Precondición:
					*tab	Puntero a una matriz de tipo entero.
					fil		Entero que indica el numero de filas de la matriz.
					col		Entero que indica el numero de columnas de la matriz.
					disc	Parámetro de tipo entero que indica el numero de discos usados.
					ultNum	Entero que indica el numero que esta usando el disco mas grande.
*/

	int f, c;
	int i, esp;

	for( c=col-1; c >= 0; c-- )
	{
		for( f=0; f < fil; f++ )
		{
			esp = ( ultNum - tab[col*f+c] )/2;

			// Espacios a la izquierda
			for( i=0; i < esp; i++ )
				printf( " " );

			// Imprime los comodines
			for( i=0; i < tab[col*f+c]; i++ )
				printf( "*" );

			// Espacios a la derecha
			for( i=0; i < esp; i++ )
				printf( " " );

			printf( "\t" );
		};

		printf( "\n" );
	};

};

void mueveDisco( int *tab, int fil, int col, int ultNum, int filOrig, int filDest )
{
	/*
	Precondición:
					*tab	Puntero a una matriz de tipo entero.
					fil		Entero que indica el numero de filas de la matriz.
					col		Entero que indica el numero de columnas de la matriz.
					disc	Parámetro de tipo entero que indica el numero de discos usados.
					ultNum	Entero que indica el numero que esta usando el disco mas grande.
					filOrig	Entero que indica el numero de fila de la matriz en la cual hay que coger el numero/disco
					filDest	Entero que indica el numero de fila de la matriz en la cual hay que dejar el numero/disco.
	Poscondición:
					Se mueve el disco y se llama a la función que imprime el tablero.
	*/

	int cO=col-1, cD=col-1;

	// Se busca el disco que se encuentre mas arriba y por lo tanto el mas pequeño de la fila de origen.
	while( cO >= 0  &&  tab[col*filOrig+cO] == 0 )
	{
		cO--;
	};
	if( cO < 0 )
		cO = 0;

	// Ahora se calcula cual es la posición libre mas arriba de la fila de destino
	while( cD >= 0  &&  tab[col*filDest+cD] == 0 )
	{
		cD--;
	};

	// Se mueve el disco de la fila de origen a la de destino:
	tab[col*filDest+cD+1] = tab[col*filOrig+cO];
	tab[col*filOrig+cO] = 0;

	// Se imprime el tablero:
	imprime( tab, fil, col, ultNum );
};

void hanoi( int *tab, int fil, int col, int disc, int ultNum, int O, int A, int D )
{
/*
Precondición:
				*tab	Puntero a una matriz de tipo entero.
				fil		Entero que indica el numero de filas de la matriz.
				col		Entero que indica el numero de columnas de la matriz.
				disc	Parámetro de tipo entero que indica el numero de discos usados.
				ultNum	Entero que indica el numero que esta usando el disco mas grande.
				O,A,D	Tres enteros que indican la fila desde donde se ha de coger el disco y a donde se ha de traspasar. La primera vez que se llama a hanoi tienen los valores de: 0 ,1 y 2 respectivamente.
Poscondición:
				Se llama recursivamente a hanoi hasta resolver el tablero.
*/

	if( disc==1 )
	{
		// Se borra la pantalla, se imprime la tabla y se hace una pausa que varia dependiendo del numero de discos:
		system("clear");
		mueveDisco( tab, fil, col, ultNum, O, D );
		if(col<=5) system("sleep 0.8"); else if(col<=10) system("sleep 0.3"); else if(col<=15) system("sleep 0.06"); else if(col>15) system("sleep 0.02");
	}
	else
	{
		hanoi( tab, fil, col, disc-1, ultNum, O, D, A );

		system("clear");
		mueveDisco( tab, fil, col, ultNum, O, D );
		if(col<=5) system("sleep 0.8"); else if(col<=10) system("sleep 0.3"); else if(col<=15) system("sleep 0.06"); else if(col>15) system("sleep 0.02");

		hanoi( tab, fil, col, disc-1, ultNum, A, O, D );
	};

};

main()
{
	int fil=3, col, *tablero = NULL;
	int f, c, disc=1, ultNum;

	printf( "Indique el numero de discos: " );
	scanf( "%i", &col );

	tablero = (int *)malloc( sizeof(int)*fil*col );

	// Resetea las torres poniendo "los discos" en una de ellas y 0 en el resto.
	for( f=0; f < fil; f++ )
		for( c=col-1; c >= 0; c-- )
			if( f==0 )
			{
				tablero[col*f+c] = disc;
				disc+=2;
			}
			else
				tablero[col*f+c] = 0;

	ultNum = disc;

	// Se imprime el tablero antes de iniciar ningún movimiento:
	system("clear");
	imprime( tablero, fil, col, ultNum );
	system("sleep 1");

	// Se llama a hanoi para comenzar "la partida":
	hanoi( tablero, fil, col, col, ultNum, 0, 1, 2 );
};

/*
5x06-Torres_de_Hanoi_parte_1
18/01/2012

Haz una versión del ejercicio siguiente (también recursiva) que simplemente vaya dando por pantalla las instrucciones necesarias para dar solución al problema de tamaño n.
Es decir, se trata de una versión del ejercicio siguiente que no muestra nada gráficamente, sino que implemente dice qué disco mover de qué torre a qué torre, para que un manipulador pueda ir haciendo esos movimientos sobre una maqueta y solucione correctamente el problema.
*/

#include <stdio.h>

void hanoi( int disc, int *cont, char O, char A, char D )
{
	/*
	Precondición:
					Se ha de recibir un parámetro de tipo entero que indica el numero de discos que se están usando.
					Un puntero a un parámetro de tipo entero que almacena el numero de movimientos.
					Y tres parámetros de tipo carácter cuyo valor va cambiando de orden por cada recursividad.
	*/

	if( disc == 1 )
	{
		if( *cont < 10 ) printf("  "); else if( *cont < 100 ) printf(" "); printf("%i:  %c -> %c\n", *cont, O, D );
		(*cont)++;
	}
	else
	{
		hanoi( disc-1, cont, O, D, A );

		if( *cont < 10 ) printf("  "); else if( *cont < 100 ) printf(" "); printf("%i:  %c -> %c\n", *cont, O, D );
		(*cont)++;

		hanoi( disc-1, cont, A, O, D );
	};

};

main()
{
	int disc, cont=1;;

	printf( "Indique el numero de discos: " );
	scanf( "%i", &disc );

	hanoi( disc, &cont, 'O', 'A', 'D' );
};

/*
5x05-Fibonacci
18/01/2012

Escribe un programa recursivo que calcule la función de Fibonacci de un número introducido por teclado. El valor de la función de Fibonacci se obtiene de la siguiente manera:

	1. Fibonacci(0)=1
	2. Fibonacci(1)=1
	3. Fibonacci(n)=Fibonacci(n-1)+Fibonacci(n-2)
*/

#include <stdio.h>

unsigned long long int fibonacci(unsigned long long int num)
{
	/*
	Precondición:
					Se ha de recibir un parámetro de tipo "unsigned long long int"
	Poscondición:
					Se devuelve otro "unsigned long long int"
	*/

	if( num == 1  || num == 0 )
		return num;
	else
		return fibonacci(num-1) + fibonacci(num-2);
};

main()
{
	unsigned long long int num;

	printf( "Introduzca un numero: " );
	scanf( "%lld", &num );

	printf( "\n   El Fibonacci de %lld es: %lld\n", num, fibonacci(num) );
};

/*
5x04-El_vector_esta_ordenado_o_no_con_recursividad
18/01/2012

Escribe un programa recursivo que determine si un vector de enteros está ordenado de menor a mayor o no.
*/

#include <stdio.h>
#include <stdlib.h>

int ordenadoONo( int *numeros, int tam, int pos )
{
	/*
	Precondición:
					Se ha de recibir el puntero de un vector de enteros de tamaño "tam"
					Cambien otro parámetro de tipo entero que indica el tamaño del vector.
					Y otro entero que indica la posición hasta la que se ha leído en el vector.
	Poscondición:
					Se devuelve true si numeros[pos] es menor que numeros[pos+1], false en caso contrario.
	*/

	int respuesta = 1;

	if( pos < tam )
	{
		if( numeros[pos] <= numeros[pos+1] )
			return ordenadoONo(numeros, tam, pos+1);
		else
		{
			printf( "\n   El numero %i no es menor que %i", numeros[pos], numeros[pos+1] );
			return 0;
		};

	}
	else
		return respuesta;

};

main()
{

	int *numeros = NULL;
	int tam, i;

	printf( "Indique el numero de enteros a introducir: " );
	scanf( "%i", &tam );

	numeros = malloc(sizeof(int)*tam);

	printf( " Introduzca los números enteros:\n" );
	for( i=0; i < tam; i++ )
	{
		printf( "  %i: ", i+1 );
		scanf( "%i", &numeros[i] );
	};

	if( ordenadoONo( numeros, tam-1, 0) )
		printf( "\n   Los números estaban ordenados\n" );
	else
		printf( "\n   Los números no siguen un orden\n" );

};