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 10⁹ + 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:

Time Complexity: O(100 * N)

Auxiliary Space: O(100 * N)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more, please refer Complete Interview Preparation Course.

My Personal Notes

Related Articles

C++

Java

Python3

C#

Javascript