Sum digits of an integer: Difference between revisions

=={{header|11l}}==

{{trans|Nim}}

V r = 0

L n > 0

print(sum_digits(1234, 10))

print(sum_digits(F'E, 16))

 

{{out}}

{{trans|REXX}}

The program uses two ASSIST macro (XDECO,XPRNT) to keep the code as short as possible.

SUMDIGIN CSECT

USING SUMDIGIN,R13 base register

XDEC DS CL12 temp

YREGS

{{out}}

<pre>

 

=={{header|8086 Assembly}}==

org 100h

section .text

dw 16, 0FEh

dw 16, 0F0Eh

 

{{out}}

29</pre>

=={{header|Action!}}==

CARD res,a

 

PrintF("num=%U base=%U sum=%U%E",num,base,res)

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sum_digits_of_an_integer.png Screenshot from Atari 8-bit computer]

Digits is a base-B number. E.g., 30, 10#30# 2#11110#, and 16#1E# are the same number -- either written in decimal, binary or hexadecimal notation.

 

 

procedure Sum_Digits is

Put(Sum_OF_Digits(16#fe#, 16)); -- 29

Put(Sum_OF_Digits(16#f0e#, 16)); -- 29

 

{{out}}

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}

# operator to return the sum of the digits of an integer value in the #

# specified base #

 

)

{{out}}

<pre>

 

==AppleScript==

 

-- baseDigitSum :: Int -> Int -> Int

end tell

return xs

{{Out}}

<pre>{{8, 17, 12, 30}, {1, 10}, {29, 29}}</pre>

 

=={{header|APL}}==

{{out}}

<pre>

 

=={{header|ArnoldC}}==

I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE n

I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE base

TALK TO THE HAND "sumDigits 254 16 ="

TALK TO THE HAND sum

{{out}}

<pre>

=={{header|Arturo}}==

{{trans|Nim}}

result: 0

while [n>0][

print sumDigits 123045 10

print sumDigits from.hex "0xfe" 16

 

{{out}}

 

=={{header|ATS}}==

(* ****** ****** *)

//

//

} (* end of [main0] *)

{{out}}

<pre>

''Translated from the C version.''

 

,SumDigits(1, 10)

,SumDigits(12345, 10)

StringReplace,s,s,`%d, % f

return s

{{out}}

<pre>1 15 15 29 29</pre>

Other versions of AWK may not have these limitations.

 

 

BEGIN {

return index("0123456789abcdef", tolower(dig)) - 1

}

{{out}}

<pre>

Note that in order for this to work with the Windows versions of PowerBASIC, the test code (the block at the end containing the PRINT lines) needs to be inside <code>FUNCTION PBMAIN</code>.

 

'can handle up to base 36

DIM outp AS LONG

PRINT sumDigits(LTRIM$(STR$(&HFE)), 16)

PRINT sumDigits(LTRIM$(STR$(&HF0E)), 16)

 

{{out}}

 

==={{header|Applesoft BASIC}}===

20 N$ = "1" : GOSUB 100 : PRINT N

30 N$ = "1234" : GOSUB 100 : PRINT N

170 N = N + J - 1

180 NEXT I

 

==={{header|BASIC256}}===

if number < 0 then number = -number

if nBase < 2 then nBase = 2

print "fe base 16 : "; SumDigits(0xfe, 16)

print "f0e base 16 : "; SumDigits(0xf0e, 16)

 

==={{header|Minimal BASIC}}===

{{trans|Tiny BASIC}}

Only base ten is supported. Minimal BASIC does not support operations on strings (except assignment to variables).

10 REM Sum digits of an integer

20 PRINT "Enter a number";

100 PRINT "Its digit sum:"; S

110 END

 

==={{header|QBasic}}===

{{works with|QBasic|1.1}}

{{works with|QuickBasic|4.5}}

IF number < 0 THEN number = -number

IF nBase < 2 THEN nBase = 2

PRINT "fe base 16 :"; SumDigits(&HFE, 16)

PRINT "f0e base 16 :"; SumDigits(&HF0E, 16)

 

==={{header|QuickBASIC}}===

{{works with|QB64}}

{{works with|VB-DOS}}

 

CLS

LOOP

SumDigits% = iSum

{{out}}

<pre>

F0E base 16 -> 20

</pre>

 

==={{header|Tiny BASIC}}===

Only base ten is supported because the only data type is signed 16-bit int.

PRINT "Enter a number."

INPUT N

GOTO 10

20 PRINT "Its digit sum is ",S,"."

{{out}}

<pre>Enter a number.

Its digit sum is 7.</pre>

 

<pre>

</pre>

 

=={{header|bc}}==

auto i, o, s

ibase = 16

s(FE)

 

{{Out}}

 

=={{header|BCPL}}==

 

let digitsum(n, base) =

writef("%N*N", digitsum(#XFE, 16)) // prints 29

writef("%N*N", digitsum(#XF0E, 16)) // also prints 29

{{out}}

<pre>1

This solution reads the number and base as integers from stdin (in base 10). There doesn't seem any point in accepting input in other bases, because it would then have to be processed as a string and the base would be irrelevant, defeating the point of this exercise.

 

|_,#!>#:<"Base: "<

<>10g+\00g/:v:p00&

v^\p01<%g00:_55+\>

 

{{out}}

 

Default base(right argument) is 10.

𝕊 𝕩: 10 𝕊 𝕩;

𝕨 𝕊 0: 0;

•Show SumDigits 1

•Show SumDigits 1234

10

 

[https://mlochbaum.github.io/BQN/try.html#code=U3VtRGlnaXRzIOKGkCB7CiAg8J2ViiDwnZWpOiAxMCDwnZWKIPCdlak7CiAg8J2VqCDwnZWKIDA6IDA7CiAgKPCdlah88J2VqSkr8J2VqPCdlYrijIrwnZWpw7fwnZWoCn0KCuKAolNob3cgU3VtRGlnaXRzIDEK4oCiU2hvdyBTdW1EaWdpdHMgMTIzNArigKJTaG93IDE2IFN1bURpZ2l0cyAyNTQ= Try It!]

 

=={{header|C}}==

 

int SumDigits(unsigned long long n, const int base) {

SumDigits(0xf0e, 16) );

return 0;

{{out}}

<pre>1 15 15 29 29</pre>

 

=={{header|C sharp|C#}}==

{

using System;

}

}

{{out}}

<pre>1

 

=={{header|C++}}==

#include <cmath>

int SumDigits(const unsigned long long int digits, const int BASE = 10) {

<< SumDigits(0xf0e, 16) << std::endl;

return 0;

{{out}}

<pre>1 15 15 29 29</pre>

===Template metaprogramming version===

Tested with g++-4.6.3 (Ubuntu).

// Template Metaprogramming version by Martin Ettl

#include <iostream>

return 0;

}

{{out}}

<pre>1 15 15 29 29</pre>

 

=={{header|Clojure}}==

(let [number (if-not (string? n) (Long/toString n base) n)]

 

{{out}}

user=> (sum-digits "clojure" 32)

147</pre>

 

=={{header|Common Lisp}}==

(loop for n = number then q

for (q r) = (multiple-value-list (truncate n base))

Example:

{{out}}

<pre>(1)_10 = 1

 

=={{header|Cowgol}}==

 

sub digitSum(n: uint32, base: uint32): (r: uint32) is

print_nl();

print_i32(digitSum(0xF0E, 16)); # prints 29

 

{{out}}

 

=={{header|Crystal}}==

def sum_digits(base : Int) : Int32

self.chars.reduce(0) { |acc, c|

puts("1234".sum_digits 10)

puts("fe".sum_digits 16)

{{out}}

<pre>1

 

=={{header|D}}==

 

uint sumDigits(T)(T n, in uint base=10) pure nothrow

sumDigits(0xf0e, 16).writeln;

1_234.BigInt.sumDigits.writeln;

{{out}}

<pre>1

29

10</pre>

 

=={{header|Dc}}==

 

1 lS x p

16 i

FE lS x p

{{out}}

<pre>

{{trans|C#}}

 

while num != 0 {

let (n, digit) = (num / bas, num % bas)

] {

print(sumOfDigits(e.num, e.bas))

 

{{out}}

=={{header|Delphi}}==

See [https://rosettacode.org/wiki/Sum_digits_of_an_integer#Pascal Pascal].

 

=={{header|Elixir}}==

def sumDigits(n, base\\10)

def sumDigits(n, base) when is_integer(n) do

Enum.each([{"1", 10}, {"1234", 10}, {"fe", 16}, {"f0e", 16}], fn {n,base} ->

IO.puts "#{n}(#{base}) sums to #{ RC.sumDigits(n,base) }"

 

{{out}}

 

=={{header|Emacs Lisp}}==

(apply #'+ (mapcar (lambda (c) (- c ?0)) (string-to-list "123"))))

 

 

=={{header|Erlang}}==

-module(sum_digits).

-export([sum_digits/2, sum_digits/1]).

sum_digits(N,B,Acc) ->

sum_digits(N div B, B, Acc + (N rem B)).

 

Example usage:

 

{{Works with|Office 365 betas 2021}}

=LAMBDA(s,

FOLDROW(

)

)

 

and also assuming the following generic bindings in the Name Manager for the WorkBook:

 

=LAMBDA(s,

MID(s,

)

)

 

{{Out}}

 

=={{header|Ezhil}}==

# இது ஒரு எழில் தமிழ் நிரலாக்க மொழி உதாரணம்

 

பதிப்பி எண்_கூட்டல்( 1289)#20

பதிப்பி எண்_கூட்டல்( 123456789)# 45

 

=={{header|F_Sharp|F#}}==

 

let digsum b n =

 

show [1; 10; 1234; 10; 0xFE; 16; 0xF0E; 16] // -> 1 10 29 29

 

===or Generically===

In order to complete the [[Digital root]] task I require a function which can handle numbers larger than 32 bit integers.

//Sum Digits of An Integer - Nigel Galloway: January 31st., 2015

//This code will work with any integer type

let rec sum(g, n) = if n < BASE then n+g else sum(g+n%BASE, n/BASE)

sum(LanguagePrimitives.GenericZero<_>,N)

{{out}}

<pre>

 

=={{header|Factor}}==

 

{{out}}

<pre>--- Data stack:

=={{header|Forth}}==

This is an easy task for Forth, that has built in support for radices up to 36. You set the radix by storing the value in variable BASE.

 

2 base ! 11110 sum_int decimal . cr

10 base ! 12345 sum_int decimal . cr

 

=={{header|Fortran}}==

Other solutions ignore the representations of the input, encode digits using the base, then sum the encoding.

Both methods appear in this implementation.

!-*- mode: compilation; default-directory: "/tmp/" -*-

!Compilation started at Fri Jun 7 21:00:12

end subroutine process0

end program digit_sum

 

=={{header|Frink}}==

In Frink numbers can be specifed to an arbitrary base from 2 to 36 as <CODE>number\\base</CODE>. The function <CODE>integerDigits[n, base]</CODE> lists the digits of <CODE>n</CODE> in the base <CODE>base</CODE>.

 

The sample problems can be written as:

sumDigits[1]

sumDigits[1234]

sumDigits[fe\\16]

sumDigits[f03\\16]

 

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Go}}==

Handling numbers up to 2^64-1 and bases from 2 to 36 is pretty easy, larger values can be handled using the <code>math/big</code> package (but it's still limited to base<=36).

 

package digit

}

return

 

package digit

t.Log("got expected error:", err)

}

 

=={{header|Groovy}}==

Solution:

Integer.toString(number, radix).collect { Integer.parseInt(it, radix) }.sum()

 

Test:

println """

Decimal value: ${it[0]}

Radix Digit Sum: ${Integer.toString(digitsum(it[0], it[1]), it[1])}

"""

 

{{out}}

 

=={{header|Haskell}}==

:: Integral a

=> a -> a -> a

 

main :: IO ()

{{Out}}

<pre>30</pre>

 

In terms of unfoldr:

import Data.Tuple (swap)

 

baseDigitSum :: Int -> Int -> Int

 

main :: IO ()

main =

mapM_

print

{{Out}}

<pre>[8,17,12,30]

 

Or, we could write '''sum . fmap digitToInt''', or the equivalent but more efficient fusion of it to a single fold: '''foldr ((+) . digitToInt) 0'''

import Data.List (transpose)

import Numeric (readInt, showIntAtBase)

readBase b s = n

where

{{Out}}

<pre> Base Digits Value digit string -> sum integer value -> sum

some of the other solutions.

 

write(dsum(a[1]|1234,a[2]|10))

end

while sum +:= (0 < n) % b do n /:= b

return sum

 

Sample runs:

=={{header|J}}==

 

 

Example use:

 

10

10 digsum 254

11

16 digsum 254

 

Illustration of mechanics:

 

1234

10 #.inv 1234

10

10 +/@(#.inv) 1234

 

So #.inv gives us the digits, +/ gives us the sum, and @ glues them together with +/ being a "post processor" for #.inv or, as we say in the expression: (#.inv). We need the parenthesis or inv will try to look up the inverse of +/@#. and that's not well defined.

Full examples:

 

1

digsum 1234

29

16 digsum 16bf0e

 

Note that J implements numeric types -- J tries to ensure that the semantics of numbers match their mathematical properties. So it doesn't matter how we originally obtained a number.

 

254

254

254

254b10 , 1r254b0.1 NB. 10 in base 254 , 0.1 in base 1/254

 

=={{header|Java}}==

public class SumDigits {

public static int sumDigits(long num) {

System.out.println(sumDigits(new BigInteger("12345678901234567890")));

}

{{out}}

<pre>

 

===Imperative===

n += ''

for (var s=0, i=0, e=n.length; i<e; i+=1) s+=parseInt(n.charAt(i),36)

}

for (var n of [1, 12345, 0xfe, 'fe', 'f0e', '999ABCXYZ']) document.write(n, ' sum to ', sumDigits(n), '<br>')

{{out}}

<pre>

</pre>

 

'use strict';

 

.join('\n');

 

 

 

<pre>1 -> 1

12345 -> 15

f0e -> 29

999ABCXYZ -> 162</pre>

 

=={{header|jq}}==

The following pipeline will have the desired effect if numbers and/or strings are presented as input:

$ jq -M 'tostring | explode | map(tonumber - 48) | add'

123

6

"123"

 

=={{header|Julia}}==

Using the built-in <code>digits</code> function:

 

=={{header|Kotlin}}==

 

const val digits = "0123456789abcdefghijklmnopqrstuvwxyz"

println("The sum of digits is:")

for ((number, base) in numbers) println("$number\tbase $base\t-> ${sumDigits(number, base)}")

 

{{out}}

16xyz base 36 -> 109

</pre>

 

=={{header|Lasso}}==

 

define sumdigits(int, base = 10) => {

sumdigits(0xfe, 16)

br

{{out}}

<pre>1

 

=={{header|Lingo}}==

sum = 0

repeat while n

end repeat

return sum

 

-- 1

put sum_digits(1234, 10)

-- 29

put sum_digits(3854, 16) -- 0xf0e

 

=={{header|LiveCode}}==

local numb

if base is empty then put 10 into base

end repeat

return numb

Example

sumdigits(1234,10) & comma & \

sumdigits(fe,16) & comma & \

 

=={{header|Logo}}==

 

to digitvalue :digit

end

 

 

{{Out}}

 

=={{header|Lua}}==

sum = 0

while n > 0.5 do

print(sum_digits(1234, 10))

print(sum_digits(0xfe, 16))

{{out}}

<pre>1

29

29</pre>

 

=={{header|Maple}}==

local digits, number_to_string, i;

number_to_string := convert( num, string );

end proc:

sumDigits( 1234 );

{{out}}

<pre>

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

{{out}}

<pre>10

29</pre>

 

=={{header|МК-61/52}}==

П3 ИП0 * - ИП2 + П2 ИП3 П1 x=0

 

=={{header|ML}}==

Function with first argument valid base, second argument number

local

open IntInf

summDigits 16 0xf0e ;

summDigits 4332489243570890023480923 0x8092eeac80923984098234098efad2109ce341000c3f0912527130 ;

output

val it = 1: IntInf.int

val it = 10: IntInf.int

val it = 29: IntInf.int

val it = 4745468831557628080368936: IntInf.int

 

==={{header|mLite}}===

Left in the to_radix even though not used in the solution.

 

fun to_radix (0, radix, result) = implode result

shosum ("1101010101010101010101010101010101010101010101010101010101010101010101010101010101010101",2);

shosum ("thequickbrownfoxjumpsoverthelazydog",36);

Output

<pre>sum of digits of 10fg (base 17) = 32

{{trans|Pascal}}

{{works with|ADW Modula-2|any (Compile with the linker option ''Console Application'').}}

MODULE SumOFDigits;

FROM STextIO IMPORT

WriteLn;

END SumOFDigits.

{{out}}

<pre>

===Strings===

Processes data as text from the command line. Provides a representative sample if no input is supplied:

options replace format comments java crossref symbols nobinary

 

 

return rVal

{{out}}

<pre>

===Type <tt>int</tt>===

Processes sample data as <tt>int</tt> arrays:

options replace format comments java crossref symbols binary

 

iVal = Integer.valueOf(oVal, 8).intValue()

return iVal

{{out}}

<pre>

 

=={{header|Never}}==

func sum_digits(n : int, base : int) -> int {

var sum = 0;

0

}

{{output}}

<pre>

 

=={{header|Nim}}==

var n = n

while n > 0:

echo sumDigits(123045, 10)

echo sumDigits(0xfe, 16)

{{out}}

<pre>1

 

=={{header|Oberon-2}}==

MODULE SumDigits;

IMPORT Out;

Out.String("OF0EH : ");Out.LongInt(Sum(0F0EH,16),10);Out.Ln

END SumDigits.

{{out}}

<pre>

 

=={{header|Objeck}}==

function : Main(args : String[]) ~ Nil {

SumDigit(1)->PrintLine();

}

}

 

{{output}}

=={{header|OCaml}}==

 

let rec aux sum x =

if x <= 0 then sum else

(sum_digits 123045 10)

(sum_digits 0xfe 16)

 

{{out}}

=={{header|Oforth}}==

 

 

Usage :

sumDigits(1234, 10) println

sumDigits(0xfe, 16) println

 

{{out}}

 

=={{header|Ol}}==

(define (sum n base)

(if (zero? n)

(print (sum #xf0e 16))

; ==> 29

 

=={{header|PARI/GP}}==

 

Also the built-in <code>sumdigits</code> can be used for base 10.

 

=={{header|Pascal}}==

 

function SumOfDigitBase(n:UInt64;base:LongWord): LongWord;

writeln('18446744073709551615 sums to ', SumOfDigitBase(High(Uint64),10));

 

;output:

<pre>

 

=={{header|Perl}}==

use strict;

use warnings;

 

print "$_ sums to " . sumdigits($_) . "\n"

{{out}}

<PRE>1 sums to 1

 

The ntheory module also does this, for a solution similar to Raku, with identical output.{{libheader|ntheory}}

 

=={{header|Phix}}==

{{libheader|Phix/basics}}

<span style="color: #008080;">function</span> <span style="color: #000000;">sum_digits</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">base</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">integer</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">sum_digits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">#FE</span><span style="color: #0000FF;">,</span><span style="color: #000000;">16</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">sum_digits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">#F0E</span><span style="color: #0000FF;">,</span><span style="color: #000000;">16</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

 

=={{header|PHP}}==

function sumDigits($num, $base = 10) {

$s = base_convert($num, 10, $base);

echo sumDigits(0xfe, 16), "\n";

echo sumDigits(0xf0e, 16), "\n";

{{out}}

<pre>

 

=={{header|Picat}}==

 

println(1=sum_digits(1)),

Map = new_map([A=I : {A,I} in zip(Alpha,0..length(Alpha)-1)]),

Len = N.length,

 

{{out}}

 

=={{header|PicoLisp}}==

(or

(=0 N)

Test:

-> 1

 

 

: (sumDigits (hex "f0e") 16)

 

=={{header|PL/I}}==

sum_digits: procedure options (main); /* 4/9/2012 */

declare ch character (1);

end;

end sum_digits;

results:

<pre>

SD= 5;

</pre>

 

=={{header|PowerShell}}==

function Get-DigitalSum ([string] $number, $base = 10)

{

}

}

 

{{out}}

 

==={{header|Alternative Implementation}}===

function Get-DigitalSum ([string] $number, $base = 10)

{

Invoke-Expression (($number.ToCharArray() | ForEach-Object {[string][convert]::ToInt16($_, $base)}) -join "+")

}

 

{{out}}

=={{header|Prolog}}==

{{works with|SWI Prolog}}

digit_sum(N, Base, Sum, 0).

 

test_digit_sum(1234, 10),

test_digit_sum(0xfe, 16),

 

{{out}}

Sum of digits of 254 in base 16 is 29.

Sum of digits of 3854 in base 16 is 29.

</pre>

 

=={{header|Python}}==

 

from numpy import base_repr

 

def sumDigits(num, base=10):

return sum(int(x, base) for x in list(base_repr(num, base)))

 

or

 

if base < 2:

return

 

{{out}}

<pre>

</pre>

The following does no error checking and requires non-base 10 numbers passed as string arguments:

 

Each digit is base converted as it's summed.

 

 

Or, as a composition of re-usable abstractions:

 

from functools import reduce

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Digit sums of numbers in bases 10 and 16:

{{trans|Forth}}

 

[ over while

swap temp share /mod

1234 10 digitsum echo sp

hex FE 16 digitsum echo sp

 

{{out}}

=={{header|R}}==

{{trans|Python}}

{

ret <- integer(as.integer(logb(x=n, base=base))+1L)

sum.digits(123045)

sum.digits(0xfe, 16)

 

=={{header|Racket}}==

(define (sum-of-digits n base (sum 0))

(if (= n 0)

; (1234)_10 = 10

; (254)_16 = 29

 

=={{header|Raku}}==

This will handle input numbers in any base from 2 to 36.

The results are in base 10.

 

{{out}}

<pre>1

=={{header|REXX}}==

===version 1===

/* REXX **************************************************************

* 04.12.2012 Walter Pachl

End

Say res '->' right(dsum,2)

{{out}}

<pre>

::* &nbsp; numbers may be expressed up to base 36

::* &nbsp; numbers may be any length (size)

parse arg z /*obtain optional argument from the CL.*/

if z='' | z="," then z= '1 1234 fe f0e +F0E -666.00 11111112222222333333344444449'

sumDigs: procedure; arg x; @=123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ; $=0

do k=1 to length(x); $=$ + pos( substr(x, k, 1), @); end /*k*/

'''output''' &nbsp; when using the default input:

<pre>

 

The function makes use of REXX's &nbsp; '''parse''' &nbsp; statement

parse arg z /*obtain optional argument from the CL.*/

if z='' | z="," then z=copies(7, 108) /*let's generate a pretty huge integer.*/

sumDigs: procedure; parse arg N 1 $ 2 ? /*use first decimal digit for the sum. */

do while ?\==''; parse var ? _ 2 ?; $=$+_; end /*while*/

'''output''' &nbsp; when using the default input:

<pre>

 

=={{header|Ring}}==

see "sum digits of 1 = " + sumDigits(1) + nl

see "sum digits of 1234 = " + sumDigits(1234) + nl

end

return sum

 

=={{header|Ruby}}==

 

 

=={{header|Rust}}==

===Using an Iterator===

This solution creates an iterator which yields the digits of a given number using a given base and then utilizes the `sum` method which is implemented automatically on iterators.

 

impl Iterator for DigitIter {

fn main() {

println!("{}", DigitIter(1234,10).sum::<usize>());

 

=={{header|Scala}}==

Test:

sumDigits(0, 2) // => 0

sumDigits(0, 16) // => 0

sumDigits("000999ABCXYZ", 36) // => 162

sumDigits(BigInt("12345678901234567890")) // => 90

 

=={{header|Scheme}}==

The output is the sum of the digits in the target base, displayed in base 10.

 

(import (scheme base)

(scheme write))

(test-case #b1101010101010101010101010101010101 2 10)

(test-case #b1101010101010101010101010101010101 2 1000)

 

{{out}}

 

=={{header|Seed7}}==

 

const func integer: sumDigits (in var integer: num, in integer: base) is func

writeln(sumDigits(16#fe, 16));

writeln(sumDigits(16#f0e, 16));

 

{{out}}

=={{header|Sidef}}==

{{trans|Raku}}

str.chars.map{ Num(_, base) }.sum

}

<1 1234 1020304 fe f0e DEADBEEF>.each { |n|

say "Σ(#{n}) = #{Σ(n)}"

{{out}}

<pre>

Σ(f0e) = 29

Σ(DEADBEEF) = 104

</pre>

 

=={{header|Standard ML}}==

| sumDigits (n, base) = n mod base + sumDigits (n div base, base)

 

val testInput = [(1, 10), (1234, 10), (0xfe, 16), (0xf0e, 16)]

 

=={{header|Stata}}==

a = ascii(strupper(s)):-48

return(sum(a:-(a:>9)*7))

 

sumdigits(inbase(16, 254, 10))

 

=={{header|Swift}}==

{{works with|Swift|4.0}}

extension String: Error {

func sumDigits(withBase base: Int) throws -> Int {

print(try! "fe".sumDigits(withBase: 16))

print(try! "f0e".sumDigits(withBase: 16))

{{out}}

<pre>

=={{header|Tcl}}==

Supporting arbitrary bases makes this primarily a string operation.

set total 0

foreach d [split $num ""] {

}

return $total

Demonstrating:

puts [sumDigits 12345]

puts [sumDigits 123045]

puts [sumDigits fe 16]

puts [sumDigits f0e 16]

{{out}}

<pre>

162

</pre>

 

=={{header|Transd}}==

 

MainModule : {

(tsd vvar reduce: ["(sumDigits col1)"] )

)

<pre>

sum of 1:10 : 1

sum of 2022:3 : 6

sum of Transd:30 : 130

</pre>

 

=={{header|Ursa}}==

The function:

decl int ret

for (decl int i) (< i (size val)) (inc i)

end for

return ret

 

Calling the function: (This could be done on a single line, but it's split up for clarity.)

out (sumDigits "1234" 10) endl console

out (sumDigits "fe" 16) endl console

{{out}}

<pre>1

29</pre>

 

 

 

 

 

<pre>

</pre>

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

var sumDigits = Fn.new { |n, b|

var b = test[1]

var sum = sumDigits.call(n, b)

 

{{out}}

 

=={{header|XPL0}}==

 

func SumDigits(N, Base);

IntOut(0, SumDigits($FE, 16)); ChOut(0, ^ );

IntOut(0, SumDigits($F0E, 16)); CrLf(0);

 

{{out}}

 

=={{header|zkl}}==

if(b==10) n.split().sum(0); // digits to list

else n.toString(b).split("").apply("toInt",b).sum(0);

If not base 10, convert the int into a string (in the proper base, ie

0xfe-->"fe"), blow it apart into a list of digits/characters, convert