Compito

Costruisci una calcolatrice, che prende qualsiasi stringa, da un file, stdin o altro, e somma tutti i valori dei caratteri.

Esempio

Input
Hello World!

Output
1085

Regole

La calcolatrice deve accettare solo la codifica ASCII.

Vince il codice più corto.

Appunti

Per quanto riguarda il commento di m.buettner, devo dire che non ho pensato alla parte multibyte.
Quindi lo lascio anche come bonus.
Il calcolatore dovrebbe essere eseguito come scritto, quindi non è necessario modificarlo prima di compilare o interpretare.

indennità

Grazie a Synthetica , ecco un altro bonus,

Il programma che ha l'output più basso quando si utilizza il suo codice mentre il suo input vince ottiene una stella.

Non voglio modificarlo completamente.

Se lo scrivi in ​​più per ottenere il valore (giusto) in UTF-8 otterrai una stella.

Il codice che viene eseguito più velocemente sul mio laptop (Lenovo Yoga 13 Intel Core i5 3317U 1,7 Ghz, 8 GB di RAM, 128 GB SSD, Intel HD 4000, Windows 8) diventa una stella.

I codici Web verranno eseguiti prima in IE11 con chakra e poi in FireFox 29.0.1 con SpiderMonkey

Il codice Linux verrà eseguito su un Raspberry Pi con Raspbian.

Il teststring è questo:

q/%8hnp>T%y?'wNb\},9krW &D9']K$n;l.3O+tE*$*._B^s!@k\&Cl:EO1zo8sVxEvBxCock_I+2o6 yeX*0Xq:tS^f)!!7=!tk9K<6#/E`ks(D'$z$\6Ac+MT&[s[]_Y(`<g%"w%cW'`c&q)D$0#C$QGf>?A$iawvc,}`9!('`c&q)D$0#C$QGf>?A$iawvc,}`9!(

Buon divertimento :)

Bonusscoring

Ho intenzione di fare il punteggio a questo sabato, quindi il 07.06.14, tutte le risposte dopo quella data non riceveranno punti bonus;)

Puoi scaricare il codice che userò per i test qui sentiti libero di fork e migliorarlo :)

Piccolo aggiornamento a causa del bonus, il mio laptop è parzialmente rotto, quindi lo farò probabilmente il prossimo fine settimana, mi dispiace davvero per questo :(

GolfScript, 4 caratteri

{+}*

Usa semplicemente l'operatore di piegatura ( *) per aggiungere tutti i caratteri.

Se deve funzionare con la stringa vuota, 9 caratteri:

{{+}*}0if

Grazie a @PeterTaylor per aver fornito una versione alternativa a 6 caratteri che funziona con stringa vuota:

0\{+}/

APL (8)

+/⎕UCS⍞

Spiegazione:

• +/ somma di
• ⎕UCS valori unicode di
• ⍞ input di caratteri

Haskell 36

main=interact$show.sum.map fromEnum

Strumenti Shell + GNU, 29 byte

echo `od -An -tuC`|tr \  +|bc

Prende input da stdin:

$ printf "%s" 'Hello World!' | ./addchars.sh 
1085
$ 

Punteggio personale: 2385

c, 52 byte

c;main(p){while(~(p=getchar()))c+=p;printf("%d",c);}

Compilare con (alcuni avvisi prodotti):

gcc addchars.c -o addchars

Prende input da stdin:

$ printf "%s" 'Hello World!' | ./addchars 
1085 $ 

Proprio punteggio: 4354

Javascript ( ES6 ) 51

alert([...prompt(x=0)].map(y=>x+=y.charCodeAt())|x)

gs2 , 1 byte

d

d( 0x64/ sum), ovviamente, somma tutti i byte nell'input standard.

Python 3 - 28 byte

print(sum(map(ord,input())))

Esempio di esecuzione:

$ ./sum_string.py <<< 'Hello World!'
1085

Ottiene l'input da stdin, mapla ordfunzione ad esso per ottenere il valore ASCII di ogni carattere, sums it e prints.

8086 Assembly (16 bit) - 47 41 byte

I contenuti del test.comfile sono:

98 01 c3 b4 01 cd 21 3c 0d 75 f5 89 c7 c6 05 24
89 d8 b1 0a 4f 31 d2 f7 f1 80 ca 30 88 15 09 c0
75 f2 89 fa b4 09 cd 21 c3

Il lavoro effettivo viene eseguito nei primi 11 byte; Ho bisogno del resto per stampare il risultato in notazione decimale.

Codice sorgente (dare come input debug.comall'assemblatore DOS ):

a
; input the string; count the sum
    cbw
    add bx, ax
    mov ah, 1
    int 21
    cmp al, d
    jne 100
; Prepare for output: stuff an end-of-line marker
    mov di, ax
    mov [di], byte 24
    mov ax, bx
    mov cl, a
; 114
; Divide by 10; write digits to buffer
    dec di
    xor dx, dx
    div cx
    or  dl, 30
    mov [di], dl
    or  ax, ax
    jne 114
; Print the string
    mov dx, di
    mov ah, 9
    int 21
    ret

rcx 29
n test.com
w
q

Alcune note sul codice:

• Gestisce solo una riga (fino al carattere di fine riga 13); si blocca se non c'è fine linea
• Sono supportati solo caratteri a 7 bit (altrimenti i risultati non sono corretti)
• Uscite 0 per input vuoto
• Impossibile gestire un output superiore a 64 KB
• Le istruzioni all'indirizzo 0x10d si sovrascrivono (pura coincidenza)
• Devi usare emulatori DOS come DosBox per assemblare ed eseguire questo programma

CJam, 3 byte (somma 260)

q1b

Puoi provarlo online .
Grazie jimmy23013 per l'aiuto nel tagliare 2 personaggi :)

Spiegazione:

q     read the input into a string  
1b    convert from base 1, treating each character as its numeric value

Befunge98, 6 byte, somma: 445

2j@.~+

Qualsiasi interprete dovrebbe andare bene. Uso CCBI .

Utilizzare come segue:

printf 'Hello World!' | ccbi calc.fg

Funziona con caratteri multibyte e stringhe vuote.

Spiegazione

• 2j- salta le due istruzioni successive ( @e .- vedi sotto)
• ~ - metti il ​​prossimo carattere in pila
• +- aggiungi il valore del codice del nuovo carattere alla somma corrente. Il puntatore dell'istruzione si sposta all'inizio e il ciclo si ripete
• quando ~incontra un EOF, inverte la direzione del puntatore e vengono eseguite le due istruzioni "nascoste":
• . - stampa la somma
• @ - Uscita

Ruby, 13 12 bytes

p~9+gets.sum

sum is a built-in function that sums the characters of a string. Subtracts 10 to account for the newline at the end of gets's return value.

(Edited 4 years later to change x-10 to ~9+x... the value of ~9 is -10, but it lets us remove the space between p and its argument, saving a byte.)

PowerShell - 27

[char[]]$args[0]|measure -s

Example

> SumChars.ps1 'Hello World!'

Count    : 12
Average  : 
Sum      : 1085
Maximum  : 
Minimum  : 
Property : 

Julia - 11 7 characters, resultant sum = 943 536

Since the question allows the input to come from whatever source you want, I choose an existing variable. Assume that A contains the string we wish to evaluate.

sum(A)1

As it turns out, you can sum the string directly, and it will evaluate... however, due to the way that summing of chars is handled, if there is an odd number of characters in the string, it will output a character, rather than an integer of any sort. As such, we force it to cast to int by multiplying by 1.

Old version:

sum(A.data)

Will output in a hexadecimal notation (if the sum is less than 256, it'll be 0x??, otherwise it'll be 8 byte as 0x????????). If used in code where the result is used, it will operate just like any other number (it's just how Julia displays unsigned ints).

To see the value of the result in decimal, enclose the above in int(), as in int(sum(A.data)).

For anybody who doesn't know Julia, you assign to A exactly the same way you do other assignments to variables. So, A="Hello World!" or A="sum(n.data)". In the case where you need to put in " or ' characters, there are multiple options, the easiest of which (because it avoids need for knowledge of the nuances of Julia string literals) is A=readline(), followed by simply typing in the string into STDIN (won't handle newlines, though). The escape sequence for newline is, as usual, \n, but I don't believe you can use that with readline().

K5, 2 bytes (function), 5 bytes (program)

Function

+/

Program

+/0:`

Not sure if K5 was created before or after this challenge was posted. Regardless...THIS IS AWESOME!!

In K5, if you perform arithmetic operations on strings, it converts the characters to their ASCII codes. So this just uses the sum operator +/ (actually, it's plus + over).

Matlab/Octave 4 bytes (bonus: 405)

This code is an anonymous function, that does the job, it will take a string, and return the required number.

@sum

Go (59 characters)

func d(s string)(t int){for _,x:=range s{t+=int(x)};return}

Everything in Go is utf8 by default. Codetext in ` delimeters run through itself gives an output of: 5399.

Jolf, 2 bytes (non-competing)

Try it here!

ui
u  sum of
 i  the input string

Umm... I don't know what else to say.

Gol><>, 4 bytes (non-competing)

Note: this language is newer than the challenge.

iEh+

Javascript ES6, 41 bytes

_=>[..._].map(y=>x+=y.charCodeAt(),x=0)|x

Thanks to @ETHproductions for 2 bytes saved!

Python, 24 bytes

This is shorter than any Python solution so far: an unnamed anonymous function, which takes the string as an argument, and returns the sum.

lambda x:sum(x.encode())

Try it online!

First, x.encode() transforms it into a bytes object. Then, sum adds the char-code values. As this is a lambda function, the value is implicity returned.

Additionally, one could have lambda x:sum(map(ord,x)) for the same byte count.

SML, 42 36

Just adding another language.

fun$x=foldl op+0(map ord(explode x))

Converts String to char array, calculates ascii number of each value and calculates the sum of all ascii numbers.

C 32

f(char*s){return*s?*s+f(s+1):0;}

D (function: 60)

Definitely not in it to win it.

Assuming it doesn't need to be a complete program

int c(string i){int s;foreach(e;i){s+=cast(int)e;}return s;}

Called like so

void main ()
{
    import std.stdio;
    auto hw = "Hello World!";
    writefln("%s = %d", hw, c(hw));
}

Output:

Hello World! = 1085

D (program: 133)

Does not count line breaks.

void main(){import std.algorithm,std.stdio;stdin.byLine.map!((a){int s;foreach(e;a){s+=cast(int)e;}return s;}).reduce!"a+b".writeln;}

With more whitespace and longer variable names for readability

void main () {
    import std.algorithm, std.stdio;

    stdin.byLine
        .map!((line) {
                int sum;
                foreach (ch; line) {
                    sum += cast(int)ch;
                }
                return sum;
            })
        .reduce!"a+b"
        .writeln;
}

To support line breaks in the input, I could either use byLine(KeepTerminator.yes) — the correct way, for 20 characters — or append a '\n' to my line — which breaks single-line input and may give the wrong sum on Windows because of CRLF, for 18 characters.

JavaScript (ES6) 54 58

alert([].reduce.call(prompt(),(v,c)=>v+c.charCodeAt(0),0))

54 bytes thanks to nderscore:

alert([...prompt()].reduce((v,c)=>v+c.charCodeAt(),0))

Delphi (87 83)

function x(s:string):int64;var c:char;begin x:=0;for c in s do x:=result+ord(c)end;

Ungolfed

function x(s:string):int64;
var
  c:char;
begin
  x:=0;
  for c in s do
    x:=result+ord(c)
end;

Loops through S adding the ord value of the char to the result. where x==result

Edits:

Saved 4 characters by switching to int64 and changing the adding to the sum.

k (8 chars)

+/6h$0:0

Q translation

sum `int$read0 0

Bonus value:

k)+/6h$0:0
+/6h$0:0
438i

J (7)

So close, yet so far... Oh well, I guess 7 is decent enough, since this answer also accepts empty strings. (I'm basing my usage of a variable as input on the phrase from a file, stdin or whatever)

+/a.i.b

Explanation:

a.

┌┬┐├┼┤└┴┘│─ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~��������������������������������������������������������������������������������������������������������������������������������

a. contains all ASCII chars.

   'people' i. 'pow'
0 2 6

x i. y is similar to python's [x.index(i) for i in y].

   a. i. 'Hello World!'
72 101 108 108 111 32 87 111 114 108 100 33

Therefor, a. i. y converts y to an array of its ASCII values

   +/1 2 3 4 5 6
21

+/ is like sum: +/1 2 3 4 5 6 means 1+2+3+4+5+6

   +/ a. i. 'Hello World!'
1085

The whole thing in action

For the bonus:

   b=:'+/a.i.b'
   +/a.i.b
482

Not bad, I guess.

   b=:'0\{+}/'
   +/a.i.b
478

Well, darn.

   A=:'+/a.i.A'
   +/a.i.A
449

Thanks @algorithmshark

    A=:'+/3 u:A'
    +/3 u:A
413

Thanks @marinus

R, 35 characters (sum of 3086) 26 bytes (sum of 2305)

sum(utf8ToInt(readline()))

readline() is one character longer than scan(,"") but scan split the input on spaces by default.

Usage:

> sum(utf8ToInt(readline()))
Hello World!
[1] 1085
> sum(utf8ToInt(readline()))
sum(utf8ToInt(readline()))
[1] 2305
> sum(utf8ToInt(readline()))
q/%8hnp>T%y?'wNb\},9krW &D9']K$n;l.3O+tE*$*._B^s!@k\&Cl:EO1zo8sVxEvBxCock_I+2o6 yeX*0Xq:tS^f)!!7=!tk9K<6#/E`ks(D'$z$\6Ac+MT&[s[]_Y(`<g%"w%cW'`c&q)D$0#C$QGf>?A$iawvc,}`9!('`c&q)D$0#C$QGf>?A$iawvc,}`9!(
[1] 14835

Japt, 6 bytes (non-competing)

This answer is non-competing because Japt was created after this challenge was posted.

U¬mc x

Pretty simple. Try it online!

How it works

U¬mc x  // Implicit: U = input string
U¬      // Split U into chars.
  mc    // Map each item to its char code.
     x  // Sum.
        // Implicit: output last expression

PlatyPar, 2 bytes (non-competing)

us

Try it online!

u generates an array of all charcode values in the input string, and s finds their sum.

When run on itself, it returns 232.

This is similar to Conor's Jolf answer, except that I use a byte to convert the string into an array of character codes (which is implicit in Jolf), whereas he uses a byte to retrieve the input (which is implicit in PlatyPar).