Open In App

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

Improve
Improve
Like Article
Like
Save
Share
Report

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 <bits/stdc++.h>
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)



Last Updated : 19 Jul, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads