Sum and product of an array: Difference between revisions
Content deleted Content added
m Some formatting. Replaced sequences with arrays to simplify. |
→Nu: add |
||
(61 intermediate revisions by 37 users not shown) | |||
Line 7:
=={{header|11l}}==
<
print(sum(arr))
print(product(arr))</
{{out}}
Line 18:
=={{header|360 Assembly}}==
<
SUMPROD CSECT
USING SUMPROD,R15 base register
Line 38:
PG DS CL24 buffer
YREGS
END SUMPROD</
{{out}}
<pre>
Line 45:
=={{header|4D}}==
<
For ($i;1;5)
APPEND TO ARRAY($list;$i)
Line 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 73 ⟶ 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 97 ⟶ 289:
}
}
}</
=={{header|Ada}}==
<
array : Int_Array := (1,2,3,4,5,6,7,8,9,10);
Line 106 ⟶ 298:
for I in array'range loop
Sum := Sum + array(I);
end loop;</
Define the product function
<
Prod : Integer := 1;
begin
Line 115 ⟶ 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)
{
Line 142 ⟶ 334:
return 0;
}</
{{out}}
<pre>77
Line 148 ⟶ 340:
=={{header|ALGOL 68}}==
<
INT default upb := 3;
MODE INTARRAY = [default upb]INT;
Line 168 ⟶ 360:
) # int product # ;
printf(($" Sum: "g(0)$,sum,$", Product:"g(0)";"l$,int product(array)))
)</
{{Out}}
<pre>
Line 175 ⟶ 367:
=={{header|ALGOL W}}==
<
% computes the sum and product of intArray %
Line 208 ⟶ 400:
write( sum, product );
end
end.</
{{out}}
Line 217 ⟶ 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 235 ⟶ 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 298 ⟶ 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}}==
<
print ["Sum =" sum arr]
print ["Product =" product arr]</
{{out}}
Line 312 ⟶ 675:
<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 321 ⟶ 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 331 ⟶ 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 346 ⟶ 723:
Result:
41
30030</
Perhaps better Babel:
<
{ [2 3 5 7 11 13]
ar2ls dup cp
Line 368 ⟶ 745:
{ * }
{ depth 1 > }
do_while } nest }</
The nest operator creates a kind of argument-passing context -
Line 381 ⟶ 758:
=={{header|BASIC}}==
{{works with|FreeBASIC}}
<
dim sum as integer = 0
Line 388 ⟶ 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|Atari BASIC}}===
Almost the same code works in Atari BASIC, but you can't READ directly into arrays, leave the variable off a NEXT, or concatenate values in PRINT without semicolons between them:
<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}}===
<
'--- set some values into the array
DECLARE a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } TYPE int
Line 418 ⟶ 809:
PRINT "The sum is ",sum
PRINT "The product is ",product
</
==={{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}}===
<
array%() = 1, 2, 3, 4, 5, 6
Line 430 ⟶ 840:
product% *= array%(I%)
NEXT
PRINT "Product of array elements = " ; product%</
==={{header|IS-BASIC}}===
<
110 LET N=5
120 NUMERIC A(1 TO N)
Line 445 ⟶ 855:
200 LET SUM=SUM+A(I):LET PROD=PROD*A(I)
210 NEXT
220 PRINT "Sum =";SUM,"Product =";PROD</
=={{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 461 ⟶ 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 486 ⟶ 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 501 ⟶ 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 528 ⟶ 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 557 ⟶ 1,012:
cout << sum(aflo,4) << " " << prod(aflo,4) << endl;
return 0;
}</
=={{header|Chef}}==
<
This recipe sums N given numbers.
Line 583 ⟶ 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 621 ⟶ 1,099:
GOBACK
.</
=={{header|CoffeeScript}}==
<
sum = (array) ->
array.reduce (x, y) -> x + y
Line 630 ⟶ 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
Line 672 ⟶ 1,150:
{sum, product}
end
</syntaxhighlight>
<syntaxhighlight lang="ruby">
require "benchmark"
Benchmark.ips do |x|
Line 680 ⟶ 1,158:
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
Line 686 ⟶ 1,164:
=={{header|D}}==
<
void main() {
Line 701 ⟶ 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 716 ⟶ 1,194:
writeln("Sum: ", r[0]);
writeln("Product: ", r[1]);
}</
=={{header|dc}}==
<
Sum: 49
Product: 135135</
=={{header|Delphi}}==
<
{$APPTYPE CONSOLE}
Line 744 ⟶ 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 794 ⟶ 1,288:
end
</syntaxhighlight>
{{Out}}
<pre>Sum of the elements of the array: 30
Line 801 ⟶ 1,295:
=={{header|Elena}}==
ELENA 5.0:
<
import extensions;
Line 810 ⟶ 1,304:
var sum := list.summarize(new Integer());
var product := list.accumulate(new Integer(1), (var,val => var * val));
}</
=={{header|Elixir}}==
When an accumulator is omitted, the first element of the collection is used as the initial value of acc.
<
15
iex(27)> Enum.reduce([1,2,3,4,5], 1, fn x,acc -> x*acc end)
Line 831 ⟶ 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 882 ⟶ 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 898 ⟶ 1,426:
printf(1,"sum is %d\n",sum)
printf(1,"prod is %d\n",prod)</
{{Out}}
Line 907 ⟶ 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 932 ⟶ 1,460:
"Sum: "s;."
Product: "p;.</
{{out}}
<pre>Sum: 15
Line 939 ⟶ 1,467:
=={{header|Fantom}}==
<
class Main
{
Line 972 ⟶ 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 982 ⟶ 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 1,005 ⟶ 1,545:
Print
Print "Press any key to quit"
Sleep</
{{out}}
Line 1,011 ⟶ 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æ}}==
'''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 1,043 ⟶ 1,673:
Print "The Product =\t" & iPrd
End</
Output:
<pre>
Line 1,049 ⟶ 1,679:
The Product = 120
</pre>
=={{header|GAP}}==
<
Sum(v);
Line 1,065 ⟶ 1,696:
Product(v, n -> 1/n);
# 1/40320</
=={{header|GFA Basic}}==
<
DIM a%(10)
' put some values into the array
Line 1,085 ⟶ 1,718:
PRINT "Sum is ";sum%
PRINT "Product is ";product%
</syntaxhighlight>
=={{header|Go}}==
;Implementation
<
import "fmt"
Line 1,100 ⟶ 1,735:
}
fmt.Println(sum, prod)
}</
{{out}}
<pre>
Line 1,106 ⟶ 1,741:
</pre>
;Library
<
import (
Line 1,119 ⟶ 1,754:
fmt.Println("Sum: ", floats.Sum(a))
fmt.Println("Product:", floats.Prod(a))
}</
{{out}}
<pre>
Line 1,128 ⟶ 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,152 ⟶ 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,162 ⟶ 1,801:
s1 = foldl (+) 0 values -- the hard way
p1 = foldl (*) 1 values</
Though foldr is generally more natural and efficient:
<syntaxhighlight lang="haskell">main :: IO ()
main =
mapM_
print
( fmap
($ [1 .. 10])
[ foldr (+) 0,
foldr (*) 1
]
)</syntaxhighlight>
{{Out}}
<pre>55
3628800</pre>
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,181 ⟶ 1,836:
=={{header|HicEst}}==
<
sum = SUM(array)
Line 1,190 ⟶ 1,845:
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,217 ⟶ 1,872:
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,247 ⟶ 1,909:
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,264 ⟶ 1,926:
}
}
}</
{{works with|Java|1.8+}}
<
public class SumProd
Line 1,278 ⟶ 1,940:
System.out.printf("product = %d\n", Arrays.stream(arg).reduce(1, (a, b) -> a * b));
}
}</
{{out}}
<pre>
Line 1,288 ⟶ 1,950:
=={{header|JavaScript}}==
===ES5===
<
sum = 0,
prod = 1,
Line 1,296 ⟶ 1,958:
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,308 ⟶ 1,970:
return a * b;
}, 1);
alert(sum + ' ' + prod);</
===ES6===
<
'use strict';
Line 1,329 ⟶ 1,991:
.map(f => f([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))
);
})();</
{{Out}}
Line 1,336 ⟶ 1,998:
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,363 ⟶ 2,029:
julia> prod([4,6,8])
192</
=={{header|K}}==
<
product: {*/}x
a: 1 3 5 7 9 11 13
Line 1,372 ⟶ 2,038:
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,386 ⟶ 2,052:
val product = a.fold(1) { acc, i -> acc * i }
println("Product is $product")
}</
{{out}}
Line 1,397 ⟶ 2,063:
=={{header|Lambdatalk}}==
<
{A.serie start end [step]} creates a sequence from start to end with optional step
{A.new words} creates an array from a sequence of words
Line 1,413 ⟶ 2,079:
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
val alist = series(19)
writeln "
writeln "
writeln "product: ", fold(fn{*}, alist)
</syntaxhighlight>
{{out}}
<pre>
sum: 190
product: 121645100408832000</pre>
=={{header|Lasso}}==
<
// sum of array elements
'Sum: '
Line 1,449 ⟶ 2,122:
local(product = 1)
with n in #x do => { #product *= #n }
#product</
{{out}}
<pre>Sum: 55
Line 1,455 ⟶ 2,128:
=={{header|Liberty BASIC}}==
<
For i = 0 To 19
Line 1,469 ⟶ 2,142:
Print "Sum is " + str$(sum)
Print "Product is " + str$(product)</
=={{header|Lingo}}==
<
res = 0
repeat with v in intList
Line 1,486 ⟶ 2,159:
end repeat
return res
end</
=={{header|LiveCode}}==
<
put "1,2,3,4" into nums
split nums using comma
Line 1,503 ⟶ 2,176:
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,517 ⟶ 2,223:
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,532 ⟶ 2,238:
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)
Line 1,555 ⟶ 2,261:
}
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,571 ⟶ 2,277:
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,584 ⟶ 2,290:
Sample Usage:
<
array =
Line 1,618 ⟶ 2,324:
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}}
<
"Sum: $1\nProduct: $2" get-stack % puts</
{{out}}
<pre>
Line 1,646 ⟶ 2,352:
=={{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,668 ⟶ 2,374:
Put("Sum of array: " & Int(sum) & "\n");
Put("Product of array: " & Int(prod) & "\n");
END Sumprod.</
{{Out}}
<pre>Sum of array: 15
Line 1,674 ⟶ 2,380:
=={{header|MUMPS}}==
<syntaxhighlight lang="mumps">
SUMPROD(A)
;Compute the sum and product of the numbers in the array A
Line 1,686 ⟶ 2,392:
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,707 ⟶ 2,413:
=={{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,736 ⟶ 2,442:
WriteLine("Sum is: {0}\tProduct is: {1}", suml, proda);
}
}</
=={{header|NetRexx}}==
<
options replace format comments java crossref savelog symbols binary
Line 1,763 ⟶ 2,469:
return
</syntaxhighlight>
{{Out}}
<pre>
Line 1,772 ⟶ 2,478:
=={{header|NewLISP}}==
<
(apply + a)
(apply * a)</
The previous example used a list, not an array.
<syntaxhighlight lang="newlisp">
(let (a (array 5 (sequence 1 5)))
(println "Sum: " (apply + a))
(println "Product: " (apply * a)))
</syntaxhighlight>
{{out}}
<pre>
Sum: 15
Product: 120
</pre>
<syntaxhighlight lang="newlisp">
;; 2-dimensional array.
(let (ary2d (array 4 5 (sequence 1 9 0.25)))
(dolist (row ary2d)
(print "Row " $idx ": ")
(dolist (x row) (print (format "%6.2f" x)))
(println))
(println)
(println (apply add (flat (array-list ary2d))))
(println (apply mul (flat (array-list ary2d)))))
</syntaxhighlight>
{{out}}
<pre>
Row 0: 1.00 1.25 1.50 1.75 2.00
Row 1: 2.25 2.50 2.75 3.00 3.25
Row 2: 3.50 3.75 4.00 4.25 4.50
Row 3: 4.75 5.00 5.25 5.50 5.75
67.5
3918712042.360157
</pre>
=={{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,800 ⟶ 2,542:
for x in xs:
sum += x
product *= x</
Or functionally:
<
let
xs = [1, 2, 3, 4, 5, 6]
sum = xs.foldl(a + b)
product = xs.foldl(a * b)</
Or using a math function:
<
let numbers = [1, 5, 4]
Line 1,818 ⟶ 2,560:
var product = 1
for n in numbers:
product *= n</
=={{header|Nu}}==
{{works with|Nushell|0.96.1}}
<syntaxhighlight lang="nu">const $v = [2 3 4 5 6]
$v | math sum | print
$v | math product | print</syntaxhighlight>
{{out}}
<pre>20
720</pre>
=={{header|Objeck}}==
<
sum := 0;
prod := 1;
Line 1,829 ⟶ 2,580:
prod *= arg[i];
};
</syntaxhighlight>
=={{header|Objective-C}}==
{{works with|GCC|4.0.1 (apple)}}
Sum:
<
{
int i, sum, value;
Line 1,846 ⟶ 2,597:
return suml;
}</
Product:
<
{
int i, prod, value;
Line 1,860 ⟶ 2,611:
return suml;
}</
=={{header|OCaml}}==
===Arrays===
<
let a = [| 1; 2; 3; 4; 5 |];;
Array.fold_left (+) 0 a;;
Line 1,871 ⟶ 2,622:
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,880 ⟶ 2,631:
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,900 ⟶ 2,651:
=={{header|Ol}}==
<
(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,928 ⟶ 2,679:
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
Line 1,936 ⟶ 2,687:
=={{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,942 ⟶ 2,693:
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,956 ⟶ 2,707:
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,972 ⟶ 2,723:
=={{header|Pascal}}==
See [[Sum_and_product_of_an_array#Delphi | Delphi]]
=={{header|PascalABC.NET}}==
<syntaxhighlight lang="delphi">
##
var a := Arr(1..9);
Print(a.Sum,a.Product);
</syntaxhighlight>
{{out}}
<pre>
45 362880
</pre>
=={{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
Line 1,991 ⟶ 2,753:
=={{header|Phix}}==
{{libheader|Phix/basics}}
<!--<
<span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">}</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"sum is %d\n"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">))</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"prod is %d\n"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">product</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">))</span>
<!--</
{{out}}
<pre>
Line 2,003 ⟶ 2,765:
=={{header|Phixmonti}}==
<
( 1 2 3 4 5 )
Line 2,015 ⟶ 2,777:
drop
"mult is " print print nl</
=={{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}}==
<
To find a sum and a product of some elements:
Line 2,070 ⟶ 2,882:
Shut down.
A sum is a number.</
{{out}}
<pre>
Line 2,079 ⟶ 2,891:
=={{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 2,111 ⟶ 2,923:
prod ==
}def
</syntaxhighlight>
{{libheader|initlib}}
<
% sum
[1 1 1 1 1] 0 {add} fold
Line 2,120 ⟶ 2,932:
[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 2,138 ⟶ 2,950:
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 2,148 ⟶ 2,960:
$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 2,165 ⟶ 2,977:
$ret | Add-Member NoteProperty Product $prod
return $ret
}</
{{Out}}
<pre>PS> Get-SumAndProduct 5,9,7,2,3,8,4
Line 2,174 ⟶ 2,986:
=={{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 2,187 ⟶ 2,999:
Using fold
<
add(A,B,R):-
R is A + B.
Line 2,211 ⟶ 3,023:
Prod = 24 .
</syntaxhighlight>
=={{header|PureBasic}}==
<
Define a, sum=0, prod=1
Line 2,227 ⟶ 3,039:
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|NumPy}}
<
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}}==
<
[ 1 swap witheach * ] is product ( [ --> n )</
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
Line 2,266 ⟶ 3,100:
15
120
Stack empty.</
=={{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)</
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku"
say 'Sum: ', [+] @ary;
say 'Product: ', [*] @ary;</
=={{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,323 ⟶ 3,174:
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,333 ⟶ 3,184:
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,351 ⟶ 3,228:
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,359 ⟶ 3,236:
=={{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,381 ⟶ 3,273:
# 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,410 ⟶ 3,302:
Print " Sum is ";sum
Print "Product is ";product</
=={{header|Rust}}==
<
fn main() {
Line 2,428 ⟶ 3,320:
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,449 ⟶ 3,341:
prod *= ();
print(prod);</
=={{header|SAS}}==
<
array a{*} a1-a100;
do i=1 to 100;
Line 2,459 ⟶ 3,351:
b=sum(of a{*});
put b c;
run;</
=={{header|Sather}}==
<
main is
a :ARRAY{INT} := |10, 5, 5, 20, 60, 100|;
Line 2,471 ⟶ 3,363:
#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,494 ⟶ 3,386:
(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,517 ⟶ 3,409:
prod *:= value;
end for;
end func;</
Call these functions with:
writeln(sumArray([](1, 2, 3, 4, 5)));
Line 2,523 ⟶ 3,415:
=={{header|SETL}}==
<
print(+/ numbers, */ numbers);</
=> <code>45 362880</code>
Line 2,530 ⟶ 3,422:
=={{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,566 ⟶ 3,458:
out output = "Sum: " sum
output = "Prod: " product
end</
Input
Line 2,579 ⟶ 3,471:
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,595 ⟶ 3,513:
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,604 ⟶ 3,522:
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:
<
sum(a)
-3
(-1)^mod(sum(a:<0),2)*exp(sum(log(abs(a))))
-120</
=={{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,653 ⟶ 3,571:
( 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,671 ⟶ 3,609:
ENDLOOP
PRINT "product: ",product
</syntaxhighlight>
{{Out}}
<pre>
Line 2,682 ⟶ 3,620:
From an internal variable, $IFS delimited:
<
prod=1
list="1 2 3"
Line 2,688 ⟶ 3,626:
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,735 ⟶ 3,679:
(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,741 ⟶ 3,685:
=={{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,748 ⟶ 3,692:
# 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,762 ⟶ 3,706:
=={{header|V}}==
<
{{Out|Using it}}
<
=
product=15
sum=120</
=={{header|Vala}}==
<
int sum = 0, prod = 1;
int[] data = { 1, 2, 3, 4 };
Line 2,779 ⟶ 3,723:
}
print(@"sum: $(sum)\nproduct: $(prod)");
}</
{{out}}
<pre>sum: 10
Line 2,786 ⟶ 3,730:
=={{header|VBA}}==
Assumes Excel is used.
<
Dim arr
arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
Debug.Print "sum : " & Application.WorksheetFunction.Sum(arr)
Debug.Print "product : " & Application.WorksheetFunction.Product(arr)
End Sub</
<pre>sum : 55
product : 3628800</pre>
=={{header|VBScript}}==
<
sum = 0
product = 1
Line 2,811 ⟶ 3,755:
myarray = Array(1,2,3,4,5,6)
sum_and_product(myarray)
</syntaxhighlight>
{{Out}}
Line 2,822 ⟶ 3,766:
{{trans|C#}}
<
Sub Main()
Dim arg As Integer() = {1, 2, 3, 4, 5}
Line 2,828 ⟶ 3,772:
Dim prod = arg.Aggregate(Function(runningProduct, nextFactor) runningProduct * nextFactor)
End Sub
End Module</
=={{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}}==
<
let s => import 'stream';
let sum array => a.stream array -> s.reduce 0 +;
let prod array => a.stream prod -> s.reduce 1 *;</
=={{header|Wortel}}==
<
@prod [1 2 3 4] ; returns 24</
=={{header|Wren}}==
{{libheader|Wren-math}}
<
var a = [7, 10, 2, 4, 6, 1, 8, 3, 9, 5]
System.print("Array : %(a)")
System.print("Sum : %(Nums.sum(a))")
System.print("Product : %(Nums.prod(a))")</
{{out}}
Line 2,861 ⟶ 3,824:
=={{header|XPL0}}==
<
func SumProd(A, L);
Line 2,872 ⟶ 3,835:
]; \SumSq
SumProd([1,2,3,4,5,6,7,8,9,10], 10)</
{{Out}}
Line 2,883 ⟶ 3,846:
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,918 ⟶ 3,881:
</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
Line 2,930 ⟶ 3,925:
=={{header|Zoea}}==
<syntaxhighlight lang="zoea">
program: sum_and_product
case: 1
Line 2,938 ⟶ 3,933:
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]
|