Quien no ha visto ese concurso donde hay un solo premio detras de 3 puertas las otras 2 con  Cabras u Ovejas...



La opción adecuada es siempre "cambiar" de puerta cuando te pregunten si te quieres cambiar de la misma..

El programa simula 10 Millones de Juegos 2 veces, en la primera ronda el jugador siempre cambia de puerta y en la segunda ronda el jugador nunca cambia de puerta.

Se demuestra que se tiene 66.6% de probabilidad de ganar si se cambia de puerta, contra 33.3% de probabilidad de ganar si no se cambia  de puerta.

#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);
}
 

Descripción del problema:

https://en.m.wikipedia.org/wiki/Monty_Hall_problem


Salida del codigo arriba mostrado:

Saludos!

Repitan despues de mi...

La memoria no se inicializa en 0 de forma automatica.
Los arreglos no se inicializan en 0 de forma automatica.
Las variables no se inicializan en 0 de forma automatica.

Se que es un tema tanto repetitivo y es el causante de muchos errores de programacion.

No existe ninguna garantia de que la memoria este inicializada en 0 todas las veces, hay ocasiones en la que si lo esta y hay ocasiones en la que no esta veamos este ejemplo, el cual muestra de un arreglo de 20 elementos los que su valor inicial no sea 0,

#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 salida de ese codigo compilado con GCC para windows es:


Y la segunda vez que lo ejecute fue


Como ven algunos valores cambiaron y otros se mantiene similares..

Depende del programador inicializar la memoria correctamente, o por lo menos estar cociente de que es posible que tenga basura en la memoria.

Una forma de inicializar en 0 el arreglo mencioanado al momento de declararlo es:

int arreglo[20] = {0};

otra forma es utilizar las funciones para inicializar con X valor la memoria

Por ejemplo para inicializar con 0:

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

Saludos!

Muy buen dia, les dejo la Base para realizar el algoritmo de dijkstra.

La imagen de ejemplo es la que esta en Wikipedia https://es.wikipedia.org/wiki/Algoritmo_de_Dijkstra#/media/File:Dijkstra_Animation.gif

He aqui el código, el ejemplo que muestra que la ruta mas rápida de 1 a 5 tiene un peso total de 20

El código esta medianamente comentado y Imprime lo que esta haciendo en tiempo de ejecución.

#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;
}
 

Muy buen dia estoy buscando optimizar el tamaño de una estructura dada.

Habia visto que es posible especificar el tamaño de una variable a nivel de bits.

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

Quiero optimizar las variables tabla, x é y

Las variables solo tiene valores del 0 al 15, con lo cual 4 bits serian suficientes.

Habia visto que se puede especificar el tamaño de la variable ejemplo:

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

Pero no se hacerlo para la variable tabla.

Saludos!

El punto es en eficiencia de busqueda.

Estaba haciendo el grafo que propuse en

¿Imposible? Juego de Rompecabezas imposible

Casi todo marcha bien con el grafo a excepcion de la parte donde valido si un valor ya existe en el grafo. En el ultimo intento que hice llevaba maa de 140 mil nodos en el grafo y con  cada posible nodo nuevo tenia que validar la existencia de su valor en el grafo (Muy lento)

Posteriormente use arreglo de los nodos existentes (Igualmente lento).

Entonces voy a usar un Arbol Binario.

Y la pregunta es esa ¿Hay algo mas eficiente que un arbol binario?

Lo pregunto por que no me he actualizado en mas de 5 años en estructuras de datos, estaba contemplando una tabla hash pero nunca la estudie y dudo que sea mas eficiente que un arbol binario en lo que se refiere a insercion y busqueda de nodos.

Saludos

Bueno les dejo aquí el código del Juego del imposible...

Se juega usando las teclas w,a,s,d como si fueran las flechas del teclado, esta seguida de un enter.

El reto "imposible" es definir dada la matriz inicial llegar a su forma inversa:




Y si, es IMPOSIBLE

/*
	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++;
	}	
}

Video:



Dejo también un Documento donde se explica de forma matemática por que es imposible el acomodo invertido dada una posición inicial.

http://miscelaneamatematica.org/Misc40/Campos_r.pdf

Aclaro que ese documento no es mio, lo realizaron los autores ahí señalados en el mismo.

Saludos!

En la cuenta de Twitter de Den Delimarsky se puede leer que la aplicación por falta de validacion de certificado es vulnerable a ser engañada mediante un proxy y con llamadas a la API es posible navegar en el mundo de pokemon go desde la comodidad del hogar y sin los peligros de ser atropellado en la calle.

@DennisCode

https://twitter.com/DennisCode/status/751592223330881536


Saludos!

Aunque no he usado Tapatalk

He visto que siempre deja titulos "Re:" sin el titulo original del tema.

Deberian de solucionar eso xD.

Saludos

Muy buen dia.

Estoy haciendo un pequeño juego en la casa (No tiene nada que ver con computadoras) y necesitaba algunas ideas frescas para los premios y/o castigos.

El detalle de esto es que estoy haciendo una estadística y quiero que en base a los premios y/o catigos los jugadores esten muy motivados para ganar.

Estaba desempolvado la vieja mesa de tortura medieval que consegui en la deepweb      pero creo que no aplica para el juego xD

La primera opcion que pense es dinero como premio o que lo paguen como castigo pero no se ustedes que sugieren?

Tambien pense en los siguientes castigos

• mini descargas electricas
• Poner hielo en alguna parte del cuerpo

Espero sus comentarios

Saludos

Muy buen dia como saben en mi canal de youtube tengo tutoriales de programación en C el ultimo que hice es el juego de Piedra Pepel y Tijera algo sencillo pero usando una Tabla de Estados simulando la forma mas básica de un autómata.

Dejo el codigo no sin antes proponerles un reto y es el siguiente: Dado el código siguiente modificarlo para que el programa sea capaz de "aprender" del histórico de jugadas del usuario y asi sea capas de predecir la próxima jugada.

Este aprendizaje no debe de perderse (Por lo tanto se debe de poder guardar para ser cargados en Futuros juegos)

/*
	Realizado por Luis Alberto
 
	Contacto
	Twitter:	@albertobsd
 
*/
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<stdbool.h>
 
//Constantes para las jugadas
#define PIEDRA 0
#define PAPEL 1
#define TIJERA 2
 
 
int main()	{
	int jugador = 0, computadora = 0;	// Variables para la seleccion de los Jugadores (Usuario - Computadora)
	char *jugadas[3] = {"Piedra","Papel","Tijera"};	//Cadenas para imprimir segun lo seleccionado por las variables Anteriores
 
	/*
		Exclusivamente para el resultado (Matriz bidimencional)
 
		Columnas para la Computadora
		Filas para el Jugador
 
		Valores:
			-	1 si el jugador Gana
			- 	0 si el jugador Empata
			- 	2 si el jugador Pierde
		[0][P][G]
		[G][0][P]
		[P][G][0]
 
	*/
	int resultados[3][3] = {{0,2,1},
							{1,0,2},
							{2,1,0}};
	char *resultados_str[3] = {"El jugador Empata","El Jugador Gana","El jugador Pierde"}; // Cadenas con los resultados
	bool entrar = true;	//Variable para detener el ciclo
	int opcion;			//Opcion seleccionada 
	char temp[10];		//Variable temporal para guardar la entrada desde el teclado
	char *valor = NULL;	//Puntero adicional usado por strtol
	srand(time(NULL));	// inicializar la semilla Pseudo-Aleatoria
	do	{
		computadora = rand() % 3;	//Valor seleccionado por la computadora al azar
		//Menu para el usuario
		printf("1) %s\n",jugadas[PIEDRA]);
		printf("2) %s\n",jugadas[PAPEL]);
		printf("3) %s\n",jugadas[TIJERA]);
		printf("S) Salir\n");
		printf("Ingrese su opcion: ");
		fgets(temp,10,stdin);	// Capturamos texto
		opcion = strtol(temp,&valor,10);	//Convertimos el texto a Entero
		if(valor[0] == '\0' || valor[0] == 0x0a)	{	//Si es un valor valido continuas
			switch(opcion)	{	//switch para las opciones pero se pudo usar un IF
				case 1:
				case 2:
				case 3:
					jugador = opcion - 1;	//Seleccion del Jugador
					//resultados:
					printf("La computadora elijio %s\n",jugadas[computadora]);
					printf("El jugador elijio %s\n",jugadas[jugador]);
					printf("Resultado: %s\n",resultados_str[resultados[jugador][computadora]]);
				break;
				default:
					printf("Aprende a leer solo valores del 1 al 3 o la letra S mayuscula\n");
				break;
			}
		}
		else	{	//Si no es valor valido posiblemente sea una S
			//printf("Elijio %.2x\n",valor[0]);
			if(temp[0] == 'S')	{	//Si es S establecemos la variable para salir del ciclo
				entrar = false;
			}
		}
	}while(entrar);
	return 0;
}

Aqui les dejo el vídeo mencionado:



Saludos!

---

He creado una estructura para guardar los resultados y posteriormente guardar la estructura en un archivo

De hecho son 2 estrucuturas:

struct nodo_ppt	{
	int count;
	int respuesta[3];
};

La estrucutura anterior guarda un contador para indicar cuantas veces se a entrado a ese nodo y posteriormente cual fue la respuesta a esto.

Por ejemplo tenemos un arreglo de  9 nodos

struct nodo_ppt nodos[9];

Y por ejemplo se juega Piedra(Jugador) vs Tijera(Computadora) entonces al igual que en la matriz de resultados:

int resultados[3][3] = {{0,2,1},{1,0,2},{2,1,0}};

Entonces guardamos como nodos "previo" la posicion de nodos [(Jugador*3) +computadora]  y en el proximo juego incrementamos la seleccion del jugador en el nodo previo y nuevamente ajustamos el nodo previo a la seleccion actual y repetimos.

Con esto tendremos un histórico de (Si en el juego anterior se juego X entonces en el juego siguiente Jugara Y (con mas probabilidad)) donde Y es el mayor numero seleccionado en el contador de respuesta