[Question]
  [
Inspired by... 
> 
> [Networking - How can I work out how many IP addresses there are in a given range?](https://softwareengineering.stackexchange.com/questions/241402/how-can-i-work-out-how-many-ip-addresses-there-are-in-a-given-range) 
> 
> 
> 
Write a program or function that takes two strings as input, each being an IPv4 address expressed in standard dotted notation and outputs or returns the number of IP addresses covered by this range, including the two IP addresses input.
* You must not use any external code, libraries or services designed to parse an IP address. (Other string processing standard library functions are acceptable.)
* All 2^32 IP addresses are equal. No distinction is made to broadcast, class E, etc.
* Normal code-golf rules apply.
For example:
```
"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.
```
  
[Answer]
# GolfScript, 20 bytes
```
~]7/${2%256base}/)\-
```
[Try it online.](http://golfscript.apphb.com/?c=OyAiNTYuNTcuNTguNTkgNjAuNjEuNjIuNjMiICMgU2ltdWxhdGUgaW5wdXQgZnJvbSBTVERJTi4KCn5dNy8kezIlMjU2YmFzZX0vKVwt)
### Test cases
```
$ 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
```
### How it works
```
~]        # 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.
```
[Answer]
# Python 2 - 106
See it [here](http://repl.it/TWl/1).
```
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
```
**Example Input**
> 
> 0.0.0.0  
> 
> 0.0.0.255
> 
> 
> 
**Example Output**
> 
> 256
> 
> 
> 
[Answer]
# CJam - 15
```
{r'./256b}2*-z)
```
Try it at <http://cjam.aditsu.net/>
Thanks Dennis, wow, I don't know how to get the best out of my own language :p
[Answer]
# Pure bash, 66 bytes
```
p()(printf %02x ${1//./ })
r=$[0x`p $1`-0x`p $2`]
echo $[1+${r/-}]
```
Notes:
* Defines a function `p` that is passed a dotted decimal IP address, and outputs the hex representation of that address:
	+ `${1//./ }` is a parameter expansion that replaces `.` with  in the IP address passed to `p()`
	+ The `printf` is mostly self explanatory. Since there is only one format specifier `%02x` and four remaining args, the format specifier is reused for each remaining arg, effectively concatenating the 2 hex digits of each of the 4 octets together
* `$[]` causes arithmetic expansion. We do a basic subtraction, and assign to the variable `r`
* `${r/-}` is a parameter expansion to remove a possible `-` character - effectively abs()
* Display 1 + the absolute difference to give the range.
Output:
```
$ ./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
$ 
```
[Answer]
## Python 2.7 - ~~96~~ ~~91~~ ~~90~~ 87
Made a function.
```
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
```
**Edit:** Removed unnecessary `int()` from `f` function. Thanks to isaacg
**Edit2:** Removed `LF` at the end of file (thanks to @Rusher) and removed `map()` at cost of `reduce()` initializer (thanks to @njzk2)
[Answer]
# 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
```
**Un-golfed**:
```
I = ( a ) ->
    return a.split( "." ).reduce( ( x, y ) -> +y + x * 256 )
R = ( a, b ) ->
    return 1 + Math.abs I( b ) - I( a )
```
**Equivalent JavaScript**:
```
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 );
}
```
[Try it online](http://coffeescript.org/#try%3aI%3D(a)-%3Ea.split(%22.%22).reduce((x%2Cy)-%3E%2By%2Bx%2a256)%0AR%3D(a%2Cb)-%3E1%2BMath.abs%20I(b)-I%20a%0A%0Atest%20%3D%20%5B%0A%20%20%20%20%5B%20%220.0.0.0%22%2C%20%22255.255.255.255%22%2C%204294967296%20%5D%2C%0A%20%20%20%20%5B%20%22255.255.255.255%22%2C%20%220.0.0.0%22%2C%204294967296%20%5D%2C%0A%20%20%20%20%5B%20%221.2.3.4%22%2C%20%221.2.3.4%22%2C%201%20%5D%2C%0A%20%20%20%20%5B%20%2256.57.58.59%22%2C%20%2260.61.62.63%22%2C%2067372037%20%5D%2C%0A%20%20%20%20%5B%20%221%22%2C%20%222%22%2C%202%20%5D%0A%5D%0A%0Apass%20%3D%20yes%0A%0Afor%20x%20in%20test%0A%20%20%20%20pass%20%3D%20pass%20and%20R(%20x%5B0%5D%2C%20x%5B1%5D%20)%20is%20x%5B2%5D%0A%0Aalert%20if%20pass%20then%20%22All%20tests%20passed.%22%20else%20%22Something%20went%20wrong.%22).
[Answer]
## GolfScript, 27 bytes
```
' '/{'.'/{~}%256base}/-abs)
```
Examples:
```
$ 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
```
[Answer]
# Perl, 43 bytes
```
#!perl -pa
$_=1+abs${\map{$_=vec eval,0,32}@F}-$F[0]
```
Counting the shebang as two bytes.
Sample Usage:
```
$ 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
```
---
**Notes** 
* `vec eval,0,32` is a drop-in for `ip2long`. Perl allows character literals to be expressed as their ordinal prefixed with a `v`, for example `v0` can be used for the null char. These can also be chained together, for example `v65.66.67.68` → `ABCD`. When three or more values are present, the initial `v` is unnecessary. The `vec` function interprets a string as an integer array, each cell having the specified number of bits (here, 32). `unpack N,eval` would have worked equally as well.
[Answer]
# dc, 61 characters
```
?[dXIr^*rdXIr^*256*+r1~dXIr^*r256*+65536*+]dspxsalpxla-d*v1+p
```
I think it's pretty amazing that this can be solved with dc at all since it has no ability to parse strings. The trick is that 192.168.123.185 goes on the stack as
```
.185
.123
192.168
```
and `dXIr^*` shifts the decimal point right as many fraction digits as there are and it even works for .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
```
Subtract a character if you let the input already be on the stack.
[Answer]
# Powershell - ~~112~~ ~~108~~ ~~92~~ 78 bytes
This is my first time golfing. Here goes nothing:
### Golfed (Old):
```
$a,$b=$args|%{$t='0x';$_-split'\.'|%{$t+="{0:X2}"-f[int]$_};[uint32]$t};1+[math]::abs($a-$b)
```
### Golfed (new)
```
$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
Save as file (in this case getipamount.ps1) and then call from the console
```
getipamount.ps1 255.255.255.255 0.0.0.0
```
[Answer]
# C# with LINQ - 139 bytes
(From 140 after applying Bob's suggestion.)
```
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;}
```
Ungolfed....
```
    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>
[Answer]
## JavaScript ES6 - 68 bytes
```
f=x=>prompt().split('.').reduce((a,b)=>+b+a*256);1+Math.abs(f()-f())
```
Try it with the console (press F12) of Firefox.
[Answer]
# Python 2.7, 104 bytes
```
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
```
[Answer]
# Perl, 72 bytes
```
#!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$ 
```
This is already longer than [primo's Perl program](https://codegolf.stackexchange.com/a/28782/4065), so not too interesting.
# Perl, 119 bytes, for obsolete IP address format
```
#!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$ 
```
This program accepts the obsolete format for IP addresses! This includes addresses with 1, 2, or 3 parts, or with hexadecimal or octal parts. Quoting the [inet\_addr(3)](http://www.openbsd.org/cgi-bin/man.cgi?query=inet_addr&apropos=0&sektion=0&manpath=OpenBSD%20Current&arch=i386&format=html) manual page,
> 
> Values specified using dot notation take one of the following forms:
> 
> 
> 
> ```
> a.b.c.d
> a.b.c
> a.b
> a
> 
> ```
> 
> ... When a three part address is specified, the last part is interpreted as a 16-bit quantity and placed in the rightmost two bytes of the network address. ... When a two part address is supplied, the last part is interpreted as a 24-bit quantity and placed in the rightmost three bytes of the network address. ... When only one part is given, the value is stored directly in the network address without any byte rearrangement.
> 
> 
> All numbers supplied as ``parts'' in a dot notation may be decimal, octal, or hexadecimal, as specified in the C language (i.e., a leading 0x or 0X implies hexadecimal; a leading 0 implies octal; otherwise, the number is interpreted as decimal).
> 
> 
> 
Most programs no longer accept this obsolete format, but `ping 0177.1` still worked in OpenBSD 5.5.
[Answer]
# PHP, ~~138~~ 110 bytes
```
<?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');
```
[Answer]
# Mathematica 9, 108 bytes
```
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]]
]
```
[Answer]
# PHP, 46 Bytes
```
<?=abs(ip2long($argv[1])-ip2long($argv[2]))+1;
```
[Try it online!](https://tio.run/nexus/php#@29jb5uYVKyRWWCUk5@XrqGSWJReFm0Yq6mLKmIUq6mpbWj9//9/UzM9U3M9Uws9U8v/ZgZ6ZoZ6ZkZ6ZsYA "PHP – TIO Nexus")
[ip2long](http://php.net/manual/en/function.ip2long.php)
[Answer]
## 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;}
```
Properly formatted
```
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>
[Answer]
# Ruby, 93 bytes
```
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}
```
Output
```
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
```
[Answer]
# J, 25 bytes
Takes the dotted-quad IP strings as left and right arguments.
```
>:@|@-&(256#.".;.2@,&'.')
```
Explained:
```
>:@|@-&(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
```
Examples:
```
   '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
```
[Answer]
# Factor, 73 bytes
Translation of the CoffeeScript answer.
```
[ "." split [ 10 base> ] [ [ 256 * ] dip + ] map-reduce ] bi@ - abs 1 + ]
```
[Answer]
# Javascript ES6, 81 chars
```
(a,b)=>Math.abs(eval(`(((((${a})>>>0)-(((((${b})>>>0)`.replace(/\./g,")<<8|")))+1
```
Test:
```
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: I'll try to optimise it a bit later.
[Answer]
## Lua, 153 Bytes
It's a shame that lua doesn't have a split function, I had to define mine!
```
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
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 12 bytes, language postdates challenge
```
ṣ”.V€ḅ⁹µ€ạ/‘
```
[Try it online!](https://tio.run/nexus/jelly#@/9w5@JHDXP1wh41rXm4o/VR485DW0HMXQv1HzXM@H@4Hcj5/z86WslADwyVdJSMTE31kLBSrA6XQjSGqA5cB0TeUM9Iz1jPBCgOY0HETc30TM31TC30TC2BcmYGemaGemZGembGSrGxAA "Jelly – TIO Nexus")
## Explanation
```
ṣ”.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
```
The number of elements in an inclusive range is the absolute difference of their endpoints, plus 1.
[Answer]
# Axiom, 385 bytes
```
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)))
```
ungolf it and test
```
-- 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
```
]