Zainspirowany przez...

Praca w sieci - jak mogę ustalić, ile adresów IP znajduje się w danym zakresie?

Napisz program lub funkcję, która pobiera dwa ciągi wejściowe, z których każdy jest adresem IPv4 wyrażonym standardową notacją kropkowaną i wysyła lub zwraca liczbę adresów IP objętych tym zakresem, w tym dwa wejścia adresów IP.

• Nie wolno używać żadnego zewnętrznego kodu, bibliotek ani usług zaprojektowanych do analizowania adresu IP. (Inne standardowe funkcje biblioteki przetwarzania łańcucha znaków są dopuszczalne.)
• Wszystkie 2 ^ 32 adresy IP są równe. Nie rozróżnia się transmisji, klasy E itp.
• Obowiązują normalne zasady gry w golfa.

Na przykład:

"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 bajtów

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

Wypróbuj online.

Przypadki testowe

$ 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

Jak to działa

~]        # 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

Zobacz tutaj .

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

Przykładowe dane wejściowe

0.0.0.0
0.0.0.255

Przykładowy wynik

256

CJam - 15

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

Wypróbuj na http://cjam.aditsu.net/

Dzięki Dennis, wow, nie wiem, jak najlepiej wykorzystać własny język: str

Pure Bash, 66 bajtów

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

Uwagi:

• Definiuje funkcję, pktórej przekazano kropkowany dziesiętny adres IP, i wyświetla szesnastkową reprezentację tego adresu:
  • ${1//./ }to rozszerzenie parametru, które zastępuje .się w przekazanym adresie IPp()
  • Jest printfto w większości oczywiste. Ponieważ istnieje tylko jeden specyfikator formatu %02xi cztery pozostałe argumenty, specyfikator formatu jest ponownie wykorzystywany dla każdego pozostałego argumentu, skutecznie łącząc 2 cyfry szesnastkowe każdego z 4 oktetów razem
• $[]powoduje rozszerzenie arytmetyczne. Wykonujemy podstawowe odejmowanie i przypisujemy do zmiennejr
• ${r/-}to rozszerzenie parametru w celu usunięcia możliwego -znaku - skutecznie abs ()
• Wyświetl 1 + różnicę bezwzględną, aby podać zakres.

Wydajność:

$ ./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

Wykonał funkcję.

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

Stosowanie:

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

Edycja: Usunięto niepotrzebne int()z ffunkcji. Dzięki isaacg

Edycja2: Usunięto LFna końcu pliku (dzięki @Rusher) i usunięto map()kosztem reduce()inicjalizacji (dzięki @ njzk2)

GolfScript, 27 bajtów

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

Przykłady:

$ 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

Bez golfa :

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

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

Odpowiednik 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 );
}

Wypróbuj online .

dc, 61 znaków

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

Myślę, że to całkiem niesamowite, że można to w ogóle rozwiązać za pomocą dc, ponieważ nie ma możliwości parsowania łańcuchów. Sztuka polega na tym, że 192.168.123.185 idzie na stos jako

.185
.123
192.168

i dXIr^*przesuwa kropkę dziesiętną w prawo o tyle cyfr ułamkowych, ile jest, i działa nawet na .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

Odejmij znak, jeśli dane wejściowe są już na stosie.

PowerShell - 112 108 92 78 bajtów

To mój pierwszy raz w golfa. Tutaj nic nie idzie:

Gra w golfa (stary):

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

Golfowy (nowy)

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

Nie golfowany:

$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

Stosowanie

Zapisz jako plik (w tym przypadku getipamount.ps1), a następnie zadzwoń z konsoli

getipamount.ps1 255.255.255.255 0.0.0.0

C # z LINQ - 139 bajtów

(Od 140 po zastosowaniu sugestii Boba).

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

Niegolfowany ....

    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 bajty

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

Licząc shebang jako dwa bajty.

Przykładowe użycie:

$ 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

Notatki

• vec eval,0,32jest drop-in dla ip2long. Perl pozwala wyrazić literały znakowe jako ich porządek poprzedzony a v, na przykład v0może być użyty do znaku null. Można je również połączyć w łańcuchy, na przykład v65.66.67.68→ ABCD. Gdy obecne są trzy lub więcej wartości, wartość początkowa vjest niepotrzebna. W vecinterpretuje jako funkcja ciąg tablicy całkowitej każda komórka z określonej liczby bitów (o, 32). unpack N,evalrównie dobrze by działał.

JavaScript ES6 - 68 bajtów

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

Wypróbuj z konsolą (naciśnij F12) Firefoksa.

Python 2.7, 104 bajty

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 bajty

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

Stosowanie:

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

Jest to już dłużej niż program Perla primo , więc nie jest zbyt interesujące.

Perl, 119 bajtów, dla przestarzałego formatu adresu IP

#!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

Stosowanie:

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

Ten program akceptuje przestarzały format adresów IP! Obejmuje to adresy zawierające 1, 2 lub 3 części lub części szesnastkowe lub ósemkowe. Cytując stronę podręcznika inet_addr (3) ,

Wartości określone za pomocą notacji kropkowej mają jedną z następujących postaci:

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

... Gdy podany jest trzyczęściowy adres, ostatnia część jest interpretowana jako liczba 16-bitowa i umieszczana w skrajnie prawych dwóch bajtach adresu sieciowego. ... Gdy podany jest adres dwuczęściowy, ostatnia część jest interpretowana jako 24-bitowa liczba i umieszczana w skrajnych trzech bajtach adresu sieciowego. ... Gdy podana jest tylko jedna część, wartość jest zapisywana bezpośrednio w adresie sieciowym bez zmiany kolejności bajtów.

Wszystkie liczby podawane jako `` części '' w notacji kropkowej mogą być dziesiętne, ósemkowe lub szesnastkowe, jak określono w języku C (tzn. Początkowe 0x lub 0X oznacza liczbę szesnastkową; wiodące 0 oznacza liczbę ósemkową; w przeciwnym razie liczba to interpretowane jako dziesiętne).

Większość programów nie akceptuje już tego przestarzałego formatu, ale ping 0177.1nadal działa w OpenBSD 5.5.

PHP, 138 110 bajtów

<?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 bajtów

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

Nie golfowany:

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 bajtów

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

Wypróbuj online!

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

Prawidłowo sformatowany

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

Ruby, 93 bajty

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}

Wydajność

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 bajtów

Pobiera ciągi IP z kropkami w kwadracie jako lewy i prawy argument.

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

Wyjaśnił:

>:@|@-&(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

Przykłady:

   '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

Współczynnik, 73 bajty

Tłumaczenie odpowiedzi CoffeeScript.

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

JavaScript ES6, 81 znaków

(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: Spróbuję zoptymalizować to trochę później.

Lua, 153 bajtów

Szkoda, że ​​lua nie ma funkcji podziału, musiałem zdefiniować swoją!

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)

Bez golfa

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

Galaretka , 12 bajtów, wyzwanie dla postdate języka

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

Wypróbuj online!

Wyjaśnienie

ṣ”.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

Liczba elementów w zakresie obejmującym stanowi bezwzględną różnicę ich punktów końcowych plus 1.

Aksjomat, 385 bajtów

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)))

rozkop go i przetestuj

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