Sum and product of an array

From Rosetta Code
(Redirected from Sum and product of array)
Jump to: navigation, search
Task
Sum and product of an array
You are encouraged to solve this task according to the task description, using any language you may know.

Compute the sum and product of an array of integers.

Contents

[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] ACL2

(defun sum (xs)
(if (endp xs)
0
(+ (first xs)
(sum (rest xs)))))
 
(defun prod (xs)
(if (endp xs)
1
(* (first xs)
(prod (rest xs)))))

[edit] ActionScript

package {
import flash.display.Sprite;
 
public class SumAndProduct extends Sprite
{
public function SumAndProduct()
{
var arr:Array = [1, 2, 3, 4, 5];
var sum:int = 0;
var prod:int = 1;
 
for (var i:int = 0; i < arr.length; i++)
{
sum += arr[i];
prod *= arr[i];
}
 
trace("Sum: " + sum); // 15
trace("Product: " + prod); // 120
}
}
}

[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] Aime

void
compute(integer &s, integer &p, list l)
{
integer i;
 
s = 0;
p = 1;
i = l_length(l);
while (i) {
i -= 1;
s += l_q_integer(l, i);
p *= l_q_integer(l, i);
}
}
 
integer
main(void)
{
integer sum, product;
 
compute(sum, product, l_effect(2, 3, 5, 7, 11, 13, 17, 19));
 
o_integer(sum);
o_newline();
o_integer(product);
o_newline();
 
return 0;
}
Output:
77
9699690

[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] AutoHotkey

numbers = 1,2,3,4,5
product := 1
loop, parse, numbers, `,
{
sum += A_LoopField
product *= A_LoopField
}
msgbox, sum = %sum%`nproduct = %product%

[edit] AWK

For array input, it is easiest to "deserialize" it from a string with the split() function.

$ awk 'func sum(s){split(s,a);r=0;for(i in a)r+=a[i];return r}{print sum($0)}'
1 2 3 4 5 6 7 8 9 10
55
 
$ awk 'func prod(s){split(s,a);r=1;for(i in a)r*=a[i];return r}{print prod($0)}'
1 2 3 4 5 6 7 8 9 10
3628800

[edit] Babel

main: { [2 3 5 7 11 13] sp }
 
sum!  : { <- 0 -> { + } eachar }
product!: { <- 1 -> { * } eachar }
 
sp!:
{ dup
sum %d cr <<
product %d cr << }
 
Result:
41
30030

Perhaps better Babel:

main: 
{ [2 3 5 7 11 13]
ar2ls dup cp
<- sum_stack ->
prod_stack
 %d cr <<
 %d cr << }
 
sum_stack:
{ { give
{ + }
{ depth 1 > }
do_while } nest }
 
prod_stack:
{ { give
{ * }
{ depth 1 > }
do_while } nest }

The nest operator creates a kind of argument-passing context - it saves whatever is on Top-of-Stack (TOS), saves the old stack, clears the stack and places the saved TOS on the new, cleared stack. This permits a section to monopolize the stack. At the end of the nest context, whatever is on TOS will be "passed back" to the original stack which will be restored.

The depth operator returns the current depth of the stack.

[edit] BASIC

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] Applesoft BASIC

 10 N = 5
20 S = 0:P = 1: DATA 1,2,3,4,5
30 N = N - 1: DIM A(N)
40 FOR I = 0 TO N
50 READ A(I): NEXT
60 FOR I = 0 TO N
70 S = S + A(I):P = P * A(I)
80 NEXT
90 PRINT "SUM="S,"PRODUCT="P

[edit] BBC BASIC

      DIM array%(5)
array%() = 1, 2, 3, 4, 5, 6
 
PRINT "Sum of array elements = " ; SUM(array%())
 
product% = 1
FOR I% = 0 TO DIM(array%(),1)
product% *= array%(I%)
NEXT
PRINT "Product of array elements = " ; product%

[edit] bc

a[0] = 3.0
a[1] = 1
a[2] = 4.0
a[3] = 1.0
a[4] = 5
a[5] = 9.00
n = 6
p = 1
for (i = 0; i < n; i++) {
s += a[i]
p *= a[i]
}
"Sum: "; s
"Product: "; p

[edit] Befunge

Works with: befungee

The program first reads the number of elements in the array, then the elements themselves (each number on a separate line) and calculates their sum.

0 &>: #v_ $. @
>1- \ & + \v
^ <

[edit] Bracmat

( ( sumprod
= sum prod num
. 0:?sum
& 1:?prod
& (  !arg
 :  ?
( #%?num ?
& !num+!sum:?sum
& !num*!prod:?prod
& ~
)
| (!sum.!prod)
)
)
& out$sumprod$(2 3 5 7 11 13 17 19)
);
Output:
77.9699690

[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] Alternative using Linq (C# 3)

Works with: C# version 3
int[] arg = { 1, 2, 3, 4, 5 };
int sum = arg.Sum();
int prod = arg.Aggregate((runningProduct, nextFactor) => runningProduct * nextFactor);

[edit] Chef

Sum and Product of Numbers as a Piece of Cake.
 
This recipe sums N given numbers.
 
Ingredients.
1 N
0 sum
1 product
1 number
 
Method.
Put sum into 1st mixing bowl.
Put product into 2nd mixing bowl.
Take N from refrigerator.
Chop N.
Take number from refrigerator.
Add number into 1st mixing bowl.
Combine number into 2nd mixing bowl.
Chop N until choped.
Pour contents of 2nd mixing bowl into the baking dish.
Pour contents of 1st mixing bowl into the baking dish.
 
Serves 1.

[edit] Clean

array = {1, 2, 3, 4, 5}
Sum = sum [x \\ x <-: array]
Prod = foldl (*) 1 [x \\ x <-: array]

[edit] Clojure

(defn sum [vals] (reduce + vals))
 
(defn product [vals] (reduce * vals))

[edit] COBOL

       IDENTIFICATION DIVISION.
PROGRAM-ID. array-sum-and-product.
 
DATA DIVISION.
WORKING-STORAGE SECTION.
78 Array-Size VALUE 10.
01 array-area VALUE "01020304050607080910".
03 array PIC 99 OCCURS Array-Size TIMES.
 
01 array-sum PIC 9(8).
01 array-product PIC 9(10) VALUE 1.
 
01 i PIC 99.
 
PROCEDURE DIVISION.
PERFORM VARYING i FROM 1 BY 1 UNTIL Array-Size < i
ADD array (i) TO array-sum
MULTIPLY array (i) BY array-product
END-PERFORM
 
DISPLAY "Sum: " array-sum
DISPLAY "Product: " array-product
 
GOBACK
.

[edit] CoffeeScript

 
sum = (array) ->
array.reduce (x, y) -> x + y
 
product = (array) ->
array.reduce (x, y) -> x * y
 

[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

(let ((data #(1 2 3 4 5)))     ; the array
(values (reduce #'+ data) ; sum
(reduce #'* data))) ; product

The loop macro also has support for sums.

(loop for i in '(1 2 3 4 5) sum i)

[edit] D

import std.stdio;
 
void main() {
immutable array = [1, 2, 3, 4, 5];
 
int sum = 0;
int prod = 1;
 
foreach (x; array) {
sum += x;
prod *= x;
}
 
writeln("Sum: ", sum);
writeln("Product: ", prod);
}
Output:
Sum: 15
Product: 120

Compute sum and product of array in one pass (same output):

import std.stdio, std.algorithm, std.typecons;
 
void main() {
immutable array = [1, 2, 3, 4, 5];
 
// Results are stored in a 2-tuple
immutable r = reduce!(q{a + b}, q{a * b})(tuple(0, 1), array);
 
writeln("Sum: ", r[0]);
writeln("Product: ", r[1]);
}

[edit] Delphi

program SumAndProductOfArray;
 
{$APPTYPE CONSOLE}
 
var
i: integer;
lIntArray: array [1 .. 5] of integer = (1, 2, 3, 4, 5);
lSum: integer = 0;
lProduct: integer = 1;
begin
for i := 1 to length(lIntArray) do
begin
Inc(lSum, lIntArray[i]);
lProduct := lProduct * lIntArray[i]
end;
 
Write('Sum: ');
Writeln(lSum);
Write('Product: ');
Writeln(lProduct);
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] Emacs 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] With a list

(setq array '(1 2 3 4 5))
(apply '+ array)
(apply '* array)

[edit] With explicit conversion

(setq array [1 2 3 4 5])
(apply '+ (append array nil))
(apply '* (append array nil))

[edit] Eiffel

 
note
description : "project application root class"
date : "$Date$"
revision : "$Revision$"
 
class
APPLICATION
 
inherit
ARGUMENTS
 
create
make
 
feature {NONE}
 
array : ARRAY[INTEGER]
 
make
do
create array.make_filled (0, 0, 4)
array.put (2, 0)
array.put (4, 1)
array.put (6, 2)
array.put (8, 3)
array.put (10, 4)
 
print("%NSum of the elements of the array: ")
print(sum(array))
print("%NProduct of the elements of the array: ")
print(product(array))
end
 
sum(ar : ARRAY[INTEGER]):INTEGER
local
s, i: INTEGER
do
from
i := 0
until
i > 4
loop
s := s + ar[i]
i := i + 1
end
Result := s
end
 
product(ar : ARRAY [INTEGER]):INTEGER
local
prod, i: INTEGER
do
prod := 1
from
i := 0
until
i > 4
loop
prod := prod * ar[i]
i := i + 1
end
Result := prod
end
end
 
Output:
Sum of the elements of the array: 30
Product of the elements of the array: 3840

[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).

To compute sum and products in one pass:

 
{Prod,Sum} = lists:foldl(fun (X, {P,S}) -> {P*X,S+X} end, {1,0}, lists:seq(1,10)).

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] Euphoria

sequence array
integer sum,prod
 
array = { 1, 2, 3, 4, 5 }
 
sum = 0
prod = 1
for i = 1 to length(array) do
sum += array[i]
prod *= array[i]
end for
 
printf(1,"sum is %d\n",sum)
printf(1,"prod is %d\n",prod)
Output:
 sum is 15
 prod is 120

[edit] F#

 
let numbers = [| 1..10 |]
let sum = numbers |> Array.sum
let product = numbers |> Array.fold (*) 1
 

[edit] Factor

1 5 1 <range> [ sum . ] [ product . ] bi
15 120
{ 1 2 3 4 } [ sum ] [ product ] bi
10 24

sum and product are defined in the sequences vocabulary:

: sum ( seq -- n ) 0 [ + ] reduce ;
: product ( seq -- n ) 1 [ * ] reduce ;

[edit] FALSE

Strictly speaking, there are no arrays in FALSE. However, a number of elements on the stack could be considered an array. The implementation below assumes the length of the array on top of the stack, and the actual items below it. Note that this implementation does remove the "array" from the stack, so in case the original values need to be retained, a copy should be provided before executing this logic.

1 2 3 4 5 {input "array"}
5 {length of input}
0s: {sum}
1p: {product}
 
[$0=~][1-\$s;+s:p;*p:]#%
 
"Sum: "s;."
Product: "p;.
Output:
Sum: 15
Product: 120

[edit] Fantom

 
class Main
{
public static Void main ()
{
Int[] array := (1..20).toList
 
// you can use a loop
Int sum := 0
array.each |Int n| { sum += n }
echo ("Sum of array is : $sum")
 
Int product := 1
array.each |Int n| { product *= n }
echo ("Product of array is : $product")
 
// or use 'reduce'
// 'reduce' takes a function,
// the first argument is the accumulated value
// and the second is the next item in the list
sum = array.reduce(0) |Obj r, Int v -> Obj|
{
return (Int)r + v
}
echo ("Sum of array : $sum")
 
product = array.reduce(1) |Obj r, Int v -> Obj|
{
return (Int)r * v
}
echo ("Product of array : $product")
}
}
 

[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] Frink

 
a = [1,2,3,5,7]
sum[a]
product[a]
 

[edit] GAP

v := [1 .. 8];
 
Sum(v);
# 36
 
Product(v);
# 40320
 
# You can sum or multiply the result of a function
 
Sum(v, n -> n^2);
# 204
 
Product(v, n -> 1/n);
# 1/40320

[edit] Go

package main
 
import "fmt"
 
func main() {
sum, prod := 0, 1
for _, x := range []int{1,2,5} {
sum += x
prod *= x
}
fmt.Println(sum, prod)
}

[edit] Groovy

Groovy adds a "sum()" method for collections, but not a "product()" method:

[1,2,3,4,5].sum()

However, for general purpose "reduction" or "folding" operations, Groovy does provide an "inject()" method for collections similar to "inject" in Ruby.

[1,2,3,4,5].inject(0) { sum, val -> sum + val }
[1,2,3,4,5].inject(1) { prod, val -> prod * val }

You can also combine these operations:

println ([1,2,3,4,5].inject([sum: 0, product: 1]) { result, value ->
[sum: result.sum + value, product: result.product * value]})

[edit] GW-BASIC

Works with: GW-BASIC
Works with: QBasic
10 REM Create an array with some test DATA in it
20 DIM A(5)
30 FOR I = 1 TO 5: READ A(I): NEXT I
40 DATA 1, 2, 3, 4, 5
50 REM Find the sum of elements in the array
60 S = 0
65 P = 1
70 FOR I = 1 TO 5
72 S = SUM + A(I)
75 P = P * A(I)
77 NEXT I
80 PRINT "The sum is "; S;
90 PRINT " and the product is "; P

[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] HicEst

array = $ ! 1, 2, ..., LEN(array)
 
sum = SUM(array)
 
product = 1 ! no built-in product function in HicEst
DO i = 1, LEN(array)
product = product * array(i)
ENDDO
 
WRITE(ClipBoard, Name) n, sum, product ! n=100; sum=5050; product=9.33262154E157;

[edit] IDL

array = [3,6,8]
print,total(array)
print,product(array)

[edit] Icon and Unicon

The program below prints the sum and product of the arguments to the program.

procedure main(arglist)
every ( sum := 0 ) +:= !arglist
every ( prod := 1 ) *:= !arglist
write("sum := ", sum,", prod := ",prod)
end

[edit] Inform 7

Sum And Product is a room.
 
To decide which number is the sum of (N - number) and (M - number) (this is summing):
decide on N + M.
 
To decide which number is the product of (N - number) and (M - number) (this is production):
decide on N * M.
 
When play begins:
let L be {1, 2, 3, 4, 5};
say "List: [L in brace notation], sum = [summing reduction of L], product = [production reduction of L].";
end the story.

[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
 
NB. on a table, each row is an item to be summed:
sum a
177 105 173 131 115 118 110 127 178 166
product a
151380 18800 174000 14065 36432 58880 39270 16400 194810 55188
 
NB. but we can tell J to sum everything within each row, instead:
sum"1 a
466 472 462
product"1 a
5.53041e15 9.67411e15 1.93356e15

[edit] Java

Works with: Java version 1.5+
public class SumProd
{
public static void main(final String[] args)
{
int sum = 0;
int prod = 1;
int[] arg = {1,2,3,4,5};
for (int i : arg)
{
sum += i;
prod *= i;
}
}
}
Works with: Java version 1.8+
import java.util.Arrays;
 
public class SumProd
{
public static void main(final String[] args)
{
int[] arg = {1,2,3,4,5};
System.out.printf("sum = %d\n", Arrays.stream(arg).sum());
System.out.printf("sum = %d\n", Arrays.stream(arg).reduce(0, (a, b) -> a + b));
System.out.printf("product = %d\n", Arrays.stream(arg).reduce(1, (a, b) -> a * b));
}
}
Output:
sum = 15
sum = 15
product = 120

[edit] JavaScript

var array = [1, 2, 3, 4, 5],
sum = 0,
prod = 1,
i;
for (i = 0; i < array.length; i += 1) {
sum += array[i];
prod *= array[i];
}
alert(sum + ' ' + prod);


Works with: Javascript version 1.8

Where supported, the reduce method can also be used:

var array = [1, 2, 3, 4, 5],
sum = array.reduce(function (a, b) {
return a + b;
}, 0),
prod = array.reduce(function (a, b) {
return a * b;
}, 1);
alert(sum + ' ' + prod);

[edit] jq

The builtin filter, add/0, computes the sum of an array:

[4,6,8] | add
# => 18

An efficient companion filter for computing the product of the items in an array can be defined as follows:

def prod: reduce .[] as $i; (1; . * $i);

Example:

[4,6,8] | prod
# => 192

[edit] Julia

julia> sum([4,6,8])
18
 
julia> prod([4,6,8])
192

[edit] Lang5

4 iota 1 + dup
 
'+ reduce
'* reduce


[edit] Lasso

local(x = array(1,2,3,4,5,6,7,8,9,10))
// sum of array elements
'Sum: '
with n in #x
sum #n
'\r'
// product of arrray elements
'Product: '
local(product = 1)
with n in #x do => { #product *= #n }
#product
Output:
Sum: 55
Product: 3628800

[edit] Liberty BASIC

Dim array(19)
 
For i = 0 To 19
array(i) = Int(Rnd(1) * 20)
Next i
 
'product must first equal one or you will get 0 as the product
product = 1
For i = 0 To 19
sum = (sum + array(i))
product = (product * array(i))
next i
 
Print "Sum is " + str$(sum)
Print "Product is " + str$(product)

[edit]

print apply "sum arraytolist {1 2 3 4 5}
print apply "product arraytolist {1 2 3 4 5}

[edit] Lua

 
function sumf(a, ...) return a and a + sumf(...) or 0 end
function sumt(t) return sumf(unpack(t)) end
function prodf(a, ...) return a and a * prodf(...) or 1 end
function prodt(t) return prodf(unpack(t)) end
 
print(sumt{1, 2, 3, 4, 5})
print(prodt{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] Mathematica

Mathematica provides many ways of doing the sum of an array (any kind of numbers or symbols):

a = {1, 2, 3, 4, 5}
Plus @@ a
Apply[Plus, a]
Total[a]
Total@a
a // Total
Sum[a[[i]], {i, 1, Length[a]}]
Sum[i, {i, a}]

all give 15. For product we also have a couple of choices:

a = {1, 2, 3, 4, 5}
Times @@ a
Apply[Times, a]
Product[a[[i]], {i, 1, Length[a]}]
Product[i, {i, a}]

all give 120.

[edit] MATLAB

These two function are built into MATLAB as the "sum(array)" and "prod(array)" functions.

Sample Usage:

>> array = [1 2 3;4 5 6;7 8 9]
 
array =
 
1 2 3
4 5 6
7 8 9
 
>> sum(array,1)
 
ans =
 
12 15 18
 
>> sum(array,2)
 
ans =
 
6
15
24
 
>> prod(array,1)
 
ans =
 
28 80 162
 
>> prod(array,2)
 
ans =
 
6
120
504


[edit] Maxima

lreduce("+", [1, 2, 3, 4, 5, 6, 7, 8]);
36
 
lreduce("*", [1, 2, 3, 4, 5, 6, 7, 8]);
40320

[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] МК-61/52

^	1	ПE	+	П0	КИП0	x#0	18	^	ИПD
+ ПD <-> ИПE * ПE БП 05 С/П

Instruction: РX - array length, Р1:РC - array, РD and РE - sum and product of an array.

[edit] Modula-3

MODULE Sumprod EXPORTS Main;
 
FROM IO IMPORT Put;
FROM Fmt IMPORT Int;
 
VAR a := ARRAY [1..5] OF INTEGER {1, 2, 3, 4, 5};
VAR sum: INTEGER := 0;
VAR prod: INTEGER := 1;
 
BEGIN
FOR i := FIRST(a) TO LAST(a) DO
INC(sum, a[i]);
prod := prod * a[i];
END;
Put("Sum of array: " & Int(sum) & "\n");
Put("Product of array: " & Int(prod) & "\n");
END Sumprod.
Output:
Sum of array: 15
Product of array: 120

[edit] MUMPS

 
SUMPROD(A)
 ;Compute the sum and product of the numbers in the array A
NEW SUM,PROD,POS
 ;SUM is the running sum,
 ;PROD is the running product,
 ;POS is the position within the array A
SET SUM=0,PROD=1,POS=""
FOR SET POS=$ORDER(A(POS)) Q:POS="" SET SUM=SUM+A(POS),PROD=PROD*A(POS)
WRITE !,"The sum of the array is "_SUM
WRITE !,"The product of the array is "_PROD
KILL SUM,PROD,POS
QUIT
Example:
USER>SET C(-1)=2,C("A")=3,C(42)=1,C(0)=7
 
USER>D SUMPROD^ROSETTA(.C)
 
The sum of the array is 13
The product of the array is 42

Note - the string "A" converts to 0 when doing mathematical operations.

USER>SET C(-1)=2,C("A")="3H",C(42)=.1,C(0)=7.0,C("B")="A"
 
USER>D SUMPROD^ROSETTA(.C)
 
The sum of the array is 12.1
The product of the array is 0

[edit] Nemerle

As mentioned for some of the other functional languages, it seems more natural to work with lists in Nemerle, but as the task specifies working on an array, this solution will work on either.

using System;
using System.Console;
using System.Collections.Generic;
using Nemerle.Collections;
 
module SumProd
{
Sum[T] (nums : T) : int
where T : IEnumerable[int]
{
nums.FoldLeft(0, _+_)
}
 
Product[T] (nums : T) : int
where T : IEnumerable[int]
{
nums.FoldLeft(1, _*_)
}
 
Main() : void
{
def arr = array[1, 2, 3, 4, 5];
def lis = [1, 2, 3, 4, 5];
 
def suml = Sum(lis);
def proda = Product(arr);
 
WriteLine("Sum is: {0}\tProduct is: {1}", suml, proda);
}
}

[edit] NetRexx

/* NetRexx */
 
options replace format comments java crossref savelog symbols binary
 
harry = [long 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
sum = long 0
product = long 1
entries = Rexx ''
 
loop n_ = int 0 to harry.length - 1
nxt = harry[n_]
entries = entries nxt
sum = sum + nxt
product = product * nxt
end n_
 
entries = entries.strip
 
say 'Sum and product of' entries.changestr(' ', ',')':'
say ' Sum:' sum
say ' Product:' product
 
return
 
Output:
 Sum and product of 1,2,3,4,5,6,7,8,9,10:
     Sum: 55
 Product: 3628800

[edit] NewLISP

(setq a '(1 2 3 4 5))
(apply + a)
(apply * a)

[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] Nimrod

var xs = @[1,2,3,4,5,6]
 
var sum, product: int
 
product = 1
 
for x in xs:
sum += x
product *= x

Or functionally:

import sequtils
 
let
xs = @[1,2,3,4,5,6]
sum = xs.foldl(a + b)
product = xs.foldl(a * b)

[edit] Objeck

 
sum := 0;
prod := 1;
arg := [1, 2, 3, 4, 5];
each(i : arg) {
sum += arg[i];
prod *= arg[i];
};
 

[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

[edit] Arrays

(* ints *)
let a = [| 1; 2; 3; 4; 5 |];;
Array.fold_left (+) 0 a;;
Array.fold_left ( * ) 1 a;;
(* floats *)
let a = [| 1.0; 2.0; 3.0; 4.0; 5.0 |];;
Array.fold_left (+.) 0.0 a;;
Array.fold_left ( *.) 1.0 a;;

[edit] Lists

(* ints *)
let x = [1; 2; 3; 4; 5];;
List.fold_left (+) 0 x;;
List.fold_left ( * ) 1 x;;
(* floats *)
let x = [1.0; 2.0; 3.0; 4.0; 5.0];;
List.fold_left (+.) 0.0 x;;
List.fold_left ( *.) 1.0 x;;

[edit] Octave

a = [ 1, 2, 3, 4, 5, 6 ];
b = [ 10, 20, 30, 40, 50, 60 ];
vsum = a + b;
vprod = a .* b;

[edit] Oz

Calculations like this are typically done on lists, not on arrays:

declare
Xs = [1 2 3 4 5]
Sum = {FoldL Xs Number.'+' 0}
Product = {FoldL Xs Number.'*' 1}
in
{Show Sum}
{Show Product}

If you are actually working with arrays, a more imperative approach seems natural:

declare
Arr = {Array.new 1 3 0}
Sum = {NewCell 0}
in
Arr.1 := 1
Arr.2 := 2
Arr.3 := 3
 
for I in {Array.low Arr}..{Array.high Arr} do
Sum := @Sum + Arr.I
end
{Show @Sum}

[edit] PARI/GP

vecsum(v)={
sum(i=1,#v,v[i])
};
vecprod(v)={
prod(i=1,#v,v[i])
};

[edit] Pascal

See Delphi

[edit] Perl

my @list = ( 1, 2, 3 );
 
my ( $sum, $prod ) = ( 0, 1 );
$sum += $_ foreach @list;
$prod *= $_ foreach @list;

Or using the List::Util module:

use List::Util qw/sum0 product/;
my @list = (1..9);
 
say "Sum: ", sum0(@list); # sum0 returns 0 for an empty list
say "Product: ", product(@list);
Output:
Sum: 45
Product: 362880

[edit] Perl 6

my @ary = 1, 5, 10, 100;
say 'Sum: ', [+] @ary;
say 'Product: ', [*] @ary;

[edit] PHP

$array = array(1,2,3,4,5,6,7,8,9);
echo array_sum($array);
echo array_product($array);

[edit] PicoLisp

(let Data (1 2 3 4 5)
(cons
(apply + Data)
(apply * Data) ) )
Output:
(15 . 120)

[edit] PL/I

declare A(10) fixed binary static initial
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
 
put skip list (sum(A));
put skip list (prod(A));

[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 alternatively 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] PowerShell

The Measure-Object cmdlet already knows how to compute a sum:

function Get-Sum ($a) {
return ($a | Measure-Object -Sum).Sum
}

But not how to compute a product:

function Get-Product ($a) {
if ($a.Length -eq 0) {
return 0
} else {
$p = 1
foreach ($x in $a) {
$p *= $x
}
return $p
}
}

One could also let PowerShell do all the work by simply creating an expression to evaluate:

Works with: PowerShell version 2
function Get-Product ($a) {
if ($a.Length -eq 0) {
return 0
}
$s = $a -join '*'
return (Invoke-Expression $s)
}

Even nicer, however, is a function which computes both at once and returns a custom object with appropriate properties:

function Get-SumAndProduct ($a) {
$sum = 0
if ($a.Length -eq 0) {
$prod = 0
} else {
$prod = 1
foreach ($x in $a) {
$sum += $x
$prod *= $x
}
}
$ret = New-Object PSObject
$ret | Add-Member NoteProperty Sum $sum
$ret | Add-Member NoteProperty Product $prod
return $ret
}
Output:
PS> Get-SumAndProduct 5,9,7,2,3,8,4

Sum Product
--- -------
 38   60480

[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;


Using fold

 
add(A,B,R):-
R is A + B.
 
mul(A,B,R):-
R is A * B.
 
% define fold now.
fold([], Act, Init, Init).
 
fold(Lst, Act, Init, Res):-
head(Lst,Hd),
tail(Lst,Tl),
apply(Act,[Init, Hd, Ra]),
fold(Tl, Act, Ra, Res).
 
sumproduct(Lst, Sum, Prod):-
fold(Lst,mul,1, Prod),
fold(Lst,add,0, Sum).
 
?- sumproduct([1,2,3,4],Sum,Prod).
Sum = 10,
Prod = 24 .
 
 

[edit] PostScript

 
/sumandproduct
{
/x exch def
/sum 0 def
/prod 0 def
/i 0 def
x length 0 eq
{
}
{
/prod prod 1 add def
x length{
/sum sum x i get add def
/prod prod x i get mul def
/i i 1 add def
}repeat
}ifelse
sum ==
prod ==
}def
 
Library: initlib
 
% sum
[1 1 1 1 1] 0 {add} fold
% product
[1 1 1 1 1] 1 {mul} fold
 
 

[edit] PureBasic

Dim MyArray(9)
Define a, sum=0, prod=1
 
For a = 0 To ArraySize(MyArray()) ; Create a list of some random numbers
MyArray(a) = 1 + Random(9) ; Insert a number [1...10] in current element
Next
 
For a = 0 To ArraySize(MyArray()) ; Calculate Sum and Product of this Array
sum + MyArray(a)
prod * MyArray(a)
Next
 
Debug "The sum is " + Str(sum) ; Present the results
Debug "Product is " + Str(prod)

[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()

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

Works with: Python version 2.6, 3.x
import math
total = math.fsum(floats)

[edit] R

total <- sum(1:5)
product <- prod(1:5)

[edit] Racket

 
#lang racket
 
(for/sum ([x #(3 1 4 1 5 9)]) x)
(for/product ([x #(3 1 4 1 5 9)]) x)
 

[edit] Raven

0 [ 1 2 3 ] each +
1 [ 1 2 3 ] each *

[edit] REBOL

rebol [
Title: "Sum and Product"
Date: 2010-01-04
Author: oofoe
URL: http://rosettacode.org/wiki/Sum_and_product_of_array
]

 
; Simple:
 
sum: func [a [block!] /local x] [x: 0 forall a [x: x + a/1] x]
 
product: func [a [block!] /local x] [x: 1 forall a [x: x * a/1] x]
 
; Way too fancy:
 
redux: func [
"Applies an operation across an array to produce a reduced value."
a [block!] "Array to operate on."
op [word!] "Operation to perform."
/init x "Initial value (default 0)."
][if not init [x: 0] forall a [x: do compose [x (op) (a/1)]] x]
 
rsum: func [a [block!]][redux a '+]
 
rproduct: func [a [block!]][redux/init a '* 1]
 
; Tests:
 
assert: func [code][print [either do code [" ok"]["FAIL"] mold code]]
 
print "Simple dedicated functions:"
assert [55 = sum [1 2 3 4 5 6 7 8 9 10]]
assert [3628800 = product [1 2 3 4 5 6 7 8 9 10]]
 
print [crlf "Fancy reducing function:"]
assert [55 = rsum [1 2 3 4 5 6 7 8 9 10]]
assert [3628800 = rproduct [1 2 3 4 5 6 7 8 9 10]]
Output:
Simple dedicated functions:
  ok [55 = sum [1 2 3 4 5 6 7 8 9 10]]
  ok [3628800 = product [1 2 3 4 5 6 7 8 9 10]]

Fancy reducing function:
  ok [55 = rsum [1 2 3 4 5 6 7 8 9 10]]
  ok [3628800 = rproduct [1 2 3 4 5 6 7 8 9 10]]

[edit] REXX

/*REXX program to add and separately multiply elements of an array. */
numeric digits 30 /*allow 30-digit numbers (default is 9)*/
m=20 /*one method of indicating array size. */
do j=1 for m /*build an array of twenty elements. */
y.j=j /*set 1st to 1, 3rd to 3, 9th to 9 ... */
end /*j*/
sum=0 /*initialize SUM to zero. */
prod=1 /*initialize PROD to unity. */
do k=1 for m
sum =sum +y.k /*add the element to the running total.*/
prod=prod*y.k /*multiple the element to running prod.*/
end /*k*/
 
say ' sum of' m "elements for the Y array is: " sum
say 'product of' m "elements for the Y array is: " prod
/*stick a fork in it, we're done. */
Output:
    sum of 20 elements for the Y array is:  210
product of 20 elements for the Y array is:  2432902008176640000

[edit] Ruby

arr = [1,2,3,4,5]     # or ary = *1..5, or ary = (1..5).to_a
p sum = arr.inject(0) { |sum, item| sum + item }
# => 15
p product = arr.inject(1) { |prod, element| prod * element }
# => 120
Works with: Ruby version 1.8.7
arr = [1,2,3,4,5]
p sum = arr.inject(0, :+) #=> 15
p product = arr.inject(1, :*) #=> 120
 
# If you do not explicitly specify an initial value for memo,
# then the first element of collection is used as the initial value of memo.
p sum = arr.inject(:+) #=> 15
p product = arr.inject(:*) #=> 120

Note: When the Array is empty, the initial value returns. However, nil returns if not giving an initial value.

arr = []
p arr.inject(0, :+) #=> 0
p arr.inject(1, :*) #=> 1
p arr.inject(:+) #=> nil
p arr.inject(:*) #=> nil

Enumerable#reduce is the alias of Enumerable#inject.

[edit] Run BASIC

dim array(100)
for i = 1 To 100
array(i) = rnd(0) * 100
next i
 
product = 1
for i = 0 To 19
sum = (sum + array(i))
product = (product * array(i))
next i
 
Print " Sum is ";sum
Print "Product is ";product

[edit] Rust

use std::iter::{AdditiveIterator, MultiplicativeIterator};
 
fn main() {
let arr = [1i, 2, 3, 4, 5, 6, 7, 8, 9];
 
// using fold
let sum = arr.iter().fold(0, |a, &b| a + b);
let product = arr.iter().fold(1, |a, &b| a * b);
println!("the sum is {:d} and the product is {:d}", sum, product);
 
// or using sum and product from AdditiveIterator
// and MultiplicativeIterator
let sum2 = arr.iter().map(|&a| a).sum();
let product2 = arr.iter().map(|&a| a).product();
println!("the sum is {:d} and the product is {:d}", sum2, product2);
}

[edit] SAS

data _null_;
array a{*} a1-a100;
do i=1 to 100;
a{i}=i*i;
end;
b=sum(of a{*});
put b c;
run;

[edit] Sather

class MAIN is
main is
a :ARRAY{INT} := |10, 5, 5, 20, 60, 100|;
sum, prod :INT;
loop sum := sum + a.elt!; end;
prod := 1;
loop prod := prod * a.elt!; end;
#OUT + sum + " " + prod + "\n";
end;
end;

[edit] Scala

val seq = Seq(1, 2, 3, 4, 5)
val sum = seq.foldLeft(0)(_ + _)
val product = seq.foldLeft(1)(_ * _)

Or even shorter:

val sum = seq.sum
val product = seq.product

Works with all data types for which a Numeric implicit is available.

[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] SETL

numbers := [1 2 3 4 5 6 7 8 9];
print(+/ numbers, */ numbers);

=> 45 362880

[edit] Slate

#(1 2 3 4 5) reduce: [:sum :number | sum + number]
#(1 2 3 4 5) reduce: [:product :number | product * number]

Shorthand for the above with a macro:

#(1 2 3 4 5) reduce: #+ `er
#(1 2 3 4 5) reduce: #* `er

[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] SNOBOL4

          t = table()
* read the integer from the std. input
init_tab t<x = x + 1> = trim(input)  :s(init_tab)
product = 1
sum = 0
 
* counting backwards to 1
loop i = t< x = ?gt(x,1) x - 1> :f(out)
sum = sum + i
product = product * i  :(loop)
out output = "Sum: " sum
output = "Prod: " product
end

Input

1
2
3
4
5
Output:
 Sum:  15
 Prod: 120

[edit] Standard ML

[edit] Arrays

(* ints *)
val a = Array.fromList [1, 2, 3, 4, 5];
Array.foldl op+ 0 a;
Array.foldl op* 1 a;
(* reals *)
val a = Array.fromList [1.0, 2.0, 3.0, 4.0, 5.0];
Array.foldl op+ 0.0 a;
Array.foldl op* 1.0 a;

[edit] Lists

(* ints *)
val x = [1, 2, 3, 4, 5];
foldl op+ 0 x;
foldl op* 1 x;
(* reals *)
val x = [1.0, 2.0, 3.0, 4.0, 5.0];
foldl op+ 0.0 x;
foldl op* 1.0 x;

[edit] Sparkling

spn:1> reduce({ 1, 2, 3, 4, 5 }, 0, function(x, y) { return x + y; })
= 15
spn:2> reduce({ 1, 2, 3, 4, 5 }, 1, function(x, y) { return x * y; })
= 120

[edit] Swift

let a = [1, 2, 3, 4, 5]
println(a.reduce(0, +)) // prints 15
println(a.reduce(1, *)) // prints 120
 
println(reduce(a, 0, +)) // prints 15
println(reduce(a, 1, *)) // prints 120

[edit] Tcl

set arr [list 3 6 8]
set sum [expr [join $arr +]]
set prod [expr [join $arr *]]
Works with: Tcl version 8.5
set arr [list 3 6 8]
set sum [tcl::mathop::+ {*}$arr]
set prod [tcl::mathop::* {*}$arr]

[edit] TI-83 BASIC

Use the built-in functions
sum()
and
prod()
.

[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] Trith

[1 2 3 4 5] 0 [+] foldl
[1 2 3 4 5] 1 [*] foldl

[edit] TUSCRIPT

 
$$ MODE TUSCRIPT
list="1'2'3'4'5"
sum=SUM(list)
PRINT " sum: ",sum
 
product=1
LOOP l=list
product=product*l
ENDLOOP
PRINT "product: ",product
 
Output:
    sum: 15
product: 120

[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

Uses ksh93-style process substitution.

Works with: bash
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

There is a race between fold sum and fold prod, which run in parallel. The program might print sum before product, or print product before sum.

[edit] Ursala

The reduction operator, :-, takes an associative binary function and a constant for the empty case. Natural numbers are unsigned and of unlimited size.

#import nat
#cast %nW
 
sp = ^(sum:-0,product:-1) <62,43,46,40,29,55,51,82,59,92,48,73,93,35,42,25>
Output:
(875,2126997171723931187788800000)

[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] Vala

 
public static void main(){
int sum = 0, product = 1;
 
int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 
foreach (int number in array){
sum += number;
product *= number;
}
}
 

[edit] Wart

def (sum_prod nums)
(list (+ @nums) (* @nums))

[edit] XPL0

code CrLf=9, IntOut=11;
 
func SumProd(A, L);
int A, L;
int S, P, I;
[S:= 0; P:= 1;
for I:= 0 to L-1 do [S:= S+A(I); P:= P*A(I)];
IntOut(0, S); CrLf(0);
IntOut(0, P); CrLf(0);
]; \SumSq
 
SumProd([1,2,3,4,5,6,7,8,9,10], 10)
Output:
55
3628800

[edit] Wortel

@sum [1 2 3 4] ; returns 10
@prod [1 2 3 4] ; returns 24

[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>

[edit] zkl

Translation of: Clojure
fcn sum(vals){vals.reduce('+,0)}
fcn product(vals){vals.reduce('*,1)}
sum(T(1,2,3,4))     //-->10
product(T(1,2,3,4)) //-->24
Personal tools
Namespaces

Variants
Actions
Community
Explore
Misc
Toolbox