Related Articles
Minimum number of palindromes required to express N as a sum | Set 2
• Last Updated : 22 Oct, 2020

Given a number N, we have to find the minimum number of palindromes required to express N as a sum of them.
Examples

Input : N = 11
Output : 1
Explanation: 11 is itself a palindrome.
Input : N = 65
Output : 3
Explanation: 65 can be expressed as a sum of three palindromes (55, 9, 1).

In the previous post, we discussed a dynamic programming approach to this problem which had a time and space complexity of O(N3/2).
Cilleruelo, Luca, and Baxter proved in a 2016 research paper that every number can be expressed as the sum of a maximum of three palindromes in any base b >= 5 (this lower bound was later improved to 3). For the proof of this theorem, please refer to the original paper. We can make the use of this theorem by safely assuming the answer to be three if the number N is not itself a palindrome and cannot be expressed as the sum of two palindromes.
Below is the implementation of the above approach:

## C++

 `// C++ program to find the minimum number of``// palindromes required to express N as a sum` `#include ``using` `namespace` `std;` `// A utility for creating palindrome``int` `createPalindrome(``int` `input, ``bool` `isOdd)``{``    ``int` `n = input;``    ``int` `palin = input;` `    ``// checks if number of digits is odd or even``    ``// if odd then neglect the last digit of input in``    ``// finding reverse as in case of odd number of``    ``// digits middle element occur once``    ``if` `(isOdd)``        ``n /= 10;` `    ``// Creates palindrome by just appending revers``    ``// of number to itself``    ``while` `(n > 0) {``        ``palin = palin * 10 + (n % 10);``        ``n /= 10;``    ``}``    ` `    ``return` `palin;``}` `// Function to generate palindromes``vector<``int``> generatePalindromes(``int` `N)``{``    ``vector<``int``> palindromes;``    ``int` `number;` `    ``// Run two times for odd and even``    ``// length palindromes``    ``for` `(``int` `j = 0; j < 2; j++) {` `        ``// Creates palindrome numbers with first half as i.``        ``// Value of j decides whether we need an odd length``        ``// or even length palindrome.``        ``int` `i = 1;``        ``while` `((number = createPalindrome(i++, j)) <= N)``            ``palindromes.push_back(number);``    ``}` `    ``return` `palindromes;``}` `// Function to find the minimum``// number of palindromes required``// to express N as a sum``int` `minimumNoOfPalindromes(``int` `N)``{``    ``// Checking if the number is a palindrome``    ``string a, b = a = to_string(N);``    ``reverse(b.begin(), b.end());``    ``if` `(a == b)``        ``return` `1;` `    ``// Checking if the number is a``    ``// sum of two palindromes` `    ``// Getting the list of all palindromes upto N``    ``vector<``int``> palindromes = generatePalindromes(N);` `    ``// Sorting the list of palindromes``    ``sort(palindromes.begin(), palindromes.end());` `    ``int` `l = 0, r = palindromes.size() - 1;``    ``while` `(l < r) {``        ``if` `(palindromes[l] + palindromes[r] == N)``            ``return` `2;``        ``else` `if` `(palindromes[l] + palindromes[r] < N)``            ``++l;``        ``else``            ``--r;``    ``}` `    ``// The answer is three if the``    ``// control reaches till this point``    ``return` `3;``}` `// Driver code``int` `main()``{``    ``int` `N = 65;``    ` `    ``cout << minimumNoOfPalindromes(N);``    ` `    ``return` `0;``}`

## Java

 `// Java program to find the minimum number of``// palindromes required to express N as a sum``import` `java.util.*;` `class` `GFG``{` `    ``// A utility for creating palindrome``    ``static` `int` `createPalindrome(``int` `input, ``int` `isOdd)``    ``{``        ``int` `n = input;``        ``int` `palin = input;` `        ``// checks if number of digits is odd or even``        ``// if odd then neglect the last digit of input in``        ``// finding reverse as in case of odd number of``        ``// digits middle element occur once``        ``if` `(isOdd % ``2` `== ``1``)``        ``{``            ``n /= ``10``;``        ``}` `        ``// Creates palindrome by just appending revers``        ``// of number to itself``        ``while` `(n > ``0``)``        ``{``            ``palin = palin * ``10` `+ (n % ``10``);``            ``n /= ``10``;``        ``}` `        ``return` `palin;``    ``}` `    ``// Function to generate palindromes``    ``static` `Vector generatePalindromes(``int` `N)``    ``{``        ``Vector palindromes = ``new` `Vector<>();``        ``int` `number;` `        ``// Run two times for odd and even``        ``// length palindromes``        ``for` `(``int` `j = ``0``; j < ``2``; j++)``        ``{` `            ``// Creates palindrome numbers with first half as i.``            ``// Value of j decides whether we need an odd length``            ``// or even length palindrome.``            ``int` `i = ``1``;``            ``while` `((number = createPalindrome(i++, j)) <= N)``            ``{``                ``palindromes.add(number);``            ``}``        ``}` `        ``return` `palindromes;``    ``}` `    ``static` `String reverse(String input)``    ``{``        ``char``[] temparray = input.toCharArray();``        ``int` `left, right = ``0``;``        ``right = temparray.length - ``1``;` `        ``for` `(left = ``0``; left < right; left++, right--)``        ``{``            ``// Swap values of left and right``            ``char` `temp = temparray[left];``            ``temparray[left] = temparray[right];``            ``temparray[right] = temp;``        ``}``        ``return` `String.valueOf(temparray);``    ``}` `    ``// Function to find the minimum``    ``// number of palindromes required``    ``// to express N as a sum``    ``static` `int` `minimumNoOfPalindromes(``int` `N)``    ``{``        ``// Checking if the number is a palindrome``        ``String a = String.valueOf(N);``        ``String b = String.valueOf(N);``        ``b = reverse(b);``        ``if` `(a.equals(b))``        ``{``            ``return` `1``;``        ``}` `        ``// Checking if the number is a``        ``// sum of two palindromes``        ``// Getting the list of all palindromes upto N``        ``Vector palindromes = generatePalindromes(N);` `        ``// Sorting the list of palindromes``        ``Collections.sort(palindromes);` `        ``int` `l = ``0``, r = palindromes.size() - ``1``;``        ``while` `(l < r)``        ``{``            ``if` `(palindromes.get(l) + palindromes.get(r) == N)``            ``{``                ``return` `2``;``            ``}``            ``else` `if` `(palindromes.get(l) + palindromes.get(r) < N)``            ``{``                ``++l;``            ``}``            ``else``            ``{``                ``--r;``            ``}``        ``}` `    ``// The answer is three if the``        ``// control reaches till this point``        ``return` `3``;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `N = ``65``;``        ``System.out.println(minimumNoOfPalindromes(N));``    ``}``}` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program to find the minimum number of``# palindromes required to express N as a sum` `# A utility for creating palindrome``def` `createPalindrome(_input, isOdd):`` ` `    ``n ``=` `palin ``=` `_input` `    ``# checks if number of digits is odd or even``    ``# if odd then neglect the last digit of _input in``    ``# finding reverse as in case of odd number of``    ``# digits middle element occur once``    ``if` `isOdd:``        ``n ``/``/``=` `10` `    ``# Creates palindrome by just appending revers``    ``# of number to itself``    ``while` `n > ``0``: ``        ``palin ``=` `palin ``*` `10` `+` `(n ``%` `10``)``        ``n ``/``/``=` `10``    ` `    ``return` `palin`` ` `# Function to generate palindromes``def` `generatePalindromes(N):`` ` `    ``palindromes ``=` `[]` `    ``# Run two times for odd and even``    ``# length palindromes``    ``for` `j ``in` `range``(``0``, ``2``): ` `        ``# Creates palindrome numbers with first half as i.``        ``# Value of j decides whether we need an odd length``        ``# or even length palindrome.``        ``i ``=` `1``        ``number ``=` `createPalindrome(i, j)``        ``while` `number <``=` `N:``            ``palindromes.append(number)``            ``i ``+``=` `1``            ``number ``=` `createPalindrome(i, j)``     ` `    ``return` `palindromes`` ` `# Function to find the minimum``# number of palindromes required``# to express N as a sum``def` `minimumNoOfPalindromes(N):`` ` `    ``# Checking if the number is a palindrome``    ``b ``=` `a ``=` `str``(N)``    ``b ``=` `b[::``-``1``]``    ``if` `a ``=``=` `b:``        ``return` `1` `    ``# Checking if the number is a``    ``# sum of two palindromes` `    ``# Getting the list of all palindromes upto N``    ``palindromes ``=` `generatePalindromes(N)` `    ``# Sorting the list of palindromes``    ``palindromes.sort()` `    ``l, r ``=` `0``, ``len``(palindromes) ``-` `1``    ``while` `l < r:``        ` `        ``if` `palindromes[l] ``+` `palindromes[r] ``=``=` `N:``            ``return` `2``        ``elif` `palindromes[l] ``+` `palindromes[r] < N:``            ``l ``+``=` `1``        ``else``:``            ``r ``-``=` `1``     ` `    ``# The answer is three if the``    ``# control reaches till this point``    ``return` `3`` ` `# Driver code``if` `__name__ ``=``=` `"__main__"``:`` ` `    ``N ``=` `65``    ``print``(minimumNoOfPalindromes(N))``    ` `# This code is contributed by Rituraj Jain`

## C#

 `// C# program to find the``// minimum number of palindromes``// required to express N as a sum``using` `System;``using` `System.Collections.Generic;``class` `GFG{` `// A utility for creating palindrome``static` `int` `createPalindrome(``int` `input,``                            ``int` `isOdd)``{``  ``int` `n = input;``  ``int` `palin = input;` `  ``// checks if number of digits``  ``// is odd or even if odd then``  ``// neglect the last digit of``  ``// input in finding reverse``  ``// as in case of odd number of``  ``// digits middle element occur once``  ``if` `(isOdd % 2 == 1)``  ``{``    ``n /= 10;``  ``}` `  ``// Creates palindrome by``  ``// just appending revers``  ``// of number to itself``  ``while` `(n > 0)``  ``{``    ``palin = palin * 10 + (n % 10);``    ``n /= 10;``  ``}` `  ``return` `palin;``}` `// Function to generate palindromes``static` `List<``int``> generatePalindromes(``int` `N)``{``  ``List<``int``> palindromes = ``new` `List<``int``>();``  ``int` `number;` `  ``// Run two times for``  ``// odd and even length``  ``// palindromes``  ``for` `(``int` `j = 0; j < 2; j++)``  ``{``    ``// Creates palindrome numbers``    ``// with first half as i. Value``    ``// of j decides whether we need``    ``// an odd length or even length``    ``// palindrome.``    ``int` `i = 1;``    ``while` `((number = createPalindrome(i++,``                                      ``j)) <= N)``    ``{``      ``palindromes.Add(number);``    ``}``  ``}` `  ``return` `palindromes;``}` `static` `String reverse(String input)``{``  ``char``[] temparray = input.ToCharArray();``  ``int` `left, right = 0;``  ``right = temparray.Length - 1;` `  ``for` `(left = 0;``       ``left < right; left++, right--)``  ``{``    ``// Swap values of left and right``    ``char` `temp = temparray[left];``    ``temparray[left] = temparray[right];``    ``temparray[right] = temp;``  ``}``  ` `  ``return` `String.Join(``""``, temparray);``}` `// Function to find the minimum``// number of palindromes required``// to express N as a sum``static` `int` `minimumNoOfPalindromes(``int` `N)``{``  ``// Checking if the number``  ``// is a palindrome``  ``String a = String.Join(``""``, N);``  ``String b = String.Join(``""``, N);``  ``b = reverse(b);``  ` `  ``if` `(a.Equals(b))``  ``{``    ``return` `1;``  ``}` `  ``// Checking if the number is``  ``// a sum of two palindromes``  ``// Getting the list of all``  ``// palindromes upto N``  ``List<``int``> palindromes =``            ``generatePalindromes(N);` `  ``// Sorting the list``  ``// of palindromes``  ``palindromes.Sort();` `  ``int` `l = 0,``      ``r = palindromes.Count - 1;``  ` `  ``while` `(l < r)``  ``{``    ``if` `(palindromes[l] +``        ``palindromes[r] == N)``    ``{``      ``return` `2;``    ``}``    ``else` `if` `(palindromes[l] +``             ``palindromes[r] < N)``    ``{``      ``++l;``    ``}``    ``else``    ``{``      ``--r;``    ``}``  ``}` `  ``// The answer is three if the``  ``// control reaches till this point``  ``return` `3;``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``  ``int` `N = 65;``  ``Console.WriteLine(minimumNoOfPalindromes(N));``}``}` `// This code is contributed by Rajput-Ji`
Output:
```3

```

Time Complexity: O(√(N)log 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 arrow_drop_up