GFG App
Open App
Browser
Continue

# Count ways to represent N as sum of palindromic integers which do not have digit 1

Given a positive integer N, the task is to find the number of distinct ways to express N as a sum of positive palindromic integers which do not have the digit 1 in them.

Note: As the answer can be quite large, print it modulo 109+7.

Examples:

Input: N = 4
Output: 2
Explanation: Following are the 2 Multisets that satisfy the condition:
1. 2+2 = 4
2. 4 = 4

Input: N = 8
Output: 7
Explanation: Following are the distinct Multisets that satisfy the condition:
1. 2+2+2+2 = 8
2. 2+3+3 = 8
3. 2+2+4 = 8
4. 4+4 = 8
5. 3+5 = 8
6. 2+6 = 8
7. 8 = 8

Approach:

Here each palindromic integers that don’t have the digit 1 can come an infinite number of times. (Repetition allowed), this is what we call Unbounded Knapsack

• We have 2 choices for a palindromic number without a digit 1, either i) to include, or ii) to exclude.  But here, the inclusion process is not for just once; we can include any palindromic number without a single one any number of times until N < Sum.
• Basically, If we are at V[m], we can take as many instances of that integer ( unbounded inclusion ) i.e count(V, m, sum â€“ V[m] )  then we move to V[m-1]. After moving to V[m-1], we canâ€™t move back and canâ€™t make choices for V[m] i.e count(V, m-1, sum).
• To find the total number of ways, so we have to add these 2 possible choices, i.e count(V, m, sum â€“ S[m] ) + count(V, m-1, sum ).

Follow the steps given below for a better approach:

• Declare a vector V to store all the numbers less than N which are palindrome and do not contain the digit 1.
• Use a recursive function and in each recursive call, pass the vector V and the index integer(m) and the value of N (sum).
• In each iteration, perform two recursive calls,
• In one of them decrease m(index element) by 1 and
• On the other one decrease the value of sum by V[m].
• If the sum became 0 then return 1. So it will be added to the final answer which we return.
• If sum or m is less than 0, then return 0.

Below is the implementation of the above approach.

## C++

```// C++ code to implement the approach

#include <bits/stdc++.h>
using namespace std;

int mod = 1e9 + 7;

// Function for checking if
// the given integer is palindrome or not
bool isPalindrome(int i)
{
string x = to_string(i);
int n = x.length();
int cnt_one = 0;
for (int i = 0; i < n / 2; i++) {
if (x[i] == '1') {
cnt_one++;
}
if (x[i] == x[n - 1 - i]) {
continue;
}
else {
return false;
}
}
if (cnt_one == 1)
return false;
return true;
}

// Helper function
int helper(vector<int>& V, int m, int sum)
{
// Base cases

// As there is 1 way which is the empty set
if (sum == 0)
return 1;

// If sum is negative then there is no way
if (sum < 0)
return 0;

// If no integer left and the sum is not 0
// then we cannot make sum 0
if (m < 0 && sum > 0)
return 0;

return (helper(V, m - 1, sum) % mod
+ helper(V, m, sum - V[m]) % mod)
% mod;
}

// Function to find the count of ways
int countMultiSet(int N)
{
vector<int> V;

// Vector storing the palindromic number till n
for (int i = 2; i <= N; i++) {
if (isPalindrome(i)) {
V.push_back(i);
}
}

// Calling the helper function
return helper(V, V.size() - 1, N);
}

// driver function
int main()
{
int N = 8;

// calling the function
cout << countMultiSet(N);
return 0;
}```

## Java

```/*package whatever //do not write package name here */
import java.io.*;
import java.util.ArrayList;

class GFG {

// Function for checking if
// the given integer is palindrome or not
static boolean isPalindrome(Integer i)
{
String x = i.toString();
int n = x.length();
int cnt_one = 0;
for (int j = 0; j < n / 2; i++) {
if (x.charAt(j) == '1') {
cnt_one++;
}
if (x.charAt(j) == x.charAt(n - 1- j)) {
continue;
}
else {
return false;
}
}
if (cnt_one == 1)
return false;
return true;
}

// Helper function
static int helper(ArrayList<Integer> V, int m, int sum)
{
// Base cases

// As there is 1 way which is the empty set
if (sum == 0)
return 1;

// If sum is negative then there is no way
if (sum < 0)
return 0;

// If no integer left and the sum is not 0
// then we cannot make sum 0
if (m < 0 && sum > 0)
return 0;

return (helper(V, m - 1, sum) % (1000000007)
+ helper(V, m, sum - V.get(m)) % (1000000007))
% (1000000007);
}

// Function to find the count of ways
static int countMultiSet(int N)
{
ArrayList<Integer> V = new ArrayList<Integer>();

// List storing the palindromic number till n
for (int i = 2; i <= N; i++) {
if (isPalindrome(i)) {
}
}

// Calling the helper function
return helper(V, V.size() - 1, N);
}
public static void main (String[] args) {
int N = 8;

// calling the function
System.out.println(countMultiSet(N));
}
}

// This code is contributed by hrithikgarg03188.```

## Python3

```# Python3 code to implement the approach
mod = 1e9 + 7

# Function for checking if
# the given integer is palindrome or not
def isPalindrome(i):
x = str(i)
n = len(x)
cnt_one = 0

for i in range(0, int(n/2)):

if (x[i] is '1'):
cnt_one = cnt_one+1
if (x[i] is x[n - 1 - i]):
continue
else:
return false
if (cnt_one is 1):
return False
return True
# Helper function
def helper(V, m, sum):
# Base cases

# As there is 1 way which is the empty set
if (sum is 0):
return 1

# If sum is negative then there is no way
if (sum < 0):
return 0

# If no integer left and the sum is not 0
# then we cannot make sum 0
if (m < 0 and sum > 0):
return 0

return (helper(V, m - 1, sum) % mod + helper(V, m, sum - V[m]) % mod) % mod

# Function to find the count of ways
def countMultiSet(N):
V = []

# Vector storing the palindromic number till n
for i in range(2, N+1):
if (isPalindrome(i)):
V.append(i)

# Calling the helper function
return helper(V, len(V) - 1, N)

# driver function
N = 8

# calling the function
ans = countMultiSet(N)
print(int(ans))

# This code is contributed by akashish__
```

## C#

```using System;
using System.Collections.Generic;

public class GFG {

// Function for checking if
// the given integer is palindrome or not
public static bool isPalindrome(int i)
{
string x = i.ToString();
int n = x.Length;
int cnt_one = 0;
for (int j = 0; j < n / 2; i++) {
if (x[j] == '1') {
cnt_one++;
}
if (x[j] == x[n - 1 - j]) {
continue;
}
else {
return false;
}
}
if (cnt_one == 1)
return false;
return true;
}

// Helper function
public static int helper(List<int> V, int m, int sum)
{
// Base cases

// As there is 1 way which is the empty set
if (sum == 0)
return 1;

// If sum is negative then there is no way
if (sum < 0)
return 0;

// If no integer left and the sum is not 0
// then we cannot make sum 0
if (m < 0 && sum > 0)
return 0;

return (helper(V, m - 1, sum) % (1000000007)
+ helper(V, m, sum - V[m]) % (1000000007))
% (1000000007);
}

// Function to find the count of ways
public static int countMultiSet(int N)
{
List<int> V = new List<int>();

// List storing the palindromic number till n
for (int i = 2; i <= N; i++) {
if (isPalindrome(i)) {
}
}

// Calling the helper function
return helper(V, V.Count - 1, N);
}

static public void Main()
{

int N = 8;

// calling the function
Console.WriteLine(countMultiSet(N));
}
}

// This code is contributed by akashish__```

## Javascript

```<script>
// JavaScript code for the above approach

// Function for checking if
// the given integer is palindrome or not
function isPalindrome(i)
{
let x = i.toString();
let n = x.length;
let cnt_one = 0;
for (let j = 0; j < Math.floor(n / 2); i++) {
if (x.charAt(j) == '1') {
cnt_one++;
}
if (x.charAt(j) == x.charAt(n - 1- j)) {
continue;
}
else {
return false;
}
}
if (cnt_one == 1)
return false;
return true;
}

// Helper function
function helper(V,  m,  sum)
{
// Base cases

// As there is 1 way which is the empty set
if (sum == 0)
return 1;

// If sum is negative then there is no way
if (sum < 0)
return 0;

// If no integer left and the sum is not 0
// then we cannot make sum 0
if (m < 0 && sum > 0)
return 0;

return (helper(V, m - 1, sum) % (1000000007)
+ helper(V, m, sum - V[m]) % (1000000007))
% (1000000007);
}

// Function to find the count of ways
function countMultiSet( N)
{
let V = new Array();

// List storing the palindromic number till n
for (let i = 2; i <= N; i++) {
if (isPalindrome(i)) {
V.push(i);
}
}

// Calling the helper function
return helper(V, V.length - 1, N);
}

// Driver Code
let N = 8;

// calling the function
document.write(countMultiSet(N));

// This code is contributed by sanjoy_62.
</script>```
Output

`7`

Time Complexity: O(2M) M is the size of the vector V
Auxiliary Space: O(M)

My Personal Notes arrow_drop_up