Skip to content
Related Articles

Related Articles

Improve Article

Print all possible strings that can be made by placing spaces

  • Difficulty Level : Medium
  • Last Updated : 27 Sep, 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

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

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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;
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
This article is contributed by Gaurav Sharma. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



My Personal Notes
arrow_drop_up
Next

Print all possible strings that can be made by placing spaces
Recommended Articles
Page :
Print all possible strings that can be made by placing spaces
15, Aug 17
Count all possible strings that can be generated by placing spaces
07, Dec 20
Check whether two strings can be made equal by reversing substring of equal length from both strings
15, Jul 20
Check if given strings can be made same by swapping two characters of same or different strings
07, Dec 20
Check if two strings can be made equal by reversing a substring of one of the strings
09, Dec 20
Check if all strings of an array can be made same by interchanging characters
15, Sep 20
Print all possible strings of length k that can be formed from a set of n characters
29, Jun 13
Print all Strings from array A[] having all strings from array B[] as subsequence
16, Jul 20
Count N-digit numbers made up of X or Y whose sum of digits is also made up of X or Y
06, Nov 20
Check whether two strings can be made equal by increasing prefixes
11, Nov 18
Check whether two strings can be made equal by copying their characters with the adjacent ones
09, Oct 19
Check if two strings can be made equal by swapping one character among each other
20, Nov 19
Check if two binary strings can be made equal by swapping pairs of unequal characters
20, Jan 21
Check if two binary strings can be made equal by swapping 1s occurring before 0s
18, Jan 21
Check if given Strings can be made equal by inserting at most 1 String
23, Jun 21
Find the longest string that can be made up of other strings from the array
04, Jul 19
Check if two strings can be made equal by swapping pairs of adjacent characters
03, Feb 21
Maximize the length of upper boundary formed by placing given N rectangles horizontally or vertically
23, Jun 21
How to remove all white spaces from a String in Java?
07, Nov 18
All possible strings of any length that can be formed from a given string
15, May 17
Print all strings of maximum length from an array of strings
02, Sep 20
Print all possible joints of a Trie constructed from a given list of strings
18, Jun 20
Print all possible palindromic string formed using any pair of given strings
09, Jul 20
Check if all bits can be made same by flipping two consecutive bits
09, Jan 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox