Converta o índice da coluna na letra da coluna correspondente

Preciso converter um índice de coluna da planilha do Google em seu valor de letra correspondente, por exemplo, em uma planilha:

Preciso fazer isso (essa função obviamente não existe, é um exemplo):

getColumnLetterByIndex(4);  // this should return "D"
getColumnLetterByIndex(1);  // this should return "A"
getColumnLetterByIndex(6);  // this should return "F"

Agora, não me lembro exatamente se o índice começa 0ou a partir 1, de qualquer maneira o conceito deve estar claro.

Não encontrei nada sobre isso na documentação do gás .. sou cego? Qualquer ideia?

Obrigado

Escrevi isso há algum tempo para vários fins (retornará os nomes das colunas com letras duplas para os números das colunas> 26):

function columnToLetter(column)
{
  var temp, letter = '';
  while (column > 0)
  {
    temp = (column - 1) % 26;
    letter = String.fromCharCode(temp + 65) + letter;
    column = (column - temp - 1) / 26;
  }
  return letter;
}

function letterToColumn(letter)
{
  var column = 0, length = letter.length;
  for (var i = 0; i < length; i++)
  {
    column += (letter.charCodeAt(i) - 64) * Math.pow(26, length - i - 1);
  }
  return column;
}

Isso funciona bem

=REGEXEXTRACT(ADDRESS(ROW(); COLUMN()); "[A-Z]+")

mesmo para colunas além de Z.

Basta substituir COLUMN()pelo número da coluna. O valor de ROW()não importa.

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

Isso pega sua célula, obtém seu endereço como, por exemplo, C1, e remove o "1".

Como funciona

• COLUMN() dá o número da coluna da célula.
• ADDRESS(1, ..., <format>)fornece o endereço de uma célula, no formato especificado por <format>parâmetro. 4significa que o endereço que você sabe - por exemplo C1.
  • A linha não importa aqui, então usamos 1.
  • Veja a ADDRESSdocumentação
• Finalmente, SUBSTITUTE(..., "1", "")substitui o 1no endereço C1, então você fica com a letra da coluna.

Isso funciona em intervalos A-Z

=char(64+column())

Não há necessidade de reinventar a roda aqui, use a linha GAS:

 var column_index = 1; // your column to resolve
 
 var ss = SpreadsheetApp.getActiveSpreadsheet();
 var sheet = ss.getSheets()[0];
 var range = sheet.getRange(1, column_index, 1, 1);

 Logger.log(range.getA1Notation().match(/([A-Z]+)/)[0]); // Logs "A"

Em javascript:

X = (n) => (a=Math.floor(n/26)) >= 0 ? X(a-1) + String.fromCharCode(65+(n%26)) : '';
console.assert (X(0) == 'A')
console.assert (X(25) == 'Z')
console.assert (X(26) == 'AA')
console.assert (X(51) == 'AZ')
console.assert (X(52) == 'BA')

Somando-se à resposta de @SauloAlessandre, isso funcionará para colunas acima de A-ZZ.

=if(column() >26,char(64+(column()-1)/26),) & char(65 + mod(column()-1,26))

Gosto das respostas de @wronex e @Ondra Žižka. No entanto, gosto muito da simplicidade da resposta de @SauloAlessandre.

Então, acabei de adicionar o código óbvio para permitir que a resposta de @SauloAlessandre funcione em planilhas mais amplas.

Como @Dave mencionou em seu comentário, é útil ter um background de programação, particularmente em C, onde adicionamos o valor hexadecimal de 'A' a um número para obter a enésima letra do alfabeto como um padrão padrão.

Resposta atualizada para detectar o erro apontado por @Sangbok Lee. Obrigado!

Eu também estava procurando por uma versão Python aqui que foi testada em Python 3.6

def columnToLetter(column):
    character = chr(ord('A') + column % 26)
    remainder = column // 26
    if column >= 26:
        return columnToLetter(remainder-1) + character
    else:
        return character

Estava procurando uma solução em PHP. Talvez isso ajude alguém.

<?php

$numberToLetter = function(int $number)
{
    if ($number <= 0) return null;

    $temp; $letter = '';
    while ($number > 0) {
        $temp = ($number - 1) % 26;
        $letter = chr($temp + 65) . $letter;
        $number = ($number - $temp - 1) / 26;
    }
    return $letter;
};

$letterToNumber = function(string $letters) {
    $letters = strtoupper($letters);
    $letters = preg_replace("/[^A-Z]/", '', $letters);

    $column = 0; 
    $length = strlen($letters);
    for ($i = 0; $i < $length; $i++) {
        $column += (ord($letters[$i]) - 64) * pow(26, $length - $i - 1);
    }
    return $column;
};

var_dump($numberToLetter(-1));
var_dump($numberToLetter(26));
var_dump($numberToLetter(27));
var_dump($numberToLetter(30));

var_dump($letterToNumber('-1A!'));
var_dump($letterToNumber('A'));
var_dump($letterToNumber('B'));
var_dump($letterToNumber('Y'));
var_dump($letterToNumber('Z'));
var_dump($letterToNumber('AA'));
var_dump($letterToNumber('AB'));

Resultado:

NULL
string(1) "Z"
string(2) "AA"
string(2) "AD"
int(1)
int(1)
int(2)
int(25)
int(26)
int(27)
int(28)

Um comentário em minha resposta diz que você queria uma função de script para ele. Tudo bem, vamos lá:

function excelize(colNum) {
    var order = 1, sub = 0, divTmp = colNum;
    do {
        divTmp -= order; sub += order; order *= 26;
        divTmp = (divTmp - (divTmp % 26)) / 26;
    } while(divTmp > 0);

    var symbols = "0123456789abcdefghijklmnopqrstuvwxyz";
    var tr = c => symbols[symbols.indexOf(c)+10];
    return Number(colNum-sub).toString(26).split('').map(c=>tr(c)).join('');
}

Isso pode lidar com qualquer número que JS pode lidar, eu acho.

Explicação:

Como não é a base 26, precisamos subtrair a ordem dos tempos base para cada símbolo adicional ("dígito"). Portanto, primeiro contamos a ordem do número resultante e, ao mesmo tempo, contamos o número a ser subtraído. E então nós o convertemos para a base 26 e subtraímos isso, e então mudamos os símbolos para em A-Zvez de0-P .

De qualquer forma, essa questão está se transformando em um golfe de código :)

Java Apache POI

String columnLetter = CellReference.convertNumToColString(columnNumber);

Isso o cobrirá até a coluna AZ:

=iferror(if(match(A2,$A$1:$AZ$1,0)<27,char(64+(match(A2,$A$1:$AZ$1,0))),concatenate("A",char(38+(match(A2,$A$1:$AZ$1,0))))),"No match")

Aqui está uma versão geral escrita em Scala. É para um índice de coluna começar em 0 (é simples de modificar para um índice que começa em 1):

def indexToColumnBase(n: Int, base: Int): String = {
  require(n >= 0, s"Index is non-negative, n = $n")
  require(2 <= base && base <= 26, s"Base in range 2...26, base = $base")

  def digitFromZeroToLetter(n: BigInt): String =
    ('A' + n.toInt).toChar.toString

  def digitFromOneToLetter(n: BigInt): String =
    ('A' - 1 + n.toInt).toChar.toString

  def lhsConvert(n: Int): String = {
    val q0: Int = n / base
    val r0: Int = n % base

    val q1 = if (r0 == 0) (n - base) / base else q0
    val r1 = if (r0 == 0) base else r0

    if (q1 == 0)
      digitFromOneToLetter(r1)
    else
      lhsConvert(q1) + digitFromOneToLetter(r1)
  }

  val q: Int = n / base
  val r: Int = n % base

  if (q == 0)
    digitFromZeroToLetter(r)
  else
    lhsConvert(q) + digitFromZeroToLetter(r)
}

def indexToColumnAtoZ(n: Int): String = {
  val AtoZBase = 26
  indexToColumnBase(n, AtoZBase)
}

Maneira simples por meio das funções do Google Sheet, de A a Z.

=column(B2) : value is 2
=address(1, column(B2)) : value is $B$1
=mid(address(1, column(B2)),2,1) : value is B

É uma maneira complicada de usar as funções do Planilhas Google, mas também é mais do que AA.

=mid(address(1, column(AB3)),2,len(address(1, column(AB3)))-3) : value is AB

Uma função para converter um índice de coluna em combinações de letras, recursivamente:

function lettersFromIndex(index, curResult, i) {

  if (i == undefined) i = 11; //enough for Number.MAX_SAFE_INTEGER
  if (curResult == undefined) curResult = "";

  var factor = Math.floor(index / Math.pow(26, i)); //for the order of magnitude 26^i

  if (factor > 0 && i > 0) {
    curResult += String.fromCharCode(64 + factor);
    curResult = lettersFromIndex(index - Math.pow(26, i) * factor, curResult, i - 1);

  } else if (factor == 0 && i > 0) {
    curResult = lettersFromIndex(index, curResult, i - 1);

  } else {
    curResult += String.fromCharCode(64 + index % 26);

  }
  return curResult;
}

function lettersFromIndex(index, curResult, i) {

  if (i == undefined) i = 11; //enough for Number.MAX_SAFE_INTEGER
  if (curResult == undefined) curResult = "";

  var factor = Math.floor(index / Math.pow(26, i));

  if (factor > 0 && i > 0) {
    curResult += String.fromCharCode(64 + factor);
    curResult = lettersFromIndex(index - Math.pow(26, i) * factor, curResult, i - 1);

  } else if (factor == 0 && i > 0) {
    curResult = lettersFromIndex(index, curResult, i - 1);

  } else {
    curResult += String.fromCharCode(64 + index % 26);

  }
  return curResult;
}

document.getElementById("result1").innerHTML = lettersFromIndex(32);
document.getElementById("result2").innerHTML = lettersFromIndex(6800);
document.getElementById("result3").innerHTML = lettersFromIndex(9007199254740991);

32 --> <span id="result1"></span><br> 6800 --> <span id="result2"></span><br> 9007199254740991 --> <span id="result3"></span>

Em python, existe a biblioteca gspread

import gspread
column_letter = gspread.utils.rowcol_to_a1(1, <put your col number here>)[:-1]

Se você não pode usar python, sugiro procurar o código-fonte de rowcol_to_a1 () em https://github.com/burnash/gspread/blob/master/gspread/utils.py

No PowerShell:

function convert-IndexToColumn
{
    Param
    (
        [Parameter(Mandatory)]
        [int]$col
    )
    "$(if($col -gt 26){[char][int][math]::Floor(64+($col-1)/26)})$([char](65 + (($col-1) % 26)))"
}

Esta é uma versão com índice zero (em Python):

letters = []
while column >= 0:
    letters.append(string.ascii_uppercase[column % 26])
    column = column // 26 - 1
return ''.join(reversed(letters))