Summing the Digits of a Number

Question

Challenge

• Given a non-negative integer, find the sum of its digits.

Rules

• Your program must take a non-negative integer as input.
• Your program should output the sum of the digits of the input integer.
• Your program should be able to handle inputs up to 10^100.

Examples

• If the input is 123, the output should be 6 (1 + 2 + 3).
• If the input is 888, the output should be 24 (8 + 8 + 8).
• If the input is 1024, the output should be 7 (1 + 0 + 2 + 4).
• If the input is 3141592653589793238462643383279502884197169399375105820974944592, the output should be 315.

Format

• Your program should take input from standard input (stdin) and output the result to standard output (stdout).
• Your program should be runnable in a Unix-like environment.

Test cases

Input:

123

Output:

6

Input:

888

Output:

24

Input:

1024

Output:

7

Input:

3141592653589793238462643383279502884197169399375105820974944592

Output:

315

Scoring

• This is a code-golf challenge, so the shortest code (in bytes) wins.

Answer 1

Zsh, 31 bytes

for i (${(s::)1})((n+=i));<<<$n

Try it online!

Answer 2

Perl 5 -F -E, 18 bytes

$s+=$_ for@F;say$s

Try it online!

Answer 3

Befunge-98 (PyFunge), 9 7 6 bytes

~c%+#q

Try it online!

Having read through the Default I/O thread, it seems my "fun extra" answer is actually valid as a submission. Note that since the output in this version is an exit code, POSIX-compatible systems (including TIO; please let me know if there's a better site for this) will only care about the least significant byte and as such display the result mod 256 (as per the Funge-98 spec).

Explanation

~: Read next character.

c%: Push 12, then take input character mod 12. This gives the number represented. Suggested by Jo King (previous iteration subtracted 48 from the number with '0-).

+: Add that to the current total (initially implicitly 0).

#q: Do nothing if control flow is LTR, quit and return top of stack as exit code if RTL.

Due to wrapping, this is a loop. At EOF, ~ reflects, thus executing the last portion RTL.

Previous version

~'0-+2j@.

Try it online!

Explanation

As above, but replace #q with:

2j@.: Jumps over the exit and print if control flow is LTR, prints top of stack as an integer then exits if RTL (push 2, jump, exit, print).

Answer 4

x86-64 Linux assembly, 18 15 bytes

Custom calling convention because I remembered lodsb exists. It turns out the answer is nearly identical to Cody Gray's now, except he cleverly used ah instead of 0 in cmp. Oh well. lea is 4 bytes, the same as sub al,'0'/add edx,eax.

I copied his listing format too because it's nicer to look at than an objdump.

sum_digits:                                 ; input: null-terminated string in esi
  31 D2         xor     edx, edx            ; sum = 0
  31 C0         xor     eax, eax            ; clear upper bits of eax
.L:                                         ; do
  AC            lodsb                       ; al c = *str++
  8D 54 02 D0   lea     edx, [edx-48+eax]   ; sum += c - '0'
  80 3E 00      cmp     BYTE [esi], 0       ; while (*str)
  75 F6         jne     .L
  C3            ret                         ; return in edx

Answer 5

Japt -x, 1 byte

ì

Try it

ì gets the digits of the number, the -x flag sums the resulting array

Answer 6

Arturo, 15 bytes

$=>[∑digits&]

Try it

Even though the question says input and output must be via standard IO, the author of the question said functions are allowed in the comments. So this is a function.

Answer 7

Charcoal, 3 bytes

ＩΣＮ

Try it online! Link is to verbose version of code. Explanation:

  Ｎ Input number
 Σ  Sum of digits
Ｉ   Cast to string
    Implicitly print

Answer 8

Standard ML, 43 bytes

(foldl op+ 0)o map(fn x=>ord x-48)o explode

Lack of sum function strikes again

Answer 9

Jelly, 2 bytes

DS

Try it online!

D    digits
 S   sum

Answer 10

Pip, 3 bytes

$+a

Attempt This Online!

$+    sum of
      (the digits of)
  a   the input

Answer 11

Hebigo, 25 bytes

print:sum:map: int input:

(It compiles to the following Python.)

print(
  sum(
    map(
      int,
      input())))

Answer 12

PowerShell Core, 31 bytes

%{$s=0;$_|% *ay|%{$s+="$_"};$s}

Input comes from the pipeline

Try it online!

%{$s=0;$_|% *ay|%{$s+="$_"};$s}
%{                            } # % is an alias for the cmdlet ForEach-Object; input (the string containing the number) comes from the pipeline and will be in $_
  $s=0;                         # initialize the final sum
       $_|% *ay                 # takes the input string and passes it to "ForEach-Object -MemberName ToCharArray": turns the string into an array of characters. This is shorter than a cast using [char[]]$_
               |%{$s+="$_"};    # pass the single characters to yet another ForEach-Object which sums up the total. The current character in $_ must be turned into a single-char string by wrapping it in double quotes;
                                # without that, PS would add up the character's byte code since the left operand (the sum) is an integer.
                            $s  # output the sum

Answer 13

Wolfram Language (Mathematica), 19 bytes

Total@IntegerDigits

Try it online!

Total@IntegerDigits@3141592653589793238462643383279502884197169399375105820974944592

315

Answer 14

MathGolf, 1 byte

Σ

Try it online.

Explanation:

Σ  # Sum the digits of the (implicit) input-integer
   # (after which the entire stack is output implicitly as result)

Answer 15

Brain-Flak, 150 bytes

{(({})<><((()()()()()){})>)({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{}{})<>({}<((()()()()()){})>(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><{}{}>)}<>

Not sure if this counts, because it exceeds TIO's 60s time limit for the 3141592653589793238462643383279502884197169399375105820974944592 test case, as its' time complexity is linear. Theoretically, given enough time, it should output the right answer. This answer is extremely similar in format to my answer here.

{                                                                               #  loop while top of left stack is not 0
(({})<><((()()()()()){})>)({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{}{})<>    #  add the result of modulo 10 of the top value of the left stack to the top value on the right stack
({}<((()()()()()){})>(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><{}{}>)          #  integer division by 10 on left stack
}                                                                               #  end loop
<>                                                                              #  switch to right stack
                                                                                #  implicit output of active (right) stack

Try it online!

Answer 16

APL, 9 bytes (?)

sd←+/⊥⍣¯1

Some characters take probably more than 1 byte, but I am not sure how many...

Answer 17

Groovy, 37 bytes

def c={("$it"as List).sum{it as int}}

Try it online!

Answer 18

Brachylog, 2 bytes

ẹ+

Try it online!

Explanation

ẹ is a pretty disgusting built-in for a declarative logic language, but it’s useful. A "better" alternative would be ∋ᶠ (find all elements) but it’s longer.

ẹ     Split into a list of elements
 +    Sum

Answer 19

KamilaLisp v0.2, 15 (APL SBCS)

$(⌿.← +)∘:⊙⍫∘⍫∧

Equivalent to $(foldl1 +)@:parse-number@str:explode.

Answer 20

KAP, 7 characters, 11 bytes:

+/@0-⍨⍕

Try it online.

It appears that one needs bigint support to properly answer this question. If strings are allowed then the last character can be removed from the answer.

Answer 21

Lua, 40 bytes

a=0(...):gsub('.',load'a=...+a')print(a)

Try it online!

Answer 22

Nibbles, 2.5 bytes

+`@10

Attempt This Online!

Explained

+`@10
+      # Sum of
 `@    # input converted to
   10  # base 10 (basically, list of digits)

Answer 23

Rockstar, 75 65 56 bytes

listen to N
cut N
X's 0
while N
let X be+roll N-0

say X

Try it here (Code will need to be pasted in)

listen to N     :Read input string into variable N
cut N           :Split to an array
X's 0           :Initialise X as 0
while N         :While N is not empty
let X be+       :  Increment X by
  roll N        :    Pop the first element from N
  -0            :    Subtract an 0 to cast it to an integer
                :End while loop
say X           :Output X

Answer 24

Shasta ^v0.0.11, 27 bytes

{(eval(join(split$"")"+"))}

{...} Function of argument $

(eval ...) Evaluate as JavaScript

(join ... "+") Join on "+"

(split $ "") Characters of the input string

Alternative 27 bytes:

{(sum(map(split$"")number)}

The sum of mapping each character of the input string to number.

Online interpreter will be set up very soon; for now, you can test this by following instructions from the README on GitHub.

Answer 25

Scala, 23 bytes

Try it online!

x=>x.map(_.asDigit).sum

Answer 26

Factor + math.unicode, 18 bytes

[ >dec 48 v-n Σ ]

Attempt This Online!

• >dec Convert the input to a string
• 48 v-n Subtract 48 from each code point
• Σ Sum

Answer 27

Ly, 3 bytes

S&+

Try it online!

Breaks STDIN into digits and pushes onto the stack, then uses &+ to sum them. Prints the stack as a number be default when the code exits.

Answer 28

GolfScript, 11 bytes

`1/{~}%{+}*

Try it online!

A function which takes a single integer as input. Link includes test cases.

Explanation

`1/{~}%{+}* # whole function
`           # convert the input into a string
  /         # split into groups of size
 1          # 1
   { }%     # for each value in the split groups...
    ~       # eval it
       {+}* # sum this `eval`ed array

Answer 29

Pyth, 4 bytes

ssMz

Try it online!

Alternatively there's sjQT or just ssM if we're allowed to have quotes around the input.

Answer 30

J, 13 bytes

[: +/ 48 -~ a. I. ]