Question

Write a function named out_of_order that takes as parameters an array of doubles and an int parameter named size and returns a value of type int. This function will test this array for being out of order, meaning that the array violates the following condition: a[0] <= a[1] <= a[2] <= ... The function returns -1 if the elements are not out of order; otherwise, it will return the index of the first element of the array that is out of order. For example, consider the declaration double a[10] = {1.2, 2.1, 3.3, 2.5, 4.5, 7.9, 5.4, 8.7, 9.9, 1.0}; In this array, a[2] and a[3] are the first pair out of order, and a[3] is the first element out of order, so the function returns 3. If the array were sorted, the function would return –1.

Short answer

Question: Write a function called 'out_of_order' that takes an array of doubles and an integer as its parameters. The function should return the index of the first element in the array that is out of order according to the non-descending condition or return -1 if the array is sorted. Answer: In order to find the first out-of-order element in a given array of doubles, we can loop through the array, compare each pair of consecutive elements, and check if they follow the non-descending condition (a[i] <= a[i+1]). If we find a pair that violates the condition, we return the index of the first element in the pair that is out of order. If no such pair is found, we return -1 to indicate that the array is sorted. The function 'out_of_order' can be implemented as follows: ```cpp int out_of_order(double arr[], int size) { int outOfOrderIndex = -1; for (int i = 0; i < size - 1; i++) { if (arr[i] > arr[i + 1]) { outOfOrderIndex = i + 1; break; } } return outOfOrderIndex; } ```

Step-by-step solution

(1. Function Signature and Initialization)

First, we'll write the function signature, taking an array of doubles, and an int as its parameters. We'll initialize a variable to hold the out of order index. ```cpp int out_of_order(double arr[], int size) { int outOfOrderIndex = -1; // Rest of the code } ```

(2. Check Consecutive Elements for Non-Decreasing Condition)

Now, we will loop through the array, checking each pair of consecutive elements to see if they break the non-decreasing condition `a[i] <= a[i+1]`. If we find a pair that breaks the condition, we will set `outOfOrderIndex` to the index of the first element in the pair that is out of order. ```cpp for (int i = 0; i < size - 1; i++) { if (arr[i] > arr[i + 1]) { outOfOrderIndex = i + 1; break; } } ```

(3. Return the Out of Order Index)

Finally, we'll return the value of `outOfOrderIndex`. If no pair of elements is out of order, the value will still be -1, indicating that the array is sorted. ```cpp return outOfOrderIndex; ```

(4. Complete Function Implementation)

Bringing all the steps together, we get the following solution: ```cpp int out_of_order(double arr[], int size) { int outOfOrderIndex = -1; for (int i = 0; i < size - 1; i++) { if (arr[i] > arr[i + 1]) { outOfOrderIndex = i + 1; break; } } return outOfOrderIndex; } ``` This function will correctly find the index of the first element that is out of order in a given array or return -1 if the array is sorted.