Rosetta Code

Minimum numbers of three lists: Difference between revisions

Page Discussion

Minimum numbers of three lists (view source)

Revision as of 10:04, 4 January 2024

22,044 bytes added ,  4 months ago
m
→‎{{header|Wren}}: Changed to Wren S/H
(→‎{{header|Factor}}: even better than transposing a matrix)
m (→‎{{header|Wren}}: Changed to Wren S/H)
(37 intermediate revisions by 27 users not shown)
Line 13:
# Show Numbers on this page.
<br><br>
 
=={{header|11l}}==
{{trans|Python}}
 
<syntaxhighlight lang="11l">V numbers1 = [5, 45, 23, 21, 67]
V numbers2 = [43, 22, 78, 46, 38]
V numbers3 = [9, 98, 12, 98, 53]
 
V numbers = (0 .< numbers1.len).map(i -> min(:numbers1[i], :numbers2[i], :numbers3[i]))
 
print(numbers)</syntaxhighlight>
 
{{out}}
<pre>
[5, 22, 12, 21, 38]
</pre>
 
=={{header|Ada}}==
<syntaxhighlight lang="ada">with Ada.Text_Io; use Ada.Text_Io;
 
procedure Minimum_Three_Lists is
 
type Number_Array is array (Positive range 1 .. 5) of Integer;
 
Numbers_1 : constant Number_Array := (5,45,23,21,67);
Numbers_2 : constant Number_Array := (43,22,78,46,38);
Numbers_3 : constant Number_Array := (9,98,12,98,53);
 
Result : Number_Array;
begin
for A in Number_Array'Range loop
declare
R : Integer renames Result (A);
N_1 : Integer renames Numbers_1 (A);
N_2 : Integer renames Numbers_2 (A);
N_3 : Integer renames Numbers_3 (A);
begin
R := Integer'Min (N_1, Integer'Min (N_2, N_3));
end;
end loop;
 
for R of Result loop
Put (R'Image);
end loop;
New_Line;
end Minimum_Three_Lists;</syntaxhighlight>
{{out}}
<pre> 5 22 12 21 38</pre>
 
=={{header|ALGOL 68}}==
Generallising a little...
{{libheader|ALGOL 68-rows}}
<lang algol68>BEGIN # construct a list of the minimum values of some other lists #
<syntaxhighlight lang="algol68">BEGIN # construct a list of the minimum values of some other lists #
# lists are represented by arrays in this sample #
PR read "rows.incl.a68" PR # row-related utilities #
# returns a list composed of the minimum values of the lists in lists #
# the lists must all have te same bounds #
Line 40 ⟶ 90:
result
FI # min # ;
 
# displays a list of numbers #
PROC show = ( []INT list )VOID:
FOR i FROM LWB list TO UPB list DO print( ( " ", whole( list[ i ], 0 ) ) ) OD;
# construct the lists of numbers required by the task #
REF[]INT numbers1 = HEAP[ 1 : 5 ]INT := ( 5, 45, 23, 21, 67 );
Line 48 ⟶ 96:
REF[]INT numbers3 = HEAP[ 1 : 5 ]INT := ( 9, 98, 12, 98, 53 );
# display the minimum values for each element in the lists #
show(SHOW min( ( numbers1, numbers2, numbers3 ) ) )
END</langsyntaxhighlight>
{{out}}
<pre>
Line 56 ⟶ 104:
 
=={{header|ALGOL W}}==
<langsyntaxhighlight lang="algolw">begin % show the minimum elements of three lists %
integer array numbers1, numbers2, numbers3 ( 1 :: 5 );
integer pos;
Line 69 ⟶ 117:
writeon( i_w := 1, s_w := 0, " ", m )
end for_i;
end.</langsyntaxhighlight>
{{out}}
<pre>
5 22 12 21 38
</pre>
 
=={{header|Arturo}}==
 
<syntaxhighlight lang="arturo">lists: [
[ 5 45 23 21 67]
[43 22 78 46 38]
[ 9 98 12 98 53]
]
 
print map 0..dec size first lists 'i ->
min map lists 'l -> l\[i]</syntaxhighlight>
 
{{out}}
 
<pre>5 22 12 21 38</pre>
 
=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">Numbers1 := [5,45,23,21,67]
Numbers2 := [43,22,78,46,38]
Numbers3 := [9,98,12,98,53]
Numbers := []
for i, v in Numbers1
{
tempArr := []
loop 3
tempArr.Push(Numbers%A_Index%[i])
Numbers.Push(Min(tempArr*))
}
 
for i, v in Numbers
result .= v ", "
MsgBox % result := "[" . Trim(result, ", ") . "]"</syntaxhighlight>
{{out}}
<pre>[5, 22, 12, 21, 38]</pre>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f MINIMUM_NUMBERS_OF_THREE_LISTS.AWK
BEGIN {
n1 = split("5,45,23,21,67",numbers1,",")
n2 = split("43,22,78,46,38",numbers2,",")
n3 = split("9,98,12,98,53",numbers3,",")
if (n1 != n2 || n1 != n3) {
print("error: arrays must be same length")
exit(1)
}
for (i=1; i<=n1; i++) {
numbers[i] = min(min(numbers1[i],numbers2[i]),numbers3[i])
printf("%d ",numbers[i])
}
printf("\n")
exit(0)
}
function min(x,y) { return((x < y) ? x : y) }
</syntaxhighlight>
{{out}}
<pre>
5 22 12 21 38
</pre>
 
=={{header|BASIC}}==
==={{header|Applesoft BASIC}}===
{{works with|Chipmunk Basic}}
<syntaxhighlight lang="qbasic">100 DIM n1(5)
110 n1(1) = 5 : n1(2) = 45 : n1(3) = 23 : n1(4) = 21 : n1(5) = 67
120 DIM n2(5)
130 n2(1) = 43 : n2(2) = 22 : n2(3) = 78 : n2(4) = 46 : n2(5) = 38
140 DIM n3(5)
150 n3(1) = 9 : n3(2) = 98 : n3(3) = 12 : n3(4) = 98 : n3(5) = 53
160 FOR i = 1 TO 5
170 LET a = n2(i)
180 LET b = n3(i)
190 GOSUB 260
200 LET a = n1(i)
210 LET b = m
220 GOSUB 260
230 PRINT m
240 NEXT i
250 END
260 rem FUNCTION min(a, b)
270 IF a < b THEN LET m = a
280 IF a >= b THEN LET m = b
290 RETURN</syntaxhighlight>
{{out}}
<pre>5
22
12
21
38</pre>
 
==={{header|BASIC256}}===
<syntaxhighlight lang="vb">dim numbers1 = {5, 45, 23, 21, 67}
dim numbers2 = {43, 22, 78, 46, 38}
dim numbers3 = {9, 98, 12, 98, 53}
 
for i = 0 to 4
print min(numbers1[i], min(numbers2[i], numbers3[i]))
next i
end
 
function min(a, b)
if a < b then return a else return b
end function</syntaxhighlight>
{{out}}
<pre>5
22
12
21
38</pre>
 
==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
<syntaxhighlight lang="qbasic">100 dim n1(5)
110 n1(1) = 5 : n1(2) = 45 : n1(3) = 23 : n1(4) = 21 : n1(5) = 67
120 dim n2(5)
130 n2(1) = 43 : n2(2) = 22 : n2(3) = 78 : n2(4) = 46 : n2(5) = 38
140 dim n3(5)
150 n3(1) = 9 : n3(2) = 98 : n3(3) = 12 : n3(4) = 98 : n3(5) = 53
160 for i = 1 to 5
170 print min(n1(i),min(n2(i),n3(i)))
180 next i
190 end
200 sub min(a,b)
210 if a < b then min = a else min = b
220 end sub</syntaxhighlight>
{{out}}
<pre>5
22
12
21
38</pre>
 
==={{header|GW-BASIC}}===
{{works with|PC-BASIC|any}}
{{works with|MSX BASIC|any}}
<syntaxhighlight lang="qbasic">100 DIM N1
110 N1(1) = 5
120 N1(2) = 45
130 N1(3) = 23
140 N1(4) = 21
150 N1(5) = 67
160 DIM N2
170 N2(1) = 43
180 N2(2) = 22
190 N2(3) = 78
200 N2(4) = 46
210 N2(5) = 38
220 DIM N3
230 N3(1) = 9
240 N3(2) = 98
250 N3(3) = 12
260 N3(4) = 98
270 N3(5) = 53
280 FOR I = 1 TO 5
290 A = N2(I)
300 B = N3(I)
310 GOSUB 380
320 A = N1(I)
330 B = M
340 GOSUB 380
350 PRINT M
360 NEXT I
370 END
380 REM FUNCTION min(a, b)
390 IF A < B THEN M = A ELSE M = B
400 RETURN</syntaxhighlight>
{{out}}
<pre>5
22
12
21
38</pre>
 
==={{header|Minimal BASIC}}===
<syntaxhighlight lang="qbasic">100 DIM X(5)
110 LET X(1) = 5
120 LET X(2) = 45
130 LET X(3) = 23
140 LET X(4) = 21
150 LET X(5) = 67
160 DIM Y(5)
170 LET Y(1) = 43
180 LET Y(2) = 22
190 LET Y(3) = 78
200 LET Y(4) = 46
210 LET Y(5) = 38
220 DIM Z(5)
230 LET Z(1) = 9
240 LET Z(2) = 98
250 LET Z(3) = 12
260 LET Z(4) = 98
270 LET Z(5) = 53
280 FOR I = 1 TO 5
290 LET A = Y(I)
300 LET B = Z(I)
310 GOSUB 380
320 LET A = X(I)
330 LET B = M
340 GOSUB 380
350 PRINT M
360 NEXT I
370 STOP
380 REM FUNCTION MIN(A, B)
390 IF A < B THEN 420
410 LET M = B
415 RETURN
420 LET M = A
430 RETURN
440 END</syntaxhighlight>
{{out}}
<pre>5
22
12
21
38</pre>
 
==={{header|MSX Basic}}===
{{works with|MSX BASIC|any}}
The [[#GW-BASIC|GW-BASIC]] solution works without any changes.
 
==={{header|PureBasic}}===
<syntaxhighlight lang="purebasic">OpenConsole()
 
Procedure.i min(a, b)
If a < b
Result = a
Else
Result = b
EndIf
ProcedureReturn result
EndProcedure
 
Dim n1.i(5)
n1(1) = 5 : n1(2) = 45 : n1(3) = 23 : n1(4) = 21 : n1(5) = 67
Dim n2.i(5)
n2(1) = 43 : n2(2) = 22 : n2(3) = 78 : n2(4) = 46 : n2(5) = 38
Dim n3.i(5)
n3(1) = 9 : n3(2) = 98 : n3(3) = 12 : n3(4) = 98 : n3(5) = 53
 
For i.i = 1 To 5
PrintN(Str(min(n1(i), min(n2(i), n3(i)))))
Next i
 
PrintN(#CRLF$ + "--- Press ENTER to exit ---"): Input()
CloseConsole()</syntaxhighlight>
{{out}}
<pre>5
22
12
21
38</pre>
 
==={{header|QBasic}}===
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
<syntaxhighlight lang="qbasic">FUNCTION min (a, b)
IF a < b THEN min = a ELSE min = b
END FUNCTION
 
DIM numbers(1 To 3, 1 To 5) = {{5,45,23,21,67},{43,22,78,46,38},{9,98,12,98,53}}
 
FOR i = 1 TO 5
PRINT min(numbers(1, i), min(numbers(2, i), numbers(3, i)))
NEXT i
END</syntaxhighlight>
{{out}}
<pre>5
22
12
21
38</pre>
 
==={{header|Quite BASIC}}===
<syntaxhighlight lang="qbasic">100 ARRAY n1
110 LET n1(1) = 5
120 LET n1(2) = 45
130 LET n1(3) = 23
140 LET n1(4) = 21
150 LET n1(5) = 67
160 ARRAY n2
170 LET n2(1) = 43
180 LET n2(2) = 22
190 LET n2(3) = 78
200 LET n2(4) = 46
210 LET n2(5) = 38
220 ARRAY n3
230 LET n3(1) = 9
240 LET n3(2) = 98
250 LET n3(3) = 12
260 LET n3(4) = 98
270 LET n3(5) = 53
280 FOR i = 1 TO 5
290 LET a = n2(i)
300 LET b = n3(i)
310 GOSUB 380
320 LET a = n1(i)
330 LET b = m
340 GOSUB 380
350 PRINT m
360 NEXT i
370 END
380 rem FUNCTION min(a, b)
390 IF a < b THEN LET m = a
400 IF a >= b THEN LET m = b
410 RETURN</syntaxhighlight>
{{out}}
<pre>5
22
12
21
38</pre>
 
==={{header|Run BASIC}}===
{{works with|Just BASIC}}
{{works with|Liberty BASIC}}
The [[#Yabasic|Yabasic]] solution works without any changes.
 
==={{header|True BASIC}}===
<syntaxhighlight lang="qbasic">FUNCTION min(a, b)
IF a < b then LET min = a else LET min = b
END FUNCTION
 
DIM n1(5)
LET n1(1) = 5
LET n1(2) = 45
LET n1(3) = 23
LET n1(4) = 21
LET n1(5) = 67
DIM n2(5)
LET n2(1) = 43
LET n2(2) = 22
LET n2(3) = 78
LET n2(4) = 46
LET n2(5) = 38
DIM n3(5)
LET n3(1) = 9
LET n3(2) = 98
LET n3(3) = 12
LET n3(4) = 98
LET n3(5) = 53
 
FOR i = 1 to 5
PRINT min(n1(i), min(n2(i), n3(i)))
NEXT i
END</syntaxhighlight>
{{out}}
<pre>5
22
12
21
38</pre>
 
==={{header|XBasic}}===
{{works with|Windows XBasic}}
<syntaxhighlight lang="qbasic">PROGRAM "Minimum numbers of three lists"
VERSION "0.0000"
 
DECLARE FUNCTION Entry ()
DECLARE FUNCTION min(a, b)
 
FUNCTION Entry ()
DIM n1[5]
n1[1] = 5: n1[2] = 45 : n1[3] = 23 : n1[4] = 21 : n1[5] = 67
DIM n2[5]
n2[1] = 43 : n2[2] = 22 : n2[3] = 78 : n2[4] = 46 : n2[5] = 38
DIM n3[5]
n3[1] = 9 : n3[2] = 98 : n3[3] = 12 : n3[4] = 98 : n3[5] = 53
 
FOR i = 1 TO 5
PRINT min(n1[i], min(n2[i], n3[i]))
NEXT i
END FUNCTION
 
FUNCTION min (a, b)
IF a < b THEN RETURN a ELSE RETURN b
END FUNCTION
END PROGRAM</syntaxhighlight>
{{out}}
<pre>5
22
12
21
38</pre>
 
==={{header|Yabasic}}===
====With one-dimensional arrays====
{{works with|Run BASIC}}
{{works with|Just BASIC}}
{{works with|Liberty BASIC}}
<syntaxhighlight lang="vb">dim n1(5)
n1(1) = 5 : n1(2) = 45 : n1(3) = 23 : n1(4) = 21 : n1(5) = 67
dim n2(5)
n2(1) = 43 : n2(2) = 22 : n2(3) = 78 : n2(4) = 46 : n2(5) = 38
dim n3(5)
n3(1) = 9 : n3(2) = 98 : n3(3) = 12 : n3(4) = 98 : n3(5) = 53
 
for i = 1 to 5
print min(n1(i), min(n2(i), n3(i)))
next i
end</syntaxhighlight>
{{out}}
<pre>5
22
12
21
38</pre>
 
====With multidimensional arrays====
<syntaxhighlight lang="vb">dim n(3, 5)
n(1, 1) = 5 : n(1, 2) = 45 : n(1, 3) = 23 : n(1, 4) = 21 : n(1, 5) = 67
n(2, 1) = 43 : n(2, 2) = 22 : n(2, 3) = 78 : n(2, 4) = 46 : n(2, 5) = 38
n(3, 1) = 9 : n(3, 2) = 98 : n(3, 3) = 12 : n(3, 4) = 98 : n(3, 5) = 53
 
for i = 1 to 5
print min(n(1, i), min(n(2, i), n(3, i)))
next i
end</syntaxhighlight>
 
{{out}}
<pre>5
22
12
21
38</pre>
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include <stdio.h>
 
int min(int a, int b) {
Line 95 ⟶ 567:
printf("\n");
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 101 ⟶ 573:
5 22 12 21 38
</pre>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
type TNumList = array [0..2, 0..4] of integer;
 
const NumLists: TNumList = (
(5,45,23,21,67),
(43,22,78,46,38),
(9,98,12,98,53));
 
 
type TIntArray = array of integer;
 
procedure GetMinimumCols(NumList: TNumList; var ColMins: TIntArray);
{Get the minimum value is each colum and store in array}
var X,Y: integer;
var Low: integer;
begin
for X:=0 to High(NumLists[0]) do
begin
Low:=High(Integer);
for Y:=0 to High(NumList) do
if NumLists[Y,X]<Low then Low:=NumList[Y,X];
SetLength(ColMins,Length(Colmins)+1);
ColMins[High(ColMins)]:=Low;
end;
end;
 
 
 
procedure ShowColumnMins(Memo: TMemo);
{Show min value for columns in NumLists}
var ColMins: TIntArray;
var I: integer;
var S: string;
begin
GetMinimumCols(NumLists,ColMins);
S:='[';
for I:=0 to High(ColMins) do
begin
if I<>0 then S:=S+' ';
S:=S+IntToStr(ColMins[I]);
end;
S:=S+']';
Memo.Lines.Add(S);
end;
 
 
</syntaxhighlight>
{{out}}
<pre>
[5 22 12 21 38]
 
</pre>
 
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">
// Minimum numbers of three lists. Nigel Galloway: October 26th., 2021
let N1,N2,N3=[5;45;23;21;67],[43;22;78;46;38],[9;98;12;98;53]
printfn "%A" (List.zip3 N1 N2 N3|>List.map(fun(n,g,l)->min (min n g) l))
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 115 ⟶ 646:
=={{header|Factor}}==
{{works with|Factor|0.99 2021-06-02}}
<langsyntaxhighlight lang="factor">USING: arraysmath.order sequences prettyprint ;
 
{ 5 45 23 21 67 } { 43 22 78 46 38 } { 9 98 12 98 53 }
[ min min ] 3map .</langsyntaxhighlight>
{{out}}
<pre>
{ 5 22 12 21 38 }
</pre>
 
=={{header|Fermat}}==
<syntaxhighlight lang="fermat">[numbers1] := [(5,45,23,21,67)];
[numbers2] := [(43,22,78,46,38)];
[numbers3] := [(9,98,12,98,53)];
 
Func Minby( a, b, c, n ) =
if a[n]<b[n] and a[n]<b[n] then Return(a[n]) fi;
if b[n]<c[n] then Return(b[n]) fi;
Return(c[n]).;
for i = 1 to 5 do !!Minby( [numbers1], [numbers2], [numbers3], i ) od;</syntaxhighlight>
 
{{out}}<pre>
5
22
23
21
38
</pre>
 
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">#define min(a, b) Iif(a<b,a,b)
 
dim as integer numbers(1 to 3, 1 to 5) = _
{ {5,45,23,21,67}, {43,22,78,46,38}, {9,98,12,98,53} }
 
for i as uinteger = 1 to 5
print min( numbers(1, i), min(numbers(2,i), numbers(3, i) ) )
next i</syntaxhighlight>
 
{{out}}<pre>
5
22
12
21
38
</pre>
 
=={{header|Go}}==
{{libheader|Go-rcu}}
<langsyntaxhighlight lang="go">package main
 
import (
Line 142 ⟶ 711:
}
fmt.Println(numbers)
}</langsyntaxhighlight>
 
{{out}}
Line 148 ⟶ 717:
[5 22 12 21 38]
</pre>
 
=={{header|Haskell}}==
<syntaxhighlight lang="haskell">import Data.List (transpose)
 
numbers1, numbers2, numbers3 :: [Integer]
numbers1 = [5, 45, 23, 21, 67]
numbers2 = [43, 22, 78, 46, 38]
numbers3 = [9, 98, 12, 98, 53]
 
main :: IO ()
main =
print $
minimum
<$> transpose
[numbers1, numbers2, numbers3]</syntaxhighlight>
{{Out}}
<pre>[5,22,12,21,38]</pre>
 
=={{header|J}}==
<syntaxhighlight lang="j"> ] numbers =. 3 5 $ 5 45 23 21 67 43 22 78 46 38 9 98 12 54 53
5 45 23 21 67
43 22 78 46 38
9 98 12 54 53
 
<./ numbers
5 22 12 21 38</syntaxhighlight>
 
=={{header|JavaScript}}==
<syntaxhighlight lang="javascript">(() => {
"use strict";
 
const main = () => {
const
numbers1 = [5, 45, 23, 21, 67],
numbers2 = [43, 22, 78, 46, 38],
numbers3 = [9, 98, 12, 98, 53];
 
return transpose([
numbers1, numbers2, numbers3
]).map(minimum);
};
 
 
// --------------------- GENERIC ---------------------
 
// min :: Ord a => (a, a) -> a
const min = (a, b) =>
// The lesser of a and b.
b < a ? b : a;
 
 
// minimum :: Ord a => [a] -> a
const minimum = xs =>
// The least value of xs.
0 < xs.length ? (
xs.slice(1).reduce(min, xs[0])
) : null;
 
 
// transpose :: [[a]] -> [[a]]
const transpose = rows =>
// The columns of the input transposed
// into new rows.
// Simpler version of transpose, assuming input
// rows of even length.
0 < rows.length ? rows[0].map(
(_, i) => rows.flatMap(
v => v[i]
)
) : [];
 
// MAIN ---
return JSON.stringify(main());
})();</syntaxhighlight>
{{Out}}
<pre>[5,22,12,21,38]</pre>
 
=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
Two solutions are presented - an iterative one that mirrors the problem description, and one that is functional:<langsyntaxhighlight lang="jq">def numbers1: [ 5, 45, 23, 21, 67];
def numbers2: [43, 22, 78, 46, 38];
def numbers3: [ 9, 98, 12, 98, 53];</langsyntaxhighlight>
'''Mirroring the requirements'''
<langsyntaxhighlight lang="jq">[range(0;5)
| [numbers1[.], numbers2[.], numbers3[.]] | min]</langsyntaxhighlight>
'''Functional solution'''
<langsyntaxhighlight lang="jq">[numbers1, numbers2, numbers3]
| transpose
| map(min)</langsyntaxhighlight>
{{out}}
<pre>
Line 169 ⟶ 814:
=={{header|Julia}}==
Computed in the REPL, using matrix functions.
<langsyntaxhighlight lang="julia">
julia> Numbers1 = [5,45,23,21,67]
5-element Vector{Int64}:
Line 209 ⟶ 854:
21
38
</syntaxhighlight>
</lang>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">Min /@ Transpose@{{5, 45, 23, 21, 67}, {43, 22, 78, 46, 38}, {9, 98,
12, 98, 53}}</syntaxhighlight>
 
{{out}}<pre>
{5,22,12,21,38}
</pre>
 
=={{header|Nim}}==
<syntaxhighlight lang="nim">const
Numbers1 = [ 5, 45, 23, 21, 67]
Numbers2 = [43, 22, 78, 46, 38]
Numbers3 = [ 9, 98, 12, 98, 53]
 
var numbers: array[0..Numbers1.high, int]
 
for i in 0..numbers.high:
numbers[i] = min(min(Numbers1[i], Numbers2[i]), Numbers3[i])
 
echo numbers</syntaxhighlight>
 
{{out}}
<pre>[5, 22, 12, 21, 38]</pre>
 
=={{header|ooRexx}}==
<syntaxhighlight lang="oorexx">/* REXX */
l.1=.array~of( 5, 45, 23, 21, 67)
l.2=.array~of(43, 22, 78, 46, 38)
l.3=.array~of( 9, 98, 12, 98, 53)
o=''
Do i=1 To 5
o=o min(l.1[i],l.2[i],l.3[i])
End
Say strip(o)</syntaxhighlight>
{{out}}
<pre>[5 22 12 21 38]</pre>
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">use strict;
use warnings;
use List::Util 'min';
Line 220 ⟶ 902:
for my $i (0 .. $#{ $lists[0] }) {
print ' ' . min map { $lists[$_][$i] } 0..$#lists;
}</langsyntaxhighlight>
{{out}}
<pre> 5 22 12 21 38</pre>
 
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">N123</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{{</span> <span style="color: #000000;">5</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">45</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">23</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">21</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">67</span><span style="color: #0000FF;">},</span>
<span style="color: #0000FF;">{</span><span style="color: #000000;">43</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">22</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">78</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">46</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">38</span><span style="color: #0000FF;">},</span>
<span style="color: #0000FF;">{</span> <span style="color: #000000;">9</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">98</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">12</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">98</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">53</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;">"%V\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">vslice</span><span style="color: #0000FF;">,{{</span><span style="color: #000000;">N123</span><span style="color: #0000FF;">},</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">5</span><span style="color: #0000FF;">)}),</span><span style="color: #7060A8;">minsq</span><span style="color: #0000FF;">)})</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
{5,22,12,21,38}
</pre>
 
=={{header|Plain English}}==
<syntaxhighlight lang="plainenglish">To run:
Start up.
Create a first list and a second list and a third list.
Find a minimum list (element-wise) of the first list and the second list and the third list.
Destroy the first list. Destroy the second list. Destroy the third list.
Write the minimum list on the console.
Destroy the minimum list.
Wait for the escape key.
Shut down.
 
An entry is a thing with a number.
 
A list is some entries.
 
To add a number to a list:
Allocate memory for an entry.
Put the number into the entry's number.
Append the entry to the list.
 
To create a first list and a second list and a third list:
Add 5 to the first list.
Add 45 to the first list.
Add 23 to the first list.
Add 21 to the first list.
Add 67 to the first list.
Add 43 to the second list.
Add 22 to the second list.
Add 78 to the second list.
Add 46 to the second list.
Add 38 to the second list.
Add 9 to the third list.
Add 98 to the third list.
Add 12 to the third list.
Add 98 to the third list.
Add 53 to the third list.
 
To find a minimum number of a number and another number:
If the number is less than the other number, put the number into the minimum; exit.
Put the other number into the minimum.
 
To find a minimum list (element-wise) of a list and another list and a third list:
Get an entry from the list.
Get another entry from the other list.
Get a third entry from the third list.
Loop.
If the entry is nil, exit.
Find a minimum number of the entry's number and the other entry's number.
Find another minimum number of the third entry's number and the minimum number.
Add the other minimum number to the minimum list.
Put the entry's next into the entry.
Put the other entry's next into the other entry.
Put the third entry's next into the third entry.
Repeat.
 
To write a list on a console;
To write a list to a console:
Get an entry from the list.
Loop.
If the entry is nil, write "" on the console; exit.
Convert the entry's number to a string.
Write the string on the console without advancing.
If the entry's next is not nil, write ", " on the console without advancing.
Put the entry's next into the entry.
Repeat.</syntaxhighlight>
{{out}}
<pre>
5, 22, 12, 21, 38
</pre>
 
=={{header|Python}}==
<syntaxhighlight lang="python">numbers1 = [5,45,23,21,67]
numbers2 = [43,22,78,46,38]
numbers3 = [9,98,12,98,53]
 
numbers = [min(numbers1[i],numbers2[i],numbers3[i]) for i in range(0,len(numbers1))]
 
print(numbers)</syntaxhighlight>
{{Output}}
<pre>[5, 22, 12, 21, 38]</pre>
 
 
Or, in terms of zip:
<syntaxhighlight lang="python">'''Minimum value in each column'''
 
numbers1 = [5, 45, 23, 21, 67]
numbers2 = [43, 22, 78, 46, 38]
numbers3 = [9, 98, 12, 98, 53]
 
print([
min(x) for x
in zip(*[numbers1, numbers2, numbers3])
])</syntaxhighlight>
{{Out}}
<pre>[5, 22, 12, 21, 38]</pre>
 
=={{header|Quackery}}==
 
<code>transpose</code> is defined at [[Matrix transposition#Quackery]].
 
<syntaxhighlight lang="Quackery"> [ ' [ 5 45 23 21 67 ] ] is Numbers1
[ ' [ 43 22 78 46 38 ] ] is Numbers2
[ ' [ 9 98 12 98 53 ] ] is Numbers3
 
[]
Numbers1 nested
Numbers2 nested join
Numbers3 nested join
transpose
witheach
[ behead swap
witheach min
join ]
echo</syntaxhighlight>
 
{{out}}
 
<pre>[ 5 22 12 21 38 ]</pre>
 
=={{header|Raku}}==
<syntaxhighlight lang="raku" perl6line>say [Zmin] (5,45,23,21,67), (43,22,78,46,38), (9,98,12,98,53);</langsyntaxhighlight>
{{out}}
<pre>(5 22 12 21 38)</pre>
 
=={{header|Red}}==
<langsyntaxhighlight lang="rebol">Red [
Red-version: 0.6.4
Description: "Find the element-wise minimum of three lists"
Line 243 ⟶ 1,057:
result/:i: min min numbers1/:i numbers2/:i numbers3/:i
]
print result</langsyntaxhighlight>
{{out}}
<pre>
5 22 12 21 38
</pre>
 
=={{header|REXX}}==
<syntaxhighlight lang="rexx">/* REXX */
w= 5 45 23 21 67 43 22 78 46 38 9 98 12 98 53
Do i=1 To 3
Do j=1 To 5
Parse Var w l.i.j w
End
End
o=''
Do j=1 To 5
o=o min(l.1.j,l.2.j,l.3.j)
End
Say strip(o)</syntaxhighlight>
{{out}}
<pre>5 22 12 21 38</pre>
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">see "? "working..."
 
Num1 = [ 5,45,23,21,67]
Line 268 ⟶ 1,098:
rv = ar[1]
for n = 2 to len(ar) rv += "," + ar[n] next
return "[" + rv + "]"</langsyntaxhighlight>
{{out}}
<pre>
Line 275 ⟶ 1,105:
done...
</pre>
 
=={{header|RPL}}==
≪ → l1 l2 l3
≪ {} 1 l1 SIZE l2 SIZE l3 SIZE MIN MIN '''FOR''' j
l1 j GET l2 j GET l3 j GET MIN MIN + '''NEXT'''
≫ ≫ ‘'''L3MIN'''’ STO
 
{5 45 23 21 67} {43 22 78 46 38} {9 98 12 98 53} '''L3MIN'''
{{out}}
<pre>
1: { 5 22 12 21 38 }
</pre>
 
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">numbers1 = [ 5, 45, 23, 21, 67]
numbers2 = [43, 22, 78, 46, 38]
numbers3 = [ 9, 98, 12, 98, 53]
p [numbers1, numbers2, numbers3].transpose.map(&:min)</syntaxhighlight>
{{out}}
<pre>[5, 22, 12, 21, 38]
</pre>
 
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">var lists = [
[ 5, 45, 23, 21, 67],
[43, 22, 78, 46, 38],
[ 9, 98, 12, 98, 53],
]
 
say lists.zip.map{.min}</syntaxhighlight>
 
{{out}}
<pre>
[5, 22, 12, 21, 38]
</pre>
 
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">import math
fn main() {
numbers1 := [5, 45, 23, 21, 67]!
numbers2 := [43, 22, 78, 46, 38]!
numbers3 := [9, 98, 12, 98, 53]!
mut numbers := [5]int{}
for n in 0..5 {
numbers[n] = math.min<int>(math.min<int>(numbers1[n], numbers2[n]), numbers3[n])
}
println(numbers)
}</syntaxhighlight>
{{out}}
<pre>[5, 22, 12, 21, 38]</pre>
 
=={{header|Wren}}==
<langsyntaxhighlight ecmascriptlang="wren">var numbers1 = [ 5, 45, 23, 21, 67]
var numbers2 = [43, 22, 78, 46, 38]
var numbers3 = [ 9, 98, 12, 98, 53]
var numbers = List.filled(5, 0)
for (n in 0..4) numbers[n] = numbers1[n].min(numbers2[n]).min(numbers3[n])
System.print(numbers)</langsyntaxhighlight>
 
{{out}}
<pre>
[5, 22, 12, 21, 38]
</pre>
 
=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">func Min(A, B);
int A, B;
return if A<B then A else B;
 
int N1, N2, N3, I;
[N1:= [5,45,23,21,67];
N2:= [43,22,78,46,38];
N3:= [9,98,12,98,53];
for I:= 0 to 4 do
[IntOut(0, Min(Min(N1(I), N2(I)), Min(N2(I), N3(I))));
ChOut(0, ^ );
];
]</syntaxhighlight>
 
{{out}}
<pre>
5 22 12 21 38
</pre>
PureFox
9,476

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/316736...355116"