message
stringlengths 2
23.8k
| message_type
stringclasses 2
values | message_id
int64 0
1
| conversation_id
int64 97
109k
| cluster
float64 0
0
| __index_level_0__
int64 194
217k
|
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Paul hates palindromes. He assumes that string s is tolerable if each its character is one of the first p letters of the English alphabet and s doesn't contain any palindrome contiguous substring of length 2 or more.
Paul has found a tolerable string s of length n. Help him find the lexicographically next tolerable string of the same length or else state that such string does not exist.
Input
The first line contains two space-separated integers: n and p (1 ≤ n ≤ 1000; 1 ≤ p ≤ 26). The second line contains string s, consisting of n small English letters. It is guaranteed that the string is tolerable (according to the above definition).
Output
If the lexicographically next tolerable string of the same length exists, print it. Otherwise, print "NO" (without the quotes).
Examples
Input
3 3
cba
Output
NO
Input
3 4
cba
Output
cbd
Input
4 4
abcd
Output
abda
Note
String s is lexicographically larger (or simply larger) than string t with the same length, if there is number i, such that s1 = t1, ..., si = ti, si + 1 > ti + 1.
The lexicographically next tolerable string is the lexicographically minimum tolerable string which is larger than the given one.
A palindrome is a string that reads the same forward or reversed.
|
instruction
| 0
| 11,142
| 0
| 22,284
|
Tags: greedy, strings
Correct Solution:
```
n, p = map(int, input().split())
t, q = input(), 'NO'
if p == 2:
if t == 'a': q = 'b'
elif t == 'ab': q = 'ba'
elif p > 2:
t = [ord(c) - 97 for c in t] + [27, 27]
for k in range(n - 1, -1, -1):
for i in range(t[k] + 1, p):
if i - t[k - 1] and i - t[k - 2]:
t[k] = i
a, b = min(t[k - 1], 2), min(t[k], 2)
if a == b: a = 1
t = t[: k + 1] + [3 - a - b, a, b] * (n // 3 + 1)
print(''.join(chr(t[i] + 97) for i in range(n)))
exit(0)
print(q)
```
|
output
| 1
| 11,142
| 0
| 22,285
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Paul hates palindromes. He assumes that string s is tolerable if each its character is one of the first p letters of the English alphabet and s doesn't contain any palindrome contiguous substring of length 2 or more.
Paul has found a tolerable string s of length n. Help him find the lexicographically next tolerable string of the same length or else state that such string does not exist.
Input
The first line contains two space-separated integers: n and p (1 ≤ n ≤ 1000; 1 ≤ p ≤ 26). The second line contains string s, consisting of n small English letters. It is guaranteed that the string is tolerable (according to the above definition).
Output
If the lexicographically next tolerable string of the same length exists, print it. Otherwise, print "NO" (without the quotes).
Examples
Input
3 3
cba
Output
NO
Input
3 4
cba
Output
cbd
Input
4 4
abcd
Output
abda
Note
String s is lexicographically larger (or simply larger) than string t with the same length, if there is number i, such that s1 = t1, ..., si = ti, si + 1 > ti + 1.
The lexicographically next tolerable string is the lexicographically minimum tolerable string which is larger than the given one.
A palindrome is a string that reads the same forward or reversed.
|
instruction
| 0
| 11,143
| 0
| 22,286
|
Tags: greedy, strings
Correct Solution:
```
import sys
n, p = map(int, input().split())
s = input()
a = [(ord(s[i]) - ord('a') + 1) for i in range(n)]
curr = len(s) - 1
a += [p + 1, p + 1]
f = 0
def valid(x):
global f
if x == -1:
return False
if not (a[x] + 1 in (a[x - 1], a[x - 2])) and a[x] + 1 <= p:
a[x] += 1
elif not (a[x] + 2 in (a[x - 1], a[x - 2])) and a[x] + 2 <= p:
a[x] += 2
elif not (a[x] + 3 in (a[x - 1], a[x - 2])) and a[x] + 3 <= p:
a[x] += 3
else:
return True
print(s[:x], end = '')
print(chr(a[x] + ord('a') - 1), end = '')
tmp = 1
ind = x
while tmp in (a[x], a[x - 1]):
tmp += 1
for i in range(x + 1, len(s)):
print(chr(tmp + ord('a') - 1), end = '')
a[i] = tmp
tmp = 1
while tmp in (a[i], a[i - 1]):
tmp += 1
f = 1
return False
while valid(curr):
curr -= 1
if f == 1:
sys.exit()
print('NO')
```
|
output
| 1
| 11,143
| 0
| 22,287
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Paul hates palindromes. He assumes that string s is tolerable if each its character is one of the first p letters of the English alphabet and s doesn't contain any palindrome contiguous substring of length 2 or more.
Paul has found a tolerable string s of length n. Help him find the lexicographically next tolerable string of the same length or else state that such string does not exist.
Input
The first line contains two space-separated integers: n and p (1 ≤ n ≤ 1000; 1 ≤ p ≤ 26). The second line contains string s, consisting of n small English letters. It is guaranteed that the string is tolerable (according to the above definition).
Output
If the lexicographically next tolerable string of the same length exists, print it. Otherwise, print "NO" (without the quotes).
Examples
Input
3 3
cba
Output
NO
Input
3 4
cba
Output
cbd
Input
4 4
abcd
Output
abda
Note
String s is lexicographically larger (or simply larger) than string t with the same length, if there is number i, such that s1 = t1, ..., si = ti, si + 1 > ti + 1.
The lexicographically next tolerable string is the lexicographically minimum tolerable string which is larger than the given one.
A palindrome is a string that reads the same forward or reversed.
|
instruction
| 0
| 11,144
| 0
| 22,288
|
Tags: greedy, strings
Correct Solution:
```
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
# from fractions import *
# from heapq import*
from bisect import *
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
ALPHA='abcdefghijklmnopqrstuvwxyz/'
M=10**9+7
EPS=1e-6
def Ceil(a,b): return a//b+int(a%b>0)
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
# vsInput()
n,p=value()
s=list(input())[::-1]
s[0]=ALPHA[ALPHA.index(s[0])+1]
i=0
while(i>=0 and i<n):
cur=ALPHA.index(s[i])
if(cur>=p):
s[i]='a'
i+=1
if(i<n): s[i]=ALPHA[ALPHA.index(s[i])+1]
else:
if(i+1<n and s[i+1]==s[i]):
s[i]=ALPHA[ALPHA.index(s[i])+1]
elif(i+2<n and s[i+2]==s[i]):
s[i]=ALPHA[ALPHA.index(s[i])+1]
else:
i-=1
s=s[::-1]
if(s==['a']*n): print("NO")
else: print(*s,sep="")
```
|
output
| 1
| 11,144
| 0
| 22,289
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Paul hates palindromes. He assumes that string s is tolerable if each its character is one of the first p letters of the English alphabet and s doesn't contain any palindrome contiguous substring of length 2 or more.
Paul has found a tolerable string s of length n. Help him find the lexicographically next tolerable string of the same length or else state that such string does not exist.
Input
The first line contains two space-separated integers: n and p (1 ≤ n ≤ 1000; 1 ≤ p ≤ 26). The second line contains string s, consisting of n small English letters. It is guaranteed that the string is tolerable (according to the above definition).
Output
If the lexicographically next tolerable string of the same length exists, print it. Otherwise, print "NO" (without the quotes).
Examples
Input
3 3
cba
Output
NO
Input
3 4
cba
Output
cbd
Input
4 4
abcd
Output
abda
Note
String s is lexicographically larger (or simply larger) than string t with the same length, if there is number i, such that s1 = t1, ..., si = ti, si + 1 > ti + 1.
The lexicographically next tolerable string is the lexicographically minimum tolerable string which is larger than the given one.
A palindrome is a string that reads the same forward or reversed.
|
instruction
| 0
| 11,145
| 0
| 22,290
|
Tags: greedy, strings
Correct Solution:
```
n,p=map(int,input().split())
s=list(map(ord,input()))
index=n-1
s[n-1]+=1
p+=97
while(index>=0 and index<n):
if(s[index]>=p):
s[index]=97
index-=1
s[index]+=1
elif (index!=0 and s[index]==s[index-1]):
s[index]+=1
elif(index>1 and s[index]==s[index-2]):
s[index]+=1
else:
index+=1
if(index<0): print("NO")
else:
for i in s: print(chr(i), end="")
```
|
output
| 1
| 11,145
| 0
| 22,291
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Paul hates palindromes. He assumes that string s is tolerable if each its character is one of the first p letters of the English alphabet and s doesn't contain any palindrome contiguous substring of length 2 or more.
Paul has found a tolerable string s of length n. Help him find the lexicographically next tolerable string of the same length or else state that such string does not exist.
Input
The first line contains two space-separated integers: n and p (1 ≤ n ≤ 1000; 1 ≤ p ≤ 26). The second line contains string s, consisting of n small English letters. It is guaranteed that the string is tolerable (according to the above definition).
Output
If the lexicographically next tolerable string of the same length exists, print it. Otherwise, print "NO" (without the quotes).
Examples
Input
3 3
cba
Output
NO
Input
3 4
cba
Output
cbd
Input
4 4
abcd
Output
abda
Note
String s is lexicographically larger (or simply larger) than string t with the same length, if there is number i, such that s1 = t1, ..., si = ti, si + 1 > ti + 1.
The lexicographically next tolerable string is the lexicographically minimum tolerable string which is larger than the given one.
A palindrome is a string that reads the same forward or reversed.
|
instruction
| 0
| 11,146
| 0
| 22,292
|
Tags: greedy, strings
Correct Solution:
```
#!/usr/bin/env python
# coding: utf-8
# In[11]:
n,p=map(int,input().split())
s=list(map(ord,input()))
i=n-1
s[i]+=1
p+=97
while ~i and i<n:
if s[i]==p:
s[i]=97
i-=1
s[i]+=1
elif i and s[i]==s[i-1]:
s[i]+=1
elif i>1 and s[i]==s[i-2]:
s[i]+=1
else:
i+=1
if i<0:
print('NO')
else:
#print('Yes')
for i in s:
print(chr(i),end='')
```
|
output
| 1
| 11,146
| 0
| 22,293
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Paul hates palindromes. He assumes that string s is tolerable if each its character is one of the first p letters of the English alphabet and s doesn't contain any palindrome contiguous substring of length 2 or more.
Paul has found a tolerable string s of length n. Help him find the lexicographically next tolerable string of the same length or else state that such string does not exist.
Input
The first line contains two space-separated integers: n and p (1 ≤ n ≤ 1000; 1 ≤ p ≤ 26). The second line contains string s, consisting of n small English letters. It is guaranteed that the string is tolerable (according to the above definition).
Output
If the lexicographically next tolerable string of the same length exists, print it. Otherwise, print "NO" (without the quotes).
Examples
Input
3 3
cba
Output
NO
Input
3 4
cba
Output
cbd
Input
4 4
abcd
Output
abda
Note
String s is lexicographically larger (or simply larger) than string t with the same length, if there is number i, such that s1 = t1, ..., si = ti, si + 1 > ti + 1.
The lexicographically next tolerable string is the lexicographically minimum tolerable string which is larger than the given one.
A palindrome is a string that reads the same forward or reversed.
|
instruction
| 0
| 11,147
| 0
| 22,294
|
Tags: greedy, strings
Correct Solution:
```
n, p = map(int, input().split())
t = [ord(c) - 97 for c in input()] + [27, 27]
for k in range(n - 1, -1, -1):
for i in range(t[k] + 1, p):
if i - t[k - 1] and i - t[k - 2]:
a, b = min(t[k - 1], 2), min(i, 2)
if a == b: a = 1
t = t[: k] + [i] + [3 - a - b, a, b] * (n // 3 + 1)
print(''.join(chr(i + 97) for i in t)[: n])
exit(0)
print('NO')
```
|
output
| 1
| 11,147
| 0
| 22,295
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Paul hates palindromes. He assumes that string s is tolerable if each its character is one of the first p letters of the English alphabet and s doesn't contain any palindrome contiguous substring of length 2 or more.
Paul has found a tolerable string s of length n. Help him find the lexicographically next tolerable string of the same length or else state that such string does not exist.
Input
The first line contains two space-separated integers: n and p (1 ≤ n ≤ 1000; 1 ≤ p ≤ 26). The second line contains string s, consisting of n small English letters. It is guaranteed that the string is tolerable (according to the above definition).
Output
If the lexicographically next tolerable string of the same length exists, print it. Otherwise, print "NO" (without the quotes).
Examples
Input
3 3
cba
Output
NO
Input
3 4
cba
Output
cbd
Input
4 4
abcd
Output
abda
Note
String s is lexicographically larger (or simply larger) than string t with the same length, if there is number i, such that s1 = t1, ..., si = ti, si + 1 > ti + 1.
The lexicographically next tolerable string is the lexicographically minimum tolerable string which is larger than the given one.
A palindrome is a string that reads the same forward or reversed.
|
instruction
| 0
| 11,148
| 0
| 22,296
|
Tags: greedy, strings
Correct Solution:
```
import sys
import math as mt
import bisect
#input=sys.stdin.buffer.readline
#t=int(input())
t=1
for __ in range(t):
#s=input()
#n=int(input())
n,p=map(int,input().split())
#l=list(map(int,input().split()))
up=chr(p+96)
s=input()
ind=-1
for i in range(len(s)-1,-1,-1):
if i>=2:
for j in range(26):
if chr(97+j)>s[i] and chr(97+j)<=up and chr(97+j)!=s[i-1] and chr(97+j)!=s[i-2]:
ind=i
ch=chr(97+j)
break
elif i==1:
for j in range(26):
if chr(97+j)>s[i] and chr(97+j)<=up and chr(97+j)!=s[i-1] :
ind=i
ch=chr(97+j)
break
else:
for j in range(26):
if chr(97+j)>s[i] and chr(97+j)<=up:
ind=i
ch=chr(97+j)
#ch1='stop'
break
if ind!=-1:
break
if ind==-1:
print("NO")
else:
s1=s[:ind]
s1+=ch
falg=True
#print(111,ch)
for j in range(ind+1,len(s)):
ch2=0
for j1 in range(26):
if len(s1)<=1:
if chr(j1+97)!=s1[-1] and chr(j1+97)<=up:
s1+=chr(j1+97)
ch2=1
break
else:
if chr(j1+97)!=s1[-1] and chr(j1+97)!=s1[-2] and chr(j1+97)<=up:
ch2=1
s1+=chr(j1+97)
break
if ch2==1:
break
if ch2==0:
falg=False
if falg==True:
print(s1)
else:
print("NO")
```
|
output
| 1
| 11,148
| 0
| 22,297
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Paul hates palindromes. He assumes that string s is tolerable if each its character is one of the first p letters of the English alphabet and s doesn't contain any palindrome contiguous substring of length 2 or more.
Paul has found a tolerable string s of length n. Help him find the lexicographically next tolerable string of the same length or else state that such string does not exist.
Input
The first line contains two space-separated integers: n and p (1 ≤ n ≤ 1000; 1 ≤ p ≤ 26). The second line contains string s, consisting of n small English letters. It is guaranteed that the string is tolerable (according to the above definition).
Output
If the lexicographically next tolerable string of the same length exists, print it. Otherwise, print "NO" (without the quotes).
Examples
Input
3 3
cba
Output
NO
Input
3 4
cba
Output
cbd
Input
4 4
abcd
Output
abda
Note
String s is lexicographically larger (or simply larger) than string t with the same length, if there is number i, such that s1 = t1, ..., si = ti, si + 1 > ti + 1.
The lexicographically next tolerable string is the lexicographically minimum tolerable string which is larger than the given one.
A palindrome is a string that reads the same forward or reversed.
Submitted Solution:
```
def clean(n,w,i):
for j in range(i+1,n):
if 0 not in [w[j-1],w[j-2]]:
w[j] = 0
elif 1 not in [w[j-1],w[j-2]]:
w[j] = 1
else:
w[j] = 2
return ''.join([chr(ord('a')+x) for x in w])
def solve():
n, p = map(int, input().split())
w = [ord(c)-ord('a') for c in input()]
if p==1:
return 'NO'
elif p==2:
if n==1 and w[0]==0:
return 'b'
elif n==2 and w[0]==0:
return 'ba'
else:
return 'NO'
elif n==1:
if w[0]==p-1:
return 'NO'
else:
return chr(ord('a')+w[0]+1)
for i in range(n-1,1,-1):
for k in range(1,3+1):
if w[i]+k not in [w[i-1],w[i-2]] and w[i]+k < p:
w[i] += k
return clean(n,w,i)
for k in range(1,2+1):
if w[1]+k not in [w[0]] and w[1]+k < p:
w[1] += k
return clean(n,w,1)
if w[0]+1 < p:
w[0] += 1
w[1] = 0
return clean(n,w,1)
return 'NO'
print(solve())
```
|
instruction
| 0
| 11,149
| 0
| 22,298
|
Yes
|
output
| 1
| 11,149
| 0
| 22,299
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Paul hates palindromes. He assumes that string s is tolerable if each its character is one of the first p letters of the English alphabet and s doesn't contain any palindrome contiguous substring of length 2 or more.
Paul has found a tolerable string s of length n. Help him find the lexicographically next tolerable string of the same length or else state that such string does not exist.
Input
The first line contains two space-separated integers: n and p (1 ≤ n ≤ 1000; 1 ≤ p ≤ 26). The second line contains string s, consisting of n small English letters. It is guaranteed that the string is tolerable (according to the above definition).
Output
If the lexicographically next tolerable string of the same length exists, print it. Otherwise, print "NO" (without the quotes).
Examples
Input
3 3
cba
Output
NO
Input
3 4
cba
Output
cbd
Input
4 4
abcd
Output
abda
Note
String s is lexicographically larger (or simply larger) than string t with the same length, if there is number i, such that s1 = t1, ..., si = ti, si + 1 > ti + 1.
The lexicographically next tolerable string is the lexicographically minimum tolerable string which is larger than the given one.
A palindrome is a string that reads the same forward or reversed.
Submitted Solution:
```
def trans(c):
return chr(ord(c) + 1)
n, p = list(map(int, input().split()))
s = list(input())
s[n-1] = trans(s[n-1])
i = n - 1
while i >= 0 and i < n:
if ord(s[i]) >= ord('a') + p:
s[i] = 'a'
i -= 1
s[i] = trans(s[i])
elif i > 0 and s[i] == s[i-1] or i > 1 and s[i] == s[i-2]:
s[i] = trans(s[i])
else:
i += 1
else:
print("NO" if i < 0 else "".join(s))
# Made By Mostafa_Khaled
```
|
instruction
| 0
| 11,150
| 0
| 22,300
|
Yes
|
output
| 1
| 11,150
| 0
| 22,301
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Paul hates palindromes. He assumes that string s is tolerable if each its character is one of the first p letters of the English alphabet and s doesn't contain any palindrome contiguous substring of length 2 or more.
Paul has found a tolerable string s of length n. Help him find the lexicographically next tolerable string of the same length or else state that such string does not exist.
Input
The first line contains two space-separated integers: n and p (1 ≤ n ≤ 1000; 1 ≤ p ≤ 26). The second line contains string s, consisting of n small English letters. It is guaranteed that the string is tolerable (according to the above definition).
Output
If the lexicographically next tolerable string of the same length exists, print it. Otherwise, print "NO" (without the quotes).
Examples
Input
3 3
cba
Output
NO
Input
3 4
cba
Output
cbd
Input
4 4
abcd
Output
abda
Note
String s is lexicographically larger (or simply larger) than string t with the same length, if there is number i, such that s1 = t1, ..., si = ti, si + 1 > ti + 1.
The lexicographically next tolerable string is the lexicographically minimum tolerable string which is larger than the given one.
A palindrome is a string that reads the same forward or reversed.
Submitted Solution:
```
import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
import copy
import time
starttime = time.time()
mod = int(pow(10, 9) + 7)
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(*var, end="\n"): sys.stdout.write(' '.join(map(str, var))+end)
def L(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]
try:
# sys.setrecursionlimit(int(pow(10,4)))
sys.stdin = open("input.txt", "r")
# sys.stdout = open("../output.txt", "w")
except:
pass
def pmat(A):
for ele in A:
print(*ele,end="\n")
# def seive():
# prime=[1 for i in range(10**6+1)]
# prime[0]=0
# prime[1]=0
# for i in range(10**6+1):
# if(prime[i]):
# for j in range(2*i,10**6+1,i):
# prime[j]=0
# return prime
n, p = list(map(int, input().split()))
s = list(input())
s[n-1] = chr(ord(s[n-1]) + 1)
i = n - 1
while i >= 0 and i < n:
if ord(s[i]) >= ord('a') + p:
s[i] = 'a'
i -= 1
s[i] = chr(ord(s[i]) + 1)
elif i > 0 and s[i] == s[i-1] or i > 1 and s[i] == s[i-2]:
s[i] = chr(ord(s[i]) + 1)
else:
i += 1
print("NO" if i < 0 else "".join(s))
endtime = time.time()
# print(f"Runtime of the program is {endtime - starttime}")
```
|
instruction
| 0
| 11,151
| 0
| 22,302
|
Yes
|
output
| 1
| 11,151
| 0
| 22,303
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Paul hates palindromes. He assumes that string s is tolerable if each its character is one of the first p letters of the English alphabet and s doesn't contain any palindrome contiguous substring of length 2 or more.
Paul has found a tolerable string s of length n. Help him find the lexicographically next tolerable string of the same length or else state that such string does not exist.
Input
The first line contains two space-separated integers: n and p (1 ≤ n ≤ 1000; 1 ≤ p ≤ 26). The second line contains string s, consisting of n small English letters. It is guaranteed that the string is tolerable (according to the above definition).
Output
If the lexicographically next tolerable string of the same length exists, print it. Otherwise, print "NO" (without the quotes).
Examples
Input
3 3
cba
Output
NO
Input
3 4
cba
Output
cbd
Input
4 4
abcd
Output
abda
Note
String s is lexicographically larger (or simply larger) than string t with the same length, if there is number i, such that s1 = t1, ..., si = ti, si + 1 > ti + 1.
The lexicographically next tolerable string is the lexicographically minimum tolerable string which is larger than the given one.
A palindrome is a string that reads the same forward or reversed.
Submitted Solution:
```
def palin(a):
a = a-1
m = len(c)-1
if(a>=0):
if(c[a] == c[a+2]):
return 1
return 0;
def inc(i):
if(len(c)==1):
if(ord(c[i]) - 96 == b):
print("NO");
exit()
else:
c[i] = chr(ord(c[i])+1)
return 0;
if(ord(c[i]) - 96 == b):
c[i] = 'a'
if(i == 1):
if(c[0] == chr(96+b)):
print("NO")
exit()
inc(i-1)
if(c[i] == c[i-1] or palin(i-1)):
inc(i);
else:
c[i] = chr(ord(c[i])+1)
if(c[i] == c[i-1] or palin(i-1)):
inc(i)
a,b = map(int,input().split(" "))
c = list(input())
e = 1
i = a-1
inc(i)
print(''.join(c))
```
|
instruction
| 0
| 11,152
| 0
| 22,304
|
Yes
|
output
| 1
| 11,152
| 0
| 22,305
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Paul hates palindromes. He assumes that string s is tolerable if each its character is one of the first p letters of the English alphabet and s doesn't contain any palindrome contiguous substring of length 2 or more.
Paul has found a tolerable string s of length n. Help him find the lexicographically next tolerable string of the same length or else state that such string does not exist.
Input
The first line contains two space-separated integers: n and p (1 ≤ n ≤ 1000; 1 ≤ p ≤ 26). The second line contains string s, consisting of n small English letters. It is guaranteed that the string is tolerable (according to the above definition).
Output
If the lexicographically next tolerable string of the same length exists, print it. Otherwise, print "NO" (without the quotes).
Examples
Input
3 3
cba
Output
NO
Input
3 4
cba
Output
cbd
Input
4 4
abcd
Output
abda
Note
String s is lexicographically larger (or simply larger) than string t with the same length, if there is number i, such that s1 = t1, ..., si = ti, si + 1 > ti + 1.
The lexicographically next tolerable string is the lexicographically minimum tolerable string which is larger than the given one.
A palindrome is a string that reads the same forward or reversed.
Submitted Solution:
```
def main():
def f(s, n, p):
if n == 2 and s[0] == s[1]:
return False
for i in range(0, n - 1):
if ord(s[i]) - ord('a') >= p:
return False
if s[i] == s[i + 1]:
return False
for i in range(0, n - 2):
if s[i] == s[i + 2]:
return False
return True
(n, p) = map(int, input().split(' '))
s = list(input())
if n == 1:
if ord(s[0]) - ord('a') >= p:
return "NO"
else:
return chr(ord(s[0]) + 1)
i = n - 1
while True:
if i < 1:
break
s[i] = chr(ord(s[i]) + 1)
if (ord(s[i]) - ord('a')) >= p:
s[i] = 'a'
m = True
i -= 1
s[i] = chr(ord(s[i]) + 1)
#print(' '.join(s), i, n)
if s[i] != s[i - 1]:
if i >= 2 and s[i - 2] != s[i]:
break
if f(s, n, p):
return ''.join(s)
return "NO"
print(main())
```
|
instruction
| 0
| 11,153
| 0
| 22,306
|
No
|
output
| 1
| 11,153
| 0
| 22,307
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Paul hates palindromes. He assumes that string s is tolerable if each its character is one of the first p letters of the English alphabet and s doesn't contain any palindrome contiguous substring of length 2 or more.
Paul has found a tolerable string s of length n. Help him find the lexicographically next tolerable string of the same length or else state that such string does not exist.
Input
The first line contains two space-separated integers: n and p (1 ≤ n ≤ 1000; 1 ≤ p ≤ 26). The second line contains string s, consisting of n small English letters. It is guaranteed that the string is tolerable (according to the above definition).
Output
If the lexicographically next tolerable string of the same length exists, print it. Otherwise, print "NO" (without the quotes).
Examples
Input
3 3
cba
Output
NO
Input
3 4
cba
Output
cbd
Input
4 4
abcd
Output
abda
Note
String s is lexicographically larger (or simply larger) than string t with the same length, if there is number i, such that s1 = t1, ..., si = ti, si + 1 > ti + 1.
The lexicographically next tolerable string is the lexicographically minimum tolerable string which is larger than the given one.
A palindrome is a string that reads the same forward or reversed.
Submitted Solution:
```
n, p = map(int, input().split())
t = input()
s = [chr(97 + i) for i in range(p)]
def f1(t):
i = s.index(t)
if i < p - 1: return s[i + 1]
return 'NO'
def f2(t):
x, y = t
for a in s:
if a < x: continue
for b in s:
if b == a or (a == x and b <= y): continue
return a + b
return 'NO'
def f3(t):
t = '..' + t
x, y, z = t[n - 1: ]
u, v = t[-4], t[-5]
for a in s:
if a == u or a == v or a < x: continue
for b in s:
if b == a or b == v or (a == x and b < y): continue
for c in s:
if c == b or c == a or (a == x and b == y and c <= z): continue
return t[2: n - 1] + a + b + c
return 'NO'
if n == 1: print(f1(t))
elif n == 2: print(f2(t))
else: print(f3(t))
```
|
instruction
| 0
| 11,154
| 0
| 22,308
|
No
|
output
| 1
| 11,154
| 0
| 22,309
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Paul hates palindromes. He assumes that string s is tolerable if each its character is one of the first p letters of the English alphabet and s doesn't contain any palindrome contiguous substring of length 2 or more.
Paul has found a tolerable string s of length n. Help him find the lexicographically next tolerable string of the same length or else state that such string does not exist.
Input
The first line contains two space-separated integers: n and p (1 ≤ n ≤ 1000; 1 ≤ p ≤ 26). The second line contains string s, consisting of n small English letters. It is guaranteed that the string is tolerable (according to the above definition).
Output
If the lexicographically next tolerable string of the same length exists, print it. Otherwise, print "NO" (without the quotes).
Examples
Input
3 3
cba
Output
NO
Input
3 4
cba
Output
cbd
Input
4 4
abcd
Output
abda
Note
String s is lexicographically larger (or simply larger) than string t with the same length, if there is number i, such that s1 = t1, ..., si = ti, si + 1 > ti + 1.
The lexicographically next tolerable string is the lexicographically minimum tolerable string which is larger than the given one.
A palindrome is a string that reads the same forward or reversed.
Submitted Solution:
```
def is_tolerable(s):
n = len(s)
t1, t2 = -1, -1
tolerable = 1
for i in range(n - 1, 0, -1):
if s[i] == s[i - 1]:
t1 = i
break
for i in range(n - 2, 0, -1):
if s[i + 1] == s[i - 1]:
t2 = i + 1
break
tolerable = max(t1, t2)
return tolerable
def increment_string(s, m, i):
j = i
flag = 0
while flag == 0 and j >= 0:
flag = 1
x = ord(s[j]) % ord('a')
y = ord(m) % ord('a') + 1
z = (x + 1) % y
t = z + ord('a')
li = list(s)
li[j] = chr(t)
s = "".join(li)
if z == 0:
flag = 0
j -= 1
if j == -1:
s = "NO"
return s
n, p = list(map(int, input().split()))
s = input()
m = ord('a') + p - 1
ans = s
flag = 0
i = n - 1
while flag == 0:
flag = 1
ans = increment_string(ans, chr(m), i)
if ans == "NO":
break
t = is_tolerable(ans)
if t != -1:
flag = 0
i = t
print(ans)
```
|
instruction
| 0
| 11,155
| 0
| 22,310
|
No
|
output
| 1
| 11,155
| 0
| 22,311
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Paul hates palindromes. He assumes that string s is tolerable if each its character is one of the first p letters of the English alphabet and s doesn't contain any palindrome contiguous substring of length 2 or more.
Paul has found a tolerable string s of length n. Help him find the lexicographically next tolerable string of the same length or else state that such string does not exist.
Input
The first line contains two space-separated integers: n and p (1 ≤ n ≤ 1000; 1 ≤ p ≤ 26). The second line contains string s, consisting of n small English letters. It is guaranteed that the string is tolerable (according to the above definition).
Output
If the lexicographically next tolerable string of the same length exists, print it. Otherwise, print "NO" (without the quotes).
Examples
Input
3 3
cba
Output
NO
Input
3 4
cba
Output
cbd
Input
4 4
abcd
Output
abda
Note
String s is lexicographically larger (or simply larger) than string t with the same length, if there is number i, such that s1 = t1, ..., si = ti, si + 1 > ti + 1.
The lexicographically next tolerable string is the lexicographically minimum tolerable string which is larger than the given one.
A palindrome is a string that reads the same forward or reversed.
Submitted Solution:
```
n, p = map(int, input().split())
r = list(reversed(list(map(lambda c: ord(c) - ord("a"), list(input())))))
def checker(lst, pos):
l = lst[max(0, pos - 2):pos + 3]
for i in range(len(l) - 1):
if l[i] == l[i+1]:
return False
for i in range(len(l) - 2):
if l[i] == l[i+2]:
return False
return True
result = "NO"
while 1:
flag = True
changed = []
for i in range(len(r)):
if flag:
r[i] += 1
changed.append(i)
if r[i] == p:
r[i] = 0
flag = True
else:
flag = False
if flag:
break
# print(r, changed)
if all((checker(r, i) for i in changed)):
result = "".join(list(map(lambda x: chr(x + ord("a")), reversed(r))))
break
print(result)
```
|
instruction
| 0
| 11,156
| 0
| 22,312
|
No
|
output
| 1
| 11,156
| 0
| 22,313
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Genos recently installed the game Zuma on his phone. In Zuma there exists a line of n gemstones, the i-th of which has color ci. The goal of the game is to destroy all the gemstones in the line as quickly as possible.
In one second, Genos is able to choose exactly one continuous substring of colored gemstones that is a palindrome and remove it from the line. After the substring is removed, the remaining gemstones shift to form a solid line again. What is the minimum number of seconds needed to destroy the entire line?
Let us remind, that the string (or substring) is called palindrome, if it reads same backwards or forward. In our case this means the color of the first gemstone is equal to the color of the last one, the color of the second gemstone is equal to the color of the next to last and so on.
Input
The first line of input contains a single integer n (1 ≤ n ≤ 500) — the number of gemstones.
The second line contains n space-separated integers, the i-th of which is ci (1 ≤ ci ≤ n) — the color of the i-th gemstone in a line.
Output
Print a single integer — the minimum number of seconds needed to destroy the entire line.
Examples
Input
3
1 2 1
Output
1
Input
3
1 2 3
Output
3
Input
7
1 4 4 2 3 2 1
Output
2
Note
In the first sample, Genos can destroy the entire line in one second.
In the second sample, Genos can only destroy one gemstone at a time, so destroying three gemstones takes three seconds.
In the third sample, to achieve the optimal time of two seconds, destroy palindrome 4 4 first and then destroy palindrome 1 2 3 2 1.
|
instruction
| 0
| 11,210
| 0
| 22,420
|
Tags: dp
Correct Solution:
```
from sys import stdin,stdout
for _ in range(1):#(stdin.readline())):
n=int(stdin.readline())
# n,m=list(map(int,stdin.readline().split()))
a=list(map(int,stdin.readline().split()))
dp=[[0 for _ in range(n)] for _ in range(n)]
for sz in range(n):
for i in range(n-sz):
j=i+sz
# print(i,j)
if sz==0:dp[i][j]=1
elif sz==1:dp[i][j]=1+int(a[i]!=a[j])
else:
v=n
if a[i]==a[j]:v=dp[i+1][j-1]
for k in range(i,j):
v=min(v,dp[i][k]+dp[k+1][j])
dp[i][j]=v
# print(*dp,sep='\n')
print(dp[0][n-1])
```
|
output
| 1
| 11,210
| 0
| 22,421
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Genos recently installed the game Zuma on his phone. In Zuma there exists a line of n gemstones, the i-th of which has color ci. The goal of the game is to destroy all the gemstones in the line as quickly as possible.
In one second, Genos is able to choose exactly one continuous substring of colored gemstones that is a palindrome and remove it from the line. After the substring is removed, the remaining gemstones shift to form a solid line again. What is the minimum number of seconds needed to destroy the entire line?
Let us remind, that the string (or substring) is called palindrome, if it reads same backwards or forward. In our case this means the color of the first gemstone is equal to the color of the last one, the color of the second gemstone is equal to the color of the next to last and so on.
Input
The first line of input contains a single integer n (1 ≤ n ≤ 500) — the number of gemstones.
The second line contains n space-separated integers, the i-th of which is ci (1 ≤ ci ≤ n) — the color of the i-th gemstone in a line.
Output
Print a single integer — the minimum number of seconds needed to destroy the entire line.
Examples
Input
3
1 2 1
Output
1
Input
3
1 2 3
Output
3
Input
7
1 4 4 2 3 2 1
Output
2
Note
In the first sample, Genos can destroy the entire line in one second.
In the second sample, Genos can only destroy one gemstone at a time, so destroying three gemstones takes three seconds.
In the third sample, to achieve the optimal time of two seconds, destroy palindrome 4 4 first and then destroy palindrome 1 2 3 2 1.
|
instruction
| 0
| 11,212
| 0
| 22,424
|
Tags: dp
Correct Solution:
```
dp = [[-1 for i in range(505)] for j in range(505)]
n = int(input())
A = [int(i) for i in input().split()]
def do(i, j):
#print('At',i , j)
if i>=j:
dp[i][j] = 1
return 1
if dp[i][j] != -1:
return dp[i][j]
ans = len(A)
if A[i] == A[j]:
ans = min(ans, do(i+1, j-1))
for x in range(i, j):
left = do(i, x)
right = do(x+1, j)
ans = min(ans, left+right)
dp[i][j] = ans
return ans
if len(set(A)) == n:
print(n)
else:
print(do(0, n-1))
```
|
output
| 1
| 11,212
| 0
| 22,425
|
Provide tags and a correct Python 2 solution for this coding contest problem.
Genos recently installed the game Zuma on his phone. In Zuma there exists a line of n gemstones, the i-th of which has color ci. The goal of the game is to destroy all the gemstones in the line as quickly as possible.
In one second, Genos is able to choose exactly one continuous substring of colored gemstones that is a palindrome and remove it from the line. After the substring is removed, the remaining gemstones shift to form a solid line again. What is the minimum number of seconds needed to destroy the entire line?
Let us remind, that the string (or substring) is called palindrome, if it reads same backwards or forward. In our case this means the color of the first gemstone is equal to the color of the last one, the color of the second gemstone is equal to the color of the next to last and so on.
Input
The first line of input contains a single integer n (1 ≤ n ≤ 500) — the number of gemstones.
The second line contains n space-separated integers, the i-th of which is ci (1 ≤ ci ≤ n) — the color of the i-th gemstone in a line.
Output
Print a single integer — the minimum number of seconds needed to destroy the entire line.
Examples
Input
3
1 2 1
Output
1
Input
3
1 2 3
Output
3
Input
7
1 4 4 2 3 2 1
Output
2
Note
In the first sample, Genos can destroy the entire line in one second.
In the second sample, Genos can only destroy one gemstone at a time, so destroying three gemstones takes three seconds.
In the third sample, to achieve the optimal time of two seconds, destroy palindrome 4 4 first and then destroy palindrome 1 2 3 2 1.
|
instruction
| 0
| 11,213
| 0
| 22,426
|
Tags: dp
Correct Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
raw_input = stdin.readline
pr = stdout.write
def in_num():
return int(raw_input())
def in_arr():
return map(int,raw_input().split())
def pr_num(n):
stdout.write(str(n)+'\n')
def pr_arr(arr):
pr(' '.join(map(str,arr))+'\n')
# fast read function for total integer input
def inp():
# this function returns whole input of
# space/line seperated integers
# Use Ctrl+D to flush stdin.
return map(int,stdin.read().split())
range = xrange # not for python 3.0+
# main code
n=in_num()
l=in_arr()
dp=[[1 for i in range(n)] for j in range(n)]
for ln in range(1,n):
for i in range(n-ln):
dp[i][i+ln]=min(dp[i][j]+dp[j+1][i+ln] for j in range(i,i+ln))
if l[i]==l[i+ln]:
dp[i][i+ln]=min(dp[i][i+ln],dp[i+1][i+ln-1])
pr_num(dp[0][-1])
```
|
output
| 1
| 11,213
| 0
| 22,427
|
Provide a correct Python 3 solution for this coding contest problem.
Given are two strings S and T.
Let us change some of the characters in S so that T will be a substring of S.
At least how many characters do we need to change?
Here, a substring is a consecutive subsequence. For example, `xxx` is a substring of `yxxxy`, but not a substring of `xxyxx`.
Constraints
* The lengths of S and T are each at least 1 and at most 1000.
* The length of T is at most that of S.
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
Print the minimum number of characters in S that need to be changed.
Examples
Input
cabacc
abc
Output
1
Input
codeforces
atcoder
Output
6
|
instruction
| 0
| 11,392
| 0
| 22,784
|
"Correct Solution:
```
s=input()
t=input()
tl=len(t)
m=0
for i in range(len(s)-tl+1):
c=0
for x,y in zip(t,s[i:i+tl]):
if x==y:
c+=1
m=max(m,c)
print(tl-m)
```
|
output
| 1
| 11,392
| 0
| 22,785
|
Provide a correct Python 3 solution for this coding contest problem.
Given are two strings S and T.
Let us change some of the characters in S so that T will be a substring of S.
At least how many characters do we need to change?
Here, a substring is a consecutive subsequence. For example, `xxx` is a substring of `yxxxy`, but not a substring of `xxyxx`.
Constraints
* The lengths of S and T are each at least 1 and at most 1000.
* The length of T is at most that of S.
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
Print the minimum number of characters in S that need to be changed.
Examples
Input
cabacc
abc
Output
1
Input
codeforces
atcoder
Output
6
|
instruction
| 0
| 11,393
| 0
| 22,786
|
"Correct Solution:
```
s=input()
t=input()
k=len(t)
for i in range(len(s)-len(t)+1):
p=0
for j in range(len(t)):
if s[i+j]!=t[j]:
p+=1
if k>p:
k=p
print(k)
```
|
output
| 1
| 11,393
| 0
| 22,787
|
Provide a correct Python 3 solution for this coding contest problem.
Given are two strings S and T.
Let us change some of the characters in S so that T will be a substring of S.
At least how many characters do we need to change?
Here, a substring is a consecutive subsequence. For example, `xxx` is a substring of `yxxxy`, but not a substring of `xxyxx`.
Constraints
* The lengths of S and T are each at least 1 and at most 1000.
* The length of T is at most that of S.
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
Print the minimum number of characters in S that need to be changed.
Examples
Input
cabacc
abc
Output
1
Input
codeforces
atcoder
Output
6
|
instruction
| 0
| 11,394
| 0
| 22,788
|
"Correct Solution:
```
s=input()
t=input()
a=0
for i in range(len(s)-len(t)+1):
c=0
for j,d in enumerate(t):
if s[i+j]==d: c+=1
a=max(a,c)
print(len(t)-a)
```
|
output
| 1
| 11,394
| 0
| 22,789
|
Provide a correct Python 3 solution for this coding contest problem.
Given are two strings S and T.
Let us change some of the characters in S so that T will be a substring of S.
At least how many characters do we need to change?
Here, a substring is a consecutive subsequence. For example, `xxx` is a substring of `yxxxy`, but not a substring of `xxyxx`.
Constraints
* The lengths of S and T are each at least 1 and at most 1000.
* The length of T is at most that of S.
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
Print the minimum number of characters in S that need to be changed.
Examples
Input
cabacc
abc
Output
1
Input
codeforces
atcoder
Output
6
|
instruction
| 0
| 11,395
| 0
| 22,790
|
"Correct Solution:
```
S=input()
T=input()
r=1000
for i in range(len(S)-len(T)+1):
r=min(r,sum([S[i+j]!=T[j] for j in range(len(T))]))
print(r)
```
|
output
| 1
| 11,395
| 0
| 22,791
|
Provide a correct Python 3 solution for this coding contest problem.
Given are two strings S and T.
Let us change some of the characters in S so that T will be a substring of S.
At least how many characters do we need to change?
Here, a substring is a consecutive subsequence. For example, `xxx` is a substring of `yxxxy`, but not a substring of `xxyxx`.
Constraints
* The lengths of S and T are each at least 1 and at most 1000.
* The length of T is at most that of S.
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
Print the minimum number of characters in S that need to be changed.
Examples
Input
cabacc
abc
Output
1
Input
codeforces
atcoder
Output
6
|
instruction
| 0
| 11,396
| 0
| 22,792
|
"Correct Solution:
```
s = input()
t = input()
n, m = len(s), len(t)
print(min(sum(si != ti for si, ti in zip(s[i: i+m], t)) for i in range(n-m+1)))
```
|
output
| 1
| 11,396
| 0
| 22,793
|
Provide a correct Python 3 solution for this coding contest problem.
Given are two strings S and T.
Let us change some of the characters in S so that T will be a substring of S.
At least how many characters do we need to change?
Here, a substring is a consecutive subsequence. For example, `xxx` is a substring of `yxxxy`, but not a substring of `xxyxx`.
Constraints
* The lengths of S and T are each at least 1 and at most 1000.
* The length of T is at most that of S.
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
Print the minimum number of characters in S that need to be changed.
Examples
Input
cabacc
abc
Output
1
Input
codeforces
atcoder
Output
6
|
instruction
| 0
| 11,397
| 0
| 22,794
|
"Correct Solution:
```
S, T = input(), input()
best = len(T)
for i in range(len(S)-len(T)+1):
best = min(best, sum(S[i+j] != c for j, c in enumerate(T)))
print(best)
```
|
output
| 1
| 11,397
| 0
| 22,795
|
Provide a correct Python 3 solution for this coding contest problem.
Given are two strings S and T.
Let us change some of the characters in S so that T will be a substring of S.
At least how many characters do we need to change?
Here, a substring is a consecutive subsequence. For example, `xxx` is a substring of `yxxxy`, but not a substring of `xxyxx`.
Constraints
* The lengths of S and T are each at least 1 and at most 1000.
* The length of T is at most that of S.
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
Print the minimum number of characters in S that need to be changed.
Examples
Input
cabacc
abc
Output
1
Input
codeforces
atcoder
Output
6
|
instruction
| 0
| 11,398
| 0
| 22,796
|
"Correct Solution:
```
s=input()
t=input()
l=len(s)
l2=len(t)
ans=1000000
for i in range(l-l2+1):
curr=0
for j in range(i,i+l2):
if(s[j]!=t[j-i]):
curr+=1
if(curr<ans):
ans=curr
print(ans)
```
|
output
| 1
| 11,398
| 0
| 22,797
|
Provide a correct Python 3 solution for this coding contest problem.
Given are two strings S and T.
Let us change some of the characters in S so that T will be a substring of S.
At least how many characters do we need to change?
Here, a substring is a consecutive subsequence. For example, `xxx` is a substring of `yxxxy`, but not a substring of `xxyxx`.
Constraints
* The lengths of S and T are each at least 1 and at most 1000.
* The length of T is at most that of S.
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
Print the minimum number of characters in S that need to be changed.
Examples
Input
cabacc
abc
Output
1
Input
codeforces
atcoder
Output
6
|
instruction
| 0
| 11,399
| 0
| 22,798
|
"Correct Solution:
```
s = input()
t = input()
S,T = len(s),len(t)
ans = T
for i in range(S-T+1):
tmp = [c1!=c2 for c1,c2 in zip(s[i:i+T],t)].count(True)
ans = min(ans,tmp)
print(ans)
```
|
output
| 1
| 11,399
| 0
| 22,799
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given are two strings S and T.
Let us change some of the characters in S so that T will be a substring of S.
At least how many characters do we need to change?
Here, a substring is a consecutive subsequence. For example, `xxx` is a substring of `yxxxy`, but not a substring of `xxyxx`.
Constraints
* The lengths of S and T are each at least 1 and at most 1000.
* The length of T is at most that of S.
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
Print the minimum number of characters in S that need to be changed.
Examples
Input
cabacc
abc
Output
1
Input
codeforces
atcoder
Output
6
Submitted Solution:
```
s=input()
t=input()
lt=len(t)
x=lt
for i in range(len(s)-lt+1):
a=0
for j in range(lt):
if s[i+j]!=t[j]:
a+=1
x=min(x,a)
print(x)
```
|
instruction
| 0
| 11,400
| 0
| 22,800
|
Yes
|
output
| 1
| 11,400
| 0
| 22,801
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given are two strings S and T.
Let us change some of the characters in S so that T will be a substring of S.
At least how many characters do we need to change?
Here, a substring is a consecutive subsequence. For example, `xxx` is a substring of `yxxxy`, but not a substring of `xxyxx`.
Constraints
* The lengths of S and T are each at least 1 and at most 1000.
* The length of T is at most that of S.
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
Print the minimum number of characters in S that need to be changed.
Examples
Input
cabacc
abc
Output
1
Input
codeforces
atcoder
Output
6
Submitted Solution:
```
S = input()
T = input()
print(min([sum(map(lambda x:x[0]!=x[1], zip(S[i:i+len(T)],T))) for i in range(1+len(S)-len(T))]))
```
|
instruction
| 0
| 11,401
| 0
| 22,802
|
Yes
|
output
| 1
| 11,401
| 0
| 22,803
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given are two strings S and T.
Let us change some of the characters in S so that T will be a substring of S.
At least how many characters do we need to change?
Here, a substring is a consecutive subsequence. For example, `xxx` is a substring of `yxxxy`, but not a substring of `xxyxx`.
Constraints
* The lengths of S and T are each at least 1 and at most 1000.
* The length of T is at most that of S.
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
Print the minimum number of characters in S that need to be changed.
Examples
Input
cabacc
abc
Output
1
Input
codeforces
atcoder
Output
6
Submitted Solution:
```
S,T=input(),input()
res=n=len(T)
m=len(S)
for i in range(m-n+1):
c = 0
for k in range(n):
if S[i+k]!=T[k]:
c+=1
res=min(res,c)
print(res)
```
|
instruction
| 0
| 11,402
| 0
| 22,804
|
Yes
|
output
| 1
| 11,402
| 0
| 22,805
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given are two strings S and T.
Let us change some of the characters in S so that T will be a substring of S.
At least how many characters do we need to change?
Here, a substring is a consecutive subsequence. For example, `xxx` is a substring of `yxxxy`, but not a substring of `xxyxx`.
Constraints
* The lengths of S and T are each at least 1 and at most 1000.
* The length of T is at most that of S.
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
Print the minimum number of characters in S that need to be changed.
Examples
Input
cabacc
abc
Output
1
Input
codeforces
atcoder
Output
6
Submitted Solution:
```
s=input()
t=input()
ans=10**7
for i in range(len(s)-len(t)+1):
ansi=0
for j in range(len(t)):
if s[i+j]!=t[j]:
ansi+=1
ans=min(ans,ansi)
print(ans)
```
|
instruction
| 0
| 11,403
| 0
| 22,806
|
Yes
|
output
| 1
| 11,403
| 0
| 22,807
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given are two strings S and T.
Let us change some of the characters in S so that T will be a substring of S.
At least how many characters do we need to change?
Here, a substring is a consecutive subsequence. For example, `xxx` is a substring of `yxxxy`, but not a substring of `xxyxx`.
Constraints
* The lengths of S and T are each at least 1 and at most 1000.
* The length of T is at most that of S.
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
Print the minimum number of characters in S that need to be changed.
Examples
Input
cabacc
abc
Output
1
Input
codeforces
atcoder
Output
6
Submitted Solution:
```
s = input()
t = input()
ls = len(s)
lt = len(t)
a = []
sum_ = 0
for i in range(ls-lt+1):
ss = s[i:i+lt]
sum_ = 0
for i, alb in enumerate(lt):
if alb == ss[i]:
sum_+= 1
a.append(sum_)
print(lt - max(a))
```
|
instruction
| 0
| 11,404
| 0
| 22,808
|
No
|
output
| 1
| 11,404
| 0
| 22,809
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given are two strings S and T.
Let us change some of the characters in S so that T will be a substring of S.
At least how many characters do we need to change?
Here, a substring is a consecutive subsequence. For example, `xxx` is a substring of `yxxxy`, but not a substring of `xxyxx`.
Constraints
* The lengths of S and T are each at least 1 and at most 1000.
* The length of T is at most that of S.
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
Print the minimum number of characters in S that need to be changed.
Examples
Input
cabacc
abc
Output
1
Input
codeforces
atcoder
Output
6
Submitted Solution:
```
S = input()
T = input()
min_count = len(T)
for s_i in range(len(S)):
i = s_i
matched = 0
for j in range(len(T)):
i += 1
if len(S) <= i: # Out of S
matched = 0 # Cannot append characters to S
break
if S[i] == T[j]:
matched += 1
count = len(T) - matched
if count < min_count:
min_count = count
print(min_count)
```
|
instruction
| 0
| 11,405
| 0
| 22,810
|
No
|
output
| 1
| 11,405
| 0
| 22,811
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given are two strings S and T.
Let us change some of the characters in S so that T will be a substring of S.
At least how many characters do we need to change?
Here, a substring is a consecutive subsequence. For example, `xxx` is a substring of `yxxxy`, but not a substring of `xxyxx`.
Constraints
* The lengths of S and T are each at least 1 and at most 1000.
* The length of T is at most that of S.
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
Print the minimum number of characters in S that need to be changed.
Examples
Input
cabacc
abc
Output
1
Input
codeforces
atcoder
Output
6
Submitted Solution:
```
s=list(input())
t=list(input())
n=len(t)
m=len(s)
for i in range(n):
l=n-i
for j in range(i+1):
if ''.join(t[j:j+l]) in ''.join(s[j:j+m-i]):
print(i)
exit()
print(n)
```
|
instruction
| 0
| 11,406
| 0
| 22,812
|
No
|
output
| 1
| 11,406
| 0
| 22,813
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given are two strings S and T.
Let us change some of the characters in S so that T will be a substring of S.
At least how many characters do we need to change?
Here, a substring is a consecutive subsequence. For example, `xxx` is a substring of `yxxxy`, but not a substring of `xxyxx`.
Constraints
* The lengths of S and T are each at least 1 and at most 1000.
* The length of T is at most that of S.
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
Print the minimum number of characters in S that need to be changed.
Examples
Input
cabacc
abc
Output
1
Input
codeforces
atcoder
Output
6
Submitted Solution:
```
S = input()
T = input()
ans = len(T)
for i in range(len(S)):
for s,t in zip(S[i:i+len(T)],T):
tmp = len(T)
if t == s:
tmp -= 1
ans = min(ans,tmp)
else:
print(ans)
```
|
instruction
| 0
| 11,407
| 0
| 22,814
|
No
|
output
| 1
| 11,407
| 0
| 22,815
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Mike and Ann are sitting in the classroom. The lesson is boring, so they decided to play an interesting game. Fortunately, all they need to play this game is a string s and a number k (0 ≤ k < |s|).
At the beginning of the game, players are given a substring of s with left border l and right border r, both equal to k (i.e. initially l=r=k). Then players start to make moves one by one, according to the following rules:
* A player chooses l^{\prime} and r^{\prime} so that l^{\prime} ≤ l, r^{\prime} ≥ r and s[l^{\prime}, r^{\prime}] is lexicographically less than s[l, r]. Then the player changes l and r in this way: l := l^{\prime}, r := r^{\prime}.
* Ann moves first.
* The player, that can't make a move loses.
Recall that a substring s[l, r] (l ≤ r) of a string s is a continuous segment of letters from s that starts at position l and ends at position r. For example, "ehn" is a substring (s[3, 5]) of "aaaehnsvz" and "ahz" is not.
Mike and Ann were playing so enthusiastically that they did not notice the teacher approached them. Surprisingly, the teacher didn't scold them, instead of that he said, that he can figure out the winner of the game before it starts, even if he knows only s and k.
Unfortunately, Mike and Ann are not so keen in the game theory, so they ask you to write a program, that takes s and determines the winner for all possible k.
Input
The first line of the input contains a single string s (1 ≤ |s| ≤ 5 ⋅ 10^5) consisting of lowercase English letters.
Output
Print |s| lines.
In the line i write the name of the winner (print Mike or Ann) in the game with string s and k = i, if both play optimally
Examples
Input
abba
Output
Mike
Ann
Ann
Mike
Input
cba
Output
Mike
Mike
Mike
|
instruction
| 0
| 11,714
| 0
| 23,428
|
Tags: games, greedy, strings
Correct Solution:
```
s = input()
a = [-1] * len(s)
menor = 'z'
#preprocessar
for i,v in enumerate(s):
if menor < v:
a[i] = 1
else:
menor = v
for k in range(len(s)):
if k == 0:
print('Mike')
elif a[k] == 1:
print('Ann')
else:
print('Mike')
```
|
output
| 1
| 11,714
| 0
| 23,429
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Mike and Ann are sitting in the classroom. The lesson is boring, so they decided to play an interesting game. Fortunately, all they need to play this game is a string s and a number k (0 ≤ k < |s|).
At the beginning of the game, players are given a substring of s with left border l and right border r, both equal to k (i.e. initially l=r=k). Then players start to make moves one by one, according to the following rules:
* A player chooses l^{\prime} and r^{\prime} so that l^{\prime} ≤ l, r^{\prime} ≥ r and s[l^{\prime}, r^{\prime}] is lexicographically less than s[l, r]. Then the player changes l and r in this way: l := l^{\prime}, r := r^{\prime}.
* Ann moves first.
* The player, that can't make a move loses.
Recall that a substring s[l, r] (l ≤ r) of a string s is a continuous segment of letters from s that starts at position l and ends at position r. For example, "ehn" is a substring (s[3, 5]) of "aaaehnsvz" and "ahz" is not.
Mike and Ann were playing so enthusiastically that they did not notice the teacher approached them. Surprisingly, the teacher didn't scold them, instead of that he said, that he can figure out the winner of the game before it starts, even if he knows only s and k.
Unfortunately, Mike and Ann are not so keen in the game theory, so they ask you to write a program, that takes s and determines the winner for all possible k.
Input
The first line of the input contains a single string s (1 ≤ |s| ≤ 5 ⋅ 10^5) consisting of lowercase English letters.
Output
Print |s| lines.
In the line i write the name of the winner (print Mike or Ann) in the game with string s and k = i, if both play optimally
Examples
Input
abba
Output
Mike
Ann
Ann
Mike
Input
cba
Output
Mike
Mike
Mike
|
instruction
| 0
| 11,715
| 0
| 23,430
|
Tags: games, greedy, strings
Correct Solution:
```
import math
t = input()
s = set()
for i in t:
res = False
for n in s:
if ord(n) < ord(i):
res = True
break
s.add(i)
if res:
print('Ann')
else:
print('Mike')
```
|
output
| 1
| 11,715
| 0
| 23,431
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Mike and Ann are sitting in the classroom. The lesson is boring, so they decided to play an interesting game. Fortunately, all they need to play this game is a string s and a number k (0 ≤ k < |s|).
At the beginning of the game, players are given a substring of s with left border l and right border r, both equal to k (i.e. initially l=r=k). Then players start to make moves one by one, according to the following rules:
* A player chooses l^{\prime} and r^{\prime} so that l^{\prime} ≤ l, r^{\prime} ≥ r and s[l^{\prime}, r^{\prime}] is lexicographically less than s[l, r]. Then the player changes l and r in this way: l := l^{\prime}, r := r^{\prime}.
* Ann moves first.
* The player, that can't make a move loses.
Recall that a substring s[l, r] (l ≤ r) of a string s is a continuous segment of letters from s that starts at position l and ends at position r. For example, "ehn" is a substring (s[3, 5]) of "aaaehnsvz" and "ahz" is not.
Mike and Ann were playing so enthusiastically that they did not notice the teacher approached them. Surprisingly, the teacher didn't scold them, instead of that he said, that he can figure out the winner of the game before it starts, even if he knows only s and k.
Unfortunately, Mike and Ann are not so keen in the game theory, so they ask you to write a program, that takes s and determines the winner for all possible k.
Input
The first line of the input contains a single string s (1 ≤ |s| ≤ 5 ⋅ 10^5) consisting of lowercase English letters.
Output
Print |s| lines.
In the line i write the name of the winner (print Mike or Ann) in the game with string s and k = i, if both play optimally
Examples
Input
abba
Output
Mike
Ann
Ann
Mike
Input
cba
Output
Mike
Mike
Mike
|
instruction
| 0
| 11,716
| 0
| 23,432
|
Tags: games, greedy, strings
Correct Solution:
```
# ------------------- fast io --------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------- fast io --------------------
vals=[ord(k)-97 for k in input()]
minsofar=28
ans=[]
for s in range(len(vals)):
if vals[s]<minsofar:
minsofar=vals[s]
if vals[s]>minsofar:
ans.append("Ann")
else:
ans.append("Mike")
print("\n".join(ans))
```
|
output
| 1
| 11,716
| 0
| 23,433
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Mike and Ann are sitting in the classroom. The lesson is boring, so they decided to play an interesting game. Fortunately, all they need to play this game is a string s and a number k (0 ≤ k < |s|).
At the beginning of the game, players are given a substring of s with left border l and right border r, both equal to k (i.e. initially l=r=k). Then players start to make moves one by one, according to the following rules:
* A player chooses l^{\prime} and r^{\prime} so that l^{\prime} ≤ l, r^{\prime} ≥ r and s[l^{\prime}, r^{\prime}] is lexicographically less than s[l, r]. Then the player changes l and r in this way: l := l^{\prime}, r := r^{\prime}.
* Ann moves first.
* The player, that can't make a move loses.
Recall that a substring s[l, r] (l ≤ r) of a string s is a continuous segment of letters from s that starts at position l and ends at position r. For example, "ehn" is a substring (s[3, 5]) of "aaaehnsvz" and "ahz" is not.
Mike and Ann were playing so enthusiastically that they did not notice the teacher approached them. Surprisingly, the teacher didn't scold them, instead of that he said, that he can figure out the winner of the game before it starts, even if he knows only s and k.
Unfortunately, Mike and Ann are not so keen in the game theory, so they ask you to write a program, that takes s and determines the winner for all possible k.
Input
The first line of the input contains a single string s (1 ≤ |s| ≤ 5 ⋅ 10^5) consisting of lowercase English letters.
Output
Print |s| lines.
In the line i write the name of the winner (print Mike or Ann) in the game with string s and k = i, if both play optimally
Examples
Input
abba
Output
Mike
Ann
Ann
Mike
Input
cba
Output
Mike
Mike
Mike
|
instruction
| 0
| 11,717
| 0
| 23,434
|
Tags: games, greedy, strings
Correct Solution:
```
#code
s=list(input())
n=len(s)
minn=ord(s[0])
print("Mike")
arr=[]
for i in range(1,n):
if minn<ord(s[i]):
print("Ann")
else:
minn=ord(s[i])
print("Mike")
```
|
output
| 1
| 11,717
| 0
| 23,435
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Mike and Ann are sitting in the classroom. The lesson is boring, so they decided to play an interesting game. Fortunately, all they need to play this game is a string s and a number k (0 ≤ k < |s|).
At the beginning of the game, players are given a substring of s with left border l and right border r, both equal to k (i.e. initially l=r=k). Then players start to make moves one by one, according to the following rules:
* A player chooses l^{\prime} and r^{\prime} so that l^{\prime} ≤ l, r^{\prime} ≥ r and s[l^{\prime}, r^{\prime}] is lexicographically less than s[l, r]. Then the player changes l and r in this way: l := l^{\prime}, r := r^{\prime}.
* Ann moves first.
* The player, that can't make a move loses.
Recall that a substring s[l, r] (l ≤ r) of a string s is a continuous segment of letters from s that starts at position l and ends at position r. For example, "ehn" is a substring (s[3, 5]) of "aaaehnsvz" and "ahz" is not.
Mike and Ann were playing so enthusiastically that they did not notice the teacher approached them. Surprisingly, the teacher didn't scold them, instead of that he said, that he can figure out the winner of the game before it starts, even if he knows only s and k.
Unfortunately, Mike and Ann are not so keen in the game theory, so they ask you to write a program, that takes s and determines the winner for all possible k.
Input
The first line of the input contains a single string s (1 ≤ |s| ≤ 5 ⋅ 10^5) consisting of lowercase English letters.
Output
Print |s| lines.
In the line i write the name of the winner (print Mike or Ann) in the game with string s and k = i, if both play optimally
Examples
Input
abba
Output
Mike
Ann
Ann
Mike
Input
cba
Output
Mike
Mike
Mike
|
instruction
| 0
| 11,718
| 0
| 23,436
|
Tags: games, greedy, strings
Correct Solution:
```
s = input()
min_val = 9999
for c in s:
if min_val < ord(c):
print('Ann')
else:
print('Mike')
min_val = min(min_val, ord(c))
```
|
output
| 1
| 11,718
| 0
| 23,437
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Mike and Ann are sitting in the classroom. The lesson is boring, so they decided to play an interesting game. Fortunately, all they need to play this game is a string s and a number k (0 ≤ k < |s|).
At the beginning of the game, players are given a substring of s with left border l and right border r, both equal to k (i.e. initially l=r=k). Then players start to make moves one by one, according to the following rules:
* A player chooses l^{\prime} and r^{\prime} so that l^{\prime} ≤ l, r^{\prime} ≥ r and s[l^{\prime}, r^{\prime}] is lexicographically less than s[l, r]. Then the player changes l and r in this way: l := l^{\prime}, r := r^{\prime}.
* Ann moves first.
* The player, that can't make a move loses.
Recall that a substring s[l, r] (l ≤ r) of a string s is a continuous segment of letters from s that starts at position l and ends at position r. For example, "ehn" is a substring (s[3, 5]) of "aaaehnsvz" and "ahz" is not.
Mike and Ann were playing so enthusiastically that they did not notice the teacher approached them. Surprisingly, the teacher didn't scold them, instead of that he said, that he can figure out the winner of the game before it starts, even if he knows only s and k.
Unfortunately, Mike and Ann are not so keen in the game theory, so they ask you to write a program, that takes s and determines the winner for all possible k.
Input
The first line of the input contains a single string s (1 ≤ |s| ≤ 5 ⋅ 10^5) consisting of lowercase English letters.
Output
Print |s| lines.
In the line i write the name of the winner (print Mike or Ann) in the game with string s and k = i, if both play optimally
Examples
Input
abba
Output
Mike
Ann
Ann
Mike
Input
cba
Output
Mike
Mike
Mike
|
instruction
| 0
| 11,719
| 0
| 23,438
|
Tags: games, greedy, strings
Correct Solution:
```
def main():
s = input()
max_k = len(s)
min_upto = []
min_letter = "z"
for i, letter in enumerate(s):
min_letter = min(min_letter, s[i])
min_upto.append(min_letter)
min_letter = min_upto[max_k-1]
for i in range(max_k):
if s[i] == min_letter or i == 0:
print("Mike")
else:
if min_upto[i-1] < s[i]:
print("Ann")
else:
print("Mike")
if __name__ == "__main__":
main()
```
|
output
| 1
| 11,719
| 0
| 23,439
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Mike and Ann are sitting in the classroom. The lesson is boring, so they decided to play an interesting game. Fortunately, all they need to play this game is a string s and a number k (0 ≤ k < |s|).
At the beginning of the game, players are given a substring of s with left border l and right border r, both equal to k (i.e. initially l=r=k). Then players start to make moves one by one, according to the following rules:
* A player chooses l^{\prime} and r^{\prime} so that l^{\prime} ≤ l, r^{\prime} ≥ r and s[l^{\prime}, r^{\prime}] is lexicographically less than s[l, r]. Then the player changes l and r in this way: l := l^{\prime}, r := r^{\prime}.
* Ann moves first.
* The player, that can't make a move loses.
Recall that a substring s[l, r] (l ≤ r) of a string s is a continuous segment of letters from s that starts at position l and ends at position r. For example, "ehn" is a substring (s[3, 5]) of "aaaehnsvz" and "ahz" is not.
Mike and Ann were playing so enthusiastically that they did not notice the teacher approached them. Surprisingly, the teacher didn't scold them, instead of that he said, that he can figure out the winner of the game before it starts, even if he knows only s and k.
Unfortunately, Mike and Ann are not so keen in the game theory, so they ask you to write a program, that takes s and determines the winner for all possible k.
Input
The first line of the input contains a single string s (1 ≤ |s| ≤ 5 ⋅ 10^5) consisting of lowercase English letters.
Output
Print |s| lines.
In the line i write the name of the winner (print Mike or Ann) in the game with string s and k = i, if both play optimally
Examples
Input
abba
Output
Mike
Ann
Ann
Mike
Input
cba
Output
Mike
Mike
Mike
|
instruction
| 0
| 11,720
| 0
| 23,440
|
Tags: games, greedy, strings
Correct Solution:
```
s=input();n=len(s);dp=[0]*(500002)
dp[0]=s[0]
for i in range(1,n):
dp[i]=min(dp[i-1],s[i])
for i in range(n):
if dp[i]<s[i]:print("Ann")
else:print("Mike")
```
|
output
| 1
| 11,720
| 0
| 23,441
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Mike and Ann are sitting in the classroom. The lesson is boring, so they decided to play an interesting game. Fortunately, all they need to play this game is a string s and a number k (0 ≤ k < |s|).
At the beginning of the game, players are given a substring of s with left border l and right border r, both equal to k (i.e. initially l=r=k). Then players start to make moves one by one, according to the following rules:
* A player chooses l^{\prime} and r^{\prime} so that l^{\prime} ≤ l, r^{\prime} ≥ r and s[l^{\prime}, r^{\prime}] is lexicographically less than s[l, r]. Then the player changes l and r in this way: l := l^{\prime}, r := r^{\prime}.
* Ann moves first.
* The player, that can't make a move loses.
Recall that a substring s[l, r] (l ≤ r) of a string s is a continuous segment of letters from s that starts at position l and ends at position r. For example, "ehn" is a substring (s[3, 5]) of "aaaehnsvz" and "ahz" is not.
Mike and Ann were playing so enthusiastically that they did not notice the teacher approached them. Surprisingly, the teacher didn't scold them, instead of that he said, that he can figure out the winner of the game before it starts, even if he knows only s and k.
Unfortunately, Mike and Ann are not so keen in the game theory, so they ask you to write a program, that takes s and determines the winner for all possible k.
Input
The first line of the input contains a single string s (1 ≤ |s| ≤ 5 ⋅ 10^5) consisting of lowercase English letters.
Output
Print |s| lines.
In the line i write the name of the winner (print Mike or Ann) in the game with string s and k = i, if both play optimally
Examples
Input
abba
Output
Mike
Ann
Ann
Mike
Input
cba
Output
Mike
Mike
Mike
|
instruction
| 0
| 11,721
| 0
| 23,442
|
Tags: games, greedy, strings
Correct Solution:
```
s = input()
alph = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
d = {}
for l in alph:
try:
d[l] = s.index(l)
except Exception:
d[l] = len(s)
m = len(s)
k = {}
for i in range(len(alph)):
k[alph[i]] = m
m = min(m, d[alph[i]])
for i in range(len(s)):
if (k[s[i]]<i):
print('Ann')
else:
print('Mike')
```
|
output
| 1
| 11,721
| 0
| 23,443
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mike and Ann are sitting in the classroom. The lesson is boring, so they decided to play an interesting game. Fortunately, all they need to play this game is a string s and a number k (0 ≤ k < |s|).
At the beginning of the game, players are given a substring of s with left border l and right border r, both equal to k (i.e. initially l=r=k). Then players start to make moves one by one, according to the following rules:
* A player chooses l^{\prime} and r^{\prime} so that l^{\prime} ≤ l, r^{\prime} ≥ r and s[l^{\prime}, r^{\prime}] is lexicographically less than s[l, r]. Then the player changes l and r in this way: l := l^{\prime}, r := r^{\prime}.
* Ann moves first.
* The player, that can't make a move loses.
Recall that a substring s[l, r] (l ≤ r) of a string s is a continuous segment of letters from s that starts at position l and ends at position r. For example, "ehn" is a substring (s[3, 5]) of "aaaehnsvz" and "ahz" is not.
Mike and Ann were playing so enthusiastically that they did not notice the teacher approached them. Surprisingly, the teacher didn't scold them, instead of that he said, that he can figure out the winner of the game before it starts, even if he knows only s and k.
Unfortunately, Mike and Ann are not so keen in the game theory, so they ask you to write a program, that takes s and determines the winner for all possible k.
Input
The first line of the input contains a single string s (1 ≤ |s| ≤ 5 ⋅ 10^5) consisting of lowercase English letters.
Output
Print |s| lines.
In the line i write the name of the winner (print Mike or Ann) in the game with string s and k = i, if both play optimally
Examples
Input
abba
Output
Mike
Ann
Ann
Mike
Input
cba
Output
Mike
Mike
Mike
Submitted Solution:
```
''' CODED WITH LOVE BY SATYAM KUMAR '''
from sys import stdin, stdout
import heapq
import cProfile, math
from collections import Counter, defaultdict, deque
from bisect import bisect_left, bisect, bisect_right
import itertools
from copy import deepcopy
from fractions import Fraction
import sys, threading
import operator as op
from functools import reduce
import sys
sys.setrecursionlimit(10 ** 6) # max depth of recursion
threading.stack_size(2 ** 27) # new thread will get stack of such size
fac_warm_up = False
printHeap = str()
memory_constrained = False
P = 10 ** 9 + 7
class MergeFind:
def __init__(self, n):
self.parent = list(range(n))
self.size = [1] * n
self.num_sets = n
self.lista = [[_] for _ in range(n)]
def find(self, a):
to_update = []
while a != self.parent[a]:
to_update.append(a)
a = self.parent[a]
for b in to_update:
self.parent[b] = a
return self.parent[a]
def merge(self, a, b):
a = self.find(a)
b = self.find(b)
if a == b:
return
if self.size[a] < self.size[b]:
a, b = b, a
self.num_sets -= 1
self.parent[b] = a
self.size[a] += self.size[b]
self.lista[a] += self.lista[b]
def set_size(self, a):
return self.size[self.find(a)]
def __len__(self):
return self.num_sets
def display(string_to_print):
stdout.write(str(string_to_print) + "\n")
def prime_factors(n): # n**0.5 complex
factors = dict()
for i in range(2, math.ceil(math.sqrt(n)) + 1):
while n % i == 0:
if i in factors:
factors[i] += 1
else:
factors[i] = 1
n = n // i
if n > 2:
factors[n] = 1
return (factors)
def all_factors(n):
return set(reduce(list.__add__,
([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
def fibonacci_modP(n, MOD):
if n < 2: return 1
return (cached_fn(fibonacci_modP, (n + 1) // 2, MOD) * cached_fn(fibonacci_modP, n // 2, MOD) + cached_fn(
fibonacci_modP, (n - 1) // 2, MOD) * cached_fn(fibonacci_modP, (n - 2) // 2, MOD)) % MOD
def factorial_modP_Wilson(n, p):
if (p <= n):
return 0
res = (p - 1)
for i in range(n + 1, p):
res = (res * cached_fn(InverseEuler, i, p)) % p
return res
def binary(n, digits=20):
b = bin(n)[2:]
b = '0' * (digits - len(b)) + b
return b
def is_prime(n):
"""Returns True if n is prime."""
if n < 4:
return True
if n % 2 == 0:
return False
if n % 3 == 0:
return False
i = 5
w = 2
while i * i <= n:
if n % i == 0:
return False
i += w
w = 6 - w
return True
def generate_primes(n):
prime = [True for i in range(n + 1)]
p = 2
while p * p <= n:
if prime[p]:
for i in range(p * 2, n + 1, p):
prime[i] = False
p += 1
return prime
factorial_modP = []
def warm_up_fac(MOD):
global factorial_modP, fac_warm_up
if fac_warm_up: return
factorial_modP = [1 for _ in range(fac_warm_up_size + 1)]
for i in range(2, fac_warm_up_size):
factorial_modP[i] = (factorial_modP[i - 1] * i) % MOD
fac_warm_up = True
def InverseEuler(n, MOD):
return pow(n, MOD - 2, MOD)
def nCr(n, r, MOD):
global fac_warm_up, factorial_modP
if not fac_warm_up:
warm_up_fac(MOD)
fac_warm_up = True
return (factorial_modP[n] * (
(pow(factorial_modP[r], MOD - 2, MOD) * pow(factorial_modP[n - r], MOD - 2, MOD)) % MOD)) % MOD
def test_print(*args):
if testingMode:
print(args)
def display_list(list1, sep=" "):
stdout.write(sep.join(map(str, list1)) + "\n")
def display_2D_list(li):
for i in li:
print(i)
def prefix_sum(li):
sm = 0
res = []
for i in li:
sm += i
res.append(sm)
return res
def get_int():
return int(stdin.readline().strip())
def get_tuple():
return map(int, stdin.readline().split())
def get_list():
return list(map(int, stdin.readline().split()))
memory = dict()
def clear_cache():
global memory
memory = dict()
def cached_fn(fn, *args):
global memory
if args in memory:
return memory[args]
else:
result = fn(*args)
memory[args] = result
return result
def ncr(n, r):
return math.factorial(n) / (math.factorial(n - r) * math.factorial(r))
def binary_search(i, li):
fn = lambda x: li[x] - x // i
x = -1
b = len(li)
while b >= 1:
while b + x < len(li) and fn(b + x) > 0: # Change this condition 2 to whatever you like
x += b
b = b // 2
return x
# -------------------------------------------------------------- MAIN PROGRAM
TestCases = False
fac_warm_up_size = 10 ** 5 + 100
optimise_for_recursion = False # Can not be used clubbed with TestCases WHen using recursive functions, use Python 3
def main():
st = list(stdin.readline().strip())
mini = st[0]
for i in st:
if i<=mini:
print("Mike")
mini = i
else:
print("Ann")
# --------------------------------------------------------------------- END=
if TestCases:
for i in range(get_int()):
main()
else:
main() if not optimise_for_recursion else threading.Thread(target=main).start()
```
|
instruction
| 0
| 11,722
| 0
| 23,444
|
Yes
|
output
| 1
| 11,722
| 0
| 23,445
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mike and Ann are sitting in the classroom. The lesson is boring, so they decided to play an interesting game. Fortunately, all they need to play this game is a string s and a number k (0 ≤ k < |s|).
At the beginning of the game, players are given a substring of s with left border l and right border r, both equal to k (i.e. initially l=r=k). Then players start to make moves one by one, according to the following rules:
* A player chooses l^{\prime} and r^{\prime} so that l^{\prime} ≤ l, r^{\prime} ≥ r and s[l^{\prime}, r^{\prime}] is lexicographically less than s[l, r]. Then the player changes l and r in this way: l := l^{\prime}, r := r^{\prime}.
* Ann moves first.
* The player, that can't make a move loses.
Recall that a substring s[l, r] (l ≤ r) of a string s is a continuous segment of letters from s that starts at position l and ends at position r. For example, "ehn" is a substring (s[3, 5]) of "aaaehnsvz" and "ahz" is not.
Mike and Ann were playing so enthusiastically that they did not notice the teacher approached them. Surprisingly, the teacher didn't scold them, instead of that he said, that he can figure out the winner of the game before it starts, even if he knows only s and k.
Unfortunately, Mike and Ann are not so keen in the game theory, so they ask you to write a program, that takes s and determines the winner for all possible k.
Input
The first line of the input contains a single string s (1 ≤ |s| ≤ 5 ⋅ 10^5) consisting of lowercase English letters.
Output
Print |s| lines.
In the line i write the name of the winner (print Mike or Ann) in the game with string s and k = i, if both play optimally
Examples
Input
abba
Output
Mike
Ann
Ann
Mike
Input
cba
Output
Mike
Mike
Mike
Submitted Solution:
```
[s] = input().strip().split()
(mike, ann) = ('Mike', 'Ann')
k = s.__len__()
lessthan = [False] * k
smallestLetter = s[0]
for i in range(1, k):
if (s[i] > smallestLetter):
lessthan[i] = True
elif (s[i] < smallestLetter):
smallestLetter = s[i]
for i in range(k):
if lessthan[i]:
print(ann)
else:
print(mike)
```
|
instruction
| 0
| 11,723
| 0
| 23,446
|
Yes
|
output
| 1
| 11,723
| 0
| 23,447
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mike and Ann are sitting in the classroom. The lesson is boring, so they decided to play an interesting game. Fortunately, all they need to play this game is a string s and a number k (0 ≤ k < |s|).
At the beginning of the game, players are given a substring of s with left border l and right border r, both equal to k (i.e. initially l=r=k). Then players start to make moves one by one, according to the following rules:
* A player chooses l^{\prime} and r^{\prime} so that l^{\prime} ≤ l, r^{\prime} ≥ r and s[l^{\prime}, r^{\prime}] is lexicographically less than s[l, r]. Then the player changes l and r in this way: l := l^{\prime}, r := r^{\prime}.
* Ann moves first.
* The player, that can't make a move loses.
Recall that a substring s[l, r] (l ≤ r) of a string s is a continuous segment of letters from s that starts at position l and ends at position r. For example, "ehn" is a substring (s[3, 5]) of "aaaehnsvz" and "ahz" is not.
Mike and Ann were playing so enthusiastically that they did not notice the teacher approached them. Surprisingly, the teacher didn't scold them, instead of that he said, that he can figure out the winner of the game before it starts, even if he knows only s and k.
Unfortunately, Mike and Ann are not so keen in the game theory, so they ask you to write a program, that takes s and determines the winner for all possible k.
Input
The first line of the input contains a single string s (1 ≤ |s| ≤ 5 ⋅ 10^5) consisting of lowercase English letters.
Output
Print |s| lines.
In the line i write the name of the winner (print Mike or Ann) in the game with string s and k = i, if both play optimally
Examples
Input
abba
Output
Mike
Ann
Ann
Mike
Input
cba
Output
Mike
Mike
Mike
Submitted Solution:
```
s = input()
m = 200
for i in range(len(s)):
#print(ord(s[i]), m)
if ord(s[i]) <= m:
print('Mike')
else:
print('Ann')
m = min(m, ord(s[i]))
```
|
instruction
| 0
| 11,724
| 0
| 23,448
|
Yes
|
output
| 1
| 11,724
| 0
| 23,449
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mike and Ann are sitting in the classroom. The lesson is boring, so they decided to play an interesting game. Fortunately, all they need to play this game is a string s and a number k (0 ≤ k < |s|).
At the beginning of the game, players are given a substring of s with left border l and right border r, both equal to k (i.e. initially l=r=k). Then players start to make moves one by one, according to the following rules:
* A player chooses l^{\prime} and r^{\prime} so that l^{\prime} ≤ l, r^{\prime} ≥ r and s[l^{\prime}, r^{\prime}] is lexicographically less than s[l, r]. Then the player changes l and r in this way: l := l^{\prime}, r := r^{\prime}.
* Ann moves first.
* The player, that can't make a move loses.
Recall that a substring s[l, r] (l ≤ r) of a string s is a continuous segment of letters from s that starts at position l and ends at position r. For example, "ehn" is a substring (s[3, 5]) of "aaaehnsvz" and "ahz" is not.
Mike and Ann were playing so enthusiastically that they did not notice the teacher approached them. Surprisingly, the teacher didn't scold them, instead of that he said, that he can figure out the winner of the game before it starts, even if he knows only s and k.
Unfortunately, Mike and Ann are not so keen in the game theory, so they ask you to write a program, that takes s and determines the winner for all possible k.
Input
The first line of the input contains a single string s (1 ≤ |s| ≤ 5 ⋅ 10^5) consisting of lowercase English letters.
Output
Print |s| lines.
In the line i write the name of the winner (print Mike or Ann) in the game with string s and k = i, if both play optimally
Examples
Input
abba
Output
Mike
Ann
Ann
Mike
Input
cba
Output
Mike
Mike
Mike
Submitted Solution:
```
s=input()
sms=[]
mic='z'
for i in s:
if i<mic:
sms.append(i)
mic=i
else:
sms.append(mic)
for i in range(len(s)):
if sms[i]<s[i]:
print("Ann")
else:
print("Mike")
```
|
instruction
| 0
| 11,725
| 0
| 23,450
|
Yes
|
output
| 1
| 11,725
| 0
| 23,451
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mike and Ann are sitting in the classroom. The lesson is boring, so they decided to play an interesting game. Fortunately, all they need to play this game is a string s and a number k (0 ≤ k < |s|).
At the beginning of the game, players are given a substring of s with left border l and right border r, both equal to k (i.e. initially l=r=k). Then players start to make moves one by one, according to the following rules:
* A player chooses l^{\prime} and r^{\prime} so that l^{\prime} ≤ l, r^{\prime} ≥ r and s[l^{\prime}, r^{\prime}] is lexicographically less than s[l, r]. Then the player changes l and r in this way: l := l^{\prime}, r := r^{\prime}.
* Ann moves first.
* The player, that can't make a move loses.
Recall that a substring s[l, r] (l ≤ r) of a string s is a continuous segment of letters from s that starts at position l and ends at position r. For example, "ehn" is a substring (s[3, 5]) of "aaaehnsvz" and "ahz" is not.
Mike and Ann were playing so enthusiastically that they did not notice the teacher approached them. Surprisingly, the teacher didn't scold them, instead of that he said, that he can figure out the winner of the game before it starts, even if he knows only s and k.
Unfortunately, Mike and Ann are not so keen in the game theory, so they ask you to write a program, that takes s and determines the winner for all possible k.
Input
The first line of the input contains a single string s (1 ≤ |s| ≤ 5 ⋅ 10^5) consisting of lowercase English letters.
Output
Print |s| lines.
In the line i write the name of the winner (print Mike or Ann) in the game with string s and k = i, if both play optimally
Examples
Input
abba
Output
Mike
Ann
Ann
Mike
Input
cba
Output
Mike
Mike
Mike
Submitted Solution:
```
s = input()
length = len(s)
for i in range(length):
left = i
right = i
if s.index(min(s)) < left and min(s) != s[left]:
print('Ann')
else:
print('Mike')
```
|
instruction
| 0
| 11,726
| 0
| 23,452
|
No
|
output
| 1
| 11,726
| 0
| 23,453
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mike and Ann are sitting in the classroom. The lesson is boring, so they decided to play an interesting game. Fortunately, all they need to play this game is a string s and a number k (0 ≤ k < |s|).
At the beginning of the game, players are given a substring of s with left border l and right border r, both equal to k (i.e. initially l=r=k). Then players start to make moves one by one, according to the following rules:
* A player chooses l^{\prime} and r^{\prime} so that l^{\prime} ≤ l, r^{\prime} ≥ r and s[l^{\prime}, r^{\prime}] is lexicographically less than s[l, r]. Then the player changes l and r in this way: l := l^{\prime}, r := r^{\prime}.
* Ann moves first.
* The player, that can't make a move loses.
Recall that a substring s[l, r] (l ≤ r) of a string s is a continuous segment of letters from s that starts at position l and ends at position r. For example, "ehn" is a substring (s[3, 5]) of "aaaehnsvz" and "ahz" is not.
Mike and Ann were playing so enthusiastically that they did not notice the teacher approached them. Surprisingly, the teacher didn't scold them, instead of that he said, that he can figure out the winner of the game before it starts, even if he knows only s and k.
Unfortunately, Mike and Ann are not so keen in the game theory, so they ask you to write a program, that takes s and determines the winner for all possible k.
Input
The first line of the input contains a single string s (1 ≤ |s| ≤ 5 ⋅ 10^5) consisting of lowercase English letters.
Output
Print |s| lines.
In the line i write the name of the winner (print Mike or Ann) in the game with string s and k = i, if both play optimally
Examples
Input
abba
Output
Mike
Ann
Ann
Mike
Input
cba
Output
Mike
Mike
Mike
Submitted Solution:
```
s = input()
n = len(s)
ans = []
for i in range(n):
sub = s[i]
if i == 0 or i == n-1:
ans.append('Mike')
else:
l = i
while l > 0:
if ord(s[l-1]) <= ord(s[l]):
l -= 1
else:
break
if l == 0:
ans.append('Ann')
else:
ans.append('Mike')
for i in ans:
print(i)
```
|
instruction
| 0
| 11,727
| 0
| 23,454
|
No
|
output
| 1
| 11,727
| 0
| 23,455
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mike and Ann are sitting in the classroom. The lesson is boring, so they decided to play an interesting game. Fortunately, all they need to play this game is a string s and a number k (0 ≤ k < |s|).
At the beginning of the game, players are given a substring of s with left border l and right border r, both equal to k (i.e. initially l=r=k). Then players start to make moves one by one, according to the following rules:
* A player chooses l^{\prime} and r^{\prime} so that l^{\prime} ≤ l, r^{\prime} ≥ r and s[l^{\prime}, r^{\prime}] is lexicographically less than s[l, r]. Then the player changes l and r in this way: l := l^{\prime}, r := r^{\prime}.
* Ann moves first.
* The player, that can't make a move loses.
Recall that a substring s[l, r] (l ≤ r) of a string s is a continuous segment of letters from s that starts at position l and ends at position r. For example, "ehn" is a substring (s[3, 5]) of "aaaehnsvz" and "ahz" is not.
Mike and Ann were playing so enthusiastically that they did not notice the teacher approached them. Surprisingly, the teacher didn't scold them, instead of that he said, that he can figure out the winner of the game before it starts, even if he knows only s and k.
Unfortunately, Mike and Ann are not so keen in the game theory, so they ask you to write a program, that takes s and determines the winner for all possible k.
Input
The first line of the input contains a single string s (1 ≤ |s| ≤ 5 ⋅ 10^5) consisting of lowercase English letters.
Output
Print |s| lines.
In the line i write the name of the winner (print Mike or Ann) in the game with string s and k = i, if both play optimally
Examples
Input
abba
Output
Mike
Ann
Ann
Mike
Input
cba
Output
Mike
Mike
Mike
Submitted Solution:
```
s = input()
for k in range(len(s)):
if k == 0 or k == len(s)-1:
print('Mike')
continue
for i in range(k):
if s[i] < s[k]:
print('Ann')
break
else:
print('Mike')
```
|
instruction
| 0
| 11,728
| 0
| 23,456
|
No
|
output
| 1
| 11,728
| 0
| 23,457
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mike and Ann are sitting in the classroom. The lesson is boring, so they decided to play an interesting game. Fortunately, all they need to play this game is a string s and a number k (0 ≤ k < |s|).
At the beginning of the game, players are given a substring of s with left border l and right border r, both equal to k (i.e. initially l=r=k). Then players start to make moves one by one, according to the following rules:
* A player chooses l^{\prime} and r^{\prime} so that l^{\prime} ≤ l, r^{\prime} ≥ r and s[l^{\prime}, r^{\prime}] is lexicographically less than s[l, r]. Then the player changes l and r in this way: l := l^{\prime}, r := r^{\prime}.
* Ann moves first.
* The player, that can't make a move loses.
Recall that a substring s[l, r] (l ≤ r) of a string s is a continuous segment of letters from s that starts at position l and ends at position r. For example, "ehn" is a substring (s[3, 5]) of "aaaehnsvz" and "ahz" is not.
Mike and Ann were playing so enthusiastically that they did not notice the teacher approached them. Surprisingly, the teacher didn't scold them, instead of that he said, that he can figure out the winner of the game before it starts, even if he knows only s and k.
Unfortunately, Mike and Ann are not so keen in the game theory, so they ask you to write a program, that takes s and determines the winner for all possible k.
Input
The first line of the input contains a single string s (1 ≤ |s| ≤ 5 ⋅ 10^5) consisting of lowercase English letters.
Output
Print |s| lines.
In the line i write the name of the winner (print Mike or Ann) in the game with string s and k = i, if both play optimally
Examples
Input
abba
Output
Mike
Ann
Ann
Mike
Input
cba
Output
Mike
Mike
Mike
Submitted Solution:
```
s = input()
k = len(s)
j = 0
i = 0
for i in range(k):
if i == k - 1:
print("Mike")
break
for j in range(i+1):
if (ord(s[j]) < ord(s[i])):
print("Ann")
break
if j == i:
print("Mike")
```
|
instruction
| 0
| 11,729
| 0
| 23,458
|
No
|
output
| 1
| 11,729
| 0
| 23,459
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.