Таким чином, ми всі, маємо надію, знайомі з позначеннями комірок електронної таблиці "А1".

Це просто буквено-цифрове зображення розташування зазначеної комірки в сітці. Букви (и) представляють позицію стовпчика комірки, а число - рядок.

Частина "літер" може складатися з 1 або більше літер англійського алфавіту з 26 літер, всі вони повинні бути великими літерами. Ці карти відбиваються на числа за допомогою використання 26-адичної біективної нумерації. Частина 'число' може складатися з будь-якого додатного, ненульового цілого числа.

Завдання, написати програму, яка дала позначення А1 будь-якої комірки як єдину рядок, може вивести рядок, що містить позицію стовпця, представлену як число, а потім пробіл, а потім номер рядка.

Приклади введення / виводу нижче:

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

Це мій перший виклик, отже, відносна простота та потенційна бідність критеріїв.

EDIT : Рядок повинен бути літерами з цифрами, а критерій виграшу - найкоротша довжина коду (якщо це може бути річ)

EDIT : Пов’язано з цим, але робить зворотний процес з іншим стартовим індексом. Деякі можуть стверджувати, що цей факт робить пов'язану головоломку цікавішою.

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 Таблиці, 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 байт запозичення алгоритму Рода ( зауваження до себе: додавання списків )

Діалог 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прапорі.

Математика, 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].

Математика, 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<>""]}

Перетворіть вищезгадане з базової-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+
$.&

Перетворити все в десятковий.

Ruby , 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 байти завдяки Ink 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

Луа, 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