Sum and product of array
From Rosetta Code
Programming Task
This is a programming task. It lays out a problem which Rosetta Code users are encouraged to solve, using languages they know.
[edit] 4D
ARRAY INTEGER($list;0)
For ($i;1;5)
APPEND TO ARRAY($list;$i)
End for
$sum:=0
$product:=1
For ($i;1;Size of array($list))
$sum:=$var+$list{$i}
$product:=$product*$list{$i}
End for
[edit] Ada
type Int_Array is array(Integer range <>) of Integer; array : Int_Array := (1,2,3,4,5,6,7,8,9,10); Sum : Integer := 0; for I in array'range loop Sum := Sum + array(I); end loop;
Define the product function
function Product(Item : Int_Array) return Integer is Prod : Integer := 1; begin for I in Item'range loop Prod := Prod * Item(I); end loop; return Prod; end Product;
This function will raise the predefined exception Constraint_Error if the product overflows the values represented by type Integer
[edit] ALGOL 68
main:(
INT default upb := 3;
MODE INTARRAY = [default upb]INT;
INTARRAY array = (1,2,3,4,5,6,7,8,9,10);
INT sum := 0;
FOR i FROM LWB array TO UPB array DO
sum +:= array[i]
OD;
# Define the product function #
PROC int product = (INTARRAY item)INT:
(
INT prod :=1;
FOR i FROM LWB item TO UPB item DO
prod *:= item[i]
OD;
prod
) # int product # ;
printf(($" Sum: "g(0)$,sum,$", Product:"g(0)";"l$,int product(array)))
)
Output:
Sum: 55, Product:3628800;
[edit] APL
Works with: APL2
sum ← +/
prod ← ×/
list ← 1 2 3 4 5
sum list
15
prod list
120
[edit] AppleScript
set array to {1, 2, 3, 4, 5}
set sum to 0
set product to 1
repeat with i in array
set sum to sum + i
set product to product * i
end repeat
[edit] BASIC
Interpreter: unknown
10 REM Create an array with some test data in it 20 DIM ARRAY(5) 30 FOR I = 1 TO 5: READ ARRAY(I): NEXT I 40 DATA 1, 2, 3, 4, 5 50 REM Find the sum of elements in the array 60 SUM = 0 65 PRODUCT = 1 70 FOR I = 1 TO 5 72 SUM = SUM + ARRAY(I) 75 PRODUCT = PRODUCT + ARRAY(I) 77 NEXT I 80 PRINT "The sum is ";SUM; 90 PRINT " and the product is ";PRODUCT
Works with: FreeBASIC
dim array(5) as integer = { 1, 2, 3, 4, 5 }
dim sum as integer = 0 dim prod as integer = 1 for index as integer = lbound(array) to ubound(array) sum += array(index) prod *= array(index) next
[edit] C
/* using pointer arithmetic (because we can, I guess) */
int arg[] = { 1,2,3,4,5 };
int arg_length = sizeof(arg)/sizeof(arg[0]);
int *end = arg+arg_length;
int sum = 0, prod = 1;
int *p;
for (p = arg; p!=end; ++p) {
sum += *p;
prod *= *p;
}
[edit] C++
Library: STL
#include <numeric>
#include <functional>
int arg[] = { 1, 2, 3, 4, 5 };
int sum = std::accumulate(arg, arg+5, 0, std::plus<int>());
// or just
// std::accumulate(arg, arg + 5, 0);
// since plus() is the default functor for accumulate
int prod = std::accumulate(arg, arg+5, 1, std::multiplies<int>());
Template alternative:
// this would be more elegant using STL collections
template <typename T> T sum (const T *array, const unsigned n)
{
T accum = 0;
for (unsigned i=0; i<n; i++)
accum += array[i];
return accum;
}
template <typename T> T prod (const T *array, const unsigned n)
{
T accum = 1;
for (unsigned i=0; i<n; i++)
accum *= array[i];
return accum;
}
#include <iostream>
using std::cout;
using std::endl;
int main ()
{
int aint[] = {1, 2, 3};
cout << sum(aint,3) << " " << prod(aint, 3) << endl;
float aflo[] = {1.1, 2.02, 3.003, 4.0004};
cout << sum(aflo,4) << " " << prod(aflo,4) << endl;
return 0;
}
[edit] C#
int sum = 0, prod = 1;
int[] arg = { 1, 2, 3, 4, 5 };
foreach (int value in arg) {
sum += value;
prod *= value;
}
[edit] Clean
array = {1, 2, 3, 4, 5}
Sum = sum [x \\ x <-: array]
Prod = foldl (*) 1 [x \\ x <-: array]
[edit] ColdFusion
Sum of an Array,
<cfset Variables.myArray = [1,2,3,4,5,6,7,8,9,10]> <cfoutput>#ArraySum(Variables.myArray)#</cfoutput>
Product of an Array,
<cfset Variables.myArray = [1,2,3,4,5,6,7,8,9,10]> <cfset Variables.Product = 1> <cfloop array="#Variables.myArray#" index="i"> <cfset Variables.Product *= i> </cfloop> <cfoutput>#Variables.Product#</cfoutput>
[edit] Common Lisp
Works with: CLisp
(defparameter data #1A(1 2 3 4 5)) (values (reduce #'+ data) (reduce #'* data))
[edit] D
auto sum = 0, prod = 1; auto array = [1, 2, 3, 4, 5]; foreach(v; array) { sum += v; prod *= v; }
Compute sum and product of array in one pass using std.algorithm:
auto array = [1, 2, 3, 4, 5]; auto r = reduce!("a + b", "a * b")(0, 1, array); // 0 and 1 are seeds for corresponding functions writefln("Sum: ", r._0); // Results are stored in a tuple writefln("Product: ", r._1);
[edit] Delphi
var
Ints : array[1..5] of integer = (1,2,3,4,5) ;
i,Sum : integer = 0 ;
Prod : integer = 1 ;
begin
for i := 1 to length(ints) do begin
inc(sum,ints[i]) ;
prod := prod * ints[i]
end;
end;
[edit] E
pragma.enable("accumulator")
accum 0 for x in [1,2,3,4,5] { _ + x }
accum 1 for x in [1,2,3,4,5] { _ * x }
[edit] Erlang
Using the standard libraries:
% create the list: L = lists:seq(1, 10).
% and compute its sum: S = lists:sum(L). P = lists:foldl(fun (X, P) -> X * P end, 1, L).
Or defining our own versions:
-module(list_sum). -export([sum_rec/1, sum_tail/1]).
% recursive definition:
sum_rec([]) ->
0;
sum_rec([Head|Tail]) ->
Head + sum_rec(Tail).
% tail-recursive definition:
sum_tail(L) ->
sum_tail(L, 0).
sum_tail([], Acc) ->
Acc;
sum_tail([Head|Tail], Acc) ->
sum_tail(Tail, Head + Acc).
[edit] Factor
1 5 1 <range> dup sum . product .
15 120
{ 1 2 3 4 } dup sum swap product
10 24
sum and product are defined in the sequences vocabulary:
: sum ( seq -- n ) 0 [+] reduce ; : product ( seq -- n ) 1 [ * ] reduce ;
[edit] Forth
: third ( a b c -- a b c a ) 2 pick ; : reduce ( xt n addr cnt -- n' ) \ where xt ( a b -- n ) cells bounds do i @ third execute cell +loop nip ;
create a 1 , 2 , 3 , 4 , 5 , ' + 0 a 5 reduce . \ 15 ' * 1 a 5 reduce . \ 120
[edit] Fortran
In ISO Fortran 90 and later, use SUM and PRODUCT intrinsics:
integer, dimension(10) :: a = (/ (i, i=1, 10) /) integer :: sresult, presult sresult = sum(a); presult = product(a);
[edit] Groovy
[1,2,3,4,5].sum() [1,2,3,4,5].product()
[1,2,3,4,5].inject(0) { sum, val -> sum + val }
[1,2,3,4,5].inject(1) { prod, val -> prod * val }
[edit] Haskell
For lists, sum and product are already defined in the Prelude:
values = [1..10] s = sum values -- the easy way p = product values s' = foldl (+) 0 values -- the hard way p' = foldl (*) 1 values
To do the same for an array, just convert it lazily to a list:
import Data.Array values = listArray (1,10) [1..10] s = sum . elems $ values p = product . elems $ values
[edit] IDL
array = [3,6,8] print,total(array) print,product(array)
[edit] J
sum=: +/ product=: */
For example:
sum 1 3 5 7 9 11 13 49 product 1 3 5 7 9 11 13 135135 a=: 3 10 ?@$ 100 NB. random array a 90 47 58 29 22 32 55 5 55 73 58 50 40 5 69 46 34 40 46 84 29 8 75 97 24 40 21 82 77 9 sum a 177 105 173 131 115 118 110 127 178 166 product a 151380 18800 174000 14065 36432 58880 39270 16400 194810 55188 sum"1 a 466 472 462 product"1 a 5.53041e15 9.67411e15 1.93356e15
[edit] Java
public class SumProd{
public static void main(String[] args){
int sum= 0;
int prod= 1
int[] arg= {1,2,3,4,5};
for (int i: arg) {
sum+= i;
prod*= i;
}
}
}
[edit] JavaScript
var array = [1, 2, 3, 4, 5];
var sum = 0, prod = 1;
for(var i in array) {
sum += array[i];
prod *= array[i];
}
alert(sum + " " + prod);
[edit] Lisp
Works with: XEmacs version version 21.5.21
(setq array [1 2 3 4 5]) (eval (concatenate 'list '(+) array)) (eval (concatenate 'list '(*) array))
[edit] Logo
print apply "sum arraytolist {1 2 3 4 5}
print apply "product arraytolist {1 2 3 4 5}
[edit] Lucid
prints a running sum and product of sequence 1,2,3...
[%sum,product%]
where
x = 1 fby x + 1;
sum = 0 fby sum + x;
product = 1 fby product * x
end
[edit] MAXScript
arr = #(1, 2, 3, 4, 5) sum = 0 for i in arr do sum += i product = 1 for i in arr do product *= i
[edit] Nial
Nial being an array language, what applies to individual elements are extended to cover array operations by default strand notation
+ 1 2 3 = 6 * 1 2 3 = 6
array notation
+ [1,2,3]
grouped notation
(* 1 2 3) = 6 * (1 2 3) = 6
(All these notations are equivalent)
[edit] Objective-C
Works with: GCC version 4.0.1 (apple)
Sum:
- (float) sum:(NSMutableArray *)array
{
int i, sum, value;
sum = 0;
value = 0;
for (i = 0; i < [array count]; i++) {
value = [[array objectAtIndex: i] intValue];
sum += value;
}
return suml;
}
Product:
- (float) prod:(NSMutableArray *)array
{
int i, prod, value;
prod = 0;
value = 0;
for (i = 0; i < [array count]; i++) {
value = [[array objectAtIndex: i] intValue];
prod *= value;
}
return suml;
}
[edit] OCaml
let a = [| 1; 2; 3; 4; 5 |] in Array.fold_left (+) 0 a Array.fold_left ( * ) 1 a
Variant, using a liked list rather than an array:
let x = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10];; List.fold_left (+) 0 x List.fold_left ( * ) 1 x
[edit] Oz
functor
import
Application System
define
Print = System.showInfo
Arr = [1 2 3 4 5]
{Print {FoldL Arr Number.'+' 0}}
{Print {FoldL Arr Number.'*' 1}}
{Application.exit 0}
end
[edit] Perl
my ($sum, $prod) = (0, 1); my @list = (1, 2, 3); $sum += $_ foreach @list; $prod *= $_ foreach @list;
Alternate (note: won't work on empty list)
Library: List::Util
use List::Util qw(sum); my @list = (1, 2, 3); my $s = sum @list;
Alternate (note: won't work on empty list)
Library: List::Util
use List::Util qw(reduce);
my @list = (1, 2, 3);
my $sum = reduce { $a + $b } @list;
my $product = reduce { $a * $b } @list;
Alternate
# TMTOWTDI
my ($sum, $prod) = (0, 1);
my @list = qw(1 2 3);
map { $sum += $_ } @list;
map($prod *= $_, @list);
[edit] PHP
$array = array(1,2,3,4,5,6,7,8,9); echo array_sum($array); echo array_product($array);
[edit] Pop11
Simple loop:
lvars i, sum = 0, prod = 1, ar = {1 2 3 4 5 6 7 8 9};
for i from 1 to length(ar) do
ar(i) + sum -> sum;
ar(i) * prod -> prod;
endfor;
One can alternativly use second order iterator:
lvars sum = 0, prod = 1, ar = {1 2 3 4 5 6 7 8 9};
appdata(ar, procedure(x); x + sum -> sum; endprocedure);
appdata(ar, procedure(x); x * prod -> prod; endprocedure);
[edit] Prolog
sum([],0). sum([H|T],X) :- sum(T,Y), X is H + Y. product([],1). product([H|T],X) :- product(T,Y), X is H * X.
test
:- sum([1,2,3,4,5,6,7,8,9],X). X =45; :- product([1,2,3,4,5],X). X = 120;
[edit] Python
Works with: Python version 2.5
numbers = [1, 2, 3]
total = sum(numbers)
product = 1
for i in numbers:
product *= i
Or functionally (faster but perhaps less clear):
Works with: Python version 2.5
from operator import mul, add sum = reduce(add, numbers) # note: this version doesn't work with empty lists sum = reduce(add, numbers, 0) product = reduce(mul, numbers) # note: this version doesn't work with empty lists product = reduce(mul, numbers, 1)
Library: numpy
from numpy import r_ numbers = r_[1:4] total = numbers.sum() product = numbers.prod()
[edit] R
arr <- c(1,2,3,4,5) total <- sum(arr) product <- prod(arr)
[edit] Raven
0 [ 1 2 3 ] each + 1 [ 1 2 3 ] each *
[edit] Ruby
arr = [1,2,3,4,5] # or ary = *1..5
sum = arr.inject { |sum, item| sum + item }
# => 15
product = ary.inject{ |prod, element| prod * element }
# => 120
Ruby 1.9
arr = [1,2,3,4,5] # or ary = *1..5 sum = arr.inject(:+) # => 15 product = ary.inject(:*) # => 120
[edit] Scala
val a = Array(1,2,3,4,5)
val sum = a.foldLeft(0)(_ + _)
val product = a.foldLeft(1)(_ * _)
// (_ * _) is a shortcut for {(x,y) => x * y}
It may also be done in a classic imperative way :
var sum = 0; val product = 1 for (val x <- a) sum = sum + x for (val x <- a) product = product * x
[edit] Scheme
(apply + '(1 2 3 4 5)) (apply * '(1 2 3 4 5))
A tail-recursive solution, without the n-ary operator "trick". Because Scheme supports tail call optimization, this is as space-efficient as an imperative loop.
(define (reduce f i l)
(if (null? l)
i
(reduce f (f i (car l)) (cdr l))))
(reduce + 0 '(1 2 3 4 5)) ;; 0 is unit for +
(reduce * 1 '(1 2 3 4 5)) ;; 1 is unit for *
[edit] Seed7
const func integer: sumArray (in array integer: valueArray) is func
result
var integer: sum is 0;
local
var integer: value is 0;
begin
for value range valueArray do
sum +:= value;
end for;
end func;
const func integer: prodArray (in array integer: valueArray) is func
result
var integer: prod is 1;
local
var integer: value is 0;
begin
for value range valueArray do
prod *:= value;
end for;
end func;
Call these functions with:
writeln(sumArray([](1, 2, 3, 4, 5))); writeln(prodArray([](1, 2, 3, 4, 5)));
[edit] Smalltalk
#(1 2 3 4 5) inject: 0 into: [:sum :number | sum + number] #(1 2 3 4 5) inject: 1 into: [:product :number | product * number]
Some implementation also provide a fold: message:
#(1 2 3 4 5) fold: [:sum :number | sum + number] #(1 2 3 4 5) fold: [:product :number | product * number]
[edit] Standard ML
val array = [1,2,3,4,5]; foldl op+ 0 array; foldl (op*) 1 array;
[edit] Tcl
set arr [list 3 6 8] set sum [expr [join $arr +]] set prod [expr [join $arr *]]
[edit] Toka
4 cells is-array foo 212 1 foo array.put 51 2 foo array.put 12 3 foo array.put 91 4 foo array.put [ ( array size -- sum ) >r 0 r> 0 [ over i swap array.get + ] countedLoop nip ] is sum-array
( product ) reset 1 4 0 [ i foo array.get * ] countedLoop .
[edit] UNIX Shell
Works with: NetBSD version 3.0
From an internal variable, $IFS delimited:
sum=0 prod=1 list="1 2 3" for n in $list do sum="$(($sum + $n))"; prod="$(($prod * $n))" done echo $sum $prod
From the argument list (ARGV):
sum=0 prod=1 for n do sum="$(($sum + $n))"; prod="$(($prod * $n))" done echo $sum $prod
From STDIN, one integer per line:
sum=0 prod=1 while read n do sum="$(($sum + $n))"; prod="$(($prod * $n))" done echo $sum $prod
Works with: GNU bash version 3.2.0(1)-release (i386-unknown-freebsd6.1)
From variable:
LIST='20 20 2'; SUM=0; PROD=1; for i in $LIST; do SUM=$[$SUM + $i]; PROD=$[$PROD * $i]; done; echo $SUM $PROD
[edit] UnixPipes
prod() {
(read B; res=$1; test -n "$B" && expr $res \* $B || echo $res)
}
sum() {
(read B; res=$1; test -n "$B" && expr $res + $B || echo $res)
}
fold() {
(func=$1; while read a ; do ; fold $func | $func $a done)
}
(echo 3; echo 1; echo 4;echo 1;echo 5;echo 9) | tee >(fold sum) >(fold prod) > /dev/null
[edit] V
[sp dup 0 [+] fold 'product=' put puts 1 [*] fold 'sum=' put puts].
Using it
[1 2 3 4 5] sp = product=15 sum=120
[edit] XSLT
XSLT (or XPath rather) has a few built-in functions for reducing from a collection, but product is not among them. Because of referential transparency, one must resort to recursive solutions for general iterative operations upon collections. The following code represents the array by numeric values in <price> elements in the source document.
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="text" />
<xsl:template name="sum-prod">
<xsl:param name="values" />
<xsl:param name="sum" select="0" />
<xsl:param name="prod" select="1" />
<xsl:choose>
<xsl:when test="not($values)">
<xsl:text>
Sum: </xsl:text>
<xsl:value-of select="$sum" />
<xsl:text>
Product: </xsl:text>
<xsl:value-of select="$prod" />
</xsl:when>
<xsl:otherwise>
<xsl:call-template name="sum-prod">
<xsl:with-param name="values" select="$values[position() > 1]" />
<xsl:with-param name="sum" select="$sum + $values[1]" />
<xsl:with-param name="prod" select="$prod * $values[1]" />
</xsl:call-template>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template match="/">
<xsl:text>
Sum (built-in): </xsl:text>
<xsl:value-of select="sum(//price)" />
<xsl:call-template name="sum-prod">
<xsl:with-param name="values" select="//price" />
</xsl:call-template>
</xsl:template>
</xsl:stylesheet>
Categories: Programming Tasks | Arithmetic operations | 4D | Ada | ALGOL 68 | APL | AppleScript | BASIC | C | C++ | STL | C sharp | Clean | ColdFusion | Common Lisp | D | Delphi | E | Erlang | Factor | Forth | Fortran | Groovy | Haskell | IDL | J | Java | JavaScript | Lisp | Logo | Lucid | MAXScript | Nial | Objective-C | OCaml | Oz | Perl | List::Util | PHP | Pop11 | Prolog | Python | Numpy | R | Raven | Ruby | Scala | Scheme | Seed7 | Smalltalk | Standard ML | Tcl | Toka | UNIX Shell | UnixPipes | V | XSLT
