Find the original number by flipping K unique bits in C++

Introduction:

As finding the original number by flipping K unique bits is an interesting problem in C++ which concerns the interpretation of digital encoding of a number transforming certain bits of it. In the digital world, each integer is expressed in binary, which is a binary digit 0s and 1s. Inverting a bit means being there are 0 on both sides, while changing the approaches used trying to turn a 0 into a 1, or a 1 into a 0. The problem is to infer the initial number when a particular number of these bit flips are performed.

Suppose you are given three numbers X, Y, and Z, which are asserted to be created, by flipping K unique bits, of an unidentified original number. One is to solve the riddle and find out what that initial number was. This is achieved through C++ programming - a robust and widely-used language for such computational challenges.

The steps include bitwise operations, which enable manipulation of single bits present in the binary form of the number. The algorithm verifies the flipped bits positions in the binary form of two given numbers. From considering the relationships between these numbers, the common patterns of the flipped positions can be determined, and then the original number can be rebuilt.

This problem is significant not only as a computational puzzle. It is of practical value for subjects as diverse as computer science and cryptography, where understanding and moulding binary representations is fundamental. The solution entails a systematic approach of logical thinking and using the concepts of a program that would help in crossing through the binary territory.

Program:

#include <iostream>
#include <unordered_set>
// Helper function to find the flipped positions between
// two numbers
std::unordered_set<int> helper(int X, int Y) {
    std::unordered_set<int> flippedPositions;
    int ans = X ^ Y;
    // Find the positions where bits are flipped
    for (int i = 0; i < 32; i++) {
        if (ans & (1 << i)) {
            flippedPositions.insert(i);
        }
    }
    return flippedPositions;
}
int findOriginalNumber(int X, int Y, int Z, int K) {
    // Use helper function to find the flipped positions
    // in the binary representation of x and y
    std::unordered_set<int> A = helper(X, Y);
    // Use helper function to find the flipped positions
    // in the binary representation of x and z
    std::unordered_set<int> B = helper(X, Z);
    // Find the common flipped positions in both sets
    std::unordered_set<int> commonPositions;
    for (int position : A) {
        if (B.count(position)) {
            commonPositions.insert(position);
        }
    }
    // Flip the bits at the common positions to
    // reconstruct the original number
    for (int p : commonPositions) {
        int t = 1 << p;
        X = X ^ t;
    }
    return X;
}
int main() {
    std::cout << findOriginalNumber(9, 17, 29, 1) << std::endl;
    return 0;
}

Output:

Explanation:

Helper Function:

The helper function has X and Y, two integers, as its input arguments. It seeks to locate the indexes where the inversion of bits is done between the binary representations of X and Y. It employs bitwise XOR (^) to determine a number (ans) whose ones (set bits) form the coordinates of the positions where bits corresponding to X and Y are different.

For each bit that is set (1) in ans, the function goes through the 32-bit ans and, for each it adds the position to the set (flippedPositions).

findOriginalNumber Function:

The function findOriginalNumber receives, as parameters, three integers values (X, Y, and Z) and an integer value K. It employs the helper function that determines the positions in which bits are inverted between X and Y (set A) and between X and Z (set B). It enumerates the shared placements, where bits are flipped in sets A and B, and saves them in a set (commonPositions).

The function then loops through the common positions and switches the respective bits in the original number X using bitwise XOR. The output is the final value of X.

Main Function:

Within the main function, the function findOriginalNumber is invoked, and the arguments are 9, 17, 29, and I. The output is printed to the console.

Output:

The given code when executed prints the result of the findOriginalNumber function with the associated arguments (9, 17, 29, 1) to the console.

Overall, the code is aimed at the finding of the original number (X) given three numbers (X, Y, and Z), where each of X, Y, and Z is finding X, Y, and Z obtained by flipping K unique bits in the of the original number. Using the helper function to determine the positions where the bits are inverted and utilizing the findOriginalNumber function to restore the original number based on these positions.

Complexity Analysis:

The given code has a time complexity and space complexity that is proportional to the binary size of the numbers.

Time Complexity:

Bit Flipping (helper function):

The helperfunction uses bitwise XOR Operation used to operates on the bit-levels of X and Y, which allows finding the locations where bits differ. The loop goes through each bit (32 bits in number) making the time complexity O(32) = or simpler, O(1), since the number of bits processed is invariant. In the case of findOriginalNumber function, common positions are found in sets A and B.

Time complexity being O(32) or O(1) again due to the fixed number of iterations through bits.

Overall Time Complexity:

Taking into consideration each step separately, the overall-time complexity is dominated by the constant number of bits (32). Therefore, the time complexity can be written as O(1).

Space Complexity:

The helper function stores the variables (flippedPositions) as a set where the bits are flipped. The space required for this set is in direct proportion to the number of flip positions, which is at most K, the total number of bits. Hence, the space complexity is O(32) or O(1).

The findOriginalNumbers function utilizes a set (commonPositions) in which it stores the common positions of sets A and B. Also, the memory space required is indirectly proportional to the frequency of occurrence, which again is less than or equal to 32. Thus, the time complexity is O(32) or O(1).

Overall Space Complexity:

The overall space complexity is given by the maximum storage needed by flippedPositions and commonPositions which is O(32) or O(1).

Next Topicfma() Function in C++

← prev next →