message stringlengths 2 57.2k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 61 108k | cluster float64 22 22 | __index_level_0__ int64 122 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
An agent called Cypher is decrypting a message, that contains a [composite number](https://en.wikipedia.org/wiki/Composite_number) n. All divisors of n, which are greater than 1, are placed in a circle. Cypher can choose the initial order of numbers in the circle.
In one move Cypher can choose two adjacent numbers in a circle and insert their [least common multiple](https://en.wikipedia.org/wiki/Least_common_multiple) between them. He can do that move as many times as needed.
A message is decrypted, if every two adjacent numbers are not coprime. Note that for such constraints it's always possible to decrypt the message.
Find the minimal number of moves that Cypher should do to decrypt the message, and show the initial order of numbers in the circle for that.
Input
The first line contains an integer t (1 β€ t β€ 100) β the number of test cases. Next t lines describe each test case.
In a single line of each test case description, there is a single composite number n (4 β€ n β€ 10^9) β the number from the message.
It's guaranteed that the total number of divisors of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in the first line output the initial order of divisors, which are greater than 1, in the circle. In the second line output, the minimal number of moves needed to decrypt the message.
If there are different possible orders with a correct answer, print any of them.
Example
Input
3
6
4
30
Output
2 3 6
1
2 4
0
2 30 6 3 15 5 10
0
Note
In the first test case 6 has three divisors, which are greater than 1: 2, 3, 6. Regardless of the initial order, numbers 2 and 3 are adjacent, so it's needed to place their least common multiple between them. After that the circle becomes 2, 6, 3, 6, and every two adjacent numbers are not coprime.
In the second test case 4 has two divisors greater than 1: 2, 4, and they are not coprime, so any initial order is correct, and it's not needed to place any least common multiples.
In the third test case all divisors of 30 greater than 1 can be placed in some order so that there are no two adjacent numbers that are coprime. | instruction | 0 | 5,977 | 22 | 11,954 |
Tags: constructive algorithms, implementation, math, number theory
Correct Solution:
```
import sys
import math
ii = lambda: sys.stdin.readline().strip()
idata = lambda: [int(x) for x in ii().split()]
def solve():
n = int(ii())
simple = []
dividers = []
slov = {}
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
dividers += [i]
if n // i != i:
dividers += [n // i]
dividers += [1]
dividers.sort()
for i in range(len(dividers) - 1, -1, -1):
flag = 1
for j in range(len(simple)):
if (n // dividers[i]) % simple[j] == 0 and flag:
flag = 0
slov[simple[j]] += [n // dividers[i]]
if flag:
simple += [n // dividers[i]]
slov[n // dividers[i]] = []
dividers += [n]
simple.sort()
if len(simple) == 2:
if n % pow(simple[0], 2) != 0 and n % pow(simple[1], 2) != 0:
print(*dividers[1:])
print(1)
else:
slov[simple[0]].remove(n)
ans = [simple[0]] + slov[simple[0]] + [simple[1]] + slov[simple[1]] + [n]
print(*ans)
print(0)
return
if len(simple) >= 2:
s = simple[0] * simple[-1]
slov[simple[0]].remove(s)
ans = []
for j in range(len(simple)):
ans += [simple[j]]
d = simple[(j + 1) % len(simple)] * simple[j]
for i in slov[simple[j]]:
if i != d and i != simple[j]:
ans += [i]
ans += [d]
print(*ans)
print(0)
for t in range(int(ii())):
solve()
``` | output | 1 | 5,977 | 22 | 11,955 |
Provide tags and a correct Python 3 solution for this coding contest problem.
An agent called Cypher is decrypting a message, that contains a [composite number](https://en.wikipedia.org/wiki/Composite_number) n. All divisors of n, which are greater than 1, are placed in a circle. Cypher can choose the initial order of numbers in the circle.
In one move Cypher can choose two adjacent numbers in a circle and insert their [least common multiple](https://en.wikipedia.org/wiki/Least_common_multiple) between them. He can do that move as many times as needed.
A message is decrypted, if every two adjacent numbers are not coprime. Note that for such constraints it's always possible to decrypt the message.
Find the minimal number of moves that Cypher should do to decrypt the message, and show the initial order of numbers in the circle for that.
Input
The first line contains an integer t (1 β€ t β€ 100) β the number of test cases. Next t lines describe each test case.
In a single line of each test case description, there is a single composite number n (4 β€ n β€ 10^9) β the number from the message.
It's guaranteed that the total number of divisors of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in the first line output the initial order of divisors, which are greater than 1, in the circle. In the second line output, the minimal number of moves needed to decrypt the message.
If there are different possible orders with a correct answer, print any of them.
Example
Input
3
6
4
30
Output
2 3 6
1
2 4
0
2 30 6 3 15 5 10
0
Note
In the first test case 6 has three divisors, which are greater than 1: 2, 3, 6. Regardless of the initial order, numbers 2 and 3 are adjacent, so it's needed to place their least common multiple between them. After that the circle becomes 2, 6, 3, 6, and every two adjacent numbers are not coprime.
In the second test case 4 has two divisors greater than 1: 2, 4, and they are not coprime, so any initial order is correct, and it's not needed to place any least common multiples.
In the third test case all divisors of 30 greater than 1 can be placed in some order so that there are no two adjacent numbers that are coprime. | instruction | 0 | 5,978 | 22 | 11,956 |
Tags: constructive algorithms, implementation, math, number theory
Correct Solution:
```
from collections import defaultdict, deque
T = int(input())
for _ in range(T):
n = int(input())
d, p = defaultdict(int), 2
while p*p <= n:
while n % p == 0:
d[p], n = d[p]+1, n//p
p += 1
if n > 1: d[n] = 1
ls = [1]
for u, cc in d.items():
m, p = len(ls), 1
for _ in range(cc):
p *= u
for v in reversed(ls[0:m]):
ls.append(v*p)
if len(ls) > 2: ls[-1], ls[-2] = ls[-2], ls[-1]
move = (len(d) == 2 and max(d.values()) == 1)
print(*ls[1:])
print(1 if move else 0)
``` | output | 1 | 5,978 | 22 | 11,957 |
Provide tags and a correct Python 3 solution for this coding contest problem.
An agent called Cypher is decrypting a message, that contains a [composite number](https://en.wikipedia.org/wiki/Composite_number) n. All divisors of n, which are greater than 1, are placed in a circle. Cypher can choose the initial order of numbers in the circle.
In one move Cypher can choose two adjacent numbers in a circle and insert their [least common multiple](https://en.wikipedia.org/wiki/Least_common_multiple) between them. He can do that move as many times as needed.
A message is decrypted, if every two adjacent numbers are not coprime. Note that for such constraints it's always possible to decrypt the message.
Find the minimal number of moves that Cypher should do to decrypt the message, and show the initial order of numbers in the circle for that.
Input
The first line contains an integer t (1 β€ t β€ 100) β the number of test cases. Next t lines describe each test case.
In a single line of each test case description, there is a single composite number n (4 β€ n β€ 10^9) β the number from the message.
It's guaranteed that the total number of divisors of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in the first line output the initial order of divisors, which are greater than 1, in the circle. In the second line output, the minimal number of moves needed to decrypt the message.
If there are different possible orders with a correct answer, print any of them.
Example
Input
3
6
4
30
Output
2 3 6
1
2 4
0
2 30 6 3 15 5 10
0
Note
In the first test case 6 has three divisors, which are greater than 1: 2, 3, 6. Regardless of the initial order, numbers 2 and 3 are adjacent, so it's needed to place their least common multiple between them. After that the circle becomes 2, 6, 3, 6, and every two adjacent numbers are not coprime.
In the second test case 4 has two divisors greater than 1: 2, 4, and they are not coprime, so any initial order is correct, and it's not needed to place any least common multiples.
In the third test case all divisors of 30 greater than 1 can be placed in some order so that there are no two adjacent numbers that are coprime. | instruction | 0 | 5,979 | 22 | 11,958 |
Tags: constructive algorithms, implementation, math, number theory
Correct Solution:
```
import random
from math import gcd, sqrt, floor, ceil
#__________________________________________________#
# brute force solution_____________________________#
def solve_1(n):
d = divisors(n)
order = [0] * len(d)
moves = [999999999] * 1
mark = [False] * len(d)
permutation(d, [0] * len(d), 0, moves, mark, order)
if gcd(order[0], order[-1]) == 1:
moves[0] += 1
return order, moves[0]
def permutation(d, p, pos, moves, mark, order):
if pos == len(d):
m = 0
for i in range(len(p) - 1):
if gcd(p[i], p[i + 1]) == 1:
m += 1
if m < moves[0]:
moves[0] = m
for i in range(len(p)):
order[i] = p[i]
#print(p)
return
for i in range(len(d)):
if not mark[i]:
mark[i] = True
p[pos] = d[i]
permutation(d, p, pos + 1, moves, mark, order)
mark[i] = False
return
def divisors(n):
d = []
for i in range(2, int(sqrt(n)) + 1):
if(n % i == 0):
d.insert(floor(len(d)/2), i)
if(i * i != n):
d.insert(ceil(len(d)/2), n//i)
d.append(n)
return d
#__________________________________________________#
# solution_________________________________________#
def solve_2(n):
d = divisors(n)
moves = 0
if len(d) == 1:
return d, 0
order = sort(d)
if(gcd(order[0], order[len(order) - 1]) == 1):
moves += 1
return order, moves
def sort(d):
order = []
order.append(d[0])
count = len(d)
d.remove(d[0])
j = 0
while(len(order) < count):
if int(gcd(d[j], order[-1])) != 1:
order.append(d[j])
d.remove(d[j])
j = 0
else: j += 1
return order
#__________________________________________________#
# main_____________________________________________#
def main():
t = int(input())
for i in range(t):
n = int(input())
#order, moves = solve_1(n) #solucion_fuerza_bruta
order, moves = solve_2(n) #solucion_eficiente
print(' '.join(str(j) for j in order))
print(moves)
return
# _________________________________________________#
# random cases tester______________________________#
def random_cases():
n = random.randint(2, 50)
print('Case: \n' + "n = " + str(n))
order, moves = solve_1(n) #solucion_fuerza_bruta
#order, moves = solve_2(n) #solucion_eficiente
print(' '.join(str(i) for i in order)) #solucion
print(moves)
return
#__________________________________________________#
# tester___________________________________________#
def tester():
for i in range(1, 20):
n = random. randint(4, 50)
order_1, moves_1 = solve_1(n)
order_2, moves_2 = solve_2(n)
print('Case ' + str(i) + ':\n' + 'n = ' + str(n))
print('solucion fuerza bruta : \n' + ' '.join(str(i) for i in order_1) + '\n' + str(moves_1)) #solucion_fuerza_bruta
print('solucion eficiente : \n' + ' '.join(str(i) for i in order_2) + '\n' + str(moves_2)) #solucion_eficiente
for i in range(min(len(order_1), len(order_2))):
if(order_1[i] != order_2[i] or len(order_1) != len(order_2) or moves_1 != moves_2):
print(Color.RED + 'Wrong Answer\n' + Color.RESET)
return
print(Color.GREEN + 'Accepted\n' + Color.RESET)
return
main() #entrada_de_casos_por_consola
#random_cases() #casos_random
#tester() #tester_automatico
``` | output | 1 | 5,979 | 22 | 11,959 |
Provide tags and a correct Python 3 solution for this coding contest problem.
An agent called Cypher is decrypting a message, that contains a [composite number](https://en.wikipedia.org/wiki/Composite_number) n. All divisors of n, which are greater than 1, are placed in a circle. Cypher can choose the initial order of numbers in the circle.
In one move Cypher can choose two adjacent numbers in a circle and insert their [least common multiple](https://en.wikipedia.org/wiki/Least_common_multiple) between them. He can do that move as many times as needed.
A message is decrypted, if every two adjacent numbers are not coprime. Note that for such constraints it's always possible to decrypt the message.
Find the minimal number of moves that Cypher should do to decrypt the message, and show the initial order of numbers in the circle for that.
Input
The first line contains an integer t (1 β€ t β€ 100) β the number of test cases. Next t lines describe each test case.
In a single line of each test case description, there is a single composite number n (4 β€ n β€ 10^9) β the number from the message.
It's guaranteed that the total number of divisors of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in the first line output the initial order of divisors, which are greater than 1, in the circle. In the second line output, the minimal number of moves needed to decrypt the message.
If there are different possible orders with a correct answer, print any of them.
Example
Input
3
6
4
30
Output
2 3 6
1
2 4
0
2 30 6 3 15 5 10
0
Note
In the first test case 6 has three divisors, which are greater than 1: 2, 3, 6. Regardless of the initial order, numbers 2 and 3 are adjacent, so it's needed to place their least common multiple between them. After that the circle becomes 2, 6, 3, 6, and every two adjacent numbers are not coprime.
In the second test case 4 has two divisors greater than 1: 2, 4, and they are not coprime, so any initial order is correct, and it's not needed to place any least common multiples.
In the third test case all divisors of 30 greater than 1 can be placed in some order so that there are no two adjacent numbers that are coprime. | instruction | 0 | 5,980 | 22 | 11,960 |
Tags: constructive algorithms, implementation, math, number theory
Correct Solution:
```
'''
Auther: ghoshashis545 Ashis Ghosh
College: jalpaiguri Govt Enggineering College
'''
from os import path
import sys
from heapq import heappush,heappop
from functools import cmp_to_key as ctk
from collections import deque,defaultdict as dd
from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
from itertools import permutations
from datetime import datetime
from math import ceil,sqrt,log,gcd
def ii():return int(input())
def si():return input().rstrip()
def mi():return map(int,input().split())
def li():return list(mi())
abc='abcdefghijklmnopqrstuvwxyz'
mod=1000000007
# mod=998244353
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def bo(i):
return ord(i)-ord('a')
def ceil(a,b):
return (a+b-1)//b
file=1
def f():
sys.stdout.flush()
def solve():
for _ in range(ii()):
n = ii()
n1 = n
primedivisor = []
for i in range(2,int(sqrt(n))+1):
c = 0
while(n%i==0):
c +=1
n //=i
if c > 0:
primedivisor.append([i,c])
if n>1:
primedivisor.append([n,1])
cnt = len(primedivisor)
# only one prime divisor
if cnt == 1:
p = primedivisor[0][0]
q = primedivisor[0][1]
for i in range(1,q+1):
print(p**i,end=" ")
print()
print(0)
continue
p = primedivisor[0][0]
q = primedivisor[0][1]
ans = []
# divisor -> p^1,p^2,p^2,p^3.....p^q
for j in range(1,q+1):
ans.append(p**j)
f = 0
for i in range(1,cnt):
p = primedivisor[i][0]
q = primedivisor[i][1]
curlen = len(ans)
lcm = p * primedivisor[i-1][0]
ans.append(lcm)
# divisor -> p^2,p^2,p^3.....p^q
for j in range(2,q+1):
ans.append(p**j)
for j in range(curlen):
for k in range(1,q+1):
x = p**k * ans[j]
if x == lcm:
continue
if x==n1:
f = 1
continue
ans.append(x)
ans.append(p)
if len(ans) == 3:
print(*ans)
print(1)
else:
if(f==0):
ans[-2],ans[-1] = ans[-1],ans[-2]
else:
ans.append(n1)
print(*ans)
print(0)
if __name__ =="__main__":
if path.exists('input.txt'):
sys.stdin=open('input.txt', 'r')
sys.stdout=open('output.txt','w')
else:
input=sys.stdin.readline
solve()
``` | output | 1 | 5,980 | 22 | 11,961 |
Provide tags and a correct Python 3 solution for this coding contest problem.
An agent called Cypher is decrypting a message, that contains a [composite number](https://en.wikipedia.org/wiki/Composite_number) n. All divisors of n, which are greater than 1, are placed in a circle. Cypher can choose the initial order of numbers in the circle.
In one move Cypher can choose two adjacent numbers in a circle and insert their [least common multiple](https://en.wikipedia.org/wiki/Least_common_multiple) between them. He can do that move as many times as needed.
A message is decrypted, if every two adjacent numbers are not coprime. Note that for such constraints it's always possible to decrypt the message.
Find the minimal number of moves that Cypher should do to decrypt the message, and show the initial order of numbers in the circle for that.
Input
The first line contains an integer t (1 β€ t β€ 100) β the number of test cases. Next t lines describe each test case.
In a single line of each test case description, there is a single composite number n (4 β€ n β€ 10^9) β the number from the message.
It's guaranteed that the total number of divisors of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in the first line output the initial order of divisors, which are greater than 1, in the circle. In the second line output, the minimal number of moves needed to decrypt the message.
If there are different possible orders with a correct answer, print any of them.
Example
Input
3
6
4
30
Output
2 3 6
1
2 4
0
2 30 6 3 15 5 10
0
Note
In the first test case 6 has three divisors, which are greater than 1: 2, 3, 6. Regardless of the initial order, numbers 2 and 3 are adjacent, so it's needed to place their least common multiple between them. After that the circle becomes 2, 6, 3, 6, and every two adjacent numbers are not coprime.
In the second test case 4 has two divisors greater than 1: 2, 4, and they are not coprime, so any initial order is correct, and it's not needed to place any least common multiples.
In the third test case all divisors of 30 greater than 1 can be placed in some order so that there are no two adjacent numbers that are coprime. | instruction | 0 | 5,981 | 22 | 11,962 |
Tags: constructive algorithms, implementation, math, number theory
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
from collections import Counter
def main():
for _ in range(int(input())):
n = int(input())
fac = Counter()
div = {n}
x = n
for i in range(2,int(x**0.5)+1):
if not x%i:
div.add(i)
div.add(x//i)
while not n%i:
fac[i] += 1
n //= i
if n != 1:
fac[n] += 1
x = list(fac.keys())
if len(fac) == 1:
print(' '.join(map(str,div)))
print(0)
elif sum(fac.values()) == 2 and len(fac) == 2:
print(x[0],x[0]*x[1],x[1])
print(1)
else:
fir = []
for i in range(len(x)):
su = x[i]*x[i-1]
for j in div:
if not j%su:
fir.append(j)
break
div.remove(fir[-1])
ans = []
for ind,val in enumerate(x):
ans.append(fir[ind])
nu = 0
for j in div:
if not j%val:
nu += 1
ans.append(j)
for j in range(-1,-1-nu,-1):
div.remove(ans[j])
print(' '.join(map(str,ans)))
print(0)
#Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == '__main__':
main()
``` | output | 1 | 5,981 | 22 | 11,963 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An agent called Cypher is decrypting a message, that contains a [composite number](https://en.wikipedia.org/wiki/Composite_number) n. All divisors of n, which are greater than 1, are placed in a circle. Cypher can choose the initial order of numbers in the circle.
In one move Cypher can choose two adjacent numbers in a circle and insert their [least common multiple](https://en.wikipedia.org/wiki/Least_common_multiple) between them. He can do that move as many times as needed.
A message is decrypted, if every two adjacent numbers are not coprime. Note that for such constraints it's always possible to decrypt the message.
Find the minimal number of moves that Cypher should do to decrypt the message, and show the initial order of numbers in the circle for that.
Input
The first line contains an integer t (1 β€ t β€ 100) β the number of test cases. Next t lines describe each test case.
In a single line of each test case description, there is a single composite number n (4 β€ n β€ 10^9) β the number from the message.
It's guaranteed that the total number of divisors of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in the first line output the initial order of divisors, which are greater than 1, in the circle. In the second line output, the minimal number of moves needed to decrypt the message.
If there are different possible orders with a correct answer, print any of them.
Example
Input
3
6
4
30
Output
2 3 6
1
2 4
0
2 30 6 3 15 5 10
0
Note
In the first test case 6 has three divisors, which are greater than 1: 2, 3, 6. Regardless of the initial order, numbers 2 and 3 are adjacent, so it's needed to place their least common multiple between them. After that the circle becomes 2, 6, 3, 6, and every two adjacent numbers are not coprime.
In the second test case 4 has two divisors greater than 1: 2, 4, and they are not coprime, so any initial order is correct, and it's not needed to place any least common multiples.
In the third test case all divisors of 30 greater than 1 can be placed in some order so that there are no two adjacent numbers that are coprime.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
pfacs = []
m, i = n, 2
while i * i <= m:
while m % i == 0:
pfacs.append(i)
m //= i
i += 1
if m > 1:
pfacs.append(m)
pr = list(set(pfacs))
facs = {1}
for p in pfacs:
facs |= set(p * x for x in facs)
facs.remove(1)
def get():
global facs
if len(pr) == 1:
return facs, 0
if len(pr) == 2:
p, q = pr
if len(pfacs) == 2:
return [p, q, n], 1
pmul = set(x for x in facs if x % p == 0)
facs -= pmul
pmul -= {p, p * q, n}
facs.remove(q)
return [p, *pmul, p * q, q, *facs, n], 0
ans = []
for p, q in zip(pr, pr[1:] + [pr[0]]):
pmul = set(x for x in facs if x % p == 0)
if p == pr[0]:
pmul.remove(p * pr[-1])
facs -= pmul
pmul -= {p, p * q}
ans += [p, *pmul, p * q]
return ans, 0
ans, c = get()
print(*ans)
print(c)
``` | instruction | 0 | 5,982 | 22 | 11,964 |
Yes | output | 1 | 5,982 | 22 | 11,965 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An agent called Cypher is decrypting a message, that contains a [composite number](https://en.wikipedia.org/wiki/Composite_number) n. All divisors of n, which are greater than 1, are placed in a circle. Cypher can choose the initial order of numbers in the circle.
In one move Cypher can choose two adjacent numbers in a circle and insert their [least common multiple](https://en.wikipedia.org/wiki/Least_common_multiple) between them. He can do that move as many times as needed.
A message is decrypted, if every two adjacent numbers are not coprime. Note that for such constraints it's always possible to decrypt the message.
Find the minimal number of moves that Cypher should do to decrypt the message, and show the initial order of numbers in the circle for that.
Input
The first line contains an integer t (1 β€ t β€ 100) β the number of test cases. Next t lines describe each test case.
In a single line of each test case description, there is a single composite number n (4 β€ n β€ 10^9) β the number from the message.
It's guaranteed that the total number of divisors of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in the first line output the initial order of divisors, which are greater than 1, in the circle. In the second line output, the minimal number of moves needed to decrypt the message.
If there are different possible orders with a correct answer, print any of them.
Example
Input
3
6
4
30
Output
2 3 6
1
2 4
0
2 30 6 3 15 5 10
0
Note
In the first test case 6 has three divisors, which are greater than 1: 2, 3, 6. Regardless of the initial order, numbers 2 and 3 are adjacent, so it's needed to place their least common multiple between them. After that the circle becomes 2, 6, 3, 6, and every two adjacent numbers are not coprime.
In the second test case 4 has two divisors greater than 1: 2, 4, and they are not coprime, so any initial order is correct, and it's not needed to place any least common multiples.
In the third test case all divisors of 30 greater than 1 can be placed in some order so that there are no two adjacent numbers that are coprime.
Submitted Solution:
```
def gen(i, cur):
global dvs, used
if i == len(kk):
if (ohne != 1 or cur != 1) and (ok or not used[cur * ohne]):
dvs.append(cur * ohne)
return
gen(i + 1, cur)
for j in range(kk[i]):
cur *= pp[i]
gen(i + 1, cur)
gans = []
for _ in range(int(input())):
n = int(input())
pp = []
kk = []
i = 2
cnt = []
while i * i <= n:
if n % i == 0:
pp.append(i)
kk.append(0)
while n % i == 0:
kk[-1] += 1
n //= i
i += 1
if n != 1:
pp.append(n)
kk.append(1)
dvs = []
ohne = 1
ok = True
gen(0, 1)
if len(pp) == 1:
gans.append(' '.join(map(str, dvs)))
gans.append(str(0))
elif len(pp) == 2 and kk[0] == kk[1] == 1:
gans.append(' '.join(map(str, dvs)))
gans.append(str(1))
elif len(pp) == 2:
used = dict()
for i in range(len(dvs)):
used[dvs[i]] = False
ans = []
ok = False
used[pp[0] * pp[1]] = True
aaa = [pp[0] * pp[1]]
if kk[0] > 1:
used[pp[0] * pp[0] * pp[1]] = True
aaa.append(pp[0] * pp[0] * pp[1])
else:
used[pp[0] * pp[1] * pp[1]] = True
aaa.append(pp[0] * pp[1] * pp[1])
for i in range(len(pp)):
dvs = []
ans.append(aaa[i])
kk[i] -= 1
ohne = pp[i]
gen(0, 1)
for j in range(len(dvs)):
used[dvs[j]] = True
ans.append(dvs[j])
gans.append(' '.join(map(str, ans)))
gans.append(str(0))
else:
used = dict()
for i in range(len(dvs)):
used[dvs[i]] = False
ans = []
ok = False
for i in range(len(pp)):
used[pp[i - 1] * pp[i]] = True
for i in range(len(pp)):
dvs = []
ans.append(pp[i - 1] * pp[i])
kk[i] -= 1
ohne = pp[i]
gen(0, 1)
for j in range(len(dvs)):
used[dvs[j]] = True
ans.append(dvs[j])
gans.append(' '.join(map(str, ans)))
gans.append(str(0))
print('\n'.join(gans))
``` | instruction | 0 | 5,983 | 22 | 11,966 |
Yes | output | 1 | 5,983 | 22 | 11,967 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An agent called Cypher is decrypting a message, that contains a [composite number](https://en.wikipedia.org/wiki/Composite_number) n. All divisors of n, which are greater than 1, are placed in a circle. Cypher can choose the initial order of numbers in the circle.
In one move Cypher can choose two adjacent numbers in a circle and insert their [least common multiple](https://en.wikipedia.org/wiki/Least_common_multiple) between them. He can do that move as many times as needed.
A message is decrypted, if every two adjacent numbers are not coprime. Note that for such constraints it's always possible to decrypt the message.
Find the minimal number of moves that Cypher should do to decrypt the message, and show the initial order of numbers in the circle for that.
Input
The first line contains an integer t (1 β€ t β€ 100) β the number of test cases. Next t lines describe each test case.
In a single line of each test case description, there is a single composite number n (4 β€ n β€ 10^9) β the number from the message.
It's guaranteed that the total number of divisors of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in the first line output the initial order of divisors, which are greater than 1, in the circle. In the second line output, the minimal number of moves needed to decrypt the message.
If there are different possible orders with a correct answer, print any of them.
Example
Input
3
6
4
30
Output
2 3 6
1
2 4
0
2 30 6 3 15 5 10
0
Note
In the first test case 6 has three divisors, which are greater than 1: 2, 3, 6. Regardless of the initial order, numbers 2 and 3 are adjacent, so it's needed to place their least common multiple between them. After that the circle becomes 2, 6, 3, 6, and every two adjacent numbers are not coprime.
In the second test case 4 has two divisors greater than 1: 2, 4, and they are not coprime, so any initial order is correct, and it's not needed to place any least common multiples.
In the third test case all divisors of 30 greater than 1 can be placed in some order so that there are no two adjacent numbers that are coprime.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline()
# ------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def print_list(l):
print(' '.join(map(str,l)))
# sys.setrecursionlimit(300000)
# from heapq import *
# from collections import deque as dq
from math import ceil,floor,sqrt,pow
# import bisect as bs
# from collections import Counter
# from collections import defaultdict as dc
for i in range(N()):
n = N()
nn,k = n,2
p,d = [],[i for i in range(2,int(sqrt(n))+1) if n%i==0]
d+=[n//i for i in d]
d = set(d)
d.add(n)
# print(d)
for i in d:
if nn%i==0:
p.append(i)
while nn%i==0:
nn//=i
# print(d)
# print(p)
if len(p)==1:
print_list(d)
print(0)
elif len(p)==2:
if len(d)==3:
print_list(d)
print(1)
else:
a,b = p[0],p[1]
res = [a*b,a]
d-={a*b,a,n}
for i in d:
if i%a==0:
res.append(i)
res.append(n)
for i in d:
if i%a>0:
res.append(i)
print_list(res)
print(0)
else:
res = []
s = 0
pp = [p[i]*p[i-1] for i in range(1,len(p))]+[p[0]*p[-1]]
d-=set(pp)
d-=set(p)
for i in range(len(p)):
k = p[i]
for t in d:
if t%k==0:
res.append(t)
d-=set(res[s:])
s = len(res)
res.append(p[i])
res.append(pp[i])
print_list(res)
print(0)
``` | instruction | 0 | 5,984 | 22 | 11,968 |
Yes | output | 1 | 5,984 | 22 | 11,969 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An agent called Cypher is decrypting a message, that contains a [composite number](https://en.wikipedia.org/wiki/Composite_number) n. All divisors of n, which are greater than 1, are placed in a circle. Cypher can choose the initial order of numbers in the circle.
In one move Cypher can choose two adjacent numbers in a circle and insert their [least common multiple](https://en.wikipedia.org/wiki/Least_common_multiple) between them. He can do that move as many times as needed.
A message is decrypted, if every two adjacent numbers are not coprime. Note that for such constraints it's always possible to decrypt the message.
Find the minimal number of moves that Cypher should do to decrypt the message, and show the initial order of numbers in the circle for that.
Input
The first line contains an integer t (1 β€ t β€ 100) β the number of test cases. Next t lines describe each test case.
In a single line of each test case description, there is a single composite number n (4 β€ n β€ 10^9) β the number from the message.
It's guaranteed that the total number of divisors of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in the first line output the initial order of divisors, which are greater than 1, in the circle. In the second line output, the minimal number of moves needed to decrypt the message.
If there are different possible orders with a correct answer, print any of them.
Example
Input
3
6
4
30
Output
2 3 6
1
2 4
0
2 30 6 3 15 5 10
0
Note
In the first test case 6 has three divisors, which are greater than 1: 2, 3, 6. Regardless of the initial order, numbers 2 and 3 are adjacent, so it's needed to place their least common multiple between them. After that the circle becomes 2, 6, 3, 6, and every two adjacent numbers are not coprime.
In the second test case 4 has two divisors greater than 1: 2, 4, and they are not coprime, so any initial order is correct, and it's not needed to place any least common multiples.
In the third test case all divisors of 30 greater than 1 can be placed in some order so that there are no two adjacent numbers that are coprime.
Submitted Solution:
```
from itertools import product
def p_factorization_t(n):
if n == 1: return []
pf_cnt = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i == 0:
cnt = 0
while temp%i == 0:
cnt += 1
temp //= i
pf_cnt.append((i,cnt))
if temp != 1: pf_cnt.append((temp,1))
return pf_cnt
def main():
ansl = []
for _ in range(int(input())):
n = int(input())
facs = p_factorization_t(n)
# print(facs)
if len(facs) == 1:
p,cnt = facs[0]
al = []
for i in range(1,cnt+1):
al.append(pow(p,i))
print(*al)
print(0)
ff = []
pd = {}
ps = []
for p,cnt in facs:
row = []
for i in range(0,cnt+1):
row.append(pow(p,i))
ff.append(row)
pd[p] = []
ps.append(p)
vals = [1]
for row in ff:
new_vals = []
for v in vals:
for p in row:
new_vals.append(p*v)
if p != 1:
pd[row[1]].append(v*p)
vals = new_vals[:]
if len(facs) >= 3:
al = []
for i in range(len(ps)):
cval = -1
if i > 0:
cval = (ps[i]*ps[i-1])
al.append(cval)
else:
cval = (ps[i]*ps[-1])
for v in pd[ps[i]]:
if v != cval:
al.append(v)
print(*al)
print(0)
elif len(facs) == 2:
al = []
for i in range(len(ps)):
cval = -1
if i > 0:
cval = (ps[i]*ps[i-1])
al.append(cval)
else:
cval = (ps[i]*ps[-1])
for v in pd[ps[i]]:
if v != cval:
al.append(v)
print(*al)
if facs[0][1] == 1 and facs[1][1] == 1:
print(1)
else:
print(0)
# elif len(facs) == 2:
if __name__ == "__main__":
main()
``` | instruction | 0 | 5,985 | 22 | 11,970 |
Yes | output | 1 | 5,985 | 22 | 11,971 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An agent called Cypher is decrypting a message, that contains a [composite number](https://en.wikipedia.org/wiki/Composite_number) n. All divisors of n, which are greater than 1, are placed in a circle. Cypher can choose the initial order of numbers in the circle.
In one move Cypher can choose two adjacent numbers in a circle and insert their [least common multiple](https://en.wikipedia.org/wiki/Least_common_multiple) between them. He can do that move as many times as needed.
A message is decrypted, if every two adjacent numbers are not coprime. Note that for such constraints it's always possible to decrypt the message.
Find the minimal number of moves that Cypher should do to decrypt the message, and show the initial order of numbers in the circle for that.
Input
The first line contains an integer t (1 β€ t β€ 100) β the number of test cases. Next t lines describe each test case.
In a single line of each test case description, there is a single composite number n (4 β€ n β€ 10^9) β the number from the message.
It's guaranteed that the total number of divisors of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in the first line output the initial order of divisors, which are greater than 1, in the circle. In the second line output, the minimal number of moves needed to decrypt the message.
If there are different possible orders with a correct answer, print any of them.
Example
Input
3
6
4
30
Output
2 3 6
1
2 4
0
2 30 6 3 15 5 10
0
Note
In the first test case 6 has three divisors, which are greater than 1: 2, 3, 6. Regardless of the initial order, numbers 2 and 3 are adjacent, so it's needed to place their least common multiple between them. After that the circle becomes 2, 6, 3, 6, and every two adjacent numbers are not coprime.
In the second test case 4 has two divisors greater than 1: 2, 4, and they are not coprime, so any initial order is correct, and it's not needed to place any least common multiples.
In the third test case all divisors of 30 greater than 1 can be placed in some order so that there are no two adjacent numbers that are coprime.
Submitted Solution:
```
depth=32000
primes=[True]*depth
primes[0]=primes[1]=False
prime_list=[0]*3432
k=0
for i in range(depth):
if primes[i]:
prime_list[k]=i
k+=1
for j in range(i*i,depth,i):
primes[j]=False
t=int(input())
for i in range(t):
flag=True
n=int(input())
divisors=[0]*200000
num_of_div=0
k=n
j=0
current_lenght=0
''' Π Π°Π·Π»Π°Π³Π°Π΅ΠΌ Π½Π° ΠΌΠ½ΠΎΠΆΠΈΡΠ΅Π»ΠΈ'''
while k>1 and j<3432:
degree=0
while k%prime_list[j]==0:
degree+=1
k=k//prime_list[j]
if degree:
num_of_div+=1
current=1
if degree>1:
flag=False
if current_lenght==0 and degree:
for index in range(degree-1):
current*=prime_list[j]
divisors[index]=current
print(current, end=' ')
current*=prime_list[j]
if k==1:
print(current)
else:
print(current, end=' ')
divisors[degree-1]=current
current_lenght=degree
elif degree and k>1:
for m in range(1,degree+1):
current*=prime_list[j]
for index in range(current_lenght):
divisors[m*current_lenght+index]=\
divisors[current_lenght-index-1]*current
print(divisors[m*current_lenght+index], end=' ')
print(prime_list[j], end=' ')
current_lenght=degree*current_lenght+1
elif degree and k==1:
for m in range(1,degree):
current*=prime_list[j]
for index in range(current_lenght):
divisors[m*current_lenght+index]=\
divisors[current_lenght-index-1]*current
print(divisors[m*current_lenght+index], end=' ')
if degree>1:
print(prime_list[j], end=' ')
m=degree
current*=prime_list[j]
for index in range(current_lenght-1):
divisors[m*current_lenght+index]=\
divisors[current_lenght-index-1]*current
print(divisors[m*current_lenght+index], end=' ')
print(current, end=' ')
print(current*divisors[0])
j+=1
'''ΠΠΎΠΏΠΈΡΡΠ²Π°Π΅ΠΌ ΠΏΠΎΡΠ»Π΅Π΄Π½ΠΈΠΉ Π΄Π΅Π»ΠΈΡΠ΅Π»Ρ'''
if k!=1:
for index in range(current_lenght-1,0,-1):
print(k*divisors[index], end=' ')
num_of_div+=1
print(k,end=' ')
print(divisors[0]*k)
if num_of_div==2 and flag:
print(1)
else:
print(0)
``` | instruction | 0 | 5,986 | 22 | 11,972 |
No | output | 1 | 5,986 | 22 | 11,973 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An agent called Cypher is decrypting a message, that contains a [composite number](https://en.wikipedia.org/wiki/Composite_number) n. All divisors of n, which are greater than 1, are placed in a circle. Cypher can choose the initial order of numbers in the circle.
In one move Cypher can choose two adjacent numbers in a circle and insert their [least common multiple](https://en.wikipedia.org/wiki/Least_common_multiple) between them. He can do that move as many times as needed.
A message is decrypted, if every two adjacent numbers are not coprime. Note that for such constraints it's always possible to decrypt the message.
Find the minimal number of moves that Cypher should do to decrypt the message, and show the initial order of numbers in the circle for that.
Input
The first line contains an integer t (1 β€ t β€ 100) β the number of test cases. Next t lines describe each test case.
In a single line of each test case description, there is a single composite number n (4 β€ n β€ 10^9) β the number from the message.
It's guaranteed that the total number of divisors of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in the first line output the initial order of divisors, which are greater than 1, in the circle. In the second line output, the minimal number of moves needed to decrypt the message.
If there are different possible orders with a correct answer, print any of them.
Example
Input
3
6
4
30
Output
2 3 6
1
2 4
0
2 30 6 3 15 5 10
0
Note
In the first test case 6 has three divisors, which are greater than 1: 2, 3, 6. Regardless of the initial order, numbers 2 and 3 are adjacent, so it's needed to place their least common multiple between them. After that the circle becomes 2, 6, 3, 6, and every two adjacent numbers are not coprime.
In the second test case 4 has two divisors greater than 1: 2, 4, and they are not coprime, so any initial order is correct, and it's not needed to place any least common multiples.
In the third test case all divisors of 30 greater than 1 can be placed in some order so that there are no two adjacent numbers that are coprime.
Submitted Solution:
```
import sys
input = sys.stdin.readline
import math
def yaku(x):
xr=math.ceil(math.sqrt(x))
LIST=[]
for i in range(1,xr+1):
if x%i==0:
LIST.append(i)
LIST.append(x//i)
L=int(math.sqrt(x))
FACT=dict()
for i in range(2,L+2):
while x%i==0:
FACT[i]=FACT.get(i,0)+1
x=x//i
if x!=1:
FACT[x]=FACT.get(x,0)+1
return sorted(set(LIST)),sorted(set(FACT))
t=int(input())
for tests in range(t):
n=int(input())
L,SS=yaku(n)
USE=[0]*len(L)
USE[0]=1
USE[-1]=1
ANS=[n]
for i in range(len(SS)-1):
NEXT=SS[i]*SS[i+1]
ANSX=[]
for j in range(len(L)):
if L[j]==NEXT:
USE[j]=1
if USE[j]==0 and L[j]%SS[i]==0:
USE[j]=1
ANSX.append(L[j])
if NEXT!=n:
ANSX.append(NEXT)
ANS+=ANSX
ANS.append(SS[-1])
SC=0
for i in range(len(ANS)):
if math.gcd(ANS[i],ANS[i-1])==1:
SC+=1
print(*ANS)
print(SC)
``` | instruction | 0 | 5,987 | 22 | 11,974 |
No | output | 1 | 5,987 | 22 | 11,975 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An agent called Cypher is decrypting a message, that contains a [composite number](https://en.wikipedia.org/wiki/Composite_number) n. All divisors of n, which are greater than 1, are placed in a circle. Cypher can choose the initial order of numbers in the circle.
In one move Cypher can choose two adjacent numbers in a circle and insert their [least common multiple](https://en.wikipedia.org/wiki/Least_common_multiple) between them. He can do that move as many times as needed.
A message is decrypted, if every two adjacent numbers are not coprime. Note that for such constraints it's always possible to decrypt the message.
Find the minimal number of moves that Cypher should do to decrypt the message, and show the initial order of numbers in the circle for that.
Input
The first line contains an integer t (1 β€ t β€ 100) β the number of test cases. Next t lines describe each test case.
In a single line of each test case description, there is a single composite number n (4 β€ n β€ 10^9) β the number from the message.
It's guaranteed that the total number of divisors of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in the first line output the initial order of divisors, which are greater than 1, in the circle. In the second line output, the minimal number of moves needed to decrypt the message.
If there are different possible orders with a correct answer, print any of them.
Example
Input
3
6
4
30
Output
2 3 6
1
2 4
0
2 30 6 3 15 5 10
0
Note
In the first test case 6 has three divisors, which are greater than 1: 2, 3, 6. Regardless of the initial order, numbers 2 and 3 are adjacent, so it's needed to place their least common multiple between them. After that the circle becomes 2, 6, 3, 6, and every two adjacent numbers are not coprime.
In the second test case 4 has two divisors greater than 1: 2, 4, and they are not coprime, so any initial order is correct, and it's not needed to place any least common multiples.
In the third test case all divisors of 30 greater than 1 can be placed in some order so that there are no two adjacent numbers that are coprime.
Submitted Solution:
```
def gcd(a, b):
while b: a, b = b, a % b
return a
def isPrimeMR(n):
d = n - 1
d = d // (d & -d)
L = [2, 7, 61] if n < 1<<32 else [2, 3, 5, 7, 11, 13, 17] if n < 1<<48 else [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]
for a in L:
t = d
y = pow(a, t, n)
if y == 1: continue
while y != n - 1:
y = y * y % n
if y == 1 or t == n - 1: return 0
t <<= 1
return 1
def findFactorRho(n):
m = 1 << n.bit_length() // 8
for c in range(1, 99):
f = lambda x: (x * x + c) % n
y, r, q, g = 2, 1, 1, 1
while g == 1:
x = y
for i in range(r):
y = f(y)
k = 0
while k < r and g == 1:
ys = y
for i in range(min(m, r - k)):
y = f(y)
q = q * abs(x - y) % n
g = gcd(q, n)
k += m
r <<= 1
if g == n:
g = 1
while g == 1:
ys = f(ys)
g = gcd(abs(x - ys), n)
if g < n:
if isPrimeMR(g): return g
elif isPrimeMR(n // g): return n // g
return findFactorRho(g)
def primeFactor(n):
i = 2
ret = {}
rhoFlg = 0
while i * i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k: ret[i] = k
i += i % 2 + (3 if i % 3 == 1 else 1)
if i == 101 and n >= 2 ** 20:
while n > 1:
if isPrimeMR(n):
ret[n], n = 1, 1
else:
rhoFlg = 1
j = findFactorRho(n)
k = 0
while n % j == 0:
n //= j
k += 1
ret[j] = k
if n > 1: ret[n] = 1
if rhoFlg: ret = {x: ret[x] for x in sorted(ret)}
return ret
def divisors(pf):
ret = [1]
for p in pf:
ret_prev = ret
ret = []
for i in range(pf[p]+1):
for r in ret_prev:
ret.append(r * (p ** i))
return sorted(ret)
T = int(input())
for _ in range(T):
N = int(input())
pf = primeFactor(N)
dv = divisors(pf)
if len(pf) == 2 and len(dv) == 4:
print(*dv[1:])
print(1)
continue
if len(pf) == 1:
print(*dv[1:])
print(0)
continue
lpf = list(pf)
# print("lpf =", lpf)
X = [[] for _ in range(len(pf))]
S = {1}
for i, p in enumerate(lpf):
# print("i, p, pf[p] =", i, p, pf[p])
X[i].append(lpf[i-1] * p)
S.add(lpf[i-1] * p)
for j in range(1, pf[p] + 1):
X[i].append(p ** j)
S.add(p ** j)
for a in dv:
if a not in S:
for i, p in enumerate(lpf):
if a % p == 0:
X[i].append(a)
break
# print("X =", X)
ANS = []
for x in X:
for y in x:
ANS.append(y)
print(*ANS)
print(0)
``` | instruction | 0 | 5,988 | 22 | 11,976 |
No | output | 1 | 5,988 | 22 | 11,977 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An agent called Cypher is decrypting a message, that contains a [composite number](https://en.wikipedia.org/wiki/Composite_number) n. All divisors of n, which are greater than 1, are placed in a circle. Cypher can choose the initial order of numbers in the circle.
In one move Cypher can choose two adjacent numbers in a circle and insert their [least common multiple](https://en.wikipedia.org/wiki/Least_common_multiple) between them. He can do that move as many times as needed.
A message is decrypted, if every two adjacent numbers are not coprime. Note that for such constraints it's always possible to decrypt the message.
Find the minimal number of moves that Cypher should do to decrypt the message, and show the initial order of numbers in the circle for that.
Input
The first line contains an integer t (1 β€ t β€ 100) β the number of test cases. Next t lines describe each test case.
In a single line of each test case description, there is a single composite number n (4 β€ n β€ 10^9) β the number from the message.
It's guaranteed that the total number of divisors of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in the first line output the initial order of divisors, which are greater than 1, in the circle. In the second line output, the minimal number of moves needed to decrypt the message.
If there are different possible orders with a correct answer, print any of them.
Example
Input
3
6
4
30
Output
2 3 6
1
2 4
0
2 30 6 3 15 5 10
0
Note
In the first test case 6 has three divisors, which are greater than 1: 2, 3, 6. Regardless of the initial order, numbers 2 and 3 are adjacent, so it's needed to place their least common multiple between them. After that the circle becomes 2, 6, 3, 6, and every two adjacent numbers are not coprime.
In the second test case 4 has two divisors greater than 1: 2, 4, and they are not coprime, so any initial order is correct, and it's not needed to place any least common multiples.
In the third test case all divisors of 30 greater than 1 can be placed in some order so that there are no two adjacent numbers that are coprime.
Submitted Solution:
```
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
from collections import deque
import threading
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now-----------------------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
#-------------------------------------------------------------------------
for _ in range (int(input())):
n=int(input())
s=set()
d=set()
a=list()
c=1
d.add(n)
for i in range (2,int(math.sqrt(n))+1):
if n%i==0:
d.add(i)
if i*i!=n:
d.add(n//i)
copy=n
while copy%2==0:
copy//=2
s.add(2)
for i in range (3,int(math.sqrt(copy))+1):
if copy%i==0:
while copy%i==0:
copy//=i
s.add(i)
if copy>2:
s.add(copy)
#print(s)
#print(d)
b=list(s)
if len(b)==2 and b[0]*b[1]==n:
print(*b,b[0]*b[1])
print(1)
else:
for i in s:
a.append([i])
d.remove(i)
#print(a)
for i in range (len(a)):
if i==len(a)-1 and len(s)!=1:
c=a[i][0]*a[0][1]
if c in d:
a[i]=[c]+a[i]
d.remove(c)
else:
c=a[i][0]*a[(i+1)%(len(s))][0]
if c in d:
a[i]=[c]+a[i]
d.remove(c)
#print(a)
for i in range (len(a)):
t=d.copy()
for j in t:
if j%a[i][0]==0:
a[i].append(j)
d.remove(j)
#print(a)
for i in range (len(a)):
print(*a[i][1:],a[i][0],end=' ')
print()
print(0)
``` | instruction | 0 | 5,989 | 22 | 11,978 |
No | output | 1 | 5,989 | 22 | 11,979 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three integers a, b and c.
Find two positive integers x and y (x > 0, y > 0) such that:
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
gcd(x, y) denotes the [greatest common divisor (GCD)](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers x and y.
Output x and y. If there are multiple answers, output any of them.
Input
The first line contains a single integer t (1 β€ t β€ 285) β the number of testcases.
Each of the next t lines contains three integers a, b and c (1 β€ a, b β€ 9, 1 β€ c β€ min(a, b)) β the required lengths of the numbers.
It can be shown that the answer exists for all testcases under the given constraints.
Additional constraint on the input: all testcases are different.
Output
For each testcase print two positive integers β x and y (x > 0, y > 0) such that
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
Example
Input
4
2 3 1
2 2 2
6 6 2
1 1 1
Output
11 492
13 26
140133 160776
1 1
Note
In the example:
1. gcd(11, 492) = 1
2. gcd(13, 26) = 13
3. gcd(140133, 160776) = 21
4. gcd(1, 1) = 1 | instruction | 0 | 6,032 | 22 | 12,064 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
for t in range(int(input())):
a, b, c = map(int, input().split())
print("1" + "0" * (a - 1), "1" * (b - c + 1) + "0" * (c - 1))
``` | output | 1 | 6,032 | 22 | 12,065 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three integers a, b and c.
Find two positive integers x and y (x > 0, y > 0) such that:
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
gcd(x, y) denotes the [greatest common divisor (GCD)](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers x and y.
Output x and y. If there are multiple answers, output any of them.
Input
The first line contains a single integer t (1 β€ t β€ 285) β the number of testcases.
Each of the next t lines contains three integers a, b and c (1 β€ a, b β€ 9, 1 β€ c β€ min(a, b)) β the required lengths of the numbers.
It can be shown that the answer exists for all testcases under the given constraints.
Additional constraint on the input: all testcases are different.
Output
For each testcase print two positive integers β x and y (x > 0, y > 0) such that
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
Example
Input
4
2 3 1
2 2 2
6 6 2
1 1 1
Output
11 492
13 26
140133 160776
1 1
Note
In the example:
1. gcd(11, 492) = 1
2. gcd(13, 26) = 13
3. gcd(140133, 160776) = 21
4. gcd(1, 1) = 1 | instruction | 0 | 6,033 | 22 | 12,066 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
for _ in range(int(input())):
a, b, c = map(int, input().split())
g = 7
while len(str(g)) < c: g *= 7
assert len(str(g)) == c
x = g
y = g
while len(str(x)) < a: x *= 2
while len(str(y)) < b: y *= 3
assert len(str(x)) == a
assert len(str(y)) == b
print(x, y)
``` | output | 1 | 6,033 | 22 | 12,067 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three integers a, b and c.
Find two positive integers x and y (x > 0, y > 0) such that:
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
gcd(x, y) denotes the [greatest common divisor (GCD)](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers x and y.
Output x and y. If there are multiple answers, output any of them.
Input
The first line contains a single integer t (1 β€ t β€ 285) β the number of testcases.
Each of the next t lines contains three integers a, b and c (1 β€ a, b β€ 9, 1 β€ c β€ min(a, b)) β the required lengths of the numbers.
It can be shown that the answer exists for all testcases under the given constraints.
Additional constraint on the input: all testcases are different.
Output
For each testcase print two positive integers β x and y (x > 0, y > 0) such that
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
Example
Input
4
2 3 1
2 2 2
6 6 2
1 1 1
Output
11 492
13 26
140133 160776
1 1
Note
In the example:
1. gcd(11, 492) = 1
2. gcd(13, 26) = 13
3. gcd(140133, 160776) = 21
4. gcd(1, 1) = 1 | instruction | 0 | 6,034 | 22 | 12,068 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
T=int(input())
for t in range(T):
a,b,c=[int(i) for i in input().split()]
gcd=10**(c-1)
x=gcd
lim=10**(a-1)
while x<lim or x<gcd:
x*=2
y=gcd
lim=10**(b-1)
while y<lim or y<gcd:
y*=3
print(x,y)
``` | output | 1 | 6,034 | 22 | 12,069 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three integers a, b and c.
Find two positive integers x and y (x > 0, y > 0) such that:
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
gcd(x, y) denotes the [greatest common divisor (GCD)](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers x and y.
Output x and y. If there are multiple answers, output any of them.
Input
The first line contains a single integer t (1 β€ t β€ 285) β the number of testcases.
Each of the next t lines contains three integers a, b and c (1 β€ a, b β€ 9, 1 β€ c β€ min(a, b)) β the required lengths of the numbers.
It can be shown that the answer exists for all testcases under the given constraints.
Additional constraint on the input: all testcases are different.
Output
For each testcase print two positive integers β x and y (x > 0, y > 0) such that
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
Example
Input
4
2 3 1
2 2 2
6 6 2
1 1 1
Output
11 492
13 26
140133 160776
1 1
Note
In the example:
1. gcd(11, 492) = 1
2. gcd(13, 26) = 13
3. gcd(140133, 160776) = 21
4. gcd(1, 1) = 1 | instruction | 0 | 6,035 | 22 | 12,070 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
import time
#start_time = time.time()
#def TIME_(): print(time.time()-start_time)
import os, sys
from io import BytesIO, IOBase
from types import GeneratorType
from bisect import bisect_left, bisect_right
from collections import defaultdict as dd, deque as dq, Counter as dc
import math, string, heapq as h
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
self.os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def getInt(): return int(input())
def getStrs(): return input().split()
def getInts(): return list(map(int,input().split()))
def getStr(): return input()
def listStr(): return list(input())
def getMat(n): return [getInts() for _ in range(n)]
def getBin(): return list(map(int,list(input())))
def isInt(s): return '0' <= s[0] <= '9'
def ceil_(a,b): return a//b + (a%b > 0)
MOD = 10**9 + 7
"""
Start with number Z of C digits
"""
def solve():
A,B,C = getInts()
Z = 10**(C-1)
X = Z
Y = Z
while not len(str(X)) == A:
X *= 7
while not len(str(Y)) == B:
Y *= 3
print(X,Y)
return
for _ in range(getInt()):
#print(solve())
solve()
#TIME_()
``` | output | 1 | 6,035 | 22 | 12,071 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three integers a, b and c.
Find two positive integers x and y (x > 0, y > 0) such that:
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
gcd(x, y) denotes the [greatest common divisor (GCD)](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers x and y.
Output x and y. If there are multiple answers, output any of them.
Input
The first line contains a single integer t (1 β€ t β€ 285) β the number of testcases.
Each of the next t lines contains three integers a, b and c (1 β€ a, b β€ 9, 1 β€ c β€ min(a, b)) β the required lengths of the numbers.
It can be shown that the answer exists for all testcases under the given constraints.
Additional constraint on the input: all testcases are different.
Output
For each testcase print two positive integers β x and y (x > 0, y > 0) such that
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
Example
Input
4
2 3 1
2 2 2
6 6 2
1 1 1
Output
11 492
13 26
140133 160776
1 1
Note
In the example:
1. gcd(11, 492) = 1
2. gcd(13, 26) = 13
3. gcd(140133, 160776) = 21
4. gcd(1, 1) = 1 | instruction | 0 | 6,036 | 22 | 12,072 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
from sys import maxsize, stdout, stdin,stderr
mod = int(1e9 + 7)
def I(): return int(stdin.readline())
def lint(): return [int(x) for x in stdin.readline().split()]
def S(): return input().strip()
def grid(r, c): return [lint() for i in range(r)]
from collections import defaultdict
import math
l = [2,16,128,1024,16384,131072,1048576,16777216,134217728]
t = I()
for _ in range(t):
a,b,c= lint()
c-=1
c=l[c]
a1 = l[a-1]
b-=1
b1=c
while(b1/10**b<1):
b1*=3
print(a1,b1)
``` | output | 1 | 6,036 | 22 | 12,073 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three integers a, b and c.
Find two positive integers x and y (x > 0, y > 0) such that:
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
gcd(x, y) denotes the [greatest common divisor (GCD)](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers x and y.
Output x and y. If there are multiple answers, output any of them.
Input
The first line contains a single integer t (1 β€ t β€ 285) β the number of testcases.
Each of the next t lines contains three integers a, b and c (1 β€ a, b β€ 9, 1 β€ c β€ min(a, b)) β the required lengths of the numbers.
It can be shown that the answer exists for all testcases under the given constraints.
Additional constraint on the input: all testcases are different.
Output
For each testcase print two positive integers β x and y (x > 0, y > 0) such that
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
Example
Input
4
2 3 1
2 2 2
6 6 2
1 1 1
Output
11 492
13 26
140133 160776
1 1
Note
In the example:
1. gcd(11, 492) = 1
2. gcd(13, 26) = 13
3. gcd(140133, 160776) = 21
4. gcd(1, 1) = 1 | instruction | 0 | 6,037 | 22 | 12,074 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
t = int(input())
for _ in range(t):
a,b,c = map(int, input().split())
a = a-1
b = b-1
c = c-1
x = 10**a
y = (10**b) + (10**c)
print(x,y)
``` | output | 1 | 6,037 | 22 | 12,075 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three integers a, b and c.
Find two positive integers x and y (x > 0, y > 0) such that:
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
gcd(x, y) denotes the [greatest common divisor (GCD)](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers x and y.
Output x and y. If there are multiple answers, output any of them.
Input
The first line contains a single integer t (1 β€ t β€ 285) β the number of testcases.
Each of the next t lines contains three integers a, b and c (1 β€ a, b β€ 9, 1 β€ c β€ min(a, b)) β the required lengths of the numbers.
It can be shown that the answer exists for all testcases under the given constraints.
Additional constraint on the input: all testcases are different.
Output
For each testcase print two positive integers β x and y (x > 0, y > 0) such that
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
Example
Input
4
2 3 1
2 2 2
6 6 2
1 1 1
Output
11 492
13 26
140133 160776
1 1
Note
In the example:
1. gcd(11, 492) = 1
2. gcd(13, 26) = 13
3. gcd(140133, 160776) = 21
4. gcd(1, 1) = 1 | instruction | 0 | 6,038 | 22 | 12,076 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
import os
from io import BytesIO, IOBase
import sys
import math
def main():
for i in range(int(input())):
a,b,c=map(int,input().split())
a1=1
b1=1
c1=1
while len(str(c1))<c:
c1=c1*2
a1=a1*2
b1=b1*2
while len(str(b1))<b:
b1=b1*5
while len(str(a1))<a:
a1=a1*3
print(a1,b1)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | output | 1 | 6,038 | 22 | 12,077 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three integers a, b and c.
Find two positive integers x and y (x > 0, y > 0) such that:
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
gcd(x, y) denotes the [greatest common divisor (GCD)](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers x and y.
Output x and y. If there are multiple answers, output any of them.
Input
The first line contains a single integer t (1 β€ t β€ 285) β the number of testcases.
Each of the next t lines contains three integers a, b and c (1 β€ a, b β€ 9, 1 β€ c β€ min(a, b)) β the required lengths of the numbers.
It can be shown that the answer exists for all testcases under the given constraints.
Additional constraint on the input: all testcases are different.
Output
For each testcase print two positive integers β x and y (x > 0, y > 0) such that
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
Example
Input
4
2 3 1
2 2 2
6 6 2
1 1 1
Output
11 492
13 26
140133 160776
1 1
Note
In the example:
1. gcd(11, 492) = 1
2. gcd(13, 26) = 13
3. gcd(140133, 160776) = 21
4. gcd(1, 1) = 1 | instruction | 0 | 6,039 | 22 | 12,078 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
#rOkY
#FuCk
############################### kOpAl ##################################
t=int(input())
while(t>0):
a,b,c=map(int,input().split())
x=1
y=1
while(len(str(x))!=c):
if(len(str(x))==c):
break
x*=2
y*=2
while(len(str(x))!=a):
if(len(str(x))==a):
break
x*=3
while(len(str(y))!=b):
if(len(str(y))==b):
break
y*=5
print(x,y)
t-=1
``` | output | 1 | 6,039 | 22 | 12,079 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three integers a, b and c.
Find two positive integers x and y (x > 0, y > 0) such that:
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
gcd(x, y) denotes the [greatest common divisor (GCD)](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers x and y.
Output x and y. If there are multiple answers, output any of them.
Input
The first line contains a single integer t (1 β€ t β€ 285) β the number of testcases.
Each of the next t lines contains three integers a, b and c (1 β€ a, b β€ 9, 1 β€ c β€ min(a, b)) β the required lengths of the numbers.
It can be shown that the answer exists for all testcases under the given constraints.
Additional constraint on the input: all testcases are different.
Output
For each testcase print two positive integers β x and y (x > 0, y > 0) such that
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
Example
Input
4
2 3 1
2 2 2
6 6 2
1 1 1
Output
11 492
13 26
140133 160776
1 1
Note
In the example:
1. gcd(11, 492) = 1
2. gcd(13, 26) = 13
3. gcd(140133, 160776) = 21
4. gcd(1, 1) = 1
Submitted Solution:
```
from math import gcd
def solve():
a, b, c = map(int, input().split())
print(*res[a - 1][b - 1][c - 1])
if __name__ == '__main__':
res = [[[[2, 2], [11, 11], [101, 101], [1009, 1009], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[2, 10], [11, 11], [101, 101], [1009, 1009], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[2, 100], [11, 110], [101, 101], [1009, 1009], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[2, 1000], [11, 1001], [101, 1010], [1009, 1009], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[2, 10000], [11, 10010], [101, 10100], [1009, 10090], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[2, 100000], [11, 100001], [101, 100091], [1009, 100900], [10007, 100070], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[2, 1000000], [11, 1000010], [101, 1000001], [1009, 1000928], [10007, 1000700], [100003, 1000030], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[2, 10000000], [11, 10000001], [101, 10000010], [1009, 10000199], [10007, 10007000], [100003, 10000300], [1000033, 10000330], [10000019, 10000019], [100000007, 100000007]], [[2, 100000000], [11, 100000010], [101, 100000100], [1009, 100000981], [10007, 100009958], [100003, 100003000], [1000033, 100003300], [10000019, 100000190], [100000007, 100000007]]], [[[10, 2], [11, 11], [101, 101], [1009, 1009], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[10, 12], [11, 11], [101, 101], [1009, 1009], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[10, 102], [11, 110], [101, 101], [1009, 1009], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[10, 1002], [11, 1001], [101, 1010], [1009, 1009], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[10, 10002], [11, 10010], [101, 10100], [1009, 10090], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[10, 100002], [11, 100001], [101, 100091], [1009, 100900], [10007, 100070], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[10, 1000002], [11, 1000010], [101, 1000001], [1009, 1000928], [10007, 1000700], [100003, 1000030], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[10, 10000002], [11, 10000001], [101, 10000010], [1009, 10000199], [10007, 10007000], [100003, 10000300], [1000033, 10000330], [10000019, 10000019], [100000007, 100000007]], [[10, 100000002], [11, 100000010], [101, 100000100], [1009, 100000981], [10007, 100009958], [100003, 100003000], [1000033, 100003300], [10000019, 100000190], [100000007, 100000007]]], [[[100, 2], [110, 11], [101, 101], [1009, 1009], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[100, 14], [110, 11], [101, 101], [1009, 1009], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[100, 102], [110, 121], [101, 101], [1009, 1009], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[100, 1002], [110, 1001], [101, 1010], [1009, 1009], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[100, 10002], [110, 10021], [101, 10100], [1009, 10090], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[100, 100002], [110, 100001], [101, 100091], [1009, 100900], [10007, 100070], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[100, 1000002], [110, 1000021], [101, 1000001], [1009, 1000928], [10007, 1000700], [100003, 1000030], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[100, 10000002], [110, 10000001], [101, 10000010], [1009, 10000199], [10007, 10007000], [100003, 10000300], [1000033, 10000330], [10000019, 10000019], [100000007, 100000007]], [[100, 100000002], [110, 100000021], [101, 100000100], [1009, 100000981], [10007, 100009958], [100003, 100003000], [1000033, 100003300], [10000019, 100000190], [100000007, 100000007]]], [[[1000, 2], [1001, 11], [1010, 101], [1009, 1009], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[1000, 14], [1001, 11], [1010, 101], [1009, 1009], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[1000, 102], [1001, 110], [1010, 101], [1009, 1009], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[1000, 1002], [1001, 1012], [1010, 1111], [1009, 1009], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[1000, 10002], [1001, 10021], [1010, 10201], [1009, 10090], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[1000, 100002], [1001, 100001], [1010, 100091], [1009, 100900], [10007, 100070], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[1000, 1000002], [1001, 1000010], [1010, 1000001], [1009, 1000928], [10007, 1000700], [100003, 1000030], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[1000, 10000002], [1001, 10000001], [1010, 10000111], [1009, 10000199], [10007, 10007000], [100003, 10000300], [1000033, 10000330], [10000019, 10000019], [100000007, 100000007]], [[1000, 100000002], [1001, 100000010], [1010, 100000201], [1009, 100000981], [10007, 100009958], [100003, 100003000], [1000033, 100003300], [10000019, 100000190], [100000007, 100000007]]], [[[10000, 2], [10010, 11], [10100, 101], [10090, 1009], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[10000, 14], [10010, 11], [10100, 101], [10090, 1009], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[10000, 102], [10010, 121], [10100, 101], [10090, 1009], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[10000, 1002], [10010, 1023], [10100, 1111], [10090, 1009], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[10000, 10002], [10010, 10021], [10100, 10201], [10090, 11099], [10007, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[10000, 100002], [10010, 100001], [10100, 100091], [10090, 101909], [10007, 100070], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[10000, 1000002], [10010, 1000021], [10100, 1000001], [10090, 1001937], [10007, 1000700], [100003, 1000030], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[10000, 10000002], [10010, 10000001], [10100, 10000111], [10090, 10000199], [10007, 10007000], [100003, 10000300], [1000033, 10000330], [10000019, 10000019], [100000007, 100000007]], [[10000, 100000002], [10010, 100000021], [10100, 100000201], [10090, 100000981], [10007, 100009958], [100003, 100003000], [1000033, 100003300], [10000019, 100000190], [100000007, 100000007]]], [[[100000, 2], [100001, 11], [100091, 101], [100900, 1009], [100070, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[100000, 14], [100001, 11], [100091, 101], [100900, 1009], [100070, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[100000, 102], [100001, 110], [100091, 101], [100900, 1009], [100070, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[100000, 1002], [100001, 1001], [100091, 1010], [100900, 1009], [100070, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[100000, 10002], [100001, 10010], [100091, 10100], [100900, 11099], [100070, 10007], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[100000, 100002], [100001, 100012], [100091, 100192], [100900, 101909], [100070, 110077], [100003, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[100000, 1000002], [100001, 1000021], [100091, 1000001], [100900, 1001937], [100070, 1010707], [100003, 1000030], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[100000, 10000002], [100001, 10000001], [100091, 10000010], [100900, 10000199], [100070, 10017007], [100003, 10000300], [1000033, 10000330], [10000019, 10000019], [100000007, 100000007]], [[100000, 100000002], [100001, 100000010], [100091, 100000100], [100900, 100000981], [100070, 100039979], [100003, 100003000], [1000033, 100003300], [10000019, 100000190], [100000007, 100000007]]], [[[1000000, 2], [1000010, 11], [1000001, 101], [1000928, 1009], [1000700, 10007], [1000030, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[1000000, 14], [1000010, 11], [1000001, 101], [1000928, 1009], [1000700, 10007], [1000030, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[1000000, 102], [1000010, 121], [1000001, 101], [1000928, 1009], [1000700, 10007], [1000030, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[1000000, 1002], [1000010, 1001], [1000001, 1010], [1000928, 1009], [1000700, 10007], [1000030, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[1000000, 10002], [1000010, 10021], [1000001, 10100], [1000928, 11099], [1000700, 10007], [1000030, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[1000000, 100002], [1000010, 100023], [1000001, 100091], [1000928, 101909], [1000700, 110077], [1000030, 100003], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[1000000, 1000002], [1000010, 1000021], [1000001, 1000102], [1000928, 1001937], [1000700, 1010707], [1000030, 1100033], [1000033, 1000033], [10000019, 10000019], [100000007, 100000007]], [[1000000, 10000002], [1000010, 10000001], [1000001, 10000111], [1000928, 10000199], [1000700, 10017007], [1000030, 10100303], [1000033, 10000330], [10000019, 10000019], [100000007, 100000007]], [[1000000, 100000002], [1000010, 100000021], [1000001, 100000201], [1000928, 100000981], [1000700, 100039979], [1000030, 100103003], [1000033, 100003300], [10000019, 100000190], [100000007, 100000007]]], [[[10000000, 2], [10000001, 11], [10000010, 101], [10000199, 1009], [10007000, 10007], [10000300, 100003], [10000330, 1000033], [10000019, 10000019], [100000007, 100000007]], [[10000000, 14], [10000001, 11], [10000010, 101], [10000199, 1009], [10007000, 10007], [10000300, 100003], [10000330, 1000033], [10000019, 10000019], [100000007, 100000007]], [[10000000, 102], [10000001, 110], [10000010, 101], [10000199, 1009], [10007000, 10007], [10000300, 100003], [10000330, 1000033], [10000019, 10000019], [100000007, 100000007]], [[10000000, 1002], [10000001, 1001], [10000010, 1111], [10000199, 1009], [10007000, 10007], [10000300, 100003], [10000330, 1000033], [10000019, 10000019], [100000007, 100000007]], [[10000000, 10002], [10000001, 10010], [10000010, 10201], [10000199, 10090], [10007000, 10007], [10000300, 100003], [10000330, 1000033], [10000019, 10000019], [100000007, 100000007]], [[10000000, 100002], [10000001, 100001], [10000010, 100091], [10000199, 100900], [10007000, 110077], [10000300, 100003], [10000330, 1000033], [10000019, 10000019], [100000007, 100000007]], [[10000000, 1000002], [10000001, 1000010], [10000010, 1000203], [10000199, 1000928], [10007000, 1010707], [10000300, 1100033], [10000330, 1000033], [10000019, 10000019], [100000007, 100000007]], [[10000000, 10000002], [10000001, 10000012], [10000010, 10000111], [10000199, 10001208], [10007000, 10017007], [10000300, 10100303], [10000330, 11000363], [10000019, 10000019], [100000007, 100000007]], [[10000000, 100000002], [10000001, 100000021], [10000010, 100000201], [10000199, 100000981], [10007000, 100039979], [10000300, 100103003], [10000330, 101003333], [10000019, 100000190], [100000007, 100000007]]], [[[100000000, 2], [100000010, 11], [100000100, 101], [100000981, 1009], [100009958, 10007], [100003000, 100003], [100003300, 1000033], [100000190, 10000019], [100000007, 100000007]], [[100000000, 14], [100000010, 11], [100000100, 101], [100000981, 1009], [100009958, 10007], [100003000, 100003], [100003300, 1000033], [100000190, 10000019], [100000007, 100000007]], [[100000000, 102], [100000010, 121], [100000100, 101], [100000981, 1009], [100009958, 10007], [100003000, 100003], [100003300, 1000033], [100000190, 10000019], [100000007, 100000007]], [[100000000, 1002], [100000010, 1001], [100000100, 1111], [100000981, 1009], [100009958, 10007], [100003000, 100003], [100003300, 1000033], [100000190, 10000019], [100000007, 100000007]], [[100000000, 10002], [100000010, 10021], [100000100, 10201], [100000981, 10090], [100009958, 10007], [100003000, 100003], [100003300, 1000033], [100000190, 10000019], [100000007, 100000007]], [[100000000, 100002], [100000010, 100001], [100000100, 100091], [100000981, 100900], [100009958, 110077], [100003000, 100003], [100003300, 1000033], [100000190, 10000019], [100000007, 100000007]], [[100000000, 1000002], [100000010, 1000021], [100000100, 1000203], [100000981, 1000928], [100009958, 1010707], [100003000, 1100033], [100003300, 1000033], [100000190, 10000019], [100000007, 100000007]], [[100000000, 10000002], [100000010, 10000023], [100000100, 10000111], [100000981, 10000199], [100009958, 10017007], [100003000, 10100303], [100003300, 11000363], [100000190, 10000019], [100000007, 100000007]], [[100000000, 100000002], [100000010, 100000021], [100000100, 100000201], [100000981, 100001990], [100009958, 100019965], [100003000, 100103003], [100003300, 101003333], [100000190, 110000209], [100000007, 100000007]]]]
t = int(input())
for _ in range(t):
solve()
``` | instruction | 0 | 6,040 | 22 | 12,080 |
Yes | output | 1 | 6,040 | 22 | 12,081 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three integers a, b and c.
Find two positive integers x and y (x > 0, y > 0) such that:
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
gcd(x, y) denotes the [greatest common divisor (GCD)](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers x and y.
Output x and y. If there are multiple answers, output any of them.
Input
The first line contains a single integer t (1 β€ t β€ 285) β the number of testcases.
Each of the next t lines contains three integers a, b and c (1 β€ a, b β€ 9, 1 β€ c β€ min(a, b)) β the required lengths of the numbers.
It can be shown that the answer exists for all testcases under the given constraints.
Additional constraint on the input: all testcases are different.
Output
For each testcase print two positive integers β x and y (x > 0, y > 0) such that
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
Example
Input
4
2 3 1
2 2 2
6 6 2
1 1 1
Output
11 492
13 26
140133 160776
1 1
Note
In the example:
1. gcd(11, 492) = 1
2. gcd(13, 26) = 13
3. gcd(140133, 160776) = 21
4. gcd(1, 1) = 1
Submitted Solution:
```
#print("/sys/devices/pci0000:00/0000:00:01.0/0000:02:00.0/drm/card0/card0-LVDS-1/radeon_bl0$ sudo nano brightness")
for _ in range(int(input())):
a,b,c=map(int,input().split())
print(10**(a-1)+10**(c-1),10**(b-1))
``` | instruction | 0 | 6,041 | 22 | 12,082 |
Yes | output | 1 | 6,041 | 22 | 12,083 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three integers a, b and c.
Find two positive integers x and y (x > 0, y > 0) such that:
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
gcd(x, y) denotes the [greatest common divisor (GCD)](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers x and y.
Output x and y. If there are multiple answers, output any of them.
Input
The first line contains a single integer t (1 β€ t β€ 285) β the number of testcases.
Each of the next t lines contains three integers a, b and c (1 β€ a, b β€ 9, 1 β€ c β€ min(a, b)) β the required lengths of the numbers.
It can be shown that the answer exists for all testcases under the given constraints.
Additional constraint on the input: all testcases are different.
Output
For each testcase print two positive integers β x and y (x > 0, y > 0) such that
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
Example
Input
4
2 3 1
2 2 2
6 6 2
1 1 1
Output
11 492
13 26
140133 160776
1 1
Note
In the example:
1. gcd(11, 492) = 1
2. gcd(13, 26) = 13
3. gcd(140133, 160776) = 21
4. gcd(1, 1) = 1
Submitted Solution:
```
import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int,sys.stdin.readline().rstrip().split())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI2(): return list(map(int,sys.stdin.readline().rstrip()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def LS2(): return list(sys.stdin.readline().rstrip())
t = I()
for _ in range(t):
a,b,c = MI()
if a >= b:
x = 10**(a-1)+10**(c-1)
y = 10**(b-1)
else:
x = 10**(a-1)
y = 10**(b-1)+10**(c-1)
print(x,y)
``` | instruction | 0 | 6,042 | 22 | 12,084 |
Yes | output | 1 | 6,042 | 22 | 12,085 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three integers a, b and c.
Find two positive integers x and y (x > 0, y > 0) such that:
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
gcd(x, y) denotes the [greatest common divisor (GCD)](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers x and y.
Output x and y. If there are multiple answers, output any of them.
Input
The first line contains a single integer t (1 β€ t β€ 285) β the number of testcases.
Each of the next t lines contains three integers a, b and c (1 β€ a, b β€ 9, 1 β€ c β€ min(a, b)) β the required lengths of the numbers.
It can be shown that the answer exists for all testcases under the given constraints.
Additional constraint on the input: all testcases are different.
Output
For each testcase print two positive integers β x and y (x > 0, y > 0) such that
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
Example
Input
4
2 3 1
2 2 2
6 6 2
1 1 1
Output
11 492
13 26
140133 160776
1 1
Note
In the example:
1. gcd(11, 492) = 1
2. gcd(13, 26) = 13
3. gcd(140133, 160776) = 21
4. gcd(1, 1) = 1
Submitted Solution:
```
from math import gcd as g
t = int(input())
for i in range(t):
a, b, c = list(map(int, input().split()))
am = 10 ** a - 1
bm = 10 ** b - 1
cm = 10 ** c - 1
ax = 10 ** (a - 1)
bx = 10 ** (b - 1)
cx = 10 ** (c - 1)
m = 0
if a == b and b == c: print(am, bm)
elif c == 1:
if a > b: print(bm*(10 ** (a - b)) + 1, bm)
elif b > a: print(am, am * (10 ** (b -a)) + 1)
else: print (am, am - 1)
else:
if a > b:
if b != c: print(ax, bx + cx)
else: print(ax, bx)
else:
if a != c: print(ax + cx, bx)
else: print(ax, bx)
``` | instruction | 0 | 6,043 | 22 | 12,086 |
Yes | output | 1 | 6,043 | 22 | 12,087 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three integers a, b and c.
Find two positive integers x and y (x > 0, y > 0) such that:
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
gcd(x, y) denotes the [greatest common divisor (GCD)](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers x and y.
Output x and y. If there are multiple answers, output any of them.
Input
The first line contains a single integer t (1 β€ t β€ 285) β the number of testcases.
Each of the next t lines contains three integers a, b and c (1 β€ a, b β€ 9, 1 β€ c β€ min(a, b)) β the required lengths of the numbers.
It can be shown that the answer exists for all testcases under the given constraints.
Additional constraint on the input: all testcases are different.
Output
For each testcase print two positive integers β x and y (x > 0, y > 0) such that
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
Example
Input
4
2 3 1
2 2 2
6 6 2
1 1 1
Output
11 492
13 26
140133 160776
1 1
Note
In the example:
1. gcd(11, 492) = 1
2. gcd(13, 26) = 13
3. gcd(140133, 160776) = 21
4. gcd(1, 1) = 1
Submitted Solution:
```
t = int(input())
for _ in range(t):
a,b,c = list(map(int,input().strip().split()))
x,y,z = 0,0,0
c -= 1
z = 10**c
primes = {1:[3,5],2:[11,13],3:[151,163],4:[1064,1069],5:[10009,10039],6:[947711,947263],7:[1777771,5164541],8:[12815137,12830327],9:[10000019,10000169]}
x = primes[(a-c)][0]*z
y = primes[(b-c)][1]*z
print(x,y)
1 - 0,1
2 - 2,3
3 - 4,5
4 - 6,7
6 - 8,9
``` | instruction | 0 | 6,044 | 22 | 12,088 |
No | output | 1 | 6,044 | 22 | 12,089 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three integers a, b and c.
Find two positive integers x and y (x > 0, y > 0) such that:
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
gcd(x, y) denotes the [greatest common divisor (GCD)](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers x and y.
Output x and y. If there are multiple answers, output any of them.
Input
The first line contains a single integer t (1 β€ t β€ 285) β the number of testcases.
Each of the next t lines contains three integers a, b and c (1 β€ a, b β€ 9, 1 β€ c β€ min(a, b)) β the required lengths of the numbers.
It can be shown that the answer exists for all testcases under the given constraints.
Additional constraint on the input: all testcases are different.
Output
For each testcase print two positive integers β x and y (x > 0, y > 0) such that
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
Example
Input
4
2 3 1
2 2 2
6 6 2
1 1 1
Output
11 492
13 26
140133 160776
1 1
Note
In the example:
1. gcd(11, 492) = 1
2. gcd(13, 26) = 13
3. gcd(140133, 160776) = 21
4. gcd(1, 1) = 1
Submitted Solution:
```
import math as m
for _ in range(int(input())):
a,b,c=map(int,input().split())
x=(10**(a-c-1)+1)*(10**c)
y=(10**(b-c-1)+2)*(10**c)
print(x,y)
``` | instruction | 0 | 6,045 | 22 | 12,090 |
No | output | 1 | 6,045 | 22 | 12,091 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three integers a, b and c.
Find two positive integers x and y (x > 0, y > 0) such that:
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
gcd(x, y) denotes the [greatest common divisor (GCD)](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers x and y.
Output x and y. If there are multiple answers, output any of them.
Input
The first line contains a single integer t (1 β€ t β€ 285) β the number of testcases.
Each of the next t lines contains three integers a, b and c (1 β€ a, b β€ 9, 1 β€ c β€ min(a, b)) β the required lengths of the numbers.
It can be shown that the answer exists for all testcases under the given constraints.
Additional constraint on the input: all testcases are different.
Output
For each testcase print two positive integers β x and y (x > 0, y > 0) such that
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
Example
Input
4
2 3 1
2 2 2
6 6 2
1 1 1
Output
11 492
13 26
140133 160776
1 1
Note
In the example:
1. gcd(11, 492) = 1
2. gcd(13, 26) = 13
3. gcd(140133, 160776) = 21
4. gcd(1, 1) = 1
Submitted Solution:
```
t = int(input())
for __ in range(t):
a,b,c = map(int,input().split())
aa = [1]*a
ab = [1]*b
ans = 1
aa = aa[:len(aa)-c+1] + [0]*(c-1)
ab = ab[:len(ab)-c+1] + [0]*(c-1)
for j in range(len(aa)-1,-1,-1):
if aa[j]==1:
aa[j] = ans
ans+=1
ans = 2
for j in range(len(ab)-1,-1,-1):
if ab[j]==1:
ab[j] = ans
ans+=1
print(*aa," ",*ab,sep="")
``` | instruction | 0 | 6,046 | 22 | 12,092 |
No | output | 1 | 6,046 | 22 | 12,093 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three integers a, b and c.
Find two positive integers x and y (x > 0, y > 0) such that:
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
gcd(x, y) denotes the [greatest common divisor (GCD)](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers x and y.
Output x and y. If there are multiple answers, output any of them.
Input
The first line contains a single integer t (1 β€ t β€ 285) β the number of testcases.
Each of the next t lines contains three integers a, b and c (1 β€ a, b β€ 9, 1 β€ c β€ min(a, b)) β the required lengths of the numbers.
It can be shown that the answer exists for all testcases under the given constraints.
Additional constraint on the input: all testcases are different.
Output
For each testcase print two positive integers β x and y (x > 0, y > 0) such that
* the decimal representation of x without leading zeroes consists of a digits;
* the decimal representation of y without leading zeroes consists of b digits;
* the decimal representation of gcd(x, y) without leading zeroes consists of c digits.
Example
Input
4
2 3 1
2 2 2
6 6 2
1 1 1
Output
11 492
13 26
140133 160776
1 1
Note
In the example:
1. gcd(11, 492) = 1
2. gcd(13, 26) = 13
3. gcd(140133, 160776) = 21
4. gcd(1, 1) = 1
Submitted Solution:
```
M=\
{(1, 1, 1): (3,3),
(1, 2, 1): (3,11),
(1, 3, 1): (3,101),
(1, 4, 1): (3,1009),
(1, 5, 1): (3,10007),
(1, 6, 1): (3,100003),
(1, 7, 1): (3,1000003),
(1, 8, 1): (3,10000019),
(1, 9, 1): (3,100000007),
(2, 1, 1): (11,3),
(2, 2, 1): (11,11),
(2, 2, 2): (22,11),
(2, 3, 1): (11,101),
(2, 3, 2): (22,297),
(2, 4, 1): (11,1009),
(2, 4, 2): (22,2673),
(2, 5, 1): (11,10007),
(2, 5, 2): (22,24057),
(2, 6, 1): (11,100003),
(2, 6, 2): (22,216513),
(2, 7, 1): (11,1000003),
(2, 7, 2): (22,1948617),
(2, 8, 1): (11,10000019),
(2, 8, 2): (22,17537553),
(2, 9, 1): (11,100000007),
(2, 9, 2): (22,157837977),
(3, 1, 1): (101,3),
(3, 2, 1): (101,11),
(3, 2, 2): (220,11),
(3, 3, 1): (101,101),
(3, 3, 2): (220,297),
(3, 3, 3): (202,101),
(3, 4, 1): (101,1009),
(3, 4, 2): (220,2673),
(3, 4, 3): (202,2727),
(3, 5, 1): (101,10007),
(3, 5, 2): (220,24057),
(3, 5, 3): (202,24543),
(3, 6, 1): (101,100003),
(3, 6, 2): (220,216513),
(3, 6, 3): (202,220887),
(3, 7, 1): (101,1000003),
(3, 7, 2): (220,1948617),
(3, 7, 3): (202,1987983),
(3, 8, 1): (101,10000019),
(3, 8, 2): (220,17537553),
(3, 8, 3): (202,17891847),
(3, 9, 1): (101,100000007),
(3, 9, 2): (220,157837977),
(3, 9, 3): (202,161026623),
(4, 1, 1): (1009,3),
(4, 2, 1): (1009,11),
(4, 2, 2): (2200,11),
(4, 3, 1): (1009,101),
(4, 3, 2): (2200,297),
(4, 3, 3): (2020,101),
(4, 4, 1): (1009,1009),
(4, 4, 2): (2200,2673),
(4, 4, 3): (2020,2727),
(4, 4, 4): (2018,1009),
(4, 5, 1): (1009,10007),
(4, 5, 2): (2200,24057),
(4, 5, 3): (2020,24543),
(4, 5, 4): (2018,27243),
(4, 6, 1): (1009,100003),
(4, 6, 2): (2200,216513),
(4, 6, 3): (2020,220887),
(4, 6, 4): (2018,245187),
(4, 7, 1): (1009,1000003),
(4, 7, 2): (2200,1948617),
(4, 7, 3): (2020,1987983),
(4, 7, 4): (2018,2206683),
(4, 8, 1): (1009,10000019),
(4, 8, 2): (2200,17537553),
(4, 8, 3): (2020,17891847),
(4, 8, 4): (2018,19860147),
(4, 9, 1): (1009,100000007),
(4, 9, 2): (2200,157837977),
(4, 9, 3): (2020,161026623),
(4, 9, 4): (2018,178741323),
(5, 1, 1): (10007,3),
(5, 2, 1): (10007,11),
(5, 2, 2): (22000,11),
(5, 3, 1): (10007,101),
(5, 3, 2): (22000,297),
(5, 3, 3): (20200,101),
(5, 4, 1): (10007,1009),
(5, 4, 2): (22000,2673),
(5, 4, 3): (20200,2727),
(5, 4, 4): (20180,1009),
(5, 5, 1): (10007,10007),
(5, 5, 2): (22000,24057),
(5, 5, 3): (20200,24543),
(5, 5, 4): (20180,27243),
(5, 5, 5): (20014,10007),
(5, 6, 1): (10007,100003),
(5, 6, 2): (22000,216513),
(5, 6, 3): (20200,220887),
(5, 6, 4): (20180,245187),
(5, 6, 5): (20014,270189),
(5, 7, 1): (10007,1000003),
(5, 7, 2): (22000,1948617),
(5, 7, 3): (20200,1987983),
(5, 7, 4): (20180,2206683),
(5, 7, 5): (20014,2431701),
(5, 8, 1): (10007,10000019),
(5, 8, 2): (22000,17537553),
(5, 8, 3): (20200,17891847),
(5, 8, 4): (20180,19860147),
(5, 8, 5): (20014,21885309),
(5, 9, 1): (10007,100000007),
(5, 9, 2): (22000,157837977),
(5, 9, 3): (20200,161026623),
(5, 9, 4): (20180,178741323),
(5, 9, 5): (20014,196967781),
(6, 1, 1): (100003,3),
(6, 2, 1): (100003,11),
(6, 2, 2): (220000,11),
(6, 3, 1): (100003,101),
(6, 3, 2): (220000,297),
(6, 3, 3): (202000,101),
(6, 4, 1): (100003,1009),
(6, 4, 2): (220000,2673),
(6, 4, 3): (202000,2727),
(6, 4, 4): (201800,1009),
(6, 5, 1): (100003,10007),
(6, 5, 2): (220000,24057),
(6, 5, 3): (202000,24543),
(6, 5, 4): (201800,27243),
(6, 5, 5): (200140,10007),
(6, 6, 1): (100003,100003),
(6, 6, 2): (220000,216513),
(6, 6, 3): (202000,220887),
(6, 6, 4): (201800,245187),
(6, 6, 5): (200140,270189),
(6, 6, 6): (200006,100003),
(6, 7, 1): (100003,1000003),
(6, 7, 2): (220000,1948617),
(6, 7, 3): (202000,1987983),
(6, 7, 4): (201800,2206683),
(6, 7, 5): (200140,2431701),
(6, 7, 6): (200006,2700081),
(6, 8, 1): (100003,10000019),
(6, 8, 2): (220000,17537553),
(6, 8, 3): (202000,17891847),
(6, 8, 4): (201800,19860147),
(6, 8, 5): (200140,21885309),
(6, 8, 6): (200006,24300729),
(6, 9, 1): (100003,100000007),
(6, 9, 2): (220000,157837977),
(6, 9, 3): (202000,161026623),
(6, 9, 4): (201800,178741323),
(6, 9, 5): (200140,196967781),
(6, 9, 6): (200006,218706561),
(7, 1, 1): (1000003,3),
(7, 2, 1): (1000003,11),
(7, 2, 2): (2200000,11),
(7, 3, 1): (1000003,101),
(7, 3, 2): (2200000,297),
(7, 3, 3): (2020000,101),
(7, 4, 1): (1000003,1009),
(7, 4, 2): (2200000,2673),
(7, 4, 3): (2020000,2727),
(7, 4, 4): (2018000,1009),
(7, 5, 1): (1000003,10007),
(7, 5, 2): (2200000,24057),
(7, 5, 3): (2020000,24543),
(7, 5, 4): (2018000,27243),
(7, 5, 5): (2001400,10007),
(7, 6, 1): (1000003,100003),
(7, 6, 2): (2200000,216513),
(7, 6, 3): (2020000,220887),
(7, 6, 4): (2018000,245187),
(7, 6, 5): (2001400,270189),
(7, 6, 6): (2000060,100003),
(7, 7, 1): (1000003,1000003),
(7, 7, 2): (2200000,1948617),
(7, 7, 3): (2020000,1987983),
(7, 7, 4): (2018000,2206683),
(7, 7, 5): (2001400,2431701),
(7, 7, 6): (2000060,2700081),
(7, 7, 7): (2000006,1000003),
(7, 8, 1): (1000003,10000019),
(7, 8, 2): (2200000,17537553),
(7, 8, 3): (2020000,17891847),
(7, 8, 4): (2018000,19860147),
(7, 8, 5): (2001400,21885309),
(7, 8, 6): (2000060,24300729),
(7, 8, 7): (2000006,27000081),
(7, 9, 1): (1000003,100000007),
(7, 9, 2): (2200000,157837977),
(7, 9, 3): (2020000,161026623),
(7, 9, 4): (2018000,178741323),
(7, 9, 5): (2001400,196967781),
(7, 9, 6): (2000060,218706561),
(7, 9, 7): (2000006,243000729),
(8, 1, 1): (10000019,3),
(8, 2, 1): (10000019,11),
(8, 2, 2): (22000000,11),
(8, 3, 1): (10000019,101),
(8, 3, 2): (22000000,297),
(8, 3, 3): (20200000,101),
(8, 4, 1): (10000019,1009),
(8, 4, 2): (22000000,2673),
(8, 4, 3): (20200000,2727),
(8, 4, 4): (20180000,1009),
(8, 5, 1): (10000019,10007),
(8, 5, 2): (22000000,24057),
(8, 5, 3): (20200000,24543),
(8, 5, 4): (20180000,27243),
(8, 5, 5): (20014000,10007),
(8, 6, 1): (10000019,100003),
(8, 6, 2): (22000000,216513),
(8, 6, 3): (20200000,220887),
(8, 6, 4): (20180000,245187),
(8, 6, 5): (20014000,270189),
(8, 6, 6): (20000600,100003),
(8, 7, 1): (10000019,1000003),
(8, 7, 2): (22000000,1948617),
(8, 7, 3): (20200000,1987983),
(8, 7, 4): (20180000,2206683),
(8, 7, 5): (20014000,2431701),
(8, 7, 6): (20000600,2700081),
(8, 7, 7): (20000060,1000003),
(8, 8, 1): (10000019,10000019),
(8, 8, 2): (22000000,17537553),
(8, 8, 3): (20200000,17891847),
(8, 8, 4): (20180000,19860147),
(8, 8, 5): (20014000,21885309),
(8, 8, 6): (20000600,24300729),
(8, 8, 7): (20000060,27000081),
(8, 8, 8): (20000038,10000019),
(8, 9, 1): (10000019,100000007),
(8, 9, 2): (22000000,157837977),
(8, 9, 3): (20200000,161026623),
(8, 9, 4): (20180000,178741323),
(8, 9, 5): (20014000,196967781),
(8, 9, 6): (20000600,218706561),
(8, 9, 7): (20000060,243000729),
(8, 9, 8): (20000038,270000513),
(9, 1, 1): (100000007,3),
(9, 2, 1): (100000007,11),
(9, 2, 2): (220000000,11),
(9, 3, 1): (100000007,101),
(9, 3, 2): (220000000,297),
(9, 3, 3): (202000000,101),
(9, 4, 1): (100000007,1009),
(9, 4, 2): (220000000,2673),
(9, 4, 3): (202000000,2727),
(9, 4, 4): (201800000,1009),
(9, 5, 1): (100000007,10007),
(9, 5, 2): (220000000,24057),
(9, 5, 3): (202000000,24543),
(9, 5, 4): (201800000,27243),
(9, 5, 5): (200140000,10007),
(9, 6, 1): (100000007,100003),
(9, 6, 2): (220000000,216513),
(9, 6, 3): (202000000,220887),
(9, 6, 4): (201800000,245187),
(9, 6, 5): (200140000,270189),
(9, 6, 6): (200006000,100003),
(9, 7, 1): (100000007,1000003),
(9, 7, 2): (220000000,1948617),
(9, 7, 3): (202000000,1987983),
(9, 7, 4): (201800000,2206683),
(9, 7, 5): (200140000,2431701),
(9, 7, 6): (200006000,2700081),
(9, 7, 7): (200000600,1000003),
(9, 8, 1): (100000007,10000019),
(9, 8, 2): (220000000,17537553),
(9, 8, 3): (202000000,17891847),
(9, 8, 4): (201800000,19860147),
(9, 8, 5): (200140000,21885309),
(9, 8, 6): (200006000,24300729),
(9, 8, 7): (200000600,27000081),
(9, 8, 8): (200000380,10000019),
(9, 9, 1): (100000007,100000007),
(9, 9, 2): (220000000,157837977),
(9, 9, 3): (202000000,161026623),
(9, 9, 4): (201800000,178741323),
(9, 9, 5): (200140000,196967781),
(9, 9, 6): (200006000,218706561),
(9, 9, 7): (200000600,243000729),
(9, 9, 8): (200000380,270000513),
(9, 9, 9): (200000014,100000007)}
T=int(input())
for _ in range(T):
a,b,c=map(int,input().split())
print(*M[(a,b,c)])
``` | instruction | 0 | 6,047 | 22 | 12,094 |
No | output | 1 | 6,047 | 22 | 12,095 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little X has n distinct integers: p1, p2, ..., pn. He wants to divide all of them into two sets A and B. The following two conditions must be satisfied:
* If number x belongs to set A, then number a - x must also belong to set A.
* If number x belongs to set B, then number b - x must also belong to set B.
Help Little X divide the numbers into two sets or determine that it's impossible.
Input
The first line contains three space-separated integers n, a, b (1 β€ n β€ 105; 1 β€ a, b β€ 109). The next line contains n space-separated distinct integers p1, p2, ..., pn (1 β€ pi β€ 109).
Output
If there is a way to divide the numbers into two sets, then print "YES" in the first line. Then print n integers: b1, b2, ..., bn (bi equals either 0, or 1), describing the division. If bi equals to 0, then pi belongs to set A, otherwise it belongs to set B.
If it's impossible, print "NO" (without the quotes).
Examples
Input
4 5 9
2 3 4 5
Output
YES
0 0 1 1
Input
3 3 4
1 2 4
Output
NO
Note
It's OK if all the numbers are in the same set, and the other one is empty. | instruction | 0 | 6,188 | 22 | 12,376 |
Tags: 2-sat, dfs and similar, dsu, graph matchings, greedy
Correct Solution:
```
import sys
from collections import defaultdict as dd
input = sys.stdin.readline
I = lambda : list(map(int,input().split()))
n,a,b=I()
l=I()
dic=dd(int)
for i in range(n):
dic[l[i]]=1
bs=[]
pa=dd(int)
for i in range(n):
if dic[a-l[i]]==0:
bs.append(l[i])
else:
pa[l[i]]=a-l[i]
j=0
while j<len(bs):
for i in range(j,len(bs)):
cr=bs[i]
dic[cr]=2
if dic[b-cr]==0:
print("NO");exit()
dic[b-cr]=2
if dic[a-b+cr]==1:
dic[a-b+cr]=2
bs.append(a-b+cr)
j+=1
#ct=0;vt=a-b+cr
#while vt!=pa[pa[vt]]:
# vt=pa[vt];dic[b-vt]=2
# dic[vt]=2
an=[0]*n
for i in range(n):
an[i]=dic[l[i]]-1
print("YES")
print(*an)
``` | output | 1 | 6,188 | 22 | 12,377 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little X has n distinct integers: p1, p2, ..., pn. He wants to divide all of them into two sets A and B. The following two conditions must be satisfied:
* If number x belongs to set A, then number a - x must also belong to set A.
* If number x belongs to set B, then number b - x must also belong to set B.
Help Little X divide the numbers into two sets or determine that it's impossible.
Input
The first line contains three space-separated integers n, a, b (1 β€ n β€ 105; 1 β€ a, b β€ 109). The next line contains n space-separated distinct integers p1, p2, ..., pn (1 β€ pi β€ 109).
Output
If there is a way to divide the numbers into two sets, then print "YES" in the first line. Then print n integers: b1, b2, ..., bn (bi equals either 0, or 1), describing the division. If bi equals to 0, then pi belongs to set A, otherwise it belongs to set B.
If it's impossible, print "NO" (without the quotes).
Examples
Input
4 5 9
2 3 4 5
Output
YES
0 0 1 1
Input
3 3 4
1 2 4
Output
NO
Note
It's OK if all the numbers are in the same set, and the other one is empty. | instruction | 0 | 6,189 | 22 | 12,378 |
Tags: 2-sat, dfs and similar, dsu, graph matchings, greedy
Correct Solution:
```
class DisjointSet:
def __init__(self, n):
self._fa = list(range(n))
def union(self, x, y):
x = self.get_father(x)
y = self.get_father(y)
self._fa[x] = y
return y
def get_father(self, x):
y = self._fa[x]
if self._fa[y] == y:
return y
else:
z = self._fa[y] = self.get_father(y)
return z
def __repr__(self):
return repr([self.get_father(i) for i in range(len(self._fa))])
def solve(n, a, b, xs):
h = {x: i for i, x in enumerate(xs)}
if a == b:
if all(a - x in h for x in xs):
return [0] * n
return False
g1 = n
g2 = n + 1
ds = DisjointSet(n + 2)
for i, x in enumerate(xs):
for t in (a, b):
if t - x in h:
ds.union(i, h[t-x])
for i, x in enumerate(xs):
b1 = (a - x) in h
b2 = (b - x) in h
if b1 + b2 == 0:
return False
if b1 + b2 == 1:
if b1:
ds.union(i, g1)
else:
ds.union(i, g2)
if ds.get_father(g1) == ds.get_father(g2):
return False
group = [None] * n
for i, x in enumerate(xs):
f = ds.get_father(i)
if f < n:
return False
group[i] = f - n
return group
n, a, b = map(int, input().split())
xs = list(map(int, input().split()))
group = solve(n, a, b, xs)
if isinstance(group, list):
print('YES')
print(' '.join(map(str, group)))
else:
print('NO')
``` | output | 1 | 6,189 | 22 | 12,379 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little X has n distinct integers: p1, p2, ..., pn. He wants to divide all of them into two sets A and B. The following two conditions must be satisfied:
* If number x belongs to set A, then number a - x must also belong to set A.
* If number x belongs to set B, then number b - x must also belong to set B.
Help Little X divide the numbers into two sets or determine that it's impossible.
Input
The first line contains three space-separated integers n, a, b (1 β€ n β€ 105; 1 β€ a, b β€ 109). The next line contains n space-separated distinct integers p1, p2, ..., pn (1 β€ pi β€ 109).
Output
If there is a way to divide the numbers into two sets, then print "YES" in the first line. Then print n integers: b1, b2, ..., bn (bi equals either 0, or 1), describing the division. If bi equals to 0, then pi belongs to set A, otherwise it belongs to set B.
If it's impossible, print "NO" (without the quotes).
Examples
Input
4 5 9
2 3 4 5
Output
YES
0 0 1 1
Input
3 3 4
1 2 4
Output
NO
Note
It's OK if all the numbers are in the same set, and the other one is empty.
Submitted Solution:
```
import sys
from collections import defaultdict as dd
input = sys.stdin.readline
I = lambda : list(map(int,input().split()))
n,a,b=I()
l=I()
st=set(l)
an=[0]*n
pos=1;vis=dd(int)
for i in range(n):
if vis[l[i]]:
an[i]=1;continue
if (b-l[i]) in st:
an[i]=1;vis[b-l[i]]=1
#print(l[i],b-l[i],l.index(b-l[i]))
continue
if (a-l[i]) in st:
continue
pos=0;break
if pos:
print("YES")
print(*an)
else:
print("NO")
``` | instruction | 0 | 6,192 | 22 | 12,384 |
No | output | 1 | 6,192 | 22 | 12,385 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During the research on properties of the greatest common divisor (GCD) of a set of numbers, Ildar, a famous mathematician, introduced a brand new concept of the weakened common divisor (WCD) of a list of pairs of integers.
For a given list of pairs of integers (a_1, b_1), (a_2, b_2), ..., (a_n, b_n) their WCD is arbitrary integer greater than 1, such that it divides at least one element in each pair. WCD may not exist for some lists.
For example, if the list looks like [(12, 15), (25, 18), (10, 24)], then their WCD can be equal to 2, 3, 5 or 6 (each of these numbers is strictly greater than 1 and divides at least one number in each pair).
You're currently pursuing your PhD degree under Ildar's mentorship, and that's why this problem was delegated to you. Your task is to calculate WCD efficiently.
Input
The first line contains a single integer n (1 β€ n β€ 150 000) β the number of pairs.
Each of the next n lines contains two integer values a_i, b_i (2 β€ a_i, b_i β€ 2 β
10^9).
Output
Print a single integer β the WCD of the set of pairs.
If there are multiple possible answers, output any; if there is no answer, print -1.
Examples
Input
3
17 18
15 24
12 15
Output
6
Input
2
10 16
7 17
Output
-1
Input
5
90 108
45 105
75 40
165 175
33 30
Output
5
Note
In the first example the answer is 6 since it divides 18 from the first pair, 24 from the second and 12 from the third ones. Note that other valid answers will also be accepted.
In the second example there are no integers greater than 1 satisfying the conditions.
In the third example one of the possible answers is 5. Note that, for example, 15 is also allowed, but it's not necessary to maximize the output. | instruction | 0 | 6,588 | 22 | 13,176 |
Tags: brute force, greedy, number theory
Correct Solution:
```
import math
import sys
n=int(input())
a=[];b=[];g=0
for i in range(n):
x,y=map(int,sys.stdin.readline().split())
a.append(x)
b.append(y)
g=math.gcd(g,x*y)
for i in range(n):
if math.gcd(g,a[i])>1:
g=math.gcd(g,a[i])
else:
g=math.gcd(g,b[i])
if g==1:
print(-1)
else:
print(g)
``` | output | 1 | 6,588 | 22 | 13,177 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During the research on properties of the greatest common divisor (GCD) of a set of numbers, Ildar, a famous mathematician, introduced a brand new concept of the weakened common divisor (WCD) of a list of pairs of integers.
For a given list of pairs of integers (a_1, b_1), (a_2, b_2), ..., (a_n, b_n) their WCD is arbitrary integer greater than 1, such that it divides at least one element in each pair. WCD may not exist for some lists.
For example, if the list looks like [(12, 15), (25, 18), (10, 24)], then their WCD can be equal to 2, 3, 5 or 6 (each of these numbers is strictly greater than 1 and divides at least one number in each pair).
You're currently pursuing your PhD degree under Ildar's mentorship, and that's why this problem was delegated to you. Your task is to calculate WCD efficiently.
Input
The first line contains a single integer n (1 β€ n β€ 150 000) β the number of pairs.
Each of the next n lines contains two integer values a_i, b_i (2 β€ a_i, b_i β€ 2 β
10^9).
Output
Print a single integer β the WCD of the set of pairs.
If there are multiple possible answers, output any; if there is no answer, print -1.
Examples
Input
3
17 18
15 24
12 15
Output
6
Input
2
10 16
7 17
Output
-1
Input
5
90 108
45 105
75 40
165 175
33 30
Output
5
Note
In the first example the answer is 6 since it divides 18 from the first pair, 24 from the second and 12 from the third ones. Note that other valid answers will also be accepted.
In the second example there are no integers greater than 1 satisfying the conditions.
In the third example one of the possible answers is 5. Note that, for example, 15 is also allowed, but it's not necessary to maximize the output. | instruction | 0 | 6,589 | 22 | 13,178 |
Tags: brute force, greedy, number theory
Correct Solution:
```
from sys import stdin
from math import gcd
input=stdin.readline
n=int(input())
ab=[list(map(int,input().split())) for i in range(n)]
z=ab[0][0]*ab[0][1]
for a,b in ab:
z=gcd(z,a*b)
for a,b in ab:
if gcd(z,a)>1:
z=gcd(z,a)
else:
z=gcd(z,b)
print(z if z!=1 else -1)
``` | output | 1 | 6,589 | 22 | 13,179 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During the research on properties of the greatest common divisor (GCD) of a set of numbers, Ildar, a famous mathematician, introduced a brand new concept of the weakened common divisor (WCD) of a list of pairs of integers.
For a given list of pairs of integers (a_1, b_1), (a_2, b_2), ..., (a_n, b_n) their WCD is arbitrary integer greater than 1, such that it divides at least one element in each pair. WCD may not exist for some lists.
For example, if the list looks like [(12, 15), (25, 18), (10, 24)], then their WCD can be equal to 2, 3, 5 or 6 (each of these numbers is strictly greater than 1 and divides at least one number in each pair).
You're currently pursuing your PhD degree under Ildar's mentorship, and that's why this problem was delegated to you. Your task is to calculate WCD efficiently.
Input
The first line contains a single integer n (1 β€ n β€ 150 000) β the number of pairs.
Each of the next n lines contains two integer values a_i, b_i (2 β€ a_i, b_i β€ 2 β
10^9).
Output
Print a single integer β the WCD of the set of pairs.
If there are multiple possible answers, output any; if there is no answer, print -1.
Examples
Input
3
17 18
15 24
12 15
Output
6
Input
2
10 16
7 17
Output
-1
Input
5
90 108
45 105
75 40
165 175
33 30
Output
5
Note
In the first example the answer is 6 since it divides 18 from the first pair, 24 from the second and 12 from the third ones. Note that other valid answers will also be accepted.
In the second example there are no integers greater than 1 satisfying the conditions.
In the third example one of the possible answers is 5. Note that, for example, 15 is also allowed, but it's not necessary to maximize the output. | instruction | 0 | 6,590 | 22 | 13,180 |
Tags: brute force, greedy, number theory
Correct Solution:
```
def d(x):
for dl in range(2,int(x**0.5)+1):
if x % dl == 0:
return(dl)
return (x)
def gcd(a,b):
return a if b==0 else gcd(b,a%b)
n=int(input())
a,b=map(int,input().split())
for i in range(n-1):
an,bn=map(int,input().split())
a,b=gcd(an*bn,a),gcd(an*bn,b)
if a>1:
print(d(a))
elif b>1:
print(d(b))
else:
print(-1)
``` | output | 1 | 6,590 | 22 | 13,181 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During the research on properties of the greatest common divisor (GCD) of a set of numbers, Ildar, a famous mathematician, introduced a brand new concept of the weakened common divisor (WCD) of a list of pairs of integers.
For a given list of pairs of integers (a_1, b_1), (a_2, b_2), ..., (a_n, b_n) their WCD is arbitrary integer greater than 1, such that it divides at least one element in each pair. WCD may not exist for some lists.
For example, if the list looks like [(12, 15), (25, 18), (10, 24)], then their WCD can be equal to 2, 3, 5 or 6 (each of these numbers is strictly greater than 1 and divides at least one number in each pair).
You're currently pursuing your PhD degree under Ildar's mentorship, and that's why this problem was delegated to you. Your task is to calculate WCD efficiently.
Input
The first line contains a single integer n (1 β€ n β€ 150 000) β the number of pairs.
Each of the next n lines contains two integer values a_i, b_i (2 β€ a_i, b_i β€ 2 β
10^9).
Output
Print a single integer β the WCD of the set of pairs.
If there are multiple possible answers, output any; if there is no answer, print -1.
Examples
Input
3
17 18
15 24
12 15
Output
6
Input
2
10 16
7 17
Output
-1
Input
5
90 108
45 105
75 40
165 175
33 30
Output
5
Note
In the first example the answer is 6 since it divides 18 from the first pair, 24 from the second and 12 from the third ones. Note that other valid answers will also be accepted.
In the second example there are no integers greater than 1 satisfying the conditions.
In the third example one of the possible answers is 5. Note that, for example, 15 is also allowed, but it's not necessary to maximize the output. | instruction | 0 | 6,591 | 22 | 13,182 |
Tags: brute force, greedy, number theory
Correct Solution:
```
from math import sqrt
n = int(input())
def prime_factors(n):
factors = set()
while n % 2 == 0:
factors.add(2)
n = n / 2
for i in range(3,int(sqrt(n))+1,2):
while n % i== 0:
factors.add(i)
n = n / i
if n > 2:
factors.add(n)
return factors
a, b = tuple(map(int, input().split()))
factors = prime_factors(a).union(prime_factors(b))
for i in range(n-1):
a, b = tuple(map(int, input().split()))
if factors:
new_factors = set()
for f in factors:
if a % f == 0 or b % f == 0:
new_factors.add(f)
factors = new_factors
print(int(factors.pop()) if factors else -1)
``` | output | 1 | 6,591 | 22 | 13,183 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During the research on properties of the greatest common divisor (GCD) of a set of numbers, Ildar, a famous mathematician, introduced a brand new concept of the weakened common divisor (WCD) of a list of pairs of integers.
For a given list of pairs of integers (a_1, b_1), (a_2, b_2), ..., (a_n, b_n) their WCD is arbitrary integer greater than 1, such that it divides at least one element in each pair. WCD may not exist for some lists.
For example, if the list looks like [(12, 15), (25, 18), (10, 24)], then their WCD can be equal to 2, 3, 5 or 6 (each of these numbers is strictly greater than 1 and divides at least one number in each pair).
You're currently pursuing your PhD degree under Ildar's mentorship, and that's why this problem was delegated to you. Your task is to calculate WCD efficiently.
Input
The first line contains a single integer n (1 β€ n β€ 150 000) β the number of pairs.
Each of the next n lines contains two integer values a_i, b_i (2 β€ a_i, b_i β€ 2 β
10^9).
Output
Print a single integer β the WCD of the set of pairs.
If there are multiple possible answers, output any; if there is no answer, print -1.
Examples
Input
3
17 18
15 24
12 15
Output
6
Input
2
10 16
7 17
Output
-1
Input
5
90 108
45 105
75 40
165 175
33 30
Output
5
Note
In the first example the answer is 6 since it divides 18 from the first pair, 24 from the second and 12 from the third ones. Note that other valid answers will also be accepted.
In the second example there are no integers greater than 1 satisfying the conditions.
In the third example one of the possible answers is 5. Note that, for example, 15 is also allowed, but it's not necessary to maximize the output. | instruction | 0 | 6,592 | 22 | 13,184 |
Tags: brute force, greedy, number theory
Correct Solution:
```
import math
import sys
n=int(input());
a=[]
b=[]
g=0
for i in range(n) :
p,q=map(int,sys.stdin.readline().split())
a.append(p)
b.append(q)
g=math.gcd(g,p*q);
#print(g)
if (1==g):
exit(print("-1"))
#print(g)
for i in range (n) :
if math.gcd (g,a[i])!=1 :
g=math.gcd (g,a[i])
#print("a",g)
else :
g=math.gcd (g,b[i])
#print("b",g)
print(g)
``` | output | 1 | 6,592 | 22 | 13,185 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During the research on properties of the greatest common divisor (GCD) of a set of numbers, Ildar, a famous mathematician, introduced a brand new concept of the weakened common divisor (WCD) of a list of pairs of integers.
For a given list of pairs of integers (a_1, b_1), (a_2, b_2), ..., (a_n, b_n) their WCD is arbitrary integer greater than 1, such that it divides at least one element in each pair. WCD may not exist for some lists.
For example, if the list looks like [(12, 15), (25, 18), (10, 24)], then their WCD can be equal to 2, 3, 5 or 6 (each of these numbers is strictly greater than 1 and divides at least one number in each pair).
You're currently pursuing your PhD degree under Ildar's mentorship, and that's why this problem was delegated to you. Your task is to calculate WCD efficiently.
Input
The first line contains a single integer n (1 β€ n β€ 150 000) β the number of pairs.
Each of the next n lines contains two integer values a_i, b_i (2 β€ a_i, b_i β€ 2 β
10^9).
Output
Print a single integer β the WCD of the set of pairs.
If there are multiple possible answers, output any; if there is no answer, print -1.
Examples
Input
3
17 18
15 24
12 15
Output
6
Input
2
10 16
7 17
Output
-1
Input
5
90 108
45 105
75 40
165 175
33 30
Output
5
Note
In the first example the answer is 6 since it divides 18 from the first pair, 24 from the second and 12 from the third ones. Note that other valid answers will also be accepted.
In the second example there are no integers greater than 1 satisfying the conditions.
In the third example one of the possible answers is 5. Note that, for example, 15 is also allowed, but it's not necessary to maximize the output. | instruction | 0 | 6,593 | 22 | 13,186 |
Tags: brute force, greedy, number theory
Correct Solution:
```
from math import gcd
n = int(input())
a, b = [int(x) for x in input().split()]
for i in range(1, n):
x, y = [int(x) for x in input().split()]
xy = x * y
if a > 1:
a = gcd(a, xy)
if b > 1:
b = gcd(b, xy)
g = max(a, b)
if g == 1:
print(-1)
else:
i = 2
while i * i <= g:
if g % i == 0:
print(i)
break
i += 1
else:
print(g)
``` | output | 1 | 6,593 | 22 | 13,187 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During the research on properties of the greatest common divisor (GCD) of a set of numbers, Ildar, a famous mathematician, introduced a brand new concept of the weakened common divisor (WCD) of a list of pairs of integers.
For a given list of pairs of integers (a_1, b_1), (a_2, b_2), ..., (a_n, b_n) their WCD is arbitrary integer greater than 1, such that it divides at least one element in each pair. WCD may not exist for some lists.
For example, if the list looks like [(12, 15), (25, 18), (10, 24)], then their WCD can be equal to 2, 3, 5 or 6 (each of these numbers is strictly greater than 1 and divides at least one number in each pair).
You're currently pursuing your PhD degree under Ildar's mentorship, and that's why this problem was delegated to you. Your task is to calculate WCD efficiently.
Input
The first line contains a single integer n (1 β€ n β€ 150 000) β the number of pairs.
Each of the next n lines contains two integer values a_i, b_i (2 β€ a_i, b_i β€ 2 β
10^9).
Output
Print a single integer β the WCD of the set of pairs.
If there are multiple possible answers, output any; if there is no answer, print -1.
Examples
Input
3
17 18
15 24
12 15
Output
6
Input
2
10 16
7 17
Output
-1
Input
5
90 108
45 105
75 40
165 175
33 30
Output
5
Note
In the first example the answer is 6 since it divides 18 from the first pair, 24 from the second and 12 from the third ones. Note that other valid answers will also be accepted.
In the second example there are no integers greater than 1 satisfying the conditions.
In the third example one of the possible answers is 5. Note that, for example, 15 is also allowed, but it's not necessary to maximize the output. | instruction | 0 | 6,594 | 22 | 13,188 |
Tags: brute force, greedy, number theory
Correct Solution:
```
def gcd(a,b):
if a%b==0:
return b
else:
return gcd(b,a%b)
import math
def pr(n):
a=[]
while n % 2 == 0:
a.append(2)
n = n / 2
for i in range(3,int(math.sqrt(n))+1,2):
while n % i== 0:
a.append(i)
n = n / i
if n > 2:
a.append(n)
return list(set(a))
n=int(input())
a=[]
for i in range(n):
a.append(list(map(int,input().split())))
if n==1:
print(a[0][0])
else:
b=[]
b.append(pr(a[0][0]))
b.append(pr(a[0][1]))
c=set([])
for i in range(len(b)):
for j in range(len(b[i])):
c.add(b[i][j])
c=list(c)
e=0
for i in range(len(c)):
b=0
for j in range(n):
if a[j][0]%c[i]==0 or a[j][1]%c[i]==0:
b+=1
if b==n:
e=1
print(int(c[i]))
break
if e==0:
print(-1)
``` | output | 1 | 6,594 | 22 | 13,189 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During the research on properties of the greatest common divisor (GCD) of a set of numbers, Ildar, a famous mathematician, introduced a brand new concept of the weakened common divisor (WCD) of a list of pairs of integers.
For a given list of pairs of integers (a_1, b_1), (a_2, b_2), ..., (a_n, b_n) their WCD is arbitrary integer greater than 1, such that it divides at least one element in each pair. WCD may not exist for some lists.
For example, if the list looks like [(12, 15), (25, 18), (10, 24)], then their WCD can be equal to 2, 3, 5 or 6 (each of these numbers is strictly greater than 1 and divides at least one number in each pair).
You're currently pursuing your PhD degree under Ildar's mentorship, and that's why this problem was delegated to you. Your task is to calculate WCD efficiently.
Input
The first line contains a single integer n (1 β€ n β€ 150 000) β the number of pairs.
Each of the next n lines contains two integer values a_i, b_i (2 β€ a_i, b_i β€ 2 β
10^9).
Output
Print a single integer β the WCD of the set of pairs.
If there are multiple possible answers, output any; if there is no answer, print -1.
Examples
Input
3
17 18
15 24
12 15
Output
6
Input
2
10 16
7 17
Output
-1
Input
5
90 108
45 105
75 40
165 175
33 30
Output
5
Note
In the first example the answer is 6 since it divides 18 from the first pair, 24 from the second and 12 from the third ones. Note that other valid answers will also be accepted.
In the second example there are no integers greater than 1 satisfying the conditions.
In the third example one of the possible answers is 5. Note that, for example, 15 is also allowed, but it's not necessary to maximize the output. | instruction | 0 | 6,595 | 22 | 13,190 |
Tags: brute force, greedy, number theory
Correct Solution:
```
n = int(input())
from math import gcd
al = []
bl = []
g = 0
for _ in range(n):
a,b = map(int,input().split())
g = gcd(g,a*b)
al.append(a)
bl.append(b)
if(g==1):
print(-1)
exit(0)
for i in range(n):
x = gcd(g,al[i])
if(x>1):
g = x
x = gcd(g,bl[i])
if(x>1):
g = x
if(g!=1):
print(g)
else:
print(-1)
``` | output | 1 | 6,595 | 22 | 13,191 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
During the research on properties of the greatest common divisor (GCD) of a set of numbers, Ildar, a famous mathematician, introduced a brand new concept of the weakened common divisor (WCD) of a list of pairs of integers.
For a given list of pairs of integers (a_1, b_1), (a_2, b_2), ..., (a_n, b_n) their WCD is arbitrary integer greater than 1, such that it divides at least one element in each pair. WCD may not exist for some lists.
For example, if the list looks like [(12, 15), (25, 18), (10, 24)], then their WCD can be equal to 2, 3, 5 or 6 (each of these numbers is strictly greater than 1 and divides at least one number in each pair).
You're currently pursuing your PhD degree under Ildar's mentorship, and that's why this problem was delegated to you. Your task is to calculate WCD efficiently.
Input
The first line contains a single integer n (1 β€ n β€ 150 000) β the number of pairs.
Each of the next n lines contains two integer values a_i, b_i (2 β€ a_i, b_i β€ 2 β
10^9).
Output
Print a single integer β the WCD of the set of pairs.
If there are multiple possible answers, output any; if there is no answer, print -1.
Examples
Input
3
17 18
15 24
12 15
Output
6
Input
2
10 16
7 17
Output
-1
Input
5
90 108
45 105
75 40
165 175
33 30
Output
5
Note
In the first example the answer is 6 since it divides 18 from the first pair, 24 from the second and 12 from the third ones. Note that other valid answers will also be accepted.
In the second example there are no integers greater than 1 satisfying the conditions.
In the third example one of the possible answers is 5. Note that, for example, 15 is also allowed, but it's not necessary to maximize the output.
Submitted Solution:
```
def primes(n):
d = 2
while d*d <= n:
while (n % d) == 0:
primfac.add(d)
n //= d
d += 1
if n > 1:
primfac.add(n)
return primfac
n = int(input())
pairs = []
for i in range(n):
pairs.append([int(i) for i in input().split()])
primfac = set()
primes(pairs[0][0])
primes(pairs[0][1])
for i in range(n - 1):
to_delete = []
for j in primfac:
if pairs[i + 1][0] % j != 0 and pairs[i + 1][1] % j != 0:
to_delete.append(j)
for j in to_delete:
primfac.remove(j)
li = list(primfac)
if len(li) == 0:
print(-1)
else:
print(li[-1])
``` | instruction | 0 | 6,596 | 22 | 13,192 |
Yes | output | 1 | 6,596 | 22 | 13,193 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
During the research on properties of the greatest common divisor (GCD) of a set of numbers, Ildar, a famous mathematician, introduced a brand new concept of the weakened common divisor (WCD) of a list of pairs of integers.
For a given list of pairs of integers (a_1, b_1), (a_2, b_2), ..., (a_n, b_n) their WCD is arbitrary integer greater than 1, such that it divides at least one element in each pair. WCD may not exist for some lists.
For example, if the list looks like [(12, 15), (25, 18), (10, 24)], then their WCD can be equal to 2, 3, 5 or 6 (each of these numbers is strictly greater than 1 and divides at least one number in each pair).
You're currently pursuing your PhD degree under Ildar's mentorship, and that's why this problem was delegated to you. Your task is to calculate WCD efficiently.
Input
The first line contains a single integer n (1 β€ n β€ 150 000) β the number of pairs.
Each of the next n lines contains two integer values a_i, b_i (2 β€ a_i, b_i β€ 2 β
10^9).
Output
Print a single integer β the WCD of the set of pairs.
If there are multiple possible answers, output any; if there is no answer, print -1.
Examples
Input
3
17 18
15 24
12 15
Output
6
Input
2
10 16
7 17
Output
-1
Input
5
90 108
45 105
75 40
165 175
33 30
Output
5
Note
In the first example the answer is 6 since it divides 18 from the first pair, 24 from the second and 12 from the third ones. Note that other valid answers will also be accepted.
In the second example there are no integers greater than 1 satisfying the conditions.
In the third example one of the possible answers is 5. Note that, for example, 15 is also allowed, but it's not necessary to maximize the output.
Submitted Solution:
```
from math import gcd
import io, os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
x = 0
for _ in range(int(input())):
a, b = map(int, input().split())
x = gcd(x,a*b)
if x == 1: print(-1)
else:
if gcd(x,a) != 1: x = gcd(x,a)
else: x = gcd(x,b)
n = int(x**(.5))
mark = [False]*(n+1)
mark[0] = mark[1] = True
primes = set()
for i in range(2,n+1):
if mark[i] == False:
if x%i == 0:
print(i)
break
primes.add(i)
for j in range(i+i, n+1, i):
mark[j] = True
else: print(x)
``` | instruction | 0 | 6,597 | 22 | 13,194 |
Yes | output | 1 | 6,597 | 22 | 13,195 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
During the research on properties of the greatest common divisor (GCD) of a set of numbers, Ildar, a famous mathematician, introduced a brand new concept of the weakened common divisor (WCD) of a list of pairs of integers.
For a given list of pairs of integers (a_1, b_1), (a_2, b_2), ..., (a_n, b_n) their WCD is arbitrary integer greater than 1, such that it divides at least one element in each pair. WCD may not exist for some lists.
For example, if the list looks like [(12, 15), (25, 18), (10, 24)], then their WCD can be equal to 2, 3, 5 or 6 (each of these numbers is strictly greater than 1 and divides at least one number in each pair).
You're currently pursuing your PhD degree under Ildar's mentorship, and that's why this problem was delegated to you. Your task is to calculate WCD efficiently.
Input
The first line contains a single integer n (1 β€ n β€ 150 000) β the number of pairs.
Each of the next n lines contains two integer values a_i, b_i (2 β€ a_i, b_i β€ 2 β
10^9).
Output
Print a single integer β the WCD of the set of pairs.
If there are multiple possible answers, output any; if there is no answer, print -1.
Examples
Input
3
17 18
15 24
12 15
Output
6
Input
2
10 16
7 17
Output
-1
Input
5
90 108
45 105
75 40
165 175
33 30
Output
5
Note
In the first example the answer is 6 since it divides 18 from the first pair, 24 from the second and 12 from the third ones. Note that other valid answers will also be accepted.
In the second example there are no integers greater than 1 satisfying the conditions.
In the third example one of the possible answers is 5. Note that, for example, 15 is also allowed, but it's not necessary to maximize the output.
Submitted Solution:
```
import sys
import math
from collections import defaultdict,deque
import _operator
input = sys.stdin.readline
def inar():
return [int(el) for el in input().split()]
def main():
n=int(input())
pairs=[]
for i in range(n):
x,y=inar()
pairs.append([x,y])
counter=0
take=[]
for i in range(2,int(pairs[0][0]**0.5)+1):
if pairs[0][0] % i==0:
take.append(i)
while pairs[0][0] % i==0:
pairs[0][0]//=i
if pairs[0][0]>1:
take.append(pairs[0][0])
ans=-1
for j in range(len(take)):
counter=0
for i in range(1,n):
if pairs[i][0] % take[j]==0 or pairs[i][1] %take[j]==0:
continue
else:
counter=1
break
if counter==0:
ans=take[j]
break
if ans!=-1:
print(ans)
else:
counter = 0
take = []
for i in range(2, int(pairs[0][1] ** 0.5) + 1):
if pairs[0][1] % i == 0:
take.append(i)
while pairs[0][1] % i == 0:
pairs[0][1] //= i
if pairs[0][1] > 1:
take.append(pairs[0][1])
ans = -1
for j in range(len(take)):
counter = 0
for i in range(1, n):
if pairs[i][0] % take[j] == 0 or pairs[i][1] % take[j] == 0:
continue
else:
counter = 1
break
if counter == 0:
ans = take[j]
break
print(ans)
if __name__ == '__main__':
main()
``` | instruction | 0 | 6,598 | 22 | 13,196 |
Yes | output | 1 | 6,598 | 22 | 13,197 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
During the research on properties of the greatest common divisor (GCD) of a set of numbers, Ildar, a famous mathematician, introduced a brand new concept of the weakened common divisor (WCD) of a list of pairs of integers.
For a given list of pairs of integers (a_1, b_1), (a_2, b_2), ..., (a_n, b_n) their WCD is arbitrary integer greater than 1, such that it divides at least one element in each pair. WCD may not exist for some lists.
For example, if the list looks like [(12, 15), (25, 18), (10, 24)], then their WCD can be equal to 2, 3, 5 or 6 (each of these numbers is strictly greater than 1 and divides at least one number in each pair).
You're currently pursuing your PhD degree under Ildar's mentorship, and that's why this problem was delegated to you. Your task is to calculate WCD efficiently.
Input
The first line contains a single integer n (1 β€ n β€ 150 000) β the number of pairs.
Each of the next n lines contains two integer values a_i, b_i (2 β€ a_i, b_i β€ 2 β
10^9).
Output
Print a single integer β the WCD of the set of pairs.
If there are multiple possible answers, output any; if there is no answer, print -1.
Examples
Input
3
17 18
15 24
12 15
Output
6
Input
2
10 16
7 17
Output
-1
Input
5
90 108
45 105
75 40
165 175
33 30
Output
5
Note
In the first example the answer is 6 since it divides 18 from the first pair, 24 from the second and 12 from the third ones. Note that other valid answers will also be accepted.
In the second example there are no integers greater than 1 satisfying the conditions.
In the third example one of the possible answers is 5. Note that, for example, 15 is also allowed, but it's not necessary to maximize the output.
Submitted Solution:
```
import sys
import math
f=sys.stdin
def prime_factors(n):
factors = []
d=2
while n>1:
while n%d==0:
factors.append(d)
n/=d
d=d+1
if d*d>n:
if n>1:
factors.append(n)
break
return factors[0]
n=int(f.readline().rstrip('\r\n'))
inp=[]
gcd=0
for i in range(n):
a,b=map(int,f.readline().rstrip('\r\n').split())
c=a*b
gcd=math.gcd(gcd,c)
if gcd>1:
if gcd<=10000000000:
sys.stdout.write(str(prime_factors(gcd))+"\n")
else:
if (math.gcd(gcd,a)>1):
sys.stdout.write(str(math.gcd(a,gcd))+"\n")
else:
sys.stdout.write(str(math.gcd(b,gcd))+'\n')
else:
sys.stdout.write("-1\n")
``` | instruction | 0 | 6,599 | 22 | 13,198 |
Yes | output | 1 | 6,599 | 22 | 13,199 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
During the research on properties of the greatest common divisor (GCD) of a set of numbers, Ildar, a famous mathematician, introduced a brand new concept of the weakened common divisor (WCD) of a list of pairs of integers.
For a given list of pairs of integers (a_1, b_1), (a_2, b_2), ..., (a_n, b_n) their WCD is arbitrary integer greater than 1, such that it divides at least one element in each pair. WCD may not exist for some lists.
For example, if the list looks like [(12, 15), (25, 18), (10, 24)], then their WCD can be equal to 2, 3, 5 or 6 (each of these numbers is strictly greater than 1 and divides at least one number in each pair).
You're currently pursuing your PhD degree under Ildar's mentorship, and that's why this problem was delegated to you. Your task is to calculate WCD efficiently.
Input
The first line contains a single integer n (1 β€ n β€ 150 000) β the number of pairs.
Each of the next n lines contains two integer values a_i, b_i (2 β€ a_i, b_i β€ 2 β
10^9).
Output
Print a single integer β the WCD of the set of pairs.
If there are multiple possible answers, output any; if there is no answer, print -1.
Examples
Input
3
17 18
15 24
12 15
Output
6
Input
2
10 16
7 17
Output
-1
Input
5
90 108
45 105
75 40
165 175
33 30
Output
5
Note
In the first example the answer is 6 since it divides 18 from the first pair, 24 from the second and 12 from the third ones. Note that other valid answers will also be accepted.
In the second example there are no integers greater than 1 satisfying the conditions.
In the third example one of the possible answers is 5. Note that, for example, 15 is also allowed, but it's not necessary to maximize the output.
Submitted Solution:
```
from sys import stdin
def main():
input()
data, pp = set(stdin.read().splitlines()), set()
s = data.pop()
if not (data):
print(s.split()[0])
return
for a in map(int, set(s.split())):
for p in 2, 3, 5:
if not a % p:
pp.add(p)
while not a % p:
a //= p
p = 7
while a >= p * p:
for s in 4, 2, 4, 2, 4, 6, 2, 6:
pp.add(p)
while not a % p:
a //= p
p += s
if a > 1:
pp.add(a)
for s in data:
pp = {p for a in map(int, s.split()) for p in pp if not a % p}
if not pp:
print(-1)
return
print(max(pp))
if __name__ == '__main__':
main()
``` | instruction | 0 | 6,600 | 22 | 13,200 |
No | output | 1 | 6,600 | 22 | 13,201 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
During the research on properties of the greatest common divisor (GCD) of a set of numbers, Ildar, a famous mathematician, introduced a brand new concept of the weakened common divisor (WCD) of a list of pairs of integers.
For a given list of pairs of integers (a_1, b_1), (a_2, b_2), ..., (a_n, b_n) their WCD is arbitrary integer greater than 1, such that it divides at least one element in each pair. WCD may not exist for some lists.
For example, if the list looks like [(12, 15), (25, 18), (10, 24)], then their WCD can be equal to 2, 3, 5 or 6 (each of these numbers is strictly greater than 1 and divides at least one number in each pair).
You're currently pursuing your PhD degree under Ildar's mentorship, and that's why this problem was delegated to you. Your task is to calculate WCD efficiently.
Input
The first line contains a single integer n (1 β€ n β€ 150 000) β the number of pairs.
Each of the next n lines contains two integer values a_i, b_i (2 β€ a_i, b_i β€ 2 β
10^9).
Output
Print a single integer β the WCD of the set of pairs.
If there are multiple possible answers, output any; if there is no answer, print -1.
Examples
Input
3
17 18
15 24
12 15
Output
6
Input
2
10 16
7 17
Output
-1
Input
5
90 108
45 105
75 40
165 175
33 30
Output
5
Note
In the first example the answer is 6 since it divides 18 from the first pair, 24 from the second and 12 from the third ones. Note that other valid answers will also be accepted.
In the second example there are no integers greater than 1 satisfying the conditions.
In the third example one of the possible answers is 5. Note that, for example, 15 is also allowed, but it's not necessary to maximize the output.
Submitted Solution:
```
import math
def getDivs(a,b):
divs = set()
divs.add(a);divs.add(b)
x = int(math.sqrt(a) +5); y = int(math.sqrt(b) +5)
for i in range(2, x):
if a % i == 0:
divs.add( i)
divs.add(int(a/i))
for i in range(2, y):
if b % i == 0:
divs.add( i)
divs.add(int(b/i))
return divs
n = int( input() )
l=[]
for i in range( 0,n):
a , b = [int(x) for x in input().split()]
l.append((a,b))
a,b = l[0][0], l[0][1]
# print(a,b)
if n == 1:
print(a)
else:
divs = getDivs(a,b)
# print(divs)
for i in range(1, n):
aux = set()
a,b = l[i][0], l[i][1]
for s in divs:
if a %s == 0 or b %s == 0:
aux.add(s)
divs = aux
# print(divs)
if len(divs) >= 1:
print(divs.pop())
else:
print("-1")
``` | instruction | 0 | 6,601 | 22 | 13,202 |
No | output | 1 | 6,601 | 22 | 13,203 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
During the research on properties of the greatest common divisor (GCD) of a set of numbers, Ildar, a famous mathematician, introduced a brand new concept of the weakened common divisor (WCD) of a list of pairs of integers.
For a given list of pairs of integers (a_1, b_1), (a_2, b_2), ..., (a_n, b_n) their WCD is arbitrary integer greater than 1, such that it divides at least one element in each pair. WCD may not exist for some lists.
For example, if the list looks like [(12, 15), (25, 18), (10, 24)], then their WCD can be equal to 2, 3, 5 or 6 (each of these numbers is strictly greater than 1 and divides at least one number in each pair).
You're currently pursuing your PhD degree under Ildar's mentorship, and that's why this problem was delegated to you. Your task is to calculate WCD efficiently.
Input
The first line contains a single integer n (1 β€ n β€ 150 000) β the number of pairs.
Each of the next n lines contains two integer values a_i, b_i (2 β€ a_i, b_i β€ 2 β
10^9).
Output
Print a single integer β the WCD of the set of pairs.
If there are multiple possible answers, output any; if there is no answer, print -1.
Examples
Input
3
17 18
15 24
12 15
Output
6
Input
2
10 16
7 17
Output
-1
Input
5
90 108
45 105
75 40
165 175
33 30
Output
5
Note
In the first example the answer is 6 since it divides 18 from the first pair, 24 from the second and 12 from the third ones. Note that other valid answers will also be accepted.
In the second example there are no integers greater than 1 satisfying the conditions.
In the third example one of the possible answers is 5. Note that, for example, 15 is also allowed, but it's not necessary to maximize the output.
Submitted Solution:
```
nums = [map(int, input().split()) for _ in range(int(input()))]
prods = [x * y for x, y in nums]
numWorks = 0
i = -1
for j in range(0, len(prods)):
if prods[j] % 2 == 0:
numWorks += 1
else:
break
if numWorks == len(prods):
print(2)
exit
while (numWorks < len(prods)):
i += 2
numWorks = 0
for j in range(0, len(prods)):
if prods[j] % i == 0:
numWorks += 1
else:
break
if numWorks == len(prods):
print(i)
else:
print(-1)
``` | instruction | 0 | 6,602 | 22 | 13,204 |
No | output | 1 | 6,602 | 22 | 13,205 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
During the research on properties of the greatest common divisor (GCD) of a set of numbers, Ildar, a famous mathematician, introduced a brand new concept of the weakened common divisor (WCD) of a list of pairs of integers.
For a given list of pairs of integers (a_1, b_1), (a_2, b_2), ..., (a_n, b_n) their WCD is arbitrary integer greater than 1, such that it divides at least one element in each pair. WCD may not exist for some lists.
For example, if the list looks like [(12, 15), (25, 18), (10, 24)], then their WCD can be equal to 2, 3, 5 or 6 (each of these numbers is strictly greater than 1 and divides at least one number in each pair).
You're currently pursuing your PhD degree under Ildar's mentorship, and that's why this problem was delegated to you. Your task is to calculate WCD efficiently.
Input
The first line contains a single integer n (1 β€ n β€ 150 000) β the number of pairs.
Each of the next n lines contains two integer values a_i, b_i (2 β€ a_i, b_i β€ 2 β
10^9).
Output
Print a single integer β the WCD of the set of pairs.
If there are multiple possible answers, output any; if there is no answer, print -1.
Examples
Input
3
17 18
15 24
12 15
Output
6
Input
2
10 16
7 17
Output
-1
Input
5
90 108
45 105
75 40
165 175
33 30
Output
5
Note
In the first example the answer is 6 since it divides 18 from the first pair, 24 from the second and 12 from the third ones. Note that other valid answers will also be accepted.
In the second example there are no integers greater than 1 satisfying the conditions.
In the third example one of the possible answers is 5. Note that, for example, 15 is also allowed, but it's not necessary to maximize the output.
Submitted Solution:
```
nums = [map(int, input().split()) for _ in range(int(input()))]
prods = [x * y for x, y in nums]
numWorks = 0
i = 1
while (numWorks < len(prods)):
i += 1
numWorks = 0
for j in range(0, len(prods)):
if prods[j] % i == 0:
numWorks += 1
else:
break
``` | instruction | 0 | 6,603 | 22 | 13,206 |
No | output | 1 | 6,603 | 22 | 13,207 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two integers a and b, and q queries. The i-th query consists of two numbers l_i and r_i, and the answer to it is the number of integers x such that l_i β€ x β€ r_i, and ((x mod a) mod b) β ((x mod b) mod a). Calculate the answer for each query.
Recall that y mod z is the remainder of the division of y by z. For example, 5 mod 3 = 2, 7 mod 8 = 7, 9 mod 4 = 1, 9 mod 9 = 0.
Input
The first line contains one integer t (1 β€ t β€ 100) β the number of test cases. Then the test cases follow.
The first line of each test case contains three integers a, b and q (1 β€ a, b β€ 200; 1 β€ q β€ 500).
Then q lines follow, each containing two integers l_i and r_i (1 β€ l_i β€ r_i β€ 10^{18}) for the corresponding query.
Output
For each test case, print q integers β the answers to the queries of this test case in the order they appear.
Example
Input
2
4 6 5
1 1
1 3
1 5
1 7
1 9
7 10 2
7 8
100 200
Output
0 0 0 2 4
0 91 | instruction | 0 | 6,730 | 22 | 13,460 |
Tags: math, number theory
Correct Solution:
```
from fractions import gcd
get=lambda x,lcm,b:x-b*(x//lcm)-min(b,x%lcm+1)
for _ in range(int(input())):
a,b,q=map(int,input().split())
lcm=a*b//gcd(a,b)
for i in range(q):
l,r=map(int,input().split())
print(get(r,lcm,max(a,b))-get(l-1,lcm,max(a,b)))
``` | output | 1 | 6,730 | 22 | 13,461 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two integers a and b, and q queries. The i-th query consists of two numbers l_i and r_i, and the answer to it is the number of integers x such that l_i β€ x β€ r_i, and ((x mod a) mod b) β ((x mod b) mod a). Calculate the answer for each query.
Recall that y mod z is the remainder of the division of y by z. For example, 5 mod 3 = 2, 7 mod 8 = 7, 9 mod 4 = 1, 9 mod 9 = 0.
Input
The first line contains one integer t (1 β€ t β€ 100) β the number of test cases. Then the test cases follow.
The first line of each test case contains three integers a, b and q (1 β€ a, b β€ 200; 1 β€ q β€ 500).
Then q lines follow, each containing two integers l_i and r_i (1 β€ l_i β€ r_i β€ 10^{18}) for the corresponding query.
Output
For each test case, print q integers β the answers to the queries of this test case in the order they appear.
Example
Input
2
4 6 5
1 1
1 3
1 5
1 7
1 9
7 10 2
7 8
100 200
Output
0 0 0 2 4
0 91 | instruction | 0 | 6,731 | 22 | 13,462 |
Tags: math, number theory
Correct Solution:
```
import sys,math
input = sys.stdin.buffer.readline
def f(x,b,g,lcm):
seq,rest = divmod(x,lcm)
return seq*(lcm-b) + max(0,rest-b+1)
T = int(input())
for testcase in range(T):
a,b,q = map(int,input().split())
if a > b:
a,b = b,a
g = math.gcd(a,b)
lcm = a*b//g
res = []
for i in range(q):
ll,rr = map(int,input().split())
res.append(f(rr,b,g,lcm)-f(ll-1,b,g,lcm))
print(*res)
``` | output | 1 | 6,731 | 22 | 13,463 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.