विश्व आईपीवी 6 दिवस 2014

22

विश्व आईपीवी 6 दिवस की वर्षगांठ को चिह्नित करने के लिए , इंटरनेट सोसायटी ने 6 जून 2014 को वन डे के लिए टर्न ऑफ आईपीवी 4 के लिए एक अभियान प्रकाशित किया है ।

IPv6 पतों को उनके लंबे रूप में आठ औपनिवेशिक-पृथक 16-बिट हेक्स मानों के रूप में दर्शाया जा सकता है। पते के आधार पर, उन्हें RFC 3513 के पते के खंड 2.2 पाठ प्रतिनिधित्व के आइटम 2 में वर्णित के रूप में भी छोटा किया जा सकता है :

शून्य बिट वाले लेखन पते को आसान बनाने के लिए शून्य को संपीड़ित करने के लिए एक विशेष वाक्यविन्यास उपलब्ध है। "::" का उपयोग शून्य के 16 बिट्स के एक या अधिक समूहों को इंगित करता है। "::" केवल एक पते में एक बार दिखाई दे सकता है। "::" का उपयोग किसी पते में अग्रणी या अनुगामी शून्य को संपीड़ित करने के लिए भी किया जा सकता है।

  • इस चुनौती में प्रवेश ऐसे कार्यक्रम होंगे जो लंबे या छोटे प्रारूप में प्रारूपित एक आईपीवी 6 पते को स्वीकार करते हैं, और उस क्रम में दोनों लंबे और छोटे प्रारूपों में एक ही पता प्रदर्शित करेंगे ।

  • इनपुट कमांड-लाइन तर्कों, STDIN, या किसी अन्य इनपुट स्रोत से आ सकता है जो आपकी भाषा के अनुकूल है।

  • विशेष रूप से IPv6 पते पार्स करने के लिए लाइब्रेरी या उपयोगिताओं पर प्रतिबंध लगा दिया गया है (जैसे inet_ {ntop, pton} () )।

  • यदि इनपुट पता अमान्य है, तो आउटपुट रिक्त होगा (या पते को अमान्य बताते हुए कुछ उपयुक्त त्रुटि संदेश दिया गया है)

  • ऐसे मामलों में जहां ::छोटा होता है, एक दिए गए पते के लिए केवल एक छोटा संचालन हो सकता है। यदि किसी दिए गए पते के लिए एक से अधिक संभावित छोटे संचालन हैं, तो वह ऑपरेशन जो सबसे छोटा पता देता है, का उपयोग किया जाना चाहिए। यदि इस संबंध में कोई टाई है, तो पहले ऑपरेशन का उपयोग किया जाएगा। इसका उदाहरण नीचे दिए गए उदाहरणों में दिया गया है।

  • मानक खामियों से बचा जाए

उदाहरण:

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>

यह कोडगोल्फ है , इसलिए 6 जून 2014 को बाइट्स में सबसे छोटा उत्तर विजेता के रूप में स्वीकार किया जाएगा।

code-golf  string  networking 
— डिजिटल आघात
स्रोत
कहो इनपुट है 1:0:0:2:2::3। छोटा आउटपुट उसी के समान होगा या 1::2:2:0:0:3? गैर-आशावादी लघु इनपुट के लिए भी।
— मार्टिन एंडर
@ m.buettner इस मामले में, मैं आपको या तो लेने दूँगा।
— डिजिटल ट्रामा
है 1::2:0:0:0:3एक संभव इनपुट?
— user12205
— डिजिटल ट्रामा
2
मुझे लगता है कि यह एकमात्र तरीका है जिससे किसी को भी मुझे आईपीवी 6 सीखने को मिलेगा। +1
— आपाधापी

जवाबों:

4

जावास्क्रिप्ट (ईएस 6) - 198 , 183 , 180 , 188 , 187 बाइट्स

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

और, कुछ पॉप-अप (203 बाइट्स) के साथ थोड़ा लंबा, इंटरैक्टिव संस्करण:

/^(:[\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];
}

स्पष्टीकरण:

IPv6 पते के लंबे संस्करण की गणना करने के लिए:

8 - str.split(/:+/).length % 9- गणना करें कि हमें कितने शून्य सम्मिलित करने की आवश्यकता है। वे 8 हैं - हेक्स मूल्यों की संख्या। यहां% 9 एक गार्ड है इसलिए यह कभी भी ऋणात्मक संख्या नहीं होगी।

replace('::', ':0'.repeat(zeros || 1) + ':')- "::" को कोलोन से अलग किए गए शून्य से बदलें। यदि कोई शून्य जोड़ने के लिए अभी भी एक नहीं है, तो पता अंत में मान्य नहीं होगा

replace(/^:0|0:$/g, zeros ? '0:0' : '0')- यह विशेष मामले के साथ संबंधित है जब पता शुरू होता है या "::" के साथ समाप्त होता है क्योंकि splitफ़ंक्शन हेक्स मानों की संख्या में 1 जोड़ता है (:: 1 -> ["", "1"])

बस! अब संक्षिप्त रूप की गणना करते हैं:

replace(/(\b0(:0)*)(?!.*\1:0)/,':') - बृहदान्त्र (ओं) के साथ शून्य की सबसे लंबी पंक्ति को बदलें (यह कोई फर्क नहीं पड़ता कि कितने)।

replace(/::+/,'::') - यदि कोई हो तो अतिरिक्त कॉलोन हटा दें

return /^(:[\da-f]{1,4}){8}$/i.test(':'+longIP) && [longIP, shortIP];- परीक्षण अगर लंबा संस्करण IPv6 मान्य है और दोनों संस्करणों को वापस कर falseदें या यदि परीक्षण विफल हो जाता है।

फ़ायरफ़ॉक्स में टेस्ट:

>>> 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
— core1024
स्रोत
इतना बेहतर है मेरा! इस तरह के इनपुट को संभालने के लिए बस कुछ सुधार की आवश्यकता है :: 1 :,: 1 ::
— edc65
इसने 1:2:3:4::a:b:c:d
— कर्ण
6

जावास्क्रिप्ट (ई 6) 246 305 284 292 319

भारी संशोधित संशोधित मामले के लिए विशेष रूप से नियंत्रित: विशेष रूप से संकलित चरण लूप के लिए बचा जाता है (लेकिन वास्तव में बहुत छोटा नहीं है) मुझे यकीन है कि अंतिम सेक चरण को कम किया जा सकता है। वैसे भी अब नहीं

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

अंडरस्कोर करने के लिए धन्यवाद

एक कार्यक्रम के रूप में

जेएस पॉपअप का उपयोग करते हुए इनपुट और आउटपुट, मूल रूप से: p=prompt,p(F(p())) पॉपअप के साथ रीफ़्रिट करना और फ़ंक्शन परिभाषा के बिना, चार्ट की गणना 260 से कम होनी चाहिए

असंगठित और थोड़ा टिप्पणी की

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

कंसोल में टेस्ट करें

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

परीक्षण उत्पादन

"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"
— edc65
स्रोत
मैं एक समारोह के बजाय एक कार्यक्रम चाहता था। मैं जावास्क्रिप्ट को अच्छी तरह से नहीं जानता कि क्या यह संभव है।
— डिजिटल ट्रॉमा
@nderscore Oops - टाइपो। एक नई टिप्पणी में सही।
— डिजिटल ट्रॉमा
से इनपुट लेकर इसे एक प्रोग्राम में बनाया जा सकता है prompt()। यहाँ कुछ अनुकूलन दिए गए हैं जो इसे 290 तक ले जाते हैं: pastie.org/private/3ccpinzqrvvliu9nkccyg
— nderscore
@nderscore: thx, पहली जगह इनपुट = '::' के लिए काम नहीं करता है, वैसे भी बढ़िया काम!
— edc65
@ edc65 मैंने इसके लिए एक जगह तय की :) :) pastie.org/pirt/kee0sdvjez0vfcmlvaxu8q
— nderscore
4

पर्ल - 204 176 190 191 197

( -pध्वज के लिए 202 वर्ण + 2 )

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

उदाहरण:

$ 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

स्पष्टीकरण:

# -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
— mniip
स्रोत
1
"IPv6.pl लाइन 1, <> लाइन 1" पर निधन । यह सवाल टिप्पणियों में पूछा गया था। यदि कोई संदेश है, तो यह स्पष्ट होना चाहिए कि यह अमान्य संदेश के कारण है। मैंने उस प्रश्न में स्पष्ट करने की कोशिश की। अन्यथा अच्छा लग रहा है!
— डिजिटल ट्रॉमा
1
@DigitalTrauma dieएक मौन निकास में बदल गया।
— मणिप
1
एक दोष? यह कार्यक्रम अमान्य पते को स्वीकार करता है 1:2:3:4::a:b:c:d। यह एक कष्टप्रद विशेष मामला है, क्योंकि अधिकांश आठ पेट के पते अवैध हैं, लेकिन ::2:3:4:a:b:c:dऔर 1:2:3:4:a:b:c::दोनों मान्य हैं।
— कर्णघट
3

सेड, 276

मेरे पास ipshorten.sed में 275 बाइट्स हैं, साथ ही विस्तारित नियमित अभिव्यक्तियों का उपयोग करने के लिए -rस्विच के लिए 1 बाइट sed -rf। मैंने ओपनबीएसडी सेड (1) का इस्तेमाल किया ।

उपयोग: 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/:$//

मैं 22 नियमित अभिव्यक्तियों का उपयोग करता हूं, क्योंकि sed संख्याओं की तुलना नहीं कर सकता है या सरणियां नहीं बना सकता है। इनपुट की प्रत्येक पंक्ति के लिए, sed कमांड चलाता है और लाइन को प्रिंट करता है। परीक्षण के दौरान, मैंने एक फ़ाइल में कथित आईपी पते की कई पंक्तियाँ डालीं, और इस फ़ाइल को sed को खिलाया। विस्तारित नियमित अभिव्यक्तियों का एक संदर्भ re_format (7) में है ।

  1. s/^/:/लाइन की शुरुआत में एक अतिरिक्त कोलन जोड़ता है। मैं इस अतिरिक्त बृहदान्त्र का उपयोग अगले दो आदेशों को प्राप्त करने के लिए करता हूँ।
  2. /^(:[0-9A-Fa-f]{0,4})*$/!dजाँच करता है कि पूरी लाइन शून्य या अधिक समूहों से मेल खाती है जिसके बाद शून्य से चार हेक्साडेसिमल अंक हैं। !चेक को नकारता है, इसलिए dबहुत बड़ी हेक्साडेसिमल संख्याओं या अमान्य वर्णों के साथ लाइनें हटाता है। जब dकोई लाइन हटाता है, तो sed इस लाइन पर अधिक कमांड नहीं चलाता है।
  3. s/:0*([^:])/:\1/gप्रत्येक नंबर से 0s हटाता है। यह बदल जाएगा :0000:0000:करने के लिए :0:0:। मुझे यह करना चाहिए क्योंकि मेरा संकुचन लूप केवल एकल-अंक 0s के साथ काम करता है।
  4. s/://अतिरिक्त बृहदान्त्र हटाता है। यह केवल पहले कोलन को हटाता है।
  5. s/::/:=/पहले ::को बदलता है :=। यह इसलिए बाद में आदेश के =बजाय मैच कर सकते हैं ::, और इसलिए =एक बृहदान्त्र के रूप में गिनती नहीं है। यदि कोई नहीं है ::, तो यह प्रतिस्थापन सुरक्षित रूप से कुछ नहीं करता है।
    • अब ::कम से कम एक 0 बनाना चाहिए, लेकिन इस 0 को रखने के लिए तीन अलग-अलग मामले हैं।
  6. s/(.:=)(.)/\10:\2/पहला मामला है। अगर ::दो अन्य पात्रों के बीच था, तो :=बन जाता है :=0:। यह एकमात्र मामला है जो एक बृहदान्त्र जोड़ता है।
  7. s/^:=/0&/दूसरा मामला है। अगर ::लाइन की शुरुआत में था, तो वहाँ 0 डाल दिया।
  8. s/=$/&0/तीसरा मामला है, ::लाइन के अंत के लिए।
  9. :E विस्तार पाश के लिए लेबल है।
  10. /(.*:){7}/!{/=/!dयदि लाइन 7 से कम कॉलन है, तो एक सशर्त ब्लॉक शुरू होता है। /=/!dउन लाइनों को हटा देता है जिनके पास ::पर्याप्त कॉलोन नहीं थे।
  11. s//=0:/एक कोलोन जोड़ता है। खाली //अंतिम नियमित अभिव्यक्ति को दोहराता है, इसलिए यह वास्तव में है s/=/=0:/।
  12. bEशाखाओं को :Eलूप जारी रखने के लिए।
  13. }ब्लॉक बंद कर देता है। अब लाइन में कम से कम सात कॉलोन हैं।
  14. s/=//हटा देता है =।
  15. /^:|::|:$|(.*:){8}/dविस्तार के बाद एक अंतिम जांच है। यह एक अग्रणी बृहदान्त्र के साथ लाइनों को हटाता है, एक अतिरिक्त ::जिसे विस्तारित नहीं किया गया था, एक अनुगामी बृहदान्त्र, या आठ या अधिक कॉलोन।
  16. p लाइन को प्रिंट करता है, जो लंबे रूप में एक आईपी एड्रेस है।
  17. s/.*/:&:/ अतिरिक्त कॉलनों में पता लपेटता है।
    • अगला कार्य 0s के सबसे लंबे समूह को खोजना, पसंद करना :0:0:0:और उसमें अनुबंध करना है ::।
  18. s/:((0:)+)/:<\1>/g0s के प्रत्येक समूह को खाता है, इसलिए :0:0:0:बन जाएगा :<0:0:0:>।
  19. :C संकुचन पाश के लिए लेबल है।
  20. s/0:>/>0:/gप्रत्येक मुंह से एक 0 चलता है, इसलिए :<0:0:0:>बन जाएगा :<0:0:>0:।
  21. /<0/{s/<>//gयदि कोई मुंह खाली नहीं है तो एक सशर्त ब्लॉक खोलता है। s/<>//gसभी खाली मुंह हटा देता है, क्योंकि वे समूह बहुत कम हैं।
  22. bC संकुचन पाश जारी है।
  23. }ब्लॉक बंद कर देता है। अब कोई भी मुंह खाली है और 0s के सबसे लंबे समूह को चिह्नित करता है।
  24. s/<>(0:)+/:/सबसे लंबे समूह का अनुबंध करता है, इसलिए :<>0:0:0:बन जाएगा ::। एक टाई में, यह बाईं ओर खाली मुंह चुनता है।
  25. s/<>//g किसी भी अन्य खाली मुंह को हटाता है।
  26. /^::/!s/://जब तक यह का हिस्सा नहीं है तब तक पहले अतिरिक्त कोलन को हटा देता है ::।
  27. /::$/!s/:$//अंतिम अतिरिक्त बृहदान्त्र के लिए ऐसा करता है। फिर sed संक्षिप्त रूप में IP पते को प्रिंट करता है।
— kernigh
स्रोत
1

पायथन 3: 387 वर्ण

यहां तक ​​कि अनुचित रूप से छोटा इनपुट के साथ काम करता है।

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

डबल रिप्लेस के ':::'साथ '::'वास्तव में बुरा लगता है लेकिन निश्चित नहीं है कि 0 के सबसे लंबे स्ट्रिंग के साथ सफाई से कैसे निपटें जब यह एक या दोनों को समाप्त कर देता है।

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

अंतिम बदलें passसाथ raiseदेखने के लिए कि यह कैसे है दुर्घटनाग्रस्त विकृत इनपुट के खिलाफ की रक्षा।

$ 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
— निक टी
स्रोत
@DigitalTrauma ने ठीक किया। मैं "0: 0: 0 ..." के लिए खोज कर रहा था और यह 0
— निक टी
आप वास्तव में आजकल पर्याप्त शब्द "एब्स" नहीं सुनते हैं
— क्लाउडीयू
एक दोष? इस कार्यक्रम को स्वीकार कर लिया 1:2:3:4::a:b:c:dलेकिन अस्वीकार कर दोनों ::2:3:4:a:b:c:dऔर 1:2:3:4:a:b:c::। मेरा मानना ​​है कि यह तीनों बार गलत था।
— कर्नेल
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.