message stringlengths 2 57.2k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 61 108k | cluster float64 22 22 | __index_level_0__ int64 122 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an integer number n. The following algorithm is applied to it:
1. if n = 0, then end algorithm;
2. find the smallest prime divisor d of n;
3. subtract d from n and go to step 1.
Determine the number of subtrations the algorithm will make.
Input
The only line contains a single integer n (2 ≤ n ≤ 10^{10}).
Output
Print a single integer — the number of subtractions the algorithm will make.
Examples
Input
5
Output
1
Input
4
Output
2
Note
In the first example 5 is the smallest prime divisor, thus it gets subtracted right away to make a 0.
In the second example 2 is the smallest prime divisor at both steps. | instruction | 0 | 58,030 | 22 | 116,060 |
Tags: implementation, math, number theory
Correct Solution:
```
import math
n = int(input())
count = 0
while True:
if n == 0:
break
if n % 2 == 0:
count += (n // 2)
break
i = 2
d = n
while i < int(math.sqrt(n)) + 1:
if n % i == 0:
d = i
break
i += 1
n -= d
count += 1
print(count)
``` | output | 1 | 58,030 | 22 | 116,061 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an integer number n. The following algorithm is applied to it:
1. if n = 0, then end algorithm;
2. find the smallest prime divisor d of n;
3. subtract d from n and go to step 1.
Determine the number of subtrations the algorithm will make.
Input
The only line contains a single integer n (2 ≤ n ≤ 10^{10}).
Output
Print a single integer — the number of subtractions the algorithm will make.
Examples
Input
5
Output
1
Input
4
Output
2
Note
In the first example 5 is the smallest prime divisor, thus it gets subtracted right away to make a 0.
In the second example 2 is the smallest prime divisor at both steps. | instruction | 0 | 58,031 | 22 | 116,062 |
Tags: implementation, math, number theory
Correct Solution:
```
import math
n=int(input())
if n%2==0:
print(n//2)
else:
i=3
f=0
c=0
while(i<=int(math.ceil(math.sqrt(n)))):
if n%i==0:
c+=1
n=n-i
if n%2==0:
f=1
print(c+n//2)
break
else:
i=3
else:
i+=1
if f==0:
print(c+1)
``` | output | 1 | 58,031 | 22 | 116,063 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer number n. The following algorithm is applied to it:
1. if n = 0, then end algorithm;
2. find the smallest prime divisor d of n;
3. subtract d from n and go to step 1.
Determine the number of subtrations the algorithm will make.
Input
The only line contains a single integer n (2 ≤ n ≤ 10^{10}).
Output
Print a single integer — the number of subtractions the algorithm will make.
Examples
Input
5
Output
1
Input
4
Output
2
Note
In the first example 5 is the smallest prime divisor, thus it gets subtracted right away to make a 0.
In the second example 2 is the smallest prime divisor at both steps.
Submitted Solution:
```
n=int(input())
i=2
while i*i<n and n%i:i+=1
if i*i>n:i=n
print(1+(n-i)//2)
``` | instruction | 0 | 58,032 | 22 | 116,064 |
Yes | output | 1 | 58,032 | 22 | 116,065 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer number n. The following algorithm is applied to it:
1. if n = 0, then end algorithm;
2. find the smallest prime divisor d of n;
3. subtract d from n and go to step 1.
Determine the number of subtrations the algorithm will make.
Input
The only line contains a single integer n (2 ≤ n ≤ 10^{10}).
Output
Print a single integer — the number of subtractions the algorithm will make.
Examples
Input
5
Output
1
Input
4
Output
2
Note
In the first example 5 is the smallest prime divisor, thus it gets subtracted right away to make a 0.
In the second example 2 is the smallest prime divisor at both steps.
Submitted Solution:
```
def f(n):
i = 2
while i*i<=n:
if n%i==0:
return i
i+=1
return n
n = int(input())
ans = 0
if n%2==0:
print(n//2)
else:
a = f(n)
n-=a
print((n//2)+1)
``` | instruction | 0 | 58,033 | 22 | 116,066 |
Yes | output | 1 | 58,033 | 22 | 116,067 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer number n. The following algorithm is applied to it:
1. if n = 0, then end algorithm;
2. find the smallest prime divisor d of n;
3. subtract d from n and go to step 1.
Determine the number of subtrations the algorithm will make.
Input
The only line contains a single integer n (2 ≤ n ≤ 10^{10}).
Output
Print a single integer — the number of subtractions the algorithm will make.
Examples
Input
5
Output
1
Input
4
Output
2
Note
In the first example 5 is the smallest prime divisor, thus it gets subtracted right away to make a 0.
In the second example 2 is the smallest prime divisor at both steps.
Submitted Solution:
```
def func():
global x
if x % 2 == 0:
print(x // 2)
else:
count = 0
flag = True
for i in range(3, int(x**(1/2))+1, 2):
if x % i == 0:
x -= i
count += 1
flag = False
break
if flag:
print(1)
return
else:
print(count + x // 2)
x = int(input())
func()
``` | instruction | 0 | 58,034 | 22 | 116,068 |
Yes | output | 1 | 58,034 | 22 | 116,069 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer number n. The following algorithm is applied to it:
1. if n = 0, then end algorithm;
2. find the smallest prime divisor d of n;
3. subtract d from n and go to step 1.
Determine the number of subtrations the algorithm will make.
Input
The only line contains a single integer n (2 ≤ n ≤ 10^{10}).
Output
Print a single integer — the number of subtractions the algorithm will make.
Examples
Input
5
Output
1
Input
4
Output
2
Note
In the first example 5 is the smallest prime divisor, thus it gets subtracted right away to make a 0.
In the second example 2 is the smallest prime divisor at both steps.
Submitted Solution:
```
def mind(n):
d = 3
while d * d <= n:
if n % d == 0:
return d
d += 1
return n
n = int(input())
if n == 0:
print(0)
else:
if n % 2 == 0:
print(n // 2)
else:
res = mind(n)
n -= res
print(n // 2 + 1)
``` | instruction | 0 | 58,035 | 22 | 116,070 |
Yes | output | 1 | 58,035 | 22 | 116,071 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer number n. The following algorithm is applied to it:
1. if n = 0, then end algorithm;
2. find the smallest prime divisor d of n;
3. subtract d from n and go to step 1.
Determine the number of subtrations the algorithm will make.
Input
The only line contains a single integer n (2 ≤ n ≤ 10^{10}).
Output
Print a single integer — the number of subtractions the algorithm will make.
Examples
Input
5
Output
1
Input
4
Output
2
Note
In the first example 5 is the smallest prime divisor, thus it gets subtracted right away to make a 0.
In the second example 2 is the smallest prime divisor at both steps.
Submitted Solution:
```
import math
def isPrime(n):
if (n <= 1):
return False
if (n <= 3):
return True
if (n % 2 == 0 or n % 3 == 0):
return False
i = 5
while (i * i <= n):
if (n % i == 0 or n % (i + 2) == 0):
return False
i = i + 6
return True
n = int(input())
result = 0
def go(k):
global result
if k==0:
return
if k % 2 == 0:
result = k // 2
return
else:
if (isPrime(k)): result+=1; go(0)
for i in range(3, int(math.sqrt(n))+1):
if isPrime(i) and k%i==0:
result+=1
go(k-i)
go(n)
print(result)
``` | instruction | 0 | 58,036 | 22 | 116,072 |
No | output | 1 | 58,036 | 22 | 116,073 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer number n. The following algorithm is applied to it:
1. if n = 0, then end algorithm;
2. find the smallest prime divisor d of n;
3. subtract d from n and go to step 1.
Determine the number of subtrations the algorithm will make.
Input
The only line contains a single integer n (2 ≤ n ≤ 10^{10}).
Output
Print a single integer — the number of subtractions the algorithm will make.
Examples
Input
5
Output
1
Input
4
Output
2
Note
In the first example 5 is the smallest prime divisor, thus it gets subtracted right away to make a 0.
In the second example 2 is the smallest prime divisor at both steps.
Submitted Solution:
```
import sys
LI=lambda:list(map(int, sys.stdin.readline().split()))
MI=lambda:map(int, sys.stdin.readline().split())
SI=lambda:sys.stdin.readline().strip('\n')
II=lambda:int(sys.stdin.readline())
n=II()
ok=[1]*(1000001)
for i in range(2, 1000001):
if ok[i]:
for j in range(i+i, 1000001, i):
ok[j]=0
if n%i==0:
break
print(1+(n-i)//2)
``` | instruction | 0 | 58,037 | 22 | 116,074 |
No | output | 1 | 58,037 | 22 | 116,075 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer number n. The following algorithm is applied to it:
1. if n = 0, then end algorithm;
2. find the smallest prime divisor d of n;
3. subtract d from n and go to step 1.
Determine the number of subtrations the algorithm will make.
Input
The only line contains a single integer n (2 ≤ n ≤ 10^{10}).
Output
Print a single integer — the number of subtractions the algorithm will make.
Examples
Input
5
Output
1
Input
4
Output
2
Note
In the first example 5 is the smallest prime divisor, thus it gets subtracted right away to make a 0.
In the second example 2 is the smallest prime divisor at both steps.
Submitted Solution:
```
n=int(input())
import math
def is_prime(n):
count=0
for i in range(2, int(math.sqrt(n)+1)):
if n%i==0:
count+=1
if count==0:
return True
else:
return False
def cf(n):
if n%2==0:
print(int(n/2))
else:
for i in range(2,int(math.sqrt(n)+1)):
if n%i==0 and is_prime(i)==True:
print (int(((n- i)/2)+1))
break
else:
print("1")
break
cf(n)
``` | instruction | 0 | 58,038 | 22 | 116,076 |
No | output | 1 | 58,038 | 22 | 116,077 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer number n. The following algorithm is applied to it:
1. if n = 0, then end algorithm;
2. find the smallest prime divisor d of n;
3. subtract d from n and go to step 1.
Determine the number of subtrations the algorithm will make.
Input
The only line contains a single integer n (2 ≤ n ≤ 10^{10}).
Output
Print a single integer — the number of subtractions the algorithm will make.
Examples
Input
5
Output
1
Input
4
Output
2
Note
In the first example 5 is the smallest prime divisor, thus it gets subtracted right away to make a 0.
In the second example 2 is the smallest prime divisor at both steps.
Submitted Solution:
```
import math
def smallestDividor(n):
if(n%2 == 0):
return 2
for j in range(3,n+2,2):
if(n%j == 0):
return j
n = int(input())
compt = 0
dep = 2
p = smallestDividor(n)
compt = n//p
print(compt)
``` | instruction | 0 | 58,039 | 22 | 116,078 |
No | output | 1 | 58,039 | 22 | 116,079 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Johnny has recently found an ancient, broken computer. The machine has only one register, which allows one to put in there one variable. Then in one operation, you can shift its bits left or right by at most three positions. The right shift is forbidden if it cuts off some ones. So, in fact, in one operation, you can multiply or divide your number by 2, 4 or 8, and division is only allowed if the number is divisible by the chosen divisor.
Formally, if the register contains a positive integer x, in one operation it can be replaced by one of the following:
* x ⋅ 2
* x ⋅ 4
* x ⋅ 8
* x / 2, if x is divisible by 2
* x / 4, if x is divisible by 4
* x / 8, if x is divisible by 8
For example, if x = 6, in one operation it can be replaced by 12, 24, 48 or 3. Value 6 isn't divisible by 4 or 8, so there're only four variants of replacement.
Now Johnny wonders how many operations he needs to perform if he puts a in the register and wants to get b at the end.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases. The following t lines contain a description of test cases.
The first and only line in each test case contains integers a and b (1 ≤ a, b ≤ 10^{18}) — the initial and target value of the variable, respectively.
Output
Output t lines, each line should contain one integer denoting the minimum number of operations Johnny needs to perform. If Johnny cannot get b at the end, then write -1.
Example
Input
10
10 5
11 44
17 21
1 1
96 3
2 128
1001 1100611139403776
1000000000000000000 1000000000000000000
7 1
10 8
Output
1
1
-1
0
2
2
14
0
-1
-1
Note
In the first test case, Johnny can reach 5 from 10 by using the shift to the right by one (i.e. divide by 2).
In the second test case, Johnny can reach 44 from 11 by using the shift to the left by two (i.e. multiply by 4).
In the third test case, it is impossible for Johnny to reach 21 from 17.
In the fourth test case, initial and target values are equal, so Johnny has to do 0 operations.
In the fifth test case, Johnny can reach 3 from 96 by using two shifts to the right: one by 2, and another by 3 (i.e. divide by 4 and by 8). | instruction | 0 | 59,011 | 22 | 118,022 |
Tags: implementation
Correct Solution:
```
for k in range(int(input())):
a,b=map(int,input().split())
count=0
if(a<b):
while(8*a<=b):
a=a*8
count+=1
while(4*a<=b):
a=a*4
count+=1
while(2*a<=b):
a=a*2
count+=1
if(a==b):
print(count)
else:
print(-1)
else:
while(a>=b*8 and a%8==0):
a=a//8
count+=1
while(a>=b*4 and a%4==0):
a=a//4
count+=1
while(a>=b*2 and a%2==0):
a=a//2
count+=1
if(b==a):
print(count)
else:
print(-1)
``` | output | 1 | 59,011 | 22 | 118,023 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Johnny has recently found an ancient, broken computer. The machine has only one register, which allows one to put in there one variable. Then in one operation, you can shift its bits left or right by at most three positions. The right shift is forbidden if it cuts off some ones. So, in fact, in one operation, you can multiply or divide your number by 2, 4 or 8, and division is only allowed if the number is divisible by the chosen divisor.
Formally, if the register contains a positive integer x, in one operation it can be replaced by one of the following:
* x ⋅ 2
* x ⋅ 4
* x ⋅ 8
* x / 2, if x is divisible by 2
* x / 4, if x is divisible by 4
* x / 8, if x is divisible by 8
For example, if x = 6, in one operation it can be replaced by 12, 24, 48 or 3. Value 6 isn't divisible by 4 or 8, so there're only four variants of replacement.
Now Johnny wonders how many operations he needs to perform if he puts a in the register and wants to get b at the end.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases. The following t lines contain a description of test cases.
The first and only line in each test case contains integers a and b (1 ≤ a, b ≤ 10^{18}) — the initial and target value of the variable, respectively.
Output
Output t lines, each line should contain one integer denoting the minimum number of operations Johnny needs to perform. If Johnny cannot get b at the end, then write -1.
Example
Input
10
10 5
11 44
17 21
1 1
96 3
2 128
1001 1100611139403776
1000000000000000000 1000000000000000000
7 1
10 8
Output
1
1
-1
0
2
2
14
0
-1
-1
Note
In the first test case, Johnny can reach 5 from 10 by using the shift to the right by one (i.e. divide by 2).
In the second test case, Johnny can reach 44 from 11 by using the shift to the left by two (i.e. multiply by 4).
In the third test case, it is impossible for Johnny to reach 21 from 17.
In the fourth test case, initial and target values are equal, so Johnny has to do 0 operations.
In the fifth test case, Johnny can reach 3 from 96 by using two shifts to the right: one by 2, and another by 3 (i.e. divide by 4 and by 8). | instruction | 0 | 59,012 | 22 | 118,024 |
Tags: implementation
Correct Solution:
```
import os
import heapq
import sys
import math
import operator
from collections import defaultdict
from io import BytesIO, IOBase
# def gcd(a,b):
# if b==0:
# return a
# else:
# return gcd(b,a%b)
def inar():
return [int(k) for k in input().split()]
def main():
# mod=10**9+7
for _ in range(int(input())):
#n=int(input())
a,b=map(int,input().split())
#arr=inar()
if a==b:
print(0)
else:
if max(a,b)%min(a,b)!=0:
print(-1)
continue
rem=max(a,b)//min(a,b)
c=0
while 1:
if rem==1:
break
if rem%8==0:
rem=rem//8
c+=1
elif rem%4==0:
rem=rem//4
c+=1
elif rem%2==0:
rem=rem//2
c+=1
else:
if rem!=1:
c=-1
break
elif rem==1:
break
print(c)
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 | 59,012 | 22 | 118,025 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Johnny has recently found an ancient, broken computer. The machine has only one register, which allows one to put in there one variable. Then in one operation, you can shift its bits left or right by at most three positions. The right shift is forbidden if it cuts off some ones. So, in fact, in one operation, you can multiply or divide your number by 2, 4 or 8, and division is only allowed if the number is divisible by the chosen divisor.
Formally, if the register contains a positive integer x, in one operation it can be replaced by one of the following:
* x ⋅ 2
* x ⋅ 4
* x ⋅ 8
* x / 2, if x is divisible by 2
* x / 4, if x is divisible by 4
* x / 8, if x is divisible by 8
For example, if x = 6, in one operation it can be replaced by 12, 24, 48 or 3. Value 6 isn't divisible by 4 or 8, so there're only four variants of replacement.
Now Johnny wonders how many operations he needs to perform if he puts a in the register and wants to get b at the end.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases. The following t lines contain a description of test cases.
The first and only line in each test case contains integers a and b (1 ≤ a, b ≤ 10^{18}) — the initial and target value of the variable, respectively.
Output
Output t lines, each line should contain one integer denoting the minimum number of operations Johnny needs to perform. If Johnny cannot get b at the end, then write -1.
Example
Input
10
10 5
11 44
17 21
1 1
96 3
2 128
1001 1100611139403776
1000000000000000000 1000000000000000000
7 1
10 8
Output
1
1
-1
0
2
2
14
0
-1
-1
Note
In the first test case, Johnny can reach 5 from 10 by using the shift to the right by one (i.e. divide by 2).
In the second test case, Johnny can reach 44 from 11 by using the shift to the left by two (i.e. multiply by 4).
In the third test case, it is impossible for Johnny to reach 21 from 17.
In the fourth test case, initial and target values are equal, so Johnny has to do 0 operations.
In the fifth test case, Johnny can reach 3 from 96 by using two shifts to the right: one by 2, and another by 3 (i.e. divide by 4 and by 8). | instruction | 0 | 59,013 | 22 | 118,026 |
Tags: implementation
Correct Solution:
```
z=int(input())
for q in range(z):
a,b=map(int,input().split())
j = a
a = max(a, b)
b = min(j, b)
if a == b:
print(0)
elif a % b != 0:
print(-1)
else:
x = a // b
cnt = 0
flag = 0
while True:
if x >= 8 and x%8==0:
x = x // 8
cnt += 1
else:
if x == 4 or x == 2:
cnt += 1
break
elif x == 1:
break
else:
flag = 1
break
if flag == 1:
print(-1)
else:
print(cnt)
``` | output | 1 | 59,013 | 22 | 118,027 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Johnny has recently found an ancient, broken computer. The machine has only one register, which allows one to put in there one variable. Then in one operation, you can shift its bits left or right by at most three positions. The right shift is forbidden if it cuts off some ones. So, in fact, in one operation, you can multiply or divide your number by 2, 4 or 8, and division is only allowed if the number is divisible by the chosen divisor.
Formally, if the register contains a positive integer x, in one operation it can be replaced by one of the following:
* x ⋅ 2
* x ⋅ 4
* x ⋅ 8
* x / 2, if x is divisible by 2
* x / 4, if x is divisible by 4
* x / 8, if x is divisible by 8
For example, if x = 6, in one operation it can be replaced by 12, 24, 48 or 3. Value 6 isn't divisible by 4 or 8, so there're only four variants of replacement.
Now Johnny wonders how many operations he needs to perform if he puts a in the register and wants to get b at the end.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases. The following t lines contain a description of test cases.
The first and only line in each test case contains integers a and b (1 ≤ a, b ≤ 10^{18}) — the initial and target value of the variable, respectively.
Output
Output t lines, each line should contain one integer denoting the minimum number of operations Johnny needs to perform. If Johnny cannot get b at the end, then write -1.
Example
Input
10
10 5
11 44
17 21
1 1
96 3
2 128
1001 1100611139403776
1000000000000000000 1000000000000000000
7 1
10 8
Output
1
1
-1
0
2
2
14
0
-1
-1
Note
In the first test case, Johnny can reach 5 from 10 by using the shift to the right by one (i.e. divide by 2).
In the second test case, Johnny can reach 44 from 11 by using the shift to the left by two (i.e. multiply by 4).
In the third test case, it is impossible for Johnny to reach 21 from 17.
In the fourth test case, initial and target values are equal, so Johnny has to do 0 operations.
In the fifth test case, Johnny can reach 3 from 96 by using two shifts to the right: one by 2, and another by 3 (i.e. divide by 4 and by 8). | instruction | 0 | 59,014 | 22 | 118,028 |
Tags: implementation
Correct Solution:
```
t = int(input())
for _ in range(t):
a, b = map(int, input().split())
if(b>a):
if(b%a!=0):
print("-1")
else:
x = bin(b//a)[2::].count("1")
if(x!=1):
print("-1")
else:
y = bin(b//a)[2::].count("0")
ans = 0
ans += y//3
y = y - (y//3)*3
ans += y//2
y = y - (y//2)*2
ans += y
print(ans)
elif(a>b):
a, b = b, a
if(b%a!=0):
print("-1")
else:
x = bin(b//a)[2::].count("1")
if(x!=1):
print("-1")
else:
y = bin(b//a)[2::].count("0")
ans = 0
ans += y//3
y = y - (y//3)*3
ans += y//2
y = y - (y//2)*2
ans += y
print(ans)
else:
print("0")
``` | output | 1 | 59,014 | 22 | 118,029 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Johnny has recently found an ancient, broken computer. The machine has only one register, which allows one to put in there one variable. Then in one operation, you can shift its bits left or right by at most three positions. The right shift is forbidden if it cuts off some ones. So, in fact, in one operation, you can multiply or divide your number by 2, 4 or 8, and division is only allowed if the number is divisible by the chosen divisor.
Formally, if the register contains a positive integer x, in one operation it can be replaced by one of the following:
* x ⋅ 2
* x ⋅ 4
* x ⋅ 8
* x / 2, if x is divisible by 2
* x / 4, if x is divisible by 4
* x / 8, if x is divisible by 8
For example, if x = 6, in one operation it can be replaced by 12, 24, 48 or 3. Value 6 isn't divisible by 4 or 8, so there're only four variants of replacement.
Now Johnny wonders how many operations he needs to perform if he puts a in the register and wants to get b at the end.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases. The following t lines contain a description of test cases.
The first and only line in each test case contains integers a and b (1 ≤ a, b ≤ 10^{18}) — the initial and target value of the variable, respectively.
Output
Output t lines, each line should contain one integer denoting the minimum number of operations Johnny needs to perform. If Johnny cannot get b at the end, then write -1.
Example
Input
10
10 5
11 44
17 21
1 1
96 3
2 128
1001 1100611139403776
1000000000000000000 1000000000000000000
7 1
10 8
Output
1
1
-1
0
2
2
14
0
-1
-1
Note
In the first test case, Johnny can reach 5 from 10 by using the shift to the right by one (i.e. divide by 2).
In the second test case, Johnny can reach 44 from 11 by using the shift to the left by two (i.e. multiply by 4).
In the third test case, it is impossible for Johnny to reach 21 from 17.
In the fourth test case, initial and target values are equal, so Johnny has to do 0 operations.
In the fifth test case, Johnny can reach 3 from 96 by using two shifts to the right: one by 2, and another by 3 (i.e. divide by 4 and by 8). | instruction | 0 | 59,015 | 22 | 118,030 |
Tags: implementation
Correct Solution:
```
import math
t=int(input())
for i in range(t):
a,b=map(int,input().split())
if a==b:
print(0)
elif a>b:
if a%b==0:
c=a//b
v=1
d=0
for j in range(1,61):
v*=2
if c==v:
if j%3==0:
b=0
else:
b=1
print(b+j//3)
d=1
break
elif c<v:
break
if d==0:
print(-1)
else:
print(-1)
else:
if b%a==0:
c=b//a
v=1
d=0
for j in range(1,61):
v*=2
if c==v:
if j%3==0:
b=0
else:
b=1
print(b+j//3)
d=1
break
elif c<v:
break
if d==0:
print(-1)
else:
print(-1)
``` | output | 1 | 59,015 | 22 | 118,031 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Johnny has recently found an ancient, broken computer. The machine has only one register, which allows one to put in there one variable. Then in one operation, you can shift its bits left or right by at most three positions. The right shift is forbidden if it cuts off some ones. So, in fact, in one operation, you can multiply or divide your number by 2, 4 or 8, and division is only allowed if the number is divisible by the chosen divisor.
Formally, if the register contains a positive integer x, in one operation it can be replaced by one of the following:
* x ⋅ 2
* x ⋅ 4
* x ⋅ 8
* x / 2, if x is divisible by 2
* x / 4, if x is divisible by 4
* x / 8, if x is divisible by 8
For example, if x = 6, in one operation it can be replaced by 12, 24, 48 or 3. Value 6 isn't divisible by 4 or 8, so there're only four variants of replacement.
Now Johnny wonders how many operations he needs to perform if he puts a in the register and wants to get b at the end.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases. The following t lines contain a description of test cases.
The first and only line in each test case contains integers a and b (1 ≤ a, b ≤ 10^{18}) — the initial and target value of the variable, respectively.
Output
Output t lines, each line should contain one integer denoting the minimum number of operations Johnny needs to perform. If Johnny cannot get b at the end, then write -1.
Example
Input
10
10 5
11 44
17 21
1 1
96 3
2 128
1001 1100611139403776
1000000000000000000 1000000000000000000
7 1
10 8
Output
1
1
-1
0
2
2
14
0
-1
-1
Note
In the first test case, Johnny can reach 5 from 10 by using the shift to the right by one (i.e. divide by 2).
In the second test case, Johnny can reach 44 from 11 by using the shift to the left by two (i.e. multiply by 4).
In the third test case, it is impossible for Johnny to reach 21 from 17.
In the fourth test case, initial and target values are equal, so Johnny has to do 0 operations.
In the fifth test case, Johnny can reach 3 from 96 by using two shifts to the right: one by 2, and another by 3 (i.e. divide by 4 and by 8). | instruction | 0 | 59,016 | 22 | 118,032 |
Tags: implementation
Correct Solution:
```
def foo(a,b):
ans = 0
while b!=a:
if b%8==0 and b//8>=a:
b//=8
ans += 1
continue
if b%4==0 and b//4>=a:
b//=4
ans += 1
continue
if b%2==0 and b//2>=a:
b//=2
ans += 1
continue
return -1
return ans
for _ in range(int(input())):
a,b = map(int,input().split())
if b<a:
temp = a
a = b
b = temp
print(foo(a,b))
``` | output | 1 | 59,016 | 22 | 118,033 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Johnny has recently found an ancient, broken computer. The machine has only one register, which allows one to put in there one variable. Then in one operation, you can shift its bits left or right by at most three positions. The right shift is forbidden if it cuts off some ones. So, in fact, in one operation, you can multiply or divide your number by 2, 4 or 8, and division is only allowed if the number is divisible by the chosen divisor.
Formally, if the register contains a positive integer x, in one operation it can be replaced by one of the following:
* x ⋅ 2
* x ⋅ 4
* x ⋅ 8
* x / 2, if x is divisible by 2
* x / 4, if x is divisible by 4
* x / 8, if x is divisible by 8
For example, if x = 6, in one operation it can be replaced by 12, 24, 48 or 3. Value 6 isn't divisible by 4 or 8, so there're only four variants of replacement.
Now Johnny wonders how many operations he needs to perform if he puts a in the register and wants to get b at the end.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases. The following t lines contain a description of test cases.
The first and only line in each test case contains integers a and b (1 ≤ a, b ≤ 10^{18}) — the initial and target value of the variable, respectively.
Output
Output t lines, each line should contain one integer denoting the minimum number of operations Johnny needs to perform. If Johnny cannot get b at the end, then write -1.
Example
Input
10
10 5
11 44
17 21
1 1
96 3
2 128
1001 1100611139403776
1000000000000000000 1000000000000000000
7 1
10 8
Output
1
1
-1
0
2
2
14
0
-1
-1
Note
In the first test case, Johnny can reach 5 from 10 by using the shift to the right by one (i.e. divide by 2).
In the second test case, Johnny can reach 44 from 11 by using the shift to the left by two (i.e. multiply by 4).
In the third test case, it is impossible for Johnny to reach 21 from 17.
In the fourth test case, initial and target values are equal, so Johnny has to do 0 operations.
In the fifth test case, Johnny can reach 3 from 96 by using two shifts to the right: one by 2, and another by 3 (i.e. divide by 4 and by 8). | instruction | 0 | 59,017 | 22 | 118,034 |
Tags: implementation
Correct 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().rstrip("\r\n")
# ------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
from math import factorial
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush
# ------------------------------
# f = open('../input.txt')
# sys.stdin = f
def main():
for _ in range(N()):
a, b = RL()
ra = rb = 0
while a&1==0:
a>>=1
ra+=1
while b&1==0:
b>>=1
rb+=1
if a!=b:
print(-1)
else:
zero = abs(ra-rb)
res = 0
res += zero//3
zero = zero%3
res += zero//2
zero = zero%2
res+=zero
print(res)
if __name__ == "__main__":
main()
``` | output | 1 | 59,017 | 22 | 118,035 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Johnny has recently found an ancient, broken computer. The machine has only one register, which allows one to put in there one variable. Then in one operation, you can shift its bits left or right by at most three positions. The right shift is forbidden if it cuts off some ones. So, in fact, in one operation, you can multiply or divide your number by 2, 4 or 8, and division is only allowed if the number is divisible by the chosen divisor.
Formally, if the register contains a positive integer x, in one operation it can be replaced by one of the following:
* x ⋅ 2
* x ⋅ 4
* x ⋅ 8
* x / 2, if x is divisible by 2
* x / 4, if x is divisible by 4
* x / 8, if x is divisible by 8
For example, if x = 6, in one operation it can be replaced by 12, 24, 48 or 3. Value 6 isn't divisible by 4 or 8, so there're only four variants of replacement.
Now Johnny wonders how many operations he needs to perform if he puts a in the register and wants to get b at the end.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases. The following t lines contain a description of test cases.
The first and only line in each test case contains integers a and b (1 ≤ a, b ≤ 10^{18}) — the initial and target value of the variable, respectively.
Output
Output t lines, each line should contain one integer denoting the minimum number of operations Johnny needs to perform. If Johnny cannot get b at the end, then write -1.
Example
Input
10
10 5
11 44
17 21
1 1
96 3
2 128
1001 1100611139403776
1000000000000000000 1000000000000000000
7 1
10 8
Output
1
1
-1
0
2
2
14
0
-1
-1
Note
In the first test case, Johnny can reach 5 from 10 by using the shift to the right by one (i.e. divide by 2).
In the second test case, Johnny can reach 44 from 11 by using the shift to the left by two (i.e. multiply by 4).
In the third test case, it is impossible for Johnny to reach 21 from 17.
In the fourth test case, initial and target values are equal, so Johnny has to do 0 operations.
In the fifth test case, Johnny can reach 3 from 96 by using two shifts to the right: one by 2, and another by 3 (i.e. divide by 4 and by 8). | instruction | 0 | 59,018 | 22 | 118,036 |
Tags: implementation
Correct Solution:
```
t=int(input())
for i in range(t):
a,b=list(map(int,input().split()))
if a==b:
print(0)
else:
if a>b:
a,b=b,a
s1=bin(b)
s2=bin(a)
try:
if not s1.index(s2)==0:
print(-1)
continue
except ValueError:
print(-1)
continue
s1=s1[len(s2):]
if '1' in s1:
print(-1)
continue
l=len(s1)
if l%3==0:
print(l//3)
else:
print(1+l//3)
``` | output | 1 | 59,018 | 22 | 118,037 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Johnny has recently found an ancient, broken computer. The machine has only one register, which allows one to put in there one variable. Then in one operation, you can shift its bits left or right by at most three positions. The right shift is forbidden if it cuts off some ones. So, in fact, in one operation, you can multiply or divide your number by 2, 4 or 8, and division is only allowed if the number is divisible by the chosen divisor.
Formally, if the register contains a positive integer x, in one operation it can be replaced by one of the following:
* x ⋅ 2
* x ⋅ 4
* x ⋅ 8
* x / 2, if x is divisible by 2
* x / 4, if x is divisible by 4
* x / 8, if x is divisible by 8
For example, if x = 6, in one operation it can be replaced by 12, 24, 48 or 3. Value 6 isn't divisible by 4 or 8, so there're only four variants of replacement.
Now Johnny wonders how many operations he needs to perform if he puts a in the register and wants to get b at the end.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases. The following t lines contain a description of test cases.
The first and only line in each test case contains integers a and b (1 ≤ a, b ≤ 10^{18}) — the initial and target value of the variable, respectively.
Output
Output t lines, each line should contain one integer denoting the minimum number of operations Johnny needs to perform. If Johnny cannot get b at the end, then write -1.
Example
Input
10
10 5
11 44
17 21
1 1
96 3
2 128
1001 1100611139403776
1000000000000000000 1000000000000000000
7 1
10 8
Output
1
1
-1
0
2
2
14
0
-1
-1
Note
In the first test case, Johnny can reach 5 from 10 by using the shift to the right by one (i.e. divide by 2).
In the second test case, Johnny can reach 44 from 11 by using the shift to the left by two (i.e. multiply by 4).
In the third test case, it is impossible for Johnny to reach 21 from 17.
In the fourth test case, initial and target values are equal, so Johnny has to do 0 operations.
In the fifth test case, Johnny can reach 3 from 96 by using two shifts to the right: one by 2, and another by 3 (i.e. divide by 4 and by 8).
Submitted Solution:
```
import sys
from math import log2 as log
input = sys.stdin.buffer.readline
def I(): return(list(map(int,input().split())))
def sieve(n):
a=[1]*n
for i in range(2,n):
if a[i]:
for j in range(i*i,n,i):
a[j]=0
return a
for __ in range(int(input())):
a,b=I()
b,a=max(a,b),min(a,b)
if b%a!=0:
print(-1)
continue
x=log((b//a))
if b//a!=2**int(x):
print(-1)
continue
else:
x=int(x)
m=0
m+=x//3
x%=3
m+=x//2
x%=2
m+=x
print(m)
``` | instruction | 0 | 59,019 | 22 | 118,038 |
Yes | output | 1 | 59,019 | 22 | 118,039 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Johnny has recently found an ancient, broken computer. The machine has only one register, which allows one to put in there one variable. Then in one operation, you can shift its bits left or right by at most three positions. The right shift is forbidden if it cuts off some ones. So, in fact, in one operation, you can multiply or divide your number by 2, 4 or 8, and division is only allowed if the number is divisible by the chosen divisor.
Formally, if the register contains a positive integer x, in one operation it can be replaced by one of the following:
* x ⋅ 2
* x ⋅ 4
* x ⋅ 8
* x / 2, if x is divisible by 2
* x / 4, if x is divisible by 4
* x / 8, if x is divisible by 8
For example, if x = 6, in one operation it can be replaced by 12, 24, 48 or 3. Value 6 isn't divisible by 4 or 8, so there're only four variants of replacement.
Now Johnny wonders how many operations he needs to perform if he puts a in the register and wants to get b at the end.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases. The following t lines contain a description of test cases.
The first and only line in each test case contains integers a and b (1 ≤ a, b ≤ 10^{18}) — the initial and target value of the variable, respectively.
Output
Output t lines, each line should contain one integer denoting the minimum number of operations Johnny needs to perform. If Johnny cannot get b at the end, then write -1.
Example
Input
10
10 5
11 44
17 21
1 1
96 3
2 128
1001 1100611139403776
1000000000000000000 1000000000000000000
7 1
10 8
Output
1
1
-1
0
2
2
14
0
-1
-1
Note
In the first test case, Johnny can reach 5 from 10 by using the shift to the right by one (i.e. divide by 2).
In the second test case, Johnny can reach 44 from 11 by using the shift to the left by two (i.e. multiply by 4).
In the third test case, it is impossible for Johnny to reach 21 from 17.
In the fourth test case, initial and target values are equal, so Johnny has to do 0 operations.
In the fifth test case, Johnny can reach 3 from 96 by using two shifts to the right: one by 2, and another by 3 (i.e. divide by 4 and by 8).
Submitted Solution:
```
for i in range(int(input())):
a,b = map(int,input().split())
x,y = max(a,b),min(a,b)
c=0
while y<x:
y = y*8
c+=1
if x==y or y//4==x or y//2==x:
print(c)
else:
print (-1)
``` | instruction | 0 | 59,020 | 22 | 118,040 |
Yes | output | 1 | 59,020 | 22 | 118,041 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Johnny has recently found an ancient, broken computer. The machine has only one register, which allows one to put in there one variable. Then in one operation, you can shift its bits left or right by at most three positions. The right shift is forbidden if it cuts off some ones. So, in fact, in one operation, you can multiply or divide your number by 2, 4 or 8, and division is only allowed if the number is divisible by the chosen divisor.
Formally, if the register contains a positive integer x, in one operation it can be replaced by one of the following:
* x ⋅ 2
* x ⋅ 4
* x ⋅ 8
* x / 2, if x is divisible by 2
* x / 4, if x is divisible by 4
* x / 8, if x is divisible by 8
For example, if x = 6, in one operation it can be replaced by 12, 24, 48 or 3. Value 6 isn't divisible by 4 or 8, so there're only four variants of replacement.
Now Johnny wonders how many operations he needs to perform if he puts a in the register and wants to get b at the end.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases. The following t lines contain a description of test cases.
The first and only line in each test case contains integers a and b (1 ≤ a, b ≤ 10^{18}) — the initial and target value of the variable, respectively.
Output
Output t lines, each line should contain one integer denoting the minimum number of operations Johnny needs to perform. If Johnny cannot get b at the end, then write -1.
Example
Input
10
10 5
11 44
17 21
1 1
96 3
2 128
1001 1100611139403776
1000000000000000000 1000000000000000000
7 1
10 8
Output
1
1
-1
0
2
2
14
0
-1
-1
Note
In the first test case, Johnny can reach 5 from 10 by using the shift to the right by one (i.e. divide by 2).
In the second test case, Johnny can reach 44 from 11 by using the shift to the left by two (i.e. multiply by 4).
In the third test case, it is impossible for Johnny to reach 21 from 17.
In the fourth test case, initial and target values are equal, so Johnny has to do 0 operations.
In the fifth test case, Johnny can reach 3 from 96 by using two shifts to the right: one by 2, and another by 3 (i.e. divide by 4 and by 8).
Submitted Solution:
```
t = int(input())
for _ in range(t):
a, b = list(map(int, input().split()))
a, b = bin(a)[2:], bin(b)[2:]
if a == b:
print(0)
continue
if b > a:
l = (len(b) - len(a))
e = a + '0'*l
t = e == b
else:
l = (len(a) - len(b))
e = b + '0'*l
t = e == a
if not t:
print(-1)
else:
o = 0
for v in range(3, 0, -1):
m = l // v
o += m
l -= m * v
print(o)
``` | instruction | 0 | 59,021 | 22 | 118,042 |
Yes | output | 1 | 59,021 | 22 | 118,043 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Johnny has recently found an ancient, broken computer. The machine has only one register, which allows one to put in there one variable. Then in one operation, you can shift its bits left or right by at most three positions. The right shift is forbidden if it cuts off some ones. So, in fact, in one operation, you can multiply or divide your number by 2, 4 or 8, and division is only allowed if the number is divisible by the chosen divisor.
Formally, if the register contains a positive integer x, in one operation it can be replaced by one of the following:
* x ⋅ 2
* x ⋅ 4
* x ⋅ 8
* x / 2, if x is divisible by 2
* x / 4, if x is divisible by 4
* x / 8, if x is divisible by 8
For example, if x = 6, in one operation it can be replaced by 12, 24, 48 or 3. Value 6 isn't divisible by 4 or 8, so there're only four variants of replacement.
Now Johnny wonders how many operations he needs to perform if he puts a in the register and wants to get b at the end.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases. The following t lines contain a description of test cases.
The first and only line in each test case contains integers a and b (1 ≤ a, b ≤ 10^{18}) — the initial and target value of the variable, respectively.
Output
Output t lines, each line should contain one integer denoting the minimum number of operations Johnny needs to perform. If Johnny cannot get b at the end, then write -1.
Example
Input
10
10 5
11 44
17 21
1 1
96 3
2 128
1001 1100611139403776
1000000000000000000 1000000000000000000
7 1
10 8
Output
1
1
-1
0
2
2
14
0
-1
-1
Note
In the first test case, Johnny can reach 5 from 10 by using the shift to the right by one (i.e. divide by 2).
In the second test case, Johnny can reach 44 from 11 by using the shift to the left by two (i.e. multiply by 4).
In the third test case, it is impossible for Johnny to reach 21 from 17.
In the fourth test case, initial and target values are equal, so Johnny has to do 0 operations.
In the fifth test case, Johnny can reach 3 from 96 by using two shifts to the right: one by 2, and another by 3 (i.e. divide by 4 and by 8).
Submitted Solution:
```
from math import log,floor
def main():
T=int(input())
for _ in range(T):
a,b=map(int,input().split())
if max(a,b)%min(a,b)!=0:
print(-1)
elif a==b:
print(0)
else:
ans=0
val=max(b,a)//min(b,a)
if val&(val-1)==0:
log8=floor(log(val,8))
log4=floor(log(val,4))
log2=floor(log(val,2))
if log8>=1:
val=val//pow(8,log8)
log4=floor(log(val,4))
log2=floor(log(val,2))
ans+=log8
if log4>=1:
val=val//pow(4,log4)
log2=floor(log(val,2))
ans+=log4
if log2>=1:
val=val//pow(2,log2)
ans+=log2
elif log2>=1:
val=val//pow(2,log2)
ans+=log2
elif log4>=1:
val=val//pow(4,log4)
log2=floor(log(val,2))
ans+=log4
if log2>=1:
val=val//pow(2,log2)
ans+=log2
elif log2>=1:
val=val//pow(2,log2)
ans+=log2
print(ans)
else:
print(-1)
if __name__=='__main__':
main()
``` | instruction | 0 | 59,022 | 22 | 118,044 |
Yes | output | 1 | 59,022 | 22 | 118,045 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Johnny has recently found an ancient, broken computer. The machine has only one register, which allows one to put in there one variable. Then in one operation, you can shift its bits left or right by at most three positions. The right shift is forbidden if it cuts off some ones. So, in fact, in one operation, you can multiply or divide your number by 2, 4 or 8, and division is only allowed if the number is divisible by the chosen divisor.
Formally, if the register contains a positive integer x, in one operation it can be replaced by one of the following:
* x ⋅ 2
* x ⋅ 4
* x ⋅ 8
* x / 2, if x is divisible by 2
* x / 4, if x is divisible by 4
* x / 8, if x is divisible by 8
For example, if x = 6, in one operation it can be replaced by 12, 24, 48 or 3. Value 6 isn't divisible by 4 or 8, so there're only four variants of replacement.
Now Johnny wonders how many operations he needs to perform if he puts a in the register and wants to get b at the end.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases. The following t lines contain a description of test cases.
The first and only line in each test case contains integers a and b (1 ≤ a, b ≤ 10^{18}) — the initial and target value of the variable, respectively.
Output
Output t lines, each line should contain one integer denoting the minimum number of operations Johnny needs to perform. If Johnny cannot get b at the end, then write -1.
Example
Input
10
10 5
11 44
17 21
1 1
96 3
2 128
1001 1100611139403776
1000000000000000000 1000000000000000000
7 1
10 8
Output
1
1
-1
0
2
2
14
0
-1
-1
Note
In the first test case, Johnny can reach 5 from 10 by using the shift to the right by one (i.e. divide by 2).
In the second test case, Johnny can reach 44 from 11 by using the shift to the left by two (i.e. multiply by 4).
In the third test case, it is impossible for Johnny to reach 21 from 17.
In the fourth test case, initial and target values are equal, so Johnny has to do 0 operations.
In the fifth test case, Johnny can reach 3 from 96 by using two shifts to the right: one by 2, and another by 3 (i.e. divide by 4 and by 8).
Submitted Solution:
```
t=int(input())
res=[]
import math
for i in range(t):
a,b = map(int,input().split())
if a>b:
if (a/b)%2!=0 or a%b!=0:
res.append(-1)
else:
log = math.log((a//b), 2)
r=0
r+=log//3
resto = log%3
if resto!=0:
r+=1
res.append(int(r))
elif b>a:
if (b/a)%2!=0 or b%a!=0:
res.append(-1)
else:
log = math.log((b//a), 2)
r=0
r+=log//3
resto = log%3
if resto!=0:
r+=1
res.append(int(r))
else:
res.append(0)
for r in res:
print(r)
``` | instruction | 0 | 59,023 | 22 | 118,046 |
No | output | 1 | 59,023 | 22 | 118,047 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Johnny has recently found an ancient, broken computer. The machine has only one register, which allows one to put in there one variable. Then in one operation, you can shift its bits left or right by at most three positions. The right shift is forbidden if it cuts off some ones. So, in fact, in one operation, you can multiply or divide your number by 2, 4 or 8, and division is only allowed if the number is divisible by the chosen divisor.
Formally, if the register contains a positive integer x, in one operation it can be replaced by one of the following:
* x ⋅ 2
* x ⋅ 4
* x ⋅ 8
* x / 2, if x is divisible by 2
* x / 4, if x is divisible by 4
* x / 8, if x is divisible by 8
For example, if x = 6, in one operation it can be replaced by 12, 24, 48 or 3. Value 6 isn't divisible by 4 or 8, so there're only four variants of replacement.
Now Johnny wonders how many operations he needs to perform if he puts a in the register and wants to get b at the end.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases. The following t lines contain a description of test cases.
The first and only line in each test case contains integers a and b (1 ≤ a, b ≤ 10^{18}) — the initial and target value of the variable, respectively.
Output
Output t lines, each line should contain one integer denoting the minimum number of operations Johnny needs to perform. If Johnny cannot get b at the end, then write -1.
Example
Input
10
10 5
11 44
17 21
1 1
96 3
2 128
1001 1100611139403776
1000000000000000000 1000000000000000000
7 1
10 8
Output
1
1
-1
0
2
2
14
0
-1
-1
Note
In the first test case, Johnny can reach 5 from 10 by using the shift to the right by one (i.e. divide by 2).
In the second test case, Johnny can reach 44 from 11 by using the shift to the left by two (i.e. multiply by 4).
In the third test case, it is impossible for Johnny to reach 21 from 17.
In the fourth test case, initial and target values are equal, so Johnny has to do 0 operations.
In the fifth test case, Johnny can reach 3 from 96 by using two shifts to the right: one by 2, and another by 3 (i.e. divide by 4 and by 8).
Submitted Solution:
```
import sys
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def input(): return sys.stdin.readline().strip()
mod = 1000000007
from math import log
t = int(input())
for _ in range(t):
a,b = get_ints()
if a == b:
print(0)
continue
flag = 0
if a > b:
flag = 1
s = min(a,b)
m = max(a,b)
n = log(m/s,2)
l = m
ans = 0
if (m/s)%2 != 0:
print(-1)
continue
if n >=3:
ans += n//3
n %= 3
if n >= 2:
ans += n//2
n %= 2
ans += n
if flag == 1:
flag_z = 0
for i in range(int(n)):
if (1<<i)&m == 1:
flag_z = 1
if flag_z == 1:
print(-1)
else:
print(int(ans))
else:
print(int(ans))
``` | instruction | 0 | 59,024 | 22 | 118,048 |
No | output | 1 | 59,024 | 22 | 118,049 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Johnny has recently found an ancient, broken computer. The machine has only one register, which allows one to put in there one variable. Then in one operation, you can shift its bits left or right by at most three positions. The right shift is forbidden if it cuts off some ones. So, in fact, in one operation, you can multiply or divide your number by 2, 4 or 8, and division is only allowed if the number is divisible by the chosen divisor.
Formally, if the register contains a positive integer x, in one operation it can be replaced by one of the following:
* x ⋅ 2
* x ⋅ 4
* x ⋅ 8
* x / 2, if x is divisible by 2
* x / 4, if x is divisible by 4
* x / 8, if x is divisible by 8
For example, if x = 6, in one operation it can be replaced by 12, 24, 48 or 3. Value 6 isn't divisible by 4 or 8, so there're only four variants of replacement.
Now Johnny wonders how many operations he needs to perform if he puts a in the register and wants to get b at the end.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases. The following t lines contain a description of test cases.
The first and only line in each test case contains integers a and b (1 ≤ a, b ≤ 10^{18}) — the initial and target value of the variable, respectively.
Output
Output t lines, each line should contain one integer denoting the minimum number of operations Johnny needs to perform. If Johnny cannot get b at the end, then write -1.
Example
Input
10
10 5
11 44
17 21
1 1
96 3
2 128
1001 1100611139403776
1000000000000000000 1000000000000000000
7 1
10 8
Output
1
1
-1
0
2
2
14
0
-1
-1
Note
In the first test case, Johnny can reach 5 from 10 by using the shift to the right by one (i.e. divide by 2).
In the second test case, Johnny can reach 44 from 11 by using the shift to the left by two (i.e. multiply by 4).
In the third test case, it is impossible for Johnny to reach 21 from 17.
In the fourth test case, initial and target values are equal, so Johnny has to do 0 operations.
In the fifth test case, Johnny can reach 3 from 96 by using two shifts to the right: one by 2, and another by 3 (i.e. divide by 4 and by 8).
Submitted Solution:
```
import math
# Function to check
# Log base 2
def Log2(x):
if x == 0:
return false;
return (math.log10(x) /
math.log10(2));
# Function to check
# if x is power of 2
def isPowerOfTwo(n):
return (math.ceil(Log2(n)) ==
math.floor(Log2(n)));
def find_power(n):
count=0
while(n>1):
count+=1
n=n//2
return count;
for i in range(int(input())):
a,b=map(int,input().split())
x=max(a,b)
y=min(a,b)
z=x/y
if( isPowerOfTwo(z)):
power=find_power(z)
ans=0
while(power>0):
if(power>2):
ans+=1
power-=3
elif(power>1):
ans+=1
power-=2
elif(power==1):
ans+=1
power-=1
elif(power==0):
break
print(ans)
else:
print(-1)
``` | instruction | 0 | 59,025 | 22 | 118,050 |
No | output | 1 | 59,025 | 22 | 118,051 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Johnny has recently found an ancient, broken computer. The machine has only one register, which allows one to put in there one variable. Then in one operation, you can shift its bits left or right by at most three positions. The right shift is forbidden if it cuts off some ones. So, in fact, in one operation, you can multiply or divide your number by 2, 4 or 8, and division is only allowed if the number is divisible by the chosen divisor.
Formally, if the register contains a positive integer x, in one operation it can be replaced by one of the following:
* x ⋅ 2
* x ⋅ 4
* x ⋅ 8
* x / 2, if x is divisible by 2
* x / 4, if x is divisible by 4
* x / 8, if x is divisible by 8
For example, if x = 6, in one operation it can be replaced by 12, 24, 48 or 3. Value 6 isn't divisible by 4 or 8, so there're only four variants of replacement.
Now Johnny wonders how many operations he needs to perform if he puts a in the register and wants to get b at the end.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases. The following t lines contain a description of test cases.
The first and only line in each test case contains integers a and b (1 ≤ a, b ≤ 10^{18}) — the initial and target value of the variable, respectively.
Output
Output t lines, each line should contain one integer denoting the minimum number of operations Johnny needs to perform. If Johnny cannot get b at the end, then write -1.
Example
Input
10
10 5
11 44
17 21
1 1
96 3
2 128
1001 1100611139403776
1000000000000000000 1000000000000000000
7 1
10 8
Output
1
1
-1
0
2
2
14
0
-1
-1
Note
In the first test case, Johnny can reach 5 from 10 by using the shift to the right by one (i.e. divide by 2).
In the second test case, Johnny can reach 44 from 11 by using the shift to the left by two (i.e. multiply by 4).
In the third test case, it is impossible for Johnny to reach 21 from 17.
In the fourth test case, initial and target values are equal, so Johnny has to do 0 operations.
In the fifth test case, Johnny can reach 3 from 96 by using two shifts to the right: one by 2, and another by 3 (i.e. divide by 4 and by 8).
Submitted Solution:
```
n=int(input())
for i in range(n):
out=0
a,b=map(int,input().split())
if b>a:
a,b=b,a
if a==b:
print(0)
continue
while True:
befa=a
if a%2==0:
a//=2
print(a)
if a==b:
out+=1
print(out)
break
a=befa
if a%4==0:
a//=4
if a==b:
out+=1
print(out)
break
a=befa
if a%8==0:
a//=8
out+=1
if a==b:
print(out)
break
else:
print(-1)
break
``` | instruction | 0 | 59,026 | 22 | 118,052 |
No | output | 1 | 59,026 | 22 | 118,053 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The \text{gcdSum} of a positive integer is the gcd of that integer with its sum of digits. Formally, \text{gcdSum}(x) = gcd(x, sum of digits of x) for a positive integer x. gcd(a, b) denotes the greatest common divisor of a and b — the largest integer d such that both integers a and b are divisible by d.
For example: \text{gcdSum}(762) = gcd(762, 7 + 6 + 2)=gcd(762,15) = 3.
Given an integer n, find the smallest integer x ≥ n such that \text{gcdSum}(x) > 1.
Input
The first line of input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t lines follow, each containing a single integer n (1 ≤ n ≤ 10^{18}).
All test cases in one test are different.
Output
Output t lines, where the i-th line is a single integer containing the answer to the i-th test case.
Example
Input
3
11
31
75
Output
12
33
75
Note
Let us explain the three test cases in the sample.
Test case 1: n = 11:
\text{gcdSum}(11) = gcd(11, 1 + 1) = gcd(11,\ 2) = 1.
\text{gcdSum}(12) = gcd(12, 1 + 2) = gcd(12,\ 3) = 3.
So the smallest number ≥ 11 whose gcdSum > 1 is 12.
Test case 2: n = 31:
\text{gcdSum}(31) = gcd(31, 3 + 1) = gcd(31,\ 4) = 1.
\text{gcdSum}(32) = gcd(32, 3 + 2) = gcd(32,\ 5) = 1.
\text{gcdSum}(33) = gcd(33, 3 + 3) = gcd(33,\ 6) = 3.
So the smallest number ≥ 31 whose gcdSum > 1 is 33.
Test case 3: \ n = 75:
\text{gcdSum}(75) = gcd(75, 7 + 5) = gcd(75,\ 12) = 3.
The \text{gcdSum} of 75 is already > 1. Hence, it is the answer. | instruction | 0 | 59,065 | 22 | 118,130 |
Tags: brute force, math
Correct Solution:
```
import math
for _ in range(int(input())):
n=input()
while math.gcd(int(n),sum([int(i) for i in n]))==1:
n=str(int(n)+1)
print(n)
``` | output | 1 | 59,065 | 22 | 118,131 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The \text{gcdSum} of a positive integer is the gcd of that integer with its sum of digits. Formally, \text{gcdSum}(x) = gcd(x, sum of digits of x) for a positive integer x. gcd(a, b) denotes the greatest common divisor of a and b — the largest integer d such that both integers a and b are divisible by d.
For example: \text{gcdSum}(762) = gcd(762, 7 + 6 + 2)=gcd(762,15) = 3.
Given an integer n, find the smallest integer x ≥ n such that \text{gcdSum}(x) > 1.
Input
The first line of input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t lines follow, each containing a single integer n (1 ≤ n ≤ 10^{18}).
All test cases in one test are different.
Output
Output t lines, where the i-th line is a single integer containing the answer to the i-th test case.
Example
Input
3
11
31
75
Output
12
33
75
Note
Let us explain the three test cases in the sample.
Test case 1: n = 11:
\text{gcdSum}(11) = gcd(11, 1 + 1) = gcd(11,\ 2) = 1.
\text{gcdSum}(12) = gcd(12, 1 + 2) = gcd(12,\ 3) = 3.
So the smallest number ≥ 11 whose gcdSum > 1 is 12.
Test case 2: n = 31:
\text{gcdSum}(31) = gcd(31, 3 + 1) = gcd(31,\ 4) = 1.
\text{gcdSum}(32) = gcd(32, 3 + 2) = gcd(32,\ 5) = 1.
\text{gcdSum}(33) = gcd(33, 3 + 3) = gcd(33,\ 6) = 3.
So the smallest number ≥ 31 whose gcdSum > 1 is 33.
Test case 3: \ n = 75:
\text{gcdSum}(75) = gcd(75, 7 + 5) = gcd(75,\ 12) = 3.
The \text{gcdSum} of 75 is already > 1. Hence, it is the answer. | instruction | 0 | 59,066 | 22 | 118,132 |
Tags: brute force, math
Correct Solution:
```
def res(n2, n3):
MAX = 0
for i in range(n3, 0, -1):
if n3%i==0 and n2%i==0:
return i
for _ in range(int(input())):
n = int(input())
n1 = sum([int(i)for i in str(n)])
while res(n, n1) == 1:
n += 1
n1 = sum([int(i)for i in str(n)])
print(n)
``` | output | 1 | 59,066 | 22 | 118,133 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The \text{gcdSum} of a positive integer is the gcd of that integer with its sum of digits. Formally, \text{gcdSum}(x) = gcd(x, sum of digits of x) for a positive integer x. gcd(a, b) denotes the greatest common divisor of a and b — the largest integer d such that both integers a and b are divisible by d.
For example: \text{gcdSum}(762) = gcd(762, 7 + 6 + 2)=gcd(762,15) = 3.
Given an integer n, find the smallest integer x ≥ n such that \text{gcdSum}(x) > 1.
Input
The first line of input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t lines follow, each containing a single integer n (1 ≤ n ≤ 10^{18}).
All test cases in one test are different.
Output
Output t lines, where the i-th line is a single integer containing the answer to the i-th test case.
Example
Input
3
11
31
75
Output
12
33
75
Note
Let us explain the three test cases in the sample.
Test case 1: n = 11:
\text{gcdSum}(11) = gcd(11, 1 + 1) = gcd(11,\ 2) = 1.
\text{gcdSum}(12) = gcd(12, 1 + 2) = gcd(12,\ 3) = 3.
So the smallest number ≥ 11 whose gcdSum > 1 is 12.
Test case 2: n = 31:
\text{gcdSum}(31) = gcd(31, 3 + 1) = gcd(31,\ 4) = 1.
\text{gcdSum}(32) = gcd(32, 3 + 2) = gcd(32,\ 5) = 1.
\text{gcdSum}(33) = gcd(33, 3 + 3) = gcd(33,\ 6) = 3.
So the smallest number ≥ 31 whose gcdSum > 1 is 33.
Test case 3: \ n = 75:
\text{gcdSum}(75) = gcd(75, 7 + 5) = gcd(75,\ 12) = 3.
The \text{gcdSum} of 75 is already > 1. Hence, it is the answer. | instruction | 0 | 59,067 | 22 | 118,134 |
Tags: brute force, math
Correct Solution:
```
# cook your dish here
import math
t = int(input())
for i in range(t):
n = int(input())
while(1):
v = n
v1 = v
sumofv = 0
while(v>0):
k = v%10
v = v//10
sumofv+=k
n+=1
if(math.gcd(v1,sumofv)>1):
print(v1)
break
``` | output | 1 | 59,067 | 22 | 118,135 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The \text{gcdSum} of a positive integer is the gcd of that integer with its sum of digits. Formally, \text{gcdSum}(x) = gcd(x, sum of digits of x) for a positive integer x. gcd(a, b) denotes the greatest common divisor of a and b — the largest integer d such that both integers a and b are divisible by d.
For example: \text{gcdSum}(762) = gcd(762, 7 + 6 + 2)=gcd(762,15) = 3.
Given an integer n, find the smallest integer x ≥ n such that \text{gcdSum}(x) > 1.
Input
The first line of input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t lines follow, each containing a single integer n (1 ≤ n ≤ 10^{18}).
All test cases in one test are different.
Output
Output t lines, where the i-th line is a single integer containing the answer to the i-th test case.
Example
Input
3
11
31
75
Output
12
33
75
Note
Let us explain the three test cases in the sample.
Test case 1: n = 11:
\text{gcdSum}(11) = gcd(11, 1 + 1) = gcd(11,\ 2) = 1.
\text{gcdSum}(12) = gcd(12, 1 + 2) = gcd(12,\ 3) = 3.
So the smallest number ≥ 11 whose gcdSum > 1 is 12.
Test case 2: n = 31:
\text{gcdSum}(31) = gcd(31, 3 + 1) = gcd(31,\ 4) = 1.
\text{gcdSum}(32) = gcd(32, 3 + 2) = gcd(32,\ 5) = 1.
\text{gcdSum}(33) = gcd(33, 3 + 3) = gcd(33,\ 6) = 3.
So the smallest number ≥ 31 whose gcdSum > 1 is 33.
Test case 3: \ n = 75:
\text{gcdSum}(75) = gcd(75, 7 + 5) = gcd(75,\ 12) = 3.
The \text{gcdSum} of 75 is already > 1. Hence, it is the answer. | instruction | 0 | 59,068 | 22 | 118,136 |
Tags: brute force, math
Correct Solution:
```
# Author : raj1307 - Raj Singh
# Date : 29.03.2021
from __future__ import division, print_function
import os,sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
def ii(): return int(input())
def si(): return input()
def mi(): return map(int,input().strip().split(" "))
def msi(): return map(str,input().strip().split(" "))
def li(): return list(mi())
def dmain():
sys.setrecursionlimit(1000000)
threading.stack_size(1024000)
thread = threading.Thread(target=main)
thread.start()
#from collections import deque, Counter, OrderedDict,defaultdict
#from heapq import nsmallest, nlargest, heapify,heappop ,heappush, heapreplace
#from math import log,sqrt,factorial,cos,tan,sin,radians
#from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
#from decimal import *
#import threading
#from itertools import permutations
#Copy 2D list m = [x[:] for x in mark] .. Avoid Using Deepcopy
abc='abcdefghijklmnopqrstuvwxyz'
abd={'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod=1000000007
#mod=998244353
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def getKey(item): return item[1]
def sort2(l):return sorted(l, key=getKey,reverse=True)
def d2(n,m,num):return [[num for x in range(m)] for y in range(n)]
def isPowerOfTwo (x): return (x and (not(x & (x - 1))) )
def decimalToBinary(n): return bin(n).replace("0b","")
def ntl(n):return [int(i) for i in str(n)]
def ncr(n,r): return factorial(n)//(factorial(r)*factorial(max(n-r,1)))
def ceil(x,y):
if x%y==0:
return x//y
else:
return x//y+1
def powerMod(x,y,p):
res = 1
x %= p
while y > 0:
if y&1:
res = (res*x)%p
y = y>>1
x = (x*x)%p
return res
def gcd(x, y):
while y:
x, y = y, x % y
return x
def isPrime(n) : # Check Prime Number or not
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
def read():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
def main():
for _ in range(ii()):
n=ii()
while True:
x=str(n)
s=0
for i in x:
s+=int(i)
if gcd(s,n)>1:
print(n)
break
n+=1
# region fastio
# template taken from https://github.com/cheran-senthil/PyRival/blob/master/templates/template.py
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
#read()
main()
#dmain()
# Comment Read()
``` | output | 1 | 59,068 | 22 | 118,137 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The \text{gcdSum} of a positive integer is the gcd of that integer with its sum of digits. Formally, \text{gcdSum}(x) = gcd(x, sum of digits of x) for a positive integer x. gcd(a, b) denotes the greatest common divisor of a and b — the largest integer d such that both integers a and b are divisible by d.
For example: \text{gcdSum}(762) = gcd(762, 7 + 6 + 2)=gcd(762,15) = 3.
Given an integer n, find the smallest integer x ≥ n such that \text{gcdSum}(x) > 1.
Input
The first line of input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t lines follow, each containing a single integer n (1 ≤ n ≤ 10^{18}).
All test cases in one test are different.
Output
Output t lines, where the i-th line is a single integer containing the answer to the i-th test case.
Example
Input
3
11
31
75
Output
12
33
75
Note
Let us explain the three test cases in the sample.
Test case 1: n = 11:
\text{gcdSum}(11) = gcd(11, 1 + 1) = gcd(11,\ 2) = 1.
\text{gcdSum}(12) = gcd(12, 1 + 2) = gcd(12,\ 3) = 3.
So the smallest number ≥ 11 whose gcdSum > 1 is 12.
Test case 2: n = 31:
\text{gcdSum}(31) = gcd(31, 3 + 1) = gcd(31,\ 4) = 1.
\text{gcdSum}(32) = gcd(32, 3 + 2) = gcd(32,\ 5) = 1.
\text{gcdSum}(33) = gcd(33, 3 + 3) = gcd(33,\ 6) = 3.
So the smallest number ≥ 31 whose gcdSum > 1 is 33.
Test case 3: \ n = 75:
\text{gcdSum}(75) = gcd(75, 7 + 5) = gcd(75,\ 12) = 3.
The \text{gcdSum} of 75 is already > 1. Hence, it is the answer. | instruction | 0 | 59,069 | 22 | 118,138 |
Tags: brute force, math
Correct Solution:
```
# Har har mahadev
# author : @ harsh kanani
import math
import os
import sys
from collections import Counter
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def main():
for _ in range(int(input())):
n = int(input())
i = n
while True:
a = str(i)
s = 0
for j in a:
s += int(j)
#print(s)
if math.gcd(i, s) > 1:
print(i)
break
i += 1
if __name__ == "__main__":
main()
``` | output | 1 | 59,069 | 22 | 118,139 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The \text{gcdSum} of a positive integer is the gcd of that integer with its sum of digits. Formally, \text{gcdSum}(x) = gcd(x, sum of digits of x) for a positive integer x. gcd(a, b) denotes the greatest common divisor of a and b — the largest integer d such that both integers a and b are divisible by d.
For example: \text{gcdSum}(762) = gcd(762, 7 + 6 + 2)=gcd(762,15) = 3.
Given an integer n, find the smallest integer x ≥ n such that \text{gcdSum}(x) > 1.
Input
The first line of input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t lines follow, each containing a single integer n (1 ≤ n ≤ 10^{18}).
All test cases in one test are different.
Output
Output t lines, where the i-th line is a single integer containing the answer to the i-th test case.
Example
Input
3
11
31
75
Output
12
33
75
Note
Let us explain the three test cases in the sample.
Test case 1: n = 11:
\text{gcdSum}(11) = gcd(11, 1 + 1) = gcd(11,\ 2) = 1.
\text{gcdSum}(12) = gcd(12, 1 + 2) = gcd(12,\ 3) = 3.
So the smallest number ≥ 11 whose gcdSum > 1 is 12.
Test case 2: n = 31:
\text{gcdSum}(31) = gcd(31, 3 + 1) = gcd(31,\ 4) = 1.
\text{gcdSum}(32) = gcd(32, 3 + 2) = gcd(32,\ 5) = 1.
\text{gcdSum}(33) = gcd(33, 3 + 3) = gcd(33,\ 6) = 3.
So the smallest number ≥ 31 whose gcdSum > 1 is 33.
Test case 3: \ n = 75:
\text{gcdSum}(75) = gcd(75, 7 + 5) = gcd(75,\ 12) = 3.
The \text{gcdSum} of 75 is already > 1. Hence, it is the answer. | instruction | 0 | 59,070 | 22 | 118,140 |
Tags: brute force, math
Correct Solution:
```
from math import gcd
def check(num):
sm = sum(list(map(int,str(num))))
if gcd(num,sm) > 1:
return True
return False
for t in range(int(input())):
num = int(input())
for i in range(num,num*10):
if check(i):
print(i)
break
``` | output | 1 | 59,070 | 22 | 118,141 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The \text{gcdSum} of a positive integer is the gcd of that integer with its sum of digits. Formally, \text{gcdSum}(x) = gcd(x, sum of digits of x) for a positive integer x. gcd(a, b) denotes the greatest common divisor of a and b — the largest integer d such that both integers a and b are divisible by d.
For example: \text{gcdSum}(762) = gcd(762, 7 + 6 + 2)=gcd(762,15) = 3.
Given an integer n, find the smallest integer x ≥ n such that \text{gcdSum}(x) > 1.
Input
The first line of input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t lines follow, each containing a single integer n (1 ≤ n ≤ 10^{18}).
All test cases in one test are different.
Output
Output t lines, where the i-th line is a single integer containing the answer to the i-th test case.
Example
Input
3
11
31
75
Output
12
33
75
Note
Let us explain the three test cases in the sample.
Test case 1: n = 11:
\text{gcdSum}(11) = gcd(11, 1 + 1) = gcd(11,\ 2) = 1.
\text{gcdSum}(12) = gcd(12, 1 + 2) = gcd(12,\ 3) = 3.
So the smallest number ≥ 11 whose gcdSum > 1 is 12.
Test case 2: n = 31:
\text{gcdSum}(31) = gcd(31, 3 + 1) = gcd(31,\ 4) = 1.
\text{gcdSum}(32) = gcd(32, 3 + 2) = gcd(32,\ 5) = 1.
\text{gcdSum}(33) = gcd(33, 3 + 3) = gcd(33,\ 6) = 3.
So the smallest number ≥ 31 whose gcdSum > 1 is 33.
Test case 3: \ n = 75:
\text{gcdSum}(75) = gcd(75, 7 + 5) = gcd(75,\ 12) = 3.
The \text{gcdSum} of 75 is already > 1. Hence, it is the answer. | instruction | 0 | 59,071 | 22 | 118,142 |
Tags: brute force, math
Correct Solution:
```
def computeGCD(x, y):
while(y):
x, y = y, x % y
return x
T=int(input())
for i in range(T):
x=input()
flag=True
while(flag!=False):
if computeGCD(int(x),sum([int(i) for i in x]))>1:
print(x)
flag=False
else:
x=str(int(x)+1)
``` | output | 1 | 59,071 | 22 | 118,143 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The \text{gcdSum} of a positive integer is the gcd of that integer with its sum of digits. Formally, \text{gcdSum}(x) = gcd(x, sum of digits of x) for a positive integer x. gcd(a, b) denotes the greatest common divisor of a and b — the largest integer d such that both integers a and b are divisible by d.
For example: \text{gcdSum}(762) = gcd(762, 7 + 6 + 2)=gcd(762,15) = 3.
Given an integer n, find the smallest integer x ≥ n such that \text{gcdSum}(x) > 1.
Input
The first line of input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t lines follow, each containing a single integer n (1 ≤ n ≤ 10^{18}).
All test cases in one test are different.
Output
Output t lines, where the i-th line is a single integer containing the answer to the i-th test case.
Example
Input
3
11
31
75
Output
12
33
75
Note
Let us explain the three test cases in the sample.
Test case 1: n = 11:
\text{gcdSum}(11) = gcd(11, 1 + 1) = gcd(11,\ 2) = 1.
\text{gcdSum}(12) = gcd(12, 1 + 2) = gcd(12,\ 3) = 3.
So the smallest number ≥ 11 whose gcdSum > 1 is 12.
Test case 2: n = 31:
\text{gcdSum}(31) = gcd(31, 3 + 1) = gcd(31,\ 4) = 1.
\text{gcdSum}(32) = gcd(32, 3 + 2) = gcd(32,\ 5) = 1.
\text{gcdSum}(33) = gcd(33, 3 + 3) = gcd(33,\ 6) = 3.
So the smallest number ≥ 31 whose gcdSum > 1 is 33.
Test case 3: \ n = 75:
\text{gcdSum}(75) = gcd(75, 7 + 5) = gcd(75,\ 12) = 3.
The \text{gcdSum} of 75 is already > 1. Hence, it is the answer. | instruction | 0 | 59,072 | 22 | 118,144 |
Tags: brute force, math
Correct Solution:
```
import math
def sumofdigits(n):
a = 0
while n:
a += n % 10
n //= 10
return a
for _ in range(int(input())):
n = int(input())
f = n
while True:
if math.gcd(f, sumofdigits(f)) > 1:
break
f += 1
print(f)
``` | output | 1 | 59,072 | 22 | 118,145 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The \text{gcdSum} of a positive integer is the gcd of that integer with its sum of digits. Formally, \text{gcdSum}(x) = gcd(x, sum of digits of x) for a positive integer x. gcd(a, b) denotes the greatest common divisor of a and b — the largest integer d such that both integers a and b are divisible by d.
For example: \text{gcdSum}(762) = gcd(762, 7 + 6 + 2)=gcd(762,15) = 3.
Given an integer n, find the smallest integer x ≥ n such that \text{gcdSum}(x) > 1.
Input
The first line of input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t lines follow, each containing a single integer n (1 ≤ n ≤ 10^{18}).
All test cases in one test are different.
Output
Output t lines, where the i-th line is a single integer containing the answer to the i-th test case.
Example
Input
3
11
31
75
Output
12
33
75
Note
Let us explain the three test cases in the sample.
Test case 1: n = 11:
\text{gcdSum}(11) = gcd(11, 1 + 1) = gcd(11,\ 2) = 1.
\text{gcdSum}(12) = gcd(12, 1 + 2) = gcd(12,\ 3) = 3.
So the smallest number ≥ 11 whose gcdSum > 1 is 12.
Test case 2: n = 31:
\text{gcdSum}(31) = gcd(31, 3 + 1) = gcd(31,\ 4) = 1.
\text{gcdSum}(32) = gcd(32, 3 + 2) = gcd(32,\ 5) = 1.
\text{gcdSum}(33) = gcd(33, 3 + 3) = gcd(33,\ 6) = 3.
So the smallest number ≥ 31 whose gcdSum > 1 is 33.
Test case 3: \ n = 75:
\text{gcdSum}(75) = gcd(75, 7 + 5) = gcd(75,\ 12) = 3.
The \text{gcdSum} of 75 is already > 1. Hence, it is the answer.
Submitted Solution:
```
def gcdsum(a):
answer=a
num=0
k=str(a)
b=[]
for i in k:
b.append(int(i))
for i in b:
num+=i
while num!=0:
a,num=num,a%num
if a>1:
return answer
else:
return gcdsum(answer+1)
for _ in range(int(input())):
a=int(input())
print(gcdsum(a))
``` | instruction | 0 | 59,073 | 22 | 118,146 |
Yes | output | 1 | 59,073 | 22 | 118,147 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The \text{gcdSum} of a positive integer is the gcd of that integer with its sum of digits. Formally, \text{gcdSum}(x) = gcd(x, sum of digits of x) for a positive integer x. gcd(a, b) denotes the greatest common divisor of a and b — the largest integer d such that both integers a and b are divisible by d.
For example: \text{gcdSum}(762) = gcd(762, 7 + 6 + 2)=gcd(762,15) = 3.
Given an integer n, find the smallest integer x ≥ n such that \text{gcdSum}(x) > 1.
Input
The first line of input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t lines follow, each containing a single integer n (1 ≤ n ≤ 10^{18}).
All test cases in one test are different.
Output
Output t lines, where the i-th line is a single integer containing the answer to the i-th test case.
Example
Input
3
11
31
75
Output
12
33
75
Note
Let us explain the three test cases in the sample.
Test case 1: n = 11:
\text{gcdSum}(11) = gcd(11, 1 + 1) = gcd(11,\ 2) = 1.
\text{gcdSum}(12) = gcd(12, 1 + 2) = gcd(12,\ 3) = 3.
So the smallest number ≥ 11 whose gcdSum > 1 is 12.
Test case 2: n = 31:
\text{gcdSum}(31) = gcd(31, 3 + 1) = gcd(31,\ 4) = 1.
\text{gcdSum}(32) = gcd(32, 3 + 2) = gcd(32,\ 5) = 1.
\text{gcdSum}(33) = gcd(33, 3 + 3) = gcd(33,\ 6) = 3.
So the smallest number ≥ 31 whose gcdSum > 1 is 33.
Test case 3: \ n = 75:
\text{gcdSum}(75) = gcd(75, 7 + 5) = gcd(75,\ 12) = 3.
The \text{gcdSum} of 75 is already > 1. Hence, it is the answer.
Submitted Solution:
```
from sys import stdin
from math import gcd
std = stdin.readline
N = int(std())
def plus_num(str1):
ans = 0
for s in str1:
ans += int(s)
return ans
num = []
for i in range(N):
n = std().rstrip()
two = plus_num(n)
n = int(n)
num.append((n, two, gcd(n, two)))
for k in num:
a, b, c = k
# print(a, b, c)
if c > 1:
print(a)
else:
while True:
if c > 1:
print(a)
break
a += 1
b = plus_num(str(a))
c = gcd(a, b)
``` | instruction | 0 | 59,074 | 22 | 118,148 |
Yes | output | 1 | 59,074 | 22 | 118,149 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The \text{gcdSum} of a positive integer is the gcd of that integer with its sum of digits. Formally, \text{gcdSum}(x) = gcd(x, sum of digits of x) for a positive integer x. gcd(a, b) denotes the greatest common divisor of a and b — the largest integer d such that both integers a and b are divisible by d.
For example: \text{gcdSum}(762) = gcd(762, 7 + 6 + 2)=gcd(762,15) = 3.
Given an integer n, find the smallest integer x ≥ n such that \text{gcdSum}(x) > 1.
Input
The first line of input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t lines follow, each containing a single integer n (1 ≤ n ≤ 10^{18}).
All test cases in one test are different.
Output
Output t lines, where the i-th line is a single integer containing the answer to the i-th test case.
Example
Input
3
11
31
75
Output
12
33
75
Note
Let us explain the three test cases in the sample.
Test case 1: n = 11:
\text{gcdSum}(11) = gcd(11, 1 + 1) = gcd(11,\ 2) = 1.
\text{gcdSum}(12) = gcd(12, 1 + 2) = gcd(12,\ 3) = 3.
So the smallest number ≥ 11 whose gcdSum > 1 is 12.
Test case 2: n = 31:
\text{gcdSum}(31) = gcd(31, 3 + 1) = gcd(31,\ 4) = 1.
\text{gcdSum}(32) = gcd(32, 3 + 2) = gcd(32,\ 5) = 1.
\text{gcdSum}(33) = gcd(33, 3 + 3) = gcd(33,\ 6) = 3.
So the smallest number ≥ 31 whose gcdSum > 1 is 33.
Test case 3: \ n = 75:
\text{gcdSum}(75) = gcd(75, 7 + 5) = gcd(75,\ 12) = 3.
The \text{gcdSum} of 75 is already > 1. Hence, it is the answer.
Submitted Solution:
```
import math
y=int(input())
for i in range(1,y+1):
n=int(input())
j=n
while n>=j:
t=n
sum=0
while n:
r=n%10
sum+=r
n=n//10
n=t
a=math.gcd(n,sum)
if a>1:
print(n)
break
else:
n=n+1
``` | instruction | 0 | 59,075 | 22 | 118,150 |
Yes | output | 1 | 59,075 | 22 | 118,151 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The \text{gcdSum} of a positive integer is the gcd of that integer with its sum of digits. Formally, \text{gcdSum}(x) = gcd(x, sum of digits of x) for a positive integer x. gcd(a, b) denotes the greatest common divisor of a and b — the largest integer d such that both integers a and b are divisible by d.
For example: \text{gcdSum}(762) = gcd(762, 7 + 6 + 2)=gcd(762,15) = 3.
Given an integer n, find the smallest integer x ≥ n such that \text{gcdSum}(x) > 1.
Input
The first line of input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t lines follow, each containing a single integer n (1 ≤ n ≤ 10^{18}).
All test cases in one test are different.
Output
Output t lines, where the i-th line is a single integer containing the answer to the i-th test case.
Example
Input
3
11
31
75
Output
12
33
75
Note
Let us explain the three test cases in the sample.
Test case 1: n = 11:
\text{gcdSum}(11) = gcd(11, 1 + 1) = gcd(11,\ 2) = 1.
\text{gcdSum}(12) = gcd(12, 1 + 2) = gcd(12,\ 3) = 3.
So the smallest number ≥ 11 whose gcdSum > 1 is 12.
Test case 2: n = 31:
\text{gcdSum}(31) = gcd(31, 3 + 1) = gcd(31,\ 4) = 1.
\text{gcdSum}(32) = gcd(32, 3 + 2) = gcd(32,\ 5) = 1.
\text{gcdSum}(33) = gcd(33, 3 + 3) = gcd(33,\ 6) = 3.
So the smallest number ≥ 31 whose gcdSum > 1 is 33.
Test case 3: \ n = 75:
\text{gcdSum}(75) = gcd(75, 7 + 5) = gcd(75,\ 12) = 3.
The \text{gcdSum} of 75 is already > 1. Hence, it is the answer.
Submitted Solution:
```
from collections import *
import sys
from math import gcd
input=sys.stdin.readline
# "". join(strings)
def ri():
return int(input())
def rl():
return list(map(int, input().split()))
def sumDigits(n):
if n < 10:
return n
else:
return n%10 + sumDigits(n//10)
t =ri()
for _ in range(t):
n =ri()
while True:
s = sumDigits(n)
if gcd(n, s) > 1:
break
else:
n += 1
print(n)
``` | instruction | 0 | 59,076 | 22 | 118,152 |
Yes | output | 1 | 59,076 | 22 | 118,153 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The \text{gcdSum} of a positive integer is the gcd of that integer with its sum of digits. Formally, \text{gcdSum}(x) = gcd(x, sum of digits of x) for a positive integer x. gcd(a, b) denotes the greatest common divisor of a and b — the largest integer d such that both integers a and b are divisible by d.
For example: \text{gcdSum}(762) = gcd(762, 7 + 6 + 2)=gcd(762,15) = 3.
Given an integer n, find the smallest integer x ≥ n such that \text{gcdSum}(x) > 1.
Input
The first line of input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t lines follow, each containing a single integer n (1 ≤ n ≤ 10^{18}).
All test cases in one test are different.
Output
Output t lines, where the i-th line is a single integer containing the answer to the i-th test case.
Example
Input
3
11
31
75
Output
12
33
75
Note
Let us explain the three test cases in the sample.
Test case 1: n = 11:
\text{gcdSum}(11) = gcd(11, 1 + 1) = gcd(11,\ 2) = 1.
\text{gcdSum}(12) = gcd(12, 1 + 2) = gcd(12,\ 3) = 3.
So the smallest number ≥ 11 whose gcdSum > 1 is 12.
Test case 2: n = 31:
\text{gcdSum}(31) = gcd(31, 3 + 1) = gcd(31,\ 4) = 1.
\text{gcdSum}(32) = gcd(32, 3 + 2) = gcd(32,\ 5) = 1.
\text{gcdSum}(33) = gcd(33, 3 + 3) = gcd(33,\ 6) = 3.
So the smallest number ≥ 31 whose gcdSum > 1 is 33.
Test case 3: \ n = 75:
\text{gcdSum}(75) = gcd(75, 7 + 5) = gcd(75,\ 12) = 3.
The \text{gcdSum} of 75 is already > 1. Hence, it is the answer.
Submitted Solution:
```
import math
for s in[*open(0)][1:]:
n=int(s)
while math.gcd(n,sum(map(int,str(n))))<2:n+=1
print(n)
``` | instruction | 0 | 59,077 | 22 | 118,154 |
No | output | 1 | 59,077 | 22 | 118,155 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The \text{gcdSum} of a positive integer is the gcd of that integer with its sum of digits. Formally, \text{gcdSum}(x) = gcd(x, sum of digits of x) for a positive integer x. gcd(a, b) denotes the greatest common divisor of a and b — the largest integer d such that both integers a and b are divisible by d.
For example: \text{gcdSum}(762) = gcd(762, 7 + 6 + 2)=gcd(762,15) = 3.
Given an integer n, find the smallest integer x ≥ n such that \text{gcdSum}(x) > 1.
Input
The first line of input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t lines follow, each containing a single integer n (1 ≤ n ≤ 10^{18}).
All test cases in one test are different.
Output
Output t lines, where the i-th line is a single integer containing the answer to the i-th test case.
Example
Input
3
11
31
75
Output
12
33
75
Note
Let us explain the three test cases in the sample.
Test case 1: n = 11:
\text{gcdSum}(11) = gcd(11, 1 + 1) = gcd(11,\ 2) = 1.
\text{gcdSum}(12) = gcd(12, 1 + 2) = gcd(12,\ 3) = 3.
So the smallest number ≥ 11 whose gcdSum > 1 is 12.
Test case 2: n = 31:
\text{gcdSum}(31) = gcd(31, 3 + 1) = gcd(31,\ 4) = 1.
\text{gcdSum}(32) = gcd(32, 3 + 2) = gcd(32,\ 5) = 1.
\text{gcdSum}(33) = gcd(33, 3 + 3) = gcd(33,\ 6) = 3.
So the smallest number ≥ 31 whose gcdSum > 1 is 33.
Test case 3: \ n = 75:
\text{gcdSum}(75) = gcd(75, 7 + 5) = gcd(75,\ 12) = 3.
The \text{gcdSum} of 75 is already > 1. Hence, it is the answer.
Submitted Solution:
```
import queue
import math
import sys
from collections import deque
def sum_digit(x):
ss=0
while x!=0:
ss+=x%10
x = x//10
return ss
def gcd_sum_not_1 (x):
ss = sum_digit(x)
if ss%3==0:
return True
elif x%2==0 and ss%2==0:
return True
else:
primes = [5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83]
for p in primes:
if x%p ==0 and ss%p==0:
return True
return False
t = int(input())
for _ in range(t):
n = int(input())
if n <=12:
print (12)
else:
x=n
while not gcd_sum_not_1 (x):
x+=1
print (x)
``` | instruction | 0 | 59,078 | 22 | 118,156 |
No | output | 1 | 59,078 | 22 | 118,157 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The \text{gcdSum} of a positive integer is the gcd of that integer with its sum of digits. Formally, \text{gcdSum}(x) = gcd(x, sum of digits of x) for a positive integer x. gcd(a, b) denotes the greatest common divisor of a and b — the largest integer d such that both integers a and b are divisible by d.
For example: \text{gcdSum}(762) = gcd(762, 7 + 6 + 2)=gcd(762,15) = 3.
Given an integer n, find the smallest integer x ≥ n such that \text{gcdSum}(x) > 1.
Input
The first line of input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t lines follow, each containing a single integer n (1 ≤ n ≤ 10^{18}).
All test cases in one test are different.
Output
Output t lines, where the i-th line is a single integer containing the answer to the i-th test case.
Example
Input
3
11
31
75
Output
12
33
75
Note
Let us explain the three test cases in the sample.
Test case 1: n = 11:
\text{gcdSum}(11) = gcd(11, 1 + 1) = gcd(11,\ 2) = 1.
\text{gcdSum}(12) = gcd(12, 1 + 2) = gcd(12,\ 3) = 3.
So the smallest number ≥ 11 whose gcdSum > 1 is 12.
Test case 2: n = 31:
\text{gcdSum}(31) = gcd(31, 3 + 1) = gcd(31,\ 4) = 1.
\text{gcdSum}(32) = gcd(32, 3 + 2) = gcd(32,\ 5) = 1.
\text{gcdSum}(33) = gcd(33, 3 + 3) = gcd(33,\ 6) = 3.
So the smallest number ≥ 31 whose gcdSum > 1 is 33.
Test case 3: \ n = 75:
\text{gcdSum}(75) = gcd(75, 7 + 5) = gcd(75,\ 12) = 3.
The \text{gcdSum} of 75 is already > 1. Hence, it is the answer.
Submitted Solution:
```
from math import gcd
t = int(input())
for _ in range(t):
n = int(input())
for i in range(n, int(1e18)+1):
a = str(i)
if gcd(int(a), sum(list(map(int, list(a))))) > 1:
print(i)
break
``` | instruction | 0 | 59,079 | 22 | 118,158 |
No | output | 1 | 59,079 | 22 | 118,159 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The \text{gcdSum} of a positive integer is the gcd of that integer with its sum of digits. Formally, \text{gcdSum}(x) = gcd(x, sum of digits of x) for a positive integer x. gcd(a, b) denotes the greatest common divisor of a and b — the largest integer d such that both integers a and b are divisible by d.
For example: \text{gcdSum}(762) = gcd(762, 7 + 6 + 2)=gcd(762,15) = 3.
Given an integer n, find the smallest integer x ≥ n such that \text{gcdSum}(x) > 1.
Input
The first line of input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t lines follow, each containing a single integer n (1 ≤ n ≤ 10^{18}).
All test cases in one test are different.
Output
Output t lines, where the i-th line is a single integer containing the answer to the i-th test case.
Example
Input
3
11
31
75
Output
12
33
75
Note
Let us explain the three test cases in the sample.
Test case 1: n = 11:
\text{gcdSum}(11) = gcd(11, 1 + 1) = gcd(11,\ 2) = 1.
\text{gcdSum}(12) = gcd(12, 1 + 2) = gcd(12,\ 3) = 3.
So the smallest number ≥ 11 whose gcdSum > 1 is 12.
Test case 2: n = 31:
\text{gcdSum}(31) = gcd(31, 3 + 1) = gcd(31,\ 4) = 1.
\text{gcdSum}(32) = gcd(32, 3 + 2) = gcd(32,\ 5) = 1.
\text{gcdSum}(33) = gcd(33, 3 + 3) = gcd(33,\ 6) = 3.
So the smallest number ≥ 31 whose gcdSum > 1 is 33.
Test case 3: \ n = 75:
\text{gcdSum}(75) = gcd(75, 7 + 5) = gcd(75,\ 12) = 3.
The \text{gcdSum} of 75 is already > 1. Hence, it is the answer.
Submitted Solution:
```
import math
for i in range(int(input())):
x = int(input())
z = 0
while 1 == 1:
for j in range(len(str(x))):
z += int(j)
if math.gcd(x, z) == 1:
x += 1
else:
print(x)
break
``` | instruction | 0 | 59,080 | 22 | 118,160 |
No | output | 1 | 59,080 | 22 | 118,161 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently, the bear started studying data structures and faced the following problem.
You are given a sequence of integers x1, x2, ..., xn of length n and m queries, each of them is characterized by two integers li, ri. Let's introduce f(p) to represent the number of such indexes k, that xk is divisible by p. The answer to the query li, ri is the sum: <image>, where S(li, ri) is a set of prime numbers from segment [li, ri] (both borders are included in the segment).
Help the bear cope with the problem.
Input
The first line contains integer n (1 ≤ n ≤ 106). The second line contains n integers x1, x2, ..., xn (2 ≤ xi ≤ 107). The numbers are not necessarily distinct.
The third line contains integer m (1 ≤ m ≤ 50000). Each of the following m lines contains a pair of space-separated integers, li and ri (2 ≤ li ≤ ri ≤ 2·109) — the numbers that characterize the current query.
Output
Print m integers — the answers to the queries on the order the queries appear in the input.
Examples
Input
6
5 5 7 10 14 15
3
2 11
3 12
4 4
Output
9
7
0
Input
7
2 3 5 7 11 4 8
2
8 10
2 123
Output
0
7
Note
Consider the first sample. Overall, the first sample has 3 queries.
1. The first query l = 2, r = 11 comes. You need to count f(2) + f(3) + f(5) + f(7) + f(11) = 2 + 1 + 4 + 2 + 0 = 9.
2. The second query comes l = 3, r = 12. You need to count f(3) + f(5) + f(7) + f(11) = 1 + 4 + 2 + 0 = 7.
3. The third query comes l = 4, r = 4. As this interval has no prime numbers, then the sum equals 0. | instruction | 0 | 59,181 | 22 | 118,362 |
Tags: binary search, brute force, data structures, dp, implementation, math, number theory
Correct Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
from io import BytesIO, IOBase
import sys
from collections import defaultdict, deque, Counter
from math import sqrt, pi, ceil, log, inf, gcd, floor
from itertools import combinations
from bisect import *
def main():
n = int(input())
x = list(map(int,input().split()))
m, z = int(input()), max(x)
p,ans,xx=[0]*(z+1),[0]*(z+1),[0]*(z+1)
for i in x:
xx[i]+=1
i=2
while i<=z:
if not p[i]:
j=i
while j <= z:
p[j]=1
ans[i]+=xx[j]
j+=i
i += 1
for i in range(2,z+1):
ans[i] += ans[i-1]
for i in range(m):
l, r = map(int, input().split())
print(0 if l > z else ans[min(r, z)] - ans[l - 1])
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | output | 1 | 59,181 | 22 | 118,363 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently, the bear started studying data structures and faced the following problem.
You are given a sequence of integers x1, x2, ..., xn of length n and m queries, each of them is characterized by two integers li, ri. Let's introduce f(p) to represent the number of such indexes k, that xk is divisible by p. The answer to the query li, ri is the sum: <image>, where S(li, ri) is a set of prime numbers from segment [li, ri] (both borders are included in the segment).
Help the bear cope with the problem.
Input
The first line contains integer n (1 ≤ n ≤ 106). The second line contains n integers x1, x2, ..., xn (2 ≤ xi ≤ 107). The numbers are not necessarily distinct.
The third line contains integer m (1 ≤ m ≤ 50000). Each of the following m lines contains a pair of space-separated integers, li and ri (2 ≤ li ≤ ri ≤ 2·109) — the numbers that characterize the current query.
Output
Print m integers — the answers to the queries on the order the queries appear in the input.
Examples
Input
6
5 5 7 10 14 15
3
2 11
3 12
4 4
Output
9
7
0
Input
7
2 3 5 7 11 4 8
2
8 10
2 123
Output
0
7
Note
Consider the first sample. Overall, the first sample has 3 queries.
1. The first query l = 2, r = 11 comes. You need to count f(2) + f(3) + f(5) + f(7) + f(11) = 2 + 1 + 4 + 2 + 0 = 9.
2. The second query comes l = 3, r = 12. You need to count f(3) + f(5) + f(7) + f(11) = 1 + 4 + 2 + 0 = 7.
3. The third query comes l = 4, r = 4. As this interval has no prime numbers, then the sum equals 0. | instruction | 0 | 59,182 | 22 | 118,364 |
Tags: binary search, brute force, data structures, dp, implementation, math, number theory
Correct Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
from io import BytesIO, IOBase
import sys
from collections import defaultdict, deque, Counter
from math import sqrt, pi, ceil, log, inf, gcd, floor
from itertools import combinations
from bisect import *
def main():
n = int(input())
x = list(map(int, input().split()))
m, z = int(input()), max(x)
i, p, a, ans = 2, [0] * (z + 1), [], [0] * (z + 1)
while i * i <= z:
if not p[i]:
j = i* i
while j <= z:
p[j] = i
j += i
i += 1
for i in range(n):
if not p[x[i]]:
ans[x[i]] += 1
else:
y, c = x[i], set()
while p[y] != 0 and y != 1:
c.add(p[y])
y = y // p[y]
if not p[y]:
c.add(y)
for i in c:
ans[i] += 1
for i in range(1, z + 1):
ans[i] += ans[i - 1]
for i in range(m):
l, r = map(int, input().split())
print(0 if l > z else ans[min(r, z)] - ans[l - 1])
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | output | 1 | 59,182 | 22 | 118,365 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently, the bear started studying data structures and faced the following problem.
You are given a sequence of integers x1, x2, ..., xn of length n and m queries, each of them is characterized by two integers li, ri. Let's introduce f(p) to represent the number of such indexes k, that xk is divisible by p. The answer to the query li, ri is the sum: <image>, where S(li, ri) is a set of prime numbers from segment [li, ri] (both borders are included in the segment).
Help the bear cope with the problem.
Input
The first line contains integer n (1 ≤ n ≤ 106). The second line contains n integers x1, x2, ..., xn (2 ≤ xi ≤ 107). The numbers are not necessarily distinct.
The third line contains integer m (1 ≤ m ≤ 50000). Each of the following m lines contains a pair of space-separated integers, li and ri (2 ≤ li ≤ ri ≤ 2·109) — the numbers that characterize the current query.
Output
Print m integers — the answers to the queries on the order the queries appear in the input.
Examples
Input
6
5 5 7 10 14 15
3
2 11
3 12
4 4
Output
9
7
0
Input
7
2 3 5 7 11 4 8
2
8 10
2 123
Output
0
7
Note
Consider the first sample. Overall, the first sample has 3 queries.
1. The first query l = 2, r = 11 comes. You need to count f(2) + f(3) + f(5) + f(7) + f(11) = 2 + 1 + 4 + 2 + 0 = 9.
2. The second query comes l = 3, r = 12. You need to count f(3) + f(5) + f(7) + f(11) = 1 + 4 + 2 + 0 = 7.
3. The third query comes l = 4, r = 4. As this interval has no prime numbers, then the sum equals 0. | instruction | 0 | 59,183 | 22 | 118,366 |
Tags: binary search, brute force, data structures, dp, implementation, math, number theory
Correct Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
from io import BytesIO, IOBase
import sys
from collections import defaultdict, deque, Counter
from math import sqrt, pi, ceil, log, inf, gcd, floor
from itertools import combinations
from bisect import *
def main():
n=int(input())
x=list(map(int,input().split()))
m=int(input())
z=max(x)
i,p,a,ans=2,[0]*(z+1),[],[0]*(z+1)
while i*i<=z:
if not p[i]:
j=2*i
while j<=z:
p[j]=i
j+=i
i+=1
for i in range(n):
if not p[x[i]]:
ans[x[i]]+=1
else:
y,c=x[i],set()
while p[y]!=0 and y!=1:
c.add(p[y])
y=y//p[y]
if not p[y]:
c.add(y)
for i in c:
ans[i]+=1
for i in range(1,z+1):
ans[i]+=ans[i-1]
for i in range(m):
l,r=map(int,input().split())
if l>z:
print(0)
else:
r=min(r,z)
print(ans[r]-ans[l-1])
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | output | 1 | 59,183 | 22 | 118,367 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently, the bear started studying data structures and faced the following problem.
You are given a sequence of integers x1, x2, ..., xn of length n and m queries, each of them is characterized by two integers li, ri. Let's introduce f(p) to represent the number of such indexes k, that xk is divisible by p. The answer to the query li, ri is the sum: <image>, where S(li, ri) is a set of prime numbers from segment [li, ri] (both borders are included in the segment).
Help the bear cope with the problem.
Input
The first line contains integer n (1 ≤ n ≤ 106). The second line contains n integers x1, x2, ..., xn (2 ≤ xi ≤ 107). The numbers are not necessarily distinct.
The third line contains integer m (1 ≤ m ≤ 50000). Each of the following m lines contains a pair of space-separated integers, li and ri (2 ≤ li ≤ ri ≤ 2·109) — the numbers that characterize the current query.
Output
Print m integers — the answers to the queries on the order the queries appear in the input.
Examples
Input
6
5 5 7 10 14 15
3
2 11
3 12
4 4
Output
9
7
0
Input
7
2 3 5 7 11 4 8
2
8 10
2 123
Output
0
7
Note
Consider the first sample. Overall, the first sample has 3 queries.
1. The first query l = 2, r = 11 comes. You need to count f(2) + f(3) + f(5) + f(7) + f(11) = 2 + 1 + 4 + 2 + 0 = 9.
2. The second query comes l = 3, r = 12. You need to count f(3) + f(5) + f(7) + f(11) = 1 + 4 + 2 + 0 = 7.
3. The third query comes l = 4, r = 4. As this interval has no prime numbers, then the sum equals 0. | instruction | 0 | 59,184 | 22 | 118,368 |
Tags: binary search, brute force, data structures, dp, implementation, math, number theory
Correct Solution:
```
import math, sys
input = sys.stdin.buffer.readline
def ints():
return map(int, input().split())
n = int(input())
x = list(ints())
MAX = max(x) + 1
freq = [0] * MAX
for i in x:
freq[i] += 1
sieve = [False] * MAX
f = [0] * MAX
for i in range(2, MAX):
if sieve[i]:
continue
for j in range(i, MAX, i):
sieve[j] = True
f[i] += freq[j]
for i in range(2, MAX):
f[i] += f[i-1]
m = int(input())
for i in range(m):
l, r = ints()
if l >= MAX:
print(0)
elif r >= MAX:
print(f[-1] - f[l-1])
else:
print(f[r] - f[l-1])
``` | output | 1 | 59,184 | 22 | 118,369 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently, the bear started studying data structures and faced the following problem.
You are given a sequence of integers x1, x2, ..., xn of length n and m queries, each of them is characterized by two integers li, ri. Let's introduce f(p) to represent the number of such indexes k, that xk is divisible by p. The answer to the query li, ri is the sum: <image>, where S(li, ri) is a set of prime numbers from segment [li, ri] (both borders are included in the segment).
Help the bear cope with the problem.
Input
The first line contains integer n (1 ≤ n ≤ 106). The second line contains n integers x1, x2, ..., xn (2 ≤ xi ≤ 107). The numbers are not necessarily distinct.
The third line contains integer m (1 ≤ m ≤ 50000). Each of the following m lines contains a pair of space-separated integers, li and ri (2 ≤ li ≤ ri ≤ 2·109) — the numbers that characterize the current query.
Output
Print m integers — the answers to the queries on the order the queries appear in the input.
Examples
Input
6
5 5 7 10 14 15
3
2 11
3 12
4 4
Output
9
7
0
Input
7
2 3 5 7 11 4 8
2
8 10
2 123
Output
0
7
Note
Consider the first sample. Overall, the first sample has 3 queries.
1. The first query l = 2, r = 11 comes. You need to count f(2) + f(3) + f(5) + f(7) + f(11) = 2 + 1 + 4 + 2 + 0 = 9.
2. The second query comes l = 3, r = 12. You need to count f(3) + f(5) + f(7) + f(11) = 1 + 4 + 2 + 0 = 7.
3. The third query comes l = 4, r = 4. As this interval has no prime numbers, then the sum equals 0. | instruction | 0 | 59,185 | 22 | 118,370 |
Tags: binary search, brute force, data structures, dp, implementation, math, number theory
Correct Solution:
```
import sys
import io, os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
#arr=list(map(int, input().split()))
import os, sys, atexit
from io import BytesIO, StringIO
_OUTPUT_BUFFER = StringIO()
sys.stdout = _OUTPUT_BUFFER
@atexit.register
def write():
sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
def sieve(n):
prime = [1 for i in range(n + 1)]
p = 2
while (p * p <= n):
if (prime[p] ==1):
for i in range(p * p, n + 1, p):
prime[i] = p
p += 1
return prime
def main():
n=int(input())
arr=list(map(int, input().split()))
ma=max(arr)+1
sie=sieve(ma)
l=[0]*(ma+1)
for i in range(n):
curr=arr[i]
while(True):
if(sie[curr]==1):
l[curr]+=1
break
if(curr%(sie[curr]*sie[curr])!=0):
l[sie[curr]]+=1
curr=curr//sie[curr]
pref=[0]*(ma+1)
for i in range(1,len(pref)):
pref[i]=pref[i-1]+l[i]
m=int(input())
for i in range(m):
arr=list(map(int, input().split()))
ls=min(arr[0],ma)
rs=min(arr[1],ma)
print(pref[rs]-pref[ls]+l[ls])
if __name__ == '__main__':
main()
``` | output | 1 | 59,185 | 22 | 118,371 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently, the bear started studying data structures and faced the following problem.
You are given a sequence of integers x1, x2, ..., xn of length n and m queries, each of them is characterized by two integers li, ri. Let's introduce f(p) to represent the number of such indexes k, that xk is divisible by p. The answer to the query li, ri is the sum: <image>, where S(li, ri) is a set of prime numbers from segment [li, ri] (both borders are included in the segment).
Help the bear cope with the problem.
Input
The first line contains integer n (1 ≤ n ≤ 106). The second line contains n integers x1, x2, ..., xn (2 ≤ xi ≤ 107). The numbers are not necessarily distinct.
The third line contains integer m (1 ≤ m ≤ 50000). Each of the following m lines contains a pair of space-separated integers, li and ri (2 ≤ li ≤ ri ≤ 2·109) — the numbers that characterize the current query.
Output
Print m integers — the answers to the queries on the order the queries appear in the input.
Examples
Input
6
5 5 7 10 14 15
3
2 11
3 12
4 4
Output
9
7
0
Input
7
2 3 5 7 11 4 8
2
8 10
2 123
Output
0
7
Note
Consider the first sample. Overall, the first sample has 3 queries.
1. The first query l = 2, r = 11 comes. You need to count f(2) + f(3) + f(5) + f(7) + f(11) = 2 + 1 + 4 + 2 + 0 = 9.
2. The second query comes l = 3, r = 12. You need to count f(3) + f(5) + f(7) + f(11) = 1 + 4 + 2 + 0 = 7.
3. The third query comes l = 4, r = 4. As this interval has no prime numbers, then the sum equals 0. | instruction | 0 | 59,186 | 22 | 118,372 |
Tags: binary search, brute force, data structures, dp, implementation, math, number theory
Correct Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
from io import BytesIO, IOBase
import sys
from collections import defaultdict, deque, Counter
from math import sqrt, pi, ceil, log, inf, gcd, floor
from itertools import combinations
from bisect import *
def main():
n=int(input())
x=list(map(int,input().split()))
m,z=int(input()),max(x)
i,p,a,ans=2,[0]*(z+1),[],[0]*(z+1)
while i*i<=z:
if not p[i]:
j=2*i
while j<=z:
p[j]=i
j+=i
i+=1
for i in range(n):
if not p[x[i]]:
ans[x[i]]+=1
else:
y,c=x[i],set()
while p[y]!=0 and y!=1:
c.add(p[y])
y=y//p[y]
if not p[y]:
c.add(y)
for i in c:
ans[i]+=1
for i in range(1,z+1):
ans[i]+=ans[i-1]
for i in range(m):
l,r=map(int,input().split())
print(0 if l>z else ans[min(r,z)]-ans[l-1])
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | output | 1 | 59,186 | 22 | 118,373 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently, the bear started studying data structures and faced the following problem.
You are given a sequence of integers x1, x2, ..., xn of length n and m queries, each of them is characterized by two integers li, ri. Let's introduce f(p) to represent the number of such indexes k, that xk is divisible by p. The answer to the query li, ri is the sum: <image>, where S(li, ri) is a set of prime numbers from segment [li, ri] (both borders are included in the segment).
Help the bear cope with the problem.
Input
The first line contains integer n (1 ≤ n ≤ 106). The second line contains n integers x1, x2, ..., xn (2 ≤ xi ≤ 107). The numbers are not necessarily distinct.
The third line contains integer m (1 ≤ m ≤ 50000). Each of the following m lines contains a pair of space-separated integers, li and ri (2 ≤ li ≤ ri ≤ 2·109) — the numbers that characterize the current query.
Output
Print m integers — the answers to the queries on the order the queries appear in the input.
Examples
Input
6
5 5 7 10 14 15
3
2 11
3 12
4 4
Output
9
7
0
Input
7
2 3 5 7 11 4 8
2
8 10
2 123
Output
0
7
Note
Consider the first sample. Overall, the first sample has 3 queries.
1. The first query l = 2, r = 11 comes. You need to count f(2) + f(3) + f(5) + f(7) + f(11) = 2 + 1 + 4 + 2 + 0 = 9.
2. The second query comes l = 3, r = 12. You need to count f(3) + f(5) + f(7) + f(11) = 1 + 4 + 2 + 0 = 7.
3. The third query comes l = 4, r = 4. As this interval has no prime numbers, then the sum equals 0. | instruction | 0 | 59,187 | 22 | 118,374 |
Tags: binary search, brute force, data structures, dp, implementation, math, number theory
Correct Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
from io import BytesIO, IOBase
import sys
from collections import defaultdict, deque, Counter
from math import sqrt, pi, ceil, log, inf, gcd, floor
from itertools import combinations
from bisect import *
def main():
n = int(input())
x = list(map(int, input().split()))
m, z = int(input()), max(x)
p, ans, xx = [0] * (z + 1), [0] * (z + 1), [0] * (z + 1)
for i in x:
xx[i] += 1
del x
i = 2
while i <= z:
if not p[i]:
j = i
while j <= z:
p[j] = 1
ans[i] += xx[j]
j += i
i += 1
del p
del xx
for i in range(2, z + 1):
ans[i] += ans[i - 1]
for i in range(m):
l, r = map(int, input().split())
print(0 if l > z else ans[min(r, z)] - ans[l - 1])
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | output | 1 | 59,187 | 22 | 118,375 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently, the bear started studying data structures and faced the following problem.
You are given a sequence of integers x1, x2, ..., xn of length n and m queries, each of them is characterized by two integers li, ri. Let's introduce f(p) to represent the number of such indexes k, that xk is divisible by p. The answer to the query li, ri is the sum: <image>, where S(li, ri) is a set of prime numbers from segment [li, ri] (both borders are included in the segment).
Help the bear cope with the problem.
Input
The first line contains integer n (1 ≤ n ≤ 106). The second line contains n integers x1, x2, ..., xn (2 ≤ xi ≤ 107). The numbers are not necessarily distinct.
The third line contains integer m (1 ≤ m ≤ 50000). Each of the following m lines contains a pair of space-separated integers, li and ri (2 ≤ li ≤ ri ≤ 2·109) — the numbers that characterize the current query.
Output
Print m integers — the answers to the queries on the order the queries appear in the input.
Examples
Input
6
5 5 7 10 14 15
3
2 11
3 12
4 4
Output
9
7
0
Input
7
2 3 5 7 11 4 8
2
8 10
2 123
Output
0
7
Note
Consider the first sample. Overall, the first sample has 3 queries.
1. The first query l = 2, r = 11 comes. You need to count f(2) + f(3) + f(5) + f(7) + f(11) = 2 + 1 + 4 + 2 + 0 = 9.
2. The second query comes l = 3, r = 12. You need to count f(3) + f(5) + f(7) + f(11) = 1 + 4 + 2 + 0 = 7.
3. The third query comes l = 4, r = 4. As this interval has no prime numbers, then the sum equals 0. | instruction | 0 | 59,188 | 22 | 118,376 |
Tags: binary search, brute force, data structures, dp, implementation, math, number theory
Correct Solution:
```
import sys
input = sys.stdin.buffer.readline
n = int(input())
x = list(map(int, input().split()))
mx = max(x)
hf = [i for i in range(mx + 1)]
p = 2
while p * p <= mx:
if hf[p] == p:
for m in range(p * p, mx + 1, p):
hf[m] = p
p += 1
count = [0] * (mx + 1)
for e in x:
while e > 1:
p = hf[e]
while e % p == 0:
e //= p
count[p] += 1
for i in range(mx):
count[i + 1] += count[i]
m = int(input())
res = []
for _ in range(m):
l, r = map(int, input().split())
if l > mx:
res.append(0)
else:
res.append(count[min(r, mx)] - count[l - 1])
print("\n".join(map(str, res)))
``` | output | 1 | 59,188 | 22 | 118,377 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.