Programming Fundamentals

// Written 14/3/2018 by Andrew Taylor (andrewt@unsw.edu.au)
// as a test for COMP1511

// Print a hollow triangle

#include <stdio.h>

int main(void) {

    int size;
    printf("Enter size: ");
    scanf("%d", &size);

    int row = 1;
    while (row <= size) {
        int col = 1;
        while (col <= row) {
            // row == size gives horizontal line
            // row == col gives diagonal line
            // col == 1 gives vertical line
            if (row == size || col == 1 || row == col) {
                printf("*");
            } else {
                printf(" ");
            }
            col = col + 1;
        }
        printf("\n");
        row = row + 1;
    }

    return 0;
}

// Written 14/3/2018 by Andrew Taylor (andrewt@unsw.edu.au)
// as a lab example for COMP1511

// Print an nxn "x" pattern of asterisks and spaces
//
// For example here is the output for n == 9
//
// *-------*
// -*-----*-
// --*---*--
// ---*-*---
// ----*----
// ---*-*---
// --*---*--
// -*-----*-
// *-------*

#include <stdio.h>

int main(void) {
    int size, n_numbers_read;
    int row, column;

    printf("Enter size: ");
    n_numbers_read = scanf("%d", &size);

    if (n_numbers_read != 1) {
        // scanf failed to read a number
        return 1;
    }

    if (size < 5 || size % 2 != 1) {
        printf("Error: size has to be odd and >= 5.\n");
        return 1;
    }

    row = 0;
    while (row < size) {
        column = 0;
        while (column < size) {
            if (row == column || row == size - (column + 1)) {
                printf("*");
            } else {
                printf("-");
            }
            column = column + 1;
        }
        printf("\n");
        row = row + 1;
    }

    return 0;
}

// This program was written by YOUR-NAME-HERE (zXXXXXXX)
// on INSERT-DATE-HERE

#include <stdio.h>

#define MAX_SIZE 100

int is_perfect_square(int n) {

    int i = 0;
    while (i * i < n) {
        i++;
    }

    if (i * i == n) {
        return 1;
    }

    return 0;
}

int count_perfect_squares(int length, int array[]) {
    int count = 0;
    for (int i = 0; i < length; i++) {
        if (is_perfect_square(array[i])) {
            count++;
        }
    }

    return count;
}

int main(void) {

    int size;
    scanf("%d", &size);

    int array[MAX_SIZE];

    for(int i = 0; i < size; i++) {
        scanf("%d", &array[i]);
        if (is_perfect_square(array[i])) {
            printf("%d is a perfect square\n", array[i]);
        } else {
            printf("%d is not a perfect square\n", array[i]);
        }
    }


    printf("number of perfect squares: %d\n", 
           count_perfect_squares(size, array));
    return 0;
}

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

// This program was written by YOUR-NAME-HERE (zXXXXXXX)
// on INSERT-DATE-HERE

#include <stdio.h>

int dot_product(int length, int vector1[], int vector2[]);

// This is a simple main function that you can use to test your array_sum_prod
// function.
// It will not be marked - only your function will be marked.
//
// Note: the autotest does not call this main function!
// It calls your function directly.
// Any changes that you make to this main function will not affect the autotests.
int main(void) {

    //Feel free to modify any of these tests.
    int test_vector1[] = {5, 10, 3};
    int test_vector2[] = {5, 3, 17};
    int test_vector3[] = {-5, 0, 1};

    int result = dot_product(3, test_vector1, test_vector2);

    printf("Result: %d\n", result);

    int result2 = dot_product(3, test_vector2, test_vector3);

    printf("Result2: %d\n", result2);

    return 0;
}



// Calculates the dot product of two arrays of the same length.
//
// Parameters:
//  `length`: the length of both arrays
//  `vector1`: The first array
//  `vector2`: The second array
//
// Returns: the dot product of `vector1` and `vector2`.
int dot_product(int length, int vector1[], int vector2[]) {
    int result = 0;
    for (int i = 0; i < length; i++) {
        result += vector1[i] * vector2[i];
    }

    return result;
}

#include <stdio.h>
#define TEST_ARRAY_SIZE 100

// Return the number of "small" values in a square 2D array
// with sides of length side_length.
// A "small" value is greater than -10 and less than +10.
int array_max(int array[TEST_ARRAY_SIZE][TEST_ARRAY_SIZE], int side_length) {
    // PUT YOUR CODE HERE (you must change the next line!)
    int max = array[0][0];
    int i = 0;
    while (i < side_length) {
        int j = 0;
        while (j < side_length) {
            if (array[i][j] > max) {
                max = array[i][j];
            }
            j++;
        }
        i++;
    }
    return max;
}

// This is a simple main function which could be used
// to test your array_max function.
// It will not be marked.

int main(void) {
    int test_array[TEST_ARRAY_SIZE][TEST_ARRAY_SIZE] = {
        { 1,    2,   3,    4  },
        {-1,  -11, -111, -111},
        { 0,   0,   0,    0  },
        { 22, -22,  2,    2  }
    };

    int result;

    result = array_max(test_array, 1);
    printf("Largest value in 1x1 array: %d\n", result);

    result = array_max(test_array, 2);
    printf("Largest value in 2x2 array: %d\n", result);

    result = array_max(test_array, 3);
    printf("Largest value in 3x3 array: %d\n", result);

    result = array_max(test_array, 4);
    printf("Largest value in 4x4 array: %d\n", result);

    return 0;
}

// This program was written by YOUR-NAME-HERE (zXXXXXXX)
// on INSERT-DATE-HERE

#include <stdio.h>

#define SIZE 7
#define TRUE 1
#define FALSE !TRUE

int find_treasure(char map[SIZE][SIZE], int *row_pointer, int *col_pointer);

// This is a simple main function that you can use to test your function.
// It will not be marked - only your function will be marked.
//
// Note: the autotest does not call this main function!
// It calls your function directly.
// Any changes that you make to this main function will not affect the autotests.
int main(void) {

    //Feel free to modify the treasure map to test your code:
    char treasure_map[SIZE][SIZE] = {
        {'O', 'O', 'O', 'O', 'O', 'O', 'O'},
        {'O', 'O', 'O', 'O', 'O', 'O', 'O'},
        {'O', 'O', 'O', 'O', 'O', 'O', 'O'},
        {'O', 'O', 'O', 'O', 'O', 'O', 'O'},
        {'O', 'O', 'O', 'O', 'O', 'O', 'O'},
        {'O', 'O', 'X', 'O', 'O', 'O', 'O'},
        {'O', 'O', 'O', 'O', 'O', 'O', 'O'},
    };

    int row;
    int col;

    //Pass in the address of the row and column variables
    int contains_treasure = find_treasure(treasure_map, &row, &col);

    if (contains_treasure) {
        printf("Treasure was found at coordinates (%d, %d)!\n", row, col);
    } else {
        printf("The map contained no treasure :(\n");
    }
   
    return 0;
}



// Finds the location of the 'X' in the 2d array.
//
// Parameters:
//  `map`: a 2d array of chars which contains at most one 'X'.
//  `row_pointer`: A pointer to an integer. 
//      If the map contains an 'X', this pointer should be used to set the 
//      integer to the row number of the 'X'.
//  `col_pointer`: A pointer to an integer. 
//      If the map contains an 'X', this pointer should be used to set the 
//      integer to the column number of the 'X'.
//
// Returns: 1 if the treasure was found, 0 otherwise
int find_treasure(char map[SIZE][SIZE], int *row_pointer, int *col_pointer) {

    int treasure_was_found = FALSE;

    for (int row = 0; row < SIZE; row++) {
        for (int col = 0; col < SIZE; col++) {
            if (map[row][col] == 'X') {
                *row_pointer = row;
                *col_pointer = col;
                treasure_was_found = TRUE;
            }
        }
    }

    return treasure_was_found;
}