Lo strumento di scansione della rete è fastidiosamente complicato per l'input e si blocca immediatamente se gli dai un indirizzo IPv4 che contiene caratteri non corretti o non è formattato correttamente.

Un indirizzo IPv4 è un indirizzo numerico a 32 bit scritto come quattro numeri separati da punti. Ogni numero può essere compreso tra zero e 255 .

Dobbiamo scrivere uno strumento per pre-validare l'input per evitare quegli arresti anomali, e il nostro strumento specifico è esigente: un formato valido apparirà come a.b.c.ddove a, b, c e d:

• Può essere un 0numero naturale o senza zeri iniziali .
• Dovrebbe essere compreso tra 0 e 255 (incluso).
• Dovrebbe non contenere simboli speciali come +, -, ,, e altri.
• Dovrebbe essere decimale (base 10)

Input : una stringa

Output : valore Verità o Falsey (sono accettati anche valori arbitrari)

Casi di prova :

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)

Questo è code-golf , quindi vinceranno meno byte!

Nota per gli utenti : se desideri aggiungere altri casi di test, sei il benvenuto (suggerendo una modifica). Ma, per favore, assicurati che i casi di test non si ripetano! Grazie

Codice macchina X86_64: 18 16 byte

Modifica: questa risposta non funziona del tutto, come

1. Sto usando inet_ptondalle librerie C standard, il che significa che ho bisogno di extern. Tuttavia non ho incluso l'esterno nel mio conteggio byte.
2. Ho usato la zona rossa come risultato per l'indirizzo reale, ma ho chiamato una funzione che avrebbe potuto usare anche la zona rossa. Fortunatamente non funziona sulla mia macchina, ma una strana build di libreria standard potrebbe usarla che potrebbe causare un comportamento indefinito.

E sì, il tutto è praticamente fatto da una funzione già scritta

Comunque, questo è quello che ho ottenuto: 48 89 fe 6a 02 5f 48 8d 54 24 80 e9 00 00 00 00

Montaggio:

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

Spiegazione:

Dai un'occhiata inet_pton(3). Prende un indirizzo IP stringa e lo inserisce in un buffer con cui è possibile utilizzarlo struct sockaddr. Sono necessari 3 argomenti: la famiglia di indirizzi ( AF_INET(ipv4), 2 o AF_INET6(ipv6), 10), la stringa dell'indirizzo IP e un puntatore all'output. Restituisce 1 in caso di successo, 0 per un indirizzo non valido o -1 per quando la famiglia di indirizzi non è né AF_INETo AF_INET6(che non si verificherà mai perché gli sto passando una costante).

Quindi sposto semplicemente la stringa nel registro per il secondo argomento, imposto il primo registro su 2 e imposto il terzo registro sulla zona rossa (128 byte sotto il puntatore dello stack) poiché non mi interessa il risultato. Quindi posso semplicemente jmpfarlo inet_ptone lasciare che ritorni direttamente al chiamante!

Ho sviluppato questo rapido programma di test per testare i tuoi casi:

#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;
}

Assembla nasm -felf64 assembly.asm, compila con gcc -no-pie test.c assembly.oe otterrai:

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

Potrei renderlo molto più piccolo se il chiamante dovesse passare AF_INETo AF_INET6alla funzione

Java (JDK) , 63 byte

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

Provalo online!

Crediti

• -1 byte grazie a Kevin Cruijssen
• l4m2 per mostrare il caso precedentemente fallito .1.1.1.1.

JavaScript (Node.js) , 43 byte

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

Provalo online!

JavaScript (Node.js) , 46 byte

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

Provalo online!

usato la parte di Arnauld

JavaScript (Node.js) , 54 53 51 byte

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

Provalo online!

-2B per 0+t<256, -1B da Patrick Stephansen, + 1B per evitare input1.1.1.1e-80

Soluzione RegExp 58 54 byte

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

Grazie a Deadcode per 3 byte

PHP , 39 36 byte

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

Provalo online!

275 ricorda la costante FILTER_VALIDATE_IP

5 ** 9 viene utilizzato al posto della costante FILTER_FLAG_IPV4. Questo è sufficiente, perché 5**9 & FILTER_FLAG_IPV4è vero, che è esattamente ciò che fa PHP in background, come ha sottolineato Benoit Esnard.

Qui, filter_varrestituisce il primo argomento, se è un indirizzo IPv4 valido, o falso in caso contrario. Con +!!, produciamo l'output richiesto dalla sfida.

PHP, 36 byte

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

ip2longè una nota funzione integrata .

Perl 6 , 22 21 20 byte

-1 byte grazie a Phil H.

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

Provalo online!

Spiegazione

{                  }  # 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 byte

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

-1 byte grazie a @Emigna .
+1 byte per il bug test che 1.1.1.1E1restituisce erroneamente un risultato veritiero.

Provalo online o verifica tutti i casi di test .

Spiegazione:

'.¡              '# 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 byte

-8 byte, grazie @AdmBorkBork

-2 byte, trueo falseconsentito dall'autore

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

Script di prova:

$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"
}

Produzione:

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

Spiegazione:

Lo script tenta di analizzare una stringa di argomenti, per costruire un oggetto .NET, IPAddress .

• restituisce $truese objectcreato e la stringa dell'argomento è uguale a una rappresentazione di stringa dell'indirizzo object(indirizzo normalizzato di object.toString())
• ritorno $falsealtrimenti

PowerShell, 59 56 54 byte, alternativa "non usare una libreria .NET"

-3 byte trueo falseconsentito dall'autore

-2 byte, grazie a @ Deadcode per il fantastico regexp.

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

Provalo online!

Grazie @ Olivier Grégoire per l'espressione regolare originale.

C (gcc) / POSIX, 26 byte

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

Provalo online!

Funziona come codice a 64 bit su TIO ma probabilmente lo richiede sizeof(int) == sizeof(char*)su altre piattaforme.

PHP 7+, 37 35 32 byte

Questo utilizza la funzione integrata filter_varper confermare che si tratta di un indirizzo IPv4 .

Perché funzioni, è necessario passare la chiave isu una richiesta GET.

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

Non genererà nulla (per un falsyrisultato) o IP (per un truthyrisultato), a seconda del risultato.

Puoi provare questo su: http://sandbox.onlinephpfunctions.com/code/639c22281ea3ba753cf7431281486d8e6e66f68e http://sandbox.onlinephpfunctions.com/code/ff6aaeb2b2d0e0ac43f48125de0549320bc071b4

Questo utilizza direttamente i seguenti valori:

• 275 = FILTER_VALIDATE_IP
• 1 << 20 = 1048576 = FILTER_FLAG_IPV4
• 5 ** 9 = 1953125 (che ha il bit richiesto come "1", per 1048576)

Grazie a Benoit Esnard per questo suggerimento che mi ha salvato 1 byte!

Grazie a Titus per avermi ricordato le modifiche alla sfida.

Ho esaminato l'utilizzo della funzione ip2long, ma funziona con indirizzi IP non completi.

Gli indirizzi IPv4 non completi sono considerati non validi in questa sfida.

Se fossero autorizzati, questo sarebbe il codice finale (solo per PHP 5.2.10):

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

Attualmente, non è esplicito nella documentazione che questo smetterà di funzionare (quando viene passato un IP incompleto) con le nuove versioni di PHP.

Dopo i test, ha confermato che era così.

Grazie a nwellnhof per l'informazione!

Python 3: 81 78 70 69 66 byte

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

Scorri tutti i possibili indirizzi IPv4, ottieni la rappresentazione della stringa e confrontala con l'input. Ci vuole un po 'di tempo per correre.

EDIT: rimossi 3 byte passando dal programma completo alla funzione anonima.

EDIT2: rimossi 8 byte con l'aiuto di xnor

EDIT3: rimosso 1 byte utilizzando una mappa decompressa anziché la comprensione dell'elenco

EDIT4: rimossi 3 byte utilizzando la comprensione dell'elenco anziché il ipaddressmodulo

C # (compilatore interattivo Visual C #) , 84 79 65 byte

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

Provalo online!

-5 e -14 byte salvati grazie a @dana!

# C # (compilatore interattivo Visual C #) , 61 byte

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

Provalo online!

Si tratta di un lavoro in corso. Il codice usa System.Net(+17 byte se lo conti). se ti chiedi perché conto e analizzo:

La limitazione con il metodo IPAddress.TryParse è che verifica se una stringa può essere convertita in indirizzo IP, quindi se viene fornita con un valore di stringa come "5", la considera come "0.0.0.5".

fonte

Come ha detto @milk nel commento, in effetti fallirà sugli zero iniziali. Quindi, i 61 byte uno non funziona.

Python 2 , 85 82 81 byte

-1 byte grazie a Kevin Cruijssen

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

Provalo online!

La risposta a 113 byte viene eliminata perché non riesce1.1.1.1e-80

Japt, 17 15 byte

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

Provalo o esegui tutti i casi di test o verifica altri casi di test dai commenti della sfida

Spiegazione

Ci dividiamo in un array acceso ., controlliamo che la lunghezza di quell'array sia uguale a 4AND che la lunghezza quando tutti gli elementi dell'intervallo ["0","255"]vengono rimossi da esso è false ( 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 byte

Versione originale:

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

Versione modificata (grazie a Misha Lavrov)

 AtomQ@*Interpreter["IPAddress"]

che restituisce Truese l'input è un indirizzo IP valido ( provalo ).

Nel caso in cui insisti per ottenere 1e 0invece, sarebbero necessari ulteriori 7 byte:

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

JavaScript (ES6), 49 byte

Restituisce un valore booleano.

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

Provalo online!

Python 2, 93 89 67 53 byte

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

Provalo online!

Grazie a Dennis per aver rasato altri 14 byte sui confronti interni e sul codice di uscita.

Un ringraziamento speciale a Jonathan Allan per la rasatura di 22 byte e una correzione logica! Prova fastidiosa / tranne begone!

Prendendo stringhe correttamente formattate anziché byte non elaborati, si rade 4 byte, grazie Jo King.

sfk , 176 byte

* era originariamente Bash + SFK ma da allora TIO ha aggiunto un wrapper SFK appropriato

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

Provalo online!

Python3 Bash * 60

* Anche altre conchiglie. Qualcuno per cui il test di verità / falsità passa un codice di uscita del programma

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

Spiegazione

Il problema con soluzioni Python pure è che un crash del programma è considerato indeterminato. Potremmo usare un "sacco" di codice per convertire un'eccezione in un valore di verità / verità corretto. Tuttavia, a un certo punto l'interprete Python gestisce questa eccezione non rilevata e restituisce un codice di uscita diverso da zero. Per il basso costo del cambio delle lingue nella tua shell Unix preferita, possiamo risparmiare un bel po 'di codice!

Certo, questo è vulnerabile agli attacchi di iniezione ... Gli input come 1.1.1.1'); print('Doing Something Eviluna minaccia non criticata!

ECMAScript regex puro, 41 byte

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

Provalo online!
Provalo su regex101

Penso che la logica in questa regex parli da sola, quindi mi limiterò a stampare piuttosto ma non commentarla:

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

Questo può essere usato per eliminare 2 byte dalle seguenti altre risposte:

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

Ecco una versione alternativa che consente zeri iniziali, ma lo fa in modo coerente (gli ottetti possono essere rappresentati da un massimo di 3 cifre decimali):

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

O consenti un numero qualsiasi di zeri iniziali:

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

Rosso , 106 byte

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]

Provalo online!

Returnd trueofalse

Spiegazione:

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 byte

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

Esegui ed esegui il debug

Disimballato, non golfato e commentato, sembra così.

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?

Esegui questo

Python 3, 109 93 byte

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

Spiegazione

Ogni ottetto può essere compreso tra 0 e 255:

• inizia con 25 e con 0-5 come ultima cifra
• inizia con 2, ha 0-4 come seconda cifra e qualsiasi cifra alla fine
• inizia con 1 e 00 - 99 come cifre di riposo
• ha solo 2 cifre - 1-9 è la prima e qualsiasi cifra successiva
• o solo una singola cifra

Un ottetto può terminare con un (.) O semplicemente terminare, a condizione che non sia in grado di fare entrambe le cose, lo sguardo negativo (?!$)si occupa di questo caso

Grazie @Zachary per avermi fatto capire che posso scartare gli spazi (dato che si tratta di codice golf)
Grazie @DLosc per i miglioramenti e per avermi fatto capire il mio errore, ora è stato corretto.

Bash , 30 byte

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

Provalo online!

Carbone , 45 21 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Modifica: salvato 24 byte eseguendo il porting della risposta Japt di Shaggy. Spiegazione:

    θ                   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 byte

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

La risposta Java di Port of @ OlivierGrégoire , quindi assicurati di votarlo!
-2 byte grazie a @Neil .

Provalo online .

Spiegazione:

^
.                           # 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

Gelatina , 11 byte

⁹ḶṾ€ṗ4j€”.ċ

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

$16$⁴$256$⁹

Come?

⁹ḶṾ€ṗ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 byte

~(K`

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

Provalo online! Basato su una versione precedente della risposta Perl 6 di @ nwellnhof, ma 1 byte salvato rubando il \.?\btrucco dalla risposta di @ Deadcode. Spiegazione:

K`

Cancella l'area di lavoro.

255*

Inserisci 255 caratteri.

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

Genera l'intervallo 0..255 separato da |s, con prefisso ^((e suffisso )\.?\b){4}$, creando così l'espressione regolare ^((0|1|...255)\.?\b){4}$.

~(

Valutalo sull'input originale.

Pip , 25 16 byte

a~=X,256RL4J"\."

Prende l'indirizzo IP candidato come argomento della riga di comando. Provalo online! oppure Verifica tutti i casi di test

Spiegazione

Soluzione Regex, essenzialmente una porta di risposta Stax ricorsiva .

                  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 byte

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

Provalo online!

Creare RegExpgruppi di acquisizione da indici di un array con length 256intervallo 0-255unito a |e seguito da .caratteri di escape ( ^(0|1...|255)\.(0|1...|255)\.(0|1...|255)\.(0|1...|255)$) ripetuti 3volte chiudendo con array unito seguito da $per far corrispondere la fine della stringa, il ritorno trueo il falserisultato dell'input passato a RegExp.prototype.test().