Sum and product of an array

Task

Compute the sum and product of an array of integers.

11l

<lang 11l>V arr = [1, 2, 3, 4] print(sum(arr)) print(product(arr))</lang>

Output:

10
24

360 Assembly

<lang 360asm>* Sum and product of an array 20/04/2017 SUMPROD CSECT

        USING  SUMPROD,R15        base register
        SR     R3,R3              su=0
        LA     R5,1               pr=1
        LA     R6,1               i=1
      DO WHILE=(CH,R6,LE,=AL2((PG-A)/4))  do i=1 to hbound(a)         
        LR     R1,R6                i
        SLA    R1,2                 *4
        A      R3,A-4(R1)           su=su+a(i)
        M      R4,A-4(R1)           pr=pr*a(i)
        LA     R6,1(R6)             i++
      ENDDO    ,                  enddo i
        XDECO  R3,PG              su
        XDECO  R5,PG+12           pr
        XPRNT  PG,L'PG            print
        BR     R14                exit

A DC F'1',F'2',F'3',F'4',F'5',F'6',F'7',F'8',F'9',F'10' PG DS CL24 buffer

        YREGS
        END    SUMPROD</lang>

Output:

          55     3628800

4D

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

// since 4D v13

$sum:=sum($list) </lang>

ACL2

<lang Lisp>(defun sum (xs)

  (if (endp xs)
      0
      (+ (first xs)
         (sum (rest xs)))))

(defun prod (xs)

  (if (endp xs)
      1
      (* (first xs)
         (prod (rest xs)))))</lang>

Action!

<lang Action!>DEFINE LAST="6"

PROC Main()

 INT ARRAY data=[1 2 3 4 5 6 7]
 BYTE i
 INT a,res

 res=0
 FOR i=0 TO LAST
 DO
   a=data(i)
   PrintI(a)
   IF i=LAST THEN
     Put('=)
   ELSE
     Put('+)
   FI
   res==+a
 OD
 PrintIE(res)

 res=1
 FOR i=0 TO LAST
 DO
   a=data(i)
   PrintI(a)
   IF i=LAST THEN
     Put('=)
   ELSE
     Put('*)
   FI
   res=res*a
 OD
 PrintIE(res)

RETURN</lang>

Output:

Screenshot from Atari 8-bit computer

1+2+3+4+5+6+7=28
1*2*3*4*5*6*7=5040

ActionScript

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

Ada

<lang 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;</lang> Define the product function <lang ada>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;</lang> This function will raise the predefined exception Constraint_Error if the product overflows the values represented by type Integer

Aime

<lang aime>void compute(integer &s, integer &p, list l) {

   integer v;

   s = 0;
   p = 1;
   for (, v in l) {
       s += v;
       p *= v;
   }

}

integer main(void) {

   integer sum, product;

   compute(sum, product, list(2, 3, 5, 7, 11, 13, 17, 19));

   o_form("~\n~\n", sum, product);

   return 0;

}</lang>

Output:

77
9699690

ALGOL 68

<lang algol68>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)))

)</lang>

Output:

 Sum: 55, Product:3628800;

ALGOL W

<lang algolw>begin

   % computes the sum and product of intArray                               %
   % the results are returned in sum and product                            %
   % the bounds of the array must be specified in lb and ub                 %
   procedure sumAndProduct( integer array  intArray ( * )
                          ; integer value  lb, ub
                          ; integer result sum, product
                          ) ;
   begin

       sum     := 0;
       product := 1;

       for i := lb until ub
       do begin
           sum     :=     sum + intArray( i );
           product := product * intArray( i );
       end for_i ;

   end sumAndProduct ;

   % test the sumAndProduct procedure                                       %
   begin

       integer array v   ( 1 :: 10 );
       integer sum, product;

       for i := 1 until 10 do v( i ) := i;

       sumAndProduct( v, 1, 10, sum, product );
       write( sum, product );
   end

end.</lang>

Output:

            55         3628800

APL

Works with: APL2

<lang apl> sum ← +/ ⍝ sum (+) over (/) an array

     prod ←  ×/   ⍝ product (×) over (/) an array
     
     a ←  1 2 3 4 5   ⍝ assign a literal array to variable 'a'
     
     sum  a   ⍝ or simply: +/a

15

     prod a   ⍝ or simply: ×/a

120</lang> What follows ⍝ is a comment and / is usually known as reduce in APL. The use of the sum and prod functions is not necessary and was added only to please people baffled by the extreme conciseness of using APL symbols.

Works with: dzaima/APL

(Try It Online)

Works with: Extended Dyalog APL

(Try It Online)

using the pair (⍮) primitive function <lang apl> ⎕ ← (+/ ⍮ ×/) 1 2 3 4 5 15 120</lang> Spaces are optional except as separators between array elements.

AppleScript

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

Condensed version of above, which also prints the results : <lang AppleScript> set {array, sum, product} to {{1, 2, 3, 4, 5}, 0, 1} repeat with i in array set {sum, product} to {sum + i, product * i} end repeat return sum & " , " & product as string </lang>

Output:

"15 , 120"

Or, using an AppleScript implementation of fold/reduce:

<lang AppleScript>on summed(a, b)

   a + b

end summed

on product(a, b)

   a * b

end product

-- TEST ----------------------------------------------------------------------- on run

   set xs to enumFromTo(1, 10)
   
   {xs, ¬
       {sum:foldl(summed, 0, xs)}, ¬
       {product:foldl(product, 1, xs)}}
   
   --> {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {sum:55}, {product:3628800}}

end run

-- GENERIC FUNCTIONS ----------------------------------------------------------

-- enumFromTo :: Int -> Int -> [Int] on enumFromTo(m, n)

   if n < m then
       set d to -1
   else
       set d to 1
   end if
   set lst to {}
   repeat with i from m to n by d
       set end of lst to i
   end repeat
   return lst

end enumFromTo

-- foldl :: (a -> b -> a) -> a -> [b] -> a on foldl(f, startValue, xs)

   tell mReturn(f)
       set v to startValue
       set lng to length of xs
       repeat with i from 1 to lng
           set v to |λ|(v, item i of xs, i, xs)
       end repeat
       return v
   end tell

end foldl

-- Lift 2nd class handler function into 1st class script wrapper -- mReturn :: Handler -> Script on mReturn(f)

   if class of f is script then
       f
   else
       script
           property |λ| : f
       end script
   end if

end mReturn</lang>

Output:

<lang AppleScript>{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {sum:55}, {product:3628800}}</lang>

Arturo

<lang rebol>arr: 1..10

print ["Sum =" sum arr] print ["Product =" product arr]</lang>

Output:

Sum = 55 
Product = 3628800

Asymptote

<lang Asymptote>int[] matriz = {1,2,3,4,5}; int suma = 0, prod = 1;

for (int p : matriz) {

 suma += p;
 prod *= p;

} write("Sum = ", suma); write("Product = ", prod);</lang>

Output:

Sum = 15 
Product = 120

AutoHotkey

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

AWK

For array input, it is easiest to "deserialize" it from a string with the split() function. <lang awk>$ 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</lang>

Babel

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

Perhaps better Babel:

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

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.

BASIC

Works with: FreeBASIC

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

Applesoft BASIC

Works with: Commodore BASIC

<lang ApplesoftBasic> 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</lang>

Atari BASIC

Almost the same code works in Atari BASIC, but you can't READ directly into arrays, leave the variable off a NEXT, or concatenate values in PRINT without semicolons between them:

<lang 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 X:A(I) = X: NEXT I 60 FOR I = 0 TO N 70 S = S + A(I):P = P * A(I) 80 NEXT I 90 PRINT "SUM=";S,"PRODUCT=";P</lang>

BaCon

<lang freebasic> '--- set some values into the array DECLARE a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } TYPE int

sum = 0 product = 1 i = 1

WHILE a[i] <= 10 sum = sum + a[i] product = product * a[i] INCR i WEND

PRINT "The sum is ",sum PRINT "The product is ",product </lang>

BBC BASIC

<lang bbcbasic> 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%</lang>

IS-BASIC

<lang IS-BASIC>100 RANDOMIZE 110 LET N=5 120 NUMERIC A(1 TO N) 130 LET SUM=0:LET PROD=1 140 FOR I=1 TO N 150 LET A(I)=RND(9)+1 160 PRINT A(I); 170 NEXT 180 PRINT 190 FOR I=1 TO N 200 LET SUM=SUM+A(I):LET PROD=PROD*A(I) 210 NEXT 220 PRINT "Sum =";SUM,"Product =";PROD</lang>

BASIC256

Translation of: Yabasic

<lang BASIC256>arraybase 1 dim array(5) array[1] = 1 array[2] = 2 array[3] = 3 array[4] = 4 array[5] = 5

sum = 0 prod = 1 for index = 1 to array[?] sum += array[index] prod *= array[index] next index print "The sum is "; sum #15 print "and the product is "; prod #120 end</lang>

bc

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

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. <lang Befunge>0 &>: #v_ $. @

      >1- \ & + \v
  ^              <</lang>

BQN

Getting the sum and product as a two element array fits nicely within a tacit fork pattern.

Sum +´
Paired with ⋈
Product ×´

<lang bqn> SumProd ← +´⋈×´ +´⋈×´

  SumProd 1‿2‿3‿4‿5

⟨ 15 120 ⟩</lang>

Bracmat

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

Output:

77.9699690

C

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

}</lang>

C#

<lang csharp>int sum = 0, prod = 1; int[] arg = { 1, 2, 3, 4, 5 }; foreach (int value in arg) {

 sum += value;
 prod *= value;

}</lang>

Alternative using Linq (C# 3)

Works with: C# version 3

<lang csharp>int[] arg = { 1, 2, 3, 4, 5 }; int sum = arg.Sum(); int prod = arg.Aggregate((runningProduct, nextFactor) => runningProduct * nextFactor);</lang>

C++

Library: STL

<lang cpp>#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>());</lang> Template alternative: <lang cpp>// 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;

}</lang>

Chef

<lang 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.</lang>

Clean

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

Clojure

<lang lisp>(defn sum [vals] (reduce + vals))

(defn product [vals] (reduce * vals))</lang>

CLU

<lang clu>sum_and_product = proc (a: array[int]) returns (int,int) signals (overflow)

   sum: int := 0
   prod: int := 1
   for i: int in array[int]$elements(a) do
       sum := sum + i
       prod := prod * i
   end resignal overflow
   return(sum, prod)

end sum_and_product

start_up = proc ()

   arr: array[int] := array[int]$[1,2,3,4,5,6,7,8,9,10]
   sum, prod: int := sum_and_product(arr)
   
   po: stream := stream$primary_output()
   stream$putl(po, "Sum = " || int$unparse(sum))
   stream$putl(po, "Product = " || int$unparse(prod))

end start_up</lang>

Output:

Sum = 55
Product = 3628800

COBOL

<lang 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
          .</lang>

CoffeeScript

<lang coffeescript> sum = (array) ->

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

product = (array) ->

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

</lang>

ColdFusion

Sum of an Array, <lang cfm><cfset Variables.myArray = [1,2,3,4,5,6,7,8,9,10]> <cfoutput>#ArraySum(Variables.myArray)#</cfoutput></lang>

Product of an Array, <lang cfm><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></lang>

Common Lisp

<lang lisp>(let ((data #(1 2 3 4 5))) ; the array

 (values (reduce #'+ data)       ; sum
         (reduce #'* data)))     ; product</lang>

The loop macro also has support for sums. <lang lisp>(loop for i in '(1 2 3 4 5) sum i)</lang>

Crystal

Declarative

<lang Ruby> def sum_product(a)

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

end </lang>

Imperative

<lang Ruby> def sum_product_imperative(a)

   sum, product = 0, 1
   a.each do |e|
       sum += e
       product *= e
   end

   {sum, product}

end </lang>

<lang Ruby> require "benchmark" Benchmark.ips do |x|

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

end </lang>

declarative    8.1M (123.45ns) (± 2.99%)  65 B/op   1.30× slower
 imperative  10.57M ( 94.61ns) (± 2.96%)  65 B/op        fastest

D

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

}</lang>

Output:

Sum: 15
Product: 120

Compute sum and product of array in one pass (same output): <lang d>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]);

}</lang>

dc

<lang dc>1 3 5 7 9 11 13 0ss1sp[dls+sslp*spz0!=a]dsax[Sum: ]Plsp[Product: ]Plpp Sum: 49 Product: 135135</lang>

Delphi

<lang 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.</lang>

E

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

Eiffel

<lang eiffel> class APPLICATION

create make

feature {NONE}

make local test: ARRAY [INTEGER] do create test.make_empty test := <<5, 1, 9, 7>> io.put_string ("Sum: " + sum (test).out) io.new_line io.put_string ("Product: " + product (test).out) end

sum (ar: ARRAY [INTEGER]): INTEGER -- Sum of the items of the array 'ar'. do across ar.lower |..| ar.upper as c loop Result := Result + ar [c.item] end end

product (ar: ARRAY [INTEGER]): INTEGER -- Product of the items of the array 'ar'. do Result := 1 across ar.lower |..| ar.upper as c loop Result := Result * ar [c.item] end end

end </lang>

Output:

Sum of the elements of the array: 30
Product of the elements of the array: 3840

Elena

ELENA 5.0: <lang elena>import system'routines; import extensions;

public program() {

   var list := new int[]{1, 2, 3, 4, 5 };

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

}</lang>

Elixir

When an accumulator is omitted, the first element of the collection is used as the initial value of acc. <lang elixir>iex(26)> Enum.reduce([1,2,3,4,5], 0, fn x,acc -> x+acc end) 15 iex(27)> Enum.reduce([1,2,3,4,5], 1, fn x,acc -> x*acc end) 120 iex(28)> Enum.reduce([1,2,3,4,5], fn x,acc -> x+acc end) 15 iex(29)> Enum.reduce([1,2,3,4,5], fn x,acc -> x*acc end) 120 iex(30)> Enum.reduce([], 0, fn x,acc -> x+acc end) 0 iex(31)> Enum.reduce([], 1, fn x,acc -> x*acc end) 1 iex(32)> Enum.reduce([], fn x,acc -> x+acc end)

- (Enum.EmptyError) empty error

   (elixir) lib/enum.ex:1287: Enum.reduce/2

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

- (Enum.EmptyError) empty error

   (elixir) lib/enum.ex:1287: Enum.reduce/2</lang>

The function with sum <lang elixir>Enum.sum([1,2,3,4,5]) #=> 15</lang>

Emacs Lisp

<lang lisp>(let ((array [1 2 3 4 5]))

 (apply #'+ (append array nil))
 (apply #'* (append array nil)))</lang>

Library: cl-lib

<lang lisp>(require 'cl-lib)

(let ((array [1 2 3 4 5]))

 (cl-reduce #'+ array)
 (cl-reduce #'* array))</lang>

Library: seq.el

<lang lisp>(require 'seq)

(let ((array [1 2 3 4 5]))

 (seq-reduce #'+ array 0)
 (seq-reduce #'* array 1))</lang>

Erlang

Using the standard libraries: <lang erlang>% 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).</lang> To compute sum and products in one pass: <lang erlang> {Prod,Sum} = lists:foldl(fun (X, {P,S}) -> {P*X,S+X} end, {1,0}, lists:seq(1,10)).</lang> Or defining our own versions: <lang erlang>-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).</lang>

Euphoria

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

Output:

 sum is 15
 prod is 120

F#

<lang fsharp> let numbers = [| 1..10 |] let sum = numbers |> Array.sum let product = numbers |> Array.reduce (*) </lang>

Factor

<lang factor>1 5 1 <range> [ sum . ] [ product . ] bi

   15 120

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

   10 24</lang>

sum and product are defined in the sequences vocabulary: <lang factor>: sum ( seq -- n ) 0 [ + ] reduce ;

product ( seq -- n ) 1 [ * ] reduce ;</lang>

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. <lang false>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;.</lang>

Output:

Sum: 15
Product: 120

Fantom

<lang 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")
 }

} </lang>

Fermat

<lang fermat> [a]:=[(1,1,2,3,5,8,13)]; !!Sigma<i=1,7>[a[i]]; !!Prod<i=1,7>[a[i]]; </lang>

Output:

33
3120

Forth

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

Fortran

In ISO Fortran 90 and later, use SUM and PRODUCT intrinsics: <lang fortran>integer, dimension(10) :: a = (/ (i, i=1, 10) /) integer :: sresult, presult

sresult = sum(a) presult = product(a)</lang>

FreeBASIC

<lang freebasic>' FB 1.05.0 Win64

Dim a(1 To 4) As Integer = {1, 4, 6, 3} Dim As Integer i, sum = 0, prod = 1 For i = 1 To 4

 sum  += a(i)
 prod *= a(i)

Next Print "Sum ="; sum Print "Product ="; prod Print Print "Press any key to quit" Sleep</lang>

Output:

Sum     = 14
Product = 72

Frink

<lang frink> a = [1,2,3,5,7] sum[a] product[a] </lang>

Fōrmulæ

Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.

Programs in Fōrmulæ are created/edited online in its website, However they run on execution servers. By default remote servers are used, but they are limited in memory and processing power, since they are intended for demonstration and casual use. A local server can be downloaded and installed, it has no limitations (it runs in your own computer). Because of that, example programs can be fully visualized and edited, but some of them will not run if they require a moderate or heavy computation/memory resources, and no local server is being used.

In this page you can see the program(s) related to this task and their results.

Gambas

Click this link to run this code <lang gambas>Public Sub Main() Dim iList As Integer[] = [1, 2, 3, 4, 5] Dim iSum, iCount As Integer Dim iPrd As Integer = 1

For iCount = 0 To iList.Max

 iSum += iList[iCount]
 iPrd *= iList[iCount]

End</lang> Output:

The Sum =       15
The Product =   120

GAP

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

GFA Basic

<lang basic> DIM a%(10) ' put some values into the array FOR i%=1 TO 10

 a%(i%)=i%

NEXT i% ' sum%=0 product%=1 FOR i%=1 TO 10

 sum%=sum%+a%(i%)
 product%=product%*a%(i%)

NEXT i% ' PRINT "Sum is ";sum% PRINT "Product is ";product% </lang>

Go

Implementation

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

}</lang>

Output:

8 10

Library

<lang go>package main

import (

   "fmt"

   "github.com/gonum/floats"

)

var a = []float64{1, 2, 5}

func main() {

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

}</lang>

Output:

Sum:     8
Product: 10

Groovy

Groovy adds a "sum()" method for collections, but not a "product()" method: <lang groovy>[1,2,3,4,5].sum()</lang> However, for general purpose "reduction" or "folding" operations, Groovy does provide an "inject()" method for collections similar to "inject" in Ruby. <lang groovy>[1,2,3,4,5].inject(0) { sum, val -> sum + val } [1,2,3,4,5].inject(1) { prod, val -> prod * val }</lang> You can also combine these operations: <lang groovy>println ([1,2,3,4,5].inject([sum: 0, product: 1]) { result, value ->

   [sum: result.sum + value, product: result.product * value]})</lang>

GW-BASIC

Works with: GW-BASIC

Works with: QBasic

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

Haskell

For lists, sum and product are already defined in the Prelude: <lang haskell>values = [1..10]

s = sum values -- the easy way p = product values

s1 = foldl (+) 0 values -- the hard way p1 = foldl (*) 1 values</lang> To do the same for an array, just convert it lazily to a list: <lang haskell>import Data.Array

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

s = sum . elems $ values p = product . elems $ values</lang>

Or perhaps: <lang haskell>import Data.Array (listArray, elems)

main :: IO () main = mapM_ print $ [sum, product] <*> [elems $ listArray (1, 10) [11 .. 20]]</lang>

Output:

155
670442572800

HicEst

<lang 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;</lang>

Icon and Unicon

The program below prints the sum and product of the arguments to the program. <lang Icon>procedure main(arglist) every ( sum := 0 ) +:= !arglist every ( prod := 1 ) *:= !arglist write("sum := ", sum,", prod := ",prod) end</lang>

IDL

<lang idl>array = [3,6,8] print,total(array) print,product(array)</lang>

Inform 7

<lang inform7>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.</lang>

J

Simple approach:<lang J> (+/,*/) 2 3 5 7 17 210</lang>

Longer exposition:

<lang j>sum =: +/ product =: */</lang>

For example:

<lang j> 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</lang>

Java

Works with: Java version 1.5+

<lang java5>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;
 }
}

}</lang>

Works with: Java version 1.8+

<lang java5>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));
}

}</lang>

Output:

sum = 15
sum = 15
product = 120

JavaScript

ES5

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

Works with: Javascript version 1.8

Where supported, the reduce method can also be used: <lang javascript>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);</lang>

ES6

<lang JavaScript>(() => {

   'use strict';

   // sum :: (Num a) => [a] -> a
   const sum = xs => xs.reduce((a, x) => a + x, 0);

   // product :: (Num a) => [a] -> a
   const product = xs => xs.reduce((a, x) => a * x, 1);

   // TEST
   // show :: a -> String
   const show = x => JSON.stringify(x, null, 2);

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

})();</lang>

Output:

jq

The builtin filter, add/0, computes the sum of an array: <lang jq>[4,6,8] | add

=> 18</lang>

<lang jq>[range(2;5) * 2] | add

=> 18</lang>

An efficient companion filter for computing the product of the items in an array can be defined as follows: <lang jq>def prod: reduce .[] as $i (1; . * $i);</lang> Examples: <lang jq>[4,6,8] | prod

# => 192</lang>

10! <lang jq>[range(1;11)] | prod

=>3628800</lang>

Julia

<lang julia>julia> sum([4,6,8]) 18

julia> +((1:10)...) 55

julia +([1,2,3]...) 6

julia> prod([4,6,8]) 192</lang>

K

<lang k> sum: {+/}x

 product: {*/}x
 a: 1 3 5 7 9 11 13
 sum a

49

 product a

135135</lang>

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

Kotlin

<lang scala>// version 1.1.2

fun main(args: Array<String>) {

   val a = intArrayOf(1, 5, 8, 11, 15)
   println("Array contains : ${a.contentToString()}")
   val sum = a.sum()
   println("Sum is $sum")
   val product = a.fold(1) { acc, i -> acc * i }
   println("Product is $product")

}</lang>

Output:

Array contains : [1, 5, 8, 11, 15]
Sum is 40
Product is 6600

Lambdatalk

<lang lisp> {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 {A.toS array} creates a sequence from the items of an array {long_add x y} returns the sum of two integers of any size {long_mult x y} returns the product of two integers of any size

{def A {A.new {S.serie 1 10}}} -> [1,2,3,4,5,6,7,8,9,10] {+ {A.toS {A}}} -> 55 {* {A.toS {A}}} -> 3628800

{def B {A.new {S.serie 1 100}}} -> [1,2,3,4,5,6,7,8,9,10,...,95,96,97,98,99,100] {S.reduce long_add {A.toS {B}}} -> 5050 {S.reduce long_mult {A.toS {B}}} -> 9332621544394415268169923885626670049071596826438162146859296389521759999322991 5608941463976156518286253697920827223758251185210916864000000000000000000000000 </lang>

Lang5

<lang lang5>4 iota 1 + dup

'+ reduce '* reduce</lang>

langur

<lang langur>val .arr = series 19 writeln " array: ", .arr writeln " sum: ", fold f .x + .y, .arr writeln "product: ", fold f .x x .y, .arr</lang>

Works with: langur version 0.6.6

<lang langur>val .arr = series 19 writeln " array: ", .arr writeln " sum: ", fold f{+}, .arr writeln "product: ", fold f{x}, .arr</lang>

Output:

  array: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
    sum: 190
product: 121645100408832000

Lasso

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

Output:

Sum: 55
Product: 3628800

Liberty BASIC

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

Lingo

<lang lingo>on sum (intList)

 res = 0
 repeat with v in intList
   res = res + v
 end repeat
 return res

end

on product (intList)

 res = 1
 repeat with v in intList
   res = res * v
 end repeat
 return res

end</lang>

LiveCode

<lang LiveCode>//sum put "1,2,3,4" into nums split nums using comma answer sum(nums)

// product local prodNums repeat for each element n in nums

   if prodNums is empty then 
       put n into prodNums
   else
       multiply prodnums by n
   end if

end repeat answer prodnums</lang>

Logo

<lang logo>print apply "sum arraytolist {1 2 3 4 5} print apply "product arraytolist {1 2 3 4 5}</lang>

Lua

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

<lang lua> function table.sum(arr, length)

     --same as if <> then <> else <>
     return length == 1 and arr[1] or arr[length] + table.sum(arr, length -1)

end

function table.product(arr, length)

     return length == 1 and arr[1] or arr[length] * table.product(arr, length -1)

end

t = {1,2,3} print(table.sum(t,#t)) print(table.product(t,3)) </lang>

Lucid

prints a running sum and product of sequence 1,2,3... <lang lucid>[%sum,product%]

where
   x = 1 fby x + 1;
   sum = 0 fby sum + x;
   product = 1 fby product * x
end</lang>

M2000 Interpreter

<lang M2000 Interpreter> Module Checkit {

     a = (1,2,3,4,5,6,7,8,9,10)
     print a#sum() = 55
     sum = lambda->{push number+number}
     product = lambda->{Push number*number}
     print a#fold(lambda->{Push number*number}, 1), a#fold(lambda->{push number+number},0)
     dim a(2,2) = 5
     Print a()#sum() = 20

} checkit </lang>

Maple

<lang maple>a := Array([1, 2, 3, 4, 5, 6]); add(a); mul(a);</lang>

Mathematica/Wolfram Language

Mathematica provides many ways of doing the sum of an array (any kind of numbers or symbols): <lang Mathematica>a = {1, 2, 3, 4, 5} Plus @@ a Apply[Plus, a] Total[a] Total@a a // Total Sum[ai, {i, 1, Length[a]}] Sum[i, {i, a}]</lang> all give 15. For product we also have a couple of choices: <lang Mathematica>a = {1, 2, 3, 4, 5} Times @@ a Apply[Times, a] Product[ai, {i, 1, Length[a]}] Product[i, {i, a}]</lang> all give 120.

MATLAB

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

Sample Usage: <lang MATLAB>>> 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</lang>

Maxima

<lang maxima>lreduce("+", [1, 2, 3, 4, 5, 6, 7, 8]); 36

lreduce("*", [1, 2, 3, 4, 5, 6, 7, 8]); 40320</lang>

MAXScript

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

min

Works with: min version 0.19.3

<lang min>(1 2 3 4 5) ((sum) (1 '* reduce)) cleave "Sum: $1\nProduct: $2" get-stack % puts</lang>

Output:

Sum: 15
Product: 120

МК-61/52

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

Modula-3

<lang modula3>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.</lang>

Output:

Sum of array: 15
Product of array: 120

MUMPS

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

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

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. <lang Nemerle>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);
   }

}</lang>

NetRexx

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

Output:

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

NewLISP

<lang NewLISP>(setq a '(1 2 3 4 5)) (apply + a) (apply * a)</lang>

Nial

Nial being an array language, what applies to individual elements are extended to cover array operations by default strand notation <lang nial>+ 1 2 3 = 6

1 2 3

= 6</lang> array notation <lang nial>+ [1,2,3]</lang> grouped notation <lang nial>(* 1 2 3) = 6

(1 2 3)

= 6</lang> (All these notations are equivalent)

Nim

<lang nim>var xs = [1, 2, 3, 4, 5, 6]

var sum, product: int

product = 1

for x in xs:

 sum += x
 product *= x</lang>

Or functionally: <lang nim>import sequtils

let

 xs = [1, 2, 3, 4, 5, 6]
 sum = xs.foldl(a + b)
 product = xs.foldl(a * b)</lang>

Or using a math function: <lang nim>import math

let numbers = [1, 5, 4] let total = sum(numbers)

var product = 1 for n in numbers:

 product *= n</lang>

Objeck

<lang objeck> sum := 0; prod := 1; arg := [1, 2, 3, 4, 5]; each(i : arg) {

 sum += arg[i];
 prod *= arg[i];

}; </lang>

Objective-C

Works with: GCC version 4.0.1 (apple)

Sum: <lang objc>- (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; }</lang> Product: <lang objc>- (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; }</lang>

OCaml

Arrays

<lang ocaml>(* 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;;</lang>

Lists

<lang ocaml>(* 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;;</lang>

Octave

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

Oforth

<lang Oforth>[1, 2, 3, 4, 5 ] sum println [1, 3, 5, 7, 9 ] prod println</lang>

Output:

15
945

Ol

<lang scheme> (print (fold + 0 '(1 2 3 4 5))) (print (fold * 1 '(1 2 3 4 5))) </lang>

ooRexx

Translation of: REXX

<lang oorexx>a=.my_array~new(20) do i=1 To 20

 a[i]=i
 End

s=a~makestring((LINE),',') Say s Say ' sum='a~sum Say 'product='a~prod

class my_array subclass array

method sum

sum=0 Do i=1 To self~dimension(1)

 sum+=self[i]
 End

Return sum

method prod

Numeric Digits 30 prod=1 Do i=1 To self~dimension(1)

 prod*=self[i]
 End

Return prod</lang>

Output:

1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20
    sum=210
product=2432902008176640000

Oz

Calculations like this are typically done on lists, not on arrays: <lang oz>declare

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

in

 {Show Sum}
 {Show Product}</lang>

If you are actually working with arrays, a more imperative approach seems natural: <lang oz>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}</lang>

PARI/GP

These are built in to GP: vecsum and factorback (the latter can also take factorization matrices, thus the name). They could be coded like so: <lang parigp>vecsum1(v)={

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

}; vecprod(v)={

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

};</lang>

Works with: PARI/GP version 2.10.0+

In 2.10.0 the function vecprod was introduced as well. Like factorback it gives the product of the elements of an array but unlike factorback it doesn't handle factorization matrices.

Pascal

See Delphi

Perl

<lang perl>my @list = ( 1, 2, 3 );

my ( $sum, $prod ) = ( 0, 1 ); $sum += $_ foreach @list; $prod *= $_ foreach @list;</lang> Or using the List::Util module: <lang perl>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);</lang>

Output:

Sum: 45
Product: 362880

Phix

Library: Phix/basics

sequence s = {1,2,3,4,5}
printf(1,"sum is %d\n",sum(s))
printf(1,"prod is %d\n",product(s))

Output:

sum is 15
prod is 120

Phixmonti

<lang Phixmonti>include ..\Utilitys.pmt

( 1 2 3 4 5 )

dup sum "sum is " print print nl

1 swap len for

   get rot * swap

endfor drop

"mult is " print print nl</lang>

PHP

<lang php>$array = array(1,2,3,4,5,6,7,8,9); echo array_sum($array); echo array_product($array);</lang>

Picat

 L = 1..10,
 println(sum=sum(L)),  
 println(prod=prod(L)),  
 nl,
 println(sum_reduce=reduce(+,L)),  
 println(prod_reduce=reduce(*,L)),  
 println(sum_reduce=reduce(+,L,0)),  
 println(prod_reduce=reduce(*,L,1)),  
 nl,
 println(sum_fold=fold(+,0,L)),  
 println(prod_fold=fold(*,1,L)),  
 nl,
 println(sum_rec=sum_rec(L)),  
 println(prod_rec=prod_rec(L)),

nl.

% recursive variants sum_rec(List) = Sum =>

 sum_rec(List,0,Sum).

sum_rec([],Sum0,Sum) =>

 Sum=Sum0.

sum_rec([H|T], Sum0,Sum) =>

 sum_rec(T, H+Sum0,Sum).

prod_rec(List) = Prod =>

 prod_rec(List,1,Prod).

prod_rec([],Prod0,Prod) =>

 Prod=Prod0.

prod_rec([H|T], Prod0,Prod) =>

 prod_rec(T, H*Prod0,Prod).</lang>

Output:

sum = 55
prod = 3628800

sum_reduce = 55
prod_reduce = 3628800
sum_reduce = 55
prod_reduce = 3628800

sum_fold = 55
prod_fold = 3628800

sum_rec = 55
prod_rec = 3628800

PicoLisp

<lang PicoLisp>(let Data (1 2 3 4 5)

  (cons
     (apply + Data)
     (apply * Data) ) )</lang>

Output:

(15 . 120)

PL/I

<lang pli>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));</lang>

Plain English

<lang plainenglish>An element is a thing with a number.

To find a sum and a product of some elements: Put 0 into the sum. Put 1 into the product. Get an element from the elements. Loop. If the element is nil, exit. Add the element's number to the sum. Multiply the product by the element's number. Put the element's next into the element. Repeat.

To make some example elements: If a counter is past 10, exit. Allocate memory for an element. Put the counter into the element's number. Append the element to the example. Repeat.

A product is a number.

To run: Start up. Make some example elements. Find a sum and a product of the example elements. Destroy the example elements. Write "Sum: " then the sum on the console. Write "Product: " then the product on the console. Wait for the escape key. Shut down.

A sum is a number.</lang>

Output:

Sum: 55
Product: 3628800

Pop11

Simple loop: <lang pop11>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;</lang> One can alternatively use second order iterator: <lang pop11>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);</lang>

PostScript

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

Library: initlib

<lang postscript> % sum [1 1 1 1 1] 0 {add} fold % product [1 1 1 1 1] 1 {mul} fold

</lang>

PowerShell

The Measure-Object cmdlet already knows how to compute a sum: <lang powershell>function Get-Sum ($a) {

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

}</lang> But not how to compute a product: <lang powershell>function Get-Product ($a) {

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

}</lang> One could also let PowerShell do all the work by simply creating an expression to evaluate:

Works with: PowerShell version 2

<lang powershell>function Get-Product ($a) {

   if ($a.Length -eq 0) {
       return 0
   }
   $s = $a -join '*'
   return (Invoke-Expression $s)

}</lang> Even nicer, however, is a function which computes both at once and returns a custom object with appropriate properties: <lang powershell>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

}</lang>

Output:

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

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

Prolog

<lang 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.</lang>

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 <lang prolog> 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 .

</lang>

PureBasic

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

 sum  + MyArray(a)
 prod * MyArray(a)

Python

Works with: Python version 2.5

<lang python>numbers = [1, 2, 3] total = sum(numbers)

product = 1 for i in numbers:

   product *= i</lang>

Or functionally (faster but perhaps less clear):

Works with: Python version 2.5

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

Library: NumPy

<lang python>from numpy import r_ numbers = r_[1:4] total = numbers.sum() product = numbers.prod()</lang>

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

<lang python>import math total = math.fsum(floats)</lang>

QBasic

Works with: QBasic

Works with: QuickBasic

Works with: True BASIC

<lang QBasic>DIM array(1 TO 5) DATA 1, 2, 3, 4, 5 FOR index = LBOUND(array) TO UBOUND(array)

   READ array(index)

NEXT index

LET sum = 0 LET prod = 1 FOR index = LBOUND(array) TO UBOUND(array)

   LET sum = sum + array(index)
   LET prod = prod * array(index)

NEXT index PRINT "The sum is "; sum PRINT "and the product is "; prod END</lang>

Quackery

<lang Quackery>[ 0 swap witheach + ] is sum ( [ --> n )

[ 1 swap witheach * ] is product ( [ --> n )</lang> In the shell (i.e. Quackery REPL): <lang Quackery> /O> ' [ 1 2 3 4 5 ] sum echo cr ... ' [ 1 2 3 4 5 ] product echo ... 15 120 Stack empty.</lang>

R

<lang r>total <- sum(1:5) product <- prod(1:5)</lang>

Racket

<lang racket>#lang racket

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

Raku

(formerly Perl 6) <lang perl6>my @ary = 1, 5, 10, 100; say 'Sum: ', [+] @ary; say 'Product: ', [*] @ary;</lang>

Rapira

<lang Rapira>fun sumOfArr(arr)

 sum := 0
 for N from 1 to #arr do
   sum := sum + arr[N]
 od
 return sum

end

fun productOfArr(arr)

 product := arr[1]
 for N from 2 to #arr do
   product := product * arr[N]
 od
 return product

end</lang>

Raven

REBOL

<lang REBOL>REBOL [

   Title: "Sum and Product"
   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]]</lang>

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

Red

<lang rebol>Red [

   red-version: 0.6.4
   description: "Find the sum and product of an array of numbers."

]

product: function [

   "Returns the product of all values in a block."
   values [any-list! vector!]

][

   result: 1
   foreach value values [result: result * value]
   result

]

a: [1 2 3 4 5 6 7 8 9 10] print a print ["Sum:" sum a] print ["Product:" product a]</lang>

Output:

1 2 3 4 5 6 7 8 9 10
Sum: 55
Product: 3628800

REXX

<lang rexx>/*REXX program adds and multiplies N elements of a (populated) array @. */ numeric digits 200 /*200 decimal digit #s (default is 9).*/ parse arg N .; if N== then N=20 /*Not specified? Then use the default.*/

         do j=1  for N                /*build array of  N  elements (or 20?).*/
         @.j=j                        /*set 1st to 1, 3rd to 3, 8th to 8 ··· */
         end   /*j*/

sum=0 /*initialize SUM (variable) to zero. */ prod=1 /*initialize PROD (variable) to unity.*/

         do k=1  for N
         sum  = sum  + @.k            /*add the element to the running total.*/
         prod = prod * @.k            /*multiply element to running product. */
         end   /*k*/                  /* [↑]  this pgm:  same as N factorial.*/

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

                                      /*stick a fork in it,  we're all done. */</lang>

output using the default input of: 20

     sum of  M  elements for the  @  array is:  210
 product of  M  elements for the  @  array is:  2432902008176640000

Ring

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

Ruby

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

Works with: Ruby version 1.8.7

<lang ruby>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</lang>

Note: When the Array is empty, the initial value returns. However, nil returns if not giving an initial value. <lang ruby>arr = [] p arr.inject(0, :+) #=> 0 p arr.inject(1, :*) #=> 1 p arr.inject(:+) #=> nil p arr.inject(:*) #=> nil</lang>

Enumerable#reduce is the alias of Enumerable#inject.

Works with: Ruby version 1.9.3

Run BASIC

<lang runbasic>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</lang>

Rust

fn main() {

   let arr = vec![1, 2, 3, 4, 5, 6, 7, 8, 9];

   // using fold
   let sum = arr.iter().fold(0i32, |a, &b| a + b);
   let product = arr.iter().fold(1i32, |a, &b| a * b);
   println!("the sum is {} and the product is {}", sum, product);

   // or using sum and product
   let sum = arr.iter().sum::<i32>();
   let product = arr.iter().product::<i32>();
   println!("the sum is {} and the product is {}", sum, product);

} </lang>

S-lang

<lang S-lang>variable a = [5, -2, 3, 4, 666, 7];</lang>

The sum of array elements is handled by an intrinsic. [note: print is slsh-specific; if not available, use printf().]

<lang S-lang>print(sum(a));</lang>

The product is slightly more involved; I'll use this as a chance to show the alternate stack-based use of 'foreach': <lang S-lang>variable prod = a[0];

% Skipping the loop variable causes the val to be placed on the stack. % Also note that the double-brackets ARE required. The inner one creates % a "range array" based on the length of a. foreach (a1:)

 % () pops it off.
 prod *= ();

print(prod);</lang>

SAS

<lang 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;</lang>

Sather

<lang 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;</lang>

Scala

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

Or even shorter: <lang scala>val sum = seq.sum val product = seq.product</lang>

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

Scheme

<lang scheme>(apply + '(1 2 3 4 5)) (apply * '(1 2 3 4 5))</lang> 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. <lang scheme>(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 *</lang>

Seed7

<lang 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;</lang>

Call these functions with:

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

SETL

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

=> 45 362880

Sidef

Using built-in methods: <lang ruby>var ary = [1, 2, 3, 4, 5]; say ary.sum; # => 15 say ary.prod; # => 120</lang>

Alternatively, using hyper-operators: <lang ruby>var ary = [1, 2, 3, 4, 5]; say ary«+»; # => 15 say ary«*»; # => 120</lang>

Slate

<lang slate>#(1 2 3 4 5) reduce: [:sum :number | sum + number]

(1 2 3 4 5) reduce: [:product :number | product * number]</lang>

Shorthand for the above with a macro: <lang slate>#(1 2 3 4 5) reduce: #+ `er

(1 2 3 4 5) reduce: #* `er</lang>

Smalltalk

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

Some implementation also provide a fold: message: <lang smalltalk>#(1 2 3 4 5) fold: [:sum :number | sum + number]

(1 2 3 4 5) fold: [:product :number | product * number]</lang>

SNOBOL4

<lang snobol> 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</lang>

Input

Output:

 Sum:  15
 Prod: 120

Sparkling

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

Standard ML

Arrays

<lang sml>(* 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;</lang>

Lists

<lang sml>(* 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;</lang>

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:

<lang stata>a = 1,-2,-3,-4,5 sum(a)

-3

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

 -120</lang>

Swift

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

Tcl

Works with: Tcl version 8.5

<lang tcl>set arr [list 3 6 8] set sum [tcl::mathop::+ {*}$arr] set prod [tcl::mathop::* {*}$arr]</lang>

TI-83 BASIC

Use the built-in functions sum() and prod(). <lang ti83b>seq(X,X,1,10,1)→L₁ {1 2 3 4 5 6 7 8 9 10} sum(L₁) 55 prod(L₁) 3628800</lang>

Toka

<lang 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 .</lang>

Trith

<lang trith>[1 2 3 4 5] 0 [+] foldl</lang> <lang trith>[1 2 3 4 5] 1 [*] foldl</lang>

True BASIC

Works with: QBasic

<lang QBasic>DIM array(1 TO 5) DATA 1, 2, 3, 4, 5 FOR index = LBOUND(array) TO UBOUND(array)

   READ array(index)

NEXT index

LET sum = 0 LET prod = 1 FOR index = LBOUND(array) TO UBOUND(array)

   LET sum = sum + array(index)
   LET prod = prod * array(index)

NEXT index PRINT "The sum is "; sum PRINT "and the product is "; prod END</lang>

TUSCRIPT

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

Output:

    sum: 15
product: 120

UNIX Shell

Works with: NetBSD version 3.0

From an internal variable, $IFS delimited:

From the argument list (ARGV):

From STDIN, one integer per line:

<lang bash>sum=0 prod=1 while read n do sum="$(($sum + $n))"; prod="$(($prod * $n))" done echo $sum $prod</lang>

Works with: Bourne Again SHell

Works with: Korn Shell

Works with: Zsh

Using an actual array variable:

<lang bash>list=(20 20 2); (( sum=0, prod=1 )) for n in "${list[@]}"; do

  (( sum += n, prod *= n ))

done printf '%d\t%d\n' "$sum" "$prod" </lang>

Output:

42	800

UnixPipes

Uses ksh93-style process substitution.

Works with: bash

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

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.

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. <lang ursa>declare int<> stream append 34 76 233 8 2 734 56 stream

outputs 1143

out (+ stream) endl console

outputs 3.95961079808E11

out (* stream) endl console</lang>

Ursala

The reduction operator, :-, takes an associative binary function and a constant for the empty case. Natural numbers are unsigned and of unlimited size. <lang Ursala>#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></lang>

Output:

(875,2126997171723931187788800000)

V

<lang v>[sp dup 0 [+] fold 'product=' put puts 1 [*] fold 'sum=' put puts].</lang>

Using it:

<lang v>[1 2 3 4 5] sp = product=15 sum=120</lang>

Vala

<lang Vala>void main() {

 int sum = 0, prod = 1;
 int[] data = { 1, 2, 3, 4 };
 foreach (int val in data) {
   sum  += val;
   prod *= val;
 } 
 print(@"sum: $(sum)\nproduct: $(prod)");

}</lang>

Output:

sum: 10
product: 24

VBA

Assumes Excel is used. <lang vb>Sub Demo() 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)

End Sub</lang>

Output:

sum : 55
product : 3628800

VBScript

<lang vb>Function sum_and_product(arr) sum = 0 product = 1 For i = 0 To UBound(arr) sum = sum + arr(i) product = product * arr(i) Next WScript.StdOut.Write "Sum: " & sum WScript.StdOut.WriteLine WScript.StdOut.Write "Product: " & product WScript.StdOut.WriteLine End Function

myarray = Array(1,2,3,4,5,6) sum_and_product(myarray) </lang>

Output:

Sum: 21
Product: 720

Visual Basic .NET

Translation of: C#

<lang vbnet>Module Program

   Sub Main()
       Dim arg As Integer() = {1, 2, 3, 4, 5}
       Dim sum = arg.Sum()
       Dim prod = arg.Aggregate(Function(runningProduct, nextFactor) runningProduct * nextFactor)
   End Sub

End Module</lang>

Wart

<lang wart>def (sum_prod nums)

 (list (+ @nums) (* @nums))</lang>

WDTE

<lang WDTE>let a => import 'arrays'; let s => import 'stream';

let sum array => a.stream array -> s.reduce 0 +; let prod array => a.stream prod -> s.reduce 1 *;</lang>

Wortel

<lang wortel>@sum [1 2 3 4] ; returns 10 @prod [1 2 3 4] ; returns 24</lang>

Wren

Library: Wren-math

<lang ecmascript>import "/math" for Nums var a = [7, 10, 2, 4, 6, 1, 8, 3, 9, 5] System.print("Array : %(a)") System.print("Sum : %(Nums.sum(a))") System.print("Product : %(Nums.prod(a))")</lang>

Output:

Array   : [7, 10, 2, 4, 6, 1, 8, 3, 9, 5]
Sum     : 55
Product : 3628800

XPL0

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

Output:

55
3628800

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: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></lang>

Yabasic

Translation of: QBasic

<lang yabasic>dim array(5) data 1, 2, 3, 4, 5 for index = 1 to arraysize(array(), 1)

   read array(index)

next index

sum = 0 prod = 1 for index = 1 to arraysize(array(), 1)

   sum = sum + array(index)
   prod = prod * array(index)

next index print "The sum is ", sum //15 print "and the product is ", prod //120 end</lang>

zkl

Translation of: Clojure

<lang zkl>fcn sum(vals){vals.reduce('+,0)} fcn product(vals){vals.reduce('*,1)}</lang>

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

Zoea

<lang Zoea> program: sum_and_product

 case: 1
   input: [3,5]
   output: [8,15]
 case: 2
   input: [2,3,4]
   output: [9,24]

</lang>

Zoea Visual

Sum and product of an array