#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <unordered_map>
#include <map>
#include <set>
#include <list>
#include <string>
#include <cstring>
#include <cctype>
#include <regex>
#include <unordered_set>
#include <cmath>
#include <utility>
#include <bitset>
#include <numeric>
#include <typeinfo>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
 
using namespace std;
 
#define mod 1000000007
#define mod9 1000000009
#define inf 1000000011
#define infll 2000000000000000005LL 
double pi = 22 / 7;
 
#define here cout<<endl<<"here"<<endl;
 
typedef long long int ll;
typedef unsigned long long int ull;
typedef long int l;
typedef long double ld;
 
int dx[] = {0, 0, -1, 1};
int dy[] = {1, -1, 0, 0};
 
template<class T>
inline T gcd(T a, T b){ 
    while (b > 0){
        a %= b; 
        swap(a, b); 
    }
    return a; 
}
 
template<class T>
inline T lcm(T a, T b){
    return a*b / gcd(a, b); 
}
 
template<class T>
inline bool ispalin(T &arr){ 
    int n = arr.size(); 
    for (int i = 0; i < n / 2; i++){ 
        if (arr[i] != arr[n - i - 1]) 
            return false; 
    }
    return true;
}
 
struct point{
    int x, y;
    point(){}
    point(int x, int y){
        this->x = x;
        this->y = y;
    }
};
 
struct pair_hash {
    template <class T1, class T2>
    size_t operator () (const pair<T1,T2> &p) const {
        auto h1 = hash<T1>{}(p.first);
        auto h2 = hash<T2>{}(p.second);
        return h1 ^ 23909 ^ h2 ;  
    }
};
 
template <class T>
vector<T> prime_factors(T num){
    vector<T> factors;
    while(!(num % 2)){
        num /= 2;
        factors.push_back(2);
    }
    for(T i = 3; i <= sqrt(num); i += 2){
        while(!(num % i)){
            num /= i;
            factors.push_back(i);
        }
    }
    if(num > 2) factors.push_back(num);
    return factors;
}
 
template <class T> 
T powb(T base, T p, T modval = mod) {
    T res = 1;
    while(p) {
        if(p & 1) res = (res * base) % modval;
        base = (base * base) % modval;
        p /= 2;
    }
    return res % modval;
}
 
 
class fastprime{
    int size = 0;
    vector<int> SPF;
public:
    vector<int> prime; // SPF -> Smallest Prime Factor
    vector<bool> isprime;
    fastprime(int size){
        this->size = size;
        isprime.resize(size, 1);
        SPF.resize(size);
        sieve();
    }
    void sieve(){
        isprime[0] = isprime[1] = 0;
        for(int i=2;i<size;i++){
            if(isprime[i]){
                prime.push_back(i);
                SPF[i] = i; 
            }
            for(int j=0;j<(int)prime.size() && i*prime[j] < size && prime[j] <= SPF[i];j++){
                isprime[i*prime[j]] = 0;
                SPF[i*prime[j]] = prime[j];
            }   
        }
    }
};


// ---------------------------------------------------------------------------------

int main() {
    int N;
    cin >> N;
    string str;
    cin >> str;
    string numbers = "0123456789";
    string lower_case = "abcdefghijklmnopqrstuvwxyz";
    string upper_case = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    string special_characters = "!@#$%^&*()-+";
    unordered_set<char> num, low, up, spl;
    for(char ch : numbers) num.insert(ch);
    for(char ch : lower_case) low.insert(ch);
    for(char ch : upper_case) up.insert(ch);
    for(char ch : special_characters) spl.insert(ch);
    int l = 0, u = 0, s = 0, n = 0;
    for(char ch : str) {
        if(num.find(ch) != num.end()) n++;
        else if(low.find(ch) != low.end()) l++;
        else if(up.find(ch) != up.end()) u++;
        else s++;
    }
    int rem = 0;
    if(!l) rem++;
    if(!u) rem++;
    if(!s) rem++;
    if(!n) rem++;
    cout << max(6 - N, rem);
}