Minimum numbers of three lists: Difference between revisions
m
→{{header|Wren}}: Changed to Wren S/H
m (→{{header|Wren}}: Changed to Wren S/H) |
|||
| (26 intermediate revisions by 19 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}}
<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 # ;
# 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 #
END</
{{out}}
<pre>
Line 56 ⟶ 104:
=={{header|ALGOL W}}==
<
integer array numbers1, numbers2, numbers3 ( 1 :: 5 );
integer pos;
Line 69 ⟶ 117:
writeon( i_w := 1, s_w := 0, " ", m )
end for_i;
end.</
{{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 {
Line 93 ⟶ 176:
}
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}}==
<
int min(int a, int b) {
Line 119 ⟶ 567:
printf("\n");
return 0;
}</
{{out}}
Line 125 ⟶ 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#}}==
<
// 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>
{{out}}
<pre>
Line 139 ⟶ 646:
=={{header|Factor}}==
{{works with|Factor|0.99 2021-06-02}}
<
{ 5 45 23 21 67 } { 43 22 78 46 38 } { 9 98 12 98 53 }
[ min min ] 3map .</
{{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}}
<
import (
Line 166 ⟶ 711:
}
fmt.Println(numbers)
}</
{{out}}
Line 172 ⟶ 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:<
def numbers2: [43, 22, 78, 46, 38];
def numbers3: [ 9, 98, 12, 98, 53];</
'''Mirroring the requirements'''
<
| [numbers1[.], numbers2[.], numbers3[.]] | min]</
'''Functional solution'''
<
| transpose
| map(min)</
{{out}}
<pre>
Line 193 ⟶ 814:
=={{header|Julia}}==
Computed in the REPL, using matrix functions.
<
julia> Numbers1 = [5,45,23,21,67]
5-element Vector{Int64}:
Line 233 ⟶ 854:
21
38
</syntaxhighlight>
=={{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}}==
<
Numbers1 = [ 5, 45, 23, 21, 67]
Numbers2 = [43, 22, 78, 46, 38]
Line 246 ⟶ 874:
numbers[i] = min(min(Numbers1[i], Numbers2[i]), Numbers3[i])
echo numbers</
{{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}}==
<
use warnings;
use List::Util 'min';
Line 260 ⟶ 902:
for my $i (0 .. $#{ $lists[0] }) {
print ' ' . min map { $lists[$_][$i] } 0..$#lists;
}</
{{out}}
<pre> 5 22 12 21 38</pre>
=={{header|Phix}}==
<!--<
<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>
Line 271 ⟶ 913:
<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>
<!--</
{{out}}
<pre>
Line 278 ⟶ 920:
=={{header|Plain English}}==
<
Start up.
Create a first list and a second list and a third list.
Line 341 ⟶ 983:
If the entry's next is not nil, write ", " on the console without advancing.
Put the entry's next into the entry.
Repeat.</
{{out}}
<pre>
Line 348 ⟶ 990:
=={{header|Python}}==
<
numbers2 = [43,22,78,46,38]
numbers3 = [9,98,12,98,53]
Line 354 ⟶ 996:
numbers = [min(numbers1[i],numbers2[i],numbers3[i]) for i in range(0,len(numbers1))]
print(numbers)</
{{Output}}
<pre>[5, 22, 12, 21, 38]</pre>
Or, in terms of zip:
<
numbers1 = [5, 45, 23, 21, 67]
Line 368 ⟶ 1,011:
min(x) for x
in zip(*[numbers1, numbers2, numbers3])
])</
{{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"
{{out}}
<pre>(5 22 12 21 38)</pre>
=={{header|Red}}==
<
Red-version: 0.6.4
Description: "Find the element-wise minimum of three lists"
Line 391 ⟶ 1,057:
result/:i: min min numbers1/:i numbers2/:i numbers3/:i
]
print result</
{{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}}==
<
Num1 = [ 5,45,23,21,67]
Line 416 ⟶ 1,098:
rv = ar[1]
for n = 2 to len(ar) rv += "," + ar[n] next
return "[" + rv + "]"</
{{out}}
<pre>
Line 422 ⟶ 1,104:
The minimum numbers of three lists = [5,22,12,21,38]
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}}==
<
numbers2 = [43, 22, 78, 46, 38]
numbers3 = [ 9, 98, 12, 98, 53]
p [numbers1, numbers2, numbers3].transpose.map(&:min)</
{{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}}==
<
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)</
{{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>
| |||