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

Submission status: Accepted

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

    print(count)
    



if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
import sys

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

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

solve()

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

print(cnt)

Submission status: Accepted

Solution code:
S=str(input())
T=str(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()
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)):
    s = S[i]
    t = T[i]
    
    if (s != t):
        cnt += 1
 
print(cnt)

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

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()
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 get_input() -> tuple:
    """
    標準入力を取得する.

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

    return S, T


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

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

    # 結果出力
    print(ans)


if __name__ == "__main__":
    # 標準入力を取得
    S, T = get_input()

    # メイン処理
    main(S, T)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from itertools import permutations, accumulate, combinations, combinations_with_replacement
from math import sqrt, ceil, floor, factorial
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy
from operator import itemgetter
from functools import reduce, lru_cache  # @lru_cache(None)
from fractions import gcd
import sys  # def input(): return sys.stdin.readline().rstrip() # sys.setrecursionlimit(10**6)

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

print(count)

Submission status: Accepted

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

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))


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


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

    return


if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

print(sum)

Submission status: Accepted

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

Submission status: Accepted

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

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

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

Submission status: Accepted

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

ans = 0

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

Submission status: Accepted

Solution code:
###############################################################################
#Imports
import collections
import itertools
from functools import lru_cache
import sys
import math
from decimal import Decimal
###############################################################################
#Constants
MOD = int(1e9)+7
###############################################################################
#Helper
def helper():
	pass
###############################################################################
#Solver
def solve():
	s=input()
	t=input()
	count = 0
	for i in range(len(s)):
		if s[i]!=t[i]: count+=1
	print(count)
###############################################################################
#Driver
t = 1
for _ in range(t):
	solve()
###############################################################################

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
S = list(input())
T = list(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(0, len(S)):
  if S[i] != T[i]:
    ans = ans + 1
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

print(result)

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

print(cnt)

Submission status: Accepted

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

Submission status: Accepted

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

sum = 0

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

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:
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:
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:
# B - Minor Change
def main():
    S, T = open(0).read().split()
    print(sum(s != t for s, t in zip(S, T)))


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
s = list(input())
t = list(input())
ans = 0
for i, j in zip(s, t):
    if i == j:
        continue
    else:
        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:
import sys
import math
import collections

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


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


if __name__ == '__main__':
    # set_debug(True)

    # t = int(input())
    t = 1

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

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

        print(res)

Submission status: Accepted

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

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

if __name__ == "__main__":
    solve()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

def II(): return int(input())
def MII(): return map(int, input().split())
def LII(): return list(map(int, input().split()))

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

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

    print(ans)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

print(r)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

a = 0

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(300000)

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


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

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:
line = list(input())
line2 = list(input())

x = 0
num = (len(line))

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# Author: S Mahesh Raju
# Username: maheshraju2020
# Date: 27/06/2020

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

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

for i in range(len(s)):
    if s[i] == t[i]:
        continue
    else:
        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 = list(input())
T = list(input())

num = 0
count = 0

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

print(count)

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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


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


# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    S = next(tokens)  # type: str
    T = next(tokens)  # type: str
    solve(S, T)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
sf=input()
tf=input()
print(sum(s!=t for s,t in zip(sf,tf)))

Submission status: Accepted

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

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

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

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

import sys
sys.setrecursionlimit(300000)


def solve(S: str, T: str):
    ret = 0
    for i in range(len(S)):
        if S[i] != T[i]:
            ret += 1
    print(ret)
    return

def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    S = next(tokens)  # type: str
    T = next(tokens)  # type: str
    solve(S, T)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#n = int(input())
#a = [int(z) for z in input().split()]
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()
ans = 0
for a,b in zip(s,t):
    if a != b:
        ans += 1
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

s = list(S)
t = list(T)
ans = 0
#なんこ違いがあるか考えればいい

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

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

Submission status: Accepted

Solution code:
import math
import sys
S=input()
T=input()
cnt=0
for i in range(len(S)):
  cnt+=int(S[i]!=T[i])
print(cnt)

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:

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

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


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


if __name__ == '__main__':
    solve()

Submission status: Accepted

Solution code:
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
import copy


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

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 n in range(len(S)):
  if S[n]!=T[n]:ans+=1
print(ans)

Submission status: Accepted

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

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

n = 0

al = list(a)
bl = list(b)

for ai,bi in zip(al,bl):
 if ai != bi:
  n = n + 1

print(n)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

#############
# Libraries #
#############

import sys
input = sys.stdin.readline

import math
#from math import gcd
import bisect
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache

#############
# Constants #
#############

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

#############
# Functions #
#############

######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(input()) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]

######OUTPUT######
def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()

#####Shorten#####
def DD(arg): return defaultdict(arg)

#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)

######Combination######
kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n): return kaijo_memo[n]
  if(len(kaijo_memo) == 0): kaijo_memo.append(1)
  while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if n == r: return 1
  if n < r or r < 0: return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret

######Factorization######
def factorization(n):
  arr = []
  temp = n
  for i in range(2, int(-(-n**0.5//1))+1):
    if temp%i==0:
      cnt=0
      while temp%i==0: 
        cnt+=1 
        temp //= i
      arr.append([i, cnt])
  if temp!=1: arr.append([temp, 1])
  if arr==[]: arr.append([n, 1])
  return arr

#####MakeDivisors######
def make_divisors(n):
  divisors = []
  for i in range(1, int(n**0.5)+1):
    if n % i == 0:
      divisors.append(i)
      if i != n // i: 
        divisors.append(n//i)
  return divisors

#####MakePrimes######
def make_primes(N):
  max = int(math.sqrt(N))
  seachList = [i for i in range(2,N+1)]
  primeNum = []
  while seachList[0] <= max:
    primeNum.append(seachList[0])
    tmp = seachList[0]
    seachList = [i for i in seachList if i % tmp != 0]
  primeNum.extend(seachList)
  return primeNum

#####GCD#####
def gcd(a, b):
    while b: a, b = b, a % b
    return a

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

#####BitCount#####
def count_bit(n):
  count = 0
  while n:
    n &= n-1
    count += 1
  return count

#####ChangeBase#####
def base_10_to_n(X, n):
  if X//n: return base_10_to_n(X//n, n)+[X%n]
  return [X%n]

def base_n_to_10(X, n):
  return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))

def base_10_to_n_without_0(X, n):
  X -= 1
  if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]
  return [X%n]

#####IntLog#####
def int_log(n, a):
  count = 0
  while n>=a:
    n //= a
    count += 1
  return count

#############
# Main Code #
#############
A = S()
B = S()
N = len(A)
count = 0
for i in range(N):
  if A[i] != B[i]:
    count += 1
print(count)

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7


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


if __name__ == '__main__':
    resolve()

Submission status: Accepted

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

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

print(j)

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

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
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:
bef = input()
aft = input()
answer = 0
count = 0
i = 1

    
for i in range(len(bef)):
  if bef[count] == aft[count]:
    count += 1
    i += 1
  else:
    answer += 1
    i += 1
    count += 1
print(answer)

Submission status: Accepted

Solution code:
import sys

def LS2(): return list(sys.stdin.readline().rstrip())  #空白なし

S = LS2()
T = LS2()

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

print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
S, T = open(0).read().split()
count = 0
for index, x in enumerate(S):
    if x != T[index]:
        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)