एक हालिया डेली डब्ल्यूटीएफ लेख से प्रेरित ...

एक प्रोग्राम या फ़ंक्शन लिखें जो GUID लेता है (प्रारूप में स्ट्रिंग XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX, जहां प्रत्येक X एक हेक्साडेसिमल अंक का प्रतिनिधित्व करता है), और एक से बढ़े हुए GUID को आउटपुट करता है।

उदाहरण

>>> increment_guid('7f128bd4-b0ba-4597-8f35-3a2f2756dfbb')
'7f128bd4-b0ba-4597-8f35-3a2f2756dfbc'
>>> increment_guid('06b86883-f3e7-4f9d-87c5-a047e89a19fa')
'06b86883-f3e7-4f9d-87c5-a047e89a19fb'
>>> increment_guid('89f25f2f-2f7b-4aa6-b9d7-46a98e3cb2cf')
'89f25f2f-2f7b-4aa6-b9d7-46a98e3cb2d0'
>>> increment_guid('89f25f2f-2f7b-4aa6-b9d7-46a98e3cb29f')
'89f25f2f-2f7b-4aa6-b9d7-46a98e3cb2a0'
>>> increment_guid('8e0f9835-4086-406b-b7a4-532da46963ff')
'8e0f9835-4086-406b-b7a4-532da4696400'
>>> increment_guid('7f128bd4-b0ba-4597-ffff-ffffffffffff')
'7f128bd4-b0ba-4598-0000-000000000000'

लिंक किए गए लेख के विपरीत, एफ में समाप्त होने वाले GUID को बढ़ाकर पिछले हेक्स अंक को "कैरी" करना चाहिए। ऊपर के उदाहरण देखें।
आप मान सकते हैं कि इनपुट नहीं होगा ffffffff-ffff-ffff-ffff-ffffffffffff।
9 से ऊपर के हेक्स अंकों के लिए, आप ऊपरी (AF) या निचले (af) केस का उपयोग कर सकते हैं।
हाँ, GUIDs a से शुरू हो सकते हैं 0।
आपका आउटपुट से मिलकर चाहिए वास्तव में 32 हेक्स अंक और उम्मीद प्रारूप में 4 हाइफ़न, किसी भी आवश्यक प्रमुख सहित 0रों।
आपको GUID के संस्करण संख्या या अन्य निश्चित बिट्स को संरक्षित करने की आवश्यकता नहीं है। मान लें कि यह केवल 128-बिट पूर्णांक है जहां बिट्स में से कोई भी विशेष अर्थ नहीं है। इसी तरह, GUID को एक Windows GUIDसंरचना के द्विआधारी क्रम के बजाय सीधे लेक्सोग्राफिक क्रम में क्रमबद्ध करने के लिए माना जाता है ।
यदि एक समारोह लेखन, इनपुट किसी भी क्रम के- का हो सकता है charडेटा प्रकार: string, char[], List<char>, आदि

code-golf

— dan04
स्रोत

1

क्या हम UUIDv4 बरकरार 6 तय बिट्स को छोड़ने वाले हैं?

— फिलिप हगलुंड

2

@FilipHaglund: नहीं, बस GUID को 128-बिट संख्या के रूप में मानते हैं, जहां बिट्स का कोई विशेष अर्थ नहीं है। इसी तरह, GUID को एक Windows GUIDसंरचना के द्विआधारी क्रम के बजाय सीधे शाब्दिक क्रम में क्रमबद्ध करने के लिए माना जाता है ।

— 04

3

सुझाया गया परीक्षण मामला: 89f25f2f-2f7b-4aa6-b9d7-46a98e3cb29fयह सुनिश्चित करने के लिए कि उत्तर संक्रमण कर सकते हैं 9 -> a।

— कामिल दकरी

1

@dana: आप किसी भी डेटा प्रकार का उपयोग कर सकते हैं जिसके लिए आपकी भाषा C # के समकक्ष foreach (char ch in theInput)मान्य है।

— 04

7

05AB1E , 17 15 18 बाइट्स

सहेजे गए 2 बाइट्स के लिए धन्यवाद केविन क्रूज़सेन के बचाए

'-K1ìH>h¦Ž¦˜S·£'-ý

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

'-K                  # remove "-" from input
   1ì                # prepend a 1 (to preserve leading 0s)
     H               # convert from hex to base 10
      >              # increment
       h             # convert to hex from base 10
        ¦            # remove the extra 1
         Ž¦˜S·       # push [8, 4, 4, 4, 12]
              £      # split into parts of these sizes
               '-ý   # join on "-"

— Emigna
स्रोत

डांग, तुमने मुझे इसके लिए हराया .. कुछ बहुत समान था, लेकिन žKÃइसके बजाय '-K। Btw, आप को बदलने के द्वारा 2 बाइट्स बचा सकते हैं •É]•S3+करने के लिए Ž¦˜S·।

— केविन क्रूज़सेन

@ केविनक्रूजसेन: धन्यवाद! मैं नहीं जानता कि कितनी बार मैं भूल गया हूँ कि Žअब एक बात है ...

— Emigna

मैंने इस उत्तर को स्वीकार नहीं किया क्योंकि किसी ने बताया कि यह 0 के प्रमुख को छोड़ देगा। कृपया ठीक करें।

— dan04

@ dan04: अच्छा फोन! मैंने ऐसा नहीं सोचा था। अब तय होना चाहिए :)

— एमिगा

20

अजगर 2 , 50

3 बाइट्स @ डेनिस की बदौलत बच गए।

lambda s:UUID(int=UUID(s).int+1)
from uuid import*

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

— डिजिटल आघात
स्रोत

11

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

आउटपुट स्ट्रिंग लोअरकेस में है।

s=>(g=(c,x=+('0x'+s[--n])+!!c)=>1/x?g(x>>4)+(x&15).toString(16):~n?g(c)+'-':'')(n=36)

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

टिप्पणी की गई

s => (                   // s = GUID
  g = (                  // g = recursive function taking:
    c,                   //   c = carry from the previous iteration
    x = +('0x' + s[--n]) //   x = decimal conversion of the current digit
        + !!c            //       add the carry
  ) =>                   //
    1 / x ?              // if x is numeric:
      g(x >> 4) +        //   do a recursive call, using the new carry
      (x & 15)           //   and append the next digit
      .toString(16)      //   converted back to hexadecimal 
    :                    // else:
      ~n ?               //   if n is not equal to -1:
        g(c)             //     do a recursive call, leaving the current carry unchanged
        + '-'            //     and append a hyphen
      :                  //   else:
        ''               //     stop recursion
)(n = 36)                // initial call to g with n = 36 and a truthy carry

— Arnauld
स्रोत

5

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

q='f0123456789abcdef--'
f=lambda s:[str,f][s[-1]in'f-'](s[:-1])+q[q.find(s[-1])+1]

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

कोई आयात या हेक्स रूपांतरण।

यह स्ट्रिंग के पीछे से स्कैन करता है, प्रत्येक वर्ण को चक्र के साथ ले जाता है 0123456789abcdef, -अपने आप से जा रहा है। इसके बाद fया -इसके अलावा एक प्रतीक को हिट करने के बाद , यह बाईं ओर स्कैन करना बंद कर देता है, और बस शेष अपरिवर्तित रिटर्न देता है। यह समाधान यूयूआईडी प्रारूप के लिए विशिष्ट नहीं है - हेक्स पत्रों के किसी भी संख्या के ब्लॉक में से कोई भी काम करेगा।

का आधार मामला [str,f][s[-1]in'f-'](s[:-1])एक चाल है जिसे मैंने पहले गोल्फ में इस्तेमाल नहीं किया था। यह किसी भी बिना प्रत्यावर्तन समाप्त हो जाता है if, and,or , या अन्य स्पष्ट नियंत्रण प्रवाह।

[s[-1]in'f-']अंतिम चरित्र की स्थिति के आधार पर , कोड या तो वापस आ जाता है f(s[:-1])या बस s[:-1]अपरिवर्तित रहता है। चूंकि strस्ट्रिंग्स पर पहचान है, हम किसी एक फ़ंक्शन का चयन कर सकते हैं [str,f]और इसे लागू कर सकते हैं s[:-1]। ध्यान दें कि fअगर यह चुना नहीं जाता है, तो पुनरावर्ती कॉल सामान्य समस्या समस्या के आसपास हो रही है जो पायथन उत्सुकता से अप्रयुक्त विकल्पों का मूल्यांकन करता है, जिससे पुनरावृत्तियों में अनंतता आ जाती है।

— XNOR
स्रोत

खैर, वहाँ सुबह के लिए मेरा दिमाग चला जाता है।

— उज्ज्वल

3

एपीएल (Dyalog यूनिकोड) , 46 बाइट्स ^SBCS

बेनामी tacit उपसर्ग समारोह।

⎕CY'dfns'
(∊1hex 16(|+1⌽=)⍣≡1+@32dec¨)@('-'≠⊢)

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

⎕CY'dfns' c op y "dfns" लाइब्रेरी (पाने के लिए hexऔरdec )

(... )
⊢ तर्क
≠ से भिन्न
'-' एक पानी का छींटा
(... )@ स्थानों से मिलकर सबसेट पर पर जो ऊपर कसौटी सच है, लागू होते हैं:
dec¨ एक दशमलव संख्या के लिए प्रत्येक हेक्साडेसिमल चरित्र परिवर्तित
... @32 पर स्थिति 32 (अंतिम अंक), लागू होते हैं:
1+ वेतन वृद्धि
16(... )⍣≡ बार-बार के साथ लागू बाएं तर्क 16 को स्थिर होने तक:
= तुलना करें (मुखौटा देता है जहां हेक्साडेसिमल अंक 16 हैं)
1⌽ चक्रीय रूप से एक कदम छोड़ दिया (यह कैरी बिट है)
|+ उस पर, विभाजन को शेष जोड़ें जब विभाजित (सोलह से, इस प्रकार सभी 16 को 0 में बदल दें ) लंबाई-एक हेक्साडेसिमल चरित्र अभ्यावेदन में अंक ε nlist (समतल)
1hex
∊

— एडम
स्रोत

3

जावा 11, 152 149 111 108 बाइट्स

s->{var b=s.getLeastSignificantBits()+1;return new java.util.UUID(s.getMostSignificantBits()+(b==0?1:0),b);}

-38 बाइट्स के लिए धन्यवाद @ OlivierGrégoire ।
-3 बाइट्स @ ASCII- केवल के लिए धन्यवाद ।

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

स्पष्टीकरण:

s->{         // Method with UUID as both parameter and return-type
  var b=s.getLeastSignificantBits()
             //  Get the 64 least significant bits of the input-UUID's 128 bits as long
        +1;  //  And increase it by 1
  return new java.util.UUID(
             //  Return a new UUID with:
    s.getMostSignificantBits()
             //   The 64 most significant bits of the input-UUID's 128 bits as long
    +(b==0?  //    And if the 64 least significant bits + 1 are exactly 0:
       1     //     Increase the 64 most significant bits by 1 as well
      :      //    Else:
       0,    //     Don't change the 64 most significant bits by adding 0
     b);}    //   And the 64 least significant bits + 1

पुराने 149 बाइट्स उत्तर:

s->{var t=new java.math.BigInteger(s.replace("-",""),16);return(t.add(t.ONE).toString(16)).replaceAll("(.{4})".repeat(5)+"(.*)","$1$2-$3-$4-$5-$6");}

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

स्पष्टीकरण:

s->{                              // Method with String as both parameter and return-type
  var t=new java.math.BigInteger( //  Create a BigInteger
         s.replace("-",""),       //  Of the input-string with all "-" removed
         16);                     //  Converted from Hexadecimal
  return(t.add(t.ONE)             //  Add 1
         .toString(16))           //  And convert it back to a Hexadecimal String
         .replaceAll("(.{4})".repeat(5)+"(.*)",
                                  //  And split the string into parts of sizes 4,4,4,4,4,rest
           "$1$2-$3-$4-$5-$6");}  //  And insert "-" after parts of size 8,4,4,4,
                                  //  and return it as result

— केविन क्रूज़सेन
स्रोत

1

111 बाइट्स

— ओलिवियर ग्रेजायर

@ OlivierGrégoire ने वास्तविक UUID का उपयोग करने के बारे में नहीं सोचा था! अच्छा और छोटा विकल्प। : डी

— केविन क्रूज़सेन

1

109

— एएससीआईआई-केवल

लंबे समय के बजाय संस्करण के साथ -1 अधिक

— एएससीआईआई-केवल

3

रूबी `-pl` , 62 57 55 बाइट्स

$_="%032x"%-~gsub(?-,"").hex
7.step(22,5){|i|$_[i]+=?-}

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

— किरिल एल।
स्रोत

3

पायथन 3 , 50 बाइट्स

from uuid import*
lambda u:UUID(int=UUID(u).int+1)

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

— Draconis
स्रोत

2

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

def f(s):a=hex(int(s.replace('-',''),16)+1+2**128);return'-'.join((a[3:11],a[11:15],a[15:19],a[19:23],a[23:-1]))

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

बिना आयात के

— TFeld
स्रोत

2

रेटिना 0.8.2 , 21 बाइट्स

T`FfdlL`0dlL`.[-Ff]*$

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण मामले शामिल हैं। 9बन जाता है a। स्पष्टीकरण: रेगेक्स सभी अनुवर्ती fएस और -एस प्लस एक पूर्ववर्ती चरित्र से मेल खाता है । लिप्यंतरण तब उन वर्णों को चक्रीय रूप से बढ़ाता है जैसे कि वे हेक्स अंक थे। वैकल्पिक दृष्टिकोण, भी 21 बाइट्स:

T`L`l
T`fo`dl`.[-f]*$

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण मामले शामिल हैं। लिप्यंतरण को सरल बनाने के लिए इनपुट को कम करके काम करता है। इसलिए 15 बाइट्स होगी यदि उसे केवल लोअरकेस का समर्थन करना था। इसे ऑनलाइन आज़माएं! लिंक में परीक्षण मामले शामिल हैं।

— नील
स्रोत

2

MATLAB, 138 बाइट्स

a=1;Z=a;for r=flip(split(input(''),'-'))'
q=r{:};z=dec2hex(hex2dec(q)+a,nnz(q));try
z+q;a=0;catch
z=~q+48;end
Z=[z 45 Z];end;disp(Z(1:36))

एक बग के मामले में एक बग फिक्स्ड सभी शून्य है। इसके अलावा कोशिश / कैच को गाली देकर बहुत कुछ हासिल किया। नेट परिणाम: 0 बाइट्स सहेजे गए।

java.util.UUIDविफल का उपयोग करके 'धोखा' देने का प्रयास क्योंकि longमूल्य से लौटा गया जो कि सटीकता की हानि में java.util.UUID.get[Most/Least]SignificantBitsपरिवर्तित हो जाता है double। मैं आपको इस तालिका पर एक नज़र डालने और चुपचाप बोलने के लिए आमंत्रित करता हूं "... लेकिन क्यों? "

व्याख्या

hex2decसमारोह spits एक बाहर double, तो यह एक बार से अधिक से बचने के लिए पर पूरे GUID संसाधित नहीं कर सकता flintmax। इसके बजाय, हमें उपयोग करके, chunck द्वारा GUID चंक को संसाधित करना होगा split। चरaअगर हम एक को ले जाने की जरूरत है, तो जाँचता है, और धोखा भी प्रारंभिक वेतन वृद्धि है जो हम जोड़ते हैं। ले जाने के लिए शर्त यह है कि मूल और बढ़े हुए तारों की लंबाई अब समान नहीं है।

मूल संस्करण सिर्फ 160 बाइट्स के तहत था इसलिए मैं यह सोचना चाहता हूं कि यह आसान नहीं होना चाहिए।

— Sanchises
स्रोत

2

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

s='%032x'%-~int(input().replace('-',''),16)
print'-'.join((s[:8],s[8:12],s[12:16],s[16:20],s[20:]))

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

कोई uuid.UUIDफायदा नहीं ।

— आउटग्रॉफर को एरिक करें
स्रोत

2

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 77 बाइट्स

x=>{for(int i=35,c;(x[i]=(char)((c=x[i--])<48?c:c==57?65:c>69?48:c+1))<49;);}

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

-1 बाइट @ASCIIOnly को धन्यवाद!

अनाम फ़ंक्शन जो char[]इनपुट के रूप में लेता है और एक तर्क को संशोधित करके आउटपुट करता है ।

इनपुट को दाईं से बाईं ओर स्कैन किया जाता है और निम्नलिखित नियमों का उपयोग करके प्रतिस्थापित किया जाता है।

-चरित्र को नजरअंदाज कर दिया जाता है और प्रसंस्करण के लिए जारी
Fचरित्र में बदल जाती है 0और प्रसंस्करण के लिए जारी
9चरित्र में बदल जाती है Aऔर प्रसंस्करण बंद हो जाता है
वर्ण A-Eऔर 0-81 और प्रसंस्करण बंद हो जाता है से बढ़ती है,

— दाना
स्रोत

2

==70->>69

— ASCII- केवल

बहुत बढ़िया - धन्यवाद :)

— दाना

2

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

for($p=1;$d=+"$args"[--$i]){$d+=$p*(1-@{45=1;57=-7;70=23;102=55}.$d)
$p*=$d-in45,48
$r=[char]$d+$r}$r

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

कोई बाहरी पुस्तकालय या हेक्स रूपांतरण नहीं। किसी भी तार की लंबाई। लोअर केस और अपर केस की अनुमति है। इनपुट स्ट्रिंग मिलान ^[f-]*$की भी अनुमति है।

यह स्क्रिप्ट स्ट्रिंग के पीछे से स्कैन करती है और हैशटेबल के मान से प्रत्येक वर्ण को बढ़ाती है:

-: वेतन वृद्धि = 1-1
9: वेतन वृद्धि = १ + 1, परिणाम =A
F: वेतन वृद्धि = 1-23, परिणाम =0
f: वेतन वृद्धि = 1-55, परिणाम =0
वेतन वृद्धि = अन्य चार्ट के लिए 1

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

टेस्ट स्क्रिप्ट:

$f = {

for($p=1;$d=+"$args"[--$i]){$d+=$p*(1-@{45=1;57=-7;70=23;102=55}.$d)
$p*=$d-in45,48
$r=[char]$d+$r}$r

}

@(
    ,('f','0')
    ,('F','0')
    ,('0','1')
    ,('9','A')
    ,('A','B')
    ,('a','b')
    ,('0-f','1-0')
    ,('0-F','1-0')
    ,("7f128bd4-b0ba-4597-8f35-3a2f2756dfbb","7f128bd4-b0ba-4597-8f35-3a2f2756dfbc")
    ,("06b86883-f3e7-4f9d-87c5-a047e89a19f9","06b86883-f3e7-4f9d-87c5-a047e89a19fa")
    ,("89f25f2f-2f7b-4aa6-b9d7-46a98e3cb2cf","89f25f2f-2f7b-4aa6-b9d7-46a98e3cb2d0")
    ,("8e0f9835-4086-406b-b7a4-532da46963ff","8e0f9835-4086-406b-b7a4-532da4696400")
    ,("7f128bd4-b0ba-4597-ffff-ffffffffffff","7f128bd4-b0ba-4598-0000-000000000000")
    ,("89f25f2f-2f7b-4aa6-b9d7-46a98e3cb29f","89f25f2f-2f7b-4aa6-b9d7-46a98e3cb2a0")
    ,("ffffffff-ffff-ffff-ffff-ffffffffffff","00000000-0000-0000-0000-000000000000")
) | % {
    $guid,$expected = $_
    $result = &$f $guid
    "$($result-eq$expected): $result"
}

आउटपुट:

True: 0
True: 0
True: 1
True: A
True: B
True: b
True: 1-0
True: 1-0
True: 7f128bd4-b0ba-4597-8f35-3a2f2756dfbc
True: 06b86883-f3e7-4f9d-87c5-a047e89a19fA
True: 89f25f2f-2f7b-4aa6-b9d7-46a98e3cb2d0
True: 8e0f9835-4086-406b-b7a4-532da4696400
True: 7f128bd4-b0ba-4598-0000-000000000000
True: 89f25f2f-2f7b-4aa6-b9d7-46a98e3cb2A0
True: 00000000-0000-0000-0000-000000000000

— Mazzy
स्रोत

1

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

{(:16(TR/-//)+1).base(16).comb.rotor(8,4,4,4,*)».join.join('-')}

झसे आज़माओ

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

1

ओपी ने स्पष्ट किया है कि अग्रणी जीरो को संरक्षित किया जाना चाहिए।

— डेनिस

अग्रणी ज़ीरो के साथ 56 बाइट्स

— जो किंग

1

या 53 बाइट्स को अधिक मैन्युअल रूप से संभाल कर

— जो किंग

1

जेली , २० बाइट्स

-2 (और एक बग फिक्स) डेनिस के लिए धन्यवाद!

ØhiⱮṣ0µẎḅ⁴‘ḃ⁴ịØhṁj”-

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

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

1

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

$a=("{0:X32}" -f (1+[Numerics.BigInteger]::Parse($args[0]-replace"-", 'AllowHexSpecifier')));5..2|%{$a=$a.Insert(4*$_,"-")};$a

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

सुंदर तुच्छ उत्तर। बस सोचा था कि मैं प्रिय PowerShell सूची में जोड़ा जाएगा :)

— KGlasier
स्रोत

1

जावास्क्रिप्ट (Node.js) , 78 बाइट्स

s=>s.replace(/.([f-]*)$/,(s,y)=>('0x'+s[0]-~0).toString(16)+y.replace(/f/g,0))

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

— TSH
स्रोत

0

पर्ल 5, 64 बाइट्स

$c=reverse((1+hex s/-//gr)->as_hex);$c=~s/..$//;s/[^-]/chop$c/ge

यहाँ आवश्यक कोष्ठकों की संख्या मुझे दुखी करती है, लेकिन ->बहुत कसकर बांधती है, जैसे->as_hex कि मुझे हेक्साडेसिमल-स्वरूपित आउटपुट प्राप्त करने का सबसे तेज तरीका है।

साथ चलाना perl -Mbigint -p। मूल रूप से, यह सिर्फ संख्या को एक बड़े आकार के हेक्साडेसिमल में रूपांतरित करता है, एक जोड़ता है, और फिर परिणाम के अंकों को मूल मूल्य में वापस घटा देता है, जो डैश को अछूता छोड़ देता है।

— सिल्वियो मायोलो
स्रोत

0

जंग, 258 बाइट्स

let x=|s:&str|s.chars().rev().scan(1,|a,c|{let d=c.to_digit(16).unwrap_or(99);match(d,*a){(15,1)=>{*a=1;Some(0)}(0..=14,1)=>{*a = 0;Some(d + 1)}_=> Some(d),}}).collect::<Vec<u32>>().iter().rev().for_each(|d| print!("{}", std::char::from_digit(*d, 16).unwrap_or('-')));

हाँ इसकी लंबी .. लेकिन तकनीकी तौर पर 1 अभिव्यक्ति के साथ इसकी केवल एक पंक्ति है? और कोई फैंसी लाइब्रेरी नहीं? और यह एक फजी इनपुट पर दुर्घटना नहीं करेगा? ungolf:

let x=|s:&str|s.chars().rev().scan(1, |a, c| {
            let d = c.to_digit(16).unwrap_or(99);
            match (d, *a) {
                (15, 1) => {*a = 1;Some(0)}
                (0..=14, 1) => {*a = 0;Some(d + 1)}
                _ => Some(d),
            }
        }).collect::<Vec<u32>>().iter().rev()
        .for_each(|d| print!("{}", std::char::from_digit(*d, 16).unwrap_or('-')));

जंग के खेल के मैदान पर इसे आज़माएं

— चमकाओ
स्रोत

btw आपको व्हाट्सएप की आवश्यकता नहीं है

— ASCII-only

0

16/32/64-बिट x86 असेंबली कोड, 28 बाइट्स

बाइट्स: 83C623FDAC3C2D74FB403C3A7502B0613C677502B03088460173E9C3

कोड:

     add esi, 35       ;point to end of string - 1
     std               ;go backwards
l1:  lodsb             ;fetch a character
     cmp al, '-'
     je  l1            ;skip '-'
     inc eax           ;otherwise increment
     cmp al, '9' + 1
     jne l2            ;branch if not out of numbers
     mov al, 'a'       ;otherwise switch '9'+1 to 'a'
l2:  cmp al, 'f' + 1   ;sets carry if less
     jne l3            ;branch if not out of letters
     mov al, '0'       ;otherwise switch 'f'+1 to '0'
                       ;and carry is clear
l3:  mov [esi + 1], al ;replace character
     jnb l1            ;and loop while carry is clear
     ret

GUID की ओर इशारा करते हुए ईएसआई के साथ कॉल करें। 16-बिट के लिए एसआई के साथ ईएसआई को बदलें, या 64-बिट (और +2 बाइट्स) के लिए आरएसआई।

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

0

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

g(char*i){for(i+=36;(*--i-45?*i+=*i-70?*i-57?1:8:-22:0)<49;);}

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

— AZTECCO
स्रोत

रुकिए। क्या लोअरकेस / अपरकेस जाँच से कुछ भी खर्च नहीं होता है ???

— एएससीआईआई-केवल

मेरा मतलब है, यह लोअरकेस और दोनों को संभाल सकता है अपरकेस को बिना किसी लागत के संभाल सकता है ?!

— ASCII- केवल

आह ठीक है .. ch-70% 32? : '0' के लिए ... 64 और 96 32 के कई हैं इसलिए 70-6 और 102-6% 32।

— AZTECCO

1

आपको वास्तव में दोनों को संभालना नहीं है, इसलिए 64

— ASCII- केवल

0

आम लिस्प, 166 बाइट्स

(lambda(s &aux(r(format()"~32,'0x"(1+(parse-integer(remove #\- s):radix 16)))))(format()"~{~a~^-~}"(mapcar(lambda(x y)(subseq r x y))#1='(0 8 12 16 20 32)(cdr #1#))))

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

— रेंज़ो
स्रोत

एक GUID बढ़ाना

उदाहरण

टिप्पणियाँ

05AB1E , 17 15 18 बाइट्स

अजगर 2 , 50

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

टिप्पणी की गई

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

एपीएल (Dyalog यूनिकोड) , 46 बाइट्स ^SBCS

जावा 11, 152 149 111 108 बाइट्स

रूबी `-pl` , 62 57 55 बाइट्स

पायथन 3 , 50 बाइट्स

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

रेटिना 0.8.2 , 21 बाइट्स

MATLAB, 138 बाइट्स

व्याख्या

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

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 77 बाइट्स

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

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

जेली , २० बाइट्स

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

जावास्क्रिप्ट (Node.js) , 78 बाइट्स

पर्ल 5, 64 बाइट्स

जंग, 258 बाइट्स

16/32/64-बिट x86 असेंबली कोड, 28 बाइट्स

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

आम लिस्प, 166 बाइट्स

एक GUID बढ़ाना

उदाहरण

टिप्पणियाँ

05AB1E , 17 15 18 बाइट्स

अजगर 2 , 50

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

टिप्पणी की गई

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

एपीएल (Dyalog यूनिकोड) , 46 बाइट्स SBCS

जावा 11, 152 149 111 108 बाइट्स

रूबी -pl , 62 57 55 बाइट्स

पायथन 3 , 50 बाइट्स

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

रेटिना 0.8.2 , 21 बाइट्स

MATLAB, 138 बाइट्स

व्याख्या

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

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 77 बाइट्स

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

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

जेली , २० बाइट्स

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

जावास्क्रिप्ट (Node.js) , 78 बाइट्स

पर्ल 5, 64 बाइट्स

जंग, 258 बाइट्स

16/32/64-बिट x86 असेंबली कोड, 28 बाइट्स

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

आम लिस्प, 166 बाइट्स

एपीएल (Dyalog यूनिकोड) , 46 बाइट्स ^SBCS

रूबी `-pl` , 62 57 55 बाइट्स