There are several solutions to your problem. They are all different ways of preprocessing your data so that it is in a suitable state for the main algorithm. Ultimately they use the facility of split with an empty string to generate a list of single characters. You can either provide your input data as a number in string, or convert your array to a string (using join most likely), then use split to create a clean list of digits:

my @number = split '', '1234567';
[download]

However with a little more preprocessing the actual addition logic becomes much simpler. Consider:

use strict;
use warnings;

my @numbers = map {[reverse split '']} qw(109156 114);
my $maxDigits = 0;

@$_ > $maxDigits and $maxDigits = @$_ for @numbers;

@numbers = map {[@$_, (0) x ($maxDigits - @$_)]} @numbers;

my @result;
my $carry;

for my $digit (0 .. $maxDigits - 1) {
    my $sum = $carry;
    
    $sum += $_->[$digit] for @numbers;
    push @result, substr $sum, -1, 1, '';
    $carry = $sum || 0;
}

@numbers = map {[reverse @$_]} @numbers;
@result = reverse @result;

print "@$_\n" for @numbers;
print '-' x ($maxDigits * 2), "\n";
print "@result\n";
[download]

Prints:

1 0 9 1 5 6
0 0 0 1 1 4
------------
1 0 9 2 7 0
[download]

Suppressing the leading zeros is left as an exercise for the reader. ;)

I considered preprocessing, but that would have me involving in posing restriction to the flexibility of feeding any number larger than 9 to a certain array position (or so thought I). You have actually made justice to this situation, so thankful I am indeed, I think preprocessing should be considered, however, I wished your answer was more commented, I am still in the start of learning Perl the right way so some advanced things require someone opening my eyes for me and directing my attention there, there are some places in your reply where I could not understand the concept because some things I faced them first time, like this line

@$_ > $maxDigits and $maxDigits = @$_ for @numbers;
[download]

I mean the @$_ to be specific.....Thank you and ++ , I will of course read about it and learn it :)
Excellence is an Endeavor of Persistence. Chance Favors a Prepared Mind

I must admit that some of my intent was to make you look hard at the code and think and about how it works. I hope that the variable names convey the intent of the code even if the mechanism is not obvious for someone starting out.

$_ is of course the default variable. The line

my @numbers = map {[reverse split '']} qw(109156 114);
[download]

generates two entries in @numbers. Each entry is an array of the digits in the number with the order from least significant digit to most significant.

@$_ > $maxDigits and $maxDigits = @$_ for @numbers;
[download]

iterates over the numbers (which are stored as arrays of digits remember) and sets $_ to the reference to each digit array in turn. Thus @$_ is the array of digits in the current array which in scalar context is simply the number of digits.

The other trick there is using an and in place of an if to have the assignment only happen if the current number of digits is greater than $maxDigits. Use this particular trick sparingly. I only used it here to avoid using a full for loop rather than for as a statement modifier. Nested statement modifiers are not allowed.

For bonus points, can you see the bug in the code?

Did you notice that you can provide any number of numbers?

Would a short comment have conveyed that information? Would a long comment be useful when you have progressed to the point of recognising @$_? In general comments of that nature should be avoided - at best they obscure the actual code and at worst they may be wrong. In either case they double the effort of maintenance. It is much better to use good identifiers and code structure to convey the intent of code with comments used to provide information about interaction between different parts of the code and other 'global' information that can not be gleaned from the code itself.

---

True laziness is hard work

I'm not sure how you add on paper, but for me, I only ever consider one digit of the number at a time. From my perspective, the problem is that your inputs can be arbitrary numbers, not just digits.

To get all elements to be digits, you can:

• work in a base greater than the largest element (changes the rules, feels like cheating)
• preprocess the arrays
• treat the elements with more care when you pop them

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

use constant BASE => 10;

run( @$_ ) for (
    [    'case1 when @a > @b',
        [qw(1 0 9 15 6)],
        [qw(    1 1  4 )], ],
    [   'case2 when @a < @b',
        [qw(   1  5 9)],
        [qw(10 9  3 6)], ],
    [    'case3 when @a == @b',
        [qw(1 1 6 9 2)],
        [qw(2 1 4 4 8)], ] );


sub run {
    my ($msg, $a, $b) = @_;

    local $\ = "\n"; # or use say on 5.10

    print "# $msg";

    print "@$a";
    print "@$b";
    print "__________+";

    my @result = add( $a, $b );
    print "@result";
    print "";
}

{
    use integer 'division';
    
    sub add {
        my ($a, $b) = @_;
        my @sum;
        my $carry = 0;

        while (@$a || @$b || $carry) {
            my $_a = rem_lsd($a);
            my $_b = rem_lsd($b);

            my $sum = $_a + $_b + $carry;

            $carry = $sum / BASE;
            $sum %= BASE;

            unshift @sum, $sum;
        }

        return @sum;
    }
    
    # get (remove) least significant digit
    # corrects for multidigit inputs (by removing the lsd from the las
+t element)
    # returns zero when array is empty
    sub rem_lsd {
        my $elem = pop @{$_[0]} || 0;

        # put back extra digits
        if (my $extra = $elem / BASE) {
            push @{$_[0]}, $extra;
        }
        $elem %= BASE;

        return $elem;
    }
}
[download]

Thanks very much for the generous explanation, this is just it, esp using the base to decide the value of $carry... I will try something similar of a combination of grandfather reply and this one here.
Excellence is an Endeavor of Persistence. Chance Favors a Prepared Mind

Have (1,0,9,1,5,6) represent the number 651901. That means that $number[$i] is the 10**$i constant and makes lining things up much easier. You'll need to throw in random reverses, but it makes everything else make more sense.

When you're done you may wish to read the code to my (semi-joke) module Math::Fleximal which does something very much like this. (But not necessarily in base 10. Though it can work in base 10.)