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.
Greatest common divisor GCD(a, b) of two positive integers a and b is equal to the biggest integer d such that both integers a and b are divisible by d. There are many efficient algorithms to find greatest common divisor GCD(a, b), for example, Euclid algorithm.
Formally, find the biggest integer d, such that all integers a, a + 1, a + 2, ..., b are divisible by d. To make the problem even more complicated we allow a and b to be up to googol, 10100 — such number do not fit even in 64-bit integer type!
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10100).
Output
Output one integer — greatest common divisor of all integers from a to b inclusive.
Examples
Input
1 2
Output
1
Input
61803398874989484820458683436563811772030917980576 61803398874989484820458683436563811772030917980576
Output
61803398874989484820458683436563811772030917980576
Submitted Solution:
```
numbers = list(map(int,input().split()))
if (numbers[0] == numbers[1]):
print(numbers[0])
else:
print(1)
``` | instruction | 0 | 74,612 | 22 | 149,224 |
Yes | output | 1 | 74,612 | 22 | 149,225 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Greatest common divisor GCD(a, b) of two positive integers a and b is equal to the biggest integer d such that both integers a and b are divisible by d. There are many efficient algorithms to find greatest common divisor GCD(a, b), for example, Euclid algorithm.
Formally, find the biggest integer d, such that all integers a, a + 1, a + 2, ..., b are divisible by d. To make the problem even more complicated we allow a and b to be up to googol, 10100 — such number do not fit even in 64-bit integer type!
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10100).
Output
Output one integer — greatest common divisor of all integers from a to b inclusive.
Examples
Input
1 2
Output
1
Input
61803398874989484820458683436563811772030917980576 61803398874989484820458683436563811772030917980576
Output
61803398874989484820458683436563811772030917980576
Submitted Solution:
```
def solve():
A, B = input().split()
if A == B:
print(A)
else:
print(1)
if __name__ == '__main__':
solve()
``` | instruction | 0 | 74,613 | 22 | 149,226 |
Yes | output | 1 | 74,613 | 22 | 149,227 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Greatest common divisor GCD(a, b) of two positive integers a and b is equal to the biggest integer d such that both integers a and b are divisible by d. There are many efficient algorithms to find greatest common divisor GCD(a, b), for example, Euclid algorithm.
Formally, find the biggest integer d, such that all integers a, a + 1, a + 2, ..., b are divisible by d. To make the problem even more complicated we allow a and b to be up to googol, 10100 — such number do not fit even in 64-bit integer type!
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10100).
Output
Output one integer — greatest common divisor of all integers from a to b inclusive.
Examples
Input
1 2
Output
1
Input
61803398874989484820458683436563811772030917980576 61803398874989484820458683436563811772030917980576
Output
61803398874989484820458683436563811772030917980576
Submitted Solution:
```
def main():
a, b = [int(x) for x in input().split()]
if a == b:
print(a)
else:
print(1)
main()
``` | instruction | 0 | 74,614 | 22 | 149,228 |
Yes | output | 1 | 74,614 | 22 | 149,229 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Greatest common divisor GCD(a, b) of two positive integers a and b is equal to the biggest integer d such that both integers a and b are divisible by d. There are many efficient algorithms to find greatest common divisor GCD(a, b), for example, Euclid algorithm.
Formally, find the biggest integer d, such that all integers a, a + 1, a + 2, ..., b are divisible by d. To make the problem even more complicated we allow a and b to be up to googol, 10100 — such number do not fit even in 64-bit integer type!
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10100).
Output
Output one integer — greatest common divisor of all integers from a to b inclusive.
Examples
Input
1 2
Output
1
Input
61803398874989484820458683436563811772030917980576 61803398874989484820458683436563811772030917980576
Output
61803398874989484820458683436563811772030917980576
Submitted Solution:
```
str = input().split(' ');
a = int(str[0]);
b = int(str[1]);
if (a == b):
print(a);
else:
print(1);
``` | instruction | 0 | 74,615 | 22 | 149,230 |
Yes | output | 1 | 74,615 | 22 | 149,231 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Greatest common divisor GCD(a, b) of two positive integers a and b is equal to the biggest integer d such that both integers a and b are divisible by d. There are many efficient algorithms to find greatest common divisor GCD(a, b), for example, Euclid algorithm.
Formally, find the biggest integer d, such that all integers a, a + 1, a + 2, ..., b are divisible by d. To make the problem even more complicated we allow a and b to be up to googol, 10100 — such number do not fit even in 64-bit integer type!
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10100).
Output
Output one integer — greatest common divisor of all integers from a to b inclusive.
Examples
Input
1 2
Output
1
Input
61803398874989484820458683436563811772030917980576 61803398874989484820458683436563811772030917980576
Output
61803398874989484820458683436563811772030917980576
Submitted Solution:
```
i = input()
a = i.split()[0]
a = int(a)
b = i.split()[1]
b = int(b)
def gcd(x,y):
if y==0: return x
else: return gcd(y,x%y)
print(gcd(a,b))
``` | instruction | 0 | 74,616 | 22 | 149,232 |
No | output | 1 | 74,616 | 22 | 149,233 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Greatest common divisor GCD(a, b) of two positive integers a and b is equal to the biggest integer d such that both integers a and b are divisible by d. There are many efficient algorithms to find greatest common divisor GCD(a, b), for example, Euclid algorithm.
Formally, find the biggest integer d, such that all integers a, a + 1, a + 2, ..., b are divisible by d. To make the problem even more complicated we allow a and b to be up to googol, 10100 — such number do not fit even in 64-bit integer type!
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10100).
Output
Output one integer — greatest common divisor of all integers from a to b inclusive.
Examples
Input
1 2
Output
1
Input
61803398874989484820458683436563811772030917980576 61803398874989484820458683436563811772030917980576
Output
61803398874989484820458683436563811772030917980576
Submitted Solution:
```
a, b = map(int, input().split())
print([a, 1][a == b])
``` | instruction | 0 | 74,617 | 22 | 149,234 |
No | output | 1 | 74,617 | 22 | 149,235 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Greatest common divisor GCD(a, b) of two positive integers a and b is equal to the biggest integer d such that both integers a and b are divisible by d. There are many efficient algorithms to find greatest common divisor GCD(a, b), for example, Euclid algorithm.
Formally, find the biggest integer d, such that all integers a, a + 1, a + 2, ..., b are divisible by d. To make the problem even more complicated we allow a and b to be up to googol, 10100 — such number do not fit even in 64-bit integer type!
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10100).
Output
Output one integer — greatest common divisor of all integers from a to b inclusive.
Examples
Input
1 2
Output
1
Input
61803398874989484820458683436563811772030917980576 61803398874989484820458683436563811772030917980576
Output
61803398874989484820458683436563811772030917980576
Submitted Solution:
```
def gcd(a,b):
if a==0:
return b
return gcd(b%a,a)
d=input().split()
a=int(d[0])
b=int(d[1])
print(gcd(a,b))
``` | instruction | 0 | 74,618 | 22 | 149,236 |
No | output | 1 | 74,618 | 22 | 149,237 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Greatest common divisor GCD(a, b) of two positive integers a and b is equal to the biggest integer d such that both integers a and b are divisible by d. There are many efficient algorithms to find greatest common divisor GCD(a, b), for example, Euclid algorithm.
Formally, find the biggest integer d, such that all integers a, a + 1, a + 2, ..., b are divisible by d. To make the problem even more complicated we allow a and b to be up to googol, 10100 — such number do not fit even in 64-bit integer type!
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10100).
Output
Output one integer — greatest common divisor of all integers from a to b inclusive.
Examples
Input
1 2
Output
1
Input
61803398874989484820458683436563811772030917980576 61803398874989484820458683436563811772030917980576
Output
61803398874989484820458683436563811772030917980576
Submitted Solution:
```
from fractions import gcd
n,m=map(int,input().split())
print(gcd(n,m))
``` | instruction | 0 | 74,619 | 22 | 149,238 |
No | output | 1 | 74,619 | 22 | 149,239 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Today Pari and Arya are playing a game called Remainders.
Pari chooses two positive integer x and k, and tells Arya k but not x. Arya have to find the value <image>. There are n ancient numbers c1, c2, ..., cn and Pari has to tell Arya <image> if Arya wants. Given k and the ancient values, tell us if Arya has a winning strategy independent of value of x or not. Formally, is it true that Arya can understand the value <image> for any positive integer x?
Note, that <image> means the remainder of x after dividing it by y.
Input
The first line of the input contains two integers n and k (1 ≤ n, k ≤ 1 000 000) — the number of ancient integers and value k that is chosen by Pari.
The second line contains n integers c1, c2, ..., cn (1 ≤ ci ≤ 1 000 000).
Output
Print "Yes" (without quotes) if Arya has a winning strategy independent of value of x, or "No" (without quotes) otherwise.
Examples
Input
4 5
2 3 5 12
Output
Yes
Input
2 7
2 3
Output
No
Note
In the first sample, Arya can understand <image> because 5 is one of the ancient numbers.
In the second sample, Arya can't be sure what <image> is. For example 1 and 7 have the same remainders after dividing by 2 and 3, but they differ in remainders after dividing by 7. | instruction | 0 | 74,620 | 22 | 149,240 |
Tags: chinese remainder theorem, math, number theory
Correct Solution:
```
#prime factorize the k
import math
a=input().split(' ')
n=int(a[0])
k=int(a[1])
t=True
def gcd(a, b):
if b==0: return a
else: return gcd(b, a%b)
C=set(map(int, input().split()))
Composite=False
a=math.floor(math.sqrt(k+1))
if k%2==0: Composite=True
else:
for i in range(3, a+1, 2):
if k%i==0:
Composite=True
break
if not Composite:
if k>max(C):print ('NO')
else:
A=set()
z=True
for i in C:
if i in A: pass
if i%k==0:
z=False
print ('YES')
break
else: A.add(i)
if z: print('NO')
else:
A=set()
m=1
for i in C:
if i in A: pass
else:
A.add(i)
m*=i/gcd(m,i)
m%=k
if m==0:
t=False
print('YES')
break
if t: print('NO')
``` | output | 1 | 74,620 | 22 | 149,241 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Today Pari and Arya are playing a game called Remainders.
Pari chooses two positive integer x and k, and tells Arya k but not x. Arya have to find the value <image>. There are n ancient numbers c1, c2, ..., cn and Pari has to tell Arya <image> if Arya wants. Given k and the ancient values, tell us if Arya has a winning strategy independent of value of x or not. Formally, is it true that Arya can understand the value <image> for any positive integer x?
Note, that <image> means the remainder of x after dividing it by y.
Input
The first line of the input contains two integers n and k (1 ≤ n, k ≤ 1 000 000) — the number of ancient integers and value k that is chosen by Pari.
The second line contains n integers c1, c2, ..., cn (1 ≤ ci ≤ 1 000 000).
Output
Print "Yes" (without quotes) if Arya has a winning strategy independent of value of x, or "No" (without quotes) otherwise.
Examples
Input
4 5
2 3 5 12
Output
Yes
Input
2 7
2 3
Output
No
Note
In the first sample, Arya can understand <image> because 5 is one of the ancient numbers.
In the second sample, Arya can't be sure what <image> is. For example 1 and 7 have the same remainders after dividing by 2 and 3, but they differ in remainders after dividing by 7. | instruction | 0 | 74,621 | 22 | 149,242 |
Tags: chinese remainder theorem, math, number theory
Correct Solution:
```
from math import *
n,k=map(int,input().split())
arr=list(map(int,input().split()))
flag=0
if(k==1):
print('Yes')
else:
arr1=[]
temp=k
for i in range(2,k+1):
if(temp%i==0):
cnt=0
while(temp%i==0):
cnt+=1
temp=temp//i
arr1.append(i**cnt)
#print(*arr1)
mainflag=0
for j in arr1:
flag=0
for i in range(n):
if(arr[i]%j==0):
flag=1
break
if(flag==0):
mainflag=1
break
if(mainflag==1):
print('No')
else:
print('Yes')
``` | output | 1 | 74,621 | 22 | 149,243 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today Pari and Arya are playing a game called Remainders.
Pari chooses two positive integer x and k, and tells Arya k but not x. Arya have to find the value <image>. There are n ancient numbers c1, c2, ..., cn and Pari has to tell Arya <image> if Arya wants. Given k and the ancient values, tell us if Arya has a winning strategy independent of value of x or not. Formally, is it true that Arya can understand the value <image> for any positive integer x?
Note, that <image> means the remainder of x after dividing it by y.
Input
The first line of the input contains two integers n and k (1 ≤ n, k ≤ 1 000 000) — the number of ancient integers and value k that is chosen by Pari.
The second line contains n integers c1, c2, ..., cn (1 ≤ ci ≤ 1 000 000).
Output
Print "Yes" (without quotes) if Arya has a winning strategy independent of value of x, or "No" (without quotes) otherwise.
Examples
Input
4 5
2 3 5 12
Output
Yes
Input
2 7
2 3
Output
No
Note
In the first sample, Arya can understand <image> because 5 is one of the ancient numbers.
In the second sample, Arya can't be sure what <image> is. For example 1 and 7 have the same remainders after dividing by 2 and 3, but they differ in remainders after dividing by 7.
Submitted Solution:
```
#prime factorize the k
import math
a=input().split(' ')
n=int(a[0])
k=int(a[1])
t=True
def gcd(a, b):
if b==0: return a
else: return gcd(b, a%b)
C=set(map(int, input().split()))
h=False
a=math.floor(math.sqrt(k+1))
if k%2==0: pass
else:
for i in range(3, a+1, 2):
if k%i==0:
h=True
break
if h:
if k>max(C):print ('NO')
else:
A=set()
z=True
for i in C:
if i in A: pass
if i%k==0:
z=False
print ('YES')
break
else: A.add(i)
if z: print('NO')
else:
A=set()
m=1
for i in C:
if i in A: pass
else:
A.add(i)
m*=i/gcd(m,i)
m%=k
if m==0:
t=False
print('YES')
break
if t: print('NO')
``` | instruction | 0 | 74,622 | 22 | 149,244 |
No | output | 1 | 74,622 | 22 | 149,245 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today Pari and Arya are playing a game called Remainders.
Pari chooses two positive integer x and k, and tells Arya k but not x. Arya have to find the value <image>. There are n ancient numbers c1, c2, ..., cn and Pari has to tell Arya <image> if Arya wants. Given k and the ancient values, tell us if Arya has a winning strategy independent of value of x or not. Formally, is it true that Arya can understand the value <image> for any positive integer x?
Note, that <image> means the remainder of x after dividing it by y.
Input
The first line of the input contains two integers n and k (1 ≤ n, k ≤ 1 000 000) — the number of ancient integers and value k that is chosen by Pari.
The second line contains n integers c1, c2, ..., cn (1 ≤ ci ≤ 1 000 000).
Output
Print "Yes" (without quotes) if Arya has a winning strategy independent of value of x, or "No" (without quotes) otherwise.
Examples
Input
4 5
2 3 5 12
Output
Yes
Input
2 7
2 3
Output
No
Note
In the first sample, Arya can understand <image> because 5 is one of the ancient numbers.
In the second sample, Arya can't be sure what <image> is. For example 1 and 7 have the same remainders after dividing by 2 and 3, but they differ in remainders after dividing by 7.
Submitted Solution:
```
#prime factorize the k
import math
a=input().split(' ')
n=int(a[0])
k=int(a[1])
C=input().split(' ')
def lspr(a):
l=[2]
for i in range(3, a+1, 2):
for j in l:
if i%j==0:
break
elif i not in l:
l.append(i)
return l
d={}
a=math.floor(math.sqrt(k+1))
for i in lspr(a):
if k==1: break
elif k%i==0:
if i not in d:
k/=i
d[i]=1
while k%i==0:
k/=i
d[i]+=1
if k!=1: d[k]=1
x=set()
for i in C:
i=int(i)
for j in d:
if i%(j**d.get(j))==0:
i/=j**(d.get(j))
while i%j:
i/=j
x.add(j)
for i in x:
del d[i]
if d=={}: print ('YES')
else: print('NO')
``` | instruction | 0 | 74,623 | 22 | 149,246 |
No | output | 1 | 74,623 | 22 | 149,247 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today Pari and Arya are playing a game called Remainders.
Pari chooses two positive integer x and k, and tells Arya k but not x. Arya have to find the value <image>. There are n ancient numbers c1, c2, ..., cn and Pari has to tell Arya <image> if Arya wants. Given k and the ancient values, tell us if Arya has a winning strategy independent of value of x or not. Formally, is it true that Arya can understand the value <image> for any positive integer x?
Note, that <image> means the remainder of x after dividing it by y.
Input
The first line of the input contains two integers n and k (1 ≤ n, k ≤ 1 000 000) — the number of ancient integers and value k that is chosen by Pari.
The second line contains n integers c1, c2, ..., cn (1 ≤ ci ≤ 1 000 000).
Output
Print "Yes" (without quotes) if Arya has a winning strategy independent of value of x, or "No" (without quotes) otherwise.
Examples
Input
4 5
2 3 5 12
Output
Yes
Input
2 7
2 3
Output
No
Note
In the first sample, Arya can understand <image> because 5 is one of the ancient numbers.
In the second sample, Arya can't be sure what <image> is. For example 1 and 7 have the same remainders after dividing by 2 and 3, but they differ in remainders after dividing by 7.
Submitted Solution:
```
from math import *
n,k=map(int,input().split())
arr=list(map(int,input().split()))
flag=0
if(k==1):
print('Yes')
else:
for i in range(n):
if(arr[i]%k==0):
flag=1
break
elif(arr[i]!=1 and floor(log(k,arr[i]))==ceil(log(k,arr[i]))):
flag=1
break
if(flag==1):
print('Yes')
else:
print('No')
``` | instruction | 0 | 74,624 | 22 | 149,248 |
No | output | 1 | 74,624 | 22 | 149,249 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today Pari and Arya are playing a game called Remainders.
Pari chooses two positive integer x and k, and tells Arya k but not x. Arya have to find the value <image>. There are n ancient numbers c1, c2, ..., cn and Pari has to tell Arya <image> if Arya wants. Given k and the ancient values, tell us if Arya has a winning strategy independent of value of x or not. Formally, is it true that Arya can understand the value <image> for any positive integer x?
Note, that <image> means the remainder of x after dividing it by y.
Input
The first line of the input contains two integers n and k (1 ≤ n, k ≤ 1 000 000) — the number of ancient integers and value k that is chosen by Pari.
The second line contains n integers c1, c2, ..., cn (1 ≤ ci ≤ 1 000 000).
Output
Print "Yes" (without quotes) if Arya has a winning strategy independent of value of x, or "No" (without quotes) otherwise.
Examples
Input
4 5
2 3 5 12
Output
Yes
Input
2 7
2 3
Output
No
Note
In the first sample, Arya can understand <image> because 5 is one of the ancient numbers.
In the second sample, Arya can't be sure what <image> is. For example 1 and 7 have the same remainders after dividing by 2 and 3, but they differ in remainders after dividing by 7.
Submitted Solution:
```
#prime factorize the k
import math
a=input().split(' ')
n=int(a[0])
k=int(a[1])
C=input().split(' ')
def lspr(a):
l=[2]
for i in range(3, a+1, 2):
for j in l:
if i%j==0:
break
elif i not in l:
l.append(i)
return l
d={}
def fac(k):
global d
a=math.floor(math.sqrt(k+1))
for i in lspr(a):
if k==1: break
elif k%i==0:
if i not in d:
k/=i
d[i]=1
while k%i==0:
k/=i
d[i]+=1
fac(k)
x=set()
for i in C:
i=int(i)
for j in d:
if i%(j**d.get(j))==0:
i/=j**(d.get(j))
while i%j:
i/=j
x.add(j)
for i in x:
del d[i]
if d=={}: print ('YES')
else: print('NO')
``` | instruction | 0 | 74,625 | 22 | 149,250 |
No | output | 1 | 74,625 | 22 | 149,251 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a dream Marco met an elderly man with a pair of black glasses. The man told him the key to immortality and then disappeared with the wind of time.
When he woke up, he only remembered that the key was a sequence of positive integers of some length n, but forgot the exact sequence. Let the elements of the sequence be a1, a2, ..., an. He remembered that he calculated gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n and put it into a set S. gcd here means the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor).
Note that even if a number is put into the set S twice or more, it only appears once in the set.
Now Marco gives you the set S and asks you to help him figure out the initial sequence. If there are many solutions, print any of them. It is also possible that there are no sequences that produce the set S, in this case print -1.
Input
The first line contains a single integer m (1 ≤ m ≤ 1000) — the size of the set S.
The second line contains m integers s1, s2, ..., sm (1 ≤ si ≤ 106) — the elements of the set S. It's guaranteed that the elements of the set are given in strictly increasing order, that means s1 < s2 < ... < sm.
Output
If there is no solution, print a single line containing -1.
Otherwise, in the first line print a single integer n denoting the length of the sequence, n should not exceed 4000.
In the second line print n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the sequence.
We can show that if a solution exists, then there is a solution with n not exceeding 4000 and ai not exceeding 106.
If there are multiple solutions, print any of them.
Examples
Input
4
2 4 6 12
Output
3
4 6 12
Input
2
2 3
Output
-1
Note
In the first example 2 = gcd(4, 6), the other elements from the set appear in the sequence, and we can show that there are no values different from 2, 4, 6 and 12 among gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n. | instruction | 0 | 74,706 | 22 | 149,412 |
Tags: constructive algorithms, math
Correct Solution:
```
from math import gcd
n=int(input())
l=[int(x) for x in input().split()]
for i in range(n):
if l[i]%l[0]:
print("-1")
exit(0)
print(2*n)
for i in range(n):
print(l[0],l[i],end=" ")
``` | output | 1 | 74,706 | 22 | 149,413 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a dream Marco met an elderly man with a pair of black glasses. The man told him the key to immortality and then disappeared with the wind of time.
When he woke up, he only remembered that the key was a sequence of positive integers of some length n, but forgot the exact sequence. Let the elements of the sequence be a1, a2, ..., an. He remembered that he calculated gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n and put it into a set S. gcd here means the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor).
Note that even if a number is put into the set S twice or more, it only appears once in the set.
Now Marco gives you the set S and asks you to help him figure out the initial sequence. If there are many solutions, print any of them. It is also possible that there are no sequences that produce the set S, in this case print -1.
Input
The first line contains a single integer m (1 ≤ m ≤ 1000) — the size of the set S.
The second line contains m integers s1, s2, ..., sm (1 ≤ si ≤ 106) — the elements of the set S. It's guaranteed that the elements of the set are given in strictly increasing order, that means s1 < s2 < ... < sm.
Output
If there is no solution, print a single line containing -1.
Otherwise, in the first line print a single integer n denoting the length of the sequence, n should not exceed 4000.
In the second line print n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the sequence.
We can show that if a solution exists, then there is a solution with n not exceeding 4000 and ai not exceeding 106.
If there are multiple solutions, print any of them.
Examples
Input
4
2 4 6 12
Output
3
4 6 12
Input
2
2 3
Output
-1
Note
In the first example 2 = gcd(4, 6), the other elements from the set appear in the sequence, and we can show that there are no values different from 2, 4, 6 and 12 among gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n. | instruction | 0 | 74,707 | 22 | 149,414 |
Tags: constructive algorithms, math
Correct Solution:
```
from collections import defaultdict,deque
import sys
import bisect
input=sys.stdin.readline
n=int(input())
hcf=[int(i) for i in input().split() if i!='\n']
ans=[]
if n==1:
print(1)
print(hcf[0])
else:
for i in range(1,n):
if hcf[i]%hcf[0]!=0:
print(-1)
break
else:
for i in range(n):
ans.append(hcf[i])
ans.append(hcf[0])
print(len(ans))
print(*ans)
``` | output | 1 | 74,707 | 22 | 149,415 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a dream Marco met an elderly man with a pair of black glasses. The man told him the key to immortality and then disappeared with the wind of time.
When he woke up, he only remembered that the key was a sequence of positive integers of some length n, but forgot the exact sequence. Let the elements of the sequence be a1, a2, ..., an. He remembered that he calculated gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n and put it into a set S. gcd here means the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor).
Note that even if a number is put into the set S twice or more, it only appears once in the set.
Now Marco gives you the set S and asks you to help him figure out the initial sequence. If there are many solutions, print any of them. It is also possible that there are no sequences that produce the set S, in this case print -1.
Input
The first line contains a single integer m (1 ≤ m ≤ 1000) — the size of the set S.
The second line contains m integers s1, s2, ..., sm (1 ≤ si ≤ 106) — the elements of the set S. It's guaranteed that the elements of the set are given in strictly increasing order, that means s1 < s2 < ... < sm.
Output
If there is no solution, print a single line containing -1.
Otherwise, in the first line print a single integer n denoting the length of the sequence, n should not exceed 4000.
In the second line print n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the sequence.
We can show that if a solution exists, then there is a solution with n not exceeding 4000 and ai not exceeding 106.
If there are multiple solutions, print any of them.
Examples
Input
4
2 4 6 12
Output
3
4 6 12
Input
2
2 3
Output
-1
Note
In the first example 2 = gcd(4, 6), the other elements from the set appear in the sequence, and we can show that there are no values different from 2, 4, 6 and 12 among gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n. | instruction | 0 | 74,708 | 22 | 149,416 |
Tags: constructive algorithms, math
Correct Solution:
```
def gcd(a,b):
if a < b:
return gcd(b,a)
if a == b:
return a
if b == 0:
return a
return gcd(a%b,b)
def gcd_group(a,s):
if s == 1:
return a[0]
if s == 2:
return gcd(a[0],a[1])
return gcd(gcd_group(a[:-1],s-1),a[-1])
m = int(input())
a = list(map(int,input().split()))
if m == 1:
print(1)
print(a[0])
else:
t = 0
for i in a[1:]:
if i % a[0] != 0:
print(-1)
t = 1
break
if t == 0:
k = [str(a[0])]
for i in a[1:]:
k.append(str(i))
k.append(str(a[0]))
print(2*m-1)
print(' '.join(k))
``` | output | 1 | 74,708 | 22 | 149,417 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a dream Marco met an elderly man with a pair of black glasses. The man told him the key to immortality and then disappeared with the wind of time.
When he woke up, he only remembered that the key was a sequence of positive integers of some length n, but forgot the exact sequence. Let the elements of the sequence be a1, a2, ..., an. He remembered that he calculated gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n and put it into a set S. gcd here means the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor).
Note that even if a number is put into the set S twice or more, it only appears once in the set.
Now Marco gives you the set S and asks you to help him figure out the initial sequence. If there are many solutions, print any of them. It is also possible that there are no sequences that produce the set S, in this case print -1.
Input
The first line contains a single integer m (1 ≤ m ≤ 1000) — the size of the set S.
The second line contains m integers s1, s2, ..., sm (1 ≤ si ≤ 106) — the elements of the set S. It's guaranteed that the elements of the set are given in strictly increasing order, that means s1 < s2 < ... < sm.
Output
If there is no solution, print a single line containing -1.
Otherwise, in the first line print a single integer n denoting the length of the sequence, n should not exceed 4000.
In the second line print n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the sequence.
We can show that if a solution exists, then there is a solution with n not exceeding 4000 and ai not exceeding 106.
If there are multiple solutions, print any of them.
Examples
Input
4
2 4 6 12
Output
3
4 6 12
Input
2
2 3
Output
-1
Note
In the first example 2 = gcd(4, 6), the other elements from the set appear in the sequence, and we can show that there are no values different from 2, 4, 6 and 12 among gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n. | instruction | 0 | 74,709 | 22 | 149,418 |
Tags: constructive algorithms, math
Correct Solution:
```
m = int(input())
s = list(map(int,input().split(' ')))
fl = True
for i in range(1,m):
if s[i]%s[0]:
fl = False
break
if not fl:
print(-1)
else:
print(m*2)
for i in range(m):
print(s[i],s[0],end=' ')
``` | output | 1 | 74,709 | 22 | 149,419 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a dream Marco met an elderly man with a pair of black glasses. The man told him the key to immortality and then disappeared with the wind of time.
When he woke up, he only remembered that the key was a sequence of positive integers of some length n, but forgot the exact sequence. Let the elements of the sequence be a1, a2, ..., an. He remembered that he calculated gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n and put it into a set S. gcd here means the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor).
Note that even if a number is put into the set S twice or more, it only appears once in the set.
Now Marco gives you the set S and asks you to help him figure out the initial sequence. If there are many solutions, print any of them. It is also possible that there are no sequences that produce the set S, in this case print -1.
Input
The first line contains a single integer m (1 ≤ m ≤ 1000) — the size of the set S.
The second line contains m integers s1, s2, ..., sm (1 ≤ si ≤ 106) — the elements of the set S. It's guaranteed that the elements of the set are given in strictly increasing order, that means s1 < s2 < ... < sm.
Output
If there is no solution, print a single line containing -1.
Otherwise, in the first line print a single integer n denoting the length of the sequence, n should not exceed 4000.
In the second line print n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the sequence.
We can show that if a solution exists, then there is a solution with n not exceeding 4000 and ai not exceeding 106.
If there are multiple solutions, print any of them.
Examples
Input
4
2 4 6 12
Output
3
4 6 12
Input
2
2 3
Output
-1
Note
In the first example 2 = gcd(4, 6), the other elements from the set appear in the sequence, and we can show that there are no values different from 2, 4, 6 and 12 among gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n. | instruction | 0 | 74,710 | 22 | 149,420 |
Tags: constructive algorithms, math
Correct Solution:
```
def gcd(a,b):
if(b==0):
return a
else:
return gcd(b,a%b)
n=int(input())
a=list(map(int,input().split()))
gcd1=a[0]
for i in range(1,n):
gcd1=gcd(gcd1,a[i])
if gcd1 not in a:
print(-1)
else:
s=''
for i in range(n):
s+=str(gcd1) + ' ' + str(a[i]) + ' ' + str(gcd1) + ' '
print(3*n)
print(s[:-1])
``` | output | 1 | 74,710 | 22 | 149,421 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a dream Marco met an elderly man with a pair of black glasses. The man told him the key to immortality and then disappeared with the wind of time.
When he woke up, he only remembered that the key was a sequence of positive integers of some length n, but forgot the exact sequence. Let the elements of the sequence be a1, a2, ..., an. He remembered that he calculated gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n and put it into a set S. gcd here means the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor).
Note that even if a number is put into the set S twice or more, it only appears once in the set.
Now Marco gives you the set S and asks you to help him figure out the initial sequence. If there are many solutions, print any of them. It is also possible that there are no sequences that produce the set S, in this case print -1.
Input
The first line contains a single integer m (1 ≤ m ≤ 1000) — the size of the set S.
The second line contains m integers s1, s2, ..., sm (1 ≤ si ≤ 106) — the elements of the set S. It's guaranteed that the elements of the set are given in strictly increasing order, that means s1 < s2 < ... < sm.
Output
If there is no solution, print a single line containing -1.
Otherwise, in the first line print a single integer n denoting the length of the sequence, n should not exceed 4000.
In the second line print n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the sequence.
We can show that if a solution exists, then there is a solution with n not exceeding 4000 and ai not exceeding 106.
If there are multiple solutions, print any of them.
Examples
Input
4
2 4 6 12
Output
3
4 6 12
Input
2
2 3
Output
-1
Note
In the first example 2 = gcd(4, 6), the other elements from the set appear in the sequence, and we can show that there are no values different from 2, 4, 6 and 12 among gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n. | instruction | 0 | 74,711 | 22 | 149,422 |
Tags: constructive algorithms, math
Correct Solution:
```
def gcd(a, b):
if b==0:
return a
return gcd(b, a%b)
def solve(a):
if len(a) == 1:
return 1, str(a[0])
d = {x: 1 for x in a}
arr = []
g_ = a[0]
for x in a[1:]:
g_ = gcd(g_, x)
if g_ not in d:
return -1, None
return 2*len(a)-1, ' {} '.format(str(g_)).join([str(x) for x in a])
n = int(input())
a = list(map(int, input().split()))
arr = solve(a)
if arr[0] == -1:
print(-1)
else:
print(arr[0])
print(arr[1])
``` | output | 1 | 74,711 | 22 | 149,423 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a dream Marco met an elderly man with a pair of black glasses. The man told him the key to immortality and then disappeared with the wind of time.
When he woke up, he only remembered that the key was a sequence of positive integers of some length n, but forgot the exact sequence. Let the elements of the sequence be a1, a2, ..., an. He remembered that he calculated gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n and put it into a set S. gcd here means the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor).
Note that even if a number is put into the set S twice or more, it only appears once in the set.
Now Marco gives you the set S and asks you to help him figure out the initial sequence. If there are many solutions, print any of them. It is also possible that there are no sequences that produce the set S, in this case print -1.
Input
The first line contains a single integer m (1 ≤ m ≤ 1000) — the size of the set S.
The second line contains m integers s1, s2, ..., sm (1 ≤ si ≤ 106) — the elements of the set S. It's guaranteed that the elements of the set are given in strictly increasing order, that means s1 < s2 < ... < sm.
Output
If there is no solution, print a single line containing -1.
Otherwise, in the first line print a single integer n denoting the length of the sequence, n should not exceed 4000.
In the second line print n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the sequence.
We can show that if a solution exists, then there is a solution with n not exceeding 4000 and ai not exceeding 106.
If there are multiple solutions, print any of them.
Examples
Input
4
2 4 6 12
Output
3
4 6 12
Input
2
2 3
Output
-1
Note
In the first example 2 = gcd(4, 6), the other elements from the set appear in the sequence, and we can show that there are no values different from 2, 4, 6 and 12 among gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n. | instruction | 0 | 74,712 | 22 | 149,424 |
Tags: constructive algorithms, math
Correct Solution:
```
from math import gcd
m=int(input())
s=sorted(list(map(int,input().split())))
a=0
for e in s:a=gcd(a,e)
if(a!=s[0]):
print(-1)
else:
print(2*m-1)
v=[0]*(2*m-1)
for i in range(2*m-1):
if(i%2==0):
v[i]=s[i//2]
else: v[i]=a
print(*v)
``` | output | 1 | 74,712 | 22 | 149,425 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a dream Marco met an elderly man with a pair of black glasses. The man told him the key to immortality and then disappeared with the wind of time.
When he woke up, he only remembered that the key was a sequence of positive integers of some length n, but forgot the exact sequence. Let the elements of the sequence be a1, a2, ..., an. He remembered that he calculated gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n and put it into a set S. gcd here means the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor).
Note that even if a number is put into the set S twice or more, it only appears once in the set.
Now Marco gives you the set S and asks you to help him figure out the initial sequence. If there are many solutions, print any of them. It is also possible that there are no sequences that produce the set S, in this case print -1.
Input
The first line contains a single integer m (1 ≤ m ≤ 1000) — the size of the set S.
The second line contains m integers s1, s2, ..., sm (1 ≤ si ≤ 106) — the elements of the set S. It's guaranteed that the elements of the set are given in strictly increasing order, that means s1 < s2 < ... < sm.
Output
If there is no solution, print a single line containing -1.
Otherwise, in the first line print a single integer n denoting the length of the sequence, n should not exceed 4000.
In the second line print n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the sequence.
We can show that if a solution exists, then there is a solution with n not exceeding 4000 and ai not exceeding 106.
If there are multiple solutions, print any of them.
Examples
Input
4
2 4 6 12
Output
3
4 6 12
Input
2
2 3
Output
-1
Note
In the first example 2 = gcd(4, 6), the other elements from the set appear in the sequence, and we can show that there are no values different from 2, 4, 6 and 12 among gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n. | instruction | 0 | 74,713 | 22 | 149,426 |
Tags: constructive algorithms, math
Correct Solution:
```
n = int(input())
s = input().split()
i = list(map(int, s))
if all(map(lambda x: x % i[0] == 0, i)):
ans = str(2 * n - 1) + "\n"
ans += (" " + s[0] + " ").join(s)
else:
ans = -1
print(ans)
``` | output | 1 | 74,713 | 22 | 149,427 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a dream Marco met an elderly man with a pair of black glasses. The man told him the key to immortality and then disappeared with the wind of time.
When he woke up, he only remembered that the key was a sequence of positive integers of some length n, but forgot the exact sequence. Let the elements of the sequence be a1, a2, ..., an. He remembered that he calculated gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n and put it into a set S. gcd here means the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor).
Note that even if a number is put into the set S twice or more, it only appears once in the set.
Now Marco gives you the set S and asks you to help him figure out the initial sequence. If there are many solutions, print any of them. It is also possible that there are no sequences that produce the set S, in this case print -1.
Input
The first line contains a single integer m (1 ≤ m ≤ 1000) — the size of the set S.
The second line contains m integers s1, s2, ..., sm (1 ≤ si ≤ 106) — the elements of the set S. It's guaranteed that the elements of the set are given in strictly increasing order, that means s1 < s2 < ... < sm.
Output
If there is no solution, print a single line containing -1.
Otherwise, in the first line print a single integer n denoting the length of the sequence, n should not exceed 4000.
In the second line print n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the sequence.
We can show that if a solution exists, then there is a solution with n not exceeding 4000 and ai not exceeding 106.
If there are multiple solutions, print any of them.
Examples
Input
4
2 4 6 12
Output
3
4 6 12
Input
2
2 3
Output
-1
Note
In the first example 2 = gcd(4, 6), the other elements from the set appear in the sequence, and we can show that there are no values different from 2, 4, 6 and 12 among gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n.
Submitted Solution:
```
from fractions import gcd
n = int(input())
a = [int(z) for z in input().split()]
g = 0
for i in range(n):
g = gcd(g, a[i])
if a[0] != g:
print(-1)
exit(0)
print(2 * n)
for i in range(n):
print(g, a[i], end=" ")
``` | instruction | 0 | 74,714 | 22 | 149,428 |
Yes | output | 1 | 74,714 | 22 | 149,429 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a dream Marco met an elderly man with a pair of black glasses. The man told him the key to immortality and then disappeared with the wind of time.
When he woke up, he only remembered that the key was a sequence of positive integers of some length n, but forgot the exact sequence. Let the elements of the sequence be a1, a2, ..., an. He remembered that he calculated gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n and put it into a set S. gcd here means the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor).
Note that even if a number is put into the set S twice or more, it only appears once in the set.
Now Marco gives you the set S and asks you to help him figure out the initial sequence. If there are many solutions, print any of them. It is also possible that there are no sequences that produce the set S, in this case print -1.
Input
The first line contains a single integer m (1 ≤ m ≤ 1000) — the size of the set S.
The second line contains m integers s1, s2, ..., sm (1 ≤ si ≤ 106) — the elements of the set S. It's guaranteed that the elements of the set are given in strictly increasing order, that means s1 < s2 < ... < sm.
Output
If there is no solution, print a single line containing -1.
Otherwise, in the first line print a single integer n denoting the length of the sequence, n should not exceed 4000.
In the second line print n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the sequence.
We can show that if a solution exists, then there is a solution with n not exceeding 4000 and ai not exceeding 106.
If there are multiple solutions, print any of them.
Examples
Input
4
2 4 6 12
Output
3
4 6 12
Input
2
2 3
Output
-1
Note
In the first example 2 = gcd(4, 6), the other elements from the set appear in the sequence, and we can show that there are no values different from 2, 4, 6 and 12 among gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n.
Submitted Solution:
```
m = int(input())
set = list(map(int, input().split()))
flag = True
if m == 1:
print(1)
print(set[0])
flag = False
for s in set:
if s % set[0] != 0:
print(-1)
flag = False
break
if flag:
list = []
for i in set[1:]:
list.append(set[0])
list.append(i)
print(len(list))
for i, n in enumerate(list):
if i != len(list) - 1:
print(n, end=' ')
else:
print(n)
``` | instruction | 0 | 74,715 | 22 | 149,430 |
Yes | output | 1 | 74,715 | 22 | 149,431 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a dream Marco met an elderly man with a pair of black glasses. The man told him the key to immortality and then disappeared with the wind of time.
When he woke up, he only remembered that the key was a sequence of positive integers of some length n, but forgot the exact sequence. Let the elements of the sequence be a1, a2, ..., an. He remembered that he calculated gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n and put it into a set S. gcd here means the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor).
Note that even if a number is put into the set S twice or more, it only appears once in the set.
Now Marco gives you the set S and asks you to help him figure out the initial sequence. If there are many solutions, print any of them. It is also possible that there are no sequences that produce the set S, in this case print -1.
Input
The first line contains a single integer m (1 ≤ m ≤ 1000) — the size of the set S.
The second line contains m integers s1, s2, ..., sm (1 ≤ si ≤ 106) — the elements of the set S. It's guaranteed that the elements of the set are given in strictly increasing order, that means s1 < s2 < ... < sm.
Output
If there is no solution, print a single line containing -1.
Otherwise, in the first line print a single integer n denoting the length of the sequence, n should not exceed 4000.
In the second line print n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the sequence.
We can show that if a solution exists, then there is a solution with n not exceeding 4000 and ai not exceeding 106.
If there are multiple solutions, print any of them.
Examples
Input
4
2 4 6 12
Output
3
4 6 12
Input
2
2 3
Output
-1
Note
In the first example 2 = gcd(4, 6), the other elements from the set appear in the sequence, and we can show that there are no values different from 2, 4, 6 and 12 among gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n.
Submitted Solution:
```
'''
Hey why peeping here -_'_- ?
I believe on myself and I will achieve
this->author = Fuad Ashraful Mehmet, CSE ,University of Asia Pacific
https://www.youtube.com/watch?v=2fqiOX7WugE&ab_channel=FolkStudioBangla
'''
import sys
input=sys.stdin.readline
R=lambda:map(int,input().split())
I=lambda:int(input())
S=lambda:input().rstrip('\n')
L=lambda:list(R())
class Div2_447_C:
def __init__(self):
self.m=I()
self.s=L()
self.ans=[]
def solve(self):
#print(self.s)
g=self.s[0]
for x in self.s:
if x%g:
print(-1)
return
self.ans+=[x,g]
print(len(self.ans))
print(*self.ans)
return
if __name__=="__main__":
obj=Div2_447_C()
obj.solve()
``` | instruction | 0 | 74,716 | 22 | 149,432 |
Yes | output | 1 | 74,716 | 22 | 149,433 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a dream Marco met an elderly man with a pair of black glasses. The man told him the key to immortality and then disappeared with the wind of time.
When he woke up, he only remembered that the key was a sequence of positive integers of some length n, but forgot the exact sequence. Let the elements of the sequence be a1, a2, ..., an. He remembered that he calculated gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n and put it into a set S. gcd here means the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor).
Note that even if a number is put into the set S twice or more, it only appears once in the set.
Now Marco gives you the set S and asks you to help him figure out the initial sequence. If there are many solutions, print any of them. It is also possible that there are no sequences that produce the set S, in this case print -1.
Input
The first line contains a single integer m (1 ≤ m ≤ 1000) — the size of the set S.
The second line contains m integers s1, s2, ..., sm (1 ≤ si ≤ 106) — the elements of the set S. It's guaranteed that the elements of the set are given in strictly increasing order, that means s1 < s2 < ... < sm.
Output
If there is no solution, print a single line containing -1.
Otherwise, in the first line print a single integer n denoting the length of the sequence, n should not exceed 4000.
In the second line print n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the sequence.
We can show that if a solution exists, then there is a solution with n not exceeding 4000 and ai not exceeding 106.
If there are multiple solutions, print any of them.
Examples
Input
4
2 4 6 12
Output
3
4 6 12
Input
2
2 3
Output
-1
Note
In the first example 2 = gcd(4, 6), the other elements from the set appear in the sequence, and we can show that there are no values different from 2, 4, 6 and 12 among gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n.
Submitted Solution:
```
from functools import reduce
n = int(input())
arr = list(map(int, input().split()))
def gcd(a, b):
if a > b: a, b = b, a
if (b % a == 0): return a
return gcd(a, b % a)
g = reduce(gcd, arr)
if g != min(arr):
print(-1)
else:
ans = []
for elt in arr:
ans.append(g)
ans.append(elt)
print(len(ans))
print(" ".join(list(map(str, ans))))
``` | instruction | 0 | 74,717 | 22 | 149,434 |
Yes | output | 1 | 74,717 | 22 | 149,435 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a dream Marco met an elderly man with a pair of black glasses. The man told him the key to immortality and then disappeared with the wind of time.
When he woke up, he only remembered that the key was a sequence of positive integers of some length n, but forgot the exact sequence. Let the elements of the sequence be a1, a2, ..., an. He remembered that he calculated gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n and put it into a set S. gcd here means the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor).
Note that even if a number is put into the set S twice or more, it only appears once in the set.
Now Marco gives you the set S and asks you to help him figure out the initial sequence. If there are many solutions, print any of them. It is also possible that there are no sequences that produce the set S, in this case print -1.
Input
The first line contains a single integer m (1 ≤ m ≤ 1000) — the size of the set S.
The second line contains m integers s1, s2, ..., sm (1 ≤ si ≤ 106) — the elements of the set S. It's guaranteed that the elements of the set are given in strictly increasing order, that means s1 < s2 < ... < sm.
Output
If there is no solution, print a single line containing -1.
Otherwise, in the first line print a single integer n denoting the length of the sequence, n should not exceed 4000.
In the second line print n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the sequence.
We can show that if a solution exists, then there is a solution with n not exceeding 4000 and ai not exceeding 106.
If there are multiple solutions, print any of them.
Examples
Input
4
2 4 6 12
Output
3
4 6 12
Input
2
2 3
Output
-1
Note
In the first example 2 = gcd(4, 6), the other elements from the set appear in the sequence, and we can show that there are no values different from 2, 4, 6 and 12 among gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n.
Submitted Solution:
```
n=int(input())
a=list(map(int,input().split()))
cur=a[-1]
from math import gcd
for i in range(1,n-1):
cur=gcd(cur,a[i])
if cur !=a[0]:
print(-1)
else:
print(2*n)
for i in a:
print(i,a[0],end=' ')
``` | instruction | 0 | 74,718 | 22 | 149,436 |
No | output | 1 | 74,718 | 22 | 149,437 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a dream Marco met an elderly man with a pair of black glasses. The man told him the key to immortality and then disappeared with the wind of time.
When he woke up, he only remembered that the key was a sequence of positive integers of some length n, but forgot the exact sequence. Let the elements of the sequence be a1, a2, ..., an. He remembered that he calculated gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n and put it into a set S. gcd here means the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor).
Note that even if a number is put into the set S twice or more, it only appears once in the set.
Now Marco gives you the set S and asks you to help him figure out the initial sequence. If there are many solutions, print any of them. It is also possible that there are no sequences that produce the set S, in this case print -1.
Input
The first line contains a single integer m (1 ≤ m ≤ 1000) — the size of the set S.
The second line contains m integers s1, s2, ..., sm (1 ≤ si ≤ 106) — the elements of the set S. It's guaranteed that the elements of the set are given in strictly increasing order, that means s1 < s2 < ... < sm.
Output
If there is no solution, print a single line containing -1.
Otherwise, in the first line print a single integer n denoting the length of the sequence, n should not exceed 4000.
In the second line print n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the sequence.
We can show that if a solution exists, then there is a solution with n not exceeding 4000 and ai not exceeding 106.
If there are multiple solutions, print any of them.
Examples
Input
4
2 4 6 12
Output
3
4 6 12
Input
2
2 3
Output
-1
Note
In the first example 2 = gcd(4, 6), the other elements from the set appear in the sequence, and we can show that there are no values different from 2, 4, 6 and 12 among gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n.
Submitted Solution:
```
m = int(input())
A = input().split()
A = [int(i) for i in A]
def ans(A):
final = []
for i in range (1,m):
final = final + [A[i]] + [A[0]]
if A[i]%A[0] != 0:
return (-1)
break
final = [str(i) for i in final]
return (" ".join(final))
print (ans(A))
``` | instruction | 0 | 74,719 | 22 | 149,438 |
No | output | 1 | 74,719 | 22 | 149,439 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a dream Marco met an elderly man with a pair of black glasses. The man told him the key to immortality and then disappeared with the wind of time.
When he woke up, he only remembered that the key was a sequence of positive integers of some length n, but forgot the exact sequence. Let the elements of the sequence be a1, a2, ..., an. He remembered that he calculated gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n and put it into a set S. gcd here means the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor).
Note that even if a number is put into the set S twice or more, it only appears once in the set.
Now Marco gives you the set S and asks you to help him figure out the initial sequence. If there are many solutions, print any of them. It is also possible that there are no sequences that produce the set S, in this case print -1.
Input
The first line contains a single integer m (1 ≤ m ≤ 1000) — the size of the set S.
The second line contains m integers s1, s2, ..., sm (1 ≤ si ≤ 106) — the elements of the set S. It's guaranteed that the elements of the set are given in strictly increasing order, that means s1 < s2 < ... < sm.
Output
If there is no solution, print a single line containing -1.
Otherwise, in the first line print a single integer n denoting the length of the sequence, n should not exceed 4000.
In the second line print n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the sequence.
We can show that if a solution exists, then there is a solution with n not exceeding 4000 and ai not exceeding 106.
If there are multiple solutions, print any of them.
Examples
Input
4
2 4 6 12
Output
3
4 6 12
Input
2
2 3
Output
-1
Note
In the first example 2 = gcd(4, 6), the other elements from the set appear in the sequence, and we can show that there are no values different from 2, 4, 6 and 12 among gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n.
Submitted Solution:
```
def main():
m = int(input())
a = list(map(int, input().split()))
for i in range(1, m):
if a[i] % a[0] != 0:
print(-1)
exit()
print(2*m - 2)
print(a[0], end = ' ')
for i in range(1, m):
print(a[i], a[0], end = ' ')
main()
``` | instruction | 0 | 74,720 | 22 | 149,440 |
No | output | 1 | 74,720 | 22 | 149,441 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a dream Marco met an elderly man with a pair of black glasses. The man told him the key to immortality and then disappeared with the wind of time.
When he woke up, he only remembered that the key was a sequence of positive integers of some length n, but forgot the exact sequence. Let the elements of the sequence be a1, a2, ..., an. He remembered that he calculated gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n and put it into a set S. gcd here means the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor).
Note that even if a number is put into the set S twice or more, it only appears once in the set.
Now Marco gives you the set S and asks you to help him figure out the initial sequence. If there are many solutions, print any of them. It is also possible that there are no sequences that produce the set S, in this case print -1.
Input
The first line contains a single integer m (1 ≤ m ≤ 1000) — the size of the set S.
The second line contains m integers s1, s2, ..., sm (1 ≤ si ≤ 106) — the elements of the set S. It's guaranteed that the elements of the set are given in strictly increasing order, that means s1 < s2 < ... < sm.
Output
If there is no solution, print a single line containing -1.
Otherwise, in the first line print a single integer n denoting the length of the sequence, n should not exceed 4000.
In the second line print n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the sequence.
We can show that if a solution exists, then there is a solution with n not exceeding 4000 and ai not exceeding 106.
If there are multiple solutions, print any of them.
Examples
Input
4
2 4 6 12
Output
3
4 6 12
Input
2
2 3
Output
-1
Note
In the first example 2 = gcd(4, 6), the other elements from the set appear in the sequence, and we can show that there are no values different from 2, 4, 6 and 12 among gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n.
Submitted Solution:
```
from fractions import gcd
n = int(input())
A =list(map(int,input().split()))
ans = [A[-1]]
visited = set(A)
anse = set()
anse.add(A[-1])
for j in range(n-2,-1,-1):
ro = 1
if A[j] not in anse:
cur = gcd(A[j],ans[0])
if cur in visited:
for l in range(1,len(ans)):
cur = gcd(cur,A[l])
if cur not in visited:
ro = 0
break
if ro == 1:
anse.add(A[j])
cur = gcd(A[j],ans[0])
anse.add(cur)
for l in range(1,len(ans)):
cur = gcd(cur,A[l])
anse.add(cur)
ans.append(A[j])
if visited == anse:
print(len(ans))
print(' '.join(map(str,ans)))
else:
print(-1)
``` | instruction | 0 | 74,721 | 22 | 149,442 |
No | output | 1 | 74,721 | 22 | 149,443 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nastia has 2 positive integers A and B. She defines that:
* The integer is good if it is divisible by A ⋅ B;
* Otherwise, the integer is nearly good, if it is divisible by A.
For example, if A = 6 and B = 4, the integers 24 and 72 are good, the integers 6, 660 and 12 are nearly good, the integers 16, 7 are neither good nor nearly good.
Find 3 different positive integers x, y, and z such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
Input
The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line of each test case contains two integers A and B (1 ≤ A ≤ 10^6, 1 ≤ B ≤ 10^6) — numbers that Nastia has.
Output
For each test case print:
* "YES" and 3 different positive integers x, y, and z (1 ≤ x, y, z ≤ 10^{18}) such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
* "NO" if no answer exists.
You can print each character of "YES" or "NO" in any case.
If there are multiple answers, print any.
Example
Input
3
5 3
13 2
7 11
Output
YES
10 50 60
YES
169 39 208
YES
28 154 182
Note
In the first test case: 60 — good number; 10 and 50 — nearly good numbers.
In the second test case: 208 — good number; 169 and 39 — nearly good numbers.
In the third test case: 154 — good number; 28 and 182 — nearly good numbers. | instruction | 0 | 75,271 | 22 | 150,542 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
"""
inp_start
3
5 3
13 2
7 11
inp_end
"""
tcs = int(input())
for tc in range(tcs):
x, y = list(map(int, input().split()))
if y==1:
print("NO")
continue
print("YES")
a, b, c = 1, y-1, 1
if y==2:
a, b, c = 1, 3, 2
print(x*a, x*b, x*y*c)
``` | output | 1 | 75,271 | 22 | 150,543 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nastia has 2 positive integers A and B. She defines that:
* The integer is good if it is divisible by A ⋅ B;
* Otherwise, the integer is nearly good, if it is divisible by A.
For example, if A = 6 and B = 4, the integers 24 and 72 are good, the integers 6, 660 and 12 are nearly good, the integers 16, 7 are neither good nor nearly good.
Find 3 different positive integers x, y, and z such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
Input
The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line of each test case contains two integers A and B (1 ≤ A ≤ 10^6, 1 ≤ B ≤ 10^6) — numbers that Nastia has.
Output
For each test case print:
* "YES" and 3 different positive integers x, y, and z (1 ≤ x, y, z ≤ 10^{18}) such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
* "NO" if no answer exists.
You can print each character of "YES" or "NO" in any case.
If there are multiple answers, print any.
Example
Input
3
5 3
13 2
7 11
Output
YES
10 50 60
YES
169 39 208
YES
28 154 182
Note
In the first test case: 60 — good number; 10 and 50 — nearly good numbers.
In the second test case: 208 — good number; 169 and 39 — nearly good numbers.
In the third test case: 154 — good number; 28 and 182 — nearly good numbers. | instruction | 0 | 75,272 | 22 | 150,544 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
t = int(input())
for _ in range(t):
a,b = map(int,input().split())
if b == 1:
print("NO")
continue
if b==2:
b = 4
tmp = a*b
print("YES")
tmp1 = a
tmp2 = a*(b-1)
print(tmp1,tmp2,tmp)
``` | output | 1 | 75,272 | 22 | 150,545 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nastia has 2 positive integers A and B. She defines that:
* The integer is good if it is divisible by A ⋅ B;
* Otherwise, the integer is nearly good, if it is divisible by A.
For example, if A = 6 and B = 4, the integers 24 and 72 are good, the integers 6, 660 and 12 are nearly good, the integers 16, 7 are neither good nor nearly good.
Find 3 different positive integers x, y, and z such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
Input
The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line of each test case contains two integers A and B (1 ≤ A ≤ 10^6, 1 ≤ B ≤ 10^6) — numbers that Nastia has.
Output
For each test case print:
* "YES" and 3 different positive integers x, y, and z (1 ≤ x, y, z ≤ 10^{18}) such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
* "NO" if no answer exists.
You can print each character of "YES" or "NO" in any case.
If there are multiple answers, print any.
Example
Input
3
5 3
13 2
7 11
Output
YES
10 50 60
YES
169 39 208
YES
28 154 182
Note
In the first test case: 60 — good number; 10 and 50 — nearly good numbers.
In the second test case: 208 — good number; 169 and 39 — nearly good numbers.
In the third test case: 154 — good number; 28 and 182 — nearly good numbers. | instruction | 0 | 75,273 | 22 | 150,546 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
t=int(input())
for i in range(t):
a,b=map(int,input().split())
x=0
y=0
z=0
if b==1:
print('NO')
else:
x=a
y=a*b
z=x+y
print("YES")
print(x,y,z)
``` | output | 1 | 75,273 | 22 | 150,547 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nastia has 2 positive integers A and B. She defines that:
* The integer is good if it is divisible by A ⋅ B;
* Otherwise, the integer is nearly good, if it is divisible by A.
For example, if A = 6 and B = 4, the integers 24 and 72 are good, the integers 6, 660 and 12 are nearly good, the integers 16, 7 are neither good nor nearly good.
Find 3 different positive integers x, y, and z such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
Input
The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line of each test case contains two integers A and B (1 ≤ A ≤ 10^6, 1 ≤ B ≤ 10^6) — numbers that Nastia has.
Output
For each test case print:
* "YES" and 3 different positive integers x, y, and z (1 ≤ x, y, z ≤ 10^{18}) such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
* "NO" if no answer exists.
You can print each character of "YES" or "NO" in any case.
If there are multiple answers, print any.
Example
Input
3
5 3
13 2
7 11
Output
YES
10 50 60
YES
169 39 208
YES
28 154 182
Note
In the first test case: 60 — good number; 10 and 50 — nearly good numbers.
In the second test case: 208 — good number; 169 and 39 — nearly good numbers.
In the third test case: 154 — good number; 28 and 182 — nearly good numbers. | instruction | 0 | 75,274 | 22 | 150,548 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
import sys
import time
import itertools
import math
def inp():
ln = input().split()
return int(ln[0]) if len(ln) == 1 else [int(i) for i in ln]
def prl(x):
print(' '.join([str(i) for i in x]))
# Problem A
testcases = inp()
for testcase in range (testcases):
a,b = inp()
if b==1: print("NO")
else:
print("YES")
print(a,a*(b-1)+a*b,2*a*b)
# Problem B
# testcases = inp()
#
# for testcase in range (testcases):
#
# Problem C
# testcases = inp()
#
# for testcase in range (testcases):
#
# Problem D
# testcases = inp()
#
# for testcase in range (testcases):
#
# Problem E
# testcases = inp()
#
# for testcase in range (testcases):
#
``` | output | 1 | 75,274 | 22 | 150,549 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nastia has 2 positive integers A and B. She defines that:
* The integer is good if it is divisible by A ⋅ B;
* Otherwise, the integer is nearly good, if it is divisible by A.
For example, if A = 6 and B = 4, the integers 24 and 72 are good, the integers 6, 660 and 12 are nearly good, the integers 16, 7 are neither good nor nearly good.
Find 3 different positive integers x, y, and z such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
Input
The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line of each test case contains two integers A and B (1 ≤ A ≤ 10^6, 1 ≤ B ≤ 10^6) — numbers that Nastia has.
Output
For each test case print:
* "YES" and 3 different positive integers x, y, and z (1 ≤ x, y, z ≤ 10^{18}) such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
* "NO" if no answer exists.
You can print each character of "YES" or "NO" in any case.
If there are multiple answers, print any.
Example
Input
3
5 3
13 2
7 11
Output
YES
10 50 60
YES
169 39 208
YES
28 154 182
Note
In the first test case: 60 — good number; 10 and 50 — nearly good numbers.
In the second test case: 208 — good number; 169 and 39 — nearly good numbers.
In the third test case: 154 — good number; 28 and 182 — nearly good numbers. | instruction | 0 | 75,275 | 22 | 150,550 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
import math
for _ in range(int(input())):
n,m=map(int,input().split())
ans=n*m
ans1=n*(m-1)
ans2=n*1
if ans1+ans2==ans and ans1>0 and ans2>0 and ans>0:
if ans1==ans2:
print("YES")
print(ans1*3,ans2*1,ans*2)
else:
print("YES")
print(ans1,ans2,ans)
else:
print("NO")
``` | output | 1 | 75,275 | 22 | 150,551 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nastia has 2 positive integers A and B. She defines that:
* The integer is good if it is divisible by A ⋅ B;
* Otherwise, the integer is nearly good, if it is divisible by A.
For example, if A = 6 and B = 4, the integers 24 and 72 are good, the integers 6, 660 and 12 are nearly good, the integers 16, 7 are neither good nor nearly good.
Find 3 different positive integers x, y, and z such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
Input
The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line of each test case contains two integers A and B (1 ≤ A ≤ 10^6, 1 ≤ B ≤ 10^6) — numbers that Nastia has.
Output
For each test case print:
* "YES" and 3 different positive integers x, y, and z (1 ≤ x, y, z ≤ 10^{18}) such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
* "NO" if no answer exists.
You can print each character of "YES" or "NO" in any case.
If there are multiple answers, print any.
Example
Input
3
5 3
13 2
7 11
Output
YES
10 50 60
YES
169 39 208
YES
28 154 182
Note
In the first test case: 60 — good number; 10 and 50 — nearly good numbers.
In the second test case: 208 — good number; 169 and 39 — nearly good numbers.
In the third test case: 154 — good number; 28 and 182 — nearly good numbers. | instruction | 0 | 75,276 | 22 | 150,552 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
for _ in range(int(input())):
A, B = map(int, input().split())
if B == 1:
print('NO')
else:
print('YES')
print(A, A*B, A*(B+1))
``` | output | 1 | 75,276 | 22 | 150,553 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nastia has 2 positive integers A and B. She defines that:
* The integer is good if it is divisible by A ⋅ B;
* Otherwise, the integer is nearly good, if it is divisible by A.
For example, if A = 6 and B = 4, the integers 24 and 72 are good, the integers 6, 660 and 12 are nearly good, the integers 16, 7 are neither good nor nearly good.
Find 3 different positive integers x, y, and z such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
Input
The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line of each test case contains two integers A and B (1 ≤ A ≤ 10^6, 1 ≤ B ≤ 10^6) — numbers that Nastia has.
Output
For each test case print:
* "YES" and 3 different positive integers x, y, and z (1 ≤ x, y, z ≤ 10^{18}) such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
* "NO" if no answer exists.
You can print each character of "YES" or "NO" in any case.
If there are multiple answers, print any.
Example
Input
3
5 3
13 2
7 11
Output
YES
10 50 60
YES
169 39 208
YES
28 154 182
Note
In the first test case: 60 — good number; 10 and 50 — nearly good numbers.
In the second test case: 208 — good number; 169 and 39 — nearly good numbers.
In the third test case: 154 — good number; 28 and 182 — nearly good numbers. | instruction | 0 | 75,277 | 22 | 150,554 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
import heapq,math
from collections import defaultdict,deque
import sys, os.path
#sys.setrecursionlimit(1000000)
if(os.path.exists('C:/Users/Dhanush/Desktop/cp/input.txt')):
sys.stdout = open('C:/Users/Dhanush/Desktop/cp/output.txt', 'w')
sys.stdin = open('C:/Users/Dhanush/Desktop/cp/input.txt', 'r')
input=sys.stdin.readline
maxi=10**18
t=int(input())
for _ in range(t):
a,b=map(int,input().split())
if(b==1):
print('NO')
else:
c1=a
c2=(b-1)*a
c3=a*b
if(c1==c2 or c2==c3 or c1==c3 or c1%(a*b)==0 or c2%(a*b)==0):
z=2
f=0
while(1):
x=1
y=z*b-1
c1=a
c2=y*a
c3=z*a*b
if(c2>maxi or c3>maxi):
break
if(c1!=c2 and c2!=c3 and c1!=c3 and c2%(a*b)!=0):
f=1
print('YES')
print(c1,c2,c3)
break
z+=1
if(f==0):
print('NO')
else:
print('YES')
print(c1,c2,c3)
``` | output | 1 | 75,277 | 22 | 150,555 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nastia has 2 positive integers A and B. She defines that:
* The integer is good if it is divisible by A ⋅ B;
* Otherwise, the integer is nearly good, if it is divisible by A.
For example, if A = 6 and B = 4, the integers 24 and 72 are good, the integers 6, 660 and 12 are nearly good, the integers 16, 7 are neither good nor nearly good.
Find 3 different positive integers x, y, and z such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
Input
The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line of each test case contains two integers A and B (1 ≤ A ≤ 10^6, 1 ≤ B ≤ 10^6) — numbers that Nastia has.
Output
For each test case print:
* "YES" and 3 different positive integers x, y, and z (1 ≤ x, y, z ≤ 10^{18}) such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
* "NO" if no answer exists.
You can print each character of "YES" or "NO" in any case.
If there are multiple answers, print any.
Example
Input
3
5 3
13 2
7 11
Output
YES
10 50 60
YES
169 39 208
YES
28 154 182
Note
In the first test case: 60 — good number; 10 and 50 — nearly good numbers.
In the second test case: 208 — good number; 169 and 39 — nearly good numbers.
In the third test case: 154 — good number; 28 and 182 — nearly good numbers. | instruction | 0 | 75,278 | 22 | 150,556 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
for nt in range(int(input())):
A,B = map(int,input().split())
if B == 1:
print("NO")
continue
print("YES")
print(A*(B-1),A*(B+1),2*A*B)
``` | output | 1 | 75,278 | 22 | 150,557 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nastia has 2 positive integers A and B. She defines that:
* The integer is good if it is divisible by A ⋅ B;
* Otherwise, the integer is nearly good, if it is divisible by A.
For example, if A = 6 and B = 4, the integers 24 and 72 are good, the integers 6, 660 and 12 are nearly good, the integers 16, 7 are neither good nor nearly good.
Find 3 different positive integers x, y, and z such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
Input
The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line of each test case contains two integers A and B (1 ≤ A ≤ 10^6, 1 ≤ B ≤ 10^6) — numbers that Nastia has.
Output
For each test case print:
* "YES" and 3 different positive integers x, y, and z (1 ≤ x, y, z ≤ 10^{18}) such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
* "NO" if no answer exists.
You can print each character of "YES" or "NO" in any case.
If there are multiple answers, print any.
Example
Input
3
5 3
13 2
7 11
Output
YES
10 50 60
YES
169 39 208
YES
28 154 182
Note
In the first test case: 60 — good number; 10 and 50 — nearly good numbers.
In the second test case: 208 — good number; 169 and 39 — nearly good numbers.
In the third test case: 154 — good number; 28 and 182 — nearly good numbers.
Submitted Solution:
```
import sys
import math
input = sys.stdin.readline
def main():
t = int(input())
for _ in range(t):
A, B = [int(x) for x in input().split()]
if B == 1:
print("NO")
continue
x = A
z = B * A
if B == 2:
z *= 2
y = z - x
print("YES")
print(x, y, z)
if __name__ == '__main__':
main()
``` | instruction | 0 | 75,279 | 22 | 150,558 |
Yes | output | 1 | 75,279 | 22 | 150,559 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nastia has 2 positive integers A and B. She defines that:
* The integer is good if it is divisible by A ⋅ B;
* Otherwise, the integer is nearly good, if it is divisible by A.
For example, if A = 6 and B = 4, the integers 24 and 72 are good, the integers 6, 660 and 12 are nearly good, the integers 16, 7 are neither good nor nearly good.
Find 3 different positive integers x, y, and z such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
Input
The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line of each test case contains two integers A and B (1 ≤ A ≤ 10^6, 1 ≤ B ≤ 10^6) — numbers that Nastia has.
Output
For each test case print:
* "YES" and 3 different positive integers x, y, and z (1 ≤ x, y, z ≤ 10^{18}) such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
* "NO" if no answer exists.
You can print each character of "YES" or "NO" in any case.
If there are multiple answers, print any.
Example
Input
3
5 3
13 2
7 11
Output
YES
10 50 60
YES
169 39 208
YES
28 154 182
Note
In the first test case: 60 — good number; 10 and 50 — nearly good numbers.
In the second test case: 208 — good number; 169 and 39 — nearly good numbers.
In the third test case: 154 — good number; 28 and 182 — nearly good numbers.
Submitted Solution:
```
import sys
input = sys.stdin.readline
t=int(input())
for tests in range(t):
A,B=map(int,input().split())
ANS=[A*(B-1),A*(B+1),2*A*B]
if (A*(B-1))%(A*B)==0 or (A*(B+1))%(A*B)==0 :
print("NO")
else:
print("YES")
print(*ANS)
``` | instruction | 0 | 75,280 | 22 | 150,560 |
Yes | output | 1 | 75,280 | 22 | 150,561 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nastia has 2 positive integers A and B. She defines that:
* The integer is good if it is divisible by A ⋅ B;
* Otherwise, the integer is nearly good, if it is divisible by A.
For example, if A = 6 and B = 4, the integers 24 and 72 are good, the integers 6, 660 and 12 are nearly good, the integers 16, 7 are neither good nor nearly good.
Find 3 different positive integers x, y, and z such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
Input
The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line of each test case contains two integers A and B (1 ≤ A ≤ 10^6, 1 ≤ B ≤ 10^6) — numbers that Nastia has.
Output
For each test case print:
* "YES" and 3 different positive integers x, y, and z (1 ≤ x, y, z ≤ 10^{18}) such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
* "NO" if no answer exists.
You can print each character of "YES" or "NO" in any case.
If there are multiple answers, print any.
Example
Input
3
5 3
13 2
7 11
Output
YES
10 50 60
YES
169 39 208
YES
28 154 182
Note
In the first test case: 60 — good number; 10 and 50 — nearly good numbers.
In the second test case: 208 — good number; 169 and 39 — nearly good numbers.
In the third test case: 154 — good number; 28 and 182 — nearly good numbers.
Submitted Solution:
```
for _ in range(int(input())):
n , k = map(int , input().split())
z = n * k
if(k == 1):
print("NO")
else:
print("YES")
if(k == 2):
print(n , 3*n , 4 *n)
else:
print(n , n*(k-1) ,n*k)
``` | instruction | 0 | 75,281 | 22 | 150,562 |
Yes | output | 1 | 75,281 | 22 | 150,563 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nastia has 2 positive integers A and B. She defines that:
* The integer is good if it is divisible by A ⋅ B;
* Otherwise, the integer is nearly good, if it is divisible by A.
For example, if A = 6 and B = 4, the integers 24 and 72 are good, the integers 6, 660 and 12 are nearly good, the integers 16, 7 are neither good nor nearly good.
Find 3 different positive integers x, y, and z such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
Input
The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line of each test case contains two integers A and B (1 ≤ A ≤ 10^6, 1 ≤ B ≤ 10^6) — numbers that Nastia has.
Output
For each test case print:
* "YES" and 3 different positive integers x, y, and z (1 ≤ x, y, z ≤ 10^{18}) such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
* "NO" if no answer exists.
You can print each character of "YES" or "NO" in any case.
If there are multiple answers, print any.
Example
Input
3
5 3
13 2
7 11
Output
YES
10 50 60
YES
169 39 208
YES
28 154 182
Note
In the first test case: 60 — good number; 10 and 50 — nearly good numbers.
In the second test case: 208 — good number; 169 and 39 — nearly good numbers.
In the third test case: 154 — good number; 28 and 182 — nearly good numbers.
Submitted Solution:
```
for _ in range(int(input())):
a,b=map(int,input().split())
if b==1: print("NO")
else:print("YES");print(a*b,a,a*(b+1))
``` | instruction | 0 | 75,282 | 22 | 150,564 |
Yes | output | 1 | 75,282 | 22 | 150,565 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nastia has 2 positive integers A and B. She defines that:
* The integer is good if it is divisible by A ⋅ B;
* Otherwise, the integer is nearly good, if it is divisible by A.
For example, if A = 6 and B = 4, the integers 24 and 72 are good, the integers 6, 660 and 12 are nearly good, the integers 16, 7 are neither good nor nearly good.
Find 3 different positive integers x, y, and z such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
Input
The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line of each test case contains two integers A and B (1 ≤ A ≤ 10^6, 1 ≤ B ≤ 10^6) — numbers that Nastia has.
Output
For each test case print:
* "YES" and 3 different positive integers x, y, and z (1 ≤ x, y, z ≤ 10^{18}) such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
* "NO" if no answer exists.
You can print each character of "YES" or "NO" in any case.
If there are multiple answers, print any.
Example
Input
3
5 3
13 2
7 11
Output
YES
10 50 60
YES
169 39 208
YES
28 154 182
Note
In the first test case: 60 — good number; 10 and 50 — nearly good numbers.
In the second test case: 208 — good number; 169 and 39 — nearly good numbers.
In the third test case: 154 — good number; 28 and 182 — nearly good numbers.
Submitted Solution:
```
from math import ceil
def slv(a,b):
if a % b == 0:
print('NO')
return
print('YES')
print(a, a*(2*b-1), 2*a*b)
t = int(input())
for _ in range(t):
a,b = map(int, input().split())
slv(a,b)
``` | instruction | 0 | 75,283 | 22 | 150,566 |
No | output | 1 | 75,283 | 22 | 150,567 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nastia has 2 positive integers A and B. She defines that:
* The integer is good if it is divisible by A ⋅ B;
* Otherwise, the integer is nearly good, if it is divisible by A.
For example, if A = 6 and B = 4, the integers 24 and 72 are good, the integers 6, 660 and 12 are nearly good, the integers 16, 7 are neither good nor nearly good.
Find 3 different positive integers x, y, and z such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
Input
The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line of each test case contains two integers A and B (1 ≤ A ≤ 10^6, 1 ≤ B ≤ 10^6) — numbers that Nastia has.
Output
For each test case print:
* "YES" and 3 different positive integers x, y, and z (1 ≤ x, y, z ≤ 10^{18}) such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
* "NO" if no answer exists.
You can print each character of "YES" or "NO" in any case.
If there are multiple answers, print any.
Example
Input
3
5 3
13 2
7 11
Output
YES
10 50 60
YES
169 39 208
YES
28 154 182
Note
In the first test case: 60 — good number; 10 and 50 — nearly good numbers.
In the second test case: 208 — good number; 169 and 39 — nearly good numbers.
In the third test case: 154 — good number; 28 and 182 — nearly good numbers.
Submitted Solution:
```
from sys import stdin
from collections import defaultdict
def readGenerator():
while True:
tokens = stdin.readline().strip().split(' ')
for t in tokens:
yield t
reader = readGenerator()
def readWord():
return next(reader)
def readInt():
return int(next(reader))
def readFloat():
return float(next(reader))
def readLine():
return input()
def gcd(a, b):
while b:
a, b = b, a % b
return a
def lcm(x, y):
return (x * y) // gcd(x, y)
def solve(a, b):
x = a * b
y = a
z = x - y
i = 2
while z % a != 0 or y % a != 0 or z == y:
x *= i
y += a
z = x - y
print('YES')
print(x, y, z)
t = readInt()
for _ in range(t):
a, b = readInt(), readInt()
solve(a, b)
``` | instruction | 0 | 75,284 | 22 | 150,568 |
No | output | 1 | 75,284 | 22 | 150,569 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nastia has 2 positive integers A and B. She defines that:
* The integer is good if it is divisible by A ⋅ B;
* Otherwise, the integer is nearly good, if it is divisible by A.
For example, if A = 6 and B = 4, the integers 24 and 72 are good, the integers 6, 660 and 12 are nearly good, the integers 16, 7 are neither good nor nearly good.
Find 3 different positive integers x, y, and z such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
Input
The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line of each test case contains two integers A and B (1 ≤ A ≤ 10^6, 1 ≤ B ≤ 10^6) — numbers that Nastia has.
Output
For each test case print:
* "YES" and 3 different positive integers x, y, and z (1 ≤ x, y, z ≤ 10^{18}) such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
* "NO" if no answer exists.
You can print each character of "YES" or "NO" in any case.
If there are multiple answers, print any.
Example
Input
3
5 3
13 2
7 11
Output
YES
10 50 60
YES
169 39 208
YES
28 154 182
Note
In the first test case: 60 — good number; 10 and 50 — nearly good numbers.
In the second test case: 208 — good number; 169 and 39 — nearly good numbers.
In the third test case: 154 — good number; 28 and 182 — nearly good numbers.
Submitted Solution:
```
for i in range(int(input())):
A,B=map(int,input().split())
if B==1:
print("NO")
else:
if A+A*((A*B)//A-1)==A*B:
print("YES")
print(A,A*((A*B)//A-1),A*B)
``` | instruction | 0 | 75,285 | 22 | 150,570 |
No | output | 1 | 75,285 | 22 | 150,571 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nastia has 2 positive integers A and B. She defines that:
* The integer is good if it is divisible by A ⋅ B;
* Otherwise, the integer is nearly good, if it is divisible by A.
For example, if A = 6 and B = 4, the integers 24 and 72 are good, the integers 6, 660 and 12 are nearly good, the integers 16, 7 are neither good nor nearly good.
Find 3 different positive integers x, y, and z such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
Input
The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line of each test case contains two integers A and B (1 ≤ A ≤ 10^6, 1 ≤ B ≤ 10^6) — numbers that Nastia has.
Output
For each test case print:
* "YES" and 3 different positive integers x, y, and z (1 ≤ x, y, z ≤ 10^{18}) such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
* "NO" if no answer exists.
You can print each character of "YES" or "NO" in any case.
If there are multiple answers, print any.
Example
Input
3
5 3
13 2
7 11
Output
YES
10 50 60
YES
169 39 208
YES
28 154 182
Note
In the first test case: 60 — good number; 10 and 50 — nearly good numbers.
In the second test case: 208 — good number; 169 and 39 — nearly good numbers.
In the third test case: 154 — good number; 28 and 182 — nearly good numbers.
Submitted Solution:
```
def mult_solve():
for i in range(int(input())):
solve()
def solve():
a, b = [int(x) for x in input().split()]
if (a % b == 0):
print("NO")
else:
x = a
y = a * (b * 2 - 1)
z = x + y
print("YES")
print(x, y, z)
mult_solve()
``` | instruction | 0 | 75,286 | 22 | 150,572 |
No | output | 1 | 75,286 | 22 | 150,573 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A number is called almost prime if it has exactly two distinct prime divisors. For example, numbers 6, 18, 24 are almost prime, while 4, 8, 9, 42 are not. Find the amount of almost prime numbers which are between 1 and n, inclusive.
Input
Input contains one integer number n (1 ≤ n ≤ 3000).
Output
Output the amount of almost prime numbers between 1 and n, inclusive.
Examples
Input
10
Output
2
Input
21
Output
8 | instruction | 0 | 75,337 | 22 | 150,674 |
Tags: number theory
Correct Solution:
```
"""
https://codeforces.com/problemset/problem/26/A
"""
def prime_factors(n):
i = 2
factors = []
while i * i <= n:
if n % i:
i += 1
else:
n //= i
factors.append(i)
if n > 1:
factors.append(n)
return factors
number = int(input())
p = 0
for i in range(number+1):
factors = prime_factors(i)
factors = list(dict.fromkeys(factors))
if len(factors) == 2 and i != 0:
p += 1
print(p)
``` | output | 1 | 75,337 | 22 | 150,675 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A number is called almost prime if it has exactly two distinct prime divisors. For example, numbers 6, 18, 24 are almost prime, while 4, 8, 9, 42 are not. Find the amount of almost prime numbers which are between 1 and n, inclusive.
Input
Input contains one integer number n (1 ≤ n ≤ 3000).
Output
Output the amount of almost prime numbers between 1 and n, inclusive.
Examples
Input
10
Output
2
Input
21
Output
8 | instruction | 0 | 75,338 | 22 | 150,676 |
Tags: number theory
Correct Solution:
```
PRIMES = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107,
109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229,
233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359,
367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491,
499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641,
643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787,
797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941,
947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063,
1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201,
1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319,
1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471,
1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597,
1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723,
1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873,
1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011,
2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141,
2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293,
2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417,
2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591,
2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711,
2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843,
2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001]
def _dividers(num):
r = set()
for prime in PRIMES:
if prime > num / 2:
break
if num % prime == 0:
r.add(prime)
return r
n = int(input())
count = 0
for i in range(1, n + 1):
count += int(len(_dividers(i)) == 2)
print(count)
``` | output | 1 | 75,338 | 22 | 150,677 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A number is called almost prime if it has exactly two distinct prime divisors. For example, numbers 6, 18, 24 are almost prime, while 4, 8, 9, 42 are not. Find the amount of almost prime numbers which are between 1 and n, inclusive.
Input
Input contains one integer number n (1 ≤ n ≤ 3000).
Output
Output the amount of almost prime numbers between 1 and n, inclusive.
Examples
Input
10
Output
2
Input
21
Output
8 | instruction | 0 | 75,339 | 22 | 150,678 |
Tags: number theory
Correct Solution:
```
def isprime(num):
p=True
for i in range(1, num):
if num%i==0 and i!=1:
p=False
return p
def dprime(a):
c=0
b=False
for i in range(2, a):
if a%i==0 and isprime(i)==True :
c+=1
if c==2:
b=True
return b
n=int(input())
if n<=3000 and n>0:
count=0
for j in range(n+1):
if dprime(j)==True:
count+=1
print(count)
``` | output | 1 | 75,339 | 22 | 150,679 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A number is called almost prime if it has exactly two distinct prime divisors. For example, numbers 6, 18, 24 are almost prime, while 4, 8, 9, 42 are not. Find the amount of almost prime numbers which are between 1 and n, inclusive.
Input
Input contains one integer number n (1 ≤ n ≤ 3000).
Output
Output the amount of almost prime numbers between 1 and n, inclusive.
Examples
Input
10
Output
2
Input
21
Output
8 | instruction | 0 | 75,340 | 22 | 150,680 |
Tags: number theory
Correct Solution:
```
def is_prime(n) :
if n == 1:
return False
if n in [2,3,5,7]:
return True
if n% 2 == 0 :
return False
r = 3
while r * r <= n:
if n % r == 0:
return False
r += 2
return True
limit = int(input())
def lowerDivisors(num) :
return [i for i in range(1, num + 1) if num % i == 0]
def upperDivisors(num) :
return [num / i for i in lowerDivisors(num)]
def allDivisors(num) :
return set(lowerDivisors(num) + upperDivisors(num))
def almostPrime(num) :
return len([i for i in allDivisors(num) if is_prime(i)]) == 2
print(len([i for i in range(1 , limit + 1) if almostPrime(i)]))
``` | output | 1 | 75,340 | 22 | 150,681 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.