我父亲是一位退休的老师，他经常提供拼写和数学测验的组合，学生可以在其中拼写一个单词，然后通过将字母加起来（其中a = 1，b = 2等）来“打分”该单词。 （例如cat = 3 + 1 + 20 = 24）。这使对测验进行评分变得更加容易，因为他只需要检查“分数”而不是拼写错误的单词即可，并且具有一次测试2个技能的额外好处。

他雇用了我的一个朋友来编写一个程序，该程序可以为他打分，因此他可以生成冗长的答案键而不会出错。该问题是受该程序启发的。

要求：

1. 接受任何带有大写和小写字母的单词
2. 返回任何特殊字符的错误，例如空格，连字符，@ ^％＃等。
3. a = 1，b = 2，...和A = 1，B = 2，...
4. 打印单词的分数
5. （可选）在计分后检查单词是否在字典中，如果不是，则打印警告。
6. 无需导入外部字母->数字字典。您必须自己生成它。

任何语言都是可以接受的。这类似于“ 数字根战 ”，但要简单得多。

Golfscript-23个字符

0\{.31&.(.26%=@64///+}/

确保输入中没有结尾的换行符（例如use echo -n）。

Brainf ***（100）

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

我必须承认，这并不完全符合所有要求。首先，它仅接受大写字母，并且该单词必须以制表符结尾。对于无效字符，它具有未定义的行为，并且不会引发错误。它将字母的总和显示为ASCII字符。例如，如果单词是“ HELLO”，（8 + 5 + 12 + 12 + 15 = 52），它将显示字符“ 4”，它是52的ASCII字符。这也意味着程序在总和超过255。

但是除此之外，它还可以。休息一下，我的大脑只能承受小剂量的...嗯，你知道的。

巨蟒（65 64）

print sum(['',ord(i)-64]['@'<i<'[']for i in raw_input().upper())

如果单词包含非字母字符，但没有帮助或提示性的字符，则会引发错误。（编辑：将帽子的尖端固定在索引技巧上。）

Ruby，43个字符

$_=gets.upcase;p~/[^A-Z]/?_: $_.sum-64*~/$/

但是，生成的错误消息并不是完全有用。此处发布的两个解决方案均假设输入没有尾随换行符，因此，请使用测试它们echo -n。

Ruby，76个字符，带字典检查

l=STDIN.gets;$_=l.upcase;p~/[^A-Z]/?_: $_.sum-64*~/$/;[*$<].index(l)||$><<?W

警告消息由单个字符“ W”组成。字典的路径必须通过ARGV提供。用法示例：

$ echo -n asd | ruby addletters.rb /usr/share/dict/words
24
W
$ echo -n cat | ruby addletters.rb /usr/share/dict/words
24

Python 2.6（72个字符），无字典检查

print sum(map(" abcdefghijklmnopqrstuvwxyz".index, raw_input().lower()))

带有字典检查功能的Python 2.6（178个字符*）

w=raw_input().lower()
print sum(map(" abcdefghijklmnopqrstuvwxyz".index, w))
if w not in open('/usr/share/dict/american-english').read().split():
 print('Word not in dictionary')

_{*可以将其降低到156，并显示一条不太有用的错误消息。:-)}

感谢所有评论者帮助改善此问题。

Perl （52）（48）

多亏了Timwi才打高尔夫球

perl -lpe "($w=uc)=~/[^A-Z]/&¨$w=~s/./$_-=64-ord$&/ge"

巨蟒（80）

w=raw_input().lower()
s=0
for l in w:s+=range(97,123).index(ord(l))+1
print s

Python v2（65，但char`将被接受）

print sum(map(range(96,123).index,map(ord,raw_input().lower())))

v3（60个字符，@将被接受，但不计算在内，谢谢jloy）

print sum(map(range(64,91).index,map(ord,input().upper())))

Scala：59个字符，其中7个有效载荷，无字典：

(0/:"Payload".map(c=>if(c.isLetter)(c-'A')%32 else-999))(_+_)
67

到目前为止没有字典。负结果表示：负！

(0/:"Pay!wall?".map(c=>if(c.isLetter)(c-'A')%32 else-999))(_+_)   
-1915

顺便优雅地处理德国Umlaute：

(0/:"Müllrößchen".map(c=>if(c.isLetter)(c-'A')%32 else-999))(_+_)
155

Java + Google Guava库，347个字符，带有字典检查

无法读取的1个长字符串版本:-)

import java.io.*;import com.google.common.base.*;import com.google.common.io.*;class C{public static void main(String[]a)throws Exception{int s=0;for(int c:a[0].toUpperCase().toCharArray()){assert(c>64&&c<91);s+=c-64;}String d=Files.toString(new File(a[1]),Charsets.UTF_8);if(StringUtils.containsIgnoreCase(d,a[0]))System.out.println("w");System.out.println(s);}}

易于阅读的版本（：-）

import java.io.*;

import com.google.common.base.*;
import com.google.common.io.*;

class C {
    public static void main(String[] a) throws Exception {
        int s=0;

        for(int c : a[0].toUpperCase().toCharArray()) {
            System.out.println(c);
            assert(c > 64 && c < 91);
            s += c - 64;
        }

        String d = Files.toString(new File(a[1]), Charsets.UTF_8);

        if (d.contains(a[0])) System.out.println("w");

        System.out.println(s);
    }
}

现在，通过传递了字典路径a[1]，为了使断言起作用，您必须使用-ea标志（+3个以上的字符）。至于字典，已使用字典/usr/share/dict/words（在大多数* nix系统上应该可用）。

Python 3，95个字符，带字典

d=input().lower()
print(d in open("d").read()and sum(['',ord(c)-96]['`'<c<'{']for c in d)or'f')

字典必须在名为d的文件中。

Python 3，61，没有字典，但主意被盗

print(sum(['',ord(c)-96]['`'<c<'{']for c in input().lower()))

佩尔（71）

($a)=lc<>;$a=~/[^a-z]/i&&die;$x+=ord$_ for split//,$a;die$x-96*length$a;

VB.NET，84 82 73 71

Console.Write(Console.ReadLine.Sum(Function(c)Asc(Char.ToUpper(c))-64))

编辑：验证为：

Dim r=Console.ReadLine
Console.Write(If(r.All(AddressOf Char.IsLetter),r.Sum(Function(c)Asc(Char.ToUpper(c))-64),"Invalid input."))

129个字符。在这种情况下：

C＃，118

var r=Console.ReadLine();Console.Write(r.All(char.IsLetter)?r.Sum(c=>char.ToUpper(c)-64).ToString():"Invalid input.");

略微提高了约翰的答案：Python（90）

s=0
for i in raw_input().lower():
 s+=("abcdefghijklmnopqrstuvwxyz".index(i)+1)
print(s)

Erlang，104岁

a()->
a(string:to_lower(io:get_line([])),0).
a([_|[]],S)->
S;
a([C|R],S) when C<${, C>=$`->
a(R,S+C-$`).

Golfscript - 39 chars

n%~{.96>{96}{64}if-..26>\0<|{0/}*}%{+}*

The error it throws is not exactly the best, but hey, it aborts execution.

PYTHON 62 68* Characters

print sum(map(chr,range(65,91)).index(c)+1 for c in input().upper())

Requires user to input strings using quotes, and is not safe (input executes code), but, as I said in a comment to another post, "user-friendly" and "not a security risk" ain't in the spec!

_{* I forgot about print, dammit.}

Ruby 1.9, 69

w=gets.chop.upcase
w[/[^A-Z]/]&&fail
p w.bytes.inject(0){|s,b|s+b-64}

GolfScript, 50(53)

Gives an error on bad characters, but not a very good one (50 characters):

);[{""123,97>+91,65>+?}/].-1?0<{{26%1+}%{+}*}{@}if

Gives "E" on error instead (53 characters):

);[{""123,97>+91,65>+?}/].-1?0<{{26%1+}%{+}*}{;"E"}if

The alphabet-generating snippet 123,97>+ is stolen from Ventero .

J (55)

+/64-~-&32`]@.(<&97)`_:@.(<&65)`_:@.(>&122)"0,I.a.&e."0

This satisfies all the conditions except the dictionary one. As an error condition, it returns "infinity" (the underscore symbol in J) for words that contain anything but letters.

Haskell (127)

(raises an error on weird characters)
(also: the space between toUpper. and \x is needed otherwise it parses it as(toUpper) .\ (x))

import Char
main=getLine>>=putStrLn.show.sum.(map$(-65+).ord.toUpper. \x->if x`elem`['A'..'Z']++['a'..'z']then x else error"")

Haskell (70)

(does not raise an error, but 45% shorter)

import Char
main=getLine>>=putStrLn.show.sum.(map$(-65+).ord.toUpper)

C++ (111 107)

void main(){int a=0;s8*b=new s8[99];for(cin>>b;*b;)if(isalpha(*b))a+=tolower(*b++)-96;else return;cout<<a;}

The "set up"/etc:

#include <iostream>
#include <cstdio>
#include <cctype>

#ifdef _MSC_VER
    typedef __int8 s8;
#else
    typedef signed char s8;
#endif

"Undefined" behavior (It's more 'bad practice' than 'undefined', but oh well):

• void main() That says it all.
• I'm using new without delete.

JavaScript 1.8, 80 chars

Surprisingly readable!

alert(Array.reduce(prompt().toLowerCase(),function(a,b)a+b.charCodeAt(0)-96,0))

APL (34)

+/{⍵∊⍳26:⍵}¨{64-⍨A-32×96<A←⎕UCS⍵}⍞

Gives either the score, or a VALUE ERROR if there are non-alphabetic characters in the input.

Explanation:

• ⍞: read a line of input
• {...}: function applied to every character of input
• A←⎕UCS⍵: store the ASCII value of the current character in A
• A-32×96<A: make character uppercase: from A is subtracted 32 if 96<A (so, if it's uppercase), otherwise 0
• 64-⍨: subtract 64 from this, giving A=1, B=2 ...
• ¨: apply this function to every character:
• ⍵∊⍳26: if the character is between 1 and 26...
• :⍵: then return ⍵ (and since there's no else clause there will be a VALUE ERROR if it's not between 1 and 26)
• +/: sum all the values together (and this value is automatically outputted because it's the final result).

JavaScript, 60 bytes

s=>[...s.toUpperCase()].reduce((a,b)=>a+b.charCodeAt()-64,0)

If the program must return an error on invalid inputs, then 80 bytes:

s=>/[^a-z]/i.test(s)?_:[...s.toUpperCase()].reduce((a,b)=>a+b.charCodeAt()-64,0)

If an input is invalid, then the console will say that _ is not defined (there must not already be a variable defined called _).

Python 3, 58 55

print(sum(ord(x)%32for x in input()if x.isalpha()or z))

without dictionary or stolen idea but still unhelpful error ;)

thx @Eᴀsᴛᴇʀʟʏ

Test here.

C, 98 bytes

 int a(char *s){int b=0;while(*s){if(!isalpha(*s))throw 1;b+=(toupper(*(s++))-64);}printf("%d",b);}

F# (no validation) 79 57 chars

let a w=w|>Seq.fold(fun a b->a+(int b)-65)0|>printfn"%i"

C# with validation: 108 chars (with 12 for error message):

var s=Console.ReadLine();Console.Write(s.All(Char.IsLetter)?s.Sum(x=>x&'_'-'@').ToString():"Invalid input");

C# without validation: 60 53 chars:

Console.Write(Console.ReadLine().Sum(x=>x&'_'-'@'));

Perl (42 31)

perl -F -pale '$c+=ord(uc$_)-64for@F;$_=$c'

I hope counting F, p, a and l as 1 character was correct.

JavaScript, 68 Bytes

This can almost certainly be golfed more

w=>[...w.toLowerCase()].map(v=>v.charCodeAt()-96).reduce((a,b)=>a+b)

With dictionary check (Node.js & Unix Descendants only) 195 Bytes

Uses /usr/share/dict/words, and can definitely be shortened (see the warn message)

w=>(require("fs").readFile("/usr/share/dict/words",(e,t)=>!(t+"").split`
`.includes(w=w.toLowerCase())&&console.warn(w+" not found in dict")),[...w].map(v=>v.charCodeAt()-96).reduce((a,b)=>a+b))