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.

05AB1E , 12 11 bytes

áÇ64-₂βð¹þJ

Usa a codificação 05AB1E . Experimente online!

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

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 .

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)

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.

JavaScript, 72 bytes

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

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 )

Dyalog APL, 44 bytes

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

Experimente online!

Pitão - 31 bytes

Primeira tentativa, muito ingênua.

jd,s*V.u*26NQ1_hMxLGr-QK@`UTQZK

Experimente online aqui .

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.

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"]

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 ² + 26 × 26 ¹ + 1 × 26 ⁰ = 2029, mesmo que a representação "esperada" tivesse sido [3,0,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.

Haskell, 67 bytes

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

Experimente online.

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.

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!

> <>, 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

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.

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

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