Esto me recuerda cuando hace unos años alguien subió un torrent "Herramienta de hackers: lista completa de todas las direcciones IP". Esto era, por supuesto, solo una lista generada de los ~ 4 mil millones de direcciones IPv4, pero miles de "h4xx0rz" la descargaron. ¡Mira mamá, imahacker!

Esto fue entonces, pero hoy en día todo el mundo ha cambiado a IPv6 . (¿Derecho?)

Su tarea es escribir un programa que imprima todas las direcciones IPv6 .

Debe escribir un programa completo que no reciba entradas e imprima direcciones IPv6, una por línea y ninguna otra salida. Su programa debe imprimir las 2 ¹²⁸ direcciones posibles, incluidas las no válidas. Cada dirección debe imprimirse exactamente una vez. Puede imprimir las direcciones en cualquier orden.

Cada dirección puede imprimirse en su totalidad, con 8 grupos de 4 dígitos hexadecimales separados por dos puntos, p. Ej.

2001:0db8:85a3:0000:0000:8a2e:0370:7334

Puede, a su discreción, usar cualquiera de las abreviaturas estándar de RFC 5952 :

• Los ceros a la izquierda en un grupo pueden omitirse, excepto que 0no pueden abreviarse más.
• :: se puede usar como máximo una vez por dirección para abreviar una secuencia de uno o más grupos todos cero.
• Los dígitos hexadecimales pueden usar minúsculas o mayúsculas.

Si cumple con la recomendación de representación de RFC 5952 (solo letras minúsculas, la representación más corta posible, se ::usa lo antes posible si hay varios lugares donde se puede usar), obtiene un bono de -20% .

Debido al tamaño de la salida, no se espera que su programa termine mientras estamos sentados allí. Su programa puede ser interrumpido por medios externos en algún momento ( Ctrl+ C, desconectando la alimentación, ...). Su programa debe producir resultados como una secuencia, de modo que después de una espera "razonable", haya producido algunas líneas. Básicamente, no está permitido construir una cadena gigante en la memoria solo para imprimirla al final. Cualquier programa que se quede sin memoria en una PC "estándar" queda descalificado. (No obstante, si su programa se dejó ejecutar durante el tiempo suficiente, debe imprimir todas las direcciones IPv6 y luego salir).

(Si esta condición es un problema para los intérpretes web que ejecutan el programa hasta su finalización y luego le permiten ver el resultado, y no tiene un intérprete alojado, pruebe su programa en una versión más pequeña del problema y luego ajústelo cuidadosamente al completo 2 ^128. )

Su puntaje es la longitud de su programa en bytes, multiplicado por 0.8 si obtiene el bono. Es el código de golf, por lo que gana el puntaje más bajo.

Pyth, 21 bytes

KJ^8CdWJj\:ct.H+K=tJ4

Utiliza un bucle while con Jla variable iterador. Inicializa el máximo usando 8^chr(' '). Al agregar ese valor inicial, se convierte en hexadecimal y luego se elimina el primer carácter.

Python 3, 65 bytes · 0.8 = 52.0

from ipaddress import*
n=4**64
while n:n-=1;print(IPv6Address(n))

Pyth, 27 25 24 bytes

Nota: el código tenía un error anteriormente, corrigiéndolo se guardó 1 byte

J^4 64WJj\:c%"%032x"=tJ4

Imprime las direcciones como

ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff
ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffe
ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffd
ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffc
...
0000:0000:0000:0000:0000:0000:0000:0003
0000:0000:0000:0000:0000:0000:0000:0002
0000:0000:0000:0000:0000:0000:0000:0001
0000:0000:0000:0000:0000:0000:0000:0000

Versión anterior (más complicada) que usa el operador de plataforma (también 24 bytes):

J^4 64WJj\:c.[\032.H=tJ4

Explicación

J^4 64                  set J to 2^128
WJ                     while J is not 0:
            =tJ               decrement J
    %"%032x"                 format to length-32 hex string
   c           4            split every 4 chars
j\:                        join by : and print

Pyth, 21 bytes (no válido)

jmj\:c.[\032.Hd4^4 64

Esto no se puede ejecutar ya que 1) consumiría al menos 2 ¹³² bytes (2 ⁵² yobibytes) de memoria y 2) al intérprete no le gusta (2 ¹²⁸ no encaja ssize_t, por lo que no hay lists de ese tamaño) . Imprimiría las direcciones en orden lexicográfico. Puede probar el algoritmo cambiando los números al final a algo utilizable.

C (con extensiones GCC), 76 bytes * 0.8 = 60.8

__uint128_t i;main(){char s[50];for(;inet_ntop(10,&i,s,49),puts(s),++i>0;);}

Esto utiliza la extensión GCC de enteros de 128 bits para simplemente contar desde ::hasta ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff. inet_ntop()formatea correctamente cada dirección para que se pueda reclamar el bono de -20%.

Salida

Utilizando la sedsalida de cada línea millonésima hasta 10 millones:

$ ./ipv6all | sed -n '1~1000000p;10000000q'
::
4042:f00::
8084:1e00::
c0c6:2d00::
9:3d00::
404b:4c00::
808d:5b00::
c0cf:6a00::
12:7a00::
4054:8900::
$ 

Tenga en cuenta que estoy usando una máquina little-endian x86_64, y que las direcciones de red generalmente siempre están en orden de red (big-endian), por lo que la endianidad se intercambia de manera efectiva mediante el uso inet_ntop(). Esto no importa: todas las direcciones se mostrarán (eventualmente).

CJam, 36 27 bytes

G32#{(_"%032x"e%4/':*oNo}h;

-9 bytes gracias a @Dennis (olvidé que CJam tiene formato de cadena). Imprime las direcciones en minúsculas y descendentes.

Por razones obvias, use el intérprete de Java, no el en línea. Sin G32#embargo, puede reemplazarlo por algo más pequeño para probar en línea, por ejemplo, aquí están los últimos 100 .

Explicación

G32#             16^32 = 2^128. Call this n
{ ... }h;        While loop. The final ; is to pop n at the end
 (               Decrement n
 _               Copy n
 "%032x"e%       String format to hex, padded to 32 digits
 4/              Split into groups of 4
 ':*             Join with colons
 oNo             Output with newline

Python 2.7, 67 bytes

n=4**64
while n:n-=1;s='%032x'%n;exec"s=s[4:]+':'+s[:4];"*7;print s

Como efecto secundario del método utilizado para insertar los dos puntos, las direcciones se imprimen con la columna más a la derecha que aparece a la izquierda:

ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff
fffe:ffff:ffff:ffff:ffff:ffff:ffff:ffff
fffc:ffff:ffff:ffff:ffff:ffff:ffff:ffff
...
0003:0000:0000:0000:0000:0000:0000:0000
0002:0000:0000:0000:0000:0000:0000:0000
0001:0000:0000:0000:0000:0000:0000:0000

Verilog, 335

Mi primera presentación de Verilog, probablemente podría usar más golf, pero no tengo la energía para hacerlo en este momento. ces reloj, oes salida ASCII. No califica para el bono de formato debido a cero relleno en lugar de abreviar.

module b(output[0:38]o,input c);reg[127:0]a;wire[0:39]d;assign o=d[0:38];always @(posedge c) a<=a+(~(&a));genvar i,j;generate for(i=0;i<8;i=i+1) begin:q for(j=0;j<4;j=j+1) begin:r assign d[5*i+j]=a[16*i+4*j:16*i+4*j+7]>9?{4'h6,a[16*i+4*j:16*i+4*j+7]-9}:{4'h3,a[16*i+4*j:16*i+4*j+7]};end assign d[5*i+4]=8'h3A; end endgenerate endmodule

Esta es una iteración simple seguida de un poco de giro de bits para hacer la salida ASCII. Corté el colon después del último grupo con un pequeño truco. Sintetiza y parece funcionar para xc3s500e-4ft256-4 en ISE 13.7 lin64.

C, 91-126 bytes

Mi versión original, 119 bytes.

long a[9],i;
f(long*x){if(65536&++*x)*x=0,f(x+1);}
main(){for(;!a[8];f(a))for(i=7;i+1;i--)printf(i?"%lx:":"%lx\n",a[i]);}

La mejor versión de golf portátil-ish, 103 bytes (gracias @Dennis por algunos de estos conceptos)

long*p,a[9];
main(i){while(!a[8]){
for(i=8;i--;printf(i?"%lx:":"%lx\n",a[i]));
for(p=a;++*p>>16;*p++=0);}}

Explicación: El algoritmo en sí es razonablemente sencillo. Utilicé int en lugar de unsigned porque es más corto. Declararlos a nivel de archivo significa que todo está preinicializado con ceros. La ffunción es un incremento simple con carry que opera en los 16 bits bajos de cada palabra. El bucle termina cuando se lleva al bit 129.

Iterar hacia atrás para printf significa que imprimimos las direcciones en el orden "correcto" y también el cheque para imprimir una nueva línea tiene unos pocos caracteres más cortos.

Esto usa algunas construcciones no portátiles. Se considera mejor como un dialecto K&R de C, ya que utiliza tipos de retorno int implícitos y no incluye stdio.h. Y mi uso de long fue informado por esto: en la mayoría de los sistemas modernos int es suficiente porque son 32 bits. Esto probablemente podría ejecutarse sin modificaciones en PDP-11 Unix.

Sin embargo, puede ser más corto. Si suponemos que podemos usar int (ya sea como un tipo más ancho que 16 bits, o un tipo de exactamente 16 bits con varias propiedades que resultan ser ciertas en muchos sistemas, como dos complemento y rollover aritmético), podemos deshacernos de las cosas relacionadas con el uso de largo.

Versión para int más ancho que 16 bits, 97 bytes.

a[9],*p;main(i){while(!a[8]){
for(i=8;i--;printf(i?"%x:":"%x\n",a[i]));
for(p=a;++*p>>16;*p++=0);}}

Versión para sistemas de 16 bits, 91 bytes.

a[9],*p;main(i){while(!a[8]){
for(i=8;i--;printf(i?"%x:":"%x\n",a[i]));
for(p=a;!++*p;p++);}}

Curiosamente, sin embargo, el original K. & R compilador no que realmente apoyan la declaración sin int (que compila bien, pero trata a las variables como externa y por lo tanto sin definir en tiempo de enlace), por lo que se necesitan otros tres bytes adicionales para cambiar la declaración int*p,a[9];de un total de 94.

Además, si la suposición de que se interrumpe antes de completar la salida fuera una restricción difícil, podríamos eliminar la verificación final, ahorrando cinco bytes.

Bonificación: versión portátil totalmente ANSI, 126 bytes:

#include<stdio.h>
long*p,i,a[9];
int main(){while(!a[8]){
for(i=8;i--;printf(i?"%lx:":"%lx\n",a[i]));
for(p=a;++*p>>16;*p++=0);}}

Las líneas nuevas en todas las versiones se insertan para facilitar la lectura y en ubicaciones donde no se requiere espacio en blanco, y se excluyen del recuento de bytes, a excepción de la línea nueva después de la #includelínea en la versión ANSI.

Todas las versiones, excepto la versión ANSI, caen al final de main y, por lo tanto, pueden devolver un código de salida falso al sistema operativo.

AutoIt3, 142 231 Bytes

For $a=0 To 2^32-1
For $b=0 To 2^32-1
For $c=0 To 2^32-1
For $d=0 To 2^32-1
$s=StringFormat("%08x%08x%08x%08x",$a,$b,$c,$d)
For $j=0 To 8
ConsoleWrite(StringMid($s,$j*4+1,4)&($j<7?":":""))
Next
ConsoleWrite(@LF)
Next
Next
Next
Next

Explicación

• For $a=0 To 2^32-1: Iterar 4 veces sobre 0-2 ^ 32 ((2 ^ 32) ^ 4 = 2 ^ 128) combinaciones posibles.
• $s=StringFormat("%08x%08x%08x%08x",$a,$b,$c,$d): Convierte los números en una cadena hexadecimal con una longitud de 32 (4 * 32).
• For $j=0 To 8: Itera sobre las 8 secciones de la cadena.
• ConsoleWrite(StringMid($s,$j*4+1,4)&($j<7?":":"")): Extraiga los siguientes 4 caracteres de la cadena y agregue dos puntos ( :) al final, si no hemos llegado a la última sección, luego envíe todo a la consola
• Next: Finaliza el bucle for interno
• ConsoleWrite(@LF): Agregar un avance de línea al final de la línea
• Next: Fin de los bucles for externos

Tamaño de salida esperado: (Una línea (39 bytes) + avance de línea) (= 40 bytes) * 2 ^ 128 = 1.361 * 10 ^ 16 YB (yottabytes)

Chicle de canela, 16 bytes

0000000: 678b 36d0 b54c d44d 8bc5 455b 8d0c 0500  g.6..L.M..E[....                               .

Pruébalo en línea. (TIO limita la salida)

Explicación

El gmodo pone Cinnamon Gum en modo generar . El resto de la cadena se descomprime en esta expresión regular:

[0-9a-f][0-9a-f][0-9a-f][0-9a-f]:[0-9a-f][0-9a-f][0-9a-f][0-9a-f]:[0-9a-f][0-9a-f][0-9a-f][0-9a-f]:[0-9a-f][0-9a-f][0-9a-f][0-9a-f]:[0-9a-f][0-9a-f][0-9a-f][0-9a-f]:[0-9a-f][0-9a-f][0-9a-f][0-9a-f]:[0-9a-f][0-9a-f][0-9a-f][0-9a-f]:[0-9a-f][0-9a-f][0-9a-f][0-9a-f]

Luego crea un generador de todas las cadenas posibles que coinciden con la expresión regular e itera a través de ella, imprimiendo cada una.

De forma algo divertida, la expresión regular de golf en ([0-9a-f]{4,4}:){7,7}[0-9a-f]{4,4}realidad se comprime en una cadena más larga que la expresión regular anterior.

Commodore BASIC 2.0, 339 bytes

Para obtener dígitos hexadecimales en minúsculas, este programa está escrito en "modo desplazado" (presione <SHIFT>+<C=>)

1k=65535:a=0
2fOb=0tok:fOc=0tok:fOd=0tok:fOe=0tok:fOf=0tok:fOg=0tok:fOh=0tok
3x=a:goS6:?":";:x=b:goS6:?":";:x=c:goS6:?":";:x=d:goS6:?":";:x=e:goS6:?":";:x=f
4goS6:?":";:x=g:goS6:?":";:x=h:goS6:?
5nE:nE:nE:nE:nE:nE:nE:nE:a=a+1:ifa<65536tH2
6y=x/4096:goS7:y=x/256aN15:goS7:y=x/16aN15:goS7:y=xaN15:goS7:reT
7?mI("0123456789abcdef",y+1,1);:reT

Simplemente haciendo que esto funcione en el Commodore 64 fue un desafío, debido a la memoria, el tamaño de la pantalla, el tamaño de los datos y otras limitaciones. Pensé en implementar la representación abreviada, pero otras limitaciones (como la incapacidad no documentada para usar elementos de matriz como índices de bucle) significaban que aumentaría la longitud del programa en aproximadamente 1000 bytes.

Line 7 es una implementación de la HEX$()que falta Commodore BASIC 2.0. No puedo usar unDEF FN para esto porque solo pueden devolver números, no cadenas. La línea 6 es una subrutina que la aplica a un grupo de cuatro dígitos, que habría sido considerablemente más corta si las funciones pudieran devolver cadenas.

Las líneas 2 y 5 son ocho bucles anidados, implementados como siete bucles "for" y un goto condicional porque ocho bucles "for", cuando se combinan con los dos "gosubs" para imprimir la dirección, desbordarán la pequeña pila del C64.

Un C64 puede imprimir aproximadamente 1.2 direcciones por segundo, para un tiempo de ejecución estimado de 1.3 * 10 ^ 31 años.

PowerShell (v4), 193166162145103 bytes

La versión sin bonificación de TimmyD a 103 bytes:

$i=[bigint]::Pow(4,64);while($i-gt0){('{0:X32}'-f($i-=1)-replace'0(?=.{32})'-re‌​place'.{4}(?!$)','$0:')}

Versión anterior con bonificación en 145 * 0.8 = 116 bytes

Con la ayuda de TimmyD y Tomkandy , que señala eso 0 -eq $falsepero ([bigint]0) -eq $true. Entonces, todas mis versiones anteriores no terminarán.

$i=[bigint]::Pow(4,64);while($i-gt0){$i-=1;[IPAddress]::Parse((('{0:X32}'-f$i
)-replace'0(?=.{32})'-replace'.{4}(?!$)','$0:')).IPAddressToString}

Anteriormente en 162, antes de algunos cambios de expresiones regulares:

$i=[bigint]::Pow(4,64)
while($i){$i-=1;if(($x='{0:X32}'-f$i).Length-eq33){$x=$x.Substring(1)}
[IPAddress]::Parse(($x-replace'.{4}(?!$)','$0:')).IPAddressToString}

"¡Un desafío donde PowerShell debería ser razonablemente competitivo!" - Yo, antes de intentarlo.

Explicación

# PowerShell (PS) has no IP address arithmetic, e.g. IP + 1
#- PS has no 128 bit integers
#- PS has no automatic bignums

# Start from the top, with the BigInteger specialised Power()
$i = [BigInt]::pow(4,64)

# Loop 4**64 through 1, work with $i-1 for ff... -> ::0
while ($i) {
    # PS has no decrement operator for bignums
    # (no using $i-- in the while loop test)
    $i-=1

    # The Net.IPAddress class can't turn a BigInteger
    # into an IPv6 address directly. And because it mashes
    # IPv4 and IPv6 into one class, there's no obvious way 
    # to make a small number always cast to an IPv6 address.
    # Format the bignum as a string of 32 hex digits.
    $x = '{0:X32}' -f $i

    # The BigInteger often formats as /33/ hex digits, 
    # with a leading zero (to avoid unintentional +/- sign bits)
    # ( https://msdn.microsoft.com/library/dd268287 )
    # So remove the leading 0, if there is one
    if (($x).Length-eq33){$x=$x.Substring(1)}

    # I can't always remove the leading zero, because it 
    # can't parse FFFFF... into an address without colons
    # and this regex replace into groups of 4 with colons
    # would go wrong at length 31. No : after the last group
    # This is still better than split/join ... because there
    # isn't a split-into-groups-of-N that I know of.
    $x = ($x -replace '.{4}(?!$)', '$1:'

    # Woo! * 0.8 bonus! 45 characters to save 38! :D
    [IPAddress]::Parse($x).IPAddressToString

}

AutoIt3, 137 Bytes

For $i=0 To 4^64
$s=StringFormat("%032x",$i)
For $j=0 To 7
ConsoleWrite(StringMid($s,$j*4+1,4)&($j<7?':':''))
Next
ConsoleWrite(@LF)
Next

Python 2, 95 bytes

def i(p=0):
 while p<4**64:print':'.join(hex(p)[2:].zfill(32)[4*s:4*s+4]for s in range(8));p+=1

Simplemente pasa por cada número del 0 al 2 ^ 128. Primero convierte el número actual a una cadena hexadecimal, luego elimina el '0x'que le da esa función. A continuación, ajusta la cadena para que tenga 32 ceros en el frente y luego la divide en grupos de cuatro. Finalmente, une los grupos de cuatro con dos puntos, lo imprime y agrega 1 al número actual. Tiene la ventaja adicional de que puede iniciarlo en cualquier valor si le da uno, pero no se necesita ninguna entrada.

Haskell 111

s[]=[[]]
s(a:b)=[y:z|z<-s b,y<-a]
r=replicate
main=mapM putStrLn$s$tail$concat$r 8$":":r 4"0123456789abcdef"

Con mi propia función de secuencia sya no pierde memoria, pero ya no se siente golf.

CBM BASIC v7.0 (166 caracteres)

a=65535
fOi=0toa:fOj=0toa:fOk=0toa:fOl=0toa:fOm=0toa:fOn=0toa:fOo=0toa:fOp=0toa:?hE(i)":"hE(j)":"hE(k)":"hE(l)":"hE(m)":"hE(n)":"hE(o)":"hE(p):nE:nE:nE:nE:nE:nE:nE:nE

La respuesta de Mark es para el BASIC 2.0 del Commodore 64, que carece de un comando incorporado para imprimir números en hexadecimal. Sin embargo, gracias a la HEX$()función en BASIC 7.0, la versión Commodore 128 es mucho más corta. No cabe en una sola línea lógica (que en el C128 está limitada a 160 caracteres) pero aún se puede ingresar como dos líneas separadas en modo directo.

Rubí 75

x=->s,n{n>0?65536.times{|m|x.(s+?:*(8<=>n)+m.to_s(16),n-1)}: p(s)};x.('',8)

Esta es una solución recursiva que toma cada prefijo y encuentra todos los sufijos posibles. Recursivamente.

Tcl 341 318 301

proc ip6 {p c} {
    set s %x:%x:%x:%x:%x:%x:%x:%x
    set p [scan $p $s]
    while {[set d 7]} {
        $c [format [string map {x 04x} $s] {*}$p]
        while {[set i [lindex $p $d]]==0xFFFF} {
            lset p $d 0
            if {!$d} return
            incr d -1
        }
        lset p $d [incr i]
    }
}
ip6 fFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:0000 puts