Problem:
 Score : 200 points    Problem Statement Given are strings S and T . Consider changing S to T by repeating the operation below. Find the minimum number of operations required to do so.  Operation: Choose one character of S and replace it with a different character.      Constraints  S and T have lengths between 1 and 2\times 10^5 (inclusive).  S and T consists of lowercase English letters.  S and T have equal lengths.         Input Input is given from Standard Input in the following format:  S  T       Output Print the answer.        Sample Input 1 cupofcoffee
cupofhottea      Sample Output 1 4  We can achieve the objective in four operations, such as the following:   First, replace the sixth character c with h .  Second, replace the eighth character f with t .  Third, replace the ninth character f with t .  Fourth, replace the eleventh character e with a .        Sample Input 2 abcde
bcdea      Sample Output 2 5       Sample Input 3 apple
apple      Sample Output 3 0  No operations may be needed to achieve the objective.

Solution (Python):
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
import math
from copy import deepcopy
import queue


Mod = 1000000007
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1] 
for i in range(2, 10**5 + 1):
    fact.append((fact[-1] * i) % Mod)
    inv.append((-inv[Mod % i] * (Mod // i)) % Mod)
    factinv.append((factinv[-1] * inv[-1]) % Mod)
    
def cmb(n, r, p):
    if (r < 0) or (n < r):
        return 0
    r = min(r, n - r)
    return fact[n] * factinv[r] * factinv[n - r] % p
    
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[y] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)
import string
def main():  
    s = input()
    t = input()
    n = len(s)
    ans = 0
    for i in range(n):
        if s[i] != t[i]:
            ans += 1
    print(ans)
if __name__ == "__main__":
    main()

Solution (Python):
import sys
sys.setrecursionlimit(10**9)

def mi(): return map(int,input().split())
def ii(): return int(input())
def isp(): return input().split()
def deb(text): print("-------\n{}\n-------".format(text))

def main():
    S = list(input())
    T = list(input())

    ans = 0
    for i in range(len(S)):
        if S[i] == T[i]: continue
        ans += 1
    
    print(ans)





if __name__ == "__main__":
    main()

Solution (Python):
T =list(input())
S = list(input())
ans = 0
for n in range(len(T)):
  if S[n] != T[n]:
    ans += 1
print(ans)

Solution (Python):
import sys
sys.setrecursionlimit(10**7) 
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right

from collections import deque


from collections import Counter

from itertools import accumulate,combinations,permutations

from heapq import heapify,heappop,heappush


from functools import lru_cache

from decimal import Decimal

def input(): 
    x=sys.stdin.readline()
    return x[:-1] if x[-1]=="\n" else x
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False): 
    inds=sorted(range(len(s)), key=lambda k: s[k])
    if return_sorted: return inds, [s[i] for i in inds]
    return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
    K,N,M=len(B),len(A),len(B[0])
    return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
    N,size=len(v),len(M)
    return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
    n,m=len(M),len(M[0])
    return [[M[j][i] for j in range(n)] for i in range(m)]
def main():
    mod = 1000000007
    

    
    
    
    
    

    s=input()
    t=input()
    cnt=0
    for si,ti in zip(s,t):
        if si!=ti:cnt+=1

    print(cnt)

if __name__ == "__main__":
    main()

Solution (Python):
def main():
    s = input()
    t = input()
    ans = 0
    for i in range(len(s)):
        if s[i] != t[i]:
            ans += 1
    print(ans)

if __name__ == "__main__":
    main()

Solution (Python):
print(sum(si != ti for si, ti in zip(input(), input())))

Solution (Python):
s=input()
t=input()

cnt=0
for i in range(len(s)):
    if s[i]!=t[i]:
        cnt+=1
print(cnt)

Solution (Python):
s = input()
t = input()
n = len(s)
ans = 0
for i in range(n):
    if s[i] != t[i]:
        ans+= 1
        
print(ans)

Solution (Python):

S=input()
T=input()

ans=0

for i in range(len(S)):
    if S[i]!=T[i]:
        ans+=1

print(ans)

Solution (Python):
import sys
input = sys.stdin.readline

S = input().rstrip()
T = input().rstrip()

L = len(S)
ans = 0
for i in range(L):
    if S[i] != T[i]:
        ans += 1
print(ans)

Solution (Python):
import sys
input = sys.stdin.readline


def readstr():
    return input().strip()


def readint():
    return int(input())


def readnums():
    return map(int, input().split())


def readstrs():
    return input().split()


def main():
    S = readstr()
    T = readstr()
    ans = 0
    for i in range(len(S)):
        if S[i] != T[i]:
            ans += 1

    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")

s = input()
t = input()

cnt = 0

for i in range(len(s)):
    if s[i] != t[i]:
        cnt += 1

print(cnt)

Solution (Python):


import sys
import math
import itertools
import collections

def solve(S,T):
    counter = 0
    for s,t in zip(S,T):
        if s != t:
            counter += 1
    return counter
def main():
    S = input()
    T = input()
    
    print(solve(S,T))

if __name__ == "__main__":
    main()

Solution (Python):



import sys
from collections import defaultdict, deque
from heapq import heappush, heappop
import math
import bisect
input = sys.stdin.readline




s = input()
t = input()

ans = 0
for i in range(len(s)):
    if s[i] == t[i]:
        pass
    else:
        ans += 1

print(ans)

Solution (Python):
s = input()
t = input()

ans = 0
for i in range(len(s)):
    if s[i] != t[i]:
        ans += 1

print(ans)

Solution (Python):
S = list(input())
T = list(input())
c=0
for x, y in zip(S, T):
    c += 1-(x==y)
print(c)

Solution (Python):
S=input()
T=input()
N=len(S)

U=0
for i in range(N):
    if S[i]!=T[i]:
        U+=1
print(U)

Solution (Python):
s = input()
t = input()
counter = 0
for i in range(len(s)):
    if s[i] != t[i] :
        counter += 1
print(counter)

Solution (Python):
S = input()
T = input()

ans = 0
for s, t in zip(S, T):
    if s != t:
        ans += 1
print(ans)

Solution (Python):
import sys
readline = sys.stdin.readline

def solve():
    S = readline().rstrip()
    T = readline().rstrip()

    print(sum(1 for s,t in zip(S, T) if s != t))

solve()

Solution (Python):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    s = input()
    t = input()
    ans = 0

    for ch1, ch2 in zip(s, t):
        if ch1 != ch2:
            ans += 1

    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
s = str(input())
t = str(input())
l = len(s)
c = 0
for i in range(l):
  if s[i] != t[i]:
    c += 1
print(c)

Solution (Python):
s = input()
t = input()

cnt = 0
for i in range(len(s)):
    if s[i] != t[i]:
        cnt += 1

print(cnt)

Solution (Python):
def main():
    S = input()
    T = input()
    N = len(S)
    ans = 0
    for i in range(N):
        if S[i] != T[i]:
            ans += 1
    print(ans)
if __name__ == '__main__':
    main()

Solution (Python):
S = input()
T = input()
N = len(S)
cnt = 0
for i in range(N):
    if S[i] != T[i]:
        cnt += 1
print(cnt)

Solution (Python):
import sys

def solve():
      input = sys.stdin.readline
      S = input().strip("\n")
      T = input().strip("\n")
      a = 0
      for i in range(len(S)):
            if S[i] != T[i]: a += 1
      print(a)

      return 0

if __name__ == "__main__":
      solve()

Solution (Python):
s = input() 
t = input() 
n = len(s)
ans = 0
for i in range(n):
    if s[i]!=t[i]:
        ans+=1

print(ans)

Solution (Python):
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10 ** 8)
from itertools import accumulate
from itertools import permutations
from itertools import combinations
from collections import defaultdict
from collections import Counter
import fractions
import math
from collections import deque
from bisect import bisect_left
from bisect import bisect_right
from bisect import insort_left
import itertools
from heapq import heapify
from heapq import heappop
from heapq import heappush
import heapq
from copy import deepcopy
from decimal import Decimal
alf = list("abcdefghijklmnopqrstuvwxyz")
ALF = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")

INF = float("inf")


S = list(input())[:-1]
T = list(input())[:-1]
N = len(S)
ans = N
for i in range(N):
    if S[i] == T[i]:
        ans -= 1
print(ans)

Solution (Python):
S = input()
T = input()
ans = 0
for s, t in zip(S, T):
    if s != t:
        ans += 1
print(ans)

Solution (Python):
S=input()
T=input()
res=0
for i in range(len(S)):
    res+=(S[i]!=T[i])

print(res)

Solution (Python):
s = input()
t = input()
ans = 0
for i in range(len(s)):
    if s[i]!=t[i]:
        ans += 1
print(ans)

Solution (Python):
s = input()
t = input()

ret = 0
for i, ch in enumerate(s):
    if t[i] != ch:
        ret += 1

print(ret)

Solution (Python):
s = input()
t = input()

ans=0
for i in range(len(s)):
    if s[i]!=t[i]:
        ans+=1
print(ans)

Solution (Python):
s=input()
t=input()
ans=0
for i in range(len(s)):
  if s[i]!=t[i]:
    ans+=1
    
print(ans)

Solution (Python):
s = list(input())
t = list(input())
cnt=0
n=len(s)
for i in range(n):
    if s[i]!=t[i]:
        cnt+=1
print(cnt)

Solution (Python):
s = input()
t = input()
count = 0
for c1, c2 in zip(s, t):
    if c1 != c2:
        count += 1

print(count)

Solution (Python):
s = input()
t = input()

count = 0
for i in range(len(s)):
    if s[i] != t[i]:
        count += 1

print(count)

Solution (Python):
S = input().strip()
T = input().strip()
ans = 0
for i in range(len(S)):
    if S[i] != T[i]:
        ans += 1
print(ans)

Solution (Python):

import sys


def solve(S: str, T: str):
    count = 0
    for s, t in zip(S, T):
        if s != t:
            count += 1
    print(count)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    S = next(tokens)  
    T = next(tokens)  
    solve(S, T)

if __name__ == '__main__':
    main()

Solution (Python):
s = input()
t = input()

ans = 0
for i in range(len(s)):
    if s[i] != t[i]:
        ans += 1

print(ans)

Solution (Python):
S = input()
T = input()
ans = 0
for s, t in zip(S, T):
    ans += (s!=t)
print(ans)

Solution (Python):
s = input()
t = input()
res = 0
for i in range(len(s)):
    if s[i]!=t[i]:
        res += 1
print(res)

Solution (Python):
from sys import stdin
from sys import setrecursionlimit
setrecursionlimit(10 ** 7)

s = input()
t = input()
point = 0

for i,j in zip(s,t):
    if i != j:
        point += 1

print(point)

Solution (Python):



def mp(): return map(int, input().split())
def lmp(): return list(map(int, input().split()))

s = list(input())
t = list(input())
ans = 0
for i in range(len(s)):
    if s[i] != t[i]:
        ans += 1
print(ans)

Solution (Python):


import sys

class BMinorChange:
    def solve(self, tc=0):
        s = input()
        t = input()
        ans = 0
        for i in range(len(s)):
            if s[i] != t[i]:
                ans += 1

        print(ans)


solver = BMinorChange()
input = sys.stdin.readline

solver.solve()

Solution (Python):
S = input()
T = input()
count = 0
for i in range(len(S)):
    if S[i]!=T[i]:
        count+=1

print(count)

Solution (Python):
S = input()
T = input()
print(len([1 for s, t in zip(S, T) if s != t]))

Solution (Python):
S = input()
T = input()
ans = 0
for s,t  in zip(S, T):
    if s != t:
        ans += 1
print(ans)

Solution (Python):
S =list(input())
T =list(input())
count =0
for i,j in zip(S,T):
    if(i!=j):
        count +=1
print(count)

Solution (Python):
s = input()
t = input()
n = len(s)
res = 0
for i in range(n):
    if s[i] != t[i]:
        res += 1

print(res)

Solution (Python):
S = input()
T = input()
N = len(S)
ans = 0
for i in range(N):
  if(S[i]!=T[i]):
    ans += 1
print(ans)

Solution (Python):
s = input()
t = input()

ans = 0
for i in range(len(s)):
    if s[i] != t[i]:
        ans += 1

print(ans)

Solution (Python):
s = input()
t = input()
l = len(s)
ans = 0
for i in range(l):
  if s[i] != t[i]:
    ans += 1
print(ans)

Solution (Python):
s = input()
t = input()
ans = 0
for i in range(len(s)):
    if s[i] == t[i]:
        pass
    else:
        ans += 1
print(ans)

Solution (Python):
S = input()
T = input()
N = len(S)
cnt=0
for i in range(N):
    if S[i]!=T[i]:
        cnt+=1
print(cnt)

Solution (Python):
def main():
    
    
    
    S=input()
    T=input()
    ans=0
    for i in range(len(T)):
        if S[i]!=T[i]:
            ans+=1
    print(ans)

main()

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip()

S = input()
T = input()

ans = 0
for i in range(len(S)):
    if S[i] != T[i]:
        ans += 1
print(ans)

Solution (Python):
from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:list(map(int,stdin.readline().split()))

s=input()
t=input()

ans=0
for i in range(len(s)):
  if s[i]!=t[i]:
    ans+=1

print(ans)

Solution (Python):
S=input()
T=input()
a=0
for i in range(len(S)):
    if S[i]!=T[i]:
        a+=1
print(a)

Solution (Python):



def main():
    s = input()
    t = input()

    ans = 0
    for i in range(len(s)):
        if s[i] != t[i]:
            ans += 1
    
    return ans


print(main())

Solution (Python):
s = input()
t = input()
ans = 0
for i in range(len(s)):
    if s[i]!=t[i]:
        ans += 1
print(ans)

Solution (Python):
s=input()
t=input()
cnt=0
for i in range(len(s)):
    if s[i]!=t[i]:
        cnt+=1
print(cnt)

Solution (Python):
s = input()
t = input()

ans = 0

for i in range(len(s)):
    if s[i] != t[i]:
        ans += 1

print(ans)

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 7)

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

S = list(input())
T = list(input())
L = len(S)

ans = 0
for i in range(L):
    if S[i] == T[i]:
        continue
    ans += 1

print(ans)

Solution (Python):

import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial
from bisect import bisect_left 
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep='\n')

S = input()
T = input()

cnt = 0
for s, t in zip(S, T):
    if s!=t:
        cnt += 1
print(cnt)

Solution (Python):
import sys
sys.setrecursionlimit(10**6)
from math import floor,ceil,sqrt,factorial,log,gcd
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
mod = 10 ** 9 + 7
inf = float('inf')
ninf = -float('inf')



 
import numpy as np
from scipy.sparse.csgraph import shortest_path, floyd_warshall, dijkstra, bellman_ford, johnson
from scipy.sparse import csr_matrix

 

def ii(): return int(sys.stdin.readline().rstrip()) 
def mii(): return map(int,sys.stdin.readline().rstrip().split())
def limii(): return list(mii()) 
def lin(n:int): return [ii() for _ in range(n)]
def llint(n: int): return [limii() for _ in range(n)]

def ss(): return sys.stdin.readline().rstrip() 
def mss(): return sys.stdin.readline().rstrip().split()
def limss(): return list(mss()) 
def lst(n:int): return [ss() for _ in range(n)]
def llstr(n: int): return [limss() for _ in range(n)]





s=list(ss())
t=list(ss())
ans=0
for i in range(len(s)):
    if s[i]!=t[i]:
        ans+=1
print(ans)

Solution (Python):
s = input()
t = input()
print(sum(1 for x, y in zip(s, t) if x != y))

Solution (Python):
S = input()
T = input()
res = 0

for i in range(len(S)):
    if S[i] != T[i]:
        res += 1

print(res)

Solution (Python):
import sys
from collections import deque,Counter
import numpy as np
import math
sys.setrecursionlimit(10**6)
def S(): return sys.stdin.readline().rstrip()
def SL(): return map(str,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def IL(): return map(int,sys.stdin.readline().rstrip().split())

def Main():
    s = S()
    t = S()
    ans = 0
    for i in range(len(s)):
        if s[i]!=t[i]:
            ans += 1
    print(ans)
    return

if __name__=='__main__':
    Main()

Solution (Python):
s = input()
t = input()

n = len(s)
cnt = 0
for i in range(n):
    if s[i] != t[i]:
        cnt += 1
print(cnt)

Solution (Python):
s = input()
t = input()
n = len(s)
ans = 0
for i in range(n):
  if s[i] != t[i]:
    ans += 1
print(ans)

Solution (Python):
def main():
    s = input()
    t = input()
    n = len(s)
    cnt = 0
    for i in range(n):
        if s[i] != t[i]:
            cnt += 1
    print(cnt)


main()

Solution (Python):
S=input()
T=input()
ans=0
for s,t in zip(S,T):
    if s!=t:
        ans+=1
print(ans)

Solution (Python):
S = input()
T = input()
ans = 0
for s, t in zip(S, T):
    if s != t:
        ans += 1
print(ans)

Solution (Python):
S=input()
T=input()
ans=0
for i in range(len(S)):
    if S[i]==T[i]:
        continue
    ans+=1

print(ans)

Solution (Python):
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): 
	return list(map(int,input().split()))
def m(): 
	return map(int,input().split())
def onem(): 
	return int(input())
def s(x): 
	a = []
	if len(x) == 0:
		return []
	aa = x[0]
	su = 1
	for i in range(len(x)-1):
		if aa != x[i+1]:
			a.append([aa,su])
			aa = x[i+1]
			su = 1
		else:
			su += 1
	a.append([aa,su])
	return a
def jo(x): 
	return " ".join(map(str,x))
def max2(x): 
	return max(map(max,x))
def In(x,a): 
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False

def pow_k(x, n):
    ans = 1
    while n:
        if n % 2:
            ans *= x
        x *= x
        n >>= 1
    return ans

"""
def nibu(x,n,r):
	ll = 0
	rr = r
	while True:
		mid = (ll+rr)//2

	if rr == mid:
		return ll
	if (ここに評価入れる):
		rr = mid
	else:
		ll = mid+1
"""

s = input()[:-1]
t = input()[:-1]

co = len(s)

for i in range(len(s)):
	if s[i] == t[i]:
		co -= 1
print(co)

Solution (Python):
import sys
import heapq
import re
from itertools import permutations
from bisect import bisect_left, bisect_right
from collections import Counter, deque
from math import factorial, sqrt, ceil, gcd
from functools import lru_cache, reduce
from decimal import Decimal
INF = 1 << 60
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)


class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())


def dijkstra_heap(s, edge, n):
    
    d = [10**20] * n
    used = [True] * n 
    d[s] = 0
    used[s] = False
    edgelist = []
    for a,b in edge[s]:
        heapq.heappush(edgelist,a*(10**6)+b)
    while len(edgelist):
        minedge = heapq.heappop(edgelist)
        
        if not used[minedge%(10**6)]:
            continue
        v = minedge%(10**6)
        d[v] = minedge//(10**6)
        used[v] = False
        for e in edge[v]:
            if used[e[1]]:
                heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
    return d


def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr


def lcm(x, y):
    return (x * y) // gcd(x, y)


def lcm_list(numbers):
    return reduce(lcm, numbers, 1)


def gcd_list(numbers):
    return reduce(gcd, numbers)


def is_prime(n):
    if n <= 1:
        return False
    p = 2
    while True:
        if p ** 2 > n:
            break
        if n % p == 0:
            return False
        p += 1
    return True



def eratosthenes(limit):
    A = [i for i in range(2, limit+1)]
    P = []

    while True:
        prime = min(A)
        
        if prime > sqrt(limit):
            break
            
        P.append(prime)
            
        i = 0
        while i < len(A):
            if A[i] % prime == 0:
                A.pop(i)
                continue
            i += 1
            
    for a in A:
        P.append(a)
            
    return P


def permutation_with_duplicates(L):

    if L == []:
        return [[]]

    else:
        ret = []

        
        S = sorted(set(L))

        for i in S:

            data = L[:]
            data.remove(i)

            for j in permutation_with_duplicates(data):
                ret.append([i] + j)

        return ret



s = input()
t = input()
n = len(s)
ans = 0
for i in range(n):
    if s[i] != t[i]:
        ans += 1
print(ans)

Solution (Python):
S = input()
T = input()

res = 0
for i in range(len(S)):
    if S[i] != T[i]:
        res += 1

print(res)

Solution (Python):
def main():
    s=input()
    t=input()
    res=0
    for i in range(len(s)):
        if(s[i]!=t[i]):
            res+=1
    print(res)
if __name__ == '__main__':
    main()

Solution (Python):
S = input()
T = input()

a = 0
for i in range(len(S)):
    if S[i] != T[i]:
        a += 1
print(a)

Solution (Python):
s = str(input())
t = str(input())

cnt = 0
for i in range(len(s)):
    if s[i] != t[i]:
        cnt += 1

print(cnt)

Solution (Python):
import sys
readline = sys.stdin.readline

def main():
    S = readline().rstrip()
    T = readline().rstrip()
    res = 0
    for s, t in zip(S, T):
        if s != t:
            res += 1
    
    print(res)

if __name__ == '__main__':
    main()

Solution (Python):
from sys import stdin
from collections import defaultdict as dd
from collections import deque as dq
import itertools as it
from math import sqrt, log, log2
from fractions import Fraction





s = input()
t = input()

count = 0
for i, j in zip(s, t):
    if i!=j:
        count += 1

print(count)

Solution (Python):
S = input()
T = input()
ans = 0
for i in range(len(S)):
    if S[i] != T[i]:
        ans += 1
print(ans)

Solution (Python):
s=input()
t=input()
c=0
for i in range(len(s)):
  if s[i]!=t[i]:
    c+=1
print(c)

Solution (Python):
import os
import sys
from io import BytesIO, IOBase

BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")



def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD = 10**9+7

Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()

s = ri()
t = ri()

ans = 0
for i in range(len(s)):
    if s[i] != t[i]:
        ans+=1

print(ans)

Solution (Python):

import sys
input = sys.stdin.readline

s = input().rstrip()
t = input().rstrip()

ans = 0
for si, ti in zip(s, t):
    if si != ti:
        ans += 1
print(ans)

Solution (Python):
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**6)
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

s = ns()
t = ns()
ans = 0
for i in range(len(s)):
    if s[i] != t[i]:
        ans += 1

print(ans)

Solution (Python):
S = input()
T = input()
ans = 0
for i in range(len(S)):
    if S[i] != T[i]:
        ans += 1
print(ans)

Solution (Python):
a = input()
b = input()

c = 0
for i in range(max(len(a), len(b))):
  if a[i] != b[i]:
    c += 1
print(c)

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    S = readline().strip()
    T = readline().strip()
    
    ans = 0
    for s, t in zip(S, T):
        if s != t:
            ans += 1

    print(ans)
    return


if __name__ == '__main__':
    main()

Solution (Python):
s = input()
t = input()
ans = 0

for i in range(len(s)):
    if s[i] != t[i]:
        ans += 1

print(ans)

Solution (Python):
def main():
    s = input()
    t = input()

    ans = 0
    for a, b in zip(s, t):
        if a != b:
            ans += 1

    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
S = input()
T = input()
res = 0
for i in range(len(S)):
    if S[i] != T[i]:
        res += 1
print(res)

Solution (Python):
s = input()
t = input()

ans = 0

for i in range(len(s)):
    if s[i] != t[i]:
        ans += 1
        
print(ans)

Solution (Python):
S = input()
T = input()

ans = 0
for s, t in zip(S, T):
    if s != t:
        ans += 1

print(ans)

Solution (Python):
from collections import defaultdict

def readInt():
	return int(input())
def readInts():
	return list(map(int, input().split()))
def readChar():
	return input()
def readChars():
	return input().split()

s = input()
t = input()
ans = 0
for i in range(len(s)):
	if s[i]!=t[i]:
		ans+=1

print(ans)

Solution (Python):
s = input().rstrip()
t = input().rstrip()

n = 0
for i in range(len(s)):
    if s[i] != t[i]:
        n += 1
print(n)

Solution (Python):
s= input()

t = input()
ans = 0
for i in range(len(s)):
  if s[i]==t[i]:
    pass
  else:
    ans+=1
    
print(ans)

Solution (Python):

from collections import deque, Counter
from heapq import heappop, heappush
from bisect import bisect_right

def main():
    S = input()
    T = input()
    ans = 0
    for i in range(len(S)):
        if S[i] != T[i]:
            ans += 1
    print(ans)

if __name__ == "__main__":
    main()

Solution (Python):
s = input()
t = input()

ans = 0
for i in range(len(s)):
    if s[i] != t[i]:
        ans += 1
print(ans)

Solution (Python):
S = input()
T = input()

cnt = 0
for i in range(len(S)):
    if S[i] != T[i]:
        cnt += 1
print(cnt)

Solution (Python):
S = input()
T = input()

ans = 0
for i in range(len(S)):
    if S[i] != T[i]:
        ans += 1
print(ans)

Solution (Python):
s = input()
t = input()

ans = 0
for i in range(len(s)):
    if s[i] != t[i]:
        ans += 1
print(ans)

Solution (Python):
import sys
sys.setrecursionlimit(10000000)
MOD = 10 ** 9 + 7
INF = 10 ** 15

def main():
    S = input()
    t = input()
    ans = 0
    for i in range(len(S)):
        if S[i] != t[i]:
            ans += 1
    print(ans)

if __name__ == '__main__':
    main()

Solution (Python):
S = input()
T = input()

ans = 0
l = len(S)
for i in range(l):
  if S[i]!=T[i]:
    ans += 1
    
print(ans)

Solution (Python):
S = str(input())
T = str(input())

ans=0

for i in range(len(S)):
	if S[i]!=T[i]:
		ans+=1


print(ans)

Solution (Python):
S = input()
T = input()
ans = 0
for i in range(len(S)):
    if S[i] != T[i]:
        ans += 1
print(ans)

Solution (Python):

s = input()
t = input()
ans = 0
for i in range(len(s)):
    if s[i] != t[i]:
        ans += 1
print(ans)

Solution (Python):
s=input()
t=input()
ans=0
for i in range(len(s)):
    if s[i]!=t[i]:ans+=1
print(ans)

Solution (Python):
from sys import stdin
input = stdin.readline

s = input().rstrip()
t = input().rstrip()
n = len(s)
cnt = 0

for x in range(n):
    if s[x] != t[x]:
        cnt += 1

print(cnt)

Solution (Python):
s = input()
t = input()

ans = 0
for i in range(len(s)):
    if s[i] != t[i]:
        ans += 1
print(ans)

Solution (Python):


S = input()
T = input()

ret = 0

for i in range(len(S)):
    if S[i] != T[i]:
        ret += 1

print(ret)