Таким образом, мы все, надеюсь, знакомы с нотацией ячейки Spreadsheet 'A1'.

Это просто буквенно-цифровое представление положения указанной ячейки в сетке. Буква (буквы) представляет расположение столбца в ячейке, а число представляет строку.

Часть «буквы» может состоять из 1 или более букв из 26 букв английского алфавита, причем все они должны быть заглавными буквами. Они сопоставляются с числами с помощью 26-адической биективной нумерации. Часть «число» может состоять из любого положительного, ненулевого целого числа.

Задача - написать программу, в которой для каждой ячейки задана нотация A1 в виде одной строки, можно вывести строку, содержащую позицию столбца, представленную в виде числа, за которым следует пробел, а затем номер строки.

Пример входов / выходов ниже:

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

Это моя первая проблема, отсюда и относительная простота и потенциальная слабость критериев.

РЕДАКТИРОВАТЬ : строка должна состоять из букв, за которыми следуют цифры, и критерием выигрыша является самая короткая длина кода (если это может быть вещь)

РЕДАКТИРОВАТЬ : Связано с этим, но делает обратный процесс с другим начальным индексом. Некоторые могут утверждать, что этот факт делает связанную головоломку более интересной.

05AB1E , 12 11 байт

áÇ64-₂βð¹þJ

Использует кодировку 05AB1E . Попробуйте онлайн!

Microsoft Excel, 43 байта.

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

Я не мог с собой поделать, мне просто нужно было использовать правильный инструмент для работы. Принимает участие на А1.

Тестовые случаи

Microsoft Excel, 40 байт

Бразильско-португальская языковая версия.

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

Переведенная (и, следовательно, игра в гольф) версия решения ATaco .

Python 2 , 94 91 73 байта

^{-3 байта благодаря Джонатану Аллану
-18 байтов благодаря tsh}

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

Попробуйте онлайн!

Это злоупотребляет тем, как это .stripработает, удаляя все цифры, a=s(`3**39`)где `3**39`есть просто более короткий способ генерирования цифр из 0в 9, это будет хранить только те символы, aкоторые будут использоваться для удаления символов из чисел наs(a)

Google Sheets, 43 байта

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

Попробуйте онлайн!

A1является входной ячейкой. Надеюсь, что приведенная выше ссылка работает, я никогда раньше не пробовал играть в гольф с Google Sheets.

JavaScript, 72 байта

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

Протон , 113 байт

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

Попробуйте онлайн!

-19 байт, заимствуя алгоритм Рода ( примечание к себе: добавить списки )

Dyalog APL, 44 байта

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

Попробуйте онлайн!

Pyth - 31 байт

Первая попытка, очень наивная.

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

Попробуйте это онлайн здесь .

Perl 5 , 35 + 1 (-p) = 36 байт

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

Попробуйте онлайн!

В mapзаявлении рассматривает столбец как число base26 и преобразует его в десятичное. Подстановка заменяет буквы цифрами. Вход и выход неявны в -pфлаге.

Mathematica, 108 байт

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

Оператор, StringReplaceкоторый принимает буквенную часть cстроки, преобразует ее в список кодов символов, вычитает 64из каждой кодовой точки, интерпретирует результат как базовое 26целое число, преобразует это целое число в a String, затем в StringJoinпробел, за которым следует числовая часть r.

Используя регулярное выражение (также 108байты):

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

Желе ,  16  15 байт

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

Полная программа, принимающая строку в качестве аргумента и печатающая результат

Попробуйте онлайн!

Как?

Ø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

Примечание: преобразование из списка чисел с использованием базового атома преобразования ḅпозволяет местам находиться за пределами ожидаемого диапазона, поэтому преобразование, скажем, с использованием [2,26,1]( "BZA"), ḅ26рассчитывается как 2 × 26 ² + 26 × 26 ¹ + 1 × 26 ⁰ = 2029, хотя "ожидаемое" представление было бы [3,0,1].

Mathematica, 77 72 69 68 байт

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

Принимает список персонажей.

Попробуйте это на Wolfram Sandbox

использование

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

{194, 93}

или

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

{194, 93}

объяснение

#/.

На входе заменить ...

{a__,b__?DigitQ}

Список, содержащий две последовательности aи b(с 1 или более элементами), где bсостоит только из цифр ... (Mathematica использует ленивое сопоставление с образцом, поэтому проверка не требуется a)

:>

в...

f=FromDigits;

Установите fфункцию преобразования цифр в целые числа.

LetterNumber@{a}

Преобразовать aв буквенные числа (a -> 1, b -> 2 и т. Д.).

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

Преобразуйте вышеупомянутое из base-26 в десятичное, и преобразуйте bв десятичное.

Haskell, 67 байт

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

Попробуйте онлайн.

Сетчатка , 85 байт

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

Попробуйте онлайн! Объяснение:

[A-Z]
$& 

Отделите буквы друг от друга и окончательный номер.

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

Преобразуйте буквы в десятичные.

\d+
$*

Переведите все в одинарные.

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

Хотя есть хотя бы три числа, умножьте первое на 26 и добавьте ко второму.

1+
$.&

Перевести все в десятичное.

Рубин , 50 48 + 1 = 51 49 байтов

Использует -pфлаг. -2 байта из m-chrzan.

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

Попробуйте онлайн!

> <>, 42 байта

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

Попробуйте онлайн

Объяснение:

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

Вышеупомянутый цикл будет читать первую часть числовой части (например, «3» в «AB34») перед разрывом, и из него уже будет вычтено 64, поэтому следующий бит кода должен иметь дело с этим

$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

Этот цикл начинается с вывода символа, который будет либо первым знаком, прочитанным первым циклом, либо символом, прочитанным предыдущей итерацией этого цикла.

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

Рубин, 64 61 59 байт

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

Сохранено 2 байта благодаря Value Ink.

Excel-VBA Непосредственное окно, 44 45 байт ( 36 35)

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

1 байт добавлен, чтобы подавить завершающий перевод строки

Или за 35 с ведущими пробелами

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

1 байт сохранен благодаря @TaylorScott!

Оба принимают вход из ячейки A1, выводят в окно VBE Immediate

Луа, 127 байт

Там идут некоторые приятные манипуляции со струнами, я использую некоторые функции, которые обычно никогда не используются во время игры в гольф в Луа: D. Наилучший способ игры в гольф - это найти другой способ перебора части столбца ввода, сохраняя при этом положение каждой буквы. Я не ^^ '.

Попробуйте онлайн!

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

объяснение

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