# Restore IP Addresses Leetcode Solution

#### ByBrokenprogrammers

Dec 15, 2022

In this post, you will know how to solve the Restore IP Addresses Leetcode Solution problem of Leetcode. This Leetcode problem is done in many programming languages like C++, Java, and Python.

One more thing to add, don’t directly look for the solutions, first try to solve the problems of Leetcode by yourself. If you find any difficulty after trying several times, then you can look for solutions.

## Problem

valid IP address consists of exactly four integers separated by single dots. Each integer is between `0` and `255` (inclusive) and cannot have leading zeros.

• For example, `"0.1.2.201"` and `"192.168.1.1"` are valid IP addresses, but `"0.011.255.245"``"192.168.1.312"` and `"[email protected]"` are invalid IP addresses.

Given a string `s` containing only digits, return all possible valid IP addresses that can be formed by inserting dots into `s`. You are not allowed to reorder or remove any digits in `s`. You may return the valid IP addresses in any order.

Example 1:

```Input: s = "25525511135"
Output: ["255.255.11.135","255.255.111.35"]
```

Example 2:

```Input: s = "0000"
Output: ["0.0.0.0"]
```

Example 3:

```Input: s = "101023"
Output: ["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]
```

Constraints:

• `1 <= s.length <= 20`
• `s` consists of digits only.

### Restore IP AddressesLeetcode Solutions in Python

```class Solution:
def restoreIpAddresses(self, s: str) -> List[str]:
ans = []
def dfs(start: int, path: List[int]) -> None:
if len(path) == 4 and start == len(s):
ans.append(path[0] + '.' + path[1] + '.' + path[2] + '.' + path[3])
return
if len(path) == 4 or start == len(s):
return
for length in range(1, 4):
if start + length > len(s):
return  # Out of bound
if length > 1 and s[start] == '0':
num = s[start: start + length]
if int(num) > 255:
return
dfs(start + length, path + [num])
dfs(0, [])
return ans
```

### Restore IP Addresses Leetcode Solutions in CPP

```class Solution {
public:
vector<string> ans;
dfs(s, 0, {}, ans);
return ans;
}
private:
void dfs(const string& s, int start, vector<string>&& path,
vector<string>& ans) {
if (path.size() == 4 && start == s.length()) {
ans.push_back(path[0] + "." + path[1] + "." + path[2] + "." + path[3]);
return;
}
if (path.size() == 4 || start == s.length())
return;
for (int length = 1; length <= 3; ++length) {
if (start + length > s.length())
return;  // Out of bound
if (length > 1 && s[start] == '0')
const string& num = s.substr(start, length);
if (stoi(num) > 255)
return;
path.push_back(num);
dfs(s, start + length, move(path), ans);
path.pop_back();
}
}
};
```

### Restore IP Addresses Leetcode Solutions in Java

```class Solution {
public List<String> restoreIpAddresses(final String s) {
List<String> ans = new ArrayList<>();
dfs(s, 0, new ArrayList<>(), ans);
return ans;
}
private void dfs(final String s, int start, List<String> path, List<String> ans) {
if (path.size() == 4 && start == s.length()) {
return;
}
if (path.size() == 4 || start == s.length())
return;
for (int length = 1; length <= 3; ++length) {
if (start + length > s.length()) // Out of bound
return;
if (length > 1 && s.charAt(start) == '0') // Leading '0'
return;
final String num = s.substring(start, start + length);
if (Integer.parseInt(num) > 255)
return;
dfs(s, start + length, path, ans);
path.remove(path.size() - 1);
}
}
}
```

Note: This problem Restore IP Addresses is generated by Leetcode but the solution is provided by BrokenProgrammers. This tutorial is only for Educational and Learning purposes.