Để đánh dấu kỷ niệm ngày IPv6 thế giới , Hiệp hội Internet đã xuất bản một chiến dịch Tắt IPv4 vào ngày 6 tháng 6 năm 2014 trong một ngày .

Địa chỉ IPv6 có thể được biểu diễn dưới dạng dài như tám giá trị hex 16 bit được phân tách bằng dấu hai chấm. Tùy thuộc vào địa chỉ, chúng cũng có thể được rút ngắn như được mô tả trong mục 2 của phần 2.2 Văn bản đại diện địa chỉ của RFC 3513 :

Để làm cho các địa chỉ ghi có chứa bit 0 dễ dàng hơn, một cú pháp đặc biệt có sẵn để nén các số không. Việc sử dụng "::" chỉ ra một hoặc nhiều nhóm 16 bit số không. "::" chỉ có thể xuất hiện một lần trong một địa chỉ. "::" cũng có thể được sử dụng để nén các số 0 ở đầu hoặc cuối trong một địa chỉ.

• Các mục nhập cho thử thách này sẽ là các chương trình chấp nhận chính xác một địa chỉ IPv6 được định dạng theo định dạng dài hoặc rút gọn và sẽ hiển thị cùng một địa chỉ ở cả định dạng dài và ngắn, theo thứ tự đó.

• Đầu vào có thể đến từ các đối số dòng lệnh, STDIN hoặc bất kỳ nguồn đầu vào nào khác phù hợp với lựa chọn ngôn ngữ của bạn.

• Các thư viện hoặc tiện ích đặc biệt để phân tích địa chỉ IPv6 bị cấm (ví dụ: inet_ {ntop, pton} () ).

• Nếu địa chỉ đầu vào không hợp lệ, đầu ra sẽ trống (hoặc một số thông báo lỗi phù hợp cho biết địa chỉ không hợp lệ được cung cấp)

• Trong trường hợp ::rút ngắn xảy ra, chỉ một thao tác rút ngắn có thể xảy ra đối với một địa chỉ nhất định. Nếu có nhiều hơn một thao tác rút ngắn tiềm năng cho một địa chỉ nhất định, thì phải sử dụng thao tác cung cấp địa chỉ ngắn nhất nói chung. Nếu có một sự ràng buộc trong vấn đề này, hoạt động đầu tiên sẽ được sử dụng. Điều này được minh họa trong các ví dụ dưới đây.

• Các sơ hở tiêu chuẩn cần tránh

Ví dụ:

Input                         Output

1080:0:0:0:8:800:200C:417A    1080:0:0:0:8:800:200C:417A
                              1080::8:800:200C:417A

FF01::101                     FF01:0:0:0:0:0:0:101
                              FF01::101

0:0:0:0:0:0:0:1               0:0:0:0:0:0:0:1
                              ::1

::                            0:0:0:0:0:0:0:0
                              ::

1:0:0:2:0:0:0:3               1:0:0:2:0:0:0:3
                              1:0:0:2::3

1:0:0:8:8:0:0:3               1:0:0:8:8:0:0:3
                              1::8:8:0:0:3

1:2:3:4:5:6:7:8               1:2:3:4:5:6:7:8
                              1:2:3:4:5:6:7:8

ABCD:1234                     <Invalid address format - no output>

ABCDE::1234                   <Invalid address format - no output>

1:2:3:4:5:6:7:8:9             <Invalid address format - no output>

:::1                          <Invalid address format - no output>

codegolf puzzle               <Invalid address format - no output>

Đây là codegolf , vì vậy câu trả lời ngắn nhất tính bằng byte vào ngày 6 tháng 6 năm 2014 sẽ được chấp nhận là người chiến thắng.

JavaScript (ES6) - 198 , 183 , 180 , 188 , 187 byte

f=s=>/^(:[\da-f]{1,4}){8}$/i.test(':'+(s=s[r='replace'](d='::',':0'.repeat((n=8-s.split(/:+/).length%9)||1)+':')[r](/^:0|0:$/g,n?'0:0':0)))&&[s,s[r](/(\b0(:0)*)(?!.*\1:0)/,d)[r](/::+/,d)]

Và, lâu hơn một chút, phiên bản tương tác với một số cửa sổ bật lên (203 byte):

/^(:[\da-f]{1,4}){8}$/i.test(':'+(s=(s=prompt())[r='replace'](d='::',':0'.repeat((n=8-s.split(/:+/).length%9)||1)+':')[r](/^:0|0:$/g,n?'0:0':0)))&&alert(s+'\n'+s[r](/(\b0(:0)*)(?!.*\1:0)/,d)[r](/::+/,d))

Ung dung:

function ipv6(str) {
    "use strict";
    var zeros = 8 - str.split(/:+/).length % 9

        ,longIP = str
            .replace('::', ':0'.repeat(zeros || 1) + ':')
            .replace(/^:0|0:$/g, zeros ? '0:0' : '0')

        ,shortIP = longIP
            .replace(/(\b0(:0)*)(?!.*\1:0)/,':')
            .replace(/::+/,'::');

    return /^(:[\da-f]{1,4}){8}$/i.test(':'+longIP) && [longIP, shortIP];
}

Giải trình:

Để tính phiên bản dài của địa chỉ IPv6:

8 - str.split(/:+/).length % 9- tính toán có bao nhiêu số không chúng ta cần chèn. Chúng là 8 - số lượng các giá trị hex. Ở đây% 9 là người bảo vệ nên nó sẽ không bao giờ là số âm.

replace('::', ':0'.repeat(zeros || 1) + ':')- thay thế "::" bằng các số 0 được phân tách bằng dấu hai chấm. Nếu không có số không để thêm, nó vẫn thêm một số để cuối cùng địa chỉ sẽ không hợp lệ

replace(/^:0|0:$/g, zeros ? '0:0' : '0')- điều này xử lý trường hợp đặc biệt khi địa chỉ bắt đầu hoặc kết thúc bằng "::" khi splithàm thêm 1 vào số giá trị hex (:: 1 -> ["", "1"])

Đó là nó! Bây giờ hãy tính dạng ngắn:

replace(/(\b0(:0)*)(?!.*\1:0)/,':') - thay thế hàng số 0 dài nhất bằng dấu hai chấm (Không quan trọng là bao nhiêu).

replace(/::+/,'::') - loại bỏ các dấu hai chấm thừa nếu có

return /^(:[\da-f]{1,4}){8}$/i.test(':'+longIP) && [longIP, shortIP];- kiểm tra nếu phiên bản dài là IPv6 hợp lệ và trả về cả hai phiên bản hoặc falsenếu thử nghiệm thất bại.

Các thử nghiệm trong Firefox:

>>> f('1080:0:0:0:8:800:200C:417A')
["1080:0:0:0:8:800:200C:417A", "1080::8:800:200C:417A"]
>>> f('FF01::101')
["FF01:0:0:0:0:0:0:101", "FF01::101"]
>>> f('0:0:0:0:0:0:0:1')
["0:0:0:0:0:0:0:1", "::1"]
>>> f('::')
["0:0:0:0:0:0:0:0", "::"]
>>> f('1:0:0:2:0:0:0:3')
["1:0:0:2:0:0:0:3", "1:0:0:2::3"]
>>> f('1:0:0:8:8:0:0:3')
["1:0:0:8:8:0:0:3", "1::8:8:0:0:3"]
>>> f('1:2:3:4:5:6:7:8')
["1:2:3:4:5:6:7:8", "1:2:3:4:5:6:7:8"]
>>> f('ABCD:1234')
false
>>> f('ABCDE::1234')
false
>>> f('1:2:3:4:5:6:7:8:9')
false
>>> f(':::1')
false
>>> f('1:2:3:4::a:b:c:d')
false
>>> f('codegolf puzzle')
false

Javascript (E6) 246 305 284 292 319

Trường hợp đặc biệt được sửa đổi mạnh mẽ cho :: giai đoạn nén được xử lý cụ thể, tránh vòng lặp for (nhưng thực tế không ngắn hơn) Tôi chắc chắn rằng giai đoạn nén cuối cùng có thể được thực hiện ngắn hơn. Không phải bây giờ

F=i=>(c=':',d=c+c,z=':0'.repeat(9-i.split(c,9).length)+c,i=i==d?0+z+0:i[R='replace'](/^::/,0+z)[R](/::$/,z+0)[R](d,z>c?z:d),/^(:[\da-f]{1,4}){8}:$/i.test(k=c+i+c)&&[i,k[R]((k.match(/:(0:)+/g)||[]).sort().pop(),d)[R](/^:([^:])|([^:]):$/g,'$1$2')])

Cảm ơn nderscore

Như một chương trình

Về cơ bản, đầu vào và đầu ra sử dụng cửa sổ bật lên js: p=prompt,p(F(p())) Viết lại bằng cửa sổ bật lên và không có định nghĩa hàm, số char phải dưới 260

Ungolfed và bình luận một chút

F = i => (
  c = ':',
  d = c+c,
  z = ':0'.repeat(9-i.split(c,9).length) + c, 
  i = i == d ? 0+z+0 /* special case '::' */
    : i.replace(/^::/,0+z) /* special case '::...' */
       .replace(/::$/,z+0) /* special case '...::' */
       .replace(d, z > c ? z : d), /* here, if z==c, not valid: too much colons */
  /^(:[\da-f]{1,4}){8}:$/i.test(k = c+i+c) /* Check if valid */
  && [
   i, 
   k.replace((k.match(/:(0:)+/g)||[]).sort().pop(),d) /* find longest 0: sequence and replace it */
    .replace(/^:([^:])|([^:]):$/g,'$1$2') /* cut leading and trailing colons */
  ]
)

Kiểm tra trong bảng điều khiển

i=['1080:0:0:0:8:800:200C:417A'
, '::1:2:3:4:5:6:7', '1:2:3:4:5:6:7::'
, '1:2:3:4::5:6:7:8'
, ':1:2:3:4:5:6:7', '1:2:3:4:5:6:7:'
, 'FF01::101', '0:0:0:0:0:0:0:1'
, '::', '1::', '::1', ':::1', '1:::'
, '1:0:0:2:0:0:0:3', '1:0:0:0:2:0:0:3', '1::8:0:0:0:3'
, '1:2:3:4:5:6:7:8'
, 'ABCD:1234', 'ABCDE::1234', ':::', '::::::::::'
, '1:2:3:4:5:6:7:8:9', '::::1', 'codegolf puzzle'];
i.map(x=>x+' => '+F(x)).join('\n')

Đầu ra thử nghiệm

"1080:0:0:0:8:800:200C:417A => 1080:0:0:0:8:800:200C:417A,1080::8:800:200C:417A
::1:2:3:4:5:6:7 => 0:1:2:3:4:5:6:7,::1:2:3:4:5:6:7
1:2:3:4:5:6:7:: => 1:2:3:4:5:6:7:0,1:2:3:4:5:6:7::
1:2:3:4::5:6:7:8 => false
:1:2:3:4:5:6:7 => false
1:2:3:4:5:6:7: => false
FF01::101 => FF01:0:0:0:0:0:0:101,FF01::101
0:0:0:0:0:0:0:1 => 0:0:0:0:0:0:0:1,::1
:: => 0:0:0:0:0:0:0:0,::
1:: => 1:0:0:0:0:0:0:0,1::
::1 => 0:0:0:0:0:0:0:1,::1
:::1 => false
1::: => false
1:0:0:2:0:0:0:3 => 1:0:0:2:0:0:0:3,1:0:0:2::3
1:0:0:0:2:0:0:3 => 1:0:0:0:2:0:0:3,1::2:0:0:3
1::8:0:0:0:3 => 1:0:0:8:0:0:0:3,1:0:0:8::3
1:2:3:4:5:6:7:8 => 1:2:3:4:5:6:7:8,1:2:3:4:5:6:7:8
ABCD:1234 => false
ABCDE::1234 => false
::: => false
:::::::::: => false
1:2:3:4:5:6:7:8:9 => false
::::1 => false
codegolf puzzle => false"   

Perl - 204 176 190 191 197

(202 ký tự + 2 cho -pcờ)

$_=uc;(9-split/:/)||/^:|:$/||last;s/^::/0::/;s/::$/::0/;s|::|':0'x(9-split/:/).':'|e;/::|^:|:$|\w{5}|[^A-F0-:].*\n/||(8-split/:/)and last;s/\b0*(?!\b)//g;print;s/\b((0:)*0)\b(?!.*\1:0\b)/::/;s/::::?/::/

Thí dụ:

$ perl -p ipv6.pl <<< 1:0:2:0::3
1:0:2:0:0:0:0:3
1:0:2::3
$ perl -p ipv6.pl <<< somethinginvalid
$ perl -p ipv6.pl <<< 1:2:0:4:0:6::8
1:2:0:4:0:6:0:8
1:2::4:0:6:0:8

Giải trình:

# -p reads a line from stdin and stores in $_
#
# Convert to uppercase
$_ = uc;

# Detect the annoying case @kernigh pointed out
(9 - split /:/) || /^:|:$/ || last;

# Fix :: hanging on the beginning or the end of the string
s/^::/0::/;
s/::$/::0/;

# Replace :: with the appropriate number of 0 groups
s|::|':0' x (9 - split /:/) . ':'|e;

# Silently exit if found an extra ::, a hanging :, a 5-char group, an invalid
# character, or there's not 8 groups
/::|^:|:$|\w{5}|[^A-F0-:].*\n/ || (8 - split /:/) and last;

# Remove leading zeros from groups
s/\b0*(?!\b)//g;

# Output the ungolfed form
print;

# Find the longest sequence of 0 groups (a sequence not followed by something
# and a longer sequence) and replace with ::
# This doesn't replace the colons around the sequence because those are optional
# thus we are left with 4 or 3 colons in a row
s/\b((0:)*0)\b(?!.*\1:0\b)/::/;

# Fix the colons after previous transformation
s/::::?/::/

# -p then prints the golfed form of the address

sed, 276

Tôi có 275 byte trong ipshorten.sed, cộng thêm 1 byte cho -rchuyển đổi sed -rfđể sử dụng các biểu thức chính quy mở rộng. Tôi đã sử dụng OpenBSD sed (1) .

Sử dụng: echo ::2:3:4:a:b:c:d | sed -rf ipshorten.sed

s/^/:/
/^(:[0-9A-Fa-f]{0,4})*$/!d
s/:0*([^:])/:\1/g
s/://
s/::/:=/
s/(.:=)(.)/\10:\2/
s/^:=/0&/
s/=$/&0/
:E
/(.*:){7}/!{/=/!d
s//=0:/
bE
}
s/=//
/^:|::|:$|(.*:){8}/d
p
s/.*/:&:/
s/:((0:)+)/:<\1>/g
:C
s/0:>/>0:/g
/<0/{s/<>//g
bC
}
s/<>(0:)+/:/
s/<>//g
/^::/!s/://
/::$/!s/:$//

Tôi sử dụng 22 biểu thức chính quy, vì sed không thể so sánh số hoặc tạo mảng. Đối với mỗi dòng đầu vào, sed chạy các lệnh và in dòng. Trong quá trình thử nghiệm, tôi đặt một số dòng địa chỉ IP bị cáo buộc vào một tệp và đưa tệp này vào sed. Tham chiếu đến các biểu thức chính quy mở rộng là trong re_format (7) .

1. s/^/:/thêm một dấu hai chấm vào đầu dòng. Tôi sử dụng thêm dấu hai chấm này để đánh golf hai lệnh tiếp theo.
2. /^(:[0-9A-Fa-f]{0,4})*$/!dkiểm tra xem toàn bộ dòng có khớp với 0 hoặc nhiều nhóm dấu hai chấm theo sau từ 0 đến 4 chữ số thập lục phân không. !phủ nhận kiểm tra, do đó dxóa các dòng có số thập lục phân quá lớn hoặc với các ký tự không hợp lệ. Khi dxóa một dòng, sed không chạy thêm lệnh nào trên dòng này.
3. s/:0*([^:])/:\1/gxóa các số 0 đứng đầu từ mỗi số. Nó sẽ thay đổi :0000:0000:thành :0:0:. Tôi phải làm điều này bởi vì vòng lặp co của tôi chỉ hoạt động với 0 chữ số đơn.
4. s/://xóa đại tràng thêm. Nó chỉ xóa dấu hai chấm đầu tiên.
5. s/::/:=/thay đổi đầu tiên ::thành :=. Điều này là để các lệnh sau này có thể khớp =hơn là ::và =không được tính là dấu hai chấm. Nếu không có ::, sự thay thế này một cách an toàn không làm gì cả.
   • Bây giờ ::phải tạo ít nhất một 0, nhưng có ba trường hợp khác nhau để đặt 0 này.
6. s/(.:=)(.)/\10:\2/là trường hợp đầu tiên. Nếu ::là giữa hai nhân vật khác, sau đó :=trở thành :=0:. Đây là trường hợp duy nhất có thêm dấu hai chấm.
7. s/^:=/0&/là trường hợp thứ hai. Nếu ::là ở đầu dòng, sau đó đặt 0 ở đó.
8. s/=$/&0/là trường hợp thứ ba, cho ::ở cuối dòng.
9. :E là nhãn cho vòng lặp mở rộng.
10. /(.*:){7}/!{/=/!dbắt đầu một khối có điều kiện nếu dòng có ít hơn 7 dấu hai chấm. /=/!dxóa các dòng không có ::và không đủ dấu hai chấm.
11. s//=0:/thêm một dấu hai chấm. Trống //lặp lại biểu thức chính quy cuối cùng, vì vậy điều này thực sự s/=/=0:/.
12. bEcác nhánh để :Etiếp tục vòng lặp.
13. }đóng khối. Bây giờ dòng có ít nhất bảy dấu hai chấm.
14. s/=//xóa =.
15. /^:|::|:$|(.*:){8}/dlà kiểm tra cuối cùng sau khi mở rộng. Nó xóa các dòng có dấu hai chấm đầu, phần phụ ::không được mở rộng, dấu hai chấm hoặc tám hoặc nhiều dấu hai chấm.
16. p in dòng, là một địa chỉ IP ở dạng dài.
17. s/.*/:&:/ kết thúc địa chỉ trong dấu hai chấm thêm.
    • Nhiệm vụ tiếp theo là tìm nhóm 0 dài nhất, thích :0:0:0:và ký hợp đồng với nó ::.
18. s/:((0:)+)/:<\1>/găn mỗi nhóm 0, vì vậy :0:0:0:sẽ trở thành :<0:0:0:>.
19. :C là nhãn cho vòng lặp co.
20. s/0:>/>0:/gdi chuyển một 0 từ mỗi miệng, vì vậy :<0:0:0:>sẽ trở thành :<0:0:>0:.
21. /<0/{s/<>//gmở một khối có điều kiện nếu bất kỳ miệng không trống. s/<>//gxóa tất cả các miệng trống, bởi vì các nhóm quá ngắn.
22. bC tiếp tục vòng lặp co.
23. }đóng khối. Bây giờ bất kỳ miệng trống rỗng và đánh dấu nhóm 0 dài nhất.
24. s/<>(0:)+/:/hợp đồng nhóm dài nhất, vì vậy :<>0:0:0:sẽ trở thành ::. Trong một cái cà vạt, nó chọn cái miệng trống rỗng bên trái.
25. s/<>//g xóa bất kỳ miệng trống rỗng khác.
26. /^::/!s/://xóa dấu hai chấm đầu tiên trừ khi nó là một phần của ::.
27. /::$/!s/:$//làm như vậy cho đại tràng cuối cùng. Sau đó sed in địa chỉ IP ở dạng ngắn.

Python 3: 387 ký tự

Thậm chí hoạt động với đầu vào rút ngắn không đúng.

$ echo '1::2:0:0:0:3' | python3 ipv6.py 
1:0:0:2:0:0:0:3
1:0:0:2::3

Thay thế kép ':::'bằng '::'cảm giác thực sự tồi tệ nhưng không chắc chắn làm thế nào để xử lý sạch chuỗi 0 dài nhất khi nó tiếp giáp một hoặc cả hai đầu.

c=':'
p=print
try:
 B=[int(x,16)if x else''for x in input().split(c)];L=len(B)
 if any(B)-1:B=[''];L=1
 if L!=8:s=B.index('');B[s:s+1]=[0]*(9-L)
 for b in B:assert-1<b<2**16
 H=[format(x,'X')for x in B];o=c.join(H);p(o);n=''.join(str(h=='0')[0]for h in H)
 for i in range(8,0,-1):
  s=n.find('T'*i)
  if s>=0:H[s:s+i]=[c*2];p(c.join(H).replace(c*3,c*2).replace(c*3,c*2));q
 p(o)
except:0

Thay thế trận chung kết passvới raiseđể xem cách nó đâm bảo vệ chống đầu vào thay đổi.

$ cat ipv6-test.sh 
echo '1080:0:0:0:8:800:200C:417A' | python3 ipv6.py
echo '1:2:3:4:5:6:7:8' | python3 ipv6.py
echo 'FF01::101' | python3 ipv6.py
echo '0:0:0:0:0:0:0:1' | python3 ipv6.py
echo '0:0:0:0:1:0:0:0' | python3 ipv6.py
echo '1:0:0:0:0:0:0:0' | python3 ipv6.py
echo '::' | python3 ipv6.py
echo '1:0:0:2:0:0:0:3' | python3 ipv6.py
echo '1::2:0:0:0:3' | python3 ipv6.py
echo '1:0:0:8:8:0:0:3' | python3 ipv6.py
echo 'ABCD:1234' | python3 ipv6.py
echo 'ABCDE::1234' | python3 ipv6.py
echo '1:2:3:4:5:6:7:8:9' | python3 ipv6.py
echo ':::1' | python3 ipv6.py
echo 'codegolf puzzle' | python3 ipv6.py
$ ./ipv6-test.sh 
1080:0:0:0:8:800:200C:417A
1080::8:800:200C:417A

1:2:3:4:5:6:7:8
1:2:3:4:5:6:7:8

FF01:0:0:0:0:0:0:101
FF01::101

0:0:0:0:0:0:0:1
::1

0:0:0:0:1:0:0:0
::1:0:0:0

1:0:0:0:0:0:0:0
1::


0:0:0:0:0:0:0:0
::

1:0:0:2:0:0:0:3
1:0:0:2::3

1:0:0:2:0:0:0:3
1:0:0:2::3

1:0:0:8:8:0:0:3
1::8:8:0:0:3