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 |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Famous Brazil city Rio de Janeiro holds a tennis tournament and Ostap Bender doesn't want to miss this event. There will be n players participating, and the tournament will follow knockout rules from the very first game. That means, that if someone loses a game he leaves the tournament immediately.
Organizers are still arranging tournament grid (i.e. the order games will happen and who is going to play with whom) but they have already fixed one rule: two players can play against each other only if the number of games one of them has already played differs by no more than one from the number of games the other one has already played. Of course, both players had to win all their games in order to continue participating in the tournament.
Tournament hasn't started yet so the audience is a bit bored. Ostap decided to find out what is the maximum number of games the winner of the tournament can take part in (assuming the rule above is used). However, it is unlikely he can deal with this problem without your help.
Input
The only line of the input contains a single integer n (2 β€ n β€ 1018) β the number of players to participate in the tournament.
Output
Print the maximum number of games in which the winner of the tournament can take part.
Examples
Input
2
Output
1
Input
3
Output
2
Input
4
Output
2
Input
10
Output
4
Note
In all samples we consider that player number 1 is the winner.
In the first sample, there would be only one game so the answer is 1.
In the second sample, player 1 can consequently beat players 2 and 3.
In the third sample, player 1 can't play with each other player as after he plays with players 2 and 3 he can't play against player 4, as he has 0 games played, while player 1 already played 2. Thus, the answer is 2 and to achieve we make pairs (1, 2) and (3, 4) and then clash the winners. | instruction | 0 | 94,886 | 19 | 189,772 |
Tags: combinatorics, constructive algorithms, greedy, math
Correct Solution:
```
import sys,os,io
import math,bisect,operator
inf,mod = float('inf'),10**9+7
# sys.setrecursionlimit(10 ** 6)
from itertools import groupby,accumulate
from heapq import heapify,heappop,heappush
from collections import deque,Counter,defaultdict
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
Neo = lambda : list(map(int,input().split()))
# test, = Neo()
n, = Neo()
t = 0
k1,k2 = 2,1
while k1 <= n:
t += 1
k1,k2 = k1+k2,k1
print(t)
``` | output | 1 | 94,886 | 19 | 189,773 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Famous Brazil city Rio de Janeiro holds a tennis tournament and Ostap Bender doesn't want to miss this event. There will be n players participating, and the tournament will follow knockout rules from the very first game. That means, that if someone loses a game he leaves the tournament immediately.
Organizers are still arranging tournament grid (i.e. the order games will happen and who is going to play with whom) but they have already fixed one rule: two players can play against each other only if the number of games one of them has already played differs by no more than one from the number of games the other one has already played. Of course, both players had to win all their games in order to continue participating in the tournament.
Tournament hasn't started yet so the audience is a bit bored. Ostap decided to find out what is the maximum number of games the winner of the tournament can take part in (assuming the rule above is used). However, it is unlikely he can deal with this problem without your help.
Input
The only line of the input contains a single integer n (2 β€ n β€ 1018) β the number of players to participate in the tournament.
Output
Print the maximum number of games in which the winner of the tournament can take part.
Examples
Input
2
Output
1
Input
3
Output
2
Input
4
Output
2
Input
10
Output
4
Note
In all samples we consider that player number 1 is the winner.
In the first sample, there would be only one game so the answer is 1.
In the second sample, player 1 can consequently beat players 2 and 3.
In the third sample, player 1 can't play with each other player as after he plays with players 2 and 3 he can't play against player 4, as he has 0 games played, while player 1 already played 2. Thus, the answer is 2 and to achieve we make pairs (1, 2) and (3, 4) and then clash the winners. | instruction | 0 | 94,887 | 19 | 189,774 |
Tags: combinatorics, constructive algorithms, greedy, math
Correct Solution:
```
n=int(input())
fib=1
last=1
i=0
while True:
i+=1
fib=fib+last
last=fib-last
if fib>n:
print(i-1)
exit(0)
#Π§ΡΠΎ Ρ codeforces?
``` | output | 1 | 94,887 | 19 | 189,775 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Famous Brazil city Rio de Janeiro holds a tennis tournament and Ostap Bender doesn't want to miss this event. There will be n players participating, and the tournament will follow knockout rules from the very first game. That means, that if someone loses a game he leaves the tournament immediately.
Organizers are still arranging tournament grid (i.e. the order games will happen and who is going to play with whom) but they have already fixed one rule: two players can play against each other only if the number of games one of them has already played differs by no more than one from the number of games the other one has already played. Of course, both players had to win all their games in order to continue participating in the tournament.
Tournament hasn't started yet so the audience is a bit bored. Ostap decided to find out what is the maximum number of games the winner of the tournament can take part in (assuming the rule above is used). However, it is unlikely he can deal with this problem without your help.
Input
The only line of the input contains a single integer n (2 β€ n β€ 1018) β the number of players to participate in the tournament.
Output
Print the maximum number of games in which the winner of the tournament can take part.
Examples
Input
2
Output
1
Input
3
Output
2
Input
4
Output
2
Input
10
Output
4
Note
In all samples we consider that player number 1 is the winner.
In the first sample, there would be only one game so the answer is 1.
In the second sample, player 1 can consequently beat players 2 and 3.
In the third sample, player 1 can't play with each other player as after he plays with players 2 and 3 he can't play against player 4, as he has 0 games played, while player 1 already played 2. Thus, the answer is 2 and to achieve we make pairs (1, 2) and (3, 4) and then clash the winners. | instruction | 0 | 94,888 | 19 | 189,776 |
Tags: combinatorics, constructive algorithms, greedy, math
Correct Solution:
```
n=int(input())
a,b,c=2,1,0
while a<=n:
a,b=a+b,a
c+=1
print(c)
``` | output | 1 | 94,888 | 19 | 189,777 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Famous Brazil city Rio de Janeiro holds a tennis tournament and Ostap Bender doesn't want to miss this event. There will be n players participating, and the tournament will follow knockout rules from the very first game. That means, that if someone loses a game he leaves the tournament immediately.
Organizers are still arranging tournament grid (i.e. the order games will happen and who is going to play with whom) but they have already fixed one rule: two players can play against each other only if the number of games one of them has already played differs by no more than one from the number of games the other one has already played. Of course, both players had to win all their games in order to continue participating in the tournament.
Tournament hasn't started yet so the audience is a bit bored. Ostap decided to find out what is the maximum number of games the winner of the tournament can take part in (assuming the rule above is used). However, it is unlikely he can deal with this problem without your help.
Input
The only line of the input contains a single integer n (2 β€ n β€ 1018) β the number of players to participate in the tournament.
Output
Print the maximum number of games in which the winner of the tournament can take part.
Examples
Input
2
Output
1
Input
3
Output
2
Input
4
Output
2
Input
10
Output
4
Note
In all samples we consider that player number 1 is the winner.
In the first sample, there would be only one game so the answer is 1.
In the second sample, player 1 can consequently beat players 2 and 3.
In the third sample, player 1 can't play with each other player as after he plays with players 2 and 3 he can't play against player 4, as he has 0 games played, while player 1 already played 2. Thus, the answer is 2 and to achieve we make pairs (1, 2) and (3, 4) and then clash the winners. | instruction | 0 | 94,889 | 19 | 189,778 |
Tags: combinatorics, constructive algorithms, greedy, math
Correct Solution:
```
n=int(input())
fib=1
last=1
i=0
while True:
i+=1
fib=fib+last
last=fib-last
if fib>n:
print(i-1)
exit(0)
``` | output | 1 | 94,889 | 19 | 189,779 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Allen and Bessie are playing a simple number game. They both know a function f: \{0, 1\}^n β R, i. e. the function takes n binary arguments and returns a real value. At the start of the game, the variables x_1, x_2, ..., x_n are all set to -1. Each round, with equal probability, one of Allen or Bessie gets to make a move. A move consists of picking an i such that x_i = -1 and either setting x_i β 0 or x_i β 1.
After n rounds all variables are set, and the game value resolves to f(x_1, x_2, ..., x_n). Allen wants to maximize the game value, and Bessie wants to minimize it.
Your goal is to help Allen and Bessie find the expected game value! They will play r+1 times though, so between each game, exactly one value of f changes. In other words, between rounds i and i+1 for 1 β€ i β€ r, f(z_1, ..., z_n) β g_i for some (z_1, ..., z_n) β \{0, 1\}^n. You are to find the expected game value in the beginning and after each change.
Input
The first line contains two integers n and r (1 β€ n β€ 18, 0 β€ r β€ 2^{18}).
The next line contains 2^n integers c_0, c_1, ..., c_{2^n-1} (0 β€ c_i β€ 10^9), denoting the initial values of f. More specifically, f(x_0, x_1, ..., x_{n-1}) = c_x, if x = \overline{x_{n-1} β¦ x_0} in binary.
Each of the next r lines contains two integers z and g (0 β€ z β€ 2^n - 1, 0 β€ g β€ 10^9). If z = \overline{z_{n-1} ... z_0} in binary, then this means to set f(z_0, ..., z_{n-1}) β g.
Output
Print r+1 lines, the i-th of which denotes the value of the game f during the i-th round. Your answer must have absolute or relative error within 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac{|a - b|}{max{(1, |b|)}} β€ 10^{-6}.
Examples
Input
2 2
0 1 2 3
2 5
0 4
Output
1.500000
2.250000
3.250000
Input
1 0
2 3
Output
2.500000
Input
2 0
1 1 1 1
Output
1.000000
Note
Consider the second test case. If Allen goes first, he will set x_1 β 1, so the final value will be 3. If Bessie goes first, then she will set x_1 β 0 so the final value will be 2. Thus the answer is 2.5.
In the third test case, the game value will always be 1 regardless of Allen and Bessie's play. | instruction | 0 | 95,022 | 19 | 190,044 |
Tags: math
Correct Solution:
```
n, r = [int(x) for x in input().split()]
n = 2 ** n
xs = [int(x) for x in input().split()]
s = sum(xs)
res = [0 for _ in range(r+1)]
for i in range(r):
res[i] = s / n
i, val = [int(x) for x in input().split()]
s += val - xs[i]
xs[i] = val
res[r] = s / n
print("\n".join(map(str, res)))
``` | output | 1 | 95,022 | 19 | 190,045 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Allen and Bessie are playing a simple number game. They both know a function f: \{0, 1\}^n β R, i. e. the function takes n binary arguments and returns a real value. At the start of the game, the variables x_1, x_2, ..., x_n are all set to -1. Each round, with equal probability, one of Allen or Bessie gets to make a move. A move consists of picking an i such that x_i = -1 and either setting x_i β 0 or x_i β 1.
After n rounds all variables are set, and the game value resolves to f(x_1, x_2, ..., x_n). Allen wants to maximize the game value, and Bessie wants to minimize it.
Your goal is to help Allen and Bessie find the expected game value! They will play r+1 times though, so between each game, exactly one value of f changes. In other words, between rounds i and i+1 for 1 β€ i β€ r, f(z_1, ..., z_n) β g_i for some (z_1, ..., z_n) β \{0, 1\}^n. You are to find the expected game value in the beginning and after each change.
Input
The first line contains two integers n and r (1 β€ n β€ 18, 0 β€ r β€ 2^{18}).
The next line contains 2^n integers c_0, c_1, ..., c_{2^n-1} (0 β€ c_i β€ 10^9), denoting the initial values of f. More specifically, f(x_0, x_1, ..., x_{n-1}) = c_x, if x = \overline{x_{n-1} β¦ x_0} in binary.
Each of the next r lines contains two integers z and g (0 β€ z β€ 2^n - 1, 0 β€ g β€ 10^9). If z = \overline{z_{n-1} ... z_0} in binary, then this means to set f(z_0, ..., z_{n-1}) β g.
Output
Print r+1 lines, the i-th of which denotes the value of the game f during the i-th round. Your answer must have absolute or relative error within 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac{|a - b|}{max{(1, |b|)}} β€ 10^{-6}.
Examples
Input
2 2
0 1 2 3
2 5
0 4
Output
1.500000
2.250000
3.250000
Input
1 0
2 3
Output
2.500000
Input
2 0
1 1 1 1
Output
1.000000
Note
Consider the second test case. If Allen goes first, he will set x_1 β 1, so the final value will be 3. If Bessie goes first, then she will set x_1 β 0 so the final value will be 2. Thus the answer is 2.5.
In the third test case, the game value will always be 1 regardless of Allen and Bessie's play. | instruction | 0 | 95,023 | 19 | 190,046 |
Tags: math
Correct Solution:
```
R = lambda:list(map(int,input().split()))
sum1 = 0
p1 = 1
a = [0]*263000
b = a
n,r = R()
p1 = 2**n
a = R()
sum1 = sum(a)
p2 = sum1 / p1
for i in range(r):
z,g=R()
sum1 = sum1 - a[z] + g
a[z] = g
b[i] = sum1/p1
print(p2)
for i in range(r):
print(b[i])
``` | output | 1 | 95,023 | 19 | 190,047 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Allen and Bessie are playing a simple number game. They both know a function f: \{0, 1\}^n β R, i. e. the function takes n binary arguments and returns a real value. At the start of the game, the variables x_1, x_2, ..., x_n are all set to -1. Each round, with equal probability, one of Allen or Bessie gets to make a move. A move consists of picking an i such that x_i = -1 and either setting x_i β 0 or x_i β 1.
After n rounds all variables are set, and the game value resolves to f(x_1, x_2, ..., x_n). Allen wants to maximize the game value, and Bessie wants to minimize it.
Your goal is to help Allen and Bessie find the expected game value! They will play r+1 times though, so between each game, exactly one value of f changes. In other words, between rounds i and i+1 for 1 β€ i β€ r, f(z_1, ..., z_n) β g_i for some (z_1, ..., z_n) β \{0, 1\}^n. You are to find the expected game value in the beginning and after each change.
Input
The first line contains two integers n and r (1 β€ n β€ 18, 0 β€ r β€ 2^{18}).
The next line contains 2^n integers c_0, c_1, ..., c_{2^n-1} (0 β€ c_i β€ 10^9), denoting the initial values of f. More specifically, f(x_0, x_1, ..., x_{n-1}) = c_x, if x = \overline{x_{n-1} β¦ x_0} in binary.
Each of the next r lines contains two integers z and g (0 β€ z β€ 2^n - 1, 0 β€ g β€ 10^9). If z = \overline{z_{n-1} ... z_0} in binary, then this means to set f(z_0, ..., z_{n-1}) β g.
Output
Print r+1 lines, the i-th of which denotes the value of the game f during the i-th round. Your answer must have absolute or relative error within 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac{|a - b|}{max{(1, |b|)}} β€ 10^{-6}.
Examples
Input
2 2
0 1 2 3
2 5
0 4
Output
1.500000
2.250000
3.250000
Input
1 0
2 3
Output
2.500000
Input
2 0
1 1 1 1
Output
1.000000
Note
Consider the second test case. If Allen goes first, he will set x_1 β 1, so the final value will be 3. If Bessie goes first, then she will set x_1 β 0 so the final value will be 2. Thus the answer is 2.5.
In the third test case, the game value will always be 1 regardless of Allen and Bessie's play. | instruction | 0 | 95,024 | 19 | 190,048 |
Tags: math
Correct Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import time
(n, r) = (int(i) for i in input().split())
c = [int(i) for i in input().split()]
start = time.time()
s = sum(c)
n2 = 2**n
ans = [s/n2]
for i in range(r):
(k, new) = (int(i) for i in input().split())
s += new - c[k]
c[k] = new
ans.append(s/n2)
for i in range(len(ans)):
print(ans[i])
finish = time.time()
#print(finish - start)
``` | output | 1 | 95,024 | 19 | 190,049 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Allen and Bessie are playing a simple number game. They both know a function f: \{0, 1\}^n β R, i. e. the function takes n binary arguments and returns a real value. At the start of the game, the variables x_1, x_2, ..., x_n are all set to -1. Each round, with equal probability, one of Allen or Bessie gets to make a move. A move consists of picking an i such that x_i = -1 and either setting x_i β 0 or x_i β 1.
After n rounds all variables are set, and the game value resolves to f(x_1, x_2, ..., x_n). Allen wants to maximize the game value, and Bessie wants to minimize it.
Your goal is to help Allen and Bessie find the expected game value! They will play r+1 times though, so between each game, exactly one value of f changes. In other words, between rounds i and i+1 for 1 β€ i β€ r, f(z_1, ..., z_n) β g_i for some (z_1, ..., z_n) β \{0, 1\}^n. You are to find the expected game value in the beginning and after each change.
Input
The first line contains two integers n and r (1 β€ n β€ 18, 0 β€ r β€ 2^{18}).
The next line contains 2^n integers c_0, c_1, ..., c_{2^n-1} (0 β€ c_i β€ 10^9), denoting the initial values of f. More specifically, f(x_0, x_1, ..., x_{n-1}) = c_x, if x = \overline{x_{n-1} β¦ x_0} in binary.
Each of the next r lines contains two integers z and g (0 β€ z β€ 2^n - 1, 0 β€ g β€ 10^9). If z = \overline{z_{n-1} ... z_0} in binary, then this means to set f(z_0, ..., z_{n-1}) β g.
Output
Print r+1 lines, the i-th of which denotes the value of the game f during the i-th round. Your answer must have absolute or relative error within 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac{|a - b|}{max{(1, |b|)}} β€ 10^{-6}.
Examples
Input
2 2
0 1 2 3
2 5
0 4
Output
1.500000
2.250000
3.250000
Input
1 0
2 3
Output
2.500000
Input
2 0
1 1 1 1
Output
1.000000
Note
Consider the second test case. If Allen goes first, he will set x_1 β 1, so the final value will be 3. If Bessie goes first, then she will set x_1 β 0 so the final value will be 2. Thus the answer is 2.5.
In the third test case, the game value will always be 1 regardless of Allen and Bessie's play. | instruction | 0 | 95,025 | 19 | 190,050 |
Tags: math
Correct Solution:
```
import sys
n, r = [int(x) for x in sys.stdin.readline().split()]
a = [int(x) for x in sys.stdin.readline().split()]
s = sum(a)
n = 2**n
sys.stdout.write(str(s / n)+"\n")
for i in range(r):
p, x = [int(x) for x in sys.stdin.readline().split()]
s = s - a[p] + x
a[p] = x
sys.stdout.write(str(s / n)+"\n")
``` | output | 1 | 95,025 | 19 | 190,051 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Allen and Bessie are playing a simple number game. They both know a function f: \{0, 1\}^n β R, i. e. the function takes n binary arguments and returns a real value. At the start of the game, the variables x_1, x_2, ..., x_n are all set to -1. Each round, with equal probability, one of Allen or Bessie gets to make a move. A move consists of picking an i such that x_i = -1 and either setting x_i β 0 or x_i β 1.
After n rounds all variables are set, and the game value resolves to f(x_1, x_2, ..., x_n). Allen wants to maximize the game value, and Bessie wants to minimize it.
Your goal is to help Allen and Bessie find the expected game value! They will play r+1 times though, so between each game, exactly one value of f changes. In other words, between rounds i and i+1 for 1 β€ i β€ r, f(z_1, ..., z_n) β g_i for some (z_1, ..., z_n) β \{0, 1\}^n. You are to find the expected game value in the beginning and after each change.
Input
The first line contains two integers n and r (1 β€ n β€ 18, 0 β€ r β€ 2^{18}).
The next line contains 2^n integers c_0, c_1, ..., c_{2^n-1} (0 β€ c_i β€ 10^9), denoting the initial values of f. More specifically, f(x_0, x_1, ..., x_{n-1}) = c_x, if x = \overline{x_{n-1} β¦ x_0} in binary.
Each of the next r lines contains two integers z and g (0 β€ z β€ 2^n - 1, 0 β€ g β€ 10^9). If z = \overline{z_{n-1} ... z_0} in binary, then this means to set f(z_0, ..., z_{n-1}) β g.
Output
Print r+1 lines, the i-th of which denotes the value of the game f during the i-th round. Your answer must have absolute or relative error within 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac{|a - b|}{max{(1, |b|)}} β€ 10^{-6}.
Examples
Input
2 2
0 1 2 3
2 5
0 4
Output
1.500000
2.250000
3.250000
Input
1 0
2 3
Output
2.500000
Input
2 0
1 1 1 1
Output
1.000000
Note
Consider the second test case. If Allen goes first, he will set x_1 β 1, so the final value will be 3. If Bessie goes first, then she will set x_1 β 0 so the final value will be 2. Thus the answer is 2.5.
In the third test case, the game value will always be 1 regardless of Allen and Bessie's play. | instruction | 0 | 95,026 | 19 | 190,052 |
Tags: math
Correct Solution:
```
from sys import stdin
from math import fsum
def main():
n, m = map(int, input().split())
ff = list(map(float, input().split()))
scale, r = .5 ** n, fsum(ff)
res = [r * scale]
for si, sf in map(str.split, stdin.read().splitlines()):
i, f = int(si), float(sf)
r += f - ff[i]
ff[i] = f
res.append(r * scale)
print('\n'.join(map(str, res)))
if __name__ == '__main__':
main()
``` | output | 1 | 95,026 | 19 | 190,053 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Allen and Bessie are playing a simple number game. They both know a function f: \{0, 1\}^n β R, i. e. the function takes n binary arguments and returns a real value. At the start of the game, the variables x_1, x_2, ..., x_n are all set to -1. Each round, with equal probability, one of Allen or Bessie gets to make a move. A move consists of picking an i such that x_i = -1 and either setting x_i β 0 or x_i β 1.
After n rounds all variables are set, and the game value resolves to f(x_1, x_2, ..., x_n). Allen wants to maximize the game value, and Bessie wants to minimize it.
Your goal is to help Allen and Bessie find the expected game value! They will play r+1 times though, so between each game, exactly one value of f changes. In other words, between rounds i and i+1 for 1 β€ i β€ r, f(z_1, ..., z_n) β g_i for some (z_1, ..., z_n) β \{0, 1\}^n. You are to find the expected game value in the beginning and after each change.
Input
The first line contains two integers n and r (1 β€ n β€ 18, 0 β€ r β€ 2^{18}).
The next line contains 2^n integers c_0, c_1, ..., c_{2^n-1} (0 β€ c_i β€ 10^9), denoting the initial values of f. More specifically, f(x_0, x_1, ..., x_{n-1}) = c_x, if x = \overline{x_{n-1} β¦ x_0} in binary.
Each of the next r lines contains two integers z and g (0 β€ z β€ 2^n - 1, 0 β€ g β€ 10^9). If z = \overline{z_{n-1} ... z_0} in binary, then this means to set f(z_0, ..., z_{n-1}) β g.
Output
Print r+1 lines, the i-th of which denotes the value of the game f during the i-th round. Your answer must have absolute or relative error within 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac{|a - b|}{max{(1, |b|)}} β€ 10^{-6}.
Examples
Input
2 2
0 1 2 3
2 5
0 4
Output
1.500000
2.250000
3.250000
Input
1 0
2 3
Output
2.500000
Input
2 0
1 1 1 1
Output
1.000000
Note
Consider the second test case. If Allen goes first, he will set x_1 β 1, so the final value will be 3. If Bessie goes first, then she will set x_1 β 0 so the final value will be 2. Thus the answer is 2.5.
In the third test case, the game value will always be 1 regardless of Allen and Bessie's play.
Submitted Solution:
```
from sys import stdin
def main():
n, m = map(int, input().split())
ff = list(map(float, input().split()))
scale, r = .5 ** n, sum(ff)
res = [r * scale]
for s in stdin.read().splitlines():
i, f = map(int, s.split())
r += f - ff[i]
res.append(r * scale)
print('\n'.join(map(str, res)))
if __name__ == '__main__':
main()
``` | instruction | 0 | 95,027 | 19 | 190,054 |
No | output | 1 | 95,027 | 19 | 190,055 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Allen and Bessie are playing a simple number game. They both know a function f: \{0, 1\}^n β R, i. e. the function takes n binary arguments and returns a real value. At the start of the game, the variables x_1, x_2, ..., x_n are all set to -1. Each round, with equal probability, one of Allen or Bessie gets to make a move. A move consists of picking an i such that x_i = -1 and either setting x_i β 0 or x_i β 1.
After n rounds all variables are set, and the game value resolves to f(x_1, x_2, ..., x_n). Allen wants to maximize the game value, and Bessie wants to minimize it.
Your goal is to help Allen and Bessie find the expected game value! They will play r+1 times though, so between each game, exactly one value of f changes. In other words, between rounds i and i+1 for 1 β€ i β€ r, f(z_1, ..., z_n) β g_i for some (z_1, ..., z_n) β \{0, 1\}^n. You are to find the expected game value in the beginning and after each change.
Input
The first line contains two integers n and r (1 β€ n β€ 18, 0 β€ r β€ 2^{18}).
The next line contains 2^n integers c_0, c_1, ..., c_{2^n-1} (0 β€ c_i β€ 10^9), denoting the initial values of f. More specifically, f(x_0, x_1, ..., x_{n-1}) = c_x, if x = \overline{x_{n-1} β¦ x_0} in binary.
Each of the next r lines contains two integers z and g (0 β€ z β€ 2^n - 1, 0 β€ g β€ 10^9). If z = \overline{z_{n-1} ... z_0} in binary, then this means to set f(z_0, ..., z_{n-1}) β g.
Output
Print r+1 lines, the i-th of which denotes the value of the game f during the i-th round. Your answer must have absolute or relative error within 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac{|a - b|}{max{(1, |b|)}} β€ 10^{-6}.
Examples
Input
2 2
0 1 2 3
2 5
0 4
Output
1.500000
2.250000
3.250000
Input
1 0
2 3
Output
2.500000
Input
2 0
1 1 1 1
Output
1.000000
Note
Consider the second test case. If Allen goes first, he will set x_1 β 1, so the final value will be 3. If Bessie goes first, then she will set x_1 β 0 so the final value will be 2. Thus the answer is 2.5.
In the third test case, the game value will always be 1 regardless of Allen and Bessie's play.
Submitted Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import time
(n, r) = (int(i) for i in input().split())
c = [int(i) for i in input().split()]
start = time.time()
s = sum(c)
n2 = 2**n
ans = [s/n2]
for i in range(r):
(k, new) = (int(i) for i in input().split())
s += new - c[k]
c[k] = new
ans.append(s/n2)
for i in range(len(ans)):
print(ans[i], end=" ")
print()
finish = time.time()
print(finish - start)
``` | instruction | 0 | 95,028 | 19 | 190,056 |
No | output | 1 | 95,028 | 19 | 190,057 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Allen and Bessie are playing a simple number game. They both know a function f: \{0, 1\}^n β R, i. e. the function takes n binary arguments and returns a real value. At the start of the game, the variables x_1, x_2, ..., x_n are all set to -1. Each round, with equal probability, one of Allen or Bessie gets to make a move. A move consists of picking an i such that x_i = -1 and either setting x_i β 0 or x_i β 1.
After n rounds all variables are set, and the game value resolves to f(x_1, x_2, ..., x_n). Allen wants to maximize the game value, and Bessie wants to minimize it.
Your goal is to help Allen and Bessie find the expected game value! They will play r+1 times though, so between each game, exactly one value of f changes. In other words, between rounds i and i+1 for 1 β€ i β€ r, f(z_1, ..., z_n) β g_i for some (z_1, ..., z_n) β \{0, 1\}^n. You are to find the expected game value in the beginning and after each change.
Input
The first line contains two integers n and r (1 β€ n β€ 18, 0 β€ r β€ 2^{18}).
The next line contains 2^n integers c_0, c_1, ..., c_{2^n-1} (0 β€ c_i β€ 10^9), denoting the initial values of f. More specifically, f(x_0, x_1, ..., x_{n-1}) = c_x, if x = \overline{x_{n-1} β¦ x_0} in binary.
Each of the next r lines contains two integers z and g (0 β€ z β€ 2^n - 1, 0 β€ g β€ 10^9). If z = \overline{z_{n-1} ... z_0} in binary, then this means to set f(z_0, ..., z_{n-1}) β g.
Output
Print r+1 lines, the i-th of which denotes the value of the game f during the i-th round. Your answer must have absolute or relative error within 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac{|a - b|}{max{(1, |b|)}} β€ 10^{-6}.
Examples
Input
2 2
0 1 2 3
2 5
0 4
Output
1.500000
2.250000
3.250000
Input
1 0
2 3
Output
2.500000
Input
2 0
1 1 1 1
Output
1.000000
Note
Consider the second test case. If Allen goes first, he will set x_1 β 1, so the final value will be 3. If Bessie goes first, then she will set x_1 β 0 so the final value will be 2. Thus the answer is 2.5.
In the third test case, the game value will always be 1 regardless of Allen and Bessie's play.
Submitted Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import time
(n, r) = (int(i) for i in input().split())
c = [int(i) for i in input().split()]
start = time.time()
s = sum(c)
n2 = 2**n
ans = [s/n2]
for i in range(r):
(k, new) = (int(i) for i in input().split())
s += new - c[k]
c[k] = new
ans.append(s/n2)
print(s/n2)
finish = time.time()
print(finish - start)
``` | instruction | 0 | 95,029 | 19 | 190,058 |
No | output | 1 | 95,029 | 19 | 190,059 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Allen and Bessie are playing a simple number game. They both know a function f: \{0, 1\}^n β R, i. e. the function takes n binary arguments and returns a real value. At the start of the game, the variables x_1, x_2, ..., x_n are all set to -1. Each round, with equal probability, one of Allen or Bessie gets to make a move. A move consists of picking an i such that x_i = -1 and either setting x_i β 0 or x_i β 1.
After n rounds all variables are set, and the game value resolves to f(x_1, x_2, ..., x_n). Allen wants to maximize the game value, and Bessie wants to minimize it.
Your goal is to help Allen and Bessie find the expected game value! They will play r+1 times though, so between each game, exactly one value of f changes. In other words, between rounds i and i+1 for 1 β€ i β€ r, f(z_1, ..., z_n) β g_i for some (z_1, ..., z_n) β \{0, 1\}^n. You are to find the expected game value in the beginning and after each change.
Input
The first line contains two integers n and r (1 β€ n β€ 18, 0 β€ r β€ 2^{18}).
The next line contains 2^n integers c_0, c_1, ..., c_{2^n-1} (0 β€ c_i β€ 10^9), denoting the initial values of f. More specifically, f(x_0, x_1, ..., x_{n-1}) = c_x, if x = \overline{x_{n-1} β¦ x_0} in binary.
Each of the next r lines contains two integers z and g (0 β€ z β€ 2^n - 1, 0 β€ g β€ 10^9). If z = \overline{z_{n-1} ... z_0} in binary, then this means to set f(z_0, ..., z_{n-1}) β g.
Output
Print r+1 lines, the i-th of which denotes the value of the game f during the i-th round. Your answer must have absolute or relative error within 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac{|a - b|}{max{(1, |b|)}} β€ 10^{-6}.
Examples
Input
2 2
0 1 2 3
2 5
0 4
Output
1.500000
2.250000
3.250000
Input
1 0
2 3
Output
2.500000
Input
2 0
1 1 1 1
Output
1.000000
Note
Consider the second test case. If Allen goes first, he will set x_1 β 1, so the final value will be 3. If Bessie goes first, then she will set x_1 β 0 so the final value will be 2. Thus the answer is 2.5.
In the third test case, the game value will always be 1 regardless of Allen and Bessie's play.
Submitted Solution:
```
from sys import stdin
from math import fsum
def main():
n, m = map(int, input().split())
ff = list(map(float, input().split()))
scale, r = .5 ** n, fsum(ff)
res = [r * scale]
for i, f in map(str.split, stdin.read().splitlines()):
r += float(f) - ff[int(i)]
res.append(r * scale)
print('\n'.join(map(str, res)))
if __name__ == '__main__':
main()
``` | instruction | 0 | 95,030 | 19 | 190,060 |
No | output | 1 | 95,030 | 19 | 190,061 |
Provide a correct Python 3 solution for this coding contest problem.
Tic-tac-toe is a game in which you win when you put β and Γ alternately in the 3 Γ 3 squares and line up β or Γ in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: β wins | Figure 2: Γ wins | Figure 3: Draw
In tic-tac-toe, β and Γ alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both β and Γ to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for β, Γ, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if β wins, x in lowercase half-width letters if Γ wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d | instruction | 0 | 95,179 | 19 | 190,358 |
"Correct Solution:
```
def f(a):
for x in ['o','x']:
if a[0::4].count(x)==3 or a[2:7:2].count(x)==3:return x
for i in range(3):
if a[i*3:i*3+3].count(x)==3 or a[i::3].count(x)==3:return x
return 'd'
while 1:
try:print(f(input()))
except:break
``` | output | 1 | 95,179 | 19 | 190,359 |
Provide a correct Python 3 solution for this coding contest problem.
Tic-tac-toe is a game in which you win when you put β and Γ alternately in the 3 Γ 3 squares and line up β or Γ in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: β wins | Figure 2: Γ wins | Figure 3: Draw
In tic-tac-toe, β and Γ alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both β and Γ to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for β, Γ, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if β wins, x in lowercase half-width letters if Γ wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d | instruction | 0 | 95,180 | 19 | 190,360 |
"Correct Solution:
```
import sys
for line in sys.stdin.readlines():
l = [s for s in line.rstrip()]
answer = 'd'
for i in range(3):
if l[i] == l[i+3] == l[i+6]:
if l[i] == 'o':
answer = 'o'
elif l[i] == 'x':
answer = 'x'
for i in range(0,8,3):
if l[i] == l[i+1] == l[i+2]:
if l[i] == 'o':
answer = 'o'
elif l[i] == 'x':
answer = 'x'
if l[0] == l[4] == l[8] or l[2] == l[4] == l[6]:
if l[4] == 'o':
answer = 'o'
elif l[4] == 'x':
answer = 'x'
print(answer)
``` | output | 1 | 95,180 | 19 | 190,361 |
Provide a correct Python 3 solution for this coding contest problem.
Tic-tac-toe is a game in which you win when you put β and Γ alternately in the 3 Γ 3 squares and line up β or Γ in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: β wins | Figure 2: Γ wins | Figure 3: Draw
In tic-tac-toe, β and Γ alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both β and Γ to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for β, Γ, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if β wins, x in lowercase half-width letters if Γ wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d | instruction | 0 | 95,181 | 19 | 190,362 |
"Correct Solution:
```
def f(s):
for t in ['o', 'x']:
if s[::4].count(t) == 3 or s[2:7:2].count(t) == 3:
return t
for i in range(3):
if s[i::3].count(t) == 3 or s[3 * i:3 * i + 3].count(t) == 3:
return t
return 'd'
while 1:
try:
print(f(input()))
except:
break
``` | output | 1 | 95,181 | 19 | 190,363 |
Provide a correct Python 3 solution for this coding contest problem.
Tic-tac-toe is a game in which you win when you put β and Γ alternately in the 3 Γ 3 squares and line up β or Γ in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: β wins | Figure 2: Γ wins | Figure 3: Draw
In tic-tac-toe, β and Γ alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both β and Γ to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for β, Γ, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if β wins, x in lowercase half-width letters if Γ wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d | instruction | 0 | 95,182 | 19 | 190,364 |
"Correct Solution:
```
ok = [[0,4,8], [2,4,6], [0,1,2], [3,4,5], [6,7,8], [0,3,6], [1,4,7], [2,5,8]]
while True:
try:
s = input()
except EOFError:
break
flag = False
for i in ok:
if s[i[0]] == s[i[1]] == s[i[2]] and s[i[0]] != 's':
print(s[i[0]])
flag = True
break
if flag:
continue
print("d")
``` | output | 1 | 95,182 | 19 | 190,365 |
Provide a correct Python 3 solution for this coding contest problem.
Tic-tac-toe is a game in which you win when you put β and Γ alternately in the 3 Γ 3 squares and line up β or Γ in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: β wins | Figure 2: Γ wins | Figure 3: Draw
In tic-tac-toe, β and Γ alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both β and Γ to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for β, Γ, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if β wins, x in lowercase half-width letters if Γ wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d | instruction | 0 | 95,183 | 19 | 190,366 |
"Correct Solution:
```
while True:
try:
ban = input()
except EOFError:
break
s = [ban[:3], ban[3:6], ban[6:]]
s += map(''.join, zip(*s))
s += [ban[0]+ban[4]+ban[8]] + [ban[2]+ban[4]+ban[6]]
if 'ooo' in s:
print('o')
elif 'xxx' in s:
print('x')
else:
print('d')
``` | output | 1 | 95,183 | 19 | 190,367 |
Provide a correct Python 3 solution for this coding contest problem.
Tic-tac-toe is a game in which you win when you put β and Γ alternately in the 3 Γ 3 squares and line up β or Γ in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: β wins | Figure 2: Γ wins | Figure 3: Draw
In tic-tac-toe, β and Γ alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both β and Γ to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for β, Γ, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if β wins, x in lowercase half-width letters if Γ wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d | instruction | 0 | 95,184 | 19 | 190,368 |
"Correct Solution:
```
import sys
f = sys.stdin
vlines = [[0,1,2],[3,4,5],[6,7,8],[0,3,6],[1,4,7],[2,5,8],[0,4,8],[2,4,6]]
for line in f:
result = 'd'
for v in vlines:
if 's' != line[v[0]] and line[v[0]]== line[v[1]] == line[v[2]]:
result = line[v[0]]
break
print(result)
``` | output | 1 | 95,184 | 19 | 190,369 |
Provide a correct Python 3 solution for this coding contest problem.
Tic-tac-toe is a game in which you win when you put β and Γ alternately in the 3 Γ 3 squares and line up β or Γ in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: β wins | Figure 2: Γ wins | Figure 3: Draw
In tic-tac-toe, β and Γ alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both β and Γ to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for β, Γ, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if β wins, x in lowercase half-width letters if Γ wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d | instruction | 0 | 95,185 | 19 | 190,370 |
"Correct Solution:
```
# AOJ 0066 Tic Tac Toe
# Python3 2018.6.15 bal4u
def check(a):
for koma in ['o', 'x']:
for i in range(3):
if a[i:9:3].count(koma) == 3 or a[3*i:3*i+3].count(koma) == 3: return koma
if a[0:9:4].count(koma) == 3 or a[2:7:2].count(koma) == 3: return koma
return 'd'
while True:
try: print(check(list(input())))
except EOFError: break
``` | output | 1 | 95,185 | 19 | 190,371 |
Provide a correct Python 3 solution for this coding contest problem.
Tic-tac-toe is a game in which you win when you put β and Γ alternately in the 3 Γ 3 squares and line up β or Γ in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: β wins | Figure 2: Γ wins | Figure 3: Draw
In tic-tac-toe, β and Γ alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both β and Γ to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for β, Γ, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if β wins, x in lowercase half-width letters if Γ wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d | instruction | 0 | 95,186 | 19 | 190,372 |
"Correct Solution:
```
# -*- coding: utf-8 -*-
import sys
import os
import re
def is_win(A, B, C, sign):
if A[0] == A[1] == A[2] == sign or B[0] == B[1] == B[2] == sign or C[0] == C[1] == C[2] == sign:
return True
elif A[0] == B[0] == C[0] == sign or A[1] == B[1] == C[1] == sign or A[2] == B[2] == C[2] == sign:
return True
elif A[0] == B[1] == C[2] == sign or A[2] == B[1] == C[0] == sign:
return True
else:
return False
for s in sys.stdin:
s = s.strip()
A = s[0:3]
B = s[3:6]
C = s[6:9]
if is_win(A, B, C, 'o'):
print('o')
elif is_win(A, B, C, 'x'):
print('x')
else:
print('d')
``` | output | 1 | 95,186 | 19 | 190,373 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tic-tac-toe is a game in which you win when you put β and Γ alternately in the 3 Γ 3 squares and line up β or Γ in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: β wins | Figure 2: Γ wins | Figure 3: Draw
In tic-tac-toe, β and Γ alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both β and Γ to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for β, Γ, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if β wins, x in lowercase half-width letters if Γ wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
Submitted Solution:
```
def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
N = list(get_input())
for l in range(len(N)):
table = [[0 for i in range(3)] for j in range(3)]
S = N[l]
ans = "d"
for i in range(9):
if S[i] == "o":
table[i // 3][i % 3] = 1
elif S[i] == "x":
table[i // 3][i % 3] = -1
for i in range(3):
s = 0
for j in range(3):
s += table[i][j]
if s == 3:
ans = "o"
elif s == -3:
ans = "x"
for i in range(3):
s = 0
for j in range(3):
s += table[j][i]
if s == 3:
ans = "o"
elif s == -3:
ans = "x"
s = table[0][0] + table[1][1] + table[2][2]
if s == 3:
ans = "o"
elif s == -3:
ans = "x"
s = table[0][2] + table[1][1] + table[2][0]
if s == 3:
ans = "o"
elif s == -3:
ans = "x"
print(ans)
``` | instruction | 0 | 95,187 | 19 | 190,374 |
Yes | output | 1 | 95,187 | 19 | 190,375 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tic-tac-toe is a game in which you win when you put β and Γ alternately in the 3 Γ 3 squares and line up β or Γ in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: β wins | Figure 2: Γ wins | Figure 3: Draw
In tic-tac-toe, β and Γ alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both β and Γ to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for β, Γ, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if β wins, x in lowercase half-width letters if Γ wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
Submitted Solution:
```
import sys
[
print('o' if 'ooo' in b else ('x' if 'xxx' in b else 'd'))
for b in [
[
"".join([l[i] for i in t])
for t in [(0, 1, 2), (3, 4, 5), (6, 7, 8), (0, 3, 6), (1, 4, 7), (2, 5, 8), (0, 4, 8), (2, 4, 6)]
]
for l in (
list(s.strip())
for s in sys.stdin
)
]
]
``` | instruction | 0 | 95,188 | 19 | 190,376 |
Yes | output | 1 | 95,188 | 19 | 190,377 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tic-tac-toe is a game in which you win when you put β and Γ alternately in the 3 Γ 3 squares and line up β or Γ in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: β wins | Figure 2: Γ wins | Figure 3: Draw
In tic-tac-toe, β and Γ alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both β and Γ to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for β, Γ, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if β wins, x in lowercase half-width letters if Γ wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
Submitted Solution:
```
while True:
try:
hoge = input()
except:
break
ans = "d"
for i in range(3):
if "ooo" == hoge[i*3:i*3+3] or "ooo" == hoge[i::3]:
ans = "o"
break
elif "xxx" == hoge[i*3:i*3+3] or "xxx" == hoge[i::3]:
ans = "x"
break
if hoge[0::4] == "ooo" or hoge[2:7:2] == "ooo":
ans = "o"
elif hoge[0::4] == "xxx" or hoge[2:7:2] == "xxx":
ans = "x"
print(ans)
``` | instruction | 0 | 95,189 | 19 | 190,378 |
Yes | output | 1 | 95,189 | 19 | 190,379 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tic-tac-toe is a game in which you win when you put β and Γ alternately in the 3 Γ 3 squares and line up β or Γ in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: β wins | Figure 2: Γ wins | Figure 3: Draw
In tic-tac-toe, β and Γ alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both β and Γ to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for β, Γ, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if β wins, x in lowercase half-width letters if Γ wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
Submitted Solution:
```
while True:
try:
k = list(input())
ans = 'd'
lst1 = [k[:3], k[3:6], k[6:]]
lst2 = [k[::3], k[1::3], k[2::3]]
if k[4] != 's':
if k[0] == k[4] and k[4] == k[8]:
ans = k[4]
elif k[2] == k[4] and k[4] == k[6]:
ans = k[4]
for i in lst1:
if i.count('o') == 3:
ans = 'o'
elif i.count('x') == 3:
ans = 'x'
else:
pass
for i in lst2:
if i.count('o') == 3:
ans = 'o'
elif i.count('x') == 3:
ans = 'x'
else:
pass
print(ans)
except EOFError:
break
``` | instruction | 0 | 95,190 | 19 | 190,380 |
Yes | output | 1 | 95,190 | 19 | 190,381 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tic-tac-toe is a game in which you win when you put β and Γ alternately in the 3 Γ 3 squares and line up β or Γ in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: β wins | Figure 2: Γ wins | Figure 3: Draw
In tic-tac-toe, β and Γ alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both β and Γ to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for β, Γ, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if β wins, x in lowercase half-width letters if Γ wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
Submitted Solution:
```
import sys
board = []
board_list = []
result = []
for line in sys.stdin:
line = line.rstrip('\n')
board.append(line)
l_num = len(board)
print(board)
def check(num):
if board_list[num][0] == board_list[num][1] == board_list[num][2]:
if board_list[num][0] == 'o':
return 'o'
elif board_list[num][0] == 'x':
return 'x'
if board_list[0][num] == board_list[1][num] == board_list[2][num]:
if board_list[0][num] == 'o':
return 'o'
elif board_list[0][num] == 'x':
return 'x'
if board_list[0][0] == board_list[1][1] == board_list[2][2]:
if board_list[0][0] == 'o':
return 'o'
elif board_list[0][0] == 'x':
return 'x'
if board_list[0][2] == board_list[1][1] == board_list[2][0]:
if board_list[0][0] == 'o':
return 'o'
elif board_list[0][0] == 'x':
return 'x'
return'd'
for i in board:
board_list = [(a + b + c) for (a, b, c) in zip(i[::3], i[1::3], i[2::3])]
print(board_list)
for j in range(3):
if check(j) != "d":
print(check(j))
break
elif j == 2:
print(check(j))
``` | instruction | 0 | 95,191 | 19 | 190,382 |
No | output | 1 | 95,191 | 19 | 190,383 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tic-tac-toe is a game in which you win when you put β and Γ alternately in the 3 Γ 3 squares and line up β or Γ in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: β wins | Figure 2: Γ wins | Figure 3: Draw
In tic-tac-toe, β and Γ alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both β and Γ to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for β, Γ, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if β wins, x in lowercase half-width letters if Γ wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
Submitted Solution:
```
ok = [{0,4,8}, {2,4,6}, {0,1,2}, {3,4,5}, {6,7,8}, {0,3,6}, {1,4,7}, {2,5,8}]
while True:
s = input()
if len(s) == 0:
break
maru = set()
batu = set()
for i in range(9):
if s[i] == 'o':
maru.add(i)
elif s[i] == 'x':
batu.add(i)
flag = False
for i in ok:
if len(i - maru) == 0:
print("o")
flag = True
break
elif len(i - batu) == 0:
print("x")
flag = True
break
if flag:
continue
print("d")
``` | instruction | 0 | 95,192 | 19 | 190,384 |
No | output | 1 | 95,192 | 19 | 190,385 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tic-tac-toe is a game in which you win when you put β and Γ alternately in the 3 Γ 3 squares and line up β or Γ in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: β wins | Figure 2: Γ wins | Figure 3: Draw
In tic-tac-toe, β and Γ alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both β and Γ to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for β, Γ, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if β wins, x in lowercase half-width letters if Γ wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
Submitted Solution:
```
ok = [[0,4,8], [2,4,6], [0,1,2], [3,4,5], [6,7,8], [0,3,6], [1,4,7], [2,5,8]]
while True:
s = input()
if len(s) == 0:
break
maru = []
batu = []
for i in range(9):
if s[i] == 'o':
maru.append(i)
elif s[i] == 'x':
batu.append(i)
flag = False
for i in ok:
if i == maru:
print("o")
flag = True
break
elif i ==batu:
print("x")
flag = True
break
if flag:
continue
print("d")
``` | instruction | 0 | 95,193 | 19 | 190,386 |
No | output | 1 | 95,193 | 19 | 190,387 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tic-tac-toe is a game in which you win when you put β and Γ alternately in the 3 Γ 3 squares and line up β or Γ in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: β wins | Figure 2: Γ wins | Figure 3: Draw
In tic-tac-toe, β and Γ alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both β and Γ to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for β, Γ, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if β wins, x in lowercase half-width letters if Γ wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
Submitted Solution:
```
def check(num):
if board_list[num][0] == board_list[num][1] == board_list[num][2]:
if board_list[num][0] == 'o':
return 'o'
elif board_list[num][0] == 'x':
return 'x'
if board_list[0][num] == board_list[1][num] == board_list[2][num]:
if board_list[0][num] == 'o':
return 'o'
elif board_list[0][num] == 'x':
return 'x'
if board_list[0][0] == board_list[1][1] == board_list[2][2]:
if board_list[0][0] == 'o':
return 'o'
elif board_list[0][0] == 'x':
return 'x'
if board_list[0][2] == board_list[1][1] == board_list[2][0]:
if board_list[0][0] == 'o':
return 'o'
elif board_list[0][0] == 'x':
return 'x'
return 'd'
if __name__ == '__main__':
board = input()
board_list = [(a + b + c) for (a, b, c) in zip(board[::3], board[1::3],
board[2::3])]
for i in range(3):
result = check(i)
if result != "d":
break
print(result)
``` | instruction | 0 | 95,194 | 19 | 190,388 |
No | output | 1 | 95,194 | 19 | 190,389 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob have decided to play the game "Rock, Paper, Scissors".
The game consists of several rounds, each round is independent of each other. In each round, both players show one of the following things at the same time: rock, paper or scissors. If both players showed the same things then the round outcome is a draw. Otherwise, the following rules applied:
* if one player showed rock and the other one showed scissors, then the player who showed rock is considered the winner and the other one is considered the loser;
* if one player showed scissors and the other one showed paper, then the player who showed scissors is considered the winner and the other one is considered the loser;
* if one player showed paper and the other one showed rock, then the player who showed paper is considered the winner and the other one is considered the loser.
Alice and Bob decided to play exactly n rounds of the game described above. Alice decided to show rock a_1 times, show scissors a_2 times and show paper a_3 times. Bob decided to show rock b_1 times, show scissors b_2 times and show paper b_3 times. Though, both Alice and Bob did not choose the sequence in which they show things. It is guaranteed that a_1 + a_2 + a_3 = n and b_1 + b_2 + b_3 = n.
Your task is to find two numbers:
1. the minimum number of round Alice can win;
2. the maximum number of rounds Alice can win.
Input
The first line of the input contains one integer n (1 β€ n β€ 10^{9}) β the number of rounds.
The second line of the input contains three integers a_1, a_2, a_3 (0 β€ a_i β€ n) β the number of times Alice will show rock, scissors and paper, respectively. It is guaranteed that a_1 + a_2 + a_3 = n.
The third line of the input contains three integers b_1, b_2, b_3 (0 β€ b_j β€ n) β the number of times Bob will show rock, scissors and paper, respectively. It is guaranteed that b_1 + b_2 + b_3 = n.
Output
Print two integers: the minimum and the maximum number of rounds Alice can win.
Examples
Input
2
0 1 1
1 1 0
Output
0 1
Input
15
5 5 5
5 5 5
Output
0 15
Input
3
0 0 3
3 0 0
Output
3 3
Input
686
479 178 29
11 145 530
Output
22 334
Input
319
10 53 256
182 103 34
Output
119 226
Note
In the first example, Alice will not win any rounds if she shows scissors and then paper and Bob shows rock and then scissors. In the best outcome, Alice will win one round if she shows paper and then scissors, and Bob shows rock and then scissors.
In the second example, Alice will not win any rounds if Bob shows the same things as Alice each round.
In the third example, Alice always shows paper and Bob always shows rock so Alice will win all three rounds anyway. | instruction | 0 | 95,453 | 19 | 190,906 |
Tags: brute force, constructive algorithms, flows, greedy, math
Correct Solution:
```
import sys
n=int(input())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
mx=min(a[0],b[1])+min(a[1],b[2])+min(a[2],b[0])
if(a[0]>b[0]+b[2]):
mn=a[0]-b[0]-b[2]
elif(a[1]>b[0]+b[1]):
mn=a[1]-b[0]-b[1]
elif(a[2]>b[1]+b[2]):
mn=a[2]-b[1]-b[2]
else:
mn=0
print(mn,mx)
``` | output | 1 | 95,453 | 19 | 190,907 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob have decided to play the game "Rock, Paper, Scissors".
The game consists of several rounds, each round is independent of each other. In each round, both players show one of the following things at the same time: rock, paper or scissors. If both players showed the same things then the round outcome is a draw. Otherwise, the following rules applied:
* if one player showed rock and the other one showed scissors, then the player who showed rock is considered the winner and the other one is considered the loser;
* if one player showed scissors and the other one showed paper, then the player who showed scissors is considered the winner and the other one is considered the loser;
* if one player showed paper and the other one showed rock, then the player who showed paper is considered the winner and the other one is considered the loser.
Alice and Bob decided to play exactly n rounds of the game described above. Alice decided to show rock a_1 times, show scissors a_2 times and show paper a_3 times. Bob decided to show rock b_1 times, show scissors b_2 times and show paper b_3 times. Though, both Alice and Bob did not choose the sequence in which they show things. It is guaranteed that a_1 + a_2 + a_3 = n and b_1 + b_2 + b_3 = n.
Your task is to find two numbers:
1. the minimum number of round Alice can win;
2. the maximum number of rounds Alice can win.
Input
The first line of the input contains one integer n (1 β€ n β€ 10^{9}) β the number of rounds.
The second line of the input contains three integers a_1, a_2, a_3 (0 β€ a_i β€ n) β the number of times Alice will show rock, scissors and paper, respectively. It is guaranteed that a_1 + a_2 + a_3 = n.
The third line of the input contains three integers b_1, b_2, b_3 (0 β€ b_j β€ n) β the number of times Bob will show rock, scissors and paper, respectively. It is guaranteed that b_1 + b_2 + b_3 = n.
Output
Print two integers: the minimum and the maximum number of rounds Alice can win.
Examples
Input
2
0 1 1
1 1 0
Output
0 1
Input
15
5 5 5
5 5 5
Output
0 15
Input
3
0 0 3
3 0 0
Output
3 3
Input
686
479 178 29
11 145 530
Output
22 334
Input
319
10 53 256
182 103 34
Output
119 226
Note
In the first example, Alice will not win any rounds if she shows scissors and then paper and Bob shows rock and then scissors. In the best outcome, Alice will win one round if she shows paper and then scissors, and Bob shows rock and then scissors.
In the second example, Alice will not win any rounds if Bob shows the same things as Alice each round.
In the third example, Alice always shows paper and Bob always shows rock so Alice will win all three rounds anyway. | instruction | 0 | 95,454 | 19 | 190,908 |
Tags: brute force, constructive algorithms, flows, greedy, math
Correct Solution:
```
n = int(input())
a1,a3,a2 = map(int,input().split())
b1,b3,b2 = map(int,input().split())
mx = min(a1,b3) + min(a2,b1) + min(a3,b2)
mi = max(0,a1+b3-n , a2+b1-n , a3+b2-n)
print(mi,mx)
``` | output | 1 | 95,454 | 19 | 190,909 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob have decided to play the game "Rock, Paper, Scissors".
The game consists of several rounds, each round is independent of each other. In each round, both players show one of the following things at the same time: rock, paper or scissors. If both players showed the same things then the round outcome is a draw. Otherwise, the following rules applied:
* if one player showed rock and the other one showed scissors, then the player who showed rock is considered the winner and the other one is considered the loser;
* if one player showed scissors and the other one showed paper, then the player who showed scissors is considered the winner and the other one is considered the loser;
* if one player showed paper and the other one showed rock, then the player who showed paper is considered the winner and the other one is considered the loser.
Alice and Bob decided to play exactly n rounds of the game described above. Alice decided to show rock a_1 times, show scissors a_2 times and show paper a_3 times. Bob decided to show rock b_1 times, show scissors b_2 times and show paper b_3 times. Though, both Alice and Bob did not choose the sequence in which they show things. It is guaranteed that a_1 + a_2 + a_3 = n and b_1 + b_2 + b_3 = n.
Your task is to find two numbers:
1. the minimum number of round Alice can win;
2. the maximum number of rounds Alice can win.
Input
The first line of the input contains one integer n (1 β€ n β€ 10^{9}) β the number of rounds.
The second line of the input contains three integers a_1, a_2, a_3 (0 β€ a_i β€ n) β the number of times Alice will show rock, scissors and paper, respectively. It is guaranteed that a_1 + a_2 + a_3 = n.
The third line of the input contains three integers b_1, b_2, b_3 (0 β€ b_j β€ n) β the number of times Bob will show rock, scissors and paper, respectively. It is guaranteed that b_1 + b_2 + b_3 = n.
Output
Print two integers: the minimum and the maximum number of rounds Alice can win.
Examples
Input
2
0 1 1
1 1 0
Output
0 1
Input
15
5 5 5
5 5 5
Output
0 15
Input
3
0 0 3
3 0 0
Output
3 3
Input
686
479 178 29
11 145 530
Output
22 334
Input
319
10 53 256
182 103 34
Output
119 226
Note
In the first example, Alice will not win any rounds if she shows scissors and then paper and Bob shows rock and then scissors. In the best outcome, Alice will win one round if she shows paper and then scissors, and Bob shows rock and then scissors.
In the second example, Alice will not win any rounds if Bob shows the same things as Alice each round.
In the third example, Alice always shows paper and Bob always shows rock so Alice will win all three rounds anyway. | instruction | 0 | 95,455 | 19 | 190,910 |
Tags: brute force, constructive algorithms, flows, greedy, math
Correct Solution:
```
#1426E
from itertools import permutations
import sys
n=int(input())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
maxa=min(a[0],b[1])+min(a[1],b[2])+min(a[2],b[0])
combi=((0,0),(1,1),(2,2),(0,2),(1,0),(2,1))
mina=sys.maxsize
for i in permutations((combi)):
a1=a[:];b1=b[:]
for j in i:
x=min(a1[j[0]],b1[j[1]])
a1[j[0]]-=x
b1[j[1]]-=x
mina=min(mina,min(a1[0],b1[1])+min(a1[1],b1[2])+min(a1[2],b1[0]))
print("%d %d" %(mina, maxa))
``` | output | 1 | 95,455 | 19 | 190,911 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob have decided to play the game "Rock, Paper, Scissors".
The game consists of several rounds, each round is independent of each other. In each round, both players show one of the following things at the same time: rock, paper or scissors. If both players showed the same things then the round outcome is a draw. Otherwise, the following rules applied:
* if one player showed rock and the other one showed scissors, then the player who showed rock is considered the winner and the other one is considered the loser;
* if one player showed scissors and the other one showed paper, then the player who showed scissors is considered the winner and the other one is considered the loser;
* if one player showed paper and the other one showed rock, then the player who showed paper is considered the winner and the other one is considered the loser.
Alice and Bob decided to play exactly n rounds of the game described above. Alice decided to show rock a_1 times, show scissors a_2 times and show paper a_3 times. Bob decided to show rock b_1 times, show scissors b_2 times and show paper b_3 times. Though, both Alice and Bob did not choose the sequence in which they show things. It is guaranteed that a_1 + a_2 + a_3 = n and b_1 + b_2 + b_3 = n.
Your task is to find two numbers:
1. the minimum number of round Alice can win;
2. the maximum number of rounds Alice can win.
Input
The first line of the input contains one integer n (1 β€ n β€ 10^{9}) β the number of rounds.
The second line of the input contains three integers a_1, a_2, a_3 (0 β€ a_i β€ n) β the number of times Alice will show rock, scissors and paper, respectively. It is guaranteed that a_1 + a_2 + a_3 = n.
The third line of the input contains three integers b_1, b_2, b_3 (0 β€ b_j β€ n) β the number of times Bob will show rock, scissors and paper, respectively. It is guaranteed that b_1 + b_2 + b_3 = n.
Output
Print two integers: the minimum and the maximum number of rounds Alice can win.
Examples
Input
2
0 1 1
1 1 0
Output
0 1
Input
15
5 5 5
5 5 5
Output
0 15
Input
3
0 0 3
3 0 0
Output
3 3
Input
686
479 178 29
11 145 530
Output
22 334
Input
319
10 53 256
182 103 34
Output
119 226
Note
In the first example, Alice will not win any rounds if she shows scissors and then paper and Bob shows rock and then scissors. In the best outcome, Alice will win one round if she shows paper and then scissors, and Bob shows rock and then scissors.
In the second example, Alice will not win any rounds if Bob shows the same things as Alice each round.
In the third example, Alice always shows paper and Bob always shows rock so Alice will win all three rounds anyway. | instruction | 0 | 95,456 | 19 | 190,912 |
Tags: brute force, constructive algorithms, flows, greedy, math
Correct Solution:
```
n = int(input())
r,s,p = map(int,input().split())
a,b,c = map(int,input().split())
maxi = min(r,b)+min(s,c)+min(a,p)
mini = max(0,r+b-n)+max(0,s+c-n)+max(0,p+a-n)
print(mini,maxi)
``` | output | 1 | 95,456 | 19 | 190,913 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob have decided to play the game "Rock, Paper, Scissors".
The game consists of several rounds, each round is independent of each other. In each round, both players show one of the following things at the same time: rock, paper or scissors. If both players showed the same things then the round outcome is a draw. Otherwise, the following rules applied:
* if one player showed rock and the other one showed scissors, then the player who showed rock is considered the winner and the other one is considered the loser;
* if one player showed scissors and the other one showed paper, then the player who showed scissors is considered the winner and the other one is considered the loser;
* if one player showed paper and the other one showed rock, then the player who showed paper is considered the winner and the other one is considered the loser.
Alice and Bob decided to play exactly n rounds of the game described above. Alice decided to show rock a_1 times, show scissors a_2 times and show paper a_3 times. Bob decided to show rock b_1 times, show scissors b_2 times and show paper b_3 times. Though, both Alice and Bob did not choose the sequence in which they show things. It is guaranteed that a_1 + a_2 + a_3 = n and b_1 + b_2 + b_3 = n.
Your task is to find two numbers:
1. the minimum number of round Alice can win;
2. the maximum number of rounds Alice can win.
Input
The first line of the input contains one integer n (1 β€ n β€ 10^{9}) β the number of rounds.
The second line of the input contains three integers a_1, a_2, a_3 (0 β€ a_i β€ n) β the number of times Alice will show rock, scissors and paper, respectively. It is guaranteed that a_1 + a_2 + a_3 = n.
The third line of the input contains three integers b_1, b_2, b_3 (0 β€ b_j β€ n) β the number of times Bob will show rock, scissors and paper, respectively. It is guaranteed that b_1 + b_2 + b_3 = n.
Output
Print two integers: the minimum and the maximum number of rounds Alice can win.
Examples
Input
2
0 1 1
1 1 0
Output
0 1
Input
15
5 5 5
5 5 5
Output
0 15
Input
3
0 0 3
3 0 0
Output
3 3
Input
686
479 178 29
11 145 530
Output
22 334
Input
319
10 53 256
182 103 34
Output
119 226
Note
In the first example, Alice will not win any rounds if she shows scissors and then paper and Bob shows rock and then scissors. In the best outcome, Alice will win one round if she shows paper and then scissors, and Bob shows rock and then scissors.
In the second example, Alice will not win any rounds if Bob shows the same things as Alice each round.
In the third example, Alice always shows paper and Bob always shows rock so Alice will win all three rounds anyway. | instruction | 0 | 95,457 | 19 | 190,914 |
Tags: brute force, constructive algorithms, flows, greedy, math
Correct Solution:
```
def maxV(first, second):
return str(min(first[0], second[1]) + min(first[1], second[2]) + min(first[2], second[0]))
def minV(first, second):
vitPedra = first[0] - (second[0] + second[2])
vitTesoura = first[1] - (second[0] + second[1])
vitPapel = first[2] - (second[1] + second[2])
return str(max(vitPedra, 0) + max(vitTesoura, 0) + max(vitPapel, 0))
n = int(input())
alice = [int(k) for k in input().split()]
bob = [int(k) for k in input().split()]
print(minV(alice, bob), maxV(alice, bob))
``` | output | 1 | 95,457 | 19 | 190,915 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob have decided to play the game "Rock, Paper, Scissors".
The game consists of several rounds, each round is independent of each other. In each round, both players show one of the following things at the same time: rock, paper or scissors. If both players showed the same things then the round outcome is a draw. Otherwise, the following rules applied:
* if one player showed rock and the other one showed scissors, then the player who showed rock is considered the winner and the other one is considered the loser;
* if one player showed scissors and the other one showed paper, then the player who showed scissors is considered the winner and the other one is considered the loser;
* if one player showed paper and the other one showed rock, then the player who showed paper is considered the winner and the other one is considered the loser.
Alice and Bob decided to play exactly n rounds of the game described above. Alice decided to show rock a_1 times, show scissors a_2 times and show paper a_3 times. Bob decided to show rock b_1 times, show scissors b_2 times and show paper b_3 times. Though, both Alice and Bob did not choose the sequence in which they show things. It is guaranteed that a_1 + a_2 + a_3 = n and b_1 + b_2 + b_3 = n.
Your task is to find two numbers:
1. the minimum number of round Alice can win;
2. the maximum number of rounds Alice can win.
Input
The first line of the input contains one integer n (1 β€ n β€ 10^{9}) β the number of rounds.
The second line of the input contains three integers a_1, a_2, a_3 (0 β€ a_i β€ n) β the number of times Alice will show rock, scissors and paper, respectively. It is guaranteed that a_1 + a_2 + a_3 = n.
The third line of the input contains three integers b_1, b_2, b_3 (0 β€ b_j β€ n) β the number of times Bob will show rock, scissors and paper, respectively. It is guaranteed that b_1 + b_2 + b_3 = n.
Output
Print two integers: the minimum and the maximum number of rounds Alice can win.
Examples
Input
2
0 1 1
1 1 0
Output
0 1
Input
15
5 5 5
5 5 5
Output
0 15
Input
3
0 0 3
3 0 0
Output
3 3
Input
686
479 178 29
11 145 530
Output
22 334
Input
319
10 53 256
182 103 34
Output
119 226
Note
In the first example, Alice will not win any rounds if she shows scissors and then paper and Bob shows rock and then scissors. In the best outcome, Alice will win one round if she shows paper and then scissors, and Bob shows rock and then scissors.
In the second example, Alice will not win any rounds if Bob shows the same things as Alice each round.
In the third example, Alice always shows paper and Bob always shows rock so Alice will win all three rounds anyway. | instruction | 0 | 95,458 | 19 | 190,916 |
Tags: brute force, constructive algorithms, flows, greedy, math
Correct Solution:
```
import sys
def main():
#n = iinput()
#k = iinput()
#m = iinput()
n = int(sys.stdin.readline().strip())
#n, k = rinput()
#n, m = rinput()
#m, k = rinput()
#n, k, m = rinput()
#n, m, k = rinput()
#k, n, m = rinput()
#k, m, n = rinput()
#m, k, n = rinput()
#m, n, k = rinput()
#n, t = map(int, sys.stdin.readline().split())
#q = list(map(int, sys.stdin.readline().split()))
#q = linput()
a,a1,a2= map(int, sys.stdin.readline().split())
b,b1,b2= map(int, sys.stdin.readline().split())
res = min(a, b1) + min(a1, b2) + min(a2, b)
if b >= a1 + a:
ans = a2 - (n - b)
elif b1 >= a1 + a2:
ans = a - (n - b1)
elif b2 >= a2 + a:
ans = a1 - (n - b2)
elif (b == a and b1 == a1 and b2 == a2):
ans = 0
elif a > b and a1 > b1:
b2 -= a2
a -= b2
a1 -= b1
if a <= 0:
ans = a1 - b
else:
ans = a + a1 - b
elif a2 > b2 and a1 > b1:
b -= a
a1 -= b
a2 -= b2
if a1 <= 0:
ans = a2 - b1
else:
ans = a2 + a1 - b1
elif a > b and a2 > b2:
b1 -= a1
a2 -= b1
a -= b
if a2 <= 0:
ans = a - b
else:
ans = a2 + a - b
elif a > b:
a -= b
b1 -= a1
a2 -= b1
a1 = 0
ans = a + a2 - b2
elif a1 > b1:
a1 -= b1
b2 -= a2
a -= b2
a2 = 0
ans = a + a1 - b
elif a2 > b2:
a2 -= b2
b -= a
a1 -= b
a = 0
ans = a2 + a1 - b1
print(max(0, ans), res)
for i in range(1):
main()
``` | output | 1 | 95,458 | 19 | 190,917 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob have decided to play the game "Rock, Paper, Scissors".
The game consists of several rounds, each round is independent of each other. In each round, both players show one of the following things at the same time: rock, paper or scissors. If both players showed the same things then the round outcome is a draw. Otherwise, the following rules applied:
* if one player showed rock and the other one showed scissors, then the player who showed rock is considered the winner and the other one is considered the loser;
* if one player showed scissors and the other one showed paper, then the player who showed scissors is considered the winner and the other one is considered the loser;
* if one player showed paper and the other one showed rock, then the player who showed paper is considered the winner and the other one is considered the loser.
Alice and Bob decided to play exactly n rounds of the game described above. Alice decided to show rock a_1 times, show scissors a_2 times and show paper a_3 times. Bob decided to show rock b_1 times, show scissors b_2 times and show paper b_3 times. Though, both Alice and Bob did not choose the sequence in which they show things. It is guaranteed that a_1 + a_2 + a_3 = n and b_1 + b_2 + b_3 = n.
Your task is to find two numbers:
1. the minimum number of round Alice can win;
2. the maximum number of rounds Alice can win.
Input
The first line of the input contains one integer n (1 β€ n β€ 10^{9}) β the number of rounds.
The second line of the input contains three integers a_1, a_2, a_3 (0 β€ a_i β€ n) β the number of times Alice will show rock, scissors and paper, respectively. It is guaranteed that a_1 + a_2 + a_3 = n.
The third line of the input contains three integers b_1, b_2, b_3 (0 β€ b_j β€ n) β the number of times Bob will show rock, scissors and paper, respectively. It is guaranteed that b_1 + b_2 + b_3 = n.
Output
Print two integers: the minimum and the maximum number of rounds Alice can win.
Examples
Input
2
0 1 1
1 1 0
Output
0 1
Input
15
5 5 5
5 5 5
Output
0 15
Input
3
0 0 3
3 0 0
Output
3 3
Input
686
479 178 29
11 145 530
Output
22 334
Input
319
10 53 256
182 103 34
Output
119 226
Note
In the first example, Alice will not win any rounds if she shows scissors and then paper and Bob shows rock and then scissors. In the best outcome, Alice will win one round if she shows paper and then scissors, and Bob shows rock and then scissors.
In the second example, Alice will not win any rounds if Bob shows the same things as Alice each round.
In the third example, Alice always shows paper and Bob always shows rock so Alice will win all three rounds anyway. | instruction | 0 | 95,459 | 19 | 190,918 |
Tags: brute force, constructive algorithms, flows, greedy, math
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
mini=0
maxi=min(a[0],b[1])+min(a[1],b[2])+min(a[2],b[0])
if a[0]>(b[0]+b[2]):
mini=a[0]-b[2]-b[0]
elif a[1]>(b[1]+b[0]):
mini=a[1]-b[1]-b[0]
elif a[2]>(b[2]+b[1]):
mini=a[2]-b[2]-b[1]
else:
mini=0
print(mini,maxi)
``` | output | 1 | 95,459 | 19 | 190,919 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob have decided to play the game "Rock, Paper, Scissors".
The game consists of several rounds, each round is independent of each other. In each round, both players show one of the following things at the same time: rock, paper or scissors. If both players showed the same things then the round outcome is a draw. Otherwise, the following rules applied:
* if one player showed rock and the other one showed scissors, then the player who showed rock is considered the winner and the other one is considered the loser;
* if one player showed scissors and the other one showed paper, then the player who showed scissors is considered the winner and the other one is considered the loser;
* if one player showed paper and the other one showed rock, then the player who showed paper is considered the winner and the other one is considered the loser.
Alice and Bob decided to play exactly n rounds of the game described above. Alice decided to show rock a_1 times, show scissors a_2 times and show paper a_3 times. Bob decided to show rock b_1 times, show scissors b_2 times and show paper b_3 times. Though, both Alice and Bob did not choose the sequence in which they show things. It is guaranteed that a_1 + a_2 + a_3 = n and b_1 + b_2 + b_3 = n.
Your task is to find two numbers:
1. the minimum number of round Alice can win;
2. the maximum number of rounds Alice can win.
Input
The first line of the input contains one integer n (1 β€ n β€ 10^{9}) β the number of rounds.
The second line of the input contains three integers a_1, a_2, a_3 (0 β€ a_i β€ n) β the number of times Alice will show rock, scissors and paper, respectively. It is guaranteed that a_1 + a_2 + a_3 = n.
The third line of the input contains three integers b_1, b_2, b_3 (0 β€ b_j β€ n) β the number of times Bob will show rock, scissors and paper, respectively. It is guaranteed that b_1 + b_2 + b_3 = n.
Output
Print two integers: the minimum and the maximum number of rounds Alice can win.
Examples
Input
2
0 1 1
1 1 0
Output
0 1
Input
15
5 5 5
5 5 5
Output
0 15
Input
3
0 0 3
3 0 0
Output
3 3
Input
686
479 178 29
11 145 530
Output
22 334
Input
319
10 53 256
182 103 34
Output
119 226
Note
In the first example, Alice will not win any rounds if she shows scissors and then paper and Bob shows rock and then scissors. In the best outcome, Alice will win one round if she shows paper and then scissors, and Bob shows rock and then scissors.
In the second example, Alice will not win any rounds if Bob shows the same things as Alice each round.
In the third example, Alice always shows paper and Bob always shows rock so Alice will win all three rounds anyway. | instruction | 0 | 95,460 | 19 | 190,920 |
Tags: brute force, constructive algorithms, flows, greedy, math
Correct Solution:
```
import itertools
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
M = min(a[0], b[1]) + min(a[1], b[2]) + min(a[2], b[0])
order = []
order.append((0, 0))
order.append((0, 2))
order.append((1, 1))
order.append((1, 0))
order.append((2, 2))
order.append((2, 1))
orders = itertools.permutations(order)
# ors = [ordr for ordr in orders]
# print(len(ors))
m = float("inf")
for ordr in orders:
ac = a[:]
bc = b[:]
# print(ac, bc)
for i in range(6):
cnt = min(ac[ordr[i][0]], bc[ordr[i][1]])
ac[ordr[i][0]] -= cnt
bc[ordr[i][1]] -= cnt
cand = min(ac[0], bc[1]) + min(ac[1], bc[2]) + min(ac[2], bc[0])
m = min(m, cand)
print(m, M)
``` | output | 1 | 95,460 | 19 | 190,921 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob have decided to play the game "Rock, Paper, Scissors".
The game consists of several rounds, each round is independent of each other. In each round, both players show one of the following things at the same time: rock, paper or scissors. If both players showed the same things then the round outcome is a draw. Otherwise, the following rules applied:
* if one player showed rock and the other one showed scissors, then the player who showed rock is considered the winner and the other one is considered the loser;
* if one player showed scissors and the other one showed paper, then the player who showed scissors is considered the winner and the other one is considered the loser;
* if one player showed paper and the other one showed rock, then the player who showed paper is considered the winner and the other one is considered the loser.
Alice and Bob decided to play exactly n rounds of the game described above. Alice decided to show rock a_1 times, show scissors a_2 times and show paper a_3 times. Bob decided to show rock b_1 times, show scissors b_2 times and show paper b_3 times. Though, both Alice and Bob did not choose the sequence in which they show things. It is guaranteed that a_1 + a_2 + a_3 = n and b_1 + b_2 + b_3 = n.
Your task is to find two numbers:
1. the minimum number of round Alice can win;
2. the maximum number of rounds Alice can win.
Input
The first line of the input contains one integer n (1 β€ n β€ 10^{9}) β the number of rounds.
The second line of the input contains three integers a_1, a_2, a_3 (0 β€ a_i β€ n) β the number of times Alice will show rock, scissors and paper, respectively. It is guaranteed that a_1 + a_2 + a_3 = n.
The third line of the input contains three integers b_1, b_2, b_3 (0 β€ b_j β€ n) β the number of times Bob will show rock, scissors and paper, respectively. It is guaranteed that b_1 + b_2 + b_3 = n.
Output
Print two integers: the minimum and the maximum number of rounds Alice can win.
Examples
Input
2
0 1 1
1 1 0
Output
0 1
Input
15
5 5 5
5 5 5
Output
0 15
Input
3
0 0 3
3 0 0
Output
3 3
Input
686
479 178 29
11 145 530
Output
22 334
Input
319
10 53 256
182 103 34
Output
119 226
Note
In the first example, Alice will not win any rounds if she shows scissors and then paper and Bob shows rock and then scissors. In the best outcome, Alice will win one round if she shows paper and then scissors, and Bob shows rock and then scissors.
In the second example, Alice will not win any rounds if Bob shows the same things as Alice each round.
In the third example, Alice always shows paper and Bob always shows rock so Alice will win all three rounds anyway.
Submitted Solution:
```
import sys
import math
from collections import defaultdict,Counter
# input=sys.stdin.readline
# def print(x):
# sys.stdout.write(str(x)+"\n")
# sys.stdout=open("CP1/output.txt",'w')
# sys.stdin=open("CP1/input.txt",'r')
# mod=pow(10,9)+7
n=int(input())
a1,a2,a3=map(int,input().split())
b1,b2,b3=map(int,input().split())
ma=min(a1,b2)+min(a2,b3)+min(a3,b1)
s1=min(b1,a2)
s2=min(b2,a3)
s3=min(b3,a1)
mi=s1+s2+s3
mi=min(b1,a2)+min(b2,a3)+min(b3,a1)
mi+=min(a1,b1-s1)+min(a2,b2-s2)+min(a3,b3-s3)
# print(n-mi)
# ans=str(n-mi)+' '+str(ma)
print(n-mi,ma)
``` | instruction | 0 | 95,461 | 19 | 190,922 |
Yes | output | 1 | 95,461 | 19 | 190,923 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob have decided to play the game "Rock, Paper, Scissors".
The game consists of several rounds, each round is independent of each other. In each round, both players show one of the following things at the same time: rock, paper or scissors. If both players showed the same things then the round outcome is a draw. Otherwise, the following rules applied:
* if one player showed rock and the other one showed scissors, then the player who showed rock is considered the winner and the other one is considered the loser;
* if one player showed scissors and the other one showed paper, then the player who showed scissors is considered the winner and the other one is considered the loser;
* if one player showed paper and the other one showed rock, then the player who showed paper is considered the winner and the other one is considered the loser.
Alice and Bob decided to play exactly n rounds of the game described above. Alice decided to show rock a_1 times, show scissors a_2 times and show paper a_3 times. Bob decided to show rock b_1 times, show scissors b_2 times and show paper b_3 times. Though, both Alice and Bob did not choose the sequence in which they show things. It is guaranteed that a_1 + a_2 + a_3 = n and b_1 + b_2 + b_3 = n.
Your task is to find two numbers:
1. the minimum number of round Alice can win;
2. the maximum number of rounds Alice can win.
Input
The first line of the input contains one integer n (1 β€ n β€ 10^{9}) β the number of rounds.
The second line of the input contains three integers a_1, a_2, a_3 (0 β€ a_i β€ n) β the number of times Alice will show rock, scissors and paper, respectively. It is guaranteed that a_1 + a_2 + a_3 = n.
The third line of the input contains three integers b_1, b_2, b_3 (0 β€ b_j β€ n) β the number of times Bob will show rock, scissors and paper, respectively. It is guaranteed that b_1 + b_2 + b_3 = n.
Output
Print two integers: the minimum and the maximum number of rounds Alice can win.
Examples
Input
2
0 1 1
1 1 0
Output
0 1
Input
15
5 5 5
5 5 5
Output
0 15
Input
3
0 0 3
3 0 0
Output
3 3
Input
686
479 178 29
11 145 530
Output
22 334
Input
319
10 53 256
182 103 34
Output
119 226
Note
In the first example, Alice will not win any rounds if she shows scissors and then paper and Bob shows rock and then scissors. In the best outcome, Alice will win one round if she shows paper and then scissors, and Bob shows rock and then scissors.
In the second example, Alice will not win any rounds if Bob shows the same things as Alice each round.
In the third example, Alice always shows paper and Bob always shows rock so Alice will win all three rounds anyway.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(RL())
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
def toord(c): return ord(c)-ord('a')
def lcm(a, b): return a*b//gcd(a, b)
mod = 998244353
INF = float('inf')
from math import factorial, sqrt, ceil, floor, gcd
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush
# ------------------------------
# f = open('./input.txt')
# sys.stdin = f
def main():
n = N()
arra = RLL()
arrb = RLL()
ma = min(arrb[0], arra[2]) + min(arrb[1], arra[0]) + min(arrb[2], arra[1])
mi = n - (min(arra[0], arrb[0] + arrb[2]) + min(arra[1], arrb[1] + arrb[0]) + min(arra[2], arrb[2] + arrb[1]))
print(mi, ma)
if __name__ == "__main__":
main()
``` | instruction | 0 | 95,462 | 19 | 190,924 |
Yes | output | 1 | 95,462 | 19 | 190,925 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob have decided to play the game "Rock, Paper, Scissors".
The game consists of several rounds, each round is independent of each other. In each round, both players show one of the following things at the same time: rock, paper or scissors. If both players showed the same things then the round outcome is a draw. Otherwise, the following rules applied:
* if one player showed rock and the other one showed scissors, then the player who showed rock is considered the winner and the other one is considered the loser;
* if one player showed scissors and the other one showed paper, then the player who showed scissors is considered the winner and the other one is considered the loser;
* if one player showed paper and the other one showed rock, then the player who showed paper is considered the winner and the other one is considered the loser.
Alice and Bob decided to play exactly n rounds of the game described above. Alice decided to show rock a_1 times, show scissors a_2 times and show paper a_3 times. Bob decided to show rock b_1 times, show scissors b_2 times and show paper b_3 times. Though, both Alice and Bob did not choose the sequence in which they show things. It is guaranteed that a_1 + a_2 + a_3 = n and b_1 + b_2 + b_3 = n.
Your task is to find two numbers:
1. the minimum number of round Alice can win;
2. the maximum number of rounds Alice can win.
Input
The first line of the input contains one integer n (1 β€ n β€ 10^{9}) β the number of rounds.
The second line of the input contains three integers a_1, a_2, a_3 (0 β€ a_i β€ n) β the number of times Alice will show rock, scissors and paper, respectively. It is guaranteed that a_1 + a_2 + a_3 = n.
The third line of the input contains three integers b_1, b_2, b_3 (0 β€ b_j β€ n) β the number of times Bob will show rock, scissors and paper, respectively. It is guaranteed that b_1 + b_2 + b_3 = n.
Output
Print two integers: the minimum and the maximum number of rounds Alice can win.
Examples
Input
2
0 1 1
1 1 0
Output
0 1
Input
15
5 5 5
5 5 5
Output
0 15
Input
3
0 0 3
3 0 0
Output
3 3
Input
686
479 178 29
11 145 530
Output
22 334
Input
319
10 53 256
182 103 34
Output
119 226
Note
In the first example, Alice will not win any rounds if she shows scissors and then paper and Bob shows rock and then scissors. In the best outcome, Alice will win one round if she shows paper and then scissors, and Bob shows rock and then scissors.
In the second example, Alice will not win any rounds if Bob shows the same things as Alice each round.
In the third example, Alice always shows paper and Bob always shows rock so Alice will win all three rounds anyway.
Submitted Solution:
```
import sys,math
from collections import Counter,deque,defaultdict
from bisect import bisect_left,bisect_right
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n = inp()
a = inpl()
b = inpl()
sua = sum(a)
sub = sum(b)
mi_res = 0
if a[0] > b[0]+b[2]: mi_res = a[0]-b[0]-b[2]
if a[1] > b[0]+b[1]: mi_res = a[1]-b[0]-b[1]
if a[2] > b[2]+b[1]: mi_res = a[2]-b[2]-b[1]
ma_res = min(a[0],b[1]) + min(a[1],b[2]) + min(a[2],b[0])
print(mi_res,ma_res)
``` | instruction | 0 | 95,463 | 19 | 190,926 |
Yes | output | 1 | 95,463 | 19 | 190,927 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob have decided to play the game "Rock, Paper, Scissors".
The game consists of several rounds, each round is independent of each other. In each round, both players show one of the following things at the same time: rock, paper or scissors. If both players showed the same things then the round outcome is a draw. Otherwise, the following rules applied:
* if one player showed rock and the other one showed scissors, then the player who showed rock is considered the winner and the other one is considered the loser;
* if one player showed scissors and the other one showed paper, then the player who showed scissors is considered the winner and the other one is considered the loser;
* if one player showed paper and the other one showed rock, then the player who showed paper is considered the winner and the other one is considered the loser.
Alice and Bob decided to play exactly n rounds of the game described above. Alice decided to show rock a_1 times, show scissors a_2 times and show paper a_3 times. Bob decided to show rock b_1 times, show scissors b_2 times and show paper b_3 times. Though, both Alice and Bob did not choose the sequence in which they show things. It is guaranteed that a_1 + a_2 + a_3 = n and b_1 + b_2 + b_3 = n.
Your task is to find two numbers:
1. the minimum number of round Alice can win;
2. the maximum number of rounds Alice can win.
Input
The first line of the input contains one integer n (1 β€ n β€ 10^{9}) β the number of rounds.
The second line of the input contains three integers a_1, a_2, a_3 (0 β€ a_i β€ n) β the number of times Alice will show rock, scissors and paper, respectively. It is guaranteed that a_1 + a_2 + a_3 = n.
The third line of the input contains three integers b_1, b_2, b_3 (0 β€ b_j β€ n) β the number of times Bob will show rock, scissors and paper, respectively. It is guaranteed that b_1 + b_2 + b_3 = n.
Output
Print two integers: the minimum and the maximum number of rounds Alice can win.
Examples
Input
2
0 1 1
1 1 0
Output
0 1
Input
15
5 5 5
5 5 5
Output
0 15
Input
3
0 0 3
3 0 0
Output
3 3
Input
686
479 178 29
11 145 530
Output
22 334
Input
319
10 53 256
182 103 34
Output
119 226
Note
In the first example, Alice will not win any rounds if she shows scissors and then paper and Bob shows rock and then scissors. In the best outcome, Alice will win one round if she shows paper and then scissors, and Bob shows rock and then scissors.
In the second example, Alice will not win any rounds if Bob shows the same things as Alice each round.
In the third example, Alice always shows paper and Bob always shows rock so Alice will win all three rounds anyway.
Submitted Solution:
```
# Coder : Hakesh D #
import sys
#input=sys.stdin.readline
from collections import deque
from math import ceil,sqrt,gcd,factorial
from bisect import bisect_right,bisect_left
mod = 1000000007
INF = 10**18
NINF = -INF
def INT():return int(input())
def MAP():return map(int,input().split())
def LIST():return list(map(int,input().split()))
def modi(x):return pow(x,mod-2,mod)
def lcm(x,y):return (x*y)//gcd(x,y)
def write(l):
for i in l:
print(i,end=' ')
print()
########################################################################################
n = int(input())
r,s,p=MAP()
rr,ss,pp=MAP()
maxa = min(r,ss) + min(s,pp) + min(p,rr)
mini = min(r,rr+pp) + min(s,ss + rr) + min(p,pp + ss)
print(n - mini,maxa)
``` | instruction | 0 | 95,464 | 19 | 190,928 |
Yes | output | 1 | 95,464 | 19 | 190,929 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob have decided to play the game "Rock, Paper, Scissors".
The game consists of several rounds, each round is independent of each other. In each round, both players show one of the following things at the same time: rock, paper or scissors. If both players showed the same things then the round outcome is a draw. Otherwise, the following rules applied:
* if one player showed rock and the other one showed scissors, then the player who showed rock is considered the winner and the other one is considered the loser;
* if one player showed scissors and the other one showed paper, then the player who showed scissors is considered the winner and the other one is considered the loser;
* if one player showed paper and the other one showed rock, then the player who showed paper is considered the winner and the other one is considered the loser.
Alice and Bob decided to play exactly n rounds of the game described above. Alice decided to show rock a_1 times, show scissors a_2 times and show paper a_3 times. Bob decided to show rock b_1 times, show scissors b_2 times and show paper b_3 times. Though, both Alice and Bob did not choose the sequence in which they show things. It is guaranteed that a_1 + a_2 + a_3 = n and b_1 + b_2 + b_3 = n.
Your task is to find two numbers:
1. the minimum number of round Alice can win;
2. the maximum number of rounds Alice can win.
Input
The first line of the input contains one integer n (1 β€ n β€ 10^{9}) β the number of rounds.
The second line of the input contains three integers a_1, a_2, a_3 (0 β€ a_i β€ n) β the number of times Alice will show rock, scissors and paper, respectively. It is guaranteed that a_1 + a_2 + a_3 = n.
The third line of the input contains three integers b_1, b_2, b_3 (0 β€ b_j β€ n) β the number of times Bob will show rock, scissors and paper, respectively. It is guaranteed that b_1 + b_2 + b_3 = n.
Output
Print two integers: the minimum and the maximum number of rounds Alice can win.
Examples
Input
2
0 1 1
1 1 0
Output
0 1
Input
15
5 5 5
5 5 5
Output
0 15
Input
3
0 0 3
3 0 0
Output
3 3
Input
686
479 178 29
11 145 530
Output
22 334
Input
319
10 53 256
182 103 34
Output
119 226
Note
In the first example, Alice will not win any rounds if she shows scissors and then paper and Bob shows rock and then scissors. In the best outcome, Alice will win one round if she shows paper and then scissors, and Bob shows rock and then scissors.
In the second example, Alice will not win any rounds if Bob shows the same things as Alice each round.
In the third example, Alice always shows paper and Bob always shows rock so Alice will win all three rounds anyway.
Submitted Solution:
```
n = int(input())
a1, a2, a3 = map(int, input().split())
b1, b2, b3 = map(int, input().split())
x1, x2, x3 = a1, a2, a3
y1, y2, y3 = b1, b2, b3
d1, d2 = 0, 0
for i in range(n):
if a1 != 0 and b2 != 0:
d2 += 1
a1 -= 1
b2 -= 1
if a2 != 0 and b3 != 0:
d2 += 1
a2 -= 1
b3 -= 1
if a3 != 0 and b1 != 0:
d2 += 1
a3 -= 1
b1 -= 1
a1, a2, a3 = x1, x2, x3
b1, b2, b3 = y1, y2, y3
del x1, x2, x3, y1, y2, y3
for i in range(n):
if max(a1,a2,a3) == a1:
while a1 != 0 and b3 != 0:
a1 -= 1
b3 -= 1
elif max(a1,a2,a3) == a2:
while a2 != 0 and b1 != 0:
a2 -= 1
b1 -= 1
elif max(a1,a2,a3) == a3:
while a3 != 0 and b2 != 0:
a3 -= 1
b2 -= 1
for i in range(n):
if max(a1,a2,a3) == a1:
while a1 != 0 and b1 != 0:
a1 -= 1
b1 -= 1
elif max(a1,a2,a3) == a2:
while a2 != 0 and b2 != 0:
a2 -= 1
b2 -= 1
elif max(a1,a2,a3) == a3:
while a3 != 0 and b3 != 0:
a3 -= 1
b3 -= 1
for i in range(n):
if a1 != 0 and b2 != 0:
d1 += 1
a1 -= 1
b2 -= 1
if a2 != 0 and b3 != 0:
d1 += 1
a2 -= 1
b3 -= 1
if a3 != 0 and b1 != 0:
d1 += 1
a3 -= 1
b1 -= 1
print(d1,d2)
``` | instruction | 0 | 95,465 | 19 | 190,930 |
No | output | 1 | 95,465 | 19 | 190,931 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob have decided to play the game "Rock, Paper, Scissors".
The game consists of several rounds, each round is independent of each other. In each round, both players show one of the following things at the same time: rock, paper or scissors. If both players showed the same things then the round outcome is a draw. Otherwise, the following rules applied:
* if one player showed rock and the other one showed scissors, then the player who showed rock is considered the winner and the other one is considered the loser;
* if one player showed scissors and the other one showed paper, then the player who showed scissors is considered the winner and the other one is considered the loser;
* if one player showed paper and the other one showed rock, then the player who showed paper is considered the winner and the other one is considered the loser.
Alice and Bob decided to play exactly n rounds of the game described above. Alice decided to show rock a_1 times, show scissors a_2 times and show paper a_3 times. Bob decided to show rock b_1 times, show scissors b_2 times and show paper b_3 times. Though, both Alice and Bob did not choose the sequence in which they show things. It is guaranteed that a_1 + a_2 + a_3 = n and b_1 + b_2 + b_3 = n.
Your task is to find two numbers:
1. the minimum number of round Alice can win;
2. the maximum number of rounds Alice can win.
Input
The first line of the input contains one integer n (1 β€ n β€ 10^{9}) β the number of rounds.
The second line of the input contains three integers a_1, a_2, a_3 (0 β€ a_i β€ n) β the number of times Alice will show rock, scissors and paper, respectively. It is guaranteed that a_1 + a_2 + a_3 = n.
The third line of the input contains three integers b_1, b_2, b_3 (0 β€ b_j β€ n) β the number of times Bob will show rock, scissors and paper, respectively. It is guaranteed that b_1 + b_2 + b_3 = n.
Output
Print two integers: the minimum and the maximum number of rounds Alice can win.
Examples
Input
2
0 1 1
1 1 0
Output
0 1
Input
15
5 5 5
5 5 5
Output
0 15
Input
3
0 0 3
3 0 0
Output
3 3
Input
686
479 178 29
11 145 530
Output
22 334
Input
319
10 53 256
182 103 34
Output
119 226
Note
In the first example, Alice will not win any rounds if she shows scissors and then paper and Bob shows rock and then scissors. In the best outcome, Alice will win one round if she shows paper and then scissors, and Bob shows rock and then scissors.
In the second example, Alice will not win any rounds if Bob shows the same things as Alice each round.
In the third example, Alice always shows paper and Bob always shows rock so Alice will win all three rounds anyway.
Submitted Solution:
```
def main():
n = int(input())
r2, s2, p2 = map(int, input().split())
r1, s1, p1 = map(int, input().split())
ma = min(r1, p2)+min(s1, r2)+min(p1, s2)
if s2>=r1+s1:
mi = s2-r1-s1
else:
mi = n
k1 = max(0, s2-s1)
k2 = min(r1, s2)
c1 = r1-r2
c2 = p2-s1+s2
if k1<=c1:
mi = c1-min(k2, c1)
if k2>=c2:
mi = min(mi, c2-max(k1, c2))
if c2>c1+1 and (c2>k1 and c1<k2) or (k1>c1 and k2<c2):
mi = 0
print(mi, ma)
main()
``` | instruction | 0 | 95,466 | 19 | 190,932 |
No | output | 1 | 95,466 | 19 | 190,933 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob have decided to play the game "Rock, Paper, Scissors".
The game consists of several rounds, each round is independent of each other. In each round, both players show one of the following things at the same time: rock, paper or scissors. If both players showed the same things then the round outcome is a draw. Otherwise, the following rules applied:
* if one player showed rock and the other one showed scissors, then the player who showed rock is considered the winner and the other one is considered the loser;
* if one player showed scissors and the other one showed paper, then the player who showed scissors is considered the winner and the other one is considered the loser;
* if one player showed paper and the other one showed rock, then the player who showed paper is considered the winner and the other one is considered the loser.
Alice and Bob decided to play exactly n rounds of the game described above. Alice decided to show rock a_1 times, show scissors a_2 times and show paper a_3 times. Bob decided to show rock b_1 times, show scissors b_2 times and show paper b_3 times. Though, both Alice and Bob did not choose the sequence in which they show things. It is guaranteed that a_1 + a_2 + a_3 = n and b_1 + b_2 + b_3 = n.
Your task is to find two numbers:
1. the minimum number of round Alice can win;
2. the maximum number of rounds Alice can win.
Input
The first line of the input contains one integer n (1 β€ n β€ 10^{9}) β the number of rounds.
The second line of the input contains three integers a_1, a_2, a_3 (0 β€ a_i β€ n) β the number of times Alice will show rock, scissors and paper, respectively. It is guaranteed that a_1 + a_2 + a_3 = n.
The third line of the input contains three integers b_1, b_2, b_3 (0 β€ b_j β€ n) β the number of times Bob will show rock, scissors and paper, respectively. It is guaranteed that b_1 + b_2 + b_3 = n.
Output
Print two integers: the minimum and the maximum number of rounds Alice can win.
Examples
Input
2
0 1 1
1 1 0
Output
0 1
Input
15
5 5 5
5 5 5
Output
0 15
Input
3
0 0 3
3 0 0
Output
3 3
Input
686
479 178 29
11 145 530
Output
22 334
Input
319
10 53 256
182 103 34
Output
119 226
Note
In the first example, Alice will not win any rounds if she shows scissors and then paper and Bob shows rock and then scissors. In the best outcome, Alice will win one round if she shows paper and then scissors, and Bob shows rock and then scissors.
In the second example, Alice will not win any rounds if Bob shows the same things as Alice each round.
In the third example, Alice always shows paper and Bob always shows rock so Alice will win all three rounds anyway.
Submitted Solution:
```
def find_max_winning_rounds(p1,p2):
result=0
for i in range(3):
max_winnable=min(p1[i],p2[(i+1)%3])
result+=max_winnable
return result
def find_min_winning_rounds(p1,p2):
for i in range(3):
find_bigger_item_to_subtract(p2, i, p1)
result = 0
for i in range(3):
result += p1[i]
return result
def find_bigger_item_to_subtract(p2, i, p1):
if p2[(i+2)%3]>=p2[i]:
p1[i],p2[(i+2)%3]=sub(p1[i],p2[(i+2)%3])
if p1[i]>0:
p1[i],p2[i]=sub(p1[i],p2[i])
else:
p1[i],p2[i]=sub(p1[i],p2[i])
if p1[i]>0:
p1[i],p2[(i+2)%3]=sub(p1[i],p2[(i+2)%3])
def sub(a,b):
if a >= b:
return a-b,0
else:
return 0,b-a
rounds=int(input())
player1_strategy=list(map(int,input().split()))
player2_strategy=list(map(int,input().split()))
max_win=find_max_winning_rounds(player1_strategy,player2_strategy)
min_win=find_min_winning_rounds(player1_strategy,player2_strategy)
print(min_win,max_win)
``` | instruction | 0 | 95,467 | 19 | 190,934 |
No | output | 1 | 95,467 | 19 | 190,935 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob have decided to play the game "Rock, Paper, Scissors".
The game consists of several rounds, each round is independent of each other. In each round, both players show one of the following things at the same time: rock, paper or scissors. If both players showed the same things then the round outcome is a draw. Otherwise, the following rules applied:
* if one player showed rock and the other one showed scissors, then the player who showed rock is considered the winner and the other one is considered the loser;
* if one player showed scissors and the other one showed paper, then the player who showed scissors is considered the winner and the other one is considered the loser;
* if one player showed paper and the other one showed rock, then the player who showed paper is considered the winner and the other one is considered the loser.
Alice and Bob decided to play exactly n rounds of the game described above. Alice decided to show rock a_1 times, show scissors a_2 times and show paper a_3 times. Bob decided to show rock b_1 times, show scissors b_2 times and show paper b_3 times. Though, both Alice and Bob did not choose the sequence in which they show things. It is guaranteed that a_1 + a_2 + a_3 = n and b_1 + b_2 + b_3 = n.
Your task is to find two numbers:
1. the minimum number of round Alice can win;
2. the maximum number of rounds Alice can win.
Input
The first line of the input contains one integer n (1 β€ n β€ 10^{9}) β the number of rounds.
The second line of the input contains three integers a_1, a_2, a_3 (0 β€ a_i β€ n) β the number of times Alice will show rock, scissors and paper, respectively. It is guaranteed that a_1 + a_2 + a_3 = n.
The third line of the input contains three integers b_1, b_2, b_3 (0 β€ b_j β€ n) β the number of times Bob will show rock, scissors and paper, respectively. It is guaranteed that b_1 + b_2 + b_3 = n.
Output
Print two integers: the minimum and the maximum number of rounds Alice can win.
Examples
Input
2
0 1 1
1 1 0
Output
0 1
Input
15
5 5 5
5 5 5
Output
0 15
Input
3
0 0 3
3 0 0
Output
3 3
Input
686
479 178 29
11 145 530
Output
22 334
Input
319
10 53 256
182 103 34
Output
119 226
Note
In the first example, Alice will not win any rounds if she shows scissors and then paper and Bob shows rock and then scissors. In the best outcome, Alice will win one round if she shows paper and then scissors, and Bob shows rock and then scissors.
In the second example, Alice will not win any rounds if Bob shows the same things as Alice each round.
In the third example, Alice always shows paper and Bob always shows rock so Alice will win all three rounds anyway.
Submitted Solution:
```
n=int(input())
a1,a2,a3=map(int,input().split())
b1,b2,b3=map(int,input().split())
maxx=0
maxx=maxx+min(a1,b2)
maxx=maxx+min(a2,b3)
maxx=maxx+min(a3,b1)
minn=0
if (a1-b3)>0:
minn=minn+(a1-b3)
if (a2-b1)>0:
minn=minn+(a2-b1)
if (a3-b2)>0:
minn=minn+(a3-b2)
print(minn,maxx)
``` | instruction | 0 | 95,468 | 19 | 190,936 |
No | output | 1 | 95,468 | 19 | 190,937 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Yaroslav, Andrey and Roman can play cubes for hours and hours. But the game is for three, so when Roman doesn't show up, Yaroslav and Andrey play another game.
Roman leaves a word for each of them. Each word consists of 2Β·n binary characters "0" or "1". After that the players start moving in turns. Yaroslav moves first. During a move, a player must choose an integer from 1 to 2Β·n, which hasn't been chosen by anybody up to that moment. Then the player takes a piece of paper and writes out the corresponding character from his string.
Let's represent Yaroslav's word as s = s1s2... s2n. Similarly, let's represent Andrey's word as t = t1t2... t2n. Then, if Yaroslav choose number k during his move, then he is going to write out character sk on the piece of paper. Similarly, if Andrey choose number r during his move, then he is going to write out character tr on the piece of paper.
The game finishes when no player can make a move. After the game is over, Yaroslav makes some integer from the characters written on his piece of paper (Yaroslav can arrange these characters as he wants). Andrey does the same. The resulting numbers can contain leading zeroes. The person with the largest number wins. If the numbers are equal, the game ends with a draw.
You are given two strings s and t. Determine the outcome of the game provided that Yaroslav and Andrey play optimally well.
Input
The first line contains integer n (1 β€ n β€ 106). The second line contains string s β Yaroslav's word. The third line contains string t β Andrey's word.
It is guaranteed that both words consist of 2Β·n characters "0" and "1".
Output
Print "First", if both players play optimally well and Yaroslav wins. If Andrey wins, print "Second" and if the game ends with a draw, print "Draw". Print the words without the quotes.
Examples
Input
2
0111
0001
Output
First
Input
3
110110
001001
Output
First
Input
3
111000
000111
Output
Draw
Input
4
01010110
00101101
Output
First
Input
4
01100000
10010011
Output
Second | instruction | 0 | 95,587 | 19 | 191,174 |
Tags: games, greedy
Correct Solution:
```
"""
Author - Satwik Tiwari .
24th NOV , 2020 - Tuesday
"""
#===============================================================================================
#importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from functools import cmp_to_key
# from itertools import *
from heapq import *
from math import gcd, factorial,floor,ceil,sqrt
from copy import deepcopy
from collections import deque
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
#==============================================================================================
#fast I/O region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
#===============================================================================================
#some shortcuts
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def testcase(t):
for pp in range(t):
solve(pp)
def google(p):
print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(x, y, p) :
y%=(p-1) #not so sure about this. used when y>p-1. if p is prime.
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) : # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def ncr(n,r): return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
inf = pow(10,20)
mod = 10**9+7
#===============================================================================================
# code here ;))
def solve(case):
n = int(inp())
a = inp()
b = inp()
chck = [0]*4
for i in range(2*n):
chck[int(a[i]) + 2*int(b[i])] +=1
f = 0
s = 0
for i in range(n):
if(chck[3] > 0):
f+=1;chck[3]-=1
elif(chck[1]>0):
f+=1;chck[1]-=1
elif(chck[2]>0):
chck[2]-=1
else: chck[0]-=1
if(chck[3] > 0):
s+=1;chck[3]-=1
elif(chck[2]>0):
s+=1;chck[2]-=1
elif(chck[1]>0):
chck[1]-=1
else: chck[0]-=1
print('Draw' if f==s else ('First' if f>s else 'Second'))
testcase(1)
# testcase(int(inp()))
``` | output | 1 | 95,587 | 19 | 191,175 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Yaroslav, Andrey and Roman can play cubes for hours and hours. But the game is for three, so when Roman doesn't show up, Yaroslav and Andrey play another game.
Roman leaves a word for each of them. Each word consists of 2Β·n binary characters "0" or "1". After that the players start moving in turns. Yaroslav moves first. During a move, a player must choose an integer from 1 to 2Β·n, which hasn't been chosen by anybody up to that moment. Then the player takes a piece of paper and writes out the corresponding character from his string.
Let's represent Yaroslav's word as s = s1s2... s2n. Similarly, let's represent Andrey's word as t = t1t2... t2n. Then, if Yaroslav choose number k during his move, then he is going to write out character sk on the piece of paper. Similarly, if Andrey choose number r during his move, then he is going to write out character tr on the piece of paper.
The game finishes when no player can make a move. After the game is over, Yaroslav makes some integer from the characters written on his piece of paper (Yaroslav can arrange these characters as he wants). Andrey does the same. The resulting numbers can contain leading zeroes. The person with the largest number wins. If the numbers are equal, the game ends with a draw.
You are given two strings s and t. Determine the outcome of the game provided that Yaroslav and Andrey play optimally well.
Input
The first line contains integer n (1 β€ n β€ 106). The second line contains string s β Yaroslav's word. The third line contains string t β Andrey's word.
It is guaranteed that both words consist of 2Β·n characters "0" and "1".
Output
Print "First", if both players play optimally well and Yaroslav wins. If Andrey wins, print "Second" and if the game ends with a draw, print "Draw". Print the words without the quotes.
Examples
Input
2
0111
0001
Output
First
Input
3
110110
001001
Output
First
Input
3
111000
000111
Output
Draw
Input
4
01010110
00101101
Output
First
Input
4
01100000
10010011
Output
Second | instruction | 0 | 95,588 | 19 | 191,176 |
Tags: games, greedy
Correct Solution:
```
n = int(input())
a, b = input(), input()
t = {i + j: 0 for i in '01' for j in '01'}
for i in range(2 * n): t[a[i] + b[i]] += 1
d = t['11'] & 1
d += (t['10'] - t['01'] + 1 - d) // 2
if d > 0: d = 1
elif d < 0: d = 2
print(['Draw', 'First', 'Second'][d])
``` | output | 1 | 95,588 | 19 | 191,177 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Yaroslav, Andrey and Roman can play cubes for hours and hours. But the game is for three, so when Roman doesn't show up, Yaroslav and Andrey play another game.
Roman leaves a word for each of them. Each word consists of 2Β·n binary characters "0" or "1". After that the players start moving in turns. Yaroslav moves first. During a move, a player must choose an integer from 1 to 2Β·n, which hasn't been chosen by anybody up to that moment. Then the player takes a piece of paper and writes out the corresponding character from his string.
Let's represent Yaroslav's word as s = s1s2... s2n. Similarly, let's represent Andrey's word as t = t1t2... t2n. Then, if Yaroslav choose number k during his move, then he is going to write out character sk on the piece of paper. Similarly, if Andrey choose number r during his move, then he is going to write out character tr on the piece of paper.
The game finishes when no player can make a move. After the game is over, Yaroslav makes some integer from the characters written on his piece of paper (Yaroslav can arrange these characters as he wants). Andrey does the same. The resulting numbers can contain leading zeroes. The person with the largest number wins. If the numbers are equal, the game ends with a draw.
You are given two strings s and t. Determine the outcome of the game provided that Yaroslav and Andrey play optimally well.
Input
The first line contains integer n (1 β€ n β€ 106). The second line contains string s β Yaroslav's word. The third line contains string t β Andrey's word.
It is guaranteed that both words consist of 2Β·n characters "0" and "1".
Output
Print "First", if both players play optimally well and Yaroslav wins. If Andrey wins, print "Second" and if the game ends with a draw, print "Draw". Print the words without the quotes.
Examples
Input
2
0111
0001
Output
First
Input
3
110110
001001
Output
First
Input
3
111000
000111
Output
Draw
Input
4
01010110
00101101
Output
First
Input
4
01100000
10010011
Output
Second | instruction | 0 | 95,589 | 19 | 191,178 |
Tags: games, greedy
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
##########################################################
##########################################################
from collections import Counter
# c=sorted((i,int(val))for i,val in enumerate(input().split()))
import heapq
# c=sorted((i,int(val))for i,val in enumerate(input().split()))
# n = int(input())
# ls = list(map(int, input().split()))
# n, k = map(int, input().split())
# n =int(input())
# e=list(map(int, input().split()))
from collections import Counter
#print("\n".join(ls))
#print(os.path.commonprefix(ls[0:2]))
#for _ in range(int(input())):
#for _ in range(int(input())):
n=int(input())
s=input()
t=input()
both=0
only_a=0
only_b=0
for i in range(2*n):
if s[i]=="1" and t[i]=="1":
both+=1
else:
if s[i]=="1":
only_a+=1
if t[i]=="1":
only_b+=1
a=0
b=0
for i in range(n):
if both:
a+=1
both-=1
elif only_a:
only_a-=1
a+=1
elif only_b:
only_b-=1
if both:
both-=1
b+=1
elif only_b:
b+=1
only_b-=1
elif only_a:
only_a-=1
if a>b:
print("First")
elif a==b:
print("Draw")
else:
print("Second")
``` | output | 1 | 95,589 | 19 | 191,179 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Yaroslav, Andrey and Roman can play cubes for hours and hours. But the game is for three, so when Roman doesn't show up, Yaroslav and Andrey play another game.
Roman leaves a word for each of them. Each word consists of 2Β·n binary characters "0" or "1". After that the players start moving in turns. Yaroslav moves first. During a move, a player must choose an integer from 1 to 2Β·n, which hasn't been chosen by anybody up to that moment. Then the player takes a piece of paper and writes out the corresponding character from his string.
Let's represent Yaroslav's word as s = s1s2... s2n. Similarly, let's represent Andrey's word as t = t1t2... t2n. Then, if Yaroslav choose number k during his move, then he is going to write out character sk on the piece of paper. Similarly, if Andrey choose number r during his move, then he is going to write out character tr on the piece of paper.
The game finishes when no player can make a move. After the game is over, Yaroslav makes some integer from the characters written on his piece of paper (Yaroslav can arrange these characters as he wants). Andrey does the same. The resulting numbers can contain leading zeroes. The person with the largest number wins. If the numbers are equal, the game ends with a draw.
You are given two strings s and t. Determine the outcome of the game provided that Yaroslav and Andrey play optimally well.
Input
The first line contains integer n (1 β€ n β€ 106). The second line contains string s β Yaroslav's word. The third line contains string t β Andrey's word.
It is guaranteed that both words consist of 2Β·n characters "0" and "1".
Output
Print "First", if both players play optimally well and Yaroslav wins. If Andrey wins, print "Second" and if the game ends with a draw, print "Draw". Print the words without the quotes.
Examples
Input
2
0111
0001
Output
First
Input
3
110110
001001
Output
First
Input
3
111000
000111
Output
Draw
Input
4
01010110
00101101
Output
First
Input
4
01100000
10010011
Output
Second | instruction | 0 | 95,590 | 19 | 191,180 |
Tags: games, greedy
Correct Solution:
```
from sys import stdin
#def read(): return map(int, stdin.readline().split())
n = int(stdin.readline())
a = stdin.readline()
b = stdin.readline()
cnt0 = 0
cnt1 = 0
cnt2 = 0
for i in range(n*2):
if a[i] == '0':
if b[i] == '0': cnt0 += 1
else: cnt1 += 1
elif b[i] == '0': cnt2 += 1
cnt = [ cnt0, cnt1, cnt2, 2*n - cnt0 - cnt1 - cnt2 ]
dif = 0
iter1 = iter ( ( 0b11, 0b10, 0b01, 0b00 ) )
iter2 = iter ( ( 0b11, 0b01, 0b10, 0b00 ) )
cur1 = next(iter1)
cur2 = next(iter2)
left = n
while left > 0:
while cnt[cur1] == 0:
cur1 = next(iter1)
dif += (cur1>>1)
cnt[cur1] -= 1
while cnt[cur2] == 0:
cur2 = next(iter2)
dif -= (cur2&1)
cnt[cur2] -= 1
jump = min ( cnt[cur1], cnt[cur2] ) if cur1 != cur2 else cnt[cur1]//2
dif += ( (cur1>>1) - (cur2&1) )*jump
cnt[cur1] -= jump
cnt[cur2] -= jump
left -= jump+1
if dif > 0: print( "First" )
elif dif < 0: print ( "Second" )
else: print ( "Draw" )
``` | output | 1 | 95,590 | 19 | 191,181 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Yaroslav, Andrey and Roman can play cubes for hours and hours. But the game is for three, so when Roman doesn't show up, Yaroslav and Andrey play another game.
Roman leaves a word for each of them. Each word consists of 2Β·n binary characters "0" or "1". After that the players start moving in turns. Yaroslav moves first. During a move, a player must choose an integer from 1 to 2Β·n, which hasn't been chosen by anybody up to that moment. Then the player takes a piece of paper and writes out the corresponding character from his string.
Let's represent Yaroslav's word as s = s1s2... s2n. Similarly, let's represent Andrey's word as t = t1t2... t2n. Then, if Yaroslav choose number k during his move, then he is going to write out character sk on the piece of paper. Similarly, if Andrey choose number r during his move, then he is going to write out character tr on the piece of paper.
The game finishes when no player can make a move. After the game is over, Yaroslav makes some integer from the characters written on his piece of paper (Yaroslav can arrange these characters as he wants). Andrey does the same. The resulting numbers can contain leading zeroes. The person with the largest number wins. If the numbers are equal, the game ends with a draw.
You are given two strings s and t. Determine the outcome of the game provided that Yaroslav and Andrey play optimally well.
Input
The first line contains integer n (1 β€ n β€ 106). The second line contains string s β Yaroslav's word. The third line contains string t β Andrey's word.
It is guaranteed that both words consist of 2Β·n characters "0" and "1".
Output
Print "First", if both players play optimally well and Yaroslav wins. If Andrey wins, print "Second" and if the game ends with a draw, print "Draw". Print the words without the quotes.
Examples
Input
2
0111
0001
Output
First
Input
3
110110
001001
Output
First
Input
3
111000
000111
Output
Draw
Input
4
01010110
00101101
Output
First
Input
4
01100000
10010011
Output
Second | instruction | 0 | 95,591 | 19 | 191,182 |
Tags: games, greedy
Correct Solution:
```
ii=lambda:int(input())
kk=lambda:map(int,input().split())
ll=lambda:list(kk())
n,a1,a2=ii(),input(),input()
locs = [0]*4
for i in range(2*n):
locs[int(a1[i])+2*int(a2[i])]+=1
rm = min(locs[1],locs[2])
locs[1]-=rm
locs[2]-=rm
locs[3]=locs[3]&1
if locs[1]:
print("First")
else:
if locs[3]:
if locs[2]==0:
print("First")
elif locs[2]<3:
print("Draw")
else:
print("Second")
else:
if locs[2]<2:
print("Draw")
else:
print("Second")
``` | output | 1 | 95,591 | 19 | 191,183 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.