0-9 are the same, and:
A - 11
B - 12 
...
V - 31
[download]

Just use 16-bit. The simplest solution is usually the best.

I've mapped base 32 to 'A'..'Z', 0 .. 5, but you could use any set of 32 symbols that you like:

use Digest::MD5 qw[ md5 ];
sub md5_base32{ 
    join'',map{ 
        ('A'..'Z', 0..5 )[ ord pack 'b5', $_ ] 
    } unpack '(A5)*', unpack'b*', md5( $_[ 0 ] ) 
}

print md5_base32( 'fred' );

XSCAZ54XMU5W0OVYUWYRGZU0RF
[download]

Note that the last digit will always be 0..5/'A'..'F', but that's probably okay for your purpose.

Update: A slightly more efficient version:

sub md5_base32_2{ 
    join'', ('A'..'Z', 0..5 )[ 
        unpack 'C*', 
          pack '(b5)*', 
        unpack '(A5)*', 
        unpack 'b*', 
           md5 $_[ 0 ] 
    ] 
}
[download]

use strict;
use Digest::MD5 qw(md5);

my $d = md5("somerandomdata");
my $f = join "", map sprintf ("%03d", ord $_), split "", $d;

print $f;
[download]

Why? Taking the ordinate doesn't make the file name any more unique than not taking it. If you want safety, you would be better off using Data::UUID, which, as the docs say, will generate a UUID that "…is 128 bits long, and is guaranteed to be different from all other UUIDs/GUIDs generated until 3400 CE."

Granted, that's limited to your domain, but I still doubt it will be a serious problem. And, by the time it causes issues, you will be dead. ;-) MD5 sums can collide, as any hash algorithm can -- it's just very hard to deliberately construct two messages with the same signature that could possibly be mistaken for each other.

MD5 is not for establishing uniqueness, it's for signing data to validate that it has not changed since its first signing.

Anima Legato
.oO all things connect through the motion of the mind

The problem with the guaranteed version of Data::UUID is that you can't recreate the same UUID a second time. Which means that if you want the same file, you can't just create the Data::UUID to find out what directory it's in - you need to scan them. What is wanted here is a hashing algorithm - put in some piece of data (possibly including characters that cannot be represented on the filesystem), get a directory to store it in, and then be able to retrieve it when you pass in the same piece of data.

I actually have an implementation of this that is ready to go on CPAN ... as soon as my manager allows me to do so.

It's because I store "unique" files and the best way to ensure and quickly check that (without a db or additional db-file) is to simply save them with the checksum as the name.

As for the collission, I tought about that before. I think I'll add another checksum algo, SHA, to the name.
Using two independent algorithms should save me from any collission. Then it's more likely the whole building tunnels into another universe spontanously.


holli, /regexed monk/

In other words, you have a 128 bit number, and you want to represent it in base32.

my $binary_digest = ...;

my @digits = (0..9, 'A'..'V');
my $base32_digest = '';
for (0..3) { # 2^32^4 = 2^128
   $base32_digest = $digits[$binary_digest & 31]. $base32_digest;
   $binary_digest >>= 5;
}

print("$base32_digest\n");
[download]

Update: Strike that. You don't start with a 128 bit number, it wouldn't fit. I'd reengineer my solution, but I must leave. Good luck.