मुझे UUID की आवश्यकता है। आपका काम एक उत्पन्न करना है।

कैनोनिकल यूयूआईडी (यूनिवर्सली यूनिक आइडेंटिफ़ायर) एक 32 अंकों की हेक्साडेसिमल संख्या है जिसमें कुछ निश्चित बिंदुओं में हाइफ़न डाले जाते हैं। कार्यक्रम में xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx( 8-4-4-4-12अंकों) के रूप में 32 हेक्स डिजिट (128 बिट्स) का उत्पादन होना चाहिए , जहां xएक यादृच्छिक हेक्साडेसिमल संख्या है। यह मानते हुए कि आपकी भाषा का PRNG सही है, सभी मान्य आउटपुट में समान जेनरेट होने की संभावना होनी चाहिए।

टी एल; डॉ

प्रपत्र में 32 यादृच्छिक हेक्साडेसिमल अंक बनाएँ 8-4-4-4-12। सबसे छोटा कोड जीतता है।

EDIT: हेक्साडेसिमल होना चाहिए। हमेशा केवल जनरेट करना अमान्य है। EDIT 2: बिल्ट-इन नहीं। ये GUID नहीं हैं, केवल सामान्य हेक्स अंक हैं।

उदाहरण आउटपुट:

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

इनपुट और मानक खामियों को रोक दिया गया है।

यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है। इसके अलावा, स्पष्टीकरण पूछने के लिए स्वतंत्र महसूस करें।

code-golf random

— ताली
स्रोत

5

कोडगॉल्फ.स्टैकएक्सचेंज

— q/

9

"ये उदाहरण यादृच्छिक नहीं हैं। कुछ महत्व देने की कोशिश करें।" इसका क्या मतलब है?

— एलेक्स ए।

3

वास्तव में, किसी को हेक्साडेसिमल संख्याओं की आवश्यकता नहीं है, 10-बेस भी यादृच्छिक हो सकते हैं। उदाहरण के लिए, 12345678-1234-1234-1234-123456789012एक वैध यूयूआईडी होना चाहिए (या क्या कोई हेक्स डिजिट आवश्यक है?)। क्या आप इसे एक बचाव का रास्ता मानते हैं?

— Voitcus

3

शीर्षक और पहला वाक्य बताता है कि आप एक विहित यूयूआईडी चाहते हैं, और दिए गए उदाहरण यूयूआईडी के लिए कल्पना का पालन करते दिखाई देते हैं, लेकिन आप वास्तव में कुछ और के लिए पूछ रहे हैं।

— पीटर टेलर

3

मैं यह इंगित करने के लिए मजबूर हूं कि संस्करण 4 (यादृच्छिक) यूयूआईडी के पास एक आवश्यक प्रारूप है xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx जहां yसे एक है [89AB]। इस टिप्पणी के समय, कोई भी उत्तर (सी # को छोड़कर, लाइब्रेरी में निर्मित # का उपयोग करके) एक वैध यादृच्छिक यूयूआईडी (और वास्तव में, एक का उत्पादन नहीं करने की काफी संभावना है) का उत्पादन करने की गारंटी है।

11

अजगर, 20 बाइट्स

j\-msm.HO16*4hdj83 3

प्रदर्शन।

[1, 0, 0, 0, 2]बेस 3 में 83 के रूप में एनकोड करता है, फिर प्रत्येक सेगमेंट की लंबाई प्राप्त करने के लिए एक को जोड़ता है और चार से गुणा करता है। फिर हेक्स अंक बनाता है और हाइफ़न पर जुड़ता है।

— isaacg
स्रोत

8

जूलिया, 80 बाइट्स

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

एक यादृच्छिक 128-बिट पूर्णांक बनाएं, अपने हेक्सिडेसिमल प्रतिनिधित्व को एक स्ट्रिंग के रूप में 32 अंक तक पहुंचाएं, और इसे विभाजन में डैश के साथ जोड़ा।

ConfusedMr_C और उनकी मदद के लिए धन्यवाद!

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

8

सीजेएम, 26 25 बाइट्स

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

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

यह काम किस प्रकार करता है

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.

— डेनिस
स्रोत

5

पॉवरशेल, 77 69 67 बाइट्स

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

संपादित करें: बाहरी सामान:

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

संपादित करें: अनुगामी को निकालने में सक्षम था। मूल से ("-"):

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

यह कुछ व्हाट्सएप से स्पष्ट हो सकता है जिसे झंडे की प्रकृति (-f और -Join) दी गई है। मैं अभी भी अंतिम ट्रिम ("-") को खोना चाहूंगा:

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

या, अंतर्निहित कार्यक्षमता का उपयोग करते हुए (उपरोक्त सी # उत्तर दें)

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

हालाँकि, यह 31 बिट में आता है, भले ही यह एक छोटा सा शॉर्टकट- y लगता है।

— Forty3
स्रोत

61 बाइट:(8,4,4,4,12|%{-join(1..$_|%{'{0:X}'-f(random(16))})})-join'-'

— माज़ी

5

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

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

पायथन को प्रत्येक खंड के लिए विशिष्ट रूप से हेक्स संख्या बनाने के लिए यह चेन स्ट्रिंग फॉर्मेटर्स।

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

यह कुछ सुधार का उपयोग कर सकता है, लेकिन मुझे गर्व है।

— jqblz
स्रोत

5

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

@ बक्श को धन्यवाद दो बाइट्स बचाए !

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

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

— डोम हेस्टिंग्स
स्रोत

1

अपने मूल विधि का उपयोग करते हुए, दो बाइट्स शेव की गईं: इसे ऑनलाइन आज़माएं!

— Xcali

शुक्रिया @Xcali!

— डोम हेस्टिंग्स

4

PHP, 69 72 75 बाइट्स

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

यह हेक्स अंकों ( a, ... f) को आउटपुट नहीं करता है । उन्हें अनुमति है, लेकिन प्रश्न निकाय द्वारा आवश्यक नहीं है।

कोई अंक समूह शुरू नहीं होता 0(आवश्यक भी नहीं)।

संपादित करें: @IsmaelMiguel के लिए 3 बाइट्स सहेजे गए

— Voitcus
स्रोत

यह 32 से अधिक बाइट्स की तरह दिखता है।

— isaacg

@isaacg हाँ, क्षमा करें - मेरी गलती

— Voitcus

आपको join()इसके बजाय उपयोग करना चाहिए ।

— इस्माइल मिगुएल

3

सी #, 65 बाइट्स

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

संपादित करें: हाँ! C # किसी अन्य भाषा (जावा के अलावा) से छोटी है :)

— स्टेफ़न शिंकेल
स्रोत

1

मुझे लगता है कि यह एक मानक खामियाजा

— डोम हेस्टिंग्स

1

मुझे लगता है कि यह एक मानक खामी नहीं माना जाता है: जैसा कि आप देख सकते हैं कि इस सामान को छोड़ने का अनुरोध सिर्फ 1 वर्ष में 2 अपवोट मिला। इसके विपरीत टिप्पणी जो कहती है कि आपको बिल्ट-इन-फंक्शन्स का उपयोग करना चाहिए, 58 अपवोट मिले। या जैसा कि एक टिप्पणीकार ने कहा -> अगर हम सभी बिल्ट-इन फ़ंक्शन के एक ही सेट तक सीमित थे, तो प्रत्येक प्रतियोगिता को एपीएल या गोल्फस्क्रिप्ट द्वारा जीता जाएगा क्योंकि उनके कमांड नाम सबसे कम हैं। (माइकल स्टर्न)

— स्टीफ़न शिंकेल

1

या बस इसे किसी अन्य तरीके से लगाने के लिए: क्या हम प्रिंटफ का उपयोग कर सकते हैं? या क्या हमें इन्टिप्ट एएसएम का उपयोग इंटरप्ट 21 को ट्रिगर करने के लिए करना चाहिए?

— स्टीफन शिंकेल

एक अच्छी बात! मुझे परेशान करने का इरादा नहीं था, मेरा मतलब केवल मददगार होना था! मुझे लगता है कि तब, गणितज्ञ जीत सकता है CreateUUID[]!

— डोम हेस्टिंग्स 11

1

@StephanSchinkel "केवल एक वर्ष में 2 उत्थान" भ्रामक है। इसमें 47 अपवोट्स और 45 डाउनवोट्स अभी हैं, इसलिए एक शुद्ध +2 है। यह कहा जा रहा है, आम तौर पर स्वीकार की गई सीमा इससे अधिक है, इसलिए आप सही हैं कि यह "वास्तव में" अभी एक मानक खामियों के रूप में नहीं गिनता है।

— 19

3

गौक, 86६

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

आप एक अद्वितीय यादृच्छिक "UUID" उत्पन्न करने के लिए हर सेकंड एक बार इसका उपयोग कर सकते हैं। ऐसा इसलिए है क्योंकि srand()यदि तर्क दिया जाता है तो तर्क के रूप में सिस्टम समय का उपयोग सेकंड में किया जाता है।

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

मुझे लगता है कि अजीब हिस्सा बल्कि सुरुचिपूर्ण है।

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

यदि आप इसे हर बार एक से अधिक बार उपयोग करना चाहते हैं तो आप इसे इस तरह से बैश में कह सकते हैं। ध्यान दें कि awk हिस्सा भी बदल गया है।

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

echoवहाँ जोड़ा जाता है एक नई लाइन हर बार मुद्रित करने के लिए।

— Cabbie407
स्रोत

3

K5, 35 बाइट्स

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

हेक्स वर्णमाला उत्पन्न करने के लिए मैं `c$अंकों की सूची ( 48+!10) और पहले 6 बड़े अक्षरों ( ) से एक वर्ण स्ट्रिंग ( ) उत्पन्न करता हूं (65+!6 ) । अंकों को उत्पन्न करने का एक वैकल्पिक तरीका जो समान लंबाई है ,/$!10।

"0123456789ABCDEF" स्ट्रिंग के साथ, शेष सरल है। इस सेट से 32 यादृच्छिक मानों का चयन करें ( 32?), स्लाइस ( _) परिणामस्वरूप स्ट्रिंग को 0 8 12 16 20गणना के माध्यम से (0,8+4*!4), और फिर डैश ( "-"/) के साथ परिणामी स्ट्रिंग टुकड़े से जुड़ें ।

कार्रवाई में:

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

— JohnE
स्रोत

3

आर , 63 बाइट्स

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

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

कोड पहले एक 36 वर्ण यादृच्छिक स्ट्रिंग बनाता है, और फिर चार हाइफ़न रखता है। यह स्टडआउट के लिए एक UUID आउटपुट करता है।

— NofP
स्रोत

cकॉल को sprintf("%x",0:15)-1 से बदलें ।

— जे। डी। ओ।

3

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

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

रेगेक्स रिप्लेस का उपयोग करता है। एक हेक्स चार पैदा करने के लिए एक गिनती के रूप में प्रारूप स्ट्रिंग व्यवहार करता है। जहाँ भी मैं कर सकता हूँ वहाँ फहराना; अर्धविराम को छोड़ना जहां संभव हो।

— रेनो मैकेंजी
स्रोत

89 बाइट्स,'8-4-4-4-12'.replace(/\d+/g,n=>Math.floor(16**n*Math.random()).toString(16).padStart(n,0))

— kamoroso94

2

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

स्पष्ट एक:

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

पर्ल 5 उदाहरण का उपयोग करके अनुवाद करना printf, कोड में परिणाम जो थोड़ा छोटा है।

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

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

(0..16⁴)?! आप पर्ल में कर सकते हैं?

— क्लैप

1

@VoteToSpam आप 9 दिन पहले हो सकते हैं । (पर्ल 6 को इस महीने के अंत में रिलीज़ किया जाएगा)

— ब्रैड गिलबर्ट b2gills

Cooooool। शायद मुझे यह सीखना चाहिए

— ताली

@VoteToSpam इसकी तुलना में कुछ भी नहीं है 1,2,4,8,16 ... *जो 2. की शक्तियों की एक आलसी अनंत सूची उत्पन्न {2**$++} ... *करता है ( भी काम करता है)

— ब्रैड गिल्बर्ट b2gills

2

कोटलिन , 175 बाइट्स

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

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

मेरा पहला कोटलिन प्रोग्राम और PPCG सबमिशन

— Cheldon
स्रोत

152 बाइट्स -> tio.run/…

— jrtapsell

2

एपीएल (डायलॉग यूनिकोड) , 115 78 बाइट्स

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

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

यह मेरा पहला APL सबमिशन है। PPCG के APL चैट में और हेक्साडेसिमल रूपांतरण फ़ंक्शन के लिए मेरे साथ @ Adám के लिए विशाल धन्यवाद।

@ बाइट के लिए @ Zacharý को धन्यवाद

बाइट गिनती को ठीक करने के लिए संपादित।

— जे। सल्ल
स्रोत

आप ⎕IO←0बिना किसी लागत के मान सकते हैं , Adám कि बहुत कुछ करता है। इसके अलावा, अधिकांश बाइट्स (आईआईआरसी, आपके पास यहां मौजूद सभी) एपीएल में गिने जा सकते हैं।

— ज़ाचरी

@ Zacharý मैंने अपने प्रस्तुत करने के लिए बाइट्स गिनने के लिए TIO का उपयोग किया है, क्या मुझे इसके बजाय वर्णों की संख्या का उपयोग करना चाहिए था? मैं अभी भी पीपीसीजी के लिए नया हूं और एपीएल का उपयोग कर रहा हूं, इसलिए मुझे इसके बारे में ज्यादा जानकारी नहीं है कि इसके लिए बाइट की गिनती कैसे की जाती है।

— जे। सेले

इसके अलावा, आप बदल सकते हैं a(H 12?16)करने के लिए a H 12?16एक बाइट को बचाने के लिए।

— २०:४१ पर जच्चाकार

'-'@(+\9,3⍴5)⊢(⎕D,819⌶⎕A)[?36⍴16]या'-'@(+\9,3⍴5)∊⌂hex?18⍴256

— आदाम

2

जाप , 32 बाइट्स

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

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

— Bejofo
स्रोत

PPCG में आपका स्वागत है और Japt में आपका स्वागत है :) मैं अब तक आपके समाधानों के माध्यम से एक रन लूंगा, जब मैं कुछ समय बना सकता हूं (बस छुट्टियों से वापस आ सकता हूं, तो मुझे पकड़ने के लिए बहुत कुछ होगा) लेकिन मैं जो पहले टिप दूंगा वह परिचित है अपने आप को यूनिकोड शॉर्टकट ( m@- £उदाहरण के लिए) के साथ और, आपको अपने समाधान के लिए जल्दबाजी में बनाए गए 24 बाइट संस्करण यहां शुरू करने में मदद करने के लिए: ethproductions.github.io/japt/… यदि आप कोई प्रश्न पूछना चाहते हैं, तो जाप कक्ष में उतरें ।

— झबरा

1

MATLAB / ऑक्टेव, 95 बाइट्स

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

— costrom
स्रोत

1

पर्ल , 51 बाइट्स

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

मुझे लगता है कि perl5> = 5.10 की आवश्यकता है। / R संशोधक के लिए और कहने के लिए ()।

— केजेटिल एस।
स्रोत

1

अच्छा! यह मेरी तुलना में बहुत बेहतर है! अपने समाधान को देखने के बाद, आप ध्वज के उपयोग के साथ इस मेटा पोस्ट के आधार पर अधिक बचत करने में सक्षम हो सकते हैं, इसका मतलब यह भी होगा कि यह बिना किसी अतिरिक्त यात्रा पर काम करता है । s//xx-x-x-x-xxx/;s/x/sprintf"%04x",rand 65536/eg-p-E

— डोम हेस्टिंग्स

धन्यवाद। आपका सुझाव है: प्रतिध्वनि | perl -pe / // xx-xxx-xxx /? S / x / sprintf "% 04x", रैंड 65536 / उदा 'और' के बीच सिर्फ 48 वर्णों को '। (क्या इस तरह का धोखा है? शायद नहीं)

— Kjetil S.

इस मेटा पोस्ट के अनुसार यह स्वीकार्य है, मुझे अभी तक स्वयं उस तंत्र का उपयोग करने का अवसर नहीं मिला है, लेकिन उम्मीद है कि मैं जल्द ही पर्याप्त होगा! 49 बाइट्स (+ -p) होंगे लेकिन फिर भी बहुत अच्छे होंगे और मैंने आपका जवाब देखे बिना उस दृष्टिकोण पर विचार नहीं किया होगा!

— डोम हेस्टिंग्स

1

जे , ४२ ३ ९ ३ , २, बाइट्स

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

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

— FrownyFrog
स्रोत

1

सी ++, 194 193 221 210 201 बाइट्स

+7 बाइट्स Zacharý के लिए धन्यवाद (पता है -कि अंत में नहीं होना चाहिए)

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

अगर किसी को बदलने srandऔर शामिल किए बिना हर निष्पादन को एक अलग मूल्य प्राप्त करने का एक तरीका है <ctime>, तो यह बहुत अच्छा होगा

— HatsuPointerKun
स्रोत

नहीं #define L(a) forहो सकता ... हो सकता है #define L(a)for...? (हो सकता है कि पहले से ही पूछा है)

— Zacharý

यह अमान्य है, अंत में एक "-" है (जो कि वहाँ नहीं होना चाहिए)

— Zacharý

@ Zacharý सुधार अब लागू

— HatsuPointerKun

210 बाइट्स

— Zacharý

1

क्या आप ऐसा कुछ कर सकते हैं "0123456789abcdef"[rand()%16], और फिर हटा सकते हैं f?

— जकार्इ

1

बेफुंज -93 , 97 बाइट्स

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

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

मुझे यकीन है कि यह सिकुड़ सकता है, लेकिन यह मेरी पहली कोशिश है :)

— nornagon
स्रोत

1

बैश, 67 बाइट्स

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

— apilat
स्रोत

PPCG में आपका स्वागत है!

— डेनिस

1

जावास्क्रिप्ट REPL, 79 बाइट्स

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

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

Math.randomलौट सकते हैं 0। 5 शून्य जोड़ने से स्लाइसिंग 4 0एस हो जाती है

— l4m2
स्रोत

1

फोर्थ (gforth) , 91 89 बाइट्स

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

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

व्याख्या

बेस को हेक्साडेसिमल में बदल देता है, फिर निर्दिष्ट अंतराल पर डैश के साथ उचित लंबाई के संख्या / खंडों को आउटपुट करता है

कोड स्पष्टीकरण

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

— reffu
स्रोत

1

सी (जीसीसी) , 94 91 86 बाइट्स

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

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

मैं मैक्स वर्क्लाकोव ( उनके उत्तर ) पर एक टिप्पणी में इस संस्करण का सुझाव देना पसंद करूंगा , लेकिन दुर्भाग्य से मेरे पास अभी तक 50 आवश्यक प्रतिष्ठा बिंदु नहीं हैं, इसलिए यहां मेरा जवाब है।

803912है C4448हेक्साडेसिमल में, यह बताता है कि कैसे उत्पादन स्वरूपित किया जाना चाहिए ( 12-4-4-4-8), यह उलट है क्योंकि कम से कम महत्वपूर्ण अंक पहले पढ़ा जाएगा।

संपादन:

जोनाथन फ्रेच के लिए 3 बाइट्स को बचाया
के srand(time(0))साथ बदलकर 5 और बाइट्स को बचायाsrand(&i)

— Annyo
स्रोत

1

main(){...;int i=हो सकता है main(i){...;i=।

— जोनाथन फ्रेच

मैं कुछ सोच रहा था, स्पष्ट रूप से इसके बीज पैरामीटर के रूप में srand()स्वीकार करता हूं unsigned int। Tio.run पर, एक unsigned int4 बाइट्स लंबा है, लेकिन UUID 16 बाइट्स लंबा है। इसका मतलब है कि वैध आउटपुट का केवल एक छोटा सा अंश (1/2 ^ 12) उत्पन्न होगा, इस प्रकार मेरा समाधान (साथ ही पिछले वाले time(0)) मान्य नहीं है। तुम क्या सोचते हो ?

— Annyo

ओपी बताता है Assuming that your language's PRNG is perfect, all valid outputs must have the same probability of being generated.। बीज एन्ट्रापी आवश्यक रूप से आरएनजी एन्ट्रापी का निर्धारण नहीं करता है, हालांकि यह संभावना है ( srand()कार्यान्वयन की जांच नहीं करता है )। हालांकि, srand()मेरी जानकारी के लिए समान रूप से समान है, इसलिए यदि आरएनजी सही था, तो भी यह एक समान होगा। इसलिए मुझे लगता है कि आपका उत्तर मान्य है।

— जोनाथन फ्रैच

ठीक है मै समझ गया। मैं एक फ़ंक्शन के रूप में अपना जवाब भी प्रस्तुत कर सकता था, यह मानते हुए srand()कि पहले से ही किया गया है, और इस मामले में कोई संदेह नहीं होगा। लेकिन मुझे यकीन नहीं है कि अगर इसकी अनुमति है, तो अन्य C / C ++ सबमिशन में srand()इंट का जवाब देना शामिल है (जब तक कि इसका उपयोग न करें rand())

— Annyo

81 बाइट्स

— छत

1

सी (जीसीसी), 143 110 103 96 94 बाइट्स

सीलिंगकैट और जोनाथन फ्रेच की बदौलत 94 बाइट्स के लिए नीचे गिरा।

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

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

स्पष्टीकरण:

/*
  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));
}

— मैक्स येखलाकोव
स्रोत

1

नमस्कार और PPCG में आपका स्वागत है! 110 बाइट्स ।

— जोनाथन फ्रैच

@JonathanFrech धन्यवाद! आपका संस्करण बहुत प्रभावशाली है!

— मैक्स येखलाकोव

के *z=L"\27\23\17\vz"बजाय *z=L"\10\4\4\4\14"और के for(n=32;n--;z+=printf("-%x"+(n!=*z),P()&15)-1)बजाय for(;*z;*++z&&putchar(45))for(n=*z;n--;printf("%x",P()&15))

— सुझाव

1

जावा दस फुट लेजर ध्रुव v। 1.06, 126 बाइट्स के साथ

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

लाइब्रेरी के संस्करण 1.06 के साथ परीक्षण किया गया है, लेकिन यह किसी भी संस्करण 1.04 या नए के साथ काम करना चाहिए ।

— SuperJedi224
स्रोत

0

जेली , 17 बाइट्स

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

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

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

0

स्माइलबासिक, 65 62 बाइट्स

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

मैंने 4 यादृच्छिक हेक्स अंकों को प्रिंट करने के लिए एक फ़ंक्शन बनाया: DEF H?HEX$(RND(65536),4);:ENDसाथ ही -उनके बाद 4 अंक DEF G:H?"-";:END:। फिर इसे बस इन कार्यों को कई बार कॉल करना होगा।

— 12Me21
स्रोत

0

टुकड़ा , 109 + 6 = 115 बाइट्स

झंडे की आवश्यकता होती है -wc36, जिससे +6 बाइट्स होती हैं

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

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

4 यादृच्छिक बिट्स (चार ?के) उत्पन्न करता है और हेक्स अंकों में परिवर्तित होता है:

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

... थोड़ा अपरंपरागत, लेकिन इसने परिणामों के वितरण के लिए बिना किसी खर्च के मुझे कुछ बाइट्स बचाए।

— Phlarx
स्रोत

यादृच्छिक UUID उत्पन्न करें

मुझे UUID की आवश्यकता है। आपका काम एक उत्पन्न करना है।

टी एल; डॉ

उदाहरण आउटपुट:

अजगर, 20 बाइट्स

जूलिया, 80 बाइट्स

सीजेएम, 26 25 बाइट्स

यह काम किस प्रकार करता है

पॉवरशेल, 77 69 67 बाइट्स

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

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

PHP, 69 72 75 बाइट्स

सी #, 65 बाइट्स

गौक, 86६

K5, 35 बाइट्स

आर , 63 बाइट्स

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

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

कोटलिन , 175 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 115 78 बाइट्स

जाप , 32 बाइट्स

MATLAB / ऑक्टेव, 95 बाइट्स

पर्ल , 51 बाइट्स

जे , ४२ ३ ९ ३ , २, बाइट्स

सी ++, 194 193 221 210 201 बाइट्स

बेफुंज -93 , 97 बाइट्स

बैश, 67 बाइट्स

जावास्क्रिप्ट REPL, 79 बाइट्स

फोर्थ (gforth) , 91 89 बाइट्स

व्याख्या

कोड स्पष्टीकरण

सी (जीसीसी) , 94 91 86 बाइट्स

संपादन:

सी (जीसीसी), 143 110 103 96 94 बाइट्स

जावा दस फुट लेजर ध्रुव v। 1.06, 126 बाइट्स के साथ

जेली , 17 बाइट्स

स्माइलबासिक, 65 62 बाइट्स

टुकड़ा , 109 + 6 = 115 बाइट्स