Sum and product of an array: Difference between revisions

 

=={{header|11l}}==

print(sum(arr))

 

{{out}}

 

=={{header|360 Assembly}}==

SUMPROD CSECT

USING SUMPROD,R15 base register

PG DS CL24 buffer

YREGS

{{out}}

<pre>

 

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

For ($i;1;5)

APPEND TO ARRAY($list;$i)

 

$sum:=sum($list)

 

=={{header|ACL2}}==

(if (endp xs)

0

1

(* (first xs)

 

=={{header|Action!}}==

 

PROC Main()

OD

PrintIE(res)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sum_and_product_of_an_array.png Screenshot from Atari 8-bit computer]

 

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

compute(integer &s, integer &p, list l)

{

 

return 0;

{{out}}

<pre>77

 

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

{{Out}}

<pre>

 

=={{header|ALGOL W}}==

 

% computes the sum and product of intArray %

write( sum, product );

end

 

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

 

Condensed version of above, which also prints the results :

set {array, sum, product} to {{1, 2, 3, 4, 5}, 0, 1}

repeat with i in array

end repeat

return sum & " , " & product as string

{{out}}

<pre>

Or, using an AppleScript implementation of '''fold'''/'''reduce''':

 

a + b

end summed

end script

end if

{{Out}}

 

=={{header|Arturo}}==

 

print ["Sum =" sum arr]

 

{{out}}

<pre>Sum = 55

Product = 3628800</pre>

 

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

 

==={{header|BaCon}}===

'--- set some values into the array

DECLARE a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } TYPE int

PRINT "The sum is ",sum

PRINT "The product is ",product

 

==={{header|BBC BASIC}}===

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

product% *= array%(I%)

NEXT

 

==={{header|IS-BASIC}}===

110 LET N=5

120 NUMERIC A(1 TO N)

200 LET SUM=SUM+A(I):LET PROD=PROD*A(I)

210 NEXT

 

 

=={{header|BASIC256}}==

{{trans|Yabasic}}

dim array(5)

array[1] = 1

print "The sum is "; sum #15

print "and the product is "; prod #120

 

 

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

{{Out}}

<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 sharp|C#}}==

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

foreach (int value in arg) {

sum += value;

prod *= value;

 

===Alternative using Linq (C# 3)===

{{works with|C sharp|C#|3}}

 

int sum = arg.Sum();

 

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

sum: int := 0

prod: int := 1

stream$putl(po, "Sum = " || int$unparse(sum))

stream$putl(po, "Product = " || int$unparse(prod))

{{out}}

<pre>Sum = 55

 

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

===Declarative===

def sum_product(a)

{ a.sum(), a.product() }

end

 

===Imperative===

def sum_product_imperative(a)

sum, product = 0, 1

{sum, product}

end

 

require "benchmark"

Benchmark.ips do |x|

x.report("imperative") { sum_product_imperative [1, 2, 3, 4, 5] }

end

 

<pre>declarative 8.1M (123.45ns) (± 2.99%) 65 B/op 1.30× slower

 

=={{header|D}}==

 

void main() {

writeln("Sum: ", sum);

writeln("Product: ", prod);

{{Out}}

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

Sum: 49

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

Write('Product: ');

Writeln(lProduct);

 

=={{header|E}}==

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

 

=={{header|Eiffel}}==

class

APPLICATION

 

end

{{Out}}

<pre>Sum of the elements of the array: 30

=={{header|Elena}}==

ELENA 5.0:

import extensions;

var sum := list.summarize(new Integer());

var product := list.accumulate(new Integer(1), (var,val => var * val));

 

=={{header|Elixir}}==

When an accumulator is omitted, the first element of the collection is used as the initial value of acc.

15

iex(27)> Enum.reduce([1,2,3,4,5], 1, fn x,acc -> x*acc end)

iex(32)> Enum.reduce([], fn x,acc -> x*acc end)

** (Enum.EmptyError) empty error

 

The function with sum

 

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

 

{{Out}}

 

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

let numbers = [| 1..10 |]

let sum = numbers |> Array.sum

let product = numbers |> Array.reduce (*)

 

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

[a]:=[(1,1,2,3,5,8,13)];

!!Sigma<i=1,7>[a[i]];

!!Prod<i=1,7>[a[i]];

{{out}}

<pre>

 

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

 

sresult = sum(a)

 

=={{header|FreeBASIC}}==

 

Dim a(1 To 4) As Integer = {1, 4, 6, 3}

Print

Print "Press any key to quit"

 

{{out}}

Sum = 14

Product = 72

</pre>

 

=={{header|Frink}}==

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

sum[a]

product[a]

 

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=4a4bdc35d661e2dc22d66d88991bef95 Click this link to run this code]'''

Dim iList As Integer[] = [1, 2, 3, 4, 5]

Dim iSum, iCount As Integer

Print "The Product =\t" & iPrd

 

Output:

<pre>

The Product = 120

</pre>

 

=={{header|GAP}}==

 

Sum(v);

 

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

 

=={{header|GFA Basic}}==

 

DIM a%(10)

' put some values into the array

PRINT "Sum is ";sum%

PRINT "Product is ";product%

 

=={{header|Go}}==

;Implementation

 

import "fmt"

}

fmt.Println(sum, prod)

{{out}}

<pre>

</pre>

;Library

 

import (

fmt.Println("Sum: ", floats.Sum(a))

fmt.Println("Product:", floats.Prod(a))

{{out}}

<pre>

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

 

s1 = foldl (+) 0 values -- the hard way

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

 

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

 

s = sum . elems $ values

 

Or perhaps:

 

main :: IO ()

{{Out}}

<pre>155

 

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

print,total(array)

 

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

===ES5===

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

 

===ES6===

'use strict';

 

.map(f => f([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))

);

 

{{Out}}

3628800

]</pre>

 

=={{header|jq}}==

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

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

Examples:

10!

 

=={{header|Julia}}==

18

 

 

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

 

=={{header|K}}==

product: {*/}x

a: 1 3 5 7 9 11 13

49

product a

 

It is easy to see the relationship of K to J here.

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

val product = a.fold(1) { acc, i -> acc * i }

println("Product is $product")

 

{{out}}

=={{header|Lambdatalk}}==

 

{A.serie start end [step]} creates a sequence from start to end with optional step

{A.new words} creates an array from a sequence of words

9332621544394415268169923885626670049071596826438162146859296389521759999322991

5608941463976156518286253697920827223758251185210916864000000000000000000000000

 

=={{header|Lang5}}==

 

'+ reduce

 

=={{header|langur}}==

 

{{out}}

sum: 190

product: 121645100408832000</pre>

 

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

res = 0

repeat with v in intList

end repeat

return res

 

=={{header|LiveCode}}==

put "1,2,3,4" into nums

split nums using comma

end if

end repeat

 

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

 

function table.sum(arr, length)

--same as if <> then <> else <>

print(table.sum(t,#t))

print(table.product(t,3))

 

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

 

=={{header|M2000 Interpreter}}==

Module Checkit {

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

}

checkit

 

=={{header|Maple}}==

add(a);

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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

{{works with|min|0.19.3}}

{{out}}

<pre>

 

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

{{Out}}

<pre>Sum of array: 15

 

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

{{Out}}

<pre>

 

=={{header|NewLISP}}==

(apply + a)

 

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

 

var sum, product: int

for x in xs:

sum += x

 

Or functionally:

 

let

xs = [1, 2, 3, 4, 5, 6]

sum = xs.foldl(a + b)

 

Or using a math function:

 

let numbers = [1, 5, 4]

var product = 1

for n in numbers:

 

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

 

 

{{out}}

 

=={{header|Ol}}==

(print (fold + 0 '(1 2 3 4 5)))

(print (fold * 1 '(1 2 3 4 5)))

 

=={{header|ooRexx}}==

{{trans|REXX}}

do i=1 To 20

a[i]=i

prod*=self[i]

End

{{out}}

<pre>1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20

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

These are built in to GP: <code>vecsum</code> and <code>factorback</code> (the latter can also take factorization matrices, thus the name). They could be coded like so:

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

};

vecprod(v)={

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

 

{{works with|PARI/GP|2.10.0+}}

 

=={{header|Perl}}==

 

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

$sum += $_ foreach @list;

Or using the [https://metacpan.org/pod/List::Util List::Util] module:

my @list = (1..9);

 

say "Sum: ", sum0(@list); # sum0 returns 0 for an empty list

{{out}}

<pre>Sum: 45

=={{header|Phix}}==

{{libheader|Phix/basics}}

<span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">}</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"sum is %d\n"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">))</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"prod is %d\n"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">product</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">))</span>

{{out}}

<pre>

 

=={{header|Phixmonti}}==

 

( 1 2 3 4 5 )

drop

 

 

=={{header|PHP}}==

echo array_sum($array);

 

=={{header|PicoLisp}}==

(cons

(apply + Data)

{{Out}}

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

 

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

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

 

put skip list (sum(A));

 

=={{header|Plain English}}==

 

To find a sum and a product of some elements:

Shut down.

 

{{out}}

<pre>

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

/sumandproduct

{

prod ==

}def

 

{{libheader|initlib}}

% sum

[1 1 1 1 1] 0 {add} fold

[1 1 1 1 1] 1 {mul} fold

 

 

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

{{Out}}

<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

{{libheader|NumPy}}

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

 

 

{{works with|QuickBasic}}

{{works with|True BASIC}}

DATA 1, 2, 3, 4, 5

FOR index = LBOUND(array) TO UBOUND(array)

PRINT "The sum is "; sum

PRINT "and the product is "; prod

 

 

=={{header|Quackery}}==

 

In the shell (i.e. Quackery REPL):

/O> ' [ 1 2 3 4 5 ] sum echo cr

... ' [ 1 2 3 4 5 ] product echo

15

120

=={{header|R}}==

 

=={{header|Racket}}==

 

 

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

 

=={{header|Raku}}==

(formerly Perl 6)

say 'Sum: ', [+] @ary;

 

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

 

{{Out}}

 

=={{header|Red}}==

red-version: 0.6.4

description: "Find the sum and product of an array of numbers."

print a

print ["Sum:" sum a]

{{out}}

<pre>

 

=={{header|REXX}}==

numeric digits 200 /*200 decimal digit #s (default is 9).*/

parse arg N .; if N=='' then N=20 /*Not specified? Then use the default.*/

say ' sum of ' m " elements for the @ array is: " sum

say ' product of ' m " elements for the @ array is: " prod

'''output''' using the default input of: &nbsp; <tt> 20 </tt>

<pre>

 

=={{header|Ring}}==

aList = 1:10 nSum=0 nProduct=0

for x in aList nSum += x nProduct *= x next

See "Sum = " + nSum + nl

See "Product = " + nProduct + nl

 

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

 

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

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

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

p arr.inject(:+) #=> nil

 

Enumerable#reduce is the alias of Enumerable#inject.

 

{{works with|Ruby|1.9.3}}

p sum = arr.sum #=> 15

 

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

for i = 1 To 100

array(i) = rnd(0) * 100

Print " Sum is ";sum

 

=={{header|Rust}}==

 

fn main() {

println!("the sum is {} and the product is {}", sum, product);

}

 

=={{header|S-lang}}==

 

The sum of array elements is handled by an intrinsic.

[note: print is slsh-specific; if not available, use printf().]

 

 

The product is slightly more involved; I'll use this as a

chance to show the alternate stack-based use of 'foreach':

 

% Skipping the loop variable causes the val to be placed on the stack.

prod *= ();

 

 

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

Using built-in methods:

say ary.sum; # => 15

 

Alternatively, using hyper-operators:

say ary«+»; # => 15

 

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

Prod: 120

</pre>

 

=={{header|Sparkling}}==

= 15

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

 

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

Mata does not have a builtin product function, but one can do the following, which will compute the product of nonzero elements of the array:

 

sum(a)

-3

(-1)^mod(sum(a:<0),2)*exp(sum(log(abs(a))))

 

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

Use the built-in functions <code>sum()</code> and <code>prod()</code>.

{1 2 3 4 5 6 7 8 9 10}

sum(L₁)

55

prod(L₁)

 

=={{header|Toka}}==

 

212 1 foo array.put

 

( product )

 

=={{header|Trith}}==

 

 

=={{header|True BASIC}}==

{{works with|QBasic}}

DATA 1, 2, 3, 4, 5

FOR index = LBOUND(array) TO UBOUND(array)

PRINT "The sum is "; sum

PRINT "and the product is "; prod

 

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

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

ENDLOOP

PRINT "product: ",product

{{Out}}

<pre>

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

Ursa doesn't have arrays in the traditional sense. Its equivalent is the stream. All math operators take streams as arguments, so sums and products of streams can be found like this.

append 34 76 233 8 2 734 56 stream

 

 

# outputs 3.95961079808E11

 

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

 

 

{{Out}}

 

=={{header|V}}==

 

{{Out|Using it}}

=

product=15

 

=={{header|Vala}}==

int sum = 0, prod = 1;

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

}

print(@"sum: $(sum)\nproduct: $(prod)");

{{out}}

<pre>sum: 10

=={{header|VBA}}==

Assumes Excel is used.

Dim arr

arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

Debug.Print "sum : " & Application.WorksheetFunction.Sum(arr)

Debug.Print "product : " & Application.WorksheetFunction.Product(arr)

<pre>sum : 55

product : 3628800</pre>

 

=={{header|VBScript}}==

sum = 0

product = 1

myarray = Array(1,2,3,4,5,6)

sum_and_product(myarray)

 

{{Out}}

{{trans|C#}}

 

Sub Main()

Dim arg As Integer() = {1, 2, 3, 4, 5}

Dim prod = arg.Aggregate(Function(runningProduct, nextFactor) runningProduct * nextFactor)

End Sub

 

=={{header|Wart}}==

 

=={{header|WDTE}}==

let s => import 'stream';

 

let sum array => a.stream array -> s.reduce 0 +;

 

=={{header|Wortel}}==

 

=={{header|Wren}}==

{{libheader|Wren-math}}

var a = [7, 10, 2, 4, 6, 1, 8, 3, 9, 5]

System.print("Array : %(a)")

System.print("Sum : %(Nums.sum(a))")

 

{{out}}

 

=={{header|XPL0}}==

 

func SumProd(A, L);

]; \SumSq

 

 

{{Out}}

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

{{trans|QBasic}}

data 1, 2, 3, 4, 5

for index = 1 to arraysize(array(), 1)

print "The sum is ", sum //15

print "and the product is ", prod //120

 

 

=={{header|zkl}}==

{{trans|Clojure}}

<pre>

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

 

=={{header|Zoea}}==

program: sum_and_product

case: 1

input: [2,3,4]

output: [9,24]

 

=={{header|Zoea Visual}}==