Su herramienta de escaneo de red es irritantemente exigente con la entrada, e inmediatamente se bloquea si la alimenta con una dirección IPv4 que contiene caracteres incorrectos o no está formateada correctamente.

Una dirección IPv4 es una dirección numérica de 32 bits escrita como cuatro números separados por puntos. Cada número puede ser de cero a 255 .

Necesitamos escribir una herramienta para validar previamente la entrada para evitar esos bloqueos, y nuestra herramienta específica es exigente: se verá un formato válidoa.b.c.d donde a, b, c y d:

• Puede ser un 0número natural o sin ceros a la izquierda .
• Debe estar entre 0 y 255 (inclusive).
• En caso de no incluir los símbolos especiales como +, -, ,, y otros.
• Debe ser decimal (base 10)

Entrada : una cadena

Salida : valor de Verdad o Falsey (también se aceptan valores arbitrarios)

Casos de prueba :

Input            |  Output  |  Reason
                 |          |
- 1.160.10.240   |  true    |
- 192.001.32.47  |  false   |  (leading zeros present)
- 1.2.3.         |  false   |  (only three digits)
- 1.2.3          |  false   |  (only three digits)
- 0.00.10.255    |  false   |  (leading zeros present)
- 1.2.$.4        |  false   |  (only three digits and a special symbol present)
- 255.160.0.34   |  true    |
- .1.1.1         |  false   |  (only three digits)
- 1..1.1.1       |  false   |  (more than three periods)
- 1.1.1.-0       |  false   |  (special symbol present)
- .1.1.+1        |  false   |  (special symbol present)
- 1 1 1 1        |  false   |  (no periods)
- 1              |  false   |  (only one digit)
- 10.300.4.0     |  false   |  (value over 255)
- 10.4F.10.99    |  false   |  (invalid characters)
- fruit loops    |  false   |  (umm...)
- 1.2.3.4.5      |  false   |  (too many periods/numbers)
- 0.0.0.0        |  true    |
- 0.0 0.0.       |  false   |  (periods misplaced)
- 1.23..4        |  false   |  (a typo of 1.2.3.4)
- 1:1:1:1:1:1:1:1|  false   |  (an IPv6 address, not IPv4)

Este es el código de golf , ¡por lo que ganarán menos bytes!

Nota para los usuarios : si desea agregar más casos de prueba, será bienvenido (sugiriendo una edición). Pero, ¡asegúrese de que los casos de prueba no se repitan! Gracias

Código máquina X86_64: 18 años 16 bytes

Editar: esta respuesta no funciona, ya que

1. Estoy usando inet_ptonde las bibliotecas C estándar, lo que significa que necesito el externo. Sin embargo, no incluí el externo en mi recuento de bytes.
2. Utilicé la zona roja como resultado de la dirección real, pero llamé a una función que también podría haber utilizado la zona roja. Afortunadamente no funciona en mi máquina, pero algunas compilaciones de biblioteca estándar extrañas podrían usarlo, lo que podría causar un comportamiento indefinido.

Y sí, todo se está haciendo prácticamente por una función ya escrita

De todos modos, esto es lo que obtuve: 48 89 fe 6a 02 5f 48 8d 54 24 80 e9 00 00 00 00

Montaje:

section .text
    extern inet_pton
    global ipIsValid

ipIsValid:
    mov rsi, rdi
    ;mov rdi, 2 ; change to 10 for ipv6
    push 2
    pop rdi ; thank you peter
    lea rdx, [rsp - 128]
    jmp inet_pton

Explicación:

Echa un vistazo a inet_pton(3). Toma una dirección IP de cadena y la coloca en un búfer con el que puede usar struct sockaddr. Toma 3 argumentos: la familia de direcciones ( AF_INET(ipv4), 2 o AF_INET6(ipv6), 10), la cadena de la dirección ip y un puntero a la salida. Devuelve 1 en caso de éxito, 0 para una dirección no válida o -1 para cuando la familia de direcciones es ninguno AF_INETo AF_INET6(lo que nunca ocurrirá porque le estoy pasando una constante).

Entonces, simplemente muevo la cadena al registro para el segundo argumento, establezco el primer registro en 2 y establezco el tercer registro en la zona roja (128 bytes debajo del puntero de la pila) ya que no me importa el resultado. Entonces puede simplemente jmpa inet_ptony dejar que el regreso directamente a la persona que llama!

Hice girar este programa de prueba rápida para probar sus casos:

#include <stdio.h>
#include <arpa/inet.h>
#include <netinet/ip.h>

extern int ipIsValid(char *);

int main(){
    char *addresses[] = {
        "1.160.10.240",
        "192.001.32.47",
        "1.2.3.",
        "1.2.3",
        "0.00.10.255",
        "1.2.$.4",
        "255.160.0.34",
        ".1.1.1",
        "1..1.1.1",
        "1.1.1.-0",
        ".1.1.+1",
        "1 1 1 1",
        "1",
        "10.300.4.0",
        "10.4F.10.99",
        "fruit loops",
        "1.2.3.4.5",
        NULL
    };

    for(size_t i = 0; addresses[i] != NULL; ++i){
        printf("Address %s:\t%s\n", addresses[i],
            ipIsValid(addresses[i]) ? "true" : "false");
    }
    return 0;
}

Ensambla nasm -felf64 assembly.asm, compila gcc -no-pie test.c assembly.oy obtendrás:

Address 1.160.10.240:   true
Address 192.001.32.47:  false
Address 1.2.3.: false
Address 1.2.3:  false
Address 0.00.10.255:    false
Address 1.2.$.4:    false
Address 255.160.0.34:   true
Address .1.1.1: false
Address 1..1.1.1:   false
Address 1.1.1.-0:   false
Address .1.1.+1:    false
Address 1 1 1 1:    false
Address 1:  false
Address 10.300.4.0: false
Address 10.4F.10.99:    false
Address fruit loops:    false
Address 1.2.3.4.5:  false

Podría hacer esto mucho más pequeño si se supone que la persona que llama debe pasar AF_INETo AF_INET6a la función

Java (JDK) , 63 bytes

s->("."+s).matches("(\\.(25[0-5]|(2[0-4]|1\\d|[1-9])?\\d)){4}")

Pruébalo en línea!

Créditos

• -1 byte gracias a Kevin Cruijssen
• l4m2 para mostrar el caso que fallaba anteriormente .1.1.1.1.

JavaScript (Node.js) , 43 bytes

x=>x.split`.`.map(t=>[t&255]==t&&[])==`,,,`

Pruébalo en línea!

JavaScript (Node.js) , 46 bytes

x=>x.split`.`.every(t=>k--&&[t&255]==t,k=4)*!k

Pruébalo en línea!

utiliza la parte de Arnauld

JavaScript (Node.js) , 54 53 51 bytes

x=>x.split`.`.every(t=>k--*0+t<256&[~~t]==t,k=4)*!k

Pruébalo en línea!

-2B para 0+t<256, -1B de Patrick Stephansen, + 1B para evitar la entrada1.1.1.1e-80

Solución RegExp 58 54 bytes

s=>/^((2(?!5?[6-9])|1|(?!0\d))\d\d?\.?\b){4}$/.test(s)

Gracias Deadcode por 3 bytes

PHP , 39 36 bytes

<?=+!!filter_var($argv[1],275,5**9);

Pruébalo en línea!

275 se asemeja a la constante FILTER_VALIDATE_IP

Se está usando 5 ** 9 en lugar de la constante FILTER_FLAG_IPV4. Esto es suficiente, porque 5**9 & FILTER_FLAG_IPV4es verdad, que es exactamente lo que PHP hace en segundo plano, como señaló Benoit Esnard.

Aquí, filter_vardevuelve el primer argumento, si es una dirección IPv4 válida, o falso si no lo es. Con +!!, producimos la salida requerida por el desafío.

PHP, 36 bytes

echo(ip2long($argv[1])===false?0:1);

ip2longes una conocida función incorporada .

Perl 6 , 22 21 20 bytes

-1 byte gracias a Phil H.

{?/^@(^256)**4%\.$/}

Pruébalo en línea!

Explicación

{                  }  # Anonymous Block
  /               /   # Regex match
   ^             $    # Anchor to start/end
    @(    )           # Interpolate
      ^256            #   range 0..255,
                      #   effectively like (0|1|2|...|255)
           **4        # Repeated four times
              %\.     # Separated by dot
 ?                    # Convert match result to Bool

05AB1E , 26 24 23 22 23 bytes

'.¡©g4Q₅Ý®å`®1šDïþJsJQP

-1 byte gracias a @Emigna .
+1 byte para el caso de prueba de corrección de errores que 1.1.1.1E1devuelve incorrectamente un resultado verdadero.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

'.¡              '# Split the (implicit) input by "."
   ©              # Save it in the register (without popping)
    g4Q           # Check that there are exactly 4 numbers
    ₅Ý®å          # Check for each of the numbers that they are in the range [0,255],
        `         # and push the result for each number separated onto the stack
    ®1šDïþJsJQ    # Check that each number does NOT start with a "0" (excluding 0s itself),
                  # and that they consist of digits only
              P   # Check if all values on the stack are truthy (and output implicitly)

PowerShell, 59 51 49 bytes

-8 bytes, gracias @AdmBorkBork

-2 bytes, trueo falsepermitido por el autor

try{"$args"-eq[IPAddress]::Parse($args)}catch{!1}

Script de prueba:

$f = {

try{"$args"-eq[IPAddress]::Parse($args)}catch{!1}

}

@(
    ,("1.160.10.240" , $true)
    ,("192.001.32.47" , $false)
    ,("1.2.3." , $false)
    ,("1.2.3" , $false)
    ,("0.00.10.255" , $false)
    ,("192.168.1.1" , $true)
    ,("1.2.$.4" , $false)
    ,("255.160.0.34" , $true)
    ,(".1.1.1" , $false)
    ,("1..1.1.1" , $false)
    ,("1.1.1.-0" , $false)
    ,("1.1.1.+1" , $false)
    ,("1 1 1 1" , $false)
    ,("1"            ,$false)
    ,("10.300.4.0"   ,$false)
    ,("10.4F.10.99"  ,$false)
    ,("fruit loops"  ,$false)
    ,("1.2.3.4.5"    ,$false)

) | % {
    $s,$expected = $_
    $result = &$f $s
    "$($result-eq$expected): $result : $s"
}

Salida:

True: True : 1.160.10.240
True: False : 192.001.32.47
True: False : 1.2.3.
True: False : 1.2.3
True: False : 0.00.10.255
True: True : 192.168.1.1
True: False : 1.2.$.4
True: True : 255.160.0.34
True: False : .1.1.1
True: False : 1..1.1.1
True: False : 1.1.1.-0
True: False : 1.1.1.+1
True: False : 1 1 1 1
True: False : 1
True: False : 10.300.4.0
True: False : 10.4F.10.99
True: False : fruit loops
True: False : 1.2.3.4.5

Explicación:

El script intenta analizar una cadena de argumento para construir un objeto .NET, IPAddress .

• devolver $truesi se objectcreó y la cadena de argumento es igual a una representación de cadena de object(dirección normalizada por object.toString())
• volver de lo $falsecontrario

PowerShell, 59 56 54 bytes, alternativa 'no use una lib .NET'

-3 bytes, trueo falsepermitido por el autor

-2 bytes, gracias a @ Deadcode por la genial expresión regular .

".$args"-match'^(\.(2(?!5?[6-9])|1|(?!0\B))\d\d?){4}$'

Pruébalo en línea!

Gracias @ Olivier Grégoire por la expresión regular original.

C (gcc) / POSIX, 26 bytes

f(s){s=inet_pton(2,s,&s);}

Pruébalo en línea!

Funciona como código de 64 bits en TIO, pero probablemente lo requiera sizeof(int) == sizeof(char*)en otras plataformas.

PHP 7+, 37 35 32 bytes

Esto utiliza la función incorporada filter_var, para validar que es una dirección IPv4 .

Para que funcione, debe pasar la clave isobre una solicitud GET.

<?=filter_var($_GET[i],275,5**9);

No generará nada (para un falsyresultado) o la IP (para un truthyresultado), dependiendo del resultado.

Puedes probar esto en: http://sandbox.onlinephpfunctions.com/code/639c22281ea3ba753cf7431281486d8e6e66f68e http://sandbox.onlinephpfunctions.com/code/ff6aaeb2b2d0e0ac43f48125de0549320bc071b4

Esto usa los siguientes valores directamente:

• 275 = FILTER_VALIDATE_IP
• 1 << 20 = 1048576 = FILTER_FLAG_IPV4
• 5 ** 9 = 1953125 (que tiene el bit requerido como "1", para 1048576)

¡Gracias a Benoit Esnard por este consejo que me salvó 1 byte!

Gracias a Titus por recordarme los cambios al desafío.

He ip2longinvestigado el uso de la función , pero funciona con direcciones IP no completas.

Las direcciones IPv4 no completas se consideran inválidas en este desafío.

Si se les permitiera, este sería el código final (solo para PHP 5.2.10):

<?=ip2long($_GET[i]);

Actualmente, no está explícito en la documentación que esto dejará de funcionar (cuando se pasa una IP incompleta) con las nuevas versiones de PHP.

Después de la prueba, confirmó que ese era el caso.

Gracias a nwellnhof por la informacion!

Python 3: 81 78 70 69 66 bytes

['%d.%d.%d.%d'%(*x.to_bytes(4,'big'),)for x in range(16**8)].count

Recorra todas las direcciones IPv4 posibles, obtenga la representación de cadena y compárela con la entrada. Es ... lleva un tiempo correr.

EDITAR: Se eliminaron 3 bytes al cambiar del programa completo a la función anónima.

EDIT2: eliminado 8 bytes con ayuda de xnor

EDITAR3: se eliminó 1 byte usando un mapa desempaquetado en lugar de la comprensión de la lista

EDIT4: se eliminaron 3 bytes mediante el uso de la comprensión de la lista en lugar del ipaddressmódulo

C # (compilador interactivo de Visual C #) , 84 79 65 bytes

s=>s.Split('.').Sum(t=>byte.TryParse(t,out var b)&t==b+""?1:5)==4

Pruébalo en línea!

-5 y -14 bytes guardados gracias a @dana!

# C # (compilador interactivo de Visual C #) , 61 bytes

s=>s.Count(c=>c==46)==3&IPAddress.TryParse(s,out IPAddress i)

Pruébalo en línea!

Este es un trabajo en progreso. El uso del código System.Net(+17 bytes si lo cuenta). si te preguntas por qué cuento y analizo:

La limitación con el método IPAddress. TryParse es que verifica si una cadena se puede convertir a una dirección IP, por lo tanto, si se le proporciona un valor de cadena como "5", lo considera como "0.0.0.5".

fuente

Como @milk dijo en un comentario, fallará en ceros a la izquierda. Entonces, el de 61 bytes no está funcionando.

Python 2 , 85 82 81 bytes

-1 byte gracias a Kevin Cruijssen

from ipaddress import*
I=input()
try:r=I==str(IPv4Address(I))
except:r=0
print~~r

Pruébalo en línea!

La respuesta de 113 bytes se elimina porque falla1.1.1.1e-80

Japt, 17 15 bytes

q.
ʶ4«Uk#ÿòs)Ê

Pruébelo o ejecute todos los casos de prueba o verifique casos de prueba adicionales a partir de comentarios de desafío

Explicación

Nos dividimos en una matriz activada ., verificamos que la longitud de esa matriz sea igual a 4AND y que la longitud cuando ["0","255"]se eliminan todos los elementos del rango sea ​​falsey ( 0).

                 :Implicit input of string U
q.               :Split on "."
\n               :Reassign resulting array to U
Ê                :Length of U
 ¶4              :Equals 4?
   «             :&&!
    Uk           :Remove from U
      #ÿ         :  255
        ò        :  Range [0,255]
         s       :  Convert each to a string
          )      :End removal
           Ê     :Length of resulting array

Mathematica, 39 31 bytes

Versión original:

¬FailureQ[Interpreter["IPAddress"][#]]&

Versión modificada (gracias a Misha Lavrov)

 AtomQ@*Interpreter["IPAddress"]

que vuelve Truesi la entrada es una dirección IP válida ( pruébelo ).

En caso de que insista en obtener 1y 0, en cambio, serían necesarios 7 bytes adicionales:

Boole/@AtomQ@*Interpreter["IPAddress"]

JavaScript (ES6), 49 bytes

Devuelve un valor booleano.

s=>[0,1,2,3].map(i=>s.split`.`[i]&255).join`.`==s

Pruébalo en línea!

Python 2, 93 89 67 53 bytes

[i==`int(i)&255`for i in input().split('.')]!=[1]*4>_

Pruébalo en línea!

Gracias a Dennis por reducir otros 14 bytes en las comparaciones internas y el código de salida.

¡Un agradecimiento especial a Jonathan Allan por reducir 22 bytes y una solución lógica! Intento molesto / excepto desaparecido!

Tomar cadenas formateadas correctamente en lugar de bytes sin formato elimina 4 bytes, gracias Jo King.

sfk , 176 bytes

* originalmente era Bash + SFK, pero desde entonces TIO ha agregado un envoltorio SFK adecuado

xex -i "_[lstart][1.3 digits].[1.3 digits].[1.3 digits].[1.3 digits][lend]_[part2]\n[part4]\n[part6]\n[part8]_" +xed _[lstart]0[digit]_999_ +hex +linelen +filt -+1 -+2 +linelen

Pruébalo en línea!

Python3 Bash * 60

* También otras conchas. Cualquiera para el que la prueba de verdad / falsedad pase un código de salida del programa

read I
python3 -c "from ipaddress import*;IPv4Address('$I')"

Explicación

El problema con las soluciones puras de Python es que el bloqueo de un programa se considera indeterminado. Podríamos usar un "lote" de código para convertir una excepción en un valor verdadero / rápido apropiado. Sin embargo, en algún momento el intérprete de Python maneja esta excepción no detectada y devuelve un código de salida distinto de cero. ¡Por el bajo costo de cambiar los idiomas a su shell de Unix favorito, podemos ahorrar bastante código!

Por supuesto, esto es vulnerable a los ataques de inyección ... ¡Entradas como 1.1.1.1'); print('Doing Something Eviluna amenaza no mitigada!

ECMAScript regex puro, 41 bytes

^((2(?!5?[6-9])|1|(?!0\B))\d\d?\.?\b){4}$

Pruébalo en línea!
Pruébalo en regex101

Creo que la lógica en esta expresión regular habla por sí misma, por lo que simplemente imprimiré bonito pero no lo comentaré:

^
(
    (
        2(?!5?[6-9])
    |
        1
    |
        (?!0\B)
    )
    \d\d?
    \.?\b
){4}
$

Esto se puede usar para eliminar 2 bytes de las siguientes otras respuestas:

• Olivier Grégoire (Java (JDK))
• l4m2 (JavaScript (Node.js))
• mazzy (PowerShell)
• Kevin Cruijssen (Retina)

Aquí hay una versión alternativa que permite los ceros a la izquierda, pero lo hace de manera consistente (los octetos pueden estar representados por un máximo de 3 dígitos decimales):

^((2(?!5?[6-9])|1|0?)\d\d?\.?\b){4}$

O permita cualquier número de ceros a la izquierda:

^(0*(2(?!5?[6-9])|1?)\d\d?\.?\b){4}$

Rojo , 106 bytes

func[s][if error? try[t: load s][return off]if 4 <> length? t[return off]s =
form as-ipv4 t/1 t/2 t/3 t/4]

Pruébalo en línea!

Devolver trueofalse

Explicación:

f: func [ s ] [
    if error? try [                  ; checks if the execution of the next block result in an error
        t: load s                    ; loading a string separated by '.' gives a tuple   
    ] [                              ; each part of which must be in the range 0..255
        return off                   ; if there's an error, return 'false' 
    ]
    if 4 <> length? t [              ; if the tuple doesn't have exactly 4 parts
        return off                   ; return 'false'  
    ]
    s = form as-ipv4 t/1 t/2 t/3 t/4 ; is the input equal to its parts converted to an IP adress
]

Stax , 14 bytes

∞n·Θ3ª&JH‼∙*~Γ

Ejecutar y depurarlo

Desempaquetado, sin golf y comentado, se ve así.

VB      constant 256
r       [0 .. 255]
'|*     coerce and string-join with "|"; i.e. "0|1|2|3 ... 254|255"
:{      parenthesize to "(0|1|2|3 ... 254|255)"
]4*     make 4-length array of number pattern
.\.*    string join with "\\."; this forms the complete regex
|Q      is the input a complete match for the regex?

Ejecute este

Python 3, 109 93 bytes

import re
lambda x:bool(re.match(r'^((25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(\.(?!$)|$)){4}$',x))

Explicación

Cada octeto puede ser 0-255:

• comienza con 25 y tiene 0-5 como último dígito
• comienza con 2, tiene 0-4 como segundo dígito y cualquier dígito al final
• comienza con 1 y 00-99 como dígitos de descanso
• tiene solo 2 dígitos: 1-9 es el primero y cualquier dígito posterior
• o solo un dígito

Un octeto puede terminar con un (.) O simplemente terminar, con la condición de que no pueda hacer las dos cosas, la anticipación negativa (?!$)se ocupa de este caso

Gracias @Zachary por hacerme darme cuenta de que puedo descartar espacios (ya que es un código de golf)
Gracias @DLosc por las mejoras y hacerme dar cuenta de mi error, ya se ha corregido.

Bash , 30 bytes

ipcalc -c `cat`;echo $(($?^1))

Pruébalo en línea!

Carbón , 45 21 bytes

Ｉ∧⁼№θ.³¬Φ⪪θ.¬№Ｅ²⁵⁶Ｉλι

Pruébalo en línea! El enlace es a la versión detallada del código. Editar: Guardado 24 bytes al portar la respuesta de @ Shaggy's Japt. Explicación:

    θ                   Input string
   №                    Count occurrences of
     .                  Literal `.`
  ⁼                     Equal to
      ³                 Literal 3
 ∧                      Logical And
       ¬                Logical Not
          θ             Input string
         ⪪              Split on
           .            Literal `.`
        Φ               Filter by
            ¬           Logical Not
               ²⁵⁶      Literal 256
              Ｅ         Map over implicit range
                   λ    Map value
                  Ｉ     Cast to string
             №          Count occurrences of
                    ι   Filter value
Ｉ                       Cast to string
                        Implicitly print

Retina , 46 44 bytes

^
.
^(\.(25[0-5]|(2[0-4]|1\d|[1-9])?\d)){4}$

Puerto de la respuesta Java de @ OlivierGrégoire , ¡así que asegúrese de votarlo!
-2 bytes gracias a @Neil .

Pruébalo en línea .

Explicación:

^
.                           # Prepend a dot "." before the (implicit) input
^...$                       # Check if the entire string matches the following regex
                            # exactly, resulting in 1/0 as truthy/falsey:
 (                          #  Open a capture group
  \.                        #   A dot "."
    (25[0-5]                #   Followed by a number in the range [250,255]
    |(2[0-4]|         ) \d) #   or by a number in the range [200,249]
    |(      |1\d|     ) \d) #   or by a number in the range [100,199]
    |(          |[1-9]) \d) #   or by a number in the range [10,99]
    |(                )?\d) #   or by a number in the range [0,9]
 )                          #  Close capture group
  {4}                       #  This capture group should match 4 times after each other

Jalea , 11 bytes

⁹ḶṾ€ṗ4j€”.ċ

$1$$0$$256^4=4294967296$

$16$⁴$256$⁹

¿Cómo?

⁹ḶṾ€ṗ4j€”.ċ - Link: list of characters, S
⁹           - literal 256
 Ḷ          - lowered range = [0,1,2,...,254,255]
  Ṿ€        - unevaluate €ach = ['0','1',...,['2','5','4'],['2','5','5']]
    ṗ4      - 4th Cartesian power = ALL 256^4 lists of 4 of them
            -               (e.g.: ['0',['2','5','5'],'9',['1','0']])
        ”.  - literal '.' character
      j€    - join for €ach (e.g. ['0','.','2','5','5','.','9','.','1','0'] = "0.255.9.10")
          ċ - count occurrences of right (S) in left (that big list)

Retina , 42 41 bytes

~(K`

255*
["^(("|'|]")\.?\b){4}$"L$`
$.`

Pruébalo en línea! Basado en una versión anterior de la respuesta de Perl 6 de @nwellnhof, pero se guardó 1 byte al robar el \.?\btruco de la respuesta de @ Deadcode. Explicación:

K`

Despeje el área de trabajo.

255*

Insertar 255 caracteres.

["^(("|'|]")\.?\b){4}$"L$`
$.`

Genere el rango 0..255 separado con |s, con el prefijo ^((y con el sufijo )\.?\b){4}$, construyendo así la expresión regular ^((0|1|...255)\.?\b){4}$.

~(

Evalúe eso en la entrada original.

Pip , 25 16 bytes

a~=X,256RL4J"\."

Toma la dirección IP candidata como argumento de línea de comando. Pruébalo en línea! o Verificar todos los casos de prueba

Explicación

Solución Regex, esencialmente un puerto de respuesta Stax recursiva .

                  a is 1st cmdline arg (implicit)
    ,256          Range(256), i.e. [0 1 2 ... 255]
   X              To regex: creates a regex that matches any item from that list
                  i.e. essentially `(0|1|2|...|255)`
        RL4       Create a list with 4 copies of that regex
           J"\."  Join on this string
 ~=               Regex full-match
a                 against the input

JavaScript, 89 bytes

(_,r=`(${[...Array(256).keys()].join`|`})`)=>RegExp(`^${(r+'\\.').repeat(3)+r}$`).test(_)

Pruébalo en línea!

Cree RegExpgrupos de captura a partir de índices de una matriz que tiene length 256un rango 0-255unido con |y seguido de un .carácter escapado ( ^(0|1...|255)\.(0|1...|255)\.(0|1...|255)\.(0|1...|255)$) repetidas 3veces cerrando con una matriz unida seguido de $para coincidir con el final de la cadena, el retorno trueo el falseresultado de la entrada pasada RegExp.prototype.test().