이것은 몇 년 전에 누군가가 토런트 "해커 도구 : 모든 IP 주소의 전체 목록"을 업로드했을 때를 상기시킵니다. 물론 이것은 40 억 개의 IPv4 주소의 생성 된 목록 일 뿐이지 만 수천 개의 "h4xx0rz"가이를 다운로드했습니다. 엄마 봐요, 이마 해커!

당시에는 모든 사람들이 IPv6 로 전환했습니다 . (권리?)

당신의 임무는 모든 IPv6 주소 를 인쇄 하는 프로그램을 작성하는 것 입니다.

입력을받지 않고 IPv6 주소를 한 줄에 하나씩, 다른 출력을 인쇄하지 않는 전체 프로그램을 작성해야합니다. 프로그램은 유효하지 않은 주소를 포함하여 ^{2128 개의} 가능한 주소를 모두 인쇄해야합니다 . 각 주소는 정확히 한 번만 인쇄해야합니다. 주소는 어떤 순서로든 인쇄 할 수 있습니다.

각 주소는 콜론으로 구분 된 4 개의 16 진수로 구성된 8 개의 그룹으로 전체 인쇄 될 수 있습니다. 예 :

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

귀하의 재량에 따라 RFC 5952 의 표준 약어를 사용할 수 있습니다 .

• 그룹에서 선행 0은 생략 할 수 있지만 0더 이상 생략 할 수는 없습니다.
• :: 는 하나 이상의 모든 0 그룹의 시퀀스를 축약하기 위해 주소 당 최대 한 번만 사용될 수 있습니다.
• 16 진수는 소문자 또는 대문자를 사용할 수 있습니다.

당신이 달성되면 RFC 5952에서 표현의 추천 (와 소문자 문자 만 짧은 표현을 ::일찍 사용할 수 있습니다 여러 위치가있는 경우 가능한 한 사용), 당신은 얻을 -20 %의 보너스를 .

출력 크기로 인해 우리가 앉아있는 동안 프로그램이 완료되지 않을 것으로 예상됩니다. 어느 시점에서 외부 수단에 의해 프로그램이 중단 될 수 있습니다 ( Ctrl+ C, 전원을 끄는 중…). 프로그램은 출력을 스트림으로 생성해야하므로 "합리적인"대기 후에 일부 라인이 생성됩니다. 기본적으로 마지막에 인쇄하기 위해 메모리에 거대한 문자열을 작성하는 것은 허용되지 않습니다. "표준"PC에서 메모리가 부족한 모든 프로그램은 실격 처리됩니다. 그럼에도 불구하고 프로그램을 충분히 오래 실행 한 경우 모든 IPv6 주소를 인쇄 한 다음 종료해야합니다.

(이 조건이 완료 될 때까지 프로그램을 실행 한 다음 출력을 보도록하는 웹 통역사에 문제가있는 경우 호스팅 된 통역사가없는 경우 더 작은 버전의 문제에 대해 프로그램을 테스트 한 후 신중하게 조정하십시오. 전체 ^2128까지 .)

점수는 프로그램 길이 (바이트)이며 보너스를받는 경우 0.8을 곱한 값입니다. 코드 골프이므로 최저 점수가 이깁니다.

Pyth, 21 바이트

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

J반복자 변수로 while 루프를 사용 합니다. 을 사용하여 최대 값을 초기화합니다 8^chr(' '). 초기 값을 더하고 16 진수로 변환 한 다음 첫 문자를 제거하여 채 웁니다.

파이썬 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

이는 적어도 2 소비하는 것) 한 이후 실행할 수 없습니다 ¹³² 바이트 (2 ⁵² yobibytes) 메모리, 2) 인터프리터가 좋아하지 않는을 (2 ⁽¹²⁸⁾ 에 적합하지 않으며 ssize_t그래서, list그 크기 S) . 사전 식 순서로 주소를 인쇄합니다. 결국 숫자를 사용 가능한 것으로 변경하여 알고리즘을 시험해 볼 수 있습니다.

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천만에 대한 모든 백만 라인의 최대 출력 :

$ ./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 시스템을 사용하고 있으며 네트워크 주소는 일반적으로 항상 네트워크 순서 (빅 엔디안)이므로 엔디안은을 사용하여 효과적으로 교환됩니다 inet_ntop(). 이것은 중요하지 않습니다-모든 주소는 여전히 (결과적으로) 표시됩니다.

CJam, 36 27 바이트

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

@Dennis 덕분에 -9 바이트 (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

파이썬 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

Verilog, 335

내 첫 Verilog 제출은 아마도 더 많은 골프를 사용할 수 있지만 지금은 그렇게 할 에너지가 없습니다. c시계, oASCII 출력입니다. 약식 대신에 제로 패딩으로 인해 서식 보너스를받을 수 없습니다.

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를 만들기 위해 약간의 비트 조정이 뒤 따릅니다. 나는 작은 그룹으로 마지막 그룹 뒤에 콜론을 자른다. ISE 13.7 lin64에서 xc3s500e-4ft256-4를 합성하고 작동하는 것으로 보입니다.

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

설명 : 알고리즘 자체는 매우 간단합니다. 나는 더 짧기 때문에 unsigned int보다는 오랫동안 사용했습니다. 파일 수준에서 선언하면 모든 것이 0으로 사전 초기화됩니다. 이 f기능은 캐리의 간단한 증가로 각 워드의 하위 16 비트에서 작동합니다. 루프가 129 번째 비트로 전달되면 종료됩니다.

printf에 대해 거꾸로 반복한다는 것은 주소를 "적절한"순서로 인쇄한다는 것을 의미하며 개행 인쇄 검사는 몇 문자가 더 짧습니다.

이것은 이식 불가능한 구성을 사용합니다. 암시 적 int 반환 유형을 사용하고 stdio.h를 포함하지 않기 때문에 C의 K & R 방언으로 가장 잘 간주됩니다. 그리고 내 long 사용은 이것에 의해 알려졌습니다. 대부분의 현대 시스템에서는 int이면 32 비트이기 때문에 충분합니다. 이것은 아마도 PDP-11 Unix에서 수정되지 않은 상태로 실행될 수 있습니다.

그러나 더 짧을 수 있습니다. int (16 비트보다 넓은 유형 또는 2 개의 보수 및 산술 롤오버와 같은 많은 시스템에서 적용되는 다양한 속성을 가진 정확히 16 비트 유형)를 사용할 수 있다고 가정하면 제거 할 수 있습니다. 오래 사용하는 것과 관련된 것들.

16 비트보다 넓은 int 버전, 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없이 선언을 지원하지 않았다 (이 벌금을 컴파일하지만 외부 따라서 링크 타임에 정의되지 않은 등의 취급 변수), 추가로 3 바이트가에 선언 변경하는 데 필요한, 그래서 int*p,a[9];를 들어 총 94.

또한 출력을 완료하기 전에 중단되었다는 가정이 어려운 제약 조건 인 경우 종료 검사를 제거하여 5 바이트를 절약 할 수 있습니다.

보너스 : 완전 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: 0-2 ^ 32 ((2 ^ 32) ^ 4 = 2 ^ 128) 가능한 조합에 대해 4 번 반복합니다.
• $s=StringFormat("%08x%08x%08x%08x",$a,$b,$c,$d): 숫자를 길이가 32 (4 * 32) 인 16 진 문자열로 변환하십시오.
• For $j=0 To 8: 문자열의 모든 8 개 섹션을 반복합니다.
• ConsoleWrite(StringMid($s,$j*4+1,4)&($j<7?":":"")): 문자열에서 다음 4자를 추출하고 :마지막 부분에 도달하지 않은 경우 끝에 콜론 ( )을 추가 한 다음 모든 것을 콘솔에 출력하십시오.
• Next: 내부 루프 종료
• ConsoleWrite(@LF): 줄 끝에 줄 바꿈 추가
• Next: 외부 for 루프 종료

예상 출력 크기 : (한 줄 (39 바이트) + 줄 ​​바꿈) (= 40 바이트) * 2 ^ 128 = 1.361 * 10 ^ 16 YB (요타 바이트)

계피 껌, 16 바이트

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

온라인으로 사용해보십시오. (TIO 리미트 출력)

설명

이 g모드는 Cinnamon Gum을 생성 모드로 설정합니다 . 나머지 문자열은이 정규식으로 압축 해제됩니다.

[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}실제로 위 정규식보다 긴 문자열로 압축됩니다.

코모도어 베이직 2.0, 339 바이트

소문자 16 진수를 얻기 위해이 프로그램은 "shifted mode"로 작성됩니다 (을 누르십시오 <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 행은 4 자리 그룹에 적용되는 서브 루틴으로, 함수가 문자열을 리턴 할 수있는 경우 상당히 짧습니다.

2 행과 5 행은 8 개의 중첩 루프로, 7 개의 "for"루프와 조건부 goto로 구현됩니다. 8 개의 "for"루프는 주소를 인쇄하기위한 2 개의 "gosubs"와 결합되면 C64의 작은 스택에 오버플로가 발생하기 때문입니다.

C64는 1.3 * 10 ^ 31 년의 예상 런타임 동안 초당 약 1.2 개의 주소를 인쇄 할 수 있습니다.

PowerShell (v4), 193166162145103 바이트

103 바이트의 TimmyD의 비 보너스 버전 :

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

145 * 0.8 = 116 바이트의 이전 with-Bonus 버전

도움을 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

파이썬 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까지의 모든 숫자를 거칩니다. 먼저 현재 숫자를 16 진수 문자열로 변환 한 다음 '0x'해당 함수가 제공하는 것을 제거 합니다. 그런 다음 문자열 앞에 32 개의 0을 갖도록 조정 한 다음 4 개의 그룹으로 나눕니다. 마지막으로 4 개의 그룹을 콜론으로 연결하고 출력하여 현재 숫자에 1을 더합니다. 추가 보너스를 주면 아무 값에서나 시작할 수 있지만 추가 입력이 필요하지 않습니다.

하스켈 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

Mark의 대답 은 Commodore 64의 BASIC 2.0에 대한 것이며, 16 진수로 숫자를 인쇄하기위한 기본 제공 명령이 없습니다. 그러나 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