Cela me rappelle qu'il y a quelques années, quelqu'un a téléchargé un torrent "Outil de piratage: liste complète de toutes les adresses IP". Il s’agissait bien entendu d’une liste générée des quelque 4 milliards d’adresses IPv4, mais des milliers de «h4xx0rz» l’ont téléchargée. Regarde maman, imahacker!

C'était à l'époque, mais aujourd'hui, tout le monde est passé à IPv6 . (Droite?)

Votre tâche consiste à écrire un programme imprimant toutes les adresses IPv6 .

Vous devez écrire un programme complet ne prenant aucune entrée et imprimant les adresses IPv6, une par ligne, et aucune autre sortie. Votre programme doit imprimer les 2 ¹²⁸ adresses possibles, y compris les adresses non valides. Chaque adresse doit être imprimée exactement une fois. Vous pouvez imprimer les adresses dans n'importe quel ordre.

Chaque adresse peut être imprimée en entier, avec 8 groupes de 4 chiffres hexadécimaux séparés par des points, par exemple

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

Vous pouvez, à votre discrétion, utiliser l’une des abréviations standard du RFC 5952 :

• Les zéros non significatifs d'un groupe peuvent être omis, à l'exception de ceux qui 0ne peuvent pas être abrégés davantage.
• :: peut être utilisé au plus une fois par adresse pour abréger une séquence d'un ou de plusieurs groupes entièrement nuls.
• Les chiffres hexadécimaux peuvent utiliser des minuscules ou des majuscules.

Si vous atteignez la recommandation de représentation de la RFC 5952 (lettres minuscules uniquement, représentation la plus courte possible, ::utilisée le plus tôt possible s'il existe plusieurs endroits où elle peut être utilisée), vous obtenez un bonus de -20% .

En raison de la taille de la sortie, votre programme ne devrait pas se terminer tant que nous resterons assis. Votre programme peut être interrompu par des moyens externes à un moment donné ( Ctrl+ C, coupure de courant,…). Votre programme doit produire une sortie sous forme de flux, afin qu'après une attente «raisonnable», il ait généré des lignes. Fondamentalement, la construction d'une chaîne de caractères géante en mémoire uniquement pour l'imprimer à la fin n'est pas autorisée. Tout programme qui manquerait de mémoire sur un PC «standard» est disqualifié. (Néanmoins, si votre programme doit être exécuté suffisamment longtemps, il doit imprimer toutes les adresses IPv6 puis quitter.)

(Si cette condition pose un problème pour les interprètes Web qui exécutent le programme jusqu'à la fin, puis vous permettent d'afficher le résultat et que vous ne disposez pas d'un interprète hébergé, testez votre programme sur une version plus petite du problème, puis ajustez-le soigneusement. au maximum 2 ^128. )

Votre score est la longueur en octets de votre programme, multipliée par 0,8 si vous obtenez le bonus. C'est le code de golf, donc le score le plus bas gagne.

Pyth, 21 octets

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

Utilise une boucle while avec Jcomme variable itérateur. Initialise le maximum en utilisant 8^chr(' '). Pads en ajoutant cette valeur initiale, la conversion en hexadécimal, puis en supprimant le premier caractère.

Python 3, 65 octets · 0.8 = 52.0

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

Pyth, 27 25 24 octets

Note: le code avait un bogue précédemment, le corrigeant sauvé 1 octet

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

Imprime les adresses comme

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

Version précédente (plus compliquée) utilisant l'opérateur Pad (également 24 octets):

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

Explication

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 octets (invalide)

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

Cela ne peut pas être exécuté car 1) il consommerait au moins 2 ¹³² octets (2 ⁵² yobibytes) de mémoire et 2) l'interpréteur ne l'aime pas (2 ¹²⁸ n'entre pas ssize_t, donc pas de lists de cette taille) . Il imprimerait les adresses dans l'ordre lexicographique. Vous pouvez essayer l'algorithme en changeant le (s) numéro (s) en un objet utilisable.

C (avec extensions GCC), 76 octets * 0.8 = 60.8

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

Il utilise les entiers de 128 bits extension de GCC pour compter tout simplement de ::la ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff. inet_ntop()formate correctement chaque adresse pour que le bonus de -20% puisse être réclamé.

Sortie

Utilisant sedpour produire chaque millionième ligne jusqu'à 10 millions:

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

Remarque J'utilise une machine little-endian x86_64 et, comme les adresses réseau sont généralement toujours dans l'ordre du réseau (big-endian), l'endianité est donc efficacement permutée par inet_ntop(). Cela n'a pas d'importance - toutes les adresses seront toujours (éventuellement) affichées.

CJam, 36 27 octets

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

-9 octets grâce à @Dennis (j'ai oublié que CJam a un formatage de chaîne). Imprime les adresses minuscules et décroissantes.

Pour des raisons évidentes, utilisez l’interpréteur Java, pas celui en ligne. Vous pouvez toutefois remplacer G32#par quelque chose de plus petit pour les tests en ligne, par exemple , les 100 derniers .

Explication

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 octets

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

Comme effet secondaire de la méthode utilisée pour insérer les deux points, les adresses sont imprimées avec la colonne la plus à droite apparaissant à gauche:

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

Ma première soumission Verilog pourrait probablement utiliser davantage de golf, mais je n’ai pas l’énergie pour le faire pour le moment. cis clock, oest une sortie ASCII. Ne remplit pas les conditions pour bénéficier d'un bonus de mise en forme en raison de la mise à zéro et non de l'abréviation.

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

Il s’agit d’une simple itération suivie d’un peu de bricolage pour rendre la sortie ASCII. Je coupe le côlon après le dernier groupe avec un petit hack. Synthétise et semble fonctionner pour xc3s500e-4ft256-4 sur ISE 13.7 lin64.

C, 91-126 octets

Ma version originale, 119 octets.

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

Meilleure version portable au golf, 103 octets (merci à Dennis pour certains de ces concepts)

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

Explication: L’algorithme lui-même est relativement simple. J'ai utilisé long plutôt que unsigned int parce que c'est plus court. Les déclarer au niveau du fichier signifie que tout est pré-initialisé avec des zéros. La ffonction est un simple incrémentation avec retenue qui opère sur les 16 bits les plus bas de chaque mot. La boucle se termine quand elle passe dans le 129ème bit.

Une itération en arrière pour printf signifie que nous imprimons les adresses dans le "bon" ordre et que le contrôle pour l'impression d'une nouvelle ligne est plus court de quelques caractères.

Cela utilise des constructions non portables. Il est préférable de le considérer comme un dialecte K & R de C, car il utilise des types de retour int implicites et n'inclut pas stdio.h. Et mon utilisation de long a été informée par cela - sur la plupart des systèmes modernes, int est suffisant car 32 bits. Cela pourrait probablement fonctionner sans modification sur PDP-11 Unix.

Cependant, cela peut être plus court. Si nous supposons que nous pouvons utiliser int (soit comme un type plus large que 16 bits, ou un type d’exactement 16 bits avec diverses propriétés qui se vérifient sur de nombreux systèmes tels que le complément à deux et le basculement arithmétique), nous pouvons nous débarrasser de les trucs liés à l'utilisation de long.

Version pour int plus large que 16 bits, 97 octets.

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 pour les systèmes 16 bits, 91 octets.

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

Curieusement, cependant, le compilateur K & R original ne supportait pas la déclaration sans int (il compile bien, mais traite les variables comme externes et donc indéfinies au moment du lien), donc trois octets supplémentaires sont nécessaires pour changer la déclaration en int*p,a[9];pour un total de 94.

De plus, si l'hypothèse qu'il est interrompu avant la fin de la sortie était une contrainte difficile, nous pourrions supprimer le contrôle de fin en économisant cinq octets.

Bonus: version portable entièrement ANSI, 126 octets:

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

Les nouvelles lignes de toutes les versions sont insérées pour des raisons de lisibilité et aux emplacements où aucun espace n'est requis, et sont exclues du nombre d'octets, à l'exception de la nouvelle ligne après la #includeligne dans la version ANSI.

Toutes les versions, à l'exception de la version ANSI, tombent à la fin de la version principale et peuvent par conséquent renvoyer un code de sortie parasite au système d'exploitation.

AutoIt3, 142 231 octets

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

Explication

• For $a=0 To 2^32-1: Itérer 4 fois sur 0-2 ^ 32 ((2 ^ 32) ^ 4 = 2 ^ 128) combinaisons possibles.
• $s=StringFormat("%08x%08x%08x%08x",$a,$b,$c,$d): Convertir les nombres en chaîne hexadécimale d’une longueur de 32 (4 * 32).
• For $j=0 To 8: Itérer sur les 8 sections de la chaîne.
• ConsoleWrite(StringMid($s,$j*4+1,4)&($j<7?":":"")): Extrait les 4 prochains caractères de la chaîne et ajoute un signe deux-points ( :) à la fin, si nous n’avons pas atteint la dernière section, puis tout afficher sur la console
• Next: Termine la boucle for interne
• ConsoleWrite(@LF): Ajouter un saut de ligne à la fin de la ligne
• Next: Terminez les boucles externes

Taille de sortie attendue: (une ligne (39 octets) + saut de ligne) (= 40 octets) * 2 ^ 128 = 1,361 * 10 ^ 16 YB (yottabytes)

Cannelle, 16 octets

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

Essayez-le en ligne. (TIO limite la sortie)

Explication

Le gmode met Cinnamon Gum en mode de génération . Le reste de la chaîne se décompresse en cette 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]

Il crée ensuite un générateur de toutes les chaînes possibles qui correspondent à l'expression rationnelle et effectue une itération à travers celle-ci, en affichant chacune d'elles.

De manière assez amusante, la regex golfier ([0-9a-f]{4,4}:){7,7}[0-9a-f]{4,4}compresse en fait une chaîne plus longue que la regex ci-dessus.

Commodore BASIC 2.0, 339 octets

Pour obtenir des chiffres hexadécimaux minuscules, ce programme est écrit en "mode décalé" (appuyez sur <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

Faire fonctionner ce système sur le Commodore 64 était un véritable défi en raison de la mémoire, de la taille de l’écran, de la taille des données et d’autres limitations. J'ai envisagé d'implémenter la représentation abrégée, mais d'autres limitations (telles que l'incapacité non documentée d'utiliser des éléments de tableau en tant qu'indices de boucle) impliquaient une augmentation de la longueur du programme d'environ 1000 octets.

La ligne 7 est une implémentation de HEX$()laquelle Commodore BASIC 2.0 fait défaut. Je ne peux pas utiliser un DEF FNpour cela car ceux-ci ne peuvent que renvoyer des nombres, pas des chaînes. La ligne 6 est un sous-programme qui l’applique à un groupe de quatre chiffres, ce qui aurait été considérablement plus court si les fonctions pouvaient renvoyer des chaînes.

Les lignes 2 et 5 sont huit boucles imbriquées, implémentées comme sept boucles "pour" et une condition conditionnelle, car huit boucles pour "," combinées aux deux "gosubs" pour imprimer l'adresse débordent de la pile minuscule du C64.

Un C64 peut imprimer environ 1,2 adresse par seconde, pour un temps d'exécution estimé à 1,3 * 10 ^ 31 ans.

PowerShell (v4), 193 166 162 145 103 octets

La version sans bonus de TimmyD à 103 octets:

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

Version précédente avec bonus à 145 * 0.8 = 116 octets

Avec l' aide de TimmyD et tomkandy , qui souligne que , 0 -eq $falsemais ([bigint]0) -eq $true. Donc, toutes mes versions précédentes ne se termineront pas.

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

Auparavant à 162, avant quelques changements de 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}

"Un défi où PowerShell doit être raisonnablement compétitif!" - moi, avant de l'essayer.

Explication

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

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 octets

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

Parcourt simplement tous les nombres de 0 à 2 ^ 128. Il convertit d'abord le nombre actuel en chaîne hexadécimale, puis supprime le résultat de la '0x'fonction. Ensuite, il ajuste la chaîne de manière à avoir 32 zéros à l’avant, puis la divise en groupes de quatre. Enfin, il joint les groupes de quatre avec des deux points, les imprime et ajoute 1 au nombre actuel. A le bonus supplémentaire que vous pouvez le démarrer à n'importe quelle valeur si vous lui donnez un, mais aucune entrée n'est nécessaire.

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"

Avec ma propre fonction de séquence, sil ne perd plus de mémoire, mais ne se sent plus joué au golf.

CBM BASIC v7.0 (166 caractères)

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 réponse de Mark concerne BASIC 2.0 du Commodore 64, pour lequel il manque une commande intégrée permettant d’imprimer des nombres au format hexadécimal. Cependant, grâce à la HEX$()fonction de BASIC 7.0, la version du Commodore 128 est beaucoup plus courte. Il ne tient pas sur une seule ligne logique (limitée à 160 caractères sur le C128), mais peut toujours être saisi en tant que deux lignes distinctes en mode direct.

Ruby 75

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

C'est une solution récursive qui prend un préfixe et trouve tous les suffixes possibles. Récursivement.

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