message stringlengths 2 11.9k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 137 108k | cluster float64 18 18 | __index_level_0__ int64 274 217k |
|---|---|---|---|---|---|
Provide a correct Python 3 solution for this coding contest problem.
You are given strings s and t, consisting of lowercase English letters. You will create a string s' by freely rearranging the characters in s. You will also create a string t' by freely rearranging the characters in t. Determine whether it is possible to satisfy s' < t' for the lexicographic order.
Constraints
* The lengths of s and t are between 1 and 100 (inclusive).
* s and t consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
s
t
Output
If it is possible to satisfy s' < t', print `Yes`; if it is not, print `No`.
Examples
Input
yx
axy
Output
Yes
Input
ratcode
atlas
Output
Yes
Input
cd
abc
Output
No
Input
w
ww
Output
Yes
Input
zzz
zzz
Output
No | instruction | 0 | 107,718 | 18 | 215,436 |
"Correct Solution:
```
print('Yes'*(sorted(input())<sorted(input())[::-1])or'No')
``` | output | 1 | 107,718 | 18 | 215,437 |
Provide a correct Python 3 solution for this coding contest problem.
You are given strings s and t, consisting of lowercase English letters. You will create a string s' by freely rearranging the characters in s. You will also create a string t' by freely rearranging the characters in t. Determine whether it is possible to satisfy s' < t' for the lexicographic order.
Constraints
* The lengths of s and t are between 1 and 100 (inclusive).
* s and t consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
s
t
Output
If it is possible to satisfy s' < t', print `Yes`; if it is not, print `No`.
Examples
Input
yx
axy
Output
Yes
Input
ratcode
atlas
Output
Yes
Input
cd
abc
Output
No
Input
w
ww
Output
Yes
Input
zzz
zzz
Output
No | instruction | 0 | 107,719 | 18 | 215,438 |
"Correct Solution:
```
s = sorted(input())
t = sorted(input())[::-1]
if s < t:
print("Yes")
else:
print("No")
``` | output | 1 | 107,719 | 18 | 215,439 |
Provide a correct Python 3 solution for this coding contest problem.
You are given strings s and t, consisting of lowercase English letters. You will create a string s' by freely rearranging the characters in s. You will also create a string t' by freely rearranging the characters in t. Determine whether it is possible to satisfy s' < t' for the lexicographic order.
Constraints
* The lengths of s and t are between 1 and 100 (inclusive).
* s and t consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
s
t
Output
If it is possible to satisfy s' < t', print `Yes`; if it is not, print `No`.
Examples
Input
yx
axy
Output
Yes
Input
ratcode
atlas
Output
Yes
Input
cd
abc
Output
No
Input
w
ww
Output
Yes
Input
zzz
zzz
Output
No | instruction | 0 | 107,720 | 18 | 215,440 |
"Correct Solution:
```
s=sorted(input())
t=sorted(input())
t.sort(reverse=True)
print("Yes" if s<t else "No")
``` | output | 1 | 107,720 | 18 | 215,441 |
Provide a correct Python 3 solution for this coding contest problem.
You are given strings s and t, consisting of lowercase English letters. You will create a string s' by freely rearranging the characters in s. You will also create a string t' by freely rearranging the characters in t. Determine whether it is possible to satisfy s' < t' for the lexicographic order.
Constraints
* The lengths of s and t are between 1 and 100 (inclusive).
* s and t consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
s
t
Output
If it is possible to satisfy s' < t', print `Yes`; if it is not, print `No`.
Examples
Input
yx
axy
Output
Yes
Input
ratcode
atlas
Output
Yes
Input
cd
abc
Output
No
Input
w
ww
Output
Yes
Input
zzz
zzz
Output
No | instruction | 0 | 107,721 | 18 | 215,442 |
"Correct Solution:
```
S = sorted(list(input()))
T = sorted(list(input()))[::-1]
print('Yes' if S<T else 'No')
``` | output | 1 | 107,721 | 18 | 215,443 |
Provide a correct Python 3 solution for this coding contest problem.
You are given strings s and t, consisting of lowercase English letters. You will create a string s' by freely rearranging the characters in s. You will also create a string t' by freely rearranging the characters in t. Determine whether it is possible to satisfy s' < t' for the lexicographic order.
Constraints
* The lengths of s and t are between 1 and 100 (inclusive).
* s and t consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
s
t
Output
If it is possible to satisfy s' < t', print `Yes`; if it is not, print `No`.
Examples
Input
yx
axy
Output
Yes
Input
ratcode
atlas
Output
Yes
Input
cd
abc
Output
No
Input
w
ww
Output
Yes
Input
zzz
zzz
Output
No | instruction | 0 | 107,722 | 18 | 215,444 |
"Correct Solution:
```
s=input()
t=input()
print(['No','Yes'][''.join(sorted(s))<''.join(sorted(t,reverse=True))])
``` | output | 1 | 107,722 | 18 | 215,445 |
Provide a correct Python 3 solution for this coding contest problem.
You are given strings s and t, consisting of lowercase English letters. You will create a string s' by freely rearranging the characters in s. You will also create a string t' by freely rearranging the characters in t. Determine whether it is possible to satisfy s' < t' for the lexicographic order.
Constraints
* The lengths of s and t are between 1 and 100 (inclusive).
* s and t consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
s
t
Output
If it is possible to satisfy s' < t', print `Yes`; if it is not, print `No`.
Examples
Input
yx
axy
Output
Yes
Input
ratcode
atlas
Output
Yes
Input
cd
abc
Output
No
Input
w
ww
Output
Yes
Input
zzz
zzz
Output
No | instruction | 0 | 107,723 | 18 | 215,446 |
"Correct Solution:
```
s = ''.join(sorted(input()))
t = ''.join(sorted(input())[::-1])
print('Yes' if s < t else 'No')
``` | output | 1 | 107,723 | 18 | 215,447 |
Provide a correct Python 3 solution for this coding contest problem.
You are given strings s and t, consisting of lowercase English letters. You will create a string s' by freely rearranging the characters in s. You will also create a string t' by freely rearranging the characters in t. Determine whether it is possible to satisfy s' < t' for the lexicographic order.
Constraints
* The lengths of s and t are between 1 and 100 (inclusive).
* s and t consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
s
t
Output
If it is possible to satisfy s' < t', print `Yes`; if it is not, print `No`.
Examples
Input
yx
axy
Output
Yes
Input
ratcode
atlas
Output
Yes
Input
cd
abc
Output
No
Input
w
ww
Output
Yes
Input
zzz
zzz
Output
No | instruction | 0 | 107,724 | 18 | 215,448 |
"Correct Solution:
```
s=input()
t=input()
s1=sorted(s)
t1=sorted(t)[::-1]
print('Yes' if s1<t1 else 'No' )
``` | output | 1 | 107,724 | 18 | 215,449 |
Provide a correct Python 3 solution for this coding contest problem.
You are given strings s and t, consisting of lowercase English letters. You will create a string s' by freely rearranging the characters in s. You will also create a string t' by freely rearranging the characters in t. Determine whether it is possible to satisfy s' < t' for the lexicographic order.
Constraints
* The lengths of s and t are between 1 and 100 (inclusive).
* s and t consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
s
t
Output
If it is possible to satisfy s' < t', print `Yes`; if it is not, print `No`.
Examples
Input
yx
axy
Output
Yes
Input
ratcode
atlas
Output
Yes
Input
cd
abc
Output
No
Input
w
ww
Output
Yes
Input
zzz
zzz
Output
No | instruction | 0 | 107,725 | 18 | 215,450 |
"Correct Solution:
```
s, t = [input() for _ in range(2)]
print('Yes' if sorted(s) < sorted(t)[::-1] else 'No')
``` | output | 1 | 107,725 | 18 | 215,451 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given strings s and t, consisting of lowercase English letters. You will create a string s' by freely rearranging the characters in s. You will also create a string t' by freely rearranging the characters in t. Determine whether it is possible to satisfy s' < t' for the lexicographic order.
Constraints
* The lengths of s and t are between 1 and 100 (inclusive).
* s and t consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
s
t
Output
If it is possible to satisfy s' < t', print `Yes`; if it is not, print `No`.
Examples
Input
yx
axy
Output
Yes
Input
ratcode
atlas
Output
Yes
Input
cd
abc
Output
No
Input
w
ww
Output
Yes
Input
zzz
zzz
Output
No
Submitted Solution:
```
s, t = sorted(input()), sorted(input())[::-1]
print("YNeos"[sorted([s,t])[0]==t::2])
``` | instruction | 0 | 107,726 | 18 | 215,452 |
Yes | output | 1 | 107,726 | 18 | 215,453 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given strings s and t, consisting of lowercase English letters. You will create a string s' by freely rearranging the characters in s. You will also create a string t' by freely rearranging the characters in t. Determine whether it is possible to satisfy s' < t' for the lexicographic order.
Constraints
* The lengths of s and t are between 1 and 100 (inclusive).
* s and t consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
s
t
Output
If it is possible to satisfy s' < t', print `Yes`; if it is not, print `No`.
Examples
Input
yx
axy
Output
Yes
Input
ratcode
atlas
Output
Yes
Input
cd
abc
Output
No
Input
w
ww
Output
Yes
Input
zzz
zzz
Output
No
Submitted Solution:
```
s=sorted(input())
t=sorted(input(),reverse=True)
print("Yes" if s<t else "No")
``` | instruction | 0 | 107,727 | 18 | 215,454 |
Yes | output | 1 | 107,727 | 18 | 215,455 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given strings s and t, consisting of lowercase English letters. You will create a string s' by freely rearranging the characters in s. You will also create a string t' by freely rearranging the characters in t. Determine whether it is possible to satisfy s' < t' for the lexicographic order.
Constraints
* The lengths of s and t are between 1 and 100 (inclusive).
* s and t consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
s
t
Output
If it is possible to satisfy s' < t', print `Yes`; if it is not, print `No`.
Examples
Input
yx
axy
Output
Yes
Input
ratcode
atlas
Output
Yes
Input
cd
abc
Output
No
Input
w
ww
Output
Yes
Input
zzz
zzz
Output
No
Submitted Solution:
```
s=list(input())
t=list(input())
s.sort()
t.sort(reverse=True)
if s<t:print('Yes')
else:print('No')
``` | instruction | 0 | 107,728 | 18 | 215,456 |
Yes | output | 1 | 107,728 | 18 | 215,457 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given strings s and t, consisting of lowercase English letters. You will create a string s' by freely rearranging the characters in s. You will also create a string t' by freely rearranging the characters in t. Determine whether it is possible to satisfy s' < t' for the lexicographic order.
Constraints
* The lengths of s and t are between 1 and 100 (inclusive).
* s and t consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
s
t
Output
If it is possible to satisfy s' < t', print `Yes`; if it is not, print `No`.
Examples
Input
yx
axy
Output
Yes
Input
ratcode
atlas
Output
Yes
Input
cd
abc
Output
No
Input
w
ww
Output
Yes
Input
zzz
zzz
Output
No
Submitted Solution:
```
s = sorted(list(input()))
t = sorted(list(input()), reverse=True)
print("Yes" if s < t else "No")
``` | instruction | 0 | 107,729 | 18 | 215,458 |
Yes | output | 1 | 107,729 | 18 | 215,459 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given strings s and t, consisting of lowercase English letters. You will create a string s' by freely rearranging the characters in s. You will also create a string t' by freely rearranging the characters in t. Determine whether it is possible to satisfy s' < t' for the lexicographic order.
Constraints
* The lengths of s and t are between 1 and 100 (inclusive).
* s and t consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
s
t
Output
If it is possible to satisfy s' < t', print `Yes`; if it is not, print `No`.
Examples
Input
yx
axy
Output
Yes
Input
ratcode
atlas
Output
Yes
Input
cd
abc
Output
No
Input
w
ww
Output
Yes
Input
zzz
zzz
Output
No
Submitted Solution:
```
input = [str(input()) for i in range(2)]
s_list = sorted(input[0])
t_list = sorted(input[1], reverse=True)
def main():
# tγε°γγγγ°no
for s, t in zip(s_list, t_list):
if s < t:
return 'Yes'
elif s > t:
return 'No'
if len(s) >= len(t):
return 'No'
else:
return 'Yes'
print(main())
``` | instruction | 0 | 107,730 | 18 | 215,460 |
No | output | 1 | 107,730 | 18 | 215,461 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given strings s and t, consisting of lowercase English letters. You will create a string s' by freely rearranging the characters in s. You will also create a string t' by freely rearranging the characters in t. Determine whether it is possible to satisfy s' < t' for the lexicographic order.
Constraints
* The lengths of s and t are between 1 and 100 (inclusive).
* s and t consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
s
t
Output
If it is possible to satisfy s' < t', print `Yes`; if it is not, print `No`.
Examples
Input
yx
axy
Output
Yes
Input
ratcode
atlas
Output
Yes
Input
cd
abc
Output
No
Input
w
ww
Output
Yes
Input
zzz
zzz
Output
No
Submitted Solution:
```
s = input()
t = input()
s = sorted(s)
t = sorted(t, reverse=True)
s_len = len(s)
t_len = len(t)
min_len = min(s_len, t_len)
for i in range(min_len):
if s[i] < t[i]:
print('Yes')
exit()
elif s[i] > t[i]:
print('No')
exit()
if s_len == t_len:
print('No')
else:
print('Yes')
``` | instruction | 0 | 107,731 | 18 | 215,462 |
No | output | 1 | 107,731 | 18 | 215,463 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given strings s and t, consisting of lowercase English letters. You will create a string s' by freely rearranging the characters in s. You will also create a string t' by freely rearranging the characters in t. Determine whether it is possible to satisfy s' < t' for the lexicographic order.
Constraints
* The lengths of s and t are between 1 and 100 (inclusive).
* s and t consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
s
t
Output
If it is possible to satisfy s' < t', print `Yes`; if it is not, print `No`.
Examples
Input
yx
axy
Output
Yes
Input
ratcode
atlas
Output
Yes
Input
cd
abc
Output
No
Input
w
ww
Output
Yes
Input
zzz
zzz
Output
No
Submitted Solution:
```
print("Yes") if sorted(input()) < sorted(input()) else print("No")
``` | instruction | 0 | 107,732 | 18 | 215,464 |
No | output | 1 | 107,732 | 18 | 215,465 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given strings s and t, consisting of lowercase English letters. You will create a string s' by freely rearranging the characters in s. You will also create a string t' by freely rearranging the characters in t. Determine whether it is possible to satisfy s' < t' for the lexicographic order.
Constraints
* The lengths of s and t are between 1 and 100 (inclusive).
* s and t consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
s
t
Output
If it is possible to satisfy s' < t', print `Yes`; if it is not, print `No`.
Examples
Input
yx
axy
Output
Yes
Input
ratcode
atlas
Output
Yes
Input
cd
abc
Output
No
Input
w
ww
Output
Yes
Input
zzz
zzz
Output
No
Submitted Solution:
```
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
def gcd(*numbers): reduce(math.gcd, numbers)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
count = 0
ans = 0
a = s()
t = s()
a.sort()
y = "".join(a)
t = sorted(t,reverse = True)
x = "".join(t)
if y < x:
print("Yes")
else:
print("No")
``` | instruction | 0 | 107,733 | 18 | 215,466 |
No | output | 1 | 107,733 | 18 | 215,467 |
Provide a correct Python 3 solution for this coding contest problem.
There is data of up to 100 characters per line, consisting of half-width alphabetic character strings. Some lines are symmetric (same whether read from the left edge or the right edge). Create a program that reads this data and outputs the number of symmetric strings in it. Note that lines consisting of only one character are symmetrical.
Input
Multiple strings are given over multiple lines. One string is given for each line. The number of strings does not exceed 50.
Output
Outputs the number of symmetric strings on one line.
Example
Input
abcba
sx
abcddcba
rttrd
Output
2 | instruction | 0 | 107,773 | 18 | 215,546 |
"Correct Solution:
```
import sys
readlines = sys.stdin.readlines
write = sys.stdout.write
def solve():
ans = 0
for line in readlines():
s = line.strip()
if s == s[::-1]:
ans += 1
write("%d\n" % ans)
solve()
``` | output | 1 | 107,773 | 18 | 215,547 |
Provide a correct Python 3 solution for this coding contest problem.
There is data of up to 100 characters per line, consisting of half-width alphabetic character strings. Some lines are symmetric (same whether read from the left edge or the right edge). Create a program that reads this data and outputs the number of symmetric strings in it. Note that lines consisting of only one character are symmetrical.
Input
Multiple strings are given over multiple lines. One string is given for each line. The number of strings does not exceed 50.
Output
Outputs the number of symmetric strings on one line.
Example
Input
abcba
sx
abcddcba
rttrd
Output
2 | instruction | 0 | 107,774 | 18 | 215,548 |
"Correct Solution:
```
cnt = 0
while True :
try :
n = list(input())
N = list(reversed(n))
if n == N :
cnt += 1
except :
print(cnt)
break
``` | output | 1 | 107,774 | 18 | 215,549 |
Provide a correct Python 3 solution for this coding contest problem.
There is data of up to 100 characters per line, consisting of half-width alphabetic character strings. Some lines are symmetric (same whether read from the left edge or the right edge). Create a program that reads this data and outputs the number of symmetric strings in it. Note that lines consisting of only one character are symmetrical.
Input
Multiple strings are given over multiple lines. One string is given for each line. The number of strings does not exceed 50.
Output
Outputs the number of symmetric strings on one line.
Example
Input
abcba
sx
abcddcba
rttrd
Output
2 | instruction | 0 | 107,775 | 18 | 215,550 |
"Correct Solution:
```
q=0
while True:
try:
x = input()
c = 0
if len(x)%2==0:
for i in range(len(x)//2):
if x[i] == x[len(x)-i-1]:
c += 1
else:
pass
if c == len(x)//2:
q += 1
else:
for j in range((len(x)-1)//2):
if x[j] == x[len(x)-j-1]:
c += 1
else:
pass
if c == (len(x)-1)//2:
q += 1
except EOFError:
break
print(q)
``` | output | 1 | 107,775 | 18 | 215,551 |
Provide a correct Python 3 solution for this coding contest problem.
There is data of up to 100 characters per line, consisting of half-width alphabetic character strings. Some lines are symmetric (same whether read from the left edge or the right edge). Create a program that reads this data and outputs the number of symmetric strings in it. Note that lines consisting of only one character are symmetrical.
Input
Multiple strings are given over multiple lines. One string is given for each line. The number of strings does not exceed 50.
Output
Outputs the number of symmetric strings on one line.
Example
Input
abcba
sx
abcddcba
rttrd
Output
2 | instruction | 0 | 107,777 | 18 | 215,554 |
"Correct Solution:
```
c = 0
while True:
try:
s = input()
t = s[::-1]
print
if s == t:
c += 1
except EOFError:
break
print(c)
``` | output | 1 | 107,777 | 18 | 215,555 |
Provide a correct Python 3 solution for this coding contest problem.
There is data of up to 100 characters per line, consisting of half-width alphabetic character strings. Some lines are symmetric (same whether read from the left edge or the right edge). Create a program that reads this data and outputs the number of symmetric strings in it. Note that lines consisting of only one character are symmetrical.
Input
Multiple strings are given over multiple lines. One string is given for each line. The number of strings does not exceed 50.
Output
Outputs the number of symmetric strings on one line.
Example
Input
abcba
sx
abcddcba
rttrd
Output
2 | instruction | 0 | 107,778 | 18 | 215,556 |
"Correct Solution:
```
import sys
f = sys.stdin
def is_symmetry(s):
return s == s[::-1]
print(sum(1 for line in f if is_symmetry(line.strip())))
``` | output | 1 | 107,778 | 18 | 215,557 |
Provide a correct Python 3 solution for this coding contest problem.
There is data of up to 100 characters per line, consisting of half-width alphabetic character strings. Some lines are symmetric (same whether read from the left edge or the right edge). Create a program that reads this data and outputs the number of symmetric strings in it. Note that lines consisting of only one character are symmetrical.
Input
Multiple strings are given over multiple lines. One string is given for each line. The number of strings does not exceed 50.
Output
Outputs the number of symmetric strings on one line.
Example
Input
abcba
sx
abcddcba
rttrd
Output
2 | instruction | 0 | 107,779 | 18 | 215,558 |
"Correct Solution:
```
ans=0
while True:
try :
n=input()
if n==n[::-1]:
ans+=1
except :
break
print(ans)
``` | output | 1 | 107,779 | 18 | 215,559 |
Provide a correct Python 3 solution for this coding contest problem.
There is data of up to 100 characters per line, consisting of half-width alphabetic character strings. Some lines are symmetric (same whether read from the left edge or the right edge). Create a program that reads this data and outputs the number of symmetric strings in it. Note that lines consisting of only one character are symmetrical.
Input
Multiple strings are given over multiple lines. One string is given for each line. The number of strings does not exceed 50.
Output
Outputs the number of symmetric strings on one line.
Example
Input
abcba
sx
abcddcba
rttrd
Output
2 | instruction | 0 | 107,780 | 18 | 215,560 |
"Correct Solution:
```
# coding: utf-8
# Your code here!
s=0
while True:
try:
x=input()
X=x[::-1]
if x==X:
s+=1
else:
pass
except EOFError:
break
print(s)
``` | output | 1 | 107,780 | 18 | 215,561 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is data of up to 100 characters per line, consisting of half-width alphabetic character strings. Some lines are symmetric (same whether read from the left edge or the right edge). Create a program that reads this data and outputs the number of symmetric strings in it. Note that lines consisting of only one character are symmetrical.
Input
Multiple strings are given over multiple lines. One string is given for each line. The number of strings does not exceed 50.
Output
Outputs the number of symmetric strings on one line.
Example
Input
abcba
sx
abcddcba
rttrd
Output
2
Submitted Solution:
```
ans=0
while True:
try:
b = input()
a = list(b)
c=len(a)
if c==0:
break
c=int(c/2)
e=0
for i in range(c):
d=i+1
if a[i]==a[-d]:
e+=1
else:
break
if e==c:
ans+=1
except:
break
print(ans)
``` | instruction | 0 | 107,781 | 18 | 215,562 |
Yes | output | 1 | 107,781 | 18 | 215,563 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is data of up to 100 characters per line, consisting of half-width alphabetic character strings. Some lines are symmetric (same whether read from the left edge or the right edge). Create a program that reads this data and outputs the number of symmetric strings in it. Note that lines consisting of only one character are symmetrical.
Input
Multiple strings are given over multiple lines. One string is given for each line. The number of strings does not exceed 50.
Output
Outputs the number of symmetric strings on one line.
Example
Input
abcba
sx
abcddcba
rttrd
Output
2
Submitted Solution:
```
s=0
while True:
try:
x=input()
X=x[::-1]
if x==X:
s+=1
else:
pass
except EOFError:
break
print(s)
``` | instruction | 0 | 107,782 | 18 | 215,564 |
Yes | output | 1 | 107,782 | 18 | 215,565 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is data of up to 100 characters per line, consisting of half-width alphabetic character strings. Some lines are symmetric (same whether read from the left edge or the right edge). Create a program that reads this data and outputs the number of symmetric strings in it. Note that lines consisting of only one character are symmetrical.
Input
Multiple strings are given over multiple lines. One string is given for each line. The number of strings does not exceed 50.
Output
Outputs the number of symmetric strings on one line.
Example
Input
abcba
sx
abcddcba
rttrd
Output
2
Submitted Solution:
```
import sys
print(sum([1 for i in sys.stdin if i.strip()==i.strip()[::-1]]))
``` | instruction | 0 | 107,783 | 18 | 215,566 |
Yes | output | 1 | 107,783 | 18 | 215,567 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is data of up to 100 characters per line, consisting of half-width alphabetic character strings. Some lines are symmetric (same whether read from the left edge or the right edge). Create a program that reads this data and outputs the number of symmetric strings in it. Note that lines consisting of only one character are symmetrical.
Input
Multiple strings are given over multiple lines. One string is given for each line. The number of strings does not exceed 50.
Output
Outputs the number of symmetric strings on one line.
Example
Input
abcba
sx
abcddcba
rttrd
Output
2
Submitted Solution:
```
count = 0
while True:
try:
text = list(input())
a = len(text)
b = a//2
_te = []
te_ = []
for i in range(0,b):
_te.append(text[i])
te_.append(text[a-1-i])
if _te==te_:
count += 1
except:
break
print(count)
``` | instruction | 0 | 107,784 | 18 | 215,568 |
Yes | output | 1 | 107,784 | 18 | 215,569 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is data of up to 100 characters per line, consisting of half-width alphabetic character strings. Some lines are symmetric (same whether read from the left edge or the right edge). Create a program that reads this data and outputs the number of symmetric strings in it. Note that lines consisting of only one character are symmetrical.
Input
Multiple strings are given over multiple lines. One string is given for each line. The number of strings does not exceed 50.
Output
Outputs the number of symmetric strings on one line.
Example
Input
abcba
sx
abcddcba
rttrd
Output
2
Submitted Solution:
```
res = 0
while True:
try:
cc = list(input())
except:
break
l = len(cc)
if l % 2 == 0:
if cc[:l // 2] == cc[:l // 2 - 1:-1]:
res += 1
else:
if cc[:(l + 1) // 2] == cc[:(l - 1) // 2 - 1:-1]:
res += 1
print(res)
``` | instruction | 0 | 107,785 | 18 | 215,570 |
No | output | 1 | 107,785 | 18 | 215,571 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is data of up to 100 characters per line, consisting of half-width alphabetic character strings. Some lines are symmetric (same whether read from the left edge or the right edge). Create a program that reads this data and outputs the number of symmetric strings in it. Note that lines consisting of only one character are symmetrical.
Input
Multiple strings are given over multiple lines. One string is given for each line. The number of strings does not exceed 50.
Output
Outputs the number of symmetric strings on one line.
Example
Input
abcba
sx
abcddcba
rttrd
Output
2
Submitted Solution:
```
res = 0
while True:
try:
cc = list(input())
if not len(cc):
break
except:
break
l = len(cc)
if l % 2 == 0:
if cc[:l // 2] == cc[:l // 2 - 1:-1]:
res += 1
else:
if cc[:(l + 1) // 2] == cc[:(l - 1) // 2 - 1:-1]:
res += 1
print(res)
``` | instruction | 0 | 107,786 | 18 | 215,572 |
No | output | 1 | 107,786 | 18 | 215,573 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is data of up to 100 characters per line, consisting of half-width alphabetic character strings. Some lines are symmetric (same whether read from the left edge or the right edge). Create a program that reads this data and outputs the number of symmetric strings in it. Note that lines consisting of only one character are symmetrical.
Input
Multiple strings are given over multiple lines. One string is given for each line. The number of strings does not exceed 50.
Output
Outputs the number of symmetric strings on one line.
Example
Input
abcba
sx
abcddcba
rttrd
Output
2
Submitted Solution:
```
import sys
print(e[:-1]==e[-2::-1]for e in sys.stdin)
``` | instruction | 0 | 107,787 | 18 | 215,574 |
No | output | 1 | 107,787 | 18 | 215,575 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's analyze a program written on some strange programming language. The variables in this language have names consisting of 1 to 4 characters, and each character is a lowercase or an uppercase Latin letter, or a digit. There is an extra constraint that the first character should not be a digit.
There are four types of operations in the program, each denoted by one of the characters: $, ^, # or &.
Each line of the program has one of the following formats:
* <lvalue>=<rvalue>, where <lvalue> and <rvalue> are valid variable names;
* <lvalue>=<arg1><op><arg2>, where <lvalue>, <arg1> and <arg2> are valid variable names, and <op> is an operation character.
The program is executed line-by-line, and the result of execution is stored in a variable having the name res. If res is never assigned in the program, then the result will be equal to the value of res before running the program.
Two programs are called equivalent if no matter which operations do characters $, ^, # and & denote (but, obviously, performing the same operation on the same arguments gives the same result) and which values do variables have before execution of program, the value of res after running the first program is equal to the value of res after running the second program (the programs are executed independently).
You are given a program consisting of n lines. Your task is to write a program consisting of minimum possible number of lines that is equivalent to the program you are given.
Input
The first line contains one integer n (1 β€ n β€ 1000) β the number of lines in the program.
Then n lines follow β the program itself. Each line corresponds to the format described in the statement and has no extra whitespaces.
Output
In the first line print k β the minimum number of lines in the equivalent program.
Then print k lines without any whitespaces β an equivalent program having exactly k lines, in the same format it is described in the statement.
Examples
Input
4
c=aa#bb
d12=c
res=c^d12
tmp=aa$c
Output
2
aaaa=aa#bb
res=aaaa^aaaa
Input
2
max=aaaa$bbbb
min=bbbb^aaaa
Output
0
Submitted Solution:
```
import string
import random
def simplify_params(value):
value = value
the_sign = ''
lv = ''
rest = ''
for i in range(len(value)):
charr = value[i]
# print('character i = {} , a charr = {}'.format(i, charr))
if charr == '^' or charr =='#' or charr =='$' or charr=='&':
the_sign = charr
lv = value[:i]
rest = value[i+1:]
# print("KAO TUJ TREBA DA ISKOCI ? ")
break
if not lv:
lv = value
# print('lv = {}, the_sign = {}, rest = {}'.format(lv, the_sign, rest))
return lv, the_sign, rest
def req(value, lista):
lista.append(value)
# print("VALUE -> {} ".format(value))
if not value:
return ''
if value in main_dict.keys():
# print("return main_dict[value] = {}".format(main_dict[value]))
req(main_dict[value], lista)
lv, first_sign, rest = simplify_params(value)
if lv in main_dict.keys():
# print('return {} + {} + req({})'.format(lv, first_sign, rest))
return req(main_dict[lv] + first_sign, lista) + req(rest, lista)
else:
# print('return {} + {} + req({})'.format(lv, first_sign, rest))
return (lv + first_sign) + req(rest, lista)
main_dict = {}
n = input()
for i in range(int(n)):
text_line = input()
lv, rv = text_line.split('=')
# temp_val = main_dict.get(lv, [])
# temp_val.append(rv)
# main_dict[lv] = temp_val
main_dict[lv] = rv
if not 'res' in main_dict.keys():
# print('0')
pass
res = main_dict.get('res')
# print("main_dict -> {}".format(main_dict))
# print("RES -> {}".format(res))
# print('pred REQ')
listata = []
stringat = req(res, listata)
# print( "STRINGAT -> {} ".format(stringat))
# print('listata -> ')
# print(listata)
# print('2')
# print('bbb=aa#bb')
# print('res=bbb^bbb')
print_lista = []
for item in listata:
if not item:
continue
charr = item[len(item)-1]
# print('charr -> {}'.format(charr))
if charr == '^' or charr =='#' or charr =='$' or charr=='&':
item = item[:-1]
if item in stringat:
rand_name = ''.join(random.choice(string.ascii_uppercase) for _ in range(4))
print_lista.append(str(rand_name) + '=' + str(item))
stringat = stringat.replace(str(item), str(rand_name))
# print('stringat = {}'.format(stringat))
print_lista.append('res=' +str(stringat))
# print("PRINT LISTAAA -> ")
# print(print_lista)
[print(item) for item in print_lista]
``` | instruction | 0 | 107,894 | 18 | 215,788 |
No | output | 1 | 107,894 | 18 | 215,789 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's analyze a program written on some strange programming language. The variables in this language have names consisting of 1 to 4 characters, and each character is a lowercase or an uppercase Latin letter, or a digit. There is an extra constraint that the first character should not be a digit.
There are four types of operations in the program, each denoted by one of the characters: $, ^, # or &.
Each line of the program has one of the following formats:
* <lvalue>=<rvalue>, where <lvalue> and <rvalue> are valid variable names;
* <lvalue>=<arg1><op><arg2>, where <lvalue>, <arg1> and <arg2> are valid variable names, and <op> is an operation character.
The program is executed line-by-line, and the result of execution is stored in a variable having the name res. If res is never assigned in the program, then the result will be equal to the value of res before running the program.
Two programs are called equivalent if no matter which operations do characters $, ^, # and & denote (but, obviously, performing the same operation on the same arguments gives the same result) and which values do variables have before execution of program, the value of res after running the first program is equal to the value of res after running the second program (the programs are executed independently).
You are given a program consisting of n lines. Your task is to write a program consisting of minimum possible number of lines that is equivalent to the program you are given.
Input
The first line contains one integer n (1 β€ n β€ 1000) β the number of lines in the program.
Then n lines follow β the program itself. Each line corresponds to the format described in the statement and has no extra whitespaces.
Output
In the first line print k β the minimum number of lines in the equivalent program.
Then print k lines without any whitespaces β an equivalent program having exactly k lines, in the same format it is described in the statement.
Examples
Input
4
c=aa#bb
d12=c
res=c^d12
tmp=aa$c
Output
2
aaaa=aa#bb
res=aaaa^aaaa
Input
2
max=aaaa$bbbb
min=bbbb^aaaa
Output
0
Submitted Solution:
```
# print('mau -> ? ')
def simplify_params(value):
value = value
the_sign = ''
lv = ''
rest = ''
for i in range(len(value)):
charr = value[i]
# print('character i = {} , a charr = {}'.format(i, charr))
if charr == '^' or charr =='#' or charr =='$' or charr=='&':
the_sign = charr
lv = value[:i]
rest = value[i+1:]
# print("KAO TUJ TREBA DA ISKOCI ? ")
break
if not lv:
lv = value
# print('lv = {}, the_sign = {}, rest = {}'.format(lv, the_sign, rest))
return lv, the_sign, rest
def req(value):
# print("VALUE -> {} ".format(value))
if not value:
return ''
if value in main_dict.keys():
# print("return main_dict[value] = {}".format(main_dict[value]))
req(main_dict[value])
lv, first_sign, rest = simplify_params(value)
if lv in main_dict.keys():
# print('return {} + {} + req({})'.format(lv, first_sign, rest))
return req(main_dict[lv] + first_sign) + req(rest)
else:
# print('return {} + {} + req({})'.format(lv, first_sign, rest))
return (lv + first_sign) + req(rest)
main_dict = {}
n = input()
for i in range(int(n)):
text_line = input()
lv, rv = text_line.split('=')
# temp_val = main_dict.get(lv, [])
# temp_val.append(rv)
# main_dict[lv] = temp_val
main_dict[lv] = rv
if not 'res' in main_dict.keys():
print('0')
res = main_dict.get('res')
# print("main_dict -> {}".format(main_dict))
# print("RES -> {}".format(res))
# print('pred REQ')
stringat = req(res)
# print( "STRINGAT -> {} ".format(stringat))
print('2')
print('aaaa=aa#bb')
print('res=aaaa^aaaa')
``` | instruction | 0 | 107,895 | 18 | 215,790 |
No | output | 1 | 107,895 | 18 | 215,791 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's analyze a program written on some strange programming language. The variables in this language have names consisting of 1 to 4 characters, and each character is a lowercase or an uppercase Latin letter, or a digit. There is an extra constraint that the first character should not be a digit.
There are four types of operations in the program, each denoted by one of the characters: $, ^, # or &.
Each line of the program has one of the following formats:
* <lvalue>=<rvalue>, where <lvalue> and <rvalue> are valid variable names;
* <lvalue>=<arg1><op><arg2>, where <lvalue>, <arg1> and <arg2> are valid variable names, and <op> is an operation character.
The program is executed line-by-line, and the result of execution is stored in a variable having the name res. If res is never assigned in the program, then the result will be equal to the value of res before running the program.
Two programs are called equivalent if no matter which operations do characters $, ^, # and & denote (but, obviously, performing the same operation on the same arguments gives the same result) and which values do variables have before execution of program, the value of res after running the first program is equal to the value of res after running the second program (the programs are executed independently).
You are given a program consisting of n lines. Your task is to write a program consisting of minimum possible number of lines that is equivalent to the program you are given.
Input
The first line contains one integer n (1 β€ n β€ 1000) β the number of lines in the program.
Then n lines follow β the program itself. Each line corresponds to the format described in the statement and has no extra whitespaces.
Output
In the first line print k β the minimum number of lines in the equivalent program.
Then print k lines without any whitespaces β an equivalent program having exactly k lines, in the same format it is described in the statement.
Examples
Input
4
c=aa#bb
d12=c
res=c^d12
tmp=aa$c
Output
2
aaaa=aa#bb
res=aaaa^aaaa
Input
2
max=aaaa$bbbb
min=bbbb^aaaa
Output
0
Submitted Solution:
```
import string
import random
def simplify_params(value):
value = value
the_sign = ''
lv = ''
rest = ''
for i in range(len(value)):
charr = value[i]
# print('character i = {} , a charr = {}'.format(i, charr))
if charr == '^' or charr =='#' or charr =='$' or charr=='&':
the_sign = charr
lv = value[:i]
rest = value[i+1:]
# print("KAO TUJ TREBA DA ISKOCI ? ")
break
if not lv:
lv = value
# print('lv = {}, the_sign = {}, rest = {}'.format(lv, the_sign, rest))
return lv, the_sign, rest
def req(value, lista):
lista.append(value)
# print("VALUE -> {} ".format(value))
if not value:
return ''
if value in main_dict.keys():
# print("return main_dict[value] = {}".format(main_dict[value]))
req(main_dict[value], lista)
lv, first_sign, rest = simplify_params(value)
if lv in main_dict.keys():
# print('return {} + {} + req({})'.format(lv, first_sign, rest))
return req(main_dict[lv] + first_sign, lista) + req(rest, lista)
else:
# print('return {} + {} + req({})'.format(lv, first_sign, rest))
return (lv + first_sign) + req(rest, lista)
main_dict = {}
n = input()
for i in range(int(n)):
text_line = input()
lv, rv = text_line.split('=')
# temp_val = main_dict.get(lv, [])
# temp_val.append(rv)
# main_dict[lv] = temp_val
main_dict[lv] = rv
if not 'res' in main_dict.keys():
# print('0')
pass
res = main_dict.get('res')
# print("main_dict -> {}".format(main_dict))
# print("RES -> {}".format(res))
# print('pred REQ')
listata = []
stringat = req(res, listata)
# print( "STRINGAT -> {} ".format(stringat))
# print('listata -> ')
# print(listata)
# print('2')
# print('bbb=aa#bb')
# print('res=bbb^bbb')
print_lista = []
for item in listata:
if not item:
continue
charr = item[len(item)-1]
# print('charr -> {}'.format(charr))
if charr == '^' or charr =='#' or charr =='$' or charr=='&':
item = item[:-1]
if item in stringat:
rand_name = ''.join(random.choice(string.ascii_uppercase) for _ in range(4))
print_lista.append(str(rand_name) + '=' + str(item))
stringat = stringat.replace(str(item), str(rand_name))
# print('stringat = {}'.format(stringat))
print_lista.append('res=' +str(stringat))
# print("PRINT LISTAAA -> ")
# print(print_lista)
print(len(print_lista))
[print(item) for item in print_lista]
``` | instruction | 0 | 107,896 | 18 | 215,792 |
No | output | 1 | 107,896 | 18 | 215,793 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's analyze a program written on some strange programming language. The variables in this language have names consisting of 1 to 4 characters, and each character is a lowercase or an uppercase Latin letter, or a digit. There is an extra constraint that the first character should not be a digit.
There are four types of operations in the program, each denoted by one of the characters: $, ^, # or &.
Each line of the program has one of the following formats:
* <lvalue>=<rvalue>, where <lvalue> and <rvalue> are valid variable names;
* <lvalue>=<arg1><op><arg2>, where <lvalue>, <arg1> and <arg2> are valid variable names, and <op> is an operation character.
The program is executed line-by-line, and the result of execution is stored in a variable having the name res. If res is never assigned in the program, then the result will be equal to the value of res before running the program.
Two programs are called equivalent if no matter which operations do characters $, ^, # and & denote (but, obviously, performing the same operation on the same arguments gives the same result) and which values do variables have before execution of program, the value of res after running the first program is equal to the value of res after running the second program (the programs are executed independently).
You are given a program consisting of n lines. Your task is to write a program consisting of minimum possible number of lines that is equivalent to the program you are given.
Input
The first line contains one integer n (1 β€ n β€ 1000) β the number of lines in the program.
Then n lines follow β the program itself. Each line corresponds to the format described in the statement and has no extra whitespaces.
Output
In the first line print k β the minimum number of lines in the equivalent program.
Then print k lines without any whitespaces β an equivalent program having exactly k lines, in the same format it is described in the statement.
Examples
Input
4
c=aa#bb
d12=c
res=c^d12
tmp=aa$c
Output
2
aaaa=aa#bb
res=aaaa^aaaa
Input
2
max=aaaa$bbbb
min=bbbb^aaaa
Output
0
Submitted Solution:
```
# print('mau -> ? ')
def simplify_params(value):
value = value
the_sign = ''
lv = ''
rest = ''
for i in range(len(value)):
charr = value[i]
# print('character i = {} , a charr = {}'.format(i, charr))
if charr == '^' or charr =='#' or charr =='$' or charr=='&':
the_sign = charr
lv = value[:i]
rest = value[i+1:]
# print("KAO TUJ TREBA DA ISKOCI ? ")
break
if not lv:
lv = value
# print('lv = {}, the_sign = {}, rest = {}'.format(lv, the_sign, rest))
return lv, the_sign, rest
def req(value):
# print("VALUE -> {} ".format(value))
if not value:
return ''
if value in main_dict.keys():
# print("return main_dict[value] = {}".format(main_dict[value]))
req(main_dict[value])
lv, first_sign, rest = simplify_params(value)
if lv in main_dict.keys():
# print('return {} + {} + req({})'.format(lv, first_sign, rest))
return req(main_dict[lv] + first_sign) + req(rest)
else:
# print('return {} + {} + req({})'.format(lv, first_sign, rest))
return (lv + first_sign) + req(rest)
main_dict = {}
n = input()
for i in range(int(n)):
text_line = input()
lv, rv = text_line.split('=')
# temp_val = main_dict.get(lv, [])
# temp_val.append(rv)
# main_dict[lv] = temp_val
main_dict[lv] = rv
if not 'res' in main_dict.keys():
# print('0')
pass
res = main_dict.get('res')
# print("main_dict -> {}".format(main_dict))
# print("RES -> {}".format(res))
# print('pred REQ')
stringat = req(res)
# print( "STRINGAT -> {} ".format(stringat))
print('2')
print('bbb=aa#bb')
print('res=bbb^bbb')
``` | instruction | 0 | 107,897 | 18 | 215,794 |
No | output | 1 | 107,897 | 18 | 215,795 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's hard times now. Today Petya needs to score 100 points on Informatics exam. The tasks seem easy to Petya, but he thinks he lacks time to finish them all, so he asks you to help with one..
There is a glob pattern in the statements (a string consisting of lowercase English letters, characters "?" and "*"). It is known that character "*" occurs no more than once in the pattern.
Also, n query strings are given, it is required to determine for each of them if the pattern matches it or not.
Everything seemed easy to Petya, but then he discovered that the special pattern characters differ from their usual meaning.
A pattern matches a string if it is possible to replace each character "?" with one good lowercase English letter, and the character "*" (if there is one) with any, including empty, string of bad lowercase English letters, so that the resulting string is the same as the given string.
The good letters are given to Petya. All the others are bad.
Input
The first line contains a string with length from 1 to 26 consisting of distinct lowercase English letters. These letters are good letters, all the others are bad.
The second line contains the pattern β a string s of lowercase English letters, characters "?" and "*" (1 β€ |s| β€ 105). It is guaranteed that character "*" occurs in s no more than once.
The third line contains integer n (1 β€ n β€ 105) β the number of query strings.
n lines follow, each of them contains single non-empty string consisting of lowercase English letters β a query string.
It is guaranteed that the total length of all query strings is not greater than 105.
Output
Print n lines: in the i-th of them print "YES" if the pattern matches the i-th query string, and "NO" otherwise.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
ab
a?a
2
aaa
aab
Output
YES
NO
Input
abc
a?a?a*
4
abacaba
abaca
apapa
aaaaax
Output
NO
YES
NO
YES
Note
In the first example we can replace "?" with good letters "a" and "b", so we can see that the answer for the first query is "YES", and the answer for the second query is "NO", because we can't match the third letter.
Explanation of the second example.
* The first query: "NO", because character "*" can be replaced with a string of bad letters only, but the only way to match the query string is to replace it with the string "ba", in which both letters are good.
* The second query: "YES", because characters "?" can be replaced with corresponding good letters, and character "*" can be replaced with empty string, and the strings will coincide.
* The third query: "NO", because characters "?" can't be replaced with bad letters.
* The fourth query: "YES", because characters "?" can be replaced with good letters "a", and character "*" can be replaced with a string of bad letters "x". | instruction | 0 | 108,330 | 18 | 216,660 |
Tags: implementation, strings
Correct Solution:
```
l = input()
s = input()
n = int(input())
a = []
for _ in range(n):
c = input()
nl = s
if '*' in nl:
if len(nl) <= len(c):
nl = nl.replace('*', '*'*(abs(len(nl)-len(c))+1))
elif len(nl)==len(c)+1:
nl = nl.replace('*', '')
if len(c)!=len(nl):
a.append("NO")
else:
for i in range(len(c)):
if nl[i] == '*':
if c[i] in l:
a.append("NO")
break
elif nl[i] == '?':
if c[i] not in l:
a.append("NO")
break
else:
if nl[i] != c[i]:
a.append("NO")
break
else:
a.append("YES")
for i in a:
print(i)
``` | output | 1 | 108,330 | 18 | 216,661 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's hard times now. Today Petya needs to score 100 points on Informatics exam. The tasks seem easy to Petya, but he thinks he lacks time to finish them all, so he asks you to help with one..
There is a glob pattern in the statements (a string consisting of lowercase English letters, characters "?" and "*"). It is known that character "*" occurs no more than once in the pattern.
Also, n query strings are given, it is required to determine for each of them if the pattern matches it or not.
Everything seemed easy to Petya, but then he discovered that the special pattern characters differ from their usual meaning.
A pattern matches a string if it is possible to replace each character "?" with one good lowercase English letter, and the character "*" (if there is one) with any, including empty, string of bad lowercase English letters, so that the resulting string is the same as the given string.
The good letters are given to Petya. All the others are bad.
Input
The first line contains a string with length from 1 to 26 consisting of distinct lowercase English letters. These letters are good letters, all the others are bad.
The second line contains the pattern β a string s of lowercase English letters, characters "?" and "*" (1 β€ |s| β€ 105). It is guaranteed that character "*" occurs in s no more than once.
The third line contains integer n (1 β€ n β€ 105) β the number of query strings.
n lines follow, each of them contains single non-empty string consisting of lowercase English letters β a query string.
It is guaranteed that the total length of all query strings is not greater than 105.
Output
Print n lines: in the i-th of them print "YES" if the pattern matches the i-th query string, and "NO" otherwise.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
ab
a?a
2
aaa
aab
Output
YES
NO
Input
abc
a?a?a*
4
abacaba
abaca
apapa
aaaaax
Output
NO
YES
NO
YES
Note
In the first example we can replace "?" with good letters "a" and "b", so we can see that the answer for the first query is "YES", and the answer for the second query is "NO", because we can't match the third letter.
Explanation of the second example.
* The first query: "NO", because character "*" can be replaced with a string of bad letters only, but the only way to match the query string is to replace it with the string "ba", in which both letters are good.
* The second query: "YES", because characters "?" can be replaced with corresponding good letters, and character "*" can be replaced with empty string, and the strings will coincide.
* The third query: "NO", because characters "?" can't be replaced with bad letters.
* The fourth query: "YES", because characters "?" can be replaced with good letters "a", and character "*" can be replaced with a string of bad letters "x". | instruction | 0 | 108,331 | 18 | 216,662 |
Tags: implementation, strings
Correct Solution:
```
a=input()
s=input()
k=int(input())
def qw(c):
t=True
w=-1
if len(s)>len(c)+1: t=False
try:
for j in range(len(s)):
w+=1
if s[j]=='?':
if c[w] not in a: t=False
elif s[j]=='*':
b=len(c)-len(s)+1
for e in c[j:j+b]:
if e in a:
t=False
w+=b-1
else:
if s[j]!=c[w]: t=False
if t==False: break
except IndexError:
return False
return t if len(c)==w+1 else False
for i in range(k):
c=input()
print('YES') if qw(c) else print('NO')
``` | output | 1 | 108,331 | 18 | 216,663 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's hard times now. Today Petya needs to score 100 points on Informatics exam. The tasks seem easy to Petya, but he thinks he lacks time to finish them all, so he asks you to help with one..
There is a glob pattern in the statements (a string consisting of lowercase English letters, characters "?" and "*"). It is known that character "*" occurs no more than once in the pattern.
Also, n query strings are given, it is required to determine for each of them if the pattern matches it or not.
Everything seemed easy to Petya, but then he discovered that the special pattern characters differ from their usual meaning.
A pattern matches a string if it is possible to replace each character "?" with one good lowercase English letter, and the character "*" (if there is one) with any, including empty, string of bad lowercase English letters, so that the resulting string is the same as the given string.
The good letters are given to Petya. All the others are bad.
Input
The first line contains a string with length from 1 to 26 consisting of distinct lowercase English letters. These letters are good letters, all the others are bad.
The second line contains the pattern β a string s of lowercase English letters, characters "?" and "*" (1 β€ |s| β€ 105). It is guaranteed that character "*" occurs in s no more than once.
The third line contains integer n (1 β€ n β€ 105) β the number of query strings.
n lines follow, each of them contains single non-empty string consisting of lowercase English letters β a query string.
It is guaranteed that the total length of all query strings is not greater than 105.
Output
Print n lines: in the i-th of them print "YES" if the pattern matches the i-th query string, and "NO" otherwise.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
ab
a?a
2
aaa
aab
Output
YES
NO
Input
abc
a?a?a*
4
abacaba
abaca
apapa
aaaaax
Output
NO
YES
NO
YES
Note
In the first example we can replace "?" with good letters "a" and "b", so we can see that the answer for the first query is "YES", and the answer for the second query is "NO", because we can't match the third letter.
Explanation of the second example.
* The first query: "NO", because character "*" can be replaced with a string of bad letters only, but the only way to match the query string is to replace it with the string "ba", in which both letters are good.
* The second query: "YES", because characters "?" can be replaced with corresponding good letters, and character "*" can be replaced with empty string, and the strings will coincide.
* The third query: "NO", because characters "?" can't be replaced with bad letters.
* The fourth query: "YES", because characters "?" can be replaced with good letters "a", and character "*" can be replaced with a string of bad letters "x". | instruction | 0 | 108,332 | 18 | 216,664 |
Tags: implementation, strings
Correct Solution:
```
a=input()
s=input()
k=int(input())
def qw(c):
t=True
w=-1
if len(s)>len(c)+1: t=False
try:
for j in range(len(s)):
w+=1
if s[j]=='?':
if c[w] not in a: t=False
elif s[j]=='*':
b=len(c)-len(s)+1
for e in c[j:j+b]:
if e in a:
t=False
w+=b-1
else:
if s[j]!=c[w]: t=False
if t==False: break
except IndexError:
return False
return t if len(c)==w+1 else False
for i in range(k):
c=input()
print('YES') if qw(c) else print('NO')
# Made By Mostafa_Khaled
``` | output | 1 | 108,332 | 18 | 216,665 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's hard times now. Today Petya needs to score 100 points on Informatics exam. The tasks seem easy to Petya, but he thinks he lacks time to finish them all, so he asks you to help with one..
There is a glob pattern in the statements (a string consisting of lowercase English letters, characters "?" and "*"). It is known that character "*" occurs no more than once in the pattern.
Also, n query strings are given, it is required to determine for each of them if the pattern matches it or not.
Everything seemed easy to Petya, but then he discovered that the special pattern characters differ from their usual meaning.
A pattern matches a string if it is possible to replace each character "?" with one good lowercase English letter, and the character "*" (if there is one) with any, including empty, string of bad lowercase English letters, so that the resulting string is the same as the given string.
The good letters are given to Petya. All the others are bad.
Input
The first line contains a string with length from 1 to 26 consisting of distinct lowercase English letters. These letters are good letters, all the others are bad.
The second line contains the pattern β a string s of lowercase English letters, characters "?" and "*" (1 β€ |s| β€ 105). It is guaranteed that character "*" occurs in s no more than once.
The third line contains integer n (1 β€ n β€ 105) β the number of query strings.
n lines follow, each of them contains single non-empty string consisting of lowercase English letters β a query string.
It is guaranteed that the total length of all query strings is not greater than 105.
Output
Print n lines: in the i-th of them print "YES" if the pattern matches the i-th query string, and "NO" otherwise.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
ab
a?a
2
aaa
aab
Output
YES
NO
Input
abc
a?a?a*
4
abacaba
abaca
apapa
aaaaax
Output
NO
YES
NO
YES
Note
In the first example we can replace "?" with good letters "a" and "b", so we can see that the answer for the first query is "YES", and the answer for the second query is "NO", because we can't match the third letter.
Explanation of the second example.
* The first query: "NO", because character "*" can be replaced with a string of bad letters only, but the only way to match the query string is to replace it with the string "ba", in which both letters are good.
* The second query: "YES", because characters "?" can be replaced with corresponding good letters, and character "*" can be replaced with empty string, and the strings will coincide.
* The third query: "NO", because characters "?" can't be replaced with bad letters.
* The fourth query: "YES", because characters "?" can be replaced with good letters "a", and character "*" can be replaced with a string of bad letters "x". | instruction | 0 | 108,333 | 18 | 216,666 |
Tags: implementation, strings
Correct Solution:
```
p=q=[]
g=input()
a=input()
for _ in range(int(input())):
ans=1
x=input()
if len(x)<len(a)-1 or ('*' not in a and len(x)!=len(a)):
ans=0
if ans:
i=0
while i<min(len(a), len(x)) and a[i]!='*':
if a[i]=='?':
if x[i] not in g:
ans=0
break
else:
if a[i]!=x[i]:
ans=0
break
i+=1
j=i
if ans and i<len(a):
i=len(a)-1
z=len(x)-1
while a[i]!='*':
if a[i]=='?':
if x[z] not in g:
ans=0
break
else:
if a[i]!=x[z]:
ans=0
break
i-=1
z-=1
k=z+1
if ans:
for i in range(j, k):
if x[i] in g:
ans=0
break
print(['NO', 'YES'][ans])
``` | output | 1 | 108,333 | 18 | 216,667 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's hard times now. Today Petya needs to score 100 points on Informatics exam. The tasks seem easy to Petya, but he thinks he lacks time to finish them all, so he asks you to help with one..
There is a glob pattern in the statements (a string consisting of lowercase English letters, characters "?" and "*"). It is known that character "*" occurs no more than once in the pattern.
Also, n query strings are given, it is required to determine for each of them if the pattern matches it or not.
Everything seemed easy to Petya, but then he discovered that the special pattern characters differ from their usual meaning.
A pattern matches a string if it is possible to replace each character "?" with one good lowercase English letter, and the character "*" (if there is one) with any, including empty, string of bad lowercase English letters, so that the resulting string is the same as the given string.
The good letters are given to Petya. All the others are bad.
Input
The first line contains a string with length from 1 to 26 consisting of distinct lowercase English letters. These letters are good letters, all the others are bad.
The second line contains the pattern β a string s of lowercase English letters, characters "?" and "*" (1 β€ |s| β€ 105). It is guaranteed that character "*" occurs in s no more than once.
The third line contains integer n (1 β€ n β€ 105) β the number of query strings.
n lines follow, each of them contains single non-empty string consisting of lowercase English letters β a query string.
It is guaranteed that the total length of all query strings is not greater than 105.
Output
Print n lines: in the i-th of them print "YES" if the pattern matches the i-th query string, and "NO" otherwise.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
ab
a?a
2
aaa
aab
Output
YES
NO
Input
abc
a?a?a*
4
abacaba
abaca
apapa
aaaaax
Output
NO
YES
NO
YES
Note
In the first example we can replace "?" with good letters "a" and "b", so we can see that the answer for the first query is "YES", and the answer for the second query is "NO", because we can't match the third letter.
Explanation of the second example.
* The first query: "NO", because character "*" can be replaced with a string of bad letters only, but the only way to match the query string is to replace it with the string "ba", in which both letters are good.
* The second query: "YES", because characters "?" can be replaced with corresponding good letters, and character "*" can be replaced with empty string, and the strings will coincide.
* The third query: "NO", because characters "?" can't be replaced with bad letters.
* The fourth query: "YES", because characters "?" can be replaced with good letters "a", and character "*" can be replaced with a string of bad letters "x". | instruction | 0 | 108,334 | 18 | 216,668 |
Tags: implementation, strings
Correct Solution:
```
import pdb
good_letters = set(input())
pattern = input()
n = int(input())
def ismatch(pattern, query):
if len(pattern) != len(query):
return False
zipped = zip(pattern, query)
for (a, b) in zipped:
if a.isalpha():
if b != a:
return False
elif a == '?':
if b not in good_letters:
return False
return True
if pattern.find('*') == -1:
for i in range(n):
if ismatch(pattern, input()):
print("YES")
else:
print("NO")
else:
(p1, sep, p2) = pattern.partition('*')
#pdb.set_trace()
for i in range(n):
query = input()
if len(query) < len(pattern) - 1:
print("NO")
else:
s1 = query[:len(p1)]
if len(p2) > 0:
s2 = query[-len(p2):]
mid = set(query[len(p1):-len(p2)])
else:
s2 = ""
mid = set(query[len(p1):])
if ismatch(p1, s1) and ismatch(p2, s2) and mid.isdisjoint(good_letters):
print("YES")
else:
print("NO")
``` | output | 1 | 108,334 | 18 | 216,669 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's hard times now. Today Petya needs to score 100 points on Informatics exam. The tasks seem easy to Petya, but he thinks he lacks time to finish them all, so he asks you to help with one..
There is a glob pattern in the statements (a string consisting of lowercase English letters, characters "?" and "*"). It is known that character "*" occurs no more than once in the pattern.
Also, n query strings are given, it is required to determine for each of them if the pattern matches it or not.
Everything seemed easy to Petya, but then he discovered that the special pattern characters differ from their usual meaning.
A pattern matches a string if it is possible to replace each character "?" with one good lowercase English letter, and the character "*" (if there is one) with any, including empty, string of bad lowercase English letters, so that the resulting string is the same as the given string.
The good letters are given to Petya. All the others are bad.
Input
The first line contains a string with length from 1 to 26 consisting of distinct lowercase English letters. These letters are good letters, all the others are bad.
The second line contains the pattern β a string s of lowercase English letters, characters "?" and "*" (1 β€ |s| β€ 105). It is guaranteed that character "*" occurs in s no more than once.
The third line contains integer n (1 β€ n β€ 105) β the number of query strings.
n lines follow, each of them contains single non-empty string consisting of lowercase English letters β a query string.
It is guaranteed that the total length of all query strings is not greater than 105.
Output
Print n lines: in the i-th of them print "YES" if the pattern matches the i-th query string, and "NO" otherwise.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
ab
a?a
2
aaa
aab
Output
YES
NO
Input
abc
a?a?a*
4
abacaba
abaca
apapa
aaaaax
Output
NO
YES
NO
YES
Note
In the first example we can replace "?" with good letters "a" and "b", so we can see that the answer for the first query is "YES", and the answer for the second query is "NO", because we can't match the third letter.
Explanation of the second example.
* The first query: "NO", because character "*" can be replaced with a string of bad letters only, but the only way to match the query string is to replace it with the string "ba", in which both letters are good.
* The second query: "YES", because characters "?" can be replaced with corresponding good letters, and character "*" can be replaced with empty string, and the strings will coincide.
* The third query: "NO", because characters "?" can't be replaced with bad letters.
* The fourth query: "YES", because characters "?" can be replaced with good letters "a", and character "*" can be replaced with a string of bad letters "x". | instruction | 0 | 108,335 | 18 | 216,670 |
Tags: implementation, strings
Correct Solution:
```
good = set(input().strip())
pattern = input().strip()
n = int(input())
minlen = len(pattern)
is_star = '*' in pattern
if is_star:
minlen -= 1
maxlen = 1000000000
leftlen = pattern.find('*')
rightlen = len(pattern) - leftlen - 1
else:
maxlen = minlen
def check_simple_pattern(task, pattern):
#print(task +" -> " + pattern)
for i in range(len(task)):
if pattern[i] != task[i] and not (pattern[i] == '?' and task[i] in good):
return False
return True
def check(task):
if len(task) < minlen or len(task) > maxlen:
return False
if is_star:
if rightlen == 0:
cond = all([i not in good for i in task[leftlen:]])
else:
cond = all([i not in good for i in task[leftlen:-rightlen]])
return check_simple_pattern(task[:leftlen], pattern[:leftlen]) \
and (rightlen == 0 or check_simple_pattern(task[-rightlen:], pattern[-rightlen:])) \
and cond
else:
return check_simple_pattern(task, pattern)
for i in range(n):
task = input().strip()
if check(task):
print("YES")
else:
print("NO")
``` | output | 1 | 108,335 | 18 | 216,671 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's hard times now. Today Petya needs to score 100 points on Informatics exam. The tasks seem easy to Petya, but he thinks he lacks time to finish them all, so he asks you to help with one..
There is a glob pattern in the statements (a string consisting of lowercase English letters, characters "?" and "*"). It is known that character "*" occurs no more than once in the pattern.
Also, n query strings are given, it is required to determine for each of them if the pattern matches it or not.
Everything seemed easy to Petya, but then he discovered that the special pattern characters differ from their usual meaning.
A pattern matches a string if it is possible to replace each character "?" with one good lowercase English letter, and the character "*" (if there is one) with any, including empty, string of bad lowercase English letters, so that the resulting string is the same as the given string.
The good letters are given to Petya. All the others are bad.
Input
The first line contains a string with length from 1 to 26 consisting of distinct lowercase English letters. These letters are good letters, all the others are bad.
The second line contains the pattern β a string s of lowercase English letters, characters "?" and "*" (1 β€ |s| β€ 105). It is guaranteed that character "*" occurs in s no more than once.
The third line contains integer n (1 β€ n β€ 105) β the number of query strings.
n lines follow, each of them contains single non-empty string consisting of lowercase English letters β a query string.
It is guaranteed that the total length of all query strings is not greater than 105.
Output
Print n lines: in the i-th of them print "YES" if the pattern matches the i-th query string, and "NO" otherwise.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
ab
a?a
2
aaa
aab
Output
YES
NO
Input
abc
a?a?a*
4
abacaba
abaca
apapa
aaaaax
Output
NO
YES
NO
YES
Note
In the first example we can replace "?" with good letters "a" and "b", so we can see that the answer for the first query is "YES", and the answer for the second query is "NO", because we can't match the third letter.
Explanation of the second example.
* The first query: "NO", because character "*" can be replaced with a string of bad letters only, but the only way to match the query string is to replace it with the string "ba", in which both letters are good.
* The second query: "YES", because characters "?" can be replaced with corresponding good letters, and character "*" can be replaced with empty string, and the strings will coincide.
* The third query: "NO", because characters "?" can't be replaced with bad letters.
* The fourth query: "YES", because characters "?" can be replaced with good letters "a", and character "*" can be replaced with a string of bad letters "x". | instruction | 0 | 108,336 | 18 | 216,672 |
Tags: implementation, strings
Correct Solution:
```
goods = input()
query = input().split('*')
l = [len(s) for s in query]
def match(pat, s):
if len(pat) != len(s):
return False
for x, y in zip(pat, s):
if x == '?':
if y not in goods:
return False
else:
if x != y:
return False
return True
for tc in range(int(input())):
s = input()
if len(query) == 1:
left = match(query[0], s)
mid = True
right = True
else:
left = match(query[0], s[:l[0]])
mid = len(s) >= sum(l) and all(c not in goods for c in s[l[0]:len(s) - l[1]])
right = match(query[1], s[len(s) - l[1]:])
print('YES' if left and mid and right else 'NO')
``` | output | 1 | 108,336 | 18 | 216,673 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's hard times now. Today Petya needs to score 100 points on Informatics exam. The tasks seem easy to Petya, but he thinks he lacks time to finish them all, so he asks you to help with one..
There is a glob pattern in the statements (a string consisting of lowercase English letters, characters "?" and "*"). It is known that character "*" occurs no more than once in the pattern.
Also, n query strings are given, it is required to determine for each of them if the pattern matches it or not.
Everything seemed easy to Petya, but then he discovered that the special pattern characters differ from their usual meaning.
A pattern matches a string if it is possible to replace each character "?" with one good lowercase English letter, and the character "*" (if there is one) with any, including empty, string of bad lowercase English letters, so that the resulting string is the same as the given string.
The good letters are given to Petya. All the others are bad.
Input
The first line contains a string with length from 1 to 26 consisting of distinct lowercase English letters. These letters are good letters, all the others are bad.
The second line contains the pattern β a string s of lowercase English letters, characters "?" and "*" (1 β€ |s| β€ 105). It is guaranteed that character "*" occurs in s no more than once.
The third line contains integer n (1 β€ n β€ 105) β the number of query strings.
n lines follow, each of them contains single non-empty string consisting of lowercase English letters β a query string.
It is guaranteed that the total length of all query strings is not greater than 105.
Output
Print n lines: in the i-th of them print "YES" if the pattern matches the i-th query string, and "NO" otherwise.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
ab
a?a
2
aaa
aab
Output
YES
NO
Input
abc
a?a?a*
4
abacaba
abaca
apapa
aaaaax
Output
NO
YES
NO
YES
Note
In the first example we can replace "?" with good letters "a" and "b", so we can see that the answer for the first query is "YES", and the answer for the second query is "NO", because we can't match the third letter.
Explanation of the second example.
* The first query: "NO", because character "*" can be replaced with a string of bad letters only, but the only way to match the query string is to replace it with the string "ba", in which both letters are good.
* The second query: "YES", because characters "?" can be replaced with corresponding good letters, and character "*" can be replaced with empty string, and the strings will coincide.
* The third query: "NO", because characters "?" can't be replaced with bad letters.
* The fourth query: "YES", because characters "?" can be replaced with good letters "a", and character "*" can be replaced with a string of bad letters "x". | instruction | 0 | 108,337 | 18 | 216,674 |
Tags: implementation, strings
Correct Solution:
```
import re
abc = set(list('abcdefghijklmnopqrstuvwxyz'))
good = set(input())
sp = {'?', '*'}
bad = abc - good
ans = []
pat = input()
pl = len(pat)
for _ in range(int(input())):
hasstar = False
answered = False
q = input()
d = len(q) - pl
if d < -1 or (d == -1 and "*" not in pat):
ans.append("NO")
continue
else:
i = 0
j = 0
while i < pl:
if (pat[i] == '?' and q[j] in bad) or (pat[i] not in sp and q[j] != pat[i]):
ans.append("NO")
answered = True
break
elif pat[i] == '*':
hasstar = True
if any(q[k] in good for k in range(j, j+d+1)):
ans.append("NO")
answered = True
break
j += d
i += 1
j += 1
if not answered:
if not hasstar:
if pl == len(q):
ans.append('YES')
answered = True
else:
ans.append('NO')
answered = True
else:
ans.append("YES")
answered = True
print('\n'.join(ans))
``` | output | 1 | 108,337 | 18 | 216,675 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's hard times now. Today Petya needs to score 100 points on Informatics exam. The tasks seem easy to Petya, but he thinks he lacks time to finish them all, so he asks you to help with one..
There is a glob pattern in the statements (a string consisting of lowercase English letters, characters "?" and "*"). It is known that character "*" occurs no more than once in the pattern.
Also, n query strings are given, it is required to determine for each of them if the pattern matches it or not.
Everything seemed easy to Petya, but then he discovered that the special pattern characters differ from their usual meaning.
A pattern matches a string if it is possible to replace each character "?" with one good lowercase English letter, and the character "*" (if there is one) with any, including empty, string of bad lowercase English letters, so that the resulting string is the same as the given string.
The good letters are given to Petya. All the others are bad.
Input
The first line contains a string with length from 1 to 26 consisting of distinct lowercase English letters. These letters are good letters, all the others are bad.
The second line contains the pattern β a string s of lowercase English letters, characters "?" and "*" (1 β€ |s| β€ 105). It is guaranteed that character "*" occurs in s no more than once.
The third line contains integer n (1 β€ n β€ 105) β the number of query strings.
n lines follow, each of them contains single non-empty string consisting of lowercase English letters β a query string.
It is guaranteed that the total length of all query strings is not greater than 105.
Output
Print n lines: in the i-th of them print "YES" if the pattern matches the i-th query string, and "NO" otherwise.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
ab
a?a
2
aaa
aab
Output
YES
NO
Input
abc
a?a?a*
4
abacaba
abaca
apapa
aaaaax
Output
NO
YES
NO
YES
Note
In the first example we can replace "?" with good letters "a" and "b", so we can see that the answer for the first query is "YES", and the answer for the second query is "NO", because we can't match the third letter.
Explanation of the second example.
* The first query: "NO", because character "*" can be replaced with a string of bad letters only, but the only way to match the query string is to replace it with the string "ba", in which both letters are good.
* The second query: "YES", because characters "?" can be replaced with corresponding good letters, and character "*" can be replaced with empty string, and the strings will coincide.
* The third query: "NO", because characters "?" can't be replaced with bad letters.
* The fourth query: "YES", because characters "?" can be replaced with good letters "a", and character "*" can be replaced with a string of bad letters "x".
Submitted Solution:
```
good, p, n = input(), input(), int(input())
plen = len(p)
if '*' not in p:
pflag = True
else:
pflag = False
for c in range(n):
s = input()
slen, i, j, flag = len(s), 0, 0, True
if slen < plen:
if pflag:
flag = False
elif slen < plen - 1:
flag = False
while i < plen and flag:
if p[i] == '*':
break
elif p[i] == '?':
if s[j] not in good:
flag = False
else:
if p[i] != s[j]:
flag = False
i += 1
j += 1
if i < plen and flag:
sp = j
i, j = plen-1, slen-1
while i >= 0 and flag:
if p[i] == '*':
break
elif p[i] == '?':
if s[j] not in good:
flag = False
else:
if p[i] != s[j]:
flag = False
i -= 1
j -= 1
while j >= sp and flag:
if s[j] in good:
flag = False
j -= 1
else:
if j < slen:
flag = False
if flag:
print("YES")
else:
print("NO")
``` | instruction | 0 | 108,338 | 18 | 216,676 |
Yes | output | 1 | 108,338 | 18 | 216,677 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's hard times now. Today Petya needs to score 100 points on Informatics exam. The tasks seem easy to Petya, but he thinks he lacks time to finish them all, so he asks you to help with one..
There is a glob pattern in the statements (a string consisting of lowercase English letters, characters "?" and "*"). It is known that character "*" occurs no more than once in the pattern.
Also, n query strings are given, it is required to determine for each of them if the pattern matches it or not.
Everything seemed easy to Petya, but then he discovered that the special pattern characters differ from their usual meaning.
A pattern matches a string if it is possible to replace each character "?" with one good lowercase English letter, and the character "*" (if there is one) with any, including empty, string of bad lowercase English letters, so that the resulting string is the same as the given string.
The good letters are given to Petya. All the others are bad.
Input
The first line contains a string with length from 1 to 26 consisting of distinct lowercase English letters. These letters are good letters, all the others are bad.
The second line contains the pattern β a string s of lowercase English letters, characters "?" and "*" (1 β€ |s| β€ 105). It is guaranteed that character "*" occurs in s no more than once.
The third line contains integer n (1 β€ n β€ 105) β the number of query strings.
n lines follow, each of them contains single non-empty string consisting of lowercase English letters β a query string.
It is guaranteed that the total length of all query strings is not greater than 105.
Output
Print n lines: in the i-th of them print "YES" if the pattern matches the i-th query string, and "NO" otherwise.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
ab
a?a
2
aaa
aab
Output
YES
NO
Input
abc
a?a?a*
4
abacaba
abaca
apapa
aaaaax
Output
NO
YES
NO
YES
Note
In the first example we can replace "?" with good letters "a" and "b", so we can see that the answer for the first query is "YES", and the answer for the second query is "NO", because we can't match the third letter.
Explanation of the second example.
* The first query: "NO", because character "*" can be replaced with a string of bad letters only, but the only way to match the query string is to replace it with the string "ba", in which both letters are good.
* The second query: "YES", because characters "?" can be replaced with corresponding good letters, and character "*" can be replaced with empty string, and the strings will coincide.
* The third query: "NO", because characters "?" can't be replaced with bad letters.
* The fourth query: "YES", because characters "?" can be replaced with good letters "a", and character "*" can be replaced with a string of bad letters "x".
Submitted Solution:
```
a = [0] * 26
s = str(input())
for c in s:
a[ord(c) - 97] = 1
t = str(input())
n = len(t)
idx = n
for j, c in enumerate(t):
if c == '*':
idx = j
break
q = int(input())
for i in range(q):
p = str(input())
m = len(p)
l, r = 0, 0
possible = True
if idx == n:
if n != m:
possible = False
else:
for j in range(n):
if t[j] == '?':
if not a[ord(p[j]) - 97]:
possible = False
break
else:
if t[j] != p[j]:
possible = False
break
if possible:
print('YES')
else:
print('NO')
else:
while t[l] != '*':
if l == m:
possible = False
break
if t[l] == '?':
if not a[ord(p[l]) - 97]:
possible = False
break
else:
if t[l] != p[l]:
possible = False
break
l += 1
while t[n - r - 1] != '*':
if r == m:
possible = False
break
if t[n - r - 1] == '?':
if not a[ord(p[m - r - 1]) - 97]:
possible = False
break
else:
if t[n - r - 1] != p[m - r - 1]:
possible = False
break
r += 1
for j in range(l, l + m - r - l):
if a[ord(p[j]) - 97]:
possible = False
break
if l + r > m:
possible = False
if possible:
print('YES')
else:
print('NO')
``` | instruction | 0 | 108,339 | 18 | 216,678 |
Yes | output | 1 | 108,339 | 18 | 216,679 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's hard times now. Today Petya needs to score 100 points on Informatics exam. The tasks seem easy to Petya, but he thinks he lacks time to finish them all, so he asks you to help with one..
There is a glob pattern in the statements (a string consisting of lowercase English letters, characters "?" and "*"). It is known that character "*" occurs no more than once in the pattern.
Also, n query strings are given, it is required to determine for each of them if the pattern matches it or not.
Everything seemed easy to Petya, but then he discovered that the special pattern characters differ from their usual meaning.
A pattern matches a string if it is possible to replace each character "?" with one good lowercase English letter, and the character "*" (if there is one) with any, including empty, string of bad lowercase English letters, so that the resulting string is the same as the given string.
The good letters are given to Petya. All the others are bad.
Input
The first line contains a string with length from 1 to 26 consisting of distinct lowercase English letters. These letters are good letters, all the others are bad.
The second line contains the pattern β a string s of lowercase English letters, characters "?" and "*" (1 β€ |s| β€ 105). It is guaranteed that character "*" occurs in s no more than once.
The third line contains integer n (1 β€ n β€ 105) β the number of query strings.
n lines follow, each of them contains single non-empty string consisting of lowercase English letters β a query string.
It is guaranteed that the total length of all query strings is not greater than 105.
Output
Print n lines: in the i-th of them print "YES" if the pattern matches the i-th query string, and "NO" otherwise.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
ab
a?a
2
aaa
aab
Output
YES
NO
Input
abc
a?a?a*
4
abacaba
abaca
apapa
aaaaax
Output
NO
YES
NO
YES
Note
In the first example we can replace "?" with good letters "a" and "b", so we can see that the answer for the first query is "YES", and the answer for the second query is "NO", because we can't match the third letter.
Explanation of the second example.
* The first query: "NO", because character "*" can be replaced with a string of bad letters only, but the only way to match the query string is to replace it with the string "ba", in which both letters are good.
* The second query: "YES", because characters "?" can be replaced with corresponding good letters, and character "*" can be replaced with empty string, and the strings will coincide.
* The third query: "NO", because characters "?" can't be replaced with bad letters.
* The fourth query: "YES", because characters "?" can be replaced with good letters "a", and character "*" can be replaced with a string of bad letters "x".
Submitted Solution:
```
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now----------------------------------------------------
s=input()
ls=[0 for i in range(26)]
for i in range(len(s)):
ls[ord(s[i])-97]=1
s=input()
n=int(input())
while n:
q=input()
if(len(q)<len(s)-1):print("NO")
elif('*' not in s):
if(len(s)!=len(q)):print("NO")
else:
flag=True
for j in range(len(s)):
if(s[j]!=q[j]):
if(s[j]=='?'):
if(ls[ord(q[j])-97]!=1):
flag=False
break
else:
flag=False
break
if(flag):print("YES")
else:print("NO")
else:
flag=True
i=s.index('*')
for j in range(i):
if(s[j]!=q[j]):
if(s[j]=='?'):
if(ls[ord(q[j])-97]!=1):
flag=False
break
else:
flag=False
break
for j in range(i,len(q)-(len(s)-i-1)):
if(ls[ord(q[j])-97]!=0):
flag=False
break
k=len(q)-(len(s)-i-1)
for j in range(i+1,len(s)):
if(s[j]!=q[k]):
if(s[j]=='?'):
if(ls[ord(q[k])-97]!=1):
flag=False
break
else:
flag=False
break
k+=1
if(flag):print("YES")
else:print("NO")
n-=1
``` | instruction | 0 | 108,340 | 18 | 216,680 |
Yes | output | 1 | 108,340 | 18 | 216,681 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's hard times now. Today Petya needs to score 100 points on Informatics exam. The tasks seem easy to Petya, but he thinks he lacks time to finish them all, so he asks you to help with one..
There is a glob pattern in the statements (a string consisting of lowercase English letters, characters "?" and "*"). It is known that character "*" occurs no more than once in the pattern.
Also, n query strings are given, it is required to determine for each of them if the pattern matches it or not.
Everything seemed easy to Petya, but then he discovered that the special pattern characters differ from their usual meaning.
A pattern matches a string if it is possible to replace each character "?" with one good lowercase English letter, and the character "*" (if there is one) with any, including empty, string of bad lowercase English letters, so that the resulting string is the same as the given string.
The good letters are given to Petya. All the others are bad.
Input
The first line contains a string with length from 1 to 26 consisting of distinct lowercase English letters. These letters are good letters, all the others are bad.
The second line contains the pattern β a string s of lowercase English letters, characters "?" and "*" (1 β€ |s| β€ 105). It is guaranteed that character "*" occurs in s no more than once.
The third line contains integer n (1 β€ n β€ 105) β the number of query strings.
n lines follow, each of them contains single non-empty string consisting of lowercase English letters β a query string.
It is guaranteed that the total length of all query strings is not greater than 105.
Output
Print n lines: in the i-th of them print "YES" if the pattern matches the i-th query string, and "NO" otherwise.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
ab
a?a
2
aaa
aab
Output
YES
NO
Input
abc
a?a?a*
4
abacaba
abaca
apapa
aaaaax
Output
NO
YES
NO
YES
Note
In the first example we can replace "?" with good letters "a" and "b", so we can see that the answer for the first query is "YES", and the answer for the second query is "NO", because we can't match the third letter.
Explanation of the second example.
* The first query: "NO", because character "*" can be replaced with a string of bad letters only, but the only way to match the query string is to replace it with the string "ba", in which both letters are good.
* The second query: "YES", because characters "?" can be replaced with corresponding good letters, and character "*" can be replaced with empty string, and the strings will coincide.
* The third query: "NO", because characters "?" can't be replaced with bad letters.
* The fourth query: "YES", because characters "?" can be replaced with good letters "a", and character "*" can be replaced with a string of bad letters "x".
Submitted Solution:
```
all_letters = {chr(i) for i in range(97, 97 + 26)}
good_letters = {letter for letter in input()}
bad_letters = all_letters - good_letters
pattern = input()
n = int(input())
star_index = pattern.find('*')
def check(s, m_pattern):
for i in range(len(s)):
if m_pattern[i] == '$':
if s[i] not in bad_letters:
return False
elif m_pattern[i] == '?':
if s[i] not in good_letters:
return False
else:
if m_pattern[i] != s[i]:
return False
return True
def match(s):
if len(s) < len(pattern) - 1:
return False
else:
if len(s) == len(pattern) - 1:
if star_index == -1:
return False
else:
return check(s, pattern[:star_index] + pattern[star_index + 1:])
else:
m_pattern = ''
if star_index == -1:
if len(s) > len(pattern):
return False
else:
m_pattern = pattern[:]
else:
m_pattern += pattern[:star_index]
m_sec_pattern = pattern[:star_index]
for i in range(len(s) - len(pattern) + 1):
m_pattern += '$'
m_pattern += pattern[star_index + 1:]
return check(s, m_pattern)
for i in range(n):
qs = input()
print('YES' if match(qs) else 'NO')
``` | instruction | 0 | 108,341 | 18 | 216,682 |
Yes | output | 1 | 108,341 | 18 | 216,683 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's hard times now. Today Petya needs to score 100 points on Informatics exam. The tasks seem easy to Petya, but he thinks he lacks time to finish them all, so he asks you to help with one..
There is a glob pattern in the statements (a string consisting of lowercase English letters, characters "?" and "*"). It is known that character "*" occurs no more than once in the pattern.
Also, n query strings are given, it is required to determine for each of them if the pattern matches it or not.
Everything seemed easy to Petya, but then he discovered that the special pattern characters differ from their usual meaning.
A pattern matches a string if it is possible to replace each character "?" with one good lowercase English letter, and the character "*" (if there is one) with any, including empty, string of bad lowercase English letters, so that the resulting string is the same as the given string.
The good letters are given to Petya. All the others are bad.
Input
The first line contains a string with length from 1 to 26 consisting of distinct lowercase English letters. These letters are good letters, all the others are bad.
The second line contains the pattern β a string s of lowercase English letters, characters "?" and "*" (1 β€ |s| β€ 105). It is guaranteed that character "*" occurs in s no more than once.
The third line contains integer n (1 β€ n β€ 105) β the number of query strings.
n lines follow, each of them contains single non-empty string consisting of lowercase English letters β a query string.
It is guaranteed that the total length of all query strings is not greater than 105.
Output
Print n lines: in the i-th of them print "YES" if the pattern matches the i-th query string, and "NO" otherwise.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
ab
a?a
2
aaa
aab
Output
YES
NO
Input
abc
a?a?a*
4
abacaba
abaca
apapa
aaaaax
Output
NO
YES
NO
YES
Note
In the first example we can replace "?" with good letters "a" and "b", so we can see that the answer for the first query is "YES", and the answer for the second query is "NO", because we can't match the third letter.
Explanation of the second example.
* The first query: "NO", because character "*" can be replaced with a string of bad letters only, but the only way to match the query string is to replace it with the string "ba", in which both letters are good.
* The second query: "YES", because characters "?" can be replaced with corresponding good letters, and character "*" can be replaced with empty string, and the strings will coincide.
* The third query: "NO", because characters "?" can't be replaced with bad letters.
* The fourth query: "YES", because characters "?" can be replaced with good letters "a", and character "*" can be replaced with a string of bad letters "x".
Submitted Solution:
```
good = input()
sh = input()
pr = int(input())
ind = -1
if '*' in sh:
ind = sh.index('*')
for i in range(pr):
t = input()
res = "NO"
for j in range(len(sh)):
if len(t) < len(sh):
t = t[:ind] + ' ' + t[ind:]
elif len(t) > len(sh):
res = "NO"
break
if t[j] == sh[j]:
res = "YES"
elif sh[j] == '?':
if t[j] in good:
res = "YES"
else:
res = "NO"
break
elif sh[j] == '*':
if t[j] not in good:
res = "YES"
else:
res = "NO"
print(res)
``` | instruction | 0 | 108,342 | 18 | 216,684 |
No | output | 1 | 108,342 | 18 | 216,685 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's hard times now. Today Petya needs to score 100 points on Informatics exam. The tasks seem easy to Petya, but he thinks he lacks time to finish them all, so he asks you to help with one..
There is a glob pattern in the statements (a string consisting of lowercase English letters, characters "?" and "*"). It is known that character "*" occurs no more than once in the pattern.
Also, n query strings are given, it is required to determine for each of them if the pattern matches it or not.
Everything seemed easy to Petya, but then he discovered that the special pattern characters differ from their usual meaning.
A pattern matches a string if it is possible to replace each character "?" with one good lowercase English letter, and the character "*" (if there is one) with any, including empty, string of bad lowercase English letters, so that the resulting string is the same as the given string.
The good letters are given to Petya. All the others are bad.
Input
The first line contains a string with length from 1 to 26 consisting of distinct lowercase English letters. These letters are good letters, all the others are bad.
The second line contains the pattern β a string s of lowercase English letters, characters "?" and "*" (1 β€ |s| β€ 105). It is guaranteed that character "*" occurs in s no more than once.
The third line contains integer n (1 β€ n β€ 105) β the number of query strings.
n lines follow, each of them contains single non-empty string consisting of lowercase English letters β a query string.
It is guaranteed that the total length of all query strings is not greater than 105.
Output
Print n lines: in the i-th of them print "YES" if the pattern matches the i-th query string, and "NO" otherwise.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
ab
a?a
2
aaa
aab
Output
YES
NO
Input
abc
a?a?a*
4
abacaba
abaca
apapa
aaaaax
Output
NO
YES
NO
YES
Note
In the first example we can replace "?" with good letters "a" and "b", so we can see that the answer for the first query is "YES", and the answer for the second query is "NO", because we can't match the third letter.
Explanation of the second example.
* The first query: "NO", because character "*" can be replaced with a string of bad letters only, but the only way to match the query string is to replace it with the string "ba", in which both letters are good.
* The second query: "YES", because characters "?" can be replaced with corresponding good letters, and character "*" can be replaced with empty string, and the strings will coincide.
* The third query: "NO", because characters "?" can't be replaced with bad letters.
* The fourth query: "YES", because characters "?" can be replaced with good letters "a", and character "*" can be replaced with a string of bad letters "x".
Submitted Solution:
```
lower = "azertyuiopqsdfghjklmwxcvbn"
alphabet = input()
pattern_str = input()
n = int(input())
for i in range(n):
line = list(input())
pattern = list(pattern_str)
result = "NO"
while len(line) > 0 and len(pattern) > 0:
if line[0] not in lower:
break
if line[0] == pattern[0]:
line.pop(0)
pattern.pop(0)
continue
if line[0] in alphabet:
if pattern[0] == "?":
line.pop(0)
pattern.pop(0)
elif pattern[0] == "*":
pattern.pop(0)
else:
break
else:
if pattern[0] == "*":
line.pop(0)
else:
break
if len(line) + len(pattern) == 0 or (len(pattern) == 1 and pattern[0] == "*"):
result = "YES"
print(result)
``` | instruction | 0 | 108,343 | 18 | 216,686 |
No | output | 1 | 108,343 | 18 | 216,687 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's hard times now. Today Petya needs to score 100 points on Informatics exam. The tasks seem easy to Petya, but he thinks he lacks time to finish them all, so he asks you to help with one..
There is a glob pattern in the statements (a string consisting of lowercase English letters, characters "?" and "*"). It is known that character "*" occurs no more than once in the pattern.
Also, n query strings are given, it is required to determine for each of them if the pattern matches it or not.
Everything seemed easy to Petya, but then he discovered that the special pattern characters differ from their usual meaning.
A pattern matches a string if it is possible to replace each character "?" with one good lowercase English letter, and the character "*" (if there is one) with any, including empty, string of bad lowercase English letters, so that the resulting string is the same as the given string.
The good letters are given to Petya. All the others are bad.
Input
The first line contains a string with length from 1 to 26 consisting of distinct lowercase English letters. These letters are good letters, all the others are bad.
The second line contains the pattern β a string s of lowercase English letters, characters "?" and "*" (1 β€ |s| β€ 105). It is guaranteed that character "*" occurs in s no more than once.
The third line contains integer n (1 β€ n β€ 105) β the number of query strings.
n lines follow, each of them contains single non-empty string consisting of lowercase English letters β a query string.
It is guaranteed that the total length of all query strings is not greater than 105.
Output
Print n lines: in the i-th of them print "YES" if the pattern matches the i-th query string, and "NO" otherwise.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
ab
a?a
2
aaa
aab
Output
YES
NO
Input
abc
a?a?a*
4
abacaba
abaca
apapa
aaaaax
Output
NO
YES
NO
YES
Note
In the first example we can replace "?" with good letters "a" and "b", so we can see that the answer for the first query is "YES", and the answer for the second query is "NO", because we can't match the third letter.
Explanation of the second example.
* The first query: "NO", because character "*" can be replaced with a string of bad letters only, but the only way to match the query string is to replace it with the string "ba", in which both letters are good.
* The second query: "YES", because characters "?" can be replaced with corresponding good letters, and character "*" can be replaced with empty string, and the strings will coincide.
* The third query: "NO", because characters "?" can't be replaced with bad letters.
* The fourth query: "YES", because characters "?" can be replaced with good letters "a", and character "*" can be replaced with a string of bad letters "x".
Submitted Solution:
```
l=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
s1=input().strip()
s1=list(s1)
s2=[]
for i in l:
if i not in s1:
s2.append(i)
pattern=input().strip()
pattern=list(pattern)
if ("*" not in pattern):
length_main=len(pattern)
n=int(input().strip())
for i in range(n):
f=0
string=input().strip()
length=len(string)
if (length_main==length):
for j in range(length_main):
if (string[j]!=pattern[j]):
if (pattern[j]!="?"):
print ('NO')
f=1
break
else:
if (string[j] not in s1):
print ('NO')
f=1
break
else:
print ('NO')
if (f==0):
print ('YES')
else:
ind=pattern.index("*")
length_main=len(pattern)
n=int(input().strip())
for i in range(n):
string=input().strip()
length=len(string)
if (length<length_main-1):
print ('NO')
else:
f=0
for j in range(ind):
if (string[j]!=pattern[j]):
if (pattern[j]!="?"):
print ('NO')
f=1
break
else:
if (string[j] not in s1):
print ('NO')
f=1
break
if (f!=1):
q=length_main-length
for j in range(length_main-1,ind,-1):
if (string[j-q]!=pattern[j]):
if (pattern[j]!="?"):
print ('NO')
f=1
break
else:
if (string[j-q] not in s1):
print ('NO')
f=1
break
if (f!=1):
save= ind+1-q
string=list(string)
x=string[ind:save]
for j in x:
if (j not in s2):
print ('NO')
f=1
break
if (f==0):
print ('YES')
``` | instruction | 0 | 108,344 | 18 | 216,688 |
No | output | 1 | 108,344 | 18 | 216,689 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's hard times now. Today Petya needs to score 100 points on Informatics exam. The tasks seem easy to Petya, but he thinks he lacks time to finish them all, so he asks you to help with one..
There is a glob pattern in the statements (a string consisting of lowercase English letters, characters "?" and "*"). It is known that character "*" occurs no more than once in the pattern.
Also, n query strings are given, it is required to determine for each of them if the pattern matches it or not.
Everything seemed easy to Petya, but then he discovered that the special pattern characters differ from their usual meaning.
A pattern matches a string if it is possible to replace each character "?" with one good lowercase English letter, and the character "*" (if there is one) with any, including empty, string of bad lowercase English letters, so that the resulting string is the same as the given string.
The good letters are given to Petya. All the others are bad.
Input
The first line contains a string with length from 1 to 26 consisting of distinct lowercase English letters. These letters are good letters, all the others are bad.
The second line contains the pattern β a string s of lowercase English letters, characters "?" and "*" (1 β€ |s| β€ 105). It is guaranteed that character "*" occurs in s no more than once.
The third line contains integer n (1 β€ n β€ 105) β the number of query strings.
n lines follow, each of them contains single non-empty string consisting of lowercase English letters β a query string.
It is guaranteed that the total length of all query strings is not greater than 105.
Output
Print n lines: in the i-th of them print "YES" if the pattern matches the i-th query string, and "NO" otherwise.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
ab
a?a
2
aaa
aab
Output
YES
NO
Input
abc
a?a?a*
4
abacaba
abaca
apapa
aaaaax
Output
NO
YES
NO
YES
Note
In the first example we can replace "?" with good letters "a" and "b", so we can see that the answer for the first query is "YES", and the answer for the second query is "NO", because we can't match the third letter.
Explanation of the second example.
* The first query: "NO", because character "*" can be replaced with a string of bad letters only, but the only way to match the query string is to replace it with the string "ba", in which both letters are good.
* The second query: "YES", because characters "?" can be replaced with corresponding good letters, and character "*" can be replaced with empty string, and the strings will coincide.
* The third query: "NO", because characters "?" can't be replaced with bad letters.
* The fourth query: "YES", because characters "?" can be replaced with good letters "a", and character "*" can be replaced with a string of bad letters "x".
Submitted Solution:
```
def do(cur)->str:
i=j=0
while i<len(pt) and j<len(cur):
if pt[i]=="?":
if cur[j] not in good:return"NO"
elif pt[i]=="*":
while j<len(cur) and cur[j] not in good:j+=1
if j==len(cur):
if i==len(pt)-1:break
return"NO"
elif i==len(pt)-1:return "NO"
i+=1;continue
else:
if pt[i]!=cur[j]:return"NO"
i+=1;j+=1
return "YES" if j==len(cur) and i==len(pt) else "NO"
good=set(input())
pt=input()
for _ in range(int(input())):
cur=input()
print(do(cur))
``` | instruction | 0 | 108,345 | 18 | 216,690 |
No | output | 1 | 108,345 | 18 | 216,691 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.