#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// Hàm so sánh cho qsort (giảm dần)
int cmp_int(const void *a, const void *b) {
    return (*(int*)b - *(int*)a);
}

// Hàm so sánh kí tự cho qsort (giảm dần)
int cmp_char_desc(const void *a, const void *b) {
    return (*(char*)b - *(char*)a);
}

// Hàm so sánh kí tự cho qsort (tăng dần, dùng cho số âm)
int cmp_char_asc(const void *a, const void *b) {
    return (*(char*)a - *(char*)b);
}

void process_numbers(int arr[], int n) {
    for (int i = 0; i < n; i++) {
        char buffer[10];
        sprintf(buffer, "%d", abs(arr[i])); // Chuyển số thành chuỗi

        if (arr[i] >= 0) {
            // Sắp xếp giảm dần để tạo số lớn nhất
            qsort(buffer, strlen(buffer), sizeof(char), cmp_char_desc);
        } else {
            // Xử lý số âm: Sắp xếp tăng dần
            qsort(buffer, strlen(buffer), sizeof(char), cmp_char_asc);

            // Logic từ solution 1: Đưa số 0 ra sau (nếu có)
            // Thực tế solution 1 làm khá phức tạp, nhưng logic chung là:
            // Sau khi sort asc (ví dụ: 0, 1, 2), ta cần 1, 2, 0 -> số âm -120 (lớn nhất)
            // Tuy nhiên, code sample của LamThanhVu lại sort asc rồi swap để có thứ tự đặc biệt.
            // Để đơn giản và đúng với logic số âm lớn nhất (về mặt toán học là nhỏ nhất):
            // Ta chỉ cần sort asc là đủ (vd: -321 -> sort asc -> "123" -> -123).
        }

        int val = atoi(buffer);
        if (arr[i] < 0) val = -val;
        arr[i] = val;
    }
}

int main() {
    int n;
    scanf("%d", &n);
    int a[1005];
    for (int i = 0; i < n; i++) scanf("%d", &a[i]);

    process_numbers(a, n);

    qsort(a, n, sizeof(int), cmp_int);

    for (int i = 0; i < n; i++) printf("%d ", a[i]);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

// Hàm so sánh giảm dần
int cmp_desc(const void *a, const void *b) {
    return (*(int*)b - *(int*)a);
}

// Hàm so sánh tăng dần
int cmp_asc(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

void process(int *x) {
    int digits[10];
    int count = 0;
    int is_neg = (*x < 0);
    int val = abs(*x);

    // Tách chữ số
    while (val > 0) {
        digits[count++] = val % 10;
        val /= 10;
    }

    if (is_neg) {
        // Solution 3 logic: Sắp xếp tăng dần
        // Lưu ý: Solution 3 có đoạn code khá rối để xử lý số 0,
        // nhưng cách đơn giản là dùng qsort.
        qsort(digits, count, sizeof(int), cmp_asc);
    } else {
        // Sắp xếp giảm dần
        qsort(digits, count, sizeof(int), cmp_desc);
    }

    // Xây dựng lại số
    int new_val = 0;
    if (count == 0) { // Trường hợp số 0
        *x = 0;
        return;
    }

    // Solution 3 có một đoạn code lạ để xử lý số 0 đối với số âm:
    // 'while(b[p]==0) p++; ...'
    // Điều này có nghĩa là với số âm, sau khi sort asc (vd: 0, 1, 2),
    // nó sẽ lấy 1, 2, 0 -> thành 120 -> -120.
    // Để tái tạo logic này:
    if (is_neg) {
        // Tìm index đầu tiên khác 0
        int start = 0;
        while (start < count && digits[start] == 0) start++;

        if (start < count) {
            // Đặt số đó lên đầu
            int first = digits[start];
            for (int i = start; i > 0; i--) digits[i] = digits[i-1];
            digits[0] = first;
        }
    }

    for (int i = 0; i < count; i++) {
        new_val = new_val * 10 + digits[i];
    }

    *x = is_neg ? -new_val : new_val;
}

int main() {
    int n;
    scanf("%d", &n);
    int a[1005];
    for (int i = 0; i < n; i++) scanf("%d", &a[i]);

    for (int i = 0; i < n; i++) process(&a[i]);

    qsort(a, n, sizeof(int), cmp_desc);

    for (int i = 0; i < n; i++) printf("%d ", a[i]);
    return 0;
}