Well, to show you a better way, we need to see the code you've written so far. You could also tell us why you think your code isn't ideal.

If your strings are of equal length and the overlappings start at the same position, finding them is easy:

my $str1 = 'a11211b123';
my $str2 = 'a11222b123';
my $overlapped = $str1 ^ $str2;

$overlapped =~ s/\0/X/g;

print $overlapped;
[download]

If your strings are of differing lengths, you will have to look at something like Algorithm::Diff.

• split both strings into arrays of characters
• use Algorithm::Diff to compare the two arrays
• convert the output into the format you like

1. Show some effort: ie, post what you've tried
2. Tell how that code fails to meet your expectations (including error messages, if any)
3. Use the tools provided here (including Search and Super_Search, Tutorials, etc. to find answers before posting a question already answered repeatedly.

Hint: search terms such as "common strings" may be helpful.

Something like this might be what you're looking for:

#! perl -slw
use strict;

sub common {
    die 'Bad args' unless @_ == 2;
    my $output = $_[ 0 ] ^ $_[ 1 ];

    $output =~ s[([^\0]+|[\0]+)]{
        my $p = $-[0];
        my $l = $+[0] - $-[ 0 ];
        ord( $1 ) == 0
            ? substr( $_[ 0 ], $p, $l )
            : join '', map{ '[' . substr( $_, $p, $l ) . ']' } @_
    }ge;
    return $output;
}

while( my $str1 = <DATA> ) {
    my $str2 = <DATA>;
    print common( $str1, $str2 );
}

__END__
a11211b123
a11222b123
The quick brown fox jumps over the lazy dog
the quiet green fir looms over the lazy dog
Send reinforcements; we're going to advance
Send 3 and sixpence; we're going to a dance
Time flies like an arrow
Dung flies like a  brick
[download]

Output:

c:\test>junk1
a112[11][22]b123

[T][t]he qui[ck][et] [b][g]r[ow][ee]n f[ox][ir] [jump][loom]s over the
+ lazy dog

Send [rei][3 a]n[forcem][d sixp]en[ts][ce]; we're going to a[dv][ d]an
+ce

[Time][Dung] flies like a[n][ ] [a][b]r[row][ick]
[download]

Not sure about the usefulness of the output format though.

use Algorithm::Diff;

say diff_str( qw/xa11211b123 a11222b123x/ );

sub diff_str {
    my $diff = Algorithm::Diff->new( map { [ split // ] } @_ );

    my $diff_str = '';
    while ( $diff->Next ) {
        my ($h1, $h2) = map { join "", $diff->Items( $_ ) } 1, 2;
        $diff_str .= $diff->Diff  ?  "[$h1][$h2]"  :  $h1;
    }
    return $diff_str;
}
#Output: [x][]a112[11][22]b123[][x]
[download]

We can't tell you a better way of doing anything unless you show us the code you're using to do it presently.