Sum and product of an array: Difference between revisions
→{{header|langur}}
Langurmonkey (talk | contribs) |
|||
(136 intermediate revisions by 72 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}}==
<syntaxhighlight 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</syntaxhighlight>
{{out}}
<pre>
55 3628800
</pre>
=={{header|4D}}==
<
For ($i;1;5)
APPEND TO ARRAY($list;$i)
Line 18 ⟶ 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 31 ⟶ 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 55 ⟶ 289:
}
}
}</
=={{header|Ada}}==
<
array : Int_Array := (1,2,3,4,5,6,7,8,9,10);
Line 64 ⟶ 298:
for I in array'range loop
Sum := Sum + array(I);
end loop;</
Define the product function
<
Prod : Integer := 1;
begin
Line 73 ⟶ 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 97 ⟶ 329:
integer sum, product;
compute(sum, product,
return 0;
}</
{{out}}
<pre>77
Line 111 ⟶ 340:
=={{header|ALGOL 68}}==
<
INT default upb := 3;
MODE INTARRAY = [default upb]INT;
Line 131 ⟶ 360:
) # int product # ;
printf(($" Sum: "g(0)$,sum,$", Product:"g(0)";"l$,int product(array)))
)</
{{Out}}
<pre>
Line 138 ⟶ 367:
=={{header|ALGOL W}}==
<
% computes the sum and product of intArray %
Line 171 ⟶ 400:
write( sum, product );
end
end.</
{{out}}
Line 180 ⟶ 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 197 ⟶ 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''':
<syntaxhighlight lang="applescript">on summed(a, b)
a + b
end summed
Line 233 ⟶ 461:
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</syntaxhighlight>
{{Out}}
<syntaxhighlight lang="applescript">{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {sum:55}, {product:3628800}}</syntaxhighlight>
=={{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 249 ⟶ 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 258 ⟶ 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 273 ⟶ 723:
Result:
41
30030</
Perhaps better Babel:
<
{ [2 3 5 7 11 13]
ar2ls dup cp
Line 295 ⟶ 745:
{ * }
{ depth 1 > }
do_while } nest }</
The nest operator creates a kind of argument-passing context -
Line 308 ⟶ 758:
=={{header|BASIC}}==
{{works with|FreeBASIC}}
<
dim sum as integer = 0
Line 315 ⟶ 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 338 ⟶ 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 354 ⟶ 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 379 ⟶ 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 394 ⟶ 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 421 ⟶ 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 450 ⟶ 1,012:
cout << sum(aflo,4) << " " << prod(aflo,4) << endl;
return 0;
}</
=={{header|Chef}}==
<
This recipe sums N given numbers.
Line 476 ⟶ 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 514 ⟶ 1,099:
GOBACK
.</
=={{header|CoffeeScript}}==
<
sum = (array) ->
array.reduce (x, y) -> x + y
Line 523 ⟶ 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 562 ⟶ 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 577 ⟶ 1,194:
writeln("Sum: ", r[0]);
writeln("Product: ", r[1]);
}</
=={{header|dc}}==
<syntaxhighlight lang="dc">1 3 5 7 9 11 13 0ss1sp[dls+sslp*spz0!=a]dsax[Sum: ]Plsp[Product: ]Plpp
Sum: 49
Product: 135135</syntaxhighlight>
=={{header|Delphi}}==
<
{$APPTYPE CONSOLE}
Line 600 ⟶ 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 650 ⟶ 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 := new int[]{1, 2, 3, 4, 5 };
var sum := list.summarize(new Integer());
var product := list.accumulate(new Integer(1), (var,val => var * val));
}</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 686 ⟶ 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 737 ⟶ 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 753 ⟶ 1,426:
printf(1,"sum is %d\n",sum)
printf(1,"prod is %d\n",prod)</
{{Out}}
Line 762 ⟶ 1,435:
=={{header|F_Sharp|F#}}==
<
let numbers = [| 1..10 |]
let sum = numbers |> Array.sum
let product = numbers |> Array.
</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 787 ⟶ 1,460:
"Sum: "s;."
Product: "p;.</
{{out}}
<pre>Sum: 15
Line 794 ⟶ 1,467:
=={{header|Fantom}}==
<
class Main
{
Line 827 ⟶ 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 837 ⟶ 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}}==
<syntaxhighlight 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</syntaxhighlight>
{{out}}
<pre>
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]'''
<syntaxhighlight 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]
Next
Print "The Sum =\t" & iSum
Print "The Product =\t" & iPrd
End</syntaxhighlight>
Output:
<pre>
The Sum = 15
The Product = 120
</pre>
=={{header|GAP}}==
<
Sum(v);
Line 869 ⟶ 1,696:
Product(v, n -> 1/n);
# 1/40320</
=={{header|GFA Basic}}==
<syntaxhighlight 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%
</syntaxhighlight>
=={{header|Go}}==
;Implementation
<
import "fmt"
Line 884 ⟶ 1,735:
}
fmt.Println(sum, prod)
}</
{{out}}
<pre>
Line 890 ⟶ 1,741:
</pre>
;Library
<
import (
Line 903 ⟶ 1,754:
fmt.Println("Sum: ", floats.Sum(a))
fmt.Println("Product:", floats.Prod(a))
}</
{{out}}
<pre>
Line 912 ⟶ 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 936 ⟶ 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
p = product values
To do the same for an array, just convert it lazily to a list:
<
values = listArray (1,10) [1..10]
s = sum . elems $ values
p = product . elems $ values</
Or perhaps:
<syntaxhighlight lang="haskell">import Data.Array (listArray, elems)
main :: IO ()
main = mapM_ print $ [sum, product] <*> [elems $ listArray (1, 10) [11 .. 20]]</syntaxhighlight>
{{Out}}
<pre>155
670442572800</pre>
=={{header|HicEst}}==
<
sum = SUM(array)
Line 965 ⟶ 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 992 ⟶ 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,022 ⟶ 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,039 ⟶ 1,910:
}
}
}</
{{works with|Java|1.8+}}
<
public class SumProd
Line 1,053 ⟶ 1,924:
System.out.printf("product = %d\n", Arrays.stream(arg).reduce(1, (a, b) -> a * b));
}
}</
{{out}}
<pre>
Line 1,062 ⟶ 1,933:
=={{header|JavaScript}}==
===ES5===
<syntaxhighlight lang="javascript">var array = [1, 2, 3, 4, 5],
sum = 0,
prod = 1,
Line 1,070 ⟶ 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,082 ⟶ 1,954:
return a * b;
}, 1);
alert(sum + ' ' + prod);</
===ES6===
<syntaxhighlight 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]))
);
})();</syntaxhighlight>
{{Out}}
<pre>[
55,
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,110 ⟶ 2,013:
julia> prod([4,6,8])
192</
=={{header|K}}==
<syntaxhighlight lang="k"> sum: {+/}x
product: {*/}x
a: 1 3 5 7 9 11 13
sum a
49
product a
135135</syntaxhighlight>
It is easy to see the relationship of K to J here.
=={{header|Kotlin}}==
<syntaxhighlight 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")
}</syntaxhighlight>
{{out}}
<pre>
Array contains : [1, 5, 8, 11, 15]
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,130 ⟶ 2,105:
local(product = 1)
with n in #x do => { #product *= #n }
#product</
{{out}}
<pre>Sum: 55
Line 1,136 ⟶ 2,111:
=={{header|Liberty BASIC}}==
<
For i = 0 To 19
Line 1,150 ⟶ 2,125:
Print "Sum is " + str$(sum)
Print "Product is " + str$(product)</
=={{header|Lingo}}==
<syntaxhighlight 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</syntaxhighlight>
=={{header|LiveCode}}==
<
put "1,2,3,4" into nums
split nums using comma
Line 1,167 ⟶ 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,181 ⟶ 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,190 ⟶ 2,215:
function table.product(arr, length)
return length == 1 and arr[1] or arr[length] * table.
end
Line 1,196 ⟶ 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}}==
<syntaxhighlight lang="maple">a := Array([1, 2, 3, 4, 5, 6]);
add(a);
mul(a);</syntaxhighlight>
=={{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,215 ⟶ 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,228 ⟶ 2,273:
Sample Usage:
<
array =
Line 1,262 ⟶ 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,303 ⟶ 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,309 ⟶ 2,363:
=={{header|MUMPS}}==
<syntaxhighlight lang="mumps">
SUMPROD(A)
;Compute the sum and product of the numbers in the array A
Line 1,321 ⟶ 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,342 ⟶ 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,371 ⟶ 2,425:
WriteLine("Sum is: {0}\tProduct is: {1}", suml, proda);
}
}</
=={{header|NetRexx}}==
<
options replace format comments java crossref savelog symbols binary
Line 1,398 ⟶ 2,452:
return
</syntaxhighlight>
{{Out}}
<pre>
Line 1,407 ⟶ 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,435 ⟶ 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,454 ⟶ 2,518:
prod *= arg[i];
};
</syntaxhighlight>
=={{header|Objective-C}}==
{{works with|GCC|4.0.1 (apple)}}
Sum:
<
{
int i, sum, value;
Line 1,471 ⟶ 2,535:
return suml;
}</
Product:
<
{
int i, prod, value;
Line 1,485 ⟶ 2,549:
return suml;
}</
=={{header|OCaml}}==
===Arrays===
<
let a = [| 1; 2; 3; 4; 5 |];;
Array.fold_left (+) 0 a;;
Line 1,496 ⟶ 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,505 ⟶ 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,523 ⟶ 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,547 ⟶ 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,561 ⟶ 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,575 ⟶ 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+}}
In 2.10.0 the function <code>vecprod</code> was introduced as well. Like <code>factorback</code> it gives the product of the elements of an array but unlike <code>factorback</code> it doesn't handle factorization matrices.
=={{header|Pascal}}==
Line 1,590 ⟶ 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,624 ⟶ 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,679 ⟶ 2,850:
prod ==
}def
</syntaxhighlight>
{{libheader|initlib}}
<
% sum
[1 1 1 1 1] 0 {add} fold
Line 1,688 ⟶ 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,706 ⟶ 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,716 ⟶ 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,733 ⟶ 2,904:
$ret | Add-Member NoteProperty Product $prod
return $ret
}</
{{Out}}
<pre>PS> Get-SumAndProduct 5,9,7,2,3,8,4
Line 1,742 ⟶ 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,755 ⟶ 2,926:
Using fold
<
add(A,B,R):-
R is A + B.
Line 1,779 ⟶ 2,950:
Prod = 24 .
</syntaxhighlight>
=={{header|PureBasic}}==
<
Define a, sum=0, prod=1
Line 1,795 ⟶ 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 1,877 ⟶ 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 1,887 ⟶ 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 1,905 ⟶ 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 1,913 ⟶ 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 1,935 ⟶ 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}}
<syntaxhighlight lang="ruby">arr = [1,2,3,4,5]
p sum = arr.sum #=> 15
p [].sum #=> 0</syntaxhighlight>
=={{header|Run BASIC}}==
<
for i = 1 To 100
array(i) = rnd(0) * 100
Line 1,959 ⟶ 3,229:
Print " Sum is ";sum
Print "Product is ";product</
=={{header|Rust}}==
<syntaxhighlight lang="rust">
fn main() {
let arr
// using fold
Line 1,973 ⟶ 3,243:
// 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);
}
</syntaxhighlight>
=={{header|S-lang}}==
<syntaxhighlight lang="s-lang">variable a = [5, -2, 3, 4, 666, 7];</syntaxhighlight>
The sum of array elements is handled by an intrinsic.
[note: print is slsh-specific; if not available, use printf().]
<syntaxhighlight lang="s-lang">print(sum(a));</syntaxhighlight>
The product is slightly more involved; I'll use this as a
chance to show the alternate stack-based use of 'foreach':
<syntaxhighlight 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 (a[[1:]])
% () pops it off.
prod *= ();
print(prod);</syntaxhighlight>
=={{header|SAS}}==
<
array a{*} a1-a100;
do i=1 to 100;
Line 1,988 ⟶ 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,000 ⟶ 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,023 ⟶ 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,045 ⟶ 3,336:
prod *:= value;
end for;
end func;</
Call these functions with:
writeln(sumArray([](1, 2, 3, 4, 5)));
Line 2,051 ⟶ 3,342:
=={{header|SETL}}==
<
print(+/ numbers, */ numbers);</
=> <code>45 362880</code>
Line 2,058 ⟶ 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,092 ⟶ 3,385:
out output = "Sum: " sum
output = "Prod: " product
end</
Input
Line 2,105 ⟶ 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,121 ⟶ 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,130 ⟶ 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 <
<syntaxhighlight 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</syntaxhighlight>
=={{header|Toka}}==
<
212 1 foo array.put
Line 2,164 ⟶ 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,181 ⟶ 3,536:
ENDLOOP
PRINT "product: ",product
</syntaxhighlight>
{{Out}}
<pre>
Line 2,192 ⟶ 3,547:
From an internal variable, $IFS delimited:
<
prod=1
list="1 2 3"
Line 2,198 ⟶ 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,245 ⟶ 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.
=={{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.
<syntaxhighlight 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</syntaxhighlight>
=={{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,261 ⟶ 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,300 ⟶ 3,682:
myarray = Array(1,2,3,4,5,6)
sum_and_product(myarray)
</syntaxhighlight>
{{Out}}
Line 2,306 ⟶ 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,328 ⟶ 3,762:
]; \SumSq
SumProd([1,2,3,4,5,6,7,8,9,10], 10)</
{{Out}}
Line 2,339 ⟶ 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,374 ⟶ 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]
|