Here's an evil trick to do it,

my %hash;
%hash = split /,/, $scalar;
my @evens = keys %hash;
my @odds = values %hash;
[download]

That's fine until you have two identical elements in any of the even fields.

Makeshifts last the longest.

That begs a question of semantics. Do you mean the even vs odd values?

Then the common idiom would be something like

my (@even, @odd);
push @{ $_ % 2 ? \@odd : \@even }, $_ for split /,/, $text;
[download]

Here, you loop over all the elements, giving push either @odd or @even to push the element onto, depending on whether the element is odd or even. The awkward @{ ... } construct is necessary because push demands that its first argument have a @ sigil in front, no matter what.

Or, do you mean the even vs odd positions in the list?

Then you'd use something like

my (@even, @odd);

my $i = 0;
push @{ $i++ % 2 ? \@odd : \@even }, $_ for split /,/, $text;
[download]

Here, you increase a position counter at each iteration, and make the decision depending on its even/oddness.

Update: see Re^6: split every other value about the following code and Re^7: split every other value for my reply with a correct derivative.

Another option in this case is something like

my @field = split /,/, $text;

my (@even, @odd) = @field[
    map { $_, $_ + @field / 2 } 0 .. ( @field / 2 ) - 1
];
[download]

That won't work for text, however, which is what the problem supposedly really is. jcpunk wants to split on odd/even array indexes, not on the odd/evenness of the array element.

Update: Oh good, you have a second version which divides the stuff up on array index.

Read the code again. That's exactly what it does.

Makeshifts last the longest.

This is one way:

my $ra_all = [ [], [] ];
map { push @{$ra_all->[$_ % 2]}, $_ } @array;
my @evens = @{$ra_all->[0]};
my @odds = @{$ra_all->[1]};
[download]

Regards,

And even faster with optimisation:

my (@evens, @odds);
my $ra_all = [ \@evens, \@odds ];
map { push @{$ra_all->[$_ % 2]}, $_ } split /,/, $scalar;
[download]

Regards,

PN5

I don't understand the point of the third arrayref. I also find it easier on the eyes with a foreach, but to each his own.

my ( @evens, @odds );
my @all = ( \@even, \@odd );
push @{ $all[ $_ % 2 ] }, $_ for split /,/, $scalar;
[download]

Brevity, but don't do this at home: you can combine the first two lines into

my @all = \my ( @evens, @odds );
[download]

Makeshifts last the longest.

#!/usr/bin/perl

use strict;
use warnings;

my $scalar = '1,2,3,4,5,6,7,8';
my @array = split(/\,/,$scalar);
print "array = @array\n";

# do the odd/even split
my @odd = ();
my @even = ();
while (@array)
{
    my $odd = shift @array;
    my $even = shift @array;
    if (defined $odd)
    {
        push @odd, $odd;
    }
    if (defined $even)
    {
        push @even, $even;
    }
}

print "odd = @odd, even = @even\n";

__END__
[download]

You got your odd/even mixed up. The first element is at index 0, which is even. Also, enter splice and statement modifiers.

while( @array ) {
    my ( $even, $odd ) = splice @array, 0, 2;
    push @odd, $odd if defined $odd;
    push @even, $even if defined $even;
}
[download]

It is worth noting that this would be buggy if the list could possibly have undefs in it (not the case here; but I'd put a comment to that effect in the code).

Obscure trickery for the fun of reducing it further, but don't do this at home:

( $even[ @even ], $odd[ @odd ] ) = splice @array, 0, 2 while @array;
[download]

Makeshifts last the longest.

I shouldn't have used the names "@odd" and "@even", seeing as how we're supposed to be dealing with text. So here's a program which doesn't use those terribly misleading names, and deals with undefs.

#!/usr/bin/perl

use strict;
use warnings;

my @array = map{chr} ('32' .. '126');
push @array, undef, undef;
unshift @array, undef, undef, undef;

# split elements into two arrays
my (@arr0, @arr1);
while (@array > 1)
{
    my ($el0, $el1) = splice @array, 0, 2;
    push @arr0, $el0;
    push @arr1, $el1;
}

# get the last element if there is one
if(@array)
{
    push @arr0, shift @array;
}

# check that all elements were gotten
die "still elements left" if (@array);

print "arr0 = @arr0\narr1 = @arr1\n";

__END__
[download]

my $a = "1,2,3,4,5,6,7,8";
my @even = ($a =~ /(.+?),.+?,?/g); #prints 1,3,5,7
my @old = ($a =~ /.+?,(.+?),?/g); # prints 2,4,6,8
[download]

$list = '1,2,3,4,5,6,7,8';

@odds = grep $_ % 2, split(/,/, $list);
@evens = grep not($_ % 2), split(/,/, $list);
[download]

$list = 'a,b,c,d,e,f,g,h';

$i=0;
@pos1 = grep not($i++ % 2), split(/,/, $list);

$i=0;
@pos2 = grep $i++ % 2, split(/,/, $list);
[download]

That requires iterating over the list twice, though.

Makeshifts last the longest.

my $scalar = '1,2,3,4,5,6,7,8';
print "$scalar\n";
my @evens;
while ( $scalar =~ s/^([^,]),[^,](,|$)// ) {
        push @evens, $1;
}
print "@evens\n";
[download]

You don't need to use a substitution if you anchor the pattern using \G. And why not capture the odd elements as well?

my ( @even, @odd );
while ( $text =~ /\G ( [^,]+ ) (?: , ( [^,]+  ) )? (?: , | \z ) /gx ) 
+{
    push @even, $1;
    push @odd, $2 if defined $2;
}
[download]

Makeshifts last the longest.

my $s = join',', 1..10;
my( @odds, @evens );

m[([^,]+),([^,]+)] 
    and push @odds, $1 
    and push @evens, $2 
    for split /([^,]+,[^,]+)(?:,|$)/, $s;

print "@odds\n@evens";;

1 3 5 7 9
2 4 6 8 10
[download]

You didn't test that with an odd number of elements in $s, did you? :-)

Makeshifts last the longest.

You right. Here's a better way that resurrects and old snippet with (I think), improvements:

sub mapn (&$@) {
    my( $code, $n, ) = ( shift, shift );
    map {
        $code->( @_[ $_ .. $_ + $n -1 ] );
    } map $n * $_, 0 ..  ( $#_ / $n );
}

my $s = join',', 1 .. 11;
my( @odds, @evens );

mapn{ 
    push @odds,  shift||(); 
    push @evens, shift||();
} 2, split ',', $s;

print "@odds\n@evens";;
1 3 5 7 9 11
2 4 6 8 10
[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

A zip function takes two lists as its input, and interleaves them, so given the lists:

qw(ant bat camel)
[download]

qw(aardvark bird cow)
[download]

qw(ant aardvark bat bird camel cow)
[download]

and unzip() does the exact opposite. Language::Functional is a very useful module indeed, despite the very low version number.

nothing fancy:

#!/usr/bin/perl

my @array = ( a .. x, undef );
print "@array\n";

my (@a,@b);
for ( 0 .. $#array ) {
  if ( $_ % 2 ) { 
    push @b, $array[$_];
  } else {
    push @a, $array[$_];
  }
}

print "a: '@a'\n";
print "b: '@b'\n";
[download]

qq

Not glamorous but sturdy and works for text just as well as numbers:

#!/usr/bin/perl

use strict;

my $scalar = '1,2,3,4,5,6,7,8';
my @array = split(/\,/,$scalar);

my $flag = 1;

my ($element, @odds, @evens, $odd, $even);

foreach $element(@array)
{
    if ($flag==1)
    {
        push (@odds, $element); 
        $flag=2;
    }
    else
    {
        push (@evens, $element); 
        $flag=1;
    }
}

print "Odd elements: ";
foreach $odd(@odds)
{
    print "$odd ";
}
print "\nEven elements: ";
foreach $even(@evens)
{
    print "$even ";
}
[download]

Hope this of some help.

Chris