Skip to content
Related Articles
Given a string, print all possible palindromic partitions
• Difficulty Level : Hard
• Last Updated : 08 Jun, 2021

Given a string, find all possible palindromic partitions of given string.
Example: Note that this problem is different from Palindrome Partitioning Problem, there the task was to find the partitioning with minimum cuts in input string. Here we need to print all possible partitions.
The idea is to go through every substring starting from first character, check if it is palindrome. If yes, then add the substring to solution and recur for remaining part. Below is complete algorithm.
Below is the implementation of above idea.

## C++

 `// C++ program to print all palindromic partitions of a given string``#include``using` `namespace` `std;` `// A utility function to check if str is palindrome``bool` `isPalindrome(string str, ``int` `low, ``int` `high)``{``    ``while` `(low < high)``    ``{``        ``if` `(str[low] != str[high])``            ``return` `false``;``        ``low++;``        ``high--;``    ``}``    ``return` `true``;``}` `// Recursive function to find all palindromic partitions of str[start..n-1]``// allPart --> A vector of vector of strings. Every vector inside it stores``//             a partition``// currPart --> A vector of strings to store current partition``void` `allPalPartUtil(vector >&allPart, vector &currPart,``                   ``int` `start, ``int` `n, string str)``{``    ``// If 'start' has reached len``    ``if` `(start >= n)``    ``{``        ``allPart.push_back(currPart);``        ``return``;``    ``}` `    ``// Pick all possible ending points for substrings``    ``for` `(``int` `i=start; i > allPart;` `    ``// To store current palindromic partition``    ``vector currPart;` `    ``// Call recursive function to generate all partitions``    ``// and store in allPart``    ``allPalPartUtil(allPart, currPart, 0, n, str);` `    ``// Print all partitions generated by above call``    ``for` `(``int` `i=0; i< allPart.size(); i++ )``    ``{``        ``for` `(``int` `j=0; j

## Java

 `// Java program to print all palindromic``// partitions of a given string``import` `java.util.ArrayList;``import` `java.util.Deque;``import` `java.util.LinkedList;` `public` `class` `PrintAllPalindrome``{``    ``// Driver program``    ``public` `static` `void` `main(String[] args)``    ``{``        ``String input = ``"nitin"``;` `        ``System.out.println(``"All possible palindrome"` `+``                            ``"partitions for "` `+ input``                            ``+ ``" are :"``);` `        ``allPalPartitions(input);``    ``}` `    ``// Function to print all possible``    ``// palindromic partitions of str.``    ``// It mainly creates vectors and``    ``// calls allPalPartUtil()``    ``private` `static` `void` `allPalPartitions(String input)``    ``{``        ``int` `n = input.length();` `        ``// To Store all palindromic partitions``        ``ArrayList> allPart = ``new` `ArrayList<>();` `        ``// To store current palindromic partition``        ``Deque currPart = ``new` `LinkedList();` `        ``// Call recursive function to generate``        ``// all partitions and store in allPart``        ``allPalPartitonsUtil(allPart, currPart, ``0``, n, input);` `        ``// Print all partitions generated by above call``        ``for` `(``int` `i = ``0``; i < allPart.size(); i++)``        ``{``            ``for` `(``int` `j = ``0``; j < allPart.get(i).size(); j++)``            ``{``                ``System.out.print(allPart.get(i).get(j) + ``" "``);``            ``}``            ``System.out.println();``        ``}` `    ``}` `    ``// Recursive function to find all palindromic``    ``// partitions of input[start..n-1] allPart --> A``    ``// ArrayList of Deque of strings. Every Deque``    ``// inside it stores a partition currPart --> A``    ``// Deque of strings to store current partition``    ``private` `static` `void` `allPalPartitonsUtil(ArrayList> allPart,``            ``Deque currPart, ``int` `start, ``int` `n, String input)``    ``{``        ``// If 'start' has reached len``        ``if` `(start >= n)``        ``{``            ``allPart.add(``new` `ArrayList<>(currPart));``            ``return``;``        ``}` `        ``// Pick all possible ending points for substrings``        ``for` `(``int` `i = start; i < n; i++)``        ``{``            ` `            ``// If substring str[start..i] is palindrome``            ``if` `(isPalindrome(input, start, i))``            ``{``                ` `                ``// Add the substring to result``                ``currPart.addLast(input.substring(start, i + ``1``));` `                ``// Recur for remaining remaining substring``                ``allPalPartitonsUtil(allPart, currPart, i + ``1``, n, input);` `                ``// Remove substring str[start..i] from current``                ``// partition``                ``currPart.removeLast();``            ``}``        ``}``    ``}` `    ``// A utility function to check``    ``// if input is Palindrome``    ``private` `static` `boolean` `isPalindrome(String input,``                                    ``int` `start, ``int` `i)``    ``{``        ``while` `(start < i)``        ``{``            ``if` `(input.charAt(start++) != input.charAt(i--))``                ``return` `false``;``        ``}``        ``return` `true``;``    ``}``}` `// This code is contributed by Prerna Saini`

## Python3

 `# Python3 program to print all``# palindromic partitions of a given string` `# A utility function to check if``# str is palindrome``def` `isPalindrome(string: ``str``,``                 ``low: ``int``, high: ``int``):``    ``while` `low < high:``        ``if` `string[low] !``=` `string[high]:``            ``return` `False``        ``low ``+``=` `1``        ``high ``-``=` `1``    ``return` `True` `# Recursive function to find all``# palindromic partitions of str[start..n-1]``# allPart --> A vector of vector of strings.``#             Every vector inside it stores a partition``# currPart --> A vector of strings to store current partition``def` `allPalPartUtil(allPart: ``list``, currPart: ``list``,``                   ``start: ``int``, n: ``int``, string: ``str``):` `    ``# If 'start' has reached len``    ``if` `start >``=` `n:``        ` `        ``# In Python list are passed by reference``        ``# that is why it is needed to copy first``        ``# and then append``        ``x ``=` `currPart.copy()` `        ``allPart.append(x)``        ``return` `    ``# Pick all possible ending points for substrings``    ``for` `i ``in` `range``(start, n):` `        ``# If substring str[start..i] is palindrome``        ``if` `isPalindrome(string, start, i):` `            ``# Add the substring to result``            ``currPart.append(string[start:i ``+` `1``])` `            ``# Recur for remaining remaining substring``            ``allPalPartUtil(allPart, currPart,``                            ``i ``+` `1``, n, string)` `            ``# Remove substring str[start..i]``            ``# from current partition``            ``currPart.pop()` `# Function to print all possible``# palindromic partitions of str.``# It mainly creates vectors and``# calls allPalPartUtil()``def` `allPalPartitions(string: ``str``):` `    ``n ``=` `len``(string)` `    ``# To Store all palindromic partitions``    ``allPart ``=` `[]` `    ``# To store current palindromic partition``    ``currPart ``=` `[]` `    ``# Call recursive function to generate``    ``# all partitions and store in allPart``    ``allPalPartUtil(allPart, currPart, ``0``, n, string)` `    ``# Print all partitions generated by above call``    ``for` `i ``in` `range``(``len``(allPart)):``        ``for` `j ``in` `range``(``len``(allPart[i])):``            ``print``(allPart[i][j], end ``=` `" "``)``        ``print``()` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ``string ``=` `"nitin"``    ``allPalPartitions(string)` `# This code is contributed by``# sanjeev2552`

## C#

 `// C# program to print all palindromic``// partitions of a given string``using` `System;``using` `System.Collections.Generic;` `public` `class` `PrintAllPalindrome``{``    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``String input = ``"nitin"``;` `        ``Console.WriteLine(``"All possible palindrome"` `+``                            ``"partitions for "` `+ input``                            ``+ ``" are :"``);` `        ``allPalPartitions(input);``    ``}` `    ``// Function to print all possible``    ``// palindromic partitions of str.``    ``// It mainly creates vectors and``    ``// calls allPalPartUtil()``    ``private` `static` `void` `allPalPartitions(String input)``    ``{``        ``int` `n = input.Length;` `        ``// To Store all palindromic partitions``        ``List> allPart = ``new` `List>();` `        ``// To store current palindromic partition``        ``List currPart = ``new` `List();` `        ``// Call recursive function to generate``        ``// all partitions and store in allPart``        ``allPalPartitonsUtil(allPart, currPart, 0, n, input);` `        ``// Print all partitions generated by above call``        ``for` `(``int` `i = 0; i < allPart.Count; i++)``        ``{``            ``for` `(``int` `j = 0; j < allPart[i].Count; j++)``            ``{``                ``Console.Write(allPart[i][j] + ``" "``);``            ``}``            ``Console.WriteLine();``        ``}` `    ``}` `    ``// Recursive function to find all palindromic``    ``// partitions of input[start..n-1] allPart --> A``    ``// List of Deque of strings. Every Deque``    ``// inside it stores a partition currPart --> A``    ``// Deque of strings to store current partition``    ``private` `static` `void` `allPalPartitonsUtil(List> allPart,``            ``List currPart, ``int` `start, ``int` `n, String input)``    ``{``        ``// If 'start' has reached len``        ``if` `(start >= n)``        ``{``            ``allPart.Add(``new` `List(currPart));``            ``return``;``        ``}` `        ``// Pick all possible ending points for substrings``        ``for` `(``int` `i = start; i < n; i++)``        ``{``            ` `            ``// If substring str[start..i] is palindrome``            ``if` `(isPalindrome(input, start, i))``            ``{``                ` `                ``// Add the substring to result``                ``currPart.Add(input.Substring(start, i + 1 - start));` `                ``// Recur for remaining remaining substring``                ``allPalPartitonsUtil(allPart, currPart, i + 1, n, input);` `                ``// Remove substring str[start..i] from current``                ``// partition``                ``currPart.RemoveAt(currPart.Count - 1);``            ``}``        ``}``    ``}` `    ``// A utility function to check``    ``// if input is Palindrome``    ``private` `static` `bool` `isPalindrome(String input,``                                    ``int` `start, ``int` `i)``    ``{``        ``while` `(start < i)``        ``{``            ``if` `(input[start++] != input[i--])``                ``return` `false``;``        ``}``        ``return` `true``;``    ``}``}` `// This code is contributed by PrinciRaj1992`
Output

```n i t i n
n iti n
nitin ```

Output:

```n i t i n
n iti n
nitin```

Approach 2: Expand around every palindrome

The idea is to split the string into all palindromes of length 1 that is convert the string to a list of its characters (but as string data type) and then expand the smaller palindromes to bigger palindromes by checking if its left and right (reversed) are equal or not if they are equal then merge them and solve for new list recursively. Also if two adjacent strings of this list are equal (when one of them is reversed), merging them would also give a palindrome so merge them and solve recursively.

## Python3

 `class` `GFG:``    ``def` `solve(``self``, arr):``        ``self``.res.add(``tuple``(arr)) ``# add current partitioning to result``        ``if` `len``(arr)<``=``1``:  ``# Base case when there is nothing to merge``            ``return``        ``for` `i ``in` `range``(``1``,``len``(arr)):``            ``if` `arr[i``-``1``]``=``=``arr[i][::``-``1``]: ``# When two adjacent such that one is reverse of another``                ``brr ``=` `arr[:i``-``1``] ``+` `[arr[i``-``1``]``+``arr[i]] ``+` `arr[i``+``1``:]``                ``self``.solve(brr)``            ``if` `i``+``1``<``len``(arr) ``and` `arr[i``-``1``]``=``=``arr[i``+``1``][::``-``1``]:  ``# All are individually palindrome,``              ``# when one left and one right of i are reverse of each other then we can merge``              ``# the three of them to form a new partitioning way``                ``brr ``=` `arr[:i``-``1``] ``+` `[arr[i``-``1``]``+``arr[i]``+``arr[i``+``1``]] ``+` `arr[i``+``2``:]``                ``self``.solve(brr)``    ``def` `getGray(``self``, S):``        ``self``.res ``=` `set``()  ``# result is a set of tuples to avoid same partition multiple times``        ``self``.solve(``list``(S)) ``# Call recursive function to solve for S``        ``return` `sorted``(``list``(``self``.res))``# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``ob ``=` `GFG()``    ``allPart ``=` `ob.getGray(``"geeks"``)``    ``for` `i ``in` `range``(``len``(allPart)):``        ``for` `j ``in` `range``(``len``(allPart[i])):``            ``print``(allPart[i][j], end ``=` `" "``)``        ``print``()``# This code is contributed by Gautam Wadhwani`
Output
```g e e k s
g ee k s ```

This article is contributed by Ekta Goel. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up