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

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

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

    cnt = 0

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

    print(cnt)

if __name__ == "__main__":
    solve()

Solution (Python):

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

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

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

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

count = 0

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

print(count)

Solution (Python):
S = input()
T = input()
A = []
B = []
N = len(S)
for s in range(len(S)):
    A.append(S[s])
for t in range(len(T)):
    B.append(T[t])
cnt = 0
for n in range(N):
    if A[n] != B[n]:
        cnt += 1
print(cnt)

Solution (Python):
def main():
    S = str(input())
    T = str(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
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(rs())
def rs_(): return [_ for _ in rs().split()]
def ri_(): return [int(_) for _ in rs().split()]

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

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

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

ret = sum(d[0] != d[1] for d in zip(S,T))
print(ret)

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

length = len(S)

ans = 0
for i in range(length):
    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())
print(sum([s!=t for s,t in zip(S,T)]))

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

n = len(S)
r = 0

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

Solution (Python):


import sys
import math
import time

import collections
from collections import deque
from collections import Counter
import queue
import copy
import bisect
import heapq
import itertools










S = str(input())
T = str(input())
ans = 0

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

print(ans)

Solution (Python):


import math
import re
import numpy as np
import copy


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

def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())

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

print(ans)

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

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

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

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

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

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

    print(ans)
    return


if __name__ == "__main__":
    main()
    sys.exit(0)

Solution (Python):
from copy import deepcopy
import math
import string
import collections
from collections import Counter
from collections import deque
from decimal import Decimal
import sys
import fractions
from operator import itemgetter
import itertools
import copy


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


def nCr(n, r):
    return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor


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



dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]
s = input()
t = input()
if s == t:
    print(0)
    exit()
cnt = 0
for i in range(len(s)):
    if s[i] != t[i]:
        cnt += 1
print(cnt)

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

length = len(s)

ans = length
for i in range(length):
  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)
    return

if __name__=='__main__':
    main()

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

cnt = 0
for n in range(len(S)):
    if S[n] == T[n]:
        continue
    else:
        cnt += 1
        
print(cnt)

Solution (Python):
import re
import sys
from bisect import bisect, bisect_left, insort, insort_left
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from itertools import (
    accumulate, combinations, combinations_with_replacement, groupby,
    permutations, product)
from math import (acos, asin, atan, ceil, cos, degrees, factorial, gcd, hypot,
                  log2, pi, radians, sin, sqrt, tan)
from operator import itemgetter, mul
from string import ascii_lowercase, ascii_uppercase, digits


def inp():
    return(int(input()))


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


def instr():
    s = input()
    return(list(s[:len(s)]))


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


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

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

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

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()
count = 0
for i in range(len(S)):
    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
    else:
        continue

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

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

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

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


q2()

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):
s=input()
t=input()
ans=0
for i,_ in enumerate(s):
  if s[i]!=t[i]:
    ans+=1
print(ans)

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

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

count = 0

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

print(count)

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

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

if __name__ == '__main__':
    main()

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

ans = 0

st_len = len(s)

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

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

Solution (Python):
"""
~~ Author : Bhaskar
~~ Dated : 10~06~2020
"""

import sys
from bisect import *
from math import floor,sqrt,ceil,factorial as F,gcd,pi
from itertools import chain,combinations,permutations,accumulate
from collections import Counter,defaultdict,OrderedDict,deque
from array import array
INT_MAX = sys.maxsize
INT_MIN = -(sys.maxsize)-1
mod = 1000000007
ch = "abcdefghijklmnopqrstuvwxyz"
lcm = lambda a,b : (a*b)//gcd(a,b)
setbit = lambda x : bin(x)[2:].count("1")
input = lambda : sys.stdin.readline()

def solve():
    s = sys.stdin.readline().replace("\n", "")
    t = sys.stdin.readline().replace("\n", "")
    ans = 0
    for i in range(len(s)):
        if s[i] != t[i]:
            ans += 1
    print(ans)
    


if __name__ == "__main__":
    try:
        sys.stdin = open('input.txt','r')
        sys.stdout = open('output.txt','w')
    except:
       pass
    solve()

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

Solution (Python):


s, = map(str, input().split())
t, = map(str, input().split())

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

Solution (Python):




from __future__ import division, print_function 

import sys
import os
from collections import Counter, deque, defaultdict
import itertools
import math
import io


"""Uncomment modules according to your need"""













if sys.version_info[0] < 3:
    input = raw_input
    range = xrange

    filter = itertools.ifilter
    map = itertools.imap
    zip = itertools.izip



"""value of mod"""
MOD = 998244353
mod = 10**9 + 7

"""Uncomment next 4 lines if doing huge recursion"""




def prepare_factorial(mod=mod):
    """ returns two lists, factorial and inverse factorial modulo argument by default 10**9 +7 """
    
    fact = [1]
    for i in range(1, 200005):
        fact.append((fact[-1] * i) % mod)

    ifact = [0] * 200005
    ifact[200004] = pow(fact[200004], mod - 2, mod)
    for i in range(200004, 0, -1):
        ifact[i - 1] = (i * ifact[i]) % mod

    return fact, ifact

def modinv(n, p):
    """ returns N inverse modulo p """
    return pow(n, p - 2, p)

def ncr(n, r,  fact, ifact):
    """ takes 4 arguments: n , r and factorial and inverse factorial lists"""
    t = (fact[n] * (ifact[r]*ifact[n-r]) % MOD)% MOD
    return t


def get_n(Sum):    
    """this function returns the maximum n for which Summation(n) <= Sum"""
    ans = (-1 + sqrt(1 + 8*Sum))//2
    return ans

def sieve(n):
    """ returns a list of prime numbers till n """
    if n < 2: return list()
    prime = [True for _ in range(n + 1)]
    p = 3
    while p * p <= n:
        if prime[p]:
            for i in range(p * 2, n + 1, p):
                prime[i] = False
        p += 2
    r = [2]
    for p in range(3, n + 1, 2):
        if prime[p]:
            r.append(p)
    return r



def divs(n, start=1):
    """ returns a list of all divisors till n """
    divisors = []
    
    for i in range(start, int(math.sqrt(n) + 1)):
        if n % i == 0:
            if n / i == i:
                divisors.append(i)
            else:
                divisors.extend([i, n // i])
    return divisors



def divn(n, primes):
    """ returns the number of divisors, two arguments n and the sieve till n """
    divs_number = 1
    for i in primes:
        if n == 1:
            return divs_number
        t = 1
        while n % i == 0:
            t += 1
            n //= i
        divs_number *= t



def lrfind(d, x, default=-1):
    """ Takes 2 arguments an iterable and an element. returns a tuple (firstoccurence,lastoccurence) -1 if not found """
    left = right = -1
    for i in range(len(d)):
        if d[i] == x:
            if left == -1: left = i
            right = i
    if left == -1:
        return default, default
    else:
        return left, right

def gcd(x, y): 
    """ returns greatest common divisor of x and y """
    while y:
        x, y = y, x % y
    return x

def check_sorted(a):
    ''' returns True/False '''
    for i in range(len(a)-1):
        if a[i]>a[i+1]:
            return False
    return True
def ceil(n, k=1): return n // k + (n % k != 0) 
def input(): return sys.stdin.readline().strip()
def ii(): return int(input()) 
def mi(): return map(int, input().split()) 
def li(): return list(map(int, input().split())) 
def lw(): return input().split() 
def lcm(a, b): return abs(a * b) // gcd(a, b) 
def prr(a, sep=' ', end='\n'): print(sep.join(map(str, a)), end=end) 
def dd(): return defaultdict(int) 
def ddl(): return defaultdict(list) 
def write(s): return sys.stdout.write(s)














def main():
    
    s=input()
    t=input()
    count=0
    for i in range(len(s)):
        if s[i]!=t[i]:
            count+=1
    print(count)
""" -------- Python 2 and 3 footer by Pajenegod and c1729 ---------"""

py2 = round(0.5)
if py2:
    from future_builtins import ascii, filter, hex, map, oct, zip
    range = xrange

import os, sys
from io import IOBase, BytesIO

BUFSIZE = 8192

class FastIO(BytesIO):
    newlines = 0

    def __init__(self, file):
        self._file = file
        self._fd = file.fileno()
        self.writable = "x" in file.mode or "w" in file.mode
        self.write = super(FastIO, self).write if self.writable else None

    def _fill(self):
        s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
        self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
        return s

    def read(self):
        while self._fill(): pass
        return super(FastIO, self).read()

    def readline(self):
        while self.newlines == 0:
            s = self._fill();
            self.newlines = s.count(b"\n") + (not s)
        self.newlines -= 1
        return super(FastIO, self).readline()

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


class IOWrapper(IOBase):

    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        if py2:
            self.write = self.buffer.write
            self.read = self.buffer.read
            self.readline = self.buffer.readline
        else:
            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')



""" main function"""

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

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

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

print(ans)