Algorithm::Permute::permute { print "@array\n" } @array;
[download]

In addition to the replies you've already got, the replies in the thread incrementing mixed letters and numbers show a bunch of different ways to go about a task like this.

$ perl -e 'use strict;
> use warnings;
>
> my @array = qw(A T C G);
> my $length = 5;
> my @result = @array;
>
> add_to_strings($length - 1);
> print "@result";
>
>
> sub add_to_strings {
>     my $len = shift;
>     return if $len <= 0;
>     my @temp;
>     for my $string (@result) {
>         push @temp, $string . $_ for @array;
>     }
>     @result = @temp;
>     add_to_strings ($len - 1);
> }
> '
AAAAA AAAAT AAAAC AAAAG AAATA (... many string omitted for brevity ...
+) GGGGA GGGGT GGGGC GGGGG
[download]

You could do it without recursion, but it's likely to be a bit more complicated.

Also note that I have used here a global @result array for simplicity, but you could also pass @result in subroutine calls and returns to make it cleaner.

Update at 15:51 UTC: this is what the cleaner version might look like:

use strict;
use warnings;

my @array = qw(A T C G);
my $length = 5;

my @result = add_to_strings($length - 1, @array);
print "@result";


sub add_to_strings {
    my $len = shift;
    my @temp_result = @_;
    return @temp_result if $len <= 0;
    my @temp;
    for my $string (@temp_result) {
        push @temp, $string . $_ for @array;
    }
    add_to_strings ($len - 1, @temp);
}
[download]

Like this  @input = glob '{A,C,T,G}' x 5 ?

For instance: (debugger demo)

  DB<4> x glob '{A,C,T,G}' x 2
0  'AA'
1  'AC'
2  'AT'
3  'AG'
4  'CA'
5  'CC'
6  'CT'
7  'CG'
8  'TA'
9  'TC'
10  'TT'
11  'TG'
12  'GA'
13  'GC'
14  'GT'
15  'GG'
[download]

But I think you might benefit from couple of comments on your code.

Any way to improve it?

First, you should have this:

use strict;
[download]

Second, you should try to properly indent your code. The computer doesn't care, but human readers do.

Third, using variables named count1, count2 and so on is usually a red flag. You should probably use an array of values. This is not sufficient to make your algorithm able to handle word lengths other than 3, but it is certainly a precondition to make this possible (within the context of your code).

So, as a first step, your code could be rewritten as follows:

use warnings;
use strict;

my @array = qw(A T C G);
my $word_length = 3;

my $max = ($#array+1)**$word_length;
my @count;
$count[$_] = 0 for 1..$word_length;
my $mainc = 0;

while ($mainc != $max){ 
    print $array[$count[$_]] for 1..$word_length;  
    $count[1]++;
    if ($count[1] == $#array){
        $count[1] = 0;
        $count[2]++;
    }
    if ($count[2] == $#array){
        $count[2] = 0;
        $count[3]++;
    }
    if ($count[3] == $#array){
        $count[3] = 0;
    }
    print "\n";
    $mainc++;
}
[download]

You should probably try to do it by yourself and avoid looking at the solution below:

Update at 18:53 UTC: I just noticed that the result is not correct, because the algorithm of your original program is not correct (see this post: Re: More effective way of doing this below). I won't attempt to fix it, though, because, as noted earlier, I don't really understand how your original program is supposed to work.

your program does not work properly even for 3-letter strings. Sorting the output shows that you have duplicates as well as missing words (only showing here words starting with the letter A):

AAA
AAA
AAA
AAC
AAC
AAT
AAT
AAT
ACA
ACA
ACA
ACC
ACC
ACT
ACT
ATA
ATA
ATA
ATC
ATC
ATT
ATT
(...)
[download]