Re^3: du -h, sorted

[grinder]

in reply to Re^2: du -h, sorted
in thread du -h, sorted

You're absolutely correct. Allow me to replace it by the following, clocking in at 87.

perl -e'sub h{pop=~/(...)(.)/&&{M,1e3,G,1e6}->{$2}+$1}print sort{h($b)
+<=>h$a}`du -h`'

update: No wait! There's something in your idea of bitanding... Just have to get rid of the second spaceship comparator...

perl -e'sub c{pop=~/[GMK]/;(ord$&&7).1e3+$`}print sort{c($b)<=>c$a}`du
+ -h`'

76 strokes.

[hbm]

Alas, your last two methods put a 400K file before a 399M file... For the first one, I added a "K" key to your anonymous hash:

perl -e 'sub h{pop=~/^([\d.]+)(.)/&&{K,1e1,M,1e3,G,1e6}->{$2}+$1}print
+ sort{h($b)<=>h$a}`du -h`'

For the second one, I think you're in a bind because ord(k)&7 and ord(K)&7 are equal...

And I offer another method, bumming heavily from yours, longer but possibly faster on large filesystems:

perl -e 'print map substr($_,8),reverse sort map sprintf("%8d",(/^([\d
+.]+)([kKMG])/)?{K,1e1,M,1e3,G,1e6}->{$2}+$1:$1).$_,`du -h`'

[bellaire]

Oh, I see. Could I then also change the regex to save two more characters?

perl -e'sub c{pop=~/.\s/;(ord$&&7).1e3+$`}print sort{c($b)<=>c$a}`du -
+h`'

74 characters.

And, in fact, since we are only using .1e3 to make sure the sizes sort properly, why not save one more:

perl -e'sub c{pop=~/.\s/;(ord$&&7)**7+$`}print sort{c($b)<=>c$a}`du -h
+`'

73 characters.

[hbm]

Slick! But how about 70, using 'x' instead of '**', and 'die' instead of 'print':

perl -e'sub c{pop=~/.\s/;(ord$&&7)x7+$`}die sort{c($b)<=>c$a}`du -h`'

[bellaire]

Very impressive. Made me waste a lot of time trying to beat it!

I think I've got it just a little shorter. I don't know if the time I spent on this has brought me any closer to enlightenment, but it did make me fast (as in skip a meal)...

perl -e'%h=map{/.\s/;7**(ord$&&30)-$`,$_}`du -h`;die @h{sort %h}'

66 characters.

The key is the 7 to the power of ord(char) bitwise 30 part. I had to write a little perl script that would find the magic values 7 and 30 which would work for a lexicographic (default) sort. That is, I take 7 to the power of those values, and subtract the value of $` ... to produce hash keys which sort properly.

Then I take a hash slice on the sorted result. The sort actually returns the entire flattened hash sorted, keys and values, but since the values in that hash don't map to anything, they are silent.

I think I need to go get something to eat.