DPST1091 Revision Strings Exercises

Assume the only non-word characters are space and newline.

All other characters should be considered word characters.

A word is defined as a maximal non-empty sequence of word characters.

Multiple spaces or newline characters may separate words.

Match the output format below exactly:

dcc -o word_count word_count.c
./word_count
The quick brown fox jumped over the lazy dog.

1 lines 9 words 46 characters
./word_count
only
    three
        words

3 lines 3 words 29 characters
./word_count
Are you saying 'Boo' or 'Boo-Urns'?

1 lines 6 words 36 characters
./word_count
 In this house,
we obey the laws of thermodynamics!

2 lines 9 words 52 characters
./word_count
Simpson, Homer Simpson
He's the greatest guy in history
 From the
  Town of Springfield
  He's about to hit a chestnut tree.

5 lines 21 words 125 characters

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

1091 autotest word_count

For example:

dcc -o reverse_lines reverse_lines.c
./reverse_lines
Two roads diverged in a yellow wood,
,doow wolley a ni degrevid sdaor owT
And sorry I could not travel both
htob levart ton dluoc I yrros dnA
And be one traveler, long I stood
doots I gnol ,relevart eno eb dnA
To where it bent in the undergrowth;
;htworgrednu eht ni tneb ti erehw oT
You don't make friends with salad.
.dalas htiw sdneirf ekam t'nod uoY

You can assume lines are terminated with a newline ('\n') character,

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

1091 autotest reverse_lines

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

cp -n /import/reed/A/dp1091/public_html/26T1/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;
}

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

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

1091 autotest string_length

You should use printf("%c") 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 /import/reed/A/dp1091/public_html/26T1/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:

1091 autotest show_letters

You should use printf("%c") 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 /import/reed/A/dp1091/public_html/26T1/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:

1091 autotest show_terminated_letters

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 /import/reed/A/dp1091/public_html/26T1/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:

1091 autotest string_copy

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

cp -n /import/reed/A/dp1091/public_html/26T1/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:

1091 autotest string_to_upper

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 /import/reed/A/dp1091/public_html/26T1/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
}

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:

1091 autotest rotate_thirteen

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

cp -n /import/reed/A/dp1091/public_html/26T1/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:

1091 autotest string_reverse

Download swap_case.c here

Or, copy these file(s) to your CSE account using the following command:

1091 fetch-activity swap_case

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

int swap_case(int character) {
    // TODO: Write this function, which should:
    //  - return character in lower case if it is an upper case letter
    //  - return character in upper case if it is an lower case letter
    //  - return the character unchanged otherwise

    return 'x';
}

Edit the C program swap_case.c (linked above) which reads characters from its input and writes the same characters to its output with lower case letters converted to upper case and upper case letters converted to lower case.

Your program should stop only at the end of input.

which:

• returns the character in lowercase if it is an uppercase letter
• returns the character in uppercase if it is a lowercase letter
• returns the character unchanged otherwise

Note: Your program will not pass autotests if it does not contain this function.

Examples

dcc swap_case.c -o swap_case
./swap_case
Are you saying 'Boo' or 'Boo-Urns'?
aRE YOU SAYING 'bOO' OR 'bOO-uRNS'?
In this house, we obey the laws of thermodynamics!
iN THIS HOUSE, WE OBEY THE LAWS OF THERMODYNAMICS!
UPPER !@#$% lower
upper !@#$% LOWER

Assumptions/Restrictions/Clarifications

• You need only a single int variable. Don't use an array.
• Make sure you understand this example program which reads characters until end of input.
• Make sure you understand this example program which reads characters, printing them with lower case letters converted to uppercase.

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

1091 autotest swap_case

Write a C program substitution.c which reads characters from its input and writes the characters to its output encrypted with a Substitution cipher.

A Substitution cipher maps each letter to another letter.

The mapping will be given to your program via the command line as a command line argument (no spaces between any characters). This is all on one line. This input will contain 26 characters: an ordering of the letters 'a'..'z'.

Characters other than letters should not be encrypted.

Your program should stop only at the end of input.

Your program should contain at least one function other than main.

Examples

dcc substitution.c -o substitution
./substitution qwertyuiopasdfghjklzxcvbnm
Enter text:
I was scared of dentists and the dark
O vql leqktr gy rtfzolzl qfr zit rqka
I was scared of pretty girls and starting conversations
O vql leqktr gy hktzzn uoksl qfr lzqkzofu egfctklqzogfl

./substitution abcdefghijklmnopqrstuvwxyz
Enter text:
The identity cipher!!!
The identity cipher!!!

./substitution bcdefghijklmnopqrstuvwxyza
Enter text:
The Caesar cipher is a subset of the substitution cipher!
Uif Dbftbs djqifs jt b tvctfu pg uif tvctujuvujpo djqifs!

Your program will only be tested with an appropriate and valid mapping input for marking - but a good programmer would check the input is present and appropriate.

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

1091 autotest substitution

Characters which are not letters should be ignored .

Differences between upper case and lower case are ignored. For example:

./punctuated_palindrome
Enter a string: Do geese see God?
String is a palindrome
./punctuated_palindrome
Enter a string: Do ducks see God?
String is not a palindrome
./punctuated_palindrome
Enter a string: Madam, I'm Adam
String is a palindrome
./punctuated_palindrome
Enter a string: Madam, I'm Andrew
String is not a palindrome

You can assume lines contain at most 4096 characters.

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

1091 autotest punctuated_palindrome

Write a C program frequency_analysis.c which reads characters from its input until end of input.

It should then print the occurrence frequency for each of the 26 letters 'a'..'z'.

The frequency should be printed as a decimal value and an absolute number in exactly the format below.

Note upper and lower case letters are counted together.

Examples

dcc frequency_analysis.c -o frequency_analysis
./frequency_analysis
Hello and goodbye.

'a' 0.066667 1
'b' 0.066667 1
'c' 0.000000 0
'd' 0.133333 2
'e' 0.133333 2
'f' 0.000000 0
'g' 0.066667 1
'h' 0.066667 1
'i' 0.000000 0
'j' 0.000000 0
'k' 0.000000 0
'l' 0.133333 2
'm' 0.000000 0
'n' 0.066667 1
'o' 0.200000 3
'p' 0.000000 0
'q' 0.000000 0
'r' 0.000000 0
's' 0.000000 0
't' 0.000000 0
'u' 0.000000 0
'v' 0.000000 0
'w' 0.000000 0
'x' 0.000000 0
'y' 0.066667 1
'z' 0.000000 0
./frequency_analysis
Hey! Hey! Hey!
I don't like walking around this old and empty house
So hold my hand, I'll walk with you my dear

'a' 0.072289 6
'b' 0.000000 0
'c' 0.000000 0
'd' 0.084337 7
'e' 0.084337 7
'f' 0.000000 0
'g' 0.012048 1
'h' 0.096386 8
'i' 0.072289 6
'j' 0.000000 0
'k' 0.036145 3
'l' 0.084337 7
'm' 0.036145 3
'n' 0.060241 5
'o' 0.084337 7
'p' 0.012048 1
'q' 0.000000 0
'r' 0.024096 2
's' 0.036145 3
't' 0.048193 4
'u' 0.036145 3
'v' 0.000000 0
'w' 0.036145 3
'x' 0.000000 0
'y' 0.084337 7
'z' 0.000000 0

Hint: use an array to store counts of each letter.

Hint: make sure you understand this example program which counts integers from the range 0..99.

Manually Cracking a Substitution Cipher

This English text was encrypted with a substitution cipher.

Di jd, vdl'ht xtqa dh O qn
Vdl rdlwk O'ss wdkith htqromu omkd ok
O fhdwqwsv xdm'k
Styk kd nv dxm rtzoetj
Wlk kiqk'j kit royythtmet om dlh dfomodmj

Vdl'ht q ndlkiyls
Kiqk qndlmkj ydh qmdkith xtta dm nv dxm
Mdx O'n q mdzts nqrt htjdlhetyls
O jkqhk q eiqom xoki nv kidluik

Kqsa oj eitqf, nv rqhsomu
Xitm vdl'ht yttsomu houik qk idnt
O xqmmq nqat vdl ndzt xoki edmyortmet
O xqmmq wt xoki vdl qsdmt

What was the original text?

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

1091 autotest frequency_analysis

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

1091 autotest NONAME