Skip to content
Related Articles
Number of ways of scoring R runs in B balls with at most W wickets
• Difficulty Level : Hard
• Last Updated : 18 May, 2021

Given three integers R, B and W which denote the number of runs, balls and wickets. One can score 0, 1, 2, 3, 4, 6 or a wicket in a single ball in a cricket match. The task is to count the number of ways in which a team can score exactly R runs in exactly B balls with at-most W wickets. Since the number of ways will be large, print the answer modulo 1000000007
Examples:

Input: R = 4, B = 2, W = 2
Output:
The 7 ways are:
0, 4
4, 0
Wicket, 4
4, Wicket
1, 3
3, 1
2, 2
Input: R = 40, B = 10, W = 4
Output: 653263

Approach: The problem can be solved using Dynamic Programming and Combinatorics. The recurrence will have 6 states, we initially start with runs = 0, balls = 0 and wickets = 0. The states will be:

• If a team scores 1 run off a ball then runs = runs + 1 and balls = balls + 1.
• If a team scores 2 runs off a ball then runs = runs + 2 and balls = balls + 1.
• If a team scores 3 runs off a ball then runs = runs + 3 and balls = balls + 1.
• If a team scores 4 runs off a ball then runs = runs + 4 and balls = balls + 1.
• If a team scores 6 runs off a ball then runs = runs + 6 and balls = balls + 1.
• If a team scores no run off a ball then runs = runs and balls = balls + 1.
• If a team loses 1 wicket off a ball then runs = runs and balls = balls + 1 and wickets = wickets + 1.

The DP will consist of three states, with the run state being a maximum of 6 * Balls, since it is the maximum possible. Hence dp[i][j][k] denotes the number of ways in which i runs can be scored in exactly j balls with losing k wickets
Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;``#define mod 1000000007``#define RUNMAX 300``#define BALLMAX 50``#define WICKETMAX 10` `// Function to return the number of ways``// to score R runs in B balls with``// at most W wickets``int` `CountWays(``int` `r, ``int` `b, ``int` `l, ``int` `R, ``int` `B, ``int` `W,``              ``int` `dp[RUNMAX][BALLMAX][WICKETMAX])``{` `    ``// If the wickets lost are more``    ``if` `(l > W)``        ``return` `0;` `    ``// If runs scored are more``    ``if` `(r > R)``        ``return` `0;` `    ``// If condition is met``    ``if` `(b == B && r == R)``        ``return` `1;` `    ``// If no run got scored``    ``if` `(b == B)``        ``return` `0;` `    ``// Already visited state``    ``if` `(dp[r][b][l] != -1)``        ``return` `dp[r][b][l];` `    ``int` `ans = 0;` `    ``// If scored 0 run``    ``ans += CountWays(r, b + 1, l, R, B, W, dp);``    ``ans = ans % mod;` `    ``// If scored 1 run``    ``ans += CountWays(r + 1, b + 1, l, R, B, W, dp);``    ``ans = ans % mod;` `    ``// If scored 2 runs``    ``ans += CountWays(r + 2, b + 1, l, R, B, W, dp);``    ``ans = ans % mod;` `    ``// If scored 3 runs``    ``ans += CountWays(r + 3, b + 1, l, R, B, W, dp);``    ``ans = ans % mod;` `    ``// If scored 4 runs``    ``ans += CountWays(r + 4, b + 1, l, R, B, W, dp);``    ``ans = ans % mod;` `    ``// If scored 6 runs``    ``ans += CountWays(r + 6, b + 1, l, R, B, W, dp);``    ``ans = ans % mod;` `    ``// If scored no run and lost a wicket``    ``ans += CountWays(r, b + 1, l + 1, R, B, W, dp);``    ``ans = ans % mod;` `    ``// Memoize and return``    ``return` `dp[r][b][l] = ans;``}` `// Driver code``int` `main()``{``    ``int` `R = 40, B = 10, W = 4;` `    ``int` `dp[RUNMAX][BALLMAX][WICKETMAX];``    ``memset``(dp, -1, ``sizeof` `dp);` `    ``cout << CountWays(0, 0, 0, R, B, W, dp);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach` `class` `GFG``{``     ` `static` `int` `mod = ``1000000007``;``static` `int` `RUNMAX = ``300``;``static` `int` `BALLMAX = ``50``;``static` `int` `WICKETMAX = ``10``;`` ` `// Function to return the number of ways``// to score R runs in B balls with``// at most W wickets``static` `int` `CountWays(``int` `r, ``int` `b, ``int` `l,``                    ``int` `R, ``int` `B, ``int` `W,``                            ``int` `[][][]dp)``{`` ` `    ``// If the wickets lost are more``    ``if` `(l > W)``        ``return` `0``;`` ` `    ``// If runs scored are more``    ``if` `(r > R)``        ``return` `0``;`` ` `    ``// If condition is met``    ``if` `(b == B && r == R)``        ``return` `1``;`` ` `    ``// If no run got scored``    ``if` `(b == B)``        ``return` `0``;`` ` `    ``// Already visited state``    ``if` `(dp[r][b][l] != -``1``)``        ``return` `dp[r][b][l];`` ` `    ``int` `ans = ``0``;`` ` `    ``// If scored 0 run``    ``ans += CountWays(r, b + ``1``, l, R, B, W, dp);``    ``ans = ans % mod;`` ` `    ``// If scored 1 run``    ``ans += CountWays(r + ``1``, b + ``1``, l, R, B, W, dp);``    ``ans = ans % mod;`` ` `    ``// If scored 2 runs``    ``ans += CountWays(r + ``2``, b + ``1``, l, R, B, W, dp);``    ``ans = ans % mod;`` ` `    ``// If scored 3 runs``    ``ans += CountWays(r + ``3``, b + ``1``, l, R, B, W, dp);``    ``ans = ans % mod;`` ` `    ``// If scored 4 runs``    ``ans += CountWays(r + ``4``, b + ``1``, l, R, B, W, dp);``    ``ans = ans % mod;`` ` `    ``// If scored 6 runs``    ``ans += CountWays(r + ``6``, b + ``1``, l, R, B, W, dp);``    ``ans = ans % mod;`` ` `    ``// If scored no run and lost a wicket``    ``ans += CountWays(r, b + ``1``, l + ``1``, R, B, W, dp);``    ``ans = ans % mod;`` ` `    ``// Memoize and return``    ``return` `dp[r][b][l] = ans;``}`` ` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `R = ``40``, B = ``10``, W = ``4``;`` ` `    ``int``[][][] dp = ``new` `int``[RUNMAX][BALLMAX][WICKETMAX];``    ``for``(``int` `i = ``0``; i < RUNMAX;i++)``        ``for``(``int` `j = ``0``; j < BALLMAX; j++)``            ``for``(``int` `k = ``0``; k < WICKETMAX; k++)``    ``dp[i][j][k]=-``1``;`` ` `    ``System.out.println(CountWays(``0``, ``0``, ``0``, R, B, W, dp));``}``}` `// This code has been contributed by 29AjayKumar`

## Python3

 `# Python3 implementation of the approach``mod ``=` `1000000007``RUNMAX ``=` `300``BALLMAX ``=` `50``WICKETMAX ``=` `10` `# Function to return the number of ways``# to score R runs in B balls with``# at most W wickets``def` `CountWays(r, b, l, R, B, W, dp):``    ` `    ``# If the wickets lost are more``    ``if` `(l > W):``        ``return` `0``;` `    ``# If runs scored are more``    ``if` `(r > R):``        ``return` `0``;` `    ``# If condition is met``    ``if` `(b ``=``=` `B ``and` `r ``=``=` `R):``        ``return` `1``;` `    ``# If no run got scored``    ``if` `(b ``=``=` `B):``        ``return` `0``;` `    ``# Already visited state``    ``if` `(dp[r][b][l] !``=` `-``1``):``        ``return` `dp[r][b][l]``        ` `    ``ans ``=` `0``;` `    ``# If scored 0 run``    ``ans ``+``=` `CountWays(r, b ``+` `1``, l,``                     ``R, B, W, dp);``    ``ans ``=` `ans ``%` `mod;` `    ``# If scored 1 run``    ``ans ``+``=` `CountWays(r ``+` `1``, b ``+` `1``, l,``                     ``R, B, W, dp);``    ``ans ``=` `ans ``%` `mod;` `    ``# If scored 2 runs``    ``ans ``+``=` `CountWays(r ``+` `2``, b ``+` `1``, l,``                     ``R, B, W, dp);``    ``ans ``=` `ans ``%` `mod;` `    ``# If scored 3 runs``    ``ans ``+``=` `CountWays(r ``+` `3``, b ``+` `1``, l,``                     ``R, B, W, dp);``    ``ans ``=` `ans ``%` `mod;` `    ``# If scored 4 runs``    ``ans ``+``=` `CountWays(r ``+` `4``, b ``+` `1``, l,``                     ``R, B, W, dp);``    ``ans ``=` `ans ``%` `mod;` `    ``# If scored 6 runs``    ``ans ``+``=` `CountWays(r ``+` `6``, b ``+` `1``, l,``                     ``R, B, W, dp);``    ``ans ``=` `ans ``%` `mod;` `    ``# If scored no run and lost a wicket``    ``ans ``+``=` `CountWays(r, b ``+` `1``, l ``+` `1``,``                     ``R, B, W, dp);``    ``ans ``=` `ans ``%` `mod;``    ` `    ``# Memoize and return``    ``dp[r][b][l] ``=` `ans``    ` `    ``return` `ans;``    ` `# Driver code   ``if` `__name__``=``=``"__main__"``:``    ` `    ``R ``=` `40``    ``B ``=` `10``    ``W ``=` `40``    ` `    ``dp ``=` `[[[``-``1` `for` `k ``in` `range``(WICKETMAX)]``               ``for` `j ``in` `range``(BALLMAX)]``               ``for` `i ``in` `range``(RUNMAX)]``    ` `    ``print``(CountWays(``0``, ``0``, ``0``, R, B, W, dp))` `# This code is contributed by rutvik_56`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections.Generic;``using` `System.Linq;` `class` `GFG``{``    ` `static` `int` `mod = 1000000007;``static` `int` `RUNMAX = 300;``static` `int` `BALLMAX = 50;``static` `int` `WICKETMAX = 10;` `// Function to return the number of ways``// to score R runs in B balls with``// at most W wickets``static` `int` `CountWays(``int` `r, ``int` `b, ``int` `l,``                    ``int` `R, ``int` `B, ``int` `W,``                            ``int` `[,,]dp)``{` `    ``// If the wickets lost are more``    ``if` `(l > W)``        ``return` `0;` `    ``// If runs scored are more``    ``if` `(r > R)``        ``return` `0;` `    ``// If condition is met``    ``if` `(b == B && r == R)``        ``return` `1;` `    ``// If no run got scored``    ``if` `(b == B)``        ``return` `0;` `    ``// Already visited state``    ``if` `(dp[r, b, l] != -1)``        ``return` `dp[r, b, l];` `    ``int` `ans = 0;` `    ``// If scored 0 run``    ``ans += CountWays(r, b + 1, l, R, B, W, dp);``    ``ans = ans % mod;` `    ``// If scored 1 run``    ``ans += CountWays(r + 1, b + 1, l, R, B, W, dp);``    ``ans = ans % mod;` `    ``// If scored 2 runs``    ``ans += CountWays(r + 2, b + 1, l, R, B, W, dp);``    ``ans = ans % mod;` `    ``// If scored 3 runs``    ``ans += CountWays(r + 3, b + 1, l, R, B, W, dp);``    ``ans = ans % mod;` `    ``// If scored 4 runs``    ``ans += CountWays(r + 4, b + 1, l, R, B, W, dp);``    ``ans = ans % mod;` `    ``// If scored 6 runs``    ``ans += CountWays(r + 6, b + 1, l, R, B, W, dp);``    ``ans = ans % mod;` `    ``// If scored no run and lost a wicket``    ``ans += CountWays(r, b + 1, l + 1, R, B, W, dp);``    ``ans = ans % mod;` `    ``// Memoize and return``    ``return` `dp[r, b, l] = ans;``}` `// Driver code``static` `void` `Main()``{``    ``int` `R = 40, B = 10, W = 4;` `    ``int``[,,] dp = ``new` `int``[RUNMAX, BALLMAX, WICKETMAX];``    ``for``(``int` `i = 0; i < RUNMAX;i++)``        ``for``(``int` `j = 0; j < BALLMAX; j++)``            ``for``(``int` `k = 0; k < WICKETMAX; k++)``    ``dp[i, j, k]=-1;` `    ``Console.WriteLine(CountWays(0, 0, 0, R, B, W, dp));``}``}` `// This code is contributed by mits`

## Javascript

 ``
Output:
`653263`

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 industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up