Inspiré par...

Réseau - Comment puis-je déterminer le nombre d'adresses IP dans une plage donnée?

Écrivez un programme ou une fonction qui prend deux chaînes en entrée, chacune étant une adresse IPv4 exprimée en notation pointillée standard et génère ou renvoie le nombre d'adresses IP couvertes par cette plage, y compris les deux adresses IP entrées.

• Vous ne devez pas utiliser de code externe, de bibliothèques ou de services conçus pour analyser une adresse IP. (D'autres fonctions de bibliothèque standard de traitement de chaîne sont acceptables.)
• Toutes les adresses IP 2 ^ 32 sont égales. Aucune distinction n'est faite pour la diffusion, la classe E, etc.
• Les règles normales du code-golf s'appliquent.

Par exemple:

"0.0.0.0","255.255.255.255" returns 4294967296.
"255.255.255.255","0.0.0.0" also returns 4294967296.
"1.2.3.4","1.2.3.4" returns 1.
"56.57.58.59","60.61.62.63" returns 67372037.
"1","2" is invalid input. Your code may do anything you like.

GolfScript, 20 octets

~]7/${2%256base}/)\-

Essayez-le en ligne.

Cas de test

$ echo 0.0.0.0 255.255.255.255 | golfscript range.gs
4294967296
$ echo 255.255.255.255 0.0.0.0 | golfscript test.gs
4294967296
$ echo 1.2.3.4 1.2.3.4 | golfscript test.gs
1
$ echo 56.57.58.59 60.61.62.63 | golfscript test.gs
67372037

Comment ça marche

~]        # Evaluate and collect into an array.
          #
          # “.” duplicates, so for "5.6.7.8 1.2.3.4", this leaves
          # [ 5 5 6 6 7 7 8 1 1 2 2 3 3 4 ] on the stack.
          #
7/        # Split into chunks of length 7: [ [ 5 5 6 6 7 7 8 ] [ 1 1 2 2 3 3 4 ] ]
$         # Sort the array of arrays: [ [ 1 1 2 2 3 3 4 ] [ 5 5 6 6 7 7 8 ] ]
{         # For each array:
  2%      # Extract every second element. Example: [ 1 2 3 4 ]
  256base # Convert the IP into an integer by considering it a base 256 number.
}/        #
)         # Add 1 to the second integer.
\-        # Swap and subtract. Since the integers were sorted, the result is positive.

Python 2-106

Voyez-le ici .

def a():x=map(int,raw_input().split("."));return x[0]*2**24+x[1]*2**16+x[2]*2**8+x[3]
print abs(a()-a())+1

Exemple d'entrée

0.0.0.0
0.0.0.255

Exemple de sortie

256

CJam - 15

{r'./256b}2*-z)

Essayez-le sur http://cjam.aditsu.net/

Merci Dennis, wow, je ne sais pas comment tirer le meilleur parti de ma propre langue: p

Pure bash, 66 octets

p()(printf %02x ${1//./ })
r=$[0x`p $1`-0x`p $2`]
echo $[1+${r/-}]

Remarques:

• Définit une fonction à plaquelle est passée une adresse IP décimale en pointillés et génère la représentation hexadécimale de cette adresse:
  • ${1//./ }est une extension de paramètre qui remplace .par l'adresse IP transmise àp()
  • Le printfest principalement explicite. Puisqu'il n'y a qu'un spécificateur de format %02xet quatre arguments restants, le spécificateur de format est réutilisé pour chaque argument restant, concaténant efficacement les 2 chiffres hexadécimaux de chacun des 4 octets ensemble
• $[]provoque une expansion arithmétique. Nous faisons une soustraction de base et affectons à la variabler
• ${r/-}est une extension de paramètre pour supprimer un -caractère possible - effectivement abs ()
• Afficher 1 + la différence absolue pour donner la plage.

Sortie:

$ ./iprangesize.sh 0.0.0.0 255.255.255.255
4294967296
$ ./iprangesize.sh 255.255.255.255 0.0.0.0
4294967296
$ ./iprangesize.sh 1.2.3.4 1.2.3.4
1
$ ./iprangesize.sh 56.57.58.59 60.61.62.63
67372037
$ ./iprangesize.sh 1 2
2
$ 

Python 2.7 - 96 91 90 87

Fait une fonction.

f=lambda a:reduce(lambda x,y:x*256+int(y),a.split("."),0)
p=lambda a,b:abs(f(a)-f(b))+1

Usage:

>>> p("1.2.3.4","1.2.3.5")
2

Modifier: Suppression inutile int()de la ffonction. Merci à isaacg

Edit2: supprimé LFà la fin du fichier (grâce à @Rusher) et supprimé map()au prix de l' reduce()initialisation (merci à @ njzk2)

GolfScript, 27 octets

' '/{'.'/{~}%256base}/-abs)

Exemples:

$ echo 0.0.0.0 255.255.255.255 | ruby golfscript.rb iprange.gs
4294967296
$ echo 255.255.255.255 0.0.0.0 | ruby golfscript.rb iprange.gs
4294967296
$ echo 1.2.3.4 1.2.3.4 | ruby golfscript.rb iprange.gs
1
$ echo 56.57.58.59 60.61.62.63 | ruby golfscript.rb iprange.gs
67372037

CoffeeScript - 94, 92, 79, 72

I=(a)->a.split(".").reduce((x,y)->+y+x*256)
R=(a,b)->1+Math.abs I(b)-I a

Non-golfé :

I = ( a ) ->
    return a.split( "." ).reduce( ( x, y ) -> +y + x * 256 )

R = ( a, b ) ->
    return 1 + Math.abs I( b ) - I( a )

JavaScript équivalent :

function ip2long( ip_str )
{
    var parts = ip_str.split( "." );    
    return parts.reduce( function( x, y ) {
        return ( +y ) + x * 256; //Note: the unary '+' prefix operator casts the variable to an int without the need for parseInt()
    } );
}

function ip_range( ip1, ip2 )
{
    var ip1 = ip2long( ip1 );
    var ip2 = ip2long( ip2 );

    return 1 + Math.abs( ip2 - ip1 );
}

Essayez-le en ligne .

dc, 61 caractères

?[dXIr^*rdXIr^*256*+r1~dXIr^*r256*+65536*+]dspxsalpxla-d*v1+p

Je pense que c'est assez étonnant que cela puisse être résolu avec dc car il n'a pas la capacité d'analyser les chaînes. L'astuce est que 192.168.123.185 va sur la pile comme

.185
.123
192.168

et dXIr^*déplace la virgule décimale vers la droite autant de chiffres de fraction qu'il y a et cela fonctionne même pour .100.

$ echo 56.57.58.59 60.61.62.63 | dc -e '?[dXIr^*rdXIr^*256*+r1~dXIr^*r256*+65536*+]dspxsalpxla-d*v1+p'
67372037.00

Soustrayez un caractère si vous laissez l'entrée déjà sur la pile.

Powershell - 112 108 92 78 bytes

C'est ma première fois au golf. Rien ne va ici:

Golfé (ancien):

$a,$b=$args|%{$t='0x';$_-split'\.'|%{$t+="{0:X2}"-f[int]$_};[uint32]$t};1+[math]::abs($a-$b)

Golfé (nouveau)

$a,$b=$args|%{$t='0x';$_-split'\.'|%{$t+="{0:X2}"-f+$_};[long]$t}|sort;1+$b-$a

Ungolfed:

$a, $b = $args | % {           #powershell's way of popping an array. In a larger array
                               #$a would equal the first member and $b would be the rest.
    $t = '0x';                 #string prefix of 0x for hex notation
    $_ -split '\.' | % {       #split by escaped period (unary split uses regex)
        $t += "{0:X2}" -f +$_  #convert a dirty casted int into a hex value (1 octet)
    };
    [long]$t                   #and then cast to long
} | sort;                      #sort to avoid needing absolute value
1 + $b - $a                    #perform the calculation

Usage

Enregistrez en tant que fichier (dans ce cas getipamount.ps1), puis appelez à partir de la console

getipamount.ps1 255.255.255.255 0.0.0.0

C # avec LINQ - 139 octets

(À partir de 140 après avoir appliqué la suggestion de Bob.)

long f(params string[] a){return Math.Abs(a.Select(b=>b.Split('.').Select(long.Parse).Aggregate((c,d)=>c*256+d)).Aggregate((e,f)=>e-f))+1;}

Non golfé ....

    long f(params string[] a)                           // params is shorter than two parameters.
    {
        return Math.Abs(                                // At the end, make all values +ve.
             a.Select(                                  // Go through both items in the array...
                b =>                                    // Calling each one 'b'. 
                    b.Split('.')                        // Separating out each "." separated byte...
                    .Select(long.Parse)                 // Converting them to a long.
                    .Aggregate((c, d) => c*256 + d)     // Shift each byte along and add the next one.
             )
             .Aggregate((e,f) => e-f)                   // Find the difference between the two remaining values.
         )+1;                                           // Add one to the result of Math.Abs.
    }

https://dotnetfiddle.net/XPTDlt

Perl, 43 octets

#!perl -pa
$_=1+abs${\map{$_=vec eval,0,32}@F}-$F[0]

Compter le shebang comme deux octets.

Exemple d'utilisation:

$ echo 0.0.0.0 255.255.255.255 | perl count-ips.pl
4294967296

$ echo 255.255.255.255 0.0.0.0 | perl count-ips.pl
4294967296

$ echo 56.57.58.59 60.61.62.63 | perl count-ips.pl
67372037

Remarques

• vec eval,0,32est un rendez-vous pour ip2long. Perl permet aux littéraux de caractères d'être exprimés sous la forme d'un préfixe ordinal avec a v, par exemple, v0peut être utilisé pour le caractère nul. Ceux-ci peuvent également être enchaînés ensemble, par exemple v65.66.67.68→ ABCD. Lorsque trois valeurs ou plus sont présentes, l'initiale vn'est pas nécessaire. La vecfonction interprète une chaîne comme un tableau d'entiers, chaque cellule ayant le nombre spécifié de bits (ici, 32). unpack N,evalaurait également fonctionné.

JavaScript ES6 - 68 octets

f=x=>prompt().split('.').reduce((a,b)=>+b+a*256);1+Math.abs(f()-f())

Essayez-le avec la console (appuyez sur F12) de Firefox.

Python 2.7, 104 octets

y=lambda:map(int,input().split("."));a,b=y(),y();print sum(256**(3-i)*abs(a[i]-b[i])for i in range(4))+1

Perl, 72 octets

#!perl -ap
@a=map{unpack N,pack C4,split/\./,$_}@F;$_=abs($a[1]-$a[0])+1

Usage:

$ echo 10.0.2.0 10.0.3.255 | perl ip-range.pl
512$ 

C'est déjà plus long que le programme Perl de primo , donc pas trop intéressant.

Perl, 119 octets, pour un format d'adresse IP obsolète

#!perl -ap
sub v(){/^0/?oct:$_}@a=map{$m=3;@p=split/\./,$_;$_=pop@p;$s=v;$s+=v<<8*$m--for@p;$s}@F;$_=abs($a[1]-$a[0])+1

Usage:

$ echo 10.0.2.0 10.0.3.255 | perl ip-obsolete.pl
512$ 
$ echo 10.512 10.1023 | perl ip-obsolete.pl
512$ 
$ echo 0xa.0x200 012.01777 | perl ip-obsolete.pl 
512$ 

Ce programme accepte le format obsolète des adresses IP! Cela inclut les adresses avec 1, 2 ou 3 parties, ou avec des parties hexadécimales ou octales. Citant la page de manuel inet_addr (3) ,

Les valeurs spécifiées à l'aide de la notation par points prennent l'une des formes suivantes:

a.b.c.d
a.b.c
a.b
a

... Lorsqu'une adresse en trois parties est spécifiée, la dernière partie est interprétée comme une quantité de 16 bits et placée dans les deux octets les plus à droite de l'adresse réseau. ... Lorsqu'une adresse en deux parties est fournie, la dernière partie est interprétée comme une quantité de 24 bits et placée dans les trois octets les plus à droite de l'adresse réseau. ... Lorsqu'une seule partie est donnée, la valeur est stockée directement dans l'adresse réseau sans réarrangement d'octets.

Tous les nombres fournis en tant que `` parties '' dans une notation par points peuvent être décimaux, octaux ou hexadécimaux, comme spécifié dans le langage C (c.-à-d., Un 0x ou 0X en tête implique hexadécimal; un 0 en tête implique octal; sinon, le nombre est interprété comme décimal).

La plupart des programmes n'acceptent plus ce format obsolète, mais ping 0177.1fonctionnaient toujours dans OpenBSD 5.5.

PHP, 138 110 octets

<?php

function d($a,$b){foreach(explode('.',"$a.$b")as$i=>$v){$r+=$v*(1<<24-$i%4*8)*($i<4?1:-1);}return 1+abs($r);}

// use it as
d('0.0.0.0','255.255.255.255');

Mathematica 9, 108 octets

c[f_,s_]:=1+First@Total@MapIndexed[#1*256^(4-#2)&,First@Abs@Differences@ToExpression@StringSplit[{f,s},"."]]

Ungolfed:

countIpAddresses[first_, second_] := Module[{digitArrays, differences},

  (* Split the strings and parse them into numbers. 
  Mathematica automatically maps many/most of its functions across/
  through lists *)

  digitArrays = ToExpression[StringSplit[{first, second}, "."]];

  (* Find the absolute value of the differences of the two lists, 
  element-wise *)
  differences = Abs[Differences[digitArrays]];

  (* differences looks like {{4, 4, 4, 4}} right now, 
  so take the first element *)
  differences = First[differences];

  (* now map a function across the differences, 
  taking the nth element (in code, '#2') which we will call x (in 
  code, '#1') and setting it to be equal to (x * 256^(4-n)). 
  To do this we need to track the index, so we use MapIndexed. 
  Which is a shame, 
  because Map can be written '/@' and is generally a huge character-
  saver. *)
  powersOf256 = MapIndexed[#1*256^(4 - #2) &, differences];

  (* now we essentially have a list (of singleton lists, 
  due to MapIndexed quirk) which represents the digits of a base-256, 
  converted to decimal form. 
  Example: {{67108864},{262144},{1024},{4}}

  We add them all up using Total, 
  which will give us a nested list as such: {67372036}

  We need to add 1 to this result no matter what. But also, 
  to be fair to the challenge, we want to return a number - 
  not a list containing one number. 
  So we take the First element of our result. If we did not do this, 
  we could chop off 6 characters from our code. *)

  1 + First[Total[powersOf256]]
]

PHP, 46 octets

<?=abs(ip2long($argv[1])-ip2long($argv[2]))+1;

Essayez-le en ligne!

ip2long

C # - 135

long f(string x,string y){Func<string,long>b=s=>s.Split('.').Select((c,i)=>long.Parse(c)<<(3-i)*8).Sum();return Math.Abs(b(x)-b(y))+1;}

Bien formaté

long g(string x, string y) { 
    Func<string, long> b = s => s.Split('.').Select((c, i) => long.Parse(c) << (3 - i) * 8).Sum(); 
    return Math.Abs(b(x) - b(y)) + 1; 
}

https://dotnetfiddle.net/Q0jkdA

Rubis, 93 octets

a=->(x){s=i=0;x.split('.').map{|p|s+=256**(3-i)*p.to_i;i+=1};s}
s=->(x,y){1+(a[x]-a[y]).abs}

Sortie

irb(main):003:0> s['1.1.1.1', '1.1.1.2']
=> 2
irb(main):006:0> s['0.0.0.0', '255.255.255.255']
=> 4294967296

J, 25 octets

Prend les chaînes IP à quatre points comme arguments gauche et droit.

>:@|@-&(256#.".;.2@,&'.')

A expliqué:

>:@|@-&(256#.".;.2@,&'.')  NB. ip range
      &(                )  NB. on both args, do:
                   ,&'.'   NB.   append a .
               ;.2@        NB.   split by last character:
             ".            NB.     convert each split to number
        256#.              NB. convert from base 256
   |@-                     NB. absolute difference
>:@                        NB. add 1 to make range inclusive

Exemples:

   '0.0.0.0' >:@|@-&(256#.".;.2@,&'.') '255.255.255.255'
4294967296
   iprange =: >:@|@-&(256#.".;.2@,&'.')
   '255.255.255.255' iprange '0.0.0.0'
4294967296
   '1.2.3.4' iprange '1.2.3.4'
1
   '56.57.58.59' iprange '60.61.62.63'
67372037

Facteur, 73 octets

Traduction de la réponse CoffeeScript.

[ "." split [ 10 base> ] [ [ 256 * ] dip + ] map-reduce ] bi@ - abs 1 + ]

Javascript ES6, 81 caractères

(a,b)=>Math.abs(eval(`(((((${a})>>>0)-(((((${b})>>>0)`.replace(/\./g,")<<8|")))+1

Tester:

f=(a,b)=>Math.abs(eval(`(((((${a})>>>0)-(((((${b})>>>0)`.replace(/\./g,")<<8|")))+1
;`0.0.0.0,255.255.255.255,4294967296
255.255.255.255,0.0.0.0,4294967296
1.2.3.4,1.2.3.4,1
56.57.58.59,60.61.62.63,67372037`.split`
`.map(x=>x.split`,`).every(x=>f(x[0],x[1])==x[2])

PS: je vais essayer de l'optimiser un peu plus tard.

Lua, 153 octets

Dommage que lua n'ait pas de fonction split, j'ai dû définir la mienne!

a,b=...r=0y=8^8x={}t={}function f(t,s)s:gsub("%d+",function(d)t[#t+1]=d end)end
f(x,a)f(t,b)for i=1,4 do r=r+y*math.abs(t[i]-x[i])y=y/256 end print(r+1)

Ungolfed

a,b=...                    -- unpack the arguments into two variables
r=0                        -- initialise the sume of ip adress
y=8^8                      -- weight for the rightmost value
x={}t={}                   -- two empty arrays -> will contains the splittedip adresses
function f(t,s)            -- define a split function that takes:
                           --   a pointer to an array
                           --   a string
  s:gsub("%d+",function(d) -- iterate over the group of digits in the string
    t[#t+1]=d              -- and insert them into the array
  end)
end
f(x,a)                     -- fill the array x with the first address
f(t,b)                     -- fill the array t with the second address
for i=1,4                  -- iterate over t and x
do
  r=r+y*math.abs(t[i]-x[i])-- incr r by weight*abs(range a- range b)
  y=y/256                  -- reduce the weight
end
print(r+1)                 -- output the result

Gelée , 12 octets, défi de postdates de langue

ṣ”.V€ḅ⁹µ€ạ/‘

Essayez-le en ligne!

Explication

ṣ”.V€ḅ⁹µ€ạ/‘
       µ€     On each element of input:
ṣ”.             Split on periods
   V€           Convert string to number in each section
     ḅ⁹         Convert base 256 to integer
         ạ/   Take absolute difference of the resulting integers
           ‘  Increment

Le nombre d'éléments dans une plage inclusive est la différence absolue de leurs points d'extrémité, plus 1.

Axiome, 385 octets

c(a:String):INT==(d:=digit();s:NNI:=#a;t:INT:=0;for i in 1..s repeat(~member?(a.i,d)=>return-1;t:=t+(ord(a.i)-48)*10^(s-i)::NNI);t)
g(x:String):List NNI==(a:=split(x,char".");s:NNI:=#a;r:=[];for i in s..1 by -1 repeat(y:=c(a.i);y=-1=>return [];r:=concat(y,r));r)
m(x:NNI,y:NNI):NNI==x*256+y
f(a:String,b:String):INT==(x:=g(a);y:=g(b);#x~=4 or #y~=4=>-1;1+abs(reduce(m,x)-reduce(m,y)))

dé-golfer et tester

-- convert the string only digit a in one not negative number
-- return -1 in case of error
cc(a:String):INT==
     d:=digit();s:NNI:=#a;t:INT:=0
     for i in 1..s repeat
               ~member?(a.i,d)=>return -1
               t:=t+(ord(a.i)-48)*10^(s-i)::NNI
     t

-- Split the string x using '.' as divisor in a list of NNI
-- if error return []
gg(x:String):List NNI==
    a:=split(x,char".");s:NNI:=#a;r:=[]
    for i in s..1 by -1 repeat
          y:=cc(a.i)
          y=-1=>return []
          r:=concat(y,r)
    r


mm(x:NNI,y:NNI):NNI==x*256+y

-- Return absolute value of difference of address for IP strings in a and in b 
-- Retrun -1 for error
-- [Convert the IP strings in a and in b in numbers ad subtract and return the difference]
ff(a:String,b:String):INT==(x:=gg(a);y:=gg(b);#x~=4 or #y~=4=>-1;1+abs(reduce(mm,x)-reduce(mm,y)))


(14) -> f("0.0.0.0", "255.255.255.255")
   (14)  4294967296
                                                    Type: PositiveInteger
(15) -> f("255.255.255.255", "0.0.0.0")
   (15)  4294967296
                                                    Type: PositiveInteger
(16) -> f("1.2.3.4", "1.2.3.4")
   (16)  1
                                                    Type: PositiveInteger
(17) -> f("56.57.58.59", "60.61.62.63")
   (17)  67372037
                                                    Type: PositiveInteger
(18) -> f("1", "2")
   (18)  - 1
                                                            Type: Integer