UNIVERSIDAD DE LAS

FUERZAS ARMADAS - ESPE

ASIGNATURA: PROCESOS ESTOCSTICOS

LABORATORIO 1

INTEGRANTE:
1. Johann Pez

FECHA: 26 de ABRIL 2014

Conteo, Muestreo y Juegos en Matlab

Procesos Estocsticos
Prof. Vinicio Carrera
1. Introduccin
En este laboratorio, estudiaremos experimentos de conteo y demostraremos como se relacionan con
un muestreo aleatorio de un conjunto. Estas ideas sern utilizadas para algunos juegos que las
personas juegan. Como muchos problemas de ingeniara, necesitaras realizar razonamientos
matemticos y verificar su resultado con un software. En este caso, utilizaremos Matlab.

2. Conteo y Muestreo
El propsito del conteo en la teora de probabilidades es determinar la cantidad de posibilidades que
un experimento pueda suceder. Por ejemplo, en 42 nmeros de la lotera, existen 5245768 maneras
del estado elegir 6 nmeros ganadores aleatorios de los 42. Probaremos eso.
Si lo piensas, el estado saca un pequeo pedazo de plstico etiquetados con nmeros. Esto
es, el estado usa nmeros enteros como cdigo para los objetos del experimento. Esto es una
manera de conveniencia. Hasta los equipos de futbol utilizan nmeros en las camisas para codificar
los participantes humanos. Como veremos, la codificacin de enteros a objetos en un experimento
simplifica la descripcin. No importara si los objetos son personas o cartas de juego.
Debido a que existe un juego para ilustrar a cada principio de conteo, podemos estudiar las
formulas clsicas de conteo estudiando juegos.

2.1 Muestreo con y sin remplazo

Considerando el sacar desde un sombrero nmeros del 1 a n. El primer nmero sacado produce que
existan n posibilidades. Si el nmero sacado es puesto devuelta y un segundo nmero es sacado (de
un mximo de n nmeros), entonces hay n2 posibilidades que el experimento suceda. Si este nmero
es puesto de vuelta al sombrero y el experimento continua por r nmeros que sern extrados,
entonces el numero de posibilidades del experimento es de N=n r. Llamamos este experimento
muestreo con remplazo.
Ahora suponiendo r nmeros que son sacados de un gorro sin remplazo. El primer nmero
sacado produce una de n posibilidades que suceda, el segundo produce una de n-1 posibilidades que
suceda, y as sucesivamente. El nmero de posibilidades que suceda para r nmeros sacados es de
. Llamamos este experimento muestreo sin remplazo.
Si nuevamente suceda el experimento donde sacamos nmeros de un sombrero que
contiene n nmeros, entonces permutaciones dependen del orden que sacan los nmeros. De otra
manera, si estamos interesados en el nmero de r nmeros de combinaciones que sern sacadas del
sombrero de n nmeros, entonces necesitamos remover el multiplicador de cada combinacin,
llamndole

2.2 Conteo y muestreo en Matlab

Existen cuatro funciones principales que necesitaras para este laboratorio. Las primeras dos estn
construidas en las funciones de Matlab para realizar permutaciones y combinaciones, y las otras 2
son funciones caseras que puedes utilizar para realizar muestreo sin remplazo y contar el nmero de
elementos que sean iguales en 2 vectores.
La funcin de permutacin en Matlab es perms. Lo llamas con un vector y te regresa todas
las permutaciones de ese vector. Para verlo intenta escribiendo perms(1:4) o hasta perms(abcd). Si
no le gusta el orden del resultado, puede hasta intentar perms(4:-1:1) o sortrows(perms(1:4)).
Hay una funcin que calcula ambos valores de
y retorna todas las combinaciones de
tamao k, llamado nchoosek(m,k). Esta funcin toma dos entradas. Cuando la primera entrada es un
numero, la salida es el valor numrico de
. Cuando la primera entrada es un vector de longitud n,
entonces nchoosek retorna las
combinaciones de n nmeros 1 hasta n, tomados k cada tiempo.
Para verlo, escriba nchoosek(5,3) y se ver 10 combinaciones de 5 elementos tomados 3 cada
tiempo. Para ver la combinacin actual escriba nchoosek(1:5,3).

2.3 Muestreo sin remplazo en Matlab

Para el muestreo sin remplazo, crear la funcin pick_nums.m. Esta funcin debe aleatoriamente
sacar sin remplazo k nmeros de un conjunto de n nmeros. Para verificar, intenta escribiendo
pick_nums(1:12,3) o pick_nums(1:42,6) cuantas veces sea.
La ltima funcin a crear es count_matches.m, lo que toma dos vectores y cuenta el nmero
de elementos que tienen en comn sin importar la posicin de esos elementos en sus respectivos
vectores. Por ejemplo, el vector [147] tiene 2 nmeros en comn con el vector [734]. Los dos
vectores no necesitan tener el mismo tamao. Un ejemplo que usa count_matches es
State = pick_nums(1:60,20);
player = pick_nums(1:60,10);
num_matches = count_matches(State,player)
Cuando esa ltima funcin es llamada con solamente una variable de retorno (sobre
num_matches), esto solo retorna el numero de coincidencias. Si quisieras ver cules son los valores
que coinciden, puedes remplazar la ltima lnea con
[num_matches values_matched] = count_matches(State, player)

3. Lotto
Lotto es un juego donde cada jugador elije K nmeros nicos de N posibles nmeros hasta que el
estado cierre el juego. A ese punto, el estado elije sus propios K nmeros nicos y paga a cada
jugador basado en el nmero correcto de coincidencias numricas.
En un caso hipottico del juego Lotto, dejemos que N=42 nmeros posibles. Cada jugador
(y tambin el estado) elijen K=6 nmeros. Esto significa que hay
posibles casos de
elegir 6 nmeros de 42. Por lo tanto las probabilidades de acertar los 6 nmeros son de 5245786 a 1.
Pero que dicen las probabilidades de acertar 4 nmeros. Para ver eso, rompa los 42 posibles
nmeros en conjuntos deseados de 6 nmeros y no deseados de 36 nmeros. Si el jugador acierta 4
de los nmeros deseados, entonces el jugador tambin acierta 2 nmeros del conjunto no deseado.
Por lo tanto, el nmero total de combinaciones de 4 nmeros deseados y 2 no deseados es

. Esto significa que las probabilidades de acertar exactamente 4 nmeros son 5245786 a 9450,
que es aproximadamente 555 a 1. En general esto es

Maneras de coincidir k=0,1,,6 nmeros en (42,6) el Lotto. Las probabilidades de coincidir k

nmeros es justo el nmero posible de acertar vs el nmero de aciertos que produce k coincidencias,
llamada
. La probabilidad inversa es la probabilidad de k coincidencias.

Hay dos funciones que necesitas crear para simular el juego del Lotto. La primera, llamada
lotto_game.m, debe jugarse el Lotto con M jugadores y retornar los nmeros que saco el estado ms
los sacados por los jugadores con sus respectivas coincidencias numricas. Para usar esa funcin,
debes definir 3 valores: N=total de posibles nmeros, k=cantidad de nmeros sacados por cada
jugador y M=nmero de jugadores. Por ejemplo si escribes
lotto_game(42,6,5)
El resultado podra ser
State =
35 2 25 41 12 37
Player_data =
5 3 12 40 4 14 1
42 9 21 13 29 40 0
33 28 6 4 1 14 0
35 42 1 33 25 22 2
11 35 12 32 28 8 2
En la matriz player_data, la ltima columna contiene los nmeros de coincidencias que el jugador
consigui. La segunda funcin a crear es lotto_histo.m, lo que juega el Lotto con M jugadores y
grafica la medida y la estadstica terica del juego. Para verlo, debes escribir lo siguiente:
[est_pmf act_pmf] = lotto_histo(42,6,10)

4. Keno
Keno es similar al Lotto en cambio el jugador elige K nmeros de N posibles nmeros y el jugador
le pagan basado en aciertos de k nmeros. Sin embargo en Keno, el estado saca
numeros. Tal
juego se refiere como (N,n,K) del juego Keno. La probabilidad de sacar k coincidencias en (N,n,K)
juego de Keno es

Donde
es el numero de formas que el jugador puede coincidir k nmeros deseados,
es el
numero de formas que el jugador puede coincidir K-k nmeros indeseados y
es el total de
formas que el jugador pueda elegir K nmeros de N posibles nmeros.

4.1 Asignacin

En un escenario hipottico, considere jugar el Keno con (60,20,10). Cul es la

probabilidad de aciertos en
nmeros?
El programa del Lotto nos da antes un caso especial del programa Keno. Como podras usar
el programa del Keno para simular el Lotto.

5. Carreras de Caballos
En una carrera de 12 caballos, hay 12! = 479001600 posibles formas que los caballos pueden
terminar la carrera, acertando las 12 posiciones sera un gran tiro. Sin embargo solo
(12)(11)(10)=(12)3 =1320 formas para ordenar el primero, segundo y tercero que terminaran.
Atinando los 3 primeros caballos en orden se conoce como trifecta.

5.1 Asignacin

Una trifecta box apuesta que permite el jugador elegir los 3 primeros caballos sin
especificar el orden. Esa apuesta cuesta 6 veces ms de la trifecta regular. Porque? Cuantas
posibles formas se puede hacer una trifecta box?

6. Realizacin del Lab

Lotto game (Hiptesis)

Se requiere comprobar que probabilidad se tiene de coincidir k=0, 1, 2, 3, 4, 5 o 6 nmeros que

tengan los jugadores con los que sortea el estado de los 42 nmeros existentes. Para cada k existe
una probabilidad siendo tericamente estas las siguientes:
Coincidencias
Probabilidad
de suceso

0.371

0.431

0.168

0.027

0.0018

0.000041

0.00000019

Segn el enunciado se program los siguientes cdigos:

a)
function [Z,W]=lotto_game(N,k,M)
%N es la cantidad de numeros que se generaran del 1 hasta N
%k es la cantidad de numeros elegidos por los jugadores
%M es la cantidad de jugadores que van a participar
if(N<k)
display('La cantidad de numeros a elegir supera a los existentes no
es posible')
Z='ERROR';
return
end
W=pick_nums(1:N,k);
for i=1:M
player=pick_nums(1:N,k);
aux=count_matches(W,player);
for j=1:k
A(i,j)=player(j);

end
A(i,k+1)=aux;
end
Z=A;
return

b)
function [mesu teo]=lotto_histo(N,k,M)
[Z,W]=lotto_game(N,k,M);
aux2=(factorial(42))/((factorial(6))*(factorial(42-6)));
for i=1:7
aux1=(factorial(6))/((factorial(i-1))*(factorial(6-i+1)));
aux3=(factorial(36))/((factorial(6-i+1))*(factorial(36-6+i-1)));
teo(i)=(aux1*aux3)/(aux2);
end
mesu=(Z(:,k+1))';
subplot(3,1,1)
hist(mesu,0:k)
title('Aciertos de cada nmero');
subplot(3,1,2)
bar(teo)
set(gca,'xticklabel',{'0','1','2','3','4','5','6'});
title('Valores tericos de probabilidad');

c)
function [X]=pick_nums(A,B)
%A es el vector con los numeros ejm (1:40) y B cuantos numeros se
elegirn
[m,p]=size(A);
n=B;
aux1=max(max(A));
aux2=min(min(A))-1;
if(p<n)
display('No puede retirar mas numeros de los existentes')
X='ERROR';
return
else
numeros=randperm(aux1-aux2:aux1)+aux2;
X=numeros(1:B);
end
return

d)
function [Y]=count_matches(State,player)
%State es el vector con los numeros ganadores
%player son los numeros elegidos por los jugadores
[m,n]=size(State);
[p,q]=size(player);
contador=0;
for i=1:n
for j=1:q
if(State(i)==player(j))
contador=contador+1;
end
end
end

Y=contador;
return

Explicacin.- El programa es vlido para otros N, k y M que se quieran elegir, lo primero que hace
es validar los valores ingresados verificando que no puedan extraerse ms nmeros de los que ya
existen, luego llamamos la funcin pick_nums para que nos entregue un vector con los nmeros
del estado y asignamos a una variable W. Creamos un bucle para que se puedan generar ms
formaciones de nmeros aleatorios que serian los nmeros de los jugadores, este ciclo se repite
tantas veces existan jugadores por jugar. Adentro de ese mismo ciclo automticamente llamamos a
count_matches para verificar si los nmeros generados al jugador coinciden con los del estado y
nos regresa un nuevo vector agregado a la ltima posicin la cantidad de aciertos de ese jugador.
Por ltimo agregamos todos los vectores generados de cada jugador a una matriz para poder
proceder a la impresin de los datos. Ejm:

Tambin se programo el cdigo lotto_histo que sirve para realizar el proceso de lotto_game
y realizar un histograma de su resultado. Para graficar el mtodo terico se program la frmula

Y para los valores medidos simplemente se utiliz la ltima columna del count_matches para
obtener la cantidad de aciertos probables. Ejm:
>> lotto_histo(42,6,5)

Comprobacin de hiptesis.- con los programas realizados comprobaremos la hiptesis, pero para
eso necesitaremos tomar un gran nmero de jugadores para poder acercarse ms al valor esperado.
En este caso tomaremos los valores del histograma y calcularemos sus probabilidades.
Experimento con 50000 jugadores tomando 6 nmeros de 42 en total.

Segn ya conocemos las probabilidades tericas son:

Coincidencias
Probabilidad
de suceso

0.371306

0.431194

0.168435

0.027222

0.001801

0.000041

0.00000019

Y las probabilidades medidas son cuando se uso un experimento con 50000 jugadores:
Coincidencias
Probabilidad
de suceso
medido

Para que se pueda comprobar la hiptesis el error debe ser menor al 5%

Para el error 6 debido a que en el experimento no se lograron aciertos de 6 nmeros vamos a

verificar por otro mtodo observando que la probabilidad terica de 0.00000019 es prcticamente 0
como en el experimento.
Sumario del Lotto
Debido que para mayores de 50000 jugadores la mquina se congelaba se pudo comprobar
la hiptesis en su mayora, ya que a ms iteraciones posibles se acercara ms al valor terico.
A parte de los grficos fue necesario contar la cantidad de nmeros repetidos con otra
funcin que no est visible en los programas pero fue utilizada, esta es: numel(find(ans==k)) siendo
k el valor que quiere saber cuntas veces se repite.
En la vida diaria muchos pensamos que algn da de suerte podremos ganar un juego como
el Lotto pero al haber estudiado probabilidades y verificado con una maquina virtual repetidas veces,
se comprueba que es prcticamente imposible acertar todos los nmeros de este juego.

Keno game (Hiptesis)

Se requiere saber que probabilidad se tiene al intentar jugar el Keno cuando existen 60 nmeros
posibles de los cuales el estado tomar 20 y los jugadores elegirn 10. Utilizando la formula:

tenemos
Coincidencias
Probabilidad
de suceso
Coincidencias
Probabilidad
de suceso

0.0112431

0.0725359

0.193806998

0.281901

0.24666345

0.13531252

10

0.0469835

0.010158598

0.00130324

0.00008911

0.00000245

El programa del Keno y del Lotto solo se diferencia que ya no existe un nmero de jugadores en el
Keno para ese programa y que el estado elegir ms nmeros que el jugador para que este tenga
ms chances de ganar. Lo que se realiza en el programa del Keno para adaptar al Lotto es

simplemente que el parmetro K sea igual a n. Entonces tendramos el siguiente programa

adaptable.
function [Z,W]=keno_game(N,n,k)
if(N<k)
display('La cantidad de numeros a elegir supera a los existentes no
es posible')
Z='ERROR';
return
end
if(n<k)
display('El estado debe elegir siempre mas numeros que el jugador')
Z='ERROR';
return
end
Z=pick_nums(1:N,n);
player=pick_nums(1:N,k);
aux=count_matches(Z,player);
player(k+1)=aux;
W=player;
return

OPCIONAL KENO

Para poder retornar valores aceptables para comprobar la hiptesis de las probabilidades en el juego
del Keno es necesario que este se adapte para poder utilizar muchas iteraciones de juego y as poder
tener un clculo base. Tenemos los siguientes programas.
a)
function [Z,W]=keno_game(N,n,k)
if(N<k)
display('La cantidad de numeros a elegir supera a los existentes no
es posible')
Z='ERROR';
return
end
if(n<k)
display('El estado debe elegir siempre mas numeros que el jugador')
Z='ERROR';
return
end
Z=pick_nums(1:N,n);
for i=1:50000
player=pick_nums(1:N,k);
aux=count_matches(Z,player);
for j=1:k
A(i,j)=player(j);
end
A(i,k+1)=aux;
end
W=A;
return

b)
function [mesu teo]=keno_histo(N,n,K)
[W,Z]=keno_game(N,n,K);
aux2=(factorial(60))/((factorial(10))*(factorial(60-10)));
for i=1:K+1
aux1=(factorial(20))/((factorial(i-1))*(factorial(20-i+1)));
aux3=(factorial(40))/((factorial(K-i+1))*(factorial(40-K+i-1)));
teo(i)=(aux1*aux3)/(aux2);
end
mesu=(Z(:,K+1))';
subplot(3,1,1)
hist(mesu,0:K)
title('Nmero de aciertos');
subplot(3,1,2)
bar(teo)
set(gca,'xticklabel',{'0','1','2','3','4','5','6','7','8','9','10'});
title('Valores tericos de probabilidad');

Explicacin.- El programa es vlido para otros N, n y K que se quieran elegir, lo primero que hace
es validar los valores ingresados verificando que no puedan extraerse ms nmeros de los que
existen, lo segundo es validar que el estado saque siempre ms nmeros que el jugador, luego se
repite el proceso del programa del Lotto llamando las funciones de pick_nums para poder ingresar
a un vector los nmeros del estado y luego adentro de un bucle hacemos el mismo procedimiento
pero utilizando la funcin pick_nums para obtener ms nmeros que el estado y luego verificando
cuantos aciertos se tiene con la funcin count_matches esto se encontrar adentro del bucle para
poder repetir ese procedimiento varias veces simulando varios juegos (el valor 50000 en el for
indica las iteraciones), despus se ingresa a un vector auxiliar A los nmeros del jugador y
agregando a la ltima columna el nmero de aciertos con respecto al estado, por ltimo se genera
una matriz con los valores obtenidos en cada juego y sus aciertos. Si llamamos a la funcin
keno_histo igualmente realizar el mismo procedimiento que el de lotto_histo ahora
implementando la siguiente frmula en matlab:

Y luego con los comandos hist y bar se grafican los valores medidos y tericos.
Ejm: Keno game con 10 iteraciones:

Keno game con 50000 iteraciones

Sumario del Keno

A diferencia del Lotto el Keno es un juego mucho ms probable de obtener ms aciertos ya
que el estado toma ms nmeros y con eso incrementa la posibilidad que el jugador tenga nmeros
iguales al estado.
A parte que sigue siendo complicado acertar todos los valores tambin es muy difcil no
acertar ninguno como se puede observar en las grficas mnimo se obtendrn 2 valores iguales al
estado fcilmente.
Como el programa del Keno no peda un parmetro de jugadores, simulaba solo un juego de
Keno haciendo impreciso afirmar una probabilidad, por lo que se genero un bucle que itere 50000

veces para simular 50000 diferentes juegos, as teniendo ya una aproximacin ms exacta de los
valores probabilsticos tericos.

Carrera de Caballos (Hiptesis)

Se requiere comprobar cuntos posibles casos se puede tener cuando se realiza una trifecta box y
que probabilidad es que se gane con una apuesta de esas. Si existen 12 caballos que se pueden
formar de 12! Maneras diferentes tenemos 479001600 posibilidades pero en una trifecta box
tenemos:

Elegimos los 3 primeros caballos sin importar el orden y obtenemos que existen 220 maneras
diferentes de ordenarlos. Ahora si la trifecta son
maneras de ordenar y cuesta un
valor X. Podemos comprobar que la trifecta box debera valer 6 veces ms debido a que es
exactamente 6 veces ms probable de ganar segn la siguiente relacin:

Es decir Y vale 6 veces ms que X para compensar la probabilidad de victorias.

OPCIONAL CARRERA DE CABALLOS (trifecta)

Este programa simular las carreras de caballos y un jugador que elije aleatoriamente 3 caballos
ganadores en orden, y se comparar con otro vector que tiene los 3 caballos vencedores.
function trifecta_game(A)
victorias=0;
perdidas=0;
if(A<500)
display=('Ingresar una mayor cantidad de carreras >500')
X='Error';
return
end
for i=1:A
carrera=pick_nums(1:12,3);
ticket=pick_nums(1:12,3);
if(carrera(1)==ticket(1)&&carrera(2)==ticket(2)&&carrera(3)==ticket(3))
victorias=victorias+1;
else
perdidas=perdidas+1;
end
end
Resultado=[victorias perdidas];
bar(Resultado)
set(gca,'xticklabel',{'Victorias','Derrotas'});
fprintf('La probabilidad de ganar es de %d en %d\n',victorias,A)
return

Explicacin.- Primeramente el programa inicializa 2 variables victorias y perdidas en 0, de ah

verifica que el valor ingresado como parmetro A (nos indica el nmero de carreras o iteraciones)
no sea menor a 500 ya que a mayor nmero de iteraciones mas se acercar los valores medidos a los
tericos. Luego adentro de un bucle for que repetir A carreras elegimos al vector ganador carrera
y luego el jugador ticket utilizando la funcin pick_nums que tomara los 3 primeros elementos
de un vector con 12 nmeros, despus de realizar ese procedimiento adentro del argumento if
verificamos si las primeras, segundas y terceras posiciones de esos 2 vectores son idnticas, si es
cierto el contador de victorias subira en 1, caso contrario el contador de derrotas subira, al final
asignamos a otro vector los valores de victorias y derrotas para poder utilizar la funcin bar para
graficar el resultado, para terminar se imprime en pantalla la probabilidad de victoria.
= 7.2*10-4
= 8.7*10-4
= 8.1*10-4
= 8.7*10-4
= 6.88*10-4
= 7.08*10-4

La probabilidad terica de ganar una trifecta es de 1 en 1320 es decir 7.57575757*10-4, si

comparamos con los valores obtenidos en Matlab podemos observar que a mayores iteraciones se
acerca ms al valor aun que tenga un pequeo error.

OPCIONAL CARRERA DE CABALLOS (trifecta box)

Este programa simular las carreras de caballos y un jugador que elije aleatoriamente 3 caballos
ganadores sin importar el orden, y se comparar con otro vector que tiene los 3 caballos vencedores.
function trifectabox_game(A)
victorias=0;
perdidas=0;
if(A<500)
display=('Ingresar una mayor cantidad de carreras >200')
X='Error';
return
end
for i=1:A
carrera=pick_nums(1:12,3);
ticket=pick_nums(1:12,3);
contador=count_matches(carrera,ticket);
if(contador==3)
victorias=victorias+1;
else
perdidas=perdidas+1;
end
end
Resultado=[victorias perdidas];
bar(Resultado)
set(gca,'xticklabel',{'Victorias','Derrotas'});
fprintf('La probabilidad de ganar es de %d en %d\n',victorias,A)
return

Explicacin.- Primeramente el programa inicializa 2 variables victorias y perdidas en 0, de ah

verifica que el valor ingresado como parmetro A (nos indica el nmero de carreras o iteraciones)
no sea menor a 500 ya que a mayor nmero de iteraciones mas se acercar los valores medidos a los
tericos. Luego adentro de un bucle for que repetir A carreras elegimos al vector ganador carrera
y luego el jugador ticket utilizando la funcin pick_nums que tomara los 3 primeros elementos
de un vector con 12 nmeros, despus de realizar ese procedimiento luego utilizaremos la funcin
count_matches ya que nos permite verificar si existen coincidencias sin importar el orden y

agregando ese valor de coincidencias a una variable auxiliar contador si esa variable es 3 significa
que encontr 3 aciertos es decir gano por lo tanto entra a la sentencia if y aade una victoria a la
variable victorias caso contrario se aade una derrota a la variable perdidas, al final asignamos a
otro vector los valores de victorias y derrotas para poder utilizar la funcin bar para graficar el
resultado, para terminar se imprime en pantalla la probabilidad de victoria.
= 4.69*10-3
= 4.03*10-3

= 4.47*10-3
= 4.518*10-3

La probabilidad terica de ganar una trifecta box es de 1 en 220 es decir 4.54545454*10-3, si

comparamos con los valores obtenidos en Matlab podemos observar que a mayores iteraciones se
acerca ms al valor aun que tenga un pequeo error.

Sumario de la Carrera de Caballos

Cuando no importa el orden se trata de combinaciones y es lgico pensar que siempre
existirn menos combinaciones que permutaciones de una misma muestra, en este caso de los 12
caballos de los cuales se toman los 3 primeros.
En el programa de la trifecta se genero un error notable debido a que solo existen 12
caballos y al realizar vectores ordenados aleatoriamente se repiten muchos casos haciendo que se
produzca un mayor error entre el valor terico y el medido, pero mismo as si se realizan ms de 1
milln de iteraciones es muy probable que el valor se acerque ms.
En el programa de la trifecta box se produjo un menor error debido a que existan ms
posibilidades de acertar en un rango aleatorio pequeo de 12 caballos, tanto que solo fueron
necesarias 500000 iteraciones para ver como el valor converge al valor terico.

7. Conclusin
Las ideas de conteo que fueron explorados en este laboratorio se extienden en muchos otros casos.
Alguna de estas incluye (pero no estn limitadas a) sedes de comit, votaciones, cumpleaos iguales,
juego de cartas y cualquier juego virtual que puedas apostar. Estos mtodos para calcular
probabilidades pueden ser usados para explicar porque los casinos se vuelven ms ricos y los
apostadores ms pobres. Por ejemplo, la probabilidad de acertar 8 nmeros en (60,20,10) del juego
Keno es casi 768 a 1, lo que significa que 1$ que vale el ticket del Keno, debera pagar 768$ para
ganar. En la realidad solo te pagaran 100$ lo que significa que mismo que ganaras 99$, no ests
siendo pago debidamente por el risco que corres!