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 |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer n. Check if n has an odd divisor, greater than one (does there exist such a number x (x > 1) that n is divisible by x and x is odd).
For example, if n=6, then there is x=3. If n=4, then such a number does not exist.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
Each test case contains one integer n (2 ≤ n ≤ 10^{14}).
Please note, that the input for some test cases won't fit into 32-bit integer type, so you should use at least 64-bit integer type in your programming language.
Output
For each test case, output on a separate line:
* "YES" if n has an odd divisor, greater than one;
* "NO" otherwise.
You can output "YES" and "NO" in any case (for example, the strings yEs, yes, Yes and YES will be recognized as positive).
Example
Input
6
2
3
4
5
998244353
1099511627776
Output
NO
YES
NO
YES
YES
NO
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
if n%2:
print('YES')
else:
if n%3 and n%5 and n%7:
print("NO")
``` | instruction | 0 | 86,869 | 22 | 173,738 |
No | output | 1 | 86,869 | 22 | 173,739 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer n. Check if n has an odd divisor, greater than one (does there exist such a number x (x > 1) that n is divisible by x and x is odd).
For example, if n=6, then there is x=3. If n=4, then such a number does not exist.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
Each test case contains one integer n (2 ≤ n ≤ 10^{14}).
Please note, that the input for some test cases won't fit into 32-bit integer type, so you should use at least 64-bit integer type in your programming language.
Output
For each test case, output on a separate line:
* "YES" if n has an odd divisor, greater than one;
* "NO" otherwise.
You can output "YES" and "NO" in any case (for example, the strings yEs, yes, Yes and YES will be recognized as positive).
Example
Input
6
2
3
4
5
998244353
1099511627776
Output
NO
YES
NO
YES
YES
NO
Submitted Solution:
```
def ans(n):
if n%2==0:
n=n//2
ans(n)
else:
if n==1:
return False
else:
return True
for _ in range(int(input())):
n=int(input())
if ans(n):
print("YES")
else:
print("NO")
``` | instruction | 0 | 86,870 | 22 | 173,740 |
No | output | 1 | 86,870 | 22 | 173,741 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call the following process a transformation of a sequence of length n.
If the sequence is empty, the process ends. Otherwise, append the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) (GCD) of all the elements of the sequence to the result and remove one arbitrary element from the sequence. Thus, when the process ends, we have a sequence of n integers: the greatest common divisors of all the elements in the sequence before each deletion.
You are given an integer sequence 1, 2, ..., n. Find the lexicographically maximum result of its transformation.
A sequence a_1, a_2, …, a_n is lexicographically larger than a sequence b_1, b_2, …, b_n, if there is an index i such that a_j = b_j for all j < i, and a_i > b_i.
Input
The first and only line of input contains one integer n (1≤ n≤ 10^6).
Output
Output n integers — the lexicographically maximum result of the transformation.
Examples
Input
3
Output
1 1 3
Input
2
Output
1 2
Input
1
Output
1
Note
In the first sample the answer may be achieved this way:
* Append GCD(1, 2, 3) = 1, remove 2.
* Append GCD(1, 3) = 1, remove 1.
* Append GCD(3) = 3, remove 3.
We get the sequence [1, 1, 3] as the result. | instruction | 0 | 87,557 | 22 | 175,114 |
Tags: constructive algorithms, math
Correct Solution:
```
from math import gcd
n = int(input())
if n==3:
print(1,1,3)
exit()
ans = []
p = 0
avail = [i+1 for i in range(n)]
vis = [False for i in range(n)]
while avail!=[]:
# print(avail)
cnt = 0
for i in range(0,len(avail),2):
p = gcd(p,avail[i])
vis[avail[i]-1] = True
cnt+=1
ans = ans+[p for i in range(cnt)]
# print(avail,p)
p = 0
avail = []
for i in range(n):
if vis[i]==False:
avail.append(i+1)
if len(avail)==1:
ans.append(avail[0])
break
elif len(avail)==2:
ans+=[gcd(avail[0],avail[1]),avail[1]]
break
elif len(avail)==3:
x,y,z = avail
a = gcd(gcd(x,y),z)
b = gcd(y,z)
ans+=[a,b,z]
break
# print(avail,p)
print(*ans)
``` | output | 1 | 87,557 | 22 | 175,115 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call the following process a transformation of a sequence of length n.
If the sequence is empty, the process ends. Otherwise, append the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) (GCD) of all the elements of the sequence to the result and remove one arbitrary element from the sequence. Thus, when the process ends, we have a sequence of n integers: the greatest common divisors of all the elements in the sequence before each deletion.
You are given an integer sequence 1, 2, ..., n. Find the lexicographically maximum result of its transformation.
A sequence a_1, a_2, …, a_n is lexicographically larger than a sequence b_1, b_2, …, b_n, if there is an index i such that a_j = b_j for all j < i, and a_i > b_i.
Input
The first and only line of input contains one integer n (1≤ n≤ 10^6).
Output
Output n integers — the lexicographically maximum result of the transformation.
Examples
Input
3
Output
1 1 3
Input
2
Output
1 2
Input
1
Output
1
Note
In the first sample the answer may be achieved this way:
* Append GCD(1, 2, 3) = 1, remove 2.
* Append GCD(1, 3) = 1, remove 1.
* Append GCD(3) = 3, remove 3.
We get the sequence [1, 1, 3] as the result. | instruction | 0 | 87,558 | 22 | 175,116 |
Tags: constructive algorithms, math
Correct Solution:
```
n = int(input())
visit = [0 for i in range(n+1)]
res = []
c = 0
s,t=0,0
def do(i):
global c,s,t
for j in range(i,n+1,2*i):
res.append(i)
c += 1
if c >= (n-1) and n>2:
if s == 0:
s = j
else:
t = j
return res
curr = 0
i = 1
while(i<=n):
# print(i)
do(i)
i = 2*i
if n>2:
res[n-1] = max(s,t)
# print(s,t)
for i in res:
print(i,end=" ")
``` | output | 1 | 87,558 | 22 | 175,117 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call the following process a transformation of a sequence of length n.
If the sequence is empty, the process ends. Otherwise, append the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) (GCD) of all the elements of the sequence to the result and remove one arbitrary element from the sequence. Thus, when the process ends, we have a sequence of n integers: the greatest common divisors of all the elements in the sequence before each deletion.
You are given an integer sequence 1, 2, ..., n. Find the lexicographically maximum result of its transformation.
A sequence a_1, a_2, …, a_n is lexicographically larger than a sequence b_1, b_2, …, b_n, if there is an index i such that a_j = b_j for all j < i, and a_i > b_i.
Input
The first and only line of input contains one integer n (1≤ n≤ 10^6).
Output
Output n integers — the lexicographically maximum result of the transformation.
Examples
Input
3
Output
1 1 3
Input
2
Output
1 2
Input
1
Output
1
Note
In the first sample the answer may be achieved this way:
* Append GCD(1, 2, 3) = 1, remove 2.
* Append GCD(1, 3) = 1, remove 1.
* Append GCD(3) = 3, remove 3.
We get the sequence [1, 1, 3] as the result. | instruction | 0 | 87,559 | 22 | 175,118 |
Tags: constructive algorithms, math
Correct Solution:
```
n = int(input())
if n == 1:
print("1")
elif n == 2:
print("1 2")
else:
base = 1
gap = 2
cur = base
next = 1
ans = ''
for i in range(n - 1):
ans += str(base) + ' '
next = cur
cur += gap
if cur > n:
base *= 2
gap *= 2
cur = base
next = max(next, cur)
ans += str(next)
print(ans)
``` | output | 1 | 87,559 | 22 | 175,119 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call the following process a transformation of a sequence of length n.
If the sequence is empty, the process ends. Otherwise, append the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) (GCD) of all the elements of the sequence to the result and remove one arbitrary element from the sequence. Thus, when the process ends, we have a sequence of n integers: the greatest common divisors of all the elements in the sequence before each deletion.
You are given an integer sequence 1, 2, ..., n. Find the lexicographically maximum result of its transformation.
A sequence a_1, a_2, …, a_n is lexicographically larger than a sequence b_1, b_2, …, b_n, if there is an index i such that a_j = b_j for all j < i, and a_i > b_i.
Input
The first and only line of input contains one integer n (1≤ n≤ 10^6).
Output
Output n integers — the lexicographically maximum result of the transformation.
Examples
Input
3
Output
1 1 3
Input
2
Output
1 2
Input
1
Output
1
Note
In the first sample the answer may be achieved this way:
* Append GCD(1, 2, 3) = 1, remove 2.
* Append GCD(1, 3) = 1, remove 1.
* Append GCD(3) = 3, remove 3.
We get the sequence [1, 1, 3] as the result. | instruction | 0 | 87,560 | 22 | 175,120 |
Tags: constructive algorithms, math
Correct Solution:
```
#Complexity - O(logn)
import math
n = int(input())
arr = []
curr = 1
while n > 0:
if n == 1:
arr.append(curr)
break
elif n == 2:
arr.append(curr)
arr.append(curr*2)
break
elif n == 3:
arr.append(curr)
arr.append(curr*1)
arr.append(curr*3)
break
else:
arr.extend([curr]*math.ceil(n/2))
n = math.floor(n/2)
curr *= 2
print(" ".join(map(str, arr)))
``` | output | 1 | 87,560 | 22 | 175,121 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call the following process a transformation of a sequence of length n.
If the sequence is empty, the process ends. Otherwise, append the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) (GCD) of all the elements of the sequence to the result and remove one arbitrary element from the sequence. Thus, when the process ends, we have a sequence of n integers: the greatest common divisors of all the elements in the sequence before each deletion.
You are given an integer sequence 1, 2, ..., n. Find the lexicographically maximum result of its transformation.
A sequence a_1, a_2, …, a_n is lexicographically larger than a sequence b_1, b_2, …, b_n, if there is an index i such that a_j = b_j for all j < i, and a_i > b_i.
Input
The first and only line of input contains one integer n (1≤ n≤ 10^6).
Output
Output n integers — the lexicographically maximum result of the transformation.
Examples
Input
3
Output
1 1 3
Input
2
Output
1 2
Input
1
Output
1
Note
In the first sample the answer may be achieved this way:
* Append GCD(1, 2, 3) = 1, remove 2.
* Append GCD(1, 3) = 1, remove 1.
* Append GCD(3) = 3, remove 3.
We get the sequence [1, 1, 3] as the result. | instruction | 0 | 87,561 | 22 | 175,122 |
Tags: constructive algorithms, math
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
import math
# 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)
def input(): return sys.stdin.readline().rstrip("\r\n")
def getint(): return int(input())
def getints(): return list(map(int, input().split()))
def getint1(): return list(map(lambda x: int(x) - 1, input().split()))
def main():
###CODE
n = getint()
k = n
if n==1:
print(1)
elif n==2:
print(1,2)
elif n==3:
print(1,1,3)
else:
extra = 0
l = []
if n%2:
extra = 1
n-=1
while n>1:
v = math.ceil(n/2)
l.append(v)
n -= l[-1]
out = []
l[0] += extra
p = 1
for i in l:
out.extend([p]*i)
p*=2
out = out[:k-1]
p = out[-1]
out.append(p*(k//p))
print(*out)
if __name__ == "__main__":
main()
``` | output | 1 | 87,561 | 22 | 175,123 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call the following process a transformation of a sequence of length n.
If the sequence is empty, the process ends. Otherwise, append the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) (GCD) of all the elements of the sequence to the result and remove one arbitrary element from the sequence. Thus, when the process ends, we have a sequence of n integers: the greatest common divisors of all the elements in the sequence before each deletion.
You are given an integer sequence 1, 2, ..., n. Find the lexicographically maximum result of its transformation.
A sequence a_1, a_2, …, a_n is lexicographically larger than a sequence b_1, b_2, …, b_n, if there is an index i such that a_j = b_j for all j < i, and a_i > b_i.
Input
The first and only line of input contains one integer n (1≤ n≤ 10^6).
Output
Output n integers — the lexicographically maximum result of the transformation.
Examples
Input
3
Output
1 1 3
Input
2
Output
1 2
Input
1
Output
1
Note
In the first sample the answer may be achieved this way:
* Append GCD(1, 2, 3) = 1, remove 2.
* Append GCD(1, 3) = 1, remove 1.
* Append GCD(3) = 3, remove 3.
We get the sequence [1, 1, 3] as the result. | instruction | 0 | 87,562 | 22 | 175,124 |
Tags: constructive algorithms, math
Correct Solution:
```
n=int(input())
def cal(n,t):
if n==1:
print(t,end=' ')
elif n==2:
print(t,t<<1,end=' ')
elif n==3:
print(t,t,t*3, end=' ')
else:
tmp=n-(n>>1)
for i in range(tmp):
print(t,end=' ')
cal(n>>1,t<<1)
cal(n,1)
``` | output | 1 | 87,562 | 22 | 175,125 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call the following process a transformation of a sequence of length n.
If the sequence is empty, the process ends. Otherwise, append the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) (GCD) of all the elements of the sequence to the result and remove one arbitrary element from the sequence. Thus, when the process ends, we have a sequence of n integers: the greatest common divisors of all the elements in the sequence before each deletion.
You are given an integer sequence 1, 2, ..., n. Find the lexicographically maximum result of its transformation.
A sequence a_1, a_2, …, a_n is lexicographically larger than a sequence b_1, b_2, …, b_n, if there is an index i such that a_j = b_j for all j < i, and a_i > b_i.
Input
The first and only line of input contains one integer n (1≤ n≤ 10^6).
Output
Output n integers — the lexicographically maximum result of the transformation.
Examples
Input
3
Output
1 1 3
Input
2
Output
1 2
Input
1
Output
1
Note
In the first sample the answer may be achieved this way:
* Append GCD(1, 2, 3) = 1, remove 2.
* Append GCD(1, 3) = 1, remove 1.
* Append GCD(3) = 3, remove 3.
We get the sequence [1, 1, 3] as the result. | instruction | 0 | 87,563 | 22 | 175,126 |
Tags: constructive algorithms, math
Correct Solution:
```
#copying.............................................
n,t=int(input()),1
while n>0:
if n!=3:
k=n//2+n%2
print((str(t)+' ')*k,end='')
n-=k
t*=2
else:
print(t,t,t*3)
n=0
``` | output | 1 | 87,563 | 22 | 175,127 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call the following process a transformation of a sequence of length n.
If the sequence is empty, the process ends. Otherwise, append the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) (GCD) of all the elements of the sequence to the result and remove one arbitrary element from the sequence. Thus, when the process ends, we have a sequence of n integers: the greatest common divisors of all the elements in the sequence before each deletion.
You are given an integer sequence 1, 2, ..., n. Find the lexicographically maximum result of its transformation.
A sequence a_1, a_2, …, a_n is lexicographically larger than a sequence b_1, b_2, …, b_n, if there is an index i such that a_j = b_j for all j < i, and a_i > b_i.
Input
The first and only line of input contains one integer n (1≤ n≤ 10^6).
Output
Output n integers — the lexicographically maximum result of the transformation.
Examples
Input
3
Output
1 1 3
Input
2
Output
1 2
Input
1
Output
1
Note
In the first sample the answer may be achieved this way:
* Append GCD(1, 2, 3) = 1, remove 2.
* Append GCD(1, 3) = 1, remove 1.
* Append GCD(3) = 3, remove 3.
We get the sequence [1, 1, 3] as the result. | instruction | 0 | 87,564 | 22 | 175,128 |
Tags: constructive algorithms, math
Correct Solution:
```
from sys import stdin,stdout,exit,setrecursionlimit
def sin():
return stdin.readline().rstrip()
def listInput():
return list(map(int,sin().split()))
def printBS(li):
if not li: return
for i in range(len(li)-1):
stdout.write("%d "%(li[i]))
stdout.write("%d\n"%(li[-1]))
setrecursionlimit(10**5)
n = int(sin())
def res(i):
if i==1: return [1]
if i==2: return [1,2]
if i==3: return [1,1,3]
cnt = i//2
if i%2==1: cnt+=1
return [1]*cnt+[2*j for j in res(i-cnt)]
printBS(res(n))
``` | output | 1 | 87,564 | 22 | 175,129 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call the following process a transformation of a sequence of length n.
If the sequence is empty, the process ends. Otherwise, append the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) (GCD) of all the elements of the sequence to the result and remove one arbitrary element from the sequence. Thus, when the process ends, we have a sequence of n integers: the greatest common divisors of all the elements in the sequence before each deletion.
You are given an integer sequence 1, 2, ..., n. Find the lexicographically maximum result of its transformation.
A sequence a_1, a_2, …, a_n is lexicographically larger than a sequence b_1, b_2, …, b_n, if there is an index i such that a_j = b_j for all j < i, and a_i > b_i.
Input
The first and only line of input contains one integer n (1≤ n≤ 10^6).
Output
Output n integers — the lexicographically maximum result of the transformation.
Examples
Input
3
Output
1 1 3
Input
2
Output
1 2
Input
1
Output
1
Note
In the first sample the answer may be achieved this way:
* Append GCD(1, 2, 3) = 1, remove 2.
* Append GCD(1, 3) = 1, remove 1.
* Append GCD(3) = 3, remove 3.
We get the sequence [1, 1, 3] as the result.
Submitted Solution:
```
n = int(input())
if n == 3:
print('1 1 3')
exit()
if n == 1:
print('1')
exit()
if n == 2:
print('1 2')
exit()
d = 2
ans = []
lfn = n
while d <= n:
k = n // d
for j in range(lfn - k):
ans.append(d//2)
lfn = n - len(ans)
d *=2
d //= 2
k = n/d
if k < 1.5:
ans.append(d)
else:
ans.append(d + d//2)
print(' '.join([str(i) for i in ans]))
``` | instruction | 0 | 87,565 | 22 | 175,130 |
Yes | output | 1 | 87,565 | 22 | 175,131 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call the following process a transformation of a sequence of length n.
If the sequence is empty, the process ends. Otherwise, append the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) (GCD) of all the elements of the sequence to the result and remove one arbitrary element from the sequence. Thus, when the process ends, we have a sequence of n integers: the greatest common divisors of all the elements in the sequence before each deletion.
You are given an integer sequence 1, 2, ..., n. Find the lexicographically maximum result of its transformation.
A sequence a_1, a_2, …, a_n is lexicographically larger than a sequence b_1, b_2, …, b_n, if there is an index i such that a_j = b_j for all j < i, and a_i > b_i.
Input
The first and only line of input contains one integer n (1≤ n≤ 10^6).
Output
Output n integers — the lexicographically maximum result of the transformation.
Examples
Input
3
Output
1 1 3
Input
2
Output
1 2
Input
1
Output
1
Note
In the first sample the answer may be achieved this way:
* Append GCD(1, 2, 3) = 1, remove 2.
* Append GCD(1, 3) = 1, remove 1.
* Append GCD(3) = 3, remove 3.
We get the sequence [1, 1, 3] as the result.
Submitted Solution:
```
import bisect
from itertools import accumulate
import os
import sys
import math
from decimal import *
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")
def isPrime(n) :
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 SieveOfEratosthenes(n):
prime=[]
primes = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (primes[p] == True):
prime.append(p)
for i in range(p * p, n+1, p):
primes[i] = False
p += 1
return prime
def primefactors(n):
fac=[]
while(n%2==0):
fac.append(2)
n=n//2
for i in range(3,int(math.sqrt(n))+2):
while(n%i==0):
fac.append(i)
n=n//i
if n>1:
fac.append(n)
return fac
def factors(n):
fac=set()
fac.add(1)
fac.add(n)
for i in range(2,int(math.sqrt(n))+1):
if n%i==0:
fac.add(i)
fac.add(n//i)
return list(fac)
def NcR(n, r):
p = 1
k = 1
if (n - r < r):
r = n - r
if (r != 0):
while (r):
p *= n
k *= r
m = math.gcd(p, k)
p //= m
k //= m
n -= 1
r -= 1
else:
p = 1
return p
#--------------------------------------------------------
n = int(input())
i = 0
while n:
if n == 3:
print(2**i,2**i,3*2**i)
break
print(*([2**i]*((n+1)//2)),end = ' ')
n -= (n+1)//2
i += 1
``` | instruction | 0 | 87,566 | 22 | 175,132 |
Yes | output | 1 | 87,566 | 22 | 175,133 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call the following process a transformation of a sequence of length n.
If the sequence is empty, the process ends. Otherwise, append the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) (GCD) of all the elements of the sequence to the result and remove one arbitrary element from the sequence. Thus, when the process ends, we have a sequence of n integers: the greatest common divisors of all the elements in the sequence before each deletion.
You are given an integer sequence 1, 2, ..., n. Find the lexicographically maximum result of its transformation.
A sequence a_1, a_2, …, a_n is lexicographically larger than a sequence b_1, b_2, …, b_n, if there is an index i such that a_j = b_j for all j < i, and a_i > b_i.
Input
The first and only line of input contains one integer n (1≤ n≤ 10^6).
Output
Output n integers — the lexicographically maximum result of the transformation.
Examples
Input
3
Output
1 1 3
Input
2
Output
1 2
Input
1
Output
1
Note
In the first sample the answer may be achieved this way:
* Append GCD(1, 2, 3) = 1, remove 2.
* Append GCD(1, 3) = 1, remove 1.
* Append GCD(3) = 3, remove 3.
We get the sequence [1, 1, 3] as the result.
Submitted Solution:
```
n = int(input())
if (n == 3):
print('1 1 3')
else:
done = 0
arr = []
for i in range(30, -1, -1):
arr.extend([2**i]*(n//(2**i) - done))
done += n//(2**i) - done
if (done == 1):
k = i
arr[0] = max(arr[0], (n//2**(k-1)) * 2**(k-1))
arr.reverse()
print(' '.join(map(str, arr)))
``` | instruction | 0 | 87,567 | 22 | 175,134 |
Yes | output | 1 | 87,567 | 22 | 175,135 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call the following process a transformation of a sequence of length n.
If the sequence is empty, the process ends. Otherwise, append the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) (GCD) of all the elements of the sequence to the result and remove one arbitrary element from the sequence. Thus, when the process ends, we have a sequence of n integers: the greatest common divisors of all the elements in the sequence before each deletion.
You are given an integer sequence 1, 2, ..., n. Find the lexicographically maximum result of its transformation.
A sequence a_1, a_2, …, a_n is lexicographically larger than a sequence b_1, b_2, …, b_n, if there is an index i such that a_j = b_j for all j < i, and a_i > b_i.
Input
The first and only line of input contains one integer n (1≤ n≤ 10^6).
Output
Output n integers — the lexicographically maximum result of the transformation.
Examples
Input
3
Output
1 1 3
Input
2
Output
1 2
Input
1
Output
1
Note
In the first sample the answer may be achieved this way:
* Append GCD(1, 2, 3) = 1, remove 2.
* Append GCD(1, 3) = 1, remove 1.
* Append GCD(3) = 3, remove 3.
We get the sequence [1, 1, 3] as the result.
Submitted Solution:
```
n=int(input())
n0=n
a=[]
a1=0
b=1
while a1<n0:
if n==3:
a+=[b,b,3*b]
a1+=3
else:
a+=[b]*((n+1)//2)
a1+=(n+1)//2
n//=2
b*=2
print(*a)
``` | instruction | 0 | 87,568 | 22 | 175,136 |
Yes | output | 1 | 87,568 | 22 | 175,137 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call the following process a transformation of a sequence of length n.
If the sequence is empty, the process ends. Otherwise, append the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) (GCD) of all the elements of the sequence to the result and remove one arbitrary element from the sequence. Thus, when the process ends, we have a sequence of n integers: the greatest common divisors of all the elements in the sequence before each deletion.
You are given an integer sequence 1, 2, ..., n. Find the lexicographically maximum result of its transformation.
A sequence a_1, a_2, …, a_n is lexicographically larger than a sequence b_1, b_2, …, b_n, if there is an index i such that a_j = b_j for all j < i, and a_i > b_i.
Input
The first and only line of input contains one integer n (1≤ n≤ 10^6).
Output
Output n integers — the lexicographically maximum result of the transformation.
Examples
Input
3
Output
1 1 3
Input
2
Output
1 2
Input
1
Output
1
Note
In the first sample the answer may be achieved this way:
* Append GCD(1, 2, 3) = 1, remove 2.
* Append GCD(1, 3) = 1, remove 1.
* Append GCD(3) = 3, remove 3.
We get the sequence [1, 1, 3] as the result.
Submitted Solution:
```
from math import log2
n = int(input())
if n == 1:
print(1)
elif n == 3:
print(1, 1, 3)
exit()
l = [1] * (n // 2)
if n % 2 == 1:
l.append(1)
xn = int(log2(n))
tmp = n - len(l)
for i in range(2, xn+1):
fn = tmp // 2
if tmp % 2 == 1:
fn += 1
tmp -= fn
l += ([pow(2, i-1)] * fn)
l.append(pow(2, xn))
print(' '.join(str(i) for i in l))
``` | instruction | 0 | 87,569 | 22 | 175,138 |
No | output | 1 | 87,569 | 22 | 175,139 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call the following process a transformation of a sequence of length n.
If the sequence is empty, the process ends. Otherwise, append the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) (GCD) of all the elements of the sequence to the result and remove one arbitrary element from the sequence. Thus, when the process ends, we have a sequence of n integers: the greatest common divisors of all the elements in the sequence before each deletion.
You are given an integer sequence 1, 2, ..., n. Find the lexicographically maximum result of its transformation.
A sequence a_1, a_2, …, a_n is lexicographically larger than a sequence b_1, b_2, …, b_n, if there is an index i such that a_j = b_j for all j < i, and a_i > b_i.
Input
The first and only line of input contains one integer n (1≤ n≤ 10^6).
Output
Output n integers — the lexicographically maximum result of the transformation.
Examples
Input
3
Output
1 1 3
Input
2
Output
1 2
Input
1
Output
1
Note
In the first sample the answer may be achieved this way:
* Append GCD(1, 2, 3) = 1, remove 2.
* Append GCD(1, 3) = 1, remove 1.
* Append GCD(3) = 3, remove 3.
We get the sequence [1, 1, 3] as the result.
Submitted Solution:
```
n = int(input())
if n == 3:
print('1 1 3')
exit()
i = 1
while n:
if i > 1:
print(' ', end='')
print(*([i] * ((n + 1) // 2)), end='')
i <<= 1
n >>= 1
``` | instruction | 0 | 87,570 | 22 | 175,140 |
No | output | 1 | 87,570 | 22 | 175,141 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call the following process a transformation of a sequence of length n.
If the sequence is empty, the process ends. Otherwise, append the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) (GCD) of all the elements of the sequence to the result and remove one arbitrary element from the sequence. Thus, when the process ends, we have a sequence of n integers: the greatest common divisors of all the elements in the sequence before each deletion.
You are given an integer sequence 1, 2, ..., n. Find the lexicographically maximum result of its transformation.
A sequence a_1, a_2, …, a_n is lexicographically larger than a sequence b_1, b_2, …, b_n, if there is an index i such that a_j = b_j for all j < i, and a_i > b_i.
Input
The first and only line of input contains one integer n (1≤ n≤ 10^6).
Output
Output n integers — the lexicographically maximum result of the transformation.
Examples
Input
3
Output
1 1 3
Input
2
Output
1 2
Input
1
Output
1
Note
In the first sample the answer may be achieved this way:
* Append GCD(1, 2, 3) = 1, remove 2.
* Append GCD(1, 3) = 1, remove 1.
* Append GCD(3) = 3, remove 3.
We get the sequence [1, 1, 3] as the result.
Submitted Solution:
```
def getFactors(n):
f = []
p = 2
while n % p == 0:
f.append(p)
n /= p
p = 3
while n > 1:
while n % p == 0:
f.append(p)
n /= p
p += 2
return f
def getMagicNumbers(n, factors):
answer = [0] * len(factors)
for i, f in enumerate(factors):
answer[-i - 1] = n
n //= f
return answer
n = int(input())
answer = [1] * n
factors = getFactors(n)
if len(factors) == 1:
answer[-1] = n
else:
replacement = getMagicNumbers(n, factors)
answer[n - len(replacement):] = replacement
print (' '.join(map(str, answer)))
# 2 2 2
# 2 4 8
# 8
# 4 8
#
# 1 1 1 1 1 2 2
# 4
# 2 2 3
# 3 2 2
# 2 4 6 12
# 2,2,3->
# 12->6->3
# 24
# 2 2 2 3
# 24->12->6->3
#2 3 6
#1 1 1 2 3 6
#
#1 1 1 2 3 6
# 4
# 1 2 3 4
# 4
# 1 1 2 4
# 2 3 4 5
# 1
# 1 1 1 2 4
# 1 1 1 1 5
# 1 1 1 1 1 1 1 1 3 9
``` | instruction | 0 | 87,571 | 22 | 175,142 |
No | output | 1 | 87,571 | 22 | 175,143 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call the following process a transformation of a sequence of length n.
If the sequence is empty, the process ends. Otherwise, append the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) (GCD) of all the elements of the sequence to the result and remove one arbitrary element from the sequence. Thus, when the process ends, we have a sequence of n integers: the greatest common divisors of all the elements in the sequence before each deletion.
You are given an integer sequence 1, 2, ..., n. Find the lexicographically maximum result of its transformation.
A sequence a_1, a_2, …, a_n is lexicographically larger than a sequence b_1, b_2, …, b_n, if there is an index i such that a_j = b_j for all j < i, and a_i > b_i.
Input
The first and only line of input contains one integer n (1≤ n≤ 10^6).
Output
Output n integers — the lexicographically maximum result of the transformation.
Examples
Input
3
Output
1 1 3
Input
2
Output
1 2
Input
1
Output
1
Note
In the first sample the answer may be achieved this way:
* Append GCD(1, 2, 3) = 1, remove 2.
* Append GCD(1, 3) = 1, remove 1.
* Append GCD(3) = 3, remove 3.
We get the sequence [1, 1, 3] as the result.
Submitted Solution:
```
n = int(input())
def solve(n):
if n == 1: return '1'
if n == 2: return '1 2'
if n == 3: return '1 1 3'
if n == 6: return '1 1 1 2 2 6'
if n == 7: return '1 1 1 1 2 2 6'
res = []
num = 1
tmp = n
while len(res) < tmp:
c = (n+1) // 2
res += [num] * c
n = n - c
num *= 2
return ' '.join(map(str, res))
print(solve(n))
``` | instruction | 0 | 87,572 | 22 | 175,144 |
No | output | 1 | 87,572 | 22 | 175,145 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14. | instruction | 0 | 88,527 | 22 | 177,054 |
Tags: constructive algorithms, greedy, number theory
Correct Solution:
```
t = int(input())
for i in range(t):
x = int(input())
print("1", x - 1)
``` | output | 1 | 88,527 | 22 | 177,055 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14. | instruction | 0 | 88,528 | 22 | 177,056 |
Tags: constructive algorithms, greedy, number theory
Correct Solution:
```
t=int(input())
for testcase in range(t):
sum=int(input())
print(1,sum-1)
``` | output | 1 | 88,528 | 22 | 177,057 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14. | instruction | 0 | 88,529 | 22 | 177,058 |
Tags: constructive algorithms, greedy, number theory
Correct Solution:
```
t = int(input())
while t:
x = int(input())
print('1 ', x - 1)
t -= 1
``` | output | 1 | 88,529 | 22 | 177,059 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14. | instruction | 0 | 88,530 | 22 | 177,060 |
Tags: constructive algorithms, greedy, number theory
Correct Solution:
```
n=int(input())
for i in range(n):
n1=int(input())
print(1,n1-1)
``` | output | 1 | 88,530 | 22 | 177,061 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14. | instruction | 0 | 88,531 | 22 | 177,062 |
Tags: constructive algorithms, greedy, number theory
Correct Solution:
```
for i in range(int(input())):
n=int(input())
print(1,n-1,end=' ')
``` | output | 1 | 88,531 | 22 | 177,063 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14. | instruction | 0 | 88,532 | 22 | 177,064 |
Tags: constructive algorithms, greedy, number theory
Correct Solution:
```
t = int(input())
count = 0
ans = []
while count < t :
x = int(input())
ans.append(x)
count +=1
for y in ans:
print ("1" , y-1)
``` | output | 1 | 88,532 | 22 | 177,065 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14. | instruction | 0 | 88,533 | 22 | 177,066 |
Tags: constructive algorithms, greedy, number theory
Correct Solution:
```
cases=int(input())
for case in range(cases):
number=int(input())
for i in range(1,number//2+1):
if (number-i)%i==0:
print(i,number-i)
break
``` | output | 1 | 88,533 | 22 | 177,067 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14. | instruction | 0 | 88,534 | 22 | 177,068 |
Tags: constructive algorithms, greedy, number theory
Correct Solution:
```
t = int(input())
for tc in range(t):
x = int(input())
a = x-1
b = 1
print(a, b)
``` | output | 1 | 88,534 | 22 | 177,069 |
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 x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
Submitted Solution:
```
# ANSHUL GAUTAM
# IIIT-D
from math import *
from copy import *
from string import * # alpha = ascii_lowercase
from random import * # l.sort(key=lambda l1:l1[0]-l1[1]) => ex: sort on the basis difference
from bisect import * # bisect_left(arr,x,start,end) => start and end parameters are temporary
from sys import stdin # bisect_left return leftmost position where x should be inserted to keep sorted
from sys import maxsize
from operator import * # d = sorted(d.items(), key=itemgetter(1))
from itertools import *
from collections import Counter # d = dict(Counter(l))
from collections import defaultdict # d = defaultdict(list)
'''
'''
def solve(l):
n = len(l)
T = int(input())
for _ in range(T):
N = int(stdin.readline())
print(1,N-1)
``` | instruction | 0 | 88,535 | 22 | 177,070 |
Yes | output | 1 | 88,535 | 22 | 177,071 |
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 x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
Submitted Solution:
```
t=int(input())
while(t>0):
n=int(input())
print(1,n-1,sep=' ')
t=t-1
``` | instruction | 0 | 88,536 | 22 | 177,072 |
Yes | output | 1 | 88,536 | 22 | 177,073 |
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 x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
Submitted Solution:
```
teste = int(input())
for i in range(teste):
valor = int(input())
print(1,valor-1)
``` | instruction | 0 | 88,537 | 22 | 177,074 |
Yes | output | 1 | 88,537 | 22 | 177,075 |
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 x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
if n % 2 == 0:
print(n//2, n//2)
else:
print(1, n - 1)
``` | instruction | 0 | 88,538 | 22 | 177,076 |
Yes | output | 1 | 88,538 | 22 | 177,077 |
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 x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
Submitted Solution:
```
import math
t = int(input())
answers=[]
for n in range(t):
case = int(input())
for a in range(9):
if (a == 0): continue
for b in range(9):
if (b == 0): continue
gcd = math.gcd(a, b)
lcm = (a*b)/gcd
if ((gcd + lcm) == case):
answers.append([a, b])
break
for a in answers:
print(a[0], a[1])
``` | instruction | 0 | 88,539 | 22 | 177,078 |
No | output | 1 | 88,539 | 22 | 177,079 |
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 x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
Submitted Solution:
```
print(1, 1)
print(6, 4)
``` | instruction | 0 | 88,540 | 22 | 177,080 |
No | output | 1 | 88,540 | 22 | 177,081 |
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 x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
Submitted Solution:
```
def gcd(a,b):
if b == 0:
return a
return gcd(b,a%b)
t = int(input())
for _ in range(t):
x = int(input())
for i in range(1,x):
k = False
for j in range(i+1,x):
g = gcd(i,j)
if g + (i*j)/g == x:
print(i,j)
k = True
break
if k:
break
``` | instruction | 0 | 88,541 | 22 | 177,082 |
No | output | 1 | 88,541 | 22 | 177,083 |
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 x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
Submitted Solution:
```
t = int(input())
for x in range(t):
n = int(input())
if n == 2:
print(1, 1)
continue
print(1, n)
``` | instruction | 0 | 88,542 | 22 | 177,084 |
No | output | 1 | 88,542 | 22 | 177,085 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your friend has recently learned about coprime numbers. A pair of numbers {a, b} is called coprime if the maximum number that divides both a and b is equal to one.
Your friend often comes up with different statements. He has recently supposed that if the pair (a, b) is coprime and the pair (b, c) is coprime, then the pair (a, c) is coprime.
You want to find a counterexample for your friend's statement. Therefore, your task is to find three distinct numbers (a, b, c), for which the statement is false, and the numbers meet the condition l ≤ a < b < c ≤ r.
More specifically, you need to find three numbers (a, b, c), such that l ≤ a < b < c ≤ r, pairs (a, b) and (b, c) are coprime, and pair (a, c) is not coprime.
Input
The single line contains two positive space-separated integers l, r (1 ≤ l ≤ r ≤ 1018; r - l ≤ 50).
Output
Print three positive space-separated integers a, b, c — three distinct numbers (a, b, c) that form the counterexample. If there are several solutions, you are allowed to print any of them. The numbers must be printed in ascending order.
If the counterexample does not exist, print the single number -1.
Examples
Input
2 4
Output
2 3 4
Input
10 11
Output
-1
Input
900000000000000009 900000000000000029
Output
900000000000000009 900000000000000010 900000000000000021
Note
In the first sample pair (2, 4) is not coprime and pairs (2, 3) and (3, 4) are.
In the second sample you cannot form a group of three distinct integers, so the answer is -1.
In the third sample it is easy to see that numbers 900000000000000009 and 900000000000000021 are divisible by three. | instruction | 0 | 88,801 | 22 | 177,602 |
Tags: brute force, implementation, math, number theory
Correct Solution:
```
def gcd(a, b):
if(a == 0 or b == 0): return a + b
else: return gcd(b, a % b);
l, r = map(int, input().split())
r = r + 1
for a in range(l, r):
for b in range(a + 1, r):
for c in range(b + 1, r):
if(gcd(a, b) == 1 and gcd(b, c) == 1 and gcd(a, c) != 1):
print(str(a) + " " + str(b) + " " + str(c))
exit(0)
print(-1)
``` | output | 1 | 88,801 | 22 | 177,603 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your friend has recently learned about coprime numbers. A pair of numbers {a, b} is called coprime if the maximum number that divides both a and b is equal to one.
Your friend often comes up with different statements. He has recently supposed that if the pair (a, b) is coprime and the pair (b, c) is coprime, then the pair (a, c) is coprime.
You want to find a counterexample for your friend's statement. Therefore, your task is to find three distinct numbers (a, b, c), for which the statement is false, and the numbers meet the condition l ≤ a < b < c ≤ r.
More specifically, you need to find three numbers (a, b, c), such that l ≤ a < b < c ≤ r, pairs (a, b) and (b, c) are coprime, and pair (a, c) is not coprime.
Input
The single line contains two positive space-separated integers l, r (1 ≤ l ≤ r ≤ 1018; r - l ≤ 50).
Output
Print three positive space-separated integers a, b, c — three distinct numbers (a, b, c) that form the counterexample. If there are several solutions, you are allowed to print any of them. The numbers must be printed in ascending order.
If the counterexample does not exist, print the single number -1.
Examples
Input
2 4
Output
2 3 4
Input
10 11
Output
-1
Input
900000000000000009 900000000000000029
Output
900000000000000009 900000000000000010 900000000000000021
Note
In the first sample pair (2, 4) is not coprime and pairs (2, 3) and (3, 4) are.
In the second sample you cannot form a group of three distinct integers, so the answer is -1.
In the third sample it is easy to see that numbers 900000000000000009 and 900000000000000021 are divisible by three. | instruction | 0 | 88,802 | 22 | 177,604 |
Tags: brute force, implementation, math, number theory
Correct Solution:
```
import sys
le, rg = map(int, input().split())
rg += 1
def gcd(a, b):
while b:
a, b = b, a % b
return a
for a in range(le, rg):
for b in range(a + 1, rg):
gab = gcd(a, b)
if gab != 1:
continue
for c in range(b + 1, rg):
if gcd(b, c) == 1 and gcd(a, c) > 1:
print(a, b, c)
sys.exit(0)
print(-1)
``` | output | 1 | 88,802 | 22 | 177,605 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your friend has recently learned about coprime numbers. A pair of numbers {a, b} is called coprime if the maximum number that divides both a and b is equal to one.
Your friend often comes up with different statements. He has recently supposed that if the pair (a, b) is coprime and the pair (b, c) is coprime, then the pair (a, c) is coprime.
You want to find a counterexample for your friend's statement. Therefore, your task is to find three distinct numbers (a, b, c), for which the statement is false, and the numbers meet the condition l ≤ a < b < c ≤ r.
More specifically, you need to find three numbers (a, b, c), such that l ≤ a < b < c ≤ r, pairs (a, b) and (b, c) are coprime, and pair (a, c) is not coprime.
Input
The single line contains two positive space-separated integers l, r (1 ≤ l ≤ r ≤ 1018; r - l ≤ 50).
Output
Print three positive space-separated integers a, b, c — three distinct numbers (a, b, c) that form the counterexample. If there are several solutions, you are allowed to print any of them. The numbers must be printed in ascending order.
If the counterexample does not exist, print the single number -1.
Examples
Input
2 4
Output
2 3 4
Input
10 11
Output
-1
Input
900000000000000009 900000000000000029
Output
900000000000000009 900000000000000010 900000000000000021
Note
In the first sample pair (2, 4) is not coprime and pairs (2, 3) and (3, 4) are.
In the second sample you cannot form a group of three distinct integers, so the answer is -1.
In the third sample it is easy to see that numbers 900000000000000009 and 900000000000000021 are divisible by three. | instruction | 0 | 88,803 | 22 | 177,606 |
Tags: brute force, implementation, math, number theory
Correct Solution:
```
l, r = map(int, input().split())
if r - l + 1 < 3 or (r - l + 1 == 3 and l % 2 == 1):
print(-1)
else:
base = l % 2 + l
ans = [base, base+1, base+2]
print(*ans, sep=' ')
``` | output | 1 | 88,803 | 22 | 177,607 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your friend has recently learned about coprime numbers. A pair of numbers {a, b} is called coprime if the maximum number that divides both a and b is equal to one.
Your friend often comes up with different statements. He has recently supposed that if the pair (a, b) is coprime and the pair (b, c) is coprime, then the pair (a, c) is coprime.
You want to find a counterexample for your friend's statement. Therefore, your task is to find three distinct numbers (a, b, c), for which the statement is false, and the numbers meet the condition l ≤ a < b < c ≤ r.
More specifically, you need to find three numbers (a, b, c), such that l ≤ a < b < c ≤ r, pairs (a, b) and (b, c) are coprime, and pair (a, c) is not coprime.
Input
The single line contains two positive space-separated integers l, r (1 ≤ l ≤ r ≤ 1018; r - l ≤ 50).
Output
Print three positive space-separated integers a, b, c — three distinct numbers (a, b, c) that form the counterexample. If there are several solutions, you are allowed to print any of them. The numbers must be printed in ascending order.
If the counterexample does not exist, print the single number -1.
Examples
Input
2 4
Output
2 3 4
Input
10 11
Output
-1
Input
900000000000000009 900000000000000029
Output
900000000000000009 900000000000000010 900000000000000021
Note
In the first sample pair (2, 4) is not coprime and pairs (2, 3) and (3, 4) are.
In the second sample you cannot form a group of three distinct integers, so the answer is -1.
In the third sample it is easy to see that numbers 900000000000000009 and 900000000000000021 are divisible by three. | instruction | 0 | 88,804 | 22 | 177,608 |
Tags: brute force, implementation, math, number theory
Correct Solution:
```
inp = input().split(' ')
a = int(inp[0])
b = int(inp[1])
if (b-a)<2:
print(-1)
elif (b-a) == 2 and b%2 == 1:
print(-1)
else:
if a%2 == 1:
a = a + 1
print(a,a+1,a+2)
``` | output | 1 | 88,804 | 22 | 177,609 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your friend has recently learned about coprime numbers. A pair of numbers {a, b} is called coprime if the maximum number that divides both a and b is equal to one.
Your friend often comes up with different statements. He has recently supposed that if the pair (a, b) is coprime and the pair (b, c) is coprime, then the pair (a, c) is coprime.
You want to find a counterexample for your friend's statement. Therefore, your task is to find three distinct numbers (a, b, c), for which the statement is false, and the numbers meet the condition l ≤ a < b < c ≤ r.
More specifically, you need to find three numbers (a, b, c), such that l ≤ a < b < c ≤ r, pairs (a, b) and (b, c) are coprime, and pair (a, c) is not coprime.
Input
The single line contains two positive space-separated integers l, r (1 ≤ l ≤ r ≤ 1018; r - l ≤ 50).
Output
Print three positive space-separated integers a, b, c — three distinct numbers (a, b, c) that form the counterexample. If there are several solutions, you are allowed to print any of them. The numbers must be printed in ascending order.
If the counterexample does not exist, print the single number -1.
Examples
Input
2 4
Output
2 3 4
Input
10 11
Output
-1
Input
900000000000000009 900000000000000029
Output
900000000000000009 900000000000000010 900000000000000021
Note
In the first sample pair (2, 4) is not coprime and pairs (2, 3) and (3, 4) are.
In the second sample you cannot form a group of three distinct integers, so the answer is -1.
In the third sample it is easy to see that numbers 900000000000000009 and 900000000000000021 are divisible by three. | instruction | 0 | 88,805 | 22 | 177,610 |
Tags: brute force, implementation, math, number theory
Correct Solution:
```
# t=int(input())
t=1
# see u codeforces on 11-07-2020..bye bye
for _ in range(t):
# n=int(input())
n,m=map(int,input().split())
# l=list(map(int,input().split()))
if(n&1):
n+=1
if(n+2>m):
print(-1)
else:
print(n,n+1,n+2)
``` | output | 1 | 88,805 | 22 | 177,611 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your friend has recently learned about coprime numbers. A pair of numbers {a, b} is called coprime if the maximum number that divides both a and b is equal to one.
Your friend often comes up with different statements. He has recently supposed that if the pair (a, b) is coprime and the pair (b, c) is coprime, then the pair (a, c) is coprime.
You want to find a counterexample for your friend's statement. Therefore, your task is to find three distinct numbers (a, b, c), for which the statement is false, and the numbers meet the condition l ≤ a < b < c ≤ r.
More specifically, you need to find three numbers (a, b, c), such that l ≤ a < b < c ≤ r, pairs (a, b) and (b, c) are coprime, and pair (a, c) is not coprime.
Input
The single line contains two positive space-separated integers l, r (1 ≤ l ≤ r ≤ 1018; r - l ≤ 50).
Output
Print three positive space-separated integers a, b, c — three distinct numbers (a, b, c) that form the counterexample. If there are several solutions, you are allowed to print any of them. The numbers must be printed in ascending order.
If the counterexample does not exist, print the single number -1.
Examples
Input
2 4
Output
2 3 4
Input
10 11
Output
-1
Input
900000000000000009 900000000000000029
Output
900000000000000009 900000000000000010 900000000000000021
Note
In the first sample pair (2, 4) is not coprime and pairs (2, 3) and (3, 4) are.
In the second sample you cannot form a group of three distinct integers, so the answer is -1.
In the third sample it is easy to see that numbers 900000000000000009 and 900000000000000021 are divisible by three. | instruction | 0 | 88,806 | 22 | 177,612 |
Tags: brute force, implementation, math, number theory
Correct Solution:
```
import sys,random
def gcd(x,y):
if y==0:
return x
else:
return gcd(y,x%y)
def pollard(n):
i = 1
x = random.randint(0,n-1)
y = x
k = 2
while True:
i = i+1
x = (x*x - 1)%n
d = gcd(y-x,n)
if d!=1 and d!=n:
print(d)
if i == k:
y = x
k = 2*k
def div(a,b):
c = a+2
while not (gcd(c,a)!=1 and gcd(c,b)==1):
c+=1
return c
def iff(l,r):
if r-l <=1:
return -1
a = l
b = l+1
c = div(a,b)
return a,b,c
l,r = map(int,input().split())
if l%2!=0:
l+=1
if r-l <=1:
print(-1)
else:
print(l,l+1,l+2)
``` | output | 1 | 88,806 | 22 | 177,613 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your friend has recently learned about coprime numbers. A pair of numbers {a, b} is called coprime if the maximum number that divides both a and b is equal to one.
Your friend often comes up with different statements. He has recently supposed that if the pair (a, b) is coprime and the pair (b, c) is coprime, then the pair (a, c) is coprime.
You want to find a counterexample for your friend's statement. Therefore, your task is to find three distinct numbers (a, b, c), for which the statement is false, and the numbers meet the condition l ≤ a < b < c ≤ r.
More specifically, you need to find three numbers (a, b, c), such that l ≤ a < b < c ≤ r, pairs (a, b) and (b, c) are coprime, and pair (a, c) is not coprime.
Input
The single line contains two positive space-separated integers l, r (1 ≤ l ≤ r ≤ 1018; r - l ≤ 50).
Output
Print three positive space-separated integers a, b, c — three distinct numbers (a, b, c) that form the counterexample. If there are several solutions, you are allowed to print any of them. The numbers must be printed in ascending order.
If the counterexample does not exist, print the single number -1.
Examples
Input
2 4
Output
2 3 4
Input
10 11
Output
-1
Input
900000000000000009 900000000000000029
Output
900000000000000009 900000000000000010 900000000000000021
Note
In the first sample pair (2, 4) is not coprime and pairs (2, 3) and (3, 4) are.
In the second sample you cannot form a group of three distinct integers, so the answer is -1.
In the third sample it is easy to see that numbers 900000000000000009 and 900000000000000021 are divisible by three. | instruction | 0 | 88,807 | 22 | 177,614 |
Tags: brute force, implementation, math, number theory
Correct Solution:
```
l, r = map(int, input().split())
if l % 2 != 0:
l += 1
if l + 2 > r:
print(-1)
else:
print(l, l+1, l+2)
``` | output | 1 | 88,807 | 22 | 177,615 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your friend has recently learned about coprime numbers. A pair of numbers {a, b} is called coprime if the maximum number that divides both a and b is equal to one.
Your friend often comes up with different statements. He has recently supposed that if the pair (a, b) is coprime and the pair (b, c) is coprime, then the pair (a, c) is coprime.
You want to find a counterexample for your friend's statement. Therefore, your task is to find three distinct numbers (a, b, c), for which the statement is false, and the numbers meet the condition l ≤ a < b < c ≤ r.
More specifically, you need to find three numbers (a, b, c), such that l ≤ a < b < c ≤ r, pairs (a, b) and (b, c) are coprime, and pair (a, c) is not coprime.
Input
The single line contains two positive space-separated integers l, r (1 ≤ l ≤ r ≤ 1018; r - l ≤ 50).
Output
Print three positive space-separated integers a, b, c — three distinct numbers (a, b, c) that form the counterexample. If there are several solutions, you are allowed to print any of them. The numbers must be printed in ascending order.
If the counterexample does not exist, print the single number -1.
Examples
Input
2 4
Output
2 3 4
Input
10 11
Output
-1
Input
900000000000000009 900000000000000029
Output
900000000000000009 900000000000000010 900000000000000021
Note
In the first sample pair (2, 4) is not coprime and pairs (2, 3) and (3, 4) are.
In the second sample you cannot form a group of three distinct integers, so the answer is -1.
In the third sample it is easy to see that numbers 900000000000000009 and 900000000000000021 are divisible by three. | instruction | 0 | 88,808 | 22 | 177,616 |
Tags: brute force, implementation, math, number theory
Correct Solution:
```
if __name__ == '__main__':
l, r = [int(i) for i in input().split()]
if r - l < 2: print(-1)
elif l % 2 == 0: print(l, l + 1, l + 2)
elif r - l > 2: print(l + 1, l + 2, l + 3)
else: print(-1)
``` | output | 1 | 88,808 | 22 | 177,617 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your friend has recently learned about coprime numbers. A pair of numbers {a, b} is called coprime if the maximum number that divides both a and b is equal to one.
Your friend often comes up with different statements. He has recently supposed that if the pair (a, b) is coprime and the pair (b, c) is coprime, then the pair (a, c) is coprime.
You want to find a counterexample for your friend's statement. Therefore, your task is to find three distinct numbers (a, b, c), for which the statement is false, and the numbers meet the condition l ≤ a < b < c ≤ r.
More specifically, you need to find three numbers (a, b, c), such that l ≤ a < b < c ≤ r, pairs (a, b) and (b, c) are coprime, and pair (a, c) is not coprime.
Input
The single line contains two positive space-separated integers l, r (1 ≤ l ≤ r ≤ 1018; r - l ≤ 50).
Output
Print three positive space-separated integers a, b, c — three distinct numbers (a, b, c) that form the counterexample. If there are several solutions, you are allowed to print any of them. The numbers must be printed in ascending order.
If the counterexample does not exist, print the single number -1.
Examples
Input
2 4
Output
2 3 4
Input
10 11
Output
-1
Input
900000000000000009 900000000000000029
Output
900000000000000009 900000000000000010 900000000000000021
Note
In the first sample pair (2, 4) is not coprime and pairs (2, 3) and (3, 4) are.
In the second sample you cannot form a group of three distinct integers, so the answer is -1.
In the third sample it is easy to see that numbers 900000000000000009 and 900000000000000021 are divisible by three.
Submitted Solution:
```
l, r = map(int, input().split())
l += l % 2
if (r - l < 2):
print(-1)
else:
print(l, l + 1, l + 2)
``` | instruction | 0 | 88,809 | 22 | 177,618 |
Yes | output | 1 | 88,809 | 22 | 177,619 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your friend has recently learned about coprime numbers. A pair of numbers {a, b} is called coprime if the maximum number that divides both a and b is equal to one.
Your friend often comes up with different statements. He has recently supposed that if the pair (a, b) is coprime and the pair (b, c) is coprime, then the pair (a, c) is coprime.
You want to find a counterexample for your friend's statement. Therefore, your task is to find three distinct numbers (a, b, c), for which the statement is false, and the numbers meet the condition l ≤ a < b < c ≤ r.
More specifically, you need to find three numbers (a, b, c), such that l ≤ a < b < c ≤ r, pairs (a, b) and (b, c) are coprime, and pair (a, c) is not coprime.
Input
The single line contains two positive space-separated integers l, r (1 ≤ l ≤ r ≤ 1018; r - l ≤ 50).
Output
Print three positive space-separated integers a, b, c — three distinct numbers (a, b, c) that form the counterexample. If there are several solutions, you are allowed to print any of them. The numbers must be printed in ascending order.
If the counterexample does not exist, print the single number -1.
Examples
Input
2 4
Output
2 3 4
Input
10 11
Output
-1
Input
900000000000000009 900000000000000029
Output
900000000000000009 900000000000000010 900000000000000021
Note
In the first sample pair (2, 4) is not coprime and pairs (2, 3) and (3, 4) are.
In the second sample you cannot form a group of three distinct integers, so the answer is -1.
In the third sample it is easy to see that numbers 900000000000000009 and 900000000000000021 are divisible by three.
Submitted Solution:
```
from math import gcd
l,r=map(int,input().split())
res=False
for a in range(l,r+1):
for b in range(a+1,r+1):
for c in range(b+1,r+1):
if gcd(a,b)==1 and gcd(b,c)==1 and gcd(a,c)!=1:
print(str(a)+' '+str(b)+' '+str(c))
res=True
break
if res:
break
if res:
break
if not res:
print(-1)
``` | instruction | 0 | 88,810 | 22 | 177,620 |
Yes | output | 1 | 88,810 | 22 | 177,621 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your friend has recently learned about coprime numbers. A pair of numbers {a, b} is called coprime if the maximum number that divides both a and b is equal to one.
Your friend often comes up with different statements. He has recently supposed that if the pair (a, b) is coprime and the pair (b, c) is coprime, then the pair (a, c) is coprime.
You want to find a counterexample for your friend's statement. Therefore, your task is to find three distinct numbers (a, b, c), for which the statement is false, and the numbers meet the condition l ≤ a < b < c ≤ r.
More specifically, you need to find three numbers (a, b, c), such that l ≤ a < b < c ≤ r, pairs (a, b) and (b, c) are coprime, and pair (a, c) is not coprime.
Input
The single line contains two positive space-separated integers l, r (1 ≤ l ≤ r ≤ 1018; r - l ≤ 50).
Output
Print three positive space-separated integers a, b, c — three distinct numbers (a, b, c) that form the counterexample. If there are several solutions, you are allowed to print any of them. The numbers must be printed in ascending order.
If the counterexample does not exist, print the single number -1.
Examples
Input
2 4
Output
2 3 4
Input
10 11
Output
-1
Input
900000000000000009 900000000000000029
Output
900000000000000009 900000000000000010 900000000000000021
Note
In the first sample pair (2, 4) is not coprime and pairs (2, 3) and (3, 4) are.
In the second sample you cannot form a group of three distinct integers, so the answer is -1.
In the third sample it is easy to see that numbers 900000000000000009 and 900000000000000021 are divisible by three.
Submitted Solution:
```
l, r = map(int, input().split())
if r - l < 2:
print('-1')
if r - l == 2 and l % 2 == 1:
print('-1')
if r - l >= 2 and l % 2 == 0:
print(l, l + 1, l + 2)
if r - l > 2 and l % 2 == 1:
print(l + 1, l + 2, l + 3)
``` | instruction | 0 | 88,811 | 22 | 177,622 |
Yes | output | 1 | 88,811 | 22 | 177,623 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your friend has recently learned about coprime numbers. A pair of numbers {a, b} is called coprime if the maximum number that divides both a and b is equal to one.
Your friend often comes up with different statements. He has recently supposed that if the pair (a, b) is coprime and the pair (b, c) is coprime, then the pair (a, c) is coprime.
You want to find a counterexample for your friend's statement. Therefore, your task is to find three distinct numbers (a, b, c), for which the statement is false, and the numbers meet the condition l ≤ a < b < c ≤ r.
More specifically, you need to find three numbers (a, b, c), such that l ≤ a < b < c ≤ r, pairs (a, b) and (b, c) are coprime, and pair (a, c) is not coprime.
Input
The single line contains two positive space-separated integers l, r (1 ≤ l ≤ r ≤ 1018; r - l ≤ 50).
Output
Print three positive space-separated integers a, b, c — three distinct numbers (a, b, c) that form the counterexample. If there are several solutions, you are allowed to print any of them. The numbers must be printed in ascending order.
If the counterexample does not exist, print the single number -1.
Examples
Input
2 4
Output
2 3 4
Input
10 11
Output
-1
Input
900000000000000009 900000000000000029
Output
900000000000000009 900000000000000010 900000000000000021
Note
In the first sample pair (2, 4) is not coprime and pairs (2, 3) and (3, 4) are.
In the second sample you cannot form a group of three distinct integers, so the answer is -1.
In the third sample it is easy to see that numbers 900000000000000009 and 900000000000000021 are divisible by three.
Submitted Solution:
```
# In this template you are not required to write code in main
import sys
inf = float("inf")
#from collections import deque, Counter, OrderedDict,defaultdict
#from heapq import nsmallest, nlargest, heapify,heappop ,heappush, heapreplace
from math import ceil,floor,log,sqrt,factorial,pow,pi,gcd
#from bisect import bisect_left,bisect_right
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,MOD=1000000007,998244353
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def input(): return sys.stdin.readline().strip()
l,r=get_ints()
flag=0
for i in range(l,r-1):
for j in range(i+1,r):
for k in range(j+1,r+1):
if gcd(i,j)==1 and gcd(j,k)==1 and gcd(i,k)!=1:
flag=1
store1,store2,store3=i,j,k
break
if flag==1:
break
if flag==1:
break
if flag==1:
print(store1,store2,store3)
else:
print(-1)
``` | instruction | 0 | 88,812 | 22 | 177,624 |
Yes | output | 1 | 88,812 | 22 | 177,625 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your friend has recently learned about coprime numbers. A pair of numbers {a, b} is called coprime if the maximum number that divides both a and b is equal to one.
Your friend often comes up with different statements. He has recently supposed that if the pair (a, b) is coprime and the pair (b, c) is coprime, then the pair (a, c) is coprime.
You want to find a counterexample for your friend's statement. Therefore, your task is to find three distinct numbers (a, b, c), for which the statement is false, and the numbers meet the condition l ≤ a < b < c ≤ r.
More specifically, you need to find three numbers (a, b, c), such that l ≤ a < b < c ≤ r, pairs (a, b) and (b, c) are coprime, and pair (a, c) is not coprime.
Input
The single line contains two positive space-separated integers l, r (1 ≤ l ≤ r ≤ 1018; r - l ≤ 50).
Output
Print three positive space-separated integers a, b, c — three distinct numbers (a, b, c) that form the counterexample. If there are several solutions, you are allowed to print any of them. The numbers must be printed in ascending order.
If the counterexample does not exist, print the single number -1.
Examples
Input
2 4
Output
2 3 4
Input
10 11
Output
-1
Input
900000000000000009 900000000000000029
Output
900000000000000009 900000000000000010 900000000000000021
Note
In the first sample pair (2, 4) is not coprime and pairs (2, 3) and (3, 4) are.
In the second sample you cannot form a group of three distinct integers, so the answer is -1.
In the third sample it is easy to see that numbers 900000000000000009 and 900000000000000021 are divisible by three.
Submitted Solution:
```
a,b=map(int,input().split())
if((b-a)==1):
print(-1)
else:
if(a%3==0):
print(a,a+1,a+12)
elif(a%2==0):
print(a,a+1,a+2)
else:
if((b-a)<3):
if(a%2==0):
print(a,a+1,a+2)
else:
print(-1)
``` | instruction | 0 | 88,813 | 22 | 177,626 |
No | output | 1 | 88,813 | 22 | 177,627 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your friend has recently learned about coprime numbers. A pair of numbers {a, b} is called coprime if the maximum number that divides both a and b is equal to one.
Your friend often comes up with different statements. He has recently supposed that if the pair (a, b) is coprime and the pair (b, c) is coprime, then the pair (a, c) is coprime.
You want to find a counterexample for your friend's statement. Therefore, your task is to find three distinct numbers (a, b, c), for which the statement is false, and the numbers meet the condition l ≤ a < b < c ≤ r.
More specifically, you need to find three numbers (a, b, c), such that l ≤ a < b < c ≤ r, pairs (a, b) and (b, c) are coprime, and pair (a, c) is not coprime.
Input
The single line contains two positive space-separated integers l, r (1 ≤ l ≤ r ≤ 1018; r - l ≤ 50).
Output
Print three positive space-separated integers a, b, c — three distinct numbers (a, b, c) that form the counterexample. If there are several solutions, you are allowed to print any of them. The numbers must be printed in ascending order.
If the counterexample does not exist, print the single number -1.
Examples
Input
2 4
Output
2 3 4
Input
10 11
Output
-1
Input
900000000000000009 900000000000000029
Output
900000000000000009 900000000000000010 900000000000000021
Note
In the first sample pair (2, 4) is not coprime and pairs (2, 3) and (3, 4) are.
In the second sample you cannot form a group of three distinct integers, so the answer is -1.
In the third sample it is easy to see that numbers 900000000000000009 and 900000000000000021 are divisible by three.
Submitted Solution:
```
import math
a,b=input().split(" ")
a=int(a)
b=int(b)
if(b-a==1):
print(-1)
else:
x = math.gcd(a,b)
i=a+1
while(i<=i+x):
if(math.gcd(i,a)==math.gcd(i,b)):
print(a,i,b)
exit(0)
print(-1)
``` | instruction | 0 | 88,814 | 22 | 177,628 |
No | output | 1 | 88,814 | 22 | 177,629 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your friend has recently learned about coprime numbers. A pair of numbers {a, b} is called coprime if the maximum number that divides both a and b is equal to one.
Your friend often comes up with different statements. He has recently supposed that if the pair (a, b) is coprime and the pair (b, c) is coprime, then the pair (a, c) is coprime.
You want to find a counterexample for your friend's statement. Therefore, your task is to find three distinct numbers (a, b, c), for which the statement is false, and the numbers meet the condition l ≤ a < b < c ≤ r.
More specifically, you need to find three numbers (a, b, c), such that l ≤ a < b < c ≤ r, pairs (a, b) and (b, c) are coprime, and pair (a, c) is not coprime.
Input
The single line contains two positive space-separated integers l, r (1 ≤ l ≤ r ≤ 1018; r - l ≤ 50).
Output
Print three positive space-separated integers a, b, c — three distinct numbers (a, b, c) that form the counterexample. If there are several solutions, you are allowed to print any of them. The numbers must be printed in ascending order.
If the counterexample does not exist, print the single number -1.
Examples
Input
2 4
Output
2 3 4
Input
10 11
Output
-1
Input
900000000000000009 900000000000000029
Output
900000000000000009 900000000000000010 900000000000000021
Note
In the first sample pair (2, 4) is not coprime and pairs (2, 3) and (3, 4) are.
In the second sample you cannot form a group of three distinct integers, so the answer is -1.
In the third sample it is easy to see that numbers 900000000000000009 and 900000000000000021 are divisible by three.
Submitted Solution:
```
l,r=map(int,input().split())
c=-1
if l==r or r-l==1:
print(-1)
c=1
if l%2==0 and c!=1:
print(l,l+1,l+2)
c=1
if l%2!=0 and c!=1:
print(l+1,l+2,l+3)
c=1
if c!=1:
print(c)
``` | instruction | 0 | 88,815 | 22 | 177,630 |
No | output | 1 | 88,815 | 22 | 177,631 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your friend has recently learned about coprime numbers. A pair of numbers {a, b} is called coprime if the maximum number that divides both a and b is equal to one.
Your friend often comes up with different statements. He has recently supposed that if the pair (a, b) is coprime and the pair (b, c) is coprime, then the pair (a, c) is coprime.
You want to find a counterexample for your friend's statement. Therefore, your task is to find three distinct numbers (a, b, c), for which the statement is false, and the numbers meet the condition l ≤ a < b < c ≤ r.
More specifically, you need to find three numbers (a, b, c), such that l ≤ a < b < c ≤ r, pairs (a, b) and (b, c) are coprime, and pair (a, c) is not coprime.
Input
The single line contains two positive space-separated integers l, r (1 ≤ l ≤ r ≤ 1018; r - l ≤ 50).
Output
Print three positive space-separated integers a, b, c — three distinct numbers (a, b, c) that form the counterexample. If there are several solutions, you are allowed to print any of them. The numbers must be printed in ascending order.
If the counterexample does not exist, print the single number -1.
Examples
Input
2 4
Output
2 3 4
Input
10 11
Output
-1
Input
900000000000000009 900000000000000029
Output
900000000000000009 900000000000000010 900000000000000021
Note
In the first sample pair (2, 4) is not coprime and pairs (2, 3) and (3, 4) are.
In the second sample you cannot form a group of three distinct integers, so the answer is -1.
In the third sample it is easy to see that numbers 900000000000000009 and 900000000000000021 are divisible by three.
Submitted Solution:
```
import math
buff = input().split(" ")
l = int(buff[0])
r = int(buff[1])
a = l
b = l + 1
c = -1
for i in range(b + 1, r + 1):
if math.gcd(a, i) != 1:
c = i
break
if c != -1:
print(a, b, c)
else:
print(-1)
``` | instruction | 0 | 88,816 | 22 | 177,632 |
No | output | 1 | 88,816 | 22 | 177,633 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.