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 a correct Python 3 solution for this coding contest problem.
We have a string S of length N consisting of uppercase English letters.
How many times does `ABC` occur in S as contiguous subsequences (see Sample Inputs and Outputs)?
Constraints
* 3 \leq N \leq 50
* S consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print number of occurrences of `ABC` in S as contiguous subsequences.
Examples
Input
10
ZABCDBABCQ
Output
2
Input
19
THREEONEFOURONEFIVE
Output
0
Input
33
ABCCABCBABCCABACBCBBABCBCBCBCABCB
Output
5 | instruction | 0 | 24,516 | 0 | 49,032 |
"Correct Solution:
```
k = int(input())
s = input()
print(s.count('ABC'))
``` | output | 1 | 24,516 | 0 | 49,033 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Naman has two binary strings s and t of length n (a binary string is a string which only consists of the characters "0" and "1"). He wants to convert s into t using the following operation as few times as possible.
In one operation, he can choose any subsequence of s and rotate it clockwise once.
For example, if s = 1110100, he can choose a subsequence corresponding to indices (1-based) \{2, 6, 7 \} and rotate them clockwise. The resulting string would then be s = 1010110.
A string a is said to be a subsequence of string b if a can be obtained from b by deleting some characters without changing the ordering of the remaining characters.
To perform a clockwise rotation on a sequence c of size k is to perform an operation which sets c_1:=c_k, c_2:=c_1, c_3:=c_2, …, c_k:=c_{k-1} simultaneously.
Determine the minimum number of operations Naman has to perform to convert s into t or say that it is impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of the strings.
The second line contains the binary string s of length n.
The third line contains the binary string t of length n.
Output
If it is impossible to convert s to t after any number of operations, print -1.
Otherwise, print the minimum number of operations required.
Examples
Input
6
010000
000001
Output
1
Input
10
1111100000
0000011111
Output
5
Input
8
10101010
01010101
Output
1
Input
10
1111100000
1111100001
Output
-1
Note
In the first test, Naman can choose the subsequence corresponding to indices \{2, 6\} and rotate it once to convert s into t.
In the second test, he can rotate the subsequence corresponding to all indices 5 times. It can be proved, that it is the minimum required number of operations.
In the last test, it is impossible to convert s into t. | instruction | 0 | 24,936 | 0 | 49,872 |
Tags: binary search, constructive algorithms, data structures, greedy
Correct Solution:
```
n = int(input())
todo = [0 for i in range(n)]
a = input()
b = input()
for i in range(n):
if(a[i] == b[i]):
todo[i] = 0
elif (a[i] == '0' and b[i] == '1'):
todo[i] = 1
else:
todo[i] = -1
maxx1, maxx2 = 0, 0
res1, res2 = 0, 0
for i in range(n):
if((res2 == 0 and todo[i] == 1 and res1+todo[i] <= 0) or (todo[i] == -1 and res2 == 0)):
res1 += todo[i]
maxx1 = max(abs(res1), maxx1)
else:
res2 += todo[i]
maxx2 = max(abs(res2), maxx2)
if res1 != 0 or res2 != 0:
print(-1)
else:
print(maxx1+maxx2)
``` | output | 1 | 24,936 | 0 | 49,873 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Naman has two binary strings s and t of length n (a binary string is a string which only consists of the characters "0" and "1"). He wants to convert s into t using the following operation as few times as possible.
In one operation, he can choose any subsequence of s and rotate it clockwise once.
For example, if s = 1110100, he can choose a subsequence corresponding to indices (1-based) \{2, 6, 7 \} and rotate them clockwise. The resulting string would then be s = 1010110.
A string a is said to be a subsequence of string b if a can be obtained from b by deleting some characters without changing the ordering of the remaining characters.
To perform a clockwise rotation on a sequence c of size k is to perform an operation which sets c_1:=c_k, c_2:=c_1, c_3:=c_2, …, c_k:=c_{k-1} simultaneously.
Determine the minimum number of operations Naman has to perform to convert s into t or say that it is impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of the strings.
The second line contains the binary string s of length n.
The third line contains the binary string t of length n.
Output
If it is impossible to convert s to t after any number of operations, print -1.
Otherwise, print the minimum number of operations required.
Examples
Input
6
010000
000001
Output
1
Input
10
1111100000
0000011111
Output
5
Input
8
10101010
01010101
Output
1
Input
10
1111100000
1111100001
Output
-1
Note
In the first test, Naman can choose the subsequence corresponding to indices \{2, 6\} and rotate it once to convert s into t.
In the second test, he can rotate the subsequence corresponding to all indices 5 times. It can be proved, that it is the minimum required number of operations.
In the last test, it is impossible to convert s into t. | instruction | 0 | 24,937 | 0 | 49,874 |
Tags: binary search, constructive algorithms, data structures, greedy
Correct Solution:
```
def answer(n,s,t):
if s==t:
return 0
c1s=0
for i in s:
if i=="1":
c1s+=1
c1t=0
for i in t:
if i=="1":
c1t+=1
if c1s!=c1t:
return -1
ones=0
zeros=0
for i in range(n):
if s[i]=="1" and t[i]=="0":
if zeros:
zeros-=1
ones+=1
elif s[i]=="0" and t[i]=="1":
if ones:
ones-=1
zeros+=1
return zeros+ones
n=int(input())
s=input()
t=input()
print(answer(n,s,t))
``` | output | 1 | 24,937 | 0 | 49,875 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Naman has two binary strings s and t of length n (a binary string is a string which only consists of the characters "0" and "1"). He wants to convert s into t using the following operation as few times as possible.
In one operation, he can choose any subsequence of s and rotate it clockwise once.
For example, if s = 1110100, he can choose a subsequence corresponding to indices (1-based) \{2, 6, 7 \} and rotate them clockwise. The resulting string would then be s = 1010110.
A string a is said to be a subsequence of string b if a can be obtained from b by deleting some characters without changing the ordering of the remaining characters.
To perform a clockwise rotation on a sequence c of size k is to perform an operation which sets c_1:=c_k, c_2:=c_1, c_3:=c_2, …, c_k:=c_{k-1} simultaneously.
Determine the minimum number of operations Naman has to perform to convert s into t or say that it is impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of the strings.
The second line contains the binary string s of length n.
The third line contains the binary string t of length n.
Output
If it is impossible to convert s to t after any number of operations, print -1.
Otherwise, print the minimum number of operations required.
Examples
Input
6
010000
000001
Output
1
Input
10
1111100000
0000011111
Output
5
Input
8
10101010
01010101
Output
1
Input
10
1111100000
1111100001
Output
-1
Note
In the first test, Naman can choose the subsequence corresponding to indices \{2, 6\} and rotate it once to convert s into t.
In the second test, he can rotate the subsequence corresponding to all indices 5 times. It can be proved, that it is the minimum required number of operations.
In the last test, it is impossible to convert s into t. | instruction | 0 | 24,938 | 0 | 49,876 |
Tags: binary search, constructive algorithms, data structures, greedy
Correct Solution:
```
# import os,io
# input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
n = int(input())
s = input()
t = input()
s1 = 0
t1 = 0
if s==t:
print(0)
else:
for i in range(n):
if s[i]=='1':
s1+=1
if t[i]=='1':
t1+=1
if s1 != t1:
print(-1)
else:
stype1 = 0
stype2 = 0
for i in range(n):
if s[i]=='1' and t[i]=='0':
stype1+=1
stype2=max(0,stype2-1)
elif s[i]=='0' and t[i]=='1':
stype2+=1
stype1=max(0,stype1-1)
print(stype1+stype2)
``` | output | 1 | 24,938 | 0 | 49,877 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Naman has two binary strings s and t of length n (a binary string is a string which only consists of the characters "0" and "1"). He wants to convert s into t using the following operation as few times as possible.
In one operation, he can choose any subsequence of s and rotate it clockwise once.
For example, if s = 1110100, he can choose a subsequence corresponding to indices (1-based) \{2, 6, 7 \} and rotate them clockwise. The resulting string would then be s = 1010110.
A string a is said to be a subsequence of string b if a can be obtained from b by deleting some characters without changing the ordering of the remaining characters.
To perform a clockwise rotation on a sequence c of size k is to perform an operation which sets c_1:=c_k, c_2:=c_1, c_3:=c_2, …, c_k:=c_{k-1} simultaneously.
Determine the minimum number of operations Naman has to perform to convert s into t or say that it is impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of the strings.
The second line contains the binary string s of length n.
The third line contains the binary string t of length n.
Output
If it is impossible to convert s to t after any number of operations, print -1.
Otherwise, print the minimum number of operations required.
Examples
Input
6
010000
000001
Output
1
Input
10
1111100000
0000011111
Output
5
Input
8
10101010
01010101
Output
1
Input
10
1111100000
1111100001
Output
-1
Note
In the first test, Naman can choose the subsequence corresponding to indices \{2, 6\} and rotate it once to convert s into t.
In the second test, he can rotate the subsequence corresponding to all indices 5 times. It can be proved, that it is the minimum required number of operations.
In the last test, it is impossible to convert s into t. | instruction | 0 | 24,939 | 0 | 49,878 |
Tags: binary search, constructive algorithms, data structures, greedy
Correct Solution:
```
import sys
import heapq
import random
import collections
# available on Google, not available on Codeforces
# import numpy as np
# import scipy
def maxSubArraySum(arr):
max_so_far = 0
max_ending_here = 0
for a in arr:
max_ending_here = max_ending_here + a
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if max_ending_here < 0:
max_ending_here = 0
return max_so_far
def solve(arr, brr): # fix inputs here
console("----- solving ------")
ar = []
br = []
if collections.Counter(arr)["0"] != collections.Counter(brr)["0"]:
return -1
for a,b in zip(arr,brr):
if a == b:
continue
ar.append(2*int(a)-1)
br.append(2*int(b)-1)
# ar.append(int(a))
# br.append(int(b))
return max(maxSubArraySum(ar), maxSubArraySum(br))
def console(*args): # the judge will not read these print statement
print('\033[36m', *args, '\033[0m', file=sys.stderr)
return
# for case_num in range(int(input())):
# read line as a string
# strr = input()
# read line as an integer
_ = int(input())
arr = input()
brr = input()
# read one line and parse each word as a string
# lst = input().split()
# read one line and parse each word as an integer
# lst = list(map(int,input().split()))
# read matrix and parse as integers (after reading read nrows)
# lst = list(map(int,input().split()))
# nrows = lst[0] # index containing information, please change
# grid = []
# for _ in range(nrows):
# grid.append(list(map(int,input().split())))
res = solve(arr, brr) # please change
assert res == solve(brr, arr)
# Google - case number required
# print("Case #{}: {}".format(case_num+1, res))
# Codeforces - no case number required
print(res)
``` | output | 1 | 24,939 | 0 | 49,879 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Naman has two binary strings s and t of length n (a binary string is a string which only consists of the characters "0" and "1"). He wants to convert s into t using the following operation as few times as possible.
In one operation, he can choose any subsequence of s and rotate it clockwise once.
For example, if s = 1110100, he can choose a subsequence corresponding to indices (1-based) \{2, 6, 7 \} and rotate them clockwise. The resulting string would then be s = 1010110.
A string a is said to be a subsequence of string b if a can be obtained from b by deleting some characters without changing the ordering of the remaining characters.
To perform a clockwise rotation on a sequence c of size k is to perform an operation which sets c_1:=c_k, c_2:=c_1, c_3:=c_2, …, c_k:=c_{k-1} simultaneously.
Determine the minimum number of operations Naman has to perform to convert s into t or say that it is impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of the strings.
The second line contains the binary string s of length n.
The third line contains the binary string t of length n.
Output
If it is impossible to convert s to t after any number of operations, print -1.
Otherwise, print the minimum number of operations required.
Examples
Input
6
010000
000001
Output
1
Input
10
1111100000
0000011111
Output
5
Input
8
10101010
01010101
Output
1
Input
10
1111100000
1111100001
Output
-1
Note
In the first test, Naman can choose the subsequence corresponding to indices \{2, 6\} and rotate it once to convert s into t.
In the second test, he can rotate the subsequence corresponding to all indices 5 times. It can be proved, that it is the minimum required number of operations.
In the last test, it is impossible to convert s into t. | instruction | 0 | 24,940 | 0 | 49,880 |
Tags: binary search, constructive algorithms, data structures, greedy
Correct Solution:
```
from bisect import *
from collections import *
from math import *
from heapq import *
from typing import List
from itertools import *
from operator import *
from functools import *
@lru_cache(None)
def fact(x):
if x<2:
return 1
return fact(x-1)*x
@lru_cache(None)
def per(i,j):
return fact(i)//fact(i-j)
@lru_cache(None)
def com(i,j):
return per(i,j)//fact(j)
def linc(f,t,l,r):
while l<r:
mid=(l+r)//2
if t>f(mid):
l=mid+1
else:
r=mid
return l
def rinc(f,t,l,r):
while l<r:
mid=(l+r+1)//2
if t<f(mid):
r=mid-1
else:
l=mid
return l
def ldec(f,t,l,r):
while l<r:
mid=(l+r)//2
if t<f(mid):
l=mid+1
else:
r=mid
return l
def rdec(f,t,l,r):
while l<r:
mid=(l+r+1)//2
if t>f(mid):
r=mid-1
else:
l=mid
return l
def isprime(n):
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
return True
def power2(n):
while not n&1:
n>>=1
return n==1
n=int(input())
s=input()
t=input()
if s.count('1')!=t.count('1'):
print(-1)
exit()
one,zero=0,0
ans=0
for i in range(n):
if s[i]!=t[i]:
if s[i]=='1':
if zero:
zero-=1
one+=1
ans=max(one,ans)
else:
if one:
one-=1
zero+=1
ans=max(zero,ans)
print(ans)
``` | output | 1 | 24,940 | 0 | 49,881 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Naman has two binary strings s and t of length n (a binary string is a string which only consists of the characters "0" and "1"). He wants to convert s into t using the following operation as few times as possible.
In one operation, he can choose any subsequence of s and rotate it clockwise once.
For example, if s = 1110100, he can choose a subsequence corresponding to indices (1-based) \{2, 6, 7 \} and rotate them clockwise. The resulting string would then be s = 1010110.
A string a is said to be a subsequence of string b if a can be obtained from b by deleting some characters without changing the ordering of the remaining characters.
To perform a clockwise rotation on a sequence c of size k is to perform an operation which sets c_1:=c_k, c_2:=c_1, c_3:=c_2, …, c_k:=c_{k-1} simultaneously.
Determine the minimum number of operations Naman has to perform to convert s into t or say that it is impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of the strings.
The second line contains the binary string s of length n.
The third line contains the binary string t of length n.
Output
If it is impossible to convert s to t after any number of operations, print -1.
Otherwise, print the minimum number of operations required.
Examples
Input
6
010000
000001
Output
1
Input
10
1111100000
0000011111
Output
5
Input
8
10101010
01010101
Output
1
Input
10
1111100000
1111100001
Output
-1
Note
In the first test, Naman can choose the subsequence corresponding to indices \{2, 6\} and rotate it once to convert s into t.
In the second test, he can rotate the subsequence corresponding to all indices 5 times. It can be proved, that it is the minimum required number of operations.
In the last test, it is impossible to convert s into t. | instruction | 0 | 24,941 | 0 | 49,882 |
Tags: binary search, constructive algorithms, data structures, greedy
Correct Solution:
```
import math
import sys
n = int(input())
t1 = list(input())
t3 = list(input())
o=0
z=0
i=0
t2 = []
while i<len(t1):
if(t1[i]==t3[i]):
i+=1
else:
if(t1[i]=='1'):
o+=1
t2.append(t3[i])
else:
z+=1
t2.append(t3[i])
i+=1
if(len(t2)==0):
print("0")
sys.exit()
for i in range(len(t2)):
if(t2[i]=='0'):
z-=1
else:
o-=1
if(o<0 or z<0):
print("-1")
sys.exit()
else:
ma = 0
m = 0
for i in t2:
if(int(i)%2==0):
m+=1
ma = max(ma,m)
else:
m = max(0,m-1)
ma = max(m,ma)
m = 0
for i in t2:
if(int(i)%2==1):
m+=1
ma = max(ma,m)
else:
m = max(0,m-1)
ma = max(m,ma)
print(ma)
``` | output | 1 | 24,941 | 0 | 49,883 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Naman has two binary strings s and t of length n (a binary string is a string which only consists of the characters "0" and "1"). He wants to convert s into t using the following operation as few times as possible.
In one operation, he can choose any subsequence of s and rotate it clockwise once.
For example, if s = 1110100, he can choose a subsequence corresponding to indices (1-based) \{2, 6, 7 \} and rotate them clockwise. The resulting string would then be s = 1010110.
A string a is said to be a subsequence of string b if a can be obtained from b by deleting some characters without changing the ordering of the remaining characters.
To perform a clockwise rotation on a sequence c of size k is to perform an operation which sets c_1:=c_k, c_2:=c_1, c_3:=c_2, …, c_k:=c_{k-1} simultaneously.
Determine the minimum number of operations Naman has to perform to convert s into t or say that it is impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of the strings.
The second line contains the binary string s of length n.
The third line contains the binary string t of length n.
Output
If it is impossible to convert s to t after any number of operations, print -1.
Otherwise, print the minimum number of operations required.
Examples
Input
6
010000
000001
Output
1
Input
10
1111100000
0000011111
Output
5
Input
8
10101010
01010101
Output
1
Input
10
1111100000
1111100001
Output
-1
Note
In the first test, Naman can choose the subsequence corresponding to indices \{2, 6\} and rotate it once to convert s into t.
In the second test, he can rotate the subsequence corresponding to all indices 5 times. It can be proved, that it is the minimum required number of operations.
In the last test, it is impossible to convert s into t. | instruction | 0 | 24,942 | 0 | 49,884 |
Tags: binary search, constructive algorithms, data structures, greedy
Correct Solution:
```
from sys import stdin
input=lambda : stdin.readline().strip()
from math import ceil,sqrt,gcd
from collections import deque
n=int(input())
s=list(input())
t=list(input())
o=0
z=0
x=[]
for i in range(n):
if s[i]=='1':
o+=1
else:
z+=1
if t[i]=='1':
o-=1
else:
z-=1
if z==0 and o==0:
st1=[]
st2=[]
for i in range(n):
if s[i]=='1' and t[i]=='0':
if len(st1)==0:
x.append([i])
st2.append(len(x)-1)
else:
ne=st1.pop()
x[ne].append(i)
st2.append(ne)
elif s[i]=='0' and t[i]=='1':
if len(st2)==0:
x.append([i])
st1.append(len(x)-1)
else:
ne=st2.pop()
x[ne].append(i)
st1.append(ne)
print(len(x))
# print(x)
else:
print(-1)
``` | output | 1 | 24,942 | 0 | 49,885 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Naman has two binary strings s and t of length n (a binary string is a string which only consists of the characters "0" and "1"). He wants to convert s into t using the following operation as few times as possible.
In one operation, he can choose any subsequence of s and rotate it clockwise once.
For example, if s = 1110100, he can choose a subsequence corresponding to indices (1-based) \{2, 6, 7 \} and rotate them clockwise. The resulting string would then be s = 1010110.
A string a is said to be a subsequence of string b if a can be obtained from b by deleting some characters without changing the ordering of the remaining characters.
To perform a clockwise rotation on a sequence c of size k is to perform an operation which sets c_1:=c_k, c_2:=c_1, c_3:=c_2, …, c_k:=c_{k-1} simultaneously.
Determine the minimum number of operations Naman has to perform to convert s into t or say that it is impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of the strings.
The second line contains the binary string s of length n.
The third line contains the binary string t of length n.
Output
If it is impossible to convert s to t after any number of operations, print -1.
Otherwise, print the minimum number of operations required.
Examples
Input
6
010000
000001
Output
1
Input
10
1111100000
0000011111
Output
5
Input
8
10101010
01010101
Output
1
Input
10
1111100000
1111100001
Output
-1
Note
In the first test, Naman can choose the subsequence corresponding to indices \{2, 6\} and rotate it once to convert s into t.
In the second test, he can rotate the subsequence corresponding to all indices 5 times. It can be proved, that it is the minimum required number of operations.
In the last test, it is impossible to convert s into t. | instruction | 0 | 24,943 | 0 | 49,886 |
Tags: binary search, constructive algorithms, data structures, greedy
Correct Solution:
```
m=int(input())
s=list(input())
t=list(input())
i=0
a=c=d=0
while(i<m):
if s[i]!=t[i]:
if s[i]=='0':
a+=1
else:
a-=1
c=min(c,a)
d=max(d,a)
i+=1
if a==0:
print(d-c)
else:
print(-1)
``` | output | 1 | 24,943 | 0 | 49,887 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Naman has two binary strings s and t of length n (a binary string is a string which only consists of the characters "0" and "1"). He wants to convert s into t using the following operation as few times as possible.
In one operation, he can choose any subsequence of s and rotate it clockwise once.
For example, if s = 1110100, he can choose a subsequence corresponding to indices (1-based) \{2, 6, 7 \} and rotate them clockwise. The resulting string would then be s = 1010110.
A string a is said to be a subsequence of string b if a can be obtained from b by deleting some characters without changing the ordering of the remaining characters.
To perform a clockwise rotation on a sequence c of size k is to perform an operation which sets c_1:=c_k, c_2:=c_1, c_3:=c_2, …, c_k:=c_{k-1} simultaneously.
Determine the minimum number of operations Naman has to perform to convert s into t or say that it is impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of the strings.
The second line contains the binary string s of length n.
The third line contains the binary string t of length n.
Output
If it is impossible to convert s to t after any number of operations, print -1.
Otherwise, print the minimum number of operations required.
Examples
Input
6
010000
000001
Output
1
Input
10
1111100000
0000011111
Output
5
Input
8
10101010
01010101
Output
1
Input
10
1111100000
1111100001
Output
-1
Note
In the first test, Naman can choose the subsequence corresponding to indices \{2, 6\} and rotate it once to convert s into t.
In the second test, he can rotate the subsequence corresponding to all indices 5 times. It can be proved, that it is the minimum required number of operations.
In the last test, it is impossible to convert s into t.
Submitted Solution:
```
import sys
input = sys.stdin.readline
I = lambda : list(map(int,input().split()))
n,=I()
s=input().strip()
t=input().strip()
if s.count('1')!=t.count('1'):
print(-1)
else:
an=0
if s==t:
print(an)
else:
a=b=0
for i in range(n):
if s[i]!=t[i]:
if s[i]=='1':
if b:
b-=1
else:
an+=1
a+=1
else:
if a:
a-=1
else:
an+=1
b+=1
print(an)
``` | instruction | 0 | 24,944 | 0 | 49,888 |
Yes | output | 1 | 24,944 | 0 | 49,889 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Naman has two binary strings s and t of length n (a binary string is a string which only consists of the characters "0" and "1"). He wants to convert s into t using the following operation as few times as possible.
In one operation, he can choose any subsequence of s and rotate it clockwise once.
For example, if s = 1110100, he can choose a subsequence corresponding to indices (1-based) \{2, 6, 7 \} and rotate them clockwise. The resulting string would then be s = 1010110.
A string a is said to be a subsequence of string b if a can be obtained from b by deleting some characters without changing the ordering of the remaining characters.
To perform a clockwise rotation on a sequence c of size k is to perform an operation which sets c_1:=c_k, c_2:=c_1, c_3:=c_2, …, c_k:=c_{k-1} simultaneously.
Determine the minimum number of operations Naman has to perform to convert s into t or say that it is impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of the strings.
The second line contains the binary string s of length n.
The third line contains the binary string t of length n.
Output
If it is impossible to convert s to t after any number of operations, print -1.
Otherwise, print the minimum number of operations required.
Examples
Input
6
010000
000001
Output
1
Input
10
1111100000
0000011111
Output
5
Input
8
10101010
01010101
Output
1
Input
10
1111100000
1111100001
Output
-1
Note
In the first test, Naman can choose the subsequence corresponding to indices \{2, 6\} and rotate it once to convert s into t.
In the second test, he can rotate the subsequence corresponding to all indices 5 times. It can be proved, that it is the minimum required number of operations.
In the last test, it is impossible to convert s into t.
Submitted Solution:
```
r=int(input())
s=list(input())
t=list(input())
i=0
a=c=d=0
while(i<r):
if s[i]!=t[i]:
if s[i]=='0':
a+=1
else:
a-=1
c=min(c,a)
d=max(d,a)
i+=1
if a==0:
print(d-c)
else:
print(-1)
``` | instruction | 0 | 24,945 | 0 | 49,890 |
Yes | output | 1 | 24,945 | 0 | 49,891 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Naman has two binary strings s and t of length n (a binary string is a string which only consists of the characters "0" and "1"). He wants to convert s into t using the following operation as few times as possible.
In one operation, he can choose any subsequence of s and rotate it clockwise once.
For example, if s = 1110100, he can choose a subsequence corresponding to indices (1-based) \{2, 6, 7 \} and rotate them clockwise. The resulting string would then be s = 1010110.
A string a is said to be a subsequence of string b if a can be obtained from b by deleting some characters without changing the ordering of the remaining characters.
To perform a clockwise rotation on a sequence c of size k is to perform an operation which sets c_1:=c_k, c_2:=c_1, c_3:=c_2, …, c_k:=c_{k-1} simultaneously.
Determine the minimum number of operations Naman has to perform to convert s into t or say that it is impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of the strings.
The second line contains the binary string s of length n.
The third line contains the binary string t of length n.
Output
If it is impossible to convert s to t after any number of operations, print -1.
Otherwise, print the minimum number of operations required.
Examples
Input
6
010000
000001
Output
1
Input
10
1111100000
0000011111
Output
5
Input
8
10101010
01010101
Output
1
Input
10
1111100000
1111100001
Output
-1
Note
In the first test, Naman can choose the subsequence corresponding to indices \{2, 6\} and rotate it once to convert s into t.
In the second test, he can rotate the subsequence corresponding to all indices 5 times. It can be proved, that it is the minimum required number of operations.
In the last test, it is impossible to convert s into t.
Submitted Solution:
```
import sys
from collections import defaultdict as dd
from collections import deque
from fractions import Fraction as f
from copy import *
from bisect import *
from heapq import *
#from math import *
from itertools import permutations
def eprint(*args):
print(*args, file=sys.stderr)
zz=1
#sys.setrecursionlimit(10**6)
if zz:
input=sys.stdin.readline
else:
sys.stdin=open('input.txt', 'r')
sys.stdout=open('all.txt','w')
def li():
return [int(x) for x in input().split()]
def fi():
return int(input())
def si():
return list(input().rstrip())
def mi():
return map(int,input().split())
def gh():
sys.stdout.flush()
def graph(n,m):
for i in range(m):
x,y=mi()
a[x].append(y)
a[y].append(x)
def bo(i):
return ord(i)-ord('a')
n=fi()
a=si()
b=si()
d=[]
for i in range(n):
if a[i]!=b[i]:
d.append(1 if a[i]=='1' else -1)
maxi=0
i=c1=c2=0
for i in range(len(d)):
c1+=d[i]
c2+=d[i]*-1
maxi=max(maxi,max(c1,c2))
if c1<0:
c1=0
if c2<0:
c2=0
print(maxi if a.count('1')==b.count('1') else -1)
``` | instruction | 0 | 24,946 | 0 | 49,892 |
Yes | output | 1 | 24,946 | 0 | 49,893 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Naman has two binary strings s and t of length n (a binary string is a string which only consists of the characters "0" and "1"). He wants to convert s into t using the following operation as few times as possible.
In one operation, he can choose any subsequence of s and rotate it clockwise once.
For example, if s = 1110100, he can choose a subsequence corresponding to indices (1-based) \{2, 6, 7 \} and rotate them clockwise. The resulting string would then be s = 1010110.
A string a is said to be a subsequence of string b if a can be obtained from b by deleting some characters without changing the ordering of the remaining characters.
To perform a clockwise rotation on a sequence c of size k is to perform an operation which sets c_1:=c_k, c_2:=c_1, c_3:=c_2, …, c_k:=c_{k-1} simultaneously.
Determine the minimum number of operations Naman has to perform to convert s into t or say that it is impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of the strings.
The second line contains the binary string s of length n.
The third line contains the binary string t of length n.
Output
If it is impossible to convert s to t after any number of operations, print -1.
Otherwise, print the minimum number of operations required.
Examples
Input
6
010000
000001
Output
1
Input
10
1111100000
0000011111
Output
5
Input
8
10101010
01010101
Output
1
Input
10
1111100000
1111100001
Output
-1
Note
In the first test, Naman can choose the subsequence corresponding to indices \{2, 6\} and rotate it once to convert s into t.
In the second test, he can rotate the subsequence corresponding to all indices 5 times. It can be proved, that it is the minimum required number of operations.
In the last test, it is impossible to convert s into t.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
from collections import defaultdict as dd
def main():
n=int(input())
s=input()
t=input()
o,z=0,0
a=0
if s==t: print(0)
elif s.count('1')!=t.count('1'): print(-1)
else:
for i in range(n):
a+=int(s[i])-int(t[i])
o=max(a,o)
z=min(a,z)
print(o-z)
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")
if __name__ == "__main__":
main()
``` | instruction | 0 | 24,947 | 0 | 49,894 |
Yes | output | 1 | 24,947 | 0 | 49,895 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Naman has two binary strings s and t of length n (a binary string is a string which only consists of the characters "0" and "1"). He wants to convert s into t using the following operation as few times as possible.
In one operation, he can choose any subsequence of s and rotate it clockwise once.
For example, if s = 1110100, he can choose a subsequence corresponding to indices (1-based) \{2, 6, 7 \} and rotate them clockwise. The resulting string would then be s = 1010110.
A string a is said to be a subsequence of string b if a can be obtained from b by deleting some characters without changing the ordering of the remaining characters.
To perform a clockwise rotation on a sequence c of size k is to perform an operation which sets c_1:=c_k, c_2:=c_1, c_3:=c_2, …, c_k:=c_{k-1} simultaneously.
Determine the minimum number of operations Naman has to perform to convert s into t or say that it is impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of the strings.
The second line contains the binary string s of length n.
The third line contains the binary string t of length n.
Output
If it is impossible to convert s to t after any number of operations, print -1.
Otherwise, print the minimum number of operations required.
Examples
Input
6
010000
000001
Output
1
Input
10
1111100000
0000011111
Output
5
Input
8
10101010
01010101
Output
1
Input
10
1111100000
1111100001
Output
-1
Note
In the first test, Naman can choose the subsequence corresponding to indices \{2, 6\} and rotate it once to convert s into t.
In the second test, he can rotate the subsequence corresponding to all indices 5 times. It can be proved, that it is the minimum required number of operations.
In the last test, it is impossible to convert s into t.
Submitted Solution:
```
n = int(input())
t = input()
s = input()
o1 = 0
o2 = 0
for i in range(len(s)):
if s[i]=='1':
o1+=1
if t[i]=='1':
o2+=1
if o1!=o2:
print(-1)
exit(0)
i = n
j = n-1
ans = 0
while i>0:
i-=1
c = 0
while s[j%n]!=t[i]:
j = (j-1)%n
c+=1
j-=1
ans = max(ans,c)
print(ans)
``` | instruction | 0 | 24,948 | 0 | 49,896 |
No | output | 1 | 24,948 | 0 | 49,897 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Naman has two binary strings s and t of length n (a binary string is a string which only consists of the characters "0" and "1"). He wants to convert s into t using the following operation as few times as possible.
In one operation, he can choose any subsequence of s and rotate it clockwise once.
For example, if s = 1110100, he can choose a subsequence corresponding to indices (1-based) \{2, 6, 7 \} and rotate them clockwise. The resulting string would then be s = 1010110.
A string a is said to be a subsequence of string b if a can be obtained from b by deleting some characters without changing the ordering of the remaining characters.
To perform a clockwise rotation on a sequence c of size k is to perform an operation which sets c_1:=c_k, c_2:=c_1, c_3:=c_2, …, c_k:=c_{k-1} simultaneously.
Determine the minimum number of operations Naman has to perform to convert s into t or say that it is impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of the strings.
The second line contains the binary string s of length n.
The third line contains the binary string t of length n.
Output
If it is impossible to convert s to t after any number of operations, print -1.
Otherwise, print the minimum number of operations required.
Examples
Input
6
010000
000001
Output
1
Input
10
1111100000
0000011111
Output
5
Input
8
10101010
01010101
Output
1
Input
10
1111100000
1111100001
Output
-1
Note
In the first test, Naman can choose the subsequence corresponding to indices \{2, 6\} and rotate it once to convert s into t.
In the second test, he can rotate the subsequence corresponding to all indices 5 times. It can be proved, that it is the minimum required number of operations.
In the last test, it is impossible to convert s into t.
Submitted Solution:
```
import sys
from collections import defaultdict as dd
from collections import Counter as cc
from queue import Queue
import math
import itertools
try:
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
except:
pass
# input = lambda: sys.stdin.buffer.readline().rstrip()
q=int(input())
w=input()
e=input()
r=[]
if w.count('1')!=e.count('1'):
print(-1)
exit()
if w.count('1')==q or w.count('1')==0:
print(0)
exit()
for i in range(q):
if w[i]!=e[i]:
r.append(e[i])
k=1
l=1
w=[1]
e=[1]
for i in range(1,len(r)):
if r[i-1]=='1' and r[i]=='1':
k+=1
elif r[i-1]=='0' and r[i]=='0':
l+=1
else:
e.append(k)
w.append(l)
k=1
l=1
e.append(k)
w.append(l)
print(max(e))
``` | instruction | 0 | 24,949 | 0 | 49,898 |
No | output | 1 | 24,949 | 0 | 49,899 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Naman has two binary strings s and t of length n (a binary string is a string which only consists of the characters "0" and "1"). He wants to convert s into t using the following operation as few times as possible.
In one operation, he can choose any subsequence of s and rotate it clockwise once.
For example, if s = 1110100, he can choose a subsequence corresponding to indices (1-based) \{2, 6, 7 \} and rotate them clockwise. The resulting string would then be s = 1010110.
A string a is said to be a subsequence of string b if a can be obtained from b by deleting some characters without changing the ordering of the remaining characters.
To perform a clockwise rotation on a sequence c of size k is to perform an operation which sets c_1:=c_k, c_2:=c_1, c_3:=c_2, …, c_k:=c_{k-1} simultaneously.
Determine the minimum number of operations Naman has to perform to convert s into t or say that it is impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of the strings.
The second line contains the binary string s of length n.
The third line contains the binary string t of length n.
Output
If it is impossible to convert s to t after any number of operations, print -1.
Otherwise, print the minimum number of operations required.
Examples
Input
6
010000
000001
Output
1
Input
10
1111100000
0000011111
Output
5
Input
8
10101010
01010101
Output
1
Input
10
1111100000
1111100001
Output
-1
Note
In the first test, Naman can choose the subsequence corresponding to indices \{2, 6\} and rotate it once to convert s into t.
In the second test, he can rotate the subsequence corresponding to all indices 5 times. It can be proved, that it is the minimum required number of operations.
In the last test, it is impossible to convert s into t.
Submitted Solution:
```
from sys import stdin
input = stdin.readline
n = int(input())
a = input().rstrip()
b = input().rstrip()
c = []
res = []
for x in range(n):
if a[x] != b[x]:
if a[x] == '1':
c.append(1)
else:
c.append(-1)
if sum(c) != 0:
print(-1)
elif a == b:
print(0)
else:
cnt, now = 1, 1
m = len(c) * 3
d = []
for x in c:
d.append(x)
for x in c:
d.append(x)
for x in c:
d.append(x)
for x in range(1, m):
if d[x] != d[x - 1]:
now = 1
else:
now += 1
if cnt < now:
cnt = now
res.append(cnt)
d.insert(0, d[-1])
del d[-1]
cnt, now = 1, 1
for x in range(1, m):
if d[x] != d[x - 1]:
now = 1
else:
now += 1
if cnt < now:
cnt = now
res.append(cnt)
print(min(res))
``` | instruction | 0 | 24,950 | 0 | 49,900 |
No | output | 1 | 24,950 | 0 | 49,901 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Naman has two binary strings s and t of length n (a binary string is a string which only consists of the characters "0" and "1"). He wants to convert s into t using the following operation as few times as possible.
In one operation, he can choose any subsequence of s and rotate it clockwise once.
For example, if s = 1110100, he can choose a subsequence corresponding to indices (1-based) \{2, 6, 7 \} and rotate them clockwise. The resulting string would then be s = 1010110.
A string a is said to be a subsequence of string b if a can be obtained from b by deleting some characters without changing the ordering of the remaining characters.
To perform a clockwise rotation on a sequence c of size k is to perform an operation which sets c_1:=c_k, c_2:=c_1, c_3:=c_2, …, c_k:=c_{k-1} simultaneously.
Determine the minimum number of operations Naman has to perform to convert s into t or say that it is impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of the strings.
The second line contains the binary string s of length n.
The third line contains the binary string t of length n.
Output
If it is impossible to convert s to t after any number of operations, print -1.
Otherwise, print the minimum number of operations required.
Examples
Input
6
010000
000001
Output
1
Input
10
1111100000
0000011111
Output
5
Input
8
10101010
01010101
Output
1
Input
10
1111100000
1111100001
Output
-1
Note
In the first test, Naman can choose the subsequence corresponding to indices \{2, 6\} and rotate it once to convert s into t.
In the second test, he can rotate the subsequence corresponding to all indices 5 times. It can be proved, that it is the minimum required number of operations.
In the last test, it is impossible to convert s into t.
Submitted Solution:
```
n=int(input())
s=input()
t=input()
moves=[]
s1_z=0
s2_z=0
for i in range(n):
if s[i]=='0':
s1_z+=1
if t[i]=='0':
s2_z+=1
if s[i]!=t[i]:
moves.append(s[i])
if s1_z!=s2_z:
print(-1)
else:
# print(moves)
total=len(moves)//2
comb1=0
comb2=0
for x in range(len(moves)-1):
if (moves[x]=='1' and moves[x+1]=='0'):
comb1+=1
elif (moves[x]=='0' and moves[x+1]=='1'):
comb2+=1
print(total-max(max(0,comb1-1),max(0,comb2-1)))
``` | instruction | 0 | 24,951 | 0 | 49,902 |
No | output | 1 | 24,951 | 0 | 49,903 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Just in case somebody missed it: this winter is totally cold in Nvodsk! It is so cold that one gets funny thoughts. For example, let's say there are strings with the length exactly n, based on the alphabet of size m. Any its substring with length equal to k is a palindrome. How many such strings exist? Your task is to find their quantity modulo 1000000007 (109 + 7). Be careful and don't miss a string or two!
Let us remind you that a string is a palindrome if it can be read the same way in either direction, from the left to the right and from the right to the left.
Input
The first and only line contains three integers: n, m and k (1 ≤ n, m, k ≤ 2000).
Output
Print a single integer — the number of strings of the described type modulo 1000000007 (109 + 7).
Examples
Input
1 1 1
Output
1
Input
5 2 4
Output
2
Note
In the first sample only one string is valid: "a" (let's denote the only letter of our alphabet as "a").
In the second sample (if we denote the alphabet letters as "a" and "b") the following strings are valid: "aaaaa" and "bbbbb". | instruction | 0 | 25,000 | 0 | 50,000 |
Tags: combinatorics, dfs and similar, graphs, math
Correct Solution:
```
import sys
n,m,k=(int(x) for x in sys.stdin.readline().split())
ret=0
if (k==1)or(k>n):
ret=(m**n)%1000000007
elif k==n:
if n%2==1:
ret=(m**int((n+1)/2))%1000000007
else:
ret=(m**int(n/2))%1000000007
elif k<n:
if k%2==1:
ret=m**2
else:
ret=m
print(int(ret))
``` | output | 1 | 25,000 | 0 | 50,001 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Just in case somebody missed it: this winter is totally cold in Nvodsk! It is so cold that one gets funny thoughts. For example, let's say there are strings with the length exactly n, based on the alphabet of size m. Any its substring with length equal to k is a palindrome. How many such strings exist? Your task is to find their quantity modulo 1000000007 (109 + 7). Be careful and don't miss a string or two!
Let us remind you that a string is a palindrome if it can be read the same way in either direction, from the left to the right and from the right to the left.
Input
The first and only line contains three integers: n, m and k (1 ≤ n, m, k ≤ 2000).
Output
Print a single integer — the number of strings of the described type modulo 1000000007 (109 + 7).
Examples
Input
1 1 1
Output
1
Input
5 2 4
Output
2
Note
In the first sample only one string is valid: "a" (let's denote the only letter of our alphabet as "a").
In the second sample (if we denote the alphabet letters as "a" and "b") the following strings are valid: "aaaaa" and "bbbbb". | instruction | 0 | 25,001 | 0 | 50,002 |
Tags: combinatorics, dfs and similar, graphs, math
Correct Solution:
```
n, m, k = map(int, input().split())
def check(l, r) :
while (l < r) :
if (s[l] != s[r]) :
return False
l += 1
r -= 1
return True
s = [0] * n
def rec(v) :
if (v == n) :
for i in range(n - k + 1) :
if (not check(i, i + k - 1)) :
return ;
res = ''
for i in range(n) :
res = res + str(s[i]) + ' '
print(res)
else :
for i in range(m) :
s[v] = i
rec(v + 1)
ans = 0
base = 1e9 + 7
base = int(base)
if (k > n or k == 1) :
ans = 1
for i in range(n) :
ans = ans * m % base
print(ans)
elif (n == k) :
ans = 1
for i in range((n + 1) // 2) :
ans = ans * m % base
print(ans)
elif (n > k) :
ans = m
if (k % 2 == 1) :
ans += m * (m - 1)
print(ans % base)
``` | output | 1 | 25,001 | 0 | 50,003 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Just in case somebody missed it: this winter is totally cold in Nvodsk! It is so cold that one gets funny thoughts. For example, let's say there are strings with the length exactly n, based on the alphabet of size m. Any its substring with length equal to k is a palindrome. How many such strings exist? Your task is to find their quantity modulo 1000000007 (109 + 7). Be careful and don't miss a string or two!
Let us remind you that a string is a palindrome if it can be read the same way in either direction, from the left to the right and from the right to the left.
Input
The first and only line contains three integers: n, m and k (1 ≤ n, m, k ≤ 2000).
Output
Print a single integer — the number of strings of the described type modulo 1000000007 (109 + 7).
Examples
Input
1 1 1
Output
1
Input
5 2 4
Output
2
Note
In the first sample only one string is valid: "a" (let's denote the only letter of our alphabet as "a").
In the second sample (if we denote the alphabet letters as "a" and "b") the following strings are valid: "aaaaa" and "bbbbb". | instruction | 0 | 25,002 | 0 | 50,004 |
Tags: combinatorics, dfs and similar, graphs, math
Correct Solution:
```
n, m, k = input().split()
n = int(n)
m = int(m)
k = int(k)
module = 1000000007
if k <= 0:
print(0)
elif k == 1 or k > n:
print((m ** n) % module)
elif k == n:
print((m ** int((n + 1) / 2)) % module)
elif k % 2 == 1:
print((m ** 2) % module)
elif k % 2 == 0:
print(m % module)
``` | output | 1 | 25,002 | 0 | 50,005 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Just in case somebody missed it: this winter is totally cold in Nvodsk! It is so cold that one gets funny thoughts. For example, let's say there are strings with the length exactly n, based on the alphabet of size m. Any its substring with length equal to k is a palindrome. How many such strings exist? Your task is to find their quantity modulo 1000000007 (109 + 7). Be careful and don't miss a string or two!
Let us remind you that a string is a palindrome if it can be read the same way in either direction, from the left to the right and from the right to the left.
Input
The first and only line contains three integers: n, m and k (1 ≤ n, m, k ≤ 2000).
Output
Print a single integer — the number of strings of the described type modulo 1000000007 (109 + 7).
Examples
Input
1 1 1
Output
1
Input
5 2 4
Output
2
Note
In the first sample only one string is valid: "a" (let's denote the only letter of our alphabet as "a").
In the second sample (if we denote the alphabet letters as "a" and "b") the following strings are valid: "aaaaa" and "bbbbb". | instruction | 0 | 25,003 | 0 | 50,006 |
Tags: combinatorics, dfs and similar, graphs, math
Correct Solution:
```
n,m,k=map(int,input().split())
mod=10**9+7
if n<k:
print(pow(m,n,mod))
elif n==k:
x=n//2
if n%2==0:
print(pow(m,x,mod))
else:
print(pow(m,x+1,mod))
else:
if k==1:
print(pow(m,n,mod))
elif k%2==1:
ans=0
ans+=m
ans+=m*(m-1)
print(ans%mod)
else:
print(m)
``` | output | 1 | 25,003 | 0 | 50,007 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Just in case somebody missed it: this winter is totally cold in Nvodsk! It is so cold that one gets funny thoughts. For example, let's say there are strings with the length exactly n, based on the alphabet of size m. Any its substring with length equal to k is a palindrome. How many such strings exist? Your task is to find their quantity modulo 1000000007 (109 + 7). Be careful and don't miss a string or two!
Let us remind you that a string is a palindrome if it can be read the same way in either direction, from the left to the right and from the right to the left.
Input
The first and only line contains three integers: n, m and k (1 ≤ n, m, k ≤ 2000).
Output
Print a single integer — the number of strings of the described type modulo 1000000007 (109 + 7).
Examples
Input
1 1 1
Output
1
Input
5 2 4
Output
2
Note
In the first sample only one string is valid: "a" (let's denote the only letter of our alphabet as "a").
In the second sample (if we denote the alphabet letters as "a" and "b") the following strings are valid: "aaaaa" and "bbbbb". | instruction | 0 | 25,004 | 0 | 50,008 |
Tags: combinatorics, dfs and similar, graphs, math
Correct Solution:
```
n,m,k = map(int, input().split())
mod = 1000000007
if k == 1 or k > n:
ans = pow(m, n, mod)
elif k == n:
ans = pow(m, (n + 1) // 2, mod)
elif k % 2 == 0:
ans = m
else:
ans = m * m
print(ans)
``` | output | 1 | 25,004 | 0 | 50,009 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Just in case somebody missed it: this winter is totally cold in Nvodsk! It is so cold that one gets funny thoughts. For example, let's say there are strings with the length exactly n, based on the alphabet of size m. Any its substring with length equal to k is a palindrome. How many such strings exist? Your task is to find their quantity modulo 1000000007 (109 + 7). Be careful and don't miss a string or two!
Let us remind you that a string is a palindrome if it can be read the same way in either direction, from the left to the right and from the right to the left.
Input
The first and only line contains three integers: n, m and k (1 ≤ n, m, k ≤ 2000).
Output
Print a single integer — the number of strings of the described type modulo 1000000007 (109 + 7).
Examples
Input
1 1 1
Output
1
Input
5 2 4
Output
2
Note
In the first sample only one string is valid: "a" (let's denote the only letter of our alphabet as "a").
In the second sample (if we denote the alphabet letters as "a" and "b") the following strings are valid: "aaaaa" and "bbbbb". | instruction | 0 | 25,005 | 0 | 50,010 |
Tags: combinatorics, dfs and similar, graphs, math
Correct Solution:
```
#!/usr/bin/python3
MOD = int(1e9 + 7)
N, m, k = [int(x) for x in input().split()]
def kelk(a, b):
ret = 1
while b:
if b % 2:
ret = (a*int(ret))%MOD
a = int(a*a)%MOD
a = int(a) % MOD
b //= 2
return int(ret) % MOD
if k > N or k == 1:
print(kelk(m, N))
elif k < N:
print(int(m + m*(m - 1)*(k % 2)))
elif k == N:
print(kelk(m, (N+1)//2))
``` | output | 1 | 25,005 | 0 | 50,011 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Just in case somebody missed it: this winter is totally cold in Nvodsk! It is so cold that one gets funny thoughts. For example, let's say there are strings with the length exactly n, based on the alphabet of size m. Any its substring with length equal to k is a palindrome. How many such strings exist? Your task is to find their quantity modulo 1000000007 (109 + 7). Be careful and don't miss a string or two!
Let us remind you that a string is a palindrome if it can be read the same way in either direction, from the left to the right and from the right to the left.
Input
The first and only line contains three integers: n, m and k (1 ≤ n, m, k ≤ 2000).
Output
Print a single integer — the number of strings of the described type modulo 1000000007 (109 + 7).
Examples
Input
1 1 1
Output
1
Input
5 2 4
Output
2
Note
In the first sample only one string is valid: "a" (let's denote the only letter of our alphabet as "a").
In the second sample (if we denote the alphabet letters as "a" and "b") the following strings are valid: "aaaaa" and "bbbbb". | instruction | 0 | 25,006 | 0 | 50,012 |
Tags: combinatorics, dfs and similar, graphs, math
Correct Solution:
```
import sys,os,io
import math
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r") ; sys.stdout = open("output.txt","w")
else:
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
mod = 1000000007
def power(x, y, p) :
res = 1
x = x % p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) :
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
n,m,k = [int(i) for i in input().split()]
parent = [int(i) for i in range(n)]
k-=1
prev = -1
for i in range(n):
j = i
while(j<=i+(k-1)//2):
#print(parent)
x = i+k-(j-i)
if (x>=n):
break
#print(j,x)
J = j
pa = parent[x]
pb = parent[j]
if (pa<pb):
x,j = j,x
pa = parent[x]
pb = parent[j]
#print("pa,pb",pa,pb)
while(parent[pa]!=pa):
pa = parent[pa]
while(parent[pb]!=pb):
pb = parent[pb]
if (pa!=pb):
parent[pa]=pb
j = J+1
cnt = 0
for i in range(n):
if parent[i]==i:
cnt+=1
#print(cnt,m)
print(power(m,cnt,mod))
# for i in range(n):
# if (i%k==0):
# prev = i
# for j in range(i+k,n,k):
# x = j
# #print("fuck",i,x)
# pa = parent[x]
# pb = parent[i]
# while(parent[pa]!=pa):
# pa = parent[pa]
# while(parent[pb]!=pb):
# pb = parent[pb]
# if (pa!=pb):
# parent[pa]=pb
# x = prev+k-i%k
# if (x>=n):
# break
# #print("fuck",i,x)
# pa = parent[x]
# pb = parent[i]
# while(parent[pa]!=pa):
# pa = parent[pa]
# while(parent[pb]!=pb):
# pb = parent[pb]
# if (pa!=pb):
# parent[pa]=pb
# #print(parent)
# #print(len(set(parent)))
``` | output | 1 | 25,006 | 0 | 50,013 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Just in case somebody missed it: this winter is totally cold in Nvodsk! It is so cold that one gets funny thoughts. For example, let's say there are strings with the length exactly n, based on the alphabet of size m. Any its substring with length equal to k is a palindrome. How many such strings exist? Your task is to find their quantity modulo 1000000007 (109 + 7). Be careful and don't miss a string or two!
Let us remind you that a string is a palindrome if it can be read the same way in either direction, from the left to the right and from the right to the left.
Input
The first and only line contains three integers: n, m and k (1 ≤ n, m, k ≤ 2000).
Output
Print a single integer — the number of strings of the described type modulo 1000000007 (109 + 7).
Examples
Input
1 1 1
Output
1
Input
5 2 4
Output
2
Note
In the first sample only one string is valid: "a" (let's denote the only letter of our alphabet as "a").
In the second sample (if we denote the alphabet letters as "a" and "b") the following strings are valid: "aaaaa" and "bbbbb". | instruction | 0 | 25,007 | 0 | 50,014 |
Tags: combinatorics, dfs and similar, graphs, math
Correct Solution:
```
mod = 1000000007
n,m,k = map(int,input().split())
if k==1 or n<k:
print(pow(m,n,mod))
elif k==n:
print(pow(m,(n+1)//2,mod))
elif k%2!=0:
print((m*m)%mod)
else:
print(m)
``` | output | 1 | 25,007 | 0 | 50,015 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Just in case somebody missed it: this winter is totally cold in Nvodsk! It is so cold that one gets funny thoughts. For example, let's say there are strings with the length exactly n, based on the alphabet of size m. Any its substring with length equal to k is a palindrome. How many such strings exist? Your task is to find their quantity modulo 1000000007 (109 + 7). Be careful and don't miss a string or two!
Let us remind you that a string is a palindrome if it can be read the same way in either direction, from the left to the right and from the right to the left.
Input
The first and only line contains three integers: n, m and k (1 ≤ n, m, k ≤ 2000).
Output
Print a single integer — the number of strings of the described type modulo 1000000007 (109 + 7).
Examples
Input
1 1 1
Output
1
Input
5 2 4
Output
2
Note
In the first sample only one string is valid: "a" (let's denote the only letter of our alphabet as "a").
In the second sample (if we denote the alphabet letters as "a" and "b") the following strings are valid: "aaaaa" and "bbbbb".
Submitted Solution:
```
n , m , k = map(int , input().split())
mod = 1000 * 1000 * 1000 + 7
cnt = 0
if k > n :
cnt = n
elif n == k :
cnt = (k + 1) // 2
elif k == 1 :
cnt = n
elif k % 2 == 1 :
cnt = 2
else :
cnt = 1
ans = 1
for i in range(cnt):
ans = (ans * m) % mod
print(ans)
``` | instruction | 0 | 25,008 | 0 | 50,016 |
Yes | output | 1 | 25,008 | 0 | 50,017 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Just in case somebody missed it: this winter is totally cold in Nvodsk! It is so cold that one gets funny thoughts. For example, let's say there are strings with the length exactly n, based on the alphabet of size m. Any its substring with length equal to k is a palindrome. How many such strings exist? Your task is to find their quantity modulo 1000000007 (109 + 7). Be careful and don't miss a string or two!
Let us remind you that a string is a palindrome if it can be read the same way in either direction, from the left to the right and from the right to the left.
Input
The first and only line contains three integers: n, m and k (1 ≤ n, m, k ≤ 2000).
Output
Print a single integer — the number of strings of the described type modulo 1000000007 (109 + 7).
Examples
Input
1 1 1
Output
1
Input
5 2 4
Output
2
Note
In the first sample only one string is valid: "a" (let's denote the only letter of our alphabet as "a").
In the second sample (if we denote the alphabet letters as "a" and "b") the following strings are valid: "aaaaa" and "bbbbb".
Submitted Solution:
```
n, m, k = [int(i) for i in input().split(" ")]
if k==1 or k>n:
print(pow(m,n,1000000007))
elif k==n:
print(pow(m, (n+1)//2, 1000000007))
elif k%2:
print(pow(m, 2, 1000000007))
else:
print(pow(m, 1, 1000000007))
``` | instruction | 0 | 25,009 | 0 | 50,018 |
Yes | output | 1 | 25,009 | 0 | 50,019 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Just in case somebody missed it: this winter is totally cold in Nvodsk! It is so cold that one gets funny thoughts. For example, let's say there are strings with the length exactly n, based on the alphabet of size m. Any its substring with length equal to k is a palindrome. How many such strings exist? Your task is to find their quantity modulo 1000000007 (109 + 7). Be careful and don't miss a string or two!
Let us remind you that a string is a palindrome if it can be read the same way in either direction, from the left to the right and from the right to the left.
Input
The first and only line contains three integers: n, m and k (1 ≤ n, m, k ≤ 2000).
Output
Print a single integer — the number of strings of the described type modulo 1000000007 (109 + 7).
Examples
Input
1 1 1
Output
1
Input
5 2 4
Output
2
Note
In the first sample only one string is valid: "a" (let's denote the only letter of our alphabet as "a").
In the second sample (if we denote the alphabet letters as "a" and "b") the following strings are valid: "aaaaa" and "bbbbb".
Submitted Solution:
```
import math
def pow(a,b,p):
res = 1
while(b > 0):
if b%2 == 1:
res = (res*a)%p
a = (a*a)%p
b = int(b/2)
return res
n,m,k = list(map(int,input().strip().split()))
p = 10 ** 9 + 7
if k > n or k == 1:
print(pow(m, n, p))
elif k == n:
print(pow(m, math.ceil(k/2), p))
elif n == 1:
print(m)
elif k % 2 == 0:
print(m)
else:
print(pow(m,2,p))
``` | instruction | 0 | 25,010 | 0 | 50,020 |
Yes | output | 1 | 25,010 | 0 | 50,021 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Just in case somebody missed it: this winter is totally cold in Nvodsk! It is so cold that one gets funny thoughts. For example, let's say there are strings with the length exactly n, based on the alphabet of size m. Any its substring with length equal to k is a palindrome. How many such strings exist? Your task is to find their quantity modulo 1000000007 (109 + 7). Be careful and don't miss a string or two!
Let us remind you that a string is a palindrome if it can be read the same way in either direction, from the left to the right and from the right to the left.
Input
The first and only line contains three integers: n, m and k (1 ≤ n, m, k ≤ 2000).
Output
Print a single integer — the number of strings of the described type modulo 1000000007 (109 + 7).
Examples
Input
1 1 1
Output
1
Input
5 2 4
Output
2
Note
In the first sample only one string is valid: "a" (let's denote the only letter of our alphabet as "a").
In the second sample (if we denote the alphabet letters as "a" and "b") the following strings are valid: "aaaaa" and "bbbbb".
Submitted Solution:
```
def solve():
mod = int(1e9+7)
n, m, k = map(int, input().split())
if k==1 or k>n:
print(pow(m, n, mod))
elif k==n:
print(pow(m, (n+1)//2, mod))
elif k%2==1:
print((m*m)%mod)
elif k%2==0:
print(m)
solve()
``` | instruction | 0 | 25,011 | 0 | 50,022 |
Yes | output | 1 | 25,011 | 0 | 50,023 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Just in case somebody missed it: this winter is totally cold in Nvodsk! It is so cold that one gets funny thoughts. For example, let's say there are strings with the length exactly n, based on the alphabet of size m. Any its substring with length equal to k is a palindrome. How many such strings exist? Your task is to find their quantity modulo 1000000007 (109 + 7). Be careful and don't miss a string or two!
Let us remind you that a string is a palindrome if it can be read the same way in either direction, from the left to the right and from the right to the left.
Input
The first and only line contains three integers: n, m and k (1 ≤ n, m, k ≤ 2000).
Output
Print a single integer — the number of strings of the described type modulo 1000000007 (109 + 7).
Examples
Input
1 1 1
Output
1
Input
5 2 4
Output
2
Note
In the first sample only one string is valid: "a" (let's denote the only letter of our alphabet as "a").
In the second sample (if we denote the alphabet letters as "a" and "b") the following strings are valid: "aaaaa" and "bbbbb".
Submitted Solution:
```
from os import path;import sys,time
mod = int(1e9 + 7)
from math import ceil, floor,gcd,log,log2 ,factorial,sqrt
from collections import defaultdict ,Counter , OrderedDict , deque;from itertools import combinations,permutations
# from string import ascii_lowercase ,ascii_uppercase
from bisect import *;from functools import reduce;from operator import mul;maxx = float('inf')
I = lambda :int(sys.stdin.buffer.readline())
lint = lambda :[int(x) for x in sys.stdin.buffer.readline().split()]
S = lambda: sys.stdin.readline().strip('\n')
grid = lambda r :[lint() for i in range(r)]
localsys = 0
start_time = time.time()
#left shift --- num*(2**k) --(k - shift)
nCr = lambda n, r: reduce(mul, range(n - r + 1, n + 1), 1) // factorial(r)
def ceill(n,x):
return (n+x -1 )//x
T =0
def solve():
n , m , k = lint()
if k > n or k < 2:
return print(n*m)
elif n == k :
return print(m * ((n+1)//2))
print(m*m) if k % 2 else print(m)
def run():
if (path.exists('input.txt')):
sys.stdin=open('input.txt','r')
sys.stdout=open('output.txt','w')
run()
T = I() if T else 1
for _ in range(T):
solve()
if localsys:
print("\n\nTime Elased :",time.time() - start_time,"seconds")
``` | instruction | 0 | 25,012 | 0 | 50,024 |
No | output | 1 | 25,012 | 0 | 50,025 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Just in case somebody missed it: this winter is totally cold in Nvodsk! It is so cold that one gets funny thoughts. For example, let's say there are strings with the length exactly n, based on the alphabet of size m. Any its substring with length equal to k is a palindrome. How many such strings exist? Your task is to find their quantity modulo 1000000007 (109 + 7). Be careful and don't miss a string or two!
Let us remind you that a string is a palindrome if it can be read the same way in either direction, from the left to the right and from the right to the left.
Input
The first and only line contains three integers: n, m and k (1 ≤ n, m, k ≤ 2000).
Output
Print a single integer — the number of strings of the described type modulo 1000000007 (109 + 7).
Examples
Input
1 1 1
Output
1
Input
5 2 4
Output
2
Note
In the first sample only one string is valid: "a" (let's denote the only letter of our alphabet as "a").
In the second sample (if we denote the alphabet letters as "a" and "b") the following strings are valid: "aaaaa" and "bbbbb".
Submitted Solution:
```
import sys,os,io
import math
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r") ; sys.stdout = open("output.txt","w")
else:
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
n,m,k = [int(i) for i in input().split()]
parent = [int(i) for i in range(n)]
k-=1
prev = -1
for i in range(n):
j = i
while(j<=i+(k-1)//2):
#print(parent)
x = i+k-(j-i)
if (x>=n):
break
#print(j,x)
J = j
pa = parent[x]
pb = parent[j]
if (pa<pb):
x,j = j,x
pa = parent[x]
pb = parent[j]
#print("pa,pb",pa,pb)
while(parent[pa]!=pa):
pa = parent[pa]
while(parent[pb]!=pb):
pb = parent[pb]
if (pa!=pb):
parent[pa]=pb
j = J+1
cnt = 0
for i in range(n):
if parent[i]==i:
cnt+=1
#print(cnt,m)
print(m**cnt)
# for i in range(n):
# if (i%k==0):
# prev = i
# for j in range(i+k,n,k):
# x = j
# #print("fuck",i,x)
# pa = parent[x]
# pb = parent[i]
# while(parent[pa]!=pa):
# pa = parent[pa]
# while(parent[pb]!=pb):
# pb = parent[pb]
# if (pa!=pb):
# parent[pa]=pb
# x = prev+k-i%k
# if (x>=n):
# break
# #print("fuck",i,x)
# pa = parent[x]
# pb = parent[i]
# while(parent[pa]!=pa):
# pa = parent[pa]
# while(parent[pb]!=pb):
# pb = parent[pb]
# if (pa!=pb):
# parent[pa]=pb
# #print(parent)
# #print(len(set(parent)))
``` | instruction | 0 | 25,013 | 0 | 50,026 |
No | output | 1 | 25,013 | 0 | 50,027 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Just in case somebody missed it: this winter is totally cold in Nvodsk! It is so cold that one gets funny thoughts. For example, let's say there are strings with the length exactly n, based on the alphabet of size m. Any its substring with length equal to k is a palindrome. How many such strings exist? Your task is to find their quantity modulo 1000000007 (109 + 7). Be careful and don't miss a string or two!
Let us remind you that a string is a palindrome if it can be read the same way in either direction, from the left to the right and from the right to the left.
Input
The first and only line contains three integers: n, m and k (1 ≤ n, m, k ≤ 2000).
Output
Print a single integer — the number of strings of the described type modulo 1000000007 (109 + 7).
Examples
Input
1 1 1
Output
1
Input
5 2 4
Output
2
Note
In the first sample only one string is valid: "a" (let's denote the only letter of our alphabet as "a").
In the second sample (if we denote the alphabet letters as "a" and "b") the following strings are valid: "aaaaa" and "bbbbb".
Submitted Solution:
```
n,m,k = map(int,input().split())
if n == k:
ans = int(m**((n+1)/2))
elif k == 1 or k > n:
ans = int(m**n)
elif k % 2 == 1:
ans = int(m**2)
else:
ans = int(m)
ans = ans % (10**9+7)
print(ans)
``` | instruction | 0 | 25,014 | 0 | 50,028 |
No | output | 1 | 25,014 | 0 | 50,029 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Just in case somebody missed it: this winter is totally cold in Nvodsk! It is so cold that one gets funny thoughts. For example, let's say there are strings with the length exactly n, based on the alphabet of size m. Any its substring with length equal to k is a palindrome. How many such strings exist? Your task is to find their quantity modulo 1000000007 (109 + 7). Be careful and don't miss a string or two!
Let us remind you that a string is a palindrome if it can be read the same way in either direction, from the left to the right and from the right to the left.
Input
The first and only line contains three integers: n, m and k (1 ≤ n, m, k ≤ 2000).
Output
Print a single integer — the number of strings of the described type modulo 1000000007 (109 + 7).
Examples
Input
1 1 1
Output
1
Input
5 2 4
Output
2
Note
In the first sample only one string is valid: "a" (let's denote the only letter of our alphabet as "a").
In the second sample (if we denote the alphabet letters as "a" and "b") the following strings are valid: "aaaaa" and "bbbbb".
Submitted Solution:
```
n,m,k=map(int,input().split())
mod=10**9+7
if n==k:
x=n//2
print(pow(m,x,mod))
else:
if k%2==1:
ans=0
ans+=m
ans+=m*(m-1)
print(ans%mod)
else:
print(m)
``` | instruction | 0 | 25,015 | 0 | 50,030 |
No | output | 1 | 25,015 | 0 | 50,031 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Suppose you are given two strings a and b. You can apply the following operation any number of times: choose any contiguous substring of a or b, and sort the characters in it in non-descending order. Let f(a, b) the minimum number of operations you have to apply in order to make them equal (or f(a, b) = 1337 if it is impossible to make a and b equal using these operations).
For example:
* f(ab, ab) = 0;
* f(ba, ab) = 1 (in one operation, we can sort the whole first string);
* f(ebcda, ecdba) = 1 (in one operation, we can sort the substring of the second string starting from the 2-nd character and ending with the 4-th character);
* f(a, b) = 1337.
You are given n strings s_1, s_2, ..., s_k having equal length. Calculate ∑ _{i = 1}^{n} ∑_{j = i + 1}^{n} f(s_i, s_j).
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of strings.
Then n lines follow, each line contains one of the strings s_i, consisting of lowercase Latin letters. |s_1| = |s_2| = … = |s_n|, and n ⋅ |s_1| ≤ 2 ⋅ 10^5. All these strings are pairwise distinct.
Output
Print one integer: ∑ _{i = 1}^{n} ∑_{j = i + 1}^{n} f(s_i, s_j).
Examples
Input
4
zzz
bac
abc
acb
Output
4015
Input
2
a
b
Output
1337
Submitted Solution:
```
def check(s1, s2):
ref = {}
if len(s1)!=len(s2):
return False
for char in s1:
ref[char] = ref.get(char, 0) + 1
for char in s2:
if char not in ref:
return False
ref[char]-=1
for key in ref:
if ref[key] !=0:
return False
return True
def give_temp(s1, s2):
start, end = None, None
for i in range(len(s1)):
if s1[i]!=s2[i]:
if start is None:
start = i
elif end is not None:
return float('inf')
elif s1[i]==s2[i] and start is not None and end is None:
end = i
if end is None:
end = len(s1)
s1 = s1[start:end]
s2 = s2[start:end]
if sorted(s1)==list(s1) or sorted(s2)==list(s2):
return 1
return float('inf')
num_test = int(input())
cases = []
for i in range(num_test):
cases.append(input())
ans = 0
for i in range(num_test-1):
for j in range(i+1, num_test):
s1, s2 = cases[i], cases[j]
if s1==s2:
ans+=0
elif check(s1, s2):
temp = give_temp(s1,s2)
ans+=min(2, temp)
else:
ans+=1337
print(ans)
``` | instruction | 0 | 25,016 | 0 | 50,032 |
No | output | 1 | 25,016 | 0 | 50,033 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Suppose you are given two strings a and b. You can apply the following operation any number of times: choose any contiguous substring of a or b, and sort the characters in it in non-descending order. Let f(a, b) the minimum number of operations you have to apply in order to make them equal (or f(a, b) = 1337 if it is impossible to make a and b equal using these operations).
For example:
* f(ab, ab) = 0;
* f(ba, ab) = 1 (in one operation, we can sort the whole first string);
* f(ebcda, ecdba) = 1 (in one operation, we can sort the substring of the second string starting from the 2-nd character and ending with the 4-th character);
* f(a, b) = 1337.
You are given n strings s_1, s_2, ..., s_k having equal length. Calculate ∑ _{i = 1}^{n} ∑_{j = i + 1}^{n} f(s_i, s_j).
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of strings.
Then n lines follow, each line contains one of the strings s_i, consisting of lowercase Latin letters. |s_1| = |s_2| = … = |s_n|, and n ⋅ |s_1| ≤ 2 ⋅ 10^5. All these strings are pairwise distinct.
Output
Print one integer: ∑ _{i = 1}^{n} ∑_{j = i + 1}^{n} f(s_i, s_j).
Examples
Input
4
zzz
bac
abc
acb
Output
4015
Input
2
a
b
Output
1337
Submitted Solution:
```
MAX = 500001
parent = [0] * MAX
Rank = [0] * MAX
# Function to find out
# parent of an alphabet
def find(x):
if parent[x] == x:
return x
else:
return find(parent[x])
# Function to merge two
# different alphabets
def merge(r1, r2):
# Merge a and b using
# rank compression
if (r1 != r2):
if (Rank[r1] > Rank[r2]):
parent[r2] = r1
Rank[r1] += Rank[r2]
else:
parent[r1] = r2
Rank[r2] += Rank[r1]
# Function to find the minimum
# number of operations required
def minimumOperations(s1, s2):
# Initializing parent to i
# and rank(size) to 1
for i in range(1, 26 + 1):
parent[i] = i
Rank[i] = 1
# We will store our
# answerin this list
ans = []
# Traversing strings
for i in range(len(s1)):
if (s1[i] != s2[i]):
# If they have different parents
if (find(ord(s1[i]) - 96) !=
find(ord(s2[i]) - 96)):
# Find their respective
# parents and merge them
x = find(ord(s1[i]) - 96)
y = find(ord(s2[i]) - 96)
merge(x, y)
# Store this in
# our Answer list
ans.append([s1[i], s2[i]])
return len(ans)
def character_difference(s1, s2):
for i in range(len(s1)):
if s2.count(s1[i]) != s1.count(s1[i]):
return True
return False
# Driver code
def main():
t = int(input()) # number of strings
L = []
for i in range(t):
L.append(input())
sum = 0
var = t * len(L[0])
var2 = 2 * 100000
var = var <= var2
Bigger_value = t <= var2
Smaller_value = t >= 1
if var and Bigger_value and Smaller_value:
for i in range(t):
for j in range(i+1,t):
if character_difference(L[i], L[j]):
sum += 1337
else:
sum += minimumOperations(L[i], L[j])
print(sum)
main()
``` | instruction | 0 | 25,017 | 0 | 50,034 |
No | output | 1 | 25,017 | 0 | 50,035 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Suppose you are given two strings a and b. You can apply the following operation any number of times: choose any contiguous substring of a or b, and sort the characters in it in non-descending order. Let f(a, b) the minimum number of operations you have to apply in order to make them equal (or f(a, b) = 1337 if it is impossible to make a and b equal using these operations).
For example:
* f(ab, ab) = 0;
* f(ba, ab) = 1 (in one operation, we can sort the whole first string);
* f(ebcda, ecdba) = 1 (in one operation, we can sort the substring of the second string starting from the 2-nd character and ending with the 4-th character);
* f(a, b) = 1337.
You are given n strings s_1, s_2, ..., s_k having equal length. Calculate ∑ _{i = 1}^{n} ∑_{j = i + 1}^{n} f(s_i, s_j).
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of strings.
Then n lines follow, each line contains one of the strings s_i, consisting of lowercase Latin letters. |s_1| = |s_2| = … = |s_n|, and n ⋅ |s_1| ≤ 2 ⋅ 10^5. All these strings are pairwise distinct.
Output
Print one integer: ∑ _{i = 1}^{n} ∑_{j = i + 1}^{n} f(s_i, s_j).
Examples
Input
4
zzz
bac
abc
acb
Output
4015
Input
2
a
b
Output
1337
Submitted Solution:
```
MAX = 2 * (10 ** 5) + 1
parent = [0] * MAX
Rank = [0] * MAX
# Function to find out
# parent of an alphabet
def find(x):
if parent[x] == x:
return x
else:
return find(parent[x])
# Function to merge two
# different alphabets
def merge(r1, r2):
# Merge a and b using
# rank compression
if (r1 != r2):
if (Rank[r1] > Rank[r2]):
parent[r2] = r1
Rank[r1] += Rank[r2]
else:
parent[r1] = r2
Rank[r2] += Rank[r1]
# Function to find the minimum
# number of operations required
def minimumOperations(s1, s2):
# Initializing parent to i
# and rank(size) to 1
for i in range(1, 26 + 1):
parent[i] = i
Rank[i] = 1
# We will store our
# answerin this list
ans = []
# Traversing strings
for i in range(len(s1)):
if (s1[i] != s2[i]):
# If they have different parents
if (find(ord(s1[i]) - 96) !=
find(ord(s2[i]) - 96)):
# Find their respective
# parents and merge them
x = find(ord(s1[i]) - 96)
y = find(ord(s2[i]) - 96)
merge(x, y)
# Store this in
# our Answer list
ans.append([s1[i], s2[i]])
return len(ans)
def character_difference(s1, s2):
for i in range(len(s1)):
if s2.count(s1[i]) == 0:
return True
return False
# Driver code
def main():
t = int(input()) # number of strings
L = []
for i in range(t):
L.append(input())
sum = 0
var = t * len(L[0])
var2 = 2 * 100000
var = var <= var2
Bigger_value = t <= var2
Smaller_value = t >= 1
if var and Bigger_value and Smaller_value:
for i in range(t):
for j in range(i+1,t):
if character_difference(L[i], L[j]):
sum += 1337
else:
sum += minimumOperations(L[i], L[j])
print(sum)
main()
``` | instruction | 0 | 25,018 | 0 | 50,036 |
No | output | 1 | 25,018 | 0 | 50,037 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Suppose you are given two strings a and b. You can apply the following operation any number of times: choose any contiguous substring of a or b, and sort the characters in it in non-descending order. Let f(a, b) the minimum number of operations you have to apply in order to make them equal (or f(a, b) = 1337 if it is impossible to make a and b equal using these operations).
For example:
* f(ab, ab) = 0;
* f(ba, ab) = 1 (in one operation, we can sort the whole first string);
* f(ebcda, ecdba) = 1 (in one operation, we can sort the substring of the second string starting from the 2-nd character and ending with the 4-th character);
* f(a, b) = 1337.
You are given n strings s_1, s_2, ..., s_k having equal length. Calculate ∑ _{i = 1}^{n} ∑_{j = i + 1}^{n} f(s_i, s_j).
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of strings.
Then n lines follow, each line contains one of the strings s_i, consisting of lowercase Latin letters. |s_1| = |s_2| = … = |s_n|, and n ⋅ |s_1| ≤ 2 ⋅ 10^5. All these strings are pairwise distinct.
Output
Print one integer: ∑ _{i = 1}^{n} ∑_{j = i + 1}^{n} f(s_i, s_j).
Examples
Input
4
zzz
bac
abc
acb
Output
4015
Input
2
a
b
Output
1337
Submitted Solution:
```
MAX = 500001
parent = [0] * MAX
Rank = [0] * MAX
# Function to find out
# parent of an alphabet
def find(x):
if parent[x] == x:
return x
else:
return find(parent[x])
# Function to merge two
# different alphabets
def merge(r1, r2):
# Merge a and b using
# rank compression
if (r1 != r2):
if (Rank[r1] > Rank[r2]):
parent[r2] = r1
Rank[r1] += Rank[r2]
else:
parent[r1] = r2
Rank[r2] += Rank[r1]
# Function to find the minimum
# number of operations required
def minimumOperations(s1, s2):
# Initializing parent to i
# and rank(size) to 1
for i in range(1, 26 + 1):
parent[i] = i
Rank[i] = 1
# We will store our
# answerin this list
ans = []
# Traversing strings
for i in range(len(s1)):
if (s1[i] != s2[i]):
# If they have different parents
if (find(ord(s1[i]) - 96) !=
find(ord(s2[i]) - 96)):
# Find their respective
# parents and merge them
x = find(ord(s1[i]) - 96)
y = find(ord(s2[i]) - 96)
merge(x, y)
# Store this in
# our Answer list
ans.append([s1[i], s2[i]])
return len(ans)
def character_difference(s1, s2):
for i in range(len(s1)):
if s2.count(s1[i]) == 0:
return True
return False
# Driver code
def main():
t = int(input()) # number of strings
L = []
for i in range(t):
L.append(input())
sum = 0
for i in range(t):
for j in range(i+1,t):
if character_difference(L[i], L[j]):
sum += 1337
else:
sum += minimumOperations(L[i], L[j])
print(sum)
main()
``` | instruction | 0 | 25,019 | 0 | 50,038 |
No | output | 1 | 25,019 | 0 | 50,039 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bear Limak prepares problems for a programming competition. Of course, it would be unprofessional to mention the sponsor name in the statement. Limak takes it seriously and he is going to change some words. To make it still possible to read, he will try to modify each word as little as possible.
Limak has a string s that consists of uppercase English letters. In one move he can swap two adjacent letters of the string. For example, he can transform a string "ABBC" into "BABC" or "ABCB" in one move.
Limak wants to obtain a string without a substring "VK" (i.e. there should be no letter 'V' immediately followed by letter 'K'). It can be easily proved that it's possible for any initial string s.
What is the minimum possible number of moves Limak can do?
Input
The first line of the input contains an integer n (1 ≤ n ≤ 75) — the length of the string.
The second line contains a string s, consisting of uppercase English letters. The length of the string is equal to n.
Output
Print one integer, denoting the minimum possible number of moves Limak can do, in order to obtain a string without a substring "VK".
Examples
Input
4
VKVK
Output
3
Input
5
BVVKV
Output
2
Input
7
VVKEVKK
Output
3
Input
20
VKVKVVVKVOVKVQKKKVVK
Output
8
Input
5
LIMAK
Output
0
Note
In the first sample, the initial string is "VKVK". The minimum possible number of moves is 3. One optimal sequence of moves is:
1. Swap two last letters. The string becomes "VKKV".
2. Swap first two letters. The string becomes "KVKV".
3. Swap the second and the third letter. The string becomes "KKVV". Indeed, this string doesn't have a substring "VK".
In the second sample, there are two optimal sequences of moves. One is "BVVKV" → "VBVKV" → "VVBKV". The other is "BVVKV" → "BVKVV" → "BKVVV".
In the fifth sample, no swaps are necessary. | instruction | 0 | 25,256 | 0 | 50,512 |
Tags: dp
Correct Solution:
```
# http://codeforces.com/contest/771/problem/D
"""
DP-solution.
For each state (v, k, x, v_is_last_letter) we trial a step along the v, k and x
axes and check that
dp[future_state] = min(dp[future_state], dp[state] + cost_of_move)
Hence this implicitly reults in the one with least cost.
V, K, X are arrays that contain the number of occurences of v, k, x at the i'th
index of s.
"""
def cost_of_move(state, ss_ind):
"""
eg. ss = s[0:K.index(k+1)]
Note: ss includes the i+1'th occurence of letter I. We hence want
ss = s[0:ss_ind-1]
And then we cound the number of occurences of V, K, X in this substring.
However, we don't need ss now - this info is contained in lists V, K, X.
"""
curr_v, curr_k, curr_x = state
cost = sum([max(0, V[ss_ind-1] - curr_v), max(0, K[ss_ind-1] - curr_k),
max(0, X[ss_ind-1] - curr_x)])
return cost
if __name__ == "__main__":
n = int(input())
s = input()
V = [s[0:i].count('V') for i in range(n+1)]
K = [s[0:i].count('K') for i in range(n+1)]
X = [(i - V[i] - K[i]) for i in range(n+1)]
# Initialising
n_v, n_k, n_x = V[n], K[n], X[n]
dp = [[[[float('Inf') for vtype in range(2)] for x in range(n_x+1)]
for k in range(n_k+1)] for v in range(n_v+1)]
dp[0][0][0][0] = 0
for v in range(n_v + 1):
for k in range(n_k + 1):
for x in range(n_x + 1):
for vtype in range(2):
orig = dp[v][k][x][vtype]
if v < n_v:
dp[v+1][k][x][1] = min(dp[v+1][k][x][vtype],
orig + cost_of_move([v, k, x], V.index(v+1)))
if k < n_k and vtype == 0:
dp[v][k+1][x][0] = min(dp[v][k+1][x][0],
orig + cost_of_move([v, k, x], K.index(k+1)))
if x < n_x:
dp[v][k][x+1][0] = min(dp[v][k][x+1][0],
orig + cost_of_move([v, k, x], X.index(x+1)))
print(min(dp[n_v][n_k][n_x]))
``` | output | 1 | 25,256 | 0 | 50,513 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given a string s, find the number of ways to split s to substrings such that if there are k substrings (p1, p2, p3, ..., pk) in partition, then pi = pk - i + 1 for all i (1 ≤ i ≤ k) and k is even.
Since the number of ways can be large, print it modulo 109 + 7.
Input
The only line of input contains a string s (2 ≤ |s| ≤ 106) of even length consisting of lowercase Latin letters.
Output
Print one integer, the number of ways of partitioning the string modulo 109 + 7.
Examples
Input
abcdcdab
Output
1
Input
abbababababbab
Output
3
Note
In the first case, the only way to partition the string is ab|cd|cd|ab.
In the second case, the string can be partitioned as ab|b|ab|ab|ab|ab|b|ab or ab|b|abab|abab|b|ab or abbab|ab|ab|abbab.
Submitted Solution:
```
s = str(input())
if (len(s)/2)%2 == 0:
print(len(s)/2)
else:
print((len(s)/2)/2)
``` | instruction | 0 | 25,298 | 0 | 50,596 |
No | output | 1 | 25,298 | 0 | 50,597 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given a string s, find the number of ways to split s to substrings such that if there are k substrings (p1, p2, p3, ..., pk) in partition, then pi = pk - i + 1 for all i (1 ≤ i ≤ k) and k is even.
Since the number of ways can be large, print it modulo 109 + 7.
Input
The only line of input contains a string s (2 ≤ |s| ≤ 106) of even length consisting of lowercase Latin letters.
Output
Print one integer, the number of ways of partitioning the string modulo 109 + 7.
Examples
Input
abcdcdab
Output
1
Input
abbababababbab
Output
3
Note
In the first case, the only way to partition the string is ab|cd|cd|ab.
In the second case, the string can be partitioned as ab|b|ab|ab|ab|ab|b|ab or ab|b|abab|abab|b|ab or abbab|ab|ab|abbab.
Submitted Solution:
```
s = input()
if (len(s)/2)%2 == 0:
print(len(s)/2)
else:
print(round(len(s)/2/2))
``` | instruction | 0 | 25,299 | 0 | 50,598 |
No | output | 1 | 25,299 | 0 | 50,599 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given a string s, find the number of ways to split s to substrings such that if there are k substrings (p1, p2, p3, ..., pk) in partition, then pi = pk - i + 1 for all i (1 ≤ i ≤ k) and k is even.
Since the number of ways can be large, print it modulo 109 + 7.
Input
The only line of input contains a string s (2 ≤ |s| ≤ 106) of even length consisting of lowercase Latin letters.
Output
Print one integer, the number of ways of partitioning the string modulo 109 + 7.
Examples
Input
abcdcdab
Output
1
Input
abbababababbab
Output
3
Note
In the first case, the only way to partition the string is ab|cd|cd|ab.
In the second case, the string can be partitioned as ab|b|ab|ab|ab|ab|b|ab or ab|b|abab|abab|b|ab or abbab|ab|ab|abbab.
Submitted Solution:
```
s = str(input())
if (len(s)/2)%2 == 0:
print(len(s)/2)
else:
print(int(round(len(s)/2/2)))
``` | instruction | 0 | 25,300 | 0 | 50,600 |
No | output | 1 | 25,300 | 0 | 50,601 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given a string s, find the number of ways to split s to substrings such that if there are k substrings (p1, p2, p3, ..., pk) in partition, then pi = pk - i + 1 for all i (1 ≤ i ≤ k) and k is even.
Since the number of ways can be large, print it modulo 109 + 7.
Input
The only line of input contains a string s (2 ≤ |s| ≤ 106) of even length consisting of lowercase Latin letters.
Output
Print one integer, the number of ways of partitioning the string modulo 109 + 7.
Examples
Input
abcdcdab
Output
1
Input
abbababababbab
Output
3
Note
In the first case, the only way to partition the string is ab|cd|cd|ab.
In the second case, the string can be partitioned as ab|b|ab|ab|ab|ab|b|ab or ab|b|abab|abab|b|ab or abbab|ab|ab|abbab.
Submitted Solution:
```
s = str(input())
if (len(s)/2)%2 == 0:
print(int(len(s)/2))
else:
print(int(round(len(s)/2/2)))
``` | instruction | 0 | 25,301 | 0 | 50,602 |
No | output | 1 | 25,301 | 0 | 50,603 |
Provide a correct Python 3 solution for this coding contest problem.
For a string S, let f(S) be the lexicographically smallest cyclic shift of S. For example, if S = `babca`, f(S) = `ababc` because this is the smallest among all cyclic shifts (`babca`, `abcab`, `bcaba`, `cabab`, `ababc`).
You are given three integers X, Y, and Z. You want to construct a string T that consists of exactly X `a`s, exactly Y `b`s, and exactly Z `c`s. If there are multiple such strings, you want to choose one that maximizes f(T) lexicographically.
Compute the lexicographically largest possible value of f(T).
Constraints
* 1 \leq X + Y + Z \leq 50
* X, Y, Z are non-negative integers.
Input
Input is given from Standard Input in the following format:
X Y Z
Output
Print the answer.
Examples
Input
2 2 0
Output
abab
Input
1 1 1
Output
acb | instruction | 0 | 25,433 | 0 | 50,866 |
"Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**15
mod = 10**9+7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def main():
x,y,z = LI()
a = ['a' for _ in range(x)] + ['b' for _ in range(y)] + ['c' for _ in range(z)]
while len(a) > 1:
a.sort()
a[0] += a[-1]
a = a[:-1]
return a[0]
print(main())
``` | output | 1 | 25,433 | 0 | 50,867 |
Provide a correct Python 3 solution for this coding contest problem.
For a string S, let f(S) be the lexicographically smallest cyclic shift of S. For example, if S = `babca`, f(S) = `ababc` because this is the smallest among all cyclic shifts (`babca`, `abcab`, `bcaba`, `cabab`, `ababc`).
You are given three integers X, Y, and Z. You want to construct a string T that consists of exactly X `a`s, exactly Y `b`s, and exactly Z `c`s. If there are multiple such strings, you want to choose one that maximizes f(T) lexicographically.
Compute the lexicographically largest possible value of f(T).
Constraints
* 1 \leq X + Y + Z \leq 50
* X, Y, Z are non-negative integers.
Input
Input is given from Standard Input in the following format:
X Y Z
Output
Print the answer.
Examples
Input
2 2 0
Output
abab
Input
1 1 1
Output
acb | instruction | 0 | 25,434 | 0 | 50,868 |
"Correct Solution:
```
a,b,c = map(int,input().split())
L = [[0] for _ in range(a)] + [[1] for _ in range(b)] + [[2] for _ in range(c)]
while len(L) > 1:
L[0] += L.pop()
L.sort()
print(''.join(('a','b','c')[i] for i in L[0]))
``` | output | 1 | 25,434 | 0 | 50,869 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a string S, let f(S) be the lexicographically smallest cyclic shift of S. For example, if S = `babca`, f(S) = `ababc` because this is the smallest among all cyclic shifts (`babca`, `abcab`, `bcaba`, `cabab`, `ababc`).
You are given three integers X, Y, and Z. You want to construct a string T that consists of exactly X `a`s, exactly Y `b`s, and exactly Z `c`s. If there are multiple such strings, you want to choose one that maximizes f(T) lexicographically.
Compute the lexicographically largest possible value of f(T).
Constraints
* 1 \leq X + Y + Z \leq 50
* X, Y, Z are non-negative integers.
Input
Input is given from Standard Input in the following format:
X Y Z
Output
Print the answer.
Examples
Input
2 2 0
Output
abab
Input
1 1 1
Output
acb
Submitted Solution:
```
from itertools import permutations,count,chain
from collections import deque
def helper(s):
for i in range(len(s)):
yield s[i:]+s[:i]
def naive(a,b,c):
return max(min(helper(s)) for s in permutations('a'*a+'b'*b+'c'*c))
def solve(a,b,c):
def helper(a,b,c):
cnt = (a,b,c).count(0)
if cnt == 3:
return []
elif cnt == 2:
n,i = max((x,i) for i,x in enumerate((a,b,c)))
return [i]*n
elif cnt == 1:
(l,nl),(u,nu) = ((i,x) for i,x in enumerate((a,b,c)) if x != 0)
n = nl//nu
return tuple(reversed(([u]+[l]*n)*nu + [l]*(nl-n*nu)))
n0 = c%a
n1 = a - n0
m0 = b%n1
m1 = n1-m0
R = helper(m1,m0,n0)
nc = c//a
nb = b//n1
s = ([0] + [2]*nc + [1]*nb, [0] + [2]*nc + [1]*(nb+1), [0] + [2]*(nc+1))
return tuple(chain.from_iterable(s[r] for r in R))
s = ('a','b','c')
return ''.join(s[i] for i in helper(a,b,c))
print(solve(*map(int,input().split())))
``` | instruction | 0 | 25,435 | 0 | 50,870 |
No | output | 1 | 25,435 | 0 | 50,871 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a string S, let f(S) be the lexicographically smallest cyclic shift of S. For example, if S = `babca`, f(S) = `ababc` because this is the smallest among all cyclic shifts (`babca`, `abcab`, `bcaba`, `cabab`, `ababc`).
You are given three integers X, Y, and Z. You want to construct a string T that consists of exactly X `a`s, exactly Y `b`s, and exactly Z `c`s. If there are multiple such strings, you want to choose one that maximizes f(T) lexicographically.
Compute the lexicographically largest possible value of f(T).
Constraints
* 1 \leq X + Y + Z \leq 50
* X, Y, Z are non-negative integers.
Input
Input is given from Standard Input in the following format:
X Y Z
Output
Print the answer.
Examples
Input
2 2 0
Output
abab
Input
1 1 1
Output
acb
Submitted Solution:
```
X, Y, Z = map(int, input().split())
d = []
if X > 0:
if (Y+Z) > 0:
j = max(X//(Y+Z), 1)
else:
j = 1
for _ in range(X//j):
d.append("a"*j)
for i in range(X-j*(X//j)):
d[i] = d[i] + "a"
for i in range(len(d)):
d[i] = d[i] + "c"*(Z//X)
for i in range(Z-(Z//X)*X):
d[len(d)-i-1] = d[len(d)-i-1] + "c"
for i in range(len(d)):
d[i] = d[i] + "b"*(Y//X)
for i in range(Y-(Y//X)*X):
d[len(d)-i-1] = d[len(d)-i-1] + "b"
elif Y > 0:
if (Z) > 0:
j = max(Y//Z, 1)
else:
j = 1
for _ in range(Y//j):
d.append("b"*j)
for i in range(Y-j*(Y//j)):
d[i] = d[i] + "b"
for i in range(len(d)):
d[i] = d[i] + "c"*(Z//Y)
for i in range(Z-(Z//Y)*Y):
d[len(d)-i-1] = d[len(d)-i-1] + "c"
else:
for _ in range(Z):
d.append("c")
print("".join(d))
``` | instruction | 0 | 25,436 | 0 | 50,872 |
No | output | 1 | 25,436 | 0 | 50,873 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a string S, let f(S) be the lexicographically smallest cyclic shift of S. For example, if S = `babca`, f(S) = `ababc` because this is the smallest among all cyclic shifts (`babca`, `abcab`, `bcaba`, `cabab`, `ababc`).
You are given three integers X, Y, and Z. You want to construct a string T that consists of exactly X `a`s, exactly Y `b`s, and exactly Z `c`s. If there are multiple such strings, you want to choose one that maximizes f(T) lexicographically.
Compute the lexicographically largest possible value of f(T).
Constraints
* 1 \leq X + Y + Z \leq 50
* X, Y, Z are non-negative integers.
Input
Input is given from Standard Input in the following format:
X Y Z
Output
Print the answer.
Examples
Input
2 2 0
Output
abab
Input
1 1 1
Output
acb
Submitted Solution:
```
from itertools import permutations
def shift(seq):
res = []
for _ in range(len(seq)):
res.append(seq)
seq = seq[1:]+seq[0]
return min(res)
N = [int(i) for i in input().split(" ")]
seq = "a"*N[0] + "b"*N[1] + "c"*N[2]
print(max([shift("".join(i)) for i in set([s for s in permutations(seq)])]))
``` | instruction | 0 | 25,437 | 0 | 50,874 |
No | output | 1 | 25,437 | 0 | 50,875 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a string S, let f(S) be the lexicographically smallest cyclic shift of S. For example, if S = `babca`, f(S) = `ababc` because this is the smallest among all cyclic shifts (`babca`, `abcab`, `bcaba`, `cabab`, `ababc`).
You are given three integers X, Y, and Z. You want to construct a string T that consists of exactly X `a`s, exactly Y `b`s, and exactly Z `c`s. If there are multiple such strings, you want to choose one that maximizes f(T) lexicographically.
Compute the lexicographically largest possible value of f(T).
Constraints
* 1 \leq X + Y + Z \leq 50
* X, Y, Z are non-negative integers.
Input
Input is given from Standard Input in the following format:
X Y Z
Output
Print the answer.
Examples
Input
2 2 0
Output
abab
Input
1 1 1
Output
acb
Submitted Solution:
```
X, Y, Z = map(int, input().split())
d = []
if X > 0:
for _ in range(X):
d.append("a")
for i in range(len(d)):
d[i] = d[i] + "c"*(Z//X)
for i in range(Z-(Z//X)*X):
d[len(d)-i-1] = d[len(d)-i-1] + "c"
for i in range(len(d)):
d[i] = d[i] + "b"*(Y//X)
for i in range(Y-(Y//X)*X):
d[len(d)-i-1] = d[len(d)-i-1] + "b"
elif Y > 0:
for _ in range(Y):
d.append("b")
for i in range(len(d)):
d[i] = d[i] + "c"*(Z//Y)
for i in range(Z-(Z//Y)*Y):
d[len(d)-i-1] = d[len(d)-i-1] + "c"
else:
for _ in range(Z):
d.append("c")
print("".join(d))
``` | instruction | 0 | 25,438 | 0 | 50,876 |
No | output | 1 | 25,438 | 0 | 50,877 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a set of strings S. Each string consists of lowercase Latin letters.
For each string in this set, you want to calculate the minimum number of seconds required to type this string. To type a string, you have to start with an empty string and transform it into the string you want to type using the following actions:
* if the current string is t, choose some lowercase Latin letter c and append it to the back of t, so the current string becomes t + c. This action takes 1 second;
* use autocompletion. When you try to autocomplete the current string t, a list of all strings s ∈ S such that t is a prefix of s is shown to you. This list includes t itself, if t is a string from S, and the strings are ordered lexicographically. You can transform t into the i-th string from this list in i seconds. Note that you may choose any string from this list you want, it is not necessarily the string you are trying to type.
What is the minimum number of seconds that you have to spend to type each string from S?
Note that the strings from S are given in an unusual way.
Input
The first line contains one integer n (1 ≤ n ≤ 10^6).
Then n lines follow, the i-th line contains one integer p_i (0 ≤ p_i < i) and one lowercase Latin character c_i. These lines form some set of strings such that S is its subset as follows: there are n + 1 strings, numbered from 0 to n; the 0-th string is an empty string, and the i-th string (i ≥ 1) is the result of appending the character c_i to the string p_i. It is guaranteed that all these strings are distinct.
The next line contains one integer k (1 ≤ k ≤ n) — the number of strings in S.
The last line contains k integers a_1, a_2, ..., a_k (1 ≤ a_i ≤ n, all a_i are pairwise distinct) denoting the indices of the strings generated by above-mentioned process that form the set S — formally, if we denote the i-th generated string as s_i, then S = {s_{a_1}, s_{a_2}, ..., s_{a_k}}.
Output
Print k integers, the i-th of them should be equal to the minimum number of seconds required to type the string s_{a_i}.
Examples
Input
10
0 i
1 q
2 g
0 k
1 e
5 r
4 m
5 h
3 p
3 e
5
8 9 1 10 6
Output
2 4 1 3 3
Input
8
0 a
1 b
2 a
2 b
4 a
4 b
5 c
6 d
5
2 3 4 7 8
Output
1 2 2 4 4
Note
In the first example, S consists of the following strings: ieh, iqgp, i, iqge, ier. | instruction | 0 | 25,723 | 0 | 51,446 |
Tags: data structures, dfs and similar, dp
Correct Solution:
```
import io
import os
DEBUG = False
def dfs(trie, root, preorder=None, postorder=None):
stack = [root]
seen = set()
while stack:
nodeId = stack.pop()
if nodeId not in seen:
if preorder:
preorder(nodeId)
stack.append(nodeId)
seen.add(nodeId)
for c, childId in reversed(trie[nodeId]):
stack.append(childId)
else:
if postorder:
postorder(nodeId)
def solve(N, PC, K, A):
ROOT = 0
trie = {ROOT: []} # nodeId to list of (character, nodeId)
parent = {}
for i, (p, c) in enumerate(PC, 1): # i starts from 1
trie[p].append((c, i))
assert i not in trie
trie[i] = []
parent[i] = p
terminal = set(A)
# Sort children of each node by character
for children in trie.values():
children.sort()
# DFS
offset = 0
ancestor = []
dist = {}
def getDistPre(nodeId):
nonlocal offset
best = None
if nodeId != 0:
assert nodeId in parent
best = 1 + dist[parent[nodeId]]
if nodeId in terminal:
best = min(best, ancestor[-1] + offset + 1)
ancestor.append(min(ancestor[-1], best - offset))
if nodeId in terminal:
offset += 1
else:
# Is root
best = 0
ancestor.append(0)
dist[nodeId] = best
def getDistPost(nodeId):
ancestor.pop()
dfs(trie, ROOT, preorder=getDistPre, postorder=getDistPost)
if DEBUG:
def printNode(nodeId, word):
return (
str(nodeId)
+ "\t"
+ word
+ ("$" if nodeId in terminal else "")
+ "\t"
+ "dist: "
+ str(dist[nodeId])
)
return str(nodeId) + "\t" + word + ("$" if nodeId in terminal else "")
def printGraph(nodeId, path):
W = 8
depth = len(path)
for ch, childId in trie[nodeId]:
path.append(ch)
print(
(
" " * (W * depth)
+ "└"
+ ch.center(W - 1, "─")
+ str(childId)
+ ("$" if childId in terminal else "")
).ljust(50)
+ printNode(childId, "".join(path))
)
printGraph(childId, path)
path.pop()
printGraph(ROOT, [])
out = []
for a in A:
out.append(str(dist[a]))
return " ".join(out)
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
N, = list(map(int, input().split()))
PC = []
for i in range(N):
p, c = input().decode().split()
PC.append((int(p), str(c)))
K, = list(map(int, input().split()))
A = list(map(int, input().split()))
ans = solve(N, PC, K, A)
print(ans)
``` | output | 1 | 25,723 | 0 | 51,447 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a set of strings S. Each string consists of lowercase Latin letters.
For each string in this set, you want to calculate the minimum number of seconds required to type this string. To type a string, you have to start with an empty string and transform it into the string you want to type using the following actions:
* if the current string is t, choose some lowercase Latin letter c and append it to the back of t, so the current string becomes t + c. This action takes 1 second;
* use autocompletion. When you try to autocomplete the current string t, a list of all strings s ∈ S such that t is a prefix of s is shown to you. This list includes t itself, if t is a string from S, and the strings are ordered lexicographically. You can transform t into the i-th string from this list in i seconds. Note that you may choose any string from this list you want, it is not necessarily the string you are trying to type.
What is the minimum number of seconds that you have to spend to type each string from S?
Note that the strings from S are given in an unusual way.
Input
The first line contains one integer n (1 ≤ n ≤ 10^6).
Then n lines follow, the i-th line contains one integer p_i (0 ≤ p_i < i) and one lowercase Latin character c_i. These lines form some set of strings such that S is its subset as follows: there are n + 1 strings, numbered from 0 to n; the 0-th string is an empty string, and the i-th string (i ≥ 1) is the result of appending the character c_i to the string p_i. It is guaranteed that all these strings are distinct.
The next line contains one integer k (1 ≤ k ≤ n) — the number of strings in S.
The last line contains k integers a_1, a_2, ..., a_k (1 ≤ a_i ≤ n, all a_i are pairwise distinct) denoting the indices of the strings generated by above-mentioned process that form the set S — formally, if we denote the i-th generated string as s_i, then S = {s_{a_1}, s_{a_2}, ..., s_{a_k}}.
Output
Print k integers, the i-th of them should be equal to the minimum number of seconds required to type the string s_{a_i}.
Examples
Input
10
0 i
1 q
2 g
0 k
1 e
5 r
4 m
5 h
3 p
3 e
5
8 9 1 10 6
Output
2 4 1 3 3
Input
8
0 a
1 b
2 a
2 b
4 a
4 b
5 c
6 d
5
2 3 4 7 8
Output
1 2 2 4 4
Note
In the first example, S consists of the following strings: ieh, iqgp, i, iqge, ier. | instruction | 0 | 25,724 | 0 | 51,448 |
Tags: data structures, dfs and similar, dp
Correct Solution:
```
import sys
input = sys.stdin.readline
n=int(input())
T=[input().split() for i in range(n)]
k=int(input())
S=list(map(int,input().split()))
SETS=set(S)
E=[[] for i in range(n+1)]
P=[-1]*(n+1)
for i in range(n):
p,s=T[i]
p=int(p)
E[p].append((s,i+1))
P[i+1]=p
for i in range(n+1):
E[i].sort(reverse=True)
ELI=[0]*(n+1)
DEPTH=[0]*(n+1)
ELIMIN=[0]*(n+1)
ANS=[0]*(n+1)
Q=[0]
USED=[0]*(n+1)
count=0
while Q:
x=Q.pop()
USED[x]=1
if x in SETS:
count+=1
#print(x,count)
if x in SETS:
ANS[x]=min(DEPTH[x],count+ELIMIN[P[x]],ANS[P[x]]+1)
ELI[x]=ANS[x]-count+1
else:
ANS[x]=min(DEPTH[x],ANS[P[x]]+1)
ELI[x]=ANS[x]-count
ELIMIN[x]=min(ELI[x],ELIMIN[P[x]])
for s,to in E[x]:
if USED[to]==1:
continue
Q.append(to)
DEPTH[to]=DEPTH[x]+1
print(*[ANS[s] for s in S])
``` | output | 1 | 25,724 | 0 | 51,449 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.