message stringlengths 2 57.2k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 61 108k | cluster float64 22 22 | __index_level_0__ int64 122 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kate has a set S of n integers \{1, ..., n\} .
She thinks that imperfection of a subset M ⊆ S is equal to the maximum of gcd(a, b) over all pairs (a, b) such that both a and b are in M and a ≠ b.
Kate is a very neat girl and for each k ∈ \{2, ..., n\} she wants to find a subset that has the smallest imperfection among all subsets in S of size k. There can be more than one subset with the smallest imperfection and the same size, but you don't need to worry about it. Kate wants to find all the subsets herself, but she needs your help to find the smallest possible imperfection for each size k, will name it I_k.
Please, help Kate to find I_2, I_3, ..., I_n.
Input
The first and only line in the input consists of only one integer n (2≤ n ≤ 5 ⋅ 10^5) — the size of the given set S.
Output
Output contains only one line that includes n - 1 integers: I_2, I_3, ..., I_n.
Examples
Input
2
Output
1
Input
3
Output
1 1
Note
First sample: answer is 1, because gcd(1, 2) = 1.
Second sample: there are subsets of S with sizes 2, 3 with imperfection equal to 1. For example, \{2,3\} and \{1, 2, 3\}.
Submitted Solution:
```
n = int(input())
print(*[1] * (n - 1))
``` | instruction | 0 | 89,436 | 22 | 178,872 |
No | output | 1 | 89,436 | 22 | 178,873 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kate has a set S of n integers \{1, ..., n\} .
She thinks that imperfection of a subset M ⊆ S is equal to the maximum of gcd(a, b) over all pairs (a, b) such that both a and b are in M and a ≠ b.
Kate is a very neat girl and for each k ∈ \{2, ..., n\} she wants to find a subset that has the smallest imperfection among all subsets in S of size k. There can be more than one subset with the smallest imperfection and the same size, but you don't need to worry about it. Kate wants to find all the subsets herself, but she needs your help to find the smallest possible imperfection for each size k, will name it I_k.
Please, help Kate to find I_2, I_3, ..., I_n.
Input
The first and only line in the input consists of only one integer n (2≤ n ≤ 5 ⋅ 10^5) — the size of the given set S.
Output
Output contains only one line that includes n - 1 integers: I_2, I_3, ..., I_n.
Examples
Input
2
Output
1
Input
3
Output
1 1
Note
First sample: answer is 1, because gcd(1, 2) = 1.
Second sample: there are subsets of S with sizes 2, 3 with imperfection equal to 1. For example, \{2,3\} and \{1, 2, 3\}.
Submitted Solution:
```
def main():
for _ in inputt(1):
n, = inputi()
S = [1] * (n + 1)
for i in range(2, n // 2 + 1):
for j in range(i * 2, n + 1, i):
S[j] = i
print(*S[2:])
# region M
# region fastio
import sys, io, os
BUFSIZE = 8192
class FastIO(io.IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = io.BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(io.IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
for x in args:
file.write(str(x))
file.write(kwargs.pop("end", "\n"))
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
# region import
inputt = lambda t = 0: range(t) if t else range(int(input()))
inputi = lambda: map(int, input().split())
inputl = lambda: list(inputi())
from math import *
from heapq import *
from bisect import *
from itertools import *
from functools import reduce, lru_cache
from collections import Counter, defaultdict
import re, copy, operator, cmath
from builtins import *
# endregion
# region main
if __name__ == "__main__":
main()
# endregion
# endregion
``` | instruction | 0 | 89,437 | 22 | 178,874 |
No | output | 1 | 89,437 | 22 | 178,875 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kate has a set S of n integers \{1, ..., n\} .
She thinks that imperfection of a subset M ⊆ S is equal to the maximum of gcd(a, b) over all pairs (a, b) such that both a and b are in M and a ≠ b.
Kate is a very neat girl and for each k ∈ \{2, ..., n\} she wants to find a subset that has the smallest imperfection among all subsets in S of size k. There can be more than one subset with the smallest imperfection and the same size, but you don't need to worry about it. Kate wants to find all the subsets herself, but she needs your help to find the smallest possible imperfection for each size k, will name it I_k.
Please, help Kate to find I_2, I_3, ..., I_n.
Input
The first and only line in the input consists of only one integer n (2≤ n ≤ 5 ⋅ 10^5) — the size of the given set S.
Output
Output contains only one line that includes n - 1 integers: I_2, I_3, ..., I_n.
Examples
Input
2
Output
1
Input
3
Output
1 1
Note
First sample: answer is 1, because gcd(1, 2) = 1.
Second sample: there are subsets of S with sizes 2, 3 with imperfection equal to 1. For example, \{2,3\} and \{1, 2, 3\}.
Submitted Solution:
```
n = int(input())
P = set()
for k in range(2, n + 1):
prime = True
for p in P:
if k % p == 0:
prime = False
break
if prime:
P.add(k)
ans = []
R = set()
for p in P:
ans.append(1)
R.add(p)
Q = []
for i in range(2, n // 2 + 1):
if i in P:
Q.append(i)
for q in Q:
if i * q <= n and i * q not in R:
ans.append(i)
R.add(i * q)
print(' '.join(map(str, ans)))
if (len(ans) == n - 1):
print('ok', file=__import__('sys').stderr)
``` | instruction | 0 | 89,438 | 22 | 178,876 |
No | output | 1 | 89,438 | 22 | 178,877 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three integers x, y and n. Your task is to find the maximum integer k such that 0 ≤ k ≤ n that k mod x = y, where mod is modulo operation. Many programming languages use percent operator % to implement it.
In other words, with given x, y and n you need to find the maximum possible integer from 0 to n that has the remainder y modulo x.
You have to answer t independent test cases. It is guaranteed that such k exists for each test case.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 5 ⋅ 10^4) — the number of test cases. The next t lines contain test cases.
The only line of the test case contains three integers x, y and n (2 ≤ x ≤ 10^9;~ 0 ≤ y < x;~ y ≤ n ≤ 10^9).
It can be shown that such k always exists under the given constraints.
Output
For each test case, print the answer — maximum non-negative integer k such that 0 ≤ k ≤ n and k mod x = y. It is guaranteed that the answer always exists.
Example
Input
7
7 5 12345
5 0 4
10 5 15
17 8 54321
499999993 9 1000000000
10 5 187
2 0 999999999
Output
12339
0
15
54306
999999995
185
999999998
Note
In the first test case of the example, the answer is 12339 = 7 ⋅ 1762 + 5 (thus, 12339 mod 7 = 5). It is obvious that there is no greater integer not exceeding 12345 which has the remainder 5 modulo 7. | instruction | 0 | 89,455 | 22 | 178,910 |
Tags: math
Correct Solution:
```
t = int(input())
for cases in range(t):
x, y, n = [int(i) for i in input().split()]
if n % x == y:
print(n)
else:
if y - (n % x) < 0:
k = n + y - (n % x)
else:
k = (n + y - (n % x)) - x
if k >= 0:
print(k)
else:
print(0)
``` | output | 1 | 89,455 | 22 | 178,911 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three integers x, y and n. Your task is to find the maximum integer k such that 0 ≤ k ≤ n that k mod x = y, where mod is modulo operation. Many programming languages use percent operator % to implement it.
In other words, with given x, y and n you need to find the maximum possible integer from 0 to n that has the remainder y modulo x.
You have to answer t independent test cases. It is guaranteed that such k exists for each test case.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 5 ⋅ 10^4) — the number of test cases. The next t lines contain test cases.
The only line of the test case contains three integers x, y and n (2 ≤ x ≤ 10^9;~ 0 ≤ y < x;~ y ≤ n ≤ 10^9).
It can be shown that such k always exists under the given constraints.
Output
For each test case, print the answer — maximum non-negative integer k such that 0 ≤ k ≤ n and k mod x = y. It is guaranteed that the answer always exists.
Example
Input
7
7 5 12345
5 0 4
10 5 15
17 8 54321
499999993 9 1000000000
10 5 187
2 0 999999999
Output
12339
0
15
54306
999999995
185
999999998
Note
In the first test case of the example, the answer is 12339 = 7 ⋅ 1762 + 5 (thus, 12339 mod 7 = 5). It is obvious that there is no greater integer not exceeding 12345 which has the remainder 5 modulo 7. | instruction | 0 | 89,456 | 22 | 178,912 |
Tags: math
Correct Solution:
```
from math import *
from itertools import *
from collections import *
def ii():
return int(input())
def mas():
return [int(i) for i in input().split()]
def mapis():
return map(int, input().split())
INF = 1e9 + 1
def solve():
x, y, n = mapis()
k = (n // x) * x
if k + y > n:
print(k - x + y)
else:
print(k + y)
def main():
# t = 1
t = ii()
while t:
solve()
t -= 1
main()
``` | output | 1 | 89,456 | 22 | 178,913 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three integers x, y and n. Your task is to find the maximum integer k such that 0 ≤ k ≤ n that k mod x = y, where mod is modulo operation. Many programming languages use percent operator % to implement it.
In other words, with given x, y and n you need to find the maximum possible integer from 0 to n that has the remainder y modulo x.
You have to answer t independent test cases. It is guaranteed that such k exists for each test case.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 5 ⋅ 10^4) — the number of test cases. The next t lines contain test cases.
The only line of the test case contains three integers x, y and n (2 ≤ x ≤ 10^9;~ 0 ≤ y < x;~ y ≤ n ≤ 10^9).
It can be shown that such k always exists under the given constraints.
Output
For each test case, print the answer — maximum non-negative integer k such that 0 ≤ k ≤ n and k mod x = y. It is guaranteed that the answer always exists.
Example
Input
7
7 5 12345
5 0 4
10 5 15
17 8 54321
499999993 9 1000000000
10 5 187
2 0 999999999
Output
12339
0
15
54306
999999995
185
999999998
Note
In the first test case of the example, the answer is 12339 = 7 ⋅ 1762 + 5 (thus, 12339 mod 7 = 5). It is obvious that there is no greater integer not exceeding 12345 which has the remainder 5 modulo 7. | instruction | 0 | 89,457 | 22 | 178,914 |
Tags: math
Correct Solution:
```
t=int(input())
for i in range(t):
x,y,n=map(int,input().split())
n-=y
n=n//x
n*=x
n+=y
print(n)
``` | output | 1 | 89,457 | 22 | 178,915 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three integers x, y and n. Your task is to find the maximum integer k such that 0 ≤ k ≤ n that k mod x = y, where mod is modulo operation. Many programming languages use percent operator % to implement it.
In other words, with given x, y and n you need to find the maximum possible integer from 0 to n that has the remainder y modulo x.
You have to answer t independent test cases. It is guaranteed that such k exists for each test case.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 5 ⋅ 10^4) — the number of test cases. The next t lines contain test cases.
The only line of the test case contains three integers x, y and n (2 ≤ x ≤ 10^9;~ 0 ≤ y < x;~ y ≤ n ≤ 10^9).
It can be shown that such k always exists under the given constraints.
Output
For each test case, print the answer — maximum non-negative integer k such that 0 ≤ k ≤ n and k mod x = y. It is guaranteed that the answer always exists.
Example
Input
7
7 5 12345
5 0 4
10 5 15
17 8 54321
499999993 9 1000000000
10 5 187
2 0 999999999
Output
12339
0
15
54306
999999995
185
999999998
Note
In the first test case of the example, the answer is 12339 = 7 ⋅ 1762 + 5 (thus, 12339 mod 7 = 5). It is obvious that there is no greater integer not exceeding 12345 which has the remainder 5 modulo 7. | instruction | 0 | 89,458 | 22 | 178,916 |
Tags: math
Correct Solution:
```
t = int(input())
for test in range(t):
x,y,n = [int(x) for x in input().split()]
z = n%x
req = y-z
if req<=0:
ans = n-abs(req)
else:
ans = n-x+abs(req)
print(ans)
``` | output | 1 | 89,458 | 22 | 178,917 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three integers x, y and n. Your task is to find the maximum integer k such that 0 ≤ k ≤ n that k mod x = y, where mod is modulo operation. Many programming languages use percent operator % to implement it.
In other words, with given x, y and n you need to find the maximum possible integer from 0 to n that has the remainder y modulo x.
You have to answer t independent test cases. It is guaranteed that such k exists for each test case.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 5 ⋅ 10^4) — the number of test cases. The next t lines contain test cases.
The only line of the test case contains three integers x, y and n (2 ≤ x ≤ 10^9;~ 0 ≤ y < x;~ y ≤ n ≤ 10^9).
It can be shown that such k always exists under the given constraints.
Output
For each test case, print the answer — maximum non-negative integer k such that 0 ≤ k ≤ n and k mod x = y. It is guaranteed that the answer always exists.
Example
Input
7
7 5 12345
5 0 4
10 5 15
17 8 54321
499999993 9 1000000000
10 5 187
2 0 999999999
Output
12339
0
15
54306
999999995
185
999999998
Note
In the first test case of the example, the answer is 12339 = 7 ⋅ 1762 + 5 (thus, 12339 mod 7 = 5). It is obvious that there is no greater integer not exceeding 12345 which has the remainder 5 modulo 7. | instruction | 0 | 89,459 | 22 | 178,918 |
Tags: math
Correct Solution:
```
n=int(input())
for _ in range(n):
x,y,n=map(int,input().split())
a=n%x
if(a-y>=0):
n=n-(a-y)
else:
n=n-a-x+y
print(n)
``` | output | 1 | 89,459 | 22 | 178,919 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three integers x, y and n. Your task is to find the maximum integer k such that 0 ≤ k ≤ n that k mod x = y, where mod is modulo operation. Many programming languages use percent operator % to implement it.
In other words, with given x, y and n you need to find the maximum possible integer from 0 to n that has the remainder y modulo x.
You have to answer t independent test cases. It is guaranteed that such k exists for each test case.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 5 ⋅ 10^4) — the number of test cases. The next t lines contain test cases.
The only line of the test case contains three integers x, y and n (2 ≤ x ≤ 10^9;~ 0 ≤ y < x;~ y ≤ n ≤ 10^9).
It can be shown that such k always exists under the given constraints.
Output
For each test case, print the answer — maximum non-negative integer k such that 0 ≤ k ≤ n and k mod x = y. It is guaranteed that the answer always exists.
Example
Input
7
7 5 12345
5 0 4
10 5 15
17 8 54321
499999993 9 1000000000
10 5 187
2 0 999999999
Output
12339
0
15
54306
999999995
185
999999998
Note
In the first test case of the example, the answer is 12339 = 7 ⋅ 1762 + 5 (thus, 12339 mod 7 = 5). It is obvious that there is no greater integer not exceeding 12345 which has the remainder 5 modulo 7. | instruction | 0 | 89,460 | 22 | 178,920 |
Tags: math
Correct Solution:
```
n = int(input())
results = []
for _ in range(n):
x, y, n = input().split()
x = int(x)
y = int(y)
n = int(n)
r = n % x
if r == y:
results.append(n)
elif r < y:
res = (n - x) + (y - r)
results.append(res)
elif r > y:
res = n - (r - y)
results.append(res)
for r in results:
print(r)
``` | output | 1 | 89,460 | 22 | 178,921 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three integers x, y and n. Your task is to find the maximum integer k such that 0 ≤ k ≤ n that k mod x = y, where mod is modulo operation. Many programming languages use percent operator % to implement it.
In other words, with given x, y and n you need to find the maximum possible integer from 0 to n that has the remainder y modulo x.
You have to answer t independent test cases. It is guaranteed that such k exists for each test case.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 5 ⋅ 10^4) — the number of test cases. The next t lines contain test cases.
The only line of the test case contains three integers x, y and n (2 ≤ x ≤ 10^9;~ 0 ≤ y < x;~ y ≤ n ≤ 10^9).
It can be shown that such k always exists under the given constraints.
Output
For each test case, print the answer — maximum non-negative integer k such that 0 ≤ k ≤ n and k mod x = y. It is guaranteed that the answer always exists.
Example
Input
7
7 5 12345
5 0 4
10 5 15
17 8 54321
499999993 9 1000000000
10 5 187
2 0 999999999
Output
12339
0
15
54306
999999995
185
999999998
Note
In the first test case of the example, the answer is 12339 = 7 ⋅ 1762 + 5 (thus, 12339 mod 7 = 5). It is obvious that there is no greater integer not exceeding 12345 which has the remainder 5 modulo 7. | instruction | 0 | 89,461 | 22 | 178,922 |
Tags: math
Correct Solution:
```
for _ in range(int(input())):
x,y,n=map(int,input().split())
f=((n-y)//x)*x + y
print(f)
``` | output | 1 | 89,461 | 22 | 178,923 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three integers x, y and n. Your task is to find the maximum integer k such that 0 ≤ k ≤ n that k mod x = y, where mod is modulo operation. Many programming languages use percent operator % to implement it.
In other words, with given x, y and n you need to find the maximum possible integer from 0 to n that has the remainder y modulo x.
You have to answer t independent test cases. It is guaranteed that such k exists for each test case.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 5 ⋅ 10^4) — the number of test cases. The next t lines contain test cases.
The only line of the test case contains three integers x, y and n (2 ≤ x ≤ 10^9;~ 0 ≤ y < x;~ y ≤ n ≤ 10^9).
It can be shown that such k always exists under the given constraints.
Output
For each test case, print the answer — maximum non-negative integer k such that 0 ≤ k ≤ n and k mod x = y. It is guaranteed that the answer always exists.
Example
Input
7
7 5 12345
5 0 4
10 5 15
17 8 54321
499999993 9 1000000000
10 5 187
2 0 999999999
Output
12339
0
15
54306
999999995
185
999999998
Note
In the first test case of the example, the answer is 12339 = 7 ⋅ 1762 + 5 (thus, 12339 mod 7 = 5). It is obvious that there is no greater integer not exceeding 12345 which has the remainder 5 modulo 7. | instruction | 0 | 89,462 | 22 | 178,924 |
Tags: math
Correct Solution:
```
for i in range(int(input())):
x,y,n=map(int,input().split())
k=n%x
if(k==y):
print(n)
# elif(n<x):
# print(0)
else:
if(k<y):
print(n-k-(x-y))
else:
print(n-(k-y))
``` | output | 1 | 89,462 | 22 | 178,925 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three integers x, y and n. Your task is to find the maximum integer k such that 0 ≤ k ≤ n that k mod x = y, where mod is modulo operation. Many programming languages use percent operator % to implement it.
In other words, with given x, y and n you need to find the maximum possible integer from 0 to n that has the remainder y modulo x.
You have to answer t independent test cases. It is guaranteed that such k exists for each test case.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 5 ⋅ 10^4) — the number of test cases. The next t lines contain test cases.
The only line of the test case contains three integers x, y and n (2 ≤ x ≤ 10^9;~ 0 ≤ y < x;~ y ≤ n ≤ 10^9).
It can be shown that such k always exists under the given constraints.
Output
For each test case, print the answer — maximum non-negative integer k such that 0 ≤ k ≤ n and k mod x = y. It is guaranteed that the answer always exists.
Example
Input
7
7 5 12345
5 0 4
10 5 15
17 8 54321
499999993 9 1000000000
10 5 187
2 0 999999999
Output
12339
0
15
54306
999999995
185
999999998
Note
In the first test case of the example, the answer is 12339 = 7 ⋅ 1762 + 5 (thus, 12339 mod 7 = 5). It is obvious that there is no greater integer not exceeding 12345 which has the remainder 5 modulo 7.
Submitted Solution:
```
t=int(input())
while t>0:
t-=1
x, y, n=[int(x) for x in input().split(" ")]
v = n - n%x
while v+y > n:
v-=x
print(v+y)
``` | instruction | 0 | 89,463 | 22 | 178,926 |
Yes | output | 1 | 89,463 | 22 | 178,927 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three integers x, y and n. Your task is to find the maximum integer k such that 0 ≤ k ≤ n that k mod x = y, where mod is modulo operation. Many programming languages use percent operator % to implement it.
In other words, with given x, y and n you need to find the maximum possible integer from 0 to n that has the remainder y modulo x.
You have to answer t independent test cases. It is guaranteed that such k exists for each test case.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 5 ⋅ 10^4) — the number of test cases. The next t lines contain test cases.
The only line of the test case contains three integers x, y and n (2 ≤ x ≤ 10^9;~ 0 ≤ y < x;~ y ≤ n ≤ 10^9).
It can be shown that such k always exists under the given constraints.
Output
For each test case, print the answer — maximum non-negative integer k such that 0 ≤ k ≤ n and k mod x = y. It is guaranteed that the answer always exists.
Example
Input
7
7 5 12345
5 0 4
10 5 15
17 8 54321
499999993 9 1000000000
10 5 187
2 0 999999999
Output
12339
0
15
54306
999999995
185
999999998
Note
In the first test case of the example, the answer is 12339 = 7 ⋅ 1762 + 5 (thus, 12339 mod 7 = 5). It is obvious that there is no greater integer not exceeding 12345 which has the remainder 5 modulo 7.
Submitted Solution:
```
t=int(input())
for i in range(0,t,1):
x,y,n=map(int,input().split())
s=int((n-y)/x)
sum=s*x+y
print(sum)
``` | instruction | 0 | 89,464 | 22 | 178,928 |
Yes | output | 1 | 89,464 | 22 | 178,929 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three integers x, y and n. Your task is to find the maximum integer k such that 0 ≤ k ≤ n that k mod x = y, where mod is modulo operation. Many programming languages use percent operator % to implement it.
In other words, with given x, y and n you need to find the maximum possible integer from 0 to n that has the remainder y modulo x.
You have to answer t independent test cases. It is guaranteed that such k exists for each test case.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 5 ⋅ 10^4) — the number of test cases. The next t lines contain test cases.
The only line of the test case contains three integers x, y and n (2 ≤ x ≤ 10^9;~ 0 ≤ y < x;~ y ≤ n ≤ 10^9).
It can be shown that such k always exists under the given constraints.
Output
For each test case, print the answer — maximum non-negative integer k such that 0 ≤ k ≤ n and k mod x = y. It is guaranteed that the answer always exists.
Example
Input
7
7 5 12345
5 0 4
10 5 15
17 8 54321
499999993 9 1000000000
10 5 187
2 0 999999999
Output
12339
0
15
54306
999999995
185
999999998
Note
In the first test case of the example, the answer is 12339 = 7 ⋅ 1762 + 5 (thus, 12339 mod 7 = 5). It is obvious that there is no greater integer not exceeding 12345 which has the remainder 5 modulo 7.
Submitted Solution:
```
for _ in range(int(input())):
x, y, n = map(int, input().split())
if n % x == y:
print(n)
else:
if n % x > y:
print(n - (n % x - y))
else:
print(n - x + (y - n % x))
``` | instruction | 0 | 89,465 | 22 | 178,930 |
Yes | output | 1 | 89,465 | 22 | 178,931 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three integers x, y and n. Your task is to find the maximum integer k such that 0 ≤ k ≤ n that k mod x = y, where mod is modulo operation. Many programming languages use percent operator % to implement it.
In other words, with given x, y and n you need to find the maximum possible integer from 0 to n that has the remainder y modulo x.
You have to answer t independent test cases. It is guaranteed that such k exists for each test case.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 5 ⋅ 10^4) — the number of test cases. The next t lines contain test cases.
The only line of the test case contains three integers x, y and n (2 ≤ x ≤ 10^9;~ 0 ≤ y < x;~ y ≤ n ≤ 10^9).
It can be shown that such k always exists under the given constraints.
Output
For each test case, print the answer — maximum non-negative integer k such that 0 ≤ k ≤ n and k mod x = y. It is guaranteed that the answer always exists.
Example
Input
7
7 5 12345
5 0 4
10 5 15
17 8 54321
499999993 9 1000000000
10 5 187
2 0 999999999
Output
12339
0
15
54306
999999995
185
999999998
Note
In the first test case of the example, the answer is 12339 = 7 ⋅ 1762 + 5 (thus, 12339 mod 7 = 5). It is obvious that there is no greater integer not exceeding 12345 which has the remainder 5 modulo 7.
Submitted Solution:
```
def ninja(x,y,n):
k=n%x
if k==y:
return n
elif k>y:
return n-(k-y)
else:
return n-k-(x-y)
for _ in range(int(input())):
x,y,n=map(int,input().split())
print(ninja(x,y,n))
``` | instruction | 0 | 89,466 | 22 | 178,932 |
Yes | output | 1 | 89,466 | 22 | 178,933 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three integers x, y and n. Your task is to find the maximum integer k such that 0 ≤ k ≤ n that k mod x = y, where mod is modulo operation. Many programming languages use percent operator % to implement it.
In other words, with given x, y and n you need to find the maximum possible integer from 0 to n that has the remainder y modulo x.
You have to answer t independent test cases. It is guaranteed that such k exists for each test case.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 5 ⋅ 10^4) — the number of test cases. The next t lines contain test cases.
The only line of the test case contains three integers x, y and n (2 ≤ x ≤ 10^9;~ 0 ≤ y < x;~ y ≤ n ≤ 10^9).
It can be shown that such k always exists under the given constraints.
Output
For each test case, print the answer — maximum non-negative integer k such that 0 ≤ k ≤ n and k mod x = y. It is guaranteed that the answer always exists.
Example
Input
7
7 5 12345
5 0 4
10 5 15
17 8 54321
499999993 9 1000000000
10 5 187
2 0 999999999
Output
12339
0
15
54306
999999995
185
999999998
Note
In the first test case of the example, the answer is 12339 = 7 ⋅ 1762 + 5 (thus, 12339 mod 7 = 5). It is obvious that there is no greater integer not exceeding 12345 which has the remainder 5 modulo 7.
Submitted Solution:
```
t=int(input())
i=0
for i in range(0,t):
x, y, n = [int(x) for x in input().split()]
ans=0
j=0
if (n-n%x+y<=n):
ans=n-n%x+y
else:
ans=n-n%x+(x-y)
print(ans)
``` | instruction | 0 | 89,467 | 22 | 178,934 |
No | output | 1 | 89,467 | 22 | 178,935 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three integers x, y and n. Your task is to find the maximum integer k such that 0 ≤ k ≤ n that k mod x = y, where mod is modulo operation. Many programming languages use percent operator % to implement it.
In other words, with given x, y and n you need to find the maximum possible integer from 0 to n that has the remainder y modulo x.
You have to answer t independent test cases. It is guaranteed that such k exists for each test case.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 5 ⋅ 10^4) — the number of test cases. The next t lines contain test cases.
The only line of the test case contains three integers x, y and n (2 ≤ x ≤ 10^9;~ 0 ≤ y < x;~ y ≤ n ≤ 10^9).
It can be shown that such k always exists under the given constraints.
Output
For each test case, print the answer — maximum non-negative integer k such that 0 ≤ k ≤ n and k mod x = y. It is guaranteed that the answer always exists.
Example
Input
7
7 5 12345
5 0 4
10 5 15
17 8 54321
499999993 9 1000000000
10 5 187
2 0 999999999
Output
12339
0
15
54306
999999995
185
999999998
Note
In the first test case of the example, the answer is 12339 = 7 ⋅ 1762 + 5 (thus, 12339 mod 7 = 5). It is obvious that there is no greater integer not exceeding 12345 which has the remainder 5 modulo 7.
Submitted Solution:
```
t=int(input())
for i in range(t):
x,y,n=map(int,input().split())
z=n//x
a=(z*x)+y
print(a)
``` | instruction | 0 | 89,468 | 22 | 178,936 |
No | output | 1 | 89,468 | 22 | 178,937 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three integers x, y and n. Your task is to find the maximum integer k such that 0 ≤ k ≤ n that k mod x = y, where mod is modulo operation. Many programming languages use percent operator % to implement it.
In other words, with given x, y and n you need to find the maximum possible integer from 0 to n that has the remainder y modulo x.
You have to answer t independent test cases. It is guaranteed that such k exists for each test case.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 5 ⋅ 10^4) — the number of test cases. The next t lines contain test cases.
The only line of the test case contains three integers x, y and n (2 ≤ x ≤ 10^9;~ 0 ≤ y < x;~ y ≤ n ≤ 10^9).
It can be shown that such k always exists under the given constraints.
Output
For each test case, print the answer — maximum non-negative integer k such that 0 ≤ k ≤ n and k mod x = y. It is guaranteed that the answer always exists.
Example
Input
7
7 5 12345
5 0 4
10 5 15
17 8 54321
499999993 9 1000000000
10 5 187
2 0 999999999
Output
12339
0
15
54306
999999995
185
999999998
Note
In the first test case of the example, the answer is 12339 = 7 ⋅ 1762 + 5 (thus, 12339 mod 7 = 5). It is obvious that there is no greater integer not exceeding 12345 which has the remainder 5 modulo 7.
Submitted Solution:
```
for i in range(int(input())):
x, y, n = [int(i) for i in input().split(" ")]
temp = 0
for i in range(int(n/x)+1, 0, -1):
if i*x + y <= n:
print(i*x+y)
temp = 1
break
if temp == 0:
print(0)
``` | instruction | 0 | 89,469 | 22 | 178,938 |
No | output | 1 | 89,469 | 22 | 178,939 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three integers x, y and n. Your task is to find the maximum integer k such that 0 ≤ k ≤ n that k mod x = y, where mod is modulo operation. Many programming languages use percent operator % to implement it.
In other words, with given x, y and n you need to find the maximum possible integer from 0 to n that has the remainder y modulo x.
You have to answer t independent test cases. It is guaranteed that such k exists for each test case.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 5 ⋅ 10^4) — the number of test cases. The next t lines contain test cases.
The only line of the test case contains three integers x, y and n (2 ≤ x ≤ 10^9;~ 0 ≤ y < x;~ y ≤ n ≤ 10^9).
It can be shown that such k always exists under the given constraints.
Output
For each test case, print the answer — maximum non-negative integer k such that 0 ≤ k ≤ n and k mod x = y. It is guaranteed that the answer always exists.
Example
Input
7
7 5 12345
5 0 4
10 5 15
17 8 54321
499999993 9 1000000000
10 5 187
2 0 999999999
Output
12339
0
15
54306
999999995
185
999999998
Note
In the first test case of the example, the answer is 12339 = 7 ⋅ 1762 + 5 (thus, 12339 mod 7 = 5). It is obvious that there is no greater integer not exceeding 12345 which has the remainder 5 modulo 7.
Submitted Solution:
```
ans = []
for i in range(int(input())):
x,y,n = list(map(int,input().split()))
for k in range(n,1,-1):
if(k%x==y):
ans.append(k)
break
for a in ans:
print(a)
``` | instruction | 0 | 89,470 | 22 | 178,940 |
No | output | 1 | 89,470 | 22 | 178,941 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer x. Check whether the number x is representable as the sum of the cubes of two positive integers.
Formally, you need to check if there are two integers a and b (1 ≤ a, b) such that a^3+b^3=x.
For example, if x = 35, then the numbers a=2 and b=3 are suitable (2^3+3^3=8+27=35). If x=4, then no pair of numbers a and b is suitable.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case contains one integer x (1 ≤ x ≤ 10^{12}).
Please note, that the input for some test cases won't fit into 32-bit integer type, so you should use at least 64-bit integer type in your programming language.
Output
For each test case, output on a separate line:
* "YES" if x is representable as the sum of the cubes of two positive integers.
* "NO" otherwise.
You can output "YES" and "NO" in any case (for example, the strings yEs, yes, Yes and YES will be recognized as positive).
Example
Input
7
1
2
4
34
35
16
703657519796
Output
NO
YES
NO
NO
YES
YES
YES
Note
The number 1 is not representable as the sum of two cubes.
The number 2 is represented as 1^3+1^3.
The number 4 is not representable as the sum of two cubes.
The number 34 is not representable as the sum of two cubes.
The number 35 is represented as 2^3+3^3.
The number 16 is represented as 2^3+2^3.
The number 703657519796 is represented as 5779^3+7993^3. | instruction | 0 | 89,528 | 22 | 179,056 |
Tags: binary search, brute force, brute force, math
Correct Solution:
```
# def SieveOfEratosthenes(n):
# prime = [True for i in range(n+1)]
# p = 2
# while (p * p <= n):
# if (prime[p] == True):
# for i in range(p * p, n+1, p):
# prime[i] = False
# p += 1
# for p in range(2, n+1):
# if prime[p]:
# l.append(p)
# l=[]
# SieveOfEratosthenes(2*19999909)
def s(x):
di = dict()
for i in range(1, 10000):
di[i*i*i] = 1
for i in range(1, 10000):
y = x - i*i*i
t = di.get(y, 0)
if t:
return True
return False
return False
def solve():
n=int(input())
#a,b=list(map (int,input ().split()))
#a=list(map (int,input ().split()))
#b=list(map (int,input ().split()))
if s(n):
print("YES")
else:
print("NO")
for _ in range (int(input())):
solve()
``` | output | 1 | 89,528 | 22 | 179,057 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer x. Check whether the number x is representable as the sum of the cubes of two positive integers.
Formally, you need to check if there are two integers a and b (1 ≤ a, b) such that a^3+b^3=x.
For example, if x = 35, then the numbers a=2 and b=3 are suitable (2^3+3^3=8+27=35). If x=4, then no pair of numbers a and b is suitable.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case contains one integer x (1 ≤ x ≤ 10^{12}).
Please note, that the input for some test cases won't fit into 32-bit integer type, so you should use at least 64-bit integer type in your programming language.
Output
For each test case, output on a separate line:
* "YES" if x is representable as the sum of the cubes of two positive integers.
* "NO" otherwise.
You can output "YES" and "NO" in any case (for example, the strings yEs, yes, Yes and YES will be recognized as positive).
Example
Input
7
1
2
4
34
35
16
703657519796
Output
NO
YES
NO
NO
YES
YES
YES
Note
The number 1 is not representable as the sum of two cubes.
The number 2 is represented as 1^3+1^3.
The number 4 is not representable as the sum of two cubes.
The number 34 is not representable as the sum of two cubes.
The number 35 is represented as 2^3+3^3.
The number 16 is represented as 2^3+2^3.
The number 703657519796 is represented as 5779^3+7993^3. | instruction | 0 | 89,529 | 22 | 179,058 |
Tags: binary search, brute force, brute force, math
Correct Solution:
```
for i in range(int(input())):
n = int(input())
j = 1
works = False
while (not j*j*j > n):
aux = n-j**3
if(int(round(aux**(1./3))**3) == aux):
if(not aux == 0):
works = True
break
j += 1
if works:
print("YES")
else:
print("NO")
``` | output | 1 | 89,529 | 22 | 179,059 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer x. Check whether the number x is representable as the sum of the cubes of two positive integers.
Formally, you need to check if there are two integers a and b (1 ≤ a, b) such that a^3+b^3=x.
For example, if x = 35, then the numbers a=2 and b=3 are suitable (2^3+3^3=8+27=35). If x=4, then no pair of numbers a and b is suitable.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case contains one integer x (1 ≤ x ≤ 10^{12}).
Please note, that the input for some test cases won't fit into 32-bit integer type, so you should use at least 64-bit integer type in your programming language.
Output
For each test case, output on a separate line:
* "YES" if x is representable as the sum of the cubes of two positive integers.
* "NO" otherwise.
You can output "YES" and "NO" in any case (for example, the strings yEs, yes, Yes and YES will be recognized as positive).
Example
Input
7
1
2
4
34
35
16
703657519796
Output
NO
YES
NO
NO
YES
YES
YES
Note
The number 1 is not representable as the sum of two cubes.
The number 2 is represented as 1^3+1^3.
The number 4 is not representable as the sum of two cubes.
The number 34 is not representable as the sum of two cubes.
The number 35 is represented as 2^3+3^3.
The number 16 is represented as 2^3+2^3.
The number 703657519796 is represented as 5779^3+7993^3. | instruction | 0 | 89,530 | 22 | 179,060 |
Tags: binary search, brute force, brute force, math
Correct Solution:
```
# region fastio
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
def main():
s={pow(i,3):None for i in range(1,10000)}
for _ in range(int(input())):
n=int(input())
f=1
lim = int(pow(n, 1 / 3)) + 1
for i in range(1, lim):
b = n - pow(i, 3)
if b > 0 and b in s:
print('YES')
f=0
break
if f:
print('NO')
return
if __name__ == '__main__':
main()
``` | output | 1 | 89,530 | 22 | 179,061 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer x. Check whether the number x is representable as the sum of the cubes of two positive integers.
Formally, you need to check if there are two integers a and b (1 ≤ a, b) such that a^3+b^3=x.
For example, if x = 35, then the numbers a=2 and b=3 are suitable (2^3+3^3=8+27=35). If x=4, then no pair of numbers a and b is suitable.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case contains one integer x (1 ≤ x ≤ 10^{12}).
Please note, that the input for some test cases won't fit into 32-bit integer type, so you should use at least 64-bit integer type in your programming language.
Output
For each test case, output on a separate line:
* "YES" if x is representable as the sum of the cubes of two positive integers.
* "NO" otherwise.
You can output "YES" and "NO" in any case (for example, the strings yEs, yes, Yes and YES will be recognized as positive).
Example
Input
7
1
2
4
34
35
16
703657519796
Output
NO
YES
NO
NO
YES
YES
YES
Note
The number 1 is not representable as the sum of two cubes.
The number 2 is represented as 1^3+1^3.
The number 4 is not representable as the sum of two cubes.
The number 34 is not representable as the sum of two cubes.
The number 35 is represented as 2^3+3^3.
The number 16 is represented as 2^3+2^3.
The number 703657519796 is represented as 5779^3+7993^3. | instruction | 0 | 89,531 | 22 | 179,062 |
Tags: binary search, brute force, brute force, math
Correct Solution:
```
def get_t():
s = set()
for i in range(1,10000):
s.add(i*i*i)
return s
def solve():
pass
n = int(input())
f = 0
for i in cube_set:
if n-i in cube_set:
print("YES")
f = 1
break
if not f:
print("NO")
T = int(input())
cube_set = get_t()
while(T):
T-=1
solve()
# a = list(map(int,input().split(' ')))
# a,b = a[0], a[1]
``` | output | 1 | 89,531 | 22 | 179,063 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer x. Check whether the number x is representable as the sum of the cubes of two positive integers.
Formally, you need to check if there are two integers a and b (1 ≤ a, b) such that a^3+b^3=x.
For example, if x = 35, then the numbers a=2 and b=3 are suitable (2^3+3^3=8+27=35). If x=4, then no pair of numbers a and b is suitable.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case contains one integer x (1 ≤ x ≤ 10^{12}).
Please note, that the input for some test cases won't fit into 32-bit integer type, so you should use at least 64-bit integer type in your programming language.
Output
For each test case, output on a separate line:
* "YES" if x is representable as the sum of the cubes of two positive integers.
* "NO" otherwise.
You can output "YES" and "NO" in any case (for example, the strings yEs, yes, Yes and YES will be recognized as positive).
Example
Input
7
1
2
4
34
35
16
703657519796
Output
NO
YES
NO
NO
YES
YES
YES
Note
The number 1 is not representable as the sum of two cubes.
The number 2 is represented as 1^3+1^3.
The number 4 is not representable as the sum of two cubes.
The number 34 is not representable as the sum of two cubes.
The number 35 is represented as 2^3+3^3.
The number 16 is represented as 2^3+2^3.
The number 703657519796 is represented as 5779^3+7993^3. | instruction | 0 | 89,532 | 22 | 179,064 |
Tags: binary search, brute force, brute force, math
Correct Solution:
```
import math as mt
def is_perfect_cube(x):
x = abs(x)
return int(round(x ** (1. / 3))) ** 3 == x
for _ in range(int(input())):
a = int(input())
flag = 0
for i in range(1,10001):
b = a - (i**3)
if(b<1):
continue
if(is_perfect_cube(b) == True):
print("YES")
flag = 1
break
if(flag == 0):
print("NO")
``` | output | 1 | 89,532 | 22 | 179,065 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer x. Check whether the number x is representable as the sum of the cubes of two positive integers.
Formally, you need to check if there are two integers a and b (1 ≤ a, b) such that a^3+b^3=x.
For example, if x = 35, then the numbers a=2 and b=3 are suitable (2^3+3^3=8+27=35). If x=4, then no pair of numbers a and b is suitable.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case contains one integer x (1 ≤ x ≤ 10^{12}).
Please note, that the input for some test cases won't fit into 32-bit integer type, so you should use at least 64-bit integer type in your programming language.
Output
For each test case, output on a separate line:
* "YES" if x is representable as the sum of the cubes of two positive integers.
* "NO" otherwise.
You can output "YES" and "NO" in any case (for example, the strings yEs, yes, Yes and YES will be recognized as positive).
Example
Input
7
1
2
4
34
35
16
703657519796
Output
NO
YES
NO
NO
YES
YES
YES
Note
The number 1 is not representable as the sum of two cubes.
The number 2 is represented as 1^3+1^3.
The number 4 is not representable as the sum of two cubes.
The number 34 is not representable as the sum of two cubes.
The number 35 is represented as 2^3+3^3.
The number 16 is represented as 2^3+2^3.
The number 703657519796 is represented as 5779^3+7993^3. | instruction | 0 | 89,533 | 22 | 179,066 |
Tags: binary search, brute force, brute force, math
Correct Solution:
```
'''
* Author : Ayushman Chahar #
* About : IT Sophomore #
* Insti : VIT, Vellore #
'''
import os
import sys
from collections import defaultdict
# from itertools import *
from math import ceil
# from queue import *
# from heapq import *
# from bisect import *
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
readint = lambda: int(sys.stdin.readline().rstrip("\r\n"))
readints = lambda: map(int, sys.stdin.readline().rstrip("\r\n").split())
readstr = lambda: sys.stdin.readline().rstrip("\r\n")
readstrs = lambda: map(str, sys.stdin.readline().rstrip("\r\n").split())
readarri = lambda: [int(_) for _ in sys.stdin.readline().rstrip("\r\n").split()]
readarrs = lambda: [str(_) for _ in sys.stdin.readline().rstrip("\r\n").split()]
mod = 998244353
MOD = int(1e9) + 7
N = int(1e12)
stores = [i * i * i for i in range(1, int(N ** (1 / 3)) + 1)]
mapp = defaultdict(int)
for i in stores:
mapp[i] = 1
def solve():
n = readint()
for i in stores:
if(mapp[n - i]):
print("YES")
return
print("NO")
def main():
t = 1
t = readint()
for _ in range(t):
# print("Case #" + str(_ + 1) + ": ", end="")
solve()
if __name__ == "__main__":
main()
``` | output | 1 | 89,533 | 22 | 179,067 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer x. Check whether the number x is representable as the sum of the cubes of two positive integers.
Formally, you need to check if there are two integers a and b (1 ≤ a, b) such that a^3+b^3=x.
For example, if x = 35, then the numbers a=2 and b=3 are suitable (2^3+3^3=8+27=35). If x=4, then no pair of numbers a and b is suitable.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case contains one integer x (1 ≤ x ≤ 10^{12}).
Please note, that the input for some test cases won't fit into 32-bit integer type, so you should use at least 64-bit integer type in your programming language.
Output
For each test case, output on a separate line:
* "YES" if x is representable as the sum of the cubes of two positive integers.
* "NO" otherwise.
You can output "YES" and "NO" in any case (for example, the strings yEs, yes, Yes and YES will be recognized as positive).
Example
Input
7
1
2
4
34
35
16
703657519796
Output
NO
YES
NO
NO
YES
YES
YES
Note
The number 1 is not representable as the sum of two cubes.
The number 2 is represented as 1^3+1^3.
The number 4 is not representable as the sum of two cubes.
The number 34 is not representable as the sum of two cubes.
The number 35 is represented as 2^3+3^3.
The number 16 is represented as 2^3+2^3.
The number 703657519796 is represented as 5779^3+7993^3. | instruction | 0 | 89,534 | 22 | 179,068 |
Tags: binary search, brute force, brute force, math
Correct Solution:
```
import sys
inputlines=sys.stdin.readlines()
number_of_testcases=int(inputlines[0])
N=10**12
def make_cube_root_set():
cube_root_set=set()
i=1
cube=i**3
while(cube<N):
cube_root_set.add(cube)
i+=1
cube=i**3
return cube_root_set
for i in range(number_of_testcases):
possible_sum_of_cubes=int(inputlines[i+1])
j=1
cube=j**3
cube_root_set=make_cube_root_set()
while(cube<possible_sum_of_cubes):
if possible_sum_of_cubes-cube in cube_root_set:
print('YES')
break
j+=1
cube=j**3
if cube>=possible_sum_of_cubes:
print('NO')
'''
#This approach failed because for big numbers, cube root cannot be exactly calculated
#Failed for the case 703657519796
for i in range(number_of_testcases):
possible_sum_of_cubes=int(inputlines[i+1])
print('possible_sum_of_cubes',possible_sum_of_cubes)
cube_root_of_possible_sums_of_cubes=int(possible_sum_of_cubes**(1/3))
print('cube_root_of_possible_sums_of_cubes',cube_root_of_possible_sums_of_cubes)
for i in range(1,cube_root_of_possible_sums_of_cubes+1):
print(i)
b=possible_sum_of_cubes-i**3
print(b)
b=b**(1/3)
print('b',b)
if b==(b//1)*1.0 and b>=1:
print('YES')
break
else:
print('NO')
'''
``` | output | 1 | 89,534 | 22 | 179,069 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer x. Check whether the number x is representable as the sum of the cubes of two positive integers.
Formally, you need to check if there are two integers a and b (1 ≤ a, b) such that a^3+b^3=x.
For example, if x = 35, then the numbers a=2 and b=3 are suitable (2^3+3^3=8+27=35). If x=4, then no pair of numbers a and b is suitable.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case contains one integer x (1 ≤ x ≤ 10^{12}).
Please note, that the input for some test cases won't fit into 32-bit integer type, so you should use at least 64-bit integer type in your programming language.
Output
For each test case, output on a separate line:
* "YES" if x is representable as the sum of the cubes of two positive integers.
* "NO" otherwise.
You can output "YES" and "NO" in any case (for example, the strings yEs, yes, Yes and YES will be recognized as positive).
Example
Input
7
1
2
4
34
35
16
703657519796
Output
NO
YES
NO
NO
YES
YES
YES
Note
The number 1 is not representable as the sum of two cubes.
The number 2 is represented as 1^3+1^3.
The number 4 is not representable as the sum of two cubes.
The number 34 is not representable as the sum of two cubes.
The number 35 is represented as 2^3+3^3.
The number 16 is represented as 2^3+2^3.
The number 703657519796 is represented as 5779^3+7993^3. | instruction | 0 | 89,535 | 22 | 179,070 |
Tags: binary search, brute force, brute force, math
Correct Solution:
```
for cases in range(int(input())):
x = int(input())
if x == 2:
print("yes")
continue
i = 1
myset = set()
found = False
while i * i * i < x:
cube = i * i * i
if x - cube in myset or x == 2 * cube:
print("yes")
found = True
break
else:
myset.add(cube)
i += 1
if not found :
print("no")
``` | output | 1 | 89,535 | 22 | 179,071 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Jzzhu has picked n apples from his big apple tree. All the apples are numbered from 1 to n. Now he wants to sell them to an apple store.
Jzzhu will pack his apples into groups and then sell them. Each group must contain two apples, and the greatest common divisor of numbers of the apples in each group must be greater than 1. Of course, each apple can be part of at most one group.
Jzzhu wonders how to get the maximum possible number of groups. Can you help him?
Input
A single integer n (1 ≤ n ≤ 105), the number of the apples.
Output
The first line must contain a single integer m, representing the maximum number of groups he can get. Each of the next m lines must contain two integers — the numbers of apples in the current group.
If there are several optimal answers you can print any of them.
Examples
Input
6
Output
2
6 3
2 4
Input
9
Output
3
9 3
2 4
6 8
Input
2
Output
0 | instruction | 0 | 89,651 | 22 | 179,302 |
Tags: constructive algorithms, number theory
Correct Solution:
```
apples=int(input())
if apples<=3:
print(0)
else:
halfpr=int(apples/2)
def primes(n):
isPrime = [True for i in range(n + 1)]
isPrime[0] = isPrime[1] = False
idx = 2
while idx * idx <= n:
if isPrime[idx]:
for i in range(idx * 2, n, idx):
isPrime[i] = False
idx += 1
return isPrime
primeslist=primes(halfpr)
totallist=[False]*(apples+1)
applepairs=[]
for prime in range(len(primeslist)-1, 1, -1):
if primeslist[prime]:
numprimes=int(apples/prime)
primesx=[int(i*prime) for i in range(1, numprimes+1) if not totallist[i*prime]]
if len(primesx)%2==1:
primesx.remove(2*prime)
for pr in primesx:
applepairs.append(pr)
totallist[pr]=True
print(int(len(applepairs)/2))
for t in range(int(len(applepairs)/2)):
print(applepairs[2*t], applepairs[2*t+1])
``` | output | 1 | 89,651 | 22 | 179,303 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Jzzhu has picked n apples from his big apple tree. All the apples are numbered from 1 to n. Now he wants to sell them to an apple store.
Jzzhu will pack his apples into groups and then sell them. Each group must contain two apples, and the greatest common divisor of numbers of the apples in each group must be greater than 1. Of course, each apple can be part of at most one group.
Jzzhu wonders how to get the maximum possible number of groups. Can you help him?
Input
A single integer n (1 ≤ n ≤ 105), the number of the apples.
Output
The first line must contain a single integer m, representing the maximum number of groups he can get. Each of the next m lines must contain two integers — the numbers of apples in the current group.
If there are several optimal answers you can print any of them.
Examples
Input
6
Output
2
6 3
2 4
Input
9
Output
3
9 3
2 4
6 8
Input
2
Output
0 | instruction | 0 | 89,652 | 22 | 179,304 |
Tags: constructive algorithms, number theory
Correct Solution:
```
apples=int(input())
if apples<=3:
print(0)
else:
halfpr=int(apples/2)
def primes(n):
isPrime = [True for i in range(n + 1)]
isPrime[0] = isPrime[1] = False
idx = 2
while idx * idx <= n:
if isPrime[idx]:
for i in range(idx * 2, n, idx):
isPrime[i] = False
idx += 1
return isPrime
primeslist=primes(halfpr)
totallist=[False]*(apples+1)
applepairs=[]
for prime in range(len(primeslist)-1, 1, -1):
if primeslist[prime]:
numprimes=int(apples/prime)
primesx=[int(i*prime) for i in range(1, numprimes+1) if not totallist[i*prime]]
if len(primesx)%2==1:
primesx.remove(2*prime)
for pr in primesx:
applepairs.append(pr)
totallist[pr]=True
print(int(len(applepairs)/2))
for t in range(int(len(applepairs)/2)):
print(applepairs[2*t], applepairs[2*t+1])
# Made By Mostafa_Khaled
``` | output | 1 | 89,652 | 22 | 179,305 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Jzzhu has picked n apples from his big apple tree. All the apples are numbered from 1 to n. Now he wants to sell them to an apple store.
Jzzhu will pack his apples into groups and then sell them. Each group must contain two apples, and the greatest common divisor of numbers of the apples in each group must be greater than 1. Of course, each apple can be part of at most one group.
Jzzhu wonders how to get the maximum possible number of groups. Can you help him?
Input
A single integer n (1 ≤ n ≤ 105), the number of the apples.
Output
The first line must contain a single integer m, representing the maximum number of groups he can get. Each of the next m lines must contain two integers — the numbers of apples in the current group.
If there are several optimal answers you can print any of them.
Examples
Input
6
Output
2
6 3
2 4
Input
9
Output
3
9 3
2 4
6 8
Input
2
Output
0 | instruction | 0 | 89,653 | 22 | 179,306 |
Tags: constructive algorithms, number theory
Correct Solution:
```
import math,sys,bisect,heapq
from collections import defaultdict,Counter,deque
from itertools import groupby,accumulate
#sys.setrecursionlimit(200000000)
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
ilele = lambda: map(int,input().split())
alele = lambda: list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
MOD = 1000000000 + 7
def Y(c): print(["NO","YES"][c])
def y(c): print(["no","yes"][c])
def Yy(c): print(["No","Yes"][c])
def SieveOfEratosthenes(n):
Z=[]
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
# Update all multiples of p
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
# Print all prime numbers
for p in range(2, n):
if prime[p]:
Z.append(p)
return Z
N = int(input())
prime = SieveOfEratosthenes(N//2)
if N <=3:
print(0)
else:
mark = {}
if N//2 not in prime:
prime.append(N//2)
Ans = []
prime = prime[::-1]
for i in prime:
Z= []
for j in range(1,N//i + 1):
if mark.get(i*j,-1) == -1:
Z.append(i*j)
if len(Z) % 2 == 0:
for k in Z:
Ans.append(k)
mark[k] = 1
else:
for k in Z:
if k!= 2*i:
Ans.append(k)
mark[k] = 1
print(len(Ans)//2)
for i in range(0,len(Ans),2):
print(Ans[i],Ans[i+1])
``` | output | 1 | 89,653 | 22 | 179,307 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Jzzhu has picked n apples from his big apple tree. All the apples are numbered from 1 to n. Now he wants to sell them to an apple store.
Jzzhu will pack his apples into groups and then sell them. Each group must contain two apples, and the greatest common divisor of numbers of the apples in each group must be greater than 1. Of course, each apple can be part of at most one group.
Jzzhu wonders how to get the maximum possible number of groups. Can you help him?
Input
A single integer n (1 ≤ n ≤ 105), the number of the apples.
Output
The first line must contain a single integer m, representing the maximum number of groups he can get. Each of the next m lines must contain two integers — the numbers of apples in the current group.
If there are several optimal answers you can print any of them.
Examples
Input
6
Output
2
6 3
2 4
Input
9
Output
3
9 3
2 4
6 8
Input
2
Output
0 | instruction | 0 | 89,654 | 22 | 179,308 |
Tags: constructive algorithms, number theory
Correct Solution:
```
n = int(input())
primes = [x for x in range(2, int(n/2)+1) if all(x % y != 0 for y in range(2, int(x**(0.5))+1))] #go to discord
primes = primes[::-1]
used = {}
for i in range(2,n+1):
used[i] = False
def solve(n, primes, used):
outputs = []
doubles = []
counter = 0
if n == 1:
return 0, 0
for i in primes:
multiples = []
for x in range(1,n//i+1):
if used[i*x] == False:
multiples.append(i*x)
used[i*x] = True
if len(multiples)%2==0:
for j in range(0, int(len(multiples)), 2):
outputs.append((multiples[j], multiples[j+1]))
counter+=1
else:
#doubles.append(2*i)
multiples.pop(1)
used[i*2] = False
for j in range(0, int(len(multiples)), 2):
outputs.append((multiples[j], multiples[j+1]))
counter+=1
#outputs+=[(multiples[x], multiples[2*x]) for x in range(int(len(multiples)/2)) if multiples[2*x] != 2*i]
#print(multiples)
#print(used)
#print(doubles)
#for j in range(0, int(len(doubles)/2), 2):
#outputs.append((multiples[j], multiples[j+1]))
return outputs, counter
a = solve(n, primes, used)
print(a[1])
if a[0] != 0:
for i in a[0]:
print(*i)
``` | output | 1 | 89,654 | 22 | 179,309 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Jzzhu has picked n apples from his big apple tree. All the apples are numbered from 1 to n. Now he wants to sell them to an apple store.
Jzzhu will pack his apples into groups and then sell them. Each group must contain two apples, and the greatest common divisor of numbers of the apples in each group must be greater than 1. Of course, each apple can be part of at most one group.
Jzzhu wonders how to get the maximum possible number of groups. Can you help him?
Input
A single integer n (1 ≤ n ≤ 105), the number of the apples.
Output
The first line must contain a single integer m, representing the maximum number of groups he can get. Each of the next m lines must contain two integers — the numbers of apples in the current group.
If there are several optimal answers you can print any of them.
Examples
Input
6
Output
2
6 3
2 4
Input
9
Output
3
9 3
2 4
6 8
Input
2
Output
0 | instruction | 0 | 89,655 | 22 | 179,310 |
Tags: constructive algorithms, number theory
Correct Solution:
```
import math
apples=int(input())
if apples<=3:
print(0)
else:
halfpr=int(apples/2)
def primes(n):
primeslistsa=[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37,
41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83,
89, 97, 101, 103, 107, 109, 113, 127, 131,
137, 139, 149, 151, 157, 163, 167, 173, 179,
181, 191, 193, 197, 199, 211, 223, 227, 229,
233, 239, 241, 251, 257, 263, 269, 271, 277,
281, 283, 293, 307, 311, 313, 317]
yesnoprime=[False, False]+[True]*(n-1)
t=0
while primeslistsa[t+1]<=int(math.sqrt(n)):
t+=1
for x in range(t+1):
for sa in range(2, int(n/primeslistsa[x]+1)):
yesnoprime[primeslistsa[x]*sa]=False
return yesnoprime
primeslist=primes(halfpr)
totallist=[False]*(apples+1)
applepairs=[]
for prime in range(len(primeslist)-1, 1, -1):
if primeslist[prime]:
numprimes=int(apples/prime)
primesx=[int(i*prime) for i in range(1, numprimes+1) if not totallist[i*prime]]
if len(primesx)%2==1:
primesx.remove(2*prime)
for pr in primesx:
applepairs.append(pr)
totallist[pr]=True
print(int(len(applepairs)/2))
for t in range(int(len(applepairs)/2)):
print(applepairs[2*t], applepairs[2*t+1])
``` | output | 1 | 89,655 | 22 | 179,311 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Jzzhu has picked n apples from his big apple tree. All the apples are numbered from 1 to n. Now he wants to sell them to an apple store.
Jzzhu will pack his apples into groups and then sell them. Each group must contain two apples, and the greatest common divisor of numbers of the apples in each group must be greater than 1. Of course, each apple can be part of at most one group.
Jzzhu wonders how to get the maximum possible number of groups. Can you help him?
Input
A single integer n (1 ≤ n ≤ 105), the number of the apples.
Output
The first line must contain a single integer m, representing the maximum number of groups he can get. Each of the next m lines must contain two integers — the numbers of apples in the current group.
If there are several optimal answers you can print any of them.
Examples
Input
6
Output
2
6 3
2 4
Input
9
Output
3
9 3
2 4
6 8
Input
2
Output
0 | instruction | 0 | 89,656 | 22 | 179,312 |
Tags: constructive algorithms, number theory
Correct Solution:
```
def find_primes(p):
nums = list(range(3,p + 1))
divisors=[2]
for num in nums:
check=0
res = True
while divisors[check] <= num**(1/2):
if num % divisors[check] == 0:
res = False
break
check += 1
if res:
divisors.append(num)
divisors.reverse()
return divisors
num = int(input())
nums = set(range(2,num + 1))
check = dict()
for i in range(1,num+1):
check[i] = False
primes = find_primes(num//2)
results = []
for prime in primes:
if prime > num // 2:
break
considering = []
for x in range(1, num // prime+1):
if not check.get(x * prime):
considering.append(x * prime)
check[x * prime] = True
if len(considering) % 2 != 0:
considering.remove(prime * 2)
check[prime*2] = False
adding = [(considering[i], considering[i+1]) for i in range(0,len(considering),2)]
results += adding
nums = [x for x in nums if x % 2 == 0 and not check.get(x)]
if len(nums) % 2 != 0:
nums.pop()
results += [(nums[i], nums[i+1]) for i in range(0,len(nums),2)]
print(len(results))
for res in results:
print(res[0], res[1])
``` | output | 1 | 89,656 | 22 | 179,313 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Jzzhu has picked n apples from his big apple tree. All the apples are numbered from 1 to n. Now he wants to sell them to an apple store.
Jzzhu will pack his apples into groups and then sell them. Each group must contain two apples, and the greatest common divisor of numbers of the apples in each group must be greater than 1. Of course, each apple can be part of at most one group.
Jzzhu wonders how to get the maximum possible number of groups. Can you help him?
Input
A single integer n (1 ≤ n ≤ 105), the number of the apples.
Output
The first line must contain a single integer m, representing the maximum number of groups he can get. Each of the next m lines must contain two integers — the numbers of apples in the current group.
If there are several optimal answers you can print any of them.
Examples
Input
6
Output
2
6 3
2 4
Input
9
Output
3
9 3
2 4
6 8
Input
2
Output
0 | instruction | 0 | 89,657 | 22 | 179,314 |
Tags: constructive algorithms, number theory
Correct Solution:
```
"""
Codeforces Round 257 Div 1 Problem C
Author : chaotic_iak
Language: Python 3.3.4
"""
def read(mode=2):
# 0: String
# 1: List of strings
# 2: List of integers
inputs = input().strip()
if mode == 0:
return inputs
if mode == 1:
return inputs.split()
if mode == 2:
return [int(x) for x in inputs.split()]
def write(s="\n"):
if isinstance(s, list): s = " ".join(map(str,s))
s = str(s)
print(s, end="")
################################################### SOLUTION
# croft algorithm to generate primes
# from pyprimes library, not built-in, just google it
from itertools import compress
import itertools
def croft():
"""Yield prime integers using the Croft Spiral sieve.
This is a variant of wheel factorisation modulo 30.
"""
# Implementation is based on erat3 from here:
# http://stackoverflow.com/q/2211990
# and this website:
# http://www.primesdemystified.com/
# Memory usage increases roughly linearly with the number of primes seen.
# dict ``roots`` stores an entry x:p for every prime p.
for p in (2, 3, 5):
yield p
roots = {9: 3, 25: 5} # Map d**2 -> d.
primeroots = frozenset((1, 7, 11, 13, 17, 19, 23, 29))
selectors = (1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0)
for q in compress(
# Iterate over prime candidates 7, 9, 11, 13, ...
itertools.islice(itertools.count(7), 0, None, 2),
# Mask out those that can't possibly be prime.
itertools.cycle(selectors)
):
# Using dict membership testing instead of pop gives a
# 5-10% speedup over the first three million primes.
if q in roots:
p = roots[q]
del roots[q]
x = q + 2*p
while x in roots or (x % 30) not in primeroots:
x += 2*p
roots[x] = p
else:
roots[q*q] = q
yield q
n, = read()
cr = croft()
primes = []
for i in cr:
if i < n:
primes.append(i)
else:
break
primes.reverse()
used = [0] * (n+1)
res = []
for p in primes:
k = n//p
tmp = []
while k:
if not used[k*p]:
tmp.append(k*p)
used[k*p] = 1
if len(tmp) == 2:
res.append(tmp)
tmp = []
k -= 1
if tmp == [p] and p > 2 and p*2 <= n and len(res) and res[-1][1] == p*2:
res[-1][1] = p
used[p*2] = 0
used[p] = 1
print(len(res))
for i in res:
print(" ".join(map(str, i)))
``` | output | 1 | 89,657 | 22 | 179,315 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Jzzhu has picked n apples from his big apple tree. All the apples are numbered from 1 to n. Now he wants to sell them to an apple store.
Jzzhu will pack his apples into groups and then sell them. Each group must contain two apples, and the greatest common divisor of numbers of the apples in each group must be greater than 1. Of course, each apple can be part of at most one group.
Jzzhu wonders how to get the maximum possible number of groups. Can you help him?
Input
A single integer n (1 ≤ n ≤ 105), the number of the apples.
Output
The first line must contain a single integer m, representing the maximum number of groups he can get. Each of the next m lines must contain two integers — the numbers of apples in the current group.
If there are several optimal answers you can print any of them.
Examples
Input
6
Output
2
6 3
2 4
Input
9
Output
3
9 3
2 4
6 8
Input
2
Output
0 | instruction | 0 | 89,658 | 22 | 179,316 |
Tags: constructive algorithms, number theory
Correct Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from math import *
def prm(x):
s = int(sqrt(x+0.5))
for i in range(2, s+1):
if not (x%i): return False
return True
def ap(a):
while(len(a) >= 2):
print(a[-1], a[-2])
a.pop()
a.pop()
n, cnt, ans, vis, ansl, ansr = int(input()), 0, 0, [False]*100100, [], []
prime = filter(prm, range(3, n//2+1))
for x in prime:
tcnt, nlst = 0, []
for i in range(1, n//x+1):
if not vis[i*x]:
vis[i*x] = True
nlst.append(i)
tcnt += 1
ans += tcnt >> 1
cnt += tcnt & 1
if tcnt & 1 :
nlst = nlst[0:1] + nlst[2:]
ansr.append(x<<1)
ansl += list(map(lambda k : x*k, nlst))
for i in range(1, n+1):
if not vis[i] and not (i&1):
ansr.append(i)
cnt += 1
print(ans+(cnt>>1))
ap(ansl)
ap(ansr)
``` | output | 1 | 89,658 | 22 | 179,317 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Jzzhu has picked n apples from his big apple tree. All the apples are numbered from 1 to n. Now he wants to sell them to an apple store.
Jzzhu will pack his apples into groups and then sell them. Each group must contain two apples, and the greatest common divisor of numbers of the apples in each group must be greater than 1. Of course, each apple can be part of at most one group.
Jzzhu wonders how to get the maximum possible number of groups. Can you help him?
Input
A single integer n (1 ≤ n ≤ 105), the number of the apples.
Output
The first line must contain a single integer m, representing the maximum number of groups he can get. Each of the next m lines must contain two integers — the numbers of apples in the current group.
If there are several optimal answers you can print any of them.
Examples
Input
6
Output
2
6 3
2 4
Input
9
Output
3
9 3
2 4
6 8
Input
2
Output
0
Submitted Solution:
```
n = int(input())
primes = [x for x in range(2, int(n/2)+1) if all(x % y != 0 for y in range(2, int(x*(0.5))+1))] #go to discord
primes = primes[::-1]
used = {}
for i in range(2,n+1):
used[i] = False
def solve(n, primes, used):
outputs = []
doubles = []
counter = 0
if n == 1:
return 0, 0
for i in primes:
multiples = []
for x in range(1,n//i+1):
if used[i*x] == False:
multiples.append(i*x)
used[i*x] = True
if len(multiples)%2==0:
for j in range(0, int(len(multiples)), 2):
outputs.append((multiples[j], multiples[j+1]))
counter+=1
else:
#doubles.append(2i)
multiples.pop(1)
used[i*2] = False
for j in range(0, int(len(multiples)), 2):
outputs.append((multiples[j], multiples[j+1]))
counter+=1
#outputs+=[(multiples[x], multiples[2x]) for x in range(int(len(multiples)/2)) if multiples[2x] != 2i]
#print(multiples)
#print(used)
#print(doubles)
#for j in range(0, int(len(doubles)/2), 2):
#outputs.append((multiples[j], multiples[j+1]))
return outputs, counter
a = solve(n, primes, used)
print(a[1])
if a[0] != 0:
for i in a[0]:
print(*i)
``` | instruction | 0 | 89,659 | 22 | 179,318 |
Yes | output | 1 | 89,659 | 22 | 179,319 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Jzzhu has picked n apples from his big apple tree. All the apples are numbered from 1 to n. Now he wants to sell them to an apple store.
Jzzhu will pack his apples into groups and then sell them. Each group must contain two apples, and the greatest common divisor of numbers of the apples in each group must be greater than 1. Of course, each apple can be part of at most one group.
Jzzhu wonders how to get the maximum possible number of groups. Can you help him?
Input
A single integer n (1 ≤ n ≤ 105), the number of the apples.
Output
The first line must contain a single integer m, representing the maximum number of groups he can get. Each of the next m lines must contain two integers — the numbers of apples in the current group.
If there are several optimal answers you can print any of them.
Examples
Input
6
Output
2
6 3
2 4
Input
9
Output
3
9 3
2 4
6 8
Input
2
Output
0
Submitted Solution:
```
n = int(input())
primes = [x for x in range(2, int(n/2)+1) if all(x % y != 0 for y in range(2, int(x**(0.5))+1))] #go to discord
primes = primes[::-1]
used = []
def solve(n, primes, used):
outputs = []
doubles = []
counter = 0
if n == 1:
return 0
for i in primes:
multiples = [i*x for x in range(1,n//i+1) if i*x not in used]
if len(multiples)%2==0:
for j in range(0, int(len(multiples)/2)+1, 2):
outputs.append((multiples[j], multiples[j+1]))
counter+=1
else:
doubles.append(2*i)
multiples.pop(1)
for j in range(0, int(len(multiples)/2)+1, 2):
outputs.append((multiples[j], multiples[j+1]))
counter+=1
#outputs+=[(multiples[x], multiples[2*x]) for x in range(int(len(multiples)/2)) if multiples[2*x] != 2*i]
used+=multiples
#print(multiples)
#print(doubles)
#for j in range(0, int(len(doubles)/2), 2):
#outputs.append((multiples[j], multiples[j+1]))
return outputs, counter
a = solve(n, primes, used)
print(a[1])
for i in a[0]:
print(*i)
``` | instruction | 0 | 89,660 | 22 | 179,320 |
No | output | 1 | 89,660 | 22 | 179,321 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Jzzhu has picked n apples from his big apple tree. All the apples are numbered from 1 to n. Now he wants to sell them to an apple store.
Jzzhu will pack his apples into groups and then sell them. Each group must contain two apples, and the greatest common divisor of numbers of the apples in each group must be greater than 1. Of course, each apple can be part of at most one group.
Jzzhu wonders how to get the maximum possible number of groups. Can you help him?
Input
A single integer n (1 ≤ n ≤ 105), the number of the apples.
Output
The first line must contain a single integer m, representing the maximum number of groups he can get. Each of the next m lines must contain two integers — the numbers of apples in the current group.
If there are several optimal answers you can print any of them.
Examples
Input
6
Output
2
6 3
2 4
Input
9
Output
3
9 3
2 4
6 8
Input
2
Output
0
Submitted Solution:
```
apples=int(input())
lastprime=int(apples/2)
totappls=[int(x) for x in range(2, apples+1)]
sa=[]
if apples<=3:
print(0)
else:
def primes(n):
# http://stackoverflow.com/questions/2068372/fastest-way-to-list-all-primes-below-n-in-python/3035188#3035188
# Copied code
""" Returns a list of primes < n """
sieve = [True] * n
for i in range(3,int(n**0.5)+1,2):
if sieve[i]:
sieve[i*i::2*i]=[False]*int((n-i*i-1)/(2*i)+1)
return [i for i in range(3,n,2) if sieve[i]]+[2]
for prime in primes(lastprime+1):
primelist=[int(prime*x) for x in range(1, int(apples/prime)+1) if prime*x in totappls]
if len(primelist)%2==0:
for t in range(int(len(primelist)/2)):
sa.append(str(primelist[2*t])+' '+str(primelist[2*t+1]))
else:
primelist.remove(2*prime)
for t in range(int(len(primelist)/2)):
sa.append(str(primelist[2*t])+' '+str(primelist[2*t+1]))
[totappls.remove(x) for x in primelist]
print(len(sa))
for element in sa:
print(element)
``` | instruction | 0 | 89,661 | 22 | 179,322 |
No | output | 1 | 89,661 | 22 | 179,323 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Jzzhu has picked n apples from his big apple tree. All the apples are numbered from 1 to n. Now he wants to sell them to an apple store.
Jzzhu will pack his apples into groups and then sell them. Each group must contain two apples, and the greatest common divisor of numbers of the apples in each group must be greater than 1. Of course, each apple can be part of at most one group.
Jzzhu wonders how to get the maximum possible number of groups. Can you help him?
Input
A single integer n (1 ≤ n ≤ 105), the number of the apples.
Output
The first line must contain a single integer m, representing the maximum number of groups he can get. Each of the next m lines must contain two integers — the numbers of apples in the current group.
If there are several optimal answers you can print any of them.
Examples
Input
6
Output
2
6 3
2 4
Input
9
Output
3
9 3
2 4
6 8
Input
2
Output
0
Submitted Solution:
```
def find_primes(p):
nums = list(range(3,p + 1))
divisors=[2]
for num in nums:
check=0
res = True
while divisors[check] <= num**(1/2):
if num % divisors[check] == 0:
res = False
break
check = check+1
if res:
divisors.append(num)
divisors.reverse()
return divisors
num = int(input())
nums = list(range(2,num + 1))
primes = find_primes(num//2)
results = []
for prime in primes:
if prime > num // 2:
break
considering = [x for x in nums if x % prime == 0]
set_considering = set(considering)
if len(considering) % 2 != 0:
considering.remove(prime * 2)
nums = [x for x in nums if x not in set_considering]
adding = [(considering[i], considering[i+1]) for i in range(0,len(considering),2)]
results += adding
nums = [x for x in nums if x % 2 == 0]
if len(nums) % 2 != 0:
nums.pop()
results += [(nums[i], nums[i+1]) for i in range(0,len(nums),2)]
print(len(results))
for res in results:
print(res[0], res[1])
``` | instruction | 0 | 89,662 | 22 | 179,324 |
No | output | 1 | 89,662 | 22 | 179,325 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Jzzhu has picked n apples from his big apple tree. All the apples are numbered from 1 to n. Now he wants to sell them to an apple store.
Jzzhu will pack his apples into groups and then sell them. Each group must contain two apples, and the greatest common divisor of numbers of the apples in each group must be greater than 1. Of course, each apple can be part of at most one group.
Jzzhu wonders how to get the maximum possible number of groups. Can you help him?
Input
A single integer n (1 ≤ n ≤ 105), the number of the apples.
Output
The first line must contain a single integer m, representing the maximum number of groups he can get. Each of the next m lines must contain two integers — the numbers of apples in the current group.
If there are several optimal answers you can print any of them.
Examples
Input
6
Output
2
6 3
2 4
Input
9
Output
3
9 3
2 4
6 8
Input
2
Output
0
Submitted Solution:
```
n = int(input())
primes = [x for x in range(2, int(n/2)+1) if all(x % y != 0 for y in range(2, int(x**(0.5))+1))] #go to discord
primes = primes[::-1]
used = []
def solve(n, primes, used):
outputs = []
doubles = []
counter = 0
if n == 1:
return 0
for i in primes:
multiples = [i*x for x in range(1,n//i+1) if i*x not in used]
if len(multiples)%2==0:
for j in range(0, int(len(multiples)), 2):
outputs.append((multiples[j], multiples[j+1]))
counter+=1
else:
doubles.append(2*i)
multiples.pop(1)
for j in range(0, int(len(multiples)), 2):
outputs.append((multiples[j], multiples[j+1]))
counter+=1
#outputs+=[(multiples[x], multiples[2*x]) for x in range(int(len(multiples)/2)) if multiples[2*x] != 2*i]
used+=multiples
print(multiples)
#print(doubles)
#for j in range(0, int(len(doubles)/2), 2):
#outputs.append((multiples[j], multiples[j+1]))
return outputs, counter
a = solve(n, primes, used)
print(a[1])
for i in a[0]:
print(*i)
``` | instruction | 0 | 89,663 | 22 | 179,326 |
No | output | 1 | 89,663 | 22 | 179,327 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which finds the greatest common divisor of two natural numbers a and b
Hint
You can use the following observation:
For integers x and y, if x ≥ y, then gcd(x, y) = gcd(y, x%y)
Constrants
1 ≤ a, b ≤ 109
Input
a and b are given in a line sparated by a single space.
Output
Output the greatest common divisor of a and b.
Examples
Input
54 20
Output
2
Input
147 105
Output
21 | instruction | 0 | 90,066 | 22 | 180,132 |
"Correct Solution:
```
A = list(map(int,input().split()))
a=A[0]
b=A[1]
while b:
a,b=b,a%b
print(a)
``` | output | 1 | 90,066 | 22 | 180,133 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which finds the greatest common divisor of two natural numbers a and b
Hint
You can use the following observation:
For integers x and y, if x ≥ y, then gcd(x, y) = gcd(y, x%y)
Constrants
1 ≤ a, b ≤ 109
Input
a and b are given in a line sparated by a single space.
Output
Output the greatest common divisor of a and b.
Examples
Input
54 20
Output
2
Input
147 105
Output
21 | instruction | 0 | 90,067 | 22 | 180,134 |
"Correct Solution:
```
# 76
import math
x,y = (int(x) for x in input().split())
print(math.gcd(x, y))
``` | output | 1 | 90,067 | 22 | 180,135 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which finds the greatest common divisor of two natural numbers a and b
Hint
You can use the following observation:
For integers x and y, if x ≥ y, then gcd(x, y) = gcd(y, x%y)
Constrants
1 ≤ a, b ≤ 109
Input
a and b are given in a line sparated by a single space.
Output
Output the greatest common divisor of a and b.
Examples
Input
54 20
Output
2
Input
147 105
Output
21 | instruction | 0 | 90,068 | 22 | 180,136 |
"Correct Solution:
```
X, Y = map(int, input().split())
x = min(X, Y)
y = max(X, Y)
while x > 0:
r = y % x
y = x
x = r
print(y)
``` | output | 1 | 90,068 | 22 | 180,137 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which finds the greatest common divisor of two natural numbers a and b
Hint
You can use the following observation:
For integers x and y, if x ≥ y, then gcd(x, y) = gcd(y, x%y)
Constrants
1 ≤ a, b ≤ 109
Input
a and b are given in a line sparated by a single space.
Output
Output the greatest common divisor of a and b.
Examples
Input
54 20
Output
2
Input
147 105
Output
21 | instruction | 0 | 90,069 | 22 | 180,138 |
"Correct Solution:
```
x, y = map(int, input().split())
if x < y:
x, y = y, x
while y > 0:
x, y = y, (x%y)
print(x)
``` | output | 1 | 90,069 | 22 | 180,139 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which finds the greatest common divisor of two natural numbers a and b
Hint
You can use the following observation:
For integers x and y, if x ≥ y, then gcd(x, y) = gcd(y, x%y)
Constrants
1 ≤ a, b ≤ 109
Input
a and b are given in a line sparated by a single space.
Output
Output the greatest common divisor of a and b.
Examples
Input
54 20
Output
2
Input
147 105
Output
21 | instruction | 0 | 90,070 | 22 | 180,140 |
"Correct Solution:
```
import math
line=input().split()
x=int(line[0])
y=int(line[1])
print(math.gcd(x,y))
``` | output | 1 | 90,070 | 22 | 180,141 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which finds the greatest common divisor of two natural numbers a and b
Hint
You can use the following observation:
For integers x and y, if x ≥ y, then gcd(x, y) = gcd(y, x%y)
Constrants
1 ≤ a, b ≤ 109
Input
a and b are given in a line sparated by a single space.
Output
Output the greatest common divisor of a and b.
Examples
Input
54 20
Output
2
Input
147 105
Output
21 | instruction | 0 | 90,071 | 22 | 180,142 |
"Correct Solution:
```
a, b = map(int, input().split())
if a <= b:
a, b = b, a
while a % b != 0:
a, b = b, a % b
print(b)
``` | output | 1 | 90,071 | 22 | 180,143 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which finds the greatest common divisor of two natural numbers a and b
Hint
You can use the following observation:
For integers x and y, if x ≥ y, then gcd(x, y) = gcd(y, x%y)
Constrants
1 ≤ a, b ≤ 109
Input
a and b are given in a line sparated by a single space.
Output
Output the greatest common divisor of a and b.
Examples
Input
54 20
Output
2
Input
147 105
Output
21 | instruction | 0 | 90,072 | 22 | 180,144 |
"Correct Solution:
```
a,b = map(int,input().split())
if a < b:
a,b = b,a
while b != 0:
c = a % b
a,b = b,c
print(a)
``` | output | 1 | 90,072 | 22 | 180,145 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which finds the greatest common divisor of two natural numbers a and b
Hint
You can use the following observation:
For integers x and y, if x ≥ y, then gcd(x, y) = gcd(y, x%y)
Constrants
1 ≤ a, b ≤ 109
Input
a and b are given in a line sparated by a single space.
Output
Output the greatest common divisor of a and b.
Examples
Input
54 20
Output
2
Input
147 105
Output
21 | instruction | 0 | 90,073 | 22 | 180,146 |
"Correct Solution:
```
x, y = map(int, input(). split())
while True:
if x % y == 0:
break
tmp = x % y
x = y
y = tmp
print(y)
``` | output | 1 | 90,073 | 22 | 180,147 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which finds the greatest common divisor of two natural numbers a and b
Hint
You can use the following observation:
For integers x and y, if x ≥ y, then gcd(x, y) = gcd(y, x%y)
Constrants
1 ≤ a, b ≤ 109
Input
a and b are given in a line sparated by a single space.
Output
Output the greatest common divisor of a and b.
Examples
Input
54 20
Output
2
Input
147 105
Output
21
Submitted Solution:
```
import math
x,y = map(int,input().split())
ans = math.gcd(x,y)
print(ans)
``` | instruction | 0 | 90,074 | 22 | 180,148 |
Yes | output | 1 | 90,074 | 22 | 180,149 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which finds the greatest common divisor of two natural numbers a and b
Hint
You can use the following observation:
For integers x and y, if x ≥ y, then gcd(x, y) = gcd(y, x%y)
Constrants
1 ≤ a, b ≤ 109
Input
a and b are given in a line sparated by a single space.
Output
Output the greatest common divisor of a and b.
Examples
Input
54 20
Output
2
Input
147 105
Output
21
Submitted Solution:
```
# coding: utf-8
# Your code here!
import math
a, b = map(int,input().split())
print(math.gcd(a,b))
``` | instruction | 0 | 90,075 | 22 | 180,150 |
Yes | output | 1 | 90,075 | 22 | 180,151 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.