The following uses a recursive search to find all matching combinations:

use strict;
use warnings;

my $target = "cowboycatdog";
my @parts = qw(cow cowboy boy cat at do dog);

search ($target, [@parts], []);


sub search {
    my ($target, $parts, $used) = @_;

    unless (length $target) {
        print join ("-", @$used), "\n";
        return;
    }

    for my $part (@$parts) {
        next unless 0 == index $target, $part;

        my $remainder = substr $target, length $part;

        search ($remainder, [grep {$part ne $_} @$parts], [@$used, $pa
+rt]);
    }
}
[download]

Prints:

cow-boy-cat-dog
cowboy-cat-dog
[download]

Write a procedure that tries to match each of the words in the list, only at the very beginning of the string. If there is a match, the procedure calls itself to match the remainder of the string, otherwise it just returns. Except... if the remainder of the string is zero length, print the segments that matched.

The parameters of the procedure could be the sequence of words that have have been matched so far separated by dashes, and the remaining part of the string.

For your example, you would start with

try_match( "", "cowboycatdog" )
[download]

try_match( "cow-boy", "catdog" );
[download]

try_match( "cow-boy-cat-dog", "" );
[download]

$ perl -le'
my @array = qw/
    cow
    cowboy
    boy
    cat
    do
    dog
    /;

my $string = join q//, @array;
print $string;
1 while $string =~ s/(\w{2,})\1/$1/;
print $string;
'
cowcowboyboycatdodog
cowboycatdog
[download]

my $h = 
{
  cowboy => [ cow, boy ],
  cat    => undef,
  dog    => undef
}
[download]

First turn on strictures (you always use strictures don't you?), then set up the target string and the search list. Perform the search using the starting parameters.

use strict;
use warnings;

my $target = "cowboycatdog";
my @parts = qw(cow cowboy boy cat at do dog);

search ($target, [@parts], []);
[download]

Assign the parameters passed to the sub to local variables. Note that the arrays are passed as references so that two arrays can be passed.

sub search {
    my ($target, $parts, $used) = @_;
[download]

Check to see if there is anything left to match. If the target string is zero length then we have a successful combination in @$used. Print the result and return.

    unless (length $target) {
        print join ("-", @$used), "\n";
        return;
    }
[download]

otherwise loop over the remaining unused words looking for matches with the start of the remaining target string.

    for my $part (@$parts) {
[download]

if there is no match for the current word at the start of the target string skip to the next word

        next unless 0 == index $target, $part;
[download]

otherwise isolate the part of the target string following the current word.

        my $remainder = substr $target, length $part;
[download]

Recursively search the remaining part of the target string using the word list passed in excluding the current word and passing a list of the words used so far plus the current word.

        search ($remainder, [grep {$part ne $_} @$parts], [@$used, $pa
+rt]);
    }
}
[download]

---

Perl is environmentally friendly - it saves trees

salutations, GrandFather,

the algorithm works well, but there is a small problem: if we try to segmentate:

cowboycatdogcat
[download]

it won't work, because it won't segmentate as, for example:

cow-boy-cat-dog-cat
[download]

because "cat" and "cat" are repeated morphemes, even if the array itself has the items "cowboy cow boy cat do dog cat" with "cat" repeated. how can we solve it? thank you in advance.