Descriptiоn оf the Prоgrаm to Write Let us consider the following structure definitions: /* A Plаyer structure represents the informаtion about a single player for an arcade game cabinet.*/struct player { char* nickname; // Nickname of the player int score; // Number of points scored on this arcade game}; typedef struct player Player;/* A ScoreBoard contains the information about all the players and their respective scores.*/struct board { Player* players; int numberOfPlayers; // current # of players which scores are kept in this ScoreBoard int maxNumberOfPlayers; // maximum # of players that this ScoreBoard can contain};typedef struct board ScoreBoard; In this code, a ScoreBoard holds a link to a dynamical array of Player structures which size is specified by maxNumberOfPlayers. Each Player element holds information about the nickname of the player (as a char*) as well as their score (as an int). We want to implement functions that are going to allow us to allocate and deallocate memory for a ScoreBoard structure, including all the Player structures inside of its dynamical array. The prototypes of the functions, and a summary of what they must accomplish, is as follows: Player* players_allocate(int size);/* This function returns the address of a dynamically allocated array of Player. The size of this array is specified by the parameter size. Each of the Player in the array has a default score of 0 points and a nickname set to NULL */void players_deallocate(Player* ptr, int numberOfPlayers);/* This function deallocates the whole dynamical array of Player but also makes sure that every Player had first its nickname field deallocated (if it is not NULL).*/ScoreBoard* scoreboard_allocate(int size);/* This function returns the address of a dynamically allocated ScoreBoard that has its maxNumberOfPlayers field initialized to the value of the parameter size, and its players field initialized with the help of the players_allocate function that was previously defined. */ void scoreboard_deallocate(ScoreBoard* ptr);/* This function deallocates the ScoreBoard structure located at the address specified by the parameter ptr. To this end, it also makes use of the players_deallocate function previously defined. */ In addition to these allocation and deallocation functions, you will also implement a function that will allow you to add information about the nickname and score of a Player in the dynamically allocated array of a ScoreBoard. As you do so, you will also make sure to update its numberOfPlayers field to reflect that there is an additional Player now stored in the ScoreBoard. You will also return without doing anything once the numberOfPlayers has reached the maxNumberOfPlayers. void scoreboard_add(ScoreBoard* ptr, char* playerNickname, int playerScore);/* This function adds information about a new Player with nickname playerNickname and score playerScore to an already allocated ScoreBoard referred to by ptr. To store the nickname and score, you will use the first element of the array referred to by the field players that has a NULL value for its nickname. If no such element is available, which also means numberOfPlayers has reached maxNumberOfPlayers, simply do nothing and return. Please note that you will use the standard strdup method in order to duplicate playerNickname and assign the address of this duplicate to the field nickname in your structure.*/ Last but not least, you will also implement a function to display the contents of a ScoreBoard. Please note that it might be relevant to implement this function earlier in order to be able to test out the scoreboard_add method previously mentioned. void scoreboard_display(ScoreBoard* ptr);/* This function displays all the information stored in a ScoreBoard which address is specified by the parameter ptr. An example of the output is given in the instructions of this final exam. */ Upload a .c source file containing the implementation of all the above functions. In addition, you will use the following main method to test your functions (Feel free to change the nicknames and scores of the players of our ScoreBoard. int main(){ ScoreBoard* ptr = scoreboard_allocate(MAXSIZE); scoreboard_add(ptr, "Parzival", 110000); scoreboard_add(ptr, "Art3mis", 109000); scoreboard_add(ptr, "Hech", 108000); scoreboard_add(ptr, "Daito", 107000); scoreboard_add(ptr, "Sho", 106000); scoreboard_display(ptr); scoreboard_deallocate(ptr); return EXIT_SUCCESS;} Example of Execution Displaying ScoreBoard with 5 Players: #1 (110000 points) "Parzival" #2 (109000 points) "Art3mis" #3 (108000 points) "Hech" #4 (107000 points) "Daito" #5 (106000 points) "Sho" Please note the following: We use tabulations (‘t’) If the score of a player is 1 point there is no ‘s’ at the end of ‘points’ We display double quotes around the nicknames of the players Grading Criteria: Rubric # Pts Additional Grading Notes The program compiles without compilation errors or warnings 3 Deduct 1 point per minor compilation error (e.g., typo, forgotten semi-colon, forgotten or extra curly braces or parentheses). If the program does not compile due to too many errors or due to an error that is non-trivial to fix (see above), then the whole assignment receives zero points. The program executes without crashing at runtime 3 Deduct one point for each use case that leads the program to crash (maximum 3) players_allocate 3 3 – Implemented according to requirements 2 – Mostly properly implemented 1 – Not properly implemented 0 – not implemented players_deallocate 3 3 – Implemented according to requirements 2 – Mostly properly implemented 1 – Not properly implemented 0 – not implemented scoreboard_allocate 3 3 – Implemented according to requirements 2 – Mostly properly implemented 1 – Not properly implemented 0 – not implemented scoreboard_deallocate 3 3 – Implemented according to requirements 2 – Mostly properly implemented 1 – Not properly implemented 0 – not implemented scoreboard_add 3 3 – Implemented according to requirements 2 – Mostly properly implemented 1 – Not properly implemented 0 – not implemented scoreboard_display 3 3 – Implemented according to requirements 2 – Mostly properly implemented 1 – Not properly implemented 0 – not implemented Total 24
Given the recurrence relаtiоn F(n) = n F(n-1) + n(n+1), with F(0) = 1, cоmpute F(4).