Array function help
Hello,
I am trying to find the right code for this question, I am having problem understanding it
changes’s job is to go through the array from beginning to end, counting how many times the data changes its direction between increasing and decreasing. For instance, if the data is increasing, then decreasing, then increasing, then decreasing, changes will return 3. That is,
I know it looks bad but I need first to get it the idea of it
I am trying to find the right code for this question, I am having problem understanding it
changes’s job is to go through the array from beginning to end, counting how many times the data changes its direction between increasing and decreasing. For instance, if the data is increasing, then decreasing, then increasing, then decreasing, changes will return 3. That is,
|
|
I know it looks bad but I need first to get it the idea of it
Ok, here are some immediate errors or ambiguities that I see:
1. In the FOR loop, the variable index1 has a range of 0->elements-1 inclusive. However, the segmentation fault (index array out of bounds) error would probably occur at lines 7, 9, and 11 (if the variable elements is the size of the array a) because you try to access a[index1+1] when this area in memory is not allocated. You are essentially accessing one past the last valid element in array a.
FIX: You could alter the FOR loop construct to look like
2. You increment count each time a[index1] == a[index1+1]. In this algorithm, you only want to increment count when the data changes from increasing to decreasing or decreasing to increasing. When two contiguous elements are equal, there is technically no change in data direction. You did a good job of breaking the algorithm down into individual cases, however the logic is not yet complete.
The first case is the data was previously increasing, but it has changed direction and is now decreasing.
The second case is the data was previously decreasing, but it has changed direction and is now increasing.
The third case is the data is neither increasing or decreasing.
So you see, a key component you were missing was storing a direction variable and testing it in the IF statements.
There is another technicality to this problem and it concerns inputs where the first two or more elements are equal e.g. {5, 5, 5, 7, 9, 3, 2} because you must first initialize a direction (increasing or decreasing). There is a simple workaround of iterating until two elements are not equal and then initialize the direction variable and begin the algorithm. I have a correct algorithm implemented, however, I will let this all sink in before posting it. Its important to understand the idea like you said!
1. In the FOR loop, the variable index1 has a range of 0->elements-1 inclusive. However, the segmentation fault (index array out of bounds) error would probably occur at lines 7, 9, and 11 (if the variable elements is the size of the array a) because you try to access a[index1+1] when this area in memory is not allocated. You are essentially accessing one past the last valid element in array a.
FIX: You could alter the FOR loop construct to look like
for (unsigned index1 = 0; index1 < elements-1; index1++)2. You increment count each time a[index1] == a[index1+1]. In this algorithm, you only want to increment count when the data changes from increasing to decreasing or decreasing to increasing. When two contiguous elements are equal, there is technically no change in data direction. You did a good job of breaking the algorithm down into individual cases, however the logic is not yet complete.
The first case is the data was previously increasing, but it has changed direction and is now decreasing.
|
|
The second case is the data was previously decreasing, but it has changed direction and is now increasing.
|
|
The third case is the data is neither increasing or decreasing.
|
|
So you see, a key component you were missing was storing a direction variable and testing it in the IF statements.
There is another technicality to this problem and it concerns inputs where the first two or more elements are equal e.g. {5, 5, 5, 7, 9, 3, 2} because you must first initialize a direction (increasing or decreasing). There is a simple workaround of iterating until two elements are not equal and then initialize the direction variable and begin the algorithm. I have a correct algorithm implemented, however, I will let this all sink in before posting it. Its important to understand the idea like you said!
|
|
I still don't know what is missing in the last IF statement
Last edited on
Getting there!
Watch your variable types, you try to assign a negative value to dirc on line 16 which is impossible because the type of dirc is unsigned. In the below code, for simplicity just use a boolean value denoting either increasing->true or decreasing->false.
When coded correctly, there is no third IF statement because when two contiguous elements are equal, you do not need to change direction, instead you keep saving the direction for later in the sequence when either a[index1] > a[index1+1] or a[index1] < a[index1+1].
Your solution is very close to being correct, there are still issues however. First, you simply initialize dirc=1, however, this is incorrect if the first two elements of a are e.g. {5, 3, ....}. You initialized it as increasing, but in reality it is decreasing. Heres the fix, it requires a couple lines before your FOR loop:
Let me know what you don't understand, this is a great problem that emphasizes logical thinking and also has many opportunities for expanding syntactical knowledge of C++.
Watch your variable types, you try to assign a negative value to dirc on line 16 which is impossible because the type of dirc is unsigned. In the below code, for simplicity just use a boolean value denoting either increasing->true or decreasing->false.
When coded correctly, there is no third IF statement because when two contiguous elements are equal, you do not need to change direction, instead you keep saving the direction for later in the sequence when either a[index1] > a[index1+1] or a[index1] < a[index1+1].
Your solution is very close to being correct, there are still issues however. First, you simply initialize dirc=1, however, this is incorrect if the first two elements of a are e.g. {5, 3, ....}. You initialized it as increasing, but in reality it is decreasing. Heres the fix, it requires a couple lines before your FOR loop:
|
|
Let me know what you don't understand, this is a great problem that emphasizes logical thinking and also has many opportunities for expanding syntactical knowledge of C++.
Last edited on
I edited the code and figured out that I cannot put the els++ inside the FOR loop and I don't know why please tell me?
|
|
Last edited on
Try removing the unnecessary braces at lines 8 and 26. Then move the els++ back into the FOR loop. So the loop will look like this:
Those braces should not have been there, post any error messages you get if these changes don't work.
Also, please use indentation! Style is just as important as function!
|
|
Those braces should not have been there, post any error messages you get if these changes don't work.
Also, please use indentation! Style is just as important as function!
Last edited on
it worked this way, I went through this problem on a paper and it now make sense to me but I am wondering if there is nicer and shorter way of doing this
|
|
Last edited on
Note:
I would personally start the code:
|
|
I would personally start the code:
|
|
Last edited on
The only difference between your code and mine is that while we both look at two consecutive elements, you refer to them by the index of the first (els) and I by the second (elt). els+1===elt
In other words I place the +1 or -1 in different points.
Note: Line 7; return 0, if whole array has equal values rather than compute bool from a[elements] (out-of-range error).
|
|
In other words I place the +1 or -1 in different points.
Note: Line 7; return 0, if whole array has equal values rather than compute bool from a[elements] (out-of-range error).
Topic archived. No new replies allowed.