에서 영감을 받다...

네트워킹-주어진 범위에 몇 개의 IP 주소가 있는지 어떻게 알 수 있습니까?

두 개의 문자열을 입력으로 사용하는 프로그램 또는 함수를 작성하십시오. 각 문자열은 표준 점 표기법으로 표현 된 IPv4 주소이며 두 개의 IP 주소 입력을 포함하여이 범위가 적용되는 IP 주소 수를 출력하거나 리턴합니다.

• IP 주소를 구문 분석하도록 설계된 외부 코드, 라이브러리 또는 서비스를 사용해서는 안됩니다. (다른 문자열 처리 표준 라이브러리 함수도 허용됩니다.)
• 모든 2 ^ 32 IP 주소가 동일합니다. 방송, 클래스 E 등은 구별되지 않습니다.
• 일반적인 코드 골프 규칙이 적용됩니다.

예를 들면 다음과 같습니다.

"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 바이트

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

온라인으로 사용해보십시오.

테스트 사례

$ 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

작동 원리

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

파이썬 2-106

여기를 참조 하십시오 .

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

입력 예

0.0.0.0
0.0.0.255

출력 예

256

CJam-15

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

http://cjam.aditsu.net/ 에서 시도 하십시오

고마워 Dennis, 와우, 나는 내 언어를 최대한 활용하는 방법을 모른다 : p

순수한 bash, 66 바이트

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

노트:

• p점으로 구분 된 10 진수 IP 주소로 전달 되는 함수 를 정의하고 해당 주소의 16 진 표현을 출력합니다.
  • ${1//./ }을 대체하는 매개 변수 확장이다 .와 IP 주소가 전달이p()
  • 는 printf대부분 자기 설명이다. 하나의 형식 지정자 %02x와 나머지 4 개의 인수가 있으므로 나머지 지정 인수마다 형식 지정자를 재사용하여 4 개의 8 진수 각각의 2 개의 16 진수를 효과적으로 연결합니다.
• $[]산술 확장을 일으 킵니다. 기본 뺄셈을하고 변수에 대입합니다r
• ${r/-}가능한 -문자 를 제거하는 매개 변수 확장입니다. 효과적으로 abs ()
• 범위를 제공하기 위해 1 + 절대 차이를 표시하십시오.

산출:

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

파이썬 2.7- 96 91 90 87

기능을 만들었습니다.

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

용법:

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

편집 : 기능 int()에서 불필요한 제거 f. isaacg 덕분에

Edit2 :LF 파일 끝에서 제거 (@Rusher 덕분) 및 초기화 map()비용으로 제거 reduce()(@ njzk2 덕분)

GolfScript, 27 바이트

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

예 :

$ 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

언 골프 :

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

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

동등한 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 );
}

온라인으로 사용해보십시오 .

dc, 61 자

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

문자열을 구문 분석 할 수 없기 때문에 dc 로이 문제를 해결할 수 있다는 것이 놀랍습니다. 요령은 192.168.123.185가 스택에서

.185
.123
192.168

그리고 dXIr^*거기에 그것도 .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

입력을 이미 스택에 놓은 경우 문자를 빼십시오.

파워 쉘 - 112 108 92 78 바이트

이것은 내 첫 골프입니다. 여기에는 아무 것도 없습니다.

골프 (구) :

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

골프 (신규)

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

언 골프 드 :

$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

용법

파일 (이 경우 getipamount.ps1)로 저장 한 다음 콘솔에서 호출하십시오.

getipamount.ps1 255.255.255.255 0.0.0.0

LINQ가있는 C #-139 바이트

(Bob의 제안을 적용한 후 140부터)

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

언 골프 ....

    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

펄, 43 바이트

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

shebang을 2 바이트로 계산합니다.

샘플 사용법 :

$ 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

노트

• vec eval,0,32에 대한 드롭 인입니다 ip2long. Perl을 사용하면 문자 리터럴을 앞에 서수로 접두어로 표시 할 수 있습니다 ( v예 : v0널 문자에 사용할 수 있음). 예를 들어 v65.66.67.68→ 와 같이 연결될 수도 있습니다 ABCD. 세 개 이상의 값이 있으면 초기 값 v이 필요하지 않습니다. 이 vec함수는 문자열을 정수 배열로 해석하며 각 셀에는 지정된 비트 수 (여기서는 32)가 있습니다. unpack N,eval똑같이 일했을 것입니다.

자바 스크립트 ES6-68 바이트

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

Firefox 콘솔 (F12 누름)로 사용해보십시오.

파이썬 2.7, 104 바이트

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

펄, 72 바이트

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

용법:

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

이것은 이미 primo의 Perl 프로그램 보다 길기 때문에 너무 흥미롭지 않습니다.

더 이상 사용되지 않는 IP 주소 형식의 경우 Perl (119 바이트)

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

용법:

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

이 프로그램은 더 이상 사용되지 않는 IP 주소 형식을 허용합니다! 여기에는 1, 2 또는 3 개의 부분이 있거나 16 진 또는 8 진 부분이있는 주소가 포함됩니다. inet_addr (3) 매뉴얼 페이지를 인용하면 ,

점 표기법을 사용하여 지정된 값은 다음 형식 중 하나를 사용합니다.

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

... 3 개 부품 주소가 지정되면 마지막 부품은 16 비트 수량으로 해석되어 네트워크 주소의 가장 오른쪽 2 바이트에 배치됩니다. ... 2 개의 부품 주소가 제공되면 마지막 부품은 24 비트 수량으로 해석되어 네트워크 주소의 가장 오른쪽 3 바이트에 배치됩니다. ... 한 부분 만 제공되면 바이트 재 배열없이 네트워크 주소에 직접 값이 저장됩니다.

점 표기법에서``부품 ''으로 제공되는 모든 숫자는 C 언어에 지정된 10 진수, 8 진수 또는 16 진수 일 수 있습니다 (즉, 선행 0x 또는 0X는 16 진수를 의미하고 선행 0은 8 진수를 의미하고 그렇지 않으면 숫자는 10 진수로 해석 됨).

대부분의 프로그램은 더 이상이 더 이상 사용되지 않는 형식을 허용하지 않지만 ping 0177.1여전히 OpenBSD 5.5에서 작동했습니다.

PHP, 138110 바이트

<?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 바이트

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

언 골프 드 :

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 바이트

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

온라인으로 사용해보십시오!

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

올바른 형식

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

루비, 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}

산출

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 바이트

점으로 구분 된 쿼드 IP 문자열을 왼쪽 및 오른쪽 인수로 사용합니다.

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

설명 :

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

예 :

   '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

팩터, 73 바이트

CoffeeScript 답변의 번역.

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

자바 스크립트 ES6, 81 자

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

테스트:

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

추신 : 나중에 조금 최적화하려고합니다.

루아, 153 바이트

루아가 스플릿 기능을 가지고 있지 않다는 것은 부끄러운 일입니다. 내 정의해야했습니다!

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)

언 골프

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

젤리 , 12 바이트, 언어 날짜 도전 과제

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

온라인으로 사용해보십시오!

설명

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

포함 범위의 요소 수는 끝점의 절대 차이에 1을 더한 값입니다.

공리, 385 바이트

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

그것을 풀고 테스트

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