#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;
}

void solve() {
    ll n;
    cin >> n;
    string str1;
    cin >> str1;
    string str2;
    cin >> str2;
    ll ans = 0;
    for (ll i = 0; i < n; i++) {
        if (str1[i] != str2[i]) {
            ans++;
        }
    }
    cout << ans << endl;

    



 }

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

    // }
solve();

   
   

    return 0;
}