Dieser kommt von einem realen Problem. Wir haben es natürlich gelöst, aber wir haben immer das Gefühl, es hätte besser gemacht werden können, dass es zu langwierig und umständlich ist. Allerdings kann sich keiner meiner Kollegen eine prägnantere Schreibweise vorstellen. Daher präsentiere ich es als Code-Golf.

Das Ziel ist es, eine nichtnegative Ganzzahl in eine Zeichenfolge zu konvertieren, so wie Excel die Spaltenüberschriften darstellt. Somit:

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

Es muss mindestens bis zu 16.383 funktionieren, aber darüber hinaus ist es auch akzeptabel (aber keine Bonuspunkte). Ich freue mich am meisten auf die C # -Lösung, aber gemäß den Traditionen von Code-Golf ist jede echte Programmiersprache willkommen.

Perl 6 ,16 14 Bytes

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

Funktioniert auch über XFD hinaus. Dank der unendlichen Listen in Perl 6 dauert die Ausführung nicht ewig (anderthalb).

Probieren Sie es online!

Excel Formula :), 36 Zeichen

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

Verwendung:

Entschuldigung, konnte nicht widerstehen ...

Perl, 17 Zeichen

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

Der ..Operator macht dasselbe wie das magische automatische Inkrementieren, benötigt jedoch keine temporäre Variable und Schleife. Es sei denn , strict subsin Rahmen ist, die Barewords Aund XFDwerden als Strings interpretiert.

( Diese Antwort wurde vorgeschlagen , von einem anonymen Benutzer als Bearbeitung auf einer bestehenden Antwort . Ich fühlte es verdient eine gesonderte Antwort zu sein, und haben es zu einem gemacht. Da es nicht fair wäre für mich rep zu gewinnen aus, ich‘ habe es zum Community Wiki gemacht. )

C, 53 Zeichen

Es ist, als würde man mit einem Hammer Golf spielen ...

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

Normale Version:

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

Und die Verwendung ist wie folgt:

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

Haskell, 48

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

Weniger golfen:

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

Erläuterung

Der sequenceKombinator von Haskell führt eine Liste von Aktionen durch und gibt das Ergebnis jeder Aktion in einer Liste zurück. Beispielsweise:

sequence [getChar, getChar, getChar]

ist äquivalent zu:

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

In Haskell werden Aktionen wie Werte behandelt und unter Verwendung von >>=(Binden) und returnPrimitiven zusammengeklebt. Jeder Typ kann eine "Aktion" sein, wenn er diese Operatoren durch eine Monade implementiert Instanz .

Übrigens hat der Listentyp eine Monadeninstanz. Beispielsweise:

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

Das ist gleich [(1,4),(1,5),(1,6),(2,4),(2,5),(2,6),(3,4),(3,5),(3,6)]. Beachten Sie, dass das Listenverständnis auffällig ähnlich ist:

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

Da Listen eine Art "Aktion" sind, können wir sie sequencemit Listen verwenden. Das Obige kann ausgedrückt werden als:

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

Somit, sequence gibt uns Kombinationen kostenlos!

So erstellen Sie die Liste:

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

Ich muss nur Listen erstellen, an die ich übergebe sequence

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

Verwenden Sie dann, concatMapum beide sequenceauf die Listen anzuwenden und die resultierenden Listen zu verketten. Zufälligerweise concatMapist dies die =<<Funktion für Listen. Mit der Listenmonade kann ich auch hier einige Zeichen rasieren.

Perl, 26 Zeichen

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

Ruby, 35 Zeichen

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

Verwendung:

puts e[16383]   # XFD

Hinweis: Es gibt auch eine kürzere Version (30 Zeichen) mit Rekursion.

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

Bei Verwendung dieser Funktion müssen Sie möglicherweise die Stapelgröße für große Zahlen erhöhen, abhängig von Ihrem Ruby-Interpreter.

Groovy, 47 Jahre alt

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 Zeichen

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

Verwendung:

println(f(16383))

kehrt zurück:

XFD

Sie können dies mit Simply Scala ausprobieren . Kopieren Sie die Funktion, fügen Sie sie ein und verwenden Sie f(some integer), um das Ergebnis anzuzeigen.

Excel VBA, 31 Bytes

Anonyme VBE-Direktfensterfunktion, die Eingaben von der Zelle [A1]und Ausgaben in das VBE-Direktfenster übernimmt

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

JavaScript (Node.js) , 50 Byte

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

Probieren Sie es online!

Als ich sah, dass viele Leute anfingen, darauf zu antworten, antwortete ich auch.

Hinweis :

Dies ist im Grunde eine Abzocke der Antwort von @ kevinCruijssen in Java, die dank JS verkürzt wurde.

PHP, 30 Bytes

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

Führe es als Pipe mit -nr aus oder versuche es online .

VBA / VB6 / VBScript (nicht Excel), 73 Byte

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

Der Anruf s(16383)wird zurückgegeben XFC.

Javascript, 147 Bytes

Ich hatte ein ähnliches Problem. Das ist der Golf der Lösung. Excel-Spalten sind bijektive Basis 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))}

Erweitert, außer bei Verwendung von 1-Indizes:

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 Bytes (rekursiv)

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

Probieren Sie es online aus.

Erläuterung:

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 Bytes (iterativ)

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

Probieren Sie es online aus.

Erläuterung:

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

Viertens (gviertens) , 59 Bytes

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

Probieren Sie es online!

Erläuterung

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 Bytes

Rekursive Antwort wie viele frühere Antworten.

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

Probieren Sie es online!

Powershell, 68 Bytes

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

Alternative rekursive Version, 68 Bytes:

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

Testskript:

$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"
}

Ausgabe:

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

Hinweis: Powershell bietet keinen divOperator.

Haskell, 48

Ich dachte wirklich, dass ich den anderen Haskell-Eintrag schlagen könnte, aber leider ...

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

Ich bin mir sicher, dass es möglich ist, ein paar Charaktere davon abzuhalten, aber ich habe fast ein Jahr lang nicht in Haskell codiert, also bin ich ziemlich rostig.

Es ist nicht genau das, was Sie als elegant bezeichnen würden.

Jq 1,5 , 71 Bytes

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

Erwartet Eingaben in N. z.B

def N:16383;

Erweitert:

[                       # 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

Probieren Sie es online!

> <> 29 Bytes

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

Probieren Sie es online!

Icon , 58 Bytes

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

Probieren Sie es online!