Question

Fix this C++ below so does not use any loops at all. Use recursion instead. here is some guides given.

Create a directory to hold assignment 3. Copy files hailstone.cpp, Makefile and dotestassignment 2 to the assignment 3 directory. Edit the comments at the top of hailstone.cppto say that this is assignment 3. You should be able to keep the same contracts, 'next' function and 'main' function from assignment 2, unless they contained errors that needed to be fixed. If necessary, edit those functions so that they do not change the value of any variable, once the variable has a value.
2. Modify the other functions so that they use recursion instead of loops. Modify them one at at time, and test each one after modifying it. Do not try to modify them all then test them all together. The remaining items give some hints.
3. Modify the function that prints the entire sequence. Include a special case for n = 1. When n > 1, the sequence that starts at n contains n followed by the sequence that starts at next(n).
4. Suppose that you want to find the length of the hailstone sequence starting at 7. Notice that next(7) = 22. If you ask for the length of the hailstone sequence starting at 22 (result: 16), how would you determine the length of the sequence starting at 7? Handle the length of the sequence starting at 1 as a special case. Use an if-statement to decide whether this is the special case of n = 1 or not.
5. Suppose that you want to know the largest number in the sequence starting at 7. Ask for the largest number in the sequence starting at 22. (The answer is 52.) The largest number for 7 is clearly the larger of 7 and 52, since 7 is the only number that was not already taken into account in the sequence starting at 22. As another example, suppose that you want to know the largest number in the sequence starting at 52. Ask for the largest number in the sequence starting at 26 (since next(52) = 26). The answer is 40. What you want is the larger of 52 and 40: clearly 52. Important Note. In terms of efficiency, recursion acts as an amplifier. Algorithm designers use it because, if they think of a clever idea and they use it in a recursive definition, recursion amplifies it into a very efficient algorithm. But recursion also amplifies bad ideas. If you do something in a slopply way in a recursive function, recursion can amplify it and make a very slow algorithm. In particular, if you do the same recursive call twice, which is a waste of time, recursion will be very slow. Try your program on input 97. Does it respond quickly, or is it really slow? Try it on a few larger numbers, say around 1000.
6. Suppose you want to compute the length of the longest sequence starting on a number from 1 to n. Ifn = 1, the answer is obvious. If n > 1, first get the length k of the longest sequence starting on a number from 1 to n − 1. Then compute the larger of length(n) and k.
7. Suppose you want to compute the starting value of the longest sequence starting on a number from 1 to n. Again, the answer is obvious when n = 1. If n > 1, first get the starting value m of the longest sequence starting on a number from 1 to n − 1. Then compare length(n) and length(m). How can you determine the answer from the result of that comparison? HERE IS THE CODE Fix this C++ below so does not use any loops at all. Use recursion instead. // next //=========================================== //next(n) returns next value in the hailstone //sequence that follows n //=========================================== #include int next(int n) { int x = n; if (x % 2 == 0) { return x / 2; } else { return 3 * x + 1; } } //=========================================== // hailOut //=========================================== //hailOut(n) prints the hailstone sequence //to the standard output //=========================================== void hailOut(int n) { for (int x = n; x > 1; x = next(x)) { printf("%i ", x); } printf("1 "); } //=========================================== // hailLength //=========================================== //hailLength(n) returns the length of the //hailstone sequence starting at n //=========================================== int hailLength(int n) { int count = 1; int x = n; while (x > 1) { x = next(x); count++; } return count; } //=========================================== // hailLargest //=========================================== //hailLargest(n) returns the largest value of //the hailstone sequence starting at n //=========================================== int hailLargest(int n) { int ans = n; int x = n; while (x != 1) { if (ans <= x) { ans = x; } x = next(x); } return ans; } //=========================================== // hailLargestLength //=========================================== //hailLargestLength(n) returns the largest //possible length of a sequence that starts //from 1 to n //=========================================== int hailLargestLength(int n) { int x = n; int ans = hailLength(x); if (x == 1) { return 1; } while (x > 1) { if (ans <= hailLength(x)) { ans = hailLength(x); } x = x - 1; } return ans; } //=========================================== // hailLargestStartValue //=========================================== //hailLargestStartValue(n) returns the start //value of the longest hailstone sequence //starting with a number from 1 to n. //=========================================== int hailLargestStartValue(int n) { int x = n; int val = n; int ans = hailLength(x); if (x == 1) { return 1; } while (x > 1) { if (ans <= hailLength(x)) { ans = hailLength(x); val = x; } x = x - 1; } return val; } //=========================================== // hailSequenceLargestValue //=========================================== //hailSequenceLargestValue(n) returns the //largest value that occurs in a hailstone //sequence that starts with a number from 1 to n. //=========================================== int hailSequenceLargestValue(int n) { int x = n; int ans = hailLargest(x); if (x == 1) { return 1; } while (x > 1) { if (ans <= hailLargest(x)) { ans = hailLargest(x); } x = x - 1; } return ans; } //=========================================== // main //=========================================== int main() { int n = 0; printf("What number shall I start with? "); scanf("%i", &n); printf("The hailstone sequence starting at %i is: ", n); hailOut(n); printf(" The length of the sequence is %i. ", hailLength(n)); printf("The largest number of the sequence is %i. ", hailLargest(n)); //printf("There are %i local maxima. ", hailMaxima(n)); printf("The longest hailstone sequence starting with a number up to %i has length %i. ", n, hailLargestLength(n)); printf("The start value of the longest hailstone sequence starting with a number up to %i is %i. ", n, hailLargestStartValue(n)); printf("The largest value that occurs in a hailstone sequence that starts with a number up to %i is %i. ", n, hailSequenceLargestValue(n)); return 0; }

Answer 1

#include <iostream>
using namespace std;

//prints the hailstorm series
void hailOut(int N)
{
static int c;
//prints the series
cout<<N<<" ";
if (N == 1 && c == 0) {
// N is initially 1.
return;
}
else if (N == 1 && c != 0) {
// N is reduced to 1.
c++;
return;
}
else if (N % 2 == 0) {
  
// If N is Even.
c++;
hailOut(N / 2);
}
else if (N % 2 != 0) {
  
// N is Odd.
c++;
hailOut(3 * N + 1);
}
}
//finds the legth of the series
int HailLength(int N)
{
static int c;
int count;
if (N == 1 && c == 0) {
// N is initially 1.
return c;
}
else if (N == 1 && c != 0) {
// N is reduced to 1.
c++;
count= c;
c=0;
return count;
}
else if (N % 2 == 0) {
  
// If N is Even.
c++;
HailLength(N / 2);
}
else if (N % 2 != 0) {
  
// N is Odd.
c++;
HailLength(3 * N + 1);
}
}
// returns largest value of the series
int HailLargest(int N)
{
static int c;
//stores the largest number of the series
static int max;
if(N>max)
max=N;
if (N == 1 && c == 0) {
// N is initially 1.
return c;
}
else if (N == 1 && c != 0) {
// N is reduced to 1.
c++;
return max;
}
else if (N % 2 == 0) {
  
// If N is Even.
c++;
HailLargest(N / 2);
}
else if (N % 2 != 0) {
  
// N is Odd.
c++;
HailLargest(3 * N + 1);
}
}
//return length of longest sequence in series 1 to N
int longestHailstoneSequence(int N)
{
int lengthOfSeries;
static int longestSeries;
if(N>0)
{
lengthOfSeries=HailLength(N);
if(lengthOfSeries>longestSeries)
longestSeries=lengthOfSeries;
longestHailstoneSequence(N-1);
  
}
else
return longestSeries;
}
//returns max value of the series from 1 to N
int hailSequenceLargestValue(int N)
{
int max;
static int seriesMax;
if(N>0)
{
max=HailLargest(N);
if(max>seriesMax)
seriesMax=max;
hailSequenceLargestValue(N-1);
}
else
return seriesMax;
  
}
// returns start value of longest sequence
int hailLargestStartValue(int N)
{
int lengthOfSeries;
static int longestSeries;
static int startValue;
if(N>0)
{
lengthOfSeries=HailLength(N);
if(lengthOfSeries>longestSeries)
{
longestSeries=lengthOfSeries;
startValue=N;
}
hailLargestStartValue(N-1);
  
}
else
return startValue;
}

int main(void) {
  
//starting number for the sequence
int N;
int end;
cout<<"What number shall I start with?"<<endl;
cin>>N;
cout<<"Hailstone starting at "<<N<<" is:";
hailOut(N);
cout<<endl<<"Length of series="<<HailLength(N)<<endl;
//cout<<"Largest number in the series="<<HailLargest(N)<<endl;
cout<<"Enter the end number of the sequence 1 to N"<<endl;
cin>>end;
cout<<"Longest sequence length starting with 1 to "<<end<<" is:"<<longestHailstoneSequence(end)<<endl;
cout<<"Largest value starting with 1 to "<<end<<" is:"<<hailSequenceLargestValue(end)<<endl;
cout<<"The start value of the longest hailstone sequence starting with a 1 up to "<<end<<" is:"<<hailLargestStartValue(end)<<endl;
  
return 0;
}

Sample Output:

Hope this helps.. Thanks!