COMP1521 Revision 02 Sample Solutions

Revision Exercise: Change RGB Colours (Pointers)

You can fetch the starter code for this activity by running:

1521 fetch-activity c_revision_change_colour

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

void change_colour(int red, int green, int blue) {
    // Implement this function
    // NOTE: You will need to modify the parameters
    
}

The RGB colour system represents colours by combining red, green, and blue. The amount of each is stored as an integer between 0 and 255.

Complete the shift_colour to change the RGB values so that:

the new green value = old red value
new blue = old green
new red = old blue

Once your program is working, you should see something like:

dcc change_colour.c -o change_colour
./change_colour
RGB Value: 10 20 30
Shifted RGB Value: 30 10 20
./change_colour
RGB Value: 255 0 90
Shifted RGB Value: 90 255 0

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

1521 autotest c_revision_change_colour

Sample solution for c_revision_change_colour.c

#include <stdio.h>

// POINTERS
// &num => address of num
// *ptr => value at the address pointed to by ptr (dereferencing)

void change_colour(int *red, int *green, int *blue);

int main(void) {
    int red = 0;
    int green = 0;
    int blue = 0;
    
    printf("RGB Value: ");
    scanf(" %d %d %d", &red, &green, &blue);
  
    // change colour accepts pointers to the red, green, blue integers
    change_colour(&red, &green, &blue);

    printf("Shifted RGB Value: %d %d %d\n", red, green , blue);
  
    return 0;
}

void change_colour(int *red, int *green, int *blue) {
    // store the value of red in temp
    int temp = *red;
    *red = *blue;
    *blue = *green;
    *green = temp;
}

Revision Exercise: Change RGB Colours (Structs)

You can fetch the starter code for this activity by running:

1521 fetch-activity c_revision_change_colour_2

Currently the red, green and blue values are stored in three separate integers.

Add code to struct rgb so that it contains three integers called red, green and blue.

Rewrite main so that struct rgb is used rather than three separate variables.

Add code to the function change_colour so that given a struct rgb * (a pointer to an rgb struct), you change the RGB values so that: Complete the shift_colour to change the RGB values so that

the new green value = old red value
new blue = old green
new red = old blue

Once your program is working, you should see something like:

dcc change_colour_2.c -o change_colour_2
./change_colour_2
RGB Value: 10 20 30
Shifted RGB Value: 30 10 20
./change_colour_2
RGB Value: 255 0 90
Shifted RGB Value: 90 255 0

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

1521 autotest c_revision_change_colour_2

Sample solution for c_revision_change_colour_2.c

#include <stdio.h>

// struct to hold RGB values
struct rgb {
    int red;
    int green;
    int blue;
};

void change_colour(struct rgb *colour);

int main(void) {
    struct rgb colour;
        
    printf("RGB Value: ");
    // store scanned values directly into the fields of the struct
    scanf(" %d %d %d", &(colour.red), &(colour.green), &(colour.blue));

    // pass the struct pointer to function
    change_colour(&colour);
    
    printf("Shifted RGB Value: %d %d %d\n", colour.red, colour.green, colour.blue);

    return 0;
}

void change_colour(struct rgb *colour) {
    // store red value in temp variable
    int temp = colour->red;
    colour->red = colour->blue;
    colour->blue = colour->green;
    colour->green = temp;
}

// Use "." to access struct fields directly
// struct rgb colour;
// colour.red 

// Pointer to a struct "->"
// struct rgb * colour_ptr;
// colour_ptr->red
// (*colour_ptr).red

Revision Exercise: Read in and Malloc an Array

You can fetch the starter code for this activity by running:

1521 fetch-activity c_revision_malloc_array

For this question you'll need to complete two functions; create_array and print_double.

Part 1: Creating an Array using Malloc

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

int *create_array(int size) {
    // Implement this function

    return NULL;
}

Complete the create_array function so that it returns an integer array size elements long.

Fill the array by using scanf to read in each element.

You will have to use malloc to allocate space on the heap for your new array.

Part 2: Print the double of each element of an array

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

void print_double(int *array, int size) {
    // Implement this function

}

Complete the print_double function so that it prints double each element in array.

The double of each element should be separated by a space. You should not change the array itself.

Once your code is working, it should look something like:

 dcc malloc_array.c test_malloc_array.c -o malloc_array
./malloc_array
Enter size of array: 10
Enter array elements: 1
2
3
4
5
6
7
8
9
10
Array elements doubled: 2 4 6 8 10 12 14 16 18 20

In this question you'll need to edit malloc_array.c, which does not have a main function.

The main function is in a different file test_malloc_array.c. Both files #include "malloc_array.h".

To compile and execute this question, you can use:

    dcc malloc_array.c test_malloc_array.c -o malloc_array
    ./malloc_array

The executable malloc_array will execute the main from test_malloc_array.c using the functions you wrote in malloc_array.c.

$ man 3 malloc

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

1521 autotest c_revision_malloc_array

Revision Exercise: Daily Average Temperature

You can fetch the starter code for this activity by running:

1521 fetch-activity c_revision_daily_avg_temp

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

// print the average temperature each day for the three days we have data for
void daily_avg_temp(int daily_temperature[N_COLS][N_ROWS]) {

}

A weather station records the temperature 5 times each day. The temperatures for the last three days are stored in a 2-dimensional array called daily_temperature. Each row corresponds to a single day and has 5 columns for the temperatures taken throughout that day.

Add code to the function daily_avg_temp so that given the 2-dimensional integer array daily_temperature you print out the average temperature for each day.

Once your program is working, you should see something like:

./daily_avg_temp
Average temperature for day 0 = 23
Average temperature for day 1 = 28
Average temperature for day 2 = 20

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

1521 autotest c_revision_daily_avg_temp

Sample solution for c_revision_daily_avg_temp.c

#include <stdio.h>

#define N_COLS  3
#define N_ROWS  5

void daily_avg_temp(int daily_temperature[N_COLS][N_ROWS]);

int main(int argc, char **argv) {
    // create 2D array
    int daily_temperature[N_COLS][N_ROWS] = { {19, 21, 25, 27, 23},
                                    {24, 31, 34, 29, 26},
                                    {22, 23, 20, 19, 17} };

    daily_avg_temp(daily_temperature);
}

// find and print the average temperature for each of the last three days
void daily_avg_temp(int daily_temperature[N_COLS][N_ROWS]) {

    // i => row number, which row are we up to?
    for (int i = 0; i < N_COLS; i++) {

        int sum = 0; // store the sum of temperatures over one row (aka one day)

	// j => column number
        for (int j = 0; j < N_ROWS; j++) {
	    // access ith row, jth column
            sum += daily_temperature[i][j];
        }

	// calculate and print average
        int avg = sum/N_ROWS;
        printf("Average temperature for day %d = %d\n", i, avg);
    }
}

Revision Exercise: Clamp the length of a string

You can fetch the starter code for this activity by running:

1521 fetch-activity c_revision_clamp_string

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

void clamp_string(char *string, int limit) {
    // Implement this function

}

Add code to the clamp_string function to ensure that string is at most limit characters long.

You should not change the arguments or return type of the clamp_string function. You can (and should) change the string variable directly. You do not need to print anything in the function.

Once your program is working, you should see something like:

dcc clamp_string.c test_clamp_string.c -o clamp_string
./clamp_string
Input: Hello, how are you?
Limit: 5
Output: Hello
./clamp_string
Input: Hello!!
Limit: 30
Output: Hello!!

You can use a null terminating character '\0' to clamp the length of string

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

1521 autotest c_revision_clamp_string

Sample solution for c_revision_clamp_string.c

#include <stdio.h>
#include <string.h>

void clamp_string(char *string, int limit) {
    // if the string is already less than limit, no need to do anything
    if (limit >= strlen(string)) {
        return;
    }

    // end the string with a null terminating character
    string[limit] = '\0';
}

Revision Exercise: Remove File Suffix

You can fetch the starter code for this activity by running:

1521 fetch-activity c_revision_remove_file_suffix

Write a program remove_file_suffix.c which reads filenames from its input and outputs the filename without the suffix.

The suffix tells you the file type and is at the end of the filename after a full stop. For example the suffix of test.txt is .txt.

You should use fgets to read in each filename. Your program should only stop at the end of input.

If the filename doesn't have a suffix you should ignore it.

Once you have remove_file_suffix.c working correctly it should behave as follows:

dcc remove_file_suffix.c -o remove_file_suffix
./remove_file_suffix
hello.py
hello
test.txt
test


./remove_file_suffix
hello
hello.c
hello

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

1521 autotest c_revision_remove_file_suffix

Sample solution for c_revision_remove_file_suffix.c

#include <stdio.h>
#include <string.h>

#define STRING_MAX 256

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

    // read in filenames until user enters Ctrl-D or EOF (End-Of-File)
    while (scanf("%s", filename) != EOF) {

	// loop through string to find "." (where suffix starts)
        for (int i = 0; i < strlen(filename); i++) {
	    // replace "." with '\0' to remove suffix by ending string early
            if (filename[i] == '.') {
                filename[i] = '\0';
		// print suffix-less filename
                printf("%s\n", filename);
                break;
            }
        }
    }

    return 0;
}

Revision Exercise: Combine two sentences into a single string

You can fetch the starter code for this activity by running:

1521 fetch-activity c_revision_combine_sentences

There are two functions to complete for this task.

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

void strip_newline(char *sentence) {
    // Implement this function

}

Complete the strip_newline so that it removes the newline at the end of sentence.

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

char *combine_sentences(char *sentence_1, char *sentence_2) {
    // Implement this function

    return NULL;
}

Add code to combine_sentences so that it returns a new string which is sentence_1 and sentence_2 joined together.

You will need to use malloc to allocate space for the new string.

You should use your strip_newline function to get rid of the newlines from the sentences before combining them.

When your program is working, it should look something like:

dcc combine_sentences.c test_combine_sentences.c -o combine_sentences
./combine_sentences
Sentence 1: What a wonderful day
Sentence 2: to write assembly
Combined: What a wonderful dayto write assembly

    man 3 malloc
    man 3 strlen
    man 3 strcpy
    man 3 strcat

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

1521 autotest c_revision_combine_sentences

Sample solution for c_revision_combine_sentences.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void strip_newline(char *sentence);
char *combine_sentences(char *sentence_1, char *sentence_2);


// combine two strings by adding sentence_2 to the end of sentence_1
char *combine_sentences(char *sentence_1, char *sentence_2) {
    // strip both sentences of newlines
    strip_newline(sentence_1);
    strip_newline(sentence_2);

    // create new char array to hold combined sentence
    char *new_sentence = malloc(sizeof(char) * (strlen(sentence_1) + strlen(sentence_2) + 1));

    strcpy(new_sentence, sentence_1);
    strcat(new_sentence, sentence_2);

    return new_sentence;
}

// strip newline from a string
void strip_newline(char *sentence) {
    // strcspn() finds the first instance of a given character in a string
    // and returns the index
    sentence[strcspn(sentence, "\n")] = '\0';
}

// solution without strcspn()
void strip_newline_2(char *sentence) {
    int i = 0;
    // loop over characters in a string
    while (sentence[i] != '\0') {

        // if we've found a newline, replace with null terminator and stop
        if (sentence[i] == '\n') {
            sentence[i] = '\0';
            break;
        }
        i++;
    }
}

// solution with pointer arithmetic
void strip_newline_3(char *sentence) {
    // dereference string pointer sentence to look at a character
    while (*sentence != '\0') {
        if (*sentence == '\n') {
                *sentence = '\0';
                break;
         }

        // increment sentence to get next character
        sentence++;
    }
}

Revision Exercise: Blast off! (Recursion)

You can fetch the starter code for this activity by running:

1521 fetch-activity c_revision_blast_off

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

// recursive function to count down to blast off
void perform_launch(int timer) {
    // TODO: complete this function
}

Add code to the perform_launch function so that it counts down to launch one second at a time. Each passing second should be printed on a new line.

You must use recursion to do this question. You are not permitted to use while or for loops.

When your code is working, it should look like:

./blast_off 10
10
9
8
7
6
5
4
3
2
1
Blast off!

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

1521 autotest c_revision_blast_off

Sample solution for c_revision_blast_off.c

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

void perform_launch(int timer);

int main(int argc, char *argv[]) {
    int time_to_launch = atoi(argv[1]);

    perform_launch(time_to_launch);

    return 0;
}

// recursive function to count from timer to 0 (blast off)
void perform_launch(int timer) {
    // base condition: if the timer is at or below 0 we are finished
    if (timer <= 0) {
        printf("Blast off!\n");
        return;
    }

    // call again with timer - 1
    printf("%d\n", timer);
    perform_launch(timer - 1);
}

Revision Exercise: Movie Reviews (Structs)

You can fetch the starter code for this activity by running:

1521 fetch-activity c_revision_movie_review

You're writing a program to rate movies, each movie rating is stored in a struct movie_review. The review contains the name of the movie, release year and a rating out of 10.

You need to complete two functions new_review and print_review.

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

// Create a new movie review
struct movie_review *new_review(char *title, int release_year, int rating) {
    // TODO: complete this function
    return NULL;
}

Add code to the new_review function so that it returns a pointer to a new struct movie_review filled out with the title, release year and rating.

You should remove the newline at the end of the title before storing it in the struct.

You will need to use malloc to create a new struct that will still exist after your function returns.

To copy a string from one location to another (for example into a struct) you can use strcpy.

You can use the arrow operator to access the fields of a struct using a pointer.

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

// Print the details of a movie review
void print_review(struct movie_review *m) {
    //TODO: complete this function
}

Add code to the print_review function so that given a pointer to a movie review m you print the title, release year and rating.

When your code is working, it should look like:

./movie_review
Enter title: 10 Things I Hate About You
Enter release year: 1999
Enter rating from 0-10: 10
New review:
Movie: 10 Things I Hate About You
Released: 1999
Rating: 10/10

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

1521 autotest c_revision_movie_review

Sample solution for c_revision_movie_review.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_TITLE_LEN 256

struct movie_review {
    char title[MAX_TITLE_LEN];
    int release_year;
    int rating;
};

struct movie_review *new_review(char *title, int release_year, int rating);
void print_review(struct movie_review *m);

int main(void) {
    // get movie information
    char title[MAX_TITLE_LEN];
    printf("Enter title: ");
    if (fgets(title, MAX_TITLE_LEN, stdin) == NULL) return 1;

    int year;
    printf("Enter release year: ");
    if (scanf("%d", &year) != 1) return 1;

    int rating;
    printf("Enter rating from 0-10: ");
    if (scanf("%d", &rating) != 1) return 1;

    struct movie_review *new_movie = new_review(title, year, rating);

    printf("New review:\n");
    print_review(new_movie);

    // free the malloc'd struct movie_review
    free(new_movie);
}

// create a new movie_review struct and return a pointer to it
struct movie_review *new_review(char *title, int release_year, int rating) {
    // to return a pointer to a new variable we need to use malloc
    struct movie_review *new_movie = malloc(sizeof(struct movie_review));

    // strip the newline from the title
    int i = 0;
    while (title[i] != '\0') {
        if (title[i] == '\n') {
            title[i] = '\0';
        }
        i++;
    }

    // use strcpy to move strings into structs
    strcpy(new_movie->title, title);
    new_movie->release_year = release_year;
    new_movie->rating = rating;

    return new_movie;
}

// print out movie review information
void print_review(struct movie_review *m) {
        printf("Movie: %s\n", m->title);
        printf("Released: %d\n", m->release_year);
        printf("Rating: %d/10\n", m->rating);
}

Revision Exercise: Find Well-Rated Movies (Structs)

You can fetch the starter code for this activity by running:

1521 fetch-activity c_revision_find_movies

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

// find all movies in list with ratings equal to or above minimum
// rating and print them out
void find_and_print_movies(struct movie_review movie_list[], int num_movies, int min_rating) {
    // TODO: Complete this function
}

The find_and_print_movies function should search the struct movie_review array to find movies rated at or above a minimum rating and print out any movie with a high enough rating.

The struct is defined in find_movies.h.

If the user has entered an invalid rating (not between 1 and 10), you should not search for movies and print a message saying the rating is invalid.

When your code is working, it should look like:

dcc find_movies_main.c find_movies.c -o find_movies
./find_movies
Find movies rated at or above: 4
You could watch:
- Jurassic Park (1993): 8/10
- Alien (1979): 9/10
- The Thing (1982): 10/10
- Despicable Me 4 (2024): 6/10
- Spiderman 3 (2007): 5/10
- Legally Blonde (2001): 8/10
- Mean Girls (2004): 7/10
./find_movies
Find movies rated at or above: 100
Invalid rating, must be between 0 and 10.

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

1521 autotest c_revision_find_movies

Sample solution for c_revision_find_movies.c

#include <stdio.h>

#include "find_movies.h"

// find all movies in list with ratings equal to or above minimum
// rating and print them out
void find_and_print_movies(struct movie_review movie_list[], int num_movies, int min_rating) {
    // check if min rating is valid
    if (min_rating < 0 || min_rating > 10) {
        printf("Invalid rating, must be between 0 and 10.\n");
        return;
    }

    // find movies
    printf("You could watch: \n");
    for (int i = 0; i < num_movies; i++) {
	
	// movie_list[i] => ith movie struct in movie_list
        if (movie_list[i].rating >= min_rating) {
            printf("- %s (%d): %d/10\n", movie_list[i].title, movie_list[i].release_year, movie_list[i].rating);
        }
    }
}