problem_id stringclasses 100 values | submission_id stringlengths 10 10 | status stringclasses 2 values | code stringlengths 6 806 |
|---|---|---|---|
p02571 | s150416070 | Wrong Answer | s = input()
t = input()
l = len(t)
num = 0
for i in range(l):
for j in range(i+1,l):
if t[i:j] in s[i:]:
num = max(num, (j-i))
print(l-num) |
p02571 | s521089221 | Wrong Answer | S = input()
T = input()
ans = 0xffffffff
for offset in range(len(S) - len(T) - 1):
diff = 0
for i in range(len(T)):
if S[offset + i] != T[i]:
diff += 1
ans = min(ans, diff)
print(ans)
|
p02571 | s096827103 | Wrong Answer | S = input().strip() # novel
T = input().strip() # substring
x = len(T)
ans = len(S)
for i in range(len(S) - x):
U = S[i:i+x]
cost = sum(1 if U[k] != T[k] else 0 for k in range(x))
ans = min(ans, cost)
print(ans)
|
p02571 | s567118177 | Wrong Answer | #!/usr/bin/env python3
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
S = input()
T = input()
lis = list(T)
max_count = 0
for i in range(len(S) - len(T)):
subS = list(S[i:i+len(T)])
count = 0
for j in range(len(T)):
if subS[j] == T[j]:
count += 1
max_count = max(max_count, count)
print(len(T) - max_count)
|
p02571 | s687137263 | Wrong Answer | S = input()
T = input()
ans = 1000
for i in range(len(S)-len(T)):
s = S[i:i+len(T)]
n = 0
for j in range(len(s)):
ss = s[j]
if T[j] != ss:
n += 1
ans = min(ans,n)
print(ans) |
p02571 | s666706324 | Wrong Answer | s = input() # all
t = input() # substring
def calc_length(str1, str2):
length = 0
for i in range(len(str1)):
if str1[i] != str2[i]:
length += 1
return length
min_length = len(t)
for i in range(len(s)- len(t)):
l = calc_length(s[i:i+len(t)], t)
if l < min_length:
min_length = l
print(min_length)
|
p02571 | s918630543 | Wrong Answer | s = input()
t = input()
ans = 1001001001
for i in range(len(s)-len(t)):
_s = s[i:i+len(t)]
cnt = 0
for j in range(len(t)):
if t[j] != _s[j]:
cnt += 1
ans = min(ans, cnt)
print(ans) |
p02571 | s176832047 | Wrong Answer | def main():
s = (input())
t = (input())
mn = 10**5
for i in range(len(s)-len(t)):
result = 0
for j in range(len(t)):
if s[i+j] != t[j]:
result += 1
mn = min(result, mn)
print(mn)
if __name__ == '__main__':
main()
|
p02571 | s934513541 | Wrong Answer | import numpy as np
S = np.array(list(input().rstrip()))
T = np.array(list(input().rstrip()))
s = len(S)
t = len(T)
max_count = 0
for i in range(s-t):
max_count = max(max_count, (S[i:i+t]==T).sum())
print(len(T) - max_count)
#print(S[5:5+1])
#print(T[-(10-5):5+1])
#print(S[5:5+1] in T[-(10-5):5+1]) |
p02571 | s962974028 | Wrong Answer | s = input()
t = input()
ans = 10000000
for i in range(len(s)-len(t)):
tnp = 0
for j in range(len(t)):
if (s[j+i]!=t[j]):
tnp += 1
ans = min(ans,tnp)
print(ans) |
p02571 | s682148843 | Wrong Answer | S =input()
T =input()
answer = len(T)
for i in range(len(S)-len(T)+1):
count = 0
for j in range(len(T)):
if S[i + j] != T[j]:
count = count + 1
if count < answer:
answer = count
print(count) |
p02571 | s972373912 | Wrong Answer | s=input()
t=input()
n=len(s)
k=len(t)
c=n
for i in range(n-k):
c1=0
for j in range(i,i+k):
if(s[j]!=t[j-i]):
c1+=1
c=min(c,c1)
print(c) |
p02571 | s318679213 | Wrong Answer | a = str(input())
b = str(input())
ind = 0
for i in range(len(b)):
if b[i:len(b)] in a or b[0:len(b)-i] in a:
ind += 1
print(len(b)-ind)
|
p02571 | s319456573 | Wrong Answer | # -*- coding: utf-8 -*-
s = input()
t = input()
ans = len(t)
for i in range(len(s)-len(t)):
dif = 0
for j in range(len(t)):
if s[j+i] != t[j]:
dif += 1
ans = min(ans, dif)
print(ans)
|
p02571 | s671729058 | Wrong Answer | S = input()
T = input()
print(S)
print(T)
lens = len(S)
lent = len(T)
ans = 1000000
for i in range(lens - lent):
count = 0
for j in range(lent):
if(S[i+j] != T[j]):
count = count + 1
if count < ans:
ans = count
print(ans) |
p02571 | s972618936 | Wrong Answer |
def count(s1,s2):
cnt = 0
for i in range(len(s2)):
if s1[i] != s2[i]:
cnt += 1
return cnt
S1 = input()
S2 = input()
mmin = 99999999
for i in range(len(S1)-len(S2)):
k = count(S2,S1[i:len(S2)+i])
if k < mmin:
mmin = k
print(mmin)
|
p02571 | s674708413 | Wrong Answer | s = input()
t = input()
minCount = len(t)
i = 0
while i < len(s):
countDiff = 0
j = 0
while j < len(t) and i+j < len(s):
if t[j] != s[i+j]:
countDiff += 1
j += 1
minCount = min(countDiff, minCount)
i += 1
print(minCount)
|
p02571 | s659119395 | Wrong Answer | import sys
s=input()
t=input()
for i in range(len(t)):
for j in range(len(t)-i):
for k in range(i,len(s)-len(t[i:len(t)-j])):
if t[i:len(t)-j]==s[k:k+len(t[i:len(t)-j])]:
print(len(t)-len(t[i:len(t)-j]))
sys.exit() |
p02571 | s484001936 | Wrong Answer | # B Subtring
S = input()
T = input()
ans = 10000
for s in range(len(S) - len(T)):
cnt = 0
for t in range(len(T)):
if S[s+t] != T[t]:
cnt += 1
ans = min(ans, cnt)
print(ans) |
p02571 | s178787801 | Wrong Answer | #d,t,s=map(int,input().split())
s=str(input())
t=str(input())
cans=10000
for i in range(len(s)-len(t)):
ans=0
for j in range(len(t)):
if s[i]!=t[j]:
ans+=1
i+=1
cans=min(ans,cans)
print(cans) |
p02571 | s871639124 | Wrong Answer | s=input()
t=input()
T,S=len(t),len(s)
ans=T
for i in range(S-T):
tmp=0
for c1,c2 in zip(s[i:i+T],t):
if c1!=c2:
tmp+=1
ans=min(ans,tmp)
print(ans)
|
p02571 | s780932032 | Wrong Answer | s = input()
t = input()
slen = len(s)
tlen = len(t)
ans = 10**9
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 | s177128979 | Wrong Answer | import math
min = math.inf
S = input()
T = input()
len_t = len(T)
for s in range(0,len(S)-len_t):
sub = S[s: s+len_t]
diff = 0
for i in range(len_t):
if sub[i] != T[i]:
diff += 1
if diff > min:
break
else:
if diff < min:
min = diff
print(min) |
p02571 | s917017021 | Wrong Answer | def judge(s,t):
if t in s:
return 0
for i in reversed(range(len(t))):
for j in range((len(t)-i)+1):
if t[0+j:i+j] in s:
if s.find(t[0+j:i+j])>=j:
if len(s)-(s.find(t[0+j:i+j])+i)>=len(t)-(i+j):
print(t[0+j:i+j])
return len(t)-i
s = input()
t = input()
r = judge(s,t)
print(r)
|
p02571 | s185451548 | Wrong Answer | S = input()
T = input()
ans = 0
if T in S:
print(ans)
exit()
l = len(T)
for t in range(1,l):
if (T[t:] in S) or (T[:-1*t] in S):
ans = t
break
print(ans) |
p02571 | s684828266 | Wrong Answer | s,t=open(0).read().split()
res=1001
for i in range(len(s)-len(t)):
cnt=0
for j in range(len(t)):
if s[i+j]==t[j]:
cnt+=1
res=min(len(t)-cnt,res)
print(res) |
p02571 | s576171433 | Wrong Answer | s = input()
t = input()
length = len(t)
for i in range(length):
if t in s:
print(i)
break
if t[i:length] in s or t[:length-i] in s:
print(i)
break |
p02571 | s923609926 | Wrong Answer | s=input()
t=input()
n=len(s)
m=len(t)
ans=m
for i in range(n-m):
cnt=0
for j in range(m):
if s[i+j]!=t[j]:cnt+=1
ans=min(ans,cnt)
print(ans) |
p02571 | s903822566 | Wrong Answer | s = input()
t = input()
ans = ''
for i in range(len(t)):
k = len(t) - i
if ans == '':
for j in range(len(s) - k + 1):
if s[j: j + k] in t and j > t.index(s[j:j + k]):
ans = len(t) - k
break
print(ans) |
p02571 | s482810092 | Wrong Answer | def func(S,T):
tlen = len(T)
min = 1000
for x in range(0,len(S)-tlen,1):
tmp = S[x:x+tlen]
tmpNum = 0
for i in range(0,len(tmp),1):
if tmp[i] != T[i]:
tmpNum += 1
if min > tmpNum:
min = tmpNum
return min
if __name__ == "__main__":
S = input()
T = input()
print(func(S,T)) |
p02571 | s403177518 | Wrong Answer | S = input().rstrip()
T = input().rstrip()
count = 0
lens = len(S)
lent = len(T)
for i in range(lens-lent+1):
tempcount=0
for j in range(lent):
if S[i+j]==T[j]:
tempcount += 1
print(tempcount)
count = max(count,tempcount)
print(lent-count) |
p02571 | s784768988 | Wrong Answer | s = input()
t = input()
ans = 10000
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
ans = min(ans, cnt)
print(cnt)
|
p02571 | s964079418 | Wrong Answer | S = input()
T = input()
t_len = len(T)
count = len(S) - len(T) + 1
max_correct = []
for i in range(count):
s_tmp = S[i:t_len]
for n, s in enumerate(s_tmp):
correct = 0
if s == T[n]:
correct += 1
max_correct.append(correct)
i = i + 1
t_len = t_len + 1
print(max(max_correct)) |
p02571 | s253259157 | Wrong Answer | s = input()
t = input()
lendif = len(s) - len(t)
min_global = len(s)
for i in range(lendif):
beg = i
end = i + len(t)
sl = s[beg:end]
m = 0
for j in range(len(t)):
if t[j] != sl[j]:
m += 1
if m < min_global:
min_global = m
print(min_global)
|
p02571 | s780822546 | Wrong Answer | S = input()
T = input()
for i in range(len(T), 0, -1):
for j in range(len(T)-i):
subst = T[j:i+j]
if S.find(subst, j)>=0:
print (len(T)-i)
exit(0)
|
p02571 | s816232849 | 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 s[i+j] != t[j]:
diff += 1
ans = min(ans, diff)
print(ans) |
p02571 | s667815077 | Wrong Answer | s = input()
t = input()
ans = 0
if not t in s:
for i in range(1, len(t)):
if t[:-i] in s[:-i] or t[i:] in s[i:]:
ans = i
break
print(ans) |
p02571 | s333801512 | Wrong Answer | a = input()
b = input()
mini = len(b)
for s in range(len(a) - len(b)):
c = 0
for i, j in zip(a[s:s + len(b)], b):
if i != j:
c += 1
mini = min([mini, c])
print(mini)
|
p02571 | s682202604 | Wrong Answer | s = input()
t_list = list(input())
ans = len(t_list)
for start in range(len(s) - len(t_list)):
diff = 0
for i in range(len(t_list)):
if(t_list[i] != s[start + i]):
diff += 1
ans = min(ans, diff)
print(ans) |
p02571 | s644936103 | Wrong Answer | s = input()
t = input()
s_length = len(s)
t_length = len(t)
ans = 1000
for i in range(s_length - t_length):
diff = 0
parts = s[i:t_length+i]
for j in range(t_length):
if parts[j] != t[j]:
diff += 1
if ans > diff:
ans = diff
print(ans)
|
p02571 | s967283720 | Wrong Answer | s = input()
t = input()
ans = len(t)
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
ans = min(ans, cnt)
print(cnt) |
p02571 | s088793786 | Wrong Answer | s = input()
t = input()
res = 10000000000
for i in range(0, len(s)-len(t)+1):
m = 0
# print(s[i:], t)
# for j, k in zip(s[i:],t):
# print(j,k)
# if j==k:
# m += 1
for j in range(0, len(t)):
# print(s[j], t[j])
if(s[j]==t[j]):
m+=1
res = min(res, len(t)-m)
# print(len(t)-m)
print(res) |
p02571 | s495853133 | Wrong Answer | s = input()
t = input()
ans = len(t)
for i in range(len(s)-len(t)):
cnt = 0
for j in range(len(t)):
if s[i+j] != t[j]:
cnt += 1
if ans > cnt:
ans = cnt
print(ans)
|
p02571 | s304049723 | Wrong Answer | s = input()
t = input()
result = [0]*len(s)
for i in range(len(s)):
for j in range(len(t)):
try:
if s[i+j] == t[j]:
result[i] += 1
except:
pass
print(len(t) - max(result))
|
p02571 | s643757519 | Wrong Answer | s=input()
t=input()
ans=0
for i in range(len(s)-len(t)):
u=0
for a,b in zip(t,s[i:len(t)+i]):
if a==b:u+=1
print(t,s[i:len(t)+i],u)
ans=max(ans,u)
if len(s)==len(t):
for a,b in zip(t,s):
if a==b:ans+=1
print(len(t)-ans) |
p02571 | s152195874 | Wrong Answer | S = input()
T = input()
def diff_count(A,B):
diff = 0
for a,b in zip(A,B):
if a!=b:
diff += 1
return diff
ans = len(T)
for i in range(len(S) - len(T)):
temp = S[i:i+len(T)]
diff_num = diff_count(T,temp)
ans = min(diff_num,ans)
print(ans) |
p02571 | s284548400 | Wrong Answer | string1 = input()
string2 = input()
n, m = len(string1), len(string2)
best = float("inf")
for i in range(n - m):
current = string1[i:i+m]
differences = 0
for i in range(m):
if current[i] != string2[i]:
differences += 1
best = min(differences, best)
if best == float("inf"):
print(0)
else:
print(best) |
p02571 | s390533040 | Wrong Answer | s=input()
t=input()
for i in range(len(s)-len(t)+1):
a=s[i:len(t)+i]
num=0
for i,j in zip(t,a):
if i!=j:
num+=1
num=min(1000,num)
print(num)
|
p02571 | s424742907 | Wrong Answer | s = input()
t = input()
mini = -1
for i in range(len(s) - len(t)+1):
temp = 0
for j in range(len(t)):
if(s[j + i] != t[j]):
temp+=1
if(mini == -1 or temp < mini):
mini = temp
print(temp) |
p02571 | s927548239 | Wrong Answer | S = input()
T = input()
# T < S
ans = 10000
for si in range(len(S)-len(T)):
ic = 0
for ti in range(len(T)):
if S[si+ti] != T[ti]:
ic += 1
ans = min(ic, ans)
print(ans) |
p02571 | s427971258 | Wrong Answer | S = input()
T = input()
ans = len(T)
for i in range(len(T)):
for j in range(i+1,len(T)+1):
if T[i:j] in S:
if i - S.find(T[i:j]) <= 0 and len(S) - S.find(T[i:j]) - 1 >= len(T) - i - 1:
ans = min(ans, len(T)-len(T[i:j]))
print(ans) |
p02571 | s426958485 | Wrong Answer | S = input()
T = input()
A = len(T)
print(len(T))
for i in range(len(T)-1):
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 > len(T)-i and A > len(T)-i:
A = len(T)-i
M = S.rfind(T[:i])
if M > len(T)-i and A > len(T)-i:
A = len(T)-i
print(A) |
p02571 | s340206320 | Wrong Answer | S = str(input())
T = str(input())
max_len = 0
for left in range(len(T)):
for right in range(0, len(T) - left):
if right == 0:
tmpT = T[left:]
tmpS = S[left:]
else:
tmpT = T[left:-right]
tmpS = S[left:-right]
# print(tmpT, tmpS)
if tmpT in tmpS:
max_len = max(len(tmpT), max_len)
print(len(T) - max_len) |
p02571 | s704111905 | Wrong Answer | S = str(input())
T = str(input())
init = len(T)-1
tmp = init
ans = tmp+1
for i in range(0,len(S)):
if i > len(S)-len(T):
break
for n in range(0, len(T)):
#print(n)
if S[i]==T[n]:
ans =ans -1
i=i+1
if ans < tmp:
tmp =ans
else:
ans = init+1
break
ans = tmp
print(ans)
|
p02571 | s814237862 | Wrong Answer | def judge(s,t):
if t in s:
return 0
for i in reversed(range(len(t))):
for j in range((len(t)-i)+1):
if t[0+j:i+j] in s[:-1]:
if s.find(t[0+j:i+j])>=j:
return len(t)-i
s = input()
t = input()
r = judge(s,t)
print(r) |
p02571 | s120866895 | Wrong Answer | #!/usr/bin/env python
def main():
s = input()
t = input()
m = len(s)
n = len(t)
c_max = 0
for i in range(m-n):
cnt = 0
for j in range(n):
if s[i+j] == t[j]:
cnt += 1
if cnt > c_max:
c_max = cnt
print(n - c_max)
if __name__ == '__main__':
main()
|
p02571 | s583148115 | Wrong Answer | S = input()
T = input()
L = 0
judge = False
for i in range(len(T), -1, -1):
for j in range(len(T)-i):
if T[j:j+i] in S[j:]:
L = i
# print(T[j:j+i])
judge = True
break
if judge:
break
print(len(T)-L)
|
p02571 | s522389797 | Wrong Answer | s=input()
t=input()
ls=len(s);lt=len(t)
ans=10000
for i in range(ls-lt):
ss=list(s[i:i+lt])
tt=list(t)
tmp=[tt[j] for j in range(lt) if tt[j]!=ss[j]]
ans=min(ans,len(tmp))
print(ans) |
p02571 | s822705919 | Wrong Answer | ni = lambda: int(input())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))
s = [_ for _ in input()]
t = [_ for _ in input()]
ans = 10**10
for i in range(len(s) - len(t)):
a = 0
for j in range(len(t)):
if s[i+j] != t[j]:
a+=1
ans = min(a,ans)
print(ans)
|
p02571 | s541472783 | Wrong Answer | S = input()
T = input()
T1= T
Tlist =[]
countfront = 0
countback = 0
while T not in S:
#if T not in S:
#print (T,S)
Tlist = list(T)
Tlist.pop(0)
T ="".join(Tlist)
T.lstrip()
#print (T)
countfront+=1
Tlist = []
while T1 not in S:
#if T1 not in S:
#print (T1,S)
Tlist = list(T1)
Tlist.pop(0)
T1 ="".join(Tlist)
T1.lstrip()
#print (T1)
countback+=1
if countfront>countback:
print (countback)
else :
print (countfront)
|
p02571 | s000942040 | Wrong Answer | S = input()
T = input()
if S.find(T) >= 0:
print(0)
else:
cnt = 1
for _ in range(1, len(T)):
for shift in range(cnt):
if S.find(T[shift:shift - cnt]) >= 0:
print(cnt)
exit()
cnt += 1
print(cnt)
|
p02571 | s805227612 | Wrong Answer | s = input()
t = input()
scnt = len(s)
tcnt = len(t)
change = 10**3
for i in range (0, scnt - tcnt):
cnt = 0
for j in range(tcnt):
if s[i+j] != t[j]:
cnt += 1
if change > cnt:
change = cnt
print(change) |
p02571 | s482700422 | Wrong Answer | a = input()
b = input()
l = []
for i in range(len(a) - len(b) + 1):
cnt = 0
for j in range(len(b)):
if b[j] == a[i + j]:
cnt += 1
l.append(cnt)
print(l)
print(len(b) - max(l)) |
p02571 | s625519564 | Wrong Answer | S = input().rstrip()
T = input().rstrip()
res = float("inf")
for i in range(len(S)-len(T)):
t = 0
for j in range(len(T)):
if S[i+j]!=T[j]:
t += 1
res = min(t,res)
print(res) |
p02571 | s344085080 | Wrong Answer | S = input()
T = input()
N = len(T)
s_list = []
for i in range(len(S) - N + 1):
s = S[i: i + N]
s_list.append(s)
answer = N
for s in s_list:
counter = 0
for i in range(N):
if s[i] != T[i]:
counter += 1
answer = min(answer, counter)
print(answer) |
p02571 | s252067316 | Wrong Answer | s = list(input())
t = list(input())
tmp = 0
ans = len(t)
j_tmp = 0
for i in range(len(s) - len(t)):
tmp = 0
for j in range(len(t)):
if s[i + j] != t[j]:
tmp += 1
if tmp < ans:
ans = tmp
print(ans)
|
p02571 | s242734443 | Wrong Answer | import sys
input = sys.stdin.readline
S = input().strip()
T = input().strip()
ans = float("inf")
ls = len(S)
lt = len(T)
for i in range(ls - lt + 1):
tmp = 0
for j in range(lt):
if S[i+j] != T[j]:
tmp += 1
ans = min(ans, tmp)
print(tmp) |
p02571 | s021129596 | Wrong Answer | s = input()
t = input()
ans = 0
max = 0
if t in s:
print(ans)
else:
for i in range(len(s) - len(t) + 1):
for j in range(len(t)):
if t[j] == s[i]:
ans += 1
i += 1
else:
if max < ans:
max = ans
ans = 0
i += 1
print(len(t) - max)
|
p02571 | s041862117 | Wrong Answer | import sys
def main():
input = sys.stdin.readline
s = input()
t = input()
res = len(t)
# 部分文字列の探索
for i in range(len(s)-len(t)+1):
diff = 0
for j in range(len(t)):
if s[i + j] != t[j]:
diff += 1
res = min(res, diff)
print(res)
if __name__ == '__main__':
main() |
p02571 | s084593474 | Wrong Answer | S = input()
T = input()
n = len(T)
ans = len(T)
for st in range(0, len(S)-len(T)):
SS = S[st:st+len(T)]
tmp = len(T)
for s,t in zip(SS,T):
if s==t:
tmp -= 1
ans = min(ans, tmp)
print(ans)
|
p02571 | s161874438 | Wrong Answer | s = input()
t = input()
r = len(s)
lon = len(t)
for i in range(len(s)-len(t)):
c = 0
for j in range(lon):
if t[j]!=s[j+i]:
c += 1
if r >= c:
r = c
print(r) |
p02571 | s960617282 | Wrong Answer | str = input()
part = input()
flg = False
for i in range(len(part)):
for j in range(i + 1):
# atcoder -> atcode
# print(part[j:len(part)-i])
target = str[j: -(i - j)]
search = part[j: - (i - j)]
if search in target:
print(i)
flg = True
break
if flg:
break
if not flg:
print(len(part)) |
p02571 | s816725554 | Wrong Answer | S = input()
T = input()
S = list(S)
T = list(T)
result = len(T)-1
x = 0
for i in range(len(S)-len(T)+1):
for j in range(len(T)):
if S[i+j] != T[j]:
x += 1
if result > x:
result = x
x = 0
print(result) |
p02571 | s754331604 | Wrong Answer | S = input()
T = input()
max_count = 0
for start in range(len(T)):
for end in range(start+1, len(T)):
if T[start:end] in S[start:]:
count = end - start
max_count = max(max_count, count)
# print(T[start:end], count)
answer = len(T) - max_count
print(answer) |
p02571 | s782453437 | Wrong Answer | import numpy as np
S=input()
T=input()
length = len(list(T))
max_score = 0
for i in range(len(list(S))-len(list(T))):
tmp_T = np.array(list(T))
tmp_S = np.array(list(S))[i:i+len(tmp_T)]
score = np.zeros(len(tmp_T))
score[tmp_T==tmp_S]=1
score = np.sum(score)
if max_score < score:
max_score=score
print(int(length-max_score))
|
p02571 | s779103137 | Wrong Answer | S = input()
T = input()
ans = 1000
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
ans = min(ans, tmp)
print(i, ans)
print(ans)
|
p02571 | s765613348 | Wrong Answer | S = input()
T = input()
count = 0
ans = len(T)
for i in range(len(T)):
tmp = T[i:len(T)]
if tmp in S:
if ans > i:
ans = i
for i in range(1,len(T)+1):
tmp = T[0:i]
if tmp in S:
if ans > len(T) -i:
ans = len(T) -i
print(ans) |
p02571 | s782155568 | Wrong Answer | import sys
input = sys.stdin.readline
def main():
s = list( input() )
t = list( input() )
len_s = len( s )
len_t = len( t )
max = 0
for i in range( len_s - len_t + 1 ):
same = 0
for j in range( len_t ):
if s[ i + j ] == t[ j ]:
same += 1
if same > max:
max = same
print( len_t - max )
main() |
p02571 | s999880013 | Wrong Answer | import sys
input = sys.stdin.readline
S = input()
T = input()
if len(S) - len(T) > 0:
score_list = []
for i in range(len(S) - len(T)):
s = S[i:i+len(T)]
score = 0
for i in range(len(s)):
if s[i] != T[i]:
score += 1
score_list.append(score)
print(min(score_list))
|
p02571 | s998486108 | Wrong Answer | def l_in(type_): return list(map(type_, input().split()))
def i_in(): return int(input())
def m_in(type_): return map(type_, input().split())
def r_in(n, type_): return [type_(input()) for _ in range(n)]
ans = 0
s = input()
t = input()
l = len(t)
mx = 0
for idx, _ in enumerate(s[:-l]):
word = ''
for i in range(l):
word += s[idx+i]
x = 0
for a, b in zip(word, t):
if a == b: x += 1
if x > mx: mx = x
ans = l - mx
print(ans)
|
p02571 | s239649258 | Wrong Answer | import sys
input = sys.stdin.readline
S= input().rstrip('\n')
T= input().rstrip('\n')
res = 0
check = 0
for x in range(len(T),0,-1):
for i in range(len(T)-x):
l = len(T)-i-x-1
if T[i:i+x] in S[i:len(S)-l]:
res += len(T)-x
check += 1
break
if check>0:
break
print(res) |
p02571 | s974597383 | Wrong Answer | s = input()
t = input()
ans = 1000
for i in range(len(s) - len(t)):
c = 0
f = 0
for j in range(i, i + len(t)):
if s[j] != t[f]:
c += 1
f += 1
ans = min(ans, c)
print(ans)
|
p02571 | s102945121 | Wrong Answer | s = input()
t = input()
len_t = len(t)
ans = 9999
for i in range(len(s)-len(t)):
count = 0
for j in range(len_t):
if s[i+j]!=t[j]:
count+=1
ans = min(ans,count)
print(ans)
|
p02571 | s136794139 | Wrong Answer | s=input()
t=input()
slen=len(s)
tlen = len(t)
min = tlen
for i in range(slen - tlen):
count = 0
for j in range(tlen):
if s[i + j] != t[j]:
count += 1
if count < min:
min = count
print(min) |
p02571 | s227123931 | Wrong Answer |
S = input()
T = input()
count = 0
max_count = 0
for i in range(len(S) - len(T)):
for j in range(len(T)):
if S[i+j] == T[j]:
count += 1
if max_count <= count:
max_count = count
if j == (len(T) -1):
count = 0
print(len(T) - max_count)
|
p02571 | s859324574 | Wrong Answer | s = input()
t = input()
def count_ans(a,b):
ans = 0
for k in range(len(a)):
for l in range(len(b)-k):
if k==l and a[k]==b[l]:
ans += 1
return ans
ans = 0
for i in range(len(s)-len(t)+1):
Ans = count_ans(s[i:i+len(t)],t)
if ans < Ans:
ans = Ans
print(len(t)-ans) |
p02571 | s355783594 | Wrong Answer | S = input()
T = input()
for i in range(len(T)):
lT = len(T)-i+1
sT = 0
while lT != len(T)+1:
if T[sT:lT] in S[sT:len(S)]:
print(i)
exit()
else:
sT += 1
lT += 1
print(len(T))
|
p02571 | s281830740 | Wrong Answer | S = input()
T = input()
ans = 0
fin = 0
if (T in S):
print(0)
else:
for i in range(len(T)):
if fin == 1:
break
else:
ans += 1
for j in range(len(T)):
tmp = T[:j] + T[j+i +1:]
if (tmp in S):
print(ans)
fin = 1
break
|
p02571 | s910944966 | Wrong Answer | s = list(input())
t = list(input())
m = len(t)
for i in range(len(s)-len(t)+1):
c = 0
target = s[i:i+len(t)]
print(target)
for j in range(len(t)):
print(target[j],t[j])
if not target[j] == t[j]:
c += 1
print(m,c)
if c < m :
m = c
print(m) |
p02571 | s711667547 | Wrong Answer | s = input()
t = input()
ans = len(t)
for i in range(len(s) - len(t)):
cnt = len(t)
for j in range(len(t)):
if s[i + j] == t[j]:
cnt -= 1
if cnt < ans:
ans = cnt
print(ans)
|
p02571 | s827611273 | Wrong Answer | S=input()
T=input()
ans=len(T)
for j in range(len(S)-len(T)):
total=0
for i in range(len(T)):
if S[i+j]!=T[i]:
total+=1
if ans>=total:
ans=total
print(ans) |
p02571 | s744448138 | Wrong Answer | S = input()
T = input()
ans = float('inf')
for i in range(len(S)-len(T)):
st = S[i:len(T)+i]
count = 0
for j in range(len(T)):
if st[j]!=T[j]:
count+=1
ans = min(ans,count)
print(ans) |
p02571 | s370110403 | Wrong Answer | S=input()
LS=len(S)
T=input()
LT=len(T)
tmp=0
ans=LT
for i in range(LS-LT):
for j in range(LT):
if S[i+j]!=T[j]:
tmp+=1
ans=min(tmp,ans)
tmp=0
print(ans) |
p02571 | s453065897 | Wrong Answer | # Python template
from collections import defaultdict
import sys
import math
def get_array(): return list(map(int , sys.stdin.readline().strip().split()))
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def input(): return sys.stdin.readline().strip()
s = input()
t = input()
ans = math.inf
for i in range(len(s)-len(t)):
cnt = 0
for j in range(len(t)):
if t[j] != s[i+j]:
cnt+=1
ans = min(cnt,ans)
print(ans) |
p02571 | s741379652 | Wrong Answer | s=input()
t=input()
a=len(s)
b=len(t)
ans=1001
kari=0
k=0
for i in range(0,a-b):
kari=0
k=0
for j in t:
if j!=s[i+k]:
kari+=1
k+=1
if ans>kari:
ans=kari
print(ans) |
p02571 | s402306252 | Wrong Answer | S = input()
T = input()
max_diff = 0
window = len(T)
for i in range(0, len(S) - window + 1):
x = S[i: i+window]
count = 0
for a, b in zip(T, x):
if a != b:
count += 1
max_diff = max(count, max_diff)
print(max_diff) |
p02571 | s223912973 | Wrong Answer | S = input()
T = input()
temp = T
ans = 0
ret = False
t = list(T)
s = list(S)
t_ans = len(t)
f_ans = len(t)
for i in range(len(t)):
for k in range(len(t) - len(T)):
if T in S[k:k + len(T)]:
print(len(t) - len(T))
ret = True
if not ret:
print(len(t)) |
p02571 | s887816254 | Wrong Answer | def subst(S, T)-> int:
lenT = len(T)
result = lenT
for i in range(len(S) - lenT):
# tempS = S[i-lenT]
tempResult = 0
for j in range(lenT):
if T[j] != S[j + i]:
tempResult += 1
if tempResult < result:
result = tempResult
return result
if __name__ == "__main__":
S = input()
T = input()
print(subst(S, T)) |
p02571 | s477189057 | Wrong Answer | S = input()
T = input()
assert len(S) <= 1000
assert len(T) <= 1000
assert len(T) <= len(S)
len_T = len(T)
max_count = 0
for i in range(len(S)-len_T):
count = 0
for j in range(len_T):
count += int(T[j] == S[i+j])
max_count = max(count, max_count)
print(len_T - max_count) |
p02571 | s265810509 | Wrong Answer | S = input()
T = input()
lens = len(S)
lent = len(T)
ans = lent
for i in range(lens - lent):
count = 0
for j in range(lent):
if S[i+j] != T[j]:
count = count + 1
if count < ans:
ans = count
print(ans) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.