http://www.graphics.stanford.edu/~seander/bithacks.html#IntegerMinOrMax

r = x - ((x - y) & -(x < y)); // max(x, y)

можно весело провести время с арифметическим смещением (x - y) для насыщения знакового бита, но это обычно достаточно. Или можно протестировать высокий бит, всегда забава.

Я думаю, что у меня есть он.

int data[2] = {a,b};
int c = a - b;
return data[(int)((c & 0x80000000) >> 31)];

разве это не работало бы? В основном Вы берете различие этих двух и затем возвращаетесь один или другой на основе знакового бита. (Это - то, как процессор делает больше, чем или меньше, чем так или иначе.) Поэтому, если знаковый бит 0, возвратите a, начиная с больше, чем или равный b. Если знаковый бит равняется 1, возвратите b, потому что, вычитая b от вызванного результат для движения отрицательный, указывая, что b был больше, чем a. Просто удостоверьтесь, что Ваши ints составляют подписанные 32 бита.

возвратитесь (a> b? a: b);

или

int max(int a, int b)
{
        int x = (a - b) >> 31;
        int y = ~x;
        return (y & a) | (x & b); 
}

не столь притягательный как вышеупомянутое..., но...

int getMax(int a, int b)
{
    for(int i=0; (i<a) || (i<b); i++) { }
    return i;
}

Так как это - загадка, решение будет немного замысловатым:

let greater x y = signum (1+signum (x-y))

let max a b = (greater a b)*a + (greater b a)*b

Это - Haskell, но это будет то же на любом другом языке. Люди C/C# должны использовать "sgn" (или "знак"?) вместо знака.

Примечание, что это будет работать над ints произвольного размера и над реалами также.

Это - вид обмана, с помощью ассемблера, но это интересно, тем не менее:

// GCC inline assembly
int max(int a, int b)
{
  __asm__("movl %0, %%eax\n\t"   // %eax = a
          "cmpl %%eax, %1\n\t"   // compare a to b
          "cmovg %1, %%eax"      // %eax = b if b>a
         :: "r"(a), "r"(b));
}

, Если Вы хотите быть строгими о правилах и сказать, что cmpl команда запрещена для этого, затем следующая (менее эффективная) последовательность будет работать:

int max(int a, int b)
{
  __asm__("movl %0, %%eax\n\t"
      "subl %1, %%eax\n\t"
          "cmovge %0, %%eax\n\t"
          "cmovl %1, %%eax"
         :: "r"(a), "r"(b)
         :"%eax");
}

В мире математики:

max(a+b) = ( (a+b) + |(a-b)| ) / 2
min(a-b) = ( (a+b) - |(a-b)| ) / 2

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

| x | означает абсолютное значение x.

Комментарий:

Вы правы, абсолютное значение было забыто. Это должно быть справедливо для всех положительных или отрицательных значений a, b

Из статьи z0mbie (известного автора вирусов) "Полиморфные игры", может быть, она вам пригодится:

#define H0(x)       (((signed)(x)) >> (sizeof((signed)(x))*8-1))
#define H1(a,b)     H0((a)-(b))

#define MIN1(a,b)   ((a)+(H1(b,a) & ((b)-(a))))
#define MIN2(a,b)   ((a)-(H1(b,a) & ((a)-(b))))
#define MIN3(a,b)   ((b)-(H1(a,b) & ((b)-(a))))
#define MIN4(a,b)   ((b)+(H1(a,b) & ((a)-(b))))
//#define MIN5(a,b)   ((a)<(b)?(a):(b))
//#define MIN6(a,b)   ((a)>(b)?(b):(a))
//#define MIN7(a,b)   ((b)>(a)?(a):(b))
//#define MIN8(a,b)   ((b)<(a)?(b):(a))

#define MAX1(a,b)   ((a)+(H1(a,b) & ((b)-(a))))
#define MAX2(a,b)   ((a)-(H1(a,b) & ((a)-(b))))
#define MAX3(a,b)   ((b)-(H1(b,a) & ((b)-(a))))
#define MAX4(a,b)   ((b)+(H1(b,a) & ((a)-(b))))
//#define MAX5(a,b)   ((a)<(b)?(b):(a))
//#define MAX6(a,b)   ((a)>(b)?(a):(b))
//#define MAX7(a,b)   ((b)>(a)?(b):(a))
//#define MAX8(a,b)   ((b)<(a)?(a):(b))

#define ABS1(a)     (((a)^H0(a))-H0(a))
//#define ABS2(a)     ((a)>0?(a):-(a))
//#define ABS3(a)     ((a)>=0?(a):-(a))
//#define ABS4(a)     ((a)<0?-(a):(a))
//#define ABS5(a)     ((a)<=0?-(a):(a))

ура