Ambiguous Coordinates

Ambiguous Coordinates - Problem

We had some 2-dimensional coordinates, like (1, 3) or (2, 0.5). Then, we removed all commas, decimal points, and spaces and ended up with the string s.

For example, (1, 3) becomes s = "(13)" and (2, 0.5) becomes s = "(205)".

Return a list of strings representing all possibilities for what our original coordinates could have been.

Our original representation never had extraneous zeroes, so we never started with numbers like "00", "0.0", "0.00", "1.0", "001", "00.01", or any other number that can be represented with fewer digits. Also, a decimal point within a number never occurs without at least one digit occurring before it, so we never started with numbers like ".1".

The final answer list can be returned in any order. All coordinates in the final answer have exactly one space between them (occurring after the comma).

Input & Output

Example 1 — Basic Case

$ Input: s = "(123)"

› Output: ["(1, 23)", "(12, 3)", "(1.2, 3)", "(1, 2.3)"]

💡 Note: Split "123" at positions 1 and 2. For split "1|23": (1, 23) and (1, 2.3). For split "12|3": (12, 3) and (1.2, 3). All combinations are valid.

Example 2 — Leading Zero Constraint

$ Input: s = "(00011)"

› Output: ["(0.001, 1)", "(0, 0.011)"]

💡 Note: Split positions create parts with leading zeros. "0001" cannot be "0001" or "000.1" (invalid), but "0.001" is valid. "1" is valid, "0011" becomes "0.011".

Example 3 — Trailing Zero Constraint

$ Input: s = "(0123)"

› Output: ["(0, 123)", "(0, 12.3)", "(0, 1.23)", "(0.1, 23)", "(0.1, 2.3)", "(0.12, 3)"]

💡 Note: "0" by itself is valid. "123" can be "123", "12.3", "1.23". "01" becomes "0.1" (since "01" has leading zero). "23" can be "23" or "2.3".

Constraints

4 ≤ s.length ≤ 12
s[0] == '(' and s[s.length - 1] == ')'
The rest of s are digits

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is to systematically split the string and validate number formats. Numbers cannot have leading zeros (except single '0'), cannot end with '0' after decimal, and must have digits before decimal point. Best approach uses enumeration to generate all valid combinations. Time: O(n³), Space: O(n)

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Backtracking with Pruning

⏱️ Time: O(n³) Space: O(n)

Use backtracking to generate coordinate combinations by first splitting the string, then recursively trying decimal placements. Prune invalid branches early to avoid unnecessary computation.

Brute Force Enumeration

⏱️ Time: O(n³) Space: O(n)

Generate all possible ways to split the string into two parts, then for each part generate all valid decimal number representations. Combine valid pairs into coordinate format.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int start, end;
} Interval;

int compareIntervals(const void* a, const void* b) {
    return ((Interval*)a)->start - ((Interval*)b)->start;
}

int* solution(int** paint, int paintSize, int* returnSize) {
    Interval intervals[1000];
    int intervalCount = 0;
    int* worklog = (int*)malloc(paintSize * sizeof(int));
    *returnSize = paintSize;
    
    for (int i = 0; i < paintSize; i++) {
        int start = paint[i][0];
        int end = paint[i][1];
        int newArea = end - start;
        
        for (int j = 0; j < intervalCount; j++) {
            if (intervals[j].end <= start || intervals[j].start >= end) {
                continue;
            }
            
            int overlapStart = (start > intervals[j].start) ? start : intervals[j].start;
            int overlapEnd = (end < intervals[j].end) ? end : intervals[j].end;
            newArea -= (overlapEnd - overlapStart);
        }
        
        intervals[intervalCount].start = start;
        intervals[intervalCount].end = end;
        intervalCount++;
        
        qsort(intervals, intervalCount, sizeof(Interval), compareIntervals);
        
        int mergedCount = 0;
        for (int j = 0; j < intervalCount; j++) {
            if (mergedCount == 0 || intervals[j].start > intervals[mergedCount-1].end) {
                intervals[mergedCount] = intervals[j];
                mergedCount++;
            } else {
                if (intervals[j].end > intervals[mergedCount-1].end) {
                    intervals[mergedCount-1].end = intervals[j].end;
                }
            }
        }
        intervalCount = mergedCount;
        
        worklog[i] = newArea;
    }
    
    return worklog;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int** paint = (int**)malloc(1000 * sizeof(int*));
    int paintSize = 0;
    
    char* ptr = line;
    while (*ptr) {
        if (*ptr == '[' && *(ptr+1) != ']') {
            ptr++;
            while (*ptr == ' ' || *ptr == '[') ptr++;
            
            if (*ptr == '-' || (*ptr >= '0' && *ptr <= '9')) {
                paint[paintSize] = (int*)malloc(2 * sizeof(int));
                
                char* endPtr;
                paint[paintSize][0] = strtol(ptr, &endPtr, 10);
                ptr = endPtr;
                
                while (*ptr == ' ' || *ptr == ',') ptr++;
                
                paint[paintSize][1] = strtol(ptr, &endPtr, 10);
                ptr = endPtr;
                
                paintSize++;
            }
        } else {
            ptr++;
        }
    }
    
    int returnSize;
    int* result = solution(paint, paintSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

32.0K Views

Medium Frequency

~25 min Avg. Time

890 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