Description
1. (50 points) Suppose you are given an array of integers with a zero as one of elements. You want
to split the array into two arrays, one containing the elements before zero and one containing the
elements after zero.
Sample input/output #1:
Enter the length of the array: 7
Enter the elements of the array: 3 5 0 4 1 3 9
Output:
Array 1: 3 5
Array 2: 4 1 3 9
Sample input/output #2:
Enter the length of the array: 6
Enter the elements of the array: 0 6 13 4 1 7
Output:
Array 1:
Array 2: 6 13 4 1 7
1) Name your program arrays1.c
2) Include the compute() function to compute and return the length of the array 1 by
searching for 0:
int compute(int *a, int n);
a represents the input array with length n. The compute function should use pointer
arithmetic– not subscripting – to visit array elements. In other words, eliminate the
loop index variables and all use of the [] operator in the function.
3) In the main function, ask the user to enter the length of the input array, declare the
input array, call the compute function to find the length of array 1 and calculate the
lengths of array 2, declare array 1 and array 2 and store the elements, then display the
two output arrays. Pointer arithmetic in NOT required in the main function.
2. (50 points) Write a program arrays2.c that checks if an integer array contains three identical
consecutive elements. Assume the number of identical consecutive elements are no more than
three if they exist.
Sample input/output #1:
Enter the length of the array: 11
Enter the elements of the array: -12 0 4 2 2 2 36 7 7 7 43
Output: The array contains 2 of three identical consecutive
elements: 2 7
Sample input/output #2:
Enter the length of the array: 4
Enter the elements of the array: -12 0 4 36
Output: The array does NOT contain identical consecutive
elements
Sample input/output #3:
Enter the length of the array: 11
Enter the elements of the array: -12 0 4 2 2 2 36 7 7 43 43
Output: The array contains 1 of identical consecutive
elements: 2
1) Name your program arrays2.c
2) Include and implement the following function in the program. Do not modify the
function prototype.
void search_three(int *a1, int *a2, int n, int *num_three);
The function takes two integer array parameter a1 and a2 of size n. a1 is the input array.
a2 is the output array containing the integers that are in the three consecutive integers.
num_three as a pointer variable, pointing to the variable for the total number of the three
consecutive integers (also the actual size of the output array). For example, the total number
of the three consecutive integers for sample input #1 is 2, 0 for sample input #2, and 1 for
sample input #3.
The function should use pointer arithmetic – not subscripting – to visit array elements.
In other words, eliminate the loop index variables and all use of the [] operator in the
function.
3) In the main function, ask the user to enter the size of the input array, declare the input
array and output array of the same size, and then ask the user to enter the elements of the
input array. The main function calls search_three function, and displays the result.
Before you submit
1. Compile both programs with –Wall. –Wall shows the warnings by the compiler. Be sure
it compiles on student cluster with no errors and no warnings.
gcc –Wall arrays1.c
gcc –Wall arrays2.c
2. Be sure your Unix source file is read & write protected. Change Unix file permission on
Unix:
chmod 600 arrays1.c
chmod 600 arrays2.c
3. Test your fraction program with the shell scripts on Unix:
chmod +x try_arrays1
./try_arrays1
chmod +x try_arrays2
./try_arrays2
4. Submit arrays1.c and arrays2.c on Canvas.
Grading
Total points: 100 (50 points each problem)
1. A program that does not compile will result in a zero.
2. Runtime error and compilation warning 5%
3. Commenting and style 15%
4. Functionality 80% (Including functions implemented as required)
Programming Style Guidelines
The major purpose of programming style guidelines is to make programs easy to read and
understand. Good programming style helps make it possible for a person knowledgeable in the
application area to quickly read a program and understand how it works.
1. Your program should begin with a comment that briefly summarizes what it does. This
comment should also include your name.
2. In most cases, a function should have a brief comment above its definition describing
what it does. Other than that, comments should be written only needed in order for a
reader to understand what is happening.
3. Information to include in the comment for a function: name of the function, purpose of
the function, meaning of each parameter, description of return value (if any), description
of side effects (if any, such as modifying external variables)
4. Variable names and function names should be sufficiently descriptive that a
knowledgeable reader can easily understand what the variable means and what the
function does. If this is not possible, comments should be added to make the meaning
clear.
5. Use consistent indentation to emphasize block structure.
6. Full line comments inside function bodies should conform to the indentation of the code
where they appear.
7. Macro definitions (#define) should be used for defining symbolic names for numeric
constants. For example: #define PI 3.141592
8. Use names of moderate length for variables. Most names should be between 2 and 12
letters long.
9. Use underscores to make compound names easier to read: tot_vol or
total_volumn is clearer than totalvolumn.
