# Compute the minimum or maximum of two integers without branching

• Difficulty Level : Hard
• Last Updated : 12 Jun, 2022

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

## C++

 `/* The obvious approach to find minimum (involves branching) */``int` `min(``int` `x, ``int` `y)``{``  ``return` `(x < y) ? x : y``}` `//This code is contributed by Shubham Singh`

## C

 `/* The obvious approach to find minimum (involves branching) */``int` `min(``int` `x, ``int` `y)``{``  ``return` `(x < y) ? x : y``}`

## Java

 `/* The obvious approach to find minimum (involves branching) */``static` `int` `min(``int` `x, ``int` `y)``{``  ``return` `(x < y) ? x : y;``}` `// This code is contributed by rishavmahato348.`

## Python3

 `# The obvious approach to find minimum (involves branching)``def` `min``(x, y):``    ``return` `x ``if` `x < y ``else` `y` `  ``# This code is contributed by subham348.`

## C#

 `/* The obvious approach to find minimum (involves branching) */``static` `int` `min(``int` `x, ``int` `y)``{``  ``return` `(x < y) ? x : y;``}` `// This code is contributed by rishavmahato348.`

## Javascript

 ``

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``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` `/*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

 ``

## Javascript

 ``

Output:

```Minimum of 15 and 6 is 6
Maximum of 15 and 6 is 15```

Time Complexity: O(1)

Auxiliary Space: O(1)

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 ``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 "``<

## C

 `#include``#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

 ``

Time Complexity: O(1)

Auxiliary Space: O(1)

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 ``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

 ``

Time Complexity: O(1)

Auxiliary Space: O(1)
Source:
http://graphics.stanford.edu/~seander/bithacks.html#IntegerMinOrMax

My Personal Notes arrow_drop_up