Jobs

Interviews

Discussions

Encode Number

Medium

Quora

0 views

Topics:

Bit Manipulation

Given a non-negative integer num, represent it as the sum of num = 2ⁱ + 2^j + 2^k + ..., where i >= 0, j >= 0, k >= 0, ... You may choose the bits i, j, k, ... any number of times. Return an array of integers representing these bits.

Example 1:

Input: num = 10
Output: [2,8]
Explanation:
num = 10 = 2 + 8 = 2¹ + 2³

Example 2:

Input: num = 23
Output: [1,2,4,16]
Explanation:
num = 23 = 1 + 2 + 4 + 16 = 2⁰ + 2¹ + 2² + 2⁴

Constraints:

1 <= num <= 10⁵

Try coding it in LeetCode

Encode Number

Medium

Quora

0 views

Topics:

Bit Manipulation

Example 1:

Input: num = 10
Output: [2,8]
Explanation:
num = 10 = 2 + 8 = 2¹ + 2³

Example 2:

Input: num = 23
Output: [1,2,4,16]
Explanation:
num = 23 = 1 + 2 + 4 + 16 = 2⁰ + 2¹ + 2² + 2⁴

Constraints:

1 <= num <= 10⁵

Try coding it in LeetCode

Solution

Clarifying Questions

When you get asked this question in a real-life environment, it will often be ambiguous (especially at FAANG). Make sure to ask these questions in that case:

What is the maximum possible value for the input number?
Should I handle the case where the input number is zero or negative?
Could you clarify what you mean by 'i-th substring'? For example, if the number is 3, what specific substring from '101001000100001...' would that correspond to?
If the number is larger than the total number of substrings within the initial sequence of '101001000100001...', should I extend the binary string S or return an error?
Is there a specific format for the encoded string that I should adhere to?

Brute Force Solution

Approach

The goal is to find the smallest set of special numbers that can add up to a given target number. We can try every possible combination of these special numbers to see if any of them exactly match the target.

Here's how the algorithm would work step-by-step:

Start by considering using only one special number at a time. Check each special number to see if it equals the target number.
Next, try using two special numbers. Consider every possible pair of special numbers and see if they add up to the target number.
If no pair works, move on to trying combinations of three special numbers. Again, check every possible group of three special numbers to see if their sum equals the target number.
Keep increasing the number of special numbers you are combining (four, five, and so on).
For each combination, see if their sum is equal to the target number.
Stop when you find a combination of special numbers that adds up to the target number. If you've tried all combinations up to using every special number and haven't found a match, then it's impossible to create the target number using these special numbers.

Code Implementation

def encode_number_brute_force(special_numbers, target):
    # Iterate through different lengths of combinations
    for combination_length in range(1, len(special_numbers) + 1):
        # Generate all possible combinations of the specified length
        combinations = get_combinations(special_numbers, combination_length)

        # Iterate through each combination to check for a match
        for combination in combinations:
            if sum(combination) == target:
                return combination

    return []

def get_combinations(special_numbers, combination_length):
    combinations_list = []
    get_combinations_recursive(special_numbers, combination_length, 0, [], combinations_list)
    return combinations_list

def get_combinations_recursive(special_numbers, combination_length, start_index, current_combination, combinations_list):
    if combination_length == 0:
        # If combination length is 0, add current comb to list
        combinations_list.append(current_combination[:])
        return

    # Ensure that the index does not go out of bounds.
    for index in range(start_index, len(special_numbers)):
        current_combination.append(special_numbers[index])
        get_combinations_recursive(special_numbers, combination_length - 1, index + 1, current_combination, combinations_list)

        # Backtrack: remove the last element to try other combinations
        current_combination.pop()

Big(O) Analysis

Time Complexity

O(2^n) – The algorithm iterates through all possible combinations of the 'special numbers' to find a subset that sums up to the target. In the worst-case scenario, it has to consider all subsets of the 'special numbers'. If there are 'n' special numbers, there are 2^n possible subsets, as each number can either be included or excluded from a subset. Therefore, the time complexity is exponential, specifically O(2^n), because we potentially examine every possible combination of the n 'special numbers'.

Space Complexity

O(1) – The provided plain English explanation focuses on trying combinations of special numbers. The algorithm checks if combinations of 1, 2, 3, up to all special numbers sum to the target. This process does not inherently require storing all combinations simultaneously. Therefore, only a few variables are used to track the current combination being tested, and potentially a sum of the combination, regardless of how many special numbers exist. The space used is constant and does not depend on the number of special numbers or the target value.

Optimal Solution

Approach

The best way to encode the number is to think of it as a special kind of pattern. We want to find the smallest set of special numbers that add up to the number, using only numbers that are one less than a power of two.

Here's how the algorithm would work step-by-step:

Think about the number as a sum of numbers that look like 1, 3, 7, 15, 31, and so on (one less than a power of two).
Start by finding the biggest number in that special set that is still smaller than or equal to the number we want to encode.
Write down the 'index' of that number in the special set (0 for 1, 1 for 3, 2 for 7, and so on).
Subtract that special number from the original number.
Repeat the process with the leftover number until you reach zero.
The list of 'indexes' you wrote down is the encoded version of the original number.

Code Implementation

def encode(number):
    encoded_list = []
    
    while number > 0:
        power_of_two = 0
        # Find the highest power of two minus 1, less than the number
        while (1 << (power_of_two + 1)) - 1 <= number:
            power_of_two += 1

        encoded_list.append(power_of_two)

        # Subtract the largest possible 'special' number
        number -= (1 << power_of_two) - 1

    return encoded_list

Big(O) Analysis

Time Complexity

O(log n) – The encoding process involves repeatedly finding the largest number of the form 2^k - 1 that is less than or equal to the remaining number. In each iteration, the remaining number is significantly reduced. The number of iterations is determined by how many powers of 2 are needed to represent the number n. This is logarithmic in the input number n, as we are essentially finding the most significant bit of n and successively processing the remaining value after subtracting a number close to a power of 2. Therefore, the time complexity is O(log n).

Space Complexity

O(log N) – The algorithm's space complexity is primarily determined by the number of elements stored in the result (the list of indices). In the worst-case scenario, the input number N might require a decomposition into a sequence of numbers that are one less than a power of two, leading to approximately log2(N) indices being added to the result list. Thus the space scales logarithmically with the input N. Therefore, the auxiliary space used to store the indices is O(log N).

Edge Cases

Case	How to Handle
Input number is zero	Handle zero as a valid input, and return the corresponding substring from the infinite binary string S based on its index.
Input number is negative	Define whether negative numbers are allowed; if not, throw an IllegalArgumentException or return an error string; if allowed, handle negative indices appropriately by perhaps shifting them to a positive range or defining them as invalid.
Input number is one	Input '1' should return the first substring which is '1'.
Large input number exceeding integer limits in substring generation	Use long data types to avoid overflow issues when calculating the length of the substring and its index within the S string.
Memory constraints when generating very long prefixes of S	Generate the required portion of S on demand instead of pre-calculating the entire infinite string, to manage memory efficiently.
No valid solution exists due to Integer.MAX_VALUE limits	If the input number is greater than the largest calculable index given memory/integer limits, define that an error string be returned.
Correctness of substring calculation	Thoroughly test the substring indexing and extraction logic to ensure it consistently returns the i-th substring of S.
Performance bottlenecks when repeatedly calculating substrings	Employ memoization to cache already calculated substrings, avoiding redundant calculations for frequently requested indices.

Solution

Clarifying Questions

When you get asked this question in a real-life environment, it will often be ambiguous (especially at FAANG). Make sure to ask these questions in that case:

What is the maximum possible value for the input number?
Should I handle the case where the input number is zero or negative?
Could you clarify what you mean by 'i-th substring'? For example, if the number is 3, what specific substring from '101001000100001...' would that correspond to?
If the number is larger than the total number of substrings within the initial sequence of '101001000100001...', should I extend the binary string S or return an error?
Is there a specific format for the encoded string that I should adhere to?

Brute Force Solution

Approach

Here's how the algorithm would work step-by-step:

Start by considering using only one special number at a time. Check each special number to see if it equals the target number.
Next, try using two special numbers. Consider every possible pair of special numbers and see if they add up to the target number.
If no pair works, move on to trying combinations of three special numbers. Again, check every possible group of three special numbers to see if their sum equals the target number.
Keep increasing the number of special numbers you are combining (four, five, and so on).
For each combination, see if their sum is equal to the target number.
Stop when you find a combination of special numbers that adds up to the target number. If you've tried all combinations up to using every special number and haven't found a match, then it's impossible to create the target number using these special numbers.

Code Implementation

def encode_number_brute_force(special_numbers, target):
    # Iterate through different lengths of combinations
    for combination_length in range(1, len(special_numbers) + 1):
        # Generate all possible combinations of the specified length
        combinations = get_combinations(special_numbers, combination_length)

        # Iterate through each combination to check for a match
        for combination in combinations:
            if sum(combination) == target:
                return combination

    return []

def get_combinations(special_numbers, combination_length):
    combinations_list = []
    get_combinations_recursive(special_numbers, combination_length, 0, [], combinations_list)
    return combinations_list

def get_combinations_recursive(special_numbers, combination_length, start_index, current_combination, combinations_list):
    if combination_length == 0:
        # If combination length is 0, add current comb to list
        combinations_list.append(current_combination[:])
        return

    # Ensure that the index does not go out of bounds.
    for index in range(start_index, len(special_numbers)):
        current_combination.append(special_numbers[index])
        get_combinations_recursive(special_numbers, combination_length - 1, index + 1, current_combination, combinations_list)

        # Backtrack: remove the last element to try other combinations
        current_combination.pop()

Big(O) Analysis

Time Complexity

Space Complexity

Optimal Solution

Approach

Here's how the algorithm would work step-by-step:

Think about the number as a sum of numbers that look like 1, 3, 7, 15, 31, and so on (one less than a power of two).
Start by finding the biggest number in that special set that is still smaller than or equal to the number we want to encode.
Write down the 'index' of that number in the special set (0 for 1, 1 for 3, 2 for 7, and so on).
Subtract that special number from the original number.
Repeat the process with the leftover number until you reach zero.
The list of 'indexes' you wrote down is the encoded version of the original number.

Code Implementation

def encode(number):
    encoded_list = []
    
    while number > 0:
        power_of_two = 0
        # Find the highest power of two minus 1, less than the number
        while (1 << (power_of_two + 1)) - 1 <= number:
            power_of_two += 1

        encoded_list.append(power_of_two)

        # Subtract the largest possible 'special' number
        number -= (1 << power_of_two) - 1

    return encoded_list

Big(O) Analysis

Time Complexity

Space Complexity

Edge Cases

Case	How to Handle
Input number is zero	Handle zero as a valid input, and return the corresponding substring from the infinite binary string S based on its index.
Input number is negative	Define whether negative numbers are allowed; if not, throw an IllegalArgumentException or return an error string; if allowed, handle negative indices appropriately by perhaps shifting them to a positive range or defining them as invalid.
Input number is one	Input '1' should return the first substring which is '1'.
Large input number exceeding integer limits in substring generation	Use long data types to avoid overflow issues when calculating the length of the substring and its index within the S string.
Memory constraints when generating very long prefixes of S	Generate the required portion of S on demand instead of pre-calculating the entire infinite string, to manage memory efficiently.
No valid solution exists due to Integer.MAX_VALUE limits	If the input number is greater than the largest calculable index given memory/integer limits, define that an error string be returned.
Correctness of substring calculation	Thoroughly test the substring indexing and extraction logic to ensure it consistently returns the i-th substring of S.
Performance bottlenecks when repeatedly calculating substrings	Employ memoization to cache already calculated substrings, avoiding redundant calculations for frequently requested indices.