3n + 1问题。 为什么会出现断点错误，如何返回计数器“ Max”

Question

I need some help figuring out whats wrong with my code.

First what I'm supposed to do. I'm computing the 3n+1 | n/2 problem.

If a positive number(input) is even, I n/2. If odd I use 3n+1. I'm supposed to continue this sequence until I get to number 1.

Steps:

1. Collect a range of the numbers. The range will serve as the n.
2. Find what is the longest sequence of computations.
3. Print out the longest sequence.

This is an example of how the execution should look like:

• Enter the min of the range for the sequence to start: 1
• Enter the max of the range for the sequence to start: 5

The longest sequence with a start value in the range [1, 5] has 8 elements.

3, 10, 5, 16, 8, 4, 2, 1 

My problem so far is that I'm getting breakpoint error when I use

sequenceLength = longestSequence(minimum, maximum);

I don't understand why this is an issue. Secondly, I'm not getting the return I want for the length of the longest sequence. I believe I'm not returning the right value?

I'm relatively new to c++ and there's still some concepts I have to grasp! I hope you guys can help. Here's my code.

#include <iostream>
using namespace std;
// Functions
string generateSequence(); // A print of the longest sequence. To be made. I can't figure it out yet. Arrays?
int counter = 1; // To start out the counter in getNextElement
void getUserInput(int &start, int &end) // collects the user input for minimum and maximum
{
    cout << "Enter the min of the range for the sequence to start " << endl;
    cin >> start;
    cout << "Enter the max of the range for the sequence to start " << endl;
    cin >> end;
}
int getNextElement(int x) // // This function does the 3n+1 computation
{
    if (x != 1) // Checks for the end of the sequence. The end being when the number is 1.
    {
        counter++; //this is the counter for the number of times the sequence is done with the specific number.
        if (x % 2 == 0) // checks if its even
            getNextElement(x / 2); // takes the new number through the function again
        else
            getNextElement(x * 3 + 1); // takes the new number into the function again
    }
    return counter; // this is returned as length in the longestSequence function. No?
}

int longestSequence(int minimum, int maximum) // this function compares all the sequence lengths within the range of minimum and maximum.
{
    int first = 0; // minimum
    int second = 0; // maximum
    int max = 0; // start of longest sequence counter. Is this bad?

    for (int i = first; i <= second; i++)
    {
        int length = getNextElement(i); // length is a temp that will hold the largest sequence    

        if (length > max) // this loop validates if the newest "length" from the sequence is bigger than the previous one       
            max = length; // after the first run of the loop, max stores the longest sequence, and updates it after each run of the for loop if its longer
        counter = 1; // resets the counter to 1. This counter is length    
    }
    return max;
}

int main()
{
    int minimum;
    int maximum;
    int sequenceLength;
    getUserInput(minimum, maximum); // retrieves user input

    sequenceLength = longestSequence(minimum, maximum); // starts longest sequence counter

    cout << sequenceLength;
    cout << "This is the end of main. Nothing is after this" << endl;

    return 0;
}

These are the functions I'm supposed to use.

getUserInput – takes two parameters start and end and asks the user to enter the min and max of the range to check. It sets start to min and end to max. The function returns nothing.

getNextElement – takes a value and returns the next value in the sequence according to the rules. 1 shall return 1.

generateSequence – takes a start value for the sequence and a sequence string. It returns the length of the generated sequence starting with that start value and the sequence string is set to the generated sequence.

longestSequence - takes a start and an end value specifying the range of start values to check and a sequence string. It returns the length of the longest sequence encountered with a start value in the range[start, end] and the sequence string is set to the longest sequence encountered.

Answer 1

My problem so far is that I'm getting breakpoint error when I use "sequenceLength = longestSequence(minimum, maximum); "

Breakpoint error sounds kind of odd, so let's look at longestSequence and see what it could be doing.

int longestSequence(int minimum, int maximum) 

One immediate take-away is that minimum and maximum are not used in the function.

{
    int first = 0; // minimum
    int second = 0; // maximum

minimum and maximum are referenced here in comments where they don't do the program any good, begging the question why not just use minimum and maximum instead of first and second ?

    int max = 0; // start of longest seqence counter. Is this bad?

Why would it be bad? One should always set variables to a known value. If you are looking for a maximum count, setting the default to 0 says there's only one way the counter can go: Up! Great movie. You should see it if you haven't.

    for (int i = first; i <= second; i++)

Here using first and second instead of minimum and maximum starts causing problems. They are both 0 resulting in one iteration of the loop: 0 <= 0 . getNextElement can only be called with 0.

    {
        int length = getNextElement(i); 
        if (length > max) // this loop validates if the newest "length" from the sequence is bigger than the previous one       
            max = length; // after the first run of the loop, max stores the longest seqence, and updates it after each run of the for loop if its longer
        counter = 1; // resets the counter to 1. This counter is length    
    }

Bingo. This is almost exactly right. But to see why it still fails, we have to examine getNextElement . The one bit that raises an eyebrow is counter . Why have both length and counter ? They track the same thing. When you find yourself with two variables doing the same, or almost exactly the same, thing you should stop and ask yourself why. Odds are good that you're doing something that can be improved.

    return max;
}

OK. So what goes wrong with getNextElement ? Not that much, actually. It just has a real problem with numbers less than 1. I'm going to strip out all of the comments because they are simply restating the obvious and add noise.

int getNextElement(int x) 
{
    if (x != 1) 

This is a recursive function, so yeah. We need an exit condition. We can tweak this to better filter impossible values, but otherwise this is good.

    {
        counter++; 

Here is counter again. We saw counter in longestSequence . All counter does is count. longestSequence doesn't care that it counts, it only cares about the final returned count. So why does longestSequence have any interaction with it at all? To reset the counter? That can be done inside this function, removing the need for counter as a global variable.

If you can do away with a global, do it. They can lead to interesting little bugs with tentacles throughout the entire program. It is in your best interests to keep things in as small a scope as possible so that when something does go wrong, you don't have to look at as much code to find it.

        if (x % 2 == 0) 
            getNextElement(x / 2); 
        else
            getNextElement(x * 3 + 1); 
    }
    return counter; 
}

The rest of this function is excellent. So why does it fail? Let's walk through with first and second of 0:

for (int i = 0; i <= 0; i++)

So i = 0. That means

    int length = getNextElement(0);

and

int getNextElement(0)
{
    if (0 != 1) // always true
    {
        counter++; 
        if (0 % 2 == 0) // always even
            getNextElement(0 / 2);  // always calls getNextElement(0) again
        else
            getNextElement(0 * 3 + 1); 
    }
    return counter; 
}

This quickly turns into

counter++;
getNextElement(0);
counter++;
getNextElement(0);
counter++;
getNextElement(0);
counter++;
getNextElement(0);
counter++;
getNextElement(0);

For all eternity. Oops. Sooner or later you will run out of memory and the program does weird things.

How to fix this:

First, use the user input.

int longestSequence(int minimum, int maximum) 
{
    int max = 0; 
    for (int i = minimum; i <= maximum; i++)
    {
        int length = getNextElement(i); 
        if (length > max) 
            max = length; 
        counter = 1; 
    }
    return max;
}

Second, reject values that getNextElement cannot handle with a slightly smarter exit condition:

int getNextElement(int x)
{
    if (x > 0) // only execute if x can be processed
    {
        counter++; 
        if (x % 2 == 0) 
            getNextElement(x / 2); 
        else
            getNextElement(x * 3 + 1); 
    }
    return counter; 
}

The program will terminate correctly at this point, but... Third, consider reducing the scope of counter

int getNextElement(int x, 
                   int counter = 1) // if counter is not provided it will be set to 1
{
    if (x > 0) // only execute if x can be processed
    {
        counter++; 
        if (x % 2 == 0) 
            getNextElement(x / 2, counter); 
        else
            getNextElement(x * 3 + 1, counter); 
    }
    return counter; 
}

int longestSequence(int minimum, int maximum) 
{
    int max = 0; 
    for (int i = minimum; i <= maximum; i++)
    {
        int length = getNextElement(i); 
        if (length > max) 
            max = length; 
    }
    return max;
}

This does have a side effect of doubling the memory needed by the function, so maybe it isn't a good idea in this case. Depends on how many iterations of getNextElement are needed.