Mi padre es un maestro retirado, y solía dar exámenes combinados de ortografía y matemáticas, donde el alumno deletreaba una palabra y luego 'puntuaba' la palabra sumando las letras, donde a = 1, b = 2, etc. (p. ej. cat = 3 + 1 + 20 = 24). Esto facilitó la calificación de los cuestionarios, ya que solo tendría que verificar las 'puntuaciones' incorrectas en lugar de las palabras mal escritas, y tuvo el beneficio adicional de probar 2 habilidades a la vez.

Contrató a un amigo mío para que escribiera un programa que calificara palabras para él, de modo que pudiera generar largas respuestas sin errores. Este problema está inspirado en ese programa.

Requisitos:

1. Acepta cualquier palabra con letras mayúsculas y minúsculas
2. Devuelve un error para cualquier carácter especial, es decir, espacios, guiones, @ ^% # etc.
3. a = 1, b = 2, ... y A = 1, B = 2, ...
4. Imprime el puntaje de la palabra
5. (Opcional) verifique que la palabra esté en un diccionario después de la puntuación e imprima una advertencia si no lo está.
6. No importa un diccionario externo de letras-> números. Debes generarlo tú mismo.

Cualquier idioma es aceptable. Esto es similar a la ' batalla raíz digital ', pero mucho más simple.

Golfscript - 23 caracteres

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

Asegúrese de que no haya nuevas líneas finales en la entrada (por ejemplo, uso echo -n).

Brainf *** (100)

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

Sin embargo, debo admitir que esto no cumple con todos los requisitos. Primero, solo acepta letras mayúsculas, y la palabra debe terminar con una pestaña. Tiene un comportamiento indefinido para caracteres no válidos y no arroja un error. Muestra la suma de las letras como un carácter ASCII. Por ejemplo, si la palabra es "HOLA", (8 + 5 + 12 + 12 + 15 = 52) mostrará el carácter "4", que es el carácter ASCII para 52. Esto también significa que el programa se asusta cuando la suma es más de 255.

Pero aparte de eso , funciona bien. Dame un respiro, mi cerebro solo puede manejar pequeñas dosis de ... bueno, ya sabes.

Pitón ( 65 64)

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

Esto genera un error si la palabra contiene caracteres que no son letras, pero no es útil o informativo. (Editar: punta del sombrero para evitar el truco de indexación).

Ruby, 43 caracteres

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

Sin embargo, el mensaje de error que esto genera no es exactamente útil. Ambas soluciones publicadas aquí suponen que la entrada no tiene salto de línea final, así que para probarlas, use echo -n.

Ruby, 76 caracteres con verificación de diccionario

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

El mensaje de advertencia consta del carácter único "W". La ruta al diccionario se debe proporcionar a través de ARGV. Ejemplo de uso:

$ 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 caracteres) Sin verificación de diccionario

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

Python 2.6 (178 caracteres *) con verificación de diccionario

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

_{* Se puede bajar a 156 con un mensaje de error menos útil. :-)}

Gracias a todos los comentaristas por ayudar a mejorar esto.

Perl (52) (48)

golf aún más gracias a Timwi

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

Pitón (80)

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

Python v2 (65 pero char `será aceptado)

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

v3 (60 caracteres, @ serán aceptados pero no contados, gracias jloy)

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

Scala: 59 caracteres, 7 de ellos carga útil, sin dict:

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

No hay diccionario hasta ahora. Resultado negativo significa: ¡Negativo!

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

Maneja el Umlaute alemán con gracia, por cierto:

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

Bibliotecas Java + Google Guava, 347 caracteres, con verificación de diccionario

Versión de 1 cadena larga ilegible :-)

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

Versión legible para humanos (tipo de :-))

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

La ruta del diccionario ahora se pasa a través de a[1], para que las aserciones funcionen, debe usar la -eabandera (+3 caracteres más). En cuanto al diccionario, /usr/share/dict/wordsse ha utilizado el dict (debería estar disponible en la mayoría de los sistemas * nix).

Python 3, 95 caracteres con diccionario

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

El diccionario tiene que estar en un archivo llamado d.

Python 3, 61 sin diccionario, pero idea robada

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

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

Editar: Con validación es:

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

129 caracteres. En ese caso:

C #, 118

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

Mejorando ligeramente la respuesta de John: 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 caracteres

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

El error que arroja no es exactamente el mejor, pero bueno, aborta la ejecución.

PYTHON 62 68 * Personajes

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

Requiere que el usuario ingrese cadenas usando comillas, y no es seguro ( inputejecuta el código), pero, como dije en un comentario en otra publicación, "no es fácil de usar" y "no es un riesgo de seguridad" no está en la especificación.

_{* Me olvidé print, maldita sea.}

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)

Da un error en los caracteres incorrectos, pero no uno muy bueno (50 caracteres):

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

Da "E" en caso de error (53 caracteres):

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

El fragmento generador de alfabeto 123,97>+es robado de Ventero.

J (55)

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

Esto satisface todas las condiciones excepto la del diccionario. Como condición de error, devuelve "infinito" (el símbolo de subrayado en J) para palabras que contienen cualquier cosa menos letras.

Haskell (127)

(genera un error en caracteres extraños)
(también: el espacio entre toUpper.y \xes necesario, de lo contrario lo analiza como (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)

(no genera un error, pero es un 45% más corto)

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

La "configuración" / etc:

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

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

Comportamiento "indefinido" (es más 'mala práctica' que 'indefinido', pero bueno):

• void main() Eso lo dice todo.
• Estoy usando newsin delete.

JavaScript 1.8, 80 caracteres

Sorprendentemente legible!

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

APL (34)

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

Da la puntuación o un VALUE ERRORsi hay caracteres no alfabéticos en la entrada.

Explicación:

• ⍞: lee una línea de entrada
• {... }: función aplicada a cada carácter de entrada
• A←⎕UCS⍵: almacena el valor ASCII del carácter actual en A
• A-32×96<A: hace que el carácter sea mayúscula: de Ase resta 32 si 96<A(entonces, si es mayúscula), de lo contrario 0
• 64-⍨: resta 64 de esto, dando A = 1, B = 2 ...
• ¨: aplica esta función a cada personaje:
• ⍵∊⍳26: si el personaje tiene entre 1 y 26 ...
• :⍵: luego devuelve ⍵ (y dado que no hay otra cláusula, habrá un VALUE ERRORsi no está entre 1 y 26)
• +/: suma todos los valores juntos (y este valor se genera automáticamente porque es el resultado final).

JavaScript, 60 bytes

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

Si el programa debe devolver un error en entradas no válidas, entonces 80 bytes:

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

Si una entrada no es válida, la consola dirá que _no está definida (no debe haber una variable definida llamada _).

Pitón 3, 58 55

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

sin diccionario o idea robada pero todavía error inútil;)

thx @ Eᴀsᴛᴇʀʟʏ

Prueba aquí .

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 # (sin validación) 79 57 caracteres

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

C # con validación: 108 caracteres (con 12 para mensaje de error):

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

C # sin validación: 60 53 caracteres:

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

Perl (42 31)

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

Espero contar F, p, a y l como 1 carácter fue correcto.

JavaScript, 68 bytes

Esto casi seguro se puede jugar más al golf

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

Con comprobación de diccionario (Node.js y descendientes de Unix únicamente) 195 bytes

Usos /usr/share/dict/words, y definitivamente se puede acortar (ver el mensaje de advertencia)

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