#include<stdio.h>
#include<stdint.h>
#include<string.h>
#include<stdlib.h>
#include<time.h>
 
#define GOAT 0		//CABRA 0
#define PRIZE 1		//PREMIO 1
 
#define MAX_SIMULATIONS 10000000
 
int main()	{
	/*unsigned char */
	uint8_t position = 0;	//Posicion del premio
	uint8_t selected = 0;	//Posicion seleccionada por el jugado
	uint8_t doors[3];		//Puertas
	uint8_t can_switch = 0;	//La puerta a la cual se puede cambiar
	register uint32_t count_win = 0;
	register uint32_t simulations = 0;
	srand(time(NULL));							//Semilla Random
	memset(doors,GOAT,sizeof(uint8_t)*3);		//Todas las puertas son Cabras
						//< 10000000
	while(simulations < MAX_SIMULATIONS)	{
		position = rand() % 3;		//position del Premio Pseudo-Aleatoria
		doors[position] = PRIZE;	//Guardamos el premio en la position antes seleccionada
		selected = rand() % 3;					//position elejida por el Jugador
 
		switch(selected)	{		//En base a lo elejido por el jugador
									//El encargado del juego valida que puerta tiene otra Cabra y la destapa
									//Dandole la oportunida al jugador de cambiar su puerta por la puerta restante
			case 0:							//Puerta 0 elejida por el Jugador
				if(doors[1] == GOAT)	{	//Si otra puerta 1 Tiene cabra entonces
					can_switch = 2; 		//Le damos la oportunidad de elegir entre la puerta 0 y la puerta 2
				}
				else	{					//Caso contrario
					can_switch = 1;			//Le damos la opotunidad de elegir entre la puerta 0 y la puerta 1
				}
			break;				
			case 1:							//Repetimos en caso de que seleccione la puerta 1
				if(doors[2] == GOAT)	{
					can_switch = 0; 
				}
				else	{
					can_switch = 2;
				}
			break;
			case 2:							//Repetimos en caso de que seleccione la puerta 2
				if(doors[0] == GOAT)	{
					can_switch = 1; 
				}
				else	{
					can_switch = 0;
				}
			break;
		}
		if(doors[can_switch] == PRIZE)	{	//Evaluamos si la puerta elejida tiene el premio
			count_win++;					//Si es asi incrementamos el contador de premios
		}
		doors[position] = GOAT;	//0			//Restablecemos la puerta con premio nuevamente a Cabra
		simulations++;						//Incrementamos el contador de Simulaciones
	}
 
	//Imprimimos totales
	printf("Total simulations with change %u, win: %u rate: %f\n",simulations,count_win,(float)((float)count_win/(float)simulations));
 
	count_win = 0;				//Restablecemos contador de premios a 0
	simulations = 0;			//Restablecemos contador de simulaciones a 0
 
	//Como en la siguiente similacion el jugador no cambiara de puerta no es necesario evaluar las otras puertas
	while(simulations < MAX_SIMULATIONS)	{
		position = rand() % 3;
		doors[position] = PRIZE;
		selected = rand() % 3;
		if(doors[selected] == PRIZE)	{
			count_win++;
		}
		doors[position] = GOAT;	//0
		simulations++;
	}
	printf("Total simulations without change %u, win: %u rate: %f\n",simulations,count_win,(float)((float)count_win/(float)simulations));
	return(0);
}
 

Total simulations with change 10000000, win: 6665613 rate: 0.666561
Total simulations without change 10000000, win: 3335076 rate: 0.333508

#include<stdio.h>
 
int main()	{
	int i;
	int arreglo[20];
	i = 0;
	while(i < 20)	{
		if(arreglo[i] != 0)	{
			printf("La posicion %i del arreglo no esta inicializada su valor actual es %i\n",i,arreglo[i]);
		}
		i++;
	}
	return 0;
}
 
 

La posicion 0 del arreglo no esta inicializada su valor actual es 4200160
La posicion 2 del arreglo no esta inicializada su valor actual es 21
La posicion 4 del arreglo no esta inicializada su valor actual es 9966448
La posicion 6 del arreglo no esta inicializada su valor actual es 1
La posicion 8 del arreglo no esta inicializada su valor actual es -1
La posicion 9 del arreglo no esta inicializada su valor actual es -1
La posicion 10 del arreglo no esta inicializada su valor actual es 4200261
La posicion 12 del arreglo no esta inicializada su valor actual es 1
La posicion 14 del arreglo no esta inicializada su valor actual es 4200137
La posicion 16 del arreglo no esta inicializada su valor actual es 3
La posicion 18 del arreglo no esta inicializada su valor actual es 21

La posicion 0 del arreglo no esta inicializada su valor actual es 4200160
La posicion 2 del arreglo no esta inicializada su valor actual es 21
La posicion 4 del arreglo no esta inicializada su valor actual es 12063600
La posicion 6 del arreglo no esta inicializada su valor actual es 1
La posicion 8 del arreglo no esta inicializada su valor actual es -1
La posicion 9 del arreglo no esta inicializada su valor actual es -1
La posicion 10 del arreglo no esta inicializada su valor actual es 4200261
La posicion 12 del arreglo no esta inicializada su valor actual es 1
La posicion 14 del arreglo no esta inicializada su valor actual es 4200137
La posicion 16 del arreglo no esta inicializada su valor actual es 3
La posicion 18 del arreglo no esta inicializada su valor actual es 21

int arreglo[20] = {0};

memset(arreglo,0,sizeof(int)*20);

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
 
struct nodo	{
	int id;
	//Dato del Nodo
	//struct data *datos;	//En caso de apuntar a otro tipo de estrucutura	
	//Variables auxiliar para el Grafo
	int peso_actual;	//Contenedor del peso actual recorrido para llegar a este nodo
	struct nodo *mejor_ruta;	//Indice de la mejor ruta para llegar al nodo de la ultima busqueda -1 para datos no inicializados
	int visitado;	//Variable Entera de Visitado, almacena un numero Ramdon para deteminar si fue visitado o no por el proceso actual
	int out;
	int total;		//Total de vetices conectados a reste Nodo
	int *aristas;	//En caso de que existan distintos pesos para viajar al X vertice se ponen aqui
	struct nodo **vertices;	//Distintos vertices que se pueden alcanzar desde este Nodo
	//int *vertices; //En caso de aplicar un nodo por indices a un arreglo de nodos
};
 
struct grafo	{
	int total;				// Total de nodos validos en el grafo
	int disponible;			// Total de espacios asignables en el grafo
	struct nodo **nodos;	//tabla de acceso rapido a X nodo
};
 
 
struct grafo *add(struct grafo *grafo_actual,int origen, int peso, int destino);
void add_nodo(struct grafo *grafo_actual,int origen,int peso,int destino);
int dijkstra(struct nodo *nodo_a,struct nodo *nodo_b);
int menor_ruta(struct grafo *grafo_actual,int A,int B);
 
int main()	{
	struct grafo *grafo = NULL;
/*
struct grafo *add(struct grafo *grafo_actual,int origen, int peso, int destino);
*/
	grafo = add(grafo,1, 7,2);
	grafo = add(grafo,1, 9,3);
	grafo = add(grafo,1,14,6);
	grafo = add(grafo,6, 9,5);
	grafo = add(grafo,6, 2,3);
	grafo = add(grafo,3,11,4);
	grafo = add(grafo,3,10,2);
	grafo = add(grafo,2,15,4);
	grafo = add(grafo,4, 6,5);
	printf("Ruta %i\n",menor_ruta(grafo,1,5));
	return 0;
}
 
int menor_ruta(struct grafo *grafo_actual,int A,int B)	{
	return dijkstra(grafo_actual->nodos[A-1],grafo_actual->nodos[B-1]);
}
 
struct grafo *add(struct grafo *grafo_actual,int origen, int peso, int destino)	{
	/*
		Variables
	*/
	int mayor = destino;
	struct nodo **temp = NULL;
	/*
		Inicializamos el grafo en caso de que no exista
	*/
	if(grafo_actual == NULL)	{
		grafo_actual = calloc(1,sizeof(struct grafo));
	}
	/*
		Determinamos el indice mayor
	*/
	if(origen > destino)	{
		mayor = origen;
	}
	/*
		Evaluamos si tenemos espacio suficiente
	*/
	if(mayor > grafo_actual->disponible)	{
		/*
			En caso de no tener espacio suficiente lo reasignamos
		*/
		temp = calloc(mayor,sizeof(struct nodo*));
		if(temp)	{
			if(grafo_actual->nodos)	{
				memcpy(temp,grafo_actual->nodos,grafo_actual->disponible*sizeof(struct nodo*));
				free(grafo_actual->nodos);
				grafo_actual->nodos = NULL;
			}
			grafo_actual->nodos = temp;
			grafo_actual->disponible = mayor;
		}else	{
			printf("Memory out!!\n");
			exit(0);
		}
	}
	/*
		Inicializamos los nodos en caso de que no existan
	*/
	if(grafo_actual->nodos[origen-1] == NULL)	{
		grafo_actual->nodos[origen-1] = calloc(1,sizeof(struct nodo));
		grafo_actual->nodos[origen-1]->id = origen;
		grafo_actual->total++;
	}
	if(grafo_actual->nodos[destino-1] == NULL)	{
		grafo_actual->nodos[destino-1] = calloc(1,sizeof(struct nodo));
		grafo_actual->nodos[destino-1]->id = destino;
		grafo_actual->total++;
	}
 
	/*
		Agregamos las Pesos y Aristas
	*/
	add_nodo(grafo_actual,origen,peso,destino);
	add_nodo(grafo_actual,destino,peso,origen);
 
	/*
		Retornamos el grafo_actual
	*/
	return grafo_actual;
}
 
void add_nodo(struct grafo *grafo_actual,int origen,int peso,int destino)	{
	struct nodo *aux = grafo_actual->nodos[origen-1];
	aux->aristas = realloc(aux->aristas,sizeof(int)*(aux->total+1));
	aux->vertices = realloc(aux->vertices,sizeof(int)*(aux->total+1));
	aux->aristas[aux->total]  = peso;
	aux->vertices[aux->total] = grafo_actual->nodos[destino-1];
	printf("Uniendo nodos: (%i)--[%i]--(%i)\n",origen,peso,destino);
	aux->total++;
}
 
int dijkstra(struct nodo *nodo_a,struct nodo *nodo_b)	{
	struct nodo *inicio =NULL,*pivote = NULL;
	struct nodo **pendientes = NULL;	//Arreglo de nodos no visitados a un.
	int i,j,total = 0;
	int visitado = rand();		//Variable aleatoria para determinar si un Nodo ya fue visitado por esta ocacion
	int peso_nuevo; 			//Variable temporal para evaluar cual es el menor peso al momento de visitar un nodo
	i = 0;
	pendientes = realloc(pendientes,sizeof(struct nodo*)*(total+1));
	pendientes[total] = nodo_a;	//Nodo inicial a visitar el el nodo A que se recibio como parametr
	nodo_a->peso_actual = 0;
	total++;
	printf("Buscando ruta de %i a %i\n",nodo_a->id,nodo_b->id);
	while(i < total)	{
		pivote = pendientes[i];
		printf("Procesando el nodo %i\n",pivote->id);
		if(pivote->out != visitado){	//Si aun no Agotamos el nodo actual
			printf("Visitando %i\n",pivote->id);
			j = 0;
			while(j < pivote->total )	{
				if(pivote->vertices[j]->out != visitado)	{
					if(pivote->vertices[j]->visitado != visitado)	{
						printf("El subnodo %i no a sido visitado\n",pivote->vertices[j]->id);
						pendientes = realloc(pendientes,sizeof(struct nodo*)*(total+1));
						pendientes[total] = pivote->vertices[j];
						total++;
						pivote->vertices[j]->peso_actual = pivote->peso_actual + pivote->aristas[j];
						pivote->vertices[j]->mejor_ruta = pivote;
						//printf("Ruta de %i a %i vale %i\n",nodo_a->id,pivote->vertices[j]->id,pivote->vertices[j]->peso_actual);
					}
					else	{	//Aqui ya lo visitamos, solo validaremos si la ruta pesa menos por este camino que por que se visito previamente
						printf("El subnodo %i ya a sido visitado\n",pivote->vertices[j]->id);
						//printf("El subnodo %i ya a sido visitado\n",pivote->vertices[j]->id);
						peso_nuevo =  pivote->peso_actual + pivote->aristas[j];
						printf("%i > %i ? %s\n",pivote->vertices[j]->peso_actual,peso_nuevo,(pivote->vertices[j]->peso_actual > peso_nuevo) ? "si":"no");
						if(pivote->vertices[j]->peso_actual > peso_nuevo)	{	// Si esta condicion se cumple es mas rapido llegar al nodo pivote->vertices[j] mediante el nodo pivote
							printf("Nueva mejor ruta a %i con peso de %i\n",pivote->vertices[j]->id,peso_nuevo);
							pivote->vertices[j]->peso_actual = peso_nuevo;
							pivote->vertices[j]->mejor_ruta = pivote;
						}
						printf("Ruta de %i a %i vale %i\n",nodo_a->id,pivote->vertices[j]->id,pivote->vertices[j]->peso_actual);
						//En caso de que el if no se cumpla es mas rapido llegar al nodo pivote->vertices[j] de la manera en la ya habia sido visitado previamente
					}
				}
				else	{
					//printf("El subnodo %i ya a sido visitado\n",pivote->vertices[j]->id);
					printf("El subnodo %i ya a sido visitado\n",pivote->vertices[j]->id);
					peso_nuevo =  pivote->peso_actual + pivote->aristas[j];
					printf("%i > %i ? %s\n",pivote->vertices[j]->peso_actual,peso_nuevo,(pivote->vertices[j]->peso_actual > peso_nuevo) ? "si":"no");
					if(pivote->vertices[j]->peso_actual > peso_nuevo)	{	// Si esta condicion se cumple es mas rapido llegar al nodo pivote->vertices[j] mediante el nodo pivote
						printf("Nueva mejor ruta a %i con peso de %i\n",pivote->vertices[j]->id,peso_nuevo);
						pivote->vertices[j]->peso_actual
						= peso_nuevo;
						pivote->vertices[j]->mejor_ruta = pivote;
					}
					printf("Ruta de %i a %i vale %i\n",nodo_a->id,pivote->vertices[j]->id,pivote->vertices[j]->peso_actual);
					//En caso de que el if no se cumpla es mas rapido llegar al nodo pivote->vertices[j] de la manera en la ya habia sido visitado previamente
				}
				pivote->vertices[j]->visitado = visitado;
				j++;
			}
			pivote->out = visitado;
			printf("Nodo %i fuera!\n",pivote->id);
		}
		else	{
			printf("El nodo %i ya esta fuera\n",pivote->id);
		}
		i++;
	}
	free(pendientes);
	return nodo_b->peso_actual;
}
 

struct nodo	{
	int id;
	unsigned char tabla[4][4];
	unsigned char x,y;
	struct nodo *aristas[4];
};
 

struct nodo	{
	int id;
	unsigned char tabla[4][4];
	unsigned char x:4;
	unsigned char y:4;
	struct nodo *aristas[4];
};
 

	[ 1][ 2][ 3][ 4]
	[ 5][ 6][ 7][ 8]
	[ 9][10][11][12]
	[13][14][15][  ]

	[15][14][13][12]
	[11][10][ 9][ 8]
	[ 7][ 6][ 5][ 4]
	[ 3][ 2][ 1][  ]

/*
	Juego del Imposible | Programación en C
 
	[ 1][ 2][ 3][ 4]
	[ 5][ 6][ 7][ 8]
	[ 9][10][11][12]
	[13][14][15][  ]
 
	 w
	asd
 
	Contacto
	Twitter:	@albertobsd
	Email:		alberto.bsd@gmail.com		
*/
#include<stdio.h>
 
void imprimir_tablero();
 
int tabla[4][4];
int x= 3,y =3;
 
int main()	{
	int i = 0,j =0,contador = 1;
	char caracter,enter;
	//Inicializar la tabla o matriz de juego
	while(i < 4)	{
		j = 0;
		while(j < 4)	{
			tabla[i][j] = contador;
			//printf("[%2i]",tabla[i][j]);
			j++;
			contador++;
		}
		printf("\n");
		i++;
	}
	tabla[y][x] = 0;
	imprimir_tablero();
	do	{
		caracter = getchar();
		enter = getchar();
		switch(caracter)	{
			case 'w':	//arriba
				if(y <= 2)	{
					//Movimiento de ficha
					tabla[y][x] = tabla[y+1][x];
					tabla[y+1][x] = 0;
					imprimir_tablero();
					y++;
				}
				else	{
					printf("Fuera de los limites\n");
				}
			break;
			case 's':	//abajo
				if(y >= 1)	{
					//Movimiento de ficha
					tabla[y][x] = tabla[y-1][x];
					tabla[y-1][x] = 0;
					imprimir_tablero();
					y--;
				}
				else	{
					printf("Fuera de los limites\n");
				}
			break;
			case 'a':	//izquierda
				if(x <= 2)	{
					//Movimiento de ficha
					tabla[y][x] = tabla[y][x+1];
					tabla[y][x+1] = 0;
					imprimir_tablero();
					x++;
				}
				else	{
					printf("Fuera de los limites\n");
				}
 
			break;
			case 'd':	//derecha
				if(x >= 1)	{
					tabla[y][x] = tabla[y][x-1];
					tabla[y][x-1] = 0;
					imprimir_tablero();
					x--;
				}
				else	{
					printf("Fuera de los limites\n");
				}
			break;
			case '0':	//Salida
			break;
			default:
				printf("Caracter Incorrecto");
			break;
		}
		printf("Caracter : %c\n",caracter);
	}while(caracter != '0');
	return 0;
}
 
void imprimir_tablero()	{
	int i = 0,j;
	while(i < 4)	{
		j = 0;
		while(j < 4)	{
			if(tabla[i][j] != 0)	{
				printf("[%2i]",tabla[i][j]);
			}
			else	{
				printf("[  ]");
			}
			j++;
		}
		printf("\n");
		i++;
	}	
}