ट्रैक
/
R
R
/
अभ्यास
/
कैप्टन की लॉगबुक
कैप्टन की लॉगबुक

कैप्टन की लॉगबुक

सीखने का अभ्यास

परिचय

बहुत से प्रोग्राम को वास्तविक दुनिया की घटनाओं का सिमुलेशन करने के लिए (देखने में) यादृच्छिक वैल्यू चाहिए होती हैं।

कुछ आम और परिचित उदाहरण:

  • सिक्का उछालना: एक यादृच्छिक वैल्यू, जो "H" या "T" होती है।
  • पासा फेंकना: 1 से 6 तक का एक यादृच्छिक पूर्णांक।
  • ताश की गड्डी फेंटना: ताश की सूची का एक यादृच्छिक क्रम।

कंप्यूटर से वास्तव में यादृच्छिक वैल्यू बनाना आश्चर्यजनक रूप से कठिन तकनीकी चुनौती है, इसलिए आप देख सकते हैं कि इन नतीजों को "स्यूडोरैंडम" कहा जाता है।

ज़रूरी: इस कॉन्सेप्ट में क्रिप्टोग्राफिक रूप से सुरक्षित यादृच्छिक संख्याएँ शामिल नहीं हैं, जो कहीं ज़्यादा कठिन चुनौती हैं।

लेकिन R को एक सांख्यिकी पैकेज से बनाया गया था और इसका इस्तेमाल अक्सर सिमुलेशन के लिए किया जाता है, इसलिए इसमें यादृच्छिक वैल्यू बनाने के कई तरह के तरीके मौजूद हैं। मॉडलिंग, सिमुलेशन और गेम में ज़्यादातर कामों के लिए ये नतीजे काफी अच्छे हैं।

प्रतिस्थापन के साथ या बिना सैंपल लेना

सोचिए कि हमारे पास एक थैला है जिसमें 3 लाल गेंदें और 4 हरी गेंदें हैं, और हम थैले में से बिना देखे एक गेंद निकालते हैं। दूसरी गेंद निकालने के लिए दो तरीके हैं:

  1. पहली गेंद को थैले में वापस डालिए और दूसरी निकालने से पहले थैले को अच्छी तरह हिलाइए। अब थैले में गेंदों की संख्या पहले जितनी ही (7) है, और लाल और हरी गेंदों का अनुपात भी वही रहता है।
  2. पहली गेंद को मेज़ पर रख दीजिए और फिर दूसरी निकालिए। अब थैले में सिर्फ 6 गेंदें बची हैं, और लाल और हरी का अनुपात इस बात पर निर्भर करता है कि पहली गेंद किस रंग की थी।

पहली स्थिति प्रतिस्थापन के साथ है और दूसरी प्रतिस्थापन के बिना। दोनों के नतीजे अलग-अलग होते हैं।

sample से अलग-अलग वैल्यू चुनना

सीमित संख्या में अलग-अलग वैल्यू में से चुनने के लिए sample() का इस्तेमाल प्रतिस्थापन के साथ या बिना किया जा सकता है। यह पूर्णांक, स्ट्रिंग आदि के लिए उपयोगी है।

sample(1:10, 5) # no repeats by default
#> [1] 8 3 4 2 6

sample(1:10, 5, replace = TRUE) # repeats are OK
#> [1] 10 10  7 10  9

languages <- c("Fortran", "R", "Python", "Julia")
sample(languages, 1)
#> [1] "Python"

sample(c("H", "T"), 5, replace = TRUE) # coin flips
#> [1] "T" "T" "H" "H" "H"

sample(c(TRUE, FALSE), 5, replace = TRUE) # alternative coin flips
#> [1] FALSE  TRUE FALSE  TRUE  TRUE

सैंपलिंग डेटा पाइपलाइन में अच्छी तरह काम करती है। उदाहरण के लिए, यादृच्छिक अल्फान्यूमेरिक स्ट्रिंग बनाने के लिए:

library(stringr)

c(letters, LETTERS, 0:9) |> sample(50) |> str_flatten()
#> [1] "5tX71jhbM9zUmKrpENBQyGYaZdJPVAx06leSF2s8gcfw3OviIH"

फेंटना

कई दूसरी भाषाओं में किसी क्रम को फेंटने के लिए एक खास फंक्शन होता है।

R में फेंटने का कोई फंक्शन नहीं है। क्यों?

इसे समझने के लिए sample फंक्शन को फिर से देखिए।

इसका पूरा रूप है sample(x, size, replace = FALSE, prob = NULL), जहाँ x (आम तौर पर) वह क्रम है जिसमें से सैंपल लेना है और size उन चीज़ों की संख्या है जिन्हें चुनना है।

हम replace पर पहले बात कर चुके हैं, जहाँ डिफाल्ट प्रतिस्थापन के बिना सैंपल लेना है। फिलहाल prob को छोड़ दीजिए, जिससे आप x के अलग-अलग एलिमेंट को अलग-अलग भार दे सकते हैं।

अगर हम size छोड़ दें और सिर्फ x दें तो क्या होता है?

x <- letters[1:6]
x
#> [1] "a" "b" "c" "d" "e" "f"
sample(x)
#> [1] "e" "a" "f" "b" "c" "d"

R की आम शैली में यहाँ वेक्टर अंदर और वेक्टर बाहर का तरीका चलता है, और size का डिफाल्ट length(x) होता है।

"x के सारे एलिमेंट को प्रतिस्थापन के बिना सैंपल करना" कहने का एक ज़्यादा तकनीकी तरीका "x को फेंटना" ही है।

इसीलिए shuffle नाम का कोई फंक्शन नहीं है, क्योंकि sample वह काम पहले से ही ठीक वैसे ही कर देता है जैसा हमें चाहिए!

वितरण के साथ काम करना

ऊपर के उदाहरणों में हर नतीजे की संभावना बराबर थी। जैसे sample(1:100) में 1 से 100 तक का कोई भी पूर्णांक मिलने की संभावना बराबर है।

इसे uniform वितरण कहते हैं।

वास्तविक दुनिया की कई स्थितियाँ इससे कहीं ज़्यादा जटिल होती हैं। इसलिए सांख्यिकीविदों ने "वास्तविक दुनिया" के नतीजों को गणित की भाषा में समझाने के लिए कई तरह के distributions बनाए हैं।

दशमलव संख्याएँ

समान वितरण

दशमलव संख्याओं के बराबर भार वाले वितरण के लिए runif() इस्तेमाल कीजिए (ध्यान "random-uniform" पर दीजिए, और इसे "run if" पढ़ने की स्वाभाविक पर गलत आदत से बचिए)। min और max दोनों दिए जा सकते हैं, लेकिन इनका डिफाल्ट 0 और 1 है।

runif(5)  # generate 5 values
#> [1] 0.3038506 0.3527959 0.3319309 0.4846354 0.4386279

# generate 5 non-negative values <= 100.0
runif(5, max = 100)
#> [1] 79.70762 51.62232 52.85281 71.08571 63.94380

निर्देश

मैरी टीवी सीरीज़ Star Trek: The Next Generation की बहुत बड़ी प्रशंसक है। वह अक्सर कागज़-कलम वाले रोल-प्लेइंग गेम खेलती है, जिनमें वह और उसके दोस्त खुद को Starship Enterprise का चालक दल मान लेते हैं।

मैरी का किरदार कैप्टन पिकार्ड का है, यानी उसे कैप्टन का लॉग रखना पड़ता है। उसे खेल का रचनात्मक हिस्सा बहुत पसंद है, लेकिन वह मौके पर ही रैंडम डेटा बनाना पसंद नहीं करती।

कैप्टन के लॉग में जो डेटा अक्सर आता है, उसके लिए रैंडम जनरेटर बनाकर मैरी की मदद कीजिए।

1. रैंडम ग्रह बनाइए

Starship Enterprise को अपनी यात्राओं में बहुत से ग्रह मिलते हैं। Star Trek की दुनिया में ग्रहों को उनके गुणों के आधार पर श्रेणियों में बाँटा गया है। जैसे पृथ्वी एक क्लास M ग्रह है। ग्रहों की सभी संभव क्लास हैं: D, H, J, K, L, M, N, R, T और Y.

random_planet_class फंक्शन बनाइए। इसे एक वेक्टर लौटाना चाहिए जिसमें ज़रूरत के अनुसार संख्या में ग्रहों की क्लासें रैंडम रूप से हों। क्लासों का दोहराव ठीक है, और लंबे वेक्टर के लिए यह ज़रूरी भी हो सकता है।

random_planet_class(number_needed)
#> "K"

2. एक रैंडम स्टारशिप रजिस्ट्री नंबर बनाइए

Enterprise (रजिस्ट्री नंबर NCC-1701) अकेला उड़ता हुआ स्टारशिप नहीं है! जब Enterprise का सामना किसी दूसरे स्टारशिप से होता है, तो मैरी को उस स्टारशिप का रजिस्ट्री नंबर लॉग में लिखना पड़ता है।

रजिस्ट्री नंबर "NCC-" उपसर्ग से शुरू होते हैं और उसके बाद 1000 से 9999 तक (दोनों शामिल) की कोई संख्या आती है।

random_ship_registry_number फंक्शन बनाइए, जो एक रैंडम स्टारशिप रजिस्ट्री नंबर लौटाता है।

random_ship_registry_number()
#> "NCC-1947"

3. स्टारशिप के बेड़े को रैंडम क्रम में लगाइए

खेल के एक संस्करण में दूसरे स्टारशिप के साथ बातचीत करनी होती है, और मैरी को एक चयन चाहिए।

संभव स्टारशिप की एक पूरी सूची है, लेकिन हर खेल में इनमें से कुछ ही चाहिए, और इन्हें रैंडम तरीके से चुना जाना चाहिए।

shuffle_starships(starships) फंक्शन बनाइए, जो अलग-अलग स्टारशिप रजिस्ट्री नंबरों का एक वेक्टर लेता है। यह उसी लंबाई का एक वेक्टर लौटाता है जिसमें स्टारशिप रैंडम क्रम में हों। फिर मैरी के लिए वेक्टर की शुरुआत से किसी भी आकार का रैंडम चयन लेना आसान हो जाएगा।

परिणाम की वैल्यू starships से ही ली जानी चाहिए, उनमें कोई दोहराव नहीं होना चाहिए।

shuffle_starships(c("NCC-5011", "NCC-1228", "NCC-7039", "NCC-3978", "NCC-1476"))
#> [1] "NCC-1476" "NCC-7039" "NCC-3978" "NCC-5011" "NCC-1228"

4. एक रैंडम स्टारडेट बनाइए

अगर लॉग में तारीखें ही न हों, तो ऐसा लॉग किस काम का?

स्टारडेट एक दशमलव संख्या होती है। The Next Generation के पहले सीज़न के Starship Enterprise के कारनामे स्टारडेट 41000.0 और 42000.0 के बीच होते हैं। "4" का मतलब 24वीं सदी है, और "1" का मतलब पहले सीज़न।

random_stardate फंक्शन बनाइए, जो 41000.0 और 42000.0 के बीच एक दशमलव संख्या लौटाता है।

random_stardate()
#> 41037.6
GitHub के ज़रिए संपादित करें यह लिंक एक नई विंडो या टैब में खुलता है
R Exercism

कैप्टन की लॉगबुक शुरू करने के लिए तैयार हैं?

Exercism पर साइन अप कीजिए और R को 21 कॉन्सेप्ट111 अभ्यास तथा असली इंसानों से मिलने वाली मेंटरिंग के साथ सीखिए और उसमें महारत हासिल कीजिए, वह भी बिल्कुल मुफ्त।