FigBug posted:

union is a keyword, you can't use it for a variable name.
you are missing a semicolon on line 28

ShoulderDaemon posted:

bcrules82 posted:

http://www.cplusplus.com/reference/clibrary/cstdlib/rand.html
http://www.cplusplus.com/reference/clibrary/cstdlib/srand.html
http://www.cplusplus.com/reference/clibrary/ctime/time.html

ShoulderDaemon posted:

code:

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

int main ( int argc, char *argv[] ) {

  int ret;
  int players;
  int teams;

  // Prepare the random number generator by seeding with the time.
  srandom( time( NULL ) );

  // Ask how many players are involved.
  fprintf( stdout, "How many players total? " );
  ret = fscanf( stdin, "%i\n", &players );
  assert( ret == 1 );
  assert( players <= 20 ); // If there are more than 20 players, then
                           // we will never not have duplicate rolls.

  // Ask if this is a team game.
  // Teams only make sense with an even number of players greater than 2.
  if ( players > 2 && players % 2 == 0 ) {

    char yesno;

    do { 
      fprintf( stdout, "Is this a team game? (y/n) " );
      ret = fscanf( stdin, "%c\n", &yesno );
    } while ( yesno != 'y' && yesno != 'Y' && yesno != 'n' && yesno != 'N' );

    if ( yesno == 'y' || yesno == 'Y' ) {
      teams = 1;
    } else {
      teams = 0;
    };

  } else {
    teams = 0;
  };

  int die[players];

  // This die-rolling logic is a little bit complicated...
  // I'm trying to preserve exactly the "if two people have the same roll,
  // then only they reroll" behaviour.

  // First, I set each die as "not-yet-rolled", for which I use the value -1.
  for ( int i = 0; i < players; ++i )
    die[i] = -1;

  // Now, for each player, I roll a die...
  for ( int i = 0; i < players; ++i ) {

    if ( die[i] == -1 ) {
      // This player needs to roll.
      die[i] = random( ) % 20;
      fprintf( stdout, "Player %i rolled %i.\n", i + 1, die[i] + 1 );
    };

    // Check to see if this roll is the same as any other roll before it.
    for ( int j = 0; j < i; ++j ) {

      if ( die[i] == die[j] ) {
        // These players rolled the same, so they both need to reroll.
        fprintf( stdout, "Player %i has the same roll as player %i, so they both reroll.\n", i + 1, j + 1 );
        // This is probably the subtlest part of the code I've written.
        die[i] = -1;
        die[j] = -1;
        i = j - 1;
        break; // Goes back to the outer loop.
      };

    };

  };

  // Print out the order of the players.
  // This would be better done by sorting a list of the players;
  // the algorithm I have here is equivalent to a bubble sort, but I'm
  // using it because it's simple and speed probably doesn't matter too much.
  // This is marginally subtle and kind of fun to prove why it works.

  int highest_score = 20; // Die rolls are 0..19, so this is higher than any of them.

  // This is a loop over play positions.
  for ( int i = 0; i < players; ++i ) {

    int next_highest_score = -1;
    int next_player;

    // And this is a loop over players.
    for ( int j = 0; j < players; ++j ) {

      // We are searching for the player with the largest die roll that is
      // still smaller than highest_score.
      if ( die[j] < highest_score && die[j] > next_highest_score ) {
        next_highest_score = die[j];
        next_player = j;
      };

    };

    fprintf( stdout, "Position %i: Player %i\n", i + 1, next_player + 1 );

    highest_score = next_highest_score;

  };

  // Print out the teams, if we're in team play mode.
  if ( teams ) {

    // The algorithm here mangles the die array,
    // which is why I'm doing it after printing the turn order.

    // For each team, I'm going to select the players with the highest and lowest
    // rolls that haven't yet been chosen. This loop is over teams.
    for ( int i = 0; i < players / 2; ++i ) {

      int lowest_player, lowest_roll;
      int highest_player, highest_roll;


      // Out of bounds values.
      lowest_roll = 20;
      highest_roll = -1;

      // And this loop is over players.
      for ( int j = 0; j < players; ++j ) {

        // If this player hasn't yet been chosen...
        if ( die[j] != -1 ) {

          // Check if they are the highest roll we've seen so far.
          if ( die[j] > highest_roll ) {
            highest_roll = die[j];
            highest_player = j;
          };

          // Check if they are the lowest roll we've seen so far.
          if ( die[j] < lowest_roll ) {
            lowest_roll = die[j];
            lowest_player = j;
          };

        };

      };

      // Mark the two players as chosen.
      die[highest_player] = -1;
      die[lowest_player] = -1;

      fprintf( stdout, "Team %i: Player %i and Player %i\n", i + 1, highest_player + 1, lowest_player + 1 );

    };

  };

  return 0;

}

quote:

The birthday paradox is that there is a surprisingly high probability that two people in the same room happen to share the same birthday. By birthday, we mean the same day of the year (ignoring leap years), but not the exact birthday including the birth year or time of day. Write a program that approximates the probability that two people in the same room have the same birthday, for 2 to 50 people in the room.

The program should use simulation to approximate the answer. Over many trials (say, 10,000), randomly assign birthdays to everyone in the room. Count up the number of times at least two people have the same birthday on a trial, and then divide by the number of trials to get an estimated probability that two people share the same birthday for a given room size.

Hint: Try writing a function that can search through an array for a target value, but only search up to a specified number of people.

csammis posted:

The problem's in the loops in main(). You're incrementing num_matches multiple times per trial. It only needs to be incremented once per trial, because once two people share the same birthday, the trial is a match and you can stop checking.