हेक्स अपने स्रोत कोड को डंप करें

Question

जब कोड-गोल्फिंग होती है तो कई बार आपको अपने कोड के हेक्स डंप की आवश्यकता होती है, आमतौर पर क्योंकि आपने अनपेक्षित वर्णों का उपयोग किया है। तो, हेक्स डंप्स ही क्यों एक कार्यक्रम नहीं बनाते हैं?

चुनौती

यह चुनौती है, बिना किसी इनपुट के, निम्न स्वरूपण में अपने स्रोत कोड के हेक्स डंप को आउटपुट करें:

0000: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
0010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
0020: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
0030: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................

या, उदाहरण के लिए, यदि आपका कार्यक्रम था print("SomeString"):rep(123)

0000: 70 72 69 6e 74 28 5c 22 53 6f 6d 65 53 74 72 69  print("SomeStrin
0010: 6e 67 5c 22 29 3a 72 65 70 28 31 32 33 29        g"):rep(123)

विशिष्ट तथ्य

हेक्स डंप तीन भागों की पंक्तियों में विभाजित है, प्रत्येक पंक्ति आपके स्रोत कोड के 16 बाइट्स का प्रतिनिधित्व करती है।

पहला भाग मेमोरी एड्रेस है। यह निर्दिष्ट करता है कि आपके कोड में वर्तमान पंक्ति कहां से शुरू होती है। एक 2 बाइट हेक्साडेसिमल संख्या के रूप में लिखा गया है :, उसके बाद एक स्थान है।

दूसरा, हेक्स डंप ही है। यह आपके सोर्स कोड की 16 बाइट्स है, जो कि हेक्साडेसिमल फॉर्म में लिखी गई है जो कि स्पेस से अलग होती है। यह आपके कोड के एन्कोडिंग का उपयोग करके एक सटीक बाइट प्रतिनिधित्व होना चाहिए।

अंत में, दो अंतरिक्ष अंतराल के बाद, कोड ही है। यह आपके कोड का केवल 16 अक्षर है, जिसमें नॉन प्रिंट करने योग्य वर्ण लिखे गए हैं.

टिप्पणियाँ

• यह है एक Quine हां, तो चुनौती स्टैंडर्ड Quine नियम लागू होते हैं।
• और यह कोड-गोल्फ चुनौती भी है, इसलिए स्टैंडर्ड लोफॉल्स लागू होते हैं।
• जैसा कि दूसरे उदाहरण में दिखाया गया है, ईओएफ के बाद बाइट न लिखें, इसके बजाय व्हॉट्सएप का उपयोग करें।
• ट्रेलिंग व्हाट्सएप ठीक है।
• हेक्स डंप के इनबिल्ट्स, यदि आपके पास इस विशिष्ट प्रारूप में एक है, तो प्रतिबंधित नहीं है, लेकिन इसे फेंक दिया जाता है।
• गैर मुद्रण योग्य वर्ण किसी भी वर्ण को संदर्भित करते हैं, जिसे केवल एक बाइट के रूप में दर्शाया जाता है, एक एकल स्थानित ग्लिफ़ के रूप में प्रतिनिधित्व नहीं किया जा सकता है। UTF-8, इस का अर्थ है 0-31, 128-255। के लिए जेली कोडपेज , के रूप में सभी पात्रों एक भी दूरी ग्लिफ़ के रूप में प्रतिनिधित्व किया जा सकता है, वहाँ कोई गैर मुद्रण योग्य पात्र हैं।

Comments

संबंधित / नकल? codegolf.stackexchange.com/q/11985/47022

— हर्ब वोल्फ

व्यक्तिगत रूप से मुझे ऐसा लगता है कि यह एक लागू क्वीन है जो इसे काफी अलग बनाता है, लेकिन मैं समुदाय के विचारों को देखने के लिए तैयार हूं।

— एटीको

इसलिए रिकॉर्ड के लिए, आप अपना फ़ाइल नाम और xxdइसे नहीं पढ़ सकते हैं ?

— R

निश्चित रूप से, मानक क्वान नियम यह नहीं

— मानते हैं

व्यक्तिगत रूप से, मैं इसे उत्तर तक छोड़ दूंगा। इस वजह से किसी भाषा को छोड़कर मेरी राय में बिल्कुल अनावश्यक है। यदि आप एक निश्चित चौड़ाई पर जोर देते हैं, तो ऐसी चीज़ का उपयोग करें जो अधिकांश भाषाओं के लिए पर्याप्त होनी चाहिए। अधिकांश हेक्सडंप उपयोगिताओं में 7 हेक्स-अंकों का उपयोग होता है।

— डेनिस

Answer 1

वी , 39 बाइट्स

ñi241"qp:%!xxd
Î4x
Íøø / &
f&3i ÿ

इसे ऑनलाइन आज़माएं!

ध्यान दें कि आम तौर पर V लैटिन 1 एन्कोडिंग का उपयोग करता है, जहां यह 36 बाइट्स है (जो कि टीआईओ कहता है) लेकिन यह सबमिशन यूटीएफ -8 का उपयोग कर रहा है जहां यह 39 बाइट्स है।

यह मेरे द्वारा लिखे गए वी-क्वीन टेम्पलेट का सिर्फ एक संशोधन है ।

Comments

क्या 0aआउटपुट के अंत में नई रेखा नहीं हटाई जानी चाहिए?

— क्रिक्टी लिथोस

@kritiilithos आह, मैं इसके बारे में भूल गया था। अंत में केवल एक नई पंक्ति जोड़ना आसान है।

— जेम्स

Answer 2

पर्ल, 81 बाइट्स

#!perl -l
$_=q($%+=print"00$%0: @{[unpack'(H2)*']}  $_"for"\$_=q($_);eval"=~/.{16}/g);eval

एक के रूप में गड़गड़ाहट की गिनती। कोड की लंबाई 16 से अधिक होने से स्वरूपण पर काफी बचत होती है। Ais523 से उधार लेने के लिए खुद को आश्वस्त करने के evalलिए उपयोग करना ।$_

आउटपुट:

0000: 24 5f 3d 71 28 24 25 2b 3d 70 72 69 6e 74 22 30  $_=q($%+=print"0
0010: 30 24 25 30 3a 20 40 7b 5b 75 6e 70 61 63 6b 27  0$%0: @{[unpack'
0020: 28 48 32 29 2a 27 5d 7d 20 20 24 5f 22 66 6f 72  (H2)*']}  $_"for
0030: 22 5c 24 5f 3d 71 28 24 5f 29 3b 65 76 61 6c 22  "\$_=q($_);eval"
0040: 3d 7e 2f 2e 7b 31 36 7d 2f 67 29 3b 65 76 61 6c  =~/.{16}/g);eval

इसे ऑनलाइन आज़माएं!

Answer 3

पर्ल + xxd + कट, 61 बाइट्स

$_=q(open F,"|xxd -g1|cut -c5-";print F"\$_=q($_);eval");eval

इसे ऑनलाइन आज़माएं!

यह पर्ल + में कॉल करने xxdऔर cutहेक्सडंपिंग करने के लिए एक सार्वभौमिक क्वीन कंस्ट्रक्टर है । प्रश्न में कोई भी कार्यक्रम प्रश्न में प्रारूप में एक हेक्सडंप करने के लिए एक अंतर्निहित नहीं है; हालाँकि, xxd -g1बहुत करीब आता है और इसलिए इसका उपयोग करना संभव हैcut आउटपुट को सही आकार में ट्रिम करना ।

सार्वभौमिक क्वीन कंस्ट्रक्टर है $_=q("\$_=q($_);eval");eval, जो मेमोरी में अपने स्वयं के सोर्स कोड की एक प्रति बनाता है, और उस पर मनमाना संचालन करने के लिए संशोधित किया जा सकता है। इस मामले में, मैं का उपयोग करें open "|"और printपाइप के बाहरी प्रोग्राम में इनपुट, xxdजो hexdumping काम के थोक करता है और cutजो आवश्यक प्रारूप में बदल जाता है।

Answer 4

जावास्क्रिप्ट (ईएस 6) 229 219 162 बाइट्स

बहुत सारे बाइट्स बचाने के लिए @ नील का धन्यवाद

ध्यान दें

काफी लोगों को लगता है कि किसी फ़ंक्शन के स्रोत कोड तक पहुंचने का तरीका यह है कि मैं इसे धोखा दे रहा हूं, लेकिन @ डेनिस के अनुसार, यह ठीक है। जैसे, मैं अपना जवाब यहाँ छोड़ दूँगा।

कोड

f=_=>([...c=`f=`+f].map(d=>d.charCodeAt()[t=`toString`](16)).join‌​` `+` `.repeat(46)).match(/.{48}/g).map((s,i)=>`00${i[t](16)}0: `+s+c.substr(i*16,16)).join`\n`

प्रयोग

f()

बस फ़ंक्शन को बिना किसी तर्क के कॉल करें।

उत्पादन

0000: 66 3d 5f 3d 3e 28 5b 2e 2e 2e 63 3d 60 66 3d 60 f=_=>([...c=`f=`
0010: 2b 66 5d 2e 6d 61 70 28 63 3d 3e 63 2e 63 68 61 +f].map(c=>c.cha
0020: 72 43 6f 64 65 41 74 28 29 5b 74 3d 60 74 6f 53 rCodeAt()[t=`toS
0030: 74 72 69 6e 67 60 5d 28 31 36 29 29 2e 6a 6f 69 tring`](16)).joi
0040: 6e 60 20 60 2b 60 20 60 2e 72 65 70 65 61 74 28 n` `+` `.repeat(
0050: 34 36 29 29 2e 6d 61 74 63 68 28 2f 2e 7b 34 38 46)).match(/.{48
0060: 7d 2f 67 29 2e 6d 61 70 28 28 73 2c 69 29 3d 3e }/g).map((s,i)=>
0070: 60 30 30 24 7b 69 5b 74 5d 28 31 36 29 7d 30 3a `00${i[t](16)}0:
0080: 20 60 2b 73 2b 63 2e 73 75 62 73 74 72 28 69 2a  `+s+c.substr(i*
0090: 31 36 2c 31 36 29 29 2e 6a 6f 69 6e 60 5c 6e 60 16,16)).join`\n`                                     

Comments

(यह निश्चित नहीं है कि मानक fine नियमों के तहत 'f =' + f की अनुमति है, लेकिन यदि यह 161 बाइट्स के लिए है तो मैं आपको देता हूं f=_=>([...c=`f=`+f].map(c=>c.charCodeAt().toString(16)).join` `+` `.repeat(46)).match(/.{48}/g).map((s,i)=>`00`+i.toString(16)+`0 `+s+c.substr(i*16,16)).join`\n`।

— नील

चतुर दृष्टिकोण। मैंने कुछ प्रश्न पढ़े, और ऐसा प्रतीत होता है कि लोग आमतौर पर सोचते हैं कि यह धोखा माना जाता है क्योंकि मैं एक सुविधाजनक भाषा सुविधा का दुरुपयोग कर रहा हूं। मैं आपके उत्तर के साथ आपके बेहतर कोड के साथ जोड़ दूंगा।

— ल्यूक

मुझे लगता है कि इसकी अनुमति है, डेनिस ने एक अन्य क्वीन चुनौती पर कहा कि फ़ंक्शन स्रोत निरीक्षण का उपयोग करना ठीक है, और मुझे पता है कि कई "गोल्फ एक क्वीन" उत्तर इसका उपयोग करते हैं।

— पलटें

पहला परिवर्तन .toStringकरने के लिए [t=toString]और दूसरा करने के लिए [t]3 बाइट्स को बचाने के लिए। एक और एक को बचाने के <backtick>\n<backtick>लिए बदलें <backtick><newline><backtick>।

— user2428118

इसे स्ट्रिंग विधि में बदलने के लिए फ़ंक्शन नाम को एक स्ट्रिंग की आवश्यकता होती है, जैसे, यह केवल एक बाइट बचाता है। न्यूलाइन के रूप में, यह aहेक्स डंप में परिणाम देगा , जिसमें 0 पूर्वनिर्मित की जरूरत है, और उस चेक को जोड़ने से केवल बायटेकाउंट बढ़ेगा।

— ल्यूक

Answer 5

रूबी, 128 112 बाइट्स

eval b='7.times{|y|$><<"%04x:"%y*=16;c=("eval b="+(a=39.chr)+b+a)[y,16];c.chars{|x|$><<" %x"%x.ord};puts"  "+c}'

नई लाइन अनुगामी के बिना।

16-बाइट सीमा को संरेखित करने के विचार के लिए धन्यवाद प्राइमो।

उत्पादन

0000: 65 76 61 6c 20 62 3d 27 37 2e 74 69 6d 65 73 7b  eval b='7.times{
0010: 7c 79 7c 24 3e 3c 3c 22 25 30 34 78 3a 22 25 79  |y|$><<"%04x:"%y
0020: 2a 3d 31 36 3b 63 3d 28 22 65 76 61 6c 20 62 3d  *=16;c=("eval b=
0030: 22 2b 28 61 3d 33 39 2e 63 68 72 29 2b 62 2b 61  "+(a=39.chr)+b+a
0040: 29 5b 79 2c 31 36 5d 3b 63 2e 63 68 61 72 73 7b  )[y,16];c.chars{
0050: 7c 78 7c 24 3e 3c 3c 22 20 25 78 22 25 78 2e 6f  |x|$><<" %x"%x.o
0060: 72 64 7d 3b 70 75 74 73 22 20 20 22 2b 63 7d 27  rd};puts"  "+c}'