I'm assuming that we have lists that look like this:

@oldstock = ("widgets:10:5",
             "wodgets:4:2",
             "spanners:5:3");

@newstock = ("screwdrivers:8:3",
             "hammers:5:1",
             "widgets:3:1");
[download]

@totalstock = ("widgets:13:6",  # Both widget entries joined
               "wodgets:4:2",
               "spanners:5:3",
               "screwdrivers:8:3",
               "hammers:5:1");
[download]

This is a perfect opportunity to use hashes. We have an obvious key (the name), and values (stock and shown). Given that all we really want to do is join the lists together, we should just be able to iterate through them, use some hashes to build our results, and them print them. Here's an example using the arrays above:

my %stock = ();
my %shown = ();

# Build our records

foreach my $record (@newstock @oldstock) {
    my ($name, $stock, $shown) = split(/:/$record);
    $stock{$name} += $stock;
    $shown{$name} += $shown;
}

# Print the result.

foreach my $name (keys %stock) {
    print join(":",$name,$stock{name},$shown{name}),"\n";
}
[download]

Hope that the above helps.

Cheers,
Paul

Update: Updated to not check for the existance of entries in the hashes, but just += them anyway. I was doing an explicit test with exists() in order to avoid warnings, but as it happens using += with an undefined lvalue doesn't produce a warning anyway. Thanks to cLive ;-) for pointing this out.

ah, oops, my point exactly (blush). Small point:

    if (exists($stock{$name})) {
        $stock{$name} += $stock;
        $shown{$name} += $shown;
    } else {
        $stock{$name} = $stock;
        $shown{$name} = $shown;
    }
[download]

You don't need to check it exists:

    $stock{$name} += ($stock + $shown);
[download]

will do.

cLive ;-)

G'day cLive,

The code that you've given above is slightly different from what I used in my example. I was keeping stock and shown seperated, whereas your code is adding them together. I was uncertain which the original poster required, so I erred on the side of caution and went with the most flexible result.

My original post mentions that checking for the existance of hash entries is intentional, in order to avoid warnings. However after checking with perl 5.6.1 and 5.005_03, += does not produce a warning if used with an undefined lvalue, so you're right, it is un-necessary even for avoiding warnings.

Thanks for the feedback, I'll update my original post accordingly.

Cheers,
Paul

my @old_stock1 = ('products','here');
my @old_stock2 = ('products','here');

# define hash to store quantities
my %new_stock;

# iterate through old
for (@old_stock1, @old_stock2) {

  # add one to count for this element
  # (creating it if it doesn't exist)
  $new_stock{$_}++;

}
[download]

for (keys %new_stock) {
  print "$_ = $new_stock{$_}\n";
}
[download]

cLive ;-)

ps - Update - oops, just re-read the question. See below (but the principal still stands :) - pjf seems to have covered it.

One way is to make current inventory a hash of arrays. Assuming you get inventory on a filehandle which returns one record at a time:

my %current_inventory;
while (<RECORDS>) {
    my @ary = split ':';
    $current_inventory{$ary[0]} = [@ary[1,2]];
}
close(RECORDS) or die $!;
# now inventory is in memory as a hash, can look things up directly
[download]

while (<NEW_RECORDS>) {
    my @ary = split ':';
    $current_inventory{$ary[0]}->[0] += ary[1];
    $current_inventory{$ary[0]}->[1] += $ary[2]];
}
close(NEW_RECORDS) or die $!;
# now update is done, save with proper file locking
[download]

This approach will be faster than nested loops. It requires keeping the inventory in memory, but it would be a remarkably varied inventory to make that a problem.

After Compline,
Zaxo

#!/usr/bin/perl -wT
use strict;

my @a = (1,2,3,4,5,6,7);             # make a couple of arrays
my @b = reverse @a;

my $maxlen = $#a > $#b ? $#a : $#b;  # find the last index of the larg
+est one

for my $index (0..$maxlen) {         # loop through the indexes
  my $aval = $a[$index];
  my $bval = $b[$index];

  print "\$a[$index]=$aval  \$b[$index]=$bval\n";
}

=OUTPUT
$a[0]=1  $b[0]=7
$a[1]=2  $b[1]=6
$a[2]=3  $b[2]=5
$a[3]=4  $b[3]=4
$a[4]=5  $b[4]=3
$a[5]=6  $b[5]=2
$a[6]=7  $b[6]=1
[download]

-Blake

perldoc -q intersection might be of marginal interest.

I should have explained that $shown doesn't need to change; it's the number of products that we will appear to have, and if it's zero, then the amount we have will show as a default. I should've explained that.

However, I do think I'm going to be able to get this put together, so thank you all again for your time. :)