Imprima todas las direcciones IPv6

45

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

Gilles 'SO- deja de ser malvado'
fuente
22
Esto es 5.445 * 10¹⁵ yottabytes. Para almacenar todos esos datos, necesita al menos 15 centros de datos del tamaño de la Tierra que no contengan más que discos duros empaquetados de la manera más compacta posible. Ese es un gran torrente .....
Kaz Wolfe
77
@Mew Me pregunto qué tan pequeño se comprimiría el archivo (usando alguna compresión genérica como gzip).
SztupY
35
@SztupY: aparentemente la salida se puede comprimir a 25 bytes (algoritmo de descompresión = un intérprete Pyth, algoritmo de compresión = publicar en PPCG). Al acechar en este sitio, parece que Pyth es un formato comprimido bastante genérico.
Ben Voigt
3
¡En mi experiencia, @Gilles es un verdadero TAN pesado! ¡Me alegra verte trayendo preguntas a nuestro pequeño rincón PPCG de SO! También es divertido para mí ver preguntas relacionadas con redes.
Trauma digital
55
Esto me recuerda la pregunta "iterar sobre todos los GUID posibles" en SO.
MikeTheLiar

Respuestas:

5

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.

isaacg
fuente
Ese código parece que alguien estornudó en su teclado y luego trató de limpiarlo.
darksky
@darksky Eso es golflangs para ti: P
Esolanging Fruit
50

Python 3, 65 bytes · 0.8 = 52.0

from ipaddress import*
n=4**64
while n:n-=1;print(IPv6Address(n))
Anders Kaseorg
fuente
77
Dang python! ¡Siempre tiene los métodos correctos! : D
MayorMonty
ipaddresses solo python3.
@ Hurricane996, sí, lo había estado usando en Python 2 desde PyPI sin darme cuenta de que solo ingresó a la biblioteca estándar en Python 3. Así que cambié esto a Python 3 a expensas de un byte.
Anders Kaseorg
@MDXF Python no tiene operadores ++ o -
Draconis
14

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 132 bytes (2 52 yobibytes) de memoria y 2) al intérprete no le gusta (2 128 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.

PurkkaKoodari
fuente
1
Qué pasa con ... " Cualquier programa que se quede sin memoria en una PC" estándar "está descalificado". ?
TessellatingHeckler
2
@TessellatingHeckler El primero no lo hará, ya que se ejecuta de forma iterativa. El segundo lo he marcado claramente como no válido.
PurkkaKoodari
12

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

Trauma digital
fuente
11

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
Sp3000
fuente
1
Lo interesante es que el intérprete en línea, más allá de no poder manejar el tamaño, por supuesto, también imprime el resultado incorrectamente. Si elimina el bucle y solo imprime el primer valor, se imprime 0000:0000:0000:0000:0000:0000:ffff:ffff. Parece que el formato de cadena podría funcionar de manera diferente en línea. Confirmé que funciona bien con la versión sin conexión.
Reto Koradi
nes lo mismo que oNoen TIO .
Esolanging Fruit
8

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
xsot
fuente
1
¡La rotación es realmente ordenada! También tardío, pero bienvenido desde la anarquía :)
Sp3000
3
Si dice que la columna de la derecha está a la izquierda, está imprimiendo direcciones IPv6 no válidas, pero si las columnas están en los lugares correctos, entonces está [printing] the addresses in any order. ;)
TessellatingHeckler
7

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.

ζ--
fuente
6

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.

Aleatorio832
fuente
1
La portabilidad generalmente no es una preocupación aquí. Esto funciona en mi máquina:a[9];f(int*x){if(++*x>>16)*x=f(x+1);}main(i){for(;!a[8];f(a))for(i=8;i--;)printf(i?"%x:":"%x\n",a[i]);}
Dennis
Claramente eres mucho mejor en esto que yo. Algunos de los que estoy muy sorprendido funcionan, pero realmente debería haber pensado en la i--comprobación del estado.
Random832
Cuando probaste esto, ¿lo corriste hasta el acarreo? Mi máquina pone un valor aleatorio en un [0] después de pasar a su versión.
Random832
Si. Las primeras 6.553.601 direcciones IP están impresas correctamente en mi máquina.
Dennis
A Ideone tampoco le gusta, pero funciona en el teclado: envolvera[0] y envolvera[1]
Dennis
5

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)

Árbol Gigante
fuente
No quiere decir 4^64 - 1?
Anders Kaseorg
@AndersKaseorg aparentemente necesito incluso usar 4 bucles hasta 2 ^ 32-1, porque AutoIt puede analizar valores grandes como 4 ^ 64, pero no puedo almacenarlos para usarlos en un bucle, porque los enteros solo van hasta 2 ^ 32 -1 en AutoIt.
GiantTree
5

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.

un espagueti
fuente
4

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.

marca
fuente
4

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

}
TessellatingHeckler
fuente
95 sin bonificación. Gracias a ustedes dos por presentarme a [bigint], eso es bastante útil (para las cosas que no debería hacer de manera elegante en primer lugar ...)for($g=[bigint]::pow(2,128);$g;$g-=1){'{0:X32}'-f$g-replace'(?=(.{4})+$)',':'-replace'^0+:',''}
tomkandy
Lo siento debería serfor($g=[bigint]::pow(2,120);$g;$g-=1){'{0:X32}'-f$g-replace'(?=(.{4})+$)',':'-replace'^0*:',''}
tomkandy
for($g=[bigint]::pow(2,128);$g-gt0;$g-=1){'{0:X32}'-f$g-replace'(?=(.{4})+$)',':'-replace'^\d*:',''}Sí, la primera dirección es incorrecta pero no se repite al final. También tenga while($i)en cuenta que en el suyo no se detendrá en cero - [boolean][bigint]0evalúa como verdadero
tomkandy
@tomkandy oh wow, solo debo haber probado el final estableciendo $ i = 5 como int. (El complejo 0 tampoco es $ falso ... y tampoco es una cadena vacía. Debería prestar más atención a "no es Python"). ¡Gracias! (Y este guión tuyo ya no se deshace del líder 0:: /)
TessellatingHeckler
@TessellatingHeckler No ir por el bono es lamentablemente 13 bytes más corto - $i=[bigint]::Pow(4,64);while($i-gt0){('{0:X32}'-f($i-=1)-replace'0(?=.{32})'-replace'.{4}(?!$)','$0:')}en 103 ...
AdmBorkBork
3

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
rav_kr
fuente
Lo sé pero soy nuevo aquí :(
rav_kr
Solo asegurándome de que lo sepas. Gracias.
mbomb007
No quiere decir 4^64 - 1?
Anders Kaseorg
2

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.

Estado
fuente
Si su respuesta es una función, no necesita llamarla :)
Beta Decay
@BetaDecay Entonces ese fue mi malentendido. ¡Fijo! Gracias.
Estado del
2

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.

Franky
fuente
¿Cómo lo compilas para que no se quede sin memoria? Con mi ghc v7.10.2 y std. Opciones de compilación pierde memoria.
nimi
2

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.

Psiconauta
fuente
Parece que te falta la mitad de tus bucles. Una dirección IPv6 es de 128 bits, no de 64 bits.
Mark
@ Mark: ¡Gracias por señalar esto! He solucionado el problema.
Psiconauta
2

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.

MegaTom
fuente
Obtenga definiciones de funciones más cortas con lambdas:x=->s,n{...};x['',8]
Pomo de la puerta
0

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
martillo de lobo
fuente