Inspiré d' un récent article du Daily WTF ...

Écrivez un programme ou une fonction qui prend un GUID (chaîne au format XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX, où chaque X représente un chiffre hexadécimal) et génère le GUID incrémenté de un.

Exemples

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

Remarques

• Contrairement à l'article lié, l'incrémentation d'un GUID qui se termine par F doit «porter» au chiffre hexadécimal précédent. Voir les exemples ci-dessus.
• Vous pouvez supposer que l'entrée ne le sera pas ffffffff-ffff-ffff-ffff-ffffffffffff.
• Pour les chiffres hexadécimaux supérieurs à 9, vous pouvez utiliser des majuscules (AF) ou des minuscules (af).
• Oui, les GUID peuvent commencer par a 0.
• Votre sortie doit être composée exactement de 32 chiffres hexadécimaux et de 4 traits d'union dans le format attendu, y compris les éventuels interlignes 0.
• Vous n'avez pas à conserver le numéro de version ou d'autres bits fixes du GUID. Supposons que ce soit juste un entier de 128 bits où aucun des bits n'a de signification particulière. De même, les GUID sont supposés trier dans un ordre lexicographique simple plutôt que dans l'ordre binaire d'une GUIDstructure Windows .
• Si vous écrivez une fonction, l'entrée peut être d'une séquence-of- chartype de données: string, char[], List<char>, etc.

05AB1E , 17 15 18 octets

Enregistré 2 octets grâce à Kevin Cruijssen

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

Essayez-le en ligne! ou comme suite de tests

Explication

'-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 octets enregistrés grâce à @Dennis.

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

Essayez-le en ligne!

JavaScript (ES6), 85 octets

La chaîne de sortie est en minuscules.

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

Essayez-le en ligne!

Commenté

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 octets

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

Essayez-le en ligne!

Aucune importation ou conversion hexadécimale.

Cela balaye de l'arrière de la chaîne, en déplaçant chaque caractère le long du cycle 0123456789abcdef, avec -aller à lui-même. Après avoir touché un symbole autre que fou -, il arrête de balayer vers la gauche et renvoie simplement le reste inchangé. Cette solution n'est pas spécifique au format UUID - n'importe quel nombre de blocs de n'importe quel nombre de lettres hexadécimales fonctionnerait.

Le cas de base [str,f][s[-1]in'f-'](s[:-1])est un truc que je n'avais jamais vu utilisé dans un golf auparavant. Il met fin à la récursivité sans if, and,or ou un autre flux de contrôle explicite.

En fonction de la condition [s[-1]in'f-']du dernier caractère, le code retourne f(s[:-1])ou s[:-1]reste inchangé. Étant donné que strl'identité est sur les chaînes, nous pouvons sélectionner l'une des fonctions [str,f]et l'appliquer s[:-1]. Notez que l'appel récursif fn'est pas effectué s'il n'est pas choisi, contournant le problème courant que Python évalue avec impatience les options inutilisées, conduisant à une régression infinie dans les récursions.

APL (Dyalog Unicode) , 46 octets ^SBCS

Fonction de préfixe tacite anonyme.

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

Essayez-le en ligne!

⎕CY'dfns' c op y la bibliothèque "dfns" (pour obtenir hexetdec )

(... )
 ⊢ les arguments
 ≠ diffère de
 '-' la planche de bord
(... )@ sur le sous - ensemble constitué par les emplacements à laquelle le critère ci - dessus est vrai, sont applicables:
 dec¨ convertir chaque caractère hexadécimal à un nombre décimal
 ... @32 à la position 32 (le dernier chiffre), sont applicables:
  1+ incrément
 16(... )⍣≡ appliquer de façon répétée avec argument de gauche 16 jusqu'à ce qu'il soit stable:
  = comparer (donne un masque où les chiffres hexadécimaux sont 16)
  1⌽ faire pivoter cycliquement d'un pas vers la gauche (c'est le bit de retenue)
  |+ à cela, ajouter le reste de la division lorsqu'il est divisé (par seize, faisant ainsi tous les 16 en 0)  tourner chiffres en représentations de caractères hexadécimaux de longueur un ϵ nlist (aplatir)
 1hex
 ∊ 

Java 11, 152 149 111 111 108 octets

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

-38 octets merci à @ OlivierGrégoire .
-3 octets grâce à @ ASCII uniquement .

Essayez-le en ligne.

Explication:

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

Ancienne réponse de 149 octets:

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

Essayez-le en ligne.

Explication:

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

Rubis -pl , 62 57 55 octets

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

Essayez-le en ligne!

Python 3 , 50 octets

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

Essayez-le en ligne!

Python 2 , 113 112 octets

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

Essayez-le en ligne!

Sans importations

Retina 0.8.2 , 21 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. 9devient a. Explication: l'expression régulière correspond à tous les fs et -s de fin plus un caractère précédent. La translittération incrémente ensuite cycliquement ces caractères comme s'il s'agissait de chiffres hexadécimaux. Approche alternative, également 21 octets:

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

Essayez-le en ligne! Le lien inclut des cas de test. Fonctionne en minuscule l'entrée pour simplifier la translittération. Serait donc de 15 octets s'il ne devait prendre en charge que les minuscules. Essayez-le en ligne! Le lien inclut des cas de test.

MATLAB, 138 octets

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

Correction d'un bug au cas où un morceau serait entièrement composé de zéros. Golfé aussi beaucoup en abusant de try / catch. Résultat net: 0 octet enregistré.

Une tentative de «triche» en utilisant a java.util.UUIDéchoué car la longvaleur renvoyée par java.util.UUID.get[Most/Least]SignificantBitsest convertie en un doublequi entraîne une perte de précision. Je vous invite à jeter un œil à ce tableau et à prononcer silencieusement "... mais pourquoi? "

Explication

La hex2decfonction crache un double, donc elle ne peut pas traiter tout le GUID à la fois pour éviter de dépasser flintmax. Au lieu de cela, nous devons traiter le bloc GUID par chunck, en utilisant split. La variablea vérifie si nous devons en porter un, et triche également est l'incrément initial que nous ajoutons. La condition de report est de savoir si les longueurs des chaînes originales et incrémentées ne sont plus égales.

La version originale était un peu moins de 160 octets, donc j'aimerais penser que cela ne devrait pas être facile à surpasser.

Python 2 , 99 octets

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

Essayez-le en ligne!

Pas d' uuid.UUIDutilisation.

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

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

Essayez-le en ligne!

-1 octet grâce à @ASCIIOnly!

Fonction anonyme qui prend une char[]entrée et une sortie en modifiant un argument .

L'entrée est analysée de droite à gauche et remplacée à l'aide des règles suivantes.

• le - caractère est ignoré et le traitement continue
• Le Fpersonnage est converti en0 et le traitement se poursuit
• Le 9personnage est converti enA et le traitement s'arrête
• Les caractères A-Eet 0-8sont incrémentés de 1 et le traitement s'arrête

Powershell, 101 octets

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

Essayez-le en ligne!

Aucune bibliothèque externe ou conversion hexadécimale. N'importe quelle longueur de chaîne. Les minuscules et les majuscules sont autorisées. La chaîne d'entrée correspondant à ^[f-]*$est également autorisée.

Ce script analyse à l'arrière de la chaîne et incrémente chaque caractère par la valeur de la table de hachage:

• -: incrément = 1-1
• 9: incrément = 1 + 7, résultat =A
• F: incrément = 1-23, résultat =0
• f: incrément = 1-55, résultat =0
• incrément = 1 pour les autres caractères

Ensuite, le script utilise $p pour déterminer s'il faut incrémenter le caractère actuel.

Script de test:

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

Sortie:

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 octets

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

Essaye-le

Gelée , 20 octets

-2 (et correction d'un bug) grâce à Dennis!

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

Essayez-le en ligne!

PowerShell , 126 octets

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

Essayez-le en ligne!

Réponse assez banale. Je pensais juste que le bien-aimé PowerShell serait ajouté à la liste :)

JavaScript (Node.js) , 78 octets

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

Essayez-le en ligne!

Perl 5, 64 octets

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

Le nombre de parenthèses nécessaires ici me rend triste, mais -> se lie très étroitement, comme->as_hex c'est le moyen le plus rapide que je puisse trouver pour obtenir une sortie au format hexadécimal.

Courez avec perl -Mbigint -p. Fondamentalement, il convertit simplement le nombre en hexadécimal bigint, en ajoute un, puis sous-titre les chiffres du résultat dans la valeur d'origine, en laissant les tirets intacts.

Rouille, 258 octets

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

oui c'est long .. mais techniquement c'est une seule ligne avec 1 expression? et pas de bibliothèques fantaisies? et il ne plantera pas sur une entrée 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('-')));

essayez-le sur le terrain de jeu de la rouille

Code d'assemblage x86 16/32/64 bits, 28 octets

octets: 83C623FDAC3C2D74FB403C3A7502B0613C677502B03088460173E9C3

code:

     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

Appelez avec ESI pointant vers GUID. Remplacez ESI par SI pour 16 bits ou RSI pour 64 bits (et +2 octets).

C (clang) , 62 octets

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

Essayez-le en ligne!

Lisp commun, 166 octets

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

Essayez-le en ligne!