It might help to realize that the column name is essentially a base-26 number, using A as '0'. Then a div+mod loop while anything is left would only require building a 26 character alphabet. (for all I know, this could be how the XLS utils mentioned above handle it).

There are a couple of fencepost errors here. Fix coming shortly Ok, this is not quite a base-26 number. The least significant digit is treated slightly different than all other digits.

sub mlx_xls2col {
    my $col      = shift;
    my $alphabet = shift || [ 'A' .. 'Z' ];

    my $alphabet_size = scalar( @$alphabet );

    my $result    = '';
    my $remainder = $col;
    while ( $remainder ) {
        my $letter = $remainder % $alphabet_size;
        my $adj = length( $result ) ? -1 : 0;    # Not quite a base-26
+ number
        $result = $alphabet->[$letter + $adj] . $result;
        $remainder = int( $remainder / $alphabet_size );
    }
    $result ||= $alphabet->[0];

    $result;
}

print mlx_xls2col( 0 ), "\n";
print mlx_xls2col( 1 ), "\n";
print mlx_xls2col( 2 ), "\n";
print mlx_xls2col( 24 ), "\n";
print mlx_xls2col( 25 ), "\n";
print mlx_xls2col( 26 ), "\n";
print mlx_xls2col( 27 ), "\n";
print mlx_xls2col( 51 ), "\n";
print mlx_xls2col( 52 ), "\n";
print mlx_xls2col( 53 ), "\n";

__DATA__
A
B
C
Y
Z
AA
AB
AZ
BA
BB
[download]

Spreadsheet::ParseExcel::Utility has col2int and int2col and sheetRef, which convert between rownames and Perl indices, and the A1-notation.

Hi bulrush,

Here are a couple of tests, and just for fun my own (horribly inefficient, benchmark included) implementation using Perl's magic string increment:

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

sub excelpos2ltr { # by bulrush, https://perlmonks.pair.com/?node_id=1
+168549
    my($oldcol)=@_; # Col starts at 0='A'
    my($procname,$numeric,$ltr,$num2,$outs);
    $procname="excelpos2ltr";
    # Alt method 4.
    $numeric = $oldcol % 26;
    $ltr = chr(65 + $numeric);
    #$num2 = intval($oldcol / 26); # old line
    $num2 = int($oldcol / 26);
    if ($num2 > 0) {
        $outs=excelpos2ltr($num2 - 1) . $ltr;
    }
    else {
        $outs=$ltr;
    }
    return $outs;
}

sub colname {
    my $n = "A";
    $n++ for 1..shift;
    return $n;
}

my %tests = (
      0=>"A",    1=>"B",
     25=>"Z",   26=>"AA",
     27=>"AB",  99=>"CV",
    420=>"PE", 479=>"RL",
     14557=>"UMX",
    285075=>"PERL",
);

use Test::More;
plan tests => 2 * scalar keys %tests;
is excelpos2ltr($_), $tests{$_}, "excelpos2ltr $_ => $tests{$_}"
    for sort {$a<=>$b} keys %tests;
is colname($_), $tests{$_}, "colname $_ => $tests{$_}"
    for sort {$a<=>$b} keys %tests;
done_testing;

use Benchmark 'cmpthese';
cmpthese(-5, {
    # not neccesarily a fair benchmark due to random test data
    excelpos2ltr => sub { excelpos2ltr(rand(10000)) },
    colname => sub { colname(rand(10000)) },
});
[download]

Regards,
-- Hauke D

What's the maximum for column numbers? A simple routine for up to three letters:

sub ltr { ("A".."ZZZ")[@_] }

print ltr(26);
[download]

Simple and elegant given that Excel has a max column of "XFD". I'd modify this to cache the column names and throw a fit if we go too far (eventually, the column cap will be increased or removed):

sub ltr_cached {
    state $ltr_cache = ["A".."ZZZ"];
    return ($$ltr_cache[$_[0]] or die "column too big: $_[0]")
}
[download]

Good Day,
    Dean

For simplicity and perlness points, an extra ++ to this one... :-)

Running haukex's test-and-benchmark with AM's ltr() included (without 285075=>'PERL' in the test list), ltr() appears about 10x more efficient than colname(). A four-Z-based ltr(), however, is about 75% less efficient than colname().

Excel 2007 upped the limit from 2-letter/256-column to 3-letter/16384-column, and that hasn't changed as of Excel 2016, so the more-efficient ZZZ-based ltr() is sufficient for now. :-)

Although it's not zero based, I've been using Number::Latin to convert between column numbers and names. And it's not too difficult to modify input/output of its functions to use zero based numbering scheme for the columns.