Rosetta Code

Last list item: Difference between revisions

Page Discussion

Last list item (view source)

Revision as of 10:44, 28 April 2024

7,058 bytes added ,  1 month ago
Added Easylang
(Added Easylang)
 
(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|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}}==
{{works with|Factor|0.99 2021-06-02}}
<langsyntaxhighlight lang="factor">USING: formatting io kernel math math.statistics prettyprint
sequences sequences.extras ;
 
Line 596 ⟶ 791:
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 ⟶ 814:
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">#define HUGE 99999999
 
redim as integer list(0 to 8)
Line 656 ⟶ 851:
next i
print
wend</langsyntaxhighlight>
{{out}}<pre>
6 81 243 14 25 49 123 69 11
Line 672 ⟶ 867:
{{trans|Wren}}
===With sorting===
<langsyntaxhighlight lang="go">package main
 
import (
Line 690 ⟶ 885:
}
fmt.Println("Last item is", a[0], "\b.")
}</langsyntaxhighlight>
 
{{out}}
Line 714 ⟶ 909:
 
===Without sorting===
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 745 ⟶ 940:
}
fmt.Println("Last item is", a[0], "\b.")
}</langsyntaxhighlight>
 
{{out}}
Line 769 ⟶ 964:
 
=={{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 ⟶ 972:
243 150 228
243 378
621</langsyntaxhighlight>
 
Alternative interpretation:<langsyntaxhighlight Jlang="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
Line 786 ⟶ 981:
243 150 228
243 378
621</langsyntaxhighlight>
 
=={{header|jq}}==
Line 793 ⟶ 988:
'''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 805 ⟶ 1,000:
 
[6, 81, 243, 14, 25, 49, 123, 69, 11]
| task_with_sorting</langsyntaxhighlight>
{{out}}
<pre>
Line 827 ⟶ 1,022:
</pre>
===Without sorting===
<langsyntaxhighlight lang="jq">def min_index:
. as $in
| reduce range(0; length) as $i ( null;
Line 854 ⟶ 1,049:
[6, 81, 243, 14, 25, 49, 123, 69, 11]
| task_without_sorting
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 877 ⟶ 1,072:
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">list = [6, 81, 243, 14, 25, 49, 123, 69, 11]
 
function addleastreduce!(lis)
Line 888 ⟶ 1,083:
 
@show list, addleastreduce!(copy(list))
</langsyntaxhighlight>{{out}}
<pre>
Interim list: [81, 243, 14, 25, 49, 123, 69, 17]
Line 903 ⟶ 1,098:
=={{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 915 ⟶ 1,110:
,
{Length[list] - 1}
]</langsyntaxhighlight>
{{out}}
<pre>{6,81,243,14,25,49,123,69,11}
Line 931 ⟶ 1,126:
===With sorting===
We sort in descending order as it is more efficient.
<langsyntaxhighlight Nimlang="nim"># With sorting.
import algorithm, strformat
 
Line 946 ⟶ 1,141:
while list.len >= 2:
list.extractAndAddTwoSmallest()
echo &"Last item is {list[0]}."</langsyntaxhighlight>
 
{{out}}
Line 962 ⟶ 1,157:
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 987 ⟶ 1,182:
while list.len >= 2:
list.extractAndAddTwoSmallest()
echo &"Last item is {list[0]}."</langsyntaxhighlight>
 
{{out}}
Line 1,002 ⟶ 1,197:
=={{header|Perl}}==
{{trans|Raku}}
<langsyntaxhighlight lang="perl">use strict;
use warnings;
use feature 'say';
Line 1,016 ⟶ 1,211:
printf " %3d ", $min;
$min;
}</langsyntaxhighlight>
{{out}}
<pre> Original 6 81 243 14 25 49 123 69 11
Line 1,031 ⟶ 1,226:
=={{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,041 ⟶ 1,236:
<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,055 ⟶ 1,250:
</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,071 ⟶ 1,266:
<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,087 ⟶ 1,282:
=={{header|Python}}==
{{trans|Julia}}
<langsyntaxhighlight lang="python">""" Rosetta code task: Last list item """
 
def add_least_reduce(lis):
Line 1,099 ⟶ 1,294:
 
print(LIST, ' ==> ', add_least_reduce(LIST.copy()))
</langsyntaxhighlight>{{out}}
<pre>
Interim list: [81, 243, 14, 25, 49, 123, 69, 17]
Line 1,111 ⟶ 1,306:
[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,122 ⟶ 1,352:
printf " %3d ", $min;
$min;
}</langsyntaxhighlight>
{{out}}
<pre> Original [6 81 243 14 25 49 123 69 11]
Line 1,137 ⟶ 1,367:
=={{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,173 ⟶ 1,403:
swl=swl wa.i
End
Return strip(swl)</langsyntaxhighlight>
{{out}}
<Pre>Sorted list: 6 11 14 25 49 69 81 123 243
Line 1,193 ⟶ 1,423:
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,216 ⟶ 1,446:
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,239 ⟶ 1,469:
=={{header|Ring}}==
===With sorting===
<langsyntaxhighlight lang="ring">
see "working..." + nl
 
Line 1,289 ⟶ 1,519:
txt = txt + "]"
see txt + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,314 ⟶ 1,544:
</pre>
===Without sorting===
<langsyntaxhighlight lang="ring">
see "working..." + nl
Line 1,358 ⟶ 1,588:
txt = txt + "]"
see txt + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,381 ⟶ 1,611:
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,392 ⟶ 1,670:
list << a.sum
say "#{a.map{'%3s' % _}.join(' ')} : #{list}"
}</langsyntaxhighlight>
{{out}}
<pre>
Line 1,406 ⟶ 1,684:
 
===Without sorting===
<langsyntaxhighlight lang="ruby">var k = 2
var list = [6, 81, 243, 14, 25, 49, 123, 69, 11]
 
Line 1,420 ⟶ 1,698:
list << a.sum
say "#{a.map{'%3s' % _}.join(' ')} : #{list}"
}</langsyntaxhighlight>
{{out}}
<pre>
Line 1,433 ⟶ 1,711:
</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,447 ⟶ 1,725:
}
println("Last item is ${a[0]}.")
}</langsyntaxhighlight>
 
{{out}}
Line 1,471 ⟶ 1,749:
 
===Without sorting===
<syntaxhighlight lang="v (vlang)">fn find_min(a []int) (int, int) {
mut ix := 0
mut min := a[0]
Line 1,497 ⟶ 1,775:
}
println("Last item is ${a[0]}.")
}</langsyntaxhighlight>
 
{{out}}
Line 1,522 ⟶ 1,800:
=={{header|Wren}}==
===With sorting===
<langsyntaxhighlight ecmascriptlang="wren">var a = [6, 81, 243, 14, 25, 49, 123, 69, 11]
 
while (a.count > 1) {
Line 1,533 ⟶ 1,811:
}
 
System.print("Last item is %(a[0]).")</langsyntaxhighlight>
 
{{out}}
Line 1,557 ⟶ 1,835:
 
===Without sorting===
<langsyntaxhighlight ecmascriptlang="wren">var findMin = Fn.new { |a|
var ix = 0
var min = a[0]
Line 1,584 ⟶ 1,862:
}
 
System.print("Last item is %(a[0]).")</langsyntaxhighlight>
 
{{out}}
Line 1,608 ⟶ 1,886:
 
=={{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,629 ⟶ 1,907:
List(End):= Sum;
];
]</langsyntaxhighlight>
 
{{out}}
Chkas
2,041

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/316646...364024"