Алгоритмы и программы по обработке одномерных и двумерных массивов

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <conio.h>
 
// Функция, возвращающая сумму положительных элементов массива
double sum(double *mas, int n)
{
    double s = 0.0; // Переменная, хранящая сумму
    int i;          // Счётчик
 
    // В цикле пробегаем по всем элементам массива
    for (i = 0; i < n; i++)
        if (mas[i] > 0.0) // Если очередной элемент положительный
            s += mas[i]; // Прибавляем его к общей сумме
 
    return s; // Возвращаем найденную сумму
}
 
// Функция, возвращающая произведение элементов массива, расположенных между максимальным и минимальным по модулю элементами
double product(double *mas, int n)
{
    int minIndex = 0; // Переменная, хранящая индекс минимального по модулю элемента
    int maxIndex = 0; // Переменная, хранящая индекс максимального по модулю элемента
    int tempIndex;    // Временная переменная
    double p = 1.0;   // Переменная, хранящая найденное произведение
    int i;            // Счётчик
 
    // В цикле пробегаем по всем элементам массива
    for (i = 0; i < n; i++)
    {
        if (fabs(mas[i]) > fabs(mas[maxIndex])) // Если элемент с индексом i больше по модулю, чем элемент с ранее найденным индексом,
            maxIndex = i; // то теперь индекс максимального элемента равен i
        else // Иначе
        {
            if (fabs(mas[i]) < fabs(mas[minIndex])) // Если элемент с индексом i меньше по модулю, чем элемент с ранее найденным индексом,
                minIndex = i; // то теперь индекс минимального по модулю элемента равен i
        }
    }
 
    // Если минимальный по модулю элемент расположен в массиве правее максимального
    if (minIndex > maxIndex)
    {
        // Для удобства меняем значения индексов
        tempIndex = minIndex;
        minIndex = maxIndex;
        maxIndex = tempIndex;
    }
 
    // В цикле пробегаем элементы массива от одного найденного индекса до другого
    for (i = minIndex + 1; i < maxIndex; i++)
        p *= mas[i]; // Формируем произведение
 
    return p; // Возвращаем найденное произведение
}
 
// Функция, сортирующая массив по убыванию модулей элементов
void bubbleSort(double *mas, int n)
{
    double temp; // Временная переменная
    int i, j;    // Счётчики
 
    // Во внешнем цикле пробегаем весь массив
    for (i = 0; i < n; i++)
    {
        // Во вложенном цикле пробегаем массив с конца до i
        for (j = n - 1; j > i; j--)
        {
            // Если модуль правого элемента оказался больше модуля левого
            if (fabs(mas[j]) > fabs(mas[j - 1]))
            {
                // Меняем элементы местами
                temp = mas[j];
                mas[j] = mas[j - 1];
                mas[j - 1] = temp;
            }
        }
    }
}
// (Советую почитать про пузырьковую сортировку)
 
int main()
{
    double *mas; // Указатель на будущий массив
    int n;       // Количество элементов массива
    double s;    // Сумма положительных элементов
    double p;    // Произведение элементов, расположенных между минимальным и максимальным по модулю элементами
    int i;       // Счётчик
 
    printf("Enter n: ");
    scanf("%d", &n); // Вводим количество элементов
 
    mas = (double *)malloc(n * sizeof(double)); // Выделяем память
 
    // Заполняем массив
    for (i = 0; i < n; i++)
    {
        printf("mas[%d]: ", i);
        scanf("%lf", &mas[i]);
    }
 
    s = sum(mas, n);     // Считаем сумму
    p = product(mas, n); // Считаем произведение
    bubbleSort(mas, n);  // Сортируем массив
 
    printf("\nSum: %lf", s);     // Выводим сумму
    printf("\nProduct: %lf", p); // Выводим произведение
 
    // Выводим отсортированный массив
    printf("\n\nSorted mas:\n\n");
 
    for (i = 0; i < n; i++)
        printf("%lf  ", mas[i]);
 
    free(mas); // Освобождаем память
 
    getch();
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
int mod_cmp_desc(const void * a, const void * b){
    double diff = fabs(*(const double*)b) - fabs(*(const double*)a);
    return ( diff < 0.0 ) ? -1 : ( diff > 0.0 ) ? 1 : 0;
}
 
double p_sum(const double * arr, size_t size){
    return ( size == 0 ) ? 0.0 : ( *arr > 0.0 ) ? *arr + p_sum(arr + 1, size - 1) : p_sum(arr + 1, size - 1);
}
 
#define SIZE 10
 
int main(void){
    double arr[SIZE] = { 3.7, -2.4, 5.8, 3.1, -0.8, 2.2, 0.4, -8.3, 4.1, 2.8 };
    int i;
    
    printf("Unsorted:\n");
    for ( i = 0; i < SIZE; ++i )
        printf("%.1f ", arr[i]);
    printf("\nSum of positive elements:\n%.1f\n", p_sum(arr, SIZE));
    
    qsort(arr, SIZE, sizeof(double), mod_cmp_desc);
    printf("Sorted by MOD descendant:\n");
    for ( i = 0; i < SIZE; ++i )
        printf("%.1f ", arr[i]);
    
    printf("\n");
    
    exit(0);
}

if ( ! mas ){
  fprintf(stderr, "Memory error!\n");
  return 1;
}