¿Cuántas direcciones IP hay en un rango dado?

31

Inspirado por...

Redes: ¿cómo puedo calcular cuántas direcciones IP hay en un rango determinado?

Escriba un programa o función que tome dos cadenas como entrada, cada una de las cuales es una dirección IPv4 expresada en notación punteada estándar y genera o devuelve el número de direcciones IP cubiertas por este rango, incluidas las dos entradas de direcciones IP.

  • No debe usar ningún código externo, bibliotecas o servicios diseñados para analizar una dirección IP. (Se aceptan otras funciones de biblioteca estándar de procesamiento de cadenas).
  • Todas las 2 ^ 32 direcciones IP son iguales. No se hace distinción para transmitir, clase E, etc.
  • Se aplican reglas normales de código de golf.

Por ejemplo:

"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.
billpg
fuente
Vi esta pregunta en los programadores, y estaba pensando en hacerla en code golf lol.
Cruncher
3
Pensé que esta es una pregunta de StackOverflow sobre qué direcciones IP son imposibles según los estándares.
Ming-Tang
8
¿No es IPv4 un poco pasajero?
Ugoren

Respuestas:

20

GolfScript, 20 bytes

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

Pruébalo en línea.

Casos de prueba

$ 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

Cómo funciona

~]        # 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.
Dennis
fuente
Muy agradable, y buen uso $para evitar abs.
Chris Jester-Young
44
~]También es muy inteligente.
primo
10

Python 2 - 106

Véalo aquí .

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

Entrada de ejemplo

0.0.0.0
0.0.0.255

Salida de ejemplo

256

Perno de lluvia
fuente
1
def a():return reduce(lambda c,d:c*256+d,map(int,raw_input().split(".")))es mucho más corto
Michael M.
55
@ Michael Gracias por la sugerencia. Lo usé durante unos minutos, luego lo miré y pensé: "No escribí el 90% de eso". así que lo hice rodar
Rainbolt
@ Michael a=lambda:en lugar de def a():return guarda 6 caracteres
Avall
Es @Rusher 107 caracteres, no 106
Avall
1
@avall: Asumo que estás contando el LF final.
Dennis
8

CJam - 15

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

Pruébalo en http://cjam.aditsu.net/

Gracias Dennis, wow, no sé cómo sacar lo mejor de mi propio idioma: p

aditsu
fuente
Puede guardar dos bytes eliminando :i( bparece convertir a entero) y uno usando en {r...}2*lugar deqS/{...}/
Dennis
6

Bash puro, 66 bytes

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

Notas:

  • Define una función pque pasa una dirección IP decimal con puntos y genera la representación hexadecimal de esa dirección:
    • ${1//./ }es una expansión de parámetros que reemplaza .con en la dirección IP pasada ap()
    • La printfmayoría se explica por sí misma. Como solo hay un especificador de formato %02xy cuatro argumentos restantes, el especificador de formato se reutiliza para cada argumento restante, concatenando efectivamente los 2 dígitos hexadecimales de cada uno de los 4 octetos juntos
  • $[]causa expansión aritmética. Hacemos una resta básica y asignamos a la variabler
  • ${r/-}es una expansión de parámetros para eliminar un posible -personaje - efectivamente abs ()
  • Mostrar 1 + la diferencia absoluta para dar el rango.

Salida:

$ ./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
$ 
Trauma digital
fuente
Lo detecto printfy echo. ¿Son parte de eso bash?
CalculatorFeline
1
@CatsAreFluffy Son incorporados.
fase
6

Python 2.7 - 96 91 91 90 87

Hecho una función.

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

Uso:

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

Editar: eliminado innecesario int()de la ffunción. Gracias a isaacg

Edit2: Eliminado LFal final del archivo (gracias a @Rusher) y eliminado map()al costo del reduce()inicializador (gracias a @ njzk2)

avall
fuente
1
¿Por qué la función f necesita int () en el exterior?
isaacg
1
Bien. No tenía idea: D
avall
puede obtener 2 caracteres colocando el int en la reducción en lugar de usar el mapa (solo 2, ya que necesita agregar ,0parámetros a su función de reducción)
njzk2
Acabo de escribir algo que es casi exactamente su código, por lo que no me molestaré en enviarlo ahora. En realidad, ¡el mío es tres caracteres más largo!
danmcardle
5

GolfScript, 27 bytes

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

Ejemplos:

$ 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
Chris Jester-Young
fuente
2
Puede guardar un carácter utilizando en /lugar de %~.
Dennis
4

CoffeeScript - 94, 92, 7972

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

Sin golf :

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

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

JavaScript equivalente :

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

Pruébalo en línea .

Tony Ellis
fuente
1
Puede guardar algunos caracteres reemplazando algunos paréntesis con espacios: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
Parece que estás perdiendo mucho espacio Math.abs, pero no puedo encontrar nada más corto. (z>0)*z||-zes el mejor que tengo (misma longitud, y necesita una entrada de un solo carácter). ¿Tienes algo más inteligente que eso?
Aaron Dufour
Esta versión de JavaScript realmente me ayuda, he estado buscando esto durante una hora. ¡Gracias!
nodeffect
4

dc, 61 caracteres

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

Creo que es bastante sorprendente que esto se pueda resolver con DC ya que no tiene la capacidad de analizar cadenas. El truco es que 192.168.123.185 va a la pila como

.185
.123
192.168

y dXIr^*desplaza el punto decimal a la derecha tantos dígitos de fracción como haya e incluso funciona para .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

Reste un carácter si deja que la entrada ya esté en la pila.

Geoff Reedy
fuente
4

Powershell - 112 108 92 78 bytes

Esta es mi primera vez jugando al golf. Aquí va nada:

Golfizado (antiguo):

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

Golfizado (nuevo)

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

Sin golf:

$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

Uso

Guardar como archivo (en este caso getipamount.ps1) y luego llamar desde la consola

getipamount.ps1 255.255.255.255 0.0.0.0
SomeShinyMonica
fuente
4

C # con LINQ - 139 bytes

(A partir de 140 después de aplicar la sugerencia 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;}

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

billpg
fuente
¿Podría alguien explicarme cómo funciona todo este cambio de bytes?
Obversidad
@Obversity a.b.c.des equivalente a (a << 24) | (b << 16) | (c << 8) | (d << 0)es equivalente a (((a << 8) << 8) << 8) + ((b << 8) << 8) + (c << 8) + d). Básicamente, cada iteración de la agregación toma la suma existente y la desplaza a la izquierda un octeto, luego agrega el siguiente octeto.
Bob
Puedes guardar un personaje usando en c*256lugar de (c<<8).
Bob
@Bob Bien visto.
billpg
Puede guardar dos personajes más mediante la sustitución e-fcon e<f?f-e:e-fy soltando elMath.Abs()
Patrick Huizinga
4

Perl, 43 bytes

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

Contando el shebang como dos bytes.

Uso de muestra:

$ 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

Notas

  • vec eval,0,32es un drop-in para ip2long. Perl permite que los literales de caracteres se expresen como su ordinal prefijado con un v, por ejemplo, v0se puede usar para el carácter nulo. Estos también se pueden encadenar juntos, por ejemplo v65.66.67.68ABCD. Cuando hay tres o más valores, la inicial ves innecesaria. La vecfunción interpreta una cadena como una matriz entera, cada celda tiene el número especificado de bits (aquí, 32). unpack N,evalhabría funcionado igualmente también.
primo
fuente
3

JavaScript ES6 - 68 bytes

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

Pruébelo con la consola (presione F12) de Firefox.

Michael M.
fuente
Deberías estar usando alerto console.log. La salida de la consola es barata.
nderscore
44
@nderscore, absolutamente ninguna diferencia entre console.logy salida directa. Esto es código golf, no se trata de hacer código limpio.
Michael M.
La respuesta más votada a esta meta publicación no está de acuerdo: los estándares de JavaScript para IO . No es una cuestión de código limpio. Es una cuestión de no producir nada en realidad.
nderscore
@DigitalTrauma, no funcionará debido a la precedencia del operador . (adición vs cambio bit a bit)
Michael M.
2

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
Pablo Lucena
fuente
1
Gracias por la solucion. ¿Crees que podrías: 1. Cambiar de punto y coma a líneas nuevas, para facilitar la lectura sin sacrificar la longitud. 2. Explicar cómo funciona el código?
isaacg
2

Perl, 72 bytes

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

Uso:

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

Esto ya es más largo que el programa Perl de primo , por lo que no es demasiado interesante.

Perl, 119 bytes, para formato de dirección IP obsoleto

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

Uso:

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

¡Este programa acepta el formato obsoleto para las direcciones IP! Esto incluye direcciones con 1, 2 o 3 partes, o con partes hexadecimales u octales. Citando la página del manual inet_addr (3) ,

Los valores especificados usando la notación de puntos toman una de las siguientes formas:

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

... Cuando se especifica una dirección de tres partes, la última parte se interpreta como una cantidad de 16 bits y se coloca en los dos bytes más a la derecha de la dirección de red. ... Cuando se proporciona una dirección de dos partes, la última parte se interpreta como una cantidad de 24 bits y se coloca en los tres bytes más a la derecha de la dirección de red. ... Cuando solo se proporciona una parte, el valor se almacena directamente en la dirección de red sin reordenamiento de bytes.

Todos los números suministrados como `` partes '' en una notación de puntos pueden ser decimales, octales o hexadecimales, como se especifica en el lenguaje C (es decir, un 0x o 0X inicial implica hexadecimal; un 0 inicial implica octal; de lo contrario, el número es interpretado como decimal).

La mayoría de los programas ya no aceptan este formato obsoleto, pero ping 0177.1aún funcionan en OpenBSD 5.5.

kernigh
fuente
El hecho de que esté usando BSD es más sorprendente que lo de IP.
fase
2

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');
Vitaly Dyatlov
fuente
Como no hay mención de 'advertencias de desaprobación', puede guardar un personaje reemplazándolo explode('.',"$a.$b")por split('\.',"$a.$b").
MrLore
Cuento 109, no 110. Ahorre 9 bytes con un programa en lugar de una función y 8 más con estos pasos de golf: sandbox.onlinephpfunctions.com/code/…
Titus
1

Mathematica 9, 108 bytes

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

Sin golf:

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]]
]
Ian Douglas
fuente
0

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

Formateado adecuadamente

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

tia
fuente
0

Rubí, 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}

Salida

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
bsd
fuente
0

J, 25 bytes

Toma las cadenas de IP de cuatro puntos como argumentos izquierdo y derecho.

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

Explicado:

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

Ejemplos:

   '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
Algoritmo de tiburón
fuente
0

Factor, 73 bytes

Traducción de la respuesta CoffeeScript.

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

Javascript ES6, 81 caracteres

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

Prueba:

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

PD: Intentaré optimizarlo un poco más tarde.

Qwertiy
fuente
0

Lua, 153 bytes

Es una pena que lua no tenga una función dividida, ¡tuve que definir la mía!

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)

Sin golf

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
Katenkyo
fuente
0

Jelly , 12 bytes, desafío de fechas posteriores al idioma

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

Pruébalo en línea!

Explicación

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

El número de elementos en un rango inclusivo es la diferencia absoluta de sus puntos finales, más 1.


fuente
0

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

deshazte de él y prueba

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