Word formation using concatenation of two dictionary words

Given a dictionary find out if given word can be made by two words in the dictionary. 
Note: Words in the dictionary must be unique and the word to be formed should not be a repetition of same words that are present in the Trie.

Examples: 

Input : dictionary[] = {"news", "abcd", "tree", 
                              "geeks", "paper"}   
        word = "newspaper"
Output : Yes
We can form "newspaper" using "news" and "paper"

Input : dictionary[] = {"geeks", "code", "xyz", 
                           "forgeeks", "paper"}   
        word = "geeksforgeeks"
Output : Yes

Input : dictionary[] = {"geek", "code", "xyz", 
                           "forgeeks", "paper"}   
        word = "geeksforgeeks"
Output : No

The idea is store all words of dictionary in a Trie. We do prefix search for given word. Once we find a prefix, we search for rest of the word.

Algorithm :  

1- Store all the words of the dictionary in a Trie.
2- Start searching for the given word in Trie.
   If it partially matched then split it into two
   parts and then search for the second part in
   the Trie.
3- If both found, then return true.
4- Otherwise return false.

Below is the implementation of above idea. 

// C++ program to check if a string can be
// formed by concatenating two words
#include<bits/stdc++.h>
using namespace std;

// Converts key current character into index
// use only 'a' through 'z'
#define char_int(c) ((int)c - (int)'a')

// Alphabet size
#define SIZE (26)

// Trie Node
struct TrieNode
{
    TrieNode *children[SIZE];

    // isLeaf is true if the node represents
    // end of a word
    bool isLeaf;
};

// Returns new trie node (initialized to NULLs)
TrieNode *getNode()
{
    TrieNode * newNode = new TrieNode;
    newNode->isLeaf = false;
    for (int i =0 ; i< SIZE ; i++)
        newNode->children[i] = NULL;
    return newNode;
}

// If not present, inserts key into Trie
// If the key is prefix of trie node, just
// mark leaf node
void insert(TrieNode *root, string Key)
{
    int n = Key.length();
    TrieNode * pCrawl = root;

    for (int i=0; i<n; i++)
    {
        int index = char_int(Key[i]);

        if (pCrawl->children[index] == NULL)
            pCrawl->children[index] = getNode();

        pCrawl = pCrawl->children[index];
    }

    // make last node as leaf node
    pCrawl->isLeaf = true;
}

// Searches a prefix of key. If prefix is present,
// returns its ending position in string. Else
// returns -1.
int findPrefix(struct TrieNode *root, string key)
{
    int pos = -1, level;
    struct TrieNode *pCrawl = root;

    for (level = 0; level < key.length(); level++)
    {
        int index = char_int(key[level]);
        if (pCrawl->isLeaf == true)
            pos = level;
        if (!pCrawl->children[index])
            return pos;

        pCrawl = pCrawl->children[index];
    }
    if (pCrawl != NULL && pCrawl->isLeaf)
        return level;
}

// Function to check if word formation is possible
// or not
bool isPossible(struct TrieNode* root, string word)
{
    // Search for the word in the trie and
    // store its position upto which it is matched
    int len = findPrefix(root, word);

    // print not possible if len = -1 i.e. not
    // matched in trie
    if (len == -1)
        return false;

    // If word is partially matched in the dictionary
    // as another word
    // search for the word made after splitting
    // the given word up to the length it is
    // already,matched
    string split_word(word, len, word.length()-(len));
    int split_len = findPrefix(root, split_word);

    // check if word formation is possible or not
    return (len + split_len == word.length());
}

// Driver program to test above function
int main()
{
    // Let the given dictionary be following
    vector<string> dictionary = {"geeks", "forgeeks",
                                    "quiz", "geek"};

    string word = "geeksquiz"; //word to be formed

    // root Node of trie
    TrieNode *root = getNode();

    // insert all words of dictionary into trie
    for (int i=0; i<dictionary.size(); i++)
        insert(root, dictionary[i]);

    isPossible(root, word) ? cout << "Yes":
                             cout << "No";

    return 0;
}

import java.util.ArrayList;
import java.util.List;

// Java program to check if a string can be 
// formed by concatenating two words 
public class GFG { 
        
    // Alphabet size 
    final static int SIZE = 26; 
    
    // Trie Node 
    static class TrieNode 
    { 
        TrieNode[] children = new TrieNode[SIZE]; 
    
        // isLeaf is true if the node represents 
        // end of a word 
        boolean isLeaf; 
        
        // constructor 
        public TrieNode() { 
            isLeaf = false; 
            for (int i =0 ; i< SIZE ; i++) 
                    children[i] = null; 
        } 
    } 
    
    
    static TrieNode root; 
    
    // If not present, inserts key into Trie 
    // If the key is prefix of trie node, just 
    // mark leaf node 
    static void insert(TrieNode root, String Key) 
    { 
        int n = Key.length(); 
        TrieNode pCrawl = root; 
    
        for (int i=0; i<n; i++) 
        { 
            int index = Key.charAt(i) - 'a'; 
    
            if (pCrawl.children[index] == null) 
                pCrawl.children[index] = new TrieNode(); 
    
            pCrawl = pCrawl.children[index]; 
        } 
    
        // make last node as leaf node 
        pCrawl.isLeaf = true; 
    } 
    
    // Searches a prefix of key. If prefix is present, 
    // returns its ending position in string. Else 
    // returns -1. 
    static List<Integer> findPrefix(TrieNode root, String key) 
    { 
        List<Integer> prefixPositions = new ArrayList<Integer>();
        int level; 
        TrieNode pCrawl = root; 
    
        for (level = 0; level < key.length(); level++) 
        { 
            int index = key.charAt(level) - 'a'; 
            if (pCrawl.isLeaf == true) 
                prefixPositions.add(level); 
            if (pCrawl.children[index] == null) 
                return prefixPositions; 
    
            pCrawl = pCrawl.children[index]; 
        } 
        if (pCrawl != null && pCrawl.isLeaf) 
            prefixPositions.add(level);  
        
        return prefixPositions;  
    } 
    
    // Function to check if word formation is possible 
    // or not 
    static boolean isPossible(TrieNode root, String word) 
    { 
        // Search for the word in the trie and get its prefix positions
        // upto which there is matched 
        List<Integer> prefixPositions1 = findPrefix(root, word); 
    
        // Word formation is not possible if the word did not have 
        // at least one prefix match
        if (prefixPositions1.isEmpty()) 
            return false; 
    
        // Search for rest of substring for each prefix match
        for (Integer len1 : prefixPositions1) {
            String restOfSubstring = word.substring(len1, word.length()); 
            List<Integer> prefixPositions2 = findPrefix(root, restOfSubstring);
            for (Integer len2 : prefixPositions2) {
                // check if word formation is possible
                if (len1 + len2 == word.length())
                    return true;
            }
        }
        
        return false;
    } 
    
    // Driver program to test above function 
    public static void main(String args[]) 
    { 
        // Let the given dictionary be following 
        String[] dictionary = {"news", "newspa", "paper", "geek"}; 
    
        String word = "newspaper"; //word to be formed 
    
        // root Node of trie 
        root = new TrieNode(); 
    
        // insert all words of dictionary into trie 
        for (int i=0; i<dictionary.length; i++) 
            insert(root, dictionary[i]); 
    
        if(isPossible(root, word)) 
            System.out.println( "Yes"); 
        else
            System.out.println("No"); 
    } 
}
// This code is contributed by Sumit Ghosh
// Updated by Narendra Jha

class TrieNode:
    def __init__(self):
        # Initialize a new TrieNode with a list of 26 children and isLeaf flag set to False
        self.children = [None]*26
        self.isLeaf = False


def charToInt(ch):
    # Helper function to convert character to corresponding integer value (0-25)
    return ord(ch) - ord('a')


def insert(root, key):
    # Insert a new key into the Trie
    pCrawl = root
    for ch in key:
        # Convert character to integer index value
        index = charToInt(ch)
        # If child node doesn't exist, create one
        if not pCrawl.children[index]:
            pCrawl.children[index] = TrieNode()
        # Move to next child node
        pCrawl = pCrawl.children[index]
    # Mark the last node as a leaf node
    pCrawl.isLeaf = True


def findPrefix(root, key):
    # Find the length of the longest prefix of the key that exists in the Trie
    pos = -1
    pCrawl = root
    for i, ch in enumerate(key):
        index = charToInt(ch)
        if pCrawl.isLeaf:
            pos = i
        if not pCrawl.children[index]:
            return pos
        pCrawl = pCrawl.children[index]
    return len(key)


def isPossible(root, word):
    # Check if it is possible to split the word into two dictionary words
    len1 = findPrefix(root, word)
    if len1 == -1:
        return False
    split_word = word[len1:]
    len2 = findPrefix(root, split_word)
    return len1 + len2 == len(word)


# Driver program to test above function
if __name__ == "__main__":
    # Define dictionary and word to test
    dictionary = ["geeks", "forgeeks", "quiz", "geek"]
    word = "geeksquiz"
    # Create root node of Trie
    root = TrieNode()
    # Insert each dictionary word into the Trie
    for key in dictionary:
        insert(root, key)
    # Check if it is possible to split the word into two dictionary words and print result
    print("Yes" if isPossible(root, word) else "No")

// C# program to check if a string can be 
// formed by concatenating two words 
using System;
using System.Collections.Generic;

class GFG 
{ 
        
    // Alphabet size 
    readonly public static int SIZE = 26; 
    
    // Trie Node 
    public class TrieNode 
    { 
        public TrieNode []children = new TrieNode[SIZE]; 
    
        // isLeaf is true if the node 
        // represents end of a word 
        public bool isLeaf; 
        
        // constructor 
        public TrieNode() 
        { 
            isLeaf = false; 
            for (int i = 0 ; i < SIZE ; i++) 
                    children[i] = null; 
        } 
    } 
    static TrieNode root; 
    
    // If not present, inserts key into Trie 
    // If the key is prefix of trie node, just 
    // mark leaf node 
    static void insert(TrieNode root, String Key) 
    { 
        int n = Key.Length; 
        TrieNode pCrawl = root; 
    
        for (int i = 0; i < n; i++) 
        { 
            int index = Key[i] - 'a'; 
    
            if (pCrawl.children[index] == null) 
                pCrawl.children[index] = new TrieNode(); 
    
            pCrawl = pCrawl.children[index]; 
        } 
    
        // make last node as leaf node 
        pCrawl.isLeaf = true; 
    } 
    
    // Searches a prefix of key. If prefix 
    // is present, returns its ending position 
    //  in string. Else returns -1. 
    static List<int> findPrefix(TrieNode root, String key) 
    { 
        List<int> prefixPositions = new List<int>(); 
        int level; 
        TrieNode pCrawl = root; 
    
        for (level = 0; level < key.Length; level++) 
        { 
            int index = key[level] - 'a'; 
            if (pCrawl.isLeaf == true) 
                prefixPositions.Add(level); 
            if (pCrawl.children[index] == null) 
                return prefixPositions; 
    
            pCrawl = pCrawl.children[index]; 
        } 
        if (pCrawl != null && pCrawl.isLeaf) 
            prefixPositions.Add(level); 
        
        return prefixPositions; 
    } 
    
    // Function to check if word  
    // formation is possible or not 
    static bool isPossible(TrieNode root, String word) 
    { 
        // Search for the word in the trie 
        // and get its prefix positions 
        // upto which there is matched 
        List<int> prefixPositions1 = findPrefix(root, word); 
    
        // Word formation is not possible 
        // if the word did not have 
        // at least one prefix match 
        if (prefixPositions1.Count==0) 
            return false; 
    
        // Search for rest of substring 
        // for each prefix match 
        foreach (int len1 in prefixPositions1) 
        { 
            String restOfSubstring = word.Substring(len1,
                                        word.Length-len1); 
            List<int> prefixPositions2 = findPrefix(root,
                                        restOfSubstring); 
            foreach (int len2 in prefixPositions2) 
            { 
                
                // check if word formation is possible 
                if (len1 + len2 == word.Length) 
                    return true; 
            } 
        } 
        return false; 
    } 
    
    // Driver code 
    public static void Main(String []args) 
    { 
        // Let the given dictionary be following 
        String[] dictionary = {"news", "newspa", "paper", "geek"}; 
    
        // word to be formed 
        String word = "newspaper"; 
    
        // root Node of trie 
        root = new TrieNode(); 
    
        // insert all words of dictionary into trie 
        for (int i = 0; i < dictionary.Length; i++) 
            insert(root, dictionary[i]); 
    
        if(isPossible(root, word)) 
            Console.WriteLine( "Yes"); 
        else
            Console.WriteLine("No"); 
    } 
} 

// This code is contributed by 29AjayKumar

<script>

// Javascript program to check if a string
// can be formed by concatenating two words 

// Alphabet size 
let SIZE = 26; 

// Trie Node 
class TrieNode 
{
    constructor()
    {
        this.isLeaf = false; 
        this.children = new Array(SIZE);
        
        for(let i = 0 ; i < SIZE; i++) 
            this.children[i] = null;
    }
}

let root; 

// If not present, inserts key into Trie 
// If the key is prefix of trie node, just 
// mark leaf node
function insert(root, Key)
{
    let n = Key.length; 
    let pCrawl = root; 
  
    for(let i = 0; i < n; i++) 
    { 
        let index = Key[i].charCodeAt(0) -
                       'a'.charCodeAt(0); 
  
        if (pCrawl.children[index] == null) 
            pCrawl.children[index] = new TrieNode(); 
  
        pCrawl = pCrawl.children[index]; 
    } 
  
    // Make last node as leaf node 
    pCrawl.isLeaf = true; 
}

// Searches a prefix of key. If prefix
// is present, returns its ending 
// position in string. Else returns -1. 
function findPrefix(root, key)
{
    let prefixPositions = [];
    let level; 
    let pCrawl = root; 
  
    for(level = 0; level < key.length; level++) 
    { 
        let index = key[level].charCodeAt(0) - 
                           'a'.charCodeAt(0); 
        if (pCrawl.isLeaf == true) 
            prefixPositions.push(level); 
        if (pCrawl.children[index] == null) 
            return prefixPositions; 
  
        pCrawl = pCrawl.children[index]; 
    } 
    if (pCrawl != null && pCrawl.isLeaf) 
        prefixPositions.push(level);  
      
    return prefixPositions;  
}

// Function to check if word formation 
// is possible or not 
function isPossible(root, word) 
{
    
    // Search for the word in the trie and 
    // get its prefix positions upto which 
    // there is matched 
    let prefixPositions1 = findPrefix(root, word); 
  
    // Word formation is not possible if
    // the word did not have at least one
    // prefix match
    if (prefixPositions1.length == 0) 
        return false; 
  
    // Search for rest of substring for 
    // each prefix match
    for(let len1 = 0; 
            len1 < prefixPositions1.length;
            len1++)
    {
        let restOfSubstring = word.substring(
            prefixPositions1[len1], word.length); 
        let prefixPositions2 = findPrefix(
            root, restOfSubstring);
            
        for(let len2 = 0;
                len2 < prefixPositions2.length;
                len2++)
        {
            
            // Check if word formation is possible
            if (prefixPositions1[len1] + 
                prefixPositions2[len2] == word.length)
                return true;
        }
    }
    return false;
}

// Driver code
let dictionary = [ "news", "newspa", 
                   "paper", "geek" ];
                   
// word to be formed 
let word = "newspaper"; 

// Root Node of trie 
root = new TrieNode(); 

// Insert all words of dictionary into trie 
for(let i = 0; i < dictionary.length; i++) 
    insert(root, dictionary[i]); 

if (isPossible(root, word)) 
    document.write("Yes"); 
else
    document.write("No"); 

// This code is contributed by rag2127

</script>

Output: 

Yes

Exercise : 
A generalized version of the problem is to check if a given word can be formed using concatenation of 1 or more dictionary words. Write code for the generalized version.

Time Complexity: The time complexity of the given program is O(MN), where M is the length of the given word and N is the number of words in the dictionary. This is because the program needs to traverse the given word and perform a prefix search in the trie for each substring of the word, which takes O(M) time. Additionally, the program needs to insert all the words in the dictionary into the trie, which takes O(NM) time.

Auxiliary Space: The space complexity of the program is O(NM), where N is the number of words in the dictionary and M is the maximum length of a word in the dictionary. This is because the program needs to store the trie data structure, which requires O(NM) space.

Another Approach

The above approach is implementing the Trie data structure to efficiently store and search the dictionary words. However, we can optimize the code by using the unordered_set data structure instead of Trie. The unordered_set is a hash-based data structure that has an average constant time complexity O(1) for insertion and search operations. Therefore, it can be used to efficiently search for words in the dictionary.

Approach:

1. Check if the given word exists in the dictionary. If it does, return true.
2. If the given word is not found in the dictionary, then check if it can be formed by concatenating two or more words from the dictionary recursively.
3. To check if a word can be formed by concatenating two or more words from the dictionary, the code splits the word into a prefix and a suffix at every possible position and then checks if the prefix exists in the dictionary.
4. If the prefix exists in the dictionary, then the suffix is checked recursively to see if it can be formed by concatenating two or more words from the dictionary. This is done by calling the "isPossible" function recursively with the suffix and the dictionary as input.
5. If the suffix can be formed by concatenating two or more words from the dictionary, then the entire word can be formed by concatenating the prefix and suffix. In this case, the function returns true.
6. If none of the prefixes can be found in the dictionary, or if none of the suffixes can be formed by concatenating two or more words from the dictionary, then the function returns false.

Algorithm:

This code uses recursion to check whether a given word can be formed by concatenating two words from a given dictionary.

• The function "isPossible" takes two parameters: an unordered_set "dict" containing the dictionary of words and a string word to be checked.
• If the word is found in the dictionary, the function returns true. Otherwise, it recursively checks all possible prefixes and suffixes of the word to see if they can be formed by concatenating two words from the "dict".
• The recursion stops when either the prefix is not found in the dictionary, or the suffix cannot be formed by concatenating two words from the "dict".
• If the word can be formed by concatenating two words from the "dict", the function returns true. Otherwise, it returns false.
• The "main" function creates an "unordered_set" of strings containing the dictionary, and then calls the "isPossible" function to check if the given word can be formed by concatenating two words from the dictionary. Finally, it prints "Yes" if the word can be formed, and "No" otherwise.

Below is the implementation of the above approach:

#include <bits/stdc++.h>
using namespace std;

// Function to check if word formation is possible
// or not
bool isPossible(unordered_set<string>& dict, string word)
{
    // If word is found in the dictionary, it can be formed
    if (dict.find(word) != dict.end())
        return true;

    // Check if word can be formed by concatenating
    // two words from the dictionary
    int n = word.length();
    for (int i = 1; i < n; i++) {
        string prefix = word.substr(0, i);
        string suffix = word.substr(i);

        // Check if prefix exists in dictionary and
        // suffix can be formed by concatenating two
        // words from the dictionary recursively
        if (dict.find(prefix) != dict.end() && isPossible(dict, suffix))
            return true;
    }

    // Word cannot be formed by concatenating
    // two words from the dictionary
    return false;
}

// Driver program to test above function
int main()
{
    // Let the given dictionary be following
    unordered_set<string> dictionary = {"geeks", "forgeeks", "quiz", "geek"};

    string word = "geeksquiz"; //word to be formed

    isPossible(dictionary, word) ? cout << "Yes" : cout << "No";

    return 0;
}
//This code is contributed by rudra1807raj

import java.util.*;

public class WordFormation {
    // Function to check if word formation is possible or not
    public static boolean isPossible(Set<String> dict, String word) {
        // If word is found in the dictionary, it can be formed
        if (dict.contains(word))
            return true;

        // Check if word can be formed by concatenating
        // two words from the dictionary
        int n = word.length();
        for (int i = 1; i < n; i++) {
            String prefix = word.substring(0, i);
            String suffix = word.substring(i);

            // Check if prefix exists in dictionary and
            // suffix can be formed by concatenating two
            // words from the dictionary recursively
            if (dict.contains(prefix) && isPossible(dict, suffix))
                return true;
        }

        // Word cannot be formed by concatenating
        // two words from the dictionary
        return false;
    }

    // Driver program to test above function
    public static void main(String[] args) {
        // Let the given dictionary be following
        Set<String> dictionary = new HashSet<String>();
        dictionary.add("geeks");
        dictionary.add("forgeeks");
        dictionary.add("quiz");
        dictionary.add("geek");

        String word = "geeksquiz"; // word to be formed

        System.out.println(isPossible(dictionary, word) ? "Yes" : "No");
    }
}
//This code is contributed by rudra1807raj

# Python Code

# importing the required library
import itertools

# Function to check if word formation is possible or not
def isPossible(dict, word): 
  
    # If word is found in the dictionary, it can be formed
    if word in dict: 
        return True
  
    # Check if word can be formed by concatenating 
    # two words from the dictionary 
    for i in range(1, len(word)): 
        prefix = word[:i] 
        suffix = word[i:] 
  
        # Check if prefix exists in dictionary and 
        # suffix can be formed by concatenating two 
        # words from the dictionary recursively 
        if prefix in dict and isPossible(dict, suffix): 
            return True
  
    # Word cannot be formed by concatenating 
    # two words from the dictionary 
    return False

# Driver program to test above function 
if __name__ == '__main__': 
  
    # Let the given dictionary be following 
    dictionary = {'geeks', 'forgeeks', 'quiz', 'geek'}
    word = 'geeksquiz' # word to be formed 
    if isPossible(dictionary, word):
      print("Yes")
    else:
      print("No")

using System;
using System.Collections.Generic;

public class WordFormation {
    // Function to check if word formation is possible or not
    public static bool IsPossible(HashSet<string> dict, string word) {
        // If word is found in the dictionary, it can be formed
        if (dict.Contains(word))
            return true;

        // Check if word can be formed by concatenating
        // two words from the dictionary
        int n = word.Length;
        for (int i = 1; i < n; i++) {
            string prefix = word.Substring(0, i);
            string suffix = word.Substring(i);

            // Check if prefix exists in dictionary and
            // suffix can be formed by concatenating two
            // words from the dictionary recursively
            if (dict.Contains(prefix) && IsPossible(dict, suffix))
                return true;
        }

        // Word cannot be formed by concatenating
        // two words from the dictionary
        return false;
    }

    // Driver program to test above function
    public static void Main() {
        // Let the given dictionary be following
        HashSet<string> dictionary = new HashSet<string>();
        dictionary.Add("geeks");
        dictionary.Add("forgeeks");
        dictionary.Add("quiz");
        dictionary.Add("geek");

        string word = "geeksquiz"; // word to be formed

        Console.WriteLine(IsPossible(dictionary, word) ? "Yes" : "No");
    }
}
//This code is contributed by rudra1807raj

function isPossible(dict, word) {
  // If word is found in the dictionary, it can be formed
  if (dict.has(word)) {
    return true;
  }

  // Check if word can be formed by concatenating
  // two words from the dictionary
  let n = word.length;
  for (let i = 1; i < n; i++) {
    let prefix = word.substring(0, i);
    let suffix = word.substring(i);

    // Check if prefix exists in dictionary and
    // suffix can be formed by concatenating two
    // words from the dictionary recursively
    if (dict.has(prefix) && isPossible(dict, suffix)) {
      return true;
    }
  }

  // Word cannot be formed by concatenating
  // two words from the dictionary
  return false;
}

// Driver program to test above function
let dictionary = new Set(["geeks", "forgeeks", "quiz", "geek"]);
let word = "geeksquiz"; //word to be formed

isPossible(dictionary, word) ? console.log("Yes") : console.log("No");

//Note that the unordered_set used in the C++ code has been replaced with
//a Set in JavaScript. The Set in JavaScript is similar to unordered_set in 
//C++ and allows for fast lookup of elements. The substring function in 
//JavaScript is used to extract a portion of a string. The console.log function
//is used to print the output.

//This code is contributed by rudra1807raj

Output:

Yes

Time Complexity: The time complexity of the "isPossible" function in this code is O(N^3), where N is the length of the input word. This is because, in the worst case, the function will need to check every possible partition of the word into two parts, which is O(N^2), and for each partition, it may need to recursively check both parts, which can take an additional O(N) time.

Auxiliary Space: The space complexity of this function is also O(N^3) in the worst case, due to the recursion stack. Specifically, in the worst case, the recursion depth will be O(N), and at each level of the recursion, the function may need to store a string of length up to N. Therefore, the overall space complexity is O(N^3).