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):
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())

count = 0

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

print(count)

Solution (Python):
one = input()
two = input()
letter_one = list(one)
letter_two = list(two)


ans = 0
for i in range(len(letter_one)):
    if letter_one[i] == letter_two[i]:
        ans += 0
    else:
        ans += 1
        
print(ans)

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):
ans = 0
for s, t in zip(input(), input()):
    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]:
        ans += 1

print(ans)

Solution (Python):
ans=0
for i,j in zip(input(),input()):
    if i!=j: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()
n=input()
ans=0
for i in range(len(n)):
  if s[i]!=n[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()
i = 0
count = 0
for s in S:
    if s != T[i]:
        count = count + 1
    i = i + 1
print(count)

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

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


print(count)

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

counter = 0
for index, character in enumerate(s):
    if t[index] != character:
        counter += 1
print(counter)

Solution (Python):
a = input()
b = input()
res=0
for i,j in zip(a,b):
  if i!=j:
    res+=1
print(res)

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

time = []

S_list = list(S)
T_list = list(T)

Len = (len(S))
listt = list(range(Len))

for ss in listt:
      if S[ss] ==T[ss]:
            None
      else:
            time.append(ss)

print(len(time))

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

res = 0

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

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):
s = list(input())
t = list(input())
cnt = 0
for (s1,t1) in zip(s,t):
  if s1 != t1:
    cnt += 1
print(cnt)

Solution (Python):
import sys


def input(): return sys.stdin.readline().strip()


def main():
    S = input()
    T = input()
    count = 0

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

    print(count)


if __name__ == "__main__":
    main()

Solution (Python):
S = input()
T = input()
S_chars = list(S)
T_chars = list(T)
i = 0
count = 0


for roop in S_chars:
    if not S_chars[i] == T_chars[i]:
        count += 1
    i += 1
print(count)

Solution (Python):
if __name__ == '__main__':
	s = input()
	t = input()
	cnt = 0
	for x,y in zip(s,t):
		if x != y:
			cnt += 1
	print(cnt)

Solution (Python):
s=input()
t=input()
ans=0
for i,j in zip(s,t):
    if i!=j: 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):
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()
U = S + T[::-1]
count = 0
for i in range(int(len(U)/2)):
  if U[i] != U[-(i+1)]:
    count += 1
print(count)

Solution (Python):
S = list(input())
T = list(input())
count = 0

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

print(count)

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

a = 0
b = len(s) 

for i in range(0,b):
    if s[i] != t[i]:
        a += 1

print(a)

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

def solve(a,b):
    ans = 0
    for s,t in zip(S,T):
        if s != t:
            ans += 1
    return ans

print(solve(S,T))

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

if S == T:
    print(0)
else:
    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()

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

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()
count = 0
for i in range(len(s)):
    if s[i] != t[i]:
        count += 1
print(count)

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

Solution (Python):
s = list(input())
t = list(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 = ans + 1
 
print(ans)

Solution (Python):
S = list(input())
T = list(input())
x = 0

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

print(x)

Solution (Python):
def main():
    s = input()
    t = input()
    ans = 0
    for i,j in zip(s, t):
        if i != j:
            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 = ans + 1
print(ans)

Solution (Python):

import sys


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



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)  
    print(solve(S, T))

if __name__ == '__main__':
    main()

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

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

Solution (Python):
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):
S = input()
T = input()

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

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

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

count = 0
for i in range(len(s)):
  
  if s[i] != t[i]:
    count = 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()
t = input()
n = len(s)
ans = 0
for i in range(n):
  if s[i] != t[i]:
    ans += 1
print(ans)

Solution (Python):

a= []
b= []

a= input(" ")

d= len(a)

b= input(" ")

e= 0
for i in range(0, d):
    if a[i]==b[i]:
        pass
    else:
        e= e+1
print(e)

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())

dif_count = 0
for i in range(len(s)):
  if s[i] != t[i]:
    dif_count+=1
print(dif_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()

count = 0

for (elm_s, elm_t) in zip(s, t):
    if (elm_s != elm_t):
        count+=1

print(count)

Solution (Python):
x = str(input())
y = str(input())
cnt = 0
for i,j in zip(x,y):
	if i!=j:
		cnt+=1
print(cnt)

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

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

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

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

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):
a = input()
b = input()
ans = 0
for i in range(len(a)):
  if a[i] != b[i]:
    ans += 1
print(ans)

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

print(c)

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



count=0

for i in range(len(a)):
    if a[i]!=b[i]:
        count+=1

print(count)

Solution (Python):
s=input()
t=input()
ans=0
for ss,tt in zip(s,t):
    if ss==tt:
        ans+=1
print(len(s)-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()

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

print(count)

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()
count = 0
for i in range(len(S)):
    if S[i] != T[i]:
        count += 1
print(count)

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

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

N = len(S)

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

print(count)

Solution (Python):
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):
s=input()
t=input()
c=0
for i in range(len(s)):
    if s[i:i+1]!=t[i:i+1]:
        c+=1
print(c)

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

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

ans = len(s)
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(0, 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()
cnt = 0
for i in range(len(s)):
    if s[i] != t[i]:
        cnt += 1


print(cnt)

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

for x, y in zip(S, T):
    if x != y:
        change += 1

print(change)

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(0,len(S)):
    if S[i] != T[i]:
        ans += 1
print(ans)

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

count = 0

for i in range(len(s)):
    if not s[i] == t[i]:
        count = 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()

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,j in zip(s,t):
    if i!=j:
        ans+=1
print(ans)

Solution (Python):
from math import floor,ceil,sqrt,factorial,log
from collections import Counter, deque
from functools import reduce
import numpy as np
import itertools
def S(): return input()
def I(): return int(input())
def MS(): return map(str,input().split())
def MI(): return map(int,input().split())
def FLI(): return [int(i) for i in input().split()]
def LS(): return list(MS())
def LI(): return list(MI())
def LLS(): return [list(map(str, l.split() )) for l in input()]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def LLSN(n: int): return [LS() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]

s = S()
t = S()

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):
n=input()
m=input()

count=0
for x in range(len(m)):
  if(n[x]!=m[x]):
    count=count+1;
    
print(count)

Solution (Python):
count = 0
def main():
  global count
  s = input()
  t = input()
  for i in zip(s,t):
    if i[0] != i[1]:
      count += 1
  print(count)    
  
  
  
  
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()
count=0
for (i,j) in zip(s,t):
  if i != j:
    count+=1
print(count)

Solution (Python):
a = input()
b = input()
c = 0
for x,y in zip(a,b):
    if x != y:
        c += 1
print(c)

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

Solution (Python):
s = input()
t = input()
cnt = 0
for (i,j) in zip(s,t):
  if i!=j: cnt +=1 
print(cnt)

Solution (Python):
import sys
readline = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7

INF = 10**18
eps = 10**-7

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

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()

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

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

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

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

def int1(x): return int(x) - 1
def II(): return int(input())
def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def MS(): return input().split()
def LS(): return list(input())
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def printlist(lst, k=' '): print(k.join(list(map(str, lst))))
INF = float('inf')







def solve():
    S = LS()
    T = LS()

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

    print(ans)
if __name__ == '__main__':
    solve()

Solution (Python):
inword = input()
outword = input()
answer = 0

for i in range(len(inword)):
    if inword[i] != outword[i]:
        answer += 1

print(answer)

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

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
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7

S, T = SR(2)

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

print(counter)

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

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

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

Solution (Python):
import itertools
import math
import fractions
import functools
import copy
from collections import deque
from functools import reduce
from decimal import Decimal


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


if __name__ == '__main__':
    main()

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()
count=0
for i in range(len(S)):
  if S[i]!=T[i]:
    count+=1
print(count)

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

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):
a = input()
b = input()
count=0
for i in range(len(a)):
  if a[i] !=b[i]:
    count +=1
print(count)

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

Solution (Python):
ans = 0
for s, t in zip(input(), input()):
    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]:
    ans = ans + 1
print(ans)

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()
count = 0

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

print(count)

Solution (Python):
input1 = input()
input2 = input()
diff = 0;
for i in range (len(input1)):
  if input1[i] != input2[i]:
    diff = diff + 1
print(diff)

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

Solution (Python):
def main():
    a = list(input())
    b = list(input())
    contador = 0
    for i in range(len(a)):
        if a[i] != b[i]:
            contador += 1

    print(contador)


if __name__ == "__main__":
    main()

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

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

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()
count = 0

for i in range(len(S)):
    if S[i] != T[i]:
        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()
count = 0
j =0
for i in S:
  if i != T[j]:
    count +=1
  j+=1

print(count)

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

count=0
j=0

for i in s:
    if i!=t[j]:
        count+=1
    j+=1

print(count)

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

k=0

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

print(k)

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random,resource

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)


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

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

    return r


print(main())

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

print(len([1 for a in zip(s, t) if a[0] != a[1]]))

Solution (Python):
a = input()
b = input()
cnt = 0
for i in range(len(a)):
    if a[i] != b[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):
"""
    Satwik_Tiwari ;) .
    4th july , 2020  - Saturday
"""



from __future__ import division, print_function

from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase


import bisect
from heapq import *
from math import *
from collections import deque
from collections import Counter as counter  
from itertools import combinations as comb 
from itertools import permutations as permutate
from bisect import bisect_left as bl


from bisect import bisect_right as br
from bisect import bisect





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")


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)






mod = 1000000007
def inp(): return sys.stdin.readline().rstrip("\r\n") 
def out(var): sys.stdout.write(str(var))  
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())

def zerolist(n): return [0]*n
def nextline(): out("\n")  
def testcase(t):
    for p in range(t):
        solve()
def printlist(a) :
    for p in range(0,len(a)):
        out(str(a[p]) + ' ')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(a,b):
    ans = 1
    while(b>0):
        if(b%2==1):
            ans*=a
        a*=a
        b//=2
    return ans
def ncr(n,r): return factorial(n)//(factorial(r)*factorial(max(n-r,1)))
def isPrime(n) : 
    if (n <= 1) : return False
    if (n <= 3) : return True
    if (n % 2 == 0 or n % 3 == 0) : return False
    i = 5
    while(i * i <= n) :
        if (n % i == 0 or n % (i + 2) == 0) :
            return False
        i = i + 6
    return True



def bs(a,l,h,x):
    while(l<h):
        
        mid = (l+h)//2
        if(a[mid] == x):
            return mid
        if(a[mid] < x):
            l = mid+1
        else:
            h = mid
    return l

def sieve(a): 
    
    for i in range(3,((10**6)+1),2):
        a[i] = 1
    
    for i in range(3,((10**6)+1),2):
        for j in range(i*i,((10**6)+1),i):
            a[j] = 0
    a[2] = 1 
    return (a)


def bfs(g,st):
    visited = [-1]*(len(g))
    visited[st] = 0
    queue = []
    queue.append(st)
    new = []
    while(len(queue) != 0):
        s = queue.pop()
        new.append(s)
        for i in g[s]:
            if(visited[i] == -1):
                visited[i] = visited[s]+1
                queue.append(i)
    return visited


def dfsusingstack(v,st):
    d = deque([])
    visited = [0]*(len(v))
    d.append(st)
    new = []
    visited[st] = 1
    while(len(d) != 0):
        curr = d.pop()
        new.append(curr)
        for i in v[curr]:
            if(visited[i] == 0):
                visited[i] = 1
                d.append(i)
    return new



def solve():
    a = list(inp())
    b = list(inp())
    cnt = 0
    for i in range(0,len(a)):
        if(a[i] == b[i]):
            continue
        else:
            cnt+=1
    print(cnt)


testcase(1)

Solution (Python):














a = [input() for i in range(2)]
i = 0
count = 0

while i<len(a[0]):
  if a[0][i]!=a[1][i]:
    count+=1
  i+=1

print(count)

Solution (Python):
a=[input() for i in range(2)]
i=0
count=0
while i<len(a[1]):
  if a[0][i] != a[1][i]:
    count+=1
  i+=1
print(count)

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

count = 0

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

print(count)

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

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):
N=input()
M=input()
count=0
for i in range(len(N)):
    if N[i]!=M[i]:
        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()

ans = 0

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

print(ans)

Solution (Python):
print(sum([not s == t for s, t in zip(input(), input())]))

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

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

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

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

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

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

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

Solution (Python):

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

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

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

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

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()

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

print(count)

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

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

Solution (Python):
inp = [input() for str in range(2)]

out = 0
for i in range(len(inp[0])):
	if inp[0][i] != inp[1][i]:
  		out += 1
        
print(out)

Solution (Python):
import sys

s = sys.stdin.readline().rstrip()
t = sys.stdin.readline().rstrip()

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

Solution (Python):
import sys
import time
import math
st = time.perf_counter()
def inpl():
    return list(map(int, input().split()))



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

print(ans)



ed = time.perf_counter()
print('time:', ed-st, file=sys.stderr)

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

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

ndif = sum(i != j for i, j in zip(s, t))
print(ndif)

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()
c = 0
for i in range(len(s)):
    if s[i]!=t[i]: c+=1
print(c)

Solution (Python):
S = [input() for _ in range(2)]
count = 0
for i in range(len(S[0])):
    if S[0][i] != S[1][i]:
        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 = str(input())
T = str(input())
c = 0
for i in range(len(S)):
    if S[i] != T[i]:
        c += 1
print(c)

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

for n in range(len(S)):
    if T[n] != S[n]:
        count += 1
print(count)

Solution (Python):
S = list(i for i in input())
T = list(i for i in input())

counter = 0

while(S != T):
    for i in range(len(S)):
        if S[i] != T[i]:
            S[i] = T[i]
            counter = counter + 1
        else:
            pass

print(counter)