Celui-ci vient d'un problème réel. Nous l'avons résolu, bien sûr, mais il semble toujours que cela aurait pu être mieux fait, que c'est une solution trop longue et détournée. Cependant, aucun de mes collègues ne peut penser à une manière plus succincte de l'écrire. Je le présente donc comme du code-golf.

Le but est de convertir un entier non négatif en une chaîne de la même manière qu'Excel présente ses en-têtes de colonne. Donc:

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

Il doit fonctionner au moins jusqu'à 16 383, mais au-delà est également acceptable (pas de points bonus cependant). J'attends le plus avec impatience la solution C #, mais, selon les traditions du code-golf, tout véritable langage de programmation est le bienvenu.

Perl 6 ,16 14 octets

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

Fonctionne même au-delà de XFD. Grâce aux listes infinies de Perl 6, cela ne prend pas une éternité (et demie) à s'exécuter.

Essayez-le en ligne!

Formule Excel :), 36 caractères

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

Usage:

Désolé, je n'ai pas pu résister ...

Perl, 17 caractères

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

L' ..opérateur fait la même chose que l'auto-incrémentation magique, mais sans avoir besoin de la variable temporaire et de la boucle. Sauf si strict subsc'est dans la portée, les mots nus Aet XFDsont interprétés comme des chaînes.

( Cette réponse a été suggérée par un utilisateur anonyme en tant que modification d' une réponse existante . Je pensais qu'elle méritait d'être une réponse distincte, et je l'ai faite. Puisqu'il ne serait pas juste pour moi d'en gagner la réputation, je ' ve l'ont fait Wiki communautaire. )

C, 53 caractères

C'est comme jouer au golf avec un marteau ...

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

Version normale:

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

Et l'usage est comme ça:

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

Haskell, 48

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

Moins golfé:

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

Explication

Le sequencecombinateur de Haskell prend une liste d'actions et les exécute, renvoyant le résultat de chaque action dans une liste. Par exemple:

sequence [getChar, getChar, getChar]

est équivalent à:

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

Dans Haskell, les actions sont traitées comme des valeurs et sont collées ensemble à l'aide de >>=(bind) et des returnprimitives. Tout type peut être une "action" s'il implémente ces opérateurs en ayant une instance Monad .

Par ailleurs, le type de liste a une instance de monade. Par exemple:

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

C'est égal [(1,4),(1,5),(1,6),(2,4),(2,5),(2,6),(3,4),(3,5),(3,6)]. Remarquez comment la compréhension de la liste est étonnamment similaire:

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

Les listes étant un type "d'action", nous pouvons les utiliser sequenceavec des listes. Ce qui précède peut être exprimé comme suit:

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

Ainsi, sequencenous donne des combinaisons gratuitement!

Ainsi, pour construire la liste:

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

J'ai juste besoin de construire des listes pour passer à sequence

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

Ensuite, utilisez concatMappour appliquer les deux aux sequencelistes et concaténer les listes résultantes. Par coïncidence, concatMapc'est la =<<fonction pour les listes, donc la monade de liste me permet de raser quelques caractères ici aussi.

Perl, 26 caractères

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

Ruby, 35 caractères

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

Usage:

puts e[16383]   # XFD

Remarque: Il existe également une version plus courte (30 caractères) utilisant la récursivité.

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

Mais en utilisant cette fonction, vous devrez peut-être augmenter la taille de la pile pour les grands nombres en fonction de votre interprète 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 caractères

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

Usage:

println(f(16383))

Retour:

XFD

Vous pouvez l'essayer sur Simply scala . Copiez et collez la fonction et utilisez f(some integer)pour voir le résultat.

Excel VBA, 31 octets

Fonction de fenêtre immédiate VBE anonyme qui prend les entrées de la cellule [A1]et les sorties vers la fenêtre immédiate VBE

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

JavaScript (Node.js) , 50 octets

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

Essayez-le en ligne!

Voyant que beaucoup de gens ont commencé à répondre à cela, j'ai répondu aussi.

Remarque :

Il s'agit essentiellement d'une arnaque de la réponse de @ kevinCruijssen en Java raccourcie grâce à JS.

PHP, 30 octets

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

Exécutez en tant que pipe avec `-nr 'ou essayez-le en ligne .

VBA / VB6 / VBScript (non Excel), 73 octets

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

L'appel s(16383)reviendra XFC.

Javascript, 147 octets

J'avais un problème similaire. C'est le golf de la solution. Les colonnes Excel sont bijectives base-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))}

Développé, sauf en utilisant des indices 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 octets (récursif)

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

Essayez-le en ligne.

Explication:

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 octets (itératif)

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

Essayez-le en ligne.

Explication:

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

Forth (gforth) , 59 octets

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

Essayez-le en ligne!

Explication

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 octets

Réponse récursive comme le sont de nombreuses réponses précédentes.

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

Essayez-le en ligne!

Powershell, 68 octets

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

Version récursive alternative, 68 octets:

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

Script de test:

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

Production:

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

Remarque: Powershell ne fournit pas d' divopérateur.

Haskell, 48

Je pensais vraiment que je pourrais battre l'autre entrée de Haskell, mais hélas ...

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

Je suis certain qu'il est possible de raser quelques personnages, mais je n'ai pas codé en Haskell depuis près d'un an, donc je suis assez rouillé.

Ce n'est pas exactement ce que vous appelleriez élégant.

Jq 1,5 , 71 octets

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

Attend une entrée N. par exemple

def N:16383;

Étendu:

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

Essayez-le en ligne!

> <> , 29 octets

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

Essayez-le en ligne!

Icône , 58 octets

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

Essayez-le en ligne!