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 = input()
T = input()
ans = 0
for s,t in zip(S,T):
    ans += (s!=t)
print (ans)

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

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


def input(): return sys.stdin.readline().strip()
def I(): return int(input())
def LI(): return list(map(int, input().split()))
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 S(): return input()
def LS(): return input().split()


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

Solution (Python):
import math
import fractions
import collections
import itertools
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()
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 = 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=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 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()
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().strip()
t = input().strip()

cnt = 0
for cs, ct in zip(s, t):
    cnt += 0 if cs == ct else 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()

ans = 0
for si, ti in zip(s, t):
    if si != ti:
        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):
import sys
import math
from collections import deque

sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(input())
NMI = lambda: map(int, input().split())
NLI = lambda: list(NMI())
SI = lambda: input()


def make_grid(h, w, num): return [[int(num)] * w for _ in range(h)]


def main():
    S = SI()
    T = SI()
    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()

ans = 0
l = len(s)

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

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

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

count = 0
for s, t in zip(S, T):
	if s != t:
		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 = list(input())

t = list(input())

cnt = 0

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

Solution (Python):
def resolve():
    S = str(input())
    T = str(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 = 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):
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,t,c = raw_input(), raw_input(), 0
for u,v in zip(s,t):
	if u != v: 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()
ans = 0
for i in range(len(s)):
    if s[i] != t[i]:
        ans += 1

print(ans)

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

ans = 0

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

print(ans)

Solution (Python):
s = list(str(input()))
t = list(str(input()))
num = 0

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

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)
cnt = 0
for i in range(n):
    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()
k = len(s)
ans = 0
for i in range(k):
    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 = len(s)

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

print(ans)

Solution (Python):
import sys
import math
def II():
	return int(sys.stdin.readline())

def LI():
	return list(map(int, sys.stdin.readline().split()))

def MI():
	return map(int, sys.stdin.readline().split())

def SI():
	return sys.stdin.readline().strip()
s = SI()
t = SI()
count = 0
for i in range(len(s)):
	if s[i] !=t[i]:
		count+=1
print(count)

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

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

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

'''

'''

s = input().strip()
t = input().strip()
print(sum(1 if c1 != c2 else 0 for c1, c2 in zip(s, t)))

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

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

Solution (Python):

import numpy as np
import sys
from collections import deque
from collections import defaultdict
import heapq
import collections
import itertools
import bisect


def zz():
    return list(map(int, sys.stdin.readline().split()))


def z():
    return int(sys.stdin.readline())


def S():
    return sys.stdin.readline()


def C(line):
    return [sys.stdin.readline() for _ in range(line)]


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

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

Solution (Python):
from sys import stdin

A=stdin.readline()
B=stdin.readline()
count=0

for k in range(0,len(A)):
    if A[k]!=B[k]:
        count+=1

print(count)

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 = input()
t = input()
count = 0
i = 0
while i < len(s):
    if s[i] != t[i]:
        count+=1
    i+=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):
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.buffer.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.buffer.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

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

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

Solution (Python):
import math
import time
from collections import defaultdict, deque
from sys import stdin, stdout
from bisect import bisect_left, bisect_right
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 x,y in zip(s,t):
  if x != y:
    ans += 1
print(ans)

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

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

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

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

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

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












stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
MIN = -10 ** 9
MOD = 10 ** 9 + 7
INF = float("inf")
IINF = 10 ** 18

def solve():
    s = str(stdin.readline().rstrip())
    t = str(stdin.readline().rstrip())
    
    
    
    
    
    
    ans = 0
    for i in range(len(s)):
        if s[i] != t[i]:
            ans += 1
    print(ans)


if __name__ == '__main__':
    solve()

Solution (Python):

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

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


import sys
read = sys.stdin.read
readline = sys.stdin.readline

s = input()
t = input()

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

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

Solution (Python):
def main():
	k = list(str(input()))
	k2 = list(str(input()))
	ans = 0
	for i in range(len(k)):
		if k[i] == k2[i]:
			continue
		else:
			ans += 1
	print(ans)


if __name__ == '__main__':
	main()

Solution (Python):
s=input().rstrip('\n')
t=input().rstrip('\n')
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)):
    ans += (1 if s[i] != t[i] else 0)
print(ans)

Solution (Python):

def s0():return input()
def s1():return input().split()
def s2(n):return [input() for x in range(n)]
def s3(n):return [input().split() for _ in range(n)]
def s4(n):return [[x for x in s] for s in s2(n)]
def n0():return int(input())
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(input()) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]
def t3(n):return [tuple(int(x) for x in input().split()) for _ in range(n)]
def p0(b,yes="Yes",no="No"): print(yes if b else no)








s=s0()
t=s0()

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

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

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

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

print(ans)

Solution (Python):





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

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


def read():
    S = input().strip()
    T = input().strip()
    return S, T


def solve(S, T):
    count = 0
    for x, y in zip(S, T):
        if x != y:
            count += 1
    return count


if __name__ == '__main__':
    inputs = read()
    outputs = solve(*inputs)
    if outputs is not None:
        print("%s" % str(outputs))

Solution (Python):
import sys, os, math, bisect, itertools, collections, heapq, queue

from decimal import Decimal
from collections import defaultdict



sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)


MOD = 10 ** 9 + 7
MAX = float('inf')


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    A = iss()
    B = iss()

    ret = 0
    for a, b in zip(A, B):
        if a != b: ret+=1
    print(ret)


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):
Ss = input().rstrip()
Ts = input().rstrip()

ans = 0
for S, T in zip(Ss, Ts):
    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):
import sys, math
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7

S = rs()
T = rs()

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

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

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

print(ans)

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

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

Solution (Python):
S,T=input(),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 x in range(len(S)):
    if S[x] != T[x]:
        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()
N=len(S)
answer=0
for n in range(N):
    if S[n]!=T[n]:
        answer+=1
print(answer)

Solution (Python):

from collections import defaultdict
con = 10 ** 9 + 7; INF = float("inf")

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


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):
def examA():
    N = I()
    ans = N + N**2 + N**3
    print(ans)
    return

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

def examC():
    ans = 0
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    ans = 0
    print(ans)
    return

def examF():
    ans = 0
    print(ans)
    return

from decimal import getcontext,Decimal as dec
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(input())
def LI(): return list(map(int,sys.stdin.readline().split()))
def DI(): return dec(input())
def LDI(): return list(map(dec,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = dec("0.000000000001")
alphabet = [chr(ord('a') + i) for i in range(26)]
alphabet_convert = {chr(ord('a') + i): i for i in range(26)}

getcontext().prec = 28

sys.setrecursionlimit(10**7)

if __name__ == '__main__':
    examB()

"""
142
12 9 1445 0 1
asd dfg hj o o
aidn
"""

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

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

resolve()

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

import sys, re
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, log
from heapq import heappush, heappop, heapify, nlargest, nsmallest
def STR(): return list(input())
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def sortListWithIndex(listOfTuples, idx):   return (sorted(listOfTuples, key=lambda x: x[idx]))
def sortDictWithVal(passedDic):
    temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))
    toret = {}
    for tup in temp:
        toret[tup[0]] = tup[1]
    return toret
def sortDictWithKey(passedDic):
    return dict(OrderedDict(sorted(passedDic.items())))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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

Solution (Python):
def LI():return list(map(int,input().split()))
from collections import Counter, deque, defaultdict
from heapq import heappop, heappush
import numpy as np
import math



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

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

Solution (Python):
s, t = input(), 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 s, t in zip(S, T):
    if s != t:
        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):
import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline

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

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

Solution (Python):
def main():
    s = input()
    t = input()
    ans = 0
    for ss,tt in zip(s,t):
        if ss != tt:
            ans += 1
    print(ans)
    return
if __name__ == "__main__":
    main()

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()


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

sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))  
def LI2(): return list(map(int,sys.stdin.readline().rstrip()))  
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())  
def LS2(): return list(sys.stdin.readline().rstrip())  

S = LS2()
T = LS2()

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

print(ans)

Solution (Python):
str1 = input()
str2 = input()

diff_cnt = 0

for i in range(len(str1)):
    if str1[i] != str2[i]:
        diff_cnt += 1

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

if __name__ == '__main__':
    main()

Solution (Python):


S = str(input())
T = str(input())

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

print(ans)

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

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

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

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

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(2 * 10**6)


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


def main():
    S = input().strip()
    T = input().strip()
    print(len([False for s, t in zip(S, T) if s != t]))
    return


if __name__ == '__main__':
    main()

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

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

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

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

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

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

Solution (Python):
s=input()
t =input()
ans = 0
for i in range(len(s)):
         if s[i] != t[i]:
                  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):
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):
import sys
input=sys.stdin.readline
s=input().rstrip()
t=input().rstrip()
n=len(s)
ans=0
for i in range(n):
    if s[i]==t[i]:
        pass
    else:
        ans+=1
print(ans)

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

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

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

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

Solution (Python):
import sys

import math
import collections

import bisect
import itertools
import fractions

import copy

import decimal

import queue



sys.setrecursionlimit(10000001)
INF = 10 ** 16
MOD = 10 ** 9 + 7


ni = lambda: int(sys.stdin.readline())
ns = lambda: map(int, sys.stdin.readline().split())
na = lambda: list(map(int, sys.stdin.readline().split()))




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

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

print(sum(si!=ti for si,ti in zip(s,t)))

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
from decimal import *



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

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

cnt = 0
for k, v in zip(s, t):
    if k != v:
        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=lambda:input()
I=lambda:int(input())
L=lambda:list(map(int,input().split()))
LS=lambda:list(map(str,input().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 solve():
    ans = 0
    S = input()
    T = input()
    for i in range(len(S)):
        if S[i]!=T[i]:
            ans += 1
    return ans
print(solve())

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

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

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

Solution (Python):
import sys,queue,math,copy,itertools,bisect,collections,heapq

def main():
    sys.setrecursionlimit(10**7)
    INF = 10**18
    MOD = 10**9 + 7
    LI = lambda : [int(x) for x in sys.stdin.readline().split()]
    _LI = lambda : [-int(x) for x in sys.stdin.readline().split()]
    NI = lambda : int(sys.stdin.readline())
    SI = lambda : sys.stdin.readline().rstrip()
    DD = ((1,0),(0,1),(-1,0),(0,-1))

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

if __name__ == '__main__':
    main()

Solution (Python):
import sys

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
sys.setrecursionlimit(10000000)
import math
import bisect
from collections import deque
def input():
    return sys.stdin.readline()[:-1]

s = input()
t = input()
ans = 0

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

print(ans)

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

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

    print(cnt)    


if __name__ == "__main__":
    main()