हेक्साडेसिमल काउंटर

10

हेक्स रूपांतरण तालिका w / काउंटर की छवि

हेक्साडेसिमल एक बेस 16 काउंटिंग सिस्टम है जो से जाता 0है f। आपका काम एक काउंटर बनाना है जो इन नंबरों को प्रदर्शित करेगा।

उदाहरण:

$ python counter.py
1 2 3 4 5 6 7 8 9 a b c d e f 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30

नियम:

  • स्थान, टैब या नई लाइनों द्वारा संख्याओं को अलग किया जा सकता है।
  • आपको न्यूनतम संख्या 30(दशमलव में 48) पर जाना चाहिए ।
    • आप प्रोग्राम प्रिंट नंबर को हमेशा के लिए बंद कर सकते हैं।
  • पत्र अपरकेस या लोअरकेस ( Aया a) में हो सकते हैं।
  • अनुमत कार्यों में कोई अंतर्निहित (जो सीधे हेक्साडेसिमल रूपांतरण / गिनती को प्रभावित करता है)।
  • अग्रणी शून्य की अनुमति है
  • यह 1या से शुरू हो सकता है0
  • सबसे छोटा कोड जीतता है!
code-golf  hexadecimal 
— चरण
स्रोत
@ Sp3000 वे कैसे बनाए गए हैं? हेक्स के लिए दशमलव परिवर्तित?
— चरण
@ Sp3000 अनुमत कार्यों में निर्मित नहीं!
— चरण
4
फिर सामान्य आधार रूपांतरण कार्यों के बारे में कैसे?
— Sp3000
1
@ Sp3000 ज़रूर (इस पर ध्यान न दें, 15 वर्ण सीमा)
— चरण
1
@ मोरिस हां! यह सुनिश्चित करने के लिए दिलचस्प होने जा रहा है ...
— चरण

जवाबों:

5

पायथ - 12 बाइट्स

कार्टेशियन उत्पाद का उपयोग करता है, और सही क्रम में प्राप्त करने के लिए अंत में सॉर्ट करता है, फिर रिक्त स्थान से जुड़ता है। प्रिंट 00-ffसमावेशी।

jdS^s+<G6UT2

इसे यहाँ ऑनलाइन आज़माएँ ।

jd             Join by spaces
 S             Sort lexiographically
  ^    2       Cartesian product repeat twice
   s+          Append then concatenate entire list
    <G6        First six of alphabet
    UT         Range 0-9
— Maltysen
स्रोत
6

सीजाम, 21 14 बाइट्स

A,_6,'Af++m*S*

अंक 00 से 9F तक प्रिंट करता है।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

यह काम किस प्रकार करता है

A,             e# Push [0 ... 9].
  _            e# Push a copy.
   6,          e# Push [0 ... 5].
     'Af+      e# Add 'A' to each. This pushes "ABCDEF".
         +     e# Concatenate. This pushes [0 ... 9 'A' ... 'F'].
          m*   e# Cartesian product. This pushes [[0 0] ... [9 'F'].
            S* e# Join, separating by spaces.
— डेनिस
स्रोत
5

अजगर 2, 52

a=0
for b in'0123456789ABCDEF'*4:print`a`+b;a+=b>'E'

प्रिंट 00करता है 3F। इस तथ्य का लाभ उठाता है कि पहला अंक aहमेशा इस सीमा में एक संख्या है। दूसरे अंक के चार चक्रों के माध्यम से लूप करें b, aजब भी दूसरा अंक बढ़े F।

यह अधिक प्रत्यक्ष से एक चार छोटा है

for a in'0123':
 for b in'0123456789ABCDEF':print a+b
— XNOR
स्रोत
n ='0123'कुछ चरों को बचाना चाहिए
— कारिडोरक
@Caridorc बिल्कुल कैसे?
— xnor
लिखकरthing in n + restofstring
— कारिडोरक
@ करिकॉर्ड का मतलब यह नहीं है कि आपका क्या मतलब है, यह करने के लिए लंबा हैn='0123' for a in n: for b in n+'456789ABCDEF':print a+b
— xnor
2
@Caridorc एक धातु शॉर्टकट जो मैं उपयोग करता हूं, वह है कि एक चर की बचत में 4 वर्णों की लागत होती है, इसलिए उसे क्षतिपूर्ति करने के लिए बचत के 4 वर्णों की आवश्यकता होती है, इसलिए 0123किसी अन्य चीज़ के लिए 4 वर्णों की बचत करना पर्याप्त नहीं है।
— xnor
5

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

पायथन लोगों के रूप में एक ही दृष्टिकोण मुझे लगता है।

for(i of c='0123456789ABCDEF')for(j of c)console.log(i+j)
— rink.attendant.6
स्रोत
4

टीआई-बेसिक, 63 बाइट्स

:For(I,0,4,16⁻¹
:Disp sub(" 0123456789ABCDEF",1+16fPart(I),2
:Output(7,1,int(I
:End

मेरे कैलकुलेटर पर मेमोरी मैनेजमेंट स्क्रीन के अनुसार, यह 63 बाइट्स है, एक टीआई -84 +। आंशिक रूप से भरी हुई होम स्क्रीन के साथ कार्यक्रम शुरू करना सुनिश्चित करें!

— gengkev
स्रोत
क्या आपको 9-बाइट हेडर की लंबाई और कोड लंबाई से प्रोग्राम का नाम घटाना याद है?
— lirtosiast
4

बेफुज -93, 57 बाइट्स

<_v#-*44:+1,*84,g2:\,g2:\
^ >$1+:9-!#@_0
0123456789ABCDEF

से प्रिंट 00करता है 8F। आप हमेशा के लिए चलाने के लिए अपने कार्यक्रमों को पसंद करते हैं तो नीचे दिए गए संस्करण गैर-सांत है और इच्छा लगातार उत्पादन सभी नंबरों से 00करने के लिए FF।

<_v#-*44:+1,*84,g2:\,g2:\
^ >$1+:35*`!*0
0123456789ABCDEF
— सोक
स्रोत
आप एक जोड़ी बाइट्स -98 में <_v # -f: +1, ', g2: \, g2: \ के साथ सहेज सकते हैं। इससे परे कई सुधार नहीं देख सकते हैं।
— जैकब
0123456789ABCDEF01g::88+/2-0g,88+%0g,9,1+01p
— लिन
वह 44 बाइट्स की है। यह हमेशा के लिए बंद हो जाता है, जैसे आपका दूसरा समाधान, और दूसरा 1F पिछले गलत परिणामों को प्रिंट करता है। इसके लिए एक कार्यान्वयन (जैसे संदर्भ कार्यान्वयन bef.c) की आवश्यकता होती है जो चुपचाप अज्ञात आदेशों ( ABCDEF) को अनदेखा कर देता है ।
— लिन
(ओपी ने अतीत की मार को कहीं न कहीं "तोड़ने" के समाधान के लिए ठीक बताया है 30- यह धीरे-धीरे ढेर को खत्म कर देगा, इसलिए मुझे लगता है कि समाप्ति के कुछ बिंदु हैं। इसके अलावा, आउटपुट टैब-अलग है; ओपी ने कहा कि यह ठीक था। ) ओह, आपके द्वारा उपयोग किए जाने वाले Befunge कार्यान्वयन को रिक्त स्थान (ASCII 0x20) के साथ पूरे 80x25 टोरस को इनिशियलाइज़ करना चाहिए ।
— लिन
@ मौरिस को लागू करने के बारे में आपकी टिप्पणी के बारे में रिक्त स्थान के साथ पूरे टोरस को तत्काल करने की आवश्यकता है, क्या यह मेरे द्वारा प्रस्तुत कोड के लिए बाइट की गिनती को प्रभावित करेगा? मैंने केवल रिक्त स्थान के साथ कोनों में भरने के बजाय आवश्यक पात्रों को गिना।
— सोक
2

सी, 78 75 बाइट्स

x(y){return y+48+y/10*7;}f(j){for(j=0;printf("%c%c ",x(j/16),x(15&j++)););}

हम f()मुद्रण के लिए कोई तर्क नहीं, और एक सहायक फ़ंक्शन के साथ बुलाए जाने वाले फ़ंक्शन को परिभाषित करते हैं x(int)। इस पर टूट जाता है FF।

आश्चर्यजनक रूप से, यह एक बाइट से अधिक स्पष्ट है:

char*s="0123456789ABCDEF";h(j){for(j=0;printf("%c%c ",s[j/16],s[15&j++]););}

चेतावनी: यह कोड डीबग वातावरण के बाहर चलाने की अनुशंसा नहीं की गई है ...

परिक्षण:

int main(int argc, char** argv) {
    f();
    return 0;
}

आउटपुट:

00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 (...)

बेशक, अधिक मजबूत (और धोखा-वाई) दृष्टिकोण यह 34-बाइट फ़ंक्शन है:

g(i){for(i=0;printf("%x ",i++););}
— BrainSteel
स्रोत
1
यह कोशिश करना शुरू किया, लेकिन मेरा जवाब भी ऐसा ही था। आप% d में पहला% c बनाकर और फ़ंक्शन को छोड़ कर कई बाइट्स बचा सकते हैं। हालांकि यह केवल 9F तक ही मान्य है।
— अल्काइमर
return y+संभवतः हो सकता है y+=।
— जोनाथन फ्रेच
2

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

VJs++kUT<G6FYJ+NY

इसे यहाँ आज़माएँ

यह काम किस प्रकार करता है:

         <G6         # "abcdef"
       UT            # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
      k              # an empty string (so + means concatenation, not addition)
   s++               # join them all ("0123456789abcdef")
  J                  # call this J
 V                   # for each N in J...
            FYJ      # for each Y in J...
               +NY   # print N and Y
— Ypnypn
स्रोत
jb^+jkUT<G6 2एक ही काम करने के लिए कार्टेशियन उत्पाद का उपयोग करता है, अभी भी गोल्फ लगता है ...
— FryAmTheEggman
2

जे, 22 बाइट्स

>{;~'0123456789abcdef'

को गिनता है ff। 0x10संख्या के प्रत्येक ब्लॉक के बीच एक अतिरिक्त नई रेखा प्रिंट करता है , जैसे:

...
0d
0e
0f

10
11
...
— लिन
स्रोत
2

कण्ठमाला - 65 बाइट्स

S Q="0123456789ABCDEF" F I=1:1:16 F J=1:1:16 W $E(Q,I),$E(Q,J),!

नहींं ... कण्ठमाला अभी तक मर नहीं है! :-)

— zmerch
स्रोत
2

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

1{_GbA,6,'af++f=oNo)}h

यह हमेशा के लिए चलता है, और इस तरह शायद यह दुर्लभ समय में से एक है जहां एक अच्छा विचार है कि एक पर्मलिंक शामिल नहीं है।

— Sp3000
स्रोत
oNonTIO की तरह ही है ।
— फल
2

TheC64Mini और कमोडोर BASIC (C64 / 128, PET, VIC-20, C16 / + 4) - 164 बेसिक और टोकन बाइट्स

 0 fOd=.to255:n=d:fOi=1to.stE-1:h%(i)=n/(16^i):n=n-(h%(i)*(16^i)):nEi:h$=""
 1 fOi=1to.stE-1:ifh%(i)<10tHh$=h$+cH(48+h%(i))
 2 ifh%(i)>9tHh$=h$+cH(55+h%(i))
 3 nEi:?h$"  ";:nEd

हेक्स संख्या के बाद डबल-स्पेस को अच्छी तरह से प्रिंट करते हुए 40/80 कॉलम और साथ ही VIC-20 पर 22 कॉलम को संरेखित करें।

कमोडोर प्लस / 4 हेक्स काउंटर इंसिट

— शॉन बीबर
स्रोत
2

ब्रेनफक , 2902 बाइट्स

आउटगोल्फ के लिए आसान है, लेकिन एक शॉट देने के लायक है

+>+[<[>>+>+<<<-]>>[<<+>>-]>[[-]>>>>>[-]++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<<<[-]++++++++++++++++++++++++++++++++++++++++++++++++>[-]<[>+<<+>-]<[>+<-]<]>+<<+<<[>>->+<<<-]>>>[<<<+>>>-]<[->+<<[>>>-<<+<-]>[<+>-]>>[<->[-]]<[<<<+>>>-]<]>>[-]<<<<[>>+>+<<<-]>>[<<+>>-]>[[-]>>.>.>>>++++++++++++++++++++++++++++++++.[-]<<[-]<<[>>+<<<+>-]<[>+<-]>>>>>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++<<[<<<<+>>>>-]+>>[<<<<<<-<+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>[>>>>-<<<<[-]]>>>>>>[-]++<<[<<<<<+>+>>>>-]<<<<<[>>>>>+<<<<<-]>[<<<[-]>[-]>>>>>>>>[<<<<<<<<+>+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>[-]]>>>>>>[-]<<<<<<]<<<[>>+>+<<<-]>>[<<+>>-]>[[-]>>>>[-]<[>+<<<+>>-]<<[>>+<<-]>>>>>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++<<[<<<<+>>>>-]+>>[<<<<<<-<+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>[>>>>-<<<<[-]]>>>>>>[-]+++<<[<<<<<+>+>>>>-]<<<<<[>>>>>+<<<<<-]>[<<<[-]>[-]>>>>>>>>[<<<<<<<<+>+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>[-]]>>>>>>[-]<<<<<<]<<<[>>+>+<<<-]>>[<<+>>-]>[[-]>>>>[-]<<[>>+<<<+>-]<[>+<-]>>>[<<<<+>>>>-]+>[<<<<<-<+>>>>>>-]<<<<<<[>>>>>>+<<<<<<-]>[>>>>-<<<<[-]]>>>>>>+++++<<[<<<<<+>+>>>>-]<<<<<[>>>>>+<<<<<-]>[<<<[-]>[-]>>>>>>>>[<<<<<<<<+>+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>[-]]>>>>>>[-]<<<<<<]>++++++<<+<<[>>->+<<<-]>>>[<<<+>>>-]<[->+<<[>>>-<<+<-]>[<+>-]>>[<->[-]]<[<<<+>>>-]<]>>[-]<<<<[>>+>+<<<-]>>[<<+>>-]>[[-]>>>>[-]<[>+<<<+>>-]<<[>>+<<-]>>>[<<<<+>>>>-]+>[<<<<<-<+>>>>>>-]<<<<<<[>>>>>>+<<<<<<-]>[>>>>-<<<<[-]]>>>>>>++++<<[<<<<<+>+>>>>-]<<<<<[>>>>>+<<<<<-]>[<<<[-]>[-]>>>>>>>>[<<<<<<<<+>+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>[-]]>>>>>>[-]<<<<<<]<<<[>>+>+<<<-]>>[<<+>>-]>[[-]>>>+>>>+<<<<<<<<<[-]>[-]>>>>>>>>[<<<<<<<<+>+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>>>>>>>[-]<<<<<<]>++<<+<<[>>->+<<<-]>>>[<<<+>>>-]<[->+<<[>>>-<<+<-]>[<+>-]>>[<->[-]]<[<<<+>>>-]<]>>[-]<<<<[>>+>+<<<-]>>[<<+>>-]>[[-]>>>>>-----<<<[-]>>>[<<<+<+>>>>-]<<<<[>>>>+<<<<-]>>>>+++++>+<<<<<<<<<[-]>[-]>>>>>>>>[<<<<<<<<+>+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>>>>>>>[-]<<<<<<]>+++<<+<<[>>->+<<<-]>>>[<<<+>>>-]<[->+<<[>>>-<<+<-]>[<+>-]>>[<->[-]]<[<<<+>>>-]<]>>[-]<<<<[>>+>+<<<-]>>[<<+>>-]>[[-]>>>>>-----<<[-]>>[<<+<<+>>>>-]<<<<[>>>>+<<<<-]>>>>+++++>+<<<<<<<<<[-]>[-]>>>>>>>>[<<<<<<<<+>+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>>>>>>>[-]<<<<<<]>++++<<+<<[>>->+<<<-]>>>[<<<+>>>-]<[->+<<[>>>-<<+<-]>[<+>-]>>[<->[-]]<[<<<+>>>-]<]>>[-]<<<<[>>+>+<<<-]>>[<<+>>-]>[[-]>>+>[-]++++++++++++++++++++++++++++++++++++++++++++++++>>>+<<<<<<<<<[-]>[-]>>>>>>>>[<<<<<<<<+>+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>>>>>>>[-]<<<<<<]>+++++<<+<<[>>->+<<<-]>>>[<<<+>>>-]<[->+<<[>>>-<<+<-]>[<+>-]>>[<->[-]]<[<<<+>>>-]<]>>[-]<<<<[>>+>+<<<-]>>[<<+>>-]>[[-]>>>>[-]<[>+<<<+>>-]<<[>>+<<-]>>>[<<<<+>>>>-]+>[<<<<<-<+>>>>>>-]<<<<<<[>>>>>>+<<<<<<-]>[>>>>-<<<<[-]]>>>>>>++++++<<<<<<+>>>>[<<<<[-]<+>>>>>-]<<<<<[>>>>>+<<<<<-]>[<<<[-]>[-]>>>>>>>>[<<<<<<<<+>+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>[-]]>>>>>>[-]<<<<<<]<<<[>>+>+<<<-]>>[<<+>>-]>[[-]<<<[-]>[-]>>]<<]

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

— क्रेज़सटेस्टो ज़्वेज़्स्की
स्रोत
यह छोटा होगा यदि आप केवल वर्ण उत्पन्न करते हैं 0-Fऔर फिर मुद्रण को हार्डकोड करते हैं। आपने इसे इतना लंबा करने का प्रबंधन कैसे किया?
— जो किंग
@JoKing संभवतः, लेकिन मैं बस मज़े करना चाहता था
— Krzysztof Szewczyk
क्या यह टिप्पणी एक प्रवेश नहीं है कि यह जवाब चुनौती के विजयी मापदंड का गंभीर दावेदार नहीं है?
— पिपरी
1

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

यह वास्तव में मेरे लिए सबसे स्पष्ट दृष्टिकोण होना चाहिए था।

a='0123456789ABCDEF'
for x in a:
 for y in a:print x+y

पुराना (66 बाइट्स) : तकनीकी रूप से इसके बाद एक त्रुटि होती है FF, लेकिन यह पहुंच जाती है 30।

n=1;a='0123456789ABCDEF'
while 1:print a[n/16]*(n>15)+a[n%16];n+=1

मैंने माना कि स्ट्रिंग स्वरूपण की अनुमति नहीं थी क्योंकि मुझे पूरा यकीन है कि यह आधार रूपांतरण के माध्यम से जाएगा, लेकिन अगर इसकी अनुमति थी, तो यह 29 बाइट्स होगा:

n=1
while 1:print"%x"%n;n+=1
— Kade
स्रोत
1

जावा, 104 बाइट्स

char t[]="0123456789abcdef".toCharArray(),i;void f(){for(;i<99;)System.out.println(""+t[i/16]+t[i++%16]);}

यदि i<99हटा दिया जाता है, तो यह अभी भी 30 तक पहुंचता है, लेकिन अंततः दुर्घटनाग्रस्त हो जाता है। मुझे यकीन नहीं है कि अगर यह स्वीकार्य है।

— Ypnypn
स्रोत
1

जे, 47 बाइट्स

'0123456789abcdef'{~([:|:2 256$(]#i.),256$i.)16

प्रिंट्स 00 से एफएफ

— gar
स्रोत
1
एक बहुत छोटा तरीका:>{;~'0123456789abcdef'
— लिन
वाह, यह बहुत अच्छा है! लेकिन आपने इसे उत्तर के रूप में पोस्ट क्यों नहीं किया, यह केवल 22 बाइट्स है!
— gar
1

पर्ल 6 , 34 बाइट्स

सबसे छोटा कि मैं किसी भी प्रकार के रूपांतरण का उपयोग नहीं कर सकता हूं:

put [X~] (|(0..9),|('A'..'F'))xx 2 # 34 bytes

प्रिंट 00... FFअंतरिक्ष क्रम में अलग हो गया।
यदि आप अधिक चाहते हैं तो आप 2बड़ी संख्या में स्वैप कर सकते हैं ।
(4 से अधिक संख्या का उपयोग न करें क्योंकि यह कुछ भी आउटपुट करने से पहले मूल्यों को एक साथ मिलाता है, इसलिए यह रैम की एक महत्वपूर्ण राशि का उपयोग करेगा)

सबसे छोटा जो हेक्स मान लिखना कभी बंद नहीं करेगा 

put [R~] (|(0..9),|('A'..'F'))[.polymod: 16 xx*]for 0..* # 56 bytes

अगर printfअनुमति दी गई थी

printf "%X ",$_ for 0..* # 24 bytes

यदि एक आधार रूपांतरण समारोह की अनुमति थी

put .base(16)for 0..* # 21 bytes
— ब्रैड गिल्बर्ट b2gills
स्रोत
1

सी ++ 14 - 135

#include<string>
#include<iostream>
void f(){std::string a="0123",b="0123456789ABCDEF";for(char c:a)for(char d:b)std::cout<<c<<d<<" ";}
— Yytsi
स्रोत
नहीं, यह ठीक है जैसे यह है। आप किस कंपाइलर का उपयोग कर रहे हैं? मुझे 'string' is not a member of 'std'मेरा साथ मिलता है ।
— डेनिस
@ डेनिस यह एक अच्छी बात है। मैं हमेशा भूल जाता हूं कि उसे स्ट्रिंग की आवश्यकता है क्योंकि यह स्वयं है। फिक्स्ड।
— यति
1. मैं भी के लिए एक ही त्रुटि हो रही है cout। मुझे लगता है कि आपको iostreamभी जरूरत है। 2. यह बिना अलगाव के संख्या को प्रिंट करता है। चुनौती के लिए रिक्त स्थान, टैब या न्यूलाइन्स की आवश्यकता होती है। 3. आपको C ++ के आवश्यक संस्करण का उल्लेख करना चाहिए।
— डेनिस
1

jq 1.5: 65 59 वर्ण

(56 वर्ण कोड + 3 वर्ण कमांड लाइन विकल्प।)

[range(10)]+"a b c d e f"/" "|{a:.[],b:.}|"\(.a)\(.b[])"

नमूना रन:

bash-4.3$ jq -n -r '[range(10)]+"a b c d e f"/" "|{a:.[],b:.}|"\(.a)\(.b[])"' | head
00
01
02
03
04
05
06
07
08
09

ऑन-लाइन परीक्षण ( -rURL से गुजरना समर्थित नहीं है - स्वयं रॉ आउटपुट की जाँच करें।)

jq 1.5: 56 वर्ण

(53 अक्षर कोड + 3 वर्ण कमांड लाइन विकल्प।)

[[range(10)]+"a b c d e f"/" "|"\(.[])\(.[])"]|sort[]

यह सही आउटपुट पैदा करता है, हालांकि यह बिल्कुल काउंटर नहीं है: यह क्रम में मूल्यों को उत्पन्न नहीं करता है, बस उन्हें बाद में क्रमबद्ध करें।

ऑन-लाइन परीक्षण ( -rURL से गुजरना समर्थित नहीं है - स्वयं रॉ आउटपुट की जाँच करें।)

— आदमी काम पर है
स्रोत
jq के लिए आपका लिंक काम नहीं करता है, और जब मैंने तय किया तो यह कहता है कि वहाँ कोई फ़ाइल नहीं है github पर: P
— चरण
उफ़। शुक्रिया @Phase मैं चरित्र गणना पर भी केंद्रित था।
— मैनटवर्क
1

Dyalog एपीएल , 12 बाइट्स

       ∘.,⍨16↑⎕D,⎕A
 00  01  02  03  04  05  06  07  08  09  0A  0B  0C  0D  0E  0F 
 10  11  12  13  14  15  16  17  18  19  1A  1B  1C  1D  1E  1F 
 20  21  22  23  24  25  26  27  28  29  2A  2B  2C  2D  2E  2F 
 30  31  32  33  34  35  36  37  38  39  3A  3B  3C  3D  3E  3F 
 40  41  42  43  44  45  46  47  48  49  4A  4B  4C  4D  4E  4F 
 50  51  52  53  54  55  56  57  58  59  5A  5B  5C  5D  5E  5F 
 60  61  62  63  64  65  66  67  68  69  6A  6B  6C  6D  6E  6F 
 70  71  72  73  74  75  76  77  78  79  7A  7B  7C  7D  7E  7F 
 80  81  82  83  84  85  86  87  88  89  8A  8B  8C  8D  8E  8F 
 90  91  92  93  94  95  96  97  98  99  9A  9B  9C  9D  9E  9F 
 A0  A1  A2  A3  A4  A5  A6  A7  A8  A9  AA  AB  AC  AD  AE  AF 
 B0  B1  B2  B3  B4  B5  B6  B7  B8  B9  BA  BB  BC  BD  BE  BF 
 C0  C1  C2  C3  C4  C5  C6  C7  C8  C9  CA  CB  CC  CD  CE  CF 
 D0  D1  D2  D3  D4  D5  D6  D7  D8  D9  DA  DB  DC  DD  DE  DF 
 E0  E1  E2  E3  E4  E5  E6  E7  E8  E9  EA  EB  EC  ED  EE  EF 
 F0  F1  F2  F3  F4  F5  F6  F7  F8  F9  FA  FB  FC  FD  FE  FF
— एडम
स्रोत
एक बार के लिए, एपीएल पायथ से मेल खाता है।
— 13:
1

Malbolge , 900 बाइट्स

सुधार करने के लिए...

D'``@"\7}|X9E1gwuR21=p(:9%IZYEg}eA/ya>O_)([Zvotm3qponmfN+Lbg`ed]\"CB^W\Uy<;WVONSLp3ONMLEDhH*)?>b%A@?87[;:9876/S3,P0/.-&J$)"'~D|{"y?}|utyr8potmrqpi/mfN+Lbg`e^$bDZ_^]VzZSXQVUTSLp3ONMLEDhH*)EDCB;@?8\6|:32V6v.32+O)o'&J*)i'&%|Bcb~w|u;yxwvutVrkj0nmfN+iKg`_%cE[`Y}@V[ZYXWPtT6LKJImM/KJIBAe(D=<A:98\[;{32V6v.-,P0).',%I)"!E%|#"y?w_{ts9Zvutsrkpi/mfNjihg`e^$b[Z~X]\[ZYRv98TSLKoO10FKDh+GFE>CB;_?>=}|49870/.R2+*Non&%I#"!&%${A!~}_u;yxqpo5mrqpoh.lkdibgf_%]\[!_XW{[ZYXQPt7SRQPOHGkKJIHAF?cC<;@?8\6;492V6v.-,P*p.'K+$j"'~D|#"y~wv<]yxqvutsrk1onmfN+cba`&d]#DZ_^]VzTSXQVOs65QJINGkE-IBAe(D=<A:98\654981Uv.32+*)M-,%k#(!E}$#"!x>v{t:xwputm3kpoh.fN+Lbg`ed]\"!Y^]VzZYXQVOsS54JImMFKJIHAe?>C<`@?87[;{32V05.-2+O)o-,+$H('&}Cdzy~wv<]sxqvonm3k1oQmf,jihgfeG]#a`_X|V[TxXQPUTMLp3ONMLEDhH*)ED=a;@?>76;4X816/43,P*).',%I#i!&}|Bcb~w|u;yxwputm3qSong-kjihgfH%]\a`_XW{UTYXQuUTMRKPOHlFKDhBAe?>=B;_9>=6Z:981Uv.32+*)M-,%k#(!E%$#c!x>|u;yxZpo5srqSi/z

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

— क्रेज़सटेस्टो ज़्वेज़्स्की
स्रोत
1

Zsh, 44 29 बाइट्स

-15 , गामाफंक्शन के माध्यम से   इसे ऑनलाइन आज़माएं!

h=({0..9} {a..f});echo $^h$^h

मूल (44 बाइट्स): g=0123456789abcdef;h=(${(s::)g});echo $^h$^h

— roblogic
स्रोत
1
सरणी में कनवर्ट करने के बजाय, आप वहां शुरू कर सकते हैं h=({0..9} {a..f}):। 29 बाइट्स
— गामाफंक्शन
धन्यवाद! zsh बहुत गोल्फ वाला है :)
— रोबॉटिक
1

8088 विधानसभा, आईबीएम पीसी डॉस, 34 बाइट्स

बाइट्स xxd:

00000000: 43e8 0900 e806 00b0 20cd 10eb f3b1 04d2  C....... .......
00000010: c38a c324 0f3c 0a7c 0204 0704 30b4 0ecd  ...$.<.|....0...
00000020: 10c3

unassembled:

        BYTE_LOOP: 
43          INC  BX             ; increment counter  
E8 0009     CALL HB             ; display high byte 
E8 0006     CALL HB             ; display low byte 
B0 20       MOV  AL, ' '        ; display space delimiter
CD 10       INT  10H            ; call BIOS, write char to console 
EB F3       JMP  BYTE_LOOP      ; keep looping forever
        HB PROC 
B1 04       MOV  CL, 4          ; set up bitshift for 4 bits 
D2 C3       ROL  BL, CL         ; shift counter left 4 bits 
8A C3       MOV  AL, BL         ; put counter into AL 
24 0F       AND  AL, 0FH        ; isolate nibble 
3C 0A       CMP  AL, 0AH        ; is nibble A-F? 
7C 02       JL   NOT_ALPHA      ; if not, skip adjustment 
04 07       ADD  AL, 'A'-'9'-1  ; adjust ASCII value to A-F 
        NOT_ALPHA: 
04 30       ADD  AL, '0'        ; decimal to binary convert
B4 0E       MOV  AH, 0EH        ; BIOS tty function
CD 10       INT  10H            ; call BIOS, write char to console 
C3          RET                 ; return to program
        HB ENDP

स्टैंडअलोन पीसी डॉस सटीक, आउटपुट कंसोल के लिए है और कार्यक्रम बंद होने तक प्रदर्शित करता रहेगा। बस एक खरोंच ASCII हेरफेर कार्यक्रम यहाँ। बाइनरी मान को आउटपुट के लिए स्ट्रिंग्स में परिवर्तित करने के लिए x86 या DOS / BIOS APIs में कोई अंतर्निर्मित या सुविधा विधियाँ नहीं हैं।

आउटपुट:

यहाँ छवि विवरण दर्ज करें

— 640KB
स्रोत
1

MUMPS , 57 बाइट्स

f i=1:1:48 w $tr(i\16,0),$e("0123456789abcdef",i#16+1),!

उत्पादन

>d ^xmsdgolf
1
2
3
4
5
6
7
8
9
a
b
c
d
e
f
10
11
..
28
29
2a
2b
2c
2d
2e
2f
30

व्याख्या

f i=1:1:48                     ; loop from 1 to 48
w $tr(i\16,0)                  ; print i div 16, and ditch any zeros
$e("0123456789abcdef",i#16+1)  ; extract the nth character from the string, where n is i mod 16 + 1
!                              ; crlf
— माइकल डोनली
स्रोत
0

हास्केल, 52 बाइट्स

a="0123456789abcdef";main=mapM putStrLn$mapM id[a,a]
— लिन
स्रोत
0

पायथन 2 - 57 बाइट्स

h='0123456789ABCDEF'
' '.join([i+j for i in h for j in h])

यह 00 से FF के बीच के रिक्त स्थान के साथ आउटपुट करता है।

— ब्रायन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.