1

I have an array with many fields in each line spaced by different spacing like:

INDDUMMY   drawing2   139       30        1        0        0        0        0        0
RMDUMMY    drawing2   69        2         1        0        0        0        0        0  
PIMP       drawing    7         0         1444     718      437      0        0        0

I'm trying to make sorting for this array by number in 3rd field so the desired output should be:

PIMP       drawing    7         0         1444     718      437      0        0        0
RMDUMMY    drawing2   69        2         1        0        0        0        0        0
INDDUMMY   drawing2   139       30        1        0        0        0        0        0

I tried to make a split using regular expression within the sorting function like:

@sortedListOfLayers = sort {
    split(m/\w+\s+(\d+)\s/gm,$a)
    cmp
    split(m/\w+\s+(\d+)\s/gm,$b)
}@listOfLayers;

but it doesn't work correctly. How I could make that type of sorting?

Improve this question

2 Answers 2

Reset to default
1

You need to expand out your sort function a little further. I'm also not sure that split is working the way you think it is. Split turns text into an array based on a delimiter.

I think your problem is that your regular expression - thanks to the gm flags - isn't matching what you think it's matching. I'd perhaps approach it slightly differently though:

#!/usr/bin/perl
use strict;
use warnings;

my @array = <DATA>;

sub sort_third_num {
   my $a1 = (split ( ' ', $a ) )[2];
   my $b1 = (split ( ' ', $b )) [2];
   return $a1 <=> $b1;
}

print sort sort_third_num @array;

__DATA__
NDDUMMY   drawing2   139       30        1        0        0        0        0        0
RMDUMMY    drawing2   69        2         1        0        0        0        0        0  
PIMP       drawing    7         0         1444     718      437      0        0        0

This does the trick, for example.

If you're set on doing a regex approach:

sub sort_third_num {
    my ($a1) = $a =~ m/\s(\d+)/;
    my ($b1) = $b =~ m/\s(\d+)/;
    return $a1 <=> $b1;
}

not globally matching means only the first element is returned. And only the first match of 'whitespace-digits' is returned. We also compare numerically, rather than stringwise.

Improve this answer
Sign up to request clarification or add additional context in comments.

9 Comments

For extra credit, take what Sobrique has taught you about split & regex, Search the web and teach yourself about the Schwartzian Transform, and split the lines O(n) times instead of O(n*ln(n)) times.
Or you could just save yourself all the bother and pass just the split part of the code into List::UtilsBy 's nsort_by function
@eslamsaad: Or, better still, leave it as it is unless it's running too slowly for you
@LeoNerd: But as the author of the module you would say that, wouldn't you. I have no problem wityh the recommendation, but I would prefer full disclosure
I would prefer sub sort_third_num {my ($aa, $bb) = map { (split)[2] } $a, $b; $aa <=> $bb; } to DRY things out
|
0

If you want to sort a list and the operation used in the sort block is expensive, an often used Perl idiom is the Schwartzian Transform: you apply the operation once to each list element and store the result alongside the original element, sort, then map back to your original format.

The classic textbook example is sorting files in a directory by size using the expensive -s file test. A naïve approach would be

my @sorted = sort { -s $a <=> -s $b } @unsorted;

which has to perform -s twice for each comparison operation.

Using the Schwartzian Transform, we map the file names into a list of array references, each referencing an array containing the list element and its size (which has to be determined only once per file), then sort by file size, and finally map the array references back to just the file names. This is all done in a single step:

my @sorted =
    map $_->[0],                 # 3. map to file name
    sort { a$->[1] <=> b$->[1] } # 2. sort by size
    map [ $_, -s $_ ],           # 1. evaluate size once for each file
    @unsorted;

In your case, the question is how expensive it is to extract the third field of each array element. When in doubt, measure to compare different methods. The speedup in the file size example is dramatic at about a factor 10 for a few dozen files!

The Schwartzian Transform applied to your problem would look something like this:

my @sorted =
    map $_->[0],                         # 3. Map to original array
    sort { $a->[1] <=> $b->[1] }         # 2. Sort by third column
    map [ $_, ( split( ' ', $_ ) )[2] ], # 1. Use Sobrique's idea
    @array;

If the operation used is so expensive that you want to avoid performing it more than once per value in case you have identical array elements, you can cache the results as outlined in this question; this is known as the Orcish Maneuver.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.