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.
Mr. F has n positive integers, a_1, a_2, …, a_n.
He thinks the greatest common divisor of these integers is too small. So he wants to enlarge it by removing some of the integers.
But this problem is too simple for him, so he does not want to do it by himself. If you help him, he will give you some scores in reward.
Your task is to calculate the minimum number of integers you need to remove so that the greatest common divisor of the remaining integers is bigger than that of all integers.
Input
The first line contains an integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of integers Mr. F has.
The second line contains n integers, a_1, a_2, …, a_n (1 ≤ a_i ≤ 1.5 ⋅ 10^7).
Output
Print an integer — the minimum number of integers you need to remove so that the greatest common divisor of the remaining integers is bigger than that of all integers.
You should not remove all of the integers.
If there is no solution, print «-1» (without quotes).
Examples
Input
3
1 2 4
Output
1
Input
4
6 9 15 30
Output
2
Input
3
1 1 1
Output
-1
Note
In the first example, the greatest common divisor is 1 in the beginning. You can remove 1 so that the greatest common divisor is enlarged to 2. The answer is 1.
In the second example, the greatest common divisor is 3 in the beginning. You can remove 6 and 9 so that the greatest common divisor is enlarged to 15. There is no solution which removes only one integer. So the answer is 2.
In the third example, there is no solution to enlarge the greatest common divisor. So the answer is -1. | instruction | 0 | 81,727 | 22 | 163,454 |
Tags: number theory
Correct Solution:
```
import sys
input=sys.stdin.buffer.readline
from math import gcd
n=int(input())
a=list(map(int,input().split()))
ma=max(a)
p=[0]*(ma+1)
for i in range(2,ma+1):
if p[i]==0:
for j in range(i*i,ma+1,i):
p[j]=i
for i in range(1,ma+1):
if not p[i]:
p[i]=i
g=a[0]
for i in range(1,n):
g=gcd(g,a[i])
cnt=[0]*(ma+1)
for i in range(n):
b=a[i]//g
while b>1:
fac=p[b]
cnt[fac]+=1
while b%fac==0:
b//=fac
res=max(cnt)
if res==0:
print(-1)
else:
print(n-res)
``` | output | 1 | 81,727 | 22 | 163,455 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. F has n positive integers, a_1, a_2, …, a_n.
He thinks the greatest common divisor of these integers is too small. So he wants to enlarge it by removing some of the integers.
But this problem is too simple for him, so he does not want to do it by himself. If you help him, he will give you some scores in reward.
Your task is to calculate the minimum number of integers you need to remove so that the greatest common divisor of the remaining integers is bigger than that of all integers.
Input
The first line contains an integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of integers Mr. F has.
The second line contains n integers, a_1, a_2, …, a_n (1 ≤ a_i ≤ 1.5 ⋅ 10^7).
Output
Print an integer — the minimum number of integers you need to remove so that the greatest common divisor of the remaining integers is bigger than that of all integers.
You should not remove all of the integers.
If there is no solution, print «-1» (without quotes).
Examples
Input
3
1 2 4
Output
1
Input
4
6 9 15 30
Output
2
Input
3
1 1 1
Output
-1
Note
In the first example, the greatest common divisor is 1 in the beginning. You can remove 1 so that the greatest common divisor is enlarged to 2. The answer is 1.
In the second example, the greatest common divisor is 3 in the beginning. You can remove 6 and 9 so that the greatest common divisor is enlarged to 15. There is no solution which removes only one integer. So the answer is 2.
In the third example, there is no solution to enlarge the greatest common divisor. So the answer is -1.
Submitted Solution:
```
def gcd(x, y):
while y != 0:
x, y = y, x % y
return x
primes = [2, 3]
x = 5
while x*x < 1.6*10**2:
for p in primes:
if x%p == 0:
break
else:
primes.append(x)
x += 2
n = int(input())
a = [int(x) for x in input().split()]
if a.count(1) == n:
print(-1)
exit(0)
if a.count(1) != 0:
print(a.count(1))
exit(0)
num = {}
for x in a:
for p in primes:
if x%p == 0:
num[p] = num.get(p, 0)+1
x //= p
num[x] = num.get(x, 0) + 1
m = n
for k, v in num.items():
if v == n:
continue
if v >= n // 2:
m = min(m, n - v)
else:
m = min(m, v)
print(m if m < n else -1)
``` | instruction | 0 | 81,728 | 22 | 163,456 |
No | output | 1 | 81,728 | 22 | 163,457 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. F has n positive integers, a_1, a_2, …, a_n.
He thinks the greatest common divisor of these integers is too small. So he wants to enlarge it by removing some of the integers.
But this problem is too simple for him, so he does not want to do it by himself. If you help him, he will give you some scores in reward.
Your task is to calculate the minimum number of integers you need to remove so that the greatest common divisor of the remaining integers is bigger than that of all integers.
Input
The first line contains an integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of integers Mr. F has.
The second line contains n integers, a_1, a_2, …, a_n (1 ≤ a_i ≤ 1.5 ⋅ 10^7).
Output
Print an integer — the minimum number of integers you need to remove so that the greatest common divisor of the remaining integers is bigger than that of all integers.
You should not remove all of the integers.
If there is no solution, print «-1» (without quotes).
Examples
Input
3
1 2 4
Output
1
Input
4
6 9 15 30
Output
2
Input
3
1 1 1
Output
-1
Note
In the first example, the greatest common divisor is 1 in the beginning. You can remove 1 so that the greatest common divisor is enlarged to 2. The answer is 1.
In the second example, the greatest common divisor is 3 in the beginning. You can remove 6 and 9 so that the greatest common divisor is enlarged to 15. There is no solution which removes only one integer. So the answer is 2.
In the third example, there is no solution to enlarge the greatest common divisor. So the answer is -1.
Submitted Solution:
```
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now-----------------------------------------------------
n=int(input())
a=list(map(int,input().split()))
a.sort()
b=[0]*(n-1)
g=a[-1]
for i in range (n-2,-1,-1):
b[i]=g
g=math.gcd(g, a[i])
#print(b)
r=-1
for i in range (n-1):
if b[i]>a[i]:
r=i+1
break
print(r)
``` | instruction | 0 | 81,729 | 22 | 163,458 |
No | output | 1 | 81,729 | 22 | 163,459 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. F has n positive integers, a_1, a_2, …, a_n.
He thinks the greatest common divisor of these integers is too small. So he wants to enlarge it by removing some of the integers.
But this problem is too simple for him, so he does not want to do it by himself. If you help him, he will give you some scores in reward.
Your task is to calculate the minimum number of integers you need to remove so that the greatest common divisor of the remaining integers is bigger than that of all integers.
Input
The first line contains an integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of integers Mr. F has.
The second line contains n integers, a_1, a_2, …, a_n (1 ≤ a_i ≤ 1.5 ⋅ 10^7).
Output
Print an integer — the minimum number of integers you need to remove so that the greatest common divisor of the remaining integers is bigger than that of all integers.
You should not remove all of the integers.
If there is no solution, print «-1» (without quotes).
Examples
Input
3
1 2 4
Output
1
Input
4
6 9 15 30
Output
2
Input
3
1 1 1
Output
-1
Note
In the first example, the greatest common divisor is 1 in the beginning. You can remove 1 so that the greatest common divisor is enlarged to 2. The answer is 1.
In the second example, the greatest common divisor is 3 in the beginning. You can remove 6 and 9 so that the greatest common divisor is enlarged to 15. There is no solution which removes only one integer. So the answer is 2.
In the third example, there is no solution to enlarge the greatest common divisor. So the answer is -1.
Submitted Solution:
```
def gcd(a, b):
while b > 0:
a, b = b, a % b
return a
a = int(input())
b=list(map(int,input().split()))
c = max(b)
d=[]
result = b[0]
for i in b[1:]:
result = gcd(result,i)
for i in range(len(b)-1):
for j in range(i+1,len(b)):
d.append((gcd(b[i],b[j])))
e = d.count(max(d))
if (a-(e+1)) <0:
print(-1)
else:
print(a-e-1)
``` | instruction | 0 | 81,730 | 22 | 163,460 |
No | output | 1 | 81,730 | 22 | 163,461 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. F has n positive integers, a_1, a_2, …, a_n.
He thinks the greatest common divisor of these integers is too small. So he wants to enlarge it by removing some of the integers.
But this problem is too simple for him, so he does not want to do it by himself. If you help him, he will give you some scores in reward.
Your task is to calculate the minimum number of integers you need to remove so that the greatest common divisor of the remaining integers is bigger than that of all integers.
Input
The first line contains an integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of integers Mr. F has.
The second line contains n integers, a_1, a_2, …, a_n (1 ≤ a_i ≤ 1.5 ⋅ 10^7).
Output
Print an integer — the minimum number of integers you need to remove so that the greatest common divisor of the remaining integers is bigger than that of all integers.
You should not remove all of the integers.
If there is no solution, print «-1» (without quotes).
Examples
Input
3
1 2 4
Output
1
Input
4
6 9 15 30
Output
2
Input
3
1 1 1
Output
-1
Note
In the first example, the greatest common divisor is 1 in the beginning. You can remove 1 so that the greatest common divisor is enlarged to 2. The answer is 1.
In the second example, the greatest common divisor is 3 in the beginning. You can remove 6 and 9 so that the greatest common divisor is enlarged to 15. There is no solution which removes only one integer. So the answer is 2.
In the third example, there is no solution to enlarge the greatest common divisor. So the answer is -1.
Submitted Solution:
```
from math import gcd
n = int(input())
l = list(map(int,input().split()))
l.sort()
dp = [1]*(n-1)
dp[n-2] = gcd(l[-1],l[-2])
for i in range(n-3,-1,-1):
dp[i] = gcd(dp[i+1],l[i])
c = 0
for i in range(n-1):
if dp[i] <= l[i]:
c+=1
try:
if dp[i+1] > dp[i]:
break
except IndexError:
pass
#print(dp)
if c == n-1:
print(-1)
else:
print(c)
``` | instruction | 0 | 81,731 | 22 | 163,462 |
No | output | 1 | 81,731 | 22 | 163,463 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Omkar's last class of math, he learned about the least common multiple, or LCM. LCM(a, b) is the smallest positive integer x which is divisible by both a and b.
Omkar, having a laudably curious mind, immediately thought of a problem involving the LCM operation: given an integer n, find positive integers a and b such that a + b = n and LCM(a, b) is the minimum value possible.
Can you help Omkar solve his ludicrously challenging math problem?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
Each test case consists of a single integer n (2 ≤ n ≤ 10^{9}).
Output
For each test case, output two positive integers a and b, such that a + b = n and LCM(a, b) is the minimum possible.
Example
Input
3
4
6
9
Output
2 2
3 3
3 6
Note
For the first test case, the numbers we can choose are 1, 3 or 2, 2. LCM(1, 3) = 3 and LCM(2, 2) = 2, so we output 2 \ 2.
For the second test case, the numbers we can choose are 1, 5, 2, 4, or 3, 3. LCM(1, 5) = 5, LCM(2, 4) = 4, and LCM(3, 3) = 3, so we output 3 \ 3.
For the third test case, LCM(3, 6) = 6. It can be shown that there are no other pairs of numbers which sum to 9 that have a lower LCM. | instruction | 0 | 81,870 | 22 | 163,740 |
Tags: greedy, math, number theory
Correct Solution:
```
import math
def get_divisor(n):
res = []
x = 1
while n >= x*x:
if n % x == 0:
res.append(x)
if n != x*x:
res.append(n//x)
x += 1
return sorted(res)
t = int(input())
for _ in range(t):
n = int(input())
maxgcd = 1
a, b = 1, n-1
for d in get_divisor(n)[1:-1]:
if math.gcd(d, n-d) > maxgcd:
a, b = d, n-d
maxgcd = math.gcd(d, n-d)
print(a, b)
``` | output | 1 | 81,870 | 22 | 163,741 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Omkar's last class of math, he learned about the least common multiple, or LCM. LCM(a, b) is the smallest positive integer x which is divisible by both a and b.
Omkar, having a laudably curious mind, immediately thought of a problem involving the LCM operation: given an integer n, find positive integers a and b such that a + b = n and LCM(a, b) is the minimum value possible.
Can you help Omkar solve his ludicrously challenging math problem?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
Each test case consists of a single integer n (2 ≤ n ≤ 10^{9}).
Output
For each test case, output two positive integers a and b, such that a + b = n and LCM(a, b) is the minimum possible.
Example
Input
3
4
6
9
Output
2 2
3 3
3 6
Note
For the first test case, the numbers we can choose are 1, 3 or 2, 2. LCM(1, 3) = 3 and LCM(2, 2) = 2, so we output 2 \ 2.
For the second test case, the numbers we can choose are 1, 5, 2, 4, or 3, 3. LCM(1, 5) = 5, LCM(2, 4) = 4, and LCM(3, 3) = 3, so we output 3 \ 3.
For the third test case, LCM(3, 6) = 6. It can be shown that there are no other pairs of numbers which sum to 9 that have a lower LCM. | instruction | 0 | 81,871 | 22 | 163,742 |
Tags: greedy, math, number theory
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
ans=int(n/2)
if n%2==0:
print(ans,ans)
else:
ans=1
for i in range(3,int(n**0.5)+1,2):
if n%i==0:
ans=i
break
if ans!=1:
ans=int(n/ans)
print(ans, n-ans)
``` | output | 1 | 81,871 | 22 | 163,743 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Omkar's last class of math, he learned about the least common multiple, or LCM. LCM(a, b) is the smallest positive integer x which is divisible by both a and b.
Omkar, having a laudably curious mind, immediately thought of a problem involving the LCM operation: given an integer n, find positive integers a and b such that a + b = n and LCM(a, b) is the minimum value possible.
Can you help Omkar solve his ludicrously challenging math problem?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
Each test case consists of a single integer n (2 ≤ n ≤ 10^{9}).
Output
For each test case, output two positive integers a and b, such that a + b = n and LCM(a, b) is the minimum possible.
Example
Input
3
4
6
9
Output
2 2
3 3
3 6
Note
For the first test case, the numbers we can choose are 1, 3 or 2, 2. LCM(1, 3) = 3 and LCM(2, 2) = 2, so we output 2 \ 2.
For the second test case, the numbers we can choose are 1, 5, 2, 4, or 3, 3. LCM(1, 5) = 5, LCM(2, 4) = 4, and LCM(3, 3) = 3, so we output 3 \ 3.
For the third test case, LCM(3, 6) = 6. It can be shown that there are no other pairs of numbers which sum to 9 that have a lower LCM. | instruction | 0 | 81,872 | 22 | 163,744 |
Tags: greedy, math, number theory
Correct Solution:
```
from math import sqrt
def ans(a):
if a % 2 == 0:
print(a // 2, a // 2)
else:
for i in range(2, int(sqrt(a)+1)):
if a % (i) == 0:
print(a // i, a - (a // i))
return
print(1,a-1)
for _ in range(int(input())):
a=int(input())
ans(a)
``` | output | 1 | 81,872 | 22 | 163,745 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Omkar's last class of math, he learned about the least common multiple, or LCM. LCM(a, b) is the smallest positive integer x which is divisible by both a and b.
Omkar, having a laudably curious mind, immediately thought of a problem involving the LCM operation: given an integer n, find positive integers a and b such that a + b = n and LCM(a, b) is the minimum value possible.
Can you help Omkar solve his ludicrously challenging math problem?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
Each test case consists of a single integer n (2 ≤ n ≤ 10^{9}).
Output
For each test case, output two positive integers a and b, such that a + b = n and LCM(a, b) is the minimum possible.
Example
Input
3
4
6
9
Output
2 2
3 3
3 6
Note
For the first test case, the numbers we can choose are 1, 3 or 2, 2. LCM(1, 3) = 3 and LCM(2, 2) = 2, so we output 2 \ 2.
For the second test case, the numbers we can choose are 1, 5, 2, 4, or 3, 3. LCM(1, 5) = 5, LCM(2, 4) = 4, and LCM(3, 3) = 3, so we output 3 \ 3.
For the third test case, LCM(3, 6) = 6. It can be shown that there are no other pairs of numbers which sum to 9 that have a lower LCM. | instruction | 0 | 81,873 | 22 | 163,746 |
Tags: greedy, math, number theory
Correct Solution:
```
import math
t=int(input())
for _ in range(t):
n=int(input())
if n%2==0:
print(n//2,n//2)
continue
else:
i=1
lis=[]
while i <= math.sqrt(n):
if (n % i == 0) :
if (n / i == i) :
lis.append(i)
else :
lis.append(i)
lis.append(n/i)
i+=1
lis.sort()
p=len(lis)
if p==2:
print(1,n-1)
else:
print(int(lis[p-2]),int(n-lis[p-2]))
``` | output | 1 | 81,873 | 22 | 163,747 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Omkar's last class of math, he learned about the least common multiple, or LCM. LCM(a, b) is the smallest positive integer x which is divisible by both a and b.
Omkar, having a laudably curious mind, immediately thought of a problem involving the LCM operation: given an integer n, find positive integers a and b such that a + b = n and LCM(a, b) is the minimum value possible.
Can you help Omkar solve his ludicrously challenging math problem?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
Each test case consists of a single integer n (2 ≤ n ≤ 10^{9}).
Output
For each test case, output two positive integers a and b, such that a + b = n and LCM(a, b) is the minimum possible.
Example
Input
3
4
6
9
Output
2 2
3 3
3 6
Note
For the first test case, the numbers we can choose are 1, 3 or 2, 2. LCM(1, 3) = 3 and LCM(2, 2) = 2, so we output 2 \ 2.
For the second test case, the numbers we can choose are 1, 5, 2, 4, or 3, 3. LCM(1, 5) = 5, LCM(2, 4) = 4, and LCM(3, 3) = 3, so we output 3 \ 3.
For the third test case, LCM(3, 6) = 6. It can be shown that there are no other pairs of numbers which sum to 9 that have a lower LCM. | instruction | 0 | 81,874 | 22 | 163,748 |
Tags: greedy, math, number theory
Correct Solution:
```
from math import sqrt,ceil
t=int(input())
for _ in range(t):
n=int(input())
if(n%2==0):
print(int(n/2),int(n/2))
elif(n%3==0):
print(int(n/3),int(2*n/3))
else:
a=ceil(sqrt(n))
while(n%a!=0 and a>1):
if(n%a==0):
ans=a
a-=1
ans=1
while(a>1):
if(n%a==0):
ans=a
a-=1
if(ans>1):
print(int(n/ans),(ans-1)*(int(n/ans)))
else:
print(n-ans,ans)
``` | output | 1 | 81,874 | 22 | 163,749 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Omkar's last class of math, he learned about the least common multiple, or LCM. LCM(a, b) is the smallest positive integer x which is divisible by both a and b.
Omkar, having a laudably curious mind, immediately thought of a problem involving the LCM operation: given an integer n, find positive integers a and b such that a + b = n and LCM(a, b) is the minimum value possible.
Can you help Omkar solve his ludicrously challenging math problem?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
Each test case consists of a single integer n (2 ≤ n ≤ 10^{9}).
Output
For each test case, output two positive integers a and b, such that a + b = n and LCM(a, b) is the minimum possible.
Example
Input
3
4
6
9
Output
2 2
3 3
3 6
Note
For the first test case, the numbers we can choose are 1, 3 or 2, 2. LCM(1, 3) = 3 and LCM(2, 2) = 2, so we output 2 \ 2.
For the second test case, the numbers we can choose are 1, 5, 2, 4, or 3, 3. LCM(1, 5) = 5, LCM(2, 4) = 4, and LCM(3, 3) = 3, so we output 3 \ 3.
For the third test case, LCM(3, 6) = 6. It can be shown that there are no other pairs of numbers which sum to 9 that have a lower LCM. | instruction | 0 | 81,875 | 22 | 163,750 |
Tags: greedy, math, number theory
Correct Solution:
```
def ans(n):
x = n//2
if n%2 == 0:
return (str(x)+' '+str(x))
a = 1
for i in range(2, int(n**0.5)+1):
if n%i == 0:
a = i
break
if a == 1: return ('1 '+str(n-1))
p = n//a
q = n-p
return (str(p)+' '+str(q))
for _ in range(int(input())):
n = int(input())
print(ans(n))
``` | output | 1 | 81,875 | 22 | 163,751 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Omkar's last class of math, he learned about the least common multiple, or LCM. LCM(a, b) is the smallest positive integer x which is divisible by both a and b.
Omkar, having a laudably curious mind, immediately thought of a problem involving the LCM operation: given an integer n, find positive integers a and b such that a + b = n and LCM(a, b) is the minimum value possible.
Can you help Omkar solve his ludicrously challenging math problem?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
Each test case consists of a single integer n (2 ≤ n ≤ 10^{9}).
Output
For each test case, output two positive integers a and b, such that a + b = n and LCM(a, b) is the minimum possible.
Example
Input
3
4
6
9
Output
2 2
3 3
3 6
Note
For the first test case, the numbers we can choose are 1, 3 or 2, 2. LCM(1, 3) = 3 and LCM(2, 2) = 2, so we output 2 \ 2.
For the second test case, the numbers we can choose are 1, 5, 2, 4, or 3, 3. LCM(1, 5) = 5, LCM(2, 4) = 4, and LCM(3, 3) = 3, so we output 3 \ 3.
For the third test case, LCM(3, 6) = 6. It can be shown that there are no other pairs of numbers which sum to 9 that have a lower LCM. | instruction | 0 | 81,876 | 22 | 163,752 |
Tags: greedy, math, number theory
Correct Solution:
```
t = int(input())
while t != 0:
t -= 1
n = int(input())
i = 2
m = 1
while i * i <= n:
if n % i == 0:
print(n // i, n - n // i)
m = 0
break
else:
i += 1
if m == 1:
print(1, n - 1)
``` | output | 1 | 81,876 | 22 | 163,753 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Omkar's last class of math, he learned about the least common multiple, or LCM. LCM(a, b) is the smallest positive integer x which is divisible by both a and b.
Omkar, having a laudably curious mind, immediately thought of a problem involving the LCM operation: given an integer n, find positive integers a and b such that a + b = n and LCM(a, b) is the minimum value possible.
Can you help Omkar solve his ludicrously challenging math problem?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
Each test case consists of a single integer n (2 ≤ n ≤ 10^{9}).
Output
For each test case, output two positive integers a and b, such that a + b = n and LCM(a, b) is the minimum possible.
Example
Input
3
4
6
9
Output
2 2
3 3
3 6
Note
For the first test case, the numbers we can choose are 1, 3 or 2, 2. LCM(1, 3) = 3 and LCM(2, 2) = 2, so we output 2 \ 2.
For the second test case, the numbers we can choose are 1, 5, 2, 4, or 3, 3. LCM(1, 5) = 5, LCM(2, 4) = 4, and LCM(3, 3) = 3, so we output 3 \ 3.
For the third test case, LCM(3, 6) = 6. It can be shown that there are no other pairs of numbers which sum to 9 that have a lower LCM. | instruction | 0 | 81,877 | 22 | 163,754 |
Tags: greedy, math, number theory
Correct Solution:
```
import time
def SieveOfEratosthenes(n):
# Create a boolean array "prime[0..n]" and
# initialize all entries it as true. A value
# in prime[i] will finally be false if i is
# Not a prime, else true.
prime = [True for i in range(n+1)]
p = 2
while(p * p <= n):
# If prime[p] is not changed, then it is
# a prime
if (prime[p] == True):
# Update all multiples of p
for i in range(p * p, n + 1, p):
prime[i] = False
p += 1
# Print all prime numbers
a=[]
for p in range(2, n):
if prime[p]:
a.append(p)
return a
c = SieveOfEratosthenes(1000000)
t = int(input())
for _ in range(t):
n = int(input())
if n%2==0:
print(n//2,n//2)
else:
cnt=0
for i in c:
if i>n:
break
if n%i==0:
print(n//i,n-(n//i))
cnt=1
break
if cnt==0:
print(1,n-1)
``` | output | 1 | 81,877 | 22 | 163,755 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Omkar's last class of math, he learned about the least common multiple, or LCM. LCM(a, b) is the smallest positive integer x which is divisible by both a and b.
Omkar, having a laudably curious mind, immediately thought of a problem involving the LCM operation: given an integer n, find positive integers a and b such that a + b = n and LCM(a, b) is the minimum value possible.
Can you help Omkar solve his ludicrously challenging math problem?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
Each test case consists of a single integer n (2 ≤ n ≤ 10^{9}).
Output
For each test case, output two positive integers a and b, such that a + b = n and LCM(a, b) is the minimum possible.
Example
Input
3
4
6
9
Output
2 2
3 3
3 6
Note
For the first test case, the numbers we can choose are 1, 3 or 2, 2. LCM(1, 3) = 3 and LCM(2, 2) = 2, so we output 2 \ 2.
For the second test case, the numbers we can choose are 1, 5, 2, 4, or 3, 3. LCM(1, 5) = 5, LCM(2, 4) = 4, and LCM(3, 3) = 3, so we output 3 \ 3.
For the third test case, LCM(3, 6) = 6. It can be shown that there are no other pairs of numbers which sum to 9 that have a lower LCM.
Submitted Solution:
```
import sys
input=sys.stdin.buffer.readline
import os
from math import*
t=int(input())
while t:
t-=1
n=int(input())
if n%2==0:
ans=n//2
print(ans,ans)
else:
dif=10000000000
a=1
b=n-1
z=0
for i in range(int(ceil(sqrt(n))),0,-1):
if n%i==0:
d1=n//i
d2=n-(n//i)
if dif>(int(fabs(d1-d2))):
dif=int(fabs(d1-d2))
a=d1
b=d2
else:
z=1
print(a,b)
break
if z==0:
print(1,n-1)
``` | instruction | 0 | 81,878 | 22 | 163,756 |
Yes | output | 1 | 81,878 | 22 | 163,757 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Omkar's last class of math, he learned about the least common multiple, or LCM. LCM(a, b) is the smallest positive integer x which is divisible by both a and b.
Omkar, having a laudably curious mind, immediately thought of a problem involving the LCM operation: given an integer n, find positive integers a and b such that a + b = n and LCM(a, b) is the minimum value possible.
Can you help Omkar solve his ludicrously challenging math problem?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
Each test case consists of a single integer n (2 ≤ n ≤ 10^{9}).
Output
For each test case, output two positive integers a and b, such that a + b = n and LCM(a, b) is the minimum possible.
Example
Input
3
4
6
9
Output
2 2
3 3
3 6
Note
For the first test case, the numbers we can choose are 1, 3 or 2, 2. LCM(1, 3) = 3 and LCM(2, 2) = 2, so we output 2 \ 2.
For the second test case, the numbers we can choose are 1, 5, 2, 4, or 3, 3. LCM(1, 5) = 5, LCM(2, 4) = 4, and LCM(3, 3) = 3, so we output 3 \ 3.
For the third test case, LCM(3, 6) = 6. It can be shown that there are no other pairs of numbers which sum to 9 that have a lower LCM.
Submitted Solution:
```
import math
for _ in range(int(input())):
n=int(input())
if(n%2==0):
print(n//2,n//2)
else:
t1=1
t2=n-1
for i in range(2,int(math.sqrt(n))+1):
if(n%i==0):
t1=n//i
t2=n-t1
break
print(t1,t2)
``` | instruction | 0 | 81,879 | 22 | 163,758 |
Yes | output | 1 | 81,879 | 22 | 163,759 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Omkar's last class of math, he learned about the least common multiple, or LCM. LCM(a, b) is the smallest positive integer x which is divisible by both a and b.
Omkar, having a laudably curious mind, immediately thought of a problem involving the LCM operation: given an integer n, find positive integers a and b such that a + b = n and LCM(a, b) is the minimum value possible.
Can you help Omkar solve his ludicrously challenging math problem?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
Each test case consists of a single integer n (2 ≤ n ≤ 10^{9}).
Output
For each test case, output two positive integers a and b, such that a + b = n and LCM(a, b) is the minimum possible.
Example
Input
3
4
6
9
Output
2 2
3 3
3 6
Note
For the first test case, the numbers we can choose are 1, 3 or 2, 2. LCM(1, 3) = 3 and LCM(2, 2) = 2, so we output 2 \ 2.
For the second test case, the numbers we can choose are 1, 5, 2, 4, or 3, 3. LCM(1, 5) = 5, LCM(2, 4) = 4, and LCM(3, 3) = 3, so we output 3 \ 3.
For the third test case, LCM(3, 6) = 6. It can be shown that there are no other pairs of numbers which sum to 9 that have a lower LCM.
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Sat Jul 11 20:29:38 2020
@author: shubham gupta
"""
from functools import reduce
def factors(n):return list(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n**0.5) + 1) if n % i == 0))))
for _ in range(int(input())):
n = int(input())
if n % 2 == 0:
print(n//2,n//2)
else:
r = factors(n)
#print(r)
s = []
for i in range(len(r)):
if r[i] < n:
s.append(r[i])
k = max(s)
print(k,n-k)
``` | instruction | 0 | 81,880 | 22 | 163,760 |
Yes | output | 1 | 81,880 | 22 | 163,761 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Omkar's last class of math, he learned about the least common multiple, or LCM. LCM(a, b) is the smallest positive integer x which is divisible by both a and b.
Omkar, having a laudably curious mind, immediately thought of a problem involving the LCM operation: given an integer n, find positive integers a and b such that a + b = n and LCM(a, b) is the minimum value possible.
Can you help Omkar solve his ludicrously challenging math problem?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
Each test case consists of a single integer n (2 ≤ n ≤ 10^{9}).
Output
For each test case, output two positive integers a and b, such that a + b = n and LCM(a, b) is the minimum possible.
Example
Input
3
4
6
9
Output
2 2
3 3
3 6
Note
For the first test case, the numbers we can choose are 1, 3 or 2, 2. LCM(1, 3) = 3 and LCM(2, 2) = 2, so we output 2 \ 2.
For the second test case, the numbers we can choose are 1, 5, 2, 4, or 3, 3. LCM(1, 5) = 5, LCM(2, 4) = 4, and LCM(3, 3) = 3, so we output 3 \ 3.
For the third test case, LCM(3, 6) = 6. It can be shown that there are no other pairs of numbers which sum to 9 that have a lower LCM.
Submitted Solution:
```
# n=int(input())
# n,k=map(int,input().split())
# arr=list(map(int,input().split()))
#ls=list(map(int,input().split()))
#for i in range(m):
# for _ in range(int(input())):
from collections import Counter
#from fractions import Fraction
#n = int(input())
# for _ in range(int(input())):
# import math
import sys
# from collections import deque
# from collections import Counter
# ls=list(map(int,input().split()))
# for i in range(m):
# for i in range(int(input())):
# n,k= map(int, input().split())
# arr=list(map(int,input().split()))
# n=sys.stdin.readline()
# n=int(n)
# n,k= map(int, input().split())
# arr=list(map(int,input().split()))
# n=int(input())
import math
from math import gcd
for _ in range(int(input())):
n = int(input())
for i in range(2,int(n**0.5)+1):
if n%i==0:
print(n//i,n-(n//i))
break
else:
print(1, n-1)
``` | instruction | 0 | 81,881 | 22 | 163,762 |
Yes | output | 1 | 81,881 | 22 | 163,763 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Omkar's last class of math, he learned about the least common multiple, or LCM. LCM(a, b) is the smallest positive integer x which is divisible by both a and b.
Omkar, having a laudably curious mind, immediately thought of a problem involving the LCM operation: given an integer n, find positive integers a and b such that a + b = n and LCM(a, b) is the minimum value possible.
Can you help Omkar solve his ludicrously challenging math problem?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
Each test case consists of a single integer n (2 ≤ n ≤ 10^{9}).
Output
For each test case, output two positive integers a and b, such that a + b = n and LCM(a, b) is the minimum possible.
Example
Input
3
4
6
9
Output
2 2
3 3
3 6
Note
For the first test case, the numbers we can choose are 1, 3 or 2, 2. LCM(1, 3) = 3 and LCM(2, 2) = 2, so we output 2 \ 2.
For the second test case, the numbers we can choose are 1, 5, 2, 4, or 3, 3. LCM(1, 5) = 5, LCM(2, 4) = 4, and LCM(3, 3) = 3, so we output 3 \ 3.
For the third test case, LCM(3, 6) = 6. It can be shown that there are no other pairs of numbers which sum to 9 that have a lower LCM.
Submitted Solution:
```
T=int(input())
while T!=0:
T-=1
n=int(input())
a=0
b=0
num = 1
while num*num<=n:
if n%num==0:
a=n//num
b=n-a
num += 1
print(a,b)
``` | instruction | 0 | 81,882 | 22 | 163,764 |
No | output | 1 | 81,882 | 22 | 163,765 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Omkar's last class of math, he learned about the least common multiple, or LCM. LCM(a, b) is the smallest positive integer x which is divisible by both a and b.
Omkar, having a laudably curious mind, immediately thought of a problem involving the LCM operation: given an integer n, find positive integers a and b such that a + b = n and LCM(a, b) is the minimum value possible.
Can you help Omkar solve his ludicrously challenging math problem?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
Each test case consists of a single integer n (2 ≤ n ≤ 10^{9}).
Output
For each test case, output two positive integers a and b, such that a + b = n and LCM(a, b) is the minimum possible.
Example
Input
3
4
6
9
Output
2 2
3 3
3 6
Note
For the first test case, the numbers we can choose are 1, 3 or 2, 2. LCM(1, 3) = 3 and LCM(2, 2) = 2, so we output 2 \ 2.
For the second test case, the numbers we can choose are 1, 5, 2, 4, or 3, 3. LCM(1, 5) = 5, LCM(2, 4) = 4, and LCM(3, 3) = 3, so we output 3 \ 3.
For the third test case, LCM(3, 6) = 6. It can be shown that there are no other pairs of numbers which sum to 9 that have a lower LCM.
Submitted Solution:
```
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
# divisors.sort()
return divisors
for _ in range(int(input())):
import math
def lcm(x, y):
return (x * y) // math.gcd(x, y)
n = 3
l = make_divisors(n)
l.sort()
divcnt = n // l[1]
print(divcnt, n - divcnt)
``` | instruction | 0 | 81,883 | 22 | 163,766 |
No | output | 1 | 81,883 | 22 | 163,767 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Omkar's last class of math, he learned about the least common multiple, or LCM. LCM(a, b) is the smallest positive integer x which is divisible by both a and b.
Omkar, having a laudably curious mind, immediately thought of a problem involving the LCM operation: given an integer n, find positive integers a and b such that a + b = n and LCM(a, b) is the minimum value possible.
Can you help Omkar solve his ludicrously challenging math problem?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
Each test case consists of a single integer n (2 ≤ n ≤ 10^{9}).
Output
For each test case, output two positive integers a and b, such that a + b = n and LCM(a, b) is the minimum possible.
Example
Input
3
4
6
9
Output
2 2
3 3
3 6
Note
For the first test case, the numbers we can choose are 1, 3 or 2, 2. LCM(1, 3) = 3 and LCM(2, 2) = 2, so we output 2 \ 2.
For the second test case, the numbers we can choose are 1, 5, 2, 4, or 3, 3. LCM(1, 5) = 5, LCM(2, 4) = 4, and LCM(3, 3) = 3, so we output 3 \ 3.
For the third test case, LCM(3, 6) = 6. It can be shown that there are no other pairs of numbers which sum to 9 that have a lower LCM.
Submitted Solution:
```
import math
t = int(input())
solucio = []
for k in range(t):
n = int(input())
if n % 2 == 0:
a = n / 2
else:
trobat = False
# a = n // 2
# while a > 1 and trobat is False:
# if n % a == 0:
# trobat = True
# else:
# a -= 1
ll = 3
arrel = math.sqrt(n)
while ll < arrel and trobat is False:
if n % ll == 0:
trobat = True
a = n / ll
else:
ll += 1
if trobat is False:
a = 1
solucio.append(str(int(a)) + " " + str(int(n - a)))
for i in range(t):
print(solucio[i])
``` | instruction | 0 | 81,884 | 22 | 163,768 |
No | output | 1 | 81,884 | 22 | 163,769 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Omkar's last class of math, he learned about the least common multiple, or LCM. LCM(a, b) is the smallest positive integer x which is divisible by both a and b.
Omkar, having a laudably curious mind, immediately thought of a problem involving the LCM operation: given an integer n, find positive integers a and b such that a + b = n and LCM(a, b) is the minimum value possible.
Can you help Omkar solve his ludicrously challenging math problem?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
Each test case consists of a single integer n (2 ≤ n ≤ 10^{9}).
Output
For each test case, output two positive integers a and b, such that a + b = n and LCM(a, b) is the minimum possible.
Example
Input
3
4
6
9
Output
2 2
3 3
3 6
Note
For the first test case, the numbers we can choose are 1, 3 or 2, 2. LCM(1, 3) = 3 and LCM(2, 2) = 2, so we output 2 \ 2.
For the second test case, the numbers we can choose are 1, 5, 2, 4, or 3, 3. LCM(1, 5) = 5, LCM(2, 4) = 4, and LCM(3, 3) = 3, so we output 3 \ 3.
For the third test case, LCM(3, 6) = 6. It can be shown that there are no other pairs of numbers which sum to 9 that have a lower LCM.
Submitted Solution:
```
import math
t = int(input())
num = 1
for i in range(t):
n = int(input())
flag = 0
if n%2 == 0:
print(n//2,n//2)
else:
for j in range(int(math.sqrt(n)),1,-1):
if n%j == 0:
num = max(max(j,n//j),num)
flag = 1
if flag == 0:
print(1,n-1)
if flag == 1:
print(num,n-num)
``` | instruction | 0 | 81,885 | 22 | 163,770 |
No | output | 1 | 81,885 | 22 | 163,771 |
Provide tags and a correct Python 3 solution for this coding contest problem.
DZY has a hash table with p buckets, numbered from 0 to p - 1. He wants to insert n numbers, in the order they are given, into the hash table. For the i-th number xi, DZY will put it into the bucket numbered h(xi), where h(x) is the hash function. In this problem we will assume, that h(x) = x mod p. Operation a mod b denotes taking a remainder after division a by b.
However, each bucket can contain no more than one element. If DZY wants to insert an number into a bucket which is already filled, we say a "conflict" happens. Suppose the first conflict happens right after the i-th insertion, you should output i. If no conflict happens, just output -1.
Input
The first line contains two integers, p and n (2 ≤ p, n ≤ 300). Then n lines follow. The i-th of them contains an integer xi (0 ≤ xi ≤ 109).
Output
Output a single integer — the answer to the problem.
Examples
Input
10 5
0
21
53
41
53
Output
4
Input
5 5
0
1
2
3
4
Output
-1 | instruction | 0 | 82,065 | 22 | 164,130 |
Tags: implementation
Correct Solution:
```
def solve():
p, n = map(int, input().split())
a = []
for _ in range(n):
a.append(int(input()))
myset = set()
for i in range(n):
x = a[i]
if x % p in myset:
return i + 1
else:
myset.add(x % p)
return -1
print(solve())
``` | output | 1 | 82,065 | 22 | 164,131 |
Provide tags and a correct Python 3 solution for this coding contest problem.
DZY has a hash table with p buckets, numbered from 0 to p - 1. He wants to insert n numbers, in the order they are given, into the hash table. For the i-th number xi, DZY will put it into the bucket numbered h(xi), where h(x) is the hash function. In this problem we will assume, that h(x) = x mod p. Operation a mod b denotes taking a remainder after division a by b.
However, each bucket can contain no more than one element. If DZY wants to insert an number into a bucket which is already filled, we say a "conflict" happens. Suppose the first conflict happens right after the i-th insertion, you should output i. If no conflict happens, just output -1.
Input
The first line contains two integers, p and n (2 ≤ p, n ≤ 300). Then n lines follow. The i-th of them contains an integer xi (0 ≤ xi ≤ 109).
Output
Output a single integer — the answer to the problem.
Examples
Input
10 5
0
21
53
41
53
Output
4
Input
5 5
0
1
2
3
4
Output
-1 | instruction | 0 | 82,070 | 22 | 164,140 |
Tags: implementation
Correct Solution:
```
pn = list(map(int, input().split()))
p = pn[0]
n = pn[1]
res = [0] * p
inp = []
flag = 0
for i in range(n):
inp.append(int(input()))
for i in range(len(inp)):
if res[inp[i] % p] == 0:
res[inp[i] % p] = 1
elif res[inp[i] % p] == 1:
flag = 1
break
if flag == 1:
break
if flag == 1:
print(i + 1)
else:
print(-1)
``` | output | 1 | 82,070 | 22 | 164,141 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Some time ago Leonid have known about idempotent functions. Idempotent function defined on a set {1, 2, ..., n} is such function <image>, that for any <image> the formula g(g(x)) = g(x) holds.
Let's denote as f(k)(x) the function f applied k times to the value x. More formally, f(1)(x) = f(x), f(k)(x) = f(f(k - 1)(x)) for each k > 1.
You are given some function <image>. Your task is to find minimum positive integer k such that function f(k)(x) is idempotent.
Input
In the first line of the input there is a single integer n (1 ≤ n ≤ 200) — the size of function f domain.
In the second line follow f(1), f(2), ..., f(n) (1 ≤ f(i) ≤ n for each 1 ≤ i ≤ n), the values of a function.
Output
Output minimum k such that function f(k)(x) is idempotent.
Examples
Input
4
1 2 2 4
Output
1
Input
3
2 3 3
Output
2
Input
3
2 3 1
Output
3
Note
In the first sample test function f(x) = f(1)(x) is already idempotent since f(f(1)) = f(1) = 1, f(f(2)) = f(2) = 2, f(f(3)) = f(3) = 2, f(f(4)) = f(4) = 4.
In the second sample test:
* function f(x) = f(1)(x) isn't idempotent because f(f(1)) = 3 but f(1) = 2;
* function f(x) = f(2)(x) is idempotent since for any x it is true that f(2)(x) = 3, so it is also true that f(2)(f(2)(x)) = 3.
In the third sample test:
* function f(x) = f(1)(x) isn't idempotent because f(f(1)) = 3 but f(1) = 2;
* function f(f(x)) = f(2)(x) isn't idempotent because f(2)(f(2)(1)) = 2 but f(2)(1) = 3;
* function f(f(f(x))) = f(3)(x) is idempotent since it is identity function: f(3)(x) = x for any <image> meaning that the formula f(3)(f(3)(x)) = f(3)(x) also holds. | instruction | 0 | 82,129 | 22 | 164,258 |
Tags: constructive algorithms, graphs, math
Correct Solution:
```
from random import randint
from copy import deepcopy
n = int(input())
a = list(map(int, input().split()))
for i in range(n):
a[i] -= 1
def gen(n):
a = []
for i in range(n):
a.append(randint(0, n - 1))
return a
def stupid(a, v=False):
n = len(a)
init = [a[i] for i in range(n)]
k = 1
good = False
while not good:
good = True
if v:
print(a)
for i in range(n):
if a[a[i]] != a[i]:
good = False
if good:
break
k += 1
b = [0 for i in range(n)]
for i in range(n):
b[i] = init[a[i]]
a = [b[i] for i in range(n)]
return k
def gcd(a, b):
while b:
a, b = b, a % b
return a
def get_lcm(a, b):
return a * b // gcd(a, b)
def solve(a, v=False):
n = len(a)
d = [0 for i in range(n)]
on_cycle = [False for i in range(n)]
cycle_length = [0 for i in range(n)]
until = [0 for i in range(n)]
to_len = [0 for i in range(n)]
for i in range(n):
if a[i] == i:
on_cycle[i] = True
cycle_length[i] = 1
continue
cur = i
cnt = 1
for j in range(3 * n):
cur = a[cur]
cnt += cur == i
on_cycle[i] = cnt > 1
if on_cycle[i]:
cur = i
steps = 0
for j in range(3 * n):
cur = a[cur]
steps += 1
if cur == i:
break
cycle_length[i] = steps
for i in range(n):
if not on_cycle[i]:
cur = i
steps = 0
for j in range(n + 1):
cur = a[cur]
steps += 1
if on_cycle[cur]:
break
until[i] = steps
to_len[i] = cycle_length[cur]
if v:
print('cycle', cycle_length)
print('until', until)
lcm = 1
low = 0
for i in range(n):
if on_cycle[i]:
lcm = get_lcm(lcm, cycle_length[i])
else:
low = max(low, until[i])
continue
to = to_len[i]
p = until[i]
if p % to:
p = ((p // to) + 1) * to
low = max(low, p)
if v:
print(i, p, to)
ans = lcm
while ans < low:
ans += lcm
return ans
print(solve(a))
while False:
a = gen(randint(1, 15))
print(a)
print(stupid(deepcopy(a)))
print(solve(deepcopy(a)))
assert(stupid(deepcopy(a)) == solve(deepcopy(a)))
``` | output | 1 | 82,129 | 22 | 164,259 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Some time ago Leonid have known about idempotent functions. Idempotent function defined on a set {1, 2, ..., n} is such function <image>, that for any <image> the formula g(g(x)) = g(x) holds.
Let's denote as f(k)(x) the function f applied k times to the value x. More formally, f(1)(x) = f(x), f(k)(x) = f(f(k - 1)(x)) for each k > 1.
You are given some function <image>. Your task is to find minimum positive integer k such that function f(k)(x) is idempotent.
Input
In the first line of the input there is a single integer n (1 ≤ n ≤ 200) — the size of function f domain.
In the second line follow f(1), f(2), ..., f(n) (1 ≤ f(i) ≤ n for each 1 ≤ i ≤ n), the values of a function.
Output
Output minimum k such that function f(k)(x) is idempotent.
Examples
Input
4
1 2 2 4
Output
1
Input
3
2 3 3
Output
2
Input
3
2 3 1
Output
3
Note
In the first sample test function f(x) = f(1)(x) is already idempotent since f(f(1)) = f(1) = 1, f(f(2)) = f(2) = 2, f(f(3)) = f(3) = 2, f(f(4)) = f(4) = 4.
In the second sample test:
* function f(x) = f(1)(x) isn't idempotent because f(f(1)) = 3 but f(1) = 2;
* function f(x) = f(2)(x) is idempotent since for any x it is true that f(2)(x) = 3, so it is also true that f(2)(f(2)(x)) = 3.
In the third sample test:
* function f(x) = f(1)(x) isn't idempotent because f(f(1)) = 3 but f(1) = 2;
* function f(f(x)) = f(2)(x) isn't idempotent because f(2)(f(2)(1)) = 2 but f(2)(1) = 3;
* function f(f(f(x))) = f(3)(x) is idempotent since it is identity function: f(3)(x) = x for any <image> meaning that the formula f(3)(f(3)(x)) = f(3)(x) also holds. | instruction | 0 | 82,130 | 22 | 164,260 |
Tags: constructive algorithms, graphs, math
Correct Solution:
```
n = int(input())
p = list(map(int, input().split()))
g = {}
deg = {}
first = []
circle = {}
ans = []
def push_d(deg, u, val):
if u not in deg:
deg[u] = 0
deg[u] += val
def push_g(g, u, v):
if u not in g:
g[u] = []
g[u].append(v)
def gcd(a, b):
if b == 0:
return a
return gcd(b, a%b)
def total(arr):
cur=1
for x in arr:
cur = cur // gcd(cur, x) * x
return cur
def process(g, deg, deg0, u):
if u in g:
for v in g[u]:
push_d(deg, v, -1)
if deg[v] == 0:
deg0.append(v)
def bfs(u):
S = [u]
used[u] = 1
circle[u] = 1
i = 0
while i < len(S):
u = S[i]
if u in g:
for v in g[u]:
if used[v] == 0:
used[v] = 1
circle[v] = 1
S.append(v)
i+=1
return len(S)
def bfs2(u):
S = [u]
start = 0
i = 0
while i < len(S):
u = S[i]
if u in g:
for v in g[u]:
if used[v] == -1:
S.append(v)
else:
start = used[v]
i+=1
for u in S[::-1]:
start += 1
used[u] = start
return start
for u, v in enumerate(p):
u+=1
push_d(deg, v, 1)
push_g(g, u, v)
deg0 = [x for x in range(1, n+1) if x not in deg]
first = [x for x in deg0]
used = [0 for x in range(n+1)]
while len(deg0) > 0:
u = deg0.pop()
used[u] = 1
process(g, deg, deg0, u)
cnt = []
for u in range(1, n+1):
if used[u] == 0:
cnt.append(bfs(u))
used = [-1 for x in range(n+1)]
for u in circle:
used[u] = 0
max_ = 0
for u in first:
max_ = max(max_, bfs2(u))
cur = total(cnt)
ans = cur
while ans<max_:
ans+=cur
print(ans)
``` | output | 1 | 82,130 | 22 | 164,261 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Some time ago Leonid have known about idempotent functions. Idempotent function defined on a set {1, 2, ..., n} is such function <image>, that for any <image> the formula g(g(x)) = g(x) holds.
Let's denote as f(k)(x) the function f applied k times to the value x. More formally, f(1)(x) = f(x), f(k)(x) = f(f(k - 1)(x)) for each k > 1.
You are given some function <image>. Your task is to find minimum positive integer k such that function f(k)(x) is idempotent.
Input
In the first line of the input there is a single integer n (1 ≤ n ≤ 200) — the size of function f domain.
In the second line follow f(1), f(2), ..., f(n) (1 ≤ f(i) ≤ n for each 1 ≤ i ≤ n), the values of a function.
Output
Output minimum k such that function f(k)(x) is idempotent.
Examples
Input
4
1 2 2 4
Output
1
Input
3
2 3 3
Output
2
Input
3
2 3 1
Output
3
Note
In the first sample test function f(x) = f(1)(x) is already idempotent since f(f(1)) = f(1) = 1, f(f(2)) = f(2) = 2, f(f(3)) = f(3) = 2, f(f(4)) = f(4) = 4.
In the second sample test:
* function f(x) = f(1)(x) isn't idempotent because f(f(1)) = 3 but f(1) = 2;
* function f(x) = f(2)(x) is idempotent since for any x it is true that f(2)(x) = 3, so it is also true that f(2)(f(2)(x)) = 3.
In the third sample test:
* function f(x) = f(1)(x) isn't idempotent because f(f(1)) = 3 but f(1) = 2;
* function f(f(x)) = f(2)(x) isn't idempotent because f(2)(f(2)(1)) = 2 but f(2)(1) = 3;
* function f(f(f(x))) = f(3)(x) is idempotent since it is identity function: f(3)(x) = x for any <image> meaning that the formula f(3)(f(3)(x)) = f(3)(x) also holds. | instruction | 0 | 82,131 | 22 | 164,262 |
Tags: constructive algorithms, graphs, math
Correct Solution:
```
import math
def ciclos(arr, i):
d = {i:0}
cnt = 1
while True:
i = arr[i]-1
if i in d:
return d[i],cnt-d[i]
d[i] = cnt
cnt+=1
def mcm(a,b):
return (a*b//math.gcd(a,b))
n = int(input())
a = [int(x) for x in input().split()]
max_offset = -float('inf')
act_mcm = 1
aux_max = -float('inf')
for i in range(n):
off, lon = ciclos(a,i)
aux = lon if (off==0) else lon*math.ceil(off/lon)
max_offset = max(max_offset,off)
aux_max = max(aux_max, aux)
act_mcm = mcm(act_mcm,lon)
print(act_mcm*math.ceil(aux_max/act_mcm))
``` | output | 1 | 82,131 | 22 | 164,263 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Some time ago Leonid have known about idempotent functions. Idempotent function defined on a set {1, 2, ..., n} is such function <image>, that for any <image> the formula g(g(x)) = g(x) holds.
Let's denote as f(k)(x) the function f applied k times to the value x. More formally, f(1)(x) = f(x), f(k)(x) = f(f(k - 1)(x)) for each k > 1.
You are given some function <image>. Your task is to find minimum positive integer k such that function f(k)(x) is idempotent.
Input
In the first line of the input there is a single integer n (1 ≤ n ≤ 200) — the size of function f domain.
In the second line follow f(1), f(2), ..., f(n) (1 ≤ f(i) ≤ n for each 1 ≤ i ≤ n), the values of a function.
Output
Output minimum k such that function f(k)(x) is idempotent.
Examples
Input
4
1 2 2 4
Output
1
Input
3
2 3 3
Output
2
Input
3
2 3 1
Output
3
Note
In the first sample test function f(x) = f(1)(x) is already idempotent since f(f(1)) = f(1) = 1, f(f(2)) = f(2) = 2, f(f(3)) = f(3) = 2, f(f(4)) = f(4) = 4.
In the second sample test:
* function f(x) = f(1)(x) isn't idempotent because f(f(1)) = 3 but f(1) = 2;
* function f(x) = f(2)(x) is idempotent since for any x it is true that f(2)(x) = 3, so it is also true that f(2)(f(2)(x)) = 3.
In the third sample test:
* function f(x) = f(1)(x) isn't idempotent because f(f(1)) = 3 but f(1) = 2;
* function f(f(x)) = f(2)(x) isn't idempotent because f(2)(f(2)(1)) = 2 but f(2)(1) = 3;
* function f(f(f(x))) = f(3)(x) is idempotent since it is identity function: f(3)(x) = x for any <image> meaning that the formula f(3)(f(3)(x)) = f(3)(x) also holds. | instruction | 0 | 82,132 | 22 | 164,264 |
Tags: constructive algorithms, graphs, math
Correct Solution:
```
import math
def ciclos(arr, i):
de = {i:0}
cnt = 1
while True:
i = arr[i]-1
if i in de:
return de[i],cnt-de[i]
de[i] = cnt
cnt+=1
def mcm(a,b):
return (a*b//math.gcd(a,b))
n = int(input())
a = [int(x) for x in input().split()]
max_offset = -float('inf')
act_mcm = 1
aux_max = -float('inf')
for i in range(n):
off, lon = ciclos(a,i)
aux = lon if (off==0) else lon*math.ceil(off/lon)
max_offset = max(max_offset,off)
aux_max = max(aux_max, aux)
act_mcm = mcm(act_mcm,lon)
print(act_mcm*math.ceil(aux_max/act_mcm))
``` | output | 1 | 82,132 | 22 | 164,265 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Some time ago Leonid have known about idempotent functions. Idempotent function defined on a set {1, 2, ..., n} is such function <image>, that for any <image> the formula g(g(x)) = g(x) holds.
Let's denote as f(k)(x) the function f applied k times to the value x. More formally, f(1)(x) = f(x), f(k)(x) = f(f(k - 1)(x)) for each k > 1.
You are given some function <image>. Your task is to find minimum positive integer k such that function f(k)(x) is idempotent.
Input
In the first line of the input there is a single integer n (1 ≤ n ≤ 200) — the size of function f domain.
In the second line follow f(1), f(2), ..., f(n) (1 ≤ f(i) ≤ n for each 1 ≤ i ≤ n), the values of a function.
Output
Output minimum k such that function f(k)(x) is idempotent.
Examples
Input
4
1 2 2 4
Output
1
Input
3
2 3 3
Output
2
Input
3
2 3 1
Output
3
Note
In the first sample test function f(x) = f(1)(x) is already idempotent since f(f(1)) = f(1) = 1, f(f(2)) = f(2) = 2, f(f(3)) = f(3) = 2, f(f(4)) = f(4) = 4.
In the second sample test:
* function f(x) = f(1)(x) isn't idempotent because f(f(1)) = 3 but f(1) = 2;
* function f(x) = f(2)(x) is idempotent since for any x it is true that f(2)(x) = 3, so it is also true that f(2)(f(2)(x)) = 3.
In the third sample test:
* function f(x) = f(1)(x) isn't idempotent because f(f(1)) = 3 but f(1) = 2;
* function f(f(x)) = f(2)(x) isn't idempotent because f(2)(f(2)(1)) = 2 but f(2)(1) = 3;
* function f(f(f(x))) = f(3)(x) is idempotent since it is identity function: f(3)(x) = x for any <image> meaning that the formula f(3)(f(3)(x)) = f(3)(x) also holds. | instruction | 0 | 82,133 | 22 | 164,266 |
Tags: constructive algorithms, graphs, math
Correct Solution:
```
def gcd(x, y):
if y == 0:
return x
return gcd(y, x % y)
n = int(input())
v = [(int(i) - 1) for i in input().split()]
b = [0] * n
r = 1
for i in range(n):
j, k = 1, v[i]
while j <= 2 * n + 10 and k != i:
k = v[k]
j += 1
if k == i:
r *= j // gcd(r, j)
b[i] = 1
z = 0
for i in range(n):
j, k = 0, i
while not b[k]:
k = v[k]
j += 1
z = max(z, j)
j = z
if j > r:
k = j // r
if j % r != 0:
k += 1
r *= k
print(r)
``` | output | 1 | 82,133 | 22 | 164,267 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Some time ago Leonid have known about idempotent functions. Idempotent function defined on a set {1, 2, ..., n} is such function <image>, that for any <image> the formula g(g(x)) = g(x) holds.
Let's denote as f(k)(x) the function f applied k times to the value x. More formally, f(1)(x) = f(x), f(k)(x) = f(f(k - 1)(x)) for each k > 1.
You are given some function <image>. Your task is to find minimum positive integer k such that function f(k)(x) is idempotent.
Input
In the first line of the input there is a single integer n (1 ≤ n ≤ 200) — the size of function f domain.
In the second line follow f(1), f(2), ..., f(n) (1 ≤ f(i) ≤ n for each 1 ≤ i ≤ n), the values of a function.
Output
Output minimum k such that function f(k)(x) is idempotent.
Examples
Input
4
1 2 2 4
Output
1
Input
3
2 3 3
Output
2
Input
3
2 3 1
Output
3
Note
In the first sample test function f(x) = f(1)(x) is already idempotent since f(f(1)) = f(1) = 1, f(f(2)) = f(2) = 2, f(f(3)) = f(3) = 2, f(f(4)) = f(4) = 4.
In the second sample test:
* function f(x) = f(1)(x) isn't idempotent because f(f(1)) = 3 but f(1) = 2;
* function f(x) = f(2)(x) is idempotent since for any x it is true that f(2)(x) = 3, so it is also true that f(2)(f(2)(x)) = 3.
In the third sample test:
* function f(x) = f(1)(x) isn't idempotent because f(f(1)) = 3 but f(1) = 2;
* function f(f(x)) = f(2)(x) isn't idempotent because f(2)(f(2)(1)) = 2 but f(2)(1) = 3;
* function f(f(f(x))) = f(3)(x) is idempotent since it is identity function: f(3)(x) = x for any <image> meaning that the formula f(3)(f(3)(x)) = f(3)(x) also holds. | instruction | 0 | 82,134 | 22 | 164,268 |
Tags: constructive algorithms, graphs, math
Correct Solution:
```
import sys
import fractions
n = int(input())
refs = [0] * n
used = [0] * n
to = [int(x)-1 for x in input().split(' ')]
for i in to:
refs[i] += 1
times = []
max_a = 0
depth = [-1] * n
def dfs(u, d, depth):
if depth[u] != -1:
loop = d - depth[u]
times.append(loop)
global max_a
if max_a < depth[u]:
max_a = depth[u]
return
used[u] = True
depth[u] = d
return dfs(to[u], d+1, depth)
for i in range(n):
if refs[i] == 0:
depth = [-1] * n
b = dfs(i, 0, depth)
for i in range(n):
if not used[i]:
depth = [-1] * n
b = dfs(i, 0, depth)
lcm = 1
for t in times:
lcm = lcm * t // fractions.gcd(lcm, t)
ans = lcm
while ans < max_a:
ans += lcm
print(ans)
``` | output | 1 | 82,134 | 22 | 164,269 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Some time ago Leonid have known about idempotent functions. Idempotent function defined on a set {1, 2, ..., n} is such function <image>, that for any <image> the formula g(g(x)) = g(x) holds.
Let's denote as f(k)(x) the function f applied k times to the value x. More formally, f(1)(x) = f(x), f(k)(x) = f(f(k - 1)(x)) for each k > 1.
You are given some function <image>. Your task is to find minimum positive integer k such that function f(k)(x) is idempotent.
Input
In the first line of the input there is a single integer n (1 ≤ n ≤ 200) — the size of function f domain.
In the second line follow f(1), f(2), ..., f(n) (1 ≤ f(i) ≤ n for each 1 ≤ i ≤ n), the values of a function.
Output
Output minimum k such that function f(k)(x) is idempotent.
Examples
Input
4
1 2 2 4
Output
1
Input
3
2 3 3
Output
2
Input
3
2 3 1
Output
3
Note
In the first sample test function f(x) = f(1)(x) is already idempotent since f(f(1)) = f(1) = 1, f(f(2)) = f(2) = 2, f(f(3)) = f(3) = 2, f(f(4)) = f(4) = 4.
In the second sample test:
* function f(x) = f(1)(x) isn't idempotent because f(f(1)) = 3 but f(1) = 2;
* function f(x) = f(2)(x) is idempotent since for any x it is true that f(2)(x) = 3, so it is also true that f(2)(f(2)(x)) = 3.
In the third sample test:
* function f(x) = f(1)(x) isn't idempotent because f(f(1)) = 3 but f(1) = 2;
* function f(f(x)) = f(2)(x) isn't idempotent because f(2)(f(2)(1)) = 2 but f(2)(1) = 3;
* function f(f(f(x))) = f(3)(x) is idempotent since it is identity function: f(3)(x) = x for any <image> meaning that the formula f(3)(f(3)(x)) = f(3)(x) also holds. | instruction | 0 | 82,135 | 22 | 164,270 |
Tags: constructive algorithms, graphs, math
Correct Solution:
```
from math import *
from random import *
from copy import *
import os
import sys
import fractions
n = int(input())
A = [0] + list(map(int, input().split()))
X, Y = 0, 1
for i in range(1, n + 1):
cnt = [-1] * (n + 1)
now = i
x = 0
while cnt[now] == -1:
cnt[now] = x
now = A[now]
x += 1
y = x - cnt[now]
x -= y
X = max(X, x)
Y = Y * y // fractions.gcd(Y, y)
print(max(Y, (X + Y - 1) // Y * Y))
``` | output | 1 | 82,135 | 22 | 164,271 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Some time ago Leonid have known about idempotent functions. Idempotent function defined on a set {1, 2, ..., n} is such function <image>, that for any <image> the formula g(g(x)) = g(x) holds.
Let's denote as f(k)(x) the function f applied k times to the value x. More formally, f(1)(x) = f(x), f(k)(x) = f(f(k - 1)(x)) for each k > 1.
You are given some function <image>. Your task is to find minimum positive integer k such that function f(k)(x) is idempotent.
Input
In the first line of the input there is a single integer n (1 ≤ n ≤ 200) — the size of function f domain.
In the second line follow f(1), f(2), ..., f(n) (1 ≤ f(i) ≤ n for each 1 ≤ i ≤ n), the values of a function.
Output
Output minimum k such that function f(k)(x) is idempotent.
Examples
Input
4
1 2 2 4
Output
1
Input
3
2 3 3
Output
2
Input
3
2 3 1
Output
3
Note
In the first sample test function f(x) = f(1)(x) is already idempotent since f(f(1)) = f(1) = 1, f(f(2)) = f(2) = 2, f(f(3)) = f(3) = 2, f(f(4)) = f(4) = 4.
In the second sample test:
* function f(x) = f(1)(x) isn't idempotent because f(f(1)) = 3 but f(1) = 2;
* function f(x) = f(2)(x) is idempotent since for any x it is true that f(2)(x) = 3, so it is also true that f(2)(f(2)(x)) = 3.
In the third sample test:
* function f(x) = f(1)(x) isn't idempotent because f(f(1)) = 3 but f(1) = 2;
* function f(f(x)) = f(2)(x) isn't idempotent because f(2)(f(2)(1)) = 2 but f(2)(1) = 3;
* function f(f(f(x))) = f(3)(x) is idempotent since it is identity function: f(3)(x) = x for any <image> meaning that the formula f(3)(f(3)(x)) = f(3)(x) also holds. | instruction | 0 | 82,136 | 22 | 164,272 |
Tags: constructive algorithms, graphs, math
Correct Solution:
```
n = int(input())
f = list(map(int, input().split()))
def proov(res):
for i in range(len(f)):
if res[i] != res[res[i]]:
return False
return True
for i in range(len(f)):
f[i] -= 1
def gcd(a, b):
while b != 0:
a, b = b, a % b
return a
used = [0] * n
depth = [0] * n
on_circle = [False] * n
def dfs(s, d):
ans = (0, float("inf"))
used[s] = 1
depth[s] = d + 1
if used[f[s]] == 1:
used[s] = 2
ans = (depth[s] - depth[f[s]] + 1, depth[f[s]])
if not used[f[s]]:
ans = dfs(f[s], d + 1)
if (ans[1] <= depth[s]):
on_circle[s] = True
used[s] = 2
return ans
res = list(range(n))
i = 0
circles = []
nok = 1
for i in range(n):
if not used[i]:
a = dfs(i, 0)
if(a[0] != 0):
circles.append(a[0])
for i in range(len(circles)):
nok = (nok * circles[i]) // gcd(nok, circles[i])
i = 0
while(True):
res = [f[res[j]] for j in range(n)]
#print(res)
i += 1
flag = True
for j in range(n):
flag = flag and on_circle[res[j]]
if(flag):
print(max(nok, (i + nok - 1) // nok * nok))
break
if proov(res):
print(i)
break
``` | output | 1 | 82,136 | 22 | 164,273 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Johnny has recently learned about set theory. Now he is studying binary relations. You've probably heard the term "equivalence relation". These relations are very important in many areas of mathematics. For example, the equality of the two numbers is an equivalence relation.
A set ρ of pairs (a, b) of elements of some set A is called a binary relation on set A. For two elements a and b of the set A we say that they are in relation ρ, if pair <image>, in this case we use a notation <image>.
Binary relation is equivalence relation, if:
1. It is reflexive (for any a it is true that <image>);
2. It is symmetric (for any a, b it is true that if <image>, then <image>);
3. It is transitive (if <image> and <image>, than <image>).
Little Johnny is not completely a fool and he noticed that the first condition is not necessary! Here is his "proof":
Take any two elements, a and b. If <image>, then <image> (according to property (2)), which means <image> (according to property (3)).
It's very simple, isn't it? However, you noticed that Johnny's "proof" is wrong, and decided to show him a lot of examples that prove him wrong.
Here's your task: count the number of binary relations over a set of size n such that they are symmetric, transitive, but not an equivalence relations (i.e. they are not reflexive).
Since their number may be very large (not 0, according to Little Johnny), print the remainder of integer division of this number by 109 + 7.
Input
A single line contains a single integer n (1 ≤ n ≤ 4000).
Output
In a single line print the answer to the problem modulo 109 + 7.
Examples
Input
1
Output
1
Input
2
Output
3
Input
3
Output
10
Note
If n = 1 there is only one such relation — an empty one, i.e. <image>. In other words, for a single element x of set A the following is hold: <image>.
If n = 2 there are three such relations. Let's assume that set A consists of two elements, x and y. Then the valid relations are <image>, ρ = {(x, x)}, ρ = {(y, y)}. It is easy to see that the three listed binary relations are symmetric and transitive relations, but they are not equivalence relations. | instruction | 0 | 82,145 | 22 | 164,290 |
Tags: combinatorics, dp, math
Correct Solution:
```
def main():
mod = 10 ** 9 + 7
n = int(input())
a = [[0] * (n + 1) for i in range(n + 1)]
a[0][0] = 1
for i in range(1, n + 1):
a[i][0] = a[i - 1][i - 1]
for j in range(1, i + 1):
a[i][j] = (a[i][j - 1] + a[i - 1][j - 1]) % mod
print(a[n][n - 1])
main()
``` | output | 1 | 82,145 | 22 | 164,291 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The following problem is well-known: given integers n and m, calculate
<image>,
where 2n = 2·2·...·2 (n factors), and <image> denotes the remainder of division of x by y.
You are asked to solve the "reverse" problem. Given integers n and m, calculate
<image>.
Input
The first line contains a single integer n (1 ≤ n ≤ 108).
The second line contains a single integer m (1 ≤ m ≤ 108).
Output
Output a single integer — the value of <image>.
Examples
Input
4
42
Output
10
Input
1
58
Output
0
Input
98765432
23456789
Output
23456789
Note
In the first example, the remainder of division of 42 by 24 = 16 is equal to 10.
In the second example, 58 is divisible by 21 = 2 without remainder, and the answer is 0. | instruction | 0 | 82,299 | 22 | 164,598 |
Tags: implementation, math
Correct Solution:
```
import math
n = int(input())
m = int(input())
if n <= 32 :
print(int(m%math.pow(2,n)))
else :
print(m)
``` | output | 1 | 82,299 | 22 | 164,599 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The following problem is well-known: given integers n and m, calculate
<image>,
where 2n = 2·2·...·2 (n factors), and <image> denotes the remainder of division of x by y.
You are asked to solve the "reverse" problem. Given integers n and m, calculate
<image>.
Input
The first line contains a single integer n (1 ≤ n ≤ 108).
The second line contains a single integer m (1 ≤ m ≤ 108).
Output
Output a single integer — the value of <image>.
Examples
Input
4
42
Output
10
Input
1
58
Output
0
Input
98765432
23456789
Output
23456789
Note
In the first example, the remainder of division of 42 by 24 = 16 is equal to 10.
In the second example, 58 is divisible by 21 = 2 without remainder, and the answer is 0. | instruction | 0 | 82,300 | 22 | 164,600 |
Tags: implementation, math
Correct Solution:
```
n=int(input())
print(int(input())%(2**min(n,40)))
``` | output | 1 | 82,300 | 22 | 164,601 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The following problem is well-known: given integers n and m, calculate
<image>,
where 2n = 2·2·...·2 (n factors), and <image> denotes the remainder of division of x by y.
You are asked to solve the "reverse" problem. Given integers n and m, calculate
<image>.
Input
The first line contains a single integer n (1 ≤ n ≤ 108).
The second line contains a single integer m (1 ≤ m ≤ 108).
Output
Output a single integer — the value of <image>.
Examples
Input
4
42
Output
10
Input
1
58
Output
0
Input
98765432
23456789
Output
23456789
Note
In the first example, the remainder of division of 42 by 24 = 16 is equal to 10.
In the second example, 58 is divisible by 21 = 2 without remainder, and the answer is 0. | instruction | 0 | 82,301 | 22 | 164,602 |
Tags: implementation, math
Correct Solution:
```
a = int(input())
b = int(input())
if a >= 32:
print(b)
else:
print(b % (2 ** a))
``` | output | 1 | 82,301 | 22 | 164,603 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The following problem is well-known: given integers n and m, calculate
<image>,
where 2n = 2·2·...·2 (n factors), and <image> denotes the remainder of division of x by y.
You are asked to solve the "reverse" problem. Given integers n and m, calculate
<image>.
Input
The first line contains a single integer n (1 ≤ n ≤ 108).
The second line contains a single integer m (1 ≤ m ≤ 108).
Output
Output a single integer — the value of <image>.
Examples
Input
4
42
Output
10
Input
1
58
Output
0
Input
98765432
23456789
Output
23456789
Note
In the first example, the remainder of division of 42 by 24 = 16 is equal to 10.
In the second example, 58 is divisible by 21 = 2 without remainder, and the answer is 0. | instruction | 0 | 82,302 | 22 | 164,604 |
Tags: implementation, math
Correct Solution:
```
import sys
def main():
input = sys.stdin.readline
n = int(input())
m = int(input())
print(m % (1 << n))
main()
``` | output | 1 | 82,302 | 22 | 164,605 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The following problem is well-known: given integers n and m, calculate
<image>,
where 2n = 2·2·...·2 (n factors), and <image> denotes the remainder of division of x by y.
You are asked to solve the "reverse" problem. Given integers n and m, calculate
<image>.
Input
The first line contains a single integer n (1 ≤ n ≤ 108).
The second line contains a single integer m (1 ≤ m ≤ 108).
Output
Output a single integer — the value of <image>.
Examples
Input
4
42
Output
10
Input
1
58
Output
0
Input
98765432
23456789
Output
23456789
Note
In the first example, the remainder of division of 42 by 24 = 16 is equal to 10.
In the second example, 58 is divisible by 21 = 2 without remainder, and the answer is 0. | instruction | 0 | 82,303 | 22 | 164,606 |
Tags: implementation, math
Correct Solution:
```
import math
n=int(input())
m=int(input())
if n>=27 :
print(m)
else :
print(m%(pow(2,n)))
``` | output | 1 | 82,303 | 22 | 164,607 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The following problem is well-known: given integers n and m, calculate
<image>,
where 2n = 2·2·...·2 (n factors), and <image> denotes the remainder of division of x by y.
You are asked to solve the "reverse" problem. Given integers n and m, calculate
<image>.
Input
The first line contains a single integer n (1 ≤ n ≤ 108).
The second line contains a single integer m (1 ≤ m ≤ 108).
Output
Output a single integer — the value of <image>.
Examples
Input
4
42
Output
10
Input
1
58
Output
0
Input
98765432
23456789
Output
23456789
Note
In the first example, the remainder of division of 42 by 24 = 16 is equal to 10.
In the second example, 58 is divisible by 21 = 2 without remainder, and the answer is 0. | instruction | 0 | 82,304 | 22 | 164,608 |
Tags: implementation, math
Correct Solution:
```
n = int(input())
m = int(input())
if n > 300:
print(m)
else:
x = m % 2**n
print(x)
``` | output | 1 | 82,304 | 22 | 164,609 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The following problem is well-known: given integers n and m, calculate
<image>,
where 2n = 2·2·...·2 (n factors), and <image> denotes the remainder of division of x by y.
You are asked to solve the "reverse" problem. Given integers n and m, calculate
<image>.
Input
The first line contains a single integer n (1 ≤ n ≤ 108).
The second line contains a single integer m (1 ≤ m ≤ 108).
Output
Output a single integer — the value of <image>.
Examples
Input
4
42
Output
10
Input
1
58
Output
0
Input
98765432
23456789
Output
23456789
Note
In the first example, the remainder of division of 42 by 24 = 16 is equal to 10.
In the second example, 58 is divisible by 21 = 2 without remainder, and the answer is 0. | instruction | 0 | 82,305 | 22 | 164,610 |
Tags: implementation, math
Correct Solution:
```
# Modular Expo
import sys
import math
import collections
from pprint import pprint as pp
mod = 1000000007
MAX = 10**10
def vector(size, val=0):
vec = [val for i in range(size)]
return vec
def matrix(rowNum, colNum, val=0):
mat = []
for i in range(rowNum):
collumn = [val for j in range(colNum)]
mat.append(collumn)
return mat
n, m = int(input()), int(input())
ans = 1
while n > 0 and ans <= m:
ans *= 2
n -= 1
print(m % ans)
``` | output | 1 | 82,305 | 22 | 164,611 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The following problem is well-known: given integers n and m, calculate
<image>,
where 2n = 2·2·...·2 (n factors), and <image> denotes the remainder of division of x by y.
You are asked to solve the "reverse" problem. Given integers n and m, calculate
<image>.
Input
The first line contains a single integer n (1 ≤ n ≤ 108).
The second line contains a single integer m (1 ≤ m ≤ 108).
Output
Output a single integer — the value of <image>.
Examples
Input
4
42
Output
10
Input
1
58
Output
0
Input
98765432
23456789
Output
23456789
Note
In the first example, the remainder of division of 42 by 24 = 16 is equal to 10.
In the second example, 58 is divisible by 21 = 2 without remainder, and the answer is 0. | instruction | 0 | 82,306 | 22 | 164,612 |
Tags: implementation, math
Correct Solution:
```
x = int(input())
y = int(input())
if x < 27:
print(y % (2 ** x))
else:
print(y)
``` | output | 1 | 82,306 | 22 | 164,613 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The following problem is well-known: given integers n and m, calculate
<image>,
where 2n = 2·2·...·2 (n factors), and <image> denotes the remainder of division of x by y.
You are asked to solve the "reverse" problem. Given integers n and m, calculate
<image>.
Input
The first line contains a single integer n (1 ≤ n ≤ 108).
The second line contains a single integer m (1 ≤ m ≤ 108).
Output
Output a single integer — the value of <image>.
Examples
Input
4
42
Output
10
Input
1
58
Output
0
Input
98765432
23456789
Output
23456789
Note
In the first example, the remainder of division of 42 by 24 = 16 is equal to 10.
In the second example, 58 is divisible by 21 = 2 without remainder, and the answer is 0.
Submitted Solution:
```
# input
n = int(input())
m = int(input())
def solve():
if n >= 30:
print(m)
else:
print(m%2**n)
if __name__ == "__main__":
solve()
``` | instruction | 0 | 82,307 | 22 | 164,614 |
Yes | output | 1 | 82,307 | 22 | 164,615 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The following problem is well-known: given integers n and m, calculate
<image>,
where 2n = 2·2·...·2 (n factors), and <image> denotes the remainder of division of x by y.
You are asked to solve the "reverse" problem. Given integers n and m, calculate
<image>.
Input
The first line contains a single integer n (1 ≤ n ≤ 108).
The second line contains a single integer m (1 ≤ m ≤ 108).
Output
Output a single integer — the value of <image>.
Examples
Input
4
42
Output
10
Input
1
58
Output
0
Input
98765432
23456789
Output
23456789
Note
In the first example, the remainder of division of 42 by 24 = 16 is equal to 10.
In the second example, 58 is divisible by 21 = 2 without remainder, and the answer is 0.
Submitted Solution:
```
# MZ
# Feb2, 2018
# 913a
def main():
n = int(input())
m = int(input())
if n >= 27:
res = m
else:
res = m % 2**n
print(res)
if __name__ == '__main__':
main()
``` | instruction | 0 | 82,308 | 22 | 164,616 |
Yes | output | 1 | 82,308 | 22 | 164,617 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The following problem is well-known: given integers n and m, calculate
<image>,
where 2n = 2·2·...·2 (n factors), and <image> denotes the remainder of division of x by y.
You are asked to solve the "reverse" problem. Given integers n and m, calculate
<image>.
Input
The first line contains a single integer n (1 ≤ n ≤ 108).
The second line contains a single integer m (1 ≤ m ≤ 108).
Output
Output a single integer — the value of <image>.
Examples
Input
4
42
Output
10
Input
1
58
Output
0
Input
98765432
23456789
Output
23456789
Note
In the first example, the remainder of division of 42 by 24 = 16 is equal to 10.
In the second example, 58 is divisible by 21 = 2 without remainder, and the answer is 0.
Submitted Solution:
```
from math import log2
n=int(input())
m=int(input())
if log2(m)<n:
print(m)
else:
print(m%(2**n))
``` | instruction | 0 | 82,309 | 22 | 164,618 |
Yes | output | 1 | 82,309 | 22 | 164,619 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The following problem is well-known: given integers n and m, calculate
<image>,
where 2n = 2·2·...·2 (n factors), and <image> denotes the remainder of division of x by y.
You are asked to solve the "reverse" problem. Given integers n and m, calculate
<image>.
Input
The first line contains a single integer n (1 ≤ n ≤ 108).
The second line contains a single integer m (1 ≤ m ≤ 108).
Output
Output a single integer — the value of <image>.
Examples
Input
4
42
Output
10
Input
1
58
Output
0
Input
98765432
23456789
Output
23456789
Note
In the first example, the remainder of division of 42 by 24 = 16 is equal to 10.
In the second example, 58 is divisible by 21 = 2 without remainder, and the answer is 0.
Submitted Solution:
```
f=lambda:map(int,input().split())
n=int(input())
m=int(input())
print(m%(2**n) if n<=26 else m)
``` | instruction | 0 | 82,310 | 22 | 164,620 |
Yes | output | 1 | 82,310 | 22 | 164,621 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The following problem is well-known: given integers n and m, calculate
<image>,
where 2n = 2·2·...·2 (n factors), and <image> denotes the remainder of division of x by y.
You are asked to solve the "reverse" problem. Given integers n and m, calculate
<image>.
Input
The first line contains a single integer n (1 ≤ n ≤ 108).
The second line contains a single integer m (1 ≤ m ≤ 108).
Output
Output a single integer — the value of <image>.
Examples
Input
4
42
Output
10
Input
1
58
Output
0
Input
98765432
23456789
Output
23456789
Note
In the first example, the remainder of division of 42 by 24 = 16 is equal to 10.
In the second example, 58 is divisible by 21 = 2 without remainder, and the answer is 0.
Submitted Solution:
```
import math
n = int(input())
m = int(input())
if math.log(m, 2)>n:
print(m%2**n)
else:
print(m)
``` | instruction | 0 | 82,311 | 22 | 164,622 |
No | output | 1 | 82,311 | 22 | 164,623 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The following problem is well-known: given integers n and m, calculate
<image>,
where 2n = 2·2·...·2 (n factors), and <image> denotes the remainder of division of x by y.
You are asked to solve the "reverse" problem. Given integers n and m, calculate
<image>.
Input
The first line contains a single integer n (1 ≤ n ≤ 108).
The second line contains a single integer m (1 ≤ m ≤ 108).
Output
Output a single integer — the value of <image>.
Examples
Input
4
42
Output
10
Input
1
58
Output
0
Input
98765432
23456789
Output
23456789
Note
In the first example, the remainder of division of 42 by 24 = 16 is equal to 10.
In the second example, 58 is divisible by 21 = 2 without remainder, and the answer is 0.
Submitted Solution:
```
n = int(input())
m = int(input())
if n != 1:
n = 2 << n
print(m % n)
``` | instruction | 0 | 82,312 | 22 | 164,624 |
No | output | 1 | 82,312 | 22 | 164,625 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The following problem is well-known: given integers n and m, calculate
<image>,
where 2n = 2·2·...·2 (n factors), and <image> denotes the remainder of division of x by y.
You are asked to solve the "reverse" problem. Given integers n and m, calculate
<image>.
Input
The first line contains a single integer n (1 ≤ n ≤ 108).
The second line contains a single integer m (1 ≤ m ≤ 108).
Output
Output a single integer — the value of <image>.
Examples
Input
4
42
Output
10
Input
1
58
Output
0
Input
98765432
23456789
Output
23456789
Note
In the first example, the remainder of division of 42 by 24 = 16 is equal to 10.
In the second example, 58 is divisible by 21 = 2 without remainder, and the answer is 0.
Submitted Solution:
```
n = int(input())
m = int(input())
p = 1
while (p < m and n > 0):
p *= 2
n -= 1
print(m % p)
``` | instruction | 0 | 82,313 | 22 | 164,626 |
No | output | 1 | 82,313 | 22 | 164,627 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The following problem is well-known: given integers n and m, calculate
<image>,
where 2n = 2·2·...·2 (n factors), and <image> denotes the remainder of division of x by y.
You are asked to solve the "reverse" problem. Given integers n and m, calculate
<image>.
Input
The first line contains a single integer n (1 ≤ n ≤ 108).
The second line contains a single integer m (1 ≤ m ≤ 108).
Output
Output a single integer — the value of <image>.
Examples
Input
4
42
Output
10
Input
1
58
Output
0
Input
98765432
23456789
Output
23456789
Note
In the first example, the remainder of division of 42 by 24 = 16 is equal to 10.
In the second example, 58 is divisible by 21 = 2 without remainder, and the answer is 0.
Submitted Solution:
```
get = lambda: int(input())
print(get()&((1<<min(64, get()))-1))
``` | instruction | 0 | 82,314 | 22 | 164,628 |
No | output | 1 | 82,314 | 22 | 164,629 |
Provide a correct Python 3 solution for this coding contest problem.
You are given four integers A, B, C, and D. Find the number of integers between A and B (inclusive) that can be evenly divided by neither C nor D.
Constraints
* 1\leq A\leq B\leq 10^{18}
* 1\leq C,D\leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
A B C D
Output
Print the number of integers between A and B (inclusive) that can be evenly divided by neither C nor D.
Examples
Input
4 9 2 3
Output
2
Input
10 40 6 8
Output
23
Input
314159265358979323 846264338327950288 419716939 937510582
Output
532105071133627368 | instruction | 0 | 82,395 | 22 | 164,790 |
"Correct Solution:
```
a,b,c,d = map(int,input().split())
import fractions
a = a-1
e = c*d // fractions.gcd(c,d)
cnt = b//c + b//d + a//e - a//c - a//d - b//e
print(b-a-cnt)
``` | output | 1 | 82,395 | 22 | 164,791 |
Provide a correct Python 3 solution for this coding contest problem.
You are given four integers A, B, C, and D. Find the number of integers between A and B (inclusive) that can be evenly divided by neither C nor D.
Constraints
* 1\leq A\leq B\leq 10^{18}
* 1\leq C,D\leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
A B C D
Output
Print the number of integers between A and B (inclusive) that can be evenly divided by neither C nor D.
Examples
Input
4 9 2 3
Output
2
Input
10 40 6 8
Output
23
Input
314159265358979323 846264338327950288 419716939 937510582
Output
532105071133627368 | instruction | 0 | 82,396 | 22 | 164,792 |
"Correct Solution:
```
import fractions
a, b, c, d=map(int, input().split())
k=fractions.gcd(c, d)
lcm=c*d//k
x=b//c - (a-1)//c
y=b//d - (a-1)//d
z=b//lcm - (a-1)//lcm
print(b-a+1-(x+y-z))
``` | output | 1 | 82,396 | 22 | 164,793 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.