Searching an array of version numbers in Perl - arrays

Question

I have a problem to solve, which is to find the index of a target version from an index array. The index array looks like: {16.3.1, 16.2.5, 16.1.4, 15.3.5, 15.1.1}.
For each individual item in this array (such as 16.3.1), it is concatenated of these 3 parts:
16 is the yearly release number.
3 is the quarterly release number, and it is in the range of {1,2,3,4}.
1 is the bi-weekly release number, and it can be one of these 6 options (1,2,3,4,5,6).
And the array is sorted in descending order.
Now these are the requirements:
if I was giving a target version, such as 16.1.4, this algorithm will return me the matching index from that array, which is 2.
if I was giving a target version of 16.1.5, which is not in that array, then it will return me the index of next available one, which is also 2.
The target value is always higher than 15.1.1, which means it will always return a valid index back.
I was thinking of converting such a value into a number, then to do a search. (For example, 16.1.4 => 16 * 24 + 1 * 6 + 4 = 394, ..., )
But I am just wondering if there is a simple way to solve this problem?

Answer 1

Your solution will basically have the following form:
use List::MoreUtils qw( first_index );
my #versions = qw( 16.3.1 16.2.5 16.1.4 15.3.5 15.1.1 );
my $target = '16.1.4';
my $target_key = make_key($target);
my $index = first_index { make_key($_) <= $target_key } #versions;
For long lists, you'd use a binary search instead.
The previously posted solution assumes you are starting from hardcoded values, whereas this one demonstrates how to start from strings of any origin.
All you need now is a way to generate a key that's easily comparable with string or numerical comparison operators. The following are sorted from fastest to slowest:
# Use numerical comparison functions (<=).
sub make_key {
my #parts = split(/\./, $_[0]);
return ( $parts[0] * 4 + $parts[1] ) * 6 + $parts[2];
}
or
# Use string comparison functions (le).
sub make_key {
my $key = '';
$key .= chr($_) for split(/\./, $_[0]);
return $key;
}
or
use Sort::Key::Natural qw( mkkey_natural );
# Use string comparison functions (le).
sub make_key { mkkey_natural($_[0]) }
The first solution is an implementation of what formula you suggested.
The second solution is similar to version->parse, but without all the overhead and special cases you don't need.

Answer 2

Your version strings look normal enough, and your description supports the notion that you could probably just do a string comparison without further conversion. And the domain they represent is unlikely to change arbitrarily (quarters will always be quarters, for example). So since they are relationally comparable as strings, a simple string comparison is probably adequate.
The binsearch_pos function from List::BinarySearch will provide the index of the target element, or if the target element is not found, the index at which point the target could be inserted to preserve order. It is a stable binary search, so it will always return the lowest index where the target matches. Those characteristics seem to provide exactly what you need:
use List::BinarySearch qw(binsearch_pos);
my #array = qw(
16.3.1
16.2.5
16.1.4
15.3.5
15.1.1
);
print "$_: $array[$_]\t" foreach 0 .. $#array;
print "\n\n";
print "$_: ", (binsearch_pos {$b cmp $a} $_, #array), "\n"
foreach qw(16.3.1 16.3.6 16.2.7 16.2.5 16.2.4 15.1.1 15.1.3 15.1.0);
If the list of versions is short, then List::MoreUtils::first_ix is a simple linear approach that will be sufficiently efficient. If the list is sufficiently large, the binary search might be worth considering, as it scales logarithmically rather than linearly. This means as your list of version strings grows the time needed to search the list will grow at a slower rate using the binary search than it would using a linear search.
Because your list is in descending order, this solution uses $b cmp $a, which accommodates that descending order.

Answer 3

Perl supports a data type called version strings, which packs a version number as a string with a sequence of code points. For instance, v1.2.3 would be represented as the string "\x1\x2\x3"
You can create such a string by using v followed by a dotted-decimal sequence, or any dotted-decimal sequence with two or more dots will be treated the same way, even without the v
So we can solve your problem very simply by using version strings in combination with the first_index function from List::MoreUtils, like this
use strict;
use warnings 'all';
use feature 'say';
use List::MoreUtils 'first_index';
my #versions = ( v16.3.1, v16.2.5, v16.1.4, v15.3.5, v15.1.1 );
for my $target ( v16.1.4, v16.1.5 ) {
say first_index { $_ le $target } #versions;
}
output
2
2
There may be a problem with getting the version strings into your program in the first place, which is why I asked how you currently read them. But it's really no big issue if you explain what you need
Update
I've changed my answer to use v16.1.4, v16.1.5etc. It worked fine before, but it's less than obvious that 16.1.4 is a completely different literal from the floating-point value 16.1. On the other hand, v16.1.4 and v16.1 are both version strings
You also don't really say where your input comes from. Fair enough, you can declare a literal array of versions, as I have in my answer, but presumably your $target won't also be a literal, otherwise there's little point in writing the program in the first place
I hoped you would talk about where these things were coming from so that I could help you, but you probably need to look at the version pragma, which offers class methods that will convert between ordinary strings and version strings
For example, if the target was supplied as a string you could use version->parse to convert it to a version string, which means the final loop above would look like this
use version;
for my $target ( "16.1.5", "16.1.4" ) {
my $vs = version->parse($target);
say first_index { $_ le $vs } #versions;
}
So version->parse("16.1.4") eq v16.1.4 is always true
I hope that has clarified rather than confused