Sum and product of an array: Difference between revisions

Compute the sum and product of an array of integers.

=={{header|4D}}==

For ($i;1;5)

APPEND TO ARRAY($list;$i)

$sum:=$var+$list{$i}

$product:=$product*$list{$i}

=={{header|ActionScript}}==

import flash.display.Sprite;

 

}

}

 

=={{header|Ada}}==

 

array : Int_Array := (1,2,3,4,5,6,7,8,9,10);

for I in array'range loop

Sum := Sum + array(I);

Define the product function

Prod : Integer := 1;

begin

end loop;

return Prod;

This function will raise the predefined exception Constraint_Error if the product overflows the values represented by type Integer

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

INT default upb := 3;

MODE INTARRAY = [default upb]INT;

) # int product # ;

printf(($" Sum: "g(0)$,sum,$", Product:"g(0)";"l$,int product(array)))

Sum: 55, Product:3628800;

 

=={{header|APL}}==

{{works with|APL2}}

15

=={{header|AppleScript}}==

set sum to 0

set product to 1

set sum to sum + i

set product to product * i

=={{header|AutoHotkey}}==

product := 1

loop, parse, numbers, `,

product *= A_LoopField

}

=={{header|AWK}}==

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

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

=={{header|BASIC}}==

{{works with|FreeBASIC}}

 

dim sum as integer = 0

sum += array(index)

prod *= array(index)

 

=={{header|C}}==

int arg[] = { 1,2,3,4,5 };

int arg_length = sizeof(arg)/sizeof(arg[0]);

sum += *p;

prod *= *p;

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

{{libheader|STL}}

#include <functional>

 

// std::accumulate(arg, arg + 5, 0);

// since plus() is the default functor for accumulate

Template alternative:

template <typename T> T sum (const T *array, const unsigned n)

{

cout << sum(aflo,4) << " " << prod(aflo,4) << endl;

return 0;

 

 

 

=={{header|Clean}}==

Sum = sum [x \\ x <-: array]

=={{header|Clojure}}==

 

 

 

=={{header|ColdFusion}}==

Sum of an Array,

 

Product of an Array,

<cfset Variables.Product = 1>

<cfloop array="#Variables.myArray#" index="i">

<cfset Variables.Product *= i>

</cfloop>

 

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

(values (reduce #'+ data) ; sum

=={{header|D}}==

=={{header|Delphi}}==

begin

end;

=={{header|E}}==

accum 0 for x in [1,2,3,4,5] { _ + x }

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

 

 

=={{header|Erlang}}==

Using the standard libraries:

L = lists:seq(1, 10).

 

% and compute its sum:

S = lists:sum(L).

To compute sum and products in one pass:

Or defining our own versions:

-export([sum_rec/1, sum_tail/1]).

 

Acc;

sum_tail([Head|Tail], Acc) ->

 

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

let numbers = [| 1..10 |]

let sum = numbers |> Array.sum

 

=={{header|Factor}}==

15 120

{ 1 2 3 4 } [ sum ] [ product ] bi

sum and product are defined in the sequences vocabulary:

 

=={{header|Forth}}==

: reduce ( xt n addr cnt -- n' ) \ where xt ( a b -- n )

cells bounds do i @ third execute cell +loop nip ;

 

' + 0 a 5 reduce . \ 15

 

=={{header|Fortran}}==

In ISO Fortran 90 and later, use SUM and PRODUCT intrinsics:

integer :: sresult, presult

 

=={{header|Go}}==

 

import "fmt"

}

fmt.Println(sum, prod)

 

=={{header|Groovy}}==

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

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

=={{header|Haskell}}==

For lists, ''sum'' and ''product'' are already defined in the Prelude:

 

s = sum values -- the easy way

p = product values

 

To do the same for an array, just convert it lazily to a list:

 

values = listArray (1,10) [1..10]

 

s = sum . elems $ values

 

=={{header|HicEst}}==

 

sum = SUM(array)

ENDDO

 

 

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

every ( sum := 0 ) +:= !arglist

every ( prod := 1 ) *:= !arglist

write("sum := ", sum,", prod := ",prod)

 

=={{header|Inform 7}}==

 

To decide which number is the sum of (N - number) and (M - number) (this is summing):

let L be {1, 2, 3, 4, 5};

say "List: [L in brace notation], sum = [summing reduction of L], product = [production reduction of L].";

 

=={{header|J}}==

 

 

For example:

 

49

product 1 3 5 7 9 11 13

29 8 75 97 24 40 21 82 77 9

 

sum a

177 105 173 131 115 118 110 127 178 166

151380 18800 174000 14065 36432 58880 39270 16400 194810 55188

 

sum"1 a

466 472 462

product"1 a

 

=={{header|Java}}==

{{works with|Java|1.5+}}

}

 

=={{header|JavaScript}}==

sum = 0,

prod = 1,

prod *= array[i];

}

 

 

{{Works with|Javascript|1.8}}

Where supported, the reduce method can also be used:

sum = array.reduce(function (a, b) {

return a + b;

return a * b;

}, 1);

 

=={{header|Liberty BASIC}}==

 

For i = 0 To 19

 

Print "Sum is " + str$(sum)

 

=={{header|Logo}}==

=={{header|Lua}}==

function sumf(a, ...) return a and a + sumf(...) or 0 end

function sumt(t) return sumf(unpack(t)) end

 

print(sumt{1, 2, 3, 4, 5})

 

=={{header|Lucid}}==

prints a running sum and product of sequence 1,2,3...

where

x = 1 fby x + 1;

sum = 0 fby sum + x;

product = 1 fby product * x

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

Plus @@ a

Apply[Plus, a]

a // Total

Sum[a[[i]], {i, 1, Length[a]}]

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

Times @@ a

Apply[Times, a]

Product[a[[i]], {i, 1, Length[a]}]

all give 120.

 

 

Sample Usage:

 

array =

6

120

 

=={{header|MAXScript}}==

sum = 0

for i in arr do sum += i

product = 1

=={{header|MUMPS}}==

SUMPROD(A)

;Compute the sum and product of the numbers in the array A

WRITE !,"The product of the array is "_PROD

KILL SUM,PROD,POS

Example: <pre>

USER>SET C(-1)=2,C("A")=3,C(42)=1,C(0)=7

The product of the array is 0

</pre>

 

=={{header|Nial}}==

Nial being an array language, what applies to individual elements are extended to cover array operations by default strand notation

= 6

* 1 2 3

array notation

grouped notation

= 6

* (1 2 3)

(All these notations are equivalent)

 

 

 

=={{header|Objective-C}}==

{{works with|GCC|4.0.1 (apple)}}

Sum:

{

int i, sum, value;

return suml;

Product:

{

int i, prod, value;

return suml;

=={{header|OCaml}}==

===Arrays===

let a = [| 1; 2; 3; 4; 5 |];;

Array.fold_left (+) 0 a;;

let a = [| 1.0; 2.0; 3.0; 4.0; 5.0 |];;

Array.fold_left (+.) 0.0 a;;

===Lists===

let x = [1; 2; 3; 4; 5];;

List.fold_left (+) 0 x;;

let x = [1.0; 2.0; 3.0; 4.0; 5.0];;

List.fold_left (+.) 0.0 x;;

 

=={{header|Octave}}==

b = [ 10, 20, 30, 40, 50, 60 ];

vsum = a + b;

=={{header|Oz}}==

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

Xs = [1 2 3 4 5]

Sum = {FoldL Xs Number.'+' 0}

in

{Show Sum}

 

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

Arr = {Array.new 1 3 0}

Sum = {NewCell 0}

Sum := @Sum + Arr.I

end

 

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

sum(i=1,#v,v[i])

};

vecprod(v)={

prod(i=1,#v,v[i])

 

=={{header|Perl}}==

 

my ( $sum, $prod ) = ( 0, 1 );

$sum += $_ foreach @list;

 

 

 

 

=={{header|PHP}}==

echo array_sum($array);

 

=={{header|PicoLisp}}==

(cons

(apply + Data)

<pre>(15 . 120)</pre>

 

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

(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

 

put skip list (sum(A));

 

=={{header|Pop11}}==

Simple loop:

for i from 1 to length(ar) do

ar(i) + sum -> sum;

ar(i) * prod -> prod;

One can alternatively use second order iterator:

appdata(ar, procedure(x); x + sum -> sum; endprocedure);

=={{header|PowerShell}}==

The <code>Measure-Object</code> cmdlet already knows how to compute a sum:

return ($a | Measure-Object -Sum).Sum

But not how to compute a product:

if ($a.Length -eq 0) {

return 0

return $p

}

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

 

{{works with|PowerShell|2}}

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:

$sum = 0

if ($a.Length -eq 0) {

$ret | Add-Member NoteProperty Product $prod

return $ret

<pre>PS> Get-SumAndProduct 5,9,7,2,3,8,4

 

 

=={{header|Prolog}}==

sum([H|T],X) :- sum(T,Y), X is H + Y.

product([],1).

 

test

 

Using fold

add(A,B,R):-

R is A + B.

Prod = 24 .

 

 

=={{header|PureBasic}}==

Define a, sum=0, prod=1

 

 

Debug "The sum is " + Str(sum) ; Present the results

 

=={{header|Python}}==

{{works with|Python|2.5}}

total = sum(numbers)

 

product = 1

for i in numbers:

Or functionally (faster but perhaps less clear):

{{works with|Python|2.5}}

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

numbers = r_[1:4]

total = numbers.sum()

 

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

{{works with|Python|2.6, 3.x}}

 

=={{header|R}}==

=={{header|Raven}}==

 

=={{header|REBOL}}==

Title: "Sum and Product"

URL: http://rosettacode.org/wiki/Sum_and_product_of_array

]

print [crlf "Fancy reducing function:"]

assert [55 = rsum [1 2 3 4 5 6 7 8 9 10]]

 

<pre>Simple dedicated functions:

ok [55 = sum [1 2 3 4 5 6 7 8 9 10]]

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]]</pre>

 

=={{header|REXX}}==

 

 

 

 

 

 

 

 

 

 

 

 

=={{header|Sather}}==

main is

a :ARRAY{INT} := |10, 5, 5, 20, 60, 100|;

#OUT + sum + " " + prod + "\n";

end;

 

=={{header|Scala}}==

 

=={{header|Scheme}}==

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.

(if (null? l)

i

 

(reduce + 0 '(1 2 3 4 5)) ;; 0 is unit for +

=={{header|Seed7}}==

result

var integer: sum is 0;

prod *:= value;

end for;

Call these functions with:

writeln(sumArray([](1, 2, 3, 4, 5)));

 

=={{header|SETL}}==

 

=> <code>45 362880</code>

 

=={{header|Slate}}==

Shorthand for the above with a macro:

=={{header|Smalltalk}}==

Some implementation also provide a ''fold:'' message:

=={{header|SNOBOL4}}==

* read the integer from the std. input

init_tab t<x = x + 1> = trim(input) :s(init_tab)

out output = "Sum: " sum

output = "Prod: " product

 

Input

4

5

Sum: 15

Prod: 120

 

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

===Arrays===

val a = Array.fromList [1, 2, 3, 4, 5];

Array.foldl op+ 0 a;

val a = Array.fromList [1.0, 2.0, 3.0, 4.0, 5.0];

Array.foldl op+ 0.0 a;

===Lists===

val x = [1, 2, 3, 4, 5];

foldl op+ 0 x;

val x = [1.0, 2.0, 3.0, 4.0, 5.0];

foldl op+ 0.0 x;

=={{header|Tcl}}==

set sum [expr [join $arr +]]

{{works with|Tcl|8.5}}

set sum [tcl::mathop::+ {*}$arr]

 

=={{header|TI-83 BASIC}}==

 

=={{header|Toka}}==

 

212 1 foo array.put

 

( product )

 

=={{header|Trith}}==

 

=={{header|UNIX Shell}}==

From an internal variable, $IFS delimited:

 

prod=1

list="1 2 3"

do sum="$(($sum + $n))"; prod="$(($prod * $n))"

done

 

From the argument list (ARGV):

 

prod=1

for n

do sum="$(($sum + $n))"; prod="$(($prod * $n))"

done

 

From STDIN, one integer per line:

 

prod=1

while read n

do sum="$(($sum + $n))"; prod="$(($prod * $n))"

done

 

 

 

=={{header|UnixPipes}}==

(read B; res=$1; test -n "$B" && expr $res \* $B || echo $res)

}

 

fold() {

}

 

 

 

=={{header|Ursala}}==

The reduction operator, :-, takes an associative binary function and a constant for the empty case.

Natural numbers are unsigned and of unlimited size.

#cast %nW

 

<pre>(875,2126997171723931187788800000)</pre>

 

=={{header|V}}==

=

product=15

 

=={{header|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:output method="text" />

</xsl:call-template>

</xsl:template>