Найти наибольший общий делитель для 10 заданных натуральных чисел

#include <stdio.h>
int gcd (int, int);
 
int main (void)
{
    int a, b, r;
    printf("a = "); scanf("%d", &a);
    printf("b = "); scanf("%d", &b);
    if (!a || !b) return -1;
 
    r = gcd(a, b);
 
    printf("gcd is: %d\n", r);
    return 0;
}
// -------------- рекурсивное деление с остатком --------------
int gcd (int a, int b)
{
    a = (a<0) ? -a : a;
    b = (b<0) ? -b : b;
    return (!b) ? a : gcd(b, a%b);
}
// -------------- циклическое деление с остатком --------------
/*int gcd (int a, int b)
{
    a = (a<0) ? -a : a;
    b = (b<0) ? -b : b;
    while (a && b)
        if (a > b) a = a%b;
        else b = b%a;
    return a+b;
}*/
// ------------------ циклическое вычитание -------------------
/*int gcd (int a, int b)
{
    a = (a<0) ? -a : a;
    b = (b<0) ? -b : b;
    while (a != b)
    {
        if (a > b) a -= b;
        else b -= a;
    }
    return a;
}*/
// ------------------ рекурсивное вычитание -------------------
/*int gcd (int a, int b)
{
    a = (a<0) ? -a : a;
    b = (b<0) ? -b : b;
    if (a == b) return a;
    else
    {
        if (a > b) a -= b;
        else b -= a;
    }
    return a = gcd (a, b);
}*/

#include <stdio.h>
#include <stdlib.h>
int * creater (int *, unsigned);                        // создаем массив
int * resize (int *, unsigned, unsigned);           // realloc с перезаписью
int * del (int, int *);                                 // делители числа
void print_ar (int *, int);                         // массив на экран
 
int main (void)
{
    int i;
    int *p;
    int max;
 
    // перебираем все числа от 5 до 12 и для каждого находим делители
    for (i=5; i<12; i++)
    {
        max = 0;                        // размер массива
        p = del(i, &max);           // новый массив с делителями
        if (!p) return -1;
        // число и массив на экран:
        printf("n = %d\n", i);
        print_ar(p, max);
        printf("\n");
 
        // удаляем текущий массив и готовимся к созданию нового
        free(p);
        p = NULL;
    }
 
    return 0;
}
// ------------------------ создаем массив ------------------------
int * creater (int *a, unsigned new_size)
{
    int * new_a = (int *)malloc(new_size * sizeof(int));
    if (!new_a) return NULL;
    a = new_a;
    return a;
}
// --------------------- меняем размер массива --------------------
int * resize (int *a, unsigned size, unsigned new_size)
{
    unsigned i;
    int * new_a = creater(new_a, new_size);
    if (!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;
    free(a); a = 0;
    return new_a;
}
// - находим все делители заданного числа и записываем их в массив:
int * del (int n, int * m)
{
    const int MAX_LEN = 512;    // максимум массива 1024 чисел
    int * buffer = NULL;            // массив
    int d = 0;                      // сколько делителей найдено
    int max = 0;                    // размер буфера
    int i;
    for (i=1; i<=n; i++)
    {
        if (n%i == 0)
        {
            if (d + 1 > max)
            {
                if (!max) max = 8;
                else if (max <= MAX_LEN) max *= 2;
                else
                {
                    *m = 0; // переписываем размер массива
                    free(buffer);
                    return NULL;
                }
                // меняем реальный размер буфера в памяти:
                int * temp = resize(buffer, d, max);
                if (!temp)
                {
                    *m = 0;
                    free(temp);
                    return NULL;
                }
                buffer = temp;
            }
            buffer[d++] = i;
        }
    }
    if (!d) { *m = 0; free(buffer); return NULL; }
    // минимизируем размер буфера
    int * minimal = resize(buffer, d, d);
    *m = d; // переписываем размер массива для main
    return minimal;
}
// ----------------------- массив на экран ------------------------
void print_ar (int *a, int max)
{
    int i;
    for (i=0; i<max; i++)
    {
        if (i>0 && i%13 == 0) printf("\n");
        printf("%5d", a[i]);
    }
    printf("\n");
}

#include <stdio.h>
#include <stdlib.h>
int nod (int, int);
 
int main (void)
{
    const int n = 10;       // количество чисел
    int a[n];               // будущий массив
    int gcd;                    // ноды
 
    int i;
 
    // получаем 10 чисел от пользователя
    for (i=0; i<n; i++)
    {
        printf("input a[%i] = ", i);
        scanf("%d", &a[i]);
    }
 
    gcd = nod(a[0], a[1]);
    for (i=2; i<n; i++)
        gcd = nod(gcd, a[i]);
    printf("GCD = %d\n", gcd);
 
    return 0;
}
// ----------- еще один рекурсивный вычитанием ----------------
int nod (int n, int m)
{
    if(!m || !n) return n+m;
    if(n>m) return nod(m,n-m);
    else return nod(n,m-n);
}

#include <stdio.h>
int nod (int, int);
 
int main (void)
{
    const int n = 10;       // количество чисел
    int a;                  // число с клавиатуры
    int gcd;                    // ноды
    int i;
 
    // получаем 10 чисел от пользователя
    for (i=0; i<n; i++)
    {
        printf("input a[%i] = ", i);
        scanf("%d", &a);
        // и сразу же находим ноды
        if (!i) gcd = a;
        else gcd = nod(gcd, a);
    }
 
    // результат на экран
    printf("GCD = %d\n", gcd);
 
    return 0;
}
// ----------- еще один рекурсивный вычитанием ----------------
int nod (int n, int m)
{
    if(!m || !n) return n+m;
    if(n>m) return nod(m,n-m);
    else return nod(n,m-n);
}

#include <stdio.h>
int gcd (int, int);     // вычисляем нод двух чисел
 
int main (void)
{
    int n = 10;     // количество чисел
    int a;          // число с клавиатуры
    int nod;        // ноды
    int i;
 
    // получаем 10 чисел от пользователя:
    for (i=0; i<n; i++)
    {
        printf("input a[%i] = ", i);
        scanf("%d", &a);
        // и сразу же находим ноды
        if (!i) nod = a;
        else nod = gcd(nod, a);
    }
 
    // результат на экран:
    printf("GCD = %d\n", nod);
 
    return 0;
}
// -------------- рекурсивное деление с остатком --------------
int gcd (int a, int b)
{
    a = (a<0) ? -a : a;
    b = (b<0) ? -b : b;
    return (!b) ? a : gcd(b, a%b);
}