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

Solution (Python):
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
import copy


if __name__ == "__main__":
    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):
print(sum(a!=b for a,b in zip(input(),input())))

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

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 = 0

al = list(a)
bl = list(b)

for ai,bi in zip(al,bl):
 if ai != bi:
  n = n + 1

print(n)

Solution (Python):






import sys
input = sys.stdin.readline

import math

import bisect
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache





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






def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(input()) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]


def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()


def DD(arg): return defaultdict(arg)


def inv(n): return pow(n, MOD-2, MOD)


kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n): return kaijo_memo[n]
  if(len(kaijo_memo) == 0): kaijo_memo.append(1)
  while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if n == r: return 1
  if n < r or r < 0: return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret


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


def make_divisors(n):
  divisors = []
  for i in range(1, int(n**0.5)+1):
    if n % i == 0:
      divisors.append(i)
      if i != n // i: 
        divisors.append(n//i)
  return divisors


def make_primes(N):
  max = int(math.sqrt(N))
  seachList = [i for i in range(2,N+1)]
  primeNum = []
  while seachList[0] <= max:
    primeNum.append(seachList[0])
    tmp = seachList[0]
    seachList = [i for i in seachList if i % tmp != 0]
  primeNum.extend(seachList)
  return primeNum


def gcd(a, b):
    while b: a, b = b, a % b
    return a


def lcm(a, b):
    return a * b // gcd (a, b)


def count_bit(n):
  count = 0
  while n:
    n &= n-1
    count += 1
  return count


def base_10_to_n(X, n):
  if X//n: return base_10_to_n(X//n, n)+[X%n]
  return [X%n]

def base_n_to_10(X, n):
  return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))

def base_10_to_n_without_0(X, n):
  X -= 1
  if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]
  return [X%n]


def int_log(n, a):
  count = 0
  while n>=a:
    n //= a
    count += 1
  return count




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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7


def resolve():
    S = input()
    T = input()
    res = 0
    for s, t in zip(S, T):
        if s != t:
            res += 1
    print(res)


if __name__ == '__main__':
    resolve()

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

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

print(j)

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

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
s = input()
t = input()
ans = 0
for i in range(len(s)):
    if s[i] != t[i]:
        ans += 1
print(ans)

Solution (Python):
bef = input()
aft = input()
answer = 0
count = 0
i = 1

    
for i in range(len(bef)):
  if bef[count] == aft[count]:
    count += 1
    i += 1
  else:
    answer += 1
    i += 1
    count += 1
print(answer)

Solution (Python):
import sys

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

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

Solution (Python):
S, T = open(0).read().split()
count = 0
for index, x in enumerate(S):
    if x != T[index]:
        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):
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate


def exit(*argv, **kwarg):
    print(*argv, **kwarg)
    sys.exit()


def mina(*argv, sub=1): return list(map(lambda x: x - sub, argv))



def a_int(): return int(read())


def ints(): return list(map(int, read().split()))


def read_col(H):
    '''H is number of rows
    A列、B列が与えられるようなとき
    ex1)A,B=read_col(H)    ex2) A,=read_col(H) 
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return tuple(map(list, zip(*ret)))


def read_tuple(H):
    '''H is number of rows'''
    ret = []
    for _ in range(H):
        ret.append(tuple(map(int, read().split())))
    return ret


def read_matrix(H):
    '''H is number of rows'''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return ret
    


MOD = 10**9 + 7
INF = 2**31  

from collections import defaultdict, Counter, deque
from operator import itemgetter, xor, add
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right  
from functools import reduce
from math import gcd


def lcm(a, b):
    
    g = gcd(a, b)
    return a // g * b


S = read()[:-1]
T = read()[:-1]
ans = 0
for s, t in zip(S, T):
    ans += s != t

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

Solution (Python):
x = input()
y = input()

count = 0
for i in range(0,len(x)):
    if x[i] != y[i]:
        count +=1
print(count)

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

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

replace = 0

for idx, st in enumerate(S):
  if st != T[idx]:
    replace += 1

print(replace)

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

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

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

Solution (Python):
count=0
S=str(input())
T=str(input())
if 1<=len(S)<=2*(10**5) and 1<=len(T)<=2*(10**5):
    if len(S)==len(T) and (str.islower(S) and str.islower(T)):
         for i in range(len(S)):
                if S[i]==T[i]:
                    count=count+0
                else:
                    count=count+1
    else:
        print("wrong")
print(count)

Solution (Python):
S=input()
T=input()
num = 0
for i in range(len(T)):
  if not 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(len(s)-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()
C=0

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

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

Solution (Python):




import sys

iimr = lambda: map(int, sys.stdin.readline().rstrip().split())
readline = sys.stdin.readline
sys.setrecursionlimit(10 ** 8)


def 関数(s,t):
    tlen = len(t)
    fois = 0

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

    return fois

def çözmek():
    S = sys.stdin.readline().rstrip()
    T = sys.stdin.readline().rstrip()

    res = []
    res.append(関数(S, T))
    print(*res, sep="\n")

if __name__ == "__main__":
    çözmek()

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

Solution (Python):

a = input()
a = [str(a)for a in a]
b = input()
b = [str(b)for b in b]

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

print(count)

Solution (Python):
def main():
    S = input()
    T = input()
    answer = solve(S, T)
    print(answer)


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


if __name__ == "__main__":
    main()

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

num = 0

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

print(num)

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]:
        j = j+0
    else:
        t[i]=s[i]
        j=j+1

print(j)

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

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

print("{}".format(ret))

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


cnt = 0
j = len(S)


for i in range(j):
        if S[i] != T[i]:
                cnt = 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):
def calculate(s,t):
    count = 0
    j = 0
    for i in s:
        if i != t[j]:
            count += 1
        j += 1
    return count
    
s = input()
t = input()
print(calculate(s,t))

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

c = 0
for sc, tc, in zip(s, t) :
    if sc != tc:
        c +=1
print(c)

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

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

s.split()
t.split()

ans = 0

if s==t:
    print("0")
    exit()

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

print(ans)

Solution (Python):
S = str(input())
T = str(input())
length =len(S)
listS=list(S)
listT=list(T)
num = len(T)
res = 0
for i in range(length):
    if (listS[num-1] != listT[num-1]):
        res +=1
    num -=1
print(res)

Solution (Python):

import sys


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



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

if __name__ == '__main__':
    main()

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gcd, sqrt
from operator import mul
from functools import reduce
from operator import mul
from pprint import pprint



sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007


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

Solution (Python):
s = input()
t = input()
i = 0
num = 0

for c in s:
  if c != t[i]:
    num += 1
  i += 1

print(num)

Solution (Python):
list_S0 = input()
list_S1 = input()

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

Solution (Python):
import timeit

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

S = a[0]
T = a[1]

def count_diff2(S,T):
    cnt = 0
    for c1,c2 in zip(S, T):
        if c1 != c2:
            cnt += 1
    return cnt

print(count_diff2(S,T))

Solution (Python):
a = input()
b = input()
c = 0
for A, B in zip(a, b):
  if A != B:
    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):
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10 ** 8)
from itertools import accumulate
from itertools import permutations
from itertools import combinations
from collections import defaultdict
from collections import Counter
import fractions
import math
from collections import deque
from bisect import bisect_left
from bisect import bisect_right
from bisect import insort_left
import itertools
from heapq import heapify
from heapq import heappop
from heapq import heappush
import heapq
from copy import deepcopy
from decimal import Decimal
alf = list("abcdefghijklmnopqrstuvwxyz")
ALF = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")

INF = float("inf")


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

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


def count_diff2(q, a):
    return sum(
        c1 != c2 for c1, c2 in zip(q, a)
    )

  
print(count_diff2(S,T))

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

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

Solution (Python):

alist = list(str(input()))
blist = list(str(input()))

ret = 0

for num in range(0, len(alist)):
    if (alist[num] != blist[num]):
        ret += 1

print(ret)

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 = list(input())
t = list(input())
c = 0
for i, val in enumerate(t):
    if val != s[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):

def main():
    s = list(input())
    t = list(input())
    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().strip()
t = input().strip()
r = 0
for c, u in zip(s, t):
    if c != u:
        r += 1
print(r)

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

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

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

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

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

Solution (Python):
def main():
  s1 =input()
  s2 =input()
    
  cnt = 0
      
  if s1 == s2:
    print('0')
  else:
    for c1,c2 in zip(s1, s2):
      if c1 != c2:
        cnt += 1
                  
    print(cnt)
                  
if __name__ == '__main__':
    main()

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

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

length = len(a)
n = 0
for i in range(length):
    if a[i] is not b[i]:
        n += 1

print(n)

Solution (Python):
s = str(input())
s_list = list(s)
t = str(input())
t_list = list(t)


i = 0
n = 0
for i in range(0, len(s_list)):
  if s_list[i] != t_list[i]:
    i += 1
    n += 1
  else:
    i += 1
  
print(int(n))

Solution (Python):
if __name__ == "__main__":
    s = list(input())
    t = list(input())

    count = 0

    for i, _ in enumerate(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
  else:
    pass
print(count)

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

Solution (Python):
def main():
    from builtins import int, map, list, print, len
    import sys
    sys.setrecursionlimit(10 ** 6)

    input = (lambda: (sys.stdin.readline()).rstrip())
    input_list = (lambda: input().split())
    input_number = (lambda: int(input()))
    input_number_list = (lambda: list(map(int, input_list())))

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


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

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

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

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())
k = []
for i in range(len(s)):
    k.append(s[i] == t[i])
print(len(s)-sum(k))

Solution (Python):
def count_diff(q,a):
    lst_q = list(q)
    lst_a = list(a)
    len_q = len(lst_q)
    ng = 0
    for i in range(len_q):
        if lst_q[i] != lst_a[i]:
            ng += 1
    print(ng)

q = input()
a = input()


count_diff(q,a)

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

Solution (Python):
str = [input() for i in range(2)]
S,T = list(str[0]),list(str[1])
count = 0
for s, t in zip(S, T):
    if not 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 = input()
T = input()
cnt = 0
for i, v in enumerate(zip(S,T)):
  if v[0] == v[1]:
    continue
  else:
    cnt += 1
print(cnt)

Solution (Python):
import sys
def input():return sys.stdin.readline()[:-1]
def N(): return int(input())
def NM():return map(int,input().split())
def L():return list(NM())
def LN(n):return [N() for i in range(n)]
def LL(n):return [L() 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):
s=input()
t=input()
cnt = 0
for i in range(len(s)):
    if s[i] != t[i]:
        cnt += 1
print(cnt)

Solution (Python):
q=input()
a=input()
lst_q = list(q)
lst_a = list(a)
len_q = len(lst_q)
ng = 0
for i in range(len_q):
    if lst_q[i] != lst_a[i]:
        ng += 1
print(ng)

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

Solution (Python):
S = input()
T = input()
s = list(S)
t = list(T)
K = len(s)
n=0
for i in range(0, K):
  if s[i] != t[i]:
    n+=1
  else:
    pass
print(n)

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

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

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

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

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

Snak = list(S)
Tnak = list(T)
for i in range(len(S)):
  if Snak[i] != Tnak[i]:
    C += 1
print(C)

Solution (Python):
s1 = input().split()
strS = s1[0]
s2 = input().split()
strT = s2[0]

charStrSList = list(strS)
charStrTList = list(strT)
diffStrList = []

idxA = 0
for sChar in charStrSList:
    if (sChar != charStrTList[idxA]) :
        diffStrList.append(sChar)
    idxA += 1

print(len(diffStrList))

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

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

print(count)

Solution (Python):
def main():
    s = input()
    t = input()
    ans = sum(map(lambda x: x[0]!=x[1], zip(s, t)))
    print(ans)
 
 
if __name__ == '__main__':
    import sys
    sys.setrecursionlimit(10000)
    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
import math

s = list(input())

t = list(input())


if s[0]==0 or t[0]==0:
    sys.exit(0)

i = 0
cnt = 0
while i<len(s):
    if i == 2*(pow(10,5)):
        sys.exit(0)
    if s[i]!=t[i]:
        cnt += 1
    i += 1

print(cnt)

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

Solution (Python):
import sys
import  math
import fractions
from collections import defaultdict
stdin = sys.stdin
     
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))

S=list(ns())
T=list(ns())
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 a,b in zip(S,T):
  if(a!=b):
    count+=1
    
print(count)

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

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

Solution (Python):
string1 = input()
string2 = input()
count = 0
if string1 == string2:
    print(0)
else:
    for i, j in zip(string1, string2):
        if i != j:
            count += 1
        else:
            count += 0
    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 = str(input())
t = str(input())

S = list(s)
T = list(t)

a = 0

for i in range(len(s)):
    if S[i] == T[i]:
        continue
    else:
        a += 1

print(a)

Solution (Python):
S = str(input())
T = str(input())
nagasa = len(S)
j = 0
i = 0
while i<nagasa:
    if (S[i]!=T[i]):
        j=j+1
    i=i+1
print(j)

Solution (Python):
s = str(input())
t = str(input())
lists = list(s)
listt = list(t)
cnt = 0
for index in range(len(lists)):
    if lists[index] == listt[index] :
        cnt += 1
print(len(lists)-cnt)

Solution (Python):
n=input()
m=input()
count =0
i=0
while i < len(n):

  if n[i] != m[i]:
    count +=1
  
  i +=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+=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())
count = 0

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

print(count)

Solution (Python):
a, b = [input() for i in range(2)]

count = 0
out = 0
if a == b:
  print("0")
else:
  c = list(a)
  d = list(b)
  for i in c:
    if i == d[count]:
      pass
    else:
      out = out + 1
    count = count + 1
  print(str(out))

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

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

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 x, y in zip(s, t):
    if x != y:
        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 = str(input())
T = str(input())

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

print(add)

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



print(j)

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

ans = 0
l=len(S)

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

print(count)

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

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

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

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


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

    print(counter)

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)