Week 05 Laboratory Exercises

Download swap_pointers.c here, or copy it to your CSE account using the following command:

cp -n /web/cs1511/21T1/activities/swap_pointers/swap_pointers.c .

Your task is to add code to this function in swap_pointers.c:

// swap the values in two integers, given as pointers
void swap_pointers(int *a, int *b) {
    // PUT YOUR CODE HERE (you must change the next line!)
}

For example if the integers are:

int first = 1;
int second = 2;

After your function runs, first should be 2 and second should be 1.

Assumptions/Restrictions/Clarifications.

swap_pointers is a void function. It cannot return any values.

swap_pointers should not call scanf (or getchar or fgets).

swap_pointers should not print anything. It should not call printf.

Your submitted file may contain a main function. It will not be tested or marked.

1511 style swap_pointers.c

When you think your program is working, you can use autotest to run some simple automated tests:

1511 autotest swap_pointers

When you are finished working on this exercise, you and your lab partner must both submit your work by running give:

give cs1511 lab05_swap_pointers swap_pointers.c

Note, even though this is a pair exercise, you both must run give from your own account before Monday 29 March 20:00 to obtain the marks for this lab exercise.

Download array_sum_prod.c here, or copy it to your CSE account using the following command:

cp -n /web/cs1511/21T1/activities/array_sum_prod/array_sum_prod.c .

Your task is to add code to this function in array_sum_prod.c:

// Calculates the sum and product of the array nums.
// Actually modifies the  variables that *sum and *product are pointing to
void array_sum_prod(int length, int nums[length], int *sum, int *product) {
    // TODO: Complete this function
}

The above file array_sum_prod.c contains a function array_sum_prod, which should find the sum and the product of the values stored in the array. It should write these values into the integers referenced by the pointers in the input to the function.

Unfortunately, the provided function doesn't actually work. For this lab exercise, your task is to complete this function.

Note: you must not modify the array within the array_sum_prod function. You should only read the values in the array, not change them.

Note: you will not be given an empty array as input, you can assume that you have at least 1 value.

The file also contains a main function which you can use to help test your array_sum_prod function. It has two simple test cases.

This main function will not be marked -- you must write all of your code in the array_sum_prod function. You may modify the main function if you wish (e.g. to add further tests), but only the array_sum_prod function will be marked.

Once your program is working, the output from the two provided tests in the main function should be:

dcc -o array_sum_prod array_sum_prod.c 
./array_sum_prod 
Sum: 20, Product: 360
Sum: 10, Product: 24

1511 style array_sum_prod.c

When you think your program is working, you can use autotest to run some simple automated tests:

1511 autotest array_sum_prod

When you are finished working on this exercise, you and your lab partner must both submit your work by running give:

give cs1511 lab05_array_sum_prod array_sum_prod.c

Note, even though this is a pair exercise, you both must run give from your own account before Monday 29 March 20:00 to obtain the marks for this lab exercise.

Download common_elements.c here, or copy it to your CSE account using the following command:

cp -n /web/cs1511/21T1/activities/common_elements/common_elements.c .

Your task is to add code to this function in common_elements.c:

int common_elements(int length, int source1[length], int source2[length], int destination[length]) {
    // PUT YOUR CODE HERE (you must change the next line!)
    return 42;
}

In other words, all of the elements that appear in both of the source1 and source2 should be copied to the third destination array, in the order that they appear in the first array. common_elements should return a single integer: the number of elements copied to the destination array.

For example, if the source arrays contained the following 6 elements:

source1: 1, 4, 1, 5, 9, 2

source2: 1, 1, 8, 2, 5, 3

common_elements should copy these 4 values to the destination array: 1, 1, 5, 2

The value 4 and 9 do not get copied because they do not occur in the second array.

common_elements should return the integer 4, because there were 4 values copied.

common_elements should copy the elements in the order that they appear in the first array.

If a value in the first array occurs one or more times in the second array, each occurrence of those values in the first array should be copied.

It doesn't matter how many times the values occur in the second array, as long as the values occur at least once. For example. if the two arrays contained the following 5 elements:

source1: 1, 2, 3, 2, 1

source2: 1, 2, 3, 4, 5

Your function should copy all five values (1, 2, 3, 2, 1) from source1 to the destination array {} as all of the values (1, 2, 3) appeared at least once in source2 and it should return 5 because because 5 values were copied.

Assumptions/Restrictions/Clarifications.

You can assume that all three arrays are the same size (length) and length is > 0.

You cannot assume anything about the number of common elements, i.e. there may not be any common elements between both arrays, or conversely, the entire contents of the first array may also be present in the second array.

common_elements should return a single integer.

common_elements should not change the array it is given.

common_elements should not call scanf (or getchar or fgets).

common_elements should not print anything. It should not call printf.

Your submitted file may contain a main function. It will not be tested or marked.

1511 style common_elements.c

When you think your program is working, you can use autotest to run some simple automated tests:

1511 autotest common_elements

When you are finished working on this exercise, you and your lab partner must both submit your work by running give:

give cs1511 lab05_common_elements common_elements.c

Note, even though this is a pair exercise, you both must run give from your own account before Monday 29 March 20:00 to obtain the marks for this lab exercise.

Download advanced_addition.c here, or copy it to your CSE account using the following command:

cp -n /web/cs1511/21T1/activities/advanced_addition/advanced_addition.c .

Your task is to add code to this function in advanced_addition.c:

// Put the sum of the lines in the array into the last line
// accounting for carrying. Return anything you did not carry.
//
// NOTE: num_lines is the number of lines you are adding together. The
// array has an extra line for you to put the result.
int sum(int num_lines, int num_digits, int array[MAX_SIZE][MAX_SIZE]) {
    // Put your code here.
    return 0;
}

You will implement the sum function, which will be given a two-dimensional array with a variable number of rows ("lines") and columns ("digits"), like the following:

0 1 2 3 4
0 4 3 2 4
0 0 1 1 1
0 0 0 0 0

When you receive this array, you are guaranteed the last row will be all zeroes. You should write the sum of every column into the last number in that column.

As an example, your function should modify the above array to be the following:

0 1 2 3 4
0 4 3 2 4
0 0 1 1 1
0 5 6 6 9

For each column, starting from the right-most digit, you should add every digit in that column, and put the result of that addition into the last row.

To simulate real addition, however, none of the values in the array may exceed 9, so you will need to implement "carrying", just like in normal addition. "Carrying" is when all the numbers in a column sum to greater than 9, and you add extra to the next column to keep the current column below 10. For example, the following array:

0 9
0 8
0 7
0 0

Should become:

0 9
0 8
0 7
2 4

The sum function will normally return 0. If, however, your addition cannot be represented in the array because the last column you add still carries something over, your function should return the amount carried:

9
8
7
0

Should return 2, and make the array:

9
8
7
4
    

More formally, you should:

1. Start at the rightmost column of the array.
2. Add together the integers in that column, as well as anything "carried across".
3. If the result of that addition would be less than ten, write the result of that addition into the last number in that row. Nothing is carried across.
4. Otherwise, find the result of the addition modulo 10, and write that into the last value in the column.
5. Then, divide the result of the addition by 10, and "carry that accross" to the next column.
6. Repeat on the next column to the next, from step two.
7. If you reach the leftmost column of the array, and there is still a value "carried across", return it. Otherwise, return zero.

The file advanced_addition.c contains a main function which reads values into a 2D array and calls sum.

Here is how advanced_addition.c should behave after you add the correct code to the function add:

dcc advanced_addition.c -o advanced_addition
./advanced_addition
Enter the number of rows (excluding the last): 3
Enter the number of digits on each row: 3
Enter 2D array values:
1 2 3
4 5 6
0 1 0
5 8 9

./advanced_addition
Enter the number of rows (excluding the last): 4
Enter the number of digits on each row: 2
Enter 2D array values:
1 3
1 3
1 3
1 3
5 2
./advanced_addition
Enter the number of rows (excluding the last): 2
Enter the number of digits on each row: 1
Enter 2D array values:
9
9
8
Carried over: 1

1511 style advanced_addition.c

When you think your program is working, you can use autotest to run some simple automated tests:

1511 autotest advanced_addition

When you are finished working on this exercise, you and your lab partner must both submit your work by running give:

give cs1511 lab05_advanced_addition advanced_addition.c

Note, even though this is a pair exercise, you both must run give from your own account before Monday 29 March 20:00 to obtain the marks for this lab exercise.