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 copy
from collections import deque
import collections
stdin = sys.stdin

mod = 10**9+7

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

s = ns()
t = ns()

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

print(cnt)

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

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

print(n)

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

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

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


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

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

if __name__ == '__main__':
  s=input().strip("\n")
  t=input().strip("\n")
  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):
def main():
    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 = [s for s in input()]
t = [t for t in input()]

counter = 0

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

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

print(len(list(filter(lambda x: x[0] != x[1], zip(S, T)))))

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

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

print(count)

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

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

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

print(sum_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().rstrip('\n')
t = input().rstrip('\n')

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

print(ans)

Solution (Python):

import sys


def solve(S: str, T: str):
    a = 0
    for i in range(len(S)):
        a += (S[i]==T[i])*1
    print(len(S)-a)
    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):
S = input()
T = input()

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

print(ans)

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

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

ans = 0
for i,aa in enumerate(a):
    if b[i] != aa:
        ans += 1
print(ans)

Solution (Python):
import sys
import numpy as np
import math  
from collections import deque
from collections import defaultdict
from copy import deepcopy
from itertools import accumulate 
def input(): return sys.stdin.readline().rstrip()
from functools import lru_cache 

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

if __name__ == "__main__":
    main()

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

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

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

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

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

Solution (Python):

s, t = open(0).read().split()

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

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

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):
production = True

import sys, math, collections

def input(input_format = 0, multi = 0):

    if multi > 0: return [input(input_format) for i in range(multi)]
    else:
        next_line = sys.stdin.readline()[:-1]

        if input_format >= 10:
            use_list = False
            input_format = int(str(input_format)[-1])
        else: use_list = True

        if input_format == 0: formatted_input = [next_line]
        elif input_format == 1: formatted_input = list(map(int, next_line.split()))
        elif input_format == 2: formatted_input = list(map(float, next_line.split()))
        elif input_format == 3: formatted_input = list(next_line)
        elif input_format == 4: formatted_input = (lambda x: [x[0], list(map(int, x[1:]))])(next_line.split())
        elif input_format == 5: formatted_input = (lambda x: [x[0], list(map(float, x[1:]))])(next_line.split())
        elif input_format == 6: formatted_input = next_line.split()
        else: formatted_input = [next_line]

        return formatted_input if use_list else formatted_input[0]


def out(output_line, output_format = 0, newline = True):

    formatted_output = ""

    if output_format == 0: formatted_output = str(output_line)
    elif output_format == 1: formatted_output = " ".join(map(str, output_line))
    elif output_format == 2: formatted_output = "\n".join(map(str, output_line))

    print(formatted_output, end = "\n" if newline else "")


def log(*args):
    if not production:
        print("$$$", end = "")
        print(*args)

enum = enumerate






def solve():

    a = input(3)
    b = input(3)

    c = 0

    for i, j in zip(a, b):
        if i != j:
            c += 1

    out(c)

    return



solve()

Solution (Python):
A = input()
B = input()

N = len(A)

c = 0
for i in range(N):
  if A[i] != B[i]:
    c += 1

print(c)

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

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

print(out)

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

print(ans)

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

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

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

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

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

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

Solution (Python):


def solve(s,t):
    c = len(s)
    for i in range(len(s)):
        if s[i] == t[i]:
            c -= 1
    return c




def main():
    s = input()
    t = input()
    print(solve(s,t))
    return

if __name__ == '__main__':
    main()

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

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

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

count = 0

for l in range(len(S)):
    if S[l] != T[l]:
        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()
s = list(s)
t = list(t)
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):
def main():
    s = input()
    t = input()

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

    print(r)


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):
mod=10**9+7
import math
import sys
from collections import deque
import heapq
import copy
import itertools
from itertools import permutations
from itertools import combinations
import bisect
def mi() : return map(int,sys.stdin.readline().split())
def ii() : return int(sys.stdin.readline().rstrip())
def i() : return sys.stdin.readline().rstrip()
a=i()
b=i()
c=0
for i in range(len(a)):
  if a[i]!=b[i]:
    c+=1
print(c)

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
from math import floor, sqrt, factorial, hypot, log  
from heapq import heappop, heappush, heappushpop
from collections import Counter, defaultdict, deque
from itertools import accumulate, permutations, combinations, product, combinations_with_replacement
from bisect import bisect_left, bisect_right
from copy import deepcopy
from fractions import gcd
from random import randint


def ceil(a, b): return (a + b - 1) // b


inf = float('inf')
mod = 10 ** 9 + 7


def pprint(*A):
    for a in A:     print(*a, sep='\n')


def INT_(n): return int(n) - 1


def MI(): return map(int, input().split())


def MF(): return map(float, input().split())


def MI_(): return map(INT_, input().split())


def LI(): return list(MI())


def LI_(): return [int(x) - 1 for x in input().split()]


def LF(): return list(MF())


def LIN(n: int): return [I() for _ in range(n)]


def LLIN(n: int): return [LI() for _ in range(n)]


def LLIN_(n: int): return [LI_() for _ in range(n)]


def LLI(): return [list(map(int, l.split())) for l in input()]


def I(): return int(input())


def F(): return float(input())


def ST(): return input().replace('\n', '')


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




if __name__ == '__main__':
    main()

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

Solution (Python):
s = str(input())
l = str(input())
res = 0

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

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

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

cnt = 0

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

print(cnt)

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

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

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

Solution (Python):
S = input()
T = input()
print(len([i for i,j in zip(S,T) if i!=j]))

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

Solution (Python):

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

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

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

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

print(len(list(filter(lambda xy: xy[0] != xy[1], zip(s, t)))))

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

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

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

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

print(ret)

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

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):
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):
ss = input()
tt = input()
ans = 0

for s, t in zip(ss, tt):
    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()

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

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

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

print(count)

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

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

print(c)

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

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

print(cnt)

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

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

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

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

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

print(ans)

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

Solution (Python):
'''
Created on 2020/06/27

@author: harurun
'''
S=input()
T=input()
t=0
for x in range(len(S)):
    if S[x]==T[x]:
        pass
    else:
        t += 1
print(t)

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

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

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

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

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

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

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

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

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

Solution (Python):
S = input()
T = input()
a = 0
for v, k in zip(S, T):
    if v != k:
        a += 1
print(a)

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

for i in s:
    if i != t[idx]:
        cnt += 1
    idx += 1

print(cnt)

Solution (Python):
import math
from collections import Counter

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

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

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

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

print(ct)

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

str_len = len(t)

cnt = 0
for i in range(str_len):
    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()

total = 0

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

print(total)

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

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

print(ans)

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

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

Solution (Python):



import sys


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


def resolve():
    s = input().rstrip()
    t = input().rstrip()

    count = 0

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

    print(count)


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

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

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

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

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

Solution (Python):

s = input()
t = input()

count = 0

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

print(count)

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

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

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
    else:
        continue

print(ans)

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

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

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

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

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

ls = len(S)

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

print(ans)

Solution (Python):
import numpy as np
import math
import scipy as sp
import queue
import collections

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

def main(kwargs):
    S = kwargs["S"]
    T = kwargs["T"]
    res = 0

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

    return res

if __name__ == "__main__":
    kwargs = {}

    cin = input().split()
    kwargs["S"] = cin[0]

    cin = input().split()
    kwargs["T"] = cin[0]

    cout = main(kwargs)
    print(cout)

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

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

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


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

print(cnt)

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

Solution (Python):















mod = int(1e9+7)

INF = 1<<50

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

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

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().strip() ;
T =  input().strip() ;
x = 0 ;

for i , j in zip ( S ,T ) :
	if i != j :
		x += 1 ; 
print ( x ) ;

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

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

print(count)

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

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

print(count)

Solution (Python):

s = input()
t = input()

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

print(ans)

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

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

print(cnt)

Solution (Python):

from collections import defaultdict
s = input().strip()
t = input().strip()
a = 0
for i in range(len(s)):
    a += (s[i] != t[i])
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()
l=len(s)
ans=0
for i in range(l):
    if s[i]!=t[i]:
        ans+=1
print(ans)

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

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

print(count)

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

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

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

Solution (Python):

import os
import operator
from collections import defaultdict
import sys
from io import BytesIO, IOBase
import bisect










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





















BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

if __name__ == "__main__":
    main()

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

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

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

l=len(s)
ans=0

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

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

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

print(count)

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

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 hamming_dist(str1,str2):
    count = 0
    if len(str1) > len(str2):
        str_data1 = str1[:]
        str_data2 = str2[:]
    elif len(str1) < len(str2):
        str_data1 = str2[:]
        str_data2 = str1[:]
    else:
        str_data1 = str1[:]
        str_data2 = str2[:]
    for i in range(len(str_data2)):
        if str_data1[i] != str_data2[i]:
            count += 1
    for i in range(len(str_data1)-len(str_data2)):
        count += 1

    return count
p = input()
q = input()
print(hamming_dist(p, q))

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

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)