Encode Number - Practice Coding Problems

Encode Number - Problem

You've discovered a mysterious encoding system that converts non-negative integers into binary-like strings, but with a twist! Your task is to crack the encoding pattern and implement the secret function.

Given a non-negative integer num, return its encoded string representation. The encoding follows a specific pattern that you need to deduce from the examples:

0 → "" (empty string)
1 → "0"
2 → "1"
3 → "00"
4 → "01"
5 → "10"
6 → "11"

Can you figure out the secret pattern? This encoding is related to a modified binary representation where the structure follows a unique mathematical relationship!

Input & Output

example_1.py — Basic Case

$ Input: num = 3

› Output: "00"

💡 Note: Number 3 is in level 2 of the binary tree structure (range 3-6). Its position within the level is 3-3=0. Converting position 0 to 2-bit binary gives "00".

example_2.py — Mid-range Case

$ Input: num = 6

› Output: "11"

💡 Note: Number 6 is in level 2 (range 3-6). Its position within the level is 6-3=3. Converting position 3 to 2-bit binary gives "11".

example_3.py — Edge Cases

$ Input: num = 0

› Output: ""

💡 Note: The special case: 0 maps to an empty string according to the encoding rules.

Visualization

Tap to expand

Understanding the Visualization

Understand the Structure

Numbers are organized in levels: Level 1 has 2 positions (1,2), Level 2 has 4 positions (3,4,5,6), etc.

Find the Level

Determine which level contains your target number using mathematical formulas

Calculate Position

Find the relative position within that level (0-indexed)

Binary Conversion

Convert the position to binary using the appropriate number of bits for that level

Key Takeaway

🎯 Key Insight: The encoding represents position within binary tree levels. Adding 1 and removing the highest bit directly computes this position!

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Converting to binary representation takes O(log n) time

⚡ Linearithmic

Space Complexity

O(log n)

Space for the result string of length log(n)

⚡ Linearithmic Space

Constraints

0 ≤ num ≤ 10⁹
The output string will have length at most 32 characters
Follow-up: Can you solve this without using logarithmic functions?

Asked in

G Google 35 f Facebook 28 a Amazon 22 ⊞ Microsoft 18

The optimal solution uses bit manipulation to directly compute the encoding. The key insight is that adding 1 to the input number and removing the highest bit gives us the encoded result. This works because the encoding follows a binary tree level structure where each level k contains 2^k numbers, and the encoding represents the position within that level in binary format.

Common Approaches

Approach	Time	Space	Notes
✓ Bit Manipulation (Optimal)	O(log n)	O(log n)	Use bit operations to directly compute the encoding in one mathematical step
Level-by-Level Search	O(log n)	O(log n)	Iterate through each level to find where the number belongs, then convert to binary
Mathematical Level Detection	O(log n)	O(log n)	Use logarithms to directly calculate which level contains the number

Bit Manipulation (Optimal) — Algorithm Steps

Handle special case: if num is 0, return empty string
Calculate n + 1 where n is our input number
Find the position of the highest set bit in (n + 1)
The encoding is the binary representation of n+1 with the highest bit removed
This directly gives us the result without level calculations

Visualization

Tap to expand

Step-by-Step Walkthrough

Add 1

Transform 5 → 6 to align with power-of-2 structure

Binary Representation

6 in binary is '110'

Remove Highest Bit

Remove the leftmost '1' to get '10'

Result

The encoding of 5 is '10'

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

char* encode(int num) {
    if (num == 0) {
        char* result = malloc(1);
        result[0] = '\0';
        return result;
    }
    
    // Add 1 to get the magic number
    int temp = num + 1;
    
    // Find the position of the highest set bit
    int bitLength = 0;
    int tempCopy = temp;
    while (tempCopy > 1) {
        tempCopy >>= 1;
        bitLength++;
    }
    
    // Remove the highest bit
    int resultNum = temp ^ (1 << bitLength);
    
    // Convert to binary
    char* result = malloc(bitLength + 1);
    result[bitLength] = '\0';
    
    for (int i = bitLength - 1; i >= 0; i--) {
        result[bitLength - 1 - i] = (resultNum & (1 << i)) ? '1' : '0';
    }
    return result;
}

int main() {
    int num;
    scanf("%d", &num);
    char* result = encode(num);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Converting to binary representation takes O(log n) time

⚡ Linearithmic

Space Complexity

O(log n)

Space for the result string of length log(n)

⚡ Linearithmic Space

Constraints

0 ≤ num ≤ 10⁹
The output string will have length at most 32 characters
Follow-up: Can you solve this without using logarithmic functions?

28.5K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Bit Manipulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler