Mio padre è un insegnante in pensione, ed era solito fare quiz di ortografia e matematica combinati, in cui lo studente scriveva una parola, e poi "segnava" la parola sommando le lettere, dove a = 1, b = 2, ecc. (es. gatto = 3 + 1 + 20 = 24). Ciò ha reso più semplice la valutazione dei quiz, poiché avrebbe dovuto solo verificare la presenza di "punteggi" errati anziché parole errate e avrebbe avuto l'ulteriore vantaggio di testare 2 abilità contemporaneamente.

Ha assunto un mio amico per scrivere un programma che segnasse le parole per lui, in modo da poter generare lunghe chiavi di risposta senza errori. Questo problema è ispirato da quel programma.

Requisiti:

1. Accetta qualsiasi parola con lettere maiuscole e minuscole
2. Restituisce un errore per eventuali caratteri speciali, ad esempio spazi, trattini, @ ^% # ecc.
3. a = 1, b = 2, ... e A = 1, B = 2, ...
4. Stampa il punteggio della parola
5. (Facoltativo) controlla che la parola sia in un dizionario dopo il punteggio e, se non lo è, stampa un avviso.
6. Nessuna importazione di un dizionario di lettere-> numeri esterni. Devi generarlo tu stesso.

Qualsiasi lingua è accettabile Questo è simile alla " battaglia della radice digitale ", ma molto più semplice.

Golfscript - 23 caratteri

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

Accertarsi che non siano presenti nuove righe finali nell'input (ad es. Uso echo -n).

Brainf *** (100)

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

Devo ammettere però che ciò non è del tutto conforme a tutti i requisiti. Innanzitutto, accetta solo lettere maiuscole e la parola deve terminare con una scheda. Ha un comportamento indefinito per i caratteri non validi e non genera un errore. Visualizza la somma delle lettere come carattere ASCII. Ad esempio, se la parola è "CIAO", (8 + 5 + 12 + 12 + 15 = 52) verrà visualizzato il carattere "4", che è il carattere ASCII per 52. Ciò significa anche che il programma si spaventa quando la somma è superiore a 255.

Ma a parte questo , funziona benissimo. Dammi una pausa, il mio cervello può gestire solo piccole dosi di ... beh, lo sai.

Python ( 65 64)

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

Ciò genera un errore se la parola contiene caratteri non di lettera, ma non utili o informativi. (Modifica: punta del cappello per bloccare il trucco dell'indicizzazione.)

Rubino, 43 caratteri

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

Il messaggio di errore che questo genera non è esattamente utile, però. Entrambe le soluzioni pubblicate qui presuppongono che l'input non abbia interruzioni di riga finali, quindi per testarle, utilizzare echo -n.

Rubino, 76 caratteri con controllo dizionario

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

Il messaggio di avviso è costituito dal singolo carattere "W". Il percorso del dizionario deve essere fornito tramite ARGV. Esempio di utilizzo:

$ 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 caratteri) Senza controllo del dizionario

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

Python 2.6 (178 caratteri *) Con controllo dizionario

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

_{* Può essere abbassato a 156 con un messaggio di errore meno utile. :-)}

Grazie a tutti i commentatori per aver contribuito a migliorare questo.

Perl (52) (48)

giocare a golf ancora di più grazie a Timwi

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

Python (80)

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

Python v2 (65 ma char `verrà accettato)

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

v3 (60 caratteri, @ saranno accettati ma non conteggiati, grazie jloy)

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

Scala: 59 caratteri, 7 dei quali payload, no dict:

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

Nessun dizionario finora. Il risultato negativo significa: Negativo!

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

Gestisce con grazia German Umlaute, tra l'altro:

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

Librerie Java + Google Guava, 347 caratteri, con controllo dizionario

Versione illeggibile 1 stringa lunga :-)

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

Versione leggibile dall'uomo (sorta di :-))

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

Il percorso del dizionario ora viene passato tramite a[1], per far funzionare le asserzioni devi usare il -eaflag (+3 altri caratteri). Per quanto riguarda il dizionario, /usr/share/dict/wordsè stato utilizzato il dict (dovrebbe essere disponibile sulla maggior parte dei sistemi * nix).

Python 3, 95 caratteri con dizionario

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

Il dizionario deve trovarsi in un file chiamato d.

Python 3, 61 senza dizionario, ma idea rubata

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

Modifica: con la convalida è:

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

129 caratteri. In quale caso:

C #, 118

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

Migliorare leggermente la risposta di 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 caratteri

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

L'errore che genera non è esattamente il migliore, ma ehi, interrompe l'esecuzione.

PITONE 62 68 * Personaggi

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

Richiede all'utente di inserire stringhe utilizzando le virgolette e non è sicuro (input esegue il codice), ma, come ho detto in un commento a un altro post, "user-friendly" e "non un rischio per la sicurezza" non sono nelle specifiche!

_{* Mi sono dimenticato print, dannazione.}

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)

Fornisce un errore sui caratteri errati, ma non molto buono (50 caratteri):

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

Fornisce invece "E" in caso di errore (53 caratteri):

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

Lo snippet che genera l'alfabeto 123,97>+viene rubato da Ventero.

J (55)

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

Questo soddisfa tutte le condizioni tranne quella del dizionario. Come condizione di errore, restituisce "infinito" (il simbolo di sottolineatura in J) per le parole che contengono altro che lettere.

Haskell (127)

(genera un errore su caratteri strani)
(anche: lo spazio tra toUpper.ed \xè necessario altrimenti lo analizza come (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)

(non genera un errore, ma il 45% in meno)

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

Il "set up" / etc:

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

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

Comportamento "non definito" (è più una "cattiva pratica" che "non definito", ma vabbè):

• void main() Questo dice tutto.
• Sto usando newsenza delete.

JavaScript 1.8, 80 caratteri

Sorprendentemente leggibile!

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

APL (34)

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

Fornisce il punteggio o un VALUE ERRORse ci sono caratteri non alfabetici nell'input.

Spiegazione:

• ⍞: legge una riga di input
• {... }: funzione applicata ad ogni carattere di input
• A←⎕UCS⍵: memorizza il valore ASCII del carattere corrente in A
• A-32×96<A: fa il carattere maiuscolo: da Aviene sottratto 32 if 96<A(quindi, se è maiuscolo), altrimenti 0
• 64-⍨: sottrai 64 da questo, dando A = 1, B = 2 ...
• ¨: applica questa funzione ad ogni personaggio:
• ⍵∊⍳26: se il personaggio è compreso tra 1 e 26 ...
• :⍵: poi restituisce ⍵ (e poiché non c'è altra clausola, ci sarà un VALUE ERRORse non è tra 1 e 26)
• +/: somma tutti i valori insieme (e questo valore viene automaticamente emesso perché è il risultato finale).

JavaScript, 60 byte

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

Se il programma deve restituire un errore su input non validi, quindi 80 byte:

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

Se un input non è valido, la console dirà che _non è definito (non ci deve essere già una variabile definita chiamata _).

Python 3, 58 55

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

senza dizionario o idea rubata ma errore ancora inutile;)

grazie @ Eᴀsᴛᴇʀʟʏ

Prova qui .

C, 98 byte

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

F # (nessuna convalida) 79 57 caratteri

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

C # con convalida: 108 caratteri (con 12 per messaggio di errore):

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

C # senza convalida: 60 53 caratteri:

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