Calculator that adds char values

Question

Task

Build a calculator, that takes any string, from a file, stdin or whatever, and adds up all the values of the chars.

Example

Input
Hello World!

Output
1085

Rules

The calculator needs to accept just ASCII encoding.

The shortest code wins.

Notes

Regarding to the comment of m.buettner, I need to say, I didn't thought of the multibyte part.
So I leave it as a bonus thing aswell.
The calculator should be run as written, so no need to modify before compiling or interpreting.

Bonus

Thanks to Synthetica, here is one more bonus,

The program that has the lowest output when you use its code as its input wins gets a star.

I don't want to modify it completly.

If you write it additional to output the (right) value in UTF-8 you get a star.

The code that executes fastest on my Laptop (Lenovo Yoga 13 Intel Core i5 3317U 1.7Ghz, 8GB RAM, 128GB SSD, Intel HD 4000, Windows 8) gets a star.

Web codes will run first under IE11 with chakra and then in FireFox 29.0.1 with SpiderMonkey

Linux code will run on a Raspberry Pi with Raspbian.

The teststring is this:

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

Have fun coding :)

Bonusscoring

I plan to do the scoring at this Saturday so the 07.06.14, all answers after that date won't get bonus points ;)

You can download the code I gonna use for testing here feel free to fork and improve it :)

Little update because of the bonus, my laptop is partially broken so I will do it probably next weekend, I am really sorry for that :(

Answer 1

Mathcad, 13 "bytes"

Uses built-in vector summation operator and string-to-vectorOfCharacterCodes function. Definition operator ":=" entered by single key ":", summation operator by ctl-4.

Answer 2

Python 3, 37 bytes

print(sum([ord(c) for c in input()]))

There's a shorter one, but this is possible as well. It converts the string into a list will all the ASCII values of the characters and adds them together using sum().

Star version, 55 bytes

a=sum([ord(c) for c in input()]);print(a);print(chr(a))

Now gimme my gold star.

Answer 3

Clojure, 31 bytes

#(reduce +(map int(read-line)))

Really straightforward. Gets its input from stdin, works with Unicode.

Answer 4

Hoon, 18 bytes

|*
*
(roll +< add)

This is a wet gate, so that I don't have to specify tape instead of *. This has the added bonus of it being fully generic, so it could actually accept (list @ud) too. Wet gates typecheck at the call site, instead of definition.

+< is the sample of the gate, indexed into the sample with tree navigation syntax because it's shorter than naming the function arguments. |*(a/* a) is longer than |*(* +<).

> %.  "Hello World!"
  |*
  *
  (roll +< add)
b=1.085

Unfortunately, this doesn't work correctly as-is with unicode. Urbit's string literals are lists of UTF8 chars. You can use ++tuba to convert it to UTF32, though.

> %.  "⚳ℚ⊻"
  |*
  *
  (roll +< add)
b=1.622

> %.  (tuba "⚳ℚ⊻")
  |*
  *
  (roll +< add)
b=27.272

Answer 5

Pushy, 2 bytes

S#

Try it online!

Input is automatically converted to charcodes and placed on the stack. S sums the stack, and # prints it.

Answer 6

Brainfuck - 15 Bytes

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

Try it here (You have to click the box marked "!")

Put your input after the exclamation point. (not necessary but allows easy EOF.)

What it does

,[>,]     take input as characters in separate cells until input has ended (automatically in ascii)
<         go to the last character
[         infinite loop
[<+>-]    add the last character and the character before it and save it as the last character
<]        go back to the last character and then do the infinite loop again

Unfortunately, it exits with an out of memory error and does not print the output, but that wasn't part of the challenge. If you want to see the output, read the tape. It also only goes up to 255 on this interpreter. (if anyone knows an interpreter with larger cells that exits on error, that would be great)

Answer 7

Perl 5 -pF, 15 bytes

Under the rules in place at the time of this challenge, I believe it would have been +3 for the command line flags, giving a score of 18.

map$\+=ord,@F}{

Try it online!

Answer 8

Whitespace, 61 bytes

[S S S N
_Push_0][N
S S N
_Create_Label_LOOP][S N
S _Duplicate_top][S N
S _Duplicate_top][T N
T   S _Read_STDIN_as_character][T   T   T   _Retrieve_input][S N
S _Duplicate][S S S T   S T S N
_Push_10][T S S T   _Subtract][N
T   S S N
_If_0_Jump_to_Label_PRINT][T    S S S _Add][N
S N
N
_Jump_to_Label_LOOP][N
S S S N
_Create_Label_PRINT][S N
N
_Discard_newline][T N
S T _Output_top_as_integer]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.

Since Whitespace inputs one character at a time, the input should contain a trailing newline so it knows when to stop reading characters and the input is done.

Try it online (with raw spaces, tabs, and new-lines only).

Explanation in pseudo-code:

Integer s = 0
Start LOOP:
  Integer c = Read STDIN as character
  If(c == 10) // c == '\n'
    Call function PRINT
  s = s + c
  Go to next iteration of LOOP

function PRINT:
  Discard the top of the stack (the 10 / newline)
  Print s as integer to STDOUT
  

Answer 9

C# (Visual C# Interactive Compiler), 14 bytes

s=>s.Sum(x=>x)

Try it online!

Answer 10

Ahead, 5 bytes

SK+O@

S      slurp input
 K+    reduce stack by summing
   O   output sum
    @  end

Try it online!

Answer 11

Kotlin, 22 bytes

(String) -> Int lambda.

{it.sumBy{it.toInt()}}

Try it online!

Answer 12

Japt -mx, 1 byte

c

Try it!

---

If the input cannot be an array of chars, then this can be done in 3 bytes:

¬xc

Try it!

Answer 13

Runic Enchantments, 10 bytes (Self-sum: 703)

iul1)?@+2?

Try it online!

It has a limit on how long of a string it can handle. For a version that can handle any length string:

/l͍:i0< /~~@
R1-:0≮?/:}}:{%3s}+}

Try it online! (Self-sum: 3937)

In both cases spaces need to be escaped in order to be read as a single input. The first one works by unconcatening the string and iteratively adding each character together until only a single value is left (printing it).

The second uses an index pointer and extracts one character at a time, adding it to a running total (requiring more in the way of setup and stack manipulation).

Answer 14

@, 4 bytes

Seems like a perfect task for @.

Σš

Explanation

Σ  Summation of
 š a one-line input

Answer 15

Brain-Flak, 6 bytes (own code sum: 577)

({{}})

Try it online!

Seems to be a good challenge for Brain-Flak.

Explanation:

 {  }   while top of Stack is not 0, calculate sum of
  {}    pop value
(    )  push calculated sum
        implicitly output the Stack

Answer 16

Unexpended Sinclair ZX80 - 65 tokenized BASIC bytes

 1 INPUT A$
 2 LET A=0
 3 IF A$="" THEN GO TO 7
 4 LET A=A+CODE(A$)
 5 LET A$=TL$(A$)
 6 GO TO 3
 7 PRINT A

There are a few caveats, without POKEing some (or one, I don't recall) memory location(s), all maths is done via 16-bit signed integers, so the range is -32768 to +32767, so any string entered that is too long will overflow the VAR stack and break the program. Also, the ZX80 character set is not ASCII compatible and there is no exclamation mark, so HELLO WORLD (as there are no lower-case characters by default either) is 494 - source.

BASIC does not update the screen whilst doing calculations and such, so after entering the string it will take some time to work out where nothing will be displayed. Your original string entered in the A$ variable will not show.

Answer 17

Wren, 35 bytes

The fact that they aren't doing this in Wren is a perfect chance for me.

Fn.new{|x|x.bytes.reduce{|a,i|a+i}}

Try it online!

Explanation

Fn.new{|x|                        } // New anonymous function with parameter x
          x.bytes                   // Convert x to its bytecode forms
                 .reduce{|a,i|a+i}  // Sum this bytecode form

Answer 18

𝔼𝕊𝕄𝕚𝕟 2, 5 chars / 13 bytes

⨭ ᴉ⒨⒞

Try it here (Firefox only).

Splits and maps the input to its charcodes, then sums the resulting array.

Answer 19

Pyth, 3 bytes

sCM

Try it online!

Alternatively, smC works as well.

Explanation:

    # implicit output
s   # sum(                )
  M #     map(   ,       )
 C  #         ord
    #             input()   -> implicit input

Answer 20

K (ngn/k), 2 bytes

+/

Try it online!

In K, a string is basically a list of ASCII char codes, so just the sum adverb will do the job.

Answer 21

Go, 58 bytes

func f(b[]byte)(s int){for _,e:=range b{s+=int(e)}
return}

Attempt This Online!

Answer 22

Raku, 10 bytes

*.ords.sum

Try it online!

The ords string method conveniently returns a list of the ordinal values of the characters.

Answer 23

Thunno 2 SB, 0 bytes

Attempt This Online!

Or, 2 bytes flagless:

CS

Attempt This Online!