Thank you very much... I think that with some modifications to extract the offset and the length of the subsequences from my nested structure, and being able to sort them this will work very well. I am studying the code, it is not very easy for me yet to understand code written by others.

Thank you again, Roger

it is not very easy for me yet to understand code written by others.

We all have that trouble :) Maybe this annotation will help. I'm always wary of doing this because I tend to comment on the things I think are significant, rather than on those that the reader will consider so. But Maybe it will help you.

Note: You could make @bits hold [ offset, $subsequence ]. You would then have to use length( $bit[ n ][ 1 ] ) everywhere I've used $bit[ n ][ 1 ].

#! perl -slw
use strict;

## Generate some data
my $string = '1234567890' x 7;

## This just generates some random subsequences as offset/length pairs
## Array of Arrays (AoA): $bits[ n ] = [ offset, length]
my @bits = map [ int rand length $string, 2 + int rand 10 ], 1 .. 20;

## Sort ascending offset/descending length
@bits = sort{
    $a->[ 0 ] <=> $b->[ 0 ]  ## sort on the offsets of $a & $b
    ||                       ## And if they are equal
    $b->[ 1 ] <=> $a->[ 1 ]  ## on the lengths (reversed}
} @bits;

## Result ex: @bits =( [2,5],[2,3],[3,1][4,4],[4,3] etc.


## @groups will become an AoAoA. 
## Individual offset/length pairs are moved from @bits
## into @groups[n][m] Where 
##  n := line of output 
##  m := non-overlapping pair in line
## $groups[ n ] = [ [ offset1, length1], ...], [[,],[,]],...]
my @groups;

## As we're moving pairs from @bits to @groups[n]
## When @bits is empty, we know we're done.
while( @bits ) {

    ## start a new group with the last (rightmost shortest) item in @b
+its
    ## First time around the while loop, first line of output; 2nd tim
+e 2nd line
    push @groups, [  pop @bits ];

    ## look at each of the remaining pairs in @bits
    ## scanning backwards because we are removing elements from @bits
    ## and if we went forward, removing element i would screw up the i
+ndexing
    ## for elements i+1 .. i+n. 
    for my $bit ( reverse 0 .. $#bits ) {

        ## if it'll fit in this line
        ## compare the last position (offset+length) for the current b
+it
        ## against the first position (offset) of the last element of 
+the 
        ## last group (line)
        if( $bits[ $bit ][ 0 ]+ $bits[ $bit ][ 1 ] < $groups[-1][-1][0
+] ) {

            ## If it's is less (moving backward!), add it.
            push @{ $groups[-1] }, splice @bits, $bit, 1;
        }
    }
    ## When the for loop ends, we've scanned all the bits and moved
    ## any that will fit in the current line without overlap.
    ## So now, if there are any left (while(@bits)) loop back to
    ## push another anon array onto @group add ing the now last elemen
+t 
    ## of @bits as a starting point. Repeat the for loop.
}

## display the results
print $string;
for my $group ( @groups ){
    my $line = ' ' x 70;
    for my $bit ( @{ $group } ) {
        substr $line, $bit->[ 0 ], $bit->[ 1 ], 
            substr $string, $bit->[ 0 ], $bit->[ 1 ];
    }
    print $line;
}
[download]

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

"Too many [] have been sedated by an oppressive environment of political correctness and risk aversion."

Thank you!!! that was very nice commented! You helped me a lot. I am working now on adapting your code to my script. When I finish, I will post the final result.