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>

static char results[10000][100];
static int resultCount = 0;

static char validNumbers[1000][50];
static int validCount = 0;

bool isValidInteger(const char* s, int len) {
    if (len == 0) return false;
    if (len == 1) return true;
    return s[0] != '0';
}

bool isValidDecimal(const char* left, int leftLen, const char* right, int rightLen) {
    if (leftLen == 0 || rightLen == 0) return false;
    
    if (leftLen > 1 && left[0] == '0') return false;
    
    if (right[rightLen - 1] == '0') return false;
    
    return true;
}

void getValidNumbers(const char* s, int len) {
    validCount = 0;
    
    if (len == 0) return;
    
    if (isValidInteger(s, len)) {
        strncpy(validNumbers[validCount], s, len);
        validNumbers[validCount][len] = '\0';
        validCount++;
    }
    
    for (int i = 1; i < len; i++) {
        if (isValidDecimal(s, i, s + i, len - i)) {
            strncpy(validNumbers[validCount], s, i);
            validNumbers[validCount][i] = '.';
            strncpy(validNumbers[validCount] + i + 1, s + i, len - i);
            validNumbers[validCount][len + 1] = '\0';
            validCount++;
        }
    }
}

int compareStrings(const void* a, const void* b) {
    return strcmp((const char*)a, (const char*)b);
}

void ambiguousCoordinates(const char* s) {
    int len = strlen(s);
    char cleaned[100];
    strncpy(cleaned, s + 1, len - 2);
    cleaned[len - 2] = '\0';
    
    int n = strlen(cleaned);
    resultCount = 0;
    
    for (int i = 1; i < n; i++) {
        char left[50], right[50];
        strncpy(left, cleaned, i);
        left[i] = '\0';
        strncpy(right, cleaned + i, n - i);
        right[n - i] = '\0';
        
        getValidNumbers(left, strlen(left));
        char leftNums[1000][50];
        int leftCount = validCount;
        for (int j = 0; j < validCount; j++) {
            strcpy(leftNums[j], validNumbers[j]);
        }
        
        getValidNumbers(right, strlen(right));
        char rightNums[1000][50];
        int rightCount = validCount;
        for (int j = 0; j < validCount; j++) {
            strcpy(rightNums[j], validNumbers[j]);
        }
        
        for (int l = 0; l < leftCount; l++) {
            for (int r = 0; r < rightCount; r++) {
                sprintf(results[resultCount], "(%s, %s)", leftNums[l], rightNums[r]);
                resultCount++;
            }
        }
    }
    
    qsort(results, resultCount, sizeof(results[0]), compareStrings);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int len = strlen(line);
    if (line[len - 1] == '\n') {
        line[len - 1] = '\0';
        len--;
    }
    
    ambiguousCoordinates(line);
    
    printf("[");
    for (int i = 0; i < resultCount; i++) {
        printf("\"%s\"", results[i]);
        if (i < resultCount - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic 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