Найти среднее арифметическое элементов, расположенных после первого минимального элемента

int min = 0; for (int i=0; i<k; i++) {scanf("%d", &b[i]); if(b[min]>b[i]) min = i; }

#include <stdio.h>
#include <stdlib.h>
/* ****************************************************************************
 * Создает динамический массив типа double, записывает в него значения пока не
 * введено недопустимое значение элемента массива. Находит минимальное из
 * введенных значений.
 * Рассчитывает среднее арифметическое.
 * для проверки утечек: valgrind ./program
 **************************************************************************/
double * resize (double *, unsigned, unsigned); // realloc с перезаписью
double * array (double, double, int *);         // запись данных в массив
 
void print_ar (double *, int);  // выводит массив на экран
double min (double *, int, int);    // минимальное значение в массиве
 
int main (void)
{
    double *b;          // указатель на будущий массив
    double x, y;        // граничные значения элементов массива
    int k = 0;          // размер массива
 
    // получаем граничные значения элементов массива:
    printf("input min & max: ");
    scanf("%lf %lf", &x, &y);
    fflush(stdin);
 
    // проверяем чтобы min было < max:
    if (x > y)
    {
        double temp = x;
        x = y;
        y = temp;
    }
 
    // создаем динамический массив и заносим в него значения:
    printf("\n");
    b = array(x, y, &k);
    if (!b) return -1;
 
    // массив на экран:
    printf("\n");
    print_ar(b, k);
 
    /* для теста промежуточные результаты на экран --------- */
    // номер минимального элемента:
    printf("\nmin = %d\n", (int)min(b, k, 2));
    // минимальный элемент массива:
    printf("k[min] = %5.2lf\n", min(b, k, 1));
    // чисел в массиве:
    printf("array size = %d\n", k);
    /* --------------в релизе закомментировать-------------- */
 
    // среднее арифметическое элементов, расположенных после минимального:
    double z, sum = 0.0;                // среднее арифметическое, сумма
    int i, c;                           // счетчики
    int a = (int)min(b, k, 2);      // номер минимального элемента
    if (++a == k)                       // если минимальный оказался последним,
    {                                       // ну не делить же на 0...
        sum = z = 0.0;
        c = 0;
    }
    else                                    // считаем среднее арифметическое
    {
        for (i=a, c=0; i<k; i++, c++)
            sum += b[i];
        z = sum / (double)c;
    }
 
    // результат на экран:
    printf("\nsum of %d elements = %lf\n", c, sum);
    printf("average of %d elements = (%lf / %d) = %lf\n", c, sum, c, z);
 
    // освобождаем память, занятую массивом и выходим
    free(b); b = 0;
    return 0;
}
/* ------------ находим минимальный эелемент массива ------------ */
double min (double *a, int max, int choice)
{
    int min = 0;
    for (int i=0; i<max; i++)
        if ((a[i]-a[min]) < 0.0) min = i;   // if (a[i] < a[min])
    if (choice > 1) return (double)min;     // номер минимального
    if (choice < 2) return a[min];          // минимальное значение
}
/* ----------------------- массив на экран ---------------------- */
void print_ar (double *a, int max)
{
    int i;
    for (i=0; i<max; i++)       // номера элементов
    {
        if (i>0 && i%13 == 0) printf("\n");
        printf("%5d ", i);
    }
    printf("\n");
    for (i=0; i<max; i++)       // элементы массива
    {
        if (i>0 && i%13 == 0) printf("\n");
        printf("%5.2lf ", a[i]);
    }
    printf("\n");
}
/* ------------------- меняем размер массива -------------------- */
/* -------------------------------------------------------------- */
double * resize (double *a, unsigned size, unsigned new_size)
{
    unsigned i;
    double * new_a = (double *)malloc(new_size * sizeof(double));
    if (!new_a)         // фокус не удался, факир был не в себе
    {
        //free(new_a);
        return NULL;
    }                       // переписываем значения по новому адресу:
    for (i=0; i<size && i<new_size; i++) new_a[i] = a[i];
    if (new_size > size) while (i<new_size) new_a[i++] = 0.0;
    free(a); a = 0;
    return new_a;
}
/* ---------------- объявляем массив double b[k]; --------------- */
/* -------------------------------------------------------------- */
double * array (double a, double b, int *max)
{
    double * buffer = NULL;
    double num;                 //число с клавиатуры
    const int MAX_LEN = 64; //максимум массива 128 чисел
    int capacity = 0;           //размер буфера
    int n = 0;                  //сколько чисел в буфере (размер массива)
 
    int go = 1;
    while (go)
    {
        // получаем число с клавиатуры:
        printf("b[%i] = ", n);
        scanf("%lf", &num);
        fflush(stdin);
        // определяем размер буфера:
        if (n + 1 > capacity)
        {
            if (!capacity) capacity = 8;
            else if (capacity <= MAX_LEN) capacity *= 2;
            else
            {
                *max = 0;
                free(buffer);
                return NULL;
            }
            // меняем реальный размер буфера в памяти:
            double * temp = resize(buffer, n, capacity);
            if (!temp)
            {
                *max = 0;
                free(temp);
                return NULL;
            }
            buffer = temp;
        }
        // добавляем число в массив:
        if (num >= a && num <= b) buffer[n++] = num;
        else go = 0;
    }
    // если массив нулевого размера, возвращаем NULL
    if (!n) { *max = n; free(buffer); return NULL; }
    // минимизируем размер буфера:
    double * minimal = resize(buffer, n, n);
    *max = n;           // переписываем максимум массива
    return minimal; // возвращаем полученный массив
}