Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Count all unique outcomes possible by performing S flips on N coins

  • Last Updated : 11 Jun, 2021

Given two positive integers N and S, the task is to count the number of unique outcomes possible when S flip operations are performed on N coins.

Examples:

Input: N = 3, S = 4
Output: 3
Explanation: Considering the initial configuration of coins to be “HHH”, then the possible combinations of 4 flips are:

  1. Flipping the 1st and 2nd coins once and the third coin twice modifies the configuration to “TTH”.
  2. Flipping the 1st and 3rd coins once and the 2nd coin twice modifies the configuration to “THT”.
  3. Flipping the 2nd and 3rd coins once and the 1st coin twice modifies the configuration to “HTT”.

The above three combinations are unique. Therefore, the total count is 3.

Input: N = 3, S = 6
Output: 4

Naive Approach: The given problem can be solved by using recursion whose recursive state is defined as:

  • Consider F(N, S) represents the number of unique outcomes when N coins are tossed with the total number of flips equals to S.
  • Then F(N, S) can also be expressed as the sum of all combinations with 1 flip or 2 flips i.e.,

F(N, S) = F(N – 1, S – 1) + F(N – 1, S – 2)

  • The base case for this recurrence relation is F(K, K) whose value is 1 for all (K > 1).
  • Below is the table that shows the distribution of F(N, S) = F(N – 1, S – 1) + F(N – 1, S – 2), where F(K, K) = 1.

Follow the below steps to solve the problem:

  • Declare a function, say numberOfUniqueOutcomes(N, S) that takes the number of coins and flips allowed as the parameters respectively and perform the following steps:
    • If the value of S is less than N, then return 0 from the function.
    • If the value of N is S or 1, then return 1 from the function as this is one of the unique combinations.
    • Recursively return summation of the two recursive states as:

return numberOfUniqueOutcomes(N – 1, S – 1) + numberOfUniqueOutcomes(N – 1, S – 2)

  • After completing the above steps, print the value returned by the function numberOfUniqueOutcomes(N, S) as the resultant number of outcomes.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to recursively count the
// number of unique outcomes possible
// S flips are performed on N coins
int numberOfUniqueOutcomes(int N, int S)
{
    // Base Cases
    if (S < N)
        return 0;
    if (N == 1 || N == S)
        return 1;
 
    // Recursive Calls
    return (numberOfUniqueOutcomes(N - 1, S - 1)
            + numberOfUniqueOutcomes(N - 1, S - 2));
}
 
// Driver Code
int main()
{
    int N = 3, S = 4;
 
    cout << numberOfUniqueOutcomes(N, S);
 
    return 0;
}
Java



// Java program for the above approach
import java.io.*;
class GFG
{
 
  // Function to recursively count the
  // number of unique outcomes possible
  // S flips are performed on N coins
  static int numberOfUniqueOutcomes(int N, int S)
  {
 
    // Base Cases
    if (S < N)
      return 0;
    if (N == 1 || N == S)
      return 1;
 
    // Recursive Calls
    return (numberOfUniqueOutcomes(N - 1, S - 1)
            + numberOfUniqueOutcomes(N - 1, S - 2));
  }
 
  // Driver Code
  public static void main (String[] args)
  {
    int N = 3, S = 4;
    System.out.println(numberOfUniqueOutcomes(N, S));
  }
}
 
//  This code is contributed by avanitrachhadiya2155
Python3



# Python3 program for the above approach
 
# Function to recursively count the
# number of unique outcomes possible
# S flips are performed on N coins
def numberOfUniqueOutcomes(N, S):
     
    # Base Cases
    if (S < N):
        return 0
    if (N == 1 or N == S):
        return 1
 
    # Recursive Calls
    return (numberOfUniqueOutcomes(N - 1, S - 1) +
            numberOfUniqueOutcomes(N - 1, S - 2))
 
# Driver Code
if __name__ == '__main__':
     
    N, S = 3, 4
 
    print (numberOfUniqueOutcomes(N, S))
 
# This code is contributed by mohit kumar 29
C#



// C# program for the above approach
using System;
 
class GFG{
 
// Function to recursively count the
// number of unique outcomes possible
// S flips are performed on N coins
static int numberOfUniqueOutcomes(int N, int S)
{
     
    // Base Cases
    if (S < N)
        return 0;
    if (N == 1 || N == S)
        return 1;
     
    // Recursive Calls
    return (numberOfUniqueOutcomes(N - 1, S - 1) +
            numberOfUniqueOutcomes(N - 1, S - 2));
}
 
// Driver Code
static public void Main()
{
    int N = 3, S = 4;
     
    Console.WriteLine(numberOfUniqueOutcomes(N, S));
}
}
 
// This code is contributed by sanjoy_62
Javascript



<script>
        // Javascript program for the above approach
 
        // Function to recursively count the
        // number of unique outcomes possible
        // S flips are performed on N coins
        function numberOfUniqueOutcomes(N, S) {
            // Base Cases
            if (S < N)
                return 0;
            if (N == 1 || N == S)
                return 1;
 
            // Recursive Calls
            return (numberOfUniqueOutcomes(N - 1, S - 1)
                + numberOfUniqueOutcomes(N - 1, S - 2));
        }
 
        // Driver Code
 
        let N = 3, S = 4;
 
        document.write(numberOfUniqueOutcomes(N, S))
 
        // This code is contributed by Hritik
    </script>
Output: 
3
 
Time Complexity: O(2N)
Auxiliary Space: O(N)
Efficient Approach: The above approach can also be optimized by storing the recursive states as it contains overlapping subproblems. Therefore, the idea is to use memoization to store the repeated states. Follow the steps below to solve the problem:
  • Initialize a 2D array, say dp[][] of dimensions N*M such that dp[i][j] stores the number of possible outcomes using i coins and j number of flips.
  • Declare a function, say numberOfUniqueOutcomes(N, S), that takes the number of coins and flips allowed as the parameters respectively and perform the following steps:
    • If the value of S is less than N, then update the value of dp[N][S] as 0 and return this value from the function.
    • If the value of N is S or 1, then update the value of dp[N][S] as 1 and return this value from the function as this is one of the unique combinations.
    • If the value of dp[N][S] is already calculated, then return the value dp[N][S] from the function.
    • Recursively update the value of dp[N][S] summation of the two recursive states as shown below and return this value from the function.
dp[N][S] = numberOfUniqueOutcomes(N – 1, S – 1) + numberOfUniqueOutcomes(N – 1, S – 2)
  • After completing the above steps, print the value returned by the function numberOfUniqueOutcomes(N, S) as the resultant number of outcomes.
Below is the implementation of the above approach:
C++



// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Dimensions of the DP table
#define size 1001
 
// Stores the dp states
int ans[size][size] = { 0 };
 
// Function to recursively count the
// number of unique outcomes possible
// by performing S flips on N coins
int numberOfUniqueOutcomes(int n, int s)
{
    // Base Case
    if (s < n)
        ans[n][s] = 0;
 
    else if (n == 1 || n == s)
        ans[n][s] = 1;
 
    // If the count for the current
    // state is not calculated, then
    // calculate it recursively
    else if (!ans[n][s]) {
        ans[n][s] = numberOfUniqueOutcomes(n - 1,
                                           s - 1)
                    + numberOfUniqueOutcomes(n - 1,
                                             s - 2);
    }
 
    // Otherwise return the
    // already calculated value
    return ans[n][s];
}
 
// Driver Code
int main()
{
    int N = 5, S = 8;
 
    cout << numberOfUniqueOutcomes(N, S);
 
    return 0;
}
Java



// Java program for the above approach
 
import java.util.*;
 
class GFG{
  
 // Dimensions of the DP table
static int size = 100;
static int [][]ans = new int[size][size];
   
static void initialize()
{
   
  // Stores the dp states
  for(int i = 0; i < size; i++)
  {
    for(int j = 0; j < size; j++)
    {
        ans[i][j] = 0;
    }
}
}
 
// Function to recursively count the
// number of unique outcomes possible
// by performing S flips on N coins
static int numberOfUniqueOutcomes(int n, int s)
{
    // Base Case
    if (s < n)
        ans[n][s] = 0;
 
    else if (n == 1 || n == s)
        ans[n][s] = 1;
 
    // If the count for the current
    // state is not calculated, then
    // calculate it recursively
    else if (ans[n][s] == 0) {
        ans[n][s] = numberOfUniqueOutcomes(n - 1,
                                           s - 1)
                    + numberOfUniqueOutcomes(n - 1,
                                             s - 2);
    }
 
    // Otherwise return the
    // already calculated value
    return ans[n][s];
}
 
// Driver Code
public static void main(String args[])
{
    initialize();
    int N = 5, S = 8;
    System.out.println(numberOfUniqueOutcomes(N, S));
}
}
 
// This code is contributed by SURENDRA_GANGWAR.
Python3



# Python3 program for the above approach
 
# Dimensions of the DP table
size = 100
 
# Stores the dp states
ans = [[0 for i in range(size)]
          for j in range(size)]
 
# Function to recursively count the
# number of unique outcomes possible
# by performing S flips on N coins
def numberOfUniqueOutcomes(n, s):
     
    # Base Case
    if (s < n):
        ans[n][s] = 0;
     
    elif (n == 1 or n == s):
        ans[n][s] = 1;
     
    # If the count for the current
    # state is not calculated, then
    # calculate it recursively
    elif(ans[n][s] == 0):
        ans[n][s] = (numberOfUniqueOutcomes(n - 1, s - 1) +
                     numberOfUniqueOutcomes(n - 1, s - 2))
     
    # Otherwise return the
    # already calculated value
    return ans[n][s];
 
# Driver Code
N = 5
S = 8
 
print(numberOfUniqueOutcomes(N, S))
 
# This code is contributed by rag2127
C#



// C# program for the above approach
using System;
 
class GFG{
  
// Dimensions of the DP table
static int size = 100;
static int [,]ans = new int[size, size];
   
static void initialize()
{
   
    // Stores the dp states
    for(int i = 0; i < size; i++)
    {
        for(int j = 0; j < size; j++)
        {
            ans[i, j] = 0;
        }
    }
}
 
// Function to recursively count the
// number of unique outcomes possible
// by performing S flips on N coins
static int numberOfUniqueOutcomes(int n, int s)
{
     
    // Base Case
    if (s < n)
        ans[n, s] = 0;
 
    else if (n == 1 || n == s)
        ans[n, s] = 1;
 
    // If the count for the current
    // state is not calculated, then
    // calculate it recursively
    else if (ans[n, s] == 0)
    {
        ans[n, s] = numberOfUniqueOutcomes(n - 1,
                                           s - 1) +
                    numberOfUniqueOutcomes(n - 1,
                                           s - 2);
    }
 
    // Otherwise return the
    // already calculated value
    return ans[n,s];
}
 
// Driver Code
public static void Main(string []args)
{
    initialize();
    int N = 5, S = 8;
     
    Console.WriteLine(numberOfUniqueOutcomes(N, S));
}
}
 
// This code is contributed by AnkThon
Javascript



<script>
 
    // JavaScript program for the above approach
     
    // Dimensions of the DP table
    let size = 100;
    let ans = new Array(size);
 
    function initialize()
    {
 
      // Stores the dp states
      for(let i = 0; i < size; i++)
      {
          ans[i] = new Array(size);
        for(let j = 0; j < size; j++)
        {
            ans[i][j] = 0;
        }
      }
    }
 
    // Function to recursively count the
    // number of unique outcomes possible
    // by performing S flips on N coins
    function numberOfUniqueOutcomes(n, s)
    {
        // Base Case
        if (s < n)
            ans[n][s] = 0;
 
        else if (n == 1 || n == s)
            ans[n][s] = 1;
 
        // If the count for the current
        // state is not calculated, then
        // calculate it recursively
        else if (ans[n][s] == 0) {
            ans[n][s] = numberOfUniqueOutcomes(n - 1,
                                               s - 1)
                        + numberOfUniqueOutcomes(n - 1,
                                                 s - 2);
        }
 
        // Otherwise return the
        // already calculated value
        return ans[n][s];
    }
     
    initialize();
    let N = 5, S = 8;
    document.write(numberOfUniqueOutcomes(N, S));
     
</script>
Output: 
15
 
Time Complexity: O(N*S)
Auxiliary Space: O(N*S)

My Personal Notes
arrow_drop_up
Previous
Minimum increments or decrements required to convert a sorted array into a power sequence
Next

Minimize divisions by 2, 3, or 5 required to make two given integers equal
Recommended Articles
Page :
Find all possible outcomes of a given expression
12, Sep 15
Check if two piles of coins can be emptied by repeatedly removing 2 coins from a pile and 1 coin from the other
22, Mar 21
Minimize coins required to obtain all possible values up to N
28, Jan 21
Average value of set bit count in given Binary string after performing all possible choices of K operations
20, Sep 21
Maximum number of unique values in the array after performing given operations
10, Apr 20
Maximum flips possible such that no pair of adjacent elements are both 1
19, Jan 21
Count all possible unique sum of series K, K+1, K+2, K+3, K+4, ..., K+N
09, Aug 20
Count of distinct possible strings after performing given operations
29, May 20
Minimum number of coins that can generate all the values in the given range
13, Nov 19
Program to find the count of coins of each type from the given ratio
05, Oct 18
Minimum flips required to keep all 1s together in a Binary string
19, May 20
Minimum Subarray flips required to convert all elements of a Binary Array to K
19, Aug 20
Minimize flips on K-length subarrays required to make all array elements equal to 1
09, Mar 21
Minimize flips on adjacent 2 to 3 bits to generate a binary string of all 1s
16, Jan 22
Minimum flips to make mean of all k size sub-arrays less than 1
22, Feb 22
Count of total Heads and Tails after N flips in a coin
21, May 20
Minimum Count of Bit flips required to make a Binary String Palindromic
12, Aug 20
Minimize count of flips required to make sum of the given array equal to 0
31, Jan 21
Queries to count minimum flips required to fill a binary submatrix with 0s only
03, Dec 20
Count squares of unique dimensions possible from given Straight Lines parallel to the axes
29, Oct 20
Minimum possible sum of array elements after performing the given operation
19, Feb 19
Maximum possible array sum after performing the given operation
27, Nov 19
Minimum possible sum of array elements after performing the given operation
14, Apr 20
Maximum score possible after performing given operations on an Array
05, Apr 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
suman_1729
@suman_1729
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!