0xUsernames

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

यदि किसी उपयोगकर्ता नाम में केवल वर्ण 0123456789ABCDEF(केस असंवेदनशील) होते हैं, तो इसे हेक्साडेसिमल में बदला जा सकता है और पूर्णांक के रूप में संग्रहीत किया जा सकता है। उदाहरण के लिए, उपयोगकर्ता नाम की ba5eba11व्याख्या 0xBA5EBA11हेक्साडेसिमल पूर्णांक के रूप में की जा सकती है ।

लेकिन इससे क्या 05AB1E? यह एक अग्रणी शून्य है, जो खो जाएगा। इसलिए, जब भी हम एक उपयोगकर्ता नाम परिवर्तित करते हैं, तो हम 1इसे पूर्णांक के रूप में पढ़ने से पहले सुनिश्चित करते हैं ।

चुनौती

आपका कार्य एक प्रोग्राम या फ़ंक्शन लिखना है, जिसने एक स्ट्रिंग के रूप में एक गैर-खाली उपयोगकर्ता नाम दिया है, 'हेक्सा-कंप्रेस' उपयोगकर्ता नाम:

यदि इसे हेक्साडेसिमल पूर्णांक के रूप में व्याख्या किया जा सकता है, तो 1 को पूर्वसर्ग करें, हेक्साडेसिमल के रूप में व्याख्या करें, और फिर परिणाम को आधार 10 के रूप में प्रिंट करें ।
अन्यथा, बस स्ट्रिंग अनमॉडिफाइड लौटाएं।

यह कोड-गोल्फ है , इसलिए सबसे छोटा समाधान (बाइट्स में) जीतता है! अंतर्निहित आधार रूपांतरण कार्यों की अनुमति है।

परीक्षण के मामलों

आप मान सकते हैं कि किसी भी परिणामी पूर्णांक आपकी भाषा के मानक पूर्णांक सीमा के भीतर हैं।

अधिकांश मैसेजिंग सिस्टम पर उपयोगकर्ता नाम के साथ, इनपुट स्ट्रिंग्स में केवल अल्फ़ान्यूमेरिक्स और अंडरस्कोर होंगे।

याद रखें, 1रूपांतरण से पहले आपको हमेशा एक अग्रणी जोड़ना होगा !

"ba5eba11" -> 7421737489
"05AB1E"   -> 17148702
"dec0de"   -> 31375582
"Beef"     -> 114415    
"da7aba5e" -> 7960443486
"500"      -> 5376

"DENNIS" -> "DENNIS"
"Garth"  -> "Garth"
"A_B_C"  -> "A_B_C"
"0x000"  -> "0x000"

संदर्भ के लिए, यहां एक पायथन 3 कार्यान्वयन है जिसे मैंने परीक्षण मामलों के लिए इस्तेमाल किया था (अपुष्ट):

import re

def convert_name(name):
    if re.fullmatch('^[0-9A-Fa-f]+$', name):
        return int('1' + name.upper(), base = 16)
    else:
        return name

— FlipTack
स्रोत

आह, यह नहीं देखा। इसके अलावा, क्या होगा अगर कुछ बड़े परीक्षण के मामले हमारी भाषा के सबसे बड़े पूर्णांक प्रकार की सीमा से बाहर की संख्या में हों?

— दरवाज़े

2

@ डॉर्कनोब अच्छा कैच। मैं कहूंगा कि परिणामी पूर्णांक आपकी भाषा के मानक पूर्णांक प्रकार से अधिक कभी नहीं होगा। (कृपया इसका दुरुपयोग न करें और 1-बिट पूर्णांक के साथ एक भाषा का उपयोग करें)

— FlipTack

क्या यह मान लेना ठीक है कि इनपुट केवल अपरकेस है?

— 16

@ क्षमा करें, लेकिन आपका कार्यक्रम असंवेदनशील होना चाहिए (परीक्षण मामलों को देखें)

— 18

यूनेरी की तरह इसे छोड़कर BF के बजाय यूज़रनेम एन्कोडिंग है

— MilkyWay90

27

05AB1E , 4 बाइट्स

D1ìH

व्याख्या

D    Duplicate input
 1ì  Prepend 1
   H Interpret as hexadecimal and implicitly display the value in base 10

यदि इनपुट में हेक्स वर्ण अमान्य हैं, Hतो कुछ भी धक्का नहीं देगा , इसलिए स्टैक पर अंतिम मान डुप्लिकेट किया गया इनपुट होगा, यही कारण है कि प्रोग्राम अमान्य इनपुट के मामले में इसके इनपुट को प्रिंट करता है।

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

— Osable
स्रोत

9

यहाँ विडंबना बहुत मजबूत है। 05AB1Eएक मान्य उपयोगकर्ता नाम है।

— devRicher

1

यह सही है, हालांकि नाम को हेक्साडेसिमल नंबर के रूप में चुना गया था । इसलिए यह मान्य है :)

— Osable

आश्चर्य है कि आप क्यों धोखा दे रहे थे। इसके बजाय $ का उपयोग करने का एक तरीका सोचने की कोशिश कर रहा है ....

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

16

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

s=>'0x1'+s-0||s

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

'0x1'+sइनपुट को शाब्दिक हेक्साडेसिमल स्ट्रिंग में एक पूर्वनिर्मित 1, जैसे के साथ परिवर्तित करता है 0x105ab1e। फिर -0परिणाम को एक संख्या पर रखता है। जावास्क्रिप्ट 0xशुरुआत में देखता है और स्पष्ट रूप से हेक्साडेसिमल से बदलने की कोशिश करता है; यदि sकोई गैर-हेक्साडेसिमल चार्ट शामिल है, तो यह रिटर्न करता है NaN। चूँकि यह मिथ्या है (और उत्पादन 0कभी नहीं दिया जा सकता है क्योंकि पूर्व निर्धारित है 1), हम उपयोग कर सकते ||sहैं sयदि हेक्स रूपांतरण विफल हुआ।

टेस्ट स्निपेट

f = s=>'0x1'+s-0||s

for(i of [
  "ba5eba11", "05AB1E", "dec0de", "Beef", "da7aba5e", "500",
  "DENNIS", "Garth", "A_B_C", "0x000"
]) console.log(i + ":", f(i));

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

— ETHproductions
स्रोत

2

बहुत अच्छा समाधान!

— Grax32

इम्प्लिक्ट कास्टिंग वाकई बहुत खूबसूरत है ...: ')

— डाउनगोट

10

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

एक उद्धृत स्ट्रिंग के रूप में इनपुट लेता है। रॉड के लिए -2 बाइट्स!

a=input()
try:exec'a=0x1'+a
except:1
print a

जैसा कि हम गारंटी देते हैं कि इनपुट में केवल अल्फ़ान्यूमेरिक्स और अंडरस्कोर होंगे, 0x1एक हेक्स स्ट्रिंग होने के अलावा वैध पायथन बनाने का कोई तरीका नहीं है । यदि इनपुट कुछ और है, तो त्रुटि को नजरअंदाज कर दिया जाता है, और यह मूल रूप से मुद्रण था।

मैं किसी भी छोटे से एक regex मैच बनाने के लिए प्रतीत नहीं कर सकता try/except। वास्तव में, रेगेक्स बहुत क्रियात्मक निकला:

import re
lambda n:re.match('^[0-9A-F]+$',n,2)and int('1'+n,16)or n

— FlipTack
स्रोत

आप के a=int('1'+a,16)साथ भी बदल सकते हैं exec'a=0x1'+a(शायद, परीक्षण की जरूरत है)

— रॉड

तुम्हें पता है, अगर मैं सही गोल्फिंग जारी रखने के लिए हम एक ही सटीक जवाब देने जा रहे हैं?

— एंथनी फाम

उपयोगकर्ता नाम के लिए काम नहीं करता है जो उस संदर्भ में मान्य पायथन होगा, उदा "+input()"।

— हेनरिच

"एबीसी" के लिए विफल रहता है (अंत में

— व्हॉट्सएप

मैं नहीं जानता कि वास्तव में कैसे यह अजगर 2 के लिए है, लेकिन मुझे लगता है कि आप कोष्ठक निकाल सकते हैं ()परinput()

— RudolfJelin

8

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

{:16(1~S/_/Z/)//$_}

झसे आज़माओ

विस्तारित:

{   # bare block lambda with implicit parameter ｢$_｣

    :16(     # convert from base 16
      1
      ~      # Str concatenated
      S/_/Z/ # replace an underscore with an invalid base 16 character
    )

  //         # defined or

    $_       # the input unchanged

}

— ब्रैड गिल्बर्ट b2gills
स्रोत

7

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

-1 बाइट थैंक्यू @ardnew ।

कोड + -pध्वज के 26 बाइट्स ।

$_=hex"1$_"if!/[^0-9a-f]/i

अंतिम न्यूलाइन के बिना इनपुट की आपूर्ति करें । साथ echo -nउदाहरण के लिए:

echo -n 05AB1E | perl -pe '$_=hex"1$_"if!/[^0-9a-f]/i'

स्पष्टीकरण
यह बहुत सीधे आगे है: /[^0-9a-f]/iयदि इनपुट में हेक्साडेसिमल संख्याओं के अंदर अनुमति के अलावा एक चरित्र है तो यह सच है। यदि यह गलत है, $_(जिसमें इनपुट है) तो यह परिवर्तित मान पर सेट है (रूपांतरण बिलिन द्वारा किया गया है hex)।
और झंडे $_के लिए स्पष्ट रूप से मुद्रित है -p।

— बापू
स्रोत

आप टर्नरी ऑपरेशन से बचकर बाइट शेव कर सकते हैं$_=hex"1$_"if!/[^0-9a-f]/i

— arnnew

@ardnew Hum, अब जब आप इसे कहते हैं, तो यह टर्नरी बहुत भयानक था ... वैसे भी, धन्यवाद!

— दादा

4

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

.xi+1z16z

फ्लैपैक के उत्तर के रूप में एक ही विचार । हेक्साडेसिमल-दशमलव रूपांतरण का प्रयास करें और इनपुट आउटपुट करें।

यहाँ यह कोशिश करो!

— गुरुपाद ममदापुर
स्रोत

3

बैच, 33 बाइट्स

@(cmd/cset/a0x1%1 2>nul)||echo %1

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

एक स्ट्रिंग को एक तर्क के रूप में पारित किया जाता है, 1 को इसके लिए तैयार किया जाता है, और स्ट्रिंग को स्पष्ट रूप से दशमलव में बदल दिया जाता है और मुद्रित किया जाता है। यदि स्ट्रिंग वैध हेक्साडेसिमल नहीं है, तो इसे बस प्रदर्शित किया जाता है।

यह ध्यान दिया जाना चाहिए कि चूंकि बैच गणित पर हस्ताक्षर किए गए 32-बिट पूर्णांक का उपयोग करता है, इसलिए सबसे बड़ा अनुमत उपयोगकर्ता नाम है FFFFFFF।

cmd /c अगला कमांड लेता है, इसे एक नए टर्मिनल में चलाता है, और बाहर निकलता है।

set /a गणित करता है और स्पष्ट रूप से दशमलव में परिणाम को प्रदर्शित करता है जब एक चर पर संग्रहीत नहीं किया जाता है।

0x1%1 पहले तर्क के लिए 1 को पूर्व निर्धारित करने के लिए सेट बताता है (यह आसान है क्योंकि सभी बैच चर स्ट्रिंग हैं) और इंगित करता है कि स्ट्रिंग को हेक्साडेसिमल के रूप में माना जाना चाहिए।

2>nul अमान्य हेक्साडेसिमल संख्या से उत्पन्न किसी भी त्रुटि को शांत करता है

||एक तार्किक है या दाईं ओर कमांड निष्पादित करता है यदि बाईं ओर कमांड सफल नहीं है। कोष्ठक इस बिंदु एक कमांड तक सब कुछ बनाते हैं।

echo %1 बस पहला तर्क प्रदर्शित करता है।

— SomethingDark
स्रोत

3

आम लिस्प, 71

(lambda(n)(or(ignore-errors(parse-integer(format()"1~A"n):radix 16))n))

टेस्ट

कार्य को परिभाषित करें

CL-USER> (lambda(n)(or(ignore-errors(parse-integer(format()"1~A"n):radix 16))n))
#<FUNCTION (LAMBDA (N)) {10041D213B}>

प्रश्न द्वारा दिए गए अपेक्षित इनपुट की सूची को उद्धृत करें:

CL-USER> '("ba5eba11" -> 7421737489
"05AB1E"   -> 17148702
"dec0de"   -> 31375582
"Beef"     -> 114415    
"da7aba5e" -> 7960443486
"500"      -> 5376

"DENNIS" -> "DENNIS"
"Garth"  -> "Garth"
"A_B_C"  -> "A_B_C"
"0x000"  -> "0x000")
("ba5eba11" -> 7421737489 "05AB1E" -> 17148702 "dec0de" -> 31375582 "Beef" ->
 114415 "da7aba5e" -> 7960443486 "500" -> 5376 "DENNIS" -> "DENNIS" "Garth" ->
 "Garth" "A_B_C" -> "A_B_C" "0x000" -> "0x000")

इसे पार्स करें और परिणाम एकत्र करें

CL-USER> (loop for (in _ out) on * by #'cdddr
               collect (list in out (funcall ** in)))
(("ba5eba11" 7421737489 7421737489) ("05AB1E" 17148702 17148702)
 ("dec0de" 31375582 31375582) ("Beef" 114415 114415)
 ("da7aba5e" 7960443486 7960443486) ("500" 5376 5376)
 ("DENNIS" "DENNIS" "DENNIS") ("Garth" "Garth" "Garth")
 ("A_B_C" "A_B_C" "A_B_C") ("0x000" "0x000" "0x000"))

जांचें कि अपेक्षित आउटपुट वास्तविक से मेल खाते हैं:

CL-USER> (every (lambda (x) (equalp (second x) (third x))) *)
T

— कोर निपात
स्रोत

2

सी, 108 बाइट्स

i;f(char*s){char*S=malloc(strlen(s)+2);*S=49;strcpy(S+1,s);sscanf(S,"%x%c",&i,&i)<2?printf("%d",i):puts(s);}

यह एक फ़ंक्शन है जो स्ट्रिंग को एक तर्क के रूप में लेता है और परिणाम को STDOUT में प्रिंट करता है।

i;                           // declare i as an int
f(char*s){
char*S=malloc(strlen(s)+2);  // allocate space for a new string with 1 more char
*S=49;                       // set the first char to '1' (ASCII 49)
strcpy(S+1,s);               // copy the original string to the remainder
sscanf(S,"%x%c",&i,&i)       // scan a hex integer followed by any char
<2?                          // if less than 2 items were scanned (i.e. the hex
                             // integer made up the entire string),
printf("%d",i)               // output the hex integer
:puts(s);}                   // otherwise, output the original string

— Doorknob
स्रोत

निहितार्थ का अच्छा उपयोग int:)

— FlipTack

2

जावास्क्रिप्ट: 46 41 बाइट्स

s=>/[^\dA-F]/i.test(s)?s:parseInt(1+s,16)

— ल्यूक
स्रोत

रेगेक्स 2 बाइट्स छोटा हो सकता है:/[^0-9a-f]/i

— गिल्ज़

मैं की जगह 1 बाइट बचाया 0-9द्वारा \dनिकाल कर केस-संवेदी ध्वज (धन्यवाद @GilZ) और 2 अधिक बाइट्स जोड़कर, 3 बाइट्स F=, जो जरूरत नहीं है। सलाह के लिये धन्यवाद।

— ल्यूक

2

PHP, 42 बाइट्स

हेक्स 2बीन () झूठा वापस आता है यदि इनपुट वैध हेक्स स्ट्रिंग नहीं है। यह गैर-हेक्स अंकों की तलाश के लिए रेगेक्स का उपयोग करने से कम है, लेकिन हमें @ ऑपरेटर की आवश्यकता है क्योंकि यह विफल होने पर चुप नहीं होता है।

<?=@hex2bin($s=$argv[1])?hexdec("1$s"):$s;

— एलेक्स हॉन्सस्की
स्रोत

hex2binअसमान लंबाई के साथ तार के लिए विफल रहता है। अभी भी दो बाइट्स की तुलना में कम है preg_match: <?=@hex2bin($s=$argv[1])|@hex2bin($s.a)?hexdec("1$s"):$s;57 बाइट्स के लिए।

— टाइटस

2

बैश, 46 35 31 बाइट्स

(echo $[0x1$1])2> >(:)||echo $1

स्क्रिप्ट के रूप में सहेजें, और उपयोगकर्ता नाम को एक तर्क के रूप में पास करें।

— मिशेल स्पेक्टर
स्रोत

1

अजगर 2 - 63, 52, 50, 46 बाइट्स

n=input()
try:n=int("1"+n,16)
except:1
print n

यह पायथन का उपयोग करता है int()जो किसी भी स्ट्रिंग को उसके उपयुक्त आधार के साथ 10 बेस में परिवर्तित करता है। इस मामले में, स्ट्रिंग इनपुट से जुड़ी संख्या 1 है। यदि इनपुट अमान्य है 0123456789ABCDEF(केस-असंवेदनशील) के अलावा अन्य वर्ण हैं , तो यह वापस आ जाता है ValueError:

n = input()                   # Get input (with quotes)
try:                          # Trying conversion to base 10
    n = int("1"+n,16)        
except:                       # If invalid string for base 36,
    1                         # do nothing to n
print n                       # Print result

यहाँ यह कोशिश करो!

15 बाइट बचाने के लिए @FlipTack का धन्यवाद!

— एंथोनी फाम
स्रोत

क्या होगा यदि स्ट्रिंग शून्य से शुरू नहीं होती है? यदि आप एक शून्य से शुरू करते हैं तो आपको केवल स्ट्रिंग के बाईं ओर एक जोड़ना चाहिए।

— 0WJYxW9FMN

@FlipTack वूप्स, मुझे मूर्ख।

— 0WJYxW9FMN

1

रूबी, 47 44 बाइट्स

p gets=~/^[a-f\d]+\s$/i?('1'+$&).to_i(16):$_

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

संपादित करें: नई अनुगामी putsके pरूप में परिवर्तित आमतौर पर स्वीकार किए जाते हैं, धन्यवाद @Mego।

— साइमन लैंड्री
स्रोत

STDOUT पर नई अनुगामी आमतौर पर स्वीकार्य मानी जाती हैं।

— मेघो

1

जाप , 11 बाइट्स

+`0x1{U}`ªU

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

ETHproductions के लिए बड़ा धन्यवाद!

— ओलिवर
स्रोत

1

यह उन दुर्लभ मामलों में से एक है जहां आप अंतरिक्ष से छुटकारा पा सकते हैं :-) (इसके अलावा, TIO लिंक "हैलो, वर्ल्ड!" प्रोग्राम)

— ETHproductions

1

डायलाग एपीएल , 37 बाइट्स

कोई अंतर्निहित मान्यता या हेक्स-डिक रूपांतरण का उपयोग करता है। ⎕IO←0कई सिस्टम पर डिफ़ॉल्ट की आवश्यकता होती है।

{∧/(u←1(819⌶)⍵)∊d←⎕D,6↑⎕A:16⊥1,d⍳u⋄⍵}

Ungolfed:

{
    d ← ⎕D , 6 ↑ ⎕A
    u←1 (819⌶) ⍵
    ∧/ u ∊ d: 16 ⊥ 1 , d ⍳ u
    ⍵
}

d ← ⎕D , 6 ↑ ⎕A घ हो जाता है डी के पहले 6 तत्वों द्वारा पीछा igits एक lphabet

u ← 1 (819⌶) ⍵ यू अपरकेस (819 u "बिग") तर्क देता है

∧/ u ∊ d: यदि u के सभी तत्व d के सदस्य हैं , तो: d में u
16 ⊥ 1 , d ⍳ u के सूचकांकों को खोजें , 1 को prepend करें, और बेस 16 के रूप में मूल्यांकन करें।

⍵ और: (अनमॉडिफाइड) तर्क लौटाएं

TryAPL ऑनलाइन:

— एडम
स्रोत

1

REXX, 49 48 बाइट्स

signal on syntax
pull a
a=x2d(1||a)
syntax:
say a

signal on syntaxदुभाषिया बताता लेबल के लिए कूद करने syntaxके लिए जब भी एक सिंटैक्स त्रुटि उत्पन्न होती है। कार्यक्रम aएक प्रमुख 1 के साथ हेक्स-टू-दशमलव परिवर्तित संस्करण के साथ पुन: असाइन करने का प्रयास करता है , लेकिन syntaxविफल होने पर लेबल पर कूदता है । यदि रूपांतरण पास नहीं होता है, तो यह केवल लेबल को अनदेखा करता है और पुन: असाइन किए गए चर को आउटपुट करता है।

— idrougge
स्रोत

2

क्या आप अपना कोड स्पष्ट कर सकते हैं

— एंथनी फाम

0

पॉवरशेल , 35 बाइट्स

param($v)(($h="0x1$v"|iex),$v)[!$h]

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को चलाएं!

व्याख्या

पैरामीटर ( $v) लें
एक दो-तत्व सरणी बनाएं जहां पहला तत्व ( 0) एक स्ट्रिंग का परिणाम है जिसमें 0x1$vपाइप किया गया है Invoke-Expression( iex), साथ ही साथ इस मान को असाइन करते हैं $h। यदि रूपांतरण विफल रहता है, $hतो रहेगा $null।
सरणी का दूसरा तत्व मूल पैरामीटर है।
के बूलियन -notमूल्य के साथ सरणी में सूचकांक $h। जो $hकुछ भी कथित रूप से परिवर्तित हो जाएगा [bool]( $nullएक अवैध रूपांतरण के मामले में $false, एक सफल रूपांतरण के मामले में एक सकारात्मक पूर्णांक बन जाएगा $true) नकारात्मक होने से पहले, जो बाद [int]में सरणी अनुक्रमक द्वारा परिवर्तित किया जाएगा []( $trueहोगा 1, $falseहोगा) 0), इस प्रकार सरणी का पहला तत्व (रूपांतरण परिणाम) चुना गया अगर रूपांतरण सफल रहा, और दूसरा तत्व चुना गया अगर रूपांतरण असफल रहा।

— briantist
स्रोत

0

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

s=>try{BigInt("1"+s,16)}catch{case e=>s}

उपयोग:

val f:(String=>Any)=s=>try{BigInt("1"+s,16)}catch{case e=>s}
f("ba5eba11") //returns 7421737489

स्पष्टीकरण:

s=>                //define a anonymous function with a parameter called s
  try {              //try...
    BigInt("1"+s,16)   //to contruct a BigInt from "1" prepended to the number, parsing it as base 16
  } catch {          //if the constructor throws an exception
    case e =>          //in case of an execption which we'll call e
      s                  //return s
  }

— corvus_192
स्रोत

0

सी #, 58 बाइट्स

u=>{try{u=Convert.ToInt64("1"+u,16)+"";}catch{}return u;};

परीक्षण के मामलों के साथ असंगत:

using System;
class Class
{
    public static void Main()
    {
        Func<string, string> convert = 
            u=>
            {
                try
                {
                    u = Convert.ToInt64("1" + u, 16) //Prepends "1" and tries to convert the string to and integer using base 16.
                        + ""; //Appending an empty string converts the integer to a string. Shorter than calling .ToString()
                }
                catch { } //If the conversion fails catch the exception and discard it.
                return u; //Return the result, or the unmodified input if the conversion failed.
            };

        Console.WriteLine(convert("ba5eba11"));
        Console.WriteLine(convert("05AB1E"));
        Console.WriteLine(convert("dec0de"));
        Console.WriteLine(convert("Beef"));
        Console.WriteLine(convert("da7aba5e"));
        Console.WriteLine(convert("500"));
        Console.WriteLine(convert("DENNIS"));
        Console.WriteLine(convert("Garth"));
        Console.WriteLine(convert("A_B_C"));
        Console.WriteLine(convert("0x000"));
        Console.Read();
    }
}

ऑनलाइन कोशिश करें

— raznagul
स्रोत

0

डार्ट, 51 बाइट्स

(s)=>int.parse('1$s',radix:16,onError:(_)=>null)??s

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

ओवरहेड का ज्यादातर नाम नामित मापदंडों से आता है ... ओह ठीक है!

यदि आप चाहते हैं तो कम से कम डार्ट आपको गतिशील रूप से टाइप करने देता है: डी

— ड्वेन स्लेटर
स्रोत

"0xUsernames" परिवर्तित करना

0xUsernames

चुनौती

परीक्षण के मामलों

05AB1E , 4 बाइट्स

व्याख्या

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

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

टेस्ट स्निपेट

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

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

विस्तारित:

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

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

बैच, 33 बाइट्स

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

आम लिस्प, 71

टेस्ट

सी, 108 बाइट्स

जावास्क्रिप्ट: 46 41 बाइट्स

PHP, 42 बाइट्स

बैश, 46 35 31 बाइट्स

अजगर 2 - 63, 52, 50, 46 बाइट्स

रूबी, 47 44 बाइट्स

जाप , 11 बाइट्स

डायलाग एपीएल , 37 बाइट्स

REXX, 49 48 बाइट्स

पॉवरशेल , 35 बाइट्स

व्याख्या

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

सी #, 58 बाइट्स

डार्ट, 51 बाइट्स