पायथन में एक्सप्रेशन परिणामों के अधिकतम घटित आवृत्ति मानों के अपेक्षित मान का पता लगाने का प्रोग्राम

मान लीजिए हमारे पास M अलग-अलग एक्सप्रेशंस हैं, और इन एक्सप्रेशंस के उत्तर 1 से N (दोनों समावेशी) की रेंज में हैं। तो x = max(f(i)) पर विचार करें प्रत्येक i के लिए रेंज 1 से N तक, हमें x का अपेक्षित मान ढूंढना है।

उदाहरण के लिए, यदि इनपुट M = 3, N = 3 है, तो आउटपुट 2.2 होगा, क्योंकि

$$E(x) = \sum P(x) * x = P(1) + 2P(2) + 3P(3) = \frac{1}{10} + 2 * \frac{6}{10} + 3 * \frac{3}{10} = \frac{22}{10}$$

समाधान दृष्टिकोण

इसे हल करने के लिए हम निम्न चरणों का पालन करेंगे:

• combination := एक नया मैप
• nCr() नामक एक फंक्शन परिभाषित करें। यह n, k_in लेगा
  • k := k_in और (n - k_in) का न्यूनतम
  • यदि n < k या k < 0, तो
    • 0 लौटाएं
  • अन्यथा जब (n, k), combination में है, तो
    • combination[n, k] लौटाएं
  • अन्यथा जब k, 0 के समान है, तो
    • 1 लौटाएं
  • अन्यथा जब n, k के समान है, तो
    • 1 लौटाएं
  • अन्यथा,
    • a := 1
    • cnt के लिए 0 से k - 1 तक की रेंज में, करें
      • a := a * (n - cnt)
      • a := a/(cnt + 1) का फ्लोर
      • combination[n, cnt + 1] := a
    • a लौटाएं
• मुख्य विधि से, निम्न करें:
  • arr := एक नई सूची
  • k के लिए 2 से M + 1 तक की रेंज में, करें
    • a := 1
    • s := 0
    • i के लिए 0 से M/k के फ्लोर + 2 तक की रेंज में, करें
      • यदि M < i * k, तो
        • लूप से बाहर आएं
      • s := s + a * nCr(N, i) * nCr(N-1+M-i*k, M-i*k)
      • a := -a
    • s को arr के अंत में डालें
  • total := arr का अंतिम तत्व
  • diff := एक सरणी जहां arr[0] को शुरुआत में डालें फिर एक सूची जोड़ें जहां (arr[cnt + 1] - arr[cnt]) प्रत्येक cnt के लिए रेंज 0 से M - 2 तक
  • output := (diff[cnt] *(cnt + 1) / total का योग प्रत्येक cnt के लिए रेंज 0 से M-1 तक)
  • output लौटाएं

उदाहरण

बेहतर समझ के लिए निम्न कार्यान्वयन देखें:

combination = {}

def nCr(n, k_in):
    k = min(k_in, n - k_in)
    if n < k or k < 0:
        return 0
    elif (n, k) in combination:
        return combination[(n, k)]
    elif k == 0:
        return 1
    elif n == k:
        return 1
    else:
        a = 1
        for cnt in range(k):
            a *= (n - cnt)
            a //= (cnt + 1)
            combination[(n, cnt + 1)] = a
        return a

def solve(M, N):
    arr = []
    for k in range(2, M + 2):
        a = 1
        s = 0
        for i in range(M // k + 2):
            if (M < i * k):
                break
            s += a * nCr(N, i) * nCr(N - 1 + M - i * k, M - i * k)
            a *= -1
        arr.append(s)
    total = arr[-1]
    diff = [arr[0]] + [arr[cnt + 1] - arr[cnt] for cnt in range(M - 1)]
    output = sum(diff[cnt] * (cnt + 1) / total for cnt in range(M))
    return output

M = 3
N = 3
print(solve(M, N))

इनपुट

3, 3

आउटपुट

2.2