TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: 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.

Submission attempts (in order):
N,K=map(int,input().split())
p=list(map(int,input().split()))
p.sort()
res=0
for x in p[:K]:
	res+=x

print(res)

S=input()
T=input()

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
s = input()
t = input()
count=0
for i in len(s):
  if s[i] == t[i]:
    count+=1
print(count)

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


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


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
# -*- coding: utf-8 -*-
S = list(input())
T = list(input())
total = 0
for num in range(len(S)):
  if S[num] == T[num]:
    total +=1
print(total)

# -*- coding: utf-8 -*-
S = list(input())
T = list(input())
total = 0
for num in range(len(S)):
    if S[num] != T[num]:
        total += 1
print(total)

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
[s,t]=input().split();
cnt = 0;
for i in range(len(s)):
    if s[i] != t[i] :
        cnt=cnt+1;
print(cnt);


[s,t]=input().split();

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

#[s,t]=input().split();
s=input();
t=input();
cnt = 0;
for i in range(len(s)):
    if s[i] != t[i] :
        cnt=cnt+1;
        
print(cnt);

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
S = input()
T = input()
a = o
for i in len(S):
  if S[i] != T[i]:
    a += 1
print(a)
    

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
S = input()
T = input()
count = 0
for i in len(S):
    if S[i] != T[i]:
        count+= 1
print(count)



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


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



Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
s = input()
t = input()

int t = 0

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




s = input()
t = input()

count = 0

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


Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
a = input()
b = input()
ans = 0
for i in range(len(a)):
  if a[i] == b[i]:
    ans += 1
print(ans)

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


Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
a=input()
b=input()
count=0
for i in range(len(a)):
  if a[i]==b[i]:
    count+=1
print(count)

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


Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
s=input()
t=input()
l=len(s)
count=0
if(s==t):
  break
else:
  for i in range(l):
    if(s[i]==t[i]):
      continue
    else:
      count+=1

print(count)

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

  print(count)


Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
S= input()
T= input()

count = 0
i = 0
while i < len(S):
    print("len" + str(len(S)))
    print("S[i]:" + S[i])

    if S[i] != T[i]:
        count+=1
    i+=1

print(count)


S= input()
T= input()

count = 0
i = 0
while i < len(S):
    print("len" + str(len(S)))
    print("S[i]:" + S[i])

    if S[i] != T[i]:
        count+=1
    i+=1

print(count)


S= input()
T= input()

x = 0
i = 0
while i < len(S):
    if S[i] != T[i]:
        x += 1
    i+=1

print(x)


Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: 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.

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

print(int((count+1)/2))

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

print(count)

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
S = input()
T = input()
counter = 0

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

print(counter)

S = list(i for i in input())
T = list(i for i in input())

counter = 0

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

print(counter)

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
s = input()
t = input()

count = 0

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

print(count)


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

print(count)

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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
S = input()
T = input()

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

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
S = input()
T = input()
sum = 0
for i in range(len(S)):
  if S[i-1] <> T[i-1]:
    sum = sum + 1
print(sum)  

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
S = input()
T = input()

n = 1

for a in range len(S)

if S[a] = T[a] :
    n += 1

return n

S = input()
T = input()

n = 0

for a in range(len(S)) :

    if not S[a] == T[a] :
        n += 1

print(n)

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
first_string = "abcde"
second_string = "abcfd"
count = 0

for x, y in zip(first_string, range(len(first_string))):
    if(second_string[y] != x):
        count += 1
print(count)

first_string = input()
second_string = input()
count = 0

for x, y in zip(first_string, range(len(first_string))):
    if(second_string[y] != x):
        count += 1
print(count)

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
def distance(x, y):
    return (x ** 2 + y ** 2) ** (1 / 2)


def main():
    n, d = map(int, input().split())
    xy_lst = [list(map(int, input().split())) for _ in range(n)]
    count = 0

    for i in range(n):
        x = xy_lst[i][0]
        y = xy_lst[i][1]
        if distance(x, y) <= d:
            count += 1

    print(count)


if __name__ == '__main__':
    main()

s = str(input())
t = str(input())
count = 0

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
s = list(input())
t = list(input())
print(sum([1 for x, y in zip(s, t) if x != y])

s = input()
t = input()
print(sum([1 for x, y in zip(s, t) if x != y]))

Verdicts: Runtime Error

Accepted
Problem: 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.

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

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
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()


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


Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
S = input()
T = input()

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

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
s,t=input().split()
ans=0
for i in range(len(s)):
  if s[i]!=t[i]:
    ans+=1
print(ans)

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

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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
s = input()
t = input()

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

s = input()
t = input()

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
S=input()
T=input()
k=0
i=0
while S!=T	
	if S[i]==T[i]:
  	else:
      k+=1
    i+=1

print(k)

ソースコード 

Copy
Copy
S=input()
T=input()
k=0
i=0

while i==len(S)
	if S[i]==T[i]:
  	else:
      k+=1
    i+=1
    end

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

print(k)

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

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

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

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
S=str(input())
T=str(input())
sum=0

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

print(sum)

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

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

print(sum)

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
S = input()
T = input()
print(sum(s != t for s, t in zip(S, T))

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
S = input().split()
S = list(S)
T = input.split()
T = list(T)
for i in S:
  if(S[i]!=T[i]):
    count++;

print(count)

ST = input().split()
S = list(S)
T = list(T)
for i in S:
  if(S[i]!=T[i]):
    count++
 
print(count)

S = input().split()
S = list(S)
T = input.split()
T = list(T)
for i in S:
  if(S[i]!=T[i]):
    count++
 
print(count)

S = input()
s = list(S)
T = input()
t = list(T)
s1=s[0]
t1=t[0]
count = 0
j=0
for i in S:
  if(s[j]!=t[j]):
    count=count+1
  j=j+1
print(count)

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
s=list(input().split())
t=list(input().split())
ans=0
for i in range(len(s)):
  if s[i]!=t[i]:
    ans+=1
print(ans)

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



Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
S = input()
T = input()
s = list(S)
t = list(T)
K = len(s)
n=0
for i in range(0, K):
  if s[i] == t[i]:
    n+=1
  else:
    pass
print(n)

S = input()
T = input()
s = list(S)
t = list(T)
K = len(s)
n=0
for i in range(0, K):
  if s[i] != t[i]:
    n+=1
  else:
    pass
print(n)

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
s = list(input())
t = list(input())
i = 0
cnt = 0
while (i < len(s)):
    if s != t:
       cnt += 1
    i += 1
print(cnt)

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
def minchange(s,t):
  m=len(s)
  n=len(t)
  if n!=m:
    return -1
  cnt=[0]*256
  for i in range(n):
    cnt[ord(t[i])]+=1
  for i in range(n):
    cnt[ord(s[i])]-=1
  for i in range(256):
    if cnt[i]:
      return -1
  res=0
  i=n-1
  j=n-1
  while i>=0:
    while i>=0 and s[i]!=t[i]:
      i-=1
      res+=1
    if i>=0:
      i-=1
      j-=1
  return res
s=input()
t=input()
print(str(minchange(s,t)))
      
  


def minchange(s,t):
  m=len(s)
  n=len(t)
  if n!=m:
    return -1
  cnt=[0]*256
  for i in range(n):
    cnt[ord(t[i])]+=1
  for i in range(n):
    cnt[ord(s[i])]-=1
  for i in range(256):
    if cnt[i]:
      return -1
  res=0
  i=n-1
  j=n-1
  while i>=0:
    while i>=0 and s[i]!=t[i]:
      i-=1
      res+=1
    if i>=0:
      i-=1
      j-=1
  return res
s=input()
t=input()
print(str(minchange(s,t))
      
  


def minchange(s,t):
  m=len(s)
  n=len(t)
  if n!=m:
    return -1
  cnt=[0]*256
  for i in range(n):
    cnt[ord(t[i])]+=1
  for i in range(n):
    cnt[ord(s[i])]-=1
  for i in range(256):
    if cnt[i]:
      return -1
  res=0
  i=n-1
  j=n-1
  while i>=0:
    while i>=0 and s[i]!=t[i]:
      i-=1
      res+=1
    if i>=0:
      i-=1
      j-=1
  return res
s=input()
t=int(input())
print(str(minchange(s,t))
      
  

def minchange(s,t):
  m=len(s)
  n=len(t)
  if n!=m:
    return -1
  cnt=[0]*256
  for i in range(n):
    cnt[ord(t[i])]+=1
  for i in range(n):
    cnt[ord(s[i])]-=1
  res=0
  i=n-1
  j=n-1
  while i>=0:
    while i>=0 and s[i]!=t[i]:
      i-=1
      res+=1
    if i>=0:
      i-=1
      j-=1
  return res
s=input()
t=input()
print(str(minchange(s,t)))
      
  


Verdicts: Wrong Answer

Runtime Error

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
from sys import stdin
s = stdin.readline().rstrip()
t = stdin.readline().rstrip()

#print(s, t)

a = [x for x in s]
b = [x for x in t]

count = 0

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


from sys import stdin
s = stdin.readline().rstrip()
t = stdin.readline().rstrip()

#print(s, t)

a = [x for x in s]
b = [x for x in t]

count = 0

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


Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
s = input().split()
t = input().split()
c = 0

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

print(str(c))


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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
S = input()
T = input()
W = 0
for i in range(len(S)):
    if S[i] != T[i]:
        w += 1
print(W)

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


Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
S = input()
T = input()
sum(S[i] != T[i] for i in range(len(S)))

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
s = input()
t = input()

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

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
s,t=input().split()
u=0
for i in range(0,len(s)):
    if s[i]!=t[i]:
        u+=1
print(u)


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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
s = input()
t = input()
ans = 0
for i in range(lne(s)):
  ans +=(s[i]!=t[i])
  
print(ans)

s = input()
t = input()

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

print(ans)

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
S=input()
T=input()
cnt=0
for i in len(S):
  if(S[i]==T[i]):
    cnt+=1
    
print(cnt)

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
S = input()
T = input()

res = sum(1 if s == t else 0 for s, t in zip(S,T))
print(res)

S = input()
T = input()
 
res = sum(0 if s == t else 1 for s, t in zip(S,T))
print(res)

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
s = input()
t = input()
cnt = 0
for i in len(s):
  if s[i] != t[i]:
    cnt += 1
    
print(cnt)

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
S=input()
T=input()
cout=0
for i in len(S):
  if S[i]!=T[i]:
    cout=cout+1
print (cout)

S=input()
T=input()
if S==T:
      print('0')
elif S!=T:
    STand = set(S) & set(T)
    STlist = list(STand )
    print(len(STlist))

S=str(input())
T=str(input()
if S==T:
      print('0')

S= list(map(str, input().split()))
T= list(map(str, input().split()))

STand = set(S) & set(T)
STlist = list(STand )
print(len(STlist))

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

Verdicts: Runtime Error

Wrong Answer

Runtime Error

Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
import sys
readline= sys.stdin.buffer.readline

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

count=0
for idx, i in enumerate(s):
  if s[idx]!=t[idx]:
    count+=1
print(count)

s = input()
t = input()

count=0
for idx, i in enumerate(s):
  if s[idx]!=t[idx]:
    count+=1
print(count)

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
S = input()
T = input()
ans = 0

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

print(ans)


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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
S = list(input ())
T = list(input ())
a = len(S)
change_time = 0

for i in a:
  if (S[i] ==T[i])
  continue
  
  else:
  S[i] =T[i]
  change_time += 1
  
  
print(change_time)

S = list(input ())
T = list(input ())
a = len(S)
change_time = 0
 
for i in range(a):
  if S[i] ==T[i]:
  	continue
  
  else:
 
  	change_time += 1
  
  
print(change_time)

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
a = input().split()
b = input().split()

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

a = input()
b = input()

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



Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
s=input()
t=input()

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

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

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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
s = input()
t = input()

print(len(list(set(s) - set(t))))

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

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
s,t = map(list, input().split())
k = []
for i in range(len(s)):
    k.append(s[i] == t[i])
print(len(s)-sum(k))

s,t = map(list, input().split())
k = []
for i in range(len(s)):
    k.append(s[i] !=t[i])
print(sum(k))

s = list(input())
t = list(input())
k = []
for i in range(len(s)):
    k.append(s[i] == t[i])
print(len(s)-sum(k))

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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.

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

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
def main():
    S = input()
    T = input()
    count = 0
    for i in len(S):
        if S[i] != T[i]:
            count+=1
    print(count)


if __name__  == '__main__':
    main()

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
word1=list(input())
word2=list(input2())
i = 0
for i, j in word1, word2 :
  if i!=J:
    i++
print(i)
    

word1 = list(input())
word2 = list(input())
i = 0
for p, q in zip(word1, word2):
	if p!=q:
		i+=1
print(i)

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
import timeit

a = [input() for i in range(2)]

S = a[0]
T = a[1]

def count_diff2(S,T):
    cnt = 0
    for c1,c2 in zip(S, T):
        if c1 != c2:
            cnt += 1
    return cnt

print(timeit.timeit(lambda: count_diff2(S,T)))

import timeit

a = [input() for i in range(2)]

S = a[0]
T = a[1]

def count_diff2(S,T):
    cnt = 0
    for c1,c2 in zip(S, T):
        if c1 != c2:
            cnt += 1
    return cnt

print(count_diff2(S,T))


Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
s = input()
t = input()

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

print(i)

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
S = input()
T = input()
ans = 0
for i in range(S):
  if S[i+1] == T[i+1]:
    ans += 1
print(ans)

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

print(ans)

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
first_str = input().split()
anwser_str = input().split()
cnt = 0
for i in range(len(first_str)):
    if first_str[i] != anwser_str[i]:
        first_str[i] = anwser_str[i]
        cnt += 1

print(cnt)

first_str = list(input())
anwser_str = list(input())
cnt = 0
for i in range(len(first_str)):
    if first_str[i] != anwser_str[i]:
        first_str[i] = anwser_str[i]
        cnt += 1
print(cnt)

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
import re
s = input()
t = input()
result=0
if(re.fullmatch(r'[a-z]{1-20000}', s) and re.fullmatch(r'[a-z]{1-20000}', t)):
    for i, j in s, t:
        if i==j:
            result+=1
    print(result)

import re
S = input()
T = input()
result=0
if(len(S)!=len(T)):
    pass
elif(re.fullmatch(r'[a-z]{1,200000}', S) and re.fullmatch(r'[a-z]{1,200000}', T)):
    for i in range(len(S)):
        if S[i]!=T[i]:
            result+=1
    print(result)

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
s=input()
t=input()
count=0
for i in s:
    if s[i] != t[i]:
        count += 1
print(count)

s=input().split()
t=input().split()
count=0
for i in s:
    if s[i] != t[i]:
        count += 1
print(count)

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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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.

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

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

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

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
s = input()
t = input()

result = 0
for i, v in enumerate(s):
  if t[i] !== v :
    result += 1
    
print(result)

s = input()
t = input()

result = 0
for i, v in enumerate(s):
  if t[i] != v :
    result += 1
    
print(result)


Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
import sys
s = sys.stdin.readline().rstrip()
t = sys.stdin.readline().rstrip()

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

print(count)

s = sys.stdin.readline().rstrip()
t = sys.stdin.readline().rstrip()

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

import sys

s = sys.stdin.readline().rstrip()
t = sys.stdin.readline().rstrip()

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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
s=input()
s1=input()
c=0;
for i in range(len(s1)):
  if(s1[i]!=s[i]):
    c++;
print(c)

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
s = str(input())
t = str(input())

count = 0

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

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

sl = len(s)

count = 0

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

print(count)


Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
a=int(input())
print(a+a*a+a*a*a)

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
S=input()
T=input()
count=0
for i in range(len(S)):
  if S[i]==T[i]:
    count+=1
print(count)

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


Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
try:
  s = input()
  t = input()
  count = 0
  for i in range(len(s)):
  if not s[i] == t[i]:
    count += 1
  print(count)
except EOFError:
  print('EOFError')
  

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

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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
s=input()
t=input()
a=t.count(s)
b=len(t)-a
print(b)
  

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
S = str(input())
T = str(input())

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

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
S = list(input())
T = list(input())
count = 0
for s,t in zip(S,T):
    if s != t:
        count += 1

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
a = list(input())
b = list(input())
count = 0

for i,con in enumerate(b):
  if i == a[i]:
    break
  else:
    count+=1
    
print(count)

a = list(input())
b = list(input())
count = 0

for i,con in enumerate(b):
  if i == a[i]:
    break
  else:
    count+=1
print(count)

a = list(input())
b = list(input())

for i,con in enumerate(b):
  if i == a[i]:
    break
  else:
    count+=1
print(count)
    
  

a = list(input())
b = list(input())
count = 0

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

Verdicts: Wrong Answer

Wrong Answer

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
s = input()
t = input()

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

s = input()
t = input()

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
s = input()
t = input()
count = 0
for i in len(s):
  if s[i] != t[i]:
    count += 1
    
print(count)


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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
S=list(input().split())
T=list(input().split())
count=0
for i in range(len(S)):
  if S[i]!=T[i]:
    count = count+1
print(count)

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
S = input()
T = input()
k = len(T)

S = input()
T = input()
k = len(T)
for i in range(k):
  if S[k] == T[k]:
    m = m
  else:
    m += 1
print(m)

S = input()
T = input()
k = len(T)
m = 0
for i in range(k):
  if S[k] == T[k]:
    m = m
  else:
    m += 1
print(m)

S = input()
T = input()
k = len(T)
m = 0
for i in range(k):
  if S[k] == T[k]:
    m = m
  else:
    S[k] = T[k]
    m += 1
print(m)

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

Verdicts: Wrong Answer

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):

a=input()
b=input()
i=0
good=0
while(i<len(a)):
    if(a[i]!=b[i]):
        good+=1
	i+=1
print(good)        

a=input()
b=input()
i=0
good=0
while(i<len(a)):
    if(a[i]!=b[i]):
        good+=1
print(good)        

a=input()
b=input()

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

Verdicts: Runtime Error

Time Limit Exceeded

Accepted
Problem: 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.

Submission attempts (in order):
S=input()
T=input()
count=list(range(0,len(S)))
print(count)

c=0

for i in count:
    if S[i] != T[i]:
        c+=1
    else:
        continue
print(c)

S=input()
T=input()
count=list(range(0,len(S)))
c=0

for i in count:
    if S[i] != T[i]:
        c+=1
    else:
        continue
print(c)

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
input1 = input()
input2 = input()

def match(x, y):
    i = 0
    if x is y:
        i = 1
    return i

result_list = map(match, input1, input2)
print(result_list.count(0))

input1 = input()
input2 = input()

def match(x, y):
    i = 0
    if x is y:
        i = 1
    return i

result_list = list(map(match, input1, input2))
print(result_list.count(0))

Verdicts: Runtime Error

Accepted
Problem: 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.

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

# -*- coding: utf-8 -*-
"""
Created on Fri Sep 18 19:19:52 2020

@author: ezwry
"""

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

Verdicts: Runtime Error

Accepted