Last list item: Difference between revisions
Walterpachl (talk | contribs) m (add REXX) |
(Added Easylang) |
||
(54 intermediate revisions by 29 users not shown) | |||
Line 6: | Line 6: | ||
<br>Repeat until the list contains one element. |
<br>Repeat until the list contains one element. |
||
<br>Show the steps and last item on this page. |
<br>Show the steps and last item on this page. |
||
<br>Show the unsorted list in output |
<br>Show the unsorted list in output in case "Without sort" |
||
<br><br> |
<br><br> |
||
=={{header|11l}}== |
|||
{{trans|Python}} |
|||
<syntaxhighlight lang="11l">F add_least_reduce(&lis) |
|||
L lis.len > 1 |
|||
V el1 = lis.pop(lis.index(min(lis))) |
|||
V el2 = lis.pop(lis.index(min(lis))) |
|||
lis.append(el1 + el2) |
|||
print(‘Interim list: ’lis) |
|||
R lis |
|||
V LIST = [6, 81, 243, 14, 25, 49, 123, 69, 11] |
|||
print(LIST‘ ==> ’add_least_reduce(©(LIST)))</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Interim list: [81, 243, 14, 25, 49, 123, 69, 17] |
|||
Interim list: [81, 243, 25, 49, 123, 69, 31] |
|||
Interim list: [81, 243, 49, 123, 69, 56] |
|||
Interim list: [81, 243, 123, 69, 105] |
|||
Interim list: [243, 123, 105, 150] |
|||
Interim list: [243, 150, 228] |
|||
Interim list: [243, 378] |
|||
Interim list: [621] |
|||
[6, 81, 243, 14, 25, 49, 123, 69, 11] ==> [621] |
|||
</pre> |
|||
=={{header|Ada}}== |
|||
===With sorting=== |
|||
<syntaxhighlight lang="ada">with Ada.Text_IO; |
|||
with Ada.Containers.Vectors; |
|||
procedure Last_List_Item_Sorted is |
|||
package Integer_IO is new Ada.Text_IO.Integer_IO (Integer); |
|||
package Vectors is |
|||
new Ada.Containers.Vectors (Index_Type => Positive, |
|||
Element_Type => Integer); |
|||
package Vector_Sorting is |
|||
new Vectors.Generic_Sorting; |
|||
use Ada.Containers, Vectors, Ada.Text_IO, Integer_IO; |
|||
procedure Put (List : Vector) is |
|||
begin |
|||
Put ("["); |
|||
for V of List loop |
|||
Put (" "); Put (V, Width => 0); |
|||
end loop; |
|||
Put ("]"); |
|||
end Put; |
|||
List : Vector := 6 & 81 & 243 & 14 & 25 & 49 & 123 & 69 & 11; |
|||
begin |
|||
Default_Width := 0; |
|||
while List.Length >= 2 loop |
|||
Vector_Sorting.Sort (List); |
|||
Put (List); |
|||
declare |
|||
Small_1 : constant Integer := List (List.First_Index + 0); |
|||
Small_2 : constant Integer := List (List.First_Index + 1); |
|||
Sum : constant Integer := Small_1 + Small_2; |
|||
begin |
|||
List.Delete_First (2); |
|||
Put (". Smallest: "); Put (Small_1); Put (" and "); Put (Small_2); |
|||
Put (". Sum: "); Put (Sum); New_Line; |
|||
List.Append (Sum); |
|||
end; |
|||
end loop; |
|||
Put (List); New_Line; |
|||
end Last_List_Item_Sorted;</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
[ 6 11 14 25 49 69 81 123 243]. Smallest: 6 and 11. Sum: 17 |
|||
[ 14 17 25 49 69 81 123 243]. Smallest: 14 and 17. Sum: 31 |
|||
[ 25 31 49 69 81 123 243]. Smallest: 25 and 31. Sum: 56 |
|||
[ 49 56 69 81 123 243]. Smallest: 49 and 56. Sum: 105 |
|||
[ 69 81 105 123 243]. Smallest: 69 and 81. Sum: 150 |
|||
[ 105 123 150 243]. Smallest: 105 and 123. Sum: 228 |
|||
[ 150 228 243]. Smallest: 150 and 228. Sum: 378 |
|||
[ 243 378]. Smallest: 243 and 378. Sum: 621 |
|||
[ 621] |
|||
</pre> |
|||
===Without sorting=== |
|||
<syntaxhighlight lang="ada">with Ada.Text_IO; |
|||
with Ada.Containers.Vectors; |
|||
procedure Last_List_Item is |
|||
package Integer_IO is new Ada.Text_IO.Integer_IO (Integer); |
|||
package Element_Vectors is |
|||
new Ada.Containers.Vectors (Index_Type => Positive, |
|||
Element_Type => Integer); |
|||
use Ada.Containers, Element_Vectors, Ada.Text_IO, Integer_IO; |
|||
function Pick_Smallest (List : in out Vector) return Integer is |
|||
Value : Integer := Integer'Last; |
|||
begin |
|||
if List.Is_Empty then |
|||
raise Constraint_Error; |
|||
end if; |
|||
for V of List loop |
|||
Value := Integer'Min (Value, V); |
|||
end loop; |
|||
List.Delete (List.Find_Index (Value)); |
|||
return Value; |
|||
end Pick_Smallest; |
|||
procedure Put (List : Vector) is |
|||
begin |
|||
Put ("["); |
|||
for V of List loop |
|||
Put (" "); Put (V, Width => 0); |
|||
end loop; |
|||
Put ("]"); |
|||
end Put; |
|||
List : Vector := 6 & 81 & 243 & 14 & 25 & 49 & 123 & 69 & 11; |
|||
begin |
|||
Default_Width := 0; |
|||
while List.Length >= 2 loop |
|||
Put (List); Put (". Smallest: "); |
|||
declare |
|||
Small_1 : constant Integer := Pick_Smallest (List); |
|||
Small_2 : constant Integer := Pick_Smallest (List); |
|||
Sum : constant Integer := Small_1 + Small_2; |
|||
begin |
|||
Put (Small_1); Put (" and "); Put (Small_2); |
|||
Put (". Sum: "); Put (Sum); New_Line; |
|||
List.Append (Sum); |
|||
end; |
|||
end loop; |
|||
Put (List); New_Line; |
|||
end Last_List_Item;</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
[ 6 81 243 14 25 49 123 69 11]. Smallest: 6 and 11. Sum: 17 |
|||
[ 81 243 14 25 49 123 69 17]. Smallest: 14 and 17. Sum: 31 |
|||
[ 81 243 25 49 123 69 31]. Smallest: 25 and 31. Sum: 56 |
|||
[ 81 243 49 123 69 56]. Smallest: 49 and 56. Sum: 105 |
|||
[ 81 243 123 69 105]. Smallest: 69 and 81. Sum: 150 |
|||
[ 243 123 105 150]. Smallest: 105 and 123. Sum: 228 |
|||
[ 243 150 228]. Smallest: 150 and 228. Sum: 378 |
|||
[ 243 378]. Smallest: 243 and 378. Sum: 621 |
|||
[ 621] |
|||
</pre> |
|||
=={{header|ALGOL 68}}== |
=={{header|ALGOL 68}}== |
||
===With sorting=== |
|||
{{Trans|Wren}} |
|||
{{trans|Wren}} |
|||
<lang algol68>BEGIN # find the last element after repeatedely adding the sum # |
|||
{{libheader|ALGOL 68-rows}} |
|||
<syntaxhighlight lang="algol68">BEGIN # find the last element after repeatedely adding the sum # |
|||
# of the two smallest elements and removing them # |
# of the two smallest elements and removing them # |
||
PR read "rows.incl.a68" PR # row related utilities # |
|||
# Quicksorts in-place the array of integers a, from lb to ub # |
|||
PROC quicksort = ( REF[]INT a, INT lb, ub )VOID: |
|||
IF ub > lb THEN |
|||
# more than one element, so must sort # |
|||
INT left := lb; |
|||
INT right := ub; |
|||
# choosing the middle element of the array as the pivot # |
|||
INT pivot := a[ left + ( ( right + 1 ) - left ) OVER 2 ]; |
|||
WHILE |
|||
WHILE IF left <= ub THEN a[ left ] < pivot ELSE FALSE FI DO left +:= 1 OD; |
|||
WHILE IF right >= lb THEN a[ right ] > pivot ELSE FALSE FI DO right -:= 1 OD; |
|||
left <= right |
|||
DO |
|||
INT t := a[ left ]; |
|||
a[ left ] := a[ right ]; |
|||
a[ right ] := t; |
|||
left +:= 1; |
|||
right -:= 1 |
|||
OD; |
|||
quicksort( a, lb, right ); |
|||
quicksort( a, left, ub ) |
|||
FI # quicksort # ; |
|||
[ 1 : 9 ]INT a := ( 6, 81, 243, 14, 25, 49, 123, 69, 11 ); |
[ 1 : 9 ]INT a := ( 6, 81, 243, 14, 25, 49, 123, 69, 11 ); |
||
INT a count := UPB a; |
INT a count := UPB a; |
||
WHILE a count > 1 DO |
WHILE a count > 1 DO |
||
QUICKSORT a FROMELEMENT LWB a TOELEMENT a count; |
|||
print( ( "Sorted list:" ) );FOR i TO a count DO print( ( " ", whole( a[ i ], 0 ) ) ) OD; |
print( ( "Sorted list:" ) );FOR i TO a count DO print( ( " ", whole( a[ i ], 0 ) ) ) OD; |
||
print( ( newline ) ); |
|||
INT sum = a[ 1 ] + a[ 2 ]; |
INT sum = a[ 1 ] + a[ 2 ]; |
||
print( ( " |
print( ( "; two smallest: " , whole( a[ 1 ], 0 ) |
||
, " + ", whole( a[ 2 ], 0 ) |
, " + ", whole( a[ 2 ], 0 ) |
||
, " = ", whole( sum, 0 ) |
, " = ", whole( sum, 0 ) |
||
Line 49: | Line 183: | ||
) |
) |
||
); |
); |
||
a[ 2 ] := |
a[ 1 : a count - 2 ] := a[ 3 : a count ]; |
||
a |
a count -:= 1 ; |
||
a[ a count ] := sum |
|||
OD; |
|||
print( ( "Last item is ", whole( a[ 1 ], 0 ), ".", newline ) ) |
|||
END</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Sorted list: 6 11 14 25 49 69 81 123 243; two smallest: 6 + 11 = 17 |
|||
Sorted list: 14 17 25 49 69 81 123 243; two smallest: 14 + 17 = 31 |
|||
Sorted list: 25 31 49 69 81 123 243; two smallest: 25 + 31 = 56 |
|||
Sorted list: 49 56 69 81 123 243; two smallest: 49 + 56 = 105 |
|||
Sorted list: 69 81 105 123 243; two smallest: 69 + 81 = 150 |
|||
Sorted list: 105 123 150 243; two smallest: 105 + 123 = 228 |
|||
Sorted list: 150 228 243; two smallest: 150 + 228 = 378 |
|||
Sorted list: 243 378; two smallest: 243 + 378 = 621 |
|||
Last item is 621. |
|||
</pre> |
|||
===Without sorting=== |
|||
Translation of the sorted Wren version with the sorting removed. |
|||
<syntaxhighlight lang="algol68">BEGIN # find the last element after repeatedly adding the sum # |
|||
# of the two smallest elements and removing them # |
|||
[ 1 : 9 ]INT a := ( 6, 81, 243, 14, 25, 49, 123, 69, 11 ); |
|||
INT a count := UPB a; |
|||
WHILE a count > 1 DO |
|||
print( ( "List:" ) );FOR i TO a count DO print( ( " ", whole( a[ i ], 0 ) ) ) OD; |
|||
INT s1pos, s2pos; |
|||
IF a[ 1 ] < a[ 2 ] |
|||
THEN s1pos := 1; s2pos := 2 |
|||
ELSE s1pos := 2; s2pos := 1 |
|||
FI; |
|||
FOR i FROM 3 TO a count DO |
|||
IF a[ i ] < a[ s1pos ] THEN s2pos := s1pos; s1pos := i |
|||
ELIF a[ i ] < a[ s2pos ] THEN s2pos := i |
|||
FI |
|||
OD; |
|||
INT sum = a[ s1pos ] + a[ s2pos ]; |
|||
print( ( "; two smallest: " , whole( a[ s1pos ], 0 ), " @ ", whole( s1pos, 0 ) |
|||
, " and ", whole( a[ s2pos ], 0 ), " @ ", whole( s2pos, 0 ) |
|||
, "; sum = ", whole( sum, 0 ) |
|||
, newline |
|||
) |
|||
); |
|||
INT m pos := 0; |
|||
FOR i TO a count DO |
|||
IF i /= s1pos AND i /= s2pos THEN a[ m pos +:= 1 ] := a[ i ] FI |
|||
OD; |
|||
a[ m pos + 1 ] := sum; |
|||
a count -:= 1 |
a count -:= 1 |
||
OD; |
OD; |
||
print( ( "Last item is ", whole( a[ 1 ], 0 ), ".", newline ) ) |
print( ( "Last item is ", whole( a[ 1 ], 0 ), ".", newline ) ) |
||
END</ |
END</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
List: 6 81 243 14 25 49 123 69 11; two smallest: 6 @ 1 and 11 @ 9; sum = 17 |
|||
List: 81 243 14 25 49 123 69 17; two smallest: 14 @ 3 and 17 @ 8; sum = 31 |
|||
List: 81 243 25 49 123 69 31; two smallest: 25 @ 3 and 31 @ 7; sum = 56 |
|||
Sorted list: 14 17 25 49 69 81 123 243 |
|||
List: 81 243 49 123 69 56; two smallest: 49 @ 3 and 56 @ 6; sum = 105 |
|||
List: 81 243 123 69 105; two smallest: 69 @ 4 and 81 @ 1; sum = 150 |
|||
Sorted list: 25 31 49 69 81 123 243 |
|||
List: 243 123 105 150; two smallest: 105 @ 3 and 123 @ 2; sum = 228 |
|||
List: 243 150 228; two smallest: 150 @ 2 and 228 @ 3; sum = 378 |
|||
Sorted list: 49 56 69 81 123 243 |
|||
List: 243 378; two smallest: 243 @ 1 and 378 @ 2; sum = 621 |
|||
Sorted list: 69 81 105 123 243 |
|||
Two smallest: 69 + 81 = 150 |
|||
Sorted list: 105 123 150 243 |
|||
Two smallest: 105 + 123 = 228 |
|||
Sorted list: 150 228 243 |
|||
Two smallest: 150 + 228 = 378 |
|||
Sorted list: 243 378 |
|||
Two smallest: 243 + 378 = 621 |
|||
Last item is 621. |
Last item is 621. |
||
</pre> |
</pre> |
||
=={{header|Applesoft BASIC}}== |
|||
<syntaxhighlight lang="gwbasic"> 100 DATA 6, 81, 243, 14, 25, 49, 123, 69, 11 |
|||
110 FOR L = 0 TO 8 |
|||
120 READ L(L) |
|||
130 NEXT |
|||
140 LET L = L - 1 |
|||
150 GOSUB 180"LAST LIST ITEM" |
|||
160 GOSUB 250"PRINT LIST" |
|||
170 END |
|||
180 IF L = 0 THEN RETURN |
|||
190 FOR L = L TO 0 STEP 0 |
|||
200 GOSUB 340"FIND THE 2 SMALLEST" |
|||
210 LET L = L + 1 |
|||
220 LET L(L) = PREVIOUSSMALLEST + SMALLEST |
|||
230 NEXT L |
|||
240 RETURN |
|||
250 PRINT |
|||
260 LET H = 1 |
|||
270 FOR I = 0 TO L |
|||
280 IF NOT H(I) THEN H(I) = H |
|||
290 LET H = H(I) + LEN ( STR$ (L(I))) + 1 |
|||
300 HTAB H(I) |
|||
310 PRINT L(I)" "; |
|||
320 NEXT I |
|||
330 RETURN |
|||
340 GOSUB 250"PRINT LIST" |
|||
350 GOSUB 370"FIND SMALLEST" |
|||
360 LET PREVIOUSSMALLEST = SMALLEST |
|||
370 LET S = 0 |
|||
380 FOR I = 0 TO L |
|||
390 LET SMALLEST = L(S) |
|||
400 IF L(I) < SMALLEST THEN S = I |
|||
410 NEXT I |
|||
420 LET SMALLEST = L(S) |
|||
430 LET L = L - 1 |
|||
440 IF S > L THEN RETURN |
|||
450 FOR I = S TO L |
|||
460 LET L(I) = L(I + 1) |
|||
470 LET H(I) = H(I + 1) |
|||
480 NEXT I |
|||
490 RETURN</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
6 81 243 14 25 49 123 69 11 |
|||
81 243 14 25 49 123 69 17 |
|||
81 243 25 49 123 69 31 |
|||
81 243 49 123 69 56 |
|||
81 243 123 69 105 |
|||
243 123 105 150 |
|||
243 150 228 |
|||
243 378 |
|||
621 |
|||
</pre> |
|||
=={{header|AppleScript}}== |
|||
<syntaxhighlight lang="applescript">on lastListItem(lst) |
|||
set astid to AppleScript's text item delimiters |
|||
set AppleScript's text item delimiters to ", " |
|||
set output to {"Steps:", "{" & lst & "} ← Original"} |
|||
set len to (count lst) |
|||
if (len > 1) then |
|||
repeat with len from len to 3 by -1 |
|||
set {i, j} to {1, 2} |
|||
set {s1, s2} to lst |
|||
if (s2 < s1) then set {i, s1, j, s2} to {j, s2, i, s1} |
|||
repeat with k from 3 to len |
|||
set v to lst's item k |
|||
if (v < s1) then |
|||
set {i, s1, j, s2} to {k, v, i, s1} |
|||
else if (v < s2) then |
|||
set {j, s2} to {k, v} |
|||
end if |
|||
end repeat |
|||
tell lst to set {item i, item j} to {missing value, missing value} |
|||
set lst to lst's numbers |
|||
set lst's end to s1 + s2 |
|||
set output's end to "{" & lst & "} ← " & s1 & " + " & s2 & " = " & result |
|||
end repeat |
|||
tell lst to set end of output to "{" & (beginning + end) & "} ← " & beginning & " + " & end & " = " & (beginning + end) |
|||
end if |
|||
set AppleScript's text item delimiters to linefeed |
|||
set output to output as text |
|||
set AppleScript's text item delimiters to astid |
|||
return output |
|||
end lastListItem |
|||
lastListItem({6, 81, 243, 14, 25, 49, 123, 69, 11})</syntaxhighlight> |
|||
{{output}} |
|||
<syntaxhighlight lang="applescript">"Steps: |
|||
{6, 81, 243, 14, 25, 49, 123, 69, 11} ← Original |
|||
{81, 243, 14, 25, 49, 123, 69, 17} ← 6 + 11 = 17 |
|||
{81, 243, 25, 49, 123, 69, 31} ← 14 + 17 = 31 |
|||
{81, 243, 49, 123, 69, 56} ← 25 + 31 = 56 |
|||
{81, 243, 123, 69, 105} ← 49 + 56 = 105 |
|||
{243, 123, 105, 150} ← 69 + 81 = 150 |
|||
{243, 150, 228} ← 105 + 123 = 228 |
|||
{243, 378} ← 150 + 228 = 378 |
|||
{621} ← 243 + 378 = 621"</syntaxhighlight> |
|||
=={{header|Arturo}}== |
|||
<syntaxhighlight lang="arturo">lst: [6 81 243 14 25 49 123 69 11] |
|||
initial: lst |
|||
while [1 < size lst][ |
|||
remove 'lst min1: <= min lst |
|||
remove 'lst min2: <= min lst |
|||
append 'lst min1 + min2 |
|||
print ["List:" lst] |
|||
] |
|||
print "" |
|||
print [initial "=>" lst]</syntaxhighlight> |
|||
{{out}} |
|||
<pre>List: [81 243 14 25 49 123 69 17] |
|||
List: [81 243 25 49 123 69 31] |
|||
List: [81 243 49 123 69 56] |
|||
List: [81 243 123 69 105] |
|||
List: [243 123 105 150] |
|||
List: [243 150 228] |
|||
List: [243 378] |
|||
List: [621] |
|||
[6 81 243 14 25 49 123 69 11] => [621]</pre> |
|||
=={{header|AutoHotkey}}== |
|||
<syntaxhighlight lang="autohotkey">List := [6, 81, 243, 14, 25, 49, 123, 69, 11] |
|||
steps := "Initial List `t`t`t" List2str(List) "`n" |
|||
while List.Count() > 1 |
|||
{ |
|||
sum := 0, str := "" |
|||
loop 2 |
|||
{ |
|||
num := min(List*) |
|||
sum += num |
|||
removeFromList(List, num) |
|||
str .= (!str ? "2 smallest numbers: " : " + ") num |
|||
} |
|||
List.Push(sum) |
|||
steps .= str " = " sum "`t" List2str(List) "`n" |
|||
} |
|||
MsgBox % result := steps |
|||
return |
|||
removeFromList(ByRef List, num){ |
|||
for i, v in List |
|||
if (v = num) |
|||
{ |
|||
List.RemoveAt(i) |
|||
break |
|||
} |
|||
} |
|||
List2str(List){ |
|||
for i, v in List |
|||
unsorted_List .= v ", " |
|||
return "[" Trim(unsorted_List, ", ") "]" |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Initial List [6, 81, 243, 14, 25, 49, 123, 69, 11] |
|||
2 smallest numbers: 6 + 11 = 17 [81, 243, 14, 25, 49, 123, 69, 17] |
|||
2 smallest numbers: 14 + 17 = 31 [81, 243, 25, 49, 123, 69, 31] |
|||
2 smallest numbers: 25 + 31 = 56 [81, 243, 49, 123, 69, 56] |
|||
2 smallest numbers: 49 + 56 = 105 [81, 243, 123, 69, 105] |
|||
2 smallest numbers: 69 + 81 = 150 [243, 123, 105, 150] |
|||
2 smallest numbers: 105 + 123 = 228 [243, 150, 228] |
|||
2 smallest numbers: 150 + 228 = 378 [243, 378] |
|||
2 smallest numbers: 243 + 378 = 621 [621]</pre> |
|||
=={{header|AWK}}== |
|||
<syntaxhighlight lang="awk"> |
|||
# syntax: GAWK -f LAST_LIST_ITEM.AWK |
|||
BEGIN { |
|||
split("6,81,243,14,25,49,123,69,11",arr1,",") |
|||
PROCINFO["sorted_in"] = "@val_num_asc" |
|||
while (length(arr1) > 1) { |
|||
for (i in arr1) { printf("%s ",arr1[i]) } # show sorted list |
|||
j = 0 |
|||
delete arr2 |
|||
for (i in arr1) { arr2[++j] = arr1[i] } # copy arr1 into arr2 |
|||
sum = arr2[1] + arr2[2] |
|||
printf(": %s+%s=%s\n",arr2[1],arr2[2],sum) |
|||
delete arr2[2] |
|||
arr2[1] = sum |
|||
delete arr1 |
|||
for (i in arr2) { arr1[i] = arr2[i] } # copy arr2 into arr1 |
|||
} |
|||
printf("sum=%d\n",sum) |
|||
exit(0) |
|||
} |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
6 11 14 25 49 69 81 123 243 : 6+11=17 |
|||
14 17 25 49 69 81 123 243 : 14+17=31 |
|||
25 31 49 69 81 123 243 : 25+31=56 |
|||
49 56 69 81 123 243 : 49+56=105 |
|||
69 81 105 123 243 : 69+81=150 |
|||
105 123 150 243 : 105+123=228 |
|||
150 228 243 : 150+228=378 |
|||
243 378 : 243+378=621 |
|||
sum=621 |
|||
</pre> |
|||
=={{header|BQN}}== |
|||
===With and without sorting=== |
|||
<syntaxhighlight lang="bqn">list ← ⟨6, 81, 243, 14, 25, 49, 123, 69, 11⟩ |
|||
W_sort ← {{i←2↑∧𝕩, (𝕩/˜¬𝕩∊i)∾+´i}⍟(↕≠𝕩)𝕩} |
|||
WO_sort ← {{m←⌊´𝕩, n←⌊´𝕩/˜¬m=𝕩, (𝕩/˜¬𝕩∊m‿n)∾m+n}⍟(↕≠𝕩)𝕩} |
|||
•Show¨W_sort list |
|||
•Show¨WO_sort list</syntaxhighlight> |
|||
<syntaxhighlight lang="text">⟨ 6 81 243 14 25 49 123 69 11 ⟩ |
|||
⟨ 81 243 14 25 49 123 69 17 ⟩ |
|||
⟨ 81 243 25 49 123 69 31 ⟩ |
|||
⟨ 81 243 49 123 69 56 ⟩ |
|||
⟨ 81 243 123 69 105 ⟩ |
|||
⟨ 243 123 105 150 ⟩ |
|||
⟨ 243 150 228 ⟩ |
|||
⟨ 243 378 ⟩ |
|||
⟨ 621 ⟩ |
|||
⟨ 6 81 243 14 25 49 123 69 11 ⟩ |
|||
⟨ 81 243 14 25 49 123 69 17 ⟩ |
|||
⟨ 81 243 25 49 123 69 31 ⟩ |
|||
⟨ 81 243 49 123 69 56 ⟩ |
|||
⟨ 81 243 123 69 105 ⟩ |
|||
⟨ 243 123 105 150 ⟩ |
|||
⟨ 243 150 228 ⟩ |
|||
⟨ 243 378 ⟩ |
|||
⟨ 621 ⟩</syntaxhighlight> |
|||
=={{header|C}}== |
=={{header|C}}== |
||
===With sorting=== |
===With sorting=== |
||
{{trans|Wren}} |
{{trans|Wren}} |
||
< |
<syntaxhighlight lang="c">#include <stdio.h> |
||
#include <stdlib.h> |
#include <stdlib.h> |
||
Line 108: | Line 520: | ||
printf("Last item is %d.\n", a[0]); |
printf("Last item is %d.\n", a[0]); |
||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 132: | Line 544: | ||
===Without sorting=== |
===Without sorting=== |
||
< |
<syntaxhighlight lang="c">#include <stdio.h> |
||
int findMin(int a[], int asize, int *pmin) { |
int findMin(int a[], int asize, int *pmin) { |
||
Line 168: | Line 580: | ||
printf("Last item is %d.\n", a[0]); |
printf("Last item is %d.\n", a[0]); |
||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 190: | Line 602: | ||
Last item is 621. |
Last item is 621. |
||
</pre> |
</pre> |
||
=={{header|C++}}== |
|||
<syntaxhighlight lang="cpp">#include <iostream> |
|||
#include <list> |
|||
using namespace std; |
|||
void PrintContainer(const auto& container) |
|||
{ |
|||
cout << "[ "; |
|||
for_each(container.begin(), container.end(), [](auto item){cout << item << " ";}); |
|||
cout << "]"; |
|||
} |
|||
int main() |
|||
{ |
|||
list<int> numbers{6, 81, 243, 14, 25, 49, 123, 69, 11}; |
|||
// a lambda to remove the minimum item |
|||
auto removeMin = [](auto& container) |
|||
{ |
|||
auto minIterator = min_element(container.begin(), container.end()); |
|||
auto minValue = *minIterator; |
|||
container.erase(minIterator); |
|||
return minValue; |
|||
}; |
|||
while(numbers.size() > 1) |
|||
{ |
|||
PrintContainer(numbers); |
|||
auto minValue = removeMin(numbers); |
|||
auto nextMinValue = removeMin(numbers); |
|||
auto sum = minValue + nextMinValue; |
|||
numbers.push_back(sum); |
|||
cout << " => " << minValue << " + " << nextMinValue << " = " << sum << "\n"; |
|||
} |
|||
cout << "Final list: "; PrintContainer(numbers); cout << "\n"; |
|||
} |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
[ 6 81 243 14 25 49 123 69 11 ] => 6 + 11 = 17 |
|||
[ 81 243 14 25 49 123 69 17 ] => 14 + 17 = 31 |
|||
[ 81 243 25 49 123 69 31 ] => 25 + 31 = 56 |
|||
[ 81 243 49 123 69 56 ] => 49 + 56 = 105 |
|||
[ 81 243 123 69 105 ] => 69 + 81 = 150 |
|||
[ 243 123 105 150 ] => 105 + 123 = 228 |
|||
[ 243 150 228 ] => 150 + 228 = 378 |
|||
[ 243 378 ] => 243 + 378 = 621 |
|||
Final list: [ 621 ] |
|||
</pre> |
|||
=={{header|Delphi}}== |
|||
{{works with|Delphi|6.0}} |
|||
{{libheader|SysUtils,StdCtrls}} |
|||
Uses standard Delphi object "TList" to manipulate the array. |
|||
<syntaxhighlight lang="Delphi"> |
|||
procedure FindSmallest(LS: TList; var Index,Value: Integer); |
|||
{Find smallest value in LIst} |
|||
var I: integer; |
|||
begin |
|||
Value:=High(integer); |
|||
for I:=0 to LS.Count-1 do |
|||
if integer(LS[I])<Value then |
|||
begin |
|||
Value:=integer(LS[I]); |
|||
Index:=I; |
|||
end; |
|||
end; |
|||
procedure ShowArray(Memo: TMemo; LS: TList); |
|||
{Display the contents of specified array} |
|||
var I: integer; |
|||
var S: string; |
|||
begin |
|||
S:='['; |
|||
for I:=0 to LS.Count-1 do |
|||
begin |
|||
if I>0 then S:=S+' '; |
|||
S:=S+IntToStr(Integer(LS[I])); |
|||
end; |
|||
S:=S+']'; |
|||
Memo.Lines.Add(S); |
|||
end; |
|||
procedure LastItem(Memo: TMemo; IA: array of integer); |
|||
{Repeatedly remove the two lowest values} |
|||
{Add them together and add to the list} |
|||
var LS: TList; |
|||
var I,Inx,Val1,Val2: integer; |
|||
begin |
|||
LS:=TList.Create; |
|||
try |
|||
for I:=0 to High(IA) do LS.Add(Pointer(IA[I])); |
|||
while LS.Count>1 do |
|||
begin |
|||
ShowArray(Memo,LS); |
|||
FindSmallest(LS,Inx,Val1); |
|||
LS.Delete(Inx); |
|||
FindSmallest(LS,Inx,Val2); |
|||
LS.Delete(Inx); |
|||
LS.Add(Pointer(Val1 + Val2)) |
|||
end; |
|||
Memo.Lines.Add(IntToStr(integer(LS[0]))); |
|||
finally LS.Free; end; |
|||
end; |
|||
{Supplied test array} |
|||
const IntArray: array [0..8] of integer=(6, 81, 243, 14, 25, 49, 123, 69, 11); |
|||
procedure DoLastItem(Memo: TMemo); |
|||
{Do last item problem} |
|||
begin |
|||
LastItem(Memo,IntArray); |
|||
end; |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
[6 81 243 14 25 49 123 69 11] |
|||
[81 243 14 25 49 123 69 17] |
|||
[81 243 25 49 123 69 31] |
|||
[81 243 49 123 69 56] |
|||
[81 243 123 69 105] |
|||
[243 123 105 150] |
|||
[243 150 228] |
|||
[243 378] |
|||
621 |
|||
</pre> |
|||
=={{header|EasyLang}}== |
|||
<syntaxhighlight> |
|||
l[] = [ 6 81 243 14 25 49 123 69 11 ] |
|||
while len l[] > 1 |
|||
sum = 0 |
|||
for k to 2 |
|||
for i to len l[] - 1 |
|||
if l[i] < l[$] |
|||
swap l[i] l[$] |
|||
. |
|||
. |
|||
sum += l[$] |
|||
len l[] -1 |
|||
. |
|||
l[] &= sum |
|||
print l[] |
|||
. |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
[ 69 81 243 14 25 49 123 17 ] |
|||
[ 123 81 243 69 25 49 31 ] |
|||
[ 123 81 243 69 49 56 ] |
|||
[ 123 81 243 69 105 ] |
|||
[ 123 105 243 150 ] |
|||
[ 243 150 228 ] |
|||
[ 243 378 ] |
|||
[ 621 ] |
|||
</pre> |
|||
=={{header|Factor}}== |
=={{header|Factor}}== |
||
{{works with|Factor|0.99 2021-06-02}} |
{{works with|Factor|0.99 2021-06-02}} |
||
< |
<syntaxhighlight lang="factor">USING: formatting io kernel math math.statistics prettyprint |
||
sequences sequences.extras ; |
sequences sequences.extras ; |
||
Line 211: | Line 791: | ||
V{ 6 81 243 14 25 49 123 69 11 } |
V{ 6 81 243 14 25 49 123 69 11 } |
||
[ dup length 1 > ] [ dup list. step ] while |
[ dup length 1 > ] [ dup list. step ] while |
||
last "Last item is %d.\n" printf</ |
last "Last item is %d.\n" printf</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 231: | Line 811: | ||
Two smallest: 243 + 378 = 621 |
Two smallest: 243 + 378 = 621 |
||
Last item is 621. |
Last item is 621. |
||
</pre> |
|||
=={{header|FreeBASIC}}== |
|||
<syntaxhighlight lang="freebasic">#define HUGE 99999999 |
|||
redim as integer list(0 to 8) |
|||
list(0) = 6 :list(1) = 81:list(2) = 243:list(3) = 14:list(4) = 25:list(5) = 49:list(6) = 123:list(7) = 69:list(8) = 11 |
|||
dim as integer s, si, ss, ssi, i |
|||
for i = 0 to ubound(list) |
|||
print list(i);" "; |
|||
next i |
|||
print |
|||
while ubound(list) > 0 |
|||
s = HUGE |
|||
ss = HUGE |
|||
for i = 0 to ubound(list) |
|||
if list(i)<s then |
|||
ss = s |
|||
ssi = si |
|||
s = list(i) |
|||
si = i |
|||
elseif list(i)<ss then |
|||
ss = list(i) |
|||
ssi = i |
|||
end if |
|||
next i |
|||
if ss<s then swap s, ss |
|||
for i = si to ubound(list)-1 |
|||
list(i) = list(i+1) |
|||
next i |
|||
for i = ssi to ubound(list)-2 |
|||
list(i) = list(i+1) |
|||
next i |
|||
list(ubound(list)-1) = s+ss |
|||
redim preserve list(0 to ubound(list)-1) |
|||
for i = 0 to ubound(list) |
|||
print list(i);" "; |
|||
next i |
|||
print |
|||
wend</syntaxhighlight> |
|||
{{out}}<pre> |
|||
6 81 243 14 25 49 123 69 11 |
|||
81 243 14 25 49 123 69 17 |
|||
81 243 25 49 123 69 31 |
|||
81 243 49 123 69 56 |
|||
81 243 123 69 105 |
|||
243 123 105 150 |
|||
243 150 228 |
|||
243 378 |
|||
621 |
|||
</pre> |
</pre> |
||
Line 236: | Line 867: | ||
{{trans|Wren}} |
{{trans|Wren}} |
||
===With sorting=== |
===With sorting=== |
||
< |
<syntaxhighlight lang="go">package main |
||
import ( |
import ( |
||
Line 254: | Line 885: | ||
} |
} |
||
fmt.Println("Last item is", a[0], "\b.") |
fmt.Println("Last item is", a[0], "\b.") |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 278: | Line 909: | ||
===Without sorting=== |
===Without sorting=== |
||
< |
<syntaxhighlight lang="go">package main |
||
import "fmt" |
import "fmt" |
||
Line 309: | Line 940: | ||
} |
} |
||
fmt.Println("Last item is", a[0], "\b.") |
fmt.Println("Last item is", a[0], "\b.") |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 331: | Line 962: | ||
Last item is 621. |
Last item is 621. |
||
</pre> |
</pre> |
||
=={{header|J}}== |
|||
Here we maintain the unsorted order in the intermediate steps:<syntaxhighlight lang="j"> rplc&(' 0';'')"1": ((-. , +/@]) 2 {. /:~)^:a: 81 243 14 25 49 123 69 17 |
|||
81 243 14 25 49 123 69 17 |
|||
81 243 25 49 123 69 31 |
|||
81 243 49 123 69 56 |
|||
81 243 123 69 105 |
|||
243 123 105 150 |
|||
243 150 228 |
|||
243 378 |
|||
621</syntaxhighlight> |
|||
Alternative interpretation:<syntaxhighlight lang="j"> ([[:echo,:#~1<#)@((-. , +/@]) 2 {. /:~)^:_] 81 243 14 25 49 123 69 17 |
|||
81 243 25 49 123 69 31 |
|||
81 243 49 123 69 56 |
|||
81 243 123 69 105 |
|||
243 123 105 150 |
|||
243 150 228 |
|||
243 378 |
|||
621</syntaxhighlight> |
|||
=={{header|jq}}== |
|||
'''Adapted from [[#Wren|Wren]]''' |
|||
{{works with|jq}} |
|||
'''Works with gojq, the Go implementation of jq''' |
|||
===With sorting=== |
|||
<syntaxhighlight lang="jq">def task_with_sorting: |
|||
foreach range(1; length) as $i ( {a: .}; |
|||
.a |= sort |
|||
| .emit = "Sorted list: \(.a)\n" |
|||
| (.a[0] + .a[1]) as $sum |
|||
| .emit += "Two smallest: \(.a[0]) + \(.a[1]) = \($sum)" |
|||
| .a += [$sum] |
|||
| .a |= .[2:] ; |
|||
.emit, |
|||
(select(.a|length==1) | "Last item is \(.a[0]).") ); |
|||
[6, 81, 243, 14, 25, 49, 123, 69, 11] |
|||
| task_with_sorting</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Sorted list: [6,11,14,25,49,69,81,123,243] |
|||
Two smallest: 6 + 11 = 17 |
|||
Sorted list: [14,17,25,49,69,81,123,243] |
|||
Two smallest: 14 + 17 = 31 |
|||
Sorted list: [25,31,49,69,81,123,243] |
|||
Two smallest: 25 + 31 = 56 |
|||
Sorted list: [49,56,69,81,123,243] |
|||
Two smallest: 49 + 56 = 105 |
|||
Sorted list: [69,81,105,123,243] |
|||
Two smallest: 69 + 81 = 150 |
|||
Sorted list: [105,123,150,243] |
|||
Two smallest: 105 + 123 = 228 |
|||
Sorted list: [150,228,243] |
|||
Two smallest: 150 + 228 = 378 |
|||
Sorted list: [243,378] |
|||
Two smallest: 243 + 378 = 621 |
|||
Last item is 621. |
|||
</pre> |
|||
===Without sorting=== |
|||
<syntaxhighlight lang="jq">def min_index: |
|||
. as $in |
|||
| reduce range(0; length) as $i ( null; |
|||
$in[$i] as $x |
|||
| if . == null then {ix: 0, min: $x} |
|||
elif $x < .min then {ix: $i, min: $x} |
|||
else . end) |
|||
| .ix; |
|||
def task_without_sorting: |
|||
# Output: [min, remainder] |
|||
def remove_min: |
|||
min_index as $ix |
|||
| [.[$ix], (.[:$ix] + .[$ix + 1:])]; |
|||
foreach range(1; length) as $i ( {a: .}; |
|||
.emit = "Unsorted list: \(.a)\n" |
|||
| (.a | remove_min) as [$m1, $x] |
|||
| ($x | remove_min) as [$m2, $y] |
|||
| ($m1 + $m2) as $sum |
|||
| .emit += "Two smallest: \($m1) + \($m2) = \($sum)" |
|||
| .a = $y + [$sum] ; |
|||
.emit, |
|||
(select(.a|length==1) | "Last item is \(.a[0]).") ); |
|||
[6, 81, 243, 14, 25, 49, 123, 69, 11] |
|||
| task_without_sorting |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Unsorted list: [6,81,243,14,25,49,123,69,11] |
|||
Two smallest: 6 + 11 = 17 |
|||
Unsorted list: [81,243,14,25,49,123,69,17] |
|||
Two smallest: 14 + 17 = 31 |
|||
Unsorted list: [81,243,25,49,123,69,31] |
|||
Two smallest: 25 + 31 = 56 |
|||
Unsorted list: [81,243,49,123,69,56] |
|||
Two smallest: 49 + 56 = 105 |
|||
Unsorted list: [81,243,123,69,105] |
|||
Two smallest: 69 + 81 = 150 |
|||
Unsorted list: [243,123,105,150] |
|||
Two smallest: 105 + 123 = 228 |
|||
Unsorted list: [243,150,228] |
|||
Two smallest: 150 + 228 = 378 |
|||
Unsorted list: [243,378] |
|||
Two smallest: 243 + 378 = 621 |
|||
Last item is 621. |
|||
</pre> |
|||
=={{header|Julia}}== |
|||
<syntaxhighlight lang="julia">list = [6, 81, 243, 14, 25, 49, 123, 69, 11] |
|||
function addleastreduce!(lis) |
|||
while length(lis) > 1 |
|||
push!(lis, popat!(lis, last(findmin(lis))) + popat!(lis, last(findmin(lis)))) |
|||
println("Interim list: $lis") |
|||
end |
|||
return lis |
|||
end |
|||
@show list, addleastreduce!(copy(list)) |
|||
</syntaxhighlight>{{out}} |
|||
<pre> |
|||
Interim list: [81, 243, 14, 25, 49, 123, 69, 17] |
|||
Interim list: [81, 243, 25, 49, 123, 69, 31] |
|||
Interim list: [81, 243, 49, 123, 69, 56] |
|||
Interim list: [81, 243, 123, 69, 105] |
|||
Interim list: [243, 123, 105, 150] |
|||
Interim list: [243, 150, 228] |
|||
Interim list: [243, 378] |
|||
Interim list: [621] |
|||
(list, addleastreduce!(copy(list))) = ([6, 81, 243, 14, 25, 49, 123, 69, 11], [621]) |
|||
</pre> |
|||
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
|||
===With and without sorting=== |
|||
<syntaxhighlight lang="mathematica">list = {6, 81, 243, 14, 25, 49, 123, 69, 11}; |
|||
Print[list] |
|||
Do[ |
|||
poss = Ordering[list, 2]; |
|||
extr = Extract[list, List /@ poss]; |
|||
extr //= Total; |
|||
list = Delete[list, List /@ poss]; |
|||
AppendTo[list, extr]; |
|||
Print[list] |
|||
, |
|||
{Length[list] - 1} |
|||
]</syntaxhighlight> |
|||
{{out}} |
|||
<pre>{6,81,243,14,25,49,123,69,11} |
|||
{81,243,14,25,49,123,69,17} |
|||
{81,243,25,49,123,69,31} |
|||
{81,243,49,123,69,56} |
|||
{81,243,123,69,105} |
|||
{243,123,105,150} |
|||
{243,150,228} |
|||
{243,378} |
|||
{621}</pre> |
|||
=={{header|Nim}}== |
|||
===With sorting=== |
|||
We sort in descending order as it is more efficient. |
|||
<syntaxhighlight lang="nim"># With sorting. |
|||
import algorithm, strformat |
|||
proc extractAndAddTwoSmallest(list: var seq[int]) = |
|||
list.sort(Descending) |
|||
stdout.write &"Descending sorted list: {list}" |
|||
let min1 = list.pop() |
|||
let min2 = list.pop() |
|||
echo &"; two smallest: {min1} and {min2}; sum = {min1 + min2}" |
|||
list.add min1 + min2 |
|||
var list = @[6, 81, 243, 14, 25, 49, 123, 69, 11] |
|||
while list.len >= 2: |
|||
list.extractAndAddTwoSmallest() |
|||
echo &"Last item is {list[0]}."</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Descending sorted list: @[243, 123, 81, 69, 49, 25, 14, 11, 6]; two smallest: 6 and 11; sum = 17 |
|||
Descending sorted list: @[243, 123, 81, 69, 49, 25, 17, 14]; two smallest: 14 and 17; sum = 31 |
|||
Descending sorted list: @[243, 123, 81, 69, 49, 31, 25]; two smallest: 25 and 31; sum = 56 |
|||
Descending sorted list: @[243, 123, 81, 69, 56, 49]; two smallest: 49 and 56; sum = 105 |
|||
Descending sorted list: @[243, 123, 105, 81, 69]; two smallest: 69 and 81; sum = 150 |
|||
Descending sorted list: @[243, 150, 123, 105]; two smallest: 105 and 123; sum = 228 |
|||
Descending sorted list: @[243, 228, 150]; two smallest: 150 and 228; sum = 378 |
|||
Descending sorted list: @[378, 243]; two smallest: 243 and 378; sum = 621 |
|||
Last item is 621.</pre> |
|||
===Without sorting=== |
|||
We could use the function <code>minIndex</code> from module <code>sequtils</code> but it would be less efficient. We used a single loop instead. Please note that we remove the elements using function <code>del</code> which is O(1) rather than function <code>delete</code> which is O(n). |
|||
<syntaxhighlight lang="nim"># Without sorting. |
|||
import strformat |
|||
proc extractAndAddTwoSmallest(list: var seq[int]) = |
|||
var min1, min2 = int.high |
|||
var imin1, imin2 = -1 |
|||
for i, val in list: |
|||
if val < min1: |
|||
min2 = min1 |
|||
min1 = val |
|||
imin2 = imin1 |
|||
imin1 = i |
|||
elif val < min2: |
|||
min2 = val |
|||
imin2 = i |
|||
echo &"List: {list}; two smallest: {min1}@{imin1} and {min2}@{imin2}; sum = {min1 + min2}" |
|||
if imin1 > imin2: swap imin1, imin2 # Make sure "imin2" is the greatest index. |
|||
list.del imin2 |
|||
list.del imin1 |
|||
list.add min1 + min2 |
|||
var list = @[6, 81, 243, 14, 25, 49, 123, 69, 11] |
|||
while list.len >= 2: |
|||
list.extractAndAddTwoSmallest() |
|||
echo &"Last item is {list[0]}."</syntaxhighlight> |
|||
{{out}} |
|||
<pre>List: @[6, 81, 243, 14, 25, 49, 123, 69, 11]; two smallest: 6@0 and 11@8; sum = 17 |
|||
List: @[69, 81, 243, 14, 25, 49, 123, 17]; two smallest: 14@3 and 17@7; sum = 31 |
|||
List: @[69, 81, 243, 123, 25, 49, 31]; two smallest: 25@4 and 31@6; sum = 56 |
|||
List: @[69, 81, 243, 123, 49, 56]; two smallest: 49@4 and 56@5; sum = 105 |
|||
List: @[69, 81, 243, 123, 105]; two smallest: 69@0 and 81@1; sum = 150 |
|||
List: @[123, 105, 243, 150]; two smallest: 105@1 and 123@0; sum = 228 |
|||
List: @[243, 150, 228]; two smallest: 150@1 and 228@2; sum = 378 |
|||
List: @[243, 378]; two smallest: 243@0 and 378@1; sum = 621 |
|||
Last item is 621.</pre> |
|||
=={{header|Perl}}== |
|||
{{trans|Raku}} |
|||
<syntaxhighlight lang="perl">use strict; |
|||
use warnings; |
|||
use feature 'say'; |
|||
use List::AllUtils <min firstidx>; |
|||
my @list = <6 81 243 14 25 49 123 69 11>; |
|||
say " Original @list"; |
|||
push @list, get(min @list) + get(min @list) and say "@list" while @list > 1; |
|||
sub get { |
|||
my($min) = @_; |
|||
splice @list, (firstidx { $min == $_ } @list), 1; |
|||
printf " %3d ", $min; |
|||
$min; |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> Original 6 81 243 14 25 49 123 69 11 |
|||
6 11 81 243 14 25 49 123 69 17 |
|||
14 17 81 243 25 49 123 69 31 |
|||
25 31 81 243 49 123 69 56 |
|||
49 56 81 243 123 69 105 |
|||
69 81 243 123 105 150 |
|||
105 123 243 150 228 |
|||
150 228 243 378 |
|||
243 378 621</pre> |
|||
=={{header|Phix}}== |
|||
===With sorting=== |
|||
<!--<syntaxhighlight lang="phix">(phixonline)--> |
|||
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> |
|||
<span style="color: #004080;">sequence</span> <span style="color: #000000;">list</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">6</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">81</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">243</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">14</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">25</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">49</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">123</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">69</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">11</span><span style="color: #0000FF;">}</span> |
|||
<span style="color: #008080;">while</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">list</span><span style="color: #0000FF;">)></span><span style="color: #000000;">1</span> <span style="color: #008080;">do</span> |
|||
<span style="color: #000000;">list</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sort</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">deep_copy</span><span style="color: #0000FF;">(</span><span style="color: #000000;">list</span><span style="color: #0000FF;">))</span> |
|||
<span style="color: #004080;">integer</span> <span style="color: #000000;">l1</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">list</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">],</span> <span style="color: #000000;">l2</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">list</span><span style="color: #0000FF;">[</span><span style="color: #000000;">2</span><span style="color: #0000FF;">],</span> <span style="color: #000000;">l12</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">l1</span><span style="color: #0000FF;">+</span><span style="color: #000000;">l2</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;">"Sorted list: %V, two smallest: %d + %d = %d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">list</span><span style="color: #0000FF;">,</span><span style="color: #000000;">l1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">l2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">l12</span><span style="color: #0000FF;">})</span> |
|||
<span style="color: #000000;">list</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: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">l12</span><span style="color: #0000FF;">}</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">while</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;">"Last item is %d\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">list</span><span style="color: #0000FF;">)</span> |
|||
<!--</syntaxhighlight>--> |
|||
{{out}} |
|||
<pre> |
|||
Sorted list: {6,11,14,25,49,69,81,123,243}, two smallest: 6 + 11 = 17 |
|||
Sorted list: {14,17,25,49,69,81,123,243}, two smallest: 14 + 17 = 31 |
|||
Sorted list: {25,31,49,69,81,123,243}, two smallest: 25 + 31 = 56 |
|||
Sorted list: {49,56,69,81,123,243}, two smallest: 49 + 56 = 105 |
|||
Sorted list: {69,81,105,123,243}, two smallest: 69 + 81 = 150 |
|||
Sorted list: {105,123,150,243}, two smallest: 105 + 123 = 228 |
|||
Sorted list: {150,228,243}, two smallest: 150 + 228 = 378 |
|||
Sorted list: {243,378}, two smallest: 243 + 378 = 621 |
|||
Last item is 621 |
|||
</pre> |
|||
===Without sorting=== |
|||
<!--<syntaxhighlight lang="phix">(phixonline)--> |
|||
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> |
|||
<span style="color: #004080;">sequence</span> <span style="color: #000000;">list</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">6</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">81</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">243</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">14</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">25</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">49</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">123</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">69</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">11</span><span style="color: #0000FF;">}</span> |
|||
<span style="color: #008080;">while</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">list</span><span style="color: #0000FF;">)></span><span style="color: #000000;">1</span> <span style="color: #008080;">do</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;">"List: %V, two smallest: "</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">list</span><span style="color: #0000FF;">})</span> |
|||
<span style="color: #004080;">integer</span> <span style="color: #000000;">l1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">l2</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span> |
|||
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">2</span> <span style="color: #008080;">do</span> |
|||
<span style="color: #000000;">l1</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">l2</span> |
|||
<span style="color: #004080;">integer</span> <span style="color: #000000;">ldx</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">smallest</span><span style="color: #0000FF;">(</span><span style="color: #000000;">list</span><span style="color: #0000FF;">,</span><span style="color: #004600;">true</span><span style="color: #0000FF;">)</span> |
|||
<span style="color: #000000;">l2</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">list</span><span style="color: #0000FF;">[</span><span style="color: #000000;">ldx</span><span style="color: #0000FF;">]</span> |
|||
<span style="color: #000000;">list</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">list</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">ldx</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">&</span> <span style="color: #000000;">list</span><span style="color: #0000FF;">[</span><span style="color: #000000;">ldx</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..$]</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</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;">"%d + %d = %d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">l1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">l2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">l1</span><span style="color: #0000FF;">+</span><span style="color: #000000;">l2</span><span style="color: #0000FF;">})</span> |
|||
<span style="color: #000000;">list</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">l1</span><span style="color: #0000FF;">+</span><span style="color: #000000;">l2</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">while</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;">"Last item is %d\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">list</span><span style="color: #0000FF;">)</span> |
|||
<!--</syntaxhighlight>--> |
|||
{{out}} |
|||
<pre> |
|||
List: {6,81,243,14,25,49,123,69,11}, two smallest: 6 + 11 = 17 |
|||
List: {81,243,14,25,49,123,69,17}, two smallest: 14 + 17 = 31 |
|||
List: {81,243,25,49,123,69,31}, two smallest: 25 + 31 = 56 |
|||
List: {81,243,49,123,69,56}, two smallest: 49 + 56 = 105 |
|||
List: {81,243,123,69,105}, two smallest: 69 + 81 = 150 |
|||
List: {243,123,105,150}, two smallest: 105 + 123 = 228 |
|||
List: {243,150,228}, two smallest: 150 + 228 = 378 |
|||
List: {243,378}, two smallest: 243 + 378 = 621 |
|||
Last item is 621 |
|||
</pre> |
|||
=={{header|Python}}== |
|||
{{trans|Julia}} |
|||
<syntaxhighlight lang="python">""" Rosetta code task: Last list item """ |
|||
def add_least_reduce(lis): |
|||
""" Reduce lis: sum least two elements adding sum to list. Will take len(list) - 1 steps """ |
|||
while len(lis) > 1: |
|||
lis.append(lis.pop(lis.index(min(lis))) + lis.pop(lis.index(min(lis)))) |
|||
print('Interim list:', lis) |
|||
return lis |
|||
LIST = [6, 81, 243, 14, 25, 49, 123, 69, 11] |
|||
print(LIST, ' ==> ', add_least_reduce(LIST.copy())) |
|||
</syntaxhighlight>{{out}} |
|||
<pre> |
|||
Interim list: [81, 243, 14, 25, 49, 123, 69, 17] |
|||
Interim list: [81, 243, 25, 49, 123, 69, 31] |
|||
Interim list: [81, 243, 49, 123, 69, 56] |
|||
Interim list: [81, 243, 123, 69, 105] |
|||
Interim list: [243, 123, 105, 150] |
|||
Interim list: [243, 150, 228] |
|||
Interim list: [243, 378] |
|||
Interim list: [621] |
|||
[6, 81, 243, 14, 25, 49, 123, 69, 11] ==> [621] |
|||
</pre> |
|||
=={{header|Quackery}}== |
|||
<syntaxhighlight lang="Quackery"> [ behead |
|||
-1 swap rot witheach |
|||
[ 2dup > if |
|||
[ i^ swap |
|||
2swap drop ] |
|||
drop ] |
|||
drop 1+ ] is least ( [ --> n ) |
|||
' [ 6 81 243 14 25 49 123 69 11 ] |
|||
[ dup echo cr |
|||
dup size 1 > while |
|||
dup least pluck |
|||
swap |
|||
dup least pluck |
|||
rot + join |
|||
again ] |
|||
0 peek echo |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre>[ 6 81 243 14 25 49 123 69 11 ] |
|||
[ 81 243 14 25 49 123 69 17 ] |
|||
[ 81 243 25 49 123 69 31 ] |
|||
[ 81 243 49 123 69 56 ] |
|||
[ 81 243 123 69 105 ] |
|||
[ 243 123 105 150 ] |
|||
[ 243 150 228 ] |
|||
[ 243 378 ] |
|||
[ 621 ] |
|||
621</pre> |
|||
=={{header|Raku}}== |
=={{header|Raku}}== |
||
Uses no sorting; does not modify overall list order while processing. |
Uses no sorting; does not modify overall list order while processing. |
||
<lang |
<syntaxhighlight lang="raku" line>say ' Original ', my @list = 6, 81, 243, 14, 25, 49, 123, 69, 11; |
||
say push @list: get(min @list) + get(min @list) while @list > 1; |
say push @list: get(min @list) + get(min @list) while @list > 1; |
||
Line 342: | Line 1,352: | ||
printf " %3d ", $min; |
printf " %3d ", $min; |
||
$min; |
$min; |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> Original [6 81 243 14 25 49 123 69 11] |
<pre> Original [6 81 243 14 25 49 123 69 11] |
||
Line 357: | Line 1,367: | ||
=={{header|REXX}}== |
=={{header|REXX}}== |
||
===With sorting=== |
===With sorting=== |
||
< |
<syntaxhighlight lang="rexx">/* REXX */ |
||
List = '6 81 243 14 25 49 123 69 11' |
List = '6 81 243 14 25 49 123 69 11' |
||
Do Until words(list)=1 |
Do Until words(list)=1 |
||
Line 393: | Line 1,403: | ||
swl=swl wa.i |
swl=swl wa.i |
||
End |
End |
||
Return strip(swl)</ |
Return strip(swl)</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<Pre>Sorted list: 6 11 14 25 49 69 81 123 243 |
<Pre>Sorted list: 6 11 14 25 49 69 81 123 243 |
||
Line 413: | Line 1,423: | ||
Last item: 621</pre> |
Last item: 621</pre> |
||
===Without sorting=== |
===Without sorting=== |
||
< |
<syntaxhighlight lang="rexx">/* REXX */ |
||
List = '6 81 243 14 25 49 123 69 11' |
List = '6 81 243 14 25 49 123 69 11' |
||
Do Until words(list)=1 |
Do Until words(list)=1 |
||
Line 436: | Line 1,446: | ||
End |
End |
||
list=subword(list,1,j-1) subword(list,j+1) |
list=subword(list,1,j-1) subword(list,j+1) |
||
Return m</ |
Return m</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>List: 6 81 243 14 25 49 123 69 11 |
<pre>List: 6 81 243 14 25 49 123 69 11 |
||
Line 458: | Line 1,468: | ||
=={{header|Ring}}== |
=={{header|Ring}}== |
||
===With sorting=== |
|||
<lang ring> |
|||
<syntaxhighlight lang="ring"> |
|||
see "working..." + nl |
see "working..." + nl |
||
List = [6,81,243,14,25,49,123,69,11] |
List = [6,81,243,14,25,49,123,69,11] |
||
Temp = [] |
|||
n = 0 |
n = 0 |
||
while true |
while true |
||
n++ |
n++ |
||
List = sort(List) |
|||
first = |
first = List[1] |
||
second = |
second = List[2] |
||
ind1 = find(List,first) |
ind1 = find(List,first) |
||
ind2 = find(List,second) |
ind2 = find(List,second) |
||
Line 508: | Line 1,519: | ||
txt = txt + "]" |
txt = txt + "]" |
||
see txt + nl |
see txt + nl |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
working... |
working... |
||
List = [ |
List = [14,25,49,69,81,123,243,17] |
||
two smallest is = 6 + 11 = 17 |
|||
List = [14,25,49,69,81,123,243,17] |
|||
two smallest is = 14 + 17 = 31 |
|||
List = [25,49,69,81,123,243,31] |
|||
two smallest is = 25 + 31 = 56 |
|||
List = [49,69,81,123,243,56] |
|||
two smallest is = 49 + 56 = 105 |
|||
List = [69,81,123,243,105] |
|||
two smallest is = 69 + 81 = 150 |
|||
List = [105,123,243,150] |
|||
two smallest is = 105 + 123 = 228 |
|||
List = [150,243,228] |
|||
two smallest is = 150 + 228 = 378 |
|||
List = [243,378] |
|||
Last item is: 621 |
|||
done... |
|||
</pre> |
|||
===Without sorting=== |
|||
<syntaxhighlight lang="ring"> |
|||
see "working..." + nl |
|||
List = [6,81,243,14,25,49,123,69,11] |
|||
n = 0 |
|||
while true |
|||
n++ |
|||
if n = 1 |
|||
see nl + "List = " |
|||
showArray(List) |
|||
see nl |
|||
ok |
|||
first = min(List) |
|||
ind1 = find(List,first) |
|||
del(List,ind1) |
|||
second = min(List) |
|||
ind2 = find(List,second) |
|||
del(List,ind2) |
|||
sum = first + second |
|||
add(List,sum) |
|||
if len(List) = 1 |
|||
exit |
|||
ok |
|||
showList(first,second,sum,List) |
|||
end |
|||
see "Last item is: " +List[1] + nl |
|||
see "done..." + nl |
|||
func showList(first,second,sum,List) |
|||
see "two smallest is = " + first + " + " + second + " = " + sum + nl |
|||
see "List = " |
|||
showArray(List) |
|||
func showArray(array) |
|||
txt = "" |
|||
see "[" |
|||
for n = 1 to len(array) |
|||
txt = txt + array[n] + "," |
|||
next |
|||
txt = left(txt,len(txt)-1) |
|||
txt = txt + "]" |
|||
see txt + nl |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
working... |
|||
List = [6,81,243,14,25,49,123,69,11] |
|||
two smallest is = 6 + 11 = 17 |
two smallest is = 6 + 11 = 17 |
||
Line 531: | Line 1,611: | ||
Last item is: 621 |
Last item is: 621 |
||
done... |
done... |
||
</pre> |
|||
=={{header|RPL}}== |
|||
≪ '''WHILE''' DUP SIZE 1 > '''REPEAT''' |
|||
DUP LIST→ → len |
|||
≪ 0 1 '''FOR''' j |
|||
2 len j - '''START''' |
|||
len j - ROLL '''IF''' DUP2 < '''THEN''' SWAP '''END NEXT''' |
|||
len ROLLD |
|||
'''NEXT''' |
|||
len ROLL len ROLL + len 1 - →LIST |
|||
≫ '''END''' |
|||
≫ ''''LASTL'''' STO |
|||
{{in}} |
|||
<pre> |
|||
{ 6 11 14 25 49 69 81 123 243 } LASTL |
|||
</pre> |
|||
{{out}} |
|||
<pre> |
|||
9: { 6 11 14 25 49 69 81 123 243 } |
|||
8: { 243 123 14 25 49 69 81 17 } |
|||
7: { 243 123 81 25 49 69 31 } |
|||
6: { 243 123 81 69 49 56 } |
|||
5: { 243 123 81 69 105 } |
|||
4: { 243 123 105 150 } |
|||
3: { 243 150 228 } |
|||
2: { 243 378 } |
|||
1: { 621 } |
|||
</pre> |
|||
=={{header|Ruby}}== |
|||
<syntaxhighlight lang="ruby">p original = [6, 81, 243, 14, 25, 49, 123, 69, 11] |
|||
until original.size == 1 do |
|||
mins = original.min(2) |
|||
mins.each{|el| original.delete_at(original.index(el)) } |
|||
p original << mins.sum |
|||
end |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre>[6, 81, 243, 14, 25, 49, 123, 69, 11] |
|||
[81, 243, 14, 25, 49, 123, 69, 17] |
|||
[81, 243, 25, 49, 123, 69, 31] |
|||
[81, 243, 49, 123, 69, 56] |
|||
[81, 243, 123, 69, 105] |
|||
[243, 123, 105, 150] |
|||
[243, 150, 228] |
|||
[243, 378] |
|||
[621] |
|||
</pre> |
|||
=={{header|Sidef}}== |
|||
===With sorting=== |
|||
<syntaxhighlight lang="ruby">var k = 2 |
|||
var list = [6, 81, 243, 14, 25, 49, 123, 69, 11] |
|||
while (list.len >= k) { |
|||
var a = list.sort!.shift(k) |
|||
list << a.sum |
|||
say "#{a.map{'%3s' % _}.join(' ')} : #{list}" |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
6 11 : [14, 25, 49, 69, 81, 123, 243, 17] |
|||
14 17 : [25, 49, 69, 81, 123, 243, 31] |
|||
25 31 : [49, 69, 81, 123, 243, 56] |
|||
49 56 : [69, 81, 123, 243, 105] |
|||
69 81 : [105, 123, 243, 150] |
|||
105 123 : [150, 243, 228] |
|||
150 228 : [243, 378] |
|||
243 378 : [621] |
|||
</pre> |
|||
===Without sorting=== |
|||
<syntaxhighlight lang="ruby">var k = 2 |
|||
var list = [6, 81, 243, 14, 25, 49, 123, 69, 11] |
|||
while (list.len >= k) { |
|||
var a = gather { |
|||
k.times { |
|||
take(var v = list.min) |
|||
list.delete_first(v) |
|||
} |
|||
} |
|||
list << a.sum |
|||
say "#{a.map{'%3s' % _}.join(' ')} : #{list}" |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
6 11 : [81, 243, 14, 25, 49, 123, 69, 17] |
|||
14 17 : [81, 243, 25, 49, 123, 69, 31] |
|||
25 31 : [81, 243, 49, 123, 69, 56] |
|||
49 56 : [81, 243, 123, 69, 105] |
|||
69 81 : [243, 123, 105, 150] |
|||
105 123 : [243, 150, 228] |
|||
150 228 : [243, 378] |
|||
243 378 : [621] |
|||
</pre> |
|||
=={{header|V (Vlang)}}== |
|||
{{trans|Go}} |
|||
===With sorting=== |
|||
<syntaxhighlight lang="v (vlang)">fn main() { |
|||
mut a := [6, 81, 243, 14, 25, 49, 123, 69, 11] |
|||
for a.len > 1 { |
|||
a.sort() |
|||
println("Sorted list: $a") |
|||
sum := a[0] + a[1] |
|||
println("Two smallest: ${a[0]} + ${a[1]} = $sum") |
|||
a << sum |
|||
a = a[2..] |
|||
} |
|||
println("Last item is ${a[0]}.") |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Sorted list: [6, 11, 14, 25, 49, 69, 81, 123, 243] |
|||
Two smallest: 6 + 11 = 17 |
|||
Sorted list: [14, 17, 25, 49, 69, 81, 123, 243] |
|||
Two smallest: 14 + 17 = 31 |
|||
Sorted list: [25, 31, 49, 69, 81, 123, 243] |
|||
Two smallest: 25 + 31 = 56 |
|||
Sorted list: [49, 56, 69, 81 123, 243] |
|||
Two smallest: 49 + 56 = 105 |
|||
Sorted list: [69, 81, 105, 123, 243] |
|||
Two smallest: 69 + 81 = 150 |
|||
Sorted list: [105, 123, 150, 243] |
|||
Two smallest: 105 + 123, = 228 |
|||
Sorted list: [150, 228, 243] |
|||
Two smallest: 150 + 228, = 378 |
|||
Sorted list: [243, 378] |
|||
Two smallest: 243 + 378 = 621 |
|||
Last item is 621. |
|||
</pre> |
|||
===Without sorting=== |
|||
<syntaxhighlight lang="v (vlang)">fn find_min(a []int) (int, int) { |
|||
mut ix := 0 |
|||
mut min := a[0] |
|||
for i in 1..a.len { |
|||
if a[i] < min { |
|||
ix = i |
|||
min = a[i] |
|||
} |
|||
} |
|||
return min, ix |
|||
} |
|||
fn main() { |
|||
mut a := [6, 81, 243, 14, 25, 49, 123, 69, 11] |
|||
for a.len > 1 { |
|||
println("List: $a") |
|||
mut s := [2]int{} |
|||
for i in 0..2 { |
|||
min, ix := find_min(a) |
|||
s[i] = min |
|||
a.delete(ix) |
|||
} |
|||
sum := s[0] + s[1] |
|||
println("Two smallest: ${s[0]} + ${s[1]} = $sum") |
|||
a << sum |
|||
} |
|||
println("Last item is ${a[0]}.") |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
List: [6, 81, 243, 14, 25, 49, 123, 69, 11] |
|||
Two smallest: 6 + 11 = 17 |
|||
List: [81, 243, 14, 25, 49, 123, 69, 17] |
|||
Two smallest: 14 + 17 = 31 |
|||
List: [81, 243, 25, 49, 123, 69, 31] |
|||
Two smallest: 25 + 31 = 56 |
|||
List: [81, 243, 49, 123, 69, 56] |
|||
Two smallest: 49 + 56 = 105 |
|||
List: [81, 243, 123, 69, 105] |
|||
Two smallest: 69 + 81 = 150 |
|||
List: [24,3 123, 105, 150] |
|||
Two smallest: 105 + 123 = 228 |
|||
List: [243, 150, 228] |
|||
Two smallest: 150 + 228 = 378 |
|||
List: [243, 378] |
|||
Two smallest: 243 + 378 = 621 |
|||
Last item is 621. |
|||
</pre> |
</pre> |
||
=={{header|Wren}}== |
=={{header|Wren}}== |
||
===With sorting=== |
===With sorting=== |
||
< |
<syntaxhighlight lang="wren">var a = [6, 81, 243, 14, 25, 49, 123, 69, 11] |
||
while (a.count > 1) { |
while (a.count > 1) { |
||
Line 546: | Line 1,811: | ||
} |
} |
||
System.print("Last item is %(a[0]).")</ |
System.print("Last item is %(a[0]).")</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 570: | Line 1,835: | ||
===Without sorting=== |
===Without sorting=== |
||
< |
<syntaxhighlight lang="wren">var findMin = Fn.new { |a| |
||
var ix = 0 |
var ix = 0 |
||
var min = a[0] |
var min = a[0] |
||
Line 597: | Line 1,862: | ||
} |
} |
||
System.print("Last item is %(a[0]).")</ |
System.print("Last item is %(a[0]).")</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 618: | Line 1,883: | ||
Two smallest: 243 + 378 = 621 |
Two smallest: 243 + 378 = 621 |
||
Last item is 621. |
Last item is 621. |
||
</pre> |
|||
=={{header|XPL0}}== |
|||
<syntaxhighlight lang="xpl0">int List, End, Sum, Item, Smallest, I, SI; |
|||
[List:= [6, 81, 243, 14, 25, 49, 123, 69, 11]; |
|||
End:= 8; \last index |
|||
loop [for I:= 0 to End do \show List |
|||
[IntOut(0, List(I)); ChOut(0, ^ )]; |
|||
CrLf(0); |
|||
if End = 0 then quit; \done when only one element |
|||
Sum:= 0; \find two smallest items |
|||
for Item:= 1 to 2 do |
|||
[Smallest:= -1>>1; |
|||
for I:= 0 to End do |
|||
if List(I) < Smallest then |
|||
[Smallest:= List(I); SI:= I]; |
|||
Sum:= Sum + Smallest; \add them |
|||
for I:= SI to End-1 do \remove them |
|||
List(I):= List(I+1); |
|||
End:= End-1; |
|||
]; |
|||
End:= End+1; \insert Sum at End |
|||
List(End):= Sum; |
|||
]; |
|||
]</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
6 81 243 14 25 49 123 69 11 |
|||
81 243 14 25 49 123 69 17 |
|||
81 243 25 49 123 69 31 |
|||
81 243 49 123 69 56 |
|||
81 243 123 69 105 |
|||
243 123 105 150 |
|||
243 150 228 |
|||
243 378 |
|||
621 |
|||
</pre> |
</pre> |
Latest revision as of 10:44, 28 April 2024
- Task
List = [6, 81, 243, 14, 25, 49, 123, 69, 11]
Find the two smallest items, remove them from the list, find their sum, and add the sum to the end of list.
Repeat until the list contains one element.
Show the steps and last item on this page.
Show the unsorted list in output in case "Without sort"
11l
F add_least_reduce(&lis)
L lis.len > 1
V el1 = lis.pop(lis.index(min(lis)))
V el2 = lis.pop(lis.index(min(lis)))
lis.append(el1 + el2)
print(‘Interim list: ’lis)
R lis
V LIST = [6, 81, 243, 14, 25, 49, 123, 69, 11]
print(LIST‘ ==> ’add_least_reduce(©(LIST)))
- Output:
Interim list: [81, 243, 14, 25, 49, 123, 69, 17] Interim list: [81, 243, 25, 49, 123, 69, 31] Interim list: [81, 243, 49, 123, 69, 56] Interim list: [81, 243, 123, 69, 105] Interim list: [243, 123, 105, 150] Interim list: [243, 150, 228] Interim list: [243, 378] Interim list: [621] [6, 81, 243, 14, 25, 49, 123, 69, 11] ==> [621]
Ada
With sorting
with Ada.Text_IO;
with Ada.Containers.Vectors;
procedure Last_List_Item_Sorted is
package Integer_IO is new Ada.Text_IO.Integer_IO (Integer);
package Vectors is
new Ada.Containers.Vectors (Index_Type => Positive,
Element_Type => Integer);
package Vector_Sorting is
new Vectors.Generic_Sorting;
use Ada.Containers, Vectors, Ada.Text_IO, Integer_IO;
procedure Put (List : Vector) is
begin
Put ("[");
for V of List loop
Put (" "); Put (V, Width => 0);
end loop;
Put ("]");
end Put;
List : Vector := 6 & 81 & 243 & 14 & 25 & 49 & 123 & 69 & 11;
begin
Default_Width := 0;
while List.Length >= 2 loop
Vector_Sorting.Sort (List);
Put (List);
declare
Small_1 : constant Integer := List (List.First_Index + 0);
Small_2 : constant Integer := List (List.First_Index + 1);
Sum : constant Integer := Small_1 + Small_2;
begin
List.Delete_First (2);
Put (". Smallest: "); Put (Small_1); Put (" and "); Put (Small_2);
Put (". Sum: "); Put (Sum); New_Line;
List.Append (Sum);
end;
end loop;
Put (List); New_Line;
end Last_List_Item_Sorted;
- Output:
[ 6 11 14 25 49 69 81 123 243]. Smallest: 6 and 11. Sum: 17 [ 14 17 25 49 69 81 123 243]. Smallest: 14 and 17. Sum: 31 [ 25 31 49 69 81 123 243]. Smallest: 25 and 31. Sum: 56 [ 49 56 69 81 123 243]. Smallest: 49 and 56. Sum: 105 [ 69 81 105 123 243]. Smallest: 69 and 81. Sum: 150 [ 105 123 150 243]. Smallest: 105 and 123. Sum: 228 [ 150 228 243]. Smallest: 150 and 228. Sum: 378 [ 243 378]. Smallest: 243 and 378. Sum: 621 [ 621]
Without sorting
with Ada.Text_IO;
with Ada.Containers.Vectors;
procedure Last_List_Item is
package Integer_IO is new Ada.Text_IO.Integer_IO (Integer);
package Element_Vectors is
new Ada.Containers.Vectors (Index_Type => Positive,
Element_Type => Integer);
use Ada.Containers, Element_Vectors, Ada.Text_IO, Integer_IO;
function Pick_Smallest (List : in out Vector) return Integer is
Value : Integer := Integer'Last;
begin
if List.Is_Empty then
raise Constraint_Error;
end if;
for V of List loop
Value := Integer'Min (Value, V);
end loop;
List.Delete (List.Find_Index (Value));
return Value;
end Pick_Smallest;
procedure Put (List : Vector) is
begin
Put ("[");
for V of List loop
Put (" "); Put (V, Width => 0);
end loop;
Put ("]");
end Put;
List : Vector := 6 & 81 & 243 & 14 & 25 & 49 & 123 & 69 & 11;
begin
Default_Width := 0;
while List.Length >= 2 loop
Put (List); Put (". Smallest: ");
declare
Small_1 : constant Integer := Pick_Smallest (List);
Small_2 : constant Integer := Pick_Smallest (List);
Sum : constant Integer := Small_1 + Small_2;
begin
Put (Small_1); Put (" and "); Put (Small_2);
Put (". Sum: "); Put (Sum); New_Line;
List.Append (Sum);
end;
end loop;
Put (List); New_Line;
end Last_List_Item;
- Output:
[ 6 81 243 14 25 49 123 69 11]. Smallest: 6 and 11. Sum: 17 [ 81 243 14 25 49 123 69 17]. Smallest: 14 and 17. Sum: 31 [ 81 243 25 49 123 69 31]. Smallest: 25 and 31. Sum: 56 [ 81 243 49 123 69 56]. Smallest: 49 and 56. Sum: 105 [ 81 243 123 69 105]. Smallest: 69 and 81. Sum: 150 [ 243 123 105 150]. Smallest: 105 and 123. Sum: 228 [ 243 150 228]. Smallest: 150 and 228. Sum: 378 [ 243 378]. Smallest: 243 and 378. Sum: 621 [ 621]
ALGOL 68
With sorting
BEGIN # find the last element after repeatedely adding the sum #
# of the two smallest elements and removing them #
PR read "rows.incl.a68" PR # row related utilities #
[ 1 : 9 ]INT a := ( 6, 81, 243, 14, 25, 49, 123, 69, 11 );
INT a count := UPB a;
WHILE a count > 1 DO
QUICKSORT a FROMELEMENT LWB a TOELEMENT a count;
print( ( "Sorted list:" ) );FOR i TO a count DO print( ( " ", whole( a[ i ], 0 ) ) ) OD;
INT sum = a[ 1 ] + a[ 2 ];
print( ( "; two smallest: " , whole( a[ 1 ], 0 )
, " + ", whole( a[ 2 ], 0 )
, " = ", whole( sum, 0 )
, newline
)
);
a[ 1 : a count - 2 ] := a[ 3 : a count ];
a count -:= 1 ;
a[ a count ] := sum
OD;
print( ( "Last item is ", whole( a[ 1 ], 0 ), ".", newline ) )
END
- Output:
Sorted list: 6 11 14 25 49 69 81 123 243; two smallest: 6 + 11 = 17 Sorted list: 14 17 25 49 69 81 123 243; two smallest: 14 + 17 = 31 Sorted list: 25 31 49 69 81 123 243; two smallest: 25 + 31 = 56 Sorted list: 49 56 69 81 123 243; two smallest: 49 + 56 = 105 Sorted list: 69 81 105 123 243; two smallest: 69 + 81 = 150 Sorted list: 105 123 150 243; two smallest: 105 + 123 = 228 Sorted list: 150 228 243; two smallest: 150 + 228 = 378 Sorted list: 243 378; two smallest: 243 + 378 = 621 Last item is 621.
Without sorting
Translation of the sorted Wren version with the sorting removed.
BEGIN # find the last element after repeatedly adding the sum #
# of the two smallest elements and removing them #
[ 1 : 9 ]INT a := ( 6, 81, 243, 14, 25, 49, 123, 69, 11 );
INT a count := UPB a;
WHILE a count > 1 DO
print( ( "List:" ) );FOR i TO a count DO print( ( " ", whole( a[ i ], 0 ) ) ) OD;
INT s1pos, s2pos;
IF a[ 1 ] < a[ 2 ]
THEN s1pos := 1; s2pos := 2
ELSE s1pos := 2; s2pos := 1
FI;
FOR i FROM 3 TO a count DO
IF a[ i ] < a[ s1pos ] THEN s2pos := s1pos; s1pos := i
ELIF a[ i ] < a[ s2pos ] THEN s2pos := i
FI
OD;
INT sum = a[ s1pos ] + a[ s2pos ];
print( ( "; two smallest: " , whole( a[ s1pos ], 0 ), " @ ", whole( s1pos, 0 )
, " and ", whole( a[ s2pos ], 0 ), " @ ", whole( s2pos, 0 )
, "; sum = ", whole( sum, 0 )
, newline
)
);
INT m pos := 0;
FOR i TO a count DO
IF i /= s1pos AND i /= s2pos THEN a[ m pos +:= 1 ] := a[ i ] FI
OD;
a[ m pos + 1 ] := sum;
a count -:= 1
OD;
print( ( "Last item is ", whole( a[ 1 ], 0 ), ".", newline ) )
END
- Output:
List: 6 81 243 14 25 49 123 69 11; two smallest: 6 @ 1 and 11 @ 9; sum = 17 List: 81 243 14 25 49 123 69 17; two smallest: 14 @ 3 and 17 @ 8; sum = 31 List: 81 243 25 49 123 69 31; two smallest: 25 @ 3 and 31 @ 7; sum = 56 List: 81 243 49 123 69 56; two smallest: 49 @ 3 and 56 @ 6; sum = 105 List: 81 243 123 69 105; two smallest: 69 @ 4 and 81 @ 1; sum = 150 List: 243 123 105 150; two smallest: 105 @ 3 and 123 @ 2; sum = 228 List: 243 150 228; two smallest: 150 @ 2 and 228 @ 3; sum = 378 List: 243 378; two smallest: 243 @ 1 and 378 @ 2; sum = 621 Last item is 621.
Applesoft BASIC
100 DATA 6, 81, 243, 14, 25, 49, 123, 69, 11
110 FOR L = 0 TO 8
120 READ L(L)
130 NEXT
140 LET L = L - 1
150 GOSUB 180"LAST LIST ITEM"
160 GOSUB 250"PRINT LIST"
170 END
180 IF L = 0 THEN RETURN
190 FOR L = L TO 0 STEP 0
200 GOSUB 340"FIND THE 2 SMALLEST"
210 LET L = L + 1
220 LET L(L) = PREVIOUSSMALLEST + SMALLEST
230 NEXT L
240 RETURN
250 PRINT
260 LET H = 1
270 FOR I = 0 TO L
280 IF NOT H(I) THEN H(I) = H
290 LET H = H(I) + LEN ( STR$ (L(I))) + 1
300 HTAB H(I)
310 PRINT L(I)" ";
320 NEXT I
330 RETURN
340 GOSUB 250"PRINT LIST"
350 GOSUB 370"FIND SMALLEST"
360 LET PREVIOUSSMALLEST = SMALLEST
370 LET S = 0
380 FOR I = 0 TO L
390 LET SMALLEST = L(S)
400 IF L(I) < SMALLEST THEN S = I
410 NEXT I
420 LET SMALLEST = L(S)
430 LET L = L - 1
440 IF S > L THEN RETURN
450 FOR I = S TO L
460 LET L(I) = L(I + 1)
470 LET H(I) = H(I + 1)
480 NEXT I
490 RETURN
- Output:
6 81 243 14 25 49 123 69 11 81 243 14 25 49 123 69 17 81 243 25 49 123 69 31 81 243 49 123 69 56 81 243 123 69 105 243 123 105 150 243 150 228 243 378 621
AppleScript
on lastListItem(lst)
set astid to AppleScript's text item delimiters
set AppleScript's text item delimiters to ", "
set output to {"Steps:", "{" & lst & "} ← Original"}
set len to (count lst)
if (len > 1) then
repeat with len from len to 3 by -1
set {i, j} to {1, 2}
set {s1, s2} to lst
if (s2 < s1) then set {i, s1, j, s2} to {j, s2, i, s1}
repeat with k from 3 to len
set v to lst's item k
if (v < s1) then
set {i, s1, j, s2} to {k, v, i, s1}
else if (v < s2) then
set {j, s2} to {k, v}
end if
end repeat
tell lst to set {item i, item j} to {missing value, missing value}
set lst to lst's numbers
set lst's end to s1 + s2
set output's end to "{" & lst & "} ← " & s1 & " + " & s2 & " = " & result
end repeat
tell lst to set end of output to "{" & (beginning + end) & "} ← " & beginning & " + " & end & " = " & (beginning + end)
end if
set AppleScript's text item delimiters to linefeed
set output to output as text
set AppleScript's text item delimiters to astid
return output
end lastListItem
lastListItem({6, 81, 243, 14, 25, 49, 123, 69, 11})
- Output:
"Steps:
{6, 81, 243, 14, 25, 49, 123, 69, 11} ← Original
{81, 243, 14, 25, 49, 123, 69, 17} ← 6 + 11 = 17
{81, 243, 25, 49, 123, 69, 31} ← 14 + 17 = 31
{81, 243, 49, 123, 69, 56} ← 25 + 31 = 56
{81, 243, 123, 69, 105} ← 49 + 56 = 105
{243, 123, 105, 150} ← 69 + 81 = 150
{243, 150, 228} ← 105 + 123 = 228
{243, 378} ← 150 + 228 = 378
{621} ← 243 + 378 = 621"
Arturo
lst: [6 81 243 14 25 49 123 69 11]
initial: lst
while [1 < size lst][
remove 'lst min1: <= min lst
remove 'lst min2: <= min lst
append 'lst min1 + min2
print ["List:" lst]
]
print ""
print [initial "=>" lst]
- Output:
List: [81 243 14 25 49 123 69 17] List: [81 243 25 49 123 69 31] List: [81 243 49 123 69 56] List: [81 243 123 69 105] List: [243 123 105 150] List: [243 150 228] List: [243 378] List: [621] [6 81 243 14 25 49 123 69 11] => [621]
AutoHotkey
List := [6, 81, 243, 14, 25, 49, 123, 69, 11]
steps := "Initial List `t`t`t" List2str(List) "`n"
while List.Count() > 1
{
sum := 0, str := ""
loop 2
{
num := min(List*)
sum += num
removeFromList(List, num)
str .= (!str ? "2 smallest numbers: " : " + ") num
}
List.Push(sum)
steps .= str " = " sum "`t" List2str(List) "`n"
}
MsgBox % result := steps
return
removeFromList(ByRef List, num){
for i, v in List
if (v = num)
{
List.RemoveAt(i)
break
}
}
List2str(List){
for i, v in List
unsorted_List .= v ", "
return "[" Trim(unsorted_List, ", ") "]"
}
- Output:
Initial List [6, 81, 243, 14, 25, 49, 123, 69, 11] 2 smallest numbers: 6 + 11 = 17 [81, 243, 14, 25, 49, 123, 69, 17] 2 smallest numbers: 14 + 17 = 31 [81, 243, 25, 49, 123, 69, 31] 2 smallest numbers: 25 + 31 = 56 [81, 243, 49, 123, 69, 56] 2 smallest numbers: 49 + 56 = 105 [81, 243, 123, 69, 105] 2 smallest numbers: 69 + 81 = 150 [243, 123, 105, 150] 2 smallest numbers: 105 + 123 = 228 [243, 150, 228] 2 smallest numbers: 150 + 228 = 378 [243, 378] 2 smallest numbers: 243 + 378 = 621 [621]
AWK
# syntax: GAWK -f LAST_LIST_ITEM.AWK
BEGIN {
split("6,81,243,14,25,49,123,69,11",arr1,",")
PROCINFO["sorted_in"] = "@val_num_asc"
while (length(arr1) > 1) {
for (i in arr1) { printf("%s ",arr1[i]) } # show sorted list
j = 0
delete arr2
for (i in arr1) { arr2[++j] = arr1[i] } # copy arr1 into arr2
sum = arr2[1] + arr2[2]
printf(": %s+%s=%s\n",arr2[1],arr2[2],sum)
delete arr2[2]
arr2[1] = sum
delete arr1
for (i in arr2) { arr1[i] = arr2[i] } # copy arr2 into arr1
}
printf("sum=%d\n",sum)
exit(0)
}
- Output:
6 11 14 25 49 69 81 123 243 : 6+11=17 14 17 25 49 69 81 123 243 : 14+17=31 25 31 49 69 81 123 243 : 25+31=56 49 56 69 81 123 243 : 49+56=105 69 81 105 123 243 : 69+81=150 105 123 150 243 : 105+123=228 150 228 243 : 150+228=378 243 378 : 243+378=621 sum=621
BQN
With and without sorting
list ← ⟨6, 81, 243, 14, 25, 49, 123, 69, 11⟩
W_sort ← {{i←2↑∧𝕩, (𝕩/˜¬𝕩∊i)∾+´i}⍟(↕≠𝕩)𝕩}
WO_sort ← {{m←⌊´𝕩, n←⌊´𝕩/˜¬m=𝕩, (𝕩/˜¬𝕩∊m‿n)∾m+n}⍟(↕≠𝕩)𝕩}
•Show¨W_sort list
•Show¨WO_sort list
⟨ 6 81 243 14 25 49 123 69 11 ⟩
⟨ 81 243 14 25 49 123 69 17 ⟩
⟨ 81 243 25 49 123 69 31 ⟩
⟨ 81 243 49 123 69 56 ⟩
⟨ 81 243 123 69 105 ⟩
⟨ 243 123 105 150 ⟩
⟨ 243 150 228 ⟩
⟨ 243 378 ⟩
⟨ 621 ⟩
⟨ 6 81 243 14 25 49 123 69 11 ⟩
⟨ 81 243 14 25 49 123 69 17 ⟩
⟨ 81 243 25 49 123 69 31 ⟩
⟨ 81 243 49 123 69 56 ⟩
⟨ 81 243 123 69 105 ⟩
⟨ 243 123 105 150 ⟩
⟨ 243 150 228 ⟩
⟨ 243 378 ⟩
⟨ 621 ⟩
C
With sorting
#include <stdio.h>
#include <stdlib.h>
int compare(const void *a, const void *b) {
int aa = *(const int *)a;
int bb = *(const int *)b;
if (aa < bb) return -1;
if (aa > bb) return 1;
return 0;
}
int main() {
int a[] = {6, 81, 243, 14, 25, 49, 123, 69, 11};
int isize = sizeof(int);
int asize = sizeof(a) / isize;
int i, sum;
while (asize > 1) {
qsort(a, asize, isize, compare);
printf("Sorted list: ");
for (i = 0; i < asize; ++i) printf("%d ", a[i]);
printf("\n");
sum = a[0] + a[1];
printf("Two smallest: %d + %d = %d\n", a[0], a[1], sum);
for (i = 2; i < asize; ++i) a[i-2] = a[i];
a[asize - 2] = sum;
asize--;
}
printf("Last item is %d.\n", a[0]);
return 0;
}
- Output:
Sorted list: 6 11 14 25 49 69 81 123 243 Two smallest: 6 + 11 = 17 Sorted list: 14 17 25 49 69 81 123 243 Two smallest: 14 + 17 = 31 Sorted list: 25 31 49 69 81 123 243 Two smallest: 25 + 31 = 56 Sorted list: 49 56 69 81 123 243 Two smallest: 49 + 56 = 105 Sorted list: 69 81 105 123 243 Two smallest: 69 + 81 = 150 Sorted list: 105 123 150 243 Two smallest: 105 + 123 = 228 Sorted list: 150 228 243 Two smallest: 150 + 228 = 378 Sorted list: 243 378 Two smallest: 243 + 378 = 621 Last item is 621.
Without sorting
#include <stdio.h>
int findMin(int a[], int asize, int *pmin) {
int i, ix = 0;
*pmin = a[0];
for (i = 0; i < asize; ++i) {
if (a[i] < *pmin) {
ix = i;
*pmin = a[i];
}
}
return ix;
}
int main() {
int a[] = {6, 81, 243, 14, 25, 49, 123, 69, 11};
int isize = sizeof(int);
int asize = sizeof(a) / isize;
int i, j, sum, ix, min = 0, s[2];
while (asize > 1) {
printf("List: ");
for (i = 0; i < asize; ++i) printf("%d ", a[i]);
printf("\n");
for (i = 0; i < 2; ++i) {
ix = findMin(a, asize, &min);
s[i] = min;
for (j = ix+1; j < asize; ++j) a[j-1] = a[j];
asize--;
}
sum = s[0] + s[1];
printf("Two smallest: %d + %d = %d\n", s[0], s[1], sum);
a[asize] = sum;
asize++;
}
printf("Last item is %d.\n", a[0]);
return 0;
}
- Output:
List: 6 81 243 14 25 49 123 69 11 Two smallest: 6 + 11 = 17 List: 81 243 14 25 49 123 69 17 Two smallest: 14 + 17 = 31 List: 81 243 25 49 123 69 31 Two smallest: 25 + 31 = 56 List: 81 243 49 123 69 56 Two smallest: 49 + 56 = 105 List: 81 243 123 69 105 Two smallest: 69 + 81 = 150 List: 243 123 105 150 Two smallest: 105 + 123 = 228 List: 243 150 228 Two smallest: 150 + 228 = 378 List: 243 378 Two smallest: 243 + 378 = 621 Last item is 621.
C++
#include <iostream>
#include <list>
using namespace std;
void PrintContainer(const auto& container)
{
cout << "[ ";
for_each(container.begin(), container.end(), [](auto item){cout << item << " ";});
cout << "]";
}
int main()
{
list<int> numbers{6, 81, 243, 14, 25, 49, 123, 69, 11};
// a lambda to remove the minimum item
auto removeMin = [](auto& container)
{
auto minIterator = min_element(container.begin(), container.end());
auto minValue = *minIterator;
container.erase(minIterator);
return minValue;
};
while(numbers.size() > 1)
{
PrintContainer(numbers);
auto minValue = removeMin(numbers);
auto nextMinValue = removeMin(numbers);
auto sum = minValue + nextMinValue;
numbers.push_back(sum);
cout << " => " << minValue << " + " << nextMinValue << " = " << sum << "\n";
}
cout << "Final list: "; PrintContainer(numbers); cout << "\n";
}
- Output:
[ 6 81 243 14 25 49 123 69 11 ] => 6 + 11 = 17 [ 81 243 14 25 49 123 69 17 ] => 14 + 17 = 31 [ 81 243 25 49 123 69 31 ] => 25 + 31 = 56 [ 81 243 49 123 69 56 ] => 49 + 56 = 105 [ 81 243 123 69 105 ] => 69 + 81 = 150 [ 243 123 105 150 ] => 105 + 123 = 228 [ 243 150 228 ] => 150 + 228 = 378 [ 243 378 ] => 243 + 378 = 621 Final list: [ 621 ]
Delphi
Uses standard Delphi object "TList" to manipulate the array.
procedure FindSmallest(LS: TList; var Index,Value: Integer);
{Find smallest value in LIst}
var I: integer;
begin
Value:=High(integer);
for I:=0 to LS.Count-1 do
if integer(LS[I])<Value then
begin
Value:=integer(LS[I]);
Index:=I;
end;
end;
procedure ShowArray(Memo: TMemo; LS: TList);
{Display the contents of specified array}
var I: integer;
var S: string;
begin
S:='[';
for I:=0 to LS.Count-1 do
begin
if I>0 then S:=S+' ';
S:=S+IntToStr(Integer(LS[I]));
end;
S:=S+']';
Memo.Lines.Add(S);
end;
procedure LastItem(Memo: TMemo; IA: array of integer);
{Repeatedly remove the two lowest values}
{Add them together and add to the list}
var LS: TList;
var I,Inx,Val1,Val2: integer;
begin
LS:=TList.Create;
try
for I:=0 to High(IA) do LS.Add(Pointer(IA[I]));
while LS.Count>1 do
begin
ShowArray(Memo,LS);
FindSmallest(LS,Inx,Val1);
LS.Delete(Inx);
FindSmallest(LS,Inx,Val2);
LS.Delete(Inx);
LS.Add(Pointer(Val1 + Val2))
end;
Memo.Lines.Add(IntToStr(integer(LS[0])));
finally LS.Free; end;
end;
{Supplied test array}
const IntArray: array [0..8] of integer=(6, 81, 243, 14, 25, 49, 123, 69, 11);
procedure DoLastItem(Memo: TMemo);
{Do last item problem}
begin
LastItem(Memo,IntArray);
end;
- Output:
[6 81 243 14 25 49 123 69 11] [81 243 14 25 49 123 69 17] [81 243 25 49 123 69 31] [81 243 49 123 69 56] [81 243 123 69 105] [243 123 105 150] [243 150 228] [243 378] 621
EasyLang
l[] = [ 6 81 243 14 25 49 123 69 11 ]
while len l[] > 1
sum = 0
for k to 2
for i to len l[] - 1
if l[i] < l[$]
swap l[i] l[$]
.
.
sum += l[$]
len l[] -1
.
l[] &= sum
print l[]
.
- Output:
[ 69 81 243 14 25 49 123 17 ] [ 123 81 243 69 25 49 31 ] [ 123 81 243 69 49 56 ] [ 123 81 243 69 105 ] [ 123 105 243 150 ] [ 243 150 228 ] [ 243 378 ] [ 621 ]
Factor
USING: formatting io kernel math math.statistics prettyprint
sequences sequences.extras ;
: list. ( seq -- )
"List: " write [ bl ] [ pprint ] interleave nl ;
: smallest. ( seq -- )
first2 2dup + "Two smallest: %d + %d = %d\n" printf ;
: remove-all-first! ( seq elts -- seq' )
[ swap remove-first! ] each ;
: step ( seq -- seq' )
dup { 0 1 } kth-smallests tuck remove-all-first! over
smallest. swap sum suffix! ;
V{ 6 81 243 14 25 49 123 69 11 }
[ dup length 1 > ] [ dup list. step ] while
last "Last item is %d.\n" printf
- Output:
List: 6 81 243 14 25 49 123 69 11 Two smallest: 6 + 11 = 17 List: 81 243 14 25 49 123 69 17 Two smallest: 14 + 17 = 31 List: 81 243 25 49 123 69 31 Two smallest: 25 + 31 = 56 List: 81 243 49 123 69 56 Two smallest: 49 + 56 = 105 List: 81 243 123 69 105 Two smallest: 69 + 81 = 150 List: 243 123 105 150 Two smallest: 105 + 123 = 228 List: 243 150 228 Two smallest: 150 + 228 = 378 List: 243 378 Two smallest: 243 + 378 = 621 Last item is 621.
FreeBASIC
#define HUGE 99999999
redim as integer list(0 to 8)
list(0) = 6 :list(1) = 81:list(2) = 243:list(3) = 14:list(4) = 25:list(5) = 49:list(6) = 123:list(7) = 69:list(8) = 11
dim as integer s, si, ss, ssi, i
for i = 0 to ubound(list)
print list(i);" ";
next i
print
while ubound(list) > 0
s = HUGE
ss = HUGE
for i = 0 to ubound(list)
if list(i)<s then
ss = s
ssi = si
s = list(i)
si = i
elseif list(i)<ss then
ss = list(i)
ssi = i
end if
next i
if ss<s then swap s, ss
for i = si to ubound(list)-1
list(i) = list(i+1)
next i
for i = ssi to ubound(list)-2
list(i) = list(i+1)
next i
list(ubound(list)-1) = s+ss
redim preserve list(0 to ubound(list)-1)
for i = 0 to ubound(list)
print list(i);" ";
next i
print
wend
- Output:
6 81 243 14 25 49 123 69 11 81 243 14 25 49 123 69 17 81 243 25 49 123 69 31 81 243 49 123 69 56 81 243 123 69 105 243 123 105 150 243 150 228 243 378 621
Go
With sorting
package main
import (
"fmt"
"sort"
)
func main() {
a := []int{6, 81, 243, 14, 25, 49, 123, 69, 11}
for len(a) > 1 {
sort.Ints(a)
fmt.Println("Sorted list:", a)
sum := a[0] + a[1]
fmt.Printf("Two smallest: %d + %d = %d\n", a[0], a[1], sum)
a = append(a, sum)
a = a[2:]
}
fmt.Println("Last item is", a[0], "\b.")
}
- Output:
Sorted list: [6 11 14 25 49 69 81 123 243] Two smallest: 6 + 11 = 17 Sorted list: [14 17 25 49 69 81 123 243] Two smallest: 14 + 17 = 31 Sorted list: [25 31 49 69 81 123 243] Two smallest: 25 + 31 = 56 Sorted list: [49 56 69 81 123 243] Two smallest: 49 + 56 = 105 Sorted list: [69 81 105 123 243] Two smallest: 69 + 81 = 150 Sorted list: [105 123 150 243] Two smallest: 105 + 123 = 228 Sorted list: [150 228 243] Two smallest: 150 + 228 = 378 Sorted list: [243 378] Two smallest: 243 + 378 = 621 Last item is 621.
Without sorting
package main
import "fmt"
func findMin(a []int) (int, int) {
ix := 0
min := a[0]
for i := 1; i < len(a); i++ {
if a[i] < min {
ix = i
min = a[i]
}
}
return min, ix
}
func main() {
a := []int{6, 81, 243, 14, 25, 49, 123, 69, 11}
for len(a) > 1 {
fmt.Println("List:", a)
var s [2]int
for i := 0; i < 2; i++ {
min, ix := findMin(a)
s[i] = min
a = append(a[:ix], a[ix+1:]...)
}
sum := s[0] + s[1]
fmt.Printf("Two smallest: %d + %d = %d\n", s[0], s[1], sum)
a = append(a, sum)
}
fmt.Println("Last item is", a[0], "\b.")
}
- Output:
List: [6 81 243 14 25 49 123 69 11] Two smallest: 6 + 11 = 17 List: [81 243 14 25 49 123 69 17] Two smallest: 14 + 17 = 31 List: [81 243 25 49 123 69 31] Two smallest: 25 + 31 = 56 List: [81 243 49 123 69 56] Two smallest: 49 + 56 = 105 List: [81 243 123 69 105] Two smallest: 69 + 81 = 150 List: [243 123 105 150] Two smallest: 105 + 123 = 228 List: [243 150 228] Two smallest: 150 + 228 = 378 List: [243 378] Two smallest: 243 + 378 = 621 Last item is 621.
J
Here we maintain the unsorted order in the intermediate steps:
rplc&(' 0';'')"1": ((-. , +/@]) 2 {. /:~)^:a: 81 243 14 25 49 123 69 17
81 243 14 25 49 123 69 17
81 243 25 49 123 69 31
81 243 49 123 69 56
81 243 123 69 105
243 123 105 150
243 150 228
243 378
621
Alternative interpretation:
([[:echo,:#~1<#)@((-. , +/@]) 2 {. /:~)^:_] 81 243 14 25 49 123 69 17
81 243 25 49 123 69 31
81 243 49 123 69 56
81 243 123 69 105
243 123 105 150
243 150 228
243 378
621
jq
Adapted from Wren
Works with gojq, the Go implementation of jq
With sorting
def task_with_sorting:
foreach range(1; length) as $i ( {a: .};
.a |= sort
| .emit = "Sorted list: \(.a)\n"
| (.a[0] + .a[1]) as $sum
| .emit += "Two smallest: \(.a[0]) + \(.a[1]) = \($sum)"
| .a += [$sum]
| .a |= .[2:] ;
.emit,
(select(.a|length==1) | "Last item is \(.a[0]).") );
[6, 81, 243, 14, 25, 49, 123, 69, 11]
| task_with_sorting
- Output:
Sorted list: [6,11,14,25,49,69,81,123,243] Two smallest: 6 + 11 = 17 Sorted list: [14,17,25,49,69,81,123,243] Two smallest: 14 + 17 = 31 Sorted list: [25,31,49,69,81,123,243] Two smallest: 25 + 31 = 56 Sorted list: [49,56,69,81,123,243] Two smallest: 49 + 56 = 105 Sorted list: [69,81,105,123,243] Two smallest: 69 + 81 = 150 Sorted list: [105,123,150,243] Two smallest: 105 + 123 = 228 Sorted list: [150,228,243] Two smallest: 150 + 228 = 378 Sorted list: [243,378] Two smallest: 243 + 378 = 621 Last item is 621.
Without sorting
def min_index:
. as $in
| reduce range(0; length) as $i ( null;
$in[$i] as $x
| if . == null then {ix: 0, min: $x}
elif $x < .min then {ix: $i, min: $x}
else . end)
| .ix;
def task_without_sorting:
# Output: [min, remainder]
def remove_min:
min_index as $ix
| [.[$ix], (.[:$ix] + .[$ix + 1:])];
foreach range(1; length) as $i ( {a: .};
.emit = "Unsorted list: \(.a)\n"
| (.a | remove_min) as [$m1, $x]
| ($x | remove_min) as [$m2, $y]
| ($m1 + $m2) as $sum
| .emit += "Two smallest: \($m1) + \($m2) = \($sum)"
| .a = $y + [$sum] ;
.emit,
(select(.a|length==1) | "Last item is \(.a[0]).") );
[6, 81, 243, 14, 25, 49, 123, 69, 11]
| task_without_sorting
- Output:
Unsorted list: [6,81,243,14,25,49,123,69,11] Two smallest: 6 + 11 = 17 Unsorted list: [81,243,14,25,49,123,69,17] Two smallest: 14 + 17 = 31 Unsorted list: [81,243,25,49,123,69,31] Two smallest: 25 + 31 = 56 Unsorted list: [81,243,49,123,69,56] Two smallest: 49 + 56 = 105 Unsorted list: [81,243,123,69,105] Two smallest: 69 + 81 = 150 Unsorted list: [243,123,105,150] Two smallest: 105 + 123 = 228 Unsorted list: [243,150,228] Two smallest: 150 + 228 = 378 Unsorted list: [243,378] Two smallest: 243 + 378 = 621 Last item is 621.
Julia
list = [6, 81, 243, 14, 25, 49, 123, 69, 11]
function addleastreduce!(lis)
while length(lis) > 1
push!(lis, popat!(lis, last(findmin(lis))) + popat!(lis, last(findmin(lis))))
println("Interim list: $lis")
end
return lis
end
@show list, addleastreduce!(copy(list))
- Output:
Interim list: [81, 243, 14, 25, 49, 123, 69, 17] Interim list: [81, 243, 25, 49, 123, 69, 31] Interim list: [81, 243, 49, 123, 69, 56] Interim list: [81, 243, 123, 69, 105] Interim list: [243, 123, 105, 150] Interim list: [243, 150, 228] Interim list: [243, 378] Interim list: [621] (list, addleastreduce!(copy(list))) = ([6, 81, 243, 14, 25, 49, 123, 69, 11], [621])
Mathematica/Wolfram Language
With and without sorting
list = {6, 81, 243, 14, 25, 49, 123, 69, 11};
Print[list]
Do[
poss = Ordering[list, 2];
extr = Extract[list, List /@ poss];
extr //= Total;
list = Delete[list, List /@ poss];
AppendTo[list, extr];
Print[list]
,
{Length[list] - 1}
]
- Output:
{6,81,243,14,25,49,123,69,11} {81,243,14,25,49,123,69,17} {81,243,25,49,123,69,31} {81,243,49,123,69,56} {81,243,123,69,105} {243,123,105,150} {243,150,228} {243,378} {621}
Nim
With sorting
We sort in descending order as it is more efficient.
# With sorting.
import algorithm, strformat
proc extractAndAddTwoSmallest(list: var seq[int]) =
list.sort(Descending)
stdout.write &"Descending sorted list: {list}"
let min1 = list.pop()
let min2 = list.pop()
echo &"; two smallest: {min1} and {min2}; sum = {min1 + min2}"
list.add min1 + min2
var list = @[6, 81, 243, 14, 25, 49, 123, 69, 11]
while list.len >= 2:
list.extractAndAddTwoSmallest()
echo &"Last item is {list[0]}."
- Output:
Descending sorted list: @[243, 123, 81, 69, 49, 25, 14, 11, 6]; two smallest: 6 and 11; sum = 17 Descending sorted list: @[243, 123, 81, 69, 49, 25, 17, 14]; two smallest: 14 and 17; sum = 31 Descending sorted list: @[243, 123, 81, 69, 49, 31, 25]; two smallest: 25 and 31; sum = 56 Descending sorted list: @[243, 123, 81, 69, 56, 49]; two smallest: 49 and 56; sum = 105 Descending sorted list: @[243, 123, 105, 81, 69]; two smallest: 69 and 81; sum = 150 Descending sorted list: @[243, 150, 123, 105]; two smallest: 105 and 123; sum = 228 Descending sorted list: @[243, 228, 150]; two smallest: 150 and 228; sum = 378 Descending sorted list: @[378, 243]; two smallest: 243 and 378; sum = 621 Last item is 621.
Without sorting
We could use the function minIndex
from module sequtils
but it would be less efficient. We used a single loop instead. Please note that we remove the elements using function del
which is O(1) rather than function delete
which is O(n).
# Without sorting.
import strformat
proc extractAndAddTwoSmallest(list: var seq[int]) =
var min1, min2 = int.high
var imin1, imin2 = -1
for i, val in list:
if val < min1:
min2 = min1
min1 = val
imin2 = imin1
imin1 = i
elif val < min2:
min2 = val
imin2 = i
echo &"List: {list}; two smallest: {min1}@{imin1} and {min2}@{imin2}; sum = {min1 + min2}"
if imin1 > imin2: swap imin1, imin2 # Make sure "imin2" is the greatest index.
list.del imin2
list.del imin1
list.add min1 + min2
var list = @[6, 81, 243, 14, 25, 49, 123, 69, 11]
while list.len >= 2:
list.extractAndAddTwoSmallest()
echo &"Last item is {list[0]}."
- Output:
List: @[6, 81, 243, 14, 25, 49, 123, 69, 11]; two smallest: 6@0 and 11@8; sum = 17 List: @[69, 81, 243, 14, 25, 49, 123, 17]; two smallest: 14@3 and 17@7; sum = 31 List: @[69, 81, 243, 123, 25, 49, 31]; two smallest: 25@4 and 31@6; sum = 56 List: @[69, 81, 243, 123, 49, 56]; two smallest: 49@4 and 56@5; sum = 105 List: @[69, 81, 243, 123, 105]; two smallest: 69@0 and 81@1; sum = 150 List: @[123, 105, 243, 150]; two smallest: 105@1 and 123@0; sum = 228 List: @[243, 150, 228]; two smallest: 150@1 and 228@2; sum = 378 List: @[243, 378]; two smallest: 243@0 and 378@1; sum = 621 Last item is 621.
Perl
use strict;
use warnings;
use feature 'say';
use List::AllUtils <min firstidx>;
my @list = <6 81 243 14 25 49 123 69 11>;
say " Original @list";
push @list, get(min @list) + get(min @list) and say "@list" while @list > 1;
sub get {
my($min) = @_;
splice @list, (firstidx { $min == $_ } @list), 1;
printf " %3d ", $min;
$min;
}
- Output:
Original 6 81 243 14 25 49 123 69 11 6 11 81 243 14 25 49 123 69 17 14 17 81 243 25 49 123 69 31 25 31 81 243 49 123 69 56 49 56 81 243 123 69 105 69 81 243 123 105 150 105 123 243 150 228 150 228 243 378 243 378 621
Phix
With sorting
with javascript_semantics sequence list = {6, 81, 243, 14, 25, 49, 123, 69, 11} while length(list)>1 do list = sort(deep_copy(list)) integer l1 = list[1], l2 = list[2], l12 = l1+l2 printf(1,"Sorted list: %V, two smallest: %d + %d = %d\n",{list,l1,l2,l12}) list[1..2] = {l12} end while printf(1,"Last item is %d\n",list)
- Output:
Sorted list: {6,11,14,25,49,69,81,123,243}, two smallest: 6 + 11 = 17 Sorted list: {14,17,25,49,69,81,123,243}, two smallest: 14 + 17 = 31 Sorted list: {25,31,49,69,81,123,243}, two smallest: 25 + 31 = 56 Sorted list: {49,56,69,81,123,243}, two smallest: 49 + 56 = 105 Sorted list: {69,81,105,123,243}, two smallest: 69 + 81 = 150 Sorted list: {105,123,150,243}, two smallest: 105 + 123 = 228 Sorted list: {150,228,243}, two smallest: 150 + 228 = 378 Sorted list: {243,378}, two smallest: 243 + 378 = 621 Last item is 621
Without sorting
with javascript_semantics sequence list = {6, 81, 243, 14, 25, 49, 123, 69, 11} while length(list)>1 do printf(1,"List: %V, two smallest: ",{list}) integer l1, l2 = 0 for i=1 to 2 do l1 = l2 integer ldx = smallest(list,true) l2 = list[ldx] list = list[1..ldx-1] & list[ldx+1..$] end for printf(1,"%d + %d = %d\n",{l1,l2,l1+l2}) list &= l1+l2 end while printf(1,"Last item is %d\n",list)
- Output:
List: {6,81,243,14,25,49,123,69,11}, two smallest: 6 + 11 = 17 List: {81,243,14,25,49,123,69,17}, two smallest: 14 + 17 = 31 List: {81,243,25,49,123,69,31}, two smallest: 25 + 31 = 56 List: {81,243,49,123,69,56}, two smallest: 49 + 56 = 105 List: {81,243,123,69,105}, two smallest: 69 + 81 = 150 List: {243,123,105,150}, two smallest: 105 + 123 = 228 List: {243,150,228}, two smallest: 150 + 228 = 378 List: {243,378}, two smallest: 243 + 378 = 621 Last item is 621
Python
""" Rosetta code task: Last list item """
def add_least_reduce(lis):
""" Reduce lis: sum least two elements adding sum to list. Will take len(list) - 1 steps """
while len(lis) > 1:
lis.append(lis.pop(lis.index(min(lis))) + lis.pop(lis.index(min(lis))))
print('Interim list:', lis)
return lis
LIST = [6, 81, 243, 14, 25, 49, 123, 69, 11]
print(LIST, ' ==> ', add_least_reduce(LIST.copy()))
- Output:
Interim list: [81, 243, 14, 25, 49, 123, 69, 17] Interim list: [81, 243, 25, 49, 123, 69, 31] Interim list: [81, 243, 49, 123, 69, 56] Interim list: [81, 243, 123, 69, 105] Interim list: [243, 123, 105, 150] Interim list: [243, 150, 228] Interim list: [243, 378] Interim list: [621] [6, 81, 243, 14, 25, 49, 123, 69, 11] ==> [621]
Quackery
[ behead
-1 swap rot witheach
[ 2dup > if
[ i^ swap
2swap drop ]
drop ]
drop 1+ ] is least ( [ --> n )
' [ 6 81 243 14 25 49 123 69 11 ]
[ dup echo cr
dup size 1 > while
dup least pluck
swap
dup least pluck
rot + join
again ]
0 peek echo
- Output:
[ 6 81 243 14 25 49 123 69 11 ] [ 81 243 14 25 49 123 69 17 ] [ 81 243 25 49 123 69 31 ] [ 81 243 49 123 69 56 ] [ 81 243 123 69 105 ] [ 243 123 105 150 ] [ 243 150 228 ] [ 243 378 ] [ 621 ] 621
Raku
Uses no sorting; does not modify overall list order while processing.
say ' Original ', my @list = 6, 81, 243, 14, 25, 49, 123, 69, 11;
say push @list: get(min @list) + get(min @list) while @list > 1;
sub get ($min) {
@list.splice: @list.first(* == $min, :k), 1;
printf " %3d ", $min;
$min;
}
- Output:
Original [6 81 243 14 25 49 123 69 11] 6 11 [81 243 14 25 49 123 69 17] 14 17 [81 243 25 49 123 69 31] 25 31 [81 243 49 123 69 56] 49 56 [81 243 123 69 105] 69 81 [243 123 105 150] 105 123 [243 150 228] 150 228 [243 378] 243 378 [621]
REXX
With sorting
/* REXX */
List = '6 81 243 14 25 49 123 69 11'
Do Until words(list)=1
list=wordsort(list)
Say 'Sorted list:' list
Parse Var list a b c
Say 'Two smallest:' a '+' b '=' (a+b)
list=(a+b) c
End
Say 'Last item:' list
Exit
wordsort: Procedure
/**********************************************************************
* Sort the list of words supplied as argument. Return the sorted list
**********************************************************************/
Parse Arg wl
wa.=''
wa.0=0
Do While wl<>''
Parse Var wl w wl
Do i=1 To wa.0
If wa.i>w Then Leave
End
If i<=wa.0 Then Do
Do j=wa.0 To i By -1
ii=j+1
wa.ii=wa.j
End
End
wa.i=w
wa.0=wa.0+1
End
swl=''
Do i=1 To wa.0
swl=swl wa.i
End
Return strip(swl)
- Output:
Sorted list: 6 11 14 25 49 69 81 123 243 Two smallest: 6 + 11 = 17 Sorted list: 14 17 25 49 69 81 123 243 Two smallest: 14 + 17 = 31 Sorted list: 25 31 49 69 81 123 243 Two smallest: 25 + 31 = 56 Sorted list: 49 56 69 81 123 243 Two smallest: 49 + 56 = 105 Sorted list: 69 81 105 123 243 Two smallest: 69 + 81 = 150 Sorted list: 105 123 150 243 Two smallest: 105 + 123 = 228 Sorted list: 150 228 243 Two smallest: 150 + 228 = 378 Sorted list: 243 378 Two smallest: 243 + 378 = 621 Last item: 621
Without sorting
/* REXX */
List = '6 81 243 14 25 49 123 69 11'
Do Until words(list)=1
Say 'List:' list
a=getmin()
b=getmin()
Say 'Two smallest:' a '+' b '=' (a+b)
list=list (a+b)
End
Say 'Last item:' list
Exit
getmin: Procedure Expose list
/* Return the smallest element of list and remove it from list */
min=1e9
Do i=1 To words(list)
If word(list,i)<min Then Do
m=word(list,i)
min=m
j=i
End
End
list=subword(list,1,j-1) subword(list,j+1)
Return m
- Output:
List: 6 81 243 14 25 49 123 69 11 Two smallest: 6 + 11 = 17 List: 81 243 14 25 49 123 69 17 Two smallest: 14 + 17 = 31 List: 81 243 25 49 123 69 31 Two smallest: 25 + 31 = 56 List: 81 243 49 123 69 56 Two smallest: 49 + 56 = 105 List: 81 243 123 69 105 Two smallest: 69 + 81 = 150 List: 243 123 105 150 Two smallest: 105 + 123 = 228 List: 243 150 228 Two smallest: 150 + 228 = 378 List: 243 378 Two smallest: 243 + 378 = 621 Last item: 621
Ring
With sorting
see "working..." + nl
List = [6,81,243,14,25,49,123,69,11]
n = 0
while true
n++
List = sort(List)
first = List[1]
second = List[2]
ind1 = find(List,first)
ind2 = find(List,second)
if ind1 < ind2
del(List,ind2)
del(List,ind1)
else
del(List,ind1)
del(List,ind2)
ok
sum = first + second
add(List,sum)
if len(List) = 1
exit
ok
if n = 1
see nl + "List = "
showArray(List)
see nl
ok
showList(first,second,sum,List)
end
see "Last item is: " +List[1] + nl
see "done..." + nl
func showList(first,second,sum,List)
see "two smallest is = " + first + " + " + second + " = " + sum + nl
see "List = "
showArray(List)
func showArray(array)
txt = ""
see "["
for n = 1 to len(array)
txt = txt + array[n] + ","
next
txt = left(txt,len(txt)-1)
txt = txt + "]"
see txt + nl
- Output:
working... List = [14,25,49,69,81,123,243,17] two smallest is = 6 + 11 = 17 List = [14,25,49,69,81,123,243,17] two smallest is = 14 + 17 = 31 List = [25,49,69,81,123,243,31] two smallest is = 25 + 31 = 56 List = [49,69,81,123,243,56] two smallest is = 49 + 56 = 105 List = [69,81,123,243,105] two smallest is = 69 + 81 = 150 List = [105,123,243,150] two smallest is = 105 + 123 = 228 List = [150,243,228] two smallest is = 150 + 228 = 378 List = [243,378] Last item is: 621 done...
Without sorting
see "working..." + nl
List = [6,81,243,14,25,49,123,69,11]
n = 0
while true
n++
if n = 1
see nl + "List = "
showArray(List)
see nl
ok
first = min(List)
ind1 = find(List,first)
del(List,ind1)
second = min(List)
ind2 = find(List,second)
del(List,ind2)
sum = first + second
add(List,sum)
if len(List) = 1
exit
ok
showList(first,second,sum,List)
end
see "Last item is: " +List[1] + nl
see "done..." + nl
func showList(first,second,sum,List)
see "two smallest is = " + first + " + " + second + " = " + sum + nl
see "List = "
showArray(List)
func showArray(array)
txt = ""
see "["
for n = 1 to len(array)
txt = txt + array[n] + ","
next
txt = left(txt,len(txt)-1)
txt = txt + "]"
see txt + nl
- Output:
working... List = [6,81,243,14,25,49,123,69,11] two smallest is = 6 + 11 = 17 List = [81,243,14,25,49,123,69,17] two smallest is = 14 + 17 = 31 List = [81,243,25,49,123,69,31] two smallest is = 25 + 31 = 56 List = [81,243,49,123,69,56] two smallest is = 49 + 56 = 105 List = [81,243,123,69,105] two smallest is = 69 + 81 = 150 List = [243,123,105,150] two smallest is = 105 + 123 = 228 List = [243,150,228] two smallest is = 150 + 228 = 378 List = [243,378] Last item is: 621 done...
RPL
≪ WHILE DUP SIZE 1 > REPEAT DUP LIST→ → len ≪ 0 1 FOR j 2 len j - START len j - ROLL IF DUP2 < THEN SWAP END NEXT len ROLLD NEXT len ROLL len ROLL + len 1 - →LIST ≫ END ≫ 'LASTL' STO
- Input:
{ 6 11 14 25 49 69 81 123 243 } LASTL
- Output:
9: { 6 11 14 25 49 69 81 123 243 } 8: { 243 123 14 25 49 69 81 17 } 7: { 243 123 81 25 49 69 31 } 6: { 243 123 81 69 49 56 } 5: { 243 123 81 69 105 } 4: { 243 123 105 150 } 3: { 243 150 228 } 2: { 243 378 } 1: { 621 }
Ruby
p original = [6, 81, 243, 14, 25, 49, 123, 69, 11]
until original.size == 1 do
mins = original.min(2)
mins.each{|el| original.delete_at(original.index(el)) }
p original << mins.sum
end
- Output:
[6, 81, 243, 14, 25, 49, 123, 69, 11] [81, 243, 14, 25, 49, 123, 69, 17] [81, 243, 25, 49, 123, 69, 31] [81, 243, 49, 123, 69, 56] [81, 243, 123, 69, 105] [243, 123, 105, 150] [243, 150, 228] [243, 378] [621]
Sidef
With sorting
var k = 2
var list = [6, 81, 243, 14, 25, 49, 123, 69, 11]
while (list.len >= k) {
var a = list.sort!.shift(k)
list << a.sum
say "#{a.map{'%3s' % _}.join(' ')} : #{list}"
}
- Output:
6 11 : [14, 25, 49, 69, 81, 123, 243, 17] 14 17 : [25, 49, 69, 81, 123, 243, 31] 25 31 : [49, 69, 81, 123, 243, 56] 49 56 : [69, 81, 123, 243, 105] 69 81 : [105, 123, 243, 150] 105 123 : [150, 243, 228] 150 228 : [243, 378] 243 378 : [621]
Without sorting
var k = 2
var list = [6, 81, 243, 14, 25, 49, 123, 69, 11]
while (list.len >= k) {
var a = gather {
k.times {
take(var v = list.min)
list.delete_first(v)
}
}
list << a.sum
say "#{a.map{'%3s' % _}.join(' ')} : #{list}"
}
- Output:
6 11 : [81, 243, 14, 25, 49, 123, 69, 17] 14 17 : [81, 243, 25, 49, 123, 69, 31] 25 31 : [81, 243, 49, 123, 69, 56] 49 56 : [81, 243, 123, 69, 105] 69 81 : [243, 123, 105, 150] 105 123 : [243, 150, 228] 150 228 : [243, 378] 243 378 : [621]
V (Vlang)
With sorting
fn main() {
mut a := [6, 81, 243, 14, 25, 49, 123, 69, 11]
for a.len > 1 {
a.sort()
println("Sorted list: $a")
sum := a[0] + a[1]
println("Two smallest: ${a[0]} + ${a[1]} = $sum")
a << sum
a = a[2..]
}
println("Last item is ${a[0]}.")
}
- Output:
Sorted list: [6, 11, 14, 25, 49, 69, 81, 123, 243] Two smallest: 6 + 11 = 17 Sorted list: [14, 17, 25, 49, 69, 81, 123, 243] Two smallest: 14 + 17 = 31 Sorted list: [25, 31, 49, 69, 81, 123, 243] Two smallest: 25 + 31 = 56 Sorted list: [49, 56, 69, 81 123, 243] Two smallest: 49 + 56 = 105 Sorted list: [69, 81, 105, 123, 243] Two smallest: 69 + 81 = 150 Sorted list: [105, 123, 150, 243] Two smallest: 105 + 123, = 228 Sorted list: [150, 228, 243] Two smallest: 150 + 228, = 378 Sorted list: [243, 378] Two smallest: 243 + 378 = 621 Last item is 621.
Without sorting
fn find_min(a []int) (int, int) {
mut ix := 0
mut min := a[0]
for i in 1..a.len {
if a[i] < min {
ix = i
min = a[i]
}
}
return min, ix
}
fn main() {
mut a := [6, 81, 243, 14, 25, 49, 123, 69, 11]
for a.len > 1 {
println("List: $a")
mut s := [2]int{}
for i in 0..2 {
min, ix := find_min(a)
s[i] = min
a.delete(ix)
}
sum := s[0] + s[1]
println("Two smallest: ${s[0]} + ${s[1]} = $sum")
a << sum
}
println("Last item is ${a[0]}.")
}
- Output:
List: [6, 81, 243, 14, 25, 49, 123, 69, 11] Two smallest: 6 + 11 = 17 List: [81, 243, 14, 25, 49, 123, 69, 17] Two smallest: 14 + 17 = 31 List: [81, 243, 25, 49, 123, 69, 31] Two smallest: 25 + 31 = 56 List: [81, 243, 49, 123, 69, 56] Two smallest: 49 + 56 = 105 List: [81, 243, 123, 69, 105] Two smallest: 69 + 81 = 150 List: [24,3 123, 105, 150] Two smallest: 105 + 123 = 228 List: [243, 150, 228] Two smallest: 150 + 228 = 378 List: [243, 378] Two smallest: 243 + 378 = 621 Last item is 621.
Wren
With sorting
var a = [6, 81, 243, 14, 25, 49, 123, 69, 11]
while (a.count > 1) {
a.sort()
System.print("Sorted list: %(a)")
var sum = a[0] + a[1]
System.print("Two smallest: %(a[0]) + %(a[1]) = %(sum)")
a.add(sum)
a = a[2..-1]
}
System.print("Last item is %(a[0]).")
- Output:
Sorted list: [6, 11, 14, 25, 49, 69, 81, 123, 243] Two smallest: 6 + 11 = 17 Sorted list: [14, 17, 25, 49, 69, 81, 123, 243] Two smallest: 14 + 17 = 31 Sorted list: [25, 31, 49, 69, 81, 123, 243] Two smallest: 25 + 31 = 56 Sorted list: [49, 56, 69, 81, 123, 243] Two smallest: 49 + 56 = 105 Sorted list: [69, 81, 105, 123, 243] Two smallest: 69 + 81 = 150 Sorted list: [105, 123, 150, 243] Two smallest: 105 + 123 = 228 Sorted list: [150, 228, 243] Two smallest: 150 + 228 = 378 Sorted list: [243, 378] Two smallest: 243 + 378 = 621 Last item is 621.
Without sorting
var findMin = Fn.new { |a|
var ix = 0
var min = a[0]
for (i in 1...a.count) {
if (a[i] < min) {
ix = i
min = a[i]
}
}
return [min, ix]
}
var a = [6, 81, 243, 14, 25, 49, 123, 69, 11]
while (a.count > 1) {
System.print("List: %(a)")
var s = List.filled(2, 0)
for (i in 0..1) {
var m = findMin.call(a)
s[i] = m[0]
a.removeAt(m[1])
}
var sum = s[0] + s[1]
System.print("Two smallest: %(s[0]) + %(s[1]) = %(sum)")
a.add(sum)
}
System.print("Last item is %(a[0]).")
- Output:
List: [6, 81, 243, 14, 25, 49, 123, 69, 11] Two smallest: 6 + 11 = 17 List: [81, 243, 14, 25, 49, 123, 69, 17] Two smallest: 14 + 17 = 31 List: [81, 243, 25, 49, 123, 69, 31] Two smallest: 25 + 31 = 56 List: [81, 243, 49, 123, 69, 56] Two smallest: 49 + 56 = 105 List: [81, 243, 123, 69, 105] Two smallest: 69 + 81 = 150 List: [243, 123, 105, 150] Two smallest: 105 + 123 = 228 List: [243, 150, 228] Two smallest: 150 + 228 = 378 List: [243, 378] Two smallest: 243 + 378 = 621 Last item is 621.
XPL0
int List, End, Sum, Item, Smallest, I, SI;
[List:= [6, 81, 243, 14, 25, 49, 123, 69, 11];
End:= 8; \last index
loop [for I:= 0 to End do \show List
[IntOut(0, List(I)); ChOut(0, ^ )];
CrLf(0);
if End = 0 then quit; \done when only one element
Sum:= 0; \find two smallest items
for Item:= 1 to 2 do
[Smallest:= -1>>1;
for I:= 0 to End do
if List(I) < Smallest then
[Smallest:= List(I); SI:= I];
Sum:= Sum + Smallest; \add them
for I:= SI to End-1 do \remove them
List(I):= List(I+1);
End:= End-1;
];
End:= End+1; \insert Sum at End
List(End):= Sum;
];
]
- Output:
6 81 243 14 25 49 123 69 11 81 243 14 25 49 123 69 17 81 243 25 49 123 69 31 81 243 49 123 69 56 81 243 123 69 105 243 123 105 150 243 150 228 243 378 621