मैं आर में निम्नलिखित गेम को कोड करने की कोशिश कर रहा हूं:

  • एक पासे को तब तक रोल करें जब तक कि आप 4 और उसके बाद 6 . न देखें
  • गिनें कि आपको ४ के बाद ६ का अवलोकन करने में कितनी बार लगा
  • इन पहले दो चरणों को 100 बार दोहराएं
  • एक ४ के बाद एक ६ . का अवलोकन करने में लगने वाली औसत संख्या की गणना करें

मैंने इसे निम्नानुसार मैन्युअल रूप से अनुकरण करने का प्रयास किया - मैंने पहली बार आर में "रनिफ" कमांड का उपयोग बड़ी संख्या में "एक पासा रोल" करने के लिए किया था, उम्मीद है कि आप अंततः 4 के बाद 6 देखेंगे (मुझे नहीं पता कि कैसे इसे "लूप तक करें" का उपयोग करके कोड करने के लिए)। मैंने इसे 100 बार दोहराया और इन सभी रोलों को डेटा फ्रेम में डाल दिया:

roll_1 = floor(runif(100, min=1, max=6))

roll_2 = floor(runif(100, min=1, max=6))

roll_3 = floor(runif(100, min=1, max=6))

roll_4 = floor(runif(100, min=1, max=6))

roll_5 = floor(runif(100, min=1, max=6))

#etc 

roll_100 = floor(runif(100, min=1, max=6))

all_rolls = data.frame(roll_1, roll_2, roll_3, roll_4, roll_5, roll_100)

यह इस प्रकार दिखता है:

head(all_rolls)
  roll_1 roll_2 roll_3 roll_4 roll_5 roll_100
1      4      2      5      3      1        4
2      3      2      4      4      1        2
3      1      3      1      4      2        1
4      3      2      1      4      4        3
5      4      1      2      2      5        5
6      2      3      3      5      3        1

मैंने तब इस डेटा फ़्रेम को Microsoft Excel में निर्यात किया और मैन्युअल रूप से प्रत्येक कॉलम का निरीक्षण किया और उस पंक्ति संख्या की गणना की जिस पर एक 4 से पहले एक 6 दिखाई देता है। मैंने तब सभी कॉलमों के लिए इस संख्या को औसत किया और औसत संख्या की गणना की जिसे आपको रोल करने की आवश्यकता है। इससे पहले कि आप 4 और उसके बाद 6 देखें। ऐसा करने में कुछ समय लगा, लेकिन यह काम कर गया।

मैं ऐसा करने का एक तेज़ तरीका ढूंढ रहा हूं। क्या किसी को पता है कि इस "गेम" को तेज करने के लिए आर में "जब तक" लूप का उपयोग नहीं किया जा सकता है?

धन्यवाद

2
Noob 7 सितंबर 2021, 05:32

3 जवाब

सबसे बढ़िया उत्तर

runif के बजाय, मैं sample 1:6 मान दूंगा क्योंकि एक पासे में केवल 1 से 6 तक के मान होंगे और 1.23 आदि जैसे मान नहीं होंगे।

इस प्रकार आप while लूप का उपयोग कर सकते हैं -

roll_from_4_to6 <- function() {
  n <- 1:6
  i <- 1
  previous_4 <- FALSE
  while(TRUE) {
    current_value = sample(n, 1)
    i <- i + 1
    if(previous_4 && current_value == 6) break
    previous_4 <- current_value == 4
  }
  i
}

इसे एक बार चलाएं।

roll_from_4_to6()

इसे 100 बार चलाएं और औसत लें।

mean(replicate(100, roll_from_4_to6()))
2
Ronak Shah 7 सितंबर 2021, 05:42

पासा से नमूनाकरण श्रेणीबद्ध वितरण का अनुसरण कर रहा है। extraDistr पैकेज से rcat फ़ंक्शन का उपयोग करके, आप श्रेणीबद्ध वितरण से नमूना ले सकते हैं

roll_game <- function() {
  count <- 2
  dices <- rcat(2, c(1/6 ,1/6, 1/6, 1/6, 1/6, 1/6))
  while(!(rev(dices)[2] ==4 && rev(dices)[1] ==6 )){
    dices <- c(dices, rcat(1, c(1/6 ,1/6, 1/6, 1/6, 1/6, 1/6)))
    count <- count+1
  }
  count
}

mean(replicate(100, roll_game()))

आपका जवाब मिल जाएगा

1
Park 7 सितंबर 2021, 05:46

मैंने इस समस्या को हल करने के लिए एक अलग दृष्टिकोण पर विचार किया, जो आपको प्राप्त सटीक निर्देशों से विचलित कर रहा था।

रोल का एक क्रम बनाएं जो बहुत बड़ा हो, ताकि आप १०० मामले ढूंढ सकें जिनमें ६ एक ४ का अनुसरण करता है:

x = sample(1:6, 1e6, TRUE)

4 के बाद 6 प्राप्त करने के लिए आवश्यक रोल का माध्य है:

mean(diff(which(x == 4 & data.table::shift(x) == 6)[1:100]))

आप वहां क्या कर रहे हैं:

  • x == 4 & data.table::shift(x) == 6 रिकॉर्ड का एक वेक्टर है जिसके लिए 4 के बाद 6 आता है। यह वेक्टर FALSE और TRUE का एक समूह है।
  • which(x == 4 & data.table::shift(x) == 6)[1:100] उन TRUE की अनुक्रमणिका है (पहले 100 TRUE)
  • diff हमें बताता है कि लगातार मैचों के बीच कितने रोल थे।
  • mean हमें अंतिम मान का औसत देता है।
0
PavoDive 7 सितंबर 2021, 06:16