# Count ways to make the number formed by K concatenations of a numeric string divisible by 5

• Last Updated : 19 Jul, 2022

Given a string S consisting of N digits and an integer K, the task is to count the number of ways to remove digits from the number formed by the concatenating the string S, K number of times, such that the resulting string is divisible by 5. Since count can be very large, so print it to modulo 109 + 7.

Examples:

Input: S = 1256, K = 1
Output: 4
Explanation:
Following are the ways to remove the characters so that the string S(= “1256”) is divisible by 5:

1. Remove the character 6 from the string S modifies the string to 125, which is divisible by 5.
2. Remove the character 1, and 6 from the string S modifies the string to 25, which is divisible by 5.
3. Remove the character 2, and 6 from the string S modifies the string to 15, which is divisible by 5.
4. Remove the character 1, 2, and 6 from the string S modifies the string to 5, which is divisible by 5.

Therefore, the total count of numbers formed which is divisible by 5 is 4.

Input: S = 13390, K = 2
Output: 528

Approach: The given problem can be solved by the fact that the number is divisible by 5 if and only if its last digit is either 0 or 5. If sol[i] is the number of ways to form the numbers divisible by 5 ending at i, then the count of numbers is given by (sol[1] + sol[2] + â€¦ + sol[N]). For each index i, on the right of i, the choice is to delete all digits and on the left of i, then there are two choices, either to delete or to take i.e., 2(i – 1)

Therefore, the total count of numbers for K number of concatenation is given by:

ans = ans * (2(K*N) -1) / (2N â€“ 1)

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;``typedef` `long` `long` `LL;``const` `int` `MOD = 1000000007;` `// Function to find the value of a^b``// modulo 1000000007``int` `exp_mod(LL a, LL b)``{` `    ``// Stores the resultant value a^b``    ``LL ret = 1;` `    ``// Find the value of a^b``    ``for` `(; b; b >>= 1, a = a * a % MOD) {``        ``if` `(b & 1)``            ``ret = ret * a % MOD;``    ``}` `    ``return` `ret;``}` `// Function to count the number of ways``// such that the formed number is divisible``// by 5 by removing digits``int` `countOfWays(string s, ``int` `k)``{``    ``int` `N = s.size();` `    ``// Stores the count of ways``    ``LL ans = 0;` `    ``// Find the count for string S``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// If the digit is 5 or 0``        ``if` `(s[i] == ``'5'` `|| s[i] == ``'0'``) {``            ``ans = (ans + exp_mod(2, i)) % MOD;``        ``}``    ``}` `    ``// Find the count of string for K``    ``// concatenation of string S``    ``LL q = exp_mod(2, N);``    ``LL qk = exp_mod(q, k);``    ``LL inv = exp_mod(q - 1, MOD - 2);` `    ``// Find the total count``    ``ans = ans * (qk - 1) % MOD;``    ``ans = ans * inv % MOD;` `    ``return` `ans;``}` `// Driver Code``int` `main()``{``    ``string S = ``"1256"``;``    ``int` `K = 1;``    ``cout << countOfWays(S, K);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``class` `GFG``{``  ``static` `long` `MOD = ``1000000007``;` `  ``// Function to find the value of a^b``  ``// modulo 1000000007``  ``public` `static` `long` `exp_mod(``long` `a, ``long` `b) {` `    ``// Stores the resultant value a^b``    ``long` `ret = ``1``;` `    ``// Find the value of a^b``    ``for` `(; b > ``0``; b >>= ``1``, a = a * a % MOD) {``      ``if` `((b & ``1``) > ``0``)``        ``ret = ret * a % MOD;``    ``}` `    ``return` `ret;``  ``}` `  ``// Function to count the number of ways``  ``// such that the formed number is divisible``  ``// by 5 by removing digits``  ``public` `static` `long` `countOfWays(String s, ``int` `k) {``    ``int` `N = s.length();` `    ``// Stores the count of ways``    ``long` `ans = ``0``;` `    ``// Find the count for string S``    ``for` `(``int` `i = ``0``; i < N; i++) {` `      ``// If the digit is 5 or 0``      ``if` `(s.charAt(i) == ``'5'` `|| s.charAt(``0``) == ``'0'``) {``        ``ans = (ans + exp_mod(``2``, i)) % MOD;``      ``}``    ``}` `    ``// Find the count of string for K``    ``// concatenation of string S``    ``long` `q = exp_mod(``2``, N);``    ``long` `qk = exp_mod(q, k);``    ``long` `inv = exp_mod(q - ``1``, MOD - ``2``);` `    ``// Find the total count``    ``ans = ans * (qk - ``1``) % MOD;``    ``ans = ans * inv % MOD;` `    ``return` `ans;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main(String args[]) {``    ``String S = ``"1256"``;``    ``int` `K = ``1``;``    ``System.out.println(countOfWays(S, K));` `  ``}` `}` `// This code is contributed by _saurabh_jaiswal.`

## Python3

 `# Python program for the above approach``MOD ``=` `1000000007` `# Function to find the value of a^b``# modulo 1000000007``def` `exp_mod(a, b):``    ` `    ``# Stores the resultant value a^b``    ``ret ``=` `1``    ` `    ``# Find the value of a^b``    ``while``(b):``        ``if` `(b & ``1``):``            ``ret ``=` `ret ``*` `a ``%` `MOD``        ``b >>``=` `1``        ``a ``=` `a ``*` `a ``%` `MOD``    ` `    ``return` `ret` `# Function to count the number of ways``# such that the formed number is divisible``# by 5 by removing digits``def` `countOfWays(s, k):``    ` `    ``N ``=` `len``(s)``    ` `    ``# Stores the count of ways``    ``ans ``=` `0``    ` `    ``# Find the count for string S``    ``for` `i ``in` `range``(N):``        ` `        ``# If the digit is 5 or 0``        ``if` `(s[i] ``=``=` `'5'` `or` `s[i] ``=``=` `'0'``):``            ``ans ``=` `(ans ``+` `exp_mod(``2``, i)) ``%` `MOD``            ` `    ``# Find the count of string for K``    ``# concatenation of string S``    ``q ``=` `exp_mod(``2``, N)``    ``qk ``=` `exp_mod(q, k)``    ``inv ``=` `exp_mod(q ``-` `1``, MOD ``-` `2``)``    ` `    ``# Find the total count``    ``ans ``=` `ans ``*` `(qk ``-` `1``) ``%` `MOD``    ``ans ``=` `ans ``*` `inv ``%` `MOD``    ` `    ``return` `ans` `# Driver Code``S ``=` `"1256"``K ``=` `1``print``(countOfWays(S, K))` `# This code is contributed by shivani`

## C#

 `// C# program for the above approach``using` `System;` `public` `class` `GFG``{``  ``static` `long` `MOD = 1000000007;` `  ``// Function to find the value of a^b``  ``// modulo 1000000007``  ``public` `static` `long` `exp_mod(``long` `a, ``long` `b) {` `    ``// Stores the resultant value a^b``    ``long` `ret = 1;` `    ``// Find the value of a^b``    ``for` `(; b > 0; b >>= 1, a = a * a % MOD) {``      ``if` `((b & 1) > 0)``        ``ret = ret * a % MOD;``    ``}` `    ``return` `ret;``  ``}` `  ``// Function to count the number of ways``  ``// such that the formed number is divisible``  ``// by 5 by removing digits``  ``public` `static` `long` `countOfWays(String s, ``int` `k) {``    ``int` `N = s.Length;` `    ``// Stores the count of ways``    ``long` `ans = 0;` `    ``// Find the count for string S``    ``for` `(``int` `i = 0; i < N; i++) {` `      ``// If the digit is 5 or 0``      ``if` `(s[i] == ``'5'` `|| s[0] == ``'0'``) {``        ``ans = (ans + exp_mod(2, i)) % MOD;``      ``}``    ``}` `    ``// Find the count of string for K``    ``// concatenation of string S``    ``long` `q = exp_mod(2, N);``    ``long` `qk = exp_mod(q, k);``    ``long` `inv = exp_mod(q - 1, MOD - 2);` `    ``// Find the total count``    ``ans = ans * (qk - 1) % MOD;``    ``ans = ans * inv % MOD;` `    ``return` `ans;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(String []args) {``    ``String S = ``"1256"``;``    ``int` `K = 1;``    ``Console.WriteLine(countOfWays(S, K));` `  ``}` `}` `// This code is contributed by shikhasingrajput`

## Javascript

 `// JavaScript program for the above approach``let MOD = 1000000007;` `// Function to find the value of a^b``// modulo 1000000007``function` `exp_mod(a, b)``{``    ``a = BigInt(a);``    ``b = BigInt(b);``    ` `    ``// Stores the resultant value a^b``    ``let ret = 1n;` `    ``// Find the value of a^b``    ``for` `(; b; b >>= 1n, a = a * a % BigInt(MOD)) {``        ``if` `(b & 1n)``            ``ret = ret * a % BigInt(MOD);``    ``}` `    ``return` `parseInt(ret);``}` `// Function to count the number of ways``// such that the formed number is divisible``// by 5 by removing digits``function` `countOfWays(s, k)``{``    ``let N = s.length;` `    ``// Stores the count of ways``    ``let ans = 0;``    ``// Find the count for string S``    ``for` `(``var` `i = 0; i < N; i++) {``        ``// If the digit is 5 or 0``        ``if` `(s[i] == ``'5'` `|| s[i] == ``'0'``) {``            ` `            ``ans += (exp_mod(2, i)) % MOD;``            ``ans %= MOD;``        ``}``        ` `    ``}` `    ``// Find the count of string for K``    ``// concatenation of string S``    ``let q = exp_mod(2, N);``    ``let qk = exp_mod(q, k);``    ``let inv = exp_mod(q - 1, MOD - 2);` `    ``// Find the total count``    ``ans = (ans * (qk - 1)) % MOD;``    ``ans = (ans * inv) % MOD;` `    ``return` `ans;``}` `// Driver Code``let S = ``"1256"``;``let K = 1;``console.log(countOfWays(S, K));` `// This code is contributed by phasing17`

Output:

`4`

Time Complexity: O(N*log K)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up