text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
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.
Tags: number theory
Correct Solution:
```
n = int(input())
res = n
while n != 1:
i = 2
while i*i <= n:
if not(n%i):
break
i += 1
if i*i > n:
n = 1
else:
n //= i
res += n
print(res)
```
| 92,900 |
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.
Tags: number theory
Correct Solution:
```
n = int(input())
i = 2
s = n
m = int(n ** 0.5)
while n > 1 and i <= m:
if n % i:
i += 1
else:
n //= i
s += n
print(s + (n > 1))
```
| 92,901 |
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.
Tags: number theory
Correct Solution:
```
from collections import Counter
def factors(n):
if n == 1:
return [1]
i = 2
factors = []
while i * i <= n:
if n % i == 0:
while n % i == 0:
factors.append(i)
n //= i
i += 1
if n != 1:
factors.append(n)
return factors
def main():
n = int(input())
res = n
for e in factors(n):
n //= e
res += n
print(res)
if __name__ == '__main__':
main()
```
| 92,902 |
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.
Tags: number theory
Correct Solution:
```
n = int(input())
result = n
while n != 1:
a = 2
while a * a <= n:
if n % a == 0:
break
a += 1
if a * a > n:
n = 1
else:
n //= a
result += n
print(result)
```
| 92,903 |
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.
Tags: number theory
Correct Solution:
```
n=int(input())
k=2
ans=n
while k*k<=n:
while n%k==0:
n//=k
ans+=n
if k==2:
k=3
else:
k+=2
if n>1:
ans+=1
print(ans)
```
| 92,904 |
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 main():
n = int(input())
sum_points = n
from math import floor, sqrt
while n > 1:
try:
max_divisor = floor(sqrt(n)) + 1
divisor = next(i for i in range(2, max_divisor) if n % i == 0)
while n % divisor == 0:
n //= divisor
sum_points += n
except StopIteration:
n = 1
sum_points += n
print(sum_points)
if __name__ == '__main__':
main()
```
Yes
| 92,905 |
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())
d=2
r=1
while d*d<=n:
while n%d<1:r+=n;n//=d
d+=1
if n>1:r+=n
print(r)
```
Yes
| 92,906 |
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 primeFact(n):
ans = []
i = 3
num = n
while n % 2 == 0:
ans.append(2)
n = n/2
num = n
while i * i < num+1:
while n % i == 0:
ans.append(i)
n = n / i
i += 2
if n > 1:
ans.append(int(n))
return ans
n = int(input())
facts = primeFact(n)
ans = n
for i in facts:
n = n // i
ans += n
if len(facts) == 1:
print(ans)
else:
print(ans)
```
Yes
| 92,907 |
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:
```
__author__ = 'Esfandiar'
import sys
input = sys.stdin.readline
n = int(input())
res = n
while n:
f=1
for i in range(2,int(n**.5)+1):
if n % i == 0:
res+= n // i
n//=i
f=0
break
if f:res+=1;break
print(res)
```
Yes
| 92,908 |
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, 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)
```
No
| 92,909 |
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:
```
number = int(input())
def rectangularGame(currentNum):
if currentNum == 1:
return 1
else:
numSqrt = int(currentNum**0.5)
div = 1
for i in range(1,numSqrt+1):
if currentNum%i == 0:
div = i
if div == 1:
return currentNum + 1
else:
return currentNum + rectangularGame(int(currentNum/div))
print(rectangularGame(number))
```
No
| 92,910 |
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:
```
a = int(input())
c = a
while a > 1:
v = 0
for i in range(2, int(a ** 0.5) + 1):
if a % i == 0:
a //= i
c += a
v = 1
if not v:
c += 1
break
print(c)
```
No
| 92,911 |
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:
```
from sys import stdin
from math import sqrt
input = stdin.readline
n = int(input())
ans = n; s = int(sqrt(n))
fact = []
for i in range(1,s+1):
if n%i == 0:
fact.append(i)
fact.append(n//i)
fact.sort()
if fact[-1] == fact[-2]:
fact.pop()
# print(*fact)
for i in range(len(fact)-1):
if fact[i+1]%fact[i] == 0:
ans += fact[i]
print(ans)
```
No
| 92,912 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Qwerty the Ranger took up a government job and arrived on planet Mars. He should stay in the secret lab and conduct some experiments on bacteria that have funny and abnormal properties. The job isn't difficult, but the salary is high.
At the beginning of the first experiment there is a single bacterium in the test tube. Every second each bacterium in the test tube divides itself into k bacteria. After that some abnormal effects create b more bacteria in the test tube. Thus, if at the beginning of some second the test tube had x bacteria, then at the end of the second it will have kx + b bacteria.
The experiment showed that after n seconds there were exactly z bacteria and the experiment ended at this point.
For the second experiment Qwerty is going to sterilize the test tube and put there t bacteria. He hasn't started the experiment yet but he already wonders, how many seconds he will need to grow at least z bacteria. The ranger thinks that the bacteria will divide by the same rule as in the first experiment.
Help Qwerty and find the minimum number of seconds needed to get a tube with at least z bacteria in the second experiment.
Input
The first line contains four space-separated integers k, b, n and t (1 β€ k, b, n, t β€ 106) β the parameters of bacterial growth, the time Qwerty needed to grow z bacteria in the first experiment and the initial number of bacteria in the second experiment, correspondingly.
Output
Print a single number β the minimum number of seconds Qwerty needs to grow at least z bacteria in the tube.
Examples
Input
3 1 3 5
Output
2
Input
1 4 4 7
Output
3
Input
2 2 4 100
Output
0
Tags: implementation, math
Correct Solution:
```
k,b,n,t =map(int,input().split())
q=k
q+=b
kil=0
while True :
if q<=t :
q*=k
q+=b
kil+=1
else :
break
kil=min(kil,n)
print(n-kil)
```
| 92,913 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Qwerty the Ranger took up a government job and arrived on planet Mars. He should stay in the secret lab and conduct some experiments on bacteria that have funny and abnormal properties. The job isn't difficult, but the salary is high.
At the beginning of the first experiment there is a single bacterium in the test tube. Every second each bacterium in the test tube divides itself into k bacteria. After that some abnormal effects create b more bacteria in the test tube. Thus, if at the beginning of some second the test tube had x bacteria, then at the end of the second it will have kx + b bacteria.
The experiment showed that after n seconds there were exactly z bacteria and the experiment ended at this point.
For the second experiment Qwerty is going to sterilize the test tube and put there t bacteria. He hasn't started the experiment yet but he already wonders, how many seconds he will need to grow at least z bacteria. The ranger thinks that the bacteria will divide by the same rule as in the first experiment.
Help Qwerty and find the minimum number of seconds needed to get a tube with at least z bacteria in the second experiment.
Input
The first line contains four space-separated integers k, b, n and t (1 β€ k, b, n, t β€ 106) β the parameters of bacterial growth, the time Qwerty needed to grow z bacteria in the first experiment and the initial number of bacteria in the second experiment, correspondingly.
Output
Print a single number β the minimum number of seconds Qwerty needs to grow at least z bacteria in the tube.
Examples
Input
3 1 3 5
Output
2
Input
1 4 4 7
Output
3
Input
2 2 4 100
Output
0
Tags: implementation, math
Correct Solution:
```
from math import *
k,b,n,t = map(int,input().split())
if k !=1 :
result = log10(( t*(k-1)+b)/(k-1+b)) / log10(k)
r = ceil(n-result)
print(max(r,0))
else :
c=((k**n)*1+ (b*n))
cnt=0;d=t
while (True):
if (d >= c): break;
d = d * k + b
cnt += 1
print(cnt)
```
| 92,914 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Qwerty the Ranger took up a government job and arrived on planet Mars. He should stay in the secret lab and conduct some experiments on bacteria that have funny and abnormal properties. The job isn't difficult, but the salary is high.
At the beginning of the first experiment there is a single bacterium in the test tube. Every second each bacterium in the test tube divides itself into k bacteria. After that some abnormal effects create b more bacteria in the test tube. Thus, if at the beginning of some second the test tube had x bacteria, then at the end of the second it will have kx + b bacteria.
The experiment showed that after n seconds there were exactly z bacteria and the experiment ended at this point.
For the second experiment Qwerty is going to sterilize the test tube and put there t bacteria. He hasn't started the experiment yet but he already wonders, how many seconds he will need to grow at least z bacteria. The ranger thinks that the bacteria will divide by the same rule as in the first experiment.
Help Qwerty and find the minimum number of seconds needed to get a tube with at least z bacteria in the second experiment.
Input
The first line contains four space-separated integers k, b, n and t (1 β€ k, b, n, t β€ 106) β the parameters of bacterial growth, the time Qwerty needed to grow z bacteria in the first experiment and the initial number of bacteria in the second experiment, correspondingly.
Output
Print a single number β the minimum number of seconds Qwerty needs to grow at least z bacteria in the tube.
Examples
Input
3 1 3 5
Output
2
Input
1 4 4 7
Output
3
Input
2 2 4 100
Output
0
Tags: implementation, math
Correct Solution:
```
from math import log
k, b, n, t = map(int, input().split())
if k == 1: print(max((n * b + b - t) // b, 0))
else: print(max(0, n - int(log((k * t - t + b) / (k - 1 + b)) / log(k))))
```
| 92,915 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Qwerty the Ranger took up a government job and arrived on planet Mars. He should stay in the secret lab and conduct some experiments on bacteria that have funny and abnormal properties. The job isn't difficult, but the salary is high.
At the beginning of the first experiment there is a single bacterium in the test tube. Every second each bacterium in the test tube divides itself into k bacteria. After that some abnormal effects create b more bacteria in the test tube. Thus, if at the beginning of some second the test tube had x bacteria, then at the end of the second it will have kx + b bacteria.
The experiment showed that after n seconds there were exactly z bacteria and the experiment ended at this point.
For the second experiment Qwerty is going to sterilize the test tube and put there t bacteria. He hasn't started the experiment yet but he already wonders, how many seconds he will need to grow at least z bacteria. The ranger thinks that the bacteria will divide by the same rule as in the first experiment.
Help Qwerty and find the minimum number of seconds needed to get a tube with at least z bacteria in the second experiment.
Input
The first line contains four space-separated integers k, b, n and t (1 β€ k, b, n, t β€ 106) β the parameters of bacterial growth, the time Qwerty needed to grow z bacteria in the first experiment and the initial number of bacteria in the second experiment, correspondingly.
Output
Print a single number β the minimum number of seconds Qwerty needs to grow at least z bacteria in the tube.
Examples
Input
3 1 3 5
Output
2
Input
1 4 4 7
Output
3
Input
2 2 4 100
Output
0
Tags: implementation, math
Correct Solution:
```
from math import log, ceil
k,b,n,t = map(int, input().split())
if k == 1:
print(max(0, ceil((1+b*n-t)/b)))
else:
print(max(0, ceil(n-log((t-t*k-b)/(1-k-b),k))))
```
| 92,916 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Qwerty the Ranger took up a government job and arrived on planet Mars. He should stay in the secret lab and conduct some experiments on bacteria that have funny and abnormal properties. The job isn't difficult, but the salary is high.
At the beginning of the first experiment there is a single bacterium in the test tube. Every second each bacterium in the test tube divides itself into k bacteria. After that some abnormal effects create b more bacteria in the test tube. Thus, if at the beginning of some second the test tube had x bacteria, then at the end of the second it will have kx + b bacteria.
The experiment showed that after n seconds there were exactly z bacteria and the experiment ended at this point.
For the second experiment Qwerty is going to sterilize the test tube and put there t bacteria. He hasn't started the experiment yet but he already wonders, how many seconds he will need to grow at least z bacteria. The ranger thinks that the bacteria will divide by the same rule as in the first experiment.
Help Qwerty and find the minimum number of seconds needed to get a tube with at least z bacteria in the second experiment.
Input
The first line contains four space-separated integers k, b, n and t (1 β€ k, b, n, t β€ 106) β the parameters of bacterial growth, the time Qwerty needed to grow z bacteria in the first experiment and the initial number of bacteria in the second experiment, correspondingly.
Output
Print a single number β the minimum number of seconds Qwerty needs to grow at least z bacteria in the tube.
Examples
Input
3 1 3 5
Output
2
Input
1 4 4 7
Output
3
Input
2 2 4 100
Output
0
Tags: implementation, math
Correct Solution:
```
from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
from math import log, ceil
def main():
k, b, n, t = [ int(x) for x in input().split() ]
x = 0
prev, curr = 1, k + b
while not (prev <= t < curr):
prev = curr
curr = k*curr + b
x += 1
if n - x == 0:
break
print(n - x)
BUFFSIZE = 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, BUFFSIZE))
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, BUFFSIZE))
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")
input = lambda: sys.stdin.readline().rstrip("\r\n")
def print(*args, **kwargs):
sep = kwargs.pop("sep", " ")
file = kwargs.pop("file", sys.stdout)
atStart = True
for x in args:
if not atStart:
file.write(sep)
file.write(str(x))
atStart = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
main()
```
| 92,917 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Qwerty the Ranger took up a government job and arrived on planet Mars. He should stay in the secret lab and conduct some experiments on bacteria that have funny and abnormal properties. The job isn't difficult, but the salary is high.
At the beginning of the first experiment there is a single bacterium in the test tube. Every second each bacterium in the test tube divides itself into k bacteria. After that some abnormal effects create b more bacteria in the test tube. Thus, if at the beginning of some second the test tube had x bacteria, then at the end of the second it will have kx + b bacteria.
The experiment showed that after n seconds there were exactly z bacteria and the experiment ended at this point.
For the second experiment Qwerty is going to sterilize the test tube and put there t bacteria. He hasn't started the experiment yet but he already wonders, how many seconds he will need to grow at least z bacteria. The ranger thinks that the bacteria will divide by the same rule as in the first experiment.
Help Qwerty and find the minimum number of seconds needed to get a tube with at least z bacteria in the second experiment.
Input
The first line contains four space-separated integers k, b, n and t (1 β€ k, b, n, t β€ 106) β the parameters of bacterial growth, the time Qwerty needed to grow z bacteria in the first experiment and the initial number of bacteria in the second experiment, correspondingly.
Output
Print a single number β the minimum number of seconds Qwerty needs to grow at least z bacteria in the tube.
Examples
Input
3 1 3 5
Output
2
Input
1 4 4 7
Output
3
Input
2 2 4 100
Output
0
Tags: implementation, math
Correct Solution:
```
def mikroby(k, b, n, t):
z = 1
while z <= t:
z = k * z + b
n -= 1
return max(n + 1, 0)
K, B, N, T = [int(i) for i in input().split()]
print(mikroby(K, B, N, T))
```
| 92,918 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Qwerty the Ranger took up a government job and arrived on planet Mars. He should stay in the secret lab and conduct some experiments on bacteria that have funny and abnormal properties. The job isn't difficult, but the salary is high.
At the beginning of the first experiment there is a single bacterium in the test tube. Every second each bacterium in the test tube divides itself into k bacteria. After that some abnormal effects create b more bacteria in the test tube. Thus, if at the beginning of some second the test tube had x bacteria, then at the end of the second it will have kx + b bacteria.
The experiment showed that after n seconds there were exactly z bacteria and the experiment ended at this point.
For the second experiment Qwerty is going to sterilize the test tube and put there t bacteria. He hasn't started the experiment yet but he already wonders, how many seconds he will need to grow at least z bacteria. The ranger thinks that the bacteria will divide by the same rule as in the first experiment.
Help Qwerty and find the minimum number of seconds needed to get a tube with at least z bacteria in the second experiment.
Input
The first line contains four space-separated integers k, b, n and t (1 β€ k, b, n, t β€ 106) β the parameters of bacterial growth, the time Qwerty needed to grow z bacteria in the first experiment and the initial number of bacteria in the second experiment, correspondingly.
Output
Print a single number β the minimum number of seconds Qwerty needs to grow at least z bacteria in the tube.
Examples
Input
3 1 3 5
Output
2
Input
1 4 4 7
Output
3
Input
2 2 4 100
Output
0
Tags: implementation, math
Correct Solution:
```
s = input().split(' ')
k = int(s[0])
b = int(s[1])
n = int(s[2])
t = int(s[3])
ct = 1
while ( ct <= t ):
ct = ct * k + b
n = n - 1
print(max(0 , n + 1))
```
| 92,919 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Qwerty the Ranger took up a government job and arrived on planet Mars. He should stay in the secret lab and conduct some experiments on bacteria that have funny and abnormal properties. The job isn't difficult, but the salary is high.
At the beginning of the first experiment there is a single bacterium in the test tube. Every second each bacterium in the test tube divides itself into k bacteria. After that some abnormal effects create b more bacteria in the test tube. Thus, if at the beginning of some second the test tube had x bacteria, then at the end of the second it will have kx + b bacteria.
The experiment showed that after n seconds there were exactly z bacteria and the experiment ended at this point.
For the second experiment Qwerty is going to sterilize the test tube and put there t bacteria. He hasn't started the experiment yet but he already wonders, how many seconds he will need to grow at least z bacteria. The ranger thinks that the bacteria will divide by the same rule as in the first experiment.
Help Qwerty and find the minimum number of seconds needed to get a tube with at least z bacteria in the second experiment.
Input
The first line contains four space-separated integers k, b, n and t (1 β€ k, b, n, t β€ 106) β the parameters of bacterial growth, the time Qwerty needed to grow z bacteria in the first experiment and the initial number of bacteria in the second experiment, correspondingly.
Output
Print a single number β the minimum number of seconds Qwerty needs to grow at least z bacteria in the tube.
Examples
Input
3 1 3 5
Output
2
Input
1 4 4 7
Output
3
Input
2 2 4 100
Output
0
Tags: implementation, math
Correct Solution:
```
#testing minimario's code in pypy
import math
k, b, n, t = map(int, input().split(' '))
if k == 1:
cur = n*b+1
print(max(math.ceil((-t + n*b + 1)/b), 0))
else:
god = (b+k-1)/(b+t*k-t)
m = 0
while not (k**(m-n) >= god):
m += 1
print(m)
```
| 92,920 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Qwerty the Ranger took up a government job and arrived on planet Mars. He should stay in the secret lab and conduct some experiments on bacteria that have funny and abnormal properties. The job isn't difficult, but the salary is high.
At the beginning of the first experiment there is a single bacterium in the test tube. Every second each bacterium in the test tube divides itself into k bacteria. After that some abnormal effects create b more bacteria in the test tube. Thus, if at the beginning of some second the test tube had x bacteria, then at the end of the second it will have kx + b bacteria.
The experiment showed that after n seconds there were exactly z bacteria and the experiment ended at this point.
For the second experiment Qwerty is going to sterilize the test tube and put there t bacteria. He hasn't started the experiment yet but he already wonders, how many seconds he will need to grow at least z bacteria. The ranger thinks that the bacteria will divide by the same rule as in the first experiment.
Help Qwerty and find the minimum number of seconds needed to get a tube with at least z bacteria in the second experiment.
Input
The first line contains four space-separated integers k, b, n and t (1 β€ k, b, n, t β€ 106) β the parameters of bacterial growth, the time Qwerty needed to grow z bacteria in the first experiment and the initial number of bacteria in the second experiment, correspondingly.
Output
Print a single number β the minimum number of seconds Qwerty needs to grow at least z bacteria in the tube.
Examples
Input
3 1 3 5
Output
2
Input
1 4 4 7
Output
3
Input
2 2 4 100
Output
0
Submitted Solution:
```
from math import floor, log
rdi = lambda: list(map(int, input().split()))
k, b, n, t = rdi()
if k==1: print(max(0, (1+n*b-t+b-1)//b))
else : print(max(0, n-floor(log((t*(k-1)+b)/(k-1+b), k))))
```
Yes
| 92,921 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Qwerty the Ranger took up a government job and arrived on planet Mars. He should stay in the secret lab and conduct some experiments on bacteria that have funny and abnormal properties. The job isn't difficult, but the salary is high.
At the beginning of the first experiment there is a single bacterium in the test tube. Every second each bacterium in the test tube divides itself into k bacteria. After that some abnormal effects create b more bacteria in the test tube. Thus, if at the beginning of some second the test tube had x bacteria, then at the end of the second it will have kx + b bacteria.
The experiment showed that after n seconds there were exactly z bacteria and the experiment ended at this point.
For the second experiment Qwerty is going to sterilize the test tube and put there t bacteria. He hasn't started the experiment yet but he already wonders, how many seconds he will need to grow at least z bacteria. The ranger thinks that the bacteria will divide by the same rule as in the first experiment.
Help Qwerty and find the minimum number of seconds needed to get a tube with at least z bacteria in the second experiment.
Input
The first line contains four space-separated integers k, b, n and t (1 β€ k, b, n, t β€ 106) β the parameters of bacterial growth, the time Qwerty needed to grow z bacteria in the first experiment and the initial number of bacteria in the second experiment, correspondingly.
Output
Print a single number β the minimum number of seconds Qwerty needs to grow at least z bacteria in the tube.
Examples
Input
3 1 3 5
Output
2
Input
1 4 4 7
Output
3
Input
2 2 4 100
Output
0
Submitted Solution:
```
k, b, n, t = map(int, input().split())
z = int(1)
res = int(n)
for i in range(n):
z = k*z + b
if z <= t:
res -= 1
else:
break
print(res)
```
Yes
| 92,922 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Qwerty the Ranger took up a government job and arrived on planet Mars. He should stay in the secret lab and conduct some experiments on bacteria that have funny and abnormal properties. The job isn't difficult, but the salary is high.
At the beginning of the first experiment there is a single bacterium in the test tube. Every second each bacterium in the test tube divides itself into k bacteria. After that some abnormal effects create b more bacteria in the test tube. Thus, if at the beginning of some second the test tube had x bacteria, then at the end of the second it will have kx + b bacteria.
The experiment showed that after n seconds there were exactly z bacteria and the experiment ended at this point.
For the second experiment Qwerty is going to sterilize the test tube and put there t bacteria. He hasn't started the experiment yet but he already wonders, how many seconds he will need to grow at least z bacteria. The ranger thinks that the bacteria will divide by the same rule as in the first experiment.
Help Qwerty and find the minimum number of seconds needed to get a tube with at least z bacteria in the second experiment.
Input
The first line contains four space-separated integers k, b, n and t (1 β€ k, b, n, t β€ 106) β the parameters of bacterial growth, the time Qwerty needed to grow z bacteria in the first experiment and the initial number of bacteria in the second experiment, correspondingly.
Output
Print a single number β the minimum number of seconds Qwerty needs to grow at least z bacteria in the tube.
Examples
Input
3 1 3 5
Output
2
Input
1 4 4 7
Output
3
Input
2 2 4 100
Output
0
Submitted Solution:
```
from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
from math import log, ceil
def main():
k, b, secondsToZ, initialBacteriaT = [ int(x) for x in input().split() ]
secondsSaved = 0
previous, current = 1, k + b
while not (previous <= initialBacteriaT < current):
previous = current
current = k*current + b
secondsSaved += 1
if secondsToZ - secondsSaved == 0:
break
print(secondsToZ - secondsSaved)
BUFFSIZE = 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, BUFFSIZE))
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, BUFFSIZE))
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")
input = lambda: sys.stdin.readline().rstrip("\r\n")
def print(*args, **kwargs):
sep = kwargs.pop("sep", " ")
file = kwargs.pop("file", sys.stdout)
atStart = True
for x in args:
if not atStart:
file.write(sep)
file.write(str(x))
atStart = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
main()
```
Yes
| 92,923 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Qwerty the Ranger took up a government job and arrived on planet Mars. He should stay in the secret lab and conduct some experiments on bacteria that have funny and abnormal properties. The job isn't difficult, but the salary is high.
At the beginning of the first experiment there is a single bacterium in the test tube. Every second each bacterium in the test tube divides itself into k bacteria. After that some abnormal effects create b more bacteria in the test tube. Thus, if at the beginning of some second the test tube had x bacteria, then at the end of the second it will have kx + b bacteria.
The experiment showed that after n seconds there were exactly z bacteria and the experiment ended at this point.
For the second experiment Qwerty is going to sterilize the test tube and put there t bacteria. He hasn't started the experiment yet but he already wonders, how many seconds he will need to grow at least z bacteria. The ranger thinks that the bacteria will divide by the same rule as in the first experiment.
Help Qwerty and find the minimum number of seconds needed to get a tube with at least z bacteria in the second experiment.
Input
The first line contains four space-separated integers k, b, n and t (1 β€ k, b, n, t β€ 106) β the parameters of bacterial growth, the time Qwerty needed to grow z bacteria in the first experiment and the initial number of bacteria in the second experiment, correspondingly.
Output
Print a single number β the minimum number of seconds Qwerty needs to grow at least z bacteria in the tube.
Examples
Input
3 1 3 5
Output
2
Input
1 4 4 7
Output
3
Input
2 2 4 100
Output
0
Submitted Solution:
```
k, b, n, t = map(int, input().split())
z = int(1)
res = int(n)
for i in range(n):
z = k*z + b
if z <= t:
res -= 1
else:
break
print(res)
# Made By Mostafa_Khaled
```
Yes
| 92,924 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Qwerty the Ranger took up a government job and arrived on planet Mars. He should stay in the secret lab and conduct some experiments on bacteria that have funny and abnormal properties. The job isn't difficult, but the salary is high.
At the beginning of the first experiment there is a single bacterium in the test tube. Every second each bacterium in the test tube divides itself into k bacteria. After that some abnormal effects create b more bacteria in the test tube. Thus, if at the beginning of some second the test tube had x bacteria, then at the end of the second it will have kx + b bacteria.
The experiment showed that after n seconds there were exactly z bacteria and the experiment ended at this point.
For the second experiment Qwerty is going to sterilize the test tube and put there t bacteria. He hasn't started the experiment yet but he already wonders, how many seconds he will need to grow at least z bacteria. The ranger thinks that the bacteria will divide by the same rule as in the first experiment.
Help Qwerty and find the minimum number of seconds needed to get a tube with at least z bacteria in the second experiment.
Input
The first line contains four space-separated integers k, b, n and t (1 β€ k, b, n, t β€ 106) β the parameters of bacterial growth, the time Qwerty needed to grow z bacteria in the first experiment and the initial number of bacteria in the second experiment, correspondingly.
Output
Print a single number β the minimum number of seconds Qwerty needs to grow at least z bacteria in the tube.
Examples
Input
3 1 3 5
Output
2
Input
1 4 4 7
Output
3
Input
2 2 4 100
Output
0
Submitted Solution:
```
from math import *
k,b,n,t=map(int,input().split())
temp=1
count=0
if(k==1):
print(ceil((1+(n*b)-t)/b))
exit()
while(1):
if(pow(k,count)*(b+(t*(k-1)))<pow(k,n)*(k-1+b)):
count+=1
else:
break;
print(count)
```
No
| 92,925 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Qwerty the Ranger took up a government job and arrived on planet Mars. He should stay in the secret lab and conduct some experiments on bacteria that have funny and abnormal properties. The job isn't difficult, but the salary is high.
At the beginning of the first experiment there is a single bacterium in the test tube. Every second each bacterium in the test tube divides itself into k bacteria. After that some abnormal effects create b more bacteria in the test tube. Thus, if at the beginning of some second the test tube had x bacteria, then at the end of the second it will have kx + b bacteria.
The experiment showed that after n seconds there were exactly z bacteria and the experiment ended at this point.
For the second experiment Qwerty is going to sterilize the test tube and put there t bacteria. He hasn't started the experiment yet but he already wonders, how many seconds he will need to grow at least z bacteria. The ranger thinks that the bacteria will divide by the same rule as in the first experiment.
Help Qwerty and find the minimum number of seconds needed to get a tube with at least z bacteria in the second experiment.
Input
The first line contains four space-separated integers k, b, n and t (1 β€ k, b, n, t β€ 106) β the parameters of bacterial growth, the time Qwerty needed to grow z bacteria in the first experiment and the initial number of bacteria in the second experiment, correspondingly.
Output
Print a single number β the minimum number of seconds Qwerty needs to grow at least z bacteria in the tube.
Examples
Input
3 1 3 5
Output
2
Input
1 4 4 7
Output
3
Input
2 2 4 100
Output
0
Submitted Solution:
```
k, b, n, t = map(int, input().split())
if k == 1:
print(max(0, (n * b - t + b - 1) // b))
else:
x, y, v = k - 1 + b, t * (k - 1) + b, 0
while x <= y:
x *= k
v += 1
print(max(0, n - v + 1))
```
No
| 92,926 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Qwerty the Ranger took up a government job and arrived on planet Mars. He should stay in the secret lab and conduct some experiments on bacteria that have funny and abnormal properties. The job isn't difficult, but the salary is high.
At the beginning of the first experiment there is a single bacterium in the test tube. Every second each bacterium in the test tube divides itself into k bacteria. After that some abnormal effects create b more bacteria in the test tube. Thus, if at the beginning of some second the test tube had x bacteria, then at the end of the second it will have kx + b bacteria.
The experiment showed that after n seconds there were exactly z bacteria and the experiment ended at this point.
For the second experiment Qwerty is going to sterilize the test tube and put there t bacteria. He hasn't started the experiment yet but he already wonders, how many seconds he will need to grow at least z bacteria. The ranger thinks that the bacteria will divide by the same rule as in the first experiment.
Help Qwerty and find the minimum number of seconds needed to get a tube with at least z bacteria in the second experiment.
Input
The first line contains four space-separated integers k, b, n and t (1 β€ k, b, n, t β€ 106) β the parameters of bacterial growth, the time Qwerty needed to grow z bacteria in the first experiment and the initial number of bacteria in the second experiment, correspondingly.
Output
Print a single number β the minimum number of seconds Qwerty needs to grow at least z bacteria in the tube.
Examples
Input
3 1 3 5
Output
2
Input
1 4 4 7
Output
3
Input
2 2 4 100
Output
0
Submitted Solution:
```
from math import log, ceil
k,b,n,t = map(int, input().split())
if k == 1:
print(n-1)
else:
print(max(0, ceil(n-log((t-t*k-b)/(1-k-b),k))))
```
No
| 92,927 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Qwerty the Ranger took up a government job and arrived on planet Mars. He should stay in the secret lab and conduct some experiments on bacteria that have funny and abnormal properties. The job isn't difficult, but the salary is high.
At the beginning of the first experiment there is a single bacterium in the test tube. Every second each bacterium in the test tube divides itself into k bacteria. After that some abnormal effects create b more bacteria in the test tube. Thus, if at the beginning of some second the test tube had x bacteria, then at the end of the second it will have kx + b bacteria.
The experiment showed that after n seconds there were exactly z bacteria and the experiment ended at this point.
For the second experiment Qwerty is going to sterilize the test tube and put there t bacteria. He hasn't started the experiment yet but he already wonders, how many seconds he will need to grow at least z bacteria. The ranger thinks that the bacteria will divide by the same rule as in the first experiment.
Help Qwerty and find the minimum number of seconds needed to get a tube with at least z bacteria in the second experiment.
Input
The first line contains four space-separated integers k, b, n and t (1 β€ k, b, n, t β€ 106) β the parameters of bacterial growth, the time Qwerty needed to grow z bacteria in the first experiment and the initial number of bacteria in the second experiment, correspondingly.
Output
Print a single number β the minimum number of seconds Qwerty needs to grow at least z bacteria in the tube.
Examples
Input
3 1 3 5
Output
2
Input
1 4 4 7
Output
3
Input
2 2 4 100
Output
0
Submitted Solution:
```
from fractions import Fraction
k, b, n, t = map(int, input().split())
if k != 1:
a_init = Fraction(1, 1) + Fraction(b, k - 1)
z = a_init * pow(k, n) - Fraction(b, k - 1)
x, y, mid = 0, n, 0
while x < y:
mid = (x + y) // 2
if (Fraction(t, 1) + Fraction(b, k - 1)) * pow(k, mid) - Fraction(b, k - 1) < z:
x = mid + 1
else:
y = mid
print(x)
else:
z = 1 + n * b
print((z - t + b - 1) // b)
```
No
| 92,928 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant loves numbers.
He has a positive integer x. The Little Elephant wants to find the number of positive integers d, such that d is the divisor of x, and x and d have at least one common (the same) digit in their decimal representations.
Help the Little Elephant to find the described number.
Input
A single line contains a single integer x (1 β€ x β€ 109).
Output
In a single line print an integer β the answer to the problem.
Examples
Input
1
Output
1
Input
10
Output
2
Tags: implementation
Correct Solution:
```
def readln(inp=None): return tuple(map(int, (inp or input()).split()))
x, = readln()
ans = 0
d = 1
dig = set(list(str(x)))
while d * d <= x:
if x % d == 0:
for var in set((d, x // d)):
ans += len(set(list(str(var))).intersection(dig)) > 0
d += 1
print(ans)
```
| 92,929 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant loves numbers.
He has a positive integer x. The Little Elephant wants to find the number of positive integers d, such that d is the divisor of x, and x and d have at least one common (the same) digit in their decimal representations.
Help the Little Elephant to find the described number.
Input
A single line contains a single integer x (1 β€ x β€ 109).
Output
In a single line print an integer β the answer to the problem.
Examples
Input
1
Output
1
Input
10
Output
2
Tags: implementation
Correct Solution:
```
import math
def check(s1,s2):
for i in range(len(s1)):
for j in range(len(s2)):
if(s1[i]==s2[j]):
return True
return False
N = int(input())
div = 0
bound = math.floor(math.sqrt(N))
for i in range(bound):
k = i+1
if(N%k==0):
f1 = str(k)
f2 = str(N//k)
if(check(f1,str(N))):
div += 1
if(f1!=f2 and check(f2,str(N))):
div += 1
print (div)
```
| 92,930 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant loves numbers.
He has a positive integer x. The Little Elephant wants to find the number of positive integers d, such that d is the divisor of x, and x and d have at least one common (the same) digit in their decimal representations.
Help the Little Elephant to find the described number.
Input
A single line contains a single integer x (1 β€ x β€ 109).
Output
In a single line print an integer β the answer to the problem.
Examples
Input
1
Output
1
Input
10
Output
2
Tags: implementation
Correct Solution:
```
import math
x=int(input())
digit=""
for i in range(10):
if str(i) in str(x):
digit+=str(i)
counter=0
for i in range(1,int(math.sqrt(x))+1):
if x%i==0:
for j in str(i):
if j in digit:
counter+=1
break
for j in str(x//i):
if (j in digit) and (x//i > i) :
counter+=1
break
print(counter)
```
| 92,931 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant loves numbers.
He has a positive integer x. The Little Elephant wants to find the number of positive integers d, such that d is the divisor of x, and x and d have at least one common (the same) digit in their decimal representations.
Help the Little Elephant to find the described number.
Input
A single line contains a single integer x (1 β€ x β€ 109).
Output
In a single line print an integer β the answer to the problem.
Examples
Input
1
Output
1
Input
10
Output
2
Tags: implementation
Correct Solution:
```
import math
class CodeforcesTask221BSolution:
def __init__(self):
self.result = ''
self.x = 0
def read_input(self):
self.x = int(input())
def process_task(self):
if self.x == 1:
self.result = "1"
else:
numix = 1
repo = str(self.x)
if "1" in repo:
numix += 1
for x in range(2, int(math.sqrt(self.x)) + 1):
if x < self.x:
if not self.x % x:
#print(x, self.x // x)
have = False
for c in str(x):
if c in repo:
have = True
break
if have:
numix += 1
if self.x // x != x:
have = False
for c in str(self.x // x):
if c in repo:
have = True
break
if have:
numix += 1
self.result = str(numix)
def get_result(self):
return self.result
if __name__ == "__main__":
Solution = CodeforcesTask221BSolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())
```
| 92,932 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant loves numbers.
He has a positive integer x. The Little Elephant wants to find the number of positive integers d, such that d is the divisor of x, and x and d have at least one common (the same) digit in their decimal representations.
Help the Little Elephant to find the described number.
Input
A single line contains a single integer x (1 β€ x β€ 109).
Output
In a single line print an integer β the answer to the problem.
Examples
Input
1
Output
1
Input
10
Output
2
Tags: implementation
Correct Solution:
```
n = int(input())
d = 0
for i in range(1,int(n ** 0.5)+1) :
if n % i == 0 :
for j in str(i) :
if j in str(n) :
d += 1
break
k = n // i
if k != i :
for j in str(k) :
if j in str(n) :
d += 1
break
print(d)
```
| 92,933 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant loves numbers.
He has a positive integer x. The Little Elephant wants to find the number of positive integers d, such that d is the divisor of x, and x and d have at least one common (the same) digit in their decimal representations.
Help the Little Elephant to find the described number.
Input
A single line contains a single integer x (1 β€ x β€ 109).
Output
In a single line print an integer β the answer to the problem.
Examples
Input
1
Output
1
Input
10
Output
2
Tags: implementation
Correct Solution:
```
from functools import reduce
def factors(n):
return set(reduce(list.__add__,
([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))
n = int(input())
list_ = map(str, factors(n))
n = str(n)
cont=0
for el in list_:
flag = False
for i in el:
if i in n:
flag = True
if flag==True:
cont+=1
print(cont)
```
| 92,934 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant loves numbers.
He has a positive integer x. The Little Elephant wants to find the number of positive integers d, such that d is the divisor of x, and x and d have at least one common (the same) digit in their decimal representations.
Help the Little Elephant to find the described number.
Input
A single line contains a single integer x (1 β€ x β€ 109).
Output
In a single line print an integer β the answer to the problem.
Examples
Input
1
Output
1
Input
10
Output
2
Tags: implementation
Correct Solution:
```
from sys import stdin,stdout
nmbr = lambda: int(stdin.readline())
lst = lambda: list(map(int,stdin.readline().split()))
def fn(x,fact):
same=0
for ch in str(x):
for ch1 in str(fact):
if ch==ch1:return 1
return 0
for _ in range(1):#nmbr()):
n=nmbr()
p=1;ans=0
while p*p<=n:
if n%p==0:
ans+=fn(n,p)
if p!=n//p:ans+=fn(n,n//p)
p+=1
print(ans)
```
| 92,935 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant loves numbers.
He has a positive integer x. The Little Elephant wants to find the number of positive integers d, such that d is the divisor of x, and x and d have at least one common (the same) digit in their decimal representations.
Help the Little Elephant to find the described number.
Input
A single line contains a single integer x (1 β€ x β€ 109).
Output
In a single line print an integer β the answer to the problem.
Examples
Input
1
Output
1
Input
10
Output
2
Tags: implementation
Correct Solution:
```
a=int(input())
x=0
div=[]
for i in range(1,int(a**0.5)+1):
if a%i==0:
div.append(i)
b=len(div)
for i in div[:b]:
div.append(a//i)
div=list(set(div))
for i in div:
t=0
for j in str(i):
if j in str(a):
t=1
x+=t
print(x)
```
| 92,936 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Little Elephant loves numbers.
He has a positive integer x. The Little Elephant wants to find the number of positive integers d, such that d is the divisor of x, and x and d have at least one common (the same) digit in their decimal representations.
Help the Little Elephant to find the described number.
Input
A single line contains a single integer x (1 β€ x β€ 109).
Output
In a single line print an integer β the answer to the problem.
Examples
Input
1
Output
1
Input
10
Output
2
Submitted Solution:
```
x, val, i = int(input()), 0, 1
xs = set(str(x))
def dc(n):
return bool(xs & set(str(n)))
while i * i < x:
if x % i == 0:
val += dc(i) + dc(x // i)
i += 1
print(val + (i * i == x and dc(i)))
# Made By Mostafa_Khaled
```
Yes
| 92,937 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Little Elephant loves numbers.
He has a positive integer x. The Little Elephant wants to find the number of positive integers d, such that d is the divisor of x, and x and d have at least one common (the same) digit in their decimal representations.
Help the Little Elephant to find the described number.
Input
A single line contains a single integer x (1 β€ x β€ 109).
Output
In a single line print an integer β the answer to the problem.
Examples
Input
1
Output
1
Input
10
Output
2
Submitted Solution:
```
import math
import sys
n = int(input())
arr = [0,0,0,0,0,0,0,0,0,0]
number = str(n)
counter = 0
x = math.sqrt(n)+1
divisores = []
for i in range(len(number)):
arr[int(number[i])]=1
for i in range(1,int(x)):
if n%i==0:
d = str(i)
for j in range(len(d)):
if arr[int(d[j])]==1:
divisores.append(d)
break
inv_d = str(n//i)
for j in range(len(inv_d)):
if arr[int(inv_d[j])]==1:
divisores.append(inv_d)
div = list(dict.fromkeys(divisores))
print(len(div))
```
Yes
| 92,938 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Little Elephant loves numbers.
He has a positive integer x. The Little Elephant wants to find the number of positive integers d, such that d is the divisor of x, and x and d have at least one common (the same) digit in their decimal representations.
Help the Little Elephant to find the described number.
Input
A single line contains a single integer x (1 β€ x β€ 109).
Output
In a single line print an integer β the answer to the problem.
Examples
Input
1
Output
1
Input
10
Output
2
Submitted Solution:
```
import sys
def fastio():
from io import StringIO
from atexit import register
global input
sys.stdin = StringIO(sys.stdin.read())
input = lambda : sys.stdin.readline().rstrip('\r\n')
sys.stdout = StringIO()
register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()
def debug(*var, sep = ' ', end = '\n'):
print(*var, file=sys.stderr, end = end, sep = sep)
INF = 10**20
MOD = 10**9 + 7
I = lambda:list(map(int,input().split()))
from math import gcd
from math import ceil
from collections import defaultdict as dd, Counter
from bisect import bisect_left as bl, bisect_right as br
n, = I()
ans = 0
for i in range(1, int(n ** .5) + 1):
if n % i:
continue
f = str(i)
s = ''
if i ** 2 != n:
s = str(n // i)
for i in range(10):
k = str(i)
if k in f and k in str(n):
ans += 1
break
for i in range(10):
k = str(i)
if k in s and k in str(n):
ans += 1
break
print(ans)
```
Yes
| 92,939 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Little Elephant loves numbers.
He has a positive integer x. The Little Elephant wants to find the number of positive integers d, such that d is the divisor of x, and x and d have at least one common (the same) digit in their decimal representations.
Help the Little Elephant to find the described number.
Input
A single line contains a single integer x (1 β€ x β€ 109).
Output
In a single line print an integer β the answer to the problem.
Examples
Input
1
Output
1
Input
10
Output
2
Submitted Solution:
```
import math
n=int(input())
def single(n):
l=[]
while n!=0:
a=n%10
l.append(a)
n=n//10
return l
def simple(n):
l=[]
x=int(math.sqrt(n))
for i in range(1,x+1):
if n%i==0:
if i*i==n:
l.append(i)
else:
l.append(i)
l.append(n//i)
return l
temp=simple(n)
count=0
mlist=single(n)
for i in range(len(temp)):
pink=single(temp[i])
done=0
for j in pink:
if j in mlist:
done=1
if done==1:
count+=1
print(count)
```
Yes
| 92,940 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Little Elephant loves numbers.
He has a positive integer x. The Little Elephant wants to find the number of positive integers d, such that d is the divisor of x, and x and d have at least one common (the same) digit in their decimal representations.
Help the Little Elephant to find the described number.
Input
A single line contains a single integer x (1 β€ x β€ 109).
Output
In a single line print an integer β the answer to the problem.
Examples
Input
1
Output
1
Input
10
Output
2
Submitted Solution:
```
import math
x = int(input())
divisors = set()
for d in range(1, math.ceil(math.sqrt(x)) + 1):
if x % d == 0:
divisors.add(d)
divisors.add(x / d)
def common_digits(a, b):
a = set(str(a))
b = set(str(b))
return not a.isdisjoint(b)
print(sum(1 for d in divisors if common_digits(d, x)))
```
No
| 92,941 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Little Elephant loves numbers.
He has a positive integer x. The Little Elephant wants to find the number of positive integers d, such that d is the divisor of x, and x and d have at least one common (the same) digit in their decimal representations.
Help the Little Elephant to find the described number.
Input
A single line contains a single integer x (1 β€ x β€ 109).
Output
In a single line print an integer β the answer to the problem.
Examples
Input
1
Output
1
Input
10
Output
2
Submitted Solution:
```
import math
n_str = input()
n = int(n_str)
n_set = set(n_str)
ds = []
def has_common_digit(i):
for k in i:
#print(k)
if k in n_set:
return True
return False
for i in range(1,int(math.sqrt(n))):
#for i in range(1,int(n/2)+2):
if n%i == 0:
if has_common_digit(str(i)):
ds.append(i)
if i != n/i:
if has_common_digit(str(int(n/i))):
ds.append(int(n/i))
if n not in ds:
ds.append(n)
print(len(ds))
```
No
| 92,942 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Little Elephant loves numbers.
He has a positive integer x. The Little Elephant wants to find the number of positive integers d, such that d is the divisor of x, and x and d have at least one common (the same) digit in their decimal representations.
Help the Little Elephant to find the described number.
Input
A single line contains a single integer x (1 β€ x β€ 109).
Output
In a single line print an integer β the answer to the problem.
Examples
Input
1
Output
1
Input
10
Output
2
Submitted Solution:
```
import math
x=int(input())
num=x
count=1
if x!=1 and str(1) in str(x):
count+=1
for i in range(2,int(math.sqrt(x))+1):
if num%i==0:
#print(i,(num/i))
if str(i) in str(x):
#print('yes1')
count+=1
if str(int(num/i)) in str(x):
#print('yes2')
count+=1
print(count)
```
No
| 92,943 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Little Elephant loves numbers.
He has a positive integer x. The Little Elephant wants to find the number of positive integers d, such that d is the divisor of x, and x and d have at least one common (the same) digit in their decimal representations.
Help the Little Elephant to find the described number.
Input
A single line contains a single integer x (1 β€ x β€ 109).
Output
In a single line print an integer β the answer to the problem.
Examples
Input
1
Output
1
Input
10
Output
2
Submitted Solution:
```
from math import sqrt,floor
vetor = [0] * 10
n = int(input())
aux = n
while aux != 0:
z = floor(aux % 10)
aux = floor(aux/10)
vetor[z] = 1
cont = 0
for i in range(1, floor(sqrt(n))):
if floor(n % i) == 0:
l = floor(n/i)
v = i
while l != 0:
z = floor(l%10)
l = floor(l/10)
if vetor[z] == 1:
cont += 1
break
while v != 0:
z = floor(v % 10)
v = floor(v / 10)
if vetor[z] == 1:
cont += 1
break
z = floor(sqrt(n))
if floor(z*z) == n:
while z != 0:
u = floor(z % 10)
z = floor(z/10)
if vetor[u] == 1:
cont += 1
break
print(cont)
```
No
| 92,944 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Two pirates Polycarpus and Vasily play a very interesting game. They have n chests with coins, the chests are numbered with integers from 1 to n. Chest number i has ai coins.
Polycarpus and Vasily move in turns. Polycarpus moves first. During a move a player is allowed to choose a positive integer x (2Β·x + 1 β€ n) and take a coin from each chest with numbers x, 2Β·x, 2Β·x + 1. It may turn out that some chest has no coins, in this case the player doesn't take a coin from this chest. The game finishes when all chests get emptied.
Polycarpus isn't a greedy scrooge. Polycarpys is a lazy slob. So he wonders in what minimum number of moves the game can finish. Help Polycarpus, determine the minimum number of moves in which the game can finish. Note that Polycarpus counts not only his moves, he also counts Vasily's moves.
Input
The first line contains a single integer n (1 β€ n β€ 100) β the number of chests with coins. The second line contains a sequence of space-separated integers: a1, a2, ..., an (1 β€ ai β€ 1000), where ai is the number of coins in the chest number i at the beginning of the game.
Output
Print a single integer β the minimum number of moves needed to finish the game. If no sequence of turns leads to finishing the game, print -1.
Examples
Input
1
1
Output
-1
Input
3
1 2 3
Output
3
Note
In the first test case there isn't a single move that can be made. That's why the players won't be able to empty the chests.
In the second sample there is only one possible move x = 1. This move should be repeated at least 3 times to empty the third chest.
Tags: greedy
Correct Solution:
```
n = int(input())
if n == 1 or n & 1 == 0: print(-1)
else:
t = list(map(int, input().split()))
s, k = 0, n // 2 - 1
for i in range(n - 1, 1, -2):
p = max(t[i], t[i - 1])
t[k] = max(0, t[k] - p)
s += p
k -= 1
print(s + t[0])
```
| 92,945 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Two pirates Polycarpus and Vasily play a very interesting game. They have n chests with coins, the chests are numbered with integers from 1 to n. Chest number i has ai coins.
Polycarpus and Vasily move in turns. Polycarpus moves first. During a move a player is allowed to choose a positive integer x (2Β·x + 1 β€ n) and take a coin from each chest with numbers x, 2Β·x, 2Β·x + 1. It may turn out that some chest has no coins, in this case the player doesn't take a coin from this chest. The game finishes when all chests get emptied.
Polycarpus isn't a greedy scrooge. Polycarpys is a lazy slob. So he wonders in what minimum number of moves the game can finish. Help Polycarpus, determine the minimum number of moves in which the game can finish. Note that Polycarpus counts not only his moves, he also counts Vasily's moves.
Input
The first line contains a single integer n (1 β€ n β€ 100) β the number of chests with coins. The second line contains a sequence of space-separated integers: a1, a2, ..., an (1 β€ ai β€ 1000), where ai is the number of coins in the chest number i at the beginning of the game.
Output
Print a single integer β the minimum number of moves needed to finish the game. If no sequence of turns leads to finishing the game, print -1.
Examples
Input
1
1
Output
-1
Input
3
1 2 3
Output
3
Note
In the first test case there isn't a single move that can be made. That's why the players won't be able to empty the chests.
In the second sample there is only one possible move x = 1. This move should be repeated at least 3 times to empty the third chest.
Tags: greedy
Correct Solution:
```
t = int(input())
line = input()
lis = line.split()
lis = [int(i) for i in lis]
if t==1 or t%2==0 :
print("-1")
quit()
count = 0
i = t
while i >= 4 :
if i%2 == 1 :
p = i-1
q = int(p/2)
count = count + lis[i-1]
lis[p-1] = lis[p-1] - lis[i-1]
if lis[p-1] < 0 :
lis[p-1] = 0
lis[q-1] = lis[q-1] - lis[i-1]
if lis[q-1] < 0 :
lis[q-1] = 0
lis[i-1] = 0
else :
p = i+1
q = int(i/2)
count = count + lis[i-1]
lis[p-1] = lis[p-1] - lis[i-1]
if lis[p-1] < 0 :
lis[p-1] = 0
lis[q-1] = lis[q-1] - lis[i-1]
if lis[q-1] < 0 :
lis[q-1] = 0
lis[i-1] = 0
i = i-1
m = max(lis[0], lis[1], lis[2])
count = count + m
print(count)
```
| 92,946 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Two pirates Polycarpus and Vasily play a very interesting game. They have n chests with coins, the chests are numbered with integers from 1 to n. Chest number i has ai coins.
Polycarpus and Vasily move in turns. Polycarpus moves first. During a move a player is allowed to choose a positive integer x (2Β·x + 1 β€ n) and take a coin from each chest with numbers x, 2Β·x, 2Β·x + 1. It may turn out that some chest has no coins, in this case the player doesn't take a coin from this chest. The game finishes when all chests get emptied.
Polycarpus isn't a greedy scrooge. Polycarpys is a lazy slob. So he wonders in what minimum number of moves the game can finish. Help Polycarpus, determine the minimum number of moves in which the game can finish. Note that Polycarpus counts not only his moves, he also counts Vasily's moves.
Input
The first line contains a single integer n (1 β€ n β€ 100) β the number of chests with coins. The second line contains a sequence of space-separated integers: a1, a2, ..., an (1 β€ ai β€ 1000), where ai is the number of coins in the chest number i at the beginning of the game.
Output
Print a single integer β the minimum number of moves needed to finish the game. If no sequence of turns leads to finishing the game, print -1.
Examples
Input
1
1
Output
-1
Input
3
1 2 3
Output
3
Note
In the first test case there isn't a single move that can be made. That's why the players won't be able to empty the chests.
In the second sample there is only one possible move x = 1. This move should be repeated at least 3 times to empty the third chest.
Tags: greedy
Correct Solution:
```
'''
Auther: ghoshashis545 Ashis Ghosh
College: Jalpaiguri Govt Enggineering College
'''
from os import path
from io import BytesIO, IOBase
import sys
from heapq import heappush,heappop
from functools import cmp_to_key as ctk
from collections import deque,Counter,defaultdict as dd
from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
from itertools import permutations
from datetime import datetime
from math import ceil,sqrt,log,gcd
def ii():return int(input())
def si():return input().rstrip()
def mi():return map(int,input().split())
def li():return list(mi())
abc='abcdefghijklmnopqrstuvwxyz'
mod=1000000007
#mod=998244353
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def bo(i):
return ord(i)-ord('0')
file = 1
def ceil(a,b):
return (a+b-1)//b
def solve():
# for _ in range(1,ii()+1):
n = ii()
a = li()
if n == 1 or n%2==0:
print('-1')
return
cnt = 0
for i in range(n//2-1,-1,-1):
x = max(a[2*i+1],a[2*i+2])
cnt += x
a[i] = max(0,a[i]-x)
print(cnt + a[0])
if __name__ =="__main__":
if(file):
if path.exists('input.txt'):
sys.stdin=open('input.txt', 'r')
sys.stdout=open('output.txt','w')
else:
input=sys.stdin.readline
solve()
```
| 92,947 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Two pirates Polycarpus and Vasily play a very interesting game. They have n chests with coins, the chests are numbered with integers from 1 to n. Chest number i has ai coins.
Polycarpus and Vasily move in turns. Polycarpus moves first. During a move a player is allowed to choose a positive integer x (2Β·x + 1 β€ n) and take a coin from each chest with numbers x, 2Β·x, 2Β·x + 1. It may turn out that some chest has no coins, in this case the player doesn't take a coin from this chest. The game finishes when all chests get emptied.
Polycarpus isn't a greedy scrooge. Polycarpys is a lazy slob. So he wonders in what minimum number of moves the game can finish. Help Polycarpus, determine the minimum number of moves in which the game can finish. Note that Polycarpus counts not only his moves, he also counts Vasily's moves.
Input
The first line contains a single integer n (1 β€ n β€ 100) β the number of chests with coins. The second line contains a sequence of space-separated integers: a1, a2, ..., an (1 β€ ai β€ 1000), where ai is the number of coins in the chest number i at the beginning of the game.
Output
Print a single integer β the minimum number of moves needed to finish the game. If no sequence of turns leads to finishing the game, print -1.
Examples
Input
1
1
Output
-1
Input
3
1 2 3
Output
3
Note
In the first test case there isn't a single move that can be made. That's why the players won't be able to empty the chests.
In the second sample there is only one possible move x = 1. This move should be repeated at least 3 times to empty the third chest.
Tags: greedy
Correct Solution:
```
n=int(input())
if n==1 or n%2==0:
print(-1)
exit()
A=[0]*(n+1)
A[1:n+1]=list(map(int,input().split()))
ans=0
for i in range(n,0,-1):
if(A[i]<=0):continue
x=int(i/2)
A[x]-=A[i]
ans+=A[i]
if i%2==1:
A[i-1]-=A[i]
A[i]=0
print(ans)
```
| 92,948 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Two pirates Polycarpus and Vasily play a very interesting game. They have n chests with coins, the chests are numbered with integers from 1 to n. Chest number i has ai coins.
Polycarpus and Vasily move in turns. Polycarpus moves first. During a move a player is allowed to choose a positive integer x (2Β·x + 1 β€ n) and take a coin from each chest with numbers x, 2Β·x, 2Β·x + 1. It may turn out that some chest has no coins, in this case the player doesn't take a coin from this chest. The game finishes when all chests get emptied.
Polycarpus isn't a greedy scrooge. Polycarpys is a lazy slob. So he wonders in what minimum number of moves the game can finish. Help Polycarpus, determine the minimum number of moves in which the game can finish. Note that Polycarpus counts not only his moves, he also counts Vasily's moves.
Input
The first line contains a single integer n (1 β€ n β€ 100) β the number of chests with coins. The second line contains a sequence of space-separated integers: a1, a2, ..., an (1 β€ ai β€ 1000), where ai is the number of coins in the chest number i at the beginning of the game.
Output
Print a single integer β the minimum number of moves needed to finish the game. If no sequence of turns leads to finishing the game, print -1.
Examples
Input
1
1
Output
-1
Input
3
1 2 3
Output
3
Note
In the first test case there isn't a single move that can be made. That's why the players won't be able to empty the chests.
In the second sample there is only one possible move x = 1. This move should be repeated at least 3 times to empty the third chest.
Tags: greedy
Correct Solution:
```
n, s = int(input()), 0
a = [0] + list(map(int, input().split()))
if n % 2 == 0 or n == 1:
print(-1)
else:
for i in range(n, 1, -2):
mx = max(a[i], a[i - 1])
s += mx
a[i // 2] = max(0, a[i // 2] - mx)
print(s + a[1])
```
| 92,949 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Two pirates Polycarpus and Vasily play a very interesting game. They have n chests with coins, the chests are numbered with integers from 1 to n. Chest number i has ai coins.
Polycarpus and Vasily move in turns. Polycarpus moves first. During a move a player is allowed to choose a positive integer x (2Β·x + 1 β€ n) and take a coin from each chest with numbers x, 2Β·x, 2Β·x + 1. It may turn out that some chest has no coins, in this case the player doesn't take a coin from this chest. The game finishes when all chests get emptied.
Polycarpus isn't a greedy scrooge. Polycarpys is a lazy slob. So he wonders in what minimum number of moves the game can finish. Help Polycarpus, determine the minimum number of moves in which the game can finish. Note that Polycarpus counts not only his moves, he also counts Vasily's moves.
Input
The first line contains a single integer n (1 β€ n β€ 100) β the number of chests with coins. The second line contains a sequence of space-separated integers: a1, a2, ..., an (1 β€ ai β€ 1000), where ai is the number of coins in the chest number i at the beginning of the game.
Output
Print a single integer β the minimum number of moves needed to finish the game. If no sequence of turns leads to finishing the game, print -1.
Examples
Input
1
1
Output
-1
Input
3
1 2 3
Output
3
Note
In the first test case there isn't a single move that can be made. That's why the players won't be able to empty the chests.
In the second sample there is only one possible move x = 1. This move should be repeated at least 3 times to empty the third chest.
Tags: greedy
Correct Solution:
```
n = int(input())
A = [int(i) for i in input().split()]
if n == 1 or n % 2 == 0:
print(-1)
exit()
ans = 0
for i in range(n-1, 3, -2):
diff = max(A[i], A[i-1])
ans += diff
A[(i-1)//2] -= diff
A[(i-1)//2] = max(0, A[(i-1)//2])
ans += max(A[:3])
print(ans)
```
| 92,950 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Two pirates Polycarpus and Vasily play a very interesting game. They have n chests with coins, the chests are numbered with integers from 1 to n. Chest number i has ai coins.
Polycarpus and Vasily move in turns. Polycarpus moves first. During a move a player is allowed to choose a positive integer x (2Β·x + 1 β€ n) and take a coin from each chest with numbers x, 2Β·x, 2Β·x + 1. It may turn out that some chest has no coins, in this case the player doesn't take a coin from this chest. The game finishes when all chests get emptied.
Polycarpus isn't a greedy scrooge. Polycarpys is a lazy slob. So he wonders in what minimum number of moves the game can finish. Help Polycarpus, determine the minimum number of moves in which the game can finish. Note that Polycarpus counts not only his moves, he also counts Vasily's moves.
Input
The first line contains a single integer n (1 β€ n β€ 100) β the number of chests with coins. The second line contains a sequence of space-separated integers: a1, a2, ..., an (1 β€ ai β€ 1000), where ai is the number of coins in the chest number i at the beginning of the game.
Output
Print a single integer β the minimum number of moves needed to finish the game. If no sequence of turns leads to finishing the game, print -1.
Examples
Input
1
1
Output
-1
Input
3
1 2 3
Output
3
Note
In the first test case there isn't a single move that can be made. That's why the players won't be able to empty the chests.
In the second sample there is only one possible move x = 1. This move should be repeated at least 3 times to empty the third chest.
Tags: greedy
Correct Solution:
```
#!/usr/bin/python3
n = int(input())
a = [0] + list(map(int, input().split()))
if len(a) < 3 or n % 2 == 0:
print(-1)
else:
ans = 0
for x in range(n // 2, 0, -1):
d = max(0, a[2 * x], a[2 * x + 1])
ans += d
a[x] -= d
print(ans + max(0, a[1]))
```
| 92,951 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Two pirates Polycarpus and Vasily play a very interesting game. They have n chests with coins, the chests are numbered with integers from 1 to n. Chest number i has ai coins.
Polycarpus and Vasily move in turns. Polycarpus moves first. During a move a player is allowed to choose a positive integer x (2Β·x + 1 β€ n) and take a coin from each chest with numbers x, 2Β·x, 2Β·x + 1. It may turn out that some chest has no coins, in this case the player doesn't take a coin from this chest. The game finishes when all chests get emptied.
Polycarpus isn't a greedy scrooge. Polycarpys is a lazy slob. So he wonders in what minimum number of moves the game can finish. Help Polycarpus, determine the minimum number of moves in which the game can finish. Note that Polycarpus counts not only his moves, he also counts Vasily's moves.
Input
The first line contains a single integer n (1 β€ n β€ 100) β the number of chests with coins. The second line contains a sequence of space-separated integers: a1, a2, ..., an (1 β€ ai β€ 1000), where ai is the number of coins in the chest number i at the beginning of the game.
Output
Print a single integer β the minimum number of moves needed to finish the game. If no sequence of turns leads to finishing the game, print -1.
Examples
Input
1
1
Output
-1
Input
3
1 2 3
Output
3
Note
In the first test case there isn't a single move that can be made. That's why the players won't be able to empty the chests.
In the second sample there is only one possible move x = 1. This move should be repeated at least 3 times to empty the third chest.
Tags: greedy
Correct Solution:
```
n=int(input())
if n==1 or n%2==0:
print(-1)
exit()
A=[0]*(n+1)
A[1:n+1]=list(map(int,input().split()))
ans=0
for i in range(n,0,-1):
if(A[i]<=0):continue
x=int(i/2)
A[x]-=A[i]
ans+=A[i]
if i%2==1:
A[i-1]-=A[i]
A[i]=0
print(ans)
# Made By Mostafa_Khaled
```
| 92,952 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two pirates Polycarpus and Vasily play a very interesting game. They have n chests with coins, the chests are numbered with integers from 1 to n. Chest number i has ai coins.
Polycarpus and Vasily move in turns. Polycarpus moves first. During a move a player is allowed to choose a positive integer x (2Β·x + 1 β€ n) and take a coin from each chest with numbers x, 2Β·x, 2Β·x + 1. It may turn out that some chest has no coins, in this case the player doesn't take a coin from this chest. The game finishes when all chests get emptied.
Polycarpus isn't a greedy scrooge. Polycarpys is a lazy slob. So he wonders in what minimum number of moves the game can finish. Help Polycarpus, determine the minimum number of moves in which the game can finish. Note that Polycarpus counts not only his moves, he also counts Vasily's moves.
Input
The first line contains a single integer n (1 β€ n β€ 100) β the number of chests with coins. The second line contains a sequence of space-separated integers: a1, a2, ..., an (1 β€ ai β€ 1000), where ai is the number of coins in the chest number i at the beginning of the game.
Output
Print a single integer β the minimum number of moves needed to finish the game. If no sequence of turns leads to finishing the game, print -1.
Examples
Input
1
1
Output
-1
Input
3
1 2 3
Output
3
Note
In the first test case there isn't a single move that can be made. That's why the players won't be able to empty the chests.
In the second sample there is only one possible move x = 1. This move should be repeated at least 3 times to empty the third chest.
Submitted Solution:
```
# it was stupid to think using brute intuitions, like pick first or last greedily,
# greddy must follow observation, so you also had the observation that have to do it from last
# instead you picked in random all order, those greedy after thought solutions never work!,its not cp
n=int(input())
if n==1 or n%2==0:
# print("ghe")
print(-1)
exit(0)
a=list(map(int,input().split(' ')))
# so the last element, has to be made 0, greedily, first, so by induction, it has proof,
a=[0]+a
# this is very ine elegant implementation
ans=0
for j in range(n,0,-1):
if j%2==1:
i=(j-1)//2
ans+=a[2*i+1]
mina=min(a[i],a[2*i],a[2*i+1])
a[i],a[2*i],a[2*i+1]=a[i]-mina,a[2*i]-mina,a[2*i+1]-mina
if a[2*i+1]>0:
nonzero=0
if a[i]>0:
a[i]=max(0,a[i]-a[2*i+1])
else:
a[2*i]=max(0,a[2*i]-a[2*i+1])
a[2*i+1]=0
else:
i=(j)//2
if 2*i+1>n:
# print("hemlo")
print(-1)
exit(0)
ans+=a[2*i]
mina=min(a[i],a[2*i],a[2*i+1])
a[i],a[2*i],a[2*i+1]=a[i]-mina,a[2*i]-mina,a[2*i+1]-mina
if a[2*i]>0:
a[i]=max(0,a[i]-a[2*i])
a[2*i]=0
# print(a)/
if any(a):
print(-1)
else:
print(ans)
```
Yes
| 92,953 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two pirates Polycarpus and Vasily play a very interesting game. They have n chests with coins, the chests are numbered with integers from 1 to n. Chest number i has ai coins.
Polycarpus and Vasily move in turns. Polycarpus moves first. During a move a player is allowed to choose a positive integer x (2Β·x + 1 β€ n) and take a coin from each chest with numbers x, 2Β·x, 2Β·x + 1. It may turn out that some chest has no coins, in this case the player doesn't take a coin from this chest. The game finishes when all chests get emptied.
Polycarpus isn't a greedy scrooge. Polycarpys is a lazy slob. So he wonders in what minimum number of moves the game can finish. Help Polycarpus, determine the minimum number of moves in which the game can finish. Note that Polycarpus counts not only his moves, he also counts Vasily's moves.
Input
The first line contains a single integer n (1 β€ n β€ 100) β the number of chests with coins. The second line contains a sequence of space-separated integers: a1, a2, ..., an (1 β€ ai β€ 1000), where ai is the number of coins in the chest number i at the beginning of the game.
Output
Print a single integer β the minimum number of moves needed to finish the game. If no sequence of turns leads to finishing the game, print -1.
Examples
Input
1
1
Output
-1
Input
3
1 2 3
Output
3
Note
In the first test case there isn't a single move that can be made. That's why the players won't be able to empty the chests.
In the second sample there is only one possible move x = 1. This move should be repeated at least 3 times to empty the third chest.
Submitted Solution:
```
import math
a_sum = 0
n = int(input())
a = [0]+[int(i) for i in input().split()]
if n%2 ==0 or n==1:
print(-1)
exit()
else:
i = n
while i>3:
if a[i] >= a[i-1]:
if a[i]>0:
a_sum += a[i]
a[(i - 1) // 2] = a[(i - 1) // 2] - a[i]
else:
if a[i-1]>0:
a_sum += a[i-1]
a[(i - 1) // 2] = a[(i - 1) // 2] - a[i - 1]
a[n] =0
a[n-1]=0
i -= 1
i-=1
a_max = a[3]
if a[2]> a[3]:
a_max = a[2]
if a[1]>a_max:
a_max = a[1]
if a_max>0:
a_sum+=a_max
print(a_sum)
exit()
```
Yes
| 92,954 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two pirates Polycarpus and Vasily play a very interesting game. They have n chests with coins, the chests are numbered with integers from 1 to n. Chest number i has ai coins.
Polycarpus and Vasily move in turns. Polycarpus moves first. During a move a player is allowed to choose a positive integer x (2Β·x + 1 β€ n) and take a coin from each chest with numbers x, 2Β·x, 2Β·x + 1. It may turn out that some chest has no coins, in this case the player doesn't take a coin from this chest. The game finishes when all chests get emptied.
Polycarpus isn't a greedy scrooge. Polycarpys is a lazy slob. So he wonders in what minimum number of moves the game can finish. Help Polycarpus, determine the minimum number of moves in which the game can finish. Note that Polycarpus counts not only his moves, he also counts Vasily's moves.
Input
The first line contains a single integer n (1 β€ n β€ 100) β the number of chests with coins. The second line contains a sequence of space-separated integers: a1, a2, ..., an (1 β€ ai β€ 1000), where ai is the number of coins in the chest number i at the beginning of the game.
Output
Print a single integer β the minimum number of moves needed to finish the game. If no sequence of turns leads to finishing the game, print -1.
Examples
Input
1
1
Output
-1
Input
3
1 2 3
Output
3
Note
In the first test case there isn't a single move that can be made. That's why the players won't be able to empty the chests.
In the second sample there is only one possible move x = 1. This move should be repeated at least 3 times to empty the third chest.
Submitted Solution:
```
#!/usr/bin/python3
n = int(input())
a = [0] + list(map(int, input().split()))
if len(a) < 3 or n % 2 == 0:
print(-1)
else:
ans = 0
for x in range(n // 2, 0, -1):
d = max(a[2 * x], a[2 * x + 1])
if d > 0:
ans += d
a[x] -= d
print(ans)
```
No
| 92,955 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two pirates Polycarpus and Vasily play a very interesting game. They have n chests with coins, the chests are numbered with integers from 1 to n. Chest number i has ai coins.
Polycarpus and Vasily move in turns. Polycarpus moves first. During a move a player is allowed to choose a positive integer x (2Β·x + 1 β€ n) and take a coin from each chest with numbers x, 2Β·x, 2Β·x + 1. It may turn out that some chest has no coins, in this case the player doesn't take a coin from this chest. The game finishes when all chests get emptied.
Polycarpus isn't a greedy scrooge. Polycarpys is a lazy slob. So he wonders in what minimum number of moves the game can finish. Help Polycarpus, determine the minimum number of moves in which the game can finish. Note that Polycarpus counts not only his moves, he also counts Vasily's moves.
Input
The first line contains a single integer n (1 β€ n β€ 100) β the number of chests with coins. The second line contains a sequence of space-separated integers: a1, a2, ..., an (1 β€ ai β€ 1000), where ai is the number of coins in the chest number i at the beginning of the game.
Output
Print a single integer β the minimum number of moves needed to finish the game. If no sequence of turns leads to finishing the game, print -1.
Examples
Input
1
1
Output
-1
Input
3
1 2 3
Output
3
Note
In the first test case there isn't a single move that can be made. That's why the players won't be able to empty the chests.
In the second sample there is only one possible move x = 1. This move should be repeated at least 3 times to empty the third chest.
Submitted Solution:
```
t = int(input())
line = input()
ar = line.split()
ar = [int(i) for i in ar]
ar = sorted(ar)
f = int((t-1)/2)
p = (2*f)+1
count = 0
i = p
while i > 0 and f != 0 :
if sum(ar) == 0 :
break
j = t-1
while j >= 0 :
if ar[j] >= i :
count = count + int(ar[j]/i)
ar[j] = ar[j]%i
j = j-1
i = i-1
if sum(ar) == 0 :
print(count)
else :
print(-1)
```
No
| 92,956 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two pirates Polycarpus and Vasily play a very interesting game. They have n chests with coins, the chests are numbered with integers from 1 to n. Chest number i has ai coins.
Polycarpus and Vasily move in turns. Polycarpus moves first. During a move a player is allowed to choose a positive integer x (2Β·x + 1 β€ n) and take a coin from each chest with numbers x, 2Β·x, 2Β·x + 1. It may turn out that some chest has no coins, in this case the player doesn't take a coin from this chest. The game finishes when all chests get emptied.
Polycarpus isn't a greedy scrooge. Polycarpys is a lazy slob. So he wonders in what minimum number of moves the game can finish. Help Polycarpus, determine the minimum number of moves in which the game can finish. Note that Polycarpus counts not only his moves, he also counts Vasily's moves.
Input
The first line contains a single integer n (1 β€ n β€ 100) β the number of chests with coins. The second line contains a sequence of space-separated integers: a1, a2, ..., an (1 β€ ai β€ 1000), where ai is the number of coins in the chest number i at the beginning of the game.
Output
Print a single integer β the minimum number of moves needed to finish the game. If no sequence of turns leads to finishing the game, print -1.
Examples
Input
1
1
Output
-1
Input
3
1 2 3
Output
3
Note
In the first test case there isn't a single move that can be made. That's why the players won't be able to empty the chests.
In the second sample there is only one possible move x = 1. This move should be repeated at least 3 times to empty the third chest.
Submitted Solution:
```
n=int(input())
if n==1:
print(-1)
exit(0)
a=list(map(int,input().split(' ')))
a=[0]+a
# print(a)
ans=0
for i in range(1,n+1):
if 2*i+1>n:
continue
if a[i]==0 or a[2*i]==0 or a[2*i+1]==0 :
continue
mina=min([a[i],a[2*i],a[2*i+1]])
a[i],a[2*i],a[2*i+1]=a[i]-mina,a[2*i]-mina,a[2*i+1]-mina
ans+=mina
# print(a)
for i in range(1,n+1):
if 2*i+1>n:
continue
if a[i]>0 and a[2*i]>0:
mina=min([a[i],a[2*i]])
ans+=mina
a[i],a[2*i]=a[i]-mina,a[2*i]-mina
elif a[2*i+1]>0 and a[2*i]>0:
mina=min([a[2*i+1],a[2*i]])
ans+=mina
a[2*i+1],a[2*i]=a[2*i+1]-mina,a[2*i]-mina
elif a[2*i+1]>0 and a[i]>0:
mina=min([a[2*i+1],a[i]])
ans+=mina
a[2*i+1],a[i]=a[2*i+1]-mina,a[i]-mina
for i in range(1,n+1):
if 2*i+1>n:
continue
if a[i]>0:
ans+=a[i]
a[i]=0
elif a[2*i]>0:
ans+=a[2*i]
a[2*i]=0
elif a[2*i+1]>0:
ans+=a[2*i+1]
a[2*i+1]=0
for i in range(1,n+1):
if a[i]>0:
print(-1)
exit(0)
print(ans)
```
No
| 92,957 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two pirates Polycarpus and Vasily play a very interesting game. They have n chests with coins, the chests are numbered with integers from 1 to n. Chest number i has ai coins.
Polycarpus and Vasily move in turns. Polycarpus moves first. During a move a player is allowed to choose a positive integer x (2Β·x + 1 β€ n) and take a coin from each chest with numbers x, 2Β·x, 2Β·x + 1. It may turn out that some chest has no coins, in this case the player doesn't take a coin from this chest. The game finishes when all chests get emptied.
Polycarpus isn't a greedy scrooge. Polycarpys is a lazy slob. So he wonders in what minimum number of moves the game can finish. Help Polycarpus, determine the minimum number of moves in which the game can finish. Note that Polycarpus counts not only his moves, he also counts Vasily's moves.
Input
The first line contains a single integer n (1 β€ n β€ 100) β the number of chests with coins. The second line contains a sequence of space-separated integers: a1, a2, ..., an (1 β€ ai β€ 1000), where ai is the number of coins in the chest number i at the beginning of the game.
Output
Print a single integer β the minimum number of moves needed to finish the game. If no sequence of turns leads to finishing the game, print -1.
Examples
Input
1
1
Output
-1
Input
3
1 2 3
Output
3
Note
In the first test case there isn't a single move that can be made. That's why the players won't be able to empty the chests.
In the second sample there is only one possible move x = 1. This move should be repeated at least 3 times to empty the third chest.
Submitted Solution:
```
import math
a = []
a_sum = 0
n = int(input())
a = [0]+[int(i) for i in input().split()]
def rex(k):
global a_sum
for i in range(k,2*k-1):
if i%2 == 0:
if a[i] >= a[i+1]:
a_sum += a[i]
a[i//2] = a[i//2] - a[i]
else:
a_sum += a[i+1]
a[i//2] = a[i//2] - a[i+1]
a[i] = 0
a[i+1] = 0
i +=1
# if __name__ == '__main__':
if n%2 ==0 or n==1:
print(-1)
exit()
else:
rec = int(math.log(n) / math.log(2)) +1
x = (n-1)//2
for i in range(rec):
rex(x+1)
if x>2:
if x%2 ==1:
x = (x-1)//2
else:
max = a[1]
if a[2] > a[1]:
max = a[2]
if a[3] > max:
max = a[3]
a_sum = a_sum+max
print(a_sum)
exit()
```
No
| 92,958 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square.
Tags: geometry, implementation, math
Correct Solution:
```
# Fancy Fence
cases = int(input())
x = 0
while x < cases:
interiorAngle = int(input())
ExteriorAngle = 180 - interiorAngle
numOfEdgesFloat = 360 / ExteriorAngle
numOfEdgesInt = 360 // ExteriorAngle
if(numOfEdgesFloat == numOfEdgesInt):
print("YES")
else:
print("NO")
x += 1
```
| 92,959 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square.
Tags: geometry, implementation, math
Correct Solution:
```
options = []
for n in range(3,361):
if 180*(n-2) % n == 0:
options.append(180*(n-2) // n)
cases = int(input())
for _ in range(cases):
if int(input()) in options:
print('YES')
else:
print('NO')
```
| 92,960 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square.
Tags: geometry, implementation, math
Correct Solution:
```
for i in range(int(input())):
a = int(input())
if 360%(180-a)==0:
print('YES')
else:
print('NO')
```
| 92,961 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square.
Tags: geometry, implementation, math
Correct Solution:
```
from math import gcd
for i in range(int(input())):
x = int(input())
gcf = gcd(x,180)
a,b = x//gcf,180//gcf
if b-a == 2 or b*2-a*2 == 2:#Odd and Even cases
print('YES')
else:
print('NO')
```
| 92,962 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square.
Tags: geometry, implementation, math
Correct Solution:
```
t = int(input())
for i in range(t):
angle = int(input())
if(360%(180 - angle) == 0):
print("YES")
else:
print("NO")
```
| 92,963 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square.
Tags: geometry, implementation, math
Correct Solution:
```
# Author : raj1307 - Raj Singh
# Date : 02.01.2020
from __future__ import division, print_function
import os,sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
def ii(): return int(input())
def si(): return input()
def mi(): return map(int,input().strip().split(" "))
def msi(): return map(str,input().strip().split(" "))
def li(): return list(mi())
def dmain():
sys.setrecursionlimit(100000000)
threading.stack_size(40960000)
thread = threading.Thread(target=main)
thread.start()
#from collections import deque, Counter, OrderedDict,defaultdict
#from heapq import nsmallest, nlargest, heapify,heappop ,heappush, heapreplace
#from math import ceil,floor,log,sqrt,factorial
#from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
#from decimal import *,threading
#from itertools import permutations
abc='abcdefghijklmnopqrstuvwxyz'
abd={'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod=1000000007
#mod=998244353
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def getKey(item): return item[1]
def sort2(l):return sorted(l, key=getKey)
def d2(n,m,num):return [[num for x in range(m)] for y in range(n)]
def isPowerOfTwo (x): return (x and (not(x & (x - 1))) )
def decimalToBinary(n): return bin(n).replace("0b","")
def ntl(n):return [int(i) for i in str(n)]
def powerMod(x,y,p):
res = 1
x %= p
while y > 0:
if y&1:
res = (res*x)%p
y = y>>1
x = (x*x)%p
return res
def gcd(x, y):
while y:
x, y = y, x % y
return x
def isPrime(n) : # Check Prime Number or not
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
def read():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
def main():
for _ in range(ii()):
n=ii()
if 360%(180-n)==0:
print('YES')
else:
print('NO')
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
#read()
main()
#dmain()
# Comment Read()
```
| 92,964 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square.
Tags: geometry, implementation, math
Correct Solution:
```
import sys
input = sys.stdin.readline
ins = lambda: input().rstrip()
ini = lambda: int(input().rstrip())
inm = lambda: map(int, input().split())
inl = lambda: list(map(int, input().split()))
out = lambda x: print('\n'.join(map(str, x)))
ans = []
t = ini()
for _ in range(t):
n = ini()
ans.append("YES" if (360 % (180 - n)) == 0 else "NO")
out(ans)
```
| 92,965 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square.
Tags: geometry, implementation, math
Correct Solution:
```
t = int(input())
for i in range(t):
n = int(input())
if 360 % (180-n) == 0:
print('YES')
else:
print('NO')
```
| 92,966 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square.
Submitted Solution:
```
n_list = [3, 4, 5, 6, 8, 9, 10, 12, 15, 18, 20, 24, 30, 36, 40, 45, 60, 72, 90, 120, 180, 360]
tests = int(input())
def is_regular(angle):
for n in n_list:
if angle == 180 - (360/n):
return True
return False
for i in range(tests):
if is_regular(int(input())):
print("YES")
else:
print("NO")
```
Yes
| 92,967 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square.
Submitted Solution:
```
N=int(input())
for i in range(N):
a=int(input())
n=360.0/(180-a)
if n%1==0:
print('YES')
else:
print('NO')
```
Yes
| 92,968 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square.
Submitted Solution:
```
t=int(input())
for i in range(t):
a=int(input())
f=360/(180-a)
if f>=3 and f%1==0:
print("YES")
else:
print("NO")
```
Yes
| 92,969 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square.
Submitted Solution:
```
def ok(integer):
if 360%(180-integer)==0:
return "YES"
else:
return "NO"
stor=[]
sa=input()
for x in range(int(sa)):
stor.append(ok(int(input())))
for element in stor:
print(element)
```
Yes
| 92,970 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square.
Submitted Solution:
```
t = int(input())
g = ''
for i in range(t):
a = int(input())
if (1080 % a == 0) and (a > 30):
g += 'YES '
else:
g += 'NO '
print('\n'.join(g.split()))
```
No
| 92,971 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square.
Submitted Solution:
```
for _ in range(int(input())):
a = int(input())
n = 3
while True:
if ((n-2)*180)//n >= a:
break
n += 1
if ((n-2)*180)%n == 0:
if ((n-2)*180)//n == a:
print(((n-2)*180)//n)
print('YES')
else:
print('NO')
else:
print('NO')
```
No
| 92,972 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square.
Submitted Solution:
```
# A. ΠΠ°Π²ΠΈΠ΄Π½ΡΠΉ Π·Π°Π±ΠΎΡ
n = int(input())
for i in range(n):
a = int(input())
if 3 <= 360 / (180 - a) < 360:
print("YES")
else:
print("NO")
```
No
| 92,973 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square.
Submitted Solution:
```
n = int(input())
for i in range(n):
a = int(input())
e = 360/(180-a)
absolute = abs(e)
rounded = round(e)
if(e>=3):
if(absolute - rounded ==0):
print("YES")
# print(e)
else:
print("NO")
```
No
| 92,974 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.
Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).
What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?
Input
Single line of the input contains three integers x, y and m ( - 1018 β€ x, y, m β€ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.
Output
Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.
Examples
Input
1 2 5
Output
2
Input
-1 4 15
Output
4
Input
0 -1 5
Output
-1
Note
In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).
In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).
Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations.
Tags: brute force
Correct Solution:
```
x, y, xx = map(int, input().split())
cnt = 0
while max(x, y) < xx:
if x < y:
x, y = y, x
l, r, m = 0, 4 * 10 ** 18, 0
while r > l + 1:
m = (l + r) // 2;
if x >= m * x + y:
l = m
else:
r = m
if r == 4e18:
print(-1)
exit(0)
cnt += r
temp = x
x = r * x + y
y = temp
print(cnt)
```
| 92,975 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.
Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).
What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?
Input
Single line of the input contains three integers x, y and m ( - 1018 β€ x, y, m β€ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.
Output
Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.
Examples
Input
1 2 5
Output
2
Input
-1 4 15
Output
4
Input
0 -1 5
Output
-1
Note
In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).
In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).
Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations.
Tags: brute force
Correct Solution:
```
x,y,m = map(int,input().split())
x,y = min(x,y),max(x,y)
if y >= m:
print(0)
elif y <= 0:
print(-1)
else:
cnt=0
if x<0:
cnt += (-x)//y + 1
x = x + cnt*y
while y<m:
x,y = y,x+y
cnt += 1
print(cnt)
```
| 92,976 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.
Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).
What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?
Input
Single line of the input contains three integers x, y and m ( - 1018 β€ x, y, m β€ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.
Output
Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.
Examples
Input
1 2 5
Output
2
Input
-1 4 15
Output
4
Input
0 -1 5
Output
-1
Note
In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).
In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).
Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations.
Tags: brute force
Correct Solution:
```
x, y, m = [int(x) for x in input().split()]
x, y = min(x, y), max(x, y)
if y >= m:
print(0)
exit(0)
if y <= 0:
print(-1)
exit(0)
c = 0
if x < 0 and y > 0:
if m <= 0:
c = (m - x) // y
else:
c = -x // y
x += c * y
while x < m and y < m:
xx = x + y
if xx <= min(x, y):
print(-1)
exit(0)
x, y = xx, max(x, y)
c += 1
print(c)
```
| 92,977 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.
Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).
What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?
Input
Single line of the input contains three integers x, y and m ( - 1018 β€ x, y, m β€ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.
Output
Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.
Examples
Input
1 2 5
Output
2
Input
-1 4 15
Output
4
Input
0 -1 5
Output
-1
Note
In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).
In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).
Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations.
Tags: brute force
Correct Solution:
```
x,y,m = map(int,input().strip().split())
x,y = min(x,y),max(x,y)
if y>= m:
print(0)
elif y<=0:
print(-1)
elif x>=0:
i = 0
while y<m:
x,y = min(x+y,y) , max(x+y,y)
i += 1
print(i)
else:
n = (y-x)//y
if n*y + x < y:
n += 1
if n*y + x >= m:
print(n)
else:
i = n
x,y = y , n*y + x
while y<m:
x,y = min(x+y,y) , max(x+y,y)
i += 1
print(i)
```
| 92,978 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.
Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).
What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?
Input
Single line of the input contains three integers x, y and m ( - 1018 β€ x, y, m β€ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.
Output
Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.
Examples
Input
1 2 5
Output
2
Input
-1 4 15
Output
4
Input
0 -1 5
Output
-1
Note
In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).
In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).
Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations.
Tags: brute force
Correct Solution:
```
x,y,m=map(int,input().split())
x,y=min(x,y),max(x,y)
if y>=m:s=0
elif x+y<=x:s=-1
else:
s=(y-x+y-1)//y
x+=y*s
while max(x,y)<m:
if x<y:x+=y
else:y+=x
s+=1
print(s)
```
| 92,979 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.
Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).
What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?
Input
Single line of the input contains three integers x, y and m ( - 1018 β€ x, y, m β€ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.
Output
Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.
Examples
Input
1 2 5
Output
2
Input
-1 4 15
Output
4
Input
0 -1 5
Output
-1
Note
In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).
In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).
Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations.
Tags: brute force
Correct Solution:
```
import math
a, b, c = map (int, input().split())
if (max (a, b) >= c):
print (0)
raise SystemExit
if (a <= 0 and b <= 0) :
print (-1)
raise SystemExit
tot = 0
if ((a <= 0 and b > 0) or (b <= 0 and a > 0)) :
add = max (a, b)
menor = min (a, b)
adicionar = math.ceil(-menor / add)
tot = adicionar
if (min (a, b) == a) :
a += add * adicionar
else :
b += add * adicionar
times = 500
while (times > 0) :
times -= 1
if (max(a, b) >= c) :
print (tot)
raise SystemExit
tot += 1
add = a + b
if (min (a, b) == a) :
a = add
else :
b = add
print (-1)
```
| 92,980 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.
Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).
What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?
Input
Single line of the input contains three integers x, y and m ( - 1018 β€ x, y, m β€ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.
Output
Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.
Examples
Input
1 2 5
Output
2
Input
-1 4 15
Output
4
Input
0 -1 5
Output
-1
Note
In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).
In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).
Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations.
Tags: brute force
Correct Solution:
```
x, y, m = [int(x) for x in input().split()]
if (x >= m) or (y >= m):
print(0)
exit()
if (x <= 0) and (y <= 0):
print(-1)
exit()
res = 0
if x < 0:
res -= x // y
x %= y
if y < 0:
res -= y // x
y %= x
#print(x, y, res)
while (x < m) and (y < m):
if x < y:
x = x + y
else:
y = x + y
res += 1
print(res)
```
| 92,981 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.
Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).
What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?
Input
Single line of the input contains three integers x, y and m ( - 1018 β€ x, y, m β€ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.
Output
Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.
Examples
Input
1 2 5
Output
2
Input
-1 4 15
Output
4
Input
0 -1 5
Output
-1
Note
In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).
In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).
Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations.
Tags: brute force
Correct Solution:
```
#_________________ Mukul Mohan Varshney _______________#
#Template
import sys
import os
import math
import copy
from math import gcd
from bisect import bisect
from io import BytesIO, IOBase
from math import sqrt,floor,factorial,gcd,log,ceil
from collections import deque,Counter,defaultdict
from itertools import permutations, combinations
#define function
def Int(): return int(sys.stdin.readline())
def Mint(): return map(int,sys.stdin.readline().split())
def Lstr(): return list(sys.stdin.readline().strip())
def Str(): return sys.stdin.readline().strip()
def Mstr(): return map(str,sys.stdin.readline().strip().split())
def List(): return list(map(int,sys.stdin.readline().split()))
def Hash(): return dict()
def Mod(): return 1000000007
def Ncr(n,r,p): return ((fact[n])*((ifact[r]*ifact[n-r])%p))%p
def Most_frequent(list): return max(set(list), key = list.count)
def Mat2x2(n): return [List() for _ in range(n)]
def btod(n):
return int(n,2)
def dtob(n):
return bin(n).replace("0b","")
# Driver Code
def solution():
#for _ in range(Int()):
x,y,m=Mint()
ans=0
if(x>=m or y>=m):
print(0)
elif(x<=0 and y<=0):
print(-1)
else:
if(x>0 and y<0):
ans=(x-y-1)//x
y+=ans*x
elif(y>0 and x<0):
ans=(y-x-1)//y
x+=ans*y
while(x<m and y<m):
t=x+y
if(x<y):
x=t
else:
y=t
ans+=1
print(ans)
#Call the solve function
if __name__ == "__main__":
solution()
```
| 92,982 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.
Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).
What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?
Input
Single line of the input contains three integers x, y and m ( - 1018 β€ x, y, m β€ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.
Output
Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.
Examples
Input
1 2 5
Output
2
Input
-1 4 15
Output
4
Input
0 -1 5
Output
-1
Note
In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).
In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).
Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations.
Submitted Solution:
```
def Solve():
x,y,m=map(int,input().split())
if(x>=m or y>=m):
return 0
if(x<=0 and y<=0):
return -1
ans=0
if(y<=0):
ans=abs(y)//x+1
y+=ans*x
elif(x<=0):
ans=abs(x)//y+1
x+=ans*y
while(x<m and y<m):
if(x<y):
x+=y
else:
y+=x
ans+=1
return ans
print(Solve())
```
Yes
| 92,983 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.
Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).
What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?
Input
Single line of the input contains three integers x, y and m ( - 1018 β€ x, y, m β€ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.
Output
Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.
Examples
Input
1 2 5
Output
2
Input
-1 4 15
Output
4
Input
0 -1 5
Output
-1
Note
In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).
In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).
Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations.
Submitted Solution:
```
x, y, m = [int(number) for number in input().split()]
x, y = min(x, y), max(x, y)
if y >= m:
print(0)
quit()
if y <= 0:
print(-1)
quit()
answer = 0
if x < 0:
answer += (-x + y - 1) // y
x += answer * y
x, y = min(x, y), max(x, y)
if y >= m:
print(answer)
quit()
while y < m:
x, y = y, x + y
answer += 1
print(answer)
```
Yes
| 92,984 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.
Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).
What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?
Input
Single line of the input contains three integers x, y and m ( - 1018 β€ x, y, m β€ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.
Output
Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.
Examples
Input
1 2 5
Output
2
Input
-1 4 15
Output
4
Input
0 -1 5
Output
-1
Note
In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).
In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).
Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations.
Submitted Solution:
```
def doit():
x, y, m = [int(k) for k in input().strip().split()]
if x < y:
x, y = y, x
if x >= m:
print(0)
return
if x<=0 and y<=0:
print(-1)
return
k = 0
if y < 0:
k = (-y+x-1)//x
y += k*x
assert(y >= 0)
if x < y:
x, y = y, x
while x < m:
k += 1
x, y = x+y, x
if x < y:
x, y = y, x
print(k)
doit()
```
Yes
| 92,985 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.
Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).
What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?
Input
Single line of the input contains three integers x, y and m ( - 1018 β€ x, y, m β€ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.
Output
Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.
Examples
Input
1 2 5
Output
2
Input
-1 4 15
Output
4
Input
0 -1 5
Output
-1
Note
In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).
In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).
Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations.
Submitted Solution:
```
x, y, m = map(int, input().split())
if x < y: x, y = y, x
if x >= m: print(0)
elif x > 0:
s = 0
if y < 0:
s = (-y) // x + 1
y += x * s
while x < m:
x, y = x + y, x
s += 1
print(s)
elif x < m: print(-1)
else: print(0)
```
Yes
| 92,986 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.
Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).
What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?
Input
Single line of the input contains three integers x, y and m ( - 1018 β€ x, y, m β€ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.
Output
Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.
Examples
Input
1 2 5
Output
2
Input
-1 4 15
Output
4
Input
0 -1 5
Output
-1
Note
In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).
In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).
Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations.
Submitted Solution:
```
nums = input().split(' ')
x = int(nums[0])
y = int(nums[1])
m = int(nums[2])
def ispr(x, y, m):
def ispr_recur(x, y, m, n):
if x <= 0 and y <= 0 and (m > x or m > y):
return -1
if (x >= m or y >= m):
return n
elif x >= y:
n +=1
return ispr_recur(x, x + y, m, n)
elif x < y:
n +=1
return ispr_recur(x + y, y, m, n)
return ispr_recur(x, y, m, 0)
print(ispr(x, y, m))
```
No
| 92,987 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.
Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).
What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?
Input
Single line of the input contains three integers x, y and m ( - 1018 β€ x, y, m β€ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.
Output
Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.
Examples
Input
1 2 5
Output
2
Input
-1 4 15
Output
4
Input
0 -1 5
Output
-1
Note
In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).
In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).
Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations.
Submitted Solution:
```
# -*- coding: utf-8 -*-
def main():
x, y, m = map(int, input().split())
b1 = min(x, y)
b2 = max(x, y)
count = 0
while b2 < m:
b = b1 + b2
if (b <= b1):
print(-1)
return
b1 = b2
b2 = b
count += 1
print(count)
return
if __name__ == '__main__':
main()
```
No
| 92,988 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.
Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).
What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?
Input
Single line of the input contains three integers x, y and m ( - 1018 β€ x, y, m β€ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.
Output
Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.
Examples
Input
1 2 5
Output
2
Input
-1 4 15
Output
4
Input
0 -1 5
Output
-1
Note
In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).
In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).
Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations.
Submitted Solution:
```
#_________________ Mukul Mohan Varshney _______________#
#Template
import sys
import os
import math
import copy
from math import gcd
from bisect import bisect
from io import BytesIO, IOBase
from math import sqrt,floor,factorial,gcd,log,ceil
from collections import deque,Counter,defaultdict
from itertools import permutations, combinations
#define function
def Int(): return int(sys.stdin.readline())
def Mint(): return map(int,sys.stdin.readline().split())
def Lstr(): return list(sys.stdin.readline().strip())
def Str(): return sys.stdin.readline().strip()
def Mstr(): return map(str,sys.stdin.readline().strip().split())
def List(): return list(map(int,sys.stdin.readline().split()))
def Hash(): return dict()
def Mod(): return 1000000007
def Ncr(n,r,p): return ((fact[n])*((ifact[r]*ifact[n-r])%p))%p
def Most_frequent(list): return max(set(list), key = list.count)
def Mat2x2(n): return [List() for _ in range(n)]
def btod(n):
return int(n,2)
def dtob(n):
return bin(n).replace("0b","")
# Driver Code
def solution():
#for _ in range(Int()):
x,y,m=Mint()
maxi=max(x,y)
mini=min(x,y)
ans=m-mini
if(maxi==0):
print(-1)
else:
ans=ans//maxi
print(ans)
#Call the solve function
if __name__ == "__main__":
solution()
```
No
| 92,989 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.
Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).
What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?
Input
Single line of the input contains three integers x, y and m ( - 1018 β€ x, y, m β€ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.
Output
Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.
Examples
Input
1 2 5
Output
2
Input
-1 4 15
Output
4
Input
0 -1 5
Output
-1
Note
In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).
In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).
Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations.
Submitted Solution:
```
from collections import *
from math import *
from sys import *
n,m,k = map(int,input().split())
if(n+m > min(n,m)):
ct = 0
#print(m,n)
if(n < 0):
ct = ceil(-n/m)
n = n + ct*m
elif(m < 0):
ct = ceil(-m/n)
m = m + ct*n
#print(m,n)
while(max(n,m) < k):
if(n < m):
n = n+m
else:
m = n+m
ct += 1
print(ct)
else:
if(max(n,m) < k):
print(-1)
else:
print(0)
```
No
| 92,990 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Iahub is a big fan of tourists. He wants to become a tourist himself, so he planned a trip. There are n destinations on a straight road that Iahub wants to visit. Iahub starts the excursion from kilometer 0. The n destinations are described by a non-negative integers sequence a1, a2, ..., an. The number ak represents that the kth destination is at distance ak kilometers from the starting point. No two destinations are located in the same place.
Iahub wants to visit each destination only once. Note that, crossing through a destination is not considered visiting, unless Iahub explicitly wants to visit it at that point. Also, after Iahub visits his last destination, he doesn't come back to kilometer 0, as he stops his trip at the last destination.
The distance between destination located at kilometer x and next destination, located at kilometer y, is |x - y| kilometers. We call a "route" an order of visiting the destinations. Iahub can visit destinations in any order he wants, as long as he visits all n destinations and he doesn't visit a destination more than once.
Iahub starts writing out on a paper all possible routes and for each of them, he notes the total distance he would walk. He's interested in the average number of kilometers he would walk by choosing a route. As he got bored of writing out all the routes, he asks you to help him.
Input
The first line contains integer n (2 β€ n β€ 105). Next line contains n distinct integers a1, a2, ..., an (1 β€ ai β€ 107).
Output
Output two integers β the numerator and denominator of a fraction which is equal to the wanted average number. The fraction must be irreducible.
Examples
Input
3
2 3 5
Output
22 3
Note
Consider 6 possible routes:
* [2, 3, 5]: total distance traveled: |2 β 0| + |3 β 2| + |5 β 3| = 5;
* [2, 5, 3]: |2 β 0| + |5 β 2| + |3 β 5| = 7;
* [3, 2, 5]: |3 β 0| + |2 β 3| + |5 β 2| = 7;
* [3, 5, 2]: |3 β 0| + |5 β 3| + |2 β 5| = 8;
* [5, 2, 3]: |5 β 0| + |2 β 5| + |3 β 2| = 9;
* [5, 3, 2]: |5 β 0| + |3 β 5| + |2 β 3| = 8.
The average travel distance is <image> = <image> = <image>.
Tags: combinatorics, implementation, math
Correct Solution:
```
from sys import stdin
def c2 (x):
return x * (x - 1)
def gcd (p, q):
if q == 0:
return p
return gcd(q, p % q)
n = int(stdin.readline())
arr = list(map(int, stdin.readline().split()))
arr.sort()
denom = n * (n - 1)
ans = 0
for i in range(n):
L = i
R = n - i - 1
add = 0
add += 2 * c2(L)
add += 2 * L
add += L
add -= R
add -= 2 * c2(R)
ans += add * arr[i]
gc = gcd(ans, denom)
ans //= gc
denom //= gc
print(ans, denom)
```
| 92,991 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Iahub is a big fan of tourists. He wants to become a tourist himself, so he planned a trip. There are n destinations on a straight road that Iahub wants to visit. Iahub starts the excursion from kilometer 0. The n destinations are described by a non-negative integers sequence a1, a2, ..., an. The number ak represents that the kth destination is at distance ak kilometers from the starting point. No two destinations are located in the same place.
Iahub wants to visit each destination only once. Note that, crossing through a destination is not considered visiting, unless Iahub explicitly wants to visit it at that point. Also, after Iahub visits his last destination, he doesn't come back to kilometer 0, as he stops his trip at the last destination.
The distance between destination located at kilometer x and next destination, located at kilometer y, is |x - y| kilometers. We call a "route" an order of visiting the destinations. Iahub can visit destinations in any order he wants, as long as he visits all n destinations and he doesn't visit a destination more than once.
Iahub starts writing out on a paper all possible routes and for each of them, he notes the total distance he would walk. He's interested in the average number of kilometers he would walk by choosing a route. As he got bored of writing out all the routes, he asks you to help him.
Input
The first line contains integer n (2 β€ n β€ 105). Next line contains n distinct integers a1, a2, ..., an (1 β€ ai β€ 107).
Output
Output two integers β the numerator and denominator of a fraction which is equal to the wanted average number. The fraction must be irreducible.
Examples
Input
3
2 3 5
Output
22 3
Note
Consider 6 possible routes:
* [2, 3, 5]: total distance traveled: |2 β 0| + |3 β 2| + |5 β 3| = 5;
* [2, 5, 3]: |2 β 0| + |5 β 2| + |3 β 5| = 7;
* [3, 2, 5]: |3 β 0| + |2 β 3| + |5 β 2| = 7;
* [3, 5, 2]: |3 β 0| + |5 β 3| + |2 β 5| = 8;
* [5, 2, 3]: |5 β 0| + |2 β 5| + |3 β 2| = 9;
* [5, 3, 2]: |5 β 0| + |3 β 5| + |2 β 3| = 8.
The average travel distance is <image> = <image> = <image>.
Tags: combinatorics, implementation, math
Correct Solution:
```
from fractions import Fraction
n=int(input())
a=[int(i) for i in input().split()]
a=sorted(a)
s=[]
s.append(0)
for i in range(n):
s.append(s[-1]+a[i])
ans=0
for i in range(1,n+1):
ans+=s[n]-s[i-1]-(n-i+1)*a[i-1]
ans=ans*2+sum(a)
ans=Fraction(ans,n)
print("{0:d} {1:d}".format(ans.numerator,ans.denominator))
```
| 92,992 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Iahub is a big fan of tourists. He wants to become a tourist himself, so he planned a trip. There are n destinations on a straight road that Iahub wants to visit. Iahub starts the excursion from kilometer 0. The n destinations are described by a non-negative integers sequence a1, a2, ..., an. The number ak represents that the kth destination is at distance ak kilometers from the starting point. No two destinations are located in the same place.
Iahub wants to visit each destination only once. Note that, crossing through a destination is not considered visiting, unless Iahub explicitly wants to visit it at that point. Also, after Iahub visits his last destination, he doesn't come back to kilometer 0, as he stops his trip at the last destination.
The distance between destination located at kilometer x and next destination, located at kilometer y, is |x - y| kilometers. We call a "route" an order of visiting the destinations. Iahub can visit destinations in any order he wants, as long as he visits all n destinations and he doesn't visit a destination more than once.
Iahub starts writing out on a paper all possible routes and for each of them, he notes the total distance he would walk. He's interested in the average number of kilometers he would walk by choosing a route. As he got bored of writing out all the routes, he asks you to help him.
Input
The first line contains integer n (2 β€ n β€ 105). Next line contains n distinct integers a1, a2, ..., an (1 β€ ai β€ 107).
Output
Output two integers β the numerator and denominator of a fraction which is equal to the wanted average number. The fraction must be irreducible.
Examples
Input
3
2 3 5
Output
22 3
Note
Consider 6 possible routes:
* [2, 3, 5]: total distance traveled: |2 β 0| + |3 β 2| + |5 β 3| = 5;
* [2, 5, 3]: |2 β 0| + |5 β 2| + |3 β 5| = 7;
* [3, 2, 5]: |3 β 0| + |2 β 3| + |5 β 2| = 7;
* [3, 5, 2]: |3 β 0| + |5 β 3| + |2 β 5| = 8;
* [5, 2, 3]: |5 β 0| + |2 β 5| + |3 β 2| = 9;
* [5, 3, 2]: |5 β 0| + |3 β 5| + |2 β 3| = 8.
The average travel distance is <image> = <image> = <image>.
Tags: combinatorics, implementation, math
Correct Solution:
```
import math
n = int(input())
a = list(map(int, input().split()))
a.sort(reverse = True)
k = 0
s1 = 0
s2 = 0
for i in a:
s2 += s1 - k * i
s1 += i
k += 1
s2 *= 2
s2 += sum(a)
gcd = math.gcd(s2, n)
print(s2 // gcd, n // gcd)
```
| 92,993 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Iahub is a big fan of tourists. He wants to become a tourist himself, so he planned a trip. There are n destinations on a straight road that Iahub wants to visit. Iahub starts the excursion from kilometer 0. The n destinations are described by a non-negative integers sequence a1, a2, ..., an. The number ak represents that the kth destination is at distance ak kilometers from the starting point. No two destinations are located in the same place.
Iahub wants to visit each destination only once. Note that, crossing through a destination is not considered visiting, unless Iahub explicitly wants to visit it at that point. Also, after Iahub visits his last destination, he doesn't come back to kilometer 0, as he stops his trip at the last destination.
The distance between destination located at kilometer x and next destination, located at kilometer y, is |x - y| kilometers. We call a "route" an order of visiting the destinations. Iahub can visit destinations in any order he wants, as long as he visits all n destinations and he doesn't visit a destination more than once.
Iahub starts writing out on a paper all possible routes and for each of them, he notes the total distance he would walk. He's interested in the average number of kilometers he would walk by choosing a route. As he got bored of writing out all the routes, he asks you to help him.
Input
The first line contains integer n (2 β€ n β€ 105). Next line contains n distinct integers a1, a2, ..., an (1 β€ ai β€ 107).
Output
Output two integers β the numerator and denominator of a fraction which is equal to the wanted average number. The fraction must be irreducible.
Examples
Input
3
2 3 5
Output
22 3
Note
Consider 6 possible routes:
* [2, 3, 5]: total distance traveled: |2 β 0| + |3 β 2| + |5 β 3| = 5;
* [2, 5, 3]: |2 β 0| + |5 β 2| + |3 β 5| = 7;
* [3, 2, 5]: |3 β 0| + |2 β 3| + |5 β 2| = 7;
* [3, 5, 2]: |3 β 0| + |5 β 3| + |2 β 5| = 8;
* [5, 2, 3]: |5 β 0| + |2 β 5| + |3 β 2| = 9;
* [5, 3, 2]: |5 β 0| + |3 β 5| + |2 β 3| = 8.
The average travel distance is <image> = <image> = <image>.
Tags: combinatorics, implementation, math
Correct Solution:
```
import math
def read_int():
return int(input().strip())
def read_ints():
return list(map(int, input().strip().split(' ')))
def solve():
"""
a[i] -> a[j]
(n-1)!*|a[i]-a[j]| for all j
(n-1)!*(for i=1..n, for j=1..n sum(|a[i]-a[j]|))
/
n!
"""
n = read_int()
a = read_ints()
a.sort()
R = sum(abs(a[i]-a[0]) for i in range(1, n))
L = 0
S = R+sum(a)
# a[0]+a[1]+...+a[n-1]
# (a[0]-a[0])+(a[1]-a[0])+(a[2]-a[0])+...+(a[n-1]-a[0])
# (a[1]-a[0])+(a[1]-a[1])+(a[2]-a[1])+...+(a[n-1]-a[1])
# (a[2]-a[0])+(a[2]-a[1])+(a[2]-a[2])+...+(a[n-1]-a[2])
# S-n*a[0]
# S-a[0]
for i in range(1, n):
L += (a[i]-a[i-1])*i
R -= (a[i]-a[i-1])*(n-i)
S += (L+R)
gcd = math.gcd(S, n)
print(S//gcd, n//gcd)
if __name__ == '__main__':
solve()
```
| 92,994 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Iahub is a big fan of tourists. He wants to become a tourist himself, so he planned a trip. There are n destinations on a straight road that Iahub wants to visit. Iahub starts the excursion from kilometer 0. The n destinations are described by a non-negative integers sequence a1, a2, ..., an. The number ak represents that the kth destination is at distance ak kilometers from the starting point. No two destinations are located in the same place.
Iahub wants to visit each destination only once. Note that, crossing through a destination is not considered visiting, unless Iahub explicitly wants to visit it at that point. Also, after Iahub visits his last destination, he doesn't come back to kilometer 0, as he stops his trip at the last destination.
The distance between destination located at kilometer x and next destination, located at kilometer y, is |x - y| kilometers. We call a "route" an order of visiting the destinations. Iahub can visit destinations in any order he wants, as long as he visits all n destinations and he doesn't visit a destination more than once.
Iahub starts writing out on a paper all possible routes and for each of them, he notes the total distance he would walk. He's interested in the average number of kilometers he would walk by choosing a route. As he got bored of writing out all the routes, he asks you to help him.
Input
The first line contains integer n (2 β€ n β€ 105). Next line contains n distinct integers a1, a2, ..., an (1 β€ ai β€ 107).
Output
Output two integers β the numerator and denominator of a fraction which is equal to the wanted average number. The fraction must be irreducible.
Examples
Input
3
2 3 5
Output
22 3
Note
Consider 6 possible routes:
* [2, 3, 5]: total distance traveled: |2 β 0| + |3 β 2| + |5 β 3| = 5;
* [2, 5, 3]: |2 β 0| + |5 β 2| + |3 β 5| = 7;
* [3, 2, 5]: |3 β 0| + |2 β 3| + |5 β 2| = 7;
* [3, 5, 2]: |3 β 0| + |5 β 3| + |2 β 5| = 8;
* [5, 2, 3]: |5 β 0| + |2 β 5| + |3 β 2| = 9;
* [5, 3, 2]: |5 β 0| + |3 β 5| + |2 β 3| = 8.
The average travel distance is <image> = <image> = <image>.
Tags: combinatorics, implementation, math
Correct Solution:
```
from math import *
n=int(input())
arr=list(map(int,input().split()))
arr.sort()
S1=sum(arr)
sums=0
sumsi=arr[0]
for i in range(1,n):
sums+=(i)*(arr[i])-sumsi
sumsi+=arr[i]
S2=sums
num=S1+2*S2
den=n
#print(num,den)
while(int(gcd(num,den))!=1):
x=gcd(num,den)
num=num//x
den=den//x
print(int(num),int(den))
```
| 92,995 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Iahub is a big fan of tourists. He wants to become a tourist himself, so he planned a trip. There are n destinations on a straight road that Iahub wants to visit. Iahub starts the excursion from kilometer 0. The n destinations are described by a non-negative integers sequence a1, a2, ..., an. The number ak represents that the kth destination is at distance ak kilometers from the starting point. No two destinations are located in the same place.
Iahub wants to visit each destination only once. Note that, crossing through a destination is not considered visiting, unless Iahub explicitly wants to visit it at that point. Also, after Iahub visits his last destination, he doesn't come back to kilometer 0, as he stops his trip at the last destination.
The distance between destination located at kilometer x and next destination, located at kilometer y, is |x - y| kilometers. We call a "route" an order of visiting the destinations. Iahub can visit destinations in any order he wants, as long as he visits all n destinations and he doesn't visit a destination more than once.
Iahub starts writing out on a paper all possible routes and for each of them, he notes the total distance he would walk. He's interested in the average number of kilometers he would walk by choosing a route. As he got bored of writing out all the routes, he asks you to help him.
Input
The first line contains integer n (2 β€ n β€ 105). Next line contains n distinct integers a1, a2, ..., an (1 β€ ai β€ 107).
Output
Output two integers β the numerator and denominator of a fraction which is equal to the wanted average number. The fraction must be irreducible.
Examples
Input
3
2 3 5
Output
22 3
Note
Consider 6 possible routes:
* [2, 3, 5]: total distance traveled: |2 β 0| + |3 β 2| + |5 β 3| = 5;
* [2, 5, 3]: |2 β 0| + |5 β 2| + |3 β 5| = 7;
* [3, 2, 5]: |3 β 0| + |2 β 3| + |5 β 2| = 7;
* [3, 5, 2]: |3 β 0| + |5 β 3| + |2 β 5| = 8;
* [5, 2, 3]: |5 β 0| + |2 β 5| + |3 β 2| = 9;
* [5, 3, 2]: |5 β 0| + |3 β 5| + |2 β 3| = 8.
The average travel distance is <image> = <image> = <image>.
Tags: combinatorics, implementation, math
Correct Solution:
```
#!/usr/bin/env python3
def read_string():
return input()
def read_strings(return_type = iter, split = None, skip = 0):
return return_type(input().split(split)[skip:])
def read_lines(height, return_type = iter):
return return_type(read_string() for i in range(height))
def read_number():
return int(input())
def read_numbers(return_type = iter, skip = 0):
return return_type(int(i) for i in input().split()[skip:])
def read_values(*types, array = None):
line = input().split()
result = []
for return_type, i in zip(types, range(len(types))):
result.append(return_type(line[i]))
if array != None:
array_type, array_contained = array
result.append(array_type(array_contained(i) for i in line[len(types):]))
return result
def read_array(item_type = int, return_type = iter, skip = 0):
return return_type(item_type(i) for i in input().split()[skip:])
def read_martix(height, **args):
return_type = args["return_type"] if "return_type" in args else iter
return_type_inner = args["return_type_inner"] if "return_type_inner" in args else return_type
return_type_outer = args["return_type_outer"] if "return_type_outer" in args else return_type
item_type = args["item_type"] if "item_type" in args else int
return return_type_outer(read_array(item_type = item_type, return_type = return_type_inner) for i in range(height))
def read_martix_linear(width, skip = 0, item_type = int, skiped = None):
num = read_array(item_type = item_type, skip = skip)
height = len(num) / width
return [num[i * width: (i + 1) * width] for i in range(height)]
def gcd(n, m):
if m == 0:
return n
return gcd(m, n % m)
def main():
n = read_number()
arr = sorted(read_numbers(list))
sum_x = sum(arr)
sum_xy = 0
for i in range(1, n):
sum_xy += (arr[i] - arr[i - 1]) * i * (n - i)
nu = sum_x + sum_xy * 2
de = n
g = gcd(nu, de)
nu //= g
de //= g
print(nu, de)
if __name__ == '__main__':
main()
```
| 92,996 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Iahub is a big fan of tourists. He wants to become a tourist himself, so he planned a trip. There are n destinations on a straight road that Iahub wants to visit. Iahub starts the excursion from kilometer 0. The n destinations are described by a non-negative integers sequence a1, a2, ..., an. The number ak represents that the kth destination is at distance ak kilometers from the starting point. No two destinations are located in the same place.
Iahub wants to visit each destination only once. Note that, crossing through a destination is not considered visiting, unless Iahub explicitly wants to visit it at that point. Also, after Iahub visits his last destination, he doesn't come back to kilometer 0, as he stops his trip at the last destination.
The distance between destination located at kilometer x and next destination, located at kilometer y, is |x - y| kilometers. We call a "route" an order of visiting the destinations. Iahub can visit destinations in any order he wants, as long as he visits all n destinations and he doesn't visit a destination more than once.
Iahub starts writing out on a paper all possible routes and for each of them, he notes the total distance he would walk. He's interested in the average number of kilometers he would walk by choosing a route. As he got bored of writing out all the routes, he asks you to help him.
Input
The first line contains integer n (2 β€ n β€ 105). Next line contains n distinct integers a1, a2, ..., an (1 β€ ai β€ 107).
Output
Output two integers β the numerator and denominator of a fraction which is equal to the wanted average number. The fraction must be irreducible.
Examples
Input
3
2 3 5
Output
22 3
Note
Consider 6 possible routes:
* [2, 3, 5]: total distance traveled: |2 β 0| + |3 β 2| + |5 β 3| = 5;
* [2, 5, 3]: |2 β 0| + |5 β 2| + |3 β 5| = 7;
* [3, 2, 5]: |3 β 0| + |2 β 3| + |5 β 2| = 7;
* [3, 5, 2]: |3 β 0| + |5 β 3| + |2 β 5| = 8;
* [5, 2, 3]: |5 β 0| + |2 β 5| + |3 β 2| = 9;
* [5, 3, 2]: |5 β 0| + |3 β 5| + |2 β 3| = 8.
The average travel distance is <image> = <image> = <image>.
Tags: combinatorics, implementation, math
Correct Solution:
```
from fractions import *
def solve():
n = int(input())
a = list(map(int,input().split()))
a.sort()
ans1 = 0
pres = a[0]
for i in range(1,n):
ans1+=i*a[i] -pres
pres+=a[i]
ans1 *= 2;
tmp = pres+ans1
tmp1 = n
s = Fraction(tmp,tmp1)
print(s.numerator,s.denominator)
solve()
```
| 92,997 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Iahub is a big fan of tourists. He wants to become a tourist himself, so he planned a trip. There are n destinations on a straight road that Iahub wants to visit. Iahub starts the excursion from kilometer 0. The n destinations are described by a non-negative integers sequence a1, a2, ..., an. The number ak represents that the kth destination is at distance ak kilometers from the starting point. No two destinations are located in the same place.
Iahub wants to visit each destination only once. Note that, crossing through a destination is not considered visiting, unless Iahub explicitly wants to visit it at that point. Also, after Iahub visits his last destination, he doesn't come back to kilometer 0, as he stops his trip at the last destination.
The distance between destination located at kilometer x and next destination, located at kilometer y, is |x - y| kilometers. We call a "route" an order of visiting the destinations. Iahub can visit destinations in any order he wants, as long as he visits all n destinations and he doesn't visit a destination more than once.
Iahub starts writing out on a paper all possible routes and for each of them, he notes the total distance he would walk. He's interested in the average number of kilometers he would walk by choosing a route. As he got bored of writing out all the routes, he asks you to help him.
Input
The first line contains integer n (2 β€ n β€ 105). Next line contains n distinct integers a1, a2, ..., an (1 β€ ai β€ 107).
Output
Output two integers β the numerator and denominator of a fraction which is equal to the wanted average number. The fraction must be irreducible.
Examples
Input
3
2 3 5
Output
22 3
Note
Consider 6 possible routes:
* [2, 3, 5]: total distance traveled: |2 β 0| + |3 β 2| + |5 β 3| = 5;
* [2, 5, 3]: |2 β 0| + |5 β 2| + |3 β 5| = 7;
* [3, 2, 5]: |3 β 0| + |2 β 3| + |5 β 2| = 7;
* [3, 5, 2]: |3 β 0| + |5 β 3| + |2 β 5| = 8;
* [5, 2, 3]: |5 β 0| + |2 β 5| + |3 β 2| = 9;
* [5, 3, 2]: |5 β 0| + |3 β 5| + |2 β 3| = 8.
The average travel distance is <image> = <image> = <image>.
Tags: combinatorics, implementation, math
Correct Solution:
```
from fractions import *
n=int(input());
a=list(map(int,input().split()));
a=sorted(a);
now=a[0];
ans=0;
for i in range(1,n):
ans+=i*a[i]-now;
now=now+a[i];
ans=ans*2+now;
s=Fraction(ans,n);
print(s.numerator,s.denominator);
```
| 92,998 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Iahub is a big fan of tourists. He wants to become a tourist himself, so he planned a trip. There are n destinations on a straight road that Iahub wants to visit. Iahub starts the excursion from kilometer 0. The n destinations are described by a non-negative integers sequence a1, a2, ..., an. The number ak represents that the kth destination is at distance ak kilometers from the starting point. No two destinations are located in the same place.
Iahub wants to visit each destination only once. Note that, crossing through a destination is not considered visiting, unless Iahub explicitly wants to visit it at that point. Also, after Iahub visits his last destination, he doesn't come back to kilometer 0, as he stops his trip at the last destination.
The distance between destination located at kilometer x and next destination, located at kilometer y, is |x - y| kilometers. We call a "route" an order of visiting the destinations. Iahub can visit destinations in any order he wants, as long as he visits all n destinations and he doesn't visit a destination more than once.
Iahub starts writing out on a paper all possible routes and for each of them, he notes the total distance he would walk. He's interested in the average number of kilometers he would walk by choosing a route. As he got bored of writing out all the routes, he asks you to help him.
Input
The first line contains integer n (2 β€ n β€ 105). Next line contains n distinct integers a1, a2, ..., an (1 β€ ai β€ 107).
Output
Output two integers β the numerator and denominator of a fraction which is equal to the wanted average number. The fraction must be irreducible.
Examples
Input
3
2 3 5
Output
22 3
Note
Consider 6 possible routes:
* [2, 3, 5]: total distance traveled: |2 β 0| + |3 β 2| + |5 β 3| = 5;
* [2, 5, 3]: |2 β 0| + |5 β 2| + |3 β 5| = 7;
* [3, 2, 5]: |3 β 0| + |2 β 3| + |5 β 2| = 7;
* [3, 5, 2]: |3 β 0| + |5 β 3| + |2 β 5| = 8;
* [5, 2, 3]: |5 β 0| + |2 β 5| + |3 β 2| = 9;
* [5, 3, 2]: |5 β 0| + |3 β 5| + |2 β 3| = 8.
The average travel distance is <image> = <image> = <image>.
Submitted Solution:
```
#!/usr/bin/python3
import sys
from fractions import Fraction
n = int(sys.stdin.readline())
a = [int(x) for x in sys.stdin.readline().strip().split()]
a.sort()
s1 = sum(a)
p = [0 for i in range(n)]
c = [1 for i in range(n)]
for i in range(1, n):
p[i] = (a[i] - a[i-1]) * c[i-1] + p[i-1]
c[i] += c[i-1]
s2 = 2*sum(p)
ans = Fraction(s1 + s2, n)
print("{0} {1}".format(ans.numerator, ans.denominator))
```
Yes
| 92,999 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.