Check if a word is combo of some given symbols - php

Question

I have an array of symbols (not only characters, but also syllables, such as 'p', 'pa', etc.) and I'm trying to come up with a good algorithm to identify words that can be created by concatenating those symbols.
e.g. given the array of symbols ('p', 'pa', 'aw'), the string 'paw' would be a positive match.
This is my current implementation (too slow):
function isValidWord($word,&$symbols){
$nodes = array($word);
while (count($nodes)>0){
$node = array_shift($nodes);
$nodeExpansions = array();
$nodeLength = strlen($node);
if (in_array($node,$symbols)) { return true; }
for ($len=$nodeLength-1;$len>0;$len--){
if (in_array(substr($node, 0, $len), $symbols)){
$nodeExpansions[] = substr($node, $len-$nodeLength);
}
}
$nodes = array_merge($nodeExpansions,$nodes);
}
return false;
}
It doesn't seem like a difficult problem, it's just a depth-first search implementation on an acyclic? tree, but I'm struggling to come up with an implementation which is both memory and CPU efficient. Where can I find resources to learn about this kind of problem?
Also, here is a link to a script for testing it and comparing it to the solutions proposed in the comments below: http://ideone.com/zQ9Cie
And here an album showing captures of really odd results: How can my current iterative method be 12x faster than the recursive one (proposed by #Waleed Khan) when I run them on my dev server, but 2x slower when I run them on my production server, considering both servers have almost identical configurations? (One is an EC2 micro instance and the other a VirtualBox container, but they both have the same OS, config, updates, PHP version and config, number of cores and available RAM)

Answer 1

Not sure wether it's very efficient but I guess I would create a loop with an inner loop which goes through the given array containg the symbols.
<?php
$aSymbols = array('p', 'pa', 'aw');
$aDatabase = array('paw');
$aMatches = array();
for ($iCounter = 0; $iCounter < count($aSymbols); $iCounter++)
{
for ($yCounter = 0; $yCounter < count($aSymbols); $yCounter++)
{
$sString = $aSymbols[$iCounter].$aSymbols[$yCounter];
if (in_array($sString, $aDatabase))
{
$aMatches[] = $sString;
}
}
}
?>
The if query can be replaced by a regex query, too.

Answer 2

As #Waleed Khan suggested, I've tried improving my algorithm using a Trie structure for the dictionary instead of a plain array to speed up the search for matches.
function generateTrie(&$dictionary){
if (is_string($dictionary)){
$dictionary = array($dictionary);
}
if (!is_array($dictionary)){
throw new Exception(
"Invalid input argument for \$dictionary (must be array)",
500
);
}
$trie = array();
$dictionaryCount = count($dictionary);
$f = false;
for ($i=0;$i<$dictionaryCount;$i++){
$word = $dictionary[$i];
if ($f&&!inTrie('in',$trie)){
var_export($trie);
exit;
}
if (!is_string($word)){
throw new Exception(
"Invalid input argument for \$word (must be string)",
500
);
}
$wordLength = strlen($word);
$subTrie = &$trie;
for ($j=1;$j<$wordLength;$j++){
if (array_key_exists($subWord = substr($word,0,$j),$subTrie)){
$subTrie = &$subTrie[$subWord];
}
}
if (array_key_exists($word,$subTrie)){
continue;
}
$keys = array_keys($subTrie);
if (!array_key_exists($word,$subTrie)) {
$subTrie[$word] = array();
}
foreach ($keys as $testWordForPrefix){
if (substr($testWordForPrefix,0,$wordLength) === $word){
$subTrie[$word][$testWordForPrefix] = &$subTrie[$testWordForPrefix];
unset($subTrie[$testWordForPrefix]);
}
}
}
return $trie;
}
/**
* Checks if word is on dictionary trie
*/
function inTrie($word, &$trie){
$wordLen = strlen($word);
$node = &$trie;
$found = false;
for ($i=1;$i<=$wordLen;$i++){
$index = substr($word,0,$i);
if (isset($node[$index])){
$node = &$node[$index];
$found = true;
} else {
$found = false;
}
}
return $found;
}
/**
* Checks if a $word is a concatenation of valid $symbols using inTrie()
*
* E.g. `$word = 'paw'`, `$symbols = array('p', 'pa', 'aw')` would return
* true, because `$word = 'p'.'aw'`
*
*/
function isValidTrieWord($word,&$trie){
$nodes = array($word);
while (count($nodes)>0){
$node = array_shift($nodes);
if (inTrie($node,$trie)) { return true; }
$nodeExpansions = array();
$nodeLength = strlen($node);
for ($len=$nodeLength-1;$len>0;$len--){
if (inTrie(substr($node, 0, $len), $trie)){
$nodeExpansions[] = substr($node, $len-$nodeLength);
}
}
$nodes = array_merge($nodeExpansions,$nodes);
}
return false;
}
It doesn't make much of a difference for small dictionary sizes (where preg_match is still the fastest implementation by several orders of magnitude), but for medium sized dictionaries (~10000 symbols) where longer symbols are usually a combination of shorter ones (which is where preg breaks and the other two implementations can take close to 25 seconds per 2-6 symbols word), the Trie search takes only about 1 second. That's close enough for my needs (check if a given password is a combination of symbols from a given dictionary or not).
(See the whole script on http://ideone.com/zQ9Cie)
Results on my local dev VM:
Results on my AWS EC2 test server: