Sum and product of an array: Difference between revisions
→{{header|langur}}
m (useless in Fortran) |
Langurmonkey (talk | contribs) |
||
(100 intermediate revisions by 58 users not shown) | |||
Line 1:
{{task|Arithmetic operations}}
[[Category:Iteration]]
;Task:
Compute the sum and product of an array of integers.
<br><br>
=={{header|11l}}==
<syntaxhighlight lang="11l">V arr = [1, 2, 3, 4]
print(sum(arr))
print(product(arr))</syntaxhighlight>
{{out}}
<pre>
10
24
</pre>
=={{header|360 Assembly}}==
<
SUMPROD CSECT
USING SUMPROD,R15 base register
Line 23 ⟶ 38:
PG DS CL24 buffer
YREGS
END SUMPROD</
{{out}}
<pre>
55 3628800
</pre>
=={{header|4D}}==
<
For ($i;1;5)
APPEND TO ARRAY($list;$i)
Line 46 ⟶ 60:
$sum:=sum($list)
</syntaxhighlight>
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits <br> or android 64 bits with application Termux }}
<syntaxhighlight lang AArch64 Assembly>
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program sumandproduct64.s */
/************************************/
/* Constantes */
/************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
/*********************************/
/* Initialized data */
/*********************************/
.data
szMessSum: .asciz "Sum = "
szMessProd: .asciz "Product = "
szMessStart: .asciz "Program 64 bits start.\n"
szCarriageReturn: .asciz "\n"
szMessErreur: .asciz "Overflow ! \n"
tabArray: .quad 2, 11, 19, 90, 55,1000000
.equ TABARRAYSIZE, (. - tabArray) / 8
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
sZoneConv: .skip 24
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: // entry of program
ldr x0,qAdrszMessStart
bl affichageMess
ldr x2,qAdrtabArray
mov x1,#0 // indice
mov x0,#0 // sum init
1:
ldr x3,[x2,x1,lsl #3]
adds x0,x0,x3
bcs 99f
add x1,x1,#1
cmp x1,#TABARRAYSIZE
blt 1b
ldr x1,qAdrsZoneConv
bl conversion10 // decimal conversion
mov x0,#3 // number string to display
ldr x1,qAdrszMessSum
ldr x2,qAdrsZoneConv // insert conversion in message
ldr x3,qAdrszCarriageReturn
bl displayStrings // display message
ldr x2,qAdrtabArray
mov x1,#0 // indice
mov x0,#1 // product init
2:
ldr x3,[x2,x1,lsl #3]
mul x0,x3,x0
umulh x4,x3,x0
cmp x4,#0
bne 99f
add x1,x1,#1
cmp x1,#TABARRAYSIZE
blt 2b
ldr x1,qAdrsZoneConv
bl conversion10 // decimal conversion
mov x0,#3 // number string to display
ldr x1,qAdrszMessProd
ldr x2,qAdrsZoneConv // insert conversion in message
ldr x3,qAdrszCarriageReturn
bl displayStrings // display message
b 100f
99:
ldr x0,qAdrszMessErreur
bl affichageMess
100: // standard end of the program
mov x0, #0 // return code
mov x8,EXIT
svc #0 // perform the system call
qAdrszCarriageReturn: .quad szCarriageReturn
qAdrsZoneConv: .quad sZoneConv
qAdrszMessSum: .quad szMessSum
qAdrszMessProd: .quad szMessProd
qAdrszMessErreur: .quad szMessErreur
qAdrszMessStart: .quad szMessStart
qAdrtabArray: .quad tabArray
/***************************************************/
/* display multi strings */
/* new version 24/05/2023 */
/***************************************************/
/* x0 contains number strings address */
/* x1 address string1 */
/* x2 address string2 */
/* x3 address string3 */
/* x4 address string4 */
/* x5 address string5 */
/* x6 address string5 */
displayStrings: // INFO: displayStrings
stp x7,lr,[sp,-16]! // save registers
stp x2,fp,[sp,-16]! // save registers
add fp,sp,#32 // save paraméters address (4 registers saved * 8 bytes)
mov x7,x0 // save strings number
cmp x7,#0 // 0 string -> end
ble 100f
mov x0,x1 // string 1
bl affichageMess
cmp x7,#1 // number > 1
ble 100f
mov x0,x2
bl affichageMess
cmp x7,#2
ble 100f
mov x0,x3
bl affichageMess
cmp x7,#3
ble 100f
mov x0,x4
bl affichageMess
cmp x7,#4
ble 100f
mov x0,x5
bl affichageMess
cmp x7,#5
ble 100f
mov x0,x6
bl affichageMess
100:
ldp x2,fp,[sp],16 // restaur registers
ldp x7,lr,[sp],16 // restaur registers
ret
/***************************************************/
/* ROUTINES INCLUDE */
/***************************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeARM64.inc"
</syntaxhighlight>
{{Out}}
<pre>
Program 64 bits start.
Sum = 1000177
Product = 2069100000000
</pre>
=={{header|ACL2}}==
<
(if (endp xs)
0
Line 59 ⟶ 222:
1
(* (first xs)
(prod (rest xs)))))</
=={{header|Action!}}==
<syntaxhighlight 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</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sum_and_product_of_an_array.png Screenshot from Atari 8-bit computer]
<pre>
1+2+3+4+5+6+7=28
1*2*3*4*5*6*7=5040
</pre>
=={{header|ActionScript}}==
<
import flash.display.Sprite;
Line 83 ⟶ 289:
}
}
}</
=={{header|Ada}}==
<
array : Int_Array := (1,2,3,4,5,6,7,8,9,10);
Line 92 ⟶ 298:
for I in array'range loop
Sum := Sum + array(I);
end loop;</
Define the product function
<
Prod : Integer := 1;
begin
Line 101 ⟶ 307:
end loop;
return Prod;
end Product;</
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)
{
integer
s = 0;
p = 1;
}
}
Line 125 ⟶ 329:
integer sum, product;
compute(sum, product,
o_form("~\n~\n", sum, product);
return 0;
}</
{{out}}
<pre>77
Line 136 ⟶ 340:
=={{header|ALGOL 68}}==
<
INT default upb := 3;
MODE INTARRAY = [default upb]INT;
Line 156 ⟶ 360:
) # int product # ;
printf(($" Sum: "g(0)$,sum,$", Product:"g(0)";"l$,int product(array)))
)</
{{Out}}
<pre>
Line 163 ⟶ 367:
=={{header|ALGOL W}}==
<
% computes the sum and product of intArray %
Line 196 ⟶ 400:
write( sum, product );
end
end.</
{{out}}
Line 205 ⟶ 409:
=={{header|APL}}==
{{works with|APL2}}
<
prod ← ×/ ⍝ product (×) over (/) an array
sum
15
prod
120</
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}} ([https://tio.run/##SyzI0U2pSszMTfz//1Hf1EdtEzS09R/1rjs8XV/TUMFIwVjBRMH0/38A Try It Online])
{{works with|Extended Dyalog APL}} ([https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn//1HfVIVHbRMUNLT1FR71rlM4PF1fU8FQwUjBWMFEwfT/fwA Try It Online])
using the [https://aplwiki.com/wiki/Pair pair (⍮)] primitive function
<syntaxhighlight lang="apl"> ⎕ ← (+/ ⍮ ×/) 1 2 3 4 5
15 120</syntaxhighlight>
Spaces are optional except as separators between array elements.
=={{header|AppleScript}}==
<
set sum to 0
set product to 1
Line 222 ⟶ 436:
set sum to sum + i
set product to product * i
end repeat</
Condensed version of above, which also prints the results :
<syntaxhighlight 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
</syntaxhighlight>
{{out}}
<pre>
"15 , 120"
</pre>
Or, using an AppleScript implementation of '''fold'''/'''reduce''':
<
a + b
end summed
Line 285 ⟶ 512:
end script
end if
end mReturn</
{{Out}}
<
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi <br> or android 32 bits with application Termux}}
<syntaxhighlight lang ARM Assembly>
/* ARM assembly Raspberry PI */
/* program sumandproduct.s */
/* REMARK 1 : this program use routines in a include file
see task Include a file language arm assembly
for the routine affichageMess conversion10
see at end of this program the instruction include */
/* for constantes see task include a file in arm assembly */
/************************************/
/* Constantes */
/************************************/
.include "../constantes.inc"
/*********************************/
/* Initialized data */
/*********************************/
.data
szMessSum: .asciz "Sum = "
szMessProd: .asciz "Product = "
szMessStart: .asciz "Program 32 bits start.\n"
szCarriageReturn: .asciz "\n"
szMessErreur: .asciz "Overflow ! \n"
tabArray: .int 2, 11, 19, 90, 55,1000
.equ TABARRAYSIZE, (. - tabArray) / 4
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
sZoneConv: .skip 24
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: @ entry of program
ldr r0,iAdrszMessStart
bl affichageMess
ldr r2,iAdrtabArray
mov r1,#0 @ indice
mov r0,#0 @ sum init
1:
ldr r3,[r2,r1,lsl #2]
adds r0,r0,r3
bcs 99f
add r1,r1,#1
cmp r1,#TABARRAYSIZE
blt 1b
ldr r1,iAdrsZoneConv
bl conversion10 @ decimal conversion
mov r3,#0
strb r3,[r1,r0]
mov r0,#3 @ number string to display
ldr r1,iAdrszMessSum
ldr r2,iAdrsZoneConv @ insert conversion in message
ldr r3,iAdrszCarriageReturn
bl displayStrings @ display message
ldr r2,iAdrtabArray
mov r1,#0 @ indice
mov r0,#1 @ product init
2:
ldr r3,[r2,r1,lsl #2]
umull r0,r4,r3,r0
cmp r4,#0
bne 99f
add r1,r1,#1
cmp r1,#TABARRAYSIZE
blt 2b
ldr r1,iAdrsZoneConv
bl conversion10 @ decimal conversion
mov r3,#0
strb r3,[r1,r0]
mov r0,#3 @ number string to display
ldr r1,iAdrszMessProd
ldr r2,iAdrsZoneConv @ insert conversion in message
ldr r3,iAdrszCarriageReturn
bl displayStrings @ display message
b 100f
99:
ldr r0,iAdrszMessErreur
bl affichageMess
100: @ standard end of the program
mov r0, #0 @ return code
mov r7, #EXIT @ request to exit program
svc #0 @ perform the system call
iAdrszCarriageReturn: .int szCarriageReturn
iAdrsZoneConv: .int sZoneConv
iAdrszMessSum: .int szMessSum
iAdrszMessProd: .int szMessProd
iAdrszMessErreur: .int szMessErreur
iAdrszMessStart: .int szMessStart
iAdrtabArray: .int tabArray
/***************************************************/
/* display multi strings */
/***************************************************/
/* r0 contains number strings address */
/* r1 address string1 */
/* r2 address string2 */
/* r3 address string3 */
/* other address on the stack */
/* thinck to add number other address * 4 to add to the stack */
displayStrings: @ INFO: displayStrings
push {r1-r4,fp,lr} @ save des registres
add fp,sp,#24 @ save paraméters address (6 registers saved * 4 bytes)
mov r4,r0 @ save strings number
cmp r4,#0 @ 0 string -> end
ble 100f
mov r0,r1 @ string 1
bl affichageMess
cmp r4,#1 @ number > 1
ble 100f
mov r0,r2
bl affichageMess
cmp r4,#2
ble 100f
mov r0,r3
bl affichageMess
cmp r4,#3
ble 100f
mov r3,#3
sub r2,r4,#4
1: @ loop extract address string on stack
ldr r0,[fp,r2,lsl #2]
bl affichageMess
subs r2,#1
bge 1b
100:
pop {r1-r4,fp,pc}
/***************************************************/
/* ROUTINES INCLUDE */
/***************************************************/
.include "../affichage.inc"
</syntaxhighlight>
{{Out}}
<pre>
Program 32 bits start.
Sum = 1177
Product = 2069100000
</pre>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">arr: 1..10
print ["Sum =" sum arr]
print ["Product =" product arr]</syntaxhighlight>
{{out}}
<pre>Sum = 55
Product = 3628800</pre>
=={{header|Asymptote}}==
<syntaxhighlight 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);</syntaxhighlight>
{{out}}
<pre>Sum = 15
Product = 120</pre>
=={{header|AutoHotkey}}==
<
product := 1
loop, parse, numbers, `,
Line 297 ⟶ 698:
product *= A_LoopField
}
msgbox, sum = %sum%`nproduct = %product%</
=={{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
Line 306 ⟶ 708:
$ 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</
=={{header|Babel}}==
<
sum! : { <- 0 -> { + } eachar }
Line 321 ⟶ 723:
Result:
41
30030</
Perhaps better Babel:
<
{ [2 3 5 7 11 13]
ar2ls dup cp
Line 343 ⟶ 745:
{ * }
{ depth 1 > }
do_while } nest }</
The nest operator creates a kind of argument-passing context -
Line 356 ⟶ 758:
=={{header|BASIC}}==
{{works with|FreeBASIC}}
<
dim sum as integer = 0
Line 363 ⟶ 765:
sum += array(index)
prod *= array(index)
next</
==={{header|Applesoft BASIC}}===
{{works with|Commodore BASIC}}
<syntaxhighlight lang="applesoftbasic"> 10 N = 5
20 S = 0:P = 1: DATA 1,2,3,4,5
30 N = N - 1: DIM A(N)
40
50
60
70 S = S + A(I):P = P * A(I)
80
90
==={{header|
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:
<syntaxhighlight 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</syntaxhighlight>
==={{header|BaCon}}===
<syntaxhighlight 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
</syntaxhighlight>
==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
{{works with|QBasic}}
<syntaxhighlight lang="qbasic">10 rem Sum and product of an array
20 dim array(4)' array de 5 eltos.
30 data 1,2,3,4,5
40 for index = 0 to ubound(array)
50 read array(index)
60 next index
70 sum = 0
80 prod = 1
90 for index = 0 to 4 ubound(array)
100 sum = sum+array(index)
110 prod = prod*array(index)
120 next index
130 print "The sum is ";sum
140 print "and the product is ";prod
150 end</syntaxhighlight>
==={{header|BBC BASIC}}===
<syntaxhighlight lang="bbcbasic"> DIM array%(5)
array%() = 1, 2, 3, 4, 5, 6
Line 386 ⟶ 840:
product% *= array%(I%)
NEXT
PRINT "Product of array elements = " ; product%</
==={{header|IS-BASIC}}===
<syntaxhighlight 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</syntaxhighlight>
=={{header|BASIC256}}==
{{trans|Yabasic}}
<syntaxhighlight 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</syntaxhighlight>
=={{header|bc}}==
<
a[1] = 1
a[2] = 4.0
Line 402 ⟶ 893:
}
"Sum: "; s
"Product: "; p</
=={{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}}==
Getting the sum and product as a two element array fits nicely within a tacit fork pattern.
* Sum <code>+´</code>
* Paired with <code>⋈</code>
* Product <code>×´</code>
<syntaxhighlight lang="bqn"> SumProd ← +´⋈×´
+´⋈×´
SumProd 1‿2‿3‿4‿5
⟨ 15 120 ⟩</syntaxhighlight>
=={{header|Bracmat}}==
<
= sum prod num
. 0:?sum
Line 427 ⟶ 931:
)
& out$sumprod$(2 3 5 7 11 13 17 19)
);</
{{Out}}
<pre>77.9699690</pre>
=={{header|Bruijn}}==
<syntaxhighlight lang="bruijn">
:import std/List .
:import std/Math .
arr (+1) : ((+2) : ((+3) : {}(+4)))
main [∑arr : ∏arr]
</syntaxhighlight>
=={{header|C}}==
<
int arg[] = { 1,2,3,4,5 };
int arg_length = sizeof(arg)/sizeof(arg[0]);
Line 442 ⟶ 956:
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();
int prod = arg.Aggregate((runningProduct, nextFactor) => runningProduct * nextFactor);</
=={{header|C++}}==
{{libheader|STL}}
<
#include <functional>
Line 469 ⟶ 983:
// 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>());</
Template alternative:
<
template <typename T> T sum (const T *array, const unsigned n)
{
Line 498 ⟶ 1,012:
cout << sum(aflo,4) << " " << prod(aflo,4) << endl;
return 0;
}</
=={{header|Chef}}==
<
This recipe sums N given numbers.
Line 524 ⟶ 1,038:
Pour contents of 1st mixing bowl into the baking dish.
Serves 1.</
=={{header|Clean}}==
<
Sum = sum [x \\ x <-: array]
Prod = foldl (*) 1 [x \\ x <-: array]</
=={{header|Clojure}}==
<
(defn product [vals] (reduce * vals))</
=={{header|CLU}}==
<syntaxhighlight 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</syntaxhighlight>
{{out}}
<pre>Sum = 55
Product = 3628800</pre>
=={{header|COBOL}}==
<
PROGRAM-ID. array-sum-and-product.
Line 562 ⟶ 1,099:
GOBACK
.</
=={{header|CoffeeScript}}==
<
sum = (array) ->
array.reduce (x, y) -> x + y
Line 571 ⟶ 1,108:
product = (array) ->
array.reduce (x, y) -> x * y
</syntaxhighlight>
=={{header|ColdFusion}}==
Sum of an Array,
<
<cfoutput>#ArraySum(Variables.myArray)#</cfoutput></
Product of an Array,
<
<cfset Variables.Product = 1>
<cfloop array="#Variables.myArray#" index="i">
<cfset Variables.Product *= i>
</cfloop>
<cfoutput>#Variables.Product#</cfoutput></
=={{header|Common Lisp}}==
<
(values (reduce #'+ data) ; sum
(reduce #'* data))) ; product</
The loop macro also has support for sums.
<
=={{header|Crystal}}==
===Declarative===
<syntaxhighlight lang="ruby">
def sum_product(a)
{ a.sum(), a.product() }
end
</syntaxhighlight>
===Imperative===
<syntaxhighlight lang="ruby">
def sum_product_imperative(a)
sum, product = 0, 1
a.each do |e|
sum += e
product *= e
end
{sum, product}
end
</syntaxhighlight>
<syntaxhighlight 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
</syntaxhighlight>
<pre>declarative 8.1M (123.45ns) (± 2.99%) 65 B/op 1.30× slower
imperative 10.57M ( 94.61ns) (± 2.96%) 65 B/op fastest</pre>
=={{header|D}}==
<
void main() {
Line 610 ⟶ 1,179:
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() {
Line 625 ⟶ 1,194:
writeln("Sum: ", r[0]);
writeln("Product: ", r[1]);
}</
=={{header|dc}}==
<
Sum: 49
Product: 135135</
=={{header|Delphi}}==
<
{$APPTYPE CONSOLE}
Line 653 ⟶ 1,222:
Write('Product: ');
Writeln(lProduct);
end.</
=={{header|E}}==
<
accum 0 for x in [1,2,3,4,5] { _ + x }
accum 1 for x in [1,2,3,4,5] { _ * x }</
=={{header|EasyLang}}==
<syntaxhighlight lang="easylang">
array[] = [ 5 1 19 25 12 1 14 7 ]
product = 1
for item in array[]
sum += item
product *= item
.
print "Sum: " & sum
print "Product: " & product</syntaxhighlight>
{{out}}
<pre>
Sum: 84
Product: 2793000
</pre>
=={{header|Eiffel}}==
<
class
APPLICATION
Line 703 ⟶ 1,288:
end
</syntaxhighlight>
{{Out}}
<pre>Sum of the elements of the array: 30
Product of the elements of the array: 3840</pre>
=={{header|Elena}}==
ELENA 5.0:
<syntaxhighlight lang="elena">import system'routines;
import extensions;
public program()
{
var list :=
var sum := list
var product := list
}</syntaxhighlight>
=={{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)
Line 738 ⟶ 1,325:
iex(32)> Enum.reduce([], fn x,acc -> x*acc end)
** (Enum.EmptyError) empty error
(elixir) lib/enum.ex:1287: Enum.reduce/2</
The function with sum
<
=={{header|Emacs Lisp}}==
<
{{libheader|cl-lib}}
<syntaxhighlight lang
(let ((array [1 2 3 4 5]))
(cl-reduce #'+ array)
(cl-reduce #'* array))</syntaxhighlight>
{{libheader|seq.el}}
<syntaxhighlight lang="lisp">(require 'seq)
(let ((array [1 2 3 4 5]))
(seq-reduce #'+ array 0)
(seq-reduce #'* array 1))</syntaxhighlight>
=={{header|Erlang}}==
Using the standard libraries:
<
L = lists:seq(1, 10).
% and compute its sum:
S = lists:sum(L).
P = lists:foldl(fun (X, P) -> X * P end, 1, L).</
To compute sum and products in one pass:
<
{Prod,Sum} = lists:foldl(fun (X, {P,S}) -> {P*X,S+X} end, {1,0}, lists:seq(1,10)).</
Or defining our own versions:
<
-export([sum_rec/1, sum_tail/1]).
Line 789 ⟶ 1,379:
Acc;
sum_tail([Head|Tail], Acc) ->
sum_tail(Tail, Head + Acc).</
=={{header|Euler}}==
In Euler, a list must be assigned to a variable in order for it to be subscripted.
'''begin'''
'''new''' sumAndProduct;
'''new''' sumField; '''new''' productField;
sumAndProduct
<- ` '''formal''' array;
'''begin'''
'''new''' sum; '''new''' product; '''new''' i; '''new''' v; '''label''' arrayLoop;
v <- array;
sum <- 0;
product <- 1;
i <- 0;
arrayLoop: '''if''' [ i <- i + 1 ] <= '''length''' array '''then''' '''begin'''
sum <- sum + v[ i ];
product <- product * v[ i ];
'''goto''' arrayLoop
'''end''' '''else''' 0;
sumField <- 1;
productField <- 2;
( sum, product )
'''end'''
';
'''begin'''
'''new''' sp;
sp <- sumAndProduct( ( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ) );
'''out''' sp[ sumField ];
'''out''' sp[ productField ]
'''end'''
'''end''' $
=={{header|Euphoria}}==
<
integer sum,prod
Line 805 ⟶ 1,426:
printf(1,"sum is %d\n",sum)
printf(1,"prod is %d\n",prod)</
{{Out}}
Line 814 ⟶ 1,435:
=={{header|F_Sharp|F#}}==
<
let numbers = [| 1..10 |]
let sum = numbers |> Array.sum
let product = numbers |> Array.reduce (*)
</syntaxhighlight>
=={{header|Factor}}==
<
15 120
{ 1 2 3 4 } [ sum ] [ product ] bi
10 24</
sum and product are defined in the sequences vocabulary:
<
: product ( seq -- n ) 1 [ * ] reduce ;</
=={{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}
Line 839 ⟶ 1,460:
"Sum: "s;."
Product: "p;.</
{{out}}
<pre>Sum: 15
Line 846 ⟶ 1,467:
=={{header|Fantom}}==
<
class Main
{
Line 879 ⟶ 1,500:
}
}
</syntaxhighlight>
=={{header|Fermat}}==
<syntaxhighlight lang="fermat">
[a]:=[(1,1,2,3,5,8,13)];
!!Sigma<i=1,7>[a[i]];
!!Prod<i=1,7>[a[i]];
</syntaxhighlight>
{{out}}
<pre>
33
3120
</pre>
=={{header|Forth}}==
<
: reduce ( xt n addr cnt -- n' ) \ where xt ( a b -- n )
cells bounds do i @ third execute cell +loop nip ;
Line 889 ⟶ 1,522:
' + 0 a 5 reduce . \ 15
' * 1 a 5 reduce . \ 120</
=={{header|Fortran}}==
In ISO Fortran 90 and later, use SUM and PRODUCT intrinsics:
<
integer :: sresult, presult
sresult = sum(a)
presult = product(a)</
=={{header|FreeBASIC}}==
<
Dim a(1 To 4) As Integer = {1, 4, 6, 3}
Line 912 ⟶ 1,545:
Print
Print "Press any key to quit"
Sleep</
{{out}}
Line 918 ⟶ 1,551:
Sum = 14
Product = 72
</pre>
=={{header|FreePascal}}==
<syntaxhighlight lang="pascal">
program sumproduct;
var
a:array[0..4] of integer =(1,2,3,4,5);
i:integer;
sum :Cardinal = 0;
prod:Cardinal = 1;
begin
for i in a do
sum :=sum+i;
for i in a do
prod:=prod * i;
writeln('sum: ',sum);
writeln('prod:',prod);
end.
</syntaxhighlight>
{{out}}
<pre>
15
120
</pre>
=={{header|Frink}}==
<
a = [1,2,3,5,7]
sum[a]
product[a]
</syntaxhighlight>
=={{header|FutureBasic}}==
Traditional
<syntaxhighlight lang="futurebasic">
local fn Sum( mutArr as CFMutableArrayRef ) as float
NSInteger i, count, value = 0
float sum = 0
count = fn ArrayCount( mutArr )
for i = 0 to count -1
value = fn NumberIntegerValue( fn ArrayObjectAtIndex( mutArr, i ) )
sum += value
next
end fn = sum
local fn Product( mutArr as CFMutableArrayRef ) as float
NSInteger i, count, value = 0
float prod = 0
count = fn ArrayCount( mutArr )
for i = 0 to count -1
value = fn NumberIntegerValue( fn ArrayObjectAtIndex( mutArr, i ) )
prod *= value
next
end fn = prod
</syntaxhighlight>
Sum of array elements with key-value coding
<syntaxhighlight lang="futurebasic">
local fn NumericalArraySum( array as CFArrayRef ) as CFNumberRef
end fn = fn ObjectValueForKeyPath( array, @"@sum.self" )
printf @"%@", fn NumericalArraySum( @[@0.0454, @-1.3534, @0.345, @65, @-0.345, @1.35] )
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
65.042
</pre>
=={{header|Fōrmulæ}}==
{{FormulaeEntry|page=https://formulae.org/?script=examples/Sum_and_product_of_an_array}}
'''Solution'''
[[File:Fōrmulæ - Sum and product of an array 01.png]]
'''Test cases'''
[[File:Fōrmulæ - Sum and product of an array 02.png]]
[[File:Fōrmulæ - Sum and product of an array 03.png]]
[[File:Fōrmulæ - Sum and product of an array 04.png]]
[[File:Fōrmulæ - Sum and product of an array 05.png]]
[[File:Fōrmulæ - Sum and product of an array 06.png]]
[[File:Fōrmulæ - Sum and product of an array 07.png]]
[[Wp:Empty sum|Empty sum]] and [[Wp:Empty_product|empty product]]:
[[File:Fōrmulæ - Sum and product of an array 08.png]]
[[File:Fōrmulæ - Sum and product of an array 09.png]]
=={{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
Line 942 ⟶ 1,673:
Print "The Product =\t" & iPrd
End</
Output:
<pre>
Line 948 ⟶ 1,679:
The Product = 120
</pre>
=={{header|GAP}}==
<
Sum(v);
Line 964 ⟶ 1,696:
Product(v, n -> 1/n);
# 1/40320</
=={{header|GFA Basic}}==
<
DIM a%(10)
' put some values into the array
Line 984 ⟶ 1,718:
PRINT "Sum is ";sum%
PRINT "Product is ";product%
</syntaxhighlight>
=={{header|Go}}==
;Implementation
<
import "fmt"
Line 999 ⟶ 1,735:
}
fmt.Println(sum, prod)
}</
{{out}}
<pre>
Line 1,005 ⟶ 1,741:
</pre>
;Library
<
import (
Line 1,018 ⟶ 1,754:
fmt.Println("Sum: ", floats.Sum(a))
fmt.Println("Product:", floats.Prod(a))
}</
{{out}}
<pre>
Line 1,027 ⟶ 1,763:
=={{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.
<
[1,2,3,4,5].inject(1) { prod, val -> prod * val }</
You can also combine these operations:
<
[sum: result.sum + value, product: result.product * value]})</
=={{header|GW-BASIC}}==
{{works with|Applesoft BASIC}}
{{works with|BASICA}}
{{works with|Chipmunk Basic|3.6.4}}
{{works with|GW-BASIC}}
{{works with|QBasic}}
{{works with|MSX BASIC}}
<
20 DIM A(5)
30 FOR I = 1 TO 5: READ A(I): NEXT I
Line 1,051 ⟶ 1,791:
77 NEXT I
80 PRINT "The sum is "; S;
90 PRINT " and the product is "; P</
=={{header|Haskell}}==
For lists, ''sum'' and ''product'' are already defined in the Prelude:
<
s = sum values -- the easy way
Line 1,061 ⟶ 1,801:
s1 = foldl (+) 0 values -- the hard way
p1 = foldl (*) 1 values</
To do the same for an array, just convert it lazily to a list:
<
values = listArray (1,10) [1..10]
s = sum . elems $ values
p = product . elems $ values</
Or perhaps:
<
main :: IO ()
main = mapM_ print $ [sum, product] <*> [elems $ listArray (1, 10) [11 .. 20]]</
{{Out}}
<pre>155
Line 1,080 ⟶ 1,820:
=={{header|HicEst}}==
<
sum = SUM(array)
Line 1,089 ⟶ 1,829:
ENDDO
WRITE(ClipBoard, Name) n, sum, product ! n=100; sum=5050; product=9.33262154E157;</
=={{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)
end</
=={{header|IDL}}==
<
print,total(array)
print,product(array)</
=={{header|Inform 7}}==
<
To decide which number is the sum of (N - number) and (M - number) (this is summing):
Line 1,116 ⟶ 1,856:
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.</
=={{header|J}}==
Simple approach:<syntaxhighlight lang="j"> (+/,*/) 2 3 5 7
17 210</syntaxhighlight>
<hr />
Longer exposition:
<syntaxhighlight lang="j">sum =: +/
product =: */</syntaxhighlight>
For example:
<
49
product 1 3 5 7 9 11 13
Line 1,146 ⟶ 1,893:
466 472 462
product"1 a
5.53041e15 9.67411e15 1.93356e15</
=={{header|Java}}==
{{works with|Java|1.5+}}
<
{
public static void main(final String[] args)
Line 1,163 ⟶ 1,910:
}
}
}</
{{works with|Java|1.8+}}
<
public class SumProd
Line 1,177 ⟶ 1,924:
System.out.printf("product = %d\n", Arrays.stream(arg).reduce(1, (a, b) -> a * b));
}
}</
{{out}}
<pre>
Line 1,187 ⟶ 1,934:
=={{header|JavaScript}}==
===ES5===
<
sum = 0,
prod = 1,
Line 1,195 ⟶ 1,942:
prod *= array[i];
}
alert(sum + ' ' + prod);</
{{Works with|Javascript|1.8}}
Where supported, the reduce method can also be used:
<
sum = array.reduce(function (a, b) {
return a + b;
Line 1,207 ⟶ 1,954:
return a * b;
}, 1);
alert(sum + ' ' + prod);</
===ES6===
<
'use strict';
Line 1,228 ⟶ 1,975:
.map(f => f([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))
);
})();</
{{Out}}
Line 1,235 ⟶ 1,982:
3628800
]</pre>
=={{header|Joy}}==
<syntaxhighlight lang="joy">[1 2 3 4 5] 0 [+] fold.</syntaxhighlight>
<syntaxhighlight lang="joy">[1 2 3 4 5] 1 [*] fold.</syntaxhighlight>
=={{header|jq}}==
The builtin filter, add/0, computes the sum of an array:
<
# => 18</
<
# => 18</
An efficient companion filter for computing the product of the items in an array can be defined as follows:
<
Examples:
<
# => 192</
10!
<
# =>3628800</
=={{header|Julia}}==
<
18
Line 1,262 ⟶ 2,013:
julia> prod([4,6,8])
192</
=={{header|K}}==
<
product: {*/}x
a: 1 3 5 7 9 11 13
Line 1,271 ⟶ 2,022:
49
product a
135135</
It is easy to see the relationship of K to J here.
=={{header|Kotlin}}==
<
fun main(args: Array<String>) {
Line 1,285 ⟶ 2,036:
val product = a.fold(1) { acc, i -> acc * i }
println("Product is $product")
}</
{{out}}
Line 1,292 ⟶ 2,043:
Sum is 40
Product is 6600
</pre>
=={{header|Lambdatalk}}==
<syntaxhighlight 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
</syntaxhighlight>
=={{header|Lang}}==
<syntaxhighlight lang="lang">
&values = fn.arrayGenerateFrom(fn.inc, 5)
fn.println(fn.arrayReduce(&values, 0, fn.add))
# Output: 15
fn.println(fn.arrayReduce(&values, 1, fn.mul))
# Output: 120
</syntaxhighlight>
=={{header|Lang5}}==
<
'+ reduce
'* reduce</
=={{header|langur}}==
<syntaxhighlight lang="langur">val .list = series 19
writeln " list: ", .list
writeln " sum: ", fold fn{+}, .list
writeln "product: ", fold fn{*}, .list
</syntaxhighlight>
{{out}}
<pre> list: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
sum: 190
product: 121645100408832000</pre>
=={{header|Lasso}}==
<
// sum of array elements
'Sum: '
Line 1,312 ⟶ 2,105:
local(product = 1)
with n in #x do => { #product *= #n }
#product</
{{out}}
<pre>Sum: 55
Line 1,318 ⟶ 2,111:
=={{header|Liberty BASIC}}==
<
For i = 0 To 19
Line 1,332 ⟶ 2,125:
Print "Sum is " + str$(sum)
Print "Product is " + str$(product)</
=={{header|Lingo}}==
<
res = 0
repeat with v in intList
Line 1,349 ⟶ 2,142:
end repeat
return res
end</
=={{header|LiveCode}}==
<
put "1,2,3,4" into nums
split nums using comma
Line 1,366 ⟶ 2,159:
end if
end repeat
answer prodnums</
=={{header|Logo}}==
<
print apply "product arraytolist {1 2 3 4 5}</
=={{header|LOLCODE}}==
<syntaxhighlight lang="lolcode">HAI 1.2
I HAS A Nums ITZ A BUKKIT
Nums HAS A Length ITZ 0
Nums HAS A SRS Nums'Z Length ITZ 1
Nums'Z Length R SUM OF Nums'Z Length AN 1
Nums HAS A SRS Nums'Z Length ITZ 2
Nums'Z Length R SUM OF Nums'Z Length AN 1
Nums HAS A SRS Nums'Z Length ITZ 3
Nums'Z Length R SUM OF Nums'Z Length AN 1
Nums HAS A SRS Nums'Z Length ITZ 5
Nums'Z Length R SUM OF Nums'Z Length AN 1
Nums HAS A SRS Nums'Z Length ITZ 7
Nums'Z Length R SUM OF Nums'Z Length AN 1
I HAS A Added ITZ 0
I HAS A Timesed ITZ 1
I HAS A Num
IM IN YR Loop UPPIN YR Index WILE DIFFRINT Index AN Nums'Z Length
Num R Nums'Z SRS Index
Added R SUM OF Added AN Num
Timesed R PRODUKT OF Timesed AN Num
IM OUTTA YR Loop
VISIBLE "Sum = " !
VISIBLE Added
VISIBLE "Product = " !
VISIBLE Timesed
KTHXBYE</syntaxhighlight>
{{Out}}
<pre>Sum = 18
Product = 210</pre>
=={{header|Lua}}==
<
function sumf(a, ...) return a and a + sumf(...) or 0 end
function sumt(t) return sumf(unpack(t)) end
Line 1,380 ⟶ 2,206:
print(sumt{1, 2, 3, 4, 5})
print(prodt{1, 2, 3, 4, 5})</
<
function table.sum(arr, length)
--same as if <> then <> else <>
Line 1,389 ⟶ 2,215:
function table.product(arr, length)
return length == 1 and arr[1] or arr[length] * table.
end
Line 1,395 ⟶ 2,221:
print(table.sum(t,#t))
print(table.product(t,3))
</syntaxhighlight>
=={{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
end</
=={{header|M2000 Interpreter}}==
<syntaxhighlight 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
</syntaxhighlight>
=={{header|Maple}}==
<
add(a);
mul(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]
Line 1,420 ⟶ 2,260:
a // Total
Sum[a[[i]], {i, 1, Length[a]}]
Sum[i, {i, 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]}]
Product[i, {i, a}]</
all give 120.
Line 1,433 ⟶ 2,273:
Sample Usage:
<
array =
Line 1,467 ⟶ 2,307:
6
120
504</
=={{header|Maxima}}==
<
36
lreduce("*", [1, 2, 3, 4, 5, 6, 7, 8]);
40320</
=={{header|MAXScript}}==
<
sum = 0
for i in arr do sum += i
product = 1
for i in arr do product *= i</
=={{header|min}}==
{{works with|min|0.19.3}}
<syntaxhighlight lang="min">(1 2 3 4 5) ((sum) (1 '* reduce)) cleave
"Sum: $1\nProduct: $2" get-stack % puts</syntaxhighlight>
{{out}}
<pre>
Sum: 15
Product: 120
</pre>
=={{header|МК-61/52}}==
<syntaxhighlight lang="text">^ 1 ПE + П0 КИП0 x#0 18 ^ ИПD
+ ПD <-> ИПE * ПE БП 05 С/П</
''Instruction'': РX - array length, Р1:РC - array, РD and РE - sum and product of an array.
=={{header|Modula-3}}==
<
FROM IO IMPORT Put;
Line 1,508 ⟶ 2,357:
Put("Sum of array: " & Int(sum) & "\n");
Put("Product of array: " & Int(prod) & "\n");
END Sumprod.</
{{Out}}
<pre>Sum of array: 15
Line 1,514 ⟶ 2,363:
=={{header|MUMPS}}==
<syntaxhighlight lang="mumps">
SUMPROD(A)
;Compute the sum and product of the numbers in the array A
Line 1,526 ⟶ 2,375:
WRITE !,"The product of the array is "_PROD
KILL SUM,PROD,POS
QUIT</
Example: <pre>
USER>SET C(-1)=2,C("A")=3,C(42)=1,C(0)=7
Line 1,547 ⟶ 2,396:
=={{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;
Line 1,576 ⟶ 2,425:
WriteLine("Sum is: {0}\tProduct is: {1}", suml, proda);
}
}</
=={{header|NetRexx}}==
<
options replace format comments java crossref savelog symbols binary
Line 1,603 ⟶ 2,452:
return
</syntaxhighlight>
{{Out}}
<pre>
Line 1,612 ⟶ 2,461:
=={{header|NewLISP}}==
<
(apply + a)
(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
= 6</
array notation
<syntaxhighlight lang
grouped notation
<
= 6
* (1 2 3)
= 6</
(All these notations are equivalent)
=={{header|Nim}}==
<
var sum, product: int
Line 1,640 ⟶ 2,489:
for x in xs:
sum += x
product *= x</
Or functionally:
<
let
xs =
sum = xs.foldl(a + b)
product = xs.foldl(a * b)</
Or using a math function:
<syntaxhighlight lang="nim">import math
let numbers = [1, 5, 4]
let total = sum(numbers)
var product = 1
for n in numbers:
product *= n</syntaxhighlight>
=={{header|Objeck}}==
<
sum := 0;
prod := 1;
Line 1,659 ⟶ 2,518:
prod *= arg[i];
};
</syntaxhighlight>
=={{header|Objective-C}}==
{{works with|GCC|4.0.1 (apple)}}
Sum:
<
{
int i, sum, value;
Line 1,676 ⟶ 2,535:
return suml;
}</
Product:
<
{
int i, prod, value;
Line 1,690 ⟶ 2,549:
return suml;
}</
=={{header|OCaml}}==
===Arrays===
<
let a = [| 1; 2; 3; 4; 5 |];;
Array.fold_left (+) 0 a;;
Line 1,701 ⟶ 2,560:
let a = [| 1.0; 2.0; 3.0; 4.0; 5.0 |];;
Array.fold_left (+.) 0.0 a;;
Array.fold_left ( *.) 1.0 a;;</
===Lists===
<
let x = [1; 2; 3; 4; 5];;
List.fold_left (+) 0 x;;
Line 1,710 ⟶ 2,569:
let x = [1.0; 2.0; 3.0; 4.0; 5.0];;
List.fold_left (+.) 0.0 x;;
List.fold_left ( *.) 1.0 x;;</
=={{header|Octave}}==
<
b = [ 10, 20, 30, 40, 50, 60 ];
vsum = a + b;
vprod = a .* b;</
=={{header|Oforth}}==
<
[1, 3, 5, 7, 9 ] prod println</
{{out}}
Line 1,728 ⟶ 2,587:
945
</pre>
=={{header|Ol}}==
<syntaxhighlight lang="scheme">
(print (fold + 0 '(1 2 3 4 5)))
(print (fold * 1 '(1 2 3 4 5)))
</syntaxhighlight>
=={{header|ooRexx}}==
{{trans|REXX}}
<
do i=1 To 20
a[i]=i
Line 1,752 ⟶ 2,617:
prod*=self[i]
End
Return prod</
{{out}}
<pre>1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20
sum=210
product=2432902008176640000</pre>
=={{header|Oz}}==
Calculations like this are typically done on lists, not on arrays:
<
Xs = [1 2 3 4 5]
Sum = {FoldL Xs Number.'+' 0}
Line 1,766 ⟶ 2,631:
in
{Show Sum}
{Show Product}</
If you are actually working with arrays, a more imperative approach seems natural:
<
Arr = {Array.new 1 3 0}
Sum = {NewCell 0}
Line 1,780 ⟶ 2,645:
Sum := @Sum + Arr.I
end
{Show @Sum}</
=={{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+}}
Line 1,798 ⟶ 2,663:
=={{header|Perl}}==
<
my ( $sum, $prod ) = ( 0, 1 );
$sum += $_ foreach @list;
$prod *= $_ 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
say "Product: ", product(@list);</
{{out}}
<pre>Sum: 45
Product: 362880</pre>
=={{header|Phix}}==
{{libheader|Phix/basics}}
<!--<syntaxhighlight lang="phix">-->
<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>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Line 1,832 ⟶ 2,690:
prod is 120
</pre>
=={{header|Phixmonti}}==
<syntaxhighlight 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</syntaxhighlight>
=={{header|PHP}}==
<
echo array_sum($array);
echo array_product($array);</
=={{header|Picat}}==
<syntaxhighlight lang="picat">go =>
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).</syntaxhighlight>
{{out}}
<pre>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</pre>
=={{header|PicoLisp}}==
<
(cons
(apply + Data)
(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));
put skip list (prod(A));</
=={{header|Plain English}}==
<syntaxhighlight 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.</syntaxhighlight>
{{out}}
<pre>
Sum: 55
Product: 3628800
</pre>
=={{header|Pop11}}==
Simple loop:
<
for i from 1 to length(ar) do
ar(i) + sum -> sum;
ar(i) * prod -> prod;
endfor;</
One can alternatively use second order iterator:
<
appdata(ar, procedure(x); x + sum -> sum; endprocedure);
appdata(ar, procedure(x); x * prod -> prod; endprocedure);</
=={{header|PostScript}}==
<syntaxhighlight lang="text">
/sumandproduct
{
Line 1,887 ⟶ 2,850:
prod ==
}def
</syntaxhighlight>
{{libheader|initlib}}
<
% sum
[1 1 1 1 1] 0 {add} fold
Line 1,896 ⟶ 2,859:
[1 1 1 1 1] 1 {mul} fold
</syntaxhighlight>
=={{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
Line 1,914 ⟶ 2,877:
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
Line 1,924 ⟶ 2,887:
$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) {
Line 1,941 ⟶ 2,904:
$ret | Add-Member NoteProperty Product $prod
return $ret
}</
{{Out}}
<pre>PS> Get-SumAndProduct 5,9,7,2,3,8,4
Line 1,950 ⟶ 2,913:
=={{header|Prolog}}==
<
sum([H|T],X) :- sum(T,Y), X is H + Y.
product([],1).
product([H|T],X) :- product(T,Y), X is H * X.</
test
Line 1,963 ⟶ 2,926:
Using fold
<
add(A,B,R):-
R is A + B.
Line 1,987 ⟶ 2,950:
Prod = 24 .
</syntaxhighlight>
=={{header|PureBasic}}==
<
Define a, sum=0, prod=1
Line 2,003 ⟶ 2,966:
Debug "The sum is " + Str(sum) ; Present the results
Debug "Product is " + Str(prod)</
=={{header|Python}}==
{{works with|Python|2.5}}
<
total = sum(numbers)
product = 1
for i in numbers:
product *= i</
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
product = reduce(mul, numbers, 1)</
{{libheader|
<
numbers = r_[1:4]
total = numbers.sum()
product = numbers.prod()</
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}}
<
total = math.fsum(floats)</
=={{header|QBasic}}==
{{works with|QBasic}}
{{works with|QuickBasic}}
{{works with|True BASIC}}
<syntaxhighlight 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</syntaxhighlight>
=={{header|Quackery}}==
<syntaxhighlight lang="quackery">[ 0 swap witheach + ] is sum ( [ --> n )
[ 1 swap witheach * ] is product ( [ --> n )</syntaxhighlight>
In the shell (i.e. Quackery REPL):
<syntaxhighlight lang="quackery">
/O> ' [ 1 2 3 4 5 ] sum echo cr
... ' [ 1 2 3 4 5 ] product echo
...
15
120
Stack empty.</syntaxhighlight>
=={{header|R}}==
<
product <- prod(1:5)</
=={{header|Racket}}==
<
(for/sum ([x #(3 1 4 1 5 9)]) x)
(for/product ([x #(3 1 4 1 5 9)]) x)</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" line>my @ary = 1, 5, 10, 100;
say 'Sum: ', [+] @ary;
say 'Product: ', [*] @ary;</syntaxhighlight>
=={{header|Rapira}}==
<syntaxhighlight 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</syntaxhighlight>
=={{header|Raven}}==
<
1 [ 1 2 3 ] each *</
=={{header|REBOL}}==
<
Title: "Sum and Product"
URL: http://rosettacode.org/wiki/Sum_and_product_of_array
]
Line 2,085 ⟶ 3,101:
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]]</
{{Out}}
Line 2,095 ⟶ 3,111:
ok [55 = rsum [1 2 3 4 5 6 7 8 9 10]]
ok [3628800 = rproduct [1 2 3 4 5 6 7 8 9 10]]</pre>
=={{header|Red}}==
<syntaxhighlight 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]</syntaxhighlight>
{{out}}
<pre>
1 2 3 4 5 6 7 8 9 10
Sum: 55
Product: 3628800
</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.*/
Line 2,113 ⟶ 3,155:
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. */</
'''output''' using the default input of: <tt> 20 </tt>
<pre>
Line 2,121 ⟶ 3,163:
=={{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
</syntaxhighlight>
=={{header|RPL}}==
{{works with|Halcyon Calc|4.2.7}}
≪ DUP
DUP 1 CON DOT
SWAP ARRY→ LIST→ SWAP 1 - START * NEXT
≫
'SUMPR' STO
[ 2 4 8 -5 ] SUMPR
{{out}}
<pre>
2: 9
1: -320
</pre>
=={{header|Ruby}}==
<
p sum = arr.inject(0) { |sum, item| sum + item }
# => 15
p product = arr.inject(1) { |prod, element| prod * element }
# => 120</
{{works with|Ruby|1.8.7}}
<
p sum = arr.inject(0, :+) #=> 15
p product = arr.inject(1, :*) #=> 120
Line 2,143 ⟶ 3,200:
# then the first element of collection is used as the initial value of memo.
p sum = arr.inject(:+) #=> 15
p product = arr.inject(:*) #=> 120</
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
p arr.inject(:*) #=> nil</
Enumerable#reduce is the alias of Enumerable#inject.
{{works with|Ruby|1.9.3}}
<
p sum = arr.sum #=> 15
p [].sum #=> 0</
=={{header|Run BASIC}}==
<
for i = 1 To 100
array(i) = rnd(0) * 100
Line 2,172 ⟶ 3,229:
Print " Sum is ";sum
Print "Product is ";product</
=={{header|Rust}}==
<
fn main() {
Line 2,190 ⟶ 3,247:
println!("the sum is {} and the product is {}", sum, product);
}
</syntaxhighlight>
=={{header|S-lang}}==
<
The sum of array elements is handled by an intrinsic.
[note: print is slsh-specific; if not available, use printf().]
<syntaxhighlight lang
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.
Line 2,211 ⟶ 3,268:
prod *= ();
print(prod);</
=={{header|SAS}}==
<
array a{*} a1-a100;
do i=1 to 100;
Line 2,221 ⟶ 3,278:
b=sum(of a{*});
put b c;
run;</
=={{header|Sather}}==
<
main is
a :ARRAY{INT} := |10, 5, 5, 20, 60, 100|;
Line 2,233 ⟶ 3,290:
#OUT + sum + " " + prod + "\n";
end;
end;</
=={{header|Scala}}==
<
val sum = seq.foldLeft(0)(_ + _)
val product = seq.foldLeft(1)(_ * _)</
Or even shorter:
<
val product = seq.product</
Works with all data types for which a Numeric implicit is available.
=={{header|Scheme}}==
<
(apply * '(1 2 3 4 5))</
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
Line 2,256 ⟶ 3,313:
(reduce + 0 '(1 2 3 4 5)) ;; 0 is unit for +
(reduce * 1 '(1 2 3 4 5)) ;; 1 is unit for *</
=={{header|Seed7}}==
<
result
var integer: sum is 0;
Line 2,278 ⟶ 3,336:
prod *:= value;
end for;
end func;</
Call these functions with:
writeln(sumArray([](1, 2, 3, 4, 5)));
Line 2,284 ⟶ 3,342:
=={{header|SETL}}==
<
print(+/ numbers, */ numbers);</
=> <code>45 362880</code>
Line 2,291 ⟶ 3,349:
=={{header|Sidef}}==
Using built-in methods:
<
say ary.sum; # => 15
say ary.prod; # => 120</
Alternatively, using hyper-operators:
<
say ary«+»; # => 15
say ary«*»; # => 120</
=={{header|Slate}}==
<
#(1 2 3 4 5) reduce: [:product :number | product * number]</
Shorthand for the above with a macro:
<
#(1 2 3 4 5) reduce: #* `er</
=={{header|Smalltalk}}==
<
#(1 2 3 4 5) inject: 1 into: [:product :number | product * number]</
Some implementation also provide a ''fold:'' message:
<
#(1 2 3 4 5) fold: [:product :number | product * number]</
=={{header|SNOBOL4}}==
<
* read the integer from the std. input
init_tab t<x = x + 1> = trim(input) :s(init_tab)
Line 2,325 ⟶ 3,385:
out output = "Sum: " sum
output = "Prod: " product
end</
Input
Line 2,338 ⟶ 3,398:
Prod: 120
</pre>
=={{header|SparForte}}==
As a structured script.
<syntaxhighlight lang="ada">#!/usr/local/bin/spar
pragma annotate( summary, "arraysum" )
@( description, "Compute the sum and product of an array of integers." )
@( see_also, "http://rosettacode.org/wiki/Sum_and_product_of_an_array" )
@( author, "Ken O. Burtch" );
pragma license( unrestricted );
pragma restriction( no_external_commands );
procedure arraysum is
type int_array is array(1..10) of integer;
myarr : int_array := (1,2,3,4,5,6,7,8,9,10 );
begin
? stats.sum( myarr );
declare
product : integer := 1;
begin
for i in arrays.first( myarr )..arrays.last( myarr ) loop
product := @ * myarr(i);
end loop;
? product;
end;
end arraysum;</syntaxhighlight>
=={{header|Sparkling}}==
<
= 15
spn:2> reduce({ 1, 2, 3, 4, 5 }, 1, function(x, y) { return x * y; })
= 120</
=={{header|Standard ML}}==
===Arrays===
<
val a = Array.fromList [1, 2, 3, 4, 5];
Array.foldl op+ 0 a;
Line 2,354 ⟶ 3,440:
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;</
===Lists===
<
val x = [1, 2, 3, 4, 5];
foldl op+ 0 x;
Line 2,363 ⟶ 3,449:
val x = [1.0, 2.0, 3.0, 4.0, 5.0];
foldl op+ 0.0 x;
foldl op* 1.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:
<syntaxhighlight lang="stata">a = 1,-2,-3,-4,5
sum(a)
-3
(-1)^mod(sum(a:<0),2)*exp(sum(log(abs(a))))
-120</syntaxhighlight>
=={{header|Swift}}==
<
println(a.reduce(0, +)) // prints 15
println(a.reduce(1, *)) // prints 120
println(reduce(a, 0, +)) // prints 15
println(reduce(a, 1, *)) // prints 120</
=={{header|Tcl}}==
<
set sum [expr [join $arr +]]
set prod [expr [join $arr *]]</
{{works with|Tcl|8.5}}
<
set sum [tcl::mathop::+ {*}$arr]
set prod [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₁)
3628800</
=={{header|Toka}}==
<
212 1 foo array.put
Line 2,403 ⟶ 3,498:
( product )
reset 1 4 0 [ i foo array.get * ] countedLoop .</
=={{header|Trith}}==
<
<
=={{header|True BASIC}}==
{{works with|QBasic}}
<syntaxhighlight 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</syntaxhighlight>
=={{header|TUSCRIPT}}==
<
$$ MODE TUSCRIPT
list="1'2'3'4'5"
Line 2,420 ⟶ 3,536:
ENDLOOP
PRINT "product: ",product
</syntaxhighlight>
{{Out}}
<pre>
Line 2,431 ⟶ 3,547:
From an internal variable, $IFS delimited:
<
prod=1
list="1 2 3"
Line 2,437 ⟶ 3,553:
do sum="$(($sum + $n))"; prod="$(($prod * $n))"
done
echo $sum $prod</
From the argument list (ARGV):
<
prod=1
for n
do sum="$(($sum + $n))"; prod="$(($prod * $n))"
done
echo $sum $prod</
From STDIN, one integer per line:
<
prod=1
while read n
do sum="$(($sum + $n))"; prod="$(($prod * $n))"
done
echo $sum $prod</
{{works with|
{{works with|Korn Shell}}
{{works with|Zsh}}
Using an actual array variable:
<
for
done
printf '%d\t%d\n' "$sum" "$prod"
</syntaxhighlight>
{{Out}}
<pre>42 800</pre>
=={{header|UnixPipes}}==
Uses [[ksh93]]-style process substitution.
{{works with|bash}}
<
(read B; res=$1; test -n "$B" && expr $res \* $B || echo $res)
}
Line 2,484 ⟶ 3,606:
(echo 3; echo 1; echo 4;echo 1;echo 5;echo 9) |
tee >(fold sum) >(fold prod) > /dev/null</
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.
Line 2,490 ⟶ 3,612:
=={{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
Line 2,497 ⟶ 3,619:
# outputs 3.95961079808E11
out (* stream) endl console</
=={{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
sp = ^(sum:-0,product:-1) <62,43,46,40,29,55,51,82,59,92,48,73,93,35,42,25></
{{Out}}
Line 2,511 ⟶ 3,633:
=={{header|V}}==
<
{{Out|Using it}}
<
=
product=15
sum=120</
=={{header|Vala}}==
<syntaxhighlight lang="vala">void main() {
int sum = 0, prod = 1;
foreach (int val in data) {
sum += val;
prod *= val;
}
print(@"sum: $(sum)\nproduct: $(prod)");
}</syntaxhighlight>
{{out}}
<pre>sum: 10
product: 24</pre>
=={{header|VBA}}==
Assumes Excel is used.
<syntaxhighlight 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</syntaxhighlight>{{Out}}
<pre>sum : 55
product : 3628800</pre>
=={{header|VBScript}}==
<syntaxhighlight lang="vb">Function sum_and_product(arr)
sum = 0
product = 1
Line 2,550 ⟶ 3,682:
myarray = Array(1,2,3,4,5,6)
sum_and_product(myarray)
</syntaxhighlight>
{{Out}}
Line 2,556 ⟶ 3,688:
Sum: 21
Product: 720
</pre>
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<syntaxhighlight 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</syntaxhighlight>
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">
fn main() {
values := [1, 2, 3, 4, 5]
mut sum, mut prod := 0, 1
for val in values {
sum += val
prod *= val
}
println("sum: $sum\nproduct: $prod")
}
</syntaxhighlight>
{{out}}
<pre>
sum: 15
product: 120
</pre>
=={{header|Wart}}==
<
(list (+ @nums) (* @nums))</
=={{header|WDTE}}==
<syntaxhighlight 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 *;</syntaxhighlight>
=={{header|Wortel}}==
<
@prod [1 2 3 4] ; returns 24</
=={{header|Wren}}==
{{libheader|Wren-math}}
<syntaxhighlight lang="wren">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))")</syntaxhighlight>
{{out}}
<pre>
Array : [7, 10, 2, 4, 6, 1, 8, 3, 9, 5]
Sum : 55
Product : 3628800
</pre>
=={{header|XPL0}}==
<
func SumProd(A, L);
Line 2,578 ⟶ 3,762:
]; \SumSq
SumProd([1,2,3,4,5,6,7,8,9,10], 10)</
{{Out}}
Line 2,589 ⟶ 3,773:
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" />
Line 2,624 ⟶ 3,808:
</xsl:call-template>
</xsl:template>
</xsl:stylesheet></
=={{header|Yabasic}}==
{{trans|QBasic}}
<syntaxhighlight 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</syntaxhighlight>
=={{header|Zig}}==
<syntaxhighlight lang="zig">const print = @import("std").debug.print;
pub fn main() void {
const numbers = [_]u8{ 1, 2, 3, 4, 5 };
var sum: u8 = 0;
var product: u8 = 1;
for (numbers) |number| {
product *= number;
sum += number;
}
print("{} {}\n", .{ product, sum });
}</syntaxhighlight>
=={{header|zkl}}==
{{trans|Clojure}}
<
fcn product(vals){vals.reduce('*,1)}</
<pre>
sum(T(1,2,3,4)) //-->10
product(T(1,2,3,4)) //-->24
</pre>
=={{header|Zoea}}==
<syntaxhighlight lang="zoea">
program: sum_and_product
case: 1
input: [3,5]
output: [8,15]
case: 2
input: [2,3,4]
output: [9,24]
</syntaxhighlight>
=={{header|Zoea Visual}}==
[http://zoea.co.uk/examples/zv-rc/Sum_and_product.png Sum and product of an array]
|