Enumerar uma notação de célula

16

Esperamos que todos estejam familiarizados com a notação de célula da planilha 'A1'.

É simplesmente uma representação alfanumérica do posicionamento da referida célula dentro de uma grade. As letras representam o posicionamento da coluna da célula e o número representa a linha.

A parte 'letra' pode consistir em 1 ou mais letras do alfabeto inglês de 26 letras, todas as quais devem ser maiúsculas. Eles são mapeados para números através do uso de numeração bijetiva 26-adic. A parte 'number' pode consistir em qualquer número inteiro positivo diferente de zero.


O desafio, escreva um programa que, com a notação A1 de qualquer célula como uma única sequência, possa gerar uma sequência contendo a posição da coluna representada como um número, seguida por um espaço e depois pelo número da linha.

Exemplos de entradas / saídas abaixo:

A1
>>1 1
B10
>>2 10
AC4 
>>29 4
AAC753
>>705 753
F123
>>6 123
GL93
>>194 93

Este é o meu primeiro desafio, daí a relativa simplicidade e potencial falta de critério dos critérios.

EDIT : String deve ser letras seguidas de números e o critério vencedor é o menor tamanho de código (se isso pode ser uma coisa)

EDIT : relacionado a isso, mas faz o processo inverso com um índice inicial diferente. Alguns podem argumentar que esse fato torna o quebra-cabeça vinculado mais interessante.

dbr
fonte
Podemos considerar a entrada como, por exemplo, uma matriz contendo as letras e os números:["A", "1"]
Stephen
1
@StepHen Não. Deve ser uma única string contendo as letras e os números. Eu provavelmente deveria acrescentar, também, que a string DEVE estar na ordem das letras seguidas de números.
DBR
1
Nós geralmente permitem que formatos de entrada e saída mais flexíveis, tais como a escolha de nova linha em vez de espaço como separador de saída
Luis Mendo
3
@ DeanBrunt Depende de você e, é claro, você pode aplicar um formato estrito para tornar o desafio mais difícil. Mas as pessoas geralmente gostam de dificuldade nos cálculos reais mais do que no formato
Luis Mendo
4
É porque a formatação não acrescenta qualquer valor ao próprio desafio real
Adnan

Respostas:

20

Microsoft Excel, 43 bytes.

=COLUMN(INDIRECT(A1))&" "&ROW(INDIRECT(A1))

Não pude evitar, apenas tive que usar a ferramenta certa para o trabalho. Recebe entrada em A1.

Casos de teste

ATaco
fonte
11

Microsoft Excel, 40 bytes

Versão em português do Brasil.

=COL(INDIRETO(A1))&" "&LIN(INDIRETO(A1))

Versão traduzida (e, portanto, golfada) da solução da ATaco .

pajonk
fonte
Não me lembro se o Excel permite isso como folhas, mas você poderia usar a sugestão de @Uriel em outra resposta e perder os dois últimos parênteses?
DBR
Essa sugestão (omitindo parênteses à direita) lança um aviso no Excel que você precisa confirmar para continuar, então não acho que seja permitido aqui.
Pajonk
Ah entendo. É diferente das folhas então.
DBR
7

Python 2 , 94 91 73 bytes

-3 bytes graças a Jonathan Allan
-18 bytes graças a tsh

s=input().strip
a=s(`3**39`);t=0
for n in a:t=t*26+ord(n)-64
print t,s(a)

Experimente online!

Isso abusa da maneira como .stripfunciona, removendo todos os dígitos a=s(`3**39`)onde `3**39`há apenas uma maneira mais curta de gerar os dígitos de 0para 9, isso armazenará apenas os caracteres aque serão usados ​​para separar os caracteres dos números ems(a)

Cajado
fonte
Não acho que seja necessário que stripos dados sejam os caracteres únicos, portanto, 3**39devemos fazer o mesmo trabalho.
Jonathan Allan
1
73 bytes
tsh
6

Planilhas Google, 43 bytes

=COLUMN(INDIRECT(A1))&" "&ROW(INDIRECT(A1))

Experimente online!

A1é a célula de entrada. Espero que o link acima funcione, nunca tentei código de golfe com o Planilhas Google antes.

notjagan
fonte
1
@ ATaco Não há razão para isso, pois respostas duplicadas podem coexistir.
Conor O'Brien
1
A aparência das respostas do Planilhas Google e do Microsoft Excel me agrada.
DBR
5
você pode fazer =COLUMN(INDIRECT(A1))&" "&ROW(INDIRECT(A1por 41 bytes. folhas preenche a falta de parênteses à direita.
Uriel
5

JavaScript, 72 bytes

x=>x.replace(/\D+/,s=>[...s].reduce((n,v)=>n*26+parseInt(v,36)-9,0)+' ')
tsh
fonte
2

Próton , 113 bytes

k=>{b=(s=k.strip)('0123456789');str(sum(map((a=>26**a[1][0]*(ord(a[1][1])-64)),enumerate(b[to by-1]))))+' '+s(b)}

Experimente online!

-19 bytes emprestando o algoritmo de Rod ( note a self: add listcomps )

HyperNeutrino
fonte
2

Dyalog APL, 44 bytes

(26⊥¯65+⎕AV⍳(a~⎕D)),⎕A~⍨a←⍞

Experimente online!

bgiv
fonte
1
Remova os parênteses ao redor (a~⎕D). Procure em ⎕Avez de ⎕AV. Tornar tácito. Troque argumento de ,. Obtém apenas 16 bytes:~∘⎕A,⍨26⊥⎕A⍳~∘⎕D
Adám 22/08
1

Perl 5 , 35 + 1 (-p) = 36 bytes

map$r=$r*26-64+ord,/\D/g;s/\D*/$r /

Experimente online!

A mapinstrução trata a coluna como um número base26 e a converte em decimal. A substituição substitui as letras pelos números. A entrada e a saída estão implícitas no -psinalizador.

Xcali
fonte
1

Mathematica, 108 bytes

StringReplace[c:LetterCharacter..~~r:DigitCharacter..:>ToString@FromDigits[ToCharacterCode@c-64,26]<>" "<>r]

A forma de operador StringReplaceque pega a parte alfabética cda string, a converte em uma lista de códigos de caracteres, subtrai 64de cada ponto de código, interpreta o resultado como um 26número inteiro base , converte esse número inteiro em um espaço Stringe, em seguida, em StringJoinum espaço seguido pela parte numérica r.

Usando uma regex (também 108bytes):

StringReplace[RegularExpression["([A-Z]+)(.+)"]:>ToString@FromDigits[ToCharacterCode@"$1"-64,26]<>" "<>"$2"]
ngenisis
fonte
1
ToCharacterCode@c-64às vezes pode ser reduzido a LetterNumber@c. LetterNumbernão envolve a saída Listquando a entrada é um único caractere.
JungHwan Min 16/08/19
1

Geléia ,  16  15 bytes

ØAɓi@€ḟ0ḅ26,⁸Kḟ

Um programa completo que aceita a string como argumento e imprime o resultado

Experimente online!

Quão?

ØAɓi@€ḟ0ḅ26,⁸Kḟ - Main link: list of characters, ref  e.g. "AAC753"
ØA              - uppercase alphabet yield               = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  ɓ             - dyadic chain separation, call that B and place it on the right
   i@€          - first index for €ach (swap arguments)    [1,1,3,0,0,0]
      ḟ0        - filter discard zeros                     [1,1,3]
        ḅ26     - convert from base 26 to integer           705
            ⁸   - chain's left argument (ref)              "AAC753"
           ,    - pair                                     [705,['A','A','C','7','5','3']]
             K  - join with spaces                         [705,' ','A','A','C','7','5','3']
              ḟ - filter discard those in right (B)        [705,' ','7','5','3']
                - implicit print                        >>>705 753

Nota: a conversão de uma lista de números usando o átomo de conversão base permite que os lugares fiquem fora do intervalo esperado, portanto, a conversão de, digamos, [2,26,1]( "BZA") usando ḅ26é calculada como 2 × 26 2 + 26 × 26 1 + 1 × 26 0 = 2029, mesmo que a representação "esperada" tivesse sido [3,0,1].

Jonathan Allan
fonte
2
@ Dean Brunt Não é comum aceitar uma resposta tão rapidamente (a maioria deixa uma semana) - isso pode desencorajar outros de competir. Eu não ficaria surpreso de ver esta espancado por 05AB1E ou outra língua golfe ...
Jonathan Allan
Ponto tomado. Ainda aprendendo meu caminho de volta
dbr 16/08
Sem problemas! Bem-vindo ao PPCG, e bom primeiro post :)
Jonathan Allan
1

Mathematica, 77 72 69 68 bytes

#/.{a__,b__?DigitQ}:>{f=FromDigits;f[LetterNumber@{a},26],f[b<>""]}&

Leva uma lista de caracteres.

Experimente na Wolfram Sandbox

Uso

#/.{a__,b__?DigitQ}:>{f=FromDigits;f[LetterNumber@{a},26],f[b<>""]}&[{"G", "L", "9", "3"}]

{194, 93}

ou

#/.{a__,b__?DigitQ}:>{f=FromDigits;f[LetterNumber@{a},26],f[b<>""]}&[Characters["GL93"]]

{194, 93}

Explicação

#/.

Na entrada, substitua ...

{a__,b__?DigitQ}

Uma lista contendo duas seqüências aeb (com 1 ou mais elementos), onde bconsiste apenas em caracteres de dígito ... (o Mathematica usa correspondência lenta de padrões, portanto, nenhuma verificação é necessária a)

:>

para dentro...

f=FromDigits;

Conjunto f a função de conversão de dígito para inteiro.

LetterNumber@{a}

Converter a em números de letras (a -> 1, b -> 2, etc).

{f[ ... ,26],f[b<>""]}

Converta o acima de base-26 em decimal e converta bem decimal.

JungHwan Min
fonte
1

Haskell, 67 bytes

(\(l,n)->show(foldl(\a->(a*26-64+).fromEnum)0l)++" "++n).span(>'9')

Experimente online.

Cristian Lupascu
fonte
1

Retina , 85 bytes

[A-Z]
$& 
[T-Z]
2$&
[J-S]
1$&
T`_L`ddd
\d+
$*
{`\G1(?=.* .* )
26$*
}` (.* )
$1
1+
$.&

Experimente online! Explicação:

[A-Z]
$& 

Separe as letras uma da outra e o número final.

[T-Z]
2$&
[J-S]
1$&
T`_L`ddd

Converta as letras em decimal.

\d+
$*

Converta tudo em unário.

{`\G1(?=.* .* )
26$*
}` (.* )
$1

Embora haja pelo menos três números, multiplique o primeiro por 26 e adicione-o ao segundo.

1+
$.&

Converta tudo em decimal.

Neil
fonte
1

Ruby , 50 48 + 1 = 51 49 bytes

Usa a -pbandeira. -2 bytes de m-chrzan.

sub(/\D+/){i=0;$&.bytes{|b|i=26*i+b-64};"#{i} "}

Experimente online!

Value Ink
fonte
i=i*26+b-64economiza 2 bytes.
precisa saber é o seguinte
1

> <>, 42 bytes

0i88*-:0(?\$2d**+!
$n88*+48*o\
oi:0(?;   >

Experimente Online

Explicação:

0i88*-:0(?\$2d**+! Read in the Letters part of the input
0                  Push an initial 0 to the stack
 i                 Read a character of input
  88*-             Subtract 64 to get from the ascii code to its value ('A'=1,'B'=2 etc.)
      :0(?\        If the value is less than 0, break out of this loop
           $2d**   Multiply our accumulator by 26
                +  Add our new number to the accumulator
                 ! don't add a new zero to the stack

O loop acima lerá o primeiro número da parte dos números (por exemplo, '3' em "AB34") antes de quebrar e já terá subtraído 64 dele, portanto o próximo bit de código deve lidar com isso.

$n88*+48*o\        Output a space, and prepare to output the first number we read in during the previous loop
          \        Loop round to the left end of this line
$n                 Output the value of the letters part as a number
  88*+             Add the 64 we subtracted from the first number
      48*o         Output a space
          \        Enter the next loop

Esse loop inicia com a saída de um caractere que será o 1º caractere lido pelo primeiro loop ou o caractere lido pela iteração anterior desse loop.

oi:0(?;   >        Output the numbers part, by just echoing it
          >        Loop round to the start of the line
o                  Output the character
 i                 Read in the next character
  :0(?;            If the value read in was less than 0, terminate
Sasha
fonte
1

Ruby, 64 61 59 bytes

->s{s.sub(/\D+/){"#{$&.bytes.reduce(0){|t,b|t*26+b-64}} "}}

Economizou 2 bytes graças ao Value Ink.

m-chrzan
fonte
1
$&é a última correspondência de regex, portanto, use-a em vez de msalvar 2 bytes.
Value Ink
1

Janela imediata do Excel-VBA, 44 45 bytes ( 36 35)

Set v=Range([A1]):?trim(v.Column &" "&v.Row);

1 byte adicionado para suprimir a nova linha à direita


Ou para 35 com espaço em branco à esquerda

Set v=Range([A1]):?v.Column""&v.Row

1 byte salvo graças a @TaylorScott!

Ambos recebem entrada da célula A1, saída para a janela Imediata do VBE

Greedo
fonte
1
Vou seguir em frente e dizer que a resposta líder em espaço em branco é uma resposta válida, pois a remoção deve forçar o uso de Trim()quase todas as respostas numéricas - e, nesse caso, eu não usaria Set v=Range([A1]):?v.Column""&v.Rowsua solução atual
Taylor Scott
também, caramba, não acredito que perdi essa pergunta quando ela saiu!
Taylor Scott
@TaylorScott Oh, bom truque usando o "" - acho que o Excel sabe inserir ;quando o caractere a seguir Columnnão pode fazer parte do nome da rotina. Gostaria de saber se há um único personagem que poderia fazer a mesma coisa, provavelmente não. Sim, eu teria imaginado que o espaço inicial seria aceitável para a maioria dos qus, mas para este acho que é mais um "Imprima esta string exata ". Eu perguntei (último comentário sobre a pergunta) e não me disseram nenhum espaço à esquerda ou nova linha.
Greedo
1
Além disso, quando vi o título da pergunta, soube imediatamente que deveria tentar se você ou alguém já não o tivesse! Como as outras respostas baseadas no Excel dizem, a ferramenta certa para o trabalho .
Greedo
1

Lua, 127 bytes

Algumas boas manipulações de strings indo para lá, eu estou usando alguma função que geralmente nunca é usada durante o golfe na lua: D. A melhor maneira de jogar golfe seria encontrar uma outra maneira de iterar sobre a parte da coluna da entrada, mantendo a posição de cada letra. Eu não ^^ '.

Experimente online!

I=...l=I:gsub("%d",""):reverse()r=0
for i=1,#l
do
r=r+(l:sub(i,i):byte()-64)*math.pow(26,i-1)end
print(r.." "..I:gsub("%a",""))

Explicação

I=...                       -- shorthand for the input
l=I:gsub("%d","")           -- shorthand for the column part
   :reverse()               -- letters are put in reverse order to calculate their weight
r=0                         -- column number
for i=1,#l                  -- iterate over the letters of the input
do
  r=r+                      -- add to the column number
      (l:sub(i,i):byte()-64)-- the byte value of the current letter minus 64 (A=1 this way)
      *math.pow(26,i-1)     -- then apply its weight in base 26
end
print(r                     -- output the column number
        .." "               -- a space
        ..I:gsub("%a",""))  -- and the row number
Katenkyo
fonte