How to split array values into to new separate arrays in Perl?

Question

I'am a beginner in learning perl. What I'm trying to do here is to split the array @value and insert it into a new array. my problem is, I do not know exactly how to make my coding to run in loop and get my desired result.

Is it possible to get the desired result using this method or is there any other alternative/way to get the same result?

My code is as below;

my @separated = ();
my @separated1 = ();
my @separated2 = ();
my @separated3 = ();
my $counter = 0;
my @values = "aaa 111 AAA bbb 222 BBB ccc 333 CCC ddd 444 DDD";

foreach (@values) {
my @separated = split(' ', $_);
push @separated1, $separated[0];
push @separated2, $separated[1];
push @separated3, $separated[2];
}
$counter++

print "separated1 = @separated1\n";
print "separated2 = @separated2\n";
print "separated3 = @separated3\n";

Result that I got;

separated1 = aaa

separated2 = 111

separated3 = AAA

Desired Result;

separated1 = aaa bbb ccc ddd

separated2 = 111 222 333 444

separated3 = AAA BB CCC DD

actually you dont use your $counter variable. you increment it, but never access it. i guess you wanted to use it as index for your arrays. — Chris
– Chris, Commented May 9, 2019 at 7:24
This line: my @values = "aaa 111 AAA bbb 222 BBB ccc 333 CCC ddd 444 DDD" ... is assigning one scalar value to an array. It's effectivly putting that scalar value into the first slot of @value array. You may do a split here directly: my @values = split / /, "aaa 111 AAA bbb 222 BBB ccc 333 CCC ddd 444 DDD"; Once this is in place, the rest is to take 3 values at a time etc etc. — gugod
– gugod, Commented May 9, 2019 at 7:30

zdim · Accepted Answer · 2019-06-21 03:28:04Z

A rare ocassion where the C-style for loop is suitable, to iterate over every 3rd element

my $string = 'aaa 111 AAA bbb 222 BBB ccc 333 CCC ddd 444 DDD';

my (@sep1, @sep2, @sep3);

my @values = split ' ', $string;

for (my $i=0; $i <= $#values; $i += 3) {
    push @sep1, $values[$i];
    push @sep2, $values[$i+1];
    push @sep3, $values[$i+2];
}

This assumes that the array indeed has all triplets, or better check each element.

But it's normally far nicer to work with a single structure than with a set of parallel arrays. For example, use an array with elements that are array references

use Data::Dump qw(dd);

my @sep;

for (my $i=0; $i <= $#values; $i += 3) { 
    for my $j (0..2) { 
        push @{$sep[$j]}, $values[$i+$j]; 
    }
}

dd \@sep;

where the double iteration can be avoided with a much cleaner

for my $i (0..$#values) { 
    push @{$sep[$i%3]}, $values[$i] 
}

which replaces the two loops.

This prints

[
  ["aaa", "bbb", "ccc", "ddd"],
  [111, 222, 333, 444],
  ["AAA", "BBB", "CCC", "DDD"],
]

I use Data::Dump to see complex data. An alternative in the core is Data::Dumper.

And then there are many modules with all kinds of utility routines for work with lists.

For example, using part from List::MoreUtils to partition the @values array

my @sep = map { [ @values[@$_] ] } part { $_%3 } 0..$#values;

This produces the same @sep with arrayrefs as above.

The part returns a list of arrayrefs, each containing indices since it partitioned the list of indices of @values. Then in map each arrayref is evaluated into its list of indices (@$_), which is used to take the corresponding slice of @values; that list is used to make an arrayref with []. So map returns a list of arrayrefs, with values partitioned as needed.

For working with references please see tutorial perlreftut and reference perlref

ikegami · Accepted Answer · 2019-05-09 07:33:06Z

4

my ( @foos, @bars, @quxs );
my @values = split(' ', $input);
while (@values) {
   push @foos, shift(@values);
   push @bars, shift(@values);
   push @quxs, shift(@values);
}

The above can also be written as follows:

my ( @foos, @bars, @quxs );
for ( my @values = split(' ', $input); @values; ) {
   push @foos, shift(@values);
   push @bars, shift(@values);
   push @quxs, shift(@values);
}

Are you sure you want parallel arrays, though? While they can save memory, it's usually hard to work with them, and more error-prone. In an object-dominated landscape, they are virtually never seen.

You could use an AoA:

my @moos;
my @values = split(' ', $input);
while (@values) {
   push @moos, [ splice(@values, 0, 3) ];
}

You could use an AoH:

my @moos;
my @values = split(' ', $input);
while (@values) {
   my %moo; @moo{qw( foo bar qux )} = splice(@values, 0, 3);
   push @moos, \%moo;
}

edited May 9, 2019 at 7:33

answered May 9, 2019 at 7:24

ikegami

391k17 gold badges291 silver badges555 bronze badges

2 Comments

Silvar Over a year ago

The first solution will put undefined values in the results if the number of items in the original $values is not divisable by 3.

ikegami Over a year ago

@Silvar, That's intentional, so it's would be better to point out that the AoA solution doesn't do that.

Shawn · Accepted Answer · 2019-05-09 08:20:41Z

3

Another version using part from the non-core but very useful List::MoreUtils module, that partitions up the elements directly:

#!/usr/bin/perl
use warnings;
use strict;
use feature qw/say state/;
use List::MoreUtils qw/part/;

my $str = "aaa 111 AAA bbb 222 BBB ccc 333 CCC ddd 444 DDD";

my ($sep1, $sep2, $sep3) = part { state $i = 0; $i++ % 3 } split(' ', $str);

say "sep1: @$sep1";
say "sep2: @$sep2";
say "sep3: @$sep3";

prints out

sep1: aaa bbb ccc ddd
sep2: 111 222 333 444
sep3: AAA BBB CCC DDD

The magic here is with state, which ends up creating a variable local to the block it's in that retains its value across multiple evaluations of the block.

answered May 9, 2019 at 8:20

Shawn

53.9k3 gold badges29 silver badges74 bronze badges

Comments

Grinnz · Accepted Answer · 2019-05-09 15:34:43Z

3

Another job for List::UtilsBy:

use strict;
use warnings;
use List::UtilsBy 'bundle_by', 'unzip_by';

my $string = 'aaa 111 AAA bbb 222 BBB ccc 333 CCC ddd 444 DDD';
my @vals = split ' ', $string;
my ($sep1, $sep2, $sep3) = unzip_by { @$_ } bundle_by { [@_] } 3, @vals;

print "sep1: @$sep1\nsep2: @$sep2\nsep3: @$sep3\n";

edited May 9, 2019 at 15:34

answered May 9, 2019 at 15:25

Grinnz

9,25113 silver badges18 bronze badges

Comments

Emma Marcier · Accepted Answer · 2019-05-09 23:15:05Z

This expression might help you to get your desired results:

([a-z]+\s)([0-9]+\s)([A-Z]+)

It has three capturing groups for each of your desired results. You can add or reduce boundaries to it, as you wish, and it might be faster than other methods.

Graph

This graph shows how the expression would work and you can visualize other expressions in this link:

JavaScript Test

const regex = /([a-z]+\s)([0-9]+\s)([A-Z]+)/gm;
const str = `aaa 111 AAA bbb 222 BBB ccc 333 CCC ddd 444 DDD`;
const subst = `\n$1 & $2 & $3\n`;

// The substituted value will be contained in the result variable
const result = str.replace(regex, subst);

console.log('Substitution result: ', result);

Perl Test

You can simply use $1, $2 and $3 and separate your data:

use strict;

my $str = 'aaa 111 AAA bbb 222 BBB ccc 333 CCC ddd 444 DDD';
my $regex = qr/([a-z]+\s)([0-9]+\s)([A-Z]+)/mp;
my $subst = '';

my $result = $str =~ s/$regex/$subst/rg;

print "The result of the substitution is' $result\n";

Performance Test

This JavaScript snippet shows the performance of that expression using a simple 1-million times for loop.

const repeat = 1000000;
const start = Date.now();

for (var i = repeat; i >= 0; i--) {
	const string = 'aaa 111 AAA bbb 222 BBB ccc 333 CCC ddd 444 DDD';
	const regex = /([a-z]+\s)([0-9]+\s)([A-Z]+)/gm;
	var match = string.replace(regex, "$1");
}

const end = Date.now() - start;
console.log("YAAAY! \"" + match + "\" is a match 💚💚💚 ");
console.log(end / 1000 + " is the runtime of " + repeat + " times benchmark test. 😳 ");

G. Cito · Accepted Answer · 2019-05-10 03:27:03Z

1

I like the solutions from @ikegami and @zdim. @zdim's use of part() from List::MoreUtils reminded me of natatime:

my @values = split(' ', "aaa 111 AAA bbb 222 BBB ccc 333 CCC ddd 444 DDD"); 
use List::MoreUtils 'natatime';              
my $nata_iter = natatime 3, @values ;
my @aoa ;           
while (my @tmp = $nata_iter->()) { push @aoa, \@tmp; };

Not really a consideration but possibly of interest: by using a temporary array (@tmp) to store the output of the iterator, the original @values remains intact whereas the more straightforward splice() is destructive.

answered May 10, 2019 at 3:27

G. Cito

6,4083 gold badges31 silver badges42 bronze badges

Collectives™ on Stack Overflow

How to split array values into to new separate arrays in Perl?

6 Answers 6

Comments

2 Comments

Comments

Comments

Graph

JavaScript Test

Perl Test

Performance Test

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

6 Answers 6

Comments

2 Comments

Comments

Comments

Graph

JavaScript Test

Perl Test

Performance Test

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related