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 |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In cryptography, Caesar cipher is one of the simplest and most widely known encryption method. Caesar cipher is a type of substitution cipher in which each letter in the text is replaced by a letter some fixed number of positions down the alphabet. For example, with a shift of 1, 'a' would be replaced by 'b', 'b' would become 'c', 'y' would become 'z', 'z' would become 'a', and so on. In that case, a text:
this is a pen
is would become:
uijt jt b qfo
Write a program which reads a text encrypted by Caesar Chipher and prints the corresponding decoded text. The number of shift is secret and it depends on datasets, but you can assume that the decoded text includes any of the following words: "the", "this", or "that".
Input
Input consists of several datasets. Each dataset consists of texts in a line. Input ends with EOF. The text consists of lower-case letters, periods, space, and end-of-lines. Only the letters have been encrypted. A line consists of at most 80 characters.
You may assume that you can create one decoded text which includes any of "the", "this", or "that" from the given input text.
The number of datasets is less than or equal to 20.
Output
Print decoded texts in a line.
Example
Input
xlmw mw xli tmgxyvi xlex m xsso mr xli xvmt.
Output
this is the picture that i took in the trip.
Submitted Solution:
```
import string
import sys
alpha = string.ascii_lowercase
for line in sys.stdin:
for i in range(len(alpha)):
cipher_str = ""
for s in line:
if s in alpha:
cipher_str += alpha[(alpha.index(s)+i) % len(alpha)]
else:
cipher_str += s
if ("the" or "this" or "that") in cipher_str:
print(cipher_str)
break
else:
print(line)
``` | instruction | 0 | 32,401 | 18 | 64,802 |
No | output | 1 | 32,401 | 18 | 64,803 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Unary is a minimalistic Brainfuck dialect in which programs are written using only one token.
Brainfuck programs use 8 commands: "+", "-", "[", "]", "<", ">", "." and "," (their meaning is not important for the purposes of this problem). Unary programs are created from Brainfuck programs using the following algorithm. First, replace each command with a corresponding binary code, using the following conversion table:
* ">" → 1000,
* "<" → 1001,
* "+" → 1010,
* "-" → 1011,
* "." → 1100,
* "," → 1101,
* "[" → 1110,
* "]" → 1111.
Next, concatenate the resulting binary codes into one binary number in the same order as in the program. Finally, write this number using unary numeral system — this is the Unary program equivalent to the original Brainfuck one.
You are given a Brainfuck program. Your task is to calculate the size of the equivalent Unary program, and print it modulo 1000003 (106 + 3).
Input
The input will consist of a single line p which gives a Brainfuck program. String p will contain between 1 and 100 characters, inclusive. Each character of p will be "+", "-", "[", "]", "<", ">", "." or ",".
Output
Output the size of the equivalent Unary program modulo 1000003 (106 + 3).
Examples
Input
,.
Output
220
Input
++++[>,.<-]
Output
61425
Note
To write a number n in unary numeral system, one simply has to write 1 n times. For example, 5 written in unary system will be 11111.
In the first example replacing Brainfuck commands with binary code will give us 1101 1100. After we concatenate the codes, we'll get 11011100 in binary system, or 220 in decimal. That's exactly the number of tokens in the equivalent Unary program.
Submitted Solution:
```
#!/usr/bin/python3
def readln(): return tuple(map(int, input().split()))
m = {'>': 8, '<': 9, '+': 10, '-': 11, '.': 12, ',': 13, '[': 14, ']': 15}
ans = 0
mod = 10**6 + 3
for i, c in enumerate(reversed(list(input()))):
ans = (ans + (m[c] * pow(2, 4 * i, mod))) % mod
print(ans)
``` | instruction | 0 | 32,682 | 18 | 65,364 |
Yes | output | 1 | 32,682 | 18 | 65,365 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Unary is a minimalistic Brainfuck dialect in which programs are written using only one token.
Brainfuck programs use 8 commands: "+", "-", "[", "]", "<", ">", "." and "," (their meaning is not important for the purposes of this problem). Unary programs are created from Brainfuck programs using the following algorithm. First, replace each command with a corresponding binary code, using the following conversion table:
* ">" → 1000,
* "<" → 1001,
* "+" → 1010,
* "-" → 1011,
* "." → 1100,
* "," → 1101,
* "[" → 1110,
* "]" → 1111.
Next, concatenate the resulting binary codes into one binary number in the same order as in the program. Finally, write this number using unary numeral system — this is the Unary program equivalent to the original Brainfuck one.
You are given a Brainfuck program. Your task is to calculate the size of the equivalent Unary program, and print it modulo 1000003 (106 + 3).
Input
The input will consist of a single line p which gives a Brainfuck program. String p will contain between 1 and 100 characters, inclusive. Each character of p will be "+", "-", "[", "]", "<", ">", "." or ",".
Output
Output the size of the equivalent Unary program modulo 1000003 (106 + 3).
Examples
Input
,.
Output
220
Input
++++[>,.<-]
Output
61425
Note
To write a number n in unary numeral system, one simply has to write 1 n times. For example, 5 written in unary system will be 11111.
In the first example replacing Brainfuck commands with binary code will give us 1101 1100. After we concatenate the codes, we'll get 11011100 in binary system, or 220 in decimal. That's exactly the number of tokens in the equivalent Unary program.
Submitted Solution:
```
s = input()
res = []
for char in s:
if char == '>':
res.append('1000')
if char == '<':
res.append('1001')
if char == '+':
res.append('1010')
if char == '-':
res.append('1011')
if char == '.':
res.append('1100')
if char == ',':
res.append('1101')
if char == ']':
res.append('1110')
if char == '[':
res.append('1111')
res2 = 0
for i in range(len(res)):
res2 = res2 * 16 + int(res[i],2) % 1000003
print(res2)
``` | instruction | 0 | 32,686 | 18 | 65,372 |
No | output | 1 | 32,686 | 18 | 65,373 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call a string "s-palindrome" if it is symmetric about the middle of the string. For example, the string "oHo" is "s-palindrome", but the string "aa" is not. The string "aa" is not "s-palindrome", because the second half of it is not a mirror reflection of the first half.
<image> English alphabet
You are given a string s. Check if the string is "s-palindrome".
Input
The only line contains the string s (1 ≤ |s| ≤ 1000) which consists of only English letters.
Output
Print "TAK" if the string s is "s-palindrome" and "NIE" otherwise.
Examples
Input
oXoxoXo
Output
TAK
Input
bod
Output
TAK
Input
ER
Output
NIE
Submitted Solution:
```
def solution(s):
t = "AHIMOoTUVvWwXxY"
pol = {"A" : "A",
"b" : "d",
"d" : "b",
"H" : "H",
"I" : "I",
"M" : "M",
"O" : "O",
"o" : "o",
"p" : "q",
"q" : "p",
"T" : "T",
"U" : "U",
"V" : "V",
"v" : "v",
"W" : "W",
"w" : "w",
"X" : "X",
"x" : "x",
"Y" : "Y"}
for i in range(len(s)//2):
if s[i] in pol:
if s[len(s) - i - 1] != pol[s[i]]: return "NIE"
else: return "NIE"
#print(s[len(s)//2])
if len(s)%2:
if s[len(s)//2] in t: return "TAK"
else: return "NIE"
else:
if pol[s[len(s)//2 - 1]] == s[len(s)//2]: return "TAK"
else: return "NIE"
print(solution(input()))
``` | instruction | 0 | 33,010 | 18 | 66,020 |
Yes | output | 1 | 33,010 | 18 | 66,021 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call a string "s-palindrome" if it is symmetric about the middle of the string. For example, the string "oHo" is "s-palindrome", but the string "aa" is not. The string "aa" is not "s-palindrome", because the second half of it is not a mirror reflection of the first half.
<image> English alphabet
You are given a string s. Check if the string is "s-palindrome".
Input
The only line contains the string s (1 ≤ |s| ≤ 1000) which consists of only English letters.
Output
Print "TAK" if the string s is "s-palindrome" and "NIE" otherwise.
Examples
Input
oXoxoXo
Output
TAK
Input
bod
Output
TAK
Input
ER
Output
NIE
Submitted Solution:
```
m=['A','H','I','M','O','o','T','U','V','v','W','w','X','x','Y']
n={'p': 'q', 'q': 'p', 'b': 'd', 'd': 'b'}
a=True
x=input()
for i in range(len(x)//2):
if x[i] in m:
if x[-1-i]!=x[i]:
a=False
break
elif x[i] in ['b','d','q','p']:
if n[x[i]]!=x[-1-i]:
a=False
break
else:
a=False
break
if len(x)%2==1 and x[len(x)//2] not in m:
a=False
if a:
print('TAK')
else:
print('NIE')
``` | instruction | 0 | 33,011 | 18 | 66,022 |
Yes | output | 1 | 33,011 | 18 | 66,023 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call a string "s-palindrome" if it is symmetric about the middle of the string. For example, the string "oHo" is "s-palindrome", but the string "aa" is not. The string "aa" is not "s-palindrome", because the second half of it is not a mirror reflection of the first half.
<image> English alphabet
You are given a string s. Check if the string is "s-palindrome".
Input
The only line contains the string s (1 ≤ |s| ≤ 1000) which consists of only English letters.
Output
Print "TAK" if the string s is "s-palindrome" and "NIE" otherwise.
Examples
Input
oXoxoXo
Output
TAK
Input
bod
Output
TAK
Input
ER
Output
NIE
Submitted Solution:
```
def calcut(x,etalon,dl,l,n,t):
s=0
for i in range(n+t):
if (x[0][i]==x[0][l-1-i]):
for y in range(dl):
if (x[0][i]==etalon[y]) :
s=s+1
else:
if (x[0][i]=="b")and(x[0][l-1-i]=="d") or (x[0][i]=="d")and(x[0][l-1-i]=="b"):
s=s+1
elif (x[0][i]=="p")and(x[0][l-1-i]=="q") or (x[0][i]=="q")and(x[0][l-1-i]=="p"):
s=s+1
else:
print("NIE")
break
else:
if s==n+t:
print("TAK")
else:
print("NIE")
x=input().split()
etalon=["A","H","I","M","O","o","T","U","V","v","W","w","X","x","Y"]
dl=len(etalon)
l=len(x[0])
n=l//2
if n==0:
for y in range(dl):
if (x[0][0]==etalon[y]) :
print("TAK")
break
elif y+1==dl:
print("NIE")
break
elif l%2!=0:
calcut(x,etalon,dl,l,n,1)
else:
calcut(x,etalon,dl,l,n,0)
``` | instruction | 0 | 33,012 | 18 | 66,024 |
Yes | output | 1 | 33,012 | 18 | 66,025 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call a string "s-palindrome" if it is symmetric about the middle of the string. For example, the string "oHo" is "s-palindrome", but the string "aa" is not. The string "aa" is not "s-palindrome", because the second half of it is not a mirror reflection of the first half.
<image> English alphabet
You are given a string s. Check if the string is "s-palindrome".
Input
The only line contains the string s (1 ≤ |s| ≤ 1000) which consists of only English letters.
Output
Print "TAK" if the string s is "s-palindrome" and "NIE" otherwise.
Examples
Input
oXoxoXo
Output
TAK
Input
bod
Output
TAK
Input
ER
Output
NIE
Submitted Solution:
```
s = input()
mirror={'b':'d','d':'b','p':'q','q':'p'}
while len(s)>1:
if s[0] in 'AoOIMHTUVvWwXxY':
if s[0]==s[-1]: s=s[1:-1:]
else: break
elif s[0] in mirror:
if s[0]==mirror[s[-1]]: s=s[1:-1:]
else: break
else: break
if len(s)==0 or (s[0] in 'AoOIMHTUVvWwXxY' and len(s)==1):
print('TAK')
else: print('NIE')
``` | instruction | 0 | 33,013 | 18 | 66,026 |
Yes | output | 1 | 33,013 | 18 | 66,027 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call a string "s-palindrome" if it is symmetric about the middle of the string. For example, the string "oHo" is "s-palindrome", but the string "aa" is not. The string "aa" is not "s-palindrome", because the second half of it is not a mirror reflection of the first half.
<image> English alphabet
You are given a string s. Check if the string is "s-palindrome".
Input
The only line contains the string s (1 ≤ |s| ≤ 1000) which consists of only English letters.
Output
Print "TAK" if the string s is "s-palindrome" and "NIE" otherwise.
Examples
Input
oXoxoXo
Output
TAK
Input
bod
Output
TAK
Input
ER
Output
NIE
Submitted Solution:
```
text = input()
symm = 'AHIMOoTUVvWwXxY'
if len(text) % 2 == 0:
print('NIE')
else:
middle = len(text) // 2 + 1
error = False
for i in range(middle):
if text[i] in symm and (text[i] == text[-1 - i] or s[i] + s[-i-1] in ["bd", "db", "pq", "qp"]):
continue
else:
print('NIE')
error = True
break
if not error:
print('TAK')
``` | instruction | 0 | 33,014 | 18 | 66,028 |
No | output | 1 | 33,014 | 18 | 66,029 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call a string "s-palindrome" if it is symmetric about the middle of the string. For example, the string "oHo" is "s-palindrome", but the string "aa" is not. The string "aa" is not "s-palindrome", because the second half of it is not a mirror reflection of the first half.
<image> English alphabet
You are given a string s. Check if the string is "s-palindrome".
Input
The only line contains the string s (1 ≤ |s| ≤ 1000) which consists of only English letters.
Output
Print "TAK" if the string s is "s-palindrome" and "NIE" otherwise.
Examples
Input
oXoxoXo
Output
TAK
Input
bod
Output
TAK
Input
ER
Output
NIE
Submitted Solution:
```
sym = "AHIMOTUVWXYovwx"
mir = {
'p': 'q',
'q': 'p',
'd': 'b',
'b': 'd',
}
def good(a, b):
if a in sym and a == b:
return True
if a in mir and mir[a] == b:
return True
return False
def check(s: str) -> bool:
for i in range(len(s)):
j = len(s) - i - 1
if i == j:
if not s[i] in sym:
print(i, s[i])
return False
if i != j:
if not good(s[i], s[j]):
return False
return True
s = input()
print('TAK' if check(s) else 'NIE')
``` | instruction | 0 | 33,015 | 18 | 66,030 |
No | output | 1 | 33,015 | 18 | 66,031 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call a string "s-palindrome" if it is symmetric about the middle of the string. For example, the string "oHo" is "s-palindrome", but the string "aa" is not. The string "aa" is not "s-palindrome", because the second half of it is not a mirror reflection of the first half.
<image> English alphabet
You are given a string s. Check if the string is "s-palindrome".
Input
The only line contains the string s (1 ≤ |s| ≤ 1000) which consists of only English letters.
Output
Print "TAK" if the string s is "s-palindrome" and "NIE" otherwise.
Examples
Input
oXoxoXo
Output
TAK
Input
bod
Output
TAK
Input
ER
Output
NIE
Submitted Solution:
```
alth = "AbdOoiIlMmnpqYWwVvXxTUuH"
alth2 = "bpqd"
alth3 = "AOoiIlMmnYWwVvXxTUuH"
s = input()
n = len(s)
temp = 0
for i in range(n//2):
if alth.find(s[i]) == -1 or alth.find(s[n-i-1]) == -1:
temp = 1
break
if alth2.find(s[i]) != -1:
if alth2.find(s[i]) + alth2.find(s[n-i-1]) != 3:
temp = 1
break
if alth3.find(s[i]) != -1:
if s[i] != s[n-i-1]:
temp = 1
break
if temp == 1:
print("NIE")
else:
print("TAK")
``` | instruction | 0 | 33,016 | 18 | 66,032 |
No | output | 1 | 33,016 | 18 | 66,033 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call a string "s-palindrome" if it is symmetric about the middle of the string. For example, the string "oHo" is "s-palindrome", but the string "aa" is not. The string "aa" is not "s-palindrome", because the second half of it is not a mirror reflection of the first half.
<image> English alphabet
You are given a string s. Check if the string is "s-palindrome".
Input
The only line contains the string s (1 ≤ |s| ≤ 1000) which consists of only English letters.
Output
Print "TAK" if the string s is "s-palindrome" and "NIE" otherwise.
Examples
Input
oXoxoXo
Output
TAK
Input
bod
Output
TAK
Input
ER
Output
NIE
Submitted Solution:
```
d = {
'A' : 'A',
'b' : 'd',
'd' : 'b',
'H' : 'H',
'I' : 'I',
'M' : 'M',
'O' : 'O',
'o' : 'o',
'X' : 'X',
'x' : 'x',
'Y' : 'Y',
'W' : 'W',
'V' : 'V',
'w' : 'w',
'v' : 'v',
'T' : 'T',
'p' : 'q',
'q' : 'p'
}
g = lambda c : '*' if c not in d.keys() else d[c]
s = input()
for i in range(len(s)) :
if s[i] != g(s[len(s)-i-1]) :
print('NIE')
exit(0)
print('TAK')
``` | instruction | 0 | 33,017 | 18 | 66,034 |
No | output | 1 | 33,017 | 18 | 66,035 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
ZS the Coder loves to read the dictionary. He thinks that a word is nice if there exists a substring (contiguous segment of letters) of it of length 26 where each letter of English alphabet appears exactly once. In particular, if the string has length strictly less than 26, no such substring exists and thus it is not nice.
Now, ZS the Coder tells you a word, where some of its letters are missing as he forgot them. He wants to determine if it is possible to fill in the missing letters so that the resulting word is nice. If it is possible, he needs you to find an example of such a word as well. Can you help him?
Input
The first and only line of the input contains a single string s (1 ≤ |s| ≤ 50 000), the word that ZS the Coder remembers. Each character of the string is the uppercase letter of English alphabet ('A'-'Z') or is a question mark ('?'), where the question marks denotes the letters that ZS the Coder can't remember.
Output
If there is no way to replace all the question marks with uppercase letters such that the resulting word is nice, then print - 1 in the only line.
Otherwise, print a string which denotes a possible nice word that ZS the Coder learned. This string should match the string from the input, except for the question marks replaced with uppercase English letters.
If there are multiple solutions, you may print any of them.
Examples
Input
ABC??FGHIJK???OPQR?TUVWXY?
Output
ABCDEFGHIJKLMNOPQRZTUVWXYS
Input
WELCOMETOCODEFORCESROUNDTHREEHUNDREDANDSEVENTYTWO
Output
-1
Input
??????????????????????????
Output
MNBVCXZLKJHGFDSAQPWOEIRUYT
Input
AABCDEFGHIJKLMNOPQRSTUVW??M
Output
-1
Note
In the first sample case, ABCDEFGHIJKLMNOPQRZTUVWXYS is a valid answer beacuse it contains a substring of length 26 (the whole string in this case) which contains all the letters of the English alphabet exactly once. Note that there are many possible solutions, such as ABCDEFGHIJKLMNOPQRSTUVWXYZ or ABCEDFGHIJKLMNOPQRZTUVWXYS.
In the second sample case, there are no missing letters. In addition, the given string does not have a substring of length 26 that contains all the letters of the alphabet, so the answer is - 1.
In the third sample case, any string of length 26 that contains all letters of the English alphabet fits as an answer.
Submitted Solution:
```
fr = dict()
for order in range(ord('A'), ord('Z') + 1):
fr[chr(order)] = 0
s = list(input())
zeros = set([chr(order) for order in range(ord('A'), ord('Z') + 1)])
q_marks = set()
i = j = 0
answer_found = False
while j < len(s):
if s[j] == '?':
q_marks.add(j)
else:
fr[s[j]] += 1
if fr[s[j]] == 1:
zeros.remove(s[j])
if j - i + 1 == 26:
if len(zeros) == len(q_marks):
answer_found = True
break
if s[i] == '?':
q_marks.remove(i)
else:
fr[s[i]] -= 1
if fr[s[i]] == 0:
zeros.add(s[i])
i += 1
j += 1
if answer_found:
for k in range(0, i):
if s[k] == '?':
s[k] = 'A'
for k in range(j + 1, len(s)):
if s[k] == '?':
s[k] = 'A'
for index, char in zip(q_marks, sorted(zeros)):
s[index] = char
print("".join(s))
else:
print(-1)
``` | instruction | 0 | 33,026 | 18 | 66,052 |
Yes | output | 1 | 33,026 | 18 | 66,053 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
ZS the Coder loves to read the dictionary. He thinks that a word is nice if there exists a substring (contiguous segment of letters) of it of length 26 where each letter of English alphabet appears exactly once. In particular, if the string has length strictly less than 26, no such substring exists and thus it is not nice.
Now, ZS the Coder tells you a word, where some of its letters are missing as he forgot them. He wants to determine if it is possible to fill in the missing letters so that the resulting word is nice. If it is possible, he needs you to find an example of such a word as well. Can you help him?
Input
The first and only line of the input contains a single string s (1 ≤ |s| ≤ 50 000), the word that ZS the Coder remembers. Each character of the string is the uppercase letter of English alphabet ('A'-'Z') or is a question mark ('?'), where the question marks denotes the letters that ZS the Coder can't remember.
Output
If there is no way to replace all the question marks with uppercase letters such that the resulting word is nice, then print - 1 in the only line.
Otherwise, print a string which denotes a possible nice word that ZS the Coder learned. This string should match the string from the input, except for the question marks replaced with uppercase English letters.
If there are multiple solutions, you may print any of them.
Examples
Input
ABC??FGHIJK???OPQR?TUVWXY?
Output
ABCDEFGHIJKLMNOPQRZTUVWXYS
Input
WELCOMETOCODEFORCESROUNDTHREEHUNDREDANDSEVENTYTWO
Output
-1
Input
??????????????????????????
Output
MNBVCXZLKJHGFDSAQPWOEIRUYT
Input
AABCDEFGHIJKLMNOPQRSTUVW??M
Output
-1
Note
In the first sample case, ABCDEFGHIJKLMNOPQRZTUVWXYS is a valid answer beacuse it contains a substring of length 26 (the whole string in this case) which contains all the letters of the English alphabet exactly once. Note that there are many possible solutions, such as ABCDEFGHIJKLMNOPQRSTUVWXYZ or ABCEDFGHIJKLMNOPQRZTUVWXYS.
In the second sample case, there are no missing letters. In addition, the given string does not have a substring of length 26 that contains all the letters of the alphabet, so the answer is - 1.
In the third sample case, any string of length 26 that contains all letters of the English alphabet fits as an answer.
Submitted Solution:
```
s = input()
n = len(s)
if n < 26:
print(-1)
exit()
s = list(s)
j = 0
x = ord('A')
a = [0] * 26
while(j + 26 <= n):
flag = 1
for k in range(j , j + 26):
if(s[k] != '?'):
if(a[ord(s[k])-x] == 0):
a[ord(s[k])-x] = 1
else:
a = [0] * 26
j = j + 1
flag = 0
break
if flag == 1:
p = 0
for k in range(j,j+26):
if(s[k] == "?"):
while(a[p] != 0):
p += 1
s[k] = chr(x + p)
p += 1
for i in range(n):
if s[i] == "?":
s[i] = 'A'
print("".join(s))
exit()
print(-1)
``` | instruction | 0 | 33,027 | 18 | 66,054 |
Yes | output | 1 | 33,027 | 18 | 66,055 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
ZS the Coder loves to read the dictionary. He thinks that a word is nice if there exists a substring (contiguous segment of letters) of it of length 26 where each letter of English alphabet appears exactly once. In particular, if the string has length strictly less than 26, no such substring exists and thus it is not nice.
Now, ZS the Coder tells you a word, where some of its letters are missing as he forgot them. He wants to determine if it is possible to fill in the missing letters so that the resulting word is nice. If it is possible, he needs you to find an example of such a word as well. Can you help him?
Input
The first and only line of the input contains a single string s (1 ≤ |s| ≤ 50 000), the word that ZS the Coder remembers. Each character of the string is the uppercase letter of English alphabet ('A'-'Z') or is a question mark ('?'), where the question marks denotes the letters that ZS the Coder can't remember.
Output
If there is no way to replace all the question marks with uppercase letters such that the resulting word is nice, then print - 1 in the only line.
Otherwise, print a string which denotes a possible nice word that ZS the Coder learned. This string should match the string from the input, except for the question marks replaced with uppercase English letters.
If there are multiple solutions, you may print any of them.
Examples
Input
ABC??FGHIJK???OPQR?TUVWXY?
Output
ABCDEFGHIJKLMNOPQRZTUVWXYS
Input
WELCOMETOCODEFORCESROUNDTHREEHUNDREDANDSEVENTYTWO
Output
-1
Input
??????????????????????????
Output
MNBVCXZLKJHGFDSAQPWOEIRUYT
Input
AABCDEFGHIJKLMNOPQRSTUVW??M
Output
-1
Note
In the first sample case, ABCDEFGHIJKLMNOPQRZTUVWXYS is a valid answer beacuse it contains a substring of length 26 (the whole string in this case) which contains all the letters of the English alphabet exactly once. Note that there are many possible solutions, such as ABCDEFGHIJKLMNOPQRSTUVWXYZ or ABCEDFGHIJKLMNOPQRZTUVWXYS.
In the second sample case, there are no missing letters. In addition, the given string does not have a substring of length 26 that contains all the letters of the alphabet, so the answer is - 1.
In the third sample case, any string of length 26 that contains all letters of the English alphabet fits as an answer.
Submitted Solution:
```
import re
import collections
string=input()
string1 = re.findall('.', string)
check = "ABCDEFGHIJKLMNOPQRSTUVWXYZS"
check = re.findall ('.', check)
temp = ''
list1=[]
final="-1"
var=0
mid=''
front=''
end=''
if len(string) < 26:
print(-1)
elif string1.count('?') < 26 - len(set(string1)):
print(-1)
else:
for i in range(len(string)-25):
temp = re.findall('.', string[i:i+26])
if "?" in temp:
leng = len(set(temp)) -1
else:
leng = len(set(temp))
if temp.count("?") >= 26 - leng:
list1 = list(set(check) - set(temp))
for j in range(26):
if temp[j] == "?":
temp[j] = list1[var]
var+=1
for item in temp:
mid+=item
front=string[0:i].replace("?", "A")
end=string[i+26:len(string)+1].replace("?", "A")
final = front+mid+end
break
print(final)
``` | instruction | 0 | 33,028 | 18 | 66,056 |
Yes | output | 1 | 33,028 | 18 | 66,057 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
ZS the Coder loves to read the dictionary. He thinks that a word is nice if there exists a substring (contiguous segment of letters) of it of length 26 where each letter of English alphabet appears exactly once. In particular, if the string has length strictly less than 26, no such substring exists and thus it is not nice.
Now, ZS the Coder tells you a word, where some of its letters are missing as he forgot them. He wants to determine if it is possible to fill in the missing letters so that the resulting word is nice. If it is possible, he needs you to find an example of such a word as well. Can you help him?
Input
The first and only line of the input contains a single string s (1 ≤ |s| ≤ 50 000), the word that ZS the Coder remembers. Each character of the string is the uppercase letter of English alphabet ('A'-'Z') or is a question mark ('?'), where the question marks denotes the letters that ZS the Coder can't remember.
Output
If there is no way to replace all the question marks with uppercase letters such that the resulting word is nice, then print - 1 in the only line.
Otherwise, print a string which denotes a possible nice word that ZS the Coder learned. This string should match the string from the input, except for the question marks replaced with uppercase English letters.
If there are multiple solutions, you may print any of them.
Examples
Input
ABC??FGHIJK???OPQR?TUVWXY?
Output
ABCDEFGHIJKLMNOPQRZTUVWXYS
Input
WELCOMETOCODEFORCESROUNDTHREEHUNDREDANDSEVENTYTWO
Output
-1
Input
??????????????????????????
Output
MNBVCXZLKJHGFDSAQPWOEIRUYT
Input
AABCDEFGHIJKLMNOPQRSTUVW??M
Output
-1
Note
In the first sample case, ABCDEFGHIJKLMNOPQRZTUVWXYS is a valid answer beacuse it contains a substring of length 26 (the whole string in this case) which contains all the letters of the English alphabet exactly once. Note that there are many possible solutions, such as ABCDEFGHIJKLMNOPQRSTUVWXYZ or ABCEDFGHIJKLMNOPQRZTUVWXYS.
In the second sample case, there are no missing letters. In addition, the given string does not have a substring of length 26 that contains all the letters of the alphabet, so the answer is - 1.
In the third sample case, any string of length 26 that contains all letters of the English alphabet fits as an answer.
Submitted Solution:
```
import collections
def solve(word):
dictionary = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
freq = collections.defaultdict(int)
if len(word) < 26:
return - 1
n = len(word)
flag = False
for i in range(n - 26 + 1):
for j in range(i, i + 26):
if word[j] != '?':
freq[word[j]] += 1
if all(freq[c] <= 1 for c in dictionary):
for j in range(i, i + 26):
temp = word[i: i + 26]
if word[j] == '?':
for c in dictionary:
if c not in temp:
word[j] = c
flag = True
break
freq = collections.defaultdict(int)
if flag:
for i in range(len(word)):
if word[i] == '?':
word[i] = 'S'
return ''.join(word)
else:
return -1
if __name__ == "__main__":
word = str(input())
word = list(word)
print(solve(word))
``` | instruction | 0 | 33,029 | 18 | 66,058 |
Yes | output | 1 | 33,029 | 18 | 66,059 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
ZS the Coder loves to read the dictionary. He thinks that a word is nice if there exists a substring (contiguous segment of letters) of it of length 26 where each letter of English alphabet appears exactly once. In particular, if the string has length strictly less than 26, no such substring exists and thus it is not nice.
Now, ZS the Coder tells you a word, where some of its letters are missing as he forgot them. He wants to determine if it is possible to fill in the missing letters so that the resulting word is nice. If it is possible, he needs you to find an example of such a word as well. Can you help him?
Input
The first and only line of the input contains a single string s (1 ≤ |s| ≤ 50 000), the word that ZS the Coder remembers. Each character of the string is the uppercase letter of English alphabet ('A'-'Z') or is a question mark ('?'), where the question marks denotes the letters that ZS the Coder can't remember.
Output
If there is no way to replace all the question marks with uppercase letters such that the resulting word is nice, then print - 1 in the only line.
Otherwise, print a string which denotes a possible nice word that ZS the Coder learned. This string should match the string from the input, except for the question marks replaced with uppercase English letters.
If there are multiple solutions, you may print any of them.
Examples
Input
ABC??FGHIJK???OPQR?TUVWXY?
Output
ABCDEFGHIJKLMNOPQRZTUVWXYS
Input
WELCOMETOCODEFORCESROUNDTHREEHUNDREDANDSEVENTYTWO
Output
-1
Input
??????????????????????????
Output
MNBVCXZLKJHGFDSAQPWOEIRUYT
Input
AABCDEFGHIJKLMNOPQRSTUVW??M
Output
-1
Note
In the first sample case, ABCDEFGHIJKLMNOPQRZTUVWXYS is a valid answer beacuse it contains a substring of length 26 (the whole string in this case) which contains all the letters of the English alphabet exactly once. Note that there are many possible solutions, such as ABCDEFGHIJKLMNOPQRSTUVWXYZ or ABCEDFGHIJKLMNOPQRZTUVWXYS.
In the second sample case, there are no missing letters. In addition, the given string does not have a substring of length 26 that contains all the letters of the alphabet, so the answer is - 1.
In the third sample case, any string of length 26 that contains all letters of the English alphabet fits as an answer.
Submitted Solution:
```
s=input()
lettersUsed=set()
toBeUsed={"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"}
numberBlanks=0
for i in range(len(s)):
if not s[i] in lettersUsed and s[i]!="?":
lettersUsed|={s[i]}
toBeUsed.remove(s[i])
if s[i]=="?":
numberBlanks+=1
if len(lettersUsed)+numberBlanks<26:
print("-1")
else:
for i in range(len(s)):
if s[i]!="?":
print(s[i],end="")
else:
if len(toBeUsed)!=0:
print(toBeUsed.pop(),end="")
else:
print("A",end="")
``` | instruction | 0 | 33,030 | 18 | 66,060 |
No | output | 1 | 33,030 | 18 | 66,061 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
ZS the Coder loves to read the dictionary. He thinks that a word is nice if there exists a substring (contiguous segment of letters) of it of length 26 where each letter of English alphabet appears exactly once. In particular, if the string has length strictly less than 26, no such substring exists and thus it is not nice.
Now, ZS the Coder tells you a word, where some of its letters are missing as he forgot them. He wants to determine if it is possible to fill in the missing letters so that the resulting word is nice. If it is possible, he needs you to find an example of such a word as well. Can you help him?
Input
The first and only line of the input contains a single string s (1 ≤ |s| ≤ 50 000), the word that ZS the Coder remembers. Each character of the string is the uppercase letter of English alphabet ('A'-'Z') or is a question mark ('?'), where the question marks denotes the letters that ZS the Coder can't remember.
Output
If there is no way to replace all the question marks with uppercase letters such that the resulting word is nice, then print - 1 in the only line.
Otherwise, print a string which denotes a possible nice word that ZS the Coder learned. This string should match the string from the input, except for the question marks replaced with uppercase English letters.
If there are multiple solutions, you may print any of them.
Examples
Input
ABC??FGHIJK???OPQR?TUVWXY?
Output
ABCDEFGHIJKLMNOPQRZTUVWXYS
Input
WELCOMETOCODEFORCESROUNDTHREEHUNDREDANDSEVENTYTWO
Output
-1
Input
??????????????????????????
Output
MNBVCXZLKJHGFDSAQPWOEIRUYT
Input
AABCDEFGHIJKLMNOPQRSTUVW??M
Output
-1
Note
In the first sample case, ABCDEFGHIJKLMNOPQRZTUVWXYS is a valid answer beacuse it contains a substring of length 26 (the whole string in this case) which contains all the letters of the English alphabet exactly once. Note that there are many possible solutions, such as ABCDEFGHIJKLMNOPQRSTUVWXYZ or ABCEDFGHIJKLMNOPQRZTUVWXYS.
In the second sample case, there are no missing letters. In addition, the given string does not have a substring of length 26 that contains all the letters of the alphabet, so the answer is - 1.
In the third sample case, any string of length 26 that contains all letters of the English alphabet fits as an answer.
Submitted Solution:
```
a = list(input())
count = [0 for _ in range(26)]
avilable = [0 for _ in range(26)]
miss =[]
temp = []
l = -1
r = -1
check = 0
if len(a)<26:
print(-1)
else:
undefind = 0
for i in range(26):
if a[i] =='?':
undefind +=1
miss.append(i)
else:
count[ord(a[i])-65] += 1
avilable[ord(a[i])-65] = 1
if sum(avilable) + len(miss)== 26:
check = 1
l = 0
r = 26
temp = miss[::]
idex = 0
if len(a) > 26:
for i in range(26, len(a)):
if not check:
if a[idex] == '?':
miss.pop(0)
a[idex] = 'A'
else:
count[ord(a[i]) - 65] -= 1
if count[ord(a[i]) - 65] < 1:
avilable[ord(a[i]) - 65] = 0
if a[i] == '?':
miss.append(i)
else:
count[ord(a[i]) - 65] += 1
avilable[ord(a[i]) - 65] = 1
idex += 1
if sum(avilable) + len(miss) == 26:
check = 1
l = idex
r = i
temp = miss[::]
else:
if a[i] == '?':
a[i] = 'A'
if check:
for i in range(26):
if avilable[i] == 0:
a[temp.pop(0)] = chr(i + 65)
print(''.join(a))
else:
print(-1)
``` | instruction | 0 | 33,031 | 18 | 66,062 |
No | output | 1 | 33,031 | 18 | 66,063 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
ZS the Coder loves to read the dictionary. He thinks that a word is nice if there exists a substring (contiguous segment of letters) of it of length 26 where each letter of English alphabet appears exactly once. In particular, if the string has length strictly less than 26, no such substring exists and thus it is not nice.
Now, ZS the Coder tells you a word, where some of its letters are missing as he forgot them. He wants to determine if it is possible to fill in the missing letters so that the resulting word is nice. If it is possible, he needs you to find an example of such a word as well. Can you help him?
Input
The first and only line of the input contains a single string s (1 ≤ |s| ≤ 50 000), the word that ZS the Coder remembers. Each character of the string is the uppercase letter of English alphabet ('A'-'Z') or is a question mark ('?'), where the question marks denotes the letters that ZS the Coder can't remember.
Output
If there is no way to replace all the question marks with uppercase letters such that the resulting word is nice, then print - 1 in the only line.
Otherwise, print a string which denotes a possible nice word that ZS the Coder learned. This string should match the string from the input, except for the question marks replaced with uppercase English letters.
If there are multiple solutions, you may print any of them.
Examples
Input
ABC??FGHIJK???OPQR?TUVWXY?
Output
ABCDEFGHIJKLMNOPQRZTUVWXYS
Input
WELCOMETOCODEFORCESROUNDTHREEHUNDREDANDSEVENTYTWO
Output
-1
Input
??????????????????????????
Output
MNBVCXZLKJHGFDSAQPWOEIRUYT
Input
AABCDEFGHIJKLMNOPQRSTUVW??M
Output
-1
Note
In the first sample case, ABCDEFGHIJKLMNOPQRZTUVWXYS is a valid answer beacuse it contains a substring of length 26 (the whole string in this case) which contains all the letters of the English alphabet exactly once. Note that there are many possible solutions, such as ABCDEFGHIJKLMNOPQRSTUVWXYZ or ABCEDFGHIJKLMNOPQRZTUVWXYS.
In the second sample case, there are no missing letters. In addition, the given string does not have a substring of length 26 that contains all the letters of the alphabet, so the answer is - 1.
In the third sample case, any string of length 26 that contains all letters of the English alphabet fits as an answer.
Submitted Solution:
```
word = input()
occurrences = [0 for i in range(26)]
question_marks_count = 0
def fill_substring(word):
available_chars = {ord(char) for char in word if char != '?'}
unavailable_chars = {i for i in range(ord('A'), ord('Z') + 1)} - available_chars
return ''.join([char if char != '?' else chr(unavailable_chars.pop()) for char in word])
def fill_with_A(word):
return ''.join([char if char != '?' else 'A' for char in word])
if len(word) < 26:
print(-1)
else:
for char in word[:26]:
if char == '?':
question_marks_count += 1
else:
occurrences[ord(char) - 65] += 1
if occurrences[ord(char) - 65] == 1:
question_marks_count += 1
if question_marks_count == 26:
print(fill_substring(word[:26] + fill_with_A(word[26:])))
exit()
for i in range(26, len(word)):
char_to_remove = word[i - 26]
char_to_add = word[i]
if char_to_remove == '?':
question_marks_count -= 1
else:
occurrences[ord(char_to_remove) - 65] -= 1
if occurrences[ord(char_to_remove) - 65] == 0:
question_marks_count -= 1
if char_to_add == '?':
question_marks_count += 1
else:
occurrences[ord(char_to_add) - 65] += 1
if occurrences[ord(char_to_add) - 65] == 1:
question_marks_count += 1
if question_marks_count == 26:
print(fill_with_A(word[:i - 26]) + fill_substring(word[i - 26: i]) + fill_with_A(word[i:]))
exit()
print(-1)
``` | instruction | 0 | 33,032 | 18 | 66,064 |
No | output | 1 | 33,032 | 18 | 66,065 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
ZS the Coder loves to read the dictionary. He thinks that a word is nice if there exists a substring (contiguous segment of letters) of it of length 26 where each letter of English alphabet appears exactly once. In particular, if the string has length strictly less than 26, no such substring exists and thus it is not nice.
Now, ZS the Coder tells you a word, where some of its letters are missing as he forgot them. He wants to determine if it is possible to fill in the missing letters so that the resulting word is nice. If it is possible, he needs you to find an example of such a word as well. Can you help him?
Input
The first and only line of the input contains a single string s (1 ≤ |s| ≤ 50 000), the word that ZS the Coder remembers. Each character of the string is the uppercase letter of English alphabet ('A'-'Z') or is a question mark ('?'), where the question marks denotes the letters that ZS the Coder can't remember.
Output
If there is no way to replace all the question marks with uppercase letters such that the resulting word is nice, then print - 1 in the only line.
Otherwise, print a string which denotes a possible nice word that ZS the Coder learned. This string should match the string from the input, except for the question marks replaced with uppercase English letters.
If there are multiple solutions, you may print any of them.
Examples
Input
ABC??FGHIJK???OPQR?TUVWXY?
Output
ABCDEFGHIJKLMNOPQRZTUVWXYS
Input
WELCOMETOCODEFORCESROUNDTHREEHUNDREDANDSEVENTYTWO
Output
-1
Input
??????????????????????????
Output
MNBVCXZLKJHGFDSAQPWOEIRUYT
Input
AABCDEFGHIJKLMNOPQRSTUVW??M
Output
-1
Note
In the first sample case, ABCDEFGHIJKLMNOPQRZTUVWXYS is a valid answer beacuse it contains a substring of length 26 (the whole string in this case) which contains all the letters of the English alphabet exactly once. Note that there are many possible solutions, such as ABCDEFGHIJKLMNOPQRSTUVWXYZ or ABCEDFGHIJKLMNOPQRZTUVWXYS.
In the second sample case, there are no missing letters. In addition, the given string does not have a substring of length 26 that contains all the letters of the alphabet, so the answer is - 1.
In the third sample case, any string of length 26 that contains all letters of the English alphabet fits as an answer.
Submitted Solution:
```
s = input()
latin = set("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
if len(s)<26:
print(-1)
else:
mult = set(s)
mult.discard('?')
length_mlt = len(mult)
if length_mlt==26:
print(s)
else:
if s.count('?')>=(26-length_mlt):
diff = list(latin.difference(mult))
length_diff = len(diff)-1
k = -1
for i in s:
if i=='?':
if k!=length_diff:
k+=1
print(diff[k],end='')
else:
print('A',end='')
else:
print(i,end='')
else:
print(-1)
``` | instruction | 0 | 33,033 | 18 | 66,066 |
No | output | 1 | 33,033 | 18 | 66,067 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string S of length N consisting of lowercase English letters. We will cut this string at one position into two strings X and Y. Here, we would like to maximize the number of different letters contained in both X and Y. Find the largest possible number of different letters contained in both X and Y when we cut the string at the optimal position.
Constraints
* 2 \leq N \leq 100
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the largest possible number of different letters contained in both X and Y.
Examples
Input
6
aabbca
Output
2
Input
10
aaaaaaaaaa
Output
1
Input
45
tgxgdqkyjzhyputjjtllptdfxocrylqfqjynmfbfucbir
Output
9
Submitted Solution:
```
N = int(input())
S = input()
R = -1
for n in range(1, N):
R = max(len(set(S[:n]) & set(S[n:])), R)
print(R)
``` | instruction | 0 | 33,191 | 18 | 66,382 |
Yes | output | 1 | 33,191 | 18 | 66,383 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string S of length N consisting of lowercase English letters. We will cut this string at one position into two strings X and Y. Here, we would like to maximize the number of different letters contained in both X and Y. Find the largest possible number of different letters contained in both X and Y when we cut the string at the optimal position.
Constraints
* 2 \leq N \leq 100
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the largest possible number of different letters contained in both X and Y.
Examples
Input
6
aabbca
Output
2
Input
10
aaaaaaaaaa
Output
1
Input
45
tgxgdqkyjzhyputjjtllptdfxocrylqfqjynmfbfucbir
Output
9
Submitted Solution:
```
n = int(input())
s = input()
ans = max(len(set(s[:i]) & set(s[i:])) for i in range(1, n))
print(ans)
``` | instruction | 0 | 33,192 | 18 | 66,384 |
Yes | output | 1 | 33,192 | 18 | 66,385 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string S of length N consisting of lowercase English letters. We will cut this string at one position into two strings X and Y. Here, we would like to maximize the number of different letters contained in both X and Y. Find the largest possible number of different letters contained in both X and Y when we cut the string at the optimal position.
Constraints
* 2 \leq N \leq 100
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the largest possible number of different letters contained in both X and Y.
Examples
Input
6
aabbca
Output
2
Input
10
aaaaaaaaaa
Output
1
Input
45
tgxgdqkyjzhyputjjtllptdfxocrylqfqjynmfbfucbir
Output
9
Submitted Solution:
```
n = int(input())
st = input()
l = []
for i in range(n+1):
l.append(len(set(st[:i]) & set(st[i:])))
print(max(l))
``` | instruction | 0 | 33,193 | 18 | 66,386 |
Yes | output | 1 | 33,193 | 18 | 66,387 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string S of length N consisting of lowercase English letters. We will cut this string at one position into two strings X and Y. Here, we would like to maximize the number of different letters contained in both X and Y. Find the largest possible number of different letters contained in both X and Y when we cut the string at the optimal position.
Constraints
* 2 \leq N \leq 100
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the largest possible number of different letters contained in both X and Y.
Examples
Input
6
aabbca
Output
2
Input
10
aaaaaaaaaa
Output
1
Input
45
tgxgdqkyjzhyputjjtllptdfxocrylqfqjynmfbfucbir
Output
9
Submitted Solution:
```
N = int(input())
S=input()
a=0
for i in range(1,N-1):
a=max(a,len(set(S[:i])&set(S[i:])))
print(a)
``` | instruction | 0 | 33,194 | 18 | 66,388 |
Yes | output | 1 | 33,194 | 18 | 66,389 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string S of length N consisting of lowercase English letters. We will cut this string at one position into two strings X and Y. Here, we would like to maximize the number of different letters contained in both X and Y. Find the largest possible number of different letters contained in both X and Y when we cut the string at the optimal position.
Constraints
* 2 \leq N \leq 100
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the largest possible number of different letters contained in both X and Y.
Examples
Input
6
aabbca
Output
2
Input
10
aaaaaaaaaa
Output
1
Input
45
tgxgdqkyjzhyputjjtllptdfxocrylqfqjynmfbfucbir
Output
9
Submitted Solution:
```
n=int(input())
s=input()
c=0
for i in range(1,N):
x=set(s[:i])
y=set(s[i:])
a = len(x & y)
if a > c:
c = a
print(c)
``` | instruction | 0 | 33,195 | 18 | 66,390 |
No | output | 1 | 33,195 | 18 | 66,391 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string S of length N consisting of lowercase English letters. We will cut this string at one position into two strings X and Y. Here, we would like to maximize the number of different letters contained in both X and Y. Find the largest possible number of different letters contained in both X and Y when we cut the string at the optimal position.
Constraints
* 2 \leq N \leq 100
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the largest possible number of different letters contained in both X and Y.
Examples
Input
6
aabbca
Output
2
Input
10
aaaaaaaaaa
Output
1
Input
45
tgxgdqkyjzhyputjjtllptdfxocrylqfqjynmfbfucbir
Output
9
Submitted Solution:
```
N = int(input())
S = input()
s_list = list(set(S))
n_list = []
for i in range(1, N - 2):
line1 = S[:i]
line2 = S[i:]
num = 0
for c in s_list:
_1 = line1.count(c)
_2 = line2.count(c)
if (_1 > 0 and _2 > 0):
num += 1
n_list.append(num)
print(max(n_list))
``` | instruction | 0 | 33,196 | 18 | 66,392 |
No | output | 1 | 33,196 | 18 | 66,393 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string S of length N consisting of lowercase English letters. We will cut this string at one position into two strings X and Y. Here, we would like to maximize the number of different letters contained in both X and Y. Find the largest possible number of different letters contained in both X and Y when we cut the string at the optimal position.
Constraints
* 2 \leq N \leq 100
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the largest possible number of different letters contained in both X and Y.
Examples
Input
6
aabbca
Output
2
Input
10
aaaaaaaaaa
Output
1
Input
45
tgxgdqkyjzhyputjjtllptdfxocrylqfqjynmfbfucbir
Output
9
Submitted Solution:
```
N = int(input())
S = input()
z = []
for i in range(1,N):
x = S[:i]
y = S[i:]
if set(x) & set(y):
z.append(len(set(x)&set(y)))
else:
continue
print(max(z))
``` | instruction | 0 | 33,197 | 18 | 66,394 |
No | output | 1 | 33,197 | 18 | 66,395 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string S of length N consisting of lowercase English letters. We will cut this string at one position into two strings X and Y. Here, we would like to maximize the number of different letters contained in both X and Y. Find the largest possible number of different letters contained in both X and Y when we cut the string at the optimal position.
Constraints
* 2 \leq N \leq 100
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the largest possible number of different letters contained in both X and Y.
Examples
Input
6
aabbca
Output
2
Input
10
aaaaaaaaaa
Output
1
Input
45
tgxgdqkyjzhyputjjtllptdfxocrylqfqjynmfbfucbir
Output
9
Submitted Solution:
```
N = int(input())
s = str(input())
types = []
for i in range(len(s)-1):
x = s[:i]
y = s[i:]
x.sort()
y.sort()
x_str = []
y_str = []
x_str.append(x[0])
y_str.append(y[0])
count = 0
for i in range(1,len(x)):
if x[i-1] != x[i]:
x_str.append(x[i])
for i in range(1,len(y)):
if y[i-1] != y[i]:
y_str.append(y[i])
for i in range(len(x_str)):
if x_str[i] in y_str:
count += 1
types.append(count)
print(max(types))
``` | instruction | 0 | 33,198 | 18 | 66,396 |
No | output | 1 | 33,198 | 18 | 66,397 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
You can preview the image in better quality by the link: [http://assets.codeforces.com/files/656/without-text.png](//assets.codeforces.com/files/656/without-text.png)
Input
The only line of the input is a string (between 1 and 50 characters long, inclusive). Each character will be an alphanumeric character or a full stop ".".
Output
Output the required answer.
Examples
Input
Codeforces
Output
-87
Input
APRIL.1st
Output
17
Submitted Solution:
```
result = 0
for i, x in enumerate(input()):
compare_1 = '@' < x
compare_2 = '[' > x
compare_3 = '`' < x
compare_4 = '{' > x
and_1 = compare_1 and compare_2
and_2 = compare_3 and compare_4
alphabet_index = ord(x.lower()) - ord("a") + 1
times_1 = int(and_1) * alphabet_index
times_2 = alphabet_index * int(and_2)
minus = times_1 - times_2
result += minus
print(result)
``` | instruction | 0 | 33,851 | 18 | 67,702 |
Yes | output | 1 | 33,851 | 18 | 67,703 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
You can preview the image in better quality by the link: [http://assets.codeforces.com/files/656/without-text.png](//assets.codeforces.com/files/656/without-text.png)
Input
The only line of the input is a string (between 1 and 50 characters long, inclusive). Each character will be an alphanumeric character or a full stop ".".
Output
Output the required answer.
Examples
Input
Codeforces
Output
-87
Input
APRIL.1st
Output
17
Submitted Solution:
```
# coding: utf-8
s = input()
answer = 0
for c in s:
if c.isupper():
answer += ord(c) - ord('A') + 1
elif c.islower():
answer -= ord(c) - ord('a') + 1
print(answer)
``` | instruction | 0 | 33,852 | 18 | 67,704 |
Yes | output | 1 | 33,852 | 18 | 67,705 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
You can preview the image in better quality by the link: [http://assets.codeforces.com/files/656/without-text.png](//assets.codeforces.com/files/656/without-text.png)
Input
The only line of the input is a string (between 1 and 50 characters long, inclusive). Each character will be an alphanumeric character or a full stop ".".
Output
Output the required answer.
Examples
Input
Codeforces
Output
-87
Input
APRIL.1st
Output
17
Submitted Solution:
```
s = input()
answer = 0
for c in s:
if 'A' <= c <= 'Z':
answer += ord(c) - ord('A') + 1
elif 'a' <= c <= 'z':
answer -= ord(c) - ord('a') + 1
print(answer)
``` | instruction | 0 | 33,853 | 18 | 67,706 |
Yes | output | 1 | 33,853 | 18 | 67,707 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
You can preview the image in better quality by the link: [http://assets.codeforces.com/files/656/without-text.png](//assets.codeforces.com/files/656/without-text.png)
Input
The only line of the input is a string (between 1 and 50 characters long, inclusive). Each character will be an alphanumeric character or a full stop ".".
Output
Output the required answer.
Examples
Input
Codeforces
Output
-87
Input
APRIL.1st
Output
17
Submitted Solution:
```
print(sum(map(lambda x:96-x if x>96 else x-64,map(ord,filter(str.isalpha,input())))))
# Made By Mostafa_Khaled
``` | instruction | 0 | 33,854 | 18 | 67,708 |
Yes | output | 1 | 33,854 | 18 | 67,709 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
You can preview the image in better quality by the link: [http://assets.codeforces.com/files/656/without-text.png](//assets.codeforces.com/files/656/without-text.png)
Input
The only line of the input is a string (between 1 and 50 characters long, inclusive). Each character will be an alphanumeric character or a full stop ".".
Output
Output the required answer.
Examples
Input
Codeforces
Output
-87
Input
APRIL.1st
Output
17
Submitted Solution:
```
string = input()
print(string)
``` | instruction | 0 | 33,855 | 18 | 67,710 |
No | output | 1 | 33,855 | 18 | 67,711 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
You can preview the image in better quality by the link: [http://assets.codeforces.com/files/656/without-text.png](//assets.codeforces.com/files/656/without-text.png)
Input
The only line of the input is a string (between 1 and 50 characters long, inclusive). Each character will be an alphanumeric character or a full stop ".".
Output
Output the required answer.
Examples
Input
Codeforces
Output
-87
Input
APRIL.1st
Output
17
Submitted Solution:
```
print('Lol k.')
``` | instruction | 0 | 33,856 | 18 | 67,712 |
No | output | 1 | 33,856 | 18 | 67,713 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
You can preview the image in better quality by the link: [http://assets.codeforces.com/files/656/without-text.png](//assets.codeforces.com/files/656/without-text.png)
Input
The only line of the input is a string (between 1 and 50 characters long, inclusive). Each character will be an alphanumeric character or a full stop ".".
Output
Output the required answer.
Examples
Input
Codeforces
Output
-87
Input
APRIL.1st
Output
17
Submitted Solution:
```
s = input()
res = 0
for i in s:
if i.islower():
res -= ord(i) - ord("a") + 1
else:
res += ord(i) - ord("A") + 1
print(res)
``` | instruction | 0 | 33,857 | 18 | 67,714 |
No | output | 1 | 33,857 | 18 | 67,715 |
Provide a correct Python 3 solution for this coding contest problem.
You are given strings S and T consisting of lowercase English letters.
You can perform the following operation on S any number of times:
Operation: Choose two distinct lowercase English letters c_1 and c_2, then replace every occurrence of c_1 with c_2, and every occurrence of c_2 with c_1.
Determine if S and T can be made equal by performing the operation zero or more times.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* |S| = |T|
* S and T consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S and T can be made equal, print `Yes`; otherwise, print `No`.
Examples
Input
azzel
apple
Output
Yes
Input
chokudai
redcoder
Output
No
Input
abcdefghijklmnopqrstuvwxyz
ibyhqfrekavclxjstdwgpzmonu
Output
Yes | instruction | 0 | 34,082 | 18 | 68,164 |
"Correct Solution:
```
from collections import Counter
s1 = sorted(list(dict(Counter(input())).values()))
t1 = sorted(list(dict(Counter(input())).values()))
print(['No', 'Yes'][s1 == t1])
``` | output | 1 | 34,082 | 18 | 68,165 |
Provide a correct Python 3 solution for this coding contest problem.
You are given strings S and T consisting of lowercase English letters.
You can perform the following operation on S any number of times:
Operation: Choose two distinct lowercase English letters c_1 and c_2, then replace every occurrence of c_1 with c_2, and every occurrence of c_2 with c_1.
Determine if S and T can be made equal by performing the operation zero or more times.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* |S| = |T|
* S and T consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S and T can be made equal, print `Yes`; otherwise, print `No`.
Examples
Input
azzel
apple
Output
Yes
Input
chokudai
redcoder
Output
No
Input
abcdefghijklmnopqrstuvwxyz
ibyhqfrekavclxjstdwgpzmonu
Output
Yes | instruction | 0 | 34,083 | 18 | 68,166 |
"Correct Solution:
```
S = input()
T = input()
s = []
t = []
for alp in "abcdefghijklmnopqrstuvwxyz":
s.append(S.count(alp))
t.append(T.count(alp))
if(sorted(s) == sorted(t)):
print("Yes")
else:
print("No")
``` | output | 1 | 34,083 | 18 | 68,167 |
Provide a correct Python 3 solution for this coding contest problem.
You are given strings S and T consisting of lowercase English letters.
You can perform the following operation on S any number of times:
Operation: Choose two distinct lowercase English letters c_1 and c_2, then replace every occurrence of c_1 with c_2, and every occurrence of c_2 with c_1.
Determine if S and T can be made equal by performing the operation zero or more times.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* |S| = |T|
* S and T consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S and T can be made equal, print `Yes`; otherwise, print `No`.
Examples
Input
azzel
apple
Output
Yes
Input
chokudai
redcoder
Output
No
Input
abcdefghijklmnopqrstuvwxyz
ibyhqfrekavclxjstdwgpzmonu
Output
Yes | instruction | 0 | 34,084 | 18 | 68,168 |
"Correct Solution:
```
#!/usr/bin/env python3
from collections import Counter
x = lambda : sorted(Counter(input()).values())
print('YNeos'[x()!=x()::2])
``` | output | 1 | 34,084 | 18 | 68,169 |
Provide a correct Python 3 solution for this coding contest problem.
You are given strings S and T consisting of lowercase English letters.
You can perform the following operation on S any number of times:
Operation: Choose two distinct lowercase English letters c_1 and c_2, then replace every occurrence of c_1 with c_2, and every occurrence of c_2 with c_1.
Determine if S and T can be made equal by performing the operation zero or more times.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* |S| = |T|
* S and T consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S and T can be made equal, print `Yes`; otherwise, print `No`.
Examples
Input
azzel
apple
Output
Yes
Input
chokudai
redcoder
Output
No
Input
abcdefghijklmnopqrstuvwxyz
ibyhqfrekavclxjstdwgpzmonu
Output
Yes | instruction | 0 | 34,085 | 18 | 68,170 |
"Correct Solution:
```
s = input()
t = input()
sn=[0 for i in range(26)]
tn=[0 for i in range(26)]
for i in range(len(s)):
sn[ord(s[i])-ord('a')]+=1
tn[ord(t[i])-ord('a')]+=1
print('Yes' if sorted(sn) == sorted(tn) else 'No')
``` | output | 1 | 34,085 | 18 | 68,171 |
Provide a correct Python 3 solution for this coding contest problem.
You are given strings S and T consisting of lowercase English letters.
You can perform the following operation on S any number of times:
Operation: Choose two distinct lowercase English letters c_1 and c_2, then replace every occurrence of c_1 with c_2, and every occurrence of c_2 with c_1.
Determine if S and T can be made equal by performing the operation zero or more times.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* |S| = |T|
* S and T consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S and T can be made equal, print `Yes`; otherwise, print `No`.
Examples
Input
azzel
apple
Output
Yes
Input
chokudai
redcoder
Output
No
Input
abcdefghijklmnopqrstuvwxyz
ibyhqfrekavclxjstdwgpzmonu
Output
Yes | instruction | 0 | 34,086 | 18 | 68,172 |
"Correct Solution:
```
from collections import Counter
S = input()
T = input()
scnt = sorted(list(Counter(S).values()))
tcnt = sorted(list(Counter(T).values()))
print('Yes' if scnt == tcnt else 'No')
``` | output | 1 | 34,086 | 18 | 68,173 |
Provide a correct Python 3 solution for this coding contest problem.
You are given strings S and T consisting of lowercase English letters.
You can perform the following operation on S any number of times:
Operation: Choose two distinct lowercase English letters c_1 and c_2, then replace every occurrence of c_1 with c_2, and every occurrence of c_2 with c_1.
Determine if S and T can be made equal by performing the operation zero or more times.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* |S| = |T|
* S and T consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S and T can be made equal, print `Yes`; otherwise, print `No`.
Examples
Input
azzel
apple
Output
Yes
Input
chokudai
redcoder
Output
No
Input
abcdefghijklmnopqrstuvwxyz
ibyhqfrekavclxjstdwgpzmonu
Output
Yes | instruction | 0 | 34,087 | 18 | 68,174 |
"Correct Solution:
```
from collections import Counter
S = input()
T = input()
if sorted(Counter(S).values()) != sorted(Counter(T).values()):
print("No")
else:
print("Yes")
``` | output | 1 | 34,087 | 18 | 68,175 |
Provide a correct Python 3 solution for this coding contest problem.
You are given strings S and T consisting of lowercase English letters.
You can perform the following operation on S any number of times:
Operation: Choose two distinct lowercase English letters c_1 and c_2, then replace every occurrence of c_1 with c_2, and every occurrence of c_2 with c_1.
Determine if S and T can be made equal by performing the operation zero or more times.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* |S| = |T|
* S and T consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S and T can be made equal, print `Yes`; otherwise, print `No`.
Examples
Input
azzel
apple
Output
Yes
Input
chokudai
redcoder
Output
No
Input
abcdefghijklmnopqrstuvwxyz
ibyhqfrekavclxjstdwgpzmonu
Output
Yes | instruction | 0 | 34,088 | 18 | 68,176 |
"Correct Solution:
```
from collections import Counter
S = input()
T = input()
S = Counter(S)
T = Counter(T)
S = sorted(list(S.values()))
T = sorted(list(T.values()))
if S == T:
print('Yes')
else:
print('No')
``` | output | 1 | 34,088 | 18 | 68,177 |
Provide a correct Python 3 solution for this coding contest problem.
You are given strings S and T consisting of lowercase English letters.
You can perform the following operation on S any number of times:
Operation: Choose two distinct lowercase English letters c_1 and c_2, then replace every occurrence of c_1 with c_2, and every occurrence of c_2 with c_1.
Determine if S and T can be made equal by performing the operation zero or more times.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* |S| = |T|
* S and T consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S and T can be made equal, print `Yes`; otherwise, print `No`.
Examples
Input
azzel
apple
Output
Yes
Input
chokudai
redcoder
Output
No
Input
abcdefghijklmnopqrstuvwxyz
ibyhqfrekavclxjstdwgpzmonu
Output
Yes | instruction | 0 | 34,089 | 18 | 68,178 |
"Correct Solution:
```
s = list(input())
t = list(input())
s_len = len(set(s))
t_len = len(set(t))
pare = []
for i,j in zip(s,t):
pare.append(i+j)
if len(set(pare)) == s_len == t_len:
print('Yes')
else:
print('No')
``` | output | 1 | 34,089 | 18 | 68,179 |
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 can perform the following operation on S any number of times:
Operation: Choose two distinct lowercase English letters c_1 and c_2, then replace every occurrence of c_1 with c_2, and every occurrence of c_2 with c_1.
Determine if S and T can be made equal by performing the operation zero or more times.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* |S| = |T|
* S and T consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S and T can be made equal, print `Yes`; otherwise, print `No`.
Examples
Input
azzel
apple
Output
Yes
Input
chokudai
redcoder
Output
No
Input
abcdefghijklmnopqrstuvwxyz
ibyhqfrekavclxjstdwgpzmonu
Output
Yes
Submitted Solution:
```
from collections import Counter
s = input()
t = input()
s_count = Counter(s)
t_count = Counter(t)
if sorted(s_count.values()) == sorted(t_count.values()): print("Yes")
else: print("No")
``` | instruction | 0 | 34,090 | 18 | 68,180 |
Yes | output | 1 | 34,090 | 18 | 68,181 |
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 can perform the following operation on S any number of times:
Operation: Choose two distinct lowercase English letters c_1 and c_2, then replace every occurrence of c_1 with c_2, and every occurrence of c_2 with c_1.
Determine if S and T can be made equal by performing the operation zero or more times.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* |S| = |T|
* S and T consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S and T can be made equal, print `Yes`; otherwise, print `No`.
Examples
Input
azzel
apple
Output
Yes
Input
chokudai
redcoder
Output
No
Input
abcdefghijklmnopqrstuvwxyz
ibyhqfrekavclxjstdwgpzmonu
Output
Yes
Submitted Solution:
```
from collections import Counter
print("NYoe s"[sorted(list(Counter(input()).values()))==sorted(list(Counter(input()).values()))::2])
``` | instruction | 0 | 34,091 | 18 | 68,182 |
Yes | output | 1 | 34,091 | 18 | 68,183 |
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 can perform the following operation on S any number of times:
Operation: Choose two distinct lowercase English letters c_1 and c_2, then replace every occurrence of c_1 with c_2, and every occurrence of c_2 with c_1.
Determine if S and T can be made equal by performing the operation zero or more times.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* |S| = |T|
* S and T consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S and T can be made equal, print `Yes`; otherwise, print `No`.
Examples
Input
azzel
apple
Output
Yes
Input
chokudai
redcoder
Output
No
Input
abcdefghijklmnopqrstuvwxyz
ibyhqfrekavclxjstdwgpzmonu
Output
Yes
Submitted Solution:
```
s=input()
t=input()
ar1=[0]*26
ar2=[0]*26
for i in s:
ar1[ord(i)-97]+=1
for i in t:
ar2[ord(i)-97]+=1
ar1.sort()
ar2.sort()
if ar1==ar2:
print("Yes")
else:
print("No")
``` | instruction | 0 | 34,092 | 18 | 68,184 |
Yes | output | 1 | 34,092 | 18 | 68,185 |
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 can perform the following operation on S any number of times:
Operation: Choose two distinct lowercase English letters c_1 and c_2, then replace every occurrence of c_1 with c_2, and every occurrence of c_2 with c_1.
Determine if S and T can be made equal by performing the operation zero or more times.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* |S| = |T|
* S and T consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S and T can be made equal, print `Yes`; otherwise, print `No`.
Examples
Input
azzel
apple
Output
Yes
Input
chokudai
redcoder
Output
No
Input
abcdefghijklmnopqrstuvwxyz
ibyhqfrekavclxjstdwgpzmonu
Output
Yes
Submitted Solution:
```
aaa = input()
bbb = input()
d = {}
d_rev = {}
ans = 'Yes'
for a, b in zip(aaa, bbb):
if (a in d and d.get(a) != b) or (b in d_rev and d_rev.get(b) != a):
ans = 'No'
d[a] = b
d_rev[b] = a
print(ans)
``` | instruction | 0 | 34,093 | 18 | 68,186 |
Yes | output | 1 | 34,093 | 18 | 68,187 |
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 can perform the following operation on S any number of times:
Operation: Choose two distinct lowercase English letters c_1 and c_2, then replace every occurrence of c_1 with c_2, and every occurrence of c_2 with c_1.
Determine if S and T can be made equal by performing the operation zero or more times.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* |S| = |T|
* S and T consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S and T can be made equal, print `Yes`; otherwise, print `No`.
Examples
Input
azzel
apple
Output
Yes
Input
chokudai
redcoder
Output
No
Input
abcdefghijklmnopqrstuvwxyz
ibyhqfrekavclxjstdwgpzmonu
Output
Yes
Submitted Solution:
```
s = input()
t = input()
i = 0
his = []
length = len(s)
flag = True
for i in range(0, length-1):
ss = s[i:i+1]
tt = t[i:i+1]
if ss != tt:
if tt in his:
flag = False
break
else:
his.append(tt)
it1 = re.finditer(ss, s)
it2 = re.finditer(tt, s)
for match in it1:
s = s[:match.start()] + tt + s[match.end():]
for match in it2:
s = s[:match.start()] + ss + s[match.end():]
if flag:
print("Yes")
else:
print("No")
``` | instruction | 0 | 34,094 | 18 | 68,188 |
No | output | 1 | 34,094 | 18 | 68,189 |
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 can perform the following operation on S any number of times:
Operation: Choose two distinct lowercase English letters c_1 and c_2, then replace every occurrence of c_1 with c_2, and every occurrence of c_2 with c_1.
Determine if S and T can be made equal by performing the operation zero or more times.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* |S| = |T|
* S and T consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S and T can be made equal, print `Yes`; otherwise, print `No`.
Examples
Input
azzel
apple
Output
Yes
Input
chokudai
redcoder
Output
No
Input
abcdefghijklmnopqrstuvwxyz
ibyhqfrekavclxjstdwgpzmonu
Output
Yes
Submitted Solution:
```
import sys
def main():
input = sys.stdin.readline
S = str(input().strip())
T = str(input().strip())
for i in range(len(S)):
if S[i] == T[i]:
continue
else:
c1, c2 = S[i], T[i]
S = S.replace(c1, ' ')
S = S.replace(c2, c1)
S = S.replace(' ', c2)
if S == T:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main()
``` | instruction | 0 | 34,095 | 18 | 68,190 |
No | output | 1 | 34,095 | 18 | 68,191 |
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 can perform the following operation on S any number of times:
Operation: Choose two distinct lowercase English letters c_1 and c_2, then replace every occurrence of c_1 with c_2, and every occurrence of c_2 with c_1.
Determine if S and T can be made equal by performing the operation zero or more times.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* |S| = |T|
* S and T consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S and T can be made equal, print `Yes`; otherwise, print `No`.
Examples
Input
azzel
apple
Output
Yes
Input
chokudai
redcoder
Output
No
Input
abcdefghijklmnopqrstuvwxyz
ibyhqfrekavclxjstdwgpzmonu
Output
Yes
Submitted Solution:
```
S,T=input(),input()
if len(S)==1:
print('Yes')
else:
for i in range(len(S)-1):
for j in range(i+1,len(S)):
ans='Yes'
if (S[i]==S[j] and T[i]!=T[j]) or (S[i]!=S[j] and T[i]==T[j]):
ans='No'
if ans=='No':
break
if ans=='No':
break
print(ans)
``` | instruction | 0 | 34,096 | 18 | 68,192 |
No | output | 1 | 34,096 | 18 | 68,193 |
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 can perform the following operation on S any number of times:
Operation: Choose two distinct lowercase English letters c_1 and c_2, then replace every occurrence of c_1 with c_2, and every occurrence of c_2 with c_1.
Determine if S and T can be made equal by performing the operation zero or more times.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* |S| = |T|
* S and T consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S and T can be made equal, print `Yes`; otherwise, print `No`.
Examples
Input
azzel
apple
Output
Yes
Input
chokudai
redcoder
Output
No
Input
abcdefghijklmnopqrstuvwxyz
ibyhqfrekavclxjstdwgpzmonu
Output
Yes
Submitted Solution:
```
S = [c for c in input()]
T = [c for c in input()]
def main():
z = zip(S, T)
f = filter(lambda e: e[0] != e[1], z)
s = set(f)
unpacked = list(zip(*s))
ans = [len(set(t)) == len(t) for t in unpacked]
print('Yes' if all(ans) else 'No')
if __name__ == '__main__':
main()
``` | instruction | 0 | 34,097 | 18 | 68,194 |
No | output | 1 | 34,097 | 18 | 68,195 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.