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

prod ← ×/ ⍝ product (×) over (/) an array

prod a ⍝ or simply: ×/a

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|Extended Dyalog APL}} ([https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn//1HfVIVHbRMUNLT1FR71rlM4PF1fU8FQwUjBWMFEwfT/fwA Try It Online])

using the [https://aplwiki.com/wiki/Pair pair (⍮)] primitive function

Spaces are optional except as separators between array elements.

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

=={{header|Asymptote}}==

int suma = 0, prod = 1;

}

write("Sum = ", suma);

{{out}}

<pre>Sum = 15

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

{{works with|Commodore 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)

80 NEXT

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

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)

80 NEXT 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|BQN}}==

* Paired with <code>⋈</code>

* Product <code>×´</code>

+´⋈×´

SumProd 1‿2‿3‿4‿5

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

(apply #'+ (append array nil))

{{libheader|cl-lib}}

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

(cl-reduce #'+ array)

{{libheader|seq.el}}

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

(seq-reduce #'+ array 0)

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

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

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

<hr />

Longer exposition:

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

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

writeln " array: ", .arr

writeln " sum: ", fold f .x + .y, .arr

{{works with|langur|0.6.6}}

writeln " array: ", .arr

writeln " sum: ", fold f{+}, .arr

{{out}}

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

I HAS A Nums ITZ A BUKKIT

Nums HAS A Length ITZ 0

VISIBLE "Product = " !

VISIBLE Timesed

{{Out}}

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