COMP1511 Revision Strings Exercises
Revision Exercise: Read Line
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/21T1/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
}
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
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/21T1/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;
}
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/21T1/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;
}
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;
}
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
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/21T1/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
}
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
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/21T1/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
}
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: String Copy
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/21T1/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
}
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
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/21T1/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!
}
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
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/21T1/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!
}
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
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/21T1/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!
}
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
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/21T1/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
}
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