problem_id stringclasses 100 values | submission_id stringlengths 10 10 | status stringclasses 2 values | code stringlengths 6 806 |
|---|---|---|---|
p02571 | s077747353 | Wrong Answer | s=input()
t=input()
ans=10000
for i in range(len(s)-len(t)):
tmp=0
for j in range(len(t)):
if(s[i+j]==t[j]):
tmp+=1
ans=min(ans,len(t)-tmp)
print(ans) |
p02571 | s039294469 | Wrong Answer | import numpy as np
s = np.array(list(input()))
t = np.array(list(input()))
s_sub = np.array(list((s[i:i+len(t)] for i in range(len(s)-len(t)+1))))
print(s_sub)
ans = [0]*len(s_sub)
for i in range(len(s_sub)):
ans[i] = np.count_nonzero(s_sub[i] == t)
print(len(t)-max(ans)) |
p02571 | s828899642 | Wrong Answer | s=str(input())
t=str(input())
flag=False
m=0
for i in range(len(s)-len(t)):
cnt=0
for j in range(len(t)):
#print(s[i+j],t[j])
if s[i+j]==t[j]:
cnt+=1
flag=True
else:
if flag==True:
if m==0 or m<cnt:
m=cnt
cnt=0
flag=False
print(len(t)-m)
|
p02571 | s369866915 | Wrong Answer | S = input()
T = input()
ans = len(T)
for i in range(len(S) - len(T) ):
diff = 0
for j in range(len(T)):
if T[j] != S[i+j]:
diff += 1
ans = min(ans, diff)
print(ans) |
p02571 | s910792596 | Wrong Answer | s = input()
t = input()
min_score = len(t)
for i in range(len(s) - len(t)):
s_p = s[i:i+len(t)]
count_wrong = 0
for j in range(len(t)):
if t[j] != s_p[j]:
count_wrong += 1
min_score = min(count_wrong, min_score)
print(min_score) |
p02571 | s595174227 | Wrong Answer | import numpy as np
from copy import deepcopy
from heapq import heappop, heappush
from bisect import bisect_left, bisect
from collections import Counter, defaultdict, deque
from itertools import product, permutations, combinations
S = input()
T = input()
replaced = S.replace(T, '')
print(len(S) - len(replaced))
exit()
|
p02571 | s073059098 | Wrong Answer | s = list(input())
t = list(input())
m = len(s)
l = len(t)
ans = m
for i in range(m-l):
defe = 0
for j in range(l):
if t[j] != s[i+j]:
defe += 1
ans = min(defe, ans)
print(ans) |
p02571 | s774864481 | Wrong Answer | def Qb():
s = input()
t = input()
ans = len(t)
for v in range(len(t)):
for x in range(len(t) - v):
z = t[v:len(t) - x]
if z in s[v:len(s) - x]:
if v + x < ans:
ans = v + x
print(ans)
if __name__ == '__main__':
Qb()
|
p02571 | s425484660 | Wrong Answer | s=input()
t=input()
ans=1000
num=0
for i in range(len(s)-len(t)):
num=0
for j in range(len(t)):
if s[i+j]!=t[j]:
num+=1
ans=min(num,ans)
print(ans) |
p02571 | s893432726 | Wrong Answer | S = input()
T = input()
C = []
if len(S) == len(T):
c = 0
for j in range(len(T)):
if S[j] == T[j]:
c += 1
C.append(c)
else:
for i in range(len(S) - len(T)+1):
s = S[i:len(T)+i]
c = 0
for j in range(len(T)):
if s[j] == T[j]:
c += 1
C.append(c)
print(len(T)-max(C))
|
p02571 | s821713034 | Wrong Answer | s = input()
t = input()
ans = 0
for i in range(len(t)+1):
for j in range(len(t)+1):
if i < j:
t2 = t[i:j]
#print(t2)
if (t2 in s) and ans < j-i and i<=s.find(t2):
ans = j-i
#print(ans)
#print(s.find(t2))
print(len(t)-ans)
|
p02571 | s725692688 | Wrong Answer | S = input()
T = input()
n = len(S)
for i in range(len(S) - len(T)):
k_i = 0
for j in range(len(T)):
if T[j] != S[i + j]:
k_i += 1
if k_i < n:
n = k_i
print(n)
|
p02571 | s575539731 | Wrong Answer | s = input()
t = input()
ans = len(t)
flag = False
for i in range(len(t)+1, 0, -1):
for j in range(0, len(t)-i+1):
sb = t[j:j+i]
if sb in s[j:]:
ans = len(t)-len(sb)
print(ans)
|
p02571 | s741016539 | Wrong Answer | s = input()
t = input()
len_s = len(s)
len_t = len(t)
ans = 1000
for i in range(len_s - len_t + 1):
cnt = 0
l = [0]
for j in range(len_t):
if s[i : i + len_t][j] == t[j]:
cnt += 1
else:
l.append(cnt)
cnt = 0
max_cnt = max(l)
ans = min(ans, len_t - max_cnt)
print(ans) |
p02571 | s096360843 | Wrong Answer | s=input()
t=input()
ma=0
for i in range(len(t)):
for j in range(i,len(t)):
if t[i:j+1] in s[i:]:
ma=max(ma,j-i+1)
else:
break
print(len(t)-ma) |
p02571 | s998682928 | Wrong Answer | s = input()
t = input()
if t in s: print(0)
else:
for i in range(1, len(t) + 1):
if t[:i] in s:
print(i)
break
for j in t:
if j in s:
print(len(t) - 1)
break
|
p02571 | s310187391 | Wrong Answer | S = input()
T = input()
A = len(T)
for i in range(len(T)):
M = S.find(T[i:])
if M >= i and A > i:
A = i
M = S.rfind(T[i:])
if M >= i and A > i:
A = i
for i in range(1,len(T)):
M = S.find(T[:i])
if M >= i and A > i:
A = i
M = S.rfind(T[:i])
if M >= i and A > i:
A = i
print(A) |
p02571 | s131875891 | Wrong Answer | import re
S, T = [str(input()) for _ in range(2)]
index_list = []
match_count = 0
if T in S:
print(0)
else:
index = 0
counter = 0
for s in S:
for m in re.finditer(str(s), str(T)):
if index >= m.start():
if m.start() - 1 in index_list:
print(s, m.start())
counter += 1
else:
print(s, m.start())
counter = 1
index_list = []
index_list.append(m.start())
index += 1
print(len(T)-counter) |
p02571 | s666896239 | Wrong Answer | # 171 B
S = input()
T = input()
ans = []
for i in range(0, (len(S)-len(T) + 1)):
tmp = 0
#print(i)
for j in range(0, len(T)):
if T[j] != S[i +j]:
tmp += 1
print(S[i +j] + T[j])
#print('tmp:' + str(tmp))
ans.append(tmp)
print(min(ans)) |
p02571 | s338893988 | Wrong Answer | s = input()
t = input()
ns = len(s)
nt = len(t)
ans = nt
for i in range(ns - nt):
d = 0
for j in range(nt):
if t[j] != s[i+j]:
d += 1
ans = min(ans, d)
print(ans) |
p02571 | s497836892 | Wrong Answer | s = input()
t = input()
len_s = len(s)
len_t = len(t)
ans = len_t
for i in range(len_s - len_t):
u = s[i: i+len_t]
d = sum(0 if c1 == c2 else 1 for c1, c2 in zip(t, u))
ans = min(d, ans)
print(ans) |
p02571 | s921531025 | Wrong Answer | S = input().rstrip()
T = input().rstrip()
mn = len(T)
for i in range(len(S) - len(T)):
n = 0
for j in range(len(T)):
if S[i + j] != T[j]:
n += 1
if n < mn:
mn = n
print(mn)
|
p02571 | s537932802 | Wrong Answer | s = input()
t = input()
n = len(s)
nt = len(t)
ans = 1000
for i in range(n - nt):
string = s[i:i + nt]
count = 0
for c1, c2 in zip(string, t):
if c1!=c2: count += 1
ans = min(ans, count)
print(ans) |
p02571 | s371584801 | Wrong Answer | S, T = input(), input()
nT = len(T)
f = lambda a, b: sum(1 for x, y in zip(a, b) if x != y)
m = nT
for i in range(len(S) - nT):
m = min(m, f(S[i:i+nT], T))
if m == 0:
break
print(m)
|
p02571 | s406401637 | Wrong Answer | #!/usr/bin/python3
# -*- coding: utf-8 -*-
s = input()
t = input()
min_count = 1000
for i in range(len(s) - len(t)):
count = 0
for j in range(len(t)):
if s[i+j] != t[j]:
count += 1
min_count = min(count, min_count)
if min_count == 0:
break
print(min_count) |
p02571 | s995746358 | Wrong Answer | S = str(input())
T = str(input())
ans = len(T)
for start in range(len(S)-len(T)):
diff = 0
for i in range(len(T)):
if(T[i] != S[start+i]):
diff += 1
ans = min(ans, diff)
print(ans)
|
p02571 | s391566045 | Wrong Answer | string = input()
sub_string = input()
change = 0
for i in range(0, len(sub_string)):
if sub_string[i] in string:
if sub_string[i] != string[i]:
change += 1
else:
change += 1
if change == len(sub_string):
change = 1
print(change) |
p02571 | s760811547 | Wrong Answer | xmoji=input()
ymoji=input()
x=len(xmoji)
y=len(ymoji)
tempmin = 0
for i in range(0,x-y):
xmin=xmoji[i:i+y]
samenum=0
for j in range(0,y):
if(xmin[j]==ymoji[j]):
samenum+=1
if(tempmin<samenum):
tempmin = samenum
print(y-tempmin) |
p02571 | s155148502 | Wrong Answer | def main():
s = str(input())
t = list(str(input()))
num = len(t) - 1
for i in range(1, len(t)+1):
moji = "".join(t[0:i])
if moji in s:
if num > len(t)-i:
num = len(t)-i
print(num)
main() |
p02571 | s199390729 | Wrong Answer | def count(A,B):
counter=0
for i in range(len(A)):
if A[i]==B[i]:
counter+=1
return len(A)-counter
S = input()
T = input()
t = len(T)
s = len(S)
_min = float('inf')
for i in range(s-t):
_min = min(_min,count(S[i:i+t],T))
print(_min) |
p02571 | s755662978 | Wrong Answer | a=input()
b=input()
c=999
for i in range(len(a)-len(b)+1):
d=0
for j in range(len(b)):
if a[i+j]!=b[j]:
d+=1
if d<c:
c=d
print(c) |
p02571 | s371404664 | Wrong Answer | S=input()
T=input()
check=[]
for i,ss in enumerate(S[:-len(T)+1]):
check.append(0)
for j,tt in enumerate(T):
if tt==S[i+j]:
check[i]+=1
# print(check)
check.append(0)
print(len(T)-max(check)) |
p02571 | s703212980 | Wrong Answer | S = input()
T = input()
|
p02571 | s671033491 | Wrong Answer | from sys import exit
import math
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))
s = input()
t = input()
ans = 1000000
for i in range(len(s)-len(t)):
cnt=0
for j in range(len(t)):
if s[i+j] != t[j]:
cnt += 1
ans = min(ans,cnt)
print(ans) |
p02571 | s578531387 | Wrong Answer |
def resolve():
S = input()
T =input()
s_n = len(S)
t_n = len(T)
ans = 2000
for i in range(s_n - t_n):
cnt = 0
for j in range(t_n):
if S[i+j] != T[j]:
cnt += 1
ans = min(ans, cnt)
print(ans)
if __name__ == "__main__":
resolve() |
p02571 | s507795640 | Wrong Answer | S = input()
T = input()
size = len(T)
n = len(S)
ans = size
for i in range(n-size):
t = S[i:i+size]
v = sum([i!=j for i, j in zip(T, t)])
ans = min(v, ans)
print(ans)
|
p02571 | s995230775 | Wrong Answer | S = input()
T = input()
def a():
l = len(T)
for i in range(l, 0, -1):
for j in range(0, l-i+1):
if T[j:j+i] in S[j:i+j]:
return l-i
print(a())
|
p02571 | s823600338 | Wrong Answer | S = input()
T = input()
ans = 0
count = 0
saishou = 0
for i in range(len(T)):
for j in range(i, len(S)-len(T)+i):
c = 0
while T[i+c] == S[j+c]:
c = c + 1
ans = max(ans, c)
if i + c > len(T)-1 or j + c > len(S)-1 :
break
saishou = len(T) - ans
print(saishou) |
p02571 | s547787999 | Wrong Answer | S = input()
T = input()
cand = []
for start in range(len(S) - len(T) + 1):
print(S[start:start+len(T)])
cnt = sum([not T[i] == S[start:start+len(T)][i] for i in range(len(T))])
cand.append(cnt)
print(min(cand))
|
p02571 | s872443163 | Wrong Answer | s = input()
t = input()
cnt = 0
for i in range(1, len(t) + 1):
for j in range(len(t) - i + 1):
if t[j:j+i] in s:
cnt = max(cnt, i)
print(len(s) - cnt) |
p02571 | s640270827 | Wrong Answer | S = input()
T = input()
len_s, len_t = len(S), len(T)
ans = len_t
for i in range(len_s - len_t + 1):
tmp = 0
for j in range(len_t):
if S[i+j] != T[j]:
tmp += 1
if tmp < len_t:
ans = tmp
print(ans) |
p02571 | s950543218 | Wrong Answer | s = input()
t = input()
t_len = len(t)
ans = 0
for i in range(t_len):
word = t[0:t_len-i]
for j in range(len(s)-len(word)):
if s[j:j+t_len-i]==word:
print(i)
exit(0)
else:
print(t_len-1) |
p02571 | s588638291 | Wrong Answer | if __name__ == '__main__':
a, b = input(), input()
min = 1e10
for i in range(len(a) - len(b)):
c = 0
for j in range(len(b)):
if a[i + j] != b[j]:
c += 1
if c < min:
min = c
print(min) |
p02571 | s939920796 | Wrong Answer | s=input()
t=input()
ANS=0
ans=0
for i in range(len(s)-len(t)+1):
a=s[i:i+len(t)]
ans=0
for j in range(len(a)):
if ans>ANS:
ANS=ans
if a[j]==t[j]:
ans+=1
print(len(t)-ANS) |
p02571 | s288686296 | Wrong Answer |
S=input()
T=input()
check=[]
for i,ss in enumerate(S[:-len(T)+1]):
check.append(0)
for j,tt in enumerate(T):
if tt==S[i+j]:
check[i]+=1
# print(check)
check.append(0)
print(len(T)-max(check)) |
p02571 | s146420007 | Wrong Answer | S = input()
T = input()
for i in range(len(T)+1):
lT = len(T)-i+1
sT = 0
while lT != len(T)+1:
if T[sT:lT] in S[sT:len(S)]:
print(i-1)
exit()
else:
sT += 1
lT += 1
print(len(T))
|
p02571 | s034714737 | Wrong Answer | def main():
S = input()
T = input()
l = len(T)
m = l
for i in range(len(S)-l):
r = 0
for j in range(l):
if S[i+j] != T[j]:
r += 1
if r < m:
m = r
return m
print(main())
|
p02571 | s434145612 | Wrong Answer | S = input()
T = input()
ans = len(T)
num = len(S)-len(T)
for i in range(num):
tmp = 0
for j in range(len(T)):
if S[i+j] != T[j]:
tmp += 1
ans = min(ans, tmp)
print(ans) |
p02571 | s827760777 | Wrong Answer | s = input()
t = input()
l = len(t)
ans = l
for i in range(l):
for j in range(i+1,l+1):
#print(i,j)
#print(t[i:j])
fin = -(l-j)
if j==l:
fin = len(s)
#print(s[i:fin])
#print("---")
if s[i:fin].count(t[i:j])>0:
ans = min(ans,l-len(t[i:j]))
print(ans) |
p02571 | s394731843 | Wrong Answer | s = input()
t = input()
n = len(s)
m = len(t)
ans = float("inf")
for i in range(n-m):
p = 0
for j in range(m):
if s[i+j] != t[j]: p += 1
if p < ans: ans = p
print(ans) |
p02571 | s618747634 | Wrong Answer | S = input()
T = input()
def matchcount(x, y):
ret = 0
for i in range(len(x)):
if x[i] == y[i]: ret += 1
return ret
rec = len(T)
for i in range(len(S)-len(T)):
subst = S[i:i+len(T)]
rec = min(rec, len(T) - matchcount(subst, T))
print(rec)
|
p02571 | s211359041 | Wrong Answer | s = input()
t = input()
for i in range(len(t)):
if t[:len(t)-i] in s:
print(i)
exit()
print(0)
|
p02571 | s470789330 | Wrong Answer | import copy
s = input()
t = input()
sn = len(s)
tn = len(t)
answer = int(copy.deepcopy(tn))
for i in range(sn-tn+1):
sk = s[i:i+tn]
count = 0
for j in range(tn):
if sk[j] != t[j]:
count += 1
print(sk,count)
if count < answer:
answer = count
print(answer) |
p02571 | s674919084 | Wrong Answer | #B - Substring
S = input()
T = input()
ans = 10*9
for i in range(len(S)-len(T)):
count = 0
for j in range(len(T)):
if S[i+j] != T[j]:
count += 1
else:
pass
if ans >= count:
ans = count
else:
pass
print(ans) |
p02571 | s150728082 | Wrong Answer | s = input()
t = input()
minCount = 10000
i = 0
while i < len(s):
countSame = 0
j = 0
while j < len(t) and i+j < len(s):
if t[j] == s[i+j]:
countSame += 1
j += 1
minCount = min(len(t) - countSame, minCount)
i += 1
print(minCount)
|
p02571 | s433140831 | Wrong Answer | s = input()
t = input()
maxsame = 0
for i in range(len(s)-len(t)):
same = 0
for j in range(len(t)):
if s[i+j] == t[j]:
same += 1
if same > maxsame:
maxsame = same
print(len(t)-maxsame) |
p02571 | s909396115 | Wrong Answer | S = input()
T = input()
max_count = 0
for start in range(len(T)):
for end in range(start, len(T)):
if T[start:end+1] in S[start:-(len(T)-end)]:
max_count = max(max_count, len(T[start:end+1]))
answer = len(T) - max_count
print(answer)
|
p02571 | s121199715 | Wrong Answer | S,T = input(),input()
r = len(T)
for i in range(len(S)-len(T)):
t = 0
for j in range(len(T)):
if S[i+j] != T[j]:
t += 1
r = min(r,t)
print(r) |
p02571 | s009651628 | Wrong Answer | s=input()
t=input()
mx=0
for i in range(len(s)-len(t)):
sm=0
for j in range(len(t)):
if s[i+j]==t[j]:
sm+=1
mx=max(sm,mx)
print(len(t)-mx)
|
p02571 | s597918922 | Wrong Answer | S = input()
T = input()
for r in range(len(T),0,-1):
for i in range(len(T)-r+1):
if T[i:i+r] in S[i:]:
break
else:
continue
print(len(T)-r)
break
else:
print(len(T))
|
p02571 | s629852805 | Wrong Answer | S = input()
T = input()
result = 1000
for i in range(len(S) - len(T)):
count = 0
for j in range(len(T)):
if S[i + j] != T[j]:
count += 1
result = min(count, result)
print(result)
|
p02571 | s465223105 | Wrong Answer | s = input()
t = input()
minr = len(t)
s_t_d = len(s) - len(t)
for i in range(s_t_d):
cnt = 0
for ss, ts in zip(s[i:i + len(t)], t):
if ss != ts:
cnt += 1
minr = min(minr, cnt)
print(minr) |
p02571 | s749085875 | Wrong Answer | s = input()
t = input()
for i in range(1, len(t) + 1):
if t[:i] in s:
print(i)
break
for j in t:
if j in s:
print(len(t) - 1)
break
|
p02571 | s236751695 | Wrong Answer | #!/usr/bin/env python3
import sys
INF = sys.maxsize // 10
def minimize(s, t):
ns = len(s)
nt = len(t)
res = INF
for start_idx in range(ns - nt):
cand = sum(c != d for c, d in zip(s[start_idx: start_idx + nt], t))
res = min(res, cand)
return res
def main():
s = input()
t = input()
print(minimize(s, t))
if __name__ == '__main__':
main() |
p02571 | s544998120 | Wrong Answer | s = list(input())
t = list(input())
ans = 1000
sub = 0
for i in range(len(s)):
if s[i] != t[sub]:
sub = 0
continue
else:
if sub == len(t) - 1:
print(0)
exit()
sub += 1
for i in range(len(s) - len(t)):
sub = 0
an = 0
for j in range(len(t)):
if s[i + j] != t[sub]:
an += 1
sub += 1
ans = min(an, ans)
print(ans) |
p02571 | s714185829 | Wrong Answer | s = input()
t = input()
ans = float('infinity')
for i in range(len(s)-len(t)):
c = len(t)
for j in range(len(t)):
if s[i+j] == t[j]:
c -= 1
ans = min(ans, c)
print(ans) |
p02571 | s715833969 | Wrong Answer | # t=int(input())
#
# for some_num in range(0,t):
# n=int(input())
# s,t=[int(i) for i in input().split(" ")]
s=input()
t=input()
ls=len(s)
lt=len(t)
min_change=lt
print(min_change)
for i in range(0,ls-lt+1):
if(s[i]==t[0]):
d = 0
for j in range(0,lt):
if(s[i+j]!=t[j]):
d+=1
min_change=min(min_change,d)
print(min_change)
|
p02571 | s216449271 | Wrong Answer | S = list(input())
T = list(input())
ans = 1001
for i in range(len(S)-len(T)):
num = 0
for j in range(len(T)):
if S[j+i] != T[j]:
num += 1
if num <= ans:
ans = num
print(ans) |
p02571 | s512262188 | Wrong Answer | S = input()
T = input()
minCount = len(T)
for i in range(len(S)-len(T)):
count = 0
for j in range(len(T)):
if S[i+j] != T[j]:
count += 1
minCount = min(minCount, count)
print(minCount)
|
p02571 | s994613786 | Wrong Answer | S=input("codefoces")
T=input("atcoder")
tlen = len(T)
for i in range(tlen, 1):
for k in range(0, tlen+1-i):
Tinclude = T[k:i]
print(tlen-i)
break |
p02571 | s852296645 | Wrong Answer | import sys
S = sys.stdin.readline().strip()
T = sys.stdin.readline().strip()
ls = len(S)
lt = len(T)
match = 0
for i in range(ls - lt):
tmp = 0
for j in range(lt):
if S[i+j] == T[j]:
tmp += 1
match = max(match, tmp)
print(lt - match) |
p02571 | s615658365 | Wrong Answer | s = list(input())
t = list(input())
s_num = len(s)
t_num = len(t)
max_count = 0
for i in range(s_num - t_num + 1):
count = 0
for j in range(t_num):
if s[i + j] == t[j]:
count += 1
if count > max_count:
max_count = count
print(t_num - count)
|
p02571 | s189036640 | Wrong Answer | S = input()
T = input()
ans = len(T)
for start in range(len(S) - len(T)):
dif = 0
for i in range(len(T)):
if T[i] != S[start + i]:
dif += 1
ans = min(ans, dif)
print(ans)
|
p02571 | s838639767 | Wrong Answer | def resolve():
s = input()
t = input()
ans = 0
for i in range(len(t)):
for j in range(i, len(t)):
test = t[i:(j + 1)]
if test in s[i:(len(s) - (len(t) - j) + 1)]:
ans = max(ans, len(test))
print(len(t) - ans)
resolve() |
p02571 | s970382916 | Wrong Answer | s = input()
t = input()
count = len(s)-len(t)
ans = 0
for i in range(count):
res = 0
for j in range(len(t)):
if t[j] == s[i+j]:
res += 1
ans = max(ans, res)
print(len(t)-ans) |
p02571 | s039952134 | Wrong Answer | S = input()
T = input()
import math
if T in S:
print(0)
exit()
for i in range(1,math.ceil(len(T)/2)):
if T[i:] in S or T[:-i] in S:
print(i)
exit()
print(len(T)-1) |
p02571 | s160453227 | Wrong Answer | #ceilevenoddformula
import math
import bisect
import copy
import time
from collections import Counter
from itertools import combinations
#map(int,input().split())
#int(x) for x in input().split()
s=input()
x=input()
if x in s:
print(0)
else:
ans=10**9
for i in range(len(s)-len(x)):
c=0
for j in range(len(x)):
if s[i+j]!=x[j]:
c+=1
ans=min(ans,c)
print(ans)
|
p02571 | s245560891 | Wrong Answer | s = input()
t = input()
t_len = len(t)
s_len = len(s)
max_ = 0
temp = 0
for i in range(s_len - t_len):
for j in range(t_len):
if s[i + j] == t[j]:
temp += 1
if max_ < temp:
max_ = temp
temp = 0
print(t_len - max_ + 1) |
p02571 | s444987773 | Wrong Answer | S = input()
T = input()
size = len(T)
n = len(S)
ans = size
for i in range(n-size+1):
t = S[i:i+size]
print(t)
v = sum([k!=j for k, j in zip(T, t)])
ans = min(v, ans)
print(ans)
|
p02571 | s955932905 | Wrong Answer | S=input()
T=input()
A = []
for i in range(len(T)):
for j in range(i,len(T)):
SS = S[i:j]
if SS in T:
A.append(j-i+1)
p = min(A)
print(p) |
p02571 | s704021694 | Wrong Answer | s=input()
a=len(s)
t=input()
b=len(t)
mincnt=b
for i in range(a-b):
count=0
for j in range(b):
s1=s[i+j]
s2=t[j]
if(s1!=s2):
count+=1
if(mincnt>count):
mincnt=count
print(mincnt) |
p02571 | s904623891 | Wrong Answer | s = input()
t = input()
cnt = 0
ans = 0
for ti in range(len(t)):
for si in range(ti,len(s)):
if t[ti] == s[si]:
if len(t) -ti < len(s) -si:
cnt += 1
ans = max(ans,cnt)
else:
cnt = 0
print(len(t) - ans) |
p02571 | s763246646 | Wrong Answer | # -*- coding: utf-8 -*-
S = str(input())
T = str(input())
len_S = len(S)
S_part_dict = {}
for i in range(len_S):
for j in range(i, len_S):
S_part_dict[S[i:j + 1]] = i
max_part_len = 0
for part_str, len_from_top in S_part_dict.items():
now_len_part = len(part_str)
if now_len_part <= max_part_len:
continue
if T[len_from_top:-(len_S - now_len_part)].count(part_str):
max_part = now_len_part
print(len(T) - now_len_part) |
p02571 | s947285052 | Wrong Answer | list_data = [input() for _ in range(2)]
print(list_data)
s = list_data[0]
t = list_data[1]
len_t = len(t)
max_correct = 0
for i in range(len(s)-len(t)):
correct = 0
for j in range(len(t)):
if s[i+j] == t[j]:
correct += 1
if max_correct < correct:
max_correct = correct
print(len_t - max_correct) |
p02571 | s350705563 | Wrong Answer | s = input()
t = input()
ans = 10**4
for i in range(len(s)-len(t)):
cnt = 0
for j in range(len(t)):
if s[i+j] != t[j]:
cnt += 1
ans = min(cnt,ans)
print(ans) |
p02571 | s766691186 | Wrong Answer | from collections import deque
import sys, copy, itertools,heapq
input = sys.stdin.readline
S = input()
T = input()
s = len(S)
t = len(T)
#A=[0]*(len(S))
ans = t
for i in range(len(S)-len(T)+1):
x = 0
for j in range(len(T)):
if S[i+j] != T[j]:
x += 1
ans = min(ans, x)
#print(s)
#print(t)
#print(A)
print(ans) |
p02571 | s581190995 | Wrong Answer | s = input()
t = input()
m = len(t)
ans = m
n = len(s)
for i in range(n-m):
tmp = 0
for j in range(m):
if s[i+j] != t[j]:
tmp += 1
ans = min(ans, tmp)
print(ans) |
p02571 | s932614819 | Wrong Answer | S = str(input())
T = str(input())
tempcount = 0
mincount = 0
if S in T:
print("0")
exit
for i in range(len(S) - len(T)+1):
for j in range(len(T)):
if S[i + j] != T[j]:
tempcount += 1
if i == 0:
mincount = tempcount
elif tempcount < mincount:
mincount = tempcount
tempcount = 0
print(mincount)
|
p02571 | s999406451 | Wrong Answer | s=input()
t=input()
result = 0
for i in range(len(s)):
count = 0
for j in range(len(t)):
if i+j > len(s)-1:
break
if t[j] == s[i+j]:
count += 1
result = max(result,count)
print(len(t)-result) |
p02571 | s863183007 | Wrong Answer | s = input()
t = input()
t_len = len(t)
s_len = len(s)
max_ = 0
temp = 0
for i in range(s_len - t_len):
for j in range(t_len):
if s[i + j] == t[j]:
temp += 1
if max_ < temp:
max_ = temp
temp = 0
print(t_len - max_) |
p02571 | s092318107 | Wrong Answer | S = input()
T = input()
ans = 0
for i in range(len(S)-len(T)+1):
cnt = 0
for j in range(len(T)):
if S[i+j] == T[j]:
cnt += 1
else:
cnt = 0
if cnt > ans:
ans = cnt
print(len(T)-ans) |
p02571 | s120235761 | Wrong Answer | s = input()
t = input()
slen = len(s)
tlen = len(t)
ans = tlen
temp = 0
for start in range(0,slen-tlen):
for i in range(0,tlen):
if t[i] != s[start+i]:
temp += 1
ans = min(ans,temp)
temp = 0
print(ans)
|
p02571 | s349769034 | Wrong Answer | input_list = [input() for i in range(2)]
M = len(input_list[0])
N = len(input_list[1])
ans = 0
for i in range(M-N+1):
num = 0
substring = input_list[0][i:i+N]
for j in range(len(substring)):
if substring[j] != input_list[1][j]:
num += 1
ans = num
print(ans) |
p02571 | s132471034 | Wrong Answer | import numpy as np
import sys
S = input()
T = input()
counter = 0
max_counter = 0
for i in range(len(S) - len(T) + 1):
for j in range(len(T)):
if S[j+i] == T[j]:
counter = counter + 1
if counter > max_counter:
max_counter = counter
counter = 0
print(int(len(T)) - int(max_counter)) |
p02571 | s007869120 | Wrong Answer | S=input()
T=input()
ans=len(T)
for j in range(len(S)-len(T)+1):
total=0
for i in range(len(T)):
if S[i+j-1]!=T[i]:
total+=1
if ans>=total:
ans=total
print(ans) |
p02571 | s323409251 | Wrong Answer | import re
import sys
s = input()
t = input()
for i in range(len(t)):
if re.search(t,s) != None:
print(0)
sys.exit()
t1 = t[1:]
t2 = t[:len(t)-i]
if None!=re.search( ".+"+t1+".+",s):
print(i)
sys.exit()
if None!=re.search( ".+" + t2 + ".+",s):
print(i)
sys.exit()
if i == len(t)-1:
print(len(t)-1) |
p02571 | s080460692 | Wrong Answer | #!/usr/bin/env python3
import sys
def input(): return sys.stdin.readline().rstrip()
def hantei(S,T):
anss=0
for i in range(len(S)):
if S[i]!=T[i]:
anss+=1
return anss
def main():
S=input()
T=input()
ans=10000
for i in range(len(S)-len(T)):
ans=min(ans,hantei(T,S[i:i+len(T)]))
print(ans)
if __name__ == '__main__':
main() |
p02571 | s075046446 | Wrong Answer | s = input()
t = input()
m = 0
l = len(t)
# print(l)
ans = 100000000
for tt in range(0,l):
for pp in range(l , tt, -1):
# print(t[tt:pp])
if t[tt:pp] in s[tt:len(s)-(l-pp)]:
# print("ok ", tt + (l-pp))
if ans > tt + (l-pp):
ans = tt + (l-pp)
print(ans) |
p02571 | s528109362 | Wrong Answer | S = input()
T = input()
s = len(S)
t = len(T)
A=[0]*(len(S))
ans = t
for i in range(len(S)-len(T)):
for j in range(len(T)):
if S[i+j] != T[j]:
A[i] += 1
ans = min(ans, A[i])
#print(s)
#print(t)
#print(ANS)
print(ans) |
p02571 | s784422925 | Wrong Answer | s=list(input())
t=list(input())
ans=len(t)
for i in range(len(s)-len(t)):
tmp=0
for j in range(len(t)):
if s[i+j]!=t[j]:
tmp+=1
ans=min(ans,tmp)
print(ans)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.