message stringlengths 2 57.2k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 61 108k | cluster float64 22 22 | __index_level_0__ int64 122 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two positive integers n (1 ≤ n ≤ 10^9) and k (1 ≤ k ≤ 100). Represent the number n as the sum of k positive integers of the same parity (have the same remainder when divided by 2).
In other words, find a_1, a_2, …, a_k such that all a_i>0, n = a_1 + a_2 + … + a_k and either all a_i are even or all a_i are odd at the same time.
If such a representation does not exist, then report it.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Next, t test cases are given, one per line.
Each test case is two positive integers n (1 ≤ n ≤ 10^9) and k (1 ≤ k ≤ 100).
Output
For each test case print:
* YES and the required values a_i, if the answer exists (if there are several answers, print any of them);
* NO if the answer does not exist.
The letters in the words YES and NO can be printed in any case.
Example
Input
8
10 3
100 4
8 7
97 2
8 8
3 10
5 3
1000000000 9
Output
YES
4 2 4
YES
55 5 5 35
NO
NO
YES
1 1 1 1 1 1 1 1
NO
YES
3 1 1
YES
111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111120 | instruction | 0 | 8,510 | 22 | 17,020 |
Tags: constructive algorithms, math
Correct Solution:
```
"""
// Author : snape_here - Susanta Mukherjee
"""
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().split())
def li(): return list(mi())
def read():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
def gcd(x, y):
while y:
x, y = y, x % y
return x
mod=1000000007
import math
import bisect
abc="abcdefghijklmnopqrstuvwxyz"
def main():
for _ in range(ii()):
n,k=mi()
if k==n:
print("YES")
for i in range(n):
print(1,end=" ")
print()
continue
if k>n:
print("NO")
continue
if (n%2 and k%2==0):
print("NO")
elif n%2==0 and k%2 and n//k<2:
print("NO")
elif n%2==0 and k%2:
print("YES")
for i in range(k-1):
print(2,end=" ")
print(n-(k-1)*2)
elif n%2 and k%2:
print("YES")
for i in range(k-1):
print(1,end=" ")
print(n-(k-1))
else:
print("YES")
for i in range(k-1):
print(1,end=" ")
print(n-(k-1))
# 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()
``` | output | 1 | 8,510 | 22 | 17,021 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two positive integers n (1 ≤ n ≤ 10^9) and k (1 ≤ k ≤ 100). Represent the number n as the sum of k positive integers of the same parity (have the same remainder when divided by 2).
In other words, find a_1, a_2, …, a_k such that all a_i>0, n = a_1 + a_2 + … + a_k and either all a_i are even or all a_i are odd at the same time.
If such a representation does not exist, then report it.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Next, t test cases are given, one per line.
Each test case is two positive integers n (1 ≤ n ≤ 10^9) and k (1 ≤ k ≤ 100).
Output
For each test case print:
* YES and the required values a_i, if the answer exists (if there are several answers, print any of them);
* NO if the answer does not exist.
The letters in the words YES and NO can be printed in any case.
Example
Input
8
10 3
100 4
8 7
97 2
8 8
3 10
5 3
1000000000 9
Output
YES
4 2 4
YES
55 5 5 35
NO
NO
YES
1 1 1 1 1 1 1 1
NO
YES
3 1 1
YES
111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111120 | instruction | 0 | 8,511 | 22 | 17,022 |
Tags: constructive algorithms, math
Correct Solution:
```
for _ in range(int(input())):
n, k = map(int, input().split())
if n % 2 == 1 and k % 2 == 0:
print("NO")
continue
if n % 2 == k % 2:
if k > n:
print("NO")
continue
res = [1] * (k-1)
res.append(n-(k-1))
print("YES")
print(*res)
continue
if k*2 > n:
print("NO")
continue
res = [2] * (k-1)
res.append(n-(k-1)*2)
print("YES")
print(*res)
"""
n k e o
--- ---
e e x x v
e o x
o e v
o o x v
n = 9 k = 4
1 1 1 6
_ _ _ _
n = 9 k = 3
n = 9 k = 10
n = 10 k = 6
2 2 2 2 2 2
1 1 1 7
n = 10 k = 3
2 2 6
"""
``` | output | 1 | 8,511 | 22 | 17,023 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two positive integers n (1 ≤ n ≤ 10^9) and k (1 ≤ k ≤ 100). Represent the number n as the sum of k positive integers of the same parity (have the same remainder when divided by 2).
In other words, find a_1, a_2, …, a_k such that all a_i>0, n = a_1 + a_2 + … + a_k and either all a_i are even or all a_i are odd at the same time.
If such a representation does not exist, then report it.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Next, t test cases are given, one per line.
Each test case is two positive integers n (1 ≤ n ≤ 10^9) and k (1 ≤ k ≤ 100).
Output
For each test case print:
* YES and the required values a_i, if the answer exists (if there are several answers, print any of them);
* NO if the answer does not exist.
The letters in the words YES and NO can be printed in any case.
Example
Input
8
10 3
100 4
8 7
97 2
8 8
3 10
5 3
1000000000 9
Output
YES
4 2 4
YES
55 5 5 35
NO
NO
YES
1 1 1 1 1 1 1 1
NO
YES
3 1 1
YES
111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111120 | instruction | 0 | 8,512 | 22 | 17,024 |
Tags: constructive algorithms, math
Correct Solution:
```
t = int(input())
for tt in range(t):
n, k = (int(i) for i in input().split())
if k <= n and (n-k) % 2 == 0:
print("YES")
ans = [1]*k
ans[0] = n-k+1
print(' '.join((str(i) for i in ans)))
elif 2*k <= n and (n-2*k)%2 == 0:
print("YES")
ans = [2]*k
ans[0] = n-2*k+2
print(' '.join((str(i) for i in ans)))
else:
print("NO")
``` | output | 1 | 8,512 | 22 | 17,025 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two positive integers n (1 ≤ n ≤ 10^9) and k (1 ≤ k ≤ 100). Represent the number n as the sum of k positive integers of the same parity (have the same remainder when divided by 2).
In other words, find a_1, a_2, …, a_k such that all a_i>0, n = a_1 + a_2 + … + a_k and either all a_i are even or all a_i are odd at the same time.
If such a representation does not exist, then report it.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Next, t test cases are given, one per line.
Each test case is two positive integers n (1 ≤ n ≤ 10^9) and k (1 ≤ k ≤ 100).
Output
For each test case print:
* YES and the required values a_i, if the answer exists (if there are several answers, print any of them);
* NO if the answer does not exist.
The letters in the words YES and NO can be printed in any case.
Example
Input
8
10 3
100 4
8 7
97 2
8 8
3 10
5 3
1000000000 9
Output
YES
4 2 4
YES
55 5 5 35
NO
NO
YES
1 1 1 1 1 1 1 1
NO
YES
3 1 1
YES
111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111120 | instruction | 0 | 8,513 | 22 | 17,026 |
Tags: constructive algorithms, math
Correct Solution:
```
def function(n, k):
l_odd=[1]*(k-1)
l_odd.append(n-sum(l_odd))
condition1=True
for i in l_odd:
if i%2==0 or i<=0:
condition1=False
break
if condition1:
print('YES')
print(*l_odd)
condition2=True
if not condition1:
l_even=[2]*(k-1)
l_even.append(n-sum(l_even))
for j in l_even:
if j%2!=0 or j<=0:
condition2=False
break
if condition2:
print('YES')
print(*l_even)
if condition1==False and condition2==False:
print('NO')
if __name__=='__main__':
t=int(input())
for k1 in range(t):
n, k=map(int, input().rstrip().split())
function(n, k)
``` | output | 1 | 8,513 | 22 | 17,027 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two positive integers n (1 ≤ n ≤ 10^9) and k (1 ≤ k ≤ 100). Represent the number n as the sum of k positive integers of the same parity (have the same remainder when divided by 2).
In other words, find a_1, a_2, …, a_k such that all a_i>0, n = a_1 + a_2 + … + a_k and either all a_i are even or all a_i are odd at the same time.
If such a representation does not exist, then report it.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Next, t test cases are given, one per line.
Each test case is two positive integers n (1 ≤ n ≤ 10^9) and k (1 ≤ k ≤ 100).
Output
For each test case print:
* YES and the required values a_i, if the answer exists (if there are several answers, print any of them);
* NO if the answer does not exist.
The letters in the words YES and NO can be printed in any case.
Example
Input
8
10 3
100 4
8 7
97 2
8 8
3 10
5 3
1000000000 9
Output
YES
4 2 4
YES
55 5 5 35
NO
NO
YES
1 1 1 1 1 1 1 1
NO
YES
3 1 1
YES
111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111120 | instruction | 0 | 8,514 | 22 | 17,028 |
Tags: constructive algorithms, math
Correct Solution:
```
q=int(input())
for i in range(q):
n,k=[int(i) for i in input().split()]
if k==1:
print('YES')
print(n)
else:
if n%2==1 and k%2==0 or k>n or k+1==n or ((n%2==0 and k%2==1) and n<k*2) :
print('NO')
else:
if n%2==0 and k%2==0:
print('YES')
print('1 '*(k-1)+str(n-k+1))
elif n%2==1 and k%2==1:
print('YES')
print('1 '*(k-1)+str(n-k+1))
elif n%2==0 and k%2==1:
print('YES')
print('2 '*((k-1))+str(n-(k-1)*2))
``` | output | 1 | 8,514 | 22 | 17,029 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two positive integers n (1 ≤ n ≤ 10^9) and k (1 ≤ k ≤ 100). Represent the number n as the sum of k positive integers of the same parity (have the same remainder when divided by 2).
In other words, find a_1, a_2, …, a_k such that all a_i>0, n = a_1 + a_2 + … + a_k and either all a_i are even or all a_i are odd at the same time.
If such a representation does not exist, then report it.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Next, t test cases are given, one per line.
Each test case is two positive integers n (1 ≤ n ≤ 10^9) and k (1 ≤ k ≤ 100).
Output
For each test case print:
* YES and the required values a_i, if the answer exists (if there are several answers, print any of them);
* NO if the answer does not exist.
The letters in the words YES and NO can be printed in any case.
Example
Input
8
10 3
100 4
8 7
97 2
8 8
3 10
5 3
1000000000 9
Output
YES
4 2 4
YES
55 5 5 35
NO
NO
YES
1 1 1 1 1 1 1 1
NO
YES
3 1 1
YES
111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111120 | instruction | 0 | 8,515 | 22 | 17,030 |
Tags: constructive algorithms, math
Correct Solution:
```
t = int(input())
for _ in range(t):
n, k = map(int, input().split())
if n < k:
print("NO")
continue
if n % 2 != 0:
if k % 2 == 0:
print("NO")
if k % 2 != 0:
print("YES")
print(str(n - k + 1) + ' 1' * (k - 1))
if n % 2 == 0:
if k % 2 == 0:
print("YES")
print(str(n - k + 1) + ' 1' * (k - 1))
if k % 2 != 0:
if k > n // 2:
print("NO")
else:
print("YES")
print(str(n - (k - 1) * 2) + ' 2' * (k - 1))
``` | output | 1 | 8,515 | 22 | 17,031 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two positive integers n (1 ≤ n ≤ 10^9) and k (1 ≤ k ≤ 100). Represent the number n as the sum of k positive integers of the same parity (have the same remainder when divided by 2).
In other words, find a_1, a_2, …, a_k such that all a_i>0, n = a_1 + a_2 + … + a_k and either all a_i are even or all a_i are odd at the same time.
If such a representation does not exist, then report it.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Next, t test cases are given, one per line.
Each test case is two positive integers n (1 ≤ n ≤ 10^9) and k (1 ≤ k ≤ 100).
Output
For each test case print:
* YES and the required values a_i, if the answer exists (if there are several answers, print any of them);
* NO if the answer does not exist.
The letters in the words YES and NO can be printed in any case.
Example
Input
8
10 3
100 4
8 7
97 2
8 8
3 10
5 3
1000000000 9
Output
YES
4 2 4
YES
55 5 5 35
NO
NO
YES
1 1 1 1 1 1 1 1
NO
YES
3 1 1
YES
111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111120 | instruction | 0 | 8,516 | 22 | 17,032 |
Tags: constructive algorithms, math
Correct Solution:
```
for _ in range(int(input())):
n,k=map(int,input().split())
ans1=[2]*(k-1)
ans1.append(n-2*k+2)
ans2=[1]*(k-1)
ans2.append(n-k+1)
if ans1[-1]>0 and ans1[-1]%2==0:
print("YES")
print(*ans1)
elif ans2[-1]>0 and ans2[-1]%2==1:
print("YES")
print(*ans2)
else:
print("NO")
``` | output | 1 | 8,516 | 22 | 17,033 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two positive integers n (1 ≤ n ≤ 10^9) and k (1 ≤ k ≤ 100). Represent the number n as the sum of k positive integers of the same parity (have the same remainder when divided by 2).
In other words, find a_1, a_2, …, a_k such that all a_i>0, n = a_1 + a_2 + … + a_k and either all a_i are even or all a_i are odd at the same time.
If such a representation does not exist, then report it.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Next, t test cases are given, one per line.
Each test case is two positive integers n (1 ≤ n ≤ 10^9) and k (1 ≤ k ≤ 100).
Output
For each test case print:
* YES and the required values a_i, if the answer exists (if there are several answers, print any of them);
* NO if the answer does not exist.
The letters in the words YES and NO can be printed in any case.
Example
Input
8
10 3
100 4
8 7
97 2
8 8
3 10
5 3
1000000000 9
Output
YES
4 2 4
YES
55 5 5 35
NO
NO
YES
1 1 1 1 1 1 1 1
NO
YES
3 1 1
YES
111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111120 | instruction | 0 | 8,517 | 22 | 17,034 |
Tags: constructive algorithms, math
Correct Solution:
```
t = int(input())
for i in range(t):
n,k = map(int, input().split())
if n==k:
print("YES")
print(*[1]*k)
elif n<k:
print("NO")
else:
if (n-(k-1))%2==1:
print("YES")
print(*[1]*(k-1),n-(k-1))
elif 2*(k-1) < n and (n - (2*(k-1)))%2==0:
print("YES")
print(*[2]*(k-1), n-(2*(k-1)))
else: print("NO")
``` | output | 1 | 8,517 | 22 | 17,035 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In order to put away old things and welcome a fresh new year, a thorough cleaning of the house is a must.
Little Tommy finds an old polynomial and cleaned it up by taking it modulo another. But now he regrets doing this...
Given two integers p and k, find a polynomial f(x) with non-negative integer coefficients strictly less than k, whose remainder is p when divided by (x + k). That is, f(x) = q(x)·(x + k) + p, where q(x) is a polynomial (not necessarily with integer coefficients).
Input
The only line of input contains two space-separated integers p and k (1 ≤ p ≤ 1018, 2 ≤ k ≤ 2 000).
Output
If the polynomial does not exist, print a single integer -1, or output two lines otherwise.
In the first line print a non-negative integer d — the number of coefficients in the polynomial.
In the second line print d space-separated integers a0, a1, ..., ad - 1, describing a polynomial <image> fulfilling the given requirements. Your output should satisfy 0 ≤ ai < k for all 0 ≤ i ≤ d - 1, and ad - 1 ≠ 0.
If there are many possible solutions, print any of them.
Examples
Input
46 2
Output
7
0 1 0 0 1 1 1
Input
2018 214
Output
3
92 205 1
Note
In the first example, f(x) = x6 + x5 + x4 + x = (x5 - x4 + 3x3 - 6x2 + 12x - 23)·(x + 2) + 46.
In the second example, f(x) = x2 + 205x + 92 = (x - 9)·(x + 214) + 2018. | instruction | 0 | 8,805 | 22 | 17,610 |
Tags: math
Correct Solution:
```
R=lambda:map(int,input().split())
p, k = R()
a = []
t = p//k
temp = 1
if p >= k:
while k * t >= k:
a.insert(0, (-1)**temp * t)
flag = True
if t%k == 0: flag = False
t = abs(t//k)
if temp % 2 == 1 and flag : t += 1
temp += 1
if temp % 2 == 0:
a.insert(0, 1)
ans = [0] * (len(a) + 1)
for i in range(1, len(ans) - 1):
ans[i] = a[i] + k * a[i - 1]
ans[0] = a[0]
ans[-1] = k * a[-1] + p
if p < k:
ans = [p]
print(len(ans))
print (" ".join([str(x) for x in ans[::-1]] ))
``` | output | 1 | 8,805 | 22 | 17,611 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In order to put away old things and welcome a fresh new year, a thorough cleaning of the house is a must.
Little Tommy finds an old polynomial and cleaned it up by taking it modulo another. But now he regrets doing this...
Given two integers p and k, find a polynomial f(x) with non-negative integer coefficients strictly less than k, whose remainder is p when divided by (x + k). That is, f(x) = q(x)·(x + k) + p, where q(x) is a polynomial (not necessarily with integer coefficients).
Input
The only line of input contains two space-separated integers p and k (1 ≤ p ≤ 1018, 2 ≤ k ≤ 2 000).
Output
If the polynomial does not exist, print a single integer -1, or output two lines otherwise.
In the first line print a non-negative integer d — the number of coefficients in the polynomial.
In the second line print d space-separated integers a0, a1, ..., ad - 1, describing a polynomial <image> fulfilling the given requirements. Your output should satisfy 0 ≤ ai < k for all 0 ≤ i ≤ d - 1, and ad - 1 ≠ 0.
If there are many possible solutions, print any of them.
Examples
Input
46 2
Output
7
0 1 0 0 1 1 1
Input
2018 214
Output
3
92 205 1
Note
In the first example, f(x) = x6 + x5 + x4 + x = (x5 - x4 + 3x3 - 6x2 + 12x - 23)·(x + 2) + 46.
In the second example, f(x) = x2 + 205x + 92 = (x - 9)·(x + 214) + 2018. | instruction | 0 | 8,806 | 22 | 17,612 |
Tags: math
Correct Solution:
```
[p,k]=[int(x) for x in input().split()]
d=1
res=[]
while p:
if d%2==1:
kek=k
res.append(str(p%kek))
p//=kek
else:
kek=k
lol=kek-(p%kek)
while lol>=kek:
lol-=kek
res.append(str(lol))
p=(p+lol)//kek
d+=1
print(len(res))
s=' '
print(s.join(res))
``` | output | 1 | 8,806 | 22 | 17,613 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In order to put away old things and welcome a fresh new year, a thorough cleaning of the house is a must.
Little Tommy finds an old polynomial and cleaned it up by taking it modulo another. But now he regrets doing this...
Given two integers p and k, find a polynomial f(x) with non-negative integer coefficients strictly less than k, whose remainder is p when divided by (x + k). That is, f(x) = q(x)·(x + k) + p, where q(x) is a polynomial (not necessarily with integer coefficients).
Input
The only line of input contains two space-separated integers p and k (1 ≤ p ≤ 1018, 2 ≤ k ≤ 2 000).
Output
If the polynomial does not exist, print a single integer -1, or output two lines otherwise.
In the first line print a non-negative integer d — the number of coefficients in the polynomial.
In the second line print d space-separated integers a0, a1, ..., ad - 1, describing a polynomial <image> fulfilling the given requirements. Your output should satisfy 0 ≤ ai < k for all 0 ≤ i ≤ d - 1, and ad - 1 ≠ 0.
If there are many possible solutions, print any of them.
Examples
Input
46 2
Output
7
0 1 0 0 1 1 1
Input
2018 214
Output
3
92 205 1
Note
In the first example, f(x) = x6 + x5 + x4 + x = (x5 - x4 + 3x3 - 6x2 + 12x - 23)·(x + 2) + 46.
In the second example, f(x) = x2 + 205x + 92 = (x - 9)·(x + 214) + 2018. | instruction | 0 | 8,807 | 22 | 17,614 |
Tags: math
Correct Solution:
```
def solve(n,p,k):
# print(n,p,k)
P=p
cf=1
a=[0]*n
for i in range(n):
if i&1:
p+=cf*(k-1)
a[i]-=k-1
cf*=k
# print(p)
for i in range(n):
a[i]+=p%k
p//=k
# print(n,a)
if p:
return
for i in range(n):
if i&1:
a[i]*=-1
cf=1
p=P
for i in range(n):
if a[i]<0 or a[i]>=k:
return
if i&1:
p+=a[i]*cf
else:
p-=a[i]*cf
cf*=k
if p:
return
print(len(a))
print(*a)
exit(0)
p,k=map(int,input().split())
for i in range(100):
if k**i>1<<100:
break
solve(i,p,k)
print(-1)
``` | output | 1 | 8,807 | 22 | 17,615 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In order to put away old things and welcome a fresh new year, a thorough cleaning of the house is a must.
Little Tommy finds an old polynomial and cleaned it up by taking it modulo another. But now he regrets doing this...
Given two integers p and k, find a polynomial f(x) with non-negative integer coefficients strictly less than k, whose remainder is p when divided by (x + k). That is, f(x) = q(x)·(x + k) + p, where q(x) is a polynomial (not necessarily with integer coefficients).
Input
The only line of input contains two space-separated integers p and k (1 ≤ p ≤ 1018, 2 ≤ k ≤ 2 000).
Output
If the polynomial does not exist, print a single integer -1, or output two lines otherwise.
In the first line print a non-negative integer d — the number of coefficients in the polynomial.
In the second line print d space-separated integers a0, a1, ..., ad - 1, describing a polynomial <image> fulfilling the given requirements. Your output should satisfy 0 ≤ ai < k for all 0 ≤ i ≤ d - 1, and ad - 1 ≠ 0.
If there are many possible solutions, print any of them.
Examples
Input
46 2
Output
7
0 1 0 0 1 1 1
Input
2018 214
Output
3
92 205 1
Note
In the first example, f(x) = x6 + x5 + x4 + x = (x5 - x4 + 3x3 - 6x2 + 12x - 23)·(x + 2) + 46.
In the second example, f(x) = x2 + 205x + 92 = (x - 9)·(x + 214) + 2018. | instruction | 0 | 8,808 | 22 | 17,616 |
Tags: math
Correct Solution:
```
p,k = map(int, input().split())
coeff = [1]
maxi =k-1
kk = k*k
while maxi < p:
for i in range(2):
coeff.append(0)
maxi += kk*(k-1)
kk*=k*2
n = len(coeff)
powk = [0 for i in range(n)]
pos = [0 for i in range(n)]
neg = [0 for i in range(n)]
powk[0] = 1
for i in range(1,n):
powk[i] = powk[i-1]*k
pos[0]=k-1;
neg[0]=0;
for i in range(1,n):
if i%2 ==0:
pos[i] = pos[i-1]+powk[i]*(k-1);
neg[i] = neg[i-1];
else:
pos[i] = pos[i-1];
neg[i] = neg[i-1] + powk[i]*(k-1);
for i in range(n-1,-1,-1):
if i%2 ==0:
coeff[i] = (p+neg[i])//powk[i];
p-=coeff[i]*powk[i];
else:
coeff[i] = (-p+pos[i])//powk[i];
p+=coeff[i]*powk[i];
ng = False
for i in range(n):
if coeff[i]>=k:
ng = True
if ng:
print(-1)
else:
d=n
for i in range(n-1,-1,-1):
if coeff[i]==0:
d = d-1
else:
break
print(d)
print(' '.join(map(str, coeff[0:d])))
``` | output | 1 | 8,808 | 22 | 17,617 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In order to put away old things and welcome a fresh new year, a thorough cleaning of the house is a must.
Little Tommy finds an old polynomial and cleaned it up by taking it modulo another. But now he regrets doing this...
Given two integers p and k, find a polynomial f(x) with non-negative integer coefficients strictly less than k, whose remainder is p when divided by (x + k). That is, f(x) = q(x)·(x + k) + p, where q(x) is a polynomial (not necessarily with integer coefficients).
Input
The only line of input contains two space-separated integers p and k (1 ≤ p ≤ 1018, 2 ≤ k ≤ 2 000).
Output
If the polynomial does not exist, print a single integer -1, or output two lines otherwise.
In the first line print a non-negative integer d — the number of coefficients in the polynomial.
In the second line print d space-separated integers a0, a1, ..., ad - 1, describing a polynomial <image> fulfilling the given requirements. Your output should satisfy 0 ≤ ai < k for all 0 ≤ i ≤ d - 1, and ad - 1 ≠ 0.
If there are many possible solutions, print any of them.
Examples
Input
46 2
Output
7
0 1 0 0 1 1 1
Input
2018 214
Output
3
92 205 1
Note
In the first example, f(x) = x6 + x5 + x4 + x = (x5 - x4 + 3x3 - 6x2 + 12x - 23)·(x + 2) + 46.
In the second example, f(x) = x2 + 205x + 92 = (x - 9)·(x + 214) + 2018. | instruction | 0 | 8,809 | 22 | 17,618 |
Tags: math
Correct Solution:
```
a,b=map(int,input().split())
c=-(a//b)
out=[a%b]
while True:
#print(c)
out.append(c%b)
c=-(c//b)
if out[-1]==c==0:
break
print(len(out)-1)
for i in out[:-1]:
print(i,end=" ")
print()
``` | output | 1 | 8,809 | 22 | 17,619 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In order to put away old things and welcome a fresh new year, a thorough cleaning of the house is a must.
Little Tommy finds an old polynomial and cleaned it up by taking it modulo another. But now he regrets doing this...
Given two integers p and k, find a polynomial f(x) with non-negative integer coefficients strictly less than k, whose remainder is p when divided by (x + k). That is, f(x) = q(x)·(x + k) + p, where q(x) is a polynomial (not necessarily with integer coefficients).
Input
The only line of input contains two space-separated integers p and k (1 ≤ p ≤ 1018, 2 ≤ k ≤ 2 000).
Output
If the polynomial does not exist, print a single integer -1, or output two lines otherwise.
In the first line print a non-negative integer d — the number of coefficients in the polynomial.
In the second line print d space-separated integers a0, a1, ..., ad - 1, describing a polynomial <image> fulfilling the given requirements. Your output should satisfy 0 ≤ ai < k for all 0 ≤ i ≤ d - 1, and ad - 1 ≠ 0.
If there are many possible solutions, print any of them.
Examples
Input
46 2
Output
7
0 1 0 0 1 1 1
Input
2018 214
Output
3
92 205 1
Note
In the first example, f(x) = x6 + x5 + x4 + x = (x5 - x4 + 3x3 - 6x2 + 12x - 23)·(x + 2) + 46.
In the second example, f(x) = x2 + 205x + 92 = (x - 9)·(x + 214) + 2018. | instruction | 0 | 8,810 | 22 | 17,620 |
Tags: math
Correct Solution:
```
n,a = map(int,input().split())
ar = []
j = 1
while n!=0:
q = n%a
n //= a
n = -1*n
#j += 1
ar.append(q)
print(len(ar))
for i in range(len(ar)):
print(ar[i])
``` | output | 1 | 8,810 | 22 | 17,621 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In order to put away old things and welcome a fresh new year, a thorough cleaning of the house is a must.
Little Tommy finds an old polynomial and cleaned it up by taking it modulo another. But now he regrets doing this...
Given two integers p and k, find a polynomial f(x) with non-negative integer coefficients strictly less than k, whose remainder is p when divided by (x + k). That is, f(x) = q(x)·(x + k) + p, where q(x) is a polynomial (not necessarily with integer coefficients).
Input
The only line of input contains two space-separated integers p and k (1 ≤ p ≤ 1018, 2 ≤ k ≤ 2 000).
Output
If the polynomial does not exist, print a single integer -1, or output two lines otherwise.
In the first line print a non-negative integer d — the number of coefficients in the polynomial.
In the second line print d space-separated integers a0, a1, ..., ad - 1, describing a polynomial <image> fulfilling the given requirements. Your output should satisfy 0 ≤ ai < k for all 0 ≤ i ≤ d - 1, and ad - 1 ≠ 0.
If there are many possible solutions, print any of them.
Examples
Input
46 2
Output
7
0 1 0 0 1 1 1
Input
2018 214
Output
3
92 205 1
Note
In the first example, f(x) = x6 + x5 + x4 + x = (x5 - x4 + 3x3 - 6x2 + 12x - 23)·(x + 2) + 46.
In the second example, f(x) = x2 + 205x + 92 = (x - 9)·(x + 214) + 2018. | instruction | 0 | 8,811 | 22 | 17,622 |
Tags: math
Correct Solution:
```
p, k = map(int, input().split())
if p < k:
print(1)
print(p)
else:
ans = [p]
cur = p
while cur < 0 or cur >= k:
cur = - (cur // k)
ans.append(cur)
arr = []
for i in range(1, len(ans)):
arr.append(str(k*ans[i]+ans[i-1]))
arr.append(str(ans[-1]))
print(len(arr))
print(' '.join(arr))
``` | output | 1 | 8,811 | 22 | 17,623 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In order to put away old things and welcome a fresh new year, a thorough cleaning of the house is a must.
Little Tommy finds an old polynomial and cleaned it up by taking it modulo another. But now he regrets doing this...
Given two integers p and k, find a polynomial f(x) with non-negative integer coefficients strictly less than k, whose remainder is p when divided by (x + k). That is, f(x) = q(x)·(x + k) + p, where q(x) is a polynomial (not necessarily with integer coefficients).
Input
The only line of input contains two space-separated integers p and k (1 ≤ p ≤ 1018, 2 ≤ k ≤ 2 000).
Output
If the polynomial does not exist, print a single integer -1, or output two lines otherwise.
In the first line print a non-negative integer d — the number of coefficients in the polynomial.
In the second line print d space-separated integers a0, a1, ..., ad - 1, describing a polynomial <image> fulfilling the given requirements. Your output should satisfy 0 ≤ ai < k for all 0 ≤ i ≤ d - 1, and ad - 1 ≠ 0.
If there are many possible solutions, print any of them.
Examples
Input
46 2
Output
7
0 1 0 0 1 1 1
Input
2018 214
Output
3
92 205 1
Note
In the first example, f(x) = x6 + x5 + x4 + x = (x5 - x4 + 3x3 - 6x2 + 12x - 23)·(x + 2) + 46.
In the second example, f(x) = x2 + 205x + 92 = (x - 9)·(x + 214) + 2018. | instruction | 0 | 8,812 | 22 | 17,624 |
Tags: math
Correct Solution:
```
p, k = map(int, input().split())
a = ''
cnt = 0
while p != 0:
cnt += 1
a += str(p % k) + ' '
p -= p % k
p //= -k
print(cnt)
print(a)
``` | output | 1 | 8,812 | 22 | 17,625 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In order to put away old things and welcome a fresh new year, a thorough cleaning of the house is a must.
Little Tommy finds an old polynomial and cleaned it up by taking it modulo another. But now he regrets doing this...
Given two integers p and k, find a polynomial f(x) with non-negative integer coefficients strictly less than k, whose remainder is p when divided by (x + k). That is, f(x) = q(x)·(x + k) + p, where q(x) is a polynomial (not necessarily with integer coefficients).
Input
The only line of input contains two space-separated integers p and k (1 ≤ p ≤ 1018, 2 ≤ k ≤ 2 000).
Output
If the polynomial does not exist, print a single integer -1, or output two lines otherwise.
In the first line print a non-negative integer d — the number of coefficients in the polynomial.
In the second line print d space-separated integers a0, a1, ..., ad - 1, describing a polynomial <image> fulfilling the given requirements. Your output should satisfy 0 ≤ ai < k for all 0 ≤ i ≤ d - 1, and ad - 1 ≠ 0.
If there are many possible solutions, print any of them.
Examples
Input
46 2
Output
7
0 1 0 0 1 1 1
Input
2018 214
Output
3
92 205 1
Note
In the first example, f(x) = x6 + x5 + x4 + x = (x5 - x4 + 3x3 - 6x2 + 12x - 23)·(x + 2) + 46.
In the second example, f(x) = x2 + 205x + 92 = (x - 9)·(x + 214) + 2018.
Submitted Solution:
```
p, k = input().split()
p, k = int(p), int(k)
s = k - 1
ls = [0]
while s < p:
ls.append(0)
ls.append(0)
s = s * k * k + k - 1
n = len(ls)
for i in range(n):
if (i & 1) == 0:
ls[i] = k - 1
res = s - p
for i in range(n):
t = res % k
if i & 1:
ls[i] += t
else:
ls[i] -= t
res //= k
print(n)
print(" ".join(str(x) for x in ls))
``` | instruction | 0 | 8,813 | 22 | 17,626 |
Yes | output | 1 | 8,813 | 22 | 17,627 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In order to put away old things and welcome a fresh new year, a thorough cleaning of the house is a must.
Little Tommy finds an old polynomial and cleaned it up by taking it modulo another. But now he regrets doing this...
Given two integers p and k, find a polynomial f(x) with non-negative integer coefficients strictly less than k, whose remainder is p when divided by (x + k). That is, f(x) = q(x)·(x + k) + p, where q(x) is a polynomial (not necessarily with integer coefficients).
Input
The only line of input contains two space-separated integers p and k (1 ≤ p ≤ 1018, 2 ≤ k ≤ 2 000).
Output
If the polynomial does not exist, print a single integer -1, or output two lines otherwise.
In the first line print a non-negative integer d — the number of coefficients in the polynomial.
In the second line print d space-separated integers a0, a1, ..., ad - 1, describing a polynomial <image> fulfilling the given requirements. Your output should satisfy 0 ≤ ai < k for all 0 ≤ i ≤ d - 1, and ad - 1 ≠ 0.
If there are many possible solutions, print any of them.
Examples
Input
46 2
Output
7
0 1 0 0 1 1 1
Input
2018 214
Output
3
92 205 1
Note
In the first example, f(x) = x6 + x5 + x4 + x = (x5 - x4 + 3x3 - 6x2 + 12x - 23)·(x + 2) + 46.
In the second example, f(x) = x2 + 205x + 92 = (x - 9)·(x + 214) + 2018.
Submitted Solution:
```
p,k = map(int,input().split())
num = [0] * 64
sum = 0
c = 0
power = k-1
while(sum < p):
sum += power
power *= k*k
c += 2
#print(power / k / k << endl << sum << endl;
print(c-1)
i = 0
p = sum - p
while(p > 0):
num[i] = p % k
p //= k
i += 1
#cout << sum << endl;
for i in range(c-1):
#cout << num[i] << " ";
if(i % 2 == 0) :print(k - 1 - num[i],end = ' ')
else :print(num[i],end = ' ')
``` | instruction | 0 | 8,814 | 22 | 17,628 |
Yes | output | 1 | 8,814 | 22 | 17,629 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In order to put away old things and welcome a fresh new year, a thorough cleaning of the house is a must.
Little Tommy finds an old polynomial and cleaned it up by taking it modulo another. But now he regrets doing this...
Given two integers p and k, find a polynomial f(x) with non-negative integer coefficients strictly less than k, whose remainder is p when divided by (x + k). That is, f(x) = q(x)·(x + k) + p, where q(x) is a polynomial (not necessarily with integer coefficients).
Input
The only line of input contains two space-separated integers p and k (1 ≤ p ≤ 1018, 2 ≤ k ≤ 2 000).
Output
If the polynomial does not exist, print a single integer -1, or output two lines otherwise.
In the first line print a non-negative integer d — the number of coefficients in the polynomial.
In the second line print d space-separated integers a0, a1, ..., ad - 1, describing a polynomial <image> fulfilling the given requirements. Your output should satisfy 0 ≤ ai < k for all 0 ≤ i ≤ d - 1, and ad - 1 ≠ 0.
If there are many possible solutions, print any of them.
Examples
Input
46 2
Output
7
0 1 0 0 1 1 1
Input
2018 214
Output
3
92 205 1
Note
In the first example, f(x) = x6 + x5 + x4 + x = (x5 - x4 + 3x3 - 6x2 + 12x - 23)·(x + 2) + 46.
In the second example, f(x) = x2 + 205x + 92 = (x - 9)·(x + 214) + 2018.
Submitted Solution:
```
def main():
p,k = [int(x) for x in input().split()]
ff = True
a= []
while True:
if p ==0:
break
# print(k, p)
t = (k - p) // k
if t*k + p == k:
t -=1
if t*k + p < 0:
ff =False
print(-1)
break
a.append(t*k + p)
p = t
# print(a)
if ff:
print(len(a))
print(' '.join(str(x) for x in a))
if __name__ == '__main__':
main()
``` | instruction | 0 | 8,815 | 22 | 17,630 |
Yes | output | 1 | 8,815 | 22 | 17,631 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In order to put away old things and welcome a fresh new year, a thorough cleaning of the house is a must.
Little Tommy finds an old polynomial and cleaned it up by taking it modulo another. But now he regrets doing this...
Given two integers p and k, find a polynomial f(x) with non-negative integer coefficients strictly less than k, whose remainder is p when divided by (x + k). That is, f(x) = q(x)·(x + k) + p, where q(x) is a polynomial (not necessarily with integer coefficients).
Input
The only line of input contains two space-separated integers p and k (1 ≤ p ≤ 1018, 2 ≤ k ≤ 2 000).
Output
If the polynomial does not exist, print a single integer -1, or output two lines otherwise.
In the first line print a non-negative integer d — the number of coefficients in the polynomial.
In the second line print d space-separated integers a0, a1, ..., ad - 1, describing a polynomial <image> fulfilling the given requirements. Your output should satisfy 0 ≤ ai < k for all 0 ≤ i ≤ d - 1, and ad - 1 ≠ 0.
If there are many possible solutions, print any of them.
Examples
Input
46 2
Output
7
0 1 0 0 1 1 1
Input
2018 214
Output
3
92 205 1
Note
In the first example, f(x) = x6 + x5 + x4 + x = (x5 - x4 + 3x3 - 6x2 + 12x - 23)·(x + 2) + 46.
In the second example, f(x) = x2 + 205x + 92 = (x - 9)·(x + 214) + 2018.
Submitted Solution:
```
def rec(n,k):
s=[]
while n!=0:
n,r=n//k,n%k
#print(n,r)
if r<0:
r-=k
n+=1
#print(s,n,r)
s.append(r)
return s
p,k=map(int,input().split())
d=rec(p,-k)
print(len(d))
print(*d)
``` | instruction | 0 | 8,816 | 22 | 17,632 |
Yes | output | 1 | 8,816 | 22 | 17,633 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In order to put away old things and welcome a fresh new year, a thorough cleaning of the house is a must.
Little Tommy finds an old polynomial and cleaned it up by taking it modulo another. But now he regrets doing this...
Given two integers p and k, find a polynomial f(x) with non-negative integer coefficients strictly less than k, whose remainder is p when divided by (x + k). That is, f(x) = q(x)·(x + k) + p, where q(x) is a polynomial (not necessarily with integer coefficients).
Input
The only line of input contains two space-separated integers p and k (1 ≤ p ≤ 1018, 2 ≤ k ≤ 2 000).
Output
If the polynomial does not exist, print a single integer -1, or output two lines otherwise.
In the first line print a non-negative integer d — the number of coefficients in the polynomial.
In the second line print d space-separated integers a0, a1, ..., ad - 1, describing a polynomial <image> fulfilling the given requirements. Your output should satisfy 0 ≤ ai < k for all 0 ≤ i ≤ d - 1, and ad - 1 ≠ 0.
If there are many possible solutions, print any of them.
Examples
Input
46 2
Output
7
0 1 0 0 1 1 1
Input
2018 214
Output
3
92 205 1
Note
In the first example, f(x) = x6 + x5 + x4 + x = (x5 - x4 + 3x3 - 6x2 + 12x - 23)·(x + 2) + 46.
In the second example, f(x) = x2 + 205x + 92 = (x - 9)·(x + 214) + 2018.
Submitted Solution:
```
p, k = map(int, input().split())
r = []
f = 1
while 1:
p, q = divmod(f * p, k)
f = -f
r.append(q)
if p <= 0 and -p < k:
break
if p:
r.append(-p)
print(len(r))
print(*r, sep=' ')
``` | instruction | 0 | 8,817 | 22 | 17,634 |
No | output | 1 | 8,817 | 22 | 17,635 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In order to put away old things and welcome a fresh new year, a thorough cleaning of the house is a must.
Little Tommy finds an old polynomial and cleaned it up by taking it modulo another. But now he regrets doing this...
Given two integers p and k, find a polynomial f(x) with non-negative integer coefficients strictly less than k, whose remainder is p when divided by (x + k). That is, f(x) = q(x)·(x + k) + p, where q(x) is a polynomial (not necessarily with integer coefficients).
Input
The only line of input contains two space-separated integers p and k (1 ≤ p ≤ 1018, 2 ≤ k ≤ 2 000).
Output
If the polynomial does not exist, print a single integer -1, or output two lines otherwise.
In the first line print a non-negative integer d — the number of coefficients in the polynomial.
In the second line print d space-separated integers a0, a1, ..., ad - 1, describing a polynomial <image> fulfilling the given requirements. Your output should satisfy 0 ≤ ai < k for all 0 ≤ i ≤ d - 1, and ad - 1 ≠ 0.
If there are many possible solutions, print any of them.
Examples
Input
46 2
Output
7
0 1 0 0 1 1 1
Input
2018 214
Output
3
92 205 1
Note
In the first example, f(x) = x6 + x5 + x4 + x = (x5 - x4 + 3x3 - 6x2 + 12x - 23)·(x + 2) + 46.
In the second example, f(x) = x2 + 205x + 92 = (x - 9)·(x + 214) + 2018.
Submitted Solution:
```
p, k = map(int, input().split())
res = dict()
ok = True
def f(sm, up):
#print("sm = " + str(sm))
global res
global ok
if (sm == 0) :return
if (sm > 0):
pw = 0
while (k - 1) * k ** pw < sm:
pw += 2
if pw >= up:
ok = False
return
t = int(sm / (k ** pw))
if sm % (k ** pw) > 0:
t += 1
sm -= t * (k ** pw)
res[pw] = t
f(sm, pw)
else:
a = abs(sm)
pw = 1
while (k - 1) * k ** pw < a:
pw += 2
if pw >= up:
ok = False
return
t = int(a / (k ** pw))
if a % (k ** pw) > 0:
t += 1
sm += t * (k ** pw)
res[pw] = t
f(sm, pw)
f(p, int(10**18))
if not ok:
print("-1")
else:
mx = 0
for x in res:
mx = max(x, mx)
a = [0 for i in range(mx + 1)]
print(len(a))
for x in res:
a[x] = res[x]
for x in a:
print(x)
``` | instruction | 0 | 8,818 | 22 | 17,636 |
No | output | 1 | 8,818 | 22 | 17,637 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In order to put away old things and welcome a fresh new year, a thorough cleaning of the house is a must.
Little Tommy finds an old polynomial and cleaned it up by taking it modulo another. But now he regrets doing this...
Given two integers p and k, find a polynomial f(x) with non-negative integer coefficients strictly less than k, whose remainder is p when divided by (x + k). That is, f(x) = q(x)·(x + k) + p, where q(x) is a polynomial (not necessarily with integer coefficients).
Input
The only line of input contains two space-separated integers p and k (1 ≤ p ≤ 1018, 2 ≤ k ≤ 2 000).
Output
If the polynomial does not exist, print a single integer -1, or output two lines otherwise.
In the first line print a non-negative integer d — the number of coefficients in the polynomial.
In the second line print d space-separated integers a0, a1, ..., ad - 1, describing a polynomial <image> fulfilling the given requirements. Your output should satisfy 0 ≤ ai < k for all 0 ≤ i ≤ d - 1, and ad - 1 ≠ 0.
If there are many possible solutions, print any of them.
Examples
Input
46 2
Output
7
0 1 0 0 1 1 1
Input
2018 214
Output
3
92 205 1
Note
In the first example, f(x) = x6 + x5 + x4 + x = (x5 - x4 + 3x3 - 6x2 + 12x - 23)·(x + 2) + 46.
In the second example, f(x) = x2 + 205x + 92 = (x - 9)·(x + 214) + 2018.
Submitted Solution:
```
p, k = map(int, input().split())
print('3\n1', k - p, p - p * k)
``` | instruction | 0 | 8,819 | 22 | 17,638 |
No | output | 1 | 8,819 | 22 | 17,639 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In order to put away old things and welcome a fresh new year, a thorough cleaning of the house is a must.
Little Tommy finds an old polynomial and cleaned it up by taking it modulo another. But now he regrets doing this...
Given two integers p and k, find a polynomial f(x) with non-negative integer coefficients strictly less than k, whose remainder is p when divided by (x + k). That is, f(x) = q(x)·(x + k) + p, where q(x) is a polynomial (not necessarily with integer coefficients).
Input
The only line of input contains two space-separated integers p and k (1 ≤ p ≤ 1018, 2 ≤ k ≤ 2 000).
Output
If the polynomial does not exist, print a single integer -1, or output two lines otherwise.
In the first line print a non-negative integer d — the number of coefficients in the polynomial.
In the second line print d space-separated integers a0, a1, ..., ad - 1, describing a polynomial <image> fulfilling the given requirements. Your output should satisfy 0 ≤ ai < k for all 0 ≤ i ≤ d - 1, and ad - 1 ≠ 0.
If there are many possible solutions, print any of them.
Examples
Input
46 2
Output
7
0 1 0 0 1 1 1
Input
2018 214
Output
3
92 205 1
Note
In the first example, f(x) = x6 + x5 + x4 + x = (x5 - x4 + 3x3 - 6x2 + 12x - 23)·(x + 2) + 46.
In the second example, f(x) = x2 + 205x + 92 = (x - 9)·(x + 214) + 2018.
Submitted Solution:
```
p, k = map(int, input().split())
print(3)
print(1, 1 + k, k + p)
``` | instruction | 0 | 8,820 | 22 | 17,640 |
No | output | 1 | 8,820 | 22 | 17,641 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image> <image>
*The two images are equivalent, feel free to use either one.
Input
The input contains a single integer a (-100 ≤ a ≤ 100).
Output
Output the result – an integer number.
Example
Input
1
Output
1 | instruction | 0 | 9,317 | 22 | 18,634 |
Tags: *special, math
Correct Solution:
```
import sys
import math
from bisect import bisect_left
import heapq
def II():
return int(sys.stdin.readline())
def LI():
return list(map(int, sys.stdin.readline().split()))
def MI():
return map(int, sys.stdin.readline().split())
def SI():
return sys.stdin.readline().strip()
def FACT(n, mod):
s = 1
facts = [1]
for i in range(1,n+1):
s*=i
s%=mod
facts.append(s)
return facts[n]
def C(n, k, mod):
return (FACT(n,mod) * pow((FACT(k,mod)*FACT(n-k,mod))%mod,mod-2, mod))%mod
def lcm(a,b):
return abs(a*b) // math.gcd(a, b)
print(2-II()**2)
``` | output | 1 | 9,317 | 22 | 18,635 |
Provide a correct Python 3 solution for this coding contest problem.
You are a teacher at a cram school for elementary school pupils.
One day, you showed your students how to calculate division of fraction in a class of mathematics. Your lesson was kind and fluent, and it seemed everything was going so well - except for one thing. After some experiences, a student Max got so curious about how precise he could compute the quotient. He tried many divisions asking you for a help, and finally found a case where the answer became an infinite fraction. He was fascinated with such a case, so he continued computing the answer. But it was clear for you the answer was an infinite fraction - no matter how many digits he computed, he wouldn’t reach the end.
Since you have many other things to tell in today’s class, you can’t leave this as it is. So you decided to use a computer to calculate the answer in turn of him. Actually you succeeded to persuade him that he was going into a loop, so it was enough for him to know how long he could compute before entering a loop.
Your task now is to write a program which computes where the recurring part starts and the length of the recurring part, for given dividend/divisor pairs. All computation should be done in decimal numbers. If the specified dividend/divisor pair gives a finite fraction, your program should treat the length of the recurring part as 0.
Input
The input consists of multiple datasets. Each line of the input describes a dataset. A dataset consists of two positive integers x and y, which specifies the dividend and the divisor, respectively. You may assume that 1 ≤ x < y ≤ 1,000,000.
The last dataset is followed by a line containing two zeros. This line is not a part of datasets and should not be processed.
Output
For each dataset, your program should output a line containing two integers separated by exactly one blank character.
The former describes the number of digits after the decimal point before the recurring part starts. And the latter describes the length of the recurring part.
Example
Input
1 3
1 6
3 5
2 200
25 99
0 0
Output
0 1
1 1
1 0
2 0
0 2 | instruction | 0 | 9,864 | 22 | 19,728 |
"Correct Solution:
```
def gcd(a,b):
while b:a,b=b,a%b
return a
def f(n,m):
if m==1:return 0
x=1
for i in range(m):
x=(x*n)%m
if x==1:return i+1
while 1:
a,b=map(int,input().split())
if a==0:break
c=gcd(a,b)
a//=c;b//=c
cnt=0;d=gcd(b,10)
while d!=1:
b//=d
cnt+=1
d=gcd(b,10)
print(cnt,f(10,b))
``` | output | 1 | 9,864 | 22 | 19,729 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have given an array a of length n and an integer x to a brand new robot. What the robot does is the following: it iterates over the elements of the array, let the current element be q. If q is divisible by x, the robot adds x copies of the integer q/x to the end of the array, and moves on to the next element. Note that the newly added elements could be processed by the robot later. Otherwise, if q is not divisible by x, the robot shuts down.
Please determine the sum of all values of the array at the end of the process.
Input
The first input line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5, 2 ≤ x ≤ 10^9) — the length of the array and the value which is used by the robot.
The next line contains integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the initial values in the array.
It is guaranteed that the sum of values n over all test cases does not exceed 10^5.
Output
For each test case output one integer — the sum of all elements at the end of the process.
Example
Input
2
1 2
12
4 2
4 6 8 2
Output
36
44
Note
In the first test case the array initially consists of a single element [12], and x=2. After the robot processes the first element, the array becomes [12, 6, 6]. Then the robot processes the second element, and the array becomes [12, 6, 6, 3, 3]. After the robot processes the next element, the array becomes [12, 6, 6, 3, 3, 3, 3], and then the robot shuts down, since it encounters an element that is not divisible by x = 2. The sum of the elements in the resulting array is equal to 36.
In the second test case the array initially contains integers [4, 6, 8, 2], and x=2. The resulting array in this case looks like [4, 6, 8, 2, 2, 2, 3, 3, 4, 4, 1, 1, 1, 1, 1, 1]. | instruction | 0 | 10,159 | 22 | 20,318 |
Tags: brute force, greedy, implementation, math
Correct Solution:
```
def main():
t = int(input())
for _ in range(t):
n, x = map(int, input().split())
a = list(map(int, input().split()))
l = []; mx = 0
for i in range(n):
e = a[i]
p = 0
while e % x == 0:
p += 1
e //= x
l.append(p + 1)
if l[i] < l[mx]:
mx = i
#print(l, mx)
suma = sum(a)
total = suma * l[mx]
for j in range(mx):
total += a[j]
print(total)
main()
``` | output | 1 | 10,159 | 22 | 20,319 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have given an array a of length n and an integer x to a brand new robot. What the robot does is the following: it iterates over the elements of the array, let the current element be q. If q is divisible by x, the robot adds x copies of the integer q/x to the end of the array, and moves on to the next element. Note that the newly added elements could be processed by the robot later. Otherwise, if q is not divisible by x, the robot shuts down.
Please determine the sum of all values of the array at the end of the process.
Input
The first input line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5, 2 ≤ x ≤ 10^9) — the length of the array and the value which is used by the robot.
The next line contains integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the initial values in the array.
It is guaranteed that the sum of values n over all test cases does not exceed 10^5.
Output
For each test case output one integer — the sum of all elements at the end of the process.
Example
Input
2
1 2
12
4 2
4 6 8 2
Output
36
44
Note
In the first test case the array initially consists of a single element [12], and x=2. After the robot processes the first element, the array becomes [12, 6, 6]. Then the robot processes the second element, and the array becomes [12, 6, 6, 3, 3]. After the robot processes the next element, the array becomes [12, 6, 6, 3, 3, 3, 3], and then the robot shuts down, since it encounters an element that is not divisible by x = 2. The sum of the elements in the resulting array is equal to 36.
In the second test case the array initially contains integers [4, 6, 8, 2], and x=2. The resulting array in this case looks like [4, 6, 8, 2, 2, 2, 3, 3, 4, 4, 1, 1, 1, 1, 1, 1]. | instruction | 0 | 10,160 | 22 | 20,320 |
Tags: brute force, greedy, implementation, math
Correct Solution:
```
def strangeList(a,x):
i=0
n=len(a)
count=0
flag=0
while True:
j=0
while j<n:
if a[j]%(x**i)==0:
count+=a[j]
else:
return count
j+=1
i+=1
return count
t=int(input())
for i in range(t):
n,x=map(int,input().split())
a=list(map(int,input().split()))
print(strangeList(a,x))
``` | output | 1 | 10,160 | 22 | 20,321 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have given an array a of length n and an integer x to a brand new robot. What the robot does is the following: it iterates over the elements of the array, let the current element be q. If q is divisible by x, the robot adds x copies of the integer q/x to the end of the array, and moves on to the next element. Note that the newly added elements could be processed by the robot later. Otherwise, if q is not divisible by x, the robot shuts down.
Please determine the sum of all values of the array at the end of the process.
Input
The first input line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5, 2 ≤ x ≤ 10^9) — the length of the array and the value which is used by the robot.
The next line contains integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the initial values in the array.
It is guaranteed that the sum of values n over all test cases does not exceed 10^5.
Output
For each test case output one integer — the sum of all elements at the end of the process.
Example
Input
2
1 2
12
4 2
4 6 8 2
Output
36
44
Note
In the first test case the array initially consists of a single element [12], and x=2. After the robot processes the first element, the array becomes [12, 6, 6]. Then the robot processes the second element, and the array becomes [12, 6, 6, 3, 3]. After the robot processes the next element, the array becomes [12, 6, 6, 3, 3, 3, 3], and then the robot shuts down, since it encounters an element that is not divisible by x = 2. The sum of the elements in the resulting array is equal to 36.
In the second test case the array initially contains integers [4, 6, 8, 2], and x=2. The resulting array in this case looks like [4, 6, 8, 2, 2, 2, 3, 3, 4, 4, 1, 1, 1, 1, 1, 1]. | instruction | 0 | 10,161 | 22 | 20,322 |
Tags: brute force, greedy, implementation, math
Correct Solution:
```
for _ in range(int(input())):
n,x=map(int,input().split())
arr=list(map(int,input().split()))
res=0
tmp=arr.copy()
new_arr=[0]*n
for i in range(n):
cnt=0
while arr[i]%x==0:
cnt+=1
arr[i]=arr[i]//x
new_arr[i]=cnt
idx=new_arr.index(min(new_arr))
min_value=min(new_arr)
res=(min_value+1)*sum(tmp)+sum(tmp[:idx])
print(res)
``` | output | 1 | 10,161 | 22 | 20,323 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have given an array a of length n and an integer x to a brand new robot. What the robot does is the following: it iterates over the elements of the array, let the current element be q. If q is divisible by x, the robot adds x copies of the integer q/x to the end of the array, and moves on to the next element. Note that the newly added elements could be processed by the robot later. Otherwise, if q is not divisible by x, the robot shuts down.
Please determine the sum of all values of the array at the end of the process.
Input
The first input line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5, 2 ≤ x ≤ 10^9) — the length of the array and the value which is used by the robot.
The next line contains integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the initial values in the array.
It is guaranteed that the sum of values n over all test cases does not exceed 10^5.
Output
For each test case output one integer — the sum of all elements at the end of the process.
Example
Input
2
1 2
12
4 2
4 6 8 2
Output
36
44
Note
In the first test case the array initially consists of a single element [12], and x=2. After the robot processes the first element, the array becomes [12, 6, 6]. Then the robot processes the second element, and the array becomes [12, 6, 6, 3, 3]. After the robot processes the next element, the array becomes [12, 6, 6, 3, 3, 3, 3], and then the robot shuts down, since it encounters an element that is not divisible by x = 2. The sum of the elements in the resulting array is equal to 36.
In the second test case the array initially contains integers [4, 6, 8, 2], and x=2. The resulting array in this case looks like [4, 6, 8, 2, 2, 2, 3, 3, 4, 4, 1, 1, 1, 1, 1, 1]. | instruction | 0 | 10,162 | 22 | 20,324 |
Tags: brute force, greedy, implementation, math
Correct Solution:
```
# Code Submission
#
# Author : GuptaSir
# Date : 05:01:2021
# Time : 20:14:45
#
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = 'x' in file.mode or 'r' not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b'\n') + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode('ascii'))
self.read = lambda: self.buffer.read().decode('ascii')
self.readline = lambda: self.buffer.readline().decode('ascii')
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')
for _ in range(int(input())):
n, x = map(int, input().split())
a = [*map(int, input().split())]
Ma = max(a)
px = [None for i in range(35)]
px[0] = 1
for i in range(1, 35):
px[i] = px[i - 1] * x
if px[i] > 10 ** 19:
break
px = [i for i in px if i != None]
lpx = len(px)
ac = [None for i in range(n)]
for i in range(n):
j = 1
while True:
if a[i] % px[j] == 0:
j += 1
else:
break
ac[i] = j - 1
ans = 0
mac = min(ac)
mac_reached = False
for i in range(n):
if ac[i] == mac:
mac_reached = True
if mac_reached == False:
ans += (mac + 2) * a[i]
else:
ans += (mac + 1) * a[i]
print(ans)
``` | output | 1 | 10,162 | 22 | 20,325 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have given an array a of length n and an integer x to a brand new robot. What the robot does is the following: it iterates over the elements of the array, let the current element be q. If q is divisible by x, the robot adds x copies of the integer q/x to the end of the array, and moves on to the next element. Note that the newly added elements could be processed by the robot later. Otherwise, if q is not divisible by x, the robot shuts down.
Please determine the sum of all values of the array at the end of the process.
Input
The first input line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5, 2 ≤ x ≤ 10^9) — the length of the array and the value which is used by the robot.
The next line contains integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the initial values in the array.
It is guaranteed that the sum of values n over all test cases does not exceed 10^5.
Output
For each test case output one integer — the sum of all elements at the end of the process.
Example
Input
2
1 2
12
4 2
4 6 8 2
Output
36
44
Note
In the first test case the array initially consists of a single element [12], and x=2. After the robot processes the first element, the array becomes [12, 6, 6]. Then the robot processes the second element, and the array becomes [12, 6, 6, 3, 3]. After the robot processes the next element, the array becomes [12, 6, 6, 3, 3, 3, 3], and then the robot shuts down, since it encounters an element that is not divisible by x = 2. The sum of the elements in the resulting array is equal to 36.
In the second test case the array initially contains integers [4, 6, 8, 2], and x=2. The resulting array in this case looks like [4, 6, 8, 2, 2, 2, 3, 3, 4, 4, 1, 1, 1, 1, 1, 1]. | instruction | 0 | 10,163 | 22 | 20,326 |
Tags: brute force, greedy, implementation, math
Correct Solution:
```
for i in range(int(input())):
n, x = map(int, input().split())
a = list(map(int, input().split()))
ans, mi, midx = 0, 10**10, n - 1
for i in range(n):
y = a[i]
cnt = 0
while(True):
if(y % x):
break
else:
cnt += 1;
y /= x
if(cnt < mi):
mi = cnt
midx = i
for i in a:
ans += (mi + 1) * i
for i in range(midx):
ans += a[i]
print(ans)
``` | output | 1 | 10,163 | 22 | 20,327 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have given an array a of length n and an integer x to a brand new robot. What the robot does is the following: it iterates over the elements of the array, let the current element be q. If q is divisible by x, the robot adds x copies of the integer q/x to the end of the array, and moves on to the next element. Note that the newly added elements could be processed by the robot later. Otherwise, if q is not divisible by x, the robot shuts down.
Please determine the sum of all values of the array at the end of the process.
Input
The first input line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5, 2 ≤ x ≤ 10^9) — the length of the array and the value which is used by the robot.
The next line contains integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the initial values in the array.
It is guaranteed that the sum of values n over all test cases does not exceed 10^5.
Output
For each test case output one integer — the sum of all elements at the end of the process.
Example
Input
2
1 2
12
4 2
4 6 8 2
Output
36
44
Note
In the first test case the array initially consists of a single element [12], and x=2. After the robot processes the first element, the array becomes [12, 6, 6]. Then the robot processes the second element, and the array becomes [12, 6, 6, 3, 3]. After the robot processes the next element, the array becomes [12, 6, 6, 3, 3, 3, 3], and then the robot shuts down, since it encounters an element that is not divisible by x = 2. The sum of the elements in the resulting array is equal to 36.
In the second test case the array initially contains integers [4, 6, 8, 2], and x=2. The resulting array in this case looks like [4, 6, 8, 2, 2, 2, 3, 3, 4, 4, 1, 1, 1, 1, 1, 1]. | instruction | 0 | 10,164 | 22 | 20,328 |
Tags: brute force, greedy, implementation, math
Correct Solution:
```
###pyrival template for fast IO
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
t=int(input())
while t>0:
t-=1
n,x=[int(x) for x in input().split()]
arr=[int(x) for x in input().split()]
count=[0 for x in range(n)]
for i in range(n):
val=arr[i]
c=1
while True:
if val%x==0:
val=val//x
c+=1
else:
count[i]=c
break
s=sum(arr)
index=0;val=count[0]
for i in range(1,n):
if count[i]<val:
index=i
val=count[i]
total=s*val
for i in range(index):
total+=arr[i]
print(total)
``` | output | 1 | 10,164 | 22 | 20,329 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have given an array a of length n and an integer x to a brand new robot. What the robot does is the following: it iterates over the elements of the array, let the current element be q. If q is divisible by x, the robot adds x copies of the integer q/x to the end of the array, and moves on to the next element. Note that the newly added elements could be processed by the robot later. Otherwise, if q is not divisible by x, the robot shuts down.
Please determine the sum of all values of the array at the end of the process.
Input
The first input line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5, 2 ≤ x ≤ 10^9) — the length of the array and the value which is used by the robot.
The next line contains integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the initial values in the array.
It is guaranteed that the sum of values n over all test cases does not exceed 10^5.
Output
For each test case output one integer — the sum of all elements at the end of the process.
Example
Input
2
1 2
12
4 2
4 6 8 2
Output
36
44
Note
In the first test case the array initially consists of a single element [12], and x=2. After the robot processes the first element, the array becomes [12, 6, 6]. Then the robot processes the second element, and the array becomes [12, 6, 6, 3, 3]. After the robot processes the next element, the array becomes [12, 6, 6, 3, 3, 3, 3], and then the robot shuts down, since it encounters an element that is not divisible by x = 2. The sum of the elements in the resulting array is equal to 36.
In the second test case the array initially contains integers [4, 6, 8, 2], and x=2. The resulting array in this case looks like [4, 6, 8, 2, 2, 2, 3, 3, 4, 4, 1, 1, 1, 1, 1, 1]. | instruction | 0 | 10,165 | 22 | 20,330 |
Tags: brute force, greedy, implementation, math
Correct Solution:
```
t=int(input())
for _ in range(t):
l=list(map(int,input().split()))
n,x=l[0],l[1]
l=list(map(int,input().split()))
arr=[]
for i in range(n):
k=0
p=l[i]
while(p%x==0):
k+=1
p=p//x
arr.append(k)
b=min(arr)
f=arr.index(min(arr))
s=0
for i in range(n):
if(i<=f):
d=l[i]
su=l[i]
k=0
while(d%x==0 and k<b+1):
d=d//x
su+=l[i]
k+=1
else:
d=l[i]
su=l[i]
k=0
while(d%x==0 and k<b):
d=d//x
su+=l[i]
k+=1
s+=su
print(s)
``` | output | 1 | 10,165 | 22 | 20,331 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have given an array a of length n and an integer x to a brand new robot. What the robot does is the following: it iterates over the elements of the array, let the current element be q. If q is divisible by x, the robot adds x copies of the integer q/x to the end of the array, and moves on to the next element. Note that the newly added elements could be processed by the robot later. Otherwise, if q is not divisible by x, the robot shuts down.
Please determine the sum of all values of the array at the end of the process.
Input
The first input line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5, 2 ≤ x ≤ 10^9) — the length of the array and the value which is used by the robot.
The next line contains integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the initial values in the array.
It is guaranteed that the sum of values n over all test cases does not exceed 10^5.
Output
For each test case output one integer — the sum of all elements at the end of the process.
Example
Input
2
1 2
12
4 2
4 6 8 2
Output
36
44
Note
In the first test case the array initially consists of a single element [12], and x=2. After the robot processes the first element, the array becomes [12, 6, 6]. Then the robot processes the second element, and the array becomes [12, 6, 6, 3, 3]. After the robot processes the next element, the array becomes [12, 6, 6, 3, 3, 3, 3], and then the robot shuts down, since it encounters an element that is not divisible by x = 2. The sum of the elements in the resulting array is equal to 36.
In the second test case the array initially contains integers [4, 6, 8, 2], and x=2. The resulting array in this case looks like [4, 6, 8, 2, 2, 2, 3, 3, 4, 4, 1, 1, 1, 1, 1, 1]. | instruction | 0 | 10,166 | 22 | 20,332 |
Tags: brute force, greedy, implementation, math
Correct Solution:
```
for _ in range(int(input())):
n, x = [int(i) for i in input().split(' ')]
a = [int(i) for i in input().split(' ')]
m = 0
summ = 0
stop = 0
while True:
for i in a:
if i % x**m == 0:
summ += i
else:
stop = 1
break
m += 1
if stop == 1:
break
print(summ)
``` | output | 1 | 10,166 | 22 | 20,333 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of positive integers a = [a_0, a_1, ..., a_{n - 1}] (n ≥ 2).
In one step, the array a is replaced with another array of length n, in which each element is the [greatest common divisor (GCD)](http://tiny.cc/tuy9uz) of two neighboring elements (the element itself and its right neighbor; consider that the right neighbor of the (n - 1)-th element is the 0-th element).
Formally speaking, a new array b = [b_0, b_1, ..., b_{n - 1}] is being built from array a = [a_0, a_1, ..., a_{n - 1}] such that b_i = \gcd(a_i, a_{(i + 1) mod n}), where \gcd(x, y) is the greatest common divisor of x and y, and x mod y is the remainder of x dividing by y. In one step the array b is built and then the array a is replaced with b (that is, the assignment a := b is taking place).
For example, if a = [16, 24, 10, 5] then b = [\gcd(16, 24), \gcd(24, 10), \gcd(10, 5), \gcd(5, 16)] = [8, 2, 5, 1]. Thus, after one step the array a = [16, 24, 10, 5] will be equal to [8, 2, 5, 1].
For a given array a, find the minimum number of steps after which all values a_i become equal (that is, a_0 = a_1 = ... = a_{n - 1}). If the original array a consists of identical elements then consider the number of steps is equal to 0.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
Each test case contains two lines. The first line contains an integer n (2 ≤ n ≤ 2 ⋅ 10^5) — length of the sequence a. The second line contains n integers a_0, a_1, ..., a_{n - 1} (1 ≤ a_i ≤ 10^6).
It is guaranteed that the sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
Print t numbers — answers for each test case.
Example
Input
5
4
16 24 10 5
4
42 42 42 42
3
4 6 4
5
1 2 3 4 5
6
9 9 27 9 9 63
Output
3
0
2
1
1
Submitted Solution:
```
from collections import defaultdict, Counter
from math import sqrt, log10, log2, log, gcd, floor, factorial
from bisect import bisect_left, bisect_right
from itertools import permutations
import sys, io, os
input = sys.stdin.readline
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
# print=sys.stdout.write
# sys.setrecursionlimit(10000)
inf = float('inf');
mod = 10 ** 9 + 7
def get_list(): return [int(i) for i in input().split()]
yn = lambda a: print("YES" if a else "NO")
ceil = lambda a, b: (a + b - 1) // b
class LazySegmentTree:
def __init__(self, data, default=0, func=max):
"""initialize the lazy segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self._lazy = [0] * (2 * _size)
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __len__(self):
return self._len
def _push(self, idx):
"""push query on idx to its children"""
# Let the children know of the queries
q, self._lazy[idx] = self._lazy[idx], 0
self._lazy[2 * idx] += q
self._lazy[2 * idx + 1] += q
self.data[2 * idx] += q
self.data[2 * idx + 1] += q
def _update(self, idx):
"""updates the node idx to know of all queries applied to it via its ancestors"""
for i in reversed(range(1, idx.bit_length())):
self._push(idx >> i)
def _build(self, idx):
"""make the changes to idx be known to its ancestors"""
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1]) + self._lazy[idx]
idx >>= 1
def add(self, start, stop, value):
"""lazily add value to [start, stop)"""
start = start_copy = start + self._size
stop = stop_copy = stop + self._size
while start < stop:
if start & 1:
self._lazy[start] += value
self.data[start] += value
start += 1
if stop & 1:
stop -= 1
self._lazy[stop] += value
self.data[stop] += value
start >>= 1
stop >>= 1
# Tell all nodes above of the updated area of the updates
self._build(start_copy)
self._build(stop_copy - 1)
def query(self, start, stop, default=0):
"""func of data[start, stop)"""
start += self._size
stop += self._size
# Apply all the lazily stored queries
self._update(start)
self._update(stop - 1)
res = default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "LazySegmentTree({0})".format(self.data)
t=int(input())
for i in range(t):
n=int(input())
l=get_list()
gcda=l[0]
for i in l:
gcda=gcd(i,gcda)
l+=l
s=LazySegmentTree(l,0,gcd)
maxa=0
for i in range(n):
answer=0
low=i;high=i+n
while low<high:
mid=(low+high)//2
if s.query(i,mid+1)==gcda:
high=mid
answer=mid-i
else:
low=mid+1
maxa=max(answer,maxa)
print(maxa)
``` | instruction | 0 | 10,215 | 22 | 20,430 |
Yes | output | 1 | 10,215 | 22 | 20,431 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of positive integers a = [a_0, a_1, ..., a_{n - 1}] (n ≥ 2).
In one step, the array a is replaced with another array of length n, in which each element is the [greatest common divisor (GCD)](http://tiny.cc/tuy9uz) of two neighboring elements (the element itself and its right neighbor; consider that the right neighbor of the (n - 1)-th element is the 0-th element).
Formally speaking, a new array b = [b_0, b_1, ..., b_{n - 1}] is being built from array a = [a_0, a_1, ..., a_{n - 1}] such that b_i = \gcd(a_i, a_{(i + 1) mod n}), where \gcd(x, y) is the greatest common divisor of x and y, and x mod y is the remainder of x dividing by y. In one step the array b is built and then the array a is replaced with b (that is, the assignment a := b is taking place).
For example, if a = [16, 24, 10, 5] then b = [\gcd(16, 24), \gcd(24, 10), \gcd(10, 5), \gcd(5, 16)] = [8, 2, 5, 1]. Thus, after one step the array a = [16, 24, 10, 5] will be equal to [8, 2, 5, 1].
For a given array a, find the minimum number of steps after which all values a_i become equal (that is, a_0 = a_1 = ... = a_{n - 1}). If the original array a consists of identical elements then consider the number of steps is equal to 0.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
Each test case contains two lines. The first line contains an integer n (2 ≤ n ≤ 2 ⋅ 10^5) — length of the sequence a. The second line contains n integers a_0, a_1, ..., a_{n - 1} (1 ≤ a_i ≤ 10^6).
It is guaranteed that the sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
Print t numbers — answers for each test case.
Example
Input
5
4
16 24 10 5
4
42 42 42 42
3
4 6 4
5
1 2 3 4 5
6
9 9 27 9 9 63
Output
3
0
2
1
1
Submitted Solution:
```
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
ans = []
for _ in range(int(input())):
n = int(input())
u = list(map(int, input().split()))
u += u[:]
m = 0
for i in range(n):
k1 = u[i]
k2 = u[i + 1]
c = 0
j = i + 1
while k1 != k2:
k1 = gcd(k1, u[j])
k2 = gcd(k2, u[j + 1])
j += 1
c += 1
m = max(m, c)
ans.append(m)
print('\n'.join(map(str, ans)))
``` | instruction | 0 | 10,216 | 22 | 20,432 |
Yes | output | 1 | 10,216 | 22 | 20,433 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of positive integers a = [a_0, a_1, ..., a_{n - 1}] (n ≥ 2).
In one step, the array a is replaced with another array of length n, in which each element is the [greatest common divisor (GCD)](http://tiny.cc/tuy9uz) of two neighboring elements (the element itself and its right neighbor; consider that the right neighbor of the (n - 1)-th element is the 0-th element).
Formally speaking, a new array b = [b_0, b_1, ..., b_{n - 1}] is being built from array a = [a_0, a_1, ..., a_{n - 1}] such that b_i = \gcd(a_i, a_{(i + 1) mod n}), where \gcd(x, y) is the greatest common divisor of x and y, and x mod y is the remainder of x dividing by y. In one step the array b is built and then the array a is replaced with b (that is, the assignment a := b is taking place).
For example, if a = [16, 24, 10, 5] then b = [\gcd(16, 24), \gcd(24, 10), \gcd(10, 5), \gcd(5, 16)] = [8, 2, 5, 1]. Thus, after one step the array a = [16, 24, 10, 5] will be equal to [8, 2, 5, 1].
For a given array a, find the minimum number of steps after which all values a_i become equal (that is, a_0 = a_1 = ... = a_{n - 1}). If the original array a consists of identical elements then consider the number of steps is equal to 0.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
Each test case contains two lines. The first line contains an integer n (2 ≤ n ≤ 2 ⋅ 10^5) — length of the sequence a. The second line contains n integers a_0, a_1, ..., a_{n - 1} (1 ≤ a_i ≤ 10^6).
It is guaranteed that the sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
Print t numbers — answers for each test case.
Example
Input
5
4
16 24 10 5
4
42 42 42 42
3
4 6 4
5
1 2 3 4 5
6
9 9 27 9 9 63
Output
3
0
2
1
1
Submitted Solution:
```
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
import io
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
from collections import deque
from collections import Counter
import threading
#sys.setrecursionlimit(300000)
#threading.stack_size(10**8)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now-----------------------------------------------------
#mod = 9223372036854775807
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: max(a,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
class SegmentTree1:
def __init__(self, data, default=0, func=lambda a, b: math.gcd(a,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
MOD=10**9+7
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
mod=10**9+7
omod=998244353
#-------------------------------------------------------------------------
prime = [True for i in range(10001)]
prime[0]=prime[1]=False
#pp=[0]*10000
def SieveOfEratosthenes(n=10000):
p = 2
c=0
while (p <= n):
if (prime[p] == True):
c+=1
for i in range(p, n+1, p):
#pp[i]=1
prime[i] = False
p += 1
#-----------------------------------DSU--------------------------------------------------
class DSU:
def __init__(self, R, C):
#R * C is the source, and isn't a grid square
self.par = range(R*C + 1)
self.rnk = [0] * (R*C + 1)
self.sz = [1] * (R*C + 1)
def find(self, x):
if self.par[x] != x:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
xr, yr = self.find(x), self.find(y)
if xr == yr: return
if self.rnk[xr] < self.rnk[yr]:
xr, yr = yr, xr
if self.rnk[xr] == self.rnk[yr]:
self.rnk[xr] += 1
self.par[yr] = xr
self.sz[xr] += self.sz[yr]
def size(self, x):
return self.sz[self.find(x)]
def top(self):
# Size of component at ephemeral "source" node at index R*C,
# minus 1 to not count the source itself in the size
return self.size(len(self.sz) - 1) - 1
#---------------------------------Lazy Segment Tree--------------------------------------
# https://github.com/atcoder/ac-library/blob/master/atcoder/lazysegtree.hpp
class LazySegTree:
def __init__(self, _op, _e, _mapping, _composition, _id, v):
def set(p, x):
assert 0 <= p < _n
p += _size
for i in range(_log, 0, -1):
_push(p >> i)
_d[p] = x
for i in range(1, _log + 1):
_update(p >> i)
def get(p):
assert 0 <= p < _n
p += _size
for i in range(_log, 0, -1):
_push(p >> i)
return _d[p]
def prod(l, r):
assert 0 <= l <= r <= _n
if l == r:
return _e
l += _size
r += _size
for i in range(_log, 0, -1):
if ((l >> i) << i) != l:
_push(l >> i)
if ((r >> i) << i) != r:
_push(r >> i)
sml = _e
smr = _e
while l < r:
if l & 1:
sml = _op(sml, _d[l])
l += 1
if r & 1:
r -= 1
smr = _op(_d[r], smr)
l >>= 1
r >>= 1
return _op(sml, smr)
def apply(l, r, f):
assert 0 <= l <= r <= _n
if l == r:
return
l += _size
r += _size
for i in range(_log, 0, -1):
if ((l >> i) << i) != l:
_push(l >> i)
if ((r >> i) << i) != r:
_push((r - 1) >> i)
l2 = l
r2 = r
while l < r:
if l & 1:
_all_apply(l, f)
l += 1
if r & 1:
r -= 1
_all_apply(r, f)
l >>= 1
r >>= 1
l = l2
r = r2
for i in range(1, _log + 1):
if ((l >> i) << i) != l:
_update(l >> i)
if ((r >> i) << i) != r:
_update((r - 1) >> i)
def _update(k):
_d[k] = _op(_d[2 * k], _d[2 * k + 1])
def _all_apply(k, f):
_d[k] = _mapping(f, _d[k])
if k < _size:
_lz[k] = _composition(f, _lz[k])
def _push(k):
_all_apply(2 * k, _lz[k])
_all_apply(2 * k + 1, _lz[k])
_lz[k] = _id
_n = len(v)
_log = _n.bit_length()
_size = 1 << _log
_d = [_e] * (2 * _size)
_lz = [_id] * _size
for i in range(_n):
_d[_size + i] = v[i]
for i in range(_size - 1, 0, -1):
_update(i)
self.set = set
self.get = get
self.prod = prod
self.apply = apply
MIL = 1 << 20
def makeNode(total, count):
# Pack a pair into a float
return (total * MIL) + count
def getTotal(node):
return math.floor(node / MIL)
def getCount(node):
return node - getTotal(node) * MIL
nodeIdentity = makeNode(0.0, 0.0)
def nodeOp(node1, node2):
return node1 + node2
# Equivalent to the following:
return makeNode(
getTotal(node1) + getTotal(node2), getCount(node1) + getCount(node2)
)
identityMapping = -1
def mapping(tag, node):
if tag == identityMapping:
return node
# If assigned, new total is the number assigned times count
count = getCount(node)
return makeNode(tag * count, count)
def composition(mapping1, mapping2):
# If assigned multiple times, take first non-identity assignment
return mapping1 if mapping1 != identityMapping else mapping2
#---------------------------------Pollard rho--------------------------------------------
def memodict(f):
"""memoization decorator for a function taking a single argument"""
class memodict(dict):
def __missing__(self, key):
ret = self[key] = f(key)
return ret
return memodict().__getitem__
def pollard_rho(n):
"""returns a random factor of n"""
if n & 1 == 0:
return 2
if n % 3 == 0:
return 3
s = ((n - 1) & (1 - n)).bit_length() - 1
d = n >> s
for a in [2, 325, 9375, 28178, 450775, 9780504, 1795265022]:
p = pow(a, d, n)
if p == 1 or p == n - 1 or a % n == 0:
continue
for _ in range(s):
prev = p
p = (p * p) % n
if p == 1:
return math.gcd(prev - 1, n)
if p == n - 1:
break
else:
for i in range(2, n):
x, y = i, (i * i + 1) % n
f = math.gcd(abs(x - y), n)
while f == 1:
x, y = (x * x + 1) % n, (y * y + 1) % n
y = (y * y + 1) % n
f = math.gcd(abs(x - y), n)
if f != n:
return f
return n
@memodict
def prime_factors(n):
"""returns a Counter of the prime factorization of n"""
if n <= 1:
return Counter()
f = pollard_rho(n)
return Counter([n]) if f == n else prime_factors(f) + prime_factors(n // f)
def distinct_factors(n):
"""returns a list of all distinct factors of n"""
factors = [1]
for p, exp in prime_factors(n).items():
factors += [p**i * factor for factor in factors for i in range(1, exp + 1)]
return factors
def all_factors(n):
"""returns a sorted list of all distinct factors of n"""
small, large = [], []
for i in range(1, int(n**0.5) + 1, 2 if n & 1 else 1):
if not n % i:
small.append(i)
large.append(n // i)
if small[-1] == large[-1]:
large.pop()
large.reverse()
small.extend(large)
return small
#---------------------------------Binary Search------------------------------------------
def binarySearch(arr, n, key):
left = 0
right = n-1
mid = 0
res=arr[n-1]
while (left <= right):
mid = (right + left)//2
if (arr[mid] >= key):
res=arr[mid]
right = mid-1
else:
left = mid + 1
return res
def binarySearch1(arr, n, key):
left = 0
right = n-1
mid = 0
res=-1
while (left <= right):
mid = (right + left)//2
if (arr[mid][0] >= key):
right = mid-1
else:
res=mid
left = mid + 1
return res
#---------------------------------running code------------------------------------------
t=1
t=int(input())
for _ in range (t):
n=int(input())
#n,k=map(int,input().split())
a=list(map(int,input().split()))
#tp=list(map(int,input().split()))
#s=input()
a=a+a
s=SegmentTree1(a)
m=0
g=s.query(0, n-1)
j=0
#print(g)
for i in range (n):
j=max(j,i)
#print(i,j)
if j==i:
c=a[i]
else:
c=s.query(i, j)
while c!=g:
#print(c)
j+=1
c=math.gcd(c,a[j])
m=max(m,j-i)
#print(j-i)
print(m)
``` | instruction | 0 | 10,217 | 22 | 20,434 |
Yes | output | 1 | 10,217 | 22 | 20,435 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of positive integers a = [a_0, a_1, ..., a_{n - 1}] (n ≥ 2).
In one step, the array a is replaced with another array of length n, in which each element is the [greatest common divisor (GCD)](http://tiny.cc/tuy9uz) of two neighboring elements (the element itself and its right neighbor; consider that the right neighbor of the (n - 1)-th element is the 0-th element).
Formally speaking, a new array b = [b_0, b_1, ..., b_{n - 1}] is being built from array a = [a_0, a_1, ..., a_{n - 1}] such that b_i = \gcd(a_i, a_{(i + 1) mod n}), where \gcd(x, y) is the greatest common divisor of x and y, and x mod y is the remainder of x dividing by y. In one step the array b is built and then the array a is replaced with b (that is, the assignment a := b is taking place).
For example, if a = [16, 24, 10, 5] then b = [\gcd(16, 24), \gcd(24, 10), \gcd(10, 5), \gcd(5, 16)] = [8, 2, 5, 1]. Thus, after one step the array a = [16, 24, 10, 5] will be equal to [8, 2, 5, 1].
For a given array a, find the minimum number of steps after which all values a_i become equal (that is, a_0 = a_1 = ... = a_{n - 1}). If the original array a consists of identical elements then consider the number of steps is equal to 0.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
Each test case contains two lines. The first line contains an integer n (2 ≤ n ≤ 2 ⋅ 10^5) — length of the sequence a. The second line contains n integers a_0, a_1, ..., a_{n - 1} (1 ≤ a_i ≤ 10^6).
It is guaranteed that the sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
Print t numbers — answers for each test case.
Example
Input
5
4
16 24 10 5
4
42 42 42 42
3
4 6 4
5
1 2 3 4 5
6
9 9 27 9 9 63
Output
3
0
2
1
1
Submitted Solution:
```
from math import *
from collections import *
t = int(input())
def getVal(l, sp, d):
ans = 0
while d:
di = int(log2(d))
ans = gcd(ans, sp[di][l])
di = 2**di
l += di
d -= di
return ans
def isPos(sp, mid, n):
prev = getVal(0, sp, mid)
for i in range(1, n):
if prev != getVal(i, sp, mid):
return 0
return 1
def sparsiTable(a, n):
d = int(log2(n))
sp = []
sp.append([])
# [gcd(a[i], a[i+1]) for i in range(n+n-1)]
for i in range(n+n-1):
sp[-1].append(gcd(a[i], a[i+1]))
for i in range(1, d+1):
di = 2**(i-1)
lst = []
for i in range(n+n):
if i+di < len(sp[-1]):lst.append(gcd(sp[-1][i], sp[-1][i+di]))
sp.append(lst)
return sp
for _ in range(t):
n = int(input())
a = [int(v) for v in input().split()]
f = Counter(a)
if f[a[0]] == n:print(0);continue
for i in range(n):
a.append(a[i])
sp = sparsiTable(a, n)
left, right = 1, n-1
ans = 0
while left <= right:
mid = (left+right)//2
if isPos(sp, mid, n) == 0:
left = mid + 1
else:
right = mid - 1
ans = mid
print(ans)
``` | instruction | 0 | 10,218 | 22 | 20,436 |
Yes | output | 1 | 10,218 | 22 | 20,437 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of positive integers a = [a_0, a_1, ..., a_{n - 1}] (n ≥ 2).
In one step, the array a is replaced with another array of length n, in which each element is the [greatest common divisor (GCD)](http://tiny.cc/tuy9uz) of two neighboring elements (the element itself and its right neighbor; consider that the right neighbor of the (n - 1)-th element is the 0-th element).
Formally speaking, a new array b = [b_0, b_1, ..., b_{n - 1}] is being built from array a = [a_0, a_1, ..., a_{n - 1}] such that b_i = \gcd(a_i, a_{(i + 1) mod n}), where \gcd(x, y) is the greatest common divisor of x and y, and x mod y is the remainder of x dividing by y. In one step the array b is built and then the array a is replaced with b (that is, the assignment a := b is taking place).
For example, if a = [16, 24, 10, 5] then b = [\gcd(16, 24), \gcd(24, 10), \gcd(10, 5), \gcd(5, 16)] = [8, 2, 5, 1]. Thus, after one step the array a = [16, 24, 10, 5] will be equal to [8, 2, 5, 1].
For a given array a, find the minimum number of steps after which all values a_i become equal (that is, a_0 = a_1 = ... = a_{n - 1}). If the original array a consists of identical elements then consider the number of steps is equal to 0.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
Each test case contains two lines. The first line contains an integer n (2 ≤ n ≤ 2 ⋅ 10^5) — length of the sequence a. The second line contains n integers a_0, a_1, ..., a_{n - 1} (1 ≤ a_i ≤ 10^6).
It is guaranteed that the sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
Print t numbers — answers for each test case.
Example
Input
5
4
16 24 10 5
4
42 42 42 42
3
4 6 4
5
1 2 3 4 5
6
9 9 27 9 9 63
Output
3
0
2
1
1
Submitted Solution:
```
import math
class RMQ:
def __init__(self, arr, min_max):
self.cache = [arr]
self.func = min_max
self.precompute(arr, self.func)
def precompute(self, arr, min_max):
max_log = int(math.log2(len(arr)))
for i in range(1, max_log + 1):
new_row = []
for j in range(0, len(arr) - 2 ** i + 1):
new_row.append(min_max(self.cache[i - 1][j],
self.cache[i - 1][j + 2 ** (i - 1)]))
self.cache.append(new_row)
# should be equal to min(arr[l:r]) care l == r, plus minus 1 error
def query(self, l, r):
if l == r:
return self.cache[0][l]
if l > r:
return self.func(self.query(l,n), self.query(0,r))
log_val = int(math.log2(r - l))
return self.func(self.cache[log_val][l],
self.cache[log_val][r - 2 ** log_val])
def solve(n,seq):
rmq = RMQ(seq, math.gcd)
min_all = rmq.query(0,n)
max_op = 0
cur = 0
while cur < n:
if seq[cur] == min_all:
cur+=1
continue
for i in range(1,n+1):
if (cur+i)%n+1 == cur:
res1 = min_all
else:
res1= rmq.query(cur, (cur+i)%n+1)
if res1 == min_all:
if i > max_op:
max_op=i
break
cur = cur+i
return max_op
import os
import io
# import time
# a=time.time()
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
T = int(input().decode().strip())
for t in range(T):
n = int(input().decode().strip())
seq=[int(x) for x in input().decode().strip().split(" ")]
res = solve(n,seq)
print(res)
``` | instruction | 0 | 10,219 | 22 | 20,438 |
No | output | 1 | 10,219 | 22 | 20,439 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of positive integers a = [a_0, a_1, ..., a_{n - 1}] (n ≥ 2).
In one step, the array a is replaced with another array of length n, in which each element is the [greatest common divisor (GCD)](http://tiny.cc/tuy9uz) of two neighboring elements (the element itself and its right neighbor; consider that the right neighbor of the (n - 1)-th element is the 0-th element).
Formally speaking, a new array b = [b_0, b_1, ..., b_{n - 1}] is being built from array a = [a_0, a_1, ..., a_{n - 1}] such that b_i = \gcd(a_i, a_{(i + 1) mod n}), where \gcd(x, y) is the greatest common divisor of x and y, and x mod y is the remainder of x dividing by y. In one step the array b is built and then the array a is replaced with b (that is, the assignment a := b is taking place).
For example, if a = [16, 24, 10, 5] then b = [\gcd(16, 24), \gcd(24, 10), \gcd(10, 5), \gcd(5, 16)] = [8, 2, 5, 1]. Thus, after one step the array a = [16, 24, 10, 5] will be equal to [8, 2, 5, 1].
For a given array a, find the minimum number of steps after which all values a_i become equal (that is, a_0 = a_1 = ... = a_{n - 1}). If the original array a consists of identical elements then consider the number of steps is equal to 0.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
Each test case contains two lines. The first line contains an integer n (2 ≤ n ≤ 2 ⋅ 10^5) — length of the sequence a. The second line contains n integers a_0, a_1, ..., a_{n - 1} (1 ≤ a_i ≤ 10^6).
It is guaranteed that the sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
Print t numbers — answers for each test case.
Example
Input
5
4
16 24 10 5
4
42 42 42 42
3
4 6 4
5
1 2 3 4 5
6
9 9 27 9 9 63
Output
3
0
2
1
1
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#######################################
from math import gcd
for t in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
l.append(l[0])
g=0
for i in l:
g=gcd(g,i)
ans=0
i=0
while i<=n:
a=l[i]
c=0
while a!=g:
i+=1
c+=1
if i>n:
break
a=gcd(a,l[i])
i+=1
ans=max(ans,c)
print(ans)
``` | instruction | 0 | 10,220 | 22 | 20,440 |
No | output | 1 | 10,220 | 22 | 20,441 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of positive integers a = [a_0, a_1, ..., a_{n - 1}] (n ≥ 2).
In one step, the array a is replaced with another array of length n, in which each element is the [greatest common divisor (GCD)](http://tiny.cc/tuy9uz) of two neighboring elements (the element itself and its right neighbor; consider that the right neighbor of the (n - 1)-th element is the 0-th element).
Formally speaking, a new array b = [b_0, b_1, ..., b_{n - 1}] is being built from array a = [a_0, a_1, ..., a_{n - 1}] such that b_i = \gcd(a_i, a_{(i + 1) mod n}), where \gcd(x, y) is the greatest common divisor of x and y, and x mod y is the remainder of x dividing by y. In one step the array b is built and then the array a is replaced with b (that is, the assignment a := b is taking place).
For example, if a = [16, 24, 10, 5] then b = [\gcd(16, 24), \gcd(24, 10), \gcd(10, 5), \gcd(5, 16)] = [8, 2, 5, 1]. Thus, after one step the array a = [16, 24, 10, 5] will be equal to [8, 2, 5, 1].
For a given array a, find the minimum number of steps after which all values a_i become equal (that is, a_0 = a_1 = ... = a_{n - 1}). If the original array a consists of identical elements then consider the number of steps is equal to 0.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
Each test case contains two lines. The first line contains an integer n (2 ≤ n ≤ 2 ⋅ 10^5) — length of the sequence a. The second line contains n integers a_0, a_1, ..., a_{n - 1} (1 ≤ a_i ≤ 10^6).
It is guaranteed that the sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
Print t numbers — answers for each test case.
Example
Input
5
4
16 24 10 5
4
42 42 42 42
3
4 6 4
5
1 2 3 4 5
6
9 9 27 9 9 63
Output
3
0
2
1
1
Submitted Solution:
```
import math
t = int(input())
for i in range(t):
n = int(input())
a = list(map(int, input().split()))
suc, ans = 0, 0
for j in range(n):
if a[j] != a[0]:
break
if j == n-1:
print(0)
continue
while 1:
ans = ans + 1
b, suc = [], 1
for j in range(n):
if j == 0:
bj = math.gcd(a[0],a[1])
b.append(bj)
u = bj
elif j != n-1:
bj = math.gcd(a[j],a[j+1])
b.append(bj)
if bj != u:
suc = 0
else:
bj = math.gcd(a[n-1],a[0])
b.append(bj)
if bj != u:
suc = 0
if suc:
print(ans)
break
a = b[0:n]
``` | instruction | 0 | 10,221 | 22 | 20,442 |
No | output | 1 | 10,221 | 22 | 20,443 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of positive integers a = [a_0, a_1, ..., a_{n - 1}] (n ≥ 2).
In one step, the array a is replaced with another array of length n, in which each element is the [greatest common divisor (GCD)](http://tiny.cc/tuy9uz) of two neighboring elements (the element itself and its right neighbor; consider that the right neighbor of the (n - 1)-th element is the 0-th element).
Formally speaking, a new array b = [b_0, b_1, ..., b_{n - 1}] is being built from array a = [a_0, a_1, ..., a_{n - 1}] such that b_i = \gcd(a_i, a_{(i + 1) mod n}), where \gcd(x, y) is the greatest common divisor of x and y, and x mod y is the remainder of x dividing by y. In one step the array b is built and then the array a is replaced with b (that is, the assignment a := b is taking place).
For example, if a = [16, 24, 10, 5] then b = [\gcd(16, 24), \gcd(24, 10), \gcd(10, 5), \gcd(5, 16)] = [8, 2, 5, 1]. Thus, after one step the array a = [16, 24, 10, 5] will be equal to [8, 2, 5, 1].
For a given array a, find the minimum number of steps after which all values a_i become equal (that is, a_0 = a_1 = ... = a_{n - 1}). If the original array a consists of identical elements then consider the number of steps is equal to 0.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
Each test case contains two lines. The first line contains an integer n (2 ≤ n ≤ 2 ⋅ 10^5) — length of the sequence a. The second line contains n integers a_0, a_1, ..., a_{n - 1} (1 ≤ a_i ≤ 10^6).
It is guaranteed that the sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
Print t numbers — answers for each test case.
Example
Input
5
4
16 24 10 5
4
42 42 42 42
3
4 6 4
5
1 2 3 4 5
6
9 9 27 9 9 63
Output
3
0
2
1
1
Submitted Solution:
```
import sys,os,io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
# input = sys.stdin.readline
from math import gcd
def fun(a):
na = [a[0]]
cnt = 0
f = 0
for i in range (1,len(a)):
if na[-1]!=a[i]:
cnt = 0
na.append(a[i])
else:
if a[i]!=g:
cnt += 1
f = max(f,cnt)
return [na,f]
t = int(input())
for _ in range (t):
n = int(input())
a = [int(i) for i in input().split()]
n = len(a)
g = a[0]
for i in a:
g = gcd(i,g)
flag = 0
for i in a:
if i!=g:
flag = 1
break
a,ans = fun(a)
while(flag):
ans+=1
flag = 0
na = [0]*len(a)
for i in range (len(a)):
i1 = (i+1)%len(a)
na[i] = gcd(a[i], a[i1])
if na[i]!=g:
flag = 1
a = na[:]
print(ans)
``` | instruction | 0 | 10,222 | 22 | 20,444 |
No | output | 1 | 10,222 | 22 | 20,445 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Btoh yuo adn yuor roomatme lhoate wianshg disehs, btu stlil sdmoeboy msut peorrfm tihs cohre dialy. Oen dya yuo decdie to idourtcne smoe syestm. Yuor rmmotaoe sstgegus teh fooniwllg dael. Yuo argee on tow arayrs of ientgres M adn R, nmebur upmicnog dyas (induiclng teh cunrret oen) wtih sicsescuve irnegets (teh ceurrnt dya is zreo), adn yuo wsah teh diehss on dya D if adn olny if terhe etsixs an iednx i scuh taht D mod M[i] = R[i], otwsehrie yuor rmootmae deos it. Yuo lkie teh cncepot, btu yuor rmotaome's cuinnng simle meaks yuo ssecupt sthnoemig, so yuo itennd to vefriy teh fnerisas of teh aemnrgeet.
Yuo aer geivn ayarrs M adn R. Cuaclatle teh pceanregte of dyas on wchih yuo edn up dnoig teh wisahng. Amsuse taht yuo hvae iiiftlneny mnay dyas aehad of yuo.
Input
The first line of input contains a single integer N (1 ≤ N ≤ 16).
The second and third lines of input contain N integers each, all between 0 and 16, inclusive, and represent arrays M and R, respectively. All M[i] are positive, for each i R[i] < M[i].
Output
Output a single real number. The answer is considered to be correct if its absolute or relative error does not exceed 10 - 4.
Examples
Input
1
2
0
Output
0.500000
Input
2
2 3
1 0
Output
0.666667 | instruction | 0 | 11,225 | 22 | 22,450 |
Tags: *special, implementation
Correct Solution:
```
from fractions import gcd
from functools import reduce
from operator import mul
n = int(input())
m = [int(x) for x in input().split()]
r = [int(x) for x in input().split()]
lcm = m[0]
if len(m) > 1:
lcm = reduce(mul, m, 1) // reduce(gcd, m, 0)
res = 0
for d in range(min(lcm, 100000)):
for i in range(n):
if d % m[i] == r[i]:
res += 1
break
print(res / min(lcm, 100000))
``` | output | 1 | 11,225 | 22 | 22,451 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n integers a1, a2, ..., an. Find the number of pairs of indexes i, j (i < j) that ai + aj is a power of 2 (i. e. some integer x exists so that ai + aj = 2x).
Input
The first line contains the single positive integer n (1 ≤ n ≤ 105) — the number of integers.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
Print the number of pairs of indexes i, j (i < j) that ai + aj is a power of 2.
Examples
Input
4
7 3 2 1
Output
2
Input
3
1 1 1
Output
3
Note
In the first example the following pairs of indexes include in answer: (1, 4) and (2, 4).
In the second example all pairs of indexes (i, j) (where i < j) include in answer. | instruction | 0 | 11,243 | 22 | 22,486 |
Tags: brute force, data structures, implementation, math
Correct Solution:
```
R = lambda: map(int, input().split())
n = int(input())
res = 0
vsts = {}
for num in R():
res += sum(vsts.get((1 << pwr) - num, 0) for pwr in range(32))
vsts[num] = vsts.get(num, 0) + 1
print(res)
``` | output | 1 | 11,243 | 22 | 22,487 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n integers a1, a2, ..., an. Find the number of pairs of indexes i, j (i < j) that ai + aj is a power of 2 (i. e. some integer x exists so that ai + aj = 2x).
Input
The first line contains the single positive integer n (1 ≤ n ≤ 105) — the number of integers.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
Print the number of pairs of indexes i, j (i < j) that ai + aj is a power of 2.
Examples
Input
4
7 3 2 1
Output
2
Input
3
1 1 1
Output
3
Note
In the first example the following pairs of indexes include in answer: (1, 4) and (2, 4).
In the second example all pairs of indexes (i, j) (where i < j) include in answer. | instruction | 0 | 11,244 | 22 | 22,488 |
Tags: brute force, data structures, implementation, math
Correct Solution:
```
from collections import Counter
n = int(input())
arr = list(map(int, input().split()))
cnt = Counter()
ans = 0
for v in arr:
for i in range(32):
ans += cnt[2 ** i - v]
cnt[v] += 1
print(ans)
``` | output | 1 | 11,244 | 22 | 22,489 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n integers a1, a2, ..., an. Find the number of pairs of indexes i, j (i < j) that ai + aj is a power of 2 (i. e. some integer x exists so that ai + aj = 2x).
Input
The first line contains the single positive integer n (1 ≤ n ≤ 105) — the number of integers.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
Print the number of pairs of indexes i, j (i < j) that ai + aj is a power of 2.
Examples
Input
4
7 3 2 1
Output
2
Input
3
1 1 1
Output
3
Note
In the first example the following pairs of indexes include in answer: (1, 4) and (2, 4).
In the second example all pairs of indexes (i, j) (where i < j) include in answer. | instruction | 0 | 11,245 | 22 | 22,490 |
Tags: brute force, data structures, implementation, math
Correct Solution:
```
n = int(input())
a = [int(x) for x in input().split()]
p2 = [2**i for i in range(31)]
d = {}
for i in a:
if i in d:
d[i] += 1
else:
d[i] = 1
k = 0
for i in d:
for p in p2:
j = p - i
if j > i:
break
if j in d:
if i == j:
k += d[i] * (d[i] - 1) // 2
else:
k += d[i] * d[j]
print(k)
``` | output | 1 | 11,245 | 22 | 22,491 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n integers a1, a2, ..., an. Find the number of pairs of indexes i, j (i < j) that ai + aj is a power of 2 (i. e. some integer x exists so that ai + aj = 2x).
Input
The first line contains the single positive integer n (1 ≤ n ≤ 105) — the number of integers.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
Print the number of pairs of indexes i, j (i < j) that ai + aj is a power of 2.
Examples
Input
4
7 3 2 1
Output
2
Input
3
1 1 1
Output
3
Note
In the first example the following pairs of indexes include in answer: (1, 4) and (2, 4).
In the second example all pairs of indexes (i, j) (where i < j) include in answer. | instruction | 0 | 11,246 | 22 | 22,492 |
Tags: brute force, data structures, implementation, math
Correct Solution:
```
n = int(input())
l = list(map(int, input().split()))
dic = {}
for i in range(n):
x = l[i]
dic[x] = 0
for i in range(n):
x = l[i]
dic[x] += 1
s = max(l)
m = 0
num = 0
while 2 ** m <= s:
m += 1
for i in range(n):
a = l[i]
for j in range(1, m + 1):
b = 2 ** j - a
if b in dic:
if b == a:
num += dic[b] - 1
else:
num += dic[b]
num = int(num/2)
print(num)
``` | output | 1 | 11,246 | 22 | 22,493 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n integers a1, a2, ..., an. Find the number of pairs of indexes i, j (i < j) that ai + aj is a power of 2 (i. e. some integer x exists so that ai + aj = 2x).
Input
The first line contains the single positive integer n (1 ≤ n ≤ 105) — the number of integers.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
Print the number of pairs of indexes i, j (i < j) that ai + aj is a power of 2.
Examples
Input
4
7 3 2 1
Output
2
Input
3
1 1 1
Output
3
Note
In the first example the following pairs of indexes include in answer: (1, 4) and (2, 4).
In the second example all pairs of indexes (i, j) (where i < j) include in answer. | instruction | 0 | 11,247 | 22 | 22,494 |
Tags: brute force, data structures, implementation, math
Correct Solution:
```
t = input
p = print
r = range
n = int(t())
a = list(map(int, t().split()))
c = 0
co = {x: 0 for x in range(100000)}
po = [2 ** x for x in range(33)]
for i in range(n):
if a[i] in co:
c += co.get(a[i])
for j in range(len(po)):
if a[i] < po[j]:
co.update({po[j] - a[i]: co.get(po[j] - a[i], 0) + 1})
p(c)
``` | output | 1 | 11,247 | 22 | 22,495 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n integers a1, a2, ..., an. Find the number of pairs of indexes i, j (i < j) that ai + aj is a power of 2 (i. e. some integer x exists so that ai + aj = 2x).
Input
The first line contains the single positive integer n (1 ≤ n ≤ 105) — the number of integers.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
Print the number of pairs of indexes i, j (i < j) that ai + aj is a power of 2.
Examples
Input
4
7 3 2 1
Output
2
Input
3
1 1 1
Output
3
Note
In the first example the following pairs of indexes include in answer: (1, 4) and (2, 4).
In the second example all pairs of indexes (i, j) (where i < j) include in answer. | instruction | 0 | 11,248 | 22 | 22,496 |
Tags: brute force, data structures, implementation, math
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
dic={}
for i in a:
if i in dic:
dic[i]+=1
else:
dic[i]=1
div=0
for i in range(n):
dic[a[i]]-=1
for j in range(1,32):
if 2**j - a[i] in dic:
div+=dic[2**j-a[i]]
print(abs(div))
``` | output | 1 | 11,248 | 22 | 22,497 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n integers a1, a2, ..., an. Find the number of pairs of indexes i, j (i < j) that ai + aj is a power of 2 (i. e. some integer x exists so that ai + aj = 2x).
Input
The first line contains the single positive integer n (1 ≤ n ≤ 105) — the number of integers.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
Print the number of pairs of indexes i, j (i < j) that ai + aj is a power of 2.
Examples
Input
4
7 3 2 1
Output
2
Input
3
1 1 1
Output
3
Note
In the first example the following pairs of indexes include in answer: (1, 4) and (2, 4).
In the second example all pairs of indexes (i, j) (where i < j) include in answer. | instruction | 0 | 11,249 | 22 | 22,498 |
Tags: brute force, data structures, implementation, math
Correct Solution:
```
import io, os
import sys
from atexit import register
from random import randint
DEBUG = False
if not DEBUG:
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
sys.stdout = io.BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))
tokens = []
tokens_next = 0
def nextStr():
global tokens, tokens_next
while tokens_next >= len(tokens):
tokens = input().split()
tokens_next = 0
tokens_next += 1
if type(tokens[tokens_next - 1]) == str:
return tokens[tokens_next - 1]
return tokens[tokens_next - 1].decode()
def nextInt():
return int(nextStr())
def nextIntArr(n):
return [nextInt() for i in range(n)]
def print(s, end='\n'):
sys.stdout.write((str(s) + end).encode())
def isPowerOf2(n):
while n % 2 == 0:
n //= 2
return n == 1
def bruteforce(a):
res = 0
for i in range(len(a)):
for j in range(i + 1, len(a)):
if isPowerOf2(a[i] + a[j]):
res += 1
break
return res
def genTestCase():
n = randint(1, 20)
return [randint(1, 10**9) for _ in range(n)]
def solve(a):
powers = [2**i for i in range(50)]
res = 0
seen = {}
for i in a:
for p in powers:
res += seen.get(p - i, 0)
seen[i] = seen.get(i, 0) + 1
return res
# while True:
# cur = genTestCase()
# soln1 = solve(cur)
# soln2 = bruteforce(cur)
# if soln1 != soln2:
# print('### found one')
# print(' '.join(map(str, cur)))
# print(f'{soln1} but should be {soln2}')
# exit(0)
if __name__ == "__main__":
a = nextIntArr(nextInt())
print(solve(a))
``` | output | 1 | 11,249 | 22 | 22,499 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.