Skip to content
Related Articles

Related Articles

Minimum absolute difference between N and a power of 2

Improve Article
Save Article
  • Last Updated : 23 Jun, 2022
Improve Article
Save Article

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:
Power of 2 closest to 4 is 4. Therefore the minimum difference possible is 0.
Input: N = 9 
Output:
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++




// 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;
}

Java




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

Python3




# 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

C#




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

PHP




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

Javascript




<script>
 
    // Javascript 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
        let left = Math.pow(2, Math.floor(Math.log2(n, 2)));
 
        // Power of 2 closest to n on its right
        let right = left * 2;
 
        // Return the minimum abs difference
        return Math.min((n - left), (right - n));
    }
     
    let n = 15;
    document.write(minAbsDiff(n));
     
</script>

Output: 

1

 

Time Complexity: O(1)

Auxiliary Space: O(1)

We can use left shift operator to optimize the implementation. 
 

C++




// 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;
}

Java




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

Python3




# 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

C#




// 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.

PHP




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

Javascript




<script>
    // Javascript 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
        let left = 1 << (Math.floor(Math.log(n) / Math.log(2)));
 
        // Power of 2 closest to n on its right
        let right = left * 2;
 
        // Return the minimum abs difference
        return Math.min((n - left), (right - n));
    }
     
    let n = 15;
    document.write(minAbsDiff(n));
 
</script>

Output: 

1

 

Time complexity : O(1)

Auxiliary Space: O(1)
 


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!