Restore IP Addresses - Practice Coding Problems

Restore IP Addresses - Problem

String Backtracking Medium

Restore IP Addresses is a classic string manipulation and backtracking problem that challenges you to reconstruct valid IP addresses from a string of digits.

Given a string s containing only digits, your task is to find all possible valid IP addresses that can be formed by inserting exactly three dots into the string. You cannot reorder or remove any digits - only insert dots at valid positions.

A valid IP address consists of exactly four integers separated by single dots, where each integer:
• Is between 0 and 255 (inclusive)
• Cannot have leading zeros (except for '0' itself)

Examples:
✅ Valid: "0.1.2.201", "192.168.1.1"
❌ Invalid: "0.011.255.245" (leading zero), "192.168.1.312" (> 255)

This problem tests your understanding of string validation, backtracking algorithms, and constraint satisfaction.

Input & Output

example_1.py — Basic Case

$ Input: "25525511135"

› Output: ["255.255.11.135", "255.255.111.35"]

💡 Note: The string can be split into two valid IP addresses. Both combinations satisfy the constraints: no leading zeros and all segments ≤ 255.

example_2.py — Minimum Length

$ Input: "0000"

› Output: ["0.0.0.0"]

💡 Note: Only one valid IP address can be formed. Each segment is "0" which is valid (no leading zero rule applies to single '0').

example_3.py — No Valid IPs

$ Input: "101023"

› Output: ["1.0.10.23", "1.0.102.3", "10.1.0.23", "10.10.2.3", "101.0.2.3"]

💡 Note: Multiple valid combinations exist. Each segment is between 0-255 with no leading zeros.

Constraints

1 ≤ s.length ≤ 20
s consists of digits only
Each IP segment must be between 0 and 255 (inclusive)
No leading zeros allowed (except for segment "0")

Visualization

Tap to expand

Understanding the Visualization

Analyze the Problem

You have a string of digits and need to place exactly 3 dots to create 4 segments, each representing a valid IP octet (0-255, no leading zeros).

Start Backtracking

Begin at the first position and try creating segments of length 1, 2, or 3. For each valid segment, recursively solve for the remaining part.

Apply Early Pruning

Before exploring further, check if the remaining characters can possibly form the required number of segments. If not, backtrack immediately.

Validate and Collect

When exactly 4 segments are formed and the entire string is consumed, validate the complete IP address and add it to results.

Key Takeaway

🎯 Key Insight: Backtracking with early pruning transforms a potentially exponential search into a constant-time algorithm by eliminating invalid paths before exploring them fully. The constraint that IP addresses have exactly 4 segments, each with at most 3 digits, creates a naturally bounded search space.

Asked in

G Google 42 a Amazon 38 f Meta 35 ⊞ Microsoft 28 Apple 22

The optimal solution uses backtracking with early pruning. By recursively trying each possible segment length (1-3 digits) and pruning impossible paths early, we achieve constant time complexity due to the bounded search space. The key insight is that early validation and pruning prevent exploring invalid combinations, making this approach much more efficient than brute force enumeration.

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking (Optimal)	O(1)	O(1)	Use backtracking to build IP addresses segment by segment with early pruning
Brute Force (Try All Positions)	O(1)	O(1)	Try all possible positions for the three dots and validate each combination

Backtracking (Optimal) — Algorithm Steps

Start with empty result and first position
Try segments of length 1, 2, and 3 at current position
For each valid segment, recursively build remaining parts
Prune early if remaining string can't form valid segments
When 4 segments are formed, add to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Recursion

Begin at position 0, need to form 4 segments

Try Segment Lengths

Try segments of length 1, 2, 3 at current position

Early Pruning

Skip paths where remaining characters can't form valid segments

Backtrack

Remove invalid choices and try next possibility

Code -

solution.c — C

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

bool isValid(char* segment) {
    int len = strlen(segment);
    if (len == 0 || len > 3) return false;
    if (len > 1 && segment[0] == '0') return false;
    int num = atoi(segment);
    return num >= 0 && num <= 255;
}

bool canForm(int remainingChars, int remainingSegments) {
    return remainingSegments <= remainingChars && remainingChars <= remainingSegments * 3;
}

void backtrack(char* s, int start, char path[][4], int pathSize, int segmentsLeft, char** result, int* returnSize) {
    if (segmentsLeft == 0) {
        if (start == strlen(s)) {
            char* ip = (char*)malloc(16 * sizeof(char));
            sprintf(ip, "%s.%s.%s.%s", path[0], path[1], path[2], path[3]);
            result[(*returnSize)++] = ip;
        }
        return;
    }
    
    if (!canForm(strlen(s) - start, segmentsLeft)) {
        return;
    }
    
    for (int length = 1; length <= 3; length++) {
        if (start + length > strlen(s)) break;
        
        char segment[4];
        strncpy(segment, s + start, length);
        segment[length] = '\0';
        
        if (isValid(segment)) {
            strcpy(path[pathSize], segment);
            backtrack(s, start + length, path, pathSize + 1, segmentsLeft - 1, result, returnSize);
        }
    }
}

char** restoreIpAddresses(char* s, int* returnSize) {
    char** result = (char**)malloc(100 * sizeof(char*));
    *returnSize = 0;
    char path[4][4];
    backtrack(s, 0, path, 0, 4, result, returnSize);
    return result;
}

int main() {
    char s[20];
    scanf("%s", s);
    
    if (s[0] == '"') {
        int len = strlen(s);
        memmove(s, s + 1, len - 1);
        s[len - 2] = '\0';
    }
    
    int returnSize;
    char** result = restoreIpAddresses(s, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(",");
        free(result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Maximum 3^4 = 81 combinations to explore due to early pruning and string length constraints

✓ Linear Growth

Space Complexity

O(1)

Recursion depth is at most 4, and result space is bounded by constant maximum valid IPs

✓ Linear Space

87.5K Views

Medium-High Frequency

~18 min Avg. Time

3.2K 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

Backtracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler