Bu yüzden hepimiz Umarız 'A1' Elektronik Tablosu notasyonuna aşinayız.

Bu, söz konusu hücrenin bir ızgara içine konumlandırılmasının alfasayısal bir temsilidir. Harfler, hücrenin sütun konumunu ve sayı satırı temsil eder.

'Harf' kısmı, tamamı büyük harf olmak üzere 26 harfli İngiliz alfabesinden 1 veya daha fazla harften oluşabilir. Bu 26-adik bijektif sayım kullanılarak sayılara eşlenir. 'Sayı' kısmı herhangi bir pozitif, sıfır olmayan bir tamsayıdan oluşabilir.

Herhangi bir hücrenin A1 gösterimini tek bir dize olarak veren bir program yazarak, bir sayı olarak temsil edilen sütun konumunu, ardından bir boşluk ve ardından satır numarasını içeren bir dize çıktısı alabilirsiniz.

Aşağıdaki Örnek Giriş / Çıkışlar:

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

Bu benim ilk görevim, dolayısıyla kriterlerin göreceli basitliği ve potansiyel zayıflığı.

DÜZENLEME : Dize harflerin ardından sayılar gelmeli ve kazanan ölçütler en kısa kod uzunluğudur (bu bir şey olabilirse)

DÜZENLEME : İlgili bu ama farklı bir başlangıç indeksi ters işlemini yapar. Bazıları bu gerçeğin bağlantılı bulmacayı daha ilginç hale getirdiğini iddia edebilir.

05AB1E , 12 11 bayt

áÇ64-₂βð¹þJ

05AB1E kodlamasını kullanır . Çevrimiçi deneyin!

Microsoft Excel, 43 Bayt.

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

Kendime yardım edemedim, sadece iş için doğru aracı kullanmak zorunda kaldım. A1 üzerine giriş alır.

Test Durumları

Microsoft Excel, 40 bayt

Brezilya Portekizcesi sürümü.

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

Sürümü Çeviri (ve dolayısıyla golfed) Ataco çözümüyle .

Python 2 , 94 91 73 bayt

^{Jonathan Allan sayesinde -3 byte
tsh sayesinde -18 bayt}

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

Çevrimiçi deneyin!

Bu suistimaller yolu olduğunu .stripbütün haneleri kaldırarak işleri, gayrimenkulünü a=s(`3**39`)nerede `3**39`basamak gelen üretmek için sadece kısa bir yoludur 0için 9, bu yalnızca karakter saklayacak abu konuda numaralardan gelen karakter şerit kullanılacaktırs(a)

Google E-Tablolar, 43 bayt

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

Çevrimiçi deneyin!

A1girdi hücresidir. Umarım yukarıdaki bağlantı çalışır, daha önce Google E-Tablolar ile kod golf denemedim.

JavaScript, 72 bayt

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

Proton , 113 bayt

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

Çevrimiçi deneyin!

-19 bayt ödünç çubuk algoritması ( kendine not: listcomps ekle )

Dyalog APL, 44 bayt

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

Çevrimiçi deneyin!

Pyth - 31 bayt

İlk girişim, çok saf.

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

Burada çevrimiçi deneyin .

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

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

Çevrimiçi deneyin!

mapDeyim davranır o onluya bir base26 numarası ve dönüşüm gibi sütun. İkame harfleri rakamlarla değiştirir. Girdi ve çıktı -pbayrakta gizlidir.

Mathematica, 108 bayt

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

Dizesinin StringReplacealfabetik kısmını calan, onu bir karakter kodları listesine dönüştüren 64, her kod noktasından çıkartan, sonucu temel bir 26tamsayı olarak yorumlayan, bu tamsayıyı birStringStringJoin a'ya , ardından sa boşluğuna ve ardından sayısal kısmar .

Normal ifade kullanma (ayrıca 108bayt):

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

Jöle ,  16  15 bayt

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

Dizeyi argüman olarak kabul eden ve sonucu basan tam bir program

Çevrimiçi deneyin!

Nasıl?

Ø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

Not: temel dönüşüm atom kullanarak numaraları listesi dönüştürme ḅ, yerler beklenen aralığın dışında olmasını sağlar, diyelim ki, dönüştürme, böylece [2,26,1]( "BZA"kullanarak) ḅ26olarak hesaplanır 2 x 26 ² + 26 x 26 ¹ + 1 x 26 ⁰ = 2029 "beklenen" temsil olsa da [3,0,1].

Mathematica, 77 72 69 68 bayt

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

Karakterlerin bir listesini alır.

Wolfram Sandbox'ta deneyin

kullanım

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

{194, 93}

veya

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

{194, 93}

açıklama

#/.

Girişte değiştirin ...

{a__,b__?DigitQ}

İki dizi içeren ave b(1 veya daha fazla öğeli), byalnızca rakam karakterlerinden oluşan bir liste ... (Mathematica tembel desen eşleşmesi kullanır, bu nedenle kontrol gerekmez a)

:>

içine ...

f=FromDigits;

Sayıdan ftamsayıya dönüştürme işlevine ayarlayın.

LetterNumber@{a}

aHarf numaralarına dönüştürün (a -> 1, b -> 2 vb.).

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

Yukarıdakileri taban-26'dan ondalığa dönüştürün bve ondalığa dönüştürün .

Haskell, 67 bayt

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

Çevrimiçi deneyin.

Retina , 85 bayt

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

Çevrimiçi deneyin! Açıklama:

[A-Z]
$& 

Harfleri birbirinden ve son numaradan ayırın.

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

Harfleri ondalık sayıya dönüştürün.

\d+
$*

Her şeyi tekil hale getirin.

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

En az üç sayı olsa da, ilkini 26 ile çarpın ve ikinciye ekleyin.

1+
$.&

Her şeyi ondalık sayıya dönüştürün.

Yakut , 50 48 + 1 = 51 49 bayt

-pBayrağı kullanır . -2 bayt m-chrzan.

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

Çevrimiçi deneyin!

> <>, 42 Bayt

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

Çevrimiçi Deneyin

Açıklama:

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

Yukarıdaki döngü, sayılar bölümünün ilk sayısını (örn., "AB34" içerisinde "3") okuyacaktır ve bundan 64 tane çıkarmış olacaktır, bu nedenle kodun bir sonraki biti bununla başa çıkmak zorunda

$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

Bu döngü, ilk döngü tarafından okunan ilk karakter veya bu döngü önceki yinelemesinde okunan karakter olacak bir karakter çıktısıyla başlar.

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

Yakut, 64 61 59 bayt

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

Value Ink sayesinde 2 bayt tasarruf etti.

Excel-VBA Anında pencere, 44 45 Bayt ( 36 35)

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

Sondaki yeni satırı bastırmak için 1 bayt eklendi

Veya önde gelen boşluklu 35 için

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

@TaylorScott sayesinde 1 byte tasarruf!

Her ikisi de A1 hücresinden girdi alır, VBE Anında penceresine çıkar

Lua, 127 Bayt

Bazı güzel dize manipülasyonları oraya gidiyor, ben genellikle lua: D golf yaparken kullanılan bazı işlevi kullanıyorum. Bunu golf oynamanın en iyi yolu, her harfin konumunu korurken girişin sütun kısmı üzerinde yineleme yapmak için başka bir yol bulmak olacaktır. Ben ^ ^ değil.

Çevrimiçi deneyin!

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

açıklama

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