message stringlengths 2 57.2k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 61 108k | cluster float64 22 22 | __index_level_0__ int64 122 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Holmes children are fighting over who amongst them is the cleverest.
Mycroft asked Sherlock and Eurus to find value of f(n), where f(1) = 1 and for n ≥ 2, f(n) is the number of distinct ordered positive integer pairs (x, y) that satisfy x + y = n and gcd(x, y) = 1. The integer gcd(a, b) is the greatest common divisor of a and b.
Sherlock said that solving this was child's play and asked Mycroft to instead get the value of <image>. Summation is done over all positive integers d that divide n.
Eurus was quietly observing all this and finally came up with her problem to astonish both Sherlock and Mycroft.
She defined a k-composite function Fk(n) recursively as follows:
<image>
She wants them to tell the value of Fk(n) modulo 1000000007.
Input
A single line of input contains two space separated integers n (1 ≤ n ≤ 1012) and k (1 ≤ k ≤ 1012) indicating that Eurus asks Sherlock and Mycroft to find the value of Fk(n) modulo 1000000007.
Output
Output a single integer — the value of Fk(n) modulo 1000000007.
Examples
Input
7 1
Output
6
Input
10 2
Output
4
Note
In the first case, there are 6 distinct ordered pairs (1, 6), (2, 5), (3, 4), (4, 3), (5, 2) and (6, 1) satisfying x + y = 7 and gcd(x, y) = 1. Hence, f(7) = 6. So, F1(7) = f(g(7)) = f(f(7) + f(1)) = f(6 + 1) = f(7) = 6.
Submitted Solution:
```
import math
def phi(n):
res = n
for i in range(2, int(math.sqrt(n)) + 1):
if(n % i == 0):
while n % i == 0:
n /= i
res -= res/i
if(n>1):
res -= 1
return int(res)
def F(n, k):
k = int((k + 1)/2)
res = n
while k != 0:
res = phi(res)
if res == 1:
break
k -=1
return int(res % (10 ** 9 + 7))
n, k = [int(i) for i in input().split(' ')]
print(F(n, k))
``` | instruction | 0 | 20,824 | 22 | 41,648 |
No | output | 1 | 20,824 | 22 | 41,649 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Holmes children are fighting over who amongst them is the cleverest.
Mycroft asked Sherlock and Eurus to find value of f(n), where f(1) = 1 and for n ≥ 2, f(n) is the number of distinct ordered positive integer pairs (x, y) that satisfy x + y = n and gcd(x, y) = 1. The integer gcd(a, b) is the greatest common divisor of a and b.
Sherlock said that solving this was child's play and asked Mycroft to instead get the value of <image>. Summation is done over all positive integers d that divide n.
Eurus was quietly observing all this and finally came up with her problem to astonish both Sherlock and Mycroft.
She defined a k-composite function Fk(n) recursively as follows:
<image>
She wants them to tell the value of Fk(n) modulo 1000000007.
Input
A single line of input contains two space separated integers n (1 ≤ n ≤ 1012) and k (1 ≤ k ≤ 1012) indicating that Eurus asks Sherlock and Mycroft to find the value of Fk(n) modulo 1000000007.
Output
Output a single integer — the value of Fk(n) modulo 1000000007.
Examples
Input
7 1
Output
6
Input
10 2
Output
4
Note
In the first case, there are 6 distinct ordered pairs (1, 6), (2, 5), (3, 4), (4, 3), (5, 2) and (6, 1) satisfying x + y = 7 and gcd(x, y) = 1. Hence, f(7) = 6. So, F1(7) = f(g(7)) = f(f(7) + f(1)) = f(6 + 1) = f(7) = 6.
Submitted Solution:
```
import fractions
import math
def phi(n):
amount = 0
for k in range(1, n + 1):
if fractions.gcd(n, k) == 1:
amount += 1
return amount
n,k=map(int,input().split())
num=int(math.log(k))+1
u1=phi(n)%1000000007
if math.floor(k/2)>n:
print(1)
else:
for j in range(1,num+1):
if u1==1:
break
u1=phi(u1)%1000000007
print(u1)
``` | instruction | 0 | 20,825 | 22 | 41,650 |
No | output | 1 | 20,825 | 22 | 41,651 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Holmes children are fighting over who amongst them is the cleverest.
Mycroft asked Sherlock and Eurus to find value of f(n), where f(1) = 1 and for n ≥ 2, f(n) is the number of distinct ordered positive integer pairs (x, y) that satisfy x + y = n and gcd(x, y) = 1. The integer gcd(a, b) is the greatest common divisor of a and b.
Sherlock said that solving this was child's play and asked Mycroft to instead get the value of <image>. Summation is done over all positive integers d that divide n.
Eurus was quietly observing all this and finally came up with her problem to astonish both Sherlock and Mycroft.
She defined a k-composite function Fk(n) recursively as follows:
<image>
She wants them to tell the value of Fk(n) modulo 1000000007.
Input
A single line of input contains two space separated integers n (1 ≤ n ≤ 1012) and k (1 ≤ k ≤ 1012) indicating that Eurus asks Sherlock and Mycroft to find the value of Fk(n) modulo 1000000007.
Output
Output a single integer — the value of Fk(n) modulo 1000000007.
Examples
Input
7 1
Output
6
Input
10 2
Output
4
Note
In the first case, there are 6 distinct ordered pairs (1, 6), (2, 5), (3, 4), (4, 3), (5, 2) and (6, 1) satisfying x + y = 7 and gcd(x, y) = 1. Hence, f(7) = 6. So, F1(7) = f(g(7)) = f(f(7) + f(1)) = f(6 + 1) = f(7) = 6.
Submitted Solution:
```
import fractions
def phi(n):
amount = 0
for k in range(1, n + 1):
if fractions.gcd(n, k) == 1:
amount += 1
return amount
n,k=map(int,input().split())
if n==557056 and k==12:
print(8192)
elif n==999961 and k==19:
print(32)
elif int((k-1)/2)>n:
u1=1
print(1)
else:
u1=phi(n)%1000000007
for j in range(1,int((k-1)/2)+1):
if u1==1:
break
u1=phi(u1)%1000000007
print(u1)
``` | instruction | 0 | 20,826 | 22 | 41,652 |
No | output | 1 | 20,826 | 22 | 41,653 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ralph has a magic field which is divided into n × m blocks. That is to say, there are n rows and m columns on the field. Ralph can put an integer in each block. However, the magic field doesn't always work properly. It works only if the product of integers in each row and each column equals to k, where k is either 1 or -1.
Now Ralph wants you to figure out the number of ways to put numbers in each block in such a way that the magic field works properly. Two ways are considered different if and only if there exists at least one block where the numbers in the first way and in the second way are different. You are asked to output the answer modulo 1000000007 = 109 + 7.
Note that there is no range of the numbers to put in the blocks, but we can prove that the answer is not infinity.
Input
The only line contains three integers n, m and k (1 ≤ n, m ≤ 1018, k is either 1 or -1).
Output
Print a single number denoting the answer modulo 1000000007.
Examples
Input
1 1 -1
Output
1
Input
1 3 1
Output
1
Input
3 3 -1
Output
16
Note
In the first example the only way is to put -1 into the only block.
In the second example the only way is to put 1 into every block. | instruction | 0 | 20,876 | 22 | 41,752 |
Tags: combinatorics, constructive algorithms, math, number theory
Correct Solution:
```
a, b, c = [int(i) for i in input().split(' ')]
def exp_mod_prime(x, p):
x = x % (p-1)
a = 2
bonus = 1
while x > 1:
if x % 2 == 1:
bonus = (bonus * a) % p
a = (a * a) % p
x = x // 2
return a * bonus % p
if c == 1:
if a == 1:
result = 1
elif b == 1:
result = 1
else:
result = exp_mod_prime((a-1) * (b-1), 1000000007)
else:
if a == 1:
if b % 2 == 0:
result = 0
else:
result = 1
elif b == 1:
if a % 2 == 0:
result = 0
else:
result = 1
elif (a + b) % 2 == 1:
result = 0
else:
result = exp_mod_prime((a-1) * (b-1), 1000000007)
print(result % 1000000007)
``` | output | 1 | 20,876 | 22 | 41,753 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's define a split of n as a nonincreasing sequence of positive integers, the sum of which is n.
For example, the following sequences are splits of 8: [4, 4], [3, 3, 2], [2, 2, 1, 1, 1, 1], [5, 2, 1].
The following sequences aren't splits of 8: [1, 7], [5, 4], [11, -3], [1, 1, 4, 1, 1].
The weight of a split is the number of elements in the split that are equal to the first element. For example, the weight of the split [1, 1, 1, 1, 1] is 5, the weight of the split [5, 5, 3, 3, 3] is 2 and the weight of the split [9] equals 1.
For a given n, find out the number of different weights of its splits.
Input
The first line contains one integer n (1 ≤ n ≤ 10^9).
Output
Output one integer — the answer to the problem.
Examples
Input
7
Output
4
Input
8
Output
5
Input
9
Output
5
Note
In the first sample, there are following possible weights of splits of 7:
Weight 1: [\textbf 7]
Weight 2: [\textbf 3, \textbf 3, 1]
Weight 3: [\textbf 2, \textbf 2, \textbf 2, 1]
Weight 7: [\textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1] | instruction | 0 | 20,898 | 22 | 41,796 |
Tags: math
Correct Solution:
```
n = eval(input(""))
n = n / 2 + 1
print("%d"%(n))
``` | output | 1 | 20,898 | 22 | 41,797 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's define a split of n as a nonincreasing sequence of positive integers, the sum of which is n.
For example, the following sequences are splits of 8: [4, 4], [3, 3, 2], [2, 2, 1, 1, 1, 1], [5, 2, 1].
The following sequences aren't splits of 8: [1, 7], [5, 4], [11, -3], [1, 1, 4, 1, 1].
The weight of a split is the number of elements in the split that are equal to the first element. For example, the weight of the split [1, 1, 1, 1, 1] is 5, the weight of the split [5, 5, 3, 3, 3] is 2 and the weight of the split [9] equals 1.
For a given n, find out the number of different weights of its splits.
Input
The first line contains one integer n (1 ≤ n ≤ 10^9).
Output
Output one integer — the answer to the problem.
Examples
Input
7
Output
4
Input
8
Output
5
Input
9
Output
5
Note
In the first sample, there are following possible weights of splits of 7:
Weight 1: [\textbf 7]
Weight 2: [\textbf 3, \textbf 3, 1]
Weight 3: [\textbf 2, \textbf 2, \textbf 2, 1]
Weight 7: [\textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1] | instruction | 0 | 20,899 | 22 | 41,798 |
Tags: math
Correct Solution:
```
n = int(input())
ans = int(n/2) + 1
print(ans)
``` | output | 1 | 20,899 | 22 | 41,799 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's define a split of n as a nonincreasing sequence of positive integers, the sum of which is n.
For example, the following sequences are splits of 8: [4, 4], [3, 3, 2], [2, 2, 1, 1, 1, 1], [5, 2, 1].
The following sequences aren't splits of 8: [1, 7], [5, 4], [11, -3], [1, 1, 4, 1, 1].
The weight of a split is the number of elements in the split that are equal to the first element. For example, the weight of the split [1, 1, 1, 1, 1] is 5, the weight of the split [5, 5, 3, 3, 3] is 2 and the weight of the split [9] equals 1.
For a given n, find out the number of different weights of its splits.
Input
The first line contains one integer n (1 ≤ n ≤ 10^9).
Output
Output one integer — the answer to the problem.
Examples
Input
7
Output
4
Input
8
Output
5
Input
9
Output
5
Note
In the first sample, there are following possible weights of splits of 7:
Weight 1: [\textbf 7]
Weight 2: [\textbf 3, \textbf 3, 1]
Weight 3: [\textbf 2, \textbf 2, \textbf 2, 1]
Weight 7: [\textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1] | instruction | 0 | 20,900 | 22 | 41,800 |
Tags: math
Correct Solution:
```
from math import *
from collections import *
def inp(): return map(int,input().split())
def inp_arr(): return list(map(int,input().split()))
n = int(input())
print(n//2+1)
``` | output | 1 | 20,900 | 22 | 41,801 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's define a split of n as a nonincreasing sequence of positive integers, the sum of which is n.
For example, the following sequences are splits of 8: [4, 4], [3, 3, 2], [2, 2, 1, 1, 1, 1], [5, 2, 1].
The following sequences aren't splits of 8: [1, 7], [5, 4], [11, -3], [1, 1, 4, 1, 1].
The weight of a split is the number of elements in the split that are equal to the first element. For example, the weight of the split [1, 1, 1, 1, 1] is 5, the weight of the split [5, 5, 3, 3, 3] is 2 and the weight of the split [9] equals 1.
For a given n, find out the number of different weights of its splits.
Input
The first line contains one integer n (1 ≤ n ≤ 10^9).
Output
Output one integer — the answer to the problem.
Examples
Input
7
Output
4
Input
8
Output
5
Input
9
Output
5
Note
In the first sample, there are following possible weights of splits of 7:
Weight 1: [\textbf 7]
Weight 2: [\textbf 3, \textbf 3, 1]
Weight 3: [\textbf 2, \textbf 2, \textbf 2, 1]
Weight 7: [\textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1] | instruction | 0 | 20,901 | 22 | 41,802 |
Tags: math
Correct Solution:
```
from math import ceil
print(int(int(input())/2)+1)
``` | output | 1 | 20,901 | 22 | 41,803 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's define a split of n as a nonincreasing sequence of positive integers, the sum of which is n.
For example, the following sequences are splits of 8: [4, 4], [3, 3, 2], [2, 2, 1, 1, 1, 1], [5, 2, 1].
The following sequences aren't splits of 8: [1, 7], [5, 4], [11, -3], [1, 1, 4, 1, 1].
The weight of a split is the number of elements in the split that are equal to the first element. For example, the weight of the split [1, 1, 1, 1, 1] is 5, the weight of the split [5, 5, 3, 3, 3] is 2 and the weight of the split [9] equals 1.
For a given n, find out the number of different weights of its splits.
Input
The first line contains one integer n (1 ≤ n ≤ 10^9).
Output
Output one integer — the answer to the problem.
Examples
Input
7
Output
4
Input
8
Output
5
Input
9
Output
5
Note
In the first sample, there are following possible weights of splits of 7:
Weight 1: [\textbf 7]
Weight 2: [\textbf 3, \textbf 3, 1]
Weight 3: [\textbf 2, \textbf 2, \textbf 2, 1]
Weight 7: [\textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1] | instruction | 0 | 20,902 | 22 | 41,804 |
Tags: math
Correct Solution:
```
n=int(input())
print(int(n//2+1))
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa=0
``` | output | 1 | 20,902 | 22 | 41,805 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's define a split of n as a nonincreasing sequence of positive integers, the sum of which is n.
For example, the following sequences are splits of 8: [4, 4], [3, 3, 2], [2, 2, 1, 1, 1, 1], [5, 2, 1].
The following sequences aren't splits of 8: [1, 7], [5, 4], [11, -3], [1, 1, 4, 1, 1].
The weight of a split is the number of elements in the split that are equal to the first element. For example, the weight of the split [1, 1, 1, 1, 1] is 5, the weight of the split [5, 5, 3, 3, 3] is 2 and the weight of the split [9] equals 1.
For a given n, find out the number of different weights of its splits.
Input
The first line contains one integer n (1 ≤ n ≤ 10^9).
Output
Output one integer — the answer to the problem.
Examples
Input
7
Output
4
Input
8
Output
5
Input
9
Output
5
Note
In the first sample, there are following possible weights of splits of 7:
Weight 1: [\textbf 7]
Weight 2: [\textbf 3, \textbf 3, 1]
Weight 3: [\textbf 2, \textbf 2, \textbf 2, 1]
Weight 7: [\textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1] | instruction | 0 | 20,903 | 22 | 41,806 |
Tags: math
Correct Solution:
```
print(int(int(input())/2+1))
``` | output | 1 | 20,903 | 22 | 41,807 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's define a split of n as a nonincreasing sequence of positive integers, the sum of which is n.
For example, the following sequences are splits of 8: [4, 4], [3, 3, 2], [2, 2, 1, 1, 1, 1], [5, 2, 1].
The following sequences aren't splits of 8: [1, 7], [5, 4], [11, -3], [1, 1, 4, 1, 1].
The weight of a split is the number of elements in the split that are equal to the first element. For example, the weight of the split [1, 1, 1, 1, 1] is 5, the weight of the split [5, 5, 3, 3, 3] is 2 and the weight of the split [9] equals 1.
For a given n, find out the number of different weights of its splits.
Input
The first line contains one integer n (1 ≤ n ≤ 10^9).
Output
Output one integer — the answer to the problem.
Examples
Input
7
Output
4
Input
8
Output
5
Input
9
Output
5
Note
In the first sample, there are following possible weights of splits of 7:
Weight 1: [\textbf 7]
Weight 2: [\textbf 3, \textbf 3, 1]
Weight 3: [\textbf 2, \textbf 2, \textbf 2, 1]
Weight 7: [\textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1] | instruction | 0 | 20,904 | 22 | 41,808 |
Tags: math
Correct Solution:
```
q = int(input())
a = q//2
print(a+1)
``` | output | 1 | 20,904 | 22 | 41,809 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's define a split of n as a nonincreasing sequence of positive integers, the sum of which is n.
For example, the following sequences are splits of 8: [4, 4], [3, 3, 2], [2, 2, 1, 1, 1, 1], [5, 2, 1].
The following sequences aren't splits of 8: [1, 7], [5, 4], [11, -3], [1, 1, 4, 1, 1].
The weight of a split is the number of elements in the split that are equal to the first element. For example, the weight of the split [1, 1, 1, 1, 1] is 5, the weight of the split [5, 5, 3, 3, 3] is 2 and the weight of the split [9] equals 1.
For a given n, find out the number of different weights of its splits.
Input
The first line contains one integer n (1 ≤ n ≤ 10^9).
Output
Output one integer — the answer to the problem.
Examples
Input
7
Output
4
Input
8
Output
5
Input
9
Output
5
Note
In the first sample, there are following possible weights of splits of 7:
Weight 1: [\textbf 7]
Weight 2: [\textbf 3, \textbf 3, 1]
Weight 3: [\textbf 2, \textbf 2, \textbf 2, 1]
Weight 7: [\textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1] | instruction | 0 | 20,905 | 22 | 41,810 |
Tags: math
Correct Solution:
```
n = int(input())
low, high = 1, n
while low < high - 1:
mid = (low + high) // 2
if n // mid > 1:
low = mid
else:
high = mid
print(high)
``` | output | 1 | 20,905 | 22 | 41,811 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In number world, two different numbers are friends if they have a lot in common, but also each one has unique perks.
More precisely, two different numbers a and b are friends if gcd(a,b), (a)/(gcd(a,b)), (b)/(gcd(a,b)) can form sides of a triangle.
Three numbers a, b and c can form sides of a triangle if a + b > c, b + c > a and c + a > b.
In a group of numbers, a number is lonely if it doesn't have any friends in that group.
Given a group of numbers containing all numbers from 1, 2, 3, ..., n, how many numbers in that group are lonely?
Input
The first line contains a single integer t (1 ≤ t ≤ 10^6) - number of test cases.
On next line there are t numbers, n_i (1 ≤ n_i ≤ 10^6) - meaning that in case i you should solve for numbers 1, 2, 3, ..., n_i.
Output
For each test case, print the answer on separate lines: number of lonely numbers in group 1, 2, 3, ..., n_i.
Example
Input
3
1 5 10
Output
1
3
3
Note
For first test case, 1 is the only number and therefore lonely.
For second test case where n=5, numbers 1, 3 and 5 are lonely.
For third test case where n=10, numbers 1, 5 and 7 are lonely. | instruction | 0 | 21,391 | 22 | 42,782 |
Tags: binary search, math, number theory, two pointers
Correct Solution:
```
import math
import io
import os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
#sieve
prime = [True for i in range(10**6+1)]
p = 2
while p ** 2 <= 10**6:
if prime[p]:
for i in range(p**2, 10**6+1, p):
prime[i] = False
p += 1
primes_below = [0]
for i in range(1, 10**6 + 1):
if prime[i]:
primes_below.append(primes_below[i-1] + 1)
else:
primes_below.append(primes_below[i-1])
n = int(input())
inp = [int(z) for z in input().split()]
for tc in inp:
lonely = 1
sq = int(math.sqrt(tc))
lonely += primes_below[tc] - primes_below[sq]
print(lonely)
``` | output | 1 | 21,391 | 22 | 42,783 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In number world, two different numbers are friends if they have a lot in common, but also each one has unique perks.
More precisely, two different numbers a and b are friends if gcd(a,b), (a)/(gcd(a,b)), (b)/(gcd(a,b)) can form sides of a triangle.
Three numbers a, b and c can form sides of a triangle if a + b > c, b + c > a and c + a > b.
In a group of numbers, a number is lonely if it doesn't have any friends in that group.
Given a group of numbers containing all numbers from 1, 2, 3, ..., n, how many numbers in that group are lonely?
Input
The first line contains a single integer t (1 ≤ t ≤ 10^6) - number of test cases.
On next line there are t numbers, n_i (1 ≤ n_i ≤ 10^6) - meaning that in case i you should solve for numbers 1, 2, 3, ..., n_i.
Output
For each test case, print the answer on separate lines: number of lonely numbers in group 1, 2, 3, ..., n_i.
Example
Input
3
1 5 10
Output
1
3
3
Note
For first test case, 1 is the only number and therefore lonely.
For second test case where n=5, numbers 1, 3 and 5 are lonely.
For third test case where n=10, numbers 1, 5 and 7 are lonely. | instruction | 0 | 21,393 | 22 | 42,786 |
Tags: binary search, math, number theory, two pointers
Correct Solution:
```
# This code is contributed by Siddharth
import os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
# setrecursionlimit(10**6)
# from sys import *
import random
from bisect import *
import math
from collections import *
import operator
from heapq import *
from itertools import *
inf=10**18
mod=10**9+7
# inverse modulo power pow(a,-1,mod) - it only works on py 3.8 ( *not in pypy )
# ==========================================> Code Starts Here <=====================================================================
def findprime():
n = 1000000
prime = [1 for i in range(n + 1)]
prime[0] = 0
prime[1] = 0
p = 2
while p * p <= n:
if prime[p]:
for i in range(p * p, n + 1, p):
prime[i] = 0
p += 1
for i in range(1, n + 1):
prime[i] += prime[i - 1]
return prime
n=int(input())
a=list(map(int,input().split()))
prime=findprime()
for i in a:
temp=int(math.sqrt(i))
print(prime[i]-prime[temp]+1)
``` | output | 1 | 21,393 | 22 | 42,787 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In number world, two different numbers are friends if they have a lot in common, but also each one has unique perks.
More precisely, two different numbers a and b are friends if gcd(a,b), (a)/(gcd(a,b)), (b)/(gcd(a,b)) can form sides of a triangle.
Three numbers a, b and c can form sides of a triangle if a + b > c, b + c > a and c + a > b.
In a group of numbers, a number is lonely if it doesn't have any friends in that group.
Given a group of numbers containing all numbers from 1, 2, 3, ..., n, how many numbers in that group are lonely?
Input
The first line contains a single integer t (1 ≤ t ≤ 10^6) - number of test cases.
On next line there are t numbers, n_i (1 ≤ n_i ≤ 10^6) - meaning that in case i you should solve for numbers 1, 2, 3, ..., n_i.
Output
For each test case, print the answer on separate lines: number of lonely numbers in group 1, 2, 3, ..., n_i.
Example
Input
3
1 5 10
Output
1
3
3
Note
For first test case, 1 is the only number and therefore lonely.
For second test case where n=5, numbers 1, 3 and 5 are lonely.
For third test case where n=10, numbers 1, 5 and 7 are lonely. | instruction | 0 | 21,394 | 22 | 42,788 |
Tags: binary search, math, number theory, two pointers
Correct Solution:
```
import os,io
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
n = 10**6+1
primes = [1]*n
primes[0],primes[1] = 0,0
v = int(n**0.5)+1
for i in range(2,v):
if primes[i]:
for j in range(i*i,n,i):
primes[j]=0
for i in range(1,n):
primes[i]+=primes[i-1]
cases = int(input())
for t in range(cases):
n1 = list(map(int,input().split()))
for ni in n1:
print(primes[ni]-primes[int(ni**0.5)]+1)
``` | output | 1 | 21,394 | 22 | 42,789 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In number world, two different numbers are friends if they have a lot in common, but also each one has unique perks.
More precisely, two different numbers a and b are friends if gcd(a,b), (a)/(gcd(a,b)), (b)/(gcd(a,b)) can form sides of a triangle.
Three numbers a, b and c can form sides of a triangle if a + b > c, b + c > a and c + a > b.
In a group of numbers, a number is lonely if it doesn't have any friends in that group.
Given a group of numbers containing all numbers from 1, 2, 3, ..., n, how many numbers in that group are lonely?
Input
The first line contains a single integer t (1 ≤ t ≤ 10^6) - number of test cases.
On next line there are t numbers, n_i (1 ≤ n_i ≤ 10^6) - meaning that in case i you should solve for numbers 1, 2, 3, ..., n_i.
Output
For each test case, print the answer on separate lines: number of lonely numbers in group 1, 2, 3, ..., n_i.
Example
Input
3
1 5 10
Output
1
3
3
Note
For first test case, 1 is the only number and therefore lonely.
For second test case where n=5, numbers 1, 3 and 5 are lonely.
For third test case where n=10, numbers 1, 5 and 7 are lonely.
Submitted Solution:
```
import os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def findprime():
n = 1000000
prime = [1 for i in range(n + 1)]
prime[0] = 0
prime[1] = 0
p = 2
while p * p <= n:
if prime[p]:
for i in range(p * p, n + 1, p):
prime[i] = 0
p += 1
for i in range(1, n + 1):
prime[i] += prime[i - 1]
return prime
n = int(input())
l = list(map(int, input().split()))
prime = findprime()
for i in l:
k = int(i ** 0.5)
print(prime[i] - prime[k] + 1)
``` | instruction | 0 | 21,398 | 22 | 42,796 |
Yes | output | 1 | 21,398 | 22 | 42,797 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In number world, two different numbers are friends if they have a lot in common, but also each one has unique perks.
More precisely, two different numbers a and b are friends if gcd(a,b), (a)/(gcd(a,b)), (b)/(gcd(a,b)) can form sides of a triangle.
Three numbers a, b and c can form sides of a triangle if a + b > c, b + c > a and c + a > b.
In a group of numbers, a number is lonely if it doesn't have any friends in that group.
Given a group of numbers containing all numbers from 1, 2, 3, ..., n, how many numbers in that group are lonely?
Input
The first line contains a single integer t (1 ≤ t ≤ 10^6) - number of test cases.
On next line there are t numbers, n_i (1 ≤ n_i ≤ 10^6) - meaning that in case i you should solve for numbers 1, 2, 3, ..., n_i.
Output
For each test case, print the answer on separate lines: number of lonely numbers in group 1, 2, 3, ..., n_i.
Example
Input
3
1 5 10
Output
1
3
3
Note
For first test case, 1 is the only number and therefore lonely.
For second test case where n=5, numbers 1, 3 and 5 are lonely.
For third test case where n=10, numbers 1, 5 and 7 are lonely.
Submitted Solution:
```
import sys
input=sys.stdin.readline
from math import floor,sqrt
t=int(input())
ns=list(map(int,input().split()))
def SieveOfEratosthenes(n):
# Create a boolean array "prime[0..n]" and initialize
# all entries it as true. A value in prime[i] will
# finally be false if i is Not a prime, else true.
prime = [True for i in range(n + 1)]
p = 2
while (p * p <= n):
# If prime[p] is not changed, then it is a prime
if (prime[p] == True):
# Update all multiples of p
for i in range(p * p, n + 1, p):
prime[i] = False
p += 1
prime[0] = False
prime[1] = False
return prime
from time import time
x=time()
primes=SieveOfEratosthenes(1000000+1)
sys.stdout.write(str(time()-x))
sys.stdout.flush()
p_sum=[0]*1000001
# print(time()-x)
p_sum[0]=primes[0]
for i in range(0,len(p_sum)):
p_sum[i]=primes[i]+p_sum[i-1]
# print(time()-x)
ans=''
for i in range(0,len(ns)):
if ns[i]==1:
print(1)
else:
s=int(floor(ns[i]**0.5))
ans+=str(p_sum[ns[i]]-p_sum[s]+1)+"\n"
sys.stdout.write(ans)
sys.stdout.flush()
# print(time()-x)
``` | instruction | 0 | 21,403 | 22 | 42,806 |
No | output | 1 | 21,403 | 22 | 42,807 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In number world, two different numbers are friends if they have a lot in common, but also each one has unique perks.
More precisely, two different numbers a and b are friends if gcd(a,b), (a)/(gcd(a,b)), (b)/(gcd(a,b)) can form sides of a triangle.
Three numbers a, b and c can form sides of a triangle if a + b > c, b + c > a and c + a > b.
In a group of numbers, a number is lonely if it doesn't have any friends in that group.
Given a group of numbers containing all numbers from 1, 2, 3, ..., n, how many numbers in that group are lonely?
Input
The first line contains a single integer t (1 ≤ t ≤ 10^6) - number of test cases.
On next line there are t numbers, n_i (1 ≤ n_i ≤ 10^6) - meaning that in case i you should solve for numbers 1, 2, 3, ..., n_i.
Output
For each test case, print the answer on separate lines: number of lonely numbers in group 1, 2, 3, ..., n_i.
Example
Input
3
1 5 10
Output
1
3
3
Note
For first test case, 1 is the only number and therefore lonely.
For second test case where n=5, numbers 1, 3 and 5 are lonely.
For third test case where n=10, numbers 1, 5 and 7 are lonely.
Submitted Solution:
```
MAXPRIME=10**6
isPrime=[0 for _ in range(MAXPRIME+1)]
isPrime[0]=-1;isPrime[1]=-1 #0 and 1 are not prime numbers
for i in range(2,MAXPRIME//2+1):
if isPrime[i]==0: #i is prime
for multiple in range(i*i,MAXPRIME+1,i):
if isPrime[multiple]==0:
isPrime[multiple]=i
primeNumberSet=set()
for i in range(len(isPrime)):
if isPrime[i]==0:
primeNumberSet.add(i)
primes=sorted(list(primeNumberSet))
lookupTable=[None for _ in range(MAXPRIME+1)]
pIdx=-1
pSqRtIdx=-1
for i in range(1,MAXPRIME+1):
while pIdx+1<len(primes) and primes[pIdx+1]<=i:
pIdx+=1
while pSqRtIdx+1<len(primes) and (primes[pSqRtIdx+1])**2<=i:
pSqRtIdx+=1
total=(pIdx+1)-(pSqRtIdx+1)+1 #1 is always lonely
lookupTable[i]=total
print(lookupTable[:30])
#a number is lonely if its gcd with all other numbers is 1. i.e. it is prime and its square > n. also, 1 is always lonely
t=int(input())
n=[int(x) for x in input().split()]
for nn in n:
print(lookupTable[nn])
#def gcd(x, y):
# while y != 0:
# (x, y) = (y, x % y)
# return x
#lonely=[]
#for i in range(1,n+1):
# ok=False
# for j in range(1,n+1):
# g=gcd(i,j)
# a=g
# b=i//g
# c=j//g
# if a+b>c and b+c>a and a+c>b:
# ok=True
# if i in primeNumberSet:
# print(i,j)
# break
# if ok==False:
# lonely.append(i)
#print(lonely)
``` | instruction | 0 | 21,404 | 22 | 42,808 |
No | output | 1 | 21,404 | 22 | 42,809 |
Provide tags and a correct Python 3 solution for this coding contest problem.
qd ucyhf yi q fhycu dkcruh mxeiu huluhiu yi q tyvvuhudj fhycu dkcruh. oekh jqia yi je vydt jxu djx ucyhf.
Input
jxu ydfkj sediyiji ev q iydwbu ydjuwuh d (1 ≤ d ≤ 11184) — jxu edu-rqiut ydtun ev jxu ucyhf je vydt.
Output
ekjfkj q iydwbu dkcruh.
Examples
Input
1
Output
13 | instruction | 0 | 21,464 | 22 | 42,928 |
Tags: *special, brute force, implementation, number theory
Correct Solution:
```
def prime(x) :
if x == 2 : return 1
if ~ x & 1 : return 0
i = 3
while i * i <= x :
if x % i == 0 : return 0
i += 1
return 1
n = int(input())
cnt = 0
for i in range (2, int(1e9), 1) :
if not prime(i) : continue
if i == int(str(i)[::-1]) : continue
if not prime(int(str(i)[::-1])) : continue
cnt += 1
if cnt == n : exit(print(i))
``` | output | 1 | 21,464 | 22 | 42,929 |
Provide tags and a correct Python 3 solution for this coding contest problem.
qd ucyhf yi q fhycu dkcruh mxeiu huluhiu yi q tyvvuhudj fhycu dkcruh. oekh jqia yi je vydt jxu djx ucyhf.
Input
jxu ydfkj sediyiji ev q iydwbu ydjuwuh d (1 ≤ d ≤ 11184) — jxu edu-rqiut ydtun ev jxu ucyhf je vydt.
Output
ekjfkj q iydwbu dkcruh.
Examples
Input
1
Output
13 | instruction | 0 | 21,467 | 22 | 42,934 |
Tags: *special, brute force, implementation, number theory
Correct Solution:
```
N = 1000000
def rev(z):
res = 0
while z:
res *= 10
res += z % 10
z //= 10
return res
def revv(z):
res = rev(z)
if res != z: return res
def rwh_primes_x(n):
sieve = [True] * n
for i in range(3,int(n**0.5)+1,2):
if sieve[i]:
sieve[i*i::2*i]=[False]*((n-i*i-1)//(2*i)+1)
return [i for i in range(3,n,2) if sieve[i]]
primes = rwh_primes_x(N)
test = set(primes)
found = [v for v in primes if revv(v) in test]
n = int(input())
print(found[n-1])
``` | output | 1 | 21,467 | 22 | 42,935 |
Provide tags and a correct Python 3 solution for this coding contest problem.
qd ucyhf yi q fhycu dkcruh mxeiu huluhiu yi q tyvvuhudj fhycu dkcruh. oekh jqia yi je vydt jxu djx ucyhf.
Input
jxu ydfkj sediyiji ev q iydwbu ydjuwuh d (1 ≤ d ≤ 11184) — jxu edu-rqiut ydtun ev jxu ucyhf je vydt.
Output
ekjfkj q iydwbu dkcruh.
Examples
Input
1
Output
13 | instruction | 0 | 21,468 | 22 | 42,936 |
Tags: *special, brute force, implementation, number theory
Correct Solution:
```
def primesieve(n):
primes=[2]
table=[0,0,1]+[1,0]*(n//2-1)
if len(table)==n:
table.append(1)
i=3
while i<=n:
if table[i]==1:
primes.append(i)
for k in range(i,n//i+1,2):
table[i*k]=0;
i+=2;
return primes,table
primes, table = primesieve(10**6)
def isprime(n):
return table[n]
n = int(input())
emirp = []
for p in primes:
rev = int(str(p)[::-1])
if rev == p:
continue
if isprime(rev):
emirp.append(p)
if len(emirp) == n:
print(p)
break
``` | output | 1 | 21,468 | 22 | 42,937 |
Provide tags and a correct Python 3 solution for this coding contest problem.
qd ucyhf yi q fhycu dkcruh mxeiu huluhiu yi q tyvvuhudj fhycu dkcruh. oekh jqia yi je vydt jxu djx ucyhf.
Input
jxu ydfkj sediyiji ev q iydwbu ydjuwuh d (1 ≤ d ≤ 11184) — jxu edu-rqiut ydtun ev jxu ucyhf je vydt.
Output
ekjfkj q iydwbu dkcruh.
Examples
Input
1
Output
13 | instruction | 0 | 21,469 | 22 | 42,938 |
Tags: *special, brute force, implementation, number theory
Correct Solution:
```
import sys
def solve():
d, = rv()
cur = 2
while d > 0:
if isprime(cur):
rev = int(str(cur)[::-1])
if rev != cur and isprime(rev):
d -= 1
if d > 0: cur+=1
print(cur)
def isprime(cur):
check = 2
while check * check <= cur:
if cur % check == 0: return False
check += 1
return True
def prt(l): return print(''.join(l))
def rv(): return map(int, input().split())
def rl(n): return [list(map(int, input().split())) for _ in range(n)]
if sys.hexversion == 50594544 : sys.stdin = open("test.txt")
solve()
``` | output | 1 | 21,469 | 22 | 42,939 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Squirrel Liss is interested in sequences. She also has preferences of integers. She thinks n integers a1, a2, ..., an are good.
Now she is interested in good sequences. A sequence x1, x2, ..., xk is called good if it satisfies the following three conditions:
* The sequence is strictly increasing, i.e. xi < xi + 1 for each i (1 ≤ i ≤ k - 1).
* No two adjacent elements are coprime, i.e. gcd(xi, xi + 1) > 1 for each i (1 ≤ i ≤ k - 1) (where gcd(p, q) denotes the greatest common divisor of the integers p and q).
* All elements of the sequence are good integers.
Find the length of the longest good sequence.
Input
The input consists of two lines. The first line contains a single integer n (1 ≤ n ≤ 105) — the number of good integers. The second line contains a single-space separated list of good integers a1, a2, ..., an in strictly increasing order (1 ≤ ai ≤ 105; ai < ai + 1).
Output
Print a single integer — the length of the longest good sequence.
Examples
Input
5
2 3 4 6 9
Output
4
Input
9
1 2 3 5 6 7 8 9 10
Output
4
Note
In the first example, the following sequences are examples of good sequences: [2; 4; 6; 9], [2; 4; 6], [3; 9], [6]. The length of the longest good sequence is 4. | instruction | 0 | 21,491 | 22 | 42,982 |
Tags: dp, number theory
Correct Solution:
```
#!/usr/bin/env python3
from sys import stdin
mem = [0 for i in range(int(1e5+1))]
def solve(tc):
n = int(stdin.readline().strip())
seq = list(map(int, stdin.readline().split()))
if n==1:
print(1)
return
ans = 0
for i in range(n):
num = seq[i]
divisor = set()
p = 2
while p*p <= num:
while num % p == 0:
divisor.add(p)
num //= p
p += 1
if num > 1:
divisor.add(num)
for dn in divisor:
mem[seq[i]] = max(mem[seq[i]], mem[dn]+1)
for dn in divisor:
mem[dn] = mem[seq[i]]
ans = max(ans, mem[seq[i]])
print(ans)
tcs = 1
for tc in range(tcs):
solve(tc)
``` | output | 1 | 21,491 | 22 | 42,983 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Squirrel Liss is interested in sequences. She also has preferences of integers. She thinks n integers a1, a2, ..., an are good.
Now she is interested in good sequences. A sequence x1, x2, ..., xk is called good if it satisfies the following three conditions:
* The sequence is strictly increasing, i.e. xi < xi + 1 for each i (1 ≤ i ≤ k - 1).
* No two adjacent elements are coprime, i.e. gcd(xi, xi + 1) > 1 for each i (1 ≤ i ≤ k - 1) (where gcd(p, q) denotes the greatest common divisor of the integers p and q).
* All elements of the sequence are good integers.
Find the length of the longest good sequence.
Input
The input consists of two lines. The first line contains a single integer n (1 ≤ n ≤ 105) — the number of good integers. The second line contains a single-space separated list of good integers a1, a2, ..., an in strictly increasing order (1 ≤ ai ≤ 105; ai < ai + 1).
Output
Print a single integer — the length of the longest good sequence.
Examples
Input
5
2 3 4 6 9
Output
4
Input
9
1 2 3 5 6 7 8 9 10
Output
4
Note
In the first example, the following sequences are examples of good sequences: [2; 4; 6; 9], [2; 4; 6], [3; 9], [6]. The length of the longest good sequence is 4. | instruction | 0 | 21,494 | 22 | 42,988 |
Tags: dp, number theory
Correct Solution:
```
n=int(input())
a=list(map(int, input().split(" ")))
if(a==[1]*n):
print(1)
else:
primes=[True for i in range(401)]
primes[0]=False
primes[1]=False
for k in range(1, 401):
if(primes[k]==True):
for pro in range(k*k, 401, k):
primes[pro]=False
mine=[]
for k in range(401):
if(primes[k]):
mine.append(k)
d=[0 for i in range(100001)]
dp=[0 for i in range(n)]
for k in range(n):
al=a[k]
for prime in mine:
if(al%prime==0):
dp[k]=max(d[prime]+1, dp[k])
while(al%prime==0):
al//=prime
for prime in mine:
if(a[k]%prime==0):
d[prime]=max(d[prime], dp[k])
if(al!=1):
dp[k]=max(d[al]+1, dp[k])
d[al]=dp[k]
print(max(dp))
``` | output | 1 | 21,494 | 22 | 42,989 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let x be an array of integers x = [x_1, x_2, ..., x_n]. Let's define B(x) as a minimal size of a partition of x into subsegments such that all elements in each subsegment are equal. For example, B([3, 3, 6, 1, 6, 6, 6]) = 4 using next partition: [3, 3\ |\ 6\ |\ 1\ |\ 6, 6, 6].
Now you don't have any exact values of x, but you know that x_i can be any integer value from [l_i, r_i] (l_i ≤ r_i) uniformly at random. All x_i are independent.
Calculate expected value of (B(x))^2, or E((B(x))^2). It's guaranteed that the expected value can be represented as rational fraction P/Q where (P, Q) = 1, so print the value P ⋅ Q^{-1} mod 10^9 + 7.
Input
The first line contains the single integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the size of the array x.
The second line contains n integers l_1, l_2, ..., l_n (1 ≤ l_i ≤ 10^9).
The third line contains n integers r_1, r_2, ..., r_n (l_i ≤ r_i ≤ 10^9).
Output
Print the single integer — E((B(x))^2) as P ⋅ Q^{-1} mod 10^9 + 7.
Examples
Input
3
1 1 1
1 2 3
Output
166666673
Input
3
3 4 5
4 5 6
Output
500000010
Note
Let's describe all possible values of x for the first sample:
* [1, 1, 1]: B(x) = 1, B^2(x) = 1;
* [1, 1, 2]: B(x) = 2, B^2(x) = 4;
* [1, 1, 3]: B(x) = 2, B^2(x) = 4;
* [1, 2, 1]: B(x) = 3, B^2(x) = 9;
* [1, 2, 2]: B(x) = 2, B^2(x) = 4;
* [1, 2, 3]: B(x) = 3, B^2(x) = 9;
So E = 1/6 (1 + 4 + 4 + 9 + 4 + 9) = 31/6 or 31 ⋅ 6^{-1} = 166666673.
All possible values of x for the second sample:
* [3, 4, 5]: B(x) = 3, B^2(x) = 9;
* [3, 4, 6]: B(x) = 3, B^2(x) = 9;
* [3, 5, 5]: B(x) = 2, B^2(x) = 4;
* [3, 5, 6]: B(x) = 3, B^2(x) = 9;
* [4, 4, 5]: B(x) = 2, B^2(x) = 4;
* [4, 4, 6]: B(x) = 2, B^2(x) = 4;
* [4, 5, 5]: B(x) = 2, B^2(x) = 4;
* [4, 5, 6]: B(x) = 3, B^2(x) = 9;
So E = 1/8 (9 + 9 + 4 + 9 + 4 + 4 + 4 + 9) = 52/8 or 13 ⋅ 2^{-1} = 500000010. | instruction | 0 | 22,099 | 22 | 44,198 |
Tags: dp, math, probabilities
Correct Solution:
```
from sys import stdin, stdout
p = 10**9+7
def bezout(x, y):
if x < 0:
t = bezout(-x, y)
t[0] = -t[0]
return t
if y < 0:
t = bezout(x, -y)
t[1] = -t[1]
return t
if x > y:
t = bezout(y, x)
tmp = t[0]
t[0] = t[1]
t[1] = tmp
return tmp
if x == 0:
return [0, 1, y]
t = bezout(y % x, x)
div = y // x
a = t[0]
b = t[1]
t[0] = b- div*a
t[1] = a
return t
def modinv(x, mod):
t = bezout(x, mod)
if t[2] != 1:
print("attempted to invert non-unit", x)
ans = t[0] % mod
if ans < 0:
return ans + mod
return ans
n = int(stdin.readline())
l = list(map(int, stdin.readline().split()))
r = list(map(int, stdin.readline().split()))
ps = []
for i in range(n-1):
bi = modinv(r[i] - l[i] + 1, p)
bi1 = modinv(r[i+1] - l[i+1] + 1, p)
if l[i] <= l[i+1] and r[i] >= r[i+1]:
pp = bi
elif l[i+1] <= l[i] and r[i+1] >+ r[i]:
pp = bi1
elif r[i] < l[i+1] or r[i+1] < l[i]:
pp = 0
elif l[i] < l[i+1]:
p1 = ((r[i] - l[i+1] + 1) * bi)% p
pp = (p1*bi1) % p
else:
p1 = ((r[i+1] - l[i] + 1) * bi1)% p
pp = (p1*bi) % p
ps.append(pp)
#print(ps)
ans = n**2 % p
exp = 0
for i in range(n-1):
exp += ps[i]
exp %= p
ans -= (2*n-1)*exp
ans %= p
exp2 = (exp*exp) % p
offdiag = exp2
for i in range(n-1):
offdiag -= ps[i]**2
offdiag %= p
if i > 0:
offdiag -= 2*ps[i-1]*ps[i]
offdiag %= p
ans += offdiag
ans %= p
def p3(l1, r1, l2, r2, l3, r3):
if l1 > l2:
return p3(l2, r2, l1, r1, l3, r3)
if l2 > l3:
return p3(l1, r1, l3, r3, l2, r2)
if r1 < l3 or r2 < l3:
return 0
m = min(r1, r2, r3)
b1 = modinv(r1 - l1 + 1, p)
b2 = modinv(r2 - l2 + 1, p)
b3 = modinv(r3 - l3 + 1, p)
ans = (m - l3+1)*b1
ans %= p
ans *= b2
ans %= p
ans *= b3
ans %= p
return ans
for i in range(n-2):
loc = 2*p3(l[i], r[i], l[i+1], r[i+1], l[i+2], r[i+2])
ans += loc
ans %= p
print(ans)
``` | output | 1 | 22,099 | 22 | 44,199 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let x be an array of integers x = [x_1, x_2, ..., x_n]. Let's define B(x) as a minimal size of a partition of x into subsegments such that all elements in each subsegment are equal. For example, B([3, 3, 6, 1, 6, 6, 6]) = 4 using next partition: [3, 3\ |\ 6\ |\ 1\ |\ 6, 6, 6].
Now you don't have any exact values of x, but you know that x_i can be any integer value from [l_i, r_i] (l_i ≤ r_i) uniformly at random. All x_i are independent.
Calculate expected value of (B(x))^2, or E((B(x))^2). It's guaranteed that the expected value can be represented as rational fraction P/Q where (P, Q) = 1, so print the value P ⋅ Q^{-1} mod 10^9 + 7.
Input
The first line contains the single integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the size of the array x.
The second line contains n integers l_1, l_2, ..., l_n (1 ≤ l_i ≤ 10^9).
The third line contains n integers r_1, r_2, ..., r_n (l_i ≤ r_i ≤ 10^9).
Output
Print the single integer — E((B(x))^2) as P ⋅ Q^{-1} mod 10^9 + 7.
Examples
Input
3
1 1 1
1 2 3
Output
166666673
Input
3
3 4 5
4 5 6
Output
500000010
Note
Let's describe all possible values of x for the first sample:
* [1, 1, 1]: B(x) = 1, B^2(x) = 1;
* [1, 1, 2]: B(x) = 2, B^2(x) = 4;
* [1, 1, 3]: B(x) = 2, B^2(x) = 4;
* [1, 2, 1]: B(x) = 3, B^2(x) = 9;
* [1, 2, 2]: B(x) = 2, B^2(x) = 4;
* [1, 2, 3]: B(x) = 3, B^2(x) = 9;
So E = 1/6 (1 + 4 + 4 + 9 + 4 + 9) = 31/6 or 31 ⋅ 6^{-1} = 166666673.
All possible values of x for the second sample:
* [3, 4, 5]: B(x) = 3, B^2(x) = 9;
* [3, 4, 6]: B(x) = 3, B^2(x) = 9;
* [3, 5, 5]: B(x) = 2, B^2(x) = 4;
* [3, 5, 6]: B(x) = 3, B^2(x) = 9;
* [4, 4, 5]: B(x) = 2, B^2(x) = 4;
* [4, 4, 6]: B(x) = 2, B^2(x) = 4;
* [4, 5, 5]: B(x) = 2, B^2(x) = 4;
* [4, 5, 6]: B(x) = 3, B^2(x) = 9;
So E = 1/8 (9 + 9 + 4 + 9 + 4 + 4 + 4 + 9) = 52/8 or 13 ⋅ 2^{-1} = 500000010. | instruction | 0 | 22,100 | 22 | 44,200 |
Tags: dp, math, probabilities
Correct Solution:
```
N = int(input())
mod = 10**9 + 7
L = list(map(int, input().split()))
R = list(map(int, input().split()))
def calb2(x):
ran = (R[x] - L[x] + 1) * (R[x+1] - L[x+1] + 1) % mod
return max(0, min(R[x], R[x+1]) - max(L[x], L[x+1]) + 1) * pow(ran, mod-2, mod) % mod
def calb3(x, b2):
ran = (R[x] - L[x] + 1) * (R[x+1] - L[x+1] + 1) * (R[x+2] - L[x+2] + 1) % mod
return max(0, min(R[x], R[x+1], R[x+2]) - max(L[x], L[x+1], L[x+2]) + 1) * pow(ran, mod-2, mod) % mod
def solve():
if N == 1:
return 1
b2 = [calb2(i) for i in range(N-1)]
b3 = [calb3(i, b2) for i in range(N-2)]
res = N**2 % mod
for b in b3:
res = (res + 2*b) % mod
acb2 = [0]*(N-1)
acb2[0] = b2[0]
for i in range(1, N-1):
acb2[i] = (b2[i] + acb2[i-1]) % mod
res = (res - (2*N - 1) *acb2[-1]) % mod
for i in range(2, N-1):
res = (res + 2*b2[i]*acb2[i-2]) % mod
return res
print(solve())
``` | output | 1 | 22,100 | 22 | 44,201 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let x be an array of integers x = [x_1, x_2, ..., x_n]. Let's define B(x) as a minimal size of a partition of x into subsegments such that all elements in each subsegment are equal. For example, B([3, 3, 6, 1, 6, 6, 6]) = 4 using next partition: [3, 3\ |\ 6\ |\ 1\ |\ 6, 6, 6].
Now you don't have any exact values of x, but you know that x_i can be any integer value from [l_i, r_i] (l_i ≤ r_i) uniformly at random. All x_i are independent.
Calculate expected value of (B(x))^2, or E((B(x))^2). It's guaranteed that the expected value can be represented as rational fraction P/Q where (P, Q) = 1, so print the value P ⋅ Q^{-1} mod 10^9 + 7.
Input
The first line contains the single integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the size of the array x.
The second line contains n integers l_1, l_2, ..., l_n (1 ≤ l_i ≤ 10^9).
The third line contains n integers r_1, r_2, ..., r_n (l_i ≤ r_i ≤ 10^9).
Output
Print the single integer — E((B(x))^2) as P ⋅ Q^{-1} mod 10^9 + 7.
Examples
Input
3
1 1 1
1 2 3
Output
166666673
Input
3
3 4 5
4 5 6
Output
500000010
Note
Let's describe all possible values of x for the first sample:
* [1, 1, 1]: B(x) = 1, B^2(x) = 1;
* [1, 1, 2]: B(x) = 2, B^2(x) = 4;
* [1, 1, 3]: B(x) = 2, B^2(x) = 4;
* [1, 2, 1]: B(x) = 3, B^2(x) = 9;
* [1, 2, 2]: B(x) = 2, B^2(x) = 4;
* [1, 2, 3]: B(x) = 3, B^2(x) = 9;
So E = 1/6 (1 + 4 + 4 + 9 + 4 + 9) = 31/6 or 31 ⋅ 6^{-1} = 166666673.
All possible values of x for the second sample:
* [3, 4, 5]: B(x) = 3, B^2(x) = 9;
* [3, 4, 6]: B(x) = 3, B^2(x) = 9;
* [3, 5, 5]: B(x) = 2, B^2(x) = 4;
* [3, 5, 6]: B(x) = 3, B^2(x) = 9;
* [4, 4, 5]: B(x) = 2, B^2(x) = 4;
* [4, 4, 6]: B(x) = 2, B^2(x) = 4;
* [4, 5, 5]: B(x) = 2, B^2(x) = 4;
* [4, 5, 6]: B(x) = 3, B^2(x) = 9;
So E = 1/8 (9 + 9 + 4 + 9 + 4 + 4 + 4 + 9) = 52/8 or 13 ⋅ 2^{-1} = 500000010. | instruction | 0 | 22,101 | 22 | 44,202 |
Tags: dp, math, probabilities
Correct Solution:
```
mod = 10 ** 9 + 7
def pow_(x, y, p) :
res = 1
x = x % p
if x == 0:
return 0
while y > 0:
if (y & 1) == 1:
res = (res * x) % p
y = y >> 1
x = (x * x) % p
return res
def reverse(x, mod):
return pow_(x, mod-2, mod)
def prob(l_arr, r_arr):
l_, r_ = max(l_arr), min(r_arr)
if l_ > r_:
return 1
p = (r_-l_+1)
for l, r in zip(l_arr, r_arr):
p *= reverse(r-l+1 ,mod)
return (1-p) % mod
n = int(input())
L = list(map(int, input().split()))
R = list(map(int, input().split()))
EX, EX2 = 0, 0
P = [0] * n
pre = [0] * n
for i in range(1, n):
P[i] = prob(L[i-1: i+1], R[i-1: i+1])
pre[i] = (pre[i-1] + P[i]) % mod
if i >= 2:
pA, pB, pAB = 1-P[i-1], 1-P[i], 1-prob(L[i-2: i+1], R[i-2: i+1])
p_ = 1 - (pA+pB-pAB)
EX2 += 2 * (P[i]*pre[i-2] + p_) % mod
EX = sum(P) % mod
EX2 += EX
ans = (EX2 + 2*EX + 1) % mod
print(ans)
``` | output | 1 | 22,101 | 22 | 44,203 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let x be an array of integers x = [x_1, x_2, ..., x_n]. Let's define B(x) as a minimal size of a partition of x into subsegments such that all elements in each subsegment are equal. For example, B([3, 3, 6, 1, 6, 6, 6]) = 4 using next partition: [3, 3\ |\ 6\ |\ 1\ |\ 6, 6, 6].
Now you don't have any exact values of x, but you know that x_i can be any integer value from [l_i, r_i] (l_i ≤ r_i) uniformly at random. All x_i are independent.
Calculate expected value of (B(x))^2, or E((B(x))^2). It's guaranteed that the expected value can be represented as rational fraction P/Q where (P, Q) = 1, so print the value P ⋅ Q^{-1} mod 10^9 + 7.
Input
The first line contains the single integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the size of the array x.
The second line contains n integers l_1, l_2, ..., l_n (1 ≤ l_i ≤ 10^9).
The third line contains n integers r_1, r_2, ..., r_n (l_i ≤ r_i ≤ 10^9).
Output
Print the single integer — E((B(x))^2) as P ⋅ Q^{-1} mod 10^9 + 7.
Examples
Input
3
1 1 1
1 2 3
Output
166666673
Input
3
3 4 5
4 5 6
Output
500000010
Note
Let's describe all possible values of x for the first sample:
* [1, 1, 1]: B(x) = 1, B^2(x) = 1;
* [1, 1, 2]: B(x) = 2, B^2(x) = 4;
* [1, 1, 3]: B(x) = 2, B^2(x) = 4;
* [1, 2, 1]: B(x) = 3, B^2(x) = 9;
* [1, 2, 2]: B(x) = 2, B^2(x) = 4;
* [1, 2, 3]: B(x) = 3, B^2(x) = 9;
So E = 1/6 (1 + 4 + 4 + 9 + 4 + 9) = 31/6 or 31 ⋅ 6^{-1} = 166666673.
All possible values of x for the second sample:
* [3, 4, 5]: B(x) = 3, B^2(x) = 9;
* [3, 4, 6]: B(x) = 3, B^2(x) = 9;
* [3, 5, 5]: B(x) = 2, B^2(x) = 4;
* [3, 5, 6]: B(x) = 3, B^2(x) = 9;
* [4, 4, 5]: B(x) = 2, B^2(x) = 4;
* [4, 4, 6]: B(x) = 2, B^2(x) = 4;
* [4, 5, 5]: B(x) = 2, B^2(x) = 4;
* [4, 5, 6]: B(x) = 3, B^2(x) = 9;
So E = 1/8 (9 + 9 + 4 + 9 + 4 + 4 + 4 + 9) = 52/8 or 13 ⋅ 2^{-1} = 500000010. | instruction | 0 | 22,102 | 22 | 44,204 |
Tags: dp, math, probabilities
Correct Solution:
```
import sys
def inv(n):
p = 10 ** 9 + 7
q = p-2
ans = 1
mult = n
while q > 0:
if q % 2 == 1:
q = q - 1
ans = (ans * mult) % p
else:
q = q // 2
mult = (mult * mult) % p
return ans
n = int(sys.stdin.readline())
l = list(map(int, sys.stdin.readline().strip().split()))
r = list(map(int, sys.stdin.readline().strip().split()))
p = 10 ** 9 + 7
a = [0] * (n-1)
for i in range (0, n-1):
x = max([0, 1 + min([r[i],r[i+1]]) - max([l[i],l[i+1]])])
a[i] = x * inv((1 + r[i] - l[i]) * (1 + r[i+1] - l[i+1]))
b = [0] * (n-2)
for i in range (0, n-2):
x = max([0, 1 + min([r[i],r[i+1],r[i+2]]) - max([l[i],l[i+1],l[i+2]])])
b[i] = x * inv((1 + r[i] - l[i]) * (1 + r[i+1] - l[i+1]) * (1 + r[i+2] - l[i+2]))
ans = ((n)**2 + (1- 2 * n) * sum(a) + sum(a) ** 2 + 2 * sum(b)) % p
for i in range (0, n-1):
ans = ans - a[i] ** 2 % p
for i in range (0, n-2):
ans = ans - 2 * a[i] * a[i+1] % p
print(ans % p)
``` | output | 1 | 22,102 | 22 | 44,205 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've decided to carry out a survey in the theory of prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors.
Consider positive integers a, a + 1, ..., b (a ≤ b). You want to find the minimum integer l (1 ≤ l ≤ b - a + 1) such that for any integer x (a ≤ x ≤ b - l + 1) among l integers x, x + 1, ..., x + l - 1 there are at least k prime numbers.
Find and print the required minimum l. If no value l meets the described limitations, print -1.
Input
A single line contains three space-separated integers a, b, k (1 ≤ a, b, k ≤ 106; a ≤ b).
Output
In a single line print a single integer — the required minimum l. If there's no solution, print -1.
Examples
Input
2 4 2
Output
3
Input
6 13 1
Output
4
Input
1 4 3
Output
-1 | instruction | 0 | 23,134 | 22 | 46,268 |
Tags: binary search, number theory, two pointers
Correct Solution:
```
from sys import stdin,stdout
nmbr = lambda: int(stdin.readline())
lst = lambda: list(map(int,stdin.readline().split()))
N=10**6+6
primes=[1]*N
p=2
while p*p<=N:
if primes[p]:
for j in range(p*p,N,p):
primes[j]=0
p+=1
primes[1]=primes[0]=0
def fn(x):
for i in range(n-x+1):
ones=aa[i+x-1]-(aa[i-1] if i>=1 else 0)
if ones<k:return False
return True
for _ in range(1):#nmbr()):
a,b,k=lst()
n=b-a+1
l=1;r=b-a+1
aa=[0]*(b-a+1)
c=0
for i in range(a,b+1):
aa[c]=primes[i]+aa[max(0,c-1)]
c+=1
# print(aa)
while l<=r:
mid=(l+r)>>1
# print(mid,fn(mid))
if fn(mid)==False:l=mid+1
else:r=mid-1
print(l if l<=n else -1)
``` | output | 1 | 23,134 | 22 | 46,269 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've decided to carry out a survey in the theory of prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors.
Consider positive integers a, a + 1, ..., b (a ≤ b). You want to find the minimum integer l (1 ≤ l ≤ b - a + 1) such that for any integer x (a ≤ x ≤ b - l + 1) among l integers x, x + 1, ..., x + l - 1 there are at least k prime numbers.
Find and print the required minimum l. If no value l meets the described limitations, print -1.
Input
A single line contains three space-separated integers a, b, k (1 ≤ a, b, k ≤ 106; a ≤ b).
Output
In a single line print a single integer — the required minimum l. If there's no solution, print -1.
Examples
Input
2 4 2
Output
3
Input
6 13 1
Output
4
Input
1 4 3
Output
-1 | instruction | 0 | 23,135 | 22 | 46,270 |
Tags: binary search, number theory, two pointers
Correct Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
import sys
from io import BytesIO, IOBase
from bisect import *
def seieve_prime_factorisation(n):
p,i=[1]*(n+1),2
while i*i<=n:
if p[i]:
for j in range(i*i,n+1,i):
p[j]=0
i+=1
p[0]=p[1]=0
return p
def check(p,l,a,b,k):
z=0
for i in range(a,a+l):
z+=p[i]
if z<k:
return 0
for i in range(a+l,b+1):
z+=p[i]
z-=p[i-l]
if z<k:
return 0
return 1
def main():
a,b,k=map(int,input().split())
p=seieve_prime_factorisation(b)
lo,hi,l=0,b-a+1,-1
while lo<=hi:
mid=(lo+hi)//2
if check(p,mid,a,b,k):
l=mid
hi=mid-1
else:
lo=mid+1
print(l)
# region fastio
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")
if __name__ == "__main__":
main()
``` | output | 1 | 23,135 | 22 | 46,271 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've decided to carry out a survey in the theory of prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors.
Consider positive integers a, a + 1, ..., b (a ≤ b). You want to find the minimum integer l (1 ≤ l ≤ b - a + 1) such that for any integer x (a ≤ x ≤ b - l + 1) among l integers x, x + 1, ..., x + l - 1 there are at least k prime numbers.
Find and print the required minimum l. If no value l meets the described limitations, print -1.
Input
A single line contains three space-separated integers a, b, k (1 ≤ a, b, k ≤ 106; a ≤ b).
Output
In a single line print a single integer — the required minimum l. If there's no solution, print -1.
Examples
Input
2 4 2
Output
3
Input
6 13 1
Output
4
Input
1 4 3
Output
-1 | instruction | 0 | 23,136 | 22 | 46,272 |
Tags: binary search, number theory, two pointers
Correct Solution:
```
def f(a, b):
t = [1] * (b + 1)
for i in range(3, int(b ** 0.5) + 1):
if t[i]:
t[i * i :: 2 * i] = [0] * ((b - i * i) // (2 * i) + 1)
return [i for i in range(3, b + 1, 2) if t[i] and i > a]
a, b, k = map(int, input().split())
p = f(a - 1, b)
if 3 > a and b > 1:
p = [2] + p
if k > len(p): print(-1)
elif len(p) == k:
print(max(p[k - 1] - a + 1, b - p[0] + 1))
else:
print(max(p[k - 1] - a + 1, b - p[len(p) - k] + 1, max(p[i + k] - p[i] for i in range(len(p) - k))))
``` | output | 1 | 23,136 | 22 | 46,273 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've decided to carry out a survey in the theory of prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors.
Consider positive integers a, a + 1, ..., b (a ≤ b). You want to find the minimum integer l (1 ≤ l ≤ b - a + 1) such that for any integer x (a ≤ x ≤ b - l + 1) among l integers x, x + 1, ..., x + l - 1 there are at least k prime numbers.
Find and print the required minimum l. If no value l meets the described limitations, print -1.
Input
A single line contains three space-separated integers a, b, k (1 ≤ a, b, k ≤ 106; a ≤ b).
Output
In a single line print a single integer — the required minimum l. If there's no solution, print -1.
Examples
Input
2 4 2
Output
3
Input
6 13 1
Output
4
Input
1 4 3
Output
-1 | instruction | 0 | 23,137 | 22 | 46,274 |
Tags: binary search, number theory, two pointers
Correct Solution:
```
def f(n):
m, l = int(n ** 0.5) + 1, n - 1
t = [1] * n
for i in range(3, m):
if t[i]: t[i * i :: 2 * i] = [0] * ((l - i * i) // (2 * i) + 1)
return [2] + [i for i in range(3, n, 2) if t[i]]
a, b, k = map(int, input().split())
k -= 1; b += 1; n = b + 100
t, p, x = [-1] * n, f(n), -1
for i in range(len(p) - k):
t[p[i]] = p[i + k] - p[i]
t.reverse()
for i in range(1, n):
if t[i] < 0: t[i] = t[i - 1] + 1
t.reverse()
if len(p) > k:
for i in range(a + 1, b):
t[i] = max(t[i], t[i - 1])
for l in range(1, b - a + 1):
if t[b - l] < l:
x = l
break
print(x)
``` | output | 1 | 23,137 | 22 | 46,275 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've decided to carry out a survey in the theory of prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors.
Consider positive integers a, a + 1, ..., b (a ≤ b). You want to find the minimum integer l (1 ≤ l ≤ b - a + 1) such that for any integer x (a ≤ x ≤ b - l + 1) among l integers x, x + 1, ..., x + l - 1 there are at least k prime numbers.
Find and print the required minimum l. If no value l meets the described limitations, print -1.
Input
A single line contains three space-separated integers a, b, k (1 ≤ a, b, k ≤ 106; a ≤ b).
Output
In a single line print a single integer — the required minimum l. If there's no solution, print -1.
Examples
Input
2 4 2
Output
3
Input
6 13 1
Output
4
Input
1 4 3
Output
-1 | instruction | 0 | 23,138 | 22 | 46,276 |
Tags: binary search, number theory, two pointers
Correct Solution:
```
a,b,k=map(int,input().split())
prime=[True]*(b+1)
p=[]
for i in range(2,b+1):
if prime[i]:
if i>=a:
p.append(i)
for j in range(i,b+1,i):
prime[j]=False
if len(p)<k:
print(-1)
else:
arr1=[p[i]-p[i-k] for i in range(k,len(p))]
arr2=[b-p[-k]+1,p[k-1]-a+1]
arr=arr1+arr2
print(max(arr))
``` | output | 1 | 23,138 | 22 | 46,277 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've decided to carry out a survey in the theory of prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors.
Consider positive integers a, a + 1, ..., b (a ≤ b). You want to find the minimum integer l (1 ≤ l ≤ b - a + 1) such that for any integer x (a ≤ x ≤ b - l + 1) among l integers x, x + 1, ..., x + l - 1 there are at least k prime numbers.
Find and print the required minimum l. If no value l meets the described limitations, print -1.
Input
A single line contains three space-separated integers a, b, k (1 ≤ a, b, k ≤ 106; a ≤ b).
Output
In a single line print a single integer — the required minimum l. If there's no solution, print -1.
Examples
Input
2 4 2
Output
3
Input
6 13 1
Output
4
Input
1 4 3
Output
-1 | instruction | 0 | 23,139 | 22 | 46,278 |
Tags: binary search, number theory, two pointers
Correct Solution:
```
p=[1]*(1000005)
p[0]=0
p[1]=0
for i in range(2,1001):
if p[i]:
for j in range(2*i,1000005,i):
p[j]=0
for i in range(1,1000001):
p[i]+=p[i-1]
a,b,k=map(int,input().split())
if p[b]-p[a-1]<k:
exit(print(-1))
i=j=a
l=0
while j<=b:
if p[j]-p[i-1]<k:
j+=1
else:
l=max(l,j-i+1)
i+=1
l=max(j-i+1,l)
print(l)
``` | output | 1 | 23,139 | 22 | 46,279 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've decided to carry out a survey in the theory of prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors.
Consider positive integers a, a + 1, ..., b (a ≤ b). You want to find the minimum integer l (1 ≤ l ≤ b - a + 1) such that for any integer x (a ≤ x ≤ b - l + 1) among l integers x, x + 1, ..., x + l - 1 there are at least k prime numbers.
Find and print the required minimum l. If no value l meets the described limitations, print -1.
Input
A single line contains three space-separated integers a, b, k (1 ≤ a, b, k ≤ 106; a ≤ b).
Output
In a single line print a single integer — the required minimum l. If there's no solution, print -1.
Examples
Input
2 4 2
Output
3
Input
6 13 1
Output
4
Input
1 4 3
Output
-1 | instruction | 0 | 23,140 | 22 | 46,280 |
Tags: binary search, number theory, two pointers
Correct Solution:
```
def f(a, b):
t = [1] * (b + 1)
for i in range(3, int(b ** 0.5) + 1):
if t[i]: t[i * i :: 2 * i] = [0] * ((b - i * i) // (2 * i) + 1)
return [i for i in range(3, b + 1, 2) if t[i] and i > a]
a, b, k = map(int, input().split())
p = f(a - 1, b)
if 3 > a and b > 1: p = [2] + p
if k > len(p): print(-1)
elif len(p) == k: print(max(p[k - 1] - a + 1, b - p[0] + 1))
else: print(max(p[k - 1] - a + 1, b - p[len(p) - k] + 1, max(p[i + k] - p[i] for i in range(len(p) - k))))
# Made By Mostafa_Khaled
``` | output | 1 | 23,140 | 22 | 46,281 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've decided to carry out a survey in the theory of prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors.
Consider positive integers a, a + 1, ..., b (a ≤ b). You want to find the minimum integer l (1 ≤ l ≤ b - a + 1) such that for any integer x (a ≤ x ≤ b - l + 1) among l integers x, x + 1, ..., x + l - 1 there are at least k prime numbers.
Find and print the required minimum l. If no value l meets the described limitations, print -1.
Input
A single line contains three space-separated integers a, b, k (1 ≤ a, b, k ≤ 106; a ≤ b).
Output
In a single line print a single integer — the required minimum l. If there's no solution, print -1.
Examples
Input
2 4 2
Output
3
Input
6 13 1
Output
4
Input
1 4 3
Output
-1 | instruction | 0 | 23,141 | 22 | 46,282 |
Tags: binary search, number theory, two pointers
Correct Solution:
```
import sys
from math import gcd,sqrt,ceil
from collections import defaultdict,Counter,deque
from bisect import bisect_left,bisect_right
import math
# input=sys.stdin.readline
# def print(x):
# sys.stdout.write(str(x)+"\n")
# sys.stdout=open("CP1/output.txt",'w')
# sys.stdin=open("CP1/input.txt",'r')
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")
# import sys
# import io, os
# input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def get_sum(bit,i):
s = 0
i+=1
while i>0:
s+=bit[i]
i-=i&(-i)
return s
def update(bit,n,i,v):
i+=1
while i<=n:
bit[i]+=v
i+=i&(-i)
def modInverse(b,m):
g = math.gcd(b, m)
if (g != 1):
return -1
else:
return pow(b, m - 2, m)
def primeFactors(n):
sa = set()
sa.add(n)
while n % 2 == 0:
sa.add(2)
n = n // 2
for i in range(3,int(math.sqrt(n))+1,2):
while n % i== 0:
sa.add(i)
n = n // i
# sa.add(n)
return sa
def seive(n):
pri = [True]*(n+1)
p = 2
while p*p<=n:
if pri[p] == True:
for i in range(p*p,n+1,p):
pri[i] = False
p+=1
return pri
def ifposs(l):
i = a
# print(l)
while b-i+1>=l:
z = i+l-1
if pre[z]-pre[i-1]<k:
return False
else:
i+=1
return True
a,b,k = map(int,input().split())
pri = []
h = seive(b+1)
h[1] = False
pre = [0]
for i in range(a,b+1):
if h[i] == True:
pri.append(i)
pre.append(pre[-1]+1)
else:
pre.append(pre[-1])
pre = [0]*(a-1) + pre
# print(pre)
# print(pri)
if len(pri)<k:
print(-1)
else:
i = j = a
l = 0
while j<=b:
if pre[j]-pre[i-1]<k:
j+=1
else:
l = max(l,j-i+1)
i+=1
l = max(l,j-i+1)
print(l)
``` | output | 1 | 23,141 | 22 | 46,283 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've decided to carry out a survey in the theory of prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors.
Consider positive integers a, a + 1, ..., b (a ≤ b). You want to find the minimum integer l (1 ≤ l ≤ b - a + 1) such that for any integer x (a ≤ x ≤ b - l + 1) among l integers x, x + 1, ..., x + l - 1 there are at least k prime numbers.
Find and print the required minimum l. If no value l meets the described limitations, print -1.
Input
A single line contains three space-separated integers a, b, k (1 ≤ a, b, k ≤ 106; a ≤ b).
Output
In a single line print a single integer — the required minimum l. If there's no solution, print -1.
Examples
Input
2 4 2
Output
3
Input
6 13 1
Output
4
Input
1 4 3
Output
-1
Submitted Solution:
```
import sys
from collections import deque
from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
from itertools import permutations
from datetime import datetime
from math import ceil,sqrt,log,gcd
def ii():return int(input())
def si():return input()
def mi():return map(int,input().split())
def li():return list(mi())
def read():
zz=0
if zz:
input=sys.stdin.readline
else:
sys.stdin=open('input1.txt', 'r')
sys.stdout=open('output1.txt','w')
abc='abcdefghijklmnopqrstuvwxyz'
abd={'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod=1000000007
#mod=998244353
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def solve():
n=1000005
sieve=[1]*1000005
sieve[0],sieve[1]=0,0
for i in range(2,int(sqrt(n))):
if(sieve[i]):
for j in range(i*i,n,i):
sieve[j]=0
for i in range(1,n):
sieve[i]+=sieve[i-1]
def check(m):
for i in range(a,b-m+2):
x=sieve[i+m-1]-sieve[i-1]
if(x<k):
return 0
return 1
def bs(r):
l=1
ans=-1
while(l<=r):
m=l+(r-l)//2
if(check(m)):
ans=m
r=m-1
else:
l=m+1
return ans
# print(sieve)
global a,b,k
a,b,k=mi()
ans=bs(b-a+1)
print(ans)
if __name__== "__main__":
# read()
solve()
``` | instruction | 0 | 23,142 | 22 | 46,284 |
Yes | output | 1 | 23,142 | 22 | 46,285 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've decided to carry out a survey in the theory of prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors.
Consider positive integers a, a + 1, ..., b (a ≤ b). You want to find the minimum integer l (1 ≤ l ≤ b - a + 1) such that for any integer x (a ≤ x ≤ b - l + 1) among l integers x, x + 1, ..., x + l - 1 there are at least k prime numbers.
Find and print the required minimum l. If no value l meets the described limitations, print -1.
Input
A single line contains three space-separated integers a, b, k (1 ≤ a, b, k ≤ 106; a ≤ b).
Output
In a single line print a single integer — the required minimum l. If there's no solution, print -1.
Examples
Input
2 4 2
Output
3
Input
6 13 1
Output
4
Input
1 4 3
Output
-1
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())
a,b,k = mints()
p = [True]*(b+1)
for i in range(2, b+1):
if p[i]:
for j in range(i*i, b+1, i):
p[j] = False
p[1] = False
#d = []
#for i in range(a, b+1)
# if p[i]:
# d.append(i)
c = 0
i = a
q = [0]*(b+1)
ql = 1
qr = 1
q[0] = a-1
while c < k and i <= b:
if p[i]:
c += 1
q[qr] = i
qr += 1
i += 1
if c != k:
print(-1)
exit(0)
#print(q[qr-1],a)
r = q[qr-1]-a
while i <= b:
#print(r, q[qr-1],q[ql-1]+1)
r = max(r, q[qr-1]-(q[ql-1]+1))
ql += 1
c -= 1
while i <= b:
if p[i]:
q[qr] = i
qr += 1
c += 1
i += 1
break
i += 1
if c == k:
#print(r, b, q[ql-1]+1)
r = max(r, b-q[ql-1]-1)
else:
#print(r, b, q[ql-1])
r = max(r, b-q[ql-1])
print(r+1)
``` | instruction | 0 | 23,143 | 22 | 46,286 |
Yes | output | 1 | 23,143 | 22 | 46,287 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've decided to carry out a survey in the theory of prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors.
Consider positive integers a, a + 1, ..., b (a ≤ b). You want to find the minimum integer l (1 ≤ l ≤ b - a + 1) such that for any integer x (a ≤ x ≤ b - l + 1) among l integers x, x + 1, ..., x + l - 1 there are at least k prime numbers.
Find and print the required minimum l. If no value l meets the described limitations, print -1.
Input
A single line contains three space-separated integers a, b, k (1 ≤ a, b, k ≤ 106; a ≤ b).
Output
In a single line print a single integer — the required minimum l. If there's no solution, print -1.
Examples
Input
2 4 2
Output
3
Input
6 13 1
Output
4
Input
1 4 3
Output
-1
Submitted Solution:
```
def main():
def f(n):
m = int(n ** 0.5) + 1
t = [1] * (n + 1)
for i in range(3, m):
if t[i]: t[i * i :: 2 * i] = [0] * ((n - i * i) // (2 * i) + 1)
return [2] + [i for i in range(3, n + 1, 2) if t[i]]
a, b, k = map(int, input().split())
n = 1100001
t, p, x = [-1] * n, f(n), -1
k -= 1; b += 1
for i in range(len(p) - k):
t[p[i]] = p[i + k] - p[i]
for i in range(1,n):
if t[-i] < 0:
t[-i] = t[-i + 1] + 1
for i in range(a + 1, b):
t[i] = max(t[i], t[i - 1])
for l in range(1, b - a + 1):
if t[b - l] < l:
x = l
break
print(x)
main()
``` | instruction | 0 | 23,144 | 22 | 46,288 |
Yes | output | 1 | 23,144 | 22 | 46,289 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've decided to carry out a survey in the theory of prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors.
Consider positive integers a, a + 1, ..., b (a ≤ b). You want to find the minimum integer l (1 ≤ l ≤ b - a + 1) such that for any integer x (a ≤ x ≤ b - l + 1) among l integers x, x + 1, ..., x + l - 1 there are at least k prime numbers.
Find and print the required minimum l. If no value l meets the described limitations, print -1.
Input
A single line contains three space-separated integers a, b, k (1 ≤ a, b, k ≤ 106; a ≤ b).
Output
In a single line print a single integer — the required minimum l. If there's no solution, print -1.
Examples
Input
2 4 2
Output
3
Input
6 13 1
Output
4
Input
1 4 3
Output
-1
Submitted Solution:
```
from sys import stdin
def main():
a, b, k = map(int, stdin.readline().split())
check = [True] * (10 ** 6 + 1)
check[1] = False
check[0] = False
index = 2
bound = 10 ** 6
while index * index <= bound:
if check[index]:
for i in range(index * index, bound + 1, index):
check[i] = False
index += 1
dp = [0] * (bound + 1)
for i in range(2, bound + 1):
if check[i]:
dp[i] = dp[i - 1] + 1
else:
dp[i] = dp[i - 1]
low = 0
high = (b - a) + 2
while low < high:
mid = (low + high) >> 1
ok = True
for i in range(a, b - mid + 2):
if dp[i + mid - 1] - dp[i - 1] < k:
ok = False
break
if ok:
high = mid
else:
low = mid + 1
print(low if low <= (b - a + 1) else - 1)
if __name__ == "__main__":
main()
``` | instruction | 0 | 23,145 | 22 | 46,290 |
Yes | output | 1 | 23,145 | 22 | 46,291 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've decided to carry out a survey in the theory of prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors.
Consider positive integers a, a + 1, ..., b (a ≤ b). You want to find the minimum integer l (1 ≤ l ≤ b - a + 1) such that for any integer x (a ≤ x ≤ b - l + 1) among l integers x, x + 1, ..., x + l - 1 there are at least k prime numbers.
Find and print the required minimum l. If no value l meets the described limitations, print -1.
Input
A single line contains three space-separated integers a, b, k (1 ≤ a, b, k ≤ 106; a ≤ b).
Output
In a single line print a single integer — the required minimum l. If there's no solution, print -1.
Examples
Input
2 4 2
Output
3
Input
6 13 1
Output
4
Input
1 4 3
Output
-1
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())
a,b,k = mints()
p = [True]*(b+1)
for i in range(2, b+1):
if p[i]:
for j in range(i*i, b+1, i):
p[j] = False
p[1] = False
#d = []
#for i in range(a, b+1)
# if p[i]:
# d.append(i)
c = 0
i = a
q = [0]*(b+1)
ql = 1
qr = 1
q[0] = a-1
while c < k and i <= b:
if p[i]:
c += 1
q[qr] = i
qr += 1
i += 1
if c != k:
print(-1)
exit(0)
r = q[qr-1]-a
while i < b:
#print(r, q[qr-1],q[ql-1]+1)
r = max(r, q[qr-1]-q[ql-1]-1)
ql += 1
c -= 1
while i < b:
if p[i]:
q[qr] = i
qr += 1
c += 1
i += 1
break
i += 1
if c == k:
r = max(r, b-q[1])
else:
#print(r, b, q[ql-1]+1)
r = max(r, b-q[ql-1]+1)
print(r+1)
``` | instruction | 0 | 23,146 | 22 | 46,292 |
No | output | 1 | 23,146 | 22 | 46,293 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've decided to carry out a survey in the theory of prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors.
Consider positive integers a, a + 1, ..., b (a ≤ b). You want to find the minimum integer l (1 ≤ l ≤ b - a + 1) such that for any integer x (a ≤ x ≤ b - l + 1) among l integers x, x + 1, ..., x + l - 1 there are at least k prime numbers.
Find and print the required minimum l. If no value l meets the described limitations, print -1.
Input
A single line contains three space-separated integers a, b, k (1 ≤ a, b, k ≤ 106; a ≤ b).
Output
In a single line print a single integer — the required minimum l. If there's no solution, print -1.
Examples
Input
2 4 2
Output
3
Input
6 13 1
Output
4
Input
1 4 3
Output
-1
Submitted Solution:
```
def f(a, b):
t = [1] * (b + 1)
for i in range(3, int(b ** 0.5) + 1):
if t[i]: t[i * i :: 2 * i] = [0] * ((b - i * i) // (2 * i) + 1)
return [i for i in range(3, b + 1, 2) if t[i] and i > a]
a, b, k = map(int, input().split())
p = f(a - 1, b)
if 3 > a: p = [2] + p
if k > len(p): print(-1)
else: print(max(p[k - 1] - a + 1, b - p[len(p) - k] + 1))
``` | instruction | 0 | 23,147 | 22 | 46,294 |
No | output | 1 | 23,147 | 22 | 46,295 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've decided to carry out a survey in the theory of prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors.
Consider positive integers a, a + 1, ..., b (a ≤ b). You want to find the minimum integer l (1 ≤ l ≤ b - a + 1) such that for any integer x (a ≤ x ≤ b - l + 1) among l integers x, x + 1, ..., x + l - 1 there are at least k prime numbers.
Find and print the required minimum l. If no value l meets the described limitations, print -1.
Input
A single line contains three space-separated integers a, b, k (1 ≤ a, b, k ≤ 106; a ≤ b).
Output
In a single line print a single integer — the required minimum l. If there's no solution, print -1.
Examples
Input
2 4 2
Output
3
Input
6 13 1
Output
4
Input
1 4 3
Output
-1
Submitted Solution:
```
I = lambda : map(int,input().split())
visited = [False for i in range (10**6+1)]
#prime = {}
a , b , k =I()
visited[1] = True
li = []
for i in range(2,int(b**(0.5))+1) :
#print(visited[:14])
if visited[i] == False :
#prime[i] = 1
for j in range (i+i,b+1 , i) :
visited[j] =True
for i in range (a,b+1) :
if visited[i] == False :
li.append(i)
ans = 0
maxx = 0
#print(li)
t1 = a
#print(li)
if len(li) < k :
exit(print("-1"))
if len(li) == k :
jj = max(li[k-1]-a+1 , b-li[0]+1)
exit(print(jj))
n = len(li)
li[-1] = b
for i in range (n-k+1) :
ans = li[i+k-1] -t1 + 1
maxx = max(maxx,ans)
t1 = li[i] + 1
print(maxx)
``` | instruction | 0 | 23,148 | 22 | 46,296 |
No | output | 1 | 23,148 | 22 | 46,297 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've decided to carry out a survey in the theory of prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors.
Consider positive integers a, a + 1, ..., b (a ≤ b). You want to find the minimum integer l (1 ≤ l ≤ b - a + 1) such that for any integer x (a ≤ x ≤ b - l + 1) among l integers x, x + 1, ..., x + l - 1 there are at least k prime numbers.
Find and print the required minimum l. If no value l meets the described limitations, print -1.
Input
A single line contains three space-separated integers a, b, k (1 ≤ a, b, k ≤ 106; a ≤ b).
Output
In a single line print a single integer — the required minimum l. If there's no solution, print -1.
Examples
Input
2 4 2
Output
3
Input
6 13 1
Output
4
Input
1 4 3
Output
-1
Submitted Solution:
```
def f(n):
m = int(n ** 0.5) + 1
t = [1] * (n + 1)
for i in range(3, m):
if t[i]: t[i * i :: 2 * i] = [0] * ((n - i * i) // (2 * i) + 1)
return [2] + [i for i in range(3, n + 1, 2) if t[i]]
a, b, k = map(int, input().split())
k -= 1; b += 1
t, p, x = [-1] * (b + 100), f(b + 100), -1
for i in range(len(p) - k):
t[p[i]] = p[i + k] - p[i]
t.reverse()
for i in range(1, b):
if t[i] < 0: t[i] = t[i - 1] + 1
t.reverse()
if len(p) > k:
for i in range(a + 1, b):
t[i] = max(t[i], t[i - 1])
for l in range(1, b - a + 1):
if t[b - l] < l:
x = l
break
print(x)
``` | instruction | 0 | 23,149 | 22 | 46,298 |
No | output | 1 | 23,149 | 22 | 46,299 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Calculate the value of the sum: n mod 1 + n mod 2 + n mod 3 + ... + n mod m. As the result can be very large, you should print the value modulo 109 + 7 (the remainder when divided by 109 + 7).
The modulo operator a mod b stands for the remainder after dividing a by b. For example 10 mod 3 = 1.
Input
The only line contains two integers n, m (1 ≤ n, m ≤ 1013) — the parameters of the sum.
Output
Print integer s — the value of the required sum modulo 109 + 7.
Examples
Input
3 4
Output
4
Input
4 4
Output
1
Input
1 1
Output
0 | instruction | 0 | 23,326 | 22 | 46,652 |
Tags: implementation, math, number theory
Correct Solution:
```
def sub(a, b):
if a - b < 0:
return a - b + MOD
else:
return a - b
MOD = 10 ** 9 + 7
n, m = [int(x) for x in input().split()]
ans = n * m % MOD
k = min(n, m)
d1 = 1
while d1 * d1 <= n:
if d1 <= k:
ans = sub(ans, (n // d1) * d1 % MOD)
d1 += 1
d = 1
while d * d <= n:
r = min(k, (n // d))
l = max(d1, n // (d + 1) + 1)
if l <= r and l <= k:
s = (l + r) * (r - l + 1) // 2
ans = sub(ans, d * s % MOD)
d += 1
print(ans)
``` | output | 1 | 23,326 | 22 | 46,653 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Calculate the value of the sum: n mod 1 + n mod 2 + n mod 3 + ... + n mod m. As the result can be very large, you should print the value modulo 109 + 7 (the remainder when divided by 109 + 7).
The modulo operator a mod b stands for the remainder after dividing a by b. For example 10 mod 3 = 1.
Input
The only line contains two integers n, m (1 ≤ n, m ≤ 1013) — the parameters of the sum.
Output
Print integer s — the value of the required sum modulo 109 + 7.
Examples
Input
3 4
Output
4
Input
4 4
Output
1
Input
1 1
Output
0 | instruction | 0 | 23,327 | 22 | 46,654 |
Tags: implementation, math, number theory
Correct Solution:
```
#### IMPORTANT LIBRARY ####
############################
### DO NOT USE import random --> 250ms to load the library
############################
### In case of extra libraries: https://github.com/cheran-senthil/PyRival
######################
####### IMPORT #######
######################
from functools import cmp_to_key
from collections import deque, Counter
from heapq import heappush, heappop
from math import log, ceil
######################
#### STANDARD I/O ####
######################
import sys
import os
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")
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def print(*args, **kwargs):
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
def inp():
return sys.stdin.readline().rstrip("\r\n") # for fast input
def ii():
return int(inp())
def si():
return str(inp())
def li(lag = 0):
l = list(map(int, inp().split()))
if lag != 0:
for i in range(len(l)):
l[i] += lag
return l
def mi(lag = 0):
matrix = list()
for i in range(n):
matrix.append(li(lag))
return matrix
def lsi(): #string list
return list(map(str, inp().split()))
def print_list(lista, space = " "):
print(space.join(map(str, lista)))
######################
### BISECT METHODS ###
######################
def bisect_left(a, x):
"""i tale che a[i] >= x e a[i-1] < x"""
left = 0
right = len(a)
while left < right:
mid = (left+right)//2
if a[mid] < x:
left = mid+1
else:
right = mid
return left
def bisect_right(a, x):
"""i tale che a[i] > x e a[i-1] <= x"""
left = 0
right = len(a)
while left < right:
mid = (left+right)//2
if a[mid] > x:
right = mid
else:
left = mid+1
return left
def bisect_elements(a, x):
"""elementi pari a x nell'árray sortato"""
return bisect_right(a, x) - bisect_left(a, x)
######################
### MOD OPERATION ####
######################
MOD = 10**9 + 7
maxN = 5
FACT = [0] * maxN
INV_FACT = [0] * maxN
def add(x, y):
return (x+y) % MOD
def multiply(x, y):
return (x*y) % MOD
def power(x, y):
if y == 0:
return 1
elif y % 2:
return multiply(x, power(x, y-1))
else:
a = power(x, y//2)
return multiply(a, a)
def inverse(x):
return power(x, MOD-2)
def divide(x, y):
return multiply(x, inverse(y))
def allFactorials():
FACT[0] = 1
for i in range(1, maxN):
FACT[i] = multiply(i, FACT[i-1])
def inverseFactorials():
n = len(INV_FACT)
INV_FACT[n-1] = inverse(FACT[n-1])
for i in range(n-2, -1, -1):
INV_FACT[i] = multiply(INV_FACT[i+1], i+1)
def coeffBinom(n, k):
if n < k:
return 0
return multiply(FACT[n], multiply(INV_FACT[k], INV_FACT[n-k]))
######################
#### GRAPH ALGOS #####
######################
# ZERO BASED GRAPH
def create_graph(n, m, undirected = 1, unweighted = 1):
graph = [[] for i in range(n)]
if unweighted:
for i in range(m):
[x, y] = li(lag = -1)
graph[x].append(y)
if undirected:
graph[y].append(x)
else:
for i in range(m):
[x, y, w] = li(lag = -1)
w += 1
graph[x].append([y,w])
if undirected:
graph[y].append([x,w])
return graph
def create_tree(n, unweighted = 1):
children = [[] for i in range(n)]
if unweighted:
for i in range(n-1):
[x, y] = li(lag = -1)
children[x].append(y)
children[y].append(x)
else:
for i in range(n-1):
[x, y, w] = li(lag = -1)
w += 1
children[x].append([y, w])
children[y].append([x, w])
return children
def dist(tree, n, A, B = -1):
s = [[A, 0]]
massimo, massimo_nodo = 0, 0
distanza = -1
v = [-1] * n
while s:
el, dis = s.pop()
if dis > massimo:
massimo = dis
massimo_nodo = el
if el == B:
distanza = dis
for child in tree[el]:
if v[child] == -1:
v[child] = 1
s.append([child, dis+1])
return massimo, massimo_nodo, distanza
def diameter(tree):
_, foglia, _ = dist(tree, n, 0)
diam, _, _ = dist(tree, n, foglia)
return diam
def dfs(graph, n, A):
v = [-1] * n
s = [[A, 0]]
v[A] = 0
while s:
el, dis = s.pop()
for child in graph[el]:
if v[child] == -1:
v[child] = dis + 1
s.append([child, dis + 1])
return v #visited: -1 if not visited, otherwise v[B] is the distance in terms of edges
def bfs(graph, n, A):
v = [-1] * n
s = deque()
s.append([A, 0])
v[A] = 0
while s:
el, dis = s.popleft()
for child in graph[el]:
if v[child] == -1:
v[child] = dis + 1
s.append([child, dis + 1])
return v #visited: -1 if not visited, otherwise v[B] is the distance in terms of edges
#FROM A GIVEN ROOT, RECOVER THE STRUCTURE
def parents_children_root_unrooted_tree(tree, n, root = 0):
q = deque()
visited = [0] * n
parent = [-1] * n
children = [[] for i in range(n)]
q.append(root)
while q:
all_done = 1
visited[q[0]] = 1
for child in tree[q[0]]:
if not visited[child]:
all_done = 0
q.appendleft(child)
if all_done:
for child in tree[q[0]]:
if parent[child] == -1:
parent[q[0]] = child
children[child].append(q[0])
q.popleft()
return parent, children
# CALCULATING LONGEST PATH FOR ALL THE NODES
def all_longest_path_passing_from_node(parent, children, n):
q = deque()
visited = [len(children[i]) for i in range(n)]
downwards = [[0,0] for i in range(n)]
upward = [1] * n
longest_path = [1] * n
for i in range(n):
if not visited[i]:
q.append(i)
downwards[i] = [1,0]
while q:
node = q.popleft()
if parent[node] != -1:
visited[parent[node]] -= 1
if not visited[parent[node]]:
q.append(parent[node])
else:
root = node
for child in children[node]:
downwards[node] = sorted([downwards[node][0], downwards[node][1], downwards[child][0] + 1], reverse = True)[0:2]
s = [node]
while s:
node = s.pop()
if parent[node] != -1:
if downwards[parent[node]][0] == downwards[node][0] + 1:
upward[node] = 1 + max(upward[parent[node]], downwards[parent[node]][1])
else:
upward[node] = 1 + max(upward[parent[node]], downwards[parent[node]][0])
longest_path[node] = downwards[node][0] + downwards[node][1] + upward[node] - min([downwards[node][0], downwards[node][1], upward[node]]) - 1
for child in children[node]:
s.append(child)
return longest_path
### TBD SUCCESSOR GRAPH 7.5
### TBD TREE QUERIES 10.2 da 2 a 4
### TBD ADVANCED TREE 10.3
### TBD GRAPHS AND MATRICES 11.3.3 e 11.4.3 e 11.5.3 (ON GAMES)
######################
## END OF LIBRARIES ##
######################
def p1(n, m, r):
s = 0
for i in range(1, min(m, r) + 1):
s = add(s, n % i)
return s
def p2(n, m, r):
s = 0
for i in range(1, r+1):
left = max(n // (i + 1) + 1, r + 1)
right = min(n // i, m)
if left <= right:
ml = n % left
mr = n % right
k = (ml - mr) // i
s = add(s, multiply(mr, k + 1))
s = add(s, multiply(i, k * (k + 1) // 2))
#print_list([i, s, left, right])
return s
def p3(n, m):
if m >= n:
return ((m - n) % MOD * (n % MOD)) % MOD
return 0
n, m = li()
r = int(n**0.5)
f1 = p1(n, m, r)
f2 = p2(n, m, r)
f3 = p3(n, m)
s = (f1 + f2 + f3) % MOD
#print_list([f1, f2, f3, r])
print(s % MOD)
``` | output | 1 | 23,327 | 22 | 46,655 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Calculate the value of the sum: n mod 1 + n mod 2 + n mod 3 + ... + n mod m. As the result can be very large, you should print the value modulo 109 + 7 (the remainder when divided by 109 + 7).
The modulo operator a mod b stands for the remainder after dividing a by b. For example 10 mod 3 = 1.
Input
The only line contains two integers n, m (1 ≤ n, m ≤ 1013) — the parameters of the sum.
Output
Print integer s — the value of the required sum modulo 109 + 7.
Examples
Input
3 4
Output
4
Input
4 4
Output
1
Input
1 1
Output
0 | instruction | 0 | 23,328 | 22 | 46,656 |
Tags: implementation, math, number theory
Correct Solution:
```
import math
n, m = map(int, input().split())
mod = pow(10, 9) + 7
ans = 0
if n < m:
ans = n * (m - n) % mod
m = n
ns = int(math.sqrt(n))
x = [0] * ns
f = 1
for i in range(ns):
if i + 1 > m:
f = 0
break
x[i] = n // (i + 1)
ans += (n - x[i] * (i + 1))
ans %= mod
for i in range(ns + 1, max(ns + 1, x[-1] + 1)):
ans += n % i
ans %= mod
if f:
for i in range(ns - 1):
if x[i + 1] >= m:
continue
c = x[i] - x[i + 1]
ans += ((n - x[i] * (i + 1)) * c + (i + 1) * c * (c - 1) // 2)
ans %= mod
if x[i] >= m > x[i + 1]:
c = x[i] - m
ans -= ((n - x[i] * (i + 1)) * c + (i + 1) * c * (c - 1) // 2)
ans %= mod
print(ans)
``` | output | 1 | 23,328 | 22 | 46,657 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Calculate the value of the sum: n mod 1 + n mod 2 + n mod 3 + ... + n mod m. As the result can be very large, you should print the value modulo 109 + 7 (the remainder when divided by 109 + 7).
The modulo operator a mod b stands for the remainder after dividing a by b. For example 10 mod 3 = 1.
Input
The only line contains two integers n, m (1 ≤ n, m ≤ 1013) — the parameters of the sum.
Output
Print integer s — the value of the required sum modulo 109 + 7.
Examples
Input
3 4
Output
4
Input
4 4
Output
1
Input
1 1
Output
0 | instruction | 0 | 23,329 | 22 | 46,658 |
Tags: implementation, math, number theory
Correct Solution:
```
import math
MOD = int( 1e9 + 7 )
N, M = map( int, input().split() )
sn = int( math.sqrt( N ) )
ans = N * M % MOD
for i in range( 1, min( sn, M ) + 1, 1 ):
ans -= N // i * i
ans %= MOD
if N // ( sn + 1 ) > M:
exit( print( ans ) )
for f in range( N // ( sn + 1 ), 0, -1 ):
s = lambda x: x * ( x + 1 ) // 2
if N // f > M:
ans -= f * ( s( M ) - s( N // ( f + 1 ) ) )
break
ans -= f * ( s( N // f ) - s( N // ( f + 1 ) ) )
ans %= MOD
if ans < 0:
ans += MOD
print( ans )
``` | output | 1 | 23,329 | 22 | 46,659 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Calculate the value of the sum: n mod 1 + n mod 2 + n mod 3 + ... + n mod m. As the result can be very large, you should print the value modulo 109 + 7 (the remainder when divided by 109 + 7).
The modulo operator a mod b stands for the remainder after dividing a by b. For example 10 mod 3 = 1.
Input
The only line contains two integers n, m (1 ≤ n, m ≤ 1013) — the parameters of the sum.
Output
Print integer s — the value of the required sum modulo 109 + 7.
Examples
Input
3 4
Output
4
Input
4 4
Output
1
Input
1 1
Output
0 | instruction | 0 | 23,330 | 22 | 46,660 |
Tags: implementation, math, number theory
Correct Solution:
```
from math import floor
def range_sum(low, up):
return (up * (up + 1)) // 2 - (low * (low + 1)) // 2
# for _ in range(int(input())):
mod = int(1e9 + 7)
n,m=map(int,input().split())
ans, sqrt_n = m*n, int(floor(n**0.5))
temp = 0
for i in range(1, sqrt_n + 1):
up = n // i
low = n // (i + 1)
up = min(up, m)
if(up < low):
continue
temp1 = range_sum(low, up)
temp += (temp1 * i)
for i in range(1, sqrt_n + 1):
if m < i:
break;
if n // i != i:
temp += (n // i) * i
print((ans-temp)%mod)
``` | output | 1 | 23,330 | 22 | 46,661 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Calculate the value of the sum: n mod 1 + n mod 2 + n mod 3 + ... + n mod m. As the result can be very large, you should print the value modulo 109 + 7 (the remainder when divided by 109 + 7).
The modulo operator a mod b stands for the remainder after dividing a by b. For example 10 mod 3 = 1.
Input
The only line contains two integers n, m (1 ≤ n, m ≤ 1013) — the parameters of the sum.
Output
Print integer s — the value of the required sum modulo 109 + 7.
Examples
Input
3 4
Output
4
Input
4 4
Output
1
Input
1 1
Output
0 | instruction | 0 | 23,331 | 22 | 46,662 |
Tags: implementation, math, number theory
Correct Solution:
```
from math import sqrt
def main(): #this is so hard to make pass lel
n, m = map(int, input().split())
ans, cur = 0, 2
if m >= n:
ans = n * (m - n)
m = n - 1
t = min(int(sqrt(n)) + 1, m)
while cur <= t:
ans += n % cur
cur += 1
while cur <= m:
div = n // cur
nxt = min(n // div, m)
sub = nxt - cur + 1
ans += (n % cur) * sub - div * sub * (sub - 1) // 2
cur = nxt + 1
print(ans % 1000000007)
main()
``` | output | 1 | 23,331 | 22 | 46,663 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.