Final Theory Of Everything V5.0

Discussion in 'C Programming' started by CoreyWhite@gmail.com, Sep 23, 2006.

  1. Guest

    /*
    It is possible to use martingale probability theory to beat some games
    of chance. In a fair game of coin toss, where the odds reach an
    equilibrium of 50/50 chain reactions do occur. This can be explained
    using martingale probability theory, but in simpler terms it only shows
    an example of how order emerges out of chaos.

    Example: One player has 3 pennies, and another player has only 1 penny.
    A fair coin is tossed every round to determine if a penny is won or
    lost for either player. The odds are 3/4 that player A (Who begins with
    3 pennies) will win the game. This is entirely different than the
    martingale betting strategy, because only 1 penny is bet for each round
    of the game.

    Because there are 3 ways player A may win, and only one way player B
    can win, player A has a concrete advantage. Player B, only wins in the
    event that the coin is tossed in his favor 3 times in a row, while
    player A can win on the first throw. Or he can win after losing the
    first coin toss, or he can win after losing the second coin toss. So
    the odds are 75% that he (or she) will win in this game.

    Upon further analysis it is possible to calculate the average number of
    coin flips before player A is likely to win. The equation k(n-k) works
    for perfectly fair games according to martingale probability theory to
    solve this problem. In this case 3(4-3) solves the problem, so on
    average it takes 3 coin flips for player A to win.

    To show that chain reactions occur you only have to move from the
    probability of winning the first game, and multiply it by the
    probabilities of winning the following games. For example, if 3 pennies
    are used to play this game in an attempt to win one penny, the odds are
    3/4. And once that penny is collected there is now a 4/5th chance of
    winning another penny.

    So statistics tells us that there is a (3/4) * (4/5) * (5/6) * (7/8) *
    (8/9) * (9/10) = 30% chance of the 3 pennies growing into a pile of 10.

    But in repeatable tests you will find that on average there is not a
    net win or loss in this game. If there is a 75% chance of winning 1
    penny, and a 25% chance of losing 3. The two odds cancel each other
    out, to create an equilibrium in 50/50 games.

    And at the same time we can see that despite the fact that the initial
    value of coins reaches an equilibrium when the pattern is extended to
    any length, we can show a concrete advantage to beginning with 3
    pennies, instead of beginning with one.

    In the last example player A had a 30% chance of winning 7 pennies, and
    totaling 10 in all. If we started with only one penny then player A
    would just have to total 8 pennies in order to earn 7. So lets look at
    the math:

    (1/2) * (2/3) * (3/4) * (4/5) * (5/6) * (6/7) * (7/8) = 12.5%

    So we can cleary see that even though winning 7 pennies has the same
    expected value as losing 1 penny. Outside of repeatable tests the odds
    of earning 7 pennies is clearly higher if you begin with 3.

    I can also explain the laws of nature with these prinicples. If we
    look at the equation for gravity on earth, which accelerates at 9.8 m/s
    we can derive an acceptable answer from the earlier equations. The
    gravity equation I am using is sqrt(2*n/9.8).

    In this example we are dropping a ball from 4.9 meters, and you can see
    it takes one second to land.

    t = sqrt( ( 2(4.9 m) ) / ( 9.8 m/s^2 ) ) = 1 s

    So here is my gravity theory. We are using the quadratic formula to
    solve: 2*n/9.8 = k(n-k) , for k. (The formula k(n-k) finds the average
    number of coin flips).

    k=(1/14) (7n +- sqrt(49 n^2 - 40 n)).


    So now an example...


    We are dropping a ball from 10 meters above the ground. So we plug 10
    meters into n to solve for k.


    k=(1/14) (7n +- sqrt(49 n^2 - 40 n))
    k=9.791574237


    My question to calculate the average number of coin flips in my game is

    k(n-k), so we plug in k & n:


    k*(10-k) = 2.040816327 = average number of coin flips


    Now we take the square root of the average number of flips to get the
    actual time it takes to land:


    sqrt(avg flips) = 1.428571429 = number of seconds to land.


    Now finally to factor in a problem with my equation we say that if k is
    9.791574327, that means our large gravity pile is that many pennies.
    And our small gravity pile is exactly 0.208425673 pennies!

    Now for the source code. You can actually prove everything I have
    written by running a few simple test cases. In the program when you
    set the initial beans to 5, and set 1, 2, 3, 4, or 5 beans as your
    goal, the output should look like this:

    5:1 = 83.5%

    5:2 = 71.6%

    5:3 = 62.6%

    5:4 = 56.1%

    5:5 = 50%

    But if you only play with 5 beans every time and only go after 1 bean
    with those 5 each game, then your output will look like this;

    5:1 = 83.5%

    5:1 X 5:1 = 69%

    5:1 X 5:1 X 5:1 = 58%

    5:1 X 5:1 X 5:1 X 5:1 = 48%

    5:1 X 5:1 X 5:1 X 5:1 X 5:1 = 40%

    So there is all the proof you need. Which experiment would you rather
    play?

    Another experiment you can try:

    Modify the program to run 10,000,000. Starting with 3 beans each time
    with a target of 5000. You will win 5000 beans 273 times, for winnings
    of 1,365,000 beans in total. And you would lose 3 beans 443323 times
    for a loss of 1,329,969 beans. So you ended up 35,031 beans ahead.

    Try changing the seed and you will still be ahead in the long run.

    Even if you play 100 million games you will still be ahead.

    */


    .. #include <stdio.h>
    .. #include <stdlib.h>
    ..
    ..
    .. main ()
    .. {
    .. double r;
    .. long int M;
    .. double x;
    .. int y;
    .. int z;
    .. int count;
    ..
    ..
    .. int seed = 10000;
    .. printf("Enter seend for RNG: ");
    .. scanf("%d", &seed);
    .. srand (seed);
    .. M = 2;
    ..
    ..
    .. int score = 0;
    ..
    .. //Score keeps track of the number of beans won every game
    ..
    ..
    .. int games = 0;
    ..
    .. // games keeps track of the number of games we have played before
    .. //losing all of the beans, which is equal to score.
    ..
    ..
    .. int beans1 = 0;
    ..
    .. // Initial value set to zero and defined within the loop
    ..
    .. int wins = 0;
    .. int lost = 0;
    .. int quit = 0;
    .. int init = 0;
    .. int rounds = 0;
    .. int live = 0;
    ..
    .. printf ("Initial Beans: ");
    .. scanf ("%d", &init);
    .. printf ("Stop after winning X number of beans: ");
    .. scanf ("%d", &quit);
    .. printf ("Number of rounds: ");
    .. scanf("%d", &rounds);
    .. printf("Show live output (1 or 0): ");
    .. scanf("%d", &live);
    ..
    .. for (int cnt = 0; cnt < rounds; cnt++)
    .. {
    .. // We play up to (int) rounds
    ..
    ..
    .. int count = 0;
    .. beans1 = init + score;
    ..
    .. // Beans gets defined here, as starting with 3 beans
    .. // and having a 0 bonus score (It changes as you
    .. // win more beans per round)
    ..
    ..
    .. int beans2 = 1;
    ..
    .. // The program attempts to win just one
    .. // bean for every game.
    ..
    ..
    .. while (beans1 != 0 && beans2 != 0)
    ..
    .. // The battle begins
    ..
    ..
    .. {
    .. r = ((double) rand () / ((double) (RAND_MAX) + (double) (1)));
    ..
    ..
    .. x = (r * M);
    .. y = (int) x;
    ..
    .. z = y + 1;
    ..
    .. // A coin is flipped and is either 1 or 2 in value
    ..
    .. if (z == 1)
    .. {
    .. // Heads wins.
    ..
    .. beans1++;
    ..
    .. // Beans1 gains one bean from Beans2
    ..
    .. beans2--;
    .. }
    .. if (z == 2)
    .. {
    .. // Tails loses
    ..
    .. beans1--;
    ..
    .. // Beans2 gains one bean from Beans1
    ..
    .. beans2++;
    .. }
    ..
    .. count++;
    ..
    .. // We keep track of the number of rounds in the battle
    ..
    .. }
    ..
    ..
    .. if (beans1 > score + init)
    .. {
    .. // If beans1 is greater than the initial value
    .. // of beans plus the total number of beans
    .. // that have been won so far in this game, then
    .. // the score goes up, and we go on to the next
    .. // game. We check this at the end of every game.
    ..
    .. score++;
    ..
    .. games++;
    .. }
    ..
    .. if (beans1 <= 0)
    .. {
    .. //If beans1 has lost the game and doesn't
    .. //have anymore beans then we know the
    .. //game is over, so we reset score, and reset
    .. //games.
    ..
    ..
    .. if(live==1){
    .. printf ("Lost at: %d beans , %d games.\n", score + init, games);
    .. }
    ..
    .. // And we print out the total number of
    .. // games played on this trial and show the
    .. // total score plus the initial value of beans.
    ..
    .. lost++;
    .. score = 0;
    .. games = 0;
    ..
    .. }
    ..
    .. if (score >= quit)
    .. {
    .. wins++;.
    ..
    .. if(live==1){
    .. printf ("Won at: %d beans , %d games.\n", score + init, games);
    .. }
    ..
    .. beans1 == 0;
    .. score = 0;
    .. games = 0;
    ..
    .. }
    ..
    .. }
    ..
    .. printf ("Total Won: %d/%d\n", wins, wins + lost);
    .. printf ("Net win: %d beans.\n",(wins*quit)-( (wins+lost)*init ) );
    ..
    .. }
     
    , Sep 23, 2006
    #1
    1. Advertising

  2. Richard Bos Guest

    wrote:

    Good Cthulhu... this guy goes from version 2.0 to 5.0 within four and a
    half hours. He's even better than Microsoft!

    Richard
     
    Richard Bos, Oct 2, 2006
    #2
    1. Advertising

  3. John F Guest

    Richard Bos wrote:
    > wrote:
    >
    > Good Cthulhu... this guy goes from version 2.0 to 5.0 within four
    > and
    > a half hours. He's even better than Microsoft!
    >
    > Richard


    Is there any noticeable change in functionality or is it just bug
    fixes which would normally make a minor version change? :) What I
    found interesting is the implementation in C to make it look like it
    was on topic in this group... I guess I'll have a look at the code :)

    --
    Johannes
    You can have it:
    Quick, Accurate, Inexpensive.
    Pick two.
     
    John F, Oct 2, 2006
    #3
  4. John F Guest

    John F wrote:
    > Richard Bos wrote:
    >> wrote:
    >>
    >> Good Cthulhu... this guy goes from version 2.0 to 5.0 within four
    >> and
    >> a half hours. He's even better than Microsoft!
    >>
    >> Richard

    >
    > Is there any noticeable change in functionality or is it just bug
    > fixes which would normally make a minor version change? :) What I
    > found interesting is the implementation in C to make it look like it
    > was on topic in this group... I guess I'll have a look at the code
    > :)



    My version... moslty lint-clean (no critical stuff... just moaning
    around :) I did not check functionality. I just corrected some typos.
    == -> =, 2 -> 2L and so on.

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

    void clearbuffer(void)
    { /* cleanup after scanf */
    while(getchar()!=(int)'\n');
    /*is this cast correct? I guess not :) */
    }

    int main (void)
    {
    double r;
    long int M;
    double x;
    int y;
    int z;
    int count;

    int score = 0;

    //Score keeps track of the number of beans won every game


    int games = 0;

    // games keeps track of the number of games we have played before
    //losing all of the beans, which is equal to score


    int beans1 = 0;

    // Initial value set to zero and defined within the loop

    int wins = 0;
    int lost = 0;
    int quit = 0;
    int init = 0;
    int rounds = 0;
    int live = 0;
    int cnt;

    unsigned int seed = 10000u;
    printf("Enter seend for RNG: ");
    (void) scanf("%ud", &seed);
    clearbuffer();
    srand (seed);
    M = 2L;



    printf ("Initial Beans: ");
    (void) scanf ("%d", &init);
    clearbuffer();
    printf ("Stop after winning X number of beans: ");
    (void) scanf ("%d", &quit);
    clearbuffer();
    printf ("Number of rounds: ");
    (void) scanf("%d", &rounds);
    clearbuffer();
    printf("Show live output (1 or 0): ");
    (void) scanf("%d", &live);
    clearbuffer();

    for (cnt = 0, count=0; cnt < rounds; cnt++)
    {
    // We play up to (int) rounds

    int beans2 = 1;

    beans1 = init + score;

    // Beans gets defined here, as starting with 3 beans
    // and having a 0 bonus score (It changes as you
    // win more beans per round)



    // The program attempts to win just one
    // bean for every game


    while (beans1 != 0 && beans2 != 0)

    // The battle begins


    {
    r = ((double) rand () / ((double) (RAND_MAX) + (double)
    (1)));


    x = (r * M);
    y = (int) x;

    z = y + 1;

    // A coin is flipped and is either 1 or 2 in value

    if (z == 1)
    {
    // Heads wins

    beans1++;

    // Beans1 gains one bean from Beans2

    beans2--;
    }
    if (z == 2)
    {
    // Tails loses

    beans1--;

    // Beans2 gains one bean from Beans1

    beans2++;
    }

    count++;

    // We keep track of the number of rounds in the battle

    }


    if (beans1 > score + init)
    {
    // If beans1 is greater than the initial value
    // of beans plus the total number of beans
    // that have been won so far in this game, then
    // the score goes up, and we go on to the next
    // game We check this at the end of every game

    score++;

    games++;
    }

    if (beans1 <= 0)
    {
    //If beans1 has lost the game and doesn't
    //have anymore beans then we know the
    //game is over, so we reset score, and reset
    //games


    if(live==1)
    {
    printf ("Lost at: %d beans , %d games\n", score +
    init, games);
    }

    // And we print out the total number of
    // games played on this trial and show the
    // total score plus the initial value of beans

    lost++;
    score = 0;
    games = 0;

    }

    if (score >= quit)
    {
    wins++;

    if(live==1)
    {
    printf ("Won at: %d beans , %d games\n", score + init,
    games);
    }

    beans1 = 0;
    score = 0;
    games = 0;

    }

    }

    printf ("Total Won: %d/%d\n", wins, wins + lost);
    printf ("Net win: %d beans\n",(wins*quit)-(wins+lost)*init);

    getchar();
    return EXIT_SUCCESS;
    }

    --
    Johannes
    You can have it:
    Quick, Accurate, Inexpensive.
    Pick two.
     
    John F, Oct 2, 2006
    #4
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. JFCM
    Replies:
    4
    Views:
    5,780
  2. Final Theory Of Everything V1.0

    , Sep 19, 2006, in forum: C Programming
    Replies:
    5
    Views:
    302
    David Harmon
    Sep 19, 2006
  3. Final Theory Of Everything V2.0

    , Sep 19, 2006, in forum: C Programming
    Replies:
    5
    Views:
    309
    Ancient_Hacker
    Sep 20, 2006
  4. Final Theory Of Everything V6.0

    , Sep 24, 2006, in forum: C Programming
    Replies:
    1
    Views:
    301
    Mabden
    Oct 1, 2006
  5. Replies:
    5
    Views:
    294
    David Harmon
    Sep 19, 2006
Loading...

Share This Page