Sale!

# LAB 5 Recursions, Pointers and arrays

\$30.00

Category:

1
LAB 5 Recursions, Pointers and arrays

This lab focuses mainly on pointers. Following the recent and near future lectures on pointers,
this lab contains four major parts: Part I: Pointers and passing address of scalar variables. Part II:
Pointer arithmetic. Part III: Pointers and passing char arrays (strings) to functions; Part IV:
Pointers and passing general arrays to functions.
Before delving into pointers, let’s start with exercises on rand() library function and simple
recursions, which we covered recently. We also look at system() library function as an
preparation of the Unix materials that will be covered soon in class.
0 system() library function
• the program calls function rand() to generate random numbers. Randomization is a
fundamental technique in algorithm design. Function rand(), declared in <stdlib.h>,
returns a random integer in the range 0 to RAND_MAX every time it is called.
RAND_MAX is a constant whose default value may vary between implementations but it is
granted to be at least 32767. On machines using the GNU C library RAND_MAX is equal
to INT_MAX.
• to generate a random number in a certain range, e.g., [1, 6] to represent dice rolls, a typical
approach is to use modules operation and then shift by adding the lower bound. Try to
understand the mathematic trick.
• note that rand() is a pseudorandom number generator: the sequence of values it returns
is predictable. Run the program several times and you will notice the same sequence of
random number.
• if you want to get different sequences, you need to seed the random number generator
using srand(). A typical use might be: strand(time(0)). Here time(0) returns the
number of seconds since the epoch (00:00:00 UTC, January 1, 1970, for POSIX systems).
As you observed above, If random numbers are generated with rand() without first calling
srand(), your program will create the same sequence of numbers each time it runs.
Now uncomment the first line, compile and run the program again for several times, and
you will observe different sequence of numbers. (Note that this still might give repeated
values if you run it fast – e.g., twice in the same second). Explore other approaches if you
are interested. Also explore how to generate random number in Java.
Next, uncomment the commented block in the second half of the program.
The code block calls a standard library function system(), whose prototype is
int system(char *command) as given in stdlib.h. Taking as input a string command,
which is a valid Unix command, system() executes a Unix shell command specified in
command, much as if you enter the command in terminal. Compile and run it. Observe that,
• current location is displayed, with pwd command.
• the current directory is listed, and new directories xxxDir were created in the current
directory, and the current directory is listed again. These are performed using ls, mkdir
commands.
Issue commands ls -l in the terminal to verify that directory xxxDir was generated.
2
Remove the directory each time before you run the program again. (Can you do that in terminal
using commands? Try issue command rmdir xxxDir but don’t spend too much time if you
cannot make it. We will learn how to do this in terminal when we cover unix commands later in
the course.)
No submission for this question. lab3D0
0. A Math Library functions, simple recursions (5pt)
Specification
Write an ANSI-C program that reads input from the standard input, which contains one double
and one integer representing a base b and exponent (i.e., power) n, and then calculates b
n
.
After reading base and exponent from the user, the program first calls the math library function
pow(), and then call function my_pow(), which is a recursive function that you are going to
implement here.
The program keeps on prompting user and terminates when user enters -1000 for base
(followed by any number for exponent).
Implementation
need to use %lf. (%f is use for float).
• Your function my_pow(double, double) should be RECURSIVE, not ITERATIVE. That is,
the function should be implemented using RECURSION, not loops. In a recursive solution,
the function calls itself with different (usually smaller) inputs, until the input becomes small
enough so that we can solve the case directly. This case is called a base case.
• Note that although the function’s parameters are of type double, the actual argument for
exponent is assumed to be an integer literal (i.e. the power will not be 3.5). However, the
power can be negative. Your functions should handle this.
Sample Inputs/Outputs
red 117% a.out
Enter base and power: 10 2
pow: 100.0000
my_pow: 100.0000
Enter base and power: 10 4
pow: 10000.0000
my_pow: 10000.0000
Enter base and power: 2 3
pow: 8.0000
my_pow: 8.0000
Enter base and power: 2.3 5
pow: 64.3634
my_pow: 64.3634
Enter base and power: -2 4
pow: 16.0000
my_pow: 16.0000
Enter base and power: -2.75 5
3
pow: -157.2764
my_pow: -157.2764
Enter base and power: 2 -3
pow: 0.1250
my_pow: 0.1250
Enter base and power: 2 -5
pow: 0.0312
my_pow: 0.0312
Enter base and power: 2.7 -3
pow: 0.0508
my_pow: 0.0508
Enter base and power: -2 -6
pow: 0.0156
my_pow: 0.0156
Enter base and power: -2.75 -3
pow: -0.0481
my_pow: -0.0481
Enter base and power: -1000 4
red 118%
Submit your program using submit 2031A lab5 lab5pow.c
Part I Pointers and passing address of scalar variables
1. Problem A (5pt)
Subject
Experiencing “modifying scalar arguments by passing addresses/pointers”.
Specification
Write an ANSI-C program that reads three integers line by line, and modify the input values.
• The program reads user inputs from stdin line by line. Each line of input contains 3 integers
separated by blanks. A line that has the first number being -1 indicates the end of input.
• Store the 3 input integers into variable a, b and c;
• Function swapIncre() is called in main() with an aim to change the values of a, b and
c in such a way that, after function swapIncre returns, b’s value is doubled, a stores c’s
original value incremented by 100, and c stores the original value of a. As an example,
suppose a is 1, b is 2 and c is 3, then after function returns, a has value 103, b has value 4
and c has value 1.
• Compile and run the program and observe unsurprisingly that the values of a, b and c are
not changed at all (why?).
• Modify the program so that it works correctly, as shown in the sample inputs/outputs below.
You should only modify function swapIncre and the statement in main that calls this
function.
No global variables should be used.
4
Sample Inputs/Outputs:
red 309 % a.out
4 8 9
Original inputs: a:4 b:8 c:9
Rearranged inputs: a:109 b:16 c:4
5 12 7
Original inputs: a:5 b:12 c:7
Rearranged inputs: a:107 b:24 c:5
12 20 -3
Original inputs: a:12 b:20 c:-3
Rearranged inputs: a:97 b:40 c:12
12 -3 30
Original inputs: a:12 b:-3 c:30
Rearranged inputs: a:130 b:-6 c:12
-1 2 3
red 309 % cat inputA.txt
3 5 6
2 67 -1
-12 45 66
66 55 1404
22 3 412
-2 44 6
-1 55 605
red 310 % a.out < inputA.txt
Original inputs: a:3 b:5 c:6
Rearranged inputs: a:106 b:10 c:3
Original inputs: a:2 b:67 c:-1
Rearranged inputs: a:99 b:134 c:2
Original inputs: a:-12 b:45 c:66
Rearranged inputs: a:166 b:90 c:-12
Original inputs: a:66 b:55 c:1404
Rearranged inputs: a:1504 b:110 c:66
Original inputs: a:22 b:3 c:412
Rearranged inputs: a:512 b:6 c:22
Original inputs: a:-2 b:44 c:6
Rearranged inputs: a:106 b:88 c:-2
red 311%
Submit using submit 2031A lab5 lab5swap.c
2. Problem A2 (10 pt)
Modify program lab5swap.c, by defining a new function void swap(int *, int *)
which swaps the values of a and c. This function should be called in function swapIncre().
5
Specifically, swapIncre()only increases the value of parameters, and delegates the swapping
You should not change the code of main, and the parameter list of swapIncre given in your
lab5swap.c.
Again, no global variables should be used.
Sample Inputs/Outputs: Same as above.
Name the new program lab5swap2.c and submit using
submit 2031A lab5 lab5swap2.c
3. Problem A3 (10pt)
Modify the above program, by defining a new function void swap(int **, int **)
which swaps the values of a and c. This function should be called in function swapIncre().
Specifically, swapIncre()only increases the value of parameters, and delegates the swapping
You should not change the code of main, and the parameter list of swapIncre given in your
lab5swap.c. Again, no global variables should be used.
Sample Inputs/Outputs: Same as above.
Name the new program lab5swap3.c and submit using
submit 2031A lab5 lab5swap3.c
C supports some arithmetic operations on pointers. For expression p ± n, where p is a pointer
and n is an integer, the result is another address (pointer).
Download program lab5pArithmetic.c and study the code. Then compile and run it several
times. You will get different values each time, but you should always observe the following:
• For pChar which is a pointer to char, expression pChar+1 results in an address (pointer)
whose value is the value of pchar plus 1. For pShort which is a pointer to short,
expression pShort+1 results in an address whose value is the value of pShort plus 2. For
integer pointer pInt, expression pInt+1 results in an address whose value is the value of
pInt plus 4. For Double pointer pDouble, expression pDouble+1 results in an address
whose value is the value of pDouble plus 8. Likewise, these pointers + 2 result in
addresses whose values are the original values plus 2, 4, 8 and 16 respectively. Why
was C designed this way?
• As discussed in class, the rule here is that for a pointer p, arithmetic expression p ± n
results in an address (pointer) whose value is the value of p ± n × s where s is the size of
the type of p’s pointee, in bytes. That is, the result is “scaled” by the size of the pointee type.
Thus, for an integer pointer pInt, expression pInt + n results in an address whose value
is the value of pInt + n×4, assuming size of int is 4 bytes. (Because of this, pointer
arithmetic in C is sometimes colloquially termed “p+1 is p+4”.)
• This rule is further verified by the outputs for p++, which assign the pointers to resulting
addresses, jumping the pointers by 1, 2, 4 and 8 bytes respectively, and the outputs for
p += 4, which jump the pointers by 4×1, 4×2, 4×4 and 4×8 bytes respectively.
fact 1
6
• For an array arr, its elements are stored continuously in memory, with arr occupying
the lowest address. For an integer array like arr, each element occupies 4 bytes in memory.
So the address of arr[i+1] is 4 bytes higher than the address of arr[i]. For a double
array, as another example, address of arr[i+1] is 8 bytes higher than the address of
arr[i].
• If we have a pointer ptr0 that points the first element of the array, i.e., ptr0=&arr¸
then according to the pointer arithmetic rule above (fact 1), ptr0+i results in an address
of value ptr0+i×4, which, due to the fact that array elements are stored continuously in
memory (fact 2), is the address of element i of arr. That is, if ptr0==&arr, then
ptr0+i == &arr[i], which in turn implies that *(ptr0+i) == arr[i].
• Array name arr contains the address of its first element, that is, arr and &arr contain
the same address. So array name can be treated as a pointer (to its first element). Following
pointer arithmetic, arr+i results in an address of value arr+i×4, which is the address of
element i of arr. That is, arr+i == &arr[i], and *(arr +i) == arr[i];
• Since array name arr is a pointer, assignment operation ptr = &arr can be
rewritten as ptr = arr, which assigns ptr the address of the first element of the array,
making ptr point to arr. Consequently, ptr0, ptr, arr and &arr contain
the same value. Hence, we have the rule that if ptr == arr (i.e., ptr points to arr),
then ptr+i == arr+i == &arr[i], and *(ptr+i) == *(arr+i) == arr[i].
Based on the above observations, complete the program so that arr[i] can also be
accessed in two other ways which involve pointer arithmetic, generating the following
outputs
arr[i] *(arr+i) *(ptr0+i) *(ptr+i)
==========================================================================
Element: -100 -100 -100 -100
Element: 100 100 100 100
Element: 200 200 200 200
Element: 300 300 300 300
Element: 400 400 400 400
Element: 500 500 500 500
Element: 600 600 600 600
Element: 700 700 700 700
Element: 800 800 800 800
Element: 900 900 900 900
• observe how a pointer to pointer is declared, initialized, and dereferenced. Understand the
results. For example, why the two (**pp)– statements result in different values?
• Finally, since array name can be used as a pointer, is there any difference between array
name and other pointers such as ptr? Uncomment the last line and compile again. What
did you get? Observe that ptr and pp can be changed as they are pointer variables. Array
name arr, on the other hand, is a pointer constant so cannot be changed.
Why does C have pointer arithmetic and why is the result scaled based on the type? Why array
name contains the address of its first element?
fact 2
fact 3
fact 4
fact 5
7
It turns out that all the above rules were designed with an aim to facilitate passing array to
functions, which is the subject of Part III and Part IV below.
No submission for this question.
Part III Pointers and passing char arrays to functions
Motivation
In C when an array is passed as an argument to a function, it is ‘decayed’ into a single value
which is the (starting) memory address of the array, contained in the array name that is passed
to the function. That is, the function only receives a single address value, rather than the whole
array — whether the pointee at this address is a single variable or it is the first element of an
array, or something else, it is the same form of information that is passed to the function.
Thus, a function that expects an integer array as argument can specify its parameter (formal
argument) either as int[] or int *. Likewise, a function that expects a char array (string) as
argument can specify its parameter (formal argument) either as char[] or char *. (See
prototype of functions in string.h). In calling the function, you can pass as the actual
argument either the array name (which contains the address of its first element), or a pointer to
an element of the array. Either way, passing array by address allows the invoked function to
not only access the argument array but also modify it, even it is called-by-value.
Problem C0
Passing char array as argument, and pointer notation in place of array index notation [].
Download the program lab5strlen.c, which shows more than 10 ways to implement
strlen(). Read the code and run it, and observe the following:
• Firstly, since the array name contains the address of the first element (fact 4), in addition to
array name as we did so far, we can also pass the address &arr explicitly into this
functions. If we have a pointer that points to the start of the string, then we can also pass
the pointer to the functions.
• Functions expecting a char array can specify the parameter (formal argument) either as
char [], or, char *.
• Functions expecting a char array can be called by passing either the array name or a pointer
to an array element as its actual argument.
• Even a function’s formal argument is declared as char[], you can always use pointer
notations to manipulate the argument in the function.
• Even a function’s formal argument is declared as char *, you can always use array
notation [] to manipulate the argument in the function
• Address/pointer arithmetic can be exploited strategically to calculate the string length
• Because of ‘decaying’, sub-arrays can be passed to a function easily. Note the 3 ways to pass
sub-arrays of msg.
• By passing sub-arrays, recursion can be exploited to solve the problem.
• Based on the fact that array elements are stored continuously in memory, and assuming the
array is fully populated, the length of an array can be calculated using sizeof operator,
with sizeof(arr)/sizeof(char) or sizeof(arr)/sizeof(arr[i]).
o In case of char array, we subtract 1 to exclude the ‘\0’.
8
Note that this approach does not work when used on a pointer variable that points to the
array: sizeof ptr gives the memory size of the pointer variable ptr itself, which is
usually 8 bytes. Note, sizeof is an operator, not a function. (As shown later in this lab
(lab5E0), in a function that receives a array argument, using sizeof on parameter also does
not work.)
No submission for this problem.
4.1 Problem C (20+10pt)
Subject Passing char array as argument, accessing argument array. Pointer notion in place of
array index notation.
Specification
Write an ANSI-C program that reads inputs line by line, and determines whether each line of
input forms a palindrome. A palindrome is a word, phrase, or sequence that reads the same
The program terminates when quit is read in.
Implementation
• Assume that each line of input contains at most 30 characters but it may contain blanks.
• Use fgets to read line by line
o note that the line that is read in using fgets will contain a new line character ‘\n’,
right before ‘\0’. Then you either need to exclude it when processing the array, or,
remove the trailing new line character before processing the array. As discussed in class,
one common approach for the latter is replacing the ‘\n’ with ‘\0’.
• Define a function void printReverse (char *) which prints the argument array
reversely.
o Do not use array indexing [] throughout your implementation. Instead, use pointers
and pointer arithmetic to manipulate the array.
o Do not create extra arrays. Manipulate the original array only.
• Define a function int isPalindrome (char *) which determines whether the
argument array (string) is a palindrome.
o Do not use array indexing [] throughout your implementation. Instead, use pointers and
pointer arithmetic to manipulate the array.
o Do not create extra arrays. Manipulate the original array only.
• Do not use global variables.
• [Bonus] Define another function int isPalindromeR (char *) which determines
whether the argument array (string) is a palindrome, using recursion.
o Do not use array indexing [] throughout your implementation. Instead, use pointers and
pointer arithmetic to manipulate the array.
o Do not create extra arrays. Manipulate the original array only.
o isPalindromeR(char*) itself is not necessarily a recursive function. You may want
to create a recursive helper function, which is called by isPalindromeR(char *).
9
Hint: the reason for a helper function is that the recursive function needs more
argument than isPanlidromR(char*)
Sample Inputs/Outputs:
red 339 % a.out
hello
olleh
Not a palindrome
lisaxxasil
lisaxxasil
Is a palindrome.
that is a SI taht
that IS a si taht
Not a palindrome.
that is a si taht
that is a si taht
Is a palindrome.
quit
red 340 %
red 340 % a.out < inputPalin.txt
olleh
Not a palindrome.
doogsisiht
Not a palindrome.
Is a palindrome.
Not a palindrome.
LI Saxxas il
Not a palindrome.
123454321
Is a palindrome.
Is a palindrome.
qwerty uiopoiu ytrewq
Is a palindrome.
33
Is a palindrome.
A
Is a palindrome.
lisaxxtsil
Is a palindrome.
10
that si a si taht
Not a palindrome.
that is a si taht
Is a palindrome.
abCdyfxDCBA
Not a palindrome.
abcdefedcba
Is a palindrome.
red 342 %
Submit using submit 2031A lab5 lab5palin.c
4.2 Problem D (20pt)
Subject
Array name contains address. Thus when an array is passed to a function as argument, the
function is able to not only access the array, but also modify argument array. Pointer notion in
place of array index notation.
Specification
Complete program lab5sort.c, which reads inputs line by line, and then for each line, sorts it
alphabetically, according to the indexes of the characters in ASCII table, in ascending order,
using two approaches. That is, the letter that appears earlier in the ASCII table should appear
earlier in the sorted array. The program terminates when quit is read in.
Implementation
• Assume that each line of input contains at most 50 characters and may contain blanks.
• Use fgets to read line by line
• Define a function void sortArray (char *) which sorts characters in the argument
array according to the index in the ASCII table.
o Don’t use extra arrays. The function should sort and modify the argument array directly.
• Define a function void sortArray2 (char *) which sorts characters in the argument
array according to the index in the ASCII table, using another approach.
o Do not use extra arrays. The function should sort and modify the argument array
directly.
• Do not use array indexing [] throughout the program, except for array declarations in main.
Instead, use pointers and pointer arithmetic to manipulate arrays.
• Do not use global variables.
• People have been investigating sorting problems for centuries and there exist various
sorting algorithms, so don’t try to invent a new one. Also, don’t call library function such as
qSort to do the sorting. Instead, you can implement any one of the existing famous sorting
algorithms, e.g., Bubble Sort, Insertion Sort, Selection Sort, Quick Sort, Merge Sort.
(Compared against recursive algorithms such as Quick Sort, Merge Sort which has O(nlgn)
complexity, the first three algorithms are simpler but slower – O(n2
) complexity). Pseudo-
11
code for Bubble Sort and Selection Sort are given below for you. You can implement these
algorithms or some others. Don’t use [] in your implementation.
BUBBLE-SORT(A)
0. n ← number of elements in A
1. for i ← 0 to n-2 // ≤ n-2
2. for j ← n-1 to i+1 // right to left
3. if A[j] < A[j-1]
4. swap A[j] ↔ A[ j – 1 ]
SELECTION-SORT(A)
0. n ← number of elements in A
1. for i ← 0 to n-2 // ≤ n-2
2. smallest ← i // smallest: index of current smallest, initially i
3. for j ← i + 1 to n-1
4. if A[ j ] appears earlier than A[ smallest ] in ASCII table
5. smallest ← j // update smallest
6. swap A[ i ] ↔ A[ smallest ] // move smallest element to index i
Sample Inputs/Outputs:
red 340 % a.out
hello
ehllo
ehllo
7356890
0356789
0356789
DBECHAGIF
ABCDEFGHI
ABCDEFGHI
hello world
dehllloorw
dehllloorw
2031ON 2021W
00112223NOW
00112223NOW
quit
red 341 % a.out < inputSort.txt
02eehortt
02eehortt
023456ERbbdggjnnos
023456ERbbdggjnnos
12
agghhrrtvy
agghhrrtvy
024667uy
024667uy
000001112239ABCEF
000001112239ABCEF
0123456789opqrstuvwxy
0123456789opqrstuvwxy
abcdefghijklmnopqrstuvwxyz
abcdefghijklmnopqrstuvwxyz
red 342 %
Submit your program with submit 2031A lab5 lab5sort.c
Part IV Pointers and passing general arrays to functions
In C when an array is passed into a function, it is ‘decayed’ into a single memory address. That is,
the function only receives a single address value, rather than the whole array structure itself.
Without a view of the whole structure, the function does not “know” if the pointee at this
address is a single variable or it is the first element of an array. No array length information is
passed to the function automatically, thus the caller should provide the function with the
information about where the array ends. In the case of a character array (string), the special
sentinel character ‘\0’ is used to mark the end of array. For other type of arrays such as int [],
double [], however, the caller needs to provide the function with the length information
explicitly. In this section you will explore different approaches to providing the length info of an
argument array.
5.0. Problem E0
Subject
Exploiting array memory size. (Not working).
Some people think that the function does not necessarily need a terminator token or an extra
argument of length information. The seemingly plausible trick is to use sizeof on parameter.
As implemented in lab5E0.c, one attempt is to get the array length by exploiting the memory
size of the array. Specifically, assuming the array is fully populated, then the number of
elements can be derived with operation sizeof(array)/sizeof(int).
Compile and run lab5E0.c. Observer that,
• For an array, both the functions receive the correct starting address of the argument array.
• sizeof(arrName)/sizeof(type) works in main.
• in both the functions, however, sizeof(formal argument) / sizeof(type) does
not give the correct length of the actual argument array, even when the formal argument is
declared as int [] or char[].
13
Hint：1) array passed to a function is “decayed” to an address. Thus argument c, even if defined
as int c[], is converted to int *c by the compiler; 2) sizeof is an operator, not a
function. (strlen is a function, so it works inside the function). 3) some compiler will give you
No submissions for this problem.
5.1. Problem E. Using terminator token (10pt)
Subject
Explore putting a special sentinel token at the end of array, like the case of string. Use scanf to
detect end of file.
“My data are in my lockers. I occupy several (consecutive) lockers,
starting at locker #10, and the last locker contains a bunny teddy
bear in it” – so given starting locker number #10, the function knows
that the locker with a bunny bear is the end.
Specification
Write an ANSI-C program that reads a list of non-negative integer
values (including 0), until EOF is read in, and then outputs the largest value among in the input
integers.
Assume there are no more than 20 integers. All inputs are non-negative integer literals.
Implementation
• Keep on reading integers using scanf and a loop, and put the integers into an array, until
In earlier labs we have experienced how getchar detects end of file (end of input file or
Ctrl+D). We have used scanf to read input and we have ignored the fact that scanf also
has a return value, which is an integer indicating the number of characters read in, and,
same as getchar, function scanf also returns EOF if end of file is reached. You can issue
man 3 scanf | grep return or
man 3 scanf | grep EOF in the terminal to see details.
• Note that several input integers can appear on the same line. So far we have used scanf to
read a line of input a time (which contains no spaces). Here you can observe that scanf
with a loop can read inputs that appear on the same line, as well as on multiple lines.
• In main, index notation [] should only be used in declaring the array. For the rest of code in
main, you should use pointer indirection and address arithmetic to access and update the
array. No array index [] should be used.
• Define a function void display(int *), which, given an integer array, prints the array
elements.
Note that this function takes just one argument, which is the starting address of array. How
could the caller let the function know where the end of the array is? (Hint: could the caller
add a bunny bear in the array before passing the array to the function?)
In this function, use pointer indirection and address arithmetic to access and traverse the
array. No array index [] should be used in the function.
14
• Define a function int largest(int *), which, given an integer array, returns the
largest integer in the array.
Note that this function also takes just one argument, which is the starting address of array.
In this function, use pointer indirection and address arithmetic to access and traverse the
array. No array index [] should be used in the function.
• Do not use global variables.
Sample Inputs/Outputs:
red 330 % a.out
1 2 0 33
445
23
^D
Inputs: 1 2 0 33 445 23
Largest value: 445
red 331 % a.out < inputE.txt
Inputs: 7 5 3 6 9 18 33 44 5 12 9 0 34 534 128 78
Largest value: 534
Submit using submit 2031A lab5 lab5E.c
5.2 Problem E2 Length info as argument (10 pt)
Subject
Passing length info explicitly. Use scanf to detect end of file.
The above approach provides the length info about argument array by putting a special sentinel
terminator token at the end of the array, like the case of string. This is possible because the
inputs are assumed to be non-negative integer literals. But putting a terminator might not
always be possible.
A more general approach, which is more common for general arrays, is to
pass the length info explicitly to the function (as an additional argument).
“My data are in my lockers. I occupy several (consecutive) lockers, starting
at lock #10, and I occupy eight lockers” – so given starting locker number
#10, the function knows that locker #17 is the end.
Specification
Same problem and requirement as above, but this time suppose the input numbers can be both
positive and negative (so we could not store a special terminator token in the array).
Implementation
• Implement function int largest(int *, int) and void display(int *, int).
Same as before, no array index [] should be used in main, except the array declaration. No
array index [] should be used in largest and display at all.
• Do not use global variables.
Sample Inputs/Outputs:
red 340 % a.out
15
1 2 0 33
-445
23
^D
Inputs: 1 2 0 33 -445 23
Largest value: 33
red 341 % a.out < inputE2.txt
Inputs: 7 5 3 6 9 18 -33 44 5 -12 0 9 -34 534 128 78
Largest value: 534
Name your program lab5E2.c, and submit using submit 2031A lab5 lab5E2.c
5.3 Problem E2-void (10 pt)
Rewrite lab5E2.c such that function largest is void and has one more parameters. That
is, void largest(int *, int, ?) where ? is a type that you decide. Call the
function properly in main so it has the same input and output as problem E2. Note that
function largest should not print anything. Generate output in main as before.
Name your program lab2E2void.c and submit using
submit 2031A lab5 lab5E2void.c
In summary, for this lab you should submit the following files
lab5pow.c
lab5swap.c lab5swap2.c lab5swap3.c
lab5palin.c
lab5sort.c
lab5E.c lab5E2.c lab5E2void.c
You can issue submit -l 2031A lab5 in the terminal, or go to web submit to view the list
of files that you have submitted.
Common Notes
All submitted files should contain the following header:
/***************************************
* EECS2031A – Lab5 *
* Author: Last name, first name *