message stringlengths 2 67k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 463 109k | cluster float64 19 19 | __index_level_0__ int64 926 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ilya is working for the company that constructs robots. Ilya writes programs for entertainment robots, and his current project is "Bob", a new-generation game robot. Ilya's boss wants to know his progress so far. Especially he is interested if Bob is better at playing different games than the previous model, "Alice".
So now Ilya wants to compare his robots' performance in a simple game called "1-2-3". This game is similar to the "Rock-Paper-Scissors" game: both robots secretly choose a number from the set {1, 2, 3} and say it at the same moment. If both robots choose the same number, then it's a draw and noone gets any points. But if chosen numbers are different, then one of the robots gets a point: 3 beats 2, 2 beats 1 and 1 beats 3.
Both robots' programs make them choose their numbers in such a way that their choice in (i + 1)-th game depends only on the numbers chosen by them in i-th game.
Ilya knows that the robots will play k games, Alice will choose number a in the first game, and Bob will choose b in the first game. He also knows both robots' programs and can tell what each robot will choose depending on their choices in previous game. Ilya doesn't want to wait until robots play all k games, so he asks you to predict the number of points they will have after the final game.
Input
The first line contains three numbers k, a, b (1 ≤ k ≤ 1018, 1 ≤ a, b ≤ 3).
Then 3 lines follow, i-th of them containing 3 numbers Ai, 1, Ai, 2, Ai, 3, where Ai, j represents Alice's choice in the game if Alice chose i in previous game and Bob chose j (1 ≤ Ai, j ≤ 3).
Then 3 lines follow, i-th of them containing 3 numbers Bi, 1, Bi, 2, Bi, 3, where Bi, j represents Bob's choice in the game if Alice chose i in previous game and Bob chose j (1 ≤ Bi, j ≤ 3).
Output
Print two numbers. First of them has to be equal to the number of points Alice will have, and second of them must be Bob's score after k games.
Examples
Input
10 2 1
1 1 1
1 1 1
1 1 1
2 2 2
2 2 2
2 2 2
Output
1 9
Input
8 1 1
2 2 1
3 3 1
3 1 3
1 1 1
2 1 1
1 2 3
Output
5 2
Input
5 1 1
1 2 2
2 2 2
2 2 2
1 2 2
2 2 2
2 2 2
Output
0 0
Note
In the second example game goes like this:
<image>
The fourth and the seventh game are won by Bob, the first game is draw and the rest are won by Alice.
Submitted Solution:
```
'''input
85 1 1
2 2 1
3 3 1
3 1 3
1 1 1
2 1 1
1 2 3
'''
def solve():
k, a, b = list(map(int, input().split()))
x = []
for i in range(3):
x.append(list(map(int, input().split())))
y = []
for i in range(3):
y.append(list(map(int, input().split())))
dp = [0]*200
for i in range(200):
if a > b:
dp[i] = 1
elif b > a:
dp[i] = 2
anext = x[a-1][b-1]
bnext = y[a-1][b-1]
a, b = anext, bnext
# print(dp[:85].count(1), dp[:85].count(2))
# print(dp)
# print(dp[81:])
if k < 80:
return dp[:k].count(1), dp[:k].count(2)
else:
mul = k//80
ans = [dp[:80].count(1)*mul, dp[:80].count(2)*mul]
ans[0] += dp[81:80 + k % 80 + 1].count(1)
ans[1] += dp[81:80 + k % 80 + 1].count(2)
return ans[0], ans[1]
res = solve()
print(res[0], res[1])
``` | instruction | 0 | 45,112 | 19 | 90,224 |
No | output | 1 | 45,112 | 19 | 90,225 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ilya is working for the company that constructs robots. Ilya writes programs for entertainment robots, and his current project is "Bob", a new-generation game robot. Ilya's boss wants to know his progress so far. Especially he is interested if Bob is better at playing different games than the previous model, "Alice".
So now Ilya wants to compare his robots' performance in a simple game called "1-2-3". This game is similar to the "Rock-Paper-Scissors" game: both robots secretly choose a number from the set {1, 2, 3} and say it at the same moment. If both robots choose the same number, then it's a draw and noone gets any points. But if chosen numbers are different, then one of the robots gets a point: 3 beats 2, 2 beats 1 and 1 beats 3.
Both robots' programs make them choose their numbers in such a way that their choice in (i + 1)-th game depends only on the numbers chosen by them in i-th game.
Ilya knows that the robots will play k games, Alice will choose number a in the first game, and Bob will choose b in the first game. He also knows both robots' programs and can tell what each robot will choose depending on their choices in previous game. Ilya doesn't want to wait until robots play all k games, so he asks you to predict the number of points they will have after the final game.
Input
The first line contains three numbers k, a, b (1 ≤ k ≤ 1018, 1 ≤ a, b ≤ 3).
Then 3 lines follow, i-th of them containing 3 numbers Ai, 1, Ai, 2, Ai, 3, where Ai, j represents Alice's choice in the game if Alice chose i in previous game and Bob chose j (1 ≤ Ai, j ≤ 3).
Then 3 lines follow, i-th of them containing 3 numbers Bi, 1, Bi, 2, Bi, 3, where Bi, j represents Bob's choice in the game if Alice chose i in previous game and Bob chose j (1 ≤ Bi, j ≤ 3).
Output
Print two numbers. First of them has to be equal to the number of points Alice will have, and second of them must be Bob's score after k games.
Examples
Input
10 2 1
1 1 1
1 1 1
1 1 1
2 2 2
2 2 2
2 2 2
Output
1 9
Input
8 1 1
2 2 1
3 3 1
3 1 3
1 1 1
2 1 1
1 2 3
Output
5 2
Input
5 1 1
1 2 2
2 2 2
2 2 2
1 2 2
2 2 2
2 2 2
Output
0 0
Note
In the second example game goes like this:
<image>
The fourth and the seventh game are won by Bob, the first game is draw and the rest are won by Alice.
Submitted Solution:
```
from math import floor
def kek(a, b):
if a == b:
return ([0, 0])
elif a == 3 and b == 1:
return ([0, 1])
elif a == 1 and b == 3:
return ([1, 0])
elif a == 1 and b == 2:
return ([0, 1])
elif a == 2 and b == 1:
return ([1, 0])
elif a == 2 and b == 3:
return ([0, 1])
elif a == 3 and b == 2:
return ([1, 0])
k, a1, b1 = map(int, input().split())
a, b = [], []
for i in range(3):
a.append([int(i) for i in input().split()])
for i in range(3):
b.append([int(i) for i in input().split()])
n, m = [], []
n.append([a1, b1])
m.append(kek(a1, b1))
i = 1
ansb, ansa = 0, 0
while i != k:
i += 1
a1, b1 = a[a1 - 1][b1 - 1], b[a1 - 1][b1 - 1]
t = [a1, b1]
if t not in n:
n.append([a1, b1])
m.append(kek(a1, b1))
m[-1][0] += m[-2][0]
m[-1][1] += m[-2][1]
else:
break
if i == k:
print(*m[-1])
else:
ansa, ansb = m[-1][0], m[-1][1]
i -= 1
for j in range(len(n)):
if n[j] == [a1, b1]:
t = j
break
ror = floor((k - i) / (len(n) - t))
i = i + (len(n) - t) * ror
if t != 0:
ansa += (m[-1][0] - m[t - 1][0]) * ror
ansb += (m[-1][1] - m[t - 1][1]) * ror
else:
ansa += (m[-1][0]) * ror
ansb += (m[-1][1]) * ror
# while i + len(n) - t <= k:
# if t != 0:
# ansa += m[-1][0] - m[t - 1][0]
# ansb += m[-1][1] - m[t - 1][1]
# else:
# ansa += m[-1][0]
# ansb += m[-1][1]
# i += len(n) - t
if k - i == 1:
tmp = kek(a1, b1)
ansa += tmp[0]
ansb += tmp[1]
else:
for j in range(k - i):
a1, b1 = a[a1 - 1][b1 - 1], b[a1 - 1][b1 - 1]
tmp = kek(a1, b1)
ansa += tmp[0]
ansb += tmp[1]
print(ansa, ansb)
``` | instruction | 0 | 45,113 | 19 | 90,226 |
No | output | 1 | 45,113 | 19 | 90,227 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ilya is working for the company that constructs robots. Ilya writes programs for entertainment robots, and his current project is "Bob", a new-generation game robot. Ilya's boss wants to know his progress so far. Especially he is interested if Bob is better at playing different games than the previous model, "Alice".
So now Ilya wants to compare his robots' performance in a simple game called "1-2-3". This game is similar to the "Rock-Paper-Scissors" game: both robots secretly choose a number from the set {1, 2, 3} and say it at the same moment. If both robots choose the same number, then it's a draw and noone gets any points. But if chosen numbers are different, then one of the robots gets a point: 3 beats 2, 2 beats 1 and 1 beats 3.
Both robots' programs make them choose their numbers in such a way that their choice in (i + 1)-th game depends only on the numbers chosen by them in i-th game.
Ilya knows that the robots will play k games, Alice will choose number a in the first game, and Bob will choose b in the first game. He also knows both robots' programs and can tell what each robot will choose depending on their choices in previous game. Ilya doesn't want to wait until robots play all k games, so he asks you to predict the number of points they will have after the final game.
Input
The first line contains three numbers k, a, b (1 ≤ k ≤ 1018, 1 ≤ a, b ≤ 3).
Then 3 lines follow, i-th of them containing 3 numbers Ai, 1, Ai, 2, Ai, 3, where Ai, j represents Alice's choice in the game if Alice chose i in previous game and Bob chose j (1 ≤ Ai, j ≤ 3).
Then 3 lines follow, i-th of them containing 3 numbers Bi, 1, Bi, 2, Bi, 3, where Bi, j represents Bob's choice in the game if Alice chose i in previous game and Bob chose j (1 ≤ Bi, j ≤ 3).
Output
Print two numbers. First of them has to be equal to the number of points Alice will have, and second of them must be Bob's score after k games.
Examples
Input
10 2 1
1 1 1
1 1 1
1 1 1
2 2 2
2 2 2
2 2 2
Output
1 9
Input
8 1 1
2 2 1
3 3 1
3 1 3
1 1 1
2 1 1
1 2 3
Output
5 2
Input
5 1 1
1 2 2
2 2 2
2 2 2
1 2 2
2 2 2
2 2 2
Output
0 0
Note
In the second example game goes like this:
<image>
The fourth and the seventh game are won by Bob, the first game is draw and the rest are won by Alice.
Submitted Solution:
```
k, a, b = map(int, input().split())
A = []
B = []
A.append([int(i) for i in input().split()])
A.append([int(i) for i in input().split()])
A.append([int(i) for i in input().split()])
B.append([int(i) for i in input().split()])
B.append([int(i) for i in input().split()])
B.append([int(i) for i in input().split()])
def wins(x, y):
if x == 0 and y == 2:
return 1, 0
if y == 0 and x == 2:
return 0, 1
if x > y:
return 1, 0
if x == y:
return 0, 0
return 0, 1
def cycle(a, b):
x1, y1 = A[a][b]-1, B[a][b]-1
res = wins(a, b)
ar = res[0]
br = res[1]
l = 1
while x1 != a and y1 != b:
res = wins(x1, y1)
ar += res[0]
br += res[1]
x1, y1 = A[x1][y1]-1, B[x1][y1]-1
l += 1
return ar, br, l
ar, br = 0, 0
visited = set()
a-=1; b-=1
visited.add((a, b))
res = wins(a, b)
ar += res[0]
br += res[1]
K = 2
a, b = A[a][b]-1, B[a][b]-1
while True:
if K > k:
break
if ((a,b)) in visited:
ca, cb, l = cycle(a, b)
# print(ca, cb, l)
ar += ((k-K)//l) * ca
br += ((k-K)//l) * cb
K += ((k-K)//l) * l
visited.clear()
continue
K += 1
visited.add((a,b))
res = wins(a, b)
ar += res[0]
br += res[1]
# print(a, b)
a, b = A[a][b]-1, B[a][b]-1
print(ar, br)
``` | instruction | 0 | 45,114 | 19 | 90,228 |
No | output | 1 | 45,114 | 19 | 90,229 |
Provide a correct Python 3 solution for this coding contest problem.
One of the games that uses the Hyakunin Isshu tag is "Buddhist turning". It is a simple game that uses only picture cards, so it is widely enjoyed. There are various derivative types of rules, but the shaved turn considered here is performed by N participants according to the following rules.
* Use a total of 100 cards, including 64 "men", 15 "boys", and 21 "princesses".
* Turn the bill over so that you can't see the picture and mix well to make a "bill pile".
* Draw one card from the first participant in order. After the Nth person, repeat from the first person.
* If the drawn card is a man, the person who draws will get the card.
* If the drawn card is a shaven, the person who draws puts all the cards he has, including that card, into the "field".
* If the drawn card is a princess, the person who draws gets all the cards in play, including that card.
* When there are no more cards in the bill pile, the game ends, and the person with the most cards wins.
Given the number of participants and the order of the cards piled up in the bill pile, the number of cards each participant has at the end of the game is arranged in ascending order, and the number of cards remaining in the field is shown. Create a program to output.
input
The input consists of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
c1c2 ... c100
Each dataset has two rows, and the first row is given the integer N (2 ≤ N ≤ 10) representing the number of participants. The next line is given a character string that represents the arrangement of the bills piled up in the bill pile. The letter ci represents the i-th drawn tag, where M is a man, S is a shaven, and L is a princess. There is no space between each character.
The number of datasets does not exceed 100.
output
For each data set, the sequence of the number of cards at the end of the game is output on one line. As the number of cards, the number of cards that each participant has is arranged in ascending order, and then the number of cards remaining in the field is output. Separate each number of bills with one blank. Do not print blanks at the end of the line.
Example
Input
2
SSSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
2
SSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMSL
5
MMMMMMSLSLLMMMSMMSLMMMLMMMMLSLLLLMLSMMLMMLLMSSSLMMMMLMLSMLMSMMMMMMMSMMMMMMLMMMMMSMMMLMMLMMMMMMMMMSSM
0
Output
42 58 0
0 100 0
0 0 3 10 59 28 | instruction | 0 | 45,305 | 19 | 90,610 |
"Correct Solution:
```
while True:
num = int(input())
if num == 0:
break
L = [0]*num
F = 0
cnt = 0
for i in input():
L[cnt] += 1
if i == "M":
pass
elif i == "S":
F += L[cnt]
L[cnt] = 0
else:
L[cnt] += F
F = 0
cnt += 1
cnt %= num
print(*sorted(L), F)
``` | output | 1 | 45,305 | 19 | 90,611 |
Provide a correct Python 3 solution for this coding contest problem.
One of the games that uses the Hyakunin Isshu tag is "Buddhist turning". It is a simple game that uses only picture cards, so it is widely enjoyed. There are various derivative types of rules, but the shaved turn considered here is performed by N participants according to the following rules.
* Use a total of 100 cards, including 64 "men", 15 "boys", and 21 "princesses".
* Turn the bill over so that you can't see the picture and mix well to make a "bill pile".
* Draw one card from the first participant in order. After the Nth person, repeat from the first person.
* If the drawn card is a man, the person who draws will get the card.
* If the drawn card is a shaven, the person who draws puts all the cards he has, including that card, into the "field".
* If the drawn card is a princess, the person who draws gets all the cards in play, including that card.
* When there are no more cards in the bill pile, the game ends, and the person with the most cards wins.
Given the number of participants and the order of the cards piled up in the bill pile, the number of cards each participant has at the end of the game is arranged in ascending order, and the number of cards remaining in the field is shown. Create a program to output.
input
The input consists of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
c1c2 ... c100
Each dataset has two rows, and the first row is given the integer N (2 ≤ N ≤ 10) representing the number of participants. The next line is given a character string that represents the arrangement of the bills piled up in the bill pile. The letter ci represents the i-th drawn tag, where M is a man, S is a shaven, and L is a princess. There is no space between each character.
The number of datasets does not exceed 100.
output
For each data set, the sequence of the number of cards at the end of the game is output on one line. As the number of cards, the number of cards that each participant has is arranged in ascending order, and then the number of cards remaining in the field is output. Separate each number of bills with one blank. Do not print blanks at the end of the line.
Example
Input
2
SSSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
2
SSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMSL
5
MMMMMMSLSLLMMMSMMSLMMMLMMMMLSLLLLMLSMMLMMLLMSSSLMMMMLMLSMLMSMMMMMMMSMMMMMMLMMMMMSMMMLMMLMMMMMMMMMSSM
0
Output
42 58 0
0 100 0
0 0 3 10 59 28 | instruction | 0 | 45,306 | 19 | 90,612 |
"Correct Solution:
```
# Aizu Problem 0280: The Outcome of Bonze
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
while True:
n = int(input())
if n == 0:
break
cards = [_ for _ in input().strip()]
players = [0] * n
table = 0
player = 0
for k in range(100):
card = cards[k]
if card == 'M':
players[player] += 1
elif card == 'S':
table += 1 + players[player]
players[player] = 0
elif card == 'L':
players[player] += 1 + table
table = 0
player = (player + 1) % n
players = sorted(players)
players.append(table)
print(' '.join([str(p) for p in players]))
``` | output | 1 | 45,306 | 19 | 90,613 |
Provide a correct Python 3 solution for this coding contest problem.
One of the games that uses the Hyakunin Isshu tag is "Buddhist turning". It is a simple game that uses only picture cards, so it is widely enjoyed. There are various derivative types of rules, but the shaved turn considered here is performed by N participants according to the following rules.
* Use a total of 100 cards, including 64 "men", 15 "boys", and 21 "princesses".
* Turn the bill over so that you can't see the picture and mix well to make a "bill pile".
* Draw one card from the first participant in order. After the Nth person, repeat from the first person.
* If the drawn card is a man, the person who draws will get the card.
* If the drawn card is a shaven, the person who draws puts all the cards he has, including that card, into the "field".
* If the drawn card is a princess, the person who draws gets all the cards in play, including that card.
* When there are no more cards in the bill pile, the game ends, and the person with the most cards wins.
Given the number of participants and the order of the cards piled up in the bill pile, the number of cards each participant has at the end of the game is arranged in ascending order, and the number of cards remaining in the field is shown. Create a program to output.
input
The input consists of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
c1c2 ... c100
Each dataset has two rows, and the first row is given the integer N (2 ≤ N ≤ 10) representing the number of participants. The next line is given a character string that represents the arrangement of the bills piled up in the bill pile. The letter ci represents the i-th drawn tag, where M is a man, S is a shaven, and L is a princess. There is no space between each character.
The number of datasets does not exceed 100.
output
For each data set, the sequence of the number of cards at the end of the game is output on one line. As the number of cards, the number of cards that each participant has is arranged in ascending order, and then the number of cards remaining in the field is output. Separate each number of bills with one blank. Do not print blanks at the end of the line.
Example
Input
2
SSSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
2
SSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMSL
5
MMMMMMSLSLLMMMSMMSLMMMLMMMMLSLLLLMLSMMLMMLLMSSSLMMMMLMLSMLMSMMMMMMMSMMMMMMLMMMMMSMMMLMMLMMMMMMMMMSSM
0
Output
42 58 0
0 100 0
0 0 3 10 59 28 | instruction | 0 | 45,307 | 19 | 90,614 |
"Correct Solution:
```
import sys
from itertools import cycle
f = sys.stdin
while True:
n = int(f.readline())
if n == 0:
break
c, hands, field = f.readline().strip(), [0] * n, 0
for player, ci in zip(cycle(range(n)), c):
if ci == 'S':
field += hands[player] + 1
hands[player] = 0
elif ci == 'L':
hands[player] += field + 1
field = 0
else:
hands[player] += 1
hands.sort()
print(' '.join(map(str, hands)), field)
``` | output | 1 | 45,307 | 19 | 90,615 |
Provide a correct Python 3 solution for this coding contest problem.
One of the games that uses the Hyakunin Isshu tag is "Buddhist turning". It is a simple game that uses only picture cards, so it is widely enjoyed. There are various derivative types of rules, but the shaved turn considered here is performed by N participants according to the following rules.
* Use a total of 100 cards, including 64 "men", 15 "boys", and 21 "princesses".
* Turn the bill over so that you can't see the picture and mix well to make a "bill pile".
* Draw one card from the first participant in order. After the Nth person, repeat from the first person.
* If the drawn card is a man, the person who draws will get the card.
* If the drawn card is a shaven, the person who draws puts all the cards he has, including that card, into the "field".
* If the drawn card is a princess, the person who draws gets all the cards in play, including that card.
* When there are no more cards in the bill pile, the game ends, and the person with the most cards wins.
Given the number of participants and the order of the cards piled up in the bill pile, the number of cards each participant has at the end of the game is arranged in ascending order, and the number of cards remaining in the field is shown. Create a program to output.
input
The input consists of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
c1c2 ... c100
Each dataset has two rows, and the first row is given the integer N (2 ≤ N ≤ 10) representing the number of participants. The next line is given a character string that represents the arrangement of the bills piled up in the bill pile. The letter ci represents the i-th drawn tag, where M is a man, S is a shaven, and L is a princess. There is no space between each character.
The number of datasets does not exceed 100.
output
For each data set, the sequence of the number of cards at the end of the game is output on one line. As the number of cards, the number of cards that each participant has is arranged in ascending order, and then the number of cards remaining in the field is output. Separate each number of bills with one blank. Do not print blanks at the end of the line.
Example
Input
2
SSSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
2
SSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMSL
5
MMMMMMSLSLLMMMSMMSLMMMLMMMMLSLLLLMLSMMLMMLLMSSSLMMMMLMLSMLMSMMMMMMMSMMMMMMLMMMMMSMMMLMMLMMMMMMMMMSSM
0
Output
42 58 0
0 100 0
0 0 3 10 59 28 | instruction | 0 | 45,308 | 19 | 90,616 |
"Correct Solution:
```
while True:
N = int(input())
if N==0:break
dataset = input()
mens = ["" for _ in range(N)]
i = 0
p = ""
while dataset:
if i == N: i = 0
card, dataset = dataset[0], dataset[1:]
if card == "M":
mens[i] += card
elif card == "S":
p += card + mens[i]
mens[i] = ""
else:
mens[i] += card + p
p = ""
i += 1
print(' '.join(map(str, sorted([len(m) for m in mens]))), len(p))
``` | output | 1 | 45,308 | 19 | 90,617 |
Provide a correct Python 3 solution for this coding contest problem.
One of the games that uses the Hyakunin Isshu tag is "Buddhist turning". It is a simple game that uses only picture cards, so it is widely enjoyed. There are various derivative types of rules, but the shaved turn considered here is performed by N participants according to the following rules.
* Use a total of 100 cards, including 64 "men", 15 "boys", and 21 "princesses".
* Turn the bill over so that you can't see the picture and mix well to make a "bill pile".
* Draw one card from the first participant in order. After the Nth person, repeat from the first person.
* If the drawn card is a man, the person who draws will get the card.
* If the drawn card is a shaven, the person who draws puts all the cards he has, including that card, into the "field".
* If the drawn card is a princess, the person who draws gets all the cards in play, including that card.
* When there are no more cards in the bill pile, the game ends, and the person with the most cards wins.
Given the number of participants and the order of the cards piled up in the bill pile, the number of cards each participant has at the end of the game is arranged in ascending order, and the number of cards remaining in the field is shown. Create a program to output.
input
The input consists of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
c1c2 ... c100
Each dataset has two rows, and the first row is given the integer N (2 ≤ N ≤ 10) representing the number of participants. The next line is given a character string that represents the arrangement of the bills piled up in the bill pile. The letter ci represents the i-th drawn tag, where M is a man, S is a shaven, and L is a princess. There is no space between each character.
The number of datasets does not exceed 100.
output
For each data set, the sequence of the number of cards at the end of the game is output on one line. As the number of cards, the number of cards that each participant has is arranged in ascending order, and then the number of cards remaining in the field is output. Separate each number of bills with one blank. Do not print blanks at the end of the line.
Example
Input
2
SSSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
2
SSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMSL
5
MMMMMMSLSLLMMMSMMSLMMMLMMMMLSLLLLMLSMMLMMLLMSSSLMMMMLMLSMLMSMMMMMMMSMMMMMMLMMMMMSMMMLMMLMMMMMMMMMSSM
0
Output
42 58 0
0 100 0
0 0 3 10 59 28 | instruction | 0 | 45,309 | 19 | 90,618 |
"Correct Solution:
```
while 1:
ba = 0
p = [0 for i in range(int(input()))]
if len(p) == 0:break
for i,v in enumerate(list(input())):
p[i%len(p)] += 1
if v == 'L':
p[i%len(p)] += ba
ba = 0
elif v== 'S':
ba += p[i%len(p)]
p[i%len(p)] = 0
result = ''
for v in sorted(p):
result += '%d ' % v
result += str(ba)
print(result)
``` | output | 1 | 45,309 | 19 | 90,619 |
Provide a correct Python 3 solution for this coding contest problem.
One of the games that uses the Hyakunin Isshu tag is "Buddhist turning". It is a simple game that uses only picture cards, so it is widely enjoyed. There are various derivative types of rules, but the shaved turn considered here is performed by N participants according to the following rules.
* Use a total of 100 cards, including 64 "men", 15 "boys", and 21 "princesses".
* Turn the bill over so that you can't see the picture and mix well to make a "bill pile".
* Draw one card from the first participant in order. After the Nth person, repeat from the first person.
* If the drawn card is a man, the person who draws will get the card.
* If the drawn card is a shaven, the person who draws puts all the cards he has, including that card, into the "field".
* If the drawn card is a princess, the person who draws gets all the cards in play, including that card.
* When there are no more cards in the bill pile, the game ends, and the person with the most cards wins.
Given the number of participants and the order of the cards piled up in the bill pile, the number of cards each participant has at the end of the game is arranged in ascending order, and the number of cards remaining in the field is shown. Create a program to output.
input
The input consists of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
c1c2 ... c100
Each dataset has two rows, and the first row is given the integer N (2 ≤ N ≤ 10) representing the number of participants. The next line is given a character string that represents the arrangement of the bills piled up in the bill pile. The letter ci represents the i-th drawn tag, where M is a man, S is a shaven, and L is a princess. There is no space between each character.
The number of datasets does not exceed 100.
output
For each data set, the sequence of the number of cards at the end of the game is output on one line. As the number of cards, the number of cards that each participant has is arranged in ascending order, and then the number of cards remaining in the field is output. Separate each number of bills with one blank. Do not print blanks at the end of the line.
Example
Input
2
SSSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
2
SSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMSL
5
MMMMMMSLSLLMMMSMMSLMMMLMMMMLSLLLLMLSMMLMMLLMSSSLMMMMLMLSMLMSMMMMMMMSMMMMMMLMMMMMSMMMLMMLMMMMMMMMMSSM
0
Output
42 58 0
0 100 0
0 0 3 10 59 28 | instruction | 0 | 45,310 | 19 | 90,620 |
"Correct Solution:
```
# -*- coding: utf-8 -*-
"""
The Outcome of Bonze
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0280
"""
import sys
def solve(N, C):
points = [0] * (N+1)
for i, c in enumerate(C, start=1):
pos = N if i%N== 0 else i%N
if c == 'M':
points[pos] += 1
elif c == 'S':
points[0] += (points[pos] + 1)
points[pos] = 0
else:
points[pos] += (points[0] + 1)
points[0] = 0
return sorted(points[1:]) + [points[0]]
def main(args):
while True:
N = int(input())
if N == 0:
break
C = input()
ans = solve(N, C)
print(*ans, sep=' ')
if __name__ == '__main__':
main(sys.argv[1:])
``` | output | 1 | 45,310 | 19 | 90,621 |
Provide a correct Python 3 solution for this coding contest problem.
One of the games that uses the Hyakunin Isshu tag is "Buddhist turning". It is a simple game that uses only picture cards, so it is widely enjoyed. There are various derivative types of rules, but the shaved turn considered here is performed by N participants according to the following rules.
* Use a total of 100 cards, including 64 "men", 15 "boys", and 21 "princesses".
* Turn the bill over so that you can't see the picture and mix well to make a "bill pile".
* Draw one card from the first participant in order. After the Nth person, repeat from the first person.
* If the drawn card is a man, the person who draws will get the card.
* If the drawn card is a shaven, the person who draws puts all the cards he has, including that card, into the "field".
* If the drawn card is a princess, the person who draws gets all the cards in play, including that card.
* When there are no more cards in the bill pile, the game ends, and the person with the most cards wins.
Given the number of participants and the order of the cards piled up in the bill pile, the number of cards each participant has at the end of the game is arranged in ascending order, and the number of cards remaining in the field is shown. Create a program to output.
input
The input consists of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
c1c2 ... c100
Each dataset has two rows, and the first row is given the integer N (2 ≤ N ≤ 10) representing the number of participants. The next line is given a character string that represents the arrangement of the bills piled up in the bill pile. The letter ci represents the i-th drawn tag, where M is a man, S is a shaven, and L is a princess. There is no space between each character.
The number of datasets does not exceed 100.
output
For each data set, the sequence of the number of cards at the end of the game is output on one line. As the number of cards, the number of cards that each participant has is arranged in ascending order, and then the number of cards remaining in the field is output. Separate each number of bills with one blank. Do not print blanks at the end of the line.
Example
Input
2
SSSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
2
SSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMSL
5
MMMMMMSLSLLMMMSMMSLMMMLMMMMLSLLLLMLSMMLMMLLMSSSLMMMMLMLSMLMSMMMMMMMSMMMMMMLMMMMMSMMMLMMLMMMMMMMMMSSM
0
Output
42 58 0
0 100 0
0 0 3 10 59 28 | instruction | 0 | 45,311 | 19 | 90,622 |
"Correct Solution:
```
while 1:
n = int(input())
if n == 0:
break
data = list(input())
ba = 0
hand = [0] * n
for i in range(100):
turn = i % n
card = data[i]
if card == "M":
hand[turn] += 1
elif card == "S":
ba += hand[turn] + 1
hand[turn] = 0
else:
hand[turn] += ba + 1
ba = 0
hand.sort()
hand.append(ba)
print(' '.join(str(h) for h in hand))
``` | output | 1 | 45,311 | 19 | 90,623 |
Provide a correct Python 3 solution for this coding contest problem.
One of the games that uses the Hyakunin Isshu tag is "Buddhist turning". It is a simple game that uses only picture cards, so it is widely enjoyed. There are various derivative types of rules, but the shaved turn considered here is performed by N participants according to the following rules.
* Use a total of 100 cards, including 64 "men", 15 "boys", and 21 "princesses".
* Turn the bill over so that you can't see the picture and mix well to make a "bill pile".
* Draw one card from the first participant in order. After the Nth person, repeat from the first person.
* If the drawn card is a man, the person who draws will get the card.
* If the drawn card is a shaven, the person who draws puts all the cards he has, including that card, into the "field".
* If the drawn card is a princess, the person who draws gets all the cards in play, including that card.
* When there are no more cards in the bill pile, the game ends, and the person with the most cards wins.
Given the number of participants and the order of the cards piled up in the bill pile, the number of cards each participant has at the end of the game is arranged in ascending order, and the number of cards remaining in the field is shown. Create a program to output.
input
The input consists of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
c1c2 ... c100
Each dataset has two rows, and the first row is given the integer N (2 ≤ N ≤ 10) representing the number of participants. The next line is given a character string that represents the arrangement of the bills piled up in the bill pile. The letter ci represents the i-th drawn tag, where M is a man, S is a shaven, and L is a princess. There is no space between each character.
The number of datasets does not exceed 100.
output
For each data set, the sequence of the number of cards at the end of the game is output on one line. As the number of cards, the number of cards that each participant has is arranged in ascending order, and then the number of cards remaining in the field is output. Separate each number of bills with one blank. Do not print blanks at the end of the line.
Example
Input
2
SSSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
2
SSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMSL
5
MMMMMMSLSLLMMMSMMSLMMMLMMMMLSLLLLMLSMMLMMLLMSSSLMMMMLMLSMLMSMMMMMMMSMMMMMMLMMMMMSMMMLMMLMMMMMMMMMSSM
0
Output
42 58 0
0 100 0
0 0 3 10 59 28 | instruction | 0 | 45,312 | 19 | 90,624 |
"Correct Solution:
```
while True :
n = int(input())
if n == 0 :
break
card = list(input())
maisu = [0] * (n + 1)
x = 0
for i in range(100) :
if card[i] == 'M' :
maisu[x] += 1
elif card[i] == 'S' :
maisu[n] += maisu[x] + 1
maisu[x] = 0
elif card[i] == 'L' :
maisu[x] += maisu[n] + 1
maisu[n] = 0
x += 1
if x == n :
x = 0
ba = maisu.pop()
maisu.sort()
for i in range(n) :
print(maisu[i], end=" ")
print(ba)
``` | output | 1 | 45,312 | 19 | 90,625 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One of the games that uses the Hyakunin Isshu tag is "Buddhist turning". It is a simple game that uses only picture cards, so it is widely enjoyed. There are various derivative types of rules, but the shaved turn considered here is performed by N participants according to the following rules.
* Use a total of 100 cards, including 64 "men", 15 "boys", and 21 "princesses".
* Turn the bill over so that you can't see the picture and mix well to make a "bill pile".
* Draw one card from the first participant in order. After the Nth person, repeat from the first person.
* If the drawn card is a man, the person who draws will get the card.
* If the drawn card is a shaven, the person who draws puts all the cards he has, including that card, into the "field".
* If the drawn card is a princess, the person who draws gets all the cards in play, including that card.
* When there are no more cards in the bill pile, the game ends, and the person with the most cards wins.
Given the number of participants and the order of the cards piled up in the bill pile, the number of cards each participant has at the end of the game is arranged in ascending order, and the number of cards remaining in the field is shown. Create a program to output.
input
The input consists of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
c1c2 ... c100
Each dataset has two rows, and the first row is given the integer N (2 ≤ N ≤ 10) representing the number of participants. The next line is given a character string that represents the arrangement of the bills piled up in the bill pile. The letter ci represents the i-th drawn tag, where M is a man, S is a shaven, and L is a princess. There is no space between each character.
The number of datasets does not exceed 100.
output
For each data set, the sequence of the number of cards at the end of the game is output on one line. As the number of cards, the number of cards that each participant has is arranged in ascending order, and then the number of cards remaining in the field is output. Separate each number of bills with one blank. Do not print blanks at the end of the line.
Example
Input
2
SSSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
2
SSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMSL
5
MMMMMMSLSLLMMMSMMSLMMMLMMMMLSLLLLMLSMMLMMLLMSSSLMMMMLMLSMLMSMMMMMMMSMMMMMMLMMMMMSMMMLMMLMMMMMMMMMSSM
0
Output
42 58 0
0 100 0
0 0 3 10 59 28
Submitted Solution:
```
while 1:
n=int(input())
if n==0: break
cs=input()
a,b=[0]*n,0
for i in range(100):
if cs[i]=="M":
a[i%n]+=1
elif cs[i]=="S":
a[i%n],b=0,b+1+a[i%n]
elif cs[i]=="L":
a[i%n],b=a[i%n]+1+b,0
a.sort()
print(" ".join(map(str,a+[b])))
``` | instruction | 0 | 45,313 | 19 | 90,626 |
Yes | output | 1 | 45,313 | 19 | 90,627 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One of the games that uses the Hyakunin Isshu tag is "Buddhist turning". It is a simple game that uses only picture cards, so it is widely enjoyed. There are various derivative types of rules, but the shaved turn considered here is performed by N participants according to the following rules.
* Use a total of 100 cards, including 64 "men", 15 "boys", and 21 "princesses".
* Turn the bill over so that you can't see the picture and mix well to make a "bill pile".
* Draw one card from the first participant in order. After the Nth person, repeat from the first person.
* If the drawn card is a man, the person who draws will get the card.
* If the drawn card is a shaven, the person who draws puts all the cards he has, including that card, into the "field".
* If the drawn card is a princess, the person who draws gets all the cards in play, including that card.
* When there are no more cards in the bill pile, the game ends, and the person with the most cards wins.
Given the number of participants and the order of the cards piled up in the bill pile, the number of cards each participant has at the end of the game is arranged in ascending order, and the number of cards remaining in the field is shown. Create a program to output.
input
The input consists of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
c1c2 ... c100
Each dataset has two rows, and the first row is given the integer N (2 ≤ N ≤ 10) representing the number of participants. The next line is given a character string that represents the arrangement of the bills piled up in the bill pile. The letter ci represents the i-th drawn tag, where M is a man, S is a shaven, and L is a princess. There is no space between each character.
The number of datasets does not exceed 100.
output
For each data set, the sequence of the number of cards at the end of the game is output on one line. As the number of cards, the number of cards that each participant has is arranged in ascending order, and then the number of cards remaining in the field is output. Separate each number of bills with one blank. Do not print blanks at the end of the line.
Example
Input
2
SSSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
2
SSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMSL
5
MMMMMMSLSLLMMMSMMSLMMMLMMMMLSLLLLMLSMMLMMLLMSSSLMMMMLMLSMLMSMMMMMMMSMMMMMMLMMMMMSMMMLMMLMMMMMMMMMSSM
0
Output
42 58 0
0 100 0
0 0 3 10 59 28
Submitted Solution:
```
while 1:
n = int(input())
if n == 0:break
p = [0] * n
s = 0
f = input()
for i in range(100):
if f[i] == "M":p[i % n] += 1
elif f[i] == "S":
s += p[i % n] + 1
p[i % n] = 0
else:
p[i % n] += s + 1
s = 0
p.sort()
p += [s]
print(*p)
``` | instruction | 0 | 45,314 | 19 | 90,628 |
Yes | output | 1 | 45,314 | 19 | 90,629 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One of the games that uses the Hyakunin Isshu tag is "Buddhist turning". It is a simple game that uses only picture cards, so it is widely enjoyed. There are various derivative types of rules, but the shaved turn considered here is performed by N participants according to the following rules.
* Use a total of 100 cards, including 64 "men", 15 "boys", and 21 "princesses".
* Turn the bill over so that you can't see the picture and mix well to make a "bill pile".
* Draw one card from the first participant in order. After the Nth person, repeat from the first person.
* If the drawn card is a man, the person who draws will get the card.
* If the drawn card is a shaven, the person who draws puts all the cards he has, including that card, into the "field".
* If the drawn card is a princess, the person who draws gets all the cards in play, including that card.
* When there are no more cards in the bill pile, the game ends, and the person with the most cards wins.
Given the number of participants and the order of the cards piled up in the bill pile, the number of cards each participant has at the end of the game is arranged in ascending order, and the number of cards remaining in the field is shown. Create a program to output.
input
The input consists of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
c1c2 ... c100
Each dataset has two rows, and the first row is given the integer N (2 ≤ N ≤ 10) representing the number of participants. The next line is given a character string that represents the arrangement of the bills piled up in the bill pile. The letter ci represents the i-th drawn tag, where M is a man, S is a shaven, and L is a princess. There is no space between each character.
The number of datasets does not exceed 100.
output
For each data set, the sequence of the number of cards at the end of the game is output on one line. As the number of cards, the number of cards that each participant has is arranged in ascending order, and then the number of cards remaining in the field is output. Separate each number of bills with one blank. Do not print blanks at the end of the line.
Example
Input
2
SSSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
2
SSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMSL
5
MMMMMMSLSLLMMMSMMSLMMMLMMMMLSLLLLMLSMMLMMLLMSSSLMMMMLMLSMLMSMMMMMMMSMMMMMMLMMMMMSMMMLMMLMMMMMMMMMSSM
0
Output
42 58 0
0 100 0
0 0 3 10 59 28
Submitted Solution:
```
# from sys import exit
# A, B, C = [int(n) for n in input().split()]
while(True):
N = int(input())
if N == 0:
break
S = str(input())
L = len(S)
F = {"M":0, "S":0, "L":0}
hands = [{"M":0, "S":0, "L":0} for _ in range(N)]
cur = 0
while(cur != L):
if S[cur] == "M":
hands[cur%N]["M"] += 1
elif S[cur] == "S":
F["M"] += hands[cur%N]["M"]
hands[cur%N]["M"] = 0
F["S"] += hands[cur%N]["S"] + 1
hands[cur%N]["S"] = 0
F["L"] += hands[cur%N]["L"]
hands[cur%N]["L"] = 0
else:
hands[cur%N]["M"] += F["M"]
F["M"] = 0
hands[cur%N]["S"] += F["S"]
F["S"] = 0
hands[cur%N]["L"] += F["L"] + 1
F["L"] = 0
cur += 1
ans = [sum(d.values()) for d in hands]
ans = sorted(ans)
for e in ans:
print(e, end=" ")
print(sum(F.values()))
``` | instruction | 0 | 45,315 | 19 | 90,630 |
Yes | output | 1 | 45,315 | 19 | 90,631 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One of the games that uses the Hyakunin Isshu tag is "Buddhist turning". It is a simple game that uses only picture cards, so it is widely enjoyed. There are various derivative types of rules, but the shaved turn considered here is performed by N participants according to the following rules.
* Use a total of 100 cards, including 64 "men", 15 "boys", and 21 "princesses".
* Turn the bill over so that you can't see the picture and mix well to make a "bill pile".
* Draw one card from the first participant in order. After the Nth person, repeat from the first person.
* If the drawn card is a man, the person who draws will get the card.
* If the drawn card is a shaven, the person who draws puts all the cards he has, including that card, into the "field".
* If the drawn card is a princess, the person who draws gets all the cards in play, including that card.
* When there are no more cards in the bill pile, the game ends, and the person with the most cards wins.
Given the number of participants and the order of the cards piled up in the bill pile, the number of cards each participant has at the end of the game is arranged in ascending order, and the number of cards remaining in the field is shown. Create a program to output.
input
The input consists of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
c1c2 ... c100
Each dataset has two rows, and the first row is given the integer N (2 ≤ N ≤ 10) representing the number of participants. The next line is given a character string that represents the arrangement of the bills piled up in the bill pile. The letter ci represents the i-th drawn tag, where M is a man, S is a shaven, and L is a princess. There is no space between each character.
The number of datasets does not exceed 100.
output
For each data set, the sequence of the number of cards at the end of the game is output on one line. As the number of cards, the number of cards that each participant has is arranged in ascending order, and then the number of cards remaining in the field is output. Separate each number of bills with one blank. Do not print blanks at the end of the line.
Example
Input
2
SSSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
2
SSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMSL
5
MMMMMMSLSLLMMMSMMSLMMMLMMMMLSLLLLMLSMMLMMLLMSSSLMMMMLMLSMLMSMMMMMMMSMMMMMMLMMMMMSMMMLMMLMMMMMMMMMSSM
0
Output
42 58 0
0 100 0
0 0 3 10 59 28
Submitted Solution:
```
def ans(n,s):
p = [[] for i in range(n)]
h = []
i = 0
while True:
if s == []:
break
c = s.pop(0)
if c == 'M':
if p[i] == []:
p[i] = [c]
else:
p[i].append(c)
elif c == 'L':
if p[i] == []:
p[i] = [c]
else:
p[i].append(c)
if h != []:
p[i] += h
h = []
elif c == 'S':
if h == []:
h = [c]
else:
h.append(c)
if p[i] != []:
h += p[i]
p[i] = []
i = (i+1) % n
pp = list(sorted(map(len,p)))
hh = len(h)
pp.append(hh)
return " ".join(map(str,pp))
while True:
n = int(input())
if n == 0:
break
s = list(input())
o = ans(n,s)
print(o)
``` | instruction | 0 | 45,316 | 19 | 90,632 |
Yes | output | 1 | 45,316 | 19 | 90,633 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One of the games that uses the Hyakunin Isshu tag is "Buddhist turning". It is a simple game that uses only picture cards, so it is widely enjoyed. There are various derivative types of rules, but the shaved turn considered here is performed by N participants according to the following rules.
* Use a total of 100 cards, including 64 "men", 15 "boys", and 21 "princesses".
* Turn the bill over so that you can't see the picture and mix well to make a "bill pile".
* Draw one card from the first participant in order. After the Nth person, repeat from the first person.
* If the drawn card is a man, the person who draws will get the card.
* If the drawn card is a shaven, the person who draws puts all the cards he has, including that card, into the "field".
* If the drawn card is a princess, the person who draws gets all the cards in play, including that card.
* When there are no more cards in the bill pile, the game ends, and the person with the most cards wins.
Given the number of participants and the order of the cards piled up in the bill pile, the number of cards each participant has at the end of the game is arranged in ascending order, and the number of cards remaining in the field is shown. Create a program to output.
input
The input consists of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
c1c2 ... c100
Each dataset has two rows, and the first row is given the integer N (2 ≤ N ≤ 10) representing the number of participants. The next line is given a character string that represents the arrangement of the bills piled up in the bill pile. The letter ci represents the i-th drawn tag, where M is a man, S is a shaven, and L is a princess. There is no space between each character.
The number of datasets does not exceed 100.
output
For each data set, the sequence of the number of cards at the end of the game is output on one line. As the number of cards, the number of cards that each participant has is arranged in ascending order, and then the number of cards remaining in the field is output. Separate each number of bills with one blank. Do not print blanks at the end of the line.
Example
Input
2
SSSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
2
SSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMSL
5
MMMMMMSLSLLMMMSMMSLMMMLMMMMLSLLLLMLSMMLMMLLMSSSLMMMMLMLSMLMSMMMMMMMSMMMMMMLMMMMMSMMMLMMLMMMMMMMMMSSM
0
Output
42 58 0
0 100 0
0 0 3 10 59 28
Submitted Solution:
```
while 1:
ba = 0
p = [0 for i in range(int(input()))]
if len(p) == 0:break
for i,v in enumerate(list(input())):
p[i%len(p)] += 1
if v == 'L':
p[i%len(p)] += ba
ba = 0
elif v== 'S':
ba += p[i%len(p)]
p[i%len(p)] = 0
result = ''
for v in p:
result += '%d ' % v
result += str(ba)
print(result)
``` | instruction | 0 | 45,317 | 19 | 90,634 |
No | output | 1 | 45,317 | 19 | 90,635 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One of the games that uses the Hyakunin Isshu tag is "Buddhist turning". It is a simple game that uses only picture cards, so it is widely enjoyed. There are various derivative types of rules, but the shaved turn considered here is performed by N participants according to the following rules.
* Use a total of 100 cards, including 64 "men", 15 "boys", and 21 "princesses".
* Turn the bill over so that you can't see the picture and mix well to make a "bill pile".
* Draw one card from the first participant in order. After the Nth person, repeat from the first person.
* If the drawn card is a man, the person who draws will get the card.
* If the drawn card is a shaven, the person who draws puts all the cards he has, including that card, into the "field".
* If the drawn card is a princess, the person who draws gets all the cards in play, including that card.
* When there are no more cards in the bill pile, the game ends, and the person with the most cards wins.
Given the number of participants and the order of the cards piled up in the bill pile, the number of cards each participant has at the end of the game is arranged in ascending order, and the number of cards remaining in the field is shown. Create a program to output.
input
The input consists of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
c1c2 ... c100
Each dataset has two rows, and the first row is given the integer N (2 ≤ N ≤ 10) representing the number of participants. The next line is given a character string that represents the arrangement of the bills piled up in the bill pile. The letter ci represents the i-th drawn tag, where M is a man, S is a shaven, and L is a princess. There is no space between each character.
The number of datasets does not exceed 100.
output
For each data set, the sequence of the number of cards at the end of the game is output on one line. As the number of cards, the number of cards that each participant has is arranged in ascending order, and then the number of cards remaining in the field is output. Separate each number of bills with one blank. Do not print blanks at the end of the line.
Example
Input
2
SSSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
2
SSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMSL
5
MMMMMMSLSLLMMMSMMSLMMMLMMMMLSLLLLMLSMMLMMLLMSSSLMMMMLMLSMLMSMMMMMMMSMMMMMMLMMMMMSMMMLMMLMMMMMMMMMSSM
0
Output
42 58 0
0 100 0
0 0 3 10 59 28
Submitted Solution:
```
while True:
N = int(input())
if N==0:break
dataset = input()
mens = ["" for _ in range(N)]
i = 0
p = ""
while dataset:
if i == N: i = 0
card, dataset = dataset[0], dataset[1:]
if card == "M":
mens[i] += card
elif card == "S":
p += card + mens[i]
mens[i] = ""
else:
mens[i] += card + p
p = ""
i += 1
print(*[v for v in sorted(len(m) for m in mens)], len(p))
``` | instruction | 0 | 45,318 | 19 | 90,636 |
No | output | 1 | 45,318 | 19 | 90,637 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One of the games that uses the Hyakunin Isshu tag is "Buddhist turning". It is a simple game that uses only picture cards, so it is widely enjoyed. There are various derivative types of rules, but the shaved turn considered here is performed by N participants according to the following rules.
* Use a total of 100 cards, including 64 "men", 15 "boys", and 21 "princesses".
* Turn the bill over so that you can't see the picture and mix well to make a "bill pile".
* Draw one card from the first participant in order. After the Nth person, repeat from the first person.
* If the drawn card is a man, the person who draws will get the card.
* If the drawn card is a shaven, the person who draws puts all the cards he has, including that card, into the "field".
* If the drawn card is a princess, the person who draws gets all the cards in play, including that card.
* When there are no more cards in the bill pile, the game ends, and the person with the most cards wins.
Given the number of participants and the order of the cards piled up in the bill pile, the number of cards each participant has at the end of the game is arranged in ascending order, and the number of cards remaining in the field is shown. Create a program to output.
input
The input consists of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
c1c2 ... c100
Each dataset has two rows, and the first row is given the integer N (2 ≤ N ≤ 10) representing the number of participants. The next line is given a character string that represents the arrangement of the bills piled up in the bill pile. The letter ci represents the i-th drawn tag, where M is a man, S is a shaven, and L is a princess. There is no space between each character.
The number of datasets does not exceed 100.
output
For each data set, the sequence of the number of cards at the end of the game is output on one line. As the number of cards, the number of cards that each participant has is arranged in ascending order, and then the number of cards remaining in the field is output. Separate each number of bills with one blank. Do not print blanks at the end of the line.
Example
Input
2
SSSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
2
SSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMSL
5
MMMMMMSLSLLMMMSMMSLMMMLMMMMLSLLLLMLSMMLMMLLMSSSLMMMMLMLSMLMSMMMMMMMSMMMMMMLMMMMMSMMMLMMLMMMMMMMMMSSM
0
Output
42 58 0
0 100 0
0 0 3 10 59 28
Submitted Solution:
```
def ans(n,s):
p = [[] for i in range(n+1)]
i = 0
while True:
if s == []:
break
c = s.pop(0)
if c == 'M':
if p[i] == []:
p[i] = [c]
else:
p[i].append(c)
elif c == 'L':
if p[i] == []:
p[i] = [c]
else:
p[i].append(c)
if p[n] != []:
p[i] += p[n]
p[n] = []
elif c == 'S':
if p[n] == []:
p[n] = [c]
else:
p[n].append(c)
if p[i] != []:
p[n] += p[i]
p[i] = []
i = (i+1) % n
return p
while True:
n = int(input())
if n == 0:
break
s = list(input())
o = ans(n,s)
oo= list(map(lambda x: str(len(x)),o))
print(" ".join(oo))
``` | instruction | 0 | 45,319 | 19 | 90,638 |
No | output | 1 | 45,319 | 19 | 90,639 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One of the games that uses the Hyakunin Isshu tag is "Buddhist turning". It is a simple game that uses only picture cards, so it is widely enjoyed. There are various derivative types of rules, but the shaved turn considered here is performed by N participants according to the following rules.
* Use a total of 100 cards, including 64 "men", 15 "boys", and 21 "princesses".
* Turn the bill over so that you can't see the picture and mix well to make a "bill pile".
* Draw one card from the first participant in order. After the Nth person, repeat from the first person.
* If the drawn card is a man, the person who draws will get the card.
* If the drawn card is a shaven, the person who draws puts all the cards he has, including that card, into the "field".
* If the drawn card is a princess, the person who draws gets all the cards in play, including that card.
* When there are no more cards in the bill pile, the game ends, and the person with the most cards wins.
Given the number of participants and the order of the cards piled up in the bill pile, the number of cards each participant has at the end of the game is arranged in ascending order, and the number of cards remaining in the field is shown. Create a program to output.
input
The input consists of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
c1c2 ... c100
Each dataset has two rows, and the first row is given the integer N (2 ≤ N ≤ 10) representing the number of participants. The next line is given a character string that represents the arrangement of the bills piled up in the bill pile. The letter ci represents the i-th drawn tag, where M is a man, S is a shaven, and L is a princess. There is no space between each character.
The number of datasets does not exceed 100.
output
For each data set, the sequence of the number of cards at the end of the game is output on one line. As the number of cards, the number of cards that each participant has is arranged in ascending order, and then the number of cards remaining in the field is output. Separate each number of bills with one blank. Do not print blanks at the end of the line.
Example
Input
2
SSSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
2
SSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMSL
5
MMMMMMSLSLLMMMSMMSLMMMLMMMMLSLLLLMLSMMLMMLLMSSSLMMMMLMLSMLMSMMMMMMMSMMMMMMLMMMMMSMMMLMMLMMMMMMMMMSSM
0
Output
42 58 0
0 100 0
0 0 3 10 59 28
Submitted Solution:
```
while True:
N = int(input())
if N==0:break
dataset = input()
mens = ["" for _ in range(N)]
i = 0
p = ""
while dataset:
if i == N: i = 0
card, dataset = dataset[0], dataset[1:]
if card == "M":
mens[i] += card
elif card == "S":
p += card + mens[i]
mens[i] = ""
else:
mens[i] += card + p
p = ""
i += 1
print(*[len(s) for s in sorted(mens)], len(p))
``` | instruction | 0 | 45,320 | 19 | 90,640 |
No | output | 1 | 45,320 | 19 | 90,641 |
Provide a correct Python 3 solution for this coding contest problem.
problem
You are playing with J using the Midakuji. The Amida lottery consists of n vertical bars and m horizontal bars. The vertical bars are numbered from 1 to n in order from the left, and the vertical bar i The positive integer si is written at the bottom of.
<image>
Figure 3-1 Example of Amidakuji (n = 4, m = 5, s1 = 20, s2 = 80, s3 = 100, s4 = 50)
The integer written at the bottom of the vertical bar i, which is reached by following the path from the top of the vertical bar i, is the score when the vertical bar i is selected. For example, in Fig. 3-1 the vertical bar 1 is selected. And the score is 80 points, and if the vertical bar 2 is selected, the score is 100 points.
<image>
Figure 3-2 Example of how to follow the road
Mr. J decides to choose a series of k books from vertical bar 1 to vertical bar k. The total score when selecting those k vertical bars is J's score. However, you are in the Amidakuji You can select one horizontal bar and delete that horizontal bar from the Amidakuji. (You do not have to delete it.) If you delete one horizontal bar, the vertical bar in the deleted Amidakuji will be displayed vertically. J's score is the total of the points when selecting k consecutive vertical bars from bar 1 to vertical bar k.
Given the shape of the Amida lottery and the number of vertical bars k that J chooses as input, create a program that finds the minimum value of J's score.
input
The input consists of multiple datasets. Each dataset is given in the following format.
On the first line, four integers n, m, h, k are written separated by blanks. N (2 ≤ n ≤ 1000) is the number of vertical bars, and m (1 ≤ m ≤ 100000) is the horizontal bar. H (2 ≤ h ≤ 1000) represents the length of the vertical bar, and k (1 ≤ k ≤ n) represents the number of vertical bars you choose.
The following n lines contain the score written at the bottom of the vertical bar. The first line (1 ≤ i ≤ n) contains the positive integer si. Also, s1 + s2 + ... + sn ≤ 2000000000 = 2 × 109.
The following m lines indicate the position of the horizontal bar. The horizontal bars are numbered from 1 to m. The first line (1 ≤ i ≤ m) is the horizontal bar i. The two integers ai, bi (1 ≤ ai ≤ n --1, 1 ≤ bi ≤ h --1) representing the position are separated by blanks, and the horizontal bar i connects the vertical bar ai and the vertical bar ai + 1. , Indicates that the distance from the top edge of the horizontal bar i is bi. However, no two horizontal bars share an endpoint.
Of the scoring data, 20% of the points will have the lowest score for Mr. J if the horizontal bar is not deleted. Also, 30% of the points will satisfy n ≤ 20, m ≤ 30, h ≤ 10. 60% of the points are m ≤ 1000.
The end of the input is indicated by a line containing four zeros. The number of datasets does not exceed 10.
output
For each dataset, output the minimum score of Mr. J on one line.
Examples
Input
4 5 7 2
20
80
100
50
1 1
2 6
2 3
1 5
3 1
2 2 5 1
10
20
1 1
1 3
0 0 0 0
Output
100
10
Input
None
Output
None | instruction | 0 | 45,321 | 19 | 90,642 |
"Correct Solution:
```
while True:
n,m,h,k = map(int, input().split())
if n == 0: break
pts = []
for _ in range(n):
pts.append(int(input()))
bars = []
for _ in range(m):
bars.append(list(map(int, input().split())))
bars.sort(key=lambda x: x[1])
nos = [i for i in range(n)]
barspt = []
for bar in bars:
b = bar[0]-1
barspt.append([nos[b],nos[b+1],0,0])
nos[b],nos[b+1] = nos[b+1],nos[b]
nos = [i for i in range(n)]
for barid in range(m-1,-1,-1):
b0 = bars[barid][0]-1
b1 = bars[barid][0]
barspt[barid][2] = pts[nos[b0]]
barspt[barid][3] = pts[nos[b1]]
pts[nos[b0]],pts[nos[b1]] = pts[nos[b1]],pts[nos[b0]]
atari = -1
minsc = sum(pts[0:k])
hosei = 0
for bar in barspt:
if atari <= bar[0]-1 and bar[0]-1 < atari+k and (bar[1]-1 < atari or atari+k <= bar[1]-1):
sc = bar[2]-bar[3]
if sc < hosei: hosei = sc
if atari <= bar[1]-1 and bar[1]-1 < atari+k and (bar[0]-1 < atari or atari+k <= bar[0]-1):
sc = bar[3]-bar[2]
if sc < hosei: hosei = sc
print(minsc+hosei)
``` | output | 1 | 45,321 | 19 | 90,643 |
Provide a correct Python 3 solution for this coding contest problem.
problem
You are playing with J using the Midakuji. The Amida lottery consists of n vertical bars and m horizontal bars. The vertical bars are numbered from 1 to n in order from the left, and the vertical bar i The positive integer si is written at the bottom of.
<image>
Figure 3-1 Example of Amidakuji (n = 4, m = 5, s1 = 20, s2 = 80, s3 = 100, s4 = 50)
The integer written at the bottom of the vertical bar i, which is reached by following the path from the top of the vertical bar i, is the score when the vertical bar i is selected. For example, in Fig. 3-1 the vertical bar 1 is selected. And the score is 80 points, and if the vertical bar 2 is selected, the score is 100 points.
<image>
Figure 3-2 Example of how to follow the road
Mr. J decides to choose a series of k books from vertical bar 1 to vertical bar k. The total score when selecting those k vertical bars is J's score. However, you are in the Amidakuji You can select one horizontal bar and delete that horizontal bar from the Amidakuji. (You do not have to delete it.) If you delete one horizontal bar, the vertical bar in the deleted Amidakuji will be displayed vertically. J's score is the total of the points when selecting k consecutive vertical bars from bar 1 to vertical bar k.
Given the shape of the Amida lottery and the number of vertical bars k that J chooses as input, create a program that finds the minimum value of J's score.
input
The input consists of multiple datasets. Each dataset is given in the following format.
On the first line, four integers n, m, h, k are written separated by blanks. N (2 ≤ n ≤ 1000) is the number of vertical bars, and m (1 ≤ m ≤ 100000) is the horizontal bar. H (2 ≤ h ≤ 1000) represents the length of the vertical bar, and k (1 ≤ k ≤ n) represents the number of vertical bars you choose.
The following n lines contain the score written at the bottom of the vertical bar. The first line (1 ≤ i ≤ n) contains the positive integer si. Also, s1 + s2 + ... + sn ≤ 2000000000 = 2 × 109.
The following m lines indicate the position of the horizontal bar. The horizontal bars are numbered from 1 to m. The first line (1 ≤ i ≤ m) is the horizontal bar i. The two integers ai, bi (1 ≤ ai ≤ n --1, 1 ≤ bi ≤ h --1) representing the position are separated by blanks, and the horizontal bar i connects the vertical bar ai and the vertical bar ai + 1. , Indicates that the distance from the top edge of the horizontal bar i is bi. However, no two horizontal bars share an endpoint.
Of the scoring data, 20% of the points will have the lowest score for Mr. J if the horizontal bar is not deleted. Also, 30% of the points will satisfy n ≤ 20, m ≤ 30, h ≤ 10. 60% of the points are m ≤ 1000.
The end of the input is indicated by a line containing four zeros. The number of datasets does not exceed 10.
output
For each dataset, output the minimum score of Mr. J on one line.
Examples
Input
4 5 7 2
20
80
100
50
1 1
2 6
2 3
1 5
3 1
2 2 5 1
10
20
1 1
1 3
0 0 0 0
Output
100
10
Input
None
Output
None | instruction | 0 | 45,322 | 19 | 90,644 |
"Correct Solution:
```
while True:
n,m,h,k = map(int,input().split())
if not n: break
s_lst = [int(input()) for _ in range(n)]
i_lst = [i for i in range(n)]
b_lst = [tuple(map(int,input().split())) for _ in range(m)]
b_lst = sorted(b_lst,key=lambda x:x[1])
pare_lst = []
for bar in b_lst:
ind = bar[0]
temp = i_lst[ind]
i_lst[ind] = i_lst[ind - 1]
i_lst[ind - 1] = temp
pare_lst.append((i_lst[ind], i_lst[ind - 1]))
# print(i_lst)
new_s_lst = [0] * n
for i in range(n):
new_s_lst[i_lst[i]] = s_lst[i]
# print(s_lst)
ans = sum(new_s_lst[:k])
# print(ans)
# print(pare_lst)
max_dec = 0
for pare in pare_lst:
a = pare[0]
b = pare[1]
# print(a,b,s_lst[a],s_lst[b])
if a < k and b >= k and new_s_lst[a] - new_s_lst[b] > max_dec:
max_dec = new_s_lst[a] - new_s_lst[b]
if b < k and a >= k and new_s_lst[b] - new_s_lst[a] > max_dec:
max_dec = new_s_lst[b] - new_s_lst[a]
print(ans - max_dec)
``` | output | 1 | 45,322 | 19 | 90,645 |
Provide a correct Python 3 solution for this coding contest problem.
problem
You are playing with J using the Midakuji. The Amida lottery consists of n vertical bars and m horizontal bars. The vertical bars are numbered from 1 to n in order from the left, and the vertical bar i The positive integer si is written at the bottom of.
<image>
Figure 3-1 Example of Amidakuji (n = 4, m = 5, s1 = 20, s2 = 80, s3 = 100, s4 = 50)
The integer written at the bottom of the vertical bar i, which is reached by following the path from the top of the vertical bar i, is the score when the vertical bar i is selected. For example, in Fig. 3-1 the vertical bar 1 is selected. And the score is 80 points, and if the vertical bar 2 is selected, the score is 100 points.
<image>
Figure 3-2 Example of how to follow the road
Mr. J decides to choose a series of k books from vertical bar 1 to vertical bar k. The total score when selecting those k vertical bars is J's score. However, you are in the Amidakuji You can select one horizontal bar and delete that horizontal bar from the Amidakuji. (You do not have to delete it.) If you delete one horizontal bar, the vertical bar in the deleted Amidakuji will be displayed vertically. J's score is the total of the points when selecting k consecutive vertical bars from bar 1 to vertical bar k.
Given the shape of the Amida lottery and the number of vertical bars k that J chooses as input, create a program that finds the minimum value of J's score.
input
The input consists of multiple datasets. Each dataset is given in the following format.
On the first line, four integers n, m, h, k are written separated by blanks. N (2 ≤ n ≤ 1000) is the number of vertical bars, and m (1 ≤ m ≤ 100000) is the horizontal bar. H (2 ≤ h ≤ 1000) represents the length of the vertical bar, and k (1 ≤ k ≤ n) represents the number of vertical bars you choose.
The following n lines contain the score written at the bottom of the vertical bar. The first line (1 ≤ i ≤ n) contains the positive integer si. Also, s1 + s2 + ... + sn ≤ 2000000000 = 2 × 109.
The following m lines indicate the position of the horizontal bar. The horizontal bars are numbered from 1 to m. The first line (1 ≤ i ≤ m) is the horizontal bar i. The two integers ai, bi (1 ≤ ai ≤ n --1, 1 ≤ bi ≤ h --1) representing the position are separated by blanks, and the horizontal bar i connects the vertical bar ai and the vertical bar ai + 1. , Indicates that the distance from the top edge of the horizontal bar i is bi. However, no two horizontal bars share an endpoint.
Of the scoring data, 20% of the points will have the lowest score for Mr. J if the horizontal bar is not deleted. Also, 30% of the points will satisfy n ≤ 20, m ≤ 30, h ≤ 10. 60% of the points are m ≤ 1000.
The end of the input is indicated by a line containing four zeros. The number of datasets does not exceed 10.
output
For each dataset, output the minimum score of Mr. J on one line.
Examples
Input
4 5 7 2
20
80
100
50
1 1
2 6
2 3
1 5
3 1
2 2 5 1
10
20
1 1
1 3
0 0 0 0
Output
100
10
Input
None
Output
None | instruction | 0 | 45,323 | 19 | 90,646 |
"Correct Solution:
```
while True:
n, m, h, k = map(int, input().split())
if not n:
break
points = [int(input()) for _ in range(n)]
bars = [tuple(map(int, input().split())) for _ in range(m)]
bars_h = [set() for _ in range(h)]
for ba, bh in bars:
bars_h[bh].add(ba - 1)
swap = list(range(n))
history = set()
for i in range(h - 1, 0, -1):
for ba in bars_h[i]:
l, r = swap[ba:ba + 2]
history.add((l, r) if l < r else (r, l))
swap[ba:ba + 2] = r, l
swap_dict = {v: i for i, v in enumerate(swap)}
min_score_d = 0
for l, r in history:
li, ri = swap_dict[l], swap_dict[r]
if li > ri:
l, r, li, ri = r, l, ri, li
if li < k and k <= ri:
min_score_d = min(min_score_d, points[r] - points[l])
print(sum(points[x] for x in swap[:k]) + min_score_d)
``` | output | 1 | 45,323 | 19 | 90,647 |
Provide a correct Python 3 solution for this coding contest problem.
problem
You are playing with J using the Midakuji. The Amida lottery consists of n vertical bars and m horizontal bars. The vertical bars are numbered from 1 to n in order from the left, and the vertical bar i The positive integer si is written at the bottom of.
<image>
Figure 3-1 Example of Amidakuji (n = 4, m = 5, s1 = 20, s2 = 80, s3 = 100, s4 = 50)
The integer written at the bottom of the vertical bar i, which is reached by following the path from the top of the vertical bar i, is the score when the vertical bar i is selected. For example, in Fig. 3-1 the vertical bar 1 is selected. And the score is 80 points, and if the vertical bar 2 is selected, the score is 100 points.
<image>
Figure 3-2 Example of how to follow the road
Mr. J decides to choose a series of k books from vertical bar 1 to vertical bar k. The total score when selecting those k vertical bars is J's score. However, you are in the Amidakuji You can select one horizontal bar and delete that horizontal bar from the Amidakuji. (You do not have to delete it.) If you delete one horizontal bar, the vertical bar in the deleted Amidakuji will be displayed vertically. J's score is the total of the points when selecting k consecutive vertical bars from bar 1 to vertical bar k.
Given the shape of the Amida lottery and the number of vertical bars k that J chooses as input, create a program that finds the minimum value of J's score.
input
The input consists of multiple datasets. Each dataset is given in the following format.
On the first line, four integers n, m, h, k are written separated by blanks. N (2 ≤ n ≤ 1000) is the number of vertical bars, and m (1 ≤ m ≤ 100000) is the horizontal bar. H (2 ≤ h ≤ 1000) represents the length of the vertical bar, and k (1 ≤ k ≤ n) represents the number of vertical bars you choose.
The following n lines contain the score written at the bottom of the vertical bar. The first line (1 ≤ i ≤ n) contains the positive integer si. Also, s1 + s2 + ... + sn ≤ 2000000000 = 2 × 109.
The following m lines indicate the position of the horizontal bar. The horizontal bars are numbered from 1 to m. The first line (1 ≤ i ≤ m) is the horizontal bar i. The two integers ai, bi (1 ≤ ai ≤ n --1, 1 ≤ bi ≤ h --1) representing the position are separated by blanks, and the horizontal bar i connects the vertical bar ai and the vertical bar ai + 1. , Indicates that the distance from the top edge of the horizontal bar i is bi. However, no two horizontal bars share an endpoint.
Of the scoring data, 20% of the points will have the lowest score for Mr. J if the horizontal bar is not deleted. Also, 30% of the points will satisfy n ≤ 20, m ≤ 30, h ≤ 10. 60% of the points are m ≤ 1000.
The end of the input is indicated by a line containing four zeros. The number of datasets does not exceed 10.
output
For each dataset, output the minimum score of Mr. J on one line.
Examples
Input
4 5 7 2
20
80
100
50
1 1
2 6
2 3
1 5
3 1
2 2 5 1
10
20
1 1
1 3
0 0 0 0
Output
100
10
Input
None
Output
None | instruction | 0 | 45,324 | 19 | 90,648 |
"Correct Solution:
```
while(1):
[n, m, h, k ] = [int(x) for x in input().split()]
if n==0:
break
A=[]
B=[ [] for x in range(h)]
C=list(range(n))
S=[0 for i in range(n)]
X=[]
for i in range(n):
A.append(int(input()))
for i in range(m):
[a, b] = [int(x) for x in input().split()]
B[b].append(a)
for y in range(h):
for a in B[y]:
C[a-1:a+1]=[C[a], C[a-1]]
X.append( sorted( C[a-1:a+1] ))
for i in range(n):
S[C[i]]=A[i]
#print(S)
ans=sum( S[:k ] )
tmpdif=0
for xx in X:
if xx[0]<k and xx[1]>=k:
tmpdif = min (tmpdif, S[xx[1]] - S[xx[0]] )
print(ans + tmpdif)
``` | output | 1 | 45,324 | 19 | 90,649 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
You are playing with J using the Midakuji. The Amida lottery consists of n vertical bars and m horizontal bars. The vertical bars are numbered from 1 to n in order from the left, and the vertical bar i The positive integer si is written at the bottom of.
<image>
Figure 3-1 Example of Amidakuji (n = 4, m = 5, s1 = 20, s2 = 80, s3 = 100, s4 = 50)
The integer written at the bottom of the vertical bar i, which is reached by following the path from the top of the vertical bar i, is the score when the vertical bar i is selected. For example, in Fig. 3-1 the vertical bar 1 is selected. And the score is 80 points, and if the vertical bar 2 is selected, the score is 100 points.
<image>
Figure 3-2 Example of how to follow the road
Mr. J decides to choose a series of k books from vertical bar 1 to vertical bar k. The total score when selecting those k vertical bars is J's score. However, you are in the Amidakuji You can select one horizontal bar and delete that horizontal bar from the Amidakuji. (You do not have to delete it.) If you delete one horizontal bar, the vertical bar in the deleted Amidakuji will be displayed vertically. J's score is the total of the points when selecting k consecutive vertical bars from bar 1 to vertical bar k.
Given the shape of the Amida lottery and the number of vertical bars k that J chooses as input, create a program that finds the minimum value of J's score.
input
The input consists of multiple datasets. Each dataset is given in the following format.
On the first line, four integers n, m, h, k are written separated by blanks. N (2 ≤ n ≤ 1000) is the number of vertical bars, and m (1 ≤ m ≤ 100000) is the horizontal bar. H (2 ≤ h ≤ 1000) represents the length of the vertical bar, and k (1 ≤ k ≤ n) represents the number of vertical bars you choose.
The following n lines contain the score written at the bottom of the vertical bar. The first line (1 ≤ i ≤ n) contains the positive integer si. Also, s1 + s2 + ... + sn ≤ 2000000000 = 2 × 109.
The following m lines indicate the position of the horizontal bar. The horizontal bars are numbered from 1 to m. The first line (1 ≤ i ≤ m) is the horizontal bar i. The two integers ai, bi (1 ≤ ai ≤ n --1, 1 ≤ bi ≤ h --1) representing the position are separated by blanks, and the horizontal bar i connects the vertical bar ai and the vertical bar ai + 1. , Indicates that the distance from the top edge of the horizontal bar i is bi. However, no two horizontal bars share an endpoint.
Of the scoring data, 20% of the points will have the lowest score for Mr. J if the horizontal bar is not deleted. Also, 30% of the points will satisfy n ≤ 20, m ≤ 30, h ≤ 10. 60% of the points are m ≤ 1000.
The end of the input is indicated by a line containing four zeros. The number of datasets does not exceed 10.
output
For each dataset, output the minimum score of Mr. J on one line.
Examples
Input
4 5 7 2
20
80
100
50
1 1
2 6
2 3
1 5
3 1
2 2 5 1
10
20
1 1
1 3
0 0 0 0
Output
100
10
Input
None
Output
None
Submitted Solution:
```
while True:
n,m,h,k = map(int, input().split())
if n == 0: break
pts = []
for _ in range(n):
pts.append(int(input()))
bars = []
for _ in range(m):
bars.append(list(map(int, input().split())))
bars.sort(key=lambda x: x[1])
nos = [i for i in range(n)]
barspt = []
for bar in bars:
b = bar[0]-1
barspt.append([nos[b],nos[b+1],0,0])
nos[b],nos[b+1] = nos[b+1],nos[b]
nos = [i for i in range(n)]
for barid in range(m-1,-1,-1):
b0 = bars[barid][0]-1
b1 = bars[barid][0]
barspt[barid][2] = pts[nos[b0]]
barspt[barid][3] = pts[nos[b1]]
pts[nos[b0]],pts[nos[b1]] = pts[nos[b0]],pts[nos[b1]]
nos[b0],nos[b1] = nos[b1],nos[b0]
atari = -1
minsc = 2*10**9+1
for i in range(n-k+1):
sc = sum(pts[i:i+k])
if sc < minsc:
minsc = sc
atari = i
hosei = 0
for bar in barspt:
if i <= bar[0]-1 and bar[0]-1 < i+k and (bar[1]-1 < i or i+k <= bar[1]-1):
sc = bar[2]-bar[3]
if sc < hosei: hosei = sc
if i <= bar[1]-1 and bar[1]-1 < i+k and (bar[0]-1 < i or i+k <= bar[0]-1):
sc = bar[3]-bar[2]
if sc < hosei: hosei = sc
print(minsc+hosei)
``` | instruction | 0 | 45,325 | 19 | 90,650 |
No | output | 1 | 45,325 | 19 | 90,651 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
You are playing with J using the Midakuji. The Amida lottery consists of n vertical bars and m horizontal bars. The vertical bars are numbered from 1 to n in order from the left, and the vertical bar i The positive integer si is written at the bottom of.
<image>
Figure 3-1 Example of Amidakuji (n = 4, m = 5, s1 = 20, s2 = 80, s3 = 100, s4 = 50)
The integer written at the bottom of the vertical bar i, which is reached by following the path from the top of the vertical bar i, is the score when the vertical bar i is selected. For example, in Fig. 3-1 the vertical bar 1 is selected. And the score is 80 points, and if the vertical bar 2 is selected, the score is 100 points.
<image>
Figure 3-2 Example of how to follow the road
Mr. J decides to choose a series of k books from vertical bar 1 to vertical bar k. The total score when selecting those k vertical bars is J's score. However, you are in the Amidakuji You can select one horizontal bar and delete that horizontal bar from the Amidakuji. (You do not have to delete it.) If you delete one horizontal bar, the vertical bar in the deleted Amidakuji will be displayed vertically. J's score is the total of the points when selecting k consecutive vertical bars from bar 1 to vertical bar k.
Given the shape of the Amida lottery and the number of vertical bars k that J chooses as input, create a program that finds the minimum value of J's score.
input
The input consists of multiple datasets. Each dataset is given in the following format.
On the first line, four integers n, m, h, k are written separated by blanks. N (2 ≤ n ≤ 1000) is the number of vertical bars, and m (1 ≤ m ≤ 100000) is the horizontal bar. H (2 ≤ h ≤ 1000) represents the length of the vertical bar, and k (1 ≤ k ≤ n) represents the number of vertical bars you choose.
The following n lines contain the score written at the bottom of the vertical bar. The first line (1 ≤ i ≤ n) contains the positive integer si. Also, s1 + s2 + ... + sn ≤ 2000000000 = 2 × 109.
The following m lines indicate the position of the horizontal bar. The horizontal bars are numbered from 1 to m. The first line (1 ≤ i ≤ m) is the horizontal bar i. The two integers ai, bi (1 ≤ ai ≤ n --1, 1 ≤ bi ≤ h --1) representing the position are separated by blanks, and the horizontal bar i connects the vertical bar ai and the vertical bar ai + 1. , Indicates that the distance from the top edge of the horizontal bar i is bi. However, no two horizontal bars share an endpoint.
Of the scoring data, 20% of the points will have the lowest score for Mr. J if the horizontal bar is not deleted. Also, 30% of the points will satisfy n ≤ 20, m ≤ 30, h ≤ 10. 60% of the points are m ≤ 1000.
The end of the input is indicated by a line containing four zeros. The number of datasets does not exceed 10.
output
For each dataset, output the minimum score of Mr. J on one line.
Examples
Input
4 5 7 2
20
80
100
50
1 1
2 6
2 3
1 5
3 1
2 2 5 1
10
20
1 1
1 3
0 0 0 0
Output
100
10
Input
None
Output
None
Submitted Solution:
```
import sys
sys.setrecursionlimit(100000)
while True:
n,m,h,k = map(int,input().split())
if not n: break
s_lst = [int(input()) for _ in range(n)]
b_lst = [tuple(map(int,input().split())) for _ in range(m)]
b_lst = sorted(b_lst,key=lambda x:-x[1])
def amida(b_lst, s_lst, used, k):
if not b_lst:
return sum(s_lst[0:k])
elif used:
for bar in b_lst:
a = bar[0]
temp = s_lst[a]
s_lst[a] = s_lst[a - 1]
s_lst[a - 1] = temp
return sum(s_lst[0:k])
else:
save_s_lst = [i for i in s_lst]
a = b_lst[0][0]
temp = s_lst[a]
s_lst[a] = s_lst[a - 1]
s_lst[a - 1] = temp
return min(amida(b_lst[1:], s_lst, 0, k), amida(b_lst[1:], save_s_lst, 1, k))
print(amida(b_lst, s_lst, 0, k))
``` | instruction | 0 | 45,326 | 19 | 90,652 |
No | output | 1 | 45,326 | 19 | 90,653 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
You are playing with J using the Midakuji. The Amida lottery consists of n vertical bars and m horizontal bars. The vertical bars are numbered from 1 to n in order from the left, and the vertical bar i The positive integer si is written at the bottom of.
<image>
Figure 3-1 Example of Amidakuji (n = 4, m = 5, s1 = 20, s2 = 80, s3 = 100, s4 = 50)
The integer written at the bottom of the vertical bar i, which is reached by following the path from the top of the vertical bar i, is the score when the vertical bar i is selected. For example, in Fig. 3-1 the vertical bar 1 is selected. And the score is 80 points, and if the vertical bar 2 is selected, the score is 100 points.
<image>
Figure 3-2 Example of how to follow the road
Mr. J decides to choose a series of k books from vertical bar 1 to vertical bar k. The total score when selecting those k vertical bars is J's score. However, you are in the Amidakuji You can select one horizontal bar and delete that horizontal bar from the Amidakuji. (You do not have to delete it.) If you delete one horizontal bar, the vertical bar in the deleted Amidakuji will be displayed vertically. J's score is the total of the points when selecting k consecutive vertical bars from bar 1 to vertical bar k.
Given the shape of the Amida lottery and the number of vertical bars k that J chooses as input, create a program that finds the minimum value of J's score.
input
The input consists of multiple datasets. Each dataset is given in the following format.
On the first line, four integers n, m, h, k are written separated by blanks. N (2 ≤ n ≤ 1000) is the number of vertical bars, and m (1 ≤ m ≤ 100000) is the horizontal bar. H (2 ≤ h ≤ 1000) represents the length of the vertical bar, and k (1 ≤ k ≤ n) represents the number of vertical bars you choose.
The following n lines contain the score written at the bottom of the vertical bar. The first line (1 ≤ i ≤ n) contains the positive integer si. Also, s1 + s2 + ... + sn ≤ 2000000000 = 2 × 109.
The following m lines indicate the position of the horizontal bar. The horizontal bars are numbered from 1 to m. The first line (1 ≤ i ≤ m) is the horizontal bar i. The two integers ai, bi (1 ≤ ai ≤ n --1, 1 ≤ bi ≤ h --1) representing the position are separated by blanks, and the horizontal bar i connects the vertical bar ai and the vertical bar ai + 1. , Indicates that the distance from the top edge of the horizontal bar i is bi. However, no two horizontal bars share an endpoint.
Of the scoring data, 20% of the points will have the lowest score for Mr. J if the horizontal bar is not deleted. Also, 30% of the points will satisfy n ≤ 20, m ≤ 30, h ≤ 10. 60% of the points are m ≤ 1000.
The end of the input is indicated by a line containing four zeros. The number of datasets does not exceed 10.
output
For each dataset, output the minimum score of Mr. J on one line.
Examples
Input
4 5 7 2
20
80
100
50
1 1
2 6
2 3
1 5
3 1
2 2 5 1
10
20
1 1
1 3
0 0 0 0
Output
100
10
Input
None
Output
None
Submitted Solution:
```
while True:
n,m,h,k = map(int,input().split())
if not n: break
s_lst = [int(input()) for _ in range(n)]
b_lst = [tuple(map(int,input().split())) for _ in range(m)]
b_lst = sorted(b_lst,key=lambda x:-x[1])
h_map = [[s_lst[i] for i in range(n)] for _ in range(h)]
for bar in b_lst:
ind, height = bar[0], bar[1] - 1
temp = h_map[height][ind]
h_map[height + 1][ind - 1] = temp
temp = h_map[height][ind - 1]
h_map[height + 1][ind] = temp
dic = dict()
for i in range(n):
dic[h_map[0][i]] = i
ans = sum(h_map[0][:k])
max_decrease = 0
for bar in b_lst:
ind, height = bar[0], bar[1] - 1
v1 = h_map[height][ind]
v2 = h_map[height][ind - 1]
if v1 < v2 and v2 - v1 > max_decrease and dic[v1] >= k and dic[v2] < k:
max_decrease = v2 - v1
elif v2 < v1 and v1 - v2 > max_decrease and dic[v2] >= k and dic[v1] < k:
max_decrease = v1 - v2
print(ans - max_decrease)
``` | instruction | 0 | 45,327 | 19 | 90,654 |
No | output | 1 | 45,327 | 19 | 90,655 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
You are playing with J using the Midakuji. The Amida lottery consists of n vertical bars and m horizontal bars. The vertical bars are numbered from 1 to n in order from the left, and the vertical bar i The positive integer si is written at the bottom of.
<image>
Figure 3-1 Example of Amidakuji (n = 4, m = 5, s1 = 20, s2 = 80, s3 = 100, s4 = 50)
The integer written at the bottom of the vertical bar i, which is reached by following the path from the top of the vertical bar i, is the score when the vertical bar i is selected. For example, in Fig. 3-1 the vertical bar 1 is selected. And the score is 80 points, and if the vertical bar 2 is selected, the score is 100 points.
<image>
Figure 3-2 Example of how to follow the road
Mr. J decides to choose a series of k books from vertical bar 1 to vertical bar k. The total score when selecting those k vertical bars is J's score. However, you are in the Amidakuji You can select one horizontal bar and delete that horizontal bar from the Amidakuji. (You do not have to delete it.) If you delete one horizontal bar, the vertical bar in the deleted Amidakuji will be displayed vertically. J's score is the total of the points when selecting k consecutive vertical bars from bar 1 to vertical bar k.
Given the shape of the Amida lottery and the number of vertical bars k that J chooses as input, create a program that finds the minimum value of J's score.
input
The input consists of multiple datasets. Each dataset is given in the following format.
On the first line, four integers n, m, h, k are written separated by blanks. N (2 ≤ n ≤ 1000) is the number of vertical bars, and m (1 ≤ m ≤ 100000) is the horizontal bar. H (2 ≤ h ≤ 1000) represents the length of the vertical bar, and k (1 ≤ k ≤ n) represents the number of vertical bars you choose.
The following n lines contain the score written at the bottom of the vertical bar. The first line (1 ≤ i ≤ n) contains the positive integer si. Also, s1 + s2 + ... + sn ≤ 2000000000 = 2 × 109.
The following m lines indicate the position of the horizontal bar. The horizontal bars are numbered from 1 to m. The first line (1 ≤ i ≤ m) is the horizontal bar i. The two integers ai, bi (1 ≤ ai ≤ n --1, 1 ≤ bi ≤ h --1) representing the position are separated by blanks, and the horizontal bar i connects the vertical bar ai and the vertical bar ai + 1. , Indicates that the distance from the top edge of the horizontal bar i is bi. However, no two horizontal bars share an endpoint.
Of the scoring data, 20% of the points will have the lowest score for Mr. J if the horizontal bar is not deleted. Also, 30% of the points will satisfy n ≤ 20, m ≤ 30, h ≤ 10. 60% of the points are m ≤ 1000.
The end of the input is indicated by a line containing four zeros. The number of datasets does not exceed 10.
output
For each dataset, output the minimum score of Mr. J on one line.
Examples
Input
4 5 7 2
20
80
100
50
1 1
2 6
2 3
1 5
3 1
2 2 5 1
10
20
1 1
1 3
0 0 0 0
Output
100
10
Input
None
Output
None
Submitted Solution:
```
while True:
n, m, h, k = map(int, input().split())
if not n:
break
points = [int(input()) for _ in range(n)]
bars = [tuple(map(int, input().split())) for _ in range(m)]
bars_h = [set() for _ in range(h)]
for ba, bh in bars:
bars_h[bh].add(ba - 1)
swap = [points] + [None] * m
pattern = 1
for i in range(h - 1, 0, -1):
for ba in bars_h[i]:
swap[pattern] = swap[0][:]
for s in swap[:pattern]:
s[ba], s[ba + 1] = s[ba + 1], s[ba]
pattern += 1
print(min(sum(s[:k]) for s in swap))
``` | instruction | 0 | 45,328 | 19 | 90,656 |
No | output | 1 | 45,328 | 19 | 90,657 |
Provide a correct Python 3 solution for this coding contest problem.
Honestly, a rabbit does not matter.
There is a rabbit playing a stage system action game. In this game, every stage has a difficulty level. The rabbit, which always needs challenges, basically wants to play more difficult stages than he has ever played. However, he sometimes needs rest too. So, to compromise, he admitted to play T or less levels easier stages than the preceding one.
How many ways are there to play all the stages at once, while honoring the convention above? Maybe the answer will be a large number. So, let me know the answer modulo 1,000,000,007.
Input
The first line of input contains two integers N and T (1 ≤ N ≤ 100,000, 1 ≤ T ≤ 10,000). N is the number of stages, and T is the compromise level.
The following N lines describe the difficulty levels of each stage. The i-th line contains one integer Di (1 ≤ Di ≤ 100,000), which is the difficulty level of the i-th stage.
Output
Calculate how many ways to play all the stages at once there are. Print the answer modulo 1,000,000,007 in a line.
Examples
Input
3 1
1
2
3
Output
4
Input
5 3
9
2
6
8
8
Output
24
Input
5 7
9
9
9
1
5
Output
48 | instruction | 0 | 45,337 | 19 | 90,674 |
"Correct Solution:
```
from collections import Counter
MOD = 10**9+7
n, t = map(int, input().split())
d = [int(input()) for _ in range(n)]
d.sort(reverse=True)
c = Counter(d)
cum = [0 for _ in range(200002)]
for i in range(100000, 0, -1):
cum[i] = cum[i+1] + c[i]
ans = 1
for i, x in enumerate(d):
mul = i+1 - cum[x+t+1]
ans *= mul
ans %= MOD
print(ans)
``` | output | 1 | 45,337 | 19 | 90,675 |
Provide a correct Python 3 solution for this coding contest problem.
Honestly, a rabbit does not matter.
There is a rabbit playing a stage system action game. In this game, every stage has a difficulty level. The rabbit, which always needs challenges, basically wants to play more difficult stages than he has ever played. However, he sometimes needs rest too. So, to compromise, he admitted to play T or less levels easier stages than the preceding one.
How many ways are there to play all the stages at once, while honoring the convention above? Maybe the answer will be a large number. So, let me know the answer modulo 1,000,000,007.
Input
The first line of input contains two integers N and T (1 ≤ N ≤ 100,000, 1 ≤ T ≤ 10,000). N is the number of stages, and T is the compromise level.
The following N lines describe the difficulty levels of each stage. The i-th line contains one integer Di (1 ≤ Di ≤ 100,000), which is the difficulty level of the i-th stage.
Output
Calculate how many ways to play all the stages at once there are. Print the answer modulo 1,000,000,007 in a line.
Examples
Input
3 1
1
2
3
Output
4
Input
5 3
9
2
6
8
8
Output
24
Input
5 7
9
9
9
1
5
Output
48 | instruction | 0 | 45,338 | 19 | 90,676 |
"Correct Solution:
```
import sys
import bisect
# ???????????¨?????????DP?
#
def main():
n,t = map(int, sys.stdin.readline().split())
levels = []
for i in range(n):
d = int(sys.stdin.readline())
levels.append(d)
levels.sort()
ans = 1
for i in range(n):
cnt = i - bisect.bisect_left(levels, levels[i] - t) + 1
ans *= cnt
ans %= 1000000007
print(ans)
if __name__ == '__main__':
main()
``` | output | 1 | 45,338 | 19 | 90,677 |
Provide a correct Python 3 solution for this coding contest problem.
Honestly, a rabbit does not matter.
There is a rabbit playing a stage system action game. In this game, every stage has a difficulty level. The rabbit, which always needs challenges, basically wants to play more difficult stages than he has ever played. However, he sometimes needs rest too. So, to compromise, he admitted to play T or less levels easier stages than the preceding one.
How many ways are there to play all the stages at once, while honoring the convention above? Maybe the answer will be a large number. So, let me know the answer modulo 1,000,000,007.
Input
The first line of input contains two integers N and T (1 ≤ N ≤ 100,000, 1 ≤ T ≤ 10,000). N is the number of stages, and T is the compromise level.
The following N lines describe the difficulty levels of each stage. The i-th line contains one integer Di (1 ≤ Di ≤ 100,000), which is the difficulty level of the i-th stage.
Output
Calculate how many ways to play all the stages at once there are. Print the answer modulo 1,000,000,007 in a line.
Examples
Input
3 1
1
2
3
Output
4
Input
5 3
9
2
6
8
8
Output
24
Input
5 7
9
9
9
1
5
Output
48 | instruction | 0 | 45,339 | 19 | 90,678 |
"Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
n,t = LI()
a = sorted([I() for _ in range(n)])
r = 1
i = 0
for j in range(n):
while a[i] < a[j] - t:
i += 1
r *= j-i+1
r %= mod
return r
print(main())
``` | output | 1 | 45,339 | 19 | 90,679 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ani and Borna are playing a short game on a two-variable polynomial. It's a special kind of a polynomial: the monomials are fixed, but all of its coefficients are fill-in-the-blanks dashes, e.g. $$$ \\_ xy + \\_ x^4 y^7 + \\_ x^8 y^3 + … $$$
Borna will fill in the blanks with positive integers. He wants the polynomial to be bounded from below, i.e. his goal is to make sure there exists a real number M such that the value of the polynomial at any point is greater than M.
Ani is mischievous, and wants the polynomial to be unbounded. Along with stealing Borna's heart, she can also steal parts of polynomials. Ani is only a petty kind of thief, though: she can only steal at most one monomial from the polynomial before Borna fills in the blanks.
If Ani and Borna play their only moves optimally, who wins?
Input
The first line contains a positive integer N (2 ≤ N ≤ 200 000), denoting the number of the terms in the starting special polynomial.
Each of the following N lines contains a description of a monomial: the k-th line contains two **space**-separated integers a_k and b_k (0 ≤ a_k, b_k ≤ 10^9) which mean the starting polynomial has the term \\_ x^{a_k} y^{b_k}. It is guaranteed that for k ≠ l, either a_k ≠ a_l or b_k ≠ b_l.
Output
If Borna can always choose the coefficients such that the resulting polynomial is bounded from below, regardless of what monomial Ani steals, output "Borna". Else, output "Ani".
You shouldn't output the quotation marks.
Examples
Input
3
1 1
2 0
0 2
Output
Ani
Input
4
0 0
0 1
0 2
0 8
Output
Borna
Note
In the first sample, the initial polynomial is \\_xy+ \\_x^2 + \\_y^2. If Ani steals the \\_y^2 term, Borna is left with \\_xy+\\_x^2. Whatever positive integers are written on the blanks, y → -∞ and x := 1 makes the whole expression go to negative infinity.
In the second sample, the initial polynomial is \\_1 + \\_x + \\_x^2 + \\_x^8. One can check that no matter what term Ani steals, Borna can always win.
Submitted Solution:
```
n = int(input())
x = []
y = []
for i in range(n):
a, b = map(int, input().split())
x.append(a)
y.append(b)
x.sort()
y.sort()
if i < 2:
continue
x = x[1:]
y = y[1:]
if x[0] % 2 == 1 or x[1] % 2 == 1 or y[0] % 2 == 1 or y[1] % 2 == 1:
print("Ani")
else:
print("Borna")
``` | instruction | 0 | 45,402 | 19 | 90,804 |
No | output | 1 | 45,402 | 19 | 90,805 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ani and Borna are playing a short game on a two-variable polynomial. It's a special kind of a polynomial: the monomials are fixed, but all of its coefficients are fill-in-the-blanks dashes, e.g. $$$ \\_ xy + \\_ x^4 y^7 + \\_ x^8 y^3 + … $$$
Borna will fill in the blanks with positive integers. He wants the polynomial to be bounded from below, i.e. his goal is to make sure there exists a real number M such that the value of the polynomial at any point is greater than M.
Ani is mischievous, and wants the polynomial to be unbounded. Along with stealing Borna's heart, she can also steal parts of polynomials. Ani is only a petty kind of thief, though: she can only steal at most one monomial from the polynomial before Borna fills in the blanks.
If Ani and Borna play their only moves optimally, who wins?
Input
The first line contains a positive integer N (2 ≤ N ≤ 200 000), denoting the number of the terms in the starting special polynomial.
Each of the following N lines contains a description of a monomial: the k-th line contains two **space**-separated integers a_k and b_k (0 ≤ a_k, b_k ≤ 10^9) which mean the starting polynomial has the term \\_ x^{a_k} y^{b_k}. It is guaranteed that for k ≠ l, either a_k ≠ a_l or b_k ≠ b_l.
Output
If Borna can always choose the coefficients such that the resulting polynomial is bounded from below, regardless of what monomial Ani steals, output "Borna". Else, output "Ani".
You shouldn't output the quotation marks.
Examples
Input
3
1 1
2 0
0 2
Output
Ani
Input
4
0 0
0 1
0 2
0 8
Output
Borna
Note
In the first sample, the initial polynomial is \\_xy+ \\_x^2 + \\_y^2. If Ani steals the \\_y^2 term, Borna is left with \\_xy+\\_x^2. Whatever positive integers are written on the blanks, y → -∞ and x := 1 makes the whole expression go to negative infinity.
In the second sample, the initial polynomial is \\_1 + \\_x + \\_x^2 + \\_x^8. One can check that no matter what term Ani steals, Borna can always win.
Submitted Solution:
```
import random
a6 = random.randint(1,2)
if a6 == 1:
print('Ani')
else:
print('Borna')
``` | instruction | 0 | 45,403 | 19 | 90,806 |
No | output | 1 | 45,403 | 19 | 90,807 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ani and Borna are playing a short game on a two-variable polynomial. It's a special kind of a polynomial: the monomials are fixed, but all of its coefficients are fill-in-the-blanks dashes, e.g. $$$ \\_ xy + \\_ x^4 y^7 + \\_ x^8 y^3 + … $$$
Borna will fill in the blanks with positive integers. He wants the polynomial to be bounded from below, i.e. his goal is to make sure there exists a real number M such that the value of the polynomial at any point is greater than M.
Ani is mischievous, and wants the polynomial to be unbounded. Along with stealing Borna's heart, she can also steal parts of polynomials. Ani is only a petty kind of thief, though: she can only steal at most one monomial from the polynomial before Borna fills in the blanks.
If Ani and Borna play their only moves optimally, who wins?
Input
The first line contains a positive integer N (2 ≤ N ≤ 200 000), denoting the number of the terms in the starting special polynomial.
Each of the following N lines contains a description of a monomial: the k-th line contains two **space**-separated integers a_k and b_k (0 ≤ a_k, b_k ≤ 10^9) which mean the starting polynomial has the term \\_ x^{a_k} y^{b_k}. It is guaranteed that for k ≠ l, either a_k ≠ a_l or b_k ≠ b_l.
Output
If Borna can always choose the coefficients such that the resulting polynomial is bounded from below, regardless of what monomial Ani steals, output "Borna". Else, output "Ani".
You shouldn't output the quotation marks.
Examples
Input
3
1 1
2 0
0 2
Output
Ani
Input
4
0 0
0 1
0 2
0 8
Output
Borna
Note
In the first sample, the initial polynomial is \\_xy+ \\_x^2 + \\_y^2. If Ani steals the \\_y^2 term, Borna is left with \\_xy+\\_x^2. Whatever positive integers are written on the blanks, y → -∞ and x := 1 makes the whole expression go to negative infinity.
In the second sample, the initial polynomial is \\_1 + \\_x + \\_x^2 + \\_x^8. One can check that no matter what term Ani steals, Borna can always win.
Submitted Solution:
```
import random
a7 = random.randint(1,2)
if a7 == 1:
print('Ani')
else:
print('Borna')
``` | instruction | 0 | 45,404 | 19 | 90,808 |
No | output | 1 | 45,404 | 19 | 90,809 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ani and Borna are playing a short game on a two-variable polynomial. It's a special kind of a polynomial: the monomials are fixed, but all of its coefficients are fill-in-the-blanks dashes, e.g. $$$ \\_ xy + \\_ x^4 y^7 + \\_ x^8 y^3 + … $$$
Borna will fill in the blanks with positive integers. He wants the polynomial to be bounded from below, i.e. his goal is to make sure there exists a real number M such that the value of the polynomial at any point is greater than M.
Ani is mischievous, and wants the polynomial to be unbounded. Along with stealing Borna's heart, she can also steal parts of polynomials. Ani is only a petty kind of thief, though: she can only steal at most one monomial from the polynomial before Borna fills in the blanks.
If Ani and Borna play their only moves optimally, who wins?
Input
The first line contains a positive integer N (2 ≤ N ≤ 200 000), denoting the number of the terms in the starting special polynomial.
Each of the following N lines contains a description of a monomial: the k-th line contains two **space**-separated integers a_k and b_k (0 ≤ a_k, b_k ≤ 10^9) which mean the starting polynomial has the term \\_ x^{a_k} y^{b_k}. It is guaranteed that for k ≠ l, either a_k ≠ a_l or b_k ≠ b_l.
Output
If Borna can always choose the coefficients such that the resulting polynomial is bounded from below, regardless of what monomial Ani steals, output "Borna". Else, output "Ani".
You shouldn't output the quotation marks.
Examples
Input
3
1 1
2 0
0 2
Output
Ani
Input
4
0 0
0 1
0 2
0 8
Output
Borna
Note
In the first sample, the initial polynomial is \\_xy+ \\_x^2 + \\_y^2. If Ani steals the \\_y^2 term, Borna is left with \\_xy+\\_x^2. Whatever positive integers are written on the blanks, y → -∞ and x := 1 makes the whole expression go to negative infinity.
In the second sample, the initial polynomial is \\_1 + \\_x + \\_x^2 + \\_x^8. One can check that no matter what term Ani steals, Borna can always win.
Submitted Solution:
```
import random
a = random.randint(1,2)
if a == 1:
print('Ani')
else:
print('Borna')
``` | instruction | 0 | 45,405 | 19 | 90,810 |
No | output | 1 | 45,405 | 19 | 90,811 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a very ancient country the following game was popular. Two people play the game. Initially first player writes a string s1, consisting of exactly nine digits and representing a number that does not exceed a. After that second player looks at s1 and writes a string s2, consisting of exactly nine digits and representing a number that does not exceed b. Here a and b are some given constants, s1 and s2 are chosen by the players. The strings are allowed to contain leading zeroes.
If a number obtained by the concatenation (joining together) of strings s1 and s2 is divisible by mod, then the second player wins. Otherwise the first player wins. You are given numbers a, b, mod. Your task is to determine who wins if both players play in the optimal manner. If the first player wins, you are also required to find the lexicographically minimum winning move.
Input
The first line contains three integers a, b, mod (0 ≤ a, b ≤ 109, 1 ≤ mod ≤ 107).
Output
If the first player wins, print "1" and the lexicographically minimum string s1 he has to write to win. If the second player wins, print the single number "2".
Examples
Input
1 10 7
Output
2
Input
4 0 9
Output
1 000000001
Note
The lexical comparison of strings is performed by the < operator in modern programming languages. String x is lexicographically less than string y if exists such i (1 ≤ i ≤ 9), that xi < yi, and for any j (1 ≤ j < i) xj = yj. These strings always have length 9. | instruction | 0 | 45,456 | 19 | 90,912 |
Tags: brute force, number theory
Correct Solution:
```
a, b, m = map(int, input().split())
k = s = 10 ** 9 % m
i = 0
while k and i < a:
i += 1
if k < m - b: exit(print(1, str(i).zfill(9)))
k += s
if k >= m: k -= m
print(2)
``` | output | 1 | 45,456 | 19 | 90,913 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a very ancient country the following game was popular. Two people play the game. Initially first player writes a string s1, consisting of exactly nine digits and representing a number that does not exceed a. After that second player looks at s1 and writes a string s2, consisting of exactly nine digits and representing a number that does not exceed b. Here a and b are some given constants, s1 and s2 are chosen by the players. The strings are allowed to contain leading zeroes.
If a number obtained by the concatenation (joining together) of strings s1 and s2 is divisible by mod, then the second player wins. Otherwise the first player wins. You are given numbers a, b, mod. Your task is to determine who wins if both players play in the optimal manner. If the first player wins, you are also required to find the lexicographically minimum winning move.
Input
The first line contains three integers a, b, mod (0 ≤ a, b ≤ 109, 1 ≤ mod ≤ 107).
Output
If the first player wins, print "1" and the lexicographically minimum string s1 he has to write to win. If the second player wins, print the single number "2".
Examples
Input
1 10 7
Output
2
Input
4 0 9
Output
1 000000001
Note
The lexical comparison of strings is performed by the < operator in modern programming languages. String x is lexicographically less than string y if exists such i (1 ≤ i ≤ 9), that xi < yi, and for any j (1 ≤ j < i) xj = yj. These strings always have length 9. | instruction | 0 | 45,457 | 19 | 90,914 |
Tags: brute force, number theory
Correct Solution:
```
import sys
from math import *
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return map(int, minp().split())
a,b,mod = mints()
z = (10**9)%mod
c = 0
for i in range(min(a+1,mod)):
if c != 0 and mod-c > b:
s = str(i)
s = '0'*(9-len(s))+s
print(1, s)
exit(0)
c += z
if c >= mod:
c -= mod
print(2)
``` | output | 1 | 45,457 | 19 | 90,915 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a very ancient country the following game was popular. Two people play the game. Initially first player writes a string s1, consisting of exactly nine digits and representing a number that does not exceed a. After that second player looks at s1 and writes a string s2, consisting of exactly nine digits and representing a number that does not exceed b. Here a and b are some given constants, s1 and s2 are chosen by the players. The strings are allowed to contain leading zeroes.
If a number obtained by the concatenation (joining together) of strings s1 and s2 is divisible by mod, then the second player wins. Otherwise the first player wins. You are given numbers a, b, mod. Your task is to determine who wins if both players play in the optimal manner. If the first player wins, you are also required to find the lexicographically minimum winning move.
Input
The first line contains three integers a, b, mod (0 ≤ a, b ≤ 109, 1 ≤ mod ≤ 107).
Output
If the first player wins, print "1" and the lexicographically minimum string s1 he has to write to win. If the second player wins, print the single number "2".
Examples
Input
1 10 7
Output
2
Input
4 0 9
Output
1 000000001
Note
The lexical comparison of strings is performed by the < operator in modern programming languages. String x is lexicographically less than string y if exists such i (1 ≤ i ≤ 9), that xi < yi, and for any j (1 ≤ j < i) xj = yj. These strings always have length 9. | instruction | 0 | 45,458 | 19 | 90,916 |
Tags: brute force, number theory
Correct Solution:
```
a,b,m=map(int,input().split())
k=s=(10**9)%m
i=0
while k and i<a:
i+=1
if k<m-b:exit(print(1, str(i).zfill(9)))
k+=s
if k>=m:k-=m
print(2)
``` | output | 1 | 45,458 | 19 | 90,917 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a very ancient country the following game was popular. Two people play the game. Initially first player writes a string s1, consisting of exactly nine digits and representing a number that does not exceed a. After that second player looks at s1 and writes a string s2, consisting of exactly nine digits and representing a number that does not exceed b. Here a and b are some given constants, s1 and s2 are chosen by the players. The strings are allowed to contain leading zeroes.
If a number obtained by the concatenation (joining together) of strings s1 and s2 is divisible by mod, then the second player wins. Otherwise the first player wins. You are given numbers a, b, mod. Your task is to determine who wins if both players play in the optimal manner. If the first player wins, you are also required to find the lexicographically minimum winning move.
Input
The first line contains three integers a, b, mod (0 ≤ a, b ≤ 109, 1 ≤ mod ≤ 107).
Output
If the first player wins, print "1" and the lexicographically minimum string s1 he has to write to win. If the second player wins, print the single number "2".
Examples
Input
1 10 7
Output
2
Input
4 0 9
Output
1 000000001
Note
The lexical comparison of strings is performed by the < operator in modern programming languages. String x is lexicographically less than string y if exists such i (1 ≤ i ≤ 9), that xi < yi, and for any j (1 ≤ j < i) xj = yj. These strings always have length 9. | instruction | 0 | 45,459 | 19 | 90,918 |
Tags: brute force, number theory
Correct Solution:
```
a, b, m = map(int, input().split())
c = (10 ** 9) % m
ans = -1
for x in range(1, min(a + 1, m)):
z = (x * c) % m
if z == 0:
continue
if z + b < m:
ans = x
break
if ans == -1:
print(2)
else:
s = str(ans)
s = ('0' * 9 + s)[-9:]
print(1, s)
``` | output | 1 | 45,459 | 19 | 90,919 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a very ancient country the following game was popular. Two people play the game. Initially first player writes a string s1, consisting of exactly nine digits and representing a number that does not exceed a. After that second player looks at s1 and writes a string s2, consisting of exactly nine digits and representing a number that does not exceed b. Here a and b are some given constants, s1 and s2 are chosen by the players. The strings are allowed to contain leading zeroes.
If a number obtained by the concatenation (joining together) of strings s1 and s2 is divisible by mod, then the second player wins. Otherwise the first player wins. You are given numbers a, b, mod. Your task is to determine who wins if both players play in the optimal manner. If the first player wins, you are also required to find the lexicographically minimum winning move.
Input
The first line contains three integers a, b, mod (0 ≤ a, b ≤ 109, 1 ≤ mod ≤ 107).
Output
If the first player wins, print "1" and the lexicographically minimum string s1 he has to write to win. If the second player wins, print the single number "2".
Examples
Input
1 10 7
Output
2
Input
4 0 9
Output
1 000000001
Note
The lexical comparison of strings is performed by the < operator in modern programming languages. String x is lexicographically less than string y if exists such i (1 ≤ i ≤ 9), that xi < yi, and for any j (1 ≤ j < i) xj = yj. These strings always have length 9.
Submitted Solution:
```
import sys
a,b, mod= map(int, input().split())
if mod == 1 or a == 0:
print(2)
exit()
for i in range (1, min(a,mod-1)+1):
temp = i * 1000000000 % mod
if (mod - temp) % mod > b and temp != 0:
print("1 00000000", i)
exit()
print(2)
``` | instruction | 0 | 45,460 | 19 | 90,920 |
No | output | 1 | 45,460 | 19 | 90,921 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a very ancient country the following game was popular. Two people play the game. Initially first player writes a string s1, consisting of exactly nine digits and representing a number that does not exceed a. After that second player looks at s1 and writes a string s2, consisting of exactly nine digits and representing a number that does not exceed b. Here a and b are some given constants, s1 and s2 are chosen by the players. The strings are allowed to contain leading zeroes.
If a number obtained by the concatenation (joining together) of strings s1 and s2 is divisible by mod, then the second player wins. Otherwise the first player wins. You are given numbers a, b, mod. Your task is to determine who wins if both players play in the optimal manner. If the first player wins, you are also required to find the lexicographically minimum winning move.
Input
The first line contains three integers a, b, mod (0 ≤ a, b ≤ 109, 1 ≤ mod ≤ 107).
Output
If the first player wins, print "1" and the lexicographically minimum string s1 he has to write to win. If the second player wins, print the single number "2".
Examples
Input
1 10 7
Output
2
Input
4 0 9
Output
1 000000001
Note
The lexical comparison of strings is performed by the < operator in modern programming languages. String x is lexicographically less than string y if exists such i (1 ≤ i ≤ 9), that xi < yi, and for any j (1 ≤ j < i) xj = yj. These strings always have length 9.
Submitted Solution:
```
def solve():
a, b, mod = map(int, input().split())
a %= mod
start = max(0, a - mod)
for i in range(start, a + 1):
other = (mod - i) % mod
if other > b:
print(1, i)
return
print(2)
solve()
``` | instruction | 0 | 45,461 | 19 | 90,922 |
No | output | 1 | 45,461 | 19 | 90,923 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a very ancient country the following game was popular. Two people play the game. Initially first player writes a string s1, consisting of exactly nine digits and representing a number that does not exceed a. After that second player looks at s1 and writes a string s2, consisting of exactly nine digits and representing a number that does not exceed b. Here a and b are some given constants, s1 and s2 are chosen by the players. The strings are allowed to contain leading zeroes.
If a number obtained by the concatenation (joining together) of strings s1 and s2 is divisible by mod, then the second player wins. Otherwise the first player wins. You are given numbers a, b, mod. Your task is to determine who wins if both players play in the optimal manner. If the first player wins, you are also required to find the lexicographically minimum winning move.
Input
The first line contains three integers a, b, mod (0 ≤ a, b ≤ 109, 1 ≤ mod ≤ 107).
Output
If the first player wins, print "1" and the lexicographically minimum string s1 he has to write to win. If the second player wins, print the single number "2".
Examples
Input
1 10 7
Output
2
Input
4 0 9
Output
1 000000001
Note
The lexical comparison of strings is performed by the < operator in modern programming languages. String x is lexicographically less than string y if exists such i (1 ≤ i ≤ 9), that xi < yi, and for any j (1 ≤ j < i) xj = yj. These strings always have length 9.
Submitted Solution:
```
import sys
a,b, mod= map(int, input().split())
if mod == 1 or a == 0:
print(2)
exit()
for i in range (1, min(a,mod-1)+1):
temp = i * 1000000000 % mod
if (mod - temp) % mod > b and temp != 0:
print("1 00000000"+str(i))
exit()
print(2)
``` | instruction | 0 | 45,462 | 19 | 90,924 |
No | output | 1 | 45,462 | 19 | 90,925 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a deck of n cards numbered from 1 to n (not necessarily in this order in the deck). You have to sort the deck by repeating the following operation.
* Choose 2 ≤ k ≤ n and split the deck in k nonempty contiguous parts D_1, D_2,..., D_k (D_1 contains the first |D_1| cards of the deck, D_2 contains the following |D_2| cards and so on). Then reverse the order of the parts, transforming the deck into D_k, D_{k-1}, ..., D_2, D_1 (so, the first |D_k| cards of the new deck are D_k, the following |D_{k-1}| cards are D_{k-1} and so on). The internal order of each packet of cards D_i is unchanged by the operation.
You have to obtain a sorted deck (i.e., a deck where the first card is 1, the second is 2 and so on) performing at most n operations. It can be proven that it is always possible to sort the deck performing at most n operations.
Examples of operation: The following are three examples of valid operations (on three decks with different sizes).
* If the deck is [3 6 2 1 4 5 7] (so 3 is the first card and 7 is the last card), we may apply the operation with k=4 and D_1=[3 6], D_2=[2 1 4], D_3=[5], D_4=[7]. Doing so, the deck becomes [7 5 2 1 4 3 6].
* If the deck is [3 1 2], we may apply the operation with k=3 and D_1=[3], D_2=[1], D_3=[2]. Doing so, the deck becomes [2 1 3].
* If the deck is [5 1 2 4 3 6], we may apply the operation with k=2 and D_1=[5 1], D_2=[2 4 3 6]. Doing so, the deck becomes [2 4 3 6 5 1].
Input
The first line of the input contains one integer n (1≤ n≤ 52) — the number of cards in the deck.
The second line contains n integers c_1, c_2, ..., c_n — the cards in the deck. The first card is c_1, the second is c_2 and so on.
It is guaranteed that for all i=1,...,n there is exactly one j∈\{1,...,n\} such that c_j = i.
Output
On the first line, print the number q of operations you perform (it must hold 0≤ q≤ n).
Then, print q lines, each describing one operation.
To describe an operation, print on a single line the number k of parts you are going to split the deck in, followed by the size of the k parts: |D_1|, |D_2|, ... , |D_k|.
It must hold 2≤ k≤ n, and |D_i|≥ 1 for all i=1,...,k, and |D_1|+|D_2|+⋅⋅⋅ + |D_k| = n.
It can be proven that it is always possible to sort the deck performing at most n operations. If there are several ways to sort the deck you can output any of them.
Examples
Input
4
3 1 2 4
Output
2
3 1 2 1
2 1 3
Input
6
6 5 4 3 2 1
Output
1
6 1 1 1 1 1 1
Input
1
1
Output
0
Note
Explanation of the first testcase: Initially the deck is [3 1 2 4].
* The first operation splits the deck as [(3) (1 2) (4)] and then transforms it into [4 1 2 3].
* The second operation splits the deck as [(4) (1 2 3)] and then transforms it into [1 2 3 4].
Explanation of the second testcase: Initially the deck is [6 5 4 3 2 1].
* The first (and only) operation splits the deck as [(6) (5) (4) (3) (2) (1)] and then transforms it into [1 2 3 4 5 6].
Submitted Solution:
```
import sys
import random
from typing import NamedTuple
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
input = sys.stdin.readline
class Segment(NamedTuple):
start: int
end: int
@property
def size(self):
return self.end - self.start + 1
def shuffle(a, sizes):
n = len(a)
assert len(sizes) > 1, len(sizes)
assert sum(sizes) == len(a), (sum(sizes), n)
result = [None for i in range(n)]
offset = 0
for size in sizes:
assert size > 0, size
segment = A[offset: offset + size]
result[n - offset - size: n - offset] = segment
offset += size
return result
def split_into_segments(a):
n = len(a)
result = []
size = 1
for i in range(1, n):
if a[i] == a[i-1] + 1:
size += 1
else:
segment = Segment(start=a[i-size], end=a[i-1])
result.append(segment)
size = 1
result.append(Segment(start=a[n-size], end=a[n-1]))
assert sum(segment.size for segment in result) == n
return result
N = int(input())
A = list(map(int, input().split()))
ans = []
segments = split_into_segments(A)
while len(segments) > 1:
# print(A)
# for segment in segments:
# print(segment)
K = len(segments)
split = None
for i in range(K-1):
for j in range(i+1, K):
if segments[i].start == segments[j].end + 1:
split = list(filter(None, [
sum(segments[k].size for k in range(i)) if i else 0,
sum(segments[k].size for k in range(i, j)),
segments[j].size,
sum(segments[k].size for k in range(j+1, K)) if j != K - 1 else 0,
]))
break
if split is not None:
break
# print("Fucking split is ", split)
ans.append(split)
A = shuffle(A, split)
segments = split_into_segments(A)
# print('============')
print(len(ans))
for operation in ans:
print(len(operation), end=' ')
print(' '.join(map(str, operation)))
``` | instruction | 0 | 45,579 | 19 | 91,158 |
Yes | output | 1 | 45,579 | 19 | 91,159 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a deck of n cards numbered from 1 to n (not necessarily in this order in the deck). You have to sort the deck by repeating the following operation.
* Choose 2 ≤ k ≤ n and split the deck in k nonempty contiguous parts D_1, D_2,..., D_k (D_1 contains the first |D_1| cards of the deck, D_2 contains the following |D_2| cards and so on). Then reverse the order of the parts, transforming the deck into D_k, D_{k-1}, ..., D_2, D_1 (so, the first |D_k| cards of the new deck are D_k, the following |D_{k-1}| cards are D_{k-1} and so on). The internal order of each packet of cards D_i is unchanged by the operation.
You have to obtain a sorted deck (i.e., a deck where the first card is 1, the second is 2 and so on) performing at most n operations. It can be proven that it is always possible to sort the deck performing at most n operations.
Examples of operation: The following are three examples of valid operations (on three decks with different sizes).
* If the deck is [3 6 2 1 4 5 7] (so 3 is the first card and 7 is the last card), we may apply the operation with k=4 and D_1=[3 6], D_2=[2 1 4], D_3=[5], D_4=[7]. Doing so, the deck becomes [7 5 2 1 4 3 6].
* If the deck is [3 1 2], we may apply the operation with k=3 and D_1=[3], D_2=[1], D_3=[2]. Doing so, the deck becomes [2 1 3].
* If the deck is [5 1 2 4 3 6], we may apply the operation with k=2 and D_1=[5 1], D_2=[2 4 3 6]. Doing so, the deck becomes [2 4 3 6 5 1].
Input
The first line of the input contains one integer n (1≤ n≤ 52) — the number of cards in the deck.
The second line contains n integers c_1, c_2, ..., c_n — the cards in the deck. The first card is c_1, the second is c_2 and so on.
It is guaranteed that for all i=1,...,n there is exactly one j∈\{1,...,n\} such that c_j = i.
Output
On the first line, print the number q of operations you perform (it must hold 0≤ q≤ n).
Then, print q lines, each describing one operation.
To describe an operation, print on a single line the number k of parts you are going to split the deck in, followed by the size of the k parts: |D_1|, |D_2|, ... , |D_k|.
It must hold 2≤ k≤ n, and |D_i|≥ 1 for all i=1,...,k, and |D_1|+|D_2|+⋅⋅⋅ + |D_k| = n.
It can be proven that it is always possible to sort the deck performing at most n operations. If there are several ways to sort the deck you can output any of them.
Examples
Input
4
3 1 2 4
Output
2
3 1 2 1
2 1 3
Input
6
6 5 4 3 2 1
Output
1
6 1 1 1 1 1 1
Input
1
1
Output
0
Note
Explanation of the first testcase: Initially the deck is [3 1 2 4].
* The first operation splits the deck as [(3) (1 2) (4)] and then transforms it into [4 1 2 3].
* The second operation splits the deck as [(4) (1 2 3)] and then transforms it into [1 2 3 4].
Explanation of the second testcase: Initially the deck is [6 5 4 3 2 1].
* The first (and only) operation splits the deck as [(6) (5) (4) (3) (2) (1)] and then transforms it into [1 2 3 4 5 6].
Submitted Solution:
```
import sys
input = sys.stdin.readline
def update(operations,c):
if operations is None:
return c
new = []
for i in operations:
new.append(c[:i])
c = c[i:]
c2 =[]
for i in range(len(new)-1,-1,-1):
c2.extend(new[i])
return c2
def prog():
n = int(input())
c = list(map(int,input().split()))
fix_l = 1
fix_r = n
tot_moves =[]
for i in range(n//2):
idxl = c.index(fix_l)
idxr = c.index(fix_r)
moves1 = []
moves2 = []
if idxl > idxr:
if fix_l > 1:
moves1.append(fix_l-1)
moves1.append(n-(fix_l-1) -(n-fix_r))
if fix_r < n:
moves1.append(n-fix_r)
if len(moves1) == 1:
moves1 = None
else:
if fix_l > 1:
moves1.append(fix_l-1)
moves1 += [1]*(n-(fix_l-1) -(n-fix_r))
if fix_r < n:
moves1.append(n-fix_r)
c = update(moves1,c)
idxl2 = c.index(fix_l)
idxr2 = c.index(fix_r)
if fix_r < n:
moves2.append(n-fix_r)
moves2.append(idxr2-(n-fix_r) + 1)
if idxl2-idxr2-1 > 0:
moves2.append(idxl2-idxr2-1)
moves2.append(n-idxl2-(fix_l-1))
if fix_l > 1:
moves2.append(fix_l-1)
c = update(moves2,c)
if moves1 != None:
tot_moves.append(moves1)
tot_moves.append(moves2)
fix_l += 1
fix_r -= 1
print(len(tot_moves))
for move in tot_moves:
print(len(move),*move)
prog()
``` | instruction | 0 | 45,580 | 19 | 91,160 |
Yes | output | 1 | 45,580 | 19 | 91,161 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a deck of n cards numbered from 1 to n (not necessarily in this order in the deck). You have to sort the deck by repeating the following operation.
* Choose 2 ≤ k ≤ n and split the deck in k nonempty contiguous parts D_1, D_2,..., D_k (D_1 contains the first |D_1| cards of the deck, D_2 contains the following |D_2| cards and so on). Then reverse the order of the parts, transforming the deck into D_k, D_{k-1}, ..., D_2, D_1 (so, the first |D_k| cards of the new deck are D_k, the following |D_{k-1}| cards are D_{k-1} and so on). The internal order of each packet of cards D_i is unchanged by the operation.
You have to obtain a sorted deck (i.e., a deck where the first card is 1, the second is 2 and so on) performing at most n operations. It can be proven that it is always possible to sort the deck performing at most n operations.
Examples of operation: The following are three examples of valid operations (on three decks with different sizes).
* If the deck is [3 6 2 1 4 5 7] (so 3 is the first card and 7 is the last card), we may apply the operation with k=4 and D_1=[3 6], D_2=[2 1 4], D_3=[5], D_4=[7]. Doing so, the deck becomes [7 5 2 1 4 3 6].
* If the deck is [3 1 2], we may apply the operation with k=3 and D_1=[3], D_2=[1], D_3=[2]. Doing so, the deck becomes [2 1 3].
* If the deck is [5 1 2 4 3 6], we may apply the operation with k=2 and D_1=[5 1], D_2=[2 4 3 6]. Doing so, the deck becomes [2 4 3 6 5 1].
Input
The first line of the input contains one integer n (1≤ n≤ 52) — the number of cards in the deck.
The second line contains n integers c_1, c_2, ..., c_n — the cards in the deck. The first card is c_1, the second is c_2 and so on.
It is guaranteed that for all i=1,...,n there is exactly one j∈\{1,...,n\} such that c_j = i.
Output
On the first line, print the number q of operations you perform (it must hold 0≤ q≤ n).
Then, print q lines, each describing one operation.
To describe an operation, print on a single line the number k of parts you are going to split the deck in, followed by the size of the k parts: |D_1|, |D_2|, ... , |D_k|.
It must hold 2≤ k≤ n, and |D_i|≥ 1 for all i=1,...,k, and |D_1|+|D_2|+⋅⋅⋅ + |D_k| = n.
It can be proven that it is always possible to sort the deck performing at most n operations. If there are several ways to sort the deck you can output any of them.
Examples
Input
4
3 1 2 4
Output
2
3 1 2 1
2 1 3
Input
6
6 5 4 3 2 1
Output
1
6 1 1 1 1 1 1
Input
1
1
Output
0
Note
Explanation of the first testcase: Initially the deck is [3 1 2 4].
* The first operation splits the deck as [(3) (1 2) (4)] and then transforms it into [4 1 2 3].
* The second operation splits the deck as [(4) (1 2 3)] and then transforms it into [1 2 3 4].
Explanation of the second testcase: Initially the deck is [6 5 4 3 2 1].
* The first (and only) operation splits the deck as [(6) (5) (4) (3) (2) (1)] and then transforms it into [1 2 3 4 5 6].
Submitted Solution:
```
#!/usr/local/bin/python3
n = int(input())
arr = list(map(int, input().split()))
n = len(arr)
movesDone = []
def issorted(arr):
return all(
arr[i] <= arr[i + 1] for i in range(len(arr) - 1)
)
def apply(sizes):
# print(f'{sizes = }')
movesDone.append(sizes)
arrs = []
curr = 0
for size in sizes:
currArr = []
for i in range(curr, curr+size):
currArr.append( arr[i] )
arrs.append(currArr)
curr += size
arrs.reverse()
result = []
for currArr in arrs:
for num in currArr:
result.append(num)
# print(f'{result = }')
return result
# Make 1 a prefix
# Then, make 21 a suffix
# Then, make 123 a prefix
# Repeat
for i in range(n):
if issorted(arr):
break
numSorted = i
currNum = i+1
currIndex = arr.index(currNum)
sizes = []
if i%2 == 0:
if currIndex > 0:
sizes.append(currIndex)
if n-numSorted-currIndex > 0:
sizes.append(n-numSorted-currIndex)
for _ in range(numSorted):
sizes.append(1)
else:
for _ in range(numSorted):
sizes.append(1)
if currIndex+1 - numSorted > 0:
sizes.append(currIndex+1 - numSorted)
if n-(currIndex+1) > 0:
sizes.append(n-(currIndex+1))
if len(sizes) > 1:
arr = apply(sizes)
if not issorted(arr):
sizes = [1] * n
arr = apply(sizes)
assert(issorted(arr))
assert(len(movesDone) <= n)
print(len(movesDone))
for move in movesDone:
print(len(move), ' '.join(map(str, move)))
``` | instruction | 0 | 45,581 | 19 | 91,162 |
Yes | output | 1 | 45,581 | 19 | 91,163 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a deck of n cards numbered from 1 to n (not necessarily in this order in the deck). You have to sort the deck by repeating the following operation.
* Choose 2 ≤ k ≤ n and split the deck in k nonempty contiguous parts D_1, D_2,..., D_k (D_1 contains the first |D_1| cards of the deck, D_2 contains the following |D_2| cards and so on). Then reverse the order of the parts, transforming the deck into D_k, D_{k-1}, ..., D_2, D_1 (so, the first |D_k| cards of the new deck are D_k, the following |D_{k-1}| cards are D_{k-1} and so on). The internal order of each packet of cards D_i is unchanged by the operation.
You have to obtain a sorted deck (i.e., a deck where the first card is 1, the second is 2 and so on) performing at most n operations. It can be proven that it is always possible to sort the deck performing at most n operations.
Examples of operation: The following are three examples of valid operations (on three decks with different sizes).
* If the deck is [3 6 2 1 4 5 7] (so 3 is the first card and 7 is the last card), we may apply the operation with k=4 and D_1=[3 6], D_2=[2 1 4], D_3=[5], D_4=[7]. Doing so, the deck becomes [7 5 2 1 4 3 6].
* If the deck is [3 1 2], we may apply the operation with k=3 and D_1=[3], D_2=[1], D_3=[2]. Doing so, the deck becomes [2 1 3].
* If the deck is [5 1 2 4 3 6], we may apply the operation with k=2 and D_1=[5 1], D_2=[2 4 3 6]. Doing so, the deck becomes [2 4 3 6 5 1].
Input
The first line of the input contains one integer n (1≤ n≤ 52) — the number of cards in the deck.
The second line contains n integers c_1, c_2, ..., c_n — the cards in the deck. The first card is c_1, the second is c_2 and so on.
It is guaranteed that for all i=1,...,n there is exactly one j∈\{1,...,n\} such that c_j = i.
Output
On the first line, print the number q of operations you perform (it must hold 0≤ q≤ n).
Then, print q lines, each describing one operation.
To describe an operation, print on a single line the number k of parts you are going to split the deck in, followed by the size of the k parts: |D_1|, |D_2|, ... , |D_k|.
It must hold 2≤ k≤ n, and |D_i|≥ 1 for all i=1,...,k, and |D_1|+|D_2|+⋅⋅⋅ + |D_k| = n.
It can be proven that it is always possible to sort the deck performing at most n operations. If there are several ways to sort the deck you can output any of them.
Examples
Input
4
3 1 2 4
Output
2
3 1 2 1
2 1 3
Input
6
6 5 4 3 2 1
Output
1
6 1 1 1 1 1 1
Input
1
1
Output
0
Note
Explanation of the first testcase: Initially the deck is [3 1 2 4].
* The first operation splits the deck as [(3) (1 2) (4)] and then transforms it into [4 1 2 3].
* The second operation splits the deck as [(4) (1 2 3)] and then transforms it into [1 2 3 4].
Explanation of the second testcase: Initially the deck is [6 5 4 3 2 1].
* The first (and only) operation splits the deck as [(6) (5) (4) (3) (2) (1)] and then transforms it into [1 2 3 4 5 6].
Submitted Solution:
```
n = int(input())
c = list(map(int, input().split()))
c2 = c[::]
out = []
for i in range(1, n):
ind = c2.index(i)
if i == ind + 1:
continue
sizes = [1] * (i - 1) + [ind - i + 2] + [1] * (n - ind - 1)
if len(sizes) > 1:
if c2 == c:
sizesr = sizes
else:
sizesr = sizes[::-1]
out.append(str(len(sizesr)) + ' ' + ' '.join(map(str,sizesr)))
lists = []
curr = 0
for v in sizes:
lists.append(c2[curr:curr+v])
curr += v
lists.reverse()
c2 = []
for l in lists:
c2 += l
lists = []
curr = 0
for v in sizesr:
lists.append(c[curr:curr+v])
curr += v
lists.reverse()
c = []
for l in lists:
c += l
c2.reverse()
if c != c2:
out.append(str(n) + ' 1'*n)
c = c[::-1]
assert(c == list(range(1,n+1)))
print(len(out))
print('\n'.join(out))
``` | instruction | 0 | 45,582 | 19 | 91,164 |
Yes | output | 1 | 45,582 | 19 | 91,165 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a deck of n cards numbered from 1 to n (not necessarily in this order in the deck). You have to sort the deck by repeating the following operation.
* Choose 2 ≤ k ≤ n and split the deck in k nonempty contiguous parts D_1, D_2,..., D_k (D_1 contains the first |D_1| cards of the deck, D_2 contains the following |D_2| cards and so on). Then reverse the order of the parts, transforming the deck into D_k, D_{k-1}, ..., D_2, D_1 (so, the first |D_k| cards of the new deck are D_k, the following |D_{k-1}| cards are D_{k-1} and so on). The internal order of each packet of cards D_i is unchanged by the operation.
You have to obtain a sorted deck (i.e., a deck where the first card is 1, the second is 2 and so on) performing at most n operations. It can be proven that it is always possible to sort the deck performing at most n operations.
Examples of operation: The following are three examples of valid operations (on three decks with different sizes).
* If the deck is [3 6 2 1 4 5 7] (so 3 is the first card and 7 is the last card), we may apply the operation with k=4 and D_1=[3 6], D_2=[2 1 4], D_3=[5], D_4=[7]. Doing so, the deck becomes [7 5 2 1 4 3 6].
* If the deck is [3 1 2], we may apply the operation with k=3 and D_1=[3], D_2=[1], D_3=[2]. Doing so, the deck becomes [2 1 3].
* If the deck is [5 1 2 4 3 6], we may apply the operation with k=2 and D_1=[5 1], D_2=[2 4 3 6]. Doing so, the deck becomes [2 4 3 6 5 1].
Input
The first line of the input contains one integer n (1≤ n≤ 52) — the number of cards in the deck.
The second line contains n integers c_1, c_2, ..., c_n — the cards in the deck. The first card is c_1, the second is c_2 and so on.
It is guaranteed that for all i=1,...,n there is exactly one j∈\{1,...,n\} such that c_j = i.
Output
On the first line, print the number q of operations you perform (it must hold 0≤ q≤ n).
Then, print q lines, each describing one operation.
To describe an operation, print on a single line the number k of parts you are going to split the deck in, followed by the size of the k parts: |D_1|, |D_2|, ... , |D_k|.
It must hold 2≤ k≤ n, and |D_i|≥ 1 for all i=1,...,k, and |D_1|+|D_2|+⋅⋅⋅ + |D_k| = n.
It can be proven that it is always possible to sort the deck performing at most n operations. If there are several ways to sort the deck you can output any of them.
Examples
Input
4
3 1 2 4
Output
2
3 1 2 1
2 1 3
Input
6
6 5 4 3 2 1
Output
1
6 1 1 1 1 1 1
Input
1
1
Output
0
Note
Explanation of the first testcase: Initially the deck is [3 1 2 4].
* The first operation splits the deck as [(3) (1 2) (4)] and then transforms it into [4 1 2 3].
* The second operation splits the deck as [(4) (1 2 3)] and then transforms it into [1 2 3 4].
Explanation of the second testcase: Initially the deck is [6 5 4 3 2 1].
* The first (and only) operation splits the deck as [(6) (5) (4) (3) (2) (1)] and then transforms it into [1 2 3 4 5 6].
Submitted Solution:
```
n = int(input())
a = [*map(int,input().split())]
a1 = [i for i in a]
sol = []
sol1 = []
ok = 1
for i in range(n):
if(a==sorted(a) or a1==sorted(a1)):
break
if(n-i-1==0):
break
l1,r1= a1.index(i+1),a1.index(i+2)
l,r = a.index(n-i-1),a.index(n-i)
if(l>r):
sol.append([1] * (r + 1) + [abs(r - l)] + [1] * (n - l - 1))
a = ([a[i] for i in range(n-1,l,-1)]+(a[r+1:l+1])+[a[i] for i in range(r,-1,-1)])
elif(l+1==r):
continue
else:
sol.append([1]*n)
a = a[::-1]
l, r = a.index(n - i - 1), a.index(n - i)
sol.append([1]*(r+1)+[abs(r-l)]+[1]*(n-l-1))
a = ([a[i] for i in range(n-1,l,-1)]+(a[r+1:l+1])+[a[i] for i in range(r,-1,-1)])
if (l1 > r1):
sol1.append([1] * (r1 + 1) + [abs(r1 - l1)] + [1] * (n - l1 - 1))
a1 = ([a1[i] for i in range(n - 1, l1, -1)] + (a1[r1 + 1:l1 + 1]) + [a1[i] for i in range(r1, -1, -1)])
elif(l1+1==r1):
continue
else:
sol1.append([1] * n)
a1 = a1[::-1]
l1, r1 = a1.index(i+1), a1.index(i+2)
sol1.append([1] * (r1 + 1) + [abs(r1 - l1)] + [1] * (n - l1 - 1))
a1 = ([a1[i] for i in range(n - 1, l1, -1)] + (a1[r1 + 1:l1 + 1]) + [a1[i] for i in range(r1, -1, -1)])
if(len(sol)>len(sol1)):
sol = sol1
print(len(sol))
for i in sol:
print(len(i),end=" ")
print(*i)
``` | instruction | 0 | 45,583 | 19 | 91,166 |
No | output | 1 | 45,583 | 19 | 91,167 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a deck of n cards numbered from 1 to n (not necessarily in this order in the deck). You have to sort the deck by repeating the following operation.
* Choose 2 ≤ k ≤ n and split the deck in k nonempty contiguous parts D_1, D_2,..., D_k (D_1 contains the first |D_1| cards of the deck, D_2 contains the following |D_2| cards and so on). Then reverse the order of the parts, transforming the deck into D_k, D_{k-1}, ..., D_2, D_1 (so, the first |D_k| cards of the new deck are D_k, the following |D_{k-1}| cards are D_{k-1} and so on). The internal order of each packet of cards D_i is unchanged by the operation.
You have to obtain a sorted deck (i.e., a deck where the first card is 1, the second is 2 and so on) performing at most n operations. It can be proven that it is always possible to sort the deck performing at most n operations.
Examples of operation: The following are three examples of valid operations (on three decks with different sizes).
* If the deck is [3 6 2 1 4 5 7] (so 3 is the first card and 7 is the last card), we may apply the operation with k=4 and D_1=[3 6], D_2=[2 1 4], D_3=[5], D_4=[7]. Doing so, the deck becomes [7 5 2 1 4 3 6].
* If the deck is [3 1 2], we may apply the operation with k=3 and D_1=[3], D_2=[1], D_3=[2]. Doing so, the deck becomes [2 1 3].
* If the deck is [5 1 2 4 3 6], we may apply the operation with k=2 and D_1=[5 1], D_2=[2 4 3 6]. Doing so, the deck becomes [2 4 3 6 5 1].
Input
The first line of the input contains one integer n (1≤ n≤ 52) — the number of cards in the deck.
The second line contains n integers c_1, c_2, ..., c_n — the cards in the deck. The first card is c_1, the second is c_2 and so on.
It is guaranteed that for all i=1,...,n there is exactly one j∈\{1,...,n\} such that c_j = i.
Output
On the first line, print the number q of operations you perform (it must hold 0≤ q≤ n).
Then, print q lines, each describing one operation.
To describe an operation, print on a single line the number k of parts you are going to split the deck in, followed by the size of the k parts: |D_1|, |D_2|, ... , |D_k|.
It must hold 2≤ k≤ n, and |D_i|≥ 1 for all i=1,...,k, and |D_1|+|D_2|+⋅⋅⋅ + |D_k| = n.
It can be proven that it is always possible to sort the deck performing at most n operations. If there are several ways to sort the deck you can output any of them.
Examples
Input
4
3 1 2 4
Output
2
3 1 2 1
2 1 3
Input
6
6 5 4 3 2 1
Output
1
6 1 1 1 1 1 1
Input
1
1
Output
0
Note
Explanation of the first testcase: Initially the deck is [3 1 2 4].
* The first operation splits the deck as [(3) (1 2) (4)] and then transforms it into [4 1 2 3].
* The second operation splits the deck as [(4) (1 2 3)] and then transforms it into [1 2 3 4].
Explanation of the second testcase: Initially the deck is [6 5 4 3 2 1].
* The first (and only) operation splits the deck as [(6) (5) (4) (3) (2) (1)] and then transforms it into [1 2 3 4 5 6].
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
print(n)
for _ in range(n):
cnt = 1
li = []
i = 0
while i < n - 1:
if a[i] + 1 == a[i + 1]:
cnt += 1
i += 1
else:
tmp = 1
for j in range(i + 1, n):
if a[i] - 1 == a[j]:
li.append(cnt)
li.append(tmp)
i += tmp
cnt = 0
break
else:
tmp += 1
cnt += 1
i += 1
if i != n:
li.append(cnt)
print(len(li), *li)
l, r = n, n
ind = 0
b = [0] * n
for val in li[::-1]:
l = l - val
for i in range(l, r):
b[ind] = a[i]
ind += 1
r = l
a = b[:]
``` | instruction | 0 | 45,584 | 19 | 91,168 |
No | output | 1 | 45,584 | 19 | 91,169 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a deck of n cards numbered from 1 to n (not necessarily in this order in the deck). You have to sort the deck by repeating the following operation.
* Choose 2 ≤ k ≤ n and split the deck in k nonempty contiguous parts D_1, D_2,..., D_k (D_1 contains the first |D_1| cards of the deck, D_2 contains the following |D_2| cards and so on). Then reverse the order of the parts, transforming the deck into D_k, D_{k-1}, ..., D_2, D_1 (so, the first |D_k| cards of the new deck are D_k, the following |D_{k-1}| cards are D_{k-1} and so on). The internal order of each packet of cards D_i is unchanged by the operation.
You have to obtain a sorted deck (i.e., a deck where the first card is 1, the second is 2 and so on) performing at most n operations. It can be proven that it is always possible to sort the deck performing at most n operations.
Examples of operation: The following are three examples of valid operations (on three decks with different sizes).
* If the deck is [3 6 2 1 4 5 7] (so 3 is the first card and 7 is the last card), we may apply the operation with k=4 and D_1=[3 6], D_2=[2 1 4], D_3=[5], D_4=[7]. Doing so, the deck becomes [7 5 2 1 4 3 6].
* If the deck is [3 1 2], we may apply the operation with k=3 and D_1=[3], D_2=[1], D_3=[2]. Doing so, the deck becomes [2 1 3].
* If the deck is [5 1 2 4 3 6], we may apply the operation with k=2 and D_1=[5 1], D_2=[2 4 3 6]. Doing so, the deck becomes [2 4 3 6 5 1].
Input
The first line of the input contains one integer n (1≤ n≤ 52) — the number of cards in the deck.
The second line contains n integers c_1, c_2, ..., c_n — the cards in the deck. The first card is c_1, the second is c_2 and so on.
It is guaranteed that for all i=1,...,n there is exactly one j∈\{1,...,n\} such that c_j = i.
Output
On the first line, print the number q of operations you perform (it must hold 0≤ q≤ n).
Then, print q lines, each describing one operation.
To describe an operation, print on a single line the number k of parts you are going to split the deck in, followed by the size of the k parts: |D_1|, |D_2|, ... , |D_k|.
It must hold 2≤ k≤ n, and |D_i|≥ 1 for all i=1,...,k, and |D_1|+|D_2|+⋅⋅⋅ + |D_k| = n.
It can be proven that it is always possible to sort the deck performing at most n operations. If there are several ways to sort the deck you can output any of them.
Examples
Input
4
3 1 2 4
Output
2
3 1 2 1
2 1 3
Input
6
6 5 4 3 2 1
Output
1
6 1 1 1 1 1 1
Input
1
1
Output
0
Note
Explanation of the first testcase: Initially the deck is [3 1 2 4].
* The first operation splits the deck as [(3) (1 2) (4)] and then transforms it into [4 1 2 3].
* The second operation splits the deck as [(4) (1 2 3)] and then transforms it into [1 2 3 4].
Explanation of the second testcase: Initially the deck is [6 5 4 3 2 1].
* The first (and only) operation splits the deck as [(6) (5) (4) (3) (2) (1)] and then transforms it into [1 2 3 4 5 6].
Submitted Solution:
```
n=int(input())
d=[int(i) for i in input().split()]
def process(it, tar):
res=[]
kk=0
#print(tar, it)
assert(sum(tar)==len(it))
for k in tar:
res=it[kk:kk+k]+res
kk+=k
#print(tar,res,it)
assert(len(res)==len(it))
return res
t = list(range(1,n+1))
r=[]
while (d!=t):
z=[0]*(n+1)
for i in range(n):
z[d[i]]=i+1
if d[i]!=1 and z[d[i]-1]==0:
j= [k for k in range(n) if d[k]==d[i]-1][0]
kk=0
while (i+kk+1<n and d[i+kk+1]==d[i]+kk+1):
kk+=1
jj=0
while (j-jj-1>=0 and d[j-jj-1]==d[j]-jj-1):
jj+=1
tar = ([i] if i else []) + [kk+1] + ([n-i-kk-1-jj-1-(n-1-j)]) + [jj+1] + ([n-1-j] if j<n-1 else [])
tar= [k for k in tar if k]
d=process(d, tar)
r+=[tar]
break
print(len(r))
for k in r:
print(len(k), *k)
``` | instruction | 0 | 45,585 | 19 | 91,170 |
No | output | 1 | 45,585 | 19 | 91,171 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a deck of n cards numbered from 1 to n (not necessarily in this order in the deck). You have to sort the deck by repeating the following operation.
* Choose 2 ≤ k ≤ n and split the deck in k nonempty contiguous parts D_1, D_2,..., D_k (D_1 contains the first |D_1| cards of the deck, D_2 contains the following |D_2| cards and so on). Then reverse the order of the parts, transforming the deck into D_k, D_{k-1}, ..., D_2, D_1 (so, the first |D_k| cards of the new deck are D_k, the following |D_{k-1}| cards are D_{k-1} and so on). The internal order of each packet of cards D_i is unchanged by the operation.
You have to obtain a sorted deck (i.e., a deck where the first card is 1, the second is 2 and so on) performing at most n operations. It can be proven that it is always possible to sort the deck performing at most n operations.
Examples of operation: The following are three examples of valid operations (on three decks with different sizes).
* If the deck is [3 6 2 1 4 5 7] (so 3 is the first card and 7 is the last card), we may apply the operation with k=4 and D_1=[3 6], D_2=[2 1 4], D_3=[5], D_4=[7]. Doing so, the deck becomes [7 5 2 1 4 3 6].
* If the deck is [3 1 2], we may apply the operation with k=3 and D_1=[3], D_2=[1], D_3=[2]. Doing so, the deck becomes [2 1 3].
* If the deck is [5 1 2 4 3 6], we may apply the operation with k=2 and D_1=[5 1], D_2=[2 4 3 6]. Doing so, the deck becomes [2 4 3 6 5 1].
Input
The first line of the input contains one integer n (1≤ n≤ 52) — the number of cards in the deck.
The second line contains n integers c_1, c_2, ..., c_n — the cards in the deck. The first card is c_1, the second is c_2 and so on.
It is guaranteed that for all i=1,...,n there is exactly one j∈\{1,...,n\} such that c_j = i.
Output
On the first line, print the number q of operations you perform (it must hold 0≤ q≤ n).
Then, print q lines, each describing one operation.
To describe an operation, print on a single line the number k of parts you are going to split the deck in, followed by the size of the k parts: |D_1|, |D_2|, ... , |D_k|.
It must hold 2≤ k≤ n, and |D_i|≥ 1 for all i=1,...,k, and |D_1|+|D_2|+⋅⋅⋅ + |D_k| = n.
It can be proven that it is always possible to sort the deck performing at most n operations. If there are several ways to sort the deck you can output any of them.
Examples
Input
4
3 1 2 4
Output
2
3 1 2 1
2 1 3
Input
6
6 5 4 3 2 1
Output
1
6 1 1 1 1 1 1
Input
1
1
Output
0
Note
Explanation of the first testcase: Initially the deck is [3 1 2 4].
* The first operation splits the deck as [(3) (1 2) (4)] and then transforms it into [4 1 2 3].
* The second operation splits the deck as [(4) (1 2 3)] and then transforms it into [1 2 3 4].
Explanation of the second testcase: Initially the deck is [6 5 4 3 2 1].
* The first (and only) operation splits the deck as [(6) (5) (4) (3) (2) (1)] and then transforms it into [1 2 3 4 5 6].
Submitted Solution:
```
import sys
input = sys.stdin.readline
def update(operations,c):
if operations is None:
return c
new = []
for i in operations:
new.append(c[:i])
c = c[i:]
c2 =[]
for i in range(len(new)-1,-1,-1):
c2.extend(new[i])
return c2
def prog():
n = int(input())
c = list(map(int,input().split()))
fix_l = 1
fix_r = n
tot_moves =[]
for i in range(n//2):
idxl = c.index(fix_l)
idxr = c.index(fix_r)
moves1 = []
moves2 = []
if idxl > idxr:
if idxl == n-1 and idxr == 0 and fix_l == 1 and fix_r == n:
moves1 = None
else:
if fix_l > 1:
moves1.append(fix_l-1)
moves1.append(n-(fix_l-1) -(n-fix_r))
if fix_r < n:
moves1.append(n-fix_r)
else:
if fix_l > 1:
moves1.append(fix_l-1)
moves1 += [1]*(n-(fix_l-1) -(n-fix_r))
if fix_r < n:
moves1.append(n-fix_r)
c = update(moves1,c)
idxl2 = c.index(fix_l)
idxr2 = c.index(fix_r)
if fix_r < n:
moves2.append(n-fix_r)
moves2.append(idxr2-(n-fix_r) + 1)
if idxl2-idxr2-1 > 0:
moves2.append(idxl2-idxr2-1)
moves2.append(n-idxl2-(fix_l-1))
if fix_l > 1:
moves2.append(fix_l-1)
c = update(moves2,c)
if moves1 != None:
tot_moves.append(moves1)
tot_moves.append(moves2)
fix_l += 1
fix_r -= 1
print(len(tot_moves))
for move in tot_moves:
print(*move)
prog()
``` | instruction | 0 | 45,586 | 19 | 91,172 |
No | output | 1 | 45,586 | 19 | 91,173 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya and Petya wrote down all integers from 1 to n to play the "powers" game (n can be quite large; however, Vasya and Petya are not confused by this fact).
Players choose numbers in turn (Vasya chooses first). If some number x is chosen at the current turn, it is forbidden to choose x or all of its other positive integer powers (that is, x2, x3, ...) at the next turns. For instance, if the number 9 is chosen at the first turn, one cannot choose 9 or 81 later, while it is still allowed to choose 3 or 27. The one who cannot make a move loses.
Who wins if both Vasya and Petya play optimally?
Input
Input contains single integer n (1 ≤ n ≤ 109).
Output
Print the name of the winner — "Vasya" or "Petya" (without quotes).
Examples
Input
1
Output
Vasya
Input
2
Output
Petya
Input
8
Output
Petya
Note
In the first sample Vasya will choose 1 and win immediately.
In the second sample no matter which number Vasya chooses during his first turn, Petya can choose the remaining number and win. | instruction | 0 | 45,706 | 19 | 91,412 |
Tags: dp, games
Correct Solution:
```
from sys import stdin, stdout
import math, collections
mod = 10**9+7
def isPower(n):
if (n <= 1):
return True
for x in range(2, (int)(math.sqrt(n)) + 1):
p = x
while (p <= n):
p = p * x
if (p == n):
return True
return False
n = int(input())
arr = [0,1,2,1,4,3,2,1,5,6,2,1,8,7,5,9,8,7,3,4,7,4,2,1,10,9,3,6,11,12]
ans = arr[int(math.log(n, 2))]
s = int(math.log(n, 2))
for i in range(3, int(n**0.5)+1):
if not isPower(i):
ans^=arr[int(math.log(n, i))]
s+=int(math.log(n, i))
ans^=((n-s)%2)
print("Vasya" if ans else "Petya")
``` | output | 1 | 45,706 | 19 | 91,413 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.