从字符串构建IP地址

Question

Write a program that determines where to add periods to a decimal string so that the resulting string is a valid IP address. There may be more than one valid IP address corresponding to a string, in which case you should print all possibilities. For example, "19216811" , two of the nine possible IP addresses include 192.169.1.1 and 19.216.81.1 .

Below is my (incomplete) solution:

def valid_ips(string):
  def is_valid_part(part):
    return len(part) == 1 or (part[0] != 0 and int(part) <= 255)  

  def build_valid_ips(substring):
    result = []
    for i in range(1, min(4, len(substring))):
      part = substring[:i]
      if is_valid_part(part):
        for sub in build_valid_ips(substring[i:]):
          result.append(part + '.' + sub)
    return result

  return build_valid_ips(string)

This is a variant problem in the book I'm working out of, so I don't have a solution to look at. However, I have a couple of questions

• This solution is incorrect, as it always returns an empty list but I'm not sure why. Seems like I'm handling the inductive step and base case just fine. Could someone point me in the right direction?
• How can I do this better? I understand each recursive call generates a new list and multiple new strings which adds a ton of overhead, but how to avoid this?

Answer 1

Your function always returns an empty list because you never append anything to result in the bottom layer of recursion.

In build_valid_ips you only append to result when looping through values obtained from a recursive call to build_valid_ips , but that would only return values obtained by looping through further recursive calls to build_valid_ips . Somewhere the recursion has to stop, but at this level, nothing gets appended. As a result there's nothing to pass back up the recursion.

Try adding the lines

    if is_valid_part(substring):
        result.append(substring)

in build_valid_ips , just after the line result = [] . You should then find that your code then returns a non-empty list.

However, the result is still not correct. Nowhere in your code do you enforce that there must be four parts to an IP address, so the code will generate incorrect output such as 1.9.2.1.6.8.1.1 . I'll leave it up to you to modify your code to fix this.

As for how to improve the code, that's more a question for Code Review . For a small example such as yours, which will never run for very long, I wouldn't be too worried about generating too many lists and strings. Worry about these things only when the performance of your code becomes a problem.

Answer 2

Given that an IP has to contain four different parts, you can use recursion to generate a list of possibilities with groupings:

s = "19216811"
def ips(d, current = []):
  if not d:
     yield current
  else:
     for i in range(1, len(s)):
       yield from ips(d[i:], current + [d[:i]])

final_ips = list(filter(lambda x:all(len(i) > 1 for i in x[:2]), [i for i in ips(s) if len(list(filter(None, i))) == 4]))
new_ips = ['.'.join(a) for i, a in enumerate(final_ips) if a not in final_ips[:i]]

Output:

['19.21.6.811', '19.21.68.11', '19.21.681.1', '19.216.8.11', '19.216.81.1', '19.2168.1.1', '192.16.8.11', '192.16.81.1', '192.168.1.1', '1921.68.1.1']