Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Probability such that two subset contains same number of elements

  • Last Updated : 05 May, 2021

Given a set containing N elements. If two subset X and Y picked then find the probability that both of them contains the same number of elements.
Examples: 
 

Input:
Output: 35/128 
Input:
Output: 3/8 
 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

 



Approach: 
Let’s choose a subset X that has r number of elements then Y must contain r number of elements. A subset can have minimum 0 elements and maximum N elements.
Total number of subsets of a set contains N number of elements is 

*** QuickLaTeX cannot compile formula:
 

*** Error message:
Error: Nothing to show, formula is empty

, Total possible way to choose X and Y simultaneously will be 

*** QuickLaTeX cannot compile formula:
 

*** Error message:
Error: Nothing to show, formula is empty

*** QuickLaTeX cannot compile formula:
 

*** Error message:
Error: Nothing to show, formula is empty

*** QuickLaTeX cannot compile formula:
 

*** Error message:
Error: Nothing to show, formula is empty

.
Let, P = Total possible way to choose X and Y such that both have the same number of elements.
Then P = \sum_{r=0}^{n} ^nC_r * ^nC_r  C_0^2+C_1^2+C_2^2+....+C_n^2  ^{2n}C_{n}
So the required probability will be \frac{^{2n}C_{n}}{2^{2n}}  .
Below is the implementation of the above Approach:
 

C++




// C++ implementation of
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Returns value of Binomial
// Coefficient C(n, k)
int binomialCoeff(int n, int k)
{
    int res = 1;
 
    // Since C(n, k) = C(n, n-k)
    if (k > n - k)
        k = n - k;
 
    // Calculate value of
    for (int i = 0; i < k; ++i) {
        res *= (n - i);
        res /= (i + 1);
    }
 
    return res;
}
 
// Iterative Function to
// calculate (x^y) in O(log y)
int power(int x, unsigned int y)
{
    // Initialize result
    int res = 1;
 
    while (y > 0) {
 
        // If y is odd, multiply
        // x with result
        if (y & 1)
            res = res * x;
 
        // y must be even now
        // y = y/2
        y = y >> 1;
 
        // Change x to x^2
        x = x * x;
    }
    return res;
}
 
// Function to find probability
void FindProbability(int n)
{
 
    // Calculate total possible
    // ways and favourable ways.
    int up = binomialCoeff(2 * n, n);
    int down = power(2, 2 * n);
 
    // Divide by gcd such that
    // they become relatively coprime
    int g = __gcd(up, down);
 
    up /= g, down /= g;
 
    cout << up << "/" << down << endl;
}
 
// Driver code
int main()
{
 
    int N = 8;
 
    FindProbability(N);
 
    return 0;
}

Java




// Java implementation of
// the above approach
class GFG
{
     
    // Returns value of Binomial
    // Coefficient C(n, k)
    static int binomialCoeff(int n, int k)
    {
        int res = 1;
     
        // Since C(n, k) = C(n, n-k)
        if (k > n - k)
            k = n - k;
     
        // Calculate value of
        for (int i = 0; i < k; ++i)
        {
            res *= (n - i);
            res /= (i + 1);
        }
     
        return res;
    }
     
    // Iterative Function to
    // calculate (x^y) in O(log y)
    static int power(int x, int y)
    {
        // Initialize result
        int res = 1;
     
        while (y > 0)
        {
     
            // If y is odd, multiply
            // x with result
            if ((y & 1) == 1)
                res = res * x;
     
            // y must be even now
            // y = y/2
            y = y >> 1;
     
            // Change x to x^2
            x = x * x;
        }
        return res;
    }
     
    // Recursive function to return gcd of a and b
    static int gcd(int a, int b)
    {
        if (b == 0)
            return a;
        return gcd(b, a % b);
         
    }
     
    // Function to find probability
    static void FindProbability(int n)
    {
     
        // Calculate total possible
        // ways and favourable ways.
        int up = binomialCoeff(2 * n, n);
        int down = power(2, 2 * n);
     
        // Divide by gcd such that
        // they become relatively coprime
        int g = gcd(up, down);
     
        up /= g;
        down /= g;
     
        System.out.println(up + "/" + down);
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int N = 8;
     
        FindProbability(N);
    }
}
 
// This code is contributed by AnkitRai01

Python3




# Python3 implementation of
# the above approach
import math
 
# Returns value of Binomial
# Coefficient C(n, k)
def binomialCoeff(n, k):
 
    res = 1
 
    # Since C(n, k) = C(n, n-k)
    if (k > n - k):
        k = n - k
 
    # Calculate value of
    for i in range(0, k):
        res = res * (n - i)
        res = res // (i + 1)
 
    return res
 
# Iterative Function to
# calculate (x^y) in O(log y)
def power(x, y):
     
    # Initialize result
    res = 1
 
    while (y > 0):
 
        # If y is odd, multiply
        # x with result
        if (y & 1):
            res = res * x
 
        # y must be even now
        # y = y/2
        y = y // 2
 
        # Change x to x^2
        x = x * x
     
    return res
 
# Function to find probability
def FindProbability(n):
 
    # Calculate total possible
    # ways and favourable ways.
    up = binomialCoeff(2 * n, n)
    down = power(2, 2 * n)
 
    # Divide by gcd such that
    # they become relatively coprime
    g = math.gcd(up,down)
 
    up = up // g
    down = down // g
 
    print(up, "/", down)
 
# Driver code
N = 8
FindProbability(N)
 
# This code is contributed by Sanjit_Prasad

C#




// C# implementation of
// the above approach
using System;
using System.Collections.Generic;
     
class GFG
{
     
    // Returns value of Binomial
    // Coefficient C(n, k)
    static int binomialCoeff(int n, int k)
    {
        int res = 1;
     
        // Since C(n, k) = C(n, n-k)
        if (k > n - k)
            k = n - k;
     
        // Calculate value of
        for (int i = 0; i < k; ++i)
        {
            res *= (n - i);
            res /= (i + 1);
        }
     
        return res;
    }
     
    // Iterative Function to
    // calculate (x^y) in O(log y)
    static int power(int x, int y)
    {
        // Initialize result
        int res = 1;
     
        while (y > 0)
        {
     
            // If y is odd, multiply
            // x with result
            if ((y & 1) == 1)
                res = res * x;
     
            // y must be even now
            // y = y/2
            y = y >> 1;
     
            // Change x to x^2
            x = x * x;
        }
        return res;
    }
     
    // Recursive function to
    // return gcd of a and b
    static int gcd(int a, int b)
    {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }
     
    // Function to find probability
    static void FindProbability(int n)
    {
     
        // Calculate total possible
        // ways and favourable ways.
        int up = binomialCoeff(2 * n, n);
        int down = power(2, 2 * n);
     
        // Divide by gcd such that
        // they become relatively coprime
        int g = gcd(up, down);
     
        up /= g;
        down /= g;
     
        Console.WriteLine(up + "/" + down);
    }
     
    // Driver code
    public static void Main (String[] args)
    {
        int N = 8;
     
        FindProbability(N);
    }
}
 
// This code is contributed by 29AjayKumar

Javascript




<script>
 
// Javascript implementation of
// the above approach
 
// Returns value of Binomial
// Coefficient C(n, k)
function binomialCoeff(n, k)
{
    let res = 1;
 
    // Since C(n, k) = C(n, n-k)
    if (k > n - k)
        k = n - k;
 
    // Calculate value of
    for (let i = 0; i < k; ++i) {
        res *= (n - i);
        res = parseInt(res / (i + 1));
    }
 
    return res;
}
 
// Iterative Function to
// calculate (x^y) in O(log y)
function power(x, y)
{
    // Initialize result
    let res = 1;
 
    while (y > 0) {
 
        // If y is odd, multiply
        // x with result
        if (y & 1)
            res = res * x;
 
        // y must be even now
        // y = y/2
        y = y >> 1;
 
        // Change x to x^2
        x = x * x;
    }
    return res;
}
 
// Recursive function to
// return gcd of a and b
function gcd(a, b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}
     
// Function to find probability
function FindProbability(n)
{
 
    // Calculate total possible
    // ways and favourable ways.
    let up = binomialCoeff(2 * n, n);
    let down = power(2, 2 * n);
 
    // Divide by gcd such that
    // they become relatively coprime
    let g = gcd(up, down);
 
    up = parseInt(up / g), down = parseInt(down / g);
 
    document.write(up + "/" + down + "<br>");
}
 
// Driver code
 
    let N = 8;
 
    FindProbability(N);
 
</script>
Output: 
6435/32768

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :