Open In App

Find two integers A and B such that A ^ N = A + N and B ^ N = B + N

Given a non-negative integer N, the task is to find two integers A (greatest integer smaller than N) and (smallest integer greater than N) such that A + N = A ^ N and B + N = B ^ N
Examples: 
 

Input: N = 5 
Output: A = 2 and B = 8 
2 + 8 = 2 ^ 8 = 10
Input: N = 10 
Output: A = 5 and B = 16 
5 + 16 = 5 ^ 16 = 21 
 

 

Approach: Lets find A and B independently. To solve this problem we have to use the property, x + y = x^y + 2 * (x & y) 
Since the problem states that xor sum is equal to the given sum which implies that their AND must be 0. 
 

Below is the implementation of the above approach:
 




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
#define MAX 32
 
// Function to find A and B
void findAB(int N)
{
    bitset<MAX> arr(N), brr(N);
 
    // To store the leftmost set bit in N
    int leftsetN = -1;
    for (int i = MAX - 1; i >= 0; --i) {
        if (arr[i] == 1) {
            leftsetN = i;
            break;
        }
    }
 
    // To store the value of A
    int A = 0;
    for (int i = leftsetN; i >= 0; --i) {
 
        // If the bit is unset in N
        // then  we will set it in A
        if (arr[i] == 0) {
            A |= (1 << i);
        }
    }
 
    // To store the value of B
    int B = 0;
 
    // B will be (1 << (leftsetN + 1))
    B = 1 << (leftsetN + 1);
 
    // Print the values of A and B
    cout << "A = " << A << " and B = " << B;
}
 
// Driver code
int main()
{
    int N = 5;
 
    findAB(N);
 
    return 0;
}




// Java implementation of the approach
import java.util.*;
 
class GFG {
    static int MAX = 32;
 
    // Function to reverse string
    static String Reverse(String s)
    {
   
        StringBuilder rev = new StringBuilder();
   
        // append a string into StringBuilder rev
        rev.append(s);
   
        // reverse StringBuilder rev
        rev.reverse();
         
        return rev.toString();
   
    }
 
    // Function to find A and B
    static void findAB(int N)
    {
        // Creating a bitset
        BitSet arr = BitSet.valueOf(new long[]{N});
     
        // To store the leftmost set bit in N
        int leftsetN = -1;
        for (int i = 63; i >= 0; --i) {
            if (arr.get(i)) {
                leftsetN = i;
                break;
            }
        }
 
        // To store the value of A
        int A = 0;
        for (int i = leftsetN; i >= 0; --i) {
 
            // If the bit is unset in N
            // then  we will set it in A
            if (!arr.get(i)) {
                A |= (1 << i);
            }
        }
 
        // To store the value of B
        int B = 0;
 
        // B will be (1 << (leftsetN + 1))
        B = 1 << (leftsetN + 1);
 
        // Print the values of A and B
        System.out.println("A = " + A + " and B = " + B);
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int N = 5;
        findAB(N);
    }
}
 
// This code is contributed by phasing17.




# Python implementation of the approach
MAX = 32
 
# Function to find A and B
def findAB(N):
    arr = bin(N)[2::]
    arr = "0" * (MAX - len(arr)) + arr
    arr = arr[::-1]
 
    # To store the leftmost set bit in N
    leftsetN = -1;
    for i in range(MAX - 1, -1, -1):
        if (arr[i] == '1'):
            leftsetN = i;
            break;
 
    # To store the value of A
    A = 0;
    for i in range(leftsetN, -1, -1):
 
        # If the bit is unset in N
        # then  we will set it in A
        if (arr[i] == '0') :
            A |= (1 << (i));
         
    # To store the value of B
    B = 0;
 
    # B will be (1 << (leftsetN + 1))
    B = 1 << ((leftsetN) + 1);
 
    # Print the values of A and B
    print("A =", A, "and B =", B);
 
# Driver code
N = 5;
findAB(N);
 
# This code is contributed by phasing17




// C# implementation of the approach
using System;
using System.Collections.Specialized;
using System.Collections.Generic;
 
class GFG {
    static int MAX = 32;
 
    // Function to reverse string
    static string Reverse(string s)
    {
        char[] charArray = s.ToCharArray();
        Array.Reverse(charArray);
        return new string(charArray);
    }
 
    // Function to find A and B
    static void findAB(int N)
    {
        BitVector32 arr = new BitVector32(N);
        string arrs = arr.ToString();
        arrs
            = Reverse(arrs.Substring(arrs.Length - 33, 32));
 
        // To store the leftmost set bit in N
        int leftsetN = -1;
        for (int i = MAX - 1; i >= 0; --i) {
            if (arrs[i] == '1') {
                leftsetN = i;
                break;
            }
        }
 
        // To store the value of A
        int A = 0;
        for (int i = leftsetN; i >= 0; --i) {
 
            // If the bit is unset in N
            // then  we will set it in A
            if (arrs[i] == '0') {
                A |= (1 << i);
            }
        }
 
        // To store the value of B
        int B = 0;
 
        // B will be (1 << (leftsetN + 1))
        B = 1 << (leftsetN + 1);
 
        // Print the values of A and B
        Console.WriteLine("A = " + A + " and B = " + B);
    }
 
    // Driver code
    public static void Main(string[] args)
    {
        int N = 5;
        findAB(N);
    }
}




// JS implementation of the approach
 
let MAX = 32
 
// Function to find A and B
function findAB(N)
{
    let arr = N.toString(2);
    arr = "0".repeat(MAX - arr.length) + arr;
    arr = arr.split("");
    arr.reverse()
 
    // To store the leftmost set bit in N
    let leftsetN = -1;
    for (let i = MAX - 1; i >= 0; --i) {
        if (arr[i] == '1') {
            leftsetN = i;
            break;
        }
    }
     
 
    // To store the value of A
    let A = 0;
    for (let i = leftsetN; i >= 0; --i) {
 
        // If the bit is unset in N
        // then  we will set it in A
        if (arr[i] == '0') {
            A |= (1 << (i));
        }
    }
 
    // To store the value of B
    let B = 0;
 
    // B will be (1 << (leftsetN + 1))
    B = 1 << ((leftsetN) + 1);
 
    // Print the values of A and B
    console.log("A = " + A + " and B = " + B);
}
 
 
// Driver code
let N = 5;
findAB(N);
 
 
// This code is contributed by phasing17

Output: 
A = 2 and B = 8

 

Time Complexity: O(MAX)

Auxiliary Space: O(N)


Article Tags :