C # 156 146 118 символов

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

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

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

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

Perl, 34 символа

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

Спасибо mobrule за несколько предложений.

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

Haskell, 50 51 56 символы

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

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

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

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 #!

J , 17 12 10 символов

26#.64-~av

Пример:

26#.64-~av  'WTF'
16074

Пояснение:

• J анализирует справа налево.
• av возвращает список индексов ascii каждого из символов в своем аргументе, так, например, av'ABC ' возвращает 65 66 67 .
• Затем мы вычитаем 64 из каждого элемента этого списка с помощью глагола 64- ~ .
• Затем мы преобразуем список в базу 26, используя #. глагол.

Powershell, 42 символа

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

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

Объяснение концепций - Excelcification

Ницца. Я написал свою собственную версию этого с небольшими пояснениями давным-давно по адресу http://aboutdev.wordpress.com/2009/12/19/excelcification-brain-teaser-code/ . Хотя это не совсем оптимизированная версия!

К вашему сведению. Арифметика с основанием 26 называется шестнадцатеричной , а максимальный столбец Excel - XFD , который преобразуется в 16383 (с использованием 0 в качестве первой ячейки), что по совпадению точно 2 ^ 14 клетки .

Кто-нибудь может догадаться, почему это 2 ^ 14 ??

APL

13 символов

Поместите значение в x :

x←'WTF'

, затем вычислите его с помощью:

26⊥(⎕aV⍳x)-65

Единственная причина, по которой J победил меня, - это круглые скобки. Я думаю, что должен быть способ переставить его, чтобы они не понадобились, но это был долгий день. Идеи?

(Хех, вы, программисты Perl с вашими 30+ символами, такие милые!)

C89, 58 символов

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

Ввод (стандартный ввод) должен содержать только AZ, никаких других символов (включая новые строки) разрешены.

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

Clojure:

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

51 символ плюс количество символов во входной строке.

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

Golfscript - 16 символов

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


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

Scala, 30 символов

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

Пример:

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

Python - 63 символа

>>> f = lambda z: reduce (lambda x, y: 26 * x + y, [ord (c) -64 for c in z])

>>> f ('ROFL')

326676

MATLAB: 24 символа

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

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

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

ans =

       16074

Примечание: вы можете уменьшить его до 16 символов, если предварительно сохранить строку в x , но я подумал, что это обман:

>> x = 'WTF'

x =

WTF

>> polyval(x-64,26)

ans =

       16074

PHP - 73 символа

$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

C #, 117 111 символов

Нет соревнования по сравнению с подобными Perl, Ruby и APL, но это улучшение по сравнению с другими ответами C # / Java, приведенными до сих пор.

Здесь используется правило Хорнера .

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

C:

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

Строка хранится в 'c', значение - в 'r'.

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

Excel, 9 символов :)

Используйте подходящий инструмент для работы:

=COLUMN()

k4 (kdb +), 11 символов

26/:1+.Q.A?

Пояснение:

• k4 анализирует слева направо
• .QA определяется в k4 - это вектор «ABC ... XYZ»
• ? это оператор поиска - индекс первого совпадения для элементы в аргументе y в аргументе x arg
• +1 для смещения индекса
• 26 /: для преобразования в основание 26

Одно предостережение - это будет работать только в том случае, если перечисленные типы передаются в:

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

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

, но:

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

Common Lisp, 81 символ

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

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

Excel (не мошенничество), 25 символов

Поддерживает до XFD:

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

Установка:

2. Поместите формулу в ячейку A2.

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

1. Введите строку столбца в ячейку A1.
2. Прочтите результат в ячейке A2.

54 символа, плюс множество инструкций

Также поддерживает ROFL:

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

Установка:

1. Очистить всю электронную таблицу.
2. Поместите формулу (A2) в ячейку A2.
3. Поместите формулу (B2) в ячейку B2.
4. Заполните формулу (B2) как можно глубже.

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

4. Введите строку столбца в ячейку A1.
5. Прочтите результат в ячейке A2.