计算可以通过放置空格生成的所有可能的字符串

给定一个字符串S ，任务是计算所有可能的字符串，这些字符串可以通过在字符串的任何一对相邻字符之间放置空格来生成。

例子：

Input: S = “AB”
Output: 2
Explanation: All possible strings are { “A B”, “AB”}.

Input: S = “ABC”
Output: 4
Explanation: All possible strings are {“A BC”, “AB C”, “A B C”, “ABC”}

方法：假设字符串相邻字符对之间的空格为二进制位，可以解决该问题。通常，如果字符串的长度为L ，则有L – 1 个位置可以用空格填充。

插图：

S = “ABCD” 
Possible places for spaces are: 

• Between “A” and “B”
• Between “B” and “C”
• Between “C” and “D”

Length of the string = 4 
Possible spaces for spaces = 3 = 4 – 1
Assuming each place to be a binary bit, the total number of possible combinations are: 

1. 000 -> “ABCD”
2. 001 -> “ABC D”
3. 010 -> “AB CD”
4. 011 -> “AB C D”
5. 100 -> “A BCD”
6. 101 -> “A BC D”
7. 110 -> “A B CD”
8. 111 -> “A B C D”

Hence, 8 possible strings can be obtained for a string of length 4.
Therefore, total count of strings = 2 ^{L – 1} 
 

下面是上述想法的实现：

C++

// C++ Program to implement
// the above approach
#include 
using namespace std;
 
// Function to count the number of strings
// that can be generated by placing spaces
// between pair of adjacent characters
 
long long int countNumberOfStrings(string s)
{
 
    // Length of the string
    int length = s.length();
 
    // Count of positions for spaces
    int n = length - 1;
 
    // Count of possible strings
    long long int count = pow(2, n);
 
    return count;
}
 
// Driver Code
int main()
{
    string S = "ABCD";
    cout << countNumberOfStrings(S);
 
    return 0;
}

C

// C program to implement
// the above approach
#include 
#include 
#include 
 
// Function to count the number of strings
// that can be generated by placing spaces
// between pair of adjacent characters
long long int countNumberOfStrings(char* s)
{
     
    // Length of the string
    int length = strlen(s);
 
    // Count of positions for spaces
    int n = length - 1;
 
    // Count of possible strings
    long long int count = pow(2, n);
 
    return count;
}
 
// Driver Code
int main()
{
    char S[] = "ABCD";
    printf("%lld", countNumberOfStrings(S));
 
    return 0;
}
 
// This code is contributed by single__loop

Java

// Java program to implement
// the above approach
import java.io.*;
 
class GFG{
     
// Function to count the number of strings
// that can be generated by placing spaces
// between pair of adjacent characters
static long countNumberOfStrings(String s)
{
     
    // Count of positions for spaces
    int n = s.length() - 1;
     
    // Count of possible strings
    long count = (long)(Math.pow(2, n));
 
    return count;
}
 
// Driver Code
public static void main(String[] args)
{
    String S = "ABCD";
     
    System.out.println(countNumberOfStrings(S));
}
}
 
// This code is contributed by single__loop

Python3

# Python3 program to implement
# the above approach
 
# Function to count the number of strings
# that can be generated by placing spaces
# between pair of adjacent characters
def countNumberOfStrings(s):
     
    # Length of the string
    length = len(s)
     
    # Count of positions for spaces
    n = length - 1
     
    # Count of possible strings
    count = 2 ** n
 
    return count
 
# Driver Code
if __name__ == "__main__" :
 
    S = "ABCD"
     
    print(countNumberOfStrings(S))
     
# This code is contributed by AnkThon

C#

// C# program to implement
// the above approach
using System;
 
class GFG{
 
// Function to count the number of strings
// that can be generated by placing spaces
// between pair of adjacent characters
static long countNumberOfStrings(String s)
{
     
    // Count of positions for spaces
    int n = s.Length - 1;
     
    // Count of possible strings
    long count = (long)(Math.Pow(2, n));
 
    return count;
}
 
// Driver Code
public static void Main(String[] args)
{
    string S = "ABCD";
     
    Console.WriteLine(countNumberOfStrings(S));
}
}
 
// This code is contributed by AnkThon

Javascript

 
// JavaScript program for above approach
 
// Function to count the number of strings
// that can be generated by placing spaces
// between pair of adjacent characters
function countNumberOfStrings(s)
{
      
    // Count of positions for spaces
    let n = s.length - 1;
      
    // Count of possible strings
    let count = (Math.pow(2, n));
  
    return count;
}
 
// Driver Code
     let S = "ABCD";
    document.write(countNumberOfStrings(S));
   
  // This code is contributed by avijitmondal1998.

输出：

8

时间复杂度： O(log (len – 1))，其中len表示给定字符串的长度。
辅助空间： O(1)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live