Programming Project 6 EE312


Category: You will Instantly receive a download link for .zip solution file upon Payment


5/5 - (2 votes)

Part 1: Write three functions to find the smallest element in a set. The first function,
minIt, should use a loop (i.e., be an iterative solution). The second function minRec1
should be a recursive function that uses a decomposition where the size of the smaller
problem is n-1 (where n is the size of the original problem). The third function, minRec2
should be a recursive function that uses a decomposition where the size of the smaller
problem is n/2. Note that your recursive functions will not have any loops!
Part 2: Write two functions to calculate the square root of a number. The first function,
squareIt should be iterative and the second function squareRec should be recursive.
You’ll be using floating point numbers (type double) for this question, so it is impossible
to calculate the square root exactly. Instead you must calculate the square root accurate
to 15 (decimal) significant digits. Your functions will use three parameters. The first
parameter is the value for which you must calculate the square root. The other two
parameters are “guesses”. The first guess is guaranteed to be smaller than the actual
square root. The second guess is guaranteed to be larger than the actual square root.
These parameters should give you a big hint how to solve this problem.
Part 2: Write two functions to perform string comparison. Both functions must use only
recursion (no loops or global variables). In the first function, write the conventional
strcmp function, which compares characters using their ASCII values. The comparison is
case sensitive, and punctuation is significant. So, for example, “ zzz” is less than “aaa”
because the former string has a space in front (ASCII 32) which is less than the ASCII for
‘a’. Follow the conventions for strcmp, return -1 if the first string is less than the second,
return 0 if the strings are the same and return 1 if the first string is greater than the
second. Call your function strCompare (it’s already declared for you in the project file).
Once you’ve finished writing the traditional strcmp function (using only recursion!) write
a new version of the function that compares only the letters in the strings and ignores the
case (upper/lower case) of the letters. For this version, “ ZZZ” is greater than “aaa” since

the space is ignored and the capitalization is also ignored. Similarly, the two strings “C++
programming” and “c programming” are equal to each other. Name this function
strCompare2 (it’s also already declared for you in the project file).
Part 4: Write two functions to find the solution to a maze. The maze is represented by a
two-dimensional matrix. The syntax for accessing an element of the matrix is
maze[row][col] where row and col are the row number and column number for a
cell in the matrix. If the value of an element in the matrix is 1, then the corresponding
square in the matrix is a wall, and you cannot go into that square. If the value of the
element is 0, then you can go into the square. The entrance to the maze is a square in row
0 and the exit is a square in the last row (MATRIX_SIZE – 1). The maze is square with
MATRIX_SIZE rows and MATRIX_SIZE columns.
The maze is generated with some special properties that make finding a solution
relatively easy. There is exactly one path between any two squares in the maze (except
walls of course, there are no paths that allow you to walk into a wall). To look at the
maze that’s generated, call the printMaze function and you’ll see what I mean.
For the iterative solution to the maze problem, you’ll rely on this property. The
algorithm you’ll use is “follow the right hand wall”. The image you should have isthat
of a blind person trying to get out of the maze. By sticking out their right arm and
keeping their right hand along a wall, they’ll eventually get out of the maze. To code this
algorithm in C, you’ll need to keep track of where you currently are in the maze, and
what direction you are currently heading. I’ve written a few functions to help you
“move” through the maze. The functions turnRight and turnLeft assume that you’re
using an integer to keep track of your direction. The four directions are 0 for up (rows get
smaller, columns stay the same) 1 for moving right (the row stays the same, but the
column increases), 2 for moving down (the row increases, the column stays the same) and
three for moving left (the row stays the same and the column decreases). The function
adjacentCell calculates the correct row and column for one of the four adjacent cells to
your current position. Note that you are not allowed to move diagonally, only one of the
four directions.
Anyway, the basic technique is to keep walking through the maze with your right hand on
the wall until you get to the last row of the maze at which point you should stop (you’ve
found the exit). To prove that you’ve found your path through the maze, you should
leave a trail of “bread crumbs” on the path. For full credit, your bread crumbs should
only be left along the correct path to the exit (this is not as hard as it might sound – the
maze is designed to ensure that there’s only one path to the exit that does not involve
backtracking). To indicate a bread crumb, you should set the element in the matrix equal
to 2. When you run printMaze any of the squares with bread crumbs will be displayed as
the letter “o”.
For the recursive solution to the problem you’ll write a much more general maze solver.
Unlike the iterative version, there’s a fairly straightforward recursive solution to mazes
that will work with any type of maze (recall for this problem we’re generating a special

maze so that the “follow the right hand wall” will work). In any event, for the recursive
solution you’ll drop a bread crumb in the current square and then check to see if any of
your adjacent squares are on a path to the exit. If any square you encounter already has a
bread crumb in it, then it is not on a path to the exit (since you’ve already been to this
square and dropped a bread crumb, you’re walking around in circles, hardly the best path
to anywhere). If all of the adjacent squares are either walls, or have bread crumbs in
them, then this square is clearly not on the correct path to the exit. Similarly, if all the
adjacent squares are walls, or are known not to be on the best path, then this square is not
on the best path. There’s a bit more detailed hint in the comments in Project6.cpp.
Please note the maze is much more challenging than the first three. The iterative version
is interesting, but will not be graded.
Part 5: Write a function that makes change. The input to the function is the amount of
money (cents). The return value from the function must be a struct where the components
indicate the number of coins which will add up to the amount of money. For this
problem, we’ll use a fictitious currency (Martian currency) which has 1-cent, 5-cent and
12-cent coins (pennies, nicks and dodeks). To receive credit, your function must use the
minimum number of coins possible. For example, if the input to the function were 15,
then you should return a Martian struct with the dodek and pennies components both set
to zero and the nicks component set to 3 (since three nicks is the most efficient way to
create 15 cents using martian currency). If the input were 17, then you should return a
Martian struct with pennies equal to zero, nicks equal to 1 and dodeks equal to 1.
The real version of this problem is one where the value of each of the coins is not known
in advance. i.e., you know there are three coins, and one of the coins (the penny) is worth
1 cent. However all you know about the other coins is that the nick is worth a cents, the
dodek is worth b cents, and 1 < a < b for some integers a and b. Clearly, if you can solve
this version of the problem, then you can solve the specific case where a = 5 and b = 12
(described above). Both versions of the problem are included in Project5.cpp for you to
CHECKLIST – Did you remember to:
 Re-read the requirements after you finished your program to ensure that you
meet all of them?
 Make sure that your program passes all our testcases?
 Make up your own testcases?
 Upload your solution to Canvas?
 Download your uploaded solution into a fresh directory and re-run all testcases?
Q: I am getting Warnings about deprecated functions on mario.
A: Type ‘module load gcc’ after logging in to mario, before typing
make. See Piazza also for further details.
Q: Can we use globals or static variables? How about helper

A: You can’t use your own globals or statics, but you can use
helper functions as long as they don’t have loops, globals, or
Q: Are we allowed to modify the whatLetter function in our starter
A: No, but you can write your own different function.
Q: Does the sqrt function need to work for values less than 1 and
negative values?
A: It should work for values less than 1, but you can assume you
won’t get negative values.
Q: What should the min function return if the array length is 0?
A: The minimum isn’t well defined there, so we will not give you a
case where the array length is 0.
Q: Do we have to do anything with the iterative functions? Can we
delete them?
A: You don’t have to fill them in, but you shouldn’t delete them.
Just leave them blank if you don’t want to do them.
Q: How can I test my maze function with more mazes?
A: Seed the random number generator used to make the maze. Right
before the makeMaze function in main, there is a call to srand
that passes in a number. Changing that number will create a
different maze to test with.
Q: For the makeChange function, if there are multiple ways to use
the fewest number of coins, which one do we choose?
A: It doesn’t matter, we will take care of it.
Q: Do we put a ‘o’ at the start and end of the maze too?
A: Yes, both start and end.
Q: What is the maximum amount of money that will be tested for

A: After 50 or so, the function gets pretty slow because we are
using almost a brute force algorithm. We will not test higher than
Q: How do I check the accuracy of my square root?
Since doubles have about 15-16 decimal digits of accuracy, the
program is doable with doubles. You may divide the difference
between low_guess and high_guess by their average, and it should
be <= 10^(-15). For example, if the guesses are 8.0001 and
8.0002, the number we get is 0.0001/8, which is < 0.00001, which
is < 10^-5. So we conclude that the number 8.0001 is accurate to
5 decimal digits.