Zum Jahrestag des Welt-IPv6-Tages hat die Internet Society am 6. Juni 2014 eine Kampagne zum einmaligen Deaktivieren von IPv4 veröffentlicht .

IPv6-Adressen können in ihrer langen Form als acht durch Doppelpunkte getrennte 16-Bit-Hexadezimalwerte dargestellt werden. Abhängig von der Adresse können sie auch wie in Punkt 2 von Abschnitt 2.2 Textdarstellung von Adressen von RFC 3513 beschrieben gekürzt werden :

Um das Schreiben von Adressen mit Null-Bits zu vereinfachen, steht eine spezielle Syntax zum Komprimieren der Nullen zur Verfügung. Die Verwendung von "::" gibt eine oder mehrere Gruppen von 16 Bit Nullen an. Das "::" darf in einer Adresse nur einmal vorkommen. Das "::" kann auch verwendet werden, um führende oder nachfolgende Nullen in einer Adresse zu komprimieren.

• Beiträge zu dieser Herausforderung sind Programme, die genau eine IPv6-Adresse akzeptieren, die entweder im langen oder im verkürzten Format formatiert ist, und die die gleiche Adresse sowohl im langen als auch im kurzen Format in dieser Reihenfolge anzeigen .

• Die Eingabe kann von Befehlszeilenargumenten, STDIN oder einer anderen Eingabequelle stammen, die für Ihre Sprachauswahl geeignet ist.

• Bibliotheken oder Dienstprogramme speziell zum Parsen von IPv6-Adressen sind gesperrt (z. B. inet_ {ntop, pton} () ).

• Wenn die Eingabeadresse ungültig ist, ist die Ausgabe leer (oder es wird eine geeignete Fehlermeldung ausgegeben, die angibt, dass die Adresse ungültig ist).

• In Fällen, in denen eine ::Verkürzung auftritt, kann für eine bestimmte Adresse nur eine Verkürzungsoperation ausgeführt werden. Wenn es für eine Adresse mehr als eine mögliche Kürzungsoperation gibt, muss die Operation verwendet werden, die die insgesamt kürzeste Adresse angibt. Wenn diesbezüglich ein Gleichstand besteht, wird die erste Operation verwendet. Dies wird in den folgenden Beispielen veranschaulicht.

• Standardlücken sind zu vermeiden

Beispiele:

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>

Dies ist Codegolf , daher wird die kürzeste Antwort in Bytes am 6. Juni 2014 als Gewinner akzeptiert.

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

Und eine etwas längere, interaktive Version mit einigen Popups (203 Bytes):

/^(:[\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))

Ungolfed:

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

Erläuterung:

So berechnen Sie die lange Version der IPv6-Adresse:

8 - str.split(/:+/).length % 9- berechnen Sie, wie viele Nullen wir einfügen müssen. Sie sind 8 - die Anzahl der Hex-Werte. Hier ist% 9 eine Wache, daher wird es niemals eine negative Zahl sein.

replace('::', ':0'.repeat(zeros || 1) + ':')- Ersetzen Sie das "::" durch durch Doppelpunkte getrennte Nullen. Wenn keine Nullen hinzugefügt werden müssen, wird immer noch eine hinzugefügt, sodass die Adresse am Ende nicht gültig ist

replace(/^:0|0:$/g, zeros ? '0:0' : '0')- Dies behandelt den Sonderfall, wenn die Adresse mit "::" beginnt oder endet, da die splitFunktion die Anzahl der Hex-Werte um 1 erhöht (:: 1 -> ["", "1"]).

Das ist es! Nun berechnen wir die Kurzform:

replace(/(\b0(:0)*)(?!.*\1:0)/,':') - Ersetzen Sie die längste Nullenreihe durch Doppelpunkte (egal wie viele).

replace(/::+/,'::') - Entfernen Sie gegebenenfalls die zusätzlichen Doppelpunkte

return /^(:[\da-f]{1,4}){8}$/i.test(':'+longIP) && [longIP, shortIP];- Testen Sie, ob die lange Version IPv6-gültig ist, und geben Sie beide Versionen zurück, oder falsewenn der Test fehlschlägt.

Tests in 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

Stark überarbeiteter Spezialfall für :: speziell behandelte, komprimierte Phase vermeidet die for-Schleife (aber nicht sehr kürzer) Ich bin sicher, dass die endgültige komprimierte Phase kürzer gemacht werden kann. Jedenfalls jetzt nicht

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')])

Danke an nderscore

Als ein Programm

Ein- und Ausgabe über js Popup, grundsätzlich: Beim p=prompt,p(F(p())) Umschreiben mit Popup und ohne Funktionsdefinition sollte die Zeichenanzahl unter 260 liegen

Ungolfed und kommentierte ein bisschen

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 */
  ]
)

In Konsole testen

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')

Ausgang testen

"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 Zeichen + 2 für -pFlagge)

$_=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/::::?/::/

Beispiel:

$ 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

Erläuterung:

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

Ich habe 275 Bytes in ipshorten.sed, plus 1 Byte für die -rUmschaltung sed -rfauf erweiterte reguläre Ausdrücke. Ich habe OpenBSD sed (1) benutzt .

Verwendung: 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/:$//

Ich benutze 22 reguläre Ausdrücke, da sed keine Zahlen vergleichen oder Arrays erstellen kann. Sed führt für jede Eingabezeile die Befehle aus und gibt die Zeile aus. Während des Tests habe ich mehrere Zeilen angeblicher IP-Adressen in eine Datei geschrieben und diese Datei an sed weitergeleitet. Ein Verweis auf erweiterte reguläre Ausdrücke befindet sich in re_format (7) .

1. s/^/:/Fügt am Zeilenanfang einen zusätzlichen Doppelpunkt ein. Ich benutze diesen zusätzlichen Doppelpunkt, um die nächsten zwei Befehle zu spielen.
2. /^(:[0-9A-Fa-f]{0,4})*$/!dprüft, ob die gesamte Zeile mit null oder mehr Doppelpunktgruppen übereinstimmt, gefolgt von null bis vier hexadezimalen Ziffern. !negiert die Prüfung, dlöscht also Zeilen mit zu großen Hexadezimalzahlen oder mit ungültigen Zeichen. Wenn deine Zeile gelöscht wird, führt sed in dieser Zeile keine Befehle mehr aus.
3. s/:0*([^:])/:\1/glöscht führende Nullen von jeder Zahl. Es würde sich ändern :0000:0000:zu :0:0:. Ich muss das tun, weil meine Kontraktionsschleife nur mit einstelligen Nullen funktioniert.
4. s/://löscht den zusätzlichen Doppelpunkt. Es wird nur der erste Doppelpunkt gelöscht.
5. s/::/:=/ändert die erste ::zu :=. Dies ist so, dass spätere Befehle =eher übereinstimmen können als ::und daher =nicht als Doppelpunkt gelten. Wenn dies nicht der ::Fall ist , führt diese Substitution sicher zu nichts.
   • Jetzt ::muss mindestens eine 0 gemacht werden, aber es gibt drei verschiedene Fälle, um diese 0 zu platzieren.
6. s/(.:=)(.)/\10:\2/ist der erste Fall. Wenn ::zwischen zwei anderen Zeichen war, :=wird :=0:. Dies ist der einzige Fall, in dem ein Doppelpunkt hinzugefügt wird.
7. s/^:=/0&/ist der zweite Fall. Wenn ::sich am Zeilenanfang befand, geben Sie dort 0 ein.
8. s/=$/&0/ist der dritte Fall für ::am Ende der Zeile.
9. :E ist die Bezeichnung für die Erweiterungsschleife.
10. /(.*:){7}/!{/=/!dBeginnt ein Bedingungsblock, wenn die Zeile weniger als 7 Doppelpunkte enthält. /=/!dlöscht Zeilen, die keine ::oder nicht genügend Doppelpunkte enthalten.
11. s//=0:/fügt einen Doppelpunkt hinzu. Empty //wiederholt den letzten regulären Ausdruck, das ist also wirklich so s/=/=0:/.
12. bEverzweigt nach :E, um die Schleife fortzusetzen.
13. }schließt den Block. Jetzt hat die Linie mindestens sieben Doppelpunkte.
14. s/=//löscht =.
15. /^:|::|:$|(.*:){8}/dist eine letzte Prüfung nach der Erweiterung. Es löscht Zeilen mit einem führenden Doppelpunkt, einem ::nicht erweiterten, einem nachgestellten Doppelpunkt oder acht oder mehr Doppelpunkten.
16. p Gibt die Zeile aus, die eine lange IP-Adresse ist.
17. s/.*/:&:/ schließt die Adresse in zusätzliche Doppelpunkte ein.
    • Die nächste Aufgabe besteht darin, die längste Gruppe von Nullen zu finden :0:0:0:und sie zusammenzuziehen ::.
18. s/:((0:)+)/:<\1>/gisst jede Gruppe von 0en, :0:0:0:würde also werden :<0:0:0:>.
19. :C ist die Bezeichnung für die Kontraktionsschleife.
20. s/0:>/>0:/gBewegt sich eine 0 aus jedem Mund, so :<0:0:0:>würde es werden :<0:0:>0:.
21. /<0/{s/<>//göffnet einen bedingten Block, wenn ein Mund nicht leer ist. s/<>//glöscht alle leeren Münder, weil diese Gruppen zu kurz sind.
22. bC setzt die Kontraktionsschleife fort.
23. }schließt den Block. Jetzt ist jeder Mund leer und markiert die längste Gruppe von Nullen.
24. s/<>(0:)+/:/Verträge die längste Gruppe, so :<>0:0:0:würde werden ::. Bei einem Unentschieden nimmt es den leeren Mund auf der linken Seite.
25. s/<>//g löscht alle anderen leeren Münder.
26. /^::/!s/://löscht den ersten zusätzlichen Doppelpunkt, sofern er nicht Teil von ist ::.
27. /::$/!s/:$//tut dies für den letzten zusätzlichen Doppelpunkt. Anschließend druckt sed die IP-Adresse in Kurzform.

Python 3: 387 Zeichen

Funktioniert auch mit falsch verkürzten Eingaben.

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

Das doppelte Ersetzen von ':::'mit '::'fühlt sich wirklich schlecht an, ist sich aber nicht sicher, wie man sauber mit der längsten Zeichenfolge von Nullen umgeht, wenn sie an einem oder beiden Enden anliegt.

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

Ersetzen Sie das Finale passdurch, um raisezu sehen, wie es beim Schutz vor fehlerhaften Eingaben abstürzt .

$ 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