message stringlengths 2 57.2k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 61 108k | cluster float64 22 22 | __index_level_0__ int64 122 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's consider a table consisting of n rows and n columns. The cell located at the intersection of i-th row and j-th column contains number i × j. The rows and columns are numbered starting from 1.
You are given a positive integer x. Your task is to count the number of cells in a table that contain number x.
Input
The single line contains numbers n and x (1 ≤ n ≤ 105, 1 ≤ x ≤ 109) — the size of the table and the number that we are looking for in the table.
Output
Print a single number: the number of times x occurs in the table.
Examples
Input
10 5
Output
2
Input
6 12
Output
4
Input
5 13
Output
0
Note
A table for the second sample test is given below. The occurrences of number 12 are marked bold.
<image> | instruction | 0 | 13,691 | 22 | 27,382 |
Tags: implementation, number theory
Correct Solution:
```
n,x=input().split(" ")
n=int(n)
x=int(x)
count = 0
for i in range(1,n+1):
if x%i==0 and x/i<=n:
count = count+1
print(count)
``` | output | 1 | 13,691 | 22 | 27,383 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's consider a table consisting of n rows and n columns. The cell located at the intersection of i-th row and j-th column contains number i × j. The rows and columns are numbered starting from 1.
You are given a positive integer x. Your task is to count the number of cells in a table that contain number x.
Input
The single line contains numbers n and x (1 ≤ n ≤ 105, 1 ≤ x ≤ 109) — the size of the table and the number that we are looking for in the table.
Output
Print a single number: the number of times x occurs in the table.
Examples
Input
10 5
Output
2
Input
6 12
Output
4
Input
5 13
Output
0
Note
A table for the second sample test is given below. The occurrences of number 12 are marked bold.
<image> | instruction | 0 | 13,692 | 22 | 27,384 |
Tags: implementation, number theory
Correct Solution:
```
n, x = (int(y) for y in input().split())
count = 0
for i in range(1, n + 1):
div = x / i
if div == int(div) and div >= 1 and div <= n:
count += 1
print(count)
``` | output | 1 | 13,692 | 22 | 27,385 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's consider a table consisting of n rows and n columns. The cell located at the intersection of i-th row and j-th column contains number i × j. The rows and columns are numbered starting from 1.
You are given a positive integer x. Your task is to count the number of cells in a table that contain number x.
Input
The single line contains numbers n and x (1 ≤ n ≤ 105, 1 ≤ x ≤ 109) — the size of the table and the number that we are looking for in the table.
Output
Print a single number: the number of times x occurs in the table.
Examples
Input
10 5
Output
2
Input
6 12
Output
4
Input
5 13
Output
0
Note
A table for the second sample test is given below. The occurrences of number 12 are marked bold.
<image> | instruction | 0 | 13,693 | 22 | 27,386 |
Tags: implementation, number theory
Correct Solution:
```
from math import sqrt
n,x=map(int,input().split())
c=0
y=sqrt(x)
for i in range(1,int(y)+1):
if x%i==0 and x//i<=n:
if i!=y:
c+=2
else:
c+=1
print(c)
``` | output | 1 | 13,693 | 22 | 27,387 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's consider a table consisting of n rows and n columns. The cell located at the intersection of i-th row and j-th column contains number i × j. The rows and columns are numbered starting from 1.
You are given a positive integer x. Your task is to count the number of cells in a table that contain number x.
Input
The single line contains numbers n and x (1 ≤ n ≤ 105, 1 ≤ x ≤ 109) — the size of the table and the number that we are looking for in the table.
Output
Print a single number: the number of times x occurs in the table.
Examples
Input
10 5
Output
2
Input
6 12
Output
4
Input
5 13
Output
0
Note
A table for the second sample test is given below. The occurrences of number 12 are marked bold.
<image> | instruction | 0 | 13,694 | 22 | 27,388 |
Tags: implementation, number theory
Correct Solution:
```
n,x=map(int,input().split())
a=0
for i in range(1,n+1):
if x/i==x//i and x//i<=n:
a=a+1
print(a)
``` | output | 1 | 13,694 | 22 | 27,389 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's consider a table consisting of n rows and n columns. The cell located at the intersection of i-th row and j-th column contains number i × j. The rows and columns are numbered starting from 1.
You are given a positive integer x. Your task is to count the number of cells in a table that contain number x.
Input
The single line contains numbers n and x (1 ≤ n ≤ 105, 1 ≤ x ≤ 109) — the size of the table and the number that we are looking for in the table.
Output
Print a single number: the number of times x occurs in the table.
Examples
Input
10 5
Output
2
Input
6 12
Output
4
Input
5 13
Output
0
Note
A table for the second sample test is given below. The occurrences of number 12 are marked bold.
<image> | instruction | 0 | 13,695 | 22 | 27,390 |
Tags: implementation, number theory
Correct Solution:
```
a,b=map(int,input().split())
ans=0
for i in range(1,a+1):
if b%i==0:
if b//i<=a:
ans+=1
print(ans)
``` | output | 1 | 13,695 | 22 | 27,391 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's consider a table consisting of n rows and n columns. The cell located at the intersection of i-th row and j-th column contains number i × j. The rows and columns are numbered starting from 1.
You are given a positive integer x. Your task is to count the number of cells in a table that contain number x.
Input
The single line contains numbers n and x (1 ≤ n ≤ 105, 1 ≤ x ≤ 109) — the size of the table and the number that we are looking for in the table.
Output
Print a single number: the number of times x occurs in the table.
Examples
Input
10 5
Output
2
Input
6 12
Output
4
Input
5 13
Output
0
Note
A table for the second sample test is given below. The occurrences of number 12 are marked bold.
<image> | instruction | 0 | 13,696 | 22 | 27,392 |
Tags: implementation, number theory
Correct Solution:
```
n, x = map(int, input().split())
print(sum(x % i == 0 and x<=n*i for i in range(1, n + 1)))
``` | output | 1 | 13,696 | 22 | 27,393 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n ≥ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni ≥ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 2·109) — the total year income of mr. Funt.
Output
Print one integer — minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3 | instruction | 0 | 13,772 | 22 | 27,544 |
Tags: math, number theory
Correct Solution:
```
import math
def isPrime(n):
a=math.sqrt(n)
i=2
while i<=a:
if n%i==0:
return False
i+=1
return True
n=int(input())
if isPrime(n):
print(1)
else:
if n%2==0:
print(2)
else:
if isPrime(n-2):
print(2)
else:
print(3)
``` | output | 1 | 13,772 | 22 | 27,545 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n ≥ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni ≥ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 2·109) — the total year income of mr. Funt.
Output
Print one integer — minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3 | instruction | 0 | 13,773 | 22 | 27,546 |
Tags: math, number theory
Correct Solution:
```
import math,sys,bisect,heapq,os
from collections import defaultdict,Counter,deque
from itertools import groupby,accumulate
from functools import lru_cache
#sys.setrecursionlimit(200000000)
int1 = lambda x: int(x) - 1
def input(): return sys.stdin.readline().rstrip('\r\n')
#input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
aj = lambda: list(map(int, input().split()))
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
#MOD = 1000000000 + 7
def Y(c): print(["NO","YES"][c])
def y(c): print(["no","yes"][c])
def Yy(c): print(["No","Yes"][c])
def solve():
def isprime(n):
n = abs(int(n))
if n < 2:
return False
if n == 2:
return True
if not n & 1:
return False
for x in range(3, int(n**0.5) + 1, 2):
if n % x == 0:
return False
return True
n, = aj()
if isprime(n):
print(1)
elif isprime(n-2):
print(2)
elif n%2 == 0:
print(2)
else:
print(3)
try:
#os.system("online_judge.py")
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
except:
pass
solve()
``` | output | 1 | 13,773 | 22 | 27,547 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n ≥ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni ≥ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 2·109) — the total year income of mr. Funt.
Output
Print one integer — minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3 | instruction | 0 | 13,774 | 22 | 27,548 |
Tags: math, number theory
Correct Solution:
```
def isPrime(n):
if (n <= 1):
return False
if (n <= 3):
return True
if (n % 2 == 0 or n % 3 == 0):
return False
i = 5
while (i * i <= n):
if (n % i == 0 or n % (i + 2) == 0):
return False
i = i + 6
return True
n=int(input())
print("1") if isPrime(n) else print("2") if n%2==0 else print("2") if isPrime(n-2) else print("3")
``` | output | 1 | 13,774 | 22 | 27,549 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n ≥ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni ≥ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 2·109) — the total year income of mr. Funt.
Output
Print one integer — minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3 | instruction | 0 | 13,775 | 22 | 27,550 |
Tags: math, number theory
Correct Solution:
```
def isPrime(num):
if num <= 1:
return False
if num <= 3:
return True
if num % 2 == 0 or num % 3 == 0:
return False
i = 5
while i * i <= num:
if num % i == 0 or num % (i+2) == 0:
return False
i += 6
return True
n = int(input())
if isPrime(n):
print(1)
elif n + 1 & 1:
print(2)
elif isPrime(n - 2):
print(2)
else:
print(3)
``` | output | 1 | 13,775 | 22 | 27,551 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n ≥ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni ≥ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 2·109) — the total year income of mr. Funt.
Output
Print one integer — minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3 | instruction | 0 | 13,776 | 22 | 27,552 |
Tags: math, number theory
Correct Solution:
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Функция вычисляет, простое ли число n>=2
# 1 считается простым
def isPrime(n):
if (n==2)|(n==3):
return True
elif (n%2==0)|(n%3==0):
return False
else:
nsq=int(n**0.5)+1
for k in range(3,nsq,2):
if n%k==0:
return False
return True
n=int(input())
if isPrime(n):
print(1)
elif isPrime(n-2):
print(2)
elif n%2==0:
print(2)
else:
print (3)
``` | output | 1 | 13,776 | 22 | 27,553 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n ≥ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni ≥ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 2·109) — the total year income of mr. Funt.
Output
Print one integer — minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3 | instruction | 0 | 13,777 | 22 | 27,554 |
Tags: math, number theory
Correct Solution:
```
from sys import stdin, stdout
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
mod = pow(10, 9) + 7
mod2 = 998244353
def inp(): return stdin.readline().strip()
def iinp(): return int(inp())
def out(var, end="\n"): stdout.write(str(var)+"\n")
def outa(*var, end="\n"): stdout.write(' '.join(map(str, var)) + end)
def lmp(): return list(mp())
def mp(): return map(int, inp().split())
def smp(): return map(str, inp().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(m, val) for j in range(n)]
def remadd(x, y): return 1 if x%y else 0
def ceil(a,b): return (a+b-1)//b
S1 = 'abcdefghijklmnopqrstuvwxyz'
S2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def isprime(x):
if x<=1: return False
if x in (2, 3): return True
if x%2 == 0: return False
for i in range(3, int(sqrt(x))+1, 2):
if x%i == 0: return False
return True
n = iinp()
if isprime(n):
print(1)
elif n%2==0:
print(2)
else:
if isprime(n-2):
print(2)
else:
print(3)
``` | output | 1 | 13,777 | 22 | 27,555 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n ≥ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni ≥ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 2·109) — the total year income of mr. Funt.
Output
Print one integer — minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3 | instruction | 0 | 13,778 | 22 | 27,556 |
Tags: math, number theory
Correct Solution:
```
from math import sqrt
def prime(n):
for d in range(3, int(sqrt(n)) + 1, 2):
if n % d == 0:
return 0
return 1
n = int(input())
if n == 2:
print(1)
elif n % 2 == 0:
print(2)
elif prime(n):
print(1)
elif prime(n - 2):
print(2)
else:
print(3)
``` | output | 1 | 13,778 | 22 | 27,557 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n ≥ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni ≥ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 2·109) — the total year income of mr. Funt.
Output
Print one integer — minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3 | instruction | 0 | 13,779 | 22 | 27,558 |
Tags: math, number theory
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
from types import GeneratorType
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
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 = self.os.read(self._fd, max(self.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 = self.os.read(self._fd, max(self.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:
self.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 time
start_time = time.time()
import collections
def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input()
def listStr():
return list(input())
"""
If prime: 1
Elif even: 2
Elif odd: 3
"""
def is_prime(n):
for j in range(2,int(n**0.5)+1):
if n % j == 0:
return False
return True
def solve():
N = getInt()
if is_prime(N):
return 1
if N % 2 == 0:
return 2
if is_prime(N-2):
return 2
return 3
print(solve())
``` | output | 1 | 13,779 | 22 | 27,559 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n ≥ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni ≥ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 2·109) — the total year income of mr. Funt.
Output
Print one integer — minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Submitted Solution:
```
def isprime(x):
for i in range(2,int(x**0.5)+1):
if x%i==0:
return False
return True
n=int(input())
if isprime(n):
print(1)
elif n%2==0:
print(2)
else:
if isprime(n-2):
print(2)
else:
print(3)
``` | instruction | 0 | 13,780 | 22 | 27,560 |
Yes | output | 1 | 13,780 | 22 | 27,561 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n ≥ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni ≥ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 2·109) — the total year income of mr. Funt.
Output
Print one integer — minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Submitted Solution:
```
def is_prime(n):
for i in range(2, int(n ** 0.5 + 1)):
if n % i == 0:
return False
return True
n = int(input())
if n % 2 == 0:
if is_prime(n):
print(1)
else:
print(2)
else:
if is_prime(n):
print(1)
elif is_prime(n - 2):
print(2)
else:
print(3)
``` | instruction | 0 | 13,781 | 22 | 27,562 |
Yes | output | 1 | 13,781 | 22 | 27,563 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n ≥ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni ≥ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 2·109) — the total year income of mr. Funt.
Output
Print one integer — minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Submitted Solution:
```
def isprime(n):
if pow(2, n, n) == 2:
return True
else:
return False
n = int(input())
if n > 5 and n % 2:
if isprime(n):
print(1)
elif isprime(n-2):
print(2)
else:
print(3)
elif n > 2 and not n % 2:
print(2)
elif n in (2, 3, 5):
print(1)
``` | instruction | 0 | 13,785 | 22 | 27,570 |
No | output | 1 | 13,785 | 22 | 27,571 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n ≥ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni ≥ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 2·109) — the total year income of mr. Funt.
Output
Print one integer — minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Submitted Solution:
```
from math import sqrt
def prime_check(n):
flag=1
for i in range(3,int(sqrt(n))+2,2):
if (n%i==0):
flag=0
break
return (flag)
n=int(input())
arr=[0,0,1,1,2,1,2,1,2,3,2]
if (n<=10):
print (arr[n])
else:
if (n%2==0):
print (2)
else:
if (prime_check(n)):
print (1)
elif (prime_check(n-2)):
print (2)
else:
print (3)
``` | instruction | 0 | 13,786 | 22 | 27,572 |
No | output | 1 | 13,786 | 22 | 27,573 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Allen is playing Number Clicker on his phone.
He starts with an integer u on the screen. Every second, he can press one of 3 buttons.
1. Turn u → u+1 \pmod{p}.
2. Turn u → u+p-1 \pmod{p}.
3. Turn u → u^{p-2} \pmod{p}.
Allen wants to press at most 200 buttons and end up with v on the screen. Help him!
Input
The first line of the input contains 3 positive integers: u, v, p (0 ≤ u, v ≤ p-1, 3 ≤ p ≤ 10^9 + 9). p is guaranteed to be prime.
Output
On the first line, print a single integer ℓ, the number of button presses. On the second line, print integers c_1, ..., c_ℓ, the button presses. For 1 ≤ i ≤ ℓ, 1 ≤ c_i ≤ 3.
We can show that the answer always exists.
Examples
Input
1 3 5
Output
2
1 1
Input
3 2 5
Output
1
3
Note
In the first example the integer on the screen changes as 1 → 2 → 3.
In the second example the integer on the screen changes as 3 → 2.
Submitted Solution:
```
u, v, p = [int(x) for x in input().split()]
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, y, x = egcd(b % a, a)
return (g, x - (b // a) * y, y)
def modinv(a, m):
g, x, y = egcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
def moves(x, p):
return [(x + 1) % p, (x + p -1) % p, (modinv(x, p) if x else x)]
q = [u]
parent = {u: None}
depth = {u: 0}
res = []
q2 = [v]
parent2 = {v: None}
depth2 = {v: 0}
res2 = []
ans = None
while q:
node = q.pop(0)
if node in parent2:
ans = node
break
for i, child in enumerate(moves(node, p)):
if child not in parent:
parent[child] = (node, i + 1)
depth[child] = depth[node] + 1
q.append(child)
node2 = q2.pop(0)
if node2 in parent:
ans = node2
break
for i, child in enumerate(moves(node2, p)):
if child not in parent2:
parent2[child] = (node2, i + 1)
depth2[child] = depth2[node2] + 1
q2.append(child)
left = ans
while parent[left] is not None:
left, val = parent[left]
res.append(val)
res = res[::-1]
right = ans
while parent2[right] is not None:
right, val = parent2[right]
res.append(val)
print(len(res))
print(" ".join(map(str, res)))
``` | instruction | 0 | 13,904 | 22 | 27,808 |
No | output | 1 | 13,904 | 22 | 27,809 |
Provide a correct Python 3 solution for this coding contest problem.
There are N integers written on a blackboard. The i-th integer is A_i, and the greatest common divisor of these integers is 1.
Takahashi and Aoki will play a game using these integers. In this game, starting from Takahashi the two player alternately perform the following operation:
* Select one integer on the blackboard that is not less than 2, and subtract 1 from the integer.
* Then, divide all the integers on the black board by g, where g is the greatest common divisor of the integers written on the blackboard.
The player who is left with only 1s on the blackboard and thus cannot perform the operation, loses the game. Assuming that both players play optimally, determine the winner of the game.
Constraints
* 1 ≦ N ≦ 10^5
* 1 ≦ A_i ≦ 10^9
* The greatest common divisor of the integers from A_1 through A_N is 1.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
Output
If Takahashi will win, print `First`. If Aoki will win, print `Second`.
Examples
Input
3
3 6 7
Output
First
Input
4
1 2 4 8
Output
First
Input
5
7 8 8 8 8
Output
Second | instruction | 0 | 14,012 | 22 | 28,024 |
"Correct Solution:
```
N=int(input())
A=[int(i) for i in input().split()]
S=sum(A)
def gcd(x,y):
if x<y:
x,y=y,x
if x%y==0:
return y
return gcd(y,x%y)
if (S-N)%2:
print("First")
else:
First=False
while True:
odd=-1
for i in range(N):
if A[i]%2:
if odd>=0 or A[i]==1:
if First:
print("First")
else:
print("Second")
exit()
A[i]-=1
odd=i
if i==0:
g=A[0]
else:
g=gcd(g,A[i])
S=0
for i in range(N):
A[i]=A[i]//g
S+=A[i]
if (S-N)%2==0:
if First:
First=False
else:
First=True
else:
if First:
print("First")
else:
print("Second")
exit()
``` | output | 1 | 14,012 | 22 | 28,025 |
Provide a correct Python 3 solution for this coding contest problem.
There are N integers written on a blackboard. The i-th integer is A_i, and the greatest common divisor of these integers is 1.
Takahashi and Aoki will play a game using these integers. In this game, starting from Takahashi the two player alternately perform the following operation:
* Select one integer on the blackboard that is not less than 2, and subtract 1 from the integer.
* Then, divide all the integers on the black board by g, where g is the greatest common divisor of the integers written on the blackboard.
The player who is left with only 1s on the blackboard and thus cannot perform the operation, loses the game. Assuming that both players play optimally, determine the winner of the game.
Constraints
* 1 ≦ N ≦ 10^5
* 1 ≦ A_i ≦ 10^9
* The greatest common divisor of the integers from A_1 through A_N is 1.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
Output
If Takahashi will win, print `First`. If Aoki will win, print `Second`.
Examples
Input
3
3 6 7
Output
First
Input
4
1 2 4 8
Output
First
Input
5
7 8 8 8 8
Output
Second | instruction | 0 | 14,013 | 22 | 28,026 |
"Correct Solution:
```
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
N = I()
A = LI()
if N == 1:
print('Second')
exit()
if N == 2:
print('First')
exit()
from math import gcd
r = 0 # 0:高橋君の番、1:青木君の番
while True:
if (sum(A)-N) % 2 == 1:
if r == 0:
print('First')
else:
print('Second')
break
else:
a = 0 # 奇数の要素の個数
b = 0 # 1の個数
for i in range(N):
if A[i] % 2 == 1:
a += 1
if A[i] == 1:
b += 1
if a != 1 or b > 0:
if r == 0:
print('Second')
else:
print('First')
break
else:
g = 0
for i in range(N):
if A[i] % 2 == 1:
g = gcd(g,A[i]-1)
else:
g = gcd(g,A[i])
for i in range(N):
A[i] = A[i]//g
r = 1-r
``` | output | 1 | 14,013 | 22 | 28,027 |
Provide a correct Python 3 solution for this coding contest problem.
There are N integers written on a blackboard. The i-th integer is A_i, and the greatest common divisor of these integers is 1.
Takahashi and Aoki will play a game using these integers. In this game, starting from Takahashi the two player alternately perform the following operation:
* Select one integer on the blackboard that is not less than 2, and subtract 1 from the integer.
* Then, divide all the integers on the black board by g, where g is the greatest common divisor of the integers written on the blackboard.
The player who is left with only 1s on the blackboard and thus cannot perform the operation, loses the game. Assuming that both players play optimally, determine the winner of the game.
Constraints
* 1 ≦ N ≦ 10^5
* 1 ≦ A_i ≦ 10^9
* The greatest common divisor of the integers from A_1 through A_N is 1.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
Output
If Takahashi will win, print `First`. If Aoki will win, print `Second`.
Examples
Input
3
3 6 7
Output
First
Input
4
1 2 4 8
Output
First
Input
5
7 8 8 8 8
Output
Second | instruction | 0 | 14,014 | 22 | 28,028 |
"Correct Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from fractions import gcd
def readln(ch):
_res = list(map(int,str(input()).split(ch)))
return _res
def count(a):
odd, even = 0,0
for x in a:
if x % 2 == 1: odd = odd + 1
else: even = even + 1
return odd,even
def deal(n,a):
odd,even = count(a)
if even == 0:
return False
if even % 2 == 1:
return True
if odd > 1:
return False
if a[0] % 2 == 0:
res = a[0]
else:
res = a[1]
for i in range(0,n):
if a[i] % 2 == 1:
if a[i] == 1: return False
a[i] = a[i] - 1
res = gcd(a[i],res)
return not deal(n,list(map(lambda x: x//res,a)))
n = int(input())
a = readln(' ')
if deal(n,a):
print('First')
else:
print('Second')
``` | output | 1 | 14,014 | 22 | 28,029 |
Provide a correct Python 3 solution for this coding contest problem.
There are N integers written on a blackboard. The i-th integer is A_i, and the greatest common divisor of these integers is 1.
Takahashi and Aoki will play a game using these integers. In this game, starting from Takahashi the two player alternately perform the following operation:
* Select one integer on the blackboard that is not less than 2, and subtract 1 from the integer.
* Then, divide all the integers on the black board by g, where g is the greatest common divisor of the integers written on the blackboard.
The player who is left with only 1s on the blackboard and thus cannot perform the operation, loses the game. Assuming that both players play optimally, determine the winner of the game.
Constraints
* 1 ≦ N ≦ 10^5
* 1 ≦ A_i ≦ 10^9
* The greatest common divisor of the integers from A_1 through A_N is 1.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
Output
If Takahashi will win, print `First`. If Aoki will win, print `Second`.
Examples
Input
3
3 6 7
Output
First
Input
4
1 2 4 8
Output
First
Input
5
7 8 8 8 8
Output
Second | instruction | 0 | 14,015 | 22 | 28,030 |
"Correct Solution:
```
#d
#the niumbers of evens is important
#the point is, there is no influence to odd/even if you divide them by odd numbers.
#You should do simulation only in the case where there is one odd over 3 and even numbers of even numbers
from fractions import gcd
def count(a):
odd, even = 0,0
for x in a:
if x % 2 == 1: odd = odd + 1
else: even = even + 1
return odd,even
def deal(n,a):
odd,even = count(a)
if even == 0:
return False
if even % 2 == 1:
return True
if odd > 1:
return False
#the case where there is one odd (over 3) and even numbers of even numbers
#calculate gcd by step by step
#if you write g = 1, it is a lie.
if a[0] % 2 == 0:
g = a[0]
else:
g = a[1]
for i in range(0,n):
if a[i] % 2 == 1:
if a[i] == 1:
return False
a[i] -= 1
g = gcd(a[i], g)
return not deal(n,list(map(lambda x: x//g,a)))
n = int(input())
a = [int(i) for i in input().split()]
if deal(n,a):
print('First')
else:
print('Second')
``` | output | 1 | 14,015 | 22 | 28,031 |
Provide a correct Python 3 solution for this coding contest problem.
There are N integers written on a blackboard. The i-th integer is A_i, and the greatest common divisor of these integers is 1.
Takahashi and Aoki will play a game using these integers. In this game, starting from Takahashi the two player alternately perform the following operation:
* Select one integer on the blackboard that is not less than 2, and subtract 1 from the integer.
* Then, divide all the integers on the black board by g, where g is the greatest common divisor of the integers written on the blackboard.
The player who is left with only 1s on the blackboard and thus cannot perform the operation, loses the game. Assuming that both players play optimally, determine the winner of the game.
Constraints
* 1 ≦ N ≦ 10^5
* 1 ≦ A_i ≦ 10^9
* The greatest common divisor of the integers from A_1 through A_N is 1.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
Output
If Takahashi will win, print `First`. If Aoki will win, print `Second`.
Examples
Input
3
3 6 7
Output
First
Input
4
1 2 4 8
Output
First
Input
5
7 8 8 8 8
Output
Second | instruction | 0 | 14,016 | 22 | 28,032 |
"Correct Solution:
```
import sys
readline = sys.stdin.readline
from functools import reduce
def gcd(a,b):
while b:
a, b = b, a%b
return a
def calc(A):
N = len(A)
if N == 1:
return A[0]%2 == 0
K = sum(1 for a in A if a % 2 == 0)
if K & 1:
return True
if N-K != 1:
return False
if min(A) == 1:
return False
A = [a-a%2 for a in A]
g = reduce(gcd, A)
A = [a//g for a in A]
return not calc(A)
N = int(readline())
A = list(map(int, readline().split()))
print('First' if calc(A) else 'Second')
``` | output | 1 | 14,016 | 22 | 28,033 |
Provide a correct Python 3 solution for this coding contest problem.
There are N integers written on a blackboard. The i-th integer is A_i, and the greatest common divisor of these integers is 1.
Takahashi and Aoki will play a game using these integers. In this game, starting from Takahashi the two player alternately perform the following operation:
* Select one integer on the blackboard that is not less than 2, and subtract 1 from the integer.
* Then, divide all the integers on the black board by g, where g is the greatest common divisor of the integers written on the blackboard.
The player who is left with only 1s on the blackboard and thus cannot perform the operation, loses the game. Assuming that both players play optimally, determine the winner of the game.
Constraints
* 1 ≦ N ≦ 10^5
* 1 ≦ A_i ≦ 10^9
* The greatest common divisor of the integers from A_1 through A_N is 1.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
Output
If Takahashi will win, print `First`. If Aoki will win, print `Second`.
Examples
Input
3
3 6 7
Output
First
Input
4
1 2 4 8
Output
First
Input
5
7 8 8 8 8
Output
Second | instruction | 0 | 14,017 | 22 | 28,034 |
"Correct Solution:
```
from fractions import gcd
n = int(input())
a = list(map(int,input().split()))
def gcds(ls):
ret = 0
for i in ls:
ret = gcd(ret,i)
return ret
def flg(ls):
if (sum(ls)-len(ls))%2:
ret = 1
else:
ret = 2
return ret
if n%2 == 0:
if sum(a)%2:
print("First")
else:
print("Second")
else:
cnt = 0
while flg(a)%2 == 0:
odd = 0
oddidx = -1
even = 0
for i,x in enumerate(a):
if x%2:
odd += 1
oddidx = i
else:
even += 1
if odd == 1 and a[oddidx] > 1:
a[oddidx] -= 1
g = gcds(a)
for i in range(n):
a[i] //= g
cnt += 1
else:
break
if (flg(a)+cnt)%2 == 1:
print("First")
else:
print("Second")
``` | output | 1 | 14,017 | 22 | 28,035 |
Provide a correct Python 3 solution for this coding contest problem.
There are N integers written on a blackboard. The i-th integer is A_i, and the greatest common divisor of these integers is 1.
Takahashi and Aoki will play a game using these integers. In this game, starting from Takahashi the two player alternately perform the following operation:
* Select one integer on the blackboard that is not less than 2, and subtract 1 from the integer.
* Then, divide all the integers on the black board by g, where g is the greatest common divisor of the integers written on the blackboard.
The player who is left with only 1s on the blackboard and thus cannot perform the operation, loses the game. Assuming that both players play optimally, determine the winner of the game.
Constraints
* 1 ≦ N ≦ 10^5
* 1 ≦ A_i ≦ 10^9
* The greatest common divisor of the integers from A_1 through A_N is 1.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
Output
If Takahashi will win, print `First`. If Aoki will win, print `Second`.
Examples
Input
3
3 6 7
Output
First
Input
4
1 2 4 8
Output
First
Input
5
7 8 8 8 8
Output
Second | instruction | 0 | 14,018 | 22 | 28,036 |
"Correct Solution:
```
from fractions import gcd
def gcdL(L):
g=L[0]
for i in range(1,len(L)):
if g==1:
return(g)
g=gcd(g,L[i])
return g
def play(A,i):
A[i]-=1
g=gcdL(A)
return [x//g for x in A]
def cnt(A):
odd,even=0,0
for a in A:
if a%2:
odd+=1
else:
even+=1
return odd,even
n=int(input())
A=list(map(int,input().split()))
First=1
while True:
odd,even=cnt(A)
if even%2:
print('First' if First else 'Second')
break
elif odd>1:
print('Second' if First else 'First')
break
else:
for i in range(n):
if A[i]%2:
break
if A[i]==1:
print('Second' if First else 'First')
break
else:
A=play(A,i)
First^=1
``` | output | 1 | 14,018 | 22 | 28,037 |
Provide a correct Python 3 solution for this coding contest problem.
There are N integers written on a blackboard. The i-th integer is A_i, and the greatest common divisor of these integers is 1.
Takahashi and Aoki will play a game using these integers. In this game, starting from Takahashi the two player alternately perform the following operation:
* Select one integer on the blackboard that is not less than 2, and subtract 1 from the integer.
* Then, divide all the integers on the black board by g, where g is the greatest common divisor of the integers written on the blackboard.
The player who is left with only 1s on the blackboard and thus cannot perform the operation, loses the game. Assuming that both players play optimally, determine the winner of the game.
Constraints
* 1 ≦ N ≦ 10^5
* 1 ≦ A_i ≦ 10^9
* The greatest common divisor of the integers from A_1 through A_N is 1.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
Output
If Takahashi will win, print `First`. If Aoki will win, print `Second`.
Examples
Input
3
3 6 7
Output
First
Input
4
1 2 4 8
Output
First
Input
5
7 8 8 8 8
Output
Second | instruction | 0 | 14,019 | 22 | 28,038 |
"Correct Solution:
```
#
# ⋀_⋀
# (･ω･)
# .／ Ｕ ∽ Ｕ＼
# │＊ 合 ＊│
# │＊ 格 ＊│
# │＊ 祈 ＊│
# │＊ 願 ＊│
# │＊ ＊│
# ￣
#
import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,sqrt,factorial,hypot,log #log2ないｙｐ
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from fractions import gcd
from random import randint
def ceil(a,b): return (a+b-1)//b
inf=float('inf')
mod = 10**9+7
def pprint(*A):
for a in A: print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def gcd_list(A):
res = A[0]
for a in A:
res = gcd(a, res)
return res
def check(N,A):
if 1 in A:
if((sum(A)-N) & 1):
return 0 #先手
else:
return 1 #後手
odd_cnt, even_cnt = 0, 0
for a in A:
if(a&1):
odd_cnt += 1
else:
even_cnt += 1
if(even_cnt & 1):
return 0
else:
if(odd_cnt >= 2):
return 1
else: ##奇数のを選ぶしかないのでその後どうなるかを調べる
odd_idx = [i for i in range(N) if A[i]&1 ][0]
A[odd_idx] -= 1
G = gcd_list(A)
return check(N, [a//G for a in A]) ^ 1
def main():
N=I()
A=LI()
print(["First","Second"][check(N,A)])
if __name__ == '__main__':
main()
``` | output | 1 | 14,019 | 22 | 28,039 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N integers written on a blackboard. The i-th integer is A_i, and the greatest common divisor of these integers is 1.
Takahashi and Aoki will play a game using these integers. In this game, starting from Takahashi the two player alternately perform the following operation:
* Select one integer on the blackboard that is not less than 2, and subtract 1 from the integer.
* Then, divide all the integers on the black board by g, where g is the greatest common divisor of the integers written on the blackboard.
The player who is left with only 1s on the blackboard and thus cannot perform the operation, loses the game. Assuming that both players play optimally, determine the winner of the game.
Constraints
* 1 ≦ N ≦ 10^5
* 1 ≦ A_i ≦ 10^9
* The greatest common divisor of the integers from A_1 through A_N is 1.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
Output
If Takahashi will win, print `First`. If Aoki will win, print `Second`.
Examples
Input
3
3 6 7
Output
First
Input
4
1 2 4 8
Output
First
Input
5
7 8 8 8 8
Output
Second
Submitted Solution:
```
import random
def tester(N=0):
'''制約
1≦N≦105
1≦Ai≦109
'''
maxno1=1e5
maxno2=1e9
s=input()
if s!='':return(s)
if N==0:
return(random.randint(2,maxno1))
else:
print('Testing...')
print('N=',N)
A=[]
for i in range(N):
A.extend([random.randint(1,maxno2)])
return(' '.join(list(map(str,A))))
import copy
def gcd(a, b):
while b:
a, b = b, a % b
return a
def gcdm(x):
g=x[0]
for i in range(1,len(x)):
if g==1:
return(g)
g=gcd(g,x[i])
return(g)
def playmove(A,i):
A[i]-=1
g=gcdm(A)
return([x//g for x in A])
def noofevens(A):
r=0
for i in A:
if i%2==0:
r+=1
return(r)
N=int(tester())
A=[int(x) for x in tester(N).split()]
isFirstmove=True
while True:
e=noofevens(A)
if e%2==1:
if isFirstmove:
print('First')
else:
print('Second')
break
elif N-e>1:
if isFirstmove:
print('Second')
else:
print('First')
break
else:
for i in range(N):
if A[i]%2==1:
break
if A[i]==1:
if isFirstmove:
print('Second')
else:
print('First')
break
else:
A=playmove(A,i)
isFirstmove=(isFirstmove!=True)
``` | instruction | 0 | 14,020 | 22 | 28,040 |
Yes | output | 1 | 14,020 | 22 | 28,041 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N integers written on a blackboard. The i-th integer is A_i, and the greatest common divisor of these integers is 1.
Takahashi and Aoki will play a game using these integers. In this game, starting from Takahashi the two player alternately perform the following operation:
* Select one integer on the blackboard that is not less than 2, and subtract 1 from the integer.
* Then, divide all the integers on the black board by g, where g is the greatest common divisor of the integers written on the blackboard.
The player who is left with only 1s on the blackboard and thus cannot perform the operation, loses the game. Assuming that both players play optimally, determine the winner of the game.
Constraints
* 1 ≦ N ≦ 10^5
* 1 ≦ A_i ≦ 10^9
* The greatest common divisor of the integers from A_1 through A_N is 1.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
Output
If Takahashi will win, print `First`. If Aoki will win, print `Second`.
Examples
Input
3
3 6 7
Output
First
Input
4
1 2 4 8
Output
First
Input
5
7 8 8 8 8
Output
Second
Submitted Solution:
```
n = int(input())
x = list(map(int, input().split()))
j = 1
k=1
while j:
s=0
for i in range(n):
if x[i]%2 == 0:
x[i]/=2
s+=1
else:
x[i] = (x[i]-1)/2
if s != n-1:break
if s %2 != 0:
print("First")
else:
print("Second")
``` | instruction | 0 | 14,021 | 22 | 28,042 |
No | output | 1 | 14,021 | 22 | 28,043 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N integers written on a blackboard. The i-th integer is A_i, and the greatest common divisor of these integers is 1.
Takahashi and Aoki will play a game using these integers. In this game, starting from Takahashi the two player alternately perform the following operation:
* Select one integer on the blackboard that is not less than 2, and subtract 1 from the integer.
* Then, divide all the integers on the black board by g, where g is the greatest common divisor of the integers written on the blackboard.
The player who is left with only 1s on the blackboard and thus cannot perform the operation, loses the game. Assuming that both players play optimally, determine the winner of the game.
Constraints
* 1 ≦ N ≦ 10^5
* 1 ≦ A_i ≦ 10^9
* The greatest common divisor of the integers from A_1 through A_N is 1.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
Output
If Takahashi will win, print `First`. If Aoki will win, print `Second`.
Examples
Input
3
3 6 7
Output
First
Input
4
1 2 4 8
Output
First
Input
5
7 8 8 8 8
Output
Second
Submitted Solution:
```
import random
def tester(N=0):
'''制約
1≦N≦105
1≦Ai≦109
'''
maxno1=1e5
maxno2=1e9
s=input()
if s!='':return(s)
if N==0:
return(random.randint(2,maxno1))
else:
print('Testing...')
print('N=',N)
A=[]
for i in range(N):
A.extend([random.randint(1,maxno2)])
return(' '.join(list(map(str,A))))
import copy
def gcd(a, b):
while b:
a, b = b, a % b
return a
def gcdm(x):
g=x[0]
for i in range(1,len(x)):
if g==1:
return(g)
g=gcd(g,x[i])
return(g)
def playmove(A,i):
A[i]-=1
g=gcdm(A)
A=[x//g for x in A]
def noofevens(A):
r=0
for i in A:
if i%2==0:
r+=1
return(r)
N=int(tester())
A=[int(x) for x in tester(N).split()]
isFirstmove=True
while True:
e=noofevens(A)
if e%2==0:
if isFirstmove:
print('Second')
else:
print('First')
break
elif N-e>1:
if isFirstmove:
print('First')
else:
print('Second')
break
else:
for i in range(N):
if A[i]%2==1:
break
if A[i]==1:
if isFirstmove:
print('First')
else:
print('Second')
break
playmove(A,i)
isFirstmove=(isFirstmove!=True)
``` | instruction | 0 | 14,022 | 22 | 28,044 |
No | output | 1 | 14,022 | 22 | 28,045 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N integers written on a blackboard. The i-th integer is A_i, and the greatest common divisor of these integers is 1.
Takahashi and Aoki will play a game using these integers. In this game, starting from Takahashi the two player alternately perform the following operation:
* Select one integer on the blackboard that is not less than 2, and subtract 1 from the integer.
* Then, divide all the integers on the black board by g, where g is the greatest common divisor of the integers written on the blackboard.
The player who is left with only 1s on the blackboard and thus cannot perform the operation, loses the game. Assuming that both players play optimally, determine the winner of the game.
Constraints
* 1 ≦ N ≦ 10^5
* 1 ≦ A_i ≦ 10^9
* The greatest common divisor of the integers from A_1 through A_N is 1.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
Output
If Takahashi will win, print `First`. If Aoki will win, print `Second`.
Examples
Input
3
3 6 7
Output
First
Input
4
1 2 4 8
Output
First
Input
5
7 8 8 8 8
Output
Second
Submitted Solution:
```
n = int(input())
x = list(map(int, input().split()))
j = 1
k=1
while j:
s=0
if 1 in x:
s = sum(x)-n
break
for i in range(n):
if x[i]%2 == 0:
x[i]=x[i]//2
s+=1
else:
x[i] = (x[i]-1)//2
if s == n-1 and s%2==0:j = 1
else:j=0
if s %2 != 0:
print("First")
else:
print("Second")
``` | instruction | 0 | 14,023 | 22 | 28,046 |
No | output | 1 | 14,023 | 22 | 28,047 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N integers written on a blackboard. The i-th integer is A_i, and the greatest common divisor of these integers is 1.
Takahashi and Aoki will play a game using these integers. In this game, starting from Takahashi the two player alternately perform the following operation:
* Select one integer on the blackboard that is not less than 2, and subtract 1 from the integer.
* Then, divide all the integers on the black board by g, where g is the greatest common divisor of the integers written on the blackboard.
The player who is left with only 1s on the blackboard and thus cannot perform the operation, loses the game. Assuming that both players play optimally, determine the winner of the game.
Constraints
* 1 ≦ N ≦ 10^5
* 1 ≦ A_i ≦ 10^9
* The greatest common divisor of the integers from A_1 through A_N is 1.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
Output
If Takahashi will win, print `First`. If Aoki will win, print `Second`.
Examples
Input
3
3 6 7
Output
First
Input
4
1 2 4 8
Output
First
Input
5
7 8 8 8 8
Output
Second
Submitted Solution:
```
a = int(input())
x =list(map(int, input().split()))#x or y
x.sort()
c = x[0]
s = 0
for i in range(1,a):
s+=x[i]//c
if x[i]%c!=0:
s+=x[i]%c -1
if c !=1:s+=1
if s% 2 == 0:
print("First")
else:
print("Second")
``` | instruction | 0 | 14,024 | 22 | 28,048 |
No | output | 1 | 14,024 | 22 | 28,049 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the mathematician has a sequence consisting of n (n is divisible by 3) positive integers, each of them is at most 7. She wants to split the sequence into groups of three so that for each group of three a, b, c the following conditions held:
* a < b < c;
* a divides b, b divides c.
Naturally, Xenia wants each element of the sequence to belong to exactly one group of three. Thus, if the required partition exists, then it has <image> groups of three.
Help Xenia, find the required partition or else say that it doesn't exist.
Input
The first line contains integer n (3 ≤ n ≤ 99999) — the number of elements in the sequence. The next line contains n positive integers, each of them is at most 7.
It is guaranteed that n is divisible by 3.
Output
If the required partition exists, print <image> groups of three. Print each group as values of the elements it contains. You should print values in increasing order. Separate the groups and integers in groups by whitespaces. If there are multiple solutions, you can print any of them.
If there is no solution, print -1.
Examples
Input
6
1 1 1 2 2 2
Output
-1
Input
6
2 2 1 1 4 6
Output
1 2 4
1 2 6 | instruction | 0 | 14,518 | 22 | 29,036 |
Tags: greedy, implementation
Correct Solution:
```
n = int(input())
arr = list(map(int, input().split()))
track = [0] * 7
for i in arr:
track[i - 1] += 1
if(track[6] != 0 or track[4] != 0):
print(-1)
else:
c1 = track[0] == (track[3] + track[5])
if(c1):
_124 = track[3]
track[1] -= _124
if(track[1] >= 0):
#use remaining 2s on 126
_126 = track[1]
#subtract 126 pairings from 6
track[5] -= _126
if(track[5] == track[2]):
#works
_136 = track[2]
for i in range(_124):
print(1,2,4)
for i in range(_126):
print(1,2,6)
for i in range(_136):
print(1,3,6)
else:
print(-1)
else:
print(-1)
else:
print(-1)
``` | output | 1 | 14,518 | 22 | 29,037 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the mathematician has a sequence consisting of n (n is divisible by 3) positive integers, each of them is at most 7. She wants to split the sequence into groups of three so that for each group of three a, b, c the following conditions held:
* a < b < c;
* a divides b, b divides c.
Naturally, Xenia wants each element of the sequence to belong to exactly one group of three. Thus, if the required partition exists, then it has <image> groups of three.
Help Xenia, find the required partition or else say that it doesn't exist.
Input
The first line contains integer n (3 ≤ n ≤ 99999) — the number of elements in the sequence. The next line contains n positive integers, each of them is at most 7.
It is guaranteed that n is divisible by 3.
Output
If the required partition exists, print <image> groups of three. Print each group as values of the elements it contains. You should print values in increasing order. Separate the groups and integers in groups by whitespaces. If there are multiple solutions, you can print any of them.
If there is no solution, print -1.
Examples
Input
6
1 1 1 2 2 2
Output
-1
Input
6
2 2 1 1 4 6
Output
1 2 4
1 2 6 | instruction | 0 | 14,519 | 22 | 29,038 |
Tags: greedy, implementation
Correct Solution:
```
from collections import Counter
n=int(input())
arr=list(map(int,input().split()))
arr.append(2)
arr.append(3)
arr.append(4)
arr.append(6)
c=Counter(arr)
c[2]-=1
c[3]-=1
c[4]-=1
c[6]-=1
if c[1]!=n//3 or c[1]+c[2]+c[3]+c[4]+c[6]!=n:
print(-1)
else:
if c[4]>c[2]:
print(-1)
else:
if c[6]!=(-c[4]+c[2])+c[3]:
print(-1)
else:
for i in range(c[4]):
print(1,2,4)
c[2]-=c[4]
for i in range(c[2]):
print(1,2,6)
for i in range(c[3]):
print(1,3,6)
``` | output | 1 | 14,519 | 22 | 29,039 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the mathematician has a sequence consisting of n (n is divisible by 3) positive integers, each of them is at most 7. She wants to split the sequence into groups of three so that for each group of three a, b, c the following conditions held:
* a < b < c;
* a divides b, b divides c.
Naturally, Xenia wants each element of the sequence to belong to exactly one group of three. Thus, if the required partition exists, then it has <image> groups of three.
Help Xenia, find the required partition or else say that it doesn't exist.
Input
The first line contains integer n (3 ≤ n ≤ 99999) — the number of elements in the sequence. The next line contains n positive integers, each of them is at most 7.
It is guaranteed that n is divisible by 3.
Output
If the required partition exists, print <image> groups of three. Print each group as values of the elements it contains. You should print values in increasing order. Separate the groups and integers in groups by whitespaces. If there are multiple solutions, you can print any of them.
If there is no solution, print -1.
Examples
Input
6
1 1 1 2 2 2
Output
-1
Input
6
2 2 1 1 4 6
Output
1 2 4
1 2 6 | instruction | 0 | 14,520 | 22 | 29,040 |
Tags: greedy, implementation
Correct Solution:
```
n=int(input())
a,l,k=list(map(int,input().split())),[0]*5,n//3
for i in a:
if i==5or i==7:exit(print(-1))
elif i==3:l[4]+=1
else:l[i//2]+=1
if l[2]+l[3]!=k or l[0]!=k or l[4]+abs(l[1]-l[2])!=l[3]:print(-1)
else:exec("print(1,2,4);"*l[2]+"print(1,2,6);"*(l[1]-l[2])+"print(1,3,6);"*l[4])
``` | output | 1 | 14,520 | 22 | 29,041 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the mathematician has a sequence consisting of n (n is divisible by 3) positive integers, each of them is at most 7. She wants to split the sequence into groups of three so that for each group of three a, b, c the following conditions held:
* a < b < c;
* a divides b, b divides c.
Naturally, Xenia wants each element of the sequence to belong to exactly one group of three. Thus, if the required partition exists, then it has <image> groups of three.
Help Xenia, find the required partition or else say that it doesn't exist.
Input
The first line contains integer n (3 ≤ n ≤ 99999) — the number of elements in the sequence. The next line contains n positive integers, each of them is at most 7.
It is guaranteed that n is divisible by 3.
Output
If the required partition exists, print <image> groups of three. Print each group as values of the elements it contains. You should print values in increasing order. Separate the groups and integers in groups by whitespaces. If there are multiple solutions, you can print any of them.
If there is no solution, print -1.
Examples
Input
6
1 1 1 2 2 2
Output
-1
Input
6
2 2 1 1 4 6
Output
1 2 4
1 2 6 | instruction | 0 | 14,521 | 22 | 29,042 |
Tags: greedy, implementation
Correct Solution:
```
n=int(input())
arr=list(map(int,input().split()))
arr.sort()
t=0
ans=[]
boo=True
for i in range(0,n//3):
a=[]
a.append(arr[i])
if arr[i+n//3]>arr[i] and arr[i+n//3]%arr[i]==0:
a.append(arr[i+n//3])
else:
print(-1)
boo=False
break
if arr[i+n//3+n//3]>arr[i+n//3] and arr[i+n//3+n//3]%arr[i+n//3]==0:
a.append(arr[i+n//3+n//3])
else:
print(-1)
boo=False
break
ans.append(a)
if boo:
for i in ans:
for j in i:
print(j,end=' ')
print()
``` | output | 1 | 14,521 | 22 | 29,043 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the mathematician has a sequence consisting of n (n is divisible by 3) positive integers, each of them is at most 7. She wants to split the sequence into groups of three so that for each group of three a, b, c the following conditions held:
* a < b < c;
* a divides b, b divides c.
Naturally, Xenia wants each element of the sequence to belong to exactly one group of three. Thus, if the required partition exists, then it has <image> groups of three.
Help Xenia, find the required partition or else say that it doesn't exist.
Input
The first line contains integer n (3 ≤ n ≤ 99999) — the number of elements in the sequence. The next line contains n positive integers, each of them is at most 7.
It is guaranteed that n is divisible by 3.
Output
If the required partition exists, print <image> groups of three. Print each group as values of the elements it contains. You should print values in increasing order. Separate the groups and integers in groups by whitespaces. If there are multiple solutions, you can print any of them.
If there is no solution, print -1.
Examples
Input
6
1 1 1 2 2 2
Output
-1
Input
6
2 2 1 1 4 6
Output
1 2 4
1 2 6 | instruction | 0 | 14,522 | 22 | 29,044 |
Tags: greedy, implementation
Correct Solution:
```
n = int( input() )
a = list( map( int, input().split() ) )
cnt = [0]*8
for i in a:
cnt[i] += 1
p = []
k = 7
if cnt[5] > 0 or cnt[7] > 0 or (cnt[1]*3!=n):
print(-1)
exit(0)
#1 3 6
#1 2 4
#1 2 6
if cnt[6] > 0 and cnt[3] > 0:
for i in range( cnt[3] ):
p.append( [1,3,6] )
cnt[1] -= 1
cnt[3] -= 1
cnt[6] -= 1
if cnt[6] > 0 and cnt[2] > 0:
for i in range( cnt[6] ):
p.append( [1,2,6] )
cnt[1] -= 1
cnt[2] -= 1
cnt[6] -= 1
if cnt[4] > 0 and cnt[2] > 0:
for i in range( cnt[4] ):
p.append( [1,2,4] )
cnt[1] -= 1
cnt[2] -= 1
cnt[4] -= 1
#print(p)
if sum(cnt) != 0:
print( -1 )
exit(0)
for i in p:
for j in sorted(i):
print( j, end=' ' )
print()
``` | output | 1 | 14,522 | 22 | 29,045 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the mathematician has a sequence consisting of n (n is divisible by 3) positive integers, each of them is at most 7. She wants to split the sequence into groups of three so that for each group of three a, b, c the following conditions held:
* a < b < c;
* a divides b, b divides c.
Naturally, Xenia wants each element of the sequence to belong to exactly one group of three. Thus, if the required partition exists, then it has <image> groups of three.
Help Xenia, find the required partition or else say that it doesn't exist.
Input
The first line contains integer n (3 ≤ n ≤ 99999) — the number of elements in the sequence. The next line contains n positive integers, each of them is at most 7.
It is guaranteed that n is divisible by 3.
Output
If the required partition exists, print <image> groups of three. Print each group as values of the elements it contains. You should print values in increasing order. Separate the groups and integers in groups by whitespaces. If there are multiple solutions, you can print any of them.
If there is no solution, print -1.
Examples
Input
6
1 1 1 2 2 2
Output
-1
Input
6
2 2 1 1 4 6
Output
1 2 4
1 2 6 | instruction | 0 | 14,523 | 22 | 29,046 |
Tags: greedy, implementation
Correct Solution:
```
# It's all about what U BELIEVE
def gint(): return int(input())
def gint_arr(): return list(map(int, input().split()))
def gfloat(): return float(input())
def gfloat_arr(): return list(map(float, input().split()))
def pair_int(): return map(int, input().split())
###############################################################################
INF = (1 << 31)
dx = [-1, 0, 1, 0]
dy = [ 0, 1, 0, -1]
###############################################################################
############################ SOLUTION IS COMING ###############################
###############################################################################
n = gint()
a = gint_arr()
if 5 in a or 7 in a:
print(-1)
exit()
cnt = {}
for i in range(1, 7):
cnt[i] = a.count(i)
res = []
fail = False
while sum(cnt.values()) and not fail:
seq = []
if not cnt[1]:
fail = True
break
else:
seq.append(1)
cnt[1] -= 1
if not cnt[2] and not cnt[3]:
fail = True
elif cnt[2]:
seq.append(2)
cnt[2] -= 1
if not cnt[4]:
if not cnt[6]:
fail = True
else:
seq.append(6)
cnt[6] -= 1
else:
seq.append(4)
cnt[4] -= 1
else:
seq.append(3)
cnt[3] -= 1
if not cnt[6]:
fail = True
else:
seq.append(6)
cnt[6] -= 1
if len(seq) != 3:
fail = True
else:
res.append(seq)
if fail:
print(-1)
else:
for i in res:
print(*i)
``` | output | 1 | 14,523 | 22 | 29,047 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the mathematician has a sequence consisting of n (n is divisible by 3) positive integers, each of them is at most 7. She wants to split the sequence into groups of three so that for each group of three a, b, c the following conditions held:
* a < b < c;
* a divides b, b divides c.
Naturally, Xenia wants each element of the sequence to belong to exactly one group of three. Thus, if the required partition exists, then it has <image> groups of three.
Help Xenia, find the required partition or else say that it doesn't exist.
Input
The first line contains integer n (3 ≤ n ≤ 99999) — the number of elements in the sequence. The next line contains n positive integers, each of them is at most 7.
It is guaranteed that n is divisible by 3.
Output
If the required partition exists, print <image> groups of three. Print each group as values of the elements it contains. You should print values in increasing order. Separate the groups and integers in groups by whitespaces. If there are multiple solutions, you can print any of them.
If there is no solution, print -1.
Examples
Input
6
1 1 1 2 2 2
Output
-1
Input
6
2 2 1 1 4 6
Output
1 2 4
1 2 6 | instruction | 0 | 14,524 | 22 | 29,048 |
Tags: greedy, implementation
Correct Solution:
```
n=int(input())
A=list(map(int,input().split()))
A.sort()
D=[]
Diff=n//3
Bool=False
for val in range(Diff):
if A[val] < A[val+Diff] and A[val+Diff] < A[val+2*Diff]:
if A[val+Diff]%A[val] == 0 and A[val+2*Diff]%A[val+Diff] == 0:
pass
else:
Bool=True
break
else:
Bool=True
break
if Bool == True:
print(-1)
else:
for val in range(Diff):
print(A[val],A[val+Diff],A[val+2*Diff])
``` | output | 1 | 14,524 | 22 | 29,049 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the mathematician has a sequence consisting of n (n is divisible by 3) positive integers, each of them is at most 7. She wants to split the sequence into groups of three so that for each group of three a, b, c the following conditions held:
* a < b < c;
* a divides b, b divides c.
Naturally, Xenia wants each element of the sequence to belong to exactly one group of three. Thus, if the required partition exists, then it has <image> groups of three.
Help Xenia, find the required partition or else say that it doesn't exist.
Input
The first line contains integer n (3 ≤ n ≤ 99999) — the number of elements in the sequence. The next line contains n positive integers, each of them is at most 7.
It is guaranteed that n is divisible by 3.
Output
If the required partition exists, print <image> groups of three. Print each group as values of the elements it contains. You should print values in increasing order. Separate the groups and integers in groups by whitespaces. If there are multiple solutions, you can print any of them.
If there is no solution, print -1.
Examples
Input
6
1 1 1 2 2 2
Output
-1
Input
6
2 2 1 1 4 6
Output
1 2 4
1 2 6 | instruction | 0 | 14,525 | 22 | 29,050 |
Tags: greedy, implementation
Correct Solution:
```
n= int(input())
#val= list(map(int,input().split()))
ans=[0]*8
for i in map(int,input().split()):
ans[i]+=1
grp=n//3
if ans[1]==grp and (ans[2]+ans[3])==grp and (ans[4]+ans[6])==grp and ans[3]<=ans[6]:
print('1 2 4\n'*ans[4]+ '1 2 6\n'*(ans[6]-ans[3]) + '1 3 6\n'*(ans[3]))
else:
print(-1)
``` | output | 1 | 14,525 | 22 | 29,051 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Xenia the mathematician has a sequence consisting of n (n is divisible by 3) positive integers, each of them is at most 7. She wants to split the sequence into groups of three so that for each group of three a, b, c the following conditions held:
* a < b < c;
* a divides b, b divides c.
Naturally, Xenia wants each element of the sequence to belong to exactly one group of three. Thus, if the required partition exists, then it has <image> groups of three.
Help Xenia, find the required partition or else say that it doesn't exist.
Input
The first line contains integer n (3 ≤ n ≤ 99999) — the number of elements in the sequence. The next line contains n positive integers, each of them is at most 7.
It is guaranteed that n is divisible by 3.
Output
If the required partition exists, print <image> groups of three. Print each group as values of the elements it contains. You should print values in increasing order. Separate the groups and integers in groups by whitespaces. If there are multiple solutions, you can print any of them.
If there is no solution, print -1.
Examples
Input
6
1 1 1 2 2 2
Output
-1
Input
6
2 2 1 1 4 6
Output
1 2 4
1 2 6
Submitted Solution:
```
import sys,os,io,time,copy
if os.path.exists('input.txt'):
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
import math
n=int(input())
arr=list(map(int,input().split()))
dic={1:0,2:0,3:0,4:0,5:0,6:0,7:0}
for a in arr:
dic[a]+=1
x=min(dic[1],dic[2],dic[4])
dic[1]-=x
dic[2]-=x
dic[4]-=x
y=min(dic[1],dic[2],dic[6])
dic[1]-=y
dic[2]-=y
dic[6]-=y
z=min(dic[1],dic[3],dic[6])
dic[1]-=z
dic[3]-=z
dic[6]-=z
flag=0
for d in dic:
if dic[d]!=0:
flag=1
if flag==0:
for i in range(x):
print("1 2 4")
for i in range(y):
print("1 2 6")
for i in range(z):
print("1 3 6")
else:
print(-1)
``` | instruction | 0 | 14,526 | 22 | 29,052 |
Yes | output | 1 | 14,526 | 22 | 29,053 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Xenia the mathematician has a sequence consisting of n (n is divisible by 3) positive integers, each of them is at most 7. She wants to split the sequence into groups of three so that for each group of three a, b, c the following conditions held:
* a < b < c;
* a divides b, b divides c.
Naturally, Xenia wants each element of the sequence to belong to exactly one group of three. Thus, if the required partition exists, then it has <image> groups of three.
Help Xenia, find the required partition or else say that it doesn't exist.
Input
The first line contains integer n (3 ≤ n ≤ 99999) — the number of elements in the sequence. The next line contains n positive integers, each of them is at most 7.
It is guaranteed that n is divisible by 3.
Output
If the required partition exists, print <image> groups of three. Print each group as values of the elements it contains. You should print values in increasing order. Separate the groups and integers in groups by whitespaces. If there are multiple solutions, you can print any of them.
If there is no solution, print -1.
Examples
Input
6
1 1 1 2 2 2
Output
-1
Input
6
2 2 1 1 4 6
Output
1 2 4
1 2 6
Submitted Solution:
```
import io, os
import sys
from atexit import register
from collections import Counter
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
sys.stdout = io.BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))
tokens = []
tokens_next = 0
def nextStr():
global tokens, tokens_next
while tokens_next >= len(tokens):
tokens = input().split()
tokens_next = 0
tokens_next += 1
return tokens[tokens_next - 1]
def nextInt():
return int(nextStr())
def nextIntArr(n):
return [nextInt() for i in range(n)]
def print(s, end='\n'):
sys.stdout.write((str(s) + end).encode())
n = nextInt()
a = nextIntArr(n)
cnt = Counter(a)
res = []
for comb in [[1, 3, 6], [1, 2, 4], [1, 2, 6]]:
cur = zip(*[[i] * cnt[i] for i in comb])
cur = list(cur)
for i in comb:
cnt[i] -= len(cur)
res.extend(cur)
if list(cnt.elements()):
print(-1)
exit(0)
for i in res:
print(' '.join(map(str, i)))
``` | instruction | 0 | 14,527 | 22 | 29,054 |
Yes | output | 1 | 14,527 | 22 | 29,055 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Xenia the mathematician has a sequence consisting of n (n is divisible by 3) positive integers, each of them is at most 7. She wants to split the sequence into groups of three so that for each group of three a, b, c the following conditions held:
* a < b < c;
* a divides b, b divides c.
Naturally, Xenia wants each element of the sequence to belong to exactly one group of three. Thus, if the required partition exists, then it has <image> groups of three.
Help Xenia, find the required partition or else say that it doesn't exist.
Input
The first line contains integer n (3 ≤ n ≤ 99999) — the number of elements in the sequence. The next line contains n positive integers, each of them is at most 7.
It is guaranteed that n is divisible by 3.
Output
If the required partition exists, print <image> groups of three. Print each group as values of the elements it contains. You should print values in increasing order. Separate the groups and integers in groups by whitespaces. If there are multiple solutions, you can print any of them.
If there is no solution, print -1.
Examples
Input
6
1 1 1 2 2 2
Output
-1
Input
6
2 2 1 1 4 6
Output
1 2 4
1 2 6
Submitted Solution:
```
#------------------------------what is this I don't know....just makes my mess faster--------------------------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#----------------------------------Real game starts here--------------------------------------
'''
___________________THIS IS AESTROIX CODE________________________
KARMANYA GUPTA
'''
#_______________________________________________________________#
def fact(x):
if x == 0:
return 1
else:
return x * fact(x-1)
def lower_bound(li, num): #return 0 if all are greater or equal to
answer = -1
start = 0
end = len(li)-1
while(start <= end):
middle = (end+start)//2
if li[middle] >= num:
answer = middle
end = middle - 1
else:
start = middle + 1
return answer #index where x is not less than num
def upper_bound(li, num): #return n-1 if all are small or equal
answer = -1
start = 0
end = len(li)-1
while(start <= end):
middle = (end+start)//2
if li[middle] <= num:
answer = middle
start = middle + 1
else:
end = middle - 1
return answer #index where x is not greater than num
def abs(x):
return x if x >=0 else -x
def binary_search(li, val, lb, ub):
ans = 0
while(lb <= ub):
mid = (lb+ub)//2
#print(mid, li[mid])
if li[mid] > val:
ub = mid-1
elif val > li[mid]:
lb = mid + 1
else:
ans = 1
break
return ans
#_______________________________________________________________#
for _ in range(1):
cnt = dict()
ans = []
for i in range(1,8):
cnt.setdefault(i,0)
n = int(input())
nums = list(map(int, input().split()))
for i in nums:
cnt[i] += 1
if cnt[5] != 0 or cnt[7] != 0:
print(-1)
break
while(cnt[3] > 0):
ans.append((1,3,6))
cnt[1] -= 1
cnt[3] -= 1
cnt[6] -= 1
while(cnt[4] > 0):
ans.append((1,2,4))
cnt[1] -= 1
cnt[2] -= 1
cnt[4] -= 1
while(cnt[6] > 0):
ans.append((1,2,6))
cnt[2] -= 1
cnt[1] -= 1
cnt[6] -= 1
flag = 1
for num,val in cnt.items():
if val != 0:
flag = 0
break
if flag == 0:
print(-1)
else:
for i in range(len(ans)):
print(ans[i][0], ans[i][1], ans[i][2])
``` | instruction | 0 | 14,528 | 22 | 29,056 |
Yes | output | 1 | 14,528 | 22 | 29,057 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Xenia the mathematician has a sequence consisting of n (n is divisible by 3) positive integers, each of them is at most 7. She wants to split the sequence into groups of three so that for each group of three a, b, c the following conditions held:
* a < b < c;
* a divides b, b divides c.
Naturally, Xenia wants each element of the sequence to belong to exactly one group of three. Thus, if the required partition exists, then it has <image> groups of three.
Help Xenia, find the required partition or else say that it doesn't exist.
Input
The first line contains integer n (3 ≤ n ≤ 99999) — the number of elements in the sequence. The next line contains n positive integers, each of them is at most 7.
It is guaranteed that n is divisible by 3.
Output
If the required partition exists, print <image> groups of three. Print each group as values of the elements it contains. You should print values in increasing order. Separate the groups and integers in groups by whitespaces. If there are multiple solutions, you can print any of them.
If there is no solution, print -1.
Examples
Input
6
1 1 1 2 2 2
Output
-1
Input
6
2 2 1 1 4 6
Output
1 2 4
1 2 6
Submitted Solution:
```
import sys
from math import *
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return map(int, minp().split())
n = mint()
c = [0]*10
for i in mints():
c[i] += 1
if n // 3 == c[1] and c[0] == 0 and c[5] == 0 and c[7] == 0 \
and c[6] - c[3] == c[2] - c[4] and c[2] - c[4] >= 0:
for i in range(c[4]):
print(1,2,4)
for i in range(c[2]-c[4]):
print(1,2,6)
for i in range(c[3]):
print(1,3,6)
else:
print(-1)
``` | instruction | 0 | 14,529 | 22 | 29,058 |
Yes | output | 1 | 14,529 | 22 | 29,059 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Xenia the mathematician has a sequence consisting of n (n is divisible by 3) positive integers, each of them is at most 7. She wants to split the sequence into groups of three so that for each group of three a, b, c the following conditions held:
* a < b < c;
* a divides b, b divides c.
Naturally, Xenia wants each element of the sequence to belong to exactly one group of three. Thus, if the required partition exists, then it has <image> groups of three.
Help Xenia, find the required partition or else say that it doesn't exist.
Input
The first line contains integer n (3 ≤ n ≤ 99999) — the number of elements in the sequence. The next line contains n positive integers, each of them is at most 7.
It is guaranteed that n is divisible by 3.
Output
If the required partition exists, print <image> groups of three. Print each group as values of the elements it contains. You should print values in increasing order. Separate the groups and integers in groups by whitespaces. If there are multiple solutions, you can print any of them.
If there is no solution, print -1.
Examples
Input
6
1 1 1 2 2 2
Output
-1
Input
6
2 2 1 1 4 6
Output
1 2 4
1 2 6
Submitted Solution:
```
import io, os
import sys
from atexit import register
from collections import Counter
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
sys.stdout = io.BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))
tokens = []
tokens_next = 0
def nextStr():
global tokens, tokens_next
while tokens_next >= len(tokens):
tokens = input().split()
tokens_next = 0
tokens_next += 1
return tokens[tokens_next - 1]
def nextInt():
return int(nextStr())
def nextIntArr(n):
return [nextInt() for i in range(n)]
def print(s, end='\n'):
sys.stdout.write((str(s) + end).encode())
n = nextInt()
a = nextIntArr(n)
cnt = Counter(a)
if cnt[5] or cnt[7]:
print(-1)
exit(0)
res = []
res.extend(zip([1] * cnt[1], [3] * cnt[3], [6] * cnt[6]))
cnt[1] -= len(res)
cnt[3] -= len(res)
cnt[6] -= len(res)
res.extend(zip([1] * cnt[1], [2] * cnt[2], [4] * cnt[4]))
cnt[1] -= len(res)
cnt[2] -= len(res)
cnt[4] -= len(res)
res.extend(zip([1] * cnt[1], [2] * cnt[2], [6] * cnt[6]))
cnt[1] -= len(res)
cnt[2] -= len(res)
cnt[6] -= len(res)
if list(cnt.elements()):
print(-1)
exit(0)
for i in res:
print(' '.join(map(str, i)))
``` | instruction | 0 | 14,530 | 22 | 29,060 |
No | output | 1 | 14,530 | 22 | 29,061 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Xenia the mathematician has a sequence consisting of n (n is divisible by 3) positive integers, each of them is at most 7. She wants to split the sequence into groups of three so that for each group of three a, b, c the following conditions held:
* a < b < c;
* a divides b, b divides c.
Naturally, Xenia wants each element of the sequence to belong to exactly one group of three. Thus, if the required partition exists, then it has <image> groups of three.
Help Xenia, find the required partition or else say that it doesn't exist.
Input
The first line contains integer n (3 ≤ n ≤ 99999) — the number of elements in the sequence. The next line contains n positive integers, each of them is at most 7.
It is guaranteed that n is divisible by 3.
Output
If the required partition exists, print <image> groups of three. Print each group as values of the elements it contains. You should print values in increasing order. Separate the groups and integers in groups by whitespaces. If there are multiple solutions, you can print any of them.
If there is no solution, print -1.
Examples
Input
6
1 1 1 2 2 2
Output
-1
Input
6
2 2 1 1 4 6
Output
1 2 4
1 2 6
Submitted Solution:
```
n = int(input())
a = list(map(int,input().split()))
c = [0]*8
for i in a:
c[i]+=1
if c[5] or c[7]:
print(-1)
exit(0)
t1 = c[3]
c[3] = 0
c[1] -= t1
c[6] -= t1
t2 = c[6]
c[1] -= t2
c[6] = 0
c[2] -= t2
t3 = c[4]
c[4] = 0
c[2] -= t3
c[1] -= t3
if c.count(0) != 8:
print(-1)
else:
for i in range(t1):
print('1 3 6')
for i in range(t2):
print('1 2 6')
for i in range(t3):
print('1 2 4')
``` | instruction | 0 | 14,531 | 22 | 29,062 |
No | output | 1 | 14,531 | 22 | 29,063 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Xenia the mathematician has a sequence consisting of n (n is divisible by 3) positive integers, each of them is at most 7. She wants to split the sequence into groups of three so that for each group of three a, b, c the following conditions held:
* a < b < c;
* a divides b, b divides c.
Naturally, Xenia wants each element of the sequence to belong to exactly one group of three. Thus, if the required partition exists, then it has <image> groups of three.
Help Xenia, find the required partition or else say that it doesn't exist.
Input
The first line contains integer n (3 ≤ n ≤ 99999) — the number of elements in the sequence. The next line contains n positive integers, each of them is at most 7.
It is guaranteed that n is divisible by 3.
Output
If the required partition exists, print <image> groups of three. Print each group as values of the elements it contains. You should print values in increasing order. Separate the groups and integers in groups by whitespaces. If there are multiple solutions, you can print any of them.
If there is no solution, print -1.
Examples
Input
6
1 1 1 2 2 2
Output
-1
Input
6
2 2 1 1 4 6
Output
1 2 4
1 2 6
Submitted Solution:
```
n=int(input())
l=list(map(int,input().split()))
d={}
error=0
l.sort()
for i in l:
if i==5 or i==7:
error+=1
if i not in d:
d[i]=0
d[i]+=1
if l.count(1)!=int(n/3) or l.count(2)+l.count(3)!=int(n/3) or len(d)<3 or error>0 or (l.count(3)>0 and l.count(3)!=l.count(6)):
print("-1")
else:
for i in range(int(n/3)):
for j in range(i,n,int(n/3)):
print(l[j],end=" ")
print()
``` | instruction | 0 | 14,532 | 22 | 29,064 |
No | output | 1 | 14,532 | 22 | 29,065 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Xenia the mathematician has a sequence consisting of n (n is divisible by 3) positive integers, each of them is at most 7. She wants to split the sequence into groups of three so that for each group of three a, b, c the following conditions held:
* a < b < c;
* a divides b, b divides c.
Naturally, Xenia wants each element of the sequence to belong to exactly one group of three. Thus, if the required partition exists, then it has <image> groups of three.
Help Xenia, find the required partition or else say that it doesn't exist.
Input
The first line contains integer n (3 ≤ n ≤ 99999) — the number of elements in the sequence. The next line contains n positive integers, each of them is at most 7.
It is guaranteed that n is divisible by 3.
Output
If the required partition exists, print <image> groups of three. Print each group as values of the elements it contains. You should print values in increasing order. Separate the groups and integers in groups by whitespaces. If there are multiple solutions, you can print any of them.
If there is no solution, print -1.
Examples
Input
6
1 1 1 2 2 2
Output
-1
Input
6
2 2 1 1 4 6
Output
1 2 4
1 2 6
Submitted Solution:
```
n=int(input())
z=list(map(int,input().split()))
o1=z.count(1)
o2=z.count(2)
o3=z.count(3)
o4=z.count(4)
o6=z.count(6)
if(5 in z or 7 in z):
print(-1)
else:
k1=[1,2,4]
k2=[1,3,6]
k3=[1,2,6]
p=min(o1,o2,o4)
k1=k1*p
o1=o1-p
o2=o2-p
o4=o4-p
p1=min(o1,o2,o6)
k3=k3*p1
o1-=1
o2-=1
o6-=1
p2=min(o1,o3,o6)
k2=k2*p2
o1-=1
o3-=1
o6-=1
if(len(k1)+len(k2)+len(k3)==n):
if(len(k1)!=0):
print(*k1)
if(len(k2)!=0):
print(*k2)
if(len(k3)!=0):
print(*k3)
else:
print(-1)
``` | instruction | 0 | 14,533 | 22 | 29,066 |
No | output | 1 | 14,533 | 22 | 29,067 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two positive integers are coprime if and only if they don't have a common divisor greater than 1.
Some bear doesn't want to tell Radewoosh how to solve some algorithmic problem. So, Radewoosh is going to break into that bear's safe with solutions. To pass through the door, he must enter a permutation of numbers 1 through n. The door opens if and only if an entered permutation p1, p2, ..., pn satisfies:
<image>
In other words, two different elements are coprime if and only if their indices are coprime.
Some elements of a permutation may be already fixed. In how many ways can Radewoosh fill the remaining gaps so that the door will open? Print the answer modulo 109 + 7.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 1 000 000).
The second line contains n integers p1, p2, ..., pn (0 ≤ pi ≤ n) where pi = 0 means a gap to fill, and pi ≥ 1 means a fixed number.
It's guaranteed that if i ≠ j and pi, pj ≥ 1 then pi ≠ pj.
Output
Print the number of ways to fill the gaps modulo 109 + 7 (i.e. modulo 1000000007).
Examples
Input
4
0 0 0 0
Output
4
Input
5
0 0 1 2 0
Output
2
Input
6
0 0 1 2 0 0
Output
0
Input
5
5 3 4 2 1
Output
0
Note
In the first sample test, none of four element is fixed. There are four permutations satisfying the given conditions: (1,2,3,4), (1,4,3,2), (3,2,1,4), (3,4,1,2).
In the second sample test, there must be p3 = 1 and p4 = 2. The two permutations satisfying the conditions are: (3,4,1,2,5), (5,4,1,2,3).
Submitted Solution:
```
n = int(input())
p = list(map(int,input().split()))
MOD = 1000000007
if n <= 5:
from itertools import permutations
from math import gcd
ans = 0
for perm in permutations(range(1,n + 1),n):
flag = True
for i in range(n):
if p[i] != perm[i] and p[i] != 0:
flag = False
break
for i in range(n):
for j in range(n):
if i == j:
continue
if (gcd(perm[i],perm[j]) == 1 and gcd(i + 1,j + 1) != 1) or (gcd(perm[i],perm[j]) != 1 and gcd(i + 1,j + 1) == 1):
flag = False
if flag:
ans += 1
print(ans)
else:
def prime_sieve(n):
"""returns a sieve of primes >= 5 and < n"""
flag = n % 6 == 2
sieve = bytearray((n // 3 + flag >> 3) + 1)
for i in range(1, int(n**0.5) // 3 + 1):
if not (sieve[i >> 3] >> (i & 7)) & 1:
k = (3 * i + 1) | 1
for j in range(k * k // 3, n // 3 + flag, 2 * k):
sieve[j >> 3] |= 1 << (j & 7)
for j in range(k * (k - 2 * (i & 1) + 4) // 3, n // 3 + flag, 2 * k):
sieve[j >> 3] |= 1 << (j & 7)
return sieve
def prime_list(n):
"""returns a list of primes <= n"""
res = []
if n > 1:
res.append(2)
if n > 2:
res.append(3)
if n > 4:
sieve = prime_sieve(n + 1)
res.extend(3 * i + 1 | 1 for i in range(1, (n + 1) // 3 + (n % 6 == 1)) if not (sieve[i >> 3] >> (i & 7)) & 1)
return res
pList = prime_list(n)
largePand1 = [False] * n
largePand1[0] = True
largePand1Cnt = 1
for elem in pList:
if elem > n // 2:
largePand1[elem - 1] = True
largePand1Cnt += 1
flag = True
fixed = 0
for i in range(n):
if p[i] == 0:
continue
else:
if largePand1[i - 1]:
fixed += 1
elif i + 1 == p[i]:
pass
else:
flag = False
if not flag:
print(0)
else:
ans = 1
for i in range(1,largePand1Cnt - fixed + 1):
ans *= i
ans %= MOD
print(ans)
``` | instruction | 0 | 14,656 | 22 | 29,312 |
No | output | 1 | 14,656 | 22 | 29,313 |
Provide a correct Python 3 solution for this coding contest problem.
Given is an integer N. Find the minimum possible positive integer k such that (1+2+\cdots+k) is a multiple of N. It can be proved that such a positive integer k always exists.
Constraints
* 1 \leq N \leq 10^{15}
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer in a line.
Examples
Input
11
Output
10
Input
20200920
Output
1100144 | instruction | 0 | 14,759 | 22 | 29,518 |
"Correct Solution:
```
from collections import Counter
# 拡張ユークリッド互除法
# gcd(a,b) と ax + by = gcd(a,b) の最小整数解を返す
def egcd(a, b):
if a == 0:
return b, 0, 1
else:
g, y, x = egcd(b % a, a)
return g, x - (b // a) * y, y
def chineseRem(b1, m1, b2, m2):
# 中国剰余定理
# x ≡ b1 (mod m1) ∧ x ≡ b2 (mod m2) <=> x ≡ r (mod m)
# となる(r. m)を返す
# 解無しのとき(0, -1)
d, p, q = egcd(m1, m2)
if (b2 - b1) % d != 0:
return 0, -1
m = m1 * (m2 // d) # m = lcm(m1, m2)
tmp = (b2-b1) // d * p % (m2 // d)
r = (b1 + m1 * tmp) % m
return r, m
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
N = int(input())
p = prime_factorize(2*N)
c = Counter(p)
if N == 1:
print(1)
exit()
if len(c.keys()) == 1:
print(N-1)
exit()
d = [k ** v for k, v in c.items()]
m = len(d)
ans = N-1
for i in range(2 ** m):
a, b = 1, 1
for j in range(m):
if (i >> j) & 1:
a *= d[j]
else:
b *= d[j]
if a == 1 or b == 1:
continue
ans = min(ans, chineseRem(0, a, b-1, b)[0])
ans = min(ans, chineseRem(a-1, a, 0, b)[0])
print(ans)
``` | output | 1 | 14,759 | 22 | 29,519 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.