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.
"You must lift the dam. With a lever. I will give it to you.
You must block the canal. With a rock. I will not give the rock to you."
Danik urgently needs rock and lever! Obviously, the easiest way to get these things is to ask Hermit Lizard for them.
Hermit Lizard agreed to give Danik the lever. But to get a stone, Danik needs to solve the following task.
You are given a positive integer n, and an array a of positive integers. The task is to calculate the number of such pairs (i,j) that i<j and a_i \& a_j ≥ a_i ⊕ a_j, where \& denotes the [bitwise AND operation](https://en.wikipedia.org/wiki/Bitwise_operation#AND), and ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
Danik has solved this task. But can you solve it?
Input
Each test contains multiple test cases.
The first line contains one positive integer t (1 ≤ t ≤ 10) denoting the number of test cases. Description of the test cases follows.
The first line of each test case contains one positive integer n (1 ≤ n ≤ 10^5) — length of the array.
The second line contains n positive integers a_i (1 ≤ a_i ≤ 10^9) — elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For every test case print one non-negative integer — the answer to the problem.
Example
Input
5
5
1 4 3 7 10
3
1 1 1
4
6 2 5 3
2
2 4
1
1
Output
1
3
2
0
0
Note
In the first test case there is only one pair: (4,7): for it 4 \& 7 = 4, and 4 ⊕ 7 = 3.
In the second test case all pairs are good.
In the third test case there are two pairs: (6,5) and (2,3).
In the fourth test case there are no good pairs.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
arr = list(map(int,input().split()))
cnt = 0
final = []
for i in range(n):
for j in range(i+1,n):
if((arr[i]&arr[j])>(arr[i]^arr[j]) or (arr[i]&arr[j])==(arr[i]^arr[j])):
final.append([arr[i],arr[j]])
print(final)
``` | instruction | 0 | 65,782 | 19 | 131,564 |
No | output | 1 | 65,782 | 19 | 131,565 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
"You must lift the dam. With a lever. I will give it to you.
You must block the canal. With a rock. I will not give the rock to you."
Danik urgently needs rock and lever! Obviously, the easiest way to get these things is to ask Hermit Lizard for them.
Hermit Lizard agreed to give Danik the lever. But to get a stone, Danik needs to solve the following task.
You are given a positive integer n, and an array a of positive integers. The task is to calculate the number of such pairs (i,j) that i<j and a_i \& a_j ≥ a_i ⊕ a_j, where \& denotes the [bitwise AND operation](https://en.wikipedia.org/wiki/Bitwise_operation#AND), and ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
Danik has solved this task. But can you solve it?
Input
Each test contains multiple test cases.
The first line contains one positive integer t (1 ≤ t ≤ 10) denoting the number of test cases. Description of the test cases follows.
The first line of each test case contains one positive integer n (1 ≤ n ≤ 10^5) — length of the array.
The second line contains n positive integers a_i (1 ≤ a_i ≤ 10^9) — elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For every test case print one non-negative integer — the answer to the problem.
Example
Input
5
5
1 4 3 7 10
3
1 1 1
4
6 2 5 3
2
2 4
1
1
Output
1
3
2
0
0
Note
In the first test case there is only one pair: (4,7): for it 4 \& 7 = 4, and 4 ⊕ 7 = 3.
In the second test case all pairs are good.
In the third test case there are two pairs: (6,5) and (2,3).
In the fourth test case there are no good pairs.
Submitted Solution:
```
from collections import defaultdict
t = int(input())
for p in range(t):
n = int(input())
a = list(map(int, input().split()))
dic = defaultdict(int)
for i in range(n):
dic[a[i]] += 1
ans = 0
for key, value in dic.items():
if value > 1:
ans += (value*(value-1))//2
a = list(set(a))
a.sort()
for i in range(len(a) - 1):
if a[i]&a[i+1] >= a[i]^a[i+1]:
ans += 1
print(ans)
``` | instruction | 0 | 65,783 | 19 | 131,566 |
No | output | 1 | 65,783 | 19 | 131,567 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
"You must lift the dam. With a lever. I will give it to you.
You must block the canal. With a rock. I will not give the rock to you."
Danik urgently needs rock and lever! Obviously, the easiest way to get these things is to ask Hermit Lizard for them.
Hermit Lizard agreed to give Danik the lever. But to get a stone, Danik needs to solve the following task.
You are given a positive integer n, and an array a of positive integers. The task is to calculate the number of such pairs (i,j) that i<j and a_i \& a_j ≥ a_i ⊕ a_j, where \& denotes the [bitwise AND operation](https://en.wikipedia.org/wiki/Bitwise_operation#AND), and ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
Danik has solved this task. But can you solve it?
Input
Each test contains multiple test cases.
The first line contains one positive integer t (1 ≤ t ≤ 10) denoting the number of test cases. Description of the test cases follows.
The first line of each test case contains one positive integer n (1 ≤ n ≤ 10^5) — length of the array.
The second line contains n positive integers a_i (1 ≤ a_i ≤ 10^9) — elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For every test case print one non-negative integer — the answer to the problem.
Example
Input
5
5
1 4 3 7 10
3
1 1 1
4
6 2 5 3
2
2 4
1
1
Output
1
3
2
0
0
Note
In the first test case there is only one pair: (4,7): for it 4 \& 7 = 4, and 4 ⊕ 7 = 3.
In the second test case all pairs are good.
In the third test case there are two pairs: (6,5) and (2,3).
In the fourth test case there are no good pairs.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
c = 0
a = [int(x) for x in input().split()]
if n<2:
print(0)
else:
b = []
for i in range(n):
x = len(bin(a[i])) - 2
b.append(x)
b.sort()
b1 = list(set(b))
l = len(b1)
for i in range(n-1):
if b[i] == b[i+1]:
c+=1
print(c)
``` | instruction | 0 | 65,784 | 19 | 131,568 |
No | output | 1 | 65,784 | 19 | 131,569 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
"You must lift the dam. With a lever. I will give it to you.
You must block the canal. With a rock. I will not give the rock to you."
Danik urgently needs rock and lever! Obviously, the easiest way to get these things is to ask Hermit Lizard for them.
Hermit Lizard agreed to give Danik the lever. But to get a stone, Danik needs to solve the following task.
You are given a positive integer n, and an array a of positive integers. The task is to calculate the number of such pairs (i,j) that i<j and a_i \& a_j ≥ a_i ⊕ a_j, where \& denotes the [bitwise AND operation](https://en.wikipedia.org/wiki/Bitwise_operation#AND), and ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
Danik has solved this task. But can you solve it?
Input
Each test contains multiple test cases.
The first line contains one positive integer t (1 ≤ t ≤ 10) denoting the number of test cases. Description of the test cases follows.
The first line of each test case contains one positive integer n (1 ≤ n ≤ 10^5) — length of the array.
The second line contains n positive integers a_i (1 ≤ a_i ≤ 10^9) — elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For every test case print one non-negative integer — the answer to the problem.
Example
Input
5
5
1 4 3 7 10
3
1 1 1
4
6 2 5 3
2
2 4
1
1
Output
1
3
2
0
0
Note
In the first test case there is only one pair: (4,7): for it 4 \& 7 = 4, and 4 ⊕ 7 = 3.
In the second test case all pairs are good.
In the third test case there are two pairs: (6,5) and (2,3).
In the fourth test case there are no good pairs.
Submitted Solution:
```
print("HI")
``` | instruction | 0 | 65,785 | 19 | 131,570 |
No | output | 1 | 65,785 | 19 | 131,571 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Two people play the following string game. Initially the players have got some string s. The players move in turns, the player who cannot make a move loses.
Before the game began, the string is written on a piece of paper, one letter per cell.
<image> An example of the initial situation at s = "abacaba"
A player's move is the sequence of actions:
1. The player chooses one of the available pieces of paper with some string written on it. Let's denote it is t. Note that initially, only one piece of paper is available.
2. The player chooses in the string t = t1t2... t|t| character in position i (1 ≤ i ≤ |t|) such that for some positive integer l (0 < i - l; i + l ≤ |t|) the following equations hold: ti - 1 = ti + 1, ti - 2 = ti + 2, ..., ti - l = ti + l.
3. Player cuts the cell with the chosen character. As a result of the operation, he gets three new pieces of paper, the first one will contain string t1t2... ti - 1, the second one will contain a string consisting of a single character ti, the third one contains string ti + 1ti + 2... t|t|.
<image> An example of making action (i = 4) with string s = «abacaba»
Your task is to determine the winner provided that both players play optimally well. If the first player wins, find the position of character that is optimal to cut in his first move. If there are multiple positions, print the minimal possible one.
Input
The first line contains string s (1 ≤ |s| ≤ 5000). It is guaranteed that string s only contains lowercase English letters.
Output
If the second player wins, print in the single line "Second" (without the quotes). Otherwise, print in the first line "First" (without the quotes), and in the second line print the minimal possible winning move — integer i (1 ≤ i ≤ |s|).
Examples
Input
abacaba
Output
First
2
Input
abcde
Output
Second
Note
In the first sample the first player has multiple winning moves. But the minimum one is to cut the character in position 2.
In the second sample the first player has no available moves. | instruction | 0 | 65,903 | 19 | 131,806 |
Tags: games
Correct Solution:
```
U = input()
memo = {}
DP = [0]*(len(U)+1)
DP[0] = 0
for j in range(1, len(U) + 1):
s = set()
for i in range(j):
s.add(DP[max(0, i - 1)] ^ DP[max(0, j - i - 2)])
mex = 0
while mex in s:
mex += 1
DP[j] = mex
memo2 = {}
def Grundy(S):
"""
Basically we transform the game.
From a game where we can pick only center of palindrom to a game with several pile where we can pick anything (but it removes adjacent stone)
In this new game, only the remaining size matters (since we can pick anywhere)
"""
if S in memo2: return memo2[S]
total = 0
consec = 0
for i in range(1, len(S) - 1):
if S[i - 1] == S[i + 1]:
consec += 1
else:
total ^= DP[consec]
consec = 0
total ^= DP[consec]
memo2[S] = total
return total
import sys
sys.setrecursionlimit(3000)
if (Grundy(U) != 0):
#print(Grundy(U))
for i in range(1, len(U) - 1):
if U[i - 1] == U[i + 1]:
if ((Grundy(U[:i]) ^ Grundy(U[i + 1:])) == 0):
print("First")
print(i + 1)
break
else:
print("Second")
``` | output | 1 | 65,903 | 19 | 131,807 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two people play the following string game. Initially the players have got some string s. The players move in turns, the player who cannot make a move loses.
Before the game began, the string is written on a piece of paper, one letter per cell.
<image> An example of the initial situation at s = "abacaba"
A player's move is the sequence of actions:
1. The player chooses one of the available pieces of paper with some string written on it. Let's denote it is t. Note that initially, only one piece of paper is available.
2. The player chooses in the string t = t1t2... t|t| character in position i (1 ≤ i ≤ |t|) such that for some positive integer l (0 < i - l; i + l ≤ |t|) the following equations hold: ti - 1 = ti + 1, ti - 2 = ti + 2, ..., ti - l = ti + l.
3. Player cuts the cell with the chosen character. As a result of the operation, he gets three new pieces of paper, the first one will contain string t1t2... ti - 1, the second one will contain a string consisting of a single character ti, the third one contains string ti + 1ti + 2... t|t|.
<image> An example of making action (i = 4) with string s = «abacaba»
Your task is to determine the winner provided that both players play optimally well. If the first player wins, find the position of character that is optimal to cut in his first move. If there are multiple positions, print the minimal possible one.
Input
The first line contains string s (1 ≤ |s| ≤ 5000). It is guaranteed that string s only contains lowercase English letters.
Output
If the second player wins, print in the single line "Second" (without the quotes). Otherwise, print in the first line "First" (without the quotes), and in the second line print the minimal possible winning move — integer i (1 ≤ i ≤ |s|).
Examples
Input
abacaba
Output
First
2
Input
abcde
Output
Second
Note
In the first sample the first player has multiple winning moves. But the minimum one is to cut the character in position 2.
In the second sample the first player has no available moves.
Submitted Solution:
```
s = input()
d = [0 for i in s]
n = 0
m = 0
for i in range(1, len(s) - 1):
if s[i - 1] == s[i + 1]:
d[i] = d[i - 1] + 1
d[i - 1] = 0
for i in d:
if 1 <= i % 5 <= 2:
n += 1
elif i % 5 == 3:
m += 1
if m == 0 and n % 2 == 0 or n == 71:
print('Second')
else:
print('First')
for i in range(1, len(s) - 1):
if m % 2 == n % 2:
if d[i] >= 3:
print(i - d[i] + 3)
break
elif d[i] <= 2:
print(i - d[i])
break
``` | instruction | 0 | 65,904 | 19 | 131,808 |
No | output | 1 | 65,904 | 19 | 131,809 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two people play the following string game. Initially the players have got some string s. The players move in turns, the player who cannot make a move loses.
Before the game began, the string is written on a piece of paper, one letter per cell.
<image> An example of the initial situation at s = "abacaba"
A player's move is the sequence of actions:
1. The player chooses one of the available pieces of paper with some string written on it. Let's denote it is t. Note that initially, only one piece of paper is available.
2. The player chooses in the string t = t1t2... t|t| character in position i (1 ≤ i ≤ |t|) such that for some positive integer l (0 < i - l; i + l ≤ |t|) the following equations hold: ti - 1 = ti + 1, ti - 2 = ti + 2, ..., ti - l = ti + l.
3. Player cuts the cell with the chosen character. As a result of the operation, he gets three new pieces of paper, the first one will contain string t1t2... ti - 1, the second one will contain a string consisting of a single character ti, the third one contains string ti + 1ti + 2... t|t|.
<image> An example of making action (i = 4) with string s = «abacaba»
Your task is to determine the winner provided that both players play optimally well. If the first player wins, find the position of character that is optimal to cut in his first move. If there are multiple positions, print the minimal possible one.
Input
The first line contains string s (1 ≤ |s| ≤ 5000). It is guaranteed that string s only contains lowercase English letters.
Output
If the second player wins, print in the single line "Second" (without the quotes). Otherwise, print in the first line "First" (without the quotes), and in the second line print the minimal possible winning move — integer i (1 ≤ i ≤ |s|).
Examples
Input
abacaba
Output
First
2
Input
abcde
Output
Second
Note
In the first sample the first player has multiple winning moves. But the minimum one is to cut the character in position 2.
In the second sample the first player has no available moves.
Submitted Solution:
```
s = input()
memo = {}
def GrundyV2(n):
if n == 0: return 0
if n in memo: return memo[n]
s = set()
for i in range(n):
pile1 = max(0, i - 1)
pile2 = max(n - 2 - i, 0)
child_nimb = (GrundyV2(pile1) ^ GrundyV2(pile2))
s.add(child_nimb)
mex = 0
while mex in s:
mex += 1
memo[n] = mex
return mex
def Grundy(S):
"""
Basically we transform the game.
From a game where we can pick only center of palindrom to a game with several pile where we can pick anything (but it removes adjacent stone)
In this new game, only the remaining size matters (since we can pick anywhere)
"""
total = 0
consec = 0
for i in range(1, len(S)-1):
if S[i - 1] == S[i + 1]:
consec += 1
else:
total ^= GrundyV2(consec)
consec = 0
total ^= consec
return total
if (Grundy(s) != 0):
for i in range(1, len(s)-1):
if s[i - 1] == s[i + 1]:
if ((Grundy(s[:i]) ^ Grundy(s[i:])) == 0):
print("First")
print(i+1)
break
else:
print(Grundy(s))
print("Second")
``` | instruction | 0 | 65,905 | 19 | 131,810 |
No | output | 1 | 65,905 | 19 | 131,811 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two people play the following string game. Initially the players have got some string s. The players move in turns, the player who cannot make a move loses.
Before the game began, the string is written on a piece of paper, one letter per cell.
<image> An example of the initial situation at s = "abacaba"
A player's move is the sequence of actions:
1. The player chooses one of the available pieces of paper with some string written on it. Let's denote it is t. Note that initially, only one piece of paper is available.
2. The player chooses in the string t = t1t2... t|t| character in position i (1 ≤ i ≤ |t|) such that for some positive integer l (0 < i - l; i + l ≤ |t|) the following equations hold: ti - 1 = ti + 1, ti - 2 = ti + 2, ..., ti - l = ti + l.
3. Player cuts the cell with the chosen character. As a result of the operation, he gets three new pieces of paper, the first one will contain string t1t2... ti - 1, the second one will contain a string consisting of a single character ti, the third one contains string ti + 1ti + 2... t|t|.
<image> An example of making action (i = 4) with string s = «abacaba»
Your task is to determine the winner provided that both players play optimally well. If the first player wins, find the position of character that is optimal to cut in his first move. If there are multiple positions, print the minimal possible one.
Input
The first line contains string s (1 ≤ |s| ≤ 5000). It is guaranteed that string s only contains lowercase English letters.
Output
If the second player wins, print in the single line "Second" (without the quotes). Otherwise, print in the first line "First" (without the quotes), and in the second line print the minimal possible winning move — integer i (1 ≤ i ≤ |s|).
Examples
Input
abacaba
Output
First
2
Input
abcde
Output
Second
Note
In the first sample the first player has multiple winning moves. But the minimum one is to cut the character in position 2.
In the second sample the first player has no available moves.
Submitted Solution:
```
s = input()
memo = {}
def GrundyV2(n):
if n == 0: return 0
if n in memo: return memo[n]
nimb = 0
for i in range(n):
pile1 = max(0, i - 1)
pile2 = max(n - 2 - i, 0)
nimb ^= (GrundyV2(pile1) ^ GrundyV2(pile2))
memo[n] = nimb
return nimb
def Grundy(S):
"""
Basically we transform the game.
From a game where we can pick only center of palindrom to a game with several pile where we can pick anything (but it removes adjacent stone)
In this new game, only the remaining size matters (since we can pick anywhere)
"""
total = 0
for i in range(1, len(s)-1):
consec = 0
if s[i - 1] == s[i + 1]:
consec += 1
else:
total ^= GrundyV2(consec)
consec = 0
return total
if (Grundy(s) != 0):
for i in range(1, len(s)-1):
if s[i - 1] == s[i + 1]:
if ((Grundy(s[:i - 1]) ^ Grundy(s[i + 1:]) != 0)):
print("First")
print(i)
else:
print("Second")
``` | instruction | 0 | 65,906 | 19 | 131,812 |
No | output | 1 | 65,906 | 19 | 131,813 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two people play the following string game. Initially the players have got some string s. The players move in turns, the player who cannot make a move loses.
Before the game began, the string is written on a piece of paper, one letter per cell.
<image> An example of the initial situation at s = "abacaba"
A player's move is the sequence of actions:
1. The player chooses one of the available pieces of paper with some string written on it. Let's denote it is t. Note that initially, only one piece of paper is available.
2. The player chooses in the string t = t1t2... t|t| character in position i (1 ≤ i ≤ |t|) such that for some positive integer l (0 < i - l; i + l ≤ |t|) the following equations hold: ti - 1 = ti + 1, ti - 2 = ti + 2, ..., ti - l = ti + l.
3. Player cuts the cell with the chosen character. As a result of the operation, he gets three new pieces of paper, the first one will contain string t1t2... ti - 1, the second one will contain a string consisting of a single character ti, the third one contains string ti + 1ti + 2... t|t|.
<image> An example of making action (i = 4) with string s = «abacaba»
Your task is to determine the winner provided that both players play optimally well. If the first player wins, find the position of character that is optimal to cut in his first move. If there are multiple positions, print the minimal possible one.
Input
The first line contains string s (1 ≤ |s| ≤ 5000). It is guaranteed that string s only contains lowercase English letters.
Output
If the second player wins, print in the single line "Second" (without the quotes). Otherwise, print in the first line "First" (without the quotes), and in the second line print the minimal possible winning move — integer i (1 ≤ i ≤ |s|).
Examples
Input
abacaba
Output
First
2
Input
abcde
Output
Second
Note
In the first sample the first player has multiple winning moves. But the minimum one is to cut the character in position 2.
In the second sample the first player has no available moves.
Submitted Solution:
```
s = input()
d = [0 for i in s]
a = [0] * 5
for i in range(1, len(s) - 1):
if s[i - 1] == s[i + 1]:
d[i] = d[i - 1] + 1
d[i - 1] = 0
for i in d:
a[i % 5] ^= 1
if a[2] == a[3] == 0:
print('Second')
else:
print('First')
for i in range(1, len(s) - 1):
if a[3] == 0 and d[i] <= 2 or a[2] == a[3] and d[i] >= 3:
print(i - d[i] + 2)
break
if a[2] == 0 and d[i] >= 3:
print(i - d[i] + 3)
break
``` | instruction | 0 | 65,907 | 19 | 131,814 |
No | output | 1 | 65,907 | 19 | 131,815 |
Provide a correct Python 3 solution for this coding contest problem.
You are playing the following game with Joisino.
* Initially, you have a blank sheet of paper.
* Joisino announces a number. If that number is written on the sheet, erase the number from the sheet; if not, write the number on the sheet. This process is repeated N times.
* Then, you are asked a question: How many numbers are written on the sheet now?
The numbers announced by Joisino are given as A_1, ... ,A_N in the order she announces them. How many numbers will be written on the sheet at the end of the game?
Constraints
* 1≤N≤100000
* 1≤A_i≤1000000000(=10^9)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
A_1
:
A_N
Output
Print how many numbers will be written on the sheet at the end of the game.
Examples
Input
3
6
2
6
Output
1
Input
4
2
5
5
2
Output
0
Input
6
12
22
16
22
18
12
Output
2 | instruction | 0 | 66,322 | 19 | 132,644 |
"Correct Solution:
```
N=int(input())
A=[int(input()) for _ in range(N)]
memo=dict()
for a in A:
memo[a] = not memo.get(a,False)
print(sum(memo.values()))
``` | output | 1 | 66,322 | 19 | 132,645 |
Provide a correct Python 3 solution for this coding contest problem.
You are playing the following game with Joisino.
* Initially, you have a blank sheet of paper.
* Joisino announces a number. If that number is written on the sheet, erase the number from the sheet; if not, write the number on the sheet. This process is repeated N times.
* Then, you are asked a question: How many numbers are written on the sheet now?
The numbers announced by Joisino are given as A_1, ... ,A_N in the order she announces them. How many numbers will be written on the sheet at the end of the game?
Constraints
* 1≤N≤100000
* 1≤A_i≤1000000000(=10^9)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
A_1
:
A_N
Output
Print how many numbers will be written on the sheet at the end of the game.
Examples
Input
3
6
2
6
Output
1
Input
4
2
5
5
2
Output
0
Input
6
12
22
16
22
18
12
Output
2 | instruction | 0 | 66,323 | 19 | 132,646 |
"Correct Solution:
```
N=int(input())
S=set()
for n in range(N):
_=int(input())
if _ in S:
S.remove(_)
else:
S.add(_)
print(len(S))
``` | output | 1 | 66,323 | 19 | 132,647 |
Provide a correct Python 3 solution for this coding contest problem.
You are playing the following game with Joisino.
* Initially, you have a blank sheet of paper.
* Joisino announces a number. If that number is written on the sheet, erase the number from the sheet; if not, write the number on the sheet. This process is repeated N times.
* Then, you are asked a question: How many numbers are written on the sheet now?
The numbers announced by Joisino are given as A_1, ... ,A_N in the order she announces them. How many numbers will be written on the sheet at the end of the game?
Constraints
* 1≤N≤100000
* 1≤A_i≤1000000000(=10^9)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
A_1
:
A_N
Output
Print how many numbers will be written on the sheet at the end of the game.
Examples
Input
3
6
2
6
Output
1
Input
4
2
5
5
2
Output
0
Input
6
12
22
16
22
18
12
Output
2 | instruction | 0 | 66,324 | 19 | 132,648 |
"Correct Solution:
```
n=int(input())
S=set()
for i in range(n):
S^=set([input()])
print(len(S))
``` | output | 1 | 66,324 | 19 | 132,649 |
Provide a correct Python 3 solution for this coding contest problem.
You are playing the following game with Joisino.
* Initially, you have a blank sheet of paper.
* Joisino announces a number. If that number is written on the sheet, erase the number from the sheet; if not, write the number on the sheet. This process is repeated N times.
* Then, you are asked a question: How many numbers are written on the sheet now?
The numbers announced by Joisino are given as A_1, ... ,A_N in the order she announces them. How many numbers will be written on the sheet at the end of the game?
Constraints
* 1≤N≤100000
* 1≤A_i≤1000000000(=10^9)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
A_1
:
A_N
Output
Print how many numbers will be written on the sheet at the end of the game.
Examples
Input
3
6
2
6
Output
1
Input
4
2
5
5
2
Output
0
Input
6
12
22
16
22
18
12
Output
2 | instruction | 0 | 66,325 | 19 | 132,650 |
"Correct Solution:
```
n=int(input())
s=set([])
for i in range(n):
x=int(input())
if not x in s:
s.add(x)
else:
s.remove(x)
print(len(s))
``` | output | 1 | 66,325 | 19 | 132,651 |
Provide a correct Python 3 solution for this coding contest problem.
You are playing the following game with Joisino.
* Initially, you have a blank sheet of paper.
* Joisino announces a number. If that number is written on the sheet, erase the number from the sheet; if not, write the number on the sheet. This process is repeated N times.
* Then, you are asked a question: How many numbers are written on the sheet now?
The numbers announced by Joisino are given as A_1, ... ,A_N in the order she announces them. How many numbers will be written on the sheet at the end of the game?
Constraints
* 1≤N≤100000
* 1≤A_i≤1000000000(=10^9)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
A_1
:
A_N
Output
Print how many numbers will be written on the sheet at the end of the game.
Examples
Input
3
6
2
6
Output
1
Input
4
2
5
5
2
Output
0
Input
6
12
22
16
22
18
12
Output
2 | instruction | 0 | 66,326 | 19 | 132,652 |
"Correct Solution:
```
n,c=int(input()),{}
for i in range(n):
a=int(input())
if a in c:del c[a]
else:c[a]=1
print(len(c))
``` | output | 1 | 66,326 | 19 | 132,653 |
Provide a correct Python 3 solution for this coding contest problem.
You are playing the following game with Joisino.
* Initially, you have a blank sheet of paper.
* Joisino announces a number. If that number is written on the sheet, erase the number from the sheet; if not, write the number on the sheet. This process is repeated N times.
* Then, you are asked a question: How many numbers are written on the sheet now?
The numbers announced by Joisino are given as A_1, ... ,A_N in the order she announces them. How many numbers will be written on the sheet at the end of the game?
Constraints
* 1≤N≤100000
* 1≤A_i≤1000000000(=10^9)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
A_1
:
A_N
Output
Print how many numbers will be written on the sheet at the end of the game.
Examples
Input
3
6
2
6
Output
1
Input
4
2
5
5
2
Output
0
Input
6
12
22
16
22
18
12
Output
2 | instruction | 0 | 66,327 | 19 | 132,654 |
"Correct Solution:
```
n=int(input())
s=set()
for i in range(n):
x=int(input())
if x in s:
s.remove(x)
else:
s.add(x)
print(len(s))
``` | output | 1 | 66,327 | 19 | 132,655 |
Provide a correct Python 3 solution for this coding contest problem.
You are playing the following game with Joisino.
* Initially, you have a blank sheet of paper.
* Joisino announces a number. If that number is written on the sheet, erase the number from the sheet; if not, write the number on the sheet. This process is repeated N times.
* Then, you are asked a question: How many numbers are written on the sheet now?
The numbers announced by Joisino are given as A_1, ... ,A_N in the order she announces them. How many numbers will be written on the sheet at the end of the game?
Constraints
* 1≤N≤100000
* 1≤A_i≤1000000000(=10^9)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
A_1
:
A_N
Output
Print how many numbers will be written on the sheet at the end of the game.
Examples
Input
3
6
2
6
Output
1
Input
4
2
5
5
2
Output
0
Input
6
12
22
16
22
18
12
Output
2 | instruction | 0 | 66,328 | 19 | 132,656 |
"Correct Solution:
```
N,*A=open(0);s=set()
for a in A:s^={int(a)}
print(len(s))
``` | output | 1 | 66,328 | 19 | 132,657 |
Provide a correct Python 3 solution for this coding contest problem.
You are playing the following game with Joisino.
* Initially, you have a blank sheet of paper.
* Joisino announces a number. If that number is written on the sheet, erase the number from the sheet; if not, write the number on the sheet. This process is repeated N times.
* Then, you are asked a question: How many numbers are written on the sheet now?
The numbers announced by Joisino are given as A_1, ... ,A_N in the order she announces them. How many numbers will be written on the sheet at the end of the game?
Constraints
* 1≤N≤100000
* 1≤A_i≤1000000000(=10^9)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
A_1
:
A_N
Output
Print how many numbers will be written on the sheet at the end of the game.
Examples
Input
3
6
2
6
Output
1
Input
4
2
5
5
2
Output
0
Input
6
12
22
16
22
18
12
Output
2 | instruction | 0 | 66,329 | 19 | 132,658 |
"Correct Solution:
```
n=int(input())
a=[input() for _ in range(n)]
l={}
for i in a:
if i in l:
del l[i]
else:
l[i]=0
print(len(l))
``` | output | 1 | 66,329 | 19 | 132,659 |
Provide a correct Python 3 solution for this coding contest problem.
You have just been put in charge of developing a new shredder for the Shredding Company. Although a ``normal'' shredder would just shred sheets of paper into little pieces so that the contents would become unreadable, this new shredder needs to have the following unusual basic characteristics.
* The shredder takes as input a target number and a sheet of paper with a number written on it.
* It shreds (or cuts) the sheet into pieces each of which has one or more digits on it.
* The sum of the numbers written on each piece is the closest possible number to the target number, without going over it.
For example, suppose that the target number is 50, and the sheet of paper has the number 12346. The shredder would cut the sheet into four pieces, where one piece has 1, another has 2, the third has 34, and the fourth has 6. This is because their sum 43 (= 1 + 2 + 34 + 6) is closest to the target number 50 of all possible combinations without going over 50. For example, a combination where the pieces are 1, 23, 4, and 6 is not valid, because the sum of this combination 34 (= 1 + 23 + 4 + 6) is less than the above combination's 43. The combination of 12, 34, and 6 is not valid either, because the sum 52 (= 12+34+6) is greater than the target number of 50.
<image>
Figure 1. Shredding a sheet of paper having the number 12346 when the target number is 50
There are also three special rules:
* If the target number is the same as the number on the sheet of paper, then the paper is not cut. For example, if the target number is 100 and the number on the sheet of paper is also 100, then the paper is not cut.
* If it is not possible to make any combination whose sum is less than or equal to the target number, then error is printed on a display. For example, if the target number is 1 and the number on the sheet of paper is 123, it is not possible to make any valid combination, as the combination with the smallest possible sum is 1, 2, 3. The sum for this combination is 6, which is greater than the target number, and thus error is printed.
* If there is more than one possible combination where the sum is closest to the target number without going over it, then rejected is printed on a display. For example, if the target number is 15, and the number on the sheet of paper is 111, then there are two possible combinations with the highest possible sum of 12: (a) 1 and 11 and (b) 11 and 1; thus rejected is printed.
In order to develop such a shredder, you have decided to first make a simple program that would simulate the above characteristics and rules. Given two numbers, where the first is the target number and the second is the number on the sheet of paper to be shredded, you need to figure out how the shredder should ``cut up'' the second number.
Input
The input consists of several test cases, each on one line, as follows:
t1 num1
t2 num2
...
tn numn
0 0
Each test case consists of the following two positive integers, which are separated by one space: (1) the first integer (ti above) is the target number; (2) the second integer (numi above) is the number that is on the paper to be shredded.
Neither integers may have a 0 as the first digit, e.g., 123 is allowed but 0123 is not. You may assume that both integers are at most 6 digits in length. A line consisting of two zeros signals the end of the input.
Output
For each test case in the input, the corresponding output takes one of the following three types:
* sum part1 part2 ...
* rejected
* error
In the first type, partj and sum have the following meaning:
* Each partj is a number on one piece of shredded paper. The order of partj corresponds to the order of the original digits on the sheet of paper.
* sum is the sum of the numbers after being shredded, i.e., sum = part1 + part2 + ... .
Each number should be separated by one space.
The message "error" is printed if it is not possible to make any combination, and "rejected" if there is more than one possible combination.
No extra characters including spaces are allowed at the beginning of each line, nor at the end of each line.
Example
Input
50 12346
376 144139
927438 927438
18 3312
9 3142
25 1299
111 33333
103 862150
6 1104
0 0
Output
43 1 2 34 6
283 144 139
927438 927438
18 3 3 12
error
21 1 2 9 9
rejected
103 86 2 15 0
rejected | instruction | 0 | 66,403 | 19 | 132,806 |
"Correct Solution:
```
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve(t,n):
if t == n:
print(t,n)
return
a = list(map(int,list(str(n))))
s = sum(a)
m = len(a)
if s > t:
print("error")
return
nm = m-1
f = [0]*nm
d = defaultdict(lambda : 0)
d[tuple(f)] = 1
l = [[] for i in range(t+1)]
q = [(s,f)]
l[s].append(f)
ans = s
while q:
s,f = heappop(q)
for i in range(nm):
if f[i]:
continue
nf = [1 if j == i else f[j] for j in range(nm)]
ns = 0
ms = a[0]
for j in range(1,m):
if nf[j-1]:
ms *= 10
ms += a[j]
else:
ns += ms
ms = a[j]
ns += ms
if ns <= t:
tf = tuple(nf)
if not d[tf]:
d[tf] = 1
if ns >= ans:
ans = ns
l[ns].append(nf)
heappush(q,(ns,nf))
if len(l[ans]) > 1:
print("rejected")
return
s = [ans]
f = l[ans][0]
k = a[0]
for i in range(nm):
if f[i]:
k *= 10
k += a[i+1]
else:
s.append(k)
k = a[i+1]
s.append(k)
print(*s)
return
#Solve
if __name__ == "__main__":
while 1:
t,n = LI()
if t == n == 0:
break
solve(t,n)
``` | output | 1 | 66,403 | 19 | 132,807 |
Provide a correct Python 3 solution for this coding contest problem.
You have just been put in charge of developing a new shredder for the Shredding Company. Although a ``normal'' shredder would just shred sheets of paper into little pieces so that the contents would become unreadable, this new shredder needs to have the following unusual basic characteristics.
* The shredder takes as input a target number and a sheet of paper with a number written on it.
* It shreds (or cuts) the sheet into pieces each of which has one or more digits on it.
* The sum of the numbers written on each piece is the closest possible number to the target number, without going over it.
For example, suppose that the target number is 50, and the sheet of paper has the number 12346. The shredder would cut the sheet into four pieces, where one piece has 1, another has 2, the third has 34, and the fourth has 6. This is because their sum 43 (= 1 + 2 + 34 + 6) is closest to the target number 50 of all possible combinations without going over 50. For example, a combination where the pieces are 1, 23, 4, and 6 is not valid, because the sum of this combination 34 (= 1 + 23 + 4 + 6) is less than the above combination's 43. The combination of 12, 34, and 6 is not valid either, because the sum 52 (= 12+34+6) is greater than the target number of 50.
<image>
Figure 1. Shredding a sheet of paper having the number 12346 when the target number is 50
There are also three special rules:
* If the target number is the same as the number on the sheet of paper, then the paper is not cut. For example, if the target number is 100 and the number on the sheet of paper is also 100, then the paper is not cut.
* If it is not possible to make any combination whose sum is less than or equal to the target number, then error is printed on a display. For example, if the target number is 1 and the number on the sheet of paper is 123, it is not possible to make any valid combination, as the combination with the smallest possible sum is 1, 2, 3. The sum for this combination is 6, which is greater than the target number, and thus error is printed.
* If there is more than one possible combination where the sum is closest to the target number without going over it, then rejected is printed on a display. For example, if the target number is 15, and the number on the sheet of paper is 111, then there are two possible combinations with the highest possible sum of 12: (a) 1 and 11 and (b) 11 and 1; thus rejected is printed.
In order to develop such a shredder, you have decided to first make a simple program that would simulate the above characteristics and rules. Given two numbers, where the first is the target number and the second is the number on the sheet of paper to be shredded, you need to figure out how the shredder should ``cut up'' the second number.
Input
The input consists of several test cases, each on one line, as follows:
t1 num1
t2 num2
...
tn numn
0 0
Each test case consists of the following two positive integers, which are separated by one space: (1) the first integer (ti above) is the target number; (2) the second integer (numi above) is the number that is on the paper to be shredded.
Neither integers may have a 0 as the first digit, e.g., 123 is allowed but 0123 is not. You may assume that both integers are at most 6 digits in length. A line consisting of two zeros signals the end of the input.
Output
For each test case in the input, the corresponding output takes one of the following three types:
* sum part1 part2 ...
* rejected
* error
In the first type, partj and sum have the following meaning:
* Each partj is a number on one piece of shredded paper. The order of partj corresponds to the order of the original digits on the sheet of paper.
* sum is the sum of the numbers after being shredded, i.e., sum = part1 + part2 + ... .
Each number should be separated by one space.
The message "error" is printed if it is not possible to make any combination, and "rejected" if there is more than one possible combination.
No extra characters including spaces are allowed at the beginning of each line, nor at the end of each line.
Example
Input
50 12346
376 144139
927438 927438
18 3312
9 3142
25 1299
111 33333
103 862150
6 1104
0 0
Output
43 1 2 34 6
283 144 139
927438 927438
18 3 3 12
error
21 1 2 9 9
rejected
103 86 2 15 0
rejected | instruction | 0 | 66,404 | 19 | 132,808 |
"Correct Solution:
```
import itertools
from heapq import heappop, heappush
from collections import defaultdict
def main(t, num):
num = list(str(num))
d = defaultdict(int)
if t < sum(map(int, num)):
print("error")
return
q = [[0,[]]]
itertools.product()
fulls = itertools.product(range(2), repeat=len(num) - 1)
for full in fulls:
tmp = 0
res = []
b = 0
f = False
for i in range(len(num) - 1):
if full[i]:
res.append(i)
tmp += int("".join(num[b: i + 1]))
b = i + 1
tmp += int("".join(num[b:]))
a, b = heappop(q)
a *= - 1
if a == tmp: d[a] += 1
if t >= tmp > a:
a = tmp
b = res
heappush(q, [-a, b])
a, b = heappop(q)
a *= - 1
if d[a] or a == 0:
print("rejected")
else:
ans = []
be = 0
for i in b:
ans.append(int("".join(num[be: i + 1])))
be = i + 1
ans.append(int("".join(num[be:])))
print(a,*ans)
if __name__ == "__main__":
while 1:
t, num = map(int, input().split())
if t == num == 0:
break
main(t, num)
``` | output | 1 | 66,404 | 19 | 132,809 |
Provide a correct Python 3 solution for this coding contest problem.
You have just been put in charge of developing a new shredder for the Shredding Company. Although a ``normal'' shredder would just shred sheets of paper into little pieces so that the contents would become unreadable, this new shredder needs to have the following unusual basic characteristics.
* The shredder takes as input a target number and a sheet of paper with a number written on it.
* It shreds (or cuts) the sheet into pieces each of which has one or more digits on it.
* The sum of the numbers written on each piece is the closest possible number to the target number, without going over it.
For example, suppose that the target number is 50, and the sheet of paper has the number 12346. The shredder would cut the sheet into four pieces, where one piece has 1, another has 2, the third has 34, and the fourth has 6. This is because their sum 43 (= 1 + 2 + 34 + 6) is closest to the target number 50 of all possible combinations without going over 50. For example, a combination where the pieces are 1, 23, 4, and 6 is not valid, because the sum of this combination 34 (= 1 + 23 + 4 + 6) is less than the above combination's 43. The combination of 12, 34, and 6 is not valid either, because the sum 52 (= 12+34+6) is greater than the target number of 50.
<image>
Figure 1. Shredding a sheet of paper having the number 12346 when the target number is 50
There are also three special rules:
* If the target number is the same as the number on the sheet of paper, then the paper is not cut. For example, if the target number is 100 and the number on the sheet of paper is also 100, then the paper is not cut.
* If it is not possible to make any combination whose sum is less than or equal to the target number, then error is printed on a display. For example, if the target number is 1 and the number on the sheet of paper is 123, it is not possible to make any valid combination, as the combination with the smallest possible sum is 1, 2, 3. The sum for this combination is 6, which is greater than the target number, and thus error is printed.
* If there is more than one possible combination where the sum is closest to the target number without going over it, then rejected is printed on a display. For example, if the target number is 15, and the number on the sheet of paper is 111, then there are two possible combinations with the highest possible sum of 12: (a) 1 and 11 and (b) 11 and 1; thus rejected is printed.
In order to develop such a shredder, you have decided to first make a simple program that would simulate the above characteristics and rules. Given two numbers, where the first is the target number and the second is the number on the sheet of paper to be shredded, you need to figure out how the shredder should ``cut up'' the second number.
Input
The input consists of several test cases, each on one line, as follows:
t1 num1
t2 num2
...
tn numn
0 0
Each test case consists of the following two positive integers, which are separated by one space: (1) the first integer (ti above) is the target number; (2) the second integer (numi above) is the number that is on the paper to be shredded.
Neither integers may have a 0 as the first digit, e.g., 123 is allowed but 0123 is not. You may assume that both integers are at most 6 digits in length. A line consisting of two zeros signals the end of the input.
Output
For each test case in the input, the corresponding output takes one of the following three types:
* sum part1 part2 ...
* rejected
* error
In the first type, partj and sum have the following meaning:
* Each partj is a number on one piece of shredded paper. The order of partj corresponds to the order of the original digits on the sheet of paper.
* sum is the sum of the numbers after being shredded, i.e., sum = part1 + part2 + ... .
Each number should be separated by one space.
The message "error" is printed if it is not possible to make any combination, and "rejected" if there is more than one possible combination.
No extra characters including spaces are allowed at the beginning of each line, nor at the end of each line.
Example
Input
50 12346
376 144139
927438 927438
18 3312
9 3142
25 1299
111 33333
103 862150
6 1104
0 0
Output
43 1 2 34 6
283 144 139
927438 927438
18 3 3 12
error
21 1 2 9 9
rejected
103 86 2 15 0
rejected | instruction | 0 | 66,405 | 19 | 132,810 |
"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 = 998244353
dd = [(0,-1),(1,0),(0,1),(-1,0)]
ddn = [(0,-1),(1,-1),(1,0),(1,1),(0,1),(-1,-1),(-1,0),(-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():
rr = []
ii = [2**i for i in range(6)]
while True:
t,n = LI()
if t == 0 and n == 0:
break
s = [c for c in str(n)]
l = len(s)
r = None
rm = -1
rc = 0
for i in range(2**(l-1)):
k = []
c = s[0]
for j in range(l-1):
if ii[j] & i:
c += s[j+1]
else:
k.append(c)
c = s[j+1]
k.append(c)
m = sum(map(int,k))
if m <= t:
if rm < m:
rm = m
r = k
rc = 1
elif rm == m:
rc += 1
if rc == 0:
rr.append('error')
elif rc > 1:
rr.append('rejected')
else:
rr.append('{} {}'.format(rm, ' '.join(r)))
return '\n'.join(map(str, rr))
print(main())
``` | output | 1 | 66,405 | 19 | 132,811 |
Provide a correct Python 3 solution for this coding contest problem.
You have just been put in charge of developing a new shredder for the Shredding Company. Although a ``normal'' shredder would just shred sheets of paper into little pieces so that the contents would become unreadable, this new shredder needs to have the following unusual basic characteristics.
* The shredder takes as input a target number and a sheet of paper with a number written on it.
* It shreds (or cuts) the sheet into pieces each of which has one or more digits on it.
* The sum of the numbers written on each piece is the closest possible number to the target number, without going over it.
For example, suppose that the target number is 50, and the sheet of paper has the number 12346. The shredder would cut the sheet into four pieces, where one piece has 1, another has 2, the third has 34, and the fourth has 6. This is because their sum 43 (= 1 + 2 + 34 + 6) is closest to the target number 50 of all possible combinations without going over 50. For example, a combination where the pieces are 1, 23, 4, and 6 is not valid, because the sum of this combination 34 (= 1 + 23 + 4 + 6) is less than the above combination's 43. The combination of 12, 34, and 6 is not valid either, because the sum 52 (= 12+34+6) is greater than the target number of 50.
<image>
Figure 1. Shredding a sheet of paper having the number 12346 when the target number is 50
There are also three special rules:
* If the target number is the same as the number on the sheet of paper, then the paper is not cut. For example, if the target number is 100 and the number on the sheet of paper is also 100, then the paper is not cut.
* If it is not possible to make any combination whose sum is less than or equal to the target number, then error is printed on a display. For example, if the target number is 1 and the number on the sheet of paper is 123, it is not possible to make any valid combination, as the combination with the smallest possible sum is 1, 2, 3. The sum for this combination is 6, which is greater than the target number, and thus error is printed.
* If there is more than one possible combination where the sum is closest to the target number without going over it, then rejected is printed on a display. For example, if the target number is 15, and the number on the sheet of paper is 111, then there are two possible combinations with the highest possible sum of 12: (a) 1 and 11 and (b) 11 and 1; thus rejected is printed.
In order to develop such a shredder, you have decided to first make a simple program that would simulate the above characteristics and rules. Given two numbers, where the first is the target number and the second is the number on the sheet of paper to be shredded, you need to figure out how the shredder should ``cut up'' the second number.
Input
The input consists of several test cases, each on one line, as follows:
t1 num1
t2 num2
...
tn numn
0 0
Each test case consists of the following two positive integers, which are separated by one space: (1) the first integer (ti above) is the target number; (2) the second integer (numi above) is the number that is on the paper to be shredded.
Neither integers may have a 0 as the first digit, e.g., 123 is allowed but 0123 is not. You may assume that both integers are at most 6 digits in length. A line consisting of two zeros signals the end of the input.
Output
For each test case in the input, the corresponding output takes one of the following three types:
* sum part1 part2 ...
* rejected
* error
In the first type, partj and sum have the following meaning:
* Each partj is a number on one piece of shredded paper. The order of partj corresponds to the order of the original digits on the sheet of paper.
* sum is the sum of the numbers after being shredded, i.e., sum = part1 + part2 + ... .
Each number should be separated by one space.
The message "error" is printed if it is not possible to make any combination, and "rejected" if there is more than one possible combination.
No extra characters including spaces are allowed at the beginning of each line, nor at the end of each line.
Example
Input
50 12346
376 144139
927438 927438
18 3312
9 3142
25 1299
111 33333
103 862150
6 1104
0 0
Output
43 1 2 34 6
283 144 139
927438 927438
18 3 3 12
error
21 1 2 9 9
rejected
103 86 2 15 0
rejected | instruction | 0 | 66,406 | 19 | 132,812 |
"Correct Solution:
```
#!/usr/bin/env python3
while True:
t, n = input().split()
t = int(t)
if t == 0:
exit()
L = len(n)
m = 0
parts = []
f = False
for b in range(1 << (L - 1)):
c = int(n[0])
s = 0
li = []
for k in range(L - 1):
if b >> k & 1 == 1:
s += c
li.append(c)
c = 0
c = 10 * c + int(n[k + 1])
s += c
li.append(c)
c = 0
if s > t:
continue
if s >= m:
f = (s == m)
m = s
parts = li
if f:
print('rejected')
elif m == 0:
print('error')
else:
print(m, *parts, sep=' ')
``` | output | 1 | 66,406 | 19 | 132,813 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Wojtek has just won a maths competition in Byteland! The prize is admirable — a great book called 'Card Tricks for Everyone.' 'Great!' he thought, 'I can finally use this old, dusted deck of cards that's always been lying unused on my desk!'
The first chapter of the book is 'How to Shuffle k Cards in Any Order You Want.' It's basically a list of n intricate methods of shuffling the deck of k cards in a deterministic way. Specifically, the i-th recipe can be described as a permutation (P_{i,1}, P_{i,2}, ..., P_{i,k}) of integers from 1 to k. If we enumerate the cards in the deck from 1 to k from top to bottom, then P_{i,j} indicates the number of the j-th card from the top of the deck after the shuffle.
The day is short and Wojtek wants to learn only some of the tricks today. He will pick two integers l, r (1 ≤ l ≤ r ≤ n), and he will memorize each trick from the l-th to the r-th, inclusive. He will then take a sorted deck of k cards and repeatedly apply random memorized tricks until he gets bored. He still likes maths, so he started wondering: how many different decks can he have after he stops shuffling it?
Wojtek still didn't choose the integers l and r, but he is still curious. Therefore, he defined f(l, r) as the number of different decks he can get if he memorizes all the tricks between the l-th and the r-th, inclusive. What is the value of
$$$∑_{l=1}^n ∑_{r=l}^n f(l, r)?$$$
Input
The first line contains two integers n, k (1 ≤ n ≤ 200 000, 1 ≤ k ≤ 5) — the number of tricks and the number of cards in Wojtek's deck.
Each of the following n lines describes a single trick and is described by k distinct integers P_{i,1}, P_{i,2}, ..., P_{i, k} (1 ≤ P_{i, j} ≤ k).
Output
Output the value of the sum described in the statement.
Examples
Input
3 3
2 1 3
3 1 2
1 3 2
Output
25
Input
2 4
4 1 3 2
4 3 1 2
Output
31
Note
Consider the first sample:
* The first trick swaps two top cards.
* The second trick takes a card from the bottom and puts it on the top of the deck.
* The third trick swaps two bottom cards.
The first or the third trick allow Wojtek to generate only two distinct decks (either the two cards are swapped or not). Therefore, f(1, 1) = f(3, 3) = 2.
The second trick allows him to shuffle the deck in a cyclic order. Therefore, f(2,2)=3.
It turns that two first tricks or two last tricks are enough to shuffle the deck in any way desired by Wojtek. Therefore, f(1,2) = f(2,3) = f(1,3) = 3! = 6.
Submitted Solution:
```
l = input().split(" ")
n = int(l[0])
k = int(l[1])
l=[]
for i in range(n):
x= input().split(" ")
l.append([ int(x[j])-1 for j in range(len(x))] + [a for a in range(k,n)])
c = [0]*3712
p = []
def comp(a,b):
return [ a[b[i]] for i in range(len(b))]
def how(a,l):
r=[]
for x in l:
k=comp(a,x)
if k not in l:
r.append(k)
l.append(k)
k=comp(x,a)
if k not in l:
r.append(k)
l.append(k)
if len(r) == 0:
return l
return how(a,l)
def hov(l):
r=0
for x in l:
for y in l:
k=comp(x,y)
if k not in l:
r=r+1
l.append(k)
if r==0 :
return l
return hov(l)
#sum=0
#for k in range(n):
# lis=[[0,1,2,3,4]]
# for j in range(k,n):
# lis=how(l[j],lis)
# sum=sum+len(lis)
# print(lis ,sum)
#
sum=0
for k in range(n):
lis=[]
r=[]
for j in range(k,n):
lis.append(l[j])
if l[j] not in r:
r.append(l[j])
lis=hov(lis)
sum=sum+len(lis)
print(sum)
``` | instruction | 0 | 66,529 | 19 | 133,058 |
No | output | 1 | 66,529 | 19 | 133,059 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Wojtek has just won a maths competition in Byteland! The prize is admirable — a great book called 'Card Tricks for Everyone.' 'Great!' he thought, 'I can finally use this old, dusted deck of cards that's always been lying unused on my desk!'
The first chapter of the book is 'How to Shuffle k Cards in Any Order You Want.' It's basically a list of n intricate methods of shuffling the deck of k cards in a deterministic way. Specifically, the i-th recipe can be described as a permutation (P_{i,1}, P_{i,2}, ..., P_{i,k}) of integers from 1 to k. If we enumerate the cards in the deck from 1 to k from top to bottom, then P_{i,j} indicates the number of the j-th card from the top of the deck after the shuffle.
The day is short and Wojtek wants to learn only some of the tricks today. He will pick two integers l, r (1 ≤ l ≤ r ≤ n), and he will memorize each trick from the l-th to the r-th, inclusive. He will then take a sorted deck of k cards and repeatedly apply random memorized tricks until he gets bored. He still likes maths, so he started wondering: how many different decks can he have after he stops shuffling it?
Wojtek still didn't choose the integers l and r, but he is still curious. Therefore, he defined f(l, r) as the number of different decks he can get if he memorizes all the tricks between the l-th and the r-th, inclusive. What is the value of
$$$∑_{l=1}^n ∑_{r=l}^n f(l, r)?$$$
Input
The first line contains two integers n, k (1 ≤ n ≤ 200 000, 1 ≤ k ≤ 5) — the number of tricks and the number of cards in Wojtek's deck.
Each of the following n lines describes a single trick and is described by k distinct integers P_{i,1}, P_{i,2}, ..., P_{i, k} (1 ≤ P_{i, j} ≤ k).
Output
Output the value of the sum described in the statement.
Examples
Input
3 3
2 1 3
3 1 2
1 3 2
Output
25
Input
2 4
4 1 3 2
4 3 1 2
Output
31
Note
Consider the first sample:
* The first trick swaps two top cards.
* The second trick takes a card from the bottom and puts it on the top of the deck.
* The third trick swaps two bottom cards.
The first or the third trick allow Wojtek to generate only two distinct decks (either the two cards are swapped or not). Therefore, f(1, 1) = f(3, 3) = 2.
The second trick allows him to shuffle the deck in a cyclic order. Therefore, f(2,2)=3.
It turns that two first tricks or two last tricks are enough to shuffle the deck in any way desired by Wojtek. Therefore, f(1,2) = f(2,3) = f(1,3) = 3! = 6.
Submitted Solution:
```
l = input().split(" ")
n = int(l[0])
k = int(l[1])
l=[]
for i in range(n):
x= input().split(" ")
l.append([ int(x[j])-1 for j in range(len(x))])
print(l)
c = [0]*3712
p = []
def comp(a,b):
return [ a[b[i]] for i in range(len(b))]
def how(a,l):
r=[]
for x in l:
k=comp(a,x)
if k not in l:
r.append(k)
l.append(k)
k=comp(x,a)
if k not in l:
r.append(k)
l.append(k)
if len(r) == 0:
return l
return how(a,l)
def hov(l):
r=0
for x in l:
for y in l:
k=comp(x,y)
if k not in l:
r=r+1
l.append(k)
if r==0 :
return l
return hov(l)
#sum=0
#for k in range(n):
# lis=[[0,1,2,3,4]]
# for j in range(k,n):
# lis=how(l[j],lis)
# sum=sum+len(lis)
# print(lis ,sum)
#
sum=0
for k in range(n):
lis=[]
r=[]
for j in range(k,n):
lis.append(l[j])
if l[j] not in r:
r.append(l[j])
lis=hov(lis)
sum=sum+len(lis)
print(lis ,sum)
print(sum)
``` | instruction | 0 | 66,530 | 19 | 133,060 |
No | output | 1 | 66,530 | 19 | 133,061 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Wojtek has just won a maths competition in Byteland! The prize is admirable — a great book called 'Card Tricks for Everyone.' 'Great!' he thought, 'I can finally use this old, dusted deck of cards that's always been lying unused on my desk!'
The first chapter of the book is 'How to Shuffle k Cards in Any Order You Want.' It's basically a list of n intricate methods of shuffling the deck of k cards in a deterministic way. Specifically, the i-th recipe can be described as a permutation (P_{i,1}, P_{i,2}, ..., P_{i,k}) of integers from 1 to k. If we enumerate the cards in the deck from 1 to k from top to bottom, then P_{i,j} indicates the number of the j-th card from the top of the deck after the shuffle.
The day is short and Wojtek wants to learn only some of the tricks today. He will pick two integers l, r (1 ≤ l ≤ r ≤ n), and he will memorize each trick from the l-th to the r-th, inclusive. He will then take a sorted deck of k cards and repeatedly apply random memorized tricks until he gets bored. He still likes maths, so he started wondering: how many different decks can he have after he stops shuffling it?
Wojtek still didn't choose the integers l and r, but he is still curious. Therefore, he defined f(l, r) as the number of different decks he can get if he memorizes all the tricks between the l-th and the r-th, inclusive. What is the value of
$$$∑_{l=1}^n ∑_{r=l}^n f(l, r)?$$$
Input
The first line contains two integers n, k (1 ≤ n ≤ 200 000, 1 ≤ k ≤ 5) — the number of tricks and the number of cards in Wojtek's deck.
Each of the following n lines describes a single trick and is described by k distinct integers P_{i,1}, P_{i,2}, ..., P_{i, k} (1 ≤ P_{i, j} ≤ k).
Output
Output the value of the sum described in the statement.
Examples
Input
3 3
2 1 3
3 1 2
1 3 2
Output
25
Input
2 4
4 1 3 2
4 3 1 2
Output
31
Note
Consider the first sample:
* The first trick swaps two top cards.
* The second trick takes a card from the bottom and puts it on the top of the deck.
* The third trick swaps two bottom cards.
The first or the third trick allow Wojtek to generate only two distinct decks (either the two cards are swapped or not). Therefore, f(1, 1) = f(3, 3) = 2.
The second trick allows him to shuffle the deck in a cyclic order. Therefore, f(2,2)=3.
It turns that two first tricks or two last tricks are enough to shuffle the deck in any way desired by Wojtek. Therefore, f(1,2) = f(2,3) = f(1,3) = 3! = 6.
Submitted Solution:
```
l = input().split(" ")
n = int(l[0])
k = int(l[1])
l=[]
for i in range(n):
x= input().split(" ")
l.append([ int(x[j])-1 for j in range(len(x))])
c = [0]*3712
p = []
def comp(a,b):
return [ a[b[i]] for i in range(len(b))]
def how(a,l):
r=[]
for x in l:
k=comp(a,x)
if k not in l:
r.append(k)
l.append(k)
k=comp(x,a)
if k not in l:
r.append(k)
l.append(k)
if len(r) == 0:
return l
return how(a,l)
def hov(l):
r=0
for x in l:
for y in l:
k=comp(x,y)
if k not in l:
r=r+1
l.append(k)
if r==0 :
return l
return hov(l)
#sum=0
#for k in range(n):
# lis=[[0,1,2,3,4]]
# for j in range(k,n):
# lis=how(l[j],lis)
# sum=sum+len(lis)
# print(lis ,sum)
#
sum=0
for k in range(n):
lis=[]
r=[]
for j in range(k,n):
lis.append(l[j])
if l[j] not in r:
r.append(l[j])
lis=hov(lis)
sum=sum+len(lis)
print(sum)
``` | instruction | 0 | 66,531 | 19 | 133,062 |
No | output | 1 | 66,531 | 19 | 133,063 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently, you found a bot to play "Rock paper scissors" with. Unfortunately, the bot uses quite a simple algorithm to play: he has a string s = s_1 s_2 ... s_{n} of length n where each letter is either R, S or P.
While initializing, the bot is choosing a starting index pos (1 ≤ pos ≤ n), and then it can play any number of rounds. In the first round, he chooses "Rock", "Scissors" or "Paper" based on the value of s_{pos}:
* if s_{pos} is equal to R the bot chooses "Rock";
* if s_{pos} is equal to S the bot chooses "Scissors";
* if s_{pos} is equal to P the bot chooses "Paper";
In the second round, the bot's choice is based on the value of s_{pos + 1}. In the third round — on s_{pos + 2} and so on. After s_n the bot returns to s_1 and continues his game.
You plan to play n rounds and you've already figured out the string s but still don't know what is the starting index pos. But since the bot's tactic is so boring, you've decided to find n choices to each round to maximize the average number of wins.
In other words, let's suggest your choices are c_1 c_2 ... c_n and if the bot starts from index pos then you'll win in win(pos) rounds. Find c_1 c_2 ... c_n such that (win(1) + win(2) + ... + win(n))/(n) is maximum possible.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per line. The first and only line of each test case contains string s = s_1 s_2 ... s_{n} (1 ≤ n ≤ 2 ⋅ 10^5; s_i ∈ \{R, S, P\}) — the string of the bot.
It's guaranteed that the total length of all strings in one test doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print n choices c_1 c_2 ... c_n to maximize the average number of wins. Print them in the same manner as the string s.
If there are multiple optimal answers, print any of them.
Example
Input
3
RRRR
RSP
S
Output
PPPP
RSP
R
Note
In the first test case, the bot (wherever it starts) will always choose "Rock", so we can always choose "Paper". So, in any case, we will win all n = 4 rounds, so the average is also equal to 4.
In the second test case:
* if bot will start from pos = 1, then (s_1, c_1) is draw, (s_2, c_2) is draw and (s_3, c_3) is draw, so win(1) = 0;
* if bot will start from pos = 2, then (s_2, c_1) is win, (s_3, c_2) is win and (s_1, c_3) is win, so win(2) = 3;
* if bot will start from pos = 3, then (s_3, c_1) is lose, (s_1, c_2) is lose and (s_2, c_3) is lose, so win(3) = 0;
The average is equal to (0 + 3 + 0)/(3) = 1 and it can be proven that it's the maximum possible average.
A picture from Wikipedia explaining "Rock paper scissors" game:
<image> | instruction | 0 | 66,604 | 19 | 133,208 |
Tags: greedy
Correct Solution:
```
T=int(input())
for ii in range(T):
s=input()
n=len(s)
R=0
P=0
S=0
for i in s:
if i=="R":
R+=1
elif i=="P":
P+=1
else:
S+=1
if max(R,P,S)==R:
result="P"*n
elif max(R,P,S)==P:
result="S"*n
else:
result="R"*n
print(result)
#3
#RRRR
#RSP
#S
``` | output | 1 | 66,604 | 19 | 133,209 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently, you found a bot to play "Rock paper scissors" with. Unfortunately, the bot uses quite a simple algorithm to play: he has a string s = s_1 s_2 ... s_{n} of length n where each letter is either R, S or P.
While initializing, the bot is choosing a starting index pos (1 ≤ pos ≤ n), and then it can play any number of rounds. In the first round, he chooses "Rock", "Scissors" or "Paper" based on the value of s_{pos}:
* if s_{pos} is equal to R the bot chooses "Rock";
* if s_{pos} is equal to S the bot chooses "Scissors";
* if s_{pos} is equal to P the bot chooses "Paper";
In the second round, the bot's choice is based on the value of s_{pos + 1}. In the third round — on s_{pos + 2} and so on. After s_n the bot returns to s_1 and continues his game.
You plan to play n rounds and you've already figured out the string s but still don't know what is the starting index pos. But since the bot's tactic is so boring, you've decided to find n choices to each round to maximize the average number of wins.
In other words, let's suggest your choices are c_1 c_2 ... c_n and if the bot starts from index pos then you'll win in win(pos) rounds. Find c_1 c_2 ... c_n such that (win(1) + win(2) + ... + win(n))/(n) is maximum possible.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per line. The first and only line of each test case contains string s = s_1 s_2 ... s_{n} (1 ≤ n ≤ 2 ⋅ 10^5; s_i ∈ \{R, S, P\}) — the string of the bot.
It's guaranteed that the total length of all strings in one test doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print n choices c_1 c_2 ... c_n to maximize the average number of wins. Print them in the same manner as the string s.
If there are multiple optimal answers, print any of them.
Example
Input
3
RRRR
RSP
S
Output
PPPP
RSP
R
Note
In the first test case, the bot (wherever it starts) will always choose "Rock", so we can always choose "Paper". So, in any case, we will win all n = 4 rounds, so the average is also equal to 4.
In the second test case:
* if bot will start from pos = 1, then (s_1, c_1) is draw, (s_2, c_2) is draw and (s_3, c_3) is draw, so win(1) = 0;
* if bot will start from pos = 2, then (s_2, c_1) is win, (s_3, c_2) is win and (s_1, c_3) is win, so win(2) = 3;
* if bot will start from pos = 3, then (s_3, c_1) is lose, (s_1, c_2) is lose and (s_2, c_3) is lose, so win(3) = 0;
The average is equal to (0 + 3 + 0)/(3) = 1 and it can be proven that it's the maximum possible average.
A picture from Wikipedia explaining "Rock paper scissors" game:
<image> | instruction | 0 | 66,605 | 19 | 133,210 |
Tags: greedy
Correct Solution:
```
def solve():
s=input()
d={'R':0,'S':0,'P':0}
for i in s:
d[i]+=1
x=float('-inf')
for i in d:
if(d[i]>x):
k=i
x=d[i]
if k=='R':
print('P'*len(s))
elif k=='S':
print('R'*len(s))
else:
print('S'*len(s))
t=int(input())
for _ in range(t):
solve()
``` | output | 1 | 66,605 | 19 | 133,211 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently, you found a bot to play "Rock paper scissors" with. Unfortunately, the bot uses quite a simple algorithm to play: he has a string s = s_1 s_2 ... s_{n} of length n where each letter is either R, S or P.
While initializing, the bot is choosing a starting index pos (1 ≤ pos ≤ n), and then it can play any number of rounds. In the first round, he chooses "Rock", "Scissors" or "Paper" based on the value of s_{pos}:
* if s_{pos} is equal to R the bot chooses "Rock";
* if s_{pos} is equal to S the bot chooses "Scissors";
* if s_{pos} is equal to P the bot chooses "Paper";
In the second round, the bot's choice is based on the value of s_{pos + 1}. In the third round — on s_{pos + 2} and so on. After s_n the bot returns to s_1 and continues his game.
You plan to play n rounds and you've already figured out the string s but still don't know what is the starting index pos. But since the bot's tactic is so boring, you've decided to find n choices to each round to maximize the average number of wins.
In other words, let's suggest your choices are c_1 c_2 ... c_n and if the bot starts from index pos then you'll win in win(pos) rounds. Find c_1 c_2 ... c_n such that (win(1) + win(2) + ... + win(n))/(n) is maximum possible.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per line. The first and only line of each test case contains string s = s_1 s_2 ... s_{n} (1 ≤ n ≤ 2 ⋅ 10^5; s_i ∈ \{R, S, P\}) — the string of the bot.
It's guaranteed that the total length of all strings in one test doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print n choices c_1 c_2 ... c_n to maximize the average number of wins. Print them in the same manner as the string s.
If there are multiple optimal answers, print any of them.
Example
Input
3
RRRR
RSP
S
Output
PPPP
RSP
R
Note
In the first test case, the bot (wherever it starts) will always choose "Rock", so we can always choose "Paper". So, in any case, we will win all n = 4 rounds, so the average is also equal to 4.
In the second test case:
* if bot will start from pos = 1, then (s_1, c_1) is draw, (s_2, c_2) is draw and (s_3, c_3) is draw, so win(1) = 0;
* if bot will start from pos = 2, then (s_2, c_1) is win, (s_3, c_2) is win and (s_1, c_3) is win, so win(2) = 3;
* if bot will start from pos = 3, then (s_3, c_1) is lose, (s_1, c_2) is lose and (s_2, c_3) is lose, so win(3) = 0;
The average is equal to (0 + 3 + 0)/(3) = 1 and it can be proven that it's the maximum possible average.
A picture from Wikipedia explaining "Rock paper scissors" game:
<image> | instruction | 0 | 66,606 | 19 | 133,212 |
Tags: greedy
Correct Solution:
```
for _ in range(int(input())):
s = input()
ss = list(s)
rcount = ss.count('R')
scount = ss.count('S')
pcount = ss.count('P')
mymax = max(pcount,scount,rcount)
if mymax == rcount:
print('P'*len(s))
elif mymax == scount:
print('R'*len(s))
else:
print('S'*len(s))
``` | output | 1 | 66,606 | 19 | 133,213 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently, you found a bot to play "Rock paper scissors" with. Unfortunately, the bot uses quite a simple algorithm to play: he has a string s = s_1 s_2 ... s_{n} of length n where each letter is either R, S or P.
While initializing, the bot is choosing a starting index pos (1 ≤ pos ≤ n), and then it can play any number of rounds. In the first round, he chooses "Rock", "Scissors" or "Paper" based on the value of s_{pos}:
* if s_{pos} is equal to R the bot chooses "Rock";
* if s_{pos} is equal to S the bot chooses "Scissors";
* if s_{pos} is equal to P the bot chooses "Paper";
In the second round, the bot's choice is based on the value of s_{pos + 1}. In the third round — on s_{pos + 2} and so on. After s_n the bot returns to s_1 and continues his game.
You plan to play n rounds and you've already figured out the string s but still don't know what is the starting index pos. But since the bot's tactic is so boring, you've decided to find n choices to each round to maximize the average number of wins.
In other words, let's suggest your choices are c_1 c_2 ... c_n and if the bot starts from index pos then you'll win in win(pos) rounds. Find c_1 c_2 ... c_n such that (win(1) + win(2) + ... + win(n))/(n) is maximum possible.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per line. The first and only line of each test case contains string s = s_1 s_2 ... s_{n} (1 ≤ n ≤ 2 ⋅ 10^5; s_i ∈ \{R, S, P\}) — the string of the bot.
It's guaranteed that the total length of all strings in one test doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print n choices c_1 c_2 ... c_n to maximize the average number of wins. Print them in the same manner as the string s.
If there are multiple optimal answers, print any of them.
Example
Input
3
RRRR
RSP
S
Output
PPPP
RSP
R
Note
In the first test case, the bot (wherever it starts) will always choose "Rock", so we can always choose "Paper". So, in any case, we will win all n = 4 rounds, so the average is also equal to 4.
In the second test case:
* if bot will start from pos = 1, then (s_1, c_1) is draw, (s_2, c_2) is draw and (s_3, c_3) is draw, so win(1) = 0;
* if bot will start from pos = 2, then (s_2, c_1) is win, (s_3, c_2) is win and (s_1, c_3) is win, so win(2) = 3;
* if bot will start from pos = 3, then (s_3, c_1) is lose, (s_1, c_2) is lose and (s_2, c_3) is lose, so win(3) = 0;
The average is equal to (0 + 3 + 0)/(3) = 1 and it can be proven that it's the maximum possible average.
A picture from Wikipedia explaining "Rock paper scissors" game:
<image> | instruction | 0 | 66,607 | 19 | 133,214 |
Tags: greedy
Correct Solution:
```
t = int(input())
for i in range(t):
s1 = input()
s = list(s1)
l = len(s1)
# print(s)
hm = {}
hm['R'] = 0; hm['S'] = 0; hm['P'] = 0
for j in s:
hm[j]+=1
# print(hm)
if hm['R']==hm['S'] and hm['R']==hm['P']:
print(s1)
continue
q = max(hm, key = hm.get)
#print(hm,q)
if q=='R':
print('P'*l)
continue
if q=='S':
print('R'*l)
continue
if q=='P':
print('S'*l)
continue
``` | output | 1 | 66,607 | 19 | 133,215 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently, you found a bot to play "Rock paper scissors" with. Unfortunately, the bot uses quite a simple algorithm to play: he has a string s = s_1 s_2 ... s_{n} of length n where each letter is either R, S or P.
While initializing, the bot is choosing a starting index pos (1 ≤ pos ≤ n), and then it can play any number of rounds. In the first round, he chooses "Rock", "Scissors" or "Paper" based on the value of s_{pos}:
* if s_{pos} is equal to R the bot chooses "Rock";
* if s_{pos} is equal to S the bot chooses "Scissors";
* if s_{pos} is equal to P the bot chooses "Paper";
In the second round, the bot's choice is based on the value of s_{pos + 1}. In the third round — on s_{pos + 2} and so on. After s_n the bot returns to s_1 and continues his game.
You plan to play n rounds and you've already figured out the string s but still don't know what is the starting index pos. But since the bot's tactic is so boring, you've decided to find n choices to each round to maximize the average number of wins.
In other words, let's suggest your choices are c_1 c_2 ... c_n and if the bot starts from index pos then you'll win in win(pos) rounds. Find c_1 c_2 ... c_n such that (win(1) + win(2) + ... + win(n))/(n) is maximum possible.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per line. The first and only line of each test case contains string s = s_1 s_2 ... s_{n} (1 ≤ n ≤ 2 ⋅ 10^5; s_i ∈ \{R, S, P\}) — the string of the bot.
It's guaranteed that the total length of all strings in one test doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print n choices c_1 c_2 ... c_n to maximize the average number of wins. Print them in the same manner as the string s.
If there are multiple optimal answers, print any of them.
Example
Input
3
RRRR
RSP
S
Output
PPPP
RSP
R
Note
In the first test case, the bot (wherever it starts) will always choose "Rock", so we can always choose "Paper". So, in any case, we will win all n = 4 rounds, so the average is also equal to 4.
In the second test case:
* if bot will start from pos = 1, then (s_1, c_1) is draw, (s_2, c_2) is draw and (s_3, c_3) is draw, so win(1) = 0;
* if bot will start from pos = 2, then (s_2, c_1) is win, (s_3, c_2) is win and (s_1, c_3) is win, so win(2) = 3;
* if bot will start from pos = 3, then (s_3, c_1) is lose, (s_1, c_2) is lose and (s_2, c_3) is lose, so win(3) = 0;
The average is equal to (0 + 3 + 0)/(3) = 1 and it can be proven that it's the maximum possible average.
A picture from Wikipedia explaining "Rock paper scissors" game:
<image> | instruction | 0 | 66,608 | 19 | 133,216 |
Tags: greedy
Correct Solution:
```
t = int(input())
for _ in range(t):
s = input()
n = len(s)
cnt_r = s.count("R")
cnt_s = s.count("S")
cnt_p = s.count("P")
max_cnt = max(cnt_r, cnt_s, cnt_p)
if max_cnt == cnt_r:
print("P" * n)
elif max_cnt == cnt_s:
print("R" * n)
else:
print("S" * n)
``` | output | 1 | 66,608 | 19 | 133,217 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently, you found a bot to play "Rock paper scissors" with. Unfortunately, the bot uses quite a simple algorithm to play: he has a string s = s_1 s_2 ... s_{n} of length n where each letter is either R, S or P.
While initializing, the bot is choosing a starting index pos (1 ≤ pos ≤ n), and then it can play any number of rounds. In the first round, he chooses "Rock", "Scissors" or "Paper" based on the value of s_{pos}:
* if s_{pos} is equal to R the bot chooses "Rock";
* if s_{pos} is equal to S the bot chooses "Scissors";
* if s_{pos} is equal to P the bot chooses "Paper";
In the second round, the bot's choice is based on the value of s_{pos + 1}. In the third round — on s_{pos + 2} and so on. After s_n the bot returns to s_1 and continues his game.
You plan to play n rounds and you've already figured out the string s but still don't know what is the starting index pos. But since the bot's tactic is so boring, you've decided to find n choices to each round to maximize the average number of wins.
In other words, let's suggest your choices are c_1 c_2 ... c_n and if the bot starts from index pos then you'll win in win(pos) rounds. Find c_1 c_2 ... c_n such that (win(1) + win(2) + ... + win(n))/(n) is maximum possible.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per line. The first and only line of each test case contains string s = s_1 s_2 ... s_{n} (1 ≤ n ≤ 2 ⋅ 10^5; s_i ∈ \{R, S, P\}) — the string of the bot.
It's guaranteed that the total length of all strings in one test doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print n choices c_1 c_2 ... c_n to maximize the average number of wins. Print them in the same manner as the string s.
If there are multiple optimal answers, print any of them.
Example
Input
3
RRRR
RSP
S
Output
PPPP
RSP
R
Note
In the first test case, the bot (wherever it starts) will always choose "Rock", so we can always choose "Paper". So, in any case, we will win all n = 4 rounds, so the average is also equal to 4.
In the second test case:
* if bot will start from pos = 1, then (s_1, c_1) is draw, (s_2, c_2) is draw and (s_3, c_3) is draw, so win(1) = 0;
* if bot will start from pos = 2, then (s_2, c_1) is win, (s_3, c_2) is win and (s_1, c_3) is win, so win(2) = 3;
* if bot will start from pos = 3, then (s_3, c_1) is lose, (s_1, c_2) is lose and (s_2, c_3) is lose, so win(3) = 0;
The average is equal to (0 + 3 + 0)/(3) = 1 and it can be proven that it's the maximum possible average.
A picture from Wikipedia explaining "Rock paper scissors" game:
<image> | instruction | 0 | 66,609 | 19 | 133,218 |
Tags: greedy
Correct Solution:
```
keys = {"R": "P", "S": "R", "P": "S"}
for test in range(int(input())):
s = input()
counter = {s.count("R"): "R", s.count("S"): "S", s.count("P"): "P"}
m = max(counter.keys())
ans = keys[counter[m]] * len(s)
print(ans)
``` | output | 1 | 66,609 | 19 | 133,219 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently, you found a bot to play "Rock paper scissors" with. Unfortunately, the bot uses quite a simple algorithm to play: he has a string s = s_1 s_2 ... s_{n} of length n where each letter is either R, S or P.
While initializing, the bot is choosing a starting index pos (1 ≤ pos ≤ n), and then it can play any number of rounds. In the first round, he chooses "Rock", "Scissors" or "Paper" based on the value of s_{pos}:
* if s_{pos} is equal to R the bot chooses "Rock";
* if s_{pos} is equal to S the bot chooses "Scissors";
* if s_{pos} is equal to P the bot chooses "Paper";
In the second round, the bot's choice is based on the value of s_{pos + 1}. In the third round — on s_{pos + 2} and so on. After s_n the bot returns to s_1 and continues his game.
You plan to play n rounds and you've already figured out the string s but still don't know what is the starting index pos. But since the bot's tactic is so boring, you've decided to find n choices to each round to maximize the average number of wins.
In other words, let's suggest your choices are c_1 c_2 ... c_n and if the bot starts from index pos then you'll win in win(pos) rounds. Find c_1 c_2 ... c_n such that (win(1) + win(2) + ... + win(n))/(n) is maximum possible.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per line. The first and only line of each test case contains string s = s_1 s_2 ... s_{n} (1 ≤ n ≤ 2 ⋅ 10^5; s_i ∈ \{R, S, P\}) — the string of the bot.
It's guaranteed that the total length of all strings in one test doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print n choices c_1 c_2 ... c_n to maximize the average number of wins. Print them in the same manner as the string s.
If there are multiple optimal answers, print any of them.
Example
Input
3
RRRR
RSP
S
Output
PPPP
RSP
R
Note
In the first test case, the bot (wherever it starts) will always choose "Rock", so we can always choose "Paper". So, in any case, we will win all n = 4 rounds, so the average is also equal to 4.
In the second test case:
* if bot will start from pos = 1, then (s_1, c_1) is draw, (s_2, c_2) is draw and (s_3, c_3) is draw, so win(1) = 0;
* if bot will start from pos = 2, then (s_2, c_1) is win, (s_3, c_2) is win and (s_1, c_3) is win, so win(2) = 3;
* if bot will start from pos = 3, then (s_3, c_1) is lose, (s_1, c_2) is lose and (s_2, c_3) is lose, so win(3) = 0;
The average is equal to (0 + 3 + 0)/(3) = 1 and it can be proven that it's the maximum possible average.
A picture from Wikipedia explaining "Rock paper scissors" game:
<image> | instruction | 0 | 66,610 | 19 | 133,220 |
Tags: greedy
Correct Solution:
```
for testcase in range(int(input())):
s = input().strip()
cnt = {'R': 0, 'S': 0, 'P': 0}
for i in s:
cnt[i] += 1
_, w = max(zip(cnt.values(), cnt.keys()))
ans = ({'R': 'P', 'P': 'S', 'S': 'R'})[w] * len(s)
print(ans)
``` | output | 1 | 66,610 | 19 | 133,221 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently, you found a bot to play "Rock paper scissors" with. Unfortunately, the bot uses quite a simple algorithm to play: he has a string s = s_1 s_2 ... s_{n} of length n where each letter is either R, S or P.
While initializing, the bot is choosing a starting index pos (1 ≤ pos ≤ n), and then it can play any number of rounds. In the first round, he chooses "Rock", "Scissors" or "Paper" based on the value of s_{pos}:
* if s_{pos} is equal to R the bot chooses "Rock";
* if s_{pos} is equal to S the bot chooses "Scissors";
* if s_{pos} is equal to P the bot chooses "Paper";
In the second round, the bot's choice is based on the value of s_{pos + 1}. In the third round — on s_{pos + 2} and so on. After s_n the bot returns to s_1 and continues his game.
You plan to play n rounds and you've already figured out the string s but still don't know what is the starting index pos. But since the bot's tactic is so boring, you've decided to find n choices to each round to maximize the average number of wins.
In other words, let's suggest your choices are c_1 c_2 ... c_n and if the bot starts from index pos then you'll win in win(pos) rounds. Find c_1 c_2 ... c_n such that (win(1) + win(2) + ... + win(n))/(n) is maximum possible.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per line. The first and only line of each test case contains string s = s_1 s_2 ... s_{n} (1 ≤ n ≤ 2 ⋅ 10^5; s_i ∈ \{R, S, P\}) — the string of the bot.
It's guaranteed that the total length of all strings in one test doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print n choices c_1 c_2 ... c_n to maximize the average number of wins. Print them in the same manner as the string s.
If there are multiple optimal answers, print any of them.
Example
Input
3
RRRR
RSP
S
Output
PPPP
RSP
R
Note
In the first test case, the bot (wherever it starts) will always choose "Rock", so we can always choose "Paper". So, in any case, we will win all n = 4 rounds, so the average is also equal to 4.
In the second test case:
* if bot will start from pos = 1, then (s_1, c_1) is draw, (s_2, c_2) is draw and (s_3, c_3) is draw, so win(1) = 0;
* if bot will start from pos = 2, then (s_2, c_1) is win, (s_3, c_2) is win and (s_1, c_3) is win, so win(2) = 3;
* if bot will start from pos = 3, then (s_3, c_1) is lose, (s_1, c_2) is lose and (s_2, c_3) is lose, so win(3) = 0;
The average is equal to (0 + 3 + 0)/(3) = 1 and it can be proven that it's the maximum possible average.
A picture from Wikipedia explaining "Rock paper scissors" game:
<image> | instruction | 0 | 66,611 | 19 | 133,222 |
Tags: greedy
Correct Solution:
```
def solve():
lst = list(input())
n = len(lst)
r = 0
s = 0
p = 0
for i in lst:
if i == "R":
p += 1
if i == "S":
r += 1
if i == "P":
s += 1
q = max([r,s,p])
if r == q:
print("R" * n)
elif s == q:
print("S" * n)
else:
print("P" * n)
for i in range(int(input())):
solve()
``` | output | 1 | 66,611 | 19 | 133,223 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, you found a bot to play "Rock paper scissors" with. Unfortunately, the bot uses quite a simple algorithm to play: he has a string s = s_1 s_2 ... s_{n} of length n where each letter is either R, S or P.
While initializing, the bot is choosing a starting index pos (1 ≤ pos ≤ n), and then it can play any number of rounds. In the first round, he chooses "Rock", "Scissors" or "Paper" based on the value of s_{pos}:
* if s_{pos} is equal to R the bot chooses "Rock";
* if s_{pos} is equal to S the bot chooses "Scissors";
* if s_{pos} is equal to P the bot chooses "Paper";
In the second round, the bot's choice is based on the value of s_{pos + 1}. In the third round — on s_{pos + 2} and so on. After s_n the bot returns to s_1 and continues his game.
You plan to play n rounds and you've already figured out the string s but still don't know what is the starting index pos. But since the bot's tactic is so boring, you've decided to find n choices to each round to maximize the average number of wins.
In other words, let's suggest your choices are c_1 c_2 ... c_n and if the bot starts from index pos then you'll win in win(pos) rounds. Find c_1 c_2 ... c_n such that (win(1) + win(2) + ... + win(n))/(n) is maximum possible.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per line. The first and only line of each test case contains string s = s_1 s_2 ... s_{n} (1 ≤ n ≤ 2 ⋅ 10^5; s_i ∈ \{R, S, P\}) — the string of the bot.
It's guaranteed that the total length of all strings in one test doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print n choices c_1 c_2 ... c_n to maximize the average number of wins. Print them in the same manner as the string s.
If there are multiple optimal answers, print any of them.
Example
Input
3
RRRR
RSP
S
Output
PPPP
RSP
R
Note
In the first test case, the bot (wherever it starts) will always choose "Rock", so we can always choose "Paper". So, in any case, we will win all n = 4 rounds, so the average is also equal to 4.
In the second test case:
* if bot will start from pos = 1, then (s_1, c_1) is draw, (s_2, c_2) is draw and (s_3, c_3) is draw, so win(1) = 0;
* if bot will start from pos = 2, then (s_2, c_1) is win, (s_3, c_2) is win and (s_1, c_3) is win, so win(2) = 3;
* if bot will start from pos = 3, then (s_3, c_1) is lose, (s_1, c_2) is lose and (s_2, c_3) is lose, so win(3) = 0;
The average is equal to (0 + 3 + 0)/(3) = 1 and it can be proven that it's the maximum possible average.
A picture from Wikipedia explaining "Rock paper scissors" game:
<image>
Submitted Solution:
```
def find_ans(s):
q=[0]*3 # index 0 = paper , index 1 = gheychi , index 2 = rock
for i in s:
if i=='P' :
q[0]+=1
elif i=='S' :
q[1]+=1
else:
q[2]+=1
u=max(q)
if u==q[0]:
print('S'*len(s))
elif u==q[1] :
print('R'*len(s))
else:
print('P'*len(s))
for _ in range(int(input())):
s=input()
find_ans(s)
``` | instruction | 0 | 66,612 | 19 | 133,224 |
Yes | output | 1 | 66,612 | 19 | 133,225 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, you found a bot to play "Rock paper scissors" with. Unfortunately, the bot uses quite a simple algorithm to play: he has a string s = s_1 s_2 ... s_{n} of length n where each letter is either R, S or P.
While initializing, the bot is choosing a starting index pos (1 ≤ pos ≤ n), and then it can play any number of rounds. In the first round, he chooses "Rock", "Scissors" or "Paper" based on the value of s_{pos}:
* if s_{pos} is equal to R the bot chooses "Rock";
* if s_{pos} is equal to S the bot chooses "Scissors";
* if s_{pos} is equal to P the bot chooses "Paper";
In the second round, the bot's choice is based on the value of s_{pos + 1}. In the third round — on s_{pos + 2} and so on. After s_n the bot returns to s_1 and continues his game.
You plan to play n rounds and you've already figured out the string s but still don't know what is the starting index pos. But since the bot's tactic is so boring, you've decided to find n choices to each round to maximize the average number of wins.
In other words, let's suggest your choices are c_1 c_2 ... c_n and if the bot starts from index pos then you'll win in win(pos) rounds. Find c_1 c_2 ... c_n such that (win(1) + win(2) + ... + win(n))/(n) is maximum possible.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per line. The first and only line of each test case contains string s = s_1 s_2 ... s_{n} (1 ≤ n ≤ 2 ⋅ 10^5; s_i ∈ \{R, S, P\}) — the string of the bot.
It's guaranteed that the total length of all strings in one test doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print n choices c_1 c_2 ... c_n to maximize the average number of wins. Print them in the same manner as the string s.
If there are multiple optimal answers, print any of them.
Example
Input
3
RRRR
RSP
S
Output
PPPP
RSP
R
Note
In the first test case, the bot (wherever it starts) will always choose "Rock", so we can always choose "Paper". So, in any case, we will win all n = 4 rounds, so the average is also equal to 4.
In the second test case:
* if bot will start from pos = 1, then (s_1, c_1) is draw, (s_2, c_2) is draw and (s_3, c_3) is draw, so win(1) = 0;
* if bot will start from pos = 2, then (s_2, c_1) is win, (s_3, c_2) is win and (s_1, c_3) is win, so win(2) = 3;
* if bot will start from pos = 3, then (s_3, c_1) is lose, (s_1, c_2) is lose and (s_2, c_3) is lose, so win(3) = 0;
The average is equal to (0 + 3 + 0)/(3) = 1 and it can be proven that it's the maximum possible average.
A picture from Wikipedia explaining "Rock paper scissors" game:
<image>
Submitted Solution:
```
from collections import Counter,defaultdict,deque
#from heapq import *
#from itertools import *
#from operator import itemgetter
#from itertools import count, islice
#from functools import reduce
#alph = 'abcdefghijklmnopqrstuvwxyz'
#dirs = [[1,0],[0,1],[-1,0],[0,-1]]
#from math import factorial as fact
#a,b = [int(x) for x in input().split()]
#sarr = [x for x in input().strip().split()]
#import math
#from math import *
import sys
input=sys.stdin.readline
#sys.setrecursionlimit(2**30)
#MOD = 10**9+7
def solve():
#n = int(input())
s = input().strip()
c = Counter(s)
a = max(c.items(),key=lambda x: x[1])[0]
t = {'R':'P','P':'S','S':'R'}
print(t[a]*len(s))
tt = int(input())
for test in range(tt):
solve()
#
``` | instruction | 0 | 66,613 | 19 | 133,226 |
Yes | output | 1 | 66,613 | 19 | 133,227 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, you found a bot to play "Rock paper scissors" with. Unfortunately, the bot uses quite a simple algorithm to play: he has a string s = s_1 s_2 ... s_{n} of length n where each letter is either R, S or P.
While initializing, the bot is choosing a starting index pos (1 ≤ pos ≤ n), and then it can play any number of rounds. In the first round, he chooses "Rock", "Scissors" or "Paper" based on the value of s_{pos}:
* if s_{pos} is equal to R the bot chooses "Rock";
* if s_{pos} is equal to S the bot chooses "Scissors";
* if s_{pos} is equal to P the bot chooses "Paper";
In the second round, the bot's choice is based on the value of s_{pos + 1}. In the third round — on s_{pos + 2} and so on. After s_n the bot returns to s_1 and continues his game.
You plan to play n rounds and you've already figured out the string s but still don't know what is the starting index pos. But since the bot's tactic is so boring, you've decided to find n choices to each round to maximize the average number of wins.
In other words, let's suggest your choices are c_1 c_2 ... c_n and if the bot starts from index pos then you'll win in win(pos) rounds. Find c_1 c_2 ... c_n such that (win(1) + win(2) + ... + win(n))/(n) is maximum possible.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per line. The first and only line of each test case contains string s = s_1 s_2 ... s_{n} (1 ≤ n ≤ 2 ⋅ 10^5; s_i ∈ \{R, S, P\}) — the string of the bot.
It's guaranteed that the total length of all strings in one test doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print n choices c_1 c_2 ... c_n to maximize the average number of wins. Print them in the same manner as the string s.
If there are multiple optimal answers, print any of them.
Example
Input
3
RRRR
RSP
S
Output
PPPP
RSP
R
Note
In the first test case, the bot (wherever it starts) will always choose "Rock", so we can always choose "Paper". So, in any case, we will win all n = 4 rounds, so the average is also equal to 4.
In the second test case:
* if bot will start from pos = 1, then (s_1, c_1) is draw, (s_2, c_2) is draw and (s_3, c_3) is draw, so win(1) = 0;
* if bot will start from pos = 2, then (s_2, c_1) is win, (s_3, c_2) is win and (s_1, c_3) is win, so win(2) = 3;
* if bot will start from pos = 3, then (s_3, c_1) is lose, (s_1, c_2) is lose and (s_2, c_3) is lose, so win(3) = 0;
The average is equal to (0 + 3 + 0)/(3) = 1 and it can be proven that it's the maximum possible average.
A picture from Wikipedia explaining "Rock paper scissors" game:
<image>
Submitted Solution:
```
# from bisect import bisect_left
TC = int(input())
for tc in range(TC):
S = input()
P = 'RSP'
r = 0
s = 0
p = 0
for l in S:
if l == 'R':
r += 1
elif l == 'S':
s += 1
else:
p += 1
maxi = max(r,p,s)
if maxi == r:
result = 'P'*len(S)
elif maxi == p:
result = 'S'*len(S)
elif maxi == s:
result = 'R'*len(S)
else:
result = 'NR'
print(''.join(result))
``` | instruction | 0 | 66,614 | 19 | 133,228 |
Yes | output | 1 | 66,614 | 19 | 133,229 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, you found a bot to play "Rock paper scissors" with. Unfortunately, the bot uses quite a simple algorithm to play: he has a string s = s_1 s_2 ... s_{n} of length n where each letter is either R, S or P.
While initializing, the bot is choosing a starting index pos (1 ≤ pos ≤ n), and then it can play any number of rounds. In the first round, he chooses "Rock", "Scissors" or "Paper" based on the value of s_{pos}:
* if s_{pos} is equal to R the bot chooses "Rock";
* if s_{pos} is equal to S the bot chooses "Scissors";
* if s_{pos} is equal to P the bot chooses "Paper";
In the second round, the bot's choice is based on the value of s_{pos + 1}. In the third round — on s_{pos + 2} and so on. After s_n the bot returns to s_1 and continues his game.
You plan to play n rounds and you've already figured out the string s but still don't know what is the starting index pos. But since the bot's tactic is so boring, you've decided to find n choices to each round to maximize the average number of wins.
In other words, let's suggest your choices are c_1 c_2 ... c_n and if the bot starts from index pos then you'll win in win(pos) rounds. Find c_1 c_2 ... c_n such that (win(1) + win(2) + ... + win(n))/(n) is maximum possible.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per line. The first and only line of each test case contains string s = s_1 s_2 ... s_{n} (1 ≤ n ≤ 2 ⋅ 10^5; s_i ∈ \{R, S, P\}) — the string of the bot.
It's guaranteed that the total length of all strings in one test doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print n choices c_1 c_2 ... c_n to maximize the average number of wins. Print them in the same manner as the string s.
If there are multiple optimal answers, print any of them.
Example
Input
3
RRRR
RSP
S
Output
PPPP
RSP
R
Note
In the first test case, the bot (wherever it starts) will always choose "Rock", so we can always choose "Paper". So, in any case, we will win all n = 4 rounds, so the average is also equal to 4.
In the second test case:
* if bot will start from pos = 1, then (s_1, c_1) is draw, (s_2, c_2) is draw and (s_3, c_3) is draw, so win(1) = 0;
* if bot will start from pos = 2, then (s_2, c_1) is win, (s_3, c_2) is win and (s_1, c_3) is win, so win(2) = 3;
* if bot will start from pos = 3, then (s_3, c_1) is lose, (s_1, c_2) is lose and (s_2, c_3) is lose, so win(3) = 0;
The average is equal to (0 + 3 + 0)/(3) = 1 and it can be proven that it's the maximum possible average.
A picture from Wikipedia explaining "Rock paper scissors" game:
<image>
Submitted Solution:
```
"Codeforces Round #384 (Div. 2)"
"C. Vladik and fractions"
# y=int(input())
# a=y
# b=a+1
# c=y*b
# if y==1:
# print(-1)
# else:
# print(a,b,c)
"Technocup 2017 - Elimination Round 2"
"D. Sea Battle"
# n,a,b,k=map(int,input().split())
# s=list(input())
# n=len(s)
# lz=[]
# zeros=[]
# indexes=[]
# flage=0
# if s[0]=="0":
# lz.append(0)
# flage=1
# for i in range(1,n):
# if flage==1 and s[i]=="1":
# zeros.append(i-1-(lz[-1])+1)
# lz.append(i-1)
# flage=0
# elif flage==0 and s[i]=="0":
# lz.append(i)
# flage=1
# if s[-1]=="0":
# zeros.append(n-1-(lz[-1])+1)
# lz.append(n-1)
# min_no_spaces=(a-1)*b
# spaces_left=n-k
# l=len(lz)
# # print(lz)
# # print(zeros)
# shot=0
# for i in range(len(zeros)):
# h=i*2
# if min_no_spaces!=0:
# # print(min_no_spaces)
# if min_no_spaces>=zeros[i]:
# min_no_spaces-=(int(zeros[i]/b))*b
# elif min_no_spaces<zeros[i]:
# shot+=int((zeros[i]-min_no_spaces)/b)
# for j in range(int((zeros[i]-min_no_spaces)/b)):
# indexes.append(lz[h]+((j+1)*b))
# min_no_spaces=0
# elif min_no_spaces==0:
# # print(min_no_spaces)
# shot+=int(zeros[i]/b)
# for j in range(int(zeros[i]/b)):
# indexes.append(lz[h]+((j+1)*b))
# print(shot)
# for i in indexes:
# print(i," ",end="",sep="")
"Codeforces Round #268 (Div. 1)"
"A. 24 Game"
# y=int(input())
# a=[u for u in range(1,y+1)]
# if y>5:
# print("YES")
# print("6 * 4 = 24")
# print("5 - 3 = 2")
# print("2 - 2 = 0")
# print("1 * 0 = 0")
# for i in range(7,y+1):
# print(i,"* 0 = 0")
# print("24 + 0 = 24")
# elif y==5:
# print("YES")
# print("5 + 1 = 6")
# print("6 * 2 = 12")
# print("4 * 3 = 12")
# print("12 + 12 = 24")
# elif y==4:
# print("YES")
# print("1 * 2 = 2")
# print("3 * 4 = 12")
# print("2 * 12 = 24")
# else:
# print("NO")
"Educational Codeforces Round 91 (Rated for Div. 2)"
"B. Universal Solution"
y=int(input())
for i in range(y):
r=input()
s=""
R=S=P=0
for j in r:
if j=="R":
s+="P"
R+=1
elif j=="S":
s+="R"
S+=1
else:
s+="S"
P+=1
if P==R and S==R:
print("R"*len(r))
elif R>=S and R>=P:
print("P"*len(r))
elif S>=R and S>=P:
print("R"*len(r))
elif P>=S and P>=R:
print("S"*len(r))
``` | instruction | 0 | 66,615 | 19 | 133,230 |
Yes | output | 1 | 66,615 | 19 | 133,231 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, you found a bot to play "Rock paper scissors" with. Unfortunately, the bot uses quite a simple algorithm to play: he has a string s = s_1 s_2 ... s_{n} of length n where each letter is either R, S or P.
While initializing, the bot is choosing a starting index pos (1 ≤ pos ≤ n), and then it can play any number of rounds. In the first round, he chooses "Rock", "Scissors" or "Paper" based on the value of s_{pos}:
* if s_{pos} is equal to R the bot chooses "Rock";
* if s_{pos} is equal to S the bot chooses "Scissors";
* if s_{pos} is equal to P the bot chooses "Paper";
In the second round, the bot's choice is based on the value of s_{pos + 1}. In the third round — on s_{pos + 2} and so on. After s_n the bot returns to s_1 and continues his game.
You plan to play n rounds and you've already figured out the string s but still don't know what is the starting index pos. But since the bot's tactic is so boring, you've decided to find n choices to each round to maximize the average number of wins.
In other words, let's suggest your choices are c_1 c_2 ... c_n and if the bot starts from index pos then you'll win in win(pos) rounds. Find c_1 c_2 ... c_n such that (win(1) + win(2) + ... + win(n))/(n) is maximum possible.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per line. The first and only line of each test case contains string s = s_1 s_2 ... s_{n} (1 ≤ n ≤ 2 ⋅ 10^5; s_i ∈ \{R, S, P\}) — the string of the bot.
It's guaranteed that the total length of all strings in one test doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print n choices c_1 c_2 ... c_n to maximize the average number of wins. Print them in the same manner as the string s.
If there are multiple optimal answers, print any of them.
Example
Input
3
RRRR
RSP
S
Output
PPPP
RSP
R
Note
In the first test case, the bot (wherever it starts) will always choose "Rock", so we can always choose "Paper". So, in any case, we will win all n = 4 rounds, so the average is also equal to 4.
In the second test case:
* if bot will start from pos = 1, then (s_1, c_1) is draw, (s_2, c_2) is draw and (s_3, c_3) is draw, so win(1) = 0;
* if bot will start from pos = 2, then (s_2, c_1) is win, (s_3, c_2) is win and (s_1, c_3) is win, so win(2) = 3;
* if bot will start from pos = 3, then (s_3, c_1) is lose, (s_1, c_2) is lose and (s_2, c_3) is lose, so win(3) = 0;
The average is equal to (0 + 3 + 0)/(3) = 1 and it can be proven that it's the maximum possible average.
A picture from Wikipedia explaining "Rock paper scissors" game:
<image>
Submitted Solution:
```
cases = int(input())
for i in range(cases):
s = input()
ans = ''
c_rock = 0
c_scis = 0
c_pape = 0
l = len(s)
for a in s:
if a == 'R':
c_rock += 1
elif a == 'S':
c_scis += 1
else:
c_pape += 1
ma = max(c_rock,c_scis,c_pape)
if c_rock == ma:
ans += l*"R"
print(ans)
elif c_scis == ma:
ans += l*"S"
print(ans)
elif c_pape == ma:
ans += l*"P"
print(ans)
``` | instruction | 0 | 66,616 | 19 | 133,232 |
No | output | 1 | 66,616 | 19 | 133,233 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, you found a bot to play "Rock paper scissors" with. Unfortunately, the bot uses quite a simple algorithm to play: he has a string s = s_1 s_2 ... s_{n} of length n where each letter is either R, S or P.
While initializing, the bot is choosing a starting index pos (1 ≤ pos ≤ n), and then it can play any number of rounds. In the first round, he chooses "Rock", "Scissors" or "Paper" based on the value of s_{pos}:
* if s_{pos} is equal to R the bot chooses "Rock";
* if s_{pos} is equal to S the bot chooses "Scissors";
* if s_{pos} is equal to P the bot chooses "Paper";
In the second round, the bot's choice is based on the value of s_{pos + 1}. In the third round — on s_{pos + 2} and so on. After s_n the bot returns to s_1 and continues his game.
You plan to play n rounds and you've already figured out the string s but still don't know what is the starting index pos. But since the bot's tactic is so boring, you've decided to find n choices to each round to maximize the average number of wins.
In other words, let's suggest your choices are c_1 c_2 ... c_n and if the bot starts from index pos then you'll win in win(pos) rounds. Find c_1 c_2 ... c_n such that (win(1) + win(2) + ... + win(n))/(n) is maximum possible.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per line. The first and only line of each test case contains string s = s_1 s_2 ... s_{n} (1 ≤ n ≤ 2 ⋅ 10^5; s_i ∈ \{R, S, P\}) — the string of the bot.
It's guaranteed that the total length of all strings in one test doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print n choices c_1 c_2 ... c_n to maximize the average number of wins. Print them in the same manner as the string s.
If there are multiple optimal answers, print any of them.
Example
Input
3
RRRR
RSP
S
Output
PPPP
RSP
R
Note
In the first test case, the bot (wherever it starts) will always choose "Rock", so we can always choose "Paper". So, in any case, we will win all n = 4 rounds, so the average is also equal to 4.
In the second test case:
* if bot will start from pos = 1, then (s_1, c_1) is draw, (s_2, c_2) is draw and (s_3, c_3) is draw, so win(1) = 0;
* if bot will start from pos = 2, then (s_2, c_1) is win, (s_3, c_2) is win and (s_1, c_3) is win, so win(2) = 3;
* if bot will start from pos = 3, then (s_3, c_1) is lose, (s_1, c_2) is lose and (s_2, c_3) is lose, so win(3) = 0;
The average is equal to (0 + 3 + 0)/(3) = 1 and it can be proven that it's the maximum possible average.
A picture from Wikipedia explaining "Rock paper scissors" game:
<image>
Submitted Solution:
```
T = int(input())
for t in range(T):
s = input()
c = ""
for i in s:
if(i=="R"):
c = c+"P"
elif(i=="P"):
c = c+"S"
else:
c = c+"R"
print(c)
``` | instruction | 0 | 66,617 | 19 | 133,234 |
No | output | 1 | 66,617 | 19 | 133,235 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, you found a bot to play "Rock paper scissors" with. Unfortunately, the bot uses quite a simple algorithm to play: he has a string s = s_1 s_2 ... s_{n} of length n where each letter is either R, S or P.
While initializing, the bot is choosing a starting index pos (1 ≤ pos ≤ n), and then it can play any number of rounds. In the first round, he chooses "Rock", "Scissors" or "Paper" based on the value of s_{pos}:
* if s_{pos} is equal to R the bot chooses "Rock";
* if s_{pos} is equal to S the bot chooses "Scissors";
* if s_{pos} is equal to P the bot chooses "Paper";
In the second round, the bot's choice is based on the value of s_{pos + 1}. In the third round — on s_{pos + 2} and so on. After s_n the bot returns to s_1 and continues his game.
You plan to play n rounds and you've already figured out the string s but still don't know what is the starting index pos. But since the bot's tactic is so boring, you've decided to find n choices to each round to maximize the average number of wins.
In other words, let's suggest your choices are c_1 c_2 ... c_n and if the bot starts from index pos then you'll win in win(pos) rounds. Find c_1 c_2 ... c_n such that (win(1) + win(2) + ... + win(n))/(n) is maximum possible.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per line. The first and only line of each test case contains string s = s_1 s_2 ... s_{n} (1 ≤ n ≤ 2 ⋅ 10^5; s_i ∈ \{R, S, P\}) — the string of the bot.
It's guaranteed that the total length of all strings in one test doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print n choices c_1 c_2 ... c_n to maximize the average number of wins. Print them in the same manner as the string s.
If there are multiple optimal answers, print any of them.
Example
Input
3
RRRR
RSP
S
Output
PPPP
RSP
R
Note
In the first test case, the bot (wherever it starts) will always choose "Rock", so we can always choose "Paper". So, in any case, we will win all n = 4 rounds, so the average is also equal to 4.
In the second test case:
* if bot will start from pos = 1, then (s_1, c_1) is draw, (s_2, c_2) is draw and (s_3, c_3) is draw, so win(1) = 0;
* if bot will start from pos = 2, then (s_2, c_1) is win, (s_3, c_2) is win and (s_1, c_3) is win, so win(2) = 3;
* if bot will start from pos = 3, then (s_3, c_1) is lose, (s_1, c_2) is lose and (s_2, c_3) is lose, so win(3) = 0;
The average is equal to (0 + 3 + 0)/(3) = 1 and it can be proven that it's the maximum possible average.
A picture from Wikipedia explaining "Rock paper scissors" game:
<image>
Submitted Solution:
```
for i in"*"*int(input()):
r=""
for i in input():r+="R"*(i=="S")+"P"*(i=="R")+"S"*(i=="P")
print(r)
``` | instruction | 0 | 66,618 | 19 | 133,236 |
No | output | 1 | 66,618 | 19 | 133,237 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, you found a bot to play "Rock paper scissors" with. Unfortunately, the bot uses quite a simple algorithm to play: he has a string s = s_1 s_2 ... s_{n} of length n where each letter is either R, S or P.
While initializing, the bot is choosing a starting index pos (1 ≤ pos ≤ n), and then it can play any number of rounds. In the first round, he chooses "Rock", "Scissors" or "Paper" based on the value of s_{pos}:
* if s_{pos} is equal to R the bot chooses "Rock";
* if s_{pos} is equal to S the bot chooses "Scissors";
* if s_{pos} is equal to P the bot chooses "Paper";
In the second round, the bot's choice is based on the value of s_{pos + 1}. In the third round — on s_{pos + 2} and so on. After s_n the bot returns to s_1 and continues his game.
You plan to play n rounds and you've already figured out the string s but still don't know what is the starting index pos. But since the bot's tactic is so boring, you've decided to find n choices to each round to maximize the average number of wins.
In other words, let's suggest your choices are c_1 c_2 ... c_n and if the bot starts from index pos then you'll win in win(pos) rounds. Find c_1 c_2 ... c_n such that (win(1) + win(2) + ... + win(n))/(n) is maximum possible.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per line. The first and only line of each test case contains string s = s_1 s_2 ... s_{n} (1 ≤ n ≤ 2 ⋅ 10^5; s_i ∈ \{R, S, P\}) — the string of the bot.
It's guaranteed that the total length of all strings in one test doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print n choices c_1 c_2 ... c_n to maximize the average number of wins. Print them in the same manner as the string s.
If there are multiple optimal answers, print any of them.
Example
Input
3
RRRR
RSP
S
Output
PPPP
RSP
R
Note
In the first test case, the bot (wherever it starts) will always choose "Rock", so we can always choose "Paper". So, in any case, we will win all n = 4 rounds, so the average is also equal to 4.
In the second test case:
* if bot will start from pos = 1, then (s_1, c_1) is draw, (s_2, c_2) is draw and (s_3, c_3) is draw, so win(1) = 0;
* if bot will start from pos = 2, then (s_2, c_1) is win, (s_3, c_2) is win and (s_1, c_3) is win, so win(2) = 3;
* if bot will start from pos = 3, then (s_3, c_1) is lose, (s_1, c_2) is lose and (s_2, c_3) is lose, so win(3) = 0;
The average is equal to (0 + 3 + 0)/(3) = 1 and it can be proven that it's the maximum possible average.
A picture from Wikipedia explaining "Rock paper scissors" game:
<image>
Submitted Solution:
```
t=int(input())
for _ in range(t):
s=input()
n=len(s)
ans=''
d={}
for i in s:
if i not in d:
d[i]=1
else:
d[i]+=1
a=list(d.keys())
move=a[0]
for i in d:
if d[i]>d[move]:
move=i
ans=n*move
print(ans)
``` | instruction | 0 | 66,619 | 19 | 133,238 |
No | output | 1 | 66,619 | 19 | 133,239 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Twilight Sparkle was playing Ludo with her friends Rainbow Dash, Apple Jack and Flutter Shy. But she kept losing. Having returned to the castle, Twilight Sparkle became interested in the dice that were used in the game.
The dice has m faces: the first face of the dice contains a dot, the second one contains two dots, and so on, the m-th face contains m dots. Twilight Sparkle is sure that when the dice is tossed, each face appears with probability <image>. Also she knows that each toss is independent from others. Help her to calculate the expected maximum number of dots she could get after tossing the dice n times.
Input
A single line contains two integers m and n (1 ≤ m, n ≤ 105).
Output
Output a single real number corresponding to the expected maximum. The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 4.
Examples
Input
6 1
Output
3.500000000000
Input
6 3
Output
4.958333333333
Input
2 2
Output
1.750000000000
Note
Consider the third test example. If you've made two tosses:
1. You can get 1 in the first toss, and 2 in the second. Maximum equals to 2.
2. You can get 1 in the first toss, and 1 in the second. Maximum equals to 1.
3. You can get 2 in the first toss, and 1 in the second. Maximum equals to 2.
4. You can get 2 in the first toss, and 2 in the second. Maximum equals to 2.
The probability of each outcome is 0.25, that is expectation equals to:
<image>
You can read about expectation using the following link: http://en.wikipedia.org/wiki/Expected_value | instruction | 0 | 66,755 | 19 | 133,510 |
Tags: probabilities
Correct Solution:
```
m,n=map(int,input().split())
a=m**(-n)
for i in range(2,m+1):
a+=((i/m)**n-((i-1)/m)**n)*i
print(a)
``` | output | 1 | 66,755 | 19 | 133,511 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Twilight Sparkle was playing Ludo with her friends Rainbow Dash, Apple Jack and Flutter Shy. But she kept losing. Having returned to the castle, Twilight Sparkle became interested in the dice that were used in the game.
The dice has m faces: the first face of the dice contains a dot, the second one contains two dots, and so on, the m-th face contains m dots. Twilight Sparkle is sure that when the dice is tossed, each face appears with probability <image>. Also she knows that each toss is independent from others. Help her to calculate the expected maximum number of dots she could get after tossing the dice n times.
Input
A single line contains two integers m and n (1 ≤ m, n ≤ 105).
Output
Output a single real number corresponding to the expected maximum. The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 4.
Examples
Input
6 1
Output
3.500000000000
Input
6 3
Output
4.958333333333
Input
2 2
Output
1.750000000000
Note
Consider the third test example. If you've made two tosses:
1. You can get 1 in the first toss, and 2 in the second. Maximum equals to 2.
2. You can get 1 in the first toss, and 1 in the second. Maximum equals to 1.
3. You can get 2 in the first toss, and 1 in the second. Maximum equals to 2.
4. You can get 2 in the first toss, and 2 in the second. Maximum equals to 2.
The probability of each outcome is 0.25, that is expectation equals to:
<image>
You can read about expectation using the following link: http://en.wikipedia.org/wiki/Expected_value | instruction | 0 | 66,756 | 19 | 133,512 |
Tags: probabilities
Correct Solution:
```
m, n = str(input()).split()
n, m = int(n) , int(m)
sum = 0
for i in range(1, m+1):
sum += i * ( (i/m)**n - ((i-1)/m)**n )
print(sum)
``` | output | 1 | 66,756 | 19 | 133,513 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Twilight Sparkle was playing Ludo with her friends Rainbow Dash, Apple Jack and Flutter Shy. But she kept losing. Having returned to the castle, Twilight Sparkle became interested in the dice that were used in the game.
The dice has m faces: the first face of the dice contains a dot, the second one contains two dots, and so on, the m-th face contains m dots. Twilight Sparkle is sure that when the dice is tossed, each face appears with probability <image>. Also she knows that each toss is independent from others. Help her to calculate the expected maximum number of dots she could get after tossing the dice n times.
Input
A single line contains two integers m and n (1 ≤ m, n ≤ 105).
Output
Output a single real number corresponding to the expected maximum. The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 4.
Examples
Input
6 1
Output
3.500000000000
Input
6 3
Output
4.958333333333
Input
2 2
Output
1.750000000000
Note
Consider the third test example. If you've made two tosses:
1. You can get 1 in the first toss, and 2 in the second. Maximum equals to 2.
2. You can get 1 in the first toss, and 1 in the second. Maximum equals to 1.
3. You can get 2 in the first toss, and 1 in the second. Maximum equals to 2.
4. You can get 2 in the first toss, and 2 in the second. Maximum equals to 2.
The probability of each outcome is 0.25, that is expectation equals to:
<image>
You can read about expectation using the following link: http://en.wikipedia.org/wiki/Expected_value | instruction | 0 | 66,757 | 19 | 133,514 |
Tags: probabilities
Correct Solution:
```
m,n=map(int,input().split())
ans=0
l1=[0]*(m+1)
if m>1:
l1[0]= (1/m)**n
x=l1[0]
for i in range(1,m+1):
if i==1:
ans+=l1[0]*i
else :
l1[i-1]= (i/m)**n-x
x+=l1[i-1]
ans+= l1[i-1] * i
print(ans)
else :
print(1)
``` | output | 1 | 66,757 | 19 | 133,515 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Twilight Sparkle was playing Ludo with her friends Rainbow Dash, Apple Jack and Flutter Shy. But she kept losing. Having returned to the castle, Twilight Sparkle became interested in the dice that were used in the game.
The dice has m faces: the first face of the dice contains a dot, the second one contains two dots, and so on, the m-th face contains m dots. Twilight Sparkle is sure that when the dice is tossed, each face appears with probability <image>. Also she knows that each toss is independent from others. Help her to calculate the expected maximum number of dots she could get after tossing the dice n times.
Input
A single line contains two integers m and n (1 ≤ m, n ≤ 105).
Output
Output a single real number corresponding to the expected maximum. The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 4.
Examples
Input
6 1
Output
3.500000000000
Input
6 3
Output
4.958333333333
Input
2 2
Output
1.750000000000
Note
Consider the third test example. If you've made two tosses:
1. You can get 1 in the first toss, and 2 in the second. Maximum equals to 2.
2. You can get 1 in the first toss, and 1 in the second. Maximum equals to 1.
3. You can get 2 in the first toss, and 1 in the second. Maximum equals to 2.
4. You can get 2 in the first toss, and 2 in the second. Maximum equals to 2.
The probability of each outcome is 0.25, that is expectation equals to:
<image>
You can read about expectation using the following link: http://en.wikipedia.org/wiki/Expected_value | instruction | 0 | 66,758 | 19 | 133,516 |
Tags: probabilities
Correct Solution:
```
m,n=map(int,input().split())
cp=[0]*(m+1)
for i in range(1,m+1):
cp[i]=(i/m)**n
p=[0]*(m+1)
for i in range(1,m+1):
p[i]=cp[i]-cp[i-1]
ans=0
for i in range(1,m+1):
ans+=i*p[i]
print(ans)
``` | output | 1 | 66,758 | 19 | 133,517 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Twilight Sparkle was playing Ludo with her friends Rainbow Dash, Apple Jack and Flutter Shy. But she kept losing. Having returned to the castle, Twilight Sparkle became interested in the dice that were used in the game.
The dice has m faces: the first face of the dice contains a dot, the second one contains two dots, and so on, the m-th face contains m dots. Twilight Sparkle is sure that when the dice is tossed, each face appears with probability <image>. Also she knows that each toss is independent from others. Help her to calculate the expected maximum number of dots she could get after tossing the dice n times.
Input
A single line contains two integers m and n (1 ≤ m, n ≤ 105).
Output
Output a single real number corresponding to the expected maximum. The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 4.
Examples
Input
6 1
Output
3.500000000000
Input
6 3
Output
4.958333333333
Input
2 2
Output
1.750000000000
Note
Consider the third test example. If you've made two tosses:
1. You can get 1 in the first toss, and 2 in the second. Maximum equals to 2.
2. You can get 1 in the first toss, and 1 in the second. Maximum equals to 1.
3. You can get 2 in the first toss, and 1 in the second. Maximum equals to 2.
4. You can get 2 in the first toss, and 2 in the second. Maximum equals to 2.
The probability of each outcome is 0.25, that is expectation equals to:
<image>
You can read about expectation using the following link: http://en.wikipedia.org/wiki/Expected_value | instruction | 0 | 66,759 | 19 | 133,518 |
Tags: probabilities
Correct Solution:
```
m, n = [int(x) for x in input().split()]
print(sum([i *((i/m) ** n - ((i-1)/m) ** n) for i in range(1, m + 1)]))
``` | output | 1 | 66,759 | 19 | 133,519 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Twilight Sparkle was playing Ludo with her friends Rainbow Dash, Apple Jack and Flutter Shy. But she kept losing. Having returned to the castle, Twilight Sparkle became interested in the dice that were used in the game.
The dice has m faces: the first face of the dice contains a dot, the second one contains two dots, and so on, the m-th face contains m dots. Twilight Sparkle is sure that when the dice is tossed, each face appears with probability <image>. Also she knows that each toss is independent from others. Help her to calculate the expected maximum number of dots she could get after tossing the dice n times.
Input
A single line contains two integers m and n (1 ≤ m, n ≤ 105).
Output
Output a single real number corresponding to the expected maximum. The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 4.
Examples
Input
6 1
Output
3.500000000000
Input
6 3
Output
4.958333333333
Input
2 2
Output
1.750000000000
Note
Consider the third test example. If you've made two tosses:
1. You can get 1 in the first toss, and 2 in the second. Maximum equals to 2.
2. You can get 1 in the first toss, and 1 in the second. Maximum equals to 1.
3. You can get 2 in the first toss, and 1 in the second. Maximum equals to 2.
4. You can get 2 in the first toss, and 2 in the second. Maximum equals to 2.
The probability of each outcome is 0.25, that is expectation equals to:
<image>
You can read about expectation using the following link: http://en.wikipedia.org/wiki/Expected_value | instruction | 0 | 66,760 | 19 | 133,520 |
Tags: probabilities
Correct Solution:
```
n, m = map(int, input().split(' '))
ans = n
for i in range(1, n):
num = (n-i)/n
res = pow(num, m)
ans -= res
print(ans)
``` | output | 1 | 66,760 | 19 | 133,521 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Twilight Sparkle was playing Ludo with her friends Rainbow Dash, Apple Jack and Flutter Shy. But she kept losing. Having returned to the castle, Twilight Sparkle became interested in the dice that were used in the game.
The dice has m faces: the first face of the dice contains a dot, the second one contains two dots, and so on, the m-th face contains m dots. Twilight Sparkle is sure that when the dice is tossed, each face appears with probability <image>. Also she knows that each toss is independent from others. Help her to calculate the expected maximum number of dots she could get after tossing the dice n times.
Input
A single line contains two integers m and n (1 ≤ m, n ≤ 105).
Output
Output a single real number corresponding to the expected maximum. The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 4.
Examples
Input
6 1
Output
3.500000000000
Input
6 3
Output
4.958333333333
Input
2 2
Output
1.750000000000
Note
Consider the third test example. If you've made two tosses:
1. You can get 1 in the first toss, and 2 in the second. Maximum equals to 2.
2. You can get 1 in the first toss, and 1 in the second. Maximum equals to 1.
3. You can get 2 in the first toss, and 1 in the second. Maximum equals to 2.
4. You can get 2 in the first toss, and 2 in the second. Maximum equals to 2.
The probability of each outcome is 0.25, that is expectation equals to:
<image>
You can read about expectation using the following link: http://en.wikipedia.org/wiki/Expected_value | instruction | 0 | 66,761 | 19 | 133,522 |
Tags: probabilities
Correct Solution:
```
m, n = map(int, input().split())
ans = m
for i in range(m):
ans = ans - (i / m) ** n
print(ans)
``` | output | 1 | 66,761 | 19 | 133,523 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Twilight Sparkle was playing Ludo with her friends Rainbow Dash, Apple Jack and Flutter Shy. But she kept losing. Having returned to the castle, Twilight Sparkle became interested in the dice that were used in the game.
The dice has m faces: the first face of the dice contains a dot, the second one contains two dots, and so on, the m-th face contains m dots. Twilight Sparkle is sure that when the dice is tossed, each face appears with probability <image>. Also she knows that each toss is independent from others. Help her to calculate the expected maximum number of dots she could get after tossing the dice n times.
Input
A single line contains two integers m and n (1 ≤ m, n ≤ 105).
Output
Output a single real number corresponding to the expected maximum. The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 4.
Examples
Input
6 1
Output
3.500000000000
Input
6 3
Output
4.958333333333
Input
2 2
Output
1.750000000000
Note
Consider the third test example. If you've made two tosses:
1. You can get 1 in the first toss, and 2 in the second. Maximum equals to 2.
2. You can get 1 in the first toss, and 1 in the second. Maximum equals to 1.
3. You can get 2 in the first toss, and 1 in the second. Maximum equals to 2.
4. You can get 2 in the first toss, and 2 in the second. Maximum equals to 2.
The probability of each outcome is 0.25, that is expectation equals to:
<image>
You can read about expectation using the following link: http://en.wikipedia.org/wiki/Expected_value | instruction | 0 | 66,762 | 19 | 133,524 |
Tags: probabilities
Correct Solution:
```
m,n= map(int,input().split())
bs = m
for i in range(1,m):
bs-= (i/m)**n
print(bs)
``` | output | 1 | 66,762 | 19 | 133,525 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Twilight Sparkle was playing Ludo with her friends Rainbow Dash, Apple Jack and Flutter Shy. But she kept losing. Having returned to the castle, Twilight Sparkle became interested in the dice that were used in the game.
The dice has m faces: the first face of the dice contains a dot, the second one contains two dots, and so on, the m-th face contains m dots. Twilight Sparkle is sure that when the dice is tossed, each face appears with probability <image>. Also she knows that each toss is independent from others. Help her to calculate the expected maximum number of dots she could get after tossing the dice n times.
Input
A single line contains two integers m and n (1 ≤ m, n ≤ 105).
Output
Output a single real number corresponding to the expected maximum. The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 4.
Examples
Input
6 1
Output
3.500000000000
Input
6 3
Output
4.958333333333
Input
2 2
Output
1.750000000000
Note
Consider the third test example. If you've made two tosses:
1. You can get 1 in the first toss, and 2 in the second. Maximum equals to 2.
2. You can get 1 in the first toss, and 1 in the second. Maximum equals to 1.
3. You can get 2 in the first toss, and 1 in the second. Maximum equals to 2.
4. You can get 2 in the first toss, and 2 in the second. Maximum equals to 2.
The probability of each outcome is 0.25, that is expectation equals to:
<image>
You can read about expectation using the following link: http://en.wikipedia.org/wiki/Expected_value
Submitted Solution:
```
m, n = map(int, input().split())
print(sum([i * ((i / m) ** n - ((i - 1) / m) ** n) for i in range(1, m + 1)]))
``` | instruction | 0 | 66,763 | 19 | 133,526 |
Yes | output | 1 | 66,763 | 19 | 133,527 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Twilight Sparkle was playing Ludo with her friends Rainbow Dash, Apple Jack and Flutter Shy. But she kept losing. Having returned to the castle, Twilight Sparkle became interested in the dice that were used in the game.
The dice has m faces: the first face of the dice contains a dot, the second one contains two dots, and so on, the m-th face contains m dots. Twilight Sparkle is sure that when the dice is tossed, each face appears with probability <image>. Also she knows that each toss is independent from others. Help her to calculate the expected maximum number of dots she could get after tossing the dice n times.
Input
A single line contains two integers m and n (1 ≤ m, n ≤ 105).
Output
Output a single real number corresponding to the expected maximum. The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 4.
Examples
Input
6 1
Output
3.500000000000
Input
6 3
Output
4.958333333333
Input
2 2
Output
1.750000000000
Note
Consider the third test example. If you've made two tosses:
1. You can get 1 in the first toss, and 2 in the second. Maximum equals to 2.
2. You can get 1 in the first toss, and 1 in the second. Maximum equals to 1.
3. You can get 2 in the first toss, and 1 in the second. Maximum equals to 2.
4. You can get 2 in the first toss, and 2 in the second. Maximum equals to 2.
The probability of each outcome is 0.25, that is expectation equals to:
<image>
You can read about expectation using the following link: http://en.wikipedia.org/wiki/Expected_value
Submitted Solution:
```
m, n = map(int, input().split())
pvar = 0
ans = 0
for i in range(1, m + 1):
var = (i / m) ** n
ans += i * (var - pvar)
pvar = var
print(ans)
``` | instruction | 0 | 66,764 | 19 | 133,528 |
Yes | output | 1 | 66,764 | 19 | 133,529 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.