Largest int from concatenated ints: Difference between revisions
m
Added Easylang
(→{{header|Quackery}}: second method) |
m (Added Easylang) |
||
| (15 intermediate revisions by 13 users not shown) | |||
Line 24:
{{trans|Python}}
<
V maxlen = String(max(x)).len
R sorted
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)))</
{{out}}
Line 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 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 83:
Print_Sorted((1, 34, 3, 98, 9, 76, 45, 4));
Print_Sorted((54, 546, 548, 60));
end Largest_Int_From_List;</
=={{header|Aime}}==
<
{
index x;
Line 101:
largest(54, 546, 548, 60);
0;
}</
works for input up to 999999999.
{{Out}}
Line 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 177:
print( ( newline ) )
END</
{{out}}
<pre>
Line 185:
=={{header|Arturo}}==
<
max map permutate arr 's [
to :integer join map s => [to :string]
Line 191:
loop [[1 34 3 98 9 76 45 4] [54 546 548 60]] 'a ->
print largestConcInt a</
=={{header|AutoHotkey}}==
<
StringReplace, var, A_LoopField,%A_Space%,, all
Sort, var, D`, fConcSort
Line 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 212:
)
loop, parse, d, `n
MsgBox % LargestConcatenatedInts(A_LoopField)</
{{out}}
<pre>998764543431
Line 220:
=={{header|AWK}}==
{{works with|gawk|4.0}}
<
function cmp(i1, v1, i2, v2, u1, u2) {
u1 = v1""v2;
Line 240:
print largest_int_from_concatenated_ints(X)
}
</syntaxhighlight>
{{out}}
<pre>998764543431
Line 246:
=={{header|BBC BASIC}}==
<
Nums%()=1,34,3,98,9,76,45,4
PRINT FNlargestint(8)
Line 266:
l$+=STR$Nums%(i%)
NEXT
=l$</
{{out}}
<pre>998764543431
Line 272:
=={{header|Bracmat}}==
<
= A Z F C
. !arg:#
Line 289:
& out$(str$(maxnum$(1 34 3 98 9 76 45 4)))
& out$(str$(maxnum$(54 546 548 60)))
);</
{{out}}
<pre>998764543431
Line 295:
=={{header|C}}==
<
#include <stdlib.h>
#include <string.h>
Line 325:
return 0;
}</
{{out}}
Line 332:
=={{header|C sharp|C#}}==
<
using System.Collections.Generic;
using System.Linq;
Line 366:
}
}
</syntaxhighlight>
{{out}}
Line 373:
=={{header|C++}}==
<
#include <sstream>
#include <algorithm>
Line 401:
<< " !\n" ;
return 0 ;
}</
{{out}}
Line 410:
{{trans|Kotlin}}
{{works with|Ceylon|1.3.3}}
<
function comparator(Integer x, Integer y) {
Line 425:
value test2 = {54, 546, 548, 60};
print(biggestConcatenation(test2));
}</
=={{header|Clojure}}==
<
(read-string
(apply str
Line 436:
coll))))
(prn (map maxcat [[1 34 3 98 9 76 45 4] [54 546 548 60]]))</
{{out}}
Line 444:
=== Sort by two-by-two comparison of largest concatenated result ===
<
(defun int-concat (ints)
(read-from-string (format nil "~{~a~}" ints)))
Line 453:
(defun make-largest-int (ints)
(int-concat (sort ints #'by-biggest-result)))
</syntaxhighlight>
{{out}}
Line 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 493:
#'largest-msd-with-less-digits)))
</syntaxhighlight>
{{out}}
Line 503:
=={{header|D}}==
The three algorithms. Uses the second module from the Permutations Task.
<
auto maxCat1(in int[] arr) pure @safe {
Line 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>
Line 529:
=={{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 539 ⟶ 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 548 ⟶ 580:
=={{header|Erlang}}==
<syntaxhighlight lang="erlang">
-module( largest_int_from_concatenated ).
Line 560 ⟶ 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 569 ⟶ 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 581 ⟶ 613:
=={{header|Factor}}==
Using algorithm 3:
<
IN: rosetta-code.largest-int
Line 595 ⟶ 627:
reverse concat print ;
qw{ 1 34 3 98 9 76 45 4 } qw{ 54 546 548 60 } [ largest-int ] bi@</
{{out}}
<pre>
Line 604 ⟶ 636:
Or alternatively, a translation of F#.
{{trans|F#}}
<
: fn ( seq -- str )
[ 2dup swap [ append ] 2bi@ after? +lt+ +gt+ ? ] sort concat ;</
{{out}}
<pre>
Line 625 ⟶ 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 697 ⟶ 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 720 ⟶ 752:
=={{header|FreeBASIC}}==
<
function catint( a as string, b as string ) as uinteger
Line 762 ⟶ 794:
sort_and_print(set1())
sort_and_print(set2())</
{{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 817 ⟶ 860:
Print Val(sList.Join("")) 'Join all items in sList together and print
End</
Output:
<pre>
Line 825 ⟶ 868:
=={{header|Go}}==
<
// then sort as strings.
package main
Line 877 ⟶ 920:
fmt.Println(li(1, 34, 3, 98, 9, 76, 45, 4))
fmt.Println(li(54, 546, 548, 60))
}</
{{out}}
<pre>
Line 885 ⟶ 928:
=={{header|Groovy}}==
<
Testing:
<
assert largestInt([54, 546, 548, 60]) == 6054854654</
=={{header|Haskell}}==
===Compare repeated string method===
<
import Data.Ord (comparing)
Line 901 ⟶ 944:
in sortBy (flip $ comparing pad) xs
maxcat = read . concat . sorted . map show</
{{out}}
Line 907 ⟶ 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 917 ⟶ 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 ()
Line 936 ⟶ 979:
(maxcat <$> [[1, 34, 3, 98, 9, 76, 45, 4], [54, 546, 548, 60]] :: [Integer])
where
maxcat = read . maximum . fmap (concatMap show) . permutations</
;Output as above.
Line 945 ⟶ 988:
lifting.
<
procedure main(a)
Line 958 ⟶ 1,001:
procedure cmp(a,b)
return (a||b) > (b||a)
end</
Sample runs:
Line 970 ⟶ 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 981 ⟶ 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,022 ⟶ 1,066:
System.out.println(join(ints2));
}
}</
{{works with|Java|1.8+}}
<
import java.util.stream.Collectors;
import java.util.stream.Stream;
Line 1,071 ⟶ 1,115:
);
}
}</
{{out}}
<pre>998764543431
Line 1,080 ⟶ 1,124:
===ES5===
<
'use strict';
Line 1,106 ⟶ 1,150:
})();
</syntaxhighlight>
{{Out}}
Line 1,115 ⟶ 1,159:
===ES6===
<
// test & output
Line 1,121 ⟶ 1,165:
[1, 34, 3, 98, 9, 76, 45, 4],
[54, 546, 548, 60]
].map(maxCombine));</
=={{header|jq}}==
Line 1,127 ⟶ 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,140 ⟶ 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,148 ⟶ 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(string.(arr); lt=(x, y) -> x * y < y * x, rev=true) |> join
return try parse(Int, b) catch parse(BigInt, b) end
Line 1,167 ⟶ 1,211:
for arr in tests
println("Max concatenating in $arr:\n -> ", maxconcat(arr))
end</
{{out}}
Line 1,179 ⟶ 1,223:
=={{header|Kotlin}}==
{{trans|C#}}
<
fun main(args: Array<String>) {
Line 1,194 ⟶ 1,238:
println("%s -> %s".format(array.contentToString(), findLargestSequence(array)))
}
}</
{{Out}}
<pre>
Line 1,204 ⟶ 1,248:
{{trans|Python}}
<
table.sort(numbers,function(x,y) return (x..y) > (y..x) end)
return numbers
Line 1,213 ⟶ 1,257:
table.concat(numbers,","),table.concat(icsort(numbers))
))
end</
{{out}}
<pre>Numbers: {1,34,3,98,9,76,45,4}
Line 1,220 ⟶ 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,227 ⟶ 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}}
<
('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!</
{{out}}
<pre>
Line 1,246 ⟶ 1,318:
=={{header|NetRexx}}==
<
options replace format comments java crossref symbols nobinary
Line 1,293 ⟶ 1,365:
end il
return
</syntaxhighlight>
{{out}}
<pre>
Line 1,301 ⟶ 1,373:
=={{header|Nim}}==
<
proc maxNum(x: seq[int]): string =
Line 1,309 ⟶ 1,381:
echo maxNum(@[1, 34, 3, 98, 9, 76, 45, 4])
echo maxNum(@[54, 546, 548, 60])</
{{out}}
Line 1,316 ⟶ 1,388:
=={{header|OCaml}}==
<
let icsort nums = String.concat "" (List.sort myCompare (List.map string_of_int nums))</
;testing
Line 1,330 ⟶ 1,402:
=={{header|Oforth}}==
<
{{out}}
Line 1,341 ⟶ 1,413:
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.
<
large([1, 34, 3, 98, 9, 76, 45, 4])
large([54, 546, 548, 60])</
{{out}}
<pre>%1 = 998764543431
Line 1,351 ⟶ 1,423:
tested with freepascal.Used a more extreme example 3.
===algorithm 3===
<
base = 10;
MaxDigitCnt = 11;
Line 1,489 ⟶ 1,561:
InsertData(tmpData[i],source3[i]);
HighestInt(tmpData);
end.</
{{out}}
<pre>998764543431
Line 1,498 ⟶ 1,570:
http://rosettacode.org/wiki/Largest_int_from_concatenated_ints#Compare_repeated_string_method
<
base = 10;
MaxDigitCnt = 11;
Line 1,623 ⟶ 1,695:
InsertData(tmpData[i],source3[i]);
HighestInt(tmpData);
end.</
{{out}}
<pre>9987645434310
Line 1,630 ⟶ 1,702:
=={{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,641 ⟶ 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,662 ⟶ 1,733:
=={{header|PHP}}==
<
usort($nums, function ($x, $y) { return strcmp("$y$x", "$x$y"); });
return implode('', $nums);
Line 1,668 ⟶ 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,680 ⟶ 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,691 ⟶ 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,702 ⟶ 1,912:
=={{header|PL/I}}==
<
/* Largest catenation of integers 16 October 2013 */
/* Sort using method 2, comparing pairs of adjacent integers. */
Line 1,733 ⟶ 1,943:
end largest_integer;
end Largest;
</syntaxhighlight>
<pre>
54 546 548 60
Line 1,745 ⟶ 1,955:
{{works with|PowerShell|2}}
Using algorithm 3
<
{
# Get the length of the largest integer
Line 1,761 ⟶ 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,773 ⟶ 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,782 ⟶ 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,793 ⟶ 2,003:
===Method 2===
<
maplist(name, In, LC),
predsort(my_sort,LC, LCS),
Line 1,828 ⟶ 2,038:
my_sort(R, [H1, H1 | T], [H1]) :-
my_sort(R, [H1 | T], [H1]) .
</syntaxhighlight>
{{out}}
Line 1,842 ⟶ 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,857 ⟶ 2,067:
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,866 ⟶ 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,872 ⟶ 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,883 ⟶ 2,093:
{{works with|Python|2.6+}}
<
from math import log10
Line 1,891 ⟶ 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.
Line 1,907 ⟶ 2,117:
=={{header|Quackery}}==
<
[ 2dup swap join
dip join $< ]
Line 1,915 ⟶ 2,125:
$ '1 34 3 98 9 76 45 4' nest$ largest-int echo$ cr
$ '54 546 548 60' nest$ largest-int echo$</
{{out}}
<pre>
Line 1,922 ⟶ 2,132:
</pre>
<
[ 2dup conc unrot swap conc < ] is conc> ( n n --> b )
Line 1,936 ⟶ 2,146:
[ 54 546 548 60 ] ]
witheach [ task echo cr ] </
{{out}}
Line 1,942 ⟶ 2,152:
<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,951 ⟶ 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"
[~] @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>;</
{{out}}
<pre>998764543431
6054854654</pre>
=={{header|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>
Line 1,984 ⟶ 2,229:
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 = 1 34 3 98 9 76 45 4 /*the 1st integer list to be used. */
@.2 = 54 546 548 60 /* " 2nd " " " " " */
Line 2,005 ⟶ 2,250:
/*──────────────────────────────────────────────────────────────────────────────────────*/
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</
{{out|output|text= when using the default (internal) integer lists:}}
<pre>
Line 2,022 ⟶ 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 = 1 34 3 98 9 76 45 4 /*the 1st integer list to be used. */
@.2 = 54 546 548 60 /* " 2nd " " " " " */
Line 2,050 ⟶ 2,295:
end
if datatype(#, 'W') then return # / 1
er13: say er # "isn't an integer."; exit 13</
{{out|output|text= when using the default (internal) integer lists:}}
Line 2,064 ⟶ 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,119 ⟶ 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,129 ⟶ 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,209 ⟶ 2,454:
list=list w.ww
End
Return space(list,0)</
{{out}}
<pre>1 34 3 98 9 76 45 4 -> 998764543431
Line 2,221 ⟶ 2,466:
=={{header|Ring}}==
<
nums=[1,34,3,98,9,76,45,4]
see largestInt(8) + nl
Line 2,246 ⟶ 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,258 ⟶ 2,528:
{{trans|Tcl}}
<
nums.sort { |x, y| "#{y}#{x}" <=> "#{x}#{y}" }
end
Line 2,265 ⟶ 2,535:
p c # prints nicer in Ruby 1.8
puts icsort(c).join
end</
{{out}}
Line 2,275 ⟶ 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,283 ⟶ 2,553:
p c # prints nicer in Ruby 1.8
puts icsort(c).join
end</
;Output as above.
<
def icsort nums
Line 2,296 ⟶ 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,329 ⟶ 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,335 ⟶ 2,605:
=={{header|Rust}}==
<
a.sort_by(|x, y| {
let xy = format!("{}{}", x, y);
Line 2,350 ⟶ 2,620:
maxcat(&mut [1, 34, 3, 98, 9, 76, 45, 4]);
maxcat(&mut [54, 546, 548, 60]);
}</
{{out}}
<pre>998764543431
Line 2,356 ⟶ 2,626:
=={{header|S-lang}}==
<
{
a = string(a);
Line 2,374 ⟶ 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,382 ⟶ 2,652:
=={{header|Scala}}==
{{libheader|Scala}}
<
def lifci(list: List[Long]) = list.permutations.map(_.mkString).max
Line 2,388 ⟶ 2,658:
println(lifci(List(1, 34, 3, 98, 9, 76, 45, 4)))
println(lifci(List(54, 546, 548, 60)))
}</
{{out}}
Line 2,397 ⟶ 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,410 ⟶ 2,680:
=={{header|Sidef}}==
{{trans|Ruby}}
<
nums.sort {|x,y| "#{y}#{x}" <=> "#{x}#{y}" };
}
Line 2,416 ⟶ 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,426 ⟶ 2,696:
Version 1) sort by padded print strings:
{{works with|Smalltalk/X}}
<
(54 546 548 60)
(1 34 3 98 9 76 45 4)
Line 2,441 ⟶ 2,711:
collect:#printString) asStringWith:''.
Stdout printCR: resultString.
].</
Version 2) alternative: sort by concatenated pair's strings:
<
(54 546 548 60)
(1 34 3 98 9 76 45 4)
Line 2,453 ⟶ 2,723:
collect:#printString) asStringWith:''.
Stdout printCR: resultString.
].</
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):
<
(54 546 548 60)
(1 34 3 98 9 76 45 4)
Line 2,464 ⟶ 2,734:
do:[:eachNr | eachNr printOn:Stdout].
Stdout cr.
]</
Version 4) no need to generate any intermediate strings; the following will do as well:
<
(54 546 548 60)
(1 34 3 98 9 76 45 4)
Line 2,473 ⟶ 2,743:
(ints copy sortByApplying:[:i | i log10 fractionPart]) reverseDo:#print.
Stdout cr.
]</
{{out}}
<pre>6054854654
Line 2,479 ⟶ 2,749:
=={{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,489 ⟶ 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|VBScript}}==
{{trans|BBC BASIC}}
<syntaxhighlight lang="vb">
Function largestint(list)
nums = Split(list,",")
Line 2,523 ⟶ 2,809:
WScript.StdOut.Write largestint(WScript.Arguments(0))
WScript.StdOut.WriteLine
</syntaxhighlight>
{{Out}}
Line 2,536 ⟶ 2,822:
=={{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}}
<
var cmp = Fn.new { |x, y|
Line 2,567 ⟶ 2,853:
for (a in arrays) {
System.print("%(a) -> %(findLargestSequence.call(a))")
}</
{{out}}
Line 2,576 ⟶ 2,862:
=={{header|zkl}}==
<
ns.apply("toString").sort(fcn(a,b){ (a+b)>(b+a) }).concat();
}</
<
bigCI(T(54, 546, 548, 60)).println();</
{{out}}
<pre>
| |||