Minimum absolute difference between N and a power of 2

Given an integer N, the task is to find the minimum absolute difference between N and a power of 2.

Examples:

Input: N = 4
Output: 0
Power of 2 closest to 4 is 4. Therefore the minimum difference possible is 0.



Input: N = 9
Output: 1
Power of 2 closest to 9 is 8 and 9 – 8 = 1

Approach: Find the power of 2 closest to N on its left, left = 2floor(log2(N)) then the closest power of 2 on N’s right will be left * 2. Now the minimum absolute difference will be the minimum of N – left and right – N.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the above approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to return the minimum difference 
// between N and a power of 2
int minAbsDiff(int n)
{
    // Power of 2 closest to n on its left
    int left = pow(2, floor(log2(n)));
  
    // Power of 2 closest to n on its right
    int right = left * 2;
  
    // Return the minimum abs difference
    return min((n - left), (right - n));
}
  
// Driver code
int main()
{
    int n = 15;
    cout << minAbsDiff(n);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the above approach
import java.util.*;
  
class GFG
{
  
// Function to return the minimum difference 
// between N and a power of 2
static int minAbsDiff(int n)
{
    // Power of 2 closest to n on its left
    int left = (int)Math.pow(2, (int)(Math.log(n) /
                                Math.log(2)));
  
    // Power of 2 closest to n on its right
    int right = left * 2;
  
    // Return the minimum abs difference
    return Math.min((n - left), (right - n));
}
  
// Driver code
public static void main(String args[])
{
    int n = 15;
    System.out.println(minAbsDiff(n));
}
}
  
// This code is contributed by 
// Surendra_Gangwar

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the 
# above approach 
  
# from math lib import floor
# and log2 function
from math import floor, log2
  
# Function to return the minimum 
# difference between N and a power of 2 
def minAbsDiff(n) :
      
    # Power of 2 closest to n on its left 
    left = pow(2, floor(log2(n)))
  
    # Power of 2 closest to n on its right 
    right = left * 2
  
    # Return the minimum abs difference 
    return min((n - left), (right - n)) 
  
# Driver code 
if __name__ == "__main__" :
  
    n = 15
    print(minAbsDiff(n))
  
# This code is contributed by Ryuga

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the above approach
using System;
  
class GFG
{
// Function to return the minimum difference 
// between N and a power of 2
static double minAbsDiff(double n)
{
    // Power of 2 closest to n on its left
    double left = Math.Pow(2, 
                Math.Floor(Math.Log(n, 2)));
  
    // Power of 2 closest to n on its right
    double right = left * 2;
  
    // Return the minimum abs difference
    return Math.Min((n - left), (right - n));
}
  
// Driver code
public static void Main()
{
    double n = 15;
    Console.Write(minAbsDiff(n));
}
}
  
// This code is contributed by
// Akanksha Rai

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP implementation of the above approach
  
// Function to return the minimum difference 
// between N and a power of 2
function minAbsDiff($n)
{
    // Power of 2 closest to n on its left
    $left = pow(2, floor(log($n, 2)));
  
    // Power of 2 closest to n on its right
    $right = $left * 2;
  
    // Return the minimum abs difference
    return min(($n - $left), ($right - $n));
}
  
// Driver code
$n = 15;
echo minAbsDiff($n);
  
// This code is contributed
// by Akanksha Rai

chevron_right


Output:

1

We can use left shift operator to optimize the implementation.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the above approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to return the minimum difference 
// between N and a power of 2
int minAbsDiff(int n)
{
    // Power of 2 closest to n on its left
    int left = 1 << ((int)floor(log2(n)));
  
    // Power of 2 closest to n on its right
    int right = left * 2;
  
    // Return the minimum abs difference
    return min((n - left), (right - n));
}
  
// Driver code
int main()
{
    int n = 15;
    cout << minAbsDiff(n);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the above approach
class GFG
{
      
// Function to return the minimum difference 
// between N and a power of 2
static int minAbsDiff(int n)
{
    // Power of 2 closest to n on its left
    int left = 1 << ((int)Math.floor(Math.log(n) / Math.log(2)));
  
    // Power of 2 closest to n on its right
    int right = left * 2;
  
    // Return the minimum abs difference
    return Math.min((n - left), (right - n));
}
  
// Driver code
public static void main (String[] args) 
{
    int n = 15;
    System.out.println(minAbsDiff(n));
}
}
  
// This code is contributed by chandan_jnu

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the
# above approach
import math
  
# Function to return the minimum 
# difference between N and a power of 2
def minAbsDiff(n):
      
    # Power of 2 closest to n on its left
    left = 1 << (int)(math.floor(math.log2(n)))
  
    # Power of 2 closest to n on its right
    right = left * 2
  
    # Return the minimum abs difference
    return min((n - left), (right - n))
  
# Driver code
if __name__ == "__main__":
    n = 15
    print(minAbsDiff(n))
  
# This code is contributed 
# by 29AjayKumar

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the above approach
using System;
  
public class GFG
{
  
// Function to return the minimum difference 
// between N and a power of 2
static int minAbsDiff(int n)
{
    // Power of 2 closest to n on its left
    int left = 1 << ((int)Math.Floor(Math.Log(n) / Math.Log(2)));
  
    // Power of 2 closest to n on its right
    int right = left * 2;
  
    // Return the minimum abs difference
    return Math.Min((n - left), (right - n));
}
  
// Driver code
static public void Main ()
{
    int n = 15;
    Console.WriteLine(minAbsDiff(n));
}
}
  
// This code is contributed by jit_t.

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php 
// PHP implementation of the above approach
  
// Function to return the minimum difference 
// between N and a power of 2
function minAbsDiff($n)
{
    // Power of 2 closest to n on its left
    $left = 1 << ((floor(log($n) / log(2))));
  
    // Power of 2 closest to n on its right
    $right = $left * 2;
  
    // Return the minimum abs difference
    return min(($n - $left), ($right - $n));
}
  
// Driver code
$n = 15;
echo minAbsDiff($n);
  
// This code is contributed by ita_c
?>

chevron_right


Output:

1

competitive-programming-img




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.