Hace unos meses en una de mis clases de economia surgio esa pregunta.

El profesor en su momento nos lo explico con varias graficas de microeconomia y 2 horas completas de Clase que actualmente no recuerdo en su totalidad.

Quiero ver cuales son sus opiniones y Argumentos al respecto.

Saludos

Muy buen dia.

Estaba pensando que es posible determinar el numero de barajas usadas en un mazo de juego de 21.

Las condiciones que se tienen que dar para poder determinar el numero exacto de barajas son las siguientes.

• El mazo de cartas solo se renueva cuando se terminan las cartas del mazo actual
• Se tiene conocimiento pleno de todas las cartas que se han repartido desde el principio del juego
• Las cartas ya usadas NO se reciclan, (Condicion igual a la UNO pero solo para dejarlo mas claro)

Dada las condiciones anteriores podemos saber cuantas barajas son usadas para crear el mazo de juego.

Vamos a obviar el contenido de algunas fuciones y solo tendremos:

int main()	{
	struct mazo *mazo_juego = crear_mazo(6); // Se crea un mazo con 6 barajas
	struct carta *siguiente = NULL;
	int contador = 0;
	int acumulador = 0;
	siguiente = siguiente_carta(mazo_juego);	//Se comienza caon la primera carta
	while(siguiente != NULL)	{
		acumulador += valor_conteo(siguiente); //Acumulador va acumulando el conteo de cartas +1 para cartas del 2 al 6 y -1 para cartas del 10 al K + el A
		if(contador > 0 && (contador % 52) == 0 && acumulador == 0)	{
			printf("mazo nuevo\n");
			printf("Cantidad de Barajas %i\n",(contador/52));
			contador = 0;
		}
		contador++;
		siguiente = siguiente_carta(mazo_juego);
 
	}
}

La funcion valor conteo es la siguiente:

int valor_conteo(struct carta *actual)	{
	int r = 0;
	switch(actual->figura)	{
		case 'A':
		case 'K':
		case 'Q':
		case 'J':
		case '0':
			r = -1;
		break;
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
			r = 1;
		break;
	}
	//printf("valor de conteo de %c es %i\n",actual->figura,r);
	return r;
}

La estructura de una carta es la siguiente:

struct carta	{
	char figura;
	char tipo;
};

La condicion para saber el numero de barajas es la siguiente:

		if(contador > 0 && (contador % 52) == 0 && acumulador == 0)

Lo que quiere decir que:

• El contatador de cartas debe de ser mayor a 0 y cada que determinemos que es un "mazo nuevo" reiniciarlo a 0
• El contador debe de ser un multiplo exacto de 52
• Y el acumulador debe de ser 0

En uno de mis videos mostre como este acumulador sube o baja desde un valor muy alto a un valor muy bajo para llegar a 0 al finalizar el mazo actual.
 
El el programa main que mostre siempre da de salida.



Ahora si cambio el algoritmo para usar N cantidad de barajas a un numero random obtengo


Aun asi existen falsos positivos, en la salida anterior yo se apriori (Por que lo programe yo) que el valor random de numero de bajaras en el mazo este entre 6 y 112  y si vemos hay valores que nos dan "3" o algo menor a 6 es en falso positivo.

¿Por que se da esto?

Debido al orden aleatorio de un mazo de juego es posible que todas las condiciones que se mencionaron se cumpla antes de terminarse realmente un mazo.

Nuevamente las condiciones son

• El contatador de cartas debe de ser mayor a 0 y cada que determinemos que es un "mazo nuevo" reiniciarlo a 0
• El contador debe de ser un multiplo exacto de 52
• Y el acumulador debe de ser 0

¿Hay forma de evitar falsos positivos?

Segun pienso NO ya que en un escenario real no puedes conocer a priori todas las variables...

¿Para que sirve determinar el numero de barajas usadas?

Como se menciona en el algoritmo de conteo de cartas es deseable saber el numero de barajas usadas en un mazo de juego para determinar si es buen momento de apostar.

El video de que comento es el siguiente:



Aun asi el código ahi mostrado no esta tan avanzado como el código que muestro en este post, pero sirve para el ejemplo didáctico de conteo de cartas aquí mostrado solo con ligeros cambios.

Saludos

Muy buen dia les dejo un funcion que devuelve una arreglo de numeros enteros no repetidos y pseudo-aleatorios.

int *aleatorios_no_repetidos(int max)	{
	char *no_repetidos = NULL;
	int *desorden = NULL;
	int r = 0;
	register int i = 0;
	srand(time(NULL));
	while(no_repetidos == NULL){
		no_repetidos = calloc(max,sizeof(char));
	}
	while(desorden == NULL){
		desorden = calloc(max,sizeof(int));
	}
	do	{
		r = rand() % max;
		if(no_repetidos[r] == 0)	{
			desorden[i] = r;
			no_repetidos[r] = 1;
			i++;
		}
	}while(i < max);
	free(no_repetidos);
	return desorden;
}

Funcion explicada paso a paso:

int *aleatorios_no_repetidos(int max)	{
	char *no_repetidos = NULL;	//Variable auxiliar para determinar si un numero ya fue agregado o no
	int *desorden = NULL;	//Contenedor con los numeros en desorden y no repetidos
	int r = 0;		//variable temporal para el numero pseudo-aleatorio
	register int i = 0;	//contador de numeros en el arreglo desorden
	srand(time(NULL));	//inicializamos nuestra funcion random, en otros sistemas se puede utlizar algun otro generador de numeros aleatorios ya que esta implementacion es muy pobre
	//Los siguientes ciclos son usados para asignar espacio a no_repetidos, y  desorden respectivamennte se puede omitir el ciclo ya que rara vez calloc devuelve NULL, pero siempre es bueno validar que no exista error en el retorno de calloc
	while(no_repetidos == NULL){
		no_repetidos = calloc(max,sizeof(char));
	}
	while(desorden == NULL){
		desorden = calloc(max,sizeof(int));
	}
 
	//El siguiente ciclo do-while es usado para rellenar los numeros mientras i se menor que el numero maximo
	do	{
		r = rand() % max;		//Aqui tenemos nuestro numero aleatorio de 0 a max - 1
		if(no_repetidos[r] == 0)	{	//validamos que r no exista en el arreglo de no_repetidos
			desorden[i] = r;		//Asignamos r al arreglo de desorden
			no_repetidos[r] = 1;		//agregamos 1 al arreglo de no_repetidos para que el numero r actual no vuelva ser agregado
			i++;	//incrementamos i solo dentro del if para solo contabilizar los numeros que agregemos
		}
	}while(i < max);
	free(no_repetidos);	//Liberamos el arrgelo auxiliar de no repetidos ya que no lo necesitamos mas
	return desorden;	//regresamos la apuntador a desorden
}

Para usar esta funcion tenemos el siguiente ejemplo:

#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#include<string.h>
 
int *aleatorios_no_repetidos(int max);
 
 
int main()	{
	int maximo = 10;
	int *numeros = aleatorios_no_repetidos(maximo); // Solo numeros del 0 al 9  en desorden Los cuales son 10 en total
	int i = 0;
	printf("Numeros aleatorios no repetidos:\n"); 
	while(i < maximo)	{
		printf("%i\t",numeros[i]);
		i++;
	}
	printf("\n");
	free(numeros);
	return 0;
}
 

Salidas de ejemplo:


Cada 2 lineas es una salida de 10 numeros del 0 al 9 no repetidos y en desorden...

Noten que hay veces que se repite por la pobre implementación de rand() con time(), recomiendo si pueden implementar otra forma de aleatorios estaría mucho mejor el programa.

Proximamente agregare el video explicando el código mencionado.

Saludos

Tengo un detalle al momento de eliminar un nodo del arbol binario.

Dada la estructura:

struct nodo	{
	struct nodo *padre;
	struct nodo *izquierdo;
	struct nodo *derecho;
	char *valor;
};

Ya puedo agregar y buscar nodos sin problema y al momento de eliminar nodos hay varios casos ya aborde la mayoria de ellos solo tengo un detalle con el ultimo.

Casos:

• El Nodo a eliminar no tiene hijos (Listo)
• El Nodo a eliminar solo tiene un hijo derecho o izquierdo (Listo)
• El Nodo a eliminar tiene ambos hijos (Pendiente)

El detalles es el decidir como reconectar los nodos cuando el noda eliminar tiene 2 hijos... (Si es un problema de algoritmo pero lo pongo aqui por que esta en C)

Si esos 2 hijos no tienen hijos no hay problema simplemente selecciono uno y lo pongo en el lugar del nodo eliminado. Pero el peor de los casos es cuando ambos nodos tienes 2 hijos cada uno mas o menos asi:



La pregunta que tengo aqui seria la siguiente...

Tengo que hacer una funcion que reconecte y reorganize los nodos del arbol ¿Que recomendarian ustedes una funcion iterativa o una recursiva?

La otra solucion que tengo es manejar el nodo a eliminar como un arbol independiente desvincularlo del arbol principal y recorrer este nuevo subarbol de izquierda a derecha o viceversa y agregar cada nodo del subarbol al arbol principal, con excepcion de nodo a eliminar que seria la raiz del subarbol.

¿Que recomiendan ustedes?

La funcion que tengo es la siguiente:

void eliminar_nodo(struct nodo *arbol,char *valor)	{
	struct nodo *n;
	struct nodo *padre;
	struct nodo *derecho;
	struct nodo *izquierdo;
	if(debug_arbol)
		debug_arbol = 0;
	n = buscar_valor(arbol,valor);
	if(n)	{
 
		if(n->derecho == NULL && n->izquierdo == NULL)	{
			//No tiene hijos, hay que determinar si es el hijo derecho o izquierdo de su padre y desvincularlo
			padre = n->padre;
			if(padre->derecho == n)	{
				padre->derecho = NULL;
				free_nodo(n);
			}
			else	{
				padre->izquierdo = NULL;
				free_nodo(n);			
			}
		}
		else	{
			if(n->derecho != NULL && n->izquierdo != NULL)	{
				// Tiene 2 Hijos
				padre = n->padre;
				// Detalle aqui.....
 
			}
			else	{
				if(n->derecho != NULL)	{	//Solo tiene al hijo derecho
					derecho = n->derecho;
					padre = n->padre;
					if(padre->derecho == n)	{ //hay que determinar si es el hijo derecho o izquierdo de su padre y vincular dicho nodo, con el nodo derecho del n actual y liberar n despues de eso
						padre->derecho = derecho;
						free_nodo(n);
					}
					else	{
						padre->izquierdo = derecho;
						free_nodo(n);			
					}
				}
				else	{	//Solo tiene al hijo izquierdo
					izquierdo = n->izquierdo;
					padre = n->padre;
					if(padre->derecho == n)	{ //hay que determinar si es el hijo derecho o izquierdo de su padre y vincular dicho nodo, con el nodo izquierdo del n actual y liberar n despues de eso
						padre->derecho = izquierdo;
						free_nodo(n);
					}
					else	{
						padre->izquierdo = izquierdo;
						free_nodo(n);			
					}
				}
			}
		}
	}
	else	{
		printf("No existe un nodo con el valor \"%s\" en el arbol\n",valor);
	}	
}

---

Solucion en : http://foro.elhacker.net/programacion_cc/c_eliminando_nodo_de_arbol_binario-t453185.0.html;msg2072953#msg2072953

Muy buenas tarde comunidad estoy armando una lista de libros para tenerla en un archivo TXT con fines didacticos..

El detalle que estoy programando un Arbol (Ya tengo el codigo) solo que me pidieron que le agregara Titulos de libros y es lo que estoy buscando.

No he encontrado una lista lo bastante grande nesitaba mas de 10mil titulos de libros de ser posible mas de un millon pero me conformo con unos mil xD  

Por ejemplo busque en google por lista de libros y encontre esto:

https://es.wikipedia.org/wiki/Anexo:Los_100_mejores_libros_de_todos_los_tiempos,_seg%C3%BAn_el_Club_de_Libros_de_Noruega

Ya tengo esos 100   pero necesito encontrar alguna lista lo bastante amplia para pasarla a texto (Un libro por linea) Solo les pediria si me ayudaran a con links de listas de libros yo me encargo de pasarlos a texto.

Espero y me puedan ayudar

Si alguien sabe de alguna base de datos publica con muchisimos libros favor de avisarme  

Saludos!

Como.me gustaria ver esa platica...

:https://www.blackhat.com/us-16/briefings/schedule/#recover-a-rsa-private-key-from-a-tls-session-with-perfect-forward-secrecy-3046


¿Alguien sabe algo del tema?

Saludos

Muy buen dia.

Estoy tratando de implementar un pequeño programa que hice para hacerlo un servicio WEB... pero no estoy seguro de como aplicarlo en PHP

Tengo la siguiente estrucuta de C

struct temp{
	unsigned char *valor;
	unsigned int bytes;
};

Mi duda es como implementarlo correctamente en PHP, segun lei lo mas parecido es un clase en PHP

entonces tengo:

<?php
	class temp	{
		public $valor[];
		public $bytes;
	}
?>
 

Mi duda es como decir que $valor tiene que ser de X cantidad;

Por ejemplo cuando leeo desde un archivo X cantidad de bytes en $valor puedo saber que $valor tiene X longitud pero no se como hacerlo a mano... esto es

Voy a crear una instanacia de esa clase y al elemento $valor le quier agregar un valor en el primer elemento y posteriormente tal vez le agrege mas. Simplemente lo agrego como

$valor[1] = 200;

He usado arrays pero para este caso no creo que sea lo mas eficiente..

Hace 2 dias que vi un boletin de seguridad de freebsd.

al aplicacion afectada es sendmsg

https://www.freebsd.org/security/advisories/FreeBSD-SA-16:19.sendmsg.asc

cita:


Segun vi en mi cuenta de twitter hablaban de un root-exploit...

¿Alguien tendra algun PoC?

ya saben con fines de investigacion...

La idea es depurar la asignacion de momeria.

Tengo un programa algo grande que necestito depurar. El programa usa memoria dinamica todo el tiempo y en general el programa funciona bien.

Sin embargo segun mis calculos el programa esa usando mas memoria de la que necesita. Algunos megas de mas 

Reemplace las llamadas a free, malloc y calloc por unas funciones para ir depurando cada que se reserva o libera memoria.

¿Alguno de ustedes ha hecho algo parecido?

¿Alguna sugerencia algun cambio?

Tengo el siguiente codigo:

 
char **punteros;
size_t *contador_size;
size_t offset_contador = 0;
size_t contador_memoria = 0;
 
void _free_( char *ptr)	{
	remove_contador(ptr);
	free(ptr);
}
 
char *_calloc_(size_t nmemb, size_t size)	{
	char *ptr;
	ptr = calloc(nmemb,size);
	add_contador(ptr,nmemb*size);
	return ptr;
}
void add_contador(char *ptr,size_t size)	{
	printf("add_contador: %u [0x%x] %u + %u bytes\n",offset_contador,ptr,contador_memoria,size);
	punteros = realloc(punteros,(offset_contador+1)*sizeof(char*));
	contador_size = realloc(contador_size,(offset_contador+1)*sizeof(size_t));
	punteros[offset_contador] = ptr;
	contador_size[offset_contador] = size;
	contador_memoria+=size;
	offset_contador++;
}
 
void remove_contador(char *ptr)	{
	size_t i = 0;
	while(punteros[i] != ptr && i < offset_contador)	{
		i++;
	}
	printf("remove_contador: %u [0x%x]\n",i,ptr);
	contador_memoria-=contador_size[i];
	while(i < offset_contador-1)	{
			punteros[i] = punteros[i+1];
			contador_size[i] = contador_size[i+1];
		i++;
	}
	punteros[i] = NULL;
	contador_size[i] = 0;
	offset_contador--;
}

Al final solo tenemos que validar la variable contador_memoria para saber cuantos bytes quedan y offset_contador para saber cuantos apuntadore quedan.

Saludos

A ver tengo mi ejemplo de numeros de longitud variable o mejor conocidos como BigInt... (Implementacion propia) en C.

Estoy sumando byte a byte y el resultado lo guardo en una variable de 2 bytes por ejemplo cuando sumo 255 + 255 el primer byte del resultado tiene 255 y lo demas esta en el segundo byte el cual posterior al ciclo lo sumo al siguiente byte de la cadena en caso de no existir lo anexo al final y todo bien.

El detalle que al final si sumo una larga serie de 255 continuos  byte a byte llegara un momento en el que la variable se desborda...

Cual es la mejor solucion para esto? Guardar el resultado en una variable de 4 bytes y validar si existe acarreo en los bytes 3 y 4?

Que pasara cuando la variable de 4 bytes no sea suficiente...

Saludos