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.



Sample input:
cupofcoffee
cupofhottea


Sample output:
4

Submission status: Accepted

Solution code:
#import numpy as np
#import functools
#import operator
#from itertools import combinations as comb
#from itertools import combinations_with_replacement as comb_with
#from itertools import permutations as perm
#import collections as C #most_common
#import math


#N = int(input())
#A,B= map(int,input().split())
#P = list(map(int,input().split()))
S = str(input())
T = str(input())
c=0
for i in range(len(S)):
    if S[i]!=T[i]:
        c+=1
print(c)

Submission status: Accepted

Solution code:
import sys

readline = sys.stdin.readline
readlines = sys.stdin.readlines
ns = lambda: readline().rstrip() # input string
ni = lambda: int(readline().rstrip()) # input int
nm = lambda: map(int, readline().split()) # input multiple int 
nl = lambda: list(map(int, readline().split())) # input multiple int to list

s = input()
t = input()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin
input = stdin.readline

S = input().rstrip()
T = input().rstrip()

ans = 0

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

print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

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

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

    print(ans)

if __name__ == '__main__':
    resolve()

Submission status: Accepted

Solution code:
def main():
    s = input()
    t = input()
    ans = sum(c1 != c2 for c1, c2 in zip(s, t))
    print(ans)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

cnt = 0

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
from collections import defaultdict
ml=lambda:map(int,input().split())
ll=lambda:list(map(int,input().split()))
ii=lambda:int(input())
ip=lambda:list(input())
ips=lambda:input().split()

"""========main code==============="""

n=ip()
m=ip()
ans=0
for i in range(len(n)):
    if(n[i]!=m[i]):
        ans+=1
print(ans)

Submission status: Accepted

Solution code:
def main():
    S = input()
    T = input()
    count = 0
    for s, t in zip(S, T):
        if s != t:
            count += 1
    print(count)
if __name__ == '__main__':
    main()

Submission status: Accepted

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

n = len(s)

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
# from math import sqrt, gcd, ceil, log
from bisect import bisect_left
from collections import defaultdict, Counter
inp = sys.stdin.readline
read = lambda: list(map(int, inp().strip().split()))

# sys.setrecursionlimit(10**6)



def solve():
	s = inp(); t = inp(); ans = 0
	for i in range(len(s)):
		ans += (s[i] != t[i])
	print(ans)


		

if __name__ == "__main__":
	solve()

Submission status: Accepted

Solution code:
def input_int():
    return map(int, input().split())

def one_int():
    return int(input())

def one_str():
    return input()

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

S=one_str()
T=one_str()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))

S = input()
T = input()

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

print(ans)

Submission status: Accepted

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

print(cnt)

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

print(res)

Submission status: Accepted

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

n=len(s)

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

Submission status: Accepted

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

print(sum([s[i] != t[i] for i in range(len(s))]))

Submission status: Accepted

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


if __name__ == '__main__':
    resolve()

Submission status: Accepted

Solution code:
import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline

in_n = lambda: int(readline())
in_nn = lambda: map(int, readline().split())
in_nl = lambda: list(map(int, readline().split()))
in_na = lambda: map(int, read().split())
in_s = lambda: readline().rstrip().decode('utf-8')


def main():

    S = in_s()
    T = in_s()

    N = len(S)

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

    print(count)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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]:
        ans += 1
print(ans)

Submission status: Accepted

Solution code:
S, T = [input(), input()]
ans = 0
for s, t in zip(S, T):
    ans += (s != t)
print(ans)

Submission status: Accepted

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

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

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#float型を許すな
#numpyはpythonで
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi,factorial
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
inf = 10**17
mod = 10**9 + 7

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

Submission status: Accepted

Solution code:
import sys
def S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
INF = 1000000000000

s = S()
t = S()

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

print(count)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

s = input()
t = input()


a = 0

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

Submission status: Accepted

Solution code:
import sys


def input(): return sys.stdin.readline().strip()
def I(): return int(input())
def LI(): return list(map(int, input().split()))
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def S(): return input()
def LS(): return input().split()


s = S()
t = S()
ans = 0
for c1, c2 in zip(s, t):
    if c1 != c2:
        ans += 1
print(ans)

Submission status: Accepted

Solution code:
import math
import fractions
import collections
import itertools
S=input()
T=input()
cnt=0
for i in range(len(S)):
    if S[i]!=T[i]:
        cnt=cnt+1
print(cnt)

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
s = input().strip()
t = input().strip()

cnt = 0
for cs, ct in zip(s, t):
    cnt += 0 if cs == ct else 1

print(cnt)

Submission status: Accepted

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

Submission status: Accepted

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

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

print(ans)

Submission status: Accepted

Solution code:
import sys
import math
from collections import deque

sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(input())
NMI = lambda: map(int, input().split())
NLI = lambda: list(NMI())
SI = lambda: input()


def make_grid(h, w, num): return [[int(num)] * w for _ in range(h)]


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

if __name__ == "__main__":
    main()

Submission status: Accepted

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

ans = 0
l = len(s)

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

Submission status: Accepted

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

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

print(c)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
S = input().strip()
T = input().strip()

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

Submission status: Accepted

Solution code:

s = list(input())

t = list(input())

cnt = 0

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

Submission status: Accepted

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

resolve()

Submission status: Accepted

Solution code:
s,t,c = raw_input(), raw_input(), 0
for u,v in zip(s,t):
	if u != v: c+=1
print c

Submission status: Accepted

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

print(ans)

Submission status: Accepted

Solution code:
s = list(str(input()))
t = list(str(input()))
num = 0

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

Submission status: Accepted

Solution code:
# coding: utf-8
s = input()
t = input()
ans = 0
for i in range(len(s)):
    if s[i] != t[i]:
        ans += 1

print(ans)

Submission status: Accepted

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

print(ans)

Submission status: Accepted

Solution code:
s = input()
t = input()
ans = len(s)

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

print(ans)

Submission status: Accepted

Solution code:
import sys
import math
def II():
	return int(sys.stdin.readline())

def LI():
	return list(map(int, sys.stdin.readline().split()))

def MI():
	return map(int, sys.stdin.readline().split())

def SI():
	return sys.stdin.readline().strip()
s = SI()
t = SI()
count = 0
for i in range(len(s)):
	if s[i] !=t[i]:
		count+=1
print(count)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

'''

'''

s = input().strip()
t = input().strip()
print(sum(1 if c1 != c2 else 0 for c1, c2 in zip(s, t)))

Submission status: Accepted

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

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

print(cnt)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import numpy as np
import sys
from collections import deque
from collections import defaultdict
import heapq
import collections
import itertools
import bisect


def zz():
    return list(map(int, sys.stdin.readline().split()))


def z():
    return int(sys.stdin.readline())


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


def C(line):
    return [sys.stdin.readline() for _ in range(line)]


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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin

A=stdin.readline()
B=stdin.readline()
count=0

for k in range(0,len(A)):
    if A[k]!=B[k]:
        count+=1

print(count)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
s = input()
t = input()
count = 0
i = 0
while i < len(s):
    if s[i] != t[i]:
        count+=1
    i+=1
print(count)

Submission status: Accepted

Solution code:
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.buffer.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.buffer.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
import time
from collections import defaultdict, deque
from sys import stdin, stdout
from bisect import bisect_left, bisect_right
s=input()
t=input()
ans=0
for i in range(len(s)):
    if(s[i]!=t[i]):
        ans+=1
print(ans)

Submission status: Accepted

Solution code:
s = input()
t = input()
ans = 0
for x,y in zip(s,t):
  if x != y:
    ans += 1
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

count = 0

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

Submission status: Accepted

Solution code:
## coding: UTF-8

S = input()
T = input()
L = len(S)

ans = 0

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

print(ans)

Submission status: Accepted

Solution code:
import sys
#import string
#from collections import defaultdict, deque, Counter
#import bisect
#import heapq
#import math
#from itertools import accumulate
#from itertools import permutations as perm
#from itertools import combinations as comb
#from itertools import combinations_with_replacement as combr
#from fractions import gcd
#import numpy as np

stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
MIN = -10 ** 9
MOD = 10 ** 9 + 7
INF = float("inf")
IINF = 10 ** 18

def solve():
    s = str(stdin.readline().rstrip())
    t = str(stdin.readline().rstrip())
    #A, B, C = map(int, stdin.readline().rstrip().split())
    #l = list(map(int, stdin.readline().rstrip().split()))
    #numbers = [[int(c) for c in l.strip().split()] for l in sys.stdin]
    #word = [stdin.readline().rstrip() for _ in range(n)]
    #number = [[int(c) for c in stdin.readline().rstrip()] for _ in range(n)]
    #zeros = [[0] * w for i in range(h)]
    ans = 0
    for i in range(len(s)):
        if s[i] != t[i]:
            ans += 1
    print(ans)


if __name__ == '__main__':
    solve()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
print(len([1 for s, t in zip(input(), input()) if s != t]))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
import sys
read = sys.stdin.read
readline = sys.stdin.readline

s = input()
t = input()

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

Submission status: Accepted

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


print(count)

Submission status: Accepted

Solution code:
s=input()
s1=input()
l=list(s)
l1=list(s1)
ans=0
for i in range(len(l)):
    if l[i]!=l1[i]:
        ans=ans+1
print(ans)

Submission status: Accepted

Solution code:
def main():
	k = list(str(input()))
	k2 = list(str(input()))
	ans = 0
	for i in range(len(k)):
		if k[i] == k2[i]:
			continue
		else:
			ans += 1
	print(ans)


if __name__ == '__main__':
	main()

Submission status: Accepted

Solution code:
s=input().rstrip('\n')
t=input().rstrip('\n')
r=0
for i in range(len(s)):
  if(s[i]!=t[i]):
    r+=1
print(r)

Submission status: Accepted

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

Submission status: Accepted

Solution code:

def s0():return input()
def s1():return input().split()
def s2(n):return [input() for x in range(n)]
def s3(n):return [input().split() for _ in range(n)]
def s4(n):return [[x for x in s] for s in s2(n)]
def n0():return int(input())
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(input()) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]
def t3(n):return [tuple(int(x) for x in input().split()) for _ in range(n)]
def p0(b,yes="Yes",no="No"): print(yes if b else no)
# from sys import setrecursionlimit
# setrecursionlimit(1000000)
# from collections import Counter,deque,defaultdict
# import itertools
# import math
# import networkx as nx
# from bisect import bisect_left,bisect_right
# from heapq import heapify,heappush,heappop
s=s0()
t=s0()

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

Submission status: Accepted

Solution code:
#s = input()
#n = int(input())
#a, b, c = map(int, input().split())
#p = list(map(int, input().split()))

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline


def read():
    S = input().strip()
    T = input().strip()
    return S, T


def solve(S, T):
    count = 0
    for x, y in zip(S, T):
        if x != y:
            count += 1
    return count


if __name__ == '__main__':
    inputs = read()
    outputs = solve(*inputs)
    if outputs is not None:
        print("%s" % str(outputs))

Submission status: Accepted

Solution code:
import sys, os, math, bisect, itertools, collections, heapq, queue
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
from decimal import Decimal
from collections import defaultdict

# import fractions

sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)
# lcm = lambda x, y: (x * y) // fractions.gcd(x, y)

MOD = 10 ** 9 + 7
MAX = float('inf')


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    A = iss()
    B = iss()

    ret = 0
    for a, b in zip(A, B):
        if a != b: ret+=1
    print(ret)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
Ss = input().rstrip()
Ts = input().rstrip()

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

print(ans)

Submission status: Accepted

Solution code:
import sys, math
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7

S = rs()
T = rs()

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

Submission status: Accepted

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

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

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
S=input()
T=input()
N=len(S)
answer=0
for n in range(N):
    if S[n]!=T[n]:
        answer+=1
print(answer)

Submission status: Accepted

Solution code:

from collections import defaultdict
con = 10 ** 9 + 7; INF = float("inf")

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

#処理内容
def main():
	S = input()
	T = input()
	N = len(S)
	ans = 0
	for i in range(N):
		if S[i] != T[i]:
			ans += 1


	print(ans)




if __name__ == '__main__':
	main()

Submission status: Accepted

Solution code:
def examA():
    N = I()
    ans = N + N**2 + N**3
    print(ans)
    return

def examB():
    S = SI()
    T = SI()
    ans = 0
    for s,t in zip(S,T):
        if s!=t:
            ans += 1
    print(ans)
    return

def examC():
    ans = 0
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    ans = 0
    print(ans)
    return

def examF():
    ans = 0
    print(ans)
    return

from decimal import getcontext,Decimal as dec
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(input())
def LI(): return list(map(int,sys.stdin.readline().split()))
def DI(): return dec(input())
def LDI(): return list(map(dec,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = dec("0.000000000001")
alphabet = [chr(ord('a') + i) for i in range(26)]
alphabet_convert = {chr(ord('a') + i): i for i in range(26)}

getcontext().prec = 28

sys.setrecursionlimit(10**7)

if __name__ == '__main__':
    examB()

"""
142
12 9 1445 0 1
asd dfg hj o o
aidn
"""

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

s = input()
t = input()

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

print(ans)

Submission status: Accepted

Solution code:
def resolve():
    S= input()
    T = input()
    co=0
    for i,j in zip(S,T):
        if i!=j:
            co+=1
    print(co)

resolve()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# Template 1.0
import sys, re
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, log
from heapq import heappush, heappop, heapify, nlargest, nsmallest
def STR(): return list(input())
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def sortListWithIndex(listOfTuples, idx):   return (sorted(listOfTuples, key=lambda x: x[idx]))
def sortDictWithVal(passedDic):
    temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))
    toret = {}
    for tup in temp:
        toret[tup[0]] = tup[1]
    return toret
def sortDictWithKey(passedDic):
    return dict(OrderedDict(sorted(passedDic.items())))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

s = input()

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

print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def LI():return list(map(int,input().split()))
from collections import Counter, deque, defaultdict
from heapq import heappop, heappush
import numpy as np
import math
# p=math.pi


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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
S = input()
T = input()
cnt = 0

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline

S = input().rstrip()
T = input().rstrip()

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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