Rosetta Code

Last list item: Difference between revisions

Page Discussion

Last list item (view source)

Revision as of 10:17, 15 December 2023

6,785 bytes added ,  5 months ago
m
→‎{{header|Wren}}: Changed to Wren S/H
(Applesoft BASIC)
m (→‎{{header|Wren}}: Changed to Wren S/H)
(11 intermediate revisions by 9 users not shown)
Line 12:
{{trans|Python}}
 
<langsyntaxhighlight lang="11l">F add_least_reduce(&lis)
L lis.len > 1
V el1 = lis.pop(lis.index(min(lis)))
Line 22:
V LIST = [6, 81, 243, 14, 25, 49, 123, 69, 11]
 
print(LIST‘ ==> ’add_least_reduce(&copy(LIST)))</langsyntaxhighlight>
 
{{out}}
Line 39:
=={{header|Ada}}==
===With sorting===
<langsyntaxhighlight Adalang="ada">with Ada.Text_IO;
with Ada.Containers.Vectors;
 
Line 81:
end loop;
Put (List); New_Line;
end Last_List_Item_Sorted;</langsyntaxhighlight>
{{out}}
<pre>
Line 96:
 
===Without sorting===
<langsyntaxhighlight Adalang="ada">with Ada.Text_IO;
with Ada.Containers.Vectors;
 
Line 149:
end loop;
Put (List); New_Line;
end Last_List_Item;</langsyntaxhighlight>
{{out}}
<pre>
Line 167:
{{trans|Wren}}
{{libheader|ALGOL 68-rows}}
<langsyntaxhighlight lang="algol68">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 #
Line 188:
OD;
print( ( "Last item is ", whole( a[ 1 ], 0 ), ".", newline ) )
END</langsyntaxhighlight>
{{out}}
<pre>
Line 204:
===Without sorting===
Translation of the sorted Wren version with the sorting removed.
<langsyntaxhighlight 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 );
Line 235:
OD;
print( ( "Last item is ", whole( a[ 1 ], 0 ), ".", newline ) )
END</langsyntaxhighlight>
{{out}}
<pre>
Line 250:
 
=={{header|Applesoft BASIC}}==
<langsyntaxhighlight lang="gwbasic"> 100 DATA 6, 81, 243, 14, 25, 49, 123, 69, 11
110 FOR L = 0 TO 8
120 READ L(L)
Line 293:
470 LET H(I) = H(I + 1)
480 NEXT I
490 RETURN</langsyntaxhighlight>
{{out}}
<pre>
Line 307:
</pre>
=={{header|AppleScript}}==
<langsyntaxhighlight lang="applescript">on lastListItem(lst)
set astid to AppleScript's text item delimiters
set AppleScript's text item delimiters to ", "
Line 338:
end lastListItem
 
lastListItem({6, 81, 243, 14, 25, 49, 123, 69, 11})</langsyntaxhighlight>
 
{{output}}
<langsyntaxhighlight lang="applescript">"Steps:
{6, 81, 243, 14, 25, 49, 123, 69, 11} ← Original
{81, 243, 14, 25, 49, 123, 69, 17} ← 6 + 11 = 17
Line 350:
{243, 150, 228} ← 105 + 123 = 228
{243, 378} ← 150 + 228 = 378
{621} ← 243 + 378 = 621"</langsyntaxhighlight>
 
=={{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}}==
<langsyntaxhighlight AutoHotkeylang="autohotkey">List := [6, 81, 243, 14, 25, 49, 123, 69, 11]
steps := "Initial List `t`t`t" List2str(List) "`n"
while List.Count() > 1
Line 383 ⟶ 410:
unsorted_List .= v ", "
return "[" Trim(unsorted_List, ", ") "]"
}</langsyntaxhighlight>
{{out}}
<pre>Initial List [6, 81, 243, 14, 25, 49, 123, 69, 11]
Line 396 ⟶ 423:
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f LAST_LIST_ITEM.AWK
BEGIN {
Line 416 ⟶ 443:
exit(0)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 434 ⟶ 461:
===With and without sorting===
 
<langsyntaxhighlight lang="bqn">list ← ⟨6, 81, 243, 14, 25, 49, 123, 69, 11⟩
 
W_sort ← {{i←2↑∧𝕩, (𝕩/˜¬𝕩∊i)∾+´i}⍟(↕≠𝕩)𝕩}
Line 441 ⟶ 468:
 
•Show¨W_sort list
•Show¨WO_sort list</langsyntaxhighlight>
<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 ⟩
Line 459 ⟶ 486:
⟨ 243 150 228 ⟩
⟨ 243 378 ⟩
⟨ 621 ⟩</langsyntaxhighlight>
 
=={{header|C}}==
===With sorting===
{{trans|Wren}}
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>
 
Line 493 ⟶ 520:
printf("Last item is %d.\n", a[0]);
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 517 ⟶ 544:
 
===Without sorting===
<langsyntaxhighlight lang="c">#include <stdio.h>
 
int findMin(int a[], int asize, int *pmin) {
Line 553 ⟶ 580:
printf("Last item is %d.\n", a[0]);
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 575 ⟶ 602:
Last item is 621.
</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|Factor}}==
{{works with|Factor|0.99 2021-06-02}}
<langsyntaxhighlight lang="factor">USING: formatting io kernel math math.statistics prettyprint
sequences sequences.extras ;
 
Line 596 ⟶ 760:
V{ 6 81 243 14 25 49 123 69 11 }
[ dup length 1 > ] [ dup list. step ] while
last "Last item is %d.\n" printf</langsyntaxhighlight>
{{out}}
<pre>
Line 619 ⟶ 783:
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">#define HUGE 99999999
 
redim as integer list(0 to 8)
Line 656 ⟶ 820:
next i
print
wend</langsyntaxhighlight>
{{out}}<pre>
6 81 243 14 25 49 123 69 11
Line 672 ⟶ 836:
{{trans|Wren}}
===With sorting===
<langsyntaxhighlight lang="go">package main
 
import (
Line 690 ⟶ 854:
}
fmt.Println("Last item is", a[0], "\b.")
}</langsyntaxhighlight>
 
{{out}}
Line 714 ⟶ 878:
 
===Without sorting===
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 745 ⟶ 909:
}
fmt.Println("Last item is", a[0], "\b.")
}</langsyntaxhighlight>
 
{{out}}
Line 769 ⟶ 933:
 
=={{header|J}}==
Here we maintain the unsorted order in the intermediate steps:<langsyntaxhighlight Jlang="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
Line 777 ⟶ 941:
243 150 228
243 378
621</langsyntaxhighlight>
 
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}}==
Line 784 ⟶ 957:
'''Works with gojq, the Go implementation of jq'''
===With sorting===
<langsyntaxhighlight lang="jq">def task_with_sorting:
foreach range(1; length) as $i ( {a: .};
.a |= sort
Line 796 ⟶ 969:
 
[6, 81, 243, 14, 25, 49, 123, 69, 11]
| task_with_sorting</langsyntaxhighlight>
{{out}}
<pre>
Line 818 ⟶ 991:
</pre>
===Without sorting===
<langsyntaxhighlight lang="jq">def min_index:
. as $in
| reduce range(0; length) as $i ( null;
Line 845 ⟶ 1,018:
[6, 81, 243, 14, 25, 49, 123, 69, 11]
| task_without_sorting
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 868 ⟶ 1,041:
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">list = [6, 81, 243, 14, 25, 49, 123, 69, 11]
 
function addleastreduce!(lis)
Line 879 ⟶ 1,052:
 
@show list, addleastreduce!(copy(list))
</langsyntaxhighlight>{{out}}
<pre>
Interim list: [81, 243, 14, 25, 49, 123, 69, 17]
Line 894 ⟶ 1,067:
=={{header|Mathematica}}/{{header|Wolfram Language}}==
===With and without sorting===
<langsyntaxhighlight Mathematicalang="mathematica">list = {6, 81, 243, 14, 25, 49, 123, 69, 11};
 
Print[list]
Line 906 ⟶ 1,079:
,
{Length[list] - 1}
]</langsyntaxhighlight>
{{out}}
<pre>{6,81,243,14,25,49,123,69,11}
Line 922 ⟶ 1,095:
===With sorting===
We sort in descending order as it is more efficient.
<langsyntaxhighlight Nimlang="nim"># With sorting.
import algorithm, strformat
 
Line 937 ⟶ 1,110:
while list.len >= 2:
list.extractAndAddTwoSmallest()
echo &"Last item is {list[0]}."</langsyntaxhighlight>
 
{{out}}
Line 953 ⟶ 1,126:
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).
 
<langsyntaxhighlight Nimlang="nim"># Without sorting.
import strformat
 
Line 978 ⟶ 1,151:
while list.len >= 2:
list.extractAndAddTwoSmallest()
echo &"Last item is {list[0]}."</langsyntaxhighlight>
 
{{out}}
Line 993 ⟶ 1,166:
=={{header|Perl}}==
{{trans|Raku}}
<langsyntaxhighlight lang="perl">use strict;
use warnings;
use feature 'say';
Line 1,007 ⟶ 1,180:
printf " %3d ", $min;
$min;
}</langsyntaxhighlight>
{{out}}
<pre> Original 6 81 243 14 25 49 123 69 11
Line 1,022 ⟶ 1,195:
=={{header|Phix}}==
===With sorting===
<!--<langsyntaxhighlight Phixlang="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>
Line 1,032 ⟶ 1,205:
<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>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 1,046 ⟶ 1,219:
</pre>
===Without sorting===
<!--<langsyntaxhighlight Phixlang="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>
Line 1,062 ⟶ 1,235:
<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>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 1,078 ⟶ 1,251:
=={{header|Python}}==
{{trans|Julia}}
<langsyntaxhighlight lang="python">""" Rosetta code task: Last list item """
 
def add_least_reduce(lis):
Line 1,090 ⟶ 1,263:
 
print(LIST, ' ==> ', add_least_reduce(LIST.copy()))
</langsyntaxhighlight>{{out}}
<pre>
Interim list: [81, 243, 14, 25, 49, 123, 69, 17]
Line 1,102 ⟶ 1,275:
[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}}==
Uses no sorting; does not modify overall list order while processing.
<syntaxhighlight lang="raku" perl6line>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;
Line 1,113 ⟶ 1,321:
printf " %3d ", $min;
$min;
}</langsyntaxhighlight>
{{out}}
<pre> Original [6 81 243 14 25 49 123 69 11]
Line 1,128 ⟶ 1,336:
=={{header|REXX}}==
===With sorting===
<langsyntaxhighlight lang="rexx">/* REXX */
List = '6 81 243 14 25 49 123 69 11'
Do Until words(list)=1
Line 1,164 ⟶ 1,372:
swl=swl wa.i
End
Return strip(swl)</langsyntaxhighlight>
{{out}}
<Pre>Sorted list: 6 11 14 25 49 69 81 123 243
Line 1,184 ⟶ 1,392:
Last item: 621</pre>
===Without sorting===
<langsyntaxhighlight lang="rexx">/* REXX */
List = '6 81 243 14 25 49 123 69 11'
Do Until words(list)=1
Line 1,207 ⟶ 1,415:
End
list=subword(list,1,j-1) subword(list,j+1)
Return m</langsyntaxhighlight>
{{out}}
<pre>List: 6 81 243 14 25 49 123 69 11
Line 1,230 ⟶ 1,438:
=={{header|Ring}}==
===With sorting===
<langsyntaxhighlight lang="ring">
see "working..." + nl
 
Line 1,280 ⟶ 1,488:
txt = txt + "]"
see txt + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,305 ⟶ 1,513:
</pre>
===Without sorting===
<langsyntaxhighlight lang="ring">
see "working..." + nl
Line 1,349 ⟶ 1,557:
txt = txt + "]"
see txt + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,372 ⟶ 1,580:
Last item is: 621
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===
<langsyntaxhighlight lang="ruby">var k = 2
var list = [6, 81, 243, 14, 25, 49, 123, 69, 11]
 
Line 1,383 ⟶ 1,639:
list << a.sum
say "#{a.map{'%3s' % _}.join(' ')} : #{list}"
}</langsyntaxhighlight>
{{out}}
<pre>
Line 1,397 ⟶ 1,653:
 
===Without sorting===
<langsyntaxhighlight lang="ruby">var k = 2
var list = [6, 81, 243, 14, 25, 49, 123, 69, 11]
 
Line 1,411 ⟶ 1,667:
list << a.sum
say "#{a.map{'%3s' % _}.join(' ')} : #{list}"
}</langsyntaxhighlight>
{{out}}
<pre>
Line 1,424 ⟶ 1,680:
</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 {
Line 1,438 ⟶ 1,694:
}
println("Last item is ${a[0]}.")
}</langsyntaxhighlight>
 
{{out}}
Line 1,462 ⟶ 1,718:
 
===Without sorting===
<syntaxhighlight lang="v (vlang)">fn find_min(a []int) (int, int) {
mut ix := 0
mut min := a[0]
Line 1,488 ⟶ 1,744:
}
println("Last item is ${a[0]}.")
}</langsyntaxhighlight>
 
{{out}}
Line 1,513 ⟶ 1,769:
=={{header|Wren}}==
===With sorting===
<langsyntaxhighlight ecmascriptlang="wren">var a = [6, 81, 243, 14, 25, 49, 123, 69, 11]
 
while (a.count > 1) {
Line 1,524 ⟶ 1,780:
}
 
System.print("Last item is %(a[0]).")</langsyntaxhighlight>
 
{{out}}
Line 1,548 ⟶ 1,804:
 
===Without sorting===
<langsyntaxhighlight ecmascriptlang="wren">var findMin = Fn.new { |a|
var ix = 0
var min = a[0]
Line 1,575 ⟶ 1,831:
}
 
System.print("Last item is %(a[0]).")</langsyntaxhighlight>
 
{{out}}
Line 1,599 ⟶ 1,855:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">int List, End, Sum, Item, Smallest, I, SI;
[List:= [6, 81, 243, 14, 25, 49, 123, 69, 11];
End:= 8; \last index
Line 1,620 ⟶ 1,876:
List(End):= Sum;
];
]</langsyntaxhighlight>
 
{{out}}
PureFox
9,482

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/316645...355097"