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.
There is a string s of length 3 or greater. No two neighboring characters in s are equal.
Takahashi and Aoki will play a game against each other. The two players alternately performs the following operation, Takahashi going first:
* Remove one of the characters in s, excluding both ends. However, a character cannot be removed if removal of the character would result in two neighboring equal characters in s.
The player who becomes unable to perform the operation, loses the game. Determine which player will win when the two play optimally.
Constraints
* 3 ≤ |s| ≤ 10^5
* s consists of lowercase English letters.
* No two neighboring characters in s are equal.
Input
The input is given from Standard Input in the following format:
s
Output
If Takahashi will win, print `First`. If Aoki will win, print `Second`.
Examples
Input
aba
Output
Second
Input
abc
Output
First
Input
abcab
Output
First
Submitted Solution:
```
s = input()
n = len(s)
n -= 1
print(n)
if s[0] == s[n-1]:
print("First" if (n % 2 == 0) else "Second")
else:
print("First" if (n % 2 == 1) else "Second")
``` | instruction | 0 | 8,307 | 18 | 16,614 |
No | output | 1 | 8,307 | 18 | 16,615 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a string s of length 3 or greater. No two neighboring characters in s are equal.
Takahashi and Aoki will play a game against each other. The two players alternately performs the following operation, Takahashi going first:
* Remove one of the characters in s, excluding both ends. However, a character cannot be removed if removal of the character would result in two neighboring equal characters in s.
The player who becomes unable to perform the operation, loses the game. Determine which player will win when the two play optimally.
Constraints
* 3 ≤ |s| ≤ 10^5
* s consists of lowercase English letters.
* No two neighboring characters in s are equal.
Input
The input is given from Standard Input in the following format:
s
Output
If Takahashi will win, print `First`. If Aoki will win, print `Second`.
Examples
Input
aba
Output
Second
Input
abc
Output
First
Input
abcab
Output
First
Submitted Solution:
```
import sys
import numpy as np
def main():
s = input()
n = len(s)
if s[0] == s[n - 1] and n % 2 == 1:
print("Second")
else:
print("First")
main()
``` | instruction | 0 | 8,308 | 18 | 16,616 |
No | output | 1 | 8,308 | 18 | 16,617 |
Provide a correct Python 3 solution for this coding contest problem.
Twins
square1001 and E869120 are twins.
Please output the one that was born first.
input
No input is given.
output
Output the correct character string on one line.
However, insert a line break at the end.
Output example 1
square1001
Example
Input
Output | instruction | 0 | 8,360 | 18 | 16,720 |
"Correct Solution:
```
print('square1001')
``` | output | 1 | 8,360 | 18 | 16,721 |
Provide a correct Python 3 solution for this coding contest problem.
Twins
square1001 and E869120 are twins.
Please output the one that was born first.
input
No input is given.
output
Output the correct character string on one line.
However, insert a line break at the end.
Output example 1
square1001
Example
Input
Output | instruction | 0 | 8,361 | 18 | 16,722 |
"Correct Solution:
```
print("square1001")
``` | output | 1 | 8,361 | 18 | 16,723 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, a start up by two students of a state university of city F gained incredible popularity. Now it's time to start a new company. But what do we call it?
The market analysts came up with a very smart plan: the name of the company should be identical to its reflection in a mirror! In other words, if we write out the name of the company on a piece of paper in a line (horizontally, from left to right) with large English letters, then put this piece of paper in front of the mirror, then the reflection of the name in the mirror should perfectly match the line written on the piece of paper.
There are many suggestions for the company name, so coming up to the mirror with a piece of paper for each name wouldn't be sensible. The founders of the company decided to automatize this process. They asked you to write a program that can, given a word, determine whether the word is a 'mirror' word or not.
Input
The first line contains a non-empty name that needs to be checked. The name contains at most 105 large English letters. The name will be written with the next sans serif font:
<image>
Output
Print 'YES' (without the quotes), if the given name matches its mirror reflection. Otherwise, print 'NO' (without the quotes).
Examples
Input
AHA
Output
YES
Input
Z
Output
NO
Input
XO
Output
NO
Submitted Solution:
```
def isMirror(s):
x = s[::-1]
if(x != s):
return False
n = s.count('A') + s.count('H') + s.count('I') + s.count('M') + s.count('O') + s.count('T') + s.count('U') + s.count('V') + s.count('W') + s.count('X') + s.count('Y')
if(n != len(s)):
return False
return True
s = input()
if(isMirror(s) == True):
print('YES')
else:
print('NO')
``` | instruction | 0 | 8,650 | 18 | 17,300 |
Yes | output | 1 | 8,650 | 18 | 17,301 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, a start up by two students of a state university of city F gained incredible popularity. Now it's time to start a new company. But what do we call it?
The market analysts came up with a very smart plan: the name of the company should be identical to its reflection in a mirror! In other words, if we write out the name of the company on a piece of paper in a line (horizontally, from left to right) with large English letters, then put this piece of paper in front of the mirror, then the reflection of the name in the mirror should perfectly match the line written on the piece of paper.
There are many suggestions for the company name, so coming up to the mirror with a piece of paper for each name wouldn't be sensible. The founders of the company decided to automatize this process. They asked you to write a program that can, given a word, determine whether the word is a 'mirror' word or not.
Input
The first line contains a non-empty name that needs to be checked. The name contains at most 105 large English letters. The name will be written with the next sans serif font:
<image>
Output
Print 'YES' (without the quotes), if the given name matches its mirror reflection. Otherwise, print 'NO' (without the quotes).
Examples
Input
AHA
Output
YES
Input
Z
Output
NO
Input
XO
Output
NO
Submitted Solution:
```
import string
def is_palindrome(s):
for i in range(len(s) // 2):
k = len(s) - 1 - i
if s[i] != s[k]:
return False
return True
#
def main_function():
s = input()
is_answer_found = False
mirror_letter = ['B', 'C', 'D', 'E', 'F', 'G', 'J', 'K', 'L', 'N', 'P', 'Q', 'R', 'S', 'Z']
hash_table = [0 for i in range(150)]
if not is_palindrome(s):
print("NO")
else:
for i in s:
hash_table[ord(i)] += 1
for i in range(len(mirror_letter)):
order = ord(mirror_letter[i])
if hash_table[order] != 0:
print("NO")
is_answer_found = True
break
if not is_answer_found:
print("YES")
#
#
#
#
main_function()
``` | instruction | 0 | 8,651 | 18 | 17,302 |
Yes | output | 1 | 8,651 | 18 | 17,303 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, a start up by two students of a state university of city F gained incredible popularity. Now it's time to start a new company. But what do we call it?
The market analysts came up with a very smart plan: the name of the company should be identical to its reflection in a mirror! In other words, if we write out the name of the company on a piece of paper in a line (horizontally, from left to right) with large English letters, then put this piece of paper in front of the mirror, then the reflection of the name in the mirror should perfectly match the line written on the piece of paper.
There are many suggestions for the company name, so coming up to the mirror with a piece of paper for each name wouldn't be sensible. The founders of the company decided to automatize this process. They asked you to write a program that can, given a word, determine whether the word is a 'mirror' word or not.
Input
The first line contains a non-empty name that needs to be checked. The name contains at most 105 large English letters. The name will be written with the next sans serif font:
<image>
Output
Print 'YES' (without the quotes), if the given name matches its mirror reflection. Otherwise, print 'NO' (without the quotes).
Examples
Input
AHA
Output
YES
Input
Z
Output
NO
Input
XO
Output
NO
Submitted Solution:
```
def main():
name = input()
s = ('B', 'C', 'D', 'E', 'F', 'G', 'J', 'K', 'L', 'N', 'P', 'Q', 'R', 'S', 'Z')
for ch in s:
if ch in name:
print('NO')
return
if name[:len(name) // 2] != name[::-1][:len(name) // 2]:
print('NO')
return
print('YES')
main()
``` | instruction | 0 | 8,652 | 18 | 17,304 |
Yes | output | 1 | 8,652 | 18 | 17,305 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, a start up by two students of a state university of city F gained incredible popularity. Now it's time to start a new company. But what do we call it?
The market analysts came up with a very smart plan: the name of the company should be identical to its reflection in a mirror! In other words, if we write out the name of the company on a piece of paper in a line (horizontally, from left to right) with large English letters, then put this piece of paper in front of the mirror, then the reflection of the name in the mirror should perfectly match the line written on the piece of paper.
There are many suggestions for the company name, so coming up to the mirror with a piece of paper for each name wouldn't be sensible. The founders of the company decided to automatize this process. They asked you to write a program that can, given a word, determine whether the word is a 'mirror' word or not.
Input
The first line contains a non-empty name that needs to be checked. The name contains at most 105 large English letters. The name will be written with the next sans serif font:
<image>
Output
Print 'YES' (without the quotes), if the given name matches its mirror reflection. Otherwise, print 'NO' (without the quotes).
Examples
Input
AHA
Output
YES
Input
Z
Output
NO
Input
XO
Output
NO
Submitted Solution:
```
def isPalindrome(s):
return(s == s[::-1])
s=input()
l=['A','H','I','M','O','T','U','V','W','X','Y']
bool=[1 for i in s if i not in l]
if isPalindrome(s) and len(bool)==0:
print("YES")
else:
print("NO")
``` | instruction | 0 | 8,653 | 18 | 17,306 |
Yes | output | 1 | 8,653 | 18 | 17,307 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, a start up by two students of a state university of city F gained incredible popularity. Now it's time to start a new company. But what do we call it?
The market analysts came up with a very smart plan: the name of the company should be identical to its reflection in a mirror! In other words, if we write out the name of the company on a piece of paper in a line (horizontally, from left to right) with large English letters, then put this piece of paper in front of the mirror, then the reflection of the name in the mirror should perfectly match the line written on the piece of paper.
There are many suggestions for the company name, so coming up to the mirror with a piece of paper for each name wouldn't be sensible. The founders of the company decided to automatize this process. They asked you to write a program that can, given a word, determine whether the word is a 'mirror' word or not.
Input
The first line contains a non-empty name that needs to be checked. The name contains at most 105 large English letters. The name will be written with the next sans serif font:
<image>
Output
Print 'YES' (without the quotes), if the given name matches its mirror reflection. Otherwise, print 'NO' (without the quotes).
Examples
Input
AHA
Output
YES
Input
Z
Output
NO
Input
XO
Output
NO
Submitted Solution:
```
import sys
a = input()
b = "".join(reversed(a))
if "H" in a or "A" in a or "U" in a or "V" in a or "W" in a or "X" in a or "I" in a or "T" in a or "M" in a or "Y" in a:
if "B" not in a and "C" not in a and "D" not in a and "E" not in a and "F" not in a and "G" not in a and "J" not in a and "K" not in a and "L" not in a and "N" not in a and "P" not in a and "Q" not in a and "R" not in a and "S" not in a and "Z" not in a:
if a == b:
print("YES")
sys.exit()
print("NO")
``` | instruction | 0 | 8,654 | 18 | 17,308 |
No | output | 1 | 8,654 | 18 | 17,309 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, a start up by two students of a state university of city F gained incredible popularity. Now it's time to start a new company. But what do we call it?
The market analysts came up with a very smart plan: the name of the company should be identical to its reflection in a mirror! In other words, if we write out the name of the company on a piece of paper in a line (horizontally, from left to right) with large English letters, then put this piece of paper in front of the mirror, then the reflection of the name in the mirror should perfectly match the line written on the piece of paper.
There are many suggestions for the company name, so coming up to the mirror with a piece of paper for each name wouldn't be sensible. The founders of the company decided to automatize this process. They asked you to write a program that can, given a word, determine whether the word is a 'mirror' word or not.
Input
The first line contains a non-empty name that needs to be checked. The name contains at most 105 large English letters. The name will be written with the next sans serif font:
<image>
Output
Print 'YES' (without the quotes), if the given name matches its mirror reflection. Otherwise, print 'NO' (without the quotes).
Examples
Input
AHA
Output
YES
Input
Z
Output
NO
Input
XO
Output
NO
Submitted Solution:
```
x = input()
array1=[]
array2=[]
for i in x:
array1.append(i)
array2.append(i)
array2.reverse()
if (array1==array2) and (len(x)>1):print('YES')
else:print('NO')
#
``` | instruction | 0 | 8,655 | 18 | 17,310 |
No | output | 1 | 8,655 | 18 | 17,311 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, a start up by two students of a state university of city F gained incredible popularity. Now it's time to start a new company. But what do we call it?
The market analysts came up with a very smart plan: the name of the company should be identical to its reflection in a mirror! In other words, if we write out the name of the company on a piece of paper in a line (horizontally, from left to right) with large English letters, then put this piece of paper in front of the mirror, then the reflection of the name in the mirror should perfectly match the line written on the piece of paper.
There are many suggestions for the company name, so coming up to the mirror with a piece of paper for each name wouldn't be sensible. The founders of the company decided to automatize this process. They asked you to write a program that can, given a word, determine whether the word is a 'mirror' word or not.
Input
The first line contains a non-empty name that needs to be checked. The name contains at most 105 large English letters. The name will be written with the next sans serif font:
<image>
Output
Print 'YES' (without the quotes), if the given name matches its mirror reflection. Otherwise, print 'NO' (without the quotes).
Examples
Input
AHA
Output
YES
Input
Z
Output
NO
Input
XO
Output
NO
Submitted Solution:
```
import sys
import math
st = sys.stdin.readline()
l = len(st) - 1
dct = {'A' : 1, 'B': 0, 'C': 0, 'D': 0, 'E': 0, 'F': 0, 'G': 0, 'H': 1, 'I': 1,
'J': 0, 'K': 0, 'L': 0, 'M': 1, 'N': 0, 'O': 1, 'P': 0, 'Q': 0, 'R': 0, 'S': 1,
'T': 1, 'U': 1, 'V': 1, 'W': 1, 'X': 1, 'Y': 1, 'Z': 0 }
if(l == 1 and dct[st[0]] == 0):
print("NO")
exit()
j = l
for i in range(int(l / 2)):
if(st[i] != st[j - 1] or dct[st[i]] == 0):
print("NO")
exit()
j -= 1
print("YES")
``` | instruction | 0 | 8,656 | 18 | 17,312 |
No | output | 1 | 8,656 | 18 | 17,313 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, a start up by two students of a state university of city F gained incredible popularity. Now it's time to start a new company. But what do we call it?
The market analysts came up with a very smart plan: the name of the company should be identical to its reflection in a mirror! In other words, if we write out the name of the company on a piece of paper in a line (horizontally, from left to right) with large English letters, then put this piece of paper in front of the mirror, then the reflection of the name in the mirror should perfectly match the line written on the piece of paper.
There are many suggestions for the company name, so coming up to the mirror with a piece of paper for each name wouldn't be sensible. The founders of the company decided to automatize this process. They asked you to write a program that can, given a word, determine whether the word is a 'mirror' word or not.
Input
The first line contains a non-empty name that needs to be checked. The name contains at most 105 large English letters. The name will be written with the next sans serif font:
<image>
Output
Print 'YES' (without the quotes), if the given name matches its mirror reflection. Otherwise, print 'NO' (without the quotes).
Examples
Input
AHA
Output
YES
Input
Z
Output
NO
Input
XO
Output
NO
Submitted Solution:
```
s = input()
t = ['B', 'C', 'Z', 'Q', 'E', 'R', 'P', 'L', 'K', 'J', 'G', 'F', 'D', 'S', 'N']
k = 0
for i in range(len(s)):
if s[i] in t:
k+=1
print("YES" if k==0 else "NO")
``` | instruction | 0 | 8,657 | 18 | 17,314 |
No | output | 1 | 8,657 | 18 | 17,315 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Each employee of the "Blake Techologies" company uses a special messaging app "Blake Messenger". All the stuff likes this app and uses it constantly. However, some important futures are missing. For example, many users want to be able to search through the message history. It was already announced that the new feature will appear in the nearest update, when developers faced some troubles that only you may help them to solve.
All the messages are represented as a strings consisting of only lowercase English letters. In order to reduce the network load strings are represented in the special compressed form. Compression algorithm works as follows: string is represented as a concatenation of n blocks, each block containing only equal characters. One block may be described as a pair (li, ci), where li is the length of the i-th block and ci is the corresponding letter. Thus, the string s may be written as the sequence of pairs <image>.
Your task is to write the program, that given two compressed string t and s finds all occurrences of s in t. Developers know that there may be many such occurrences, so they only ask you to find the number of them. Note that p is the starting position of some occurrence of s in t if and only if tptp + 1...tp + |s| - 1 = s, where ti is the i-th character of string t.
Note that the way to represent the string in compressed form may not be unique. For example string "aaaa" may be given as <image>, <image>, <image>...
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 200 000) — the number of blocks in the strings t and s, respectively.
The second line contains the descriptions of n parts of string t in the format "li-ci" (1 ≤ li ≤ 1 000 000) — the length of the i-th part and the corresponding lowercase English letter.
The second line contains the descriptions of m parts of string s in the format "li-ci" (1 ≤ li ≤ 1 000 000) — the length of the i-th part and the corresponding lowercase English letter.
Output
Print a single integer — the number of occurrences of s in t.
Examples
Input
5 3
3-a 2-b 4-c 3-a 2-c
2-a 2-b 1-c
Output
1
Input
6 1
3-a 6-b 7-a 4-c 8-e 2-a
3-a
Output
6
Input
5 5
1-h 1-e 1-l 1-l 1-o
1-w 1-o 1-r 1-l 1-d
Output
0
Note
In the first sample, t = "aaabbccccaaacc", and string s = "aabbc". The only occurrence of string s in string t starts at position p = 2.
In the second sample, t = "aaabbbbbbaaaaaaacccceeeeeeeeaa", and s = "aaa". The occurrences of s in t start at positions p = 1, p = 10, p = 11, p = 12, p = 13 and p = 14.
Submitted Solution:
```
n,m = map(int, input().split())
a = list(map(str,input().split()))
b = list(map(str,input().split()))
str1 = ''
str2 = ''
for i in a:
x = int(i[0])
c = i[2]
str1 += (c*x)
for i in b:
x = int(i[0])
c = i[2]
str2 += (c*x)
i = 0
ans = 0
while (True):
r = str1.find(str2,i)
if r!=-1:
ans +=1
i = r+1
else:
break
print(ans)
``` | instruction | 0 | 8,693 | 18 | 17,386 |
No | output | 1 | 8,693 | 18 | 17,387 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Each employee of the "Blake Techologies" company uses a special messaging app "Blake Messenger". All the stuff likes this app and uses it constantly. However, some important futures are missing. For example, many users want to be able to search through the message history. It was already announced that the new feature will appear in the nearest update, when developers faced some troubles that only you may help them to solve.
All the messages are represented as a strings consisting of only lowercase English letters. In order to reduce the network load strings are represented in the special compressed form. Compression algorithm works as follows: string is represented as a concatenation of n blocks, each block containing only equal characters. One block may be described as a pair (li, ci), where li is the length of the i-th block and ci is the corresponding letter. Thus, the string s may be written as the sequence of pairs <image>.
Your task is to write the program, that given two compressed string t and s finds all occurrences of s in t. Developers know that there may be many such occurrences, so they only ask you to find the number of them. Note that p is the starting position of some occurrence of s in t if and only if tptp + 1...tp + |s| - 1 = s, where ti is the i-th character of string t.
Note that the way to represent the string in compressed form may not be unique. For example string "aaaa" may be given as <image>, <image>, <image>...
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 200 000) — the number of blocks in the strings t and s, respectively.
The second line contains the descriptions of n parts of string t in the format "li-ci" (1 ≤ li ≤ 1 000 000) — the length of the i-th part and the corresponding lowercase English letter.
The second line contains the descriptions of m parts of string s in the format "li-ci" (1 ≤ li ≤ 1 000 000) — the length of the i-th part and the corresponding lowercase English letter.
Output
Print a single integer — the number of occurrences of s in t.
Examples
Input
5 3
3-a 2-b 4-c 3-a 2-c
2-a 2-b 1-c
Output
1
Input
6 1
3-a 6-b 7-a 4-c 8-e 2-a
3-a
Output
6
Input
5 5
1-h 1-e 1-l 1-l 1-o
1-w 1-o 1-r 1-l 1-d
Output
0
Note
In the first sample, t = "aaabbccccaaacc", and string s = "aabbc". The only occurrence of string s in string t starts at position p = 2.
In the second sample, t = "aaabbbbbbaaaaaaacccceeeeeeeeaa", and s = "aaa". The occurrences of s in t start at positions p = 1, p = 10, p = 11, p = 12, p = 13 and p = 14.
Submitted Solution:
```
def main():
input().split()
ts = []
for _ in 0, 1:
tmp = input().split()
a, x, l = tmp[0][-1], 0, []
for st in tmp:
y = int(st[:-2])
b = st[-1]
if a != b:
l.append(((x, a)))
x, a = y, b
else:
x += y
l.append(((x, a)))
ts.append(l)
t, s = ts
res, m, x, a, y, b = 0, len(s), *s[0], *s[-1]
if m == 1:
res = sum(y - x + 1 for y, b in t if a == b and x <= y)
elif m == 2:
i, u = 0, ' '
for j, v in t:
if a == u and b == v and x <= i and y <= j:
res += 1
else:
t[:0] = s[1: -1] + [(0, ' ')]
tmp = [0] * len(t)
for i, j in zip(range(1, len(t)), tmp):
while j > 0 and t[i] != t[j]:
j = tmp[j - 1]
tmp[i] = j + 1 if t[i] == t[j] else j
m -= 2
del tmp[-1]
for i, q in enumerate(tmp):
if q == m:
i, u, j, v = *t[i - q], *t[i + 1]
if a == u and b == v and x <= i and y <= j:
res += 1
print(res)
if __name__ == '__main__':
main()
``` | instruction | 0 | 8,694 | 18 | 17,388 |
No | output | 1 | 8,694 | 18 | 17,389 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Each employee of the "Blake Techologies" company uses a special messaging app "Blake Messenger". All the stuff likes this app and uses it constantly. However, some important futures are missing. For example, many users want to be able to search through the message history. It was already announced that the new feature will appear in the nearest update, when developers faced some troubles that only you may help them to solve.
All the messages are represented as a strings consisting of only lowercase English letters. In order to reduce the network load strings are represented in the special compressed form. Compression algorithm works as follows: string is represented as a concatenation of n blocks, each block containing only equal characters. One block may be described as a pair (li, ci), where li is the length of the i-th block and ci is the corresponding letter. Thus, the string s may be written as the sequence of pairs <image>.
Your task is to write the program, that given two compressed string t and s finds all occurrences of s in t. Developers know that there may be many such occurrences, so they only ask you to find the number of them. Note that p is the starting position of some occurrence of s in t if and only if tptp + 1...tp + |s| - 1 = s, where ti is the i-th character of string t.
Note that the way to represent the string in compressed form may not be unique. For example string "aaaa" may be given as <image>, <image>, <image>...
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 200 000) — the number of blocks in the strings t and s, respectively.
The second line contains the descriptions of n parts of string t in the format "li-ci" (1 ≤ li ≤ 1 000 000) — the length of the i-th part and the corresponding lowercase English letter.
The second line contains the descriptions of m parts of string s in the format "li-ci" (1 ≤ li ≤ 1 000 000) — the length of the i-th part and the corresponding lowercase English letter.
Output
Print a single integer — the number of occurrences of s in t.
Examples
Input
5 3
3-a 2-b 4-c 3-a 2-c
2-a 2-b 1-c
Output
1
Input
6 1
3-a 6-b 7-a 4-c 8-e 2-a
3-a
Output
6
Input
5 5
1-h 1-e 1-l 1-l 1-o
1-w 1-o 1-r 1-l 1-d
Output
0
Note
In the first sample, t = "aaabbccccaaacc", and string s = "aabbc". The only occurrence of string s in string t starts at position p = 2.
In the second sample, t = "aaabbbbbbaaaaaaacccceeeeeeeeaa", and s = "aaa". The occurrences of s in t start at positions p = 1, p = 10, p = 11, p = 12, p = 13 and p = 14.
Submitted Solution:
```
def Z_function(L, l):
Z = []
for i in range(len(L)):
if i == 0:
Z.append(0)
else:
c = 0
for j in range(i, len(L)):
if L[j][1] == L[j - i][1]:
if l == 1 and L[j][0] > L[j - i][0]:
c = L[j][0] - L[j - i][0] + 1
elif (L[j][0] == L[j - i][0] or ((j - i == 0 or j - i == l - 1) and L[j][0] >= L[j - i][0])):
c += 1
else:
break
else:
break
Z.append(c)
return Z
def parse_string(string):
L = []
L = string.split(' ')
for i in range(len(L)):
L[i] = [int(L[i][0]), L[i][-1]]
i = 0
while i < len(L)-1:
if L[i][1] == L[i+1][1]:
L[i][0] += L[i+1][0]
L.remove(L[i+1])
i+=1
return L
def get_count_entering(t,s):
count = 0
#Creating United List
UL = s[:]
UL.append([0,'$'])
UL.extend(t)
#End of Creating
len_s = len(s)
Z = Z_function(UL, len_s)
for z in Z:
if len_s == 1:
count+=z
elif z == len_s:
count+=1
return count
def main():
nm = input()
del nm
#
string = input()
t = parse_string(string)
string = input()
s = parse_string(string)
print(get_count_entering(t,s))
if __name__ == '__main__':
main()
``` | instruction | 0 | 8,695 | 18 | 17,390 |
No | output | 1 | 8,695 | 18 | 17,391 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Each employee of the "Blake Techologies" company uses a special messaging app "Blake Messenger". All the stuff likes this app and uses it constantly. However, some important futures are missing. For example, many users want to be able to search through the message history. It was already announced that the new feature will appear in the nearest update, when developers faced some troubles that only you may help them to solve.
All the messages are represented as a strings consisting of only lowercase English letters. In order to reduce the network load strings are represented in the special compressed form. Compression algorithm works as follows: string is represented as a concatenation of n blocks, each block containing only equal characters. One block may be described as a pair (li, ci), where li is the length of the i-th block and ci is the corresponding letter. Thus, the string s may be written as the sequence of pairs <image>.
Your task is to write the program, that given two compressed string t and s finds all occurrences of s in t. Developers know that there may be many such occurrences, so they only ask you to find the number of them. Note that p is the starting position of some occurrence of s in t if and only if tptp + 1...tp + |s| - 1 = s, where ti is the i-th character of string t.
Note that the way to represent the string in compressed form may not be unique. For example string "aaaa" may be given as <image>, <image>, <image>...
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 200 000) — the number of blocks in the strings t and s, respectively.
The second line contains the descriptions of n parts of string t in the format "li-ci" (1 ≤ li ≤ 1 000 000) — the length of the i-th part and the corresponding lowercase English letter.
The second line contains the descriptions of m parts of string s in the format "li-ci" (1 ≤ li ≤ 1 000 000) — the length of the i-th part and the corresponding lowercase English letter.
Output
Print a single integer — the number of occurrences of s in t.
Examples
Input
5 3
3-a 2-b 4-c 3-a 2-c
2-a 2-b 1-c
Output
1
Input
6 1
3-a 6-b 7-a 4-c 8-e 2-a
3-a
Output
6
Input
5 5
1-h 1-e 1-l 1-l 1-o
1-w 1-o 1-r 1-l 1-d
Output
0
Note
In the first sample, t = "aaabbccccaaacc", and string s = "aabbc". The only occurrence of string s in string t starts at position p = 2.
In the second sample, t = "aaabbbbbbaaaaaaacccceeeeeeeeaa", and s = "aaa". The occurrences of s in t start at positions p = 1, p = 10, p = 11, p = 12, p = 13 and p = 14.
Submitted Solution:
```
n,m = map(int, input().split())
a = list(map(str,input().split()))
b = list(map(str,input().split()))
str1 = ''
str2 = ''
for i in a:
x = int(i[0])
c = i[2]
str1 += (c*x)
for i in b:
x = int(i[0])
c = i[2]
str2 += (c*x)
i = 0
ans = 0
while (True):
r = str1.rfind(str2,i)
if r!=-1:
ans +=1
i = r+1
else:
break
print(ans)
``` | instruction | 0 | 8,696 | 18 | 17,392 |
No | output | 1 | 8,696 | 18 | 17,393 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mike has a string s consisting of only lowercase English letters. He wants to change exactly one character from the string so that the resulting one is a palindrome.
A palindrome is a string that reads the same backward as forward, for example strings "z", "aaa", "aba", "abccba" are palindromes, but strings "codeforces", "reality", "ab" are not.
Input
The first and single line contains string s (1 ≤ |s| ≤ 15).
Output
Print "YES" (without quotes) if Mike can change exactly one character so that the resulting string is palindrome or "NO" (without quotes) otherwise.
Examples
Input
abccaa
Output
YES
Input
abbcca
Output
NO
Input
abcda
Output
YES
Submitted Solution:
```
li= input()
b = len(li)//2
count = 0
for i in range(b):
if li[i] != li[-(i+1)]:
count += 1
if count == 1: print('YES')
elif count ==0 and len(li) & 1: print('YES')
else: print("NO")
``` | instruction | 0 | 8,747 | 18 | 17,494 |
Yes | output | 1 | 8,747 | 18 | 17,495 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mike has a string s consisting of only lowercase English letters. He wants to change exactly one character from the string so that the resulting one is a palindrome.
A palindrome is a string that reads the same backward as forward, for example strings "z", "aaa", "aba", "abccba" are palindromes, but strings "codeforces", "reality", "ab" are not.
Input
The first and single line contains string s (1 ≤ |s| ≤ 15).
Output
Print "YES" (without quotes) if Mike can change exactly one character so that the resulting string is palindrome or "NO" (without quotes) otherwise.
Examples
Input
abccaa
Output
YES
Input
abbcca
Output
NO
Input
abcda
Output
YES
Submitted Solution:
```
s=input()
if len(s)==1:
print('YES')
else:
l=list(s)
l.reverse()
t=''.join(l)
l=[0]*len(s)
for i in range(len(s)):
if s[i]!=t[i]:
l[i]=1
r=''.join([str(i) for i in l])
if r.count('1')==2 or r.count('1')==0 and len(s)%2==1:
print('YES')
else:
print('NO')
``` | instruction | 0 | 8,748 | 18 | 17,496 |
Yes | output | 1 | 8,748 | 18 | 17,497 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mike has a string s consisting of only lowercase English letters. He wants to change exactly one character from the string so that the resulting one is a palindrome.
A palindrome is a string that reads the same backward as forward, for example strings "z", "aaa", "aba", "abccba" are palindromes, but strings "codeforces", "reality", "ab" are not.
Input
The first and single line contains string s (1 ≤ |s| ≤ 15).
Output
Print "YES" (without quotes) if Mike can change exactly one character so that the resulting string is palindrome or "NO" (without quotes) otherwise.
Examples
Input
abccaa
Output
YES
Input
abbcca
Output
NO
Input
abcda
Output
YES
Submitted Solution:
```
from math import ceil
n = input()
ln = ceil(len(n)/2)
f = 0
if n != n[::-1] :
for i in range(0,ln):
if n[i] != n[-(i+1)]:
if f == 0:
f = 1
else:
print('NO')
f = 0
break
elif len(n)%2==1: print('YES')
else: print('NO')
if f==1: print('YES')
``` | instruction | 0 | 8,749 | 18 | 17,498 |
Yes | output | 1 | 8,749 | 18 | 17,499 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mike has a string s consisting of only lowercase English letters. He wants to change exactly one character from the string so that the resulting one is a palindrome.
A palindrome is a string that reads the same backward as forward, for example strings "z", "aaa", "aba", "abccba" are palindromes, but strings "codeforces", "reality", "ab" are not.
Input
The first and single line contains string s (1 ≤ |s| ≤ 15).
Output
Print "YES" (without quotes) if Mike can change exactly one character so that the resulting string is palindrome or "NO" (without quotes) otherwise.
Examples
Input
abccaa
Output
YES
Input
abbcca
Output
NO
Input
abcda
Output
YES
Submitted Solution:
```
s=input()
i=0
j=len(s)-1
b=0
t=0
if len(s)==1:
print('YES')
exit()
s1=s[0]
if len(s)%2:
if s[:j//2]==s[j//2+1:][::-1]:
print('YES')
exit()
while i<j:
if s[i]!=s[j]:
b+=1
if b>1:
print('NO')
exit()
i+=1
j-=1
print('YES') if b==1 else print('NO')
``` | instruction | 0 | 8,750 | 18 | 17,500 |
Yes | output | 1 | 8,750 | 18 | 17,501 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mike has a string s consisting of only lowercase English letters. He wants to change exactly one character from the string so that the resulting one is a palindrome.
A palindrome is a string that reads the same backward as forward, for example strings "z", "aaa", "aba", "abccba" are palindromes, but strings "codeforces", "reality", "ab" are not.
Input
The first and single line contains string s (1 ≤ |s| ≤ 15).
Output
Print "YES" (without quotes) if Mike can change exactly one character so that the resulting string is palindrome or "NO" (without quotes) otherwise.
Examples
Input
abccaa
Output
YES
Input
abbcca
Output
NO
Input
abcda
Output
YES
Submitted Solution:
```
s=input()
p=0
for i in range(len(s)//2):
if (s[i]!=s[-i-1]):
p+=1
if p>1 or p==0:
print("NO")
else :
print("YES")
``` | instruction | 0 | 8,751 | 18 | 17,502 |
No | output | 1 | 8,751 | 18 | 17,503 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mike has a string s consisting of only lowercase English letters. He wants to change exactly one character from the string so that the resulting one is a palindrome.
A palindrome is a string that reads the same backward as forward, for example strings "z", "aaa", "aba", "abccba" are palindromes, but strings "codeforces", "reality", "ab" are not.
Input
The first and single line contains string s (1 ≤ |s| ≤ 15).
Output
Print "YES" (without quotes) if Mike can change exactly one character so that the resulting string is palindrome or "NO" (without quotes) otherwise.
Examples
Input
abccaa
Output
YES
Input
abbcca
Output
NO
Input
abcda
Output
YES
Submitted Solution:
```
s=input()
r=0
while(r<2 and len(s)>3):
if(s[0]!=s[-1]):
r+=1
s=s.replace(s[0],'',1)
s=s[::-1]
s=s.replace(s[0],'',1)
s=s[::-1]
if(len(s)==2 and s[0]!=s[-1]):
r+=1
print(['YES','NO'][r==2])
``` | instruction | 0 | 8,752 | 18 | 17,504 |
No | output | 1 | 8,752 | 18 | 17,505 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mike has a string s consisting of only lowercase English letters. He wants to change exactly one character from the string so that the resulting one is a palindrome.
A palindrome is a string that reads the same backward as forward, for example strings "z", "aaa", "aba", "abccba" are palindromes, but strings "codeforces", "reality", "ab" are not.
Input
The first and single line contains string s (1 ≤ |s| ≤ 15).
Output
Print "YES" (without quotes) if Mike can change exactly one character so that the resulting string is palindrome or "NO" (without quotes) otherwise.
Examples
Input
abccaa
Output
YES
Input
abbcca
Output
NO
Input
abcda
Output
YES
Submitted Solution:
```
string = input()
counter = 0
for i in range(len(string) // 2):
l = i
r = len(string) - i - 1
counter += string[l] != string[r]
print("YES" if counter == 1 else "NO")
``` | instruction | 0 | 8,753 | 18 | 17,506 |
No | output | 1 | 8,753 | 18 | 17,507 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mike has a string s consisting of only lowercase English letters. He wants to change exactly one character from the string so that the resulting one is a palindrome.
A palindrome is a string that reads the same backward as forward, for example strings "z", "aaa", "aba", "abccba" are palindromes, but strings "codeforces", "reality", "ab" are not.
Input
The first and single line contains string s (1 ≤ |s| ≤ 15).
Output
Print "YES" (without quotes) if Mike can change exactly one character so that the resulting string is palindrome or "NO" (without quotes) otherwise.
Examples
Input
abccaa
Output
YES
Input
abbcca
Output
NO
Input
abcda
Output
YES
Submitted Solution:
```
s = input()
length = len(s)
if length % 2 == 0:
count = 0
for i in range(length//2):
if s[i] != s[length - i -1]:
count += 1
if count == 1:
print("YES")
else:
print("NO")
else:
count = 0
for i in range((length - 1)//2):
if s[i] != s[length - i - 1]:
count += 1
if count == 1:
print("YES")
else:
print("NO")
``` | instruction | 0 | 8,754 | 18 | 17,508 |
No | output | 1 | 8,754 | 18 | 17,509 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem is different from the hard version. In this version Ujan makes exactly one exchange. You can hack this problem only if you solve both problems.
After struggling and failing many times, Ujan decided to try to clean up his house again. He decided to get his strings in order first.
Ujan has two distinct strings s and t of length n consisting of only of lowercase English characters. He wants to make them equal. Since Ujan is lazy, he will perform the following operation exactly once: he takes two positions i and j (1 ≤ i,j ≤ n, the values i and j can be equal or different), and swaps the characters s_i and t_j. Can he succeed?
Note that he has to perform this operation exactly once. He has to perform this operation.
Input
The first line contains a single integer k (1 ≤ k ≤ 10), the number of test cases.
For each of the test cases, the first line contains a single integer n (2 ≤ n ≤ 10^4), the length of the strings s and t.
Each of the next two lines contains the strings s and t, each having length exactly n. The strings consist only of lowercase English letters. It is guaranteed that strings are different.
Output
For each test case, output "Yes" if Ujan can make the two strings equal and "No" otherwise.
You can print each letter in any case (upper or lower).
Example
Input
4
5
souse
houhe
3
cat
dog
2
aa
az
3
abc
bca
Output
Yes
No
No
No
Note
In the first test case, Ujan can swap characters s_1 and t_4, obtaining the word "house".
In the second test case, it is not possible to make the strings equal using exactly one swap of s_i and t_j.
Submitted Solution:
```
# from debug import debug
import sys;input = sys.stdin.readline
t = int(input())
for _ in range(t):
n = int(input())
s1, s2 = list(input().strip()), list(input().strip())
dis = 0
diff = []
for i in range(n):
if s1[i] != s2[i]: dis+=1; diff.append(i)
if dis == 2 and s1[diff[0]] == s1[diff[1]] and s2[diff[1]] == s2[diff[0]]: print("YES")
elif dis == 0: print("YES")
else: print("NO")
``` | instruction | 0 | 9,212 | 18 | 18,424 |
Yes | output | 1 | 9,212 | 18 | 18,425 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem is different from the hard version. In this version Ujan makes exactly one exchange. You can hack this problem only if you solve both problems.
After struggling and failing many times, Ujan decided to try to clean up his house again. He decided to get his strings in order first.
Ujan has two distinct strings s and t of length n consisting of only of lowercase English characters. He wants to make them equal. Since Ujan is lazy, he will perform the following operation exactly once: he takes two positions i and j (1 ≤ i,j ≤ n, the values i and j can be equal or different), and swaps the characters s_i and t_j. Can he succeed?
Note that he has to perform this operation exactly once. He has to perform this operation.
Input
The first line contains a single integer k (1 ≤ k ≤ 10), the number of test cases.
For each of the test cases, the first line contains a single integer n (2 ≤ n ≤ 10^4), the length of the strings s and t.
Each of the next two lines contains the strings s and t, each having length exactly n. The strings consist only of lowercase English letters. It is guaranteed that strings are different.
Output
For each test case, output "Yes" if Ujan can make the two strings equal and "No" otherwise.
You can print each letter in any case (upper or lower).
Example
Input
4
5
souse
houhe
3
cat
dog
2
aa
az
3
abc
bca
Output
Yes
No
No
No
Note
In the first test case, Ujan can swap characters s_1 and t_4, obtaining the word "house".
In the second test case, it is not possible to make the strings equal using exactly one swap of s_i and t_j.
Submitted Solution:
```
tes=int(input())
for j in range(0,tes):
size=int(input())
s=input()
t=input()
arr=[]
l=0
k=0
for i in range(0,size):
if(s[i]!=t[i]):
arr.append(i)
l=l+1
if(l>2):
print("NO")
k=1
break
if(l==2 and s[arr[0]]==s[arr[1]] and t[arr[0]]==t[arr[1]]):
print("YES")
elif (l<2 or k==0):
print("NO")
``` | instruction | 0 | 9,213 | 18 | 18,426 |
Yes | output | 1 | 9,213 | 18 | 18,427 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem is different from the hard version. In this version Ujan makes exactly one exchange. You can hack this problem only if you solve both problems.
After struggling and failing many times, Ujan decided to try to clean up his house again. He decided to get his strings in order first.
Ujan has two distinct strings s and t of length n consisting of only of lowercase English characters. He wants to make them equal. Since Ujan is lazy, he will perform the following operation exactly once: he takes two positions i and j (1 ≤ i,j ≤ n, the values i and j can be equal or different), and swaps the characters s_i and t_j. Can he succeed?
Note that he has to perform this operation exactly once. He has to perform this operation.
Input
The first line contains a single integer k (1 ≤ k ≤ 10), the number of test cases.
For each of the test cases, the first line contains a single integer n (2 ≤ n ≤ 10^4), the length of the strings s and t.
Each of the next two lines contains the strings s and t, each having length exactly n. The strings consist only of lowercase English letters. It is guaranteed that strings are different.
Output
For each test case, output "Yes" if Ujan can make the two strings equal and "No" otherwise.
You can print each letter in any case (upper or lower).
Example
Input
4
5
souse
houhe
3
cat
dog
2
aa
az
3
abc
bca
Output
Yes
No
No
No
Note
In the first test case, Ujan can swap characters s_1 and t_4, obtaining the word "house".
In the second test case, it is not possible to make the strings equal using exactly one swap of s_i and t_j.
Submitted Solution:
```
import sys
def read_numbers():
return [int(x) for x in sys.stdin.readline()[:-1].split(" ")]
def read_str():
return sys.stdin.readline()[:-1]
def test_case():
str_len = read_numbers()[0]
str_a = list(read_str())
str_b = list(read_str())
not_common_a = list()
not_common_b = list()
for i in range(str_len):
if str_a[i] != str_b[i]:
not_common_a.append(str_a[i])
not_common_b.append(str_b[i])
if len(not_common_a) > 2:
return False
# print(not_common_a)
# print(not_common_b)
if len(not_common_a) != 2:
return False
return not_common_a[0] == not_common_a[1] and not_common_b[0] == not_common_b[1]
def main():
test_cases = read_numbers()[0]
for i in range(test_cases):
print("Yes" if test_case() else "No")
if __name__ == '__main__':
main()
``` | instruction | 0 | 9,214 | 18 | 18,428 |
Yes | output | 1 | 9,214 | 18 | 18,429 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem is different from the hard version. In this version Ujan makes exactly one exchange. You can hack this problem only if you solve both problems.
After struggling and failing many times, Ujan decided to try to clean up his house again. He decided to get his strings in order first.
Ujan has two distinct strings s and t of length n consisting of only of lowercase English characters. He wants to make them equal. Since Ujan is lazy, he will perform the following operation exactly once: he takes two positions i and j (1 ≤ i,j ≤ n, the values i and j can be equal or different), and swaps the characters s_i and t_j. Can he succeed?
Note that he has to perform this operation exactly once. He has to perform this operation.
Input
The first line contains a single integer k (1 ≤ k ≤ 10), the number of test cases.
For each of the test cases, the first line contains a single integer n (2 ≤ n ≤ 10^4), the length of the strings s and t.
Each of the next two lines contains the strings s and t, each having length exactly n. The strings consist only of lowercase English letters. It is guaranteed that strings are different.
Output
For each test case, output "Yes" if Ujan can make the two strings equal and "No" otherwise.
You can print each letter in any case (upper or lower).
Example
Input
4
5
souse
houhe
3
cat
dog
2
aa
az
3
abc
bca
Output
Yes
No
No
No
Note
In the first test case, Ujan can swap characters s_1 and t_4, obtaining the word "house".
In the second test case, it is not possible to make the strings equal using exactly one swap of s_i and t_j.
Submitted Solution:
```
import sys
import itertools
import math
import collections
from collections import Counter
#########################
# imgur.com/Pkt7iIf.png #
#########################
def sieve(n):
prime = [True for i in range(n + 1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * 2, n + 1, p):
prime[i] = False
p += 1
prime[0] = prime[1] = False
r = [p for p in range(n + 1) if prime[p]]
return r
def divs(n, start=1):
r = []
for i in range(start, int(math.sqrt(n) + 1)):
if (n % i == 0):
if (n / i == i):
r.append(i)
else:
r.extend([i, n // i])
return r
def ceil(n, k): return n // k + (n % k != 0)
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(map(int, input().split()))
def lcm(a, b): return abs(a * b) // math.gcd(a, b)
def prr(a, sep=' '): print(sep.join(map(str, a)))
def dd(): return collections.defaultdict(int)
t = ii()
for _ in range(t):
n = ii()
a = input()
b = input()
col = []
for i in range(n):
if a[i] != b[i]:
col.append(i)
if len(col) == 0:
print('Yes')
continue
if len(col) != 2:
print('No')
continue
if a[col[0]] == a[col[1]] and b[col[0]] == b[col[1]]:
print('Yes')
else:
print('No')
``` | instruction | 0 | 9,215 | 18 | 18,430 |
Yes | output | 1 | 9,215 | 18 | 18,431 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem is different from the hard version. In this version Ujan makes exactly one exchange. You can hack this problem only if you solve both problems.
After struggling and failing many times, Ujan decided to try to clean up his house again. He decided to get his strings in order first.
Ujan has two distinct strings s and t of length n consisting of only of lowercase English characters. He wants to make them equal. Since Ujan is lazy, he will perform the following operation exactly once: he takes two positions i and j (1 ≤ i,j ≤ n, the values i and j can be equal or different), and swaps the characters s_i and t_j. Can he succeed?
Note that he has to perform this operation exactly once. He has to perform this operation.
Input
The first line contains a single integer k (1 ≤ k ≤ 10), the number of test cases.
For each of the test cases, the first line contains a single integer n (2 ≤ n ≤ 10^4), the length of the strings s and t.
Each of the next two lines contains the strings s and t, each having length exactly n. The strings consist only of lowercase English letters. It is guaranteed that strings are different.
Output
For each test case, output "Yes" if Ujan can make the two strings equal and "No" otherwise.
You can print each letter in any case (upper or lower).
Example
Input
4
5
souse
houhe
3
cat
dog
2
aa
az
3
abc
bca
Output
Yes
No
No
No
Note
In the first test case, Ujan can swap characters s_1 and t_4, obtaining the word "house".
In the second test case, it is not possible to make the strings equal using exactly one swap of s_i and t_j.
Submitted Solution:
```
def gt(x,y,r):
v=[]
q=[]
e=0
for i in range(r):
if x[i]==y[i]:
None
else:
e+=1
v.append(x[i])
q.append(y[i])
if e==0:
return "Yes"
elif e==2:
if set(v)==set(l):
return "Yes"
else:
return "No"
return "No"
k=int(input())
l=[]
for i in range(k):
rd=int(input())
xd=input()
yd=input()
print(gt(xd,yd,rd))
``` | instruction | 0 | 9,216 | 18 | 18,432 |
No | output | 1 | 9,216 | 18 | 18,433 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem is different from the hard version. In this version Ujan makes exactly one exchange. You can hack this problem only if you solve both problems.
After struggling and failing many times, Ujan decided to try to clean up his house again. He decided to get his strings in order first.
Ujan has two distinct strings s and t of length n consisting of only of lowercase English characters. He wants to make them equal. Since Ujan is lazy, he will perform the following operation exactly once: he takes two positions i and j (1 ≤ i,j ≤ n, the values i and j can be equal or different), and swaps the characters s_i and t_j. Can he succeed?
Note that he has to perform this operation exactly once. He has to perform this operation.
Input
The first line contains a single integer k (1 ≤ k ≤ 10), the number of test cases.
For each of the test cases, the first line contains a single integer n (2 ≤ n ≤ 10^4), the length of the strings s and t.
Each of the next two lines contains the strings s and t, each having length exactly n. The strings consist only of lowercase English letters. It is guaranteed that strings are different.
Output
For each test case, output "Yes" if Ujan can make the two strings equal and "No" otherwise.
You can print each letter in any case (upper or lower).
Example
Input
4
5
souse
houhe
3
cat
dog
2
aa
az
3
abc
bca
Output
Yes
No
No
No
Note
In the first test case, Ujan can swap characters s_1 and t_4, obtaining the word "house".
In the second test case, it is not possible to make the strings equal using exactly one swap of s_i and t_j.
Submitted Solution:
```
q = int(input())
for i in range(q):
n = int(input())
s1 = input()
s2 = input()
dp1, dp2 = [ ],[ ]
while(i<len(s1)):
if(s1[i]!=s2[i]):
dp1.append(s1[i])
dp2.append(s2[i])
i+=1
if(len(dp1)!=2):
print("No")
elif(dp1[0]==dp1[1] and dp2[0]==dp2[1]):
print("Yes")
else:
print("No")
``` | instruction | 0 | 9,217 | 18 | 18,434 |
No | output | 1 | 9,217 | 18 | 18,435 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem is different from the hard version. In this version Ujan makes exactly one exchange. You can hack this problem only if you solve both problems.
After struggling and failing many times, Ujan decided to try to clean up his house again. He decided to get his strings in order first.
Ujan has two distinct strings s and t of length n consisting of only of lowercase English characters. He wants to make them equal. Since Ujan is lazy, he will perform the following operation exactly once: he takes two positions i and j (1 ≤ i,j ≤ n, the values i and j can be equal or different), and swaps the characters s_i and t_j. Can he succeed?
Note that he has to perform this operation exactly once. He has to perform this operation.
Input
The first line contains a single integer k (1 ≤ k ≤ 10), the number of test cases.
For each of the test cases, the first line contains a single integer n (2 ≤ n ≤ 10^4), the length of the strings s and t.
Each of the next two lines contains the strings s and t, each having length exactly n. The strings consist only of lowercase English letters. It is guaranteed that strings are different.
Output
For each test case, output "Yes" if Ujan can make the two strings equal and "No" otherwise.
You can print each letter in any case (upper or lower).
Example
Input
4
5
souse
houhe
3
cat
dog
2
aa
az
3
abc
bca
Output
Yes
No
No
No
Note
In the first test case, Ujan can swap characters s_1 and t_4, obtaining the word "house".
In the second test case, it is not possible to make the strings equal using exactly one swap of s_i and t_j.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
s = input()
t = input()
count = 0
for i in range(n):
if s[i] != t[i]:
count+=1
if count == 2:
print("Yes")
else:
print("No")
``` | instruction | 0 | 9,218 | 18 | 18,436 |
No | output | 1 | 9,218 | 18 | 18,437 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem is different from the hard version. In this version Ujan makes exactly one exchange. You can hack this problem only if you solve both problems.
After struggling and failing many times, Ujan decided to try to clean up his house again. He decided to get his strings in order first.
Ujan has two distinct strings s and t of length n consisting of only of lowercase English characters. He wants to make them equal. Since Ujan is lazy, he will perform the following operation exactly once: he takes two positions i and j (1 ≤ i,j ≤ n, the values i and j can be equal or different), and swaps the characters s_i and t_j. Can he succeed?
Note that he has to perform this operation exactly once. He has to perform this operation.
Input
The first line contains a single integer k (1 ≤ k ≤ 10), the number of test cases.
For each of the test cases, the first line contains a single integer n (2 ≤ n ≤ 10^4), the length of the strings s and t.
Each of the next two lines contains the strings s and t, each having length exactly n. The strings consist only of lowercase English letters. It is guaranteed that strings are different.
Output
For each test case, output "Yes" if Ujan can make the two strings equal and "No" otherwise.
You can print each letter in any case (upper or lower).
Example
Input
4
5
souse
houhe
3
cat
dog
2
aa
az
3
abc
bca
Output
Yes
No
No
No
Note
In the first test case, Ujan can swap characters s_1 and t_4, obtaining the word "house".
In the second test case, it is not possible to make the strings equal using exactly one swap of s_i and t_j.
Submitted Solution:
```
T = int(input())
for t in range(T):
n = int(input())
s1 = list(input())
s2 = list(input())
freq = [0]*26
for i in s1:
freq[ord(i)-ord('a')] += 1
for i in s2:
freq[ord(i) - ord('a')] += 1
ok = 1
for i in range(26):
if freq[i]&1:
ok = 0
if ok==0:
print('No')
continue
else:
print('Yes')
freqa = [0]*26
mapa = [[] for i in range(26)]
mapb = [[] for i in range(26)]
for i in range(n):
mapa[ord(s1[i])-ord('a')].append(i)
mapb[ord(s2[i])-ord('a')].append(i)
excessa = [[] for i in range(26)]
excessb = [[] for i in range(26)]
for i in range(26):
if len(mapa[i]) > (freq[i])//2:
for j in range(freq[i]//2, len(mapa[i])):
excessa[i].append(mapa[i][j])
if len(mapb[i]) > (freq[i])//2:
for j in range(freq[i]//2, len(mapb[i])):
excessb[i].append(mapb[i][j])
alla = []
for i in range(26):
for j in excessa[i]:
alla.append(j)
allb = []
for i in range(26):
for j in excessb[i]:
allb.append(j)
op = []
for i in range(len(alla)):
op.append((alla[i]+1, allb[i]+1))
s1[alla[i]], s2[allb[i]] = s2[allb[i]], s1[alla[i]]
#print('0', s1, s2)
for i in range(n):
if s1[i] == s2[i]:
continue
found = 0
for j in range(i-1, -1, -1):
if (s1[j] == s2[i]) and (s1[j] != s2[j]):
found = 1
#print('Found', s2[i], 'at', j, i)
#print(j+1, i+1)
#s1[j], s2[i] = s2[i], s1[j]
op.append((j+1, j+1))
s1[j], s2[j] = s2[j], s1[j]
op.append((j+1, i+1))
s1[j], s2[i] = s2[i], s1[j]
if found:
break
if found == 0:
for j in range(i+1, n):
if (s1[j] == s2[i]) and (s1[j] != s2[j]):
found = 1
#print('Found', s2[i], 'at', j, i)
#print(j+1, i+1)
#s1[j], s2[i] = s2[i], s1[j]
op.append((j+1, j+1))
s1[j], s2[j] = s2[j], s1[j]
op.append((j+1, i+1))
s1[j], s2[i] = s2[i], s1[j]
if found:
break
print(len(op))
for i in op:
print(*i)
``` | instruction | 0 | 9,219 | 18 | 18,438 |
No | output | 1 | 9,219 | 18 | 18,439 |
Provide a correct Python 3 solution for this coding contest problem.
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name | instruction | 0 | 9,831 | 18 | 19,662 |
"Correct Solution:
```
# coding: utf-8
# Your code here!
import re
while True:
name,type = input().split()
if type == "X":
break
if "_" in name:
X = name.split("_")
else:
tmp = name.upper()
name = tmp[0]+name[1:]
X = re.findall('[A-Z][^A-Z]*',name)
if type == "U":
for i in range(len(X)):
X[i] = X[i].capitalize()
elif type == "L":
X[0] = X[0].lower()
for i in range(1,len(X)):
X[i] = X[i].capitalize()
else:
X[0] = X[0].lower()
for i in range(1,len(X)):
X[i] = "_"+X[i].lower()
print("".join(X))
``` | output | 1 | 9,831 | 18 | 19,663 |
Provide a correct Python 3 solution for this coding contest problem.
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name | instruction | 0 | 9,832 | 18 | 19,664 |
"Correct Solution:
```
def Upper(s) :
New = []
i = 0
while True :
if i == 0 :
New.append(s[i].upper())
elif s[i] == "_" :
i += 1
New.append(s[i].upper())
elif 65 <= ord(s[i]) <= 90 :
New.append(s[i].upper())
else :
New.append(s[i].lower())
i += 1
if i >= len(s) :
break
return New
def Lower(s) :
New = []
i = 0
while True :
if s[i] == "_" :
i += 1
New.append(s[i].upper())
elif 65 <= ord(s[i]) <= 90 and i != 0:
New.append(s[i].upper())
else :
New.append(s[i].lower())
i += 1
if i >= len(s) :
break
return New
def Under_Score(s) :
New = []
i = 0
while True :
if 65 <= ord(s[i]) <= 90 and i != 0:
New.append("_")
New.append(s[i].lower())
else :
New.append(s[i].lower())
i += 1
if i >= len(s) :
break
return New
while True :
l, x = map(str, input().split())
if x == "X" :
break
elif x == "U" :
print(*Upper(l), sep="")
elif x == "L" :
print(*Lower(l), sep="")
elif x == "D" :
print(*Under_Score(l), sep="")
``` | output | 1 | 9,832 | 18 | 19,665 |
Provide a correct Python 3 solution for this coding contest problem.
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name | instruction | 0 | 9,833 | 18 | 19,666 |
"Correct Solution:
```
import re
while True:
n,t=input().split()
if t=='X':
break
if '_'in t:
ans=s.split('_')
else :
ans=re.findall(r'[a-z]+|[A-Z][a-z]*',n)
if t=='D':
ans='_'.join(map(str.lower,ans))
else :
ans=''.join(map(str.capitalize,ans))
if t=='L':
ans=ans[0].lower()+ans[1:]
print(ans)
``` | output | 1 | 9,833 | 18 | 19,667 |
Provide a correct Python 3 solution for this coding contest problem.
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name | instruction | 0 | 9,834 | 18 | 19,668 |
"Correct Solution:
```
large = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
small = list("abcdefghijklmnopqrstuvwxyz")
while 1:
word, alpha = input().split()
if alpha == "X":
break
word = list(word)
ans = ""
if alpha == "L":
first = word.pop(0)
if first in large:
ans += small[large.index(first)]
else:
ans += first
while word != []:
w = word.pop(0)
if w == "_":
target = word.pop(0)
if target in small:
ans += large[small.index(target)]
else:
ans += target
else:
ans += w
elif alpha == "U":
first = word.pop(0)
if first in small:
ans += large[small.index(first)]
else:
ans += first
while word != []:
w = word.pop(0)
if w == "_":
target = word.pop(0)
if target in small:
ans += large[small.index(target)]
else:
ans += target
else:
ans += w
elif alpha == "D":
first = word.pop(0)
if first in large:
ans += small[large.index(first)]
else:
ans += first
while word != []:
w = word.pop(0)
if w in large:
ans += "_" + small[large.index(w)]
else:
ans += w
print(ans)
``` | output | 1 | 9,834 | 18 | 19,669 |
Provide a correct Python 3 solution for this coding contest problem.
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name | instruction | 0 | 9,835 | 18 | 19,670 |
"Correct Solution:
```
while True :
name, type = map(str, input().split())
if type == "X" :
break
else :
N = list(name)
if "_" in N :
if type == "U" or type == "L" :
cnt = 0
for i in range(len(N)) :
if i == 0 and type == "U" :
N[i] = N[i].upper()
elif N[i] == "_" :
cnt += 1
elif cnt == 1 :
N[i] = N[i].upper()
cnt = 0
N = [i for i in N if i != "_"]
elif type == "U" :
N[0] = N[0].upper()
elif type == "L" :
N[0] = N[0].lower()
else :
s = 0
for i in range(len(N)) :
if i == 0 :
N[s] = N[s].lower()
s += 1
elif N[s].isupper() :
N[s] = N[s].lower()
N.insert(s, "_")
s += 2
else :
s += 1
for i in range(len(N)) :
if i == len(N) - 1 :
print(N[i])
else :
print(N[i], end = "")
``` | output | 1 | 9,835 | 18 | 19,671 |
Provide a correct Python 3 solution for this coding contest problem.
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name | instruction | 0 | 9,836 | 18 | 19,672 |
"Correct Solution:
```
while True:
s=list(map(str,input().split(' ')))
if s[1]=='X':
break
name=list(s[0])
der=0
n=[]
for i in range(1,len(name)):
if name[i].isupper()==True:
n.append(i)
if name[i]=='_':
n.append(i-der)
der+=1
if s[1]=='U':
name[0]=name[0].upper()
for u in range(len(n)):
if name[n[u]]=='_':
name.pop(n[u])
name[n[u]]=name[n[u]].upper()
print(''.join(name))
if s[1]=='L':
name[0]=name[0].lower()
for l in range(len(n)):
if name[n[l]]=='_':
name.pop(n[l])
name[n[l]]=name[n[l]].upper()
print(''.join(name))
if s[1]=='D':
if '_' in name:
print(''.join(name))
else:
name[0]=name[0].lower()
der=0
for d in range(len(n)):
name[n[d]+der]=name[n[d]+der].lower()
name.insert(n[d]+der,'_')
der+=1
print(''.join(name))
``` | output | 1 | 9,836 | 18 | 19,673 |
Provide a correct Python 3 solution for this coding contest problem.
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name | instruction | 0 | 9,837 | 18 | 19,674 |
"Correct Solution:
```
while True:
a, b = map(str,input().split())
if b=='X':
break
if '_' in a:
c = a.split('_')
else:
c=[]
k = 0
for i in range(1,len(a)):
if a[i].isupper():
c.append(a[k:i])
k = i
c.append(a[k:])
if b=='D':
c = '_'.join(map(str.lower,c))
else:
c = ''.join(map(str.capitalize,c))
if b =='L':
c = c[0].lower() + c[1:]
print(c)
``` | output | 1 | 9,837 | 18 | 19,675 |
Provide a correct Python 3 solution for this coding contest problem.
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name | instruction | 0 | 9,838 | 18 | 19,676 |
"Correct Solution:
```
import re
while True:
n,t=map(str,input().split())
if t == 'X':
break
if '_' in n :
if t == 'D':
print(n)
else:
m = n.title()
l= re.sub('_', '',m)
if t == 'U':
print(l)
elif t == 'L':
p = l[0].lower() + l[1:]
print(p)
else:
q = n[0].upper() + n[1:]
r = re.findall('[A-Z][a-z]*',q)
if t == 'D':
s = '_'.join(r)
print(s.lower())
elif t == 'U':
print("".join(r))
elif t == 'L':
u = "".join(r)
v = u[0].lower() + u[1:]
print(v)
``` | output | 1 | 9,838 | 18 | 19,677 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
Submitted Solution:
```
while True:
name,typ = input().split()
if typ=="X": break
ans = []
if "_" in name:
ans = name.split("_")
else:
j = 0
for i in range(1,len(name)):
if name[i].isupper():
ans.append(name[j:i])
j = i
ans.append(name[j:])
if typ=="D":
ans = map(str.lower, ans)
print(*ans,sep="_")
else:
ans = "".join(map(str.capitalize, ans))
if typ=="L":
ans = ans[0].lower() + ans[1:]
print(ans)
``` | instruction | 0 | 9,839 | 18 | 19,678 |
Yes | output | 1 | 9,839 | 18 | 19,679 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
Submitted Solution:
```
while True:
n, t = input().split()
if t == "X":
break
if "_" in n:
names = n.split("_")
else:
n = list(n)
for i, c in enumerate(n):
if c.isupper():
if i:
n[i] = "#" + c.lower()
else:
n[i] = c.lower()
names = "".join(n).split("#")
if t == "U":
print(*[name.title() for name in names], sep="")
elif t == "L":
print(*[name.title() if i != 0 else name for i, name in enumerate(names)], sep="")
else:
print(*names, sep="_")
``` | instruction | 0 | 9,840 | 18 | 19,680 |
Yes | output | 1 | 9,840 | 18 | 19,681 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
Submitted Solution:
```
while True:
Name, Type = input().split()
if Type=='X':
break
if '_' in Name:
Name_ = Name
_n_ = [0]
i = 0
while True:
Namelist_ = list(Name_)
n_ = Name_.find('_')
if n_==-1:
break
_n_.append(n_+_n_[i])
i += 1
del(Namelist_[0:n_+1])
Name_ = ''.join(Namelist_)
Name = ''.join(Name.split('_'))
Namelist = list(Name)
for i in range(len(_n_)):
o = str(Namelist[_n_[i]])
O = o.upper()
Namelist.pop(_n_[i])
Namelist.insert(_n_[i],O)
Name = ''.join(Namelist)
if Type=='U':
NameLIST = list(Name)
o = str(NameLIST[0])
O = o.upper()
NameLIST.pop(0)
NameLIST.insert(0,O)
NAME = ''.join(NameLIST)
if Type=='L':
NameLIST = list(Name)
O = str(NameLIST[0])
o = O.lower()
NameLIST.pop(0)
NameLIST.insert(0,o)
NAME = ''.join(NameLIST)
if Type=='D':
NameLIST = list(Name)
_T_ = []
t = 0
for i in range(len(NameLIST)):
T = str(NameLIST[i])
if T.isupper()==False:
pass
if T.isupper()==True:
if i==0:
pass
if i>0:
_T_.append(i+t)
t += 1
Tt = T.lower()
NameLIST.pop(i)
NameLIST.insert(i,Tt)
for i in range(len(_T_)):
NameLIST.insert(_T_[i],'_')
NAME = ''.join(NameLIST)
print(NAME)
``` | instruction | 0 | 9,841 | 18 | 19,682 |
Yes | output | 1 | 9,841 | 18 | 19,683 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
Submitted Solution:
```
while True:
s = input()
s, order = s.split()
if order == 'X':
break
if '_' in s:
if order == 'U':
s = s.split('_')
a = ''
for i in s:
a += i.capitalize()
print(a)
elif order == 'L':
s = s.split('_')
a = ''
a += s[0].lower()
for i in s[1:]:
a += i.capitalize()
print(a)
else:
print(s.lower())
else:
if order == 'U':
if s[0].isupper():
print(s)
else:
s = s[0].upper() + s[1:]
print(s)
elif order == 'L':
if s[0].islower():
print(s)
else:
s = s[0].lower() + s[1:]
print(s)
else:
index = []
c = 0
for i in range(len(s[1:])):
if s[i+1].isupper():
index.append(i + 1+c)
c += 1
for j in index:
s = s[: j] + '_' + s[j:]
print(s.lower())
``` | instruction | 0 | 9,842 | 18 | 19,684 |
Yes | output | 1 | 9,842 | 18 | 19,685 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
Submitted Solution:
```
import re
while True:
c, t = input().split()
if t == "X":
break
if t == "U":
if "_" in c:
tmp = c.split("_")
hoge = ""
for t in tmp:
hoge += t[0].upper() + t[1:]
c = hoge
else:
c = c[0].upper() + c[1:]
elif t == "L":
if "_" in c:
tmp = c.split("_")
flag = True if len(tmp) > 1 else False
hoge = ""
for t in tmp:
hoge += t[0].upper() + t[1:]
if flag:
hoge = hoge[0].lower() + hoge[1:]
c = hoge
else:
c = c[0].lower() + c[1:]
else:
tmp = re.findall('[a-zA-Z][a-z]+', c)
hoge = ""
for t in tmp:
hoge += t[0].lower() + t[1:] + "_"
c = hoge[:-1]
print(c)
``` | instruction | 0 | 9,843 | 18 | 19,686 |
No | output | 1 | 9,843 | 18 | 19,687 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
Submitted Solution:
```
import re
while True:
c, t = input().split()
if t == "X":
break
if t == "U":
if "_" in c:
tmp = c.split("_")
hoge = ""
for t in tmp:
hoge += t[0].upper() + t[1:]
c = hoge
else:
c = c[0].upper() + c[1:]
elif t == "L":
if "_" in c:
tmp = c.split("_")
flag = True if len(tmp) > 1 else False
hoge = ""
for t in tmp:
hoge += t[0].upper() + t[1:]
if flag:
hoge = hoge[0].lower() + hoge[1:]
c = hoge
else:
if re.match('[A-Z]', c):
c = c[0].lower() + c[1:]
else:
c = c[0].upper() + c[1:]
else:
tmp = re.findall('[a-zA-Z][a-z]+', c)
hoge = ""
for t in tmp:
hoge += t[0].lower() + t[1:] + "_"
c = hoge[:-1]
print(c)
``` | instruction | 0 | 9,844 | 18 | 19,688 |
No | output | 1 | 9,844 | 18 | 19,689 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
R3D3 spent some time on an internship in MDCS. After earning enough money, he decided to go on a holiday somewhere far, far away. He enjoyed suntanning, drinking alcohol-free cocktails and going to concerts of popular local bands. While listening to "The White Buttons" and their hit song "Dacan the Baker", he met another robot for whom he was sure is the love of his life. Well, his summer, at least. Anyway, R3D3 was too shy to approach his potential soulmate, so he decided to write her a love letter. However, he stumbled upon a problem. Due to a terrorist threat, the Intergalactic Space Police was monitoring all letters sent in the area. Thus, R3D3 decided to invent his own alphabet, for which he was sure his love would be able to decipher.
There are n letters in R3D3’s alphabet, and he wants to represent each letter as a sequence of '0' and '1', so that no letter’s sequence is a prefix of another letter's sequence. Since the Intergalactic Space Communications Service has lately introduced a tax for invented alphabets, R3D3 must pay a certain amount of money for each bit in his alphabet’s code (check the sample test for clarifications). He is too lovestruck to think clearly, so he asked you for help.
Given the costs c0 and c1 for each '0' and '1' in R3D3’s alphabet, respectively, you should come up with a coding for the alphabet (with properties as above) with minimum total cost.
Input
The first line of input contains three integers n (2 ≤ n ≤ 108), c0 and c1 (0 ≤ c0, c1 ≤ 108) — the number of letters in the alphabet, and costs of '0' and '1', respectively.
Output
Output a single integer — minimum possible total a cost of the whole alphabet.
Example
Input
4 1 2
Output
12
Note
There are 4 letters in the alphabet. The optimal encoding is "00", "01", "10", "11". There are 4 zeroes and 4 ones used, so the total cost is 4·1 + 4·2 = 12.
Submitted Solution:
```
import math
k,l,r=map(int,input().split())
print('%g'%(math.factorial(k)/2**(r-l)))
``` | instruction | 0 | 10,423 | 18 | 20,846 |
No | output | 1 | 10,423 | 18 | 20,847 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After overcoming the stairs Dasha came to classes. She needed to write a password to begin her classes. The password is a string of length n which satisfies the following requirements:
* There is at least one digit in the string,
* There is at least one lowercase (small) letter of the Latin alphabet in the string,
* There is at least one of three listed symbols in the string: '#', '*', '&'.
<image>
Considering that these are programming classes it is not easy to write the password.
For each character of the password we have a fixed string of length m, on each of these n strings there is a pointer on some character. The i-th character displayed on the screen is the pointed character in the i-th string. Initially, all pointers are on characters with indexes 1 in the corresponding strings (all positions are numbered starting from one).
During one operation Dasha can move a pointer in one string one character to the left or to the right. Strings are cyclic, it means that when we move the pointer which is on the character with index 1 to the left, it moves to the character with the index m, and when we move it to the right from the position m it moves to the position 1.
You need to determine the minimum number of operations necessary to make the string displayed on the screen a valid password.
Input
The first line contains two integers n, m (3 ≤ n ≤ 50, 1 ≤ m ≤ 50) — the length of the password and the length of strings which are assigned to password symbols.
Each of the next n lines contains the string which is assigned to the i-th symbol of the password string. Its length is m, it consists of digits, lowercase English letters, and characters '#', '*' or '&'.
You have such input data that you can always get a valid password.
Output
Print one integer — the minimum number of operations which is necessary to make the string, which is displayed on the screen, a valid password.
Examples
Input
3 4
1**2
a3*0
c4**
Output
1
Input
5 5
#*&#*
*a1c&
&q2w*
#a3c#
*&#*&
Output
3
Note
In the first test it is necessary to move the pointer of the third string to one left to get the optimal answer.
<image>
In the second test one of possible algorithms will be:
* to move the pointer of the second symbol once to the right.
* to move the pointer of the third symbol twice to the right.
<image>
Submitted Solution:
```
import math, sys, itertools
alpha = list('abcdefghijklmnopqrstuvwxyz')
digit = list('1234567890')
spec = ['*', '&', '#']
def find(s):
dpos = 10000
apos = 10000
spos = 10000
m = len(s)
for i in range(len(s)):
if s[i] in alpha:
if apos>min(m-i,i):
apos = min(m-i,i)
if s[i] in digit:
if dpos>min(m-i,i):
dpos = min(m-i,i)
if s[i] in spec:
if spos>min(m-i,i):
spos = min(m-i,i)
return apos, dpos, spos
def main():
n,m = map(int, input().split())
st = []
for i in range(n):
st.append(input())
al = []
dig = []
spec = []
for i in range(n):
a, d, s = (find(st[i]))
al.append(a)
dig.append(d)
spec.append(s)
sumn = 10000
for a in range(n):
for d in range(n):
for s in range(n):
if a!=d!=s:
if sumn>al[a]+dig[d]+spec[s]:
sumn = al[a]+dig[d]+spec[s]
print(sumn)
if __name__=="__main__":
main()
``` | instruction | 0 | 10,437 | 18 | 20,874 |
Yes | output | 1 | 10,437 | 18 | 20,875 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After overcoming the stairs Dasha came to classes. She needed to write a password to begin her classes. The password is a string of length n which satisfies the following requirements:
* There is at least one digit in the string,
* There is at least one lowercase (small) letter of the Latin alphabet in the string,
* There is at least one of three listed symbols in the string: '#', '*', '&'.
<image>
Considering that these are programming classes it is not easy to write the password.
For each character of the password we have a fixed string of length m, on each of these n strings there is a pointer on some character. The i-th character displayed on the screen is the pointed character in the i-th string. Initially, all pointers are on characters with indexes 1 in the corresponding strings (all positions are numbered starting from one).
During one operation Dasha can move a pointer in one string one character to the left or to the right. Strings are cyclic, it means that when we move the pointer which is on the character with index 1 to the left, it moves to the character with the index m, and when we move it to the right from the position m it moves to the position 1.
You need to determine the minimum number of operations necessary to make the string displayed on the screen a valid password.
Input
The first line contains two integers n, m (3 ≤ n ≤ 50, 1 ≤ m ≤ 50) — the length of the password and the length of strings which are assigned to password symbols.
Each of the next n lines contains the string which is assigned to the i-th symbol of the password string. Its length is m, it consists of digits, lowercase English letters, and characters '#', '*' or '&'.
You have such input data that you can always get a valid password.
Output
Print one integer — the minimum number of operations which is necessary to make the string, which is displayed on the screen, a valid password.
Examples
Input
3 4
1**2
a3*0
c4**
Output
1
Input
5 5
#*&#*
*a1c&
&q2w*
#a3c#
*&#*&
Output
3
Note
In the first test it is necessary to move the pointer of the third string to one left to get the optimal answer.
<image>
In the second test one of possible algorithms will be:
* to move the pointer of the second symbol once to the right.
* to move the pointer of the third symbol twice to the right.
<image>
Submitted Solution:
```
from sys import stdin, exit, setrecursionlimit
from collections import deque
from string import ascii_lowercase
from itertools import *
from math import *
input = stdin.readline
lmi = lambda: list(map(int, input().split()))
mi = lambda: map(int, input().split())
si = lambda: input().strip('\n')
ssi = lambda: input().strip('\n').split()
mod = 10**9+7
n, m = mi()
s = [si() for i in range(n)]
alle = []
for i in range(n):
e = [float("inf"), float("inf"), float("inf")]
for j in range(m):
if s[i][j] in "1234567890":
e[0] = min(e[0], j)
elif s[i][j] in ascii_lowercase:
e[1] = min(e[1], j)
elif s[i][j] in "#*&":
e[2] = min(e[2], j)
cnt = 0
for j in range(0, -m, -1):
if s[i][j] in "1234567890":
e[0] = min(e[0], cnt)
elif s[i][j] in ascii_lowercase:
e[1] = min(e[1], cnt)
elif s[i][j] in "#*&":
e[2] = min(e[2], cnt)
cnt += 1
alle.append(e)
ans = float("inf")
for i in range(n):
for j in range(n):
if i == j: continue
for k in range(n):
if k == i or k == j:
continue
ans = min(alle[i][0] + alle[j][1] + alle[k][2], ans)
print(ans)
``` | instruction | 0 | 10,438 | 18 | 20,876 |
Yes | output | 1 | 10,438 | 18 | 20,877 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After overcoming the stairs Dasha came to classes. She needed to write a password to begin her classes. The password is a string of length n which satisfies the following requirements:
* There is at least one digit in the string,
* There is at least one lowercase (small) letter of the Latin alphabet in the string,
* There is at least one of three listed symbols in the string: '#', '*', '&'.
<image>
Considering that these are programming classes it is not easy to write the password.
For each character of the password we have a fixed string of length m, on each of these n strings there is a pointer on some character. The i-th character displayed on the screen is the pointed character in the i-th string. Initially, all pointers are on characters with indexes 1 in the corresponding strings (all positions are numbered starting from one).
During one operation Dasha can move a pointer in one string one character to the left or to the right. Strings are cyclic, it means that when we move the pointer which is on the character with index 1 to the left, it moves to the character with the index m, and when we move it to the right from the position m it moves to the position 1.
You need to determine the minimum number of operations necessary to make the string displayed on the screen a valid password.
Input
The first line contains two integers n, m (3 ≤ n ≤ 50, 1 ≤ m ≤ 50) — the length of the password and the length of strings which are assigned to password symbols.
Each of the next n lines contains the string which is assigned to the i-th symbol of the password string. Its length is m, it consists of digits, lowercase English letters, and characters '#', '*' or '&'.
You have such input data that you can always get a valid password.
Output
Print one integer — the minimum number of operations which is necessary to make the string, which is displayed on the screen, a valid password.
Examples
Input
3 4
1**2
a3*0
c4**
Output
1
Input
5 5
#*&#*
*a1c&
&q2w*
#a3c#
*&#*&
Output
3
Note
In the first test it is necessary to move the pointer of the third string to one left to get the optimal answer.
<image>
In the second test one of possible algorithms will be:
* to move the pointer of the second symbol once to the right.
* to move the pointer of the third symbol twice to the right.
<image>
Submitted Solution:
```
def func(s):
a = 100000
for i in range(len(s)+1):
if(i==len(s)):
i = 100000
break
if(s[i].isalpha()):
break
for j in range(len(s)+1):
if(j==len(s)):
j = 100000
break
if(s[-j].isalpha()):
break
a = min(i, j)
b = 100000
for i in range(len(s)+1):
if(i==len(s)):
i = 100000
break
try:
n = int(s[i])
break
except:
continue
for j in range(len(s)+1):
if(j==len(s)):
j = 100000
break
try:
n = int(s[-j])
break
except:
continue
b = min(i, j)
c = 100000
for i in range(len(s)+1):
if(i==len(s)):
i = 100000
break
if(s[i]=='#' or s[i]=='&' or s[i]=='*'):
break
for j in range(len(s)+1):
if(j==len(s)):
j = 100000
break
if(s[-j]=='#' or s[-j]=='&' or s[-j]=='*'):
break
c = min(i, j)
return [a, b, c]
n, m = map(int, input().split())
x = []
for i in range(n):
s = input()
x += [func(s)]
mn = 1000000
for i in range(n):
for j in range(i+1, n):
for k in range(j+1, n):
a = x[i]
b = x[j]
c = x[k]
mn = min([mn, a[0]+b[1]+c[2], a[0]+b[2]+c[1], a[1]+b[0]+c[2], a[1]+b[2]+c[0], a[2]+b[1]+c[0], a[2]+b[0]+c[1]])
print(mn)
``` | instruction | 0 | 10,439 | 18 | 20,878 |
Yes | output | 1 | 10,439 | 18 | 20,879 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.