Máquina de Galton Dinámica

MaqGalton.c

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

int main(){

   // "i & j" son variables unicamente utlizadas para el control de ciclos
   // "r" es una variable usada para ver a donde se moverán las pelotas [un numero Random, de ahi la 'r']
   // "n_pelotas & n_niveles" son el # de pelotas que van a caer en la MaqdGalton y los niveles de la misma, respectivamente.
   // "alfiler" hace referencia al lugar en donde van a pegar las pelotas en la MaqdGalton
   // "lim_izq" es el ultimo alfiler de la parte izq de la MaqdGalton utilizada para reducir los contadores

   int i, j, r, n_pelotas, n_niveles, alfiler, lim_izq;

   printf("Numero de niveles de la Maq de Galton: ");
   scanf("%d",&n_niveles);
   printf("Numero de bolas: ");
   scanf("%d",&n_pelotas);

   //Suponiendo que el alfiler #1 fuera el pico de la piramide de alfileres, podemos decir que el siguiente a la derecha es el #2.
   //Por comodidad se dice que entonces el siguiente a la izquierda es el #0. Siguiendo con la idea, el último alfiler izquierdo viene siendo
   // Num de niveles - 2 <- negativo, es -2 ya que empezamos a contar desde el 1.
   lim_izq = n_niveles*-1 + 2;

   //Ahora bien, cada alfiler de la ultima fila de la piramide tiene la posibilidad de mandar una pelota a uno de dos canales.
   //Si el primer alfiler izquierdo mete pelotas al canal 0 o 1, el segundo alfiler mete pelotas en 1 o 2, y así sucesivamente.
   //Se puede apreciar que el ultimo alfiler mete pelotas a los canales #Niveles-1 y #Niveles, por lo tanto,
   //se genera el # de canales, siendo este = #Niveles + 1 [0 - #Niveles]. Luego se inicializa en 0's.
   int canales[n_niveles+1];
   for(i=0; i<n_niveles+1; i++)
      canales[i] = 0;

   //Posteriormente se realiza la simulación de la caida de las pelotas
   for(i=0; i<n_pelotas; i++){
      //Alfiler de origen
      alfiler = 1;
      //Nos movemos n_nivel veces en la maq
      for(j=0; j<n_niveles; j++){
      	//En cada nivel debemos ver hacia que direccion cae la pelota
         r = rand() % 2;
         //Si r es 1, se mueve a la derecha, de lo contrario, se mueve a la izquierda
         if(r) alfiler++;
         else alfiler--;
         //Bajo la idea de que las dimensiones de la MaqdGalton son exactas, se sabe que sin importar la direccion en que vaya, caera sobre otro alfiler
         //Es por ello que nos movemos n_nivel veces en el ciclo, cada iteración siendo un nivel y una posibilidad
      }
      //Debido a que se presentan numeros negativos, debemos volverlos positivos con el fin de facilitar el saber en donde caera la pelota
      //Por lo tanto, se convierten todos los alfileres a # positivos
      alfiler += (lim_izq*-1);
      //Una vez realizado lo anterior nos podemos dar cuenta que los alfileres son positivos y ademas son multiplos de dos, y tambien que,
      //si se dividen dichos numeros entre dos, se tiene el numero de canal izquierdo de cada alfiler, asi que pasamos a quitar el excedente
      alfiler /= 2;

      //Por ultimo, realizamos una vez mas la simulacion de movimiento, ya que con el ciclo llegamos unicamente hasta la ultima fila de alfileres
      //aun falta ver en que canal va a caer, por lo que hacemos la simulacion
      r = rand() % 2;
      //Si r es 1, va a caer en el canal derecho, por lo que tenemos que sumar 1 al valor del canal, de lo contrario, caera en el canal izquierdo, calculado anteriormente
      if(r) canales[alfiler+1]++;
      else canales[alfiler]++;
   }
   //Por ultimo imprimimos el numero de pelotas en cada canal.
   for(i=0; i<n_niveles+1; i++)
      printf("Canal %d: %d\n",i,canales[i]);
   return 0;
}