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 a positive integer n, it is guaranteed that n is even (i.e. divisible by 2).
You want to construct the array a of length n such that:
* The first n/2 elements of a are even (divisible by 2);
* the second n/2 elements of a are odd (not divisible by 2);
* all elements of a are distinct and positive;
* the sum of the first half equals to the sum of the second half (∑_{i=1}^{n/2} a_i = ∑_{i=n/2 + 1}^{n} a_i).
If there are multiple answers, you can print any. It is not guaranteed that the answer exists.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the length of the array. It is guaranteed that that n is even (i.e. divisible by 2).
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — "NO" (without quotes), if there is no suitable answer for the given test case or "YES" in the first line and any suitable array a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) satisfying conditions from the problem statement on the second line.
Example
Input
5
2
4
6
8
10
Output
NO
YES
2 4 1 5
NO
YES
2 4 6 8 1 3 5 11
NO | instruction | 0 | 69,088 | 22 | 138,176 |
Tags: constructive algorithms, math
Correct Solution:
```
for t in range(int(input())):
n=int(input())
if((n//2)%2==1):
print("NO")
else:
l=[]
i=2
j=0
while(i<=n):
l.append(i)
i+=2
j+=2
i=1
while(i<j-1):
l.append(i)
i+=2
l.append(n+(j//2)-1)
print("YES")
for i in l:
print(i,end=" ")
``` | output | 1 | 69,088 | 22 | 138,177 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer n, it is guaranteed that n is even (i.e. divisible by 2).
You want to construct the array a of length n such that:
* The first n/2 elements of a are even (divisible by 2);
* the second n/2 elements of a are odd (not divisible by 2);
* all elements of a are distinct and positive;
* the sum of the first half equals to the sum of the second half (∑_{i=1}^{n/2} a_i = ∑_{i=n/2 + 1}^{n} a_i).
If there are multiple answers, you can print any. It is not guaranteed that the answer exists.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the length of the array. It is guaranteed that that n is even (i.e. divisible by 2).
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — "NO" (without quotes), if there is no suitable answer for the given test case or "YES" in the first line and any suitable array a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) satisfying conditions from the problem statement on the second line.
Example
Input
5
2
4
6
8
10
Output
NO
YES
2 4 1 5
NO
YES
2 4 6 8 1 3 5 11
NO | instruction | 0 | 69,089 | 22 | 138,178 |
Tags: constructive algorithms, math
Correct Solution:
```
for t in range(int(input())):
n= int(input())
if n%4==0:
print("YES")
a=2
b=1
while a<=n:
print(a,end=' ');
a+=2
while b<n-1:
print(b,end=' ');
b+=2
print( 3*n//2 -1)
else:
print("NO")
``` | output | 1 | 69,089 | 22 | 138,179 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer n, it is guaranteed that n is even (i.e. divisible by 2).
You want to construct the array a of length n such that:
* The first n/2 elements of a are even (divisible by 2);
* the second n/2 elements of a are odd (not divisible by 2);
* all elements of a are distinct and positive;
* the sum of the first half equals to the sum of the second half (∑_{i=1}^{n/2} a_i = ∑_{i=n/2 + 1}^{n} a_i).
If there are multiple answers, you can print any. It is not guaranteed that the answer exists.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the length of the array. It is guaranteed that that n is even (i.e. divisible by 2).
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — "NO" (without quotes), if there is no suitable answer for the given test case or "YES" in the first line and any suitable array a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) satisfying conditions from the problem statement on the second line.
Example
Input
5
2
4
6
8
10
Output
NO
YES
2 4 1 5
NO
YES
2 4 6 8 1 3 5 11
NO | instruction | 0 | 69,090 | 22 | 138,180 |
Tags: constructive algorithms, math
Correct Solution:
```
from sys import stdin,stdout
for testcases in range(int(stdin.readline())):
n=int(stdin.readline())
if (n*(n+1))//2 %2==0:
arr=[]
for i in range(n//2):
arr.append(2*(i+1))
sumarr=sum(arr)
summ=0
for i in range(1,n-1):
if i%2!=0:
arr.append(i)
summ+=i
arr.append(sumarr - summ)
print('YES')
print(*arr)
else:
print('NO')
``` | output | 1 | 69,090 | 22 | 138,181 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer n, it is guaranteed that n is even (i.e. divisible by 2).
You want to construct the array a of length n such that:
* The first n/2 elements of a are even (divisible by 2);
* the second n/2 elements of a are odd (not divisible by 2);
* all elements of a are distinct and positive;
* the sum of the first half equals to the sum of the second half (∑_{i=1}^{n/2} a_i = ∑_{i=n/2 + 1}^{n} a_i).
If there are multiple answers, you can print any. It is not guaranteed that the answer exists.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the length of the array. It is guaranteed that that n is even (i.e. divisible by 2).
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — "NO" (without quotes), if there is no suitable answer for the given test case or "YES" in the first line and any suitable array a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) satisfying conditions from the problem statement on the second line.
Example
Input
5
2
4
6
8
10
Output
NO
YES
2 4 1 5
NO
YES
2 4 6 8 1 3 5 11
NO | instruction | 0 | 69,091 | 22 | 138,182 |
Tags: constructive algorithms, math
Correct Solution:
```
n = int(input())
for i in range(n):
a = int(input())
if a %4==0:
print("YES")
fh = [int(i) for i in range(1, a + 1) if i % 2 == 0]
sh = [int(i) for i in range(a) if i % 2 != 0]
sh[-1]= sh[-1] + int(a / 2)
print(*fh,*sh)
else:
print("NO")
``` | output | 1 | 69,091 | 22 | 138,183 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer n, it is guaranteed that n is even (i.e. divisible by 2).
You want to construct the array a of length n such that:
* The first n/2 elements of a are even (divisible by 2);
* the second n/2 elements of a are odd (not divisible by 2);
* all elements of a are distinct and positive;
* the sum of the first half equals to the sum of the second half (∑_{i=1}^{n/2} a_i = ∑_{i=n/2 + 1}^{n} a_i).
If there are multiple answers, you can print any. It is not guaranteed that the answer exists.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the length of the array. It is guaranteed that that n is even (i.e. divisible by 2).
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — "NO" (without quotes), if there is no suitable answer for the given test case or "YES" in the first line and any suitable array a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) satisfying conditions from the problem statement on the second line.
Example
Input
5
2
4
6
8
10
Output
NO
YES
2 4 1 5
NO
YES
2 4 6 8 1 3 5 11
NO | instruction | 0 | 69,092 | 22 | 138,184 |
Tags: constructive algorithms, math
Correct Solution:
```
for t in range(int(input())):
n = int(input())
if (n // 2) % 2 == 1:
print("NO")
else:
print("YES")
a = []
j = 2
s1 = 0
for i in range(n // 2):
a.append(j)
j += 2
s1 += j
j = 1
s2 = 0
for i in range((n // 2) - 1):
a.append(j)
j += 2
s2 += j
a.append(s1 - s2 - 2)
print(*a)
``` | output | 1 | 69,092 | 22 | 138,185 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer n, it is guaranteed that n is even (i.e. divisible by 2).
You want to construct the array a of length n such that:
* The first n/2 elements of a are even (divisible by 2);
* the second n/2 elements of a are odd (not divisible by 2);
* all elements of a are distinct and positive;
* the sum of the first half equals to the sum of the second half (∑_{i=1}^{n/2} a_i = ∑_{i=n/2 + 1}^{n} a_i).
If there are multiple answers, you can print any. It is not guaranteed that the answer exists.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the length of the array. It is guaranteed that that n is even (i.e. divisible by 2).
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — "NO" (without quotes), if there is no suitable answer for the given test case or "YES" in the first line and any suitable array a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) satisfying conditions from the problem statement on the second line.
Example
Input
5
2
4
6
8
10
Output
NO
YES
2 4 1 5
NO
YES
2 4 6 8 1 3 5 11
NO | instruction | 0 | 69,093 | 22 | 138,186 |
Tags: constructive algorithms, math
Correct Solution:
```
def solve(n):
list=[]
if int(n/2)%2!=0:
print('NO')
else:
print('YES')
for i in range(1,int(n/2)+1):
list.append(2*i)
for i in range(0,int(n/2)-1):
list.append(1+(i*2))
k=int(n/2)*(int(n/2)+1)-((int(n/2)-1)**2)
list.append(k)
print(*list, sep=' ')
test_cases = int(input())
list1=[]
for i in range(test_cases):
list1.append(int(input()))
for i in range(test_cases):
solve(list1[i])
``` | output | 1 | 69,093 | 22 | 138,187 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer n, it is guaranteed that n is even (i.e. divisible by 2).
You want to construct the array a of length n such that:
* The first n/2 elements of a are even (divisible by 2);
* the second n/2 elements of a are odd (not divisible by 2);
* all elements of a are distinct and positive;
* the sum of the first half equals to the sum of the second half (∑_{i=1}^{n/2} a_i = ∑_{i=n/2 + 1}^{n} a_i).
If there are multiple answers, you can print any. It is not guaranteed that the answer exists.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the length of the array. It is guaranteed that that n is even (i.e. divisible by 2).
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — "NO" (without quotes), if there is no suitable answer for the given test case or "YES" in the first line and any suitable array a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) satisfying conditions from the problem statement on the second line.
Example
Input
5
2
4
6
8
10
Output
NO
YES
2 4 1 5
NO
YES
2 4 6 8 1 3 5 11
NO | instruction | 0 | 69,094 | 22 | 138,188 |
Tags: constructive algorithms, math
Correct Solution:
```
# ===============================================================================================
# importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import *
from copy import *
from collections import deque
from collections import Counter as counter # Counter(list) return a dict with {key: count}
from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
from itertools import permutations as permutate
from bisect import bisect_left as bl
# If the element is already present in the list,
# the left most position where element has to be inserted is returned.
from bisect import bisect_right as br
from bisect import bisect
# If the element is already present in the list,
# the right most position where element has to be inserted is returned
# ==============================================================================================
# fast I/O region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
# ===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
# ===============================================================================================
# some shortcuts
mod = 1000000007
def inp(): return sys.stdin.readline().rstrip("\r\n") # for fast input
def out(var): sys.stdout.write(str(var)) # for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
def zerolist(n): return [0] * n
def nextline(): out("\n") # as stdout.write always print sring.
def testcase(t):
for p in range(t):
solve()
def printlist(a):
for p in range(0, len(a)):
out(str(a[p]) + ' ')
def solve():
n=int(inp())
if n%4==0:
print("YES")
s=0
for i in range(2,n+1,2):
print(i,end=" ")
s+=i
for i in range(1,n-1,2):
print(i,end=" ")
s-=i
print(s)
else:
print("NO")
testcase(int(inp()))
``` | output | 1 | 69,094 | 22 | 138,189 |
Provide tags and a correct Python 2 solution for this coding contest problem.
You are given a positive integer n, it is guaranteed that n is even (i.e. divisible by 2).
You want to construct the array a of length n such that:
* The first n/2 elements of a are even (divisible by 2);
* the second n/2 elements of a are odd (not divisible by 2);
* all elements of a are distinct and positive;
* the sum of the first half equals to the sum of the second half (∑_{i=1}^{n/2} a_i = ∑_{i=n/2 + 1}^{n} a_i).
If there are multiple answers, you can print any. It is not guaranteed that the answer exists.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the length of the array. It is guaranteed that that n is even (i.e. divisible by 2).
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — "NO" (without quotes), if there is no suitable answer for the given test case or "YES" in the first line and any suitable array a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) satisfying conditions from the problem statement on the second line.
Example
Input
5
2
4
6
8
10
Output
NO
YES
2 4 1 5
NO
YES
2 4 6 8 1 3 5 11
NO | instruction | 0 | 69,095 | 22 | 138,190 |
Tags: constructive algorithms, math
Correct Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
#from itertools import permutations, combinations
raw_input = stdin.readline
pr = stdout.write
def in_num():
return int(raw_input())
def in_arr():
return map(int,raw_input().split())
def pr_num(n):
stdout.write(str(n)+'\n')
def pr_arr(arr):
pr(' '.join(map(str,arr))+'\n')
# fast read function for total integer input
def inp():
# this function returns whole input of
# space/line seperated integers
# Use Ctrl+D to flush stdin.
return stdin.read().split()
range = xrange # not for python 3.0+
# main code
for t in range(in_num()):
n,k=in_arr()
l=in_arr()
dp=[0 for i in range(2*k+5)]
for i in range(n/2):
v1=l[i]
v2=l[n-i-1]
dp[min(v1,v2)+1]-=1
dp[v1+v2]-=1
dp[v1+v2+1]+=1
dp[max(v1,v2)+k+1]+=1
temp=n
ans=temp
for i in range(2,2*k+1):
temp+=dp[i]
ans=min(ans,temp)
pr_num(ans)
``` | output | 1 | 69,095 | 22 | 138,191 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a positive integer n, it is guaranteed that n is even (i.e. divisible by 2).
You want to construct the array a of length n such that:
* The first n/2 elements of a are even (divisible by 2);
* the second n/2 elements of a are odd (not divisible by 2);
* all elements of a are distinct and positive;
* the sum of the first half equals to the sum of the second half (∑_{i=1}^{n/2} a_i = ∑_{i=n/2 + 1}^{n} a_i).
If there are multiple answers, you can print any. It is not guaranteed that the answer exists.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the length of the array. It is guaranteed that that n is even (i.e. divisible by 2).
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — "NO" (without quotes), if there is no suitable answer for the given test case or "YES" in the first line and any suitable array a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) satisfying conditions from the problem statement on the second line.
Example
Input
5
2
4
6
8
10
Output
NO
YES
2 4 1 5
NO
YES
2 4 6 8 1 3 5 11
NO
Submitted Solution:
```
def solve():
T = int(input())
for t in range(T):
n = int(input()) # even
#odd + odd = even
#odd + even = odd
#even + even = even
if (n // 2) % 2 == 1:
print('NO')
continue
print('YES')
arr = []
even_acc = 0
odd_acc = 0
for i in range(2, n+1, 2):
arr.append(i)
even_acc += i
for i in range(1, n+1, 2):
arr.append(i)
odd_acc += i
while even_acc != odd_acc:
arr[-1] = arr[-1] + 2
odd_acc += 2
for n in arr:
print(n, end=' ')
# 4 => [2,4], [1,5]
# 8 => [2,4,6,8], [1,3,5,11]
#2 4 6 8 10 12 1 3 5 7 9 17
#print(sum([2, 4, 6, 8, 10, 12]))
#print(sum([1, 3, 5, 7, 9, 17]))
solve()
``` | instruction | 0 | 69,096 | 22 | 138,192 |
Yes | output | 1 | 69,096 | 22 | 138,193 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a positive integer n, it is guaranteed that n is even (i.e. divisible by 2).
You want to construct the array a of length n such that:
* The first n/2 elements of a are even (divisible by 2);
* the second n/2 elements of a are odd (not divisible by 2);
* all elements of a are distinct and positive;
* the sum of the first half equals to the sum of the second half (∑_{i=1}^{n/2} a_i = ∑_{i=n/2 + 1}^{n} a_i).
If there are multiple answers, you can print any. It is not guaranteed that the answer exists.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the length of the array. It is guaranteed that that n is even (i.e. divisible by 2).
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — "NO" (without quotes), if there is no suitable answer for the given test case or "YES" in the first line and any suitable array a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) satisfying conditions from the problem statement on the second line.
Example
Input
5
2
4
6
8
10
Output
NO
YES
2 4 1 5
NO
YES
2 4 6 8 1 3 5 11
NO
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())//2
if(n%2==0):
print("YES")
l=[]
for i in range(1,n+1):
l.append(str(i*2))
for i in range(1,n):
l.append(str((i*2)-1))
print(" ".join(l)+" "+str((3*n)-1))
else:
print("NO")
``` | instruction | 0 | 69,097 | 22 | 138,194 |
Yes | output | 1 | 69,097 | 22 | 138,195 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a positive integer n, it is guaranteed that n is even (i.e. divisible by 2).
You want to construct the array a of length n such that:
* The first n/2 elements of a are even (divisible by 2);
* the second n/2 elements of a are odd (not divisible by 2);
* all elements of a are distinct and positive;
* the sum of the first half equals to the sum of the second half (∑_{i=1}^{n/2} a_i = ∑_{i=n/2 + 1}^{n} a_i).
If there are multiple answers, you can print any. It is not guaranteed that the answer exists.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the length of the array. It is guaranteed that that n is even (i.e. divisible by 2).
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — "NO" (without quotes), if there is no suitable answer for the given test case or "YES" in the first line and any suitable array a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) satisfying conditions from the problem statement on the second line.
Example
Input
5
2
4
6
8
10
Output
NO
YES
2 4 1 5
NO
YES
2 4 6 8 1 3 5 11
NO
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Fri May 1 09:58:50 2020
@author: adars
"""
t=int(input())
l=[]*t
for k in range(t):
l.append(int(input()))
for n in l:
if n%4!=0:
print("NO")
else:
print("YES")
c=n//2
a=[]*c
b=[]*c
for i in range(2,n,2):
a.append(i)
b.append(i-1)
a.append(n)
b.append(n+(n//2)-1)
a.extend(b)
for j in a:
print(j,end=" ")
``` | instruction | 0 | 69,098 | 22 | 138,196 |
Yes | output | 1 | 69,098 | 22 | 138,197 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a positive integer n, it is guaranteed that n is even (i.e. divisible by 2).
You want to construct the array a of length n such that:
* The first n/2 elements of a are even (divisible by 2);
* the second n/2 elements of a are odd (not divisible by 2);
* all elements of a are distinct and positive;
* the sum of the first half equals to the sum of the second half (∑_{i=1}^{n/2} a_i = ∑_{i=n/2 + 1}^{n} a_i).
If there are multiple answers, you can print any. It is not guaranteed that the answer exists.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the length of the array. It is guaranteed that that n is even (i.e. divisible by 2).
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — "NO" (without quotes), if there is no suitable answer for the given test case or "YES" in the first line and any suitable array a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) satisfying conditions from the problem statement on the second line.
Example
Input
5
2
4
6
8
10
Output
NO
YES
2 4 1 5
NO
YES
2 4 6 8 1 3 5 11
NO
Submitted Solution:
```
def main():
t = int(input())
for _ in range(t):
n = int(input())
if n % 4 != 0:
print('NO')
else:
print('YES')
arr = []
for i in range(n // 2):
arr.append((i+1)*2)
s = 0
for i in range((n // 2) - 1):
x = arr[i] - 1
s += 1
arr.append(x)
x = arr[(n//2) - 1] + s
arr.append(x)
print(*arr)
main()
``` | instruction | 0 | 69,099 | 22 | 138,198 |
Yes | output | 1 | 69,099 | 22 | 138,199 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a positive integer n, it is guaranteed that n is even (i.e. divisible by 2).
You want to construct the array a of length n such that:
* The first n/2 elements of a are even (divisible by 2);
* the second n/2 elements of a are odd (not divisible by 2);
* all elements of a are distinct and positive;
* the sum of the first half equals to the sum of the second half (∑_{i=1}^{n/2} a_i = ∑_{i=n/2 + 1}^{n} a_i).
If there are multiple answers, you can print any. It is not guaranteed that the answer exists.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the length of the array. It is guaranteed that that n is even (i.e. divisible by 2).
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — "NO" (without quotes), if there is no suitable answer for the given test case or "YES" in the first line and any suitable array a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) satisfying conditions from the problem statement on the second line.
Example
Input
5
2
4
6
8
10
Output
NO
YES
2 4 1 5
NO
YES
2 4 6 8 1 3 5 11
NO
Submitted Solution:
```
t = int(input())
out = []
for _ in range(t):
n = int(input())//2
if n%2:
out.append('NO')
else:
out.append('YES')
l = []
l2 = []
for i in range(n):
l.append(6*i+2)
l.append(6*i+4)
l2.append(6*i+1)
l2.append(6*i+5)
out.append(''.join(map(str,l))+''.join(map(str,l2)))
print(*out,sep='\n')
``` | instruction | 0 | 69,100 | 22 | 138,200 |
No | output | 1 | 69,100 | 22 | 138,201 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a positive integer n, it is guaranteed that n is even (i.e. divisible by 2).
You want to construct the array a of length n such that:
* The first n/2 elements of a are even (divisible by 2);
* the second n/2 elements of a are odd (not divisible by 2);
* all elements of a are distinct and positive;
* the sum of the first half equals to the sum of the second half (∑_{i=1}^{n/2} a_i = ∑_{i=n/2 + 1}^{n} a_i).
If there are multiple answers, you can print any. It is not guaranteed that the answer exists.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the length of the array. It is guaranteed that that n is even (i.e. divisible by 2).
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — "NO" (without quotes), if there is no suitable answer for the given test case or "YES" in the first line and any suitable array a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) satisfying conditions from the problem statement on the second line.
Example
Input
5
2
4
6
8
10
Output
NO
YES
2 4 1 5
NO
YES
2 4 6 8 1 3 5 11
NO
Submitted Solution:
```
n=int(input())
for i in range(n):
n1=int(input())
if(n1%4==2):
print("NO")
if(n1%4==0):
print("NO")
a=[0]*n1
sum=0
for i in range(n1//2):
a[i]=2*i+2
sum+=2*i+2
for i in range(n1//2,n1-1):
a[i]=2*(i-n1//2)+1
sum-=(2*(i-n1//2)+1)
a[n1-1]=sum
print(a)
``` | instruction | 0 | 69,101 | 22 | 138,202 |
No | output | 1 | 69,101 | 22 | 138,203 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a positive integer n, it is guaranteed that n is even (i.e. divisible by 2).
You want to construct the array a of length n such that:
* The first n/2 elements of a are even (divisible by 2);
* the second n/2 elements of a are odd (not divisible by 2);
* all elements of a are distinct and positive;
* the sum of the first half equals to the sum of the second half (∑_{i=1}^{n/2} a_i = ∑_{i=n/2 + 1}^{n} a_i).
If there are multiple answers, you can print any. It is not guaranteed that the answer exists.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the length of the array. It is guaranteed that that n is even (i.e. divisible by 2).
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — "NO" (without quotes), if there is no suitable answer for the given test case or "YES" in the first line and any suitable array a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) satisfying conditions from the problem statement on the second line.
Example
Input
5
2
4
6
8
10
Output
NO
YES
2 4 1 5
NO
YES
2 4 6 8 1 3 5 11
NO
Submitted Solution:
```
t = int(input())
for i in range(t):
massif = []
n = int(input())
if n % 4 == 0:
print('YES')
massif = [i for i in range(2, n + 1, 2)]
massif += [i for i in range(1, n - 1, 2)]
massif.append((n//2 + 1)*2 + 1)
print(*massif)
else:
print('NO')
``` | instruction | 0 | 69,102 | 22 | 138,204 |
No | output | 1 | 69,102 | 22 | 138,205 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a positive integer n, it is guaranteed that n is even (i.e. divisible by 2).
You want to construct the array a of length n such that:
* The first n/2 elements of a are even (divisible by 2);
* the second n/2 elements of a are odd (not divisible by 2);
* all elements of a are distinct and positive;
* the sum of the first half equals to the sum of the second half (∑_{i=1}^{n/2} a_i = ∑_{i=n/2 + 1}^{n} a_i).
If there are multiple answers, you can print any. It is not guaranteed that the answer exists.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the length of the array. It is guaranteed that that n is even (i.e. divisible by 2).
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — "NO" (without quotes), if there is no suitable answer for the given test case or "YES" in the first line and any suitable array a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) satisfying conditions from the problem statement on the second line.
Example
Input
5
2
4
6
8
10
Output
NO
YES
2 4 1 5
NO
YES
2 4 6 8 1 3 5 11
NO
Submitted Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
if (n//2)%2 != 0:
print("NO")
else:
out = [0]*(n)
evst, oddst = 0, n//2
curEv = 2
curOd = 1
for i in range(n//4):
out[evst], out[evst+1] = curEv, curEv + 2
out[oddst], out[oddst+1] = curOd, curOd+4
evst += 2
oddst += 2
curEv += 4
curOd += 2
print(" ".join(map(str, out)))
``` | instruction | 0 | 69,103 | 22 | 138,206 |
No | output | 1 | 69,103 | 22 | 138,207 |
Provide tags and a correct Python 3 solution for this coding contest problem.
To confuse the opponents, the Galactic Empire represents fractions in an unusual format. The fractions are represented as two sets of integers. The product of numbers from the first set gives the fraction numerator, the product of numbers from the second set gives the fraction denominator. However, it turned out that the programs that work with fractions in this representations aren't complete, they lack supporting the operation of reducing fractions. Implement this operation and the Empire won't forget you.
Input
The first input line contains two space-separated integers n, m (1 ≤ n, m ≤ 105) that show how many numbers the first set (the numerator) and the second set (the denominator) contain, correspondingly.
The second line contains n space-separated integers: a1, a2, ..., an (1 ≤ ai ≤ 107) — the numbers that are multiplied to produce the numerator.
The third line contains m space-separated integers: b1, b2, ..., bm (1 ≤ bi ≤ 107) — the numbers that are multiplied to produce the denominator.
Output
Print the answer to the problem in the form, similar to the form of the input data. The number of values in the sets you print nout, mout must satisfy the inequality 1 ≤ nout, mout ≤ 105, and the actual values in the sets aout, i and bout, i must satisfy the inequality 1 ≤ aout, i, bout, i ≤ 107.
Separate the values in the lines by spaces. The printed fraction must be reduced, that is, there mustn't be such integer x (x > 1), that the numerator and the denominator of the printed fraction are divisible by x. If there are several matching answers, print any of them.
Examples
Input
3 2
100 5 2
50 10
Output
2 3
2 1
1 1 1
Input
4 3
2 5 10 20
100 1 3
Output
1 1
20
3
Note
In the first test sample the numerator equals 1000, the denominator equals 500. If we reduce fraction 1000/500 by the greatest common divisor of the numerator and the denominator (by 500), we obtain fraction 2/1.
In the second test sample the numerator equals 2000, the denominator equals 300. If we reduce fraction 2000/300 by the greatest common divisor of the numerator and the denominator (by 100), we obtain fraction 20/3. | instruction | 0 | 69,227 | 22 | 138,454 |
Tags: implementation, math, number theory, sortings
Correct Solution:
```
from collections import defaultdict
import bisect
from itertools import accumulate
import os
import sys
import math
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)
def input(): return sys.stdin.readline().rstrip("\r\n")
# ------------------- fast io --------------------
def factor(n, dic1):
while(n % 2 == 0):
if 2 not in dic1:
dic1[2] = 1
else:
dic1[2] += 1
n = n//2
for i in range(3, int(math.sqrt(n))+1, 2):
while(n % i == 0):
if i not in dic1:
dic1[i] = 1
else:
dic1[i] += 1
n = n//i
if n > 2:
if n not in dic1:
dic1[n] = 1
else:
dic1[n] += 1
def factor1(n, dic2):
while(n % 2 == 0):
if 2 not in dic2:
dic2[2] = 1
else:
dic2[2] += 1
n = n//2
for i in range(3, int(math.sqrt(n))+1, 2):
if n % i == 0:
while(n % i == 0):
if i not in dic2:
dic2[i] = 1
else:
dic2[i] += 1
n = n//i
if n > 2:
if n not in dic2:
dic2[n] = 1
else:
dic2[n] += 1
n, m = map(int, input().split())
dic1 = {}
dic2 = {}
a = sorted(list(map(int, input().split())))
b = sorted(list(map(int, input().split())))
for i in range(0, len(a)):
factor(a[i], dic1)
for i in range(0, len(b)):
factor1(b[i], dic2)
ans1 = [1]*n
ans2 = [1]*m
fac1 = []
fac2 = []
for key in dic1:
if key in dic2:
if dic1[key] >= dic2[key]:
dic1[key] -= dic2[key]
dic2[key] = 0
elif dic2[key] > dic1[key]:
dic2[key] -= dic1[key]
dic1[key] = 0
fac11=[]
fac22=[]
for key in dic1:
fac11.append([key,dic1[key]])
for key in dic2:
fac22.append([key,dic2[key]])
fac11.sort(reverse=True)
fac22.sort(reverse=True)
j=0
for i in range(0,len(fac11)):
while(fac11[i][1]>0):
if ans1[j]*fac11[i][0]<=10**7:
ans1[j]=ans1[j]*fac11[i][0]
fac11[i][1]-=1
j=(j+1)%n
j=0
for i in range(0, len(fac22)):
while(fac22[i][1] > 0):
if ans2[j]*fac22[i][0] <= 10**7:
ans2[j] = ans2[j]*fac22[i][0]
fac22[i][1] -= 1
j = (j+1) % m
print(len(ans1),len(ans2))
print(*ans1)
print(*ans2)
``` | output | 1 | 69,227 | 22 | 138,455 |
Provide tags and a correct Python 3 solution for this coding contest problem.
To confuse the opponents, the Galactic Empire represents fractions in an unusual format. The fractions are represented as two sets of integers. The product of numbers from the first set gives the fraction numerator, the product of numbers from the second set gives the fraction denominator. However, it turned out that the programs that work with fractions in this representations aren't complete, they lack supporting the operation of reducing fractions. Implement this operation and the Empire won't forget you.
Input
The first input line contains two space-separated integers n, m (1 ≤ n, m ≤ 105) that show how many numbers the first set (the numerator) and the second set (the denominator) contain, correspondingly.
The second line contains n space-separated integers: a1, a2, ..., an (1 ≤ ai ≤ 107) — the numbers that are multiplied to produce the numerator.
The third line contains m space-separated integers: b1, b2, ..., bm (1 ≤ bi ≤ 107) — the numbers that are multiplied to produce the denominator.
Output
Print the answer to the problem in the form, similar to the form of the input data. The number of values in the sets you print nout, mout must satisfy the inequality 1 ≤ nout, mout ≤ 105, and the actual values in the sets aout, i and bout, i must satisfy the inequality 1 ≤ aout, i, bout, i ≤ 107.
Separate the values in the lines by spaces. The printed fraction must be reduced, that is, there mustn't be such integer x (x > 1), that the numerator and the denominator of the printed fraction are divisible by x. If there are several matching answers, print any of them.
Examples
Input
3 2
100 5 2
50 10
Output
2 3
2 1
1 1 1
Input
4 3
2 5 10 20
100 1 3
Output
1 1
20
3
Note
In the first test sample the numerator equals 1000, the denominator equals 500. If we reduce fraction 1000/500 by the greatest common divisor of the numerator and the denominator (by 500), we obtain fraction 2/1.
In the second test sample the numerator equals 2000, the denominator equals 300. If we reduce fraction 2000/300 by the greatest common divisor of the numerator and the denominator (by 100), we obtain fraction 20/3. | instruction | 0 | 69,228 | 22 | 138,456 |
Tags: implementation, math, number theory, sortings
Correct Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
from io import BytesIO, IOBase
import sys
from collections import Counter
from math import sqrt, pi, ceil, log, inf, gcd, floor
def main():
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
z = ceil(sqrt(max(max(a), max(b))))
p = [1] * (z + 1)
i = 2
while i * i <= z:
if p[i] == 1:
j = i * i
while j <= z:
p[j] = 0
j += i
i += 1
pr = []
for i in range(2, z + 1):
if p[i]:
pr.append(i)
f = Counter()
f1 = Counter()
c = [[] for i in range(n)]
d = [[] for i in range(m)]
for i, v in enumerate(a):
y, z = ceil(sqrt(v)), v
for j in pr:
if j > y:
break
x=0
while z % j == 0:
f[j] += 1
x+=1
z = z // j
if x:
c[i].append([j,x])
if z > 1:
c[i].append([z,1])
f[z] += 1
for i, v in enumerate(b):
y, z = ceil(sqrt(v)), v
for j in pr:
if j > y:
break
x=0
while z % j == 0:
f1[j] += 1
x+=1
z = z // j
if x:
d[i].append([j,x])
if z > 1:
d[i].append([z,1])
f1[z] += 1
e = []
for i in f:
f[i], f1[i] = max(f[i] - f1[i], 0), max(f1[i] - f[i], 0)
if f[i] == 0:
e.append(i)
if f1[i] == 0:
del f1[i]
for i in e:
del f[i]
e.clear()
a = [1] * n
b = [1] * m
for i in range(n):
z, f2 = 1, 0
for j in range(len(c[i])):
xx=c[i][j][0]
y = min(c[i][j][1], f[xx])
z = z * pow(xx,y)
f[xx] -= y
if f[xx] == 0:
del f[xx]
if len(f) == 0:
f2 = 1
break
a[i] = z
if f2:
break
for i in range(m):
z, f2 = 1, 0
for j in range(len(d[i])):
xx=d[i][j][0]
y = min(d[i][j][1], f1[xx])
z = z * pow(xx, y)
f1[xx] -= y
if f1[xx] == 0:
del f1[xx]
if len(f1) == 0:
f2 = 1
break
b[i] = z
if f2:
break
print(n, m)
print(*a)
print(*b)
# 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")
if __name__ == "__main__":
main()
``` | output | 1 | 69,228 | 22 | 138,457 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To confuse the opponents, the Galactic Empire represents fractions in an unusual format. The fractions are represented as two sets of integers. The product of numbers from the first set gives the fraction numerator, the product of numbers from the second set gives the fraction denominator. However, it turned out that the programs that work with fractions in this representations aren't complete, they lack supporting the operation of reducing fractions. Implement this operation and the Empire won't forget you.
Input
The first input line contains two space-separated integers n, m (1 ≤ n, m ≤ 105) that show how many numbers the first set (the numerator) and the second set (the denominator) contain, correspondingly.
The second line contains n space-separated integers: a1, a2, ..., an (1 ≤ ai ≤ 107) — the numbers that are multiplied to produce the numerator.
The third line contains m space-separated integers: b1, b2, ..., bm (1 ≤ bi ≤ 107) — the numbers that are multiplied to produce the denominator.
Output
Print the answer to the problem in the form, similar to the form of the input data. The number of values in the sets you print nout, mout must satisfy the inequality 1 ≤ nout, mout ≤ 105, and the actual values in the sets aout, i and bout, i must satisfy the inequality 1 ≤ aout, i, bout, i ≤ 107.
Separate the values in the lines by spaces. The printed fraction must be reduced, that is, there mustn't be such integer x (x > 1), that the numerator and the denominator of the printed fraction are divisible by x. If there are several matching answers, print any of them.
Examples
Input
3 2
100 5 2
50 10
Output
2 3
2 1
1 1 1
Input
4 3
2 5 10 20
100 1 3
Output
1 1
20
3
Note
In the first test sample the numerator equals 1000, the denominator equals 500. If we reduce fraction 1000/500 by the greatest common divisor of the numerator and the denominator (by 500), we obtain fraction 2/1.
In the second test sample the numerator equals 2000, the denominator equals 300. If we reduce fraction 2000/300 by the greatest common divisor of the numerator and the denominator (by 100), we obtain fraction 20/3.
Submitted Solution:
```
import math as mt
from sys import stdin,stdout
MAXN = 10000001
spf = [0]*(MAXN)
def sieve():
spf[1] = 1
for i in range(2, MAXN):
spf[i] = i
for i in range(4, MAXN, 2):
spf[i] = 2
for i in range(3, mt.ceil(mt.sqrt(MAXN))):
if (spf[i] == i):
for j in range(i * i, MAXN, i):
if (spf[j] == j):
spf[j] = i
def getFactorization(x):
ret = list()
while (x != 1):
ret.append(spf[x])
x = x // spf[x]
return ret
sieve()
def help():
a,b = map(int,stdin.readline().split(" "))
num = list(map(int,stdin.readline().split(" ")))
den = list(map(int,stdin.readline().split(" ")))
spfn = [0]*(MAXN)
for i in range(a):
temp = getFactorization(num[i])
for j in temp:
spfn[j]+=1
for i in range(b):
temp = getFactorization(den[i])
for j in temp:
spfn[j]-=1
a1 = 0
a2 = 0
for i in range(MAXN):
if(spfn[i]>0):
a1 += spfn[i]
elif(spfn[i]<0):
a2 += -1*spfn[i]
if(a1==0 or a2==0):
if(a1==0 and a2==0):
stdout.write("1 1\n")
elif(a1==0):
stdout.write("1 "+str(a2)+"\n")
else:
stdout.write(str(a1)+" 1"+"\n")
else:
stdout.write(str(a1)+" "+str(a2)+"\n")
for i in range(MAXN):
if(spfn[i]>0):
for j in range(spfn[i]):
stdout.write(str(i)+" ")
if(a1==0):
stdout.write("1\n")
else:
stdout.write("\n")
for i in range(MAXN):
if(spfn[i]<0):
for j in range(-1*spfn[i]):
stdout.write(str(i)+" ")
if(a2==0):
stdout.write("1\n")
else:
stdout.write("\n")
help()
``` | instruction | 0 | 69,229 | 22 | 138,458 |
No | output | 1 | 69,229 | 22 | 138,459 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To confuse the opponents, the Galactic Empire represents fractions in an unusual format. The fractions are represented as two sets of integers. The product of numbers from the first set gives the fraction numerator, the product of numbers from the second set gives the fraction denominator. However, it turned out that the programs that work with fractions in this representations aren't complete, they lack supporting the operation of reducing fractions. Implement this operation and the Empire won't forget you.
Input
The first input line contains two space-separated integers n, m (1 ≤ n, m ≤ 105) that show how many numbers the first set (the numerator) and the second set (the denominator) contain, correspondingly.
The second line contains n space-separated integers: a1, a2, ..., an (1 ≤ ai ≤ 107) — the numbers that are multiplied to produce the numerator.
The third line contains m space-separated integers: b1, b2, ..., bm (1 ≤ bi ≤ 107) — the numbers that are multiplied to produce the denominator.
Output
Print the answer to the problem in the form, similar to the form of the input data. The number of values in the sets you print nout, mout must satisfy the inequality 1 ≤ nout, mout ≤ 105, and the actual values in the sets aout, i and bout, i must satisfy the inequality 1 ≤ aout, i, bout, i ≤ 107.
Separate the values in the lines by spaces. The printed fraction must be reduced, that is, there mustn't be such integer x (x > 1), that the numerator and the denominator of the printed fraction are divisible by x. If there are several matching answers, print any of them.
Examples
Input
3 2
100 5 2
50 10
Output
2 3
2 1
1 1 1
Input
4 3
2 5 10 20
100 1 3
Output
1 1
20
3
Note
In the first test sample the numerator equals 1000, the denominator equals 500. If we reduce fraction 1000/500 by the greatest common divisor of the numerator and the denominator (by 500), we obtain fraction 2/1.
In the second test sample the numerator equals 2000, the denominator equals 300. If we reduce fraction 2000/300 by the greatest common divisor of the numerator and the denominator (by 100), we obtain fraction 20/3.
Submitted Solution:
```
from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
from collections import *
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
def ii(): return int(input())
def si(): return input()
def mi(): return map(int, input().strip().split(" "))
def msi(): return map(str, input().strip().split(" "))
def li(): return list(mi())
def dmain():
sys.setrecursionlimit(1000000)
threading.stack_size(1024000)
thread = threading.Thread(target=main)
thread.start()
#from collections import deque, Counter, OrderedDict,defaultdict
#from heapq import nsmallest, nlargest, heapify,heappop ,heappush, heapreplace
#from math import log,sqrt,factorial,cos,tan,sin,radians
#from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
#from decimal import *
#import threading
#from itertools import permutations
# Copy 2D list m = [x[:] for x in mark] .. Avoid Using Deepcopy
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12,
'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod = 1000000007
# mod=998244353
inf = float("inf")
vow = ['a', 'e', 'i', 'o', 'u']
dx, dy = [-1, 1, 0, 0], [0, 0, 1, -1]
def getKey(item): return item[1]
def sort2(l): return sorted(l, key=getKey, reverse=True)
def d2(n, m, num): return [[num for x in range(m)] for y in range(n)]
def isPowerOfTwo(x): return (x and (not(x & (x - 1))))
def decimalToBinary(n): return bin(n).replace("0b", "")
def ntl(n): return [int(i) for i in str(n)]
def ncr(n, r): return factorial(n)//(factorial(r)*factorial(max(n-r, 1)))
def ceil(x, y):
if x % y == 0:
return x//y
else:
return x//y+1
def powerMod(x, y, p):
res = 1
x %= p
while y > 0:
if y & 1:
res = (res*x) % p
y = y >> 1
x = (x*x) % p
return res
def gcd(x, y):
while y:
x, y = y, x % y
return x
def isPrime(n): # Check Prime Number or not
if (n <= 1):
return False
if (n <= 3):
return True
if (n % 2 == 0 or n % 3 == 0):
return False
i = 5
while(i * i <= n):
if (n % i == 0 or n % (i + 2) == 0):
return False
i = i + 6
return True
def read():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
def main():
maxN = 10000000 + 10
# maxN = 1000
prime = []
dp = list(range(maxN+1))
pre = [0, 0]
for i in range(2, maxN+1):
pre.append(0)
if dp[i] == i:
prime.append(i)
j = 0
while j < len(prime) and prime[j]*i <= maxN and prime[j] <= dp[i]:
dp[i*prime[j]] = prime[j]
j += 1
n, m = mi()
a = li()
b = li()
num = defaultdict(int)
den = defaultdict(int)
for i in range(n):
ele = a[i]
while ele > 1:
num[dp[ele]] += 1
ele //= dp[ele]
for i in range(m):
ele = b[i]
while ele > 1:
den[dp[ele]] += 1
ele //= dp[ele]
ans1 = []
ans2 = []
size1 = 0
size2 = 0
for i in num:
diff = num[i] - min(num[i], den[i])
size1 += 1
ans1.append(pow(i, diff))
for i in den:
diff = den[i] - min(num[i], den[i])
size2 += 1
ans2.append(pow(i, diff))
if size1 == 0:
size1 += 1
ans1.append(1)
if size2 == 0:
size2 += 1
ans2.append(1)
print(size1, size2)
print(' '.join(map(str, ans1)))
print(' '.join(map(str, ans2)))
# region fastio
# template taken from https://github.com/cheran-senthil/PyRival/blob/master/templates/template.py
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)
def input(): return sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
# read()
main()
# dmain()
# Comment Read()
``` | instruction | 0 | 69,230 | 22 | 138,460 |
No | output | 1 | 69,230 | 22 | 138,461 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To confuse the opponents, the Galactic Empire represents fractions in an unusual format. The fractions are represented as two sets of integers. The product of numbers from the first set gives the fraction numerator, the product of numbers from the second set gives the fraction denominator. However, it turned out that the programs that work with fractions in this representations aren't complete, they lack supporting the operation of reducing fractions. Implement this operation and the Empire won't forget you.
Input
The first input line contains two space-separated integers n, m (1 ≤ n, m ≤ 105) that show how many numbers the first set (the numerator) and the second set (the denominator) contain, correspondingly.
The second line contains n space-separated integers: a1, a2, ..., an (1 ≤ ai ≤ 107) — the numbers that are multiplied to produce the numerator.
The third line contains m space-separated integers: b1, b2, ..., bm (1 ≤ bi ≤ 107) — the numbers that are multiplied to produce the denominator.
Output
Print the answer to the problem in the form, similar to the form of the input data. The number of values in the sets you print nout, mout must satisfy the inequality 1 ≤ nout, mout ≤ 105, and the actual values in the sets aout, i and bout, i must satisfy the inequality 1 ≤ aout, i, bout, i ≤ 107.
Separate the values in the lines by spaces. The printed fraction must be reduced, that is, there mustn't be such integer x (x > 1), that the numerator and the denominator of the printed fraction are divisible by x. If there are several matching answers, print any of them.
Examples
Input
3 2
100 5 2
50 10
Output
2 3
2 1
1 1 1
Input
4 3
2 5 10 20
100 1 3
Output
1 1
20
3
Note
In the first test sample the numerator equals 1000, the denominator equals 500. If we reduce fraction 1000/500 by the greatest common divisor of the numerator and the denominator (by 500), we obtain fraction 2/1.
In the second test sample the numerator equals 2000, the denominator equals 300. If we reduce fraction 2000/300 by the greatest common divisor of the numerator and the denominator (by 100), we obtain fraction 20/3.
Submitted Solution:
```
import sys
input = sys.stdin.readline
print = sys.stdout.write
N = int(1e7+3)
is_prime = [i for i in range(N)]
def sieve():
for i in range(2, int(N**0.5)+1):
if (is_prime[i] != i):
continue
for j in range(i * i, N, i):
if (is_prime[j] == j):
is_prime[j] = i
def get_factorization(x):
res = []
while x > 1:
res.append(is_prime[x])
x = x // is_prime[x]
return res
sieve()
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
cnt_n = [0]*N
for i in b:
temp = get_factorization(i)
for j in temp:
cnt_n[j] -= 1
cnt_d = [0]*N
for i in range(n):
temp = get_factorization(a[i])
for j in temp:
if cnt_n[j] < 0:
cnt_n[j] += 1
cnt_d[j] -= 1
a[i] = a[i] // j
for i in range(m):
temp = get_factorization(b[i])
for j in temp:
if cnt_d[j] < 0:
cnt_d[j] += 1
b[i] = b[i] // j
print(str(n)+' '+str(m))
print(' '.join(map(str, a))+'\n')
print(' '.join(map(str, b))+'\n')
``` | instruction | 0 | 69,231 | 22 | 138,462 |
No | output | 1 | 69,231 | 22 | 138,463 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To confuse the opponents, the Galactic Empire represents fractions in an unusual format. The fractions are represented as two sets of integers. The product of numbers from the first set gives the fraction numerator, the product of numbers from the second set gives the fraction denominator. However, it turned out that the programs that work with fractions in this representations aren't complete, they lack supporting the operation of reducing fractions. Implement this operation and the Empire won't forget you.
Input
The first input line contains two space-separated integers n, m (1 ≤ n, m ≤ 105) that show how many numbers the first set (the numerator) and the second set (the denominator) contain, correspondingly.
The second line contains n space-separated integers: a1, a2, ..., an (1 ≤ ai ≤ 107) — the numbers that are multiplied to produce the numerator.
The third line contains m space-separated integers: b1, b2, ..., bm (1 ≤ bi ≤ 107) — the numbers that are multiplied to produce the denominator.
Output
Print the answer to the problem in the form, similar to the form of the input data. The number of values in the sets you print nout, mout must satisfy the inequality 1 ≤ nout, mout ≤ 105, and the actual values in the sets aout, i and bout, i must satisfy the inequality 1 ≤ aout, i, bout, i ≤ 107.
Separate the values in the lines by spaces. The printed fraction must be reduced, that is, there mustn't be such integer x (x > 1), that the numerator and the denominator of the printed fraction are divisible by x. If there are several matching answers, print any of them.
Examples
Input
3 2
100 5 2
50 10
Output
2 3
2 1
1 1 1
Input
4 3
2 5 10 20
100 1 3
Output
1 1
20
3
Note
In the first test sample the numerator equals 1000, the denominator equals 500. If we reduce fraction 1000/500 by the greatest common divisor of the numerator and the denominator (by 500), we obtain fraction 2/1.
In the second test sample the numerator equals 2000, the denominator equals 300. If we reduce fraction 2000/300 by the greatest common divisor of the numerator and the denominator (by 100), we obtain fraction 20/3.
Submitted Solution:
```
from math import gcd
input()
a=1
for i in map(int, input().split()):
a*=i
b=1
for i in map(int, input().split()):
b*=i
c=gcd(a,b)
print('1 1', a//c, b//c, sep='\n')
``` | instruction | 0 | 69,232 | 22 | 138,464 |
No | output | 1 | 69,232 | 22 | 138,465 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | instruction | 0 | 69,253 | 22 | 138,506 |
Tags: binary search, brute force, math, number theory
Correct Solution:
```
# Problem: B. Prime Matrix
# Contest: Codeforces - Codeforces Round #166 (Div. 2)
# URL: https://codeforces.com/contest/271/problem/B
# Memory Limit: 256 MB
# Time Limit: 2000 ms
# Powered by CP Editor (https://github.com/cpeditor/cpeditor)
import math
from sys import stdin
def get_ints(): return list(map(int, stdin.readline().strip().split()))
def isPrime(n):
# Corner cases
if(n <= 1):
return False
if(n <= 3):
return True
# This is checked so that we can skip
# middle five numbers in below loop
if(n % 2 == 0 or n % 3 == 0):
return False
for i in range(5,int(math.sqrt(n) + 1), 6):
if(n % i == 0 or n % (i + 2) == 0):
return False
return True
# Function to return the smallest
# prime number greater than N
def nextPrime(N):
# Base case
if (N <= 1):
return 2
prime = N
found = False
# Loop continuously until isPrime returns
# True for a number greater than n
while(not found):
prime = prime + 1
if(isPrime(prime) == True):
found = True
return prime
M= 100100
primes = [0] * M
primes[0]= 2
primes[1] =2
primes[2] = 2
prev = 2
i = 3
primes[i] = 3
while i <M:
f = i
if not isPrime(f):
f = nextPrime(f)
nextone = nextPrime(f+1)
# print(i,f,nextone)
primes[i+1:nextone] = [nextone] * (nextone-i)
i+=nextone-f
# print(primes)
# print(primes[1])
n,m = get_ints()
add = [ [999]*m for i in range(n)]
for i in range(n):
line = get_ints()
for j in range(m):
add[i][j] = primes[line[j]] - line[j]
minrow = 99999999999
for row in add:
minrow = min(minrow,sum(row))
mincol = 99999999999
for col in zip(*add):
mincol = min(mincol,sum(col))
print(min(minrow,mincol))
``` | output | 1 | 69,253 | 22 | 138,507 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | instruction | 0 | 69,256 | 22 | 138,512 |
Tags: binary search, brute force, math, number theory
Correct Solution:
```
def _min(x, y):
if x < y:
return x
if y <= x:
return y
n = 100100
prime = [True for i in range(n+1)]
prime[0], prime[1] = False, False
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
n = 100100
nextPrime = [0 for _ in range(n+1)]
currentPrime = -1
for i in range(n, -1, -1):
if prime[i]:
nextPrime[i] = i
currentPrime = i
elif currentPrime == -1:
nextPrime[i] = -1
else:
nextPrime[i] = currentPrime
n, m = map(int, input().split())
rows = [0 for i in range(n)]
cols = [0 for i in range(m)]
for r in range(n):
row = [int(x) for x in input().split()]
for c in range(m):
x = row[c]
if not prime[x]:
x = nextPrime[x]
# while(not prime[x]):
# x+=1
rows[r] += (x - row[c])
cols[c] += (x - row[c])
min_row=min(rows)
min_cols=min(cols)
print(_min(min_row, min_cols))
``` | output | 1 | 69,256 | 22 | 138,513 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Suppose you have two polynomials <image> and <image>. Then polynomial <image> can be uniquely represented in the following way:
<image>
This can be done using [long division](https://en.wikipedia.org/wiki/Polynomial_long_division). Here, <image> denotes the degree of polynomial P(x). <image> is called the remainder of division of polynomial <image> by polynomial <image>, it is also denoted as <image>.
Since there is a way to divide polynomials with remainder, we can define Euclid's algorithm of finding the greatest common divisor of two polynomials. The algorithm takes two polynomials <image>. If the polynomial <image> is zero, the result is <image>, otherwise the result is the value the algorithm returns for pair <image>. On each step the degree of the second argument decreases, so the algorithm works in finite number of steps. But how large that number could be? You are to answer this question.
You are given an integer n. You have to build two polynomials with degrees not greater than n, such that their coefficients are integers not exceeding 1 by their absolute value, the leading coefficients (ones with the greatest power of x) are equal to one, and the described Euclid's algorithm performs exactly n steps finding their greatest common divisor. Moreover, the degree of the first polynomial should be greater than the degree of the second. By a step of the algorithm we mean the transition from pair <image> to pair <image>.
Input
You are given a single integer n (1 ≤ n ≤ 150) — the number of steps of the algorithm you need to reach.
Output
Print two polynomials in the following format.
In the first line print a single integer m (0 ≤ m ≤ n) — the degree of the polynomial.
In the second line print m + 1 integers between - 1 and 1 — the coefficients of the polynomial, from constant to leading.
The degree of the first polynomial should be greater than the degree of the second polynomial, the leading coefficients should be equal to 1. Euclid's algorithm should perform exactly n steps when called using these polynomials.
If there is no answer for the given n, print -1.
If there are multiple answer, print any of them.
Examples
Input
1
Output
1
0 1
0
1
Input
2
Output
2
-1 0 1
1
0 1
Note
In the second example you can print polynomials x2 - 1 and x. The sequence of transitions is
(x2 - 1, x) → (x, - 1) → ( - 1, 0).
There are two steps in it. | instruction | 0 | 69,556 | 22 | 139,112 |
Tags: constructive algorithms, math
Correct Solution:
```
n = int(input())
a = [1]
b = [0]
for i in range(n):
c = a.copy()
a.append(0)
for i in range(len(a) - 1, 0, -1):
a[i] = a[i - 1]
if i < len(b):
a[i] += b[i]
a[i] %= 2
a[0] = b[0]
b = c.copy()
print(len(a) - 1)
for i in a:
print(i, end=' ')
print('')
print(len(b) - 1)
for i in b:
print(i, end=' ')
``` | output | 1 | 69,556 | 22 | 139,113 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Suppose you have two polynomials <image> and <image>. Then polynomial <image> can be uniquely represented in the following way:
<image>
This can be done using [long division](https://en.wikipedia.org/wiki/Polynomial_long_division). Here, <image> denotes the degree of polynomial P(x). <image> is called the remainder of division of polynomial <image> by polynomial <image>, it is also denoted as <image>.
Since there is a way to divide polynomials with remainder, we can define Euclid's algorithm of finding the greatest common divisor of two polynomials. The algorithm takes two polynomials <image>. If the polynomial <image> is zero, the result is <image>, otherwise the result is the value the algorithm returns for pair <image>. On each step the degree of the second argument decreases, so the algorithm works in finite number of steps. But how large that number could be? You are to answer this question.
You are given an integer n. You have to build two polynomials with degrees not greater than n, such that their coefficients are integers not exceeding 1 by their absolute value, the leading coefficients (ones with the greatest power of x) are equal to one, and the described Euclid's algorithm performs exactly n steps finding their greatest common divisor. Moreover, the degree of the first polynomial should be greater than the degree of the second. By a step of the algorithm we mean the transition from pair <image> to pair <image>.
Input
You are given a single integer n (1 ≤ n ≤ 150) — the number of steps of the algorithm you need to reach.
Output
Print two polynomials in the following format.
In the first line print a single integer m (0 ≤ m ≤ n) — the degree of the polynomial.
In the second line print m + 1 integers between - 1 and 1 — the coefficients of the polynomial, from constant to leading.
The degree of the first polynomial should be greater than the degree of the second polynomial, the leading coefficients should be equal to 1. Euclid's algorithm should perform exactly n steps when called using these polynomials.
If there is no answer for the given n, print -1.
If there are multiple answer, print any of them.
Examples
Input
1
Output
1
0 1
0
1
Input
2
Output
2
-1 0 1
1
0 1
Note
In the second example you can print polynomials x2 - 1 and x. The sequence of transitions is
(x2 - 1, x) → (x, - 1) → ( - 1, 0).
There are two steps in it. | instruction | 0 | 69,557 | 22 | 139,114 |
Tags: constructive algorithms, math
Correct Solution:
```
"""
NTC here
"""
import sys
inp= sys.stdin.readline
input = lambda : inp().strip()
flush= sys.stdout.flush
# import threading
# sys.setrecursionlimit(10**6)
# threading.stack_size(2**25)
def iin(): return int(input())
def lin(): return list(map(int, input().split()))
# range = xrange
# input = raw_input
def main():
n = iin()
ans = [0]*(n+1)
ans[0]=1
ans1 = [0]*(n+1)
sol = 0
# print(ans, ans1)
for i in range(n):
su = ans1[:]
for j in range(n):
su[j+1]+=ans[j]
if su[j+1]>1:su[j+1]=0
# print(1, su, ans)
ans, ans1= su, ans
# print(ans, ans1, mx)
if sol:
print(-1)
else:
m1, m2=0, 0
for i in range(n+1):
if abs(ans[i]):
m1 = i+1
if abs(ans1[i]):
m2 = i+1
print(m1-1)
print( *ans[:m1])
print( m2-1)
print( *ans1[:m2])
main()
# threading.Thread(target=main).start()
``` | output | 1 | 69,557 | 22 | 139,115 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Suppose you have two polynomials <image> and <image>. Then polynomial <image> can be uniquely represented in the following way:
<image>
This can be done using [long division](https://en.wikipedia.org/wiki/Polynomial_long_division). Here, <image> denotes the degree of polynomial P(x). <image> is called the remainder of division of polynomial <image> by polynomial <image>, it is also denoted as <image>.
Since there is a way to divide polynomials with remainder, we can define Euclid's algorithm of finding the greatest common divisor of two polynomials. The algorithm takes two polynomials <image>. If the polynomial <image> is zero, the result is <image>, otherwise the result is the value the algorithm returns for pair <image>. On each step the degree of the second argument decreases, so the algorithm works in finite number of steps. But how large that number could be? You are to answer this question.
You are given an integer n. You have to build two polynomials with degrees not greater than n, such that their coefficients are integers not exceeding 1 by their absolute value, the leading coefficients (ones with the greatest power of x) are equal to one, and the described Euclid's algorithm performs exactly n steps finding their greatest common divisor. Moreover, the degree of the first polynomial should be greater than the degree of the second. By a step of the algorithm we mean the transition from pair <image> to pair <image>.
Input
You are given a single integer n (1 ≤ n ≤ 150) — the number of steps of the algorithm you need to reach.
Output
Print two polynomials in the following format.
In the first line print a single integer m (0 ≤ m ≤ n) — the degree of the polynomial.
In the second line print m + 1 integers between - 1 and 1 — the coefficients of the polynomial, from constant to leading.
The degree of the first polynomial should be greater than the degree of the second polynomial, the leading coefficients should be equal to 1. Euclid's algorithm should perform exactly n steps when called using these polynomials.
If there is no answer for the given n, print -1.
If there are multiple answer, print any of them.
Examples
Input
1
Output
1
0 1
0
1
Input
2
Output
2
-1 0 1
1
0 1
Note
In the second example you can print polynomials x2 - 1 and x. The sequence of transitions is
(x2 - 1, x) → (x, - 1) → ( - 1, 0).
There are two steps in it. | instruction | 0 | 69,558 | 22 | 139,116 |
Tags: constructive algorithms, math
Correct Solution:
```
class polynomial:
def __init__(self, data):
self.data = data
def __lshift__(self, x):
return polynomial([0] * x + self.data)
def __len__(self):
return len(self.data)
def __sub__(self, other):
newData = [y - x for y, x in zip(self.data, other.data + [0] * 1000)]
while len(newData) > 0 and newData[-1] == 0:
del newData[-1]
return polynomial(newData)
def __add__(self, other):
newData = [(y + x) % 2 for y, x in zip(self.data + [0] * 1000, other.data + [0] * 1000)]
while len(newData) > 0 and newData[-1] == 0:
del newData[-1]
return polynomial(newData)
def __mul__(self, amt):
return polynomial([x * amt for x in self.data])
def __getitem__(self, idx):
return self.data[idx]
def __mod__(self, other):
tmp = self
times = 0
while len(tmp) >= len(other):
times += 1
if times > 1000:
print(*tmp.data)
print(*other.data)
exit(0)
tmp = tmp - (other << (len(tmp) - len(other))) * (tmp[-1] // other[-1])
return tmp
def gcdSteps(p1, p2, steps=0):
# print(*p1.data)
if len(p1) == 0 or len(p2) == 0:
return steps
else:
return gcdSteps(p2, p1 % p2, steps + 1)
a, b = polynomial([0, 1]), polynomial([1])
# x = b + (a << 1)
for i in range(int(input()) - 1):
# print(gcdSteps(a, b))
if gcdSteps(a, b) != i + 1:
print("error", i)
a, b = b + (a << 1), a
print(len(a) - 1)
print(*a.data)
print(len(b) - 1)
print(*b.data)
# print(gcdSteps(x, a))
``` | output | 1 | 69,558 | 22 | 139,117 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Suppose you have two polynomials <image> and <image>. Then polynomial <image> can be uniquely represented in the following way:
<image>
This can be done using [long division](https://en.wikipedia.org/wiki/Polynomial_long_division). Here, <image> denotes the degree of polynomial P(x). <image> is called the remainder of division of polynomial <image> by polynomial <image>, it is also denoted as <image>.
Since there is a way to divide polynomials with remainder, we can define Euclid's algorithm of finding the greatest common divisor of two polynomials. The algorithm takes two polynomials <image>. If the polynomial <image> is zero, the result is <image>, otherwise the result is the value the algorithm returns for pair <image>. On each step the degree of the second argument decreases, so the algorithm works in finite number of steps. But how large that number could be? You are to answer this question.
You are given an integer n. You have to build two polynomials with degrees not greater than n, such that their coefficients are integers not exceeding 1 by their absolute value, the leading coefficients (ones with the greatest power of x) are equal to one, and the described Euclid's algorithm performs exactly n steps finding their greatest common divisor. Moreover, the degree of the first polynomial should be greater than the degree of the second. By a step of the algorithm we mean the transition from pair <image> to pair <image>.
Input
You are given a single integer n (1 ≤ n ≤ 150) — the number of steps of the algorithm you need to reach.
Output
Print two polynomials in the following format.
In the first line print a single integer m (0 ≤ m ≤ n) — the degree of the polynomial.
In the second line print m + 1 integers between - 1 and 1 — the coefficients of the polynomial, from constant to leading.
The degree of the first polynomial should be greater than the degree of the second polynomial, the leading coefficients should be equal to 1. Euclid's algorithm should perform exactly n steps when called using these polynomials.
If there is no answer for the given n, print -1.
If there are multiple answer, print any of them.
Examples
Input
1
Output
1
0 1
0
1
Input
2
Output
2
-1 0 1
1
0 1
Note
In the second example you can print polynomials x2 - 1 and x. The sequence of transitions is
(x2 - 1, x) → (x, - 1) → ( - 1, 0).
There are two steps in it. | instruction | 0 | 69,559 | 22 | 139,118 |
Tags: constructive algorithms, math
Correct Solution:
```
n = int(input())
c = [0,1]
p = [1]
for i in range(1, n):
nc = [0] + c
rev=False
for j in range(len(p)):
nc[j] -= p[j]
if abs(nc[j]) > 1:
rev = True
if rev:
for j in range(len(p)):
nc[j] += 2*p[j]
if abs(nc[j]) > 1:
rev = True
p = c
c = nc
print(len(c)-1)
print(' '.join([str(i) for i in c]))
print(len(p)-1)
print(' '.join([str(i) for i in p]))
``` | output | 1 | 69,559 | 22 | 139,119 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Suppose you have two polynomials <image> and <image>. Then polynomial <image> can be uniquely represented in the following way:
<image>
This can be done using [long division](https://en.wikipedia.org/wiki/Polynomial_long_division). Here, <image> denotes the degree of polynomial P(x). <image> is called the remainder of division of polynomial <image> by polynomial <image>, it is also denoted as <image>.
Since there is a way to divide polynomials with remainder, we can define Euclid's algorithm of finding the greatest common divisor of two polynomials. The algorithm takes two polynomials <image>. If the polynomial <image> is zero, the result is <image>, otherwise the result is the value the algorithm returns for pair <image>. On each step the degree of the second argument decreases, so the algorithm works in finite number of steps. But how large that number could be? You are to answer this question.
You are given an integer n. You have to build two polynomials with degrees not greater than n, such that their coefficients are integers not exceeding 1 by their absolute value, the leading coefficients (ones with the greatest power of x) are equal to one, and the described Euclid's algorithm performs exactly n steps finding their greatest common divisor. Moreover, the degree of the first polynomial should be greater than the degree of the second. By a step of the algorithm we mean the transition from pair <image> to pair <image>.
Input
You are given a single integer n (1 ≤ n ≤ 150) — the number of steps of the algorithm you need to reach.
Output
Print two polynomials in the following format.
In the first line print a single integer m (0 ≤ m ≤ n) — the degree of the polynomial.
In the second line print m + 1 integers between - 1 and 1 — the coefficients of the polynomial, from constant to leading.
The degree of the first polynomial should be greater than the degree of the second polynomial, the leading coefficients should be equal to 1. Euclid's algorithm should perform exactly n steps when called using these polynomials.
If there is no answer for the given n, print -1.
If there are multiple answer, print any of them.
Examples
Input
1
Output
1
0 1
0
1
Input
2
Output
2
-1 0 1
1
0 1
Note
In the second example you can print polynomials x2 - 1 and x. The sequence of transitions is
(x2 - 1, x) → (x, - 1) → ( - 1, 0).
There are two steps in it. | instruction | 0 | 69,560 | 22 | 139,120 |
Tags: constructive algorithms, math
Correct Solution:
```
import sys
#f = open('input', 'r')
f = sys.stdin
n = f.readline()
n = int(n)
t = [[0], [1]]
for j in range(n):
cur = [0] + t[-1]
for i, x in enumerate(t[-2]):
cur[i] += x
if min(cur) < -1 or max(cur) > 1:
cur = [0] + t[-1]
for i, x in enumerate(t[-2]):
cur[i] -= x
t.append(cur)
print(len(t[n+1])-1)
print(' '.join([str(x) for x in t[n+1]]))
print(len(t[n])-1)
print(' '.join([str(x) for x in t[n]]))
``` | output | 1 | 69,560 | 22 | 139,121 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Suppose you have two polynomials <image> and <image>. Then polynomial <image> can be uniquely represented in the following way:
<image>
This can be done using [long division](https://en.wikipedia.org/wiki/Polynomial_long_division). Here, <image> denotes the degree of polynomial P(x). <image> is called the remainder of division of polynomial <image> by polynomial <image>, it is also denoted as <image>.
Since there is a way to divide polynomials with remainder, we can define Euclid's algorithm of finding the greatest common divisor of two polynomials. The algorithm takes two polynomials <image>. If the polynomial <image> is zero, the result is <image>, otherwise the result is the value the algorithm returns for pair <image>. On each step the degree of the second argument decreases, so the algorithm works in finite number of steps. But how large that number could be? You are to answer this question.
You are given an integer n. You have to build two polynomials with degrees not greater than n, such that their coefficients are integers not exceeding 1 by their absolute value, the leading coefficients (ones with the greatest power of x) are equal to one, and the described Euclid's algorithm performs exactly n steps finding their greatest common divisor. Moreover, the degree of the first polynomial should be greater than the degree of the second. By a step of the algorithm we mean the transition from pair <image> to pair <image>.
Input
You are given a single integer n (1 ≤ n ≤ 150) — the number of steps of the algorithm you need to reach.
Output
Print two polynomials in the following format.
In the first line print a single integer m (0 ≤ m ≤ n) — the degree of the polynomial.
In the second line print m + 1 integers between - 1 and 1 — the coefficients of the polynomial, from constant to leading.
The degree of the first polynomial should be greater than the degree of the second polynomial, the leading coefficients should be equal to 1. Euclid's algorithm should perform exactly n steps when called using these polynomials.
If there is no answer for the given n, print -1.
If there are multiple answer, print any of them.
Examples
Input
1
Output
1
0 1
0
1
Input
2
Output
2
-1 0 1
1
0 1
Note
In the second example you can print polynomials x2 - 1 and x. The sequence of transitions is
(x2 - 1, x) → (x, - 1) → ( - 1, 0).
There are two steps in it. | instruction | 0 | 69,561 | 22 | 139,122 |
Tags: constructive algorithms, math
Correct Solution:
```
from random import getrandbits as R
rb=lambda:R(1)
def modu(p,q):
if len(q)==1:
return [0]
p=p[:]
for d in range(len(p)-1,len(q)-2,-1):
#print(d)
a = p.pop()
b = q[-1]
B = [-k*a/b for k in q[:-1]]
#print(B)
for i in range(len(B)):
p[i+1+len(p)-1-(len(q)-1)] += B[i]
while len(p)>1 and abs(p[-1])<1E-6:
p.pop()
return p
def gcd(p,q):
#print(p,q)
if len(q)==1 and abs(q[0])<1E-6:
return p,1
#if len(q)<=1:
# return q,1
else:
p,iters = gcd(q,modu(p,q))
return p,iters+1
#p,iters = gcd([5,3,2],[-10,1])
#print(p,iters)
#q,iters = gcd([2,5,4,1],[3,4,1])
#print(q,iters)
for n in [int(input())]:#range(150,0,-1):
while True:
p = [1]*(n+1)
q = [1]*(n)
for i in range(n):
p[i]=rb()
for i in range(n-1):
q[i]=rb()
Q,iters = gcd(p,q)
if iters<n+1:
continue
#print(Q,iters)
print(len(p)-1)
print(*p)
print(len(q)-1)
print(*q)
break
``` | output | 1 | 69,561 | 22 | 139,123 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Suppose you have two polynomials <image> and <image>. Then polynomial <image> can be uniquely represented in the following way:
<image>
This can be done using [long division](https://en.wikipedia.org/wiki/Polynomial_long_division). Here, <image> denotes the degree of polynomial P(x). <image> is called the remainder of division of polynomial <image> by polynomial <image>, it is also denoted as <image>.
Since there is a way to divide polynomials with remainder, we can define Euclid's algorithm of finding the greatest common divisor of two polynomials. The algorithm takes two polynomials <image>. If the polynomial <image> is zero, the result is <image>, otherwise the result is the value the algorithm returns for pair <image>. On each step the degree of the second argument decreases, so the algorithm works in finite number of steps. But how large that number could be? You are to answer this question.
You are given an integer n. You have to build two polynomials with degrees not greater than n, such that their coefficients are integers not exceeding 1 by their absolute value, the leading coefficients (ones with the greatest power of x) are equal to one, and the described Euclid's algorithm performs exactly n steps finding their greatest common divisor. Moreover, the degree of the first polynomial should be greater than the degree of the second. By a step of the algorithm we mean the transition from pair <image> to pair <image>.
Input
You are given a single integer n (1 ≤ n ≤ 150) — the number of steps of the algorithm you need to reach.
Output
Print two polynomials in the following format.
In the first line print a single integer m (0 ≤ m ≤ n) — the degree of the polynomial.
In the second line print m + 1 integers between - 1 and 1 — the coefficients of the polynomial, from constant to leading.
The degree of the first polynomial should be greater than the degree of the second polynomial, the leading coefficients should be equal to 1. Euclid's algorithm should perform exactly n steps when called using these polynomials.
If there is no answer for the given n, print -1.
If there are multiple answer, print any of them.
Examples
Input
1
Output
1
0 1
0
1
Input
2
Output
2
-1 0 1
1
0 1
Note
In the second example you can print polynomials x2 - 1 and x. The sequence of transitions is
(x2 - 1, x) → (x, - 1) → ( - 1, 0).
There are two steps in it. | instruction | 0 | 69,562 | 22 | 139,124 |
Tags: constructive algorithms, math
Correct Solution:
```
B = [1, 0] # 1x + 0
R = [1] # 0x + 1
A = list(B)
n = int(input())
for i in range(1, n):
A += [0]
# print('A =', A)
# print('R =', R)
# print('B =', B)
for j in range(-1, -len(R)-1, -1):
A[len(A)+j] += R[len(R)+j]
if A[len(A)+j] == 2:
A[len(A)+j] = 0
R = list(B)
B = list(A)
# print(i, A, R)
print(len(B)-1)
for u in reversed(B):
print(u, end=' ')
print()
print(len(R)-1)
for u in reversed(R):
print(u, end=' ')
print()
``` | output | 1 | 69,562 | 22 | 139,125 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Suppose you have two polynomials <image> and <image>. Then polynomial <image> can be uniquely represented in the following way:
<image>
This can be done using [long division](https://en.wikipedia.org/wiki/Polynomial_long_division). Here, <image> denotes the degree of polynomial P(x). <image> is called the remainder of division of polynomial <image> by polynomial <image>, it is also denoted as <image>.
Since there is a way to divide polynomials with remainder, we can define Euclid's algorithm of finding the greatest common divisor of two polynomials. The algorithm takes two polynomials <image>. If the polynomial <image> is zero, the result is <image>, otherwise the result is the value the algorithm returns for pair <image>. On each step the degree of the second argument decreases, so the algorithm works in finite number of steps. But how large that number could be? You are to answer this question.
You are given an integer n. You have to build two polynomials with degrees not greater than n, such that their coefficients are integers not exceeding 1 by their absolute value, the leading coefficients (ones with the greatest power of x) are equal to one, and the described Euclid's algorithm performs exactly n steps finding their greatest common divisor. Moreover, the degree of the first polynomial should be greater than the degree of the second. By a step of the algorithm we mean the transition from pair <image> to pair <image>.
Input
You are given a single integer n (1 ≤ n ≤ 150) — the number of steps of the algorithm you need to reach.
Output
Print two polynomials in the following format.
In the first line print a single integer m (0 ≤ m ≤ n) — the degree of the polynomial.
In the second line print m + 1 integers between - 1 and 1 — the coefficients of the polynomial, from constant to leading.
The degree of the first polynomial should be greater than the degree of the second polynomial, the leading coefficients should be equal to 1. Euclid's algorithm should perform exactly n steps when called using these polynomials.
If there is no answer for the given n, print -1.
If there are multiple answer, print any of them.
Examples
Input
1
Output
1
0 1
0
1
Input
2
Output
2
-1 0 1
1
0 1
Note
In the second example you can print polynomials x2 - 1 and x. The sequence of transitions is
(x2 - 1, x) → (x, - 1) → ( - 1, 0).
There are two steps in it. | instruction | 0 | 69,563 | 22 | 139,126 |
Tags: constructive algorithms, math
Correct Solution:
```
a_coeffs = [1, 0, -1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, -1, 0, 1, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, -1, 0, 1, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, -1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, -1, 0, 1, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 1, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, -1, 0, 1, 0, -1, 0, 0, 0, 1]
b_coeffs = [1, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, -1, 0]
def rem(a, b):
assert len(a) == len(b) + 1
coeff = a[0] * b[0]
if a[0] == -1:
a = [-c for c in a]
if b[0] == -1:
b = [-c for c in b]
b = b + [0]
assert len(a) == len(b)
r = [c1 - c2 for (c1, c2) in zip(a, b)]
assert r[0] == 0 and r[1] == 0 and r[2] != 0
r = r[2:]
r = [coeff * c for c in r]
return r
def solve(n):
a, b = a_coeffs, b_coeffs
for _ in range(n, 150):
a, b = b, rem(a, b)
if a[0] == -1:
a = [-c for c in a]
if b[0] == -1:
b = [-c for c in b]
return a, b
n = int(input())
a, b = solve(n)
print(len(a) - 1)
print(' '.join(str(c) for c in reversed(a)))
print(len(b) - 1)
print(' '.join(str(c) for c in reversed(b)))
``` | output | 1 | 69,563 | 22 | 139,127 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Suppose you have two polynomials <image> and <image>. Then polynomial <image> can be uniquely represented in the following way:
<image>
This can be done using [long division](https://en.wikipedia.org/wiki/Polynomial_long_division). Here, <image> denotes the degree of polynomial P(x). <image> is called the remainder of division of polynomial <image> by polynomial <image>, it is also denoted as <image>.
Since there is a way to divide polynomials with remainder, we can define Euclid's algorithm of finding the greatest common divisor of two polynomials. The algorithm takes two polynomials <image>. If the polynomial <image> is zero, the result is <image>, otherwise the result is the value the algorithm returns for pair <image>. On each step the degree of the second argument decreases, so the algorithm works in finite number of steps. But how large that number could be? You are to answer this question.
You are given an integer n. You have to build two polynomials with degrees not greater than n, such that their coefficients are integers not exceeding 1 by their absolute value, the leading coefficients (ones with the greatest power of x) are equal to one, and the described Euclid's algorithm performs exactly n steps finding their greatest common divisor. Moreover, the degree of the first polynomial should be greater than the degree of the second. By a step of the algorithm we mean the transition from pair <image> to pair <image>.
Input
You are given a single integer n (1 ≤ n ≤ 150) — the number of steps of the algorithm you need to reach.
Output
Print two polynomials in the following format.
In the first line print a single integer m (0 ≤ m ≤ n) — the degree of the polynomial.
In the second line print m + 1 integers between - 1 and 1 — the coefficients of the polynomial, from constant to leading.
The degree of the first polynomial should be greater than the degree of the second polynomial, the leading coefficients should be equal to 1. Euclid's algorithm should perform exactly n steps when called using these polynomials.
If there is no answer for the given n, print -1.
If there are multiple answer, print any of them.
Examples
Input
1
Output
1
0 1
0
1
Input
2
Output
2
-1 0 1
1
0 1
Note
In the second example you can print polynomials x2 - 1 and x. The sequence of transitions is
(x2 - 1, x) → (x, - 1) → ( - 1, 0).
There are two steps in it.
Submitted Solution:
```
n = int(input())
A = [0 for i in range(n + 1)]
B = [0 for i in range(n + 1)]
A[0] = 1
for i in range(n):
temp = A[:]
for j in reversed(range(1, n + 1)):
A[j] = (A[j - 1] + B[j]) % 2
A[0] = B[0]
B = temp
print(n)
for i in range(n):
print(A[i], end=' ')
print(A[n])
print(n - 1)
for i in range(n):
print(B[i], end=' ')
``` | instruction | 0 | 69,564 | 22 | 139,128 |
Yes | output | 1 | 69,564 | 22 | 139,129 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Suppose you have two polynomials <image> and <image>. Then polynomial <image> can be uniquely represented in the following way:
<image>
This can be done using [long division](https://en.wikipedia.org/wiki/Polynomial_long_division). Here, <image> denotes the degree of polynomial P(x). <image> is called the remainder of division of polynomial <image> by polynomial <image>, it is also denoted as <image>.
Since there is a way to divide polynomials with remainder, we can define Euclid's algorithm of finding the greatest common divisor of two polynomials. The algorithm takes two polynomials <image>. If the polynomial <image> is zero, the result is <image>, otherwise the result is the value the algorithm returns for pair <image>. On each step the degree of the second argument decreases, so the algorithm works in finite number of steps. But how large that number could be? You are to answer this question.
You are given an integer n. You have to build two polynomials with degrees not greater than n, such that their coefficients are integers not exceeding 1 by their absolute value, the leading coefficients (ones with the greatest power of x) are equal to one, and the described Euclid's algorithm performs exactly n steps finding their greatest common divisor. Moreover, the degree of the first polynomial should be greater than the degree of the second. By a step of the algorithm we mean the transition from pair <image> to pair <image>.
Input
You are given a single integer n (1 ≤ n ≤ 150) — the number of steps of the algorithm you need to reach.
Output
Print two polynomials in the following format.
In the first line print a single integer m (0 ≤ m ≤ n) — the degree of the polynomial.
In the second line print m + 1 integers between - 1 and 1 — the coefficients of the polynomial, from constant to leading.
The degree of the first polynomial should be greater than the degree of the second polynomial, the leading coefficients should be equal to 1. Euclid's algorithm should perform exactly n steps when called using these polynomials.
If there is no answer for the given n, print -1.
If there are multiple answer, print any of them.
Examples
Input
1
Output
1
0 1
0
1
Input
2
Output
2
-1 0 1
1
0 1
Note
In the second example you can print polynomials x2 - 1 and x. The sequence of transitions is
(x2 - 1, x) → (x, - 1) → ( - 1, 0).
There are two steps in it.
Submitted Solution:
```
f = [[1], [0, 1]]
n = int(input())
for i in range(2, n + 1):
l = [0] + f[i - 1]
for j in range(len(f[i - 2])):
l[j] = (l[j] + f[i - 2][j]) & 1
f.append(l)
print(n)
print(*f[n])
print(n - 1)
print(*f[n - 1])
``` | instruction | 0 | 69,565 | 22 | 139,130 |
Yes | output | 1 | 69,565 | 22 | 139,131 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Suppose you have two polynomials <image> and <image>. Then polynomial <image> can be uniquely represented in the following way:
<image>
This can be done using [long division](https://en.wikipedia.org/wiki/Polynomial_long_division). Here, <image> denotes the degree of polynomial P(x). <image> is called the remainder of division of polynomial <image> by polynomial <image>, it is also denoted as <image>.
Since there is a way to divide polynomials with remainder, we can define Euclid's algorithm of finding the greatest common divisor of two polynomials. The algorithm takes two polynomials <image>. If the polynomial <image> is zero, the result is <image>, otherwise the result is the value the algorithm returns for pair <image>. On each step the degree of the second argument decreases, so the algorithm works in finite number of steps. But how large that number could be? You are to answer this question.
You are given an integer n. You have to build two polynomials with degrees not greater than n, such that their coefficients are integers not exceeding 1 by their absolute value, the leading coefficients (ones with the greatest power of x) are equal to one, and the described Euclid's algorithm performs exactly n steps finding their greatest common divisor. Moreover, the degree of the first polynomial should be greater than the degree of the second. By a step of the algorithm we mean the transition from pair <image> to pair <image>.
Input
You are given a single integer n (1 ≤ n ≤ 150) — the number of steps of the algorithm you need to reach.
Output
Print two polynomials in the following format.
In the first line print a single integer m (0 ≤ m ≤ n) — the degree of the polynomial.
In the second line print m + 1 integers between - 1 and 1 — the coefficients of the polynomial, from constant to leading.
The degree of the first polynomial should be greater than the degree of the second polynomial, the leading coefficients should be equal to 1. Euclid's algorithm should perform exactly n steps when called using these polynomials.
If there is no answer for the given n, print -1.
If there are multiple answer, print any of them.
Examples
Input
1
Output
1
0 1
0
1
Input
2
Output
2
-1 0 1
1
0 1
Note
In the second example you can print polynomials x2 - 1 and x. The sequence of transitions is
(x2 - 1, x) → (x, - 1) → ( - 1, 0).
There are two steps in it.
Submitted Solution:
```
n = int(input())
A = [0 for i in range(n + 1)]
B = [0 for i in range(n + 1)]
A[0] = 1
for i in range(n):
temp = A[:]
for j in reversed(range(1, n + 1)):
A[j] = (A[j - 1] + B[j]) % 2
A[0] = B[0]
B = temp
for i in range(n):
print(A[i], end=' ')
print(A[n])
for i in range(n):
print(B[i], end=' ')
print(B[n])
``` | instruction | 0 | 69,566 | 22 | 139,132 |
No | output | 1 | 69,566 | 22 | 139,133 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Suppose you have two polynomials <image> and <image>. Then polynomial <image> can be uniquely represented in the following way:
<image>
This can be done using [long division](https://en.wikipedia.org/wiki/Polynomial_long_division). Here, <image> denotes the degree of polynomial P(x). <image> is called the remainder of division of polynomial <image> by polynomial <image>, it is also denoted as <image>.
Since there is a way to divide polynomials with remainder, we can define Euclid's algorithm of finding the greatest common divisor of two polynomials. The algorithm takes two polynomials <image>. If the polynomial <image> is zero, the result is <image>, otherwise the result is the value the algorithm returns for pair <image>. On each step the degree of the second argument decreases, so the algorithm works in finite number of steps. But how large that number could be? You are to answer this question.
You are given an integer n. You have to build two polynomials with degrees not greater than n, such that their coefficients are integers not exceeding 1 by their absolute value, the leading coefficients (ones with the greatest power of x) are equal to one, and the described Euclid's algorithm performs exactly n steps finding their greatest common divisor. Moreover, the degree of the first polynomial should be greater than the degree of the second. By a step of the algorithm we mean the transition from pair <image> to pair <image>.
Input
You are given a single integer n (1 ≤ n ≤ 150) — the number of steps of the algorithm you need to reach.
Output
Print two polynomials in the following format.
In the first line print a single integer m (0 ≤ m ≤ n) — the degree of the polynomial.
In the second line print m + 1 integers between - 1 and 1 — the coefficients of the polynomial, from constant to leading.
The degree of the first polynomial should be greater than the degree of the second polynomial, the leading coefficients should be equal to 1. Euclid's algorithm should perform exactly n steps when called using these polynomials.
If there is no answer for the given n, print -1.
If there are multiple answer, print any of them.
Examples
Input
1
Output
1
0 1
0
1
Input
2
Output
2
-1 0 1
1
0 1
Note
In the second example you can print polynomials x2 - 1 and x. The sequence of transitions is
(x2 - 1, x) → (x, - 1) → ( - 1, 0).
There are two steps in it.
Submitted Solution:
```
n = int(input())
c = [0,1]
p = [1]
for i in range(2, n):
nc = [0] + c
rev=False
for j in range(len(p)):
nc[j] -= p[j]
if abs(nc[j]) > 1:
rev = True
if rev:
for j in range(len(p)):
nc[j] += 2*p[j]
if abs(nc[j]) > 1:
rev = True
p = c
c = nc
print(len(c)-1)
print(' '.join([str(i) for i in c]))
print(len(p)-1)
print(' '.join([str(i) for i in p]))
``` | instruction | 0 | 69,567 | 22 | 139,134 |
No | output | 1 | 69,567 | 22 | 139,135 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Suppose you have two polynomials <image> and <image>. Then polynomial <image> can be uniquely represented in the following way:
<image>
This can be done using [long division](https://en.wikipedia.org/wiki/Polynomial_long_division). Here, <image> denotes the degree of polynomial P(x). <image> is called the remainder of division of polynomial <image> by polynomial <image>, it is also denoted as <image>.
Since there is a way to divide polynomials with remainder, we can define Euclid's algorithm of finding the greatest common divisor of two polynomials. The algorithm takes two polynomials <image>. If the polynomial <image> is zero, the result is <image>, otherwise the result is the value the algorithm returns for pair <image>. On each step the degree of the second argument decreases, so the algorithm works in finite number of steps. But how large that number could be? You are to answer this question.
You are given an integer n. You have to build two polynomials with degrees not greater than n, such that their coefficients are integers not exceeding 1 by their absolute value, the leading coefficients (ones with the greatest power of x) are equal to one, and the described Euclid's algorithm performs exactly n steps finding their greatest common divisor. Moreover, the degree of the first polynomial should be greater than the degree of the second. By a step of the algorithm we mean the transition from pair <image> to pair <image>.
Input
You are given a single integer n (1 ≤ n ≤ 150) — the number of steps of the algorithm you need to reach.
Output
Print two polynomials in the following format.
In the first line print a single integer m (0 ≤ m ≤ n) — the degree of the polynomial.
In the second line print m + 1 integers between - 1 and 1 — the coefficients of the polynomial, from constant to leading.
The degree of the first polynomial should be greater than the degree of the second polynomial, the leading coefficients should be equal to 1. Euclid's algorithm should perform exactly n steps when called using these polynomials.
If there is no answer for the given n, print -1.
If there are multiple answer, print any of them.
Examples
Input
1
Output
1
0 1
0
1
Input
2
Output
2
-1 0 1
1
0 1
Note
In the second example you can print polynomials x2 - 1 and x. The sequence of transitions is
(x2 - 1, x) → (x, - 1) → ( - 1, 0).
There are two steps in it.
Submitted Solution:
```
B = [1, 0] # 1x + 0
R = [1] # 0x + 1
A = list(B)
n = int(input())
for i in range(1, n+1):
A += [0]
# print('A =', A)
# print('R =', R)
# print('B =', B)
for j in range(-1, -len(R)-1, -1):
A[len(A)+j] += R[len(R)+j]
if A[len(A)+j] == 2:
A[len(A)+j] = 0
R = list(B)
B = list(A)
# print(i, A, R)
print(len(B)-1)
for u in reversed(B):
print(u, end=' ')
print()
print(len(R)-1)
for u in reversed(R):
print(u, end=' ')
print()
``` | instruction | 0 | 69,568 | 22 | 139,136 |
No | output | 1 | 69,568 | 22 | 139,137 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Suppose you have two polynomials <image> and <image>. Then polynomial <image> can be uniquely represented in the following way:
<image>
This can be done using [long division](https://en.wikipedia.org/wiki/Polynomial_long_division). Here, <image> denotes the degree of polynomial P(x). <image> is called the remainder of division of polynomial <image> by polynomial <image>, it is also denoted as <image>.
Since there is a way to divide polynomials with remainder, we can define Euclid's algorithm of finding the greatest common divisor of two polynomials. The algorithm takes two polynomials <image>. If the polynomial <image> is zero, the result is <image>, otherwise the result is the value the algorithm returns for pair <image>. On each step the degree of the second argument decreases, so the algorithm works in finite number of steps. But how large that number could be? You are to answer this question.
You are given an integer n. You have to build two polynomials with degrees not greater than n, such that their coefficients are integers not exceeding 1 by their absolute value, the leading coefficients (ones with the greatest power of x) are equal to one, and the described Euclid's algorithm performs exactly n steps finding their greatest common divisor. Moreover, the degree of the first polynomial should be greater than the degree of the second. By a step of the algorithm we mean the transition from pair <image> to pair <image>.
Input
You are given a single integer n (1 ≤ n ≤ 150) — the number of steps of the algorithm you need to reach.
Output
Print two polynomials in the following format.
In the first line print a single integer m (0 ≤ m ≤ n) — the degree of the polynomial.
In the second line print m + 1 integers between - 1 and 1 — the coefficients of the polynomial, from constant to leading.
The degree of the first polynomial should be greater than the degree of the second polynomial, the leading coefficients should be equal to 1. Euclid's algorithm should perform exactly n steps when called using these polynomials.
If there is no answer for the given n, print -1.
If there are multiple answer, print any of them.
Examples
Input
1
Output
1
0 1
0
1
Input
2
Output
2
-1 0 1
1
0 1
Note
In the second example you can print polynomials x2 - 1 and x. The sequence of transitions is
(x2 - 1, x) → (x, - 1) → ( - 1, 0).
There are two steps in it.
Submitted Solution:
```
from random import getrandbits as R
rb=lambda:R(1)
def modu(p,q):
if len(q)==1:
return [0]
p=p[:]
for d in range(len(p)-1,len(q)-2,-1):
#print(d)
a = p.pop()
b = q[-1]
B = [-k*a/b for k in q[:-1]]
#print(B)
for i in range(len(B)):
p[i+1+len(p)-1-(len(q)-1)] += B[i]
while len(p)>1 and abs(p[-1])<1E-6:
p.pop()
return p
def gcd(p,q):
#print(p,q)
if len(q)==1 and abs(q[0])<1E-6:
return p,1
#if len(q)<=1:
# return q,1
else:
p,iters = gcd(q,modu(p,q))
return p,iters+1
#p,iters = gcd([5,3,2],[-10,1])
#print(p,iters)
#q,iters = gcd([2,5,4,1],[3,4,1])
#print(q,iters)
for n in [int(input())]:#range(150,0,-1):
while True:
p = [1]*(n+1)
q = [1]*(n)
for i in range(n):
p[i]=rb()
for i in range(n-1):
q[i]=rb()
Q,iters = gcd(p,q)
if iters<n:
continue
#print(Q,iters)
print(len(p)-1)
print(*p)
print(len(q)-1)
print(*q)
break
``` | instruction | 0 | 69,569 | 22 | 139,138 |
No | output | 1 | 69,569 | 22 | 139,139 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We call a positive integer x a k-beautiful integer if and only if it is possible to split the multiset of its digits in the decimal representation into two subsets such that the difference between the sum of digits in one subset and the sum of digits in the other subset is less than or equal to k. Each digit should belong to exactly one subset after the split.
There are n queries for you. Each query is described with three integers l, r and k, which mean that you are asked how many integers x between l and r (inclusive) are k-beautiful.
Input
The first line contains a single integer n (1 ≤ n ≤ 5·104), indicating the number of queries.
Each of the next n lines describes a query, containing three integers l, r and k (1 ≤ l ≤ r ≤ 1018, 0 ≤ k ≤ 9).
Output
For each query print a single number — the answer to the query.
Examples
Input
10
1 100 0
1 100 1
1 100 2
1 100 3
1 100 4
1 100 5
1 100 6
1 100 7
1 100 8
1 100 9
Output
9
28
44
58
70
80
88
94
98
100
Input
10
1 1000 0
1 1000 1
1 1000 2
1 1000 3
1 1000 4
1 1000 5
1 1000 6
1 1000 7
1 1000 8
1 1000 9
Output
135
380
573
721
830
906
955
983
996
1000
Note
If 1 ≤ x ≤ 9, integer x is k-beautiful if and only if x ≤ k.
If 10 ≤ x ≤ 99, integer x = 10a + b is k-beautiful if and only if |a - b| ≤ k, where a and b are integers between 0 and 9, inclusive.
100 is k-beautiful if and only if k ≥ 1.
Submitted Solution:
```
def sum_up(seen, unseen):
val = 10
if len(unseen) == 0:
return val
if len(seen) == 0:
for i in unseen:
_ = unseen.copy()
_.remove(i)
_ = sum_up([i], _)
if _ < val:
val = _
else:
_ = abs(sum(seen) - sum(unseen))
if _ < val:
val = _
for i in unseen:
_ = unseen.copy()
_.remove(i)
_ = sum_up(seen + [i], _)
if _ < val:
val = _
# print(seen, unseen, val)
return val
def find_k(num):
val = [int(i) for i in str(num)]
return sum_up([], val)
def solve():
c = int(input())
for j in range(c):
l, r, k = map(int, input().strip().split())
count = 0
for i in range(l, r + 1):
if find_k(i) <= k:
count += 1
print(count + k)
solve()
# print(find_k(248))
``` | instruction | 0 | 69,570 | 22 | 139,140 |
No | output | 1 | 69,570 | 22 | 139,141 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We call a positive integer x a k-beautiful integer if and only if it is possible to split the multiset of its digits in the decimal representation into two subsets such that the difference between the sum of digits in one subset and the sum of digits in the other subset is less than or equal to k. Each digit should belong to exactly one subset after the split.
There are n queries for you. Each query is described with three integers l, r and k, which mean that you are asked how many integers x between l and r (inclusive) are k-beautiful.
Input
The first line contains a single integer n (1 ≤ n ≤ 5·104), indicating the number of queries.
Each of the next n lines describes a query, containing three integers l, r and k (1 ≤ l ≤ r ≤ 1018, 0 ≤ k ≤ 9).
Output
For each query print a single number — the answer to the query.
Examples
Input
10
1 100 0
1 100 1
1 100 2
1 100 3
1 100 4
1 100 5
1 100 6
1 100 7
1 100 8
1 100 9
Output
9
28
44
58
70
80
88
94
98
100
Input
10
1 1000 0
1 1000 1
1 1000 2
1 1000 3
1 1000 4
1 1000 5
1 1000 6
1 1000 7
1 1000 8
1 1000 9
Output
135
380
573
721
830
906
955
983
996
1000
Note
If 1 ≤ x ≤ 9, integer x is k-beautiful if and only if x ≤ k.
If 10 ≤ x ≤ 99, integer x = 10a + b is k-beautiful if and only if |a - b| ≤ k, where a and b are integers between 0 and 9, inclusive.
100 is k-beautiful if and only if k ≥ 1.
Submitted Solution:
```
Plist = []
n = []
k = []
mod = 7 + 10**9
def fast_pow(base, n, M):
if (n==0):
return 1
if (n==1):
return base
halfn = fast_pow(base, int(n/2), M)
if (n%2 == 0):
return (halfn*halfn) % M
else:
return (((halfn*halfn) % M)*base) % M
def findMMI_fermat(n, M):
return int(fast_pow(n, M-2, M))
test_case = int(input())
for test_number in range(test_case):
Plist.append(input())
n.append(int(Plist[test_number].split()[0]))
k.append(int(Plist[test_number].split()[1]))
for test_number in range(test_case):
# Find GCD of n and k
a = n[test_number]
b = k[test_number]
while (b != 0):
t = b
b = a % b
a = t
c = int(n[test_number]*k[test_number]/a)
cn = k[test_number]/a
ck = n[test_number]/a
y_nom = 0
j = 1
m = 1
for i in range(1, c+1):
y_nom += (2**(cn-j))*m
if (i%n[test_number] == 0):
j += 1
if (i%k[test_number] == 0):
m += 1
x_nom = y_nom + ck*n[test_number]
x_denom = n[test_number]*((2**cn)-1)
a = x_nom
b = x_denom
while (b != 0):
t = b
b = a % b
a = t
x_nom_min = int(x_nom / a)
x_denom_min = int(x_denom / a)
x2_denom = findMMI_fermat(x_denom_min, mod)
expected_value = ((x_nom_min%mod)*(x2_denom%mod)) % mod
print(expected_value)
``` | instruction | 0 | 69,571 | 22 | 139,142 |
No | output | 1 | 69,571 | 22 | 139,143 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We call a positive integer x a k-beautiful integer if and only if it is possible to split the multiset of its digits in the decimal representation into two subsets such that the difference between the sum of digits in one subset and the sum of digits in the other subset is less than or equal to k. Each digit should belong to exactly one subset after the split.
There are n queries for you. Each query is described with three integers l, r and k, which mean that you are asked how many integers x between l and r (inclusive) are k-beautiful.
Input
The first line contains a single integer n (1 ≤ n ≤ 5·104), indicating the number of queries.
Each of the next n lines describes a query, containing three integers l, r and k (1 ≤ l ≤ r ≤ 1018, 0 ≤ k ≤ 9).
Output
For each query print a single number — the answer to the query.
Examples
Input
10
1 100 0
1 100 1
1 100 2
1 100 3
1 100 4
1 100 5
1 100 6
1 100 7
1 100 8
1 100 9
Output
9
28
44
58
70
80
88
94
98
100
Input
10
1 1000 0
1 1000 1
1 1000 2
1 1000 3
1 1000 4
1 1000 5
1 1000 6
1 1000 7
1 1000 8
1 1000 9
Output
135
380
573
721
830
906
955
983
996
1000
Note
If 1 ≤ x ≤ 9, integer x is k-beautiful if and only if x ≤ k.
If 10 ≤ x ≤ 99, integer x = 10a + b is k-beautiful if and only if |a - b| ≤ k, where a and b are integers between 0 and 9, inclusive.
100 is k-beautiful if and only if k ≥ 1.
Submitted Solution:
```
def sum_up(seen, unseen):
val = 10
if len(unseen) == 0:
return val
if len(seen) == 0:
for i in unseen:
_ = unseen.copy()
_.remove(i)
_ = sum_up([i], _)
if _ < val:
val = _
else:
_ = abs(sum(seen) - sum(unseen))
if _ < val:
val = _
for i in unseen:
_ = unseen.copy()
_.remove(i)
_ = sum_up(seen + [i], _)
if _ < val:
val = _
# print(seen, unseen, val)
return val
def find_k(num):
val = [int(i) for i in str(num)]
return sum_up([], val)
def solve():
c = int(input())
for j in range(c):
l, r, k = map(int, input().strip().split())
count = 0
for i in range(l, r + 1):
if find_k(i) <= k:
count += 1
print(count + j)
solve()
# print(find_k(248))
``` | instruction | 0 | 69,572 | 22 | 139,144 |
No | output | 1 | 69,572 | 22 | 139,145 |
Provide a correct Python 3 solution for this coding contest problem.
Given are integers L and R. Find the number, modulo 10^9 + 7, of pairs of integers (x, y) (L \leq x \leq y \leq R) such that the remainder when y is divided by x is equal to y \mbox{ XOR } x.
What is \mbox{ XOR }?
The XOR of integers A and B, A \mbox{ XOR } B, is defined as follows:
* When A \mbox{ XOR } B is written in base two, the digit in the 2^k's place (k \geq 0) is 1 if either A or B, but not both, has 1 in the 2^k's place, and 0 otherwise.
For example, 3 \mbox{ XOR } 5 = 6. (In base two: 011 \mbox{ XOR } 101 = 110.)
Constraints
* 1 \leq L \leq R \leq 10^{18}
Input
Input is given from Standard Input in the following format:
L R
Output
Print the number of pairs of integers (x, y) (L \leq x \leq y \leq R) satisfying the condition, modulo 10^9 + 7.
Examples
Input
2 3
Output
3
Input
10 100
Output
604
Input
1 1000000000000000000
Output
68038601 | instruction | 0 | 69,613 | 22 | 139,226 |
"Correct Solution:
```
MOD = 10**9 + 7
class mint:
def __init__(self, i):
self.i = i
def __add__(self, m):
t = self.i + (m.i if isinstance(m, mint) else m)
if t > MOD:
t -= MOD
return mint(t)
def __radd__(self, m):
t = self.i + (m.i if isinstance(m, mint) else m)
if t > MOD:
t -= MOD
return mint(t)
def __mul__(self, m):
return mint(self.i * (m.i if isinstance(m, mint) else m) % MOD)
def __sub__(self, m):
t = self.i - m.i
if t < 0:
t += MOD
return mint(t)
def __pow__(self, m):
i = self.i
res = 1
while(m > 0):
if m & 1:
res = res * i % MOD
i = i * i % MOD
m >>= 1
return mint(res)
def __truediv__(self, m):
return mint(self.i * (m ** (MOD - 2)).i % MOD)
def __repr__(self):
return repr(self.i)
L, R = map(int, input().split())
dp = [[mint(0) for _ in range(4)] for _ in range(61)]
for d in range(60, 0, -1):
l = L >> d - 1 & 1
r = R >> d - 1 & 1
if (L >> d - 1) == 0:
if (R >> d - 1) > 1:
dp[d-1][3] += 1
elif (R >> d - 1) == 1:
dp[d-1][2] += 1
elif (L >> d - 1) == 1:
if (R >> d - 1) > 1:
dp[d-1][1] += 1
else:
dp[d-1][0] += 1
# x bound, y bound
if l == r:
dp[d-1][0] += dp[d][0]
elif l < r:
dp[d-1][0] += dp[d][0]
dp[d-1][1] += dp[d][0]
dp[d-1][2] += dp[d][0]
# x bound, y free
if l == 0:
dp[d-1][1] += dp[d][1] * 2
dp[d-1][3] += dp[d][1]
else:
dp[d-1][1] += dp[d][1]
# x free, y bound
if r == 1:
dp[d-1][2] += dp[d][2] * 2
dp[d-1][3] += dp[d][2]
else:
dp[d-1][2] += dp[d][2]
# x free, y free
dp[d-1][3] += dp[d][3] * 3
print(sum(dp[0]))
``` | output | 1 | 69,613 | 22 | 139,227 |
Provide a correct Python 3 solution for this coding contest problem.
Given are integers L and R. Find the number, modulo 10^9 + 7, of pairs of integers (x, y) (L \leq x \leq y \leq R) such that the remainder when y is divided by x is equal to y \mbox{ XOR } x.
What is \mbox{ XOR }?
The XOR of integers A and B, A \mbox{ XOR } B, is defined as follows:
* When A \mbox{ XOR } B is written in base two, the digit in the 2^k's place (k \geq 0) is 1 if either A or B, but not both, has 1 in the 2^k's place, and 0 otherwise.
For example, 3 \mbox{ XOR } 5 = 6. (In base two: 011 \mbox{ XOR } 101 = 110.)
Constraints
* 1 \leq L \leq R \leq 10^{18}
Input
Input is given from Standard Input in the following format:
L R
Output
Print the number of pairs of integers (x, y) (L \leq x \leq y \leq R) satisfying the condition, modulo 10^9 + 7.
Examples
Input
2 3
Output
3
Input
10 100
Output
604
Input
1 1000000000000000000
Output
68038601 | instruction | 0 | 69,614 | 22 | 139,228 |
"Correct Solution:
```
L,R = map(int,input().split())
mod = 10**9+7
m = 64 +1
fac = [1]*m
ninv = [1]*m
finv = [1]*m
for i in range(2,m):
fac[i] = fac[i-1]*i%mod
ninv[i] = (-(mod//i)*ninv[mod%i])%mod
finv[i] = finv[i-1]*ninv[i]%mod
def comb(n,k):
return (fac[n]*finv[k]%mod)*finv[n-k]%mod
def f(N):
if N==0:return 0
S = bin(N)[2:]
L = len(S)
ret = pow(2,S.count("1")-1,mod)
for i in range(L):
if S[i] == "0" : continue
c = S[:i].count("1")
j = max(0,L-i-1)
for k in range(j+1):
if c+k == 0 : continue
ret += pow(2,c+k-1,mod)*comb(j,k)
ret %= mod
return ret
def g(R,L):
if L==0 : return 0
Nr = len(bin(R))-2
Nl = len(bin(L))-2
if Nr!=Nl :
R = int("1"*Nl,2)
Nr = Nl
ret = f(int("0"+"1"*(Nr-1),2))
R = bin(R)[2:]
L = bin(L)[2:]
for i in range(Nr):
if R[i] == "0": continue
if i==0 : R2 = R
else: R2 = R[:i] + "0" + "?"*(Nr-i-1)
for j in range(Nl):
if L[j] == "0" : continue
if j==0 : L2 = L
else: L2 = L[:j] + "0" + "?"*(Nl-j-1)
tmp = 1
for r,l in zip(R2,L2):
if r==l=="?" : tmp *= 3
if r=="?" and l=="0" : tmp *= 2
if r=="1" and l=="?" : tmp *= 2
if r=="0" and l=="1" : tmp *= 0
tmp %= mod
ret += tmp
return ret
print((f(R)-g(R,L-1))%mod)
``` | output | 1 | 69,614 | 22 | 139,229 |
Provide a correct Python 3 solution for this coding contest problem.
Given are integers L and R. Find the number, modulo 10^9 + 7, of pairs of integers (x, y) (L \leq x \leq y \leq R) such that the remainder when y is divided by x is equal to y \mbox{ XOR } x.
What is \mbox{ XOR }?
The XOR of integers A and B, A \mbox{ XOR } B, is defined as follows:
* When A \mbox{ XOR } B is written in base two, the digit in the 2^k's place (k \geq 0) is 1 if either A or B, but not both, has 1 in the 2^k's place, and 0 otherwise.
For example, 3 \mbox{ XOR } 5 = 6. (In base two: 011 \mbox{ XOR } 101 = 110.)
Constraints
* 1 \leq L \leq R \leq 10^{18}
Input
Input is given from Standard Input in the following format:
L R
Output
Print the number of pairs of integers (x, y) (L \leq x \leq y \leq R) satisfying the condition, modulo 10^9 + 7.
Examples
Input
2 3
Output
3
Input
10 100
Output
604
Input
1 1000000000000000000
Output
68038601 | instruction | 0 | 69,615 | 22 | 139,230 |
"Correct Solution:
```
L,R = map(int,input().split())
dp = []
for i in range(62):
nowA = []
for i in range(2):
nowB = []
for i in range(2):
nowC = []
for i in range(2):
nowC.append(0)
nowB.append(nowC)
nowA.append(nowB)
dp.append(nowA)
dp[0][0][0][0] = 1
#print (dp[3][0][0][0])
for i in range(61):
i += 1
keta = 62-i
lb = (L >> (keta-1)) % 2
rb = (R >> (keta-1)) % 2
for j in range(2):
for k in range(2):
for m in range(2):
pre = dp[i-1][j][k][m]
for x in range(2):
for y in range(2):
nj = j
nk = k
nm = m
if x == 1 and y == 0:
continue;
if x != y and m == 0:
continue;
if j == 0 and lb == 1 and x == 0:
continue;
if k == 0 and rb == 0 and y == 1:
continue;
if j == 0 and lb == 0 and x == 1:
nj = 1
if k == 0 and rb == 1 and y == 0:
nk = 1
if m == 0 and x == 1 and y == 1:
nm = 1
dp[i][nj][nk][nm] += dp[i-1][j][k][m]
dp[i][nj][nk][nm] %= 10 ** 9 +7
ans = 0
for j in range(2):
for k in range(2):
ans += dp[-1][j][k][1]
print (ans % (10 ** 9 + 7))
``` | output | 1 | 69,615 | 22 | 139,231 |
Provide a correct Python 3 solution for this coding contest problem.
Given are integers L and R. Find the number, modulo 10^9 + 7, of pairs of integers (x, y) (L \leq x \leq y \leq R) such that the remainder when y is divided by x is equal to y \mbox{ XOR } x.
What is \mbox{ XOR }?
The XOR of integers A and B, A \mbox{ XOR } B, is defined as follows:
* When A \mbox{ XOR } B is written in base two, the digit in the 2^k's place (k \geq 0) is 1 if either A or B, but not both, has 1 in the 2^k's place, and 0 otherwise.
For example, 3 \mbox{ XOR } 5 = 6. (In base two: 011 \mbox{ XOR } 101 = 110.)
Constraints
* 1 \leq L \leq R \leq 10^{18}
Input
Input is given from Standard Input in the following format:
L R
Output
Print the number of pairs of integers (x, y) (L \leq x \leq y \leq R) satisfying the condition, modulo 10^9 + 7.
Examples
Input
2 3
Output
3
Input
10 100
Output
604
Input
1 1000000000000000000
Output
68038601 | instruction | 0 | 69,616 | 22 | 139,232 |
"Correct Solution:
```
import sys
sys.setrecursionlimit(10**9)
from functools import lru_cache
mod=1000000007
@lru_cache()
def calc(l,r):
if l>r:
return 0
if r==0:
return 1
b_l,b_r=l.bit_length(),r.bit_length()
if b_l==b_r:
return calc(l-(1<<(b_l-1)),r-(1<<(b_r-1)))
if r==(1<<(b_r-1))-1 and l==0:
return pow(3,b_r,mod)
return (calc(l,r-(1<<(b_r-1)))+calc(l,(1<<(b_r-1))-1)+calc(0,r-(1<<b_r-1)))%mod
@lru_cache()
def solve(l,r):
if l>r:
return 0
b_l,b_r=l.bit_length(),r.bit_length()
if b_r>b_l:
return (solve(l,(1<<b_r-1)-1)+calc(0,r-(1<<(b_r-1))))%mod
a=1<<(b_l-1) if l else 0
return calc(l-a,r-a)
l,r=map(int,input().split())
print(solve(l,r))
``` | output | 1 | 69,616 | 22 | 139,233 |
Provide a correct Python 3 solution for this coding contest problem.
Given are integers L and R. Find the number, modulo 10^9 + 7, of pairs of integers (x, y) (L \leq x \leq y \leq R) such that the remainder when y is divided by x is equal to y \mbox{ XOR } x.
What is \mbox{ XOR }?
The XOR of integers A and B, A \mbox{ XOR } B, is defined as follows:
* When A \mbox{ XOR } B is written in base two, the digit in the 2^k's place (k \geq 0) is 1 if either A or B, but not both, has 1 in the 2^k's place, and 0 otherwise.
For example, 3 \mbox{ XOR } 5 = 6. (In base two: 011 \mbox{ XOR } 101 = 110.)
Constraints
* 1 \leq L \leq R \leq 10^{18}
Input
Input is given from Standard Input in the following format:
L R
Output
Print the number of pairs of integers (x, y) (L \leq x \leq y \leq R) satisfying the condition, modulo 10^9 + 7.
Examples
Input
2 3
Output
3
Input
10 100
Output
604
Input
1 1000000000000000000
Output
68038601 | instruction | 0 | 69,617 | 22 | 139,234 |
"Correct Solution:
```
L,R = map(int,input().split())
mod = 10**9+7
m = 64 +1
fac = [1]*m
ninv = [1]*m
finv = [1]*m
for i in range(2,m):
fac[i] = fac[i-1]*i%mod
ninv[i] = (-(mod//i)*ninv[mod%i])%mod
finv[i] = finv[i-1]*ninv[i]%mod
def comb(n,k):
return (fac[n]*finv[k]%mod)*finv[n-k]%mod
def f(L,R):
if L>R : return 0
R = bin(R)[2:]
N = len(R)
ret = f(L,int("0"+"1"*(N-1),2))
L = bin(L)[2:]
if len(L) != N : L = "1"+"0"*(N-1)
for i in range(N):
if R[i] == "0" : continue
R2 = R[:i] + "0" + "?"*(N-i-1)
if i==0: R2 = R
for j in range(N):
if L[j] == "1" and j!=0 : continue
L2 = L[:j] + "1" + "?"*(N-j-1)
if j==0 : L2 = L
if L2[0] == "0" : break
tmp = 1
for r,l in zip(R2[1:],L2[1:]):
if r=="0" and l=="1" : tmp *= 0
if r=="?" and l=="?" : tmp *= 3
if r=="?" and l=="0" : tmp *= 2
if r=="1" and l=="?" : tmp *= 2
tmp %= mod
ret += tmp
ret %= mod
return ret%mod
print(f(L,R))
``` | output | 1 | 69,617 | 22 | 139,235 |
Provide a correct Python 3 solution for this coding contest problem.
Given are integers L and R. Find the number, modulo 10^9 + 7, of pairs of integers (x, y) (L \leq x \leq y \leq R) such that the remainder when y is divided by x is equal to y \mbox{ XOR } x.
What is \mbox{ XOR }?
The XOR of integers A and B, A \mbox{ XOR } B, is defined as follows:
* When A \mbox{ XOR } B is written in base two, the digit in the 2^k's place (k \geq 0) is 1 if either A or B, but not both, has 1 in the 2^k's place, and 0 otherwise.
For example, 3 \mbox{ XOR } 5 = 6. (In base two: 011 \mbox{ XOR } 101 = 110.)
Constraints
* 1 \leq L \leq R \leq 10^{18}
Input
Input is given from Standard Input in the following format:
L R
Output
Print the number of pairs of integers (x, y) (L \leq x \leq y \leq R) satisfying the condition, modulo 10^9 + 7.
Examples
Input
2 3
Output
3
Input
10 100
Output
604
Input
1 1000000000000000000
Output
68038601 | instruction | 0 | 69,618 | 22 | 139,236 |
"Correct Solution:
```
mod = 10**9+7
def count(L, R):
res = 0
for j in range(70):
res = (res + subcount(j, L, R)) % mod
return res
def subcount(j, L, R):
if j >= L.bit_length():
return 0
dp = [[0]*4 for _ in range(70)]
cnt = 0
if R.bit_length() != j+1:
cnt += 1
if L.bit_length() != j+1:
cnt += 2
dp[j][cnt] = 1
for i in range(j, 0, -1):
yf = R & (1<<(i-1))
xf = L & (1<<(i-1))
d0 = dp[i][0]
if yf and xf:
dp[i-1][0] += d0
dp[i-1][2] += d0
dp[i-1][3] += d0
elif yf:
dp[i-1][0] += d0
dp[i-1][1] += d0
elif xf:
dp[i-1][2] += d0
else:
dp[i-1][0] += d0
d1 = dp[i][1]
if xf:
dp[i-1][1] += d1
dp[i-1][3] += 2*d1
else:
dp[i-1][1] += 2*d1
d2 = dp[i][2]
if yf:
dp[i-1][2] += 2*d2
dp[i-1][3] += d2
else:
dp[i-1][2] += d2
d3 = dp[i][3]
dp[i-1][3] += 3*d3
dp[i-1][0] %= mod
dp[i-1][1] %= mod
dp[i-1][2] %= mod
dp[i-1][3] %= mod
return sum(dp[0][i] for i in range(4))
L, R = map(int, input().split())
print((count(R, R) - count(L-1, R))%mod)
``` | output | 1 | 69,618 | 22 | 139,237 |
Provide a correct Python 3 solution for this coding contest problem.
Given are integers L and R. Find the number, modulo 10^9 + 7, of pairs of integers (x, y) (L \leq x \leq y \leq R) such that the remainder when y is divided by x is equal to y \mbox{ XOR } x.
What is \mbox{ XOR }?
The XOR of integers A and B, A \mbox{ XOR } B, is defined as follows:
* When A \mbox{ XOR } B is written in base two, the digit in the 2^k's place (k \geq 0) is 1 if either A or B, but not both, has 1 in the 2^k's place, and 0 otherwise.
For example, 3 \mbox{ XOR } 5 = 6. (In base two: 011 \mbox{ XOR } 101 = 110.)
Constraints
* 1 \leq L \leq R \leq 10^{18}
Input
Input is given from Standard Input in the following format:
L R
Output
Print the number of pairs of integers (x, y) (L \leq x \leq y \leq R) satisfying the condition, modulo 10^9 + 7.
Examples
Input
2 3
Output
3
Input
10 100
Output
604
Input
1 1000000000000000000
Output
68038601 | instruction | 0 | 69,619 | 22 | 139,238 |
"Correct Solution:
```
from functools import lru_cache
import sys
sys.setrecursionlimit(1000000)
P = 10**9+7
@lru_cache(maxsize=None)
def subcalc(l, r):
if l < 0 or r < 0:
print("ERROR")
print("l, r =", l, r)
print(1//0)
if l > r: return 0
if r == 0: return 1
aa, bb = l.bit_length(), r.bit_length()
if aa == bb:
return subcalc(l-(1<<aa-1), r-(1<<bb-1))
if (r & (r+1) == 0) and (l == 0):
return pow(3, r.bit_length(), P)
t = (subcalc(l, r-(1<<bb-1)) + subcalc(l, (1<<bb-1)-1) + subcalc(0, r-(1<<bb-1))) % P
# print("subcalc", l, r, t)
return t
@lru_cache(maxsize=None)
def calc(L, R):
if L < 0 or R < 0:
print("ERROR")
print("l, r =", l, r)
print(1//0)
if L > R: return 0
a = L.bit_length()
b = R.bit_length()
if b > a:
t = (calc(L, (1<<b-1)-1) + calc(1<<b-1, R)) % P
# print("calc", L, R, t)
return t
a = 1 << L.bit_length() - 1 if L else 0
t = subcalc(L-a, R-a)
# print("calc", L, R, t)
return t
L, R = map(int, input().split())
print(calc(L, R))
``` | output | 1 | 69,619 | 22 | 139,239 |
Provide a correct Python 3 solution for this coding contest problem.
Given are integers L and R. Find the number, modulo 10^9 + 7, of pairs of integers (x, y) (L \leq x \leq y \leq R) such that the remainder when y is divided by x is equal to y \mbox{ XOR } x.
What is \mbox{ XOR }?
The XOR of integers A and B, A \mbox{ XOR } B, is defined as follows:
* When A \mbox{ XOR } B is written in base two, the digit in the 2^k's place (k \geq 0) is 1 if either A or B, but not both, has 1 in the 2^k's place, and 0 otherwise.
For example, 3 \mbox{ XOR } 5 = 6. (In base two: 011 \mbox{ XOR } 101 = 110.)
Constraints
* 1 \leq L \leq R \leq 10^{18}
Input
Input is given from Standard Input in the following format:
L R
Output
Print the number of pairs of integers (x, y) (L \leq x \leq y \leq R) satisfying the condition, modulo 10^9 + 7.
Examples
Input
2 3
Output
3
Input
10 100
Output
604
Input
1 1000000000000000000
Output
68038601 | instruction | 0 | 69,620 | 22 | 139,240 |
"Correct Solution:
```
mod = 10 ** 9 + 7
memo = {}
def solve(L, R):
if (L, R) in memo:
return memo[(L, R)]
if L > R:
res = 0
elif L == 1:
res = 1 + solve(2, R)
else:
res = (
solve(L // 2, (R - 1) // 2) +
solve((L + 1) // 2, R // 2) +
solve((L + 1) // 2, (R - 1) // 2)
)
res %= mod
memo[(L, R)] = res
return res
L, R = map(int, input().split())
print(solve(L, R) % mod)
``` | output | 1 | 69,620 | 22 | 139,241 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given are integers L and R. Find the number, modulo 10^9 + 7, of pairs of integers (x, y) (L \leq x \leq y \leq R) such that the remainder when y is divided by x is equal to y \mbox{ XOR } x.
What is \mbox{ XOR }?
The XOR of integers A and B, A \mbox{ XOR } B, is defined as follows:
* When A \mbox{ XOR } B is written in base two, the digit in the 2^k's place (k \geq 0) is 1 if either A or B, but not both, has 1 in the 2^k's place, and 0 otherwise.
For example, 3 \mbox{ XOR } 5 = 6. (In base two: 011 \mbox{ XOR } 101 = 110.)
Constraints
* 1 \leq L \leq R \leq 10^{18}
Input
Input is given from Standard Input in the following format:
L R
Output
Print the number of pairs of integers (x, y) (L \leq x \leq y \leq R) satisfying the condition, modulo 10^9 + 7.
Examples
Input
2 3
Output
3
Input
10 100
Output
604
Input
1 1000000000000000000
Output
68038601
Submitted Solution:
```
L, R = map(int, input().split())
MOD = 10 ** 9 + 7
l = '{:060b}'.format(L)[::-1]
r = '{:060b}'.format(R)[::-1]
memo = [[[[-1 for l in range(2)] for k in range(2)] for j in range(2)] for i in range(60)]
#上から1桁ずつ4パターン(x0y0, x1y0, x0y1, x1y1)に場合分けして計算
def f(pos, flagX, flagY, flagZ):
if pos == -1:
return 1
if memo[pos][flagX][flagY][flagZ] != -1:
return memo[pos][flagX][flagY][flagZ]
ret = 0
#x0, y0
if flagX or l[pos] == '0':
ret += f(pos-1, flagX, 1 if r[pos]=='1' else flagY, flagZ)
#x0, y1
if (flagX or l[pos] == '0') and (flagY or r[pos] == '1') and flagZ:
ret += f(pos-1, flagX, flagY, flagZ)
#x1, y1
if flagY or r[pos] == '1':
ret += f(pos-1, 1 if l[pos] == '0' else flagX, flagY, 1)
ret %= MOD
memo[pos][flagX][flagY][flagZ] = ret
return ret
ans = f(59, 0, 0, 0)
print(ans)
``` | instruction | 0 | 69,621 | 22 | 139,242 |
Yes | output | 1 | 69,621 | 22 | 139,243 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.