Brainf * ck，81个字符（无空格）

Question

挑战

按字符数排序的最短代码，它将输出Excel列字符串的数字等效值。

例如，A列为1，B为2，依此类推。点击Z后，下一列变为AA，然后变为AB，依此类推。

测试用例：

A:    1
B:    2
AD:   30
ABC:  731
WTF:  16074
ROFL: 326676

代码计数包括输入/输出（即完整程序）。

Answer 1

Excel，9个字符：）

使用正确的工具：

=COLUMN()

=COLUMN()

Answer 2

Perl， 36 34 33 31 30 17 < / s> 15 11个字符

$_=()=A..$_

用法：

$ echo -n WTF | perl -ple '$_=()=A..$_' 16074

使用echo -n减少到17以避免chop调用。

使用say而不是print来减少到15。

使用-p而不是说减少到11。

说明： A在字符串上下文中进行评估，A..$_构建一个以“A”开头的字符串，并以字符串为单位递增到输入字符串。 Perl在字母上下文中解释字符串上的++运算符（以及..），例如$_="AZ";$_++;print输出BA。

=()=（又名"goatse" operator）强制在列表上下文中计算表达式，并返回该表达式返回的元素数，即$scalar = () = <expr>对应@list = <expr>; $scalar = @list

Answer 3

J， 17 12 10个字符

26#.64-~av

示例：

26#.64-~av  'WTF'
16074

说明：

J从右到左解析。
av返回其参数中每个字符的ascii索引列表，例如av'ABC'返回65 66 67。
然后我们用动词64-~。
然后我们使用#.动词将列表转换为基数26。

Answer 4

Brainf * ck，81个字符（无空格）

,[>>>[->>+++++[-<+++++>]<+<]>[-<+>]<<++++++++[<++++++++>-]<[<->-]<[>>>+<<<-],]>>>

说明

,[  // get character input into p[0], enter loop if it isn't null (0)
>>>[->>+++++[-<+++++>]<+<] // take what's in p[3] and multiply by 26, storing it in p[4]
>[-<+>] // copy p[4] back to p[3]
<<++++++++[<++++++++>-]< // store 64 in p[1]
[<->-]< // subtract p[1], which is 64, from the input char to get it's alphabetical index
[>>>+<<<-] // add p[0] to p[3]
,] // get another character and repeat
>>> // move to p[3], where our final result is stored

所以你会注意到我实际上没有将数值转换为ascii字符串进行打印。这可能会破坏乐趣。但我赞成将指针移动到带有结果的单元格，所以至少它对机器有用。

嘿，你知道什么，我击败了C＃！

Answer 5

Ruby 1.8.7， 53 50 46 44 24 17个字符

p ('A'..$_).count

用法：

$ echo -n ROFL | ruby -n a.rb
326676
$ echo -n WTF | ruby -n a.rb
16074
$ echo -n A | ruby -n a.rb
1

Answer 6

APL

13个字符

将值放在x：

中

x←'WTF'

然后用：

计算它

26⊥(⎕aV⍳x)-65

J击败我的唯一原因是因为括号。我认为应该有一些方法来重新排列它以避免它们的需要，但这是漫长的一天。想法？

（嘿，你这个有30多个角色解决方案的程序员非常可爱！）

Answer 7

Excel（不作弊），25个字符

最多支持XFD：

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

安装：

将公式放在单元格A2中。

用法：

在单元格A1中输入列字符串。
在A2单元格中阅读结果。

54个字符，加上大量说明

也支持ROFL：

(A2)  =MAX(B:B)
(B2)  =IFERROR(26*B1+CODE(MID(A$1,ROW()-1,1))-64,0)

安装：

清除整个电子表格。
将公式（A2）放入单元格A2中。
将公式（B2）放入单元格B2中。
尽可能地填写公式（B2）。

用法：

在单元格A1中输入列字符串。
在A2单元格中阅读结果。

Answer 8

C＃ 156 146 118 Chars

using System.Linq;class P{static void Main(string[]a){System.Console.Write(
a[0].Aggregate(0,(t,c)=>(t+c-64)*26)/26);}}

Ungolfed：

using System.Linq;
class P
{
    static void Main(string[] a)
    {
        System.Console.Write(a[0]
            .Aggregate(0, (t, c) => (t + c - 64) * 26) / 26);
    }
}

Answer 9

Golfscript - 16个字符

[0]\+{31&\26*+}*


$ echo -n WTF | ./golfscript.rb excel.gs
16074
$ echo -n ROFL | ./golfscript.rb excel.gs
326676

Answer 10

Haskell，50 51 56 chars

main=interact$show.foldl(\x->(26*x-64+).fromEnum)0

用法：

~:166$ echo -n "ROFL" | ./a.out
326676
~:167$ echo -n "WTF" | ./a.out
16074

Answer 11

k4（kdb +），11个字符

26/:1+.Q.A?

说明：

k4解析右侧
.Q.A在k4中定义 - 它是向量"ABC...XYZ"
?是find运算符 - x arg中y arg中项目的第一个匹配的索引
+1以抵消索引
26/:转换为基础26

一个警告 - 这只适用于传递列出类型的地方：

  26/:1+.Q.A? "AD"
30

  26/:1+.Q.A? "WTF"
16074

但：

  26/:1+.Q.A? ,"A"
1

Answer 12

Python， 64 49个字符

s=0
for c in raw_input():s=26*s+ord(c)-64
print s

您还可以将raw_input()替换为input()以将字符数减少4，但这需要输入在其周围包含引号。

这是一个以47个字符计时的子程序：

f=lambda x:len(x)and 26*f(x[:-1])+ord(x[-1])-64

Answer 13

JavaScript 1.8：66个字符

function a(p)Array.reduce(p,function(t,d)t*26+d.charCodeAt()-64,0)

Javascript 1.8：72个字符

function a(p)(t=0,p.replace(/./g,function(d)t=t*26+d.charCodeAt()-64),t)

JavaScript 1.6：83个字符

function a(p){t=0;p.split("").map(function(d){t=t*26+d.charCodeAt(0)-64});return t}

JavaScript：95个字符

function a(p){r=0;t=1;l=p.length;for(i=0;i<l;i++){r+=(p.charCodeAt(l-1-i)-64)*t;t*=26}return r}

JavaScript：105个字符

function a(p,i){i=i||0;l=p.length;return p?(p.charCodeAt(l-1)-64)*Math.pow(26,i)+a(p.slice(0,l-1),i+1):0}

用法：

a("A")        // 1
a("B")        // 2
a("AD")       // 30
a("ABC")      // 731
a("WTF")      // 16074
a("ROFL")     // 326676

Answer 14

Powershell，42个字符

[char[]]$args[($s=0)]|%{$s=$s*26+$_-64};$s

Answer 15

Scala，30个字符

print((0/:args(0))(_*26+_-64))"

示例：

C:\>scala -e "print((0/:args(0))(_*26+_-64))" AD
30

Answer 16

概念说明 - Excelcification

尼斯。很久以前，我用更多的解释写了我自己的版本 http://aboutdev.wordpress.com/2009/12/19/excelcification-brain-teaser-code/。虽然它不是一个优化的版本！

FYI。基础26算术称为hexavigesimal，Excel的最大列为 XFD ，转换为16383（使用0作为第一个单元格），这是恰巧 2 ^ 14个细胞。

任何人都可以猜到为什么它是2 ^ 14 ??

Answer 17

Common Lisp，103 128 个字符

(defun x(s)(reduce(lambda(x y)(+(* 26 x)y))(map 'vector(lambda(b)(-(char-code b)(char-code #\A)-1))s)))

Answer 18

C89,58个字符

s;main(c){while(c=getchar()+1)s=26*s+c-65;printf("%d",s);}

输入（stdin）必须只包含A-Z，不允许其他字符（包括换行符）。

Answer 19

C＃， 117 111个字符

与Perl，Ruby和APL相比没有任何竞争，但到目前为止对其他C＃/ Java答案的改进。

这使用Horner's rule。

class C{static void Main(string[]a){int t=0;foreach(var c in a[0]){t=(t+c-64)*26;}System.Console.Write(t/26);}}

Answer 20

Clojure的：

user> (reduce #(+ (* 26 %1) %2) (map #(- (int %) 64) "AD"))
30
user> (reduce #(+ (* 26 %1) %2) (map #(- (int %) 64) "ROFL"))
326676

51个字符，加上输入字符串中的字符数。

Answer 21

Python - 63个字符

＆GT;＆GT;＆GT; f = lambda z：reduce（lambda x，y：26 * x + y，[ord（c）-64 for c in z]）

＆GT;＆GT;＆GT; F（ 'ROFL'）

326676

Answer 22

Common Lisp，86个字符。

(defun z(s)(let((a 0))(map nil(lambda(v)(setf a(+(* 26 a)(digit-char-p v 36)-9)))s)a))

Answer 23

C＃，148个字符

using System;class P{static void Main(string[]a){var r=0d;int j=0,i=a[0].
Length;while(i-->0)r+=(a[0][i]-64)*Math.Pow(26,j++);Console.WriteLine(r);}}

Ungolfed：

using System;
class P
{
    static void Main(string[] a)
    {
        var r = 0d;
        int j = 0, i = a[0].Length;
        while (i-- > 0)
            r += (a[0][i] - 64) * Math.Pow(26, j++);

        Console.WriteLine(r);
    }
}

Answer 24

Ruby 1.9,21个字符

p'A'.upto(gets).count

试验：

$ echo -n A| ruby x.rb
1
$ echo -n WTF| ruby x.rb
16074
$ echo -n ROFL| ruby x.rb
326676

Answer 25

C：

int r=0;
while(*c)r=r*26+*c++-64;

字符串存储在'c'中，值在'r'。

Answer 26

Perl，34个字符

map$\=26*$\-64+ord,pop=~/./g;print

感谢mobrule提出的一些建议。

Answer 27

Common Lisp，81个字符

(defun y(s)(reduce(lambda(x y)(+(* 26 x)(-(char-code y)64)))s :initial-value 0))

有趣的是，作为一个新用户，我可以发布自己的答案，但不会评论别人的答案。哦，如果我做错了，请道歉！

Answer 28

Ruby，20个字符

p('A'..$*[0]).count

用法：

$ ruby a.rb ABC
731

Answer 29

在VBA中我把它降到了98

Sub G(s)
Dim i, t
For i = 0 To Len(s) - 1
    t = t + ((Asc(Left(Right(s, i + 1), 1)) - 64)) * ((26 ^ i))
Next
MsgBox t
End Sub

Answer 30

PHP - 73 Chars

$n=$argv[1];$s=$i=0;while($i<strlen($n))$s=$s*26+ord($n[$i++])-64;echo$s;

用法：

php -r '$n=$argv[1];$s=$i=0;while($i<strlen($n))$s=$s*26+ord($n[$i++])-64;echo$s;' AA

> 27

Answer 31

Java：112 124 个字符

class C{public static void main(String[]a){int r=0;for(int b:a[0].getBytes())r=26*r+b-64;System.out.print(r);}}

Answer 32

MATLAB：24个字符

polyval(input('')-64,26)

用法：

>> polyval(input('')-64,26)
(after pressing enter) 'WTF'

ans =

       16074

注意：如果您在x预先存储字符串，则可以将其缩小为 16 字符，但我认为这是作弊：

>> x = 'WTF'

x =

WTF

>> polyval(x-64,26)

ans =

       16074

Answer 33

Applescript：188
这是188个字符中的必备苹果，这是一种非冗长的语言。它也恰好是目前为止所有语言中最长的答案。如果有人知道如何缩短它，请分享。

on run s  
 set {o, c} to {0, 0}  
 repeat with i in reverse of (s's item 1)'s characters  
  set m to 26 ^ c as integer  
  set c to c + 1  
  set o to o + ((ASCII number of i) - 64) * m  
 end repeat  
end run

用法：
osascript /path/to/script.scpt ROFL

Answer 34

PHP： 56 55个字符

for($i='a';$i++!=strtolower($argv[1]);@$c++){}echo++$c;

PHP： 44 仅限大写字母的43个字符

for($i='A';$i++!=$argv[1];@$c++){}echo++$c;

Answer 35

PHP，38个字符

for($a=A;++$c,$a++!=$argv[1];);echo$c;

用法，例如

php -r 'for($a=A;++$c,$a++!=$argv[1];);echo$c;' WTF

Answer 36

APL：7个字符

将所需的字符串存储在变量w：

中

w←'rofl'

假设字符是小写的：

26⊥⎕a⍳w

假设字符是大写的：

26⊥⎕A⍳w

混合案例或不确定案例（14个字符，但可能会有所改进）：

26⊥⊃⌊/⎕a⎕A⍳¨⊂w

Answer 37

wazoox：

echo -n WTF | perl -ple'$ =（）= A .. $ '

这会打印一个新行，因此答案在shell上更具可读性。

Answer 38

Smalltalk，72

Smalltalk arguments first reverse inject:0into:[:o :e|o*26+e digitValue]

Answer 39

Perl，120个字符

chomp($n=<>);@c=split(//,uc($n));$o=64;$b=0;$l=$#c;for($i=$l;$i>=0;$i--){$b+=((26**($l-$i))*(ord($c[$i])-$o));}print$b;

用法：

vivin@serenity ~/Projects/code/perl/excelc
$ echo WTF | perl e.pl
16074
vivin@serenity ~/Projects/code/perl/excelc
$ echo ROFL | perl e.pl
326676

我确信这里的一些Perl大师可以想出更小的东西。

Answer 40

Lua，61个字符

x=0 for c in(...):gfind(".")do x=x*26-64+c:byte()end print(x)

Answer 41

JavaScript，93个字符

with(prompt())for(l=length,i=0,v=i--;++i<l;)v+=(charCodeAt(l-1-i)-64)*Math.pow(26,i);alert(v)

Answer 42

Perl，47个字符（来自stdin）

chop($l=<>);$_=A;$.++,$_++while$_ ne$l;die$.,$/

Answer 43

<强> PHP：

<?$t=0;$s=str_split($argv[1]);$z=count($s);foreach($s as$v){$z--;$t+=(ord($v)-64)*pow(26,$z);}echo$t?>

用法： php filename.php ROFL

输出 326676

Answer 44

26个字符中的Ruby解决方案

p ("A"..$*[0]).to_a.size

Answer 45

Excel VBA，19个字符：

范围（ “WTF”）。柱

Answer 46

K 3.2（13个字符）

26_sv -64+_ic

用法：

  26_sv -64+_ic"ROFL"
326676

说明：

如上所述，K从右到左进行求值，因此_ic函数采用其右边的任何内容并将其转换为整数值，包括单个字符和字符向量
-64被添加到整数向量中的每个项目以获取一组基础值
_sv有两个参数：左边的一个是数字基，26，右边的那个是偏移值的整数向量

Answer 47

F＃（37个字符）：

Seq.fold (fun n c -> int c-64+26*n) 0

Answer 48

直击

过滤：97个字符

{ read c;i=0;while [ $c ];do eval s=({A..${c:0:1}});i=$((i*26+${#s[@]}));c=${c:1};done;echo $i;}

用法：

echo ROFL | { read c;i=0;while [ $c ];do eval s=({A..${c:0:1}});i=$((i*26+${#s[@]}));c=${c:1};done;echo $i;}
326676

功能：98个字符

C(){ i=0;while [ $1 ];do eval s=({A..${1:0:1}});i=$((i*26+${#s[@]}));set -- ${1:1};done;echo $i;}

用法：

C ROFL
326676

过滤器版本的

解释：

read c;i=0;

初始化列和总数。

while [ $c ];do

虽然还有列字符

eval s=({A..${c:0:1}});

${c:0:1}返回列的第一个字符; s=({A..Z})生成一个包含A到Z

字母的数组

i=$((i*26+${#s[@]}));

$((...))包含算术评估; ${#s[@]}是数组$ s

中元素的数量

c=${c:1};done;

${c:1}是第一个后面的$ c中的字符。 done结束了while循环

echo $i

我忘记了

更好但可疑

删除5个字符“echo”将导致输入“ROFL”为

326676: command not found

如果您确定在当前shell中没有设置该变量，则可能不需要i=0。

Answer 49

OOBasic：178个字符，不包括缩进的空格

订正

此版本通过了所有测试用例。我怀疑如果它没有“利用”使用这个编号系统的电子表格的事实，它会更成功地打高尔夫球。请参阅下面原始版本的注释，了解为何没有特别有用的信息。我并没有非常努力地降低分数。

另请注意，这仅在从OO计算电子表格中作为宏运行时才有效，原因很明显。

Function C(st as String) as Long
    C = 0
    while len(st)
        C = C*26 + ThisComponent.Sheets(0).getCellRangeByName(left(st,1) &"1").CellAddress.Column+1
        st = mid(st,2)
    wend
End Function

原始

OOBasic（OpenOffice Basic），字符太多（124）：

Function C(co As String) As Long 
    C = ThisComponent.Sheets(0).getCellRangeByName(co &"1").CellAddress.Column+1
End Function

限制：

co的最大值是AMJ（1024列）。任何更大的结果都会导致错误，并且会显示完全无法提供信息的错误消息。
- 此限制也适用于COLUMN（）单元格函数。据推测，这是OOCalc电子表格中的最大列数;我没有费心滚动到目前为止或谷歌搜索。

注意：

奇怪的是，不可能给变量'co'一个1个字母的名字。不知道这背后的逻辑是什么，但在花了足够的时间使用OOBasic之后，你就停止寻找逻辑并开始盲目地接受事物的方式（可能是在太阳下凝视太长时间）。

无论如何，在单元格中输入=C("A")，=C("ABC")等，对前四个测试用例起作用;最后两个给出错误。

Answer 50

Josl，48个字符

main 0 0 argv each 64 - swap 26 * + next print

示例：

$ josl numequiv.j A
1
$ josl numequiv.j ABC
731
$ josl numequiv.j ROFL
326676

从标准输入读取：

main 0 STDIN read-line each 64 - swap 26 * + next print

Answer 51

Python：88个字符

使用列表推导：

s=input()
print sum([((26**(len(s)-i-1))*(ord(s[i])-64)) for i in range(len(s))])

Answer 52

php 29 chars：


while($i++!=$t)$c++;echo$c+1;

假设register_globals = On
假设error_reporting = 0
通过网络服务器调用？i = A＆amp; t = ABC

Answer 53

序言：49个字符

c([],A,A).
c([H|T],I,R):-J is H-64+I*26,c(T,J,R).

使用上面的代码：

| ?- c("WTF",0,R).
R = 16074 ? 
yes
| ?- c("ROFL",0,R).
R = 326676 ? 
yes

Answer 54

因素：47个字符

反转[26 swap ^ swap 64 - *] map-index sum

Answer 55

Matlab 38个字符

仅适用于大写字母。不确定它是否也必须使用小写（例子中没有）。

x=input('')'-64;26.^(size(x)-1:-1:0)*x

如果新行不计算37（省略分号）：

x=input('')'-64
26.^(size(x)-1:-1:0)*x

我看到Matlab击败了很多语言。谁会想到这一点。

示例：

Input: 'ROFL' (dont forget the '' )
Output: ans = 326676

Answer 56

的Python

import string

letters = string.uppercase
colnum = lambda s: sum((letters.index(let)+1)*26**idx for idx, let in enumerate(s[::-1]))

print colnum('WTF') 
# 16074
print colnum('ROFL')
# 326676

Answer 57

Java，164个字符

public class A{public static void main(String[] z){int o=0,c=0;for(int i=z[0].length()-1;i>=0;i--,c++)o+=(z[0].charAt(i)-64)*Math.pow(26,c);System.out.println(o);}}

Java，177个字符

public class A
{
public static void main(String[] z)
{
    int m,o=0,c=0;
    for(int i=z[0].length()-1;i>=0;i--,c++)
    {
        m=(int)Math.pow(26,c);
        o+=(z[0].charAt(i)-64)*m;
    }
    System.out.println(o);
}
}

假设输入大写（通过命令行参数）。没有技巧的明显方法。

Answer 58

Python（47个字符）

reduce(lambda a,b:a*26+ord(b)-64,raw_input(),0)

仅适用于大写字母

Answer 59

dc - 20个字符

（相反）

dc无法处理字符输入，所以我编码相反：输入列号并输出列名：

?[26~64+rd0<LP]dsLxP

dc exccol.dc
326676
 ROFL

Answer 60

我的Javascript解决方案只是 82个字符，并使用Integer.parseInt和Radix 36.如果有人可以将此配置到此线程的Javascript部分，那就没问题！： - ）

a=function(b){t=0;b.split('').map(function(n){t=parseInt(n,36)-9+t*26});return t};

Answer 61

Groovy：51个字符

char[] a=args[0];t=0;for(i in a)t=26*t+i-64;print t

调用

groovy *scriptname* ROFL

或

groovy -e "char[] a=args[0];t=0;for(i in a)t=26*t+i-64;print t" ROFL

这与Java基本相同。我想象使用范围和闭包的一些可能性，但是这个例子没有想到任何东西。还有其他人看到缩短这个的方法吗？

不幸的是，带有封口的更加时髦的版本有点长。

t=0;args[0].toCharArray().each{t=t*26+it-64};print t

Answer 62

Go：106个字符

这不是所有语言中最短的。但它可以是C，C ++，Java和C＃中最短的。

package main
import("os"
"fmt")
func main(){t:=0
for _,c := range os.Args[1]{t=t*26+c-64}
fmt.Println(t)}

格式化版本：

package main

import (
    "os"
    "fmt"
)

func main() {
    t := 0
    for _, c := range os.Args[1] {
        t = t*26 + c - 64
    }   
    fmt.Println(t)
}

Answer 63

F＃92字符：）

让e2n（c：string）= c |＆gt; Seq.map（有趣的x - ＆gt;（int）x - 64）|＆gt; Seq.reduce（fun e a - ＆gt; a * 26 + e）

Answer 64

Elang，53/78

Shell，53个字符：

F=fun(S)->lists:foldl(fun(C,A)->A*26+C-64end,0,S)end.

模块，78个字符：

-module(g).
-export([f/1]).
f(S)->lists:foldl(fun(C,A)->A*26+C-64end,0,S).

Answer 65

真实VBA，216个无空格

我在真正的高尔夫球场也失败了。

Private Sub CB1_Click()
Dim C, S
Range("A1").Select
Do
S = Len(ActiveCell)
x = 0
C = 0
Do
C = (Asc(Mid(ActiveCell, (S - x), 1)) - 64) * (26 ^ x) + C
x = x + 1
Loop Until x = S
ActiveCell.Offset(0, 1) = C
ActiveCell.Offset(1, 0).Activate
Loop Until ActiveCell = ""
End Sub

使用A列输入，输出到B列，运行VB命令按钮单击。 = d

Answer 66

Excel - 99个字符

输入数组公式 - 我不计算Excel添加{}

=SUM((CODE(MID(A1,ROW(INDIRECT("1:" & LEN(A1))),1))-64)*26^(LEN(A1)-ROW(INDIRECT("1:" & LEN(A1)))))

Answer 67

新语言怎么样？运算符定义为

＃ - 将EXCEL的= COLUMN（）作为字符串编号返回

， - 读取字符串

。 - 写出一个字符串

然后执行该操作的程序是

下，＃

Code Golf：相当于Excel列名的数字

挑战

测试用例：

67 个答案:

Excel，9个字符：）

Perl， 36 34 33 31 30 17 < / s> 15 11个字符

J， 17 12 10个字符

Brainf * ck，81个字符（无空格）

说明

Ruby 1.8.7， 53 50 46 44 24 17个字符

APL

Excel（不作弊），25个字符

54个字符，加上大量说明

C＃ 156 146 118 Chars

Golfscript - 16个字符

Haskell，50 51 56 chars

k4（kdb +），11个字符

Python， 64 49个字符

JavaScript 1.8：66个字符

Javascript 1.8：72个字符

JavaScript 1.6：83个字符

JavaScript：95个字符

JavaScript：105个字符

Powershell，42个字符

概念说明 - Excelcification

Common Lisp，103 128 个字符

C89,58个字符

C＃， 117 111个字符

C＃，148个字符

Ruby 1.9,21个字符

Perl，34个字符

Ruby，20个字符

PHP - 73 Chars

Java：112 124 个字符

MATLAB：24个字符

PHP，38个字符

APL：7个字符

Smalltalk，72

Perl，120个字符

Lua，61个字符

JavaScript，93个字符

Perl，47个字符（来自stdin）

26个字符中的Ruby解决方案

Excel VBA，19个字符：

K 3.2（13个字符）

直击

订正

原始

Python：88个字符

Java，164个字符

Java，177个字符

Python（47个字符）

dc - 20个字符

F＃92字符：）

真实VBA，216个无空格