สิ่งนี้เตือนฉันเมื่อไม่กี่ปีที่ผ่านมามีคนอัพโหลดทอร์เรนต์ "เครื่องมือแฮ็กเกอร์: รายการที่อยู่ IP ทั้งหมด" แน่นอนนี่เป็นเพียงรายการที่สร้างขึ้นจากที่อยู่ IPv4 ~ 4 พันล้านรายการ แต่ "h4xx0rz" นับพันดาวน์โหลด ดูแม่ imahacker!

ตอนนี้ทุกวันนี้ทุกคนเปลี่ยนมาใช้IPv6แล้ว (ขวา?)

งานของคุณคือการเขียนโปรแกรมที่พิมพ์ออกทั้งหมดอยู่ IPv6

คุณควรเขียนโปรแกรมเต็มรูปแบบที่ไม่มีอินพุตและพิมพ์ที่อยู่ IPv6 หนึ่งรายการต่อบรรทัดและไม่มีเอาต์พุตอื่น โปรแกรมของคุณจะต้องพิมพ์ที่อยู่ทั้งหมด 2 ¹²⁸ที่อยู่รวมถึงที่อยู่ที่ไม่ถูกต้อง แต่ละที่อยู่จะต้องพิมพ์อย่างแน่นอนหนึ่งครั้ง คุณสามารถพิมพ์ที่อยู่ในลำดับใดก็ได้

แต่ละที่อยู่อาจพิมพ์เต็มจำนวนโดยมี 8 กลุ่มเป็นเลขฐานสิบหก 4 ตัวคั่นด้วยเครื่องหมายโคลอนเช่น

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

คุณอาจใช้ตัวย่อมาตรฐานใด ๆ จากRFC 5952ตามดุลยพินิจของคุณ:

• ค่าศูนย์นำหน้าในกลุ่มอาจถูกละเว้นยกเว้นว่า0ไม่สามารถย่อได้อีก
• :: อาจใช้อย่างน้อยหนึ่งครั้งต่อหนึ่งที่อยู่เพื่อย่อลำดับของกลุ่มทั้งหมดที่เป็นศูนย์อย่างน้อยหนึ่งกลุ่ม
• ตัวเลขฐานสิบหกอาจใช้ตัวพิมพ์เล็กหรือตัวพิมพ์ใหญ่

หากคุณบรรลุข้อเสนอแนะจากตัวแทน RFC 5952 (ตัวพิมพ์เล็กเท่านั้นเป็นตัวแทนที่สั้นที่สุดที่มี::ใช้อย่างเร็วที่สุดเท่าที่เป็นไปได้ถ้ามีหลายสถานที่ที่มันสามารถนำมาใช้) คุณจะได้รับโบนัส 20%

เนื่องจากขนาดของเอาต์พุตโปรแกรมของคุณไม่คาดว่าจะเสร็จในขณะที่เรานั่งอยู่ที่นั่น โปรแกรมของคุณอาจถูกขัดจังหวะด้วยวิธีการภายนอกบางอย่าง ( Ctrl+ C, ดึงกำลังไฟ, ... ) โปรแกรมของคุณจะต้องสร้างเอาต์พุตเป็นสตรีมดังนั้นหลังจากรอ "สมเหตุสมผล" โปรแกรมจะสร้างบางบรรทัด โดยทั่วไปการสร้างสตริงขนาดยักษ์ในหน่วยความจำเท่านั้นเพื่อพิมพ์ในตอนท้ายไม่ได้รับอนุญาต โปรแกรมใดก็ตามที่หน่วยความจำไม่เพียงพอบนพีซี“ มาตรฐาน” จะถูกตัดสิทธิ์ (อย่างไรก็ตามหากโปรแกรมของคุณถูกปล่อยให้ทำงานเป็นเวลานานพอสมควรจะต้องพิมพ์ที่อยู่ IPv6 ทั้งหมดจากนั้นออก)

(หากเงื่อนไขนี้เป็นปัญหาสำหรับเว็บล่ามที่รันโปรแกรมจนเสร็จสิ้นจากนั้นให้คุณเห็นผลลัพธ์และคุณไม่มีล่ามที่โฮสต์ให้ทดสอบโปรแกรมของคุณในปัญหาที่มีขนาดเล็กลงจากนั้นจึงปรับอย่างระมัดระวัง เต็ม 2 ¹²⁸ )

คะแนนของคุณคือความยาวของโปรแกรมเป็นไบต์คูณด้วย 0.8 ถ้าคุณได้รับโบนัส มันคือรหัสกอล์ฟดังนั้นคะแนนต่ำสุดชนะ

Pyth, 21 ไบต์

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

ใช้วนลูปในขณะที่Jเป็นตัวแปรตัววนซ้ำ 8^chr(' ')เริ่มต้นใช้สูงสุด เพิ่มแผ่นโดยการเพิ่มค่าเริ่มต้นแปลงเป็นเลขฐานสิบหกจากนั้นนำอักขระตัวแรกออก

Python 3, 65 ไบต์· 0.8 = 52.0

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

Pyth, 27 25 24 ไบต์

หมายเหตุ: รหัสมีข้อผิดพลาดก่อนหน้านี้แก้ไขได้บันทึก 1 ไบต์

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

พิมพ์ที่อยู่เช่น

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

รุ่นก่อนหน้า (ซับซ้อนมากขึ้น) โดยใช้ตัวดำเนินการเสริม (เช่น 24 ไบต์):

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

คำอธิบาย

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 ไบต์ (ไม่ถูกต้อง)

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

ไม่สามารถทำงานได้ตั้งแต่ 1) มันจะใช้หน่วยความจำอย่างน้อย 2 ¹³²ไบต์ (2 ⁵² yobibytes) และ 2) ล่ามไม่ชอบ (2 ¹²⁸ไม่พอดีssize_tดังนั้นจึงไม่มีlistขนาดนั้น) . มันจะพิมพ์ที่อยู่ตามลำดับพจนานุกรม คุณสามารถลองใช้อัลกอริทึมโดยเปลี่ยนจำนวนในท้ายที่สุดเป็นสิ่งที่ใช้งานได้

C (ที่มีนามสกุล GCC), 76 ไบต์ * 0.8 = 60.8

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

นี้ใช้128 บิตขยายจำนวนเต็ม GCCจะเพียงแค่นับขึ้นจากการ :: จัดรูปแบบที่อยู่แต่ละที่ให้ถูกต้องเพื่อให้สามารถขอรับโบนัสได้ -20%ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffffinet_ntop()

เอาท์พุต

ใช้sedเพื่อส่งออกทุกบรรทัดที่ล้านถึง 10 ล้าน:

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

หมายเหตุผมใช้เครื่อง x86_64 น้อย endian และที่อยู่เครือข่ายมักจะเสมอในเครือข่ายการสั่งซื้อ (big-) ดังนั้น endianness inet_ntop()จะเปลี่ยนได้อย่างมีประสิทธิภาพโดยใช้ ไม่สำคัญ - ที่อยู่ทั้งหมดจะยังคงปรากฏ (ในที่สุด)

CJam, 36 27 ไบต์

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

-9 ไบต์ขอบคุณ @Dennis (ฉันลืมว่า CJam มีการจัดรูปแบบสตริง) พิมพ์ที่อยู่ตัวพิมพ์เล็กและจากมากไปน้อย

ด้วยเหตุผลที่ชัดเจนให้ใช้ล่าม Java ไม่ใช่ตัวแปลออนไลน์ คุณสามารถแทนที่G32#ด้วยสิ่งที่มีขนาดเล็กสำหรับการทดสอบออนไลน์แม้ว่าเช่นนี่คือช่วง 100

คำอธิบาย

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 ไบต์

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

ในฐานะที่เป็นผลข้างเคียงของวิธีที่ใช้แทรกโคลอนที่อยู่จะถูกพิมพ์ด้วยคอลัมน์ด้านขวาสุดที่ปรากฏทางด้านซ้าย:

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

การส่ง Verilog ครั้งแรกของฉันอาจใช้การตีกอล์ฟได้มากกว่า แต่ตอนนี้ฉันไม่มีพลังพอที่จะทำได้ cคือนาฬิกาoคือเอาต์พุต ASCII ไม่ได้รับสิทธิ์ในการจัดรูปแบบโบนัสเนื่องจากการเติมเต็มเป็นศูนย์แทนที่จะย่อตัว

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

นี่เป็นการวนซ้ำอย่างง่ายตามด้วยการทวิบิตเพื่อทำให้เอาต์พุต ASCII ฉันตัดลำไส้หลังกลุ่มสุดท้ายด้วยการแฮ็กขนาดเล็ก สังเคราะห์และดูเหมือนจะทำงานกับ xc3s500e-4ft256-4 บน ISE 13.7 lin64

C, 91-126 ไบต์

เวอร์ชันเดิมของฉัน 119 ไบต์

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

รุ่นพกพาที่ดีที่สุด golfed-ish, 103 ไบต์ (ขอบคุณ @Dennis สำหรับแนวคิดเหล่านี้บางส่วน)

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

คำอธิบาย: อัลกอริทึมของตัวเองตรงไปตรงมาพอสมควร ฉันใช้นานมากกว่า int ที่ไม่ได้ลงนามเพราะสั้นกว่า การประกาศที่ระดับไฟล์หมายความว่าทุกอย่างถูกกำหนดค่าเริ่มต้นด้วยเลขศูนย์ fฟังก์ชั่นที่เพิ่มขึ้นเป็นที่เรียบง่ายกับการพกพาที่ทำงานบนต่ำ 16 บิตของแต่ละคำ ลูปจะสิ้นสุดลงเมื่อมีการดำเนินการเป็นบิตที่ 129

การวนซ้ำไปข้างหลังสำหรับ printf หมายความว่าเราพิมพ์ที่อยู่ตามลำดับ "ถูกต้อง" และการตรวจสอบการพิมพ์ขึ้นบรรทัดใหม่นั้นมีความยาวไม่กี่ตัวอักษร

สิ่งนี้ใช้โครงสร้างที่ไม่สามารถพกพาได้ เป็นที่รู้จักกันดีในฐานะภาษา K&R ของ C เนื่องจากใช้ประเภทการส่งคืนโดยนัยและไม่รวม stdio.h และการใช้งานที่ยาวนานของฉันได้รับแจ้งจากเรื่องนี้ - ในระบบที่ทันสมัยส่วนใหญ่ก็เพียงพอแล้วเพราะมันคือ 32 บิต สิ่งนี้อาจเรียกใช้ unmodified บน PDP-11 Unix

อย่างไรก็ตามอาจสั้นกว่านี้ได้ หากเราสมมติว่าเราสามารถใช้ int (ไม่ว่าจะเป็นชนิดที่กว้างกว่า 16 บิตหรือประเภท 16 บิตที่มีคุณสมบัติหลากหลายที่เป็นจริงในหลาย ๆ ระบบเช่นการเติมเต็ม twos และเลขคณิตแบบโรลโอเวอร์) เราสามารถกำจัด สิ่งที่เกี่ยวข้องกับการใช้งานนาน

เวอร์ชันสำหรับ int ที่กว้างกว่า 16 บิต 97 ไบต์

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

เวอร์ชันสำหรับระบบ 16 บิต 91 ไบต์

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

อย่างไรก็ตามผู้แปล K&R ดั้งเดิมไม่สนับสนุนการประกาศโดยไม่ต้องใช้ int (มันคอมไพล์ได้ดี แต่ถือว่าตัวแปรเป็นภายนอกและไม่ได้กำหนดไว้ ณ เวลาลิงก์) ดังนั้นจึงจำเป็นต้องเพิ่มสามไบต์เพิ่มเติมเพื่อเปลี่ยนการประกาศint*p,a[9];เป็น รวม 94

นอกจากนี้หากข้อสันนิษฐานว่ามันถูกขัดจังหวะก่อนที่จะเสร็จสิ้นการส่งออกเป็นข้อ จำกัด อย่างหนักเราสามารถลบการตรวจสอบปลายที่บันทึกห้าไบต์

โบนัส: เวอร์ชันพกพา ANSI ที่สมบูรณ์, 126 ไบต์:

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

บรรทัดใหม่ในทุกรุ่นจะถูกแทรกเพื่อให้สามารถอ่านได้และในสถานที่ที่ไม่ต้องการช่องว่างและจะถูกแยกออกจากการนับไบต์ยกเว้นสำหรับการขึ้นบรรทัดใหม่หลังจาก#includeบรรทัดในเวอร์ชัน ANSI

ทุกรุ่นยกเว้นรุ่น ANSI ที่อยู่ท้ายสุดของหลักและอาจส่งคืนรหัสทางออกปลอมไปยังระบบปฏิบัติการ

AutoIt3, 142 231 ไบต์

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

คำอธิบาย

• For $a=0 To 2^32-1: ซ้ำ 4 ครั้งในช่วง 0-2 ^ 32 ((2 ^ 32) ^ 4 = 2 ^ 128) ชุดค่าผสมที่เป็นไปได้
• $s=StringFormat("%08x%08x%08x%08x",$a,$b,$c,$d): แปลงตัวเลขเป็นสตริงเลขฐานสิบหกที่มีความยาว 32 (4 * 32)
• For $j=0 To 8: ทำซ้ำส่วนทั้งหมด 8 ส่วนของสตริง
• ConsoleWrite(StringMid($s,$j*4+1,4)&($j<7?":":"")): แยก 4 ตัวอักษรถัดไปจากสตริงและเพิ่มโคลอน ( :) ที่ท้ายถ้าเรายังไม่ถึงส่วนสุดท้ายแล้วเอาทุกอย่างไปยังคอนโซล
• Next: สิ้นสุดส่วนวงภายใน
• ConsoleWrite(@LF): เพิ่มการป้อนบรรทัดที่ท้ายบรรทัด
• Next: จบด้านนอกสำหรับลูป

ขนาดเอาต์พุตที่คาดหวัง: (หนึ่งบรรทัด (39 ไบต์) + ป้อนบรรทัด) (= 40 ไบต์) * 2 ^ 128 = 1.361 * 10 ^ 16 YB (yottabytes)

หมากฝรั่งอบเชย, 16 ไบต์

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

ลองออนไลน์ (TIO จำกัด เอาต์พุต)

คำอธิบาย

gโหมดทำให้อบเชยหมากฝรั่งในโหมดสร้าง ส่วนที่เหลือของสตริงจะขยายไปยัง 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]

จากนั้นจะสร้างตัวกำเนิดของสตริงที่เป็นไปได้ทั้งหมดที่ตรงกับ regex และวนซ้ำผ่านมันพิมพ์ออกมาแต่ละอัน

ค่อนข้างที่น่าประหลาดใจนักกอล์ฟ regex ([0-9a-f]{4,4}:){7,7}[0-9a-f]{4,4}บีบอัดจริงเพื่อสตริงยาวกว่า regex ข้างต้น

Commodore BASIC 2.0, 339 bytes

เพื่อให้ได้ตัวเลขฐานสิบหกตัวเล็กโปรแกรมนี้เขียนใน "shifted mode" (กด<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

เพียงแค่ทำให้งานนี้กับ Commodore 64 เป็นเรื่องที่ท้าทายเนื่องจากหน่วยความจำขนาดหน้าจอขนาดข้อมูลและข้อ จำกัด อื่น ๆ ฉันพิจารณาการใช้การนำเสนอแบบย่อ แต่ข้อ จำกัด อื่น ๆ (เช่นความไม่สามารถที่ไม่ได้ลงทะเบียนเพื่อใช้องค์ประกอบอาร์เรย์เป็นดัชนีวนรอบ) หมายความว่ามันจะเพิ่มความยาวของโปรแกรมโดยประมาณ 1,000 ไบต์

บรรทัดที่ 7 คือการนำไปใช้งานHEX$()ซึ่ง Commodore BASIC 2.0 กำลังขาดแคลน ฉันไม่สามารถใช้ a DEF FNสำหรับสิ่งนี้ได้เพราะสิ่งเหล่านั้นสามารถส่งกลับตัวเลขเท่านั้นไม่ใช่สตริง บรรทัด 6 คือรูทีนย่อยที่ใช้กับกลุ่มตัวเลขสี่หลักซึ่งจะสั้นกว่านี้มากหากฟังก์ชันสามารถส่งคืนสตริงได้

บรรทัดที่ 2 และ 5 เป็นแปดลูปซ้อนกันดำเนินการเป็นเจ็ด "สำหรับ" ลูปและเงื่อนไขที่ได้รับเพราะแปด "สำหรับ" ลูปเมื่อรวมกับ "gosubs" ทั้งสองสำหรับการพิมพ์ที่อยู่จะล้นกองเล็ก ๆ ของ C64

C64 สามารถพิมพ์ที่อยู่ประมาณ 1.2 ต่อวินาทีสำหรับรันไทม์โดยประมาณ 1.3 * 10 ^ 31 ปี

PowerShell (v4), 193 166 162 145 103 ไบต์

เวอร์ชันไม่มีโบนัสของ TimmyD ที่ 103 ไบต์:

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

รุ่นก่อนหน้าพร้อมกับโบนัสที่ 145 * 0.8 = 116 ไบต์

ด้วยความช่วยเหลือจากTimmyDและtomkandyที่ชี้ให้เห็นว่าแต่0 -eq $false ([bigint]0) -eq $trueดังนั้นเวอร์ชันก่อนหน้าของฉันทั้งหมดจะไม่ยุติลง

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

ก่อนหน้านี้ที่ 162 ก่อนที่จะมีการเปลี่ยนแปลง 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}

"ความท้าทายที่ PowerShell ควรมีความสามารถพอสมควร!" - ฉันก่อนที่ฉันจะลอง

คำอธิบาย

# 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 ไบต์

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 ไบต์

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

เพียงแค่ผ่านทุกหมายเลขตั้งแต่ 0 ถึง 2 ^ 128 ก่อนอื่นมันจะแปลงตัวเลขปัจจุบันเป็นสตริงเลขฐานสิบหกจากนั้นตัดการ'0x'ทำงานนั้นออก ถัดไปจะปรับสตริงให้มี 32 ศูนย์ด้านหน้าแล้วแบ่งออกเป็นกลุ่มสี่ ในที่สุดมันจะรวมกลุ่มของสี่กับโคลอนพิมพ์ออกมาและเพิ่ม 1 เข้ากับหมายเลขปัจจุบัน มีโบนัสเพิ่มที่คุณสามารถเริ่มได้ทุกเมื่อหากคุณให้มัน แต่ไม่จำเป็นต้องป้อนข้อมูล

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"

ด้วยฟังก์ชั่นต่อเนื่องของฉันเองsมันไม่รั่วซึมหน่วยความจำอีกต่อไป

CBM BASIC v7.0 (166 ตัวอักษร)

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

คำตอบของมาร์คนั้นใช้สำหรับ BASIC 2.0 ของ Commodore 64 ซึ่งขาดคำสั่งในตัวสำหรับการพิมพ์ตัวเลขเป็นเลขฐานสิบหก อย่างไรก็ตามด้วยHEX$()ฟังก์ชันใน BASIC 7.0 ทำให้รุ่น Commodore 128 นั้นสั้นกว่ามาก มันไม่พอดีกับสายตรรกะเดียว (ซึ่งใน C128 นั้น จำกัด อยู่ที่ 160 ตัวอักษร) แต่ยังสามารถป้อนเป็นสองบรรทัดแยกในโหมดโดยตรง

ทับทิม 75

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

นี่เป็นโซลูชันแบบเรียกซ้ำที่ใช้คำนำหน้าแต่ละคำและค้นหาคำต่อท้ายที่เป็นไปได้ทั้งหมด ซ้ำ

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