Validate IP Address

class Solution {
public:
    string validIPv4(string ip) {
        ip += '.'; // Ensure each segment is processed
        stringstream stream(ip);
        string segment;
        int segments = 0;
        while (getline(stream, segment, '.')) {
            segments++;
            // Check for valid segment length and content
            if (segment.empty() || segment.size() > 3) return "Neither";
            if (segment[0] == '0' && segment.size() != 1) return "Neither";
            for (char digit : segment) {
                if (!isdigit(digit)) return "Neither";
            }
            if (stoi(segment) > 255) return "Neither"; // Ensure valid range
        }
        return (segments == 4 && stream.eof()) ? "IPv4" : "Neither";
    }
    
    string validIPv6(string ip) {
        ip += ':'; // Ensure each segment is processed
        stringstream stream(ip);
        string segment;
        int segments = 0;
        while (getline(stream, segment, ':')) {
            segments++;
            // Check for valid segment length and content
            if (segment.empty() || segment.size() > 4) return "Neither";
            for (char hex : segment) {
                if (!isxdigit(hex)) return "Neither";
            }
        }
        return (segments == 8 && stream.eof()) ? "IPv6" : "Neither";
    }
    
    string validIPAddress(string ip) {
        return (count(begin(ip), end(ip), '.') == 3)
                   ? validIPv4(ip)
                   : (count(begin(ip), end(ip), ':') == 7 ? validIPv6(ip)
                                                          : "Neither");
    }
};

This C++ solution is designed to validate whether a given string is a valid IPv4 or IPv6 address. It defines a class Solution that contains three member functions: validIPv4, validIPv6, and validIPAddress.

• The validIPv4 function checks whether an IP string follows IPv4 standards:

  • Increments a counter for each segment split by dots.
  • Ensures that each segment is numeric, not prefixed by zeros (unless the segment is '0'), consists of 1 to 3 digits, and each number falls within the 0 to 255 range.
  • A valid IP must contain exactly four segments.

• The validIPv6 function verifies IP strings against IPv6 standards:

  • Increments a counter for each segment split by colons.
  • Ensures each segment is a hexadecimal number and comprises 1 to 4 hexadecimal characters.
  • A valid IPv6 address always consists of exactly eight segments.

• The central validIPAddress function determines the type of IP address by counting the occurrences of '.' and ':'. It calls validIPv4 if it finds three dots (indicative of an IPv4 address) and validIPv6 for seven colons (indicative of IPv6), returning "Neither" if neither condition is met.

This structured approach ensures each function focuses on a single task, maintaining clarity and enhancing maintainability of the code.

class Solution {
    
    public String checkIPv4(String ipAddress) {
        String[] segments = ipAddress.split("\\.", -1);
        for (String part : segments) {
            if (part.length() == 0 || part.length() > 3) return "Neither";
            if (part.charAt(0) == '0' && part.length() != 1) return "Neither";
            for (char c : part.toCharArray()) {
                if (!Character.isDigit(c)) return "Neither";
            }
            if (Integer.parseInt(part) > 255) return "Neither";
        }
        return "IPv4";
    }
    
    public String checkIPv6(String ipAddress) {
        String[] segments = ipAddress.split(":", -1);
        String validHex = "0123456789abcdefABCDEF";
        for (String part : segments) {
            if (part.length() == 0 || part.length() > 4) return "Neither";
            for (Character c : part.toCharArray()) {
                if (validHex.indexOf(c) == -1) return "Neither";
            }
        }
        return "IPv6";
    }
    
    public String ipValidator(String IP) {
        if (IP.chars().filter(ch -> ch == '.').count() == 3) {
            return checkIPv4(IP);
        } else if (IP.chars().filter(ch -> ch == ':').count() == 7) {
            return checkIPv6(IP);
        } else return "Neither";
    }
}

The Java program provided is designed to validate IP addresses and determine whether they are IPv4 or IPv6 format, or neither. Below is a summary of how the code functions:

• The ipValidator method is the main entry point for checking the type of an IP address. It counts the specific characters ('.' for IPv4 and ':' for IPv6) to decide the likely format of the IP, then delegates to specific methods for further validation.

• For IPv4:

  • The checkIPv4 method is called if the input string has exactly three dots. It splits the IP string into segments using a period as the delimiter.
  • It validates each segment of the IP address based on several criteria:
    • Length of the segment should be between 1 and 3 characters.
    • Segments should not start with '0' unless the segment itself is '0'.
    • Each character must be a digit.
    • The numeric value of each segment must not exceed 255.
  • If any condition is violated, the method returns "Neither". If all are satisfied, it returns "IPv4".

• For IPv6:

  • The checkIPv6 method is called if the input string contains exactly seven colons. It splits the IP string into segments using a colon as the delimiter.
  • Each segment is validated by:
    • Ensuring the segment length is between 1 and 4 characters.
    • Checking each character is a valid hexadecimal digit (0-9, a-f, or A-F).
  • If any segment fails the validation, "Neither" is returned. If all segments are valid, it returns "IPv6".

• If the initial character checks do not match either IP formats, "Neither" is returned immediately.

Through these methods, the program effectively enforces the structural and value rules of IPv4 and IPv6 addresses, ensuring accurate validation. This comprehensive system for checking IP addresses adds robustness to applications needing to distinguish between IP formats or validate user input.

class Validator:
    def checkIPv4(self, IP):
        parts = IP.split(".")
        for part in parts:
            if len(part) == 0 or len(part) > 3:
                return "Neither"
            if part[0] == "0" and len(part) != 1:
                return "Neither"
            if not part.isdigit():
                return "Neither"
            if int(part) > 255:
                return "Neither"
        return "IPv4"
    
    def checkIPv6(self, IP):
        parts = IP.split(":")
        valid_hex = "0123456789abcdefABCDEF"
        for part in parts:
            if len(part) == 0 or len(part) > 4:
                return "Neither"
            for char in part:
                if char not in valid_hex:
                    return "Neither"
        return "IPv6"
    
    def validateIP(self, IP):
        if IP.count(".") == 3:
            return self.checkIPv4(IP)
        elif IP.count(":") == 7:
            return self.checkIPv6(IP)
        else:
            return "Neither"

The given Python script features a class Validator that provides functionality to validate IP addresses for either IPv4 or IPv6 formats. Here's a concise breakdown of its capabilities:

• IPv4 Validation: The checkIPv4 method verifies if a string adheres to the IPv4 format standards:

  • Splits the IP string by periods; if not split into exactly four parts, it's invalid.
  • Checks each segment to ensure it is:
    • Not an empty string
    • Between 1 and 3 characters in length
    • Not leading with a zero (unless the segment itself is '0')
    • Fully numeric
    • Within the range of 0 to 255

  The method returns "IPv4" if all conditions are satisfied; otherwise, it returns "Neither".

• IPv6 Validation: The checkIPv6 method checks for IPv6 format compliance:

  • Divides the IP string using colons; must perfectly divide into eight parts.
  • Validates that every segment:
    • Contains between 1 to 4 hexadecimal characters (0-9, a-f, A-F)

  This method returns "IPv6" if all segments meet the criteria, otherwise "Neither".

• General IP Validation: The validateIP method decides whether to test for IPv4 or IPv6 based on the presence and count of dots or colons:

  • If the IP contains exactly three dots, it tests for IPv4.
  • If the IP contains exactly seven colons, it tests for IPv6.
  • For any other format, it directly returns "Neither".

This structure neatly encapsulates the process of IP format validation, providing a clear and efficient means of determining the correct IP version or if an address is formatted improperly.