split rowcount of a table by 3 ways in perl - perl

Question

I am getting rowcount of a sybase table in perl. For example table have 100 rows, so n=100
I want to split this value into 3 parts
1-33 | 34-66 | 67-99 or 100
please advise how do get this in perl.
Reason for this split: I need to pass the values 1 and 33 as input parameter to a stored proc to select rows whose identity column value is between 1 and 33.
same goes for 34-66 & 67-99

Answer 1

The interesting part is deciding where each range starts. From there it's easy to decide that each range ends at one less than the start of the next range.
This partition() function will determine the start points for given number of partitions within a given number of elements starting at a given offset.
sub partition {
my ($offset, $n_elements, $n_partitions) = #_;
die "Cannot create $n_partitions partitions from $n_elements elements.\n"
if $n_partitions > $n_elements;
my $step = int($n_elements / $n_partitions);
return map {$step * $_ + $offset} 0 .. $n_partitions - 1;
}
Here's how it works:
First, determine what the step should be by dividing the number of elements by the number of partitions, and preserving the integer by truncating any trailing decimal places.
Next walk through the steps by starting at zero and multiplying by the step number (or the partition number). So if the step is 5 then 5*0=0, 5x1=5, 5x2=10, and so on. We will not look at the last step, because it makes more sense to include an "off by one" in the last partition than to start a new partition with only one element.
Finally, we allow for an offset to be applied, so that partition(0,100,5)means to find the starting element positions for five partitions starting at zero and continuing for 100 elements (so a range of 0 to 99). And partition(1,100,5) would mean start at 1 and continue to 100 elements partitioning in five segments, so a range of 1 to 100.
Here's an example of putting the function to use to find the partition points in a set of several ranges:
use strict;
use warnings;
use Test::More;
sub partition {
my ($offset, $n_elements, $n_partitions) = #_;
die "Cannot create $n_partitions partitions from $n_elements elements.\n"
if $n_partitions > $n_elements;
my $step = int($n_elements / $n_partitions);
return map {$step * $_ + $offset} 0 .. $n_partitions - 1;
}
while(<DATA>) {
chomp;
next unless length;
my ($off, $n_elems, $n_parts, #starts) = split /,\s*/;
local $" = ',';
is_deeply
[partition($off, $n_elems, $n_parts)],
[#starts],
"Partitioning $n_elems elements starting at $off by $n_parts yields start positions of [#starts]";
}
done_testing();
__DATA__
0,10,2,0,5
1,11,2,1,6
0,3,2,0,1
0,7,3,0,2,4
0,21,3,0,7,14
0,21,7,0,3,6,9,12,15,18
0,20,3,0,6,12
0,100,4,0,25,50,75
1,100,4,1,26,51,76
1,100,3,1,34,67
0,10,1,0
1,10,10,1,2,3,4,5,6,7,8,9,10
This yields the following output:
ok 1 - Partitioning 10 elements starting at 0 by 2 yields start positions of [0,5]
ok 2 - Partitioning 11 elements starting at 1 by 2 yields start positions of [1,6]
ok 3 - Partitioning 3 elements starting at 0 by 2 yields start positions of [0,1]
ok 4 - Partitioning 7 elements starting at 0 by 3 yields start positions of [0,2,4]
ok 5 - Partitioning 21 elements starting at 0 by 3 yields start positions of [0,7,14]
ok 6 - Partitioning 21 elements starting at 0 by 7 yields start positions of [0,3,6,9,12,15,18]
ok 7 - Partitioning 20 elements starting at 0 by 3 yields start positions of [0,6,12]
ok 8 - Partitioning 100 elements starting at 0 by 4 yields start positions of [0,25,50,75]
ok 9 - Partitioning 100 elements starting at 1 by 4 yields start positions of [1,26,51,76]
ok 10 - Partitioning 100 elements starting at 1 by 3 yields start positions of [1,34,67]
ok 11 - Partitioning 10 elements starting at 0 by 1 yields start positions of [0]
ok 12 - Partitioning 10 elements starting at 1 by 10 yields start positions of [1,2,3,4,5,6,7,8,9,10]
1..12
For additional examples look at Split range 0 to M into N non-overlapping (roughly equal) ranges. on PerlMonks.
Your question is looking for complete range start and end points. This method makes it rather trivial:
sub partition {
my ($offset, $n_elements, $n_partitions) = #_;
my $step = int($n_elements / $n_partitions);
return map {$step * $_ + $offset} 0 .. $n_partitions - 1;
}
my $n_elems = 100;
my $offset = 1;
my $n_parts = 3;
my #starts = partition($offset, $n_elems, $n_parts);
my #ranges = map{
[
$starts[$_],
($starts[$_+1] // $n_elems+$offset)-1,
]
} 0..$#starts;
print "($_->[0], $_->[1])\n" foreach #ranges;
The output:
(1, 33)
(34, 66)
(67, 100)
Even more implementation examples appear in Algorithm for dividing a range into ranges and then finding which range a number belongs to on the StackExchange Software Engineering forum.