Por lo tanto, todos estamos familiarizados con la notación de celda de hoja de cálculo 'A1'.

Es simplemente una representación alfanumérica del posicionamiento de dicha celda dentro de una cuadrícula. Las letras representan la posición de la columna de la celda y el número representa la fila.

La parte 'letra' puede constar de 1 o más letras del alfabeto inglés de 26 letras, todas las cuales deben ser letras mayúsculas. Estos se asignan a números mediante el uso de la numeración biyectiva de 26 adic. La parte 'número' puede consistir en cualquier número entero positivo que no sea cero.

El desafío, escribir un programa que, dada la notación A1 de cualquier celda como una sola cadena, pueda generar una cadena que contenga la posición de la columna representada como un número, seguido de un espacio y luego el número de la fila.

Muestra de entradas / salidas a continuación:

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

Este es mi primer desafío, de ahí la relativa simplicidad y potencial debilidad de los criterios.

EDITAR : la cadena debe ser letras seguidas de números y el criterio ganador es la longitud de código más corta (si eso puede ser algo)

EDITAR : relacionado con esto, pero realiza el proceso inverso con un índice de inicio diferente. Algunos pueden argumentar que este hecho hace que el rompecabezas vinculado sea más interesante.

05AB1E , 12 11 bytes

áÇ64-₂βð¹þJ

Utiliza la codificación 05AB1E . Pruébalo en línea!

Microsoft Excel, 43 Bytes.

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

No pude evitarlo, solo tuve que usar la herramienta adecuada para el trabajo. Toma entrada en A1.

Casos de prueba

Microsoft Excel, 40 bytes

Versión en portugués brasileño.

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

Versión traducida (y por lo tanto golfizada) de la solución de ATaco .

Python 2 , 94 91 73 bytes

^{-3 bytes gracias a Jonathan Allan
-18 bytes gracias 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)

Pruébalo en línea!

Este abusos la forma en que .stripfunciona, la eliminación de todos los dígitos Wtih a=s(`3**39`)donde `3**39`es sólo un camino más corto para generar los dígitos de 0a 9, esto va a almacenar sólo los caracteres en aque se utilizarán para despojar a los caracteres de los números ens(a)

Hojas de cálculo de Google, 43 bytes

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

Pruébalo en línea!

A1es la celda de entrada. Espero que el enlace anterior funcione, nunca antes había probado el golf de código con Google Sheets.

JavaScript, 72 bytes

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

Protón , 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)}

Pruébalo en línea!

-19 bytes tomando prestado el algoritmo de Rod ( nota para sí mismo: agregar listcomps )

Dyalog APL, 44 bytes

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

Pruébalo en línea!

Pyth - 31 bytes

Primer intento, muy ingenuo.

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

Pruébelo en línea aquí .

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

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

Pruébalo en línea!

La mapdeclaración trata la columna como un número base26 y la convierte a decimal. La sustitución reemplaza las letras con los números. La entrada y la salida están implícitas en la -pbandera.

Mathematica, 108 bytes

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

La forma del operador StringReplacetoma la parte alfabética cde la cadena, la convierte en una lista de códigos de caracteres, resta 64de cada punto de código, interpreta el resultado como un 26entero base , convierte ese entero en a String, luego en StringJoinun espacio seguido de la parte numérica r.

Usando una expresión regular (también 108bytes):

StringReplace[RegularExpression["([A-Z]+)(.+)"]:>ToString@FromDigits[ToCharacterCode@"$1"-64,26]<>" "<>"$2"]

Jalea ,  16  15 bytes

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

Un programa completo que acepta la cadena como argumento e imprime el resultado.

Pruébalo en línea!

¿Cómo?

Ø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: la conversión de una lista de números usando el átomo de conversión base ḅpermite que los lugares estén fuera del rango esperado, por lo que la conversión de, digamos, [2,26,1]("BZA" ) usando ḅ26se calcula como 2 × 26 ² + 26 × 26 ¹ + 1 × 26 ⁰ = 2029 a pesar de que la representación "esperada" hubiera sido [3,0,1].

Mathematica, 77 72 69 68 bytes

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

Toma una lista de personajes.

Pruébalo en Wolfram Sandbox

Uso

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

{194, 93}

o

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

{194, 93}

Explicación

#/.

En la entrada reemplazar ...

{a__,b__?DigitQ}

Una lista que contiene dos secuencias ay b(con 1 o más elementos), donde bconsta solo de caracteres de dígitos ... (Mathematica utiliza la coincidencia de patrones diferidos, por lo que no se requiere verificación a)

:>

dentro...

f=FromDigits;

Establecer fen la función de conversión de dígito a entero.

LetterNumber@{a}

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

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

Convierta lo anterior de base-26 a decimal, y convierta ba decimal.

Haskell, 67 bytes

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

Pruébalo en línea.

Retina , 85 bytes

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

Pruébalo en línea! Explicación:

[A-Z]
$& 

Separe las letras entre sí y el número final.

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

Convierte las letras a decimal.

\d+
$*

Convierte todo a unario.

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

Si bien hay al menos tres números, multiplique el primero por 26 y agréguelo al segundo.

1+
$.&

Convierte todo a decimal.

Rubí , 50 48 + 1 = 51 49 bytes

Usa la -pbandera. -2 bytes de m-chrzan.

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

Pruébalo en línea!

> <>, 42 bytes

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

Pruébalo en línea

Explicación:

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

El bucle anterior se leerá en el primer número de la parte de números (por ejemplo, '3' en "AB34") antes de romperse, y ya habrá restado 64 de él, por lo que el siguiente fragmento de código tiene que lidiar con eso

$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

Este ciclo comienza generando un carácter que será el primer carácter leído por el primer ciclo o el carácter leído por la iteración anterior de este ciclo.

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

Ahorró 2 bytes gracias a Value Ink.

Ventana de Excel-VBA Inmediato, 44 45 Bytes ( 36 35)

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

1 byte agregado para suprimir la nueva línea final

O para 35 con espacios en blanco líderes

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

¡1 byte guardado gracias a @TaylorScott!

Ambos toman la entrada de la celda A1, salida a la ventana VBE Inmediato

Lua, 127 bytes

Algunas buenas manipulaciones de cuerdas van allí, estoy usando alguna función que generalmente nunca se usa mientras se juega al golf en lua: D. La mejor manera de jugar al golf sería encontrar otra forma de iterar sobre la parte de la columna de la entrada mientras se puede retener la posición de cada letra. Yo no ^^ '.

Pruébalo en línea!

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

Explicación

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