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

// gnirts a esreveR (Reverse a string)
// A sample solution.

#include <stdio.h>

void string_reverse(char *buffer);
int string_length(char *string);

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

// Takes a string in `buffer`, and reverses it in-place.
void string_reverse(char *buffer) {
    int length = string_length(buffer);
    int i = 0;
    while (i < length/2) {

        // swap array elements
        char tmp = buffer[i];
        buffer[i] = buffer[length - i - 1];
        buffer[length - i - 1] = tmp;

        i = i + 1;
    }
}

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

//  Written 3/3/2018 by Andrew Taylor (andrewt@unsw.edu.au)
//  Write stdin to stdout with upper case letters converted to lower case
// and lower case converted to upper case
//

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

int swap_case(int character);

int main(int argc, char *argv[]) {
    int character = getchar();
    while (character != EOF) {
        int swapped_character = swap_case(character);
        putchar(swapped_character);
        character = getchar();
    }

    return 0;
}


int swap_case(int character) {
    if (character >= 'A' && character <= 'Z') {
        return 'a' + character - 'A';
    } else if (character >= 'a' && character <= 'z') {
        return 'A' + character - 'a';
    } else {
        return character;
    }
}

// Substitution.c
//  Write stdin to stdout encrypted with a Substitution cipher
//  https://en.wikipedia.org/wiki/Substitution_cipher
//
//  The mapping will be supplied as a command-line argument containing 26 characters:
//  These will be an an ordering of the letters 'a'..'z'.
//
// Written 3/3/2018 by Andrew Taylor (andrewt@unsw.edu.au)
// and adapted for 23T2 by Sofia De Bellis, z5418801 on July 2023

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

#define ALPHABET_SIZE  26

int encrypt(char character, char mapping[ALPHABET_SIZE]);

int main(int argc, char *argv[]) {
    char mapping[ALPHABET_SIZE + 1];
    for (int i = 0; i < ALPHABET_SIZE; i++) {
        mapping[i] = argv[1][i];
    }

    mapping[ALPHABET_SIZE] = '\0';
    

    // Error checking - not necessary in student solution or tested
    if (mapping[0] == '\0') {
        printf("Usage: ./substitution <mapping>\n");
        return 1;
    }

    if (strlen(mapping) != ALPHABET_SIZE) {
        printf("./substitution: mapping must contain %d letters\n", ALPHABET_SIZE);
        return 1;
    }

    printf("Enter text:\n");

    char character;
    while (scanf("%c", &character) == 1) {
        int encrypted_character = encrypt(character, mapping);
        printf("%c", encrypted_character);
    }

    return 0;
}

// encrypt letters with a substitution cipher with the specified mapping
int encrypt(char character, char mapping[ALPHABET_SIZE]) {
    if (character >= 'A' && character <= 'Z') {
        return mapping[character - 'A'] - 'a' + 'A';
    } else if (character >= 'a' && character <= 'z') {
        return mapping[character - 'a'];
    } else {
        return character;
    }
}

// Read a string and then print the letters one per line
// written by Andrew Taylor andrewt@cse.unsw.edu.au
// April 2018 as a COMP1511 lab exercise
//

#include <stdio.h>
#include <ctype.h>

#define MAXLINE 5000

int is_palindrome(char line[]);

int main(void) {
    char line[MAXLINE] = {0};
    printf("Enter a string: ");
    fgets(line, MAXLINE, stdin);

    if (is_palindrome(line)) {
        printf("String is a palindrome\n");
    } else{
        printf("String is not a palindrome\n");
    }

    return 0;
}

// return 1 is line is palindromic, 0 otherwise
// line is terminated by either '\n' or '\0'
// case and non-alphabetic characters are ignored
// an empty line is considered a palindrome
int is_palindrome(char line[]) {
    int right = 0;
    while (line[right] != '\0' && line[right] != '\n') {

        right = right + 1;
    }

    right = right - 1;

    int left = 0;
    while (left < right) {
        int left_char = tolower(line[left]);
        int right_char = tolower(line[right]);
        if (!isalpha(left_char)) {
            left = left + 1;
        } else if (!isalpha(right_char)) {
            right = right - 1;
        } else if (left_char != right_char) {
            return 0;
        } else {
            left = left + 1;
            right = right - 1;
        }
    }

    return 1;
}

//  Written 3/3/2018 by Andrew Taylor (andrewt@unsw.edu.au)
//  Read characters from stdin until of input then print the frequency of letters

#include <stdio.h>

#define NOT_A_LETTER   (-1)
#define ALPHABET_SIZE  26

int get_letter_frequencies(int letter_count[ALPHABET_SIZE]);
int letter_index(int character);
void print_frequencies(int letter_count[ALPHABET_SIZE], int n_letters_read);

int main(int argc, char *argv[]) {
    int letter_count[ALPHABET_SIZE] = {0};  // 1 array element for each English letter

    int n_letters_read = get_letter_frequencies(letter_count);
    print_frequencies(letter_count, n_letters_read);
    return 0;
}

// read  characters from stdin, and for uppercase and lower case letters updating
// accumulating count a letter_count in letter_frequencies
// number of uppercase and lower case letters read is returned

int get_letter_frequencies(int letter_count[ALPHABET_SIZE]) {
    char character;
    int n_letters_read = 0;
    while (scanf(" %c", &character) == 1) {
        int index =  letter_index(character);
        if (index != NOT_A_LETTER) {
            letter_count[index] = letter_count[index] + 1;
            n_letters_read = n_letters_read + 1;
        }
    }
    return n_letters_read;
}

// return position of letter in English  alphabet (0..25)
// for lower case and upper case letter
// return NOT_A_LETTER for other characters

int letter_index(int character) {
    if (character >= 'A' && character <= 'Z') {
        return character - 'A';
    } else if (character >= 'a' && character <= 'z') {
        return character - 'a';
    } else {
        return NOT_A_LETTER;
    }
}

void print_frequencies(int letter_count[ALPHABET_SIZE], int n_letters_read) {
    if (n_letters_read == 0) {
        return;
    }
    int i = 0;
    while (i < ALPHABET_SIZE) {
        printf("'%c' %lf %d\n", 'a'+i, letter_count[i]/(double)n_letters_read,  letter_count[i]);
        i = i + 1;
    }
}