# 算法题：如何排列给定数字以形成最大数？|S1

## C ++

// Given an array of numbers, // program to arrange the numbers
// to form the largest number
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;

// A comparison function which
// is used by sort() in
// printLargest()
int myCompare(string X, string Y)
{
// first append Y at the end of X
string XY = X.append(Y);

// then append X at the end of Y
string YX = Y.append(X);

// Now see which of the two
// formed numbers is greater
return XY.compare(YX) > 0 ? 1 : 0;
}

// The main function that prints
// the arrangement with the
// largest value. The function
// accepts a vector of strings
void printLargest(vector<string> arr)
{

// Sort the numbers using
// library sort function. The
// function uses our comparison
// function myCompare() to
// compare two strings. See
// http://www.cplusplus.com/reference/
// algorithm/sort/
// for details
sort(arr.begin(), arr.end(), myCompare);

for ( int i = 0; i < arr.size(); i++)
cout << arr[i];
}

// Driver program to test above functions
int main()
{
vector<string> arr;

// output should be 6054854654
arr.push_back( "54" );
arr.push_back( "546" );
arr.push_back( "548" );
arr.push_back( "60" );
printLargest(arr);

return 0;
}

## Java

// Given an array of numbers, program to
// arrange the numbers to form the
// largest number
import java.util.*;

class GFG {

// The main function that prints the
// arrangement with the largest value.
// The function accepts a vector of strings
static void printLargest(Vector<String> arr)
{

Collections.sort(arr, new
Comparator<String>(){

// A comparison function which is used by
// sort() in printLargest()
@Override
public int compare(String X, String Y) {

// first append Y at the end of X
String XY=X + Y;

// then append X at the end of Y
String YX=Y + X;

// Now see which of the two
// formed numbers
// is greater
return XY.compareTo(YX) > 0 ? - 1 : 1 ;
}
});

Iterator it = arr.iterator();

while (it.hasNext())
System.out.print(it.next());

}

// driver program
public static void main (String[] args)
{

Vector<String> arr;
arr = new Vector<>();

//output should be 6054854654
printLargest(arr);
}
}
// This code is contributed by Shubham Juneja

## Python3

# Python3 Program to get the maximum
# possible integer from given array
# of integers...

# custom comparator to sort according
# to the ab, ba as mentioned in description
def comparator(a, b):
ab = str (a) + str (b)
ba = str (b) + str (a)
return (( int (ba) > int (ab)) -
( int (ba) < int (ab)))

def myCompare(mycmp):

# Convert a cmp= function into a key= function
class K( object ):
def __init__( self , obj, * args):
self .obj = obj
def __lt__( self , other):
return mycmp( self .obj, other.obj) < 0
def __gt__( self , other):
return mycmp( self .obj, other.obj) > 0
def __eq__( self , other):
return mycmp( self .obj, other.obj) = = 0
def __le__( self , other):
return mycmp( self .obj, other.obj) < = 0
def __ge__( self , other):
return mycmp( self .obj, other.obj) > = 0
def __ne__( self , other):
return mycmp( self .obj, other.obj) ! = 0
return K
# driver code
if __name__ = = "__main__" :
a = [ 54 , 546 , 548 , 60 , ]
sorted_array = sorted (a, key = myCompare(comparator))
number = "".join([ str (i) for i in sorted_array])
print (number)

# This code is Contributed by SaurabhTewary

## C#

// C# program for above approach
using System.Collections.Generic;
using System;

namespace LargestNumberClass
{
class LargestNumberClass
{
//Given a list of non-negative
// integers, //arrange them such that they
// form the largest number.
//Note: The result may be very
// large, so you need to
// of an integer.
public static void LargestNumberMethod(
List< int > inputList)
{
string output = string .Empty;

List< string > newList = inputList.
ConvertAll< string >
( delegate ( int i) { return i.ToString(); });

newList.Sort(MyCompare);

for ( int i = 0; i < inputList.Count; i++)
{
output = output + newList[i];
}

if (output[0] == '0' && output.Length > 1)
{
Console.Write( "0" );
}
Console.Write(output);
}

internal static int MyCompare( string X, string Y)
{
// first append Y at the end of X
string XY = X + Y;

// then append X at the end of Y
string YX = Y + X;

// Now see which of the two
// formed numbers is greater
return XY.CompareTo(YX) > 0 ? -1 : 1;
}
}

class Program
{
static void Main( string [] args)
{
List< int > inputList = new List< int >()
{ 54, 546, 548, 60 };
LargestNumberClass.LargestNumberMethod(
inputList);
}
}
// This code is contributed by Deepak Kumar Singh
}

## 的PHP

<?php
// Given an array of numbers, program
// to arrange the numbers to form the
// largest number

// A comparison function which is used
// by sort() in printLargest()
function myCompare( \$X , \$Y )
{
// first append Y at the end of X
\$XY = \$Y . \$X ;

// then append X at the end of Y
\$YX = \$X . \$Y ;

// Now see which of the two formed
// numbers is greater
return strcmp ( \$XY , \$YX ) > 0 ? 1: 0;
}

// The main function that prints the
// arrangement with the largest value.
// The function accepts a vector of strings
function printLargest( \$arr )
{
// Sort the numbers using library sort
// function. The function uses our
// comparison function myCompare() to
// compare two strings.
// See http://www.cplusplus.com/reference/
// algorithm/sort/
// for details
usort( \$arr , "myCompare" );

for ( \$i = 0; \$i < count ( \$arr ) ; \$i ++ )
echo \$arr [ \$i ];
}

// Driver Code
\$arr = array ( "54" , "546" , "548" , "60" );
printLargest( \$arr );

// This code is contributed by
// rathbhupendra
?>

6054854654

## Python3

# Python3 implementation this is to use itertools.
# permutations as coded below:

from itertools import permutations
def largest(l):
lst = []
for i in permutations(l, len (l)):
# provides all permutations of the list values, # store them in list to find max
lst.append("".join( map ( str , i)))
return max (lst)

print (largest([ 54 , 546 , 548 , 60 ])) #Output 6054854654

# This code is contributed by Raman Monga

6054854654

## C ++

// C++ approach for the above approach
#include <bits/stdc++.h>
using namespace std;

// The main function that prints the
// arrangement with the largest value.
// The function accepts a vector of strings
void printLargest(vector<string> arr)
{
sort(arr.begin(), arr.end());
for ( int i = arr.size() - 1; i >= 0; i--)
cout << arr[i];
}

// Driver code
int main()
{
vector<string> arr;

// Output should be 6054854654
arr.push_back( "54" );
arr.push_back( "546" );
arr.push_back( "548" );
arr.push_back( "60" );
printLargest(arr);
}

// This code is contributed by gauravrajput1

## Java

// Java approach for the above approach
import java.util.*;

class GFG
{

// The main function that prints the
// arrangement with the largest value.
// The function accepts a vector of strings
static void printLargest(Vector<String> arr)
{

Collections.sort(arr, Collections.
reverseOrder());
Iterator it = arr.iterator();

while (it.hasNext())
System.out.print(it.next());
}

// Driver program
public static void main(String[] args)
{

Vector<String> arr;
arr = new Vector<>();

// output should be 6054854654
printLargest(arr);
}
}

## Python3

# Python3 approach for the
# above approach

# The main function that
# prints the arrangement
# with the largest value.
# The function accepts a
# vector of strings
def printLargest(arr):

arr.sort(reverse = True )
number = "".join([ str (i) for i in arr])
print (number)

# Driver code
if __name__ = = '__main__' :

arr = [ "54" , "546" , "548" , "60" ];

# Output should be 6054854654
printLargest(arr);

# This code is contributed by gauravrajput1

## C#

// C# approach for
// the above approach
using System;
using System.Collections.Generic;
class GFG{

// The main function that prints the
// arrangement with the largest value.
// The function accepts a vector of strings
static void printLargest(List<String> arr)
{
arr.Sort();
arr.Reverse();

foreach (String str in arr)
Console.Write(str);
}

// Driver code
public static void Main(String[] args)
{
List<String> arr;
arr = new List<String>();

printLargest(arr);
}
}

// This code is contributed by Rajput-Ji

6054854654

• 回顶