Probably the first thing I'd do is invert the HoA of the source structure, since the numbers are of primary importance; you won't need the letters ($a, etc.) until constructing the new structure.

So

'I' => {
     $a => [4,10,200],
     $b => [75,350],
. . .
[download]

'I' => {
    4 => $a,
    10 => $a,
    200 => $a,
    75 => $b,
    350 => $b,
. . .
[download]

But you didn't say what should happen if a number appears in more than one list, e.g.

'I' => {
     $a => [10,200],
     $b => [75,200,350],
. . .
[download]

Maybe that just won't happen.

More importantly, what should be the behavior if a number is in two different "clusters", e.g.

$interval = 500;
'I' => {
     $a => [200,500,800],
. . .
[download]

In this case, 200 and 500 could be a cluster, and 500 and 800 could be a cluster. (Again, maybe this just won't happen.)

Good questions, all. I didn't address them at first for 2 basic reasons. First, my post was already so long, and second, I haven't the foggiest notion of what I should do.

I guess, in terms of the latter question

$interval = 500;
'I' => {
     $a => [200,500,800],
...
[download]

I guess my thoughts are, it's not *likely* to happen, but can. In that case, I was sort of thinking that if they overlap by $interval/2 or more, then just lump them together. Although, this can be dealt with at a later time.

As for a number appearing in more than 1 list, ideally, again, this wouldn't happen, but I have to assume it will. Always assume the user will f*** up your program somehow, right?

Matt

I've put together some not very elegant code that seems to do pretty much what you want.

Concerning overlaps, as brought up by jdporter, your test data actually contains such an instance. Consider the sequence:

If $interval is 500, how should this sequence be dealt with? For the purposes of my code, I interpreted your words "find all the groups that are within $interval of each other" literally, splitting this sequence into two "clusters", namely:

But the alternative solution offered in your follow-up post would be a lot easier to code. ;)

The code also deals with numbers appearing in multiple lists.

This is the Data::Dump output for the first roman numeral:

(
  "I",
  [
    [1, [4, 10, 200], 3, [0, 95], 2, [75, 350]],
    [1, [6000], 3, [5990], 2, [5900]],
    [1, [6000], 3, [5990, 6450], 2, [6402]],
    [1, [7000, 7100], 2, [7110]],
  ],
)
[download]

Oh, and by the way, you shouldn't use $a and $b as variable names, or strictures (you do use strict; don't you?) will complain when you do a sort:

Anyway, here's the program:

Thanks. I haven't had a chance yet to look over your code, but I'll take a look tomorrow. Thanks though.

As for the variable names, I was only using $a and $b in the example. As it stands, in my program, the keys corresponding to the RomanNumerals, and the letters, are actually created on the fly via iterations. And yes, I do use use strict

So, I think I actually figured out a way to do it myself. I haven't tried this or denugged it, but it logically seems to do what want, if inelegantly. I just use for keys... to go through each hash and sub-hash until I get to the elements, and then I compare that to each individual element with another set of for keys... calls.

Here's the crux of it, sorry if all the variable names are hard to follow, I'm just in a bit of a rush and aren't up to fixing it for logical readability right now....

sub WEED {
 # this sets up that we will perform this for each fasta sequence in w
+hatever
 # file.  makes the rest of the sub one step simpler.
 FASTA: for my $fastaseq (keys %matches) {
   $setscounter = 0;
   SITE: for my $site (sort {$a <=> $b } keys %{$matches{$fastaseq}}) 
+{
     ELEM: for my $i (@{$matches{$fastaseq}{$site}}) {
       $lowerlimit = $matches{$fastaseq}{$site}[$i];
       $upperlimit = $span + $lowerlimit;
       SITEKEY: for my $sitekey (sort {$a <=> $b } keys %{$matches{$fa
+staseq}}) {
         SET: for $setcount (@{$matches{$fastaseq}{$sitekey}}) {
           if ($setcount >= $lowerlimit || $_ <= $upperlimit) {
             push @{$sets{$fastaseq}[$setscounter]{$sitekey}}, $setcou
+nt;
             #closes If setcount
             }
           next SET;
           #closes For setcount
           }
         next SITEKEY;  
         #closes SITEKEY  
         }    
       next ELEM;
       # closes for my i
       }
     $setscounter++;
     next SITE;
     #closes for my site
     }
   next FASTA;
   #closes for my fastaseq
   }
 return %sets;
 #closes subroutine
 }
[download]

Thanks all for the help so far,
Matt