Perl, 36 34 33 31 30 17 15 11 символов

$_=()=A..$_

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

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

Уменьшено до 17 с помощью команды echo -n, чтобы избежать вызова chop.

Уменьшено до 15 за счет использования say вместо print.

Уменьшено до 11 за счет использования -p вместо say.

Объяснение: A оценивается в строковом контексте, а A..$_ строит список, начинающийся с «A» и увеличивающийся до входной строки. Perl интерпретирует оператор ++ (и, следовательно, ..) для строк в алфавитном контексте, поэтому, например, $_="AZ";$_++;print выводит BA.

=()= (он же оператор "goatse") заставляет выражение оцениваться в контексте списка и возвращает количество элементов, возвращаемых этим выражением, т. е. $scalar = () = <expr> соответствует @list = <expr>; $scalar = @list.

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

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

=COLUMN()

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

26#.64-~av

Пример:

26#.64-~av  'WTF'
16074

Объяснение:

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

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

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

APL

13 персонажей

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

x←'WTF'

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

26⊥(⎕aV⍳x)-65

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

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

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.

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

Без гольфа:

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

Golfscript - 16 символов

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


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

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

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

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

26/:1+.Q.A?

Объяснение:

• k4 анализирует слева направо
• .Q.A определяется в k4 - это вектор "ABC...XYZ"
• ? - это оператор поиска - индекс первого совпадения для элементов в аргументе y в аргументе x
• +1 для смещения индекса
• 26/: преобразовать в базу 26

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

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

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

но:

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

Powershell, 42 символа

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

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

Scala, 30 символов

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

Пример:

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

C89, 58 знаков

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

Ввод (stdin) должен содержать только A-Z, другие символы (включая символы новой строки) не допускаются.

Разъяснение понятий - Excelcification

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

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

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

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

Perl, 34 символа

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

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

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

Без гольфа:

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

Python - 63 символа

››› f = лямбда z: уменьшить (лямбда x, y: 26 * x + y, [ord (c) -64 для c в z])

››› f («РОФЛ»)

326676

Clojure:

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

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

C:

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

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

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

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

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

Common Lisp, 81 символ

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

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

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

в 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

Рубин, 20 символов

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

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

$ ruby a.rb ABC
731

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 могут придумать что-то гораздо меньшее.

Perl, 47 символов (из стандартного ввода)

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

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)

Lua, 61 символ

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

wazoox:

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

Это напечатает новую строку, чтобы ответ был более читабельным в оболочке.

Smalltalk, 72

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

Яблочный текст: 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

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;

PHP, 38 символов

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

использование, например

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

APL: 7 символов

Сохраните желаемую строку в переменной w:

w←'rofl'

Предполагая, что символы в нижнем регистре:

26⊥⎕a⍳w

Предполагая, что символы в верхнем регистре:

26⊥⎕A⍳w

Смешанный регистр или неуверенный регистр (14 символов, но их можно улучшить):

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

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

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

Предполагает ввод в верхнем регистре (через аргумент командной строки). Очевидный подход без уловок.

dc - 20 символов

(делает наоборот)

dc не может обрабатывать ввод символов, поэтому я закодировал обратное: введите номер столбца и выведите имя столбца:

?[26~64+rd0<LP]dsLxP

dc exccol.dc
326676
 ROFL

Мое решение 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};

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

Python (47 символов)

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

работает только с заглавными буквами

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

Фактор: 47 символов

обратный [26 swap ^ swap 64 - *] сумма индекса карты

Пролог: 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

php 29 символов:

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

• при условии, что register_globals = On
• предполагая error_reporting = 0
• позвонить через веб-сервер? i = A & t = ABC

Python: 88 символов

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

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

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

OOBasic: 178 символов, не считая пробелов в отступах.

пересмотренный

Эта версия проходит все тесты. Я подозреваю, что гольф был бы более успешным, если бы он не «воспользовался» тем фактом, что существует электронная таблица, использующая эту систему нумерации. См. Примечания к исходной версии ниже, чтобы узнать, почему это не особенно полезно. Я не особо старался сократить счет.

Также обратите внимание, что это будет работать только при запуске в качестве макроса из электронной таблицы OO calc по очевидным причинам.

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

Ограничения:

• maximum value of co is AMJ (1024 columns). Anything larger results in an error with a completely uninformative error message.
  • This limitation is also present for the COLUMN() cell function. Presumably this is the maximum number of columns in an OOCalc spreadsheet; I didn't bother scrolling over that far or googling to find out.

Примечания:

• как ни странно, невозможно дать переменной «co» однобуквенное имя. Не уверен, что за этим стоит логика, но, потратив достаточно времени на использование OOBasic, вы перестаете искать логику и начинаете слепо принимать текущее положение вещей (возможно, слишком долго глядя на Солнце).

В любом случае ввод =C("A"), =C("ABC") и т. Д. В ячейку работает для первых четырех тестовых случаев; последние два выдают ошибки.

прямой удар

фильтр: 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}) делает s массивом, содержащим буквы от A до Z

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

$((...)) завершает арифметическое вычисление; ${#s[@]} - количество элементов в массиве $ s

c=${c:1};done;

${c:1} - символы в $ c после первого. done завершает цикл while

echo $i

эм, я забыл

лучше, но сомнительно

Удаление 5 символов «эхо» приведет к тому, что для ввода «ROFL» будет получен

326676: command not found

Также i=0, вероятно, не нужен, если вы уверены, что эта переменная не установлена ​​в вашей текущей оболочке.

F # (37 символов):

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

K 3.2 (13 знаков)

26_sv -64+_ic

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

  26_sv -64+_ic"ROFL"
326676

Объяснение:

• Как упоминалось выше, K вычисляется справа налево, поэтому функция _ic принимает все, что находится справа, и преобразует его в целочисленное значение, включая как отдельные символы, так и векторы символов.
• -64 добавляется к каждому элементу целочисленного вектора, чтобы получить набор базовых значений
• _sv принимает два аргумента: слева - это числовое основание, 26, а справа - целочисленный вектор значений смещения.

Excel VBA, 19 символов:

диапазон ("WTF"). Столбец

Решение Ruby в 26 символов

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

Настоящий 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

Эланг, 53/78

Оболочка, 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).

F # 92 символа :)

let e2n (c: string) = c |> Seq.map (fun x -> (int) x - 64) |> Seq.reduce (fun e a -> a * 26 + e)

Groovy: 51 символ

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

Вызвать как

groovy *scriptname* ROFL

or

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

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

Excel - 99 знаков

Введите как формулу массива - я не считаю добавление в Excel {}

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

как насчет нового языка
с операторами, определенными как

# - вернет = COLUMN () EXCEL в виде строкового числа.

, - читать в строке

. - выпишите строку

тогда программа для этого

, #.