नंबर को हेक्साडेसिमल में बदलें

Question

चुनौती

यहाँ एक सरल है।

बेस 10 में इनपुट के रूप में नंबर दिए जाने पर एक फ़ंक्शन या प्रोग्राम लिखें, यह हेक्साडेसिमल में उस नंबर के मूल्य को वापस करेगा या प्रिंट करेगा ।

उदाहरण

15 -> F
1000 -> 3E8
256 -> 100

नियम

• कोई भी निर्मित हेक्साडेसिमल कार्य नहीं करता है
• पत्र लोअरकेस या अपरकेस हो सकते हैं
• आपको केवल गैर-नकारात्मक पूर्णांक, कोई नकारात्मक या pesky दशमलव के बारे में चिंता करने की आवश्यकता होगी
• यह भाषा के डिफ़ॉल्ट प्रकार की सीमा तक किसी भी मनमाने ढंग से बड़ी संख्या के साथ काम करना चाहिए।
• न्यूलाइन अनिवार्य नहीं
• हमेशा की तरह, यह कोड-गोल्फ है , इसलिए बाइट्स जीत में मापा जाने वाला सबसे छोटा कोड!

Comments

पहली समस्या, आशा है कि आप लोग आनंद लेंगे!

— रैंडम गाई

आउटपुट में अग्रणी शून्य की अनुमति दी जाती है, उदाहरण के लिए 32 बिट संख्या 000003E8?

— nimi

इनपुट पर कोई सीमा?

— लोवोजो

@ निम्मी हां, यह अनुमति है।

— रैंडम गाई

मजेदार तथ्य: C ++ में एक हेक्स बिल्डिन है।

— मैथ्यू रो

Answer 1

APL (Dyalog APL) , 17 बाइट्स

⎕IO←0कई एपीएल सिस्टम पर डिफ़ॉल्ट रूप से चलाया जाना चाहिए ।

(⎕D,⎕A)[16⊥⍣¯1⊢⎕]

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

(⎕D,⎕A)[... ] डी igits को अवगत कराया एक वर्णमाला के अनुरूप, तो द्वारा अनुक्रमित ...

 16⊥⍣¯1  16-बेस-टू-नंबर, यानी नंबर-टू-बेस -16 का विलोम

 ⊢ पर लागू किया गया

 ⎕ संख्यात्मक इनपुट

Comments

क्या यह 17 चरस और 23 बाइट्स के आसपास नहीं है?

— जूली पेलेटियर

@ जूलीप्लेटियर नं, डायलाग एपीएल अपने स्वयं के 256 वर्ण कोडपेज का उपयोग करता है।

— अदम

ओह! जानकार अच्छा लगा।

— जूली पेलेटियर

Answer 2

ट्यूरिंग मशीन कोड, 412 बाइट्स

हमेशा की तरह, मैं यहाँ परिभाषित नियम सारणी का उपयोग कर रहा हूँ । आप इसे उस साइट पर या वैकल्पिक रूप से इस जावा कार्यान्वयन का उपयोग करके परीक्षण कर सकते हैं ।

0 * * l B
B * * l C
C * 0 r D
D * * r E
E * * r A
A _ * l 1
A * * r *
1 0 9 l 1
1 1 0 l 2
1 2 1 l 2
1 3 2 l 2
1 4 3 l 2
1 5 4 l 2
1 6 5 l 2
1 7 6 l 2
1 8 7 l 2
1 9 8 l 2
1 _ * r Y
Y * * * X
X * _ r X
X _ _ * halt
2 * * l 2
2 _ _ l 3
3 * 1 r 4
3 1 2 r 4
3 2 3 r 4
3 3 4 r 4
3 4 5 r 4
3 5 6 r 4
3 6 7 r 4
3 7 8 r 4
3 8 9 r 4
3 9 A r 4
3 A B r 4
3 B C r 4
3 C D r 4
3 D E r 4
3 E F r 4
3 F 0 l 3
4 * * r 4
4 _ _ r A

बेस 16 में 0 से गिनती करते हुए बेस 10 में इनपुट से नीचे गिना जाता है। शून्य पर डीग्रीमेंट करने पर, यह इनपुट ब्लॉक मिटा देता है और समाप्त हो जाता है।

Comments

यह वास्तव में अच्छा है, यह 10*n + 33किसी भी मनमानी के लिए पूरा करने के निर्देश लेता है n। मुझे हालांकि कोड समझ में नहीं आता है।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn यह इनपुट के बाईं ओर कोशिकाओं का एक नया ब्लॉक बनाता है, जिसमें शुरुआत में 0. होता है। फिर, यह बेस 10 में इनपुट ब्लॉक को बार-बार घटाता है, जबकि बेस 16 में आउटपुट ब्लॉक को बढ़ाता है, जब तक कि यह एक खाली सेल को हटाने का प्रयास नहीं करता है वेतन वृद्धि चक्र [जो इसे बताता है कि इनपुट ब्लॉक अब 0 है], जिस बिंदु पर यह टेप को साफ करता है (इसलिए टेप पर केवल आउटपुट रहता है)।

— SuperJedi224

@MagicOctopusUrn इसके अलावा रनटाइम के लिए आपका समीकरण गलत है (मुझे नहीं पता कि सही सामान्य समीकरण क्या है, हालांकि यह स्पष्ट रूप से नहीं है)। उदाहरण के लिए, इसे 2 के इनपुट के साथ आज़माएं।

— SuperJedi224

शायद ऩही। हालांकि उच्च मूल्यों के लिए करीब है। मैं इसके बारे में कुछ नहीं जानता और पैटर्न को देखने का प्रयास कर रहा था।

— मैजिक ऑक्टोपस Urn

Answer 3

जावा, 92 89 बाइट्स

String x(int v){String z="";for(;v>0;v/=16)z="0123456789ABCDEF".charAt(v%16)+z;return z;}

Answer 4

जावास्क्रिप्ट, 49 43 बाइट्स।

h=i=>(i?h(i>>4):0)+"0123456789abcdef"[i%16]

User81655 द्वारा सहेजे गए 6 बाइट्स ।

इसका परीक्षण यहां करें ।

इसमें दो प्रमुख शून्य हैं, जिन्हें नियमों द्वारा अनुमति दी गई है।

यहां अग्रणी शून्य के बिना एक संस्करण है: (47 बाइट्स)।

h=i=>(i>15?h(i>>4):"")+"0123456789abcdef"[i%16]

इसका परीक्षण यहां करें ।

ये दोनों बिल्कुल मेरे पाइथन के उत्तर के समान दृष्टिकोण का उपयोग करते हैं ।

Comments

बाइनरी का उपयोग करें और। i&15दशमलव को स्वचालित रूप से पूर्णांक में बदल देगा। ~~

— edc65

मैंने 3 बाइट्स और एक अग्रणी शून्य बचाया:h=i=>i&&h(i>>4)+"0123456789abcdef"[i&15]

— नील

Answer 5

CJam, 22 21 बाइट्स

ri{Gmd_A<70s=+\}h;]W%

1 बाइट को बंद करने के लिए @ मार्टिनबटनर को धन्यवाद!

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

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

ri                      e# Read an integer from STDIN.
  {             }h      e# Do:
   Gmd                  e#   Push qotient and residue of the division by 16.
      _A<               e#   Check if the residue is less than 10.
         70s            e#   Push "70".
            =           e#   Select the character that corresponds to the Boolean.
             +          e#   Add the character to the digit.
                        e#   This way, 10 -> 'A', etc.
               \        e#   Swap the quotient on top of the stack.
                        e# While the quotient is non-zero, repeat the loop.
                  ;     e# Pop the last quotient.
                   ]W%  e# Reverse the stack.

Comments

उसी बाइट की गिनती:ri{Gmd_9>7*sc+\}h;]W%

— मार्टिन एंडर

Answer 6

पायथ, 33 26 21 20 बाइट्स

यह एक मजेदार था।

sm@+jkUTGi_d2_c_.BQ4

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

व्याख्या की:

                .BQ      Convert input to a binary string, e.g. 26 -> '11010'
             _c_   4     Reverse, chop into chunks of 4, and reverse again. We reverse 
                         because chop gives a shorter last element, and we want a shorter
                         first element: ['1', '0101']
                         Reversing three times is still shorter than using .[d4 to pad the
                         binary string to a multiple of 4 with spaces.
 m                       Map across this list:
         i_d2                Take the value of the reversed string in binary,
  @                          and use it as an index into the string:
   +jkUTG                    '0123456789abcdefghijklmnopqrstuvwxyz'
                             (The alphabet appended to the range 0 to 10)
s                        Concatenate to create the final string.

Comments

क्या आप एक स्पष्टीकरण जोड़ सकते हैं?

— तन्मात्रा

यकीन है, जो आप में रुचि रखते हैं?

— ल्यूक

सबसे इंटरस्टिंग जवाब! ;) यह कोई फर्क नहीं पड़ता ... हालांकि यह उन सभी के लिए स्पष्टीकरण पोस्ट करने के लिए एक अच्छा विचार है

— TanMath

Answer 7

सी (फ़ंक्शन), 51

पुनरावर्ती कार्य एक पैरामीटर के रूप में इनपुट पूर्णांक लेता है:

f(n){n>>4?f(n>>4):0;n&=15;n+=n>9?55:48;putchar(n);}

परीक्षण चालक:

#include <stdio.h>

f(n){if(n>>4)f(n>>4);n&=15;n+=n<10?48:55;putchar(n);}

int main (int argc, char **argv) {

    f(15);puts("");
    f(1000);puts("");
    f(256);puts("");
    f(0);puts("");

    return 0;
}

Answer 8

हास्केल, 59 58 43 41 39 बाइट्स

s="0123456789ABCDEF"
(sequence(s<$s)!!)

प्रयोग उदाहरण: sequence(s<$s)!!) $ 1000-> "00000000000003E8"।

यह 16 हेक्स-अंकों तक सभी हेक्साडेसिमल संख्याओं की एक सूची बनाता है। सौभाग्य से यह क्रम में होता है, इसलिए हम केवल nवें को चुन सकते हैं ।

संपादित करें: @Mauris ने 2 बाइट्स निकाले। धन्यवाद!

Comments

डेट सूची मोनाद डो

— डेनेथ

@ डॅनेथ: मैंने मोनाड से फन्क्टर तक स्विच किया है

— nimi

कैसे के बारे मेंs="0123456789ABCDEF";(sequence(s<$s)!!)

— लिन 5

@ मोरिस: कमाल!

— निमि

Answer 9

डीसी, ३,

?[16~rd0<m]dsmxk[A~r17*+48+Pz0<p]dspx

16 से फिर से divmods, शेष को धकेलने के लिए जब तक कि कुछ भी विभाजित करने के लिए नहीं छोड़ा जाता है। तब AF के अंक प्राप्त करने के लिए 10 से divmod का उपयोग करके, स्टैक के प्रत्येक तत्व को प्रिंट करें। शायद कल और अधिक विस्तार ... (और उम्मीद है कि कम बाइट्स)।

Answer 10

पायथन, 59 58 बाइट्स

h=lambda i:(i>15 and h(i/16)or'')+"0123456789abcdef"[i%16]

कारपेटपाइथन द्वारा बचाए गए 1 बाइट

ऐसे दोड़ो: print h(15)

इसका परीक्षण यहां करें (Ideone.com)।

स्पष्टीकरण:

h=lambda i:                                                 # Define h as a function that takes two arguments
           (i>15 and h(i/16)or'')                           # Evaluate h(i/16) if i > 15, else, give ''
                                 +"0123456789abcdef"[i%16]  # Append (i%16)'th hexadecimal number.

Comments

अच्छा काम। आप एक अन्य बाइट के साथ भी बचा सकते हैं h=lambda i:(i>15 and h(i/16)or'')+"0123456789abcdef"[i%16]।

— लॉजिक नाइट

अच्छा काम वास्तव में, आप इस तरह से एक और दो बचा सकते हैं:h=lambda i:(i>15 and h(i/16)or'')+chr(48+i%16+i%16/10*7)

— विल्म

Answer 11

सी (जीसीसी) , 45 44 बाइट्स

f(n){n&&f(n/16);n%=16;putchar(n+48+n/10*7);}

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

Comments

अभ्यास में वाक्यांश "" न्यूलाइन अनिवार्य नहीं है "इसका मतलब है कि संख्या को '\ n' के साथ समाप्त होना है?

— रोजलूपी

Answer 12

बैश (समारोह), 62

पुनरावृत्ति का उपयोग करने के सुझाव के लिए @manatwork का धन्यवाद।

h()(x=({0..9} {A..F})
echo `(($1>15))&&h $[$1/16]`${x[$1%16]})

Comments

अच्छा लगा। लेकिन पुनरावर्ती तरीका अभी भी कम प्रतीत होता है:h(){ x=({0..9} {A..F});echo `(($1>15))&&h $[$1/16]`${x[$1%16]}; }

— manatwork

@manatwork नीस - धन्यवाद! किसी कारण के लिए मैं आमतौर पर बैश में पुनरावृत्ति की कोशिश करना भूल जाता हूं, भले ही मैं इसे अन्य उत्तरों में उपयोग कर रहा हूं। फ़ंक्शन ()के { ;}चारों ओर के बजाय का उपयोग करना शरीर को और भी अधिक बचाता है :)

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

Answer 13

पर्ल 6 ,  53  48 बाइट्स

{[R~] (0..9,'A'..'F').flat[($_,*div 16...^0)X%16]||0}
{[R~] (0..9,'A'..'F').flat[.polymod(16 xx*)]||0}

यह मान जो पूर्णांक विभाजित (हैं के एक दृश्य बनाता है div,), जब तक परिणाम है 0छोड़कर 0अनुक्रम से

$_, * div 16 ...^ 0

इसके बाद Xमोडुलस ऑपरेटर ( %) के साथ उस क्रम को पार करता है16

( … ) X[%] 16

यह उन मूल्यों का उपयोग करता है जो दो चपटाओं से युक्त चपटी सूची में अनुक्रमित होते हैं 0..9और'A'..'Z'

( 0 .. 9, 'A' .. 'Z' ).flat[ … ]

अंत में यह ~रिवर्स ( R) मेटा ऑपरेटर का उपयोग करके उन्हें समेटता है ( )

[R[~]] …

यदि वह परिणाम गलत मान (रिक्त स्ट्रिंग) है, तो वापस लौटें 0

… || 0

---

उपयोग:

# (optional) give it a lexical name for ease of use
my &code = { … }

say <15 1000 256 0>.map: &code;
# (F 3E8 100 0)

say code 10¹⁰⁰;
# 1249AD2594C37CEB0B2784C4CE0BF38ACE408E211A7CAAB24308A82E8F10000000000000000000000000

Answer 14

MATL , 27 बाइट्स

i`16H#\wt9>?7+]wt]xN$hP48+c

यह भाषा / संकलक की रिलीज़ 5.1.0 का उपयोग करता है , जो इस चुनौती से पहले है।

उदाहरण

>> matl
 > i`16H#\wt9>?7+]wt]xN$hP48+c
 >
> 1000
3E8

व्याख्या

i              % input number
`              % do...
  16H#\        % remainder and quotient of division by 16
  w            % move remainder to top of stack
  t9>          % does it exceed 9?
  ?            % if so
    7+         % add 7 (for letter ASCII code)
  ]            % end if
  w            % move quotient back to the top
  t            % duplicate 
]              % ...while (duplicated) quotient is not zero
x              % delete last quotient (zero)
N$h            % create vector of all remainders 
P              % flip vector
48+c           % add 48 and convert to char (will be implicitly displayed)

Answer 15

S, 31 चार्ट / 62 बाइट्स

↺a=⬯;ï;ï≫4@a=⩥ḊĀⒸª⩥⁽ṁṇ⸩⨝[ï%Ḑ]+a

Try it here (Firefox only).

ठीक है, मुझे कुछ और सामान मिला है, जो इसे नीचे गिरा देता है।

व्याख्या

यह अनिवार्य रूप से @ SuperJedi224 के ES6 समाधान के रूप में एक ही समाधान है - लेकिन कुछ अलग के साथ।

देखें ⩥ḊĀⒸª⩥⁽ṁṇ⸩⨝? यह लेखन का एक शानदार तरीका है "0123456789ABCDEF"। ⩥Ḋ0 से 10 Ⓒª⩥⁽ṁṇ⸩तक की सीमा बनाता है , 65 से 71 तक की सीमा बनाता है और इसे ASCII के एक स्ट्रिंग में परिवर्तित करता है, और Ā...⨝दो रेंजों को मिलाता है और उन्हें एक स्ट्रिंग में जोड़ता है। यह शायद मेरे समाधान का सबसे ठंडा हिस्सा था।

बोनस गैर-प्रतिस्पर्धी संस्करण, 24 चार्ट / 45 बाइट्स

↺;ï;ï≫4@ᵴ=(⩥Ḋ⨝+ᶐ)[ï%Ḑ]+ᵴ

मैंने एक वर्णमाला स्ट्रिंग जोड़ने का फैसला किया, जैसे कि पायथ में।

Answer 16

सीड, 341 बाइट्स

:
s/\b/_/2
s/[13579]/&;/g
y/123456789/011223344/
s/;0/5/g
s/;1/6/g
s/;2/7/g
s/;3/8/g
s/;4/9/g
s/;_;_;_;_/=/
s/;_;_;__/+/
s/;_;__;_/:/
s/;_;___/>/
s/;__;_;_/</
s/;__;__/?/
s/;___;_/(/
s/;____/*/
s/_;_;_;_/-/
s/_;_;__/^/
s/_;__;_/%/
s/_;___/$/
s/__;_;_/#/
s/__;__/@/
s/___;_/!/
s/____/)/
/[1-9_]/b
y/)!@#$%^-*(?<>:+=/0123456789ABCDEF/
s/^0*//

यह इस चुनौती के लिए स्पष्ट भाषा नहीं है, लेकिन इसमें 4000 अंकों और आपके सिस्टम की उपलब्ध (आभासी) मेमोरी की सीमा के बीच (आपके कार्यान्वयन के आधार पर) तक इनपुट नंबरों का समर्थन करने का लाभ है। मैंने RSA-1024 को लगभग 0.6 सेकंड में हेक्स में बदल दिया, इसलिए यह काफी अच्छी तरह से मापता है।

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

Answer 17

पीएचपी, 65 66 64 + 1 62 59 बाइट्स

function h($n){$n&&h($n>>4);echo"0123456789abcdef"[$n&15];}

पुनरावर्ती मुद्रण समारोह, एक प्रमुख शून्य प्रिंट (सम्मिलित करें) >16&& इसे हटाने के लिए पहले )

---

कार्यक्रमों, 64 बाइट्स +1 के लिए -R(साथ पाइप के रूप में चलाएँ)-nR )

for(;$n=&$argn;$n>>=4)$s="0123456789abcdef"[$n&15].$s;echo$s?:0;

PHP 5.6 या बाद के संस्करण की आवश्यकता है (5.5 स्ट्रिंग लिटरल्स को अनुक्रमित नहीं कर सकता है)

या

for(;$n=&$argn;$n>>=4)$s=(abcdef[$n%16-10]?:$n%16).$s;echo$s?:0;

PHP 5.6 या 7.0 की आवश्यकता है (7.1 नकारात्मक स्ट्रिंग इंडेक्स को समझता है)

---

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया उन्हें आज़माएं ।

Comments

मुझे echo+$sइनपुट के लिए एक प्लस चिन्ह याद आ रहा है 0

— Jörg Hülsermann

+साइन ने पहले अक्षर पर आउटपुट में कटौती की ... इसलिए ..?:0

— टाइटस

Answer 18

जूलिया, 55 बाइट्स

h(n)=(n>15?h(n÷16):"")"0123456789ABCDEF"[(i=n%16+1):i]

यह मूल पुनरावर्ती कार्य कार्यान्वयन है। यह एक पूर्णांक को स्वीकार करता है और एक स्ट्रिंग लौटाता है।

यदि इनपुट 15 से कम है, तो फर्श इसे 16 से विभाजित करें और फिर से डालें, अन्यथा खाली स्ट्रिंग लें। इसे उचित रूप से चयनित हेक्साडेसिमल वर्ण के सामने रखें।

Answer 19

चिता , 98 बाइट्स

अंकगणित ऑपरेटरों के बिना एक भाषा में ऐसा करना शायद एक गलती थी।

let h=def (n)(if n.gt(15)h(n.div(16).int!)else "").concat("0123456789abcdef".list!.get(n.mod(16)))

इस तरह का उपयोग करें:

do
  let h = ...
  print(h(15))
end

Ungolfed:

let h = def (n) do
    if n.gt(15) 
        let x = h(n.div(16).int!)
    else 
        let x = ""
    x.concat("0123456789abcdef".list!.get(n.mod(16)))
end

Answer 20

रूबी, 48 वर्ण

( Loovjo के पायथन जवाब की प्रतिलिपि ।)

h=->n{(n>15?h[n/16]:'')+[*?0..?9,*?a..?f][n%16]}

नमूना रन:

2.1.5 :001 > h=->n{(n>15?h[n/16]:'')+[*?0..?9,*?a..?f][n%16]}
 => #<Proc:0x00000001404a38@(irb):1 (lambda)> 
2.1.5 :002 > h[15]
 => "f" 
2.1.5 :003 > h[1000]
 => "3e8" 
2.1.5 :004 > h[256]
 => "100" 

Answer 21

गंभीरता से, 35 बाइट्स

,`;4ª@%)4ª@\`╬Xε D`@;7ªD+@9<7*+c+`n

हेक्स डंप:

2c603b34a640252934a6405c60ce58ee204460403b37a6442b40393c372a2b632b606e

यह ऑनलाइन की कोशिश करो

स्पष्टीकरण:

,                                    Get evaluated input
 `          `╬                       Repeat the quoted function until top of stack is 0
  ;4ª@%                              Make a copy of the number mod 16
       )                             Send it to bottom of stack
        4ª@\                         Integer divide the original copy by 16
              X                      Delete the leftover zero. At this point the stack is 
                                     the "digits" of the hex number from LSD to MSD
               ε                     Push empty string
                 D`              `n  Essentially fold the quoted function over the stack.
                   @;                Roll up the next lowest digit, make a copy
                     7ªD+            Add 48
                         @           Bring up the other copy
                          9<         1 if it's at least 10, else 0
                            7*       Multiply with 7. 
                              +      Add. This will shift 58->65 and so on.
                               c     Convert to character.
                                +    Prepend to current string.

ध्यान दें कि इसके ;7ªD+@9<7*+cबराबर है 4ª▀E, जो 8 बाइट्स को बचाएगा, लेकिन मैंने सोचा कि शायद एक फ़ंक्शन जो बेस बी अंकों को एक स्ट्रिंग के रूप में धकेलता है उसे "हेक्साडेसिमल बिल्ट-इन" के बहुत अधिक माना जा सकता है।

Answer 22

जावास्क्रिप्ट ईएस 6, 64 58 बाइट्स

v=>eval('for(z="";v;v>>=4)z="0123456789ABCDEF"[v%16]+z')

सहेजे गए 6 बाइट्स ed neduן ɯ o user और user81655 के लिए धन्यवाद।

Comments

Eval का प्रयोग करें:v=>eval('for(z="";v;v=v/16|0)z="0123456789ABCDEF"[v%16]+z')

— मामा फन रोल

अरे हाँ, उस लंबे स्ट्रिंग के लिए एटोब और बोटो का उपयोग करने का प्रयास करें।

— मामा फन रोल

@ Ed n v=>{for(z="";v>0;v=v/16|0)z=btoa``Ó]·ã»óÐ1``[v%16]+z;return z}( uɐɯɹɐ ɯ oɯ कोशिश की गई (डबल टिल्ड सिंगल टिल्ड हैं) ==> 64 वर्ण, 71 बाइट्स। इसके लायक नहीं।

— usandfriends

v=v/16|0लिखने का एक जटिल तरीका है v>>=4।

— user81655

Answer 23

बेफुज -93, 58

&:88+%"0"+:"9"`7*+\8/2/:!#|_#
,_@                       >:#

पहली बार Befunge में एक असली गोल्फिंग चुनौती करते हुए, मुझे यकीन है कि इसके लिए एक-लाइनर है जो कि दूसरी पंक्ति के बीच में उन सभी रिक्त स्थान से कम बेकार है।

आप इसके माध्यम से यहां कदम रख सकते हैं । आंशिक विवरण:

&: इनपुट लें

:88+%: शेष मोडुलो 16 लें।

"0"+: इसे 0 के ASCII मान में जोड़ें।

:"9"`: अगर परिणाम 9 के ASCII मान से अधिक है ...

7*+: इसे एक पत्र में बदलने के लिए 7 जोड़ें।

\: स्टैक पर परिणामी चरित्र को सहेजें।

8/2/: 16 राउंड नीचे से विभाजित करें।

:!#|_: यदि परिणाम 0 है तो लूप से बाहर निकलें।

#: अन्यथा मापांक चरण पर वापस जाएं।

>:#,_@ (चारों ओर रैपिंग): एक बार समाप्त हो जाने पर, LIFO ऑर्डर में स्टैक को आउटपुट करें।

Answer 24

> <> , 46 + 3 = 49 बाइट्स

यह छोटा होता अगर> <> पूर्णांक विभाजन होता, जिसे अब हमें modulo को घटाकर 1 का अनुकरण करना पड़ता है। फिर भी, मुझे लगता है कि यह ट्रिक के आसपास कुछ सुंदर साफ लपेट का उपयोग करता है!

>:?!v:f1+%:a(?v  v
\-%1:,+1f}+"0"<+7<
!?:r/ro;

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

व्याख्या

पहला लूप

>:?!v:f1+%:a(?v  v
\-%1:,+1f}+"0"<+7<

पहला लूप हेक्स एल्गोरिथ्म में क्लासिक रूपांतरित करता है। यह मोडुलो 16 ( :f1+%) करता है और जाँचता है कि परिणाम <10 है ( :a(?)। यदि ऐसा नहीं है, तो हमें 7+ASCII तालिका में दशमलव से वर्णमाला तक जाने के लिए 7 ( ) जोड़ने की आवश्यकता है । और, हम 0 ( "0"+) के लिए ASCII मान जोड़कर और स्टैक के निचले भाग में आउटपुट होने के लिए चरित्र को शिफ्ट करके आगे बढ़ सकते हैं क्योंकि हमें उन्हें रिवर्स ऑर्डर में आउटपुट करना होगा। शीर्ष मान को इसके पूर्णांक विभाजन के परिणाम द्वारा 16 से बदल दिया जाता है। यह ए / बी - (ए / बी)% 1 ( f1+,:1%-) की गणना करके अनुकरण किया जाता है । जब लूप समाप्त हो जाता है, तो स्टैक में उल्टा आउटपुट ऑर्डर और 0 में हेक्साडेसिमल वर्ण होते हैं।

दूसरा पाश

!?:r<ro;

दूसरा लूप सूची को उलटता है और जांचता है कि क्या शीर्ष तत्व 0. है। यदि यह है, तो हम जानते हैं कि सभी नॉनज़रो प्रिंट किए गए थे और हमें समाप्त होना चाहिए। और, हम चरित्र को आउटपुट करते हैं और अगली पुनरावृत्ति की तैयारी के लिए सूची को फिर से रिवर्स करते हैं। :जब में प्रवेश दूसरा पाश 0 जो कोई प्रभाव नहीं है नकल करेंगे।

Answer 25

SpecBAS - 110 बाइट्स

1 h$="0123456789ABCDEF",r$=""
2 INPUT d
4 q=INT(d/16),r=d-(q*16),r$=h$(r+1)+r$,d=q
5 IF q>15 THEN 4
6  ?h$(q+1)+r$

यह एक एल्गोरिथ्म का उपयोग करता है जो मुझे WikiHow (दूसरी विधि) पर मिला है ।

SpecBAS में स्ट्रिंग्स 1-आधारित हैं, इसलिए +1सही तत्व को चुनना है।

Answer 26

सी (क्लैंग) , 83 बाइट्स

f(n){char h[8]={0};int i=8;while(i>0){h[i-1]=n%16;n/=16;printf("%x",h[8-i]);i--;}}

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

सी में वैकल्पिक समाधान

Answer 27

रूबी, 40 बाइट्स

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

h=->n{(n>15?h[n/16]:'')+(n%16).to_s(17)}

Answer 28

आरईएक्सएक्स, 80 78 बाइट्स

arg n
h=
do while n>0
  h=substr('0123456789ABCDEF',n//16+1,1)h
  n=n%16
  end
say h

Answer 29

सी, 48 बाइट्स

h(x){x/16&&h(x/16);x%=16;putchar(x+=48+x/10*7);}

यह पूरी तरह से मूल नहीं है, मैंने डिजिटल ट्रॉमा के संस्करण के 5 बाइट्स को काट दिया।

Answer 30

एपीएल (एनएआरएस), चार्ट्स 34, बाइट्स 68

{⍵≤0:,'0'⋄(∇⌊⍵÷16),(1+16∣⍵)⊃⎕D,⎕A}

परीक्षा:

  g←{⍵≤0:,'0'⋄(∇⌊⍵÷16),(1+16∣⍵)⊃⎕D,⎕A}
  g 0
0
  g 100
064
  g 1000
03E8
  g 1
01