zing:

You oversold your problem. It's a very basic question, not a complicated one. So beginners may skip over your question, thinking that it'll need complex methods and/or algorithms, so you'll lose some possible responses. When others see the question, they'll see that it's quite simple and not interesting enough to solve, so you'll lose a lot of other possible responses.

I could just drop some code on you, but that wouldn't be very educational. What have you tried? What algorithm(s) have you considered? For simple problems, many monks want to see you put some effort into it: i.e. an attempt to solve the problem. I don't really see any effort expended, and we're not a code-writing service. If you had a problem with some code, I'd've offered some specific suggestions. If it were truly a complicated problem, and interesting enough, I might've spent some time playing with it.

Having said all that, here are a couple of hints for you:

First, if it's going to be a sparse matrix, you might consider a hash instead of an array.

You can build the structure as you read it, rather than building two arrays and then merging the arrays.

...roboticus

When your only tool is a hammer, all problems look like your thumb.

Thanks for suggestions. This is what I have tried, but am not able to go past this.

my $file = "LIST";
open (FH, "< $file") or die "Can't open $file for read: $!";
my @hsa_sub = <FH>;

for($x=0;$x<=$#hsa_sub;$x++)
{
    $s=$hsa_sub[$x];
    $sline=`cat siper_sub | grep -n $s`;
    `sed '/substrate/!d; /$s/!d;{n;p}' everything_hsa | grep -i produc
+t | awk {'print $2,$3,$4'} >> prodlist`
    
    my $fil = "prodlist";
    open (FH, "< $fil") or die "Can't open $fil for read: $!";
    my @prod.$s.$x = <FH>;

}
[download]

I'd rather not use sed and awk WITHIN a perl program. As far as your problem is concerned, perl would provide all facilities required.

Hi guys. I have finally managed to assemble this code with some help.

my %supermatrix; 
my $list = "LIST.txt";
open my $DATA, '<', $list or die "unable to open my list $list $!\n"; 
print "\nWORKING ON $list\n";
print `head $list`;
while (my $line = <$DATA>)  { 
     chomp $line; 
     
     my $substrate = 1 if $line =~ /substrate.*(\d+)$/;
     print "SUBSTRATE ===$substrate";  
     $line = <DATA>; # fetch next line
     print "PRODUCT====$line"; 
     my @products; 
     (undef, @products) = split / /, $line; 
     foreach my $prod (@products) { 
          $supermatrix{$substrate}{$prod} = 1;
          
          print "combination $substrate $prod exists ! \n" if exists $
+supermatrix{$substrate}{$prod};
     } 
}
[download]

But there are two problems :-

1.] Its not printing any output.

2.] My list would at max be ~5 to 10% smaller than superarrays(whereas this code will handle output data sparsely). Also I need the output in such a format that there are blanks wherever there isnt a "1".

Actually the quality of the output depends on the number of blanks also, because this output will be then compared to other 20 such outputs. So in that sense the position of "blanks" and "1" is equally important.

I think you've done well in your attempt to create a matrix to represent your data set. Perhaps the following will help further your efforts:

use Modern::Perl;
use File::Slurp qw/read_file/;
use Text::Table;
use Data::Dumper;

my ( %supermatrix, @titles, %seen, @rows );

my @list = read_file 'LIST.txt';

for ( my $i = 0 ; $i < $#list + 1 ; $i += 2 ) {
    my ($substrateID) = $list[$i] =~ /(\d+)/g;
    $supermatrix{$substrateID}{$1} = 1 while $list[ $i + 1 ] =~ /(\d+)
+/g;
}

for my $product ( read_file 'SUPERLIST_PRODUCT.txt' ) {
    my ($productID) = $product =~ /(\d+)/g;
    push @titles, $productID unless $seen{$productID}++;

    for my $substrate ( read_file 'SUPERLIST_SUBSTRATE.txt' ) {
        my ($substrateID) = $substrate =~ /(\d+)/g;
        $supermatrix{$substrateID}{$productID} //= '.';
    }
}

my $titles = join ',',
  map "{title => 'p$_', align_title => 'center', align => 'center'}",
  sort { $a <=> $b } @titles;

for my $y ( sort { $a <=> $b } keys %supermatrix ) {    #rows
    my ( $rowLable, @row );

    for my $x ( sort { $a <=> $b } keys %{ $supermatrix{$y} } ) {    #
+columns
        $rowLable = $y unless $rowLable;
        push @row, $supermatrix{$y}{$x};
    }
    push @rows, [ "s$rowLable", @row ];
}

my $tb = Text::Table->new( ' ', eval $titles );
$tb->load(@rows);
say $tb;

say "\n", Dumper \%supermatrix;
[download]

Partial output:

      p1825 p1875 p2543 p2809 p3182 p3186 p3419 p3485 p3486 p3487 p348
+8 p3489 p3490 p3492 p3647 p3648 p3674 p3877
s2809   .     .     .     .     1     .     .     .     .     .     . 
+    .     .     .     .     .     .     .  
s3006   .     .     .     .     .     .     .     .     .     .     . 
+    .     .     .     .     .     .     .  
s3049   .     .     .     .     .     .     .     .     .     .     . 
+    .     .     .     .     .     .     .  
s3182   .     1     .     .     .     .     .     .     .     .     . 
+    .     .     .     .     .     .     .  
s3186   .     .     .     1     .     .     .     .     .     .     . 
+    .     .     .     .     .     .     .  
s3314   .     .     .     .     .     .     .     .     .     .     . 
+    .     .     .     .     .     .     .  
s3485   .     .     .     .     .     .     .     .     1     .     . 
+    .     .     .     .     .     .     .  
s3486   .     .     .     .     .     .     .     .     .     .     1 
+    .     .     .     .     .     .     .  
s3487   .     .     .     .     .     .     .     .     .     .     . 
+    .     .     .     .     .     .     1  
s3488   .     .     .     .     .     .     .     .     .     1     . 
+    .     .     .     .     .     .     .  
s3489   .     .     .     .     .     .     .     .     .     .     . 
+    .     1     .     .     .     .     .  
s3490   .     .     .     .     .     .     .     1     .     .     . 
+    .     .     .     .     .     .     .  
s3492   .     .     .     .     .     .     .     .     .     .     . 
+    .     .     .     .     .     .     .  
s3645   .     .     .     .     .     .     .     .     .     .     . 
+    .     .     .     1     .     .     .  
s3649   .     .     .     .     .     .     1     .     .     .     . 
+    .     .     .     .     1     .     .  
s3659   .     .     .     .     .     .     .     .     .     .     . 
+    .     .     .     1     .     .     .  
s3674   .     .     .     .     .     .     .     .     .     .     . 
+    1     1     .     .     .     .     .  
s3675   .     .     .     .     .     .     .     .     .     .     . 
+    .     .     .     .     .     1     .  
s3877   .     .     .     .     .     .     1     .     .     .     . 
+    .     .     .     .     .     .     .  

$VAR1 = {
          '3182' => {
                      '1825' => '.',
                      '3182' => '.',
                      '3877' => '.',
                      '3647' => '.',
                      '3489' => '.',
                      '3419' => '.',
                      '2809' => '.',
                      '3488' => '.',
                      '1875' => 1,
                      '2543' => '.',
                      '3492' => '.',
                      '3485' => '.',
                      '3186' => '.',
                      '3487' => '.',
                      '3648' => '.',
                      '3674' => '.',
                      '3490' => '.',
                      '3486' => '.'
                    },
...
[download]

Values are stored in the hash as follows: $supermatrix{substrateID}{productID}, where substrateIDs name the rows, and productIDs name the columns.

The hash is first initialized using the data from LIST.txt, assigning 1 to each substrateID/productID 'location.' The next, nested for loops complete the matrix, assigning a '.' to undefined substrateID/productID 'locations' (the '.' was used so the matrix could be visualized).

Finally, the matrix is printed, followed by a dump of the hash.

Hope this helps!

Please help me on this. I cant go beyond what I have tried (posted the code).

So, what have you tried so far, where do you have problems? What is your question?

See perllol for arrays of arrays (2D matrices), and perlreftut and perldsc for general introductions to nested data structures with perl.