#include<bits/stdc++.h>
using namespace std;
#define in(x) int x; cin>>x;
#define sin(s) string s; cin>>s;
#define ll long long 
#define lin(x) ll x; cin>>x;
#define vi vector<int>
#define vll vector<ll>
#define si set<int>
#define pb push_back
#define re(i,n) for(int i=0; i<n; i++)
#define pe(i,a,b) for(ll i=a; i<=b; i++)
#define rre(i,n) for(int i=n-1; i>-1; i--) 
#define mp make_pair
#define pii pair<ll,ll>
//#define endl "\n"
#define pi 3.1415926536 
#define FAST ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define fio freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
#define mod 1000000007
//#define inf LLONG_MAX
#define ninf -INT_MAX
#define inf 1000000
#define MAXN 10000001
bool compare(const pair<string,int>&i, const pair<string,int>&j) 
{ 
        if(i.second==j.second)
                return i.first<j.first;
        return i.second>j.second;
} 
/////////////////////////////////////////////////////////////////////////////////
//vi v;
int ncr(int n, int k)   
{   
        if(n<k)
                return 0;
        int C[n + 1][k + 1];   
        int i, j;   
        for (i = 0; i <= n; i++)   
        {   
                for (j = 0; j <= min(i, k); j++)   
                {   
                        if (j == 0 || j == i)   
                                C[i][j] = 1;   
                        else  
                                C[i][j] = (C[i - 1][j - 1] + C[i - 1][j])%mod;   
                }   
        }   
        return C[n][k];   
} 
////////////////////////////////////////////////////////////////////////////
ll modpowIter(ll a, ll b, ll c)   
{   
        ll ans=1;  
        while(b != 0)   
        {  
                if(b%2 == 1) 
                ans=(ans*a)%inf;  
                a=(a*a)%inf;  
                b /= 2;   
        }  
        return ans;  
} 
///////////////////////////////////////////////////////////////////////////////
string intobin(int n)
{
        string s="";
        if(n==0)
                s="0";
        while(n)
        {
                if(n%2)
                        s="1"+s;
                else
                        s="0"+s;
                n/=2;
        }
        return s;
}

////////////////////////////////////////////////////////////////////////////////

int bintoin(string s)
{
        ll n=0;
        vll v;
        v.pb(1);
        re(i,400)
        {
                v.pb((v[v.size()-1]*2)%1000003);
        }
        rre(i,s.length())
        {
                n=(n+(s[i]-'0')*v[s.length()-i-1])%1000003;
                //cout<<v[s.length()-i-1]<<endl;
        }
        return n;
}
//////////////////////////////////////////////////////////////////////////////////
ll nc2(ll n, ll k)
{
        if(n<k)
                return 0;
        return (n*(n-1))/2;
}
///////////////////////////////////////////////////////////////////////////////////
bool prime[1000001]; 
void SieveOfEratosthenes(int n)   
{     
        memset(prime, true, sizeof(prime));   
        for (int p=2; p*p<=n; p++)   
        {    
                if (prime[p] == true)   
                {   
                        for (int i=p*p; i<=n; i += p)   
                        prime[i] = false;   
                }   
        }   
        /*for (int p=2; p<=n; p++)   
                if (prime[p])   
                        v.pb(p);  */
}   
//////////////////////////////////////////////////////////////////////////////////
int parent[6];
void make_set(int v)   
{   
        parent[v] = v;   
}  

int find_set(int v)   
{   
        if (v == parent[v])   
                return v;   
        return parent[v] = find_set(parent[v]);  
}  

void union_sets(int a, int b)  
{ 
        a = find_set(a); 
        b = find_set(b); 
        if (a != b) 
                parent[b] = a; 
} 
////////////////////////////////////////////////////////////////////////////////////

int spf[10000001]; 
void sieve()   
{   
        spf[1] = 1;   
        for (int i=2; i<MAXN; i++)   
                spf[i] = i;   
        for (int i=4; i<MAXN; i+=2)   
                spf[i] = 2;   
        for (int i=3; i*i<MAXN; i++)   
        {   
                if (spf[i] == i)   
                {   
                        for (int j=i*i; j<MAXN; j+=i)   
                                if (spf[j]==j)   
                                        spf[j] = i;   
                }   
        }   
}  

//////////////////////////////////////////////////////////////////////////////////////////

void dfs(int node, int visited[], vi adj[])
{
        visited[node]=1;
        //cout<<node<<" ";
        for(auto x: adj[node])
        {
                if(!visited[x])
                {
                        dfs(x,visited,adj);
                }
        }
}
///////////////////////////////////////////////////////////////////////////////////////////
int isprime(int n)
{
        pe(i,2,sqrt(n))
        {
                if(n%i==0)
                        return 0;
        }
        return 1;
}

/////////////////////////////////////////////////////////////////////////////////////////
int main() 
{
        in(n)
        map <int,int> m;
        while(n--)
        {
                in(x)
                m[x]++;
        }
        ll sum=0;
        for(auto x: m)
        {
                if(x.first>x.second)
                {
                        sum+=x.second;
                }
                else
                {
                        sum+=x.second-x.first;
                }
        }
        cout<<sum;
        return 0;
}

Measured memory_bytes: 8148