चुनौती

मैंने हाल ही में 8-बिट कंप्यूटर में प्रवेश किया है और उनके और अन्य लोगों के कामकाज पर मोहित हैं; इस प्रकार इस कोड गोल्फ का उद्देश्य, Apple I के लिए स्टीव वोज्नियाक द्वारा डिज़ाइन किए गए Woz मॉनिटर के एक हिस्से को दोहराने के लिए है।

आप दो बाइट्स की चौड़ाई के साथ 22 हेक्साडेसिमल मानों की एक सरणी स्टोर करने के लिए हैं, (न्यूनतम मूल्य $ 10 , अधिकतम मूल्य $ FF ), और फिर इनपुट के n -ount में लें। (आम तौर पर दो; ब्रेनफक जैसी भाषाओं में एक कठिन समय हो सकता है)।
इनपुट से संदर्भित होगा कि कहां से प्रिंटिंग शुरू करने के लिए सरणी में, और कहां से रोकना है; परिभाषित व्यवहार के साथ एक इनपुट में उनका शुरुआती मूल्य कम या समाप्ति मूल्य के बराबर होगा। आपका कार्यक्रम तब प्रत्येक हेक्साडेसिमल मान को मुद्रित करने में सक्षम होना चाहिए, और इसमें हेक्साडेसिमल शामिल हैं।

इसका एक उदाहरण:

Array
00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15

Values
FF F4 B6 D7 40 00 00 A4 F0 00 FF 0D 9C 21 65 C4 02 28 90 E7 D6 A5

input first num:
04
input second num:
14
40 00 00 A4 F0 00 FF 0D 9C 21 65 C4 02 28 90 E7 D6

अब इस अभ्यास का दिलचस्प हिस्सा यह है कि आप उपयोगकर्ताओं के इनपुट की सीमा को जांचने के लिए जो चाहें उपयोग कर सकते हैं। व्यक्ति इनपुट helloऔर आपके कार्यक्रम में अपरिभाषित व्यवहार है? यह बिना सूचना के चलता है? वे दोनों वैध हैं।

केवल नियम हैं:

1. शुरू होने से पहले आपको अपने कार्यक्रम के हिस्से के रूप में 22 हेक्साडेसिमल मूल्यों को शामिल करना चाहिए, (इनपुट के लिए उपयोगकर्ता से नहीं पूछ सकते)।
2. हेक्साडेसिमल मानों के आउटपुट को सटीक प्रारूप का पालन करना चाहिए: 00 FF 00 FF 00ट्रेलिंग स्पेस, टैब या लाइनें ठीक हैं। वर्ण नहीं हैं।
3. प्रोग्राम को संदेश के साथ इनपुट के लिए पूछना नहीं पड़ता है। यदि आप चाहें तो "संदेश" खाली छोड़ दें। उपयोगकर्ता को हालांकि हेक्स-सीमा इनपुट करना होगा।
4. जैसा कि 22 हेक्साडेसिमल के मूल्यों के साथ तय करने के लिए हैं, आपको एक प्रोग्राम बनाना चाहिए जो वास्तव में भंडारण से मूल्यों को प्राप्त करता है, बस मूल्यों को प्रिंट करके प्रोग्राम की नकल करने का विरोध करता है। (जैसे कि $ 00 की सूची )।
5। इनपुट की एन-राशि , दो बाइट-चौड़ाई के एक हेक्साडेसिमल को पहचानने के लिए आपकी पसंद की भाषा के लिए आवश्यक इनपुट की मात्रा को संदर्भित करता है। जैसे। (ब्रेनफुक को प्रति हेक्स दो इनपुट की आवश्यकता होगी, जिससे यह दो के लिए चार हो जाएगा)।

यदि आपको स्पष्टीकरण की आवश्यकता है तो बेझिझक टिप्पणी करें।

यह कोड गोल्फ है, इसलिए बाइट्स की संख्या में सबसे कम जवाब विजेता है।

लीडरबोर्ड

यहाँ एक लीडरबोर्ड स्निपेट शिष्टाचार पैदा कर रहा है मार्टिन एंडर के ।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई दे रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

कोड स्निपेट दिखाएं

function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/95080/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){$.ajax({url:answersUrl(page++),method:"get",dataType:"jsonp",crossDomain:true,success:function(e){answers.push.apply(answers,e.items);if(e.has_more)getAnswers();else process()}})}function shouldHaveHeading(e){var t=false;var n=e.body_markdown.split("\n");try{t|=/^#/.test(e.body_markdown);t|=["-","="].indexOf(n[1][0])>-1;t&=LANGUAGE_REG.test(e.body_markdown)}catch(r){}return t}function shouldHaveScore(e){var t=false;try{t|=SIZE_REG.test(e.body_markdown.split("\n")[0])}catch(n){}return t}function getAuthorName(e){return e.owner.display_name}function process(){answers=answers.filter(shouldHaveScore).filter(shouldHaveHeading);answers.sort(function(e,t){var n=+(e.body_markdown.split("\n")[0].match(SIZE_REG)||[Infinity])[0],r=+(t.body_markdown.split("\n")[0].match(SIZE_REG)||[Infinity])[0];return n-r});var e={};var t=0,c=0,p=-1;answers.forEach(function(n){var r=n.body_markdown.split("\n")[0];var i=$("#answer-template").html();var s=r.match(NUMBER_REG)[0];var o=(r.match(SIZE_REG)||[0])[0];var u=r.match(LANGUAGE_REG)[1];var a=getAuthorName(n);t++;c=p==o?c:t;i=i.replace("{{PLACE}}",c+".").replace("{{NAME}}",a).replace("{{LANGUAGE}}",u).replace("{{SIZE}}",o).replace("{{LINK}}",n.share_link);i=$(i);p=o;$("#answers").append(i);e[u]=e[u]||{lang:u,user:a,size:o,link:n.share_link}});var n=[];for(var r in e)if(e.hasOwnProperty(r))n.push(e[r]);n.sort(function(e,t){if(e.lang>t.lang)return 1;if(e.lang<t.lang)return-1;return 0});for(var i=0;i<n.length;++i){var s=$("#language-template").html();var r=n[i];s=s.replace("{{LANGUAGE}}",r.lang).replace("{{NAME}}",r.user).replace("{{SIZE}}",r.size).replace("{{LINK}}",r.link);s=$(s);$("#languages").append(s)}}var QUESTION_ID=49042;var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var answers=[],page=1;getAnswers();var SIZE_REG=/\d+(?=[^\d&]*(?:&lt;(?:s&gt;[^&]*&lt;\/s&gt;|[^&]+&gt;)[^\d&]*)*$)/;var NUMBER_REG=/\d+/;var LANGUAGE_REG=/^#*\s*([^,]+)/

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src=https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js></script><link rel=stylesheet type=text/css href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id=answer-list><h2>Leaderboard</h2><table class=answer-list><thead><tr><td></td><td>Author<td>Language<td>Size<tbody id=answers></table></div><div id=language-list><h2>Winners by Language</h2><table class=language-list><thead><tr><td>Language<td>User<td>Score<tbody id=languages></table></div><table style=display:none><tbody id=answer-template><tr><td>{{PLACE}}</td><td>{{NAME}}<td>{{LANGUAGE}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table><table style=display:none><tbody id=language-template><tr><td>{{LANGUAGE}}<td>{{NAME}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table>

Expand snippet

code-golf array-manipulation hexadecimal

— फिन रेमेंट
स्रोत

क्या हम उपयोगकर्ता से दो इनपुट या एन के लिए पूछ रहे हैं? क्या हम चुनते हैं कि 22 हेक्स मान क्या हैं?

— xnor

हाँ, 22 मान तय करने वाले हैं। इनपुट मान, वे किसी भी राशि हो सकते हैं। मैंने कहा nक्योंकि ब्रेनफक 2 कैरेक्टर स्ट्रिंग में नहीं ले जा सकता है, आपको पहले बाइट को इनपुट करना होगा, फिर दूसरे को पहले वैल्यू के लिए, और फिर दूसरे वैल्यू के लिए फिर से करना होगा, कुल में 4 इनपुट। हालाँकि वे आपके जैसे कई हो सकते हैं।

— फिन रेमेंट

हालांकि मानों के साथ, आप बस उन सभी को 00 के रूप में नहीं कर सकते हैं, और एक प्रोग्राम की नकल करते हैं जो कुछ ऐसा होता है जो वास्तव में सरणियों को पढ़ता है। प्रश्न का अद्यतन करना।

— फिन रेमेंट

यदि इनपुट 2 इनपुट 1 से कम है तो क्या इसे उल्टा लपेटना या पढ़ना चाहिए?

— जोनाथन एलन

@JonathanAllan यह पूरी तरह से आप पर निर्भर है। बस याद रखें, यह सुनिश्चित करना कि इनपुट सही हैं, आपके कोड को बड़ा बना सकते हैं। जैसा कि नियमों के ठीक ऊपर लिखा गया है, आप इनपुट के किसी भी रूप (आप तक) को अनुमति दे सकते हैं, यदि आप चाहें तो अपरिभाषित व्यवहार या त्रुटियों के लिए अग्रणी हैं।

— फिन रेमेंट

4

जेली , 24 21 बाइट्स

w@€ØHḅ⁴
ɠÇµɠÇr@b⁴ịØHK

चुना हुआ मान: [00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 1F 10 11 12 13 14 15]

TryItOnline

यदि दूसरा इनपुट पहले से कम है तो यह उलट क्रम को आउटपुट करता है।
सीमा से बाहर व्यवहार अपरिभाषित है (उदाहरण के लिए "फू", "14" 38 मान लौटाता है, जिनमें से अधिकांश सरणी में भी नहीं हैं और जिनमें से कई की लंबाई 2 नहीं है)

कैसे?

w@€ØHḅ⁴ - Link 1, parse a string as a 1-based hex value e.g. "14"
w@€      - first index (1-based) of each character in
   ØH    - hex digits: "0123456789ABCDEF"                   [2,5]
     ḅ⁴ - convert from base 16                                 37

ɠÇµɠÇr@b⁴ịØHK - Main link
ɠ  ɠ          - read a line from stdin               e.g. "04"  "14"
 Ç  Ç         - call the last link (1) as a monad          21    37
  µ           - monadic chain separation
     r@       - inclusive range, with reversed arguments  [   21,   22,...,   36,   37] 
       b⁴     - convert to base 16                        [[1,5],[1,6],...,[2,4],[2,5]]
         ị    - index into
          ØH  - hex digits: "0123456789ABCDEF"            [ "04", "05",..., "13", "14"]
            K - join with spaces

— जोनाथन एलन
स्रोत

आह, क्षमा करें। आप वास्तव में सही थे। अच्छी तरह से किया है, और लीडरबोर्ड की स्थिति # 1 है। :)

— फिन रेमेंट

1

हां, मैंने बस एक ऑफसेट मान (अब 1F) को स्थानांतरित किया और बदल दिया , जिसका अर्थ है कि मुझे हेक्स इनपुट्स की "सही ढंग से" व्याख्या करने की आवश्यकता नहीं है या मुझे वापस बदलने के लिए दो हेक्स अंक देने के लिए 16 जोड़ें।

— जोनाथन एलन

4

जावास्क्रिप्ट (ईएस 6), 118 115 112 102 82 81 बाइट्स

बच निकले 1 बाइट्स ETHproductions की बदौलत

चुना हुआ मान:

00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15
-----------------------------------------------------------------
10 10 11 14 10 10 15 15 11 14 10 10 15 15 11 14 10 10 15 15 10 11

निचले बाउंड के लिए संकेत, फिर ऊपरी बाउंड के लिए (जैसे 0x04/0x0f ) के लिए।
एक अमान्य निचली सीमा के रूप में व्याख्या की जाएगी 0x00 न्यूनतम मूल्य के ।
एक अमान्य ऊपरी सीमा के रूप में व्याख्या की जाएगी 0x15 (अधिकतम मूल्य)।
यदि निचला बाउंड ऊपरी बाउंड से अधिक है तो आउटपुट कुछ भी नहीं करता है।

alert((1/7+'789').replace(/./g,(v,i)=>i<a|i>b?'':(v|10)+' ',p=prompt,b=p(a=p())))

स्निपेट का विस्तार करें

पिछला संस्करण (97 बाइट्स)

'सत्य' षोडश आधारी मूल्यों की छद्म यादृच्छिक सूची बनाना:

alert((1/7+'789').replace(/./g,(v,i)=>i<a|i>b?'':(v*7|16).toString(16)+' ',p=prompt,a=p(),b=p()))

अनुक्रम:

10 10 17 1c 1e 38 33 31 17 1c 1e 38 33 31 17 1c 1e 38 33 31 38 3f

— Arnauld
स्रोत

"संदेश": "बिना पढ़ा हुआ वाक्य रचना: अमान्य विनाशकारी असाइनमेंट लक्ष्य"

— फिन रेमेंट

@frayment - यह क्रोम है, है ना? यह अजीब है क्योंकि यह [a,b]=prompt().split(' ')कमांड लाइन में शिकायत नहीं करता है । वैसे भी, मेरे अद्यतन जवाब को ठीक करना चाहिए।

— अरनौलड

बहुत बढ़िया! अब काम करता है। यह अजीब है कि क्रोम यह करता है। मैंने इसे आपके जेएस परीक्षक पर और मेरे डेवलपर कंसोल में परीक्षण किया। वही त्रुटि। लीडरबोर्ड में आपका स्वागत है।

— फिन रेमेंट

आप कुछ बाइट्स को 0x04

— Hedi

1

यार, अपने वैकल्पिक के साथ कुछ भी गलत नहीं है, यह यहाँ ठीक काम करता है और नियमों के भीतर है। अपनी पोस्ट अपडेट करें! :)

— फिन रेमेंट

3

जावास्क्रिप्ट (ईएस 6), 107 152 137 बाइट्स

p=prompt,f=(a=+p(),b=+p(),[x,y,...s]='FFF4B6D7402011A4F0D0FF3D9C2165C4A22890E7D6A5')=>a?f(a-1,b-1,s):x+y+' '+(b?f(a,b-1,s):'');alert(f())

कोड स्निपेट दिखाएं

var
   p=prompt,f=(a=+p(),b=+p(),[x,y,...s]='FFF4B6D7402011A4F0D0FF3D9C2165C4A22890E7D6A5')=>a?f(a-1,b-1,s):x+y+' '+(b?f(a,b-1,s):'');alert(f())
;

//input 0x04 then 0x14 will print 40 to D6
//input 0x00 then 0x00 will print FF
//input 0x13 then 0x17 will print E7 D6 A5 NaN NaN

स्निपेट का विस्तार करें

चुना हुआ मान:

FF F4 B6 D7 40 20 11 A4 F0 D0 FF 3D 9C 21 65 C4 A2 28 90 E7 D6 A5

इनपुट:

इनपुट प्रारूप है 0x14
यदि कोई इनपुट ऋणात्मक है या 1 इनपुट 2 से अधिक है: InternalError: too much recursion
NaNसीमा से बाहर के लिए प्रिंट करेंगे ।

पिछला समाधान:
152 बाइट्स:

i=parseInt,p=prompt,f=(a=i(p()),b=i(p()),[x,y,...s]='FFF4B6D7402011A4F0D0FF3D9C2165C4A22890E7D6A5')=>a?f(a-1,b-1,s):x+y+' '+(b?f(a,b-1,s):'');alert(f())

107 बाइट्स, अमान्य समाधान (गुम इनपुट):

f=(a,b,[x,y,...s]='FFF4B6D7402011A4F0D0FF3D9C2165C4A22890E7D6A5')=>a?f(a-1,b-1,s):x+y+' '+(b?f(a,b-1,s):'')

— Hedi
स्रोत

1

बंद करे! लेकिन आपको इनपुट के लिए उपयोगकर्ता से पूछने में सक्षम होने की आवश्यकता है। मुझे पसंद है कि आपने console.log(...)हालांकि क्या किया । ;)

— फिन रेमेंट

@ विश्वासघात var और अंतिम ;उत्तर का हिस्सा नहीं हैं। यह सिर्फ स्निपेट के लिए है, इसलिए मैंने लाइनब्रेक जोड़ा है। मैं उत्तर संपादित करूँगा।

— हेदी

मेरी ख़राब @ हेदी, उस बारे में खेद है।

— फिन रेमेंट

2

पायथन, 88 87 86 बाइट्स

1 बाइट बचाने के लिए @JonathanAllan के लिए धन्यवाद
1 बाइट @JonathanAllan को फिर से सहेजें

कोड का आधार भी बदल दिया, अब बहुत अच्छा है।

a,b=[int(x,16)for x in raw_input().split()];l=[0]*22
while a<=b:print"%02x"%l[a],;a+=1

चुना हुआ मूल्य: 00हर चीज के लिए।

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

यह पायथन 2.x और 3.x दोनों पर काम करना चाहिए; कृपया मुझे सही करें अगर मैं गलत हूं, क्योंकि मेरे पास दोनों व्याख्याकारों तक पहुंच नहीं है, क्योंकि मेरी प्रणाली उन दोनों का समर्थन नहीं करती है।

— फिन रेमेंट
स्रोत

2

सी ++, 98 95 93 बाइट्स

#include <iostream>
int _[22],a,b;int main(){for(std::cin>>a>>b;b/a++;)printf("%02x ",_[a]);}

मेरे चुने हुए मान सभी 0 हैं

— फतिह बाकिर
स्रोत

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! यह एक अच्छी तरह से जवाब दिया है, लेकिन मुझे नहीं लगता कि यह चुनौती की आवश्यकताओं को पूरा करता है। क्या आप अपने 22 चुने हुए हेक्साडेसिमल मूल्यों को ध्यान में रखते हैं?

— ETHproductions

लगभग वहाँ! एकमात्र समस्या यह है, जब मैंने मूल्यों में प्रवेश किया 04और 06, मुझे केवल दो मूल्य वापस मिले। मुझे संदेह है कि ये मूल्य 05और 06मूल्य हैं। आपको इनपुट किए गए मानों के बीच और समस्‍त मान प्रदान करने होंगे ।

— फिन रेमेंट ऑक्ट

1

@ विश्वास, ओह यह सही है, इसे ठीक किया!

— फतह बकीर

1

पर्ल, 79 45 41 बाइट्स

"न्यूनतम मूल्य $ 10" - उदाहरण में न्यूनतम $ 00 है- यह एक टाइपो है?

यहाँ 41 बाइट्स में एक उबाऊ पर्ल उत्तर है (46 था और फिर मैं रिक्त स्थान देखता रहा, मैं मुग्ध हो सकता था)। दो लाइनों में इनपुट लेता है।

printf'%02X ',$_ for(4..26)[hex<>..hex<>]

डेटा एक सूची है 04..1A

इससे पहले कि मैं पैक और अनपैक के साथ बहुत चालाक हो रहा था। इसके इनपुट बाइट्स को एक बार में एक साथ स्मूच किया जाता है, उदाहरण के लिए "020E 'दूसरी -14 वीं प्रविष्टियों को प्रिंट करेगा

printf'%02X ',$_ for sub{(4..26)[shift..shift]}->(unpack'CC',pack'H4',<>)

सभी 0 का उपयोग करके इसे और अधिक गोल्फिंग करने की कोशिश कर सकते हैं substr, और printf'%*vX'... मेरे जवाब को लंबा बना रहा है। 48 वर्ण (ascii '7 की एक स्ट्रिंग का उपयोग करते हुए, डेटा के रूप में हेक्स 37)

printf'%*vX',' ',substr 7x22,$s=hex<>,1+hex<>-$s

— Yary
स्रोत

1

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

{r:~Gb}2*37m!s2/\)<>S*

चुना हुआ मान:

00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15
-----------------------------------------------------------------
13 76 37 53 09 12 26 34 50 46 31 59 79 58 15 80 90 24 00 00 00 00

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

— Neorej
स्रोत

1

स्काला, 45 बाइट्स

(_:Int)to(_:Int)map(x=>f"$x%02X")mkString " "

Ungolfed:

(a:Int,b:Int)=>a.to(b).map(x=>f"$x%02X").mkString(" ")

मूल्यों के रूप में उपयोग करता 00है FF, लेकिन 2147483647 तक काम करता है।

— corvus_192
स्रोत

error: ')' expected but string literal found.ata.to(b).map(

— फिन रेमिशन

पता नहीं अगर यह सिर्फ मुझे या क्या है। : / मुझे इसे चलाने का क्या प्रयास करना चाहिए?

— फिन रेमेंट ऑक्ट

@ विश्वास है कि शायद स्ट्रिंग प्रक्षेप के कारण है, जो स्काला 2.10.0 में पेश किया गया था

— corvus_192

तो आपने इसे किस संस्करण में बनाया है? 2.9?

— फिन रेमेंट

@frayment मैंने

— corvus_192

1

सी, 176 175 161 बाइट्स

1 बाइट बचाने के लिए धन्यवाद @JonathanAllan
बड़े पैमाने पर मदद के लिए धन्यवाद @Downvoter मुझे 14 बाइट बचाने के लिए !

int main(){int a[44]={0};char s[2];scanf("%s",s);int b=(int)strtol(s,0,16);scanf("%s",s);int c=(int)strtol(s,0,16);while(b<=c){printf("%d%d ",a[b],a[b+1]);b++;}}

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

चुना हुआ मूल्य: 00हर चीज के लिए।

गैर-गोल्फ जवाब:

int main() {
    int a[44] = {0};
    char s[2];
    scanf("%s", s);
    int b = (int) strtol(s, 0, 16);
    scanf("%s", s);
    int c = (int) strtol(s, 0, 16);
    while (b <= c) {
        printf("%d%d ", a[b], a[b+1]);
        b++;
    }
}

इसके लिए ट्रिक, दो इनपुट्स में ले रही है और उन्हें हेक्साडेसिमल स्ट्रिंग्स में बदलने का प्रयास कर रही है और फिर पूर्णांकों को कास्ट करती है। चूंकि कोई त्रुटि-जाँच या कुछ भी नहीं है, अपरिभाषित व्यवहार केवल त्रुटियों को फेंक रहा है और कार्यक्रम को तोड़ रहा है। उपयोगकर्ता को दो इनपुट दर्ज करने की आवश्यकता होती है, हालांकि मेरा एक्लिप्स सीडीटी संकलक मुझे उन दोनों को एक ही लाइन पर इनपुट करने देता है जिनके बीच एक स्थान है।

उन्हें सही क्रम में होना चाहिए, क्योंकि छोटे मूल्य से पहले बड़े मूल्य का अनुरोध करने से while-loop बिल्कुल भी नहीं चलेगा ।

बात वहाँ भी कोई बफ़र-अतिप्रवाह संरक्षण, तो मैं बस इस तरह के $ 0 से $ FFFF करने के लिए एक सीमा के रूप में कुछ बेतुका अनुरोध कर सकते हैं, है, और मैं के लिए स्मृति के आवंटन की शुरुआत से मेरा कंप्यूटर स्मृति में सब कुछ मिल जाएगा a[44]सरणी , सभी 65536 मूल्यों के लिए बाद में।

— फिन रेमेंट
स्रोत

इनपुट प्रारूप में एक भी व्हाट्सएप चरित्र इनपुट स्ट्रीम में किसी भी प्रकार के व्हाट्सएप से मेल खाता है, हालांकि अधिकांश स्कैनफ प्रारूप वैसे भी व्हाट्सएप को छोड़ते हैं, जिनमें से बोलता है, क्यों नहीं बीच के आदमी को काटकर %xसीधे उपयोग करें?

— नील

सामान के char s[2]बजाय उपयोग क्यों नहीं malloc? mallocवैसे भी C में कास्टिंग का रिटर्न वैल्यू आवश्यक नहीं है।

— Cadaniluk

@Neil यदि आपके printf("%d%d ", ...)पार्ट के बारे में बात की जा रही है , तो फॉर्मेटिंग की जगह %xकेवल 0'एस' के बजाय रिटर्न देता है 00, और इसे खाली नहीं करता है।

— फिन रेमेंट ऑक्ट

@Downvoter थैंक्यू बहुत! मैंने ऐसा नहीं सोचा था। अब एडिटिंग का जवाब।

— फिन रेमेंट

नहीं, मैं अभी भी के बारे में बात कर रहा हूँ scanf।

— नील

1

GNU sed, 209 + 1 (r फ्लैग) = 210 बाइट्स

1{h
s:.*:,00 FF,01 F4,02 B6,03 D7,04 40,05 00,06 00,07 A4,08 F0,09 00,0A FF,0B 0D,0C 9C,0D 21,0E 65,0F C4,10 02,11 28,12 90,13 E7,14 D6,15 A5:
H;d}
G;s:\n(.*)\n.*(,\1.*):\n\2:
s:(.*)\n(.*,\1 ..).*:\2:
s:,..::g

इसे ऑनलाइन आज़माएं! एक प्रमुख स्थान आउटपुट में मौजूद है, मुझे आशा है कि इसकी अनुमति है।

उदाहरण चलाएँ:

me@LCARS:/PPCG$ echo -e "06\n0F" | sed -rf table_lookup.sed
 00 A4 F0 00 FF 0D 9C 21 65 C4
me@LCARS:/PPCG$ echo -e "13\n13" | sed -rf table_lookup.sed
 E7

स्पष्टीकरण: संग्रहीत 22 हेक्साडेसिमल मान ओपी के उदाहरण से समान हैं

value | FF F4 B6 D7 40 00 00 A4 F0 00 FF 0D 9C 21 65 C4 02 28 90 E7 D6 A5
-------------------------------------------------------------------------
index | 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15

स्टार्ट और एंड इंडेक्स को अलग-अलग लाइनों पर पढ़ा जाता है। आउटपुट उस इंडेक्स रेंज (समावेशी) में तालिका मानों के साथ एक एकल पंक्ति है। अपरिभाषित इनपुट अमान्य आउटपुट की कई लाइनें लिखेंगे।

# store START index in hold space
1{h
# generate the table
s:.*:,INDEX1 VALUE1,INDEX2 VALUE2,°°°:
# append table to hold space and delete pattern space
H;d}
# read END index, append hold space (pattern space format is: END\nSTART\nTABLE)
G
# delete table entries up to, but excluding, the START index (END\nTABLE')
s:\n(.*)\n.*(,\1.*):\n\2:
# delete table entries starting from, but excluding, the END index (TABLE'')
s:(.*)\n(.*,\1 ..).*:\2:
# remove the indexes and print (implicitly) the resulting values
s:,..::g

— seshoumara
स्रोत

1

PHP, 106 105 104 96 + 2 बाइट्स

eval($s='for($a=a;$a++<c;)$$a=hexdec($argv[++$i]);while($b<=$c)printf("%02X ",ord($s[$b++]));');

या

eval($s='for($a=a;$a++<c;)$$a=hexdec($argv[++$i]);');while($b<=$c)printf("%02X ",ord($s[$b++]));

के साथ भागो php -nr '<code>' <lowindex> <highindex>; कोड में एकल उद्धरण से बचें।
... या इसे ऑनलाइन टेस्ट करें ।

dechexइनपुट को हेक्साडेसिमल स्ट्रिंग्स के रूप में व्याख्या करता है जहां तक वर्ण हेक्स अंक हैं,
0अगर इनपुट कुछ और के साथ शुरू होता है।

पहले मूल्य दूसरे से बड़ा है तो कुछ भी नहीं छापता है।

चुने हुए मान:

00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15
-----------------------------------------------------------------
66 6F 72 28 24 61 3D 61 3B 24 61 2B 2B 3C 63 3B 29 24 24 61 3D 68

(निष्पादित कोड के पहले 22 ascii कोड)

या

for($a=a;$a++<c;)eval($s='$$a=hexdec($argv[++$i]);');while($b<=$c)printf("%02X ",ord($s[$b++]));

इन मूल्यों के साथ:

00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15
-----------------------------------------------------------------
24 24 61 3D 68 65 78 64 65 63 28 24 61 72 67 76 5B 2B 2B 24 69 5D

— टाइटस
स्रोत

क्या उत्तर आम तौर पर <?phpठग को शामिल करते हैं ?

— फिन रेमेंट

@ यदि आप उपयोग नहीं करते हैं -r। और अगर मुझे इसे किसी फ़ाइल में संग्रहीत करने की आवश्यकता है, तो मैं शॉर्ट ओपन टैग का उपयोग करता हूं <?।

— टाइटस

लगातार a, zऔर ProgramingPuzles_CGolfअपरिभाषित हैं। ProgramingPuzles_CGolfवैसे भी कहाँ से आया? : /

— फिन रेमेंट

@ विश्वास वो नोटिस हैं। मार्ग बदलें stderrकरने के लिए /dev/nullयदि आप उन्हें तरह नहीं है। PHP अपरिभाषित स्थिरांक का मूल्यांकन तार से करती है।

— टाइटस

लेकिन सिंटेक्स एरर्स के रूप में उनका आना, मैं प्रोग्राम नहीं चला सकता।

— फिन रेमेंट

1

Apple II 6502 असेंबली, 75 बाइट्स

बाइट कोड:

A9 46 85 36 A9 10 85 37 A0 00 98 20 DA FD A9 A0 
20 ED FD C0 42 D0 F3 20 93 FE A2 FC 20 1B FD 9D 
04 01 E8 D0 F7 86 31 A9 8D 8D 04 02 20 A7 FF B5 
3C 0A 75 3C 95 3C CA 10 F6 A6 3D BD 05 02 20 ED 
FD E8 E4 3C D0 F5 99 05 02 C8 60

disassembly:

  LDA    #<+
  STA    CSWL
  LDA    #>+
  STA    CSWH    ;redirect stdout
  LDY    #$00
- TYA
  JSR    PRBYTE  ;print number
  LDA    #$A0    ;space
  JSR    COUT    ;print space
  CPY    #$42    ;22*3
  BNE    -
  JSR    SETVID  ;restore stdout
  LDX    #$FC
- JSR    KEYIN   ;fetch a key
  STA    $0104,X ;store to $200+
  INX
  BNE    -       ;four keys
  STX    MODE    ;set internal flags
  LDA    #$8D
  STA    $0204   ;set key delimiter
  JSR    GETNUM  ;convert keys to hex values
- LDA    A1L,X   ;fetch value
  ASL
  ADC    A1L,X   ;multiply by 3
  STA    A1L,X   ;store value
  DEX
  BPL    -       ;both inputs
  LDX    A1H     ;first input
- LDA    $0205,X ;fetch from index
  JSR    COUT    ;print character
  INX
  CPX    A1L
  BNE    -       ;until second input
+ STA    $0205,Y ;fall through to save a byte
  INY
  RTS

यह मेमोरी में एक सरणी बनाता है जो आउटपुट की तरह दिखता है। चुने गए मूल्य हैं:

00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15
-----------------------------------------------------------------
00 03 06 09 0C 0F 12 15 18 1B 1E 21 24 27 2A 2D 30 33 36 39 3C 3F

उपयोगकर्ता इनपुट सेट करने के लिए चार कुंजी दबाते हैं।

— पीटर फेरि
स्रोत

Oooo का उपयोग कोड स्वयं करता है। बहुत अच्छी तरह से किया।

— फिन रेमेंट