Convert to Base -2 - Practice Coding Problems

Convert to Base -2 - Problem

Math Unknown

In the fascinating world of number systems, we typically work with positive bases like binary (base 2) or decimal (base 10). But what happens when we venture into negative bases?

Your mission: Given an integer n, convert it to its representation in base -2 and return it as a binary string. In base -2, each position represents a power of -2 instead of 2:

Position 0: (-2)⁰ = 1
Position 1: (-2)¹ = -2
Position 2: (-2)² = 4
Position 3: (-2)³ = -8
And so on...

Important: The result should not have leading zeros unless the answer is exactly "0".

Example: The number 2 in base -2 is "110" because: 1×4 + 1×(-2) + 0×1 = 4 - 2 + 0 = 2

Input & Output

example_1.py — Simple Positive Number

$ Input: n = 2

› Output: "110"

💡 Note: In base -2: 1×(-2)² + 1×(-2)¹ + 0×(-2)⁰ = 1×4 + 1×(-2) + 0×1 = 4 - 2 + 0 = 2

example_2.py — Negative Number

$ Input: n = -3

› Output: "1011"

💡 Note: In base -2: 1×(-2)³ + 0×(-2)² + 1×(-2)¹ + 1×(-2)⁰ = 1×(-8) + 0×4 + 1×(-2) + 1×1 = -8 + 0 - 2 + 1 = -9 + 6 = -3

example_3.py — Edge Case Zero

$ Input: n = 0

› Output: "0"

💡 Note: Zero is represented as "0" in any base system

Constraints

-10⁶ ≤ n ≤ 10⁶
The result should not have leading zeros except when the answer is "0"
Note: Base -2 can represent both positive and negative integers using only digits 0 and 1

Visualization

Tap to expand

Understanding the Visualization

Set up the columns

Each position alternates between positive and negative values

Apply division algorithm

Divide by -2 and handle negative remainders

Build result

Collect digits from right to left to form the final answer

Key Takeaway

🎯 Key Insight: Base -2 conversion requires careful handling of negative remainders by adjusting both the remainder (+2) and quotient (+1) to maintain the binary digit constraint.

Asked in

G Google 25 ⊞ Microsoft 15 a Amazon 12 Apple 8

The optimal approach uses mathematical division by -2 with special remainder handling. When the remainder is negative, we adjust both the remainder and quotient to ensure we only use digits 0 and 1. This gives us O(log n) time complexity and efficiently handles both positive and negative numbers in a single pass.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Division Approach (Optimal)	O(log \|n\|)	O(log \|n\|)	Use division by -2 with proper remainder handling to build the result digit by digit
Brute Force (Trial and Error)	O(2^k)	O(k)	Try all possible binary strings until we find one that evaluates to n in base -2

Mathematical Division Approach (Optimal) — Algorithm Steps

If n is 0, return '0' immediately
Initialize an empty result string
While n is not 0:
- Calculate remainder = n % (-2)
- If remainder is negative, adjust: remainder += 2 and n += 2
- Prepend remainder to result string
- Update n = n / (-2) using integer division
Return the result string

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Setup

Start with n=2, result=""

First Division

2 ÷ (-2) = -1 remainder 0, prepend '0'

Second Division

-1 ÷ (-2) = 0 remainder -1, adjust to remainder 1, quotient 1

Final Division

1 ÷ (-2) = 0 remainder 1, prepend '1'

Code -

solution.c — C

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

char* baseNeg2(int n) {
    if (n == 0) {
        char* result = malloc(2);
        strcpy(result, "0");
        return result;
    }
    
    char temp[33]; // Enough for 32-bit integer
    int pos = 0;
    
    while (n != 0) {
        int remainder = n % (-2);
        n = n / (-2);
        
        // If remainder is negative, adjust
        if (remainder < 0) {
            remainder += 2;
            n += 1;
        }
        
        temp[pos++] = '0' + remainder;
    }
    
    // Reverse the string
    char* result = malloc(pos + 1);
    for (int i = 0; i < pos; i++) {
        result[i] = temp[pos - 1 - i];
    }
    result[pos] = '\0';
    
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%s\n", baseNeg2(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log |n|)

We divide n by -2 repeatedly until it becomes 0. The number of iterations is proportional to the logarithm of the absolute value of n.

⚡ Linearithmic

Space Complexity

O(log |n|)

Space needed to store the result string, which has length proportional to log|n|.

⚡ Linearithmic Space

24.5K Views

Medium Frequency

~15 min Avg. Time

847 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

Constraints

Visualization

Related Problems

Common Approaches

Mathematical Division Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler