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.
Alexander is a well-known programmer. Today he decided to finally go out and play football, but with the first hit he left a dent on the new Rolls-Royce of the wealthy businessman Big Vova. Vladimir has recently opened a store on the popular online marketplace "Zmey-Gorynych", and offers Alex a job: if he shows his programming skills by solving a task, he'll work as a cybersecurity specialist. Otherwise, he'll be delivering some doubtful products for the next two years.
You're given n positive integers a_1, a_2, ..., a_n. Using each of them exactly at once, you're to make such sequence b_1, b_2, ..., b_n that sequence c_1, c_2, ..., c_n is lexicographically maximal, where c_i=GCD(b_1,...,b_i) - the greatest common divisor of the first i elements of b.
Alexander is really afraid of the conditions of this simple task, so he asks you to solve it.
A sequence a is lexicographically smaller than a sequence b if and only if one of the following holds:
* a is a prefix of b, but a ≠ b;
* in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3) — the length of the sequence a.
The second line of each test case contains n integers a_1,...,a_n (1 ≤ a_i ≤ 10^3) — the sequence a.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case output the answer in a single line — the desired sequence b. If there are multiple answers, print any.
Example
Input
7
2
2 5
4
1 8 2 3
3
3 8 9
5
64 25 75 100 50
1
42
6
96 128 88 80 52 7
5
2 4 8 16 17
Output
5 2
8 2 1 3
9 3 8
100 50 25 75 64
42
128 96 80 88 52 7
17 2 4 8 16
Note
In the first test case of the example, there are only two possible permutations b — [2, 5] and [5, 2]: for the first one c=[2, 1], for the second one c=[5, 1].
In the third test case of the example, number 9 should be the first in b, and GCD(9, 3)=3, GCD(9, 8)=1, so the second number of b should be 3.
In the seventh test case of the example, first four numbers pairwise have a common divisor (a power of two), but none of them can be the first in the optimal permutation b. | instruction | 0 | 98,827 | 22 | 197,654 |
Tags: brute force, greedy, math, number theory
Correct Solution:
```
def bigVova(arr):
res = [None for _ in arr]
visited = [False for _ in arr]
d = 0
for i in range(len(arr)):
maxItem = 0
index = 0
for j in range(len(arr)):
currGcd = gcd(d, arr[j])
if visited[j] == False and currGcd > maxItem:
maxItem = currGcd
index = j
d = maxItem
res[i] = arr[index]
visited[index] = True
return res
def gcd(a, b):
while b > 0:
rem = a % b
a = b
b = rem
return a
for i in range(int(input())):
N = int(input())
arr = [int(val) for val in input().split(" ")]
print(" ".join(str(x) for x in bigVova(arr)))
``` | output | 1 | 98,827 | 22 | 197,655 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alexander is a well-known programmer. Today he decided to finally go out and play football, but with the first hit he left a dent on the new Rolls-Royce of the wealthy businessman Big Vova. Vladimir has recently opened a store on the popular online marketplace "Zmey-Gorynych", and offers Alex a job: if he shows his programming skills by solving a task, he'll work as a cybersecurity specialist. Otherwise, he'll be delivering some doubtful products for the next two years.
You're given n positive integers a_1, a_2, ..., a_n. Using each of them exactly at once, you're to make such sequence b_1, b_2, ..., b_n that sequence c_1, c_2, ..., c_n is lexicographically maximal, where c_i=GCD(b_1,...,b_i) - the greatest common divisor of the first i elements of b.
Alexander is really afraid of the conditions of this simple task, so he asks you to solve it.
A sequence a is lexicographically smaller than a sequence b if and only if one of the following holds:
* a is a prefix of b, but a ≠ b;
* in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3) — the length of the sequence a.
The second line of each test case contains n integers a_1,...,a_n (1 ≤ a_i ≤ 10^3) — the sequence a.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case output the answer in a single line — the desired sequence b. If there are multiple answers, print any.
Example
Input
7
2
2 5
4
1 8 2 3
3
3 8 9
5
64 25 75 100 50
1
42
6
96 128 88 80 52 7
5
2 4 8 16 17
Output
5 2
8 2 1 3
9 3 8
100 50 25 75 64
42
128 96 80 88 52 7
17 2 4 8 16
Note
In the first test case of the example, there are only two possible permutations b — [2, 5] and [5, 2]: for the first one c=[2, 1], for the second one c=[5, 1].
In the third test case of the example, number 9 should be the first in b, and GCD(9, 3)=3, GCD(9, 8)=1, so the second number of b should be 3.
In the seventh test case of the example, first four numbers pairwise have a common divisor (a power of two), but none of them can be the first in the optimal permutation b. | instruction | 0 | 98,828 | 22 | 197,656 |
Tags: brute force, greedy, math, number theory
Correct Solution:
```
from math import gcd
t = int(input())
for _ in range(t):
n = int(input())
arr = list(map(int,input().strip().split()))[:n]
#arr = sorted(arr,reverse=True)
maxi_index = None
maxi = -float('inf')
for i in range(n):
if arr[i] > maxi:
maxi = arr[i]
maxi_index = i
(arr[0],arr[maxi_index]) = (arr[maxi_index],arr[0])
curr_gcd = arr[0]
for i in range(n-1):
max_gcd = 0
max_index = None
for j in range(i+1,n):
index_gcd = gcd(curr_gcd,arr[j])
#print(index_gcd,'index gcd deb')
if index_gcd > max_gcd:
max_index = j
max_gcd = index_gcd
#print(max_gcd,'max gcd deb')
curr_gcd = max_gcd
(arr[i+1],arr[max_index]) = (arr[max_index],arr[i+1])
for i in arr:
print(i,end=' ')
print()
``` | output | 1 | 98,828 | 22 | 197,657 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alexander is a well-known programmer. Today he decided to finally go out and play football, but with the first hit he left a dent on the new Rolls-Royce of the wealthy businessman Big Vova. Vladimir has recently opened a store on the popular online marketplace "Zmey-Gorynych", and offers Alex a job: if he shows his programming skills by solving a task, he'll work as a cybersecurity specialist. Otherwise, he'll be delivering some doubtful products for the next two years.
You're given n positive integers a_1, a_2, ..., a_n. Using each of them exactly at once, you're to make such sequence b_1, b_2, ..., b_n that sequence c_1, c_2, ..., c_n is lexicographically maximal, where c_i=GCD(b_1,...,b_i) - the greatest common divisor of the first i elements of b.
Alexander is really afraid of the conditions of this simple task, so he asks you to solve it.
A sequence a is lexicographically smaller than a sequence b if and only if one of the following holds:
* a is a prefix of b, but a ≠ b;
* in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3) — the length of the sequence a.
The second line of each test case contains n integers a_1,...,a_n (1 ≤ a_i ≤ 10^3) — the sequence a.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case output the answer in a single line — the desired sequence b. If there are multiple answers, print any.
Example
Input
7
2
2 5
4
1 8 2 3
3
3 8 9
5
64 25 75 100 50
1
42
6
96 128 88 80 52 7
5
2 4 8 16 17
Output
5 2
8 2 1 3
9 3 8
100 50 25 75 64
42
128 96 80 88 52 7
17 2 4 8 16
Note
In the first test case of the example, there are only two possible permutations b — [2, 5] and [5, 2]: for the first one c=[2, 1], for the second one c=[5, 1].
In the third test case of the example, number 9 should be the first in b, and GCD(9, 3)=3, GCD(9, 8)=1, so the second number of b should be 3.
In the seventh test case of the example, first four numbers pairwise have a common divisor (a power of two), but none of them can be the first in the optimal permutation b. | instruction | 0 | 98,829 | 22 | 197,658 |
Tags: brute force, greedy, math, number theory
Correct Solution:
```
def gcd(a,b):
# Everything divides 0
if (b == 0):
return a
return gcd(b, a%b)
for _ in range(int(input())):
n=int(input())
arr=list(map(int,input().split()))
x=max(arr)
b=[x]
arr.remove(x)
for i in range(n-1):
temp=-1
k=0
m=0
for j in range(n-1):
if arr[j]!=-1:
if gcd(x,arr[j])>temp:
k=j
m=arr[j]
temp=gcd(x,arr[j])
b.append(m)
arr[k]=-1
x=temp
b=list(map(str,b))
s=" ".join(b)
print(s)
``` | output | 1 | 98,829 | 22 | 197,659 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alexander is a well-known programmer. Today he decided to finally go out and play football, but with the first hit he left a dent on the new Rolls-Royce of the wealthy businessman Big Vova. Vladimir has recently opened a store on the popular online marketplace "Zmey-Gorynych", and offers Alex a job: if he shows his programming skills by solving a task, he'll work as a cybersecurity specialist. Otherwise, he'll be delivering some doubtful products for the next two years.
You're given n positive integers a_1, a_2, ..., a_n. Using each of them exactly at once, you're to make such sequence b_1, b_2, ..., b_n that sequence c_1, c_2, ..., c_n is lexicographically maximal, where c_i=GCD(b_1,...,b_i) - the greatest common divisor of the first i elements of b.
Alexander is really afraid of the conditions of this simple task, so he asks you to solve it.
A sequence a is lexicographically smaller than a sequence b if and only if one of the following holds:
* a is a prefix of b, but a ≠ b;
* in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3) — the length of the sequence a.
The second line of each test case contains n integers a_1,...,a_n (1 ≤ a_i ≤ 10^3) — the sequence a.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case output the answer in a single line — the desired sequence b. If there are multiple answers, print any.
Example
Input
7
2
2 5
4
1 8 2 3
3
3 8 9
5
64 25 75 100 50
1
42
6
96 128 88 80 52 7
5
2 4 8 16 17
Output
5 2
8 2 1 3
9 3 8
100 50 25 75 64
42
128 96 80 88 52 7
17 2 4 8 16
Note
In the first test case of the example, there are only two possible permutations b — [2, 5] and [5, 2]: for the first one c=[2, 1], for the second one c=[5, 1].
In the third test case of the example, number 9 should be the first in b, and GCD(9, 3)=3, GCD(9, 8)=1, so the second number of b should be 3.
In the seventh test case of the example, first four numbers pairwise have a common divisor (a power of two), but none of them can be the first in the optimal permutation b. | instruction | 0 | 98,830 | 22 | 197,660 |
Tags: brute force, greedy, math, number theory
Correct Solution:
```
import math
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int,input().split(" ")))
s = dict()
for i in a:
s[i] = 0
for i in a:
s[i] += 1
a = list(set(a))
max_a = max(a)
ans = [max_a]*s[max_a]
visited = [False]*len(a)
visited[a.index(max_a)] = True
temp = max_a
for i in range(len(a)):
max_ = 1
x = ans[-1]
for j in range(len(a)):
if not visited[j] and max_ < math.gcd(temp,a[j]):
max_ = math.gcd(temp,a[j])
y = a[j]
idx = j
if max_ != 1:
ans += [y]*s[y]
visited[idx] = True
temp = max_
else:
break
for i in range(len(a)):
if not visited[i]:
ans += [a[i]]*s[a[i]]
for i in ans:
print(i,end=" ")
print()
``` | output | 1 | 98,830 | 22 | 197,661 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alexander is a well-known programmer. Today he decided to finally go out and play football, but with the first hit he left a dent on the new Rolls-Royce of the wealthy businessman Big Vova. Vladimir has recently opened a store on the popular online marketplace "Zmey-Gorynych", and offers Alex a job: if he shows his programming skills by solving a task, he'll work as a cybersecurity specialist. Otherwise, he'll be delivering some doubtful products for the next two years.
You're given n positive integers a_1, a_2, ..., a_n. Using each of them exactly at once, you're to make such sequence b_1, b_2, ..., b_n that sequence c_1, c_2, ..., c_n is lexicographically maximal, where c_i=GCD(b_1,...,b_i) - the greatest common divisor of the first i elements of b.
Alexander is really afraid of the conditions of this simple task, so he asks you to solve it.
A sequence a is lexicographically smaller than a sequence b if and only if one of the following holds:
* a is a prefix of b, but a ≠ b;
* in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3) — the length of the sequence a.
The second line of each test case contains n integers a_1,...,a_n (1 ≤ a_i ≤ 10^3) — the sequence a.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case output the answer in a single line — the desired sequence b. If there are multiple answers, print any.
Example
Input
7
2
2 5
4
1 8 2 3
3
3 8 9
5
64 25 75 100 50
1
42
6
96 128 88 80 52 7
5
2 4 8 16 17
Output
5 2
8 2 1 3
9 3 8
100 50 25 75 64
42
128 96 80 88 52 7
17 2 4 8 16
Note
In the first test case of the example, there are only two possible permutations b — [2, 5] and [5, 2]: for the first one c=[2, 1], for the second one c=[5, 1].
In the third test case of the example, number 9 should be the first in b, and GCD(9, 3)=3, GCD(9, 8)=1, so the second number of b should be 3.
In the seventh test case of the example, first four numbers pairwise have a common divisor (a power of two), but none of them can be the first in the optimal permutation b. | instruction | 0 | 98,831 | 22 | 197,662 |
Tags: brute force, greedy, math, number theory
Correct Solution:
```
from collections import defaultdict
import math
t = int(input())
while t:
t -= 1
n = int(input())
a = list(map(int, input().split()))
freq = defaultdict(int)
maxi = float("-inf")
for x in a:
freq[x] += 1
maxi = max(maxi, x)
ans = [maxi]
i = 1
freq[maxi] -= 1
while i < n:
curr_max = 0
next = None
for num in a:
if freq[num]:
if math.gcd(maxi, num) > curr_max:
curr_max = math.gcd(maxi, num)
next = num
freq[next]-=1
ans.append(next)
maxi = curr_max
i+=1
print(*ans)
``` | output | 1 | 98,831 | 22 | 197,663 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alexander is a well-known programmer. Today he decided to finally go out and play football, but with the first hit he left a dent on the new Rolls-Royce of the wealthy businessman Big Vova. Vladimir has recently opened a store on the popular online marketplace "Zmey-Gorynych", and offers Alex a job: if he shows his programming skills by solving a task, he'll work as a cybersecurity specialist. Otherwise, he'll be delivering some doubtful products for the next two years.
You're given n positive integers a_1, a_2, ..., a_n. Using each of them exactly at once, you're to make such sequence b_1, b_2, ..., b_n that sequence c_1, c_2, ..., c_n is lexicographically maximal, where c_i=GCD(b_1,...,b_i) - the greatest common divisor of the first i elements of b.
Alexander is really afraid of the conditions of this simple task, so he asks you to solve it.
A sequence a is lexicographically smaller than a sequence b if and only if one of the following holds:
* a is a prefix of b, but a ≠ b;
* in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3) — the length of the sequence a.
The second line of each test case contains n integers a_1,...,a_n (1 ≤ a_i ≤ 10^3) — the sequence a.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case output the answer in a single line — the desired sequence b. If there are multiple answers, print any.
Example
Input
7
2
2 5
4
1 8 2 3
3
3 8 9
5
64 25 75 100 50
1
42
6
96 128 88 80 52 7
5
2 4 8 16 17
Output
5 2
8 2 1 3
9 3 8
100 50 25 75 64
42
128 96 80 88 52 7
17 2 4 8 16
Note
In the first test case of the example, there are only two possible permutations b — [2, 5] and [5, 2]: for the first one c=[2, 1], for the second one c=[5, 1].
In the third test case of the example, number 9 should be the first in b, and GCD(9, 3)=3, GCD(9, 8)=1, so the second number of b should be 3.
In the seventh test case of the example, first four numbers pairwise have a common divisor (a power of two), but none of them can be the first in the optimal permutation b.
Submitted Solution:
```
def gcd(a,b):
while a % b != 0:
a,b = b, a % b
return b
def bigGCD(a):
maxGcd = max(a)
b=[]
while maxGcd > 1:
if maxGcd in a:
b.append(maxGcd)
a.remove(maxGcd)
maxNow = 1
best = 0
for i in a:
if gcd(maxGcd,i) > maxNow:
maxNow = gcd(maxGcd,i)
best = i
if best != 0:
b.append(best)
a.remove(best)
maxGcd = maxNow
while a:
b.append(a.pop(0))
return b
if __name__ == '__main__':
cases = int(input())
for i in range(cases):
n = int(input())
a = list(map(int,input().strip().split()))
ans = bigGCD(a)
print(f"{' '.join(map(str,ans))}")
``` | instruction | 0 | 98,832 | 22 | 197,664 |
Yes | output | 1 | 98,832 | 22 | 197,665 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alexander is a well-known programmer. Today he decided to finally go out and play football, but with the first hit he left a dent on the new Rolls-Royce of the wealthy businessman Big Vova. Vladimir has recently opened a store on the popular online marketplace "Zmey-Gorynych", and offers Alex a job: if he shows his programming skills by solving a task, he'll work as a cybersecurity specialist. Otherwise, he'll be delivering some doubtful products for the next two years.
You're given n positive integers a_1, a_2, ..., a_n. Using each of them exactly at once, you're to make such sequence b_1, b_2, ..., b_n that sequence c_1, c_2, ..., c_n is lexicographically maximal, where c_i=GCD(b_1,...,b_i) - the greatest common divisor of the first i elements of b.
Alexander is really afraid of the conditions of this simple task, so he asks you to solve it.
A sequence a is lexicographically smaller than a sequence b if and only if one of the following holds:
* a is a prefix of b, but a ≠ b;
* in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3) — the length of the sequence a.
The second line of each test case contains n integers a_1,...,a_n (1 ≤ a_i ≤ 10^3) — the sequence a.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case output the answer in a single line — the desired sequence b. If there are multiple answers, print any.
Example
Input
7
2
2 5
4
1 8 2 3
3
3 8 9
5
64 25 75 100 50
1
42
6
96 128 88 80 52 7
5
2 4 8 16 17
Output
5 2
8 2 1 3
9 3 8
100 50 25 75 64
42
128 96 80 88 52 7
17 2 4 8 16
Note
In the first test case of the example, there are only two possible permutations b — [2, 5] and [5, 2]: for the first one c=[2, 1], for the second one c=[5, 1].
In the third test case of the example, number 9 should be the first in b, and GCD(9, 3)=3, GCD(9, 8)=1, so the second number of b should be 3.
In the seventh test case of the example, first four numbers pairwise have a common divisor (a power of two), but none of them can be the first in the optimal permutation b.
Submitted Solution:
```
import math
def main():
n = int(input())
lst = list(map(int, input().split()))
cur = max(lst)
res = [lst.index(cur)]
st = set()
st.add(lst.index(cur))
for i in range(n - 1):
el = -1
mx = 0
for k in range(n):
if k in st:
pass
elif math.gcd(cur, lst[k]) > mx:
mx= math.gcd(cur, lst[k])
el = k
st.add(el)
res.append(el)
cur = mx
for i in res:
print(lst[i], end=" ")
print()
if __name__ == '__main__':
t = int(input())
for i in range(t):
main()
"""
60, 61
"""
"""
"""
``` | instruction | 0 | 98,833 | 22 | 197,666 |
Yes | output | 1 | 98,833 | 22 | 197,667 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alexander is a well-known programmer. Today he decided to finally go out and play football, but with the first hit he left a dent on the new Rolls-Royce of the wealthy businessman Big Vova. Vladimir has recently opened a store on the popular online marketplace "Zmey-Gorynych", and offers Alex a job: if he shows his programming skills by solving a task, he'll work as a cybersecurity specialist. Otherwise, he'll be delivering some doubtful products for the next two years.
You're given n positive integers a_1, a_2, ..., a_n. Using each of them exactly at once, you're to make such sequence b_1, b_2, ..., b_n that sequence c_1, c_2, ..., c_n is lexicographically maximal, where c_i=GCD(b_1,...,b_i) - the greatest common divisor of the first i elements of b.
Alexander is really afraid of the conditions of this simple task, so he asks you to solve it.
A sequence a is lexicographically smaller than a sequence b if and only if one of the following holds:
* a is a prefix of b, but a ≠ b;
* in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3) — the length of the sequence a.
The second line of each test case contains n integers a_1,...,a_n (1 ≤ a_i ≤ 10^3) — the sequence a.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case output the answer in a single line — the desired sequence b. If there are multiple answers, print any.
Example
Input
7
2
2 5
4
1 8 2 3
3
3 8 9
5
64 25 75 100 50
1
42
6
96 128 88 80 52 7
5
2 4 8 16 17
Output
5 2
8 2 1 3
9 3 8
100 50 25 75 64
42
128 96 80 88 52 7
17 2 4 8 16
Note
In the first test case of the example, there are only two possible permutations b — [2, 5] and [5, 2]: for the first one c=[2, 1], for the second one c=[5, 1].
In the third test case of the example, number 9 should be the first in b, and GCD(9, 3)=3, GCD(9, 8)=1, so the second number of b should be 3.
In the seventh test case of the example, first four numbers pairwise have a common divisor (a power of two), but none of them can be the first in the optimal permutation b.
Submitted Solution:
```
#!/usr/bin/env python3
# encoding: utf-8
#----------
# Constants
#----------
#----------
# Functions
#----------
def gcd(a, b):
a, b = max(a, b), min(a, b)
while b > 0:
a, b = b, a % b
return a
# The function that solves the task
def calc(a):
a.sort()
max_val = a[-1]
del a[-1]
res = [ max_val ]
res_gcd = max_val
while a:
val, pos = 0, 0
for i, item in enumerate(a):
v = gcd(res_gcd, item)
if v > val:
val = v
pos = i
res.append(a[pos])
del a[pos]
res_gcd = val
return res
# Reads a string from stdin, splits it by space chars, converts each
# substring to int, adds it to a list and returns the list as a result.
def get_ints():
return [ int(n) for n in input().split() ]
# Reads a string from stdin, splits it by space chars, converts each substring
# to floating point number, adds it to a list and returns the list as a result.
def get_floats():
return [ float(n) for n in input().split() ]
# Converts a sequence to the space separated string
def seq2str(seq):
return ' '.join(str(item) for item in seq)
#----------
# Execution start point
#----------
if __name__ == "__main__":
zzz = get_ints()
assert len(zzz) == 1
t = zzz[0]
for i in range(t):
zzz = get_ints()
assert len(zzz) == 1
n = zzz[0]
zzz = get_ints()
assert len(zzz) == n
a = zzz
res = calc(a)
print(seq2str(res))
``` | instruction | 0 | 98,834 | 22 | 197,668 |
Yes | output | 1 | 98,834 | 22 | 197,669 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alexander is a well-known programmer. Today he decided to finally go out and play football, but with the first hit he left a dent on the new Rolls-Royce of the wealthy businessman Big Vova. Vladimir has recently opened a store on the popular online marketplace "Zmey-Gorynych", and offers Alex a job: if he shows his programming skills by solving a task, he'll work as a cybersecurity specialist. Otherwise, he'll be delivering some doubtful products for the next two years.
You're given n positive integers a_1, a_2, ..., a_n. Using each of them exactly at once, you're to make such sequence b_1, b_2, ..., b_n that sequence c_1, c_2, ..., c_n is lexicographically maximal, where c_i=GCD(b_1,...,b_i) - the greatest common divisor of the first i elements of b.
Alexander is really afraid of the conditions of this simple task, so he asks you to solve it.
A sequence a is lexicographically smaller than a sequence b if and only if one of the following holds:
* a is a prefix of b, but a ≠ b;
* in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3) — the length of the sequence a.
The second line of each test case contains n integers a_1,...,a_n (1 ≤ a_i ≤ 10^3) — the sequence a.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case output the answer in a single line — the desired sequence b. If there are multiple answers, print any.
Example
Input
7
2
2 5
4
1 8 2 3
3
3 8 9
5
64 25 75 100 50
1
42
6
96 128 88 80 52 7
5
2 4 8 16 17
Output
5 2
8 2 1 3
9 3 8
100 50 25 75 64
42
128 96 80 88 52 7
17 2 4 8 16
Note
In the first test case of the example, there are only two possible permutations b — [2, 5] and [5, 2]: for the first one c=[2, 1], for the second one c=[5, 1].
In the third test case of the example, number 9 should be the first in b, and GCD(9, 3)=3, GCD(9, 8)=1, so the second number of b should be 3.
In the seventh test case of the example, first four numbers pairwise have a common divisor (a power of two), but none of them can be the first in the optimal permutation b.
Submitted Solution:
```
from sys import stdin
from math import gcd
input = stdin.readline
t = int(input())
for _ in range(t):
n = int(input())
a = [int(x) for x in input().split()]
used = [False]*n
cur = 0
b = []
for j in range(n):
best = 0
for i in range(n):
if used[i]:
continue
g = gcd(cur, a[i])
if g > best:
best = g
best_idx = i
used[best_idx] = True
cur = best
b.append(a[best_idx])
print(*b)
``` | instruction | 0 | 98,835 | 22 | 197,670 |
Yes | output | 1 | 98,835 | 22 | 197,671 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alexander is a well-known programmer. Today he decided to finally go out and play football, but with the first hit he left a dent on the new Rolls-Royce of the wealthy businessman Big Vova. Vladimir has recently opened a store on the popular online marketplace "Zmey-Gorynych", and offers Alex a job: if he shows his programming skills by solving a task, he'll work as a cybersecurity specialist. Otherwise, he'll be delivering some doubtful products for the next two years.
You're given n positive integers a_1, a_2, ..., a_n. Using each of them exactly at once, you're to make such sequence b_1, b_2, ..., b_n that sequence c_1, c_2, ..., c_n is lexicographically maximal, where c_i=GCD(b_1,...,b_i) - the greatest common divisor of the first i elements of b.
Alexander is really afraid of the conditions of this simple task, so he asks you to solve it.
A sequence a is lexicographically smaller than a sequence b if and only if one of the following holds:
* a is a prefix of b, but a ≠ b;
* in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3) — the length of the sequence a.
The second line of each test case contains n integers a_1,...,a_n (1 ≤ a_i ≤ 10^3) — the sequence a.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case output the answer in a single line — the desired sequence b. If there are multiple answers, print any.
Example
Input
7
2
2 5
4
1 8 2 3
3
3 8 9
5
64 25 75 100 50
1
42
6
96 128 88 80 52 7
5
2 4 8 16 17
Output
5 2
8 2 1 3
9 3 8
100 50 25 75 64
42
128 96 80 88 52 7
17 2 4 8 16
Note
In the first test case of the example, there are only two possible permutations b — [2, 5] and [5, 2]: for the first one c=[2, 1], for the second one c=[5, 1].
In the third test case of the example, number 9 should be the first in b, and GCD(9, 3)=3, GCD(9, 8)=1, so the second number of b should be 3.
In the seventh test case of the example, first four numbers pairwise have a common divisor (a power of two), but none of them can be the first in the optimal permutation b.
Submitted Solution:
```
t=int(input())
import math
while t:
t-=1
n=int(input())
a=[int(i) for i in input().split()]
a.sort()
ans=[]
ans.append(a[n-1])
del a[n-1]
curg=ans[0]
while len(a):
ma=0
inl=0
flag=0
for i in range(len(a)):
if curg%a[i]==0:
ma=a[i]
inl=i
flag+=1
if flag==0:
break
else:
ans.append(ma)
del a[inl]
curg=math.gcd(curg,ans[-1])
ans+=a
print(*ans,sep=" ")
``` | instruction | 0 | 98,836 | 22 | 197,672 |
No | output | 1 | 98,836 | 22 | 197,673 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alexander is a well-known programmer. Today he decided to finally go out and play football, but with the first hit he left a dent on the new Rolls-Royce of the wealthy businessman Big Vova. Vladimir has recently opened a store on the popular online marketplace "Zmey-Gorynych", and offers Alex a job: if he shows his programming skills by solving a task, he'll work as a cybersecurity specialist. Otherwise, he'll be delivering some doubtful products for the next two years.
You're given n positive integers a_1, a_2, ..., a_n. Using each of them exactly at once, you're to make such sequence b_1, b_2, ..., b_n that sequence c_1, c_2, ..., c_n is lexicographically maximal, where c_i=GCD(b_1,...,b_i) - the greatest common divisor of the first i elements of b.
Alexander is really afraid of the conditions of this simple task, so he asks you to solve it.
A sequence a is lexicographically smaller than a sequence b if and only if one of the following holds:
* a is a prefix of b, but a ≠ b;
* in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3) — the length of the sequence a.
The second line of each test case contains n integers a_1,...,a_n (1 ≤ a_i ≤ 10^3) — the sequence a.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case output the answer in a single line — the desired sequence b. If there are multiple answers, print any.
Example
Input
7
2
2 5
4
1 8 2 3
3
3 8 9
5
64 25 75 100 50
1
42
6
96 128 88 80 52 7
5
2 4 8 16 17
Output
5 2
8 2 1 3
9 3 8
100 50 25 75 64
42
128 96 80 88 52 7
17 2 4 8 16
Note
In the first test case of the example, there are only two possible permutations b — [2, 5] and [5, 2]: for the first one c=[2, 1], for the second one c=[5, 1].
In the third test case of the example, number 9 should be the first in b, and GCD(9, 3)=3, GCD(9, 8)=1, so the second number of b should be 3.
In the seventh test case of the example, first four numbers pairwise have a common divisor (a power of two), but none of them can be the first in the optimal permutation b.
Submitted Solution:
```
t=int(input())
for _ in range(t):
n=int(input())
l1=list(map(int,input().split()))
l1.sort(reverse=True)
l2,l3=[],[]
l2.append(l1[0])
m=l1[0]
for i in range(1,n):
if m%l1[i]==0:
l2.append(l1[i])
else:
l3.append(l1[i])
l3.sort()
l2+=l3
for i in range(n-1):
print(l2[i],end=" ")
print(l2[n-1])
``` | instruction | 0 | 98,837 | 22 | 197,674 |
No | output | 1 | 98,837 | 22 | 197,675 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alexander is a well-known programmer. Today he decided to finally go out and play football, but with the first hit he left a dent on the new Rolls-Royce of the wealthy businessman Big Vova. Vladimir has recently opened a store on the popular online marketplace "Zmey-Gorynych", and offers Alex a job: if he shows his programming skills by solving a task, he'll work as a cybersecurity specialist. Otherwise, he'll be delivering some doubtful products for the next two years.
You're given n positive integers a_1, a_2, ..., a_n. Using each of them exactly at once, you're to make such sequence b_1, b_2, ..., b_n that sequence c_1, c_2, ..., c_n is lexicographically maximal, where c_i=GCD(b_1,...,b_i) - the greatest common divisor of the first i elements of b.
Alexander is really afraid of the conditions of this simple task, so he asks you to solve it.
A sequence a is lexicographically smaller than a sequence b if and only if one of the following holds:
* a is a prefix of b, but a ≠ b;
* in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3) — the length of the sequence a.
The second line of each test case contains n integers a_1,...,a_n (1 ≤ a_i ≤ 10^3) — the sequence a.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case output the answer in a single line — the desired sequence b. If there are multiple answers, print any.
Example
Input
7
2
2 5
4
1 8 2 3
3
3 8 9
5
64 25 75 100 50
1
42
6
96 128 88 80 52 7
5
2 4 8 16 17
Output
5 2
8 2 1 3
9 3 8
100 50 25 75 64
42
128 96 80 88 52 7
17 2 4 8 16
Note
In the first test case of the example, there are only two possible permutations b — [2, 5] and [5, 2]: for the first one c=[2, 1], for the second one c=[5, 1].
In the third test case of the example, number 9 should be the first in b, and GCD(9, 3)=3, GCD(9, 8)=1, so the second number of b should be 3.
In the seventh test case of the example, first four numbers pairwise have a common divisor (a power of two), but none of them can be the first in the optimal permutation b.
Submitted Solution:
```
import math
import collections
for t in range(int(input())):
n=int(input())
num=list(map(int,input().split()))
val=max(num)
k=collections.defaultdict(list)
for i in num:
v=math.gcd(val,i)
k[v].append(i)
out=[]
for i in sorted(k.keys(),reverse=True):
out+=k[i]
print(*out)
``` | instruction | 0 | 98,838 | 22 | 197,676 |
No | output | 1 | 98,838 | 22 | 197,677 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alexander is a well-known programmer. Today he decided to finally go out and play football, but with the first hit he left a dent on the new Rolls-Royce of the wealthy businessman Big Vova. Vladimir has recently opened a store on the popular online marketplace "Zmey-Gorynych", and offers Alex a job: if he shows his programming skills by solving a task, he'll work as a cybersecurity specialist. Otherwise, he'll be delivering some doubtful products for the next two years.
You're given n positive integers a_1, a_2, ..., a_n. Using each of them exactly at once, you're to make such sequence b_1, b_2, ..., b_n that sequence c_1, c_2, ..., c_n is lexicographically maximal, where c_i=GCD(b_1,...,b_i) - the greatest common divisor of the first i elements of b.
Alexander is really afraid of the conditions of this simple task, so he asks you to solve it.
A sequence a is lexicographically smaller than a sequence b if and only if one of the following holds:
* a is a prefix of b, but a ≠ b;
* in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3) — the length of the sequence a.
The second line of each test case contains n integers a_1,...,a_n (1 ≤ a_i ≤ 10^3) — the sequence a.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case output the answer in a single line — the desired sequence b. If there are multiple answers, print any.
Example
Input
7
2
2 5
4
1 8 2 3
3
3 8 9
5
64 25 75 100 50
1
42
6
96 128 88 80 52 7
5
2 4 8 16 17
Output
5 2
8 2 1 3
9 3 8
100 50 25 75 64
42
128 96 80 88 52 7
17 2 4 8 16
Note
In the first test case of the example, there are only two possible permutations b — [2, 5] and [5, 2]: for the first one c=[2, 1], for the second one c=[5, 1].
In the third test case of the example, number 9 should be the first in b, and GCD(9, 3)=3, GCD(9, 8)=1, so the second number of b should be 3.
In the seventh test case of the example, first four numbers pairwise have a common divisor (a power of two), but none of them can be the first in the optimal permutation b.
Submitted Solution:
```
import math
import collections
def solution(n, a):
max_ = max(a)
max_i = a.index(max_)
x = [max_]
del a[max_i]
while a != []:
out = collections.defaultdict(list)
for e in a:
out[math.gcd(x[-1], e)].append(e)
temp = out.pop(max(list(out.keys())))
x.extend(temp)
for e in temp:
a.remove(e)
return x
if __name__ == "__main__":
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split(' ')))
print(*solution(n, a))
``` | instruction | 0 | 98,839 | 22 | 197,678 |
No | output | 1 | 98,839 | 22 | 197,679 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.
Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).
What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?
Input
Single line of the input contains three integers x, y and m ( - 1018 ≤ x, y, m ≤ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.
Output
Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.
Examples
Input
1 2 5
Output
2
Input
-1 4 15
Output
4
Input
0 -1 5
Output
-1
Note
In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).
In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).
Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations. | instruction | 0 | 98,944 | 22 | 197,888 |
Tags: brute force
Correct Solution:
```
#_________________ Mukul Mohan Varshney _______________#
#Template
import sys
import os
import math
import copy
from math import gcd
from bisect import bisect
from io import BytesIO, IOBase
from math import sqrt,floor,factorial,gcd,log,ceil
from collections import deque,Counter,defaultdict
from itertools import permutations, combinations
#define function
def Int(): return int(sys.stdin.readline())
def Mint(): return map(int,sys.stdin.readline().split())
def Lstr(): return list(sys.stdin.readline().strip())
def Str(): return sys.stdin.readline().strip()
def Mstr(): return map(str,sys.stdin.readline().strip().split())
def List(): return list(map(int,sys.stdin.readline().split()))
def Hash(): return dict()
def Mod(): return 1000000007
def Ncr(n,r,p): return ((fact[n])*((ifact[r]*ifact[n-r])%p))%p
def Most_frequent(list): return max(set(list), key = list.count)
def Mat2x2(n): return [List() for _ in range(n)]
def btod(n):
return int(n,2)
def dtob(n):
return bin(n).replace("0b","")
# Driver Code
def solution():
#for _ in range(Int()):
x,y,m=Mint()
ans=0
if(x>=m or y>=m):
print(0)
elif(x<=0 and y<=0):
print(-1)
else:
if(x>0 and y<0):
ans=(x-y-1)//x
y+=ans*x
elif(y>0 and x<0):
ans=(y-x-1)//y
x+=ans*y
while(x<m and y<m):
t=x+y
if(x<y):
x=t
else:
y=t
ans+=1
print(ans)
#Call the solve function
if __name__ == "__main__":
solution()
``` | output | 1 | 98,944 | 22 | 197,889 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.
Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).
What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?
Input
Single line of the input contains three integers x, y and m ( - 1018 ≤ x, y, m ≤ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.
Output
Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.
Examples
Input
1 2 5
Output
2
Input
-1 4 15
Output
4
Input
0 -1 5
Output
-1
Note
In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).
In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).
Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations. | instruction | 0 | 98,945 | 22 | 197,890 |
Tags: brute force
Correct Solution:
```
from math import ceil
x, y, m=map(int, input().split())
if max(x, y)>=m:
exit(print(0))
if x<=0 and y<=0:
exit(print(-1))
x, y=min(x, y), max(x, y)
steps=0
if x<0:
steps+=ceil((abs(x)+y-1)/y)
csteps=ceil((abs(x)+y-1)/y)
x=y*csteps+x
while max(x, y)<m:
x, y=x+y, max(x, y)
steps+=1
exit(print(steps))
``` | output | 1 | 98,945 | 22 | 197,891 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.
Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).
What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?
Input
Single line of the input contains three integers x, y and m ( - 1018 ≤ x, y, m ≤ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.
Output
Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.
Examples
Input
1 2 5
Output
2
Input
-1 4 15
Output
4
Input
0 -1 5
Output
-1
Note
In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).
In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).
Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations. | instruction | 0 | 98,946 | 22 | 197,892 |
Tags: brute force
Correct Solution:
```
x,y,m=map(int,input().split())
i=0
if x>=m or y>=m:
print(i)
elif max(x,y)<=0:
print(-1)
else:
if x>y:
x,y=y,x
if x<0:
i=(y-x)//y
x+=i*y
while y<m:
x,y=y,x+y
i+=1
print(i)
``` | output | 1 | 98,946 | 22 | 197,893 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.
Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).
What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?
Input
Single line of the input contains three integers x, y and m ( - 1018 ≤ x, y, m ≤ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.
Output
Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.
Examples
Input
1 2 5
Output
2
Input
-1 4 15
Output
4
Input
0 -1 5
Output
-1
Note
In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).
In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).
Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations. | instruction | 0 | 98,947 | 22 | 197,894 |
Tags: brute force
Correct Solution:
```
import math
a, b, c = map (int, input().split())
if (max (a, b) >= c):
print (0)
raise SystemExit
if (a <= 0 and b <= 0) :
print (-1)
raise SystemExit
tot = 0
if ((a <= 0 and b > 0) or (b <= 0 and a > 0)) :
add = max (a, b)
menor = min (a, b)
adicionar = math.ceil(-menor / add)
tot = adicionar
if (min (a, b) == a) :
a += add * adicionar
else :
b += add * adicionar
times = 500
while (times > 0) :
times -= 1
if (max(a, b) >= c) :
print (tot)
raise SystemExit
tot += 1
add = a + b
if (min (a, b) == a) :
a = add
else :
b = add
print (-1)
``` | output | 1 | 98,947 | 22 | 197,895 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.
Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).
What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?
Input
Single line of the input contains three integers x, y and m ( - 1018 ≤ x, y, m ≤ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.
Output
Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.
Examples
Input
1 2 5
Output
2
Input
-1 4 15
Output
4
Input
0 -1 5
Output
-1
Note
In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).
In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).
Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations. | instruction | 0 | 98,948 | 22 | 197,896 |
Tags: brute force
Correct Solution:
```
a,b,c = [ int(x) for x in input().split()]
d = 200;
pocet = 0;
while True:
if a>b:
a,b = b,a
if b>=c:
print(pocet)
quit()
d-=1
if d<0:
print(-1)
quit()
if b<-1000:
print(-1)
quit()
if a<0 and b>0:
x = max(1, -a//b - 5)
pocet+=x
a = a+x*b
else:
pocet+=1
a = a+b
``` | output | 1 | 98,948 | 22 | 197,897 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.
Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).
What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?
Input
Single line of the input contains three integers x, y and m ( - 1018 ≤ x, y, m ≤ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.
Output
Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.
Examples
Input
1 2 5
Output
2
Input
-1 4 15
Output
4
Input
0 -1 5
Output
-1
Note
In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).
In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).
Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations. | instruction | 0 | 98,949 | 22 | 197,898 |
Tags: brute force
Correct Solution:
```
import math
a,b,c=map(int,input().split())
count=0
if a<b:
a,b=b,a
if a>=c:
print(0)
else:
if a>0 and b<0:
count=math.ceil(abs(b)/a)
b+=a*count
c2=0
while max(a,b)<c:
if a<b:
a=a+b
else:
b=a+b
c2+=1
if c2>10**6:
c2=-1
break
print(count+c2)
``` | output | 1 | 98,949 | 22 | 197,899 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.
Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).
What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?
Input
Single line of the input contains three integers x, y and m ( - 1018 ≤ x, y, m ≤ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.
Output
Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.
Examples
Input
1 2 5
Output
2
Input
-1 4 15
Output
4
Input
0 -1 5
Output
-1
Note
In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).
In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).
Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations. | instruction | 0 | 98,950 | 22 | 197,900 |
Tags: brute force
Correct Solution:
```
'''
#A
m, n = map(int, input().split())
if m % 2 == 1:
if n <= (m + 1) // 2:
print(2 * n - 1)
else:
print(2 * n - (m + 1))
else:
if n <= m // 2:
print(2 * n - 1)
else:
print(2 * n - m)
#B
s = input()
l = s.split('heavy')
res = 0
for i in range(1, len(l)):
res += i * l[i].count('metal')
print(res)
'''
#C
s = input().split()
x, y, m = (int(i) for i in s)
res = 0
if x >= m or y >= m:
print(0)
elif x <= 0 and y <= 0:
print(-1)
else:
if x < 0:
q = abs(x // y)
res += q
x += y * q
elif y < 0:
q = abs(y // x)
res += q
y += x * q
while x < m and y < m:
res += 1
if x < y:
x += y
else:
y += x
print(res)
``` | output | 1 | 98,950 | 22 | 197,901 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.
Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).
What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?
Input
Single line of the input contains three integers x, y and m ( - 1018 ≤ x, y, m ≤ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.
Output
Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.
Examples
Input
1 2 5
Output
2
Input
-1 4 15
Output
4
Input
0 -1 5
Output
-1
Note
In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).
In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).
Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations. | instruction | 0 | 98,951 | 22 | 197,902 |
Tags: brute force
Correct Solution:
```
a,b,c = map(int, input().split())
k = 0
if a>=c or b>=c:
print(0)
exit()
if a<=0 and b<=0:
print(-1)
exit()
if a+b < 0:
s = max(a,b) - min(a,b)
k += abs(s//min(abs(min(a,b)),abs(max(a,b))))
if a<b:
a+=k*min(abs(a),abs(b))
else:
b+=k*min(abs(a),abs(b))
while a<c and b<c:
if a<b:
a=b+a
else:
b=b+a
k+=1
print(k)
``` | output | 1 | 98,951 | 22 | 197,903 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As behooves any intelligent schoolboy, Kevin Sun is studying psycowlogy, cowculus, and cryptcowgraphy at the Bovinia State University (BGU) under Farmer Ivan. During his Mathematics of Olympiads (MoO) class, Kevin was confronted with a weird functional equation and needs your help. For two fixed integers k and p, where p is an odd prime number, the functional equation states that
<image>
for some function <image>. (This equation should hold for any integer x in the range 0 to p - 1, inclusive.)
It turns out that f can actually be many different functions. Instead of finding a solution, Kevin wants you to count the number of distinct functions f that satisfy this equation. Since the answer may be very large, you should print your result modulo 109 + 7.
Input
The input consists of two space-separated integers p and k (3 ≤ p ≤ 1 000 000, 0 ≤ k ≤ p - 1) on a single line. It is guaranteed that p is an odd prime number.
Output
Print a single integer, the number of distinct functions f modulo 109 + 7.
Examples
Input
3 2
Output
3
Input
5 4
Output
25
Note
In the first sample, p = 3 and k = 2. The following functions work:
1. f(0) = 0, f(1) = 1, f(2) = 2.
2. f(0) = 0, f(1) = 2, f(2) = 1.
3. f(0) = f(1) = f(2) = 0. | instruction | 0 | 99,067 | 22 | 198,134 |
Tags: combinatorics, dfs and similar, dsu, math, number theory
Correct Solution:
```
MOD = 10**9+7
def f(a,b):
if b == 1:
return a%MOD
elif b % 2 == 0:
return f((a*a)%MOD,b//2)
else:
return (a*f((a*a)%MOD,b//2)) % MOD
p,k = map(int,input().split())
if k == 0:
print(f(p,p-1))
exit()
if k == 1:
print(f(p,p))
exit()
t = 1
a = k
while a != 1:
a = (a*k % p)
t += 1
n = (p-1)//t
print(f(p,n))
``` | output | 1 | 99,067 | 22 | 198,135 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As behooves any intelligent schoolboy, Kevin Sun is studying psycowlogy, cowculus, and cryptcowgraphy at the Bovinia State University (BGU) under Farmer Ivan. During his Mathematics of Olympiads (MoO) class, Kevin was confronted with a weird functional equation and needs your help. For two fixed integers k and p, where p is an odd prime number, the functional equation states that
<image>
for some function <image>. (This equation should hold for any integer x in the range 0 to p - 1, inclusive.)
It turns out that f can actually be many different functions. Instead of finding a solution, Kevin wants you to count the number of distinct functions f that satisfy this equation. Since the answer may be very large, you should print your result modulo 109 + 7.
Input
The input consists of two space-separated integers p and k (3 ≤ p ≤ 1 000 000, 0 ≤ k ≤ p - 1) on a single line. It is guaranteed that p is an odd prime number.
Output
Print a single integer, the number of distinct functions f modulo 109 + 7.
Examples
Input
3 2
Output
3
Input
5 4
Output
25
Note
In the first sample, p = 3 and k = 2. The following functions work:
1. f(0) = 0, f(1) = 1, f(2) = 2.
2. f(0) = 0, f(1) = 2, f(2) = 1.
3. f(0) = f(1) = f(2) = 0. | instruction | 0 | 99,068 | 22 | 198,136 |
Tags: combinatorics, dfs and similar, dsu, math, number theory
Correct Solution:
```
import math
p,k = map(int, input().split())
a = [0] * p
sets = 0
for i in range(p):
if ( a[i] == 0 ):
sets += 1
r = i
while ( a[r] == 0 ):
a[r] = 1
r = int(math.fmod(r * k,p))
if (k == 0):
sets = p
elif(k == 1):
sets = p+1
res = 1
big = 1000000007
for i in range(sets-1):
res = int(math.fmod(res * p,big))
print(int(res))
``` | output | 1 | 99,068 | 22 | 198,137 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As behooves any intelligent schoolboy, Kevin Sun is studying psycowlogy, cowculus, and cryptcowgraphy at the Bovinia State University (BGU) under Farmer Ivan. During his Mathematics of Olympiads (MoO) class, Kevin was confronted with a weird functional equation and needs your help. For two fixed integers k and p, where p is an odd prime number, the functional equation states that
<image>
for some function <image>. (This equation should hold for any integer x in the range 0 to p - 1, inclusive.)
It turns out that f can actually be many different functions. Instead of finding a solution, Kevin wants you to count the number of distinct functions f that satisfy this equation. Since the answer may be very large, you should print your result modulo 109 + 7.
Input
The input consists of two space-separated integers p and k (3 ≤ p ≤ 1 000 000, 0 ≤ k ≤ p - 1) on a single line. It is guaranteed that p is an odd prime number.
Output
Print a single integer, the number of distinct functions f modulo 109 + 7.
Examples
Input
3 2
Output
3
Input
5 4
Output
25
Note
In the first sample, p = 3 and k = 2. The following functions work:
1. f(0) = 0, f(1) = 1, f(2) = 2.
2. f(0) = 0, f(1) = 2, f(2) = 1.
3. f(0) = f(1) = f(2) = 0. | instruction | 0 | 99,069 | 22 | 198,138 |
Tags: combinatorics, dfs and similar, dsu, math, number theory
Correct Solution:
```
__author__ = 'MoonBall'
import sys
# sys.stdin = open('data/D.in', 'r')
T = 1
M = 1000000007
def process():
P, K = list(map(int, input().split()))
k = [K * x % P for x in range(P)]
# print(k)
# f(0) = k[f(0)]
# f(1) = k[f(4)]
# f(2) = k[f(3)]
# f(3) = k[f(2)]
# f(4) = k[f(1)]
if not K:
print(pow(P, P - 1, M))
return
if K == 1:
print(pow(P, P, M))
return
f = [0] * P
c = [0] * P
ans = 1
for i in range(P):
if f[i]: continue
cnt = 1
u = i
f[u] = 1
while not f[k[u]]:
u = k[u]
f[u] = 1
cnt = cnt + 1
c[cnt] = c[cnt] + 1
# print(c)
for i in range(2, P):
if c[i] != 0:
cnt = i * c[i] + 1
ans = ans * pow(cnt, c[i], M) % M
print(ans)
for _ in range(T):
process()
``` | output | 1 | 99,069 | 22 | 198,139 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As behooves any intelligent schoolboy, Kevin Sun is studying psycowlogy, cowculus, and cryptcowgraphy at the Bovinia State University (BGU) under Farmer Ivan. During his Mathematics of Olympiads (MoO) class, Kevin was confronted with a weird functional equation and needs your help. For two fixed integers k and p, where p is an odd prime number, the functional equation states that
<image>
for some function <image>. (This equation should hold for any integer x in the range 0 to p - 1, inclusive.)
It turns out that f can actually be many different functions. Instead of finding a solution, Kevin wants you to count the number of distinct functions f that satisfy this equation. Since the answer may be very large, you should print your result modulo 109 + 7.
Input
The input consists of two space-separated integers p and k (3 ≤ p ≤ 1 000 000, 0 ≤ k ≤ p - 1) on a single line. It is guaranteed that p is an odd prime number.
Output
Print a single integer, the number of distinct functions f modulo 109 + 7.
Examples
Input
3 2
Output
3
Input
5 4
Output
25
Note
In the first sample, p = 3 and k = 2. The following functions work:
1. f(0) = 0, f(1) = 1, f(2) = 2.
2. f(0) = 0, f(1) = 2, f(2) = 1.
3. f(0) = f(1) = f(2) = 0. | instruction | 0 | 99,070 | 22 | 198,140 |
Tags: combinatorics, dfs and similar, dsu, math, number theory
Correct Solution:
```
import math
def expmod(base, expon, mod):
ans = 1
for i in range(1, expon + 1):
ans = (ans * base) % mod
return ans
p, k = input().split()
s = 10 ** 9 + 7
k = int(k)
p = int(p)
ord = 1
done = 0
if k == 0:
z = p - 1
if k == 1:
z = p
else:
for i in range(2,p + 1):
if done == 0:
if (p-1) % i == 0:
if expmod(k, i, p) == 1:
ord = i
done = 1
z = int((p-1) / ord)
rem = expmod(p, z, s)
print(int(rem))
``` | output | 1 | 99,070 | 22 | 198,141 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As behooves any intelligent schoolboy, Kevin Sun is studying psycowlogy, cowculus, and cryptcowgraphy at the Bovinia State University (BGU) under Farmer Ivan. During his Mathematics of Olympiads (MoO) class, Kevin was confronted with a weird functional equation and needs your help. For two fixed integers k and p, where p is an odd prime number, the functional equation states that
<image>
for some function <image>. (This equation should hold for any integer x in the range 0 to p - 1, inclusive.)
It turns out that f can actually be many different functions. Instead of finding a solution, Kevin wants you to count the number of distinct functions f that satisfy this equation. Since the answer may be very large, you should print your result modulo 109 + 7.
Input
The input consists of two space-separated integers p and k (3 ≤ p ≤ 1 000 000, 0 ≤ k ≤ p - 1) on a single line. It is guaranteed that p is an odd prime number.
Output
Print a single integer, the number of distinct functions f modulo 109 + 7.
Examples
Input
3 2
Output
3
Input
5 4
Output
25
Note
In the first sample, p = 3 and k = 2. The following functions work:
1. f(0) = 0, f(1) = 1, f(2) = 2.
2. f(0) = 0, f(1) = 2, f(2) = 1.
3. f(0) = f(1) = f(2) = 0. | instruction | 0 | 99,071 | 22 | 198,142 |
Tags: combinatorics, dfs and similar, dsu, math, number theory
Correct Solution:
```
def m_pow(x, y, m):
if y == 0:
return 1
if (y & 1):
return m_pow(x, y - 1, m) * x % m
else:
t = m_pow(x, y >> 1, m)
return t * t % m
#
(p, k) = map(int, input().split())
used = [0] * p
if k == 0:
print(m_pow(p, p - 1, 1000000007))
else:
c = 1 if k == 1 else 0
for x in range(1, p):
if not used[x]:
y = x
while not used[y]:
used[y] = True
y = k * y % p
c += 1
print(m_pow(p, c, 1000000007))
``` | output | 1 | 99,071 | 22 | 198,143 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As behooves any intelligent schoolboy, Kevin Sun is studying psycowlogy, cowculus, and cryptcowgraphy at the Bovinia State University (BGU) under Farmer Ivan. During his Mathematics of Olympiads (MoO) class, Kevin was confronted with a weird functional equation and needs your help. For two fixed integers k and p, where p is an odd prime number, the functional equation states that
<image>
for some function <image>. (This equation should hold for any integer x in the range 0 to p - 1, inclusive.)
It turns out that f can actually be many different functions. Instead of finding a solution, Kevin wants you to count the number of distinct functions f that satisfy this equation. Since the answer may be very large, you should print your result modulo 109 + 7.
Input
The input consists of two space-separated integers p and k (3 ≤ p ≤ 1 000 000, 0 ≤ k ≤ p - 1) on a single line. It is guaranteed that p is an odd prime number.
Output
Print a single integer, the number of distinct functions f modulo 109 + 7.
Examples
Input
3 2
Output
3
Input
5 4
Output
25
Note
In the first sample, p = 3 and k = 2. The following functions work:
1. f(0) = 0, f(1) = 1, f(2) = 2.
2. f(0) = 0, f(1) = 2, f(2) = 1.
3. f(0) = f(1) = f(2) = 0. | instruction | 0 | 99,072 | 22 | 198,144 |
Tags: combinatorics, dfs and similar, dsu, math, number theory
Correct Solution:
```
def main():
p, k = map(int, input().split())
s = 1
m = pow(10,9)+7
if k == 0:
s = pow(p,p-1,m)
elif k == 1:
s = pow(p,p,m)
else:
o = 1
n = k
while n != 1:
n = k*n %p
o += 1
c = (p-1)//o
s = pow(p,c,m)
print(s%m)
main()
# Made By Mostafa_Khaled
``` | output | 1 | 99,072 | 22 | 198,145 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As behooves any intelligent schoolboy, Kevin Sun is studying psycowlogy, cowculus, and cryptcowgraphy at the Bovinia State University (BGU) under Farmer Ivan. During his Mathematics of Olympiads (MoO) class, Kevin was confronted with a weird functional equation and needs your help. For two fixed integers k and p, where p is an odd prime number, the functional equation states that
<image>
for some function <image>. (This equation should hold for any integer x in the range 0 to p - 1, inclusive.)
It turns out that f can actually be many different functions. Instead of finding a solution, Kevin wants you to count the number of distinct functions f that satisfy this equation. Since the answer may be very large, you should print your result modulo 109 + 7.
Input
The input consists of two space-separated integers p and k (3 ≤ p ≤ 1 000 000, 0 ≤ k ≤ p - 1) on a single line. It is guaranteed that p is an odd prime number.
Output
Print a single integer, the number of distinct functions f modulo 109 + 7.
Examples
Input
3 2
Output
3
Input
5 4
Output
25
Note
In the first sample, p = 3 and k = 2. The following functions work:
1. f(0) = 0, f(1) = 1, f(2) = 2.
2. f(0) = 0, f(1) = 2, f(2) = 1.
3. f(0) = f(1) = f(2) = 0. | instruction | 0 | 99,073 | 22 | 198,146 |
Tags: combinatorics, dfs and similar, dsu, math, number theory
Correct Solution:
```
def divisors(n):
ans = set()
i = 1
while i * i <= n:
if n % i == 0:
ans.add(i)
ans.add(n // i)
i += 1
return sorted(list(ans))
mod = 10 ** 9 + 7
p, k = [int(x) for x in input().split()]
if k == 0:
print(pow(p, p - 1, mod))
elif k == 1:
print(pow(p, p, mod))
else:
for z in divisors(p - 1):
if ((p - 1) % z == 0) and (pow(k, z, p) == 1):
print(pow(p, (p - 1) // z, mod))
break
``` | output | 1 | 99,073 | 22 | 198,147 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As behooves any intelligent schoolboy, Kevin Sun is studying psycowlogy, cowculus, and cryptcowgraphy at the Bovinia State University (BGU) under Farmer Ivan. During his Mathematics of Olympiads (MoO) class, Kevin was confronted with a weird functional equation and needs your help. For two fixed integers k and p, where p is an odd prime number, the functional equation states that
<image>
for some function <image>. (This equation should hold for any integer x in the range 0 to p - 1, inclusive.)
It turns out that f can actually be many different functions. Instead of finding a solution, Kevin wants you to count the number of distinct functions f that satisfy this equation. Since the answer may be very large, you should print your result modulo 109 + 7.
Input
The input consists of two space-separated integers p and k (3 ≤ p ≤ 1 000 000, 0 ≤ k ≤ p - 1) on a single line. It is guaranteed that p is an odd prime number.
Output
Print a single integer, the number of distinct functions f modulo 109 + 7.
Examples
Input
3 2
Output
3
Input
5 4
Output
25
Note
In the first sample, p = 3 and k = 2. The following functions work:
1. f(0) = 0, f(1) = 1, f(2) = 2.
2. f(0) = 0, f(1) = 2, f(2) = 1.
3. f(0) = f(1) = f(2) = 0. | instruction | 0 | 99,074 | 22 | 198,148 |
Tags: combinatorics, dfs and similar, dsu, math, number theory
Correct Solution:
```
from sys import stdin
c = 10**9+7
p, k = stdin.readline().rstrip().split(' ')
p = int(p); k = int(k)
if k==0:
print(pow(p, p-1, c))
elif k==1:
print(pow(p, p, c))
else:
n = k
order = 1
while n != 1:
n = (n*k) % p
order += 1
loops = (p-1) // order
print(pow(p, loops, c))
``` | output | 1 | 99,074 | 22 | 198,149 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As behooves any intelligent schoolboy, Kevin Sun is studying psycowlogy, cowculus, and cryptcowgraphy at the Bovinia State University (BGU) under Farmer Ivan. During his Mathematics of Olympiads (MoO) class, Kevin was confronted with a weird functional equation and needs your help. For two fixed integers k and p, where p is an odd prime number, the functional equation states that
<image>
for some function <image>. (This equation should hold for any integer x in the range 0 to p - 1, inclusive.)
It turns out that f can actually be many different functions. Instead of finding a solution, Kevin wants you to count the number of distinct functions f that satisfy this equation. Since the answer may be very large, you should print your result modulo 109 + 7.
Input
The input consists of two space-separated integers p and k (3 ≤ p ≤ 1 000 000, 0 ≤ k ≤ p - 1) on a single line. It is guaranteed that p is an odd prime number.
Output
Print a single integer, the number of distinct functions f modulo 109 + 7.
Examples
Input
3 2
Output
3
Input
5 4
Output
25
Note
In the first sample, p = 3 and k = 2. The following functions work:
1. f(0) = 0, f(1) = 1, f(2) = 2.
2. f(0) = 0, f(1) = 2, f(2) = 1.
3. f(0) = f(1) = f(2) = 0.
Submitted Solution:
```
p,k = map(int,input().split())
m = 10**9+7
if k == 0:
print(pow(p,p-1,m))
elif k == 1:
print(pow(p,p,m))
else:
used = [0]*p
res = 0
for i in range(1, p):
a = i
if used[a] == 0:
res += 1
while used[a] == 0:
used[a] = 1
a = k * a % p
print(pow(p, res, m))
``` | instruction | 0 | 99,075 | 22 | 198,150 |
Yes | output | 1 | 99,075 | 22 | 198,151 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As behooves any intelligent schoolboy, Kevin Sun is studying psycowlogy, cowculus, and cryptcowgraphy at the Bovinia State University (BGU) under Farmer Ivan. During his Mathematics of Olympiads (MoO) class, Kevin was confronted with a weird functional equation and needs your help. For two fixed integers k and p, where p is an odd prime number, the functional equation states that
<image>
for some function <image>. (This equation should hold for any integer x in the range 0 to p - 1, inclusive.)
It turns out that f can actually be many different functions. Instead of finding a solution, Kevin wants you to count the number of distinct functions f that satisfy this equation. Since the answer may be very large, you should print your result modulo 109 + 7.
Input
The input consists of two space-separated integers p and k (3 ≤ p ≤ 1 000 000, 0 ≤ k ≤ p - 1) on a single line. It is guaranteed that p is an odd prime number.
Output
Print a single integer, the number of distinct functions f modulo 109 + 7.
Examples
Input
3 2
Output
3
Input
5 4
Output
25
Note
In the first sample, p = 3 and k = 2. The following functions work:
1. f(0) = 0, f(1) = 1, f(2) = 2.
2. f(0) = 0, f(1) = 2, f(2) = 1.
3. f(0) = f(1) = f(2) = 0.
Submitted Solution:
```
def main():
p, k = map(int, input().split())
s = 1
m = pow(10,9)+7
if k == 0:
s = pow(p,p-1,m)
elif k == 1:
s = pow(p,p,m)
else:
o = 1
n = k
while n != 1:
n = k*n %p
o += 1
c = (p-1)//o
s = pow(p,c,m)
print(s%m)
main()
``` | instruction | 0 | 99,076 | 22 | 198,152 |
Yes | output | 1 | 99,076 | 22 | 198,153 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As behooves any intelligent schoolboy, Kevin Sun is studying psycowlogy, cowculus, and cryptcowgraphy at the Bovinia State University (BGU) under Farmer Ivan. During his Mathematics of Olympiads (MoO) class, Kevin was confronted with a weird functional equation and needs your help. For two fixed integers k and p, where p is an odd prime number, the functional equation states that
<image>
for some function <image>. (This equation should hold for any integer x in the range 0 to p - 1, inclusive.)
It turns out that f can actually be many different functions. Instead of finding a solution, Kevin wants you to count the number of distinct functions f that satisfy this equation. Since the answer may be very large, you should print your result modulo 109 + 7.
Input
The input consists of two space-separated integers p and k (3 ≤ p ≤ 1 000 000, 0 ≤ k ≤ p - 1) on a single line. It is guaranteed that p is an odd prime number.
Output
Print a single integer, the number of distinct functions f modulo 109 + 7.
Examples
Input
3 2
Output
3
Input
5 4
Output
25
Note
In the first sample, p = 3 and k = 2. The following functions work:
1. f(0) = 0, f(1) = 1, f(2) = 2.
2. f(0) = 0, f(1) = 2, f(2) = 1.
3. f(0) = f(1) = f(2) = 0.
Submitted Solution:
```
from sys import stdin
import sys
sys.setrecursionlimit(10**6)
n,k=map(int,stdin.readline().strip().split())
def dfs( n):
visited[n]=True
while not visited[adj[n]]:
n=adj[n]
visited[n]=True
mod=10**9+7
adj=[-1 for i in range(n+1)]
visited=[False for i in range(n+1)]
for i in range(n):
adj[i]=(i*k)%n
pairs=0
for i in range(1,n):
if not visited[i]:
dfs(i)
pairs+=1
if k==1:
print(pow(n,n,mod))
else:
print(pow(n,pairs,mod))
``` | instruction | 0 | 99,077 | 22 | 198,154 |
Yes | output | 1 | 99,077 | 22 | 198,155 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As behooves any intelligent schoolboy, Kevin Sun is studying psycowlogy, cowculus, and cryptcowgraphy at the Bovinia State University (BGU) under Farmer Ivan. During his Mathematics of Olympiads (MoO) class, Kevin was confronted with a weird functional equation and needs your help. For two fixed integers k and p, where p is an odd prime number, the functional equation states that
<image>
for some function <image>. (This equation should hold for any integer x in the range 0 to p - 1, inclusive.)
It turns out that f can actually be many different functions. Instead of finding a solution, Kevin wants you to count the number of distinct functions f that satisfy this equation. Since the answer may be very large, you should print your result modulo 109 + 7.
Input
The input consists of two space-separated integers p and k (3 ≤ p ≤ 1 000 000, 0 ≤ k ≤ p - 1) on a single line. It is guaranteed that p is an odd prime number.
Output
Print a single integer, the number of distinct functions f modulo 109 + 7.
Examples
Input
3 2
Output
3
Input
5 4
Output
25
Note
In the first sample, p = 3 and k = 2. The following functions work:
1. f(0) = 0, f(1) = 1, f(2) = 2.
2. f(0) = 0, f(1) = 2, f(2) = 1.
3. f(0) = f(1) = f(2) = 0.
Submitted Solution:
```
p, k = map(int, input().split())
M = 1000000007
if k == 0: print(pow(p, p - 1, M)), exit(0)
if k == 1: print(pow(p, p, M)), exit(0)
cnt, x = 0, 1
while 1:
cnt -= -1
x = (k * x) % p
if x == 1: break
print(pow(p, (p - 1) // cnt, M))
``` | instruction | 0 | 99,078 | 22 | 198,156 |
Yes | output | 1 | 99,078 | 22 | 198,157 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As behooves any intelligent schoolboy, Kevin Sun is studying psycowlogy, cowculus, and cryptcowgraphy at the Bovinia State University (BGU) under Farmer Ivan. During his Mathematics of Olympiads (MoO) class, Kevin was confronted with a weird functional equation and needs your help. For two fixed integers k and p, where p is an odd prime number, the functional equation states that
<image>
for some function <image>. (This equation should hold for any integer x in the range 0 to p - 1, inclusive.)
It turns out that f can actually be many different functions. Instead of finding a solution, Kevin wants you to count the number of distinct functions f that satisfy this equation. Since the answer may be very large, you should print your result modulo 109 + 7.
Input
The input consists of two space-separated integers p and k (3 ≤ p ≤ 1 000 000, 0 ≤ k ≤ p - 1) on a single line. It is guaranteed that p is an odd prime number.
Output
Print a single integer, the number of distinct functions f modulo 109 + 7.
Examples
Input
3 2
Output
3
Input
5 4
Output
25
Note
In the first sample, p = 3 and k = 2. The following functions work:
1. f(0) = 0, f(1) = 1, f(2) = 2.
2. f(0) = 0, f(1) = 2, f(2) = 1.
3. f(0) = f(1) = f(2) = 0.
Submitted Solution:
```
p, k = map(int, input().split())
a = [0 for i in range(p)]
count = 0
i = 0
NUM = 1000000007
def nextnum(i):
return i*k % p
while i<p:
while i<p and a[i]!=0:
i+=1
if i>=p:
break
count += 1
t = i
a[t] = count
t = nextnum(t)
a[t] = count
while t!=i and t!=0:
a[t] = count
t = nextnum(t)
ans = 1
for i in range(count-1):
ans = ans*p % NUM
print(ans)
``` | instruction | 0 | 99,079 | 22 | 198,158 |
No | output | 1 | 99,079 | 22 | 198,159 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As behooves any intelligent schoolboy, Kevin Sun is studying psycowlogy, cowculus, and cryptcowgraphy at the Bovinia State University (BGU) under Farmer Ivan. During his Mathematics of Olympiads (MoO) class, Kevin was confronted with a weird functional equation and needs your help. For two fixed integers k and p, where p is an odd prime number, the functional equation states that
<image>
for some function <image>. (This equation should hold for any integer x in the range 0 to p - 1, inclusive.)
It turns out that f can actually be many different functions. Instead of finding a solution, Kevin wants you to count the number of distinct functions f that satisfy this equation. Since the answer may be very large, you should print your result modulo 109 + 7.
Input
The input consists of two space-separated integers p and k (3 ≤ p ≤ 1 000 000, 0 ≤ k ≤ p - 1) on a single line. It is guaranteed that p is an odd prime number.
Output
Print a single integer, the number of distinct functions f modulo 109 + 7.
Examples
Input
3 2
Output
3
Input
5 4
Output
25
Note
In the first sample, p = 3 and k = 2. The following functions work:
1. f(0) = 0, f(1) = 1, f(2) = 2.
2. f(0) = 0, f(1) = 2, f(2) = 1.
3. f(0) = f(1) = f(2) = 0.
Submitted Solution:
```
from sys import stdin
p, k = stdin.readline().rstrip().split(' ')
p = int(p); k = int(k)
if k==0:
print(((p)**(p-1)) % (10**9+7))
else:
free = set(range(1, p))
loops = 0
while len(free) > 0:
n = free.pop()
l = (n*k)%p
while l != n:
free.remove(l)
l = (l*k) % p
loops += 1
print(p**loops % (10**9+7))
``` | instruction | 0 | 99,080 | 22 | 198,160 |
No | output | 1 | 99,080 | 22 | 198,161 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As behooves any intelligent schoolboy, Kevin Sun is studying psycowlogy, cowculus, and cryptcowgraphy at the Bovinia State University (BGU) under Farmer Ivan. During his Mathematics of Olympiads (MoO) class, Kevin was confronted with a weird functional equation and needs your help. For two fixed integers k and p, where p is an odd prime number, the functional equation states that
<image>
for some function <image>. (This equation should hold for any integer x in the range 0 to p - 1, inclusive.)
It turns out that f can actually be many different functions. Instead of finding a solution, Kevin wants you to count the number of distinct functions f that satisfy this equation. Since the answer may be very large, you should print your result modulo 109 + 7.
Input
The input consists of two space-separated integers p and k (3 ≤ p ≤ 1 000 000, 0 ≤ k ≤ p - 1) on a single line. It is guaranteed that p is an odd prime number.
Output
Print a single integer, the number of distinct functions f modulo 109 + 7.
Examples
Input
3 2
Output
3
Input
5 4
Output
25
Note
In the first sample, p = 3 and k = 2. The following functions work:
1. f(0) = 0, f(1) = 1, f(2) = 2.
2. f(0) = 0, f(1) = 2, f(2) = 1.
3. f(0) = f(1) = f(2) = 0.
Submitted Solution:
```
from fractions import gcd
from math import factorial
n,k = map(int,input().split())
if n==3:
print(3)
quit()
if n==5:
print(25)
if n==7:
print(49)
quit()
if n==11:
print((n-k)*factorial(n)+1)
``` | instruction | 0 | 99,081 | 22 | 198,162 |
No | output | 1 | 99,081 | 22 | 198,163 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As behooves any intelligent schoolboy, Kevin Sun is studying psycowlogy, cowculus, and cryptcowgraphy at the Bovinia State University (BGU) under Farmer Ivan. During his Mathematics of Olympiads (MoO) class, Kevin was confronted with a weird functional equation and needs your help. For two fixed integers k and p, where p is an odd prime number, the functional equation states that
<image>
for some function <image>. (This equation should hold for any integer x in the range 0 to p - 1, inclusive.)
It turns out that f can actually be many different functions. Instead of finding a solution, Kevin wants you to count the number of distinct functions f that satisfy this equation. Since the answer may be very large, you should print your result modulo 109 + 7.
Input
The input consists of two space-separated integers p and k (3 ≤ p ≤ 1 000 000, 0 ≤ k ≤ p - 1) on a single line. It is guaranteed that p is an odd prime number.
Output
Print a single integer, the number of distinct functions f modulo 109 + 7.
Examples
Input
3 2
Output
3
Input
5 4
Output
25
Note
In the first sample, p = 3 and k = 2. The following functions work:
1. f(0) = 0, f(1) = 1, f(2) = 2.
2. f(0) = 0, f(1) = 2, f(2) = 1.
3. f(0) = f(1) = f(2) = 0.
Submitted Solution:
```
from math import ceil
def pow(x, n):
"""stripping the number *sexy music*"""
BIG_CHONKUS_PRIME = 1e9+7
ret = 1
num = x
while n > 0:
if n % 2:
ret *= num
ret %= BIG_CHONKUS_PRIME
num *= num
num %= BIG_CHONKUS_PRIME
n = n // 2
return int(ret)
def moo(p, k):
"""moodular magic"""
if k == 0:
return pow(p, p-1)
if k == 1:
return pow(p, p)
m = 1
temp = k
while m <= p:
m += 1
if temp == 1:
break
temp *= k
temp %= p
x = ceil((p - 1)/m)
return pow(p, x)
def main():
"""I/O, you know, it's main"""
p, k = tuple(map(int, input().split()))
print(moo(p, k))
main()
``` | instruction | 0 | 99,082 | 22 | 198,164 |
No | output | 1 | 99,082 | 22 | 198,165 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Timofey likes integers a lot. Unfortunately, he is very young and can't work with very big integers, so he does all the operations modulo his favorite prime m. Also, Timofey likes to look for arithmetical progressions everywhere.
One of his birthday presents was a sequence of distinct integers a1, a2, ..., an. Timofey wants to know whether he can rearrange the elements of the sequence so that is will be an arithmetical progression modulo m, or not.
Arithmetical progression modulo m of length n with first element x and difference d is sequence of integers x, x + d, x + 2d, ..., x + (n - 1)·d, each taken modulo m.
Input
The first line contains two integers m and n (2 ≤ m ≤ 109 + 7, 1 ≤ n ≤ 105, m is prime) — Timofey's favorite prime module and the length of the sequence.
The second line contains n distinct integers a1, a2, ..., an (0 ≤ ai < m) — the elements of the sequence.
Output
Print -1 if it is not possible to rearrange the elements of the sequence so that is will be an arithmetical progression modulo m.
Otherwise, print two integers — the first element of the obtained progression x (0 ≤ x < m) and its difference d (0 ≤ d < m).
If there are multiple answers, print any of them.
Examples
Input
17 5
0 2 4 13 15
Output
13 2
Input
17 5
0 2 4 13 14
Output
-1
Input
5 3
1 2 3
Output
3 4 | instruction | 0 | 99,150 | 22 | 198,300 |
Tags: brute force, implementation, math, number theory
Correct Solution:
```
from functools import reduce
def gcd_extended(bigger, less):
if less == 0:
return(bigger, 1, 0)
mod = bigger % less
div = bigger // less
gcd, c_less, c_mod = gcd_extended(less, mod)
#gcd == c_less * less + c_mod * mod
#mod == bigger - div * less
#gcd = (c_less - c_mod * div) * less
# + c_mod * bigger
c_bigger = c_mod
c_less = c_less - c_mod * div
return(gcd, c_bigger, c_less)
def mlp_inverse(x, p):
one, c_p, c_x = gcd_extended(p, x) #one == c_x * x + c_p * p
return (c_x + p) % p
def tests(x, d, p, row):
_row = set(row)
n = len(row)
if d == 0:
return False
for i in range(n):
elem = x + i * d
elem = (elem % p + p) % p
if elem not in _row:
return False
return True
p, n = (int(x) for x in input().split())
row = [int(x) for x in input().split()]
if p == n:
print(1, 1)
exit()
if n == 1:
print(row[0], 0)
exit()
#precounting constants
c1 = reduce(lambda x, y: (x + y) % p, row, 0)
c2 = reduce(lambda x, y: (x + y * y) % p, row, 0)
sum_i = reduce(lambda x, y: (x + y) % p, range(0, n), 0)
sum_i_sq = reduce(lambda x, y: (x + y * y) % p, range(0, n), 0)
inv_sum_i = mlp_inverse(sum_i, p)
inv_sum_i_sq = mlp_inverse(sum_i_sq, p)
#algorythm
for x in row:
#
d = (c1 - n * x) * inv_sum_i
d = (d % p + p) % p
equasion = n * x * x + 2 * d * x * sum_i + d * d * sum_i_sq
equasion = (equasion % p + p) % p
# print(x, d)
# print(c2, equasion)
if (equasion == c2
and tests(x, d, p, row)
):
print(x, d)
exit()
print(-1)
``` | output | 1 | 99,150 | 22 | 198,301 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Timofey likes integers a lot. Unfortunately, he is very young and can't work with very big integers, so he does all the operations modulo his favorite prime m. Also, Timofey likes to look for arithmetical progressions everywhere.
One of his birthday presents was a sequence of distinct integers a1, a2, ..., an. Timofey wants to know whether he can rearrange the elements of the sequence so that is will be an arithmetical progression modulo m, or not.
Arithmetical progression modulo m of length n with first element x and difference d is sequence of integers x, x + d, x + 2d, ..., x + (n - 1)·d, each taken modulo m.
Input
The first line contains two integers m and n (2 ≤ m ≤ 109 + 7, 1 ≤ n ≤ 105, m is prime) — Timofey's favorite prime module and the length of the sequence.
The second line contains n distinct integers a1, a2, ..., an (0 ≤ ai < m) — the elements of the sequence.
Output
Print -1 if it is not possible to rearrange the elements of the sequence so that is will be an arithmetical progression modulo m.
Otherwise, print two integers — the first element of the obtained progression x (0 ≤ x < m) and its difference d (0 ≤ d < m).
If there are multiple answers, print any of them.
Examples
Input
17 5
0 2 4 13 15
Output
13 2
Input
17 5
0 2 4 13 14
Output
-1
Input
5 3
1 2 3
Output
3 4
Submitted Solution:
```
from functools import reduce
def gcd_extended(bigger, less):
if less == 0:
return(bigger, 1, 0)
mod = bigger % less
div = bigger // less
gcd, c_less, c_mod = gcd_extended(less, mod)
#gcd == c_less * less + c_mod * mod
#mod == bigger - div * less
#gcd = (c_less - c_mod * div) * less
# + c_mod * bigger
c_bigger = c_mod
c_less = c_less - c_mod * div
return(gcd, c_bigger, c_less)
def mlp_inverse(x, p):
one, c_p, c_x = gcd_extended(p, x) #one == c_x * x + c_p * p
return (c_x + p) % p
def tests(x, d, p, row):
_row = set(row)
n = len(row)
if d == 0:
return False
for i in range(n):
elem = x + i * d
elem = (elem % p + p) % p
if elem not in _row:
return False
return True
p, n = (int(x) for x in input().split())
row = [int(x) for x in input().split()]
#precounting constants
c1 = reduce(lambda x, y: (x + y) % p, row, 0)
c2 = reduce(lambda x, y: (x + y * y) % p, row, 0)
sum_i = reduce(lambda x, y: (x + y) % p, range(0, n), 0)
sum_i_sq = reduce(lambda x, y: (x + y * y) % p, range(0, n), 0)
inv_sum_i = mlp_inverse(sum_i, p)
inv_sum_i_sq = mlp_inverse(sum_i_sq, p)
#algorythm
for x in row:
#
d = (c1 - n * x) * inv_sum_i
d = (d % p + p) % p
equasion = n * x * x + 2 * d * sum_i + d * d * sum_i_sq
equasion = (equasion % p + p) % p
if (equasion == c2
and tests(x, d, p, row)
):
print(x, d)
break
print(-1)
``` | instruction | 0 | 99,151 | 22 | 198,302 |
No | output | 1 | 99,151 | 22 | 198,303 |
Provide a correct Python 3 solution for this coding contest problem.
For given integers m and n, compute mn (mod 1,000,000,007). Here, A (mod M) is the remainder when A is divided by M.
Constraints
* 1 ≤ m ≤ 100
* 1 ≤ n ≤ 109
Input
m n
Two integers m and n are given in a line.
Output
Print mn (mod 1,000,000,007) in a line.
Examples
Input
2 3
Output
8
Input
5 8
Output
390625 | instruction | 0 | 99,444 | 22 | 198,888 |
"Correct Solution:
```
def modpow(a,n,m):
res=1
while n>0:
if n&1:res=res*a%m
a=a*a%m
n//=2
return res
INF=10**9+7
n,m=map(int,input().split())
print(modpow(n,m,INF))
``` | output | 1 | 99,444 | 22 | 198,889 |
Provide a correct Python 3 solution for this coding contest problem.
For given integers m and n, compute mn (mod 1,000,000,007). Here, A (mod M) is the remainder when A is divided by M.
Constraints
* 1 ≤ m ≤ 100
* 1 ≤ n ≤ 109
Input
m n
Two integers m and n are given in a line.
Output
Print mn (mod 1,000,000,007) in a line.
Examples
Input
2 3
Output
8
Input
5 8
Output
390625 | instruction | 0 | 99,445 | 22 | 198,890 |
"Correct Solution:
```
import sys
input = sys.stdin.readline
P = 10 ** 9 + 7
def main():
M, N = map(int, input().split())
ans = pow(M, N, P)
print(ans)
if __name__ == "__main__":
main()
``` | output | 1 | 99,445 | 22 | 198,891 |
Provide a correct Python 3 solution for this coding contest problem.
For given integers m and n, compute mn (mod 1,000,000,007). Here, A (mod M) is the remainder when A is divided by M.
Constraints
* 1 ≤ m ≤ 100
* 1 ≤ n ≤ 109
Input
m n
Two integers m and n are given in a line.
Output
Print mn (mod 1,000,000,007) in a line.
Examples
Input
2 3
Output
8
Input
5 8
Output
390625 | instruction | 0 | 99,446 | 22 | 198,892 |
"Correct Solution:
```
print(int(pow(*map(int,input().split()),10**9+7)))
``` | output | 1 | 99,446 | 22 | 198,893 |
Provide a correct Python 3 solution for this coding contest problem.
For given integers m and n, compute mn (mod 1,000,000,007). Here, A (mod M) is the remainder when A is divided by M.
Constraints
* 1 ≤ m ≤ 100
* 1 ≤ n ≤ 109
Input
m n
Two integers m and n are given in a line.
Output
Print mn (mod 1,000,000,007) in a line.
Examples
Input
2 3
Output
8
Input
5 8
Output
390625 | instruction | 0 | 99,447 | 22 | 198,894 |
"Correct Solution:
```
def cal_expo(m, n, MOD):
if m == 1:
return 1
ans = 1
while n != 1:
if n % 2 != 0:
ans = (ans * m) % MOD
n //= 2
m = (m ** 2) % MOD
ans = (ans * m) % MOD
return ans
def main():
m, n = map(int, input().split())
MOD = 10 ** 9 + 7
ans = cal_expo(m, n, MOD)
print(ans)
if __name__ == '__main__':
main()
``` | output | 1 | 99,447 | 22 | 198,895 |
Provide a correct Python 3 solution for this coding contest problem.
For given integers m and n, compute mn (mod 1,000,000,007). Here, A (mod M) is the remainder when A is divided by M.
Constraints
* 1 ≤ m ≤ 100
* 1 ≤ n ≤ 109
Input
m n
Two integers m and n are given in a line.
Output
Print mn (mod 1,000,000,007) in a line.
Examples
Input
2 3
Output
8
Input
5 8
Output
390625 | instruction | 0 | 99,448 | 22 | 198,896 |
"Correct Solution:
```
m,n=map(int,input().split())
print(pow(m,n,1000000007))
``` | output | 1 | 99,448 | 22 | 198,897 |
Provide a correct Python 3 solution for this coding contest problem.
For given integers m and n, compute mn (mod 1,000,000,007). Here, A (mod M) is the remainder when A is divided by M.
Constraints
* 1 ≤ m ≤ 100
* 1 ≤ n ≤ 109
Input
m n
Two integers m and n are given in a line.
Output
Print mn (mod 1,000,000,007) in a line.
Examples
Input
2 3
Output
8
Input
5 8
Output
390625 | instruction | 0 | 99,449 | 22 | 198,898 |
"Correct Solution:
```
M = 10**9+7
def pow(x, n):
if n == 0:
return 1
res = pow(x * x % M, n//2)
if n % 2 == 1:
res = res * x % M
return res
if __name__ == "__main__":
m, n = map(int, input().split())
ans = pow(m, n)
print(ans)
``` | output | 1 | 99,449 | 22 | 198,899 |
Provide a correct Python 3 solution for this coding contest problem.
For given integers m and n, compute mn (mod 1,000,000,007). Here, A (mod M) is the remainder when A is divided by M.
Constraints
* 1 ≤ m ≤ 100
* 1 ≤ n ≤ 109
Input
m n
Two integers m and n are given in a line.
Output
Print mn (mod 1,000,000,007) in a line.
Examples
Input
2 3
Output
8
Input
5 8
Output
390625 | instruction | 0 | 99,450 | 22 | 198,900 |
"Correct Solution:
```
m, n = map(int, input().split())
print(pow(m, n, int(1e9) + 7))
``` | output | 1 | 99,450 | 22 | 198,901 |
Provide a correct Python 3 solution for this coding contest problem.
For given integers m and n, compute mn (mod 1,000,000,007). Here, A (mod M) is the remainder when A is divided by M.
Constraints
* 1 ≤ m ≤ 100
* 1 ≤ n ≤ 109
Input
m n
Two integers m and n are given in a line.
Output
Print mn (mod 1,000,000,007) in a line.
Examples
Input
2 3
Output
8
Input
5 8
Output
390625 | instruction | 0 | 99,451 | 22 | 198,902 |
"Correct Solution:
```
from functools import lru_cache
@lru_cache(maxsize=None)
def power(a, b):
res = 1
# print(a, b)
if b > 0:
res = power(a, b // 2)
if b % 2 == 0:
res = (res * res) % 1000000007
else:
res = (((res * res) % 1000000007) * a) % 1000000007
return res
m, n = map(int, input().split())
print(power(m, n))
``` | output | 1 | 99,451 | 22 | 198,903 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For given integers m and n, compute mn (mod 1,000,000,007). Here, A (mod M) is the remainder when A is divided by M.
Constraints
* 1 ≤ m ≤ 100
* 1 ≤ n ≤ 109
Input
m n
Two integers m and n are given in a line.
Output
Print mn (mod 1,000,000,007) in a line.
Examples
Input
2 3
Output
8
Input
5 8
Output
390625
Submitted Solution:
```
m, n= map(int, input().split())
p = 1000000007
a = pow(m, n, p)
print(a)
``` | instruction | 0 | 99,452 | 22 | 198,904 |
Yes | output | 1 | 99,452 | 22 | 198,905 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For given integers m and n, compute mn (mod 1,000,000,007). Here, A (mod M) is the remainder when A is divided by M.
Constraints
* 1 ≤ m ≤ 100
* 1 ≤ n ≤ 109
Input
m n
Two integers m and n are given in a line.
Output
Print mn (mod 1,000,000,007) in a line.
Examples
Input
2 3
Output
8
Input
5 8
Output
390625
Submitted Solution:
```
# coding: utf-8
m,n = map(int,input().split())
mod = 10 ** 9 + 7
ans = pow(m, n, mod)
print(ans)
``` | instruction | 0 | 99,453 | 22 | 198,906 |
Yes | output | 1 | 99,453 | 22 | 198,907 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For given integers m and n, compute mn (mod 1,000,000,007). Here, A (mod M) is the remainder when A is divided by M.
Constraints
* 1 ≤ m ≤ 100
* 1 ≤ n ≤ 109
Input
m n
Two integers m and n are given in a line.
Output
Print mn (mod 1,000,000,007) in a line.
Examples
Input
2 3
Output
8
Input
5 8
Output
390625
Submitted Solution:
```
import sys
mod = 1000000007
input = sys.stdin.readline
m,n=map(int,input().split())
print(pow(m,n,mod))
``` | instruction | 0 | 99,454 | 22 | 198,908 |
Yes | output | 1 | 99,454 | 22 | 198,909 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.