В одномерном массиве вычислить произведение элементов, находящихся между максимальным и минимальным элементами

#include <stdio.h>
#include <iostream>
#include <time.h>
 
// Задание:
// В одномерном массиве, состоящем из n вещественных элементов, вычислить:
// 1. сумму отрицательных элементов массива;
// 2. произведение элементов массива, расположенных между максимальным и минимальным элементами.
// 3. Упорядочить элементы массива по возрастанию.
 
double first(double arr[], int len)
{
    double sum = 0;
 
    for(int i = 0; i < len; i++)
        if(arr[i] < 0)
            sum += arr[i];
 
    return sum;
}
 
double second(double arr[], int len)
{
    int index_min = 0;
    int index_max = 0;
    double mult = 1;
 
    for(int i = 0; i < len; i++) {
        if(arr[i] < arr[index_min])
            index_min = i;
        if(arr[i] > arr[index_max])
            index_max = i;
    }
 
    if(index_min > index_max) {
        int temp_index = index_min;
        index_min = index_max;
        index_max = temp_index;
    }
 
    for(int i = index_min+1; i < index_max; i++)
        mult *= arr[i];
 
    return mult;
}
 
void sort(double arr[], int len)
{
    for(int i = 0; i < len-1; i++)
        for(int j = i+1; j < len; j++)
            if(arr[i] > arr[j]) {
                double temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
 
    return;
}

#include <iostream>
#include <algorithm>
#include <numeric>
#include <iterator>
 
int main()
{
    double array[] = {1, 2, 3, -4, -4, -4, 6, 7, 8, 10};
  
    auto print_array = [&array](const char *msg) {
        std::copy(std::begin(array), std::end(array), std::ostream_iterator<double>(std::cout << msg, " "));
        std::cout << std::endl;
    };
    
    print_array("Initial array: ");
 
    double negative_sum;
    std::for_each(std::begin(array), std::end(array), [&negative_sum](double n) { if (n < 0) negative_sum += n; });
    std::cout << "Sum of negative elements: " << negative_sum << std::endl;
  
    auto min_max = std::minmax_element(std::begin(array), std::end(array));
    if (min_max.first <= min_max.second) {
        double sum = std::accumulate(min_max.first, min_max.second, 0);
        std::cout << "Sum of elements between min-max: " << sum << std::endl;
    } else {
        std::cout << "Unable to calculate sum between min-max" << std::endl;
    }
  
    std::sort(std::begin(array), std::end(array));
    print_array("Sorted array: ");
  
    return 0;
}

#include <algorithm>
#include <iostream>
 
using namespace std;
 
 
int main(){
    const int N=10;
    double Arr[N]={1, 2, 3, -4, -4, -4, 6, 7, 8, 10};
    double sum=1;
 
    for (auto i:Arr) cout<<i<<"  ";
    cout<<"\n\n";
 
    auto min=min_element(Arr,Arr+N);
    auto max=max_element(Arr,Arr+N);
 
    if (min>max)  swap(min,max);
     cout<<"SUM = "<<accumulate(min,max+1,0)<<"\n";
 
    for (auto i:Arr) if  (i<0)  sum*=i;
    cout<<"MULT = "<<sum<<"\n\nSORT: ";
 
    sort(Arr,Arr+N);
    for (auto i:Arr) cout<<i<<"  ";
    cut<<"\n";
 
 
return 0;
}

double init[10] = { -1, 0.3, 5, 2, 3, 4, -3, -1, 2 };
 
    //1
    cout << std::accumulate(init, init + 10, 0, [](int &sum, const int& val){
        return (val < 0) ? sum += val : sum;
    });
 
    //2
    std::pair<double*, double*> minMax = std::minmax_element(init, init + 10);
    if (std::distance(minMax.second, minMax.first) > 0)std::swap(minMax.first, minMax.second);
    cout << std::accumulate(minMax.first + 1, minMax.second, 1, std::multiplies<int>());
 
    //3
    std::sort(init, init + 10);