(5/5)

CSI 1420 Introduction to C Programming & Unix Fall 2018, CRN 44882, Oakland University Homework Assignment #6 - Using Arrays and Functions in C Due: Sunday, December 2, 2018 11:59PM Total Grade Points: 100

Description

In this final assignment, the students will demonstrate their ability to apply two major constructs of the C programming language – Functions and Arrays – to solve computational problems.

Arrays provide a convenient way to store ‘lists’ of homogeneous data. However, using arrays is just one way to organize data; there are numerous other data structure types that are used for computation. Unlike arrays, these data structures cannot be declared or used natively. Before we can store data in a structure and perform operations specific to that structure, we must implement them using “built-in” C constructs, possibly using C arrays.

One such example of data structure without C native support – is a set. In mathematics, a set is a collection of distinct values with well-defined properties and operations. Using notations and symbols from basic set theory, some common operations involving sets are the following:

Union: The union of any two given sets, A and B, is the set of all values that are members of either A or B. The union operation is represented by the ∪ symbol.

A ∪ B = {x|x ∈ A or x ∈ B}

Example: {1,2,3} ∪ {1,2, 4,5} = {1,2, 3, 4,5}

Intersection: The intersection of any two given sets, A and B, is the set of all values that are common in both A and B. The intersection operation is represented by the ∩ symbol.

A ∩ B = {x|x ∈ A and x ∈ B}

Example: {1,2,3} ∪ {2,4,5} = {2}

{1,2} ∪ {4,5} = {} (empty set)

Subtraction: the subtraction of a set B, from another set A, is the set of values that are member(s) of A, but not members of B.

A − B = {x|x ∈ A and x ∉ B}

Example: {1,2,3} − {2,4,5} = {1,3}

You are asked to perform an array implementation of sets to emulate input, output and manipulation of set-like collections of data. You will write several c functions in a way such that a main() function(or any other ‘user’ function) can call your implemented functions and pass array type parameters to store and manipulate sets. Specifically, you have to define the following functions.

1) void set_init(int set_arr[]);

When invoked, the set_init function will modify its integer array argument in a way such that the array contents represent an empty set.

2) void set_input(int set_arr[]);

When invoked, the set_input() function will prompt the user for inputs into the set(represented by the argument array). After each set input, the function will keep re- prompting for further inputs until the user enters -1. After the -1 input, the function will return successfully while the argument array will contain the user set inputs.

3) void set_output(const int set_arr[]);

When invoked, the set_output function will print the set members, comma-separated and within braces. If the set corresponding the argument array is empty, the function will simply print “{}”. DO NOT print any additional message or characters before or after the braces(not even the newline character).

4) int set_cardinality(const int set_arr[]);

When invoked, the set_cardinality function returns the “cardinality”(the number of items/members) of the argument set.

5) int set_contains(const int set_arr[], int value);

The function returns 1(true) if value is a member of the set set_arr, and 0 otherwise.

6) void set_union(const int set_A[], const int set_B[],

int set_union[]);

The set_union function calculates the “union” operation of two sets represented by the first two array argument. The set resulting from the union operation will be populated into the third argument.

7) void set_intersection(const int set_A[], const int set_B[],

int set_intersect[]);

The set_intersection function calculates the “intersection” operation of two sets represented by the first two array argument. The set resulting from the intersection operation will be populated into the third argument.

8) void set_subtraction (const int set_A[], const int set_B[],

int set_sub[]);

The set_subtraction function calculates the “subtraction” operation of two sets represented by the first two array argument. The set resulting from the subtraction operation will be populated into the third argument.

This may seem a lot of functions, but fortunately, some of the above functions have very similar structures. Any of these functions may (and absolutely should) call or ‘use’ the other functions in its definition, and thus, avoid redundancy in code.

A sample program that ‘uses’ the above functions is given below. You may use the following main() function to test your program; however you are encouraged write your own main() function differently in a way that comprehensively tests the correctness of your implemented functions:

#include <stdio.h>

void set_init(int []); void set_input(int []); void set_output(const int []); int set_cardinality(const int []); int set_contains(const int [], int); void set_union(const int [], const int [],int []); void set_intersection(const int [],const int [], int []); void set_subtraction (const int [], const int [], int []);

#define MAX_SET_SIZE 1000

int main() {

int A[MAX_SET_SIZE]; int B[MAX_SET_SIZE];

int uni[MAX_SET_SIZE]; int inter[MAX_SET_SIZE];

int sub1[MAX_SET_SIZE], sub2[MAX_SET_SIZE];

set_init(A); set_init(B);

printf("This program will input data into two sets, perform some basic set"); printf(" operations over them, and output the result of sich operations\n");

printf("Printing the set contents. Both should be empty sets\n"); printf("Set A: "); set_output(A); printf("\t Set B: "); set_output(B); printf("\n");

printf("Before input, cardinality of A and B is %d and %d respectively \n",

set_cardinality(A),set_cardinality(B));

printf("Now reading inputs into set A\n"); set_input(A);

printf("Now reading inputs into set B\n"); set_input(A);

printf("Printing the set contents after input.\n"); printf("Set A: "); set_output(A); printf("\t Set B: "); set_output(B); printf("\n");

printf("After input, cardinality of A and B is now %d and %d respectively \n",

set_cardinality(A),set_cardinality(B));

// set_contains() not tested here. //Write your own test cases for set_contains() and enter inputs accordingly

set_union(A,B,uni); set_intersection(A,B,inter); set_subtraction(A,B,sub1); set_subtraction(B,A,sub2);

printf("\n\n A UNION B is: "); set_output(uni); printf("\n\n A INTERSECTION B is: "); set_output(inter); printf("\n\n A - B is: "); set_output(sub1); printf("\n\n B - A is: "); set_output(sub2);

printf("That's all Folks!\n");

return 0; } Assumptions:

- We assume that the all sets and arrays will store non-negative integer type of data
- We assume that all arrays passed as arguments to the above functions, will have sufficient capacity(at least 1000) to store the sets
- We further assume that while executing the set_input() function, the user will not input duplicate values into the same set.

Submission instructions:

You will only turn in ONE source code file containing the implementation of the aforementioned six function. DO NOT submit your main() function or any program executable file. Your source code must have the name array_set.c . Make sure that the file containing your source code compiles successfully at the SECS Linux servers without any compilation errors or warnings. Be sure to test the correctness of your program by running the program with an appropriate main() function with different user inputs and see it the output matches your expected results.

At the beginning of your source code, you will need to provide a comment block of the following format

/* Name: <Your Name> Assignment: <This homework assignment #> Due Date: <Due Date> Last Modified: <date >

About this project: <In your own words, write a small paragraph about what this project's goals are/what tasks it accomplishes>

Known Issues: <Mention if there is any incompleteness or unfixed bug in your program>

*/

Rules/Guidelines:

- You may not use global variables to complete this assignment
- Each compilation warning in your program will cause 5% penalty to your total grade; and may be accumulated up to 20% of your grade.
- A submitted program that does not compile will incur heavy penalty worth up to 50% of your total grade
- Throughout your program, you should follow appropriate good programming practices. Failing to maintain consistency and recommended style in coding will result in penalty to your grade.

o Identifiers(a.k.a variable names) should be meaningful and descriptive, but not too long o Comments in the same section or on consecutive lines should be aligned with each

other(start from the same cursor position) o Separate different "sections" of code with blank lines

- All content inside a scope, bounded by a pair of curly braces, { and }, should always be indented by a few spaces to the right. This maintains the structure and readability of your program. It also helps to find program bugs caused by mismatched/missing braces

(5/5)

DescriptionIn this final assignment, the students will demonstrate their ability to apply two ma

Path finding involves finding a path from A to B. Typically we want the path to have certain properties,such as being the shortest or to avoid going t

Develop a program to emulate a purchase transaction at a retail store. Thisprogram will have two classes, a LineItem class and a Transaction class. Th

1 Project 1 Introduction - the SeaPort Project series For this set of projects for the course, we wish to simulate some of the aspects of a number of

1 Project 2 Introduction - the SeaPort Project series For this set of projects for the course, we wish to simulate some of the aspects of a number of