Das erinnert mich daran, dass vor ein paar Jahren jemand einen Torrent "Hacker-Tool: vollständige Liste aller IP-Adressen" hochgeladen hat. Dies war natürlich nur eine generierte Liste der ~ 4 Milliarden IPv4-Adressen, aber Tausende von "h4xx0rz" haben sie heruntergeladen. Schau, Mama, Imahacker!

Das war damals, aber heute sind alle auf IPv6 umgestiegen . (Richtig?)

Ihre Aufgabe ist es, ein Programm zu schreiben, das alle IPv6-Adressen ausgibt .

Sie sollten ein vollständiges Programm schreiben, das keine Eingaben vornimmt und IPv6-Adressen druckt, eine pro Zeile und keine andere Ausgabe. Ihr Programm muss alle 2 ¹²⁸ möglichen Adressen einschließlich ungültiger Adressen ausgeben. Jede Adresse muss genau einmal ausgedruckt werden. Sie können die Adressen in beliebiger Reihenfolge ausdrucken.

Jede Adresse kann vollständig ausgedruckt werden, wobei 8 Gruppen mit 4 hexadezimalen Ziffern durch Doppelpunkte getrennt sind, z

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

Sie können nach eigenem Ermessen die folgenden Standardabkürzungen aus RFC 5952 verwenden :

• Führende Nullen in einer Gruppe können weggelassen werden, es sei denn, dies 0kann nicht weiter abgekürzt werden.
• :: darf höchstens einmal pro Adresse verwendet werden, um eine Folge von einer oder mehreren Nullgruppen abzukürzen.
• Bei den hexadezimalen Ziffern kann es sich um Klein- oder Großbuchstaben handeln.

Wenn Sie die Repräsentationsempfehlung von RFC 5952 (nur Kleinbuchstaben, kürzestmögliche Repräsentation, bei ::Verwendung an mehreren Stellen so früh wie möglich) erreichen, erhalten Sie einen Bonus von -20% .

Aufgrund der Größe der Ausgabe wird nicht erwartet, dass Ihr Programm beendet wird, während wir dort sitzen. Ihr Programm kann irgendwann durch externe Mittel unterbrochen werden ( Ctrl+ C, Ausschalten der Stromversorgung, ...). Ihr Programm muss die Ausgabe als Stream erzeugen, damit es nach einer "angemessenen" Wartezeit einige Zeilen erzeugt hat. Grundsätzlich ist es nicht zulässig, eine riesige Zeichenfolge im Speicher zu erstellen, um sie am Ende zu drucken. Jedes Programm, dem auf einem „Standard“ -PC der Speicher ausgeht, wird disqualifiziert. (Wenn Ihr Programm jedoch ausreichend lange ausgeführt wurde, muss es alle IPv6-Adressen drucken und dann beenden.)

(Wenn diese Bedingung ein Problem für Webinterpreter darstellt, die das Programm bis zum Abschluss ausführen und dann die Ausgabe anzeigen lassen, und Sie keinen gehosteten Interpreter haben, testen Sie Ihr Programm mit einer kleineren Version des Problems und passen Sie es dann sorgfältig an zur Gänze 2 ^128. )

Ihre Punktzahl ist die Länge Ihres Programms in Bytes, multipliziert mit 0,8, wenn Sie den Bonus erhalten. Es ist Codegolf, also gewinnt die niedrigste Punktzahl.

Pyth, 21 Bytes

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

Verwendet eine while-Schleife mit Jals Iteratorvariable. Initialisiert das Maximum mit 8^chr(' '). Füllt auf, indem Sie diesen Anfangswert addieren, in Hex konvertieren und dann das erste Zeichen entfernen.

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

Hinweis: Der Code hatte zuvor einen Fehler, durch dessen Behebung 1 Byte eingespart wurden

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

Druckt die Adressen wie

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

Vorherige (kompliziertere) Version mit dem Pad-Operator (auch 24 Bytes):

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

Erläuterung

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 (ungültig)

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

Dies kann nicht ausgeführt werden, da 1) mindestens 2 ¹³² Byte (2 ⁵² Yobibyte) Speicherplatz verbraucht werden und 2) der Interpreter es nicht mag (2 ¹²⁸ passen nicht hinein ssize_t, also keine lists dieser Größe) . Es würde die Adressen in lexikographischer Reihenfolge drucken. Sie können den Algorithmus ausprobieren, indem Sie die Zahl (en) am Ende in eine brauchbare Zahl ändern.

C (mit GCC-Erweiterungen): 76 Byte * 0,8 = 60,8

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

Dies verwendet die 128-Bit-Ganzzahlen-GCC-Erweiterung, um einfach von ::bis hochzuzählenffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff . inet_ntop()Formatiert jede Adresse korrekt, sodass der Bonus von -20% in Anspruch genommen werden kann.

Ausgabe

Mit sedjeder millionsten Zeile werden bis zu 10 Millionen ausgegeben:

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

Hinweis Ich verwende einen Little-Endian-x86_64-Computer, und die Netzwerkadressen befinden sich normalerweise immer in der Netzwerkreihenfolge (Big-Endian) inet_ntop(). Dies spielt keine Rolle - alle Adressen werden weiterhin (eventuell) angezeigt.

CJam, 36 27 Bytes

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

-9 Bytes dank @Dennis (ich habe vergessen, dass CJam String-Formatierung hat). Druckt die Adressen in Kleinbuchstaben und absteigend.

Verwenden Sie aus offensichtlichen Gründen den Java-Interpreter, nicht den Online-Interpreter. Sie können es jedoch durch G32#etwas Kleineres ersetzen , um es online zu testen, z. B. hier sind die letzten 100 .

Erläuterung

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

Als Nebeneffekt der zum Einfügen der Doppelpunkte verwendeten Methode werden die Adressen mit der am weitesten rechts stehenden Spalte gedruckt, die links angezeigt wird:

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

Meine erste Verilog-Einsendung könnte wahrscheinlich mehr Golf vertragen, aber ich habe momentan nicht die Energie, dies zu tun. cist Uhr, oist ASCII-Ausgabe. Qualifiziert sich nicht für den Formatierungsbonus, da keine Auffüllung statt Abkürzung erfolgt.

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

Dies ist eine einfache Iteration, gefolgt von einem Bit-Twiddling, um die Ausgabe als ASCII-Datei zu erstellen. Ich hacke den Doppelpunkt nach der letzten Gruppe mit einem kleinen Hack. Synthetisiert und scheint für xc3s500e-4ft256-4 auf ISE 13.7 lin64 zu funktionieren.

C 91-126 Bytes

Meine ursprüngliche Version, 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]);}

Beste portable Golf-Version, 103 Bytes (danke @Dennis für einige dieser Konzepte)

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

Erläuterung: Der Algorithmus selbst ist ziemlich einfach. Ich habe eher long als unsigned int verwendet, weil es kürzer ist. Wenn Sie sie auf Dateiebene deklarieren, wird alles mit Nullen vorinitialisiert. Die fFunktion ist ein einfaches Inkrement mit Übertrag, das die niedrigen 16 Bits jedes Wortes verarbeitet. Die Schleife endet, wenn sie in das 129. Bit übergeht.

Wenn Sie für den Ausdruck rückwärts iterieren, werden die Adressen in der "richtigen" Reihenfolge gedruckt, und auch der Scheck zum Drucken einer neuen Zeile ist einige Zeichen kürzer.

Hierbei werden einige nicht portable Konstrukte verwendet. Es wird am besten als K & R-Dialekt von C angesehen, da implizite int-Rückgabetypen verwendet werden und stdio.h nicht enthalten ist. Und meine Verwendung von long wurde dadurch informiert - auf den meisten modernen Systemen reicht int aus, weil es 32 Bit ist. Dies könnte wahrscheinlich unter PDP-11 Unix unverändert laufen.

Sie kann jedoch kürzer sein. Wenn wir davon ausgehen, dass wir int verwenden können (entweder als Typ, der breiter als 16 Bit ist, oder als Typ mit genau 16 Bit mit verschiedenen Eigenschaften, die auf vielen Systemen wie Zweierkomplement und arithmetischem Rollover zufällig zutreffen), können wir es loswerden das Zeug im Zusammenhang mit der Verwendung von langen.

Version für int breiter als 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);}}

Version für 16-Bit-Systeme, 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++);}}

Seltsamerweise unterstützte der ursprüngliche K & R-Compiler die Deklaration jedoch nicht ohne int (sie kompiliert einwandfrei, behandelt die Variablen jedoch als extern und daher zur Verbindungszeit undefiniert), sodass zusätzliche drei Bytes erforderlich sind, um die Deklaration auf int*p,a[9];for zu ändern insgesamt 94.

Wenn die Annahme, dass die Ausgabe vor dem Abschluss unterbrochen wird, eine harte Einschränkung darstellt, können wir die Endprüfung entfernen und fünf Bytes einsparen.

Bonus: voll ANSI portable Version, 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);}}

Zeilenumbrüche werden in allen Versionen aus Gründen der Lesbarkeit und an Stellen eingefügt, an denen kein Leerzeichen erforderlich ist, und sind von der Byte-Anzahl ausgenommen, mit Ausnahme der Zeilenumbrüche nach der #includeZeile in der ANSI-Version.

Alle Versionen mit Ausnahme der ANSI-Version werden am Ende von main durchgespielt und geben möglicherweise einen falschen Exit-Code an das Betriebssystem zurück.

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

Erläuterung

• For $a=0 To 2^32-1: 4-mal über 0-2 ^ 32 ((2 ^ 32) ^ 4 = 2 ^ 128) mögliche Kombinationen iterieren.
• $s=StringFormat("%08x%08x%08x%08x",$a,$b,$c,$d): Konvertieren Sie die Zahlen in eine hexadezimale Zeichenfolge mit einer Länge von 32 (4 * 32).
• For $j=0 To 8: Alle 8 Abschnitte der Zeichenfolge durchlaufen.
• ConsoleWrite(StringMid($s,$j*4+1,4)&($j<7?":":"")): Extrahieren Sie die nächsten 4 Zeichen aus der Zeichenfolge und fügen Sie :am Ende einen Doppelpunkt ( ) ein. Wenn wir den letzten Abschnitt nicht erreicht haben, geben Sie alles auf der Konsole aus
• Next: Beende die innere for-Schleife
• ConsoleWrite(@LF): Fügen Sie am Ende der Zeile einen Zeilenumbruch hinzu
• Next: Beenden Sie die äußeren for-Schleifen

Erwartete Ausgabegröße: (Eine Zeile (39 Byte) + Zeilenvorschub) (= 40 Byte) * 2 ^ 128 = 1,361 * 10 ^ 16 YB (Yottabyte)

Zimtgummi, 16 Bytes

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

Probieren Sie es online aus. (TIO begrenzt die Ausgabe)

Erläuterung

Der gModus versetzt Zimtgummi in den Erzeugungsmodus . Der Rest der Zeichenfolge wird in diesen regulären Ausdruck dekomprimiert:

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

Anschließend wird ein Generator aller möglichen Zeichenfolgen erstellt, die dem regulären Ausdruck entsprechen, und durchläuft diesen und druckt die einzelnen Zeichenfolgen aus.

Etwas amüsanterweise ([0-9a-f]{4,4}:){7,7}[0-9a-f]{4,4}komprimiert sich der Golf-Regex tatsächlich zu einer längeren Saite als der Regex darüber.

Commodore BASIC 2.0, 339 Bytes

Um hexadezimale Ziffern in Kleinbuchstaben zu erhalten, wird dieses Programm im "verschobenen Modus" geschrieben (drücken <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

Die einfache Ausführung dieser Aufgabe auf dem Commodore 64 war aufgrund von Speicher, Bildschirmgröße, Datengröße und anderen Einschränkungen eine Herausforderung. Ich dachte darüber nach, die abgekürzte Darstellung zu implementieren, aber andere Einschränkungen (wie die undokumentierte Unfähigkeit, Array-Elemente als Schleifenindizes zu verwenden) bedeuteten, dass die Länge des Programms um geschätzte 1000 Bytes erhöht würde.

Zeile 7 ist eine Implementierung von HEX$()Commodore BASIC 2.0. Ich kann hierfür kein verwenden, DEF FNda diese nur Zahlen und keine Zeichenfolgen zurückgeben können. Zeile 6 ist eine Unterroutine, die sie auf eine Gruppe von vier Ziffern anwendet, die erheblich kürzer gewesen wäre, wenn Funktionen Zeichenfolgen zurückgeben könnten.

Die Zeilen 2 und 5 sind acht verschachtelte Schleifen, die als sieben "for" -Schleifen und als bedingtes "goto" implementiert sind, da acht "for" -Schleifen in Kombination mit den zwei "gosubs" zum Ausdrucken der Adresse den winzigen Stapel des C64 überlaufen lassen.

Ein C64 kann bei einer geschätzten Laufzeit von 1,3 * 10 ^ 31 Jahren ungefähr 1,2 Adressen pro Sekunde ausgeben.

PowerShell (v4), 193 166 162 145 103 Bytes

TimmyDs No-Bonus-Version mit 103 Bytes:

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

Vorherige With-Bonus-Version bei 145 * 0,8 = 116 Bytes

Mit Hilfe von TimmyD und tomkandy , der darauf hinweist , dass 0 -eq $falseaber ([bigint]0) -eq $true. Daher werden alle meine vorherigen Versionen nicht beendet.

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

Zuvor bei 162, bevor sich einige reguläre Ausdrücke ändern:

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

"Eine Herausforderung, bei der PowerShell einigermaßen wettbewerbsfähig sein sollte!" - ich, bevor ich es versuchte.

Erläuterung

# 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

Durchläuft einfach jede Zahl von 0 bis 2 ^ 128. Zuerst konvertiert es die aktuelle Zahl in eine hexadezimale Zeichenfolge und entfernt dann die von '0x'dieser Funktion angegebenen Zahlen . Als nächstes wird die Zeichenkette so angepasst, dass sie vorne 32 Nullen hat, und dann in Vierergruppen aufgeteilt. Schließlich werden die Vierergruppen mit Doppelpunkten verbunden, ausgedruckt und die aktuelle Zahl um 1 erhöht. Hat den zusätzlichen Bonus, dass Sie es bei jedem Wert starten können, wenn Sie ihm einen geben, aber keine Eingabe erforderlich ist.

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"

Mit meiner eigenen Sequenzfunktion sverliert es keinen Speicher mehr, fühlt sich aber nicht mehr golfen.

CBM BASIC v7.0 (166 Zeichen)

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

Marks Antwort ist für den Commodore 64 BASIC 2.0, dem ein integrierter Befehl zum hexadezimalen Drucken von Zahlen fehlt. Dank der HEX$()Funktion in BASIC 7.0 ist die Commodore 128-Version jedoch viel kürzer. Es passt nicht auf eine einzelne logische Zeile (die auf dem C128 auf 160 Zeichen begrenzt ist), kann jedoch im Direktmodus als zwei separate Zeilen eingegeben werden.

Ruby 75

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

Dies ist eine rekursive Lösung, die jedes Präfix verwendet und jedes mögliche Suffix findet. Rekursiv.

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