Escreva a função mais curta para converter um endereço IP em sua representação inteira e faça a saída como um inteiro.

Para alterar um endereço IPv4 para sua representação inteira, é necessário o seguinte cálculo:

• Divida o endereço IP em quatro octetos.
• (Octet1 * 16777216) + (Octet2 * 65536) + (Octet3 * 256) + (Octet4)

Entrada de amostra

192.168.1.1           10.10.104.36           8.8.8.8

Saída de amostra

3232235777            168454180              134744072

PHP - 21 caracteres

<?=ip2long($argv[1]);

MySQL - 20 caracteres

SELECT INET_ATON(s);

Ruby (sem builtins / eval) - 47

s=->s{s.split(".").inject(0){|a,b|a<<8|b.to_i}}

Teste:

s["192.168.1.1"]
3232235777

C: 79 caracteres

main(i,a)char**a;{i=i<<8|strtol(a[1],a+1,0);*a[1]++?main(i,a):printf("%u",i);}

EDIT: C ++ removido, não seria compilado sem cabeçalhos; com o GCC, as chamadas de função printfe strtolacionam funções internas; portanto, os cabeçalhos podem ser ignorados. Obrigado a @ugoren pelas dicas. Isso irá compilar como está sem opções adicionais para gcc.

EDIT2: returné realmente redundante :)

Golfscript - 16 caracteres

{[~]2%256base}:f

Como um programa independente, isso é ainda mais curto aos 11 anos.

~]2%256base

Extremamente direto. Avalia a string de entrada ( ~) e a coloca em uma matriz []. Como os .s na sequência duplicam a parte superior da pilha, usamos apenas todos os outros termos na matriz ( 2%). Agora temos uma matriz que basicamente representa um número 256 básico, então usamos uma função interna para fazer a conversão. ( 256base)

Befunge - 2x11 = 22 caracteres

Tão perto, Befunge vai ganhar um dia.

>&+~1+#v_.@
^*4*8*8<

Explicação

A maior característica distintiva do Befunge é que, em vez de ser um conjunto linear de instruções, como a maioria dos idiomas; é uma grade 2D de instruções de caracteres únicos, onde o controle pode fluir em qualquer direção.

>      v
^      <

Esses caracteres mudam a direção do controle quando são atingidos, isso faz o loop principal.

 &+~1+

Isso insere um número e o empurra para a pilha ( &), retira os dois principais valores da pilha, os adiciona e os empurra de volta para a pilha ( +), insere um único caractere e coloca seu valor ascii na pilha ( ~); coloca 1 na pilha e os adiciona ( 1+).

O intérprete que eu estou usando retorna -1 para o final da entrada, alguns retornam 0 para que a 1+parte possa ser removida.

      #v_.@

O #faz com que o próximo caractere a ser ignorado, então os _pops um valor fora da pilha e se ele é zero envia controle direita, caso contrário, envia-o para a esquerda. Se o valor for zero, .um valor é retirado da pilha e o gera como um número inteiro e @para o programa. Caso contrário, venvia o controle para o loop de retorno.

^*4*8*8<

Isso simplesmente multiplica o valor superior da pilha por 256 e retorna o controle ao início.

Rubi (40)

q=->x{x.gsub(/(\d+)\.?/){'%02x'%$1}.hex}

->

q["192.168.1.1"]
=> 3232235777

Ruby - 46 caracteres

require"ipaddr"
def f s;IPAddr.new(s).to_i;end

Golfscript - 21 caracteres

{'.'/{~}%{\256*+}*}:f

Python 56 45

c=lambda x:eval('((('+x.replace('.','<<8)+'))

C ++ - muitos caracteres

#include <boost/algorithm/string.hpp>
#include <string>
#include <vector>
uint f(std::string p)
{
        std::vector<std::string> x;
        boost::split(x,p,boost::is_any_of("."));
        uint r=0;
        for (uint i = 0; i < x.size(); i++)
                r=r*256+atoi(x[i].c_str());
        return r;
}

PowerShell 66 61

Variação na resposta de Joey:

filter I{([ipaddress](($_-split'\.')[3..0]-join'.')).address}

PS C:\> '192.168.1.1' | I
3232235777
PS C:\> '10.10.104.36' | I
168454180
PS C:\> '8.8.8.8' | I
134744072

AWK em ~ 47 caracteres

Iniciante aqui ... Hum, não sei como contar isso, mas sem o 'eco' são 47 caracteres no AWK. (Não é exatamente um golfe falso, mas está no buraco.)

echo $addr | /bin/awk -F\. '{print $1*16777216+$2*65536+$3*256+$4}'

Dia inteiro cedo para #tbt também, então eu realmente cumpri uma agenda !!! * 8-)

Dia da bandeira.

Bash - 46

Tabela de conteúdo

Você encontrará 4 versões de golfe diferentes:

echo $[_=32,`printf "%d<<(_-=8)|" ${1//./ }`0]                        # 46chr
set -- ${1//./ };echo $[$1<<24|$2<<16|$3<<8|$4]                       # 47chr
v=('|%d<<'{24,16,8,0});printf -vv "${v[*]}" ${1//./ };echo $[0$v]     # 65chr
mapfile -td. i<<<$1;for((a=o=0;a<4;o+=i[a]<<(3-a++)*8)){ :;};echo $o  # 68chr

Nova versão! 2018-11-15 Mais golfe, 46 caracteres

echo $[_=32,`printf "%d<<(_-=8)|" ${1//./ }`0]

Explicação

• Eu costumava $_jogar mais golfe.
• A sintaxe ${1//./ }substituirá todos os pontos .por espaços .
• então printfvai render algo como192<<(_-=8)|168<<(_-=8)|1<<(_-=8)|1<<(_-=8)|
• então adicionaremos um 0depois do último OR | e
• predefinido _para 32 . o bash lerá a construção da esquerda para a direita, então $((_-=8))faça 24no 1º turno , 16no segundo e assim por diante.

em ação:

set -- 192.168.1.1
echo $[_=32,`printf "%d<<(_-=8)|" ${1//./ }`0]
3232235777

Por diversão: tentando obter $_conteúdo, depois disso:

echo $_
3232235777

; -b

set -- 192.168.1.1
echo $_ $[_=32,`printf "%d<<(_-=8)|" ${1//./ }`0] $_
192.168.1.1 3232235777 0

Ok, está correto 32 - 4 x 8 = 0

Em uma função:

ip2int() {
    echo $[_=32,`printf "%d<<(_-=8)|" ${1//./ }`0]
}
ip2int 192.168.1.1
3232235777
ip2int 255.255.255.255
4294967295
ip2int 0.0.0.0
0

ou em um loop: -> 60

ip2int() {
    for i;do
        echo $[_=32,`printf "%d<<(_-=8)|" ${i//./ }`0]
    done
}

ip2int 192.168.1.1 10.10.104.36 8.8.8.8 1.1.1.1 255.255.255.255 0.0.0.0
3232235777
168454180
134744072
16843009
4294967295
0

bash (v4.1 +): 47

Primeiro post

set -- ${1//./ };echo $[$1<<24|$2<<16|$3<<8|$4]

Explicação:

• A sintaxe ${1//./ }substituirá todos os pontos .por espaços.
• set --definir parâmetros posicionais ($@=($1 $2 $3...) )
• Assim set -- ${1//./ }será dividido $1por pontos e set $1, $2, $3e $4se string containg 3pontos (e sem espaços).

em ação:

set -- 192.168.1.1
set -- ${1//./ };echo $[$1<<24|$2<<16|$3<<8|$4]
3232235777

ou em uma função:

ip2int() {
    set -- ${1//./ }
    echo $[$1<<24|$2<<16|$3<<8|$4]
}
ip2int 192.168.1.1
3232235777
ip2int 0.0.0.0
0

ou em um loop: -> 61

for i;do set -- ${i//./ };echo $[$1<<24|$2<<16|$3<<8|$4];done

em ação:

ip2int() {
    for i;do
        set -- ${i//./ }
        echo $[$1<<24|$2<<16|$3<<8|$4]
    done
}

ip2int 192.168.1.1 10.10.104.36 8.8.8.8 1.1.1.1 0.0.0.0
3232235777
168454180
134744072
16843009
0

Outra versão com golfe diferente: 65

v=('|%d<<'{24,16,8,0});printf -vv "${v[*]}" ${1//./ };echo $[0$v]

Amostra:

ip2int() {
    v=('|%d<<'{24,16,8,0});printf -vv "${v[*]}" ${1//./ };echo $[0$v]
}

ip2int 255.255.255.255
4294967295
ip2int 10.10.104.36
168454180

Em um loop (+14): 82

ip2int() {
    for i;do
        v=('|%d<<'{24,16,8,0})
        printf -vv "${v[*]}" ${1//./ }
        echo $[0$v]
    done
}

* ou um pouco mais feio: 70 *

v=('|%d<<'{24,16,8});printf -vv "${v[*]}" ${1//./ };echo $[0${v%<<2*}]

onde printfdar um barbante como |192<<24 |168<<16 |1<<8|1<<24 |0<<16 |0<<8se tivéssemos que cortar finalmente <<2....

jogou golfe com mapfilemais tempo: 68

ip2int() {
    mapfile -td. i<<<$1;for((a=o=0;a<4;o+=i[a]<<(3-a++)*8)){ :;};echo $o
}

ou com laço: 82

ip2int() {
    for a;do
      mapfile -td. i<<<$a;for((a=o=0;a<4;o+=i[a]<<(3-a++)*8)){ :;};echo $o
    done
}

Windows PowerShell, 70

Abordagem ingênua:

filter I{[int[]]$x=$_-split'\.'
$x[0]*16MB+$x[1]*64KB+$x[2]*256+$x[3]}

Com o uso de System.Net.IPAddress: 76

filter I{([ipaddress]($_-replace('(.+)\.'*3+'(.+)'),'$4.$3.$2.$1')).address}

Teste:

> '192.168.1.1'|I
3232235777

Befunge-93 - 36 caracteres

&"~"2+::8****&884**:**&884***&++++.@

Perl: DIY (para oneliners.) (40)

$j=3;$i+=($_<<($j--*8))for split/\./,$x;

# Use valor em $ i

Função DIY (65):

sub atoi{my($i,$j)=(0,3);$i+=($_<<($j--*8))for split'.',shift;$i}

Haskell - 14 caracteres

(.) a=(256*a+)

uso no GHCi:

Prelude> let (.) a=(256*a+)
Prelude> 192. 168. 0. 1
3232235521

O único problema é que você deve colocar espaços à esquerda ou à direita do ponto, caso contrário, os números serão interpretados como ponto flutuante.

C # - 77 caracteres

Func<string,uint>F=s=>s.Split('.').Aggregate(0u,(c,b)=>(c<<8)+uint.Parse(b));

JavaScript (45 caracteres)

Requer suporte para o .reduce()método Array, introduzido no ES5 e nas funções de seta .

f=(x)=>x.split('.').reduce((p,c)=>p<<8|c)>>>0

Powershell, 47 43 bytes

$args-split'\.'|%{$r=([long]$r-shl8)+$_};$r

Script de teste:

$f = {

$args-split'\.'|%{$r=([long]$r-shl8)+$_};$r

}

@(
    ,("192.168.1.1",3232235777)
    ,("10.10.104.36",168454180)
    ,("8.8.8.8",134744072)
) | % {
    $s,$expected = $_
    $result = &$f $s
    "$($result-eq$expected): $result"
}

Resultado:

True: 3232235777
True: 168454180
True: 134744072

C # - 120 caracteres

float s(string i){var o=i.Split('.').Select(n=>float.Parse(n)).ToList();return 16777216*o[0]+65536*o[1]+256*o[2]+o[3];}

Meu primeiro código de golfe - seja gentil;)

D: 84 caracteres

uint f(S)(S s)
{
    uint n;
    int i = 4;

    foreach(o; s.split("."))
        n += to!uint(o) << 8 * --i;

    return n;
}

Python 3,2 (69)

sum((int(j)*4**(4*i)) for i,j in enumerate(input().split('.')[::-1]))

PHP (sem builtins / eval) - 54

<foreach(explode(".",$argv[1])as$b)$a=@$a<<8|$b;echo$a;

Perl, 14 caracteres:

sub _{unpack'L>',pop}

# Example usage
print _(10.10.104.36) # prints 168454180

Stax , 9 bytes

üL▼ü╛tΓi╨

Execute e depure

05AB1E , 5 bytes

'.¡₁β

Experimente online!

Perl 6 , 16 bytes

{:256[m:g/\d+/]}

Experimente online!

C (gcc) -m32 / POSIX, 33 bytes

f(a){inet_aton(a,&a);a=ntohl(a);}

Experimente online!

Em uma plataforma big-endian, você poderia simplesmente definir uma macro com -Df=inet_atonpara 13 bytes .