Массив: произведение элементов массива, расположенных между первым и вторым нулевыми элементами.

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <iterator>
 
int main()
{
   std::vector<int> vec = {1,2,3,0,4,5,6,0,1};
   std::cout << "Max elem has number: " << std::max_element(vec.begin(), vec.end())
   - vec.begin() << std::endl;
   std::vector<int>::iterator first_zero = std::find(vec.begin(), vec.end(), 0);
   if (first_zero == vec.end())
   {
      std::cerr << "No zero elements" << std::endl;
      return 1;
   }
   std::vector<int>::iterator second_zero = std::find(first_zero + 1, vec.end(), 0);
   if (second_zero == vec.end())
   {
      std::cerr << "Only one element equal to zero" << std::endl;
      return 1;
   }
   std::cout << "Sum between first 0 and second 0 is: " <<
   std::accumulate(first_zero, second_zero, 0) << std::endl;
   int idx = 0;
   std::sort(vec.begin(), vec.end(), [&idx](const int first, const int second) -> bool
   {
      ++idx;
      return ((idx - 1) % 2);
   });
   std::cout << "Sorted array" << std::endl;
   std::copy(vec.begin(), vec.end(), std::ostream_iterator<int>(std::cout, " "));
   std::cout << std::endl;
}

using namespace std; int main() { ....

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <iterator>
 
using namespace std;
 
int main()
{

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <iterator>
using namespace std;
 
int main(void)
{
    vector<int> v = {1,2,3,0,4,5,6,0,1};
    cout << "max elem has number: " << max_element(v.begin(), v.end())
        - v.begin() + 1 << endl;   
    if (count(v.begin(), v.end(), 0) < 2)
        cerr << "not enough zero elements" << endl;
    else
    {
        auto first_zero = find(v.begin(), v.end(), 0);
        auto second_zero = find(first_zero + 1, v.end(), 0);
        int p = 1;
        for (auto i = first_zero + 1; i != second_zero; ++i)
            p *= *i;
        if (second_zero - first_zero > 1)
            cout << "composition between first 0 and second 0 is: " << p << endl;
        else
            cout << "there are no elements in the given interval" << endl;
    } 
    int idx = 0;
    sort(v.begin(), v.end(), [&idx](const int first, const int second)
    {
        return idx++ % 2 != 0;
    });
    cout << "Sorted array" << endl;
    copy(v.begin(), v.end(), ostream_iterator<int>(cout, " "));
    cout << endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <iterator>
 
int main()
{
   std::vector<int> vec = {1,2,3,0,4,5,6,0,1};
   std::cout << "Max elem has number: " << std::max_element(vec.begin(), vec.end())
   - vec.begin() << std::endl;
   std::vector<int>::iterator first_zero = std::find(vec.begin(), vec.end(), 0);
   if (first_zero == vec.end())
   {
      std::cerr << "No zero elements" << std::endl;
      return 1;
   }
   std::vector<int>::iterator second_zero = std::find(first_zero + 1, vec.end(), 0);
   if (second_zero == vec.end())
   {
      std::cerr << "Only one element equal to zero" << std::endl;
      return 1;
   }
   std::cout << "Mult between first 0 and second 0 is: " <<
   std::accumulate(first_zero + 1, second_zero, 1, [] (const int f, const int s)
   {
        return f * s;
   }) << std::endl;
   int idx = 0;
   std::sort(vec.begin(), vec.end(), [&idx](const int, const int) -> bool
   {
      ++idx;
      return ((idx - 1) % 2);
   });
   std::cout << "Sorted array" << std::endl;
   std::copy(vec.begin(), vec.end(), std::ostream_iterator<int>(std::cout, " "));
   std::cout << std::endl;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <iterator>
#include <functional> 
 
class transform_by_idx : public std::unary_function<int, int>
{
public:
   transform_by_idx(const std::vector<int>& v):vec(v), idx(0)
   {
   }
   result_type operator () (const argument_type& )
   {
      if (idx >= vec.size())
      {
         idx = 1;
      }
      idx += 2;
      return vec[idx - 2];
   }
private:
   std::vector<int> vec;
   size_t idx;
};
 
int main()
{
   int array[] = {1,2,3,0,4,5,6,0,1};
   std::vector<int> vec(array, array + sizeof(array) / sizeof(*array));
   std::cout << "Max elem has number: " << std::max_element(vec.begin(), vec.end())
   - vec.begin() << std::endl;
   std::vector<int>::iterator first_zero = std::find(vec.begin(), vec.end(), 0);
   if (first_zero == vec.end())
   {
      std::cerr << "No zero elements" << std::endl;
      return 1;
   }
   std::vector<int>::iterator second_zero = std::find(first_zero + 1, vec.end(), 0);
   if (second_zero == vec.end())
   {
      std::cerr << "Only one element equal to zero" << std::endl;
      return 1;
   }
   std::cout << "Mult between first 0 and second 0 is: " <<
   std::accumulate(first_zero + 1, second_zero, 1, std::multiplies<int>()) << std::endl;
   std::transform(vec.begin(), vec.end(), vec.begin(), transform_by_idx(vec));
   std::copy(vec.begin(), vec.end(), std::ostream_iterator<int>(std::cout, " "));
   std::cout << std::endl;
}

#include <locale.h>
 
int main()
{
    setlocale(LC_ALL,"Russian");
 
    int N = -1;
    printf("Введите число элементов массива N = ");
    scanf("%d",&N);
 
    int* A = new int[N];
    for (int i = 0; i < N; i++)
     { printf("Введите A[%d] = ",i); scanf("%d",&A[i]); }
 
    printf("\n");
 
    int max = 0;
    for (int n = 0; n < N; n++)
        if (A[n] > A[max]) max = n;
 
    int k = 0, *pos = new int[2];
    for (int r = 0; (r < N) && (k != 2); r++)
        if (A[r] == 0) pos[k++] = r;
 
    int q = pos[0] + 1, mul = 1;
    while (q < pos[1]) mul*=A[q++];
 
    for (int z1 = 0; z1 < N; z1++)
        printf("%d ",A[z1]);
    printf("\n");
 
    printf("Максимальный элемент A[%d] = %d\n",max,A[max]);
    printf("Произведение элементов "); 
    for (int z2 = pos[0] + 1; z2 < pos[1]; z2++)
        printf("%d ",A[z2]);
    printf("mul = %d\n",mul);
}