Member Avatar for ramya_bugbuster

hi friends..
how to compare 3 number without using relational operator?
do u have any idea?

  • 5 Contributors
  • 9 Replies
  • 123 Views
  • 12 Hours Discussion Span
  • Latest Post Latest Post by jephthah

Dani AI

Generated

A concise, safe way to compare integers without using relational operators. This builds on the corner cases raised earlier: pointed out signed-subtraction overflow, highlighted sign/equality edge cases, and nudged toward arithmetic/bit tricks. The solution below avoids signed overflow by doing the subtraction in the unsigned domain and only uses bitwise/arithmetic/conditional operators (no <, >, <=, >=, ==, !=).

int max2_norel(int a, int b)
{
    unsigned ua = (unsigned)a;
    unsigned ub = (unsigned)b;
    const unsigned bits = sizeof(unsigned) * 8;

    unsigned sign_a = ua >> (bits - 1);         // 1 if a negative
    unsigned sign_b = ub >> (bits - 1);         // 1 if b negative
    unsigned sign_diff = sign_a ^ sign_b;       // 1 if signs differ

    unsigned diff = ua - ub;                    // unsigned wrap-around defined
    unsigned msb = diff >> (bits - 1);          // 1 if (a < b) when signs equal

    unsigned pick_b = (sign_diff & sign_a)      // if signs differ: pick the non-negative
                      | ((sign_diff ^ 1U) & msb);// else pick by unsigned-diff MSB

    return pick_b ? b : a;
}

int max3_norel(int a, int b, int c)
{
    return max2_norel(max2_norel(a, b), c);
}

Notes and cautions: this avoids undefined signed overflow by using unsigned arithmetic and extracts sign bits from the unsigned representation. It works on mainstream two's-complement platforms (the overwhelming common case) and correctly handles equality. For maximum clarity and portability in normal code, regular relational operators are simpler; use this technique only when the constraint is explicit (e.g., puzzles, branchless code) or when avoiding branches is required.

Recommended Answers

All 9 Replies

Member Avatar for stephen84s

yes I do, but can I see what you have tried, cause this looks like one of those questions with little practical application and mostly for academic use only ?

commented: Well said, it is a pratical question. Remeber me doing in the university. haha +2
Member Avatar for ssharish2005

Haha, OK i will give you an hint but not the answer. So relational operator should be used. But they dint say that cant use arithmetically operator did they???? Is that more than enough to give you a hint.

ssharish

Member Avatar for jephthah

you can't use any of the relational operators?

>, >=, <, <=, ==, and !=

well, then, what do you have left that could possibly be of use?

bitwise and logical operators.

Member Avatar for ramya_bugbuster

The question of how to compare three numbers without using relational operator.

The following peace of code helps to compare two numbers the same can be extended to three variables.
hi..
i got this reply from my friend..
i didnt check this yet now..
if u like just try..

The logic used is given two numbers if a - b is < 0 then b > a else a > b;
The negativity is checked based on the left most bit. If it is set to 1 then it is negative or it is positive.

Any other doubts or if there is a better answer please reply.

int max1(int a, int b)
{
    int chxvar = 1 << (8 * sizeof(int) - 1); //This initialises to a integer 
    if( (a - b) & chxvar)                            //of the value(100000000..) 

        return b;
    else
        return a;
}
Edited by mike_2000_17 because: Fixed formatting
Member Avatar for ssharish2005

I don't really see a great importance of this code here

int chxvar = 1 << (8 * sizeof(int) - 1);

any explanations???

ssharish

Member Avatar for stephen84s 
int max1(int a, int b)
{
int chxvar = 1 << (8 * sizeof(int) - 1); //This initialises to a integer
if( (a - b) & chxvar)                            //of the value(100000000..)
return b;
else
return a;
}

From the code I get the hint you are checking the sign bit here, this solution would not always work. For example consider the situation where a = MAX_INT_VALUE; and b=MIN_INT_VALUE; In such a scenario (a-b) would be equal to "-1" which is less than zero, due to overflow.

Note:

MAX_INT_VALUE and MIN_INT_VALUE mentioned only for illustration,
For my compiler (GCC 4.1.2) they are
MAX_INT_VALUE=2147483647
MIN_INT_VALUE=-2147483648
Edited by happygeek because: fixed formatting
Member Avatar for stephen84s

I don't really see a great importance of this code here

int chxvar = 1 << (8 * sizeof(int) - 1);

any explanations???

ssharish

If an int variable is set to "1", the very last bit is set to 1 and rest all bits are 0, 1 << (8 * sizeof(int) - 1) moves that 1 bit to the very start of memory location of that int variable, so it can be directly anded with (a-b) , to check if the sign bit is set or not.
Theres another draw back I just spotted here, if a=b, a-b=0 therefore the sign bit will not be set and the function will return saying a is greater than b.

Member Avatar for Prabakar

nice catch stephen84s. Then I guess the only way should be to play with bitwise operator

Member Avatar for jephthah

ramyavairamani's solution is correct, although not entirely complete as stephen84s showed.

all you have to do to avoid the overflow, is by first checking if either "a" or "b" is negative. if one is negative and one is not, simply return the one that is positive as the greater value

if both are negative, or if both are positive, then ((a-b) & MIN_INT_VALUE) will indicate which one is greater, as previously demonstrated, and without the danger of overflow.

.

Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.