#include<string>
#include<algorithm>
#include<iostream>
#include<vector>
#include<memory.h>

using namespace std;


int n = 0;

long long numbers[10];


long long max_memo[ 2048 ]; //max_dp 함수를 위한 Memoization 배열 
long long min_memo[ 2048 ]; //min_dp 함수를 위한 Memoization 배열 

/** max_dp(state)
 *   - 각 단어들 중 비트가 1로 표시된 인덱스에 해당하는 숫자들을 모두 사용했을 때
 *     조합해서 만들 수 있는 가장 큰 숫자
 */
long long max_dp(int state)
{
    //이미 계산한 적 있는 값이라면 생략한다
    if(max_memo[state] != -1)
        return max_memo[state];
    
    
    long long & answer = max_memo[state];
    for(int i = 0 ; i < n ; i ++)
    {
        int bits = ( 1 << i );
        if( (state & bits) == 0 )   continue;
        //state에 속한 숫자 들 중 
        //i번째 숫자를 마지막으로 사용했었다면
        //만들 수 있던 최대의 값은 얼마일까?
        
        
        //i번째 숫자를 사용하기 이전의 상태 
        int before_state = state - bits;
        
        //그 때 만들 수 있던 최대의 10진수와
        long long head = max_dp(before_state);
        
        //i번째 숫자
        long long tail = numbers[i];
        
        
        //head를 1~2자리 10진법으로 시프트하여 두 숫자를 이어붙인다.
        if(tail >= 10){
            head *= 100;
        }else{
            head *= 10;
        }
        long long concat = head + tail;
        
        //i번 숫자를 마지막으로 사용한 게 최적해라면 갱신한다
        if(answer == -1 || concat > answer)
            answer = concat;
    }
    
    //최적해를 Memoization하고 반환한다
    return answer;
}


/** min_dp(state)
 *   - 각 단어들 중 비트가 1로 표시된 인덱스에 해당하는 숫자들을 모두 사용했을 때
 *     조합해서 만들 수 있는 가장 작은 숫자
 */
long long min_dp(int state)
{
    if(min_memo[state] != -1)
        return min_memo[state];

    
    long long & answer = min_memo[state];
    for(int i = 0 ; i < n ; i ++)
    {
        int bits = ( 1 << i );
        if( (state & bits) == 0 )   continue;
        
        int before_state = state - bits;
        
        long long head = min_dp(before_state);
        long long tail = numbers[i];
        
        if(tail >= 10){
            head *= 100;
        }else{
            head *= 10;
        }
        
        long long concat = head + tail;
        if(answer == -1 || concat < answer)
            answer = concat;
    }
    
    return answer;
}

int main(){
    memset(max_memo, -1, sizeof(max_memo));
    memset(min_memo, -1, sizeof(min_memo));
    
    
    cin >> n;
    for(int i = 0 ; i < n ; i++){
        cin >> numbers[i];
        
        int bits = (1 << i);
        max_memo[bits] = min_memo[bits] = numbers[i];
    }
    
    int full_bits = (1 << n) -1;
    long long max_answer = max_dp(full_bits);
    long long min_answer = min_dp(full_bits);
    long long answer = min_answer + max_answer;
    cout << answer << endl;
    
    
    return 0;
}

import java.io.*;
import java.util.*;


class Main {
    public static final Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) {
			//사용할 숫자의 갯수를 입력받는다 
			int n = scanner.nextInt();
			
			//실제로는 숫자지만 문자열로서 다루면 훨씬 코드가 간결해지므로 이렇게 입력받는다.
			String[] numbers = new String[n];
			for(int i = 0 ; i < n ; i ++){
				numbers[i] = scanner.next();
			}
			
			//숫자들을 정렬한다.
			//정렬하는 기준은 단순 사전순이 아니라 따로 정의한다 
			Arrays.sort(numbers, new Comparator<String>() {
				@Override
				public int compare(String o1, String o2) {
					//일반적으로 작은 숫자가 앞으로 오도록 정렬하면 차례로 이어붙이면 가장 작은 숫자를 만들 수 있을 것 같다 
					
					//하지만
					//하나는 두 글자이고 하나는 한 글자일 때 앞 자리가 같은 경우가 정렬의 예외 케이스가 된다.
					//예를 들어서 큰 숫자를 만들 때 사용할 수 있는 숫자가 65, 6, 67 이 있다면
					// 67 < 6 < 65 순으로 사용하는게 가장 유리하다
					//이 경우를 예외처리 해주기 위하여 한 글자의 숫자를 두 숫자가 이어붙인 것 처럼 생각해서 정렬한다 
					
					//각 숫자가 한 글자라면 복사해서 두 글자 처럼 취급해서 정렬한다
					//예: 5 -> 55
					if( o1.length() == 1 )
						o1 = o1 + o1;
					
					if( o2.length() == 1)
						o2 = o2 + o2;
					
					//그 후 일반적인 문자열의 사전순 정렬을 따른다.
					//(자릿수가 같으므로 일반적인 숫자의 대소비교와 같다.)
					return o1.compareTo(o2);
				}
			});

			String max = ""; //정렬된 숫자들을 뒤에서부터 이어붙인다
			String min = ""; //정렬된 숫자들을 앞에서부터 이어붙인다 
			for(int i = 0 ; i < n ; i ++)
			{
				max += numbers[n-i-1];
				min += numbers[i];
			}

			//만들어진 정답 문자열들을 숫자로 변환하고
			long max_value = Long.parseLong(max);
			long min_value = Long.parseLong(min);
			
			//두 값을 더하여 정답을 만들고 출력한다
			long answer = max_value + min_value;
			System.out.println(answer);
		}
}