Defanging an IP Address - Practice Coding Problems

Defanging an IP Address - Problem

String Easy

Given a valid IPv4 IP address, you need to "defang" it for security purposes. In web security, displaying IP addresses directly can be a vulnerability, so we often need to make them safe for display.

A defanged IP address replaces every period "." with "[.]" to prevent it from being interpreted as a clickable link or executable code.

Example: The IP address "192.168.1.1" becomes "192[.]168[.]1[.]1"

Goal: Transform the input IP address string by replacing all dots with [.] and return the defanged version.

Input & Output

example_1.py — Basic IP Address

$ Input: address = "1.1.1.1"

› Output: "1[.]1[.]1[.]1"

💡 Note: Each dot in the IP address is replaced with [.] to create the defanged version

example_2.py — Standard IP Address

$ Input: address = "255.100.50.0"

› Output: "255[.]100[.]50[.]0"

💡 Note: All three dots are replaced with [.], keeping all numeric parts unchanged

example_3.py — Common Private IP

$ Input: address = "192.168.1.1"

› Output: "192[.]168[.]1[.]1"

💡 Note: This common private network IP address gets defanged by replacing all dots with [.]

Constraints

The given address is a valid IPv4 address
IPv4 addresses consist of 4 integers separated by dots
Each integer is between 0 and 255 inclusive
The input will always be a valid IP address format

Visualization

Tap to expand

Understanding the Visualization

Identify Dots

Scan through the IP address to find all dot characters

Replace Safely

Replace each dot with [.] to neutralize its network meaning

Preserve Numbers

Keep all numeric parts exactly the same

Return Safe String

The result is a defanged IP that won't be interpreted as a network address

Key Takeaway

🎯 Key Insight: String replacement is about pattern matching and substitution - identify the target pattern (dots) and replace with the safe pattern ([.])

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Meta 5

The optimal solution uses simple string iteration or built-in string replacement methods. Most languages provide efficient replace() functions that can solve this in one line: address.replace('.', '[.]'). The manual approach involves iterating through each character once, replacing dots with [.] and copying other characters as-is, achieving O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Character-by-Character Construction	O(n)	O(n)	Manually iterate through each character and build result string

Character-by-Character Construction — Algorithm Steps

Initialize an empty result string
Loop through each character in the input string
If character is '.', append '[.]' to result
Otherwise, append the character as-is
Return the constructed result string

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Processing

Begin with empty result string

Check Each Character

If '.', append '[.]', otherwise append character

Build Result

Continue until all characters processed

Return Result

Final defanged IP address

Code -

solution.c — C

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

char* defangIPaddr(char* address) {
    int len = strlen(address);
    char* result = (char*)malloc((len * 3 + 1) * sizeof(char));
    int j = 0;
    
    for (int i = 0; i < len; i++) {
        if (address[i] == '.') {
            result[j++] = '[';
            result[j++] = '.';
            result[j++] = ']';
        } else {
            result[j++] = address[i];
        }
    }
    result[j] = '\0';
    return result;
}

int main() {
    char address[100];
    fgets(address, sizeof(address), stdin);
    // Remove newline and quotes
    address[strcspn(address, "\n")] = 0;
    if (address[0] == '"') {
        memmove(address, address+1, strlen(address));
        address[strlen(address)-1] = '\0';
    }
    
    char* result = defangIPaddr(address);
    printf("\"%s\"", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each character exactly once, where n is the length of the input string

✓ Linear Growth

Space Complexity

O(n)

We create a new string that's slightly longer than the input (each '.' becomes '[.]')

⚡ Linearithmic Space

67.0K Views

High Frequency

~5 min Avg. Time

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

Character-by-Character Construction — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler