message stringlengths 2 44.5k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 42 109k | cluster float64 5 5 | __index_level_0__ int64 84 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two polynomials:
* P(x) = a0·xn + a1·xn - 1 + ... + an - 1·x + an and
* Q(x) = b0·xm + b1·xm - 1 + ... + bm - 1·x + bm.
Calculate limit <image>.
Input
The first line contains two space-separated integers n and m (0 ≤ n, m ≤ 100) — degrees of polynomials P(x) and Q(x) correspondingly.
The second line contains n + 1 space-separated integers — the factors of polynomial P(x): a0, a1, ..., an - 1, an ( - 100 ≤ ai ≤ 100, a0 ≠ 0).
The third line contains m + 1 space-separated integers — the factors of polynomial Q(x): b0, b1, ..., bm - 1, bm ( - 100 ≤ bi ≤ 100, b0 ≠ 0).
Output
If the limit equals + ∞, print "Infinity" (without quotes). If the limit equals - ∞, print "-Infinity" (without the quotes).
If the value of the limit equals zero, print "0/1" (without the quotes).
Otherwise, print an irreducible fraction — the value of limit <image>, in the format "p/q" (without the quotes), where p is the — numerator, q (q > 0) is the denominator of the fraction.
Examples
Input
2 1
1 1 1
2 5
Output
Infinity
Input
1 0
-1 3
2
Output
-Infinity
Input
0 1
1
1 0
Output
0/1
Input
2 2
2 1 6
4 5 -7
Output
1/2
Input
1 1
9 0
-5 2
Output
-9/5
Note
Let's consider all samples:
1. <image>
2. <image>
3. <image>
4. <image>
5. <image>
You can learn more about the definition and properties of limits if you follow the link: http://en.wikipedia.org/wiki/Limit_of_a_function
Submitted Solution:
```
n,m = map(int,input().split())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
a0,b0 = a[0],b[0]
if n>m:
if a0*b0>0:
print("Infinity")
else:
print("-Infinity")
elif n<m:
print("0/1")
else:
for i in range(2,100):
while a0%i==0 and b0%i==0:
a0,b0 = a0//i,b0//i
if a0*b0>0:
print(str(abs(a0))+'/'+str(abs(b0)))
else:
print('-'+str(abs(a0))+'/'+str(abs(b0)))
``` | instruction | 0 | 30,363 | 5 | 60,726 |
Yes | output | 1 | 30,363 | 5 | 60,727 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two polynomials:
* P(x) = a0·xn + a1·xn - 1 + ... + an - 1·x + an and
* Q(x) = b0·xm + b1·xm - 1 + ... + bm - 1·x + bm.
Calculate limit <image>.
Input
The first line contains two space-separated integers n and m (0 ≤ n, m ≤ 100) — degrees of polynomials P(x) and Q(x) correspondingly.
The second line contains n + 1 space-separated integers — the factors of polynomial P(x): a0, a1, ..., an - 1, an ( - 100 ≤ ai ≤ 100, a0 ≠ 0).
The third line contains m + 1 space-separated integers — the factors of polynomial Q(x): b0, b1, ..., bm - 1, bm ( - 100 ≤ bi ≤ 100, b0 ≠ 0).
Output
If the limit equals + ∞, print "Infinity" (without quotes). If the limit equals - ∞, print "-Infinity" (without the quotes).
If the value of the limit equals zero, print "0/1" (without the quotes).
Otherwise, print an irreducible fraction — the value of limit <image>, in the format "p/q" (without the quotes), where p is the — numerator, q (q > 0) is the denominator of the fraction.
Examples
Input
2 1
1 1 1
2 5
Output
Infinity
Input
1 0
-1 3
2
Output
-Infinity
Input
0 1
1
1 0
Output
0/1
Input
2 2
2 1 6
4 5 -7
Output
1/2
Input
1 1
9 0
-5 2
Output
-9/5
Note
Let's consider all samples:
1. <image>
2. <image>
3. <image>
4. <image>
5. <image>
You can learn more about the definition and properties of limits if you follow the link: http://en.wikipedia.org/wiki/Limit_of_a_function
Submitted Solution:
```
n, m = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
if n < m:
print('0/1')
elif n > m:
print(('-' if a[0] < 0 else '') + 'Infinity')
else:
print(('-' if a[0] * b[0] < 0 else '') + str(abs(a[0])) + '/' + str(abs(b[0])))
``` | instruction | 0 | 30,365 | 5 | 60,730 |
No | output | 1 | 30,365 | 5 | 60,731 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two polynomials:
* P(x) = a0·xn + a1·xn - 1 + ... + an - 1·x + an and
* Q(x) = b0·xm + b1·xm - 1 + ... + bm - 1·x + bm.
Calculate limit <image>.
Input
The first line contains two space-separated integers n and m (0 ≤ n, m ≤ 100) — degrees of polynomials P(x) and Q(x) correspondingly.
The second line contains n + 1 space-separated integers — the factors of polynomial P(x): a0, a1, ..., an - 1, an ( - 100 ≤ ai ≤ 100, a0 ≠ 0).
The third line contains m + 1 space-separated integers — the factors of polynomial Q(x): b0, b1, ..., bm - 1, bm ( - 100 ≤ bi ≤ 100, b0 ≠ 0).
Output
If the limit equals + ∞, print "Infinity" (without quotes). If the limit equals - ∞, print "-Infinity" (without the quotes).
If the value of the limit equals zero, print "0/1" (without the quotes).
Otherwise, print an irreducible fraction — the value of limit <image>, in the format "p/q" (without the quotes), where p is the — numerator, q (q > 0) is the denominator of the fraction.
Examples
Input
2 1
1 1 1
2 5
Output
Infinity
Input
1 0
-1 3
2
Output
-Infinity
Input
0 1
1
1 0
Output
0/1
Input
2 2
2 1 6
4 5 -7
Output
1/2
Input
1 1
9 0
-5 2
Output
-9/5
Note
Let's consider all samples:
1. <image>
2. <image>
3. <image>
4. <image>
5. <image>
You can learn more about the definition and properties of limits if you follow the link: http://en.wikipedia.org/wiki/Limit_of_a_function
Submitted Solution:
```
from fractions import Fraction
n,m=map(int,input().split())
p=[int(q) for q in input().split()]
q=[int(w) for w in input().split()]
if n>m:
if p[0]>0:
print("Infinity")
else:
print("-Infinity")
elif n<m:
print("0/1")
else:
if p[0]%q[0]!=0:
print(Fraction(p[0],q[0]))
else:
print(str(Fraction(p[0],q[0]))+"/1")
``` | instruction | 0 | 30,366 | 5 | 60,732 |
No | output | 1 | 30,366 | 5 | 60,733 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two polynomials:
* P(x) = a0·xn + a1·xn - 1 + ... + an - 1·x + an and
* Q(x) = b0·xm + b1·xm - 1 + ... + bm - 1·x + bm.
Calculate limit <image>.
Input
The first line contains two space-separated integers n and m (0 ≤ n, m ≤ 100) — degrees of polynomials P(x) and Q(x) correspondingly.
The second line contains n + 1 space-separated integers — the factors of polynomial P(x): a0, a1, ..., an - 1, an ( - 100 ≤ ai ≤ 100, a0 ≠ 0).
The third line contains m + 1 space-separated integers — the factors of polynomial Q(x): b0, b1, ..., bm - 1, bm ( - 100 ≤ bi ≤ 100, b0 ≠ 0).
Output
If the limit equals + ∞, print "Infinity" (without quotes). If the limit equals - ∞, print "-Infinity" (without the quotes).
If the value of the limit equals zero, print "0/1" (without the quotes).
Otherwise, print an irreducible fraction — the value of limit <image>, in the format "p/q" (without the quotes), where p is the — numerator, q (q > 0) is the denominator of the fraction.
Examples
Input
2 1
1 1 1
2 5
Output
Infinity
Input
1 0
-1 3
2
Output
-Infinity
Input
0 1
1
1 0
Output
0/1
Input
2 2
2 1 6
4 5 -7
Output
1/2
Input
1 1
9 0
-5 2
Output
-9/5
Note
Let's consider all samples:
1. <image>
2. <image>
3. <image>
4. <image>
5. <image>
You can learn more about the definition and properties of limits if you follow the link: http://en.wikipedia.org/wiki/Limit_of_a_function
Submitted Solution:
```
def limit(a,b):
if len(a)>len(b):
if (a[0]>0 and b[0]>0) or (a[0]<0 and b[0]<0):
return "Infinity"
else:
return "-Infinity"
if len(b)>len(a):
return "0"+"/"+"1"
else:
c=""
if a[0]<0 and b[0]>0:
c="-"
if a[0]>0 and b[0]<0:
c="-"
a[0]=abs(a[0])
b[0]=abs(b[0])
if a[0]%b[0]==0:
return c+str(a[0]//b[0])+"/"+"1"
if b[0]%a[0]==0:
return c+"1"+"/"+str(b[0]//a[0])
else:
return c+str(a[0])+"/"+str(b[0])
a=input()
lst=list(map(int,input().strip().split()))
lst2=list(map(int,input().strip().split()))
print(limit(lst,lst2))
``` | instruction | 0 | 30,367 | 5 | 60,734 |
No | output | 1 | 30,367 | 5 | 60,735 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two polynomials:
* P(x) = a0·xn + a1·xn - 1 + ... + an - 1·x + an and
* Q(x) = b0·xm + b1·xm - 1 + ... + bm - 1·x + bm.
Calculate limit <image>.
Input
The first line contains two space-separated integers n and m (0 ≤ n, m ≤ 100) — degrees of polynomials P(x) and Q(x) correspondingly.
The second line contains n + 1 space-separated integers — the factors of polynomial P(x): a0, a1, ..., an - 1, an ( - 100 ≤ ai ≤ 100, a0 ≠ 0).
The third line contains m + 1 space-separated integers — the factors of polynomial Q(x): b0, b1, ..., bm - 1, bm ( - 100 ≤ bi ≤ 100, b0 ≠ 0).
Output
If the limit equals + ∞, print "Infinity" (without quotes). If the limit equals - ∞, print "-Infinity" (without the quotes).
If the value of the limit equals zero, print "0/1" (without the quotes).
Otherwise, print an irreducible fraction — the value of limit <image>, in the format "p/q" (without the quotes), where p is the — numerator, q (q > 0) is the denominator of the fraction.
Examples
Input
2 1
1 1 1
2 5
Output
Infinity
Input
1 0
-1 3
2
Output
-Infinity
Input
0 1
1
1 0
Output
0/1
Input
2 2
2 1 6
4 5 -7
Output
1/2
Input
1 1
9 0
-5 2
Output
-9/5
Note
Let's consider all samples:
1. <image>
2. <image>
3. <image>
4. <image>
5. <image>
You can learn more about the definition and properties of limits if you follow the link: http://en.wikipedia.org/wiki/Limit_of_a_function
Submitted Solution:
```
from fractions import Fraction
n, m = map(int, input().split())
p1 = list(map(int, input().split()))
p2 = list(map(int, input().split()))
if n > m:
if (m > 0 and n > 0) or (m < 0 and n < 0):
print('Infinity')
else:
print('-Infinity')
if m > n:
print('0'+'/1')
if n == m:
print(Fraction(p1[0], p2[0]))
``` | instruction | 0 | 30,368 | 5 | 60,736 |
No | output | 1 | 30,368 | 5 | 60,737 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a positive integer N.
Find the number of pairs (A, B) of positive integers not greater than N that satisfy the following condition:
* When A and B are written in base ten without leading zeros, the last digit of A is equal to the first digit of B, and the first digit of A is equal to the last digit of B.
Constraints
* 1 \leq N \leq 2 \times 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
25
Output
17
Input
1
Output
1
Input
100
Output
108
Input
2020
Output
40812
Input
200000
Output
400000008 | instruction | 0 | 30,719 | 5 | 61,438 |
"Correct Solution:
```
n = int(input())
c = [[0] * 10 for _ in range(10)]
for i in range(1, n+1):
c[int(str(i)[0])][int(str(i)[-1])] += 1
ans = 0
for i in range(10):
for j in range(10):
ans += c[i][j] * c[j][i]
print(ans)
``` | output | 1 | 30,719 | 5 | 61,439 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a positive integer N.
Find the number of pairs (A, B) of positive integers not greater than N that satisfy the following condition:
* When A and B are written in base ten without leading zeros, the last digit of A is equal to the first digit of B, and the first digit of A is equal to the last digit of B.
Constraints
* 1 \leq N \leq 2 \times 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
25
Output
17
Input
1
Output
1
Input
100
Output
108
Input
2020
Output
40812
Input
200000
Output
400000008 | instruction | 0 | 30,720 | 5 | 61,440 |
"Correct Solution:
```
N = int(input())
c = [[0]*10 for _ in range(10)]
for k in range(1,N+1):
c[int(str(k)[0])][int(str(k)[-1])]+=1
ans = 0
for k in range(81):
i = k // 9 + 1
j = k % 9 + 1
ans += c[i][j] * c[j][i]
print(ans)
``` | output | 1 | 30,720 | 5 | 61,441 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a positive integer N.
Find the number of pairs (A, B) of positive integers not greater than N that satisfy the following condition:
* When A and B are written in base ten without leading zeros, the last digit of A is equal to the first digit of B, and the first digit of A is equal to the last digit of B.
Constraints
* 1 \leq N \leq 2 \times 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
25
Output
17
Input
1
Output
1
Input
100
Output
108
Input
2020
Output
40812
Input
200000
Output
400000008 | instruction | 0 | 30,721 | 5 | 61,442 |
"Correct Solution:
```
l=[0]*100;r=range(10)
for i in range(int(input())):
s=str(i+1);l[int(s[0]+s[-1])]+=1
print(sum([l[i*10+j]*l[j*10+i]for i in r for j in r]))
``` | output | 1 | 30,721 | 5 | 61,443 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a positive integer N.
Find the number of pairs (A, B) of positive integers not greater than N that satisfy the following condition:
* When A and B are written in base ten without leading zeros, the last digit of A is equal to the first digit of B, and the first digit of A is equal to the last digit of B.
Constraints
* 1 \leq N \leq 2 \times 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
25
Output
17
Input
1
Output
1
Input
100
Output
108
Input
2020
Output
40812
Input
200000
Output
400000008 | instruction | 0 | 30,722 | 5 | 61,444 |
"Correct Solution:
```
N=int(input())
A=[[0 for i in range(10)] for j in range(10)]
for i in range(1,N+1):
i=str(i)
ii=len(i)
A[int(i[0])][int(i[ii-1])]+=1
ans=0
for i in range(10):
for j in range(10):
ans+=A[i][j]*A[j][i]
print(ans)
``` | output | 1 | 30,722 | 5 | 61,445 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a positive integer N.
Find the number of pairs (A, B) of positive integers not greater than N that satisfy the following condition:
* When A and B are written in base ten without leading zeros, the last digit of A is equal to the first digit of B, and the first digit of A is equal to the last digit of B.
Constraints
* 1 \leq N \leq 2 \times 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
25
Output
17
Input
1
Output
1
Input
100
Output
108
Input
2020
Output
40812
Input
200000
Output
400000008 | instruction | 0 | 30,723 | 5 | 61,446 |
"Correct Solution:
```
n=int(input())
a=[[0]*9 for _ in range(9)]
for i in range(1,n+1):
s=str(i)
l=int(s[0])
r=int(s[len(s)-1])
if l*r!=0:
a[l-1][r-1]+=1
x=0
for i in range(9):
for j in range(9):
x+=a[i][j]*a[j][i]
print(x)
``` | output | 1 | 30,723 | 5 | 61,447 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a positive integer N.
Find the number of pairs (A, B) of positive integers not greater than N that satisfy the following condition:
* When A and B are written in base ten without leading zeros, the last digit of A is equal to the first digit of B, and the first digit of A is equal to the last digit of B.
Constraints
* 1 \leq N \leq 2 \times 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
25
Output
17
Input
1
Output
1
Input
100
Output
108
Input
2020
Output
40812
Input
200000
Output
400000008 | instruction | 0 | 30,724 | 5 | 61,448 |
"Correct Solution:
```
n = int(input())
ans = 0
d = {}
for i in range(1,n+1):
t = str(i)
key = t[0]+t[-1]
if "0" not in key:
d[key] = d.get(key,0) + 1
for k in d:
k2 = k[1]+k[0]
ans += d[k]*d.get(k2,0)
print(ans)
``` | output | 1 | 30,724 | 5 | 61,449 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a positive integer N.
Find the number of pairs (A, B) of positive integers not greater than N that satisfy the following condition:
* When A and B are written in base ten without leading zeros, the last digit of A is equal to the first digit of B, and the first digit of A is equal to the last digit of B.
Constraints
* 1 \leq N \leq 2 \times 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
25
Output
17
Input
1
Output
1
Input
100
Output
108
Input
2020
Output
40812
Input
200000
Output
400000008 | instruction | 0 | 30,725 | 5 | 61,450 |
"Correct Solution:
```
n=int(input())
count=0
ab=[[0]*10 for i in range(10)]
for i in range(1,n+1):
k=str(i)
a=int(k[0])
b=int(k[-1])
ab[b][a]+=1
#print(ab)
for i in range(10):
for j in range(10):
count+=ab[i][j]*(ab[j][i])
print(count)
``` | output | 1 | 30,725 | 5 | 61,451 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a positive integer N.
Find the number of pairs (A, B) of positive integers not greater than N that satisfy the following condition:
* When A and B are written in base ten without leading zeros, the last digit of A is equal to the first digit of B, and the first digit of A is equal to the last digit of B.
Constraints
* 1 \leq N \leq 2 \times 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
25
Output
17
Input
1
Output
1
Input
100
Output
108
Input
2020
Output
40812
Input
200000
Output
400000008 | instruction | 0 | 30,726 | 5 | 61,452 |
"Correct Solution:
```
n=int(input())
l=[[0]*10 for i in range(10)]
for i in range(n):
t=str(i+1)
l[int(t[0])][int(t[-1])]+=1
a=0
for i in range(10):
for j in range(10):
a+=l[i][j]*l[j][i]
print(a)
``` | output | 1 | 30,726 | 5 | 61,453 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a positive integer N.
Find the number of pairs (A, B) of positive integers not greater than N that satisfy the following condition:
* When A and B are written in base ten without leading zeros, the last digit of A is equal to the first digit of B, and the first digit of A is equal to the last digit of B.
Constraints
* 1 \leq N \leq 2 \times 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
25
Output
17
Input
1
Output
1
Input
100
Output
108
Input
2020
Output
40812
Input
200000
Output
400000008
Submitted Solution:
```
n=int(input())
D=[[0 for _ in range(10)] for _ in range(10)]
for i in range(1,n+1):
s=str(i)
D[int(s[0])][int(s[-1])]+=1
a=0
for i in range(10):
for j in range(10):
a+=D[i][j]*D[j][i]
print(a)
``` | instruction | 0 | 30,727 | 5 | 61,454 |
Yes | output | 1 | 30,727 | 5 | 61,455 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a positive integer N.
Find the number of pairs (A, B) of positive integers not greater than N that satisfy the following condition:
* When A and B are written in base ten without leading zeros, the last digit of A is equal to the first digit of B, and the first digit of A is equal to the last digit of B.
Constraints
* 1 \leq N \leq 2 \times 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
25
Output
17
Input
1
Output
1
Input
100
Output
108
Input
2020
Output
40812
Input
200000
Output
400000008
Submitted Solution:
```
N = int(input())
X = [[0 for j in range(10)] for i in range(10)]
for k in range(1,N+1):
X[int(str(k)[0])][int(str(k)[-1])] +=1
Ans = 0
for i in range(10):
for j in range(10):
Ans += X[i][j]*X[j][i]
print(Ans)
``` | instruction | 0 | 30,728 | 5 | 61,456 |
Yes | output | 1 | 30,728 | 5 | 61,457 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a positive integer N.
Find the number of pairs (A, B) of positive integers not greater than N that satisfy the following condition:
* When A and B are written in base ten without leading zeros, the last digit of A is equal to the first digit of B, and the first digit of A is equal to the last digit of B.
Constraints
* 1 \leq N \leq 2 \times 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
25
Output
17
Input
1
Output
1
Input
100
Output
108
Input
2020
Output
40812
Input
200000
Output
400000008
Submitted Solution:
```
n = int(input())
g = [[0]*10 for _ in range(10)]
for i in range(1,1+n):
a = int(str(i)[0])
b = i%10
g[a][b] += 1
ans = sum(g[a][b]*g[b][a] for a in range(10) for b in range(10))
print(ans)
``` | instruction | 0 | 30,729 | 5 | 61,458 |
Yes | output | 1 | 30,729 | 5 | 61,459 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a positive integer N.
Find the number of pairs (A, B) of positive integers not greater than N that satisfy the following condition:
* When A and B are written in base ten without leading zeros, the last digit of A is equal to the first digit of B, and the first digit of A is equal to the last digit of B.
Constraints
* 1 \leq N \leq 2 \times 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
25
Output
17
Input
1
Output
1
Input
100
Output
108
Input
2020
Output
40812
Input
200000
Output
400000008
Submitted Solution:
```
def II(): return int(input())
N=II()
tbl=[0]*101
for i in range(1,N+1):
i=str(i)
tbl[int(str(i[0]+i[-1]))]+=1
ans=0
for i in range(1,N+1):
i=str(i)
ans+=tbl[int(str(i[-1]+i[0]))]
print(ans)
``` | instruction | 0 | 30,730 | 5 | 61,460 |
Yes | output | 1 | 30,730 | 5 | 61,461 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a positive integer N.
Find the number of pairs (A, B) of positive integers not greater than N that satisfy the following condition:
* When A and B are written in base ten without leading zeros, the last digit of A is equal to the first digit of B, and the first digit of A is equal to the last digit of B.
Constraints
* 1 \leq N \leq 2 \times 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
25
Output
17
Input
1
Output
1
Input
100
Output
108
Input
2020
Output
40812
Input
200000
Output
400000008
Submitted Solution:
```
n=int(input())
c=[[0]*10]*10
for i in range(1,n+1):
for j in range(1,10):
for k in range(1,10):
if str(i)[0]==str(j) and str(i)[len(str(i))-1]==str(k):
c[j][k]+=1
num=0
for j in range(1,10):
for k in range(1,10):
num+=c[j][k]*c[k][j]
print(num)
``` | instruction | 0 | 30,731 | 5 | 61,462 |
No | output | 1 | 30,731 | 5 | 61,463 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a positive integer N.
Find the number of pairs (A, B) of positive integers not greater than N that satisfy the following condition:
* When A and B are written in base ten without leading zeros, the last digit of A is equal to the first digit of B, and the first digit of A is equal to the last digit of B.
Constraints
* 1 \leq N \leq 2 \times 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
25
Output
17
Input
1
Output
1
Input
100
Output
108
Input
2020
Output
40812
Input
200000
Output
400000008
Submitted Solution:
```
N = input()
M = int(N[0])
L = len(N)
cond_l = [[],[],[],[],[],[],[],[],[]]
for i in range(1,10):
for j in range(1,10):
t = 0
if i == j:
t += 1
if i < M:
for k in range(2, L+1):
t += 10 ** (k - 2)
elif i > M:
for k in range(2, L):
t += 10 ** (k - 2)
else:
for k in range(2, L):
t += 10 ** (k - 2)
if L >= 2:
t_2 = 1
for k in range(1, L-2):
t_2 *= int(N[k]) + 1
if L >= 3 and j <= int(N[-1]):
t_2 *= int(N[L-2]) + 1
elif L >= 3:
t_2 *= int(N[L-2])
t += t_2
cond_l[i-1].append(t)
ans = 0
for i in range(9):
ans += cond_l[i][i] ** 2
for i in range(8):
for j in range(i+1, 9):
ans += cond_l[i][j] * cond_l[j][i] * 2
print(ans)
``` | instruction | 0 | 30,732 | 5 | 61,464 |
No | output | 1 | 30,732 | 5 | 61,465 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a positive integer N.
Find the number of pairs (A, B) of positive integers not greater than N that satisfy the following condition:
* When A and B are written in base ten without leading zeros, the last digit of A is equal to the first digit of B, and the first digit of A is equal to the last digit of B.
Constraints
* 1 \leq N \leq 2 \times 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
25
Output
17
Input
1
Output
1
Input
100
Output
108
Input
2020
Output
40812
Input
200000
Output
400000008
Submitted Solution:
```
def n0():return int(input())
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(input()) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]
n=n0()
length=len(str(n))
ans=0
for i in range(1,10):
if n<i:
break
s=0
for j in range(1,length+1):
if j<=1:
s+=1
elif j<length:
s+=(10**(j-2))
else:
for m in range(n,10**(length-1),-1):
if str(m)[0]==str(m)[-1]==str(i):
s+=1
ans+=s*s
for i1 in range(1,10):
for i2 in range(1,10):
if i1==i2:
break;
s1=0
s2=0
for j in range(2,length+1):
if j<length:
s1+=10**(j-2)
s2+=10**(j-2)
else:
for m in range(n,10**(length-1),-1):
if str(m)[0]==str(i1) and str(m)[-1]==str(i2):
s1+=1
elif str(m)[0]==str(i2) and str(m)[-1]==str(i1):
s2+=1
ans+=s1*s2*2
print(ans)
``` | instruction | 0 | 30,733 | 5 | 61,466 |
No | output | 1 | 30,733 | 5 | 61,467 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a positive integer N.
Find the number of pairs (A, B) of positive integers not greater than N that satisfy the following condition:
* When A and B are written in base ten without leading zeros, the last digit of A is equal to the first digit of B, and the first digit of A is equal to the last digit of B.
Constraints
* 1 \leq N \leq 2 \times 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
25
Output
17
Input
1
Output
1
Input
100
Output
108
Input
2020
Output
40812
Input
200000
Output
400000008
Submitted Solution:
```
n = 20000
dict_par = dict()
for i in range(1,10):
i = str(i)
for k in range(1,10):
k = str(k)
dict_par[i+k] = 0
for num in range(1, n+1):
num = str(num)
if (num[0] == i) & (num[-1] ==k):
dict_par[i+k] +=1
ans = 0
for i in range(1,10):
i = str(i)
for k in range(1,10):
k = str(k)
ans+= dict_par[i+k] * dict_par[k+i]
print(ans)
``` | instruction | 0 | 30,734 | 5 | 61,468 |
No | output | 1 | 30,734 | 5 | 61,469 |
Provide a correct Python 3 solution for this coding contest problem.
We have a sequence of N integers A~=~A_0,~A_1,~...,~A_{N - 1}.
Let B be a sequence of K \times N integers obtained by concatenating K copies of A. For example, if A~=~1,~3,~2 and K~=~2, B~=~1,~3,~2,~1,~3,~2.
Find the inversion number of B, modulo 10^9 + 7.
Here the inversion number of B is defined as the number of ordered pairs of integers (i,~j)~(0 \leq i < j \leq K \times N - 1) such that B_i > B_j.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2000
* 1 \leq K \leq 10^9
* 1 \leq A_i \leq 2000
Input
Input is given from Standard Input in the following format:
N K
A_0 A_1 ... A_{N - 1}
Output
Print the inversion number of B, modulo 10^9 + 7.
Examples
Input
2 2
2 1
Output
3
Input
3 5
1 1 1
Output
0
Input
10 998244353
10 9 8 7 5 6 3 4 2 1
Output
185297239 | instruction | 0 | 30,735 | 5 | 61,470 |
"Correct Solution:
```
mod = 10**9 + 7
N, K = map(int,input().split())
A = list(map(int,input().split()))
a = 0
b = 0
for i in range(N):
for j in range(i+1,N):
if A[i] > A[j]:
a += 1
elif A[i] < A[j]:
b += 1
ans = a*K*(K+1)//2 + b*(K-1)*K//2
ans %= mod
print(ans)
``` | output | 1 | 30,735 | 5 | 61,471 |
Provide a correct Python 3 solution for this coding contest problem.
We have a sequence of N integers A~=~A_0,~A_1,~...,~A_{N - 1}.
Let B be a sequence of K \times N integers obtained by concatenating K copies of A. For example, if A~=~1,~3,~2 and K~=~2, B~=~1,~3,~2,~1,~3,~2.
Find the inversion number of B, modulo 10^9 + 7.
Here the inversion number of B is defined as the number of ordered pairs of integers (i,~j)~(0 \leq i < j \leq K \times N - 1) such that B_i > B_j.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2000
* 1 \leq K \leq 10^9
* 1 \leq A_i \leq 2000
Input
Input is given from Standard Input in the following format:
N K
A_0 A_1 ... A_{N - 1}
Output
Print the inversion number of B, modulo 10^9 + 7.
Examples
Input
2 2
2 1
Output
3
Input
3 5
1 1 1
Output
0
Input
10 998244353
10 9 8 7 5 6 3 4 2 1
Output
185297239 | instruction | 0 | 30,736 | 5 | 61,472 |
"Correct Solution:
```
MOD=10**9+7
N,K=map(int,input().split())
A=list(map(int,input().split()))
ans=0
for i in range(N-1):
for j in range(i+1,N):
if A[i]>A[j]:
ans+=((K+1)*K//2)%MOD
elif A[i]<A[j]:
ans+=(K*(K-1)//2)%MOD
print(ans%MOD)
``` | output | 1 | 30,736 | 5 | 61,473 |
Provide a correct Python 3 solution for this coding contest problem.
We have a sequence of N integers A~=~A_0,~A_1,~...,~A_{N - 1}.
Let B be a sequence of K \times N integers obtained by concatenating K copies of A. For example, if A~=~1,~3,~2 and K~=~2, B~=~1,~3,~2,~1,~3,~2.
Find the inversion number of B, modulo 10^9 + 7.
Here the inversion number of B is defined as the number of ordered pairs of integers (i,~j)~(0 \leq i < j \leq K \times N - 1) such that B_i > B_j.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2000
* 1 \leq K \leq 10^9
* 1 \leq A_i \leq 2000
Input
Input is given from Standard Input in the following format:
N K
A_0 A_1 ... A_{N - 1}
Output
Print the inversion number of B, modulo 10^9 + 7.
Examples
Input
2 2
2 1
Output
3
Input
3 5
1 1 1
Output
0
Input
10 998244353
10 9 8 7 5 6 3 4 2 1
Output
185297239 | instruction | 0 | 30,737 | 5 | 61,474 |
"Correct Solution:
```
P = (10**9)+7
N,K = map(int,input().split())
A = list(map(int,input().split()))
res_p = 0
res_n = 0
for i in range(N):
for j in range(i+1,N):
if A[i]>A[j]:
res_p += 1
if A[-i-1]>A[-j-1]:
res_n += 1
res = (res_p + res_n) * K * (K+1) // 2 - (K * res_n)
print(res % P)
``` | output | 1 | 30,737 | 5 | 61,475 |
Provide a correct Python 3 solution for this coding contest problem.
We have a sequence of N integers A~=~A_0,~A_1,~...,~A_{N - 1}.
Let B be a sequence of K \times N integers obtained by concatenating K copies of A. For example, if A~=~1,~3,~2 and K~=~2, B~=~1,~3,~2,~1,~3,~2.
Find the inversion number of B, modulo 10^9 + 7.
Here the inversion number of B is defined as the number of ordered pairs of integers (i,~j)~(0 \leq i < j \leq K \times N - 1) such that B_i > B_j.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2000
* 1 \leq K \leq 10^9
* 1 \leq A_i \leq 2000
Input
Input is given from Standard Input in the following format:
N K
A_0 A_1 ... A_{N - 1}
Output
Print the inversion number of B, modulo 10^9 + 7.
Examples
Input
2 2
2 1
Output
3
Input
3 5
1 1 1
Output
0
Input
10 998244353
10 9 8 7 5 6 3 4 2 1
Output
185297239 | instruction | 0 | 30,738 | 5 | 61,476 |
"Correct Solution:
```
n, k = map(int, input().split())
a = list(map(int, input().split()))
# 内部の転倒数
ls = a[:]
inner = 0
while ls:
x = ls.pop(0)
inner += sum(1 if x > y else 0 for y in ls)
# 外部の転倒数
outer = 0
for x in a:
for y in a:
if x > y:
outer += 1
print((inner*k + outer*(k-1)*k//2) % (10**9+7))
``` | output | 1 | 30,738 | 5 | 61,477 |
Provide a correct Python 3 solution for this coding contest problem.
We have a sequence of N integers A~=~A_0,~A_1,~...,~A_{N - 1}.
Let B be a sequence of K \times N integers obtained by concatenating K copies of A. For example, if A~=~1,~3,~2 and K~=~2, B~=~1,~3,~2,~1,~3,~2.
Find the inversion number of B, modulo 10^9 + 7.
Here the inversion number of B is defined as the number of ordered pairs of integers (i,~j)~(0 \leq i < j \leq K \times N - 1) such that B_i > B_j.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2000
* 1 \leq K \leq 10^9
* 1 \leq A_i \leq 2000
Input
Input is given from Standard Input in the following format:
N K
A_0 A_1 ... A_{N - 1}
Output
Print the inversion number of B, modulo 10^9 + 7.
Examples
Input
2 2
2 1
Output
3
Input
3 5
1 1 1
Output
0
Input
10 998244353
10 9 8 7 5 6 3 4 2 1
Output
185297239 | instruction | 0 | 30,739 | 5 | 61,478 |
"Correct Solution:
```
n,k=map(int,input().split())
a=list(map(int,input().split()))
m=10**9+7
print(sum((((sum(a[i]>j for j in a[i:])*(k*(k+1)//2)%m)+(sum(a[i]>j for j in a[:i+1])*(k*(k-1)//2)%m))%m) for i in range(n))%m)
``` | output | 1 | 30,739 | 5 | 61,479 |
Provide a correct Python 3 solution for this coding contest problem.
We have a sequence of N integers A~=~A_0,~A_1,~...,~A_{N - 1}.
Let B be a sequence of K \times N integers obtained by concatenating K copies of A. For example, if A~=~1,~3,~2 and K~=~2, B~=~1,~3,~2,~1,~3,~2.
Find the inversion number of B, modulo 10^9 + 7.
Here the inversion number of B is defined as the number of ordered pairs of integers (i,~j)~(0 \leq i < j \leq K \times N - 1) such that B_i > B_j.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2000
* 1 \leq K \leq 10^9
* 1 \leq A_i \leq 2000
Input
Input is given from Standard Input in the following format:
N K
A_0 A_1 ... A_{N - 1}
Output
Print the inversion number of B, modulo 10^9 + 7.
Examples
Input
2 2
2 1
Output
3
Input
3 5
1 1 1
Output
0
Input
10 998244353
10 9 8 7 5 6 3 4 2 1
Output
185297239 | instruction | 0 | 30,740 | 5 | 61,480 |
"Correct Solution:
```
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
div = 1000000007
s = 0
ss = 0
for i, a in enumerate(A):
for j in range(i+1, N):
if a > A[j]:
s += 1
for i in A:
for j in A:
if i > j:
ss += 1
print(((s * K) + (ss * K * (K-1) // 2)) % div)
``` | output | 1 | 30,740 | 5 | 61,481 |
Provide a correct Python 3 solution for this coding contest problem.
We have a sequence of N integers A~=~A_0,~A_1,~...,~A_{N - 1}.
Let B be a sequence of K \times N integers obtained by concatenating K copies of A. For example, if A~=~1,~3,~2 and K~=~2, B~=~1,~3,~2,~1,~3,~2.
Find the inversion number of B, modulo 10^9 + 7.
Here the inversion number of B is defined as the number of ordered pairs of integers (i,~j)~(0 \leq i < j \leq K \times N - 1) such that B_i > B_j.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2000
* 1 \leq K \leq 10^9
* 1 \leq A_i \leq 2000
Input
Input is given from Standard Input in the following format:
N K
A_0 A_1 ... A_{N - 1}
Output
Print the inversion number of B, modulo 10^9 + 7.
Examples
Input
2 2
2 1
Output
3
Input
3 5
1 1 1
Output
0
Input
10 998244353
10 9 8 7 5 6 3 4 2 1
Output
185297239 | instruction | 0 | 30,741 | 5 | 61,482 |
"Correct Solution:
```
n,k=map(int,input().split())
a=list(map(int,input().split()))
mod=10**9+7
inner=0
for i in range(n-1):
for j in range(i+1,n):
if a[i]>a[j]:
inner+=1
outer=0
for i in range(n):
for j in range(n):
if a[i]>a[j]:
outer+=1
ans=inner*k + outer*k*(k-1)//2
print(ans%mod)
#print(inner,' ',outer)
``` | output | 1 | 30,741 | 5 | 61,483 |
Provide a correct Python 3 solution for this coding contest problem.
We have a sequence of N integers A~=~A_0,~A_1,~...,~A_{N - 1}.
Let B be a sequence of K \times N integers obtained by concatenating K copies of A. For example, if A~=~1,~3,~2 and K~=~2, B~=~1,~3,~2,~1,~3,~2.
Find the inversion number of B, modulo 10^9 + 7.
Here the inversion number of B is defined as the number of ordered pairs of integers (i,~j)~(0 \leq i < j \leq K \times N - 1) such that B_i > B_j.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2000
* 1 \leq K \leq 10^9
* 1 \leq A_i \leq 2000
Input
Input is given from Standard Input in the following format:
N K
A_0 A_1 ... A_{N - 1}
Output
Print the inversion number of B, modulo 10^9 + 7.
Examples
Input
2 2
2 1
Output
3
Input
3 5
1 1 1
Output
0
Input
10 998244353
10 9 8 7 5 6 3 4 2 1
Output
185297239 | instruction | 0 | 30,742 | 5 | 61,484 |
"Correct Solution:
```
N,K = (int(i) for i in input().split())
A = [int(i) for i in input().split()]
mod = 10**9+7
ans = 0
for i in range(N):
bs = [1 if g < A[i] else 0 for g in A]
ans += (K+1)*K*sum(bs)//2 - sum(bs[:i])*K
print(int(ans)%mod)
``` | output | 1 | 30,742 | 5 | 61,485 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a sequence of N integers A~=~A_0,~A_1,~...,~A_{N - 1}.
Let B be a sequence of K \times N integers obtained by concatenating K copies of A. For example, if A~=~1,~3,~2 and K~=~2, B~=~1,~3,~2,~1,~3,~2.
Find the inversion number of B, modulo 10^9 + 7.
Here the inversion number of B is defined as the number of ordered pairs of integers (i,~j)~(0 \leq i < j \leq K \times N - 1) such that B_i > B_j.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2000
* 1 \leq K \leq 10^9
* 1 \leq A_i \leq 2000
Input
Input is given from Standard Input in the following format:
N K
A_0 A_1 ... A_{N - 1}
Output
Print the inversion number of B, modulo 10^9 + 7.
Examples
Input
2 2
2 1
Output
3
Input
3 5
1 1 1
Output
0
Input
10 998244353
10 9 8 7 5 6 3 4 2 1
Output
185297239
Submitted Solution:
```
n,k = map(int,input().split())
ls = list(map(int,input().split()))
mod = 10**9+7
ans = 0
for i in range(n):
a = 0
b = 0
for j in range(n):
if j < i and ls[j] < ls[i]:
a += 1
if ls[j] < ls[i]:
b += 1
a = b-a
ans += (a+b*k)*k-b*(1+k)*k//2
ans %= mod
print(ans)
``` | instruction | 0 | 30,743 | 5 | 61,486 |
Yes | output | 1 | 30,743 | 5 | 61,487 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a sequence of N integers A~=~A_0,~A_1,~...,~A_{N - 1}.
Let B be a sequence of K \times N integers obtained by concatenating K copies of A. For example, if A~=~1,~3,~2 and K~=~2, B~=~1,~3,~2,~1,~3,~2.
Find the inversion number of B, modulo 10^9 + 7.
Here the inversion number of B is defined as the number of ordered pairs of integers (i,~j)~(0 \leq i < j \leq K \times N - 1) such that B_i > B_j.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2000
* 1 \leq K \leq 10^9
* 1 \leq A_i \leq 2000
Input
Input is given from Standard Input in the following format:
N K
A_0 A_1 ... A_{N - 1}
Output
Print the inversion number of B, modulo 10^9 + 7.
Examples
Input
2 2
2 1
Output
3
Input
3 5
1 1 1
Output
0
Input
10 998244353
10 9 8 7 5 6 3 4 2 1
Output
185297239
Submitted Solution:
```
n,k=map(int,input().split())
a=list(map(int,input().split()))
cntin=0
cntot=0
mod=10**9+7
for i in range(n-1):
for j in range(i+1,n):
if a[i]<a[j]:
cntot+=1
elif a[i]>a[j]:
cntin+=1
print((cntin*((k*(k+1))//2)%mod+cntot*((k*(k-1))//2)%mod)%mod)
``` | instruction | 0 | 30,744 | 5 | 61,488 |
Yes | output | 1 | 30,744 | 5 | 61,489 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a sequence of N integers A~=~A_0,~A_1,~...,~A_{N - 1}.
Let B be a sequence of K \times N integers obtained by concatenating K copies of A. For example, if A~=~1,~3,~2 and K~=~2, B~=~1,~3,~2,~1,~3,~2.
Find the inversion number of B, modulo 10^9 + 7.
Here the inversion number of B is defined as the number of ordered pairs of integers (i,~j)~(0 \leq i < j \leq K \times N - 1) such that B_i > B_j.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2000
* 1 \leq K \leq 10^9
* 1 \leq A_i \leq 2000
Input
Input is given from Standard Input in the following format:
N K
A_0 A_1 ... A_{N - 1}
Output
Print the inversion number of B, modulo 10^9 + 7.
Examples
Input
2 2
2 1
Output
3
Input
3 5
1 1 1
Output
0
Input
10 998244353
10 9 8 7 5 6 3 4 2 1
Output
185297239
Submitted Solution:
```
n,k=map(int,input().split())
alis=list(map(int,input().split()))
a=0
b=0
for i in range(n-1):
for j in range(n-1-i):
if alis[i]>alis[i+1+j]:
a+=1
elif alis[i]<alis[i+j+1]:
b+=1
aa=(a*k*(k+1)//2)%(10**9+7)
bb=(b*k*(k-1)//2)%(10**9+7)
ans=(aa+bb)%(10**9+7)
print(int(ans))
``` | instruction | 0 | 30,745 | 5 | 61,490 |
Yes | output | 1 | 30,745 | 5 | 61,491 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a sequence of N integers A~=~A_0,~A_1,~...,~A_{N - 1}.
Let B be a sequence of K \times N integers obtained by concatenating K copies of A. For example, if A~=~1,~3,~2 and K~=~2, B~=~1,~3,~2,~1,~3,~2.
Find the inversion number of B, modulo 10^9 + 7.
Here the inversion number of B is defined as the number of ordered pairs of integers (i,~j)~(0 \leq i < j \leq K \times N - 1) such that B_i > B_j.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2000
* 1 \leq K \leq 10^9
* 1 \leq A_i \leq 2000
Input
Input is given from Standard Input in the following format:
N K
A_0 A_1 ... A_{N - 1}
Output
Print the inversion number of B, modulo 10^9 + 7.
Examples
Input
2 2
2 1
Output
3
Input
3 5
1 1 1
Output
0
Input
10 998244353
10 9 8 7 5 6 3 4 2 1
Output
185297239
Submitted Solution:
```
n,k=map(int, input().split())
a=list(map(int, input().split()))
ans=0
x=0
y=0
for i in range(n):
for j in range(n):
if a[i]>a[j] and i>j:
x+=1
if a[i]>a[j] and i<j:
y+=1
ans+=(x*(k-1)*k//2+y*k*(k+1)//2)%(10**9+7)
print(ans)
``` | instruction | 0 | 30,746 | 5 | 61,492 |
Yes | output | 1 | 30,746 | 5 | 61,493 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a sequence of N integers A~=~A_0,~A_1,~...,~A_{N - 1}.
Let B be a sequence of K \times N integers obtained by concatenating K copies of A. For example, if A~=~1,~3,~2 and K~=~2, B~=~1,~3,~2,~1,~3,~2.
Find the inversion number of B, modulo 10^9 + 7.
Here the inversion number of B is defined as the number of ordered pairs of integers (i,~j)~(0 \leq i < j \leq K \times N - 1) such that B_i > B_j.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2000
* 1 \leq K \leq 10^9
* 1 \leq A_i \leq 2000
Input
Input is given from Standard Input in the following format:
N K
A_0 A_1 ... A_{N - 1}
Output
Print the inversion number of B, modulo 10^9 + 7.
Examples
Input
2 2
2 1
Output
3
Input
3 5
1 1 1
Output
0
Input
10 998244353
10 9 8 7 5 6 3 4 2 1
Output
185297239
Submitted Solution:
```
N, K = map(int, input().split())
A = list(map(int, input().split()))
count1 = 0
for i in range(N):
for j in range(i + 1, N):
# print(i, j)
if A[i] > A[j]:
# print(A[i], A[j])
count1 += 1
# print(count1)
A2 = A + A[::]
count2 = 0
for i in range(N * 2):
for j in range(i + 1, N * 2):
# print(i, j)
if A2[i] > A2[j]:
# print(A[i], A[j])
count2 += 1
# print(count2)
A3 = A + A[::] + A[::]
count3 = 0
for i in range(N * 3):
for j in range(i + 1, N * 3):
if A3[i] > A3[j]:
count3 += 1
# print(count3)
diff1 = count2 - count1
diff2 = count3 - count2
diffx = diff2 - diff1
bn_last = diff1 + diffx * (K - 2)
# print(bn_last)
bn_sum = ((diff1 + bn_last) * (K - 1)) // 2
# print(bn_sum)
an_sum = count1 + bn_sum
if K == 1:
print(count1)
elif K == 2:
print(count2)
else:
print(an_sum % ((10 ** 9) + 7))
``` | instruction | 0 | 30,747 | 5 | 61,494 |
No | output | 1 | 30,747 | 5 | 61,495 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a sequence of N integers A~=~A_0,~A_1,~...,~A_{N - 1}.
Let B be a sequence of K \times N integers obtained by concatenating K copies of A. For example, if A~=~1,~3,~2 and K~=~2, B~=~1,~3,~2,~1,~3,~2.
Find the inversion number of B, modulo 10^9 + 7.
Here the inversion number of B is defined as the number of ordered pairs of integers (i,~j)~(0 \leq i < j \leq K \times N - 1) such that B_i > B_j.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2000
* 1 \leq K \leq 10^9
* 1 \leq A_i \leq 2000
Input
Input is given from Standard Input in the following format:
N K
A_0 A_1 ... A_{N - 1}
Output
Print the inversion number of B, modulo 10^9 + 7.
Examples
Input
2 2
2 1
Output
3
Input
3 5
1 1 1
Output
0
Input
10 998244353
10 9 8 7 5 6 3 4 2 1
Output
185297239
Submitted Solution:
```
def main():
n,k = map(int,input().split())
arr = list(map(int,input().split()))
mod = 10**9+7
ans = 0
for i in range(n):
for j in range(i+1,n):
if arr[i] > arr[j]:
ans += 1
ans = ans*k
ans = ans%mod
dist = {}
for i in arr:
if i not in dist.keys():
dist[i] = 1
else:
dist[i] += 1
arr = []
for i in dist.keys():
arr.append((i,dist[i]))
arr.sort(reverse = True)
count = 0
total = 0
for i in arr:
total += i[1]
for i in arr:
total -= i[1]
count += total
count = count*k*(k-1)//2
count = count%mod
ans += count
print(ans%mod)
main()
``` | instruction | 0 | 30,748 | 5 | 61,496 |
No | output | 1 | 30,748 | 5 | 61,497 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a sequence of N integers A~=~A_0,~A_1,~...,~A_{N - 1}.
Let B be a sequence of K \times N integers obtained by concatenating K copies of A. For example, if A~=~1,~3,~2 and K~=~2, B~=~1,~3,~2,~1,~3,~2.
Find the inversion number of B, modulo 10^9 + 7.
Here the inversion number of B is defined as the number of ordered pairs of integers (i,~j)~(0 \leq i < j \leq K \times N - 1) such that B_i > B_j.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2000
* 1 \leq K \leq 10^9
* 1 \leq A_i \leq 2000
Input
Input is given from Standard Input in the following format:
N K
A_0 A_1 ... A_{N - 1}
Output
Print the inversion number of B, modulo 10^9 + 7.
Examples
Input
2 2
2 1
Output
3
Input
3 5
1 1 1
Output
0
Input
10 998244353
10 9 8 7 5 6 3 4 2 1
Output
185297239
Submitted Solution:
```
n,k = map(int,input().split())
a = [int(i) for i in input().split()]
b=a*3
c1 = 0
c2 = 0
c3 = 0
for i in range(n*3):
for j in range(i,n*3,1):
if b[i] > b[j]:
c3+=1
if i < n*2 and j < n*2:
c2+=1
if i < n and j < n:
c1+=1
diff_c1 = c2-c1
diff_c2 = c3-c2
diff_c = diff_c2 - diff_c1
m = 10**9 + 7
all_s =( 0.5*((2*diff_c1%m+(k-2)*diff_c%m) * (k-1)%m))
if k == 1:
print("%d" % int(c1%m))
elif k == 2:
print("%d" % int(c2%m))
elif k == 3:
print("%d" % int(c3%m))
else:
print("%d" % ((c1+all_s)%m))
``` | instruction | 0 | 30,749 | 5 | 61,498 |
No | output | 1 | 30,749 | 5 | 61,499 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a sequence of N integers A~=~A_0,~A_1,~...,~A_{N - 1}.
Let B be a sequence of K \times N integers obtained by concatenating K copies of A. For example, if A~=~1,~3,~2 and K~=~2, B~=~1,~3,~2,~1,~3,~2.
Find the inversion number of B, modulo 10^9 + 7.
Here the inversion number of B is defined as the number of ordered pairs of integers (i,~j)~(0 \leq i < j \leq K \times N - 1) such that B_i > B_j.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2000
* 1 \leq K \leq 10^9
* 1 \leq A_i \leq 2000
Input
Input is given from Standard Input in the following format:
N K
A_0 A_1 ... A_{N - 1}
Output
Print the inversion number of B, modulo 10^9 + 7.
Examples
Input
2 2
2 1
Output
3
Input
3 5
1 1 1
Output
0
Input
10 998244353
10 9 8 7 5 6 3 4 2 1
Output
185297239
Submitted Solution:
```
# coding: utf-8
# Your code here!
N,K=map(int,input().split())
A=list(map(int,input().split()))
A=A+A
count=[0]*2*N
for i in range(N):
for j in range(i,2*N):
if A[i]>A[j]:
count[j]+=1
a=(sum(count[0:N]))
b=(sum(count[N:2*N]))
c=(int((a*K+b*K*(K-1)/2)))
print(c%(10**9+7))
``` | instruction | 0 | 30,750 | 5 | 61,500 |
No | output | 1 | 30,750 | 5 | 61,501 |
Provide a correct Python 3 solution for this coding contest problem.
For a set $S$ of integers, perform a sequence of the following operations. Note that each value in $S$ must be unique.
* insert($x$): Insert $x$ to $S$ and report the number of elements in $S$ after the operation.
* find($x$): Report the number of $x$ in $S$ (0 or 1).
* delete($x$): Delete $x$ from $S$.
* dump($L$, $R$): Print elements $x$ in $S$ such that $L \leq x \leq R$.
Constraints
* $1 \leq q \leq 200,000$
* $0 \leq x \leq 1,000,000,000$
* The total number of elements printed by dump operations does not exceed $1,000,000$
Input
The input is given in the following format.
$q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $x$
or
1 $x$
or
2 $x$
or
3 $L$ $R$
where the first digits 0, 1, 2 and 3 represent insert, find, delete and dump operations respectively.
Output
For each insert operation, print the number of elements in $S$.
For each find operation, print the number of specified elements in $S$.
For each dump operation, print the corresponding elements in ascending order. Print an element in a line.
Example
Input
9
0 1
0 2
0 3
2 2
1 1
1 2
1 3
0 4
3 2 4
Output
1
2
3
1
0
1
3
3
4 | instruction | 0 | 30,945 | 5 | 61,890 |
"Correct Solution:
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# FileName: set_range_search
# CreatedDate: 2020-07-25 12:57:11 +0900
# LastModified: 2020-07-25 13:36:16 +0900
#
import os
import sys
# import numpy as np
# import pandas as pd
def main():
q = int(input())
ans = set()
for _ in range(q):
s = list(map(int, input().split()))
if s[0] == 0:
ans.add(s[1])
print(len(ans))
elif s[0] == 1:
if s[1] in ans:
print(1)
else:
print(0)
elif s[0] == 2:
if s[1] in ans:
ans.remove(s[1])
else:
if len(ans) > s[2] - s[1]:
for i in range(s[1], s[2]+1):
if i in ans:
print(i)
else:
ans = sorted(ans)
for a in ans:
if s[1] <= a and a <= s[2]:
print(a)
ans = set(ans)
if __name__ == "__main__":
main()
``` | output | 1 | 30,945 | 5 | 61,891 |
Provide a correct Python 3 solution for this coding contest problem.
For a set $S$ of integers, perform a sequence of the following operations. Note that each value in $S$ must be unique.
* insert($x$): Insert $x$ to $S$ and report the number of elements in $S$ after the operation.
* find($x$): Report the number of $x$ in $S$ (0 or 1).
* delete($x$): Delete $x$ from $S$.
* dump($L$, $R$): Print elements $x$ in $S$ such that $L \leq x \leq R$.
Constraints
* $1 \leq q \leq 200,000$
* $0 \leq x \leq 1,000,000,000$
* The total number of elements printed by dump operations does not exceed $1,000,000$
Input
The input is given in the following format.
$q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $x$
or
1 $x$
or
2 $x$
or
3 $L$ $R$
where the first digits 0, 1, 2 and 3 represent insert, find, delete and dump operations respectively.
Output
For each insert operation, print the number of elements in $S$.
For each find operation, print the number of specified elements in $S$.
For each dump operation, print the corresponding elements in ascending order. Print an element in a line.
Example
Input
9
0 1
0 2
0 3
2 2
1 1
1 2
1 3
0 4
3 2 4
Output
1
2
3
1
0
1
3
3
4 | instruction | 0 | 30,946 | 5 | 61,892 |
"Correct Solution:
```
from bisect import insort, bisect_right, bisect_left
class IntSet:
def __init__(self) -> None:
self.total = 0
self.ms: dict = dict()
self.lr: list = []
def insert(self, x: int) -> None:
if x in self.ms:
if self.ms[x] == 0:
self.ms[x] = 1
self.total += 1
else:
self.total += 1
self.ms[x] = 1
insort(self.lr, x)
print(self.total)
def find(self, x: int) -> None:
print(self.ms.get(x, 0))
def delete(self, x: int) -> None:
if x in self.ms:
self.total -= self.ms[x]
self.ms[x] = 0
def dump(self, l: int, r: int) -> None:
lb = bisect_left(self.lr, l)
ub = bisect_right(self.lr, r)
for i in range(lb, ub):
k = self.lr[i]
v = self.ms[k]
print(f'{k}\n' * v, end='')
if __name__ == "__main__":
ms = IntSet()
num_query = int(input())
for _ in range(num_query):
op, *v = map(lambda x: int(x), input().split())
if 0 == op:
ms.insert(v[0])
elif 1 == op:
ms.find(v[0])
elif 2 == op:
ms.delete(v[0])
else:
ms.dump(v[0], v[1])
``` | output | 1 | 30,946 | 5 | 61,893 |
Provide a correct Python 3 solution for this coding contest problem.
For a set $S$ of integers, perform a sequence of the following operations. Note that each value in $S$ must be unique.
* insert($x$): Insert $x$ to $S$ and report the number of elements in $S$ after the operation.
* find($x$): Report the number of $x$ in $S$ (0 or 1).
* delete($x$): Delete $x$ from $S$.
* dump($L$, $R$): Print elements $x$ in $S$ such that $L \leq x \leq R$.
Constraints
* $1 \leq q \leq 200,000$
* $0 \leq x \leq 1,000,000,000$
* The total number of elements printed by dump operations does not exceed $1,000,000$
Input
The input is given in the following format.
$q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $x$
or
1 $x$
or
2 $x$
or
3 $L$ $R$
where the first digits 0, 1, 2 and 3 represent insert, find, delete and dump operations respectively.
Output
For each insert operation, print the number of elements in $S$.
For each find operation, print the number of specified elements in $S$.
For each dump operation, print the corresponding elements in ascending order. Print an element in a line.
Example
Input
9
0 1
0 2
0 3
2 2
1 1
1 2
1 3
0 4
3 2 4
Output
1
2
3
1
0
1
3
3
4 | instruction | 0 | 30,947 | 5 | 61,894 |
"Correct Solution:
```
S = set()
for _ in range(int(input())):
order = tuple(map(int,input().split()))
value = order[1]
if order[0] == 0:
S.add(value)
print(len(S))
elif order[0] == 1:
if value in S:
print(1)
else:
print(0)
elif order[0] == 2:
S.discard(value)
else:
if len(S) > order[2] - order[1]:
for i in range(order[1],order[2]+1):
if i in S:
print(i)
else:
tmp = sorted(S)
for i in tmp:
if order[1] <= i <= order[2]:
print(i)
``` | output | 1 | 30,947 | 5 | 61,895 |
Provide a correct Python 3 solution for this coding contest problem.
For a set $S$ of integers, perform a sequence of the following operations. Note that each value in $S$ must be unique.
* insert($x$): Insert $x$ to $S$ and report the number of elements in $S$ after the operation.
* find($x$): Report the number of $x$ in $S$ (0 or 1).
* delete($x$): Delete $x$ from $S$.
* dump($L$, $R$): Print elements $x$ in $S$ such that $L \leq x \leq R$.
Constraints
* $1 \leq q \leq 200,000$
* $0 \leq x \leq 1,000,000,000$
* The total number of elements printed by dump operations does not exceed $1,000,000$
Input
The input is given in the following format.
$q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $x$
or
1 $x$
or
2 $x$
or
3 $L$ $R$
where the first digits 0, 1, 2 and 3 represent insert, find, delete and dump operations respectively.
Output
For each insert operation, print the number of elements in $S$.
For each find operation, print the number of specified elements in $S$.
For each dump operation, print the corresponding elements in ascending order. Print an element in a line.
Example
Input
9
0 1
0 2
0 3
2 2
1 1
1 2
1 3
0 4
3 2 4
Output
1
2
3
1
0
1
3
3
4 | instruction | 0 | 30,948 | 5 | 61,896 |
"Correct Solution:
```
import bisect
S=[]
q=int(input())
def find(x):
index=bisect.bisect_left(S,x)
if index==len(S):
return False
return S[index]==x
for _ in range(q):
query=[int(i) for i in input().split(" ")]
if query[0]==0:
if find(query[1]):
pass
else:
bisect.insort_left(S, query[1])
print(len(S))
elif query[0]==1:
if find(query[1]):
print(1)
else:
print(0)
elif query[0]==2:
if find(query[1]):
S.remove(query[1])
else:
L,R=query[1],query[2]
indL=bisect.bisect_left(S,L)
indR=bisect.bisect_right(S,R)
for s in S[indL:indR]:
print(s)
``` | output | 1 | 30,948 | 5 | 61,897 |
Provide a correct Python 3 solution for this coding contest problem.
For a set $S$ of integers, perform a sequence of the following operations. Note that each value in $S$ must be unique.
* insert($x$): Insert $x$ to $S$ and report the number of elements in $S$ after the operation.
* find($x$): Report the number of $x$ in $S$ (0 or 1).
* delete($x$): Delete $x$ from $S$.
* dump($L$, $R$): Print elements $x$ in $S$ such that $L \leq x \leq R$.
Constraints
* $1 \leq q \leq 200,000$
* $0 \leq x \leq 1,000,000,000$
* The total number of elements printed by dump operations does not exceed $1,000,000$
Input
The input is given in the following format.
$q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $x$
or
1 $x$
or
2 $x$
or
3 $L$ $R$
where the first digits 0, 1, 2 and 3 represent insert, find, delete and dump operations respectively.
Output
For each insert operation, print the number of elements in $S$.
For each find operation, print the number of specified elements in $S$.
For each dump operation, print the corresponding elements in ascending order. Print an element in a line.
Example
Input
9
0 1
0 2
0 3
2 2
1 1
1 2
1 3
0 4
3 2 4
Output
1
2
3
1
0
1
3
3
4 | instruction | 0 | 30,949 | 5 | 61,898 |
"Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Set - Set: Range Search
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ITP2_7_C&lang=jp
"""
from bisect import insort, bisect_right, bisect_left
class Multi_set:
def __init__(self):
self.total = 0
self.ms = dict()
self.lr = []
def insert(self, x):
if x in self.ms:
if self.ms[x] == 0:
self.ms[x] = 1
self.total += 1
else:
self.total += 1
self.ms[x] = 1
insort(self.lr, x)
print(self.total)
def find(self, x):
print(self.ms.get(x, 0))
def delete(self, x):
if x in self.ms:
self.total -= self.ms[x]
self.ms[x] = 0
def dump(self, l, r):
lb = bisect_left(self.lr, l)
ub = bisect_right(self.lr, r)
for i in range(lb, ub):
k = self.lr[i]
v = self.ms[k]
print(f'{k}\n' * v, end='')
ms = Multi_set()
for _ in range(int(input())):
op, x, y = (input() + ' 1').split()[:3]
if op == '0':
ms.insert(int(x))
elif op == '1':
ms.find(int(x))
elif op == '2':
ms.delete(int(x))
else:
ms.dump(int(x), int(y))
``` | output | 1 | 30,949 | 5 | 61,899 |
Provide a correct Python 3 solution for this coding contest problem.
For a set $S$ of integers, perform a sequence of the following operations. Note that each value in $S$ must be unique.
* insert($x$): Insert $x$ to $S$ and report the number of elements in $S$ after the operation.
* find($x$): Report the number of $x$ in $S$ (0 or 1).
* delete($x$): Delete $x$ from $S$.
* dump($L$, $R$): Print elements $x$ in $S$ such that $L \leq x \leq R$.
Constraints
* $1 \leq q \leq 200,000$
* $0 \leq x \leq 1,000,000,000$
* The total number of elements printed by dump operations does not exceed $1,000,000$
Input
The input is given in the following format.
$q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $x$
or
1 $x$
or
2 $x$
or
3 $L$ $R$
where the first digits 0, 1, 2 and 3 represent insert, find, delete and dump operations respectively.
Output
For each insert operation, print the number of elements in $S$.
For each find operation, print the number of specified elements in $S$.
For each dump operation, print the corresponding elements in ascending order. Print an element in a line.
Example
Input
9
0 1
0 2
0 3
2 2
1 1
1 2
1 3
0 4
3 2 4
Output
1
2
3
1
0
1
3
3
4 | instruction | 0 | 30,950 | 5 | 61,900 |
"Correct Solution:
```
# Solved by QBnewb
# Discretization
# off-line
q = int(input())
s = []
rs = [] # for discretization
# download the input
for i in range(q):
s.append(list(map(int, input().split())))
if s[i][0] == 3:
rs.append(s[i][1])
rs.append(s[i][2])
else:
rs.append(s[i][1])
rs.append(10**9 + 1)
rs = sorted(list(set(rs)))
index = {rs[i]:i for i in range(len(rs))} # discretization
used = [False for i in range(len(rs) + 1)] # tag the elements in set
cnt = 0
for i in range(q):
op, x = s[i][0], s[i][1]
idx = index[x]
if op == 0:
if not used[idx]:
cnt += 1
used[idx] = True
print(cnt)
elif op == 1:
print(+used[idx])
elif op == 2:
if used[idx]:
cnt -= 1
used[idx] = False
else:
l = idx
r = index[s[i][2]]
for j in range(l, r+1):
if used[j]:
print(rs[j])
``` | output | 1 | 30,950 | 5 | 61,901 |
Provide a correct Python 3 solution for this coding contest problem.
For a set $S$ of integers, perform a sequence of the following operations. Note that each value in $S$ must be unique.
* insert($x$): Insert $x$ to $S$ and report the number of elements in $S$ after the operation.
* find($x$): Report the number of $x$ in $S$ (0 or 1).
* delete($x$): Delete $x$ from $S$.
* dump($L$, $R$): Print elements $x$ in $S$ such that $L \leq x \leq R$.
Constraints
* $1 \leq q \leq 200,000$
* $0 \leq x \leq 1,000,000,000$
* The total number of elements printed by dump operations does not exceed $1,000,000$
Input
The input is given in the following format.
$q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $x$
or
1 $x$
or
2 $x$
or
3 $L$ $R$
where the first digits 0, 1, 2 and 3 represent insert, find, delete and dump operations respectively.
Output
For each insert operation, print the number of elements in $S$.
For each find operation, print the number of specified elements in $S$.
For each dump operation, print the corresponding elements in ascending order. Print an element in a line.
Example
Input
9
0 1
0 2
0 3
2 2
1 1
1 2
1 3
0 4
3 2 4
Output
1
2
3
1
0
1
3
3
4 | instruction | 0 | 30,951 | 5 | 61,902 |
"Correct Solution:
```
from enum import Enum
import math
class Color(Enum):
BLACK = 0
RED = 1
@staticmethod
def flip(c):
return [Color.RED, Color.BLACK][c.value]
class RedBlackBinarySearchTree:
"""Red Black Binary Search Tree with range, min, max.
"""
class Node:
__slots__ = ('key', 'left', 'right', 'count', 'color')
def __init__(self, key):
self.key = key
self.left = None
self.right = None
self.count = 0
self.color = Color.RED
def __str__(self):
if self.color == Color.RED:
key = '*{}'.format(self.key)
else:
key = '{}'.format(self.key)
return "{}[{}] ({}, {})".format(key, self.count,
self.left, self.right)
def __init__(self):
self.root = None
def put(self, key):
def _put(node):
if node is None:
node = self.Node(key)
if node.key > key:
node.left = _put(node.left)
elif node.key < key:
node.right = _put(node.right)
node = self._restore(node)
node.count = self._size(node.left) + self._size(node.right) + 1
return node
self.root = _put(self.root)
self.root.color = Color.BLACK
def _is_red(self, node):
if node is None:
return False
else:
return node.color == Color.RED
def _is_black(self, node):
if node is None:
return False
else:
return node.color == Color.BLACK
def _is_2node(self, node):
if node is None:
return False
elif self._is_red(node):
return False
else:
return (self._is_black(node) and
not self._is_red(node.left) and
not self._is_red(node.right))
def _is_34node(self, node):
if node is None:
return False
elif self._is_red(node):
return True
else:
return (self._is_black(node) and
self._is_red(node.left) and
not self._is_red(node.right))
def _rotate_left(self, node):
x = node.right
node.right = x.left
x.left = node
x.color = node.color
node.color = Color.RED
node.count = self._size(node.left) + self._size(node.right) + 1
return x
def _rotate_right(self, node):
x = node.left
node.left = x.right
x.right = node
x.color = node.color
node.color = Color.RED
node.count = self._size(node.left) + self._size(node.right) + 1
return x
def _flip_colors(self, node):
node.color = Color.flip(node.color)
node.left.color = Color.flip(node.left.color)
node.right.color = Color.flip(node.right.color)
return node
def __contains__(self, key):
def _contains(node):
if node is None:
return False
if node.key > key:
return _contains(node.left)
elif node.key < key:
return _contains(node.right)
else:
return True
return _contains(self.root)
def delete(self, key):
def _delete_from(node):
if node is None:
return None
else:
assert not self._is_2node(node)
if node.key > key:
node = self._convert_left(node)
# print('_convert_left', node)
node.left = _delete_from(node.left)
node = self._restore(node)
# print('_restore', node)
elif node.key < key:
node = self._convert_right(node)
# print('_convert_right', node)
node.right = _delete_from(node.right)
node = self._restore(node)
# print('_restore', node)
else:
node = _remove(node)
if node is not None:
node.count = self._size(node.right) + self._size(node.left) + 1
return node
def _remove(node):
if node.left is None:
return None
elif node.right is None:
if self._is_red(node.left):
node.left.color = Color.BLACK
return node.left
else:
node = self._convert_right(node)
if node.key == key:
x = self._find_min(node.right)
node.key = x.key
node.right = self._delete_min(node.right)
else:
# print(node)
node.right = _delete_from(node.right)
node = self._restore(node)
# print('min', x.key, 'node', node.key)
return node
if self.root is None:
return
# print('initial', self.root)
if not self._is_red(self.root.left):
self.root.color = Color.RED
self.root = _delete_from(self.root)
if self.root is not None:
self.root.color = Color.BLACK
def delete_max(self):
if self.root is None:
raise ValueError('remove max on empty tree')
if self.root.left is None:
self.root = None
return
if not self._is_red(self.root.left):
self.root.color = Color.RED
self.root = self._delete_max(self.root)
self.root.color = Color.BLACK
def _delete_max(self, node):
if node.right is None:
if self._is_red(node.left):
node.left.color = Color.BLACK
return node.left
else:
assert not self._is_2node(node)
node = self._convert_right(node)
node.right = self._delete_max(node.right)
node = self._restore(node)
return node
def _convert_right(self, node):
if self._is_2node(node.right):
if self._is_2node(node.left):
self._flip_colors(node)
elif self._is_red(node.left) and self._is_2node(node.left.right):
node = self._rotate_right(node)
self._flip_colors(node.right)
elif self._is_red(node.left):
x = node.left.right
node.left.right = x.left
node.left, node.right, x.left, x.right = \
x.right, node.right.left, node.left, node.right
x.right.left = node
x.color = Color.BLACK
node.color = Color.RED
if self._is_red(x.left.right):
x.left.right.color = Color.BLACK
node.count = (self._size(node.left) +
self._size(node.right) + 1)
x.left.count = (self._size(x.left.left) +
self._size(x.left.right) + 1)
node = x
elif self._is_34node(node.left):
x = node.left
node.left, node.right, x.right = \
x.right, node.right.left, node.right
x.right.left = node
x.color = node.color
if self._is_red(x.left):
x.left.color = Color.BLACK
if self._is_black(x.right.left):
x.right.left.color = Color.RED
node.count = (self._size(node.left) +
self._size(node.right) + 1)
x.left.count = (self._size(x.left.left) +
self._size(x.left.right) + 1)
node = x
return node
def delete_min(self):
if self.root is None:
raise ValueError('remove min on empty tree')
if self.root.left is None:
self.root = None
return
if not self._is_red(self.root.left):
self.root.color = Color.RED
self.root = self._delete_min(self.root)
self.root.color = Color.BLACK
def _delete_min(self, node):
if node.left is None:
return None
else:
node = self._convert_left(node)
node.left = self._delete_min(node.left)
node = self._restore(node)
return node
def _convert_left(self, node):
if self._is_2node(node.left):
if self._is_2node(node.right):
self._flip_colors(node)
elif self._is_34node(node.right):
x = node.right.left
node.right.left = x.right
x.left, x.right, node.right = node, node.right, x.left
x.color = node.color
node.color = Color.BLACK
node.left.color = Color.RED
x.right.count = (self._size(x.right.left) +
self._size(x.right.right) + 1)
node = x
return node
def _restore(self, node):
if self._is_red(node.right) and not self._is_red(node.left):
node = self._rotate_left(node)
if self._is_red(node.left) and self._is_red(node.left.left):
node = self._rotate_right(node)
if self._is_red(node.left) and self._is_red(node.right):
node = self._flip_colors(node)
node.count = self._size(node.left) + self._size(node.right) + 1
return node
def _is_balanced(self, node):
def depth(node):
if node is None:
return 0
left = depth(node.left)
right = depth(node.right)
if left != right:
raise Exception('unbalanced')
if self._is_black(node):
return 1 + left
else:
return left
if node is None:
return True
try:
left = depth(node.left)
right = depth(node.right)
return left == right
except Exception:
return False
@property
def size(self):
return self._size(self.root)
def _size(self, node):
if node is None:
return 0
else:
return node.count
@property
def max(self):
if self.root is None:
raise ValueError('max on empty tree')
return self._max(self.root)
def _max(self, node):
x = self._find_max(node)
return x.key
def _find_max(self, node):
if node.right is None:
return node
else:
return self._find_max(node.right)
@property
def min(self):
if self.root is None:
raise ValueError('min on empty tree')
return self._min(self.root)
def _min(self, node):
x = self._find_min(node)
return x.key
def _find_min(self, node):
if node.left is None:
return node
else:
return self._find_min(node.left)
def range(self, min_, max_):
def _range(node):
if node is None:
return
if node.key > max_:
yield from _range(node.left)
elif node.key < min_:
yield from _range(node.right)
else:
yield from _range(node.left)
yield node.key
yield from _range(node.right)
if min_ > max_:
return
yield from _range(self.root)
class BalancedBstSet:
def __init__(self):
self.bst = RedBlackBinarySearchTree()
def add(self, key):
self.bst.put(key)
def __contains__(self, key):
return key in self.bst
def delete(self, key):
self.bst.delete(key)
def range(self, a, b):
for k in self.bst.range(a, b):
yield k
@property
def count(self):
return self.bst.size
def __str__(self):
return str(self.bst.root)
def run():
q = int(input())
s = BalancedBstSet()
for _ in range(q):
command, *value = [int(x) for x in input().split()]
if command == 0:
s.add(value[0])
print(s.count)
elif command == 1:
if value[0] in s:
print(1)
else:
print(0)
elif command == 2:
s.delete(value[0])
elif command == 3:
for i in s.range(*value):
print(i)
else:
raise ValueError('invalid command')
if __name__ == '__main__':
run()
``` | output | 1 | 30,951 | 5 | 61,903 |
Provide a correct Python 3 solution for this coding contest problem.
For a set $S$ of integers, perform a sequence of the following operations. Note that each value in $S$ must be unique.
* insert($x$): Insert $x$ to $S$ and report the number of elements in $S$ after the operation.
* find($x$): Report the number of $x$ in $S$ (0 or 1).
* delete($x$): Delete $x$ from $S$.
* dump($L$, $R$): Print elements $x$ in $S$ such that $L \leq x \leq R$.
Constraints
* $1 \leq q \leq 200,000$
* $0 \leq x \leq 1,000,000,000$
* The total number of elements printed by dump operations does not exceed $1,000,000$
Input
The input is given in the following format.
$q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $x$
or
1 $x$
or
2 $x$
or
3 $L$ $R$
where the first digits 0, 1, 2 and 3 represent insert, find, delete and dump operations respectively.
Output
For each insert operation, print the number of elements in $S$.
For each find operation, print the number of specified elements in $S$.
For each dump operation, print the corresponding elements in ascending order. Print an element in a line.
Example
Input
9
0 1
0 2
0 3
2 2
1 1
1 2
1 3
0 4
3 2 4
Output
1
2
3
1
0
1
3
3
4 | instruction | 0 | 30,952 | 5 | 61,904 |
"Correct Solution:
```
from bisect import bisect_left, bisect_right, insort_left
q = int(input())
S = []
D = {}
a = []
c = 0
for i in range(q):
a.append(list(map(int,input().split())))
for i in range(q):
if a[i][0] == 0:
if not a[i][1] in D:
insort_left(S,a[i][1])
D[a[i][1]] = 1
c += 1
else:
if not D[a[i][1]] == 1:
D[a[i][1]] = 1
c += 1
print(c)
elif a[i][0] == 1:
if a[i][1] in D:
if D[a[i][1]] == 1:
print(1)
else:
print(0)
else:
print(0)
elif a[i][0] == 2:
if a[i][1] in D:
if D[a[i][1]] == 1:
D[a[i][1]] = 0
c -= 1
else:
L = bisect_left(S,a[i][1])
R = bisect_right(S,a[i][2])
for j in range(L,R):
if D[S[j]] == 1:
print(S[j])
``` | output | 1 | 30,952 | 5 | 61,905 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a set $S$ of integers, perform a sequence of the following operations. Note that each value in $S$ must be unique.
* insert($x$): Insert $x$ to $S$ and report the number of elements in $S$ after the operation.
* find($x$): Report the number of $x$ in $S$ (0 or 1).
* delete($x$): Delete $x$ from $S$.
* dump($L$, $R$): Print elements $x$ in $S$ such that $L \leq x \leq R$.
Constraints
* $1 \leq q \leq 200,000$
* $0 \leq x \leq 1,000,000,000$
* The total number of elements printed by dump operations does not exceed $1,000,000$
Input
The input is given in the following format.
$q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $x$
or
1 $x$
or
2 $x$
or
3 $L$ $R$
where the first digits 0, 1, 2 and 3 represent insert, find, delete and dump operations respectively.
Output
For each insert operation, print the number of elements in $S$.
For each find operation, print the number of specified elements in $S$.
For each dump operation, print the corresponding elements in ascending order. Print an element in a line.
Example
Input
9
0 1
0 2
0 3
2 2
1 1
1 2
1 3
0 4
3 2 4
Output
1
2
3
1
0
1
3
3
4
Submitted Solution:
```
q = int(input())
s = []
rs = [] # for discretization
# download the input
for i in range(q):
s.append(list(map(int, input().split())))
if s[i][0] == 3:
rs.append(s[i][1])
rs.append(s[i][2])
else:
rs.append(s[i][1])
rs.append(10**9 + 1)
rs = sorted(list(set(rs)))
index = {rs[i]:i for i in range(len(rs))} # discretization
used = [False for i in range(len(rs) + 1)] # tag the elements in set
cnt = 0
for i in range(q):
op, x = s[i][0], s[i][1]
idx = index[x]
if op == 0:
if not used[idx]:
cnt += 1
used[idx] = True
print(cnt)
elif op == 1:
print(+used[idx])
elif op == 2:
if used[idx]:
cnt -= 1
used[idx] = False
else:
l = idx
r = index[s[i][2]]
for j in range(l, r+1):
if used[j]:
print(rs[j])
``` | instruction | 0 | 30,953 | 5 | 61,906 |
Yes | output | 1 | 30,953 | 5 | 61,907 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a set $S$ of integers, perform a sequence of the following operations. Note that each value in $S$ must be unique.
* insert($x$): Insert $x$ to $S$ and report the number of elements in $S$ after the operation.
* find($x$): Report the number of $x$ in $S$ (0 or 1).
* delete($x$): Delete $x$ from $S$.
* dump($L$, $R$): Print elements $x$ in $S$ such that $L \leq x \leq R$.
Constraints
* $1 \leq q \leq 200,000$
* $0 \leq x \leq 1,000,000,000$
* The total number of elements printed by dump operations does not exceed $1,000,000$
Input
The input is given in the following format.
$q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $x$
or
1 $x$
or
2 $x$
or
3 $L$ $R$
where the first digits 0, 1, 2 and 3 represent insert, find, delete and dump operations respectively.
Output
For each insert operation, print the number of elements in $S$.
For each find operation, print the number of specified elements in $S$.
For each dump operation, print the corresponding elements in ascending order. Print an element in a line.
Example
Input
9
0 1
0 2
0 3
2 2
1 1
1 2
1 3
0 4
3 2 4
Output
1
2
3
1
0
1
3
3
4
Submitted Solution:
```
import sys
s = set()
input()
for q in sys.stdin:
q = q.split()
if q[0] == '0':
s.add(int(q[1]))
print(len(s))
elif q[0] == '1':
print(int(int(q[1]) in s))
elif q[0] == '2':
s.discard(int(q[1]))
else:
ans = []
if len(s) > int(q[2]) - int(q[1]):
for i in range(int(q[1]), int(q[2])+1):
if i in s:
print(i)
else:
for i in s:
if int(q[1]) <= i <= int(q[2]):
ans.append(i)
for i in sorted(ans):
print(i)
``` | instruction | 0 | 30,954 | 5 | 61,908 |
Yes | output | 1 | 30,954 | 5 | 61,909 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a set $S$ of integers, perform a sequence of the following operations. Note that each value in $S$ must be unique.
* insert($x$): Insert $x$ to $S$ and report the number of elements in $S$ after the operation.
* find($x$): Report the number of $x$ in $S$ (0 or 1).
* delete($x$): Delete $x$ from $S$.
* dump($L$, $R$): Print elements $x$ in $S$ such that $L \leq x \leq R$.
Constraints
* $1 \leq q \leq 200,000$
* $0 \leq x \leq 1,000,000,000$
* The total number of elements printed by dump operations does not exceed $1,000,000$
Input
The input is given in the following format.
$q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $x$
or
1 $x$
or
2 $x$
or
3 $L$ $R$
where the first digits 0, 1, 2 and 3 represent insert, find, delete and dump operations respectively.
Output
For each insert operation, print the number of elements in $S$.
For each find operation, print the number of specified elements in $S$.
For each dump operation, print the corresponding elements in ascending order. Print an element in a line.
Example
Input
9
0 1
0 2
0 3
2 2
1 1
1 2
1 3
0 4
3 2 4
Output
1
2
3
1
0
1
3
3
4
Submitted Solution:
```
from bisect import *
import sys
n = int(input())
ss = []
color = {}
cnt = 0
for _ in range(n):
a, b, *c = map(int,sys.stdin.readline().split())
if a == 0:
if b not in color:
insort_left(ss,b)
color[b]=1
cnt += 1
elif color[b] == 0:
color[b] = 1
cnt += 1
print(cnt)
elif a == 1:
print(color[b] if b in color else 0)
elif a == 2:
if b in color:
cnt -=color[b]
color[b] = 0
else:
L = bisect_left(ss,b)
R = bisect(ss,c[0])
for i in range(L,R):
if color[ss[i]] == 1:
print(ss[i])
``` | instruction | 0 | 30,955 | 5 | 61,910 |
Yes | output | 1 | 30,955 | 5 | 61,911 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a set $S$ of integers, perform a sequence of the following operations. Note that each value in $S$ must be unique.
* insert($x$): Insert $x$ to $S$ and report the number of elements in $S$ after the operation.
* find($x$): Report the number of $x$ in $S$ (0 or 1).
* delete($x$): Delete $x$ from $S$.
* dump($L$, $R$): Print elements $x$ in $S$ such that $L \leq x \leq R$.
Constraints
* $1 \leq q \leq 200,000$
* $0 \leq x \leq 1,000,000,000$
* The total number of elements printed by dump operations does not exceed $1,000,000$
Input
The input is given in the following format.
$q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $x$
or
1 $x$
or
2 $x$
or
3 $L$ $R$
where the first digits 0, 1, 2 and 3 represent insert, find, delete and dump operations respectively.
Output
For each insert operation, print the number of elements in $S$.
For each find operation, print the number of specified elements in $S$.
For each dump operation, print the corresponding elements in ascending order. Print an element in a line.
Example
Input
9
0 1
0 2
0 3
2 2
1 1
1 2
1 3
0 4
3 2 4
Output
1
2
3
1
0
1
3
3
4
Submitted Solution:
```
from bisect import bisect_left,bisect_right,insort_left
dict = {}
keytbl = []
cnt = 0
q = int(input())
for i in range(q):
a = list(input().split())
ki = int(a[1])
if a[0] == "0":
if ki not in dict:
dict[ki] =1
cnt += 1
insort_left(keytbl,ki)
elif dict[ki] == 0:
dict[ki] = 1
cnt += 1
print(cnt)
elif a[0] == "1":print(dict[ki] if ki in dict else 0)
elif a[0] == "2":
if ki in dict:
cnt -= dict[ki]
dict[ki] =0
else:
L = bisect_left(keytbl,int(a[1]))
R = bisect_right(keytbl,int(a[2]),L)
for j in range(L,R):
if dict[keytbl[j]] == 1:print(keytbl[j])
``` | instruction | 0 | 30,956 | 5 | 61,912 |
Yes | output | 1 | 30,956 | 5 | 61,913 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a set $S$ of integers, perform a sequence of the following operations. Note that each value in $S$ must be unique.
* insert($x$): Insert $x$ to $S$ and report the number of elements in $S$ after the operation.
* find($x$): Report the number of $x$ in $S$ (0 or 1).
* delete($x$): Delete $x$ from $S$.
* dump($L$, $R$): Print elements $x$ in $S$ such that $L \leq x \leq R$.
Constraints
* $1 \leq q \leq 200,000$
* $0 \leq x \leq 1,000,000,000$
* The total number of elements printed by dump operations does not exceed $1,000,000$
Input
The input is given in the following format.
$q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $x$
or
1 $x$
or
2 $x$
or
3 $L$ $R$
where the first digits 0, 1, 2 and 3 represent insert, find, delete and dump operations respectively.
Output
For each insert operation, print the number of elements in $S$.
For each find operation, print the number of specified elements in $S$.
For each dump operation, print the corresponding elements in ascending order. Print an element in a line.
Example
Input
9
0 1
0 2
0 3
2 2
1 1
1 2
1 3
0 4
3 2 4
Output
1
2
3
1
0
1
3
3
4
Submitted Solution:
```
numset = set([])
q = int(input())
for i in range(q):
q, *val = list(map(int, input().split(' ')))
if q == 0:
numset.add(val[0])
print(len(numset))
elif q == 1:
rst = 1 if val[0] in numset else 0
print(rst)
elif q == 2:
if val[0] in numset: numset.remove(val[0])
elif q == 3:
L, R = val
ans = []
for n in numset:
if L <= n and n <= R:
ans.append(n)
ans = sorted(ans)
for num in ans:
print(num)
``` | instruction | 0 | 30,957 | 5 | 61,914 |
No | output | 1 | 30,957 | 5 | 61,915 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.