DPST1091 Revision Arrays Sample Solutions

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

#define SIZE 5

struct passenger {
    double height;
    int num_bags;
};

int main(void) {

    struct passenger my_array[SIZE];
    
    for(int i = 0; i < SIZE; i++) {
        printf("Enter height & number of bags: ");
        scanf("%lf %d", &my_array[i].height, &my_array[i].num_bags);
    }

    double filter_height;
    printf("Select height: ");
    scanf("%lf", &filter_height);

    int count = 0;
    for (int i = 0; i < SIZE; i++) {
        if (my_array[i].height >= filter_height) {
            count += my_array[i].num_bags;
        }
    }

    printf("Total of %d bags from people over %lf\n", count, filter_height);


    return 0;
}

// Some useful array functions
// Sample solution.

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

#define SMALL_ARRAY 5
#define MEDIUM_ARRAY 20
#define LARGE_ARRAY 200

// Display useful facts about the array (changes the array).
void array_facts(int size, int array[]);

// Reading and showing arrays.
void scan_array(int size, int array[]);
void show_array(int size, int array[]);

// Array functions without side effects.
int array_max(int size, int array[]);
int array_min(int size, int array[]);
int array_sum(int size, int array[]);
int array_average(int size, int array[]);

// Changing the whole array.
void array_add(int size, int array[], int num);
void array_scale(int size, int array[], int num);

int main(int argc, char *argv[]) {
    // Create an array with 5 elements.
    int array_a[SMALL_ARRAY] = {1, 2, 3, 4, 5};

    // Assert the min, max, and sum are what we expect.
    assert(array_min(SMALL_ARRAY, array_a) == 1);
    assert(array_max(SMALL_ARRAY, array_a) == 5);
    assert(array_sum(SMALL_ARRAY, array_a) == 15);
    assert(array_average(SMALL_ARRAY, array_a) == 3);

    // Add 1 to all of the values in the array.
    array_add(SMALL_ARRAY, array_a, 1);

    // Check the min/max/sum/average again.
    assert(array_min(SMALL_ARRAY, array_a) == 2);
    assert(array_max(SMALL_ARRAY, array_a) == 6);
    assert(array_sum(SMALL_ARRAY, array_a) == 20);
    assert(array_average(SMALL_ARRAY, array_a) == 4);

    // Create a medium-sized array to perform more unit tests.
    int array_b[MEDIUM_ARRAY] = {0};
    int b = 0;
    while (b < MEDIUM_ARRAY) {
        array_b[b] = b * b;
        b = b + 1;
    }

    // Check that the min/max/sum/average are what we'd expect.
    assert(array_min(MEDIUM_ARRAY, array_b) == 0);
    assert(array_max(MEDIUM_ARRAY, array_b) == 361);
    assert(array_sum(MEDIUM_ARRAY, array_b) == 2470);
    assert(array_average(MEDIUM_ARRAY, array_b) == 123);

    // Scale the array by -2, and then re-check the min/max/sum/average.
    array_scale(MEDIUM_ARRAY, array_b, -2);
    assert(array_min(MEDIUM_ARRAY, array_b) == -722);
    assert(array_max(MEDIUM_ARRAY, array_b) == 0);
    assert(array_sum(MEDIUM_ARRAY, array_b) == -4940);
    assert(array_average(MEDIUM_ARRAY, array_b) == -247);

    // Test an array with manual values
    int manual_array[MEDIUM_ARRAY] = {0};
    scan_array(MEDIUM_ARRAY, manual_array);
    array_facts(MEDIUM_ARRAY, manual_array);

    printf("All tests passed. You are Awesome!");

    return 0;
}

// Display some useful facts about an array.
// NOTE: this will change the array that is used.
void array_facts(int size, int array[]) {
    printf("The largest value in the array is %d\n",
            array_max(size, array));
    printf("The smallest value in the array is %d\n",
            array_min(size, array));
    printf("The sum of all values in the array is %d\n",
            array_sum(size, array));
    printf("The average value in the array is %d\n",
            array_average(size, array));

    int s = 0;
    while (s < 5) {
        printf("The array with %d added to all elements:\n", s);
        array_add(size, array, s);
        show_array(size, array);
        s = s + 1;
    }

    printf("The array with 10 subtracted from all elements:\n");
    array_add(size, array, -10);
    show_array(size, array);

    int m = 1;
    while (m <= 5) {
        printf("The array with all elements multiplied by %d:\n", m);
        array_scale(size, array, m);
        show_array(size, array);
        m = m + 1;
    }
}

// Read values from the screen, and store the values in an array.
void scan_array(int size, int array[]) {
    printf("Enter %d numbers: ", size);
    int i = 0;
    while (i < size) {
        scanf("%d", &array[i]);
        i = i + 1;
    }
}

// Show an array on the screen.
// This should look like [0, 1, 2, 3, 4, 5]
void show_array(int size, int array[]) {
    printf("[");
    int i = 0;
    while (i < size) {
        printf("%d", array[i]);
        i = i + 1;

        // Add the comma and space
        if (i != size) {
            printf(", ");
        }
    }
    printf("]\n");
}

// Return the largest value in an array.
int array_max(int size, int array[]) {
    int max = array[0];
    int i = 0;
    while (i < size) {
        if (array[i] > max) {
            max = array[i];
        }
        i = i + 1;
    }
    return max;
}

// Return the smallest value in the array.
int array_min(int size, int array[]) {
    int min = array[0];
    int i = 0;
    while (i < size) {
        if (array[i] < min) {
            min = array[i];
        }
        i = i + 1;
    }
    return min;
}

// Return the sum of all values in the array.
int array_sum(int size, int array[]) {
    int sum = 0;
    int i = 0;
    while (i < size) {
        sum += array[i];
        i = i + 1;
    }
    return sum;
}

// Return the average of all values in the array.
int array_average(int size, int array[]) {
    return array_sum(size, array) / size;
}

// Add num to all values in the array.
void array_add(int size, int array[], int num) {
    int i = 0;
    while (i < size) {
        array[i] += num;
        i = i + 1;
    }
}

// Multiply all values in the array by num.
void array_scale(int size, int array[], int num) {
    int i = 0;
    while (i < size) {
        array[i] *= num;
        i = i + 1;
    }
}

#include <stdio.h>

#define MAX_SIZE 100

/**
 * The array is split into two parts by the index passed in so 
 * the first part has indexes until the index non-inclusive and 
 * the second part has indexes including the index till the end of the array.
 * This function finds the sum of the first part and puts it into the first sum,
 * and finds the sum of the second part and puts it into the second sum.
 *
 * Takes in 
 * the array "array", 
 * the array's length "length", 
 * the index that splits the array into two parts "index", 
 * a pointer to where the value of the first part of the array's sum should be 
 * placed "first_sum" and 
 * a pointer to where the value of the second part of the array's sum should be 
 * placed "second_sum".
 *
 * Returns nothing.
 */
void split_sum(int array[], int length, int index, int *first_sum, int *second_sum) {

    // Gets the first sum of the array
    int i = 0;
    int sum = 0;
    while (i < index) {
        sum += array[i];
        i += 1;
    }
    *first_sum = sum;

    // Gets the second sum of the array
    sum = 0;
    while (i < length) {
        sum += array[i];
        i += 1;
    }
    *second_sum = sum;

    return;
}

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

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

    printf("Enter array values: ");
    int i = 0;
    int array[MAX_SIZE] = {0};
    while (i < length) {
        scanf("%d", &array[i]);
        i += 1;
    }

    printf("Enter index: ");
    int index;
    scanf("%d", &index);
    
    int first_sum;
    int second_sum;
    split_sum(array, length, index, &first_sum, &second_sum);

    printf("First sum: %d\n", first_sum);
    printf("Second sum: %d\n", second_sum);

    return 0;
}

// A program to print a list of integers in reverse
// Written by Tom Kunc (t.kunc@unsw.edu.au)
// Created in 2019-06-23

#include <stdio.h>

#define MAX_NUMBERS 100

int main(void) {
    
    int i = 0;
    int did_scan_something = 0;
    int scanned_value;
    int scanned_numbers[MAX_NUMBERS];

    printf("Enter numbers forwards:\n");

    while (scanf("%d", &scanned_value) == 1) {
        scanned_numbers[i] = scanned_value;
        did_scan_something = 1;
        i++;
    }
    
    printf("Reversed:\n");

    while (i > 0 && did_scan_something) {
        i--;
        printf("%d\n", scanned_numbers[i]);
    }

    return 0;
}

// This program was written by YOUR-NAME-HERE (z5555555)
// 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;
}

int common_elements(int length, int source1[length], int source2[length], int destination[length]) {
    int upto = 0;
    int a1 = 0;
    while (a1 < length) {
        int found = 0;
        int a2 = 0;
        while (a2 < length && !found) {
            if (source1[a1] == source2[a2]) {
                found = 1;
            }
            a2 = a2 + 1;
        }
        if (found) {
            destination[upto] = source1[a1];
            upto = upto + 1;
        }
        a1 = a1 + 1;
    }
    return upto;
}

int count_bigger(int length, int array[length]) {
    int bigger = 0;

    int i = 0;
    while (i < length) {
        if (array[i] > 99 || array[i] < -99) {
            bigger = bigger + 1;
        }
        i = i + 1;
    }

    return bigger;
}