tags:

views:

4714

answers:

4

I need to get the total items in array, NOT the last id, none of both ways I found to do this works:

my @a;
# Add some elements (no consecutive ids)
$a[0]= '1';
$a[5]= '2';
$a[23]= '3';

print $#a, "\n"; # prints 23
print scalar(@a), "\n"; # prints 24

I expected to get 3..

Thank you in advance.

+6  A: 

print scalar grep { defined $_ } @a;

kcwu
Explanation: perl does not really have "sparse" arrays as grilix wants them. If you say "my @a; $a[10]=5;" then perl creates an array with 11 entries: the first 10 are filled with 'undef', the 11th is filled with '5'. What "scalar @a" and "$#a" report is always the overall length/last index. kcwu filters the array to count only the defined entries.
Well, works :P.. Thank you !
grilix
It works, but it is not good. The grep function is O(n), which means if you have @a[1, 1_000_000] = (1, 2); then it has to look at each of the 1,000,000 items to get you a count, it also means that you will be taking up a bunch of memory for no reason, use a hash instead.
Chas. Owens
Ya.. It works IF I HAVE TO use arrays, but I think I can use hashes instead. Anyway, he just response what I've asked for. Thank you all.
grilix
+10  A: 

Maybe you want a hash instead (or in addition). Arrays are an ordered set of elements; if you create $foo[23], you implicitly create $foo[0] through $foo[22].

ysth
+20  A: 

scalar grep

Here are two possible solutions (see below for explanation):

print scalar(grep {defined $_} @a), "\n";  # prints 3
print scalar(grep $_ @a), "\n";            # prints 3

Explanation: After adding $a[23], your array really contains 24 elements --- but most of them are undefined (which also evaluates as false). You can count the number of defined elements (as done in the first solution) or the number of true elements (second solution).

What is the difference? If you set $a[10]=0, then the first solution will count it, but the second solution won't (because 0 is false but defined). If you set $a[3]=undef, none of the solutions will count it.

As suggested by another solution, you can work with a hash and avoid all the problems:

$a{0}  = 1;
$a{5}  = 2;
$a{23} = 3;
print scalar(keys %a), "\n";  # prints 3

This solution counts zeros and undef values.

Yaakov Belch
Will try hashes, thank you.
grilix
+9  A: 

It sounds like you want a sparse array. A normal array would have 24 items in it, but a sparse array would have 3. In Perl we emulate sparse arrays with hashes:

#!/usr/bin/perl

use strict;
use warnings;

my %sparse;

@sparse{0, 5, 23} = (1 .. 3);

print "there are ", scalar keys %sparse, " items in the sparse array\n",
    map { "\t$sparse{$_}\n" } sort { $a <=> $b } keys %sparse;

The keys function in scalar context will return the number of items in the sparse array. The only downside you using a hash to emulate a sparse array is that you must sort the keys before iterating over them if their order is important.

You must also remember to use the delete function to remove items from the sparse array (just setting their value to undef is not enough).

Chas. Owens
This is right on. However, Tie::IxHash is optional; in your example it seems unnecessary.Also, no need to provide the predicate to sort, as that is the default. "sort keys %sparse" works as well.
spoulson
Whoops, the Tie::IxHash is left over from a different example. Let me remove that.
Chas. Owens
@Spoulson No the default sort is lexical not numeric, so keys (1, 2, and 10) will be sorted (1, 10, 2).
Chas. Owens