I don't know how the pairing works, so this sample code only includes the pairs you specifically mentioned in your post, if there are other possible pairs you would have to add them to %good_pairs.

my %good_pairs = (
    'A' => 'T',
    'T' => 'A',
    'G' => 'C',
    'C' => 'G',
);
for(0 .. $#dna) {
    if($dna[$_] ne $good_pairs{$comp[$_]}) {
        print "mismatch: $dna[$_] $comp[$_]\n";
    }
}
[download]

If you only needed to know if the complement string was (or was not) a true complement of the original, perhaps the simplest way would be to re-complement the complement and check for equality. The re-complementation can be acheived very easily using Perl's tr/// operator. eg.

 
my $dna = 'ACGTACGT';
my $cmp = 'TGCATGCA';
(my $recmp = $cmp) =~ tr[ACGT][TGCA];
print 'Matched' if $recmp eq $dna;
[download]

However, as you want to know what the failures were, you can still use the technique to simplify the process of finding them by creating the re-complemented string and then detecting the differences. You could do this with substr

#! perl -slw
use strict;

while( !eof DATA ) {
    my $dna = <DATA>;
    my $cmp = <DATA>;
    (my $temp = $cmp) =~ tr[ACGT][TGCA];
    if ($dna eq $temp) {
        print "$cmp is an accurate compliment of \n$dna";
    } elsif (length $dna != length $cmp) {
        print "$cmp is a different length to \n$dna";
    } else {
        for my $pos(0 .. length $dna) {
            my $c1 = substr($dna, $pos, 1);
            my $c2 = substr($cmp, $pos, 1);
            print "$c1-$c2 (pos:$pos) is a mismatch"
                unless $c1 eq (substr($temp, $pos, 1));
        }
    }
}


__DATA__
ACTGGTACATAGCTAGCTATAGCATACGATATAGACGTCTGCTAGTCGTCGTTTGCCTAAAGCCTAGATC
+GTAGCTAGTC
TGACCATGTATCGATCGATATCGTATGCTATATCTGCAGACGATCAGCAGCAAACGGATTTCGGATCTAG
+CATCGATCAG
ACTGGTACATAGCTAGCTATAGCATACGATATAGACGTCTGCTAGTCGTCGTTTGCCTAAAGCCTAGATC
+GTAGCTAGTC
TGACCATGTATCGATCGATATCGTATGCTATATCTGCAGACGATCAGCAGCAAACGGATTTCGGATCTAG
+CATCGATCA
ACTGGTACATAGCTAGCTATAGCATACGATATAGACGTCTGCTAGTCGTCGTTTGCCTAAAGCCTAGATC
+GTAGCTAGTC
TGACCATGTATCGATCGATATCCTAGGCTATATCTGCAGACGATCAGCAGCAAACGGATATCGGATCTAG
+GATCGATCAG
[download]

Output

C:\test>243661
TGACCATGTATCGATCGATATCGTATGCTATATCTGCAGACGATCAGCAGCAAACGGATTTCGGATCTAG
+CATCGATCAG
 is an accurate compliment of
ACTGGTACATAGCTAGCTATAGCATACGATATAGACGTCTGCTAGTCGTCGTTTGCCTAAAGCCTAGATC
+GTAGCTAGTC

TGACCATGTATCGATCGATATCGTATGCTATATCTGCAGACGATCAGCAGCAAACGGATTTCGGATCTAG
+CATCGATCA
 is a different length to
ACTGGTACATAGCTAGCTATAGCATACGATATAGACGTCTGCTAGTCGTCGTTTGCCTAAAGCCTAGATC
+GTAGCTAGTC

C-C (pos:22) is a mismatch
A-G (pos:25) is a mismatch
A-A (pos:59) is a mismatch
G-G (pos:70) is a mismatch

C:\test>
[download]

Or you could go one stage further and use Perl's bit-wise string manipulations to find the differences and use the resultant string to indicate those differences in a simple manner.

#! perl -sw
use strict;

while( !eof DATA ) {
    my $dna = <DATA>;
    my $cmp = <DATA>;
    (my $temp = $cmp) =~ tr[ACGT][TGCA];

    if ($dna eq $temp) {
        print "\nNo mismatches found\n";
        print $dna;
        print $cmp;
    } else {
        ($temp ^= $dna) =~s[[^\0]][*]g;
        print "\nAsterists (*) indicate mismatches\n";
        print $dna;
        print $temp, $/;
        print $cmp;
    }
}


__DATA__
ACTGGTACATAGCTAGCTATAGCATACGATATAGACGTCTGCTAGTCGTCGTTTGCCTAAAGCCTAGATC
+GTAGCTAGTC
TGACCATGTATCGATCGATATCGTATGCTATATCTGCAGACGATCAGCAGCAAACGGATTTCGGATCTAG
+CATCGATCAG
ACTGGTACATAGCTAGCTATAGCATACGATATAGACGTCTGCTAGTCGTCGTTTGCCTAAAGCCTAGATC
+GTAGCTAGTC
TGACCATGTATCGATCGATATCGTATGCTATATCTGCAGACGATCAGCAGCAAACGGATTTCGGATCTAG
+CATCGATCA
ACTGGTACATAGCTAGCTATAGCATACGATATAGACGTCTGCTAGTCGTCGTTTGCCTAAAGCCTAGATC
+GTAGCTAGTC
TGACCATGTATCGATCGATATCCTAGGCTATATCTGCAGACGATCAGCAGCAAACGGATATCGGATCTAG
+GATCGATCAG
[download]

Output

C:\test>243661-2

No mismatches found
ACTGGTACATAGCTAGCTATAGCATACGATATAGACGTCTGCTAGTCGTCGTTTGCCTAAAGCCTAGATC
+GTAGCTAGTC
TGACCATGTATCGATCGATATCGTATGCTATATCTGCAGACGATCAGCAGCAAACGGATTTCGGATCTAG
+CATCGATCAG

Asterists (*) indicate mismatches
ACTGGTACATAGCTAGCTATAGCATACGATATAGACGTCTGCTAGTCGTCGTTTGCCTAAAGCCTAGATC
+GTAGCTAGTC
                                                                      
+         **
TGACCATGTATCGATCGATATCGTATGCTATATCTGCAGACGATCAGCAGCAAACGGATTTCGGATCTAG
+CATCGATCA

Asterists (*) indicate mismatches
ACTGGTACATAGCTAGCTATAGCATACGATATAGACGTCTGCTAGTCGTCGTTTGCCTAAAGCCTAGATC
+GTAGCTAGTC
                      *  *                                 *          
+*
TGACCATGTATCGATCGATATCCTAGGCTATATCTGCAGACGATCAGCAGCAAACGGATATCGGATCTAG
+GATCGATCAG

C:\test>
[download]

my $string1 = 'ACTG';
my $string2 = 'TGAT';

my %corresponding = ('A' => 'T',
                     'T' => 'A',
                     'C' => 'G',
                     'G' => 'C');

my $count = 0;
for (split '', $string1) {
   my $char = substr($string2, $count++, 1);
   if ($char ne $corresponding{$_}) {
      print "Position $count incorrect:  1: $_, 2: $char\n";
   }
}
[download]

my @dna = split("","ATCTGCG"); 
my @comp = split("","TCTGCAA"); 
my %pairs = qw(A T T A G C C G); 
foreach (0..$#dna) {
    my $d = $dna[$_];
    my $c = $comp[$_];
    print "$_: $d - $c is a mispair\n" unless ($pairs{$d}  eq $c);
}
[download]

my @pairs = ( [qw/ATCG TAGC/], [qw/ACTG TGAT/] );

print "@$_: ", (dna_compare(@$_) ? "matched" : "didn't matched"), $/
  for @pairs;

sub dna_compare {
  my($dna, $comp) = @_;

  return !scalar grep {
    (substr($dna, $_, 1).substr($comp, $_, 1))
     !~ m< ^ (?: AT | TA | GC | CG ) \z >x;
  } 0 .. (length($dna) - 1);
}

__output__

ATCG TAGC: matched
ACTG TGAT: didn't matched
[download]

_________
broquaint

for my $i (0 .. $#dna){
    if(! exists $pairs{$dna[$i].$comp[$i]}){
        print "mismatch: ....";
    }
}
[download]

First, you are not comparing strings, you are comparing arrays.

As this is not C, you don't need a for loop to get the length of an array: just say:

$counter=@dna;$counter2=@comp;
[download]

And your cycles are a bit out of whack... you are saying:

1. if @dna is not empty (while (@dna))
2. count how many bases I have in @dna
3. count how many bases I have in @comp
4. check if the one past last element of each list is a correct pairing
5. etc

I'll not write here a "correct" solution, since many other people already have. I'll just write a (commented) snippet for the case of strings:

my $dna; # the sequence, as a string
my $comp; # the complement, as a string
my $c2;
($c2=$comp)=~tr[ATGC][TACG]; # copy $comp into $c2, then exchange each
+ base in $c2 with its complement (using the tr-ansliteration operator
+)
print "Match!\n" if $dna eq $c2; # since $c2 is $comp's complement, it
+ should be equal to $dna
[download]

-- 
        dakkar - Mobilis in mobile

I code in perl on the MAGPIE project (MAGPIE) and would be glad to help you out!

I created a program on my calculator to do exactly this. Takes the DNA or mRNA or tRNA and outputs any of those.

Impress your teacher by making a Human Genome viewer with the data from UCSC