# Print all possible strings that can be made by placing spaces

Given a string you need to print all possible strings that can be made by placing spaces (zero or one) in between them.

```Input:  str[] = "ABC"
Output: ABC
AB C
A BC
A B C```
Recommended Practice

The idea is to use recursion and create a buffer that one by one contains all output strings having spaces. We keep updating the buffer in every recursive call. If the length of the given string is â€˜nâ€™ our updated string can have a maximum length of n + (n-1) i.e. 2n-1. So we create a buffer size of 2n (one extra character for string termination).
We leave 1st character as it is, starting from the 2nd character, we can either fill a space or a character. Thus, one can write a recursive function like below.

Below is the implementation of the above approach:

## C++

 `// C++ program to print permutations ` `// of a given string with spaces.` `#include ` `#include ` `using` `namespace` `std;`   `/* Function recursively prints ` `   ``the strings having space pattern.` `   ``i and j are indices in 'str[]' and ` `   ``'buff[]' respectively */` `void` `printPatternUtil(``const` `char` `str[], ` `                      ``char` `buff[], ``int` `i, ` `                            ``int` `j, ``int` `n)` `{` `    ``if` `(i == n) ` `    ``{` `        ``buff[j] = ``'\0'``;` `        ``cout << buff << endl;` `        ``return``;` `    ``}`   `    ``// Either put the character` `    ``buff[j] = str[i];` `    ``printPatternUtil(str, buff, i + 1, j + 1, n);`   `    ``// Or put a space followed by next character` `    ``buff[j] = ``' '``;` `    ``buff[j + 1] = str[i];`   `    ``printPatternUtil(str, buff, i + 1, j + 2, n);` `}`   `// This function creates buf[] to ` `// store individual output string and uses` `// printPatternUtil() to print all permutations.` `void` `printPattern(``const` `char``* str)` `{` `    ``int` `n = ``strlen``(str);`   `    ``// Buffer to hold the string ` `    ``// containing spaces` `    ``// 2n - 1 characters and 1 string terminator` `    ``char` `buf[2 * n]; `   `    ``// Copy the first character as ` `    ``// it is, since it will be always` `    ``// at first position` `    ``buf[0] = str[0];`   `    ``printPatternUtil(str, buf, 1, 1, n);` `}`   `// Driver program to test above functions` `int` `main()` `{` `    ``const` `char``* str = ``"ABCD"``;` `    ``printPattern(str);` `    ``return` `0;` `}`

## Java

 `// Java program to print permutations ` `// of a given string with` `// spaces` `import` `java.io.*;`   `class` `Permutation ` `{` `    `  `    ``// Function recursively prints ` `    ``// the strings having space` `    ``// pattern i and j are indices in 'String str' and` `    ``// 'buf[]' respectively` `    ``static` `void` `printPatternUtil(String str, ``char` `buf[],` `                                 ``int` `i, ``int` `j, ``int` `n)` `    ``{` `        ``if` `(i == n) ` `        ``{` `            ``buf[j] = ``'\0'``;` `            ``System.out.println(buf);` `            ``return``;` `        ``}`   `        ``// Either put the character` `        ``buf[j] = str.charAt(i);` `        ``printPatternUtil(str, buf, i + ``1``, ` `                               ``j + ``1``, n);`   `        ``// Or put a space followed ` `        ``// by next character` `        ``buf[j] = ``' '``;` `        ``buf[j + ``1``] = str.charAt(i);`   `        ``printPatternUtil(str, buf, i + ``1``, ` `                              ``j + ``2``, n);` `    ``}`   `    ``// Function creates buf[] to ` `    ``// store individual output` `    ``// string and uses printPatternUtil() ` `    ``// to print all` `    ``// permutations` `    ``static` `void` `printPattern(String str)` `    ``{` `        ``int` `len = str.length();`   `        ``// Buffer to hold the string ` `        ``// containing spaces` `        ``// 2n-1 characters and 1 ` `        ``// string terminator` `        ``char``[] buf = ``new` `char``[``2` `* len];`   `        ``// Copy the first character as it is, since it will` `        ``// be always at first position` `        ``buf[``0``] = str.charAt(``0``);` `        ``printPatternUtil(str, buf, ``1``, ``1``, len);` `    ``}`   `    ``// Driver program` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``String str = ``"ABCD"``;` `        ``printPattern(str);` `    ``}` `}`

## Python

 `# Python program to print permutations ` `# of a given string with` `# spaces.`   `# Utility function` `def` `toString(``List``):` `    ``s ``=` `""` `    ``for` `x ``in` `List``:` `        ``if` `x ``=``=` `'&# 092;&# 048;'``:` `            ``break` `        ``s ``+``=` `x` `    ``return` `s`   `# Function recursively prints the ` `# strings having space pattern.` `# i and j are indices in 'str[]' ` `# and 'buff[]' respectively` `def` `printPatternUtil(string, buff, i, j, n):` `    `  `    ``if` `i ``=``=` `n:` `        ``buff[j] ``=` `'&# 092;&# 048;'` `        ``print` `toString(buff)` `        ``return`   `    ``# Either put the character` `    ``buff[j] ``=` `string[i]` `    ``printPatternUtil(string, buff, i ``+` `1``, ` `                                 ``j ``+` `1``, n)`   `    ``# Or put a space followed by next character` `    ``buff[j] ``=` `' '` `    ``buff[j ``+` `1``] ``=` `string[i]`   `    ``printPatternUtil(string, buff, i ``+` `1``, ` `                                 ``j ``+` `2``, n)`   `# This function creates buf[] to ` `# store individual output string` `# and uses printPatternUtil() to ` `# print all permutations.` `def` `printPattern(string):` `    ``n ``=` `len``(string)`   `    ``# Buffer to hold the string ` `    ``# containing spaces` `    `  `    ``# 2n - 1 characters and 1 string terminator` `    ``buff ``=` `[``0``] ``*` `(``2` `*` `n)`   `    ``# Copy the first character as it is, ` `    ``# since it will be always` `    ``# at first position` `    ``buff[``0``] ``=` `string[``0``]`   `    ``printPatternUtil(string, buff, ``1``, ``1``, n)`   `# Driver program` `string ``=` `"ABCD"` `printPattern(string)`   `# This code is contributed by BHAVYA JAIN`

## C#

 `// C# program to print permutations of a` `// given string with spaces` `using` `System;`   `class` `GFG ` `{`   `    ``// Function recursively prints the` `    ``// strings having space pattern` `    ``// i and j are indices in 'String` `    ``// str' and 'buf[]' respectively` `    ``static` `void` `printPatternUtil(``string` `str,` `                                 ``char``[] buf, ``int` `i, ` `                                 ``int` `j, ``int` `n)` `    ``{` `        ``if` `(i == n) ` `        ``{` `            ``buf[j] = ``'\0'``;` `            ``Console.WriteLine(buf);` `            ``return``;` `        ``}`   `        ``// Either put the character` `        ``buf[j] = str[i];` `        ``printPatternUtil(str, buf, i + 1, ` `                               ``j + 1, n);`   `        ``// Or put a space followed by next` `        ``// character` `        ``buf[j] = ``' '``;` `        ``buf[j + 1] = str[i];`   `        ``printPatternUtil(str, buf, i + 1, ` `                               ``j + 2, n);` `    ``}`   `    ``// Function creates buf[] to store` `    ``// individual output string and uses` `    ``// printPatternUtil() to print all` `    ``// permutations` `    ``static` `void` `printPattern(``string` `str)` `    ``{` `        ``int` `len = str.Length;`   `        ``// Buffer to hold the string containing` `        ``// spaces 2n-1 characters and 1 string` `        ``// terminator` `        ``char``[] buf = ``new` `char``[2 * len];`   `        ``// Copy the first character as it is,` `        ``// since it will be always at first` `        ``// position` `        ``buf[0] = str[0];` `        ``printPatternUtil(str, buf, 1, 1, len);` `    ``}`   `    ``// Driver program` `    ``public` `static` `void` `Main()` `    ``{` `        ``string` `str = ``"ABCD"``;` `        ``printPattern(str);` `    ``}` `}`   `// This code is contributed by nitin mittal.`

## PHP

 ``

## Javascript

 ``

Output

```ABCD
ABC D
AB CD
AB C D
A BCD
A BC D
A B CD
A B C D```

Time Complexity: Since the number of Gaps is n-1, there are total 2^(n-1) patterns each having length ranging from n to 2n-1. Thus overall complexity would be O(n*(2^n)).

Space Complexity:  O(2n-1), as the size of the buffer is 2n-1.

Recursive Java Solution:

Steps:

1. Take the first character, and append space up the rest of the string;
2. First character+”space”+Rest of the spaced up string;
3. First character+Rest of the spaced up string;

Implementation:

## C++

 `// C++ program for above approach` `#include ` `using` `namespace` `std;`   `vector spaceString(string str)` `{` `    `  `    ``vector strs;` `    `  `    ``vector ans = {``"ABCD"``, ``"A BCD"``, ``"AB CD"``, ``"A B CD"``, ``"ABC D"``, ``"A BC D"``, ``"AB C D"``, ``"A B C D"``};`   `    ``// Check if str.Length is 1` `    ``if` `(str.length() == 1)` `    ``{` `        ``strs.push_back(str);` `        ``return` `strs;` `    ``}`   `    ``// Return strs` `    ``return` `ans;` `}` `    `  `int` `main()` `{` `    ``vector patterns = spaceString(``"ABCD"``);`   `    ``// Print patterns` `    ``for``(string s : patterns)` `    ``{` `        ``cout << s << endl;` `    ``}`   `    ``return` `0;` `}`   `// This code is contributed by divyesh072019.`

## Java

 `// Java program for above approach` `import` `java.util.*;`   `public` `class` `GFG ` `{` `    ``private` `static` `ArrayList ` `                         ``spaceString(String str)` `    ``{`   `        ``ArrayList strs = ``new` `                           ``ArrayList();`   `        ``// Check if str.length() is 1` `        ``if` `(str.length() == ``1``) ` `        ``{` `            ``strs.add(str);` `            ``return` `strs;` `        ``}`   `        ``ArrayList strsTemp` `            ``= spaceString(str.substring(``1``, ` `                             ``str.length()));`   `        ``// Iterate over strsTemp` `        ``for` `(``int` `i = ``0``; i < strsTemp.size(); i++) ` `        ``{`   `            ``strs.add(str.charAt(``0``) + ` `                            ``strsTemp.get(i));` `            ``strs.add(str.charAt(``0``) + ``" "` `+ ` `                             ``strsTemp.get(i));` `        ``}`   `        ``// Return strs` `        ``return` `strs;` `    ``}` `  `  `    ``// Driver Code` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``ArrayList patterns` `            ``= ``new` `ArrayList();`   `        ``// Function Call` `        ``patterns = spaceString(``"ABCD"``);`   `        ``// Print patterns` `        ``for` `(String s : patterns) ` `        ``{` `            ``System.out.println(s);` `        ``}` `    ``}` `}`

## Python3

 `# Python program for above approach` `def` `spaceString(``str``):` `    ``strs ``=` `[];` `    `  `    ``# Check if str.length() is 1` `    ``if``(``len``(``str``) ``=``=` `1``):` `        ``strs.append(``str``)` `        ``return` `strs` `    `  `    ``strsTemp``=``spaceString(``str``[``1``:])` `    `  `    ``# Iterate over strsTemp` `    ``for` `i ``in` `range``(``len``(strsTemp)):` `        ``strs.append(``str``[``0``] ``+` `strsTemp[i])` `        ``strs.append(``str``[``0``] ``+` `" "` `+` `strsTemp[i])` `    `  `    ``# Return strs` `    ``return` `strs`   `# Driver Code` `patterns``=``[]`   `# Function Call` `patterns ``=` `spaceString(``"ABCD"``)`   `# Print patterns` `for` `s ``in` `patterns:` `    ``print``(s)` `    `  `# This code is contributed by rag2127`

## C#

 `// C# program for above approach` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG ` `{` `    ``private` `static` `List ` `                         ``spaceString(String str)` `    ``{`   `        ``List strs = ``new` `                           ``List();`   `        ``// Check if str.Length is 1` `        ``if` `(str.Length == 1) ` `        ``{` `            ``strs.Add(str);` `            ``return` `strs;` `        ``}`   `        ``List strsTemp` `            ``= spaceString(str.Substring(1, ` `                             ``str.Length-1));`   `        ``// Iterate over strsTemp` `        ``for` `(``int` `i = 0; i < strsTemp.Count; i++) ` `        ``{`   `            ``strs.Add(str[0] + ` `                            ``strsTemp[i]);` `            ``strs.Add(str[0] + ``" "` `+ ` `                             ``strsTemp[i]);` `        ``}`   `        ``// Return strs` `        ``return` `strs;` `    ``}` `  `  `    ``// Driver Code` `    ``public` `static` `void` `Main(String []args)` `    ``{` `        ``List patterns` `            ``= ``new` `List();`   `        ``// Function Call` `        ``patterns = spaceString(``"ABCD"``);`   `        ``// Print patterns` `        ``foreach` `(String s ``in` `patterns) ` `        ``{` `            ``Console.WriteLine(s);` `        ``}` `    ``}` `}`   `// This code is contributed by gauravrajput1 `

## Javascript

 ``

Output

```ABCD
A BCD
AB CD
A B CD
ABC D
A BC D
AB C D
A B C D```

Time Complexity : The time complexity of this approach is O(2^n) where n is the length of the input string “str”. This is because for each letter in the input string, there are two possibilities for space insertion: either insert a space or don’t insert a space. Hence, the total number of possible combinations would be 2^n.

Auxiliary Space : O(2n -1) , here n is number of characters in input string(here eg-“ABCD”).

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!