Convert to Base -2 - Practice Coding Problems

Convert to Base -2 - Problem

Math Unknown

Given an integer n, return a binary string representing its representation in base -2.

Note: The returned string should not have leading zeros unless the string is "0".

Input & Output

Example 1 — Positive Number

$ Input: n = 2

› Output: "110"

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

Example 2 — Negative Number

$ Input: n = 3

› Output: "111"

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

Example 3 — Edge Case Zero

$ Input: n = 0

› Output: "0"

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

Constraints

0 ≤ n ≤ 10⁹

Visualization

Tap to expand

Understanding the Visualization

Input

Decimal number n = 2

Process

Convert using base -2 arithmetic

Output

Binary string "110"

Key Takeaway

🎯 Key Insight: In base -2, handle negative remainders by adding the base magnitude and adjusting the quotient

Asked in

G Google 15 f Facebook 12

The key insight is handling negative base conversion by adjusting remainders when they become negative. The optimal approach uses iterative division with proper remainder adjustment. Time: O(log n), Space: O(log n)

Common Approaches

Approach	Time	Space	Notes
✓ Division with Remainder Adjustment	O(log n)	O(log n)	Repeatedly divide by -2, adjusting negative remainders
Iterative Conversion	O(log n)	O(log n)	Clean iterative approach with proper negative base handling

Division with Remainder Adjustment — Algorithm Steps

Divide n by -2 to get quotient and remainder
If remainder is negative, add 2 to remainder and add 1 to quotient
Prepend remainder to result string
Continue until quotient becomes 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Divide by -2

Get quotient and remainder

Adjust Remainder

If negative, add 2 and increment quotient

Build Result

Prepend remainder to result string

Code -

solution.c — C

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

char* solution(int n) {
    if (n == 0) {
        char* result = malloc(2);
        strcpy(result, "0");
        return result;
    }
    
    char* result = malloc(100);
    char temp[100];
    int idx = 0;
    
    while (n != 0) {
        int remainder = n % -2;
        n /= -2;
        
        // If remainder is negative, adjust it
        if (remainder < 0) {
            remainder += 2;
            n += 1;
        }
        
        temp[idx++] = '0' + remainder;
    }
    
    // Reverse the string
    for (int i = 0; i < idx; i++) {
        result[i] = temp[idx - 1 - i];
    }
    result[idx] = '\0';
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Each division reduces the number by factor of 2, so log₂(n) iterations

⚡ Linearithmic

Space Complexity

O(log n)

Result string length is proportional to log₂(n)

⚡ Linearithmic Space

12.0K Views

Medium Frequency

~15 min Avg. Time

428 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

Division with Remainder Adjustment — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler