แรงบันดาลใจจากบทความ WTF รายวันล่าสุด ...

เขียนโปรแกรมหรือฟังก์ชั่นที่ใช้ 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 ที่ลงท้ายด้วย F จะต้อง“ พกพา” เป็นเลขฐานสิบหกก่อนหน้านี้ ดูตัวอย่างด้านบน
• คุณอาจคิดว่าอินพุตจะไม่เป็นffffffff-ffff-ffff-ffff-ffffffffffffเช่นนั้น
• สำหรับเลขฐานสิบหกที่สูงกว่า 9 คุณสามารถใช้ตัวพิมพ์ใหญ่ (AF) หรือตัวล่าง (af)
• ใช่ guid 0ของอาจเริ่มต้นด้วย
• การส่งออกของคุณต้องประกอบด้วยว่า 32 ตัวเลขฐานสิบหกและ 4 ยัติภังค์ในรูปแบบที่คาดหวังรวมทั้งนำใด ๆ ที่จำเป็น0s
• คุณไม่จำเป็นต้องเก็บหมายเลขเวอร์ชันหรือบิตคงที่อื่น ๆ ของ GUID สมมติว่ามันเป็นเพียงจำนวนเต็ม 128 บิตที่ไม่มีบิตใดที่มีความหมายพิเศษ ในทำนองเดียวกัน guid ของจะถือว่าเรียงลำดับในการสั่งซื้อ lexicographical ตรงไปตรงมามากกว่าในการสั่งซื้อของฐานที่ใช้ Windows GUIDstruct
• ถ้าเขียนฟังก์ชั่นการป้อนข้อมูลที่อาจจะมีลำดับ -of-ใดcharชนิดข้อมูล: string, char[], List<char>ฯลฯ

05AB1E , 17 15 18 ไบต์

บันทึก 2 ไบต์ขอบคุณKevin Cruijssen

'-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 "-"

Python 2 , 50

• บันทึก 3 ไบต์ด้วย @Dennis

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

ลองออนไลน์!

JavaScript (ES6), 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

Python 2 , 82 ไบต์

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

ลองออนไลน์!

ไม่มีการนำเข้าหรือการแปลงเลขฐานสิบหก

การสแกนนี้จากด้านหลังของสตริงย้ายตัวละครแต่ละตัวไปตามวัฏจักร0123456789abcdefโดย-ไปที่ตัวมันเอง หลังจากที่มันกระทบสัญลักษณ์อื่นที่ไม่ใช่fหรือ-จะหยุดการสแกนไปทางซ้ายและเพียงแค่คืนค่าส่วนที่เหลือไม่เปลี่ยนแปลง โซลูชันนี้ไม่เฉพาะเจาะจงกับรูปแบบ UUID - จำนวนบล็อกใด ๆ ของจำนวนตัวอักษรฐานสิบหกใด ๆ ที่ใช้งานได้

กรณีฐานของ[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จะไม่ดำเนินการหากไม่ได้รับการเลือกการแก้ไขปัญหาทั่วไปที่ Python ประเมินตัวเลือกที่ไม่ได้ใช้อย่างกระตือรือร้นนำไปสู่การถดถอยแบบไม่สิ้นสุดในการเรียกซ้ำ

APL (Dyalog Unicode) , 46 ไบต์^SBCS

ฟังก์ชันนำหน้าเงียบโดยไม่ระบุชื่อ

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

ลองออนไลน์!

⎕CY'dfns' c op y the the "dfns" library (เพื่อรับhexและdec )

(… )
 ⊢ อาร์กิวเมนต์นั้น
 ≠ แตกต่างจาก
 '-' ขีดกลาง
(… )@ บนชุดย่อยซึ่งประกอบด้วยตำแหน่งที่เป็นเกณฑ์จริงใช้:
 dec¨ แปลงอักขระฐานสิบหกแต่ละตัวให้เป็นเลขฐานสิบ
 ... @32 ที่ตำแหน่ง 32 (หลักสุดท้าย) นำไปใช้: การ
  1+ เพิ่ม
 16(... )⍣≡ ซ้ำ ๆ ใช้กับ อาร์กิวเมนต์ซ้าย 16 จนกว่าจะมีเสถียรภาพ:
  = เปรียบเทียบ (ให้หน้ากากที่ตัวเลขฐานสิบหก 16)
  1⌽ ขั้นตอนเดียวหมุนวนซ้าย (นี้เป็นบิตพก)
  |+ ที่เพิ่มที่เหลือส่วนที่เมื่อแบ่งออก (โดยสิบหกจึงทำให้ทุก 16 เข้า 0)  เปิด ตัวเลขลงในระยะเวลาหนึ่งการแสดงอักขระเลขฐานสิบหกε nlist (เรียบ)
 1hex
 ∊ 

Java 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

Ruby -pl , 62 57 55 ไบต์

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

ลองออนไลน์!

Python 3 , 50 ไบต์

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

ลองออนไลน์!

Python 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]))

ลองออนไลน์!

โดยไม่ต้องนำเข้า

เรติน่า 0.8.2 , 21 ไบต์

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

ลองออนไลน์! ลิงค์มีกรณีทดสอบ จะกลายเป็น9 aคำอธิบาย: regex ตรงกับfs และ s ต่อท้ายทั้งหมด-บวกหนึ่งอักขระก่อนหน้า จากนั้นการทับศัพท์จะเพิ่มอักขระเหล่านั้นให้เหมือนว่าเป็นเลขฐานสิบหก วิธีอื่น, 21 ไบต์เช่นกัน:

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

ลองออนไลน์! ลิงค์มีกรณีทดสอบ ทำงานโดยลดอินพุตให้เล็กลงเพื่อลดความยุ่งยากในการทับศัพท์ จะเป็น 15 ไบต์หากรองรับเพียงตัวพิมพ์เล็กเท่านั้น ลองออนไลน์! ลิงค์มีกรณีทดสอบ

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ถ่มน้ำลายฟังก์ชั่นออกมาdoubleจึงไม่สามารถดำเนินการ GUID flintmaxที่ทั้งหมดในครั้งเดียวเพื่อหลีกเลี่ยงการเกิน แต่เรามีการประมวลผลอัน GUID โดย chunck splitใช้ ตัวแปรaจะตรวจสอบว่าเราต้องการนำไปใช้หรือไม่และการโกงก็คือการเพิ่มครั้งแรกที่เราเพิ่ม เงื่อนไขในการบรรทุกคือความยาวของสายดั้งเดิมและส่วนเพิ่มนั้นไม่เท่ากันอีกต่อไป

รุ่นดั้งเดิมมีขนาดต่ำกว่า 160 ไบต์ดังนั้นฉันจึงคิดว่าไม่น่าจะง่ายกว่านี้

Python 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การใช้งาน

C # (Visual C # Interactive Compiler) , 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-8เพิ่มขึ้นทีละ 1 และหยุดการประมวลผล

Powershell ขนาด 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-]*$อนุญาตให้

สคริปต์นี้สแกนจากด้านหลังของสตริงและฝังถ่านแต่ละตัวด้วยค่าจาก hashtable:

• -: increment = 1-1
• 9: increment = 1 + 7, result =A
• F: increment = 1-23, result =0
• f: increment = 1-55, result =0
• increment = 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

Perl 6 , 65 ไบต์

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

ทดสอบมัน

เยลลี่ 20 ไบต์

-2 (และแก้ไขข้อผิดพลาด) ต้องขอบคุณเดนนิส!

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

ลองออนไลน์!

PowerShellขนาด 126 ไบต์

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

ลองออนไลน์!

คำตอบเล็กน้อยสวย แค่คิดว่าฉันจะเพิ่ม PowerShell อันเป็นที่รักลงในรายการ :)

JavaScript (Node.js) , 78 ไบต์

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

ลองออนไลน์!

Perl 5, 64 ไบต์

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

จำนวนวงเล็บที่จำเป็นที่นี่ทำให้ฉันเศร้า แต่->ผูกแน่นมากเช่นกัน->as_hexเป็นวิธีที่เร็วที่สุดที่ฉันจะหาได้รับผลลัพธ์ที่จัดรูปแบบเลขฐานสิบหก

perl -Mbigint -pทำงานด้วย โดยพื้นฐานแล้วมันเพียงแปลงตัวเลขให้เป็นเลขฐานสิบหกที่มีขนาดใหญ่เพิ่มอีกหนึ่งตัวจากนั้นก็ลบตัวเลขของผลลัพธ์กลับไปเป็นค่าเดิมโดยไม่ต้องแตะเครื่องหมายขีด

สนิม 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('-')));

ลองใช้บนสนามเด็กเล่นสนิม

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

โทรด้วย ESI ที่ชี้ไปที่ GUID แทนที่ ESI ด้วย SI สำหรับ 16 บิตหรือ RSI สำหรับ 64- บิต (และ +2 ไบต์)

C (เสียงดังกราว) , 62 ไบต์

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

ลองออนไลน์!

Lisp ทั่วไป, 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#))))

ลองออนไลน์!