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

Solution (Python):




def input_int():
    return int(input())



def int1(x):
    return int(x) - 1



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



def input_to_int_tuple():
    return tuple(map(int, input().split()))



def input_to_int_tuple_minus1():
    return tuple(map(int1, input().split()))


def main():
    s = input()
    t = input()

    cnt = 0
    for temp_s, temp_t in zip(s, t):
        if temp_s != temp_t:
            cnt += 1

    return cnt


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

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

print(cnt)

Solution (Python):


S = input()
T = input()

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

print(counter)

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

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

    print(count)


if __name__ == '__main__':
    main()

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

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

print(cnt)

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

ans = 0

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

print(ans)

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

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

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

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

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

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

Solution (Python):
k=list(input())
m=list(input())
ams=0
for i in range(len(k)):
  if(k[i]!=m[i]):
    ams+=1
print(ams)

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

Solution (Python):

S = str(input())
T = str(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())
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, j in zip(s, t):
    if i != j:
        cnt += 1
print(cnt)

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

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

print(str(count))

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

Solution (Python):
S = input()
T = input()
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):
counter = 0

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

for i,c in enumerate(S):
    if c != 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):
S = raw_input().strip()
T = raw_input().strip()

ans = len([c for c, d in zip(S, T) if c != d])
print ans

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

Solution (Python):
import sys

input_data = []
input_pointer = 0

output_data = []

def input_scan():
    global input_data
    input_data = sys.stdin.readlines()
    input_data = [x[:-1] for x in input_data]

def next_line():
    global input_pointer
    global input_data
    if input_pointer < len(input_data):
        input_pointer += 1
        return input_data[input_pointer - 1]
    else:
        return ""

def append_output(string):
    global output_data
    output_data.append(string)

def print_output():
    global output_data
    output_data.append("")
    sys.stdout.write("\n".join(output_data))






input_scan()
s = next_line()
t = next_line()
print(sum([1 for x, y in zip(list(s), list(t)) if x != y]))

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

Solution (Python):
s, t = map(lambda s: s.rstrip(), open(0).readlines())
n = len(s)
ans = 0
for i in range(n):
    ans += s[i] != t[i]
print(ans)

Solution (Python):
s, t = open(0)
n = len(s)
ans = 0
for i in range(n):
    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):

"""
Created on Sun Jun 28 13:26:25 2020

@author: NEC-PCuser
"""
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 c1, c2 in zip(s, t):
    if c1 != c2:
        count += 1
print(count)

Solution (Python):
from sys import stdin
s=stdin.readline()
t=stdin.readline()
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 n, c in enumerate(s):
    if (c is not t[n]):
        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):
a = list(input())
b = list(input())
t=0

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

print(t)

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

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


if __name__ == "__main__":
    main()

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

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

Solution (Python):
import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right

sys.setrecursionlimit(10**7)
def input():
    return sys.stdin.readline()[:-1]

mod = 10**9 + 7

def I(): return int(input())
def LI(): return list(map(int, input().split()))
def LIR(row,col):
    if row <= 0:
        return [[] for _ in range(col)]
    elif col == 1:
        return [I() for _ in range(row)]
    else:
        read_all = [LI() for _ in range(row)]
        return map(list, zip(*read_all))



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):
import collections
import heapq
import math
import random
import sys
input = sys.stdin.readline

s = input().rstrip()
t = input().rstrip()
res = sum(s[i] != t[i] for i in range(len(s)))
print(res)

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

l = len(s)

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

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

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

S = input()[:-1]
T = input()[:-1]
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 si, ti in zip(s, t):
    if si != ti:
        cnt += 1
print(cnt)

Solution (Python):
s = input()
t = input()
cnt = 0
for si, ti in zip(s, t):
    if si != ti:
        cnt += 1
print(cnt)

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

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

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

    print(count)
    



if __name__ == "__main__":
    main()

Solution (Python):
import sys

readline = sys.stdin.readline
readall = sys.stdin.read
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')

def solve():
    s = ns()
    t = ns()
    n = len(s)
    print(sum(1 for i in range(n) if s[i] != t[i]))
    return

solve()

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

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

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

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

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

Solution (Python):
s = input()
t = input()
ans = 0
for (a, b) in zip(s, t):
    if a != b:
        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()

cnt = 0

for i in range(len(S)):
  if S[i] != T[i]:
    cnt = 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):
import sys
from collections import defaultdict
readline = sys.stdin.buffer.readline



def geta(fn=lambda s: s.decode()):
    return map(fn, readline().split())


def gete(fn=lambda s: s.decode()):
    return fn(readline().rstrip())


def main():
    s, t = gete(), gete()

    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()
 
cnt = 0
 
for i in range(len(S)):
    s = S[i]
    t = T[i]
    
    if (s != t):
        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):
def main():
    import sys
    S=sys.stdin.readline()
    T=sys.stdin.readline()
    count=0
    for s,t in zip(S,T):
        count+=s!=t
    print(count)
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):


def get_input() -> tuple:
    """
    標準入力を取得する.

    Returns:\n
        tuple: 標準入力
    """
    S = input()
    T = input()

    return S, T


def main(S: str, T: str) -> None:
    """
    メイン処理.

    Args:\n
        S (str): 文字列
        T (str): 文字列
    """
    
    ans = 0
    for s, t in zip(S, T):
        ans += (s != t)

    
    print(ans)


if __name__ == "__main__":
    
    S, T = get_input()

    
    main(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()
print(sum(si != ti for si, ti in zip(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()
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([si != ti for si, ti in zip(s, t)]))

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

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

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from itertools import permutations, accumulate, combinations, combinations_with_replacement
from math import sqrt, ceil, floor, factorial
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy
from operator import itemgetter
from functools import reduce, lru_cache  
from fractions import gcd
import sys  

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

print(count)

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

Solution (Python):
a = input()
b = input()
list_a = []
list_b = []
score = 0
for n in a:
    list_a.append(n)
for m in b:
    list_b.append(m)
for i in range(0, len(list_a)):
    if list_a[i] != list_b[i]:
        score += 1
print(score)

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

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


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

Solution (Python):
print(sum(s!=t for s,t in zip(*open(0))))

Solution (Python):
print(sum(s!=t for s,t in zip(*open(0))))

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

Solution (Python):

import sys
sys.setrecursionlimit(10**8)
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)))


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


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

    return


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=str(input())
T=str(input())
sum=0

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

print(sum)

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

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

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

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):
print(sum(a!=b for a,b in zip(*open(0))))

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

ans = 0

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

Solution (Python):


import collections
import itertools
from functools import lru_cache
import sys
import math
from decimal import Decimal


MOD = int(1e9)+7


def helper():
	pass


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


t = 1
for _ in range(t):
	solve()

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

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

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

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

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

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

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

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

Solution (Python):
string1 = input()
string2 = input()

result = 0
for x in range(len(string1)):
    if string1[x] != string2[x]:
        result += 1

print(result)

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):
print(sum(s != t for s, t in zip(input(), input())))

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

print(cnt)

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

Solution (Python):
s,t=input(),input()
print(sum(map(lambda x: 1 if x[0]!=x[1] else 0, zip(s,t))))

Solution (Python):
s = str(input())
t = str(input())
sl = list(s)
tl = list(t)
n = len(s)

sum = 0

for x in range(n):
  if sl[x] != tl[x]:
    sum += 1
print(sum)

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

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

Solution (Python):

def main():
    S, T = open(0).read().split()
    print(sum(s != t for s, t in zip(S, T)))


if __name__ == "__main__":
    main()

Solution (Python):
s=input()
t=input()
count=0
for i in range(len(s)):
  if(not(ord(s[i])==ord(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 = list(input())
t = list(input())
ans = 0
for i, j in zip(s, t):
    if i == j:
        continue
    else:
        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):
import sys
import math
import collections

def set_debug(debug_mode=False):
    if debug_mode:
        fin = open('input.txt', 'r')
        sys.stdin = fin


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


if __name__ == '__main__':
    

    
    t = 1

    for ti in range(1, t + 1):
        
        s = input()
        t = input()

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

        print(res)

Solution (Python):
a = list(input())
b = list(input())
t = 0
for i in range(len(a)):
     if not a[i] == b[i]:
         t = t +1
         
print (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):
def solve():
    s = list(input())
    t = list(input())
    ans = 0
    for a, b in zip(s, t):
        if a != b:
            ans += 1
    print(ans)
    return 0

if __name__ == "__main__":
    solve()

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

Solution (Python):
frase1= input()
frase2= input()
tf1= len(frase1)
cont=0
for x in range(tf1):
    if frase1[x] != frase2[x]:
        cont+=1
print(cont)

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 II(): return int(input())
def MII(): return map(int, input().split())
def LII(): return list(map(int, input().split()))

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

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

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

print(r)

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 = list(map(str,input()))
t = list(map(str,input()))
n = len(s)
cnt = 0
for i in range(n):
    if s[i] == t[i]: pass
    else: cnt += 1
print(cnt)

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

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

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

a = 0

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

Solution (Python):
import sys
sys.setrecursionlimit(300000)

def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI0(): return map(lambda s: int(s) - 1, sys.stdin.readline().split())
def LMI(): return list(map(int, sys.stdin.readline().split()))
def LMI0(): return list(map(lambda s: int(s) - 1, sys.stdin.readline().split()))
MOD = 10 ** 9 + 7
INF = float('inf')


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

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

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

Solution (Python):
line = list(input())
line2 = list(input())

x = 0
num = (len(line))

for i in range(num):
  if line[i] != line2[i]:
    x += 1
print(x)

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

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

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

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

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




from sys import stdin,stdout
from math import gcd, ceil, sqrt
ii1 = lambda: int(stdin.readline().strip())
is1 = lambda: stdin.readline().strip()
iia = lambda: list(map(int, stdin.readline().strip().split()))
isa = lambda: stdin.readline().strip().split()
mod = 1000000007

a, b = is1(), is1()
res = 0
for i, j in zip(a, b):
    if i != j:
        res += 1
print(res)

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()
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 p,q in zip(a,b):
  if p!=q:
    ans+=1
print(ans)

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

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

count = 0

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

print(count)

Solution (Python):
s1=input()

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

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

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

print(cnt)

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

num = 0
count = 0

for i in S:
  if S[num] != T[num]:
    count += 1
  else:
    pass
  num += 1

print(count)

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

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

print(count)

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

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

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

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

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

Solution (Python):

import sys


def solve(S: str, T: str):
    ans = 0
    for i in range(len(S)):
        if S[i]!=T[i]:
            ans+=1
    print(ans)
    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):
sf=input()
tf=input()
print(sum(s!=t for s,t in zip(sf,tf)))

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

Solution (Python):


import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

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

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

Solution (Python):


import sys
sys.setrecursionlimit(300000)


def solve(S: str, T: str):
    ret = 0
    for i in range(len(S)):
        if S[i] != T[i]:
            ret += 1
    print(ret)
    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()
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 a,b in zip(s,t):
    if a != b:
        ans += 1
print(ans)

Solution (Python):
import numpy as np
s = np.array([ord(c) for c in input()])
t = np.array([ord(c) for c in input()])
print(np.count_nonzero(s - t))

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

s = list(S)
t = list(T)
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()
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()
print(len([*filter(lambda x: s[x]!=t[x], range(len(s)))]))

Solution (Python):
import math
import sys
S=input()
T=input()
cnt=0
for i in range(len(S)):
  cnt+=int(S[i]!=T[i])
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):

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

print(len(list(filter(lambda i: t[i]!=s[i], range(len(t))))))

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

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

    print(sum(s != t for s, t in zip(S, T)))


if __name__ == '__main__':
    main()

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

Solution (Python):
import sys

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


def solve():
    S = rl().rstrip()
    T = rl().rstrip()
    
    ans = 0
    for si, ti in zip(S, T):
        if si != ti:
            ans += 1
    print(ans)


if __name__ == '__main__':
    solve()