Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Count of integers obtained by replacing ? in the given string that give remainder 5 when divided by 13

  • Last Updated : 05 May, 2021

Given string str of length N. The task is to find the number of integers obtained by replacing ‘?’ with any digit such that the formed integer gives remainder 5 when it is divided by 13. 
Numbers can also begin with zero. The answer can be very large, so, output answer modulo 109 + 7.
 

Examples:

Input: str = “?44” 
Output: 1 
Only possible number is 044
Input: str = “7?4” 
Output: 0
Input: str = “8?3?4233?4?” 
Output: 770 

Approach: Let dp[i][j] be the number of ways to create an i-digit number consistent with the first i digits of the given pattern and congruent to j modulo 13. As our base case, dp[0][i]=0 for i from 1 to 12, and dp[0][0]=1 (as our length-zero number has value zero and thus is zero mod 13.)
Notice that appending a digit k to the end of a number that’s j mod 13 gives a number that’s congruent to 10j+k mod 13. We use this fact to perform our transitions. For every state, dp[i][j] with i < N, iterate over the possible values of k. (If s[i]=’?’, there will be ten choices for k, and otherwise, there will only be one choice.) Then, we add dp[i][j] to dp[i+1][(10j+k)%13].
To get our final answer, we can simply print dp[N][5].

Below is the implementation of the above approach : 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
#define MOD (int)(1e9 + 7)
 
// Function to find the count of integers
// obtained by replacing '?' in a given
// string such that formed integer
// gives remainder 5 when it is divided by 13
int modulo_13(string s, int n)
{
    long long dp[n + 1][13] = { { 0 } };
 
    // Initialise
    dp[0][0] = 1;
 
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < 10; j++) {
            int nxt = s[i] - '0';
 
            // Place digit j at ? position
            if (s[i] == '?')
                nxt = j;
 
            // Get the remainder
            for (int k = 0; k < 13; k++) {
                int rem = (10 * k + nxt) % 13;
                dp[i + 1][rem] += dp[i][k];
                dp[i + 1][rem] %= MOD;
            }
            if (s[i] != '?')
                break;
        }
    }
 
    // Return the required answer
    return (int)dp[n][5];
}
 
// Driver code
int main()
{
    string s = "?44";
    int n = s.size();
 
    cout << modulo_13(s, n);
 
    return 0;
}
Java



// Java implementation of the approach
class GFG
{
static int MOD = (int)(1e9 + 7);
 
// Function to find the count of integers
// obtained by replacing '?' in a given
// string such that formed integer
// gives remainder 5 when it is divided by 13
static int modulo_13(String s, int n)
{
    long [][]dp = new long[n + 1][13];
 
    // Initialise
    dp[0][0] = 1;
 
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < 10; j++)
        {
            int nxt = s.charAt(i) - '0';
 
            // Place digit j at ? position
            if (s.charAt(i) == '?')
                nxt = j;
 
            // Get the remainder
            for (int k = 0; k < 13; k++)
            {
                int rem = (10 * k + nxt) % 13;
                dp[i + 1][rem] += dp[i][k];
                dp[i + 1][rem] %= MOD;
            }
            if (s.charAt(i) != '?')
                break;
        }
    }
 
    // Return the required answer
    return (int)dp[n][5];
}
 
// Driver code
public static void main(String []args)
{
    String s = "?44";
    int n = s.length();
 
    System.out.println(modulo_13(s, n));
}
}
 
// This code is contributed by Rajput-Ji
Python3



# Python3 implementation of the approach
import numpy as np
 
MOD = (int)(1e9 + 7)
 
# Function to find the count of integers
# obtained by replacing '?' in a given
# string such that formed integer
# gives remainder 5 when it is divided by 13
def modulo_13(s, n) :
     
    dp = np.zeros((n + 1, 13));
     
    # Initialise
    dp[0][0] = 1;
 
    for i in range(n) :
        for j in range(10) :
            nxt = ord(s[i]) - ord('0');
 
            # Place digit j at ? position
            if (s[i] == '?') :
                nxt = j;
 
            # Get the remainder
            for k in range(13) :
                rem = (10 * k + nxt) % 13;
                dp[i + 1][rem] += dp[i][k];
                dp[i + 1][rem] %= MOD;
         
            if (s[i] != '?') :
                break;
 
    # Return the required answer
    return int(dp[n][5]);
 
# Driver code
if __name__ == "__main__" :
    s = "?44";
    n = len(s);
 
    print(modulo_13(s, n));
 
# This code is contributed by AnkitRai01
C#



// C# implementation of the approach
using System;
                     
class GFG
{
 
static int MOD = (int)(1e9 + 7);
 
// Function to find the count of integers
// obtained by replacing '?' in a given
// string such that formed integer
// gives remainder 5 when it is divided by 13
static int modulo_13(String s, int n)
{
    long [,]dp = new long[n + 1, 13];
 
    // Initialise
    dp[0, 0] = 1;
 
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < 10; j++)
        {
            int nxt = s[i] - '0';
 
            // Place digit j at ? position
            if (s[i] == '?')
                nxt = j;
 
            // Get the remainder
            for (int k = 0; k < 13; k++)
            {
                int rem = (10 * k + nxt) % 13;
                dp[i + 1, rem] += dp[i, k];
                dp[i + 1, rem] %= MOD;
            }
            if (s[i] != '?')
                break;
        }
    }
 
    // Return the required answer
    return (int)dp[n,5];
}
 
// Driver code
public static void Main(String []args)
{
    String s = "?44";
    int n = s.Length;
 
    Console.WriteLine(modulo_13(s, n));
}
}
 
// This code is contributed by 29AjayKumar
Javascript



<script>
// javascript implementation of the approach
 
    var MOD = parseInt(1e9 + 7);
 
    // Function to find the count of integers
    // obtained by replacing '?' in a given
    // string such that formed integer
    // gives remainder 5 when it is divided by 13
    function modulo_13( s , n) {
        var dp = Array(n + 1).fill().map(()=>Array(13).fill(0));
 
        // Initialise
        dp[0][0] = 1;
 
        for (i = 0; i < n; i++) {
            for (j = 0; j < 10; j++) {
                var nxt = s.charAt(i) - '0';
 
                // Place digit j at ? position
                if (s.charAt(i) == '?')
                    nxt = j;
 
                // Get the remainder
                for (k = 0; k < 13; k++) {
                    var rem = (10 * k + nxt) % 13;
                    dp[i + 1][rem] += dp[i][k];
                    dp[i + 1][rem] %= MOD;
                }
                if (s.charAt(i) != '?')
                    break;
            }
        }
 
        // Return the required answer
        return parseInt( dp[n][5]);
    }
 
    // Driver code
     
        var s = "?44";
        var n = s.length;
 
        document.write(modulo_13(s, n));
 
// This code contributed by aashish1995
</script>
Output: 
1
 
Time Complexity: O(100 * N)
Auxiliary Space: O(100 * N)

My Personal Notes
arrow_drop_up
Previous
Virtual machine installation for Cassandra CQL query
Next

PLSQL | SIN Function
Recommended Articles
Page :
Minimum number of operations on a binary string such that it gives 10^A as remainder when divided by 10^B
15, May 19
Largest number by which given 3 numbers should be divided such that they leaves same remainder
26, Nov 17
Program to find remainder when large number is divided by 11
09, Nov 17
Program to find remainder when large number is divided by r
18, Oct 18
Find the remainder when First digit of a number is divided by its Last digit
20, Aug 19
Find the remainder when N is divided by 4 using Bitwise AND operator
14, Apr 20
Largest number less than or equal to Z that leaves a remainder X when divided by Y
16, Apr 20
Smallest subarray whose product leaves remainder K when divided by size of the array
18, Jul 20
Find remainder when a number A raised to N factorial is divided by P
13, Aug 21
Check if the remainder of N-1 factorial when divided by N is N-1 or not
26, Jun 20
Minimize swaps to make remainder equal when an element and its index is divided by K
10, Nov 21
Difference between ceil of array sum divided by K and sum of ceil of array elements divided by K
03, May 21
Absolute difference between floor of Array sum divided by X and floor sum of every Array element when divided by X
15, Jun 21
Modify string by replacing all occurrences of given characters by specified replacing characters
14, Apr 21
Count distinct sequences obtained by replacing all elements of subarrays having equal first and last elements with the first element any number of times
29, Jun 21
Check whether each Array element can be reduced to minimum element by replacing it with remainder with some X
20, Aug 21
Count of pairs of integers up to X and Y that generates equal Quotient and Remainder
02, Jun 21
Check if given Array can be divided into subsequences of K increasing consecutive integers
29, Sep 21
Smallest array that can be obtained by replacing adjacent pairs with their products
04, Oct 20
Find all the possible remainders when N is divided by all positive integers from 1 to N+1
09, Dec 19
Count the number of ways to give ranks for N students such that same ranks are possible
01, May 20
Probability that the sum of all numbers obtained on throwing a dice N times lies between two given integers
13, Jan 21
Number of distinct integers obtained by lcm(X, N)/X
29, Oct 18
Count subarrays such that remainder after dividing sum of elements by K gives count of elements
16, Dec 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
pawan_asipu
@pawan_asipu
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!