grep doesn't do what you think. It returns a list of all elements where the search expression is true. The search expression in your case is $genes[$index], so if that's a true value, grep returns all the elements of @gl.

What you probably want to write instead is something like

for my $current (@genes) {
    if (grep { $_ eq $current } @gl) {
         print $current;
    }
}
[download]

Though of course if either (or both) of these arrays is large, that is rather inefficient, and you might consider storing stuff in a hash in the first place.

If @gl is (or can be) large/huge, List::Util's first can be an important speedup.

use List::Util qw( first );
for my $current (@genes) {
    say $current if first { $_ eq $current } @gl;
    }
[download]


Enjoy, Have FUN! H.Merijn

This seems rather similar to how to refer the index of an array to another array of the same length you asked a little over an hour ago, which already has several replies.

This one is a bit different, though, so here's what I would suggest. Since you will be looping over @gl for every item in @genes, put @gl in a hash (only the keys matter). You can use a hash slice:

Then, the lookup is both simple and efficient:

Complete example:

Why do you persist in using two arrays when virtually all the answers in your previous thread (A better way to make the script run faster?) advised you to use a hash, which would make your script at least an order of magnitude faster.

Anyway, you want something like:

grep($genes[$index] eq $_, @gl)
[download]

The first argument to grep is an expression or a block which is expected to return true or false.

#!/usr/bin/perl 
use strict;
use warnings;

my @arrayONE = ("rabbits", "horses", "oranges");
my @arrayTWO = ("truck", "boat", "oranges");
for (my $x = 0; $x <= $#arrayONE; $x += 1)
    {
        for (@arrayTWO)
            {
                print STDERR "SHARED: $_\n" if $arrayONE[$x] eq "$_"; 
            }
    }
[download]

Also, you might consider another type of data-structure, such as a hash, keyed by the value of the gene-string, whose value is the number of times that this particular string occurs.   This is remarkably easy to do in Perl:

my $h={};
$h->{ $_ } ++ foreach (@my_array);

After initializing $h to an empty hashref, we loop over all elements in @my_array (each element being briefly represented by the variable $_), and increment the value of the hash-entry under that key.   Welcome to Perl’s “auto-vivication” feature:   each hash-element is magically created as necessary, and since you are “incrementing” it, the initial value automagically starts at zero.

This representation is functionally-equivalent to an array of discrete strings, but much faster to process.