Ini mengingatkan saya ketika beberapa tahun yang lalu seseorang mengunggah torrent "Alat peretas: daftar lengkap semua alamat IP". Ini, tentu saja, hanya daftar yang dihasilkan dari ~ 4 miliar alamat IPv4, tetapi ribuan "h4xx0rz" mengunduhnya. Lihatlah ibu, imahacker!

Ini dulu, tetapi saat ini semua orang telah beralih ke IPv6 . (Baik?)

Tugas Anda adalah menulis program yang mencetak semua alamat IPv6 .

Anda harus menulis program lengkap yang tidak mengambil input dan mencetak alamat IPv6, satu per baris, dan tidak ada output lainnya. Program Anda harus mencetak semua ¹²⁸ alamat yang mungkin, termasuk yang tidak valid. Setiap alamat harus dicetak tepat sekali. Anda dapat mencetak alamat dengan urutan apa pun.

Setiap alamat dapat dicetak secara penuh, dengan 8 grup dengan 4 digit heksadesimal yang dipisahkan oleh titik dua, misalnya

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

Anda dapat, atas kebijakan Anda, menggunakan singkatan standar dari RFC 5952 :

• Angka nol di grup dapat dihilangkan, kecuali yang 0tidak dapat disingkat lebih lanjut.
• :: dapat digunakan paling banyak sekali per alamat untuk menyingkat urutan satu atau lebih grup yang semuanya nol.
• Digit heksadesimal dapat menggunakan huruf kecil atau huruf besar.

Jika Anda mencapai rekomendasi representasi dari RFC 5952 (hanya huruf kecil, representasi sesingkat mungkin, dengan ::digunakan sedini mungkin jika ada beberapa tempat di mana ia dapat digunakan), Anda mendapatkan bonus -20% .

Karena ukuran output, program Anda tidak diharapkan selesai saat kami duduk di sana. Program Anda mungkin terganggu oleh sarana eksternal di beberapa titik ( Ctrl+ C, mengeluarkan daya, ...). Program Anda harus menghasilkan output sebagai aliran, sehingga setelah menunggu "masuk akal", itu akan menghasilkan beberapa baris. Pada dasarnya, membangun string raksasa di memori hanya untuk mencetaknya di akhir tidak diperbolehkan. Program apa pun yang kehabisan memori pada PC "standar" didiskualifikasi. (Meskipun demikian, jika program Anda dibiarkan berjalan cukup lama, ia harus mencetak semua alamat IPv6 dan kemudian keluar.)

(Jika kondisi ini merupakan masalah bagi juru bahasa yang menjalankan program sampai selesai dan kemudian membiarkan Anda melihat hasilnya, dan Anda tidak memiliki juru bahasa yang di-host, ujilah program Anda pada versi masalah yang lebih kecil, lalu sesuaikan dengan hati-hati ke 2 ¹²⁸ penuh .)

Skor Anda adalah panjang program Anda dalam byte, dikalikan dengan 0,8 jika Anda mendapatkan bonus. Ini golf kode, jadi skor terendah menang.

Pyth, 21 byte

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

Menggunakan loop sementara dengan Jsebagai variabel iterator. Menginisialisasi penggunaan maksimum 8^chr(' '). Pads dengan menambahkan nilai awal itu, mengonversi ke hex, lalu menghapus karakter pertama.

Python 3, 65 byte · 0.8 = 52.0

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

Pyth, 27 25 24 byte

Catatan: kode memiliki bug sebelumnya, memperbaikinya menyimpan 1 byte

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

Mencetak alamat seperti

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

Versi sebelumnya (lebih rumit) menggunakan operator pad (juga 24 byte):

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

Penjelasan

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 (tidak valid)

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

Ini tidak dapat dijalankan karena 1) ia akan mengkonsumsi setidaknya 2 ¹³² byte (2 ⁵² yobibytes) memori dan 2) penerjemah tidak menyukainya (2 ¹²⁸ tidak cocok ssize_t, jadi tidak ada listukuran sebesar itu) . Itu akan mencetak alamat dalam urutan leksikografis. Anda dapat mencoba algoritme dengan mengubah angka pada akhirnya menjadi sesuatu yang dapat digunakan.

C (dengan ekstensi 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;);}

Ini menggunakan ekstensi GCC 128-bit integer untuk sekadar menghitung dari ::hingga ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff. inet_ntop()memformat setiap alamat dengan benar sehingga bonus -20% dapat diklaim.

Keluaran

Menggunakan seduntuk menghasilkan setiap garis sepersejuta hingga 10 juta:

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

Catatan Saya menggunakan mesin x86_64 little-endian, dan bahwa alamat jaringan biasanya selalu dalam urutan jaringan (big-endian), sehingga endianness secara efektif ditukar dengan menggunakan inet_ntop(). Ini tidak masalah - semua alamat masih (pada akhirnya) akan ditampilkan.

CJam, 36 27 byte

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

-9 byte terima kasih kepada @Dennis (saya lupa bahwa CJam memiliki pemformatan string). Mencetak alamat huruf kecil dan turun.

Untuk alasan yang jelas, gunakan penerjemah Java, bukan penerjemah online. Anda dapat mengganti G32#dengan sesuatu yang lebih kecil untuk pengujian online, misalnya, inilah 100 yang terakhir .

Penjelasan

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

Sebagai efek samping dari metode yang digunakan untuk memasukkan titik dua, alamat dicetak dengan kolom paling kanan muncul di sebelah kiri:

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

Pengajuan Verilog pertama saya, mungkin bisa menggunakan lebih banyak golf tetapi saya tidak punya energi untuk melakukannya sekarang. cadalah clock, oadalah output ASCII. Tidak memenuhi syarat untuk memformat bonus karena zero-padding alih-alih menyingkat.

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

Ini adalah iterasi sederhana yang diikuti oleh sedikit twiddling untuk membuat output ASCII. Saya memotong usus setelah kelompok terakhir dengan hack kecil. Mensintesis dan tampaknya berfungsi untuk xc3s500e-4ft256-4 pada ISE 13.7 lin64.

C, 91-126 byte

Versi asli saya, 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]);}

Versi portable-ish golf terbaik, 103 byte (terima kasih @Dennis untuk beberapa konsep ini)

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

Penjelasan: Algoritme itu sendiri cukup mudah. Saya menggunakan int lama daripada unsigned karena lebih pendek. Mendeklarasikan mereka di tingkat file berarti semuanya diinisialisasi dengan nol. The ffungsi adalah kenaikan sederhana dengan membawa yang beroperasi pada rendah 16 bit dari setiap kata. Loop berakhir ketika membawa ke bit ke-129.

Iterasi mundur untuk printf berarti bahwa kita mencetak alamat dalam urutan "tepat" dan juga memeriksa untuk mencetak baris baru adalah beberapa karakter lebih pendek.

Ini memang menggunakan beberapa konstruksi non-portabel. Paling baik dianggap sebagai dialek K&R dari C, karena menggunakan jenis pengembalian int implisit dan tidak termasuk stdio.h. Dan penggunaan saya lama diinformasikan oleh ini - pada kebanyakan sistem modern int sudah cukup karena 32 bit. Ini mungkin dapat dijalankan tanpa modifikasi pada PDP-11 Unix.

Namun, bisa lebih pendek. Jika kita berasumsi bahwa kita dapat menggunakan int (baik sebagai tipe yang lebih luas dari 16 bit, atau tipe tepat 16 bit dengan berbagai properti yang ternyata benar pada banyak sistem seperti komplemen dua dan rollover aritmatika), kita dapat menyingkirkan hal-hal terkait penggunaan panjang.

Versi untuk int lebih luas dari 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);}}

Versi untuk sistem 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++);}}

Anehnya, kompiler K&R asli tidak benar-benar mendukung deklarasi tanpa int (itu mengkompilasi dengan baik, tetapi memperlakukan variabel sebagai eksternal dan karenanya tidak terdefinisi pada waktu tautan), sehingga diperlukan tiga byte tambahan untuk mengubah deklarasi menjadi int*p,a[9];untuk total 94.

Juga, jika asumsi bahwa itu terganggu sebelum menyelesaikan output adalah kendala yang sulit, kita bisa menghapus cek akhir, menghemat lima byte.

Bonus: versi portabel ANSI sepenuhnya, 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);}}

Baris baru di semua versi dimasukkan untuk dibaca dan di lokasi di mana spasi tidak diperlukan, dan dikeluarkan dari jumlah byte, kecuali baris baru setelah #includebaris dalam versi ANSI.

Semua versi kecuali versi ANSI jatuh pada akhir utama dan karenanya dapat mengembalikan kode keluar palsu ke sistem operasi.

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

Penjelasan

• For $a=0 To 2^32-1: Iterasi 4 kali lebih dari 0-2 ^ 32 ((2 ^ 32) ^ 4 = 2 ^ 128) kemungkinan kombinasi.
• $s=StringFormat("%08x%08x%08x%08x",$a,$b,$c,$d): Konversi angka menjadi string heksadesimal dengan panjang 32 (4 * 32).
• For $j=0 To 8: Iterate atas semua 8 bagian dari string.
• ConsoleWrite(StringMid($s,$j*4+1,4)&($j<7?":":"")): Ekstrak 4 karakter berikutnya dari string dan tambahkan tanda titik dua ( :) di bagian akhir, jika kita belum mencapai bagian terakhir, maka output semuanya ke konsol
• Next: Akhiri for-loop dalam
• ConsoleWrite(@LF): Tambahkan umpan baris di akhir baris
• Next: Akhiri loop luar untuk

Ukuran output yang diharapkan: (Satu baris (39 byte) + feed baris) (= 40 byte) * 2 ^ 128 = 1,361 * 10 ^ 16 YB (yottabytes)

Cinnamon Gum, 16 byte

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

Cobalah online. (TIO membatasi output)

Penjelasan

The gmenempatkan modus Cinnamon Gum di menghasilkan modus . Sisa string mendekompresi ke regex ini:

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

Itu kemudian menciptakan generator dari semua string yang mungkin cocok dengan regex dan beralih melalui itu, mencetak masing-masing.

Agak mengherankan, regex golfier ([0-9a-f]{4,4}:){7,7}[0-9a-f]{4,4}sebenarnya kompres ke string yang lebih panjang daripada regex di atas.

Commodore BASIC 2.0, 339 byte

Untuk mendapatkan digit hex dengan huruf kecil, program ini ditulis dalam "mode bergeser" (tekan <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

Membuat pekerjaan ini di Commodore 64 adalah sebuah tantangan, karena memori, ukuran layar, ukuran data, dan batasan lainnya. Saya mempertimbangkan untuk menerapkan representasi yang disingkat, tetapi keterbatasan lain (seperti ketidakmampuan tidak berdokumen untuk menggunakan elemen array sebagai indeks loop) berarti akan menambah panjang program dengan sekitar 1000 byte.

Baris 7 adalah implementasi dari HEX$(), yang kurang Commodore BASIC 2.0. Saya tidak bisa menggunakan a DEF FNuntuk ini karena mereka hanya bisa mengembalikan angka, bukan string. Baris 6 adalah subrutin yang berlaku untuk sekelompok empat digit, yang akan jauh lebih pendek jika fungsi dapat mengembalikan string.

Baris 2 dan 5 adalah delapan loop bersarang, diimplementasikan sebagai tujuh "untuk" loop dan goto bersyarat karena delapan "untuk" loop, ketika dikombinasikan dengan dua "gosub" untuk mencetak alamat, akan meluap tumpukan kecil C64.

C64 dapat mencetak sekitar 1,2 alamat per detik, untuk perkiraan waktu kerja 1,3 * 10 ^ 31 tahun.

PowerShell (v4), 193 166 162 145 103 byte

Versi no-bonus TimmyD pada 103 byte:

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

Versi sebelumnya dengan bonus 145 * 0,8 = 116 byte

Dengan bantuan dari TimmyD dan TomKandy , yang menunjukkan itu 0 -eq $falsetetapi ([bigint]0) -eq $true. Jadi semua versi saya sebelumnya tidak akan berakhir.

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

Sebelumnya di 162, sebelum beberapa perubahan 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}

"Sebuah tantangan di mana PowerShell seharusnya cukup kompetitif!" - saya, sebelum saya mencobanya.

Penjelasan

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

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

Cukup melalui setiap angka dari 0 hingga 2 ^ 128. Pertama-tama ia mengubah angka saat ini menjadi string heksadesimal, kemudian menghapus '0x'yang diberikan fungsi tersebut. Selanjutnya menyesuaikan string untuk memiliki 32 nol di depan dan kemudian memecahnya menjadi kelompok empat. Akhirnya ia bergabung dengan kelompok empat dengan titik dua, mencetak yang keluar dan menambahkan 1 ke nomor saat ini. Memiliki bonus tambahan yang dapat Anda mulai dengan nilai apa pun jika Anda memberikannya, tetapi tidak diperlukan input.

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"

Dengan fungsi urutan saya sendiri s, memori tidak lagi bocor, tetapi tidak terasa golf lagi.

CBM BASIC v7.0 (166 karakter)

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

Jawaban Mark adalah untuk Commodore 64's BASIC 2.0, yang tidak memiliki perintah bawaan untuk mencetak angka dalam heksadesimal. Namun, berkat HEX$()fungsi di BASIC 7.0, versi Commodore 128 jauh lebih pendek. Itu tidak muat pada satu baris logis (yang pada C128 terbatas hingga 160 karakter) tetapi masih dapat dimasukkan sebagai dua baris terpisah dalam mode langsung.

Ruby 75

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

Ini adalah solusi rekursif yang mengambil setiap awalan dan menemukan setiap sufiks yang mungkin. Secara rekursif.

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