Điều này nhắc nhở tôi khi một vài năm trước ai đó đã tải lên một "công cụ Hacker: danh sách đầy đủ tất cả các địa chỉ IP". Tất nhiên, đây chỉ là một danh sách được tạo ra của ~ 4 tỷ địa chỉ IPv4, nhưng hàng ngàn "h4xx0rz" đã tải xuống nó. Nhìn mẹ, imahacker!

Điều này đã xảy ra sau đó, nhưng ngày nay mọi người đã chuyển sang IPv6 . (Đúng?)

Nhiệm vụ của bạn là viết một chương trình in ra tất cả các địa chỉ IPv6 .

Bạn nên viết một chương trình đầy đủ không có đầu vào và in địa chỉ IPv6, mỗi địa chỉ trên một dòng và không có đầu ra nào khác. Chương trình của bạn phải in tất cả 2 ¹²⁸ địa chỉ có thể, bao gồm cả những địa chỉ không hợp lệ. Mỗi địa chỉ phải được in chính xác một lần. Bạn có thể in các địa chỉ theo thứ tự bất kỳ.

Mỗi địa chỉ có thể được in đầy đủ, với 8 nhóm 4 chữ số thập lục phân cách nhau bằng dấu hai chấm, ví dụ:

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

Theo quyết định của bạn, bạn có thể sử dụng bất kỳ chữ viết tắt tiêu chuẩn nào từ RFC 5952 :

• Các số 0 đứng đầu trong một nhóm có thể được bỏ qua, ngoại trừ 0không thể viết tắt thêm.
• :: có thể được sử dụng nhiều nhất một lần cho mỗi địa chỉ để viết tắt một chuỗi gồm một hoặc nhiều nhóm hoàn toàn không.
• Các chữ số thập lục phân có thể sử dụng chữ thường hoặc chữ hoa.

Nếu bạn đạt được đề xuất đại diện từ RFC 5952 (chỉ chữ thường, đại diện ngắn nhất có thể, ::được sử dụng càng sớm càng tốt nếu có nhiều nơi có thể sử dụng), bạn sẽ nhận được phần thưởng -20% .

Do kích thước của đầu ra, chương trình của bạn dự kiến ​​sẽ không hoàn thành trong khi chúng tôi đang ngồi ở đó. Chương trình của bạn có thể bị gián đoạn bởi các phương tiện bên ngoài tại một số điểm ( Ctrl+ C, rút ​​nguồn, Mạnh). Chương trình của bạn phải tạo đầu ra dưới dạng luồng, để sau khi chờ đợi hợp lý, thì nó sẽ tạo ra một số dòng. Về cơ bản, việc xây dựng một chuỗi khổng lồ trong bộ nhớ chỉ để in nó ở cuối là không được phép. Bất kỳ chương trình nào hết bộ nhớ trên PC PC tiêu chuẩn của MIT đều bị loại. (Tuy nhiên, nếu chương trình của bạn còn lại để chạy đủ lâu, nó phải in tất cả các địa chỉ IPv6 và sau đó thoát.)

(Nếu điều kiện này là sự cố đối với trình thông dịch web chạy chương trình cho đến khi hoàn thành và sau đó cho phép bạn xem đầu ra và bạn không có trình thông dịch được lưu trữ, hãy kiểm tra chương trình của bạn trên phiên bản nhỏ hơn của sự cố, sau đó điều chỉnh cẩn thận đến toàn bộ 2 ^128. )

Điểm của bạn là độ dài chương trình của bạn tính bằng byte, nhân với 0,8 nếu bạn nhận được tiền thưởng. Đó là mã golf, vì vậy điểm thấp nhất sẽ thắng.

Bình thường, 21 byte

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

Sử dụng một vòng lặp while với Jbiến iterator. Khởi tạo tối đa bằng cách sử dụng 8^chr(' '). Các miếng đệm bằng cách thêm giá trị ban đầu đó, chuyển đổi thành hex, sau đó loại bỏ ký tự đầu tiên.

Python 3, 65 byte · 0.8 = 52.0

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

Bình thường, 27 25 24 byte

Lưu ý: mã đã có lỗi trước đó, sửa nó đã lưu 1 byte

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

In các địa chỉ như

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

Phiên bản trước (phức tạp hơn) sử dụng toán tử pad (cũng 24 byte):

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

Giải trình

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 byte (không hợp lệ)

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

Điều này không thể chạy được vì 1) nó sẽ tiêu tốn ít nhất 2 ¹³² byte (2 ⁵² yobibytes) bộ nhớ và 2) trình thông dịch không thích nó (2 ¹²⁸ không phù hợp ssize_t, vì vậy không có listkích thước đó) . Nó sẽ in các địa chỉ theo thứ tự từ điển. Bạn có thể thử thuật toán bằng cách thay đổi (các) số cuối cùng thành thứ gì đó có thể sử dụng được.

C (có phần mở rộng GCC), 76 byte * 0.8 = 60.8

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

Điều này sử dụng phần mở rộng GCC số nguyên 128 bit để chỉ cần đếm từ ::đến ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff. inet_ntop()định dạng chính xác từng địa chỉ để có thể nhận phần thưởng -20%.

Đầu ra

Sử dụng sedđể đầu ra mỗi dòng thứ một triệu lên tới 10 triệu:

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

Lưu ý Tôi đang sử dụng máy x86_64 endian nhỏ và các địa chỉ mạng thường luôn theo thứ tự mạng (big endian), do đó, endian được hoán đổi hiệu quả bằng cách sử dụng inet_ntop(). Điều này không quan trọng - tất cả các địa chỉ sẽ vẫn (cuối cùng) sẽ được hiển thị.

CJam, 36 27 byte

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

-9 byte nhờ @Dennis (Tôi quên rằng CJam có định dạng chuỗi). In các địa chỉ chữ thường và giảm dần.

Vì các lý do rõ ràng, hãy sử dụng trình thông dịch Java, không phải trình thông dịch trực tuyến. Bạn có thể thay thế G32#bằng một cái gì đó nhỏ hơn để thử nghiệm trực tuyến, ví dụ: đây là 100 cái cuối cùng .

Giải trình

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 byte

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

Là một tác dụng phụ của phương pháp được sử dụng để chèn dấu hai chấm, các địa chỉ được in với cột ngoài cùng bên phải xuất hiện ở bên trái:

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

Phiên bản, 335

Lần gửi Verilog đầu tiên của tôi, có thể có thể sử dụng nhiều môn đánh gôn hơn nhưng tôi không có năng lượng để làm điều đó ngay bây giờ. clà đồng hồ, olà đầu ra ASCII. Không đủ điều kiện để định dạng tiền thưởng do không đệm thay vì viết tắt.

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

Đây là một phép lặp đơn giản theo sau bởi một số thao tác xoay vòng để tạo ra ASCII đầu ra. Tôi chặt đại tràng sau nhóm cuối cùng với một bản hack nhỏ. Tổng hợp và dường như hoạt động cho xc3s500e-4ft256-4 trên ISE 13.7 lin64.

C, 91-126 byte

Phiên bản gốc của tôi, 119 byte.

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

Phiên bản di động được đánh gôn tốt nhất, 103 byte (cảm ơn @Dennis vì một số khái niệm này)

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

Giải thích: Bản thân thuật toán rất đơn giản. Tôi đã sử dụng dài hơn là không dấu int vì nó ngắn hơn. Khai báo chúng ở cấp độ tệp có nghĩa là mọi thứ được khởi tạo trước bằng số không. Các fchức năng là một increment đơn giản với carry hoạt động trên 16 bit thấp của mỗi từ. Vòng lặp kết thúc khi nó mang vào bit thứ 129.

Lặp lại ngược lại cho printf có nghĩa là chúng tôi in các địa chỉ theo thứ tự "phù hợp" và kiểm tra để in một dòng mới ngắn hơn một vài ký tự.

Điều này không sử dụng một số cấu trúc không di động. Nó được coi là phương ngữ K & R tốt nhất của C, vì nó sử dụng các kiểu trả về int ẩn và không bao gồm stdio.h. Và việc sử dụng lâu dài của tôi đã được thông báo bởi điều này - trên hầu hết các hệ thống hiện đại int là đủ vì nó là 32 bit. Điều này có thể có thể chạy không được sửa đổi trên PDP-11 Unix.

Tuy nhiên, nó có thể ngắn hơn. Nếu chúng ta giả sử rằng chúng ta có thể sử dụng int (có thể là loại rộng hơn 16 bit hoặc loại chính xác là 16 bit với các thuộc tính khác nhau xảy ra trên nhiều hệ thống như bổ sung twos và cuộn qua số học), chúng ta có thể loại bỏ những thứ liên quan đến sử dụng lâu dài.

Phiên bản cho int rộng hơn 16 bit, 97 byte.

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

Phiên bản cho hệ thống 16 bit, 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++);}}

Lạ lùng thay, tuy nhiên, bản gốc K & biên dịch R không thực sự hỗ trợ kê khai mà không int (nó biên dịch tốt, nhưng xử lý các biến như bên ngoài và do đó không xác định vào thời điểm liên kết), do đó thêm ba byte là cần thiết để thay đổi việc kê khai để int*p,a[9];cho tổng cộng 94.

Ngoài ra, nếu giả định rằng nó bị gián đoạn trước khi hoàn thành đầu ra là một ràng buộc cứng, chúng ta có thể loại bỏ kiểm tra kết thúc, tiết kiệm năm byte.

Phần thưởng: phiên bản di động hoàn toàn ANSI, 126 byte:

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

Các dòng mới trong tất cả các phiên bản được chèn để dễ đọc và ở những vị trí không yêu cầu khoảng trắng và được loại trừ khỏi số byte, ngoại trừ dòng mới sau #includedòng trong phiên bản ANSI.

Tất cả các phiên bản ngoại trừ phiên bản ANSI đều rơi vào cuối chính và do đó có thể trả lại mã thoát giả cho hệ điều hành.

AutoIt3, 142 231 byte

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

Giải trình

• For $a=0 To 2^32-1: Lặp lại 4 lần trên 0-2 ^ 32 ((2 ^ 32) ^ 4 = 2 ^ 128) các kết hợp có thể.
• $s=StringFormat("%08x%08x%08x%08x",$a,$b,$c,$d): Chuyển đổi các số thành một chuỗi thập lục phân có độ dài 32 (4 * 32).
• For $j=0 To 8: Lặp lại trên tất cả 8 phần của chuỗi.
• ConsoleWrite(StringMid($s,$j*4+1,4)&($j<7?":":"")): Trích xuất 4 ký tự tiếp theo từ chuỗi và thêm dấu hai chấm ( :) ở cuối, nếu chúng ta chưa đến phần cuối cùng, sau đó xuất mọi thứ ra bàn điều khiển
• Next: Kết thúc vòng lặp for bên trong
• ConsoleWrite(@LF): Thêm một nguồn cấp dữ liệu ở cuối dòng
• Next: Kết thúc các vòng lặp for bên ngoài

Kích thước đầu ra dự kiến: (Một dòng (39 byte) + nguồn cấp dữ liệu) (= 40 byte) * 2 ^ 128 = 1.361 * 10 ^ 16 YB (yottabyte)

Quế Gum, 16 byte

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

Hãy thử trực tuyến. (TIO giới hạn đầu ra)

Giải trình

Các gchế độ puts Quế Gum trong tạo chế độ . Phần còn lại của chuỗi giải nén cho biểu thức chính này:

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

Sau đó, nó tạo ra một trình tạo tất cả các chuỗi có thể khớp với biểu thức chính quy và lặp qua nó, in ra từng chuỗi.

Hơi lạ một chút, regex golfier ([0-9a-f]{4,4}:){7,7}[0-9a-f]{4,4}thực sự nén thành một chuỗi dài hơn so với regex ở trên.

Hàng hóa BASIC 2.0, 339 byte

Để có được các chữ số hex chữ thường, chương trình này được viết trong "chế độ thay đổi" (nhấn <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

Đơn giản chỉ cần thực hiện công việc này trên Commodore 64 là một thách thức, vì bộ nhớ, kích thước màn hình, kích thước dữ liệu và các hạn chế khác. Tôi đã xem xét việc thực hiện biểu diễn viết tắt, nhưng các hạn chế khác (chẳng hạn như không có khả năng sử dụng các phần tử mảng làm chỉ số vòng lặp) có nghĩa là nó sẽ tăng độ dài của chương trình lên khoảng 1000 byte.

Dòng 7 là một triển khai HEX$(), điều mà Commodore BASIC 2.0 đang thiếu. Tôi không thể sử dụng một DEF FNcho điều này bởi vì những người chỉ có thể trả về số, không phải chuỗi. Dòng 6 là một chương trình con áp dụng nó cho một nhóm gồm bốn chữ số, sẽ ngắn hơn đáng kể nếu các hàm có thể trả về chuỗi.

Dòng 2 và 5 là tám vòng lặp lồng nhau, được triển khai thành bảy vòng "cho" và một vòng goto có điều kiện vì tám vòng "cho", khi kết hợp với hai "gosub" để in địa chỉ, sẽ tràn ra ngăn xếp nhỏ của C64.

Một C64 có thể in ra khoảng 1,2 địa chỉ mỗi giây, với thời gian chạy ước tính là 1,3 * 10 ^ 31 năm.

PowerShell (v4), 193 166 162 145 103 byte

Phiên bản không có thưởng của TimmyD ở 103 byte:

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

Phiên bản có thưởng trước đó ở mức 145 * 0,8 = 116 byte

Với sự giúp đỡ từ TimmyD và tomkandy , người chỉ ra rằng 0 -eq $falsenhưng ([bigint]0) -eq $true. Vì vậy, tất cả các phiên bản trước của tôi sẽ không chấm dứt.

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

Trước đây ở 162, trước khi một số thay đổi 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}

"Một thách thức mà PowerShell phải có khả năng cạnh tranh hợp lý!" - tôi, trước khi tôi thử nó.

Giải trình

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

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 byte

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

Đơn giản chỉ cần đi qua mỗi số từ 0 đến 2 ^ 128. Đầu tiên, nó chuyển đổi số hiện tại thành chuỗi thập lục phân, sau đó loại bỏ '0x'hàm mà hàm đó cung cấp. Tiếp theo, nó điều chỉnh chuỗi để có 32 số 0 ở phía trước và sau đó chia nó thành các nhóm bốn. Cuối cùng, nó tham gia nhóm bốn người với dấu hai chấm, in ra và thêm 1 vào số hiện tại. Có phần thưởng bổ sung mà bạn có thể bắt đầu với bất kỳ giá trị nào nếu bạn cho nó, nhưng không cần đầu vào.

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"

Với chức năng trình tự của riêng tôi, snó không còn rò rỉ bộ nhớ, nhưng không cảm thấy bị đánh gôn nữa.

CBM BASIC v7.0 (166 ký tự)

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

Câu trả lời của Mark là dành cho BASIC 2.0 của Commodore 64, thiếu lệnh tích hợp để in các số ở dạng thập lục phân. Tuy nhiên, nhờ HEX$()chức năng trong BASIC 7.0, phiên bản Commodore 128 ngắn hơn nhiều. Nó không phù hợp với một dòng logic duy nhất (mà trên C128 bị giới hạn ở 160 ký tự) nhưng vẫn có thể được nhập dưới dạng hai dòng riêng biệt trong chế độ trực tiếp.

Ruby 75

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

Đây là một giải pháp đệ quy lấy một tiền tố và tìm mọi hậu tố có thể. Đệ quy.

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