split numeric array at specific positions - arrays

Question

I am trying to split a numerical array into smaller arrays such that each of the smaller arrays cannot contain any numbers that differ.
Example: The array (2,2,2,2,2,9,3,3,3,3) should be split into the three arrays (2,2,2,2,2), (9) and (3,3,3,3).
Here is what I tried:
my #arr = (2,2,2,2,2,9,3,3,3,3);
my #result = ();
my $last = -1;
my #newarr = ();
for my $i (0 .. $#arr){
if ( ($i>0 && $arr[$i] != $last) || $i == $#arr ){
push #result, \#newarr;
#newarr = ();
}
$last = $arr[$i];
push #newarr, $arr[$i];
}
Firstly, this code does not give me the desired result. I think my mistake is when I push the reference to #newarr into #result, but then I re-initialize #newarr.
Secondly, aren't there more elegant ways to do this? I looked at the functions split and splice, but could not think of a good solution.

Answer 1

List::MoreUtils has the "part" function:
use Data::Dumper;
use feature 'state';
use List::MoreUtils 'part';
my #array = ( 2,2,2,2,2, 9, 3,3,3,3 );
my #part = part {
state $prev;
state $i = -1;
$i++ if !defined($prev) || $_ ne $prev;
$prev = $_;
$i
} #array;
print Dumper #part;
With 'part', the value that the code block returns dictates the top level array index where the current value will be pushed into an anonymous array. $prev starts out undefined, so the first element in the input will trigger $i to increment to 0, so all of the '2's will end up in #{$part[0]}. As soon as an element in #array doesn't match $prev, the index will be incremented, and subsequent elements end up in #{$part[1]}. Each time a change is detected, a new grouping starts.
Update:
If this segment of code might be used more than once, the 'state' variables will persist their values across calls. In such a case, state is more trouble than it's worth, and one should just use lexicals in a subroutine:
use Data::Dumper;
use List::MoreUtils 'part';
my #array = ( 2,2,2,2,2, 9, 3,3,3,3 );
my #part = partition(#array);
print Dumper \#part;
sub partition {
my( $prev, $i ) = ( undef, -1 );
return part {
$i++ if ! defined($prev) || $_ ne $prev;
$prev = $_;
$i;
} #_;
}

Answer 2

Creating an array of arrays grouped by like elements.
For a refresher on complex data structures, check out perldsc.
use strict;
use warnings;
my #array = (2,2,2,2,2,9,3,3,3,3);
my #grouped;
for (#array) {
if (! #grouped || $grouped[-1][0] != $_) {
push #grouped, [];
}
push #{$grouped[-1]}, $_;
}
use Data::Dump;
dd #grouped;
Outputs:
([2, 2, 2, 2, 2], [9], [3, 3, 3, 3])

Answer 3

use List::Util 'reduce';
my #arr = (2,2,2,2,2,9,3,3,3,3);
my $result = reduce {
if ( #$a && $b == $a->[-1][0] ) {
push #{ $a->[-1] }, $b
}
else {
push #$a, [ $b ]
}
$a
} [], #arr;
Simpler but maybe more confusing to read:
my $result = reduce {
push #{ $a->[ #$a && $b == $a->[-1][0] ? -1 : #$a ] }, $b;
$a
} [], #arr;

Answer 4

my #arr = (2,2,2,2,2,9,3,3,3,3);
my %h;
my #newarr = map {
my $ok = !$h{$_};
push #{$h{$_}}, $_;
$ok ? $h{$_} : ();
}
#arr;
use Data::Dumper; print Dumper \#newarr;
or
my #arr = (2,2,2,2,2,9,3,3,3,3);
my %h;
my #newarr;
for my $v (#arr) {
if (!$h{$v}) {
push #newarr, ($h{$v} = []);
}
push #{$h{$v}}, $v;
}
output
$VAR1 = [
[
2,
2,
2,
2,
2
],
[
9
],
[
3,
3,
3,
3
]
];

Answer 5

Mandatory regex answer:
my #result = map [ (ord) x length ], grep --$|, join( '', map chr, #arr ) =~ /((.)\2*)/sg;
(under no warnings "non_unicode";).

Answer 6

This will do what you ask. It works by packing the contents of the data as a set of digits and counts and then unpacks it in the required format. The output data is in #num. I have used Data::Dump only to display the resulting data structure.
use strict;
use warnings;
my #arr = (2,2,2,2,2,9,3,3,3,3);
my (%rep, #num);
$rep{$_}++ or push #num, $_ for #arr;
#num = map [ ($_) x $rep{$_} ], #num;
use Data::Dump;
dd \#num;
output
[[2, 2, 2, 2, 2], [9], [3, 3, 3, 3]]
Update
The above solution collects all the elements with the same value into one group, even if they came from separate sequences. If you need the output arrays to be split at every change of value then this will do what you need.
use strict;
use warnings;
my #arr = (2,2,2,2,2,9,9,9,2,2,2,9,9,9);
my #groups;
for (#arr) {
push #groups, [ ] unless #groups and $_ == $groups[-1][-1];
push #{ $groups[-1] }, $_;
}
use Data::Dump;
dd \#groups;
output
[[2, 2, 2, 2, 2], [9, 9, 9], [2, 2, 2], [9, 9, 9]]
Update 2
Here's another version in view of your answer to ikegami's comment, which revealed that a list of values and their associated counts is probably closer to what you need.
use strict;
use warnings;
my #arr = (2,2,2,2,2,9,9,9,2,2,2,9,9,9);
my #groups;
for (#arr) {
if (#groups and $_ == $groups[-1][0]) {
$groups[-1][1] += 1;
}
else {
push #groups, [ $_, 1 ];
}
}
use Data::Dump;
dd \#groups;
output
[[2, 5], [9, 3], [2, 3], [9, 3]]

Answer 7

You can create a hash of arrays where by the key of the has will be a number. and for each time you encounter that number you can push it on to the array reference of the hash. thus all numbers will be split into arrays as you expected. you can then just iterate through the hash to print the arrays or access each array by its number.
use strict;
use Data::Dumper;
my #arr = (2,2,2,2,2,9,3,3,3,3);
my %hash;
push(#{$hash{$_}},$_) foreach (#arr);
print Dumper(\%hash);
output
$VAR1 = {
'3' => [
3,
3,
3,
3
],
'9' => [
9
],
'2' => [
2,
2,
2,
2,
2
]
};