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):
def main():
    import sys
    sys.setrecursionlimit(10**9)
    input = sys.stdin.readline

    s = input()
    t = input()

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

main()

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

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

Solution (Python):
if __name__ == '__main__':
    s= input()
    t=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())

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 cs, ct in zip(s, t):
  if cs != ct:
    count += 1
print(count)

Solution (Python):
from collections import deque
import math

def Next(): return input()
def NextInt(): return int(Next())
def NextInts(): return map(int,input().split())
def Nexts(): return map(str,input().split())
def NextIntList(): return list(map(int,input().split()))
def RowInts(n): return [input() for i in range(n)]

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

Solution (Python):

from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
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)]

sys.setrecursionlimit(1000000)

def main():
    S = input()
    T = input()
    ans = 0
    for (s, t) in zip(S, T):
        ans += 0 if s == t else 1
    print(ans) 

main()

Solution (Python):



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

    ret = 0

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

if __name__ == '__main__':
    main()

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

Solution (Python):









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

    count = 0

    for i, s in enumerate(S):
        t = T[i]

        if s != t:
            count += 1
    return count


def main():
    print(solve())


if __name__ == "__main__":
    main()

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 math  
from typing import Dict, List, Optional, Tuple, Union  


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


if __name__ == "__main__":
    S = input()
    T = input()
    main(S, T)

Solution (Python):
s1=list(input())

s2=list(input())

count = 0

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

Solution (Python):

S = list(input())
T = list(input())

print(sum([S[i] != T[i] for i in range(len(S))]))

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

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)

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):
import sys
input = lambda: sys.stdin.readline().rstrip()

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):
def main():
    s = input()
    t = input()

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

    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
def main():
    S = input()
    T = input()
    answer = len(S)

    for i in range(len(S)):
        if S[i] == T[i]:
            answer -= 1

    print(answer)


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)):
    cnt += (s[i] !=  t[i])
print(cnt)

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

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

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

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)
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
    return ans

if __name__ == '__main__':
    print(main())

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

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

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

Solution (Python):

import sys,io,os,time
from collections import defaultdict
from collections import OrderedDict
from collections import deque
from itertools import combinations
from itertools import permutations
import bisect,math,heapq
alphabet = "abcdefghijklmnopqrstuvwxyz"

input = sys.stdin.readline



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

Solution (Python):
import sys
input = sys.stdin.readline
def main():
    S = list(input().rstrip())
    T = list(input().rstrip())
    CNT = 0
    for i in range(len(S)):
        if S[i] != T[i]:
            CNT += 1
    print(CNT)


if __name__ == '__main__':
    main()

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

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

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

print(count)

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

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

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

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):
def getN():
    return int(input())
def getNM():
    return map(int, input().split())
def getList():
    return list(map(int, input().split()))

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()
ans = 0
for i, j in zip(s, t):
    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):
import sys

sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inm = lambda: map(int, sys.stdin.readline().split())
inl = lambda: list(inm())
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print("\033[33m", *a, "\033[0m", **dict(file=sys.stderr, **kw))

s = ins()
t = ins()


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


print(solve())

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

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

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

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 n in range(len(S)):
    if not S[n] == T[n]:
        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):
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()
ans = 0
for a,b in zip(s,t):
    if a != b:
        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):
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 s_i, t_i in zip(s, t):
    if s_i != t_i:
        ans += 1
print(ans)

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

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

if __name__ == "__main__":
    S = input()
    T = input()
    solve()

Solution (Python):

import sys

sysread = sys.stdin.readline
read = sys.stdin.read
sys.setrecursionlimit(10 ** 7)










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

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

if __name__ == "__main__":
    run()

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

Solution (Python):
import sys

def input(): return sys.stdin.readline().strip()
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 INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 19
MOD = 10 ** 9 + 7
EPS = 10 ** -10

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

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

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

def main():
    S = readline().strip()
    T = readline().strip()

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

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

Solution (Python):
from sys import stdin
import sys

S = input()
T = input()
cnt = 0
for i, v in enumerate(S):
    if T[i] != v:
        cnt += 1
print(cnt)

Solution (Python):
s1 = input()
s2 = input()
count = 0
for i in range(len(s1)):
    if s1[i] != s2[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):
def main():
    import sys
    input = sys.stdin.readline
    s = input().strip()
    t = input().strip()
    ans = 0
    for ss, tt in zip(s, t):
        if ss != tt:
            ans += 1
    print(ans)

if __name__ == '__main__':
    main()

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):
def main():
    S = input()
    T = input()
    n = len(S)
    count = 0
    for i in range(n):
        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()
ans = 0
for i, value in enumerate(S):
    if value != 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):
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 = input()
t = input()
ans = 0
for i in range(len(s)):
    if s[i] != t[i]: ans -= -1
print(ans)

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

Solution (Python):
s = list(input())
t = list(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
import math

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

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

Solution (Python):
from fractions import gcd
from collections import Counter, deque, defaultdict
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, merge
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
from itertools import accumulate, product, permutations, combinations

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()
s = list(S)
t = list(T)
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 T[i] != S[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):
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

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

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

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

print(sum([1 if S[i] != T[i] else 0 for i in range(len(S))]))

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

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

Solution (Python):
import sys

readline = sys.stdin.readline
readlines = sys.stdin.readlines
ns = lambda: readline().rstrip() 
ni = lambda: int(readline().rstrip()) 
nm = lambda: map(int, readline().split()) 
nl = lambda: list(map(int, readline().split())) 

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(t)):
    if s[i] != t[i]: ans += 1
print(ans)

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

S = input().rstrip()
T = input().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):
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()
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, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    S = SS()
    T = SS()

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

    print(ans)

if __name__ == '__main__':
    resolve()

Solution (Python):
def main():
    s = input()
    t = input()
    ans = sum(c1 != c2 for c1, c2 in zip(s, t))
    print(ans)


if __name__ == '__main__':
    main()

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

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(0, len(s)):
  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 not 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()

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 not s[i] == t[i]:
        ans += 1
print(ans)

Solution (Python):
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):
import math
from collections import defaultdict
ml=lambda:map(int,input().split())
ll=lambda:list(map(int,input().split()))
ii=lambda:int(input())
ip=lambda:list(input())
ips=lambda:input().split()

"""========main code==============="""

n=ip()
m=ip()
ans=0
for i in range(len(n)):
    if(n[i]!=m[i]):
        ans+=1
print(ans)

Solution (Python):
def main():
    S = input()
    T = input()
    count = 0
    for s, t in zip(S, T):
        if s != t:
            count += 1
    print(count)
if __name__ == '__main__':
    main()

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

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

print(count)

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

Solution (Python):
import sys

from bisect import bisect_left
from collections import defaultdict, Counter
inp = sys.stdin.readline
read = lambda: list(map(int, inp().strip().split()))





def solve():
	s = inp(); t = inp(); ans = 0
	for i in range(len(s)):
		ans += (s[i] != t[i])
	print(ans)


		

if __name__ == "__main__":
	solve()

Solution (Python):
def input_int():
    return map(int, input().split())

def one_int():
    return int(input())

def one_str():
    return input()

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

S=one_str()
T=one_str()

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

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

Solution (Python):
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): 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()
N = len(S)
cnt = 0
for i in range(N):
    cnt += (S[i] != T[i])

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

res = 0
for i, s in enumerate(S):
    if s != T[i]:
        res += 1

print(res)

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

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

print(sum([s[i] != t[i] for i in range(len(s))]))

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

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)


if __name__ == '__main__':
    resolve()

Solution (Python):
import sys

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

in_n = lambda: int(readline())
in_nn = lambda: map(int, readline().split())
in_nl = lambda: list(map(int, readline().split()))
in_na = lambda: map(int, read().split())
in_s = lambda: readline().rstrip().decode('utf-8')


def main():

    S = in_s()
    T = in_s()

    N = len(S)

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

    print(count)


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

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, math, itertools, collections, bisect 
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8') 
inf = float('inf') ;mod = 10**9+7 
mans = inf ;ans = 0 ;count = 0 ;pro = 1

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

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

Solution (Python):


import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi,factorial
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
inf = 10**17
mod = 10**9 + 7

s=SI()
t=SI()
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())
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()

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

print(ans)

Solution (Python):
import sys
def S(): return sys.stdin.readline().rstrip()
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())
INF = 1000000000000

s = S()
t = S()

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

print(count)