Questo mi ricorda quando qualche anno fa qualcuno ha caricato un torrent "Strumento di hacker: elenco completo di tutti gli indirizzi IP". Questo, ovviamente, era solo un elenco generato di ~ 4 miliardi di indirizzi IPv4, ma migliaia di "h4xx0rz" lo hanno scaricato. Guarda mamma, imahacker!

Questo era allora, ma al giorno d'oggi tutti sono passati a IPv6 . (Giusto?)

Il tuo compito è scrivere un programma che stampa tutti gli indirizzi IPv6 .

È necessario scrivere un programma completo che non accetta input e stampa indirizzi IPv6, uno per riga e nessun altro output. Il programma deve stampare tutti i 2 ¹²⁸ indirizzi possibili, inclusi quelli non validi. Ogni indirizzo deve essere stampato esattamente una volta. È possibile stampare gli indirizzi in qualsiasi ordine.

Ogni indirizzo può essere stampato per intero, con 8 gruppi di 4 cifre esadecimali separati da due punti, ad es

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

È possibile, a propria discrezione, utilizzare una qualsiasi delle abbreviazioni standard di RFC 5952 :

• Gli zeri iniziali in un gruppo possono essere omessi, tranne che 0non possono essere ulteriormente abbreviati.
• :: può essere usato al massimo una volta per indirizzo per abbreviare una sequenza di uno o più gruppi tutti zero.
• Le cifre esadecimali possono usare lettere minuscole o maiuscole.

Se ottieni la raccomandazione di rappresentazione da RFC 5952 (solo lettere minuscole, rappresentazione il più breve possibile, con ::usato il più presto possibile se ci sono più posti in cui può essere usato), otterrai un bonus del -20% .

A causa delle dimensioni dell'output, non è previsto che il programma finisca mentre siamo seduti lì. Il tuo programma potrebbe essere interrotto con mezzi esterni ad un certo punto ( Ctrl+ C, togliendo energia, ...). Il tuo programma deve produrre output come stream, in modo che dopo un'attesa "ragionevole", avrà prodotto alcune righe. Fondamentalmente, non è permesso costruire una stringa gigante in memoria solo per stamparla alla fine. Qualsiasi programma che esaurirebbe la memoria su un PC "standard" viene squalificato. (Tuttavia, se il programma è stato lasciato funzionare per un tempo sufficientemente lungo, deve stampare tutti gli indirizzi IPv6 e quindi uscire.)

(Se questa condizione è un problema per gli interpreti web che eseguono il programma fino al completamento e quindi ti permettono di vedere l'output e non hai un interprete ospitato, prova il tuo programma su una versione più piccola del problema, quindi regolalo attentamente fino a 2 ^128. )

Il tuo punteggio è la lunghezza del tuo programma in byte, moltiplicato per 0,8 se ottieni il bonus. È il golf del codice, quindi vince il punteggio più basso.

Pyth, 21 byte

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

Utilizza un ciclo while con Jcome variabile iteratore. Inizializza il massimo usando 8^chr(' '). Rilievo aggiungendo quel valore iniziale, convertendolo in esadecimale, quindi rimuovendo il primo carattere.

Python 3, 65 byte · 0,8 = 52,0

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

Pyth, 27 25 24 byte

Nota: il codice aveva un bug in precedenza, risolto salvando 1 byte

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

Stampa gli indirizzi come

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

Versione precedente (più complicata) utilizzando l'operatore pad (anche 24 byte):

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

Spiegazione

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 byte (non valido)

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

Questo non può essere eseguito dal momento che 1) consumerebbe almeno 2 ¹³² byte (2 ⁵² yobibyte) di memoria e 2) l'interprete non piace (2 ¹²⁸ non si adatta ssize_t, quindi nessuna lists di quella dimensione) . Stampa gli indirizzi in ordine lessicografico. Puoi provare l'algoritmo modificando i numeri alla fine in qualcosa di utilizzabile.

C (con estensioni GCC), 76 byte * 0,8 = 60,8

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

Questo utilizza l' estensione GCC a numeri interi a 128 bit per contare semplicemente da ::a ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff. inet_ntop()formatta correttamente ciascun indirizzo in modo da poter richiedere il bonus del -20%.

Produzione

Utilizzo sedper produrre ogni milionesimo riga fino a 10 milioni:

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

Nota Sto usando una macchina x86_64 little-endian e che gli indirizzi di rete sono in genere sempre in ordine di rete (big-endian), quindi l'endianness viene effettivamente scambiato usando inet_ntop(). Questo non ha importanza: tutti gli indirizzi verranno comunque (eventualmente) visualizzati.

CJam, 36 27 byte

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

-9 byte grazie a @Dennis (ho dimenticato che CJam ha la formattazione delle stringhe). Stampa gli indirizzi in minuscolo e in ordine decrescente.

Per ovvi motivi, utilizzare l'interprete Java, non quello online. Puoi sostituirlo G32#con qualcosa di più piccolo per i test online, ad esempio ecco gli ultimi 100 .

Spiegazione

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 byte

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

Come effetto collaterale del metodo utilizzato per inserire i due punti, gli indirizzi vengono stampati con la colonna più a destra che appare a sinistra:

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

La mia prima presentazione di Verilog, probabilmente potrei usare più golf ma non ho l'energia per farlo adesso. cè l'orologio, oè l'uscita ASCII. Non si qualifica per il bonus di formattazione a causa di zero padding anziché abbreviazione.

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

Questa è una semplice iterazione seguita da alcuni bit-twiddling per rendere l'uscita ASCII. Trito i due punti dopo l'ultimo gruppo con un piccolo trucco. Sintetizza e sembra funzionare per xc3s500e-4ft256-4 su ISE 13.7 lin64.

C, 91-126 byte

La mia versione originale, 119 byte.

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 migliore versione portatile da golf, 103 byte (grazie a @Dennis per alcuni di questi concetti)

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

Spiegazione: L'algoritmo stesso è ragionevolmente semplice. Ho usato int lungo anziché unsigned perché è più breve. Dichiararli a livello di file significa che tutto è preinizializzato con zeri. La ffunzione è un semplice incremento con carry che opera sui 16 bit bassi di ogni parola. Il loop termina quando passa al 129 ° bit.

Iterare all'indietro per printf significa che stampiamo gli indirizzi nell'ordine "corretto" e anche il controllo per la stampa di una nuova riga è più breve di alcuni caratteri.

Questo utilizza alcuni costrutti non portatili. È meglio considerato come un dialetto K&R di C, poiché utilizza tipi di ritorno int impliciti e non include stdio.h. E il mio uso di long è stato informato da questo - sulla maggior parte dei sistemi moderni int è sufficiente perché è di 32 bit. Questo potrebbe probabilmente funzionare senza modifiche su Unix PDP-11.

Tuttavia, può essere più breve. Se assumiamo che possiamo usare int (o come un tipo più largo di 16 bit, o un tipo di esattamente 16 bit con varie proprietà che sono vere su molti sistemi come il complemento a due e il rollover aritmetico), possiamo sbarazzarci di le cose relative all'uso a lungo.

Versione per int più ampia di 16 bit, 97 byte.

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

Versione per sistemi a 16 bit, 91 byte.

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

Stranamente, tuttavia, il compilatore K&R originale in realtà non supportava la dichiarazione senza int (si compila bene, ma tratta le variabili come esterne e quindi non definite al momento del collegamento), quindi sono necessari altri tre byte per modificare la dichiarazione in int*p,a[9];per per un totale di 94.

Inoltre, se il presupposto che sia stato interrotto prima del completamento dell'output era un vincolo difficile, potremmo rimuovere il controllo finale, risparmiando cinque byte.

Bonus: versione completamente portatile ANSI, 126 byte:

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

I newline in tutte le versioni vengono inseriti per motivi di leggibilità e in posizioni in cui non sono richiesti spazi bianchi e sono esclusi dal conteggio dei byte, ad eccezione del newline dopo la #includeriga nella versione ANSI.

Tutte le versioni tranne la versione ANSI falliscono alla fine di main e quindi possono restituire un codice di uscita spurie al sistema operativo.

AutoIt3, 142 231 byte

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

Spiegazione

• For $a=0 To 2^32-1: Iterate 4 volte su 0-2 ^ 32 ((2 ^ 32) ^ 4 = 2 ^ 128) combinazioni possibili.
• $s=StringFormat("%08x%08x%08x%08x",$a,$b,$c,$d): Converte i numeri in una stringa esadecimale con una lunghezza di 32 (4 * 32).
• For $j=0 To 8: Scorre su tutte e 8 le sezioni della stringa.
• ConsoleWrite(StringMid($s,$j*4+1,4)&($j<7?":":"")): Estrai i successivi 4 caratteri dalla stringa e aggiungi due punti ( :) alla fine, se non abbiamo raggiunto l'ultima sezione, quindi invia tutto alla console
• Next: Termina il for-loop interno
• ConsoleWrite(@LF): Aggiungi un avanzamento riga alla fine della riga
• Next: Termina i for-loop esterni

Dimensione di output prevista: (una riga (39 byte) + avanzamento riga) (= 40 byte) * 2 ^ 128 = 1.361 * 10 ^ 16 YB (yottabytes)

Gomma alla cannella, 16 byte

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

Provalo online. (TIO limita l'uscita)

Spiegazione

La gmodalità mette Cinnamon Gum in modalità di generazione . Il resto della stringa si decomprime in questa regex:

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

Quindi crea un generatore di tutte le possibili stringhe che corrispondono alla regex e scorre attraverso di essa, stampandole ognuna.

In qualche modo divertente, il regex golfista si ([0-9a-f]{4,4}:){7,7}[0-9a-f]{4,4}comprime in realtà su una stringa più lunga rispetto al regex sopra.

Commodore BASIC 2.0, 339 byte

Per ottenere cifre esadecimali minuscole, questo programma è scritto in "modalità spostata" (premere <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

Fare semplicemente questo lavoro su Commodore 64 era una sfida, a causa della memoria, della dimensione dello schermo, della dimensione dei dati e di altre limitazioni. Ho preso in considerazione l'implementazione della rappresentazione abbreviata, ma altre limitazioni (come l'incapacità non documentata di utilizzare gli elementi dell'array come indici di loop) hanno comportato un aumento della lunghezza del programma di circa 1000 byte.

La linea 7 è un'implementazione di HEX$()cui manca Commodore BASIC 2.0. Non posso usare a DEF FNper questo perché quelli possono solo restituire numeri, non stringhe. La riga 6 è una subroutine che la applica a un gruppo di quattro cifre, che sarebbe stato notevolmente più breve se le funzioni potessero restituire stringhe.

Le righe 2 e 5 sono otto loop nidificati, implementati come sette loop "for" e un goto condizionale perché otto loop "for", quando combinati con i due "gosub" per stampare l'indirizzo, trabocceranno il piccolo stack del C64.

Un C64 può stampare circa 1,2 indirizzi al secondo, per un tempo di esecuzione stimato di 1,3 * 10 ^ 31 anni.

PowerShell (v4), 193 166 162 145 103 byte

La versione senza bonus di TimmyD a 103 byte:

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

Versione precedente con bonus a 145 * 0,8 = 116 byte

Con l'aiuto di TimmyD e Tomkandy , che lo sottolinea 0 -eq $falsema ([bigint]0) -eq $true. Quindi tutte le mie versioni precedenti non verranno terminate.

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

Precedentemente a 162, prima che alcune modifiche regex:

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

"Una sfida in cui PowerShell dovrebbe essere ragionevolmente competitivo!" - io, prima di provarlo.

Spiegazione

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

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 byte

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

Passa semplicemente attraverso ogni numero compreso tra 0 e 2 ^ 128. Per prima cosa converte il numero corrente in stringa esadecimale, quindi rimuove '0x'ciò che quella funzione fornisce. Successivamente regola la stringa in modo che abbia 32 zeri nella parte anteriore e quindi la suddivide in gruppi di quattro. Alla fine si unisce ai gruppi di quattro con due punti, lo stampa e aggiunge 1 al numero corrente. Ha il bonus in più che puoi avviarlo a qualsiasi valore se ne dai uno, ma non è necessario alcun input.

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 la mia funzione sequenza snon perde più memoria, ma non si sente più golfato.

CBM BASIC v7.0 (166 caratteri)

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 risposta di Mark è per BASIC 2.0 del Commodore 64, che manca di un comando integrato per la stampa di numeri in formato esadecimale. Tuttavia, grazie alla HEX$()funzione in BASIC 7.0, la versione di Commodore 128 è molto più breve. Non si adatta a una singola riga logica (che sul C128 è limitata a 160 caratteri) ma può comunque essere immessa come due righe separate in modalità diretta.

Ruby 75

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

Questa è una soluzione ricorsiva che accetta ogni prefisso e trova ogni possibile suffisso. Ricorsivamente.

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