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

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

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

print(cnt)

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

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

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

Solution (Python):
import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction

sys.setrecursionlimit(int(pow(10,6)))


mod = int(pow(10, 9) + 7)
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(*var, end="\n"): sys.stdout.write(' '.join(map(str, var))+end)
def l(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]


t=1

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

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

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

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

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

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

print(n)

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

Solution (Python):
import sys
import bisect
import itertools
import collections
import fractions
import heapq
import math
from operator import mul
from functools import reduce
from functools import lru_cache


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    S = input()
    T = input()

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

    print(count)


if __name__ == '__main__':
    solve()

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

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

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

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

result = 0

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

print(result)

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

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

Solution (Python):

s = input()
t = input()

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

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

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

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

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

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


from queue import Queue
from queue import LifoQueue as Stack
from math import sqrt, floor, ceil, log2, log10, pi
from fractions import gcd
from itertools import permutations, combinations
from operator import itemgetter
from functools import cmp_to_key


INF=1001001001
__MOD__=(10**9)+7
yn = 'YNeos'
judge = False
cnt = 0
ans = None


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

def intinput():
    return int(input())

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

def lineinputs(func=intinput):
    datas = []
    while True:
        try:
            datas.append(func())
        except EOFError:
            break
    return datas

class ModInt():
    def __init__(self, x):
        self.__x = (x % __MOD__)
    def __add__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x + other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x + other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __radd__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x + self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x + self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __sub__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x - other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x - other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rsub__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x - self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x - self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __mul__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rmul__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x * self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x * self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __truediv__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__modinv())%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__modinv())%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rtruediv__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x * self.__modinv())%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x * self.__modinv())%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __pow__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__(pow(self.__x, other.__x, __MOD__)))
        elif type(other) == ModInt:
            return self.__class__(pow(self.__x, other.__x, __MOD__))
        else:
            raise Exception("Not Int or Not ModInt")
    def __rpow__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__(pow(other.__x, self.__x, __MOD__)))
        elif type(other) == ModInt:
            return self.__class__(pow(other.__x, self.__x, __MOD__))
        else:
            raise Exception("Not Int or Not ModInt")

    def __modinv(self, m=__MOD__):
        a = self.__x
        if a == 0:
            raise ZeroDivisionError()
        if gcd(a, m) != 1:
            raise Exception("%sの逆数は求まりません。" % a)
        b, u, v = m, 1, 0
        while b != 0:
            t = a//b;
            a -= t*b
            a, b = b, a
            u -= t * v
            u, v = v, u
        u %= m
        if u < 0:
            u += m
        return u
    def __int__(self):
        return self.__x
    def __str__(self):
        return str(self.__x)



if __name__ == '__main__':
    S = input()
    T = input()

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

Solution (Python):
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 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()

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**6)




s = input()
t = input()







ans = 0

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

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


S = input()
T = input()

assert(len(S) == len(T))

ans = 0

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

print(ans)

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

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

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

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

print(ans)

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

Solution (Python):
def getN():
    return int(input())
def getNM():
    return map(int, input().split())
def getList():
    return list(map(int, input().split()))
def getArray(intn):
    return [int(input()) for i in range(intn)]
def input():
    return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
    return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
    return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
  ns = []
  while len(ns) < rantime:
    n = random.randint(ran1, ran2)
    if not n in ns:
      ns.append(n)
  return sorted(ns)

def rand_query(ran1, ran2, rantime):
  r_query = []
  while len(r_query) < rantime:
    n_q = rand_ints_nodup(ran1, ran2, 2)
    if not n_q in r_query:
      r_query.append(n_q)
  return sorted(r_query)

from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import random
import string
import copy
from itertools import combinations, permutations, product
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right

import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7






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):
a = raw_input()
b = raw_input()
print(sum(x!=y for (x, y) in zip(a, b)))

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

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

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

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

print(cnt)

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

ans = 0

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

print(ans)

Solution (Python):




import sys
input = sys.stdin.readline



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

    N = len(S)
    res = 0

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

    print(res)



main()

Solution (Python):
import sys

def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list(map(lambda x: x-1, MII()))

def main():
    s = IS()
    t = IS()
    cnt = 0
    for si,ti in zip(s,t):
        if si != ti:
            cnt += 1
    print(cnt)

if __name__ == '__main__':
    main()

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

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

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

if __name__ == '__main__':
    s = input()
    t = input()
    print(solve())

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

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

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

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

counter = 0

for i in range(len_st):
  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):
input = raw_input

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

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

Solution (Python):

from sys import stdin
from operator import itemgetter
from collections import deque, Counter
import math
import pprint
from functools import reduce


MOD = 1000000007
INF = float('inf')
alpha = ["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]

def keta(kazu): 
    kazu_str = str(kazu)
    kazu_list = [int(kazu_str[i]) for i in range(0, len(kazu_str))]
    return kazu_list

def gcd(*numbers): 
    return reduce(math.gcd, numbers)

def combination(m,n): 
    
    if n > m:
        return 'すまん'
    return math.factorial(m) // (math.factorial(m-n) * math.factorial(n))

def pow_k(x,n):  
    if n == 0:
        return 1
    K = 1
    while n > 1:
        if n % 2 != 0:
            K *= x
        x *= x
        n //= 2
    return K * x

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

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

Solution (Python):
import numpy as np

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

print(ans)

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

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

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

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()
n = len(s)

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

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

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

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

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

Solution (Python):

from collections import deque




import os
import sys
from io import BytesIO, IOBase




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

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


import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())

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

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

    print(i)


if __name__ == "__main__":
    resolve()

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

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

print(ans)

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

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 = str(input())
T = str(input())
ans = 0
for i in range(len(T)):
    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):
from sys import stdin
S = (stdin.readline().rstrip())
T = (stdin.readline().rstrip())
ans = 0
for i,j in zip(S,T):
    if i != j:
        ans += 1
print(ans)

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

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

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

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)

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

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

Solution (Python):
from sys import stdin

def main():

    input = stdin.readline

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

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

    print(ans)


if __name__ == "__main__":
    main()

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

Solution (Python):
import sys
from io import StringIO
import unittest


def resolve():
    s = list(input())
    t = list(input())

    print(sum([1 for ss, tt in zip(s, t) if ss != tt]))

class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """cupofcoffee
cupofhottea"""
        output = """4"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """abcde
bcdea"""
        output = """5"""
        self.assertIO(input, output)

    def test_入力例_3(self):
        input = """apple
apple"""
        output = """0"""
        self.assertIO(input, output)


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

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

print(ans)

Solution (Python):

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

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

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

ans = 0

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**6)


def main(input, print):
    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(sys.stdin.readline, print)

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


def solve():
    S = input()
    T = input()
    c = sum(s!=t for s,t in zip(S,T))
    return str(c)

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

Solution (Python):
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def X(): return list(input())
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
count = 0

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

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

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

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

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

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

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

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

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

print(cnt)

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

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

print(ans)

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

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

print(ans)

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

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()
u = len(s)
res = 0
for i in range(u):
    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()





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

Solution (Python):
import sys
import math
import itertools as it
def I():return int(sys.stdin.readline().replace("\n",""))
def I2():return map(int,sys.stdin.readline().replace("\n","").split())
def S():return str(sys.stdin.readline().replace("\n",""))
def L():return list(sys.stdin.readline().replace("\n",""))
def Intl():return [int(k) for k in sys.stdin.readline().replace("\n","").split()]
def Lx(k):return list(map(lambda x:int(x)*-k,sys.stdin.readline().replace("\n","").split()))

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

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


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