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:

from collections import deque



# for #!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase


# region fastio

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():
    # n = int(input())
    # l = [int(j) for j in input().split()]
    

    # for t in range(int(input())):
        # n,m = [int(j) for j in input().split()]
    s = input()
    t = input()
    ans = 0
    for i in range(len(s)): 
        if s[i]!=t[i]:
            ans+=1
    print(ans)

# endregion

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
#!python3

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

Submission status: Accepted

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

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

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

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

print(count)

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:

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

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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__":
    # unittest.main()
    resolve()

Submission status: Accepted

Solution code:
#B
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:
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**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)

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 -*-

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

Submission status: Accepted

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

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

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

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

Submission status: Accepted

Solution code:
# from pprint import pprint
# import math
# import collections

# n = int(input())
s = input()
t = input()
# n, k = map(int, input().split(' '))
# a = list(map(int, input().split(' ')))

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

print(cnt)

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

Submission status: Accepted

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

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:
#!/usr/bin/env python
# coding: utf-8

# In[3]:


S = input()
T = input()


# In[4]:


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


# In[ ]:

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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,t = S_MAP()
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 SC,TC in zip(S,T):
    if SC != TC:
        Count += 1
print(Count)

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

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

print(ans)

Submission status: Accepted

Solution code:
import sys
from collections import defaultdict, Counter, namedtuple, deque
import itertools
import functools
import bisect
import heapq
import math
# from fractions import gcd

MOD = 10 ** 9 + 7
# MOD = 998244353
# sys.setrecursionlimit(10**8)


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

print(dif)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print([s == t for s, t in zip(S, T)].count(False))

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

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:

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

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

  print(num)


main()

Submission status: Accepted

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

cnt = 0

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(100000)

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

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

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

Submission status: Accepted

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

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:
#!/usr/bin/env python3
import sys

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    ss = list(input())
    ts = list(input())
    ans = 0
    for s, t in zip(ss, ts):
        if s != t:
            ans += 1
    print(ans)


if __name__ == "__main__":
    main()

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:
### ----------------
### ここから
### ----------------

import sys
from io import StringIO
import unittest

def yn(b):
    print("Yes" if b==1 else "No")
    return

def resolve():
    readline=sys.stdin.readline

    #n,m,k=map(int, readline().rstrip().split())
    #arr=list(map(int, readline().rstrip().split()))
    #n=int(readline())
    s=readline().rstrip()
    t=readline().rstrip()
    ans=0
    for i in range(len(s)):
        if s[i]!=t[i]:
            ans+=1
    print(ans)

    return

if 'doTest' not in globals():
    resolve()
    sys.exit()

### ----------------
### ここまで 
### ----------------

Submission status: Accepted

Solution code:
inpl = lambda: list(map(int,input().split()))
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 = 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:
import itertools
import decimal
import math
from collections import Counter
import sys
input = sys.stdin.readline

S=input()
T=input()

ans=0

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

print(ans)

Submission status: Accepted

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

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

print(ams)

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin,stdout
LI=lambda:list(map(int,input().split()))
MAP=lambda:map(int,input().split())
IN=lambda:int(input())
S=lambda:input()
import math
def p(a):print(" ".join(list(map(str,a))))
from collections import Counter

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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

print(res)

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 = 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:
x = 0;
s = str(input());
t = str(input());
v = len(s);

for i in range(v):
    if s[i] != t[i]:
        x += 1;
print(x);

Submission status: Accepted

Solution code:
from sys import stdin


def main():
    input = lambda: stdin.readline()[:-1]
    S = input()
    T = input()

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


main()

Submission status: Accepted

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

Submission status: Accepted

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

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

def main():
    S=input().strip("\n")
    T=input().strip("\n")
    cnt=0
    for i in range(len(S)):
        if S[i]==T[i]:
            cnt+=1
    print(len(S)-cnt)
    
    
    
if __name__=="__main__":
    main()

Submission status: Accepted

Solution code:
def main():
    s = input()
    t = input()
    res = 0
    for a, b in zip(s, t):
        if a != b:
            res += 1
    print(res)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
ma = lambda :map(int,input().split())
ni = lambda:int(input())
import collections
import math
import itertools
gcd = math.gcd
s = input()
t = input()
n = len(s)
c = 0
for i in range(n):
    if s[i] != t[i]:
        c+=1
print(c)

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:
"""
N = list(map(int,input().split()))
S = [str(input()) for _ in range(N)]
S = [list(map(int,list(input()))) for _ in range(h)] 
print(*S,sep="")
"""

import sys
sys.setrecursionlimit(10**6)
input = lambda: sys.stdin.readline().rstrip()
inf = float("inf") # 無限

s = input()
t = input()

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

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

Submission status: Accepted

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

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

print(count)

Submission status: Accepted

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

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

print(ops)

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

print(ans)

Submission status: Accepted

Solution code:
def main():
    s = input()
    t = input()
    r = 0
    for i, se in enumerate(s):
        if se != t[i]:
            r += 1
    print(r)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
S = str(input())
T = str(input())
def Main(S, T):
    ans = 0
    for s, t in zip(S, T):
        if s != t:
            ans += 1
    return ans
    
res = Main(S, T)
print(res)

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

Submission status: Accepted

Solution code:
#! /usr/bin/env python3

import sys
import numpy as np
int1 = lambda x: int(x) - 1
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

S = readline().decode().rstrip()
T = readline().decode().rstrip()

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

print(cnt)

Submission status: Accepted

Solution code:
s = input()
t = input()
l = len(s)
c = 0
for i in range(l):
    if s[i]!=t[i]:
        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:
#from collections import deque,defaultdict
from sys import stdin
input = stdin.readline
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
ins = lambda : input().strip()
DBG = True # and False
BIG = 10**18
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

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

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:
import sys
sys.setrecursionlimit(1000000000)
import math
from math import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations, chain
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok

def get_inv(n, modp):
    return pow(n, modp-2, modp)

def factorials_list(n, modp):    # 10**6
    fs = [1]
    for i in range(1, n+1):
        fs.append(fs[-1] * i % modp)
    return fs

def invs_list(n, fs, modp):     # 10**6
    invs = [get_inv(fs[-1], modp)]
    for i in range(n, 1-1, -1):
        invs.append(invs[-1] * i % modp)
    invs.reverse()
    return invs

def comb(n, k, modp):
    num = 1
    for i in range(n, n-k, -1):
        num = num * i % modp
    den = 1
    for i in range(2, k+1):
        den = den * i % modp
    return num * get_inv(den, modp) % modp

def comb_from_list(n, k, modp, fs, invs):   
    return fs[n] * invs[n-k] * invs[k] % modp

#

class UnionFindEx:
    def __init__(self, size):
        #正なら根の番号、負ならグループサイズ
        self.roots = [-1] * size
    def getRootID(self, i):
        r = self.roots[i]
        if r < 0:   #負なら根
            return i
        else:
            r = self.getRootID(r)
            self.roots[i] = r
            return r
    def getGroupSize(self, i):
        return -self.roots[self.getRootID(i)]
    def connect(self, i, j):
        r1, r2 = self.getRootID(i), self.getRootID(j)
        if r1 == r2:
            return False
        if self.getGroupSize(r1) < self.getGroupSize(r2):
            r1, r2 = r2, r1
        self.roots[r1] += self.roots[r2]    #サイズ更新
        self.roots[r2] = r1
        return True

Yes = 'Yes'
No = 'No'


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




main()

Submission status: Accepted

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

s = input().rstrip()
t = input().rstrip()
ans = 0

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

print(ans)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-


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

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

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:
a=input()
b=input()

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

Submission status: Accepted

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

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

print(sm)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
###==================================================
### import
#import bisect
#from collections import Counter, deque, defaultdict
#from copy import deepcopy
#from functools import reduce, lru_cache
#from heapq import heappush, heappop
#import itertools
#import math
#import string
import sys
### stdin
def input(): return sys.stdin.readline()
def iIn(): return int(input())
def iInM(): return map(int, input().split())
def iInM1(): return map(int1, input().split())
def iInLH(): return list(map(int, input().split()))
def iInLH1(): return list(map(int1, input().split()))
def iInLV(n): return [iIn() for _ in range(n)]
def iInLV1(n): return [iIn()-1 for _ in range(n)]
def iInLD(n): return [iInLH() for _ in range(n)]
def iInLD1(n): return [iInLH1() for _ in range(n)]
def sInLH(): return list(input().split())
def sInLV(n): return [input().rstrip("\n") for _ in range(n)]
def sInLD(n): return [sInLH() for _ in range(n)]
### stdout
def OutH(lst): print(*lst)
def OutV(lst): print(*lst, sep="\n")
### setting
sys.setrecursionlimit(10 ** 6)
### utils
int1 = lambda x: int(x) - 1
### constants
INF = int(1e9)
MOD = 1000000007
dx = (-1, 0, 1, 0)
dy = (0, -1, 0, 1)
###---------------------------------------------------

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

Submission status: Accepted

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

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