In this exercise, we will implement a simplified Monopoly game. We will see whether and when pure luck

can create extreme inequality in wealth.

Our Monopoly game has two major components: an array of players and an array of properties. The number

of players is m and the number of properties is n$.$

The n properties are arranged in a circular fashion. The index of the properties starts from $0$ and goes to

n $1$ in a clockwise direction. Then the index goes back to $0,$ the starting point.

At the beginning of the game, all the players have n dollars as their initial balance. All the player start at

property $0,$ and players take turns according to the increasing order of their id$.$ When it is a player$$s turn,

the player tosses two dice to determine the number of steps they need to move in a clockwise direction. The

face value of the two $6-$sided dice are summed to find the number of steps. The player moves this number of

steps and lands on the corresponding property. If this property is owned by someone other than this player,

this player needs to pay rent to the owner. Otherwise, if this property has no owner yet, it will be owned by

this player. Rent increase linearly from $1$ to n between the first and final properties.

Whenever a player goes back to or passes over property $0,$ n dollars will be awarded to the player.

The game ends when a player is required to pay more money than they own. When this happens, that

player pays all of their money to the player who owns the property they just landed on$.$ At the end of the

game, we will estimate the $$inequality$$ of the players as the highest wealth divided by the average wealth.

To describe a player, we need to use the structure

typedef struct Player

$\{$

int id;

int loc;

long balance;

$\}$ TPlayer;

Here, id is in the range $0...$ m $1,$ loc is in the range $0...$ n $1,$ and balance represents the wealth

accumulated by the user.

Similarly, to describe a property, we use the following structure

$3$

typedef struct Property

$\{$

int id;

int owner$\_$id;

int rent;

$\}$ TProperty;

Here, id is in the range $0...$ n $1,$ owner id is in the range $0...$ m $1,$ and rent is the rent of the property.

Below is the main$()$ function of the program; note how we use the command line arguments. Here m is

the number of players, n is the number of properties, and rounds is the maximum rounds of game in case

the game does not end.

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

$\{$

if$($argc $!=4)$

$\{$

printf$("$Usage: $\%$s m n rounds

$",$ argv$[0])$;

return $-1$;

$\}$

int m $=$ atoi$($argv$[1])$;

int n $=$ atoi$($argv$[2])$;

int rounds $=$ atoi$($argv$[3])$;

TPlayer p$[$m$]$;

TProperty prop$[$n$]$;

for$($int i $=0$; i $$ n; i$++)$

$\{$

prop$[$i$].$id $=$ i;

prop$[$i$].$owner$\_$id $=-1$;

prop$[$i$].$rent $=$ i $+1$;

$\}$

for$($int j $=0$; j $$ m; j$++)$

$\{$

p$[$j$].$id $=$ j;

p$[$j$].$loc $=0$;

p$[$j$].$balance $=$ n;

$\}$

monopoly$($m$,$ n$,$ p$,$ prop, rounds$)$;

return $0$;

$\}$

Note how we initialize the player array p$[$m$]$ and the property array prop$[$n$].$ The owner id for each property

is set to $1$ since, at the beginning, it is not owned by any player. We use $1$ instead of $0$ because id $0$ is

the id for the first player.

We need to implement the following function.

$//$Implement the following function

void monopoly$($int m$,$ int n$,$ TPlayer p$[],$ TProperty prop$[],$ int max$\_$rounds$)$

$\{$

$4$

srand$(12345)$;

int rounds $=1$;

$//$The following line of code is needed for correct output

print$\_$result$($m$,$ p$)$;

printf$("$after $\%$d rounds

$",$ rounds$)$;

$\}$

Below are outputs from a few sample runs. We can use these outputs to check our code.

$ $./$monopoly $15100100000$

id balance

$067$

$195$

$2204$

$3244$

$4102$

$5228$

$60$

$772$

$833$

$90$

$1054$

$1127$

$1276$

$1318$

$14280$

average: $100\mathrm{.}000000$ max: $280,$ max$/$average $=2\mathrm{.}800000$

after $5$ rounds

$ $./$monopoly $20100100000$

id balance

$0340$

$1200$

$2203$

$3260$

$474$

$5137$

$6199$

$768$

$840$

$90$

$1039$

$1146$

$1216$

$13137$

$1447$

$1556$

$1628$

$5$

$1715$

$1857$

$1938$

average: $100\mathrm{.}000000$ max: $340,$ max$/$average $=3\mathrm{.}400000$

after $5$ rounds#include $$stdio$.$h$>$

#include $$stdlib$.$h$>$

#include $mnmnp[]i=0i$;