message stringlengths 2 65.1k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 0 108k | cluster float64 14 14 | __index_level_0__ int64 0 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Prodiggers are quite a cool band and for this reason, they have been the surprise guest at the ENTER festival for the past 80 years. At the beginning of their careers, they weren’t so successful, so they had to spend time digging channels to earn money; hence the name. Anyway, they like to tour a lot and have surprising amounts of energy to do extremely long tours. However, they hate spending two consecutive days without having a concert, so they would like to avoid it.
A tour is defined by a sequence of concerts and days-off. You need to count in how many ways The Prodiggers can select k different tours of the same length between l and r.
For example if k = 2, l = 1 and r = 2, if we define concert day as {1} and day-off as {0}, here are all possible tours: {0}, {1}, {00}, {01}, {10}, {11}. But tour 00 can not be selected because it has 2 days-off in a row. Now, we need to count in how many ways we can select k = 2 tours of the same length in range [1;2]. Here they are: {0,1}; {01,10}; {01,11}; {10,11}.
Since their schedule is quite busy, they want you to tell them in how many ways can do that, modulo 1 000 000 007 (109 + 7).
Input
The first line of the input contains three integers k, l and r (1 ≤ k ≤ 200, 1 ≤ l ≤ r ≤ 1018).
Output
Output a single number: the number of ways to select k different tours of the same length, modulo 1 000 000 007.
Example
Input
1 1 2
Output
5
Submitted Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Feb 8 00:37:58 2018
@author: bbream
"""
import itertools
def festival(k, l, r):
modulo = 10**9 + 7
sum = 0
for i in range(l, r + 1):
sum += len(list(itertools.combinations(range(int(F(i))), k)))
return int(sum) % modulo
from math import sqrt
def F(n):
n = n + 2
return ((1+sqrt(5))**n-(1-sqrt(5))**n)/(2**n*sqrt(5))
__name__ = '__test__'
#__name__ = '__main__'
if __name__ == '__test__':
import unittest
class Test(unittest.TestCase):
def test_case1(self):
self.assertEqual(festival(1, 1, 1), 2)
self.assertEqual(festival(1, 2, 2), 3)
self.assertEqual(festival(1, 3, 3), 5)
self.assertEqual(festival(1, 4, 4), 8)
self.assertEqual(festival(1, 5, 5), 13)
#11111 * 1: 5c0,
#01111 * 5: 5c1,
#00111 * 10 - 4: 5c2 - 4,
#00011 * 10 - 3 - 2 - 1 - 2: 5c3 - 9,
#00001 * 5 - 5: 5c4 - 5,
#00000 * 1 - 1: 5c5 - 1.
def test_case2(self):
self.assertEqual(festival(2, 1, 1), 1)
self.assertEqual(festival(2, 2, 2), 3)
self.assertEqual(festival(2, 3, 3), 10)
def test_case3(self):
self.assertEqual(festival(2, 1, 2), 4)
self.assertEqual(festival(1, 1, 2), 5)
self.assertEqual(festival(1, 3, 3), 5)
self.assertEqual(festival(2, 3, 3), 10)
self.assertEqual(festival(1, 1, 5), 31)
unittest.main()
else:
import fileinput
for line in fileinput.input():
value = [int(x) for x in line.split(' ')]
k, l, r = value
print(festival(k, l, r))
``` | instruction | 0 | 59,319 | 14 | 118,638 |
No | output | 1 | 59,319 | 14 | 118,639 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Prodiggers are quite a cool band and for this reason, they have been the surprise guest at the ENTER festival for the past 80 years. At the beginning of their careers, they weren’t so successful, so they had to spend time digging channels to earn money; hence the name. Anyway, they like to tour a lot and have surprising amounts of energy to do extremely long tours. However, they hate spending two consecutive days without having a concert, so they would like to avoid it.
A tour is defined by a sequence of concerts and days-off. You need to count in how many ways The Prodiggers can select k different tours of the same length between l and r.
For example if k = 2, l = 1 and r = 2, if we define concert day as {1} and day-off as {0}, here are all possible tours: {0}, {1}, {00}, {01}, {10}, {11}. But tour 00 can not be selected because it has 2 days-off in a row. Now, we need to count in how many ways we can select k = 2 tours of the same length in range [1;2]. Here they are: {0,1}; {01,10}; {01,11}; {10,11}.
Since their schedule is quite busy, they want you to tell them in how many ways can do that, modulo 1 000 000 007 (109 + 7).
Input
The first line of the input contains three integers k, l and r (1 ≤ k ≤ 200, 1 ≤ l ≤ r ≤ 1018).
Output
Output a single number: the number of ways to select k different tours of the same length, modulo 1 000 000 007.
Example
Input
1 1 2
Output
5
Submitted Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Feb 8 00:37:58 2018
@author: bbream
"""
import itertools
def festival(k, l, r):
modulo = 10**9 + 7
sum = 0
for i in range(l, r + 1):
sum += len(list(itertools.combinations(range(2**i - int(i*(i - 1)/2)), k)))
return int(sum) % modulo
#__name__ = '__test__'
__name__ = '__main__'
if __name__ == '__test__':
import unittest
class Test(unittest.TestCase):
def test_case1(self):
self.assertEqual(festival(2, 1, 2), 4)
self.assertEqual(festival(1, 1, 2), 5)
self.assertEqual(festival(1, 3, 3), 5)
self.assertEqual(festival(2, 3, 3), 10)
unittest.main()
else:
import fileinput
for line in fileinput.input():
value = [int(x) for x in line.split(' ')]
k, l, r = value
print(festival(int(k), int(l), int(r)))
``` | instruction | 0 | 59,320 | 14 | 118,640 |
No | output | 1 | 59,320 | 14 | 118,641 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Prodiggers are quite a cool band and for this reason, they have been the surprise guest at the ENTER festival for the past 80 years. At the beginning of their careers, they weren’t so successful, so they had to spend time digging channels to earn money; hence the name. Anyway, they like to tour a lot and have surprising amounts of energy to do extremely long tours. However, they hate spending two consecutive days without having a concert, so they would like to avoid it.
A tour is defined by a sequence of concerts and days-off. You need to count in how many ways The Prodiggers can select k different tours of the same length between l and r.
For example if k = 2, l = 1 and r = 2, if we define concert day as {1} and day-off as {0}, here are all possible tours: {0}, {1}, {00}, {01}, {10}, {11}. But tour 00 can not be selected because it has 2 days-off in a row. Now, we need to count in how many ways we can select k = 2 tours of the same length in range [1;2]. Here they are: {0,1}; {01,10}; {01,11}; {10,11}.
Since their schedule is quite busy, they want you to tell them in how many ways can do that, modulo 1 000 000 007 (109 + 7).
Input
The first line of the input contains three integers k, l and r (1 ≤ k ≤ 200, 1 ≤ l ≤ r ≤ 1018).
Output
Output a single number: the number of ways to select k different tours of the same length, modulo 1 000 000 007.
Example
Input
1 1 2
Output
5
Submitted Solution:
```
import math
p = 1000000007
class phi:
def __init__(self, a, b):#(a+b*sqrt(5)), in the form of the golden ratio
self.a = a
self.b = b
def add(self, other):#(a1+b1*sqrt(5)) + (a2+b2*sqrt(5))
res = phi(0,0)
res.a = (self.a+other.a)%p
res.b = (self.b+other.b)%p
return res
def sub(self, other):#(a1+b1*sqrt(5))-(a2+b2*sqrt(5))
res = phi(0,0)
res.a = (self.a-other.a)%p
res.b = (self.b-other.b)%p
return res
def mult(self, other):#(a1+b1*sqrt(5))*(a2+b2*sqrt(5))
res = phi(0,0)
res.a = (self.a*other.a + 5*self.b*other.b)%p
res.b = (self.b*other.a + self.a*other.b)%p
return res
def div(self, other):#(a1+b1*sqrt(5))/(a2+b2*sqrt(5))
res=phi(0,0)
res.a = (self.a*other.a - 5*self.b*other.b)*inv(other.a*other.a-5*other.b*other.b)%p
res.b = (self.b*other.a - self.a*other.b)*inv(other.a*other.a-5*other.b*other.b)%p
return res
def pwr(self, exp): #faster way to get (a+b*sqrt(5))^exp, by using iterative squaring to get ~log2 time instead of n time
res = one
k = 0
while(exp>>k):
k+=1
while(k>=0):
res = res.mult(res)
if((exp>>k)&1):
res = res.mult(self)
k-=1
return res
def __str__(self): #toString, for debugging purposes
return str(self.a)+' '+str(self.b)
def inv(k): #k^(-1) (mod p)
return pow(k,p-2,p)
one = phi(1,0) #just a 1
phiplus = phi(inv(2),inv(2)) #(1+sqrt(5))/2 (mod p)
phiminus = phi(inv(2),p-inv(2)) #(1-sqrt(5))/2 (mod p)
def binom(n,k):#basic binomial coefficient
p1 = 1
p2 = 1
if(n<k):
return 0
if(k<n//2):
for i in range(1,k+1):
p1 = p1*i%p
p2 = p2*(n+1-i)%p
else:
for i in range(1,n-k+1):
p1 = p1*i%p
p2 = p2*(n+1-i)%p
return p2*inv(p1)%p
def stirlingCoeff(k):#coefficients of the expansion x(x-1)(x-2)(x-3)***(x-k+1), obviously for numerator of the binomial coefficient
coeffs = [1]
for n in range(1,k):
coeffs.append(0)
for m in range(n,0,-1):
coeffs[m] -= n*coeffs[m-1]
return coeffs
def fibsum(m, k):#sum of first m fibonacci numbers to the kth power, using binet's formula and partial geometric series formula
sum = phi(0,0)
for i in range(0,k+1):
coeff = phi(pow(-1,i)*binom(k,i),0)
num = phiplus.pwr((m+1)*(k-i)).mult(phiminus.pwr((m+1)*(i))).sub(one)
print("num:"+str(num))
denom = phiplus.pwr(k-i).mult(phiminus.pwr(i)).sub(one)
print("denom:"+str(denom))
diff = num.mult(coeff).div(denom)
if(i==k/2): diff = phi(m+1,0).mult(coeff)
print("diff:"+str(diff))
sum = sum.add(diff)
print("sum:"+str(sum))
sum = sum.mult(phi(0,inv(5)).pwr(k))
return sum
def main():
fibsums = []
factorialDenom = 1
ans = 0
k,l,r = map(int,input().split())
for m in range(k,0,-1):
fibsums.append(fibsum(r+2,m).a-fibsum(l+1,m).a)
print("fibsum("+str(r+2)+", "+str(m)+")="+str(fibsum(r+2,m).a))
print("fibsum("+str(l+1)+", "+str(m)+")="+str(fibsum(l+1,m).a))
print("fibsum for round "+str(m)+": "+str(fibsums[k-m]))
factorialDenom = factorialDenom*inv(m)%p
coeffs = stirlingCoeff(k)
for i in range(0,k):
ans = (ans+ coeffs[i]*fibsums[i])%p
ans = ans*factorialDenom%p
print(ans)
#main()
for k in range(1,2):
print("fibsum("+str(k)+", 4):"+ str(fibsum(k,4)))
``` | instruction | 0 | 59,321 | 14 | 118,642 |
No | output | 1 | 59,321 | 14 | 118,643 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Prodiggers are quite a cool band and for this reason, they have been the surprise guest at the ENTER festival for the past 80 years. At the beginning of their careers, they weren’t so successful, so they had to spend time digging channels to earn money; hence the name. Anyway, they like to tour a lot and have surprising amounts of energy to do extremely long tours. However, they hate spending two consecutive days without having a concert, so they would like to avoid it.
A tour is defined by a sequence of concerts and days-off. You need to count in how many ways The Prodiggers can select k different tours of the same length between l and r.
For example if k = 2, l = 1 and r = 2, if we define concert day as {1} and day-off as {0}, here are all possible tours: {0}, {1}, {00}, {01}, {10}, {11}. But tour 00 can not be selected because it has 2 days-off in a row. Now, we need to count in how many ways we can select k = 2 tours of the same length in range [1;2]. Here they are: {0,1}; {01,10}; {01,11}; {10,11}.
Since their schedule is quite busy, they want you to tell them in how many ways can do that, modulo 1 000 000 007 (109 + 7).
Input
The first line of the input contains three integers k, l and r (1 ≤ k ≤ 200, 1 ≤ l ≤ r ≤ 1018).
Output
Output a single number: the number of ways to select k different tours of the same length, modulo 1 000 000 007.
Example
Input
1 1 2
Output
5
Submitted Solution:
```
import math
p = 1000000007
def fib(n):
n=n%1000000007
if n == 0:
return (0, 1)
else:
a, b = fib(n // 2)
c = a * (b * 2 - a)
d = a * a + b * b
if n % 2 == 0:
return (c%1000000007, d%1000000007)
else:
return (d%1000000007, (c + d)%1000000007)
def fibonacci(n):
a, b = fib(n)
return a
class phi:
def __init__(self, a, b):#(a+b*sqrt(5)), in the form of the golden ratio
self.a = a
self.b = b
def add(self, other):#(a1+b1*sqrt(5)) + (a2+b2*sqrt(5))
res = phi(0,0)
res.a = (self.a+other.a)%p
res.b = (self.b+other.b)%p
return res
def sub(self, other):#(a1+b1*sqrt(5))-(a2+b2*sqrt(5))
res = phi(0,0)
res.a = (self.a-other.a)%p
res.b = (self.b-other.b)%p
return res
def mult(self, other):#(a1+b1*sqrt(5))*(a2+b2*sqrt(5))
res = phi(0,0)
res.a = (self.a*other.a + 5*self.b*other.b)%p
res.b = (self.b*other.a + self.a*other.b)%p
return res
def div(self, other):#(a1+b1*sqrt(5))/(a2+b2*sqrt(5))
res=phi(0,0)
res.a = (self.a*other.a - 5*self.b*other.b)*inv(other.a*other.a-5*other.b*other.b)%p
res.b = (self.b*other.a - self.a*other.b)*inv(other.a*other.a-5*other.b*other.b)%p
return res
def pwr(self, exp): #faster way to get (a+b*sqrt(5))^exp, by using iterative squaring to get ~log2 time instead of n time
res = one
k = 0
while(exp>>k):
k+=1
while(k>=0):
res = res.mult(res)
if((exp>>k)&1):
res = res.mult(self)
k-=1
return res
def __str__(self): #toString, for debugging purposes
return str(self.a)+' '+str(self.b)
def inv(k): #k^(-1) (mod p)
return pow(k,p-2,p)
one = phi(1,0) #just a 1
phiplus = phi(inv(2),inv(2)) #(1+sqrt(5))/2 (mod p)
phiminus = phi(inv(2),p-inv(2)) #(1-sqrt(5))/2 (mod p)
def binom(n,k):#basic binomial coefficient
p1 = 1
p2 = 1
if(n<k):
return 0
if(k<n//2):
for i in range(1,k+1):
p1 = p1*i%p
p2 = p2*(n+1-i)%p
else:
for i in range(1,n-k+1):
p1 = p1*i%p
p2 = p2*(n+1-i)%p
return p2*inv(p1)%p
def stirlingCoeff(k):#coefficients of the expansion x(x-1)(x-2)(x-3)***(x-k+1) for numerator of the binomial coefficient
coeffs = [1]
for n in range(1,k):
coeffs.append(0)
for m in range(n,0,-1):
coeffs[m] = (coeffs[m]-n*coeffs[m-1])%p
return coeffs
def fibsum(m, k):#sum of first m fibonacci numbers to the kth power, using binets formula and partial geometric series formula
sum = phi(0,0)
for i in range(0,k+1):
diff = (phiplus.pwr((m+1)*(k-i)).mult(phiminus.pwr((m+1)*(i))).sub(one)).mult(phi(pow(-1,i)*binom(k,i),0)).div(phiplus.pwr(k-i).mult(phiminus.pwr(i)).sub(one))
if(i==k/2 and i%2==0): diff = phi(m+1,0).mult(coeff)
sum = sum.add(diff)
sum = sum.mult(phi(0,inv(5)).pwr(k))
return sum
def main():
fibsums = []
coeffs = [1]##
factorialDenom = 1
ans = 0
k,l,r = map(int,input().split())
maexi = fibonacci(r+2)
for m in range(k,1,-1):#0 to 1
coeffs.append(0)#
for n in range(k-m+1,0,-1):#
coeffs[k-m+1] = (coeffs[k-m+1]-n*coeffs[k-m])%p#
if(m>pow(maexi,m)):
fibsums.append(0)
continue
fibsums.append(fibsum(r+2,m).a-fibsum(l+1,m).a)
factorialDenom = factorialDenom*inv(m)%p
fibsums.append(fibsum(r+2,1).a-fibsum(l+1,1).a)#
#coeffs = stirlingCoeff(k)
for i in range(0,k):
ans = (ans+ coeffs[i]*fibsums[i])%p
ans = ans*factorialDenom%p
print(ans)
main()
``` | instruction | 0 | 59,322 | 14 | 118,644 |
No | output | 1 | 59,322 | 14 | 118,645 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n workers in a company, each of them has a unique id from 1 to n. Exaclty one of them is a chief, his id is s. Each worker except the chief has exactly one immediate superior.
There was a request to each of the workers to tell how how many superiors (not only immediate). Worker's superiors are his immediate superior, the immediate superior of the his immediate superior, and so on. For example, if there are three workers in the company, from which the first is the chief, the second worker's immediate superior is the first, the third worker's immediate superior is the second, then the third worker has two superiors, one of them is immediate and one not immediate. The chief is a superior to all the workers except himself.
Some of the workers were in a hurry and made a mistake. You are to find the minimum number of workers that could make a mistake.
Input
The first line contains two positive integers n and s (1 ≤ n ≤ 2·105, 1 ≤ s ≤ n) — the number of workers and the id of the chief.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ n - 1), where ai is the number of superiors (not only immediate) the worker with id i reported about.
Output
Print the minimum number of workers that could make a mistake.
Examples
Input
3 2
2 0 2
Output
1
Input
5 3
1 0 0 4 1
Output
2
Note
In the first example it is possible that only the first worker made a mistake. Then:
* the immediate superior of the first worker is the second worker,
* the immediate superior of the third worker is the first worker,
* the second worker is the chief. | instruction | 0 | 59,323 | 14 | 118,646 |
Tags: constructive algorithms, data structures, graphs, greedy, sortings
Correct Solution:
```
n,s=[int(i) for i in input().split()]
s-=1
n-=1
d=0
l=[int(i) for i in input().split()]
if l[s]!=0:d+=1
l=l[:s]+l[s+1:]
for i in range(0,len(l)):
if(l[i]==0):l[i]=n+5
l.sort()
j=0
i=0
c=0
while 1:
while i<len(l) and j==l[i]:
i+=1
if i>=len(l):
break
elif l[i]-j==1:
j+=1
i+=1
continue
else:
l.pop()
d+=1
j+=1
print(d)
# Made By Mostafa_Khaled
``` | output | 1 | 59,323 | 14 | 118,647 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n workers in a company, each of them has a unique id from 1 to n. Exaclty one of them is a chief, his id is s. Each worker except the chief has exactly one immediate superior.
There was a request to each of the workers to tell how how many superiors (not only immediate). Worker's superiors are his immediate superior, the immediate superior of the his immediate superior, and so on. For example, if there are three workers in the company, from which the first is the chief, the second worker's immediate superior is the first, the third worker's immediate superior is the second, then the third worker has two superiors, one of them is immediate and one not immediate. The chief is a superior to all the workers except himself.
Some of the workers were in a hurry and made a mistake. You are to find the minimum number of workers that could make a mistake.
Input
The first line contains two positive integers n and s (1 ≤ n ≤ 2·105, 1 ≤ s ≤ n) — the number of workers and the id of the chief.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ n - 1), where ai is the number of superiors (not only immediate) the worker with id i reported about.
Output
Print the minimum number of workers that could make a mistake.
Examples
Input
3 2
2 0 2
Output
1
Input
5 3
1 0 0 4 1
Output
2
Note
In the first example it is possible that only the first worker made a mistake. Then:
* the immediate superior of the first worker is the second worker,
* the immediate superior of the third worker is the first worker,
* the second worker is the chief. | instruction | 0 | 59,324 | 14 | 118,648 |
Tags: constructive algorithms, data structures, graphs, greedy, sortings
Correct Solution:
```
""" This is a solution to the problem Subordinates on codeforces.com
There is a DAG with n nodes, pointing towards the root, without further constraints.
Given: for each node, a number signifying the count of (direct and indirect) predecessors, and the ID of root s.
Some of these counts might be wrong. Give the minimum amount of wrong counts.
For details, see
http://codeforces.com/problemset/problem/729/E
"""
#Idea: count = level of DAG. Check constraints: root has 0 predecessors, level 0 has only one count, each level to the last has be > 0
from sys import stdin
#lines = open("input.txt", 'r').readlines()
lines = stdin.readlines()
n, s = map(int, lines[0].split())
counts = list(map(int, lines[1].split()))
totalwrong = 0
if counts[s-1] > 0: # root has to be 0
totalwrong += 1
counts[s-1] = 0
maxlevel = max(counts)
# count number of nodes on levels
levelcount = [0] * (max(counts) + 1)
for c in counts:
levelcount[c] += 1
curwrong = levelcount[0] - 1 # only one root
levelcount[0] = 1
totalwrong += curwrong
curlevel = 0
while curlevel <= maxlevel:
lc = levelcount[curlevel]
if lc == 0: # a mistake
if curwrong > 0: # still mistakes available, just use them to fill
curwrong -= 1
levelcount[curlevel] = 1
else: # else fill from last level
levelcount[maxlevel] -= 1
levelcount[curlevel] = 1
totalwrong += 1
while levelcount[maxlevel] == 0:
maxlevel -= 1 # as levelcount[curlevel] = 1, this aborts at some point
curlevel += 1
print(totalwrong)
``` | output | 1 | 59,324 | 14 | 118,649 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n workers in a company, each of them has a unique id from 1 to n. Exaclty one of them is a chief, his id is s. Each worker except the chief has exactly one immediate superior.
There was a request to each of the workers to tell how how many superiors (not only immediate). Worker's superiors are his immediate superior, the immediate superior of the his immediate superior, and so on. For example, if there are three workers in the company, from which the first is the chief, the second worker's immediate superior is the first, the third worker's immediate superior is the second, then the third worker has two superiors, one of them is immediate and one not immediate. The chief is a superior to all the workers except himself.
Some of the workers were in a hurry and made a mistake. You are to find the minimum number of workers that could make a mistake.
Input
The first line contains two positive integers n and s (1 ≤ n ≤ 2·105, 1 ≤ s ≤ n) — the number of workers and the id of the chief.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ n - 1), where ai is the number of superiors (not only immediate) the worker with id i reported about.
Output
Print the minimum number of workers that could make a mistake.
Examples
Input
3 2
2 0 2
Output
1
Input
5 3
1 0 0 4 1
Output
2
Note
In the first example it is possible that only the first worker made a mistake. Then:
* the immediate superior of the first worker is the second worker,
* the immediate superior of the third worker is the first worker,
* the second worker is the chief. | instruction | 0 | 59,325 | 14 | 118,650 |
Tags: constructive algorithms, data structures, graphs, greedy, sortings
Correct Solution:
```
[n, s] = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
mistakes = 0
mistakes += (a[s-1] is not 0)
a[s - 1] = 0
numSuperiors = [0]*(2*100000+100)
for superiors in a:
numSuperiors[superiors] += 1
cachedMistakes = 0
while numSuperiors[0] != 1:
cachedMistakes += 1
numSuperiors[0] -= 1
rightIndex = len(numSuperiors) - 1
leftIndex = 0
while True:
while True:
if numSuperiors[leftIndex] == 0 and cachedMistakes != 0:
numSuperiors[leftIndex] += 1
cachedMistakes -= 1
mistakes += 1
if numSuperiors[leftIndex] == 0:
break
leftIndex += 1
while numSuperiors[rightIndex] == 0:
rightIndex -= 1
if leftIndex >= rightIndex:
break
numSuperiors[rightIndex] -= 1
cachedMistakes += 1
print(mistakes)
``` | output | 1 | 59,325 | 14 | 118,651 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n workers in a company, each of them has a unique id from 1 to n. Exaclty one of them is a chief, his id is s. Each worker except the chief has exactly one immediate superior.
There was a request to each of the workers to tell how how many superiors (not only immediate). Worker's superiors are his immediate superior, the immediate superior of the his immediate superior, and so on. For example, if there are three workers in the company, from which the first is the chief, the second worker's immediate superior is the first, the third worker's immediate superior is the second, then the third worker has two superiors, one of them is immediate and one not immediate. The chief is a superior to all the workers except himself.
Some of the workers were in a hurry and made a mistake. You are to find the minimum number of workers that could make a mistake.
Input
The first line contains two positive integers n and s (1 ≤ n ≤ 2·105, 1 ≤ s ≤ n) — the number of workers and the id of the chief.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ n - 1), where ai is the number of superiors (not only immediate) the worker with id i reported about.
Output
Print the minimum number of workers that could make a mistake.
Examples
Input
3 2
2 0 2
Output
1
Input
5 3
1 0 0 4 1
Output
2
Note
In the first example it is possible that only the first worker made a mistake. Then:
* the immediate superior of the first worker is the second worker,
* the immediate superior of the third worker is the first worker,
* the second worker is the chief. | instruction | 0 | 59,326 | 14 | 118,652 |
Tags: constructive algorithms, data structures, graphs, greedy, sortings
Correct Solution:
```
n, root = map(int, input().split())
a = list(map(int, input().split()))
def push(d, x, val):
if x not in d:
d[x] = 0
d[x]+=val
if d[x]==0:
del d[x]
d = {}
for x in a:
push(d, x, 1)
min_ = 0
root -= 1
inf = 9999999
if a[root] != 0:
min_+=1
push(d, a[root], -1)
push(d, 0, 1)
if 0 in d and d[0] > 1:
add = d[0] - 1
min_+=add
push(d, inf, add)
d[0] = 1
S = [[val, num] for val, num in sorted(d.items(), key = lambda x:x[0])]
#print(min_, S)
cur = -1
i = 0
while i < len(S):
remain = S[i][0] - (cur+1)
while remain > 0:
val, num = S[-1]
if val == S[i][0]:
if val != inf:
min_ += min(remain, num)
break
else:
add = min(num, remain)
remain -= add
if val != inf:
min_ += add
if num == add:
S.pop()
else:
S[-1][1] -= add
cur=S[i][0]
i+=1
print(min_)
``` | output | 1 | 59,326 | 14 | 118,653 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n workers in a company, each of them has a unique id from 1 to n. Exaclty one of them is a chief, his id is s. Each worker except the chief has exactly one immediate superior.
There was a request to each of the workers to tell how how many superiors (not only immediate). Worker's superiors are his immediate superior, the immediate superior of the his immediate superior, and so on. For example, if there are three workers in the company, from which the first is the chief, the second worker's immediate superior is the first, the third worker's immediate superior is the second, then the third worker has two superiors, one of them is immediate and one not immediate. The chief is a superior to all the workers except himself.
Some of the workers were in a hurry and made a mistake. You are to find the minimum number of workers that could make a mistake.
Input
The first line contains two positive integers n and s (1 ≤ n ≤ 2·105, 1 ≤ s ≤ n) — the number of workers and the id of the chief.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ n - 1), where ai is the number of superiors (not only immediate) the worker with id i reported about.
Output
Print the minimum number of workers that could make a mistake.
Examples
Input
3 2
2 0 2
Output
1
Input
5 3
1 0 0 4 1
Output
2
Note
In the first example it is possible that only the first worker made a mistake. Then:
* the immediate superior of the first worker is the second worker,
* the immediate superior of the third worker is the first worker,
* the second worker is the chief. | instruction | 0 | 59,327 | 14 | 118,654 |
Tags: constructive algorithms, data structures, graphs, greedy, sortings
Correct Solution:
```
n,s = map(int,input().split())
A = list(map(int,input().split()))
if A[s-1] != 0:
per = 1
A[s-1] = 0
else:
per = 0
A.sort()
maxs = max(A)
ans = [0] * (maxs + 1)
answer = maxs + 1
o = -1
for j in range(n):
if A[j] == 0:
o += 1
if ans[A[j]] == 0:
ans[A[j]] = 1
answer -= 1
an = per + max(o, answer)
for j in range(n-2,-1,-1):
for t in range(A[j+1]-1, A[j] -1,-1):
if ans[t] == 0:
answer -= 1
an = min(an, per + max(answer,o+n - j - 1))
print(an)
``` | output | 1 | 59,327 | 14 | 118,655 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n workers in a company, each of them has a unique id from 1 to n. Exaclty one of them is a chief, his id is s. Each worker except the chief has exactly one immediate superior.
There was a request to each of the workers to tell how how many superiors (not only immediate). Worker's superiors are his immediate superior, the immediate superior of the his immediate superior, and so on. For example, if there are three workers in the company, from which the first is the chief, the second worker's immediate superior is the first, the third worker's immediate superior is the second, then the third worker has two superiors, one of them is immediate and one not immediate. The chief is a superior to all the workers except himself.
Some of the workers were in a hurry and made a mistake. You are to find the minimum number of workers that could make a mistake.
Input
The first line contains two positive integers n and s (1 ≤ n ≤ 2·105, 1 ≤ s ≤ n) — the number of workers and the id of the chief.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ n - 1), where ai is the number of superiors (not only immediate) the worker with id i reported about.
Output
Print the minimum number of workers that could make a mistake.
Examples
Input
3 2
2 0 2
Output
1
Input
5 3
1 0 0 4 1
Output
2
Note
In the first example it is possible that only the first worker made a mistake. Then:
* the immediate superior of the first worker is the second worker,
* the immediate superior of the third worker is the first worker,
* the second worker is the chief. | instruction | 0 | 59,328 | 14 | 118,656 |
Tags: constructive algorithms, data structures, graphs, greedy, sortings
Correct Solution:
```
f = lambda: map(int, input().split())
n, s = f()
c = [0] * n
t = list(f())
for i in t: c[i] += 1
k = t[s - 1]
c[k] -= 1
d = c[0]
c += [d]
d += k > 0
i, j = 1, n
while i < j:
if c[i]: i += 1
elif c[j]:
c[j] -= 1
i += 1
d += j < n
else: j -= 1
print(d)
``` | output | 1 | 59,328 | 14 | 118,657 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n workers in a company, each of them has a unique id from 1 to n. Exaclty one of them is a chief, his id is s. Each worker except the chief has exactly one immediate superior.
There was a request to each of the workers to tell how how many superiors (not only immediate). Worker's superiors are his immediate superior, the immediate superior of the his immediate superior, and so on. For example, if there are three workers in the company, from which the first is the chief, the second worker's immediate superior is the first, the third worker's immediate superior is the second, then the third worker has two superiors, one of them is immediate and one not immediate. The chief is a superior to all the workers except himself.
Some of the workers were in a hurry and made a mistake. You are to find the minimum number of workers that could make a mistake.
Input
The first line contains two positive integers n and s (1 ≤ n ≤ 2·105, 1 ≤ s ≤ n) — the number of workers and the id of the chief.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ n - 1), where ai is the number of superiors (not only immediate) the worker with id i reported about.
Output
Print the minimum number of workers that could make a mistake.
Examples
Input
3 2
2 0 2
Output
1
Input
5 3
1 0 0 4 1
Output
2
Note
In the first example it is possible that only the first worker made a mistake. Then:
* the immediate superior of the first worker is the second worker,
* the immediate superior of the third worker is the first worker,
* the second worker is the chief.
Submitted Solution:
```
a=input()
b=input()
a=a.split()
b=b.split()
n=int(a[0])
s=int(a[1])
t=[]
k=0
for i in range(n):
q=1
if i==(s-1):
if int(b[i])!=0:
k=1
else:
for j in range(len(t)):
if int(b[i])==t[j] and (int(b[i])!=0):
q=0
break
if q==1 and (int(b[i])!=0):
t.append(int(b[i]))
print(k+n-len(t)-1)
``` | instruction | 0 | 59,329 | 14 | 118,658 |
No | output | 1 | 59,329 | 14 | 118,659 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n workers in a company, each of them has a unique id from 1 to n. Exaclty one of them is a chief, his id is s. Each worker except the chief has exactly one immediate superior.
There was a request to each of the workers to tell how how many superiors (not only immediate). Worker's superiors are his immediate superior, the immediate superior of the his immediate superior, and so on. For example, if there are three workers in the company, from which the first is the chief, the second worker's immediate superior is the first, the third worker's immediate superior is the second, then the third worker has two superiors, one of them is immediate and one not immediate. The chief is a superior to all the workers except himself.
Some of the workers were in a hurry and made a mistake. You are to find the minimum number of workers that could make a mistake.
Input
The first line contains two positive integers n and s (1 ≤ n ≤ 2·105, 1 ≤ s ≤ n) — the number of workers and the id of the chief.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ n - 1), where ai is the number of superiors (not only immediate) the worker with id i reported about.
Output
Print the minimum number of workers that could make a mistake.
Examples
Input
3 2
2 0 2
Output
1
Input
5 3
1 0 0 4 1
Output
2
Note
In the first example it is possible that only the first worker made a mistake. Then:
* the immediate superior of the first worker is the second worker,
* the immediate superior of the third worker is the first worker,
* the second worker is the chief.
Submitted Solution:
```
n, s = [int(i) for i in input().split()]
a = sorted([int(i) for i in input().split()])
j = 1
ans = 0
while a[j] == 0:
ans += 1
a[j] += 1
j += 1
for i in range(j, n):
if a[i] - a[i - 1] > 1:
ans += 1
a[i] = a[i - 1] + 1
print(a, ans)
``` | instruction | 0 | 59,330 | 14 | 118,660 |
No | output | 1 | 59,330 | 14 | 118,661 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n workers in a company, each of them has a unique id from 1 to n. Exaclty one of them is a chief, his id is s. Each worker except the chief has exactly one immediate superior.
There was a request to each of the workers to tell how how many superiors (not only immediate). Worker's superiors are his immediate superior, the immediate superior of the his immediate superior, and so on. For example, if there are three workers in the company, from which the first is the chief, the second worker's immediate superior is the first, the third worker's immediate superior is the second, then the third worker has two superiors, one of them is immediate and one not immediate. The chief is a superior to all the workers except himself.
Some of the workers were in a hurry and made a mistake. You are to find the minimum number of workers that could make a mistake.
Input
The first line contains two positive integers n and s (1 ≤ n ≤ 2·105, 1 ≤ s ≤ n) — the number of workers and the id of the chief.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ n - 1), where ai is the number of superiors (not only immediate) the worker with id i reported about.
Output
Print the minimum number of workers that could make a mistake.
Examples
Input
3 2
2 0 2
Output
1
Input
5 3
1 0 0 4 1
Output
2
Note
In the first example it is possible that only the first worker made a mistake. Then:
* the immediate superior of the first worker is the second worker,
* the immediate superior of the third worker is the first worker,
* the second worker is the chief.
Submitted Solution:
```
n, s = map(int, input().split())
bo = list(map(int, input().split()))
ans = 0
if bo[s-1] != 0:
ans += 1
bo.pop(s-1)
for i in range(n):
if i not in bo:
ans += 1
print(ans)
``` | instruction | 0 | 59,331 | 14 | 118,662 |
No | output | 1 | 59,331 | 14 | 118,663 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n workers in a company, each of them has a unique id from 1 to n. Exaclty one of them is a chief, his id is s. Each worker except the chief has exactly one immediate superior.
There was a request to each of the workers to tell how how many superiors (not only immediate). Worker's superiors are his immediate superior, the immediate superior of the his immediate superior, and so on. For example, if there are three workers in the company, from which the first is the chief, the second worker's immediate superior is the first, the third worker's immediate superior is the second, then the third worker has two superiors, one of them is immediate and one not immediate. The chief is a superior to all the workers except himself.
Some of the workers were in a hurry and made a mistake. You are to find the minimum number of workers that could make a mistake.
Input
The first line contains two positive integers n and s (1 ≤ n ≤ 2·105, 1 ≤ s ≤ n) — the number of workers and the id of the chief.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ n - 1), where ai is the number of superiors (not only immediate) the worker with id i reported about.
Output
Print the minimum number of workers that could make a mistake.
Examples
Input
3 2
2 0 2
Output
1
Input
5 3
1 0 0 4 1
Output
2
Note
In the first example it is possible that only the first worker made a mistake. Then:
* the immediate superior of the first worker is the second worker,
* the immediate superior of the third worker is the first worker,
* the second worker is the chief.
Submitted Solution:
```
from bisect import bisect_left as bl
from bisect import bisect_right as br
import heapq
import math
from collections import *
from functools import reduce,cmp_to_key
import sys
input = sys.stdin.readline
M = mod = 998244353
def factors(n):return sorted(list(set(reduce(list.__add__,([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))))
# def inv_mod(n):return pow(n, mod - 2, mod)
def li():return [int(i) for i in input().rstrip('\n').split()]
def st():return input().rstrip('\n')
def val():return int(input().rstrip('\n'))
def li2():return [i for i in input().rstrip('\n').split(' ')]
def li3():return [int(i) for i in input().rstrip('\n')]
n, s = li();tot = 0
a = li()
l = Counter(a)
for i in l:
if i == 0:continue
tot += max(l[i] - 1,0)
if a[s-1] != 0:tot += l[0]
else:tot += max(l[0] - 1,0)
print(tot)
``` | instruction | 0 | 59,332 | 14 | 118,664 |
No | output | 1 | 59,332 | 14 | 118,665 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A few years ago Sajjad left his school and register to another one due to security reasons. Now he wishes to find Amir, one of his schoolmates and good friends.
There are n schools numerated from 1 to n. One can travel between each pair of them, to do so, he needs to buy a ticket. The ticker between schools i and j costs <image> and can be used multiple times. Help Sajjad to find the minimum cost he needs to pay for tickets to visit all schools. He can start and finish in any school.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of schools.
Output
Print single integer: the minimum cost of tickets needed to visit all schools.
Examples
Input
2
Output
0
Input
10
Output
4
Note
In the first example we can buy a ticket between the schools that costs <image>. | instruction | 0 | 59,365 | 14 | 118,730 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
print((int(input()) - 1) // 2)
``` | output | 1 | 59,365 | 14 | 118,731 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A few years ago Sajjad left his school and register to another one due to security reasons. Now he wishes to find Amir, one of his schoolmates and good friends.
There are n schools numerated from 1 to n. One can travel between each pair of them, to do so, he needs to buy a ticket. The ticker between schools i and j costs <image> and can be used multiple times. Help Sajjad to find the minimum cost he needs to pay for tickets to visit all schools. He can start and finish in any school.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of schools.
Output
Print single integer: the minimum cost of tickets needed to visit all schools.
Examples
Input
2
Output
0
Input
10
Output
4
Note
In the first example we can buy a ticket between the schools that costs <image>. | instruction | 0 | 59,366 | 14 | 118,732 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
n = int(input())
if n%2 == 0:
print((n-2)//2)
else:
print(n//2)
``` | output | 1 | 59,366 | 14 | 118,733 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A few years ago Sajjad left his school and register to another one due to security reasons. Now he wishes to find Amir, one of his schoolmates and good friends.
There are n schools numerated from 1 to n. One can travel between each pair of them, to do so, he needs to buy a ticket. The ticker between schools i and j costs <image> and can be used multiple times. Help Sajjad to find the minimum cost he needs to pay for tickets to visit all schools. He can start and finish in any school.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of schools.
Output
Print single integer: the minimum cost of tickets needed to visit all schools.
Examples
Input
2
Output
0
Input
10
Output
4
Note
In the first example we can buy a ticket between the schools that costs <image>. | instruction | 0 | 59,367 | 14 | 118,734 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
n = int(input())
print((n+1)//2 - 1)
``` | output | 1 | 59,367 | 14 | 118,735 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A few years ago Sajjad left his school and register to another one due to security reasons. Now he wishes to find Amir, one of his schoolmates and good friends.
There are n schools numerated from 1 to n. One can travel between each pair of them, to do so, he needs to buy a ticket. The ticker between schools i and j costs <image> and can be used multiple times. Help Sajjad to find the minimum cost he needs to pay for tickets to visit all schools. He can start and finish in any school.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of schools.
Output
Print single integer: the minimum cost of tickets needed to visit all schools.
Examples
Input
2
Output
0
Input
10
Output
4
Note
In the first example we can buy a ticket between the schools that costs <image>. | instruction | 0 | 59,368 | 14 | 118,736 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
n = int(input())
print((n - 1) // 2)
``` | output | 1 | 59,368 | 14 | 118,737 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A few years ago Sajjad left his school and register to another one due to security reasons. Now he wishes to find Amir, one of his schoolmates and good friends.
There are n schools numerated from 1 to n. One can travel between each pair of them, to do so, he needs to buy a ticket. The ticker between schools i and j costs <image> and can be used multiple times. Help Sajjad to find the minimum cost he needs to pay for tickets to visit all schools. He can start and finish in any school.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of schools.
Output
Print single integer: the minimum cost of tickets needed to visit all schools.
Examples
Input
2
Output
0
Input
10
Output
4
Note
In the first example we can buy a ticket between the schools that costs <image>. | instruction | 0 | 59,369 | 14 | 118,738 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
#!/usr/bin/env python3
from sys import stdin,stdout
def readint():
return map(int, stdin.readline().split())
#lines = stdin.readlines()
n = int(input())
a = n//2
if n%2:
a +=1
print(a-1)
``` | output | 1 | 59,369 | 14 | 118,739 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A few years ago Sajjad left his school and register to another one due to security reasons. Now he wishes to find Amir, one of his schoolmates and good friends.
There are n schools numerated from 1 to n. One can travel between each pair of them, to do so, he needs to buy a ticket. The ticker between schools i and j costs <image> and can be used multiple times. Help Sajjad to find the minimum cost he needs to pay for tickets to visit all schools. He can start and finish in any school.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of schools.
Output
Print single integer: the minimum cost of tickets needed to visit all schools.
Examples
Input
2
Output
0
Input
10
Output
4
Note
In the first example we can buy a ticket between the schools that costs <image>. | instruction | 0 | 59,370 | 14 | 118,740 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
n = int(input())
if(n == 1):
print(0)
else:
if(n%2 == 0):
print(n // 2 - 1)
else:
print(n//2)
``` | output | 1 | 59,370 | 14 | 118,741 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A few years ago Sajjad left his school and register to another one due to security reasons. Now he wishes to find Amir, one of his schoolmates and good friends.
There are n schools numerated from 1 to n. One can travel between each pair of them, to do so, he needs to buy a ticket. The ticker between schools i and j costs <image> and can be used multiple times. Help Sajjad to find the minimum cost he needs to pay for tickets to visit all schools. He can start and finish in any school.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of schools.
Output
Print single integer: the minimum cost of tickets needed to visit all schools.
Examples
Input
2
Output
0
Input
10
Output
4
Note
In the first example we can buy a ticket between the schools that costs <image>. | instruction | 0 | 59,371 | 14 | 118,742 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
n = int(input())
if n % 2 == 1:
ans = (n - 1) // 2
else:
ans = (n - 2) // 2
print(ans)
``` | output | 1 | 59,371 | 14 | 118,743 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A few years ago Sajjad left his school and register to another one due to security reasons. Now he wishes to find Amir, one of his schoolmates and good friends.
There are n schools numerated from 1 to n. One can travel between each pair of them, to do so, he needs to buy a ticket. The ticker between schools i and j costs <image> and can be used multiple times. Help Sajjad to find the minimum cost he needs to pay for tickets to visit all schools. He can start and finish in any school.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of schools.
Output
Print single integer: the minimum cost of tickets needed to visit all schools.
Examples
Input
2
Output
0
Input
10
Output
4
Note
In the first example we can buy a ticket between the schools that costs <image>. | instruction | 0 | 59,372 | 14 | 118,744 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
n = int(input())
if n % 2 == 0:
print((n - 2) // 2)
else:
print((n - 1) // 2)
``` | output | 1 | 59,372 | 14 | 118,745 |
Provide a correct Python 3 solution for this coding contest problem.
There are N people standing in a queue from west to east.
Given is a string S of length N representing the directions of the people. The i-th person from the west is facing west if the i-th character of S is `L`, and east if that character of S is `R`.
A person is happy if the person in front of him/her is facing the same direction. If no person is standing in front of a person, however, he/she is not happy.
You can perform the following operation any number of times between 0 and K (inclusive):
Operation: Choose integers l and r such that 1 \leq l \leq r \leq N, and rotate by 180 degrees the part of the queue: the l-th, (l+1)-th, ..., r-th persons. That is, for each i = 0, 1, ..., r-l, the (l + i)-th person from the west will stand the (r - i)-th from the west after the operation, facing east if he/she is facing west now, and vice versa.
What is the maximum possible number of happy people you can have?
Constraints
* N is an integer satisfying 1 \leq N \leq 10^5.
* K is an integer satisfying 1 \leq K \leq 10^5.
* |S| = N
* Each character of S is `L` or `R`.
Input
Input is given from Standard Input in the following format:
N K
S
Output
Print the maximum possible number of happy people after at most K operations.
Examples
Input
6 1
LRLRRL
Output
3
Input
13 3
LRRLRLRRLRLLR
Output
9
Input
10 1
LLLLLRRRRR
Output
9
Input
9 2
RRRLRLRLL
Output
7 | instruction | 0 | 59,449 | 14 | 118,898 |
"Correct Solution:
```
N, K = map(int, input().split())
S = input()
r = 0
for i in range(1, len(S)):
if S[i] == S[i-1]:
r += 1
r = min(len(S)-1, r+2*K)
print(r)
``` | output | 1 | 59,449 | 14 | 118,899 |
Provide a correct Python 3 solution for this coding contest problem.
There are N people standing in a queue from west to east.
Given is a string S of length N representing the directions of the people. The i-th person from the west is facing west if the i-th character of S is `L`, and east if that character of S is `R`.
A person is happy if the person in front of him/her is facing the same direction. If no person is standing in front of a person, however, he/she is not happy.
You can perform the following operation any number of times between 0 and K (inclusive):
Operation: Choose integers l and r such that 1 \leq l \leq r \leq N, and rotate by 180 degrees the part of the queue: the l-th, (l+1)-th, ..., r-th persons. That is, for each i = 0, 1, ..., r-l, the (l + i)-th person from the west will stand the (r - i)-th from the west after the operation, facing east if he/she is facing west now, and vice versa.
What is the maximum possible number of happy people you can have?
Constraints
* N is an integer satisfying 1 \leq N \leq 10^5.
* K is an integer satisfying 1 \leq K \leq 10^5.
* |S| = N
* Each character of S is `L` or `R`.
Input
Input is given from Standard Input in the following format:
N K
S
Output
Print the maximum possible number of happy people after at most K operations.
Examples
Input
6 1
LRLRRL
Output
3
Input
13 3
LRRLRLRRLRLLR
Output
9
Input
10 1
LLLLLRRRRR
Output
9
Input
9 2
RRRLRLRLL
Output
7 | instruction | 0 | 59,450 | 14 | 118,900 |
"Correct Solution:
```
N,K=map(int,input().split())
s=input()
x=0
for i in range(N-1):
if s[i]!=s[i+1]:
x+=1
x=max([0,x-2*K])
print(N-1-x)
``` | output | 1 | 59,450 | 14 | 118,901 |
Provide a correct Python 3 solution for this coding contest problem.
There are N people standing in a queue from west to east.
Given is a string S of length N representing the directions of the people. The i-th person from the west is facing west if the i-th character of S is `L`, and east if that character of S is `R`.
A person is happy if the person in front of him/her is facing the same direction. If no person is standing in front of a person, however, he/she is not happy.
You can perform the following operation any number of times between 0 and K (inclusive):
Operation: Choose integers l and r such that 1 \leq l \leq r \leq N, and rotate by 180 degrees the part of the queue: the l-th, (l+1)-th, ..., r-th persons. That is, for each i = 0, 1, ..., r-l, the (l + i)-th person from the west will stand the (r - i)-th from the west after the operation, facing east if he/she is facing west now, and vice versa.
What is the maximum possible number of happy people you can have?
Constraints
* N is an integer satisfying 1 \leq N \leq 10^5.
* K is an integer satisfying 1 \leq K \leq 10^5.
* |S| = N
* Each character of S is `L` or `R`.
Input
Input is given from Standard Input in the following format:
N K
S
Output
Print the maximum possible number of happy people after at most K operations.
Examples
Input
6 1
LRLRRL
Output
3
Input
13 3
LRRLRLRRLRLLR
Output
9
Input
10 1
LLLLLRRRRR
Output
9
Input
9 2
RRRLRLRLL
Output
7 | instruction | 0 | 59,451 | 14 | 118,902 |
"Correct Solution:
```
N, K=map(int, input().split())
S=input()
ans=0
for i in range(1, N):
if S[i-1]==S[i]:
ans+=1
ans=min(N-1, ans+K*2)
print(ans)
``` | output | 1 | 59,451 | 14 | 118,903 |
Provide a correct Python 3 solution for this coding contest problem.
There are N people standing in a queue from west to east.
Given is a string S of length N representing the directions of the people. The i-th person from the west is facing west if the i-th character of S is `L`, and east if that character of S is `R`.
A person is happy if the person in front of him/her is facing the same direction. If no person is standing in front of a person, however, he/she is not happy.
You can perform the following operation any number of times between 0 and K (inclusive):
Operation: Choose integers l and r such that 1 \leq l \leq r \leq N, and rotate by 180 degrees the part of the queue: the l-th, (l+1)-th, ..., r-th persons. That is, for each i = 0, 1, ..., r-l, the (l + i)-th person from the west will stand the (r - i)-th from the west after the operation, facing east if he/she is facing west now, and vice versa.
What is the maximum possible number of happy people you can have?
Constraints
* N is an integer satisfying 1 \leq N \leq 10^5.
* K is an integer satisfying 1 \leq K \leq 10^5.
* |S| = N
* Each character of S is `L` or `R`.
Input
Input is given from Standard Input in the following format:
N K
S
Output
Print the maximum possible number of happy people after at most K operations.
Examples
Input
6 1
LRLRRL
Output
3
Input
13 3
LRRLRLRRLRLLR
Output
9
Input
10 1
LLLLLRRRRR
Output
9
Input
9 2
RRRLRLRLL
Output
7 | instruction | 0 | 59,452 | 14 | 118,904 |
"Correct Solution:
```
N, K = map(int,input().split())
S = input()
cnt = sum([S[i] != S[i+1] for i in range(N-1)])
ans = (N-1) - cnt
ans += min(2*K, cnt)
print(ans)
``` | output | 1 | 59,452 | 14 | 118,905 |
Provide a correct Python 3 solution for this coding contest problem.
There are N people standing in a queue from west to east.
Given is a string S of length N representing the directions of the people. The i-th person from the west is facing west if the i-th character of S is `L`, and east if that character of S is `R`.
A person is happy if the person in front of him/her is facing the same direction. If no person is standing in front of a person, however, he/she is not happy.
You can perform the following operation any number of times between 0 and K (inclusive):
Operation: Choose integers l and r such that 1 \leq l \leq r \leq N, and rotate by 180 degrees the part of the queue: the l-th, (l+1)-th, ..., r-th persons. That is, for each i = 0, 1, ..., r-l, the (l + i)-th person from the west will stand the (r - i)-th from the west after the operation, facing east if he/she is facing west now, and vice versa.
What is the maximum possible number of happy people you can have?
Constraints
* N is an integer satisfying 1 \leq N \leq 10^5.
* K is an integer satisfying 1 \leq K \leq 10^5.
* |S| = N
* Each character of S is `L` or `R`.
Input
Input is given from Standard Input in the following format:
N K
S
Output
Print the maximum possible number of happy people after at most K operations.
Examples
Input
6 1
LRLRRL
Output
3
Input
13 3
LRRLRLRRLRLLR
Output
9
Input
10 1
LLLLLRRRRR
Output
9
Input
9 2
RRRLRLRLL
Output
7 | instruction | 0 | 59,453 | 14 | 118,906 |
"Correct Solution:
```
n,k,s=open(0).read().split()
n,k=int(n),int(k)
d=0
for i in range(1,n):
if not s[i]==s[i-1]:
d+=1
print(n-1-max(d-2*k,0))
``` | output | 1 | 59,453 | 14 | 118,907 |
Provide a correct Python 3 solution for this coding contest problem.
There are N people standing in a queue from west to east.
Given is a string S of length N representing the directions of the people. The i-th person from the west is facing west if the i-th character of S is `L`, and east if that character of S is `R`.
A person is happy if the person in front of him/her is facing the same direction. If no person is standing in front of a person, however, he/she is not happy.
You can perform the following operation any number of times between 0 and K (inclusive):
Operation: Choose integers l and r such that 1 \leq l \leq r \leq N, and rotate by 180 degrees the part of the queue: the l-th, (l+1)-th, ..., r-th persons. That is, for each i = 0, 1, ..., r-l, the (l + i)-th person from the west will stand the (r - i)-th from the west after the operation, facing east if he/she is facing west now, and vice versa.
What is the maximum possible number of happy people you can have?
Constraints
* N is an integer satisfying 1 \leq N \leq 10^5.
* K is an integer satisfying 1 \leq K \leq 10^5.
* |S| = N
* Each character of S is `L` or `R`.
Input
Input is given from Standard Input in the following format:
N K
S
Output
Print the maximum possible number of happy people after at most K operations.
Examples
Input
6 1
LRLRRL
Output
3
Input
13 3
LRRLRLRRLRLLR
Output
9
Input
10 1
LLLLLRRRRR
Output
9
Input
9 2
RRRLRLRLL
Output
7 | instruction | 0 | 59,454 | 14 | 118,908 |
"Correct Solution:
```
n,k=list(map(int,input().split()))
s=list(input())
print(min(n-1,sum([s[i]==s[i+1] for i in range(n-1)])+k*2))
``` | output | 1 | 59,454 | 14 | 118,909 |
Provide a correct Python 3 solution for this coding contest problem.
There are N people standing in a queue from west to east.
Given is a string S of length N representing the directions of the people. The i-th person from the west is facing west if the i-th character of S is `L`, and east if that character of S is `R`.
A person is happy if the person in front of him/her is facing the same direction. If no person is standing in front of a person, however, he/she is not happy.
You can perform the following operation any number of times between 0 and K (inclusive):
Operation: Choose integers l and r such that 1 \leq l \leq r \leq N, and rotate by 180 degrees the part of the queue: the l-th, (l+1)-th, ..., r-th persons. That is, for each i = 0, 1, ..., r-l, the (l + i)-th person from the west will stand the (r - i)-th from the west after the operation, facing east if he/she is facing west now, and vice versa.
What is the maximum possible number of happy people you can have?
Constraints
* N is an integer satisfying 1 \leq N \leq 10^5.
* K is an integer satisfying 1 \leq K \leq 10^5.
* |S| = N
* Each character of S is `L` or `R`.
Input
Input is given from Standard Input in the following format:
N K
S
Output
Print the maximum possible number of happy people after at most K operations.
Examples
Input
6 1
LRLRRL
Output
3
Input
13 3
LRRLRLRRLRLLR
Output
9
Input
10 1
LLLLLRRRRR
Output
9
Input
9 2
RRRLRLRLL
Output
7 | instruction | 0 | 59,455 | 14 | 118,910 |
"Correct Solution:
```
N, K = [int(x) for x in input().split()]
S = input()
cnt = 0
for i in range(len(S)-1):
cnt += S[i] == S[i+1]
print(min(cnt+ 2*K, N-1))
``` | output | 1 | 59,455 | 14 | 118,911 |
Provide a correct Python 3 solution for this coding contest problem.
There are N people standing in a queue from west to east.
Given is a string S of length N representing the directions of the people. The i-th person from the west is facing west if the i-th character of S is `L`, and east if that character of S is `R`.
A person is happy if the person in front of him/her is facing the same direction. If no person is standing in front of a person, however, he/she is not happy.
You can perform the following operation any number of times between 0 and K (inclusive):
Operation: Choose integers l and r such that 1 \leq l \leq r \leq N, and rotate by 180 degrees the part of the queue: the l-th, (l+1)-th, ..., r-th persons. That is, for each i = 0, 1, ..., r-l, the (l + i)-th person from the west will stand the (r - i)-th from the west after the operation, facing east if he/she is facing west now, and vice versa.
What is the maximum possible number of happy people you can have?
Constraints
* N is an integer satisfying 1 \leq N \leq 10^5.
* K is an integer satisfying 1 \leq K \leq 10^5.
* |S| = N
* Each character of S is `L` or `R`.
Input
Input is given from Standard Input in the following format:
N K
S
Output
Print the maximum possible number of happy people after at most K operations.
Examples
Input
6 1
LRLRRL
Output
3
Input
13 3
LRRLRLRRLRLLR
Output
9
Input
10 1
LLLLLRRRRR
Output
9
Input
9 2
RRRLRLRLL
Output
7 | instruction | 0 | 59,456 | 14 | 118,912 |
"Correct Solution:
```
n, k = map(int, input().split())
s = input()
cnt = 0
for i, j in zip(s, s[1:]):
if i == j:
cnt += 1
ans = min(n-1, cnt + 2*k)
print(ans)
``` | output | 1 | 59,456 | 14 | 118,913 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N people standing in a queue from west to east.
Given is a string S of length N representing the directions of the people. The i-th person from the west is facing west if the i-th character of S is `L`, and east if that character of S is `R`.
A person is happy if the person in front of him/her is facing the same direction. If no person is standing in front of a person, however, he/she is not happy.
You can perform the following operation any number of times between 0 and K (inclusive):
Operation: Choose integers l and r such that 1 \leq l \leq r \leq N, and rotate by 180 degrees the part of the queue: the l-th, (l+1)-th, ..., r-th persons. That is, for each i = 0, 1, ..., r-l, the (l + i)-th person from the west will stand the (r - i)-th from the west after the operation, facing east if he/she is facing west now, and vice versa.
What is the maximum possible number of happy people you can have?
Constraints
* N is an integer satisfying 1 \leq N \leq 10^5.
* K is an integer satisfying 1 \leq K \leq 10^5.
* |S| = N
* Each character of S is `L` or `R`.
Input
Input is given from Standard Input in the following format:
N K
S
Output
Print the maximum possible number of happy people after at most K operations.
Examples
Input
6 1
LRLRRL
Output
3
Input
13 3
LRRLRLRRLRLLR
Output
9
Input
10 1
LLLLLRRRRR
Output
9
Input
9 2
RRRLRLRLL
Output
7
Submitted Solution:
```
N,K = map(int,input().split())
S = input()
count=0
for i in range(N-1):
if S[i]==S[i+1]:
count+=1
print(min(N-1, count+2*K))
``` | instruction | 0 | 59,457 | 14 | 118,914 |
Yes | output | 1 | 59,457 | 14 | 118,915 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N people standing in a queue from west to east.
Given is a string S of length N representing the directions of the people. The i-th person from the west is facing west if the i-th character of S is `L`, and east if that character of S is `R`.
A person is happy if the person in front of him/her is facing the same direction. If no person is standing in front of a person, however, he/she is not happy.
You can perform the following operation any number of times between 0 and K (inclusive):
Operation: Choose integers l and r such that 1 \leq l \leq r \leq N, and rotate by 180 degrees the part of the queue: the l-th, (l+1)-th, ..., r-th persons. That is, for each i = 0, 1, ..., r-l, the (l + i)-th person from the west will stand the (r - i)-th from the west after the operation, facing east if he/she is facing west now, and vice versa.
What is the maximum possible number of happy people you can have?
Constraints
* N is an integer satisfying 1 \leq N \leq 10^5.
* K is an integer satisfying 1 \leq K \leq 10^5.
* |S| = N
* Each character of S is `L` or `R`.
Input
Input is given from Standard Input in the following format:
N K
S
Output
Print the maximum possible number of happy people after at most K operations.
Examples
Input
6 1
LRLRRL
Output
3
Input
13 3
LRRLRLRRLRLLR
Output
9
Input
10 1
LLLLLRRRRR
Output
9
Input
9 2
RRRLRLRLL
Output
7
Submitted Solution:
```
N, K = map(int, input().split())
S = input()
c = 0
for i in range(1, N):
if S[i] == S[i - 1]:
c += 1
print(min(N - 1, c + K * 2))
``` | instruction | 0 | 59,458 | 14 | 118,916 |
Yes | output | 1 | 59,458 | 14 | 118,917 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N people standing in a queue from west to east.
Given is a string S of length N representing the directions of the people. The i-th person from the west is facing west if the i-th character of S is `L`, and east if that character of S is `R`.
A person is happy if the person in front of him/her is facing the same direction. If no person is standing in front of a person, however, he/she is not happy.
You can perform the following operation any number of times between 0 and K (inclusive):
Operation: Choose integers l and r such that 1 \leq l \leq r \leq N, and rotate by 180 degrees the part of the queue: the l-th, (l+1)-th, ..., r-th persons. That is, for each i = 0, 1, ..., r-l, the (l + i)-th person from the west will stand the (r - i)-th from the west after the operation, facing east if he/she is facing west now, and vice versa.
What is the maximum possible number of happy people you can have?
Constraints
* N is an integer satisfying 1 \leq N \leq 10^5.
* K is an integer satisfying 1 \leq K \leq 10^5.
* |S| = N
* Each character of S is `L` or `R`.
Input
Input is given from Standard Input in the following format:
N K
S
Output
Print the maximum possible number of happy people after at most K operations.
Examples
Input
6 1
LRLRRL
Output
3
Input
13 3
LRRLRLRRLRLLR
Output
9
Input
10 1
LLLLLRRRRR
Output
9
Input
9 2
RRRLRLRLL
Output
7
Submitted Solution:
```
n, k = map(int, input().split())
s = input()
cnt = 0
for i in range(1, n):
if s[i-1]==s[i]: cnt+=1
print(min(n-1, cnt+2*k))
``` | instruction | 0 | 59,459 | 14 | 118,918 |
Yes | output | 1 | 59,459 | 14 | 118,919 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N people standing in a queue from west to east.
Given is a string S of length N representing the directions of the people. The i-th person from the west is facing west if the i-th character of S is `L`, and east if that character of S is `R`.
A person is happy if the person in front of him/her is facing the same direction. If no person is standing in front of a person, however, he/she is not happy.
You can perform the following operation any number of times between 0 and K (inclusive):
Operation: Choose integers l and r such that 1 \leq l \leq r \leq N, and rotate by 180 degrees the part of the queue: the l-th, (l+1)-th, ..., r-th persons. That is, for each i = 0, 1, ..., r-l, the (l + i)-th person from the west will stand the (r - i)-th from the west after the operation, facing east if he/she is facing west now, and vice versa.
What is the maximum possible number of happy people you can have?
Constraints
* N is an integer satisfying 1 \leq N \leq 10^5.
* K is an integer satisfying 1 \leq K \leq 10^5.
* |S| = N
* Each character of S is `L` or `R`.
Input
Input is given from Standard Input in the following format:
N K
S
Output
Print the maximum possible number of happy people after at most K operations.
Examples
Input
6 1
LRLRRL
Output
3
Input
13 3
LRRLRLRRLRLLR
Output
9
Input
10 1
LLLLLRRRRR
Output
9
Input
9 2
RRRLRLRLL
Output
7
Submitted Solution:
```
n,k=map(int,input().split())
s=input()
cnt=0
for i in range(n-1):
if s[i]!=s[i+1]:
cnt+=1
p=min(n-1,n-1-cnt+k*2)
print(p)
``` | instruction | 0 | 59,460 | 14 | 118,920 |
Yes | output | 1 | 59,460 | 14 | 118,921 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N people standing in a queue from west to east.
Given is a string S of length N representing the directions of the people. The i-th person from the west is facing west if the i-th character of S is `L`, and east if that character of S is `R`.
A person is happy if the person in front of him/her is facing the same direction. If no person is standing in front of a person, however, he/she is not happy.
You can perform the following operation any number of times between 0 and K (inclusive):
Operation: Choose integers l and r such that 1 \leq l \leq r \leq N, and rotate by 180 degrees the part of the queue: the l-th, (l+1)-th, ..., r-th persons. That is, for each i = 0, 1, ..., r-l, the (l + i)-th person from the west will stand the (r - i)-th from the west after the operation, facing east if he/she is facing west now, and vice versa.
What is the maximum possible number of happy people you can have?
Constraints
* N is an integer satisfying 1 \leq N \leq 10^5.
* K is an integer satisfying 1 \leq K \leq 10^5.
* |S| = N
* Each character of S is `L` or `R`.
Input
Input is given from Standard Input in the following format:
N K
S
Output
Print the maximum possible number of happy people after at most K operations.
Examples
Input
6 1
LRLRRL
Output
3
Input
13 3
LRRLRLRRLRLLR
Output
9
Input
10 1
LLLLLRRRRR
Output
9
Input
9 2
RRRLRLRLL
Output
7
Submitted Solution:
```
n, k = [int(i) for i in input().split()]
s = list(input())
c, r, l = 0, 0, 0
if s[0] == 'L':
l = 1
if s[-1] == 'R':
r = 1
for i in range(n-1):
if s[i] == 'R' and s[i+1] == 'L':
c += 1
if c - k >= 0:
c -= k
else:
c = 0
r = 0
print(n - r - l - 2*c)
``` | instruction | 0 | 59,461 | 14 | 118,922 |
No | output | 1 | 59,461 | 14 | 118,923 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N people standing in a queue from west to east.
Given is a string S of length N representing the directions of the people. The i-th person from the west is facing west if the i-th character of S is `L`, and east if that character of S is `R`.
A person is happy if the person in front of him/her is facing the same direction. If no person is standing in front of a person, however, he/she is not happy.
You can perform the following operation any number of times between 0 and K (inclusive):
Operation: Choose integers l and r such that 1 \leq l \leq r \leq N, and rotate by 180 degrees the part of the queue: the l-th, (l+1)-th, ..., r-th persons. That is, for each i = 0, 1, ..., r-l, the (l + i)-th person from the west will stand the (r - i)-th from the west after the operation, facing east if he/she is facing west now, and vice versa.
What is the maximum possible number of happy people you can have?
Constraints
* N is an integer satisfying 1 \leq N \leq 10^5.
* K is an integer satisfying 1 \leq K \leq 10^5.
* |S| = N
* Each character of S is `L` or `R`.
Input
Input is given from Standard Input in the following format:
N K
S
Output
Print the maximum possible number of happy people after at most K operations.
Examples
Input
6 1
LRLRRL
Output
3
Input
13 3
LRRLRLRRLRLLR
Output
9
Input
10 1
LLLLLRRRRR
Output
9
Input
9 2
RRRLRLRLL
Output
7
Submitted Solution:
```
n, k = map(int, input().split())
s = input()
a = []
count = 1
for i in range(n - 1):
if s[i] != s[i + 1]:
a.append(count)
count = 1
else:
count += 1
a.append(count)
b = []
for i in range(len(a)):
if i == 0:
b.append(a[i] + a[i + 1])
elif i == len(a) - 1:
b.append(a[i - 1] + a[i])
else:
b.append(a[i - 1] + a[i] + a[i + 1])
b = sorted(b, reverse=True)
ans = 0
for i in range(k):
ans += b[i] - 1
print(ans)
``` | instruction | 0 | 59,462 | 14 | 118,924 |
No | output | 1 | 59,462 | 14 | 118,925 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N people standing in a queue from west to east.
Given is a string S of length N representing the directions of the people. The i-th person from the west is facing west if the i-th character of S is `L`, and east if that character of S is `R`.
A person is happy if the person in front of him/her is facing the same direction. If no person is standing in front of a person, however, he/she is not happy.
You can perform the following operation any number of times between 0 and K (inclusive):
Operation: Choose integers l and r such that 1 \leq l \leq r \leq N, and rotate by 180 degrees the part of the queue: the l-th, (l+1)-th, ..., r-th persons. That is, for each i = 0, 1, ..., r-l, the (l + i)-th person from the west will stand the (r - i)-th from the west after the operation, facing east if he/she is facing west now, and vice versa.
What is the maximum possible number of happy people you can have?
Constraints
* N is an integer satisfying 1 \leq N \leq 10^5.
* K is an integer satisfying 1 \leq K \leq 10^5.
* |S| = N
* Each character of S is `L` or `R`.
Input
Input is given from Standard Input in the following format:
N K
S
Output
Print the maximum possible number of happy people after at most K operations.
Examples
Input
6 1
LRLRRL
Output
3
Input
13 3
LRRLRLRRLRLLR
Output
9
Input
10 1
LLLLLRRRRR
Output
9
Input
9 2
RRRLRLRLL
Output
7
Submitted Solution:
```
N,K= map(int,input().split())
s = [str(i) for i in input()]
LR = 0
RL = 0
tmp = 0
i,j = 0,0
for m in range(K):
t_i,t_j = 0,0
f = 0
for k in range(N-1):
si = s[k:k+2]
if "".join(si) == "LR":
LR = 1
if RL == 0:
i = k+1
else:
j = k
if "".join(si) == "RL":
RL = 1
if LR == 0:
i = k+1
else:
j = k
if LR == 1 and LR == 1:
if tmp == 0:
t_i = i
t_j = j
elif i-j >= tmp:
t_i = i
t_j = j
LR = 0
RL = 0
if t_j == 0:
t_i = i
t_j = N-1
for l in range(t_i, t_j+1,1):
if s[l] == "L":
s[l] = "R"
else:
s[l] = "L"
c = 0
L = 0
R = 0
t = 0
for i in range(N):
if s[i] == "L" and R == 1:
if t>0:
c += t-1
t = 0
R = 0
if s[i] == "R" and L == 1:
if t>0:
c += t-1
t = 0
L = 0
if s[i] == "L" and R == 0:
t+=1
L = 1
if s[i] == "R" and L == 0:
t += 1
R = 1
if i == N-1:
if t>0:
c+= t-1
print(c)
``` | instruction | 0 | 59,463 | 14 | 118,926 |
No | output | 1 | 59,463 | 14 | 118,927 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N people standing in a queue from west to east.
Given is a string S of length N representing the directions of the people. The i-th person from the west is facing west if the i-th character of S is `L`, and east if that character of S is `R`.
A person is happy if the person in front of him/her is facing the same direction. If no person is standing in front of a person, however, he/she is not happy.
You can perform the following operation any number of times between 0 and K (inclusive):
Operation: Choose integers l and r such that 1 \leq l \leq r \leq N, and rotate by 180 degrees the part of the queue: the l-th, (l+1)-th, ..., r-th persons. That is, for each i = 0, 1, ..., r-l, the (l + i)-th person from the west will stand the (r - i)-th from the west after the operation, facing east if he/she is facing west now, and vice versa.
What is the maximum possible number of happy people you can have?
Constraints
* N is an integer satisfying 1 \leq N \leq 10^5.
* K is an integer satisfying 1 \leq K \leq 10^5.
* |S| = N
* Each character of S is `L` or `R`.
Input
Input is given from Standard Input in the following format:
N K
S
Output
Print the maximum possible number of happy people after at most K operations.
Examples
Input
6 1
LRLRRL
Output
3
Input
13 3
LRRLRLRRLRLLR
Output
9
Input
10 1
LLLLLRRRRR
Output
9
Input
9 2
RRRLRLRLL
Output
7
Submitted Solution:
```
N,K = map(int,input().split(' '))
S = input()
previous_idx = 0
if S[0] == 'L':
search_s = 'R'
non_search_s = 'L'
else:
search_s = 'L'
non_search_s = 'R'
flag = False
i = 0
count_s = 0
new_S = ''
previous_s = S[0]
while K != 0 and i != N:
if previous_s != S[i]:
if previous_s == search_s:
#new_S += non_search_s*count_s
K -= 1
#else:
#new_S += non_search_s*count_s
previous_s = S[i]
#count_s = 1
#count_s += 1
#if i+1 == N:
# flag =True
#new_S += non_search_s*count_s
i += 1
if K > 0:
print(N-1)
else:
new_S += non_search_s*(i-1)
if not flag:
new_S += S[i-1:N]
print(new_S)
count_s = 0
previous_s = new_S[0]
for i in range(1,N):
if previous_s == new_S[i]:
count_s +=1
else:
previous_s = new_S[i]
print(count_s)
``` | instruction | 0 | 59,464 | 14 | 118,928 |
No | output | 1 | 59,464 | 14 | 118,929 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hilbert's Hotel is a very unusual hotel since the number of rooms is infinite! In fact, there is exactly one room for every integer, including zero and negative integers. Even stranger, the hotel is currently at full capacity, meaning there is exactly one guest in every room. The hotel's manager, David Hilbert himself, decides he wants to shuffle the guests around because he thinks this will create a vacancy (a room without a guest).
For any integer k and positive integer n, let kmod n denote the remainder when k is divided by n. More formally, r=kmod n is the smallest non-negative integer such that k-r is divisible by n. It always holds that 0≤ kmod n≤ n-1. For example, 100mod 12=4 and (-1337)mod 3=1.
Then the shuffling works as follows. There is an array of n integers a_0,a_1,…,a_{n-1}. Then for each integer k, the guest in room k is moved to room number k+a_{kmod n}.
After this shuffling process, determine if there is still exactly one guest assigned to each room. That is, there are no vacancies or rooms with multiple guests.
Input
Each test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2⋅ 10^5) — the length of the array.
The second line of each test case contains n integers a_0,a_1,…,a_{n-1} (-10^9≤ a_i≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Output
For each test case, output a single line containing "YES" if there is exactly one guest assigned to each room after the shuffling process, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1
14
2
1 -1
4
5 5 5 1
3
3 2 1
2
0 1
5
-239 -2 -100 -3 -11
Output
YES
YES
YES
NO
NO
YES
Note
In the first test case, every guest is shifted by 14 rooms, so the assignment is still unique.
In the second test case, even guests move to the right by 1 room, and odd guests move to the left by 1 room. We can show that the assignment is still unique.
In the third test case, every fourth guest moves to the right by 1 room, and the other guests move to the right by 5 rooms. We can show that the assignment is still unique.
In the fourth test case, guests 0 and 1 are both assigned to room 3.
In the fifth test case, guests 1 and 2 are both assigned to room 2. | instruction | 0 | 59,866 | 14 | 119,732 |
Tags: math, number theory, sortings
Correct Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
li = [0]*n
for i in range(n):
li[(i+a[i])%n] += 1
for i in li:
if i!=1:
print('NO')
break
else:
print('YES')
``` | output | 1 | 59,866 | 14 | 119,733 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hilbert's Hotel is a very unusual hotel since the number of rooms is infinite! In fact, there is exactly one room for every integer, including zero and negative integers. Even stranger, the hotel is currently at full capacity, meaning there is exactly one guest in every room. The hotel's manager, David Hilbert himself, decides he wants to shuffle the guests around because he thinks this will create a vacancy (a room without a guest).
For any integer k and positive integer n, let kmod n denote the remainder when k is divided by n. More formally, r=kmod n is the smallest non-negative integer such that k-r is divisible by n. It always holds that 0≤ kmod n≤ n-1. For example, 100mod 12=4 and (-1337)mod 3=1.
Then the shuffling works as follows. There is an array of n integers a_0,a_1,…,a_{n-1}. Then for each integer k, the guest in room k is moved to room number k+a_{kmod n}.
After this shuffling process, determine if there is still exactly one guest assigned to each room. That is, there are no vacancies or rooms with multiple guests.
Input
Each test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2⋅ 10^5) — the length of the array.
The second line of each test case contains n integers a_0,a_1,…,a_{n-1} (-10^9≤ a_i≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Output
For each test case, output a single line containing "YES" if there is exactly one guest assigned to each room after the shuffling process, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1
14
2
1 -1
4
5 5 5 1
3
3 2 1
2
0 1
5
-239 -2 -100 -3 -11
Output
YES
YES
YES
NO
NO
YES
Note
In the first test case, every guest is shifted by 14 rooms, so the assignment is still unique.
In the second test case, even guests move to the right by 1 room, and odd guests move to the left by 1 room. We can show that the assignment is still unique.
In the third test case, every fourth guest moves to the right by 1 room, and the other guests move to the right by 5 rooms. We can show that the assignment is still unique.
In the fourth test case, guests 0 and 1 are both assigned to room 3.
In the fifth test case, guests 1 and 2 are both assigned to room 2. | instruction | 0 | 59,867 | 14 | 119,734 |
Tags: math, number theory, sortings
Correct Solution:
```
import math
import sys
input = sys.stdin.readline
t=int(input())
for i in range(t):
n=int(input())
arr=list(map(int,input().split()))
ans=[0]*n
for j in range(n):
ans[(j+arr[j])%n]+=1
f=True
for j in range(n):
if ans[j]!=1:
print("NO")
f=False
break
if f:
print("YES")
``` | output | 1 | 59,867 | 14 | 119,735 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hilbert's Hotel is a very unusual hotel since the number of rooms is infinite! In fact, there is exactly one room for every integer, including zero and negative integers. Even stranger, the hotel is currently at full capacity, meaning there is exactly one guest in every room. The hotel's manager, David Hilbert himself, decides he wants to shuffle the guests around because he thinks this will create a vacancy (a room without a guest).
For any integer k and positive integer n, let kmod n denote the remainder when k is divided by n. More formally, r=kmod n is the smallest non-negative integer such that k-r is divisible by n. It always holds that 0≤ kmod n≤ n-1. For example, 100mod 12=4 and (-1337)mod 3=1.
Then the shuffling works as follows. There is an array of n integers a_0,a_1,…,a_{n-1}. Then for each integer k, the guest in room k is moved to room number k+a_{kmod n}.
After this shuffling process, determine if there is still exactly one guest assigned to each room. That is, there are no vacancies or rooms with multiple guests.
Input
Each test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2⋅ 10^5) — the length of the array.
The second line of each test case contains n integers a_0,a_1,…,a_{n-1} (-10^9≤ a_i≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Output
For each test case, output a single line containing "YES" if there is exactly one guest assigned to each room after the shuffling process, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1
14
2
1 -1
4
5 5 5 1
3
3 2 1
2
0 1
5
-239 -2 -100 -3 -11
Output
YES
YES
YES
NO
NO
YES
Note
In the first test case, every guest is shifted by 14 rooms, so the assignment is still unique.
In the second test case, even guests move to the right by 1 room, and odd guests move to the left by 1 room. We can show that the assignment is still unique.
In the third test case, every fourth guest moves to the right by 1 room, and the other guests move to the right by 5 rooms. We can show that the assignment is still unique.
In the fourth test case, guests 0 and 1 are both assigned to room 3.
In the fifth test case, guests 1 and 2 are both assigned to room 2. | instruction | 0 | 59,868 | 14 | 119,736 |
Tags: math, number theory, sortings
Correct Solution:
```
def solve(n,s):
if n == 1:
return('YES')
a = [i for i in range(n)]
for j in range(n):
a[j] = (a[j] + s[j])%n
if len(set(a)) != len(a):
return ("NO")
else:
return("YES")
t = int(input())
for i in range(t):
n = int(input())
s = list(map(int,input().split()))
print(solve(n,s))
``` | output | 1 | 59,868 | 14 | 119,737 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hilbert's Hotel is a very unusual hotel since the number of rooms is infinite! In fact, there is exactly one room for every integer, including zero and negative integers. Even stranger, the hotel is currently at full capacity, meaning there is exactly one guest in every room. The hotel's manager, David Hilbert himself, decides he wants to shuffle the guests around because he thinks this will create a vacancy (a room without a guest).
For any integer k and positive integer n, let kmod n denote the remainder when k is divided by n. More formally, r=kmod n is the smallest non-negative integer such that k-r is divisible by n. It always holds that 0≤ kmod n≤ n-1. For example, 100mod 12=4 and (-1337)mod 3=1.
Then the shuffling works as follows. There is an array of n integers a_0,a_1,…,a_{n-1}. Then for each integer k, the guest in room k is moved to room number k+a_{kmod n}.
After this shuffling process, determine if there is still exactly one guest assigned to each room. That is, there are no vacancies or rooms with multiple guests.
Input
Each test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2⋅ 10^5) — the length of the array.
The second line of each test case contains n integers a_0,a_1,…,a_{n-1} (-10^9≤ a_i≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Output
For each test case, output a single line containing "YES" if there is exactly one guest assigned to each room after the shuffling process, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1
14
2
1 -1
4
5 5 5 1
3
3 2 1
2
0 1
5
-239 -2 -100 -3 -11
Output
YES
YES
YES
NO
NO
YES
Note
In the first test case, every guest is shifted by 14 rooms, so the assignment is still unique.
In the second test case, even guests move to the right by 1 room, and odd guests move to the left by 1 room. We can show that the assignment is still unique.
In the third test case, every fourth guest moves to the right by 1 room, and the other guests move to the right by 5 rooms. We can show that the assignment is still unique.
In the fourth test case, guests 0 and 1 are both assigned to room 3.
In the fifth test case, guests 1 and 2 are both assigned to room 2. | instruction | 0 | 59,869 | 14 | 119,738 |
Tags: math, number theory, sortings
Correct Solution:
```
t=int(input())
from copy import deepcopy
for _ in range(t):
n=int(input())
a=list(map(int,input().split()))
hashmap={}
for i in range(0,len(a)):
# print(i)
a[i]=(a[i]+i)%n
if a[i] not in hashmap:
hashmap[a[i]]=0
hashmap[a[i]]+=1
flag=0
for i in hashmap:
if hashmap[i]>1:
flag=1
print("NO")
break
if flag==0:
print("YES")
``` | output | 1 | 59,869 | 14 | 119,739 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hilbert's Hotel is a very unusual hotel since the number of rooms is infinite! In fact, there is exactly one room for every integer, including zero and negative integers. Even stranger, the hotel is currently at full capacity, meaning there is exactly one guest in every room. The hotel's manager, David Hilbert himself, decides he wants to shuffle the guests around because he thinks this will create a vacancy (a room without a guest).
For any integer k and positive integer n, let kmod n denote the remainder when k is divided by n. More formally, r=kmod n is the smallest non-negative integer such that k-r is divisible by n. It always holds that 0≤ kmod n≤ n-1. For example, 100mod 12=4 and (-1337)mod 3=1.
Then the shuffling works as follows. There is an array of n integers a_0,a_1,…,a_{n-1}. Then for each integer k, the guest in room k is moved to room number k+a_{kmod n}.
After this shuffling process, determine if there is still exactly one guest assigned to each room. That is, there are no vacancies or rooms with multiple guests.
Input
Each test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2⋅ 10^5) — the length of the array.
The second line of each test case contains n integers a_0,a_1,…,a_{n-1} (-10^9≤ a_i≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Output
For each test case, output a single line containing "YES" if there is exactly one guest assigned to each room after the shuffling process, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1
14
2
1 -1
4
5 5 5 1
3
3 2 1
2
0 1
5
-239 -2 -100 -3 -11
Output
YES
YES
YES
NO
NO
YES
Note
In the first test case, every guest is shifted by 14 rooms, so the assignment is still unique.
In the second test case, even guests move to the right by 1 room, and odd guests move to the left by 1 room. We can show that the assignment is still unique.
In the third test case, every fourth guest moves to the right by 1 room, and the other guests move to the right by 5 rooms. We can show that the assignment is still unique.
In the fourth test case, guests 0 and 1 are both assigned to room 3.
In the fifth test case, guests 1 and 2 are both assigned to room 2. | instruction | 0 | 59,870 | 14 | 119,740 |
Tags: math, number theory, sortings
Correct Solution:
```
from _collections import defaultdict
vis = defaultdict(list)
for _ in range(int(input())):
n = int(input())
l = list(map(int, input().split()))
flag = True
vis = defaultdict(list)
for i in range(n):
c = (i + l[i]) % n
if not vis[c]:
vis[c] = 1
else:
flag = False
break
if flag:
print('YES')
else:
print('NO')
``` | output | 1 | 59,870 | 14 | 119,741 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hilbert's Hotel is a very unusual hotel since the number of rooms is infinite! In fact, there is exactly one room for every integer, including zero and negative integers. Even stranger, the hotel is currently at full capacity, meaning there is exactly one guest in every room. The hotel's manager, David Hilbert himself, decides he wants to shuffle the guests around because he thinks this will create a vacancy (a room without a guest).
For any integer k and positive integer n, let kmod n denote the remainder when k is divided by n. More formally, r=kmod n is the smallest non-negative integer such that k-r is divisible by n. It always holds that 0≤ kmod n≤ n-1. For example, 100mod 12=4 and (-1337)mod 3=1.
Then the shuffling works as follows. There is an array of n integers a_0,a_1,…,a_{n-1}. Then for each integer k, the guest in room k is moved to room number k+a_{kmod n}.
After this shuffling process, determine if there is still exactly one guest assigned to each room. That is, there are no vacancies or rooms with multiple guests.
Input
Each test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2⋅ 10^5) — the length of the array.
The second line of each test case contains n integers a_0,a_1,…,a_{n-1} (-10^9≤ a_i≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Output
For each test case, output a single line containing "YES" if there is exactly one guest assigned to each room after the shuffling process, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1
14
2
1 -1
4
5 5 5 1
3
3 2 1
2
0 1
5
-239 -2 -100 -3 -11
Output
YES
YES
YES
NO
NO
YES
Note
In the first test case, every guest is shifted by 14 rooms, so the assignment is still unique.
In the second test case, even guests move to the right by 1 room, and odd guests move to the left by 1 room. We can show that the assignment is still unique.
In the third test case, every fourth guest moves to the right by 1 room, and the other guests move to the right by 5 rooms. We can show that the assignment is still unique.
In the fourth test case, guests 0 and 1 are both assigned to room 3.
In the fifth test case, guests 1 and 2 are both assigned to room 2. | instruction | 0 | 59,871 | 14 | 119,742 |
Tags: math, number theory, sortings
Correct Solution:
```
from collections import defaultdict as dc
from heapq import *
import math
from bisect import bisect_left,bisect
#bisect gives x and p[x] is element greater than it and out of bound for last one
#p[x-1] gives equal or smaller and no error for any element.
import sys
from collections import deque as dq
from heapq import heapify,heappush,heappop
mod=10**9 +7
def inp():
p=int(input())
return p
def line():
p=list(map(int,input().split()))
return p
def read_mat():
n=inp()
a=[]
for i in range(n):
a.append(line())
return a
def digit(n):
s=str(n)
p=0
for i in s:
p+=(int(i))**2
return p
ans=0
def solve(a,n):
p=dc(int)
if n==1:
return "YES"
q=0
for i in range(n):
z=(i+a[i])%n
#print(z)
p[z]+=1
if p[z]>1:
return "NO"
return "YES"
for test in range(inp()):
n=inp()
a=line()
l=solve(a,n)
print(l)
``` | output | 1 | 59,871 | 14 | 119,743 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hilbert's Hotel is a very unusual hotel since the number of rooms is infinite! In fact, there is exactly one room for every integer, including zero and negative integers. Even stranger, the hotel is currently at full capacity, meaning there is exactly one guest in every room. The hotel's manager, David Hilbert himself, decides he wants to shuffle the guests around because he thinks this will create a vacancy (a room without a guest).
For any integer k and positive integer n, let kmod n denote the remainder when k is divided by n. More formally, r=kmod n is the smallest non-negative integer such that k-r is divisible by n. It always holds that 0≤ kmod n≤ n-1. For example, 100mod 12=4 and (-1337)mod 3=1.
Then the shuffling works as follows. There is an array of n integers a_0,a_1,…,a_{n-1}. Then for each integer k, the guest in room k is moved to room number k+a_{kmod n}.
After this shuffling process, determine if there is still exactly one guest assigned to each room. That is, there are no vacancies or rooms with multiple guests.
Input
Each test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2⋅ 10^5) — the length of the array.
The second line of each test case contains n integers a_0,a_1,…,a_{n-1} (-10^9≤ a_i≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Output
For each test case, output a single line containing "YES" if there is exactly one guest assigned to each room after the shuffling process, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1
14
2
1 -1
4
5 5 5 1
3
3 2 1
2
0 1
5
-239 -2 -100 -3 -11
Output
YES
YES
YES
NO
NO
YES
Note
In the first test case, every guest is shifted by 14 rooms, so the assignment is still unique.
In the second test case, even guests move to the right by 1 room, and odd guests move to the left by 1 room. We can show that the assignment is still unique.
In the third test case, every fourth guest moves to the right by 1 room, and the other guests move to the right by 5 rooms. We can show that the assignment is still unique.
In the fourth test case, guests 0 and 1 are both assigned to room 3.
In the fifth test case, guests 1 and 2 are both assigned to room 2. | instruction | 0 | 59,872 | 14 | 119,744 |
Tags: math, number theory, sortings
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
v=[0]*n
for i in range(len(l)):
l[i]%=n
for i in range(len(l)):
x=(i+l[i])%n
if not v[x]:
v[x]=1
else:
print('NO')
break
else:
print('YES')
``` | output | 1 | 59,872 | 14 | 119,745 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hilbert's Hotel is a very unusual hotel since the number of rooms is infinite! In fact, there is exactly one room for every integer, including zero and negative integers. Even stranger, the hotel is currently at full capacity, meaning there is exactly one guest in every room. The hotel's manager, David Hilbert himself, decides he wants to shuffle the guests around because he thinks this will create a vacancy (a room without a guest).
For any integer k and positive integer n, let kmod n denote the remainder when k is divided by n. More formally, r=kmod n is the smallest non-negative integer such that k-r is divisible by n. It always holds that 0≤ kmod n≤ n-1. For example, 100mod 12=4 and (-1337)mod 3=1.
Then the shuffling works as follows. There is an array of n integers a_0,a_1,…,a_{n-1}. Then for each integer k, the guest in room k is moved to room number k+a_{kmod n}.
After this shuffling process, determine if there is still exactly one guest assigned to each room. That is, there are no vacancies or rooms with multiple guests.
Input
Each test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2⋅ 10^5) — the length of the array.
The second line of each test case contains n integers a_0,a_1,…,a_{n-1} (-10^9≤ a_i≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Output
For each test case, output a single line containing "YES" if there is exactly one guest assigned to each room after the shuffling process, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1
14
2
1 -1
4
5 5 5 1
3
3 2 1
2
0 1
5
-239 -2 -100 -3 -11
Output
YES
YES
YES
NO
NO
YES
Note
In the first test case, every guest is shifted by 14 rooms, so the assignment is still unique.
In the second test case, even guests move to the right by 1 room, and odd guests move to the left by 1 room. We can show that the assignment is still unique.
In the third test case, every fourth guest moves to the right by 1 room, and the other guests move to the right by 5 rooms. We can show that the assignment is still unique.
In the fourth test case, guests 0 and 1 are both assigned to room 3.
In the fifth test case, guests 1 and 2 are both assigned to room 2. | instruction | 0 | 59,873 | 14 | 119,746 |
Tags: math, number theory, sortings
Correct Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
a = [(i+j)%n for i,j in enumerate(a)]
if len(set(a)) == n:
print('YES')
else:
print('NO')
``` | output | 1 | 59,873 | 14 | 119,747 |
Provide tags and a correct Python 2 solution for this coding contest problem.
Hilbert's Hotel is a very unusual hotel since the number of rooms is infinite! In fact, there is exactly one room for every integer, including zero and negative integers. Even stranger, the hotel is currently at full capacity, meaning there is exactly one guest in every room. The hotel's manager, David Hilbert himself, decides he wants to shuffle the guests around because he thinks this will create a vacancy (a room without a guest).
For any integer k and positive integer n, let kmod n denote the remainder when k is divided by n. More formally, r=kmod n is the smallest non-negative integer such that k-r is divisible by n. It always holds that 0≤ kmod n≤ n-1. For example, 100mod 12=4 and (-1337)mod 3=1.
Then the shuffling works as follows. There is an array of n integers a_0,a_1,…,a_{n-1}. Then for each integer k, the guest in room k is moved to room number k+a_{kmod n}.
After this shuffling process, determine if there is still exactly one guest assigned to each room. That is, there are no vacancies or rooms with multiple guests.
Input
Each test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2⋅ 10^5) — the length of the array.
The second line of each test case contains n integers a_0,a_1,…,a_{n-1} (-10^9≤ a_i≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Output
For each test case, output a single line containing "YES" if there is exactly one guest assigned to each room after the shuffling process, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1
14
2
1 -1
4
5 5 5 1
3
3 2 1
2
0 1
5
-239 -2 -100 -3 -11
Output
YES
YES
YES
NO
NO
YES
Note
In the first test case, every guest is shifted by 14 rooms, so the assignment is still unique.
In the second test case, even guests move to the right by 1 room, and odd guests move to the left by 1 room. We can show that the assignment is still unique.
In the third test case, every fourth guest moves to the right by 1 room, and the other guests move to the right by 5 rooms. We can show that the assignment is still unique.
In the fourth test case, guests 0 and 1 are both assigned to room 3.
In the fifth test case, guests 1 and 2 are both assigned to room 2. | instruction | 0 | 59,874 | 14 | 119,748 |
Tags: math, number theory, sortings
Correct Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
raw_input = stdin.readline
pr = stdout.write
def in_num():
return int(raw_input())
def in_arr():
return map(int,raw_input().split())
def pr_num(n):
stdout.write(str(n)+'\n')
def pr_arr(arr):
pr(' '.join(map(str,arr))+'\n')
# fast read function for total integer input
def inp():
# this function returns whole input of
# space/line seperated integers
# Use Ctrl+D to flush stdin.
return map(int,stdin.read().split())
range = xrange # not for python 3.0+
for t in range(input()):
n=in_num()
l=in_arr()
d=Counter()
f=0
for i in range(n):
temp=l[i]+i
if d[temp%n]:
f=1
break
d[temp%n]=1
if f:
pr('NO\n')
else:
pr('YES\n')
``` | output | 1 | 59,874 | 14 | 119,749 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n armchairs, numbered from 1 to n from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than n/2.
For some reason, you would like to tell people to move from their armchairs to some other ones. If the i-th armchair is occupied by someone and the j-th armchair is not, you can tell the person sitting in the i-th armchair to move to the j-th armchair. The time it takes a person to move from the i-th armchair to the j-th one is |i - j| minutes. You may perform this operation any number of times, but these operations must be done sequentially, i. e. you cannot tell a person to move until the person you asked to move in the last operation has finished moving to their destination armchair.
You want to achieve the following situation: every seat that was initially occupied must be free. What is the minimum time you need to do it?
Input
The first line contains one integer n (2 ≤ n ≤ 5000) — the number of armchairs.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 1). a_i = 1 means that the i-th armchair is initially occupied, a_i = 0 means that it is initially free. The number of occupied armchairs is at most n/2.
Output
Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free.
Examples
Input
7
1 0 0 1 0 0 1
Output
3
Input
6
1 1 1 0 0 0
Output
9
Input
5
0 0 0 0 0
Output
0
Note
In the first test, you can perform the following sequence:
1. ask a person to move from armchair 1 to armchair 2, it takes 1 minute;
2. ask a person to move from armchair 7 to armchair 6, it takes 1 minute;
3. ask a person to move from armchair 4 to armchair 5, it takes 1 minute.
In the second test, you can perform the following sequence:
1. ask a person to move from armchair 1 to armchair 4, it takes 3 minutes;
2. ask a person to move from armchair 2 to armchair 6, it takes 4 minutes;
3. ask a person to move from armchair 4 to armchair 5, it takes 1 minute;
4. ask a person to move from armchair 3 to armchair 4, it takes 1 minute.
In the third test, no seat is occupied so your goal is achieved instantly. | instruction | 0 | 59,975 | 14 | 119,950 |
Tags: dp, flows, graph matchings, greedy
Correct Solution:
```
n = int(input())
l = list(map(int, input().split()))
v1, v2 = [], []
for i in range(n):
if l[i] == 1:
v1.append(i)
else:
v2.append(i)
if len(v1) == 0:
print(0)
else:
a, b = len(v1), len(v2)
dp = [[10**9]*(b+1) for _ in range(a+1)]
for i in range(a+1):
dp[i][b] = 10**9
for i in range(b+1):
dp[a][i] = 0
for i in range(a-1, -1, -1):
for j in range(b-1, -1, -1):
dp[i][j] = min(dp[i+1][j+1] + abs(v1[i]-v2[j]), dp[i][j+1])
print(dp[0][0])
``` | output | 1 | 59,975 | 14 | 119,951 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n armchairs, numbered from 1 to n from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than n/2.
For some reason, you would like to tell people to move from their armchairs to some other ones. If the i-th armchair is occupied by someone and the j-th armchair is not, you can tell the person sitting in the i-th armchair to move to the j-th armchair. The time it takes a person to move from the i-th armchair to the j-th one is |i - j| minutes. You may perform this operation any number of times, but these operations must be done sequentially, i. e. you cannot tell a person to move until the person you asked to move in the last operation has finished moving to their destination armchair.
You want to achieve the following situation: every seat that was initially occupied must be free. What is the minimum time you need to do it?
Input
The first line contains one integer n (2 ≤ n ≤ 5000) — the number of armchairs.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 1). a_i = 1 means that the i-th armchair is initially occupied, a_i = 0 means that it is initially free. The number of occupied armchairs is at most n/2.
Output
Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free.
Examples
Input
7
1 0 0 1 0 0 1
Output
3
Input
6
1 1 1 0 0 0
Output
9
Input
5
0 0 0 0 0
Output
0
Note
In the first test, you can perform the following sequence:
1. ask a person to move from armchair 1 to armchair 2, it takes 1 minute;
2. ask a person to move from armchair 7 to armchair 6, it takes 1 minute;
3. ask a person to move from armchair 4 to armchair 5, it takes 1 minute.
In the second test, you can perform the following sequence:
1. ask a person to move from armchair 1 to armchair 4, it takes 3 minutes;
2. ask a person to move from armchair 2 to armchair 6, it takes 4 minutes;
3. ask a person to move from armchair 4 to armchair 5, it takes 1 minute;
4. ask a person to move from armchair 3 to armchair 4, it takes 1 minute.
In the third test, no seat is occupied so your goal is achieved instantly. | instruction | 0 | 59,976 | 14 | 119,952 |
Tags: dp, flows, graph matchings, greedy
Correct Solution:
```
import sys
input = sys.stdin.buffer.readline
import math
n=int(input())
arr=[int(x) for x in input().split()]
h=[]
v=[]
for i in range(n):
if arr[i]:
v.append(i)
else:
h.append(i)
hh=len(h)
vv=len(v)
dp=[[0 for j in range(hh+1)] for i in range(vv+1)]
for i in range(1,vv+1):
dp[i][0]=math.inf
for i in range(1,vv+1):
for j in range(1,hh+1):
dp[i][j]=min(dp[i-1][j-1]+abs(v[i-1]-h[j-1]),dp[i][j-1])
print(dp[vv][hh])
``` | output | 1 | 59,976 | 14 | 119,953 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n armchairs, numbered from 1 to n from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than n/2.
For some reason, you would like to tell people to move from their armchairs to some other ones. If the i-th armchair is occupied by someone and the j-th armchair is not, you can tell the person sitting in the i-th armchair to move to the j-th armchair. The time it takes a person to move from the i-th armchair to the j-th one is |i - j| minutes. You may perform this operation any number of times, but these operations must be done sequentially, i. e. you cannot tell a person to move until the person you asked to move in the last operation has finished moving to their destination armchair.
You want to achieve the following situation: every seat that was initially occupied must be free. What is the minimum time you need to do it?
Input
The first line contains one integer n (2 ≤ n ≤ 5000) — the number of armchairs.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 1). a_i = 1 means that the i-th armchair is initially occupied, a_i = 0 means that it is initially free. The number of occupied armchairs is at most n/2.
Output
Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free.
Examples
Input
7
1 0 0 1 0 0 1
Output
3
Input
6
1 1 1 0 0 0
Output
9
Input
5
0 0 0 0 0
Output
0
Note
In the first test, you can perform the following sequence:
1. ask a person to move from armchair 1 to armchair 2, it takes 1 minute;
2. ask a person to move from armchair 7 to armchair 6, it takes 1 minute;
3. ask a person to move from armchair 4 to armchair 5, it takes 1 minute.
In the second test, you can perform the following sequence:
1. ask a person to move from armchair 1 to armchair 4, it takes 3 minutes;
2. ask a person to move from armchair 2 to armchair 6, it takes 4 minutes;
3. ask a person to move from armchair 4 to armchair 5, it takes 1 minute;
4. ask a person to move from armchair 3 to armchair 4, it takes 1 minute.
In the third test, no seat is occupied so your goal is achieved instantly. | instruction | 0 | 59,977 | 14 | 119,954 |
Tags: dp, flows, graph matchings, greedy
Correct Solution:
```
import sys
import math
from itertools import *
from queue import LifoQueue
from collections import deque
def gcd(a,b):
if a==0:
return b
return gcd(b%a,a)
def powset(arr,length):
out=[]
for i in range(0,length+1):
for j in combinations(arr,i):
out.append(j)
return out
def perm(arr):
return list(permutations(arr))
n=int(input())
z=[]
o=[]
ans=0
l=[int(i) for i in input().split()]
for i in range(n):
if l[i]==1:
o.append(i)
else:
z.append(i)
z.sort()
o.sort()
zl=len(z)
ol=len(o)
if ol==0:
print(0)
elif ol==1:
print(1)
elif ol==zl:
s=0
for i in range(ol):
s+=abs(z[i]-o[i])
print(s)
else:
best=0
dp=[[float("inf") for i in range(ol)]for j in range(zl)]
for i in range(zl):
dp[i][-1]=abs(z[i]-o[-1])
for i in reversed(range(ol-1)):
best=dp[zl-ol+i+1][i+1]
for j in reversed(range(zl-ol+i+1)):
#dp[j][i]=abs(z[j]-o[i])+min([_[i+1] for _ in dp[j+1:]])
best=min(best,dp[j+1][i+1])
dp[j][i]=abs(z[j]-o[i])+best
print(min([_[0] for _ in dp]))
``` | output | 1 | 59,977 | 14 | 119,955 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.