Introgramming & Unix Fall 2018, CRN 44882, Oakland University Homework Assignment 6 - Using Arrays and Functions in C

INSTRUCTIONS TO CANDIDATES

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
#include
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 operationsn");
printf("Printing the set contents. Both should be empty setsn");
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 An");
set_input(A);
printf("Now reading inputs into set Bn");
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("nn A UNION B is: ");
set_output(uni);
printf("nn A INTERSECTION B is: ");
set_output(inter);
printf("nn A - B is: ");
set_output(sub1);
printf("nn 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:
Assignment:
Due Date:
*/

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
 A submitted program that does not compile will incur heavy penalty worth up to 50% of your
 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

Related Questions

. The standard path finding involves finding the (shortest) path from an origin to a destination, typically on a map. This is an

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. This program will have two classes, a LineItem class and a Transaction class. The LineItem class will represent an individual

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

. SeaPort Project series For this set of projects for the course, we wish to simulate some of the aspects of a number of Sea Ports. Here are the classes and their instance variables we wish to define:

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

. 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 Sea Ports. Here are the classes and their instance variables we wish to define:

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

. The first programming project involves writing a program that parses, using recursive descent, a GUI definition language defined in an input file and generates the GUI that it defines. The grammar for this language is defined below:

1Project 1The first programming project involves writing a program that parses, using recursive descent, a GUIdefinition language defined in an input

Hire Me

Hire Me