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 a correct Python 3 solution for this coding contest problem.
Given is a positive integer N.
We will choose an integer K between 2 and N (inclusive), then we will repeat the operation below until N becomes less than K.
* Operation: if K divides N, replace N with N/K; otherwise, replace N with N-K.
In how many choices of K will N become 1 in the end?
Constraints
* 2 \leq N \leq 10^{12}
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of choices of K in which N becomes 1 in the end.
Examples
Input
6
Output
3
Input
3141
Output
13
Input
314159265358
Output
9 | instruction | 0 | 62,046 | 22 | 124,092 |
"Correct Solution:
```
N = int(input())
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
divlist = make_divisors(N)
count = 0
for i in divlist[1:]:
n = N
while n % i == 0:
n = n // i
if n % i == 1:
count += 1
print(count + len(make_divisors(N-1))-1)
``` | output | 1 | 62,046 | 22 | 124,093 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a positive integer N.
We will choose an integer K between 2 and N (inclusive), then we will repeat the operation below until N becomes less than K.
* Operation: if K divides N, replace N with N/K; otherwise, replace N with N-K.
In how many choices of K will N become 1 in the end?
Constraints
* 2 \leq N \leq 10^{12}
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of choices of K in which N becomes 1 in the end.
Examples
Input
6
Output
3
Input
3141
Output
13
Input
314159265358
Output
9 | instruction | 0 | 62,047 | 22 | 124,094 |
"Correct Solution:
```
def divisors(n):
lst = []; i = 1
while i * i <= n:
q, r = divmod(n, i)
if r == 0:
lst.append(i)
if i != q: lst.append(q)
i += 1
return lst
N = int(input())
ans = len(divisors(N-1)) - 1
divs = divisors(N)
for k in divs:
if k == 1: continue
temp = N
while temp % k == 0: temp //= k
if temp % k == 1: ans += 1
print(ans)
``` | output | 1 | 62,047 | 22 | 124,095 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a positive integer N.
We will choose an integer K between 2 and N (inclusive), then we will repeat the operation below until N becomes less than K.
* Operation: if K divides N, replace N with N/K; otherwise, replace N with N-K.
In how many choices of K will N become 1 in the end?
Constraints
* 2 \leq N \leq 10^{12}
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of choices of K in which N becomes 1 in the end.
Examples
Input
6
Output
3
Input
3141
Output
13
Input
314159265358
Output
9 | instruction | 0 | 62,051 | 22 | 124,102 |
"Correct Solution:
```
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
def all_pattern(l):
global n
ans=0
for ds in make_divisors(l)[1:]:
k=n
while k%ds==0:
k//=ds
ans+=(k%ds==1)
return ans
n=int(input())
print(all_pattern(n)+all_pattern(n-1))
``` | output | 1 | 62,051 | 22 | 124,103 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a positive integer N.
We will choose an integer K between 2 and N (inclusive), then we will repeat the operation below until N becomes less than K.
* Operation: if K divides N, replace N with N/K; otherwise, replace N with N-K.
In how many choices of K will N become 1 in the end?
Constraints
* 2 \leq N \leq 10^{12}
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of choices of K in which N becomes 1 in the end.
Examples
Input
6
Output
3
Input
3141
Output
13
Input
314159265358
Output
9
Submitted Solution:
```
def divisors(n):
ret=[]
for i in range(1,int(n**0.5)+1):
if n%i==0:
ret.append(i)
if n//i!=i:
ret.append(n//i)
return ret
n = int(input())
ans = len(divisors(n-1)) - 1
for d in divisors(n)[1:]:
tmp = n
while tmp%d == 0:
tmp = tmp//d
if tmp%d == 1:
ans += 1
print(ans)
``` | instruction | 0 | 62,053 | 22 | 124,106 |
Yes | output | 1 | 62,053 | 22 | 124,107 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a positive integer N.
We will choose an integer K between 2 and N (inclusive), then we will repeat the operation below until N becomes less than K.
* Operation: if K divides N, replace N with N/K; otherwise, replace N with N-K.
In how many choices of K will N become 1 in the end?
Constraints
* 2 \leq N \leq 10^{12}
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of choices of K in which N becomes 1 in the end.
Examples
Input
6
Output
3
Input
3141
Output
13
Input
314159265358
Output
9
Submitted Solution:
```
def m(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
n=int(input())
ans=len(m(n-1))-1
A=m(n)
for i in range(1,len(A)):
s=n
while s%A[i]==0:
s=s//A[i]
if s%A[i]==1:
ans=ans+1
print(ans)
``` | instruction | 0 | 62,054 | 22 | 124,108 |
Yes | output | 1 | 62,054 | 22 | 124,109 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a positive integer N.
We will choose an integer K between 2 and N (inclusive), then we will repeat the operation below until N becomes less than K.
* Operation: if K divides N, replace N with N/K; otherwise, replace N with N-K.
In how many choices of K will N become 1 in the end?
Constraints
* 2 \leq N \leq 10^{12}
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of choices of K in which N becomes 1 in the end.
Examples
Input
6
Output
3
Input
3141
Output
13
Input
314159265358
Output
9
Submitted Solution:
```
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
# divisors.sort() #小さい順位欲しいとき
return divisors
n=int(input())
a=make_divisors(n)[1:]
ans=0
for i in a:
k=n
while k%i==0:
k//=i
if k%i==1:
ans+=1
ans+=len(make_divisors(n-1))-1
print(ans)
``` | instruction | 0 | 62,056 | 22 | 124,112 |
Yes | output | 1 | 62,056 | 22 | 124,113 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a positive integer N.
We will choose an integer K between 2 and N (inclusive), then we will repeat the operation below until N becomes less than K.
* Operation: if K divides N, replace N with N/K; otherwise, replace N with N-K.
In how many choices of K will N become 1 in the end?
Constraints
* 2 \leq N \leq 10^{12}
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of choices of K in which N becomes 1 in the end.
Examples
Input
6
Output
3
Input
3141
Output
13
Input
314159265358
Output
9
Submitted Solution:
```
from collections import Counter
def main():
n = int(input())
ans = set([n])
divisors = make_divisors(n)
ans |= set(make_divisors(n-1))
ans |= set(prime_factorize(n-1))
ans |= set([divisor for divisor in divisors if ((n//divisor)%divisor)==1])
ans -= set([1])
print(len(ans))
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
def prime_factorize(x):
a = []
while x % 2 == 0:
a.append(2)
x //= 2
f = 3
while f * f <= x:
if x % f == 0:
a.append(f)
x //= f
else:
f += 2
if x != 1:
a.append(x)
return a
if __name__ == "__main__":
main()
``` | instruction | 0 | 62,057 | 22 | 124,114 |
No | output | 1 | 62,057 | 22 | 124,115 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a positive integer N.
We will choose an integer K between 2 and N (inclusive), then we will repeat the operation below until N becomes less than K.
* Operation: if K divides N, replace N with N/K; otherwise, replace N with N-K.
In how many choices of K will N become 1 in the end?
Constraints
* 2 \leq N \leq 10^{12}
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of choices of K in which N becomes 1 in the end.
Examples
Input
6
Output
3
Input
3141
Output
13
Input
314159265358
Output
9
Submitted Solution:
```
import math
N = int(input())
cnt = 0
if N == 2:
print(1)
exit()
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
# divisors.sort()
return divisors
res1 = sorted(make_divisors(N))
print(res1)
res1 = res1[1:math.ceil(len(res1)/2)]
for num in res1:
kensa = N
while True:
if kensa % num == 0:
kensa = kensa // num
continue
break
if kensa % num == 1:
cnt += 1
res2 = sorted(make_divisors(N-1))
cnt += len(res2[1:])+1
print(cnt)
``` | instruction | 0 | 62,058 | 22 | 124,116 |
No | output | 1 | 62,058 | 22 | 124,117 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer n greater or equal to 2. For every pair of integers a and b (2 ≤ |a|, |b| ≤ n), you can transform a into b if and only if there exists an integer x such that 1 < |x| and (a ⋅ x = b or b ⋅ x = a), where |x| denotes the absolute value of x.
After such a transformation, your score increases by |x| points and you are not allowed to transform a into b nor b into a anymore.
Initially, you have a score of 0. You can start at any integer and transform it as many times as you like. What is the maximum score you can achieve?
Input
A single line contains a single integer n (2 ≤ n ≤ 100 000) — the given integer described above.
Output
Print an only integer — the maximum score that can be achieved with the transformations. If it is not possible to perform even a single transformation for all possible starting integers, print 0.
Examples
Input
4
Output
8
Input
6
Output
28
Input
2
Output
0
Note
In the first example, the transformations are 2 → 4 → (-2) → (-4) → 2.
In the third example, it is impossible to perform even a single transformation. | instruction | 0 | 62,300 | 22 | 124,600 |
Tags: dfs and similar, graphs, implementation, math
Correct Solution:
```
from collections import defaultdict, Counter,deque
from math import sqrt, log10, log, floor, factorial,gcd
from bisect import bisect_left, bisect_right
from itertools import permutations,combinations
from heapq import heapify,heappop,heappush
import sys, io, os
input = sys.stdin.readline
# input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
# sys.setrecursionlimit(10000)
inf = float('inf')
mod = 10 ** 9 + 7
def get_list(): return [int(i) for i in input().split()]
def yn(a): print("YES" if a else "NO")
ceil = lambda a, b: (a + b - 1) // b
t=1
for i in range(t):
n = int(input())
print(sum([sum([k // j for k in range(2 * j, n + 1, j)]) for j in range(2, n + 1)]) * 4)
``` | output | 1 | 62,300 | 22 | 124,601 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Today the kindergarten has a new group of n kids who need to be seated at the dinner table. The chairs at the table are numbered from 1 to 4n. Two kids can't sit on the same chair. It is known that two kids who sit on chairs with numbers a and b (a ≠ b) will indulge if:
1. gcd(a, b) = 1 or,
2. a divides b or b divides a.
gcd(a, b) — the maximum number x such that a is divisible by x and b is divisible by x.
For example, if n=3 and the kids sit on chairs with numbers 2, 3, 4, then they will indulge since 4 is divided by 2 and gcd(2, 3) = 1. If kids sit on chairs with numbers 4, 6, 10, then they will not indulge.
The teacher really doesn't want the mess at the table, so she wants to seat the kids so there are no 2 of the kid that can indulge. More formally, she wants no pair of chairs a and b that the kids occupy to fulfill the condition above.
Since the teacher is very busy with the entertainment of the kids, she asked you to solve this problem.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case consists of one line containing an integer n (1 ≤ n ≤ 100) — the number of kids.
Output
Output t lines, which contain n distinct integers from 1 to 4n — the numbers of chairs that the kids should occupy in the corresponding test case. If there are multiple answers, print any of them. You can print n numbers in any order.
Example
Input
3
2
3
4
Output
6 4
4 6 10
14 10 12 8 | instruction | 0 | 62,479 | 22 | 124,958 |
Tags: constructive algorithms, math
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
k = 4*n
for i in range(n):
print(k-2*i,end=" ")
print()
``` | output | 1 | 62,479 | 22 | 124,959 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Today the kindergarten has a new group of n kids who need to be seated at the dinner table. The chairs at the table are numbered from 1 to 4n. Two kids can't sit on the same chair. It is known that two kids who sit on chairs with numbers a and b (a ≠ b) will indulge if:
1. gcd(a, b) = 1 or,
2. a divides b or b divides a.
gcd(a, b) — the maximum number x such that a is divisible by x and b is divisible by x.
For example, if n=3 and the kids sit on chairs with numbers 2, 3, 4, then they will indulge since 4 is divided by 2 and gcd(2, 3) = 1. If kids sit on chairs with numbers 4, 6, 10, then they will not indulge.
The teacher really doesn't want the mess at the table, so she wants to seat the kids so there are no 2 of the kid that can indulge. More formally, she wants no pair of chairs a and b that the kids occupy to fulfill the condition above.
Since the teacher is very busy with the entertainment of the kids, she asked you to solve this problem.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case consists of one line containing an integer n (1 ≤ n ≤ 100) — the number of kids.
Output
Output t lines, which contain n distinct integers from 1 to 4n — the numbers of chairs that the kids should occupy in the corresponding test case. If there are multiple answers, print any of them. You can print n numbers in any order.
Example
Input
3
2
3
4
Output
6 4
4 6 10
14 10 12 8 | instruction | 0 | 62,480 | 22 | 124,960 |
Tags: constructive algorithms, math
Correct Solution:
```
t=int(input())
for i in range(t):
n=int(input())
l=[]
if n==1:
print(n)
else:
a=(2*n)+2
b=(4*n)+1
for k in range(a,b):
if k%2==0:
l.append(k)
if n!=1:
print(*l)
``` | output | 1 | 62,480 | 22 | 124,961 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Today the kindergarten has a new group of n kids who need to be seated at the dinner table. The chairs at the table are numbered from 1 to 4n. Two kids can't sit on the same chair. It is known that two kids who sit on chairs with numbers a and b (a ≠ b) will indulge if:
1. gcd(a, b) = 1 or,
2. a divides b or b divides a.
gcd(a, b) — the maximum number x such that a is divisible by x and b is divisible by x.
For example, if n=3 and the kids sit on chairs with numbers 2, 3, 4, then they will indulge since 4 is divided by 2 and gcd(2, 3) = 1. If kids sit on chairs with numbers 4, 6, 10, then they will not indulge.
The teacher really doesn't want the mess at the table, so she wants to seat the kids so there are no 2 of the kid that can indulge. More formally, she wants no pair of chairs a and b that the kids occupy to fulfill the condition above.
Since the teacher is very busy with the entertainment of the kids, she asked you to solve this problem.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case consists of one line containing an integer n (1 ≤ n ≤ 100) — the number of kids.
Output
Output t lines, which contain n distinct integers from 1 to 4n — the numbers of chairs that the kids should occupy in the corresponding test case. If there are multiple answers, print any of them. You can print n numbers in any order.
Example
Input
3
2
3
4
Output
6 4
4 6 10
14 10 12 8 | instruction | 0 | 62,481 | 22 | 124,962 |
Tags: constructive algorithms, math
Correct Solution:
```
t = int(input())
for i in range(t):
n = int(input())
lst1 = []
for i in range(1,4*n+1):
lst1.append(2*i)
for i in range(n-1,2*n-1):
print(lst1[i],end = " ")
print()
``` | output | 1 | 62,481 | 22 | 124,963 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Today the kindergarten has a new group of n kids who need to be seated at the dinner table. The chairs at the table are numbered from 1 to 4n. Two kids can't sit on the same chair. It is known that two kids who sit on chairs with numbers a and b (a ≠ b) will indulge if:
1. gcd(a, b) = 1 or,
2. a divides b or b divides a.
gcd(a, b) — the maximum number x such that a is divisible by x and b is divisible by x.
For example, if n=3 and the kids sit on chairs with numbers 2, 3, 4, then they will indulge since 4 is divided by 2 and gcd(2, 3) = 1. If kids sit on chairs with numbers 4, 6, 10, then they will not indulge.
The teacher really doesn't want the mess at the table, so she wants to seat the kids so there are no 2 of the kid that can indulge. More formally, she wants no pair of chairs a and b that the kids occupy to fulfill the condition above.
Since the teacher is very busy with the entertainment of the kids, she asked you to solve this problem.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case consists of one line containing an integer n (1 ≤ n ≤ 100) — the number of kids.
Output
Output t lines, which contain n distinct integers from 1 to 4n — the numbers of chairs that the kids should occupy in the corresponding test case. If there are multiple answers, print any of them. You can print n numbers in any order.
Example
Input
3
2
3
4
Output
6 4
4 6 10
14 10 12 8 | instruction | 0 | 62,482 | 22 | 124,964 |
Tags: constructive algorithms, math
Correct Solution:
```
from sys import stdin
def main():
input = lambda: stdin.readline()[:-1]
T = int(input())
for _ in [0] * T:
N = int(input())
chair = 4 * N
ans = []
for _ in range(N):
ans.append(chair)
chair -= 2
print(*ans)
main()
``` | output | 1 | 62,482 | 22 | 124,965 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Today the kindergarten has a new group of n kids who need to be seated at the dinner table. The chairs at the table are numbered from 1 to 4n. Two kids can't sit on the same chair. It is known that two kids who sit on chairs with numbers a and b (a ≠ b) will indulge if:
1. gcd(a, b) = 1 or,
2. a divides b or b divides a.
gcd(a, b) — the maximum number x such that a is divisible by x and b is divisible by x.
For example, if n=3 and the kids sit on chairs with numbers 2, 3, 4, then they will indulge since 4 is divided by 2 and gcd(2, 3) = 1. If kids sit on chairs with numbers 4, 6, 10, then they will not indulge.
The teacher really doesn't want the mess at the table, so she wants to seat the kids so there are no 2 of the kid that can indulge. More formally, she wants no pair of chairs a and b that the kids occupy to fulfill the condition above.
Since the teacher is very busy with the entertainment of the kids, she asked you to solve this problem.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case consists of one line containing an integer n (1 ≤ n ≤ 100) — the number of kids.
Output
Output t lines, which contain n distinct integers from 1 to 4n — the numbers of chairs that the kids should occupy in the corresponding test case. If there are multiple answers, print any of them. You can print n numbers in any order.
Example
Input
3
2
3
4
Output
6 4
4 6 10
14 10 12 8 | instruction | 0 | 62,483 | 22 | 124,966 |
Tags: constructive algorithms, math
Correct Solution:
```
#include <CodeforcesSolutions.h>
#include <ONLINE_JUDGE <solution.cf(contestID = "1443",questionID = "A",method = "GET")>.h>
"""
Author : thekushalghosh
Team : CodeDiggers
I prefer Python language over the C++ language :p :D
Visit my website : thekushalghosh.github.io
"""
import sys,math,cmath,time
start_time = time.time()
##########################################################################
################# ---- THE ACTUAL CODE STARTS BELOW ---- #################
def solve():
n = inp()
q = []
for i in range(4 * n,2 * n,-2):
q.append(i)
print(*q)
################## ---- THE ACTUAL CODE ENDS ABOVE ---- ##################
##########################################################################
def main():
global tt
if not ONLINE_JUDGE:
sys.stdin = open("input.txt","r")
sys.stdout = open("output.txt","w")
t = 1
t = inp()
for tt in range(1,t + 1):
solve()
if not ONLINE_JUDGE:
print("Time Elapsed :",time.time() - start_time,"seconds")
sys.stdout.close()
#---------------------- USER DEFINED INPUT FUNCTIONS ----------------------#
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
return(input().strip())
def invr():
return(map(int,input().split()))
#------------------ USER DEFINED PROGRAMMING FUNCTIONS ------------------#
def counter(a):
q = [0] * max(a)
for i in range(len(a)):
q[a[i] - 1] = q[a[i] - 1] + 1
return(q)
def counter_elements(a):
q = dict()
for i in range(len(a)):
if a[i] not in q:
q[a[i]] = 0
q[a[i]] = q[a[i]] + 1
return(q)
def string_counter(a):
q = [0] * 26
for i in range(len(a)):
q[ord(a[i]) - 97] = q[ord(a[i]) - 97] + 1
return(q)
def factorial(n,m = 1000000007):
q = 1
for i in range(n):
q = (q * (i + 1)) % m
return(q)
def factors(n):
q = []
for i in range(1,int(n ** 0.5) + 1):
if n % i == 0: q.append(i); q.append(n // i)
return(list(sorted(list(set(q)))))
def prime_factors(n):
q = []
while n % 2 == 0: q.append(2); n = n // 2
for i in range(3,int(n ** 0.5) + 1,2):
while n % i == 0: q.append(i); n = n // i
if n > 2: q.append(n)
return(list(sorted(q)))
def transpose(a):
n,m = len(a),len(a[0])
b = [[0] * n for i in range(m)]
for i in range(m):
for j in range(n):
b[i][j] = a[j][i]
return(b)
def power_two(x):
return (x and (not(x & (x - 1))))
def ceil(a, b):
return -(-a // b)
def seive(n):
a = [1]
prime = [True for i in range(n + 1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p ** 2,n + 1,p):
prime[i] = False
p = p + 1
for p in range(2,n + 1):
if prime[p]:
a.append(p)
return(a)
def ncr(n,r):
return(math.factorial(n) // (math.factorial(n - r) * math.factorial(r)))
def npr(n,r):
return(math.factorial(n) // math.factorial(n - r))
#-----------------------------------------------------------------------#
ONLINE_JUDGE = __debug__
if ONLINE_JUDGE:
#import io,os
#input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
input = sys.stdin.readline
main()
``` | output | 1 | 62,483 | 22 | 124,967 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Today the kindergarten has a new group of n kids who need to be seated at the dinner table. The chairs at the table are numbered from 1 to 4n. Two kids can't sit on the same chair. It is known that two kids who sit on chairs with numbers a and b (a ≠ b) will indulge if:
1. gcd(a, b) = 1 or,
2. a divides b or b divides a.
gcd(a, b) — the maximum number x such that a is divisible by x and b is divisible by x.
For example, if n=3 and the kids sit on chairs with numbers 2, 3, 4, then they will indulge since 4 is divided by 2 and gcd(2, 3) = 1. If kids sit on chairs with numbers 4, 6, 10, then they will not indulge.
The teacher really doesn't want the mess at the table, so she wants to seat the kids so there are no 2 of the kid that can indulge. More formally, she wants no pair of chairs a and b that the kids occupy to fulfill the condition above.
Since the teacher is very busy with the entertainment of the kids, she asked you to solve this problem.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case consists of one line containing an integer n (1 ≤ n ≤ 100) — the number of kids.
Output
Output t lines, which contain n distinct integers from 1 to 4n — the numbers of chairs that the kids should occupy in the corresponding test case. If there are multiple answers, print any of them. You can print n numbers in any order.
Example
Input
3
2
3
4
Output
6 4
4 6 10
14 10 12 8 | instruction | 0 | 62,484 | 22 | 124,968 |
Tags: constructive algorithms, math
Correct Solution:
```
try:
t=int(input())
for i in range(t):
n=int(input())
p=[]
limit=4*n
first=limit-2
for i in range(first,0,-2):
flag="Blue"
for j in range(len(p)):
if p[j]%i==0:
flag="Red"
break
if flag=="Blue":
p.append(i)
for i in p:
print(i,end=" ")
print("")
except:
pass
``` | output | 1 | 62,484 | 22 | 124,969 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Today the kindergarten has a new group of n kids who need to be seated at the dinner table. The chairs at the table are numbered from 1 to 4n. Two kids can't sit on the same chair. It is known that two kids who sit on chairs with numbers a and b (a ≠ b) will indulge if:
1. gcd(a, b) = 1 or,
2. a divides b or b divides a.
gcd(a, b) — the maximum number x such that a is divisible by x and b is divisible by x.
For example, if n=3 and the kids sit on chairs with numbers 2, 3, 4, then they will indulge since 4 is divided by 2 and gcd(2, 3) = 1. If kids sit on chairs with numbers 4, 6, 10, then they will not indulge.
The teacher really doesn't want the mess at the table, so she wants to seat the kids so there are no 2 of the kid that can indulge. More formally, she wants no pair of chairs a and b that the kids occupy to fulfill the condition above.
Since the teacher is very busy with the entertainment of the kids, she asked you to solve this problem.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case consists of one line containing an integer n (1 ≤ n ≤ 100) — the number of kids.
Output
Output t lines, which contain n distinct integers from 1 to 4n — the numbers of chairs that the kids should occupy in the corresponding test case. If there are multiple answers, print any of them. You can print n numbers in any order.
Example
Input
3
2
3
4
Output
6 4
4 6 10
14 10 12 8 | instruction | 0 | 62,485 | 22 | 124,970 |
Tags: constructive algorithms, math
Correct Solution:
```
t=int(input())
for i in range(t):
n=int(input())
s=''
k=4*n
for i in range(n):
s=s+str(k)+" "
k=k-2
print(s)
``` | output | 1 | 62,485 | 22 | 124,971 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Today the kindergarten has a new group of n kids who need to be seated at the dinner table. The chairs at the table are numbered from 1 to 4n. Two kids can't sit on the same chair. It is known that two kids who sit on chairs with numbers a and b (a ≠ b) will indulge if:
1. gcd(a, b) = 1 or,
2. a divides b or b divides a.
gcd(a, b) — the maximum number x such that a is divisible by x and b is divisible by x.
For example, if n=3 and the kids sit on chairs with numbers 2, 3, 4, then they will indulge since 4 is divided by 2 and gcd(2, 3) = 1. If kids sit on chairs with numbers 4, 6, 10, then they will not indulge.
The teacher really doesn't want the mess at the table, so she wants to seat the kids so there are no 2 of the kid that can indulge. More formally, she wants no pair of chairs a and b that the kids occupy to fulfill the condition above.
Since the teacher is very busy with the entertainment of the kids, she asked you to solve this problem.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case consists of one line containing an integer n (1 ≤ n ≤ 100) — the number of kids.
Output
Output t lines, which contain n distinct integers from 1 to 4n — the numbers of chairs that the kids should occupy in the corresponding test case. If there are multiple answers, print any of them. You can print n numbers in any order.
Example
Input
3
2
3
4
Output
6 4
4 6 10
14 10 12 8 | instruction | 0 | 62,486 | 22 | 124,972 |
Tags: constructive algorithms, math
Correct Solution:
```
import math
for t in range(int(input())):
n = int(input())
li = list()
tr = 4*n
li.append(tr)
while(len(li)<n):
while(tr>=1):
if(math.gcd(tr,li[-1]) not in [1,tr,li[-1]]):
li.append(tr)
break
else:
tr -= 1
tr -= 1
li = li[::-1]
for data in li:
print(data,end=" ")
print()
``` | output | 1 | 62,486 | 22 | 124,973 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today the kindergarten has a new group of n kids who need to be seated at the dinner table. The chairs at the table are numbered from 1 to 4n. Two kids can't sit on the same chair. It is known that two kids who sit on chairs with numbers a and b (a ≠ b) will indulge if:
1. gcd(a, b) = 1 or,
2. a divides b or b divides a.
gcd(a, b) — the maximum number x such that a is divisible by x and b is divisible by x.
For example, if n=3 and the kids sit on chairs with numbers 2, 3, 4, then they will indulge since 4 is divided by 2 and gcd(2, 3) = 1. If kids sit on chairs with numbers 4, 6, 10, then they will not indulge.
The teacher really doesn't want the mess at the table, so she wants to seat the kids so there are no 2 of the kid that can indulge. More formally, she wants no pair of chairs a and b that the kids occupy to fulfill the condition above.
Since the teacher is very busy with the entertainment of the kids, she asked you to solve this problem.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case consists of one line containing an integer n (1 ≤ n ≤ 100) — the number of kids.
Output
Output t lines, which contain n distinct integers from 1 to 4n — the numbers of chairs that the kids should occupy in the corresponding test case. If there are multiple answers, print any of them. You can print n numbers in any order.
Example
Input
3
2
3
4
Output
6 4
4 6 10
14 10 12 8
Submitted Solution:
```
import sys
t=int(input().strip())
for a0 in range(t):
n=int(input())
if(n==1):
print(4)
elif(n==2):
print(4,6)
else:
a=2*n-2
s=str(a)
c=a+2
for i in range(n):
if(c%a==0):
pass
else:
s+=' '+str(c)
c+=2
print(s)
``` | instruction | 0 | 62,487 | 22 | 124,974 |
Yes | output | 1 | 62,487 | 22 | 124,975 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today the kindergarten has a new group of n kids who need to be seated at the dinner table. The chairs at the table are numbered from 1 to 4n. Two kids can't sit on the same chair. It is known that two kids who sit on chairs with numbers a and b (a ≠ b) will indulge if:
1. gcd(a, b) = 1 or,
2. a divides b or b divides a.
gcd(a, b) — the maximum number x such that a is divisible by x and b is divisible by x.
For example, if n=3 and the kids sit on chairs with numbers 2, 3, 4, then they will indulge since 4 is divided by 2 and gcd(2, 3) = 1. If kids sit on chairs with numbers 4, 6, 10, then they will not indulge.
The teacher really doesn't want the mess at the table, so she wants to seat the kids so there are no 2 of the kid that can indulge. More formally, she wants no pair of chairs a and b that the kids occupy to fulfill the condition above.
Since the teacher is very busy with the entertainment of the kids, she asked you to solve this problem.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case consists of one line containing an integer n (1 ≤ n ≤ 100) — the number of kids.
Output
Output t lines, which contain n distinct integers from 1 to 4n — the numbers of chairs that the kids should occupy in the corresponding test case. If there are multiple answers, print any of them. You can print n numbers in any order.
Example
Input
3
2
3
4
Output
6 4
4 6 10
14 10 12 8
Submitted Solution:
```
import sys
from math import gcd,sqrt,ceil,log2
from collections import defaultdict,Counter,deque
from bisect import bisect_left,bisect_right
import math
sys.setrecursionlimit(2*10**5+10)
import heapq
from itertools import permutations
# input=sys.stdin.readline
# def print(x):
# sys.stdout.write(str(x)+"\n")
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
aa='abcdefghijklmnopqrstuvwxyz'
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")
# import sys
# import io, os
# input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def get_sum(bit,i):
s = 0
i+=1
while i>0:
s+=bit[i]
i-=i&(-i)
return s
def update(bit,n,i,v):
i+=1
while i<=n:
bit[i]+=v
i+=i&(-i)
def modInverse(b,m):
g = math.gcd(b, m)
if (g != 1):
return -1
else:
return pow(b, m - 2, m)
def primeFactors(n):
sa = []
# sa.add(n)
while n % 2 == 0:
sa.append(2)
n = n // 2
for i in range(3,int(math.sqrt(n))+1,2):
while n % i== 0:
sa.append(i)
n = n // i
# sa.add(n)
if n > 2:
sa.append(n)
return sa
def seive(n):
pri = [True]*(n+1)
p = 2
while p*p<=n:
if pri[p] == True:
for i in range(p*p,n+1,p):
pri[i] = False
p+=1
return pri
def check_prim(n):
if n<0:
return False
for i in range(2,int(sqrt(n))+1):
if n%i == 0:
return False
return True
def getZarr(string, z):
n = len(string)
# [L,R] make a window which matches
# with prefix of s
l, r, k = 0, 0, 0
for i in range(1, n):
# if i>R nothing matches so we will calculate.
# Z[i] using naive way.
if i > r:
l, r = i, i
# R-L = 0 in starting, so it will start
# checking from 0'th index. For example,
# for "ababab" and i = 1, the value of R
# remains 0 and Z[i] becomes 0. For string
# "aaaaaa" and i = 1, Z[i] and R become 5
while r < n and string[r - l] == string[r]:
r += 1
z[i] = r - l
r -= 1
else:
# k = i-L so k corresponds to number which
# matches in [L,R] interval.
k = i - l
# if Z[k] is less than remaining interval
# then Z[i] will be equal to Z[k].
# For example, str = "ababab", i = 3, R = 5
# and L = 2
if z[k] < r - i + 1:
z[i] = z[k]
# For example str = "aaaaaa" and i = 2,
# R is 5, L is 0
else:
# else start from R and check manually
l = i
while r < n and string[r - l] == string[r]:
r += 1
z[i] = r - l
r -= 1
def search(text, pattern):
# Create concatenated string "P$T"
concat = pattern + "$" + text
l = len(concat)
z = [0] * l
getZarr(concat, z)
ha = []
for i in range(l):
if z[i] == len(pattern):
ha.append(i - len(pattern) - 1)
return ha
# n,k = map(int,input().split())
# l = list(map(int,input().split()))
#
# n = int(input())
# l = list(map(int,input().split()))
#
# hash = defaultdict(list)
# la = []
#
# for i in range(n):
# la.append([l[i],i+1])
#
# la.sort(key = lambda x: (x[0],-x[1]))
# ans = []
# r = n
# flag = 0
# lo = []
# ha = [i for i in range(n,0,-1)]
# yo = []
# for a,b in la:
#
# if a == 1:
# ans.append([r,b])
# # hash[(1,1)].append([b,r])
# lo.append((r,b))
# ha.pop(0)
# yo.append([r,b])
# r-=1
#
# elif a == 2:
# # print(yo,lo)
# # print(hash[1,1])
# if lo == []:
# flag = 1
# break
# c,d = lo.pop(0)
# yo.pop(0)
# if b>=d:
# flag = 1
# break
# ans.append([c,b])
# yo.append([c,b])
#
#
#
# elif a == 3:
#
# if yo == []:
# flag = 1
# break
# c,d = yo.pop(0)
# if b>=d:
# flag = 1
# break
# if ha == []:
# flag = 1
# break
#
# ka = ha.pop(0)
#
# ans.append([ka,b])
# ans.append([ka,d])
# yo.append([ka,b])
#
# if flag:
# print(-1)
# else:
# print(len(ans))
# for a,b in ans:
# print(a,b)
def mergeIntervals(arr):
# Sorting based on the increasing order
# of the start intervals
arr.sort(key = lambda x: x[0])
# array to hold the merged intervals
m = []
s = -10000
max = -100000
for i in range(len(arr)):
a = arr[i]
if a[0] > max:
if i != 0:
m.append([s,max])
max = a[1]
s = a[0]
else:
if a[1] >= max:
max = a[1]
#'max' value gives the last point of
# that particular interval
# 's' gives the starting point of that interval
# 'm' array contains the list of all merged intervals
if max != -100000 and [s, max] not in m:
m.append([s, max])
return m
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
def ncr(n, r, p):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den,
p - 2, p)) % p
def sol(n):
seti = set()
for i in range(1,int(sqrt(n))+1):
if n%i == 0:
seti.add(n//i)
seti.add(i)
return seti
def lcm(a,b):
return (a*b)//gcd(a,b)
#
# n,p = map(int,input().split())
#
# s = input()
#
# if n <=2:
# if n == 1:
# pass
# if n == 2:
# pass
# i = n-1
# idx = -1
# while i>=0:
# z = ord(s[i])-96
# k = chr(z+1+96)
# flag = 1
# if i-1>=0:
# if s[i-1]!=k:
# flag+=1
# else:
# flag+=1
# if i-2>=0:
# if s[i-2]!=k:
# flag+=1
# else:
# flag+=1
# if flag == 2:
# idx = i
# s[i] = k
# break
# if idx == -1:
# print('NO')
# exit()
# for i in range(idx+1,n):
# if
#
t = int(input())
for _ in range(t):
n = int(input())
temp = 4
ans = []
while len(ans)!=n:
ans = [temp]
for i in range(temp+1,4*n+1):
if len(ans) == n:
break
flag = 0
for j in ans:
if gcd(j,i) == 1 or j%i == 0 or i%j == 0:
flag = 1
break
if not flag:
ans.append(i)
temp+=1
print(*ans)
``` | instruction | 0 | 62,488 | 22 | 124,976 |
Yes | output | 1 | 62,488 | 22 | 124,977 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today the kindergarten has a new group of n kids who need to be seated at the dinner table. The chairs at the table are numbered from 1 to 4n. Two kids can't sit on the same chair. It is known that two kids who sit on chairs with numbers a and b (a ≠ b) will indulge if:
1. gcd(a, b) = 1 or,
2. a divides b or b divides a.
gcd(a, b) — the maximum number x such that a is divisible by x and b is divisible by x.
For example, if n=3 and the kids sit on chairs with numbers 2, 3, 4, then they will indulge since 4 is divided by 2 and gcd(2, 3) = 1. If kids sit on chairs with numbers 4, 6, 10, then they will not indulge.
The teacher really doesn't want the mess at the table, so she wants to seat the kids so there are no 2 of the kid that can indulge. More formally, she wants no pair of chairs a and b that the kids occupy to fulfill the condition above.
Since the teacher is very busy with the entertainment of the kids, she asked you to solve this problem.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case consists of one line containing an integer n (1 ≤ n ≤ 100) — the number of kids.
Output
Output t lines, which contain n distinct integers from 1 to 4n — the numbers of chairs that the kids should occupy in the corresponding test case. If there are multiple answers, print any of them. You can print n numbers in any order.
Example
Input
3
2
3
4
Output
6 4
4 6 10
14 10 12 8
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
for i in range(n):
print(4*n-2*i, end= " ")
print()
``` | instruction | 0 | 62,489 | 22 | 124,978 |
Yes | output | 1 | 62,489 | 22 | 124,979 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today the kindergarten has a new group of n kids who need to be seated at the dinner table. The chairs at the table are numbered from 1 to 4n. Two kids can't sit on the same chair. It is known that two kids who sit on chairs with numbers a and b (a ≠ b) will indulge if:
1. gcd(a, b) = 1 or,
2. a divides b or b divides a.
gcd(a, b) — the maximum number x such that a is divisible by x and b is divisible by x.
For example, if n=3 and the kids sit on chairs with numbers 2, 3, 4, then they will indulge since 4 is divided by 2 and gcd(2, 3) = 1. If kids sit on chairs with numbers 4, 6, 10, then they will not indulge.
The teacher really doesn't want the mess at the table, so she wants to seat the kids so there are no 2 of the kid that can indulge. More formally, she wants no pair of chairs a and b that the kids occupy to fulfill the condition above.
Since the teacher is very busy with the entertainment of the kids, she asked you to solve this problem.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case consists of one line containing an integer n (1 ≤ n ≤ 100) — the number of kids.
Output
Output t lines, which contain n distinct integers from 1 to 4n — the numbers of chairs that the kids should occupy in the corresponding test case. If there are multiple answers, print any of them. You can print n numbers in any order.
Example
Input
3
2
3
4
Output
6 4
4 6 10
14 10 12 8
Submitted Solution:
```
t=int(input())
for i in range(t):
n = int(input())
if n==1:
print(2)
else:
for j in range((4*n)-2,2*n-2,-2):
print(j,end=" ")
print()
``` | instruction | 0 | 62,490 | 22 | 124,980 |
Yes | output | 1 | 62,490 | 22 | 124,981 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today the kindergarten has a new group of n kids who need to be seated at the dinner table. The chairs at the table are numbered from 1 to 4n. Two kids can't sit on the same chair. It is known that two kids who sit on chairs with numbers a and b (a ≠ b) will indulge if:
1. gcd(a, b) = 1 or,
2. a divides b or b divides a.
gcd(a, b) — the maximum number x such that a is divisible by x and b is divisible by x.
For example, if n=3 and the kids sit on chairs with numbers 2, 3, 4, then they will indulge since 4 is divided by 2 and gcd(2, 3) = 1. If kids sit on chairs with numbers 4, 6, 10, then they will not indulge.
The teacher really doesn't want the mess at the table, so she wants to seat the kids so there are no 2 of the kid that can indulge. More formally, she wants no pair of chairs a and b that the kids occupy to fulfill the condition above.
Since the teacher is very busy with the entertainment of the kids, she asked you to solve this problem.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case consists of one line containing an integer n (1 ≤ n ≤ 100) — the number of kids.
Output
Output t lines, which contain n distinct integers from 1 to 4n — the numbers of chairs that the kids should occupy in the corresponding test case. If there are multiple answers, print any of them. You can print n numbers in any order.
Example
Input
3
2
3
4
Output
6 4
4 6 10
14 10 12 8
Submitted Solution:
```
l = []
for i in range(2,600):
f = 1
for j in range(2,int(i**0.5)+1):
if i%j==0:
f = 0
break
if f:l.append(i)
for _ in range(int(input())):
n = int(input())
for i in l[:n]:
print(2*i,end=' ')
print()
``` | instruction | 0 | 62,491 | 22 | 124,982 |
No | output | 1 | 62,491 | 22 | 124,983 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today the kindergarten has a new group of n kids who need to be seated at the dinner table. The chairs at the table are numbered from 1 to 4n. Two kids can't sit on the same chair. It is known that two kids who sit on chairs with numbers a and b (a ≠ b) will indulge if:
1. gcd(a, b) = 1 or,
2. a divides b or b divides a.
gcd(a, b) — the maximum number x such that a is divisible by x and b is divisible by x.
For example, if n=3 and the kids sit on chairs with numbers 2, 3, 4, then they will indulge since 4 is divided by 2 and gcd(2, 3) = 1. If kids sit on chairs with numbers 4, 6, 10, then they will not indulge.
The teacher really doesn't want the mess at the table, so she wants to seat the kids so there are no 2 of the kid that can indulge. More formally, she wants no pair of chairs a and b that the kids occupy to fulfill the condition above.
Since the teacher is very busy with the entertainment of the kids, she asked you to solve this problem.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case consists of one line containing an integer n (1 ≤ n ≤ 100) — the number of kids.
Output
Output t lines, which contain n distinct integers from 1 to 4n — the numbers of chairs that the kids should occupy in the corresponding test case. If there are multiple answers, print any of them. You can print n numbers in any order.
Example
Input
3
2
3
4
Output
6 4
4 6 10
14 10 12 8
Submitted Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
if (n == 1):
print(4)
else:
dp = [4,6]
for i in range(1,n):
dp.append(dp[i-1] * 2 +2)
print(*dp[0:n])
``` | instruction | 0 | 62,492 | 22 | 124,984 |
No | output | 1 | 62,492 | 22 | 124,985 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today the kindergarten has a new group of n kids who need to be seated at the dinner table. The chairs at the table are numbered from 1 to 4n. Two kids can't sit on the same chair. It is known that two kids who sit on chairs with numbers a and b (a ≠ b) will indulge if:
1. gcd(a, b) = 1 or,
2. a divides b or b divides a.
gcd(a, b) — the maximum number x such that a is divisible by x and b is divisible by x.
For example, if n=3 and the kids sit on chairs with numbers 2, 3, 4, then they will indulge since 4 is divided by 2 and gcd(2, 3) = 1. If kids sit on chairs with numbers 4, 6, 10, then they will not indulge.
The teacher really doesn't want the mess at the table, so she wants to seat the kids so there are no 2 of the kid that can indulge. More formally, she wants no pair of chairs a and b that the kids occupy to fulfill the condition above.
Since the teacher is very busy with the entertainment of the kids, she asked you to solve this problem.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case consists of one line containing an integer n (1 ≤ n ≤ 100) — the number of kids.
Output
Output t lines, which contain n distinct integers from 1 to 4n — the numbers of chairs that the kids should occupy in the corresponding test case. If there are multiple answers, print any of them. You can print n numbers in any order.
Example
Input
3
2
3
4
Output
6 4
4 6 10
14 10 12 8
Submitted Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
for i in range(1,n+1):
print(2 * i, end = ' ')
``` | instruction | 0 | 62,493 | 22 | 124,986 |
No | output | 1 | 62,493 | 22 | 124,987 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today the kindergarten has a new group of n kids who need to be seated at the dinner table. The chairs at the table are numbered from 1 to 4n. Two kids can't sit on the same chair. It is known that two kids who sit on chairs with numbers a and b (a ≠ b) will indulge if:
1. gcd(a, b) = 1 or,
2. a divides b or b divides a.
gcd(a, b) — the maximum number x such that a is divisible by x and b is divisible by x.
For example, if n=3 and the kids sit on chairs with numbers 2, 3, 4, then they will indulge since 4 is divided by 2 and gcd(2, 3) = 1. If kids sit on chairs with numbers 4, 6, 10, then they will not indulge.
The teacher really doesn't want the mess at the table, so she wants to seat the kids so there are no 2 of the kid that can indulge. More formally, she wants no pair of chairs a and b that the kids occupy to fulfill the condition above.
Since the teacher is very busy with the entertainment of the kids, she asked you to solve this problem.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case consists of one line containing an integer n (1 ≤ n ≤ 100) — the number of kids.
Output
Output t lines, which contain n distinct integers from 1 to 4n — the numbers of chairs that the kids should occupy in the corresponding test case. If there are multiple answers, print any of them. You can print n numbers in any order.
Example
Input
3
2
3
4
Output
6 4
4 6 10
14 10 12 8
Submitted Solution:
```
import sys
#input = sys.stdin.readline
t = int(input())
for test in range(t):
n = int(input())
#[n, x] = list(map(int, input().split(" ")))
#a = list(map(int, input().split(" ")))
res = []
for i in range(n):
res.append(str(4+2*i))
print(" ".join(res))
``` | instruction | 0 | 62,494 | 22 | 124,988 |
No | output | 1 | 62,494 | 22 | 124,989 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Valera had two bags of potatoes, the first of these bags contains x (x ≥ 1) potatoes, and the second — y (y ≥ 1) potatoes. Valera — very scattered boy, so the first bag of potatoes (it contains x potatoes) Valera lost. Valera remembers that the total amount of potatoes (x + y) in the two bags, firstly, was not gerater than n, and, secondly, was divisible by k.
Help Valera to determine how many potatoes could be in the first bag. Print all such possible numbers in ascending order.
Input
The first line of input contains three integers y, k, n (1 ≤ y, k, n ≤ 109; <image> ≤ 105).
Output
Print the list of whitespace-separated integers — all possible values of x in ascending order. You should print each possible value of x exactly once.
If there are no such values of x print a single integer -1.
Examples
Input
10 1 10
Output
-1
Input
10 6 40
Output
2 8 14 20 26 | instruction | 0 | 62,594 | 22 | 125,188 |
Tags: greedy, implementation, math
Correct Solution:
```
y,k,n=map(int,input().split(" "))
if y>=n:
print(-1)
else:
x=k-y%k
flag=0
while x<=n-y:
flag=1
print(x,end=" ")
x=x+k
if flag==0:
print(-1)
``` | output | 1 | 62,594 | 22 | 125,189 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Valera had two bags of potatoes, the first of these bags contains x (x ≥ 1) potatoes, and the second — y (y ≥ 1) potatoes. Valera — very scattered boy, so the first bag of potatoes (it contains x potatoes) Valera lost. Valera remembers that the total amount of potatoes (x + y) in the two bags, firstly, was not gerater than n, and, secondly, was divisible by k.
Help Valera to determine how many potatoes could be in the first bag. Print all such possible numbers in ascending order.
Input
The first line of input contains three integers y, k, n (1 ≤ y, k, n ≤ 109; <image> ≤ 105).
Output
Print the list of whitespace-separated integers — all possible values of x in ascending order. You should print each possible value of x exactly once.
If there are no such values of x print a single integer -1.
Examples
Input
10 1 10
Output
-1
Input
10 6 40
Output
2 8 14 20 26 | instruction | 0 | 62,595 | 22 | 125,190 |
Tags: greedy, implementation, math
Correct Solution:
```
y, k ,n = map(int, input().split())
if n > y:
x = n - y
else:
x = n + 2*k
while (x + y)%k != 0:
x -= (x + y)%k
result = []
while (x + y) <= n and x >0 :
result.append(x)
x -= k
if result:
result.sort()
print(" ".join([str(j) for j in result]))
else:
print(-1)
``` | output | 1 | 62,595 | 22 | 125,191 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Valera had two bags of potatoes, the first of these bags contains x (x ≥ 1) potatoes, and the second — y (y ≥ 1) potatoes. Valera — very scattered boy, so the first bag of potatoes (it contains x potatoes) Valera lost. Valera remembers that the total amount of potatoes (x + y) in the two bags, firstly, was not gerater than n, and, secondly, was divisible by k.
Help Valera to determine how many potatoes could be in the first bag. Print all such possible numbers in ascending order.
Input
The first line of input contains three integers y, k, n (1 ≤ y, k, n ≤ 109; <image> ≤ 105).
Output
Print the list of whitespace-separated integers — all possible values of x in ascending order. You should print each possible value of x exactly once.
If there are no such values of x print a single integer -1.
Examples
Input
10 1 10
Output
-1
Input
10 6 40
Output
2 8 14 20 26 | instruction | 0 | 62,596 | 22 | 125,192 |
Tags: greedy, implementation, math
Correct Solution:
```
y, k, n = map(int, input().split())
print(' '.join(map(str, range(y//k*k+k-y, n-y+1, k))) if n//k>y//k else -1)
"""a,b,c=map(int,input().split())
d=0
for x in range(1,c):
a+=x
if a%b==0 and a<c:
d+=x
break
a-=x
if c-a<b: print(-1)
else:
for x in range(d,c-a+1,b):
print(x,end=" ")
"""
"""
a,b,c=map(int,input().split())
d=0
for x in range(1,c+1,b):
a+=x
if a%b==0 and a<=c:
print(x,end=" ")
a-=x
if c-a<b: print(-1)
"""
``` | output | 1 | 62,596 | 22 | 125,193 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Valera had two bags of potatoes, the first of these bags contains x (x ≥ 1) potatoes, and the second — y (y ≥ 1) potatoes. Valera — very scattered boy, so the first bag of potatoes (it contains x potatoes) Valera lost. Valera remembers that the total amount of potatoes (x + y) in the two bags, firstly, was not gerater than n, and, secondly, was divisible by k.
Help Valera to determine how many potatoes could be in the first bag. Print all such possible numbers in ascending order.
Input
The first line of input contains three integers y, k, n (1 ≤ y, k, n ≤ 109; <image> ≤ 105).
Output
Print the list of whitespace-separated integers — all possible values of x in ascending order. You should print each possible value of x exactly once.
If there are no such values of x print a single integer -1.
Examples
Input
10 1 10
Output
-1
Input
10 6 40
Output
2 8 14 20 26 | instruction | 0 | 62,597 | 22 | 125,194 |
Tags: greedy, implementation, math
Correct Solution:
```
y, k, n = [int(i) for i in input().split()]
border = n//k
flag = 0
for q in range(1, border + 1):
x = k*q - y
if x >= 1:
print(x, end=" ")
flag = 1
if not flag:
print(-1)
``` | output | 1 | 62,597 | 22 | 125,195 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Valera had two bags of potatoes, the first of these bags contains x (x ≥ 1) potatoes, and the second — y (y ≥ 1) potatoes. Valera — very scattered boy, so the first bag of potatoes (it contains x potatoes) Valera lost. Valera remembers that the total amount of potatoes (x + y) in the two bags, firstly, was not gerater than n, and, secondly, was divisible by k.
Help Valera to determine how many potatoes could be in the first bag. Print all such possible numbers in ascending order.
Input
The first line of input contains three integers y, k, n (1 ≤ y, k, n ≤ 109; <image> ≤ 105).
Output
Print the list of whitespace-separated integers — all possible values of x in ascending order. You should print each possible value of x exactly once.
If there are no such values of x print a single integer -1.
Examples
Input
10 1 10
Output
-1
Input
10 6 40
Output
2 8 14 20 26 | instruction | 0 | 62,598 | 22 | 125,196 |
Tags: greedy, implementation, math
Correct Solution:
```
y, k, n = [int(i) for i in input().split()]
s = []
start = k - y % k
stop = n - y + 1
for i in range(start, stop, k):
s += [i]
if len(s)>0:
print(' '.join(map(str, s)))
else:
print(-1)
``` | output | 1 | 62,598 | 22 | 125,197 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Valera had two bags of potatoes, the first of these bags contains x (x ≥ 1) potatoes, and the second — y (y ≥ 1) potatoes. Valera — very scattered boy, so the first bag of potatoes (it contains x potatoes) Valera lost. Valera remembers that the total amount of potatoes (x + y) in the two bags, firstly, was not gerater than n, and, secondly, was divisible by k.
Help Valera to determine how many potatoes could be in the first bag. Print all such possible numbers in ascending order.
Input
The first line of input contains three integers y, k, n (1 ≤ y, k, n ≤ 109; <image> ≤ 105).
Output
Print the list of whitespace-separated integers — all possible values of x in ascending order. You should print each possible value of x exactly once.
If there are no such values of x print a single integer -1.
Examples
Input
10 1 10
Output
-1
Input
10 6 40
Output
2 8 14 20 26 | instruction | 0 | 62,599 | 22 | 125,198 |
Tags: greedy, implementation, math
Correct Solution:
```
temp = list(map(int, input().split()))
y = temp[0]
k = temp[1]
n = temp[2]
possible = []
c = 1
x = None
while True:
x = c * k - y
if x + y > n:
break
if x > 0:
possible.append(x)
c += 1
if len(possible) == 0:
print('-1')
else:
for x in possible:
print(x, end=' ')
``` | output | 1 | 62,599 | 22 | 125,199 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Valera had two bags of potatoes, the first of these bags contains x (x ≥ 1) potatoes, and the second — y (y ≥ 1) potatoes. Valera — very scattered boy, so the first bag of potatoes (it contains x potatoes) Valera lost. Valera remembers that the total amount of potatoes (x + y) in the two bags, firstly, was not gerater than n, and, secondly, was divisible by k.
Help Valera to determine how many potatoes could be in the first bag. Print all such possible numbers in ascending order.
Input
The first line of input contains three integers y, k, n (1 ≤ y, k, n ≤ 109; <image> ≤ 105).
Output
Print the list of whitespace-separated integers — all possible values of x in ascending order. You should print each possible value of x exactly once.
If there are no such values of x print a single integer -1.
Examples
Input
10 1 10
Output
-1
Input
10 6 40
Output
2 8 14 20 26 | instruction | 0 | 62,600 | 22 | 125,200 |
Tags: greedy, implementation, math
Correct Solution:
```
import sys
inf = float("inf")
# sys.setrecursionlimit(10000000)
# abc='abcdefghijklmnopqrstuvwxyz'
# abd={'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
# mod, MOD = 1000000007, 998244353
# words = {1:'one',2:'two',3:'three',4:'four',5:'five',6:'six',7:'seven',8:'eight',9:'nine',10:'ten',11:'eleven',12:'twelve',13:'thirteen',14:'fourteen',15:'quarter',16:'sixteen',17:'seventeen',18:'eighteen',19:'nineteen',20:'twenty',21:'twenty one',22:'twenty two',23:'twenty three',24:'twenty four',25:'twenty five',26:'twenty six',27:'twenty seven',28:'twenty eight',29:'twenty nine',30:'half'}
# vow=['a','e','i','o','u']
# dx,dy=[0,1,0,-1],[1,0,-1,0]
# import random
# from collections import deque, Counter, OrderedDict,defaultdict
# from heapq import nsmallest, nlargest, heapify,heappop ,heappush, heapreplace
from math import ceil,floor,log,sqrt,factorial,pi,gcd
# from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def input(): return sys.stdin.readline().strip()
y,k,n = get_ints()
lst = []
if y%k==0:
first = k
else:
first = ceil(y/k)*k - y
while y+first<=n:
lst.append(first)
first+=k
if len(lst)==0:
print(-1)
else:
print(*lst)
``` | output | 1 | 62,600 | 22 | 125,201 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Valera had two bags of potatoes, the first of these bags contains x (x ≥ 1) potatoes, and the second — y (y ≥ 1) potatoes. Valera — very scattered boy, so the first bag of potatoes (it contains x potatoes) Valera lost. Valera remembers that the total amount of potatoes (x + y) in the two bags, firstly, was not gerater than n, and, secondly, was divisible by k.
Help Valera to determine how many potatoes could be in the first bag. Print all such possible numbers in ascending order.
Input
The first line of input contains three integers y, k, n (1 ≤ y, k, n ≤ 109; <image> ≤ 105).
Output
Print the list of whitespace-separated integers — all possible values of x in ascending order. You should print each possible value of x exactly once.
If there are no such values of x print a single integer -1.
Examples
Input
10 1 10
Output
-1
Input
10 6 40
Output
2 8 14 20 26 | instruction | 0 | 62,601 | 22 | 125,202 |
Tags: greedy, implementation, math
Correct Solution:
```
from sys import stdin, stdout
if not __debug__:
stdin = open("input.txt", "r")
tcs = int(stdin.readline()) if not __debug__ else 1
t = 1
while t<=tcs:
y, k, n = map(int, stdin.readline().split())
b = y//k + 1
e = n//k + 1
if b<e:
for i in range((y//k)+1, (n//k)):
print((k*i)-y, end=' ')
print(k*(n//k)-y)
else:
print(-1)
t += 1
``` | output | 1 | 62,601 | 22 | 125,203 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera had two bags of potatoes, the first of these bags contains x (x ≥ 1) potatoes, and the second — y (y ≥ 1) potatoes. Valera — very scattered boy, so the first bag of potatoes (it contains x potatoes) Valera lost. Valera remembers that the total amount of potatoes (x + y) in the two bags, firstly, was not gerater than n, and, secondly, was divisible by k.
Help Valera to determine how many potatoes could be in the first bag. Print all such possible numbers in ascending order.
Input
The first line of input contains three integers y, k, n (1 ≤ y, k, n ≤ 109; <image> ≤ 105).
Output
Print the list of whitespace-separated integers — all possible values of x in ascending order. You should print each possible value of x exactly once.
If there are no such values of x print a single integer -1.
Examples
Input
10 1 10
Output
-1
Input
10 6 40
Output
2 8 14 20 26
Submitted Solution:
```
import math,sys
from collections import Counter
def li(): return list(map(int,sys.stdin.readline().split()))
def ls(): return list(map(int,list(input())))
def la(): return list(input())
def i(): return int(input())
def isPrime(n):
i= 2
if n == 1:
return False
while i <= int(math.sqrt(n)):
if n%i == 0:
return False
i = i + 1
return True
def gcd(a,b):
if b == 0:
return a
return gcd(b,a%b)
y,k,n =li()
a = n//k
b = []
i = 0
if n>y:
while i<=a:
x = i*k-y
if x>0 and x<= n-y:
b.append(x)
i = i+1
if b == []:
print(-1)
else:
print(*b)
``` | instruction | 0 | 62,603 | 22 | 125,206 |
Yes | output | 1 | 62,603 | 22 | 125,207 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Toad Ivan has m pairs of integers, each integer is between 1 and n, inclusive. The pairs are (a_1, b_1), (a_2, b_2), …, (a_m, b_m).
He asks you to check if there exist two integers x and y (1 ≤ x < y ≤ n) such that in each given pair at least one integer is equal to x or y.
Input
The first line contains two space-separated integers n and m (2 ≤ n ≤ 300 000, 1 ≤ m ≤ 300 000) — the upper bound on the values of integers in the pairs, and the number of given pairs.
The next m lines contain two integers each, the i-th of them contains two space-separated integers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the integers in the i-th pair.
Output
Output "YES" if there exist two integers x and y (1 ≤ x < y ≤ n) such that in each given pair at least one integer is equal to x or y. Otherwise, print "NO". You can print each letter in any case (upper or lower).
Examples
Input
4 6
1 2
1 3
1 4
2 3
2 4
3 4
Output
NO
Input
5 4
1 2
2 3
3 4
4 5
Output
YES
Input
300000 5
1 2
1 2
1 2
1 2
1 2
Output
YES
Note
In the first example, you can't choose any x, y because for each such pair you can find a given pair where both numbers are different from chosen integers.
In the second example, you can choose x=2 and y=4.
In the third example, you can choose x=1 and y=2. | instruction | 0 | 63,190 | 22 | 126,380 |
Tags: graphs, implementation
Correct Solution:
```
n,m = map(int, input().split())
a = []
b = []
for i in range(m):
aa,bb = list(map(int, input().split()))
a.append(aa)
b.append(bb)
cand = [a[0], b[0]]
good = 0
for c in cand:
#check each c
rest = 0
d = {}
for i in range(m):
if (a[i] == c or b[i] == c):
continue
else:
d[a[i]] = d.get(a[i], 0) + 1
d[b[i]] = d.get(b[i], 0) + 1
rest += 1
if (rest == 0):
good = 1
for k in d.keys():
if (d[k] == rest):
good = 1
if (good == 1):
print("YES")
else:
print("NO")
``` | output | 1 | 63,190 | 22 | 126,381 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Toad Ivan has m pairs of integers, each integer is between 1 and n, inclusive. The pairs are (a_1, b_1), (a_2, b_2), …, (a_m, b_m).
He asks you to check if there exist two integers x and y (1 ≤ x < y ≤ n) such that in each given pair at least one integer is equal to x or y.
Input
The first line contains two space-separated integers n and m (2 ≤ n ≤ 300 000, 1 ≤ m ≤ 300 000) — the upper bound on the values of integers in the pairs, and the number of given pairs.
The next m lines contain two integers each, the i-th of them contains two space-separated integers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the integers in the i-th pair.
Output
Output "YES" if there exist two integers x and y (1 ≤ x < y ≤ n) such that in each given pair at least one integer is equal to x or y. Otherwise, print "NO". You can print each letter in any case (upper or lower).
Examples
Input
4 6
1 2
1 3
1 4
2 3
2 4
3 4
Output
NO
Input
5 4
1 2
2 3
3 4
4 5
Output
YES
Input
300000 5
1 2
1 2
1 2
1 2
1 2
Output
YES
Note
In the first example, you can't choose any x, y because for each such pair you can find a given pair where both numbers are different from chosen integers.
In the second example, you can choose x=2 and y=4.
In the third example, you can choose x=1 and y=2. | instruction | 0 | 63,191 | 22 | 126,382 |
Tags: graphs, implementation
Correct Solution:
```
n,m=map(int,input().split())
arr=[list(map(int,input().split())) for i in range(m)]
a=arr[0][0]
b=arr[0][1]
arr1=[]
arr2=[]
for i in range(m):
if a not in arr[i]:
arr1.append(arr[i])
if b not in arr[i]:
arr2.append(arr[i])
try:
s1=set(arr1[0])
for i in arr1:
s1=s1.intersection(set(i))
s2=set(arr2[0])
for i in arr2:
s2=s2.intersection(set(i))
s1=list(s1)
s2=list(s2)
#print(s1,s2)
#print(arr1,arr2)
if len(s1)>=1 or len(s2)>=1 or arr1==[] or arr2==[]:
print("YES")
else:
print("NO")
except:
print("YES")
``` | output | 1 | 63,191 | 22 | 126,383 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Toad Ivan has m pairs of integers, each integer is between 1 and n, inclusive. The pairs are (a_1, b_1), (a_2, b_2), …, (a_m, b_m).
He asks you to check if there exist two integers x and y (1 ≤ x < y ≤ n) such that in each given pair at least one integer is equal to x or y.
Input
The first line contains two space-separated integers n and m (2 ≤ n ≤ 300 000, 1 ≤ m ≤ 300 000) — the upper bound on the values of integers in the pairs, and the number of given pairs.
The next m lines contain two integers each, the i-th of them contains two space-separated integers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the integers in the i-th pair.
Output
Output "YES" if there exist two integers x and y (1 ≤ x < y ≤ n) such that in each given pair at least one integer is equal to x or y. Otherwise, print "NO". You can print each letter in any case (upper or lower).
Examples
Input
4 6
1 2
1 3
1 4
2 3
2 4
3 4
Output
NO
Input
5 4
1 2
2 3
3 4
4 5
Output
YES
Input
300000 5
1 2
1 2
1 2
1 2
1 2
Output
YES
Note
In the first example, you can't choose any x, y because for each such pair you can find a given pair where both numbers are different from chosen integers.
In the second example, you can choose x=2 and y=4.
In the third example, you can choose x=1 and y=2. | instruction | 0 | 63,192 | 22 | 126,384 |
Tags: graphs, implementation
Correct Solution:
```
inp = input().split()
n = int(inp[0]); m = int(inp[1])
pairs = []
flag = True
x = x1 = x2 = y = y1 = y2 = 0
for i in range(m):
inp = input().split()
pairs.append(inp)
for i in range(m):
if (i==0):
x = pairs[i][0]
continue
if((x not in pairs[i]) and (y not in pairs[i])):
if(y1 == 0):
y1 = pairs[i][0]
y2 = pairs[i][1]
continue
elif(y == 0):
if(y1 in pairs[i] and y2 in pairs[i]):
pass
elif(y1 in pairs[i]):
y = y1
# check for both in pairs
elif(y2 in pairs[i]):
y = y2
else:
flag = False
break
else:
if(y not in pairs[i]):
flag = False
break
flag2 = True
y1 = y2 = x = y = 0
if(flag == False):
for i in range(m):
if (i==0):
x = pairs[i][1]
continue
if((x not in pairs[i]) and (y not in pairs[i])):
if(y1 == 0):
y1 = pairs[i][0]
y2 = pairs[i][1]
continue
elif(y == 0):
if(y1 in pairs[i] and y2 in pairs[i]):
pass
elif(y1 in pairs[i]):
y = y1
# check for both in pairs
elif(y2 in pairs[i]):
y = y2
else:
flag2 = False
break
else:
if(y not in pairs[i]):
flag2 = False
break
if(flag or flag2):
print("YES")
else:
print("NO")
``` | output | 1 | 63,192 | 22 | 126,385 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Toad Ivan has m pairs of integers, each integer is between 1 and n, inclusive. The pairs are (a_1, b_1), (a_2, b_2), …, (a_m, b_m).
He asks you to check if there exist two integers x and y (1 ≤ x < y ≤ n) such that in each given pair at least one integer is equal to x or y.
Input
The first line contains two space-separated integers n and m (2 ≤ n ≤ 300 000, 1 ≤ m ≤ 300 000) — the upper bound on the values of integers in the pairs, and the number of given pairs.
The next m lines contain two integers each, the i-th of them contains two space-separated integers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the integers in the i-th pair.
Output
Output "YES" if there exist two integers x and y (1 ≤ x < y ≤ n) such that in each given pair at least one integer is equal to x or y. Otherwise, print "NO". You can print each letter in any case (upper or lower).
Examples
Input
4 6
1 2
1 3
1 4
2 3
2 4
3 4
Output
NO
Input
5 4
1 2
2 3
3 4
4 5
Output
YES
Input
300000 5
1 2
1 2
1 2
1 2
1 2
Output
YES
Note
In the first example, you can't choose any x, y because for each such pair you can find a given pair where both numbers are different from chosen integers.
In the second example, you can choose x=2 and y=4.
In the third example, you can choose x=1 and y=2. | instruction | 0 | 63,193 | 22 | 126,386 |
Tags: graphs, implementation
Correct Solution:
```
# for t in range(int(input())):
# s = input()
# i, j = 0, 0
# cnt = 0
# ans = float('inf')
# dic = {}
# while j < len(s):
# if len(dic) < 3:
# dic[s[j]] = dic.get(s[j], 0) + 1
# # print(j)
# # print(dic)
# while len(dic) == 3:
# ans = min(ans, j - i + 1)
# dic[s[i]] -= 1
# if dic[s[i]] == 0:
# del dic[s[i]]
# i += 1
#
# j += 1
# print((0, ans)[ans < float('inf')])
# for t in range(int(input())):
# n = int(input())
# s = list(map(int, input().split()))
# dp = [1] * n
# for i in range(n):
# k = 2
# while (i + 1) * k <= n:
# j = (i + 1) * k
# if s[i] < s[j - 1]:
# dp[j - 1] = max(dp[j - 1], dp[i] + 1)
# k += 1
# print(max(dp))
# for T in range(int(input())):
# t = input()
# z, o = 0, 0
# for ch in t:
# z = z + 1 if ch == '0' else z
# o = o + 1 if ch == '1' else o
# if z > 0 and o > 0:
# print('01' * len(t))
# elif o > 0 and not z:
# print('1' * len(t))
# else:
# print('0' * len(t))
# for t in range(int(input())):
# n = int(input())
# a = list(map(int, input().split()))
# a.sort()
# ans = []
# while a:
# ans.append(str(a.pop(len(a) // 2)))
# print(' '.join(ans))
# for t in range(int(input())):
# n = int(input())
# a = list(map(int, input().split()))
# cnt = 0
# p = set()
# l, r = 0, sum(a)
# left, right = {}, {}
# for i in a:
# right[i] = right.get(i, 0) + 1
# for i in range(n - 1):
# l += a[i]
# left[a[i]] = left.get(a[i], 0) + 1
# r -= a[i]
# right[a[i]] = right.get(a[i], 0) - 1
# if not right[a[i]]:
# del right[a[i]]
# j = n - i - 1
# if (2 + i) * (i + 1) // 2 == l and (j + 1) * j // 2 == r:
# if len(left) == i + 1 and len(right) == j:
# cnt += 1
# p.add((i + 1, n - i - 1))
# print(cnt)
# if cnt:
# for el in p:
# print(*el)
# for t in range(int(input())):
# n = int(input())
# G = []
# taken = [False] * n
# girl = -1
# for i in range(n):
# g = list(map(int, input().split()))
# k = g[0]
# single = True
# for j in range(1, k + 1):
# if not taken[g[j] - 1]:
# taken[g[j] - 1] = True
# single = False
# break
# if single:
# girl = i
# if girl == -1:
# print('OPTIMAL')
# else:
# print('IMPROVE')
# print(girl + 1, taken.index(False) + 1)
# for t in range(int(input())):
# n = int(input())
# a = list(map(int, input().split()))
# odd, even = [], []
# for i in range(2 * n):
# if a[i] % 2:
# odd.append(i + 1)
# else:
# even.append(i + 1)
# for i in range(n - 1):
# if len(odd) >= len(even):
# print(odd.pop(), odd.pop())
# else:
# print(even.pop(), even.pop())
# for t in range(int(input())):
# n = int(input())
# a = list(map(int, input().split()))
# a.sort()
# ans, i, j = 0, 0, 1
# while j < n:
# if a[i] < a[j]:
# ans += 1
# i += 1
# j += 1
# else:
# while j < n and a[i] == a[j]:
# i += 1
# j += 1
# print(ans + 1)
# for t in range(int(input())):
# n = int(input())
# a = list(map(int, input().split()))
# got = False
#
# b = 1
# while not got and b < 2 * n - 1:
# if b % 2:
# i, j = (b - 1) // 2, (b + 1) // 2
# else:
# i, j = b // 2 - 1, b // 2 + 1
# left, right = set(a[:i]), set(a[j:])
# if left & right:
# got = True
# b += 1
# print('YES' if got else 'NO')
# n, m, k = list(map(int, input().split()))
# A = list(map(int, input().split()))
# B = list(map(int, input().split()))
# ans = 0
# a, b = [0], [0]
# for el in A:
# a.append(a[-1] + el)
# for el in B:
# b.append(b[-1] + el)
# d = [(i, k//i) for i in range(1, int(k**0.5)+1) if k % i == 0]
# d += [(j, i) for i, j in d if i != j]
# for i in range(n):
# for j in range(m):
# for q, p in d:
# if i + q <= n and j + p <= m:
# if a[i + q] - a[i] == q and b[j + p] - b[j] == p:
# ans += 1
# print(ans)
# for t in range(int(input())):
# n = int(input())
# s = input()
# dic, se = {s: 1}, {s}
# for k in range(2, n):
# p = s[k - 1:] + (s[:k - 1], s[:k - 1][::-1])[(n % 2) == (k % 2)]
# # print(k, p)
# if p not in dic:
# # print(dic, p)
# dic[p] = k
# se.add(p)
# if s[::-1] not in dic:
# dic[s[::-1]] = n
# se.add(s[::-1])
# # print(dic)
# ans = min(se)
# print(ans)
# print(dic[ans])
# for t in range(int(input())):
# a, b, p = list(map(int, input().split()))
# s = input()
# road = [a if s[0] == 'A' else b]
# st = [0]
# for i in range(1, len(s) - 1):
# if s[i] != s[i - 1]:
# road.append(road[-1] + (a, b)[s[i] == 'B'])
# st.append(i)
# # print(road)
# pay = road[-1]
# j = 0
# while pay > p and j < len(st):
# pay = road[-1] - road[j]
# j += 1
# # print(j)
# print(st[j] + 1 if j < len(st) else len(s))
# for t in range(int(input())):
# n, x, y = list(map(int, input().split()))
# print(max(1, min(x + y - n + 1, n)), min(n, x + y - 1))
# for t in range(int(input())):
# n = int(input())
# a = list(map(int, input().split()))
# print(' '.join(map(str, sorted(a, reverse=True))))
# s = input()
# open, close = [], []
# i = 0
# for i in range(len(s)):
# if s[i] == '(':
# open.append(i)
# else:
# close.append(i)
# i, j = 0, len(close) - 1
# ans = []
# while i < len(open) and j >= 0 and open[i] < close[j]:
# ans += [open[i] + 1, close[j] + 1]
# i += 1
# j -= 1
# ans.sort()
# print('0' if not ans else '1\n{}\n{}'.format(len(ans), ' '.join([str(idx) for idx in ans])))
import collections
# n, m = list(map(int, input().split()))
# a = list(input() for i in range(n))
# dic = {}
# for w in a:
# dic[w] = dic.get(w, 0) + 1
# l, r = '', ''
# for i in range(n):
# for j in range(i + 1, n):
# # print(i, j, a)
# if a[i] == a[j][::-1] and dic[a[i]] and dic[a[j]]:
# l += a[i]
# r = a[j] + r
# dic[a[i]] -= 1
# dic[a[j]] -= 1
# c = ''
# for k, v in dic.items():
# if v and k == k[::-1]:
# if c and c[-m] == k or not c:
# c += k
# print(f'{len(l) + len(c) + len(r)}\n{l + c + r}')
# for t in range(int(input())):
# n, g, b = list(map(int, input().split()))
# d = n // 2 + n % 2
# full, inc = divmod(d, g)
# ans = (g + b) * (full - 1, full)[inc > 0] + (g, inc)[inc > 0]
# print(ans if ans >= n else n)
# for t in range(int(input())):
# n = int(input())
# a = list(map(int, input().split()))
# a.sort()
# print(a[n] - a[n - 1])
# for t in range(int(input())):
# n, x = list(map(int, input().split()))
# s = input()
# cntz = s.count('0')
# total = 2 * cntz - n
# bal = 0
# ans = 0
# for i in range(n):
# if not total:
# if bal == x:
# ans = -1
# elif not abs(x - bal) % abs(total):
# if (x - bal) // total >= 0:
# ans += 1
# bal += 1 if s[i] == '0' else -1
# print(ans)
# n = int(input())
# ans = 0
# for i in range(1, n + 1):
# ans += 1 / i
# print(ans)
# for t in range(int(input())):
# n = int(input())
# a = list(map(int, input().split()))
# p, s = 0, n - 1
# for i in range(n):
# if a[i] < i:
# break
# p = i
# for i in range(n - 1, -1, -1):
# if a[i] < n - i - 1:
# break
# s = i
# print('Yes' if s <= p else 'No')
# n, k = list(map(int, input().split()))
# a = [input() for i in range(n)]
# c = set(a)
# b = set()
# for i in range(n):
# for j in range(i + 1, n):
# third = ''
# for c1, c2 in zip(a[i], a[j]):
# if c1 == c2:
# third += c1
# else:
# if c1 != 'S' and c2 != 'S':
# third += 'S'
# elif c1 != 'E' and c2 != 'E':
# third += 'E'
# else:
# third += 'T'
# if third in c:
# b.add(frozenset([a[i], a[j], third]))
# print(len(b))
# for t in range(int(input())):
# n = int(input())
# a = list(map(int, input().split()))
# total, curr = sum(a), 0
# ans, i, start = 'YES', 0, 0
# while ans == 'YES' and i < n:
# if curr > 0:
# curr += a[i]
# else:
# curr = a[i]
# start = i
# # print(curr, i, start, total)
# if i - start + 1 < n and curr >= total:
# ans = 'NO'
# i += 1
# print(ans)
# for t in range(int(input())):
# n, p, k = list(map(int, input().split()))
# a = list(map(int, input().split()))
# a.sort(reverse=True)
# odd, even = 0, 0
# i, j = len(a) - 1, len(a) - 2
# curr = 0
# while curr < p and i >= 0:
# curr += a[i]
# if curr <= p:
# odd += 1
# i -= 2
# curr = 0
# while curr < p and j >= 0:
# curr += a[j]
# if curr <= p:
# even += 1
# j -= 2
# print(max(odd * 2 - 1, even * 2))
# for t in range(int(input())):
# s, c = input().split()
# s = list(ch for ch in s)
# sor = sorted(s)
# for i in range(len(s)):
# if s[i] != sor[i]:
# j = max(j for j, v in enumerate(s[i:], i) if v == sor[i])
# s = s[:i] + [s[j]] + s[i + 1:j] + [s[i]] + s[j + 1:]
# break
# s = ''.join(s)
# print(s if s < c else '---')
# for t in range(int(input())):
# n, s = list(map(int, input().split()))
# a = list(map(int, input().split()))
# if sum(a) <= s:
# print(0)
# else:
# curr, i, j = 0, 0, 0
# for i in range(n):
# if a[i] > a[j]:
# j = i
# s -= a[i]
# if s < 0:
# break
# print(j + 1)
# for t in range(int(input())):
# a, b = list(map(int, input().split()))
# a, b = (b, a) if b > a else (a, b)
# if not ((1 + 8 * (a - b))**0.5 - 1) % 2 and ((1 + 8 * (a - b))**0.5 - 1) // 2 >= 0:
# ans = ((1 + 8 * (a - b))**0.5 - 1) // 2
# print(int(ans))
# else:
# n1 = int(((1 + 8 * (a - b))**0.5 - 1) // 2) + 1
# while (n1 * (n1 + 1) // 2) % 2 != (a - b) % 2:
# n1 += 1
# print(n1)
# for t in range(int(input())):
# n = int(input())
# a = list(map(int, input().split()))
# a.sort()
# ans = 0
# l = 0
# dic = {}
# for i in range(n - 1, -1, -1):
# if not a[i] % 2:
# l, r = 0, 30
# while l < r:
# m = (l + r) // 2
# # print(l, r, m, a[i] % 2**m)
# if a[i] % 2**m:
# r = m
# else:
# l = m + 1
# dic[a[i] // 2**(l - 1)] = max(dic.get(a[i] // 2**(l - 1), 0), l - 1)
# print(sum(list(dic.values())))
# n = int(input())
# s = input()
# b = s.count('B')
# w = n - b
# if b % 2 and w % 2:
# print(-1)
# elif not b or not w:
# print(0)
# else:
# ans = []
# if not b % 2:
# for i in range(n - 1):
# if s[i] != 'W':
# ans += [str(i + 1)]
# s = s[:i] + 'W' + 'BW'[s[i + 1] == 'B'] + s[i + 2:]
# elif not w % 2:
# for i in range(n - 1):
# if s[i] != 'B':
# ans += [str(i + 1)]
# s = s[:i] + 'B' + 'WB'[s[i + 1] == 'W'] + s[i + 2:]
# print(len(ans))
# print(' '.join(ans))
# n, m = list(map(int, input().split()))
# a = list(map(int, input().split()))
# b = list(map(int, input().split()))
# b.sort()
# ans = float('inf')
# for i in range(n):
# x = (b[0] - a[i]) % m
# ax = []
# for j in range(n):
# ax.append((a[j] + x) % m)
# if b == sorted(ax):
# ans = min(ans, x)
# print(ans)
# for t in range(int(input())):
# n = int(input())
# ans = [1] + [0] * (n - 1)
# p = list(map(int, input().split()))
# i, j, curr, m = p.index(1), 1, 1, 1
# l, r = i, i
# while l >= 0 and r < n:
# if l and curr + p[l - 1] == (m + 2) * (m + 1) // 2:
# ans[m] = 1
# curr += p[l - 1]
# l -= 1
#
# elif r + 1 < n and curr + p[r + 1] == (m + 2) * (m + 1) // 2:
# ans[m] = 1
# curr += p[r + 1]
# r += 1
# else:
# if l and r + 1 < n:
# curr, l, r = ((curr + p[l - 1], l - 1, r),
# (curr + p[r + 1], l, r + 1))[p[r + 1] < p[l - 1]]
# elif not l and r + 1 < n:
# curr, l, r = curr + p[r + 1], l, r + 1
# elif r + 1 == n and l:
# curr, l, r = curr + p[l - 1], l - 1, r
# else:
# break
# m += 1
# print(''.join([str(i) for i in ans]))
# for t in range(int(input())):
# n = int(input())
# p = [input() for i in range(n)]
# ans = 0
# for i in range(n):
# if p[i] in p[i + 1:]:
# for j in range(10):
# code = p[i][:3] + str(j)
# if code not in p:
# p[i] = code
# ans += 1
# break
# print(ans)
# for code in p:
# print(code)
# for t in range(int(input())):
# a, b = list(map(int, input().split()))
# if (a + b) % 3 == 0 and 2 * min(a, b) >= max(a, b):
# print('YES')
# else:
# print('NO')
# for t in range(int(input())):
# x, y = list(map(int, input().split()))
# if (x == 1 and y > 1) or (x == 2 and y > 3) or (x == 3 and y > 3):
# print('NO')
# else:
# print('YES')
# for t in range(int(input())):
# n, m = list(map(int, input().split()))
# a = list(map(int, input().split()))
# if m < n or n == 2:
# print(-1)
# elif m == n:
# print(2 * sum(a))
# for i in range(n - 1):
# print(i + 1, i + 2)
# print(n, 1)
# else:
# b = [(a[i], i + 1) for i in range(n)]
# b.sort()
# d = m - n
# ans = sum(a) + d * (b[0][0] + b[1][0])
# for i in range(d):
# print(b[0][1], b[1][1])
# for i in range(n - 1):
# print(i + 1, i + 2)
# print(n, 1)
# n = int(input())
# a = list(map(int, input().split()))
# if n % 2:
# print(-1)
# else:
# d = 0
# c = []
# curr = 0
# came = set()
# day = set()
# inc = False
# for i in range(n):
# if a[i] > 0:
# if a[i] in day:
# inc = True
# break
# else:
# day.add(a[i])
# came.add(a[i])
# else:
# if abs(a[i]) not in came:
# inc = True
# break
# else:
# came.remove(abs(a[i]))
# if len(came) == 0:
# d += 1
# c.append(i + 1)
# day = set()
# if len(came) > 0:
# inc = True
# if inc:
# print(-1)
# else:
# print(d)
# print(c[0])
# for i in range(1, len(c)):
# print(c[i] - c[i - 1])
# n = int(input())
# a = list(map(int, input().split()))
# a.sort()
# x, y = sum(a[:n // 2])**2, sum(a[n // 2:])**2
# print(x + y)
# for t in range(int(input())):
# n = int(input())
# r, p, s = list(map(int, input().split()))
# b = input()
# S, P, R = b.count('S'), b.count('P'), b.count('R')
# cnt = 0
# ans = ''
# # print(r, 'rock', p, 'paper', s, 'sc')
# for i in range(n):
# if b[i] == 'S':
# if r > 0:
# ans, r, cnt = ans + 'R', r - 1, cnt + 1
# else:
# if p > R:
# ans, p = ans + 'P', p - 1
# if len(ans) < i + 1 and s > P:
# ans, s = ans + 'S', s - 1
# S -= 1
# elif b[i] == 'P':
# if s > 0:
# ans, s, cnt = ans + 'S', s - 1, cnt + 1
# else:
# if p > R:
# ans, p = ans + 'P', p - 1
# if len(ans) < i + 1 and r > S:
# ans, r = ans + 'R', r - 1
# P -= 1
# else:
# if p > 0:
# ans, p, cnt = ans + 'P', p - 1, cnt + 1
# else:
# if s > P:
# ans, s = ans + 'S', s - 1
# if len(ans) < i + 1 and r > S:
# ans, r = ans + 'R', r - 1
# R -= 1
# if cnt < (n // 2 + n % 2):
# print('NO')
# else:
# print('YES')
# # print(r, p, s)
# print(ans)
# for t in range(int(input())):
# n = int(input())
# s = input()
# f, l = s.find('1'), s.rfind('1')
# f, l = max(f + 1, n - f) if f != -1 else 0, max(l + 1, n - l) if l != -1 else 0
# if not f and not l:
# print(n)
# else:
# print(f * 2) if f > l else print(l * 2)
# t = int(input())
# ans = list()
# for _ in [0] * t:
# n, r = map(int, input().split())
# x = sorted(set(map(int, input().split())))[::-1]
# ans.append(sum([x - i * r > 0 for i, x in enumerate(x)]))
# print(' '.join(map(str, ans)))
# n = int(input())
# dots = []
# for i in range(n):
# dots.append(sum(list(map(int, input().split()))))
# print(max(dots))
# n, m = map(int, input().split())
# print(pow(2**m - 1, n, 10**9 + 7))
# n, k = map(int, input().split())
# s = input()
# if not k:
# print(s)
# elif n == 1:
# print('0')
# else:
# s = [int(i) for i in s]
# if s[0] > 1:
# s[0], k = 1, k - 1
# for i in range(1, n):
# if not k:
# break
# if s[i] > 0:
# s[i], k = 0, k - 1
# print(''.join(map(str, s))) if len(s) > 1 else print('0')
# m, n = map(int, input().split())
# r = list(map(int, input().split()))
# c = list(map(int, input().split()))
# grid = [['ok'] * (n + 1) for i in range(m + 1)]
#
# for i in range(m):
# row = r[i]
# if row:
# for j in range(row):
# grid[i][j] = 1
# grid[i][row] = 0
# else:
# grid[i][row] = 0
#
#
# inv = False
# for j in range(n):
# col = c[j]
# if col:
# for i in range(col):
# if grid[i][j] == 0:
# inv = True
# break
# else:
# grid[i][j] = 1
# if grid[col][j] == 1:
# inv = True
# break
# else:
# grid[col][j] = 0
# else:
# if grid[col][j] == 1:
# inv = True
# break
# else:
# grid[col][j] = 0
#
# if inv:
# print(0)
# else:
# cnt = 0
# for row in grid[:m]:
# cnt += row[:n].count('ok')
# print(pow(2, cnt, 10**9 + 7))
# n = int(input())
# for i in range(n):
# print('BW' * (n // 2) + 'B' * (n % 2) if i % 2 else 'WB' * (n // 2) + 'W' * (n % 2))
# n = int(input())
# a = list(map(int, input().split()))
# curr, odd, even = 0, 0, 0
# p = 0
# for d in a:
# odd, even = ((odd, even + 1), (odd + 1, even))[curr % 2]
# curr += 1 if d < 0 else 0
# p += odd if curr % 2 else even
# print(n * (n + 1) // 2 - p, p)
# n = int(input())
# a = list(map(int, input().split()))
# p, m, z = 0, [], 0
# for d in a:
# if d > 0:
# p += d
# elif d < 0:
# m.append(d)
# else:
# z += 1
# ans = p - (n - z - len(m))
#
# if len(m) % 2:
# if z:
# m.append(-1)
# ans += 1
# z -= 1
# else:
# m.sort(reverse=True)
# x = m.pop()
# ans += 1 - x
#
# mm = len(m)
# ans += abs(sum(m)) - mm
# ans += z
# print(ans)
# n, l, r = map(int, input().split())
# a = [2**i for i in range(r)]
# print(sum(a[:l]) + n - l, sum(a) + (n - r) * a[-1])
# n = int(input())
# a = list(map(int, input().split()))
# a.sort()
# print('YES' if not sum(a) % 2 and a[-1] <= sum(a) - a[-1] else 'NO')
# for t in range(int(input())):
# n, m, k = map(int, input().split())
# h = list(map(int, input().split()))
# ans = 'YES'
# for i in range(n - 1):
# if abs(h[i] - h[i + 1]) > k:
# d = h[i] - h[i + 1]
# if d < 0 and m >= abs(d) - k:
# m -= -k - d
# elif d > 0:
# m += min(d + k, h[i])
# else:
# ans = 'NO'
# break
# else:
# d = h[i] - h[i + 1]
# if d >= 0:
# m += min(d + k, h[i])
# else:
# m += min(k + d, h[i])
# print(ans)
# h, l = map(int, input().split())
# print((h**2 + l**2) / (2 * h) - h)
# n = int(input())
# a = list(map(int, input().split()))
# a = {i: j for i, j in enumerate(a)}
# m, idx = 0, 0
# ans = 'YES'
# for i in range(n):
# if a[i] > m:
# m = a[i]
# idx = i
# for i in range(1, idx):
# if a[i] < a[i - 1]:
# ans = 'NO'
# break
# for i in range(idx + 1, n):
# if a[i] > a[i - 1]:
# ans = 'NO'
# break
# print(ans)
# n, k = map(int, input().split())
# l, r = 0, n
# while l <= r:
# m = (l + r) // 2
# t = n - m
# if m * (m + 1) // 2 - t == k:
# ans = t
# break
# elif m * (m + 1) // 2 - t < k:
# l = m + 1
# else:
# r = m - 1
# print(ans)
# for t in range(int(input())):
# n, m = map(int, input().split())
# grid = [input() for i in range(n)]
# rows = []
# cols = [0] * m
# for row in grid:
# rows.append(0)
# for i in range(m):
# if row[i] == '.':
# rows[-1] += 1
# cols[i] += 1
# ans = m + n - 1
# for i in range(n):
# for j in range(m):
# ans = min(ans, rows[i] + cols[j] - (grid[i][j] == '.'))
# print(ans)
# tiles = input().split()
# unique = {}
# m, p, s = set(), set(), set()
# m_unique = 0
# for t in tiles:
# unique[t] = unique.get(t, 0) + 1
# m_unique = max(m_unique, unique[t])
# if t[1] == 'm':
# m.add(int(t[0]))
# elif t[1] == 'p':
# p.add(int(t[0]))
# else:
# s.add(int(t[0]))
# ans = 3 - m_unique
# for t in (m, p, s):
# if not t:
# continue
# else:
# m_sub = 0
# l = list(sorted(t))
# dif = []
# for i in range(1, len(t)):
# dif.append(l[i] - l[i - 1])
# if dif[-1] == 1 or dif[-1] == 2:
# m_sub = max(m_sub, 2)
# if i > 1 and dif[-1] == dif[-2] == 1:
# m_sub = 3
# # print(l, dif, m_sub)
# ans = min(ans, 3 - m_sub)
# print(ans)
# n = int(input())
# a = list(map(int, input().split()))
# a.sort()
# print('NO' if a[-3] + a[-2] <= a[-1] else 'YES')
# if a[-3] + a[-2] > a[-1]:
# print(' '.join(str(i) for i in a[:-3] + [a[-3]] + [a[-1]] + [a[-2]]))
# n = int(input())
# s = input()
# m = int(input())
# dic = {}
# for i in range(n):
# dic.setdefault(s[i], []).append(i)
# for t in range(m):
# name = [ch for ch in input()]
# c = {}
# ans = 0
# # print(t)
# for i in range(len(name)):
# idx = c.get(name[i], -1)
# # print(name[i], dic[name[i]], c)
# c[name[i]] = idx + 1
# ans = max(ans, dic[name[i]][idx + 1])
# print(ans + 1)
# for t in range(int(input())):
# a = input()
# b = input()
# if len(b) < len(a):
# print('NO')
# else:
# ans = 'YES'
# i, j = 0, 0
# while i < len(a):
# cnt1 = 1
# while i + 1 < len(a) and a[i] == a[i + 1]:
# cnt1 += 1
# i += 1
# cnt2 = 0
# while j < len(b) and b[j] == a[i]:
# cnt2 += 1
# j += 1
# if cnt1 > cnt2:
# ans = 'NO'
# break
# i += 1
# print(ans if i == len(a) and j == len(b) else 'NO')
# m, n = map(int, input().split())
# g = [input() for i in range(m)]
# ans = 'YES'
# if m < 3 and n < 3:
# ans = 'NO'
# if ans == 'YES':
# c = (-1, -1)
# for i in range(1, m - 1):
# for j in range(1, n - 1):
# if g[i][j] == '*':
# if all(g[I][J] == '*' for I, J in ((i + 1, j), (i - 1, j), (i, j + 1), (i, j - 1))):
# c = (i, j)
# break
# if c == (-1, -1):
# ans = 'NO'
#
# if ans == 'YES':
# plus = {c}
# I, J = c
# i, j = I - 1, I + 1
# while i >= 0 and g[i][J] == '*':
# plus.add((i, J))
# i -= 1
# while j < m and g[j][J] == '*':
# plus.add((j, J))
# j += 1
# i, j = J - 1, J + 1
# while i >= 0 and g[I][i] == '*':
# plus.add((I, i))
# i -= 1
# while j < n and g[I][j] == '*':
# plus.add((I, j))
# j += 1
#
# for i in range(m):
# for j in range(n):
# if g[i][j] == '*' and (i, j) not in plus:
# ans = 'NO'
# break
#
# print(ans)
# for t in range(int(input())):
# n = int(input())
# if not n % 2:
# print(f'{n // 2} {n // 2}')
# else:
# idx = 1
# for i in range(3, int(n**0.5) + 1):
# if not n % i:
# idx = i
# break
# print(f'{n // idx} {n - n // idx}' if idx > 1 else f'{1} {n - 1}')
# l = int(input())
# n = input()
# i = l // 2
# if not l % 2 and n[i] != '0':
# print(int(n[:i]) + int(n[i:]))
# else:
# j = i + 1
# while n[i] == '0':
# i -= 1
# while j < l and n[j] == '0':
# j += 1
# if i > 0 and j < l - 1:
# print(min(int(n[:i]) + int(n[i:]), int(n[:j]) + int(n[j:])))
# else:
# if not i:
# print(int(n[:j]) + int(n[j:]))
# else:
# print(int(n[:i]) + int(n[i:]))
# n = int(input())
# a = list(map(int, input().split()))
# b = a.copy()
# for i in range(n):
# if a[i] >= 0:
# a[i] = (a[i] + 1) * -1
# if not n % 2:
# print(' '.join((str(i) for i in a)))
# else:
# m = (float('inf'), -1)
# for i in range(n):
# m = (m, (a[i], i))[m[0] > a[i] and a[i] < -1]
# if m[1] == -1:
# b[0] = 0
# print(' '.join((str(i) for i in b)))
# else:
# a[m[1]] = (a[m[1]] + 1) * -1
# print(' '.join((str(i) for i in a)))
# l = int(input())
# ans = 0
# c = [input() for i in range(l)]
# stack = [1]
# for i in range(l):
# if c[i] == 'add':
# ans += stack[-1]
# elif c[i] == 'end':
# stack.pop()
# else:
# stack.append(min(stack[-1] * int(c[i].split()[1]), 2**32))
# if ans >= 2**32:
# ans = 'OVERFLOW!!!'
# break
# print(ans)
# n = int(input())
# a = list(map(int, input().split()))
# odd = 0
# for d in a:
# if d % 2:
# odd += 1
# if 0 < odd < n:
# print(' '.join((str(i) for i in sorted(a))))
# else:
# print(' '.join((str(i) for i in a)))
# n = int(input())
# print(n // 2 + 1)
# i, j = 1, 1
# for k in range(n):
# print(i, j)
# if i == j:
# j += 1
# else:
# i += 1
n, m = map(int, input().split())
a = [list(map(int, input().split())) for i in range(m)]
x, y = a.pop()
ans = 'NO'
for v in (x, y):
val = [0] * (n + 1)
cnt = 0
for v1, v2 in a:
if v1 != v and v2 != v:
val[v1], val[v2], cnt = val[v1] + 1, val[v2] + 1, cnt + 1
if max(val) == cnt:
ans = 'YES'
break
print(ans)
``` | output | 1 | 63,193 | 22 | 126,387 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Toad Ivan has m pairs of integers, each integer is between 1 and n, inclusive. The pairs are (a_1, b_1), (a_2, b_2), …, (a_m, b_m).
He asks you to check if there exist two integers x and y (1 ≤ x < y ≤ n) such that in each given pair at least one integer is equal to x or y.
Input
The first line contains two space-separated integers n and m (2 ≤ n ≤ 300 000, 1 ≤ m ≤ 300 000) — the upper bound on the values of integers in the pairs, and the number of given pairs.
The next m lines contain two integers each, the i-th of them contains two space-separated integers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the integers in the i-th pair.
Output
Output "YES" if there exist two integers x and y (1 ≤ x < y ≤ n) such that in each given pair at least one integer is equal to x or y. Otherwise, print "NO". You can print each letter in any case (upper or lower).
Examples
Input
4 6
1 2
1 3
1 4
2 3
2 4
3 4
Output
NO
Input
5 4
1 2
2 3
3 4
4 5
Output
YES
Input
300000 5
1 2
1 2
1 2
1 2
1 2
Output
YES
Note
In the first example, you can't choose any x, y because for each such pair you can find a given pair where both numbers are different from chosen integers.
In the second example, you can choose x=2 and y=4.
In the third example, you can choose x=1 and y=2. | instruction | 0 | 63,194 | 22 | 126,388 |
Tags: graphs, implementation
Correct Solution:
```
n, m = map(int, input().split())
pairs = []
d = set()
for i in range(m):
a, b = map(int, input().split())
pairs.append([a, b])
if a not in d and b not in d:
if len(d) >= 4:
print('NO')
exit()
else:
d.add(a)
d.add(b)
d = list(d)
for i in range(len(d)):
for j in range(i+1, len(d)):
s = set()
s.add(d[i])
s.add(d[j])
f = True
for p in pairs:
if p[0] not in s and p[1] not in s:
f = False
break
if f:
print('YES')
exit()
print('NO')
``` | output | 1 | 63,194 | 22 | 126,389 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Toad Ivan has m pairs of integers, each integer is between 1 and n, inclusive. The pairs are (a_1, b_1), (a_2, b_2), …, (a_m, b_m).
He asks you to check if there exist two integers x and y (1 ≤ x < y ≤ n) such that in each given pair at least one integer is equal to x or y.
Input
The first line contains two space-separated integers n and m (2 ≤ n ≤ 300 000, 1 ≤ m ≤ 300 000) — the upper bound on the values of integers in the pairs, and the number of given pairs.
The next m lines contain two integers each, the i-th of them contains two space-separated integers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the integers in the i-th pair.
Output
Output "YES" if there exist two integers x and y (1 ≤ x < y ≤ n) such that in each given pair at least one integer is equal to x or y. Otherwise, print "NO". You can print each letter in any case (upper or lower).
Examples
Input
4 6
1 2
1 3
1 4
2 3
2 4
3 4
Output
NO
Input
5 4
1 2
2 3
3 4
4 5
Output
YES
Input
300000 5
1 2
1 2
1 2
1 2
1 2
Output
YES
Note
In the first example, you can't choose any x, y because for each such pair you can find a given pair where both numbers are different from chosen integers.
In the second example, you can choose x=2 and y=4.
In the third example, you can choose x=1 and y=2. | instruction | 0 | 63,195 | 22 | 126,390 |
Tags: graphs, implementation
Correct Solution:
```
from sys import stdin,stdout
from itertools import combinations
from collections import defaultdict,OrderedDict
import math
import heapq
def listIn():
return list((map(int,stdin.readline().strip().split())))
def stringListIn():
return([x for x in stdin.readline().split()])
def intIn():
return (int(stdin.readline()))
def stringIn():
return (stdin.readline().strip())
if __name__=="__main__":
n,m=listIn()
di=defaultdict(int)
li=[]
Arr=defaultdict(list)
for i in range(m):
a,b=listIn()
li.append((a,b))
Arr[a].append(i+1)
Arr[b].append(i+1)
di[a]+=1
di[b]+=1
a,b=li[0][0],li[0][1]
li2=[]
li2.append(a)
li2.append(b)
f=1
for i in range(1,m):
if a not in li[i] and b not in li[i]:
f=0
li2.append(li[i][0])
li2.append(li[i][1])
break
#print(li2)
if f:
print('YES')
else:
f=0
for i in [0,1]:
s=set(Arr[li2[i]])
for j in [2,3]:
s1=s|set(Arr[li2[j]])
if len(s1)==m:
#print(li2[i],li2[j])
f=1
break
if f:
break
if f:
print("YES")
else:
print('NO')
``` | output | 1 | 63,195 | 22 | 126,391 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Toad Ivan has m pairs of integers, each integer is between 1 and n, inclusive. The pairs are (a_1, b_1), (a_2, b_2), …, (a_m, b_m).
He asks you to check if there exist two integers x and y (1 ≤ x < y ≤ n) such that in each given pair at least one integer is equal to x or y.
Input
The first line contains two space-separated integers n and m (2 ≤ n ≤ 300 000, 1 ≤ m ≤ 300 000) — the upper bound on the values of integers in the pairs, and the number of given pairs.
The next m lines contain two integers each, the i-th of them contains two space-separated integers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the integers in the i-th pair.
Output
Output "YES" if there exist two integers x and y (1 ≤ x < y ≤ n) such that in each given pair at least one integer is equal to x or y. Otherwise, print "NO". You can print each letter in any case (upper or lower).
Examples
Input
4 6
1 2
1 3
1 4
2 3
2 4
3 4
Output
NO
Input
5 4
1 2
2 3
3 4
4 5
Output
YES
Input
300000 5
1 2
1 2
1 2
1 2
1 2
Output
YES
Note
In the first example, you can't choose any x, y because for each such pair you can find a given pair where both numbers are different from chosen integers.
In the second example, you can choose x=2 and y=4.
In the third example, you can choose x=1 and y=2. | instruction | 0 | 63,196 | 22 | 126,392 |
Tags: graphs, implementation
Correct Solution:
```
# take input
n, m = input().split(sep = ' ')
n= int(n)
m= int(m)
a = []
b = []
for i in range(m):
ai, bi = input().split(sep = ' ')
a.append(int(ai))
b.append(int(bi))
################### End input #########################
for x in [a[0], b[0]]:
not_ok = False
sel_couple = {x}
# Find first (ai, bi) where ai != a0 and bi != a0
j = 0
for i in range(1,m):
if (not (a[i] in sel_couple)) and (not (b[i] in sel_couple)):
j = i
not_ok = True
break
if j == 0:
break
# Test {a[0], a[j]} then {a[0], b[j]}
for y in [a[j], b[j]]:
not_ok = False
sel_couple = {x, y}
for i in range(1,m):
if (not a[i] in sel_couple) and (not b[i] in sel_couple):
sel_couple = set()
not_ok = True
break
if not_ok == False:
break
if not_ok == False:
break
if len(sel_couple) == 0:
print('NO')
else:
print('YES')
``` | output | 1 | 63,196 | 22 | 126,393 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Toad Ivan has m pairs of integers, each integer is between 1 and n, inclusive. The pairs are (a_1, b_1), (a_2, b_2), …, (a_m, b_m).
He asks you to check if there exist two integers x and y (1 ≤ x < y ≤ n) such that in each given pair at least one integer is equal to x or y.
Input
The first line contains two space-separated integers n and m (2 ≤ n ≤ 300 000, 1 ≤ m ≤ 300 000) — the upper bound on the values of integers in the pairs, and the number of given pairs.
The next m lines contain two integers each, the i-th of them contains two space-separated integers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the integers in the i-th pair.
Output
Output "YES" if there exist two integers x and y (1 ≤ x < y ≤ n) such that in each given pair at least one integer is equal to x or y. Otherwise, print "NO". You can print each letter in any case (upper or lower).
Examples
Input
4 6
1 2
1 3
1 4
2 3
2 4
3 4
Output
NO
Input
5 4
1 2
2 3
3 4
4 5
Output
YES
Input
300000 5
1 2
1 2
1 2
1 2
1 2
Output
YES
Note
In the first example, you can't choose any x, y because for each such pair you can find a given pair where both numbers are different from chosen integers.
In the second example, you can choose x=2 and y=4.
In the third example, you can choose x=1 and y=2. | instruction | 0 | 63,197 | 22 | 126,394 |
Tags: graphs, implementation
Correct Solution:
```
import sys
from collections import defaultdict
strInp = lambda : input().strip().split()
intInp = lambda : list(map(int,strInp()))
def checkAns (x1, pairs):
ans = False
allPssed = True
for i in range(len(pairs)):
if x1 not in pairs[i]:
allPssed = False
break
if allPssed :
ans = True
return ans
n, m = intInp()
ans = False
pairs = []
for i in range(m):
pairs.append(intInp())
x = pairs[0][0]
pairsWithoutX = []
for i in range(m):
if x not in pairs[i]:
pairsWithoutX.append(pairs[i])
if len(pairsWithoutX) > 0:
x1 = pairsWithoutX[0][0]
y1 = pairsWithoutX[0][1]
if len(pairsWithoutX) == 0 or checkAns(x1,pairsWithoutX) or checkAns(y1,pairsWithoutX):
print("Yes")
else:
y = pairs[0][1]
pairsWithoutY = []
for i in range(m):
if y not in pairs[i]:
pairsWithoutY.append(pairs[i])
if len(pairsWithoutY) > 0:
x1 = pairsWithoutY[0][0]
y1 = pairsWithoutY[0][1]
if len(pairsWithoutY) == 0 or checkAns(x1,pairsWithoutY) or checkAns(y1,pairsWithoutY):
print('Yes')
else:
print('No')
``` | output | 1 | 63,197 | 22 | 126,395 |
Provide a correct Python 3 solution for this coding contest problem.
Given are integers N and X. For each integer k between 0 and X (inclusive), find the answer to the following question, then compute the sum of all those answers, modulo 998244353.
* Let us repeat the following operation on the integer k. Operation: if the integer is currently odd, subtract 1 from it and divide it by 2; otherwise, divide it by 2 and add 2^{N-1} to it. How many operations need to be performed until k returns to its original value? (The answer is considered to be 0 if k never returns to its original value.)
Constraints
* 1 \leq N \leq 2\times 10^5
* 0 \leq X < 2^N
* X is given in binary and has exactly N digits. (In case X has less than N digits, it is given with leading zeroes.)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X
Output
Print the sum of the answers to the questions for the integers between 0 and X (inclusive), modulo 998244353.
Examples
Input
3
111
Output
40
Input
6
110101
Output
616
Input
30
001110011011011101010111011100
Output
549320998 | instruction | 0 | 64,621 | 22 | 129,242 |
"Correct Solution:
```
import sys
from collections import deque, defaultdict
import copy
import bisect
sys.setrecursionlimit(10 ** 9)
import math
import heapq
from itertools import product, permutations,combinations
import fractions
from operator import itemgetter
import sys
def input():
return sys.stdin.readline().strip()
N = int(input())
X = input()
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
mod = 998244353
pow2 = [1]
for i in range(N):
pow2.append((pow2[-1]*2) % mod)
yakusu_n = make_divisors(2*N)
yakusu_n.sort()
ans = 0
before = 0
#print(yakusu_n)
num_dict = defaultdict(int)
for n in yakusu_n:
if N % (2*n) != 0 and N % n == 0:
num = 0
for i in range(n):
if X[i] == "1":
num += pow2[n - 1 - i]
Y = list(X[:n])
for i in range(n):
if Y[i] == "0":
Y.append("1")
else:
Y.append("0")
Y = "".join(Y)
Y = Y*(N//n)
Y = Y[0:N]
if X >= Y:
num += 1
#print(num, X>=Y)
num_yakusu = make_divisors(n)
for z in num_yakusu:
num -= num_dict[z]
num_dict[n] = num
num *= 2*n
num %= mod
ans += num
ans %= mod
#print(n, ans, before, Y, X)
print(ans)
``` | output | 1 | 64,621 | 22 | 129,243 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given are integers N and X. For each integer k between 0 and X (inclusive), find the answer to the following question, then compute the sum of all those answers, modulo 998244353.
* Let us repeat the following operation on the integer k. Operation: if the integer is currently odd, subtract 1 from it and divide it by 2; otherwise, divide it by 2 and add 2^{N-1} to it. How many operations need to be performed until k returns to its original value? (The answer is considered to be 0 if k never returns to its original value.)
Constraints
* 1 \leq N \leq 2\times 10^5
* 0 \leq X < 2^N
* X is given in binary and has exactly N digits. (In case X has less than N digits, it is given with leading zeroes.)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X
Output
Print the sum of the answers to the questions for the integers between 0 and X (inclusive), modulo 998244353.
Examples
Input
3
111
Output
40
Input
6
110101
Output
616
Input
30
001110011011011101010111011100
Output
549320998
Submitted Solution:
```
mod=998244353
import collections
n=int(input())
x=input()
ans=(2*n*(int(x,2)+1))%mod
def make_divisors(n):
divisors=[]
for i in range(1,int(n**0.5)+1):
if n%i==0:
divisors.append(i)
if i!=n//i:
divisors.append(n//i)
divisors.sort(reverse=True)
return divisors
D=make_divisors(n)
CT=collections.defaultdict(int)
for d in D:
if d%2==0 or d==1:
continue
else:
k=n//d
#下から0がk個、1がk個、、、、を繰り返す数を求める、ｙとする。
#その周期は2*k
y=(2**n-2**k)//(2**k+1)
#ｙ+（ｙ＋１）*yyも同じ周期をもつ
#x以下の個数を数える
ct=(int(x,2)-y)//(y+1)+1
#重複分を差し引く
Dk=make_divisors(k)
for dk in Dk:
if dk<k:
ct-=CT[dk]
CT[k]=ct
#ansはすべてを2nで数えているのでそこから2(n-k)を引く
ans-=ct*2*(n-k)
print(ans%mod)
``` | instruction | 0 | 64,624 | 22 | 129,248 |
Yes | output | 1 | 64,624 | 22 | 129,249 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given are integers N and X. For each integer k between 0 and X (inclusive), find the answer to the following question, then compute the sum of all those answers, modulo 998244353.
* Let us repeat the following operation on the integer k. Operation: if the integer is currently odd, subtract 1 from it and divide it by 2; otherwise, divide it by 2 and add 2^{N-1} to it. How many operations need to be performed until k returns to its original value? (The answer is considered to be 0 if k never returns to its original value.)
Constraints
* 1 \leq N \leq 2\times 10^5
* 0 \leq X < 2^N
* X is given in binary and has exactly N digits. (In case X has less than N digits, it is given with leading zeroes.)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X
Output
Print the sum of the answers to the questions for the integers between 0 and X (inclusive), modulo 998244353.
Examples
Input
3
111
Output
40
Input
6
110101
Output
616
Input
30
001110011011011101010111011100
Output
549320998
Submitted Solution:
```
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
def nasu(x):
t = make_divisors(x)
c = 0
for i in t:
c += D[i]
return c
def honya(x):
y = 0
k = 1
for i in range(x - 1, -1, -1):
if X[i]:
y = (y + k) % MOD
k = (k * 2) % MOD
return y + honyaraka(x)
def honyaraka(x):
cnt = 0
for i in range(N // x):
t = i % 2
for j in range(x):
if X[cnt] != (X[j] ^ t):
if X[cnt] == 0:
return 0
else:
return 1
cnt += 1
return 1
N = int(input())
X = list(map(int, input()))
MOD = 998244353
Y = 0
k = 1
for i in range(N - 1, -1, -1):
if X[i]:
Y = (Y + k) % MOD
k = (k * 2) % MOD
D = [0] * (N + 1)
L = make_divisors(N)
cnt = 0
for i in L:
if i != N and (N // i) % 2 == 1:
D[i] = honya(i) - nasu(i)
cnt += D[i]
D[N] = Y - cnt + 1
ans = 0
for i in L:
ans = (ans + D[i] * i * 2) % MOD
print(ans)
``` | instruction | 0 | 64,626 | 22 | 129,252 |
Yes | output | 1 | 64,626 | 22 | 129,253 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given are integers N and X. For each integer k between 0 and X (inclusive), find the answer to the following question, then compute the sum of all those answers, modulo 998244353.
* Let us repeat the following operation on the integer k. Operation: if the integer is currently odd, subtract 1 from it and divide it by 2; otherwise, divide it by 2 and add 2^{N-1} to it. How many operations need to be performed until k returns to its original value? (The answer is considered to be 0 if k never returns to its original value.)
Constraints
* 1 \leq N \leq 2\times 10^5
* 0 \leq X < 2^N
* X is given in binary and has exactly N digits. (In case X has less than N digits, it is given with leading zeroes.)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X
Output
Print the sum of the answers to the questions for the integers between 0 and X (inclusive), modulo 998244353.
Examples
Input
3
111
Output
40
Input
6
110101
Output
616
Input
30
001110011011011101010111011100
Output
549320998
Submitted Solution:
```
def get_divisor(n):
ret = []
for i in range(3, n + 1, 2):
if n % i == 0:
ret.append(i)
return ret
def get_dec(x, MOD):
b = 1
t = 0
for c in x[::-1]:
if c == '1':
t = (t + b) % MOD
b = b * 2 % MOD
return t
def count_head_smaller(x, y, d, t, MOD):
p = x[:t]
q = y[:t]
k = get_dec(p, MOD)
r = (p + q) * (d // 2) + p
if x >= r:
k += 1
return k
def solve(n, x):
MOD = 998244353
divisors = get_divisor(n)
divisors.reverse()
checked_divisors = {}
y = ''.join('1' if c == '0' else '0' for c in x)
ans = 0
short = 0
for d in divisors:
t = n // d
k = count_head_smaller(x, y, d, t, MOD)
for pd, pk in checked_divisors.items():
if pd % d != 0:
continue
k -= pk
ans = (ans + 2 * t * k) % MOD
short += k
checked_divisors[d] = k
t = (get_dec(x, MOD) + 1 - short) % MOD
ans = (ans + t * 2 * n) % MOD
return ans
n = int(input())
x = input()
print(solve(n, x))
``` | instruction | 0 | 64,627 | 22 | 129,254 |
Yes | output | 1 | 64,627 | 22 | 129,255 |
Provide a correct Python 3 solution for this coding contest problem.
Some positive integers can be represented by a sum of one or more consecutive prime numbers. How many such representations does a given positive integer have? For example, the integer 53 has two representations 5 + 7 + 11 + 13 + 17 and 53. The integer 41 has three representations 2 + 3 + 5 + 7 + 11 + 13, 11 + 13 + 17, and 41. The integer 3 has only one representation, which is 3. The integer 20 has no such representations. Note that summands must be consecutive prime numbers, so neither 7 + 13 nor 3 + 5 + 5 + 7 is a valid representation for the integer 20.
Your mission is to write a program that reports the number of representations for the given positive integer.
Input
The input is a sequence of positive integers each in a separate line. The integers are between 2 and 10 000, inclusive. The end of the input is indicated by a zero.
Output
The output should be composed of lines each corresponding to an input line except the last zero. An output line includes the number of representations for the input integer as the sum of one or more consecutive prime numbers. No other characters should be inserted in the output.
Example
Input
2
3
17
41
20
666
12
53
0
Output
1
1
2
3
0
0
1
2 | instruction | 0 | 64,761 | 22 | 129,522 |
"Correct Solution:
```
def prime(n):
prime_flag = [0 for i in range(n + 1)]
prime_list = []
for i in range(2, n + 1):
if prime_flag[i] == 0:
prime_list.append(i)
temp = 1
while temp * i <= n:
prime_flag[temp * i] = 1
temp += 1
return prime_list
prime_list = prime(10000)
answer = []
while True:
n = int(input())
if not n:
break
left = 0
right = 0
count = 2
ans = 0
while True:
if n == count:
ans += 1
if left == right == len(prime_list) - 1:
break
elif count + prime_list[right + 1] <= n and right != len(prime_list) - 1:
right += 1
count += prime_list[right]
else:
if left == right:
left += 1
right += 1
count = prime_list[left]
else:
count -= prime_list[left]
left += 1
answer.append(ans)
for i in answer:
print(i)
``` | output | 1 | 64,761 | 22 | 129,523 |
Provide a correct Python 3 solution for this coding contest problem.
Some positive integers can be represented by a sum of one or more consecutive prime numbers. How many such representations does a given positive integer have? For example, the integer 53 has two representations 5 + 7 + 11 + 13 + 17 and 53. The integer 41 has three representations 2 + 3 + 5 + 7 + 11 + 13, 11 + 13 + 17, and 41. The integer 3 has only one representation, which is 3. The integer 20 has no such representations. Note that summands must be consecutive prime numbers, so neither 7 + 13 nor 3 + 5 + 5 + 7 is a valid representation for the integer 20.
Your mission is to write a program that reports the number of representations for the given positive integer.
Input
The input is a sequence of positive integers each in a separate line. The integers are between 2 and 10 000, inclusive. The end of the input is indicated by a zero.
Output
The output should be composed of lines each corresponding to an input line except the last zero. An output line includes the number of representations for the input integer as the sum of one or more consecutive prime numbers. No other characters should be inserted in the output.
Example
Input
2
3
17
41
20
666
12
53
0
Output
1
1
2
3
0
0
1
2 | instruction | 0 | 64,762 | 22 | 129,524 |
"Correct Solution:
```
p=[]
for i in range(2,10001):
for j in range(2,int(i**0.5)+1):
if not i%j:break
else:p+=[i]
b=[0]*5736397
for i in range(len(p)):
c=0
for j in range(i,len(p)):
c+=p[j]
b[c]+=1
while 1:
n=int(input())
if n==0:break
print(b[n])
``` | output | 1 | 64,762 | 22 | 129,525 |
Provide a correct Python 3 solution for this coding contest problem.
Some positive integers can be represented by a sum of one or more consecutive prime numbers. How many such representations does a given positive integer have? For example, the integer 53 has two representations 5 + 7 + 11 + 13 + 17 and 53. The integer 41 has three representations 2 + 3 + 5 + 7 + 11 + 13, 11 + 13 + 17, and 41. The integer 3 has only one representation, which is 3. The integer 20 has no such representations. Note that summands must be consecutive prime numbers, so neither 7 + 13 nor 3 + 5 + 5 + 7 is a valid representation for the integer 20.
Your mission is to write a program that reports the number of representations for the given positive integer.
Input
The input is a sequence of positive integers each in a separate line. The integers are between 2 and 10 000, inclusive. The end of the input is indicated by a zero.
Output
The output should be composed of lines each corresponding to an input line except the last zero. An output line includes the number of representations for the input integer as the sum of one or more consecutive prime numbers. No other characters should be inserted in the output.
Example
Input
2
3
17
41
20
666
12
53
0
Output
1
1
2
3
0
0
1
2 | instruction | 0 | 64,763 | 22 | 129,526 |
"Correct Solution:
```
import math
isPrime = [1 for _ in range (10002)]
isPrime[:2] = [0, 0]
for i in range(2, 101):
for j in range(i*i, 10001, i):
isPrime[j] = 0
prime = []
for i in range(10001):
if isPrime[i] == 1:
prime.append(i)
while True:
n = int(input())
if n == 0:
break
cnt = 0
for i in range(len(prime) + 1):
sum = 0
for j in range(i,len(prime)):
sum += prime[j]
if sum == n:
cnt += 1
break
if sum > n:
break
print(cnt)
``` | output | 1 | 64,763 | 22 | 129,527 |
Provide a correct Python 3 solution for this coding contest problem.
Some positive integers can be represented by a sum of one or more consecutive prime numbers. How many such representations does a given positive integer have? For example, the integer 53 has two representations 5 + 7 + 11 + 13 + 17 and 53. The integer 41 has three representations 2 + 3 + 5 + 7 + 11 + 13, 11 + 13 + 17, and 41. The integer 3 has only one representation, which is 3. The integer 20 has no such representations. Note that summands must be consecutive prime numbers, so neither 7 + 13 nor 3 + 5 + 5 + 7 is a valid representation for the integer 20.
Your mission is to write a program that reports the number of representations for the given positive integer.
Input
The input is a sequence of positive integers each in a separate line. The integers are between 2 and 10 000, inclusive. The end of the input is indicated by a zero.
Output
The output should be composed of lines each corresponding to an input line except the last zero. An output line includes the number of representations for the input integer as the sum of one or more consecutive prime numbers. No other characters should be inserted in the output.
Example
Input
2
3
17
41
20
666
12
53
0
Output
1
1
2
3
0
0
1
2 | instruction | 0 | 64,764 | 22 | 129,528 |
"Correct Solution:
```
primes = [0, 0] + [1]*9999
for i in range(2, 101):
if primes[i]:
for j in range(i*i, 10001, i):
primes[j] = 0
pnums = [i for i in range(10001) if primes[i]]
while True:
n = int(input())
if n == 0:
break
m = n
while not primes[m]:
m -= 1
ans = 0
end = pnums.index(m)+1
for i in range(end):
tmp = 0
for j in range(i, end):
tmp += pnums[j]
if tmp == n:
ans += 1
break
if tmp > n:
break
print(ans)
``` | output | 1 | 64,764 | 22 | 129,529 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.