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

• Difficulty Level : Medium
• Last Updated : 08 Nov, 2021

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: Please solve it on “PRACTICE” first, before moving on to the solution.

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 <cstring>
#include <iostream>
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

```
<?php
// PHP program to print permutations
// of a given string with spaces.

/* Function recursively prints the strings
having space pattern. i and j are indices
in 'str[]' and 'buff[]' respectively */
function printPatternUtil(\$str, \$buff,
\$i, \$j, \$n)
{
if (\$i == \$n)
{
\$buff[\$j] = '';
echo str_replace(', ', '',
implode(', ', \$buff))."\n";
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.
function printPattern(\$str)
{
\$n = strlen(\$str);

// Buffer to hold the string containing spaces
// 2n-1 characters and 1 string terminator
\$buf = array_fill(0, 2 * \$n, null);

// 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 code
\$str = "ABCD";
printPattern(\$str);

// This code is contributed by chandan_jnu
?>

```

## Javascript

```<script>

// JavaScript program to print permutations of a
// given string with spaces

// Function recursively prints the
// strings having space pattern
// i and j are indices in 'String
// str' and 'buf[]' respectively
function printPatternUtil(str, buf, i, j, n) {
if (i === n) {
buf[j] = "\0";
document.write(buf.join("") + "<br>");
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
function printPattern(str) {
var len = str.length;

// Buffer to hold the string containing
// spaces 2n-1 characters and 1 string
// terminator
var buf = new Array(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
var str = "ABCD";
printPattern(str);

</script>```
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)).

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;

2) First character+Rest of the spaced up string;

## C++

```// C++ program for above approach
#include <bits/stdc++.h>
using namespace std;

vector<string> spaceString(string str)
{

vector<string> strs;

vector<string> 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<string> 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<String>
spaceString(String str)
{

ArrayList<String> strs = new
ArrayList<String>();

// Check if str.length() is 1
if (str.length() == 1)
{
return strs;
}

ArrayList<String> strsTemp
= spaceString(str.substring(1,
str.length()));

// Iterate over strsTemp
for (int i = 0; i < strsTemp.size(); i++)
{

strsTemp.get(i));
strsTemp.get(i));
}

// Return strs
return strs;
}

// Driver Code
public static void main(String args[])
{
ArrayList<String> patterns
= new ArrayList<String>();

// 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<String>
spaceString(String str)
{

List<String> strs = new
List<String>();

// Check if str.Length is 1
if (str.Length == 1)
{
return strs;
}

List<String> strsTemp
= spaceString(str.Substring(1,
str.Length-1));

// Iterate over strsTemp
for (int i = 0; i < strsTemp.Count; i++)
{

strsTemp[i]);
strsTemp[i]);
}

// Return strs
return strs;
}

// Driver Code
public static void Main(String []args)
{
List<String> patterns
= new List<String>();

// Function Call
patterns = spaceString("ABCD");

// Print patterns
foreach (String s in patterns)
{
Console.WriteLine(s);
}
}
}

// This code is contributed by gauravrajput1
```

## Javascript

```<script>
// Javascript program for above approach

function spaceString(str)
{
let strs = [];
// Check if str.length() is 1
if (str.length == 1)
{
strs.push(str);
return strs;
}

let strsTemp
= spaceString(str.substring(1,
str.length));

// Iterate over strsTemp
for (let i = 0; i < strsTemp.length; i++)
{

strs.push(str[0] +
strsTemp[i]);
strs.push(str[0] + " " +
strsTemp[i]);
}

// Return strs
return strs;
}

// Driver Code
let patterns = spaceString("ABCD");

// Print patterns
for (let s of patterns.values())
{
document.write(s+"<br>");
}

// This code is contributed by avanitrachhadiya2155
</script>
```
Output
```ABCD
A BCD
AB CD
A B CD
ABC D
A BC D
AB C D
A B C D```