पॉल का समाधान एक सरल , सामान्य समाधान प्रदान करता है ।
सवाल "सबसे तेज और सरल तरीका" पूछता है । सबसे तेज़ भाग को भी संबोधित करते हैं। हम अपने अंतिम, सबसे तेज़ कोड में एक पुनरावृत्त तरीके से पहुंचेंगे। प्रत्येक चलना बेंचमार्क जवाब के अंत में पाया जा सकता है।
सभी समाधान और बेंचमार्किंग कोड गो प्लेग्राउंड पर देखे जा सकते हैं । खेल के मैदान पर कोड एक परीक्षण फ़ाइल है, एक निष्पादन योग्य नहीं है। आपको इसे नाम की एक फ़ाइल में सहेजना होगा XX_test.goऔर इसे साथ चलाना होगा
go test -bench . -benchmem
प्राक्कथन :
सबसे तेज़ समाधान एक जाने-योग्य समाधान नहीं है यदि आपको बस एक यादृच्छिक स्ट्रिंग की आवश्यकता है। उसके लिए, पॉल का समाधान एकदम सही है। यह है अगर प्रदर्शन मायने रखता है। हालाँकि पहले 2 चरण ( बाइट्स और रेमिनेडर ) एक स्वीकार्य समझौता हो सकता है: वे 50% की तरह प्रदर्शन में सुधार करते हैं ( II। बेंचमार्क अनुभाग में सटीक संख्या देखें ), और वे जटिलता को बहुत अधिक नहीं बढ़ाते हैं।
कहा जाता है कि, भले ही आपको सबसे तेज़ समाधान की आवश्यकता न हो, इस उत्तर के माध्यम से पढ़ना साहसिक और शैक्षिक हो सकता है।
I. सुधार
1. उत्पत्ति (दौड़)
एक अनुस्मारक के रूप में, मूल, सामान्य समाधान जो हम सुधार रहे हैं वह यह है:
func init() {
rand.Seed(time.Now().UnixNano())
}
var letterRunes = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
func RandStringRunes(n int) string {
b := make([]rune, n)
for i := range b {
b[i] = letterRunes[rand.Intn(len(letterRunes))]
}
return string(b)
}
2. बाइट्स
यदि अक्षरों को चुनने और यादृच्छिक स्ट्रिंग को इकट्ठा करने के लिए केवल अंग्रेजी वर्णमाला के अपरकेस और लोअरकेस अक्षर होते हैं, तो हम केवल बाइट्स के साथ काम कर सकते हैं क्योंकि UTF-8 एन्कोडिंग में अंग्रेजी वर्णमाला पत्र 1 से 1 बाइट्स के लिए मैप करता है (जो यह है कि गो स्टोर स्ट्रिंग्स)।
इसलिए इसके बजाय:
var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
हम प्रयोग कर सकते हैं:
var letters = []bytes("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
या इससे भी बेहतर:
const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
अब यह पहले से ही एक बड़ा सुधार है: हम इसे एक होने के लिए प्राप्त कर सकते constहैं ( stringस्थिरांक हैं लेकिन कोई स्लाइस स्थिरांक नहीं हैं )। अतिरिक्त लाभ के रूप में, अभिव्यक्ति len(letters)भी एक होगी const! ( len(s)यदि sस्ट्रिंग स्थिर है तो अभिव्यक्ति स्थिर है।)
और किस कीमत पर? कुछ भी नहीं। strings को अनुक्रमित किया जा सकता है जो अपने बाइट्स को अनुक्रमित करता है, एकदम सही, जो हम चाहते हैं।
हमारा अगला गंतव्य इस तरह दिखता है:
const letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
func RandStringBytes(n int) string {
b := make([]byte, n)
for i := range b {
b[i] = letterBytes[rand.Intn(len(letterBytes))]
}
return string(b)
}
3. अवशेष
पिछले समाधानों को एक यादृच्छिक पत्र प्राप्त करने के लिए एक यादृच्छिक संख्या प्राप्त होती है, जिसे कॉल करके rand.Intn()प्रतिनिधियों को भेजा जाता Rand.Intn()है Rand.Int31n()।
यह तुलना में बहुत धीमा है rand.Int63()जो 63 यादृच्छिक बिट्स के साथ एक यादृच्छिक संख्या का उत्पादन करता है।
तो हम बस rand.Int63()को विभाजित करके शेष को कॉल और उपयोग कर सकते हैं len(letterBytes):
func RandStringBytesRmndr(n int) string {
b := make([]byte, n)
for i := range b {
b[i] = letterBytes[rand.Int63() % int64(len(letterBytes))]
}
return string(b)
}
यह काम करता है और काफी तेज है, नुकसान यह है कि सभी अक्षरों की संभावना बिल्कुल समान नहीं होगी (यह मानते हुए rand.Int63()सभी 63-बिट संख्याओं को समान संभावना के साथ पैदा करता है)। हालाँकि विकृति अत्यंत छोटी है क्योंकि अक्षरों की संख्या 52इससे बहुत छोटी है 1<<63 - 1, इसलिए व्यवहार में यह बिल्कुल ठीक है।
इसे समझने में आसान बनाने के लिए: मान लीजिए कि आप श्रेणी में एक यादृच्छिक संख्या चाहते हैं 0..5। 3 यादृच्छिक बिट्स का उपयोग करना, यह संख्या 0..1को सीमा से दोगुनी संभावना के साथ उत्पन्न करेगा 2..5। 5 यादृच्छिक बिट्स का उपयोग करते हुए, रेंज में संख्याएँ 0..1होती हैं6/32 संभाव्यता के होती हैं और संभावना के 2..5साथ सीमा में संख्याएँ 5/32जो अब वांछित के करीब है। बिट्स की संख्या में वृद्धि करना इसे कम महत्वपूर्ण बनाता है, जब 63 बिट्स तक पहुंच जाता है, तो यह नगण्य है।
4. मास्किंग
पिछले समाधान पर बिल्डिंग, हम अक्षरों की संख्या का प्रतिनिधित्व करने के लिए आवश्यक यादृच्छिक संख्या के सबसे कम बिट्स का उपयोग करके केवल अक्षरों के समान वितरण को बनाए रख सकते हैं। इसलिए उदाहरण के लिए अगर हमारे पास 52 अक्षर हैं, तो इसे प्रस्तुत करने के लिए 6 बिट्स की आवश्यकता होती है 52 = 110100b:। इसलिए हम केवल सबसे कम 6 बिट्स का उपयोग करेंगे जो कि लौटाए गए नंबर से होगाrand.Int63() । और अक्षरों के समान वितरण को बनाए रखने के लिए, हम केवल "संख्या" को स्वीकार करते हैं यदि यह सीमा में आता है 0..len(letterBytes)-1। यदि सबसे कम बिट्स अधिक हैं, तो हम इसे त्याग देते हैं और एक नया यादृच्छिक संख्या क्वेरी करते हैं।
ध्यान दें कि सबसे कम बिट्स की संभावना सामान्य या औसत len(letterBytes)से कम से अधिक होने की संभावना है , जिसका अर्थ है कि भले ही यह मामला होगा, इस "दुर्लभ" मामले को दोहराते हुए एक अच्छा नहीं मिलने की संभावना कम हो जाती है नंबर। पुनरावृत्ति के बाद , मौका है कि हम एक अच्छा सूचकांक नहीं है की तुलना में बहुत कम है , और यह सिर्फ एक ऊपरी आकलन है। 52 अक्षरों के मामले में मौका है कि 6 सबसे कम बिट अच्छे नहीं हैं ; उदाहरण के लिए जिसका अर्थ है कि 10 पुनरावृत्ति के बाद एक अच्छी संख्या नहीं होने की संभावना है ।0.50.25npow(0.5, n)(64-52)/64 = 0.191e-8
तो यहाँ समाधान है:
const letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
const (
letterIdxBits = 6 // 6 bits to represent a letter index
letterIdxMask = 1<<letterIdxBits - 1 // All 1-bits, as many as letterIdxBits
)
func RandStringBytesMask(n int) string {
b := make([]byte, n)
for i := 0; i < n; {
if idx := int(rand.Int63() & letterIdxMask); idx < len(letterBytes) {
b[i] = letterBytes[idx]
i++
}
}
return string(b)
}
5. मास्किंग में सुधार
पिछला समाधान केवल 63 यादृच्छिक बिट्स द्वारा सबसे कम 6 बिट्स का उपयोग करता है rand.Int63() । यह एक बेकार है क्योंकि यादृच्छिक बिट्स हमारे एल्गोरिथ्म का सबसे धीमा हिस्सा है।
यदि हमारे पास ५२ अक्षर हैं, तो इसका अर्थ है कि ६ बिट्स एक अक्षर सूचकांक है। तो 63 यादृच्छिक बिट्स 63/6 = 10अलग-अलग पत्र सूचकांकों को नामित कर सकते हैं । चलो उन सभी का उपयोग करें 10:
const letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
const (
letterIdxBits = 6 // 6 bits to represent a letter index
letterIdxMask = 1<<letterIdxBits - 1 // All 1-bits, as many as letterIdxBits
letterIdxMax = 63 / letterIdxBits // # of letter indices fitting in 63 bits
)
func RandStringBytesMaskImpr(n int) string {
b := make([]byte, n)
// A rand.Int63() generates 63 random bits, enough for letterIdxMax letters!
for i, cache, remain := n-1, rand.Int63(), letterIdxMax; i >= 0; {
if remain == 0 {
cache, remain = rand.Int63(), letterIdxMax
}
if idx := int(cache & letterIdxMask); idx < len(letterBytes) {
b[i] = letterBytes[idx]
i--
}
cache >>= letterIdxBits
remain--
}
return string(b)
}
6. स्रोत
मास्किंग सुधार , बहुत अच्छी है बहुत ज्यादा नहीं हम इस पर सुधार कर सकते हैं। हम कर सकते हैं, लेकिन जटिलता के लायक नहीं।
अब हम कुछ और सुधारने की कोशिश करते हैं। यादृच्छिक संख्याओं का स्रोत।
एक crypto/randपैकेज है जो एक Read(b []byte)फ़ंक्शन प्रदान करता है , इसलिए हम इसका उपयोग कर सकते हैं कि हमें जितनी आवश्यकता हो उतने कॉल के साथ कई बाइट मिलें। यह प्रदर्शन के मामले में मदद नहीं करेगाcrypto/rand एक क्रिप्टोग्राफिक रूप से सुरक्षित छद्म आयामी संख्या जनरेटर लागू करता है इसलिए यह बहुत धीमा है।
तो चलो math/randपैकेज से चिपके रहते हैं । rand.Randएक का उपयोग करता है rand.Sourceयादृच्छिक बिट्स के स्रोत के रूप में। rand.Sourceएक इंटरफ़ेस है जो एक Int63() int64विधि को निर्दिष्ट करता है: वास्तव में और केवल वही चीज जो हमें चाहिए और हमारे नवीनतम समाधान में उपयोग की जाती है।
इसलिए हमें वास्तव में rand.Rand(या तो स्पष्ट या वैश्विक, randपैकेज में से एक साझा ) की आवश्यकता नहीं है, एक rand.Sourceहमारे लिए पूरी तरह से पर्याप्त है:
var src = rand.NewSource(time.Now().UnixNano())
func RandStringBytesMaskImprSrc(n int) string {
b := make([]byte, n)
// A src.Int63() generates 63 random bits, enough for letterIdxMax characters!
for i, cache, remain := n-1, src.Int63(), letterIdxMax; i >= 0; {
if remain == 0 {
cache, remain = src.Int63(), letterIdxMax
}
if idx := int(cache & letterIdxMask); idx < len(letterBytes) {
b[i] = letterBytes[idx]
i--
}
cache >>= letterIdxBits
remain--
}
return string(b)
}
इसके अलावा ध्यान दें कि यह पिछले समाधान (बीज) प्रारंभ करने में वैश्विक की आवश्यकता नहीं है Randके math/randपैकेज के रूप में है कि नहीं किया जाता है (और हमारे rand.Sourceठीक से प्रारंभ / वरीयता प्राप्त है)।
यहां एक और बात ध्यान देने योग्य है: math/randराज्यों का पैकेज डॉक्टर :
डिफ़ॉल्ट स्रोत कई गोरोनाइट द्वारा समवर्ती उपयोग के लिए सुरक्षित है।
इसलिए डिफ़ॉल्ट स्रोत इसके Sourceद्वारा प्राप्त किया जा सकता है की तुलना में धीमा है rand.NewSource(), क्योंकि डिफ़ॉल्ट स्रोत को समवर्ती उपयोग / उपयोग के तहत सुरक्षा प्रदान करना है, जबकि rand.NewSource()यह पेशकश नहीं करता है (और इस प्रकार इसके Sourceद्वारा लौटाए जाने की संभावना अधिक तेज़ है)।
7. उपयोग करना strings.Builder
सभी पिछले समाधान वापसी एक stringजिनकी सामग्री पहले एक टुकड़ा में बनाया गया है ( []runeमें उत्पत्ति , और []byteबाद के समाधान में), और फिर करने के लिए परिवर्तित string। इस अंतिम रूपांतरण को स्लाइस की सामग्री की एक प्रति stringबनानी होगी , क्योंकि मान अपरिवर्तनीय हैं, और यदि रूपांतरण प्रतिलिपि नहीं बनाएगा, तो यह गारंटी नहीं दी जा सकती है कि स्ट्रिंग की सामग्री को उसके मूल स्लाइस के माध्यम से संशोधित नहीं किया गया है। विवरण के लिए, देखें कि utf8 स्ट्रिंग को [] बाइट में कैसे परिवर्तित किया जाए? और गोलंग: [] बाइट (स्ट्रिंग) बनाम [] बाइट (* स्ट्रिंग) ।
जाओ 1.10 पेश किया strings.Builder। strings.Builderएक नए प्रकार का उपयोग हम stringइसी तरह की सामग्री बनाने के लिए कर सकते हैं bytes.Buffer। यह आंतरिक रूप से इसका उपयोग करता है []byte, और जब हम कर लेते हैं, तो हम stringइसकी Builder.String()विधि का उपयोग करके अंतिम मूल्य प्राप्त कर सकते हैं । लेकिन इसमें जो अच्छा है वह यह है कि यह प्रतिलिपि के बिना हम ऊपर की बात करते हैं। यह ऐसा करने की हिम्मत करता है क्योंकि स्ट्रिंग की सामग्री के निर्माण के लिए उपयोग की जाने वाली बाइट स्लाइस उजागर नहीं होती है, इसलिए यह गारंटी दी जाती है कि कोई भी इसे उत्पादित "अपरिवर्तनीय" स्ट्रिंग को बदलने के लिए अनजाने या दुर्भावना से संशोधित नहीं कर सकता है।
तो हमारा अगला विचार एक स्लाइस में यादृच्छिक स्ट्रिंग का निर्माण नहीं करना है, लेकिन एक की मदद से strings.Builder, इसलिए एक बार जब हम काम कर लेते हैं, तो हम इसकी प्रतिलिपि बनाने के बिना परिणाम प्राप्त कर सकते हैं और वापस कर सकते हैं। यह गति के संदर्भ में मदद कर सकता है, और यह निश्चित रूप से स्मृति उपयोग और आवंटन के संदर्भ में मदद करेगा।
func RandStringBytesMaskImprSrcSB(n int) string {
sb := strings.Builder{}
sb.Grow(n)
// A src.Int63() generates 63 random bits, enough for letterIdxMax characters!
for i, cache, remain := n-1, src.Int63(), letterIdxMax; i >= 0; {
if remain == 0 {
cache, remain = src.Int63(), letterIdxMax
}
if idx := int(cache & letterIdxMask); idx < len(letterBytes) {
sb.WriteByte(letterBytes[idx])
i--
}
cache >>= letterIdxBits
remain--
}
return sb.String()
}
ध्यान दें कि एक नया बनाने के बाद strings.Buidler, हमने इसकी Builder.Grow()विधि को बुलाया , यह सुनिश्चित करते हुए कि यह एक बड़े-पर्याप्त आंतरिक स्लाइस (वास्तविक अक्षरों को जोड़ने से बचने के लिए) को आवंटित करता है।
8. strings.Builderपैकेज के साथ "नकल"unsafe
strings.Builderएक आंतरिक में स्ट्रिंग का निर्माण करता है []byte, जैसा कि हमने खुद किया था। तो मूल रूप से strings.Builderकुछ ओवरहेड के माध्यम से कर रहा है , केवल एक चीज जिसे हमने स्विच किया strings.Builderहै वह स्लाइस की अंतिम प्रतिलिपि से बचने के लिए है।
strings.Builderपैकेज का उपयोग करके अंतिम प्रतिलिपि से बचता है unsafe:
// String returns the accumulated string.
func (b *Builder) String() string {
return *(*string)(unsafe.Pointer(&b.buf))
}
बात यह है, हम खुद भी ऐसा कर सकते हैं। इसलिए यहाँ पर विचार यादृच्छिक स्ट्रिंग के निर्माण में वापस जाने के लिए है []byte, लेकिन जब हम काम कर रहे होते हैं, तो इसे stringवापस लौटने के लिए परिवर्तित नहीं करते हैं, लेकिन एक असुरक्षित रूपांतरण करते हैं: stringजो स्ट्रिंग डेटा के रूप में हमारे बाइट स्लाइस को इंगित करता है। ।
यह इस प्रकार किया जा सकता है:
func RandStringBytesMaskImprSrcUnsafe(n int) string {
b := make([]byte, n)
// A src.Int63() generates 63 random bits, enough for letterIdxMax characters!
for i, cache, remain := n-1, src.Int63(), letterIdxMax; i >= 0; {
if remain == 0 {
cache, remain = src.Int63(), letterIdxMax
}
if idx := int(cache & letterIdxMask); idx < len(letterBytes) {
b[i] = letterBytes[idx]
i--
}
cache >>= letterIdxBits
remain--
}
return *(*string)(unsafe.Pointer(&b))
}
(9. उपयोग करते हुए rand.Read())
जाओ 1.7 ने एक rand.Read()फ़ंक्शन और एक Rand.Read()विधि जोड़ी । बेहतर प्रदर्शन को प्राप्त करने के लिए हमें एक कदम में जितनी बाइट चाहिए उतने बाइट्स पढ़ने के लिए इनका उपयोग करने का लालच दिया जाना चाहिए।
इसके साथ एक छोटी "समस्या" है: हमें कितने बाइट्स की आवश्यकता है? हम कह सकते हैं: आउटपुट पत्रों की संख्या जितनी। हमें लगता है कि यह एक ऊपरी अनुमान है, क्योंकि एक पत्र सूचकांक 8 बिट्स (1 बाइट) से कम का उपयोग करता है। लेकिन इस बिंदु पर हम पहले से ही खराब कर रहे हैं (जैसा कि यादृच्छिक बिट्स "हार्ड पार्ट" है), और हम आवश्यकता से अधिक प्राप्त कर रहे हैं।
यह भी ध्यान दें कि सभी पत्र सूचकांकों के समान वितरण को बनाए रखने के लिए, कुछ "कचरा" यादृच्छिक डेटा हो सकता है, जिसका हम उपयोग नहीं कर पाएंगे, इसलिए हम कुछ डेटा को छोड़ देंगे, और इस तरह जब हम सभी के माध्यम से कम हो जाएंगे बाइट स्लाइस। हमें "पुनरावर्ती" अधिक यादृच्छिक बाइट्स प्राप्त करने की आवश्यकता होगी। और अब हम "सिंगल कॉल टू randपैकेज" लाभ भी खो रहे हैं ...
हमारे द्वारा प्राप्त रैंडम डेटा के उपयोग को हम "कुछ हद तक" अनुकूलित कर सकते हैं math.Rand()। हम अनुमान लगा सकते हैं कि हमें कितने बाइट्स (बिट्स) की आवश्यकता होगी। 1 पत्र को letterIdxBitsबिट्स की आवश्यकता होती है, और हमें nअक्षरों की आवश्यकता होती है , इसलिए हमें n * letterIdxBits / 8.0बाइट्स को गोल करना होगा। हम एक यादृच्छिक सूचकांक के प्रयोग योग्य नहीं होने की संभावना की गणना कर सकते हैं (ऊपर देखें), इसलिए हम अधिक अनुरोध कर सकते हैं कि "अधिक संभावना" पर्याप्त होगी (यदि यह पता चला कि यह नहीं है, तो हम प्रक्रिया को दोहराते हैं)। हम उदाहरण के लिए बाइट स्लाइस को "बिट स्ट्रीम" के रूप में संसाधित कर सकते हैं, जिसके लिए हमारे पास एक अच्छा 3rd पार्टी लिब है: github.com/icza/bitio(प्रकटीकरण: मैं लेखक हूं)।
लेकिन बेंचमार्क कोड अभी भी दिखाता है कि हम जीत नहीं रहे हैं। ऐसा क्यों है?
अंतिम प्रश्न का उत्तर है क्योंकि rand.Read()लूप का उपयोग करता है और Source.Int63()तब तक कॉल करता रहता है जब तक कि यह पास के स्लाइस को भर नहीं देता है। वास्तव में क्या RandStringBytesMaskImprSrc()समाधान करता है, बिना मध्यवर्ती बफर, और जटिलता के बिना। इसलिए RandStringBytesMaskImprSrc()सिंहासन पर बने हुए हैं। हां, इसके विपरीत RandStringBytesMaskImprSrc()एक असंबद्ध का उपयोग करता है । लेकिन तर्क अभी भी लागू होता है; और जो सिद्ध होता है यदि हम इसके बजाय प्रयोग करते हैं (पूर्व भी अनसंकटेड है)।rand.Sourcerand.Read()Rand.Read()rand.Read()
द्वितीय। बेंचमार्क
सब ठीक है, यह विभिन्न समाधानों को बेंचमार्क करने का समय है।
सच्चाई का क्षण:
BenchmarkRunes-4 2000000 723 ns/op 96 B/op 2 allocs/op
BenchmarkBytes-4 3000000 550 ns/op 32 B/op 2 allocs/op
BenchmarkBytesRmndr-4 3000000 438 ns/op 32 B/op 2 allocs/op
BenchmarkBytesMask-4 3000000 534 ns/op 32 B/op 2 allocs/op
BenchmarkBytesMaskImpr-4 10000000 176 ns/op 32 B/op 2 allocs/op
BenchmarkBytesMaskImprSrc-4 10000000 139 ns/op 32 B/op 2 allocs/op
BenchmarkBytesMaskImprSrcSB-4 10000000 134 ns/op 16 B/op 1 allocs/op
BenchmarkBytesMaskImprSrcUnsafe-4 10000000 115 ns/op 16 B/op 1 allocs/op
बस रन से बाइट्स पर स्विच करने से, हमारे पास तुरंत 24% प्रदर्शन लाभ होता है, और मेमोरी की आवश्यकता एक तिहाई तक गिर जाती है ।
इसके बजाय छुटकारा पाने rand.Intn()और उपयोग rand.Int63()करने से एक और 20% बढ़ावा मिलता है।
मास्किंग (और बड़े सूचकांकों के मामले में) थोड़ा धीमा हो जाता है (पुनरावृत्ति कॉल के कारण): -22% ...
लेकिन जब हम 63 यादृच्छिक बिट्स (एक rand.Int63()कॉल से 10 सूचकांक) के सभी (या अधिकांश) का उपयोग करते हैं : जो कि बड़े समय को गति देता है: 3 बार ।
यदि हम rand.Sourceइसके बजाय (गैर-डिफ़ॉल्ट, नया) के साथ समझौता करते हैं rand.Rand, तो हम फिर से 21% प्राप्त करते हैं ।
यदि हम उपयोग करते हैं strings.Builder, तो हम गति में 3.5% की वृद्धि करते हैं , लेकिन हमने मेमोरी उपयोग और आवंटन में 50% की कमी भी हासिल की है ! यह अच्छा है!
अंत में अगर हम unsafeइसके बजाय पैकेज का उपयोग करने की हिम्मत करते हैं strings.Builder, तो हम फिर से एक अच्छा 14% हासिल करते हैं ।
प्रारंभिक समाधान करने के लिए अंतिम तुलना: RandStringBytesMaskImprSrcUnsafe()है 6.3 गुना तेजी से RandStringRunes(), का उपयोग करता छठे स्मृति और कुछ आवंटन के रूप में आधा । मिशन पूरा हुआ।