#include <bits/stdc++.h>
 using namespace std;
 #define ll long long 
 ll INF = 1e18;
 void run_dijkstra(int start_node, int n, vector<vector<pair<int, long long>>> &adj) {
    vector<long long> dist(n + 1, INF);
    vector<int> parent(n + 1, -1);
    
    // Min-priority queue: stores {distance, node}
    priority_queue<pair<long long, int>, vector<pair<long long, int>>, greater<pair<long long, int>>> pq;

    dist[start_node] = 0;
    pq.push({0, start_node});

    while (!pq.empty()) {
        long long current_dist = pq.top().first;
        int u = pq.top().second;
        pq.pop();

        if (current_dist > dist[u]) continue;

        for (auto &edge : adj[u]) {
            int v = edge.first;
            long long weight = edge.second;

            if (dist[u] + weight < dist[v]) {
                dist[v] = dist[u] + weight;
                parent[v] = u;
                pq.push({dist[v], v});
            }
        }
    }

    // Example output: print distances from start_node
    for (int i = 1; i <= n; i++) {
        if (dist[i] == INF) cout << "Node " << i << ": Unreachable\n";
        else cout << "Node " << i << ": " << dist[i] << "\n";
    }
}

// Prim's Algorithm for Minimum Spanning Tree
void run_prim() {
    int n, m;
    if (!(cin >> n >> m)) return;

    vector<vector<pair<int, long long>>> adj(n + 1);
    for (int i = 0; i < m; i++) {
        int u, v;
        long long w;
        cin >> u >> v >> w;
        adj[u].push_back({v, w});
        adj[v].push_back({u, w});
    }

    vector<long long> dist(n + 1, INF);
    vector<bool> visited(n + 1, false);
    vector<int> parent(n + 1, -1);
    set<pair<long long, int>> pq; 

    dist[1] = 0;
    pq.insert({0, 1});

    long long total_weight = 0;

    while (!pq.empty()) {
        int u = pq.begin()->second;
        long long weight = pq.begin()->first;
        pq.erase(pq.begin());

        if (visited[u]) continue;
        visited[u] = true;
        total_weight += weight;

        for (auto &edge : adj[u]) {
            int v = edge.first;
            long long w = edge.second;

            if (!visited[v] && w < dist[v]) {
                pq.erase({dist[v], v});
                dist[v] = w;
                parent[v] = u;
                pq.insert({dist[v], v});
            }
        }
    }

    cout << "Total MST Weight: " << total_weight << endl;
}
void run_toposort() {
    int n, m;
    if (!(cin >> n >> m)) return;

    vector<vector<int>> adj(n + 1);
    vector<int> in_degree(n + 1, 0);

    for (int i = 0; i < m; i++) {
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
        in_degree[v]++;
    }

    queue<int> q;
    for (int i = 1; i <= n; i++) {
        if (in_degree[i] == 0) {
            q.push(i);
        }
    }

    vector<int> result;
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        result.push_back(u);

        for (int v : adj[u]) {
            in_degree[v]--;
            if (in_degree[v] == 0) {
                q.push(v);
            }
        }
    }

    if (result.size() != n) {
       // cout << "Cycle detected! Topological sort not possible." << endl;
    } else {
        for (int i = 0; i < result.size(); i++) {
            cout << result[i] << (i == result.size() - 1 ? "" : " ");
        }
        cout << endl;
    }
}

static const long long MOD = 998244353;
static const int MAXN = 1000000; // adjust as needed

long long fact[MAXN + 1], invFact[MAXN + 1];

long long power(long long base, long long exp) {
    long long res = 1;
    base %= MOD;
    while (exp > 0) {
        if (exp & 1) res = (res * base) % MOD;
        base = (base * base) % MOD;
        exp >>= 1;
    }
    return res;
}

void precompute() {
    
    fact[0] = 1;
    for (int i = 1; i <= MAXN; i++)
        fact[i] = fact[i - 1] * i % MOD;

   
    invFact[MAXN] = power(fact[MAXN], MOD - 2); // Fermat
    for (int i = MAXN - 1; i >= 0; i--)
        invFact[i] = invFact[i + 1] * (i + 1) % MOD;
}

long long nCr(int n, int r) {
    if (r < 0 || r > n) return 0;
    return fact[n] * invFact[r] % MOD * invFact[n - r] % MOD;
}
bool isPrime(long long n) {
    if (n <= 1) return false;
    if (n <= 3) return true;
    if (n % 2 == 0 || n % 3 == 0) return false;

   
    for (long long i = 5; i * i <= n; i += 6) {
        if (n % i == 0 || n % (i + 2) == 0)
            return false;
    }
    return true;
}
 int wordLadderLength(string startWord, string targetWord) {
        
        queue<pair<string, int>> q;
        q.push({startWord, 0});

        
        set<string> st;
        st.insert(startWord);
        

        while (!q.empty()) {
            string word = q.front().first;
            int steps = q.front().second;
            q.pop();

          
            if (word == targetWord) return steps;

           
            for (int i = 0; i < word.size(); i++) {
                char original = word[i];
                for (ll j = 0; j<= 9; j++) {
                    if (i == 0 && j == 0) continue;


                    word[i] = j + '0';
                    if (st.find(word) == st.end() && isPrime(stoi(word))) {
                        st.insert(word);
                        q.push({word, steps + 1});
                    }
                }
                word[i] = original;
            }
        }
        
        return 0;
    }

void solve() {
  ll n;
  cin >> n;
  string str;
  cin >> str;
  vector<ll>arr(n);
  vector<pair<ll,ll>>prefix(n);

  for (ll i = 0; i < n; i++) {
    cin >> arr[i];
  }
  prefix[0].first = arr[0];
  prefix[0].second = str[0] == 'E' ? 1 : 0;
  for (ll i = 1; i < n; i++) {
    prefix[i].first = prefix[i - 1].first + arr[i];
    prefix[i].second = prefix[i-1].second + (str[i] == 'E'? 1: 0);
  }
  ll q;
  cin >> q;
  for (ll i = 0; i < q; i++) {
    ll a;
    cin >> a;
    ll maxi = 0;
    for (ll i = 0; i < n; i++) {
        if (i > 0) {
            auto it = upper_bound(prefix.begin(), prefix.end(), make_pair(a + prefix[i-1].first, 1e18), 
    [](const pair<ll, ll>& a, const pair<ll, ll>& b) {
        return a.first < b.first;
    });
            if (it != prefix.begin()) {
                it--;
                ll index = it - prefix.begin();
                maxi = max(maxi, prefix[index].second - prefix[i-1].second);

            }

        }
        else {
              auto it = upper_bound(prefix.begin(), prefix.end(), make_pair(a, 1e18), 
    [](const pair<ll, ll>& a, const pair<ll, ll>& b) {
        return a.first < b.first;
    });
              if (it != prefix.begin()) {
                it --;
                ll index = it - prefix.begin();
                maxi = max(maxi, prefix[index].second);
              }


        }

       
        
    }
    cout << maxi << endl;
    
  }




  



    
    

    



 }

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    precompute();
    
 
    // int t;
    // cin >> t;
    // while (t--) {
    //    solve();

    // }
solve();

   
   

    return 0;
}