Take the 2-minute tour ×
Programming Puzzles & Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It's 100% free, no registration required.

Inspired by...
http://programmers.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.
share|improve this question
    
I saw this question on programmers, and was thinking about asking it on code golf lol. –  Cruncher May 30 at 14:59
    
I thought this is a StackOverflow question about what IP addresses are impossible according to the standards. –  SHiNKiROU May 30 at 18:30
1  
Isn't IPv4 a bit passe? –  ugoren May 31 at 8:37

17 Answers 17

GolfScript, 20 bytes

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

Try it online.

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.
share|improve this answer
    
Very nice, and nice use of $ to avoid abs. –  Chris Jester-Young May 30 at 6:26
2  
~] is also really clever. –  primo May 30 at 7:23

Python 2 - 106

See it here.

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

share|improve this answer
1  
def a():return reduce(lambda c,d:c*256+d,map(int,raw_input().split("."))) is a lot shorter –  Michael May 29 at 20:37
4  
@Michael Thanks for the suggestion. I used it for a few minutes, then looked at it and thought, "I didn't write 90% of that." so I rolled it back. –  Rainbolt May 29 at 20:50
    
@Michael a=lambda: instead of def a():return saves 6 characters –  avall May 30 at 11:41
    
@Rusher It's 107 characters, not 106 –  avall May 30 at 11:44
    
@avall No, it's 106 characters, not 107. –  Rainbolt May 30 at 13:13

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
share|improve this answer
2  
You can save one char by using / instead of %~. –  Dennis May 30 at 5:21

C# with LINQ - 139 chars

(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

share|improve this answer
    
Could someone explain to me how this whole shifting bytes along thing works? –  Obversity May 30 at 0:31
    
@Obversity a.b.c.d is equivalent to (a << 24) | (b << 16) | (c << 8) | (d << 0) is equivalent to (((a << 8) << 8) << 8) + ((b << 8) << 8) + (c << 8) + d). Basically, each iteration of the aggregation takes the existing sum and shifts it left by one octet, then adds the next octet. –  Bob May 30 at 1:04
    
You can save a character by using c*256 instead of (c<<8). –  Bob May 30 at 1:13
    
@Bob Well spotted. –  billpg May 30 at 7:54
    
You can save two more characters by replacing e-f with e<f?f-e:e-f and dropping the Math.Abs() –  Patrick Huizinga May 30 at 10:06

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
$ 
share|improve this 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.

share|improve this answer
1  
You can save some characters by replacing some parentheses with spaces: I=(a)->n=0;a.split(".").forEach((x)->n<<=8;n+=parseInt x);n>>>0 R=(a,b)->1+Math.abs I(b)-I a –  Rob W May 29 at 20:48
    
It feels like you're losing a lot of space to Math.abs, but I can't come up with anything shorter. (z>0)*z||-z is the best I've got (same length, and it needs a single-char input). Do you have anything cleverer than that? –  Aaron Dufour May 30 at 21:07

Perl - 48 bytes

#!perl -pa
$_=1+abs${\map{$_=vec eval v.$_,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 v.$_,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 with only the initial v, for example v65.66.67.68ABCD. The vec function interprets a string as an integer array, each cell having the specified number of bits (here, 32). unpack N,eval v.$_ would have worked equally as well.
share|improve this 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

share|improve this answer
    
You can save two bytes by eliminating :i (b seems to cast to integer) and one by using {r...}2* instead of qS/{...}/ –  Dennis Jun 2 at 22:12

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.

share|improve this answer
    
You should be using alert or console.log. Console output is cheap. –  nderscore May 29 at 20:24
3  
@nderscore, absolutely no difference between console.log and direct output. This is code-golf, it's not about do clean code. –  Michael May 29 at 20:31
    
The most upvoted answer to this meta post disagrees: JavaScript Standards for IO. It's not a matter of clean code. It's a matter of not actually outputting anything. –  nderscore May 29 at 20:57
    
@DigitalTrauma, it won't work due to operator precedence. (addition vs bitwise shift) –  Michael May 29 at 22:29

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)

share|improve this answer
1  
why does the f function need int() on the outside? –  isaacg May 30 at 7:14
1  
Well. I had no idea :D –  avall May 30 at 7:23
    
can gain 2 chars by putting the int in the reduce instead of using the map (only 2 as you need to add ,0 parameter to your reduce function) –  njzk2 May 30 at 14:26

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.

share|improve this answer

PHP - 138 chars 110 chars

<?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');
share|improve this answer
    
As there's no mention of 'no deprecation warnings', you can save a char by replacing explode('.',"$a.$b") with split('\.',"$a.$b"). –  MrLore Jun 2 at 10:22

Perl, 72 characters

#!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, so not too interesting.

Perl, 119 characters, 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) 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.

share|improve this answer

Powershell - 112 108 92 78 Characters

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
share|improve this answer

Mathematica 9 - 108

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]]
]
share|improve this answer

J - 25 char

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
share|improve this answer

Ruby - 93

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
share|improve this answer

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.