Как найти минимальное и максимальное количество чисел в C без петель?

Question

Допустим, у меня есть 10 чисел (двойников), и мне нужно найти наименьшее число и наибольшее число без использования циклов , как бы я это сделал?

Answer 1

В псевдо-коде, если это домашнее задание:

min = arr[0]
max = arr[0]
for n in 1..size(arr)-1:
    if arr[n] > max:
        max = arr[n]
    if arr[n] < min:
        min = arr[n]

Если по какой-то причине вы не можете использовать циклы (а это , безусловно, помечает это как домашнее задание -никто в здравом уме не попробует это без цикла), просто разверните цикл:

min = arr[0]
if arr[1] < min min = arr[1]
if arr[2] < min min = arr[2]
if arr[3] < min min = arr[3]
if arr[4] < min min = arr[4]
if arr[5] < min min = arr[5]
if arr[6] < min min = arr[6]
if arr[7] < min min = arr[7]
if arr[8] < min min = arr[8]
if arr[9] < min min = arr[9]
max = arr[0]
if arr[1] > max max = arr[1]
if arr[2] > max max = arr[2]
if arr[3] > max max = arr[3]
if arr[4] > max max = arr[4]
if arr[5] > max max = arr[5]
if arr[6] > max max = arr[6]
if arr[7] > max max = arr[7]
if arr[8] > max max = arr[8]
if arr[9] > max max = arr[9]

Это не слишком плохо для десяти записей, но это будет громоздким, посколькучисло растет.

Или рекурсивное решение для более странно мыслящих из нас: -)

def findMax (arr, cur, idx):
    if idx < 0:
        return cur
    if arr[idx] > cur
        return findMax (arr, arr[idx], idx-1)
    return findMax (arr, cur, idx-1)

def findMin (arr, cur, idx):
    if idx < 0:
        return cur
    if arr[idx] < cur
        return findMin (arr, arr[idx], idx-1)
    return findMin (arr, cur, idx-1)

max = findMax (arr, arr[9], 8)
min = findMin (arr, arr[9], 8)

Но я бы не отдал это рекурсивное решение - если бы вы не сделалипока что циклов, вероятно, это намного выше уровня, на котором работает ваш класс.

---

И, поскольку рекурсивное решение является довольно изящным решением без петель (и у вас почти нулевой шансиспользовать его и не быть обнаруженным в качестве плагиата), вот оно:

#include <stdio.h>

static int findMin (int *arr, int cur, int idx) {
    if (idx < 0)
        return cur;
    if (arr[idx] < cur)
        return findMin (arr, arr[idx], idx-1);
    return findMin (arr, cur, idx-1);
}

static int findMax (int *arr, int cur, int idx) {
    if (idx < 0)
        return cur;
    if (arr[idx] > cur)
        return findMax (arr, arr[idx], idx-1);
    return findMax (arr, cur, idx-1);
}

int main (void) {
    int nums[] = {27,18,28,18,28,45,93,14,15,92,65,35,89};
    int min, max;
    int x = sizeof(nums) / sizeof(*nums) - 1;

    max = findMax (nums, nums[x], x-1);
    min = findMin (nums, nums[x], x-1);

    printf ("min=%d, max=%d\n", min, max);
    return 0;
}

Это выводит:

min=14, max=93

, как ожидается, но не используйте его в больших списках, так каквам, вероятно, не хватит места в стеке.

Answer 2

Рекурсивное наибольшее число:

double fun( double * ar, uint idx, uint size, double max )
{
    double rv;
    if( idx < size )
    {
        if( max < ar[idx] )     { rv = fun( ar, 1 + idx, size, ar[idx] ); }
        else                    { rv = fun( ar, 1 + idx, size,     max ); }
    }
    else                        { rv = max; }
    return rv;
}

Призвание:

double ray[] = { .0, -16.0, 2.0, -4.0, 8.0, -1.0, 7.0, -3.0, 5.0, -10.0 };
printf( "max %lf\n", fun( ray, 1, sizeof( ray ) / sizeof( ray[0] ), ray[0] ) );

Наименьшее - почти то же самое:

        if( ar[idx] < min )     { rv = fun( ar, 1 + idx, size, ar[idx] ); }