这是一个现实生活中的问题。当然，我们已经解决了它，但是它总是觉得它本可以做得更好，因为它太冗长和round回。但是，我的同事们都没有想到更简洁的编写方式。因此，我将其表示为代码高尔夫球。

目标是将非负整数转换为字符串，这与Excel呈现其列标题的方式相同。从而：

0 -> A
1 -> B
...
25 -> Z
26 -> AA
27 -> AB
...
51 -> AZ
52 -> BA
...
16,383 -> XFD

它必须至少工作到16,383，但是也可以接受（尽管没有奖励积分）。我最期待C＃解决方案，但是，按照代码高尔夫球的传统，任何实际的编程语言都是受欢迎的。

Perl 6，16 14字节

{("A"..*)[$_]}

即使在XFD上也可以使用。多亏了Perl 6中的无限列表，这并不需要永远（一半）来执行。

在线尝试！

Excel公式：），36个字符

=SUBSTITUTE(ADDRESS(1,A1,4),"1","")

用法：

对不起，无法抗拒...

Perl，17个字符

say[A..XFD]->[<>]

..运算符执行与神奇的自动递增相同的操作，但不需要临时变量和循环。除非strict subs在范围内，否则将裸词A和XFD解释为字符串。

（此答案是由匿名用户建议的，是对现有答案的修改。我认为应该将其作为一个单独的答案，并且已经做了一个答案。由于从中获得代表对我来说不公平，因此，我已使其成为Community Wiki。）

C，53个字符

就像用锤子打高尔夫球...

char b[4],*p=b+3;f(i){i<0||(*--p=i%26+65,f(i/26-1));}

普通版：

char b[4];
char *p = b+3;
void f(int i) {
    if (i >= 0) {
        --p;
        *p = i%26 + 65;
        f(i/26-1);
    }
}

用法是这样的：

int main(int argc, char *argv[])
{
    f(atoi(argv[1]));
    printf("%s\n", p);
    return 0;
}

哈斯克尔，48岁

f=(!!)(sequence=<<(tail$iterate(['A'..'Z']:)[]))

少打高尔夫球：

f n = (concatMap sequence $ tail $ iterate (['A'..'Z'] :) []) !! n

说明

Haskell的sequence组合器获取动作列表并执行它们，并在列表中返回每个动作的结果。例如：

sequence [getChar, getChar, getChar]

等效于：

do
    a <- getChar
    b <- getChar
    c <- getChar
    return [a,b,c]

在Haskell中，将动作视为值，并使用>>=（绑定）和return原语将动作粘合在一起。如果任何类型通过拥有Monad实例来实现这些运算符，则可以是“操作” 。

顺便说一句，列表类型具有monad实例。例如：

do
    a <- [1,2,3]
    b <- [4,5,6]
    return (a,b)

这等于[(1,4),(1,5),(1,6),(2,4),(2,5),(2,6),(3,4),(3,5),(3,6)]。请注意，列表理解非常相似：

[(a,b) | a <- [1,2,3], b <- [4,5,6]]

由于列表是一种“动作”，因此我们可以将其sequence与列表一起使用。以上可以表示为：

sequence [[1,2,3],[4,5,6]]

因此，sequence免费为我们提供组合！

因此，要构建列表：

["A","B"..."Z","AA","AB"]

我只需要建立要传递的清单 sequence

[['A'..'Z'],['A'..'Z','A'..'Z'],...]

然后使用concatMap既应用sequence到列表，又连接结果列表。巧合的concatMap是=<<列表的功能，因此list monad也让我在这里剃了几个字符。

Perl，26个字符

$x='A';map$x++,1..<>;say$x

Ruby，35个字符

e=->n{a=?A;n.times{a.next!};a}

用法：

puts e[16383]   # XFD

注意：还有一个使用递归的较短版本（30个字符）。

    e=->n{n<1??A:e[n-1].next}

但是，使用此功能时，可能需要增加大量堆栈的大小，具体取决于您的ruby解释器。

Groovy，47岁

m={it<0?'':m(((int)it/26)-1)+('A'..'Z')[it%26]}

[0:'A',1:'B',25:'Z',
        26:'AA',
        27:'AB',
        51:'AZ',
        52:'BA',
        16383:'XFD'].collect {k,v-> assert v == m(k);m(k) }

Python 45 51

f=lambda i:i>=0and f(i/26-1)+chr(65+i%26)or''

Scala，62个字符

def f(i:Int):String=if(i<0)""else f((i/26)-1)+(i%26+65).toChar

用法：

println(f(16383))

返回：

XFD

您可以在Simply scala上尝试。复制并粘贴该函数并用于f(some integer)查看结果。

Excel VBA，31字节

匿名VBE立即窗口功能，它从单元格获取输入[A1]并输出到VBE立即窗口

?Replace([Address(1,A1,4)],1,"")

JavaScript（Node.js），50字节

f=_=>_<0?'':f(_/26-1)+String.fromCharCode(_%26+65)

在线尝试！

看到很多人开始回答这个问题，我也回答了。

注意 ：

这基本上是@kevinCruijssen在Java中的答案的简化，这要归功于JS。

PHP，30个字节

for($c=A;$argn--;)$c++;echo$c;

与`-nr'作为管道运行或在线尝试。

VBA / VB6 / VBScript（非Excel），73个字节

Function s(i):While i:i=i-1:s=Chr(i Mod 26+65)&s:i=i\26:Wend:End Function

呼叫s(16383)将返回XFC。

Javascript，147个字节

我有一个类似的问题。这就是解决方案。Excel列是双射基数26。

n=>{f=Math.floor;m=Math.max;x=m(0,f((n-24)/676));y=m(0,f(n/26-x*26));return String.fromCharCode(...[x,y,n+1-x*676-y*26].filter(d=>d).map(d=>d+64))}

扩展，但使用1索引除外：

function getColName(colNum){ // example: 16384 => "XFD"
    let mostSig = Math.max(0, Math.floor((colNum - 26 - 1)/26**2));
    let midSig = Math.max(0, Math.floor((colNum - mostSig*26**2 - 1)/26));
    let leastSig = colNum - mostSig*26**2 - midSig*26;

    return String.fromCharCode(...[mostSig,midSig,leastSig].filter(d=>d).map(d=>d+64));
}

Java，57个字节（递归）

String f(int n){return n<0?"":f(n/26-1)+(char)(n%26+65);}

在线尝试。

说明：

String f(int n){        // Recursive method with integer parameter and String return-type
  return n<0?           //  If `n` is negative:
    ""                  //   Return an empty String
   :                    //  Else:
    f(n/26-1)           //   Recursive call with `n` integer-divided by 26, minus 1
    +(char)(n%26+65);}  //   And append `n%26+65` as character

Java 10，62个字节（迭代）

n->{var r="";for(;n>=0;n=n/26-1)r=(char)(n%26+65)+r;return r;}

在线尝试。

说明：

n->{                      // Method with integer parameter and String return-type
  var r="";               //  Result-String, starting empty
  for(;n>=0;              //  Loop as long as `n` is not negative
      n=n/26-1)           //    After every iteration: divide `n` by 26, and subtract 1
    r=(char)(n%26+65)+r;  //   Prepend `n%26+65` as character to the result-String
  return r;}              //  Return the result-String

第四（gforth），59字节

: f dup 0< if drop else 26 /mod 1- recurse 65 + emit then ;

在线尝试！

说明

dup 0<            \ duplicate the top of the stack and check if negative
if drop           \ if negative, drop the top of the stack
else              \ otherwise
   26 /mod        \ divide by 26 and get the quotient and remainder
   1- recurse     \ subtract one from quotient and recurse on result
   65 + emit      \ add 65 to remainder and output ascii char
then              \ exit if statement

R，65个字节

递归答案和许多以前的答案一样。

function(n,u=LETTERS[n%%26+1])"if"(n<=25,u,paste0(g(n%/%26-1),u))

在线尝试！

Powershell，68个字节

param($n)for(;$n-ge0;$n=($n-$r)/26-1){$s=[char](($r=$n%26)+65)+$s}$s

备用递归版本，68字节：

filter g{if($_-ge0){(($_-($r=$_%26))/26-1|f)+[char]($r+65)}else{''}}

测试脚本：

$f = {

param($n)for(;$n-ge0;$n=($n-$r)/26-1){$s=[char](($r=$n%26)+65)+$s}$s

}

filter g{if($_-ge0){(($_-($r=$_%26))/26-1|f)+[char]($r+65)}else{''}}


@(
    ,(0 , "A")
    ,(1 , "B")
    ,(25 , "Z")
    ,(26 , "AA")
    ,(27 , "AB")
    ,(51 , "AZ")
    ,(52 , "BA")
    ,(676 , "ZA")
    ,(702 , "AAA")
    ,(16383 , "XFD")
) | % {
    $n, $expected = $_
    $result = &$f $n
    # $result = $n|g      # Alternative
    "$($result-eq$expected): $result"
}

输出：

True: A
True: B
True: Z
True: AA
True: AB
True: AZ
True: BA
True: ZA
True: AAA
True: XFD

注意：Powershell不提供div操作员。

哈斯克尔，48岁

我真的以为我可以击败其他Haskell参赛者，但是a ...

f(-1)=""
f n=f(div n 26-1)++[toEnum$mod n 26+65]

我敢肯定可以剃掉几个字符，但是我已经有将近一年没有用Haskell编码了，所以我很生锈。

这并不是您所说的优雅。

jQuery 1.5，71个字节

[range(1;4)as$l|[65+range(26)]|implode/""|combinations($l)]|map(add)[N]

期望输入N。例如

def N:16383;

展开：

[                       # create array with
   range(1;4) as $l     #  for each length 1,2,3
 | [65+range(26)]       #   list of ordinal values A-Z
 | implode/""           #   converted to list of strings ["A", "B", ...]
 | combinations($l)     #   generate combinations of length $l
]
| map(add)[N]           # return specified element as a string

在线尝试！

> <>，29个字节

!v:2d*%:"A"+@-2d*,1-:0(?!
$<o

在线尝试！

图标，58字节

procedure f(n);return(n<0&"")|f(n/26-1)||char(65+n%26);end

在线尝试！