Lesson 9.6. Exercises on C arrays

Exercises

Exercise 1

Write a function average() that receives 3 arrays as parameters. The function computes the individual averages of the first two arrays (one average for each row of the arrays). The averages are stored in the third array. Compute and display the average of arrays grades1 and grades2 :

grade[0]    = 10.10
grade[1]    = 11.25
grade[2]    = 14.25
grade[3]    = 9.90
grade[4]    = 11.60
grade[5]    = 11.05

#include <stdio.h> // Number of grades #define NB_GRADES 6 // Display grades void display(const float notes[], int size); // Initialize each cell of grades to value void init(float grades[], int size, float value); // Compute average of arrays // COMPLETE HERE int main(void) { // Arrays float grades1[NB_GRADES] = {10.2, 12.5, 18.5, 9.8, 13.2, 12.1}; float grades2[NB_GRADES]; float averages[NB_GRADES]; // Initialize each cell of notes2 to 10 init(grades2, NB_GRADES, 10); display(grades2, NB_GRADES); // Get average of grades1 and grades 2 // COMPLETE HERE // Display averages display(averages, NB_GRADES); return 0; } // Initialize each cell of grades to value // COMPLETE HERE // Initialize each cell of grades to value void init(float grades[], int size, float value) { int i; for (i=0;i<size;i++) grades[i]=value; } // Display grades void display(const float grades[], int size) { int i; for (i=0;i<size;i++) printf ("grade[%d]\t= %.2f\n", i, grades[i]); }

Exercise 2

Write a function globalAverage() that receives an array as parameters and returns the mean of this array. Using the function, calculate and display the average of the array grades1 :

Average: 12.72

#include <stdio.h> // Number of grades #define NB_GRADES 6 // Display grades void display(const float grades[], int size); // Return the average of an array // COMPLETE HERE int main(void) { // Array float grades1[NB_GRADES] = {10.2, 12.5, 18.5, 9.8, 13.2, 12.1}; // Compute and display the average // COMPLETE HERE return 0; } // Return the average of an array // COMPLETE HERE // Display grades void display(const float grades[], int size) { int i; for (i=0;i<size;i++) printf ("grade[%d]\t= %.2f\n", i, grades[i]); }

Exercise 3

Write a function void copy(const float src[], float dest[], int size); which receives 2 arrays as parameters. This function copies all the values of the array src into dest. With this function, copy the array grades1 into grades2. Check by displaying grades2 :

grade[0] = 10.20
grade[1] = 12.50
grade[2] = 18.50
grade[3] = 9.80
grade[4] = 13.20
grade[5] = 12.10

#include <stdio.h> // Number of grades #define NB_GRADES 6 // Display grades void display(const float grades[], int size); // Copy the array src in dest void copy(const float src[], float dest[], int size); int main(void) { // Arrays float grades1[NB_GRADES] = {10.2, 12.5, 18.5, 9.8, 13.2, 12.1}; float grades2[NB_GRADES]; // Copy grades1 in grades 2 // and display grades2 // COMPLETE HERE return 0; } // Copy the array src in dest // COMPLETE HERE // Display grades void display(const float grades[], int size) { int i; for (i=0;i<size;i++) printf ("grade[%d]\t= %.2f\n", i, grades[i]); }

Exercise 4

Write a function int compare(const float t1[], const float t2[], int size); which receives 2 arrays as parameters. This function counts the number of elements with the same index and the same value in both arrays. Test the function with the following arrays:

  float grades1[NB_NOTES] = {10.2, 12.5, 18.5, 9.8, 13.2, 12.1};
  float grades2[NB_NOTES] = {15.7, 12.5, 15.3, 9.8, 10.8, 12.1};

There are 3 identical grades.

#include <stdio.h> // Number of grades #define NB_GRADES 6 // Display grades void display(const float grades[], int size); // Return the number of identical cells in t1 and t2 int compare(const float t1[], const float t2[], int size); int main(void) { // Arrays float grades1[NB_GRADES] = {10.2, 12.5, 18.5, 9.8, 13.2, 12.1}; float grades2[NB_GRADES] = {15.7, 12.5, 15.3, 9.8, 10.8, 12.1}; // Count and display the number of identical grades // COMPLETE HERE return 0; } // Return the number of identical cells in t1 and t2 // COMPLETE HERE // Display grades void display(const float grades[], int size) { int i; for (i=0;i<size;i++) printf ("grade[%d]\t= %.2f\n", i, grades[i]); }

Exercise 5

Write a function equal() that receives 2 arrays as parameters. This function returns :

• 1 if both arrays are strictly identical;
• 0 otherwise.
• Compare the arrays grades1 and grades2 before and after copying :

Before copy : arrays are different.
After copy  : the arrays are identical.

#include <stdio.h> // Number of grades #define NB_GRADES 6 // Display grades void display(const float grades[], int size); // Copy the array src in dest void copy(const float src[], float dest[], int size); // Returns 1 if arrays are identicals // COMPLETE HERE int main(void) { // Arrays float grades1[NB_GRADES] = {10.2, 12.5, 18.5, 9.8, 13.2, 12.1}; float grades2[NB_GRADES]; // Check if arrays are identicals before copy // COMPLETE HERE // Copy grades1 into grades2 // COMPLETE HERE // Check if arrays are identicals after copy // COMPLETE HERE return 0; } // Returns 1 if arrays are identicals // COMPLETE HERE // Copy the array src in dest void copy(const float src[], float dest[], int size) { int i; for (i=0;i<size;i++) dest[i]=src[i]; } // Display grades void display(const float grades[], int size) { int i; for (i=0;i<size;i++) printf ("grade[%d]\t= %.2f\n", i, grades[i]); }

Exercise 6

Write a maxTab() function that receives an array and its size as parameters. The function returns the largest value of the array.

int maxTab(int tab[], int size);

The largest value of the array is: 98

#include <stdio.h> // Array size #define SIZE 8 // Return the maximum value of the array tab int maxTab(int tab[], int size); int main(void) { // Create an array int tab[SIZE] = {12, 5, 8, 18, 3, 98, 0, 16}; printf ("The largest value of the array is: %d\n", maxTab(tab, SIZE)); return 0; } int maxTab(int tab[], int size) { // Create a variable max // which is the largest known value of the array // At the beginning, we initialize max with the first value (tab[0]) // COMPLETE HERE // We iterate through all the cells of the array // If a cell is bigger than max, // Update max with the new maximum // COMPLETE HERE // Return max, the largest value in the array // COMPLETE HERE }

Exercise 7

Write a function argmax() that receives an array and its size as parameters. The function returns the first index of the smallest element of the array.

int argmax(int tab[], int size);

The first index of the smallest element of the array is: 2

#include <stdio.h> // Array size #define SIZE 8 // Function that returns the first index of the smallest value of an array int argmax(int tab[], int size); int main(void) { // Create an array int tab[SIZE] = {12, 5, 8, 18, 3, 98, 0, 16}; printf ("The first index of the smallest element is: %d\n", argmax(tab, SIZE)); return 0; } // Function that returns the first index of the smallest value of an array int argmax(int tab[], int size) { // Declare the variable imax // imax represents the index of the smallest element // Initialize imax to 0 (first cell) // COMPLETE HERE // We browse all the cells of the array // If a cell is smaller than tab[imax], // Update imax with the new index // COMPLETE HERE // Return imax, the index of the smallest cell // COMPLETE HERE }

Exercise 8

Write a sort() function that receives an array and its size as parameters. The function sorts the array in ascending order.

void sort(int tab[], int size);

To do this exercise, you can use by the bubble sort, whose algorithm is presented on the page Wikipedia. Here is the result of the sort:

Initial array : 12 54  0 18  8 98  5 16 58  4 75  5 
Sorted array  :  0  4  5  5  8 12 16 18 54 58 75 98 

#include <stdio.h> // Array size #define SIZE 12 // Display an array void display(const int tab[], int size); // Sort array in ascending order void sort(int tab[], int size); int main(void) { // Déclaration et initialisation d'un tableau int tab[SIZE] = {12, 54, 0, 18, 8, 98, 5, 16, 58, 4, 75, 5}; // Display the initial array printf ("Initial array: "); display(tab, SIZE); // Sort array sort (tab, SIZE); // Display the sorted array printf ("Sorted array : "); display(tab, SIZE); return 0; } // Display an array void display(const int tab[], int size) { for (int i=0 ; i<size ; i++) printf ("%2d ", tab[i]); printf ("\n"); } // Sort array in ascending order void sort(int tab[], int size) { // COMPLETE HERE }

See also

• Learn C programming
• Lesson 1.1. History of C programming language
• Lesson 1.2. First program
• Lesson 1.3. Compilation
• Lesson 1.4. Preprocessor directives
• Lesson 1.5. Which compiler to choose?
• Lesson 1.6. Flowchart
• Lesson 2.1. Types and variables
• Lesson 2.2. Integers
• Lesson 2.3. Floating point numbers
• Lesson 2.4. Characters
• Lesson 2.5. Variables initialization
• Lesson 2.6. Ariane flight 501
• Lesson 3.1. Arithmetic operators
• Lesson 3.2. modulo
• Lesson 3.3. Operators and types
• Lesson 3.4. Type casting
• Lesson 3.5. Bitwise operators
• Lesson 3.6. Bitwise operators details
• Lesson 3.7. Shifting operators
• Lesson 3.8. Assignment operators
• Lesson 3.9. Increment and decrement operators
• Lesson 3.10. Comparison operators
• Lesson 3.11. Logical operators
• Lesson 3.12. Operator precedence
• Lesson 4.1. printf
• Lesson 4.2. scanf
• Lesson 4.3. putchar
• Lesson 5.1. Conditional branching (if...else)
• Lesson 5.2. Nested if and indentation
• Lesson 5.3. Checking intervals
• Lesson 5.4. Ternary Operator ?:
• Lesson 5.5. switch..case statement
• Lesson 5.6. Break keyword in switch..case
• Lesson 6.1. do..while loop in C
• Lesson 6.2. While loop in C
• Lesson 6.3. For loop in C
• Lesson 6.4. How to choose the right loop in C ?
• Lesson 6.5. Exercices on loops in C
• Lesson 7.1. Bit masking
• Lesson 7.2. Bit masking, how to clear a bit in C?
• Lesson 7.3. Bit masking, how to set a bit in C?
• Lesson 7.4. Bit masking, how to toggle a bit in C?
• Lesson 7.5. Bit masking, how to check a single bit in C?
• Lesson 7.6. Overview of bit masking
• Lesson 8.1. Basic syntax of C functions
• Lesson 8.2. Calling C functions
• Lesson 8.3. Void keyword
• Lesson 8.4. Return keyword
• Lesson 8.5. Variable scope
• Lesson 8.6. Global variables
• Lesson 8.7. Static variables
• Lesson 8.8. Random numbers in C
• Lesson 8.9. Mathematical functions in C
• Lesson 9.1. Syntax of C arrays
• Lesson 9.2. Array initialization
• Lesson 9.3. Multidimensional arrays
• Lesson 9.4. How C arrays are stored in memory?
• Lesson 9.5. Arrays and functions
• Lesson 10.1. Strings in C
• Lesson 10.2. Null terminated string
• Lesson 10.3. The string.h library
• Lesson 10.4. String and functions
• Lesson 11.1. Introduction to pointers in C
• Lesson 11.2. Syntax of C pointers
• Lesson 11.3. Dynamic memory allocation
• Lesson 11.4. Incrementing pointers
• Lesson 11.5. Pointers as function argument in C
• Lesson 12.1. Introduction to structures in C
• Lesson 12.2. Properties of structures in C
• Lesson 12.3. Structures and pointers
• Lesson 12.4. Structures and functions
• Lesson 13.1. Recursive functions in C
• Lesson 13.2. Depth of recursive functions
• Lesson 13.2. Mutual recursion
• Lesson 14.1. Additional exercises

---