Re: N-Dimensional Arrays on the fly

#! perl -slw
use strict;
use Data::Dumper;

sub new {
    return [ ( 0 ) x shift ] if @_ == 1;
    return [ map { new( @_ ) } 1 .. shift ];
}

sub deref {
    return $_[ 0 ] = $_[ 1 ] if @_ == 2;
    return deref( shift()->[ shift ], @_ );
}

my $aref = new( 3, 4, 5 );

deref $aref, 0, 0, 0, 'This is element [0,0,0]';
deref $aref, 2, 3, 4, 'This is element [2,3,4]';

print Dumper $aref;

__END__
$VAR1 = [
          [
            [ 'This is element [0,0,0]', 0, 0, 0, 0 ],
            [ 0, 0, 0, 0, 0 ],
            [ 0, 0, 0, 0, 0 ],
            [ 0, 0, 0, 0, 0 ]
          ],
          [
            [ 0, 0, 0, 0, 0 ],
            [ 0, 0, 0, 0, 0 ],
            [ 0, 0, 0, 0, 0 ],
            [ 0, 0, 0, 0, 0 ]
          ],
          [
            [ 0, 0, 0, 0, 0 ],
            [ 0, 0, 0, 0, 0 ],
            [ 0, 0, 0, 0, 0 ],
            [ 0, 0, 0, 0, 'This is element [2,3,4]' ]
          ]
        ];
[download]

Examine what is said, not who speaks.

"Efficiency is intelligent laziness." -David Dunham
"Think for yourself!" - Abigail
"Memory, processor, disk in that order on the hardware side. Algorithm, algorithm, algorithm on the code side." - tachyon

Comment on Re: N-Dimensional Arrays on the fly Download Code

Replies are listed 'Best First'.
Re^2: N-Dimensional Arrays on the fly by qumsieh (Scribe) on Aug 20, 2004 at 05:21 UTC
Ahh .. that looks good. Thanks. From past experience, I tend to avoid recursion as much as possible since it is usually slower than the more direct approach. I guess that in this case, recursion is the most natural representation. I'll try to benchmark it and see. Thanks again.	[reply]
Re^3: N-Dimensional Arrays on the fly by ikegami (Patriarch) on Aug 20, 2004 at 15:25 UTC
When dealing with trees, it's hard to avoid recursion. And this really is a tree problem: Create a structure which has i0 children, each of which have i1 children, .., each of which has 'i(n-1)' children. Normally, recursion can be avoided with AoA(oA(oA))) by hardcoding the for loops, because the list of loop counter vars acts as the stack recursion would give us. This doesn't apply in this case, because we have an arbitrary number of for loops. You could avoid recursion in this case by creating an 1-dimentional array of loop counters as long as the input list, but it would overcomplicate the code for nothing. It would be fun to code it for hte challenge, but I'm late. Update: `deref` can easily be rewritten to be non-recursive: `sub deref { my $aref = shift; $aref = $aref->[shift] while (@_ > 2); return $aref->[$_[0]] = $_[1]; }` [download]	[reply] [d/l] [select]


Perl-Sensitive Sunglasses
	PerlMonks