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

Source: Amazon Interview Experience | Set 158, Round 1, Q 1.

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)).

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 <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)
        {
            strs.add(str);
            return strs;
        }

        ArrayList<String> 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<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)
        {
            strs.Add(str);
            return strs;
        }

        List<String> 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<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

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”).