Birkaç yıl önce birisi torrent "Hacker aracı: tüm IP adreslerinin tam listesi" yüklediğinde bu bana hatırlatıyor. Elbette, bu ~ 4 milyar IPv4 adresinin oluşturulmuş bir listesiydi, ancak binlerce "h4xx0rz" indirdi. Bak anne, imahacker!

Bu öyleydi, ama bugünlerde herkes IPv6'ya geçti . (Sağ?)

Göreviniz tüm IPv6 adreslerini yazdıran bir program yazmaktır .

Giriş almayan ve IPv6 adreslerini, satır başına bir tane ve başka bir çıktı almayan tam bir program yazmalısınız. Programınız , geçersiz adresler de dahil olmak üzere mümkün olan tüm ¹²⁸ adresleri yazdırmalıdır . Her adres tam olarak bir kez basılmalıdır. Adresleri istediğiniz sırayla yazdırabilirsiniz.

Her adres tam olarak basılabilir, örneğin 8 virgülle ayrılmış 8 onaltılık basamak grubu, örn.

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

İsteğinize göre , RFC 5952'deki standart kısaltmalardan herhangi birini kullanabilirsiniz :

• Bir gruptaki baştaki sıfırlar, 0daha fazla kısaltılmaması dışında ihmal edilebilir.
• :: Bir veya daha fazla tamamen sıfır grubunun bir sırasını kısaltmak için adres başına en fazla bir kez kullanılabilir.
• Onaltılık sayılar küçük veya büyük harf kullanabilir.

Temsil önerisini RFC 5952'den alırsanız (yalnızca küçük harfler, mümkün olan en kısa sürede, ::kullanılabileceği birden fazla yer varsa mümkün olan en erken zamanda kullanılmalıdır), % -20 bonus alırsınız .

Çıktının büyüklüğü nedeniyle, biz orada otururken programınızın bitmesi beklenmiyor. Programınız bir noktada harici yollarla kesintiye uğrayabilir ( Ctrl+ C, gücü keserek ,…). Programınız çıktı olarak bir akış üretmelidir, böylece “makul” bir beklemeden sonra bazı satırlar üretilecektir. Temel olarak, yalnızca sonunda yazdırmak için bellekte dev bir dize oluşturulmasına izin verilmez. “Standart” bir PC'de belleği tükenecek herhangi bir program diskalifiye edilir. (Bununla birlikte, programınız yeterince uzun süre çalışacak şekilde bırakıldıysa, tüm IPv6 adreslerini yazdırmalı ve sonra çıkmalıdır.)

(Bu koşul, programı tamamlanana kadar çalıştıran ve daha sonra çıktısını görmenize izin veren ve barındırılan bir tercümanınız olmayan web tercümanları için bir sorunsa, programınızı sorunun daha küçük bir sürümünde sınayın ve ardından dikkatlice ayarlayın 2 ^{128'e kadar} .)

Puanınız programınızın bayt cinsinden uzunluğudur, bonusu alırsanız 0.8 ile çarpılır. Kod golf, bu yüzden en düşük puan kazanır.

Pyth, 21 bayt

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

Bir yineleme döngüsünü Jyineleyici değişkeni olarak kullanır . Kullanarak maksimum değeri başlatır 8^chr(' '). Bu başlangıç ​​değerini ekleyerek, hex'e çevirip sonra ilk karakteri kaldırarak pedleri çıkarın.

Python 3, 65 bayt · 0.8 = 52.0

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

Pyth, 27 25 24 bayt

Not: Kodun daha önce bir hatası vardı, 1 byte kurtarıldı

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

Gibi adresleri yazdırır

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

Ped operatörünü kullanan önceki (daha karmaşık) sürüm (ayrıca 24 byte):

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

açıklama

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 bayt (geçersiz)

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

Bu 1'den beri çalıştırılamaz.) En az 2 ¹³² bayt (2 ⁵² yobibyte) bellek tüketir ve 2) tercüman beğenmez (2 ¹²⁸ sığmaz ssize_t, bu yüzden listbu boyutta değildir). . Adresleri sözlüksel sıraya göre basardı. Algoritmayı, sonunda sayıları kullanışlı bir şeyle değiştirerek deneyebilirsiniz.

C (GCC uzantılı), 76 bayt * 0.8 = 60.8

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

Bu kullanır 128 bit tamsayı GCC uzantısı basitçe yukarı saymak ::için ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff. inet_ntop()Her adresi doğru şekilde biçimlendirin, böylece% -20 bonus talep edilebilir.

Çıktı

Kullanılması sed10 milyona her milyonuncu hattı çıkışına:

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

Not Küçük bir endian x86_64 makinesi kullanıyorum ve bu ağ adresleri tipik olarak her zaman ağ düzeninde (big-endian) olduğundan, endianness etkin şekilde değiştirilir inet_ntop(). Bu önemli değil - tüm adresler hala (sonunda) görüntülenecek.

CJam, 36 27 bayt

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

@Dennis sayesinde -9 bayt (CJam'in string formatına sahip olduğunu unuttum). Adresleri küçük harf ve azalan olarak yazdırır.

Açık nedenlerden dolayı, çevrimiçi olanı değil, Java yorumlayıcısını kullanın. G32#Çevrimiçi olarak test etmek için daha küçük bir şeyle değiştirebilirsiniz , örneğin işte son 100 .

açıklama

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 bayt

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

İki nokta üst üste koymak için kullanılan yöntemin bir yan etkisi olarak, adresler solda görünen en sağdaki sütunla yazdırılır:

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

İlk Verilog gönderimim, muhtemelen daha fazla golf kullanabilirdi, ancak şu anda yapacak enerjim yok. csaat, oASCII çıkışı. Kısaltma yerine sıfır doldurma nedeniyle biçimlendirme bonusu için uygun değildir.

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

Bu, ASCII'nin çıktısını almak için biraz bit bükme işlemi izleyen basit bir yinelemedir. Kolonu son bir gruptan sonra küçük bir kesmeyle kesiyorum. İMKB 13.7 lin64'te xc3s500e-4ft256-4 için sentezleniyor ve çalışıyor gibi görünüyor.

C, 91-126 bayt

Orijinal sürümüm, 119 bayt.

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

En iyi golf taşınabilir taşınabilir sürümü, 103 bayt (bu kavramların bazıları için @Dennis teşekkürler)

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

Açıklama: Algoritmanın kendisi oldukça basittir. İmzasız int yerine uzun kullandım çünkü daha kısa. Bunları dosya düzeyinde bildirmek, her şeyin sıfırlarla önceden başlatıldığı anlamına gelir. fİşlevi, her sözcüğün düşük 16 bit çalışır taşıma ile basit bir artıştır. Döngü, 129. bit ile taşındığında sona erer.

Printf için geriye doğru yineleme, adresleri "uygun" sırayla yazdırdığımız anlamına gelir ve ayrıca yeni bir satır basma kontrolü birkaç karakterden daha kısadır.

Bu, bazı taşınabilir olmayan yapıları kullanır. En iyi K ve R lehçesi olarak kabul edilir, çünkü int int türlerini kullanır ve stdio.h içermez. Ve benim uzun kullanımım bu konuda bilgilendirildi - çoğu modern sistemde int yeterli çünkü 32 bit. Bu muhtemelen PDP-11 Unix'te değiştirilmemiş olarak çalışabilir.

Ancak, daha kısa olabilir. İnt kullanabileceğimizi varsayalım (ya 16 bitten daha geniş bir tür ya da twos complement ve aritmetik rollover gibi birçok sistemde geçerli olan çeşitli özelliklere sahip tam olarak 16 bittik bir tür) kullanabileceğimizi varsayalım. uzun kullanma ile ilgili şeyler.

16 bitten daha büyük int için sürüm, 97 bayt.

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 bit sistemler için sürüm, 91 bayt.

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

İşin aslı, orijinal K&R derleyicisi int olmadan bildirimi gerçekten desteklemedi (derler (ancak derler ancak değişkenleri dış olarak kabul eder ve bu nedenle bağlantı zamanında tanımsızdır) int*p,a[9];. toplamda 94.

Ayrıca, çıktıyı tamamlamadan önce kesildiği varsayımı zor bir kısıtlama olsaydı, son baytı kaldırabilir ve beş bayt tasarruf sağlayabiliriz.

Bonus: tamamen ANSI taşınabilir sürüm, 126 bayt:

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

Tüm sürümlerdeki yeni satırlar, okunabilirlik için ve boşluk gerektirmeyen konumlara eklenir #includeve ANSI sürümündeki satırdan sonraki satır dışında, bayt sayısından çıkarılır .

ANSI sürümü dışındaki tüm sürümler ana bilgisayarın sonuna girer ve bu nedenle işletim sistemine sahte bir çıkış kodu verebilir.

AutoIt3, 142 231 Bayt

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

açıklama

• For $a=0 To 2^32-1: 0-2 ^ 32 ((2 ^ 32) ^ 4 = 2 ^ 128) olası birleşimlerin üzerinde 4 kez yineleme.
• $s=StringFormat("%08x%08x%08x%08x",$a,$b,$c,$d): Numaraları, 32 (4 * 32) uzunluğunda onaltılık bir dizgeye dönüştürün.
• For $j=0 To 8: Dizenin 8 bölümünün tümünü yineleyin.
• ConsoleWrite(StringMid($s,$j*4+1,4)&($j<7?":":"")): Dizeden sonraki 4 karakteri çıkartın ve :en son noktaya ulaşmamış olursak sonuna bir kolon ( ) ekleyin , ardından her şeyi konsola alın
• Next: İç for-loop'u sonlandır
• ConsoleWrite(@LF): Satırın sonuna bir satır besleme ekleyin.
• Next: Dış for-loop'ları sonlandır

Beklenen çıktı boyutu: (Bir satır (39 bayt) + satır besleme) (= 40 bayt) * 2 ^ 128 = 1.361 * 10 ^ 16 YB (yottabayt)

Tarçınlı Sakız, 16 bayt

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

Çevrimiçi deneyin. (TIO çıkışı sınırlar)

açıklama

gModunda koyar Tarçın Sakız modunu oluşturmak . İpin geri kalanı bu regex'e açılır:

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

Daha sonra, regex ile eşleşen olası tüm dizgelerin bir jeneratörünü oluşturur ve içinden yinelenerek her birini yazdırır.

Biraz eğlenceli, golfçü regex ([0-9a-f]{4,4}:){7,7}[0-9a-f]{4,4}aslında yukarıdaki regex daha uzun bir dizeye sıkıştırır.

Commodore BASIC 2.0, 339 bayt

Küçük harfli onaltılık haneleri almak için, bu program "kaydırılmış modda" yazılmıştır (bası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

Commodore 64'te basitçe bu işi yapmak , bellek, ekran boyutu, veri boyutu ve diğer sınırlamalar nedeniyle zor bir işti. Kısaltılmış gösterimi uygulamayı düşünmüştüm, ancak diğer sınırlamalar (dizi öğelerini döngü indeksleri olarak kullanamama gibi) programın uzunluğunu tahmini bir 1000 bayt artıracağı anlamına geliyordu.

Satır 7, HEX$()Commodore BASIC 2.0'ın eksik olduğu bir uygulamadır . Bunun için kullanamam DEF FNçünkü bunlar sadece rakamları döndürür, karakterleri değil. Satır 6, dört basamaklı bir gruba uygulayan bir alt yordamdır; işlevler dizeleri döndürürse oldukça kısa olacaktır.

Satır 2 ve 5, sekiz "döngü" için yedi "ve koşullu bir goto olarak uygulanan sekiz iç içe döngüdür, çünkü" ilmek "için sekiz", adresin basılması için iki "gosub" ile birleştiğinde, C64'ün minik yığınını aşacaktır.

Bir C64, 1.3 * 10 ^ 31 yıllık bir çalışma süresi için saniyede yaklaşık 1.2 adres yazdırabilir.

PowerShell (v4), 193 166 162 145 103 bayt

TimmyD'nin 103 bitlik bonussuz sürümü:

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

145 * 0.8 = 116 bayt'taki bonus sürümüyle önceki

Yardımıyla TimmyD ve tomkandy işaret, 0 -eq $falseancak ([bigint]0) -eq $true. Böylece önceki sürümlerimin tümü sonlandırılmıyor.

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

Daha önce 162’da, bazı regex’ler değişmeden önce:

$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'in makul derecede rekabetçi olması gereken bir meydan okuma!" - denemeden önce ben.

açıklama

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

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 bayt

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

Basitçe her numara 0 - 2 ^ 128 arasındadır. İlk önce o anki sayıyı onaltılık dizgeye dönüştürür, sonra '0x'fonksiyonun verdiği dizgiyi çıkarır. Daha sonra dizeyi önünde 32 sıfır olacak şekilde ayarlar ve sonra onu dörtlü gruplara ayırır. Sonunda dört gruba iki nokta üst üste gelir, bunları yazdırır ve geçerli sayıya 1 ekler. Bir tane verirseniz, herhangi bir değerde başlatabileceğiniz bir ikramiye var, ancak giriş yapmanız gerekmez.

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"

Kendi sıralama fonksiyonumla sartık hafızadan sızmıyor, ama artık golf oynadığını hissetmiyor.

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

Mark'ın cevabı , onaltılık sayıları basmak için yerleşik bir komutu olmayan Commodore 64'ün BASIC 2.0'ı içindir. Bununla birlikte, HEX$()BASIC 7.0'daki işlev sayesinde , Commodore 128 versiyonu çok daha kısadır. Tek bir mantıksal satıra sığmaz (C128'de 160 karakterle sınırlıdır) ancak doğrudan modda iki ayrı satır olarak girilebilir.

Ruby 75

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

Bu, her bir ön eki alan ve olası her eki bulan özyinelemeli bir çözümdür. Tekrarlı.

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