#include <bits/stdc++.h>
using namespace std;

int n;
vector<int> a;

bool check(int k) {
    // Chọn k viên gạch có độ cứng lớn nhất
    // Giả sử a đã được sắp xếp tăng dần
    // Chúng ta cần kiểm tra xem k viên cuối có thỏa mãn không
    for (int i = 0; i < k; ++i) {
        // Viên gạch thứ i từ dưới lên (dễ nhất) trong số k viên này là a[n - k + i]
        // Yêu cầu: a[n - k + i] >= (k - 1 - i)
        if (a[n - k + i] < (k - 1 - i)) return false;
    }
    return true;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cin >> n;
    a.resize(n);
    for (int i = 0; i < n; ++i) cin >> a[i];
    sort(a.begin(), a.end());

    int low = 0, high = n, ans = 0;
    while (low <= high) {
        int mid = (low + high) / 2;
        if (check(mid)) {
            ans = mid;
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    cout << ans << endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int n;
    cin >> n;
    vector<int> a(n);
    for (int i = 0; i < n; ++i) cin >> a[i];
    sort(a.begin(), a.end());

    // Nếu viên gạch lớn nhất có thể làm đáy cho cả chồng N viên
    // (tức là a[n-1] >= N-1) và đủ gạch thì đáp án là N.
    // Tuy nhiên, điều kiện này chỉ cần thiết nếu ta dùng hết gạch.
    // Thuật toán chung:

    int ans = 0;
    for (int i = 0; i < n; ++i) {
        // a[i] là độ cứng của viên gạch thứ i (từ nhỏ đến lớn)
        // Nếu ta dùng viên này làm 1 phần của chồng gạch, 
        // số viên gạch có thể đặt lên trên nó phải >= 0.
        // Giả sử ta đang xây một chồng có tổng cộng (ans + 1) viên.
        // Viên gạch này sẽ đóng góp vào độ cao.
        // Điều kiện: a[i] >= ans (vì ans là số viên trên nó nếu nó là viên mới thêm vào)
        // Hay suy nghĩ khác: Ta có thể xếp được ans viên.
        // Khi xét viên gạch tiếp theo a[i], ta có thể tăng độ cao lên 1 nữa không?
        // Nếu a[i] >= ans, ta có thể xếp thêm 1 tầng (đặt viên này lên trên)
        // Hoặc suy nghĩ: Liệt kê các viên gạch thỏa mãn a[i] >= số lượng viên gạch còn lại trong chồng.
        // Thuật toán đúng trong các submission:
        // Sắp xếp tăng dần.
        // Duyệt từ đầu, nếu a[i] >= số lượng viên gạch hiện tại đang xét (hoặc số lượng viên gạch nhỏ hơn/ bằng nó)

        // Code mẫu từ solution:
        // int d = 0;
        // for(int i=1; i<=n; i++) if(d <= a[i]) d++;
        // Logic: d là độ cao hiện tại. 
        // Nếu viên gạch a[i] có thể chịu được d viên gạch phía trên (tức a[i] >= d),
        // ta có thể đặt nó vào đáy của một chồng gạch mới hoặc bổ sung vào.
        // Nhưng thực tế thuật toán này đang đếm số lượng viên gạch thỏa mãn a[i] >= count.
        // Nó tìm số lượng viên gạch có thể tạo thành một nhóm mà ở đó viên thứ k (từ nhỏ đến lớn) có độ cứng >= k-1.

        // Code tối ưu nhất (từ Solution 2):
    }

    // Implementation từ Solution 2:
    int d = 0;
    for(int i = 0; i < n; i++) {
        if(d <= a[i]) {
            d++;
        }
    }
    cout << d;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int n;
    cin >> n;
    vector<int> a(n);
    for (int i = 0; i < n; ++i) cin >> a[i];

    // Solution 3: Sắp xếp giảm dần
    sort(a.rbegin(), a.rend());

    // Logic: Giả sử viên gạch cứng nhất làm đáy.
    // Ta cần tìm độ cao h.
    // Viên gạch cứng nhất (a[0]) cần chịu h-1 viên.
    // Viên gạch thứ 2 (a[1]) cần chịu h-2 viên...
    // Viên gạch thứ i (từ 0) cần chịu h-1-i viên.
    // Ta có thể thử greed: Chọn các viên gạch mạnh nhất.
    // Hoặc duyệt:

    int h = a[0]; // Giả định độ cao ban đầu bằng độ cứng viên đầu tiên (hoặc n)
    int i = 1;
    for (; i < n; ++i) {
        if (h == 0) break;
        // Logic này hơi lạ: h = min(h - 1, a[i])
        // h ở đây có lẽ là "sức chịu tải còn lại" của viên gạch trước đó.
        // Thực ra đây là cách khác để tính độ cao.
    }

    // Code rõ ràng hơn:
    // Sắp xếp giảm dần.
    // Duyệt từ i = 0.
    // Giả sử độ cao bắt đầu bằng a[0] + 1? Không.
    // Thuật toán chính xác để giải thích:
    // Sắp xếp giảm dần.
    // Đặt h = a[0].
    // Duyệt i từ 1:
    //   Nếu a[i] >= h - 1 thì h = h - 1 (hoặc không thay đổi?)
    //   Thực ra: Viên thứ i có thể đặt ở vị trí h-1 nếu a[i] >= h-1.
    //   Nếu a[i] >= h-1, ta có thể giữ nguyên độ cao h (tức viên này có thể nằm ở vị trí h-1).
    //   Nhưng ta đang xét từ trên xuống.

    // Logic từ code mẫu:
    // h = arr[0];
    // for (i=1; i<n; i++) {
    //     if (h == 0) break;
    //     h = min(h - 1, arr[i]);
    // }
    // cout << i;
    // Giải thích:
    // arr[0] là lớn nhất, nó có thể làm đáy cho độ cao arr[0] + 1?
    // Không, h ở đây là độ cao tối đa có thể tạo ra tính đến thời điểm hiện tại.
    // Ban đầu h = arr[0] (vì viên này có thể chịu arr[0] viên -> chồng cao arr[0]+1).
    // Tuy nhiên, code tính i là số viên.
    // Hãy xem xét ví dụ: 1 2 3 4 5. Sắp xếp giảm: 5 4 3 2 1.
    // arr[0]=5. h=5. i=1. a[1]=4. h = min(4, 4) = 4.
    // i=2. a[2]=3. h = min(3, 3) = 3.
    // ...
    // i=5. Loop end. cout 5.
    // Logic này tìm số lượng viên gạch đầu tiên mà tại đó điều kiện bị vi phạm.

    // Để dễ hiểu nhất, ta nên giải thích theo thuật toán "Greedy counting" (Approach 2) 
    // hoặc "Binary Search" (Approach 1).
    // Approach 3 này có thể được giải thích là một biến thể của Greedy.
    // Sắp xếp giảm dần.
    // Một chồng gạch có k viên (từ đáy lên) cần:
    // a[0] >= k-1 (nếu dùng viên lớn nhất làm đáy)
    // a[1] >= k-2
    // ...
    // a[k-1] >= 0
    // Khi duyệt giảm dần, ta cần tìm k lớn nhất sao cho a[k-1] >= 0 (luôn đúng), a[k-2] >= 1...
    // Code mẫu đang làm: Giả sử ta có thể tạo độ cao a[0].
    // Sau đó thử giảm độ cao xuống.
    int height = a[0];
    for (int i = 1; i < n; ++i) {
        if (height == 0) break;
        // Viên gạch thứ i có thể nằm ở độ cao height-1 không?
        // Nếu height là độ cao tối đa có thể chịu bởi các viên trên,
        // thì a[i] >= height - 1 là điều kiện.
        // Code làm: height = min(height - 1, a[i]);
        // Nếu a[i] < height - 1, thì không thể đạt độ cao height nữa, phải giảm xuống a[i] + 1.
        // Nếu a[i] >= height - 1, thì độ cao giảm đi 1 đơn vị (vì đã dùng thêm 1 viên).
        height = min(height - 1, a[i]);
    }
    cout << a[0] - height << endl;
    // Wait, output của code mẫu là i. 
    // Vòng lặp i chạy từ 1 đến n.
    // Nếu height không bao giờ bằng 0, i sẽ là n.
    // Nếu height về 0 ở bước i, vòng lặp break, i không tăng nữa.
    // Vòng lặp dừng khi i = index của viên gạch cuối cùng dùng được + 1.
    // Do đó cout i là chính xác.
    // Tuy nhiên, có trường hợp a[0] < n.
    // Code mẫu in ra i.
    // Nếu a[0] < n, ví dụ a = [2, ...].
    // height=2. i=1. height=1. i=2. height=0 (nếu a[1] < 1). Break. i=2.
    // cout 2.
    // Đáp án đúng.
    // Vậy code mẫu thực ra là:
    sort(a.rbegin(), a.rend());
    int h = a[0];
    int i;
    for (i = 1; i < n; ++i) {
        if (h == 0) break;
        h = min(h - 1, a[i]);
    }
    cout << i;