45

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.

code-golf kolmogorov-complexity Gilles, arrête de faire le mal
la source

22

Cela représente 5,445 * 10¹⁵ yottabytes. Pour stocker toutes ces données, vous avez besoin d'au moins 15 centres de données de la taille de la Terre ne contenant que des disques durs regroupés aussi étroitement que possible. C'est un gros torrent .....

Kaz Wolfe

7

@Mew Je me demande cependant si le fichier serait compressé (en utilisant une compression générique telle que gzip).

SztupY

35

@SztupY: apparemment, la sortie peut être compressée à 25 octets (algorithme de décompression = un interpréteur Pyth, algorithme de compression = publication sur PPCG) De ce site, il semble que Pyth soit un format compressé plutôt générique.

Ben Voigt

3

D'après mon expérience, @Gilles est vraiment un poids lourd! Heureux de vous voir poser des questions à notre petit coin de SO PPCG! Aussi amusant pour moi de voir les questions liées au réseau.

Digital Trauma

5

Cela me rappelle cette question "itérer sur tous les GUID possibles" sur SO.

MikeTheLiar

5

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.

isaacg
la source

Ce code ressemble à quelqu'un qui a éternué sur son clavier, puis a essayé de le nettoyer.

darksky

@darksky C'est des golflangs pour vous: P

Esolanging Fruit

50

Python 3, 65 octets · 0.8 = 52.0

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

Anders Kaseorg
la source

7

Dang Python! Il a toujours les bonnes méthodes! : D

MayorMonty

ipaddressest python3 seulement.

@ Hurricane996, oui, je l'utilisais avec PyPI dans Python 2 sans me rendre compte qu'il n'entrait que dans la bibliothèque standard de Python 3. Je suis donc passé à Python 3 au détriment d'un octet.

Anders Kaseorg

@MDXF Python n'a pas ++ ou - opérateurs

Draconis

14

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.

PurkkaKoodari
la source

1

Qu'en est-il de ... " Tout programme qui manquerait de mémoire sur un PC" standard "est disqualifié." ?

TessellatingHeckler

2

@TessellatingHeckler Le premier ne le fera pas, car il fonctionne de manière itérative. Le deuxième que j'ai clairement marqué comme invalide.

PurkkaKoodari

12

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.

Trauma numérique
la source

11

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

Sp3000
la source

1

Ce qui est intéressant, c’est que l’interprète en ligne, en plus de ne pas pouvoir gérer la taille bien sûr, imprime également le résultat faux. Si vous supprimez la boucle et imprimez uniquement la première valeur, elle est imprimée 0000:0000:0000:0000:0000:0000:ffff:ffff. On dirait que le formatage de la chaîne pourrait fonctionner différemment en ligne. J'ai confirmé que cela fonctionne bien avec la version hors ligne.

Reto Koradi

nest le même que oNodans TIO .

Esolanging Fruit le

8

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

Xsot
la source

1

La rotation est vraiment chouette! Aussi tardif, mais bienvenue de l'anarchie :)

Sp3000

3

Si vous dites que la colonne la plus à droite est à gauche, elle imprime des adresses IPv6 non valides, mais si les colonnes sont aux bons emplacements, c'est bien [printing] the addresses in any order. ;)

TessellatingHeckler

7

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.

ζ--
la source

6

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.

Au hasard832
la source

1

La portabilité n’est généralement pas un problème ici. Cela fonctionne sur ma machine: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

Tu es clairement bien meilleur que moi pour ça. Certaines de ces personnes me surprennent beaucoup, mais j’aurais vraiment dû penser à la i--vérification de mon état.

Random832

Lorsque vous avez testé cela, l'avez-vous exécuté jusqu'au transport? Ma machine met une valeur aléatoire dans un [0] après le basculement dans votre version.

Random832

Oui. Les 6 553 601 premières adresses IP sont imprimées correctement sur ma machine.

Dennis

Ideone ne l'aime pas non plus, mais cela fonctionne avec le codepad: enveloppera[0] et enveloppera[1]

Dennis

5

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)

Arbre géant
la source

Tu ne veux pas dire 4^64 - 1?

Anders Kaseorg

@AndersKaseorg apparemment, je dois même utiliser 4 boucles allant jusqu'à 2 ^ 32-1, car AutoIt peut analyser des valeurs élevées comme 4 ^ 64, mais ne peut pas les stocker pour les utiliser dans une boucle, car les entiers ne dépassent que 2 ^ 32. -1 dans AutoIt.

GiantTree

5

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.

un spaghetto
la source

4

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.

marque
la source

4

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

}

TessellatingHeckler
la source

95 sans bonus. Merci à vous deux pour m'avoir présenté [bigint], c'est plutôt pratique (pour des choses que je ne devrais pas faire en premier lieu ...)for($g=[bigint]::pow(2,128);$g;$g-=1){'{0:X32}'-f$g-replace'(?=(.{4})+$)',':'-replace'^0+:',''}

tomkandy

Désolé devrait êtrefor($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*:',''}Oui, la première adresse est fausse mais elle ne se répète pas à la fin. Notez également que while($i)chez vous, ne vous arrêtez pas à zéro - est [boolean][bigint]0considéré comme vrai

tomkandy

@tomkandy oh wow, je dois avoir seulement testé la fin en définissant $ i = 5 en tant qu'int. (Le complexe 0 n'est pas non plus $ false ... ni la chaîne vide. Je devrais faire plus attention à "ce n'est pas du Python"). Merci! (Et votre script ne se débarrasse plus du premier 0:: /)

TessellatingHeckler

@TessellatingHeckler Ne pas viser le bonus est malheureusement de 13 octets plus court - $i=[bigint]::Pow(4,64);while($i-gt0){('{0:X32}'-f($i-=1)-replace'0(?=.{32})'-replace'.{4}(?!$)','$0:')}à 103 ...

AdmBorkBork

3

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

rav_kr
la source

Je le sais mais je suis nouveau ici :(

rav_kr

Assurez-vous simplement de savoir. Merci.

mbomb007

Tu ne veux pas dire 4^64 - 1?

Anders Kaseorg

2

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.

Statut
la source

Si votre réponse est une fonction, vous n'avez pas besoin de l'appeler :)

Beta Decay

@BetaDecay Ensuite, c'était mon malentendu. Fixé! Merci.

Statut

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"

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

Franky
la source

Comment le compilez-vous pour qu'il ne manque pas de mémoire? Avec mon ghc v7.10.2 et std. options de compilation, il fuit de la mémoire.

nimi

2

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.

Psychonaute
la source

On dirait que vous manquez la moitié de vos boucles. Une adresse IPv6 est 128 bits, pas 64 bits.

Marc

@Mark: Merci de l'avoir signalé! J'ai résolu le problème.

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)

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

MegaTom
la source

Obtenez des définitions de fonction plus courtes avec les lambdas:x=->s,n{...};x['',8]

Poignée de porte

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

marteau-loup
la source

Imprimer toutes les adresses IPv6

Réponses:

Pyth, 21 octets

Python 3, 65 octets · 0.8 = 52.0

Pyth, 27 25 24 octets

Explication

Pyth, 21 octets (invalide)

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

Sortie

CJam, 36 27 octets

Explication

Python 2.7, 67 octets

Verilog, 335

C, 91-126 octets

AutoIt3, 142 231 octets

Explication

Cannelle, 16 octets

Explication

Commodore BASIC 2.0, 339 octets

PowerShell (v4), 193 166 162 145 103 octets

AutoIt3, 137 octets

Python 2, 95 octets

Haskell 111

CBM BASIC v7.0 (166 caractères)

Ruby 75

Tcl 341 318 301