Défi

Étant donné un IPv4 addressen notation quadrillée et un IPv4 subneten notation CIDR , déterminez si le addressest dans le subnet. Sortez une valeur distincte et cohérente si elle est dans le subnet, et une valeur distincte distincte et cohérente si elle n'est pas dans le subnet. Les valeurs de sortie ne doivent pas nécessairement être véridiques / falsey dans votre langue.

Brève introduction à la notation du sous-réseau CIDR

Les adresses réseau IPv4 ont une longueur de 32 bits, divisées en quatre groupes de 8 bits pour faciliter la lecture. La notation de sous-réseau CIDR est un masque du nombre spécifié de bits, commençant à l'extrême gauche. Par exemple, pour un /24sous - réseau, cela signifie que les 8 bits les plus à droite de l'adresse sont disponibles dans ce sous-réseau. Ainsi, deux adresses qui sont séparées par au plus 255et qui ont le même masque de sous-réseau se trouvent dans le même sous-réseau. Notez que les CIDR valides ont tous les bits d'hôte (le côté droit) non définis (zéros).

xxxxxxxx xxxxxxxx xxxxxxxx 00000000
^---    subnet mask   ---^ ^-hosts-^

Pour un autre exemple, un /32sous - réseau spécifie que tous les bits sont le masque de sous-réseau, ce qui signifie essentiellement qu'un seul hôte est autorisé par /32.

xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx
^---        subnet mask        ---^

Exemples:

Utiliser Truepour "dans le sous-réseau" et Falsepour "pas dans le sous-réseau" en sortie:

127.0.0.1
127.0.0.0/24
True

127.0.0.55
127.0.0.0/23
True

127.0.1.55
127.0.0.0/23
True

10.4.1.33
10.4.0.0/16
True

255.255.255.255
0.0.0.0/0
True

127.1.2.3
127.0.0.0/24
False

127.1.2.3
127.1.2.1/32
False

10.10.83.255
10.10.84.0/22
False

Règles et clarifications

• Étant donné que l'analyse des entrées n'est pas le point intéressant de ce défi, vous êtes assuré d'obtenir des adresses IPv4 et des masques de sous-réseau valides.
• L'entrée et la sortie peuvent être fournies par n'importe quelle méthode pratique .
• Vous pouvez imprimer le résultat dans STDOUT ou le renvoyer en tant que résultat de fonction. Veuillez indiquer dans votre soumission les valeurs que la sortie peut prendre.
• Un programme complet ou une fonction sont acceptables.
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

Python 3 (62 octets)

Très simple:

from ipaddress import*
lambda i,m:ip_address(i)in ip_network(m)

C # (Visual C # Compiler) , 250 + 31 = 281 octets

(a,b)=>{Func<string,string>h=g=>string.Join("",g.Split('.').Select(x=>{var e=Convert.ToString(int.Parse(x),2);while(e.Length<8)e='0'+e;return e;}));a=h(a);var c=b.Split('/');b=h(c[0]);var d=int.Parse(c[1]);return a.Substring(0,d)==b.Substring(0,d);};

Bytecount comprend using System;using System.Linq;

Essayez-le en ligne!

J'ai écrit cela dans JS dès que le défi a été publié, mais Arnauld m'a battu au poing avec une bien meilleure réponse, donc ici c'est en C # à la place.

Certainement beaucoup de place pour le golf.

Explication:

La fonction se compose d'une sous-fonction appelée h:

h=g=>string.Join("",
    g.Split('.').Select(x => {
        var e = Convert.ToString(int.Parse(x), 2);
        while (e.Length < 8) e = '0' + e;
        return e;
    }
);

Cette sous-fonction divise l'adresse IP ., convertit chaque nombre en une chaîne binaire, remplit chaque chaîne de gauche avec 0une longueur de 8 bits, puis concatène les chaînes en une chaîne binaire de 32 bits.

Cela se fait immédiatement sur place avec a=h(a);l'adresse IP donnée.
Nous avons ensuite divisé le masque de sous-réseau en une adresse IP et un numéro de masque avecc=b.Split('/');

Le composant d'adresse IP est également transmis via notre sous-fonction: b=h(c[0]);et le numéro de masque est analysé en un entier:var d=int.Parse(c[1]);

Enfin, nous prenons les premiers dbits des deux chaînes binaires (où dest le numéro de masque) et les comparons:return a.Substring(0,d)==b.Substring(0,d);

Shell Linux POSIX (avec net-tools / iputils) (34 octets sans terminaison, 47 octets avec terminaison)

Qu'est-ce qui convient le mieux pour analyser les masques et les adresses réseau que les utilitaires réseau eux-mêmes? :)

route add -net $2 reject;! ping $1

Attention: le script peut potentiellement endommager votre connectivité Internet, veuillez l'exécuter avec précaution.

Entrée: le script prend l'adresse IP testée comme premier argument et le sous-réseau testé. comme deuxième argument.

Sortie: le script renvoie une valeur véridique (0) si le premier argument du script appartient au sous-réseau indiqué dans le deuxième argument. Sinon, il ne se terminera jamais.

Hypothèses: le script doit être exécuté en tant qu'utilisateur root, dans un environnement propre ( c'est-à - dire qu'aucune autre route blackhole n'a été définie par l'administrateur, et si une instance précédente du script a été exécutée, la route blackhole qu'il a créée a été supprimée ). Le script suppose également une "connexion Internet fonctionnelle" ( c'est -à- dire qu'une route par défaut valide est présente).

Explication:

Nous créons une route de trou noir vers le sous-réseau spécifié. Nous testons ensuite la connectivité à l'adresse IP fournie en utilisant ping . Si l'adresse n'appartient pas au sous-réseau (et puisque nous supposons une connexion Internet correctement définie), ping essaiera d'envoyer des paquets à cette adresse. Notez que la réponse de cette adresse n'a pas d'importance, car ping continuera d'essayer indéfiniment. Inversement, si l'adresse appartient au sous-réseau, le ping échouera avec ENETUNREACH et renverra 2, et puisque nous avons annulé la commande, le script réussira.

Exemple

Vérifier si 5.5.5.5 appartient à 8.8.8.0/24

$ sudo ./a.sh 5.5.5.5 8.8.8.0/24
PING 5.5.5.5 (5.5.5.5) 56(84) bytes of data.
[...runs forever...]

(Nettoyer avec sudo ip route del 8.8.8.0/24 après avoir exécuté la commande).

Testez si 5.5.5.5 appartient à 5.5.5.0/24:

$ sudo ./a.sh 5.5.5.5 5.5.5.0/24
connect: Network is unreachable
$ echo $?
0

(Nettoyer avec sudo ip route del 5.5.5.0/24 après avoir exécuté la commande).

Testez si 8.8.8.8 appartient à 5.5.5.0/24:

$ sudo ./a.sh 8.8.8.8 5.5.5.0/24
PING 8.8.8.8 (8.8.8.8) 56(84) bytes of data.
64 bytes from 8.8.8.8: icmp_seq=1 ttl=122 time=2.27 ms
64 bytes from 8.8.8.8: icmp_seq=2 ttl=122 time=1.95 ms
[...runs forever...]

(Nettoyer avecsudo ip route del 5.5.5.0/24 après avoir exécuté la commande).

Version 47 octets si nous interdisons les scripts sans terminaison

route add -net $2 reject;ping -c1 $1;[ $? = 2 ]

Selon le commentaire de @ Grimy, voici la version qui se termine toujours, et retourne 0 (véridique) si l'adresse est dans le sous-réseau, et 1 (faux) sinon. Nous faisons terminer ping avec l' -c1indicateur qui limite le nombre de paquets envoyés à 1. Si l'adresse a répondu, ping renverra 0, et sinon, ping renverra 1. Seulement si l'adresse appartient au sous-réseau blackholed, ping renverra 2, qui est donc ce contre quoi nous testons dans la dernière commande.

JavaScript (ES6), 82 octets

Prend l'entrée comme (address)(subnet). Renvoie une valeur booléenne.

a=>s=>!([s,v]=s.split`/`,+v&&(g=s=>s.split`.`.map(k=v=>k=k<<8|v)|k>>32-v)(a)^g(s))

Essayez-le en ligne!

PHP , 101 92 88 octets

-13 octets de @gwaugh

function($i,$r){[$r,$n]=explode('/',$r);return(ip2long($i)&~(1<<32-$n)+1)==ip2long($r);}

Essayez-le en ligne!

PowerPC / PPC64 C, 116 114 octets

#include<stdio.h>
main(){unsigned u[4];char*p=u;for(;p<u+3;)scanf("%hhu%c",p++,u+3);return!((*u^u[1])>>32-p[-4]);}

(Testé sur x86_64 Ubuntu 18.04 à l'aide de powerpc64-linux-gnu-gcc -static et qemu-user.)

Le programme prend les deux lignes sur l'entrée standard et comme code de sortie, il renvoie 1 si l'adresse correspond et 0 si ce n'est pas le cas. (Cela dépend donc de la spécification ne nécessitant pas de valeur véridique pour une correspondance et une valeur de falsey pour une non-correspondance.) Notez que si vous exécutez de manière interactive, vous devrez signaler EOF ( ^D) trois fois après avoir entré la deuxième ligne.

Cela repose sur PowerPC étant big-endian, et également sur cette plate-forme renvoyant 0 pour décaler à droite une valeur non signée de 32 bits par 32. Il lit les octets en valeurs non signées un par un, avec la longueur du masque de réseau dans un autre octet ; puis il prend le xor des deux adresses 32 bits non signées et décale les bits non pertinents. Enfin, il s'applique !pour satisfaire à l'exigence de ne renvoyer que deux valeurs distinctes.

Remarque: Il peut être possible de raser deux octets en remplaçant u+3par pet en exigeant une compilation avec -O0. C'est vivre plus dangereusement que je ne le pense, cependant.

Merci à Peter Cordes pour l'inspiration de cette solution.

Plus portable C, 186 171 167 octets

Ici, je vais conserver une version plus portable qui fonctionne sur 167 octets.

#include<stdio.h>
main(){unsigned a,b,c,d,e,f,g,h,n;scanf("%u.%u.%u.%u %u.%u.%u.%u/%u",&a,&b,&c,&d,&e,&f,&g,&h,&n);return!(n&&((((a^e)<<8|b^f)<<8|c^g)<<8|d^h)>>32-n);}

Ce programme prend les deux lignes sur l'entrée standard et renvoie le code de sortie 1 si l'adresse est dans le sous-réseau et 0 si ce n'est pas le cas. (Cela dépend donc de la spécification ne nécessitant pas une valeur véridique pour les correspondances et une valeur de falsey pour les non-correspondances.)

Une ventilation de l'expression principale:

• a^e, b^f, c^g, d^hCalcule le OU exclusif de l'adresse et le masque octet par octet.
• (((a^e)<<8|b^f)<<8|c^g)<<8|d^h puis les combine en une seule valeur 32 bits non signée par une méthode de type Horner.
• ...>>32-ndécale ensuite les bits de la différence xor qui ne sont pas pertinents pour le masque de sous-réseau (en gardant à l'esprit que la -priorité en C est plus élevée que <<)
• Il y a cependant un problème: si n = 0, ~0U<<32cela donnera un comportement indéfini en supposant unsigned32 bits (ce qu'il est sur pratiquement toutes les plates-formes actuelles). D'un autre côté, si n = 0, alors n'importe quelle adresse correspondra, donc n&&...donnera le résultat correct (en profitant du comportement de court-circuitage de &&).
• Enfin, pour répondre à l'exigence selon laquelle la sortie ne peut être que l'une des deux valeurs, nous appliquons la !sortie 0 ou 1.

-15 octets en raison des commentaires de plafondcat et AdmBorkBork

-4 octets en raison du commentaire de Peter Cordes

Stax , 22 octets

é.○▄╗jF⌐§╥§I╓☻lw«ç┴║╫┼

Exécuter et déboguer

Il prend les paramètres d'entrée séparés par des espaces sur l'entrée standard.

Déballé, non golfé et commenté, il ressemble à ceci.

'/:/~       split on slash and push the last group back to the input stack
j{          split on space; for each group, run this code block
  './       split on period
  {emVB|E   evaluate integers and decode integer as base-256
  ;e|<      peek from input stack and shift left
  Vu/       integer divide by 2^32
F           end of for-each
=           two values left on stack are equal?

Exécutez celui-ci

Fonction de code machine x86-64, 53 48 octets

journal des modifications:

• -2 jzsur le décalage au lieu d'utiliser un décalage 64 bits pour gérer le >>(32-0)cas spécial.
• -3 retourne en ZF au lieu de AL, économisant 3 octets pour a setnz al.

(Voir également la réponse du code machine de 32 bits de Daniel Schepler basée sur cela, qui a ensuite évolué pour utiliser d'autres idées que nous avions. J'inclus ma dernière version de cela au bas de cette réponse.)

Renvoie ZF = 0 pour l'hôte qui n'est pas dans le sous-réseau, ZF = 1 pour dans le sous-réseau, afin que vous puissiez vous connecter au résultat avecje host_matches_subnet

Appelable avec la convention d'appel System V x86-64 comme
bool not_in_subnet(int dummy_rdi, const char *input_rsi);si vous ajoutiez setnz al.

La chaîne d'entrée contient à la fois l'hôte et le réseau, séparés par exactement 1 caractère non numérique. La mémoire suivant la fin de la largeur CIDR doit contenir au moins 3 octets non numériques avant la fin d'une page. (Cela ne devrait pas être un problème dans la plupart des cas, comme pour un argument cmdline.) La version 32 bits de Daniel n'a pas cette limitation.

Nous exécutons la même boucle d'analyse quadruple en pointillé 3 fois, obtenant les deux adresses IPv4 et obtenant le /masksous forme d'entier dans l'octet haut d'un dword. (C'est pourquoi il doit y avoir une mémoire lisible après le /mask, mais peu importe s'il y a des chiffres ASCII.)

Nous faisons (host ^ subnet) >> (32-mask)pour décaler les bits d'hôte (ceux autorisés à ne pas correspondre), ne laissant que la différence entre le sous-réseau et l'hôte. Pour résoudre le /0cas spécial où nous devons décaler de 32, nous sautons par-dessus le décalage sur count = 0. ( neg cldéfinit ZF, que nous pouvons ramifier et laisser comme valeur de retour si nous ne décalons pas.) Notez que 32-mask mod 32 = -mask, et les décalages scalaires x86 masquent leur nombre par & 31ou & 63.

    line  addr   machine                NASM source.  (from nasm -felf64 -l/dev/stdout)
    num          code bytes

     1                             %use smartalign
     2                             
     3                                 ;10.4.1.33 10.4.0.0/23         true
     4                                 ;10.4.1.33 10.4.0.0/24         false
     5                             
     6                             ;; /codegolf/185005/im-in-your-subnets-golfing-your-code
     7                             %ifidn __OUTPUT_FORMAT__, elf64
     8                             in_subnet:
     9                             
    10 00000000 6A03                   push 3
    11 00000002 5F                     pop  rdi                    ; edi = 3 dotted-quads to parse, sort of.
    12                             .parseloop:
    13                             
    14                                 ;xor  ebx,ebx             ; doesn't need to be zeroed first; we end up shifting out the original contents
    15                                 ;lea  ecx, [rbx+4]
    16 00000003 6A04                   push   4
    17 00000005 59                     pop    rcx                  ; rcx = 4 integers in a dotted-quad
    18                             .quadloop:
    19                             
    20 00000006 31D2                   xor   edx,edx               ; standard edx=atoi(rdi) loop terminated by a non-digit char
    21 00000008 EB05                   jmp  .digit_entry
    22                              .digitloop:
    23 0000000A 6BD20A                 imul   edx, 10
    24 0000000D 00C2                   add    dl, al
    25                              .digit_entry:
    26 0000000F AC                     lodsb
    27 00000010 2C30                   sub    al, '0'
    28 00000012 3C09                   cmp    al, 9
    29 00000014 76F4                   jbe   .digitloop
    30                                 ; al=non-digit character - '0'
    31                                 ; RDI pointing to the next character.
    32                                 ; EDX = integer
    33                             
    34 00000016 C1E308                 shl    ebx, 8
    35 00000019 88D3                   mov    bl, dl               ; build a quad 1 byte at a time, ending with the lowest byte
    36 0000001B E2E9                   loop .quadloop
    37                             
    38 0000001D 53                     push   rbx          ; push result to be collected after parsing 3 times
    39 0000001E FFCF                   dec    edi
    40 00000020 75E1                   jnz   .parseloop
    41                             
    42 00000022 59                     pop    rcx   ; /mask  (at the top of a dword)
    43 00000023 5A                     pop    rdx   ; subnet
    44 00000024 58                     pop    rax   ; host
    45 00000025 0FC9                   bswap  ecx   ; cl=network bits  (reusing the quad parse loop left it in the high byte)

    49 00000027 F6D9                   neg    cl
    50 00000029 7404                   jz   .all_net     ; skip the count=32 special case
    51                             
    52 0000002B 31D0                   xor    eax, edx   ; host ^ subnet
    53 0000002D D3E8                   shr    eax, cl    ; shift out the host bits, keeping only the diff of subnet bits
    54                             
    55                             .all_net:
    56                                ; setnz  al         ; return ZF=1 match,  ZF=0 not in subnet
    57 0000002F C3                     ret
    58 00000030 30                 .size:      db $ - in_subnet

              0x30 = 48 bytes

(non mis à jour avec la dernière version) Essayez-le en ligne!

y compris un _startqui l'appelle argv[1]et renvoie un état de sortie.

## on my desktop
$ ./ipv4-subnet "10.4.1.33 10.4.0.0/24"    && echo "$? : in subnet" || echo "$? : not in subnet"
not in subnet

$ ./ipv4-subnet "10.4.1.33 10.4.0.0/23"    && echo "$? : in subnet" || echo "$? : not in subnet"
in subnet

Cela fonctionne très bien si vous passez un argument de ligne de commande contenant une nouvelle ligne au lieu d'un espace. Mais ce doit être à la place , pas aussi bien.

Fonction de code machine x86 32 bits, 38 octets

Faites 9 entiers -> uint8_t analyse et "poussez-les" sur la pile, où nous les supprimons comme dwords ou utilisons le dernier encore dans CL. Évite la lecture après la fin de la chaîne.

En outre, decn'est que de 1 octet en mode 32 bits.

    72                             in_subnet:
    73 00000000 89E7                   mov   edi, esp
    74 00000002 51                     push  ecx
    75 00000003 51                     push  ecx                   ; sub esp,8
    76                             .byteloop:
    77                             
    78 00000004 31C9                   xor   ecx,ecx               ; standard ecx=atoi(rdi) loop terminated by a non-digit char
    79                                                             ; runs 9 times: 8 in two dotted-quads, 1 mask length
    80 00000006 EB05                   jmp  .digit_entry
    81                              .digitloop:
    82 00000008 6BC90A                 imul   ecx, 10
    83 0000000B 00C1                   add    cl, al
    84                              .digit_entry:
    85 0000000D AC                     lodsb
    86 0000000E 2C30                   sub    al, '0'
    87 00000010 3C09                   cmp    al, 9
    88 00000012 76F4                   jbe   .digitloop
    89                                 ; RDI pointing to the next character.
    90                                 ; EDX = integer
    91                             
    92 00000014 4F                     dec    edi
    93 00000015 880F                   mov    [edi], cl           ; /mask store goes below ESP but we don't reload it
    94 00000017 39E7                   cmp    edi, esp
    95 00000019 73E9                   jae   .byteloop
    96                             
    97                                 ;; CL = /mask still there from the last conversion
    98                                 ;; ESP pointing at subnet and host on the stack, EDI = ESP-1
    99                             
   100 0000001B 5A                     pop    edx   ; subnet
   101 0000001C 58                     pop    eax   ; host
   102                             
   103 0000001D 31D0                   xor    eax, edx             ; host ^ subnet
   104 0000001F F6D9                   neg    cl                   ; -mask = (32-mask) mod 32;  x86 shifts mask their count
   105 00000021 7402                   jz     .end                 ; 32-n = 32 special case
   106 00000023 D3E8                   shr    eax, cl
   107                             .end:
   108                                 ; setz  al                  ; just return in ZF
   109 00000025 C3                     ret

   110 00000026 26                 .size:      db $ - in_subnet
      0x26 = 38 bytes

Appelant de test

   113                             global _start
   114                             _start:
   115 00000027 8B742408               mov    esi, [esp+8]   ; argv[1]
   116 0000002B E8D0FFFFFF             call   in_subnet
   117 00000030 0F95C3                 setnz  bl
   118 00000033 B801000000             mov    eax, 1         ; _exit syscall
   119 00000038 CD80                   int    0x80

Gelée , 23 octets

ṣ”/ṣ€”.Vḅ⁹s2+Ø%BḊ€ḣ€ʋ/E

Essayez-le en ligne!

Lien monadique qui prend une adresse et un sous-réseau séparés par une barre oblique et renvoie 1 pour vrai et 0 pour faux.

Merci à @gwaugh d'avoir signalé une faille dans l'original - cela n'a pas permis de s'assurer que la liste binaire était longue de 32.

Perl 5 -Mbigint -MSocket=:all -p , 72 octets

sub c{unpack N,inet_aton pop}<>=~/(.*)\/(.*)/;$_=c($_)-&c($1)<2**(32-$2)

Essayez-le en ligne!

05AB1E , 21 octets

'/¡`U‚ε'.¡b8jð0:JX£}Ë

Prend le sous-réseau avant l'adresse.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

'/¡              '# Split the first subnet-input by "/"
   `              # Push both values separated to the stack
    U             # Pop and store the trailing number in variable `X`
    ‚             # Pair the subnet-IP with the second address-input
     ε            # Map both to:
      '.¡        '#  Split on "."
         b        #  Convert each integer to binary
          8j      #  Add leading spaces to make them size 8
          ð0:     #  And replace those spaces with "0"
             J    #  Join the four parts together to a single string
              X£  #  And only leave the first `X` binary digits as substring
     }Ë           # After the map: check if both mapped values are the same
                  # (which is output implicitly as result)

R 120 octets

une fonction - j'ai collé ".32" au premier terme

w=function(a,b){f=function(x)as.double(el(strsplit(x,"[./]")));t=f(paste0(a,".32"))-f(b);sum(t[-5]*c(256^(3:0)))<2^t[5]}

et juste pour le plaisir:

require("iptools");w=function(a,b)ips_in_cidrs(a,b)[[2]]

qui est de 56 octets

PHP ,75 73, 71 octets

<?=strtok($argv[2],'/')==long2ip(ip2long($argv[1])&1+~1<<32-strtok(_));

Une fourchette de la réponse de @Luis felipe De jesus Munoz , en tant que standalone prenant une entrée des arguments de la ligne de commande. Sorties '1'pour Truthy, ''(chaîne vide) pour Fasley.

$ php ipsn.php 127.0.0.1 127.0.0.0/24
1
$ php ipsn.php 127.1.2.3 127.0.0.0/24

Essayez-le en ligne!

-2 octets empruntant la petite astuce de @Christoph pour strtok(). Mais sa réponse est encore plus courte!

fonction d'assemblage x86, 49 43 octets

Ceci est principalement affiché pour satisfaire la demande de Peter Cordes pour la version révisée que j'ai créée. Il peut probablement disparaître une fois / s'il l'intègre dans sa réponse.

Cette fonction s'attend esià pointer vers une chaîne d'entrée, avec les parties d'adresse et de sous-réseau séparées par un espace ou un caractère de nouvelle ligne, et la valeur de retour est dans l'indicateur ZF (qui, par définition, n'a que deux valeurs possibles).

 1                                  %use smartalign
 2                                  
 3                                      ;10.4.1.33 10.4.0.0/23         true
 4                                      ;10.4.1.33 10.4.0.0/24         false
 5                                  
 6                                  ;; /codegolf/185005/im-in-your-subnets-golfing-your-code
 7                                  in_subnet:
 8                                  
 9                                      ;xor  ebx,ebx             ; doesn't need to be zeroed first; we end up shifting out the original contents
10                                      ;lea  ecx, [rbx+4]
11 00000000 6A09                        push   9
12 00000002 59                          pop    ecx                  ; ecx = 9 integers (8 in two dotted-quads,
13                                                                  ; 1 mask length)
14                                  
15 00000003 89E7                        mov   edi, esp
16 00000005 83EC0C                      sub   esp, 12
17                                  .quadloop:
18                                  
19 00000008 31D2                        xor   edx,edx               ; standard edx=atoi(rdi) loop terminated by a non-digit char
20 0000000A EB05                        jmp  .digit_entry
21                                   .digitloop:
22 0000000C 6BD20A                      imul   edx, 10
23 0000000F 00C2                        add    dl, al
24                                   .digit_entry:
25 00000011 AC                          lodsb
26 00000012 2C30                        sub    al, '0'
27 00000014 3C09                        cmp    al, 9
28 00000016 76F4                        jbe   .digitloop
29                                      ; al=non-digit character - '0'
30                                      ; RDI pointing to the next character.
31                                      ; EDX = integer
32                                  
33 00000018 4F                          dec    edi
34 00000019 8817                        mov    [edi], dl
35 0000001B E2EB                        loop .quadloop
36                                  
37 0000001D 59                          pop    ecx   ; /mask  (at the top of a dword)
38 0000001E 5A                          pop    edx   ; subnet
39 0000001F 58                          pop    eax   ; host
40 00000020 0FC9                        bswap  ecx   ; cl=network bits  (reusing the quad parse loop left it in the high byte)
41                                  
42                                  ;    xor    cl, -32    ; I think there's some trick like this for 32-n or 31-n, but maybe only if we're masking to &31?  Then neg or not work.
43                                  
44 00000022 31D0                        xor    eax, edx   ; host ^ subnet
45                                  ;    xor    edx, edx   ; edx = 0
46 00000024 F6D9                        neg    cl
47 00000026 7402                        jz     .end
48 00000028 D3E8                        shr    eax, cl    ; count=32 special case isn't special for a 64-bit shift
49                                  .end:    
50 0000002A C3                          ret
51 0000002B 2B                      .size:      db $ - in_subnet

Et la partie wrapper Linux x86:

53                                  global _start
54                                  _start:
55 0000002C 8B742408                    mov    esi, [esp+8]   ; argv[1]
56 00000030 E8CBFFFFFF                  call   in_subnet
57 00000035 0F95C0                      setnz  al
58 00000038 0FB6D8                      movzx  ebx, al
59 0000003B B801000000                  mov    eax, 1         ; _exit syscall
60 00000040 CD80                        int    0x80

-6 octets en raison de la suggestion de Peter Cordes de renvoyer la valeur en ZF.

Java 215211207202200199198190180180 octets

Long k,c;boolean a(String i,String s){return(b(i)^b(s))>>32-k.decode(s.split("/")[1])==0;}long b(String i){for(c=k=0l;c<4;k+=k.decode(i.split("[./]")[3+(int)-c])<<8*c++);return k;}

Sorties truepour véridique et falsepour fausse.

Remarque: Cela utilise longau lieu de intpour le décalage à droite potentiel de 32.

Essayez-le en ligne!

1 octet sauvé grâce au plafond

10 octets enregistrés grâce à Peter Cordes

Fusain , 36 octets

≔⪪Ｓ/θ≔Ｉ⊟θζ⊞θＳＵＭθ÷↨Ｉ⪪ι.²⁵⁶Ｘ²⁻³²ζ⁼⊟θ⊟θ

Essayez-le en ligne! Le lien est vers la version détaillée du code. Prend le sous-réseau comme premier paramètre et -ne sort que si l'adresse se trouve dans le sous-réseau. Explication:

≔⪪Ｓ/θ

Divisez le sous-réseau /.

≔Ｉ⊟θζ

Retirez le masque et transformez-le en entier.

⊞θＳ

Envoyez l'adresse au tableau.

ＵＭθ÷↨Ｉ⪪ι.²⁵⁶Ｘ²⁻³²ζ

Divisez les deux adresses ., convertissez-les en nombres entiers, interprétez-les comme base 256 et supprimez les bits masqués.

⁼⊟θ⊟θ

Comparez les deux valeurs.

Japt , 26 octets

Ëq'/
ËÎq. Ë°¤ù8ì¯Ug1,1Ãr¶

Essayez-le

-3 octets grâce à @Shaggy!

L'entrée est un tableau à 2 éléments [address, subnet]. Transposé JS ci-dessous:

// U: implicit input array
// split elements in U on the / and
// save back to U using a map function
U = U.m(function(D, E, F) {
  return D.q("/")
});
// map the result of the previous operation
// through another function
U.m(function(D, E, F) {
  return D
    // get the address portion of the / split
    // value and split again on .
    .g().q(".")
    // map each octet through another function
    .m(function(D, E, F) {
      // convert the octet to a base 2 string
      // left padded to a length of 8
      return (D++).s(2).ù(8)
    })
    // join the base 2 octets
    .q()
    // take the left bits of the joined octets
    // determined by subnet size
    .s(0, U.g(1, 1))
})
  // at this point, the intermediate result
  // contains 2 masked values, reduce
  // using === to check for equality
  .r("===")

C # (Visual C # Interactive Compiler) , 187 octets

a=>{var b=a.Select(x=>x.Split(".").SelectMany(g=>Convert.ToString(int.Parse(g.Split("/")[0]),2).PadLeft(8)).Take(int.Parse(a[1].Split("/")[1])));return b.First().SequenceEqual(b.Last());}

Je peux définitivement jouer au golf plus bas.

Essayez-le en ligne!

C # (Visual C # Interactive Compiler) , 134 octets

a=>a.Select(x=>x.Split('.','/').Take(4).Aggregate(0L,(y,z)=>y<<8|int.Parse(z))>>32-int.Parse(a[1].Split('/')[1])).Distinct().Count()<2

Essayez-le en ligne!

Instruction LINQ qui prend un tableau de chaînes à 2 éléments en entrée dans [address, subnet] format.

Chaque quadruple pointillé est converti en 32 bits de long en utilisant la manipulation de bits. Les bits sont décalés vers la droite de la taille du sous-réseau et les éléments sont comparés pour l'égalité.

Il y avait quelques réponses C # au moment où cette réponse a été publiée, mais aucune qui utilisait de la manipulation de bits purs.

// a: input array containing address and subnet
a=>a
  // iterate over input elements
  .Select(x=>x
    // split element on . and /
    .Split('.','/')
    // the subnet will have 5 elements,
    // we only want the parts before the /
    .Take(4)
    // use an aggregate function to convert dotted quad to 32 bits
    .Aggregate(0L,(y,z)=>y<<8|int.Parse(z))
    // shift bits of aggregate to the right
    >>
    // shift amount determined by subnet size
    32-int.Parse(a[1].Split('/')[1])
  )
  // test for equality by checking if number
  // of unique values is equal to 1
  .Distinct()
  .Count()<2

Rubis (48 octets)

require 'ipaddr'
lambda{|a,m|IPAddr.new(m)===a}