Skip to content
Related Articles

Related Articles

Improve Article

Compute the minimum or maximum of two integers without branching

  • Difficulty Level : Hard
  • Last Updated : 28 May, 2021

On some rare machines where branching is expensive, the below obvious approach to find minimum can be slow as it uses branching.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

C




/* The obvious approach to find minimum (involves branching) */
int min(int x, int y)
{
  return (x < y) ? x : y
}
Below are the methods to get minimum(or maximum) without using branching. Typically, the obvious approach is best, though.
Method 1(Use XOR and comparison operator)
Minimum of x and y will be 


y ^ ((x ^ y) & -(x < y))
It works because if x < y, then -(x < y) will be -1 which is all ones(11111….), so r = y ^ ((x ^ y) & (111111…)) = y ^ x ^ y = x. 
And if x>y, then-(x<y) will be -(0) i.e -(zero) which is zero, so r = y^((x^y) & 0) = y^0 = y.
On some machines, evaluating (x < y) as 0 or 1 requires a branch instruction, so there may be no advantage.
To find the maximum, use 
x ^ ((x ^ y) & -(x < y));
C++



// C++ program to Compute the minimum
// or maximum of two integers without
// branching
#include<iostream>
using namespace std;
 
class gfg
{
     
    /*Function to find minimum of x and y*/
    public:
    int min(int x, int y)
    {
        return y ^ ((x ^ y) & -(x < y));
    }
 
    /*Function to find maximum of x and y*/
    int max(int x, int y)
    {
        return x ^ ((x ^ y) & -(x < y));
    }
    };
     
    /* Driver code */
    int main()
    {
        gfg g;
        int x = 15;
        int y = 6;
        cout << "Minimum of " << x <<
             " and " << y << " is ";
        cout << g. min(x, y);
        cout << "\nMaximum of " << x <<
                " and " << y << " is ";
        cout << g.max(x, y);
        getchar();
    }
 
// This code is contributed by SoM15242
C



// C program to Compute the minimum
// or maximum of two integers without
// branching
#include<stdio.h>
 
/*Function to find minimum of x and y*/
int min(int x, int y)
{
return y ^ ((x ^ y) & -(x < y));
}
 
/*Function to find maximum of x and y*/
int max(int x, int y)
{
return x ^ ((x ^ y) & -(x < y));
}
 
/* Driver program to test above functions */
int main()
{
int x = 15;
int y = 6;
printf("Minimum of %d and %d is ", x, y);
printf("%d", min(x, y));
printf("\nMaximum of %d and %d is ", x, y);
printf("%d", max(x, y));
getchar();
}
Java



// Java program to Compute the minimum
// or maximum of two integers without
// branching
public class AWS {
 
    /*Function to find minimum of x and y*/
    static int min(int x, int y)
    {
    return y ^ ((x ^ y) & -(x << y));
    }
     
    /*Function to find maximum of x and y*/
    static int max(int x, int y)
    {
    return x ^ ((x ^ y) & -(x << y));
    }
     
    /* Driver program to test above functions */
    public static void main(String[] args) {
         
        int x = 15;
        int y = 6;
        System.out.print("Minimum of "+x+" and "+y+" is ");
        System.out.println(min(x, y));
        System.out.print("Maximum of "+x+" and "+y+" is ");
        System.out.println( max(x, y));
    }
 
}
Python3



# Python3 program to Compute the minimum
# or maximum of two integers without
# branching
 
# Function to find minimum of x and y
 
def min(x, y):
 
    return y ^ ((x ^ y) & -(x < y))
 
 
# Function to find maximum of x and y
def max(x, y):
 
    return x ^ ((x ^ y) & -(x < y))
 
 
# Driver program to test above functions
x = 15
y = 6
print("Minimum of", x, "and", y, "is", end=" ")
print(min(x, y))
print("Maximum of", x, "and", y, "is", end=" ")
print(max(x, y))
 
# This code is contributed
# by Smitha Dinesh Semwal
C#



using System;
 
// C# program to Compute the minimum
// or maximum of two integers without 
// branching
public class AWS
{
 
    /*Function to find minimum of x and y*/
    public  static int min(int x, int y)
    {
    return y ^ ((x ^ y) & -(x << y));
    }
 
    /*Function to find maximum of x and y*/
    public  static int max(int x, int y)
    {
    return x ^ ((x ^ y) & -(x << y));
    }
 
    /* Driver program to test above functions */
    public static void Main(string[] args)
    {
 
        int x = 15;
        int y = 6;
        Console.Write("Minimum of " + x + " and " + y + " is ");
        Console.WriteLine(min(x, y));
        Console.Write("Maximum of " + x + " and " + y + " is ");
        Console.WriteLine(max(x, y));
    }
 
}
 
  // This code is contributed by Shrikant13
PHP



<?php
// PHP program to Compute the minimum
// or maximum of two integers without
// branching
 
// Function to find minimum
// of x and y
function m_in($x, $y)
{
    return $y ^ (($x ^ $y) &
            - ($x < $y));
}
 
// Function to find maximum
// of x and y
function m_ax($x, $y)
{
    return $x ^ (($x ^ $y) &
            - ($x < $y));
}
 
// Driver Code
$x = 15;
$y = 6;
echo"Minimum of"," ", $x," ","and",
    " ",$y," "," is "," ";
     
echo m_in($x, $y);
 
echo "\nMaximum of"," ",$x," ",
    "and"," ",$y," ", " is ";
     
echo m_ax($x, $y);
 
// This code is contributed by anuj_67.
?>
Javascript



<script>
// Javascript program to Compute the minimum
// or maximum of two integers without
// branching
 
    /*Function to find minimum of x and y*/
    function min(x,y)
    {
        return y ^ ((x ^ y) & -(x << y));
    }
     
    /*Function to find maximum of x and y*/
    function max(x,y)
    {
        return x ^ ((x ^ y) & -(x << y));
    }
     
    /* Driver program to test above functions */
    let x = 15
    let y = 6
    document.write("Minimum of  "+ x + " and " + y + " is ");
    document.write(min(x, y) + "<br>");
    document.write("Maximum of " + x + " and " + y + " is ");
    document.write(max(x, y) + "\n");
     
    // This code is contributed by avanitrachhadiya2155
</script>
Output: 
Minimum of 15 and 6 is 6
Maximum of 15 and 6 is 15
Method 2(Use subtraction and shift) 
If we know that 
INT_MIN <= (x - y) <= INT_MAX
, then we can use the following, which are faster because (x – y) only needs to be evaluated once. 
Minimum of x and y will be 
y + ((x - y) & ((x - y) >>(sizeof(int) * CHAR_BIT - 1)))
This method shifts the subtraction of x and y by 31 (if size of integer is 32). If (x-y) is smaller than 0, then (x -y)>>31 will be 1. If (x-y) is greater than or equal to 0, then (x -y)>>31 will be 0. 
So if x >= y, we get minimum as y + (x-y)&0 which is y. 
If x < y, we get minimum as y + (x-y)&1 which is x.
Similarly, to find the maximum use 
x - ((x - y) & ((x - y) >> (sizeof(int) * CHAR_BIT - 1)))
C++



#include <bits/stdc++.h>
using namespace std;
#define CHARBIT 8
 
/*Function to find minimum of x and y*/
int min(int x, int y)
{
    return y + ((x - y) & ((x - y) >>
            (sizeof(int) * CHARBIT - 1)));
}
 
/*Function to find maximum of x and y*/
int max(int x, int y)
{
    return x - ((x - y) & ((x - y) >>
            (sizeof(int) * CHARBIT - 1)));
}
 
/* Driver code */
int main()
{
    int x = 15;
    int y = 6;
    cout<<"Minimum of "<<x<<" and "<<y<<" is ";
    cout<<min(x, y);
    cout<<"\nMaximum of"<<x<<" and "<<y<<" is ";
    cout<<max(x, y);
}
 
// This code is contributed by rathbhupendra
C



#include<stdio.h>
#define CHAR_BIT 8
 
/*Function to find minimum of x and y*/
int min(int x, int y)
{
  return  y + ((x - y) & ((x - y) >>
            (sizeof(int) * CHAR_BIT - 1)));
}
 
/*Function to find maximum of x and y*/
int max(int x, int y)
{
  return x - ((x - y) & ((x - y) >>
            (sizeof(int) * CHAR_BIT - 1)));
}
 
/* Driver program to test above functions */
int main()
{
  int x = 15;
  int y = 6;
  printf("Minimum of %d and %d is ", x, y);
  printf("%d", min(x, y));
  printf("\nMaximum of %d and %d is ", x, y);
  printf("%d", max(x, y));
  getchar();
}
Java



// JAVA implementation of above approach
class GFG
{
     
static int CHAR_BIT = 4;
static int INT_BIT = 8;
/*Function to find minimum of x and y*/
static int min(int x, int y)
{
    return y + ((x - y) & ((x - y) >>
                (INT_BIT * CHAR_BIT - 1)));
}
 
/*Function to find maximum of x and y*/
static int max(int x, int y)
{
    return x - ((x - y) & ((x - y) >>
            (INT_BIT * CHAR_BIT - 1)));
}
 
/* Driver code */
public static void main(String[] args)
{
    int x = 15;
    int y = 6;
    System.out.println("Minimum of "+x+" and "+y+" is "+min(x, y));
    System.out.println("Maximum of "+x+" and "+y+" is "+max(x, y));
}
}
 
// This code is contributed by 29AjayKumar
Python3



# Python3 implementation of the approach
import sys;
     
CHAR_BIT = 8;
INT_BIT = sys.getsizeof(int());
 
#Function to find minimum of x and y
def Min(x, y):
    return y + ((x - y) & ((x - y) >>
                (INT_BIT * CHAR_BIT - 1)));
 
#Function to find maximum of x and y
def Max(x, y):
    return x - ((x - y) & ((x - y) >>
                (INT_BIT * CHAR_BIT - 1)));
 
# Driver code
x = 15;
y = 6;
print("Minimum of", x, "and",
                    y, "is", Min(x, y));
print("Maximum of", x, "and",
                    y, "is", Max(x, y));
 
# This code is contributed by PrinciRaj1992
C#



// C# implementation of above approach
using System;
 
class GFG
{
     
static int CHAR_BIT = 8;
 
/*Function to find minimum of x and y*/
static int min(int x, int y)
{
    return y + ((x - y) & ((x - y) >>
                (sizeof(int) * CHAR_BIT - 1)));
}
 
/*Function to find maximum of x and y*/
static int max(int x, int y)
{
    return x - ((x - y) & ((x - y) >>
            (sizeof(int) * CHAR_BIT - 1)));
}
 
/* Driver code */
static void Main()
{
    int x = 15;
    int y = 6;
    Console.WriteLine("Minimum of "+x+" and "+y+" is "+min(x, y));
    Console.WriteLine("Maximum of "+x+" and "+y+" is "+max(x, y));
}
}
 
// This code is contributed by mits
Javascript



<script>
// javascript implementation of above approach   
var CHAR_BIT = 4;
    var INT_BIT = 8;
 
    /* Function to find minimum of x and y */
    function min(x , y) {
        return y + ((x - y) & ((x - y) >> (INT_BIT * CHAR_BIT - 1)));
    }
 
    /* Function to find maximum of x and y */
    function max(x , y) {
        return x - ((x - y) & ((x - y) >> (INT_BIT * CHAR_BIT - 1)));
    }
 
    /* Driver code */
        var x = 15;
        var y = 6;
        document.write("Minimum of " + x + " and " + y + " is " + min(x, y)+"<br/>");
        document.write("Maximum of " + x + " and " + y + " is " + max(x, y));
 
// This code is contributed by shikhasingrajput
</script>
Note that the 1989 ANSI C specification doesn’t specify the result of signed right-shift, so above method is not portable. If exceptions are thrown on overflows, then the values of x and y should be unsigned or cast to unsigned for the subtractions to avoid unnecessarily throwing an exception, however the right-shift needs a signed operand to produce all one bits when negative, so cast to signed there. 


Method 3 (Use absolute value) 
A generalized formula to find the max/min number with absolute value is : 
(x + y + ABS(x-y) )/2
Find the min number is: 
(x + y - ABS(x-y) )/2
So, if we can use the bitwise operation to find the absolute value, we can find the max/min number without using if conditions. The way to find the absolute way with bitwise operation can be found here:
Step1) Set the mask as right shift of integer by 31 (assuming integers are stored as two’s-complement 32-bit values and that the right-shift operator does sign extension).
mask = n>>31
Step2) XOR the mask with number
mask ^ n
Step3) Subtract mask from result of step 2 and return the result.
(mask^n) - mask 
Therefore, we can conclude the solution as follows:
C++



// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
int absbit32(int x, int y)
{
    int sub = x - y;
    int mask = (sub >> 31);
    return (sub ^ mask) - mask;        
 }
 
int max(int x, int y)
{
    int abs = absbit32(x, y);        
    return (x + y + abs) / 2;        
 }
  
int min(int x, int y)
{
    int abs = absbit32(x, y);        
    return (x + y - abs) / 2;
}
  
// Driver Code
int main()
{
    cout << max(2, 3) << endl; //3
    cout <<  max(2, -3) << endl; //2
    cout << max(-2, -3) << endl; //-2
    cout <<  min(2, 3) << endl; //2
    cout << min(2, -3) << endl; //-3
    cout << min(-2, -3) << endl; //-3
 
    return 0;
}
 
// This code is contributed by avijitmondal1998
Java



// Java program for the above approach
 
import java.io.*;
 
class GFG {
     public static void main(String []args){
        System.out.println( max(2,3) ); //3
        System.out.println( max(2,-3) ); //2
        System.out.println( max(-2,-3) ); //-2
        System.out.println( min(2,3) ); //2
        System.out.println( min(2,-3) ); //-3
        System.out.println( min(-2,-3) ); //-3
     }
      
     public static int max(int x, int y){
         int abs = absbit32(x,y);        
         return (x + y + abs)/2;        
     }
      
     public static int min(int x, int y){
         int abs = absbit32(x,y);        
         return (x + y - abs)/2;
     }
      
     public static int absbit32(int x, int y){
         int sub = x - y;
         int mask = (sub >> 31);
         return (sub ^ mask) - mask;        
     }
}
Python3



# Python3 program for the above approach
def max(x, y):
  abs = absbit32(x,y)
  return (x + y + abs)//2     
      
def min(x, y):
  abs = absbit32(x,y)
  return (x + y - abs)//2
      
def absbit32( x, y):
  sub = x - y
  mask = (sub >> 31)
  return (sub ^ mask) - mask      
 
# Driver code
print( max(2,3) ) #3
print( max(2,-3) ) #2
print( max(-2,-3) ) #-2
print( min(2,3) ) #2
print( min(2,-3) ) #-3
print( min(-2,-3) ) #-3
 
# This code is contributed by rohitsingh07052.
C#



// C# program for the above approach
using System;
 
class GFG{
     
public static void Main(String []args)
{
    Console.WriteLine(max(2, 3)); //3
    Console.WriteLine(max(2, -3)); //2
    Console.WriteLine(max(-2, -3)); //-2
    Console.WriteLine(min(2, 3)); //2
    Console.WriteLine(min(2, -3)); //-3
    Console.WriteLine(min(-2, -3)); //-3
}
  
public static int max(int x, int y)
{
    int abs = absbit32(x, y);        
    return (x + y + abs) / 2;        
}
 
public static int min(int x, int y)
{
    int abs = absbit32(x, y);        
    return (x + y - abs) / 2;
}
 
public static int absbit32(int x, int y)
{
    int sub = x - y;
    int mask = (sub >> 31);
    return (sub ^ mask) - mask;        
}
}
 
// This code is contributed by Amit Katiyar
Javascript



<script>
 
// Javascript program for the above approach
 
 function max(x , y){
     var abs = absbit32(x,y);        
     return (x + y + abs)/2;        
 }
  
 function min(x , y){
     var abs = absbit32(x,y);        
     return (x + y - abs)/2;
 }
  
 function absbit32(x , y){
     var sub = x - y;
     var mask = (sub >> 31);
     return (sub ^ mask) - mask;        
 }
 // Drive code
 document.write( max(2,3)+"<br>" ); //3
 document.write( max(2,-3)+"<br>" ); //2
 document.write( max(-2,-3)+"<br>" ); //-2
 document.write( min(2,3)+"<br>" ); //2
 document.write( min(2,-3)+"<br>" ); //-3
 document.write( min(-2,-3) ); //-3
 
// This code is contributed by 29AjayKumar
 
</script>
Source: 
http://graphics.stanford.edu/~seander/bithacks.html#IntegerMinOrMax
 



My Personal Notes
arrow_drop_up
Next

Smallest of three integers without comparison operators
Recommended Articles
Page :
Compute the integer absolute value (abs) without branching
26, Feb 10
Compute maximum of two integers in C/C++ using Bitwise Operators
05, Nov 20
How to sum two integers without using arithmetic operators in C/C++?
24, Jun 16
Divide two integers without using multiplication, division and mod operator
05, Feb 18
Compare two integers without using any Comparison operator
15, Jan 17
Smallest of three integers without comparison operators
12, Nov 11
Partition array into two subsets with minimum Bitwise XOR between their maximum and minimum
20, Jan 21
Compute modulus division by a power-of-2-number
22, Nov 09
Compute the parity of a number using XOR and table look-up
09, Jul 17
Find maximum XOR of given integer in a stream of integers
28, Jun 17
Maximum set bit count from pairs of integers from 0 to N that yields a sum as N
25, Jul 20
Bitwise recursive addition of two integers
15, Apr 18
Find two integers A and B such that A ^ N = A + N and B ^ N = B + N
30, Jul 19
Calculate Bitwise OR of two integers from their given Bitwise AND and Bitwise XOR values
02, Dec 20
Numbers formed by flipping common set bits in two given integers
17, Nov 20
Check if a pair of integers from two ranges exists such that their Bitwise XOR exceeds both the ranges
11, Jun 21
Hamming distance between two Integers
04, Oct 18
Count numbers up to N that cannot be expressed as sum of at least two consecutive positive integers
03, May 21
Number of mismatching bits in the binary representation of two integers
29, Oct 18
Detect if two integers have opposite signs
03, Sep 12
Smallest pair of integers with minimum difference whose Bitwise XOR is N
26, Jul 21
Find a number which give minimum sum when XOR with every number of array of integers
06, May 19
Minimum count of consecutive integers till N whose bitwise AND is 0 with N
07, Jul 21
Maximum set bit sum in array without considering adjacent elements
10, Sep 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox