Quindi speriamo tutti di avere familiarità con la notazione di cella "A1" del foglio di calcolo.

È semplicemente una rappresentazione alfanumerica del posizionamento di detta cella all'interno di una griglia. Le lettere rappresentano il posizionamento della colonna della cella e il numero rappresenta la riga.

La parte "lettera" può consistere in 1 o più lettere dell'alfabeto inglese di 26 lettere, che devono essere tutte in maiuscolo. Questi si associano ai numeri mediante l'uso della numerazione biiettiva 26-adica. La parte 'numero' può essere composta da qualsiasi numero intero positivo, diverso da zero.

La sfida, scrivere un programma che ha dato la notazione A1 di qualsiasi cella come una singola stringa, può produrre una stringa contenente la posizione della colonna rappresentata come un numero, seguita da uno spazio e quindi dal numero di riga.

Esempi di input / output di seguito:

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

Questa è la mia prima sfida, quindi la relativa semplicità e potenziale povertà dei criteri.

EDIT : la stringa deve essere composta da lettere seguite da numeri e il criterio vincente è la lunghezza del codice più breve (se può essere una cosa)

EDIT : correlati a questo, ma fa il processo inverso con un indice iniziale diverso. Alcuni potrebbero sostenere che questo fatto renda il puzzle collegato più interessante.

05AB1E , 12 11 byte

áÇ64-₂βð¹þJ

Utilizza la codifica 05AB1E . Provalo online!

Microsoft Excel, 43 byte.

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

Non potevo fare a meno di me stesso, dovevo solo usare lo strumento giusto per il lavoro. Accetta input su A1.

Casi test

Microsoft Excel, 40 byte

Versione in portoghese brasiliano.

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

Versione tradotta (e quindi golfata) della soluzione ATaco .

Python 2 , 94 91 73 byte

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

Provalo online!

Questo abusa del modo in cui .stripfunziona, rimuovendo tutte le cifre con a=s(`3**39`)dove `3**39`è solo un modo più breve per generare le cifre da 0a 9, questo memorizzerà solo i caratteri ache verranno utilizzati per rimuovere i caratteri dai numeri sus(a)

Fogli Google, 43 byte

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

Provalo online!

A1è la cella di input. Spero che il link sopra funzioni, non ho mai provato il golf code con Fogli Google prima.

JavaScript, 72 byte

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

Proton , 113 byte

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

Provalo online!

-19 byte prendendo in prestito l'algoritmo di Rod ( nota a sé: aggiungi listcomps )

Dyalog APL, 44 byte

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

Provalo online!

Pyth - 31 byte

Primo tentativo, molto ingenuo.

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

Provalo online qui .

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

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

Provalo online!

L' mapistruzione considera la colonna come un numero base26 e la converte in decimale. La sostituzione sostituisce le lettere con i numeri. L'input e l'output sono impliciti nel -pflag.

Mathematica, 108 byte

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

La forma dell'operatore StringReplaceche prende la parte alfabetica cdella stringa, la converte in un elenco di codici di caratteri, sottrae 64da ciascun punto di codice, interpreta il risultato come un 26numero intero di base , converte quel numero intero in unString , quindi StringJoinuno spazio seguito dalla parte numerica r.

Usando un regex (anche 108byte):

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

Jelly ,  16  15 byte

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

Un programma completo che accetta la stringa come argomento e stampa il risultato

Provalo online!

Come?

Ø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 conversione da un elenco di numeri utilizzando l'atomo di conversione di base ḅconsente ai luoghi di essere al di fuori dell'intervallo previsto, quindi la conversione da, diciamo, [2,26,1]( "BZA") utilizzando ḅ26viene calcolata come 2 × 26 ² + 26 × 26 ¹ + 1 × 26 ⁰ = 2029 anche se la rappresentazione "prevista" sarebbe stata [3,0,1].

Mathematica, 77 72 69 68 byte

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

Prende un elenco di caratteri.

Provalo su 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}

Spiegazione

#/.

Nell'input sostituisci ...

{a__,b__?DigitQ}

Un elenco che contiene due sequenze ae b(con 1 o più elementi), dove è bcomposto solo da caratteri numerici ... (Mathematica utilizza la corrispondenza del pattern pigro, quindi non è richiesto alcun controllo per a)

:>

in...

f=FromDigits;

Impostato fsulla funzione di conversione da cifra a intera.

LetterNumber@{a}

Converti ain numeri di lettere (a -> 1, b -> 2, ecc.).

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

Convertire quanto sopra da base-26 in decimale e convertire bin decimale.

Haskell, 67 byte

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

Provalo online.

Retina , 85 byte

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

Provalo online! Spiegazione:

[A-Z]
$& 

Separare le lettere l'una dall'altra e il numero finale.

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

Converti le lettere in decimale.

\d+
$*

Converti tutto in unario.

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

Mentre ci sono almeno tre numeri, moltiplica il primo per 26 e aggiungilo al secondo.

1+
$.&

Converti tutto in decimale.

Rubino , 50 48 + 1 = 51 49 byte

Usa la -pbandiera. -2 byte da m-chrzan.

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

Provalo online!

> <>, 42 byte

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

Provalo online

Spiegazione:

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

Il ciclo precedente leggerà il primo numero della parte numerica (ad es. '3' in "AB34") prima di interrompere, e avrà già sottratto 64 da esso, quindi il prossimo bit di codice dovrà occuparsene

$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

Questo ciclo inizia emettendo un carattere che sarà o il primo carattere letto dal primo ciclo, o il carattere letto dalla precedente iterazione di questo 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

Rubino, 64 61 59 byte

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

Risparmiato 2 byte grazie a Value Ink.

Finestra immediata di Excel-VBA, 44 45 byte ( 36 35)

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

1 byte aggiunto per sopprimere la nuova riga finale

O per 35 con spazi bianchi principali

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

1 byte salvato grazie a @TaylorScott!

Entrambi prendono input dalla cella A1, output alla finestra VBE Immediate

Lua, 127 byte

Alcune belle manipolazioni di stringhe che vanno lì, sto usando alcune funzioni che di solito non vengono mai utilizzate mentre si gioca a golf in lua: D. Il modo migliore per giocare a golf sarebbe quello di trovare un altro modo per scorrere la parte della colonna dell'input pur essendo in grado di mantenere la posizione di ogni lettera. Non ho ^^ '.

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

Spiegazione

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