def largestnumber(ns):
    ns = map(str,ns)
    ns.sort(cmp=lambda x,y:cmp(x+y,y+x),reverse=True)
    return ''.join(ns)
print largestnumber([3,30,34,5,9])

[3, 30, 34, 5, 9] => sort_key = ['33', '30', '34', '55', '99'] [123, 4956, 1, 40] => sort_key = ['1233', '4956', '1111', '4000']

>>> def make_largest_number(l):
...     numbers = map(str, l)
...     max_length = len(max(numbers, key=len))  # max에 key 사용가능
...     sort_key = lambda x: x + x[-1] * (max_length - len(x))
...     return int("".join(sorted(numbers, key=sort_key, reverse=True)))
>>> l = [3, 30, 34, 5, 9]
>>> make_largest_number(l)
9534330
>>> l = [123, 4956, 1, 40]
>>> make_largest_number(l)
4956401231

from random import shuffle


def largest(L):
    """
    Return the largest int that can be made from L.

    @type L: list[int]
    @rtype: int

    >>> largest([1, 2, 3])
    321
    >>> largest([3, 30, 34, 5, 9])
    9534330
    """

    i = 0
    ass = 0
    while i != 10000:
        temporary_value = "".join(str(x) for x in L)
        if int(temporary_value) >= int(ass):
            ass = int(temporary_value)
        shuffle(L)
        i += 1

    return ass

미적분 시험이 있는 저의 멘붕상태를 코드로 표현했습니다.

숫자를 스트링으로 만들고 우선순위를 이용하여 정렬하였습니다.

서로 다른 자리의 수를 비교하기 위해 자리수를 맞추고, 남는 부분을 첫째 짜리 숫자로 채웠습니다.

def largest_number(nums):
    nums_str = [str(x) for x in nums]
    longest = max(len(x) for x in nums_str)
    nums_str.sort(reverse=True,
                  key= lambda x: ('{0:'+str(x[0])+'<'+str(longest)+'}').format(x))
    return ''.join(nums_str)

if __name__ == '__main__':
    print(largest_number([3, 30, 34, 5, 9]))

Ruby

# join결과로 역정렬
m_sort = ->nums { nums.sort{|x,y|[y,x].join<=>[x,y].join}.join.to_i }

# 개선 : join 줄이기
p nums.sort{|x,y|[y,x]*''<=>[x,y]*''}*'' #=> "9534330"

Test

nums = [3,30,34,5,9]
expect(m_sort[nums]).to eq 9534330

python 3.5

def make_largest_number(number_list):
    digit_list = []
    result = ''
    for num in number_list:
        if len(str(num)) > 1:
            for x in str(num):
                digit_list.append(int(x))
        else:
            digit_list.append(num)
    digit_list.sort()
    digit_list.reverse()
    for digit in digit_list:
        result += str(digit)
    return int(result)


print(make_largest_number([1,2,3]))
print(make_largest_number([3, 30, 34, 5, 9]))

5, 56, 54, 1200, 12 등등의 수가 같이 있는 경우를 고려해보니, 생각보다 까다로운 문제라는 것을 느끼게 되네요. 테스트해본 바로는 모든 숫자에 상관없이 정답이 잘 출력됩니다.

import java.util.Arrays;
import java.util.Scanner;

public class BigNum {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String input = sc.nextLine();
        String[] temp = input.split(" ");
        Arrays.sort(temp);
        String an = "";
        for (int i = temp.length - 1; i > -1; i--)
            an += i - 1 > -1 && temp[i].startsWith(temp[i - 1])
                    && Integer.valueOf(temp[i - 1]) > Integer
                            .valueOf(temp[i].substring(temp[i].length() - temp[i - 1].length()))
                                    ? temp[i - 1] + temp[i--]
                                    : temp[i];
        System.out.println(an);
    }
}

from functools import reduce
reduce(lambda x, y : max(x+y, y+x), sorted(['5', '56', '54', '1200', '12']))

결과

'56545121200'

상파님의 코드를 보고 작성했습니다.

Tcl/tk 입니다. sort를 쓰지말라는 말이 없어서 sort로 해봅니다.

set num [ list 3 30 34 5 9 ]
puts [ join [ lsort -integer -decreasing $num ] "" ]

var array = [ 57, 589, 51, 5, 10, 20, 30, 44, 509, 5001, 32, 31, 6, 19, 1234 ]

    array.sortInPlace { (obj1, obj2) -> Bool in

        let s1 = String.init(format: "%d", obj1)
        let s2 = String.init(format: "%d", obj2)

        let strlen1 = s1.lengthOfBytesUsingEncoding(NSUTF8StringEncoding)
        let strlen2 = s2.lengthOfBytesUsingEncoding(NSUTF8StringEncoding)

        let mmax = max(strlen1, strlen2)
        let mmin = min(strlen1, strlen2)

        let lastNum1 = obj1 % 10
        let lastNum2 = obj2 % 10

        var num1 = obj1
        var num2 = obj2

        let diff = mmax - mmin
        for(var i = 0; i<diff; ++i) {

            if(strlen1 > strlen2)
            {
                num2 = num2 * 10 + lastNum2
            }
            else
            {
                num1 = num1 * 10 + lastNum1
            }

        }

        return num1 > num2
    }

    print(array) // [6, 589, 57, 5, 51, 509, 5001, 44, 32, 31, 30, 20, 19, 1234, 10]

from math import *

while __name__ == '__main__':
    li = list(map(int, input("\n수 입력: ").split()))
    순서, 자릿수, 정렬_후 = ([],[],[])
    for i in li:
        자릿수.append(log10(i))
    자릿수 = int(max(자릿수))
    비교_리스트 = []
    for i in range(len(li)):
        비교_리스트.append(li[i]*10**int(자릿수- int(log10(li[i]))))

    정렬_리스트 = list(비교_리스트)
    정렬_리스트.sort()
    for i in range(len(정렬_리스트)):
        순서.append(비교_리스트.index(정렬_리스트.pop()))
    for i in range(len(li)):
        정렬_후.append(li[순서[i]])

    for i in list(map(str, 정렬_후)):
        print(i, end='')

파이썬 3.5.1

def input_numbers():
    list=[]
    while True:
        number = input("Input number : ")
        if(number<0) :
            break
        list.append(number)
    return list

def largest_number(list):
    result=""
    for i in range(0, len(list)):
        for j in range(0, len(list)-1-i):
            ltr = str(list[j])+str(list[j+1])
            rtl = str(list[j+1])+str(list[j])
            if(ltr<rtl):
                tmp=list[j]
                list[j]=list[j+1]
                list[j+1]=tmp

    for i in list:
        result+=str(i)

    print(result)


largest_number(input_numbers())

082님께서 지적해주셨는데, 30, 31, 32 는 3보다 실질적으로 작다고 평가되어야 하네요. 파이썬3부터는 sorted 함수에 임의의 비교 함수를 쓸 수가 없어서 정렬함수를 새로 만들었습니다.

def do(numbers):
    def mySort(xs):
        if len(xs) < 1:
            return xs
        p = xs[0]
        l = [x for x in xs[1:] if x+p > p+x]
        r = [x for x in xs[1:] if x+p <= p+x]
        return mySort(l) + [p] + mySort(r)
    return int(''.join(mySort([str(x) for x in numbers])))

print(do([3, 30, 34, 5, 9]))
#9534330

파이썬3.4입니다. 파이썬스럽지는 않네요...

def f(li):
    '''
    버블소트
    '''
    test1, test2, = '', ''
    for i in range(len(li) - 2, -1, -1):
        flag = 0
        for j in range(i + 1):
            flag = 1
            test1 = int(str(li[j]) + str(li[j + 1]))
            test2 = int(str(li[j + 1]) + str(li[j]))
            if test1 < test2:
                (li[j], li[j + 1]) = (li[j + 1], li[j])
        if flag == 0:
            return li
    return li
li = [9, 3, 30, 34, 5, 30, 3001]
print(li)
print(f(li))

def largestnumber(arr)
  temp=0
  ar=[]
  for i in arr
    if i < 0
      puts('array has negative number')
      return
    end
  end
  for i in arr.permutation.to_a
    tex=''
    for j in i
      tex+=j.to_s
    end
    ar << tex.to_i
  end
  for i in ar
    if i > temp
      temp=i
    end
  end
  return temp
end

puts largestnumber [3,20,1,5,1,6,9,12,41]

list = [3,30,34,5,9]
a = [] # 뽑아낸수저장 장소
for i in range(len(list)):
    b = str(list[i])
    for j in range(len(b)):
        a.append(b[j])

c = int(''.join(map(str,sorted(a, reverse=True))))
# c=''.join(c)
# c=int(c)
print(c)

Python3.4.4

import functools

data = [3, 30, 34, 5, 9]

def largestSort(ns):
    ns = list(map(str, ns))
    ns.sort(key=functools.cmp_to_key(lambda x,y: int(x+y)-int(y+x)), reverse=True)
    return ''.join(ns)

print(largestSort(data))

java 8으로 작성했습니다.

    public int randomInt(int min, int max) {
        return (int) ((Math.random() * (max - min)) + min);
    }

    @Test
    public void 가장큰수만들기() {
        List<Integer> ran = Lists.newCopyOnWriteArrayList();
        IntStream.range(0, 10).forEach(x->{
            IntStream.range(0, randomInt(1, 10)).forEach(k->ran.add(randomInt(0, 100)));
            logger.debug("{} > {}", ran.toArray(), makeBigNumber(ran));
            ran.clear();
        });


        List<Integer> test = Lists.newArrayList(3,30,34,5,9);
        logger.debug("예 : {} > {}", test.toArray(), makeBigNumber(test));
    }

    private String makeBigNumber(List<Integer> ran) {
        StringBuilder stringBuilder = new StringBuilder();
        ran.stream().sorted((o1, o2) -> o2-o1).forEach(k->ran.stream().max((o1, o2) -> Integer.valueOf(String.valueOf(o1).substring(0, 1)) - Integer.valueOf(String.valueOf(o2).substring(0, 1))).ifPresent(x->{
            ran.remove(x);
            stringBuilder.append(x);
        }));
        return stringBuilder.toString();
    }

결과 13:19:33.380 [main] DEBUG com.brandon.CodeTest10 - [55, 14, 45, 4, 88, 18] > 88554541418 13:19:33.385 [main] DEBUG com.brandon.CodeTest10 - [45, 40, 64, 75] > 75644540 13:19:33.385 [main] DEBUG com.brandon.CodeTest10 - [9, 62, 89] > 98962 13:19:33.385 [main] DEBUG com.brandon.CodeTest10 - [83, 6, 90, 3] > 908363 13:19:33.386 [main] DEBUG com.brandon.CodeTest10 - [18, 98, 83, 63, 83, 77, 46] > 98838377634618 13:19:33.386 [main] DEBUG com.brandon.CodeTest10 - [82, 98, 12, 30, 41, 53, 44, 70, 81] > 988281705341443012 13:19:33.386 [main] DEBUG com.brandon.CodeTest10 - [89, 32] > 8932 13:19:33.386 [main] DEBUG com.brandon.CodeTest10 - [36, 60, 37] > 603637 13:19:33.386 [main] DEBUG com.brandon.CodeTest10 - [67, 94, 73, 57, 5, 77, 93] > 9493737767575 13:19:33.387 [main] DEBUG com.brandon.CodeTest10 - [31, 85, 55, 18, 75, 58, 39] > 85755558313918 13:19:33.390 [main] DEBUG com.brandon.CodeTest10 - 예 : [3, 30, 34, 5, 9] > 9533034

PHP로 가장 큰값이 배열의 제일 앞으로 오도록 구성 해봤습니다.

<?php
$nums =  [3, 30, 34, 5, 9];
echo largestNumber($nums)."\n";

function largestNumber($nums)
{
    $cnt = count($nums);
    for ($i=0; $i < $cnt; $i++) {
        for ($j=$i+1; $j < $cnt; $j++) {
            $str1 = $nums[$i].$nums[$j];
            $str2 = $nums[$j].$nums[$i];
            if($str1 < $str2){
                $tmp = $nums[$j];
                $nums[$j] = $nums[$i];
                $nums[$i] = $tmp;
            }
        }
    }
    $str = '';
    foreach ($nums as $key => $val) {
        $str.=$val;
    }
    return $str;
}
exit;

9534330

파이썬 3입니다

import random
lst = random.sample(range(1000), 5)
print(lst)
def largest(b):
    a = ''
    List = []
    for i in b:
        a = a + str(i)
    for i in a:
        List.append(i)
    l = sorted(List)
    l.reverse()
    for i in l:
        print(i, end = '')

largest(lst)

String returnLargestNum(int[] arry) {
  String largeNum = "";
  for(int i = 0; i < arry.length; i++) {
    for(int j = i; j < arry.length; j++) {
      int preFirstNum = Integer.parseInt((arry[i]+"").charAt(0)+"");  // i 번째 첫번째 자리 수
      int nextFirstNum = Integer.parseInt((arry[j]+"").charAt(0)+""); // j 번째 첫번째 자리 수

      // 현재수 보다 다음수가 더 클시 치환
      // 현재수와 다음수의 첫번째 수가 동일할시 값이 큰 수
      if( (preFirstNum  <  nextFirstNum)
        || (preFirstNum == nextFirstNum && arry[i] < arry[j]) ) {
        int temp = arry[i];
        arry[i] = arry[j];
        arry[j] = temp; 
      }
    }
  }
  for(int i = 0; i < arry.length; i++) {
    largeNum += arry[i]+"";
  }
  return largeNum;
}

int[] arry = {1, 2, 253, 53, 92};
System.out.println( returnLargestNum(arry) );

java 8

answer : 925325321

두 수 중 먼저 올 수를 반환하는 maxi함수를 정의한 후, maxi함수의 기준대로 정렬하였습니다.

def maxi(n1, n2):
    '''두 수 중 먼저올 수를 반환함.'''
    a=int(str(n1)+str(n2))
    b=int(str(n2)+str(n1))
    if a>b:
        return n1
    elif a==b:
        return 'same'
    else:
        return n2

n=eval(input('음수 아닌 수의 리스트를 입력하시오 : '))
#[1, 2, 3]

i=0
while i!=len(n)-1:
    if maxi(n[i], n[i+1])=='same':
        i+=1
    elif maxi(n[i], n[i+1])==n[i+1]:
        n[i], n[i+1]=n[i+1], n[i]
        i=0
    else:
        i+=1

result=''
for i in range(len(n)): result+=str(n[i])
result=int(result)
print(result)

public class lv2_13 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] num = {1,222,30};
        lv2_13 lv = new lv2_13();
        lv.num(num);
    }
    public void num(int[] n){
        int num=0;
        String n1="";
        for(int i = 0; i<n.length;i++){
            for(int j = 0; j<n.length;j++){
                if(n[i]>n[j]){
                    num = n[i];
                    n[i] = n[j];
                    n[j] = num;
                }
            }
        }
        for(int i = 0 ; i< n.length;i++)    n1 = n1+n[i]+"";
        System.out.println(n1);
    }
}

# def_name = highest, input = list of the number, ouput = the highest number made by the number given, the type of the output = integer
# [what I need]
# how to make the highest number... at any condition, put the highest number in the first place.

def hightest(list):
    perfect_list = []
    for i in list:
        if len(str(i)) == 1:
            perfect_list.append(str(i))
        else:
            for p in str(i):
                perfect_list.append(p)
    #print perfect_list
    result = []
    order = 0
    print perfect_list
    while len(perfect_list) > 0:
        result.append(max(perfect_list))
        perfect_list.remove(max(perfect_list))
    result_finally = ''
    for i in result:
        result_finally += str(i)
    return result_finally


print hightest([1,2,3])
print hightest([3, 30, 34, 5, 9])

댓글 풀이에 있는 Java code를 수정해서 만들었습니다. 30,3 케이스를 만족시키지 못하는 것 같습니다.

혹시 제가 틀렸으면 댓글 부탁드립니다.

public static String makeLargeNumber(String[] list){

        String largeNum = "";
        for(int i = 0; i < list.length; i++) {
            for(int j = i; j < list.length; j++) {
                int preFirstNum = Integer.parseInt((list[i]).charAt(0)+""); 
                int nextFirstNum = Integer.parseInt((list[j]).charAt(0)+"");

                int result = Integer.parseInt(list[i]+list[j]) - Integer.parseInt(list[j]+list[i]);

                if( (preFirstNum  <  nextFirstNum)
                    || (preFirstNum == nextFirstNum && result < 0) ) {
                    String temp = list[i];
                    list[i] = list[j];
                    list[j] = temp; 
              }
            }
        }

        for(String s : list)
            largeNum+=s;


        return largeNum;
    }

import functools
def max_(list_):
    return int(''.join(
        sorted([str(x) for x in list_]
               , key=functools.cmp_to_key(lambda x, y:int(x+y) - int(y+x))
               , reverse=True))
        )
print(max_([3,30,34,5,9]))

Python 3.5.2에서 작성하였습니다.
처음엔 마지막 숫자로 자릿수를 맞춰서 해봤다가 다른분 풀이를 보고 문제가 있는걸 알아서 다시 작성합니다.

상파님의 아이디어를 Haskell로 옮겨보았습니다.

solve input = read $ concat $ sortBy f $ map show input
         where f b a = (a ++ b) `compare` (b ++ a)

C(11) : gcc v4.9.4

//79COLUMNS////////////////////////////////////////////////////////////////////
// 가장 큰 수 만들기
// [3, 30, 34, 5, 9] => 9534330
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

typedef struct pair
// first=3, second=30 일때, 
{
    int first_second; // 330
    int second_first; // 303
} Pair;

// 숫자를 이어 붙여 구조체로 리턴한다
static Pair _concat(int first, int second);
// 이어붙인 숫자의 순서를  판단한다
static int comp(const void *first, const void *second);

int main(void)
{
    int example[5] = {3, 30, 34, 5, 9};
    qsort(example, 5, sizeof (int), comp);

    for (int i=0; i<5; i++) printf("%d", example[i]);
    putchar('\n');
    return 0;
}

static Pair _concat(int first, int second)
//3, 30 => 330, 303
{
    int first_second = first * (int)pow(10, (int)log10(second) + 1) + second;
    int second_first = second * (int)pow(10, (int)log10(first) + 1) + first;
    return (Pair){first_second, second_first};
} 

static int comp(const void *first, const void *second)
{
    Pair look = _concat(*(int *)first, *(int *)second);
    int first_second = look.first_second;
    int second_first = look.second_first;

    if (first_second < second_first)
        return 1;
    else if (second_first < first_second)
        return -1;
    else
        return 0;
} 

#python 2.7
#한줄로 만들어 보았습니다 
arr =  [3,30,34,5,9,94]
print "".join(sorted(map(str,arr),cmp=lambda x,y : cmp(x+y,y+x),reverse=True))

nums = sorted([x for x in input().split(' ') if int(x) > 0],reverse=True)

for x in range(len(nums)-1):
    if len(nums[x]) > len(nums[x+1]) and len(nums[x+1]) == 1 and\
       nums[x][0] == nums[x+1][0] and int(nums[x][1]) < int(nums[x+1]):
        nums.insert(x+1,nums.pop(x))
print(''.join(nums))

#### 2016.12.31 D-418 ####

생각보다 잘안되네요..

$input = "1,2,3";
$array = explode(",",$input);
$temp = array();

foreach($array as $num){
    if(count($temp) == 0){
        array_push($temp,$num);
        continue;
    }
    if(substr($temp[count($temp)-1],0,1) > substr($num,0,1)){
        array_push($temp,$num);
    }else if(substr($temp[count($temp)-1],0,1) < substr($num,0,1)){
        array_unshift($temp,$num);
    }else{
         if(strlen($temp[count($temp)-1]) < strlen($num)){
            array_push($temp,$num);
         }else{
            array_unshift($temp,$num);
         }
    }

}
echo join("",$temp);

def big_number(data):
    dic_data={x/(10**(len(str(x))-1))+10000**(-len(str(x))):x for x in data}
    result=[dic_data[x] for x in sorted(dic_data.keys(), reverse=True)]
    ret=""
    for i in result:
        ret+=str(i)
    return ret

big_number([3, 30, 34, 5, 9])

import java.util.*;
import java.util.stream.Collectors;

public class CreateTheLargestNumber {

    static List<Integer> numbers = new ArrayList<>();

    public static void main(String[] args) {
        String[] strings = new Scanner(System.in).next().split(",");
        factorial(strings, strings.length, 0);
        System.out.println(numbers.stream().max(Comparator.comparing(Integer::intValue)).get());
    }

    public static void factorial(String[] strings, int n, int d) {
        if (n == d) {
            numbers.add(Integer.valueOf(Arrays.asList(strings).stream().collect(Collectors.joining())));
            return;
        }

        for (int i = d; i < n; i++) {
            swap(strings, i, d);
            factorial(strings, n, d + 1);
            swap(strings, i, d);
        }
    }

    public static void swap(String[] strings, int i, int d) {
        String temp = strings[i];
        strings[i] = strings[d];
        strings[d] = temp;
    }
}

python 3.6 '상파'님 알고리즘를 한줄로 하면...

from functools import cmp_to_key as cmp

print("".join(sorted(map(str,[3,30,34,5,9]),key=cmp(lambda x,y:int(x+y)-int(y+x)),reverse=True)))

import math
import random
import copy
nums = ['3', '30', '34', '5', '9']
# length = int(input("입력할 숫자 갯수 : "))
# nums = [str(input("{0}번째 숫자 : ".format(i)) for i in range(length)]
permu = [0 for i in range(math.factorial(len(nums))-1)]
results = list()
i = 0
while permu[-1] == 0:
    random.shuffle(nums)
    if nums not in permu:
        permu[i] = copy.deepcopy(nums)
        i += 1
print(permu)
for i in range(len(permu)):
    results.append(int(''.join(permu[i])))
print(max(results))

되게 난잡하네요;

nums = ['3', '30', '34', '5', '9']를 지우고

주석 부분을 코드로 쓰면 입력을 받을 수 있습니다.

javascript

자바스크립트 프로토타입으로 Array 객체의 함수로 쓸 수 있도록 해봤습니다.

ES6 부터는 숫자 두 개를 스트링처럼 concat 하는 "" + a + b 를 `${a}${b}`로도 쓸 수 있네요.

Array.prototype.arrange = function () {
    return this.sort((a, b) => `${a}${b}` - `${b}${a}`).reverse().join("");
}

console.log([3, 30, 34, 5, 9].arrange());
console.log([1,2,3].arrange());

Python 3로 풀었습니다. 정렬과정에서 문자열 비교를 합니다. (x + y 와 y + x 간의 비교) 문자열 비교를 위해 functools.cmp_to_key() 함수를 사용했습니다.

import functools
def max_num(items):
    def compare(x, y):
        return 1 if x + y < y + x else -1
    items = [str(x) for x in items]
    items.sort(key=functools.cmp_to_key(compare))
    return ''.join(items)

Python: brute-force

def largest(lst, s):
    if not lst:
        return s

    res = []
    for i in range(len(lst)):
        res.append(largest(lst[:i]+lst[i+1:], s+str(lst[i])))

    return max(map(int, res))


print(largest([3, 30, 34, 5, 9], '')) # 9534330

C#: bubble sort (컨닝)

using System.Linq;
using static System.Console;

class LargestNumber
{
    static void Main(string[] args)
    {
        int[] input = new int[] { 3, 30, 34, 5, 9 };        
        string[] arr = (from n in input select n.ToString()).ToArray(); // select절 리턴 타입은 IEnumerable<>

        for (int last = arr.Length-1; last >= 0; last--)
        {
            for(int j = 0; j <= last - 1; j++)
            {                
                if ((arr[j]+arr[j+1]).CompareTo(arr[j+1]+arr[j]) < 0)
                {
                    string tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                }
            }
        }

        foreach (string s in arr)
            Write(s);
    }
}

논술형으로 풀이 작성합니다.

먼저, 프로그램 알고리즘으로 각 수들의 리스트에서 첫 자리가 가장 큰 수부터 차례대로 배열합니다. 만약 첫자리가 똑같을 경우, 그 다음 자리의 수의 대소를 비교합니다. 대소 확인이 되었을 경우, 수들을 있습니다(각 수들의 자릿수와 개수를 받아 각 수들에 10^n씩 곱해줍니다).

C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int charToInt(char c);
int main(int argc,char* argv[])
{
    char* str = (char*)malloc(sizeof(char)*128);
    gets(str);
    int arr[10];
    int cnt=0;
    memset(arr,0,10);
    char* substr;
    substr = strtok(str," ");
    while(substr != NULL)
    {
        arr[cnt] = atoi(substr);
        substr = strtok(NULL, " ");
        cnt++;
    }
    int tmp = 0;
    int max = arr[0];
    for(int k=0;k<cnt;k++)
    {
        for(int i=0;i<cnt-1;i++)
        {
            if(arr[i]<arr[i+1])
            {
                max = arr[i+1];
                tmp = arr[i+1];
                arr[i+1] = arr[i];
                arr[i] = tmp;
            }

        }

    }

    for(int i=0;i<cnt;i++)
        printf("%d",arr[i]);

    return 0;
}
int charToInt(char c)
{
    return (int)c - 48;
}

def largestize(N) :  # type(N) == list

    for n in N :
        s = str(n)
        if len(s) >= 2 :
            s = s[0] + '.' + s[1:]
            n = float(s)

        else :
            n = int(s)

    N.sort()
    N.reverse()
    result = []

    for p in N :
        strlistp = list(str(p))
        if '.' in strlistp :
            strlistp.remove('.')
            result.append(''.join(strlistp))

        else :
            result.append(str(p))

    return ''.join(result)

모든 수를 소수점으로 표현한 후 크기 비교를 하는 방법을 사용했습니다.

namespace _20170907
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] a = new int []{ 5, 6, 90, 2, 1, 77 };
            Array.Sort(a);
            Array.Reverse(a);
            foreach (int i in a)
            {

                Console.Write(i);
            }
        }
    }
}

# python 3.6
import itertools as it

inp = [3, 30, 34, 5, 9]

pool = it.permutations(inp, len(inp))  # 비중복 순열 제너레이터 생성
rpt = True
max_val = 0
while rpt:
    try:
        lst = next(pool)
    except StopIteration:
        rpt = False
    else:
        max_val = max(max_val, int("".join(map(str, lst))))

print(max_val)
# ans: 9534330

inp = input('input numbers: ').split()

for i in range(len(inp)):
    for j in range(i+1, len(inp)):
        if int(inp[i]+inp[j]) < int(inp[j]+inp[i]):
            inp[i], inp[j] = inp[j], inp[i]

print(''.join(inp))

const predicate = (a, b) => {
  return `${a}${b}` < `${b}${a}`;
};

const largestNumber = arr => {
  return +arr.sort(predicate).join('');
};

console.log(largestNumber([3, 30, 34, 5, 9]));
console.log(largestNumber([1, 2, 3]));
console.log(largestNumber([100, 252, 3, 8, 99, 9000]));

def maxn(a):
    r=[]
    for i in a:
        r.append(str(i))
    for j in range(1,len(r)):
        while True:
            if j>=1 and int(r[j][0])>int(r[j-1][0]):
                r[j],r[j-1]=r[j-1],r[j]
                j=j-1
            elif j>=1 and int(r[j][0])==int(r[j-1][0]) and int(r[j]+r[j-1])>int(r[j-1]+r[j]):
                r[j],r[j-1]=r[j-1],r[j]
                j=j-1 
            else:break
    print(int(''.join(r)))

def largest(a):
    if len(a) ==1:
        return a[0]
    elif len(a) == 2:
        return max(int(str(a[0])+str(a[1])), int(str(a[1])+ str(a[0])))
    else:
        b = list()
        for i in range(len(a)):
            b.append(max(int(str(a[i])+str(largest(a[:i]+a[i+1:]))), int(str(largest(a[:i]+a[i+1:]))+str(a[i]))))
        return max(b)


l = list()
while 1:
    n = input()
    if n == '':
        break
    l.append(int(n))
print(largest(l))

S=[3, 30, 34, 5, 9]
int("".join([str(10**(len(i))-int(i)) for i in sorted([str(10**(len(str(i)))-i) for i in S])]))

from itertools import permutations

num_list=input('숫자를 입력하세요:').split(' ')

for_permute=permutations(num_list)

num_set=set()
for num_tuple in for_permute:
    number=''
    for num in num_tuple:
        number+=num
    num_set.add(int(number))

print(max(num_set))

Swift입니다.

정렬을 하고 순서대로 붙여서 정수로 변환을 했습니다.

import Foundation

func generateMaxNumber(_ numbers: [Int]) -> Int {
    let sortedNumbers = numbers.sorted(by: {
        return Int(String($0) + String($1))! > Int(String($1) + String($0))!
    })
    return Int(sortedNumbers.reduce("", {$0 + String($1)} ))!
}

print( generateMaxNumber([3, 30, 34, 5, 9]) )

def BiggestNumber(lst):

    new_lst = sorted(lst, key = lambda x:str(x)[0]) # [3,30,34,5,9]
    new_lst = new_lst[::-1] # [9,5,34,30,3]

    # 앞이 같을 경우 길이가 작은것이 앞에 오도록 위치
    for idx in range(len(new_lst)):
        if idx != len(new_lst) - 1:
            if str(new_lst[idx+1]) in str(new_lst[idx]):
                new_lst[idx+1],new_lst[idx] = new_lst[idx],new_lst[idx+1]

    result = ''
    for k in new_lst:
        result += str(k)

    return result

user_input = input("Enter a numbers: ")
user_input = user_input.split()

print(BiggestNumber(user_input))

def glue_number(mylist):
    import functools
    mylist = list(map(str,mylist))
    f = lambda x,y:int(x+y)-int(y+x)
    mylist.sort(key=functools.cmp_to_key(f), reverse=True)
    print(''.join(mylist))

glue_number([3, 30, 32, 5, 9, 91, 97])

Python

import itertools
a = [3, 30, 34, 5, 9]
ans = 0
for v in itertools.permutations(a):
    #print("".join(map(str, v)))
    ans = max(ans, int("".join(map(str, v))))
print(ans)

ns = [3, 312, 313, 31, 30, 314, 3134, 9, 5]
tmp = []
for i in range(len(ns)-1):
    if i == 0:
        if int(str(ns[i]) + str(ns[i+1])) > int(str(ns[i+1]) + str(ns[i])):
            tmp.append(ns[i])
            tmp.append(ns[i+1])
        else:
            tmp.append(ns[i+1])
            tmp.append(ns[i])
    else:
        for j in range(len(tmp)):
            if int(str(ns[i+1]) + str(tmp[j])) > int(str(tmp[j]) + str(ns[i+1])):
                tmp.insert(j,ns[i+1])
                break
            elif j == len(tmp)-1: tmp.append(ns[i+1])
print(ns)
print(''.join(str(i) for i in tmp))

[3, 312, 313, 31, 30, 314, 3134, 9, 5]
95331431343133131230

파이썬3

def compare(a, b): #b가 크면 참
    if (int(str(a) + str(b)) <= int(str(b) + str(a))):
        return True
    else:
        return False

def special_sort(list1):
    for i in range(1, len(list1)):
        for j in range(i):
            if compare(list1[j], list1[i]):
                temp = list1[i]
                del list1[i]
                list1.insert(j, temp)
                break
    return "".join(list(map(str,list1)))

data = [3, 30, 34, 5, 9]
print(special_sort(data))
# 9534330

list = [34,5,9,30,3]
tmp_list = []
for j in list:
    tmp_list.append(str(j))
print(tmp_list)
d=sorted(tmp_list,key=functools.cmp_to_key(lambda a, b:int(a+b)-int(b+a)),reverse=True) # Bubble Sort
print(d)
num = ("".join(d))
print(num)

import java.util.Scanner;

public class KimSanghyeop
{
    public static void main(String[] args)
    {
        int[] arr = {3,30,34,5,9};
        int temp;
        String str1,str2;

        boolean loop= true;

        while(loop)
        {
            loop=false;
            for(int f1=0;f1<arr.length-1;f1++)
            {
                str1 = Integer.toString(arr[f1]);
                str2 = Integer.toString(arr[f1+1]);

                while(str1.length() != str2.length())
                {
                    if(arr[f1] > arr[f1+1])
                    {
                        str2+=str2.substring(0,1);
                    }
                    else
                    {
                        str1+=str1.substring(0,1);
                    }
                }

                if(Integer.parseInt(str1) < Integer.parseInt(str2))
                {
                    temp = arr[f1];
                    arr[f1] = arr[f1+1];
                    arr[f1+1] = temp;
                    loop=true;
                }
            }
        }

        String res="";
        for(int f1=0;f1<arr.length;f1++)
        {
            res+=Integer.toString(arr[f1]);
        }

        System.out.println(res);
    }
}

def func(a):
    a.sort(reverse=True)
    if len(a[-2]) >=2:
        if a[-1] > a[-2][1]:
            f = a[-1]
            a[-1]=a[-2]
            a[-2] = f 
    print(int(''.join(a)))

a=input('inputs: ').split(' ')
func(a)

def forSort(n, idx):
    n = str(n)
    if idx < len(n):
        return int(n[idx])
    else:
        return forSort(n, idx-1)

def makeLargest(L):
    m = len(str(max(L)))
    def forSortList(n):
        T = []
        for idx in range(m):
            T.append(forSort(n, idx))
        return T
    for idx in range(m):
        L.sort(key=lambda x : forSortList(x), reverse=True)
    return int(''.join(map(str, L)))

>>> makeLargest([3, 30, 34, 5, 9])
9534330
>>> makeLargest([76, 71, 70, 7, 79, 9, 3])
97977671703

    class Program
    {
        static void Main(string[] args)
        {
            //ex_input : 3 30 34 5 9
            string[] nArray = Console.ReadLine().Split(' ');
            string str1, str2;

            for(int i = 0; i<nArray.Length - 1; i ++)
            {
                for (int j = 0; j < nArray.Length - 1; j++)
                {
                    str1 =nArray[j].ToString();
                    str2 = (nArray[j + 1]).ToString();

                    if (str1.Length != str2.Length)
                    {
                        if (int.Parse(nArray[j]) > int.Parse(nArray[j + 1]))
                            str2 += str2.Substring(0, 1);
                        else
                            str1 += str1.Substring(0, 1);
                    }

                    if (int.Parse(str1) < int.Parse(str2))
                    {
                        var temp = nArray[j];
                        nArray[j] = nArray[j + 1];
                        nArray[j + 1] = temp;
                    }
                }
            }

            foreach (var item in nArray)
            {
                Console.Write(item);
            }
            Console.WriteLine();
        }
    }

import java.util.ArrayList; import java.util.List; import java.util.Scanner;

public class sol102 {

static int max = 0;

public static void solution(String count[]) throws Exception {

    maximum(count, new ArrayList<String>(), 0);
    System.out.println("max : [" + max + "]");
}


// 뽑기 [반복]
public static void maximum(String count[], List<String> data, int turn) {

    // 모두 뽑음
    if(turn == count.length) {

        String temp = "";
        int findMax = 0;
        for(int i=0; i<data.size();i++) {
            temp += data.get(i);
        }

        findMax = Integer.parseInt(temp);
        if(findMax > max) max = findMax;

    }

    // 뽑을 수 있는 모든 숫자 
    for(int i=0; i<count.length; i++) {
        String temp = count[i];

        // 이미 뽑았다면 for문으로 
        if(count[i].equals("selected")) continue;


        count[i] = "selected";
        data.add(temp);
        maximum(count, data, turn+1);   // 한번 뽑고 다음턴으로 넘김

        data.remove(data.size()-1);
        count[i] = temp;
    }
}

public static void main(String[] args) throws Exception {

    Scanner sc = new Scanner(System.in);
    //String count[] = {"1","2","3","10"};
    String count[] = {"3", "30", "34", "5", "9"};

    solution(count);
}

}

a = input()
a = [str(x) for x in a.split(',')]
for i in a:
    for j in a:
        if int(i[0]) == int(j[0]):
            if int(i+j) < int(j+i):
                a.insert(a.index(i),j)
                a.reverse()
                a.remove(j)
                a.reverse()
            elif int(i + j) > int(j + i):
                a.insert(a.index(j), i)
                a.reverse()
                a.remove(i)
                a.reverse()
        elif int(i[0]) < int(j[0]):
            a.insert(a.index(i), j)
            a.reverse()
            a.remove(j)
            a.reverse()
        elif int(i[0]) > int(j[0]):
            a.insert(a.index(j), i)
            a.reverse()
            a.remove(i)
            a.reverse()
print(''.join(a))

from functools import reduce
lst=sorted(input("여러가지 숫자를 입력하십시오: ").split(",")) #3,34,30,5,9 ->["3","30","34","5","9"]
f=lambda x, y : max(x+y,y+x)
print(reduce(lambda x, y : x+y, lst)) #3303459 #((((3+30)+34)+5)+9)
print(reduce(lambda x, y : y+x, lst)) #9534303 #(9+(5+(34+(30+3))))
print(reduce(f, lst)) #9534330   #max((3+30),(30+3)) -> x=330, y=다음 시퀀스 값
                                        #max((330+34),(34+330)) -> x=34330,
                                        #max((34330+5),(5+34330)) -> x=534330,
                                        #max((534330+9),(9+534330)) -> x=9534330


#만약 큰 수가 아니고 작은 수일 경우
#min((3+30),(30+3)) -> x=303
#min((303+34),(34+303)) -> x=30334
#min((30334+5),(5+30334)) -> x=303345
#min((303345+9),(9+303345)) -> x=3033459

GG님 풀이 보고 몇 개 배워갑니다.

N = input().split(",")
okcheck = len(N)-1
while(okcheck >= 0):
    final = 0
    incheck = 0
    for i in range(len(N)):
        if int(str(final)[0]) < int(N[i][0]):
            final = int(N[i])
            incheck = i
        elif int(str(final)[0]) == int(N[i][0]):
            if len(str(final)) != len(N[i]):
                max1 = len(str(final)) if len(str(final)) > len(N[i]) else len(N[1])
                for j in range(max1):
                    if j < max1-1:
                        if int(str(final)[j]) < int(N[i][j]):
                            final = int(N[i])
                            incheck = i
                            break
                    elif j >= max1-1:
                        if len(str(final)) > len(N[i]):
                            if int(str(final)[j]) < int(N[i][j-(max1-1)]):
                                final = int(N[i])
                                incheck = i
                        elif len(str(final)) < len(N[i]):
                            if int(str(final)[j-(max1-1)]) < int(N[i][j]):
                                final = int(N[i])
                                incheck = i
            elif len(str(final)) == len(N[i]):
                for j in range(len(str(final))):
                    if int(str(final)[j]) < int(N[i][j]):
                        final = int(N[i])
                        incheck = i

    print(final,end="")
    N.pop(incheck)
    okcheck-=1

def largest(l):

    lengh = 0 # 제일 큰 길이 구하기
    for i in l:
        if lengh < len(str(i)):
            lengh = len(str(i))

    lengh_list = []

    for i in l: # 제일 큰 길이로 숫자 다시 만들기
        j = str(i) + str(i)[-1] * (lengh - len(str(i)))
        lengh_list.append(j)

    dic = {}

    for i in range(0, len(l)): # 딕셔너리로 만들기
        dic[lengh_list[i]] = l[i]

    result = ''

    while lengh_list != []:

        max_num = lengh_list[0]

        for i in range(1, len(lengh_list)):

            if int(max_num) < int(lengh_list[i]):
                max_num = lengh_list[i]

        result += str(dic[str(max_num)])
        lengh_list.remove(max_num)

    print(result)



largest([3, 30, 34, 5, 9])
largest([1,2,3])

자릿수를 같게해서 큰수로 나열해봤습니다.

다른 사람의 코드를 참조해서 짜보았습니다.

list_a=[3,30,34,5,9,19]
list_b=[]
list_c=[]
for i in range(len(list_a)):
        list_b.append(str(list_a[i]))

while True:
    if len(list_b)==0:
        break
    MAX=max(list_b)
    list_b.remove(MAX)
    if MAX[0] in list_b:
        if len(MAX)>=2:
            for i in range(len(list_b)):
                if MAX[0]==list_b[i]:
                    if len(list_b[i])==1 and MAX[1]<list_b[i]:
                        list_b.append(MAX)
                        MAX=list_b[i]
                        list_b.remove(MAX)


    list_c.append(MAX)

print("".join(list_c))

s=[3,5,32,102,17]

def largest_number(s):

s.sort(reverse=True)

a=''

for i in s:

a += str(i)

return a

print(largest_number(s)

줄바꿈이 잘 되지 않는군요. 참고하세요.

def howmuch(a,b,c):
   if a > b or a > c:
      w = a
      zms = zns + str(a)
      words = 1
   elif b >a or b > c:
      zns = zns + str(b)
      words = 2
   else:
      zns = zns + str(c)
      words = 3
   if words == 1:
      if b > c:
         zns = zns + str(b)
         zns = zns + str(c)
      else:
         zns = zns + str(c)
         zns = zns + str(b)
   elif words == 2:
      if a > c:
         zns = zns + str(a)
         zns = zns + str(c)
      else:
         zns = zns + str(c)
         zns = zns + str(a)
   else:
      if a > b:
         zns = zns + str(a)
         zns = zns + str(b)
      else:
         zns = zns + str(b)
         zns = zns + str(a)

정말 파이썬 코드를 전혀 줄이지 않고 만든거라서 코드 수정 해주시면 감사하겠습니다. 저느 초5라서 아직 파이썬 초보입니다.갈 길이 멉니다. 그러니 맞춤법을 이해해주시고 코드 틀린것 있스면 말씀해주세요.그리고 이건 3글자 만 됩니다.그리고 하나하나 직접 쓰셔야합니다.-끝-

앞선 모범 풀이의 학습을 목적으로 작성하였습니다.```{.python} lnums = [0,2,4,55,547,53,5] def func(lnums): numbers = list(map(str, lnums)) max_len = len(max(numbers, key=len)) # max key 사용 extend_func = lambda x: x + x[-1] * (max_len - len(x)) #핵심 개념 return int(''.join(sorted(numbers, key=extend_func, reverse=True))) #sort key사용. 문자열 크기비교

print(func(lnums)) ```

// Rust

// 가장 큰 자리수를 구하고, 각 숫자에 대해 그 자리수보다 적으면 첫번째 digit으로 뒤를 채워 sort하고 합칩니다

fn largest_num() {

let mut vec = vec![3, 30, 34, 5, 9];

let l = vec.iter().map(|d| d.to_string().len())
                  .max().unwrap();
vec.sort_by_key(|d| {   let mut d_str = d.to_string();
                        let n = d_str.len();
                        let k = d / 10u32.pow((n-1) as u32);
                        if n < l {  let k_char = std::char::from_digit(k, 10).unwrap();
                                    for _ in 1..=(l-n) {
                                        d_str.push(k_char); }}
                        d_str.parse::<u32>().unwrap() });
vec.reverse();
println!("{}",
        vec.iter().fold(String::new(), |res, d| res + &d.to_string()));

}

inp = [3, 30, 34, 5, 9]
print(''.join(sorted([str(x) for x in inp])[::-1]))

a=[3, 30, 34, 5, 9] li=[] for i in a: for j in str(i): li.append(int(j)) li.sort() for i in li[::-1]: print(i,end="")

x = []
for i in range(5):
    a = int(input('입력 : '))
    for j in str(a):
        x.append(j)
        x.sort(reverse = True)
for i in x:
    print(i, end = '')

import itertools
numbers = []
lst = [i for i in input().split(" ")]

for num in list(itertools.permutations(lst)):
  number =int("".join(num))
  numbers.append(number)

print(max(numbers))