Ich brauche eine UUID. Ihre Aufgabe ist es, eine zu generieren.

Die kanonische UUID (Universally Unique IDentifier) ​​ist eine 32-stellige Hexadezimalzahl mit Bindestrichen an bestimmten Stellen. Das Programm sollte 32 Hexadezimalziffern (128 Bit) in Form von xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx( 8-4-4-4-12Ziffern) ausgeben , wobei xes sich um eine zufällige Hexadezimalzahl handelt. Vorausgesetzt, das PRNG Ihrer Sprache ist perfekt, müssen alle gültigen Ausgaben die gleiche Wahrscheinlichkeit haben, generiert zu werden.

TL; DR

Generieren Sie 32 zufällige hexadezimale Ziffern in den Formularziffern 8-4-4-4-12. Kürzester Code gewinnt.

EDIT: Muss hexadezimal sein. Es ist ungültig, immer nur eine Dezimalzahl zu generieren. EDIT 2: Keine eingebauten. Dies sind keine GUIDs, nur generische Hex-Ziffern.

Beispielausgabe:

ab13901d-5e93-1c7d-49c7-f1d67ef09198
7f7314ca-3504-3860-236b-cface7891277
dbf88932-70c7-9ae7-b9a4-f3df1740fc9c
c3f5e449-6d8c-afe3-acc9-47ef50e7e7ae
e9a77b51-6e20-79bd-3ee9-1566a95d9ef7
7b10e43c-3c57-48ed-a72a-f2b838d8374b

Eingabe- und Standardlücken sind nicht zulässig.

Das ist Code-Golf , also gewinnt der kürzeste Code. Fragen Sie auch gerne nach.

Pyth, 20 Bytes

j\-msm.HO16*4hdj83 3

Demonstration.

Codiert [1, 0, 0, 0, 2]als 83 in Basis 3, addiert dann eins und multipliziert mit vier, um die Länge jedes Segments zu erhalten. Dann werden hexadezimale Ziffern und Bindestriche hinzugefügt.

Julia, 80 Bytes

h=hex(rand(Uint128),32)
print(h[1:8]"-"h[9:12]"-"h[13:16]"-"h[17:20]"-"h[21:32])

Generieren Sie eine zufällige 128-Bit-Ganzzahl, erhalten Sie ihre hexadezimale Darstellung als Zeichenfolge, die mit 32 Ziffern aufgefüllt ist, und unterteilen Sie diese in Segmente, die durch Bindestriche verbunden sind.

Vielen Dank an ConfusedMr_C und kvill für ihre Hilfe!

CJam, 26 25 Bytes

8 4__C]{{Gmr"%x"e%}*'-}/;

Probieren Sie es online im CJam-Interpreter aus .

Wie es funktioniert

8 4__C]{              }/   For each I in [8 4 4 4 12]:
        {         }*         Do I times:
         Gmr                   Pseudo-randomly select an integer between 0 and 15.
            "%x"e%             Apply hexadecimal string formatting.
                    '-       Push a hyphen-minus.
                        ;  Discard the last hyphen-minus.

PowerShell, 77 69 67 Byte

((8,4,4,4,12)|%{((1..$_)|%{'{0:X}'-f(random(16))})-Join""})-Join"-"

bearbeiten: fremde Eltern:

((8,4,4,4,12)|%{((1..$_)|%{('{0:X}'-f(random(16)))})-Join""})-Join"-"

edit: konnte das nachfolgende .Trim ("-") aus dem Original entfernen:

(((8,4,4,4,12)|%{((1..$_)|%{('{0:X}'-f(random(16)))})+"-"})-Join"").Trim("-")

Je nach Art der Flags (-f und -Join) kann es mit Leerzeichen klarer sein. Ich möchte immer noch den letzten Trim ("-") verlieren:

(((8,4,4,4,12)|%{((1..$_)|%{('{0:X}' -f (random(16)))}) + "-"}) -Join "").Trim("-")

Oder mit der eingebauten Funktionalität (ua die obige C # -Antwort)

'{0}'-f[System.Guid]::NewGuid()

Es scheint jedoch eine kleine Abkürzung zu sein, selbst wenn es bei 31 Bytes ankommt.

Python 2, 86 84 Bytes

from random import*;print'-'.join('%%0%ix'%i%randint(0,16**i-1)for i in[8,4,4,4,12])

Diese Verkettung von Zeichenfolgenformatierungen bewirkt, dass Python die Hexadezimalzahlen für jedes Segment eindeutig formatiert.

Ungolfed:

import random

final = []
for i in [8, 4, 4, 4, 12]:               # Iterate through every segment
    max = (16 ** i) - 1                  # This is the largest number that can be
                                         # represented in i hex digits
    number = random.randint(0, max)      # Choose our random segment
    format_string = '%0' + str(i) + 'x'  # Build a format string to pad it with zeroes
    final.append(format_string % number) # Add it to the list

print '-'.join(final)                    # Join every segment with a hyphen and print

Dies könnte eine Verbesserung gebrauchen, aber ich bin stolz.

Perl 5 , 43 Bytes

2 Bytes gespart dank @Xcali !

printf"%04x"."-"x/[2-5]/,rand 2**16for 1..8

Probieren Sie es online!

PHP, 69 72 75 Bytes

foreach([8,4,4,4,12]as$c)$r[]=rand(".1e$c","1e$c");echo join('-',$r);

Dies gibt keine hexadezimalen Ziffern ( a, ... f) aus. Sie sind erlaubt, aber vom Fragetext nicht verlangt.

Keine Zifferngruppe beginnt mit 0(auch nicht erforderlich).

edit: 3 Bytes gespart dank @IsmaelMiguel

C #, 65 Bytes

using System;class C{void Main(){Console.Write(Guid.NewGuid());}}

bearbeiten: Ja! C # ist kürzer als eine andere Sprache (außer Java) :)

Gawk, 86

BEGIN{for(srand();j++<32;printf(j~"^9|13|17|21"?"-":E)"%c",x+(x>10?87:48))x=rand()*16}

Sie können dies einmal pro Sekunde verwenden, um eine eindeutige zufällige "UUID" zu generieren. Dies liegt daran, dass srand()die Systemzeit in Sekunden seit der Epoche als Argument verwendet wird, wenn kein Argument angegeben ist.

for n in `seq 100` do awk 'BEGIN{for(srand();j++<32;printf(j~"^9|13|17|21"?"-":E)"%c",x+(x>10?87:48))x=rand()*16}'; sleep 1; done

Ich finde den awk-Teil ziemlich elegant.

BEGIN{
    srand()
    for(;j++<32;) {
        x=rand()*16
        x+=(x>10?87:48)
        printf "%c", x
        if(j~"^8|12|16|20")printf "-"
    }
}

Wenn Sie es öfter als einmal pro Sekunde verwenden möchten, können Sie es in bash wie folgt aufrufen. Beachten Sie, dass auch der awk-Teil geändert wird.

echo `awk 'BEGIN{for(srand('$RANDOM');j++<32;printf(j~"^9|13|17|21"?"-":E)"%c",x+(x>10?87:48))x=rand()*16}'`

Das echowird dort hinzugefügt, um jedes Mal eine neue Zeile zu drucken.

K5, 35 Bytes

"-"/(0,8+4*!4)_32?`c$(48+!10),65+!6

Um ein Hex-Alphabet zu generieren, generiere ich eine Zeichenkette ( `c$) aus einer Liste von Ziffern ( 48+!10) und den ersten 6 Großbuchstaben ( 65+!6). Eine alternative Methode zur Erzeugung von Ziffern gleicher Länge ist ,/$!10.

Mit der generierten Zeichenfolge "0123456789ABCDEF" ist der Rest einfach. Wählen Sie 32 zufällige Werte aus dieser Menge ( 32?) aus, schneiden Sie ( _) den resultierenden String bei der 0 8 12 16 20Berechnung über (0,8+4*!4)und verbinden Sie die resultierenden String-Fragmente mit Bindestrichen ( "-"/).

In Aktion:

  "-"/(0,8+4*!4)_32?`c$(48+!10),65+!6
"9550E114-A8DA-9533-1B67-5E1857F355E1"

R , 63 Bytes

x=sample(c(0:9,letters[1:6]),36,1);x[0:3*5+9]='-';cat(x,sep='')

Probieren Sie es online!

Der Code erstellt zuerst eine zufällige Zeichenfolge mit 36 ​​Zeichen und platziert dann die vier Bindestriche. Es gibt eine UUID an stdout aus.

JavaScript, ES6, 106 Bytes

"8-4-4-4-12".replace(/\d+/g, m => {t=0;for(i=0; i<m; i++) {t+=(Math.random()*16|0).toString(16)}return t})

Verwendet Regex ersetzen. Behandelt die Formatzeichenfolge als Anzahl zum Generieren eines Hex-Zeichens. Heben wo ich kann; Wenn möglich, werden Semikolons weggelassen.

Perl 6 , 53 Bytes

Das Offensichtliche:

say join '-',(0..9,'a'..'f').flat.roll(32).rotor(8,4,4,4,12)».join # 67

Das Übersetzen des Perl 5-Beispiels mit printfergibt einen etwas kürzeren Code.

printf ($_='%04x')~"$_-"x 4~$_ x 3,(0..^4⁸).roll(8) # 53

Kotlin , 175 Bytes

fun main(a:Array<String>){
fun f()="0123456789abcdef".get((Math.random()*16).toInt())
var s=""
for(i in listOf(8,4,4,4,12)){
for(j in 1..i)
s+=f()
if(i!=12)s+="-"}
println(s)}

Probieren Sie es online!

Mein allererstes Kotlin Programm & PPCG Einreichung

APL (Dyalog Unicode) , 115 78 Bytes

a←⊣,'-',⊢
H←⊃∘(⎕D,819⌶⎕A)¨16∘⊥⍣¯1
(H 8?16)a(H 4?16)a(H 4?16)a(H 4?16)a H 12?16

Probieren Sie es online!

Dies ist meine erste APL-Einreichung. Ein großes Dankeschön an @ Adám für das Gespräch mit mir im APL-Chat des PPCG und für die hexadezimale Konvertierungsfunktion.

Vielen Dank an @ Zacharý für 1 Byte

Bearbeitet, um die Anzahl der Bytes zu korrigieren.

Japt , 32 Bytes

[8,4,4,4,12]m@MqG**X sG ù0X} q"-

Probieren Sie es online!

MATLAB / Octave, 95 Bytes

a='-';b=strcat(dec2hex(randi(16,32,1)-1)');[b(1:8) a b(9:12) a b(13:16) a b(17:20) a b(21:32)]

Perl , 51 Bytes

say"xx-x-x-x-xxx"=~s/x/sprintf"%04x",rand 65536/reg

Benötigt perl5> = 5.10 denke ich. Für den Modifizierer / r und für say ().

J , 42 39 37 27 Bytes

echo'-'(8+5*i.4)},hfd?36#16

Probieren Sie es online!

C ++, 194 193 221 210 201 Bytes

+7 Bytes dank Zacharý (erkannt ein -, das nicht am Ende sein sollte)

#include<iostream>
#include<random>
#include<ctime>
#define L(a)for(int i=0;i<a;++i)std::cout<<"0123456789abcdef"[rand()%16];
#define P(a)printf("-");L(a)
void t(){srand(time(0));L(8)P(4)P(4)P(4)P(12)}

Wenn jemand die Möglichkeit hat, bei jeder Ausführung einen anderen Wert zu erhalten, ohne ihn zu ändern srandund ohne ihn einzuschließen <ctime>, wäre das großartig

Befunge-93 , 97 Bytes

v>4448v,+<    <
0*    :  >59*0^
62v0-1_$:|>*6+^
>^>41v < @^99<
v<*2\_$:54+` |
?0>+\1-^ v*68<>
>1^

Probieren Sie es online!

Ich bin sicher, das kann geschrumpft werden, aber das ist mein erster Versuch :)

Bash, 67 Bytes

for l in 4 2 2 2 6;{ o+=`xxd -p -l$l</dev/random`-;}
echo ${o::-1}

JavaScript REPL, 79 Bytes

'66-6-6-6-666'.replace(/6/g,_=>(Math.random().toString(16)+'00000').slice(2,6))

Probieren Sie es online!

Math.randomkann zurückkehren 0. Addiert man 5 Nullen, erhält das Schneiden 4 0Sekunden

Forth (Gforth) , 91 89 Bytes

include random.fs
hex
: f 0 4 4 4 8 20 0 do dup i = if + ." -" then 10 random 1 .r loop ;

Probieren Sie es online!

Erläuterung

Ändert die Basis in hexadezimal und gibt dann Zahlen / Segmente der entsprechenden Länge in festgelegten Intervallen mit Bindestrichen aus

Code-Erklärung

include random.fs          \ include the random module
hex                        \ set the base to hexadecimal
: f                        \ start a new word definition
  0 4 4 4 8                \ enter the intervals to place dashes
  20 0 do                  \ start a counted loop from 0 to 0x20 (32 in decimal)
    dup i =                \ check if we are on a character that needs a dash
    if                     \ if we are
      +                    \ calculate the next character that gets a dash
      ." -"                \ output a dash
    then                   \ end the if block
    f random               \ get a random number between 0x0 and 0xf
    1 .r                   \ output it right-aligned in 1-character space
  loop                     \ end the loop
;                          \ end the word definition

C (GCC) ,  94   91  86 Bytes

main(i){srand(&i);i=803912;for(;i--%16||(i/=16)&&printf("-");printf("%x",rand()%16));}

Probieren Sie es online!

Ich hätte diese Version gerne in einem Kommentar zu Max Yekhlakov ( seiner Antwort ) vorgeschlagen, aber leider habe ich noch nicht die 50 benötigten Reputationspunkte. Deshalb hier meine Antwort.

803912ist C4448in hexadezimal, beschreibt es , wie sollte die Ausgabe (formatiert werden 12-4-4-4-8), ist es umgekehrt ist , weil am wenigsten signifikanten Stellen zuerst gelesen werden.
 

Bearbeitungen:

• 3 Bytes gespart dank Jonathan Frech
• sparte 5 weitere Bytes durch Ersetzen srand(time(0))durchsrand(&i)

C (gcc) 143 110 103 96 94 Bytes

Dank Ceilingcat und Jonathan Frech auf 94 Bytes reduziert.

(*P)()="\xf\x31À";*z=L"\10\4\4\4\14";main(n){for(;*z;*++z&&putchar(45))for(n=*z;n--;printf("%x",P()&15));}

Probieren Sie es online!

Erläuterung:

/*
  P is a pointer to a function.
  The string literal contains actual machine code of the function:

  0F 31     rdtsc
  C3        ret

  0xc3 is the first byte of the UTF-8 representation of the character À
*/
(*P)() = "\xf\61À";

// encode uuid chunk lengths as literal characters
// we use wide characters with 'L' prefix because
// sizeof(wchar_t)==sizeof(int) for 64-bit gcc C on TIO
// so z is actually a zero-terminated string of ints
*z = L"\8\4\4\4\14"

main (n)
{
    for (
        ; 

        // loop until we reach the trailing zero
        *z;

        // increase the pointer and dereference it
        *++z 
             // and output a hyphen, if the pointer does not point at zero
             && putchar(45) 
    )
        // output a random hex string with length pointed at by z
        for (n = *z; n--; printf ("%x", P()&15));
}

Java mit zehn Fuß Laser Pole v. 1.06, 126 Bytes

String u(){return sj224.tflp.util.StringUtil.replace("aa-a-a-a-aaa","a",s->String.format("%04x",(int)(Math.random()*65536)));}

Getestet mit Version 1.06 der Bibliothek, dies sollte jedoch mit jeder Version 1.04 oder neuer funktionieren.

Gelee , 17 Bytes

ØhWẋ36X€”-“µÇŒð‘¦

Probieren Sie es online!

SmileBASIC, 65 62 Bytes

DEF G H?"-";:END
DEF H?HEX$(RND(65536),4);
END H G G G G H H H

Ich habe eine Funktion 4 zufällige hexadezimale Ziffern drucken: DEF H?HEX$(RND(65536),4);:ENDsowie 4 Stellen mit einem -nach ihnen DEF G:H?"-";:END. Dann muss es diese Funktionen nur ein paar Mal aufrufen.

Chip , 109 + 6 = 115 Bytes

Benötigt Flags -wc36, die +6 Bytes verursachen

!ZZZZZZZZZZZZZZZZZZZZZZ
,-----.,+vv--^----^---z
?]]]--R\acd
?xx+-)\\b
?x+x-)\\c
?^xx\--\d
`-xx]v~\e
f*`)'`-\g

Probieren Sie es online!

Erzeugt 4 zufällige Bits (die vier ?) und wandelt sie in hexadezimale Ziffern um:

• 0x0- 0x9=> 0-9
• 0xa- 0xe=> b-f
• 0xf => a

... ein bisschen unkonventionell, aber es hat mir ein paar Bytes erspart, und zwar ohne Kosten für die Verteilung der Ergebnisse.