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.
The Smart Beaver from ABBYY decided to have a day off. But doing nothing the whole day turned out to be too boring, and he decided to play a game with pebbles. Initially, the Beaver has n pebbles. He arranges them in a equal rows, each row has b pebbles (a > 1). Note that the Beaver must use all the pebbles he has, i. e. n = a·b.
<image> 10 pebbles are arranged in two rows, each row has 5 pebbles
Once the Smart Beaver has arranged the pebbles, he takes back any of the resulting rows (that is, b pebbles) and discards all other pebbles. Then he arranges all his pebbles again (possibly choosing other values of a and b) and takes back one row, and so on. The game continues until at some point the Beaver ends up with exactly one pebble.
The game process can be represented as a finite sequence of integers c1, ..., ck, where:
* c1 = n
* ci + 1 is the number of pebbles that the Beaver ends up with after the i-th move, that is, the number of pebbles in a row after some arrangement of ci pebbles (1 ≤ i < k). Note that ci > ci + 1.
* ck = 1
The result of the game is the sum of numbers ci. You are given n. Find the maximum possible result of the game.
Input
The single line of the input contains a single integer n — the initial number of pebbles the Smart Beaver has.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 50
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 109
Output
Print a single number — the maximum possible result of the game.
Examples
Input
10
Output
16
Input
8
Output
15
Note
Consider the first example (c1 = 10). The possible options for the game development are:
* Arrange the pebbles in 10 rows, one pebble per row. Then c2 = 1, and the game ends after the first move with the result of 11.
* Arrange the pebbles in 5 rows, two pebbles per row. Then c2 = 2, and the game continues. During the second move we have two pebbles which can be arranged in a unique way (remember that you are not allowed to put all the pebbles in the same row!) — 2 rows, one pebble per row. c3 = 1, and the game ends with the result of 13.
* Finally, arrange the pebbles in two rows, five pebbles per row. The same logic leads us to c2 = 5, c3 = 1, and the game ends with the result of 16 — the maximum possible result. | instruction | 0 | 91,188 | 19 | 182,376 |
Tags: number theory
Correct Solution:
```
a=int(input())
c=a
while(a>1):
for i in range(1000000000):
if(a%(i+2)==0):
c+=(a/(i+2))
a=a/(i+2)
break
c=int(c)
print(c)
``` | output | 1 | 91,188 | 19 | 182,377 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Smart Beaver from ABBYY decided to have a day off. But doing nothing the whole day turned out to be too boring, and he decided to play a game with pebbles. Initially, the Beaver has n pebbles. He arranges them in a equal rows, each row has b pebbles (a > 1). Note that the Beaver must use all the pebbles he has, i. e. n = a·b.
<image> 10 pebbles are arranged in two rows, each row has 5 pebbles
Once the Smart Beaver has arranged the pebbles, he takes back any of the resulting rows (that is, b pebbles) and discards all other pebbles. Then he arranges all his pebbles again (possibly choosing other values of a and b) and takes back one row, and so on. The game continues until at some point the Beaver ends up with exactly one pebble.
The game process can be represented as a finite sequence of integers c1, ..., ck, where:
* c1 = n
* ci + 1 is the number of pebbles that the Beaver ends up with after the i-th move, that is, the number of pebbles in a row after some arrangement of ci pebbles (1 ≤ i < k). Note that ci > ci + 1.
* ck = 1
The result of the game is the sum of numbers ci. You are given n. Find the maximum possible result of the game.
Input
The single line of the input contains a single integer n — the initial number of pebbles the Smart Beaver has.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 50
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 109
Output
Print a single number — the maximum possible result of the game.
Examples
Input
10
Output
16
Input
8
Output
15
Note
Consider the first example (c1 = 10). The possible options for the game development are:
* Arrange the pebbles in 10 rows, one pebble per row. Then c2 = 1, and the game ends after the first move with the result of 11.
* Arrange the pebbles in 5 rows, two pebbles per row. Then c2 = 2, and the game continues. During the second move we have two pebbles which can be arranged in a unique way (remember that you are not allowed to put all the pebbles in the same row!) — 2 rows, one pebble per row. c3 = 1, and the game ends with the result of 13.
* Finally, arrange the pebbles in two rows, five pebbles per row. The same logic leads us to c2 = 5, c3 = 1, and the game ends with the result of 16 — the maximum possible result. | instruction | 0 | 91,189 | 19 | 182,378 |
Tags: number theory
Correct Solution:
```
n=int(input())
sum=n
while n!=1:
for i in range(2,n+1):
if n%i==0:
n//=i
break
sum+=n
print(sum)
``` | output | 1 | 91,189 | 19 | 182,379 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Smart Beaver from ABBYY decided to have a day off. But doing nothing the whole day turned out to be too boring, and he decided to play a game with pebbles. Initially, the Beaver has n pebbles. He arranges them in a equal rows, each row has b pebbles (a > 1). Note that the Beaver must use all the pebbles he has, i. e. n = a·b.
<image> 10 pebbles are arranged in two rows, each row has 5 pebbles
Once the Smart Beaver has arranged the pebbles, he takes back any of the resulting rows (that is, b pebbles) and discards all other pebbles. Then he arranges all his pebbles again (possibly choosing other values of a and b) and takes back one row, and so on. The game continues until at some point the Beaver ends up with exactly one pebble.
The game process can be represented as a finite sequence of integers c1, ..., ck, where:
* c1 = n
* ci + 1 is the number of pebbles that the Beaver ends up with after the i-th move, that is, the number of pebbles in a row after some arrangement of ci pebbles (1 ≤ i < k). Note that ci > ci + 1.
* ck = 1
The result of the game is the sum of numbers ci. You are given n. Find the maximum possible result of the game.
Input
The single line of the input contains a single integer n — the initial number of pebbles the Smart Beaver has.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 50
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 109
Output
Print a single number — the maximum possible result of the game.
Examples
Input
10
Output
16
Input
8
Output
15
Note
Consider the first example (c1 = 10). The possible options for the game development are:
* Arrange the pebbles in 10 rows, one pebble per row. Then c2 = 1, and the game ends after the first move with the result of 11.
* Arrange the pebbles in 5 rows, two pebbles per row. Then c2 = 2, and the game continues. During the second move we have two pebbles which can be arranged in a unique way (remember that you are not allowed to put all the pebbles in the same row!) — 2 rows, one pebble per row. c3 = 1, and the game ends with the result of 13.
* Finally, arrange the pebbles in two rows, five pebbles per row. The same logic leads us to c2 = 5, c3 = 1, and the game ends with the result of 16 — the maximum possible result. | instruction | 0 | 91,190 | 19 | 182,380 |
Tags: number theory
Correct Solution:
```
n=int(input())
sum=n
b=0
while(b!=1):
for i in range(2,n+1):
if(n%i==0):
b=n//i
break
sum=sum+b
n=b
print(sum)
``` | output | 1 | 91,190 | 19 | 182,381 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Smart Beaver from ABBYY decided to have a day off. But doing nothing the whole day turned out to be too boring, and he decided to play a game with pebbles. Initially, the Beaver has n pebbles. He arranges them in a equal rows, each row has b pebbles (a > 1). Note that the Beaver must use all the pebbles he has, i. e. n = a·b.
<image> 10 pebbles are arranged in two rows, each row has 5 pebbles
Once the Smart Beaver has arranged the pebbles, he takes back any of the resulting rows (that is, b pebbles) and discards all other pebbles. Then he arranges all his pebbles again (possibly choosing other values of a and b) and takes back one row, and so on. The game continues until at some point the Beaver ends up with exactly one pebble.
The game process can be represented as a finite sequence of integers c1, ..., ck, where:
* c1 = n
* ci + 1 is the number of pebbles that the Beaver ends up with after the i-th move, that is, the number of pebbles in a row after some arrangement of ci pebbles (1 ≤ i < k). Note that ci > ci + 1.
* ck = 1
The result of the game is the sum of numbers ci. You are given n. Find the maximum possible result of the game.
Input
The single line of the input contains a single integer n — the initial number of pebbles the Smart Beaver has.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 50
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 109
Output
Print a single number — the maximum possible result of the game.
Examples
Input
10
Output
16
Input
8
Output
15
Note
Consider the first example (c1 = 10). The possible options for the game development are:
* Arrange the pebbles in 10 rows, one pebble per row. Then c2 = 1, and the game ends after the first move with the result of 11.
* Arrange the pebbles in 5 rows, two pebbles per row. Then c2 = 2, and the game continues. During the second move we have two pebbles which can be arranged in a unique way (remember that you are not allowed to put all the pebbles in the same row!) — 2 rows, one pebble per row. c3 = 1, and the game ends with the result of 13.
* Finally, arrange the pebbles in two rows, five pebbles per row. The same logic leads us to c2 = 5, c3 = 1, and the game ends with the result of 16 — the maximum possible result. | instruction | 0 | 91,191 | 19 | 182,382 |
Tags: number theory
Correct Solution:
```
N = int(input())
sum = N
for j in range(2,N+1):
while N % j == 0:
N //= j
sum += N
print(sum)
``` | output | 1 | 91,191 | 19 | 182,383 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Smart Beaver from ABBYY decided to have a day off. But doing nothing the whole day turned out to be too boring, and he decided to play a game with pebbles. Initially, the Beaver has n pebbles. He arranges them in a equal rows, each row has b pebbles (a > 1). Note that the Beaver must use all the pebbles he has, i. e. n = a·b.
<image> 10 pebbles are arranged in two rows, each row has 5 pebbles
Once the Smart Beaver has arranged the pebbles, he takes back any of the resulting rows (that is, b pebbles) and discards all other pebbles. Then he arranges all his pebbles again (possibly choosing other values of a and b) and takes back one row, and so on. The game continues until at some point the Beaver ends up with exactly one pebble.
The game process can be represented as a finite sequence of integers c1, ..., ck, where:
* c1 = n
* ci + 1 is the number of pebbles that the Beaver ends up with after the i-th move, that is, the number of pebbles in a row after some arrangement of ci pebbles (1 ≤ i < k). Note that ci > ci + 1.
* ck = 1
The result of the game is the sum of numbers ci. You are given n. Find the maximum possible result of the game.
Input
The single line of the input contains a single integer n — the initial number of pebbles the Smart Beaver has.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 50
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 109
Output
Print a single number — the maximum possible result of the game.
Examples
Input
10
Output
16
Input
8
Output
15
Note
Consider the first example (c1 = 10). The possible options for the game development are:
* Arrange the pebbles in 10 rows, one pebble per row. Then c2 = 1, and the game ends after the first move with the result of 11.
* Arrange the pebbles in 5 rows, two pebbles per row. Then c2 = 2, and the game continues. During the second move we have two pebbles which can be arranged in a unique way (remember that you are not allowed to put all the pebbles in the same row!) — 2 rows, one pebble per row. c3 = 1, and the game ends with the result of 13.
* Finally, arrange the pebbles in two rows, five pebbles per row. The same logic leads us to c2 = 5, c3 = 1, and the game ends with the result of 16 — the maximum possible result. | instruction | 0 | 91,192 | 19 | 182,384 |
Tags: number theory
Correct Solution:
```
def maxsum(n):
ans = 0
while(n>1):
ans+=n
for i in range(2,n+1):
if n%i == 0:
n = n//i
break
return ans+1
n = int(input())
print(maxsum(n))
``` | output | 1 | 91,192 | 19 | 182,385 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Smart Beaver from ABBYY decided to have a day off. But doing nothing the whole day turned out to be too boring, and he decided to play a game with pebbles. Initially, the Beaver has n pebbles. He arranges them in a equal rows, each row has b pebbles (a > 1). Note that the Beaver must use all the pebbles he has, i. e. n = a·b.
<image> 10 pebbles are arranged in two rows, each row has 5 pebbles
Once the Smart Beaver has arranged the pebbles, he takes back any of the resulting rows (that is, b pebbles) and discards all other pebbles. Then he arranges all his pebbles again (possibly choosing other values of a and b) and takes back one row, and so on. The game continues until at some point the Beaver ends up with exactly one pebble.
The game process can be represented as a finite sequence of integers c1, ..., ck, where:
* c1 = n
* ci + 1 is the number of pebbles that the Beaver ends up with after the i-th move, that is, the number of pebbles in a row after some arrangement of ci pebbles (1 ≤ i < k). Note that ci > ci + 1.
* ck = 1
The result of the game is the sum of numbers ci. You are given n. Find the maximum possible result of the game.
Input
The single line of the input contains a single integer n — the initial number of pebbles the Smart Beaver has.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 50
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 109
Output
Print a single number — the maximum possible result of the game.
Examples
Input
10
Output
16
Input
8
Output
15
Note
Consider the first example (c1 = 10). The possible options for the game development are:
* Arrange the pebbles in 10 rows, one pebble per row. Then c2 = 1, and the game ends after the first move with the result of 11.
* Arrange the pebbles in 5 rows, two pebbles per row. Then c2 = 2, and the game continues. During the second move we have two pebbles which can be arranged in a unique way (remember that you are not allowed to put all the pebbles in the same row!) — 2 rows, one pebble per row. c3 = 1, and the game ends with the result of 13.
* Finally, arrange the pebbles in two rows, five pebbles per row. The same logic leads us to c2 = 5, c3 = 1, and the game ends with the result of 16 — the maximum possible result. | instruction | 0 | 91,193 | 19 | 182,386 |
Tags: number theory
Correct Solution:
```
n=int(input())
b = 0
sum=n
while b!=1:
for i in range(2,n+1):
if i==n:
b=1
break
if n%i==0:
a=i
b=int(n/a)
break
sum=sum+b
n=b
print(sum)
``` | output | 1 | 91,193 | 19 | 182,387 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Smart Beaver from ABBYY decided to have a day off. But doing nothing the whole day turned out to be too boring, and he decided to play a game with pebbles. Initially, the Beaver has n pebbles. He arranges them in a equal rows, each row has b pebbles (a > 1). Note that the Beaver must use all the pebbles he has, i. e. n = a·b.
<image> 10 pebbles are arranged in two rows, each row has 5 pebbles
Once the Smart Beaver has arranged the pebbles, he takes back any of the resulting rows (that is, b pebbles) and discards all other pebbles. Then he arranges all his pebbles again (possibly choosing other values of a and b) and takes back one row, and so on. The game continues until at some point the Beaver ends up with exactly one pebble.
The game process can be represented as a finite sequence of integers c1, ..., ck, where:
* c1 = n
* ci + 1 is the number of pebbles that the Beaver ends up with after the i-th move, that is, the number of pebbles in a row after some arrangement of ci pebbles (1 ≤ i < k). Note that ci > ci + 1.
* ck = 1
The result of the game is the sum of numbers ci. You are given n. Find the maximum possible result of the game.
Input
The single line of the input contains a single integer n — the initial number of pebbles the Smart Beaver has.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 50
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 109
Output
Print a single number — the maximum possible result of the game.
Examples
Input
10
Output
16
Input
8
Output
15
Note
Consider the first example (c1 = 10). The possible options for the game development are:
* Arrange the pebbles in 10 rows, one pebble per row. Then c2 = 1, and the game ends after the first move with the result of 11.
* Arrange the pebbles in 5 rows, two pebbles per row. Then c2 = 2, and the game continues. During the second move we have two pebbles which can be arranged in a unique way (remember that you are not allowed to put all the pebbles in the same row!) — 2 rows, one pebble per row. c3 = 1, and the game ends with the result of 13.
* Finally, arrange the pebbles in two rows, five pebbles per row. The same logic leads us to c2 = 5, c3 = 1, and the game ends with the result of 16 — the maximum possible result.
Submitted Solution:
```
import math
primes=[2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,
61,67,71,73,79,83,89,97,101,103,107,109,113,127,
131,137,139,149,151,157,163,167,173,179,181,191,
193,197,199,211,223,227,229,233,239,241,251,257,
263,269,271,277,281,293, 307, 311, 313, 317, 331, 337, 347, 349,
353,359 ,367,373,379,383,389,397,401,409,419, 421, 431 ,433 ,439 ,443 ,449 ,457 ,461 ,463
,467 ,479 ,487 ,491 ,499 ,503 ,509 ,521 ,523 ,541
,547 ,557 ,563 ,569 ,571 ,577 ,587 ,593 ,599 ,601
,607 ,613 ,617 ,619 ,631 ,641 ,643 ,647 ,653 ,659
,661 ,673 ,677 ,683 ,691 ,701 ,709 ,719 ,727 ,733
,739 ,743 ,751 ,757 ,761 ,769 ,773 ,787 ,797 ,809
,811 ,821 ,823 ,827 ,829 ,839 ,853 ,857 ,859 ,863
,877 ,881 ,883 ,887 ,907 ,911 ,919 ,929 ,937 ,941
,947 ,953 ,967 ,971 ,977 ,983 ,991 ,997 ,1009 ,1013
,1019 ,1021 ,1031 ,1033 ,1039 ,1049 ,1051 ,1061 ,1063, 1069
,1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151
,1153, 1163, 1171, 1181,11897,36709, 1187, 1193, 1201, 1213, 1217,31607]
n=int(input())
tot=n
for i in range(len(primes)):
while n%primes[i]==0:
tot+=n//primes[i]
n=n//primes[i]
if n==1:
print(tot)
else:
print(tot+1)
``` | instruction | 0 | 91,194 | 19 | 182,388 |
Yes | output | 1 | 91,194 | 19 | 182,389 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Smart Beaver from ABBYY decided to have a day off. But doing nothing the whole day turned out to be too boring, and he decided to play a game with pebbles. Initially, the Beaver has n pebbles. He arranges them in a equal rows, each row has b pebbles (a > 1). Note that the Beaver must use all the pebbles he has, i. e. n = a·b.
<image> 10 pebbles are arranged in two rows, each row has 5 pebbles
Once the Smart Beaver has arranged the pebbles, he takes back any of the resulting rows (that is, b pebbles) and discards all other pebbles. Then he arranges all his pebbles again (possibly choosing other values of a and b) and takes back one row, and so on. The game continues until at some point the Beaver ends up with exactly one pebble.
The game process can be represented as a finite sequence of integers c1, ..., ck, where:
* c1 = n
* ci + 1 is the number of pebbles that the Beaver ends up with after the i-th move, that is, the number of pebbles in a row after some arrangement of ci pebbles (1 ≤ i < k). Note that ci > ci + 1.
* ck = 1
The result of the game is the sum of numbers ci. You are given n. Find the maximum possible result of the game.
Input
The single line of the input contains a single integer n — the initial number of pebbles the Smart Beaver has.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 50
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 109
Output
Print a single number — the maximum possible result of the game.
Examples
Input
10
Output
16
Input
8
Output
15
Note
Consider the first example (c1 = 10). The possible options for the game development are:
* Arrange the pebbles in 10 rows, one pebble per row. Then c2 = 1, and the game ends after the first move with the result of 11.
* Arrange the pebbles in 5 rows, two pebbles per row. Then c2 = 2, and the game continues. During the second move we have two pebbles which can be arranged in a unique way (remember that you are not allowed to put all the pebbles in the same row!) — 2 rows, one pebble per row. c3 = 1, and the game ends with the result of 13.
* Finally, arrange the pebbles in two rows, five pebbles per row. The same logic leads us to c2 = 5, c3 = 1, and the game ends with the result of 16 — the maximum possible result.
Submitted Solution:
```
import math
def f(n):
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
return n // i
return 1
n = int(input())
ans, b = n, n
while b != 1:
b = f(b)
ans += b
print(ans)
``` | instruction | 0 | 91,195 | 19 | 182,390 |
Yes | output | 1 | 91,195 | 19 | 182,391 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Smart Beaver from ABBYY decided to have a day off. But doing nothing the whole day turned out to be too boring, and he decided to play a game with pebbles. Initially, the Beaver has n pebbles. He arranges them in a equal rows, each row has b pebbles (a > 1). Note that the Beaver must use all the pebbles he has, i. e. n = a·b.
<image> 10 pebbles are arranged in two rows, each row has 5 pebbles
Once the Smart Beaver has arranged the pebbles, he takes back any of the resulting rows (that is, b pebbles) and discards all other pebbles. Then he arranges all his pebbles again (possibly choosing other values of a and b) and takes back one row, and so on. The game continues until at some point the Beaver ends up with exactly one pebble.
The game process can be represented as a finite sequence of integers c1, ..., ck, where:
* c1 = n
* ci + 1 is the number of pebbles that the Beaver ends up with after the i-th move, that is, the number of pebbles in a row after some arrangement of ci pebbles (1 ≤ i < k). Note that ci > ci + 1.
* ck = 1
The result of the game is the sum of numbers ci. You are given n. Find the maximum possible result of the game.
Input
The single line of the input contains a single integer n — the initial number of pebbles the Smart Beaver has.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 50
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 109
Output
Print a single number — the maximum possible result of the game.
Examples
Input
10
Output
16
Input
8
Output
15
Note
Consider the first example (c1 = 10). The possible options for the game development are:
* Arrange the pebbles in 10 rows, one pebble per row. Then c2 = 1, and the game ends after the first move with the result of 11.
* Arrange the pebbles in 5 rows, two pebbles per row. Then c2 = 2, and the game continues. During the second move we have two pebbles which can be arranged in a unique way (remember that you are not allowed to put all the pebbles in the same row!) — 2 rows, one pebble per row. c3 = 1, and the game ends with the result of 13.
* Finally, arrange the pebbles in two rows, five pebbles per row. The same logic leads us to c2 = 5, c3 = 1, and the game ends with the result of 16 — the maximum possible result.
Submitted Solution:
```
import math
n = int(input())
result = 0
num = 2
sqrt_n = math.sqrt(n)
result += n
while num <= sqrt_n:
if n % num == 0:
result += n // num
n //= num
sqrt_n = math.sqrt(n)
num = 1
num += 1
result += 1
print(result)
``` | instruction | 0 | 91,196 | 19 | 182,392 |
Yes | output | 1 | 91,196 | 19 | 182,393 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Smart Beaver from ABBYY decided to have a day off. But doing nothing the whole day turned out to be too boring, and he decided to play a game with pebbles. Initially, the Beaver has n pebbles. He arranges them in a equal rows, each row has b pebbles (a > 1). Note that the Beaver must use all the pebbles he has, i. e. n = a·b.
<image> 10 pebbles are arranged in two rows, each row has 5 pebbles
Once the Smart Beaver has arranged the pebbles, he takes back any of the resulting rows (that is, b pebbles) and discards all other pebbles. Then he arranges all his pebbles again (possibly choosing other values of a and b) and takes back one row, and so on. The game continues until at some point the Beaver ends up with exactly one pebble.
The game process can be represented as a finite sequence of integers c1, ..., ck, where:
* c1 = n
* ci + 1 is the number of pebbles that the Beaver ends up with after the i-th move, that is, the number of pebbles in a row after some arrangement of ci pebbles (1 ≤ i < k). Note that ci > ci + 1.
* ck = 1
The result of the game is the sum of numbers ci. You are given n. Find the maximum possible result of the game.
Input
The single line of the input contains a single integer n — the initial number of pebbles the Smart Beaver has.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 50
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 109
Output
Print a single number — the maximum possible result of the game.
Examples
Input
10
Output
16
Input
8
Output
15
Note
Consider the first example (c1 = 10). The possible options for the game development are:
* Arrange the pebbles in 10 rows, one pebble per row. Then c2 = 1, and the game ends after the first move with the result of 11.
* Arrange the pebbles in 5 rows, two pebbles per row. Then c2 = 2, and the game continues. During the second move we have two pebbles which can be arranged in a unique way (remember that you are not allowed to put all the pebbles in the same row!) — 2 rows, one pebble per row. c3 = 1, and the game ends with the result of 13.
* Finally, arrange the pebbles in two rows, five pebbles per row. The same logic leads us to c2 = 5, c3 = 1, and the game ends with the result of 16 — the maximum possible result.
Submitted Solution:
```
n=int(input())
ans=n
while n>1:
f=0
for ff in range(2,n):
if n%ff==0:
f=max(f,max(ff,n//ff))
if f==0:
ans+=1
break
ans+=f
n=f
print(ans)
``` | instruction | 0 | 91,197 | 19 | 182,394 |
Yes | output | 1 | 91,197 | 19 | 182,395 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Smart Beaver from ABBYY decided to have a day off. But doing nothing the whole day turned out to be too boring, and he decided to play a game with pebbles. Initially, the Beaver has n pebbles. He arranges them in a equal rows, each row has b pebbles (a > 1). Note that the Beaver must use all the pebbles he has, i. e. n = a·b.
<image> 10 pebbles are arranged in two rows, each row has 5 pebbles
Once the Smart Beaver has arranged the pebbles, he takes back any of the resulting rows (that is, b pebbles) and discards all other pebbles. Then he arranges all his pebbles again (possibly choosing other values of a and b) and takes back one row, and so on. The game continues until at some point the Beaver ends up with exactly one pebble.
The game process can be represented as a finite sequence of integers c1, ..., ck, where:
* c1 = n
* ci + 1 is the number of pebbles that the Beaver ends up with after the i-th move, that is, the number of pebbles in a row after some arrangement of ci pebbles (1 ≤ i < k). Note that ci > ci + 1.
* ck = 1
The result of the game is the sum of numbers ci. You are given n. Find the maximum possible result of the game.
Input
The single line of the input contains a single integer n — the initial number of pebbles the Smart Beaver has.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 50
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 109
Output
Print a single number — the maximum possible result of the game.
Examples
Input
10
Output
16
Input
8
Output
15
Note
Consider the first example (c1 = 10). The possible options for the game development are:
* Arrange the pebbles in 10 rows, one pebble per row. Then c2 = 1, and the game ends after the first move with the result of 11.
* Arrange the pebbles in 5 rows, two pebbles per row. Then c2 = 2, and the game continues. During the second move we have two pebbles which can be arranged in a unique way (remember that you are not allowed to put all the pebbles in the same row!) — 2 rows, one pebble per row. c3 = 1, and the game ends with the result of 13.
* Finally, arrange the pebbles in two rows, five pebbles per row. The same logic leads us to c2 = 5, c3 = 1, and the game ends with the result of 16 — the maximum possible result.
Submitted Solution:
```
n = int(input())
c = n-1
while c > 1:
s = 0
for i in range(2, n + 1):
if n % i == 0:
c += (n // i)
n = n // i
s = 1
break
if s == 0:
c += 1
break
print(c)
``` | instruction | 0 | 91,198 | 19 | 182,396 |
No | output | 1 | 91,198 | 19 | 182,397 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Smart Beaver from ABBYY decided to have a day off. But doing nothing the whole day turned out to be too boring, and he decided to play a game with pebbles. Initially, the Beaver has n pebbles. He arranges them in a equal rows, each row has b pebbles (a > 1). Note that the Beaver must use all the pebbles he has, i. e. n = a·b.
<image> 10 pebbles are arranged in two rows, each row has 5 pebbles
Once the Smart Beaver has arranged the pebbles, he takes back any of the resulting rows (that is, b pebbles) and discards all other pebbles. Then he arranges all his pebbles again (possibly choosing other values of a and b) and takes back one row, and so on. The game continues until at some point the Beaver ends up with exactly one pebble.
The game process can be represented as a finite sequence of integers c1, ..., ck, where:
* c1 = n
* ci + 1 is the number of pebbles that the Beaver ends up with after the i-th move, that is, the number of pebbles in a row after some arrangement of ci pebbles (1 ≤ i < k). Note that ci > ci + 1.
* ck = 1
The result of the game is the sum of numbers ci. You are given n. Find the maximum possible result of the game.
Input
The single line of the input contains a single integer n — the initial number of pebbles the Smart Beaver has.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 50
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 109
Output
Print a single number — the maximum possible result of the game.
Examples
Input
10
Output
16
Input
8
Output
15
Note
Consider the first example (c1 = 10). The possible options for the game development are:
* Arrange the pebbles in 10 rows, one pebble per row. Then c2 = 1, and the game ends after the first move with the result of 11.
* Arrange the pebbles in 5 rows, two pebbles per row. Then c2 = 2, and the game continues. During the second move we have two pebbles which can be arranged in a unique way (remember that you are not allowed to put all the pebbles in the same row!) — 2 rows, one pebble per row. c3 = 1, and the game ends with the result of 13.
* Finally, arrange the pebbles in two rows, five pebbles per row. The same logic leads us to c2 = 5, c3 = 1, and the game ends with the result of 16 — the maximum possible result.
Submitted Solution:
```
def hcf(x,y):
if x > y:
smaller = y
else:
smaller=x
for i in range(1, smaller+1):
if((x % i == 0) and (y % i == 0)):
hcf = i
return hcf
c=10
A=[]
p=10
n=int(input())
for i in range(n-1,0,-1):
if n%i==0:
A.append(i)
for i in range(len(A)):
p=hcf(A[i],p)
if p!=1:
c+=p
else:
if i==len(A)-1:
c+=p
else:
continue
print(c)
``` | instruction | 0 | 91,199 | 19 | 182,398 |
No | output | 1 | 91,199 | 19 | 182,399 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Smart Beaver from ABBYY decided to have a day off. But doing nothing the whole day turned out to be too boring, and he decided to play a game with pebbles. Initially, the Beaver has n pebbles. He arranges them in a equal rows, each row has b pebbles (a > 1). Note that the Beaver must use all the pebbles he has, i. e. n = a·b.
<image> 10 pebbles are arranged in two rows, each row has 5 pebbles
Once the Smart Beaver has arranged the pebbles, he takes back any of the resulting rows (that is, b pebbles) and discards all other pebbles. Then he arranges all his pebbles again (possibly choosing other values of a and b) and takes back one row, and so on. The game continues until at some point the Beaver ends up with exactly one pebble.
The game process can be represented as a finite sequence of integers c1, ..., ck, where:
* c1 = n
* ci + 1 is the number of pebbles that the Beaver ends up with after the i-th move, that is, the number of pebbles in a row after some arrangement of ci pebbles (1 ≤ i < k). Note that ci > ci + 1.
* ck = 1
The result of the game is the sum of numbers ci. You are given n. Find the maximum possible result of the game.
Input
The single line of the input contains a single integer n — the initial number of pebbles the Smart Beaver has.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 50
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 109
Output
Print a single number — the maximum possible result of the game.
Examples
Input
10
Output
16
Input
8
Output
15
Note
Consider the first example (c1 = 10). The possible options for the game development are:
* Arrange the pebbles in 10 rows, one pebble per row. Then c2 = 1, and the game ends after the first move with the result of 11.
* Arrange the pebbles in 5 rows, two pebbles per row. Then c2 = 2, and the game continues. During the second move we have two pebbles which can be arranged in a unique way (remember that you are not allowed to put all the pebbles in the same row!) — 2 rows, one pebble per row. c3 = 1, and the game ends with the result of 13.
* Finally, arrange the pebbles in two rows, five pebbles per row. The same logic leads us to c2 = 5, c3 = 1, and the game ends with the result of 16 — the maximum possible result.
Submitted Solution:
```
n = int(input())
ans = n
while True:
if n%2!=0:
break
x = n//2
n = n//2
ans+=x
if n>1:
ans+=1
print(ans)
``` | instruction | 0 | 91,200 | 19 | 182,400 |
No | output | 1 | 91,200 | 19 | 182,401 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Smart Beaver from ABBYY decided to have a day off. But doing nothing the whole day turned out to be too boring, and he decided to play a game with pebbles. Initially, the Beaver has n pebbles. He arranges them in a equal rows, each row has b pebbles (a > 1). Note that the Beaver must use all the pebbles he has, i. e. n = a·b.
<image> 10 pebbles are arranged in two rows, each row has 5 pebbles
Once the Smart Beaver has arranged the pebbles, he takes back any of the resulting rows (that is, b pebbles) and discards all other pebbles. Then he arranges all his pebbles again (possibly choosing other values of a and b) and takes back one row, and so on. The game continues until at some point the Beaver ends up with exactly one pebble.
The game process can be represented as a finite sequence of integers c1, ..., ck, where:
* c1 = n
* ci + 1 is the number of pebbles that the Beaver ends up with after the i-th move, that is, the number of pebbles in a row after some arrangement of ci pebbles (1 ≤ i < k). Note that ci > ci + 1.
* ck = 1
The result of the game is the sum of numbers ci. You are given n. Find the maximum possible result of the game.
Input
The single line of the input contains a single integer n — the initial number of pebbles the Smart Beaver has.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 50
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 109
Output
Print a single number — the maximum possible result of the game.
Examples
Input
10
Output
16
Input
8
Output
15
Note
Consider the first example (c1 = 10). The possible options for the game development are:
* Arrange the pebbles in 10 rows, one pebble per row. Then c2 = 1, and the game ends after the first move with the result of 11.
* Arrange the pebbles in 5 rows, two pebbles per row. Then c2 = 2, and the game continues. During the second move we have two pebbles which can be arranged in a unique way (remember that you are not allowed to put all the pebbles in the same row!) — 2 rows, one pebble per row. c3 = 1, and the game ends with the result of 13.
* Finally, arrange the pebbles in two rows, five pebbles per row. The same logic leads us to c2 = 5, c3 = 1, and the game ends with the result of 16 — the maximum possible result.
Submitted Solution:
```
e=int(input())
def sieve(n):
save = [0] * (n+1)
save[0]=save[1]=1
i = 2
while (i*i <= n):
if (save[i]):
k = i*i
while (k<=n):
save[k] =1
k += i
i+= 1
return save
def prime(n):
p=sieve(n)
l=[]
for i in range(n+1):
if p[i]==0:
if n%i==0:
l.append(i)
return l
def ur(n):
p=sieve(n)
q=prime(n)
if p[n]==0:
return n+1
else:
return n+ur(n//q[0])
print(ur(e))
``` | instruction | 0 | 91,201 | 19 | 182,402 |
No | output | 1 | 91,201 | 19 | 182,403 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cards placed on a grid with H rows and W columns of squares.
The i-th card has an integer A_i written on it, and it is placed on the square at the R_i-th row from the top and the C_i-th column from the left.
Multiple cards may be placed on the same square.
You will first pick up at most one card from each row.
Then, you will pick up at most one card from each column.
Find the maximum possible sum of the integers written on the picked cards.
Constraints
* All values are integers.
* 1 \leq N \leq 10^5
* 1 \leq H, W \leq 10^5
* 1 \leq A_i \leq 10^5
* 1 \leq R_i \leq H
* 1 \leq C_i \leq W
Input
Input is given from Standard Input in the following format:
N H W
R_1 C_1 A_1
R_2 C_2 A_2
\vdots
R_N C_N A_N
Output
Print the maximum possible sum of the integers written on the picked cards.
Examples
Input
6 2 2
2 2 2
1 1 8
1 1 5
1 2 9
1 2 7
2 1 4
Output
28
Input
13 5 6
1 3 35902
4 6 19698
4 6 73389
3 6 3031
3 1 4771
1 4 4784
2 1 36357
2 1 24830
5 6 50219
4 6 22645
1 2 30739
1 4 68417
1 5 78537
Output
430590
Input
1 100000 100000
1 1 1
Output
1 | instruction | 0 | 91,494 | 19 | 182,988 |
"Correct Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**7)
import operator
N,H,W = map(int,readline().split())
m = map(int,read().split())
RCA = sorted(zip(m,m,m),key=operator.itemgetter(2),reverse=True)
root = list(range(H+W))
size = [0] * (H+W)
no_cycle = [True] * (H+W)
def find_root(root,x):
y = root[x]
if x == y:
return x
path = [x]
while y != root[y]:
path.append(y)
y = root[y]
for p in path:
root[p] = y
return y
def merge(root,size,x,y):
x,y = find_root(root,x),find_root(root,y)
if x == y:
return
sx,sy = size[x],size[y]
if sx < sy:
sx,sy = sy,sx
x,y = y,x
root[y] = x
no_cycle[x] = no_cycle[x] and no_cycle[y]
answer = 0
for R,C,A in RCA:
x,y = R-1,H+C-1
rx,ry = find_root(root,x),find_root(root,y)
if rx == ry:
if not no_cycle[rx]:
continue
no_cycle[rx] = False
else:
if (not no_cycle[rx]) and (not no_cycle[ry]):
continue
merge(root,size,rx,ry)
answer += A
print(answer)
``` | output | 1 | 91,494 | 19 | 182,989 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cards placed on a grid with H rows and W columns of squares.
The i-th card has an integer A_i written on it, and it is placed on the square at the R_i-th row from the top and the C_i-th column from the left.
Multiple cards may be placed on the same square.
You will first pick up at most one card from each row.
Then, you will pick up at most one card from each column.
Find the maximum possible sum of the integers written on the picked cards.
Constraints
* All values are integers.
* 1 \leq N \leq 10^5
* 1 \leq H, W \leq 10^5
* 1 \leq A_i \leq 10^5
* 1 \leq R_i \leq H
* 1 \leq C_i \leq W
Input
Input is given from Standard Input in the following format:
N H W
R_1 C_1 A_1
R_2 C_2 A_2
\vdots
R_N C_N A_N
Output
Print the maximum possible sum of the integers written on the picked cards.
Examples
Input
6 2 2
2 2 2
1 1 8
1 1 5
1 2 9
1 2 7
2 1 4
Output
28
Input
13 5 6
1 3 35902
4 6 19698
4 6 73389
3 6 3031
3 1 4771
1 4 4784
2 1 36357
2 1 24830
5 6 50219
4 6 22645
1 2 30739
1 4 68417
1 5 78537
Output
430590
Input
1 100000 100000
1 1 1
Output
1 | instruction | 0 | 91,495 | 19 | 182,990 |
"Correct Solution:
```
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n,h,w = list(map(int, input().split()))
from collections import defaultdict
ns = defaultdict(list)
for i in range(n):
r,c,a = list(map(int, input().split()))
r -= 1; c -= 1
c += h
ns[r].append((a,c))
ns[c].append((a,r))
class UnionFindTree:
def __init__(self, n):
self.n = n
self.parent = list(range(n))
self.size = [1] * n
self.es = [0]*n
def root(self, i):
inter = set()
while self.parent[i]!=i:
inter.add(i)
i = self.parent[i]
r = i
for i in inter:
self.parent[i] = r
return r
def connect(self, i, j):
ri = self.root(i)
rj = self.root(j)
if ri==rj:
self.es[ri] += 1
return
if self.size[ri]<self.size[rj]:
self.parent[ri] = rj
self.size[rj] += self.size[ri]
self.es[rj] += self.es[ri] + 1
else:
self.parent[rj] = ri
self.size[ri] += self.size[rj]
self.es[ri] += self.es[rj] + 1
def selectEdge(ns):
"""各頂点に1本以下の接続枝を割り当てて、重み最大化
"""
from heapq import heappop as hpp, heappush as hp
q = []
for u in ns.keys():
for a,v in ns[u]:
if u<v:
hp(q, (-a,(u,v)))
# 辺を選択できる = 選択した場合の連結成分において頂点数>=枝数
uf = UnionFindTree(h+w)
ans = 0
while q:
a, (u,v) = hpp(q)
a *= -1
ru = uf.root(u)
rv = uf.root(v)
if ru==rv and uf.es[ru]<uf.size[ru]:
uf.connect(u,v)
ans += a
elif ru!=rv and (uf.es[ru]+uf.es[rv]+1) <= (uf.size[ru]+uf.size[rv]):
uf.connect(u,v)
ans += a
return ans,uf
ans,uf = selectEdge(ns)
print(ans)
``` | output | 1 | 91,495 | 19 | 182,991 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cards placed on a grid with H rows and W columns of squares.
The i-th card has an integer A_i written on it, and it is placed on the square at the R_i-th row from the top and the C_i-th column from the left.
Multiple cards may be placed on the same square.
You will first pick up at most one card from each row.
Then, you will pick up at most one card from each column.
Find the maximum possible sum of the integers written on the picked cards.
Constraints
* All values are integers.
* 1 \leq N \leq 10^5
* 1 \leq H, W \leq 10^5
* 1 \leq A_i \leq 10^5
* 1 \leq R_i \leq H
* 1 \leq C_i \leq W
Input
Input is given from Standard Input in the following format:
N H W
R_1 C_1 A_1
R_2 C_2 A_2
\vdots
R_N C_N A_N
Output
Print the maximum possible sum of the integers written on the picked cards.
Examples
Input
6 2 2
2 2 2
1 1 8
1 1 5
1 2 9
1 2 7
2 1 4
Output
28
Input
13 5 6
1 3 35902
4 6 19698
4 6 73389
3 6 3031
3 1 4771
1 4 4784
2 1 36357
2 1 24830
5 6 50219
4 6 22645
1 2 30739
1 4 68417
1 5 78537
Output
430590
Input
1 100000 100000
1 1 1
Output
1 | instruction | 0 | 91,496 | 19 | 182,992 |
"Correct Solution:
```
import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 7)
N,H,W = map(int,readline().split())
RCA = [tuple(int(x) for x in line.split()) for line in readlines()]
RCA.sort(key = lambda x: -x[2])
RCA
root = list(range(H+W))
size = [0] * (H+W)
no_cycle = [True] * (H+W)
def find_root(x):
y = root[x]
if x == y:
return y
z = find_root(y)
root[x] = z
return z
def merge(x,y):
x,y = find_root(x),find_root(y)
sx,sy = size[x],size[y]
if sx < sy:
sx,sy = sy,sx
x,y = y,x
root[y] = x
no_cycle[x] = no_cycle[x] and no_cycle[y]
answer = 0
for R,C,A in RCA:
x,y = R-1,H+C-1
rx,ry = find_root(x),find_root(y)
if rx == ry:
if not no_cycle[rx]:
continue
no_cycle[rx] = False
else:
if (not no_cycle[rx]) and (not no_cycle[ry]):
continue
merge(rx,ry)
answer += A
print(answer)
``` | output | 1 | 91,496 | 19 | 182,993 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cards placed on a grid with H rows and W columns of squares.
The i-th card has an integer A_i written on it, and it is placed on the square at the R_i-th row from the top and the C_i-th column from the left.
Multiple cards may be placed on the same square.
You will first pick up at most one card from each row.
Then, you will pick up at most one card from each column.
Find the maximum possible sum of the integers written on the picked cards.
Constraints
* All values are integers.
* 1 \leq N \leq 10^5
* 1 \leq H, W \leq 10^5
* 1 \leq A_i \leq 10^5
* 1 \leq R_i \leq H
* 1 \leq C_i \leq W
Input
Input is given from Standard Input in the following format:
N H W
R_1 C_1 A_1
R_2 C_2 A_2
\vdots
R_N C_N A_N
Output
Print the maximum possible sum of the integers written on the picked cards.
Examples
Input
6 2 2
2 2 2
1 1 8
1 1 5
1 2 9
1 2 7
2 1 4
Output
28
Input
13 5 6
1 3 35902
4 6 19698
4 6 73389
3 6 3031
3 1 4771
1 4 4784
2 1 36357
2 1 24830
5 6 50219
4 6 22645
1 2 30739
1 4 68417
1 5 78537
Output
430590
Input
1 100000 100000
1 1 1
Output
1 | instruction | 0 | 91,497 | 19 | 182,994 |
"Correct Solution:
```
import sys
from heapq import *
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
def main():
def get_group(k):
g = pd[k]
if g < 0:
return k
gg = get_group(g)
pd[k] = gg
return gg
def merge(j, k):
g1 = get_group(j)
g2 = get_group(k)
if g1 != g2:
d1 = -pd[g1]
d2 = -pd[g2]
if d2 > d1:
g1, g2 = g2, g1
pd[g2] = g1
if d1 == d2:
pd[g1] -= 1
hp = []
n, h, w = map(int, input().split())
pd = [-1] * (h + w + 2) # 親(parent)と深さ(depth)。0以上は親。負の場合、そのノードが根で絶対値が深さ。
pd[0] = -(h + w + 2)
for _ in range(n):
r, c, a = map(int, input().split())
heappush(hp, [-a, r, h + c])
cnt = h + w
ans = 0
while cnt and hp:
a, r, c = heappop(hp)
gr = get_group(r)
gc = get_group(c)
if gr + gc == 0: continue
if gr == gc:
merge(gr, 0)
else:
merge(gr, gc)
ans -= a
cnt -= 1
print(ans)
main()
``` | output | 1 | 91,497 | 19 | 182,995 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cards placed on a grid with H rows and W columns of squares.
The i-th card has an integer A_i written on it, and it is placed on the square at the R_i-th row from the top and the C_i-th column from the left.
Multiple cards may be placed on the same square.
You will first pick up at most one card from each row.
Then, you will pick up at most one card from each column.
Find the maximum possible sum of the integers written on the picked cards.
Constraints
* All values are integers.
* 1 \leq N \leq 10^5
* 1 \leq H, W \leq 10^5
* 1 \leq A_i \leq 10^5
* 1 \leq R_i \leq H
* 1 \leq C_i \leq W
Input
Input is given from Standard Input in the following format:
N H W
R_1 C_1 A_1
R_2 C_2 A_2
\vdots
R_N C_N A_N
Output
Print the maximum possible sum of the integers written on the picked cards.
Examples
Input
6 2 2
2 2 2
1 1 8
1 1 5
1 2 9
1 2 7
2 1 4
Output
28
Input
13 5 6
1 3 35902
4 6 19698
4 6 73389
3 6 3031
3 1 4771
1 4 4784
2 1 36357
2 1 24830
5 6 50219
4 6 22645
1 2 30739
1 4 68417
1 5 78537
Output
430590
Input
1 100000 100000
1 1 1
Output
1 | instruction | 0 | 91,498 | 19 | 182,996 |
"Correct Solution:
```
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.size = [1] * n
self.rank = [0] * n
self.edge = [0] * n
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def is_saturated(self, x):
x = self.find(x)
return self.edge[x] == self.size[x]
def get_size(self, x):
return self.size[self.find(x)]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
self.edge[x] += 1
if x == y:
return
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.size[y] += self.size[x]
self.edge[y] += self.edge[x]
else:
self.par[y] = x
self.size[x] += self.size[y]
self.edge[x] += self.edge[y]
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
n, h, w = [int(item) for item in input().split()]
UF = UnionFind(h+w)
arc = []
for i in range(n):
r, c, a = [int(item) for item in input().split()]
r -= 1; c -= 1
c += h
arc.append([a, r, c])
arc.sort(reverse=True)
ans = 0
for a, r, c in arc:
if not UF.is_saturated(r) or not UF.is_saturated(c):
UF.union(r, c)
ans += a
print(ans)
``` | output | 1 | 91,498 | 19 | 182,997 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cards placed on a grid with H rows and W columns of squares.
The i-th card has an integer A_i written on it, and it is placed on the square at the R_i-th row from the top and the C_i-th column from the left.
Multiple cards may be placed on the same square.
You will first pick up at most one card from each row.
Then, you will pick up at most one card from each column.
Find the maximum possible sum of the integers written on the picked cards.
Constraints
* All values are integers.
* 1 \leq N \leq 10^5
* 1 \leq H, W \leq 10^5
* 1 \leq A_i \leq 10^5
* 1 \leq R_i \leq H
* 1 \leq C_i \leq W
Input
Input is given from Standard Input in the following format:
N H W
R_1 C_1 A_1
R_2 C_2 A_2
\vdots
R_N C_N A_N
Output
Print the maximum possible sum of the integers written on the picked cards.
Examples
Input
6 2 2
2 2 2
1 1 8
1 1 5
1 2 9
1 2 7
2 1 4
Output
28
Input
13 5 6
1 3 35902
4 6 19698
4 6 73389
3 6 3031
3 1 4771
1 4 4784
2 1 36357
2 1 24830
5 6 50219
4 6 22645
1 2 30739
1 4 68417
1 5 78537
Output
430590
Input
1 100000 100000
1 1 1
Output
1 | instruction | 0 | 91,499 | 19 | 182,998 |
"Correct Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**7)
import operator
N,H,W = map(int,readline().split())
m = map(int,read().split())
RCA = sorted(zip(m,m,m),key=operator.itemgetter(2),reverse=True)
root = list(range(H+W))
size = [0] * (H+W)
no_cycle = [True] * (H+W)
def find_root(x):
y = root[x]
if x == y:
return x
path = [x]
while y != root[y]:
path.append(y)
y = root[y]
for p in path:
root[p] = y
return y
def merge(x,y):
x,y = find_root(x),find_root(y)
sx,sy = size[x],size[y]
if sx < sy:
sx,sy = sy,sx
x,y = y,x
root[y] = x
no_cycle[x] = no_cycle[x] and no_cycle[y]
answer = 0
for R,C,A in RCA:
x,y = R-1,H+C-1
rx,ry = find_root(x),find_root(y)
if rx == ry:
if not no_cycle[rx]:
continue
no_cycle[rx] = False
else:
if (not no_cycle[rx]) and (not no_cycle[ry]):
continue
merge(rx,ry)
answer += A
print(answer)
``` | output | 1 | 91,499 | 19 | 182,999 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cards placed on a grid with H rows and W columns of squares.
The i-th card has an integer A_i written on it, and it is placed on the square at the R_i-th row from the top and the C_i-th column from the left.
Multiple cards may be placed on the same square.
You will first pick up at most one card from each row.
Then, you will pick up at most one card from each column.
Find the maximum possible sum of the integers written on the picked cards.
Constraints
* All values are integers.
* 1 \leq N \leq 10^5
* 1 \leq H, W \leq 10^5
* 1 \leq A_i \leq 10^5
* 1 \leq R_i \leq H
* 1 \leq C_i \leq W
Input
Input is given from Standard Input in the following format:
N H W
R_1 C_1 A_1
R_2 C_2 A_2
\vdots
R_N C_N A_N
Output
Print the maximum possible sum of the integers written on the picked cards.
Examples
Input
6 2 2
2 2 2
1 1 8
1 1 5
1 2 9
1 2 7
2 1 4
Output
28
Input
13 5 6
1 3 35902
4 6 19698
4 6 73389
3 6 3031
3 1 4771
1 4 4784
2 1 36357
2 1 24830
5 6 50219
4 6 22645
1 2 30739
1 4 68417
1 5 78537
Output
430590
Input
1 100000 100000
1 1 1
Output
1 | instruction | 0 | 91,500 | 19 | 183,000 |
"Correct Solution:
```
import sys
sys.setrecursionlimit(10 ** 5)
class UnionFind:
def __init__(self, n):
self.table = [-1] * n
self.taken = [0] * n
def _root(self, x):
if self.table[x] < 0:
return x
else:
self.table[x] = self._root(self.table[x])
return self.table[x]
def union(self, x, y):
r1 = self._root(x)
r2 = self._root(y)
if r1 == r2:
new_root = r1
else:
d1 = self.table[r1]
d2 = self.table[r2]
if d1 <= d2:
self.table[r2] = r1
self.table[r1] += d2
self.taken[r1] += self.taken[r2]
new_root = r1
else:
self.table[r1] = r2
self.table[r2] += d1
self.taken[r2] += self.taken[r1]
new_root = r2
cells = -self.table[new_root]
taken = self.taken[new_root]
if cells > taken:
self.taken[new_root] += 1
return True
return False
n, h, w = map(int, input().split())
hw = h + w
cards = []
for line in sys.stdin:
r, c, a = map(int, line.split())
cards.append((a, r - 1, h + c - 1))
cards.sort(reverse=True)
uft = UnionFind(hw)
ans = 0
for a, r, c in cards:
if uft.union(r, c):
ans += a
print(ans)
``` | output | 1 | 91,500 | 19 | 183,001 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cards placed on a grid with H rows and W columns of squares.
The i-th card has an integer A_i written on it, and it is placed on the square at the R_i-th row from the top and the C_i-th column from the left.
Multiple cards may be placed on the same square.
You will first pick up at most one card from each row.
Then, you will pick up at most one card from each column.
Find the maximum possible sum of the integers written on the picked cards.
Constraints
* All values are integers.
* 1 \leq N \leq 10^5
* 1 \leq H, W \leq 10^5
* 1 \leq A_i \leq 10^5
* 1 \leq R_i \leq H
* 1 \leq C_i \leq W
Input
Input is given from Standard Input in the following format:
N H W
R_1 C_1 A_1
R_2 C_2 A_2
\vdots
R_N C_N A_N
Output
Print the maximum possible sum of the integers written on the picked cards.
Examples
Input
6 2 2
2 2 2
1 1 8
1 1 5
1 2 9
1 2 7
2 1 4
Output
28
Input
13 5 6
1 3 35902
4 6 19698
4 6 73389
3 6 3031
3 1 4771
1 4 4784
2 1 36357
2 1 24830
5 6 50219
4 6 22645
1 2 30739
1 4 68417
1 5 78537
Output
430590
Input
1 100000 100000
1 1 1
Output
1 | instruction | 0 | 91,501 | 19 | 183,002 |
"Correct Solution:
```
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*n
self.rank = [0]*n
self.cycle = [False]*n
def find(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if(x == y):
self.cycle[x] = True
elif(self.rank[x] > self.rank[y]):
self.root[x] += self.root[y]
self.cycle[x] |= self.cycle[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.cycle[y] |= self.cycle[x]
self.root[x] = y
if(self.rank[x] == self.rank[y]):
self.rank[y] += 1
def isSame(self, x, y):
return self.find(x) == self.find(y)
#サイクルは各連結成分に一つまで
def isSafe(self, x, y):
cx = self.cycle[self.find(x)]
cy = self.cycle[self.find(y)]
return not((self.isSame(x,y) and (cx or cy)) or (cx and cy))
n,h,w,*l = map(int,open(0).read().split())
cards = sorted([(a,r-1,c-1) for r,c,a in zip(*[iter(l)]*3)])[::-1]
uf = UnionFind(h+w)
ans = 0
for a,r,c in cards:
c += h
if uf.isSafe(r,c):
uf.unite(r,c)
ans += a
print(ans)
``` | output | 1 | 91,501 | 19 | 183,003 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cards placed on a grid with H rows and W columns of squares.
The i-th card has an integer A_i written on it, and it is placed on the square at the R_i-th row from the top and the C_i-th column from the left.
Multiple cards may be placed on the same square.
You will first pick up at most one card from each row.
Then, you will pick up at most one card from each column.
Find the maximum possible sum of the integers written on the picked cards.
Constraints
* All values are integers.
* 1 \leq N \leq 10^5
* 1 \leq H, W \leq 10^5
* 1 \leq A_i \leq 10^5
* 1 \leq R_i \leq H
* 1 \leq C_i \leq W
Input
Input is given from Standard Input in the following format:
N H W
R_1 C_1 A_1
R_2 C_2 A_2
\vdots
R_N C_N A_N
Output
Print the maximum possible sum of the integers written on the picked cards.
Examples
Input
6 2 2
2 2 2
1 1 8
1 1 5
1 2 9
1 2 7
2 1 4
Output
28
Input
13 5 6
1 3 35902
4 6 19698
4 6 73389
3 6 3031
3 1 4771
1 4 4784
2 1 36357
2 1 24830
5 6 50219
4 6 22645
1 2 30739
1 4 68417
1 5 78537
Output
430590
Input
1 100000 100000
1 1 1
Output
1
Submitted Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**7)
import operator
N,H,W = map(int,readline().split())
m = map(int,read().split())
RCA = sorted(zip(m,m,m),key=operator.itemgetter(2),reverse=True)
root = list(range(H+W))
size = [0] * (H+W)
no_cycle = [True] * (H+W)
def find_root(x):
y = root[x]
if x == y:
return x
path = [x]
while y != root[y]:
path.append(y)
y = root[y]
for p in path:
root[p] = y
return y
def merge(x,y):
x,y = find_root(x),find_root(y)
sx,sy = size[x],size[y]
if sx < sy:
sx,sy = sy,sx
x,y = y,x
root[y] = x
size[x] += sy
no_cycle[x] = no_cycle[x] and no_cycle[y]
answer = 0
for R,C,A in RCA:
x,y = R-1,H+C-1
rx,ry = find_root(x),find_root(y)
if rx == ry:
if not no_cycle[rx]:
continue
no_cycle[rx] = False
else:
if (not no_cycle[rx]) and (not no_cycle[ry]):
continue
merge(rx,ry)
answer += A
print(answer)
``` | instruction | 0 | 91,502 | 19 | 183,004 |
Yes | output | 1 | 91,502 | 19 | 183,005 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cards placed on a grid with H rows and W columns of squares.
The i-th card has an integer A_i written on it, and it is placed on the square at the R_i-th row from the top and the C_i-th column from the left.
Multiple cards may be placed on the same square.
You will first pick up at most one card from each row.
Then, you will pick up at most one card from each column.
Find the maximum possible sum of the integers written on the picked cards.
Constraints
* All values are integers.
* 1 \leq N \leq 10^5
* 1 \leq H, W \leq 10^5
* 1 \leq A_i \leq 10^5
* 1 \leq R_i \leq H
* 1 \leq C_i \leq W
Input
Input is given from Standard Input in the following format:
N H W
R_1 C_1 A_1
R_2 C_2 A_2
\vdots
R_N C_N A_N
Output
Print the maximum possible sum of the integers written on the picked cards.
Examples
Input
6 2 2
2 2 2
1 1 8
1 1 5
1 2 9
1 2 7
2 1 4
Output
28
Input
13 5 6
1 3 35902
4 6 19698
4 6 73389
3 6 3031
3 1 4771
1 4 4784
2 1 36357
2 1 24830
5 6 50219
4 6 22645
1 2 30739
1 4 68417
1 5 78537
Output
430590
Input
1 100000 100000
1 1 1
Output
1
Submitted Solution:
```
class UnionFindVerSize():
def __init__(self, N):
self._parent = [n for n in range(0, N)]
self._size = [1] * N
self._edge = [0] * N
def find_root(self, x):
if self._parent[x] == x: return x
self._parent[x] = self.find_root(self._parent[x])
return self._parent[x]
def unite(self, x, y):
gx = self.find_root(x)
gy = self.find_root(y)
if gx == gy:
self._edge[gx] += 1
return
if self._size[gx] < self._size[gy]:
self._parent[gx] = gy
self._size[gy] += self._size[gx]
self._edge[gy] += self._edge[gx]+1
else:
self._parent[gy] = gx
self._size[gx] += self._size[gy]
self._edge[gx] += self._edge[gy]+1
def get_size(self, x):
return self._size[self.find_root(x)]
def is_same_group(self, x, y):
return self.find_root(x) == self.find_root(y)
def calc_group_num(self):
N = len(self._parent)
ans = 0
for i in range(N):
if self.find_root(i) == i:
ans += 1
return ans
def check(self,x,y):
gx = self.find_root(x)
gy = self.find_root(y)
if gx==gy:
return self._size[gx]>=self._edge[gx]+1
else:
nv=self._size[gx]+self._size[gy]
ne=self._edge[gx]+self._edge[gy]+1
return nv>=ne
import sys
input=sys.stdin.readline
N,H,W=map(int,input().split())
card=[]
for i in range(N):
r,c,a=map(int,input().split())
card.append((a,r-1,c-1))
card.sort()
uf=UnionFindVerSize(H+W)
ans=0
while card:
val,r,c=card.pop()
if uf.check(r,H+c):
uf.unite(r,H+c)
ans+=val
print(ans)
``` | instruction | 0 | 91,503 | 19 | 183,006 |
Yes | output | 1 | 91,503 | 19 | 183,007 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cards placed on a grid with H rows and W columns of squares.
The i-th card has an integer A_i written on it, and it is placed on the square at the R_i-th row from the top and the C_i-th column from the left.
Multiple cards may be placed on the same square.
You will first pick up at most one card from each row.
Then, you will pick up at most one card from each column.
Find the maximum possible sum of the integers written on the picked cards.
Constraints
* All values are integers.
* 1 \leq N \leq 10^5
* 1 \leq H, W \leq 10^5
* 1 \leq A_i \leq 10^5
* 1 \leq R_i \leq H
* 1 \leq C_i \leq W
Input
Input is given from Standard Input in the following format:
N H W
R_1 C_1 A_1
R_2 C_2 A_2
\vdots
R_N C_N A_N
Output
Print the maximum possible sum of the integers written on the picked cards.
Examples
Input
6 2 2
2 2 2
1 1 8
1 1 5
1 2 9
1 2 7
2 1 4
Output
28
Input
13 5 6
1 3 35902
4 6 19698
4 6 73389
3 6 3031
3 1 4771
1 4 4784
2 1 36357
2 1 24830
5 6 50219
4 6 22645
1 2 30739
1 4 68417
1 5 78537
Output
430590
Input
1 100000 100000
1 1 1
Output
1
Submitted Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import operator
N,H,W = map(int,readline().split())
m = map(int,read().split())
RCA = sorted(zip(m,m,m),key=operator.itemgetter(2),reverse=True)
root = list(range(H+W))
size = [1] * (H+W)
no_cycle = [True] * (H+W)
def find_root(x):
y = root[x]
if x == y:
return y
z = find_root(y)
root[x] = z
return z
def merge(x,y):
x,y = find_root(x),find_root(y)
sx,sy = size[x],size[y]
if sx < sy:
sx,sy = sy,sx
x,y = y,x
root[y] = x
size[x] += sy
no_cycle[x] = no_cycle[x] and no_cycle[y]
answer = 0
for R,C,A in RCA:
x,y = R-1,H+C-1
rx,ry = find_root(x),find_root(y)
if rx == ry:
if not no_cycle[rx]:
continue
no_cycle[rx] = False
else:
if (not no_cycle[rx]) and (not no_cycle[ry]):
continue
merge(rx,ry)
answer += A
print(answer)
``` | instruction | 0 | 91,504 | 19 | 183,008 |
Yes | output | 1 | 91,504 | 19 | 183,009 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cards placed on a grid with H rows and W columns of squares.
The i-th card has an integer A_i written on it, and it is placed on the square at the R_i-th row from the top and the C_i-th column from the left.
Multiple cards may be placed on the same square.
You will first pick up at most one card from each row.
Then, you will pick up at most one card from each column.
Find the maximum possible sum of the integers written on the picked cards.
Constraints
* All values are integers.
* 1 \leq N \leq 10^5
* 1 \leq H, W \leq 10^5
* 1 \leq A_i \leq 10^5
* 1 \leq R_i \leq H
* 1 \leq C_i \leq W
Input
Input is given from Standard Input in the following format:
N H W
R_1 C_1 A_1
R_2 C_2 A_2
\vdots
R_N C_N A_N
Output
Print the maximum possible sum of the integers written on the picked cards.
Examples
Input
6 2 2
2 2 2
1 1 8
1 1 5
1 2 9
1 2 7
2 1 4
Output
28
Input
13 5 6
1 3 35902
4 6 19698
4 6 73389
3 6 3031
3 1 4771
1 4 4784
2 1 36357
2 1 24830
5 6 50219
4 6 22645
1 2 30739
1 4 68417
1 5 78537
Output
430590
Input
1 100000 100000
1 1 1
Output
1
Submitted Solution:
```
import sys
from collections import deque
input = sys.stdin.readline
sys.setrecursionlimit(10**5)
N, H, W = map(int, input().split())
RCA = []
class UF(object):
def __init__(self, n):
self.parent = [i for i in range(n)]
def root(self, v):
if v == self.parent[v]:
return v
else:
self.parent[v] = self.root(self.parent[v])
return self.parent[v]
def unite(self, u, v):
u, v = self.root(u), self.root(v)
if (u == v):
return
self.parent[u] = v
for _ in range(N):
r, c, a = map(int, input().split())
r, c = r-1, c-1
RCA.append((a, r, c))
RCA.sort(reverse=True)
RCA = deque(RCA)
uf = UF(H+W+1) # r0, r1, ..., rH, c0, c1, ..., cW, loopflag
cnt, ans = 0, 0
while RCA and cnt < H+W:
a, r, c = RCA.popleft()
c += H
if uf.root(r) == uf.root(c):
if uf.root(r) == uf.root(H+W): # loop?
continue
uf.unite(r, H+W)
ans += a
cnt += 1
uf.unite(r, c)
print(ans)
``` | instruction | 0 | 91,505 | 19 | 183,010 |
Yes | output | 1 | 91,505 | 19 | 183,011 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cards placed on a grid with H rows and W columns of squares.
The i-th card has an integer A_i written on it, and it is placed on the square at the R_i-th row from the top and the C_i-th column from the left.
Multiple cards may be placed on the same square.
You will first pick up at most one card from each row.
Then, you will pick up at most one card from each column.
Find the maximum possible sum of the integers written on the picked cards.
Constraints
* All values are integers.
* 1 \leq N \leq 10^5
* 1 \leq H, W \leq 10^5
* 1 \leq A_i \leq 10^5
* 1 \leq R_i \leq H
* 1 \leq C_i \leq W
Input
Input is given from Standard Input in the following format:
N H W
R_1 C_1 A_1
R_2 C_2 A_2
\vdots
R_N C_N A_N
Output
Print the maximum possible sum of the integers written on the picked cards.
Examples
Input
6 2 2
2 2 2
1 1 8
1 1 5
1 2 9
1 2 7
2 1 4
Output
28
Input
13 5 6
1 3 35902
4 6 19698
4 6 73389
3 6 3031
3 1 4771
1 4 4784
2 1 36357
2 1 24830
5 6 50219
4 6 22645
1 2 30739
1 4 68417
1 5 78537
Output
430590
Input
1 100000 100000
1 1 1
Output
1
Submitted Solution:
```
def examA():
N = DI()/dec(7)
ans = N
print(N)
return
def examB():
ans = 0
print(ans)
return
def examC():
ans = 0
print(ans)
return
def examD():
N = I()
n = (N-1).bit_length()
V = [[-1]*(1<<n) for i in range(1<<n)]
#print(V)
for i in range(n):
b1 = 1 << i
b2 = 1 << (i + 1)
for j in range(1<<i):
for k in range(1<<(n-i)):
for l in range(1<<(n-i)):
#print(i,j,k,l,j+k*b2,j+b1+l*b2)
if j+k*b2>=N or j+b1+l*b2>=N:
continue
u,v = sorted([j+k*b2,j+b1+l*b2])
#print(u,v)
V[u][v-1] = i+1
ans = [[]for _ in range(N-1)]
for i in range(N-1):
for v in V[i]:
if v>=0:
ans[i].append(v)
for v in ans:
print(" ".join(map(str,v)))
return
# 解説
def examD2():
N = I()
ans = [[-1]*(N-1-i) for i in range(N-1)]
n = N.bit_length()
for i in range(N):
for j in range(i+1,N):
k = 0
while(True):
if i&(1<<k) != j&(1<<k):
break
k += 1
#print(i,j,j-i)
ans[i][j-i-1] = k+1
for v in ans:
print(" ".join(map(str,v)))
return
def examE():
ans = 0
print(ans)
return
def examF():
ans = 0
print(ans)
return
def test():
i = I()
li = LI()
lsi = LSI()
si = LS()
print(i)
print(li)
print(lsi)
print(si)
return
from decimal import getcontext,Decimal as dec
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(input())
def LI(): return list(map(int,sys.stdin.readline().split()))
def DI(): return dec(input())
def LDI(): return list(map(dec,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = dec("0.000000000001")
alphabet = [chr(ord('a') + i) for i in range(26)]
alphabet_convert = {chr(ord('a') + i): i for i in range(26)}
getcontext().prec = 28
sys.setrecursionlimit(10**7)
if __name__ == '__main__':
examD2()
"""
142
12 9 1445 0 1
asd dfg hj o o
aidn
"""
``` | instruction | 0 | 91,506 | 19 | 183,012 |
No | output | 1 | 91,506 | 19 | 183,013 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cards placed on a grid with H rows and W columns of squares.
The i-th card has an integer A_i written on it, and it is placed on the square at the R_i-th row from the top and the C_i-th column from the left.
Multiple cards may be placed on the same square.
You will first pick up at most one card from each row.
Then, you will pick up at most one card from each column.
Find the maximum possible sum of the integers written on the picked cards.
Constraints
* All values are integers.
* 1 \leq N \leq 10^5
* 1 \leq H, W \leq 10^5
* 1 \leq A_i \leq 10^5
* 1 \leq R_i \leq H
* 1 \leq C_i \leq W
Input
Input is given from Standard Input in the following format:
N H W
R_1 C_1 A_1
R_2 C_2 A_2
\vdots
R_N C_N A_N
Output
Print the maximum possible sum of the integers written on the picked cards.
Examples
Input
6 2 2
2 2 2
1 1 8
1 1 5
1 2 9
1 2 7
2 1 4
Output
28
Input
13 5 6
1 3 35902
4 6 19698
4 6 73389
3 6 3031
3 1 4771
1 4 4784
2 1 36357
2 1 24830
5 6 50219
4 6 22645
1 2 30739
1 4 68417
1 5 78537
Output
430590
Input
1 100000 100000
1 1 1
Output
1
Submitted Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import operator
N,H,W = map(int,readline().split())
RCA = [int(x) for x in read().split()]
it = iter(RCA)
RCA = sorted(zip(it,it,it),key=operator.itemgetter(2),reverse=True)
root = list(range(H+W+100))
size = [0] * (H+W+100)
no_cycle = [True] * (H+W+100)
def find_root(x):
y = root[x]
if x == y:
return y
z = find_root(y)
root[x] = z
return z
def merge(x,y):
x,y = find_root(x),find_root(y)
sx,sy = size[x],size[y]
if sx < sy:
sx,sy = sy,sx
x,y = y,x
root[y] = x
no_cycle[x] = (no_cycle[x] and no_cycle[y])
answer = 0
for R,C,A in RCA:
x,y = R-1,H+C-1
rx,ry = find_root(x),find_root(y)
if rx == ry:
if not no_cycle[rx]:
continue
no_cycle[rx] = False
else:
if (not no_cycle[rx]) and (not no_cycle[ry]):
continue
merge(rx,ry)
answer += A
print(answer)
``` | instruction | 0 | 91,507 | 19 | 183,014 |
No | output | 1 | 91,507 | 19 | 183,015 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cards placed on a grid with H rows and W columns of squares.
The i-th card has an integer A_i written on it, and it is placed on the square at the R_i-th row from the top and the C_i-th column from the left.
Multiple cards may be placed on the same square.
You will first pick up at most one card from each row.
Then, you will pick up at most one card from each column.
Find the maximum possible sum of the integers written on the picked cards.
Constraints
* All values are integers.
* 1 \leq N \leq 10^5
* 1 \leq H, W \leq 10^5
* 1 \leq A_i \leq 10^5
* 1 \leq R_i \leq H
* 1 \leq C_i \leq W
Input
Input is given from Standard Input in the following format:
N H W
R_1 C_1 A_1
R_2 C_2 A_2
\vdots
R_N C_N A_N
Output
Print the maximum possible sum of the integers written on the picked cards.
Examples
Input
6 2 2
2 2 2
1 1 8
1 1 5
1 2 9
1 2 7
2 1 4
Output
28
Input
13 5 6
1 3 35902
4 6 19698
4 6 73389
3 6 3031
3 1 4771
1 4 4784
2 1 36357
2 1 24830
5 6 50219
4 6 22645
1 2 30739
1 4 68417
1 5 78537
Output
430590
Input
1 100000 100000
1 1 1
Output
1
Submitted Solution:
```
import sys
input=sys.stdin.readline
class UnionFind:
def __init__(self,n):
self.par=[i for i in range(n)]
self.rank=[0]*n
self.size=[1]*n
self.Ecnt=[0]*n
def root(self,x):
if self.par[x]==x:
return x
else:
self.par[x]=self.root(self.par[x])
return self.par[x]
def union(self,x,y):
px=self.root(x); py=self.root(y)
if px!=py:
if self.rank[px]==self.rank[py]:
self.rank[px]+=1
elif self.rank[px]<self.rank[py]:
px,py=py,px
self.par[py]=px
self.size[px]+=self.size[py]
self.Ecnt[px]+=self.Ecnt[py]+1
else:
self.Ecnt[px]+=1
def same_check(self,x,y):
return self.root(x)==self.root(y)
n,h,w=map(int,input().split())
RCA=[]
for _ in range(n):
r,c,a=map(int,input().split())
r-=1
c+=h-1
RCA.append((r,c,a))
RCA.sort(lambda x:x[2],reverse=True)
uf=UnionFind(h+w)
ans=0
for r,c,a in RCA:
if uf.size[uf.par[r]]+uf.size[uf.par[c]]==uf.Ecnt[uf.par[r]]+uf.Ecnt[uf.par[c]]:
continue
uf.union(r,c)
ans+=a
print(ans)
``` | instruction | 0 | 91,508 | 19 | 183,016 |
No | output | 1 | 91,508 | 19 | 183,017 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cards placed on a grid with H rows and W columns of squares.
The i-th card has an integer A_i written on it, and it is placed on the square at the R_i-th row from the top and the C_i-th column from the left.
Multiple cards may be placed on the same square.
You will first pick up at most one card from each row.
Then, you will pick up at most one card from each column.
Find the maximum possible sum of the integers written on the picked cards.
Constraints
* All values are integers.
* 1 \leq N \leq 10^5
* 1 \leq H, W \leq 10^5
* 1 \leq A_i \leq 10^5
* 1 \leq R_i \leq H
* 1 \leq C_i \leq W
Input
Input is given from Standard Input in the following format:
N H W
R_1 C_1 A_1
R_2 C_2 A_2
\vdots
R_N C_N A_N
Output
Print the maximum possible sum of the integers written on the picked cards.
Examples
Input
6 2 2
2 2 2
1 1 8
1 1 5
1 2 9
1 2 7
2 1 4
Output
28
Input
13 5 6
1 3 35902
4 6 19698
4 6 73389
3 6 3031
3 1 4771
1 4 4784
2 1 36357
2 1 24830
5 6 50219
4 6 22645
1 2 30739
1 4 68417
1 5 78537
Output
430590
Input
1 100000 100000
1 1 1
Output
1
Submitted Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import operator
N,H,W = map(int,readline().split())
RCA = [int(x) for x in read().split()]
it = iter(RCA)
RCA = sorted(zip(it,it,it),key=operator.itemgetter(2),reverse=True)
root = list(range(H+W))
size = [0] * (H+W)
no_cycle = [True] * (H+W)
def find_root(x):
y = root[x]
if x == y:
return y
z = find_root(y)
root[x] = z
return z
def merge(x,y):
x,y = find_root(x),find_root(y)
sx,sy = size[x],size[y]
if sx < sy:
sx,sy = sy,sx
x,y = y,x
root[y] = x
no_cycle[x] = no_cycle[x] and no_cycle[y]
answer = 0
for R,C,A in RCA:
x,y = R-1,H+C-1
rx,ry = find_root(x),find_root(y)
assert 0 <= rx < H+W
assert 0 <= ry < H+W
continue
if rx == ry:
if not no_cycle[rx]:
continue
no_cycle[rx] = False
else:
if (not no_cycle[rx]) and (not no_cycle[ry]):
continue
merge(rx,ry)
answer += A
print(answer)
``` | instruction | 0 | 91,509 | 19 | 183,018 |
No | output | 1 | 91,509 | 19 | 183,019 |
Provide a correct Python 3 solution for this coding contest problem.
Taro and Hanako have numbers of cards in their hands. Each of the cards has a score on it. Taro and Hanako wish to make the total scores of their cards equal by exchanging one card in one's hand with one card in the other's hand. Which of the cards should be exchanged with which?
Note that they have to exchange their cards even if they already have cards of the same total score.
Input
The input consists of a number of datasets. Each dataset is formatted as follows.
> n m
> s1
> s2
> ...
> sn
> sn+1
> sn+2
> ...
> sn+m
>
The first line of a dataset contains two numbers n and m delimited by a space, where n is the number of cards that Taro has and m is the number of cards that Hanako has. The subsequent n+m lines list the score for each of the cards, one score per line. The first n scores (from s1 up to sn) are the scores of Taro's cards and the remaining m scores (from sn+1 up to sn+m) are Hanako's.
The numbers n and m are positive integers no greater than 100. Each score is a non-negative integer no greater than 100.
The end of the input is indicated by a line containing two zeros delimited by a single space.
Output
For each dataset, output a single line containing two numbers delimited by a single space, where the first number is the score of the card Taro gives to Hanako and the second number is the score of the card Hanako gives to Taro. If there is more than one way to exchange a pair of cards that makes the total scores equal, output a pair of scores whose sum is the smallest.
In case no exchange can make the total scores equal, output a single line containing solely -1. The output must not contain any superfluous characters that do not conform to the format.
Sample Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output for the Sample Input
1 3
3 5
-1
2 2
-1
Example
Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output
1 3
3 5
-1
2 2
-1 | instruction | 0 | 91,653 | 19 | 183,306 |
"Correct Solution:
```
def f():
for i in t:
for j in h:
if (i-j)*2==sumt-sumh:
print(i,j)
return
print(-1)
while True:
n,m=map(int,input().split())
if n==0:
break
t=[int(input()) for i in range(n)]
h=[int(input()) for j in range(m)]
t.sort()
h.sort()
sumt=sum(t)
sumh=sum(h)
f()
``` | output | 1 | 91,653 | 19 | 183,307 |
Provide a correct Python 3 solution for this coding contest problem.
Taro and Hanako have numbers of cards in their hands. Each of the cards has a score on it. Taro and Hanako wish to make the total scores of their cards equal by exchanging one card in one's hand with one card in the other's hand. Which of the cards should be exchanged with which?
Note that they have to exchange their cards even if they already have cards of the same total score.
Input
The input consists of a number of datasets. Each dataset is formatted as follows.
> n m
> s1
> s2
> ...
> sn
> sn+1
> sn+2
> ...
> sn+m
>
The first line of a dataset contains two numbers n and m delimited by a space, where n is the number of cards that Taro has and m is the number of cards that Hanako has. The subsequent n+m lines list the score for each of the cards, one score per line. The first n scores (from s1 up to sn) are the scores of Taro's cards and the remaining m scores (from sn+1 up to sn+m) are Hanako's.
The numbers n and m are positive integers no greater than 100. Each score is a non-negative integer no greater than 100.
The end of the input is indicated by a line containing two zeros delimited by a single space.
Output
For each dataset, output a single line containing two numbers delimited by a single space, where the first number is the score of the card Taro gives to Hanako and the second number is the score of the card Hanako gives to Taro. If there is more than one way to exchange a pair of cards that makes the total scores equal, output a pair of scores whose sum is the smallest.
In case no exchange can make the total scores equal, output a single line containing solely -1. The output must not contain any superfluous characters that do not conform to the format.
Sample Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output for the Sample Input
1 3
3 5
-1
2 2
-1
Example
Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output
1 3
3 5
-1
2 2
-1 | instruction | 0 | 91,654 | 19 | 183,308 |
"Correct Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import array
import heapq
import itertools
def solve(taro_cards, hanako_cards):
sum_taro = sum(taro_cards)
sum_hanako = sum(hanako_cards)
candidates = []
for t, h in itertools.product(taro_cards, hanako_cards):
if sum_taro - t + h == sum_hanako - h + t:
heapq.heappush(candidates, (t + h, [t, h]))
if not candidates:
return [-1]
else:
return candidates[0][1]
if __name__ == "__main__":
while True:
n, m = map(int, input().split())
if n == 0 and m == 0:
break
else:
taro_cards = array.array("B", (int(input()) for i in range(n)))
hanako_cards = array.array("B", (int(input()) for i in range(m)))
print(*solve(taro_cards, hanako_cards))
``` | output | 1 | 91,654 | 19 | 183,309 |
Provide a correct Python 3 solution for this coding contest problem.
Taro and Hanako have numbers of cards in their hands. Each of the cards has a score on it. Taro and Hanako wish to make the total scores of their cards equal by exchanging one card in one's hand with one card in the other's hand. Which of the cards should be exchanged with which?
Note that they have to exchange their cards even if they already have cards of the same total score.
Input
The input consists of a number of datasets. Each dataset is formatted as follows.
> n m
> s1
> s2
> ...
> sn
> sn+1
> sn+2
> ...
> sn+m
>
The first line of a dataset contains two numbers n and m delimited by a space, where n is the number of cards that Taro has and m is the number of cards that Hanako has. The subsequent n+m lines list the score for each of the cards, one score per line. The first n scores (from s1 up to sn) are the scores of Taro's cards and the remaining m scores (from sn+1 up to sn+m) are Hanako's.
The numbers n and m are positive integers no greater than 100. Each score is a non-negative integer no greater than 100.
The end of the input is indicated by a line containing two zeros delimited by a single space.
Output
For each dataset, output a single line containing two numbers delimited by a single space, where the first number is the score of the card Taro gives to Hanako and the second number is the score of the card Hanako gives to Taro. If there is more than one way to exchange a pair of cards that makes the total scores equal, output a pair of scores whose sum is the smallest.
In case no exchange can make the total scores equal, output a single line containing solely -1. The output must not contain any superfluous characters that do not conform to the format.
Sample Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output for the Sample Input
1 3
3 5
-1
2 2
-1
Example
Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output
1 3
3 5
-1
2 2
-1 | instruction | 0 | 91,655 | 19 | 183,310 |
"Correct Solution:
```
while True:
n,m=map(int,input().split())
if n==0 and m==0:
break
a=[int(input()) for i in range(n)]
b=[int(input()) for i in range(m)]
ans=[-1]
va=100000
for i in range(n):
for j in range(m):
if sum(a)-a[i]+b[j]==sum(b)-b[j]+a[i]:
if (a[i]+b[j])<va:
va=a[i]+b[j]
ans=a[i],b[j]
print(*ans)
``` | output | 1 | 91,655 | 19 | 183,311 |
Provide a correct Python 3 solution for this coding contest problem.
Taro and Hanako have numbers of cards in their hands. Each of the cards has a score on it. Taro and Hanako wish to make the total scores of their cards equal by exchanging one card in one's hand with one card in the other's hand. Which of the cards should be exchanged with which?
Note that they have to exchange their cards even if they already have cards of the same total score.
Input
The input consists of a number of datasets. Each dataset is formatted as follows.
> n m
> s1
> s2
> ...
> sn
> sn+1
> sn+2
> ...
> sn+m
>
The first line of a dataset contains two numbers n and m delimited by a space, where n is the number of cards that Taro has and m is the number of cards that Hanako has. The subsequent n+m lines list the score for each of the cards, one score per line. The first n scores (from s1 up to sn) are the scores of Taro's cards and the remaining m scores (from sn+1 up to sn+m) are Hanako's.
The numbers n and m are positive integers no greater than 100. Each score is a non-negative integer no greater than 100.
The end of the input is indicated by a line containing two zeros delimited by a single space.
Output
For each dataset, output a single line containing two numbers delimited by a single space, where the first number is the score of the card Taro gives to Hanako and the second number is the score of the card Hanako gives to Taro. If there is more than one way to exchange a pair of cards that makes the total scores equal, output a pair of scores whose sum is the smallest.
In case no exchange can make the total scores equal, output a single line containing solely -1. The output must not contain any superfluous characters that do not conform to the format.
Sample Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output for the Sample Input
1 3
3 5
-1
2 2
-1
Example
Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output
1 3
3 5
-1
2 2
-1 | instruction | 0 | 91,656 | 19 | 183,312 |
"Correct Solution:
```
while True:
n,m = map(int,input().split())
if n == m == 0: break
c1 = [int(input()) for i in range(n)]
c2 = [int(input()) for i in range(m)]
diff = sum(c1) - sum(c2)
if diff % 2 == 1:
print(-1)
continue
for v1 in sorted(c1):
v2 = v1 - diff//2
if v2 in c2:
print('{0} {1}'.format(v1, v2))
break
else:
print(-1)
``` | output | 1 | 91,656 | 19 | 183,313 |
Provide a correct Python 3 solution for this coding contest problem.
Taro and Hanako have numbers of cards in their hands. Each of the cards has a score on it. Taro and Hanako wish to make the total scores of their cards equal by exchanging one card in one's hand with one card in the other's hand. Which of the cards should be exchanged with which?
Note that they have to exchange their cards even if they already have cards of the same total score.
Input
The input consists of a number of datasets. Each dataset is formatted as follows.
> n m
> s1
> s2
> ...
> sn
> sn+1
> sn+2
> ...
> sn+m
>
The first line of a dataset contains two numbers n and m delimited by a space, where n is the number of cards that Taro has and m is the number of cards that Hanako has. The subsequent n+m lines list the score for each of the cards, one score per line. The first n scores (from s1 up to sn) are the scores of Taro's cards and the remaining m scores (from sn+1 up to sn+m) are Hanako's.
The numbers n and m are positive integers no greater than 100. Each score is a non-negative integer no greater than 100.
The end of the input is indicated by a line containing two zeros delimited by a single space.
Output
For each dataset, output a single line containing two numbers delimited by a single space, where the first number is the score of the card Taro gives to Hanako and the second number is the score of the card Hanako gives to Taro. If there is more than one way to exchange a pair of cards that makes the total scores equal, output a pair of scores whose sum is the smallest.
In case no exchange can make the total scores equal, output a single line containing solely -1. The output must not contain any superfluous characters that do not conform to the format.
Sample Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output for the Sample Input
1 3
3 5
-1
2 2
-1
Example
Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output
1 3
3 5
-1
2 2
-1 | instruction | 0 | 91,657 | 19 | 183,314 |
"Correct Solution:
```
while True:
n, m = map(int, input().split())
if n == 0:
break
a = [0] * n
b = [0] * m
sum_a = 0
sum_b = 0
for i in range(n):
a[i] = int(input())
sum_a += a[i]
for i in range(m):
b[i] = int(input())
sum_b += b[i]
a = sorted(a)
b = sorted(b)
d = sum_a - sum_b
if d % 2 != 0:
print(-1)
else:
d /= 2
ok = False
for i in range(n):
for j in range(m):
if a[i] - b[j] == d:
print(a[i], b[j])
ok = True
break
if ok:
break
if not ok:
print(-1)
``` | output | 1 | 91,657 | 19 | 183,315 |
Provide a correct Python 3 solution for this coding contest problem.
Taro and Hanako have numbers of cards in their hands. Each of the cards has a score on it. Taro and Hanako wish to make the total scores of their cards equal by exchanging one card in one's hand with one card in the other's hand. Which of the cards should be exchanged with which?
Note that they have to exchange their cards even if they already have cards of the same total score.
Input
The input consists of a number of datasets. Each dataset is formatted as follows.
> n m
> s1
> s2
> ...
> sn
> sn+1
> sn+2
> ...
> sn+m
>
The first line of a dataset contains two numbers n and m delimited by a space, where n is the number of cards that Taro has and m is the number of cards that Hanako has. The subsequent n+m lines list the score for each of the cards, one score per line. The first n scores (from s1 up to sn) are the scores of Taro's cards and the remaining m scores (from sn+1 up to sn+m) are Hanako's.
The numbers n and m are positive integers no greater than 100. Each score is a non-negative integer no greater than 100.
The end of the input is indicated by a line containing two zeros delimited by a single space.
Output
For each dataset, output a single line containing two numbers delimited by a single space, where the first number is the score of the card Taro gives to Hanako and the second number is the score of the card Hanako gives to Taro. If there is more than one way to exchange a pair of cards that makes the total scores equal, output a pair of scores whose sum is the smallest.
In case no exchange can make the total scores equal, output a single line containing solely -1. The output must not contain any superfluous characters that do not conform to the format.
Sample Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output for the Sample Input
1 3
3 5
-1
2 2
-1
Example
Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output
1 3
3 5
-1
2 2
-1 | instruction | 0 | 91,658 | 19 | 183,316 |
"Correct Solution:
```
Answer = []
while True:
inp = input().split()
n = int(inp[0])
m = int(inp[1])
c = n**2 + m**2
if c == 0:
break
T = []
for t in range(n):
inp = int(input())
T.append(inp)
H = []
for h in range(m):
inp = int(input())
H.append(inp)
Temp = []
for i in range(n):
for j in range(m):
if sum(T)-2*T[i] == sum(H)-2*H[j]:
TTemp = [T[i],H[j]]
Temp.append(TTemp)
if len(Temp) == 0:
Answer.append(-1)
else:
S = sum(Temp[0])
flg = 0
for k in range(len(Temp)):
if sum(Temp[k]) < S:
flg = k
S = min(S,sum(Temp[k]))
Answer.append(str(Temp[flg][0])+" "+str(Temp[flg][1]))
for l in range(len(Answer)):
print(Answer[l])
``` | output | 1 | 91,658 | 19 | 183,317 |
Provide a correct Python 3 solution for this coding contest problem.
Taro and Hanako have numbers of cards in their hands. Each of the cards has a score on it. Taro and Hanako wish to make the total scores of their cards equal by exchanging one card in one's hand with one card in the other's hand. Which of the cards should be exchanged with which?
Note that they have to exchange their cards even if they already have cards of the same total score.
Input
The input consists of a number of datasets. Each dataset is formatted as follows.
> n m
> s1
> s2
> ...
> sn
> sn+1
> sn+2
> ...
> sn+m
>
The first line of a dataset contains two numbers n and m delimited by a space, where n is the number of cards that Taro has and m is the number of cards that Hanako has. The subsequent n+m lines list the score for each of the cards, one score per line. The first n scores (from s1 up to sn) are the scores of Taro's cards and the remaining m scores (from sn+1 up to sn+m) are Hanako's.
The numbers n and m are positive integers no greater than 100. Each score is a non-negative integer no greater than 100.
The end of the input is indicated by a line containing two zeros delimited by a single space.
Output
For each dataset, output a single line containing two numbers delimited by a single space, where the first number is the score of the card Taro gives to Hanako and the second number is the score of the card Hanako gives to Taro. If there is more than one way to exchange a pair of cards that makes the total scores equal, output a pair of scores whose sum is the smallest.
In case no exchange can make the total scores equal, output a single line containing solely -1. The output must not contain any superfluous characters that do not conform to the format.
Sample Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output for the Sample Input
1 3
3 5
-1
2 2
-1
Example
Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output
1 3
3 5
-1
2 2
-1 | instruction | 0 | 91,659 | 19 | 183,318 |
"Correct Solution:
```
while True:
n,m = map(int,input().split())
if n==m==0: break
taro = [int(input()) for i in range(n)]
hanako = [int(input()) for i in range(m)]
ans1 = []; ans2 = []
for i in sorted(taro):
for j in sorted(hanako):
if sum(taro)-i+j == sum(hanako)-j+i:
ans1.append(i); ans2.append(j)
if len(ans1)==len(ans2)==0: print(-1)
else: print(ans1[0],ans2[0])
``` | output | 1 | 91,659 | 19 | 183,319 |
Provide a correct Python 3 solution for this coding contest problem.
Taro and Hanako have numbers of cards in their hands. Each of the cards has a score on it. Taro and Hanako wish to make the total scores of their cards equal by exchanging one card in one's hand with one card in the other's hand. Which of the cards should be exchanged with which?
Note that they have to exchange their cards even if they already have cards of the same total score.
Input
The input consists of a number of datasets. Each dataset is formatted as follows.
> n m
> s1
> s2
> ...
> sn
> sn+1
> sn+2
> ...
> sn+m
>
The first line of a dataset contains two numbers n and m delimited by a space, where n is the number of cards that Taro has and m is the number of cards that Hanako has. The subsequent n+m lines list the score for each of the cards, one score per line. The first n scores (from s1 up to sn) are the scores of Taro's cards and the remaining m scores (from sn+1 up to sn+m) are Hanako's.
The numbers n and m are positive integers no greater than 100. Each score is a non-negative integer no greater than 100.
The end of the input is indicated by a line containing two zeros delimited by a single space.
Output
For each dataset, output a single line containing two numbers delimited by a single space, where the first number is the score of the card Taro gives to Hanako and the second number is the score of the card Hanako gives to Taro. If there is more than one way to exchange a pair of cards that makes the total scores equal, output a pair of scores whose sum is the smallest.
In case no exchange can make the total scores equal, output a single line containing solely -1. The output must not contain any superfluous characters that do not conform to the format.
Sample Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output for the Sample Input
1 3
3 5
-1
2 2
-1
Example
Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output
1 3
3 5
-1
2 2
-1 | instruction | 0 | 91,660 | 19 | 183,320 |
"Correct Solution:
```
ans_list = []
while True:
n,m = map(int,input().split())
if (n,m) == (0,0):
break
S = [int(input()) for _ in range(n)]
T = [int(input()) for _ in range(m)]
ss = sum(S)
tt = sum(T)
ans = (101,101)
for s in S:
for t in T:
if ss - s + t == tt - t + s and s + t < sum(ans):
ans = (s,t)
if ans == (101,101):
ans = -1
else:
ans = "{} {}".format(ans[0],ans[1])
ans_list.append(ans)
for ans in ans_list:
print(ans)
``` | output | 1 | 91,660 | 19 | 183,321 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Taro and Hanako have numbers of cards in their hands. Each of the cards has a score on it. Taro and Hanako wish to make the total scores of their cards equal by exchanging one card in one's hand with one card in the other's hand. Which of the cards should be exchanged with which?
Note that they have to exchange their cards even if they already have cards of the same total score.
Input
The input consists of a number of datasets. Each dataset is formatted as follows.
> n m
> s1
> s2
> ...
> sn
> sn+1
> sn+2
> ...
> sn+m
>
The first line of a dataset contains two numbers n and m delimited by a space, where n is the number of cards that Taro has and m is the number of cards that Hanako has. The subsequent n+m lines list the score for each of the cards, one score per line. The first n scores (from s1 up to sn) are the scores of Taro's cards and the remaining m scores (from sn+1 up to sn+m) are Hanako's.
The numbers n and m are positive integers no greater than 100. Each score is a non-negative integer no greater than 100.
The end of the input is indicated by a line containing two zeros delimited by a single space.
Output
For each dataset, output a single line containing two numbers delimited by a single space, where the first number is the score of the card Taro gives to Hanako and the second number is the score of the card Hanako gives to Taro. If there is more than one way to exchange a pair of cards that makes the total scores equal, output a pair of scores whose sum is the smallest.
In case no exchange can make the total scores equal, output a single line containing solely -1. The output must not contain any superfluous characters that do not conform to the format.
Sample Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output for the Sample Input
1 3
3 5
-1
2 2
-1
Example
Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output
1 3
3 5
-1
2 2
-1
Submitted Solution:
```
#!/usr/bin/python3
while True:
n, m = list(map(int, input().split()))
if n == 0 and m == 0: break
taro = []
hanako = []
for i in range(n):
taro.append(int(input()))
for i in range(m):
hanako.append(int(input()))
sum_taro = sum(taro)
sum_hana = sum(hanako)
dif = sum_taro - sum_hana
# print("taro:",taro)
# print("hana:",hanako)
# print("dif:",dif)
ans_t, ans_h = 101, 101 # 0 <= point <= 100
for t in taro:
for h in hanako:
if (sum_taro - t + h) == (sum_hana - h + t) \
and (t + h) < (ans_t + ans_h):
ans_t, ans_h = t, h
if (ans_t + ans_h) == 202:
print(-1)
else:
print(ans_t, ans_h)
# sign_t = 1
# sign_h = 1
# if sum_taro < sum_hana:
# sign_h = -1
# elif sum_taro > sum_hana:
# sign_t = -1
# #if dif = 0 do nothing
#
# print("signs(t,h):",sign_t, sign_h)
# for t in taro:
# for h in hanako:
# t *= sign_h
# h *= sign_t
# if (sum_taro + h) == (sum_hana + t):
# print(abs(t), abs(h))
# break
# else:
# continue
# break
# else:
# print(-1)
``` | instruction | 0 | 91,661 | 19 | 183,322 |
Yes | output | 1 | 91,661 | 19 | 183,323 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Taro and Hanako have numbers of cards in their hands. Each of the cards has a score on it. Taro and Hanako wish to make the total scores of their cards equal by exchanging one card in one's hand with one card in the other's hand. Which of the cards should be exchanged with which?
Note that they have to exchange their cards even if they already have cards of the same total score.
Input
The input consists of a number of datasets. Each dataset is formatted as follows.
> n m
> s1
> s2
> ...
> sn
> sn+1
> sn+2
> ...
> sn+m
>
The first line of a dataset contains two numbers n and m delimited by a space, where n is the number of cards that Taro has and m is the number of cards that Hanako has. The subsequent n+m lines list the score for each of the cards, one score per line. The first n scores (from s1 up to sn) are the scores of Taro's cards and the remaining m scores (from sn+1 up to sn+m) are Hanako's.
The numbers n and m are positive integers no greater than 100. Each score is a non-negative integer no greater than 100.
The end of the input is indicated by a line containing two zeros delimited by a single space.
Output
For each dataset, output a single line containing two numbers delimited by a single space, where the first number is the score of the card Taro gives to Hanako and the second number is the score of the card Hanako gives to Taro. If there is more than one way to exchange a pair of cards that makes the total scores equal, output a pair of scores whose sum is the smallest.
In case no exchange can make the total scores equal, output a single line containing solely -1. The output must not contain any superfluous characters that do not conform to the format.
Sample Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output for the Sample Input
1 3
3 5
-1
2 2
-1
Example
Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output
1 3
3 5
-1
2 2
-1
Submitted Solution:
```
while True:
n,m=map(int,input().split())
if n==0 and m==0:
break
tarou=[]
hanako=[]
kumit=[]
kumih=[]
wa=[]
for i in range(n):
tarou.append(int(input()))
for i in range(m):
hanako.append(int(input()))
for i in range(n):
a=tarou[i]
for j in range(m):
b=hanako[j]
x=sum(tarou)-a+b
y=sum(hanako)-b+a
if x==y:
kumit.append(tarou[i])
kumih.append(hanako[j])
wa.append(tarou[i]+hanako[j])
if wa!=[]:
for i in range(len(wa)):
if wa[i]==min(wa):
print(kumit[i],kumih[i])
break
else:
print(-1)
``` | instruction | 0 | 91,662 | 19 | 183,324 |
Yes | output | 1 | 91,662 | 19 | 183,325 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Taro and Hanako have numbers of cards in their hands. Each of the cards has a score on it. Taro and Hanako wish to make the total scores of their cards equal by exchanging one card in one's hand with one card in the other's hand. Which of the cards should be exchanged with which?
Note that they have to exchange their cards even if they already have cards of the same total score.
Input
The input consists of a number of datasets. Each dataset is formatted as follows.
> n m
> s1
> s2
> ...
> sn
> sn+1
> sn+2
> ...
> sn+m
>
The first line of a dataset contains two numbers n and m delimited by a space, where n is the number of cards that Taro has and m is the number of cards that Hanako has. The subsequent n+m lines list the score for each of the cards, one score per line. The first n scores (from s1 up to sn) are the scores of Taro's cards and the remaining m scores (from sn+1 up to sn+m) are Hanako's.
The numbers n and m are positive integers no greater than 100. Each score is a non-negative integer no greater than 100.
The end of the input is indicated by a line containing two zeros delimited by a single space.
Output
For each dataset, output a single line containing two numbers delimited by a single space, where the first number is the score of the card Taro gives to Hanako and the second number is the score of the card Hanako gives to Taro. If there is more than one way to exchange a pair of cards that makes the total scores equal, output a pair of scores whose sum is the smallest.
In case no exchange can make the total scores equal, output a single line containing solely -1. The output must not contain any superfluous characters that do not conform to the format.
Sample Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output for the Sample Input
1 3
3 5
-1
2 2
-1
Example
Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output
1 3
3 5
-1
2 2
-1
Submitted Solution:
```
while True:
n,m=map(int,input().split())
if n==0:
break
a=[int(input()) for _ in range(n)]
b=[int(input()) for _ in range(m)]
a.sort()
b.sort()
sumA=sum(a)
sumB=sum(b)
def search():
for i in a:
for j in b:
if (i-j)*2==sumA-sumB:
print(i,j)
return
print(-1)
search()
``` | instruction | 0 | 91,663 | 19 | 183,326 |
Yes | output | 1 | 91,663 | 19 | 183,327 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Taro and Hanako have numbers of cards in their hands. Each of the cards has a score on it. Taro and Hanako wish to make the total scores of their cards equal by exchanging one card in one's hand with one card in the other's hand. Which of the cards should be exchanged with which?
Note that they have to exchange their cards even if they already have cards of the same total score.
Input
The input consists of a number of datasets. Each dataset is formatted as follows.
> n m
> s1
> s2
> ...
> sn
> sn+1
> sn+2
> ...
> sn+m
>
The first line of a dataset contains two numbers n and m delimited by a space, where n is the number of cards that Taro has and m is the number of cards that Hanako has. The subsequent n+m lines list the score for each of the cards, one score per line. The first n scores (from s1 up to sn) are the scores of Taro's cards and the remaining m scores (from sn+1 up to sn+m) are Hanako's.
The numbers n and m are positive integers no greater than 100. Each score is a non-negative integer no greater than 100.
The end of the input is indicated by a line containing two zeros delimited by a single space.
Output
For each dataset, output a single line containing two numbers delimited by a single space, where the first number is the score of the card Taro gives to Hanako and the second number is the score of the card Hanako gives to Taro. If there is more than one way to exchange a pair of cards that makes the total scores equal, output a pair of scores whose sum is the smallest.
In case no exchange can make the total scores equal, output a single line containing solely -1. The output must not contain any superfluous characters that do not conform to the format.
Sample Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output for the Sample Input
1 3
3 5
-1
2 2
-1
Example
Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output
1 3
3 5
-1
2 2
-1
Submitted Solution:
```
def search(t,st,h,sh):
for ta in t:
for ha in h:
if st-ta+ha==sh-ha+ta: return ' '.join(map(str,[ta,ha]))
return -1
while True:
n,m = map(int,input().split())
if n==m==0: break
t = sorted([int(input()) for _ in range(n)])
h = sorted([int(input()) for _ in range(m)])
st,sh = sum(t),sum(h)
r = search(t,st,h,sh)
print(r)
``` | instruction | 0 | 91,664 | 19 | 183,328 |
Yes | output | 1 | 91,664 | 19 | 183,329 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Taro and Hanako have numbers of cards in their hands. Each of the cards has a score on it. Taro and Hanako wish to make the total scores of their cards equal by exchanging one card in one's hand with one card in the other's hand. Which of the cards should be exchanged with which?
Note that they have to exchange their cards even if they already have cards of the same total score.
Input
The input consists of a number of datasets. Each dataset is formatted as follows.
> n m
> s1
> s2
> ...
> sn
> sn+1
> sn+2
> ...
> sn+m
>
The first line of a dataset contains two numbers n and m delimited by a space, where n is the number of cards that Taro has and m is the number of cards that Hanako has. The subsequent n+m lines list the score for each of the cards, one score per line. The first n scores (from s1 up to sn) are the scores of Taro's cards and the remaining m scores (from sn+1 up to sn+m) are Hanako's.
The numbers n and m are positive integers no greater than 100. Each score is a non-negative integer no greater than 100.
The end of the input is indicated by a line containing two zeros delimited by a single space.
Output
For each dataset, output a single line containing two numbers delimited by a single space, where the first number is the score of the card Taro gives to Hanako and the second number is the score of the card Hanako gives to Taro. If there is more than one way to exchange a pair of cards that makes the total scores equal, output a pair of scores whose sum is the smallest.
In case no exchange can make the total scores equal, output a single line containing solely -1. The output must not contain any superfluous characters that do not conform to the format.
Sample Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output for the Sample Input
1 3
3 5
-1
2 2
-1
Example
Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output
1 3
3 5
-1
2 2
-1
Submitted Solution:
```
#include <bits/stdc++.h>
using namespace std;
int main() {
while (1) {
int n, m, x, sum1 = 0, sum2 = 0, ans = 100000, num, ax = 0, ay = 0;
vector<int> N, M;
cin >> n >> m;
if (n == 0 && m == 0) break;
for (int i = n; i--;) {
cin >> x;
sum1 += x;
N.push_back(x);
}
for (int i = m; i--;) {
cin >> x;
sum2 += x;
M.push_back(x);
}
num = sum1 - sum2;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (num == 2 * (N[i] - M[j]) && ans > N[i] + M[j]) {
ans = N[i] + M[j];
ax = N[i];
ay = M[j];
}
}
}
if (ax == 0 && ay == 0)
cout << "-1\n";
else
cout << ax << " " << ay << "\n";
}
}
``` | instruction | 0 | 91,665 | 19 | 183,330 |
No | output | 1 | 91,665 | 19 | 183,331 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Taro and Hanako have numbers of cards in their hands. Each of the cards has a score on it. Taro and Hanako wish to make the total scores of their cards equal by exchanging one card in one's hand with one card in the other's hand. Which of the cards should be exchanged with which?
Note that they have to exchange their cards even if they already have cards of the same total score.
Input
The input consists of a number of datasets. Each dataset is formatted as follows.
> n m
> s1
> s2
> ...
> sn
> sn+1
> sn+2
> ...
> sn+m
>
The first line of a dataset contains two numbers n and m delimited by a space, where n is the number of cards that Taro has and m is the number of cards that Hanako has. The subsequent n+m lines list the score for each of the cards, one score per line. The first n scores (from s1 up to sn) are the scores of Taro's cards and the remaining m scores (from sn+1 up to sn+m) are Hanako's.
The numbers n and m are positive integers no greater than 100. Each score is a non-negative integer no greater than 100.
The end of the input is indicated by a line containing two zeros delimited by a single space.
Output
For each dataset, output a single line containing two numbers delimited by a single space, where the first number is the score of the card Taro gives to Hanako and the second number is the score of the card Hanako gives to Taro. If there is more than one way to exchange a pair of cards that makes the total scores equal, output a pair of scores whose sum is the smallest.
In case no exchange can make the total scores equal, output a single line containing solely -1. The output must not contain any superfluous characters that do not conform to the format.
Sample Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output for the Sample Input
1 3
3 5
-1
2 2
-1
Example
Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output
1 3
3 5
-1
2 2
-1
Submitted Solution:
```
def answer(n, m, taro, hanako):
for t in sorted(taro):
fot h in (hanako):
if sum(taro) - t + h == sum(hanako) - h + t:
return f'{t} {h}'
return -1
while True:
n, m = map(int, input().split())
if n == 0 and m == 0:
break
taro = []
hanako = []
for i in range(n):
taro.append(int(input()))
for i in range(m):
hanako.append(int(input()))
print(answer(n, m, taro, hanako))
``` | instruction | 0 | 91,666 | 19 | 183,332 |
No | output | 1 | 91,666 | 19 | 183,333 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Taro and Hanako have numbers of cards in their hands. Each of the cards has a score on it. Taro and Hanako wish to make the total scores of their cards equal by exchanging one card in one's hand with one card in the other's hand. Which of the cards should be exchanged with which?
Note that they have to exchange their cards even if they already have cards of the same total score.
Input
The input consists of a number of datasets. Each dataset is formatted as follows.
> n m
> s1
> s2
> ...
> sn
> sn+1
> sn+2
> ...
> sn+m
>
The first line of a dataset contains two numbers n and m delimited by a space, where n is the number of cards that Taro has and m is the number of cards that Hanako has. The subsequent n+m lines list the score for each of the cards, one score per line. The first n scores (from s1 up to sn) are the scores of Taro's cards and the remaining m scores (from sn+1 up to sn+m) are Hanako's.
The numbers n and m are positive integers no greater than 100. Each score is a non-negative integer no greater than 100.
The end of the input is indicated by a line containing two zeros delimited by a single space.
Output
For each dataset, output a single line containing two numbers delimited by a single space, where the first number is the score of the card Taro gives to Hanako and the second number is the score of the card Hanako gives to Taro. If there is more than one way to exchange a pair of cards that makes the total scores equal, output a pair of scores whose sum is the smallest.
In case no exchange can make the total scores equal, output a single line containing solely -1. The output must not contain any superfluous characters that do not conform to the format.
Sample Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output for the Sample Input
1 3
3 5
-1
2 2
-1
Example
Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output
1 3
3 5
-1
2 2
-1
Submitted Solution:
```
def answer(n, m, taro, hanako):
for t in sorted(taro):
for h in sorted(hanako):
if sum(taro) - t + h == sum(hanako) - h + t:
return '{t} {h}'
return -1
while True:
n, m = map(int, input().split())
if n == 0 and m == 0:
break
taro = []
hanako = []
for I in range(n)
taro.append(int(input()))
for I in range(m)
hanako.append(int(input()))
print(answer(n, m, taro, hanako)
``` | instruction | 0 | 91,667 | 19 | 183,334 |
No | output | 1 | 91,667 | 19 | 183,335 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Taro and Hanako have numbers of cards in their hands. Each of the cards has a score on it. Taro and Hanako wish to make the total scores of their cards equal by exchanging one card in one's hand with one card in the other's hand. Which of the cards should be exchanged with which?
Note that they have to exchange their cards even if they already have cards of the same total score.
Input
The input consists of a number of datasets. Each dataset is formatted as follows.
> n m
> s1
> s2
> ...
> sn
> sn+1
> sn+2
> ...
> sn+m
>
The first line of a dataset contains two numbers n and m delimited by a space, where n is the number of cards that Taro has and m is the number of cards that Hanako has. The subsequent n+m lines list the score for each of the cards, one score per line. The first n scores (from s1 up to sn) are the scores of Taro's cards and the remaining m scores (from sn+1 up to sn+m) are Hanako's.
The numbers n and m are positive integers no greater than 100. Each score is a non-negative integer no greater than 100.
The end of the input is indicated by a line containing two zeros delimited by a single space.
Output
For each dataset, output a single line containing two numbers delimited by a single space, where the first number is the score of the card Taro gives to Hanako and the second number is the score of the card Hanako gives to Taro. If there is more than one way to exchange a pair of cards that makes the total scores equal, output a pair of scores whose sum is the smallest.
In case no exchange can make the total scores equal, output a single line containing solely -1. The output must not contain any superfluous characters that do not conform to the format.
Sample Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output for the Sample Input
1 3
3 5
-1
2 2
-1
Example
Input
2 2
1
5
3
7
6 5
3
9
5
2
3
3
12
2
7
3
5
4 5
10
0
3
8
1
9
6
0
6
7 4
1
1
2
1
2
1
4
2
3
4
3
2 3
1
1
2
2
2
0 0
Output
1 3
3 5
-1
2 2
-1
Submitted Solution:
```
def impossible(taro_cards, hanako_cards, average):
if (sum(taro_cards) + sum(hanako_cards)) % 2 == 1:
return True
elif sum(taro_cards) + max(taro_cards) - min(hanako_cards) < average:
return True
elif sum(hanako_cards) + max(hanako_cards) - min(taro_cards) < average:
return True
else:
return False
while True:
n_taro, n_hanako = map(int, input().split())
if n_taro == 0 and n_hanako == 0:
break
taro_cards = []
hanako_cards = []
change_pairs = []
for i in range(n_taro):
taro_cards.append(int(input()))
for i in range(n_hanako):
hanako_cards.append(int(input()))
average = (sum(taro_cards) + sum(hanako_cards)) // 2
if impossible(taro_cards, hanako_cards, average):
print(-1)
else:
# record pairs of cards to be changed
for i in range(len(taro_cards)):
for j in range(len(hanako_cards)):
if sum(taro_cards[:i]) + sum(taro_cards[i+1:]) + hanako_cards[j] == average:
change_pairs.append((taro_cards[i], hanako_cards[j]))
# print("{0} {1}".format(taro_cards[i], hanako_cards[j]))
# print the pair of cards to be changed
pairs_leastsum = change_pairs[0]
for i in range(1, len(change_pairs)):
if sum(change_pairs[i]) <= sum(pairs_leastsum):
pairs_leastsum = change_pairs[i]
print(*pairs_leastsum)
``` | instruction | 0 | 91,668 | 19 | 183,336 |
No | output | 1 | 91,668 | 19 | 183,337 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lee is used to finish his stories in a stylish way, this time he barely failed it, but Ice Bear came and helped him. Lee is so grateful for it, so he decided to show Ice Bear his new game called "Critic"...
The game is a one versus one game. It has t rounds, each round has two integers s_i and e_i (which are determined and are known before the game begins, s_i and e_i may differ from round to round). The integer s_i is written on the board at the beginning of the corresponding round.
The players will take turns. Each player will erase the number on the board (let's say it was a) and will choose to write either 2 ⋅ a or a + 1 instead. Whoever writes a number strictly greater than e_i loses that round and the other one wins that round.
Now Lee wants to play "Critic" against Ice Bear, for each round he has chosen the round's s_i and e_i in advance. Lee will start the first round, the loser of each round will start the next round.
The winner of the last round is the winner of the game, and the loser of the last round is the loser of the game.
Determine if Lee can be the winner independent of Ice Bear's moves or not. Also, determine if Lee can be the loser independent of Ice Bear's moves or not.
Input
The first line contains the integer t (1 ≤ t ≤ 10^5) — the number of rounds the game has.
Then t lines follow, each contains two integers s_i and e_i (1 ≤ s_i ≤ e_i ≤ 10^{18}) — the i-th round's information.
The rounds are played in the same order as given in input, s_i and e_i for all rounds are known to everyone before the game starts.
Output
Print two integers.
The first one should be 1 if Lee can be the winner independent of Ice Bear's moves, and 0 otherwise.
The second one should be 1 if Lee can be the loser independent of Ice Bear's moves, and 0 otherwise.
Examples
Input
3
5 8
1 4
3 10
Output
1 1
Input
4
1 2
2 3
3 4
4 5
Output
0 0
Input
1
1 1
Output
0 1
Input
2
1 9
4 5
Output
0 0
Input
2
1 2
2 8
Output
1 0
Input
6
216986951114298167 235031205335543871
148302405431848579 455670351549314242
506251128322958430 575521452907339082
1 768614336404564650
189336074809158272 622104412002885672
588320087414024192 662540324268197150
Output
1 0
Note
Remember, whoever writes an integer greater than e_i loses. | instruction | 0 | 91,892 | 19 | 183,784 |
Tags: dfs and similar, dp, games
Correct Solution:
```
def win(s, e):
if e == s:return False
elif e == s + 1:return True
elif e & 1:return s & 1 == 0
elif e // 2 < s:return s & 1 == 1
elif e // 4 < s:return True
else:return win(s, e // 4)
def lose(s, e):return (True if e // 2 < s else win(s, e // 2))
def main():
res = [False, True]
for _ in range(int(input())):
s, e = [int(x) for x in input().split()]
if res == [True, True]:
continue
if res == [False, False]:
continue
cur = [win(s, e), lose(s, e)]
if res[0]:
cur = [not x for x in cur]
res = cur
print(*[int(x) for x in res])
main()
``` | output | 1 | 91,892 | 19 | 183,785 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lee is used to finish his stories in a stylish way, this time he barely failed it, but Ice Bear came and helped him. Lee is so grateful for it, so he decided to show Ice Bear his new game called "Critic"...
The game is a one versus one game. It has t rounds, each round has two integers s_i and e_i (which are determined and are known before the game begins, s_i and e_i may differ from round to round). The integer s_i is written on the board at the beginning of the corresponding round.
The players will take turns. Each player will erase the number on the board (let's say it was a) and will choose to write either 2 ⋅ a or a + 1 instead. Whoever writes a number strictly greater than e_i loses that round and the other one wins that round.
Now Lee wants to play "Critic" against Ice Bear, for each round he has chosen the round's s_i and e_i in advance. Lee will start the first round, the loser of each round will start the next round.
The winner of the last round is the winner of the game, and the loser of the last round is the loser of the game.
Determine if Lee can be the winner independent of Ice Bear's moves or not. Also, determine if Lee can be the loser independent of Ice Bear's moves or not.
Input
The first line contains the integer t (1 ≤ t ≤ 10^5) — the number of rounds the game has.
Then t lines follow, each contains two integers s_i and e_i (1 ≤ s_i ≤ e_i ≤ 10^{18}) — the i-th round's information.
The rounds are played in the same order as given in input, s_i and e_i for all rounds are known to everyone before the game starts.
Output
Print two integers.
The first one should be 1 if Lee can be the winner independent of Ice Bear's moves, and 0 otherwise.
The second one should be 1 if Lee can be the loser independent of Ice Bear's moves, and 0 otherwise.
Examples
Input
3
5 8
1 4
3 10
Output
1 1
Input
4
1 2
2 3
3 4
4 5
Output
0 0
Input
1
1 1
Output
0 1
Input
2
1 9
4 5
Output
0 0
Input
2
1 2
2 8
Output
1 0
Input
6
216986951114298167 235031205335543871
148302405431848579 455670351549314242
506251128322958430 575521452907339082
1 768614336404564650
189336074809158272 622104412002885672
588320087414024192 662540324268197150
Output
1 0
Note
Remember, whoever writes an integer greater than e_i loses. | instruction | 0 | 91,893 | 19 | 183,786 |
Tags: dfs and similar, dp, games
Correct Solution:
```
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
import threading
from heapq import heapify,heappush,heappop
def can_win(s,e):
if e%2==1:
return 1 if s%2==0 else 0
else:
if e//2<s<=e:
return 1 if s%2==1 else 0
if e//4<s<=e//2:
return 1
else:
return can_win(s,e//4)
def main():
t=int(input())
res=[]
for i in range(t):
si,ei=map(int,input().split())
res.append([ can_win(si,ei) , can_win(si,ei//2) if ei>=2*si else 1 ])
# print(res)
c=res
f = 1;
s = 0;
for i in range(t):
if(f == 1 and s == 1) : break
if(f == 0 and s == 0) :break
if(s == 1) :
c[i][0]^=1
c[i][1]^=1
f = c[i][1]
s = c[i][0]
print(s,f)
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")
# endregion
if __name__ == "__main__":
main()
``` | output | 1 | 91,893 | 19 | 183,787 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lee is used to finish his stories in a stylish way, this time he barely failed it, but Ice Bear came and helped him. Lee is so grateful for it, so he decided to show Ice Bear his new game called "Critic"...
The game is a one versus one game. It has t rounds, each round has two integers s_i and e_i (which are determined and are known before the game begins, s_i and e_i may differ from round to round). The integer s_i is written on the board at the beginning of the corresponding round.
The players will take turns. Each player will erase the number on the board (let's say it was a) and will choose to write either 2 ⋅ a or a + 1 instead. Whoever writes a number strictly greater than e_i loses that round and the other one wins that round.
Now Lee wants to play "Critic" against Ice Bear, for each round he has chosen the round's s_i and e_i in advance. Lee will start the first round, the loser of each round will start the next round.
The winner of the last round is the winner of the game, and the loser of the last round is the loser of the game.
Determine if Lee can be the winner independent of Ice Bear's moves or not. Also, determine if Lee can be the loser independent of Ice Bear's moves or not.
Input
The first line contains the integer t (1 ≤ t ≤ 10^5) — the number of rounds the game has.
Then t lines follow, each contains two integers s_i and e_i (1 ≤ s_i ≤ e_i ≤ 10^{18}) — the i-th round's information.
The rounds are played in the same order as given in input, s_i and e_i for all rounds are known to everyone before the game starts.
Output
Print two integers.
The first one should be 1 if Lee can be the winner independent of Ice Bear's moves, and 0 otherwise.
The second one should be 1 if Lee can be the loser independent of Ice Bear's moves, and 0 otherwise.
Examples
Input
3
5 8
1 4
3 10
Output
1 1
Input
4
1 2
2 3
3 4
4 5
Output
0 0
Input
1
1 1
Output
0 1
Input
2
1 9
4 5
Output
0 0
Input
2
1 2
2 8
Output
1 0
Input
6
216986951114298167 235031205335543871
148302405431848579 455670351549314242
506251128322958430 575521452907339082
1 768614336404564650
189336074809158272 622104412002885672
588320087414024192 662540324268197150
Output
1 0
Note
Remember, whoever writes an integer greater than e_i loses. | instruction | 0 | 91,894 | 19 | 183,788 |
Tags: dfs and similar, dp, games
Correct Solution:
```
import sys
input = sys.stdin.readline
def win(s, e):
if e == s:
return False
elif e == s + 1:
return True
elif e & 1:
return s & 1 == 0
elif e // 2 < s:
return s & 1 == 1
elif e // 4 < s:
return True
else:
return win(s, e // 4)
def lose(s, e):
if e // 2 < s:
return True
else:
return win(s, e // 2)
def main():
res = [False, True]
for _ in range(int(input())):
s, e = [int(x) for x in input().split()]
if res == [True, True]:
continue
if res == [False, False]:
continue
cur = [win(s, e), lose(s, e)]
if res[0]:
cur = [not x for x in cur]
res = cur
print(*[int(x) for x in res])
main()
``` | output | 1 | 91,894 | 19 | 183,789 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lee is used to finish his stories in a stylish way, this time he barely failed it, but Ice Bear came and helped him. Lee is so grateful for it, so he decided to show Ice Bear his new game called "Critic"...
The game is a one versus one game. It has t rounds, each round has two integers s_i and e_i (which are determined and are known before the game begins, s_i and e_i may differ from round to round). The integer s_i is written on the board at the beginning of the corresponding round.
The players will take turns. Each player will erase the number on the board (let's say it was a) and will choose to write either 2 ⋅ a or a + 1 instead. Whoever writes a number strictly greater than e_i loses that round and the other one wins that round.
Now Lee wants to play "Critic" against Ice Bear, for each round he has chosen the round's s_i and e_i in advance. Lee will start the first round, the loser of each round will start the next round.
The winner of the last round is the winner of the game, and the loser of the last round is the loser of the game.
Determine if Lee can be the winner independent of Ice Bear's moves or not. Also, determine if Lee can be the loser independent of Ice Bear's moves or not.
Input
The first line contains the integer t (1 ≤ t ≤ 10^5) — the number of rounds the game has.
Then t lines follow, each contains two integers s_i and e_i (1 ≤ s_i ≤ e_i ≤ 10^{18}) — the i-th round's information.
The rounds are played in the same order as given in input, s_i and e_i for all rounds are known to everyone before the game starts.
Output
Print two integers.
The first one should be 1 if Lee can be the winner independent of Ice Bear's moves, and 0 otherwise.
The second one should be 1 if Lee can be the loser independent of Ice Bear's moves, and 0 otherwise.
Examples
Input
3
5 8
1 4
3 10
Output
1 1
Input
4
1 2
2 3
3 4
4 5
Output
0 0
Input
1
1 1
Output
0 1
Input
2
1 9
4 5
Output
0 0
Input
2
1 2
2 8
Output
1 0
Input
6
216986951114298167 235031205335543871
148302405431848579 455670351549314242
506251128322958430 575521452907339082
1 768614336404564650
189336074809158272 622104412002885672
588320087414024192 662540324268197150
Output
1 0
Note
Remember, whoever writes an integer greater than e_i loses. | instruction | 0 | 91,895 | 19 | 183,790 |
Tags: dfs and similar, dp, games
Correct Solution:
```
def f(s,e):
if e%2:
return 1-s%2
elif s*2>e:
return s%2
else:
return g(s,e//2)
def g(s,e):
if 2*s>e:
return 1
else:
return f(s,e//2)
a=[tuple(map(int,input().split())) for i in range(int(input()))]
b=1
for i in a:
b1=g(*i)|(f(*i)<<1)
b=b1^3 if b==2 else b1
if b==0:
print('0 0')
exit(0)
elif b==3:
print('1 1')
exit(0)
if b==2:
print('1 0')
else:
print('0 1')
``` | output | 1 | 91,895 | 19 | 183,791 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.