 Open in App
Not now

# Check if N can be represented as sum of positive integers containing digit D at least once

• Difficulty Level : Hard
• Last Updated : 24 Mar, 2023

Given a positive integer N and a digit D, the task is to check if N can be represented as a sum of positive integers containing the digit D at least once. If it is possible to represent N in such a format, then print “Yes”. Otherwise, print “No”.

Examples:

```Input: N = 24, D = 7
Output: Yes
Explanation: The value 24 can be represented as 17 + 7, both containing the digit 7.```
```Input: N = 27 D = 2
Output: Yes```

Approach 1:

Follow the steps to solve the problem:

1. Check if the given N contains digit D or not. If found to be true, then print “Yes”.
2. Otherwise, iterate until N is greater than 0 and perform the following steps:
3. After completing the above steps, if none of the above conditions satisfies, then print “No”.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to check if N contains` `// digit D in it` `bool` `findDigit(``int` `N, ``int` `D)` `{` `    ``// Iterate until N is positive` `    ``while` `(N > 0) {`   `        ``// Find the last digit` `        ``int` `a = N % 10;`   `        ``// If the last digit is the` `        ``// same as digit D` `        ``if` `(a == D) {` `            ``return` `true``;` `        ``}`   `        ``N /= 10;` `    ``}`   `    ``// Return false` `    ``return` `false``;` `}`   `// Function to check if the value of` `// N can be represented as sum of` `// integers having digit d in it` `bool` `check(``int` `N, ``int` `D)` `{` `    ``// Iterate until N is positive` `    ``while` `(N > 0) {`   `        ``// Check if N contains digit` `        ``// D or not` `        ``if` `(findDigit(N, D) == ``true``) {` `            ``return` `true``;` `        ``}`   `        ``// Subtracting D from N` `        ``N -= D;` `    ``}`   `    ``// Return false` `    ``return` `false``;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 24;` `    ``int` `D = 7;` `    ``if` `(check(N, D)) {` `        ``cout << ``"Yes"``;` `    ``}` `    ``else` `{` `        ``cout << ``"No"``;` `    ``}`   `    ``return` `0;` `}`

## Java

 `// Java approach for the above approach` `import` `java.util.*;`   `class` `GFG{`   `// Function to check if N contains` `// digit D in it` `static` `boolean` `findDigit(``int` `N, ``int` `D)` `{` `    `  `    ``// Iterate until N is positive` `    ``while` `(N > ``0``)` `    ``{` `        `  `        ``// Find the last digit` `        ``int` `a = N % ``10``;`   `        ``// If the last digit is the` `        ``// same as digit D` `        ``if` `(a == D) ` `        ``{` `            ``return` `true``;` `        ``}` `        ``N /= ``10``;` `    ``}`   `    ``// Return false` `    ``return` `false``;` `}`   `// Function to check if the value of` `// N can be represented as sum of` `// integers having digit d in it` `static` `boolean` `check(``int` `N, ``int` `D)` `{` `    `  `    ``// Iterate until N is positive` `    ``while` `(N > ``0``) ` `    ``{` `        `  `        ``// Check if N contains digit` `        ``// D or not` `        ``if` `(findDigit(N, D) == ``true``) ` `        ``{` `            ``return` `true``;` `        ``}` `        `  `        ``// Subtracting D from N` `        ``N -= D;` `    ``}` `    `  `    ``// Return false` `    ``return` `false``;` `}` ` `  `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `N = ``24``;` `    ``int` `D = ``7``;` `    `  `    ``if` `(check(N, D)) ` `    ``{` `        ``System.out.print(``"Yes"``);` `    ``}` `    ``else` `    ``{` `        ``System.out.print(``"No"``);` `    ``}` `}` `}`   `// This code is contributed by sanjoy_62`

## Python3

 `# Python3 program for the above approach`   `# Function to check if N contains` `# digit D in it` `def` `findDigit(N, D):` `    `  `    ``# Iterate until N is positive` `    ``while` `(N > ``0``):` `        `  `        ``# Find the last digit` `        ``a ``=` `N ``%` `10`   `        ``# If the last digit is the` `        ``# same as digit D` `        ``if` `(a ``=``=` `D):` `            ``return` `True`   `        ``N ``/``=` `10`   `    ``# Return false` `    ``return` `False`   `# Function to check if the value of` `# N can be represented as sum of` `# integers having digit d in it` `def` `check(N, D):` `    `  `    ``# Iterate until N is positive` `    ``while` `(N > ``0``):`   `        ``# Check if N contains digit` `        ``# D or not` `        ``if` `(findDigit(N, D) ``=``=` `True``):` `            ``return` `True`   `        ``# Subtracting D from N` `        ``N ``-``=` `D`   `    ``# Return false` `    ``return` `False`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``N ``=` `24` `    ``D ``=` `7` `    `  `    ``if` `(check(N, D)):` `        ``print``(``"Yes"``)` `    ``else``:` `        ``print``(``"No"``)`   `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach` `using` `System;` ` `  `class` `GFG{` ` `  `// Function to check if N contains` `// digit D in it` `static` `bool` `findDigit(``int` `N, ``int` `D)` `{` `     `  `    ``// Iterate until N is positive` `    ``while` `(N > 0)` `    ``{` `         `  `        ``// Find the last digit` `        ``int` `a = N % 10;` ` `  `        ``// If the last digit is the` `        ``// same as digit D` `        ``if` `(a == D)` `        ``{` `            ``return` `true``;` `        ``}` `        ``N /= 10;` `    ``}` ` `  `    ``// Return false` `    ``return` `false``;` `}` ` `  `// Function to check if the value of` `// N can be represented as sum of` `// integers having digit d in it` `static` `bool` `check(``int` `N, ``int` `D)` `{` `     `  `    ``// Iterate until N is positive` `    ``while` `(N > 0)` `    ``{` `         `  `        ``// Check if N contains digit` `        ``// D or not` `        ``if` `(findDigit(N, D) == ``true``)` `        ``{` `            ``return` `true``;` `        ``}` `         `  `        ``// Subtracting D from N` `        ``N -= D;` `    ``}` `     `  `    ``// Return false` `    ``return` `false``;` `}`   ` `  `// Driver Code` `public` `static` `void` `Main()` `{` `    ``int` `N = 24;` `    ``int` `D = 7;` `     `  `    ``if` `(check(N, D))` `    ``{` `        ``Console.WriteLine(``"Yes"``);` `    ``}` `    ``else` `    ``{` `        ``Console.WriteLine(``"No"``);` `    ``}` `     `  `}` `}`   `// This code is contributed by code_hunt.`

## Javascript

 ``

Output:

`Yes`

Time Complexity: O(N)
Auxiliary Space: O(1)

Approach 2: Dynamic Programming

We can solve this problem using Dynamic Programming (DP). We can create a DP array of size N+1, where DP[i] stores whether it is possible to represent i as the sum of numbers having the digit D in them or not. We can initialize DP as true since it is always possible to represent 0 as the sum of no numbers.

Then, for each i from 1 to N, we can check if i contains the digit D. If it does, then we can mark DP[i] as true. Otherwise, we can iterate over all possible j < i such that DP[j] is true, and check if i-j contains the digit D. If it does, then we can mark DP[i] as true.

At the end, we can check if DP[N] is true or not. If it is, then we can say that N can be represented as the sum of numbers having the digit D in them. Otherwise, we can say that it is not possible.

## C++

 `#include ` `#include `   `using` `namespace` `std;`   `bool` `check(``int` `N, ``int` `D)` `{` `    ``// Create DP array` `    ``bool` `DP[N + 1];`   `    ``// Initialize DP` `    ``memset``(DP, ``false``, ``sizeof``(DP));` `    ``DP = ``true``;`   `    ``// Fill DP array` `    ``for` `(``int` `i = 1; i <= N; i++) {` `        ``// Check if i contains digit D` `        ``if` `(i % 10 == D || i / 10 == D) {` `            ``DP[i] = ``true``;` `            ``continue``;` `        ``}` `        ``// Iterate over all j < i such that DP[j] is true` `        ``for` `(``int` `j = 1; j < i; j++) {` `            ``if` `(DP[j]` `                ``&& ((i - j) % 10 == D` `                    ``|| (i - j) / 10 == D)) {` `                ``DP[i] = ``true``;` `                ``break``;` `            ``}` `        ``}` `    ``}` `    ``// Return DP[N]` `    ``return` `DP[N];` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 24;` `    ``int` `D = 7;` `    ``if` `(check(N, D)) {` `        ``cout << ``"Yes"``;` `    ``}` `    ``else` `{` `        ``cout << ``"No"``;` `    ``}`   `    ``return` `0;` `}`

Output

`Yes`

Time Complexity: O(N^(1/3)log(N)), where N is the input number.
Auxiliary Space: O(N^(1/3)), since we are storing all perfect cubes up to N^(1/3) in the map.

My Personal Notes arrow_drop_up
Related Articles