message stringlengths 2 59.7k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 37 108k | cluster float64 20 20 | __index_level_0__ int64 74 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya is sitting on an extremely boring math class. To have fun, he took a piece of paper and wrote out n numbers on a single line. After that, Vasya began to write out different ways to put pluses ("+") in the line between certain digits in the line so that the result was a correct arithmetic expression; formally, no two pluses in such a partition can stand together (between any two adjacent pluses there must be at least one digit), and no plus can stand at the beginning or the end of a line. For example, in the string 100500, ways 100500 (add no pluses), 1+00+500 or 10050+0 are correct, and ways 100++500, +1+0+0+5+0+0 or 100500+ are incorrect.
The lesson was long, and Vasya has written all the correct ways to place exactly k pluses in a string of digits. At this point, he got caught having fun by a teacher and he was given the task to calculate the sum of all the resulting arithmetic expressions by the end of the lesson (when calculating the value of an expression the leading zeros should be ignored). As the answer can be large, Vasya is allowed to get only its remainder modulo 109 + 7. Help him!
Input
The first line contains two integers, n and k (0 ≤ k < n ≤ 105).
The second line contains a string consisting of n digits.
Output
Print the answer to the problem modulo 109 + 7.
Examples
Input
3 1
108
Output
27
Input
3 2
108
Output
9
Note
In the first sample the result equals (1 + 08) + (10 + 8) = 27.
In the second sample the result equals 1 + 0 + 8 = 9. | instruction | 0 | 64,382 | 20 | 128,764 |
Tags: combinatorics, dp, math, number theory
Correct Solution:
```
n, k = map(int, input().split())
t = list(map(int, input()))
s = 0
d = 10 ** 9 + 7
f = [1] * n
for i in range(2, n): f[i] = (i * f[i - 1]) % d
c = lambda a, b: 0 if a > b else (f[b] * pow(f[a] * f[b - a], d - 2, d)) % d
if k:
p = [1] * (n + 1)
for i in range(n): p[i + 1] = (10 * p[i]) % d
x = [p[i] * c(k - 1, n - 2 - i) for i in range(n + 1)]
for i in range(n): x[i] = (x[i] + x[i - 1]) % d
for i in range(n):
y = x[n - 2 - i] + p[n - 1 - i] * c(k, i)
s = (s + t[i] * y) % d
else:
for i in t: s = (s * 10 + i) % d
print(s)
``` | output | 1 | 64,382 | 20 | 128,765 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya is sitting on an extremely boring math class. To have fun, he took a piece of paper and wrote out n numbers on a single line. After that, Vasya began to write out different ways to put pluses ("+") in the line between certain digits in the line so that the result was a correct arithmetic expression; formally, no two pluses in such a partition can stand together (between any two adjacent pluses there must be at least one digit), and no plus can stand at the beginning or the end of a line. For example, in the string 100500, ways 100500 (add no pluses), 1+00+500 or 10050+0 are correct, and ways 100++500, +1+0+0+5+0+0 or 100500+ are incorrect.
The lesson was long, and Vasya has written all the correct ways to place exactly k pluses in a string of digits. At this point, he got caught having fun by a teacher and he was given the task to calculate the sum of all the resulting arithmetic expressions by the end of the lesson (when calculating the value of an expression the leading zeros should be ignored). As the answer can be large, Vasya is allowed to get only its remainder modulo 109 + 7. Help him!
Input
The first line contains two integers, n and k (0 ≤ k < n ≤ 105).
The second line contains a string consisting of n digits.
Output
Print the answer to the problem modulo 109 + 7.
Examples
Input
3 1
108
Output
27
Input
3 2
108
Output
9
Note
In the first sample the result equals (1 + 08) + (10 + 8) = 27.
In the second sample the result equals 1 + 0 + 8 = 9. | instruction | 0 | 64,383 | 20 | 128,766 |
Tags: combinatorics, dp, math, number theory
Correct Solution:
```
n, k = map(int, input().split())
t = list(map(int, input()))
p, d = 1, 10 ** 9 + 7
s, f = 0, [1] * n
for i in range(2, n): f[i] = (i * f[i - 1]) % d
c = lambda a, b: 0 if a > b else (f[b] * pow(f[a] * f[b - a], d - 2, d)) % d
if k:
u = [0] * (n + 1)
p = [1] * (n + 1)
for i in range(n):
u[i] = (p[i] * c(k - 1, n - 2 - i) + u[i - 1]) % d
p[i + 1] = (10 * p[i]) % d
for i in range(n):
v = u[n - 2 - i] + p[n - 1 - i] * c(k, i)
s = (s + t[i] * v) % d
else:
for i in t: s = (s * 10 + i) % d
print(s)
``` | output | 1 | 64,383 | 20 | 128,767 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya is sitting on an extremely boring math class. To have fun, he took a piece of paper and wrote out n numbers on a single line. After that, Vasya began to write out different ways to put pluses ("+") in the line between certain digits in the line so that the result was a correct arithmetic expression; formally, no two pluses in such a partition can stand together (between any two adjacent pluses there must be at least one digit), and no plus can stand at the beginning or the end of a line. For example, in the string 100500, ways 100500 (add no pluses), 1+00+500 or 10050+0 are correct, and ways 100++500, +1+0+0+5+0+0 or 100500+ are incorrect.
The lesson was long, and Vasya has written all the correct ways to place exactly k pluses in a string of digits. At this point, he got caught having fun by a teacher and he was given the task to calculate the sum of all the resulting arithmetic expressions by the end of the lesson (when calculating the value of an expression the leading zeros should be ignored). As the answer can be large, Vasya is allowed to get only its remainder modulo 109 + 7. Help him!
Input
The first line contains two integers, n and k (0 ≤ k < n ≤ 105).
The second line contains a string consisting of n digits.
Output
Print the answer to the problem modulo 109 + 7.
Examples
Input
3 1
108
Output
27
Input
3 2
108
Output
9
Note
In the first sample the result equals (1 + 08) + (10 + 8) = 27.
In the second sample the result equals 1 + 0 + 8 = 9.
Submitted Solution:
```
n, k = map(int, input().split())
h = input()
t = list(map(int, h))
d = 10 ** 9 + 7
s, f = 0, [1] * n
for i in range(2, n): f[i] = (i * f[i - 1]) % d
for i in range(1, n - 1):
x = 0
for j in range(i, n - 1):
x = (10 * x + t[j]) % d
b = n - 3 - j + i
a = k - 2
if b < a: break
c = (f[b] * pow(f[a] * f[b - a], d - 2, d)) % d
s = (s + c * x) % d
x = 0
for j in range(n - 1):
x = (10 * x + t[j]) % d
b = n - 2 - j
a = k - 1
if b < a: break
c = (f[b] * pow(f[a] * f[b - a], d - 2, d)) % d
s = (s + c * x) % d
x = 0
for j in range(k, n):
b = j - 1
a = k - 1
x = int(h[j:]) % d
c = (f[b] * pow(f[a] * f[b - a], d - 2, d)) % d
s = (s + c * x) % d
print(s)
``` | instruction | 0 | 64,384 | 20 | 128,768 |
No | output | 1 | 64,384 | 20 | 128,769 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya is sitting on an extremely boring math class. To have fun, he took a piece of paper and wrote out n numbers on a single line. After that, Vasya began to write out different ways to put pluses ("+") in the line between certain digits in the line so that the result was a correct arithmetic expression; formally, no two pluses in such a partition can stand together (between any two adjacent pluses there must be at least one digit), and no plus can stand at the beginning or the end of a line. For example, in the string 100500, ways 100500 (add no pluses), 1+00+500 or 10050+0 are correct, and ways 100++500, +1+0+0+5+0+0 or 100500+ are incorrect.
The lesson was long, and Vasya has written all the correct ways to place exactly k pluses in a string of digits. At this point, he got caught having fun by a teacher and he was given the task to calculate the sum of all the resulting arithmetic expressions by the end of the lesson (when calculating the value of an expression the leading zeros should be ignored). As the answer can be large, Vasya is allowed to get only its remainder modulo 109 + 7. Help him!
Input
The first line contains two integers, n and k (0 ≤ k < n ≤ 105).
The second line contains a string consisting of n digits.
Output
Print the answer to the problem modulo 109 + 7.
Examples
Input
3 1
108
Output
27
Input
3 2
108
Output
9
Note
In the first sample the result equals (1 + 08) + (10 + 8) = 27.
In the second sample the result equals 1 + 0 + 8 = 9.
Submitted Solution:
```
n, k = input().split()
def f(t, k):
if not k: return int(t), 1
S = N = 0
for i in range(len(t) - k):
s, n = f(t[i + 1:], k - 1)
S += int(t[:i + 1]) * n + s
N += n
return S, N
print(f(input(), int(k))[0])
``` | instruction | 0 | 64,385 | 20 | 128,770 |
No | output | 1 | 64,385 | 20 | 128,771 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya is sitting on an extremely boring math class. To have fun, he took a piece of paper and wrote out n numbers on a single line. After that, Vasya began to write out different ways to put pluses ("+") in the line between certain digits in the line so that the result was a correct arithmetic expression; formally, no two pluses in such a partition can stand together (between any two adjacent pluses there must be at least one digit), and no plus can stand at the beginning or the end of a line. For example, in the string 100500, ways 100500 (add no pluses), 1+00+500 or 10050+0 are correct, and ways 100++500, +1+0+0+5+0+0 or 100500+ are incorrect.
The lesson was long, and Vasya has written all the correct ways to place exactly k pluses in a string of digits. At this point, he got caught having fun by a teacher and he was given the task to calculate the sum of all the resulting arithmetic expressions by the end of the lesson (when calculating the value of an expression the leading zeros should be ignored). As the answer can be large, Vasya is allowed to get only its remainder modulo 109 + 7. Help him!
Input
The first line contains two integers, n and k (0 ≤ k < n ≤ 105).
The second line contains a string consisting of n digits.
Output
Print the answer to the problem modulo 109 + 7.
Examples
Input
3 1
108
Output
27
Input
3 2
108
Output
9
Note
In the first sample the result equals (1 + 08) + (10 + 8) = 27.
In the second sample the result equals 1 + 0 + 8 = 9.
Submitted Solution:
```
n, k = map(int, input().split())
h = input()
t = list(map(int, h))
d = 10 ** 9 + 7
s, f = 0, [1] * n
for i in range(2, n): f[i] = (i * f[i - 1]) % d
if k > 1:
for i in range(1, n - 1):
x = 0
for j in range(i, n - 1):
x = (10 * x + t[j]) % d
b = n - 3 - j + i
a = k - 2
if b < a: break
c = (f[b] * pow(f[a] * f[b - a], d - 2, d)) % d
s = (s + c * x) % d
x = 0
for j in range(n - 1):
x = (10 * x + t[j]) % d
b = n - 2 - j
a = k - 1
if b < a: break
c = (f[b] * pow(f[a] * f[b - a], d - 2, d)) % d
s = (s + c * x) % d
for j in range(k, n):
b = j - 1
a = k - 1
x = int(h[j:]) % d
c = (f[b] * pow(f[a] * f[b - a], d - 2, d)) % d
s = (s + c * x) % d
print(s)
``` | instruction | 0 | 64,386 | 20 | 128,772 |
No | output | 1 | 64,386 | 20 | 128,773 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n integers b1, b2, ..., bn written in a row. For all i from 1 to n, values ai are defined by the crows performing the following procedure:
* The crow sets ai initially 0.
* The crow then adds bi to ai, subtracts bi + 1, adds the bi + 2 number, and so on until the n'th number. Thus, ai = bi - bi + 1 + bi + 2 - bi + 3....
Memory gives you the values a1, a2, ..., an, and he now wants you to find the initial numbers b1, b2, ..., bn written in the row? Can you do it?
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the number of integers written in the row.
The next line contains n, the i'th of which is ai ( - 109 ≤ ai ≤ 109) — the value of the i'th number.
Output
Print n integers corresponding to the sequence b1, b2, ..., bn. It's guaranteed that the answer is unique and fits in 32-bit integer type.
Examples
Input
5
6 -4 8 -2 3
Output
2 4 6 1 3
Input
5
3 -2 -1 5 6
Output
1 -3 4 11 6
Note
In the first sample test, the crows report the numbers 6, - 4, 8, - 2, and 3 when he starts at indices 1, 2, 3, 4 and 5 respectively. It is easy to check that the sequence 2 4 6 1 3 satisfies the reports. For example, 6 = 2 - 4 + 6 - 1 + 3, and - 4 = 4 - 6 + 1 - 3.
In the second sample test, the sequence 1, - 3, 4, 11, 6 satisfies the reports. For example, 5 = 11 - 6 and 6 = 6. | instruction | 0 | 64,466 | 20 | 128,932 |
Tags: implementation, math
Correct Solution:
```
input()
b=list(map(int, input().split()))+[0]
print(*(b[i-1]+b[i] for i in range(1, len(b))))
``` | output | 1 | 64,466 | 20 | 128,933 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n integers b1, b2, ..., bn written in a row. For all i from 1 to n, values ai are defined by the crows performing the following procedure:
* The crow sets ai initially 0.
* The crow then adds bi to ai, subtracts bi + 1, adds the bi + 2 number, and so on until the n'th number. Thus, ai = bi - bi + 1 + bi + 2 - bi + 3....
Memory gives you the values a1, a2, ..., an, and he now wants you to find the initial numbers b1, b2, ..., bn written in the row? Can you do it?
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the number of integers written in the row.
The next line contains n, the i'th of which is ai ( - 109 ≤ ai ≤ 109) — the value of the i'th number.
Output
Print n integers corresponding to the sequence b1, b2, ..., bn. It's guaranteed that the answer is unique and fits in 32-bit integer type.
Examples
Input
5
6 -4 8 -2 3
Output
2 4 6 1 3
Input
5
3 -2 -1 5 6
Output
1 -3 4 11 6
Note
In the first sample test, the crows report the numbers 6, - 4, 8, - 2, and 3 when he starts at indices 1, 2, 3, 4 and 5 respectively. It is easy to check that the sequence 2 4 6 1 3 satisfies the reports. For example, 6 = 2 - 4 + 6 - 1 + 3, and - 4 = 4 - 6 + 1 - 3.
In the second sample test, the sequence 1, - 3, 4, 11, 6 satisfies the reports. For example, 5 = 11 - 6 and 6 = 6. | instruction | 0 | 64,467 | 20 | 128,934 |
Tags: implementation, math
Correct Solution:
```
def main():
n = int(input())
a = [int(_) for _ in input().split()]
b = ['0'] * n
b[n - 1] = str(a[n - 1])
for i in range(n - 2, -1, -1):
b[i] = str(a[i] + a[i + 1])
print(' '.join(b))
if __name__ == '__main__':
main()
``` | output | 1 | 64,467 | 20 | 128,935 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n integers b1, b2, ..., bn written in a row. For all i from 1 to n, values ai are defined by the crows performing the following procedure:
* The crow sets ai initially 0.
* The crow then adds bi to ai, subtracts bi + 1, adds the bi + 2 number, and so on until the n'th number. Thus, ai = bi - bi + 1 + bi + 2 - bi + 3....
Memory gives you the values a1, a2, ..., an, and he now wants you to find the initial numbers b1, b2, ..., bn written in the row? Can you do it?
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the number of integers written in the row.
The next line contains n, the i'th of which is ai ( - 109 ≤ ai ≤ 109) — the value of the i'th number.
Output
Print n integers corresponding to the sequence b1, b2, ..., bn. It's guaranteed that the answer is unique and fits in 32-bit integer type.
Examples
Input
5
6 -4 8 -2 3
Output
2 4 6 1 3
Input
5
3 -2 -1 5 6
Output
1 -3 4 11 6
Note
In the first sample test, the crows report the numbers 6, - 4, 8, - 2, and 3 when he starts at indices 1, 2, 3, 4 and 5 respectively. It is easy to check that the sequence 2 4 6 1 3 satisfies the reports. For example, 6 = 2 - 4 + 6 - 1 + 3, and - 4 = 4 - 6 + 1 - 3.
In the second sample test, the sequence 1, - 3, 4, 11, 6 satisfies the reports. For example, 5 = 11 - 6 and 6 = 6. | instruction | 0 | 64,468 | 20 | 128,936 |
Tags: implementation, math
Correct Solution:
```
n=int(input())
s=list(map(int,input().split()))
for i in range(n-1):
s[i]+=s[i+1]
print(*s)
``` | output | 1 | 64,468 | 20 | 128,937 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n integers b1, b2, ..., bn written in a row. For all i from 1 to n, values ai are defined by the crows performing the following procedure:
* The crow sets ai initially 0.
* The crow then adds bi to ai, subtracts bi + 1, adds the bi + 2 number, and so on until the n'th number. Thus, ai = bi - bi + 1 + bi + 2 - bi + 3....
Memory gives you the values a1, a2, ..., an, and he now wants you to find the initial numbers b1, b2, ..., bn written in the row? Can you do it?
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the number of integers written in the row.
The next line contains n, the i'th of which is ai ( - 109 ≤ ai ≤ 109) — the value of the i'th number.
Output
Print n integers corresponding to the sequence b1, b2, ..., bn. It's guaranteed that the answer is unique and fits in 32-bit integer type.
Examples
Input
5
6 -4 8 -2 3
Output
2 4 6 1 3
Input
5
3 -2 -1 5 6
Output
1 -3 4 11 6
Note
In the first sample test, the crows report the numbers 6, - 4, 8, - 2, and 3 when he starts at indices 1, 2, 3, 4 and 5 respectively. It is easy to check that the sequence 2 4 6 1 3 satisfies the reports. For example, 6 = 2 - 4 + 6 - 1 + 3, and - 4 = 4 - 6 + 1 - 3.
In the second sample test, the sequence 1, - 3, 4, 11, 6 satisfies the reports. For example, 5 = 11 - 6 and 6 = 6. | instruction | 0 | 64,469 | 20 | 128,938 |
Tags: implementation, math
Correct Solution:
```
num=int(input())
a=list(map(int,input().split()))
b=[]
for i in range(num):
if i==num-1:
b.append(a[-1])
else:
b.append(a[i]+a[i+1])
for i in b:
print(i,end=' ')
``` | output | 1 | 64,469 | 20 | 128,939 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n integers b1, b2, ..., bn written in a row. For all i from 1 to n, values ai are defined by the crows performing the following procedure:
* The crow sets ai initially 0.
* The crow then adds bi to ai, subtracts bi + 1, adds the bi + 2 number, and so on until the n'th number. Thus, ai = bi - bi + 1 + bi + 2 - bi + 3....
Memory gives you the values a1, a2, ..., an, and he now wants you to find the initial numbers b1, b2, ..., bn written in the row? Can you do it?
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the number of integers written in the row.
The next line contains n, the i'th of which is ai ( - 109 ≤ ai ≤ 109) — the value of the i'th number.
Output
Print n integers corresponding to the sequence b1, b2, ..., bn. It's guaranteed that the answer is unique and fits in 32-bit integer type.
Examples
Input
5
6 -4 8 -2 3
Output
2 4 6 1 3
Input
5
3 -2 -1 5 6
Output
1 -3 4 11 6
Note
In the first sample test, the crows report the numbers 6, - 4, 8, - 2, and 3 when he starts at indices 1, 2, 3, 4 and 5 respectively. It is easy to check that the sequence 2 4 6 1 3 satisfies the reports. For example, 6 = 2 - 4 + 6 - 1 + 3, and - 4 = 4 - 6 + 1 - 3.
In the second sample test, the sequence 1, - 3, 4, 11, 6 satisfies the reports. For example, 5 = 11 - 6 and 6 = 6. | instruction | 0 | 64,470 | 20 | 128,940 |
Tags: implementation, math
Correct Solution:
```
n = int(input())
a = input().split()
for i in range(n-1):
print(int(a[i])+int(a[i+1]), end=' ')
print(a[n-1])
``` | output | 1 | 64,470 | 20 | 128,941 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n integers b1, b2, ..., bn written in a row. For all i from 1 to n, values ai are defined by the crows performing the following procedure:
* The crow sets ai initially 0.
* The crow then adds bi to ai, subtracts bi + 1, adds the bi + 2 number, and so on until the n'th number. Thus, ai = bi - bi + 1 + bi + 2 - bi + 3....
Memory gives you the values a1, a2, ..., an, and he now wants you to find the initial numbers b1, b2, ..., bn written in the row? Can you do it?
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the number of integers written in the row.
The next line contains n, the i'th of which is ai ( - 109 ≤ ai ≤ 109) — the value of the i'th number.
Output
Print n integers corresponding to the sequence b1, b2, ..., bn. It's guaranteed that the answer is unique and fits in 32-bit integer type.
Examples
Input
5
6 -4 8 -2 3
Output
2 4 6 1 3
Input
5
3 -2 -1 5 6
Output
1 -3 4 11 6
Note
In the first sample test, the crows report the numbers 6, - 4, 8, - 2, and 3 when he starts at indices 1, 2, 3, 4 and 5 respectively. It is easy to check that the sequence 2 4 6 1 3 satisfies the reports. For example, 6 = 2 - 4 + 6 - 1 + 3, and - 4 = 4 - 6 + 1 - 3.
In the second sample test, the sequence 1, - 3, 4, 11, 6 satisfies the reports. For example, 5 = 11 - 6 and 6 = 6. | instruction | 0 | 64,471 | 20 | 128,942 |
Tags: implementation, math
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
res=[a[i+1]+a[i] for i in range(n-1)]+[a[n-1]]
print(' '.join(map(str,res)))
``` | output | 1 | 64,471 | 20 | 128,943 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n integers b1, b2, ..., bn written in a row. For all i from 1 to n, values ai are defined by the crows performing the following procedure:
* The crow sets ai initially 0.
* The crow then adds bi to ai, subtracts bi + 1, adds the bi + 2 number, and so on until the n'th number. Thus, ai = bi - bi + 1 + bi + 2 - bi + 3....
Memory gives you the values a1, a2, ..., an, and he now wants you to find the initial numbers b1, b2, ..., bn written in the row? Can you do it?
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the number of integers written in the row.
The next line contains n, the i'th of which is ai ( - 109 ≤ ai ≤ 109) — the value of the i'th number.
Output
Print n integers corresponding to the sequence b1, b2, ..., bn. It's guaranteed that the answer is unique and fits in 32-bit integer type.
Examples
Input
5
6 -4 8 -2 3
Output
2 4 6 1 3
Input
5
3 -2 -1 5 6
Output
1 -3 4 11 6
Note
In the first sample test, the crows report the numbers 6, - 4, 8, - 2, and 3 when he starts at indices 1, 2, 3, 4 and 5 respectively. It is easy to check that the sequence 2 4 6 1 3 satisfies the reports. For example, 6 = 2 - 4 + 6 - 1 + 3, and - 4 = 4 - 6 + 1 - 3.
In the second sample test, the sequence 1, - 3, 4, 11, 6 satisfies the reports. For example, 5 = 11 - 6 and 6 = 6. | instruction | 0 | 64,472 | 20 | 128,944 |
Tags: implementation, math
Correct Solution:
```
n=int(input())
l=[int(e) for e in input().split()]
ch=''
for i in range(1,n):
ch+=str(l[i-1]+l[i])+" "
print(ch+str(l[-1]))
``` | output | 1 | 64,472 | 20 | 128,945 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n integers b1, b2, ..., bn written in a row. For all i from 1 to n, values ai are defined by the crows performing the following procedure:
* The crow sets ai initially 0.
* The crow then adds bi to ai, subtracts bi + 1, adds the bi + 2 number, and so on until the n'th number. Thus, ai = bi - bi + 1 + bi + 2 - bi + 3....
Memory gives you the values a1, a2, ..., an, and he now wants you to find the initial numbers b1, b2, ..., bn written in the row? Can you do it?
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the number of integers written in the row.
The next line contains n, the i'th of which is ai ( - 109 ≤ ai ≤ 109) — the value of the i'th number.
Output
Print n integers corresponding to the sequence b1, b2, ..., bn. It's guaranteed that the answer is unique and fits in 32-bit integer type.
Examples
Input
5
6 -4 8 -2 3
Output
2 4 6 1 3
Input
5
3 -2 -1 5 6
Output
1 -3 4 11 6
Note
In the first sample test, the crows report the numbers 6, - 4, 8, - 2, and 3 when he starts at indices 1, 2, 3, 4 and 5 respectively. It is easy to check that the sequence 2 4 6 1 3 satisfies the reports. For example, 6 = 2 - 4 + 6 - 1 + 3, and - 4 = 4 - 6 + 1 - 3.
In the second sample test, the sequence 1, - 3, 4, 11, 6 satisfies the reports. For example, 5 = 11 - 6 and 6 = 6. | instruction | 0 | 64,473 | 20 | 128,946 |
Tags: implementation, math
Correct Solution:
```
import sys
def main():
n = int(input())
a = list(map(int, input().split(' ')))
a.append(0)
b = list(a[i] + a[i + 1] for i in range(n))
for i in range(n):
print(b[i], end='')
print(' ' if i < n - 1 else '\n', end='')
if __name__ == '__main__':
main()
``` | output | 1 | 64,473 | 20 | 128,947 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an integer x of n digits a_1, a_2, …, a_n, which make up its decimal notation in order from left to right.
Also, you are given a positive integer k < n.
Let's call integer b_1, b_2, …, b_m beautiful if b_i = b_{i+k} for each i, such that 1 ≤ i ≤ m - k.
You need to find the smallest beautiful integer y, such that y ≥ x.
Input
The first line of input contains two integers n, k (2 ≤ n ≤ 200 000, 1 ≤ k < n): the number of digits in x and k.
The next line of input contains n digits a_1, a_2, …, a_n (a_1 ≠ 0, 0 ≤ a_i ≤ 9): digits of x.
Output
In the first line print one integer m: the number of digits in y.
In the next line print m digits b_1, b_2, …, b_m (b_1 ≠ 0, 0 ≤ b_i ≤ 9): digits of y.
Examples
Input
3 2
353
Output
3
353
Input
4 2
1234
Output
4
1313 | instruction | 0 | 64,943 | 20 | 129,886 |
Tags: constructive algorithms, greedy, implementation, strings
Correct Solution:
```
N, K = [int(x) for x in input().split(' ')]
s = input()
def pad(s, n):
return s * (n//len(s)) + s[:n%len(s)]
st = s[:K]
if pad(st, N) >= s:
print(N)
print(pad(st, N))
else:
for i in reversed(range(K)):
if st[i] != '9':
st = st[:i] + chr(ord(st[i]) + 1) + '0' * (K-i-1)
break
print(N)
print(pad(st, N))
``` | output | 1 | 64,943 | 20 | 129,887 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an integer x of n digits a_1, a_2, …, a_n, which make up its decimal notation in order from left to right.
Also, you are given a positive integer k < n.
Let's call integer b_1, b_2, …, b_m beautiful if b_i = b_{i+k} for each i, such that 1 ≤ i ≤ m - k.
You need to find the smallest beautiful integer y, such that y ≥ x.
Input
The first line of input contains two integers n, k (2 ≤ n ≤ 200 000, 1 ≤ k < n): the number of digits in x and k.
The next line of input contains n digits a_1, a_2, …, a_n (a_1 ≠ 0, 0 ≤ a_i ≤ 9): digits of x.
Output
In the first line print one integer m: the number of digits in y.
In the next line print m digits b_1, b_2, …, b_m (b_1 ≠ 0, 0 ≤ b_i ≤ 9): digits of y.
Examples
Input
3 2
353
Output
3
353
Input
4 2
1234
Output
4
1313 | instruction | 0 | 64,944 | 20 | 129,888 |
Tags: constructive algorithms, greedy, implementation, strings
Correct Solution:
```
n,m = map(int,input().split())
A= input()
num = A[:m]
# print(int(num))
for i in range(m,len(A),m):
# print(A[i:i+m])
if num > A[i:i+m]: break
if num < A[i:i+m]:
num = str(int(num)+1)
break
print(n)
print(num * (n // m), end='')
print(num[:(n % m)])
``` | output | 1 | 64,944 | 20 | 129,889 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an integer x of n digits a_1, a_2, …, a_n, which make up its decimal notation in order from left to right.
Also, you are given a positive integer k < n.
Let's call integer b_1, b_2, …, b_m beautiful if b_i = b_{i+k} for each i, such that 1 ≤ i ≤ m - k.
You need to find the smallest beautiful integer y, such that y ≥ x.
Input
The first line of input contains two integers n, k (2 ≤ n ≤ 200 000, 1 ≤ k < n): the number of digits in x and k.
The next line of input contains n digits a_1, a_2, …, a_n (a_1 ≠ 0, 0 ≤ a_i ≤ 9): digits of x.
Output
In the first line print one integer m: the number of digits in y.
In the next line print m digits b_1, b_2, …, b_m (b_1 ≠ 0, 0 ≤ b_i ≤ 9): digits of y.
Examples
Input
3 2
353
Output
3
353
Input
4 2
1234
Output
4
1313 | instruction | 0 | 64,945 | 20 | 129,890 |
Tags: constructive algorithms, greedy, implementation, strings
Correct Solution:
```
# for i in range(int(input())):
import sys
input = lambda : sys.stdin.readline().strip()
n,k = map(int,input().split())
s = input()
ans = ''.join(s[:k])
if int(ans*(n//k)+ans[:n%k])<int(s):
ans=str(int(ans)+1)
print(n)
print(ans*(n//k)+ans[:n%k])
``` | output | 1 | 64,945 | 20 | 129,891 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an integer x of n digits a_1, a_2, …, a_n, which make up its decimal notation in order from left to right.
Also, you are given a positive integer k < n.
Let's call integer b_1, b_2, …, b_m beautiful if b_i = b_{i+k} for each i, such that 1 ≤ i ≤ m - k.
You need to find the smallest beautiful integer y, such that y ≥ x.
Input
The first line of input contains two integers n, k (2 ≤ n ≤ 200 000, 1 ≤ k < n): the number of digits in x and k.
The next line of input contains n digits a_1, a_2, …, a_n (a_1 ≠ 0, 0 ≤ a_i ≤ 9): digits of x.
Output
In the first line print one integer m: the number of digits in y.
In the next line print m digits b_1, b_2, …, b_m (b_1 ≠ 0, 0 ≤ b_i ≤ 9): digits of y.
Examples
Input
3 2
353
Output
3
353
Input
4 2
1234
Output
4
1313 | instruction | 0 | 64,946 | 20 | 129,892 |
Tags: constructive algorithms, greedy, implementation, strings
Correct Solution:
```
n,k = map(int, input().split())
a = input()
ans = []
for i in range(k-1):
ans.append(a[i])
j = 0
ans.append(a[k-1])
lenans = len(ans)
incr = False
for i in range(k, n):
if j == lenans:
j = 0
if ans[j] < a[i]:
incr = True
break
elif ans[j] > a[i]:
break
j += 1
if incr:
increased = chr(ord(a[k-1]) + 1)
ans[-1] = chr(ord(a[k-1]) + 1)
if increased == ':':
i = k-1
ans[i] = '9'
while i >= 0 and ans[i] == '9':
ans[i] = '0'
i -= 1
if i == -1:
ans = ['1'] + ans
else:
ans[i] = chr(ord(ans[i]) + 1)
j = 0
for i in range(k,n):
if j == lenans:
j = 0
ans.append(ans[j])
j += 1
lenans = len(ans)
print(lenans)
print(''.join(ans))
``` | output | 1 | 64,946 | 20 | 129,893 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an integer x of n digits a_1, a_2, …, a_n, which make up its decimal notation in order from left to right.
Also, you are given a positive integer k < n.
Let's call integer b_1, b_2, …, b_m beautiful if b_i = b_{i+k} for each i, such that 1 ≤ i ≤ m - k.
You need to find the smallest beautiful integer y, such that y ≥ x.
Input
The first line of input contains two integers n, k (2 ≤ n ≤ 200 000, 1 ≤ k < n): the number of digits in x and k.
The next line of input contains n digits a_1, a_2, …, a_n (a_1 ≠ 0, 0 ≤ a_i ≤ 9): digits of x.
Output
In the first line print one integer m: the number of digits in y.
In the next line print m digits b_1, b_2, …, b_m (b_1 ≠ 0, 0 ≤ b_i ≤ 9): digits of y.
Examples
Input
3 2
353
Output
3
353
Input
4 2
1234
Output
4
1313 | instruction | 0 | 64,947 | 20 | 129,894 |
Tags: constructive algorithms, greedy, implementation, strings
Correct Solution:
```
#! /usr/bin/env python
# -*- coding: utf-8 -*-
def get():
return (a[:k]*(n//k+1))[:n]
def get2():
return (str(int(a[:k])+1)*(n//k+1))[:n]
n, k = map(int, input().split())
a = input()
print(n)
r1 = get()
if int(r1) >= int(a):
print(r1)
else:
print(get2())
``` | output | 1 | 64,947 | 20 | 129,895 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an integer x of n digits a_1, a_2, …, a_n, which make up its decimal notation in order from left to right.
Also, you are given a positive integer k < n.
Let's call integer b_1, b_2, …, b_m beautiful if b_i = b_{i+k} for each i, such that 1 ≤ i ≤ m - k.
You need to find the smallest beautiful integer y, such that y ≥ x.
Input
The first line of input contains two integers n, k (2 ≤ n ≤ 200 000, 1 ≤ k < n): the number of digits in x and k.
The next line of input contains n digits a_1, a_2, …, a_n (a_1 ≠ 0, 0 ≤ a_i ≤ 9): digits of x.
Output
In the first line print one integer m: the number of digits in y.
In the next line print m digits b_1, b_2, …, b_m (b_1 ≠ 0, 0 ≤ b_i ≤ 9): digits of y.
Examples
Input
3 2
353
Output
3
353
Input
4 2
1234
Output
4
1313 | instruction | 0 | 64,948 | 20 | 129,896 |
Tags: constructive algorithms, greedy, implementation, strings
Correct Solution:
```
n, k = list(map(int, input().split()))
number = list(input())
pre = "".join(number[:k])
unit = pre
cur = 0
while(cur < n):
if cur + k < n:
temp = "".join(number[cur:cur+k])
if temp == pre:
cur += k
continue
elif temp < pre:
break
elif temp > pre:
unit = str(int(pre) + 1)
break
if cur + k >= n:
temp = "".join(number[cur:n])
if temp == "".join(pre[:n-cur]):
cur += k
continue
elif temp < "".join(pre[:n-cur]):
break
elif temp > "".join(pre[:n-cur]):
unit = str(int(pre) + 1)
break
cur += k
print(n)
res = unit * (n // k) + unit[:(n%k)]
print(res)
``` | output | 1 | 64,948 | 20 | 129,897 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an integer x of n digits a_1, a_2, …, a_n, which make up its decimal notation in order from left to right.
Also, you are given a positive integer k < n.
Let's call integer b_1, b_2, …, b_m beautiful if b_i = b_{i+k} for each i, such that 1 ≤ i ≤ m - k.
You need to find the smallest beautiful integer y, such that y ≥ x.
Input
The first line of input contains two integers n, k (2 ≤ n ≤ 200 000, 1 ≤ k < n): the number of digits in x and k.
The next line of input contains n digits a_1, a_2, …, a_n (a_1 ≠ 0, 0 ≤ a_i ≤ 9): digits of x.
Output
In the first line print one integer m: the number of digits in y.
In the next line print m digits b_1, b_2, …, b_m (b_1 ≠ 0, 0 ≤ b_i ≤ 9): digits of y.
Examples
Input
3 2
353
Output
3
353
Input
4 2
1234
Output
4
1313 | instruction | 0 | 64,949 | 20 | 129,898 |
Tags: constructive algorithms, greedy, implementation, strings
Correct Solution:
```
N,K=map(int,input().split())
L=list(input())
S=L.copy()
for i in range(K,N):
S[i]=S[i-K]
if S>=L:
print(N)
print(''.join(S))
else:
for i in range(K-1,-1,-1):
if S[i]!='9':
for i in range(i,N,K):
S[i]=str(int(S[i])+1)
break
else:
for i in range(i,N,K):
S[i]='0'
print(N)
print(''.join(S))
``` | output | 1 | 64,949 | 20 | 129,899 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an integer x of n digits a_1, a_2, …, a_n, which make up its decimal notation in order from left to right.
Also, you are given a positive integer k < n.
Let's call integer b_1, b_2, …, b_m beautiful if b_i = b_{i+k} for each i, such that 1 ≤ i ≤ m - k.
You need to find the smallest beautiful integer y, such that y ≥ x.
Input
The first line of input contains two integers n, k (2 ≤ n ≤ 200 000, 1 ≤ k < n): the number of digits in x and k.
The next line of input contains n digits a_1, a_2, …, a_n (a_1 ≠ 0, 0 ≤ a_i ≤ 9): digits of x.
Output
In the first line print one integer m: the number of digits in y.
In the next line print m digits b_1, b_2, …, b_m (b_1 ≠ 0, 0 ≤ b_i ≤ 9): digits of y.
Examples
Input
3 2
353
Output
3
353
Input
4 2
1234
Output
4
1313 | instruction | 0 | 64,950 | 20 | 129,900 |
Tags: constructive algorithms, greedy, implementation, strings
Correct Solution:
```
n,k=map(int,input().split())
s=list(input())
t=s[:k]
print(n)
for i in range(k-1,-1,-1):
if t[i]!="9":
t[i]=str(int(t[i])+1)
break
else:
t[i]="0"
c=(s[:k]*((n-1)//k+1))[:n]
d=(t*((n-1)//k+1))[:n]
a=0
for i in range(n):
if int(c[i])<int(s[i]):
a=1
break
if int(c[i])>int(s[i]):
a=0
break
r=""
if a:
for i in d:r+=i
print(r)
else:
for i in c:r+=i
print(r)
``` | output | 1 | 64,950 | 20 | 129,901 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer x of n digits a_1, a_2, …, a_n, which make up its decimal notation in order from left to right.
Also, you are given a positive integer k < n.
Let's call integer b_1, b_2, …, b_m beautiful if b_i = b_{i+k} for each i, such that 1 ≤ i ≤ m - k.
You need to find the smallest beautiful integer y, such that y ≥ x.
Input
The first line of input contains two integers n, k (2 ≤ n ≤ 200 000, 1 ≤ k < n): the number of digits in x and k.
The next line of input contains n digits a_1, a_2, …, a_n (a_1 ≠ 0, 0 ≤ a_i ≤ 9): digits of x.
Output
In the first line print one integer m: the number of digits in y.
In the next line print m digits b_1, b_2, …, b_m (b_1 ≠ 0, 0 ≤ b_i ≤ 9): digits of y.
Examples
Input
3 2
353
Output
3
353
Input
4 2
1234
Output
4
1313
Submitted Solution:
```
n, k = map(int, input().split())
s = input()
dx = s[:k]
while len(dx) < n:
dx += dx
dx = dx[:n]
if dx >= s:
print(n)
print(dx)
quit()
fini=-1
for i in range(k):
if s[i] != "9":
fini = i
if fini != -1:
s1 = [int(q) for q in s]
s1[fini] += 1
for i in range(fini+1, k):
s1[i] = 0
s1 = s1[:k]
ans = "".join(str(q) for q in s1)
print(n)
while len(ans) < n:
ans += ans
print(ans[:n])
else:
print(n)
print("9"*n)
``` | instruction | 0 | 64,952 | 20 | 129,904 |
Yes | output | 1 | 64,952 | 20 | 129,905 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer x of n digits a_1, a_2, …, a_n, which make up its decimal notation in order from left to right.
Also, you are given a positive integer k < n.
Let's call integer b_1, b_2, …, b_m beautiful if b_i = b_{i+k} for each i, such that 1 ≤ i ≤ m - k.
You need to find the smallest beautiful integer y, such that y ≥ x.
Input
The first line of input contains two integers n, k (2 ≤ n ≤ 200 000, 1 ≤ k < n): the number of digits in x and k.
The next line of input contains n digits a_1, a_2, …, a_n (a_1 ≠ 0, 0 ≤ a_i ≤ 9): digits of x.
Output
In the first line print one integer m: the number of digits in y.
In the next line print m digits b_1, b_2, …, b_m (b_1 ≠ 0, 0 ≤ b_i ≤ 9): digits of y.
Examples
Input
3 2
353
Output
3
353
Input
4 2
1234
Output
4
1313
Submitted Solution:
```
# @author
import sys
class CLongBeautifulInteger:
def solve(self):
def check_blocks(s, k):
for i in range(k, len(s), k):
v = len(s[i:i + k])
if int(s[:v]) < int(s[i:i + k]):
return False
if int(s[:v]) > int(s[i:i + k]):
return True
return True
def add_one(s):
return str(int(s) + 1)
n, k = [int(_) for _ in input().split()]
s = input().strip()
base = s[:k]
if check_blocks(s, k):
print((n // k) * k + n % k)
print(base * (n // k) + base[:n % k])
else:
base1 = add_one(base)
k1 = len(base1)
print(k1 * (n // k1) + n % k1)
print(base1 * (n // k1) + base1[:n % k1])
solver = CLongBeautifulInteger()
input = sys.stdin.readline
solver.solve()
``` | instruction | 0 | 64,954 | 20 | 129,908 |
Yes | output | 1 | 64,954 | 20 | 129,909 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer x of n digits a_1, a_2, …, a_n, which make up its decimal notation in order from left to right.
Also, you are given a positive integer k < n.
Let's call integer b_1, b_2, …, b_m beautiful if b_i = b_{i+k} for each i, such that 1 ≤ i ≤ m - k.
You need to find the smallest beautiful integer y, such that y ≥ x.
Input
The first line of input contains two integers n, k (2 ≤ n ≤ 200 000, 1 ≤ k < n): the number of digits in x and k.
The next line of input contains n digits a_1, a_2, …, a_n (a_1 ≠ 0, 0 ≤ a_i ≤ 9): digits of x.
Output
In the first line print one integer m: the number of digits in y.
In the next line print m digits b_1, b_2, …, b_m (b_1 ≠ 0, 0 ≤ b_i ≤ 9): digits of y.
Examples
Input
3 2
353
Output
3
353
Input
4 2
1234
Output
4
1313
Submitted Solution:
```
n,k=map(int,input().split())
x=list(input())
ans=['0']*n
print(n)
for i in range(k):
ans[i]=x[i]
j=i+k
while j < n:
ans[j]=ans[j-k]
j+=k
good=True
for i in range(n):
if ans[i]>x[i]:
break
elif ans[i]<x[i]:
good=False
break
if good:
print(''.join(ans))
exit(0)
for i in range(k-1,-1,-1):
if ans[k] != '9':
ans[k] = chr(ord(ans[k])+1)
for j in range(i+1,k):
if ans[j] == '9':
ans[j] = '0'
break
for i in range(k):
j=i+k
while j<n:
ans[j]=ans[j-k]
j+=k
print(''.join(ans))
``` | instruction | 0 | 64,956 | 20 | 129,912 |
No | output | 1 | 64,956 | 20 | 129,913 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Luba learned about a special kind of numbers that she calls beautiful numbers. The number is called beautiful iff its binary representation consists of k + 1 consecutive ones, and then k consecutive zeroes.
Some examples of beautiful numbers:
* 12 (110);
* 1102 (610);
* 11110002 (12010);
* 1111100002 (49610).
More formally, the number is beautiful iff there exists some positive integer k such that the number is equal to (2k - 1) * (2k - 1).
Luba has got an integer number n, and she wants to find its greatest beautiful divisor. Help her to find it!
Input
The only line of input contains one number n (1 ≤ n ≤ 105) — the number Luba has got.
Output
Output one number — the greatest beautiful divisor of Luba's number. It is obvious that the answer always exists.
Examples
Input
3
Output
1
Input
992
Output
496 | instruction | 0 | 65,364 | 20 | 130,728 |
Tags: brute force, implementation
Correct Solution:
```
import sys
import math
N = int(next(sys.stdin))
beautiful = [1]
k = 1
b = 1
while b < N:
k += 1
b = (math.pow(2, k) - 1) * math.pow(2, k -1)
beautiful.append(b)
for b in beautiful[::-1]:
if N % b == 0:
print("{:g}".format(b))
sys.exit()
``` | output | 1 | 65,364 | 20 | 130,729 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Luba learned about a special kind of numbers that she calls beautiful numbers. The number is called beautiful iff its binary representation consists of k + 1 consecutive ones, and then k consecutive zeroes.
Some examples of beautiful numbers:
* 12 (110);
* 1102 (610);
* 11110002 (12010);
* 1111100002 (49610).
More formally, the number is beautiful iff there exists some positive integer k such that the number is equal to (2k - 1) * (2k - 1).
Luba has got an integer number n, and she wants to find its greatest beautiful divisor. Help her to find it!
Input
The only line of input contains one number n (1 ≤ n ≤ 105) — the number Luba has got.
Output
Output one number — the greatest beautiful divisor of Luba's number. It is obvious that the answer always exists.
Examples
Input
3
Output
1
Input
992
Output
496 | instruction | 0 | 65,365 | 20 | 130,730 |
Tags: brute force, implementation
Correct Solution:
```
n = int(input())
pow2 = [2 ** i for i in range(31)]
for i in range(30, 0, -1):
if n % ((pow2[i] - 1) * pow2[i - 1]) == 0:
print((pow2[i] - 1) * pow2[i - 1])
exit()
``` | output | 1 | 65,365 | 20 | 130,731 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Luba learned about a special kind of numbers that she calls beautiful numbers. The number is called beautiful iff its binary representation consists of k + 1 consecutive ones, and then k consecutive zeroes.
Some examples of beautiful numbers:
* 12 (110);
* 1102 (610);
* 11110002 (12010);
* 1111100002 (49610).
More formally, the number is beautiful iff there exists some positive integer k such that the number is equal to (2k - 1) * (2k - 1).
Luba has got an integer number n, and she wants to find its greatest beautiful divisor. Help her to find it!
Input
The only line of input contains one number n (1 ≤ n ≤ 105) — the number Luba has got.
Output
Output one number — the greatest beautiful divisor of Luba's number. It is obvious that the answer always exists.
Examples
Input
3
Output
1
Input
992
Output
496 | instruction | 0 | 65,366 | 20 | 130,732 |
Tags: brute force, implementation
Correct Solution:
```
a=[1,6,28,120,496,2016,8128,32640]
b=int(input())
for i in range(0,8):
if b%a[i]==0:
c=a[i]
print(str(c))
``` | output | 1 | 65,366 | 20 | 130,733 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Luba learned about a special kind of numbers that she calls beautiful numbers. The number is called beautiful iff its binary representation consists of k + 1 consecutive ones, and then k consecutive zeroes.
Some examples of beautiful numbers:
* 12 (110);
* 1102 (610);
* 11110002 (12010);
* 1111100002 (49610).
More formally, the number is beautiful iff there exists some positive integer k such that the number is equal to (2k - 1) * (2k - 1).
Luba has got an integer number n, and she wants to find its greatest beautiful divisor. Help her to find it!
Input
The only line of input contains one number n (1 ≤ n ≤ 105) — the number Luba has got.
Output
Output one number — the greatest beautiful divisor of Luba's number. It is obvious that the answer always exists.
Examples
Input
3
Output
1
Input
992
Output
496 | instruction | 0 | 65,367 | 20 | 130,734 |
Tags: brute force, implementation
Correct Solution:
```
f = lambda k : (2**k - 1)*(2**(k-1))
n = int(input())
c = 1
k = 1
while f(k)<=n:
if(n%f(k) == 0):
c = f(k)
k+=1
print(c)
``` | output | 1 | 65,367 | 20 | 130,735 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Luba learned about a special kind of numbers that she calls beautiful numbers. The number is called beautiful iff its binary representation consists of k + 1 consecutive ones, and then k consecutive zeroes.
Some examples of beautiful numbers:
* 12 (110);
* 1102 (610);
* 11110002 (12010);
* 1111100002 (49610).
More formally, the number is beautiful iff there exists some positive integer k such that the number is equal to (2k - 1) * (2k - 1).
Luba has got an integer number n, and she wants to find its greatest beautiful divisor. Help her to find it!
Input
The only line of input contains one number n (1 ≤ n ≤ 105) — the number Luba has got.
Output
Output one number — the greatest beautiful divisor of Luba's number. It is obvious that the answer always exists.
Examples
Input
3
Output
1
Input
992
Output
496 | instruction | 0 | 65,368 | 20 | 130,736 |
Tags: brute force, implementation
Correct Solution:
```
n = int(input())
c = 1
good = 1
while c<=n:
if n%c==0: good = c
c = int('1' + bin(c)[2:] + '0',2)
print(good)
``` | output | 1 | 65,368 | 20 | 130,737 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Luba learned about a special kind of numbers that she calls beautiful numbers. The number is called beautiful iff its binary representation consists of k + 1 consecutive ones, and then k consecutive zeroes.
Some examples of beautiful numbers:
* 12 (110);
* 1102 (610);
* 11110002 (12010);
* 1111100002 (49610).
More formally, the number is beautiful iff there exists some positive integer k such that the number is equal to (2k - 1) * (2k - 1).
Luba has got an integer number n, and she wants to find its greatest beautiful divisor. Help her to find it!
Input
The only line of input contains one number n (1 ≤ n ≤ 105) — the number Luba has got.
Output
Output one number — the greatest beautiful divisor of Luba's number. It is obvious that the answer always exists.
Examples
Input
3
Output
1
Input
992
Output
496 | instruction | 0 | 65,369 | 20 | 130,738 |
Tags: brute force, implementation
Correct Solution:
```
l=[0]*10**5
for i in range(1,100):
l[i]=(2**i-1)*2**(i-1)
n=int(input())
ans=0
for i in range(1,100):
if n%l[i]==0:
ans=l[i]
print(ans)
``` | output | 1 | 65,369 | 20 | 130,739 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Luba learned about a special kind of numbers that she calls beautiful numbers. The number is called beautiful iff its binary representation consists of k + 1 consecutive ones, and then k consecutive zeroes.
Some examples of beautiful numbers:
* 12 (110);
* 1102 (610);
* 11110002 (12010);
* 1111100002 (49610).
More formally, the number is beautiful iff there exists some positive integer k such that the number is equal to (2k - 1) * (2k - 1).
Luba has got an integer number n, and she wants to find its greatest beautiful divisor. Help her to find it!
Input
The only line of input contains one number n (1 ≤ n ≤ 105) — the number Luba has got.
Output
Output one number — the greatest beautiful divisor of Luba's number. It is obvious that the answer always exists.
Examples
Input
3
Output
1
Input
992
Output
496 | instruction | 0 | 65,370 | 20 | 130,740 |
Tags: brute force, implementation
Correct Solution:
```
def check(x):
for k in range(17):
if x == (2 ** k - 1) * (2 ** (k - 1)):
return True
return False
n = int(input())
ans = 0
for i in range(1, n + 1):
if n % i == 0 and check(i):
ans = max(ans, i)
print(ans)
``` | output | 1 | 65,370 | 20 | 130,741 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Luba learned about a special kind of numbers that she calls beautiful numbers. The number is called beautiful iff its binary representation consists of k + 1 consecutive ones, and then k consecutive zeroes.
Some examples of beautiful numbers:
* 12 (110);
* 1102 (610);
* 11110002 (12010);
* 1111100002 (49610).
More formally, the number is beautiful iff there exists some positive integer k such that the number is equal to (2k - 1) * (2k - 1).
Luba has got an integer number n, and she wants to find its greatest beautiful divisor. Help her to find it!
Input
The only line of input contains one number n (1 ≤ n ≤ 105) — the number Luba has got.
Output
Output one number — the greatest beautiful divisor of Luba's number. It is obvious that the answer always exists.
Examples
Input
3
Output
1
Input
992
Output
496 | instruction | 0 | 65,371 | 20 | 130,742 |
Tags: brute force, implementation
Correct Solution:
```
n=int(input())
maxc=int(0)
for i in range(1,n+1):
vv=(2 ** i - 1)*(2 **(i-1))
if (vv>n) :
break
if n % vv ==0 :
if vv>maxc :
maxc=vv
print(maxc)
``` | output | 1 | 65,371 | 20 | 130,743 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Luba learned about a special kind of numbers that she calls beautiful numbers. The number is called beautiful iff its binary representation consists of k + 1 consecutive ones, and then k consecutive zeroes.
Some examples of beautiful numbers:
* 12 (110);
* 1102 (610);
* 11110002 (12010);
* 1111100002 (49610).
More formally, the number is beautiful iff there exists some positive integer k such that the number is equal to (2k - 1) * (2k - 1).
Luba has got an integer number n, and she wants to find its greatest beautiful divisor. Help her to find it!
Input
The only line of input contains one number n (1 ≤ n ≤ 105) — the number Luba has got.
Output
Output one number — the greatest beautiful divisor of Luba's number. It is obvious that the answer always exists.
Examples
Input
3
Output
1
Input
992
Output
496
Submitted Solution:
```
a = int(input())
if a % 32640 is 0:
print(32640)
elif a % 8128 is 0:
print(8128)
elif a % 2016 is 0:
print(2016)
elif a % 496 is 0:
print(496)
elif a % 120 is 0:
print(120)
elif a % 28 is 0:
print(28)
elif a % 6 is 0:
print(6)
else:
print(1)
``` | instruction | 0 | 65,372 | 20 | 130,744 |
Yes | output | 1 | 65,372 | 20 | 130,745 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Luba learned about a special kind of numbers that she calls beautiful numbers. The number is called beautiful iff its binary representation consists of k + 1 consecutive ones, and then k consecutive zeroes.
Some examples of beautiful numbers:
* 12 (110);
* 1102 (610);
* 11110002 (12010);
* 1111100002 (49610).
More formally, the number is beautiful iff there exists some positive integer k such that the number is equal to (2k - 1) * (2k - 1).
Luba has got an integer number n, and she wants to find its greatest beautiful divisor. Help her to find it!
Input
The only line of input contains one number n (1 ≤ n ≤ 105) — the number Luba has got.
Output
Output one number — the greatest beautiful divisor of Luba's number. It is obvious that the answer always exists.
Examples
Input
3
Output
1
Input
992
Output
496
Submitted Solution:
```
n = int(input())
l = []
k = 1
while int('1' * k + '0' * (k - 1), 2) <= n:
l.append(int('1' * k + '0' * (k - 1), 2))
k += 1
for i in range(len(l)):
if n % l[-(i + 1)] == 0:
print(l[-(i + 1)])
exit()
``` | instruction | 0 | 65,373 | 20 | 130,746 |
Yes | output | 1 | 65,373 | 20 | 130,747 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Luba learned about a special kind of numbers that she calls beautiful numbers. The number is called beautiful iff its binary representation consists of k + 1 consecutive ones, and then k consecutive zeroes.
Some examples of beautiful numbers:
* 12 (110);
* 1102 (610);
* 11110002 (12010);
* 1111100002 (49610).
More formally, the number is beautiful iff there exists some positive integer k such that the number is equal to (2k - 1) * (2k - 1).
Luba has got an integer number n, and she wants to find its greatest beautiful divisor. Help her to find it!
Input
The only line of input contains one number n (1 ≤ n ≤ 105) — the number Luba has got.
Output
Output one number — the greatest beautiful divisor of Luba's number. It is obvious that the answer always exists.
Examples
Input
3
Output
1
Input
992
Output
496
Submitted Solution:
```
n = int(input())
l=[1,6,28,120,496,2016,8128,32640]
l.sort(reverse = True)
for i in l:
if n%i==0:
print(i)
break
``` | instruction | 0 | 65,374 | 20 | 130,748 |
Yes | output | 1 | 65,374 | 20 | 130,749 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Luba learned about a special kind of numbers that she calls beautiful numbers. The number is called beautiful iff its binary representation consists of k + 1 consecutive ones, and then k consecutive zeroes.
Some examples of beautiful numbers:
* 12 (110);
* 1102 (610);
* 11110002 (12010);
* 1111100002 (49610).
More formally, the number is beautiful iff there exists some positive integer k such that the number is equal to (2k - 1) * (2k - 1).
Luba has got an integer number n, and she wants to find its greatest beautiful divisor. Help her to find it!
Input
The only line of input contains one number n (1 ≤ n ≤ 105) — the number Luba has got.
Output
Output one number — the greatest beautiful divisor of Luba's number. It is obvious that the answer always exists.
Examples
Input
3
Output
1
Input
992
Output
496
Submitted Solution:
```
def beautiful_number(former_beautifulnumber,k):
return 4*former_beautifulnumber+2**k
num=int(input())
beautiful_no=1
k=1
less_beautiful=[]
while beautiful_no<=num:
former_beautiful=beautiful_no
beautiful_no=beautiful_number(beautiful_no,k)
k+=1
less_beautiful.append(former_beautiful)
for i in range(len(less_beautiful)-1,-1,-1):
if num%less_beautiful[i]==0:
print(less_beautiful[i])
break
``` | instruction | 0 | 65,375 | 20 | 130,750 |
Yes | output | 1 | 65,375 | 20 | 130,751 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Luba learned about a special kind of numbers that she calls beautiful numbers. The number is called beautiful iff its binary representation consists of k + 1 consecutive ones, and then k consecutive zeroes.
Some examples of beautiful numbers:
* 12 (110);
* 1102 (610);
* 11110002 (12010);
* 1111100002 (49610).
More formally, the number is beautiful iff there exists some positive integer k such that the number is equal to (2k - 1) * (2k - 1).
Luba has got an integer number n, and she wants to find its greatest beautiful divisor. Help her to find it!
Input
The only line of input contains one number n (1 ≤ n ≤ 105) — the number Luba has got.
Output
Output one number — the greatest beautiful divisor of Luba's number. It is obvious that the answer always exists.
Examples
Input
3
Output
1
Input
992
Output
496
Submitted Solution:
```
n = int(input())
l = []
k = 1
while int('1' * k + '0' * (k - 1), 2) <= n // 2:
l.append(int('1' * k + '0' * (k - 1), 2))
k += 1
for i in range(len(l)):
if n % l[-i] == 0:
print(l[-1])
exit()
``` | instruction | 0 | 65,376 | 20 | 130,752 |
No | output | 1 | 65,376 | 20 | 130,753 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Luba learned about a special kind of numbers that she calls beautiful numbers. The number is called beautiful iff its binary representation consists of k + 1 consecutive ones, and then k consecutive zeroes.
Some examples of beautiful numbers:
* 12 (110);
* 1102 (610);
* 11110002 (12010);
* 1111100002 (49610).
More formally, the number is beautiful iff there exists some positive integer k such that the number is equal to (2k - 1) * (2k - 1).
Luba has got an integer number n, and she wants to find its greatest beautiful divisor. Help her to find it!
Input
The only line of input contains one number n (1 ≤ n ≤ 105) — the number Luba has got.
Output
Output one number — the greatest beautiful divisor of Luba's number. It is obvious that the answer always exists.
Examples
Input
3
Output
1
Input
992
Output
496
Submitted Solution:
```
mx=[]
num=int(input())
ix=num//2
for i in range(ix,0,-1):
if(num%i==0):
x=bin(i)
strx=x[2:]
count1,count0=0,0
for j in strx:
if(j=='0'):
count0=count0+1
else:
count1=count1+1
if((count1-count0)==1):
mx.append(i)
print(mx[0])
``` | instruction | 0 | 65,377 | 20 | 130,754 |
No | output | 1 | 65,377 | 20 | 130,755 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Luba learned about a special kind of numbers that she calls beautiful numbers. The number is called beautiful iff its binary representation consists of k + 1 consecutive ones, and then k consecutive zeroes.
Some examples of beautiful numbers:
* 12 (110);
* 1102 (610);
* 11110002 (12010);
* 1111100002 (49610).
More formally, the number is beautiful iff there exists some positive integer k such that the number is equal to (2k - 1) * (2k - 1).
Luba has got an integer number n, and she wants to find its greatest beautiful divisor. Help her to find it!
Input
The only line of input contains one number n (1 ≤ n ≤ 105) — the number Luba has got.
Output
Output one number — the greatest beautiful divisor of Luba's number. It is obvious that the answer always exists.
Examples
Input
3
Output
1
Input
992
Output
496
Submitted Solution:
```
def check(w):
w = bin(w)
w = w.split('b')[1]
w = str(w)
lens=len(w)
s=0
n=0
#print(w)
for x in range(0,lens):
if w[x]=='1':
s+=1
else:
n+=1
if x!=lens-1 and w[x]=='0' and w[x+1]=='1':
return False
#print(s)
#print(n)
if s-n==1:
return True
else:
return False
#print(check(19230))
while True:
try:
n = int(input())
flag=0
for x in range(n-1,0,-1):
#print(x)
if n%x==0:
#print(n)
#print(x)
if(check(x)):
flag=x
break
print(flag)
except EOFError:
break
``` | instruction | 0 | 65,378 | 20 | 130,756 |
No | output | 1 | 65,378 | 20 | 130,757 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Luba learned about a special kind of numbers that she calls beautiful numbers. The number is called beautiful iff its binary representation consists of k + 1 consecutive ones, and then k consecutive zeroes.
Some examples of beautiful numbers:
* 12 (110);
* 1102 (610);
* 11110002 (12010);
* 1111100002 (49610).
More formally, the number is beautiful iff there exists some positive integer k such that the number is equal to (2k - 1) * (2k - 1).
Luba has got an integer number n, and she wants to find its greatest beautiful divisor. Help her to find it!
Input
The only line of input contains one number n (1 ≤ n ≤ 105) — the number Luba has got.
Output
Output one number — the greatest beautiful divisor of Luba's number. It is obvious that the answer always exists.
Examples
Input
3
Output
1
Input
992
Output
496
Submitted Solution:
```
n = int(input())
a = 0
while n%2 == 0:
a += 1
n //= 2
b = 0
while n > 0:
b += 1
n //= 2
k = 1
for i in range(b, 0, -1):
if b%i == 0 and i <= a:
k = i
break
print((2**k - 1) * 2**(k-1))
``` | instruction | 0 | 65,379 | 20 | 130,758 |
No | output | 1 | 65,379 | 20 | 130,759 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Astronaut Natasha arrived on Mars. She knows that the Martians are very poor aliens. To ensure a better life for the Mars citizens, their emperor decided to take tax from every tourist who visited the planet. Natasha is the inhabitant of Earth, therefore she had to pay the tax to enter the territory of Mars.
There are n banknote denominations on Mars: the value of i-th banknote is a_i. Natasha has an infinite number of banknotes of each denomination.
Martians have k fingers on their hands, so they use a number system with base k. In addition, the Martians consider the digit d (in the number system with base k) divine. Thus, if the last digit in Natasha's tax amount written in the number system with the base k is d, the Martians will be happy. Unfortunately, Natasha does not know the Martians' divine digit yet.
Determine for which values d Natasha can make the Martians happy.
Natasha can use only her banknotes. Martians don't give her change.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100 000, 2 ≤ k ≤ 100 000) — the number of denominations of banknotes and the base of the number system on Mars.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — denominations of banknotes on Mars.
All numbers are given in decimal notation.
Output
On the first line output the number of values d for which Natasha can make the Martians happy.
In the second line, output all these values in increasing order.
Print all numbers in decimal notation.
Examples
Input
2 8
12 20
Output
2
0 4
Input
3 10
10 20 30
Output
1
0
Note
Consider the first test case. It uses the octal number system.
If you take one banknote with the value of 12, you will get 14_8 in octal system. The last digit is 4_8.
If you take one banknote with the value of 12 and one banknote with the value of 20, the total value will be 32. In the octal system, it is 40_8. The last digit is 0_8.
If you take two banknotes with the value of 20, the total value will be 40, this is 50_8 in the octal system. The last digit is 0_8.
No other digits other than 0_8 and 4_8 can be obtained. Digits 0_8 and 4_8 could also be obtained in other ways.
The second test case uses the decimal number system. The nominals of all banknotes end with zero, so Natasha can give the Martians only the amount whose decimal notation also ends with zero. | instruction | 0 | 65,610 | 20 | 131,220 |
Tags: number theory
Correct Solution:
```
def gcd(a,b):
if b == 0:
return a
if b > a:
return gcd(b,a)
return gcd(b,a%b)
n,k = list(map(int,input().split()))
l = list(map(int,input().split()))
out = k
for i in l:
out = gcd(i,out)
print(k//out)
print(' '.join(list(map(str,range(0,k,out)))))
``` | output | 1 | 65,610 | 20 | 131,221 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Astronaut Natasha arrived on Mars. She knows that the Martians are very poor aliens. To ensure a better life for the Mars citizens, their emperor decided to take tax from every tourist who visited the planet. Natasha is the inhabitant of Earth, therefore she had to pay the tax to enter the territory of Mars.
There are n banknote denominations on Mars: the value of i-th banknote is a_i. Natasha has an infinite number of banknotes of each denomination.
Martians have k fingers on their hands, so they use a number system with base k. In addition, the Martians consider the digit d (in the number system with base k) divine. Thus, if the last digit in Natasha's tax amount written in the number system with the base k is d, the Martians will be happy. Unfortunately, Natasha does not know the Martians' divine digit yet.
Determine for which values d Natasha can make the Martians happy.
Natasha can use only her banknotes. Martians don't give her change.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100 000, 2 ≤ k ≤ 100 000) — the number of denominations of banknotes and the base of the number system on Mars.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — denominations of banknotes on Mars.
All numbers are given in decimal notation.
Output
On the first line output the number of values d for which Natasha can make the Martians happy.
In the second line, output all these values in increasing order.
Print all numbers in decimal notation.
Examples
Input
2 8
12 20
Output
2
0 4
Input
3 10
10 20 30
Output
1
0
Note
Consider the first test case. It uses the octal number system.
If you take one banknote with the value of 12, you will get 14_8 in octal system. The last digit is 4_8.
If you take one banknote with the value of 12 and one banknote with the value of 20, the total value will be 32. In the octal system, it is 40_8. The last digit is 0_8.
If you take two banknotes with the value of 20, the total value will be 40, this is 50_8 in the octal system. The last digit is 0_8.
No other digits other than 0_8 and 4_8 can be obtained. Digits 0_8 and 4_8 could also be obtained in other ways.
The second test case uses the decimal number system. The nominals of all banknotes end with zero, so Natasha can give the Martians only the amount whose decimal notation also ends with zero. | instruction | 0 | 65,611 | 20 | 131,222 |
Tags: number theory
Correct Solution:
```
from bisect import bisect
from collections import defaultdict
# l = list(map(int,input().split()))
# map(int,input().split()))
from math import gcd,sqrt,ceil,inf
from collections import Counter
import sys
sys.setrecursionlimit(1000000)
from bisect import bisect
from collections import defaultdict
# l = list(map(int,input().split()))
# map(int,input().split()))
from math import gcd,sqrt,ceil,inf,factorial,log2
from collections import Counter
import sys
sys.setrecursionlimit(10**9)
n,k = map(int,input().split())
l = list(map(int,input().split()))
g = 0
for i in l:
g = gcd(i,g)
seti = set()
for i in range(k+1):
ka = (g*i)%k
seti.add(ka)
print(len(seti))
for i in sorted(seti):
print(i,end= ' ')
``` | output | 1 | 65,611 | 20 | 131,223 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Astronaut Natasha arrived on Mars. She knows that the Martians are very poor aliens. To ensure a better life for the Mars citizens, their emperor decided to take tax from every tourist who visited the planet. Natasha is the inhabitant of Earth, therefore she had to pay the tax to enter the territory of Mars.
There are n banknote denominations on Mars: the value of i-th banknote is a_i. Natasha has an infinite number of banknotes of each denomination.
Martians have k fingers on their hands, so they use a number system with base k. In addition, the Martians consider the digit d (in the number system with base k) divine. Thus, if the last digit in Natasha's tax amount written in the number system with the base k is d, the Martians will be happy. Unfortunately, Natasha does not know the Martians' divine digit yet.
Determine for which values d Natasha can make the Martians happy.
Natasha can use only her banknotes. Martians don't give her change.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100 000, 2 ≤ k ≤ 100 000) — the number of denominations of banknotes and the base of the number system on Mars.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — denominations of banknotes on Mars.
All numbers are given in decimal notation.
Output
On the first line output the number of values d for which Natasha can make the Martians happy.
In the second line, output all these values in increasing order.
Print all numbers in decimal notation.
Examples
Input
2 8
12 20
Output
2
0 4
Input
3 10
10 20 30
Output
1
0
Note
Consider the first test case. It uses the octal number system.
If you take one banknote with the value of 12, you will get 14_8 in octal system. The last digit is 4_8.
If you take one banknote with the value of 12 and one banknote with the value of 20, the total value will be 32. In the octal system, it is 40_8. The last digit is 0_8.
If you take two banknotes with the value of 20, the total value will be 40, this is 50_8 in the octal system. The last digit is 0_8.
No other digits other than 0_8 and 4_8 can be obtained. Digits 0_8 and 4_8 could also be obtained in other ways.
The second test case uses the decimal number system. The nominals of all banknotes end with zero, so Natasha can give the Martians only the amount whose decimal notation also ends with zero. | instruction | 0 | 65,612 | 20 | 131,224 |
Tags: number theory
Correct Solution:
```
n,k=map(int,input().split())
#the number of denominations of banknotes and the base of the number system on Mars.
B=list(map(int,input().split()))
#denominations of banknotes on Mars.
def gcd(a, b):
while b:
a, b = b, a % b
return a
allgcd=k
for i in range(n):
allgcd=gcd(allgcd,B[i])
x=k//allgcd
print(x)
ANS=[None]*x
for i in range(x):
ANS[i]=allgcd*i
for i in range(x-1):
print(ANS[i],end=" ")
print(ANS[x-1])
``` | output | 1 | 65,612 | 20 | 131,225 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Astronaut Natasha arrived on Mars. She knows that the Martians are very poor aliens. To ensure a better life for the Mars citizens, their emperor decided to take tax from every tourist who visited the planet. Natasha is the inhabitant of Earth, therefore she had to pay the tax to enter the territory of Mars.
There are n banknote denominations on Mars: the value of i-th banknote is a_i. Natasha has an infinite number of banknotes of each denomination.
Martians have k fingers on their hands, so they use a number system with base k. In addition, the Martians consider the digit d (in the number system with base k) divine. Thus, if the last digit in Natasha's tax amount written in the number system with the base k is d, the Martians will be happy. Unfortunately, Natasha does not know the Martians' divine digit yet.
Determine for which values d Natasha can make the Martians happy.
Natasha can use only her banknotes. Martians don't give her change.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100 000, 2 ≤ k ≤ 100 000) — the number of denominations of banknotes and the base of the number system on Mars.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — denominations of banknotes on Mars.
All numbers are given in decimal notation.
Output
On the first line output the number of values d for which Natasha can make the Martians happy.
In the second line, output all these values in increasing order.
Print all numbers in decimal notation.
Examples
Input
2 8
12 20
Output
2
0 4
Input
3 10
10 20 30
Output
1
0
Note
Consider the first test case. It uses the octal number system.
If you take one banknote with the value of 12, you will get 14_8 in octal system. The last digit is 4_8.
If you take one banknote with the value of 12 and one banknote with the value of 20, the total value will be 32. In the octal system, it is 40_8. The last digit is 0_8.
If you take two banknotes with the value of 20, the total value will be 40, this is 50_8 in the octal system. The last digit is 0_8.
No other digits other than 0_8 and 4_8 can be obtained. Digits 0_8 and 4_8 could also be obtained in other ways.
The second test case uses the decimal number system. The nominals of all banknotes end with zero, so Natasha can give the Martians only the amount whose decimal notation also ends with zero. | instruction | 0 | 65,613 | 20 | 131,226 |
Tags: number theory
Correct Solution:
```
from functools import reduce
from math import gcd
n, k = map(int, input().split())
A = list(map(int, input().split()))
G = gcd(k, reduce(lambda x,y:gcd(x,y),A))
print(k // G)
print(*list(range(0, k, G)))
``` | output | 1 | 65,613 | 20 | 131,227 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Astronaut Natasha arrived on Mars. She knows that the Martians are very poor aliens. To ensure a better life for the Mars citizens, their emperor decided to take tax from every tourist who visited the planet. Natasha is the inhabitant of Earth, therefore she had to pay the tax to enter the territory of Mars.
There are n banknote denominations on Mars: the value of i-th banknote is a_i. Natasha has an infinite number of banknotes of each denomination.
Martians have k fingers on their hands, so they use a number system with base k. In addition, the Martians consider the digit d (in the number system with base k) divine. Thus, if the last digit in Natasha's tax amount written in the number system with the base k is d, the Martians will be happy. Unfortunately, Natasha does not know the Martians' divine digit yet.
Determine for which values d Natasha can make the Martians happy.
Natasha can use only her banknotes. Martians don't give her change.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100 000, 2 ≤ k ≤ 100 000) — the number of denominations of banknotes and the base of the number system on Mars.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — denominations of banknotes on Mars.
All numbers are given in decimal notation.
Output
On the first line output the number of values d for which Natasha can make the Martians happy.
In the second line, output all these values in increasing order.
Print all numbers in decimal notation.
Examples
Input
2 8
12 20
Output
2
0 4
Input
3 10
10 20 30
Output
1
0
Note
Consider the first test case. It uses the octal number system.
If you take one banknote with the value of 12, you will get 14_8 in octal system. The last digit is 4_8.
If you take one banknote with the value of 12 and one banknote with the value of 20, the total value will be 32. In the octal system, it is 40_8. The last digit is 0_8.
If you take two banknotes with the value of 20, the total value will be 40, this is 50_8 in the octal system. The last digit is 0_8.
No other digits other than 0_8 and 4_8 can be obtained. Digits 0_8 and 4_8 could also be obtained in other ways.
The second test case uses the decimal number system. The nominals of all banknotes end with zero, so Natasha can give the Martians only the amount whose decimal notation also ends with zero. | instruction | 0 | 65,614 | 20 | 131,228 |
Tags: number theory
Correct Solution:
```
n, k = map(int,input().split())
v = list(map(int,input().split()))
def gcd(a,b):
if a < b:
return gcd(b,a)
if b == 0:
return a
else:
return gcd(b, a%b)
g = v[0]
for i in range(1,n):
g = gcd(g, v[i])
lst = set()
for i in range(k):
lst.add(g*i % k)
lst = sorted(list(lst))
print(len(lst))
print(' '.join(map(str,lst)))
``` | output | 1 | 65,614 | 20 | 131,229 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Astronaut Natasha arrived on Mars. She knows that the Martians are very poor aliens. To ensure a better life for the Mars citizens, their emperor decided to take tax from every tourist who visited the planet. Natasha is the inhabitant of Earth, therefore she had to pay the tax to enter the territory of Mars.
There are n banknote denominations on Mars: the value of i-th banknote is a_i. Natasha has an infinite number of banknotes of each denomination.
Martians have k fingers on their hands, so they use a number system with base k. In addition, the Martians consider the digit d (in the number system with base k) divine. Thus, if the last digit in Natasha's tax amount written in the number system with the base k is d, the Martians will be happy. Unfortunately, Natasha does not know the Martians' divine digit yet.
Determine for which values d Natasha can make the Martians happy.
Natasha can use only her banknotes. Martians don't give her change.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100 000, 2 ≤ k ≤ 100 000) — the number of denominations of banknotes and the base of the number system on Mars.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — denominations of banknotes on Mars.
All numbers are given in decimal notation.
Output
On the first line output the number of values d for which Natasha can make the Martians happy.
In the second line, output all these values in increasing order.
Print all numbers in decimal notation.
Examples
Input
2 8
12 20
Output
2
0 4
Input
3 10
10 20 30
Output
1
0
Note
Consider the first test case. It uses the octal number system.
If you take one banknote with the value of 12, you will get 14_8 in octal system. The last digit is 4_8.
If you take one banknote with the value of 12 and one banknote with the value of 20, the total value will be 32. In the octal system, it is 40_8. The last digit is 0_8.
If you take two banknotes with the value of 20, the total value will be 40, this is 50_8 in the octal system. The last digit is 0_8.
No other digits other than 0_8 and 4_8 can be obtained. Digits 0_8 and 4_8 could also be obtained in other ways.
The second test case uses the decimal number system. The nominals of all banknotes end with zero, so Natasha can give the Martians only the amount whose decimal notation also ends with zero. | instruction | 0 | 65,615 | 20 | 131,230 |
Tags: number theory
Correct Solution:
```
n, k = map(int, input().split(' '))
a = set(map(lambda x: int(x) % k, input().split(' ')))
def gcd(x, y):
if (y == 0):
return x
else:
return gcd (y, x % y)
a = list(a)
a.append(k)
res = a[0]
for i in a[1::]:
res = gcd(res , i)
ans = k//res
print(ans)
out = []
for i in range(ans):
out.append(str(i*res))
print(' '.join(out))
``` | output | 1 | 65,615 | 20 | 131,231 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Astronaut Natasha arrived on Mars. She knows that the Martians are very poor aliens. To ensure a better life for the Mars citizens, their emperor decided to take tax from every tourist who visited the planet. Natasha is the inhabitant of Earth, therefore she had to pay the tax to enter the territory of Mars.
There are n banknote denominations on Mars: the value of i-th banknote is a_i. Natasha has an infinite number of banknotes of each denomination.
Martians have k fingers on their hands, so they use a number system with base k. In addition, the Martians consider the digit d (in the number system with base k) divine. Thus, if the last digit in Natasha's tax amount written in the number system with the base k is d, the Martians will be happy. Unfortunately, Natasha does not know the Martians' divine digit yet.
Determine for which values d Natasha can make the Martians happy.
Natasha can use only her banknotes. Martians don't give her change.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100 000, 2 ≤ k ≤ 100 000) — the number of denominations of banknotes and the base of the number system on Mars.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — denominations of banknotes on Mars.
All numbers are given in decimal notation.
Output
On the first line output the number of values d for which Natasha can make the Martians happy.
In the second line, output all these values in increasing order.
Print all numbers in decimal notation.
Examples
Input
2 8
12 20
Output
2
0 4
Input
3 10
10 20 30
Output
1
0
Note
Consider the first test case. It uses the octal number system.
If you take one banknote with the value of 12, you will get 14_8 in octal system. The last digit is 4_8.
If you take one banknote with the value of 12 and one banknote with the value of 20, the total value will be 32. In the octal system, it is 40_8. The last digit is 0_8.
If you take two banknotes with the value of 20, the total value will be 40, this is 50_8 in the octal system. The last digit is 0_8.
No other digits other than 0_8 and 4_8 can be obtained. Digits 0_8 and 4_8 could also be obtained in other ways.
The second test case uses the decimal number system. The nominals of all banknotes end with zero, so Natasha can give the Martians only the amount whose decimal notation also ends with zero. | instruction | 0 | 65,616 | 20 | 131,232 |
Tags: number theory
Correct Solution:
```
def gcd(a, b):
while b:
a, b = b, a % b
return a
n, k = map(int, input().split())
a = list(set([int(i) % k for i in input().split()]))
res = k
for i in a:
res = gcd(res, i)
print(k // res)
print(*list(range(0, k, res)))
``` | output | 1 | 65,616 | 20 | 131,233 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Astronaut Natasha arrived on Mars. She knows that the Martians are very poor aliens. To ensure a better life for the Mars citizens, their emperor decided to take tax from every tourist who visited the planet. Natasha is the inhabitant of Earth, therefore she had to pay the tax to enter the territory of Mars.
There are n banknote denominations on Mars: the value of i-th banknote is a_i. Natasha has an infinite number of banknotes of each denomination.
Martians have k fingers on their hands, so they use a number system with base k. In addition, the Martians consider the digit d (in the number system with base k) divine. Thus, if the last digit in Natasha's tax amount written in the number system with the base k is d, the Martians will be happy. Unfortunately, Natasha does not know the Martians' divine digit yet.
Determine for which values d Natasha can make the Martians happy.
Natasha can use only her banknotes. Martians don't give her change.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100 000, 2 ≤ k ≤ 100 000) — the number of denominations of banknotes and the base of the number system on Mars.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — denominations of banknotes on Mars.
All numbers are given in decimal notation.
Output
On the first line output the number of values d for which Natasha can make the Martians happy.
In the second line, output all these values in increasing order.
Print all numbers in decimal notation.
Examples
Input
2 8
12 20
Output
2
0 4
Input
3 10
10 20 30
Output
1
0
Note
Consider the first test case. It uses the octal number system.
If you take one banknote with the value of 12, you will get 14_8 in octal system. The last digit is 4_8.
If you take one banknote with the value of 12 and one banknote with the value of 20, the total value will be 32. In the octal system, it is 40_8. The last digit is 0_8.
If you take two banknotes with the value of 20, the total value will be 40, this is 50_8 in the octal system. The last digit is 0_8.
No other digits other than 0_8 and 4_8 can be obtained. Digits 0_8 and 4_8 could also be obtained in other ways.
The second test case uses the decimal number system. The nominals of all banknotes end with zero, so Natasha can give the Martians only the amount whose decimal notation also ends with zero. | instruction | 0 | 65,617 | 20 | 131,234 |
Tags: number theory
Correct Solution:
```
from functools import reduce
def gcd(a,b):
if a==0:
return b
else:
return gcd(b%a,a)
n, k = map(int, input().split())
A = list(map(int, input().split()))
G = gcd(k, reduce(lambda x,y:gcd(x,y),A))
print(k // G)
for i in range(0, k, G):
print(i, end = " ")
``` | output | 1 | 65,617 | 20 | 131,235 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Astronaut Natasha arrived on Mars. She knows that the Martians are very poor aliens. To ensure a better life for the Mars citizens, their emperor decided to take tax from every tourist who visited the planet. Natasha is the inhabitant of Earth, therefore she had to pay the tax to enter the territory of Mars.
There are n banknote denominations on Mars: the value of i-th banknote is a_i. Natasha has an infinite number of banknotes of each denomination.
Martians have k fingers on their hands, so they use a number system with base k. In addition, the Martians consider the digit d (in the number system with base k) divine. Thus, if the last digit in Natasha's tax amount written in the number system with the base k is d, the Martians will be happy. Unfortunately, Natasha does not know the Martians' divine digit yet.
Determine for which values d Natasha can make the Martians happy.
Natasha can use only her banknotes. Martians don't give her change.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100 000, 2 ≤ k ≤ 100 000) — the number of denominations of banknotes and the base of the number system on Mars.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — denominations of banknotes on Mars.
All numbers are given in decimal notation.
Output
On the first line output the number of values d for which Natasha can make the Martians happy.
In the second line, output all these values in increasing order.
Print all numbers in decimal notation.
Examples
Input
2 8
12 20
Output
2
0 4
Input
3 10
10 20 30
Output
1
0
Note
Consider the first test case. It uses the octal number system.
If you take one banknote with the value of 12, you will get 14_8 in octal system. The last digit is 4_8.
If you take one banknote with the value of 12 and one banknote with the value of 20, the total value will be 32. In the octal system, it is 40_8. The last digit is 0_8.
If you take two banknotes with the value of 20, the total value will be 40, this is 50_8 in the octal system. The last digit is 0_8.
No other digits other than 0_8 and 4_8 can be obtained. Digits 0_8 and 4_8 could also be obtained in other ways.
The second test case uses the decimal number system. The nominals of all banknotes end with zero, so Natasha can give the Martians only the amount whose decimal notation also ends with zero.
Submitted Solution:
```
from functools import reduce
def gcd(x,y):
if x == 0:
return y
elif y == 0:
return x
if x > y:
return gcd(x%y,y)
elif x < y:
return gcd(x,y%x)
else:
return x
def main():
[n,k]=list(map(int,input().split(" ")))
a = list(map(int,input().split(" ")))
gcd1 = reduce(gcd,a+[k])
print(int(k/gcd1))
print(" ".join([str(gcd1*x) for x in range(int(k/gcd1))]))
main()
``` | instruction | 0 | 65,618 | 20 | 131,236 |
Yes | output | 1 | 65,618 | 20 | 131,237 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Astronaut Natasha arrived on Mars. She knows that the Martians are very poor aliens. To ensure a better life for the Mars citizens, their emperor decided to take tax from every tourist who visited the planet. Natasha is the inhabitant of Earth, therefore she had to pay the tax to enter the territory of Mars.
There are n banknote denominations on Mars: the value of i-th banknote is a_i. Natasha has an infinite number of banknotes of each denomination.
Martians have k fingers on their hands, so they use a number system with base k. In addition, the Martians consider the digit d (in the number system with base k) divine. Thus, if the last digit in Natasha's tax amount written in the number system with the base k is d, the Martians will be happy. Unfortunately, Natasha does not know the Martians' divine digit yet.
Determine for which values d Natasha can make the Martians happy.
Natasha can use only her banknotes. Martians don't give her change.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100 000, 2 ≤ k ≤ 100 000) — the number of denominations of banknotes and the base of the number system on Mars.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — denominations of banknotes on Mars.
All numbers are given in decimal notation.
Output
On the first line output the number of values d for which Natasha can make the Martians happy.
In the second line, output all these values in increasing order.
Print all numbers in decimal notation.
Examples
Input
2 8
12 20
Output
2
0 4
Input
3 10
10 20 30
Output
1
0
Note
Consider the first test case. It uses the octal number system.
If you take one banknote with the value of 12, you will get 14_8 in octal system. The last digit is 4_8.
If you take one banknote with the value of 12 and one banknote with the value of 20, the total value will be 32. In the octal system, it is 40_8. The last digit is 0_8.
If you take two banknotes with the value of 20, the total value will be 40, this is 50_8 in the octal system. The last digit is 0_8.
No other digits other than 0_8 and 4_8 can be obtained. Digits 0_8 and 4_8 could also be obtained in other ways.
The second test case uses the decimal number system. The nominals of all banknotes end with zero, so Natasha can give the Martians only the amount whose decimal notation also ends with zero.
Submitted Solution:
```
n, k = map(int, input().split())
a = list(map(int, input().split()))
def gcd(a, b):
while (a != 0):
a, b = b % a, a
return b
divisor = a[0]
for i in range(1, n):
divisor = gcd(divisor, a[i])
r = gcd(divisor, k)
print(k // r)
print(*[i * r for i in range(k // r)])
``` | instruction | 0 | 65,619 | 20 | 131,238 |
Yes | output | 1 | 65,619 | 20 | 131,239 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.