Largest int from concatenated ints: Difference between revisions
Added Uiua solution
(Added Uiua solution) |
|||
(80 intermediate revisions by 34 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;
}
o_newline();
}
main(void)
{
largest(1, 34, 3, 98, 9, 76, 45, 4);
largest(54, 546, 548, 60);
}</
works for input up to 999999999.
{{Out}}
Line 97 ⟶ 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 165 ⟶ 177:
print( ( newline ) )
END</
{{out}}
<pre>
Line 171 ⟶ 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 183 ⟶ 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 191 ⟶ 212:
)
loop, parse, d, `n
MsgBox % LargestConcatenatedInts(A_LoopField)</
{{out}}
<pre>998764543431
Line 199 ⟶ 220:
=={{header|AWK}}==
{{works with|gawk|4.0}}
<
function cmp(i1, v1, i2, v2, u1, u2) {
u1 = v1""v2;
Line 219 ⟶ 240:
print largest_int_from_concatenated_ints(X)
}
</syntaxhighlight>
{{out}}
<pre>998764543431
Line 225 ⟶ 246:
=={{header|BBC BASIC}}==
<
Nums%()=1,34,3,98,9,76,45,4
PRINT FNlargestint(8)
Line 245 ⟶ 266:
l$+=STR$Nums%(i%)
NEXT
=l$</
{{out}}
<pre>998764543431
Line 251 ⟶ 272:
=={{header|Bracmat}}==
<
= A Z F C
. !arg:#
Line 268 ⟶ 289:
& out$(str$(maxnum$(1 34 3 98 9 76 45 4)))
& out$(str$(maxnum$(54 546 548 60)))
);</
{{out}}
<pre>998764543431
Line 274 ⟶ 295:
=={{header|C}}==
<
#include <stdlib.h>
#include <string.h>
Line 304 ⟶ 325:
return 0;
}</
{{out}}
<pre>998764543431
6054854654</pre>
=={{header|C sharp|C#}}==
<
using System.Collections.Generic;
using System.Linq;
Line 380 ⟶ 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 414 ⟶ 436:
coll))))
(prn (map maxcat [[1 34 3 98 9 76 45 4] [54 546 548 60]]))</
{{out}}
Line 420 ⟶ 442:
=={{header|Common Lisp}}==
=== Sort by two-by-two comparison of largest concatenated result ===
<syntaxhighlight lang="lisp">
(defun int-concat (ints)
(read-from-string (format nil "~{~a~}" ints)))
(defun by-biggest-result (first second)
(> (int-concat (list first second)) (int-concat (list second first))))
(defun make-largest-int (ints)
(int-concat (sort ints #'by-biggest-result)))
</syntaxhighlight>
{{out}}
<pre>
> (make-largest-int '(1 34 3 98 9 76 45 4))
998764543431
> (make-largest-int '(54 546 548 60))
6054854654
</pre>
=== Variation around the sort with padded most significant digit ===
<syntaxhighlight lang="lisp">
;; Sort criteria is by most significant digit with least digits used as a tie
;; breaker
Line 446 ⟶ 493:
#'largest-msd-with-less-digits)))
</syntaxhighlight>
{{out}}
Line 456 ⟶ 503:
=={{header|D}}==
The three algorithms. Uses the second module from the Permutations Task.
<
auto maxCat1(in int[] arr) pure @safe {
Line 476 ⟶ 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 489 ⟶ 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 498 ⟶ 580:
=={{header|Erlang}}==
<syntaxhighlight lang="erlang">
-module( largest_int_from_concatenated ).
Line 510 ⟶ 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 517 ⟶ 599:
Largest 6054854654 from [54,546,548,60]
</pre>
=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">
// 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>
fN [1; 34; 3; 98; 9; 76; 45; 4] -> "998764543431"
fN [54; 546; 548; 60] -> "6054854654"
</pre>
=={{header|Factor}}==
Using algorithm 3:
<syntaxhighlight lang="factor">USING: assocs io kernel math qw sequences sorting ;
IN: rosetta-code.largest-int
: pad ( target seq -- padded )
2dup length / swap <repetition> concat swap head ;
: largest-int ( seq -- )
dup dup [ length ] map supremum ! find longest length so we know how much to pad
[ swap pad ] curry map ! pad the integers
<enum> sort-values ! sort the padded integers
keys ! find the original indices of the sorted integers
swap nths ! order non-padded integers according to their sorted order
reverse concat print ;
qw{ 1 34 3 98 9 76 45 4 } qw{ 54 546 548 60 } [ largest-int ] bi@</syntaxhighlight>
{{out}}
<pre>
998764543431
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 527 ⟶ 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 599 ⟶ 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 620 ⟶ 750:
Biggest:9 8 7 6 5 4 3 2 1 10
</pre>
=={{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
<
Public Sub Main()
Line 752 ⟶ 860:
Print Val(sList.Join("")) 'Join all items in sList together and print
End</
Output:
<pre>
Line 760 ⟶ 868:
=={{header|Go}}==
<
// then sort as strings.
package main
Line 812 ⟶ 920:
fmt.Println(li(1, 34, 3, 98, 9, 76, 45, 4))
fmt.Println(li(54, 546, 548, 60))
}</
{{out}}
<pre>
Line 880 ⟶ 928:
=={{header|Groovy}}==
<
Testing:
<
assert largestInt([54, 546, 548, 60]) == 6054854654</
=={{header|Haskell}}==
===Compare repeated string method===
<
import Data.Ord (comparing)
Line 896 ⟶ 944:
in sortBy (flip $ comparing pad) xs
maxcat = read . concat . sorted . map show</
{{out}}
Line 902 ⟶ 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 912 ⟶ 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 939 ⟶ 988:
lifting.
<
procedure main(a)
Line 952 ⟶ 1,001:
procedure cmp(a,b)
return (a||b) > (b||a)
end</
Sample runs:
Line 964 ⟶ 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 975 ⟶ 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,016 ⟶ 1,066:
System.out.println(join(ints2));
}
}</
{{works with|Java|1.8+}}
<
import java.util.stream.Collectors;
import java.util.stream.Stream;
Line 1,065 ⟶ 1,115:
);
}
}</
{{out}}
<pre>998764543431
6054854654</pre>
=={{header|JavaScript}}==
===ES5===
<
'use strict';
Line 1,099 ⟶ 1,150:
})();
</syntaxhighlight>
{{Out}}
Line 1,108 ⟶ 1,159:
===ES6===
<
// test & output
Line 1,114 ⟶ 1,165:
[1, 34, 3, 98, 9, 76, 45, 4],
[54, 546, 548, 60]
].map(maxCombine));</
=={{header|jq}}==
Line 1,120 ⟶ 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,133 ⟶ 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,141 ⟶ 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.
<syntaxhighlight lang="julia">function maxconcat
b =
end
tests =
[54, 546, 548, 60],
[1, 34, 3, 98, 9, 76, 45, 4, 54, 546, 548, 60]
for
println("
end</syntaxhighlight>
{{out}}
<pre>Max concatenating in [1, 34, 3, 98, 9, 76, 45, 4]:
-> 998764543431
Max concatenating in [54, 546, 548, 60]:
-> 6054854654
Max concatenating in [1, 34, 3, 98, 9, 76, 45, 4, 54, 546, 548, 60]:
-> 9987660548546544543431</pre>
=={{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,217 ⟶ 1,257:
table.concat(numbers,","),table.concat(icsort(numbers))
))
end</
{{out}}
<pre>Numbers: {1,34,3,98,9,76,45,4}
Line 1,224 ⟶ 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,231 ⟶ 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,286 ⟶ 1,365:
end il
return
</syntaxhighlight>
{{out}}
<pre>
Line 1,294 ⟶ 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,308 ⟶ 1,388:
=={{header|OCaml}}==
<
let icsort nums = String.concat "" (List.sort myCompare (List.map string_of_int nums))</
;testing
Line 1,322 ⟶ 1,402:
=={{header|Oforth}}==
<
{{out}}
Line 1,329 ⟶ 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,424 ⟶ 1,514:
var
i,l : integer;
s :
begin
{ the easy way
Line 1,471 ⟶ 1,561:
InsertData(tmpData[i],source3[i]);
HighestInt(tmpData);
end.</
{{out}}
<pre>998764543431
Line 1,480 ⟶ 1,570:
http://rosettacode.org/wiki/Largest_int_from_concatenated_ints#Compare_repeated_string_method
<
base = 10;
MaxDigitCnt = 11;
Line 1,605 ⟶ 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,644 ⟶ 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,665 ⟶ 1,733:
=={{header|PHP}}==
<
usort($nums, function ($x, $y) { return strcmp("$y$x", "$x$y"); });
return implode('', $nums);
Line 1,671 ⟶ 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,683 ⟶ 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,694 ⟶ 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,705 ⟶ 1,912:
=={{header|PL/I}}==
<
/* Largest catenation of integers 16 October 2013 */
/* Sort using method 2, comparing pairs of adjacent integers. */
Line 1,736 ⟶ 1,943:
end largest_integer;
end Largest;
</syntaxhighlight>
<pre>
54 546 548 60
Line 1,748 ⟶ 1,955:
{{works with|PowerShell|2}}
Using algorithm 3
<
{
# Get the length of the largest integer
Line 1,764 ⟶ 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,776 ⟶ 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,785 ⟶ 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,796 ⟶ 2,003:
===Method 2===
<
maplist(name, In, LC),
predsort(my_sort,LC, LCS),
Line 1,831 ⟶ 2,038:
my_sort(R, [H1, H1 | T], [H1]) :-
my_sort(R, [H1 | T], [H1]) .
</syntaxhighlight>
{{out}}
Line 1,845 ⟶ 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,859 ⟶ 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,869 ⟶ 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,875 ⟶ 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,886 ⟶ 2,093:
{{works with|Python|2.6+}}
<
from math import log10
Line 1,894 ⟶ 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,916 ⟶ 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''.
<br>This allows the integers to be of any size.
This REXX version works with any size integer (negative, zero, positive), and does some basic error checking to
<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===
<syntaxhighlight lang="rexx">/*REXX program constructs the largest integer from an integer list using concatenation.*/
@.=.; @.1 = 1 34 3 98 9 76 45 4 /*the 1st integer list to be used. */
@.2 = 54 546 548 60 /* " 2nd " " " " " */
@.3 = 4 45 54 5 /* " 3rd " " " " " */
w=0 /* [↓] process all the integer lists.*/
do j=1 while @.j\==.; z= space(@.j) /*keep truckin' until lists exhausted. */
w=max(w, length(z) ); $= /*obtain maximum width to align output.*/
do while z\=''; idx= 1; big= norm(1) /*keep examining the list until done.*/
do k=2 to words(z); #= norm(k) /*obtain an a number from the list. */
L= max(length(big), length(#) ) /*get the maximum length of the integer*/
if left(#, L, left(#, 1) ) <<= left(big, L, left(big, 1) ) then iterate
big= #; idx= k /*we found a new biggie (and the index)*/
end /*k*/ /* [↑] find max concatenated integer. */
z= delword(z, idx, 1) /*delete this maximum integer from list*/
$= $ || big /*append " " " ───► $. */
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 0 /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
norm: arg i; #= word(z, i); er= '***error***'; if left(#, 1)=="-" then #= substr(#, 2)
if \datatype(#,'W') then do; say er # "isn't an integer."; exit 13; end; return #/1</syntaxhighlight>
{{out|output|text= when using the default (internal) integer lists:}}
<pre>
largest concatenatated integer from 1 34 3 98 9 76 45 4 is ─────► 998764543431
largest concatenatated integer from 54 546 548 60 is ─────► 6054854654
largest concatenatated integer from 4 45 54 5 is ─────► 554454
</pre>
===exponentiated integers===
In REXX, a number such as '''6.6e77''' would be considered an integer ''if'' the (current) '''numeric digits''' is
<br>large enough to express that number as an integer without the exponent.
The default for REXX is '''9''' decimal digits, but the '''norm''' function automatically uses enough decimal digits to
<br>express the number as an integer.
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).
<syntaxhighlight lang="rexx">/*REXX program constructs the largest integer from an integer list using concatenation.*/
@.=.; @.1 = 1 34 3 98 9 76 45 4 /*the 1st integer list to be used. */
@.2 = 54 546 548 60 /* " 2nd " " " " " */
@.3 = 4 45 54 5 /* " 3rd " " " " " */
@.4 = 4 45 54 5 6.6e77 /* " 4th " " " " " */
w= 0 /* [↓] process all the integer lists.*/
do j=1 while @.j\==.; z= space(@.j) /*keep truckin' until lists exhausted. */
w=max(w, length(z) ); $= /*obtain maximum width to align output.*/
do while z\=''; idx=1; big= norm(1) /*keep examining the list until done.*/
do k=2 to words(z); #= norm(k) /*obtain an a number from the list. */
L= max(length(big), length(#) ) /*get the maximum length of the integer*/
if left(#, L, left(#, 1) ) <<= left(big, L, left(big, 1) ) then iterate
big=#; idx= k /*we found a new biggie (and the index)*/
end /*k*/ /* [↑] find max concatenated integer. */
z= delword(z, idx, 1) /*delete this maximum integer from list*/
$= $ || big /*append " " " ───► $. */
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 /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
else #= # / 1 /*a #, so normalize it*/
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
largest concatenatated integer from 4 45 54 5 is 554454
largest concatenatated integer from 4 45 54 5 6.6e77 is 660000000000000000000000000000000000000000000000000000000000000000000000000000554454
</pre>
===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 " " " " " */
l.3 = ' 4 45 54 5' /* " 3rd " " " " " */
l.4 = ' 4 45 54 5 6.6e77' /* " 4th " " " " " */
l.5 = ' 3 3 .2' /* " 5th " " " " " */
/*
soll.1=998764543431
soll.2=6054854654
soll.3=554454
soll.4=660000000000000000000000000000000000000000000000000000000000000000000000000000545454
*/
l_length=0
Do li=1 By 1 While l.li<>''
l_length=max(l_length,length(space(l.li)))
End
Do li=1 By 1 While l.li<>''
z=''
Do j=1 To words(l.li)
int=integer(word(l.li,j))
If int='?' Then Do
Say left(space(l.li),l_length) '-> ** invalid ** bad integer' word(l.li,j)
Iterate li
End
Else
z=z int
End
/*Say copies(' ',l_length) ' ' soll.li */
Say left(space(l.li),l_length) '->' largeint(l.li)
End
Exit
integer: Procedure
Numeric Digits 1000
Parse Arg z
If Datatype(z,'W') Then
Return z+0
Else
Return '?'
largeint:
result=''
Do While z<>'' /* [?] check the rest of the integers.*/
big=word(z,1); index=1; LB=length(big) /*assume that first integer is biggest.*/
do k=2 to words(z);
n=word(z,k) /*obtain an integer from the list. */
L=max(LB,length(n)) /*get the maximum length of the integer*/
if left(n,L,left(n,1))<<=left(big,L,left(big,1)) then iterate
big=n; index=k /*we found a new biggie (and the index)*/
LB=length(big)
End /*k*/
z=delword(z,index,1) /*delete this maximum integer from list*/
result=result||big /*append " " " ---? $. */
end /*while z*/ /* [?] process all integers in a list.*/
Return result</syntaxhighlight>
{{out}}
<pre>1 34 3 98 9 76 45 4 -> 998764543431
54 546 548 60 -> 6054854654
4 45 54 5 -> 554454
4 45 54 5 6.6e77 -> 660000000000000000000000000000000000000000000000000000000000000000000000000000554454
3 3 .2 -> ** invalid ** bad integer .2</pre>
===Version 4===
{{trans|NetRexx}}
<syntaxhighlight lang="rexx">/*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 " " " " " */
l.3 = ' 4 45 54 5' /* " 3rd " " " " " */
l.4 = ' 4 45 54 5 6.6e77' /* " 4th " " " " " */
l.5 = ' 3 3 .2' /* " 5th " " " " " */
l.6 = ' 4 45 54 5 6.6e1001' /* " 6th " " " " " */
l.7 = ' 4.0000 45 54 5.00' /* " 7th " " " " " */
l.8 = ' 10e999999999 5' /* " 8th " " " " " */
l_length=0
Do li=1 By 1 While l.li<>''
l_length=max(l_length,length(space(l.li)))
End
Do li=1 By 1 While l.li<>''
z=''
msg=''
Do j=1 To words(l.li)
int=integer(word(l.li,j))
If int='?' Then Do
Say left(space(l.li),l_length) '-> ** invalid ** bad list item:' word(l.li,j) msg
Iterate li
End
Else
z=z int
End
zz=largeint(z)
If length(zz)<60 Then
Say left(space(l.li),l_length) '->' zz
Else
Say left(space(l.li),l_length) '->' left(zz,5)'...'right(zz,5)
End
Exit
integer: Procedure Expose msg
Numeric Digits 1000
Parse Arg z
If Datatype(z,'W') Then
Return z/1
Else Do
If Datatype(z,'NUM') Then Do
Do i=1 To 6 Until dig>=999999999
dig= digits()*10
dig=min(dig,999999999)
Numeric Digits dig
If Datatype(z,'W') Then
Return z/1
End
msg='cannot convert it to an integer'
Return '?'
End
Else Do
msg='not a number (larger than what this REXX can handle)'
Return '?'
End
End
largeint: Procedure
Parse Arg list
w.0=words(list)
Do i=1 To w.0
w.i=word(list,i)
End
Do wx=1 To w.0-1
Do wy=wx+1 To w.0
xx=w.wx
yy=w.wy
xy=xx||yy
yx=yy||xx
if xy < yx then do
/* swap xx and yy */
w.wx = yy
w.wy = xx
end
End
End
list=''
Do ww=1 To w.0
list=list w.ww
End
Return space(list,0)</syntaxhighlight>
{{out}}
<pre>1 34 3 98 9 76 45 4 -> 998764543431
54 546 548 60 -> 6054854654
4 45 54 5 -> 554454
4 45 54 5 6.6e77 -> 66000...54454
3 3 .2 -> ** invalid ** bad list item: .2 cannot convert it to an integer
4 45 54 5 6.6e1001 -> 66000...54454
4.0000 45 54 5.00 -> 554454
10e999999999 5 -> ** invalid ** bad list item: 10e999999999 not a number (larger than what this REXX can handle)</pre>
=={{header|Ring}}==
<
nums=[1,34,3,98,9,76,45,4]
see largestInt(8) + nl
Line 1,987 ⟶ 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 1,999 ⟶ 2,528:
{{trans|Tcl}}
<
nums.sort { |x, y| "#{y}#{x}" <=> "#{x}#{y}" }
end
Line 2,006 ⟶ 2,535:
p c # prints nicer in Ruby 1.8
puts icsort(c).join
end</
{{out}}
Line 2,016 ⟶ 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,024 ⟶ 2,553:
p c # prints nicer in Ruby 1.8
puts icsort(c).join
end</
;Output as above.
<
def icsort nums
Line 2,037 ⟶ 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,070 ⟶ 2,599:
maxNum$ = maxNum$ ; a$(j)
next j
end function</
{{out}}
<pre>Max Num 1, 34, 3, 98, 9, 76, 45, 4 = 998764543431
Max Num 54,546,548,60 = 6054854654</pre>
=={{header|Rust}}==
<syntaxhighlight lang="rust">fn maxcat(a: &mut [u32]) {
a.sort_by(|x, y| {
let xy = format!("{}{}", x, y);
let yx = format!("{}{}", y, x);
xy.cmp(&yx).reverse()
});
for x in a {
print!("{}", x);
}
println!();
}
fn main() {
maxcat(&mut [1, 34, 3, 98, 9, 76, 45, 4]);
maxcat(&mut [54, 546, 548, 60]);
}</syntaxhighlight>
{{out}}
<pre>998764543431
6054854654</pre>
=={{header|S-lang}}==
<
{
a = string(a);
Line 2,095 ⟶ 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,103 ⟶ 2,652:
=={{header|Scala}}==
{{libheader|Scala}}
<
def lifci(list: List[Long]) = list.permutations.map(_.mkString).max
Line 2,109 ⟶ 2,658:
println(lifci(List(1, 34, 3, 98, 9, 76, 45, 4)))
println(lifci(List(54, 546, 548, 60)))
}</
{{out}}
Line 2,118 ⟶ 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,131 ⟶ 2,680:
=={{header|Sidef}}==
{{trans|Ruby}}
<
nums.sort {|x,y| "#{y}#{x}" <=> "#{x}#{y}" };
}
Line 2,137 ⟶ 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,143 ⟶ 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,155 ⟶ 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,189 ⟶ 2,819:
WScript.StdOut.Write largestint(WScript.Arguments(0))
WScript.StdOut.WriteLine
</syntaxhighlight>
{{Out}}
Line 2,202 ⟶ 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>
|