DPST1091 Revision Strings Sample Solutions

//  Written 3/5/2018 by Andrew Taylor (andrewt@unsw.edu.au)
//  Counts lines, word & characters in standard input
//
//  The mapping will be supplied as a command-line argument containing 10 characters:

#include <stdio.h>

int word_character(int character);

int main(int argc, char *argv[]) {
    int line_count = 0;
    int character_count = 0;
    int word_count = 0;
    int lastc = ' ';
    int c = getchar();
    while (c != EOF) {
        character_count = character_count + 1;
        if (word_character(c) && !word_character(lastc)) {
            word_count = word_count + 1;
        }
        if (c == '\n') {
            line_count = line_count + 1;
        }
        lastc = c;
        c = getchar();
    }

    printf("%d lines %d words %d characters\n", line_count, word_count, character_count);
}

int word_character(int character) {
    return character != ' ' && character != '\n';
}

//  Written 3/5/2018 by Andrew Taylor (andrewt@unsw.edu.au)
//  Reads lines and writes them out with the characters of each line in reverse order.
//  Stop when it reaches the end of input.

#include <stdio.h>

#define MAX_LINE_CHARS 4096

int main(void) {
    char line[MAX_LINE_CHARS];

    // get the lines
    while (fgets(line, MAX_LINE_CHARS, stdin) != NULL) {

        // find the size of this line
        int size = 0;
        while ((line[size] != '\n') && (line[size] != '\0')) {
            // not the end yet
            size = size + 1;
        }

        // now print in reverse
        int j = size - 1;
        while (j >= 0) {
            printf("%c", line[j]);
            j = j - 1;
        }
        printf("\n");
    }

    return 0;
}

// How long is a (piece of) string?
// A sample solution.

#include <assert.h>
#include <stdio.h>

int string_length(char *string);

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;
}

// Takes a string and finds its length, excluding the null-terminator.
int string_length(char *string) {
    int i = 0;
    while (string[i] != '\0') {
        i = i + 1;
    }
    return i;
}

// Display character arrays as text, by printing the individual
// characters -- a sample solution.

#include <assert.h>
#include <stdio.h>

#define ENOUGH_SPACE 100

void show_letters(int size, char letters[]);

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

    char letters_a[13] = {0};
    letters_a[0] = 72;
    letters_a[1] = 101;
    letters_a[2] = 108;
    letters_a[3] = 108;
    letters_a[4] = 111;
    letters_a[5] = 44;
    letters_a[6] = 32;
    letters_a[7] = 119;
    letters_a[8] = 111;
    letters_a[9] = 114;
    letters_a[10] = 108;
    letters_a[11] = 100;
    letters_a[12] = 33;
    show_letters(13, letters_a);

    printf("\n");

    char letters_b[13] = {
        84,  101, 115, 116, 32,
        109, 101, 115, 115, 97,
        103, 101, 46
    };
    show_letters(13, letters_b);

    printf("\n");

    char letters_c[11] = {
        's', 'a', 'm', 'p', 'l', 'e',
        ' ', 't', 'e', 'x', 't'
    };
    show_letters(11, letters_c);

    printf("\n");

    char letters_d[ENOUGH_SPACE] = "a string";
    show_letters(8, letters_d);

    printf("\n");

    return 0;
}


// print size characters from array letters
void show_letters(int size, char letters[]) {
    int i = 0;
    while (i < size) {
        putchar(letters[i]);
        i = i + 1;
    }
}

// Displaying arrays as text
// A sample solution.

#include <assert.h>
#include <stdio.h>

#define ENOUGH_SPACE 100

// Print out each character in a NUL-terminated array of characters.
void show_terminated_letters(char *letters);

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

    char letters_a[14] = {0};
    letters_a[0] = 72;
    letters_a[1] = 101;
    letters_a[2] = 108;
    letters_a[3] = 108;
    letters_a[4] = 111;
    letters_a[5] = 44;
    letters_a[6] = 32;
    letters_a[7] = 119;
    letters_a[8] = 111;
    letters_a[9] = 114;
    letters_a[10] = 108;
    letters_a[11] = 100;
    letters_a[12] = 33;
    letters_a[13] = 0;
    show_terminated_letters(letters_a);

    putchar('\n');

    char letters_b[14] = {
        84,  101, 115, 116, 32,
        109, 101, 115, 115, 97,
        103, 101, 46, 0
    };
    show_terminated_letters(letters_b);

    putchar('\n');

    char letters_c[12] = {
        's', 'a', 'm', 'p', 'l', 'e',
        ' ', 't', 'e', 'x', 't', '\0'
    };
    show_terminated_letters(letters_c);

    putchar('\n');

    char letters_d[ENOUGH_SPACE] = "a string";
    show_terminated_letters(letters_d);

    putchar('\n');

    return 0;
}

void show_terminated_letters(char *letters) {
    int i = 0;
    while (letters[i] != '\0') {
        putchar(letters[i]);
        i = i + 1;
    }
}

// Copy a String
// A sample solution.

#include <stdio.h>

#define BUFFER_LENGTH 64

void string_copy(char *destination, char *source, int destination_size);

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;
}

// 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) {
    int i = 0;

    // stop before last array element so we can add '\0'
    while (i < destination_size - 1 && source[i] != '\0') {
        destination[i] = source[i];
        i = i + 1;
    }
    destination[i] = '\0';
}

// CONVERT A STRING TO UPPERCASE
// CREATED BY
//  ... (Z0000000)
// CREATED ON 2019-??-??

#include <stdio.h>

void string_to_upper(char *buffer);
int uppercase(int c);

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;
}

// Convert the characters in `buffer` to upper case
void string_to_upper(char *buffer) {
    int i = 0;
    while (buffer[i] != '\0') {
        buffer[i] = uppercase(buffer[i]);
        i = i + 1;
    }
}

int uppercase(int c) {
    if (c >= 'a' && c <= 'z') {
        return c - 'a' + 'A';
    } else {
        return c;
    }
}

// Perform the ROT13 algorithm on a string -- sample solution.

#include <stdio.h>
#include <assert.h>

#include <string.h>


// Add your own #defines here
#define ALPHABET_LENGTH 26
#define LOWER_START     'a'
#define LOWER_END       (LOWER_START + ALPHABET_LENGTH)
#define UPPER_START     'A'
#define UPPER_END       (UPPER_START + ALPHABET_LENGTH)

#define MAX_LENGTH      256

void rotate_thirteen(char *string);
int rotate_one(int c);
int string_length(char *string);
int strings_equal(char *string_a, char *string_b);

// Add your own function prototypes here
int is_lower_letter(char l);
int is_upper_letter(char l);

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;
}

// See: https://en.wikipedia.org/wiki/ROT13
void rotate_thirteen(char *string) {
    int l = 0;
    int length = string_length(string);
    while (l < length) {
        int i = 0;
        while (i < 13) {
            string[l] = rotate_one(string[l]);
            i = i + 1;
        }
        l = l + 1;
    }
}

// Use your code from the rotate_one warmup here.
int rotate_one(int c) {
    int letter_num = 0;
    int base = '\0';

    // Deal with lowercase and uppercase letters separately.
    if (is_lower_letter(c)) {
        letter_num = c - LOWER_START;
        base = LOWER_START;
    } else if (is_upper_letter(c)) {
        letter_num = c - UPPER_START;
        base = UPPER_START;
    } else {
        // If it's not lowercase or uppercase, it remains unchanged.
        return c;
    }

    // rotate by 1, wrap around alphabet
    letter_num = letter_num + 1;
    letter_num = letter_num % ALPHABET_LENGTH;

    return base + letter_num;
}

int string_length(char *string) {
    // Use your code from the string_length activity here.
    // Lazy tutor solution: use string.h
    return strlen(string);
}

int strings_equal(char *string_a, char *string_b) {
    // Use your code from the strings_equal activity here.
    // Lazy tutor solution: use string.h
    return strcmp(string_a, string_b) == 0;
}

int is_lower_letter(char l) {
    return (l >= LOWER_START && l < LOWER_END);
}

int is_upper_letter(char l) {
    return (l >= UPPER_START && l < UPPER_END);
}