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:
# Begin Header {{{
from math import gcd
from collections import Counter, deque, defaultdict
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, merge
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
from itertools import accumulate, product, permutations, combinations, combinations_with_replacement
# }}} End Header
# _________コーディングはここから！！___________
# ... 最小側の制約も確認した？
# ... オーバーフローしない？
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 = list(input())
T = list(input())
a = len(S)
b = 0
for i in range(a):
  if not(S[i]==T[i]):
    b +=1
print(b)

Submission status: Accepted

Solution code:
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:
import sys
from io import StringIO
import unittest
import os

# 再帰処理上限(dfs作成時に設定するのが面倒なので限度近い値を組み込む)
sys.setrecursionlimit(999999999)


# 実装を行う関数
def resolve(test_def_name=""):
    s = list(input())
    t = list(input())

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

    print(ans)


# テストクラス
class TestClass(unittest.TestCase):
    def assertIO(self, assert_input, output):
        stdout, sat_in = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(assert_input)
        resolve(sys._getframe().f_back.f_code.co_name)
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, sat_in
        self.assertEqual(out, output)

    def test_input_1(self):
        test_input = """cupofcoffee
cupofhottea"""
        output = """4"""
        self.assertIO(test_input, output)

    def test_input_2(self):
        test_input = """abcde
bcdea"""
        output = """5"""
        self.assertIO(test_input, output)

    def test_input_3(self):
        test_input = """apple
apple"""
        output = """0"""
        self.assertIO(test_input, output)

    # 自作テストパターンのひな形(利用時は「tes_t」のアンダーバーを削除すること
    def tes_t_1original_1(self):
        test_input = """データ"""
        output = """データ"""
        self.assertIO(test_input, output)


# 実装orテストの呼び出し
if __name__ == "__main__":
    if os.environ.get("USERNAME") is None:
        # AtCoder提出時の場合
        resolve()

    else:
        # 自PCの場合
        unittest.main()

Submission status: Accepted

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

  ans = 0

  for i, c in enumerate(S):
    if T[i] != c:
      ans += 1

  print(ans)

if __name__ == "__main__":
  main()

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

l=len(s)

sum=0

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

print(sum)

Submission status: Accepted

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

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

print(count)

Submission status: Accepted

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

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

for c_s, c_t in zip(s, t):
    if c_s != c_t:
        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 math


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

Submission status: Accepted

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

Submission status: Accepted

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

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
    return cnt

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

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

print(ans)

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:

s = input()
t = input()

ans = 0
for sc, tc in zip(s, t):
    ans += sc != tc
print(ans)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)
INF = float("inf")


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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
import os
import itertools
import numpy as np
from collections import deque

def main():
    if os.getenv("ENV")=='LOCAL':
        sys.stdin = open(os.path.dirname(__file__)+'/input.txt', 'r')

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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 = 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:
#!/usr/bin/env python3
import sys
import numpy as np


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:
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:
import math
#map(int,input().split())
#int(x) for x in input().split()
#for _ in range(int(input())):
a=input()
b=input()
c=0
for i in range(len(a)):
	if a[i]!=b[i]:
		c+=1
print(c)

Submission status: Accepted

Solution code:
from sys import stdin, stdout

int_in = lambda: int(stdin.readline())
arr_in = lambda: [int(x) for x in stdin.readline().split()]
mat_in = lambda rows: [arr_in() for _ in range(rows)]
str_in = lambda: stdin.readline().strip()
out = lambda o: stdout.write("{}\n".format(o))
arr_out = lambda o: out(" ".join(map(str, o)))
bool_out = lambda o: out("YES" if o else "NO")
tests = lambda: range(1, int_in() + 1)
case_out = lambda i, o: out("Case #{}: {}".format(i, o))


def solve(s, t):
    result = 0
    for i in range(len(s)):
        if s[i] != t[i]:
            result += 1
    return result


if __name__ == "__main__":
    s = str_in()
    t = str_in()
    out(solve(s, t))

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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

    
    return cnt


print(solve())

Submission status: Accepted

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

ans = 0
for s, t in zip(S, T):
    if s != t:
        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:
S=input()
T=input()

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

print(cnt)

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
# import numpy as np
sys.setrecursionlimit(int(pow(10,6)))
# sys.stdin = open("input.txt", "r")
# sys.stdout = open("out.txt", "w")
mod = int(pow(10, 9) + 7)
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(*var, end="\n"): sys.stdout.write(' '.join(map(str, var))+end)
def l(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]

# @lru_cache(None)
t=1
# t=int(input())
for _ in range(t):
    s=input()
    t=input()
    ans=0
    for i in range(len(s)):
        ans+=(s[i]!=t[i])
    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 = list(input())
T = list(input())
t = 0
for i, j in zip(S, T):
    if i != j:
        t += 1
print(t)

Submission status: Accepted

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

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

Submission status: Accepted

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

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

print(n)

Submission status: Accepted

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

Submission status: Accepted

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


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

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

    print(count)


if __name__ == '__main__':
    solve()

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 = input()
T = input()

result = 0

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

print(result)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
#N, M = map(int,input().split())
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()
res = 0
for a, b in zip(S, T):
    if a != b:
        res += 1
print(res)

Submission status: Accepted

Solution code:
# coding: utf-8
#N=int(input())
#A,B=map(int, input().split())
#List=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()

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

Submission status: Accepted

Solution code:
# /usr/bin/python3
# -*- coding: utf-8 -*-
from queue import Queue
from queue import LifoQueue as Stack
from math import sqrt, floor, ceil, log2, log10, pi
from fractions import gcd
from itertools import permutations, combinations
from operator import itemgetter
from functools import cmp_to_key


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


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

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

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

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

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

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

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

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

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

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



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

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

Submission status: Accepted

Solution code:
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
 
def main():
    S = input()
    T = input()
    n = len(S)
    cnt = 0
    for i in range(n):
        if S[i] != T[i]:
            cnt += 1
    print(cnt)
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)
INF = float('inf')

S = input()
T = input()

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

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:
import sys
def S(): return sys.stdin.readline().rstrip()
S,T = S(),S()
ans = 0
for i in range(len(S)):
    if S[i]!=T[i]:
        ans += 1
print(ans)

Submission status: Accepted

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

#a = int(input())
#b = list(map(int, input().split()))
#n, m = map(int, input().split())
s = input()
t = input()
#s,t = input().split()
#a = [int(input()) for _ in range(n)]
#
#readline = sys.stdin.readline
#n,m = [int(i) for i in readline().split()]
#ab = [[int(i) for i in readline().split()] for _ in range(n)]

ans = 0

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

Submission status: Accepted

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

Submission status: Accepted

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

S = input()
T = input()

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

ans = 0

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

print(ans)

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

print(ans)

Submission status: Accepted

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

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

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

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


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

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

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

Submission status: Accepted

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

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

print(cnt)

Submission status: Accepted

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

ans = 0

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

print(ans)

Submission status: Accepted

Solution code:
# import numpy as np
# import math
# import copy
# from collections import deque
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(10000)


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

    N = len(S)
    res = 0

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

    print(res)



main()

Submission status: Accepted

Solution code:
import sys
## io ##
def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list(map(lambda x: x-1, MII()))
#======================================================#
def main():
    s = IS()
    t = IS()
    cnt = 0
    for si,ti in zip(s,t):
        if si != ti:
            cnt += 1
    print(cnt)

if __name__ == '__main__':
    main()

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

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

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

print(count)

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

counter = 0

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

Submission status: Accepted

Solution code:
input = raw_input

s = input()
t = input()

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
from sys import stdin
from operator import itemgetter
from collections import deque, Counter
import math
import pprint
from functools import reduce
# stdin = open("sample.txt")

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

def keta(kazu): # 入力されたintを桁ごとに分解，リストで出力
    kazu_str = str(kazu)
    kazu_list = [int(kazu_str[i]) for i in range(0, len(kazu_str))]
    return kazu_list

def gcd(*numbers): # 最小公倍数
    return reduce(math.gcd, numbers)

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

def pow_k(x,n):  # (x**n)の計算の高速化
    if n == 0:
        return 1
    K = 1
    while n > 1:
        if n % 2 != 0:
            K *= x
        x *= x
        n //= 2
    return K * x

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import numpy as np

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

print(ans)

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:
import sys
input = sys.stdin.buffer.readline

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

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# B

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

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)