Найти максимум три числа в C без использования условного оператора и троичного оператора

предполагая, что вы имеете дело с целыми числами, как насчет:

#define max(x,y) (x ^ ((x ^ y) & -(x < y)))
int max3(int x, int y, int z) {
    return max(max(x,y),z);
}

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

int max( int a, int b, int c ) {
   int l1[] = { a, b };
   int l2[] = { l1[ a<b ], c };
   return l2[ l2[0] < c ];
}

подход использует (как и большинство других) тот факт, что результат логического выражения при преобразовании в int дает либо 0, либо 1. Упрощенная версия для двух значений будет:

int max( int a, int b ) {
   int lookup[] { a, b };
   return lookup[ a < b ];
}

если выражение a<b правильно возвращаемся b, тщательно хранится в первом индексе поиска матрица. Если выражение дает false, то мы возвращаем a, который хранится как элемент 0 массива подстановки. Используя это как строительный блок, вы можете сказать:

int max( int a, int b, int c ) {
   int lookup[ max(a,b), c ];
   return lookup[ max(a,b) < c ];
}

который может быть тривиально преобразован в код выше, избегая второго вызова внутреннего max используя результат, уже сохраненный в lookup[0] и встраивание исходного вызова в max(int,int).

(эта часть является еще одним доказательством того, что вы должны измерить, прежде чем прыгать в выводы, смотрите правку в конце)

Что касается того, что я действительно использую... ну, возможно, тот, который @Foo Baa здесь изменено для использования встроенной функции, а не макроса. Следующим вариантом будет либо этот, либо один из @MSN здесь.

общим знаменателем этих трех решений, отсутствующих в принятом ответе, является то, что они не только избегают синтаксической конструкции if или тернарный оператор ?:, но этого они избегают!--33-->ветвление в целом, и это может повлиять на производительность. The бранч-предиктора в CPU невозможно пропустить, когда нет ветвей.

при рассмотрении производительности сначала измерьте, а затем подумайте

я фактически реализовал несколько различных вариантов для 2-way max и проанализировал сгенерированный код компилятором. Следующие три решения генерируют все тот же код сборки:

int max( int a, int b ) { if ( a < b ) return b; else return a; }
int max( int a, int b ) { return (a < b? b : a ); }
int max( int a, int b ) {
   (void)((a < b) && (a = b));
   return a;
}

что неудивительно, так как все три представляют собой одну и ту же операцию. Интересная информация заключается в том, что сгенерированный код не содержит никакой ветви. Реализация проста с cmovge инструкция (тест выполняется с g++ на платформе intel x64):

movl    %edi, %eax       # move a into the return value
cmpl    %edi, %esi       # compare a and b
cmovge  %esi, %eax       # if (b>a), move b into the return value
ret

трюк заключается в инструкции условного перемещения, которая позволяет избежать любой потенциальной ветви.

ни одно из других решений имеет какие-либо ветви, но все они переводят больше инструкций cpu, чем любой из этого, что в конце концов успокаивает нас, что мы всегда должны написать простой код и пусть компилятор оптимизирует его для нас.

обновление: глядя на это 4 года спустя, я вижу, что это плохо, если два или более значений оказываются равными. Замена > by >= изменяет поведение, но не устраняет проблему. Он все еще может быть спасен, поэтому я пока не удалю его, но не используйте это в производственном коде.

хорошо, вот мой:

int max3(int a, int b, int c)
{
    return a * (a > b & a > c) +
           b * (b > a & b > c) +
           c * (c > a & c > b);
}

обратите внимание, что использование &, а не && избегает любого условного кода; он полагается на то, что > всегда дает 0 или 1. (Код, сгенерированный для a > b может включать условные прыжки, но они не видны из C.)

int fast_int_max(int a, int b)
{
    int select= -(a < b);
    unsigned int b_mask= select, a_mask= ~b_mask;

    return (a&a_mask)|(b&b_mask);
}

int fast_int_max3(int a, int b, int c)
{
    return fast_int_max(a, fast_int_max(b, c));
}

логические операторы значений (включая b), либо все нулевые биты (если a

int max(int a, int b)
{
    long d = (long)b - (long)a;
    int m = (int)(d >> 63);
    return a & m | b & ~m;
}

int max(int a, int b, int c)
{
    long d;
    int m;
    d = (long)b - (long)a;
    m = (int)(d >> 63);
    a = a & m | b & ~m;
    d = (long)c - (long)a;
    m = (int)(d >> 63);
    return a & m | c & ~m;
}

нет условий. Только бросок в uint. Совершенное решение.

int abs (a) { return (int)((unsigned int)a); }
int max (a, b) { return (a + b + abs(a - b)) / 2; }
int min (a, b) { return (a + b - abs(a - b)) / 2; }


void sort (int & a, int & b, int & c)
{
   int max = max(max(a,b), c);
   int min = min(min(a,b), c);
   int middle = middle = a + b + c - max - min;
   a = max;
   b = middle;
   c = min;
}

#include "stdafx.h"
#include <iostream>
int main()
{       
        int x,y,z;
        scanf("%d %d %d", &x,&y, &z);
        int max = ((x+y) + abs(x-y)) /2;
        max = ((max+z) + abs(max-z)) /2;
        printf("%d ", max);
        return 0;
}            

Вы можете использовать этот код, чтобы найти наибольшее из двух:

max{a,b} = abs(a-b)/2 + (a+b)/2

затем используйте его снова, чтобы найти третье число:

max{a,b,c} = max(a,max(b,c))

см., что это работает для положительных чисел, вы можете изменить его на работу для отрицательных.

нет условных операторов, просто циклы и задания. И совершенно разные формы чужих ответов:)

while (a > b)
{
    while (a > c)
    {
        tmp = a;
        goto finish;
    }
    tmp = c;
    goto finish;
}
while (b > c)
{
    tmp = b;
    goto finish;
}
tmp = c;
finish: max = tmp;

int compare(int a,int b, intc)
{
    return (a > b ? (a > c ? a : c) : (b > c ? b : c))
}

попробуйте это.

#include "stdio.h"
main() {
    int a,b,c,rmvivek,arni,csc; 
    printf("enter the three numbers");
    scanf("%d%d%d",&a,&b,&c);
    printf("the biggest value is %d",(a>b&&a>c?a:b>c?b:c));
}

max =  a > b ? ( a > c ? a : c ) : ( b > c ? b : c ) ;