# Array Sum In Many Programming Languages

See ArraySum for problem description and context.

(List now alphabeticized for your convenience)

AplLanguage:
```   X <- +/A
```

AwkLanguage:

``` function array_sum(a,      i,s) {
for (i in a) s+=a[i]
return s
}
```

CeePlusPlus:

```  template<class Container>
typename Container::value_type
containerSum(const Container& container) {
return std::accumulate(
container.begin(),
container.end(),
Container::value_type(0));
}
```
or

``` template<class T>
vector<T>::value_type ArraySum(vector<T> &array)
{
T retVal;
int cntr;

for(cntr = 0 ; cntr < array.size() ; cntr++)
{
cntr==0?retVal =array[0]:retVal += array[cntr];
}

return retVal;
}
```
Will work if T has an '=' and a '+' operator.

see GrokBranching (before modifying above algorithm)

or you could use a higher level library such as Blitz++, BlitzPlusPlus

``` sum( A );

```
Two more modern C++11 versions:

``` template<typename T>
auto Sum(T input) -> typename T::value_type
{
typename T::value_type result{};
for(auto x : input)
result += x;

return result;
}

template<typename T>
auto Sum(std::initializer_list<T> input) -> T
{
auto j = begin(input);
auto result = *j++;
for(; j != end(input); ++j)
result += *j;

return result;
}

```
The former works with any container that supports begin() and end(), the latter works with bare initializer lists and uses a slightly more "correct" loop:

``` auto data = std::vector<int>{1, 2, 3, 4, 5};
auto data = std::list<int>{1, 2, 3, 4, 5};
auto data = std::array<int, 5>{{1, 2, 3, 4, 5}};

cout << Sum(data) << endl;
cout << Sum({1, 2, 3, 4, 5}) << endl;

```
The following will work (C++11) for arrays, initializer_lists, valarrays, and any container that exposes appropriate begin() and end() methods. It may be made to work for other types by specializing std::begin and std::end for those types.

``` std::vector<int> data{1, 2, 3, 4, 5};
int sum = 0;

std::for_each(std::begin(data), std::end(data), [&](int item){ sum += item; });

```

CsharpLanguage:

The most direct and efficient way to go is this:

``` int[] numbers = { 1, 2, 3, 4, 5 };
int sum = 0;
foreach (int n in numbers)
sum += n;
```
This can also be written using the generic Aggregate operator defined by LINQ over any sequence of values.

``` int[] numbers = { 1, 2, 3, 4, 5 };
int sum = numbers.Aggregate((a, b) => a + b);
```
LINQ also predefines the Min, Max, Average, and Sum aggregates, which means you can just write it like this:

``` int[] numbers = { 1, 2, 3, 4, 5 };
int sum = numbers.Sum();
```
-- DonBox
CommonLisp:

``` (defun sum-sequence (s)
(reduce #'+ s))

(sum-sequence '(1 2 3))   ->  6
```
This won't work with CL arrays of rank > 1, which seems to be the point of this page

I'm not sure where the requirement can be read that it has to work on arrays of rank > 1. Are the other examples for other languages with multi-dimensional arrays taking care of it? What do you think? (The CL example that is given later on this page for example might give errors if the array has a fill-pointer.)

For those who prefer something a bit more amusing:

``` (defun sum-sequence (seq)
(loop for x across seq summing x))
```
Loop is just amusing.
CoqAssistant?:

``` Require Import List.
Require Import Arith.

Definition arraysum a := fold_left plus a O.

Fixpoint running_sum a l {struct l} :=        %l decreases with every recursive call
a :: match l with
| nil => nil
| cons b l' => running_sum (plus a b) l'
end.

Check sum.
sum
: list nat -> nat

Eval compute in sum (1::2::3::nil).
= 6
: nat

Check running_sum.
running_sum
: nat -> list nat -> list nat

Eval compute in running_sum 0 (1::2::3::nil).
= 0::1::3::6::nil
: list nat
```

DeeCee

To consume the whole main stack, here is a macro "S":
``` [+z1<S] sS
```
To use it:
``` 1 2 3 4 5
lSx
```
To consume a given number of arguments (and leave registers as they were):
``` [
Sn
[+ln1-dsn1<m] Sm
lmx
LmXLn*1=X
]
sS

[I will not be eaten]
5 4 3 2 1 5 lSx
f
15
[I will not be eaten]
```

ForthLanguage:

``` : table  create , does> cell+ ;
: tableSize  cell- @ ;
: tableSum
0 over dup tableSize cells + rot ( sum extent table )
?do I @ +  cell +loop ;

4 table aTable 1 , 2 , 3 , 4 ,
aTable tableSum .    \ 10
```

The HaskellLanguage equivalent of reduce are the foldl and foldr higher order functions. They both have the same behaviour when used with the + operator (note that parenthesising an operator turns it into a function):

```   arraysum = foldl (+) 0
```
This idiomatic use of currying is equivalent to:

```   arraysum a = foldl (+) 0 a
```
And it's good practice to explicitly declare the function type, although the compiler can infer the type from it's use:

```   arraysum :: Num a => [a] -> a
```
To produce the running sum, we use a counterpart to foldl: scanl, which produces each step of "folding" the operator in.

```   runningsum ns = tail \$ scanl (+) 0 ns
```
Giving a type of:

```   runningsum :: (Num a) => [a] -> [a]
```
Even simpler: arraysum = sum
IokeLanguage:

```   a inject(+)
```
Or, equivalently:

```   a fold(+)
```
or:

```   a reduce(+)
```
These three are actually identical (they're names for identical macros).

They work on any type which understands "+", including strings.
J (JayLanguage):
```   +/A
```
Note that this works on arrays of any rank, producing an array of one less than that rank. Thus, the sum reduces the array by the last axis. This behavior is more formal in J (JayLanguage) than in AplLanguage (see below). By the way, the reducing operation doesn't have to be plus - it can be any "binary" (we call them dyadic) function - such as multiply. Just replace the "+" with the appropriate primitive.

For even more fun,
```   +/\A
```
Produces the RUNNING sums.
JavaLanguage:

Proper software engineers should not use one-liners.

So, here is a Java version:

``` public interface Operator
{
public Object apply( Object lhs, Object rhs ) ;
}

public class CollectOperator implements Operator
{
private Operator op;

public CollectOperation( Operator op )
{
this.op = op ;
}

public Object apply( Collection coll, Object start )
{
Object accumulator = start ;
Iterator it = coll.iterator() ;
while (it.hasNext())
{
Object obj = it.next() ;
accumulator = op.apply( accumulator, obj ) ;
}
return accumulator ;
}
}

public class IntArrayList extends AbstractList
{
private int[] arr ;

public IntArrayList( int[] arr )
{
this.arr = arr ;
}

public int size()
{
return arr.length ;
}

public Object get( int index )
{
int i = arr[index] ;
return new Integer( i ) ;
}
}

{
public Object apply( Object lhs, Object rhs )
{
int l = ((Integer)lhs).intValue() ;
int r = ((Integer)rhs).intValue() ;
int sum = l + r ;
return new Integer( sum ) ;
}
}

public int arraySum ( int[] arr )
{
List l = new IntArrayList( arr ) ;
Object sum = collectAdd.apply( l ) ;
return ((Integer)sum).intValue() ;
}
```
As you can see, Java is a far superior language to all others!

-- TomAnderson

Hehehe... a serious case of YouArentGonnaNeedIt-itis with BigDesignUpFront complications. Here's a simple version:

``` public static int sum( int[] a ) {
int sum = 0;
for( int i = 0; i < a.length; i++ ) sum += a[i];
return sum;
}

/**
* Java 5.0.
*/
// Returns the sum of the elements of array a
// (blatantly plagarized from http://java.sun.com/j2se/1.5.0/docs/guide/language/foreach.html )
public static int sum(int[] a) {
int result = 0;
for (int n : a)
result += n;
return result;
}
```

JavaScript:

As a PrototypeBasedLanguage, it is most convenient to add this method to the base Array object via its prototype:

``` Array.prototype.sum = function() {
var n = 0;
for (var i=0; i<this.length; i++) n += this[i];
return n;
}

assert( [1,2,3,4,5].sum() == 15 )
```

Since ECMA5.1 (JavaScript 1.8), reduce is available. (source: http://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce#Example:_Sum_up_all_values_within_an_array )

``` var total = [0, 1, 2, 3].reduce(function(a, b) {
return a + b;
});
// total == 6

```

KayLanguage:

```  x:+/a
```

LogoLanguage:

``` show reduce "sum [1 2 3 4 5]              ; quirk: won't work on the empty list

show (sum 1 2 3 4 5)
show apply "sum [1 2 3 4 5]
```

MatLab:

Assuming x is an array of numbers:

```  my_sum_scalar = sum(x(:));
```
will return a single value, the total of all the numbers in the entire array.

```  my_sum_vector = sum(x);
```
can take a 2D array of numbers and will return the sum "vector", a 1D array of the sum of each column of the array. (It also does something useful for 3D and higher-dimensional arrays -- the same as J (JayLanguage)).
NemerleLanguage:

(a list, rather than an array, but close enough)

``` using Nemerle.Collections.List;
module Sum {
Main(): void {
def l = [1, 2, 3, 4];
def sum = FoldLeft(l, 0, _+_);
System.Console.WriteLine(sum); //prints "10"
}
}
```

OberonLanguage:

```  MODULE Example;
PROCEDURE ArraySum*(r: ARRAY OF INTEGER);
VAR
sum: INTEGER;
i: INTEGER;
BEGIN
sum := 0;
FOR i := 0 TO LEN(r) - 1 DO
sum := sum + r[i]
END;
END ArraySum;
END Example.
```

ObjectiveCaml:

``` let int_sum = List.fold_left (+) 0;; (* for integers *)
let float_sum = List.fold_left (+.) 0.;; (* for floats *)
```
Note that the plus operator in OCaml is not polymorphic, hence the two versions.
PerlLanguage:

``` my \$sum = 0; # initialize to 0 to give the correct result for an empty array
\$sum += \$_ foreach @array;
```
Or a subroutine, if that's too long to type each time:
``` sub sum { my \$s = 0; \$s += \$_ for @_; \$s }
print sum(1, 2, 3, 4, 5);
```
The function has already been written:
``` use List::Util qw(sum);
print sum(0, @array), "\n"; # need the 0 to give the correct result for an empty array
```

PhpLanguage:

```  \$sum = array_sum(\$array);
```
or:

```  \$sum = 0;
foreach (\$array as \$item)
{
\$sum += \$item;
}
```

PythonLanguage:

```   arraysum = sum(array) # As we say in Brooklyn, "Terse is cherce."
```
If you want to write it out yourself you could use reduce:

```   import operator
arraysum = reduce( operator.add, array, 0 )
```
Or you could just use a loop:

```   total = 0
for value in array:
total += value

```
If you are summing floats in Python 2.6+, you should use math.fsum(), which avoids loss of precision:

```   import math
arraysum = math.fsum(array)
```

R ( ArrLanguage )
```  sum(anArray)
```

RubyLanguage:

``` def sumArray(a)
sum = 0
a.each {|x| sum = sum + x }
return sum
end

```
or

``` module ArraySum
def sum()
sum = 0
self.each {|x| sum = sum + x }
return sum
end
end

a = Array.[](1, 2, 3)
a.extend ArraySum

puts a.sum
```
one of ruby's nice features is that you can extend classes, including the system classes, without changing their source code. The above could be:

``` class Array
def sum
s = 0; each {|x| s = s + x}; s
end
end

[1, 2, 3, 4].sum
=> 10
```
And, as always, there's a better way to do it

``` def sumArray(a)
a.inject(0) { |sum, value| sum + value }
end
```
And then there's the slightly more general expression, which returns nil as its "0", but works for all types of lists
``` def sum a
a.inject { |sum, i| sum + i }
end
```

ScalaLanguage

``` def sum(a: Int*) = (0 /: a) (_ + _)

```
Lest you conclude that ScalaLanguage is an incomprehensible language, let me point out that "/:" is right-associative synonym for "foldLeft" and "(_ + _)" is shorthand for ((i, j) => i + j) so the above could be equivalently written:
``` def sum(a: Int*) = (a foldLeft 0) ((i, j) => i + j)
```
Or with more Java-like syntax:
``` def sum(a: Int*) = a.foldLeft(0) {(i, j) => i + j }

```
Scala 2.8 now has it built in to all collections so the above function is simply:
``` def sum(a: Int*) = a sum
```

SchemeLanguage:

At last, a chance to show off the do construct of the SchemeLanguage:

``` (define (vector-sum vec)
(do ((i 0 (+ i 1))
(sum 0 (+ sum (vector-ref vec i))))
((= i (vector-length vec)) sum)))

(vector-sum '#(1 2 3))
```
Doesn't Scheme have a fold/reduce/collect/whatever function?

[He's kidding. I hope. Presumably springboarding off the above Java joke. ]

Actually, while R5RS does not define any of them, one of the SchemeRequestsForImplementation (SRFI-1, List Library) has a full complement of fold and reduce functions. Thus, in an implementation that supports SRFI-7 and SRFI-1, one could write,
``` (program (requires srfi-1))
(fold + 0 '(1 2 3 4 5))
```
Mind you, these are list reduction functions, and so technically do not fit the problem description. That's OK, though, since writing a fold-vector function would be fairly easy:

``` (define (fold-right-vector op initial vec)
(let ((endpoint (- (vector-length vec) 1)))
(if (> 0 endpoint)
initial
(begin
(op initial
(let accumulate ((count 0))
(if (>= count endpoint)
(vector-ref vec count)
(op (vector-ref vec count) (accumulate (add1 count))))))))))

(define (vector-sum vec)
(fold-right-vector + 0 vec))

(vector-sum #(1 2 3 4 5))
```
(note that this code has only been cursorily tested and may have bugs). Of course, one could use (vector->list) and then apply the list (fold), but that doesn't exactly match the problem. Adapting this to work with homogeneous-numeric vectors (SRFI 4) or multidimensional arrays (SRFI 25) is left as an exercise. - JayOsako

You can sum lists in Scheme by
``` (define (list-sum lst)
(apply + lst))
```
Aren't Scheme implementations allowed to have a smallish upper limit on how many arguments you can pass to a procedure? If so, that solution might not work for long lists.

I see one argument there.

Then look again. The elements of lst are being turned into arguments to +. If there are more elements in the list than your implementation's limit on args passed to a procedure, then you lose.

It is exactly one argument. The list is not expanded into its elements. However, the task was to give a sum function for arrays. Since there are no native arrays in Scheme (just like C), the function does not deal with arrays. As for vectors, you either have to resort to the function given above or use (vector->list array) in the second version with some overhead.

That's certainly how it is in CommonLisp. In CommonLisp you'd use REDUCE: (defun sum-sequence (s) (reduce #'+ s :initial-value 0)), which works for both lists and vectors.

Common lisp actually has a (multivariate) array type, so in that case you could do something like

``` (defun sum-array (a)
(loop for n below (array-total-size a)
summing (row-major-aref a n)))
```

SmalltalkLanguage:

``` myArray := #(1 2 3 4 5).
sum := myArray detectSum: [ :n | n + 0 ].

```
Except that #detectSum: isn't part of redbook Smalltalk. Try this instead:
``` Array>>sum
^self
inject: 0
into: [:each :sum | each + sum]
```

SmlLanguage

Lines starting with a dash contain the code. Other lines have been printed by the compiler.

```  Standard ML of New Jersey v110.57 [built: Fri Feb 10 21:37:49 2006]
- val intArraySum = Array.foldl op+ 0 ;
[library \$SMLNJ-BASIS/basis.cm is stable]
val intArraySum = fn : int array -> int
- val realArraySum = Array.foldl op+ 0.0 ;
val realArraySum = fn : real array -> real
- intArraySum (Array.tabulate (10, fn i => i)) ;
val it = 45 : int
- realArraySum (Array.tabulate (10, real)) ;
val it = 45.0 : real
```

SqlLanguage (assuming your "array" is a column of a table):

```  select sum(x) from a

```

SwiftLanguage:

``` a.reduce(0) { \$0 + \$1 }

```

TclLanguage:

(In tcl a 'list' is the equivalent of a numerically indexed array)

```  if {[llength \$arr]} {expr [join \$arr +]} {expr 0}

```
or - if using Tcl's associative 'arrays'

```  set sum 0
foreach {nm val} [array get arrName] {
incr sum \$val
}
```

VisualBasicNine:

The most direct and efficient way to go is this:

``` Dim numbers%() = { 1, 2, 3, 4, 5 }
Dim sum = 0
For Each n In numbers
sum = sum + n
Next
```
This can also be written using the generic Aggregate operator defined by LINQ over any sequence of values.

``` Dim numbers%() = { 1, 2, 3, 4, 5 }
Dim sum = numbers.Aggregate(Function(a, b) a + b)
```
LINQ also predefines the Min, Max, Average, and Sum aggregates, which means you can just write it like this:

``` Dim numbers%() = { 1, 2, 3, 4, 5 }
Dim sum = numbers.Sum()
```
-- DonBox
VisualBasicForApplications:
```  WorksheetFunction.sum(anArray)

```

ExBase
``` * Populate an array.
DIMENSION aSumArray[10]

FOR x = 1 TO 10
aSumArray(x) = x
ENDFOR

* Sum its contents.
LOCAL oursum

oursum = 0

FOR x = 1 TO ALEN(aSumArray)
oursum = oursum + aSumArray(x)
ENDFOR
```
-- KenDibble
Contributors: Various AnonymousDonors, TomAnderson, EarleMartin

This is the type of problem in which CollectionOrientedProgramming languages are clearly better geared for.

Also see CounterInManyProgrammingLanguages, DotProductInManyProgrammingLanguages, HelloWorldInManyProgrammingLanguages, WardNumberInManyProgrammingLanguages, BetterForLoopConstruct

CategoryInManyProgrammingLanguages

View edit of September 30, 2014 or FindPage with title or text search