// Public Domain 2012 by A.Coster

// some constants for readability, using booleans to save memory
boolean ON  = 1 ;
boolean OFF = 0 ;

// Arduino pin setup - there are 3 pins used for LEDs,
// 1 for push-button. The pin at index success_led is
// the one the user should try to hit.
byte led_pins[3]       = {8,9,10} ;
byte button_pin        =    2 ;
byte success_led       =    1 ;  // refers to pin 9

// time_change is the number of milliseconds to add upon
// failure or subtract upon success.
// colorswitch_delay is the amount of time that the LED stays
// on. This value has time_change added to/subtracted from it.
// So that the user knows which LED was lit up when they hit
// the button, push_pause defines the number of milliseconds
// that the LED will stay on after the button is pressed.
unsigned int time_change       =   50 ;
unsigned int colorswitch_delay =  500 ;
unsigned int push_pause        = 2000 ;

void setup(){

    for (int i=0 ; i        pinMode( led_pins[i], OUTPUT ) ;
    }
    pinMode( button_pin, INPUT ) ;
}

void loop(){
    // need to keep track of button presses
    // so set the button state to 0 and overwrite
    // later upon button press
    boolean button_state = OFF ;

    // sequentially turn on each LED
    for ( int i=0 ; i        digitalWrite( led_pins[i], HIGH ) ;

        // Check for a button press every 5 milliseconds
        for ( int t=0 ; t            button_state = digitalRead( button_pin ) ;

            // if the button has been pressed, stop
            // switching LEDs so the user knows, and
            // then check if it was the success_led
            if ( button_state == ON ){
                delay( push_pause ) ;

                // set the button state back to off
                button_state = OFF ;
                if ( i == success_led )
                    // if the user hit the right LED,
                    // make it more challenging by
                    // reducing the delay between LED
                    // switches.
                    colorswitch_delay -= time_change ;
                else
                    // if the user was wrong, make it
                    // easier by increasing the delay.
                    colorswitch_delay += time_change ;
                    break ;
                }
            delay( 5 ) ;
        }
        // and turn it off before looping through
        // to turn the next LED on.
        digitalWrite( led_pins[i], LOW ) ;
    }
}

After trying to define the problem and find an answer mathematically, I remembered that I suck at statistical reasoning about as much as the average American. So I decided to model the problem with a short Python script and find the answer that way.

The problem: There are n people (say, at a party) drawn randomly from a population in which the chances of having a birthday on any day is equal to having a birthday on any other (which is not true of real populations (probably)). What is the probability of there being at least two people with the same birthday in the sample?

To put this thing together, I figure we need three things:

1. The ability to generate random numbers (provided by Python’s random module);
2. An object representing each person;
3. A party object full of those people.

Then we can add things like the ability to choose how many people we want at the party and how many parties to have, as well as some output for making plots!

First, the Person object. All each person needs is a birthday:

import random
random.seed()

class Person:
    def __init__( self ):
        self.birthday = random.randint( 1, 365 )

After that we need a Party object, which must be able to contain a bunch of people and check to see whether any of them have the same birthday:

class Party:
    def __init__( self, partiers ):
        self.members   = [ Person()        for p      in range(partiers) ]
        self.birthdays = [ member.birthday for member in self.members    ]
        self.check_matching_birthdays()

    def check_matching_birthdays( self ):
        birthday_frequencies = { b:0 for b in self.birthdays }
        for b in self.birthdays: birthday_frequencies[b] += 1
        for b in self.birthdays:
            if birthday_frequencies[b] < 2:
                del birthday_frequencies[b]
        self.matching_dates = len(birthday_frequencies)

Finally, we need the main() function allowing the user to choose the number of parties and attendees:

def main():
    while True:
        parties  = int(input("Number of parties:  "))
        partiers = int(input("Number of partiers: "))
        parties_with_matching_birthdays = 0

        for party in range( parties ):
            party = Party( partiers )
            if party.matching_dates:
                parties_with_matching_birthdays += 1

        print( 'Fraction of parties having at least one match:' )
        print( '   ', parties_with_matching_birthdays / parties )

main()

Putting it all together we get a simple program that allows you to answer the question given, and for any number of people. As you increase the number of parties, the variability gets smaller and smaller (and, being an inefficient program, the time taken gets longer and longer). The output I get from a few values is:

Figure 1: Frequency of finding individuals with the same birthday in groups of various sizes.

At 25 people there is already a better-than-even chance of finding two people with the same birthday, and by 50 it’s almost guaranteed! That does seem a little unbelievable, so I’ll refer you to the Wikipedia page on the topic for the math (yes, there really is a page for this).

Just to see if this little simulation would recreate what Wikipedia shows, we can modify the main() function and change it to the following:

def main():
    max_partiers      = 60
    number_of_parties = 10000
    iterations        = 3

    with open( 'birthdays.r', 'w' ) as rfile:
        # First add the variable containing each number of people.
        rfile.write( 'people = c( 1' )
        for partier in range( 2, max_partiers+1 ):
            rfile.write( ', ' + str(partier) )
        rfile.write( ')\n' )

        # Then the variables for the matches in each iteration.
        for iteration in range(iterations):
            rfile.write( 'matches' + str( iteration ) + ' = c( 0' )
            for partiers in range( 2, max_partiers+1 ):
                print( 'iteration =', iteration, 'partiers =', partiers )
                matches = 0
                for party in range( number_of_parties ):
                    party = Party( partiers )
                    if party.matching_dates:
                        matches += 1
                rfile.write( ', ' + str( matches / number_of_parties ) )
            rfile.write( ')\n' )

main()

Plotting the results in R gives:

Figure 2: Output of simulation. Plotted in R using the Cairo package.

And overlaying it onto the Wikipedia plot:

Figure 3: Overlay (using Inkscape) of simulated values (blue) on Wikipedia's calculated values (red).

]]> http://adamcoster.com/2011/07/13/python-shared-birthdays/feed/ 2 sacred atom party birthday simulation simulated_birthday overlay http://adamcoster.com/2011/04/30/mindforge-tutorial-cleartype-tuner/ http://adamcoster.com/2011/04/30/mindforge-tutorial-cleartype-tuner/#comments Sat, 30 Apr 2011 12:00:17 +0000 Adam Coster http://adamcoster.com/?p=1164 ]]> As part of the continuing closet-cleaning series: WindowsXP text is ugly and induces eye-pain and headaches. Here’s what you can do about it:

If your first thought, when reading the title of this post, was “What in the hell is a disk image?”, you probably aren’t alone. But before you decide that you don’t care enough to read on, let me quickly tell you what the big deal is so that your decision to stop reading will be an informed one!

A disk image is a virtual copy of a real disk (so a virtual CD).

That’s it. This is cool because you can make backup copies of your CDs/DVDs (though some have protections that may make this difficult), video games, operating systems, etc etc.

On top of that, you can use virtual CD-drives to play your virtual disks! This has a few advantages: [1] your computer communicates faster with your virtual disks than your real ones, and [2] you won’t have to worry about carrying CDs around ever. Of course, CDs are going the way of the Dodo, so this post may already be useless.

In any event, my middle brother and I once started a custom-PC company called Mindforge Technologies. I made a screencast tutorial for the company that shows how to use disk images, which is the Youtube video above. Enjoy!