Drucken Sie alle IPv6-Adressen aus

45

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

Gilles 'SO - hör auf böse zu sein'
quelle
22
Das sind 5,445 * 10¹⁵ Yottabyte. Um all diese Daten zu speichern, benötigen Sie mindestens 15 Rechenzentren in Erdgröße, die nur Festplatten enthalten, die so dicht wie möglich zusammengepackt sind. Das ist ein großer Strom ...
Kaz Wolfe
7
@Mew Ich frage mich, wie klein die Datei komprimiert werden würde (mit einer generischen Komprimierung wie gzip).
SztupY
35
@SztupY: Anscheinend kann die Ausgabe auf 25 Byte komprimiert werden (Dekomprimierungsalgorithmus = ein Pyth-Interpreter, Komprimierungsalgorithmus = Posten in PPCG). Aufgrund der Lauern auf dieser Site scheint Pyth ein eher generisches komprimiertes Format zu sein.
Ben Voigt
3
Nach meiner Erfahrung ist @Gilles ein echtes SO-Schwergewicht! Schön, dass Sie Fragen zu unserer kleinen PPCG-Ecke von SO! Es macht mir auch Spaß, Netzwerkfragen zu sehen.
Digital Trauma
5
Dies erinnert mich an die Frage "Über alle möglichen GUIDs iterieren" bei SO.
MikeTheLiar

Antworten:

5

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.

isaacg
quelle
Dieser Code sieht aus, als hätte jemand auf der Tastatur geniest und versucht, ihn zu bereinigen.
Darksky
@ Darksky Das ist Golflangs für Sie: 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
quelle
7
Mistpython! Es hat immer die richtigen Methoden! : D
MayorMonty
ipaddressist nur python3.
@ Hurricane996, ja, ich habe es in Python 2 von PyPI verwendet, ohne zu bemerken, dass es nur in Python 3 in die Standardbibliothek aufgenommen wurde. Ich habe es also auf Kosten eines Bytes auf Python 3 umgestellt.
Anders Kaseorg
@MDXF Python hat keine ++ oder - Operatoren
Draconis
14

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 132 Byte (2 52 Yobibyte) Speicherplatz verbraucht werden und 2) der Interpreter es nicht mag (2 128 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.

PurkkaKoodari
quelle
1
Was ist mit ... " Jedes Programm, dem auf einem" Standard "-PC der Speicher ausgeht, wird disqualifiziert." ?
TessellatingHeckler
2
@TessellatingHeckler Das erste wird nicht, da es iterativ ausgeführt wird. Das zweite habe ich eindeutig als ungültig markiert.
PurkkaKoodari
12

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.

Digitales Trauma
quelle
11

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
Sp3000
quelle
1
Interessant ist, dass der Online-Dolmetscher nicht nur mit der Größe klar kommt, sondern auch das Ergebnis falsch ausgibt. Wenn Sie die Schleife entfernen und nur den ersten Wert drucken, wird dieser gedruckt 0000:0000:0000:0000:0000:0000:ffff:ffff. Es sieht so aus, als würde die Formatierung von Zeichenfolgen online möglicherweise anders funktionieren. Ich habe bestätigt, dass es mit der Offline-Version funktioniert.
Reto Koradi
nist das gleiche wie oNoin 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

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
xsot
quelle
1
Das Drehen ist wirklich ordentlich! Auch verspätet, aber willkommen aus der Anarchie :)
Sp3000
3
Wenn Sie sagen, dass sich die am weitesten rechts stehende Spalte links befindet, werden ungültige IPv6-Adressen gedruckt. Wenn sich die Spalten jedoch an den richtigen Stellen befinden, werden sie gedruckt [printing] the addresses in any order. ;)
TessellatingHeckler
7

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.

ζ--
quelle
6

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.

Random832
quelle
1
Portabilität spielt hier normalerweise keine Rolle. Dies funktioniert auf meinem Computer: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
Sie können das eindeutig besser als ich. Bei einigen Arbeiten bin ich sehr überrascht, aber ich hätte wirklich an die i--Zustandsüberprüfung denken sollen .
Random832
Wenn Sie dies getestet haben, haben Sie es bis zum Tragen durchlaufen lassen? Mein Computer fügt einen zufälligen Wert in eine [0] ein, nachdem Sie in Ihrer Version einen Rollover ausgeführt haben.
Random832
Ja. Die ersten 6.553.601 IP-Adressen werden auf meinem Computer korrekt gedruckt.
Dennis
Ideone mag es auch nicht, aber es funktioniert auf Codepad: Wrap-Ina[0] und Wrap-Ina[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

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)

GiantTree
quelle
Meinst du nicht 4^64 - 1?
Anders Kaseorg
@AndersKaseorg Anscheinend muss ich sogar 4 Schleifen bis zu 2 ^ 32-1 verwenden, da AutoIt große Werte wie 4 ^ 64 analysieren kann , diese aber nicht für die Verwendung in einer Schleife speichern kann, da Ganzzahlen nur bis zu 2 ^ 32 gehen -1 in AutoIt.
GiantTree
5

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.

ein Spaghetto
quelle
4

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.

Kennzeichen
quelle
4

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

}
TessellatingHeckler
quelle
95 ohne Bonus. Ich danke Ihnen beiden, dass Sie mich mit [bigint] bekannt gemacht haben. Das ist ziemlich praktisch (für Dinge, die ich eigentlich gar nicht machen sollte ...)for($g=[bigint]::pow(2,128);$g;$g-=1){'{0:X32}'-f$g-replace'(?=(.{4})+$)',':'-replace'^0+:',''}
Tomkandy,
Sorry sollte seinfor($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*:',''}Ja, die erste Adresse ist falsch, wird aber am Ende nicht wiederholt. Beachten Sie auch, dass while($i)in [boolean][bigint]0
Ihrem
@tomkandy oh wow, ich muss das Ende nur getestet haben, indem ich $ i = 5 als int gesetzt habe. (Komplex 0 ist auch nicht $ false ... und auch keine leere Zeichenfolge. Ich sollte mehr auf "Es ist kein Python" achten.) Vielen Dank! (Und dieses Skript von Ihnen wird die Führung nicht mehr los 0:: /)
TessellatingHeckler
@TessellatingHeckler Nicht für den Bonus ist leider 13 Bytes kürzer - $i=[bigint]::Pow(4,64);while($i-gt0){('{0:X32}'-f($i-=1)-replace'0(?=.{32})'-replace'.{4}(?!$)','$0:')}bei 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
quelle
Ich weiß das, aber ich bin neu hier :(
rav_kr
Stellen Sie nur sicher, dass Sie es wissen. Vielen Dank.
mbomb007
Meinst du nicht 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

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.

Status
quelle
Wenn Ihre Antwort eine Funktion ist, müssen Sie sie nicht aufrufen :)
Beta Decay
@BetaDecay Dann war das mein Missverständnis. Fest! Vielen Dank.
Status
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"

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

Franky
quelle
Wie kompilieren Sie es, damit nicht der Speicher voll wird? Mit meinem ghc v7.10.2 und std. Kompilieroptionen es verliert Speicher.
nimi
2

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.

Psychonaut
quelle
Es sieht so aus, als ob Ihnen die Hälfte Ihrer Loops fehlt. Eine IPv6-Adresse besteht aus 128 Bit und nicht aus 64 Bit.
Mark
@Mark: Danke für den Hinweis! Ich habe das Problem behoben.
Psychonaut
2

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.

MegaTom
quelle
Holen Sie sich kürzere Funktionsdefinitionen mit Lambdas:x=->s,n{...};x['',8]
Türklinke
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
Wolfhammer
quelle