Terinspirasi oleh artikel WTF Harian terbaru ...

Tulis program atau fungsi yang menggunakan GUID (string dalam format XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX, di mana masing-masing X mewakili digit heksadesimal), dan output GUID bertambah satu.

Contohnya

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

Catatan

• Tidak seperti dalam artikel yang ditautkan, menambahkan GUID yang berakhir dengan F harus “membawa” ke digit hex sebelumnya. Lihat contoh di atas.
• Anda mungkin berasumsi bahwa input tidak akan ffffffff-ffff-ffff-ffff-ffffffffffff.
• Untuk digit hex di atas 9, Anda dapat menggunakan case atas (AF) atau bawah (af).
• Ya, GUID dapat dimulai dengan a 0.
• Output Anda harus terdiri dari tepat 32 digit hex dan 4 tanda hubung dalam format yang diharapkan, termasuk setiap lead yang diperlukan 0.
• Anda tidak harus menyimpan nomor versi atau bit tetap GUID lainnya. Asumsikan itu hanya integer 128-bit di mana tidak ada bit yang memiliki arti khusus. Demikian pula, GUID diasumsikan mengurutkan dalam urutan leksikografis langsung daripada dalam urutan biner Windows GUIDstruct.
• Jika menulis fungsi, input mungkin dari setiap urutan-of- chartipe data: string, char[], List<char>, dll

05AB1E , 17 15 18 byte

Disimpan 2 byte berkat Kevin Cruijssen

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

Cobalah online! atau sebagai Test Suite

Penjelasan

'-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 byte disimpan berkat @Dennis.

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

Cobalah online!

JavaScript (ES6), 85 byte

String output dalam huruf kecil.

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

Cobalah online!

Berkomentar

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 byte

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

Cobalah online!

Tidak ada impor atau konversi hex.

Ini memindai dari bagian belakang string, menggerakkan setiap karakter di sepanjang siklus 0123456789abcdef, dengan -pergi ke dirinya sendiri. Setelah itu hits simbol selainf atau- , itu berhenti memindai ke kiri, dan hanya mengembalikan sisanya tidak berubah. Solusi ini tidak spesifik untuk format UUID - sejumlah blok dari sejumlah huruf hex akan berfungsi.

Kasing dasar [str,f][s[-1]in'f-'](s[:-1])adalah trik yang belum pernah saya lihat digunakan dalam golf sebelumnya. Ini berakhir rekursi tanpa if, and,or , atau aliran kontrol eksplisit lainnya.

Berdasarkan kondisi [s[-1]in'f-']karakter terakhir, kode dapat kembali f(s[:-1])atau s[:-1]tidak berubah. Karena stridentitas pada string, kita dapat memilih salah satu fungsi [str,f]dan menerapkannya s[:-1]. Perhatikan bahwa panggilan rekursif dengan ftidak dilakukan jika tidak dipilih, mengatasi masalah masalah umum yang Python bersemangat mengevaluasi opsi yang tidak digunakan, yang mengarah ke kemunduran tak terbatas dalam rekursi.

APL (Dyalog Unicode) , 46 byte ^SBCS

Fungsi awalan diam-diam anonim.

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

Cobalah online!

⎕CY'dfns' c op y perpustakaan "dfns" (untuk mendapatkan hexdandec )

(... )
 ⊢ argumen
 ≠ berbeda dari
 '-' tanda hubung
(... )@ pada himpunan bagian yang terdiri dari lokasi di mana kriteria di atas adalah benar, terapkan:
 dec¨ konversi setiap karakter heksadesimal menjadi angka desimal
 ... @32 pada posisi 32 (digit terakhir), terapkan:
  1+ kenaikan
 16(... )⍣≡ berulang kali berlaku dengan argumen kiri 16 hingga stabil:
  = bandingkan (beri mask di mana digit heksadesimal adalah 16)
  1⌽ putar satu langkah ke kiri (ini adalah carry bit)
  |+ , tambahkan sisa pembagian ketika dibagi (dengan enam belas, sehingga membuat semua 16 menjadi 0)  berbelok digit menjadi panjang-satu representasi karakter heksadesimal ϵ daftar (ratakan)
 1hex
 ∊ 

Java 11, 152 149 111 108 byte

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

-38 byte terima kasih kepada @ OlivierGrégoire .
-3 byte terima kasih hanya untuk @ ASCII .

Cobalah online.

Penjelasan:

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

Old 149 byte jawaban:

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");}

Cobalah online.

Penjelasan:

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 byte

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

Cobalah online!

Python 3 , 50 byte

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

Cobalah online!

Python 2 , 113 112 byte

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

Cobalah online!

Tanpa impor

Retina 0.8.2 , 21 byte

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

Cobalah online! Tautan termasuk kasus uji. 9menjadi a. Penjelasan: Regex cocok dengan semua trailing fs dan -s ditambah satu karakter sebelumnya. Transliterasi kemudian secara siklis menambah karakter-karakter itu seolah-olah mereka adalah digit hex Pendekatan alternatif, juga 21 byte:

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

Cobalah online! Tautan termasuk kasus uji. Bekerja dengan menurunkan input untuk menyederhanakan transliterasi. Karena itu akan menjadi 15 byte jika hanya harus mendukung huruf kecil. Cobalah online! Tautan termasuk kasus uji.

MATLAB, 138 byte

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

Memperbaiki bug seandainya sebagian besar nol. Juga bermain golf banyak dengan menyalahgunakan coba / tangkap. Hasil bersih: 0 byte disimpan.

Upaya untuk 'menipu' dengan menggunakan java.util.UUIDgagal karena longnilai yang dikembalikan dari java.util.UUID.get[Most/Least]SignificantBitsakan dikonversi ke doubleyang menimbulkan kehilangan presisi. Saya mengundang Anda untuk melihat tabel ini dan diam-diam mengucapkan "... tapi mengapa? "

Penjelasan

The hex2decmeludah fungsi keluar double, sehingga tidak dapat memproses seluruh GUID sekaligus untuk menghindari melebihi flintmax. Sebagai gantinya, kita harus memproses chid GUID dengan chunck, menggunakan split. Variabela memeriksa apakah kita perlu membawa satu, dan dengan curang juga merupakan kenaikan awal yang kita tambahkan. Kondisi untuk terbawa adalah apakah panjang string asli dan tambahan tidak lagi sama.

Versi aslinya hanya di bawah 160 byte jadi saya ingin berpikir ini seharusnya tidak mudah untuk mengalahkan.

Python 2 , 99 byte

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

Cobalah online!

Tidak ada uuid.UUIDpenggunaan.

C # (Visual C # Interactive Compiler) , 77 byte

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

Cobalah online!

-1 byte terima kasih kepada @ASCIIHanya!

Fungsi anonim yang mengambil char[]input dan output sebagai dengan memodifikasi argumen .

Input dipindai dari kanan ke kiri dan diganti menggunakan aturan berikut.

• Itu - karakter diabaikan dan pengolahan terus
• The Fkarakter dikonversi ke0 dan pengolahan terus
• The 9karakter dikonversi keA dan pengolahan berhenti
• Karakter A-Edan 0-8ditambahkan 1 dan pemrosesan berhenti

Powershell, 101 byte

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

Cobalah online!

Tidak ada perpustakaan eksternal atau konversi hex. Panjang tali apa pun. Huruf kecil dan huruf besar diizinkan. Pencocokan string input ^[f-]*$juga diizinkan.

Script ini memindai dari belakang string dan menambahkan setiap karakter dengan nilai dari hashtable:

• -: increment = 1-1
• 9: increment = 1 + 7, result =A
• F: increment = 1-23, result =0
• f: increment = 1-55, result =0
• increment = 1 untuk karakter lainnya

Selanjutnya, skrip menggunakan $p untuk menentukan apakah akan menambah karakter saat ini.

Skrip uji:

$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"
}

Keluaran:

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 byte

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

Menguji

Jelly , 20 byte

-2 (dan perbaikan bug) berkat Dennis!

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

Cobalah online!

PowerShell , 126 byte

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

Cobalah online!

Jawaban yang cukup sepele. Hanya berpikir saya akan mendapatkan PowerShell yang dicintai ditambahkan ke daftar :)

JavaScript (Node.js) , 78 byte

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

Cobalah online!

Perl 5, 64 byte

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

Jumlah tanda kurung yang diperlukan di sini membuatku sedih, tapi -> mengikat sangat erat, seperti->as_hex cara tercepat yang bisa saya temukan untuk mendapatkan output berformat heksadesimal.

Jalankan dengan perl -Mbigint -p. Pada dasarnya, itu hanya mengubah angka menjadi heksadesimal bigint, menambahkan satu, dan kemudian menggantikan digit hasil kembali ke nilai asli, meninggalkan garis tidak tersentuh.

Rust, 258 byte

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('-')));

ya itu panjang .. tapi secara teknis hanya satu baris dengan 1 ekspresi? dan tidak ada perpustakaan mewah? dan itu tidak akan crash pada input fuzz? 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('-')));

coba di taman bermain karat

Kode perakitan x86 16/32/64-bit, 28 byte

byte: 83C623FDAC3C2D74FB403C3A7502B0613C677502B03088460173E9C3

kode:

     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

Panggil dengan ESI yang menunjuk ke GUID. Ganti ESI dengan SI untuk 16-bit, atau RSI untuk 64-bit (dan +2 byte).

C (dentang) , 62 byte

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

Cobalah online!

Gangguan Umum, 166 byte

(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#))))

Cobalah online!