枚举单元符号

16

因此，我们都希望熟悉Spreadsheet“ A1”单元格表示法。

它只是该单元格在网格中的位置的字母数字表示。字母表示单元格的列位置，数字表示行。

“字母”部分可以包含26个英文字母中的1个或多个字母，所有字母必须为大写字母。这些通过使用26-adic双射数来映射为数字。“数字”部分可以由任何非零的正整数组成。

挑战在于，编写一个程序，以任何字符串的形式给出任何单元格的A1表示，可以输出一个字符串，该字符串包含以数字表示的列位置，然后是空格，然后是行号。

下面的示例输入/输出：

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

这是我面临的第一个挑战，因此，该标准相对简单且可能很差。

编辑：字符串必须是字母，后跟数字，并且获胜标准是最短的代码长度（如果可以的话）

编辑：与此有关，但是用不同的起始索引进行了反向处理。有人可能会争辩说，这一事实使链接之谜变得更加有趣。

code-golf  alphabet 
— dbr
source
我们可以将输入作为例如包含字母和数字的数组吗：["A", "1"]
— Stephen
1
@StepHen否。它必须是包含字母和数字的单个字符串。我可能还应该补充一点，字符串必须按字母顺序，后跟数字。
— dbr
1
我们通常允许使用更灵活的输入和输出格式，例如选择换行符而不是空格作为输出分隔符
— Luis Mendo
3
@DeanBrunt这取决于您，当然您可以强制采用严格的格式以使挑战变得更加困难。但是人们通常在实际计算中比在格式中享受更多的困难
— Luis Mendo
4
这是因为格式本身并没有给实际的挑战增加任何价值
— Adnan

Answers:

20

Microsoft Excel，43个字节。

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

我束手无策，我只好使用正确的工具完成工作。在A1上输入。

测试用例

— 阿塔科
source
11

Microsoft Excel，40个字节

巴西葡萄牙语葡萄牙语版本。

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

翻译（并因此打高尔夫）的ATaco解决方案版本。

— 帕琼克
source
我不记得Excel是否允许像表格这样使用，但是您可以在另一个答案上使用@Uriel的建议并丢失最后两个括号吗？
— dbr
该建议（省略最右边的括号）会在Excel中引发警告，您必须确认才能继续进行操作，因此我认为此处不允许这样做。
— pajonk
啊，我明白了。那就和床单不同了。
— DBR
7

Python 2和94 91 73字节

-3字节归功于Jonathan Allan
-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工作，清除所有数字wtih a=s(`3**39`)这里`3**39`仅仅是一个生成的数字，从较短的方式0来9，这将只存储的字符a将被用于剥去号码字符上s(a)

— 竿
source
我认为不需要strip输入成为唯一字符，因此3**39应该做同样的工作。
— 乔纳森·艾伦
1
— tsh
6

Google表格，43个字节

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

在线尝试！

A1是输入单元格。希望以上链接有效，我之前从未尝试过使用Google表格进行代码高尔夫。

— Notjagan
source
1
@ATaco没有理由，因为重复的答案可以共存。
— 科纳·奥布莱恩
1
Google表格和Microsoft Excel的出现使我感到满意。
— dbr
5
您可以做=COLUMN(INDIRECT(A1))&" "&ROW(INDIRECT(A141个字节。表格填写缺少的右括号。
— Uriel's
5

JavaScript，72个字节

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

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

在线尝试！

借用Rod算法的-19个字节（自我注意：添加listcomps）

— 超中微子
source
1

Perl 5，35 +1（-p）= 36字节

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

在线尝试！

该map语句将列视为base26数字，并将其转换为十进制。替换用数字替换字母。输入和输出隐含在-p标志中。

— Xcali
source
1

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"]
— 念珠菌病
source
1
ToCharacterCode@c-64有时可以减少到LetterNumber@c。LetterNumber但是，List当输入为单个字符时，不会包装输出。
— JungHwan Min
1

果冻， 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 2 + 26×26 1 + 1×26 0 =即使“预期的”表示应该是2029年[3,0,1]。

— 乔纳森·艾伦
source
2
@Dean Brunt这么快接受答案（通常最多一周）通常是不常见的-这可能会使其他人不敢竞争。看到05AB1E或其他高尔夫球语言打败了我，我不会感到惊讶...
— Jonathan Allan
点了。仍在学习我的方式
— dbr
没问题！欢迎来到PPCG，并发布第一篇好文章：）
— 乔纳森·艾伦
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<>""]}

将上面的从26转换b为十进制，然后转换为十进制。

— 郑焕民
source
1

视网膜，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+
$.&

将所有内容转换为十进制。

— 尼尔
source
1

> <>，​​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

上面的循环将在中断之前读入数字部分的第一个数字（例如，“ AB34”中的“ 3”），并且已经从中减去了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
— 萨沙
source
1

Ruby，64 61 59字节

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

借助Value Ink，节省了2个字节。

— m-chrzan
source
1
$&是最后一个正则表达式匹配项，因此请使用它而不是m节省2个字节。
— 价值墨水
1

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

感谢@TaylorScott，节省了1个字节！

两者都从单元格A1接受输入，输出到VBE立即窗口

— 格里多
source
1
我要说的是，领先的空白答案是一个有效的答案，因为必须删除它，否则将强制Trim()在几乎所有数字答案上使用-那样我就不能使用Set v=Range([A1]):?v.Column""&v.Row您当前的解决方案
— Taylor Scott
而且，该死，我不敢相信我错过了这个问题！
— 泰勒·斯科特
@TaylorScott哦，使用“”很不错-我猜Excel知道;当后面的字符Column不能作为例程名称的一部分时会插入。我想知道是否有一个角色可以做同样的事情，也许不会。是的，我猜想大多数qus的前导空格是可以接受的，但是对于这一点，我认为它更多的是“打印此精确字符串”。我确实问过（关于问题的最后评论），但没有被告知有空格或换行符。
— Greedo
1
另外，当我看到问题标题时，我立即知道，如果您或其他人还没有的话，我应该去试试！就像其他基于Excel的答案所说的那样，这是工作的正确工具。
— Greedo
1

Lua，127字节

一些不错的字符串操作在那里，我正在使用一些通常在lua：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
— Katenkyo
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.