problem_id stringclasses 100 values | submission_id stringlengths 10 10 | status stringclasses 2 values | code stringlengths 6 806 |
|---|---|---|---|
p02571 | s949275031 | Wrong Answer | s = input()
t = input()
ans = len(t)
for i in range(len(s) - len(t)):
dif = 0
for j in range(len(t)):
if t[j] != s[i + j]:
dif = dif + 1
ans = min(ans, dif)
print(ans)
|
p02571 | s417379614 | Wrong Answer | S = str(input())
T = str(input())
ans = 1000
for i in range(len(S) - len(T)):
c = 0
for j in range(len(T)):
if S[i] != T[j]:
c += 1
i += 1
ans = min(ans, c)
print(ans) |
p02571 | s764727717 | 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] == S[start]:
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 | s499206120 | Wrong Answer | import sys
input = sys.stdin.readline
S = input()
T = input()
if len(S) - len(T) > 0:
score_list = []
for i in range(0, len(S) - len(T) + 1):
s = S[i:i+len(T)]
if len(s) != len(T):
continue
score = sum([1 if s[i]==T[i] else 0 for i in range(len(s))])
score_list.append(score)
print(len(T) - max(score_list))
elif len(S) == len(T):
score = sum([1 if S[i]==T[i] else 0 for i in range(len(S))])
print(len(T) - score)
|
p02571 | s279563259 | Wrong Answer | import bisect,collections,copy,heapq,itertools,math,numpy,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
S,T = [S() for _ in range(2)]
num = 0
for i in range(len(S)-len(T)):
str = S[i:i+len(T)]
count = 0
for j in range(len(T)):
if str[j]==T[j]:
count += 1
num = max(num,count)
print(len(T)-num)
|
p02571 | s386891456 | Wrong Answer | s=list(str(input()))
t=list(str(input()))
ch=len(t)
for i in range(len(s)-len(t)):
temp=0
for j in range(len(t)):
if(s[i+j]!=t[j]):
temp+=1
if(temp<ch):
ch=temp
print(ch)
|
p02571 | s013193541 | Wrong Answer | S=str(input())
T=str(input())
def longestSubstringFinder(string1, string2):
answer = ""
len1, len2 = len(string1), len(string2)
for i in range(len1):
match = ""
for j in range(len2):
if (i + j < len1 and string1[i + j] == string2[j]):
match += string2[j]
else:
if (len(match) > len(answer)): answer = match
match = ""
return answer
print (len(T)-len(longestSubstringFinder(S,T))) |
p02571 | s886785336 | Wrong Answer | str = input()
part = input()
flg = False
for i in range(len(part)):
for j in range(i + 1):
target = str[j: len(str) - (i - j)]
search = part[j: len(part) - (i - j)]
# print(f'target {target}, search {search}')
if search in target:
print(i)
flg = True
break
if flg:
break
if not flg:
print(len(part)) |
p02571 | s101630229 | Wrong Answer | S = input()
T = input()
slen = len(S)
tlen = len(T)
ans = 0
for i in range(slen - tlen):
count = 0
for j in range(tlen):
if S[i+j] == T[j]:
count += 1
ans = max(ans,count)
print(tlen-ans) |
p02571 | s773472539 | 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
print(change) |
p02571 | s883315126 | Wrong Answer | s_long = input()
s_shor = input()
ans = len(s_shor)
strr_1 = s_shor
strr_2 = s_shor
if (strr_1 in s_long):
print(0)
exit()
else:
for i in range(1, len(s_shor)):
strr_1 = s_shor[: - i]
strr_2 = s_shor[i:]
if (strr_1 in s_long or strr_2 in s_long):
ans = min(ans, i)
print(ans) |
p02571 | s916827043 | Wrong Answer |
def solve():
s=input()
t=input()
ans=len(t)
for i in range(0,len(s)-len(t)) :
diff=0
for j in range(0,len(t)) :
diff+= 1 if s[i+j]!=t[j] else 0
if diff>ans :
break
ans=min(ans,diff)
return ans
print(solve())
|
p02571 | s447002751 | Wrong Answer | s = input()
t = input()
l = len(t)
for i in range(l):
print(t[i:])
if t[i:] in s:
a = i
break
else:
a = l
for j in range(1, l):
print(t[:l-j])
if t[:l-j] in s:
b = j
break
else:
b = l
print(min(a, b)) |
p02571 | s855339235 | Wrong Answer | s=input()
t=input()
for i in range(len(t),0,-1):
for j in range(0,len(t)-i+1):
sum=t[j:j+i]
if sum in s[j:]:
k=s[j:].find(sum)
if len(s)-(k+j)>=len(t):
print(sum,j,k)
print(len(t)-len(sum))
exit()
print(len(t)) |
p02571 | s689167990 | Wrong Answer | S = input()
T = input()
counter_dict = {}
for i in range(len(S)):
counter = 0
for j in range(len(T)):
if i + j < len(S):
if S[i + j] == T[j]:
counter += 1
if str(i) in counter_dict.keys():
if counter_dict[str(i)] < counter:
counter_dict[str(i)] = counter
else:
counter_dict[str(i)] = counter
max_counter = max(counter_dict.values())
print(len(T) - max_counter) |
p02571 | s993941525 | Wrong Answer | # coding:utf-8
s = input()
t = input()
ans = len(t)
for i in range(len(s) - len(t)):
count = 0
for j in range(0, len(t)):
if s[i + j] != t[j]:
count += 1
ans = min(ans, count)
print(ans)
|
p02571 | s844057111 | Wrong Answer | S=input()
T=input()
def count_letter(A,B):
score=0
for i in range(len(A)):
if A[i]==B[i]:
score+=1
return score
count_max=0
for i in range(len(S)-len(T)):
count_max=max(count_max,count_letter(S[i:i+len(T)],T))
print(len(T)-count_max) |
p02571 | s603597482 | Wrong Answer | s = input()
t = input()
n,m = len(s),len(t)
ans = 10**4
for i in range(n-m):
c = 0
for j in range(m):
if t[j] != s[i+j]:
c += 1
ans = min(ans,c)
print(ans) |
p02571 | s510959936 | Wrong Answer | import sys
if __name__ == '__main__':
S = sys.stdin.readline()
T = sys.stdin.readline()
max_match = -1
for i in range(len(T)):
for j in range(i+1, len(T)):
pos = S[i:-j].find(T[i:j])
if max_match < j-i and pos != -1:
max_match = j - i
if max_match == -1:
l = len(T)
print(len(T)-max_match-1) |
p02571 | s526773504 | Wrong Answer | S=list(input())
T=list(input())
x=[0]*(len(S)+1)
for i in range(len(S)):
for j in range(len(T)):
if T[j]==S[i] :
if (j-1)>=0 and (i-1)>=0 and T[j-1]==S[i-1]:
x[i]=x[i-1]+1
else:
x[i]=1
print(len(T)-max(x))
|
p02571 | s703471786 | Wrong Answer | s = input()
t = input()
ls = len(s)
lt = len(t)
ans = 1000000
for i in range(ls - lt):
tmp = s[i:i+lt]
score = 0
for j in range(lt):
if tmp[j] != t[j]:
score += 1
ans = min(ans, score)
print(ans) |
p02571 | s610740067 | Wrong Answer | S = input()
T = input()
ans1 = len(T)
ans2 = len(T)
for i in range(len(T)):
if T[0:i+1] in S:
ans1 = len(T) - i - 1
if T[::-1][0:i+1][::-1] in S:
ans2 = len(T) - i - 1
print(min(ans1, ans2)) |
p02571 | s159007250 | Wrong Answer | s = input()
t = input()
ans = len(t)
for i in range(len(s)):
if (i + len(t)>= len(s)): break
dif = 0
for j in range(len(t)):
if (s[i + j] != t[j]):
dif += 1
ans = min(ans, dif)
print(ans) |
p02571 | s470028868 | Wrong Answer | S = input()
T = input()
L,l = len(S),len(T)
ans = 1000
for i in range(l,L):
s = S[i-l:i]
cnt = 0
for j in range(l):
if s[j] != T[j]:
cnt += 1
if ans > cnt:
ans = cnt
print(ans) |
p02571 | s019819383 | Wrong Answer | s = input()
t = input()
ans = 0
for i in range(len(t)+1, 0, -1):
for j in range(0, len(t)-i+1):
if t[j:j+i] in s:
#print(t[j:j+i], s[j:len(t)-j+i])
ans = i
break
print(len(t)-ans)
|
p02571 | s794976966 | Wrong Answer | s=str(input())
t=str(input())
flag=False
m=0
for i in range(len(s)-len(t)+1):
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 | s937423304 | Wrong Answer | def compare(t,s):
diff=0
for i in range(len(s)):
if s[i]!=t[i]:
diff+=1
return diff
t = input().strip()
s = input().strip()
smallchange = len(s)
for i in range(len(t)-len(s)+1):
x = compare(t[i:len(s)+i], s)
if smallchange > x:
smallchange = x
print(x) |
p02571 | s756207675 | Wrong Answer | def core(s, t):
if t in s:
return 0
for i in range(1, len(t)):
for j in range(i+1):
tempt = t[j:len(t)-i+j]
temps = s[j:len(s)-i+j]
if tempt in temps:
return i
return len(t)
if __name__ == "__main__":
strings = [input() for i in range(2)]
print(core(strings[0], strings[1]))
|
p02571 | s232163324 | Wrong Answer | s = input()
t = input()
ans = 10000
len_t = len(t)
for i in range(len(s) - len_t):
ans_tmp = 0
for j in range(len(t)):
if s[i+j] != t[j]:
ans_tmp += 1
ans = min(ans, ans_tmp)
print(ans) |
p02571 | s198490656 | Wrong Answer | s = input()
t = input()
minCount = 100000000
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
if len(t) == 0:
print(0)
print(minCount)
|
p02571 | s011141420 | Wrong Answer | s = input()
t = input()
ans = float("inf")
for idx in range(len(s)-len(t)):
score = 0
for idx2 in range(len(t)):
if s[idx+idx2] != t[idx2]:
score += 1
ans = min(ans, score)
print(ans) |
p02571 | s812730713 | Wrong Answer | def main():
min_num = len(T)
for i in range(len(S)):
count = 0
for j in range(len(T)):
if i+j > len(S)-1:
break
if S[i+j] == T[j]:
count += 1
min_num = min_num if min_num < len(T)-count else len(T)-count
print(min_num)
S = input()
T = input()
main()
|
p02571 | s313087175 | Wrong Answer | S = input()
T = input()
for i in range(len(T), 0, -1):
for j in range(len(T)-i+1):
subst = T[j:i+j]
# print(subst)
if S.find(subst, j)>=0:
print (len(T)-i)
exit(0)
|
p02571 | s885126885 | Wrong Answer | S=str(input())
T=str(input())
min_count=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
min_count=min(count,min_count)
print(min_count)
|
p02571 | s729573756 | Wrong Answer | s = str(input())
t = str(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)
|
p02571 | s215518080 | Wrong Answer | S = input()
T = input()
l = len(T)
ans = l
for i in range(l):
for j in range(l):
if (i<=j):
if T[i:j+1] in S:
f = S.find(T[i:j+1])
if f >= i and f + (l-j) <= len(S):
ans = min(ans, l - (j+1-i))
print(ans)
|
p02571 | s319585644 | Wrong Answer | s = input()
t = input()
N = len(s)
n = len(t)
m = 0
for i in range(N-n):
cnt = 0
S = list(s)[i:i+n]
T = list(t)
for j in range(n):
if S[j] == T[j]:
cnt += 1
if m < cnt:
m = cnt
print(n-m) |
p02571 | s505948324 | Wrong Answer | s=input()
t=input()
ans=float('inf')
for i in range(len(s)-len(t)):
a=s[i:i+len(t)]
tans=0
for i in range(len(t)):
tans+=(t[i]!=a[i])
ans=min(ans,tans)
print(ans) |
p02571 | s122711395 | Wrong Answer | S = input()
T = input()
l = len(T)
mx = -1
for i in range(len(S) - l):
m = [a == b for a, b in zip(S[i:i + l], T)].count(True)
mx = max(m, mx)
print(l - mx) |
p02571 | s262264431 | Wrong Answer | S = input()
T = input()
res = 0
for i in range(len(S)-len(T)):
a = 0
for j in range(len(T)):
a += S[i+j] == T[j]
res = max(res,a)
print(len(T)-res) |
p02571 | s804845328 | Wrong Answer | S = input()
T = input()
ans=float('inf')
for start in range(len(S) - len(T)):
ans = min(ans, sum(s != t for s, t in zip(S, T)))
print(ans)
|
p02571 | s526762475 | Wrong Answer | import re
result_list = []
S = input()
T = list(input())
result = 0
for i in range(len(T)+1):
for j in range(len(T)):
if i+j<=len(T):
temp_word = ''.join(T[j:j+i])
if temp_word in S:
result = len(T) - len(temp_word)
print(result) |
p02571 | s258788854 | Wrong Answer | S = input()
T = input()
s = len(S)
t = len(T)
ans = 10**10
for i in range(s-t):
mm = 0
for j in range(t):
if S[i+j]!=T[j]:
mm += 1
ans = min(ans,mm)
print(ans) |
p02571 | s798185580 | 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[i:]:
if len(T) - len(T[i:j]) < ans:
ans = len(T) - len(T[i:j])
print(ans)
|
p02571 | s332313036 | Wrong Answer | s = input()
t = input()
num = 0
for i in range(len(s) - len(t) + 1):
# a = s[i:]
# print(a)
cnt = 0
for j in range(len(t)):
if i + j >= len(t):
continue
if t[j] == s[i + j]:
cnt += 1
num = max(num, cnt)
print(len(t) - num)
|
p02571 | s516452083 | Wrong Answer | S = input()
T = input()
lenS = len(S)
lenT = len(T)
substrings = [(i, j, T[i: j]) for i in range(lenT) for j in range(i + 1, lenT + 1)]
minv = lenT
for i, j, s in substrings:
if s in S:
sidx = S.index(s)
if (sidx >= i) & (sidx + j - i <= lenS):
candidate = lenT - (j - i)
if minv > candidate:
minv = candidate
print(minv) |
p02571 | s367050733 | Wrong Answer | S = list(input())
T = list(input())
ls = len(S)
lt = len(T)
ans = lt
for offset in range(ls - lt + 1):
cnt = 0
for i in range(lt):
if S[offset + i] != T[i]:
cnt += 1
ans = min(lt, cnt)
print(ans) |
p02571 | s489340446 | Wrong Answer | s = input()
t = input()
ans = len(t)
for num in range(len(t)):
if (t[:len(t) - num] in s):
ans = num
break
print(num) |
p02571 | s139811264 | Wrong Answer | def cin(): return list(map(int,input().split()))
S = input()
T = input()
ans = 10 ** 9 + 7
l1 = len(S)
l2 = len(T)
for i in range(l1 - l2):
cnt = 0
for j in range(l2):
if S[i + j] != T[j]: cnt += 1
ans = min(ans, cnt)
print(ans) |
p02571 | s864482137 | Wrong Answer | S = input()
T = input()
ans = len(S)
for i in range(len(T)):
for j in range(i, len(S)):
if T[i] == S[j]:
c = 1
for k in range(0, min(len(S)-j-1,len(T)-i-1)):
if T[i+1+k] == S[j+1+k]:
c += 1
tmp = len(T) - c
ans = min(ans, tmp)
print(ans) |
p02571 | s576655503 | Wrong Answer | sList = list(input())
tList = list(input())
numList = []
for ti,t in enumerate(tList):
num = 0
for si,s in enumerate(sList):
tnum = ti
snum = si
while tList[tnum] == sList[snum]:
num += 1
tnum += 1
snum += 1
if tnum >= len(tList): break
if snum >= len(sList): break
numList.append(num)
if max(numList) > (len(sList) - ti): break
if len(tList) - max(numList) > 0:
print(len(tList) - max(numList))
else:
print(0) |
p02571 | s304755786 | Wrong Answer | S,T = input(),input()
num = len(T)
ans = num
for i in range(num):
for j in range(i+1,num+1):
str = T[i:j]
if str in S[i:-(num-j)]:
ans = min(ans,num - len((T[i:j])))
# print(i,j,ans,T[i:j])
print(ans)
|
p02571 | s218575433 | Wrong Answer | s= input()
t = input()
ans = 100000000
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(ans,cnt)
print(ans)
|
p02571 | s479737921 | Wrong Answer | import sys
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
S = input().strip()
T = input().strip()
cnt = float("inf")
for i in range(len(S) - len(T)):
tmp = 0
for j in range(len(T)):
if S[i + j] != T[j]:
tmp += 1
cnt = min(cnt, tmp)
print(cnt)
if __name__ == '__main__':
main()
|
p02571 | s418015811 | Wrong Answer | a=b=0
for i in range(len(s:=input())-len(t:=input())):
for j,c in enumerate(t):b+=(s[i+j]==c)
a=max(a,b);b=0
print(len(t)-a) |
p02571 | s632246983 | Wrong Answer | s=input()
t=input()
res=float("INF")
for i in range(len(s)):
for j in range(len(t)):
if s[i]==t[j] and i>=j and len(s)-i>=len(t)-j :
tmp=j
for k in range(j,len(t)):
if i-j+k<(len(s)) and s[i-j+k] != t[k]:
tmp+=1
res=min(res,tmp)
print(res) |
p02571 | s314555525 | Wrong Answer | import sys
def check(S, T):
count = 0
for s, t in zip(S, T):
if s != t:
count += 1
return count
def main():
S = input()
T = input()
dif = len(S) - len(T)
ans = 10000
for i in range(dif):
compare = S[i: i+len(T)]
count = check(compare, T)
if count < ans:
ans = count
print(ans)
if __name__ == "__main__":
main()
|
p02571 | s392715857 | Wrong Answer | S = list(input())
T = list(input())
lt = len(T)
result = 10**5
for i in range(len(S) - len(T) + 1):
cnt = 0
for s, t in zip(S[i: (i + lt)], T):
if s != t:
cnt += 1
result = max(cnt, result)
print(result) |
p02571 | s379306271 | Wrong Answer | s=str(input())
t=str(input())
l=0
for i in range(len(s)-len(t)+1):
print(s[i:i+len(t)])
p=0
for j in range(len(t)):
if t[j] == s[i:i+len(t)][j]:
p+=1
l=max(l,p)
print(len(t)-l) |
p02571 | s882530444 | Wrong Answer | S = input()
T = input()
ans = 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
ans = min(ans, t)
print (ans) |
p02571 | s273830243 | Wrong Answer | S = input()
T = input()
def same(U):
k = 0
for i in range(len(U)):
if U[i] == T[i]:
k += 1
return k
ans = 0
for i in range(len(S)-len(T)):
ans = max(ans,same(S[i:i+len(T)]))
print(len(T)-ans) |
p02571 | s983703719 | Wrong Answer | import sys
readline = sys.stdin.readline
S = readline().strip()
T = readline().strip()
s = len(S)
t = len(T)
ans = t
for i in range(0, s-t):
n = t
for j in range(t):
if S[i+j] == T[j]:
n -= 1
if n < ans:
ans = n
if ans == 0:
break
print(ans)
|
p02571 | s452502568 | Wrong Answer | s, t = input(), input()
ls = len(s)
lt= len(t)
is_double = False
for i in range(0,lt):
size = lt-i
for j in range(0,lt-size+1):
jps = (j+size)
# 0 j (j+size) lt
_t = t[j:jps]
# print(i,j,size,_t, f'\t{s[j:ls-(lt-(j+size))]}')
if _t in s[j:ls-(lt-(j+size))]:
is_double = True
break
if is_double:
print(i)
break
if not is_double:
print(lt)
|
p02571 | s938006844 | Wrong Answer | s = input()
t = input()
cnt = []
for i in range(len(t)):
for k in range(i + 1, len(t) + 1):
if t[i:k] in s[i:]:
cnt.append(k - i)
else:
cnt = [0]
#print(t[i:k], k - i)
#print(cnt)
print(len(t) - max(cnt))
|
p02571 | s403069236 | Wrong Answer | S = input()
T = input()
ls = len(S)
lt = len(T)
a = 0
for i in range(lt):
for j in range(i+1,lt+1):
if T[i:j] in S[i:ls-lt+j]:
if a < j -i:
a = j - i
print(lt-a)
|
p02571 | s040582651 | Wrong Answer | s = input()
t = input()
n = len(s)
m = len(t)
ans = m
for i in range(n-m):
p = 1
for j in range(i,m):
if s[i+j] == t[j]: p += 1
else: break
if m-p < ans: ans = m-p
print(ans) |
p02571 | s872897705 | Wrong Answer | s,t=open(0)
print(min(sum(a!=b for a,b in zip(s[i:]+t,t[:-1]))for i in range(len(s)))) |
p02571 | s766878457 | Wrong Answer | S = input()
T = input()
max_match = 0
n = len(T)
m = len(S)
for i in range(m-n):
tmp = 0
for j in range(i,i+n):
if S[j] == T[j-i]:
tmp += 1
if tmp > max_match:
max_match = tmp
ans = n - max_match
print(ans) |
p02571 | s547548099 | Wrong Answer | s = input()
t = input()
ans = len(t)
len_t = 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 ans > cnt:
ans = cnt
print(ans)
|
p02571 | s074805402 | Wrong Answer | s=input()
t=input()
ans=len(t)
for i in range(len(s)):
s1=s[i:len(t)]
sum=len(t)
for j in range(len(s1)):
if t[j]==s1[j]:sum-=1
ans=min(ans,sum)
print(ans) |
p02571 | s216389462 | Wrong Answer | S = input()
T = input()
min_count = 10000000
for k in range(len(T)):
for i in range(len(S)-len(T)+1):
count = k
if T[k] == S[k+i]:
for j in range(1,len(T)-k):
if S[i+j] != T[k+j]:
count += 1
if count < min_count:
min_count = count
print(min_count) |
p02571 | s271084619 | Wrong Answer | def probB():
S = input()
T = input()
if T in S:
print(0)
return
maxequal = 0
for i in range(len(S) - len(T)):
count = 0
for j in range(len(T)):
if S[i + j] == T[j]:
count += 1
if (count > maxequal):
maxequal = count
print(len(T) - maxequal if maxequal > 0 else 0)
def main():
probB()
if __name__ == '__main__':
main()
|
p02571 | s030037512 | Wrong Answer | S,T=open(0).read().split()
def main():
for i in range(1,len(T)+1):
for j in range(i+1):
if T[j:(len(T)-i+j)] in S[j:(len(S)-i+j)]:
return i
break
if T in S:
print(0)
else:
print(main()) |
p02571 | s136451202 | Wrong Answer | # from math import
s = input()
t = input()
def distance(s, t):
assert(len(s) == len(t))
return len(s) - sum([c1 == c2 for c1, c2 in zip(s, t)])
min_d = len(s)
for i in range(len(s) - len(t)):
min_d = min(min_d, distance(s[i:i+len(t)], t))
print(min_d)
|
p02571 | s705656982 | Wrong Answer | S = input()
T = input()
len_T = len(T)
len_S = len(S)
output = 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
output = min(output, diff)
print('output',output)
|
p02571 | s119717610 | 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 | s564629068 | Wrong Answer | import re
s = input()
t = input()
cnt = -1
for i in range(len(t) + 1):
cnt += 1
f = "\S{" + str(i) +"}" + t[(i):len(t)]
b = t[0:len(t) - i] + "\S{" + str(i) + "}"
if re.search(f, s):
print("in")
break
elif re.search(b, s):
print("in")
break
print(cnt)
|
p02571 | s709108984 | Wrong Answer | s = input()
t = input()
l = len(t)
ans = 0
a = 0
for i in range(len(s) - l + 1):
ss = list(s[i:i+l])
for j in range(l):
if ss[j] ==t[j]:
ans += 1
else:
if a < ans:
a = ans
ans = 0
if a < ans:
a = ans
ans = 0
print(l-a) |
p02571 | s433875035 | Wrong Answer | s = list(str(input()))
t = list(str(input()))
x = [0]
a = 0
for i in range(len(t)):
for k in range(len(s)):
if(t[i] == s[k] and ((len(s)- k) >= (len(t)-i)) and (k >= i)):
a += 1
for n in range(1,(len(t)-i)):
if(t[i+n] == s[k+n]):
a += 1
x.append(a)
a = 0
y = max(x)
print((len(t) - y)) |
p02571 | s131795518 | Wrong Answer | S = input()
T = input()
lenS = len(S)
lenT = len(T)
maxcnt = 0
for l in range(lenT):
for r in range(l,lenT):
if T[l:r+1] in S[l:lenS-lenT+r+1]:
maxcnt = max(maxcnt, r - l + 1)
print(lenT - maxcnt) |
p02571 | s622651336 | Wrong Answer | # -*- coding: utf-8 -*-
def cout_dif(a, b):
sum = 0
for i in range(len(a)):
if a[i] != b[i]:
sum += 1
return sum
def main():
s = input()
t = input()
min = 10**5
for i in range(len(s)-len(t)):
sum = cout_dif(t, s[i:i+len(t)+1])
if sum < min:
min = sum
print(min)
if __name__ == '__main__':
main() |
p02571 | s523553574 | Wrong Answer | s = input()
t = input()
ans = 0
for i in range(len(s)-len(t)+1):
m = 0
for j, k in zip(s[i:],t):
if j==k:
m += 1
if m > ans:
ans = m
print(ans) |
p02571 | s841962927 | Wrong Answer | S = input()
T = input()
min_count = len(T)
for i in range(len(S) - len(T)):
count = 0
for x in range(len(T)):
if S[i+x] != T[x]:
count += 1
if count < min_count:
min_count = count
print(min_count)
|
p02571 | s635787223 | Wrong Answer | from functools import reduce
s, t = input(), input()
ans = 10**9
for i in range(0, len(s) - len(t)):
ans = min(ans, reduce(lambda x, a: x + (1 if a[0] != a[1] else 0), zip(s[i:], t), 0))
print(ans) |
p02571 | s706436132 | Wrong Answer | def resolve():
S = list(input())
T = list(input())
lenT = len(T)
res = lenT
for i in range(len(S)-lenT):
tmp = lenT
for j in range(lenT):
if S[i+j] == T[j]:
tmp -= 1
res = min(res, tmp)
print(res)
resolve() |
p02571 | s672244398 | Wrong Answer | s = input()
t = input()
slen = len(s)
tlen = len(t)
ans = 10000
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 | s252627362 | Wrong Answer | import sys
from sys import stdin
input = stdin.readline
INF = 10**9
s = input()
t = input()
ans = INF
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(cnt, ans)
print(ans) |
p02571 | s696920001 | Wrong Answer | S = input()
T = input()
cnt = 0
for i in range(len(S)):
tmp = 0
for j in range(len(T)):
if i + j < len(S) and S[i + j] == T[j]:
tmp += 1
else:
cnt = max(cnt, tmp)
tmp = 0
cnt = max(cnt, tmp)
print(len(T) - cnt) |
p02571 | s700556981 | Wrong Answer | s = input()
t = input()
ans = len(t)
for i in range(len(s)-len(t)+1):
tmp=0
for j in range(len(t)):
if t[j] == s[i+j]:
tmp+=1
ans = min(tmp,ans)
print(ans) |
p02571 | s380623657 | Wrong Answer | S = str(input())
T = str(input())
max_len = 0
for left in range(len(T)):
for right in range(left, len(T)):
tmp = T[left:right]
tmpS = S[left:-(len(T) - right)]
# print(tmp, tmpS)
if tmp in tmpS:
max_len = max(len(tmp), max_len)
print(len(T) - max_len) |
p02571 | s349412667 | Wrong Answer | s = input()
t = input()
maiores = []
maior = 0
for i in range(len(s)-len(t)+1):
for j in range(len(t)):
if s[i+j] == t[j]:
maior += 1
if j == len(t)-1:
maiores.append(maior)
else:
maiores.append(maior)
maior = 0
print(len(t) - max(maiores)) |
p02571 | s784298959 | Wrong Answer | S = input()
T = input()
Min = 100000
for i in range(len(S) - len(T) + 1):
count = 0
for n in range(len(T)):
if S[i + n] != T[n]:
count += 1
if count < Min:
Min = count
print(count) |
p02571 | s581475256 | Wrong Answer | import sys
def input(): return sys.stdin.readline().strip()
def I(): return int(input())
def LI(): return list(map(int, input().split()))
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def S(): return input()
def LS(): return input().split()
INF = float('inf')
s = S()
t = S()
ans = INF
for i in range(len(s)-len(t)):
now = 0
for j in range(i, i+len(t)):
if s[j] != t[j-i]:
now += 1
ans = min(ans, now)
print(ans)
|
p02571 | s754681821 | Wrong Answer | s = input()
t = input()
l = len(t)
flag = False
for i in range(l):
k = l - i
for j in range(i+1):
a = t[j:k+j]
if a in s:
flag = True
break
if flag:
break
if flag:
print(i)
else:
print(l) |
p02571 | s378640803 | Wrong Answer | s=str(input())
t=str(input())
lens=len(s)
lent=len(t)
cnt=1000
for i in range(lens-lent):
temp=0
for j in range(lent):
if t[j]!=s[i+j]:
temp+=1
if temp<cnt:
cnt=temp
print(cnt) |
p02571 | s974791579 | 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
for i in range(1,len(T)):
M = S.rfind(T[:i])
if M >= i and A > i:
A = i
print(A) |
p02571 | s962956367 | Wrong Answer | S=input()
T=input()
match=0
for i in range(len(S)-len(T)):
count=0
for j in range(len(T)):
if S[i+j]==T[j]:
count=count+1
if match<count:
match=count
print(len(T)-match) |
p02571 | s428080324 | Wrong Answer | s = input()
t = input()
ls = len(s)
lt = len(t)
flag = False
for i in range(lt):
for j in range(i+1):
a = i-j
ss = s[j:ls-a]
tt = t[j:lt-a]
if tt in ss:
flag = True
break
if flag:
break
if flag:
print(i)
else:
print(lt) |
p02571 | s741713947 | Wrong Answer | S, T = [input() for i in range(2)]
ans = 0
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 = max(ans, diff)
print(len(T)-ans) |
p02571 | s924759981 | Wrong Answer | def main():
S = input()
T = input()
temp = ''
for i in range(1, len(T)+1):
print(T[0:i])
if T[0:i] in S:
temp = T[0:i]
print(len(T)- len(temp))
if __name__ == '__main__':
main() |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.