Это напоминает мне, когда несколько лет назад кто-то загрузил торрент «Инструмент хакера: полный список всех IP-адресов». Это был, конечно, просто сгенерированный список из ~ 4 миллиардов адресов IPv4, но его скачали тысячи «h4xx0rz». Смотри мама, имахакер!

Это было тогда, но сейчас все перешли на IPv6 . (Правильно?)

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

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

Каждый адрес может быть напечатан полностью, с 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

Использует цикл while с 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);}}

Пояснение: сам алгоритм достаточно прост. Я использовал long, а не unsigned 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];for всего 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, проваливаются в конце main и поэтому могут возвращать ложный код выхода в операционную систему.

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: Конец внутреннего цикла for
• ConsoleWrite(@LF): Добавить перевод строки в конце строки
• Next: Конец внешних петель

Ожидаемый размер вывода: (одна строка (39 байт) + перевод строки) (= 40 байт) * 2 ^ 128 = 1,311 * 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 представляют собой восемь вложенных циклов, реализованных в виде семи циклов «for» и условного перехода, поскольку восемь циклов «for» в сочетании с двумя «gosub» для распечатки адреса переполнят крошечный стек 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