Це нагадує мені, коли кілька років тому хтось завантажив торрент "Хакерський інструмент: повний список усіх IP-адрес". Звичайно, це був лише створений список ~ 4 мільярдів IPv4 адрес, але тисячі "h4xx0rz" завантажили його. Подивися матусю, імакере!

Це було тоді, але сьогодні всі перейшли на IPv6 . (Так?)

Ваше завдання - написати програму, яка роздруковує всі адреси IPv6 .

Вам слід написати повну програму, яка не вводить і не друкує адреси IPv6, по одній на рядок та без іншого виводу. Ваша програма повинна надрукувати всі ¹²⁸ можливих адрес, включаючи недійсні. Кожна адреса повинна бути надрукована рівно один раз. Ви можете роздрукувати адреси в будь-якому порядку.

Кожна адреса може бути надрукована повністю, з 8 груп з 4 шістнадцяткових цифр, розділених двокрапками, наприклад

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

Ви можете, на свій розсуд, використовувати будь-яку зі стандартних абревіатур із RFC 5952 :

• Провідні нулі в групі можуть бути опущені, за винятком того, що 0їх не можна додатково скорочувати.
• :: може використовуватися щонайбільше одного разу за адресою для скорочення послідовності однієї або декількох абсолютно нульових груп.
• Шістнадцяткові цифри можуть використовувати малі або великі регістри.

Якщо ви досягнете рекомендації щодо представлення від RFC 5952 (лише малі літери, найкоротше можливе подання, ::використовуючи якомога раніше, якщо є кілька місць, де його можна використовувати), ви отримуєте бонус -20% .

Зважаючи на розмір виходу, не очікується, що ваша програма закінчиться, поки ми сидимо там. Ваша програма може бути перервана зовнішніми засобами в якийсь момент ( Ctrl+ C, витягуючи живлення,…). Ваша програма повинна виводити вихід як потік, так що після «розумного» очікування, він створить деякі рядки. В основному, побудувати гігантський рядок у пам'яті лише для друку в кінці не дозволяється. Будь-яка програма, у якої не вистачає пам'яті на "стандартному" ПК, дискваліфікується. (Тим не менш, якщо ваша програма була запущена досить довго, вона повинна надрукувати всі адреси IPv6 і потім вийти.)

(Якщо ця умова є проблемою для веб-перекладачів, які запускають програму до завершення, а потім дозволяють побачити вихід, а у вас немає розміщеного перекладача, протестуйте програму на меншій версії проблеми та ретельно відкоригуйте її в повному обсязі 2 ^128. )

Ваш бал - це довжина вашої програми в байтах, помножена на 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

Попередня (більш складна) версія з використанням оператора pad (також 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 ⁵² йобібайта) пам'яті та 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 просто підраховувати від ::до ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff. inet_ntop()правильно формати кожної адреси, щоб можна було вимагати бонус -20%.

Вихід

Використання 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 апарат, і такі мережеві адреси, як правило, завжди є в мережевому порядку (big-endian), так що цінність ефективно змінюється за допомогою 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

Верилог, 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]);}

Найкраща портативна версія для гольфу, 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, оскільки він використовує неявні типи повернення int та не включає stdio.h. І про це моє використання long довго було інформовано - для більшості сучасних систем int достатньо, тому що це 32 біти. Це, ймовірно, може працювати немодифікованим на PDP-11 Unix.

Однак він може бути і коротшим. Якщо припустити, що ми можемо використовувати int (або як тип ширше 16 біт, або тип точно 16 біт з різними властивостями, які трапляються в багатьох системах, таких як доповнення двійок та арифметичний перекидання), ми можемо позбутися речі, пов'язані з використанням довгих.

Версія для 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,336 * 10 ^ 16 YB (йоттабайт)

Кориця гумка, 16 байт

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

Спробуйте в Інтернеті. (TIO обмежує вихід)

Пояснення

gРежим ставить корицю камедь в режимі генерації . Решта рядка декомпресується до цього регулярного виразу:

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

Потім він створює генератор усіх можливих рядків, які відповідають регулярному вираженню та повторює його, виводячи кожну з них.

Дещо кумедно регекс гольфітера ([0-9a-f]{4,4}:){7,7}[0-9a-f]{4,4}насправді стискається до більш тривалої струни, ніж регекс вище.

Commodore BASIC 2.0, 339 байт

Для отримання шістнадцяткових цифр ця програма пишеться в "зміщеному режимі" (натисніть <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 було проблемою через пам’ять, розмір екрана, розмір даних та інші обмеження. Я розглядав можливість застосування скороченого подання, але інші обмеження (наприклад, недокументована неможливість використання елементів масиву як циклівних індексів) означали, що це збільшить довжину програми приблизно на 1000 байт.

Рядок 7 - це реалізація HEX$(), якої бракує Commodore BASIC 2.0. Я не можу використовувати 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, перед деякими змінами:

$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