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|ACL2}}==

(if (endp xs)

0

1

(* (first xs)

 

=={{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;

 

 

 

 

 

 

{{out}}

 

=={{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|Babel}}==

 

sum! : { <- 0 -> { + } eachar }

Result:

41

 

Perhaps better Babel:

 

{ [2 3 5 7 11 13]

ar2ls dup cp

{ * }

{ depth 1 > }

 

The nest operator creates a kind of argument-passing context -

=={{header|BASIC}}==

{{works with|FreeBASIC}}

 

dim sum as integer = 0

sum += array(index)

prod *= array(index)

 

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

20 S = 0:P = 1: DATA 1,2,3,4,5

30 N = N - 1: DIM A(N)

70 S = S + A(I):P = P * A(I)

 

array%() = 1, 2, 3, 4, 5, 6

product% *= array%(I%)

NEXT

 

=={{header|bc}}==

a[1] = 1

a[2] = 4.0

}

"Sum: "; s

 

=={{header|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.

>1- \ & + \v

 

=={{header|Bracmat}}==

= sum prod num

. 0:?sum

)

& out$sumprod$(2 3 5 7 11 13 17 19)

<pre>77.9699690</pre>

 

=={{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|Chef}}==

 

 

This recipe sums N given numbers.

Pour contents of 1st mixing bowl into the baking dish.

 

 

=={{header|Clean}}==

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

 

=={{header|Clojure}}==

 

 

 

=={{header|COBOL}}==

PROGRAM-ID. array-sum-and-product.

 

 

GOBACK

 

=={{header|CoffeeScript}}==

sum = (array) ->

array.reduce (x, y) -> x + y

product = (array) ->

array.reduce (x, y) -> x * y

 

=={{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

 

The loop macro also has support for sums.

 

=={{header|D}}==

 

void main() {

writeln("Sum: ", sum);

writeln("Product: ", prod);

<pre>Sum: 15

Product: 120</pre>

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

 

void main() {

writeln("Sum: ", r[0]);

writeln("Product: ", r[1]);

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

Write('Product: ');

Writeln(lProduct);

 

=={{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|Euphoria}}==

integer sum,prod

 

 

printf(1,"sum is %d\n",sum)

 

sum is 15

prod is 120

 

=={{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|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.

5 {length of input}

0s: {sum}

 

"Sum: "s;."

{{out}}

<pre>Sum: 15

=={{header|Fantom}}==

 

class Main

{

}

}

 

=={{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|Frink}}==

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

sum[a]

product[a]

 

=={{header|GAP}}==

 

Sum(v);

 

Product(v, n -> 1/n);

 

=={{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.

You can also combine these operations:

 

=={{header|GW-BASIC}}==

{{works with|GW-BASIC}}

{{works with|QBasic}}

 

20 DIM A(5)

30 FOR I = 1 TO 5: READ A(I): NEXT I

77 NEXT I

80 PRINT "The sum is "; S;

 

=={{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

 

 

=={{header|Icon}} and {{header|Unicon}}==

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

466 472 462

product"1 a

 

=={{header|Java}}==

{{works with|Java|1.5+}}

{

public static void main(final String[] args)

}

}

 

{{works with|Java|1.8+}}

 

public class SumProd

System.out.printf("product = %d\n", Arrays.stream(arg).reduce(1, (a, b) -> a * b));

}

{{out}}

<pre>

 

=={{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|Julia}}==

18

 

julia> prod([4,6,8])

 

=={{header|Lang5}}==

 

'+ reduce

 

 

=={{header|Lasso}}==

// sum of array elements

'Sum: '

local(product = 1)

with n in #x do => { #product *= #n }

{{out}}

<pre>Sum: 55

 

=={{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|Maxima}}==

 

36

 

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

 

=={{header|MAXScript}}==

sum = 0

for i in arr do sum += i

product = 1

 

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

 

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

 

=={{header|Modula-3}}==

 

FROM IO IMPORT Put;

Put("Sum of array: " & Int(sum) & "\n");

Put("Product of array: " & Int(prod) & "\n");

<pre>Sum of array: 15

Product of array: 120</pre>

 

=={{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

=={{header|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.Console;

using System.Collections.Generic;

WriteLine("Sum is: {0}\tProduct is: {1}", suml, proda);

}

 

=={{header|NetRexx}}==

 

options replace format comments java crossref savelog symbols binary

 

return

<pre>

Sum and product of 1,2,3,4,5,6,7,8,9,10:

Product: 3628800

</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)

 

 

var sum, product: int

for x in xs:

sum += x

 

Or functionally:

 

let

sum = xs.foldl(a + b)

 

=={{header|Objeck}}==

sum := 0;

prod := 1;

prod *= arg[i];

};

 

=={{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|Pascal}}==

 

=={{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|Racket}}==

 

 

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

 

=={{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}}==

end /*j*/

 

<pre>

</pre>

 

=={{header|Ruby}}==

p sum = arr.inject(0) { |sum, item| sum + item }

# => 15

p product = arr.inject(1) { |prod, element| prod * element }

 

{{works with|Ruby|1.8.7}}

p sum = arr.inject(0, :+) #=> 15

p product = arr.inject(1, :*) #=> 120

# then the first element of collection is used as the initial value of memo.

p sum = arr.inject(:+) #=> 15

 

=={{header|Run BASIC}}==

for i = 1 To 100

array(i) = rnd(0) * 100

Print " Sum is ";sum

 

=={{header|Rust}}==

 

fn main() {

 

=={{header|SAS}}==

array a{*} a1-a100;

do i=1 to 100;

b=sum(of a{*});

put b c;

 

=={{header|Sather}}==

main is

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

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

end;

 

=={{header|Scala}}==

val sum = seq.foldLeft(0)(_ + _)

 

Or even shorter:

 

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

 

=={{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|Swift}}==

println(a.reduce(0, +)) // prints 15

println(a.reduce(1, *)) // prints 120

 

println(reduce(a, 0, +)) // prints 15

 

=={{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|TUSCRIPT}}==

$$ MODE TUSCRIPT

list="1'2'3'4'5"

ENDLOOP

PRINT "product: ",product

<pre>

sum: 15

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}}==

Uses [[ksh93]]-style process substitution.

{{works with|bash}}

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

}

 

(echo 3; echo 1; echo 4;echo 1;echo 5;echo 9) |

 

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

 

=={{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|Vala}}==

}

 

=={{header|Wart}}==

 

=={{header|XPL0}}==

 

func SumProd(A, L);

]; \SumSq

 

 

<pre>

55

3628800

</pre>

 

=={{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>

 

=={{header|zkl}}==

{{trans|Clojure}}

<pre>

sum(T(1,2,3,4)) //-->10

product(T(1,2,3,4)) //-->24

</pre>