45

यह मुझे याद दिलाता है जब कुछ साल पहले किसी ने एक धार "हैकर टूल: सभी आईपी पतों की पूरी सूची" अपलोड की थी। यह निश्चित रूप से, ~ 4 बिलियन IPv4 पतों की सिर्फ एक जेनरेट की गई सूची थी, लेकिन हजारों "h4xx0rz" ने इसे डाउनलोड किया। देखो मम्मी, इम्हैकर!

यह तब था, लेकिन आजकल हर कोई IPv6 में बदल गया है । (सही?)

आपका कार्य एक प्रोग्राम लिखना है जो सभी IPv6 पतों को प्रिंट करता है ।

आपको एक पूर्ण कार्यक्रम लिखना चाहिए जो कोई इनपुट नहीं लेता है और IPv6 पते, प्रति पंक्ति, और कोई अन्य आउटपुट प्रिंट करता है। आपके कार्यक्रम में अमान्य सहित सभी 2 ¹²⁸ संभावित पते मुद्रित होने चाहिए । प्रत्येक पते को एक बार बिल्कुल मुद्रित किया जाना चाहिए। आप किसी भी क्रम में पते मुद्रित कर सकते हैं।

प्रत्येक पते को पूर्ण रूप से मुद्रित किया जा सकता है, कॉलोनियों द्वारा अलग किए गए 4 हेक्साडेसिमल अंकों के 8 समूहों के साथ, जैसे

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

आप अपने विवेकानुसार, RFC 5952 से किसी भी मानक संक्षिप्ताक्षर का उपयोग कर सकते हैं :

एक समूह में अग्रणी शून्य को छोड़ा जा सकता है, सिवाय इसके कि 0आगे संक्षिप्त नहीं किया जा सकता है।
:: एक या अधिक सभी-शून्य समूहों के अनुक्रम को संक्षिप्त करने के लिए प्रति पते पर एक बार उपयोग किया जा सकता है।
हेक्साडेसिमल अंक लोअरकेस या अपरकेस का उपयोग कर सकते हैं।

यदि आप RFC 5952 (केवल निचले अक्षरों को कम से कम संभव प्रतिनिधित्व के साथ ::प्रयोग किया जाता है, तो कई स्थानों पर जहाँ इसका उपयोग किया जा सकता है) से प्रतिनिधित्व अनुशंसा प्राप्त करते हैं, तो आपको -20% बोनस मिलता है ।

आउटपुट के आकार के कारण, आपके कार्यक्रम के समाप्त होने की उम्मीद नहीं है, जबकि हम वहां बैठे हैं। आपका कार्यक्रम किसी न किसी बिंदु पर बाहरी साधनों से बाधित हो सकता है ( Ctrl+ C, शक्ति को बाहर खींच रहा है, ...)। आपके प्रोग्राम को एक स्ट्रीम के रूप में आउटपुट का उत्पादन करना होगा, ताकि "उचित" प्रतीक्षा के बाद, उसने कुछ लाइनों का उत्पादन किया हो। मूल रूप से, केवल अंत में इसे मुद्रित करने के लिए स्मृति में एक विशाल स्ट्रिंग का निर्माण करने की अनुमति नहीं है। कोई भी प्रोग्राम जो "मानक" पीसी पर मेमोरी से बाहर चलेगा, वह अयोग्य है। (फिर भी, यदि आपका कार्यक्रम पर्याप्त रूप से लंबे समय तक चलने के लिए छोड़ दिया गया था, तो इसे सभी IPv6 पतों को प्रिंट करना होगा और फिर बाहर निकलना होगा।)

(यदि यह स्थिति वेब दुभाषियों के लिए एक समस्या है जो पूरा होने तक प्रोग्राम को चलाती है और फिर आपको आउटपुट देखने देती है, और आपके पास होस्टेड दुभाषिया नहीं है, तो समस्या के छोटे संस्करण पर अपने प्रोग्राम का परीक्षण करें, और फिर इसे सावधानीपूर्वक समायोजित करें पूर्ण 2 ^{128 पर} ।)

बोनस मिलने पर आपका स्कोर बाइट्स में आपके प्रोग्राम की लंबाई 0.8 से गुणा हो जाता है। यह कोड गोल्फ है, इसलिए सबसे कम स्कोर जीतता है।

code-golf kolmogorov-complexity

— गिल्स 'SO- बुराई होना बंद करो'
स्रोत

22

यह 5.445 * 10¹⁵ yottabytes है। उस सभी डेटा को संग्रहीत करने के लिए, आपको कम से कम 15 पृथ्वी-आकार के डेटासेंटर की आवश्यकता होती है, जिसमें कुछ भी नहीं बल्कि हार्ड ड्राइव को यथासंभव कसकर पैक किया जाता है। यह एक बड़ा धार है .....

— कज़ वोल्फ

7

@ मैं सोच रहा था कि फ़ाइल कितनी छोटी होगी (हालांकि कुछ सामान्य संपीड़न जैसे gzip का उपयोग करके)।

— १२:०४ पर S

35

@ सुरक्षा: जाहिरा तौर पर उत्पादन 25 बाइट्स (संपीडन एल्गोरिथ्म = एक पाइपर दुभाषिया, सम्पीडन एल्गोरिथ्म = पीपीसीजी में पोस्टिंग) के लिए संपीड़ित किया जा सकता है। इस साइट पर दुबकने से, ऐसा लगता है कि पायथ एक सामान्य रूप से संकुचित स्वरूप है।

— बेन वोइगट

3

मेरे अनुभव में, @ गिल्स एक वास्तविक SO हैवीवेट है! खुशी है कि आप एसओ के हमारे छोटे पीपीसीजी कोने में प्रश्न लाते हैं! मेरे लिए नेटवर्किंग से जुड़े सवालों को देखना भी मजेदार है।

— डिजिटल ट्रॉमा

5

यह मुझे याद दिलाता है कि एसओ पर "सभी संभव GUIDs पर प्रश्न" पुनरावृति।

— 19-30 बजे माइकइलियार

5

पायथ, 21 बाइट्स

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

Jइटरेटर चर के रूप में थोड़ी देर के लूप का उपयोग करता है । अधिकतम उपयोग का प्रारंभ करता है 8^chr(' ')। उस प्रारंभिक मूल्य को जोड़कर पैड, हेक्स में परिवर्तित करना, फिर पहले चरित्र को निकालना।

— isaacg
स्रोत

वह कोड ऐसा लगता है जैसे किसी ने उनके कीबोर्ड पर छींक दी, फिर उसे साफ करने की कोशिश की।

— अंधेरा

@ डार्स्की यह आपके लिए गोल्फलैंग्स है: पी

— एस्कलांगिंग फल

50

पायथन 3, 65 बाइट्स · 0.8 = 52.0

from ipaddress import*
n=4**64
while n:n-=1;print(IPv6Address(n))

— एंडर्स कसीर्ग
स्रोत

7

डांग अजगर! यह हमेशा सही तरीके हैं! : डी

— मेयोरमोनी

ipaddressकेवल पायथन 3 है।

@ Hurricane996, हाँ, मैं Python से Python 2 में इसका उपयोग कर रहा था, बिना यह महसूस किए कि यह केवल Python 3 में मानक पुस्तकालय में प्रवेश किया। इसलिए मैंने इसे एक बाइट की कीमत पर Python 3 में बदल दिया है।

— एंडर्स केसोर्ग

@MDXF अजगर नहीं है ++ या - ऑपरेटरों

— Draconis

14

पायथ, 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

पैड ऑपरेटर (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

पायथ, 21 बाइट्स (अमान्य)

jmj\:c.[\032.Hd4^4 64

यह 1 से नहीं चलाया जा सकता है) यह कम से कम 2 ¹³² बाइट्स (2 ⁵² yobibytes) मेमोरी और 2 का उपभोग करेगा ) दुभाषिया इसे पसंद नहीं करता है (2 ¹²⁸ में फिट नहीं होता है ssize_t, इसलिए listउस आकार का नहीं है) । यह लेक्सोग्राफिक क्रम में पतों को प्रिंट करेगा। आप कुछ के लिए अंत में संख्या (ओं) को बदलकर एल्गोरिथ्म की कोशिश कर सकते हैं।

— PurkkaKoodari
स्रोत

1

के बारे में क्या ... " कोई भी प्रोग्राम जो" मानक "पीसी पर मेमोरी से बाहर चला जाएगा अयोग्य है।" ?

— TessellatingHeckler

2

@TessellatingHeckler पहले वाला नहीं होगा, क्योंकि यह चलने-फिरने के लिए है। दूसरा जिसे मैंने स्पष्ट रूप से अमान्य के रूप में चिह्नित किया है।

— पुरकाकूदरी

12

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% बोनस का दावा किया जा सके।

उत्पादन

sed10 मिलियन तक हर मिलियन लाइन आउटपुट का उपयोग करना :

$ ./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()। इससे कोई फर्क नहीं पड़ता - सभी पते अभी भी (अंततः) प्रदर्शित होंगे।

— डिजिटल आघात
स्रोत

11

सीजेएम, 36 27 बाइट्स

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

-9 बाइट्स @ डेनिस की बदौलत (मैं भूल गया कि सीजेएम ने स्ट्रिंग फॉर्मेटिंग की है)। पतों को लोअरकेस और अवरोही प्रिंट करता है।

स्पष्ट कारणों के लिए, जावा दुभाषिया का उपयोग करें, ऑनलाइन नहीं। आप 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

— Sp3000
स्रोत

1

किस तरह की दिलचस्प बात यह है कि ऑनलाइन दुभाषिया, निश्चित रूप से आकार को संभालने में सक्षम नहीं होने के अलावा, परिणाम को गलत भी करता है। यदि आप लूप को हटाते हैं, और केवल पहले मान को प्रिंट करते हैं, तो यह प्रिंट करता है 0000:0000:0000:0000:0000:0000:ffff:ffff। ऐसा लगता है कि स्ट्रिंग स्वरूपण ऑनलाइन अलग तरीके से काम कर सकता है। मैंने पुष्टि की कि यह ऑफ़लाइन संस्करण के साथ ठीक काम करता है।

— रेटो कोराडी

nरूप में ही है oNoमें TIO ।

— 19:06 पर फल

8

पायथन 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

— xsot
स्रोत

1

घूर्णन वास्तव में साफ है! इसके अलावा, लेकिन अराजकता से स्वागत है :)

— Sp3000

3

यदि आप कहते हैं कि सबसे दाहिना स्तंभ बाईं ओर है, तो यह अमान्य IPv6 पतों को छाप रहा है, लेकिन यदि स्तंभ सही स्थानों पर हैं, तो यह है [printing] the addresses in any order। ;)

— TessellatingHeckler 15

7

वेरिलोग, 335

मेरा पहला वेरिलॉग सबमिशन, शायद अधिक गोल्फ का उपयोग कर सकता है, लेकिन मेरे पास अभी ऐसा करने की ऊर्जा नहीं है। 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 बनाने के लिए कुछ बिट-ट्विडलिंग किया जाता है। मैं एक छोटे हैक के साथ अंतिम समूह के बाद कोलन को काटता हूं। Synthesizes और ISE 13.7 lin64 पर xc3s500e-4ft256-4 के लिए काम करता है।

— ζ--
स्रोत

6

सी, 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 बाइट्स (इनमें से कुछ अवधारणाओं के लिए धन्यवाद @ डेनिस)

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

स्पष्टीकरण: एल्गोरिथ्म अपने आप में बहुत सीधा है। मैंने अहस्ताक्षरित int के बजाय लंबे समय का उपयोग किया क्योंकि यह छोटा है। उन्हें फ़ाइल के स्तर पर घोषित करने का मतलब है कि शून्य के साथ सब कुछ पूर्वनिर्मित है। fसमारोह है कि प्रत्येक शब्द के कम 16 बिट पर चल रही है कैरी के साथ एक सरल वेतन वृद्धि है। 129 वें बिट में ले जाने पर लूप समाप्त हो जाता है।

प्रिंटफ के लिए पीछे की ओर इशारा करने का मतलब है कि हम पते को "उचित" क्रम में प्रिंट करते हैं और साथ ही एक नई पंक्ति को प्रिंट करने के लिए चेक कुछ वर्ण छोटा होता है।

यह कुछ गैर-पोर्टेबल निर्माण का उपयोग करता है। इसे C की K & R बोली के रूप में सबसे अच्छा माना जाता है, क्योंकि यह अंतर्निहित int रिटर्न प्रकारों का उपयोग करता है और इसमें stdio.h शामिल नहीं है। और लंबे समय तक मेरे उपयोग को इसके द्वारा सूचित किया गया था - अधिकांश आधुनिक प्रणालियों पर इंट पर्याप्त है क्योंकि यह 32 बिट्स है। यह शायद PDP-11 यूनिक्स पर बिना लाइसेंस के चल सकता है।

हालाँकि, यह छोटा हो सकता है। यदि हम मानते हैं कि हम int का उपयोग कर सकते हैं (या तो 16 बिट्स की तुलना में एक प्रकार के व्यापक के रूप में, या विभिन्न गुणों के साथ बिल्कुल 16 बिट्स का एक प्रकार जो कई प्रणालियों पर सच हो सकता है जैसे कि टूबस पूरक और अंकगणितीय रोलओवर), तो हम छुटकारा पा सकते हैं लंबे समय का उपयोग करने से संबंधित सामान।

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

अजीब तरह से पर्याप्त है, हालांकि, मूल कश्मीर एंड आर संकलक वास्तव में पूर्णांक के बिना घोषणा का समर्थन नहीं किया (यह ठीक संकलित है, लेकिन व्यवहार करता है बाह्य और इसलिए लिंक समय में अपरिभाषित के रूप में चर), इसलिए एक अतिरिक्त तीन बाइट्स घोषणा को बदलने के लिए की जरूरत है int*p,a[9];के लिए कुल 94।

इसके अलावा, अगर यह अनुमान लगाया जाता है कि उत्पादन पूरा करने से पहले बाधित होता है तो एक कठिन बाधा थी, हम पांच बाइट बचाते हुए अंत की जांच को हटा सकते हैं।

बोनस: पूरी तरह से एएनएसआई पोर्टेबल संस्करण, 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एएनएसआई संस्करण में लाइन के बाद नईलाइन को छोड़कर ।

एएनएसआई संस्करण को छोड़कर सभी संस्करण मुख्य के अंत में आते हैं और इसलिए ऑपरेटिंग सिस्टम के लिए एक नकली निकास कोड वापस कर सकते हैं।

— Random832
स्रोत

1

पोर्टेबिलिटी आमतौर पर एक चिंता का विषय नहीं है। यह मेरी मशीन पर काम करता है:a[9];f(int*x){if(++*x>>16)*x=f(x+1);}main(i){for(;!a[8];f(a))for(i=8;i--;)printf(i?"%x:":"%x\n",a[i]);}

— डेनिस

आप स्पष्ट रूप से मुझ पर इससे बेहतर हैं। उनमें से कुछ मैं बहुत आश्चर्यचकित काम करता हूं, लेकिन मुझे वास्तव में i--हालत की जांच के बारे में सोचना चाहिए ।

— रैंडम 832

जब आपने इसका परीक्षण किया, तो क्या आपने इसे कैरी करने तक सभी तरह से चलाया? आपके संस्करण में रोल करने के बाद मेरी मशीन एक यादृच्छिक मूल्य रखती है [0]।

— रैंडम 832

हाँ। मेरी मशीन पर पहले 6,553,601 IP पते सही छपे हैं।

— डेनिस

Ideone इसे पसंद नहीं करता है, लेकिन यह कोडपैड पर काम करता है: लपेटेंa[0] और लपेटेंa[1]

— डेनिस

5

ऑटो इट 3, 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 बार Iterate करें।
$s=StringFormat("%08x%08x%08x%08x",$a,$b,$c,$d): संख्याओं को 32 (4 * 32) की लंबाई के साथ एक हेक्साडेसिमल स्ट्रिंग में परिवर्तित करें।
For $j=0 To 8: स्ट्रिंग के सभी 8 खंडों में Iterate।
ConsoleWrite(StringMid($s,$j*4+1,4)&($j<7?":":"")): स्ट्रिंग से अगले 4 वर्ण निकालें और :अंत में एक कोलन ( ) जोड़ें , यदि हम अंतिम खंड तक नहीं पहुंचे हैं, तो कंसोल में सब कुछ आउटपुट करें
Next: आंतरिक अंत-पाश के लिए
ConsoleWrite(@LF): पंक्ति के अंत में एक पंक्ति-फ़ीड जोड़ें
Next: छोरों के लिए बाहरी समाप्त करें

अपेक्षित आउटपुट आकार: (एक पंक्ति (39 बाइट्स) + लाइन-फीड) (= 40 बाइट्स) * 2 ^ 128 = 1.361 * 10 ^ 16 YB (yottabytes)

— GiantTree
स्रोत

क्या आपका मतलब नहीं है 4^64 - 1?

— एंडर्स केसरग

@AndersKaseorg जाहिरा तौर पर मुझे 2 ^ 32-1 तक 4 लूप का उपयोग करने की आवश्यकता है, क्योंकि AutoIt 4 ^ 64 जैसे बड़े मूल्यों को पार्स कर सकता है , लेकिन उन्हें लूप में उपयोग करने के लिए स्टोर नहीं कर सकता, क्योंकि पूर्णांक केवल 2 ^ 32 तक जाते हैं -1 में ऑटो इट।

— GiantTree

5

दालचीनी गोंद, 16 बाइट्स

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

इसे ऑनलाइन आज़माएं। (TIO सीमा उत्पादन)

व्याख्या

gमोड में डालता है दालचीनी गम मोड उत्पन्न । इस स्ट्रिंग के बाकी हिस्से regex:

[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}वास्तव में ऊपर रेगेक्स की तुलना में लंबे स्ट्रिंग को संकुचित करता है।

— एक स्पैगेटो
स्रोत

4

कमोडोर बेसिक 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

बस इस काम को कमोडोर 64 पर करना एक चुनौती थी, क्योंकि मेमोरी, स्क्रीन साइज़, डेटा साइज़ और अन्य सीमाएँ। मैंने संक्षिप्त प्रतिनिधित्व को लागू करने पर विचार किया, लेकिन अन्य सीमाएं (जैसे कि लूप सूचकांकों के रूप में सरणी तत्वों का उपयोग करने के लिए अवांछनीय अक्षमता) का मतलब था कि यह अनुमानित 1000 बाइट्स द्वारा कार्यक्रम की लंबाई बढ़ाएगा।

लाइन 7 का कार्यान्वयन है HEX$(), जिसमें कमोडोर बेसिक 2.0 की कमी है। मैं इसके DEF FNलिए उपयोग नहीं कर सकता क्योंकि वे केवल संख्या वापस कर सकते हैं, तार नहीं। लाइन 6 एक सबरूटीन है जो इसे चार अंकों के समूह पर लागू करता है, जो फ़ंक्शन स्ट्रिंग्स को वापस कर सकता है तो काफी कम होता।

लाइन्स 2 और 5 आठ नेस्टेड लूप हैं, जिन्हें "लूप्स और एक सशर्त गोटो" के लिए सात "के रूप में लागू किया गया है क्योंकि" लूप्स के लिए आठ ", जब एड्रेस प्रिंट करने के लिए दो" गॉब्स "के साथ संयुक्त, C64 के छोटे स्टैक को ओवरफ्लो करेगा।

1.3 * 10 ^ 31 वर्ष के अनुमानित रनटाइम के लिए C64 प्रति सेकंड लगभग 1.2 पते प्रिंट कर सकता है।

— निशान
स्रोत

4

पॉवरशेल (v4), 193 166 162 145 103 बाइट्स

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 बाइट्स पर बोनस के साथ पिछला संस्करण

टिम्मीड और टॉमकैंडी की मदद से , जो बताते हैं कि 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 (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

}

— TessellatingHeckler
स्रोत

बिना बोनस के 95। [बिगिन्ट] से मेरा परिचय कराने के लिए आप दोनों को धन्यवाद, यह बहुत आसान है (उन चीजों के लिए जो मुझे पहली बार पॉश में नहीं करनी चाहिए ...)for($g=[bigint]::pow(2,128);$g;$g-=1){'{0:X32}'-f$g-replace'(?=(.{4})+$)',':'-replace'^0+:',''}

— टॉमकिंडी

क्षमा करेंfor($g=[bigint]::pow(2,120);$g;$g-=1){'{0:X32}'-f$g-replace'(?=(.{4})+$)',':'-replace'^0*:',''}

— टॉमकुंडी

for($g=[bigint]::pow(2,128);$g-gt0;$g-=1){'{0:X32}'-f$g-replace'(?=(.{4})+$)',':'-replace'^\d*:',''}हां, पहला पता गलत है लेकिन इसे अंत में दोहराया नहीं गया है। यह भी ध्यान रखें कि while($i)आप में शून्य पर नहीं [boolean][bigint]0

— रुकेंगे

@tomkandy ओह वाह, मैंने केवल अंत में $ i = 5 को इंट के रूप में सेट करके परीक्षण किया होगा। (कॉम्प्लेक्स 0 या तो $ झूठा नहीं है ... और न ही खाली स्ट्रिंग है। मुझे "यह पायथन नहीं है" पर अधिक ध्यान देना चाहिए)। धन्यवाद! (और आप की इस लिपि को 0:अब और आगे नहीं

— बढ़ाया जा

@TessellatingHeckler बोनस के लिए नहीं जाना दुख की बात है 13 बाइट्स छोटी - $i=[bigint]::Pow(4,64);while($i-gt0){('{0:X32}'-f($i-=1)-replace'0(?=.{32})'-replace'.{4}(?!$)','$0:')}103 पर ...

— AdmBorkBork

3

ऑटो इट 3, 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

— rav_kr
स्रोत

मुझे पता है कि लेकिन मैं यहाँ नया हूँ :(

— rav_kr

बस आपको पता है। धन्यवाद।

— mbomb007

क्या आपका मतलब नहीं है 4^64 - 1?

— एंडर्स केसरग

2

पायथन 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 जोड़ देता है। जोड़ा बोनस है कि आप इसे किसी भी मूल्य पर शुरू कर सकते हैं यदि आप इसे देते हैं, लेकिन किसी इनपुट की आवश्यकता नहीं है।

— स्थिति
स्रोत

यदि आपका जवाब एक फ़ंक्शन है, तो आपको इसे कॉल करने की आवश्यकता नहीं है :)

— बीटा डेके

@BetaDecay तब मेरी गलतफहमी थी। फिक्स्ड! धन्यवाद।

— स्थिति

2

हास्केल 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यह अब स्मृति को लीक नहीं करता है, लेकिन किसी भी अधिक गोल्फ को महसूस नहीं करता है।

— Franky
स्रोत

आप इसे कैसे संकलित करते हैं ताकि यह स्मृति से बाहर न चले? मेरे ghc v7.10.2 और std के साथ। संकलन विकल्प यह स्मृति को लीक करता है।

— nimi

2

सीबीएम बेसिक 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

मार्क का जवाब कमोडोर 64 के बेसिक 2.0 के लिए है, जिसमें हेक्साडेसिमल में मुद्रण संख्या के लिए अंतर्निहित कमांड का अभाव है। हालांकि, HEX$()बेसिक 7.0 में फ़ंक्शन के लिए धन्यवाद , कमोडोर 128 संस्करण बहुत छोटा है। यह एक भी तार्किक रेखा पर फिट नहीं होता है (जो C128 पर 160 वर्णों तक सीमित है) लेकिन फिर भी इसे प्रत्यक्ष मोड में दो अलग-अलग रेखाओं के रूप में दर्ज किया जा सकता है।

— Psychonaut
स्रोत

ऐसा लगता है कि आप अपने आधे छोरों को याद कर रहे हैं। IPv6 का पता 128 बिट्स है, 64 बिट्स का नहीं।

— मार्क

@ मर्क: इसे इंगित करने के लिए धन्यवाद! मैंने समस्या ठीक कर दी है।

— साइकोनॉट

2

रूबी 75

x=->s,n{n>0?65536.times{|m|x.(s+?:*(8<=>n)+m.to_s(16),n-1)}: p(s)};x.('',8)

यह एक पुनरावर्ती समाधान है जो प्रत्येक उपसर्ग लेता है और हर संभव प्रत्यय पाता है। रिकर्सिवली।

— MegaTom
स्रोत

: Lambdas के साथ छोटे समारोह परिभाषाएं प्राप्त करेंx=->s,n{...};x['',8]

— दरवाज़े

0

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

— wolfhammer
स्रोत

सभी IPv6 पते प्रिंट करें

पायथ, 21 बाइट्स

पायथन 3, 65 बाइट्स · 0.8 = 52.0

पायथ, 27 25 24 बाइट्स

व्याख्या

पायथ, 21 बाइट्स (अमान्य)

C (GCC एक्सटेंशन के साथ), 76 बाइट्स * 0.8 = 60.8

उत्पादन

सीजेएम, 36 27 बाइट्स

व्याख्या

पायथन 2.7, 67 बाइट्स

वेरिलोग, 335

सी, 91-126 बाइट्स

ऑटो इट 3, 142 231 बाइट्स

व्याख्या

दालचीनी गोंद, 16 बाइट्स

व्याख्या

कमोडोर बेसिक 2.0, 339 बाइट्स

पॉवरशेल (v4), 193 166 162 145 103 बाइट्स

ऑटो इट 3, 137 बाइट्स

पायथन 2, 95 बाइट्स

हास्केल 111

सीबीएम बेसिक v7.0 (166 अक्षर)

रूबी 75

Tcl 341 318 301