COMP1511 Revision Strings Exercises

Revision Exercise: Read Line

In the next few activities, you'll be building some functions that deal with strings.

Remember that a string is an array of values representing characters, where the last character is followed by the special value 0 often written as '\0' in C. We refer to this zero marking the end of the string as the null terminator.

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

cp -n /web/cs1511/20T3/activities/read_line/read_line.c .

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

// Reads a line of input into `buffer`, excluding the newline;
// then ensures that `buffer` is a null-terminated string.
void read_line(int buffer_len, char *buffer) {

    // PUT YOUR CODE HERE
}
read_line takes an array, which we call a "buffer", the size of that array, and should read a line of text from standard input using getchar into the buffer.

Assume a line of text will always end with the newline character, \n. You should not write the newline into the buffer.

If more characters are available to be read than there is array space to read it into, you should stop after you have filled the array.

You should never lose characters, except for the newline.

You should always make sure that, when your function returns, you have null-terminated the buffer.

Testing

read_line.c also contains a simple main function which allows you to test your read_line function.

Do not change this main function. If you want to change it, you have misread the question.

Your read_line function will be called directly in marking. The main function is only to let you test your read_line function

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

dcc read_line.c -o read_line
./read_line
hello world
<hello world>

If you're uncertain about where to start, you may like to try the Parrot, String Length, and Array Functions revision exercises.

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

1511 autotest read_line

Revision Exercise: String Length

For this activity, you'll be writing the function string_length. It takes a string, and finds its length, excluding the null-terminator.

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

cp -n /web/cs1511/20T3/activities/string_length/string_length.c .

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

// Takes a string and finds its length, excluding the null-terminator.
int string_length(char *string) {
    // Your code goes here!
    // Don't forget to return your result.
    return 0;
}
string_length.c also contains a simple main function with some simple assert-based tests to help you build your solution:
int main(int argc, char *argv[]) {

    // Some simple assert-based tests.
    // You probably want to write some more.
    assert(string_length("") == 0);
    assert(string_length("!") == 1);
    assert(string_length("Hello, world!") == 13);
    assert(string_length("17... seventeen.\n") == 17);

    printf("All tests passed.  You are awesome!\n");

    return 0;
}

Your string_length function will be called directly in marking. The main function is only to let you test your string_length function

You can add more assert tests to main to test your string_length function.

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

1511 autotest string_length

Revision Exercise: Char Index

You should make sure you have completed read_line before completing this task.

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

cp -n /web/cs1511/20T3/activities/char_index/char_index.c .

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

// Return the index of the first occurrence of
// character `c` in the string, or `NOT_IN_STRING`
int char_index(int c, char *string) {
    // Your code goes here!
    // Don't forget to return your result.
    return 0;
}
Start by copying your read_line code into the provided function stub.

Note char_index takes a character and a string and should return the index (position) of the first appearance of the character in the string.

If the character doesn't appear in the string, char_index should return the value NOT_IN_STRING which has been already #defined for you.

char_index.c also contains a simple main function to help you test your char_index function.

// DO NOT CHANGE THIS MAIN FUNCTION
int main(int argc, char *argv[]) {
    // Declare a buffer
    char buffer[BUFFER_LENGTH] = {0};

    // Read in a line...
    printf("Enter a line: ");
    read_line(BUFFER_LENGTH, buffer);

    // Get a character
    printf("Enter a character: ");
    int ch;
    ch = getchar();

    // Find and print character index or "not in string"
    int index = char_index(ch, buffer);
    if (index == NOT_IN_STRING) {
        printf("Character '%c' is not in the string.\n", ch);
    } else {
        printf("Index of character '%c': %d\n", ch, index);
    }

    return 0;
}
This main function reads in a string and a character. Here is how char_index.c should behave after you add the correct code to the function char_index:
dcc char_index.c -o char_index
./char_index
Enter a line: Hello, world!
Enter a character: w
Index of character 'w': 7
./char_index
Enter a line: aaa
Enter a character: a
Index of character 'a': 0
./char_index
Enter a line: aaa
Enter a character: b
Character 'b' is not in the string.

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

1511 autotest char_index

Revision Exercise: Show Letters

In this activity, you will need to complete a function that prints an array of char values.

You should use the putchar() function to print each character in the array.

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

cp -n /web/cs1511/20T3/activities/show_letters/show_letters.c .

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

// print size characters from array letters
void show_letters(int size, char letters[]) {
    // Put your code here
}
show_letters.c also contains a main function to help you test your function Your show_letters function will be called directly in marking. The main function is only to let you test your show_letters function

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

dcc show_letters.c -o show_letters
./show_letters
Hello, world!
Test message.
sample text
a string

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

1511 autotest show_letters

Revision Exercise: Show Terminated Letters

In this activity, you will need to complete a function that prints an array of char values.

You should use the putchar() function to print each character in the array.

Your function will not be given the number of characters to show, instead, you must display characters from the array until you find a null terminator (0 or '\0') in the array.

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

cp -n /web/cs1511/20T3/activities/show_terminated_letters/show_terminated_letters.c .

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

void show_terminated_letters(char *letters) {
    // Your code here
}
show_terminated_letters.c also contains a main function to help you test your function Your show_terminated_letters function will be called directly in marking. The main function is only to let you test your string_reverse function

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

dcc show_terminated_letters.c -o show_terminated_letters
./show_terminated_letters
Hello, world!
Test message.
sample text
a string

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

1511 autotest show_terminated_letters

Revision Exercise: Strings Equal

You've probably noticed that you can't use the comparison operator, ==, to compare strings. So, how do we compare two strings? For this activity, you'll be writing a function to do exactly that:

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

cp -n /web/cs1511/20T3/activities/strings_equal/strings_equal.c .

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

// Takes two strings, and if they are the same,
// returns 1, or 0 otherwise.
int strings_equal(char *string1, char *string2) {
    // Your code goes here!
    // Don't forget to return your result.
    return 0;
}

It takes two strings, string1 and string2, and, if they are element-for-element the same, it returns 1, and 0 otherwise. You shouldn't ever read beyond the null-terminator of either string.

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

cp -n /web/cs1511/20T3/activities/strings_equal/strings_equal.c .

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

// Takes two strings, and if they are the same,
// returns 1, or 0 otherwise.
int strings_equal(char *string1, char *string2) {
    // Your code goes here!
    // Don't forget to return your result.
    return 0;
}
strings_equal.c also contains a simple main function with some simple assert-based tests to help you build your solution:
int main(int argc, char *argv[]) {

    // Some simple assert-based tests.
    // You probably want to write some more.
    assert(strings_equal("", "") == 1);
    assert(strings_equal(" ", "") == 0);
    assert(strings_equal("", " ") == 0);
    assert(strings_equal(" ", " ") == 1);
    assert(strings_equal("\n", "\n") == 1);
    assert(strings_equal("This is 17 bytes.", "") == 0);
    assert(strings_equal("", "This is 17 bytes.") == 0);
    assert(strings_equal("This is 17 bytes.", "This is 17 bytes.") == 1);
    assert(strings_equal("Here are 18 bytes!", "This is 17 bytes.") == 0);

    printf("All tests passed.  You are awesome!\n");

    return 0;
}

Your strings_equal function will be called directly in marking. The main function is only to let you test your strings_equal function

You can add more assert tests to main to test your strings_equal function.

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

1511 autotest strings_equal

Revision Exercise: String Copy

For this activity, you'll be writing the function string_copy

It takes a string in the source buffer, and copies it to the destination buffer, which is dest_size elements in size. If there are more characters in source than there is array space in destination, you should stop after you have filled the array. You should always make sure that your function null-terminates the destination array.

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

cp -n /web/cs1511/20T3/activities/string_copy/string_copy.c .

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

// Takes a string in `source`, and copies it to `destination`, which
// is `destSize` elements in size; only copies up to `destSize` bytes.
// Ensures the `destination` array is null-terminated.
void string_copy(char *destination, char *source, int destination_size) {
    // Put your code here
}
string_copy.c also contains a simple main function with to help you test your string_copy function
int main(int argc, char *argv[]) {
    // Declare a buffer.  In this case, we're declaring and using a
    // 64-byte buffer, but this could be any length you like, and in
    // our tests you will be required to handle arrays of any length.
    char buffer[BUFFER_LENGTH] = {0};

    // Copy a string into the buffer ...
    string_copy(buffer, "Seventeen bytes.\n", BUFFER_LENGTH);

    // ... and print it out.  The `%s` format code prints a string.
    printf("<%s>\n", buffer);

    return 0;
}

Your string_copy function will be called directly in marking. The main function is only to let you test your string_copy function

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

1511 autotest string_copy

Revision Exercise: String To Upper

For this activity, you'll be writing the function string_to_upper. It takes a string and converts it to upper case

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

cp -n /web/cs1511/20T3/activities/string_to_upper/string_to_upper.c .

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

// Convert the characters in `buffer` to upper case
void string_to_upper(char *buffer) {
    // YOUR CODE GOES HERE!
}
string_to_upper.c also contains a simple main function to help you test your solution.
int main(int argc, char *argv[]) {

    // NOTE: THIS WON'T WORK:
    // char *str = "Hello!"
    // string_to_upper(str)
    //
    // str only points to a string literal, which it is not legal to change.
    // If you attempt to modify it on Linux you will get a runtime error.
    // Instead, you need to create an array to store the string in, e.g.:
    //
    // char str[] = "Hello!"
    // string_to_upper(str)

    char str[] = "Seventeen...  SEVENTEEN, I SAY!";
    string_to_upper(str);
    printf("%s\n", str);
    return 0;
}

Your string_to_upper function will be called directly in marking. The main function is only to let you test your string_to_upper function

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

    // NOTE: THIS WON'T WORK:
    // char *str = "Hello!"
    // string_to_upper(str)
    //
    // str only points to a string literal, which it is not legal to change.
    // If you attempt to modify it on Linux you will get a runtime error.
    // Instead, you need to create an array to store the string in, e.g.:
    //
    // char str[] = "Hello!"
    // string_to_upper(str)

    char str[] = "Seventeen...  SEVENTEEN, I SAY!";
    string_to_upper(str);
    printf("%s\n", str);
    return 0;
}

Your string_to_upper function will be called directly in marking. The main function is only to let you test your string_to_upper function

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

dcc string_to_upper.c -o string_to_upper
./string_to_upper
SEVENTEEN...  SEVENTEEN, I SAY!

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

1511 autotest string_to_upper

Revision Exercise: String To Lower

For this activity, you'll be writing the function string_to_lower. It takes a string and converts it to lower case

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

cp -n /web/cs1511/20T3/activities/string_to_lower/string_to_lower.c .

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

// Convert the characters in `buffer` to lower case
void string_to_lower(char *buffer) {
    // YOUR CODE GOES HERE!
}
string_to_lower.c also contains a simple main function to help you test your solution.
int main(int argc, char *argv[]) {

    // NOTE: THIS WON'T WORK:
    // char *str = "Hello!"
    // string_to_lower(str)
    //
    // str only points to a string literal, which it is not legal to change.
    // If you attempt to modify it on Linux you will get a runtime error.
    // Instead, you need to create an array to store the string in, e.g.:
    //
    // char str[] = "Hello!"
    // string_to_lower(str)

    char str[] = "Seventeen...  SEVENTEEN, I SAY!";
    string_to_lower(str);
    printf("%s\n", str);

    return 0;
}

Your string_to_lower function will be called directly in marking. The main function is only to let you test your string_to_lower function

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

dcc string_to_lower.c -o string_to_lower
./string_to_lower
seventeen...  seventeen, i say!

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

1511 autotest string_to_lower

Revision Exercise: String Reverse

For this activity, you'll be writing the function string_reverse. It takes a string and reverses it in place.

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

cp -n /web/cs1511/20T3/activities/string_reverse/string_reverse.c .

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

// Takes a string in `buffer`, and reverses it in-place.
void string_reverse(char *buffer) {
    // YOUR CODE GOES HERE!
}
string_reverse.c also contains a simple main function to help you test your function string_reverse
int main(int argc, char *argv[]) {

    // NOTE: THIS WON'T WORK:
    // char *str = "Hello!"
    // string_reverse(str)
    //
    // str only points to a string literal, which it is not legal to change.
    // If you attempt to modify it on Linux you will get a runtime error.
    // Instead, you need to create an array to store the string in, e.g.:
    //
    // char str[] = "Hello!"
    // string_reverse(str)

    char str[] = ".'neetneves' :egassem terces A";
    string_reverse(str);
    printf("%s\n", str);
    return 0;
}

Your string_reverse function will be called directly in marking. The main function is only to let you test your string_reverse function

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

dcc string_reverse.c -o string_reverse
./string_reverse
A secret message: 'seventeen'.

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

1511 autotest string_reverse

Revision Exercise: Rotate Thirteen

For this activity, you'll be writing the function rotate_thirteen. It takes a string, and rotates each character by thirteen positions in the alphabet.

To see more about this algorithm, check out the wikipedia article.

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

cp -n /web/cs1511/20T3/activities/rotate_thirteen/rotate_thirteen.c .

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

void rotate_thirteen(char *string) {
    // YOUR CODE HERE
    // See: https://en.wikipedia.org/wiki/ROT13
}
rotate_thirteen.c also contains a simple main function with some simple assert-based tests to help you build your solution:
int main(int argc, char *argv[]) {
    // Example tests
    char test_a[MAX_LENGTH] = "Hello, world!";
    rotate_thirteen(test_a);
    assert(strings_equal("Uryyb, jbeyq!", test_a));

    char test_b[MAX_LENGTH] = "abcdefghijklmnopqrstuvwxyz";
    rotate_thirteen(test_b);
    assert(strings_equal("nopqrstuvwxyzabcdefghijklm", test_b));

    char test_c[MAX_LENGTH] = "The quick brown fox jumped over the lazy dog.";
    rotate_thirteen(test_c);
    assert(strings_equal("Gur dhvpx oebja sbk whzcrq bire gur ynml qbt.", test_c));

    // Add your own tests here

    printf("All tests passed. You are awesome!\n");

    return 0;
}

Your rotate_thirteen function will be called directly in marking. The main function is only to let you test your rotate_thirteen function

You can add more assert tests to main to test your rotate_thirteen function.

You will need to use your strings_equal function from the strings_equal activity for tests to work.

You may want to use your rotate_one function from the rotate_one activity.

You may want to use your rotate_thirteen function from the rotate_thirteen activity.

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

1511 autotest rotate_thirteen