Largest int from concatenated ints: Difference between revisions
Added Uiua solution
(Added Rust) |
(Added Uiua solution) |
||
(48 intermediate revisions by 28 users not shown) | |||
Line 20:
* [http://stackoverflow.com/questions/14532105/constructing-the-largest-number-possible-by-rearranging-a-list/14539943#14539943 Constructing the largest number possible by rearranging a list]
<br><br>
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">F maxnum(x)
V maxlen = String(max(x)).len
R sorted(x.map(v -> String(v)), key' i -> i * (@maxlen * 2 I/ i.len), reverse' 1B).join(‘’)
L(numbers) [[212, 21221], [1, 34, 3, 98, 9, 76, 45, 4], [54, 546, 548, 60]]
print("Numbers: #.\n Largest integer: #15".format(numbers, maxnum(numbers)))</syntaxhighlight>
{{out}}
<pre>
Numbers: [212, 21221]
Largest integer: 21221221
Numbers: [1, 34, 3, 98, 9, 76, 45, 4]
Largest integer: 998764543431
Numbers: [54, 546, 548, 60]
Largest integer: 6054854654
</pre>
=={{header|Ada}}==
Line 25 ⟶ 45:
The algorithmic idea is to apply a twisted comparison function:
<
( (Img(Left) & Img(Right)) > (Img(Right) & Img(Left)) );</
This function converts the parameters Left and Right to strings and returns True if (Left before Right)
exceeds (Right before Left). It needs Ada 2012 -- the code for older versions of Ada would be more verbose.
Line 32 ⟶ 52:
The rest is straightforward: Run your favourite sorting subprogram that allows to use the function "Order" instead of standard comparison operators ("<" or ">" or so) and print the results:
<
procedure Largest_Int_From_List is
Line 63 ⟶ 83:
Print_Sorted((1, 34, 3, 98, 9, 76, 45, 4));
Print_Sorted((54, 546, 548, 60));
end Largest_Int_From_List;</
=={{header|Aime}}==
<syntaxhighlight lang="aime">largest(...)
{
index x;
for (, integer e in xcall(list).__list) {
x[999999999 - 9.times(b_, data(), e).b_size(9).atoi] = e;
}
x.ucall(o_, 0);
Line 81 ⟶ 96:
}
main(void)
{
largest(1, 34, 3, 98, 9, 76, 45, 4);
largest(54, 546, 548, 60);
}</
works for input up to 999999999.
{{Out}}
Line 95 ⟶ 109:
=={{header|ALGOL 68}}==
Using method 2 - first sorting into first digit order and then comparing concatenated pairs.
<
# returns the integer value of s #
OP TOINT = ( STRING s)INT:
Line 163 ⟶ 177:
print( ( newline ) )
END</
{{out}}
<pre>
Line 169 ⟶ 183:
6054854654
</pre>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">largestConcInt: function [arr]->
max map permutate arr 's [
to :integer join map s => [to :string]
]
loop [[1 34 3 98 9 76 45 4] [54 546 548 60]] 'a ->
print largestConcInt a</syntaxhighlight>
=={{header|AutoHotkey}}==
<
StringReplace, var, A_LoopField,%A_Space%,, all
Sort, var, D`, fConcSort
Line 181 ⟶ 204:
m := a . b , n := b . a
return m < n ? 1 : m > n ? -1 : 0
}</
Examples:<
(
1, 34, 3, 98, 9, 76, 45, 4
Line 189 ⟶ 212:
)
loop, parse, d, `n
MsgBox % LargestConcatenatedInts(A_LoopField)</
{{out}}
<pre>998764543431
Line 197 ⟶ 220:
=={{header|AWK}}==
{{works with|gawk|4.0}}
<
function cmp(i1, v1, i2, v2, u1, u2) {
u1 = v1""v2;
Line 217 ⟶ 240:
print largest_int_from_concatenated_ints(X)
}
</syntaxhighlight>
{{out}}
<pre>998764543431
Line 223 ⟶ 246:
=={{header|BBC BASIC}}==
<
Nums%()=1,34,3,98,9,76,45,4
PRINT FNlargestint(8)
Line 243 ⟶ 266:
l$+=STR$Nums%(i%)
NEXT
=l$</
{{out}}
<pre>998764543431
Line 249 ⟶ 272:
=={{header|Bracmat}}==
<
= A Z F C
. !arg:#
Line 266 ⟶ 289:
& out$(str$(maxnum$(1 34 3 98 9 76 45 4)))
& out$(str$(maxnum$(54 546 548 60)))
);</
{{out}}
<pre>998764543431
Line 272 ⟶ 295:
=={{header|C}}==
<
#include <stdlib.h>
#include <string.h>
Line 302 ⟶ 325:
return 0;
}</
{{out}}
<pre>998764543431
6054854654</pre>
=={{header|C sharp|C#}}==
<
using System.Collections.Generic;
using System.Linq;
Line 378 ⟶ 366:
}
}
</syntaxhighlight>
{{out}}
<pre>The largest possible integer from set 1 is: 998764543431
The largest possible integer from set 2 is: 6054854654</pre>
=={{header|C++}}==
<syntaxhighlight lang="cpp">#include <iostream>
#include <sstream>
#include <algorithm>
#include <vector>
#include <string>
std::string findLargestConcat ( std::vector< int > & mynumbers ) {
std::vector<std::string> concatnumbers ;
std::sort ( mynumbers.begin( ) , mynumbers.end( ) ) ;
do {
std::ostringstream numberstream ;
for ( int i : mynumbers )
numberstream << i ;
concatnumbers.push_back( numberstream.str( ) ) ;
} while ( std::next_permutation( mynumbers.begin( ) ,
mynumbers.end( ) )) ;
return *( std::max_element( concatnumbers.begin( ) ,
concatnumbers.end( ) ) ) ;
}
int main( ) {
std::vector<int> mynumbers = { 98, 76 , 45 , 34, 9 , 4 , 3 , 1 } ;
std::vector<int> othernumbers = { 54 , 546 , 548 , 60 } ;
std::cout << "The largest concatenated int is " <<
findLargestConcat( mynumbers ) << " !\n" ;
std::cout << "And here it is " << findLargestConcat( othernumbers )
<< " !\n" ;
return 0 ;
}</syntaxhighlight>
{{out}}
<pre>The largest concatenated int is 998764543431 !
And here it is 6054854654 !</pre>
=={{header|Ceylon}}==
{{trans|Kotlin}}
{{works with|Ceylon|1.
<
function
assert (
return yx <=> xy;
}
function biggestConcatenation({Integer*} ints) => "".join(ints.sort(
value test1 = {1, 34, 3, 98, 9, 76, 45, 4};
print(biggestConcatenation(test1));
value test2 = {54, 546, 548, 60};
print(biggestConcatenation(test2));
}</syntaxhighlight>
=={{header|Clojure}}==
<
(read-string
(apply str
Line 412 ⟶ 436:
coll))))
(prn (map maxcat [[1 34 3 98 9 76 45 4] [54 546 548 60]]))</
{{out}}
Line 420 ⟶ 444:
=== Sort by two-by-two comparison of largest concatenated result ===
<
(defun int-concat (ints)
(read-from-string (format nil "~{~a~}" ints)))
Line 429 ⟶ 453:
(defun make-largest-int (ints)
(int-concat (sort ints #'by-biggest-result)))
</syntaxhighlight>
{{out}}
Line 443 ⟶ 467:
=== Variation around the sort with padded most significant digit ===
<
;; Sort criteria is by most significant digit with least digits used as a tie
;; breaker
Line 469 ⟶ 493:
#'largest-msd-with-less-digits)))
</syntaxhighlight>
{{out}}
Line 479 ⟶ 503:
=={{header|D}}==
The three algorithms. Uses the second module from the Permutations Task.
<
auto maxCat1(in int[] arr) pure @safe {
Line 499 ⟶ 523:
const lists = [[1, 34, 3, 98, 9, 76, 45, 4], [54, 546, 548, 60]];
[&maxCat1, &maxCat2, &maxCat3].map!(cat => lists.map!cat).writeln;
}</
{{out}}
<pre>[["998764543431", "6054854654"], ["998764543431", "6054854654"], ["998764543431", "6054854654"]]</pre>
=={{header|Delphi}}==
See [https://www.rosettacode.org/wiki/Largest_int_from_concatenated_ints#Pascal Pascal].
=={{header|EasyLang}}==
<syntaxhighlight>
func con a b .
t = 10
while b >= t
t *= 10
.
return a * t + b
.
func$ max a[] .
n = len a[]
for i to n - 1
for j = i + 1 to n
if con a[i] a[j] < con a[j] a[i]
swap a[i] a[j]
.
.
.
for v in a[]
r$ &= v
.
return r$
.
print max [ 1 34 3 98 9 76 45 4 ]
print max [ 54 546 548 60 ]
</syntaxhighlight>
{{out}}
<pre>
998764543431
6054854654
</pre>
=={{header|Elixir}}==
<
def largest_int(list) do
sorted = Enum.sort(list, fn x,y -> "#{x}#{y}" >= "#{y}#{x}" end)
Line 512 ⟶ 571:
IO.inspect RC.largest_int [1, 34, 3, 98, 9, 76, 45, 4]
IO.inspect RC.largest_int [54, 546, 548, 60]</
{{out}}
Line 521 ⟶ 580:
=={{header|Erlang}}==
<syntaxhighlight lang="erlang">
-module( largest_int_from_concatenated ).
Line 533 ⟶ 592:
task() ->
[io:fwrite("Largest ~p from ~p~n", [ints(X), X]) || X <- [[1, 34, 3, 98, 9, 76, 45, 4], [54, 546, 548, 60]]].
</syntaxhighlight>
{{out}}
<pre>
Line 542 ⟶ 601:
=={{header|F_Sharp|F#}}==
<
// Form largest integer which is a permutation from a list of integers. Nigel Galloway: March 21st., 2018
let fN g = List.map (string) g |> List.sortWith(fun n g->if n+g<g+n then 1 else -1) |> System.String.Concat
</syntaxhighlight>
{{out}}
<pre>
Line 554 ⟶ 613:
=={{header|Factor}}==
Using algorithm 3:
<
IN: rosetta-code.largest-int
Line 568 ⟶ 627:
reverse concat print ;
qw{ 1 34 3 98 9 76 45 4 } qw{ 54 546 548 60 } [ largest-int ] bi@</
{{out}}
<pre>
Line 574 ⟶ 633:
6054854654
</pre>
Or alternatively, a translation of F#.
{{trans|F#}}
<syntaxhighlight lang="factor">USING: kernel math.order qw sequences sorting ;
: fn ( seq -- str )
[ 2dup swap [ append ] 2bi@ after? +lt+ +gt+ ? ] sort concat ;</syntaxhighlight>
{{out}}
<pre>
qw{ 1 34 3 98 9 76 45 4 } qw{ 54 546 548 60 } [ fn ] bi@
--- Data stack:
"998764543431"
"6054854654"</pre>
=={{header|Fortran}}==
Line 584 ⟶ 657:
The sorting of the text array was to be by the notorious BubbleSort, taking advantage of the fact that each pass delivers the maximum value of the unsorted portion to its final position: the output could thereby be produced as the sort worked. Rather than mess about with early termination (no element being swapped) or attention to the bounds within which swapping took place, attention concentrated upon the comparison. Because of the left-alignment of the texts, a simple comparison seemed sufficient until I thought of unequal text lengths and then the following example. Suppose there are two numbers, 5, and one of 54, 55, or 56 as the other. Via normal comparisons, the 5 would always be first (because short texts are considered expanded with trailing spaces when compared against longer texts, and a space precedes every digit) however the biggest ordering is 5 54 for the first case but 56 5 for the last. This possibility is not exemplified in the specified trial sets. So, a more complex comparison is required. One could of course write a suitable function and consider the issue there but instead the comparison forms the compound text in the same manner as the result will be, in the two ways AB and BA, and looks to see which yields the bigger sequence. This need only be done for unequal length text pairs.
The source is F77 style, except for the declaration of XLAT(N), the use of <N> in the FORMAT statements instead of some large constant or similar, and the ability to declare an array via constants as in <code>(/"5","54"/)</code> rather than mess about declaring arrays and initialising them separately. The <code>I0</code> format code to convert a number (an actual number) into a digit string aligned leftwards in a CHARACTER variable of sufficient size is also a F90 introduction, though the B6700 compiler allowed a code <code>J</code> instead. This last is to demonstrate usage of actual numbers for those unpersuaded by the argument for ambiguity that allows for texts. If the <code>I0</code> format code is unavailable then <code>I9</code> (or some suitable size) could be used, followed by <code>text = ADJUSTL(text)</code>, except that this became an intrinsic function only in F90, so perhaps you will have to write a simple alignment routine. <
INTEGER A,B,T
T = B
Line 656 ⟶ 729:
END DO !Thus, the numbers are aligned left in the text field.
CALL BIGUP(T1,10)
END </
Output: the Fortran compiler ignores spaces when reading fortran source, so, hard-core fortranners should have no difficulty doing likewise for the output...
<pre>
Line 679 ⟶ 752:
=={{header|FreeBASIC}}==
<
function catint( a as string, b as string ) as uinteger
return valint(a+b)
end function
function grt( a as string, b as string ) as boolean
return catint(a, b)>catint(b, a)
end function
sub shellsort( a() as string )
'quick and dirty shellsort, not the focus of this exercise
dim as uinteger gap = ubound(a), i, j, n=ubound(a)
dim as string temp
do
gap = int(gap / 2.2)
for i=gap to n
temp = a(i)
j=i
while j>=gap andalso grt( a(j-gap), temp )
a(j) = a(j - gap)
j -= gap
wend
a(j) = temp
next i
loop until gap = 1
end sub
sub sort_and_print( a() as string )
shellsort(a())
for i=0 to ubound(a)
outstring = a(i)+outstring
next i
print outstring
end sub
dim as string set1(8) = {"1", "34", "3", "98", "9", "76", "45", "4"}
dim as string set2(4) = {"54", "546", "548", "60"}
sort_and_print(set1())
sort_and_print(set2())</syntaxhighlight>
{{out}}
<pre>998764543431
6054854654
</pre>
=={{header|Frink}}==
<syntaxhighlight lang="frink">a = [[1, 34, 3, 98, 9, 76, 45, 4], [54, 546, 548, 60]]
f = {|p| parseInt[join["",p]] }
for s = a
println[max[map[f, s.lexicographicPermute[]]]]</syntaxhighlight>
{{out}}
<pre>
998764543431
6054854654
</pre>
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=4169e7641f29ff0ae1dd202b459e60ce Click this link to run this code]'''
<
Public Sub Main()
Line 810 ⟶ 860:
Print Val(sList.Join("")) 'Join all items in sList together and print
End</
Output:
<pre>
Line 818 ⟶ 868:
=={{header|Go}}==
<
// then sort as strings.
package main
Line 930 ⟶ 920:
fmt.Println(li(1, 34, 3, 98, 9, 76, 45, 4))
fmt.Println(li(54, 546, 548, 60))
}</
{{out}}
<pre>
Line 938 ⟶ 928:
=={{header|Groovy}}==
<
Testing:
<
assert largestInt([54, 546, 548, 60]) == 6054854654</
=={{header|Haskell}}==
===Compare repeated string method===
<
import Data.Ord (comparing)
Line 954 ⟶ 944:
in sortBy (flip $ comparing pad) xs
maxcat = read . concat . sorted . map show</
{{out}}
Line 960 ⟶ 950:
Since repeating numerical string "1234" is the same as taking all the digits of 1234/9999 after the decimal point, the following does essentially the same as above:
<
import Data.Ord (comparing)
import Data.Ratio ((%))
Line 970 ⟶ 960:
map (\a->(a, head $ dropWhile (<a) nines))
main = mapM_ (print.maxcat) [[1,34,3,98,9,76,45,4], [54,546,548,60]]</
===Sort on comparison of concatenated ints method===
<
main = print (map maxcat [[1,34,3,98,9,76,45,4], [54,546,548,60]] :: [Integer])
where sorted = sortBy (\a b -> compare (b++a) (a++b))
maxcat = read . concat . sorted . map show</
;Output as above.
===Try all permutations method===
<
main :: IO ()
main =
print
(maxcat <$> [[1, 34, 3, 98, 9, 76, 45, 4], [54, 546, 548, 60]] :: [Integer])
where
maxcat = read . maximum . fmap (concatMap show
;Output as above.
Line 997 ⟶ 988:
lifting.
<
procedure main(a)
Line 1,010 ⟶ 1,001:
procedure cmp(a,b)
return (a||b) > (b||a)
end</
Sample runs:
Line 1,022 ⟶ 1,013:
=={{header|J}}==
Here we use the "pad the integers to the same size by repeating the digits then sort using these repeated integers as a sort key" approach:
'''Solution:'''
<
maxnum=: (0 ". ;)@(\: maxlen $&> ])@(8!:0)</
'''Usage:'''
<
998764543431 6054854654</
=={{header|Java}}==
Line 1,033 ⟶ 1,025:
This example sets up a comparator to order the numbers using <code>Collections.sort</code> as described in method #3 (padding and reverse sorting).
It was also necessary to make a join method to meet the output requirements.
<
public class IntConcat {
Line 1,074 ⟶ 1,066:
System.out.println(join(ints2));
}
}</
{{works with|Java|1.8+}}
<
import java.util.stream.Collectors;
import java.util.stream.Stream;
Line 1,123 ⟶ 1,115:
);
}
}</
{{out}}
<pre>998764543431
6054854654</pre>
=={{header|JavaScript}}==
===ES5===
<
'use strict';
Line 1,157 ⟶ 1,150:
})();
</syntaxhighlight>
{{Out}}
Line 1,166 ⟶ 1,159:
===ES6===
<
// test & output
Line 1,172 ⟶ 1,165:
[1, 34, 3, 98, 9, 76, 45, 4],
[54, 546, 548, 60]
].map(maxCombine));</
=={{header|jq}}==
Line 1,178 ⟶ 1,171:
==== Padding ====
''For jq versions greater than 1.4, it may be necessary to change "sort_by" to "sort".''
<
def pad(n): . + (n - length) * .[length-1:];
Line 1,191 ⟶ 1,184:
([1, 34, 3, 98, 9, 76, 45, 4],
[54, 546, 548, 60]) | largest_int
</syntaxhighlight>
{{Out}}
$ /usr/local/bin/jq -n -M -r -f Largest_int_from_concatenated_ints.jq
Line 1,199 ⟶ 1,192:
====Custom Sort====
The following uses [[Sort_using_a_custom_comparator#jq| quicksort/1]]:
<
map(tostring)
| quicksort( .[0] + .[1] < .[1] + .[0] )
| reverse | join("") ;</
=={{header|Julia}}==
Perhaps algorithm 3 is more efficient, but algorithm 2 is decent and very easy to implement in Julia. So this solution uses algorithm 2.
<
b = sort(
return try parse(Int, b) catch parse(BigInt, b) end
end
Line 1,220 ⟶ 1,211:
for arr in tests
println("Max concatenating in $arr:\n -> ", maxconcat(arr))
end</
{{out}}
Line 1,232 ⟶ 1,223:
=={{header|Kotlin}}==
{{trans|C#}}
<syntaxhighlight lang="kotlin">import kotlin.Comparator
fun main(args: Array<String>) {
val comparator = Comparator<Int> { x, y -> "$x$y".compareTo("$y$x") }
fun findLargestSequence(array: IntArray): String {
return array.sortedWith(comparator
}
for (array in listOf(
intArrayOf(1, 34, 3, 98, 9, 76, 45, 4),
intArrayOf(54, 546, 548, 60),
)) {
println("%s -> %s".format(array.contentToString(), findLargestSequence(
}
}</syntaxhighlight>
{{Out}}
<pre>
[1, 34, 3, 98, 9, 76, 45, 4] -> 998764543431
[54, 546, 548, 60] -> 6054854654
</pre>
=={{header|Lua}}==
{{trans|Python}}
<
table.sort(numbers,function(x,y) return (x..y) > (y..x) end)
return numbers
Line 1,268 ⟶ 1,257:
table.concat(numbers,","),table.concat(icsort(numbers))
))
end</
{{out}}
<pre>Numbers: {1,34,3,98,9,76,45,4}
Line 1,275 ⟶ 1,264:
Largest integer: 6054854654</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
sortedlist = Sort[list, Order[ToString[#1] <> ToString[#2], ToString[#2] <> ToString[#1]] < 0 &];
Map[ToString, sortedlist] // StringJoin // FromDigits
Line 1,282 ⟶ 1,271:
(* testing with two examples *)
makeLargestInt[{1, 34, 3, 98, 9, 76, 45, 4}]
makeLargestInt[{54, 546, 548, 60}]</
{{out}}
<pre>998764543431
6054854654</pre>
=={{header|Maxima}}==
<syntaxhighlight lang="maxima">
/* Function that decompose a number into a list of its digits using conversions between numbers and strings */
decompose_n_s(n):=block(
string(n),
charlist(%%),
map(eval_string,%%))$
/* Function that orders the list obtained by decompose_n_ according to ordergreat and then orders the result to reached what is needed to solve the problem */
largest_from_list(lst):=(
sort(map(decompose_n_s,lst),ordergreatp),
sort(%%,lambda([a,b],if last(a)>last(b) then rest(b,-1)=a else rest(a,-1)=b)),
map(string,flatten(%%)),
simplode(%%),
eval_string(%%));
/* Test cases */
test1: [1, 34, 3, 98, 9, 76, 45, 4]$
test2: [54, 546, 548, 60]$
largest_from_list(test1);
largest_from_list(test2);
</syntaxhighlight>
{{out}}
<pre>
998764543431
6054854654
</pre>
=={{header|min}}==
{{works with|min|0.19.6}}
<syntaxhighlight lang="min">(quote cons "" join) :s+
('string map (over over swap s+ 's+ dip <) sort "" join int) :fn
(1 34 3 98 9 76 45 4) fn puts!
(54 546 548 60) fn puts!</syntaxhighlight>
{{out}}
<pre>
998764543431
6054854654
</pre>
=={{header|NetRexx}}==
<
options replace format comments java crossref symbols nobinary
Line 1,337 ⟶ 1,365:
end il
return
</syntaxhighlight>
{{out}}
<pre>
Line 1,345 ⟶ 1,373:
=={{header|Nim}}==
<
proc maxNum(x: seq[int]): string =
var c = x.mapIt(
c.sort((x, y) => cmp(y&x, x&y))
c.join()
echo maxNum(@[1, 34, 3, 98, 9, 76, 45, 4])
echo maxNum(@[54, 546, 548, 60])</
{{out}}
<pre>998764543431
Line 1,359 ⟶ 1,388:
=={{header|OCaml}}==
<
let icsort nums = String.concat "" (List.sort myCompare (List.map string_of_int nums))</
;testing
Line 1,373 ⟶ 1,402:
=={{header|Oforth}}==
<
{{out}}
Line 1,380 ⟶ 1,409:
[998764543431, 6054854654]
</pre>
=={{header|PARI/GP}}==
Sorts then joins. Most of the noise comes from converting a vector of integers into a concatenated integer: <code>eval(concat(apply(n->Str(n),v)))</code>. Note that the short form <code>eval(concat(apply(Str,v)))</code> is not valid here because <code>Str</code> is variadic.
<syntaxhighlight lang="parigp">large(v)=eval(concat(apply(n->Str(n),vecsort(v,(x,y)->eval(Str(y,x,"-",x,y))))));
large([1, 34, 3, 98, 9, 76, 45, 4])
large([54, 546, 548, 60])</syntaxhighlight>
{{out}}
<pre>%1 = 998764543431
%2 = 6054854654</pre>
=={{header|Pascal}}==
tested with freepascal.Used a more extreme example 3.
===algorithm 3===
<
base = 10;
MaxDigitCnt = 11;
Line 1,475 ⟶ 1,514:
var
i,l : integer;
s :
begin
{ the easy way
Line 1,522 ⟶ 1,561:
InsertData(tmpData[i],source3[i]);
HighestInt(tmpData);
end.</
{{out}}
<pre>998764543431
Line 1,531 ⟶ 1,570:
http://rosettacode.org/wiki/Largest_int_from_concatenated_ints#Compare_repeated_string_method
<
base = 10;
MaxDigitCnt = 11;
Line 1,656 ⟶ 1,695:
InsertData(tmpData[i],source3[i]);
HighestInt(tmpData);
end.</
{{out}}
<pre>9987645434310
6054854654
602121212122210></pre>
=={{header|Perl}}==
<
join '', sort { "$b$a" cmp "$a$b" } @_
}
print maxnum(1, 34, 3, 98, 9, 76, 45, 4), "\n";
print maxnum(54, 546, 548, 60), "\n";</
{{out}}
<pre>998764543431
Line 1,695 ⟶ 1,713:
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">catcmp</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #7060A8;">compare</span><span style="color: #0000FF;">(</span><span style="color: #000000;">b</span><span style="color: #0000FF;">&</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">a</span><span style="color: #0000FF;">&</span><span style="color: #000000;">b</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">method2</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">custom_sort</span><span style="color: #0000FF;">(</span><span style="color: #000000;">catcmp</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sprint</span><span style="color: #0000FF;">)),</span><span style="color: #008000;">""</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">method2</span><span style="color: #0000FF;">({</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">34</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">98</span><span style="color: #0000FF;">,</span><span style="color: #000000;">9</span><span style="color: #0000FF;">,</span><span style="color: #000000;">76</span><span style="color: #0000FF;">,</span><span style="color: #000000;">45</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">})</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">method2</span><span style="color: #0000FF;">({</span><span style="color: #000000;">54</span><span style="color: #0000FF;">,</span><span style="color: #000000;">546</span><span style="color: #0000FF;">,</span><span style="color: #000000;">548</span><span style="color: #0000FF;">,</span><span style="color: #000000;">60</span><span style="color: #0000FF;">})</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Line 1,716 ⟶ 1,733:
=={{header|PHP}}==
<
usort($nums, function ($x, $y) { return strcmp("$y$x", "$x$y"); });
return implode('', $nums);
Line 1,722 ⟶ 1,739:
echo maxnum(array(1, 34, 3, 98, 9, 76, 45, 4)), "\n";
echo maxnum(array(54, 546, 548, 60)), "\n";</
{{out}}
<pre>998764543431
6054854654</pre>
=={{header|Picat}}==
On the simpler cases, four methods are tested: 2 using permutations and 2 with different sorting methods.
===permutation/2===
<syntaxhighlight lang="picat">s_perm1(L, Num) =>
permutation(L,P),
Num = [I.to_string() : I in P].flatten().to_integer().</syntaxhighlight>
===Using permutations/1===
<syntaxhighlight lang="picat">s_perm2(L, Num) =>
Perms = permutations(L),
Num = max([ [I.to_string() : I in P].flatten().to_integer() : P in Perms]).</syntaxhighlight>
===Sort on concatenated numbers===
<syntaxhighlight lang="picat">s_sort_conc(L,Num) =>
Num = [to_string(I) : I in qsort(L,f3)].join('').to_integer().
% sort function for s_sort_conc/2
f3(N1,N2) =>
N1S = N1.to_string(),
N2S = N2.to_string(),
(N1S ++ N2S).to_integer() >= (N2S ++ N1S).to_integer().
% qsort(List, SortFunction)
% returns a sorted list according to the sort function SortFunction.
qsort([],_F) = [].
qsort([H|T],F) = qsort([E : E in T, call(F,E,H)], F)
++ [H] ++
qsort([E : E in T, not call(F,E,H)],F).</syntaxhighlight>
===Extend each element to the largest length===
<syntaxhighlight lang="picat">s_extend(L,Num) =>
LS = [I.to_string() : I in L],
MaxLen = 2*max([I.length : I in LS]),
L2 = [],
foreach(I in LS)
I2 = I,
% extend to a larger length
while(I2.length < MaxLen)
I2 := I2 ++ I
end,
% keep info of the original number
L2 := L2 ++ [[I2,I]]
end,
Num = [I[2] : I in qsort(L2,f4)].join('').to_integer().
% sort function for s_extend/2
f4(N1,N2) => N1[1].to_integer() >= N2[1].to_integer().</syntaxhighlight>
===Test===
<syntaxhighlight lang="picat">import util.
go =>
Ls = [[1, 34, 3, 98, 9, 76, 45, 4],
[54, 546, 548, 60],
[97, 9, 13, 979],
[9, 1, 95, 17, 5]
],
foreach(L in Ls)
test(L)
end,
nl.
% Test all implementations
test(L) =>
println(l=L),
maxof_inc(s_perm1(L,Num1), Num1),
println(s_perm1=Num1),
s_perm2(L,Num2),
println(s_perm2=Num2),
s_sort_conc(L,Num3),
println(s_sort_conc=Num3),
s_extend(L,Num4),
println(s_extent=Num4),
nl.</syntaxhighlight>
{{out}}
<pre>l = [1,34,3,98,9,76,45,4]
s_perm1 = 998764543431
s_perm2 = 998764543431
s_sort_conc = 998764543431
s_extend = 998764543431
l = [54,546,548,60]
s_perm1 = 6054854654
s_perm2 = 6054854654
s_sort_conc = 6054854654
s_extend = 6054854654
l = [97,9,13,979]
s_perm1 = 99799713
s_perm2 = 99799713
s_sort_conc = 99799713
s_extend = 99799713
l = [9,1,95,17,5]
s_perm1 = 9955171
s_perm2 = 9955171
s_sort_conc = 9955171
s_extend = 9955171</pre>
===Testing larger instance===
Test a larger instance: 2000 random numbers between 1 and 100; about 5800 digits. The two permutation variants (<code>s_perm1</code> and <code>s_perm2</code>) takes too long on larger N, say N > 9.
<syntaxhighlight lang="picat">go2 =>
garbage_collect(100_000_000),
_ = random2(),
N = 2000,
println(nums=N),
L = [random(1,1000) : _ in 1..N],
S = join([I.to_string : I in L],''),
println(str_len=S.len),
nl,
println("s_sort_conc:"),
time(s_sort_conc(L,_Num3)),
println("s_extend:"),
time(s_extend(L,_Num4)),
nl.</syntaxhighlight>
{{out}}
<pre>nums = 2000
str_len = 5805
s_sort_conc:
CPU time 0.54 seconds.
s_extend:
CPU time 0.526 seconds.</pre>
=={{header|PicoLisp}}==
Line 1,734 ⟶ 1,890:
unique lists (as the comparison of identical numbers would not terminate), so a
better solution might involve additional checks.
<
===Algorithm 1===
<
(prinl (maxi format (permute L))) )</
===Algorithm 2===
<
(prinl
(sort L
Line 1,745 ⟶ 1,901:
(>
(format (pack A B))
(format (pack B A)) ) ) ) ) )</
===Algorithm 3===
<
(prinl
(flip
(by '((N) (apply circ (chop N))) sort L) ) ) )</
{{out}} in all three cases:
<pre>998764543431
Line 1,756 ⟶ 1,912:
=={{header|PL/I}}==
<
/* Largest catenation of integers 16 October 2013 */
/* Sort using method 2, comparing pairs of adjacent integers. */
Line 1,787 ⟶ 1,943:
end largest_integer;
end Largest;
</syntaxhighlight>
<pre>
54 546 548 60
Line 1,799 ⟶ 1,955:
{{works with|PowerShell|2}}
Using algorithm 3
<
{
# Get the length of the largest integer
Line 1,815 ⟶ 1,971:
return $Integer
}</
<
Get-LargestConcatenation 54, 546, 548, 60
Get-LargestConcatenation 54, 546, 548, 60, 54, 546, 548, 60</
{{out}}
<pre>998764543431
Line 1,827 ⟶ 1,983:
Works with SWI-Prolog 6.5.3.
===All permutations method===
<
maplist(name, In, LC),
aggregate(max(V), get_int(LC, V), Out).
Line 1,836 ⟶ 1,992:
append(P, LV),
name(V, LV).
</syntaxhighlight>
{{out}}
<pre> ?- largest_int_v1([1, 34, 3, 98, 9, 76, 45, 4], Out).
Line 1,847 ⟶ 2,003:
===Method 2===
<
maplist(name, In, LC),
predsort(my_sort,LC, LCS),
Line 1,882 ⟶ 2,038:
my_sort(R, [H1, H1 | T], [H1]) :-
my_sort(R, [H1 | T], [H1]) .
</syntaxhighlight>
{{out}}
Line 1,896 ⟶ 2,052:
This also shows one of the few times where cmp= is better than key= on sorted()
<
cmp # Python 2 OK or NameError in Python 3
def maxnum(x):
Line 1,910 ⟶ 2,066:
key=cmp_to_key(lambda x,y:cmp(y+x, x+y))))
for numbers in [(1, 34, 3, 98, 9, 76, 45, 4), (54, 546, 548, 60)]:
print('Numbers: %r\n Largest integer: %15s' % (numbers, maxnum(numbers)))</
{{out}}
Line 1,920 ⟶ 2,076:
===Python: Compare repeated string method===
<
maxlen = len(str(max(x)))
return ''.join(sorted((str(v) for v in x), reverse=True,
Line 1,926 ⟶ 2,082:
for numbers in [(212, 21221), (1, 34, 3, 98, 9, 76, 45, 4), (54, 546, 548, 60)]:
print('Numbers: %r\n Largest integer: %15s' % (numbers, maxnum(numbers)))</
{{out}}
Line 1,937 ⟶ 2,093:
{{works with|Python|2.6+}}
<
from math import log10
Line 1,945 ⟶ 2,101:
for numbers in [(1, 34, 3, 98, 9, 76, 45, 4), (54, 546, 548, 60)]:
print('Numbers: %r\n Largest integer: %15s' % (numbers, maxnum(numbers)))</
;Output as first Python example, above.
===Python: Try all permutations method===
<
def maxnum(x):
return max(int(''.join(n) for n in permutations(str(i) for i in x)))
for numbers in [(1, 34, 3, 98, 9, 76, 45, 4), (54, 546, 548, 60)]:
print('Numbers: %r\n Largest integer: %15s' % (numbers, maxnum(numbers)))</
;Output as above.
=={{header|Quackery}}==
===With a string of space separated sequences of digits===
<syntaxhighlight lang="quackery">[ sortwith
[ 2dup swap join
dip join $< ]
[] swap witheach join ] is largest-int ( [ --> $ )
$ '1 34 3 98 9 76 45 4' nest$ largest-int echo$ cr
$ '54 546 548 60' nest$ largest-int echo$</syntaxhighlight>
{{out}}
<pre>
998764543431
6054854654
</pre>
===With a nest of numbers===
<syntaxhighlight lang="quackery"> [ number$ dip number$ join $->n drop ] is conc ( n n --> n )
[ 2dup conc unrot swap conc < ] is conc> ( n n --> b )
[ sortwith conc>
$ "" swap
witheach [ number$ join ]
$->n drop ] is task ( [ --> n )
' [ [ 1 34 3 98 9 76 45 4 ]
[ 54 546 548 60 ] ]
witheach [ task echo cr ] </syntaxhighlight>
{{out}}
<pre>998764543431
6054854654</pre>
=={{header|R}}==
<syntaxhighlight lang="r">Largest_int_from_concat_ints <- function(vec){
#recursive function for computing all permutations
perm <- function(vec) {
n <- length(vec)
if (n == 1)
return(vec)
else {
x <- NULL
for (i in 1:n){
x <- rbind(x, cbind(vec[i], perm(vec[-i])))
}
return(x)
}
}
permutations <- perm(vec)
concat <- as.numeric(apply(permutations, 1, paste, collapse = ""))
return(max(concat))
}
#Verify
Largest_int_from_concat_ints(c(54, 546, 548, 60))
Largest_int_from_concat_ints(c(1, 34, 3, 98, 9, 76, 45, 4))
Largest_int_from_concat_ints(c(93, 4, 89, 21, 73))
</syntaxhighlight>
{{out}}
<pre>
[1] 6054854654
[1] 998764543431
[1] 938973421
</pre>
=={{header|Racket}}==
<syntaxhighlight lang="racket">
#lang racket
(define (largest-int ns)
Line 1,967 ⟶ 2,196:
(map largest-int '((1 34 3 98 9 76 45 4) (54 546 548 60)))
;; -> '(998764543431 6054854654)
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" line>sub maxnum(*@x) {
[~] @x.sort: -> $a, $b { $b ~ $a leg $a ~ $b }
}
say maxnum <1 34 3 98 9 76 45 4>;
say maxnum <54 546 548 60>;</syntaxhighlight>
{{out}}
<pre>998764543431
6054854654</pre>
=={{header|Red}}==
<syntaxhighlight lang="rebol">Red []
foreach seq [[1 34 3 98 9 76 45 4] [54 546 548 60]] [
print rejoin sort/compare seq function [a b] [ (rejoin [a b]) > rejoin [b a] ]
]
</syntaxhighlight>
{{out}}
<pre>
998764543431
6054854654</pre>
=={{header|REXX}}==
The algorithm used is based on exact comparisons (left to right) with ''right digit fill'' of the ''left digit''.
Line 1,976 ⟶ 2,227:
<br>verify that the numbers are indeed integers (and it also normalizes the integers).
The absolute value is used for negative numbers. No sorting of the numbers is required for the 1<sup>st</sup> two examples.
===simple integers===
<
@.=.; @.1 =
@.2 =
@.3 =
w=0 /* [↓] process all the integer lists.*/
do j=1 while @.j\==.; z= space(@.j)
w=max(w, length(z) ); $= /*obtain maximum width to align output.*/
do while z\=''; idx= 1;
do k=2 to words(z); #= norm(k)
L= max(length(big), length(#) )
if left(#, L, left(#, 1) ) <<= left(big, L, left(big, 1) ) then iterate
big= #; idx= k
end /*k*/ /* [↑] find max concatenated integer. */
z= delword(z, idx, 1)
$= $ ||
end /*while z*/ /* [↑] process all integers in a list.*/
say 'largest concatenatated integer from ' left( space(@.j), w) " is ─────► " $
end /*j*/ /* [↑] process each list of integers. */
exit
/*──────────────────────────────────────────────────────────────────────────────────────*/
norm: arg i; #= word(z, i);
if \datatype(#,'W') then do; say er
{{out|output|text= when using the default (internal) integer lists:}}
<pre>
Line 2,018 ⟶ 2,267:
This REXX version can handle any sized integer (most REXXes can handle up to around eight million decimal
<br>digits, but displaying the result would be problematic for results wider than the display area).
<
@.=.; @.1 =
@.2 =
@.3 =
@.4 =
w=
do j=1 while @.j\==.; z= space(@.j)
w=max(w, length(z) ); $= /*obtain maximum width to align output.*/
do while z\=''; idx=1; big= norm(1)
do k=2 to words(z); #= norm(k)
L= max(length(big), length(#) )
if left(#, L, left(#, 1) ) <<= left(big, L, left(big, 1) ) then iterate
big=#; idx=
end /*k*/ /* [↑] find max concatenated integer. */
z= delword(z, idx, 1)
$= $ ||
end /*while z*/ /* [↑] process all integers in a list.*/
say 'largest concatenatated integer from ' left( space(@.j), w) " is " $
Line 2,039 ⟶ 2,288:
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
norm: arg i; #= word(z, i);
if \datatype(#, 'N') then
else #= # / 1
if pos('E',#)>0 then do; parse var # mant "E" pow /*Has exponent? Expand*/
numeric digits pow + length(mand) /*expand digs, adjust#*/
end
if
er13: say er # "isn't an integer."; exit 13</syntaxhighlight>
{{out|output|text= when using the default (internal) integer lists:}}
(Output shown at three-quarter size.)
<pre style="font-size:75%">
largest concatenatated integer from 1 34 3 98 9 76 45 4 is 998764543431
largest concatenatated integer from 54 546 548 60 is 6054854654
Line 2,057 ⟶ 2,309:
===Alternate Version===
Inspired by the previous versions.
<syntaxhighlight lang="text">/*REXX program constructs the largest integer from an integer list using concatenation.*/
l.=''; l.1 = '1 34 3 98 9 76 45 4' /*the 1st integer list to be used. */
l.2 = '54 546 548 60' /* " 2nd " " " " " */
Line 2,112 ⟶ 2,364:
result=result||big /*append " " " ---? $. */
end /*while z*/ /* [?] process all integers in a list.*/
Return result</
{{out}}
<pre>1 34 3 98 9 76 45 4 -> 998764543431
Line 2,122 ⟶ 2,374:
===Version 4===
{{trans|NetRexx}}
<
l.=''; l.1 = '1 34 3 98 9 76 45 4' /*the 1st integer list to be used. */
l.2 = '54 546 548 60' /* " 2nd " " " " " */
Line 2,202 ⟶ 2,454:
list=list w.ww
End
Return space(list,0)</
{{out}}
<pre>1 34 3 98 9 76 45 4 -> 998764543431
Line 2,214 ⟶ 2,466:
=={{header|Ring}}==
<
nums=[1,34,3,98,9,76,45,4]
see largestInt(8) + nl
Line 2,239 ⟶ 2,491:
next
return l
</syntaxhighlight>
Output:
<pre>
998764543431
6054854654
</pre>
=={{header|RPL}}==
We use here the second algorithm, easily derived from the SORT program given in [[Sorting algorithms/Bubble sort#RPL|Sorting algorithms/Bubble sort]].
{{works with|HP|28}}
≪ LIST→ → len
≪ 1 len '''START'''
→STR len ROLL '''END'''
len 1 '''FOR''' n
1 n 1 - '''START'''
'''IF''' DUP2 + LAST SWAP + < '''THEN''' SWAP '''END'''
n ROLLD
'''NEXT''' n ROLLD
-1 '''STEP'''
2 len '''START''' + '''END''' STR→
≫ ≫ ‘<span style="color:blue">MKBIG</span>’ STO
{212 21221} <span style="color:blue">MKBIG</span>
{1 34 3 98 9 76 45 4} <span style="color:blue">MKBIG</span>
{54 546 548 60} <span style="color:blue">MKBIG</span>
{{out}}
<pre>
3: 21221221
2: 998764543431
1: 6054854654
</pre>
Line 2,251 ⟶ 2,528:
{{trans|Tcl}}
<
nums.sort { |x, y| "#{y}#{x}" <=> "#{x}#{y}" }
end
Line 2,258 ⟶ 2,535:
p c # prints nicer in Ruby 1.8
puts icsort(c).join
end</
{{out}}
Line 2,268 ⟶ 2,545:
===Compare repeated string method===
<
maxlen = nums.max.to_s.length
nums.map{ |x| x.to_s }.sort_by { |x| x * (maxlen * 2 / x.length) }.reverse
Line 2,276 ⟶ 2,553:
p c # prints nicer in Ruby 1.8
puts icsort(c).join
end</
;Output as above.
<
def icsort nums
Line 2,289 ⟶ 2,566:
p c # prints nicer in Ruby 1.8
puts icsort(c).join
end</
;Output as above.
=={{header|Run BASIC}}==
<
a2$ = "54,546,548,60"
Line 2,322 ⟶ 2,599:
maxNum$ = maxNum$ ; a$(j)
next j
end function</
{{out}}
<pre>Max Num 1, 34, 3, 98, 9, 76, 45, 4 = 998764543431
Line 2,328 ⟶ 2,605:
=={{header|Rust}}==
<
a.sort_by(|x, y| {
let xy = format!("{}{}", x, y);
Line 2,343 ⟶ 2,620:
maxcat(&mut [1, 34, 3, 98, 9, 76, 45, 4]);
maxcat(&mut [54, 546, 548, 60]);
}</
{{out}}
<pre>998764543431
Line 2,349 ⟶ 2,626:
=={{header|S-lang}}==
<
{
a = string(a);
Line 2,367 ⟶ 2,644:
print("max of series 1 is " + maxcat([1, 34, 3, 98, 9, 76, 45, 4]));
print("max of series 2 is " + maxcat([54, 546, 548, 60]));
</syntaxhighlight>
{{out}}
<pre>"max of series 1 is 998764543431"
Line 2,375 ⟶ 2,652:
=={{header|Scala}}==
{{libheader|Scala}}
<
def lifci(list: List[Long]) = list.permutations.map(_.mkString).max
Line 2,381 ⟶ 2,658:
println(lifci(List(1, 34, 3, 98, 9, 76, 45, 4)))
println(lifci(List(54, 546, 548, 60)))
}</
{{out}}
Line 2,390 ⟶ 2,667:
=={{header|Scheme}}==
<
(define (my-compare a b) (string>? (cat a b) (cat b a)))
(map (lambda (xs) (string->number (apply cat (sort xs my-compare))))
'((1 34 3 98 9 76 45 4) (54 546 548 60)))</
{{output}}
<pre>
Line 2,403 ⟶ 2,680:
=={{header|Sidef}}==
{{trans|Ruby}}
<
nums.sort {|x,y| "#{y}#{x}" <=> "#{x}#{y}" };
}
Line 2,409 ⟶ 2,686:
[[54, 546, 548, 60], [1, 34, 3, 98, 9, 76, 45, 4]].each { |c|
say maxnum(c).join.to_num;
}</
{{out}}
<pre>
Line 2,415 ⟶ 2,692:
998764543431
</pre>
=={{header|Smalltalk}}==
Version 1) sort by padded print strings:
{{works with|Smalltalk/X}}
<syntaxhighlight lang="smalltalk">#(
(54 546 548 60)
(1 34 3 98 9 76 45 4)
) do:[:ints |
|resultString|
"sort ints by padded strings (sort a copy - literals are immudatble),
then collect their strings, then concatenate"
resultString :=
((ints copy sort:[:a :b |
|pad|
pad := (a integerLog10) max:(b integerLog10).
(a printString paddedTo:pad with:$0) > (b printString paddedTo:pad with:$0)])
collect:#printString) asStringWith:''.
Stdout printCR: resultString.
].</syntaxhighlight>
Version 2) alternative: sort by concatenated pair's strings:
<syntaxhighlight lang="smalltalk">#(
(54 546 548 60)
(1 34 3 98 9 76 45 4)
) do:[:ints |
|resultString|
resultString :=
((ints copy sort:[:a :b | e'{a}{b}' > e'{b}{a}']) "(1)"
collect:#printString) asStringWith:''.
Stdout printCR: resultString.
].</syntaxhighlight>
Note ¹ replace "e'{a}{b}'" by "(a printString,b printString)" in dialects, which do not support embedded expression strings.
Version 3) no need to collect the resultString; simply print the sorted list (ok, if printing is all we want):
<syntaxhighlight lang="smalltalk">#(
(54 546 548 60)
(1 34 3 98 9 76 45 4)
) do:[:ints |
(ints copy sort:[:a :b | e'{a}{b}' > e'{b}{a}'])
do:[:eachNr | eachNr printOn:Stdout].
Stdout cr.
]</syntaxhighlight>
Version 4) no need to generate any intermediate strings; the following will do as well:
<syntaxhighlight lang="smalltalk">#(
(54 546 548 60)
(1 34 3 98 9 76 45 4)
) do:[:ints |
(ints copy sortByApplying:[:i | i log10 fractionPart]) reverseDo:#print.
Stdout cr.
]</syntaxhighlight>
{{out}}
<pre>6054854654
989764543431</pre>
=={{header|Tcl}}==
<
lsort -command {apply {{x y} {expr {"$y$x" - "$x$y"}}}} $nums
}</
Demonstrating:
<
{1 34 3 98 9 76 45 4}
{54 546 548 60}
Line 2,427 ⟶ 2,759:
set sorted [intcatsort $collection]
puts "\[$collection\] => \[$sorted\] (concatenated: [join $sorted ""])"
}</
{{out}}
<pre>
[1 34 3 98 9 76 45 4] => [9 98 76 45 4 34 3 1] (concatenated: 998764543431)
[54 546 548 60] => [60 548 546 54] (concatenated: 6054854654)
</pre>
=={{header|Transd}}==
<syntaxhighlight lang="Scheme">#lang transd
MainModule: {
_start: (lambda
(for ar in [[98, 76, 45, 34, 9, 4, 3, 1], [54, 546, 548, 60]] do
(sort ar (λ l Int() r Int() (ret (> Int(String(l r)) Int(String(r l))))))
(lout (join ar "")))
)
}</syntaxhighlight>
{{out}}
<pre>
998764543431
6054854654
</pre>
=={{header|Uiua}}==
<syntaxhighlight lang="uiua">
A ← {[212 21221] [1 34 3 98 9 76 45 4][54 546 548 60]}
≡(⋕/◇⊂⊏⊸(⍖≡↯[/↥≡⧻]).°⋕)A
</syntaxhighlight>
{{out}}
<pre>
[21221212 989764543431 6054854654]
</pre>
=={{header|VBScript}}==
{{trans|BBC BASIC}}
<syntaxhighlight lang="vb">
Function largestint(list)
nums = Split(list,",")
Line 2,461 ⟶ 2,819:
WScript.StdOut.Write largestint(WScript.Arguments(0))
WScript.StdOut.WriteLine
</syntaxhighlight>
{{Out}}
Line 2,474 ⟶ 2,832:
=={{header|Vim Script}}==
This solution is intended to be run as an Ex command within a buffer containing the integers to be processed, one per line.
<
;Demonstration
<
1 34 3 98 9 76 45 4
$ vim -S icsort.vim nums
998764543431</
=={{header|Wren}}==
{{trans|Kotlin}}
{{libheader|Wren-sort}}
<syntaxhighlight lang="wren">import "./sort" for Sort
var cmp = Fn.new { |x, y|
var xy = Num.fromString(x.toString + y.toString)
var yx = Num.fromString(y.toString + x.toString)
return (xy - yx).sign
}
var findLargestSequence = Fn.new { |a|
var b = Sort.merge(a, cmp)
return b[-1..0].join()
}
var arrays = [
[1, 34, 3, 98, 9, 76, 45, 4],
[54, 546, 548, 60]
]
for (a in arrays) {
System.print("%(a) -> %(findLargestSequence.call(a))")
}</syntaxhighlight>
{{out}}
<pre>
[1, 34, 3, 98, 9, 76, 45, 4] -> 998764543431
[54, 546, 548, 60] -> 6054854654
</pre>
=={{header|zkl}}==
<
ns.apply("toString").sort(fcn(a,b){ (a+b)>(b+a) }).concat();
}</
<
bigCI(T(54, 546, 548, 60)).println();</
{{out}}
<pre>
|