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

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

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

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]:
        ans += 1
print(ans)

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

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
S = stdin.readline().rstrip()
T = stdin.readline().rstrip()
ans = 0
for s, t in zip(S, T):
    if s != t:
        ans += 1
print(ans)

Solution (Python):
S = input().lower()
T = input().lower()
count = 0
if len(S) == len(T):
    for i in range(len(S)):
        if S[i] == T[i]:
            count += 0
        else: 
            count += 1
    print(count)
else:
    print("try again")

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

Solution (Python):

s = str(input())
t = str(input())


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

print(answer)

Solution (Python):
import sys

def II(): return int(input())
def MI(): return map(int,input().split())
def LI(): return list(map(int,input().split()))
def TI(): return tuple(map(int,input().split()))
def RN(N): return [input().strip() for i in range(N)]


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()
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]:
        ans+=1
print(ans)

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

print(j)

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(a!=b for a,b in zip(input(),input())))

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

    return count

if __name__ == "__main__":
    s = str(input())
    t = str(input())
    print(change(s,t))

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

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):
a=input()
b=input()
n=len(a)

ans=0

for i in range(n):
  if a[i]!=b[i]:
    ans+=1
print(ans)

Solution (Python):
S = list(input())
T = list(input())
i = 0
counter = 0

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

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()
a = 0
for i in range(len(s)):
  if t[i] == s[i]:
    print("")
  elif((len(s)==len(t)) and (t[i]==s[i])):
    print(0)
  else:
    a+=1
print(a)

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()
counter=[i for i in range(len(S)) if S[i]==T[i] ]
print(len(S)-len(counter))

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):
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()
c=0
d=0
e= len(a)

while c<e:
  if b[c]== a[c]:
    c+=1
    d+=1
  else:
    c+=1
    continue
print(e-d)

Solution (Python):
s = input()
t = input()
ans = 0
for i, c in enumerate(s):
    if c != 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()
counter=[i for i in range(len(S)) if S[i]==T[i] ]
print(len(S)-len(counter))

Solution (Python):
s = list(input())
t = list(input())
ans = int(0)
for num in range(len(s)):
  if s[num] != t[num]:
    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,T,ans=list(input()),list(input()),0
for i in range(len(T)):
    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):




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

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

    print(ans)


if __name__ == "__main__":
    main()

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

for i in range(l):
  if S[i] == T[i]:
    l -= 1
  else:
    pass

print(l)

Solution (Python):
from sys import stdin
input = lambda: stdin.readline().rstrip("\r\n")
from collections import defaultdict as vector, deque as que
inin = lambda: int(input())
inar = lambda: list(map(int,input().split()))
from heapq import heappush as hpush,heappop as hpop

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

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

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

Solution (Python):
from sys import stdin
def main():
    
    readline=stdin.readline
    s=readline().strip()
    t=readline().strip()

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

    print(cnt)
    
if __name__=="__main__":
    main()

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

Solution (Python):

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

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

Solution (Python):
s = input()
t = input()
count = 0
sList = list(s)
tList = list(t)

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

print(count)

Solution (Python):
S=input()
T=input()
c=0
i=0
for al in S:

    if S[i]==T[i]:
        i+=1
    else:
        c+=1
        i+=1 
print(c)

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

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

print(cnt)

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

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

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

Solution (Python):
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()
ans = 0
for id in range(len(s)):
    if s[id] != t[id]: 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):
import sys


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


sys.setrecursionlimit(20000000)

MOD = 10 ** 9 + 7
INF = float("inf")


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


if __name__ == "__main__":
    main()

Solution (Python):
from sys import stdin
input = lambda: stdin.readline().rstrip("\r\n")
from collections import defaultdict as vector
from collections import deque as que
inin = lambda: int(input())
inar = lambda: list(map(int,input().split()))
from heapq import heappush as hpush,heappop as hpop

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

ans = 0

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

print(ans)

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

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

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

Solution (Python):
print(sum(c1 != c2 for c1, c2 in zip(input(), input())))

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

l=len(S)

ans=0

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

print(l-ans)

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

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

print(cmis)

Solution (Python):
s = list(map(str,input()))
t = list(map(str,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 s, t in zip(S, T):
  if s != t:
    count += 1
    
print(count)

Solution (Python):
import itertools
import functools
import math
from collections import Counter
from itertools import combinations
import re


S = input()
T = input()

l = len(S)

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

print(cnt)

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

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

print(ans)

Solution (Python):
s,t=input(),input()
ans=0
for i in range(len(s)):
    if s[i-1] == t[i-1]:
        pass
    else:
        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):
A = list(input()) 
B = list(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 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):
S = list(input())
T = list(input())
N = len(S)
count = 0
for i in range(0,N):
  if S[i] != T[i]:
    count = count + 1
  else:
    continue
print(count)

Solution (Python):
lista = list(input())
lista2 = list(input())
cont = 0
tam = len(lista)

for i in range(tam):
	if(lista[i] != lista2[i]):
		cont+=1

print(cont)

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):
l1 = input()
l2 = input()

res = 0

for i in range(len(l1)):
  if l1[i] != l2[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()

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

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

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

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

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

ans = 0
for c1, c2 in zip(s, t):
    if c1 != c2:
        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 = count + 0
	else:
		count = count + 1

print(count)

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

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

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


if __name__ == '__main__':
    solve()

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 += 1
print(ans)

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

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

print (count)

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

Solution (Python):
from sys import stdin, stdout, setrecursionlimit
from collections import deque, defaultdict, Counter
import math

rl = lambda: stdin.readline()
rll = lambda: stdin.readline().split()
rli = lambda: map(int, stdin.readline().split())
rlf = lambda: map(float, stdin.readline().split())

INF, NINF = float('inf'), float('-inf')

def main():
	S, T = rll()[0], rll()[0]
	ans = 0
	for a, b in zip(S, T):
		if a != b: ans += 1
	print(ans)
	stdout.close()

if __name__ == "__main__":
	main()

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

Solution (Python):
def count_diff(s,t) :
    lst_s = list(s)
    lst_t = list(t)
    len_s = len(lst_s)
    ng = 0
    for i in range(len_s) :
        if lst_s[i] != lst_t[i] :
            ng += 1
    print(ng)
        
s = input()
t = input()

count_diff(s,t)

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

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

print(num)

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

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

s1 = list(s)
t1 = list(t)

s2 = len(s1)
count = 0
for i in range(s2):
    if(s1[i] != t1[i]):
        s1[i] == t1[i]
        count += 1
        
print(count)

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

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 = 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):
def main():
    S = input().strip()
    T = input().strip()
    result = solve(S, T)
    print(result)


def solve(S, T) -> int:
    count = 0
    for i in range(len(S)):
        if S[i] != T[i]:
            count += 1
    return count


if __name__ == '__main__':
    main()

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

count = 0
for i in range(len(S)):
  if S[i] == T[i]:
  	continue
  else:
    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):
l1 = []
l2 = []

S = input()
T = input()

for s in S:
    l1.append(s)

for t in T:
    l2.append(t)

count = 0
count1 = 0
lenth = int(len(S))

while lenth > count1:

    if l1[count1] == l2[count1]:
        count1 += 1
    else:
        count += 1
        count1 +=1

print(count)

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

ans=0
for i in range(len(s)):
    if t[i]!=s[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):
a = input()
b = input()
list_a = []
list_b = []
score = 0
for n in a:
    list_a.append(n)
for m in b:
    list_b.append(m)
for i in range(0, len(list_a)):
    if list_a[i] != list_b[i]:
        score += 1
print(score)

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

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

s = list(s)
t = list(t)

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

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

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

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

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

print(sum)

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

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

print(count)

Solution (Python):
import sys

S = sys.stdin.readline().rstrip()
T = sys.stdin.readline().rstrip()

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

print(cnt)

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

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

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

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

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

print(count)

Solution (Python):
s = list(input());		  t = list(input())
print(sum([1 for i,j in zip(s,t) if i!=j]))

Solution (Python):
import sys
import heapq
import math
import fractions
import bisect
import itertools
from collections import Counter
from collections import deque
from operator import itemgetter
def input(): return sys.stdin.readline().strip()
def mp(): return map(int,input().split())
def lmp(): 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)

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(sum([x!=y for x,y in zip(S,T)]))

Solution (Python):
s=input()
t=input()
print(sum([1 for index,char in enumerate(s) if t[index]!=char]))

Solution (Python):
import numpy as np
import scipy.sparse as sps
import scipy.misc as spm
import collections as col
import functools as func
import itertools as ite
import fractions as frac
import math as ma
from math import cos,sin,tan,sqrt
import cmath as cma
import copy as cp
import sys
import re
sys.setrecursionlimit(10**7)
EPS = sys.float_info.epsilon
PI = np.pi; EXP = np.e; INF = np.inf
MOD = 10**9 + 7

def sinput(): return sys.stdin.readline().strip()
def iinput(): return int(sinput())
def imap(): return map(int, sinput().split())
def fmap(): return map(float, sinput().split())
def iarr(n=0):
    if n: return [0 for _ in range(n)]
    else: return list(imap())
def farr(): return list(fmap())
def sarr(n=0):
    if n: return ["" for _ in range(n)]
    else: return sinput().split()
def adj(n): return [[] for _ in range(n)]

class unionfind():
    def __init__(self, n):
        self.n = n
        
        self.parents = [-1] * n
    def find(self, x):
        if self.parents[x] < 0: return x
        self.parents[x] = self.find(self.parents[x])
        return self.parents[x]
    def union(self, x, y):
        x,y = self.find(x), 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())

s,t = sinput(),sinput()
n = len(s)

ans = 0
for i in range(n):
    ss,tt = s[i],t[i]
    if ss==tt: continue
    else: ans += 1
print(ans)

Solution (Python):
import sys







input = sys.stdin.readline
sys.setrecursionlimit(10**7)

inf = 10**17
mod = 10**9 + 7

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

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

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

def count_diff(a,b):

    cnt = 0
    for c1,c2 in zip(a, b):
        if c1 != c2:
            cnt += 1
    return cnt
    
print(count_diff(S, T))

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):
import bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
s = S()
t = S()
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 i in range(len(s)):
        if s[i] != t[i]:
            ans += 1
    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):


s = input()
t = input()
print(sum(1 for a, b in zip(s, t) if a != b))

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

print(cnt)

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

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

l = len(s)
n = 0

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

Solution (Python):
a = input()
b = input()
 
length = len(a)
 
i = 0
count = 0
 
while i < length:
  if a[i] != b[i]:
    count = count + 1
  i = i + 1
 
print(count)

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

length = len(a)

i = 0
count = 0

while i < length:
  if a[i] != b[i]:
    count = count + 1
  i = i + 1

print(count)

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

def main():
    S = input().rstrip()
    T = input()

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

if __name__ == '__main__':
    main()

Solution (Python):
ii = lambda:int(input())
mi = lambda:list(map(int,input().split()))
ix = lambda x:list(input() for _ in range(x))
mix = lambda x:list(mi() for _ in range(x))
iix = lambda x:list(int(input()) for _ in range(x))


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

if __name__ == "__main__":
    resolve()

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

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

print(x)

Solution (Python):
import sys
from functools import reduce

def _main():
    s = sys.stdin.readline()
    t = sys.stdin.readline()

    print(reduce(lambda acc, _t: acc + (1 if _t[0] != _t[1] else 0), zip(s, t), 0))

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

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
from collections import defaultdict
from heapq import heappop, heappush
import itertools
from decimal import *

input = sys.stdin.readline

def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))
def inputStr(): return input()[:-1]

inf = float('inf')
mod = 1000000007




def main():
	S = inputStr()
	T = inputStr()

	ans = 0
	for i,val in enumerate(S):
		if val == T[i]:
			pass
		else:
			ans += 1

	print(ans)





if __name__ == "__main__":
	main()

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

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

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

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

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

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()
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-1] == T[-i-1]:
        pass
    else:
        count += 1

print (count)

Solution (Python):
s = input()
t = input()
l = len(s)
ans=0
for i in range(l):
    if t[i]!=s[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 c1, c2 in zip(s, t):
    if c1 != c2:
        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):
def main():
    S = str(input())
    T = str(input())
    a = int(0)
    for x in range(len(S)):
      if S[x]!=T[x]:
          a = a + 1
    print(int(a))
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()
S=list(S)
T=list(T)
j=0
for i in range(len(S)):
    if(S[i]!=T[i]):
        S[i]=T[i]
        j +=1
print(j)

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