static bool IsIPv4Address(string inputString)
{
    var parts = inputString.Split('.');

    foreach (var v in parts)
    {
        if (!long.TryParse(v, out var n) || n > 255 || v == "" || v != n.ToString())
        {
            return false;
        }
    }

    return parts.Length == 4;
}

defmodule IsIpv4Address do
  def is_ipv4_address(input_string) do
    parts = String.split(input_string, ".")

    length(parts) == 4 and Enum.all?(parts, &valid_octet?/1)
  end

  defp valid_octet?(v) do
    case Integer.parse(v) do
      {n, ""} -> n >= 0 and n <= 255 and Integer.to_string(n) == v
      _ -> false
    end
  end
end

-module(is_ipv4_address).
-export([is_ipv4_address/1]).

is_ipv4_address(InputString) ->
    Parts = string:split(InputString, ".", all),
    length(Parts) =:= 4 andalso lists:all(fun valid_octet/1, Parts).

valid_octet(V) ->
    case string:to_integer(V) of
        {Int, ""} when Int >= 0, Int =< 255 ->
            integer_to_list(Int) =:= V;
        _ ->
            false
    end.

func isIPv4Address(inputString string) bool {
	parts := strings.Split(inputString, ".")
	if len(parts) != 4 {
		return false
	}

	for _, part := range parts {
		n, err := strconv.Atoi(part)
		if err != nil || n > 255 || strconv.Itoa(n) != part {
			return false
		}
	}

	return true
}

isIPv4Address :: String -> Bool
isIPv4Address s = length parts == 4 && all valid parts
  where
    parts = splitOn '.' s

    splitOn c str = foldr step [""] str
      where
        step ch acc@(cur : rest)
          | ch == c   = "" : acc
          | otherwise = (ch : cur) : rest

    valid p =
      not (null p)
        && all (`elem` ['0' .. '9']) p
        && case reads p :: [(Int, String)] of
             [(n, "")] -> n <= 255 && show n == p
             _         -> False

public class Solution {
    public static boolean isIPv4Address(String inputString) {
        String[] a = inputString.split("\\.", -1);

        for (String v : a) {
            if (v.isEmpty() || v.length() > 3 || !v.matches("\\d+")) {
                return false;
            }
            int num = Integer.parseInt(v);
            if (num > 255 || !String.valueOf(num).equals(v)) {
                return false;
            }
        }

        return a.length == 4;
    }
}

(defun split-on-char (s ch)
  (loop with start = 0
        for pos = (position ch s :start start)
        collect (subseq s start pos)
        while pos
        do (setf start (1+ pos))))

(defun is-ipv4-address (input-string)
  (let ((parts (split-on-char input-string #\.)))
    (and (= (length parts) 4)
         (every (lambda (v)
                  (and (> (length v) 0)
                       (every #'digit-char-p v)
                       (<= (parse-integer v) 255)
                       (string= v (write-to-string (parse-integer v)))))
                parts))))

function isIPv4Address($inputString)
{
    $a = explode('.', $inputString);
    foreach ($a as $k => $v) {
        if ( ! is_numeric($v) || $v > 255 || $v === '' || $v !== (string)(int)$v) {
            return false;
        }
    }

    return count($a) === 4;
}

def is_ipv4_address(input_string: str) -> bool:
    parts = input_string.split(".")
    if len(parts) != 4:
        return False

    for v in parts:
        try:
            n = int(v)
        except ValueError:
            return False
        if n > 255 or v == "" or v != str(n):
            return False

    return True

fn is_ipv_4_adress(input_string: &str) -> bool {
    let parts: Vec<&str> = input_string.split('.').collect();
    if parts.len() != 4 {
        return false;
    }

    for part in &parts {
        match part.parse::<i64>() {
            Ok(n) => {
                if n > 255 || part.to_string() != n.to_string() {
                    return false;
                }
            }
            Err(_) => return false,
        }
    }

    true
}