message stringlengths 2 433k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 113 108k | cluster float64 12 12 | __index_level_0__ int64 226 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < β¦ < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = β¦ = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 100) β the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 β€ n β€ 50; 1 β€ x < y β€ 50) β the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7 | instruction | 0 | 99,618 | 12 | 199,236 |
Tags: brute force, math, number theory
Correct Solution:
```
from sys import *
from math import *
from sys import stdin,stdout
from collections import *
int_arr = lambda : list(map(int,stdin.readline().strip().split()))
str_arr = lambda :list(map(str,stdin.readline().split()))
get_str = lambda : map(str,stdin.readline().strip().split())
get_int = lambda: map(int,stdin.readline().strip().split())
get_float = lambda : map(float,stdin.readline().strip().split())
mod = 1000000007
setrecursionlimit(1000)
lst = [i for i in range(1,51)]
l = len(lst)
def ans(l,n,x,y,lst):
for i in range(l):
if (y - x) % lst[i] == 0 and (((y - x) // lst[i]) - 1) <= (n - 2):
val = lst[i]
break
res = [x,y]
ct = 2
y1,x1 = y,x
#print(val)
while ct != n:
if (y - val) > x1:
y -= val
ct += 1
res.append(y)
elif x - val > 0:
x -= val
ct += 1
res.append(x)
else:
y1 += val
ct += 1
res.append(y1)
print(*res)
for _ in range(int(input())):
n,x,y = get_int()
ans(l,n,x,y,lst)
``` | output | 1 | 99,618 | 12 | 199,237 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < β¦ < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = β¦ = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 100) β the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 β€ n β€ 50; 1 β€ x < y β€ 50) β the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7 | instruction | 0 | 99,619 | 12 | 199,238 |
Tags: brute force, math, number theory
Correct Solution:
```
import sys
input=sys.stdin.readline
for _ in range(int(input())):
# n=int(input())
n,x,y=[int(j) for j in input().split()]
ans=[]
mini=min(x,y)
y=max(x,y)
x=mini
# if n==2:
# ans.append(x)
# ans.append(y)
# elif n>=abs(x-y)+1:
# if n>=y:
# for i in range(1,n+1):
# ans.append(i)
# else:
# dif=n-(y-x+1)-1
# for i in range(x,y+1):
# ans.append(i)
# for i in range(dif,x):
# ans.append(i)
# else:
diff=[]
arr=[]
for i in range(1,y-x+1):
if (y-x)%i==0 and (y-x)//i<=(n-1):
diff.append(i)
# print(diff)
for i in range(len(diff)):
temp=[]
temp.append(x)
temp.append(y)
count=0
t=0
while count<n-2:
t+=1
if x+t*diff[i]>=y:
break
count+=1
temp.append(x+t*diff[i])
t=0
while count<n-2:
t+=1
if x-t*diff[i]<=0:
break
count+=1
temp.append(x-t*diff[i])
t=0
while count<n-2:
count+=1
t+=1
temp.append(y+t*diff[i])
arr.append(temp)
ans=arr[0]
print(*ans)
``` | output | 1 | 99,619 | 12 | 199,239 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < β¦ < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = β¦ = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 100) β the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 β€ n β€ 50; 1 β€ x < y β€ 50) β the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7 | instruction | 0 | 99,620 | 12 | 199,240 |
Tags: brute force, math, number theory
Correct Solution:
```
for _ in range(int(input())):
n, x, y = map(int, input().split())
a_n_max = float('inf')
d_max = 0
for n1 in range(2, n+1):
d = (y - x)/(n1 - 1)
if d % 1 == 0:
for pos in range(n, n1-1, -1):
a1 = y - d*(pos - 1)
if a1 > 0:
a_n = a1 + d*(n - 1)
if a_n < a_n_max:
a_n_max = int(a_n)
d_max = int(d)
arr = [0]*n
arr[-1] = a_n_max
for i in range(n-2, -1, -1):
arr[i] = arr[i+1] - d_max
print(' '.join(str(i) for i in arr))
``` | output | 1 | 99,620 | 12 | 199,241 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < β¦ < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = β¦ = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 100) β the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 β€ n β€ 50; 1 β€ x < y β€ 50) β the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7 | instruction | 0 | 99,621 | 12 | 199,242 |
Tags: brute force, math, number theory
Correct Solution:
```
t = int(input())
while t>0:
n,x,y = list(map(int,input().split()))
min_val = 1e5
min_diff = 0
for xpos in range(0,n-1):
for ypos in range(xpos+1,n):
l = ypos-xpos
if (y-x) % l > 0 :
continue
diff = (y-x)/l
max_item = x + (n-1-xpos)*diff
if max_item < min_val and (x -(xpos*diff))>=1:
min_val = int(max_item)
min_diff = int(diff)
first_num = min_val - (n-1)*min_diff
for index in range(0,n):
print("{}".format(first_num + index*min_diff), end=" ")
print("")
t -= 1
``` | output | 1 | 99,621 | 12 | 199,243 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < β¦ < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = β¦ = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 100) β the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 β€ n β€ 50; 1 β€ x < y β€ 50) β the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
Submitted Solution:
```
for _ in range(int(input())):
n, x, y = map(int, input().split())
res = [10 ** 18]
if n == 2:
res = [x, y]
else:
for i in range(1, 51):
tmp = []
if (y - x) % i == 0 and (y - x) // i <= n - 1:
tmp = [j for j in range(x, y + 1, i)]
nn = n - len(tmp)
if nn > 0:
for j in range(x - i, 0, -i):
tmp = [j] + tmp
nn -= 1
if nn == 0:
break
if nn > 0:
for j in range(y + i, y + n * i, i):
tmp.append(j)
nn -= 1
if nn == 0:
break
if res[-1] > tmp[-1]:
res = tmp
print(*res)
``` | instruction | 0 | 99,622 | 12 | 199,244 |
Yes | output | 1 | 99,622 | 12 | 199,245 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < β¦ < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = β¦ = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 100) β the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 β€ n β€ 50; 1 β€ x < y β€ 50) β the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
Submitted Solution:
```
for _ in range(int(input())):
n,x,y=map(int,input().split())
print(x,y,end=" ")
div=n-1
unsolved,needed,xtra_needed=True,0,0
diff=y-x
got=0
while unsolved:
if diff%div!=0: div-=1
else:
got=int(diff/div)
needed=div-1
xtra_needed=n-div-1
unsolved=False
another,other,num=x,y,0
while another<y and needed>0:
another+=got
print(another,end=" ")
needed-=1
while x-got>0 and xtra_needed>0:
x=x-got
xtra_needed-=1
print(x,end=" ")
while xtra_needed>0:
y+=got
xtra_needed-=1
print(y,end=" ")
print()
``` | instruction | 0 | 99,623 | 12 | 199,246 |
Yes | output | 1 | 99,623 | 12 | 199,247 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < β¦ < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = β¦ = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 100) β the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 β€ n β€ 50; 1 β€ x < y β€ 50) β the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
Submitted Solution:
```
t = int(input())
for _ in range(t):
n,x,y = map(int,input().split())
maxi = 10**18
final = []
for a in range(1,51):
for d in range(1,51):
flag = 0
ans = []
for i in range(1,n+1):
ans.append(a+(i-1)*d)
if ans[-1] == x or ans[-1] == y:
flag+=1
if flag == 2:
if ans[-1]<maxi:
maxi = min(ans[-1],maxi)
final = ans
print(*final)
``` | instruction | 0 | 99,624 | 12 | 199,248 |
Yes | output | 1 | 99,624 | 12 | 199,249 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < β¦ < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = β¦ = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 100) β the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 β€ n β€ 50; 1 β€ x < y β€ 50) β the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
Submitted Solution:
```
#include <CodeforcesSolutions.h>
#include <ONLINE_JUDGE <solution.cf(contestID = "1409",questionID = "A",method = "GET")>.h>
"""
Author : thekushalghosh
Team : CodeDiggers
I prefer Python language over the C++ language :p :D
Visit my website : thekushalghosh.github.io
"""
import sys,math,cmath,time
start_time = time.time()
##########################################################################
################# ---- THE ACTUAL CODE STARTS BELOW ---- #################
def solve():
n,x,y = invr()
q = y - x
for i in range(1,q + 1):
if q % i == 0 and (q // i) + 1 <= n:
w = i
break
qq = x
ww = n - (q // w) - 1
while qq - w >= 1 and ww >= 1:
qq = qq - w
ww = ww - 1
q = [qq]
for i in range(n - 1):
q.append(q[-1] + w)
print(*q)
################## ---- THE ACTUAL CODE ENDS ABOVE ---- ##################
##########################################################################
def main():
global tt
if not ONLINE_JUDGE:
sys.stdin = open("input.txt","r")
sys.stdout = open("output.txt","w")
t = 1
t = inp()
for tt in range(t):
solve()
if not ONLINE_JUDGE:
print("Time Elapsed :",time.time() - start_time,"seconds")
sys.stdout.close()
#---------------------- USER DEFINED INPUT FUNCTIONS ----------------------#
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
return(input().strip())
def invr():
return(map(int,input().split()))
#------------------ USER DEFINED PROGRAMMING FUNCTIONS ------------------#
def counter(a):
q = [0] * max(a)
for i in range(len(a)):
q[a[i] - 1] = q[a[i] - 1] + 1
return(q)
def counter_elements(a):
q = dict()
for i in range(len(a)):
if a[i] not in q:
q[a[i]] = 0
q[a[i]] = q[a[i]] + 1
return(q)
def string_counter(a):
q = [0] * 26
for i in range(len(a)):
q[ord(a[i]) - 97] = q[ord(a[i]) - 97] + 1
return(q)
def factors(n):
q = []
for i in range(1,int(n ** 0.5) + 1):
if n % i == 0: q.append(i); q.append(n // i)
return(list(sorted(list(set(q)))))
def prime_factors(n):
q = []
while n % 2 == 0: q.append(2); n = n // 2
for i in range(3,int(n ** 0.5) + 1,2):
while n % i == 0: q.append(i); n = n // i
if n > 2: q.append(n)
return(list(sorted(q)))
def transpose(a):
n,m = len(a),len(a[0])
b = [[0] * n for i in range(m)]
for i in range(m):
for j in range(n):
b[i][j] = a[j][i]
return(b)
def factorial(n,m = 1000000007):
q = 1
for i in range(n):
q = (q * (i + 1)) % m
return(q)
#-----------------------------------------------------------------------#
ONLINE_JUDGE = __debug__
if ONLINE_JUDGE:
input = sys.stdin.readline
main()
``` | instruction | 0 | 99,625 | 12 | 199,250 |
Yes | output | 1 | 99,625 | 12 | 199,251 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < β¦ < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = β¦ = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 100) β the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 β€ n β€ 50; 1 β€ x < y β€ 50) β the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
Submitted Solution:
```
t = int(input())
while t:
t -= 1
n, x, y = map(int, input().split())
ans =[]
ansT = 10**9 * 50+1
for d in range(1,y-x+1):
findx = y
tmptotal = y
cur = 1
tmp=[]
tmp.append(y)
ok=False
while cur<n:
findx-=d
if findx < x:
findx+=d
break
else:
cur += 1
tmptotal += findx
tmp.append(findx)
if x not in tmp:
continue
while cur<n:
findx-=d
if findx <= 0:
break
else:
cur += 1
tmptotal +=findx
tmp.append(findx)
findx = y
while cur<n:
findx+=d
tmptotal+=findx
tmp.append(findx)
cur+=1
if tmptotal<ansT:
ansT = tmptotal
ans = tmp
print(*ans)
``` | instruction | 0 | 99,626 | 12 | 199,252 |
No | output | 1 | 99,626 | 12 | 199,253 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < β¦ < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = β¦ = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 100) β the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 β€ n β€ 50; 1 β€ x < y β€ 50) β the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
Submitted Solution:
```
t=int(input())
for i in range(t):
n,x,y=map(int,input().split(" "))
if n==2:
print(x,y)
else:
arr=[x,y]
diff=y-x
between=n-2+1
while between>1:
if diff%between==0:
interval=diff//between
break
between-=1
for i in range(1,between):
arr.append(x+interval*i)
leftover=n-between-1
for i in range(1,leftover+1):
arr.append(x-interval*i)
print(*arr)
``` | instruction | 0 | 99,627 | 12 | 199,254 |
No | output | 1 | 99,627 | 12 | 199,255 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < β¦ < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = β¦ = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 100) β the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 β€ n β€ 50; 1 β€ x < y β€ 50) β the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
Submitted Solution:
```
def solve(p,n):
if p%n==0:
return p//n
return -1
def solve1(diff,n,x,y):
if y - (n - 1) * diff > 0:
a = [];p=y
for i in range(n):
a.append(p)
p -= diff
return a[::-1][:]
elif (x - 1) / (diff) % 1 == 0 and (y - 1) / (diff) % 1 == 0:
a = []
p = 1
for i in range(n):
a.append(p)
p += diff
return a[::-1][:]
else:
p = x
a = []
for i in range(n):
a.append(p)
p += diff
return a[::-1][:]
for _ in range(int(input())):
n,x,y=map(int,input().split())
a=[10**10]
for i in range(1,n):
p=solve(y-x,i)
if p!=-1:
q=solve1(p,n,x,y)
if max(q)<max(a):
a=q[:]
print(*a)
``` | instruction | 0 | 99,628 | 12 | 199,256 |
No | output | 1 | 99,628 | 12 | 199,257 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < β¦ < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = β¦ = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 100) β the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 β€ n β€ 50; 1 β€ x < y β€ 50) β the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
Submitted Solution:
```
from math import ceil
t = int(input())
for _ in range(t):
n, a, b = map(int, input().split())
c = abs(a-b)
i = n - 1
arr = [0]*n
while i != 1:
if c % i == 0:
break
else:
i -= 1
d = c // i
j = n - i - 2
arr[j+1] = min(a,b)
while j >= 0:
arr[j] = arr[j+1]-d
j -= 1
for i in range(n-i, n):
arr[i] = arr[i-1]+d
#if arr[0] <= 0:
# c = min(a,b) - arr[0]
#
# for i in range(n):
# arr[i] += c
if arr[0] <= 0:
q = ceil(abs(arr[0])/d)
c = q*d
for i in range(n):
arr[i] += c
for i in range(n):
print(arr[i], end=" ")
print()
``` | instruction | 0 | 99,629 | 12 | 199,258 |
No | output | 1 | 99,629 | 12 | 199,259 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 β€ n β€ 10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer β the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0. | instruction | 0 | 99,679 | 12 | 199,358 |
Tags: hashing, implementation, math
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
arr=list(map(int,input().split()))
d={}
ans=0
tmp=0
for i in range(n):
if arr[i] in d:
tmp+=d[arr[i]]
else:
d[arr[i]]=0
d[arr[i]]+=i+1
ans+=tmp
print(ans)
``` | output | 1 | 99,679 | 12 | 199,359 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 β€ n β€ 10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer β the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0. | instruction | 0 | 99,680 | 12 | 199,360 |
Tags: hashing, implementation, math
Correct Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
import sys
from io import BytesIO, IOBase
from collections import defaultdict
def main():
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
b = defaultdict(list)
for i, v in enumerate(a):
b[v].append(i)
ans = 0
for i in b:
z = b[i]
c = [0] * (len(z) + 1)
for j in range(len(z) - 1, -1, -1):
c[j] = c[j + 1] + (n - z[j])
for j in range(len(z) - 1):
ans += c[j + 1] * (z[j] + 1)
print(ans)
# 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 | 99,680 | 12 | 199,361 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 β€ n β€ 10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer β the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0. | instruction | 0 | 99,681 | 12 | 199,362 |
Tags: hashing, implementation, math
Correct Solution:
```
import bisect
import collections
import copy
import functools
import heapq
import itertools
import math
import sys
import string
import random
from typing import List
sys.setrecursionlimit(99999)
for _ in range(int(input())):
n = int(input())
arr = list(map(int,input().split()))
mp= collections.defaultdict(int)
cnt= collections.defaultdict(int)
ans = 0
pre = 0
for i,c in enumerate(arr):
ans+=mp[c]*(n-i)
mp[c]+=(i+1)
cnt[c]+=1
print(ans)
``` | output | 1 | 99,681 | 12 | 199,363 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 β€ n β€ 10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer β the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0. | instruction | 0 | 99,682 | 12 | 199,364 |
Tags: hashing, implementation, math
Correct Solution:
```
import math
for t in range(int(input())):
n=int(input())
#n,k=map(int,input().split())
a=list(map(int,input().split()))
dp=[0 for i in range(n+1)]
store={}
for i in range(1,n+1):
dp[i]=dp[i-1]
if a[i-1] in store:
dp[i]+=store[a[i-1]]
else:
store[a[i-1]]=0
store[a[i-1]]+=i
print(sum(dp))
``` | output | 1 | 99,682 | 12 | 199,365 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 β€ n β€ 10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer β the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0. | instruction | 0 | 99,683 | 12 | 199,366 |
Tags: hashing, implementation, math
Correct Solution:
```
import sys
input=sys.stdin.readline
from collections import *
a=int(input())
for i in range(a):
s=int(input())
z=list(map(int,input().split()))
al=defaultdict(list)
for i in range(len(z)):
al[z[i]].append(i+1)
total=0
for i in al:
ans=al[i]
t=[0 for i in range(len(ans))]
if(len(ans)<=1):
continue;
for i in range(len(ans)-1,-1,-1):
if(i==len(ans)-1):
continue;
else:
t[i]=t[i+1]+ans[i+1]-1
for i in range(len(ans)):
g1=(len(z)*(len(ans)-(i+1)))-(t[i])
total+=g1*ans[i]
print(total)
``` | output | 1 | 99,683 | 12 | 199,367 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 β€ n β€ 10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer β the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0. | instruction | 0 | 99,684 | 12 | 199,368 |
Tags: hashing, implementation, math
Correct Solution:
```
from sys import stdin,stdout
from collections import defaultdict
from itertools import accumulate
nmbr = lambda: int(input())
lst = lambda: list(map(int, input().split()))
for _ in range(nmbr()):
n=nmbr()
a=lst()
g=defaultdict(list)
for i in range(n):
g[a[i]]+=[i]
ans=0
for k,l in g.items():
ps=list(accumulate(l))
c=1
nn=len(ps)
for i in range(nn-1):
ans+=(l[i]+1)*((nn-c)*n-ps[-1]+ps[i])
c+=1
print(ans)
``` | output | 1 | 99,684 | 12 | 199,369 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 β€ n β€ 10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer β the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0. | instruction | 0 | 99,685 | 12 | 199,370 |
Tags: hashing, implementation, math
Correct Solution:
```
def fun(n,ls):
dp=[0 for i in range(n)]
dct={i:0 for i in ls}
ans=0
for i in range(n):
if(i>0):
dp[i]=dp[i-1]
if(ls[i] in dct):
dp[i]+=dct.get(ls[i])
dct[ls[i]]+=i+1
ans+=dp[i]
print(ans)
T = int(input())
for i in range(T):
n=int(input())
ls= list(map(int, input().split()))
fun(n,ls)
``` | output | 1 | 99,685 | 12 | 199,371 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 β€ n β€ 10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer β the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0. | instruction | 0 | 99,686 | 12 | 199,372 |
Tags: hashing, implementation, math
Correct Solution:
```
#!/usr/bin/env pypy
from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
MOD = 10**9 + 7
# 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")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
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()
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)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
from collections import Counter
def main():
for _ in range(int(input())):
n = int(input())
a = [*map(int, input().split())]
s = 0
cnt = Counter()
for i , ai in reversed(list(enumerate(a))):
s += cnt[ai] * (i+1)
cnt[ai] += n-i
print(s)
if __name__ == '__main__':
main()
``` | output | 1 | 99,686 | 12 | 199,373 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 β€ n β€ 10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer β the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
Submitted Solution:
```
def fun(n,ls):
dp=[0 for i in range(n)]
dct={i:0 for i in ls}
ans=0
for i in range(n):
if(i>0):
dp[i]=dp[i-1]
if(ls[i] in dct):
dp[i]+=dct.get(ls[i])
dct[ls[i]]+=i+1
ans+=dp[i]
print(ans)
T = int(input())
# T=1
for i in range(T):
# var=input()
n=int(input())
# st=input()
# ks= list(map(int, input().split()))
# ms= list(map(int, input().split()))
# n=int(input())
ls= list(map(int, input().split()))
fun(n,ls)
``` | instruction | 0 | 99,687 | 12 | 199,374 |
Yes | output | 1 | 99,687 | 12 | 199,375 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 β€ n β€ 10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer β the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
Submitted Solution:
```
from collections import defaultdict
import sys
input = sys.stdin.readline
def solve(n,a):
ctr = defaultdict(int)
ans = 0
for i in range(n):
ans += (n-i)*ctr[a[i]]
ctr[a[i]] += i+1
print(ans)
return
for nt in range(int(input())):
n = int(input())
a = list(map(int,input().split()))
solve(n,a)
``` | instruction | 0 | 99,688 | 12 | 199,376 |
Yes | output | 1 | 99,688 | 12 | 199,377 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 β€ n β€ 10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer β the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
Submitted Solution:
```
from collections import defaultdict, deque
from heapq import heappush, heappop
from math import inf
ri = lambda : map(int, input().split())
def solve():
n = int(input())
A = list(ri())
indexes = defaultdict(list)
for i in range(n):
indexes[A[i]].append(i)
ans = 0
for val in indexes:
pref = 0
for i in indexes[val]:
ans += pref * (n - i)
pref += (i + 1)
print(ans)
t = 1
t = int(input())
while t:
t -= 1
solve()
``` | instruction | 0 | 99,689 | 12 | 199,378 |
Yes | output | 1 | 99,689 | 12 | 199,379 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 β€ n β€ 10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer β the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
d = {}
for i in range(n):
if a[i] not in d:
d[a[i]] = [i]
else:
d[a[i]].append(i)
ans = 0
for el in d:
if len(d[el]) > 1:
sp = [n - d[el][-1]]
for i in range(2, len(d[el])):
sp.append(sp[-1] + (n - d[el][-i]))
for i in range(len(d[el])-1):
ans += sp[-(i+1)]*(d[el][i]+1)
print(ans)
``` | instruction | 0 | 99,690 | 12 | 199,380 |
Yes | output | 1 | 99,690 | 12 | 199,381 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 β€ n β€ 10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer β the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
Submitted Solution:
```
def cost(s):
retval = 0
cnt = dict()
for x in s:
cnt[x] = cnt.get(x, 0) + 1
for (num, count) in cnt.items():
retval += (count-1)*count//2
return retval
def solve(s):
retval = 0
i = 0
j = 2
while j < len(s):
retval += cost(s[i:j])
j += 1
while i < j:
retval += cost(s[i:j])
i += 1
return retval
count = int(input())
for _ in range(count):
input()
print(solve(list(map(int, input().split()))))
``` | instruction | 0 | 99,691 | 12 | 199,382 |
No | output | 1 | 99,691 | 12 | 199,383 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 β€ n β€ 10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer β the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
Submitted Solution:
```
for _ in range(int(input())):
l=int(input())
loi = list(map(int,input().split()))
ans=0
for i in range(1,len(loi)):
temp=0
for j in range(0,i):
if loi[j]==loi[i]:
temp+=(j+1)
ans+=temp
print(ans)
``` | instruction | 0 | 99,692 | 12 | 199,384 |
No | output | 1 | 99,692 | 12 | 199,385 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 β€ n β€ 10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer β the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
Submitted Solution:
```
import sys,os,io
import math,bisect,operator,itertools
inf,mod = float('inf'),10**9+7
# sys.setrecursionlimit(10 ** 6)
from itertools import groupby,accumulate
from heapq import heapify,heappop,heappush
from collections import deque,Counter,defaultdict
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
Neo = lambda : list(map(int,input().split()))
test, = Neo()
for _ in range(test):
n, = Neo()
A = Neo()
C = Counter(A)
t = 0
Ans = 0
for i in C:
t += max(0,C[i]*(C[i]-1)//2)
c = t
D = C.copy()
for i in A[::-1]:
Ans += t
t -= max(0,C[i]*(C[i]-1)//2)
C[i] -= 1
t += max(0,C[i]*(C[i]-1)//2)
t = c
C = D
for i in A:
Ans += t
t -= max(0,C[i]*(C[i]-1)//2)
C[i] -= 1
t += max(0,C[i]*(C[i]-1)//2)
print(Ans-c)
``` | instruction | 0 | 99,693 | 12 | 199,386 |
No | output | 1 | 99,693 | 12 | 199,387 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 β€ n β€ 10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer β the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
Submitted Solution:
```
from sys import stdin,stdout
from heapq import heapify,heappush,heappop,heappushpop
from collections import defaultdict as dd, deque as dq,Counter as C
from bisect import bisect_left as bl ,bisect_right as br
from itertools import combinations as cmb,permutations as pmb
from math import factorial as f ,ceil,gcd,sqrt,log,inf
mi = lambda : map(int,input().split())
ii = lambda: int(input())
li = lambda : list(map(int,input().split()))
mati = lambda r : [ li() for _ in range(r)]
lcm = lambda a,b : (a*b)//gcd(a,b)
def solve():
n=ii()
arr=li()
d={}
for x in range(n):
try:
d[arr[x]].append(x+1)
except:
d[arr[x]]=[x+1]
#print(d)
ans=0
for x in d:
p=len(d[x])
temp=[0 for x in range(p)]
temp[0]=d[x][0]
for y in range(1,p):
temp[y]=temp[y-1]+d[x][y]
for y in range(p-1,0,-1):
ans+=(n-d[x][y])*temp[y-1]+1
print(ans*2)
for _ in range(ii()):
solve()
``` | instruction | 0 | 99,694 | 12 | 199,388 |
No | output | 1 | 99,694 | 12 | 199,389 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p of length n. Also you are given m foe pairs (ai, bi) (1 β€ ai, bi β€ n, ai β bi).
Your task is to count the number of different intervals (x, y) (1 β€ x β€ y β€ n) that do not contain any foe pairs. So you shouldn't count intervals (x, y) that contain at least one foe pair in it (the positions and order of the values from the foe pair are not important).
Consider some example: p = [1, 3, 2, 4] and foe pairs are {(3, 2), (4, 2)}. The interval (1, 3) is incorrect because it contains a foe pair (3, 2). The interval (1, 4) is also incorrect because it contains two foe pairs (3, 2) and (4, 2). But the interval (1, 2) is correct because it doesn't contain any foe pair.
Input
The first line contains two integers n and m (1 β€ n, m β€ 3Β·105) β the length of the permutation p and the number of foe pairs.
The second line contains n distinct integers pi (1 β€ pi β€ n) β the elements of the permutation p.
Each of the next m lines contains two integers (ai, bi) (1 β€ ai, bi β€ n, ai β bi) β the i-th foe pair. Note a foe pair can appear multiple times in the given list.
Output
Print the only integer c β the number of different intervals (x, y) that does not contain any foe pairs.
Note that the answer can be too large, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
4 2
1 3 2 4
3 2
2 4
Output
5
Input
9 5
9 7 2 3 1 4 6 5 8
1 6
4 5
2 7
7 2
2 7
Output
20
Note
In the first example the intervals from the answer are (1, 1), (1, 2), (2, 2), (3, 3) and (4, 4). | instruction | 0 | 99,877 | 12 | 199,754 |
Tags: combinatorics, sortings, two pointers
Correct Solution:
```
from sys import stdin
def main():
n, k = map(int, stdin.readline().split())
ar = list(map(int, stdin.readline().split()))
lk = {ar[i] - 1: i for i in range(n)}
pair = [-1 for _ in range(n)]
for _ in range(k):
x, y = map(int, stdin.readline().split())
if lk[y - 1] > lk[x - 1]:
pair[y - 1] = max(pair[y - 1], lk[x - 1])
else:
pair[x - 1] = max(pair[x - 1], lk[y - 1])
start = 0
end = 0
ok = True
ans = 0
while end < n:
while end < n and ok:
curr = ar[end] - 1
if start <= pair[curr]:
ok = False
else:
end += 1
if end < n:
while start <= pair[ar[end] - 1]:
ans += end - start
start += 1
else:
ans += (end - start + 1) * (end - start) // 2
ok = True
print(ans)
if __name__ == '__main__':
main()
``` | output | 1 | 99,877 | 12 | 199,755 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p of length n. Also you are given m foe pairs (ai, bi) (1 β€ ai, bi β€ n, ai β bi).
Your task is to count the number of different intervals (x, y) (1 β€ x β€ y β€ n) that do not contain any foe pairs. So you shouldn't count intervals (x, y) that contain at least one foe pair in it (the positions and order of the values from the foe pair are not important).
Consider some example: p = [1, 3, 2, 4] and foe pairs are {(3, 2), (4, 2)}. The interval (1, 3) is incorrect because it contains a foe pair (3, 2). The interval (1, 4) is also incorrect because it contains two foe pairs (3, 2) and (4, 2). But the interval (1, 2) is correct because it doesn't contain any foe pair.
Input
The first line contains two integers n and m (1 β€ n, m β€ 3Β·105) β the length of the permutation p and the number of foe pairs.
The second line contains n distinct integers pi (1 β€ pi β€ n) β the elements of the permutation p.
Each of the next m lines contains two integers (ai, bi) (1 β€ ai, bi β€ n, ai β bi) β the i-th foe pair. Note a foe pair can appear multiple times in the given list.
Output
Print the only integer c β the number of different intervals (x, y) that does not contain any foe pairs.
Note that the answer can be too large, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
4 2
1 3 2 4
3 2
2 4
Output
5
Input
9 5
9 7 2 3 1 4 6 5 8
1 6
4 5
2 7
7 2
2 7
Output
20
Note
In the first example the intervals from the answer are (1, 1), (1, 2), (2, 2), (3, 3) and (4, 4). | instruction | 0 | 99,878 | 12 | 199,756 |
Tags: combinatorics, sortings, two pointers
Correct Solution:
```
def main():
from sys import stdin
n, m = map(int, input().split())
n += 1
aa, pos, duo = [0] * n, [0] * n, [0] * n
for i, a in enumerate(map(int, input().split()), 1):
aa[i] = a
pos[a] = i
for s in stdin.read().splitlines():
x, y = map(int, s.split())
px, py = pos[x], pos[y]
if px > py:
if duo[x] < py:
duo[x] = py
else:
if duo[y] < px:
duo[y] = px
res = mx = 0
for i, a in enumerate(aa):
if mx < duo[a]:
mx = duo[a]
res += i - mx
print(res)
if __name__ == '__main__':
main()
``` | output | 1 | 99,878 | 12 | 199,757 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p of length n. Also you are given m foe pairs (ai, bi) (1 β€ ai, bi β€ n, ai β bi).
Your task is to count the number of different intervals (x, y) (1 β€ x β€ y β€ n) that do not contain any foe pairs. So you shouldn't count intervals (x, y) that contain at least one foe pair in it (the positions and order of the values from the foe pair are not important).
Consider some example: p = [1, 3, 2, 4] and foe pairs are {(3, 2), (4, 2)}. The interval (1, 3) is incorrect because it contains a foe pair (3, 2). The interval (1, 4) is also incorrect because it contains two foe pairs (3, 2) and (4, 2). But the interval (1, 2) is correct because it doesn't contain any foe pair.
Input
The first line contains two integers n and m (1 β€ n, m β€ 3Β·105) β the length of the permutation p and the number of foe pairs.
The second line contains n distinct integers pi (1 β€ pi β€ n) β the elements of the permutation p.
Each of the next m lines contains two integers (ai, bi) (1 β€ ai, bi β€ n, ai β bi) β the i-th foe pair. Note a foe pair can appear multiple times in the given list.
Output
Print the only integer c β the number of different intervals (x, y) that does not contain any foe pairs.
Note that the answer can be too large, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
4 2
1 3 2 4
3 2
2 4
Output
5
Input
9 5
9 7 2 3 1 4 6 5 8
1 6
4 5
2 7
7 2
2 7
Output
20
Note
In the first example the intervals from the answer are (1, 1), (1, 2), (2, 2), (3, 3) and (4, 4). | instruction | 0 | 99,879 | 12 | 199,758 |
Tags: combinatorics, sortings, two pointers
Correct Solution:
```
def f():
sizes = input().split(' ')
n, m = int(sizes[0]), int(sizes[1])
permStr = input().split(' ')
pairsStr = [input() for i in range(m)]
indexes = [0 for i in range(n+1)]
for i in range(n):
indexes[int(permStr[i])] = i+1
lowerNums = [0 for i in range(n+1)]
for i in range(m):
pair = pairsStr[i].split(" ")
a, b = indexes[int(pair[0])], indexes[int(pair[1])]
if a < b:
l = a
h = b
else:
l = b
h = a
if l > lowerNums[h]:
lowerNums[h] = l
counter = 0
left = 0
for i in range(1,n+1):
candidate = lowerNums[i]
if candidate > left:
r=i-1-left
q=i-1-candidate
counter += (r*(r-1) - q*(q-1))//2
left = candidate
r=i-left
counter += r*(r-1)//2
print(counter + n)
f()
``` | output | 1 | 99,879 | 12 | 199,759 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p of length n. Also you are given m foe pairs (ai, bi) (1 β€ ai, bi β€ n, ai β bi).
Your task is to count the number of different intervals (x, y) (1 β€ x β€ y β€ n) that do not contain any foe pairs. So you shouldn't count intervals (x, y) that contain at least one foe pair in it (the positions and order of the values from the foe pair are not important).
Consider some example: p = [1, 3, 2, 4] and foe pairs are {(3, 2), (4, 2)}. The interval (1, 3) is incorrect because it contains a foe pair (3, 2). The interval (1, 4) is also incorrect because it contains two foe pairs (3, 2) and (4, 2). But the interval (1, 2) is correct because it doesn't contain any foe pair.
Input
The first line contains two integers n and m (1 β€ n, m β€ 3Β·105) β the length of the permutation p and the number of foe pairs.
The second line contains n distinct integers pi (1 β€ pi β€ n) β the elements of the permutation p.
Each of the next m lines contains two integers (ai, bi) (1 β€ ai, bi β€ n, ai β bi) β the i-th foe pair. Note a foe pair can appear multiple times in the given list.
Output
Print the only integer c β the number of different intervals (x, y) that does not contain any foe pairs.
Note that the answer can be too large, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
4 2
1 3 2 4
3 2
2 4
Output
5
Input
9 5
9 7 2 3 1 4 6 5 8
1 6
4 5
2 7
7 2
2 7
Output
20
Note
In the first example the intervals from the answer are (1, 1), (1, 2), (2, 2), (3, 3) and (4, 4). | instruction | 0 | 99,880 | 12 | 199,760 |
Tags: combinatorics, sortings, two pointers
Correct Solution:
```
"""
652C - ΠΡΠ°ΠΆΠ΄Π΅Π±Π½ΡΠ΅ ΠΏΠ°ΡΡ
http://codeforces.com/problemset/problem/652/C
ΠΡΠ΅Π΄ΠΏΠΎΠ΄ΡΡΠΈΡΠ°Π΅ΠΌ ΡΠ½Π°ΡΠ°Π»Π° Π΄Π»Ρ ΠΊΠ°ΠΆΠ΄ΠΎΠ³ΠΎ ΡΠΈΡΠ»Π° x Π΅Π³ΠΎ ΠΏΠΎΠ·ΠΈΡΠΈΡ posx Π² ΠΏΠ΅ΡΠ΅ΡΡΠ°Π½ΠΎΠ²ΠΊΠ΅. ΠΡΠΎ Π»Π΅Π³ΠΊΠΎ ΡΠ΄Π΅Π»Π°ΡΡ Π·Π° Π»ΠΈΠ½Π΅ΠΉΠ½ΠΎΠ΅ Π²ΡΠ΅ΠΌΡ. Π’Π΅ΠΏΠ΅ΡΡ ΡΠ°ΡΡΠΌΠΎΡΡΠΈΠΌ Π½Π΅ΠΊΠΎΡΠΎΡΡΡ Π²ΡΠ°ΠΆΠ΄Π΅Π±Π½ΡΡ ΠΏΠ°ΡΡ (a,βb) (ΠΌΠΎΠΆΠ½ΠΎ ΡΡΠΈΡΠ°ΡΡ, ΡΡΠΎ posaβ<βposb). ΠΠ°ΠΏΠΎΠΌΠ½ΠΈΠΌ Π΄Π»Ρ ΠΊΠ°ΠΆΠ΄ΠΎΠ³ΠΎ ΡΠΈΡΠ»Π° a ΡΠ°ΠΌΡΡ Π»Π΅Π²ΡΡ ΠΏΠΎΠ·ΠΈΡΠΈΡ posb ΡΠ°ΠΊΡΡ, ΡΡΠΎ (a,βb) ΠΎΠ±ΡΠ°Π·ΡΡΡ Π²ΡΠ°ΠΆΠ΄Π΅Π±Π½ΡΡ ΠΏΠ°ΡΡ. ΠΠ±ΠΎΠ·Π½Π°ΡΠΈΠΌ ΡΡΡ Π²Π΅Π»ΠΈΡΠΈΠ½Ρ za. Π’Π΅ΠΏΠ΅ΡΡ Π±ΡΠ΄Π΅ΠΌ ΠΈΠ΄ΡΠΈ ΠΏΠΎ ΠΏΠ΅ΡΠ΅ΡΡΠ°Π½ΠΎΠ²ΠΊΠ΅ ΡΠΏΡΠ°Π²Π° Π½Π°Π»Π΅Π²ΠΎ ΠΈ ΠΏΠΎΠ΄Π΄Π΅ΡΠΆΠΈΠ²Π°ΡΡ ΠΏΠΎΠ·ΠΈΡΠΈΡ rg Π½Π°ΠΈΠ±ΠΎΠ»ΡΡΠ΅Π³ΠΎ ΠΊΠΎΡΡΠ΅ΠΊΡΠ½ΠΎΠ³ΠΎ ΠΈΠ½ΡΠ΅ΡΠ²Π°Π»Π° Ρ Π»Π΅Π²ΡΠΌ ΠΊΠΎΠ½ΡΠΎΠΌ Π² ΡΠ΅ΠΊΡΡΠ΅ΠΉ ΠΏΠΎΠ·ΠΈΡΠΈΠΈ ΠΏΠ΅ΡΠ΅ΡΡΠ°Π½ΠΎΠ²ΠΊΠΈ lf. ΠΠ½Π°ΡΠ΅Π½ΠΈΠ΅ rg ΠΏΠ΅ΡΠ΅ΡΡΠΈΡΡΠ²Π°Π΅ΡΡΡ ΡΠ»Π΅Π΄ΡΡΡΠΈΠΌ ΠΎΠ±ΡΠ°Π·ΠΎΠΌ: rgβ=βmin(rg,βz[lf]). Π‘ΠΎΠΎΡΠ²Π΅ΡΡΠ²Π΅Π½Π½ΠΎ ΠΊ ΠΎΡΠ²Π΅ΡΡ Π½Π° ΠΊΠ°ΠΆΠ΄ΠΎΠΉ ΠΈΡΠ΅ΡΠ°ΡΠΈΠΈ Π½ΡΠΆΠ½ΠΎ ΠΏΡΠΈΠ±Π°Π²Π»ΡΡΡ Π²Π΅Π»ΠΈΡΠΈΠ½Ρ rgβ-βlfβ+β1.
"""
def main():
from sys import stdin
n, m = map(int, input().split())
n += 1
aa, pos, duo = [0] * n, [0] * n, [0] * n
for i, a in enumerate(map(int, input().split()), 1):
aa[i] = a
pos[a] = i
for s in stdin.read().splitlines():
x, y = map(int, s.split())
px, py = pos[x], pos[y]
if px > py:
if duo[x] < py:
duo[x] = py
else:
if duo[y] < px:
duo[y] = px
res = mx = 0
for i, a in enumerate(aa):
if mx < duo[a]:
mx = duo[a]
res += i - mx
print(res)
if __name__ == '__main__':
main()
``` | output | 1 | 99,880 | 12 | 199,761 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p of length n. Also you are given m foe pairs (ai, bi) (1 β€ ai, bi β€ n, ai β bi).
Your task is to count the number of different intervals (x, y) (1 β€ x β€ y β€ n) that do not contain any foe pairs. So you shouldn't count intervals (x, y) that contain at least one foe pair in it (the positions and order of the values from the foe pair are not important).
Consider some example: p = [1, 3, 2, 4] and foe pairs are {(3, 2), (4, 2)}. The interval (1, 3) is incorrect because it contains a foe pair (3, 2). The interval (1, 4) is also incorrect because it contains two foe pairs (3, 2) and (4, 2). But the interval (1, 2) is correct because it doesn't contain any foe pair.
Input
The first line contains two integers n and m (1 β€ n, m β€ 3Β·105) β the length of the permutation p and the number of foe pairs.
The second line contains n distinct integers pi (1 β€ pi β€ n) β the elements of the permutation p.
Each of the next m lines contains two integers (ai, bi) (1 β€ ai, bi β€ n, ai β bi) β the i-th foe pair. Note a foe pair can appear multiple times in the given list.
Output
Print the only integer c β the number of different intervals (x, y) that does not contain any foe pairs.
Note that the answer can be too large, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
4 2
1 3 2 4
3 2
2 4
Output
5
Input
9 5
9 7 2 3 1 4 6 5 8
1 6
4 5
2 7
7 2
2 7
Output
20
Note
In the first example the intervals from the answer are (1, 1), (1, 2), (2, 2), (3, 3) and (4, 4). | instruction | 0 | 99,881 | 12 | 199,762 |
Tags: combinatorics, sortings, two pointers
Correct Solution:
```
import sys # TLE without
n, m = map(int, input().split())
pos = [None] * (n + 1)
for i, a in enumerate(map(int, input().split())):
pos[a] = i
z = [300005] * (n + 1)
for pr in sys.stdin.read().splitlines():
x, y = map(int, pr.split())
if pos[x] > pos[y]:
x, y = y, x
z[pos[x]] = min(z[pos[x]], pos[y])
lf, rg, ans = n - 1, n - 1, 0
while lf >= 0:
rg = min(rg, z[lf] - 1)
ans += rg - lf + 1
lf -= 1
print(ans)
``` | output | 1 | 99,881 | 12 | 199,763 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p of length n. Also you are given m foe pairs (ai, bi) (1 β€ ai, bi β€ n, ai β bi).
Your task is to count the number of different intervals (x, y) (1 β€ x β€ y β€ n) that do not contain any foe pairs. So you shouldn't count intervals (x, y) that contain at least one foe pair in it (the positions and order of the values from the foe pair are not important).
Consider some example: p = [1, 3, 2, 4] and foe pairs are {(3, 2), (4, 2)}. The interval (1, 3) is incorrect because it contains a foe pair (3, 2). The interval (1, 4) is also incorrect because it contains two foe pairs (3, 2) and (4, 2). But the interval (1, 2) is correct because it doesn't contain any foe pair.
Input
The first line contains two integers n and m (1 β€ n, m β€ 3Β·105) β the length of the permutation p and the number of foe pairs.
The second line contains n distinct integers pi (1 β€ pi β€ n) β the elements of the permutation p.
Each of the next m lines contains two integers (ai, bi) (1 β€ ai, bi β€ n, ai β bi) β the i-th foe pair. Note a foe pair can appear multiple times in the given list.
Output
Print the only integer c β the number of different intervals (x, y) that does not contain any foe pairs.
Note that the answer can be too large, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
4 2
1 3 2 4
3 2
2 4
Output
5
Input
9 5
9 7 2 3 1 4 6 5 8
1 6
4 5
2 7
7 2
2 7
Output
20
Note
In the first example the intervals from the answer are (1, 1), (1, 2), (2, 2), (3, 3) and (4, 4). | instruction | 0 | 99,882 | 12 | 199,764 |
Tags: combinatorics, sortings, two pointers
Correct Solution:
```
import sys # TLE without
n, m = map(int, input().split())
pos = [None] * (n + 1)
for i, a in enumerate(map(int, input().split())):
pos[a] = i
z = [300005] * (n + 1)
for pr in sys.stdin.read().splitlines():
x, y = map(int, pr.split())
if pos[x] > pos[y]:
x, y = y, x
z[pos[x]] = min(z[pos[x]], pos[y])
'''
if z[pos[x]] is None:
z[pos[x]] = pos[y]
else:
z[pos[x]] = min(z[pos[x]], pos[y])
'''
lf, rg = n - 1, n - 1
ans = 0
while lf >= 0:
if z[lf] is not None:
rg = min(rg, z[lf] - 1)
ans += rg - lf + 1
lf -= 1
print(ans)
``` | output | 1 | 99,882 | 12 | 199,765 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p of length n. Also you are given m foe pairs (ai, bi) (1 β€ ai, bi β€ n, ai β bi).
Your task is to count the number of different intervals (x, y) (1 β€ x β€ y β€ n) that do not contain any foe pairs. So you shouldn't count intervals (x, y) that contain at least one foe pair in it (the positions and order of the values from the foe pair are not important).
Consider some example: p = [1, 3, 2, 4] and foe pairs are {(3, 2), (4, 2)}. The interval (1, 3) is incorrect because it contains a foe pair (3, 2). The interval (1, 4) is also incorrect because it contains two foe pairs (3, 2) and (4, 2). But the interval (1, 2) is correct because it doesn't contain any foe pair.
Input
The first line contains two integers n and m (1 β€ n, m β€ 3Β·105) β the length of the permutation p and the number of foe pairs.
The second line contains n distinct integers pi (1 β€ pi β€ n) β the elements of the permutation p.
Each of the next m lines contains two integers (ai, bi) (1 β€ ai, bi β€ n, ai β bi) β the i-th foe pair. Note a foe pair can appear multiple times in the given list.
Output
Print the only integer c β the number of different intervals (x, y) that does not contain any foe pairs.
Note that the answer can be too large, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
4 2
1 3 2 4
3 2
2 4
Output
5
Input
9 5
9 7 2 3 1 4 6 5 8
1 6
4 5
2 7
7 2
2 7
Output
20
Note
In the first example the intervals from the answer are (1, 1), (1, 2), (2, 2), (3, 3) and (4, 4). | instruction | 0 | 99,883 | 12 | 199,766 |
Tags: combinatorics, sortings, two pointers
Correct Solution:
```
import sys
n, m = map(int, sys.stdin.buffer.readline().decode('utf-8').split())
a = list(map(int, sys.stdin.buffer.readline().decode('utf-8').split()))
index = [0]*(n+1)
ng = [-1]*n
for i, x in enumerate(a):
index[x] = i
for x, y in ((map(int, line.decode('utf-8').split()))
for line in sys.stdin.buffer):
s, t = min(index[x], index[y]), max(index[x], index[y])
ng[t] = max(ng[t], s)
left = -1
ans = 0
for i in range(n):
left = max(left, ng[i])
ans += i - left
print(ans)
``` | output | 1 | 99,883 | 12 | 199,767 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p of length n. Also you are given m foe pairs (ai, bi) (1 β€ ai, bi β€ n, ai β bi).
Your task is to count the number of different intervals (x, y) (1 β€ x β€ y β€ n) that do not contain any foe pairs. So you shouldn't count intervals (x, y) that contain at least one foe pair in it (the positions and order of the values from the foe pair are not important).
Consider some example: p = [1, 3, 2, 4] and foe pairs are {(3, 2), (4, 2)}. The interval (1, 3) is incorrect because it contains a foe pair (3, 2). The interval (1, 4) is also incorrect because it contains two foe pairs (3, 2) and (4, 2). But the interval (1, 2) is correct because it doesn't contain any foe pair.
Input
The first line contains two integers n and m (1 β€ n, m β€ 3Β·105) β the length of the permutation p and the number of foe pairs.
The second line contains n distinct integers pi (1 β€ pi β€ n) β the elements of the permutation p.
Each of the next m lines contains two integers (ai, bi) (1 β€ ai, bi β€ n, ai β bi) β the i-th foe pair. Note a foe pair can appear multiple times in the given list.
Output
Print the only integer c β the number of different intervals (x, y) that does not contain any foe pairs.
Note that the answer can be too large, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
4 2
1 3 2 4
3 2
2 4
Output
5
Input
9 5
9 7 2 3 1 4 6 5 8
1 6
4 5
2 7
7 2
2 7
Output
20
Note
In the first example the intervals from the answer are (1, 1), (1, 2), (2, 2), (3, 3) and (4, 4). | instruction | 0 | 99,884 | 12 | 199,768 |
Tags: combinatorics, sortings, two pointers
Correct Solution:
```
#!/usr/bin/env python3
from __future__ import division, print_function
def solver():
import sys
blob = sys.stdin.read().split()
it = map(int, blob)
n, m = next(it), next(it)
revp = [0, ] * (n+1)
for i in range(n):
revp[next(it)] = i
pairs = [-1] * (n+1)
pairs[-1] = n-1
for _ in range(m):
a, b = next(it), next(it)
a, b = revp[a], revp[b]
if b > a:
a, b = b, a
pairs[a] = max(pairs[a], b)
res = 0
pos = 0
for right, left in enumerate(pairs):
if left == -1:
continue
for i in range(pos, left+1):
res = res + right - i
pos = max(pos, left + 1)
return res
def main():
import sys
res = solver()
sys.stdout.write("{}\n".format(res))
return 0
if __name__ == '__main__':
main()
``` | output | 1 | 99,884 | 12 | 199,769 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p of length n. Also you are given m foe pairs (ai, bi) (1 β€ ai, bi β€ n, ai β bi).
Your task is to count the number of different intervals (x, y) (1 β€ x β€ y β€ n) that do not contain any foe pairs. So you shouldn't count intervals (x, y) that contain at least one foe pair in it (the positions and order of the values from the foe pair are not important).
Consider some example: p = [1, 3, 2, 4] and foe pairs are {(3, 2), (4, 2)}. The interval (1, 3) is incorrect because it contains a foe pair (3, 2). The interval (1, 4) is also incorrect because it contains two foe pairs (3, 2) and (4, 2). But the interval (1, 2) is correct because it doesn't contain any foe pair.
Input
The first line contains two integers n and m (1 β€ n, m β€ 3Β·105) β the length of the permutation p and the number of foe pairs.
The second line contains n distinct integers pi (1 β€ pi β€ n) β the elements of the permutation p.
Each of the next m lines contains two integers (ai, bi) (1 β€ ai, bi β€ n, ai β bi) β the i-th foe pair. Note a foe pair can appear multiple times in the given list.
Output
Print the only integer c β the number of different intervals (x, y) that does not contain any foe pairs.
Note that the answer can be too large, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
4 2
1 3 2 4
3 2
2 4
Output
5
Input
9 5
9 7 2 3 1 4 6 5 8
1 6
4 5
2 7
7 2
2 7
Output
20
Note
In the first example the intervals from the answer are (1, 1), (1, 2), (2, 2), (3, 3) and (4, 4).
Submitted Solution:
```
#!/usr/bin/env python3
from __future__ import division, print_function
import sys
def solver():
import re
blob =re.split('[ \n]', sys.stdin.read())
# ~ blob = sys.stdin.read().split()
it = map(int, blob)
n, m = next(it), next(it)
revp = [0, ] * (n+1)
for i in range(n):
revp[next(it)] = i
pairs = [-1] * (n+1)
pairs[-1] = n-1
for _ in range(m):
a, b = next(it), next(it)
a, b = revp[a], revp[b]
if b > a:
a, b = b, a
pairs[a] = max(pairs[a], b)
res = 0
pos = 0
for right, left in enumerate(pairs):
if left == -1:
continue
for i in range(pos, left+1):
res = res + right - i
pos = max(pos, left + 1)
return res
def main():
res = solver()
sys.stdout.write("{}\n".format(res))
return 0
if __name__ == '__main__':
main()
``` | instruction | 0 | 99,885 | 12 | 199,770 |
Yes | output | 1 | 99,885 | 12 | 199,771 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p of length n. Also you are given m foe pairs (ai, bi) (1 β€ ai, bi β€ n, ai β bi).
Your task is to count the number of different intervals (x, y) (1 β€ x β€ y β€ n) that do not contain any foe pairs. So you shouldn't count intervals (x, y) that contain at least one foe pair in it (the positions and order of the values from the foe pair are not important).
Consider some example: p = [1, 3, 2, 4] and foe pairs are {(3, 2), (4, 2)}. The interval (1, 3) is incorrect because it contains a foe pair (3, 2). The interval (1, 4) is also incorrect because it contains two foe pairs (3, 2) and (4, 2). But the interval (1, 2) is correct because it doesn't contain any foe pair.
Input
The first line contains two integers n and m (1 β€ n, m β€ 3Β·105) β the length of the permutation p and the number of foe pairs.
The second line contains n distinct integers pi (1 β€ pi β€ n) β the elements of the permutation p.
Each of the next m lines contains two integers (ai, bi) (1 β€ ai, bi β€ n, ai β bi) β the i-th foe pair. Note a foe pair can appear multiple times in the given list.
Output
Print the only integer c β the number of different intervals (x, y) that does not contain any foe pairs.
Note that the answer can be too large, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
4 2
1 3 2 4
3 2
2 4
Output
5
Input
9 5
9 7 2 3 1 4 6 5 8
1 6
4 5
2 7
7 2
2 7
Output
20
Note
In the first example the intervals from the answer are (1, 1), (1, 2), (2, 2), (3, 3) and (4, 4).
Submitted Solution:
```
#!/usr/bin/env python3
from __future__ import division, print_function
def solver():
import sys
it = (int(x) for line in sys.stdin.read().splitlines() for x in line.split(' '))
n, m = next(it), next(it)
revp = [0, ] * (n+1)
for i in range(n):
revp[next(it)] = i
pairs = [-1] * (n+1)
pairs[-1] = n-1
for _ in range(m):
a, b = next(it), next(it)
a, b = revp[a], revp[b]
if b > a:
a, b = b, a
pairs[a] = max(pairs[a], b)
res = 0
pos = 0
for right, left in enumerate(pairs):
if left == -1:
continue
for i in range(pos, left+1):
res = res + right - i
pos = max(pos, left + 1)
return res
def main():
import sys
res = solver()
sys.stdout.write("{}\n".format(res))
return 0
if __name__ == '__main__':
main()
``` | instruction | 0 | 99,886 | 12 | 199,772 |
Yes | output | 1 | 99,886 | 12 | 199,773 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p of length n. Also you are given m foe pairs (ai, bi) (1 β€ ai, bi β€ n, ai β bi).
Your task is to count the number of different intervals (x, y) (1 β€ x β€ y β€ n) that do not contain any foe pairs. So you shouldn't count intervals (x, y) that contain at least one foe pair in it (the positions and order of the values from the foe pair are not important).
Consider some example: p = [1, 3, 2, 4] and foe pairs are {(3, 2), (4, 2)}. The interval (1, 3) is incorrect because it contains a foe pair (3, 2). The interval (1, 4) is also incorrect because it contains two foe pairs (3, 2) and (4, 2). But the interval (1, 2) is correct because it doesn't contain any foe pair.
Input
The first line contains two integers n and m (1 β€ n, m β€ 3Β·105) β the length of the permutation p and the number of foe pairs.
The second line contains n distinct integers pi (1 β€ pi β€ n) β the elements of the permutation p.
Each of the next m lines contains two integers (ai, bi) (1 β€ ai, bi β€ n, ai β bi) β the i-th foe pair. Note a foe pair can appear multiple times in the given list.
Output
Print the only integer c β the number of different intervals (x, y) that does not contain any foe pairs.
Note that the answer can be too large, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
4 2
1 3 2 4
3 2
2 4
Output
5
Input
9 5
9 7 2 3 1 4 6 5 8
1 6
4 5
2 7
7 2
2 7
Output
20
Note
In the first example the intervals from the answer are (1, 1), (1, 2), (2, 2), (3, 3) and (4, 4).
Submitted Solution:
```
def main():
from sys import stdin
n, m = map(int, input().split())
n += 1
aa, pos, duo = [0] * n, [0] * n, [0] * n
for i, a in enumerate(map(int, input().split()), 1):
aa[i] = a
pos[a] = i
for s in stdin.read().splitlines():
x, y = map(int, s.split())
px, py = pos[x], pos[y]
if px > py:
if duo[x] < py:
duo[x] = py
else:
if duo[y] < px:
duo[y] = px
res = mx = 0
for i, a in enumerate(aa):
if mx < duo[a]:
mx = duo[a]
res += i - mx
print(res)
if __name__ == '__main__':
main()
# Made By Mostafa_Khaled
``` | instruction | 0 | 99,887 | 12 | 199,774 |
Yes | output | 1 | 99,887 | 12 | 199,775 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p of length n. Also you are given m foe pairs (ai, bi) (1 β€ ai, bi β€ n, ai β bi).
Your task is to count the number of different intervals (x, y) (1 β€ x β€ y β€ n) that do not contain any foe pairs. So you shouldn't count intervals (x, y) that contain at least one foe pair in it (the positions and order of the values from the foe pair are not important).
Consider some example: p = [1, 3, 2, 4] and foe pairs are {(3, 2), (4, 2)}. The interval (1, 3) is incorrect because it contains a foe pair (3, 2). The interval (1, 4) is also incorrect because it contains two foe pairs (3, 2) and (4, 2). But the interval (1, 2) is correct because it doesn't contain any foe pair.
Input
The first line contains two integers n and m (1 β€ n, m β€ 3Β·105) β the length of the permutation p and the number of foe pairs.
The second line contains n distinct integers pi (1 β€ pi β€ n) β the elements of the permutation p.
Each of the next m lines contains two integers (ai, bi) (1 β€ ai, bi β€ n, ai β bi) β the i-th foe pair. Note a foe pair can appear multiple times in the given list.
Output
Print the only integer c β the number of different intervals (x, y) that does not contain any foe pairs.
Note that the answer can be too large, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
4 2
1 3 2 4
3 2
2 4
Output
5
Input
9 5
9 7 2 3 1 4 6 5 8
1 6
4 5
2 7
7 2
2 7
Output
20
Note
In the first example the intervals from the answer are (1, 1), (1, 2), (2, 2), (3, 3) and (4, 4).
Submitted Solution:
```
import sys
def FoePairs():
n,m=sys.stdin.readline().split()
n=int(n)
m=int(m)
s=n+1
p=[0]*s
pos_p=[0]*s
closest_pos=[0]*s
i=1
#recive la permutacion p y guarda en un nuevo arreglo las posiciones
#de esos valores en el arrreglo sin permutar
line=sys.stdin.readline().split()
while i<s:
t=int(line[i-1])
p[i]=t
pos_p[t]=i
i+=1
#recive los m foe pairs y determina para cada intervalo (x,y) el mayor par posible que contenga a y
# como extremo derecho
for x in range(0,m):
start,finish= sys.stdin.readline().split()
start=int(start)
finish=int(finish)
p_finish=pos_p[finish]
p_start=pos_p[start]
if p_finish>p_start:
closest_pos[finish]=max(closest_pos[finish],p_start)
else:
closest_pos[start]=max(closest_pos[start],p_finish)
i=1
respuesta=0
current_closest_pos=0
while i<s:
current_closest_pos=max(current_closest_pos,closest_pos[p[i]])
respuesta+=i-current_closest_pos
i+=1
print(respuesta)
FoePairs()
``` | instruction | 0 | 99,888 | 12 | 199,776 |
Yes | output | 1 | 99,888 | 12 | 199,777 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p of length n. Also you are given m foe pairs (ai, bi) (1 β€ ai, bi β€ n, ai β bi).
Your task is to count the number of different intervals (x, y) (1 β€ x β€ y β€ n) that do not contain any foe pairs. So you shouldn't count intervals (x, y) that contain at least one foe pair in it (the positions and order of the values from the foe pair are not important).
Consider some example: p = [1, 3, 2, 4] and foe pairs are {(3, 2), (4, 2)}. The interval (1, 3) is incorrect because it contains a foe pair (3, 2). The interval (1, 4) is also incorrect because it contains two foe pairs (3, 2) and (4, 2). But the interval (1, 2) is correct because it doesn't contain any foe pair.
Input
The first line contains two integers n and m (1 β€ n, m β€ 3Β·105) β the length of the permutation p and the number of foe pairs.
The second line contains n distinct integers pi (1 β€ pi β€ n) β the elements of the permutation p.
Each of the next m lines contains two integers (ai, bi) (1 β€ ai, bi β€ n, ai β bi) β the i-th foe pair. Note a foe pair can appear multiple times in the given list.
Output
Print the only integer c β the number of different intervals (x, y) that does not contain any foe pairs.
Note that the answer can be too large, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
4 2
1 3 2 4
3 2
2 4
Output
5
Input
9 5
9 7 2 3 1 4 6 5 8
1 6
4 5
2 7
7 2
2 7
Output
20
Note
In the first example the intervals from the answer are (1, 1), (1, 2), (2, 2), (3, 3) and (4, 4).
Submitted Solution:
```
#! /usr/bin/env python3
'''
' Title:
' Author: Cheng-Shih, Wong
' Date:
'''
def numOfRange( num ):
if num < 2: return 0
return num*(num-1)//2
n, m = map(int, input().split())
p = [int(i) for i in input().split()]
q = [0]*(n+1)
for i in range(n): q[p[i]] = i
vis = set()
for i in range(m):
u, v = map(int, input().split())
u, v = q[u], q[v]
if u > v: u, v = v, u
vis.add((u,v))
ps = list(vis)
ps.sort()
cover = [False]*len(ps)
for i in range(len(ps)):
for j in range(i+1, len(ps)):
if ps[i][1] <= ps[j][0]: break
if ps[i][0]<=ps[j][0] and ps[j][1]<=ps[i][1]: cover[i] = True
nps = []
for i in range(len(ps)):
if not cover[i]: nps.append(ps[i])
ans = 0
for i in range(len(nps)-1):
j = i+1
ans += numOfRange(nps[j][1]-nps[i][0]-1)
ans += n+numOfRange(nps[0][1])+numOfRange(n-nps[-1][0]-1)
print( ans )
``` | instruction | 0 | 99,889 | 12 | 199,778 |
No | output | 1 | 99,889 | 12 | 199,779 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p of length n. Also you are given m foe pairs (ai, bi) (1 β€ ai, bi β€ n, ai β bi).
Your task is to count the number of different intervals (x, y) (1 β€ x β€ y β€ n) that do not contain any foe pairs. So you shouldn't count intervals (x, y) that contain at least one foe pair in it (the positions and order of the values from the foe pair are not important).
Consider some example: p = [1, 3, 2, 4] and foe pairs are {(3, 2), (4, 2)}. The interval (1, 3) is incorrect because it contains a foe pair (3, 2). The interval (1, 4) is also incorrect because it contains two foe pairs (3, 2) and (4, 2). But the interval (1, 2) is correct because it doesn't contain any foe pair.
Input
The first line contains two integers n and m (1 β€ n, m β€ 3Β·105) β the length of the permutation p and the number of foe pairs.
The second line contains n distinct integers pi (1 β€ pi β€ n) β the elements of the permutation p.
Each of the next m lines contains two integers (ai, bi) (1 β€ ai, bi β€ n, ai β bi) β the i-th foe pair. Note a foe pair can appear multiple times in the given list.
Output
Print the only integer c β the number of different intervals (x, y) that does not contain any foe pairs.
Note that the answer can be too large, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
4 2
1 3 2 4
3 2
2 4
Output
5
Input
9 5
9 7 2 3 1 4 6 5 8
1 6
4 5
2 7
7 2
2 7
Output
20
Note
In the first example the intervals from the answer are (1, 1), (1, 2), (2, 2), (3, 3) and (4, 4).
Submitted Solution:
```
n = input()
letters = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"]
#for i in range(len(n)):
#n1.append(n[i])
l = len(n)
n1 = [0] * l
k = 0
t = 0
for i in range(l):
t = 0
for j in range(i + 1, l):
if n[j] != "?" and (n[j] in n[i:j]):
t = 1
if j - i == 25 and t == 0:
k = 1
break
if k == 1:
break
else:
print(-1)
if k == 1:
for s in range(l):
if n[s] == "?":
for k in range(26):
if i <= s and s <= j and (n[i:j + 1].count(letters[k]) == 0):
n1[s] = letters[k]
if s < i or s > j:
n1[s] = letters[0]
else:
n1[s] = n[s]
print("".join(map(str, n1)))
``` | instruction | 0 | 99,890 | 12 | 199,780 |
No | output | 1 | 99,890 | 12 | 199,781 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p of length n. Also you are given m foe pairs (ai, bi) (1 β€ ai, bi β€ n, ai β bi).
Your task is to count the number of different intervals (x, y) (1 β€ x β€ y β€ n) that do not contain any foe pairs. So you shouldn't count intervals (x, y) that contain at least one foe pair in it (the positions and order of the values from the foe pair are not important).
Consider some example: p = [1, 3, 2, 4] and foe pairs are {(3, 2), (4, 2)}. The interval (1, 3) is incorrect because it contains a foe pair (3, 2). The interval (1, 4) is also incorrect because it contains two foe pairs (3, 2) and (4, 2). But the interval (1, 2) is correct because it doesn't contain any foe pair.
Input
The first line contains two integers n and m (1 β€ n, m β€ 3Β·105) β the length of the permutation p and the number of foe pairs.
The second line contains n distinct integers pi (1 β€ pi β€ n) β the elements of the permutation p.
Each of the next m lines contains two integers (ai, bi) (1 β€ ai, bi β€ n, ai β bi) β the i-th foe pair. Note a foe pair can appear multiple times in the given list.
Output
Print the only integer c β the number of different intervals (x, y) that does not contain any foe pairs.
Note that the answer can be too large, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
4 2
1 3 2 4
3 2
2 4
Output
5
Input
9 5
9 7 2 3 1 4 6 5 8
1 6
4 5
2 7
7 2
2 7
Output
20
Note
In the first example the intervals from the answer are (1, 1), (1, 2), (2, 2), (3, 3) and (4, 4).
Submitted Solution:
```
#import sys
#sys.stdin = open('in', 'r')
#n = int(input())
n,m = map(int, input().split())
p = [int(x) for x in input().split()]
ind = [0]*(n+1)
l = [0]*n
for i in range(n):
ind[p[i]] = i
for i in range(m):
a,b = map(int, input().split())
x1 = min(ind[a], ind[b])
x2 = max(ind[a], ind[b])
d = x2 - x1
l[x2] = d if l[x2] == 0 else min(d, l[x2])
res = 0
i = 0
cnt = 0
while i < n:
if l[i] == 0:
cnt += 1
else:
res += (1 + cnt)*cnt // 2
cnt = l[i]
res -= cnt*(cnt-1)//2
i += 1
if cnt > 0:
res += (1 + cnt)*cnt // 2
print(res)
``` | instruction | 0 | 99,891 | 12 | 199,782 |
No | output | 1 | 99,891 | 12 | 199,783 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p of length n. Also you are given m foe pairs (ai, bi) (1 β€ ai, bi β€ n, ai β bi).
Your task is to count the number of different intervals (x, y) (1 β€ x β€ y β€ n) that do not contain any foe pairs. So you shouldn't count intervals (x, y) that contain at least one foe pair in it (the positions and order of the values from the foe pair are not important).
Consider some example: p = [1, 3, 2, 4] and foe pairs are {(3, 2), (4, 2)}. The interval (1, 3) is incorrect because it contains a foe pair (3, 2). The interval (1, 4) is also incorrect because it contains two foe pairs (3, 2) and (4, 2). But the interval (1, 2) is correct because it doesn't contain any foe pair.
Input
The first line contains two integers n and m (1 β€ n, m β€ 3Β·105) β the length of the permutation p and the number of foe pairs.
The second line contains n distinct integers pi (1 β€ pi β€ n) β the elements of the permutation p.
Each of the next m lines contains two integers (ai, bi) (1 β€ ai, bi β€ n, ai β bi) β the i-th foe pair. Note a foe pair can appear multiple times in the given list.
Output
Print the only integer c β the number of different intervals (x, y) that does not contain any foe pairs.
Note that the answer can be too large, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
4 2
1 3 2 4
3 2
2 4
Output
5
Input
9 5
9 7 2 3 1 4 6 5 8
1 6
4 5
2 7
7 2
2 7
Output
20
Note
In the first example the intervals from the answer are (1, 1), (1, 2), (2, 2), (3, 3) and (4, 4).
Submitted 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 bin(n):
return n*(n-1) // 2
n,m = li()
p = li(-1)
c = [set() for i in range(n)]
for el in range(m):
x, y = li(-1)
c[x].add(y)
c[y].add(x)
used = [0] * n
i, f = 0, 0
co = n
while f + 1 < n:
used[p[i]] = 1
f += 1
flag = 1
for el in c[p[f]]:
if used[el] == 1:
flag = 0
if flag == 0:
j = f-1
trovato = 0
while j >= i:
if trovato:
used[p[j]] = 0
else:
if p[j] in c[p[f]]:
used[p[j]] = 0
i = j + 1
trovato = 1
j -= 1
co += f - i
else:
used[p[f]] = 1
co += f - i
print(co)
``` | instruction | 0 | 99,892 | 12 | 199,784 |
No | output | 1 | 99,892 | 12 | 199,785 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array consisting of n non-negative integers a1, a2, ..., an.
You are going to destroy integers in the array one by one. Thus, you are given the permutation of integers from 1 to n defining the order elements of the array are destroyed.
After each element is destroyed you have to find out the segment of the array, such that it contains no destroyed elements and the sum of its elements is maximum possible. The sum of elements in the empty segment is considered to be 0.
Input
The first line of the input contains a single integer n (1 β€ n β€ 100 000) β the length of the array.
The second line contains n integers a1, a2, ..., an (0 β€ ai β€ 109).
The third line contains a permutation of integers from 1 to n β the order used to destroy elements.
Output
Print n lines. The i-th line should contain a single integer β the maximum possible sum of elements on the segment containing no destroyed elements, after first i operations are performed.
Examples
Input
4
1 3 2 5
3 4 1 2
Output
5
4
3
0
Input
5
1 2 3 4 5
4 2 3 5 1
Output
6
5
5
1
0
Input
8
5 5 4 4 6 6 5 5
5 2 8 7 1 3 4 6
Output
18
16
11
8
8
6
6
0
Note
Consider the first sample:
1. Third element is destroyed. Array is now 1 3 * 5. Segment with maximum sum 5 consists of one integer 5.
2. Fourth element is destroyed. Array is now 1 3 * * . Segment with maximum sum 4 consists of two integers 1 3.
3. First element is destroyed. Array is now * 3 * * . Segment with maximum sum 3 consists of one integer 3.
4. Last element is destroyed. At this moment there are no valid nonempty segments left in this array, so the answer is equal to 0. | instruction | 0 | 99,925 | 12 | 199,850 |
Tags: data structures, dsu
Correct Solution:
```
#!/usr/bin/python3
size = int(input())
num = list(map(int, input().split()))
rem = reversed(list(map(lambda x: int(x) - 1, input().split())))
chunks = [None] * size
res = [-1] * size
ans = [0] * size
ms = -1
def addChunk(n):
chunks[n] = [n, num[n]]
return n
def getRoot(n):
while chunks[n][0] != n:
n = chunks[n][0]
return n
def mergeChunks(parent, child):
proot = getRoot(parent)
croot = getRoot(child)
chunks[croot][0] = proot
chunks[proot][1] += chunks[croot][1]
return proot
for i in rem:
res[i] = num[i]
root = addChunk(i)
if i > 0 and chunks[i - 1] != None:
root = mergeChunks(i - 1, i)
if i + 1 < size and chunks[i + 1] != None:
root = mergeChunks(i, i + 1)
ms = max(ms, chunks[root][1])
ans.append(ms)
for i in range(1, size):
print (ans[-i-1])
print(0)
``` | output | 1 | 99,925 | 12 | 199,851 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array consisting of n non-negative integers a1, a2, ..., an.
You are going to destroy integers in the array one by one. Thus, you are given the permutation of integers from 1 to n defining the order elements of the array are destroyed.
After each element is destroyed you have to find out the segment of the array, such that it contains no destroyed elements and the sum of its elements is maximum possible. The sum of elements in the empty segment is considered to be 0.
Input
The first line of the input contains a single integer n (1 β€ n β€ 100 000) β the length of the array.
The second line contains n integers a1, a2, ..., an (0 β€ ai β€ 109).
The third line contains a permutation of integers from 1 to n β the order used to destroy elements.
Output
Print n lines. The i-th line should contain a single integer β the maximum possible sum of elements on the segment containing no destroyed elements, after first i operations are performed.
Examples
Input
4
1 3 2 5
3 4 1 2
Output
5
4
3
0
Input
5
1 2 3 4 5
4 2 3 5 1
Output
6
5
5
1
0
Input
8
5 5 4 4 6 6 5 5
5 2 8 7 1 3 4 6
Output
18
16
11
8
8
6
6
0
Note
Consider the first sample:
1. Third element is destroyed. Array is now 1 3 * 5. Segment with maximum sum 5 consists of one integer 5.
2. Fourth element is destroyed. Array is now 1 3 * * . Segment with maximum sum 4 consists of two integers 1 3.
3. First element is destroyed. Array is now * 3 * * . Segment with maximum sum 3 consists of one integer 3.
4. Last element is destroyed. At this moment there are no valid nonempty segments left in this array, so the answer is equal to 0. | instruction | 0 | 99,926 | 12 | 199,852 |
Tags: data structures, dsu
Correct Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Dec 9 16:14:34 2016
@author: kostiantyn.omelianchuk
"""
from sys import stdin, stdout
lines = stdin.readlines()
n = int(lines[0])
a = [int(x) for x in lines[1].split()]
b = [int(x) for x in lines[2].split()]
check_array = [0 for i in range(n)]
snm = [i for i in range(n)]
r = [1 for i in range(n)]
sums = dict(zip(range(n), a))
def find_x(x):
if snm[x] != x:
snm[x] = find_x(snm[x])
return snm[x]
def union(x_start, y_start):
x = find_x(x_start)
y = find_x(y_start)
sums[x] += sums[y]
sums[y] = sums[x]
if x == y:
return x
#sums[x] += sums[x_start]
if r[x] == r[y]:
r[x] += 1
if r[x] < r[y]:
snm[x] = y
return y
else:
snm[y] = x
return x
max_list = []
total_max = 0
for i in range(n):
cur_sum = 0
flag = 0
max_list.append(total_max)
#pos = n-i-1
elem = b[n-i-1] - 1
check_array[elem] = 1
#pos_x = find_x(elem)
if elem>0:
if check_array[elem-1] == 1:
pos = union(elem-1,elem)
cur_sum = sums[pos]
#print(sums, check_array, total_max, cur_sum, elem, find_x(elem))
else:
flag += 1
else:
flag += 1
if elem<(n-1):
if check_array[elem+1] == 1:
pos = union(elem,elem+1)
cur_sum = sums[pos]
#print(sums, check_array, total_max, cur_sum, elem, find_x(elem))
else:
flag += 1
else:
flag += 1
if flag == 2:
total_max = max(total_max,sums[elem])
else:
total_max = max(cur_sum, total_max)
max_list.append(total_max)
for j in range(1,n+1):
print(max_list[n-j])
``` | output | 1 | 99,926 | 12 | 199,853 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array consisting of n non-negative integers a1, a2, ..., an.
You are going to destroy integers in the array one by one. Thus, you are given the permutation of integers from 1 to n defining the order elements of the array are destroyed.
After each element is destroyed you have to find out the segment of the array, such that it contains no destroyed elements and the sum of its elements is maximum possible. The sum of elements in the empty segment is considered to be 0.
Input
The first line of the input contains a single integer n (1 β€ n β€ 100 000) β the length of the array.
The second line contains n integers a1, a2, ..., an (0 β€ ai β€ 109).
The third line contains a permutation of integers from 1 to n β the order used to destroy elements.
Output
Print n lines. The i-th line should contain a single integer β the maximum possible sum of elements on the segment containing no destroyed elements, after first i operations are performed.
Examples
Input
4
1 3 2 5
3 4 1 2
Output
5
4
3
0
Input
5
1 2 3 4 5
4 2 3 5 1
Output
6
5
5
1
0
Input
8
5 5 4 4 6 6 5 5
5 2 8 7 1 3 4 6
Output
18
16
11
8
8
6
6
0
Note
Consider the first sample:
1. Third element is destroyed. Array is now 1 3 * 5. Segment with maximum sum 5 consists of one integer 5.
2. Fourth element is destroyed. Array is now 1 3 * * . Segment with maximum sum 4 consists of two integers 1 3.
3. First element is destroyed. Array is now * 3 * * . Segment with maximum sum 3 consists of one integer 3.
4. Last element is destroyed. At this moment there are no valid nonempty segments left in this array, so the answer is equal to 0. | instruction | 0 | 99,927 | 12 | 199,854 |
Tags: data structures, dsu
Correct Solution:
```
import sys
MAX = 100005
arr = MAX * [0]
pre = MAX * [0]
ix = MAX * [0]
sun = MAX * [0]
ans = MAX * [0]
vis = MAX * [False]
mx = 0
def find(x):
if x == pre[x]:
return x
pre[x] = find(pre[x])
return pre[x]
def unite(x, y):
dx = find(x)
dy = find(y)
if dx == dy:
return
pre[dx] = dy
sun[dy] += sun[dx]
n = int(input())
arr = [int(i) for i in input().split()]
arr.insert(0, 0)
sun = arr
pre = [i for i in range(n+1)]
ix = [int(i) for i in input().split()]
for i in range(n-1, -1, -1):
x = ix[i]
ans[i] = mx
vis[x] = True
if x != 1 and vis[x-1]:
unite(x-1, x)
if x != n and vis[x+1]:
unite(x, x+1)
mx = max(mx, sun[find(x)])
for i in range(n):
print(ans[i])
``` | output | 1 | 99,927 | 12 | 199,855 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array consisting of n non-negative integers a1, a2, ..., an.
You are going to destroy integers in the array one by one. Thus, you are given the permutation of integers from 1 to n defining the order elements of the array are destroyed.
After each element is destroyed you have to find out the segment of the array, such that it contains no destroyed elements and the sum of its elements is maximum possible. The sum of elements in the empty segment is considered to be 0.
Input
The first line of the input contains a single integer n (1 β€ n β€ 100 000) β the length of the array.
The second line contains n integers a1, a2, ..., an (0 β€ ai β€ 109).
The third line contains a permutation of integers from 1 to n β the order used to destroy elements.
Output
Print n lines. The i-th line should contain a single integer β the maximum possible sum of elements on the segment containing no destroyed elements, after first i operations are performed.
Examples
Input
4
1 3 2 5
3 4 1 2
Output
5
4
3
0
Input
5
1 2 3 4 5
4 2 3 5 1
Output
6
5
5
1
0
Input
8
5 5 4 4 6 6 5 5
5 2 8 7 1 3 4 6
Output
18
16
11
8
8
6
6
0
Note
Consider the first sample:
1. Third element is destroyed. Array is now 1 3 * 5. Segment with maximum sum 5 consists of one integer 5.
2. Fourth element is destroyed. Array is now 1 3 * * . Segment with maximum sum 4 consists of two integers 1 3.
3. First element is destroyed. Array is now * 3 * * . Segment with maximum sum 3 consists of one integer 3.
4. Last element is destroyed. At this moment there are no valid nonempty segments left in this array, so the answer is equal to 0. | instruction | 0 | 99,928 | 12 | 199,856 |
Tags: data structures, dsu
Correct Solution:
```
import sys
input = sys.stdin.readline
class Unionfind:
def __init__(self, n):
self.par = [-1]*n
self.rank = [1]*n
def root(self, x):
p = x
while not self.par[p]<0:
p = self.par[p]
while x!=p:
tmp = x
x = self.par[x]
self.par[tmp] = p
return p
def unite(self, x, y):
rx, ry = self.root(x), self.root(y)
if rx==ry: return False
if self.rank[rx]<self.rank[ry]:
rx, ry = ry, rx
self.par[rx] += self.par[ry]
self.par[ry] = rx
if self.rank[rx]==self.rank[ry]:
self.rank[rx] += 1
def is_same(self, x, y):
return self.root(x)==self.root(y)
def count(self, x):
return -self.par[self.root(x)]
n = int(input())
a = list(map(int, input().split()))
p = list(map(int, input().split()))
uf = Unionfind(n)
V = [0]*n
flag = [False]*n
ans = [0]
for pi in p[::-1]:
pi -= 1
V[pi] = a[pi]
flag[pi] = True
if pi-1>=0 and flag[pi-1]:
v = V[uf.root(pi-1)]+V[uf.root(pi)]
uf.unite(pi-1, pi)
V[uf.root(pi)] = v
if pi+1<n and flag[pi+1]:
v = V[uf.root(pi+1)]+V[uf.root(pi)]
uf.unite(pi, pi+1)
V[uf.root(pi)] = v
ans.append(max(ans[-1], V[uf.root(pi)]))
for ans_i in ans[:-1][::-1]:
print(ans_i)
``` | output | 1 | 99,928 | 12 | 199,857 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array consisting of n non-negative integers a1, a2, ..., an.
You are going to destroy integers in the array one by one. Thus, you are given the permutation of integers from 1 to n defining the order elements of the array are destroyed.
After each element is destroyed you have to find out the segment of the array, such that it contains no destroyed elements and the sum of its elements is maximum possible. The sum of elements in the empty segment is considered to be 0.
Input
The first line of the input contains a single integer n (1 β€ n β€ 100 000) β the length of the array.
The second line contains n integers a1, a2, ..., an (0 β€ ai β€ 109).
The third line contains a permutation of integers from 1 to n β the order used to destroy elements.
Output
Print n lines. The i-th line should contain a single integer β the maximum possible sum of elements on the segment containing no destroyed elements, after first i operations are performed.
Examples
Input
4
1 3 2 5
3 4 1 2
Output
5
4
3
0
Input
5
1 2 3 4 5
4 2 3 5 1
Output
6
5
5
1
0
Input
8
5 5 4 4 6 6 5 5
5 2 8 7 1 3 4 6
Output
18
16
11
8
8
6
6
0
Note
Consider the first sample:
1. Third element is destroyed. Array is now 1 3 * 5. Segment with maximum sum 5 consists of one integer 5.
2. Fourth element is destroyed. Array is now 1 3 * * . Segment with maximum sum 4 consists of two integers 1 3.
3. First element is destroyed. Array is now * 3 * * . Segment with maximum sum 3 consists of one integer 3.
4. Last element is destroyed. At this moment there are no valid nonempty segments left in this array, so the answer is equal to 0. | instruction | 0 | 99,929 | 12 | 199,858 |
Tags: data structures, dsu
Correct Solution:
```
class DSU:
def __init__(self, n):
self.par = list(range(n))
self.arr = list(map(int, input().split()))
self.siz = [1] * n
self.sht = [0] * n
self.max = 0
def find(self, n):
nn = n
while nn != self.par[nn]:
nn = self.par[nn]
while n != nn:
self.par[n], n = nn, self.par[n]
return n
def union(self, a, b):
a = self.find(a)
b = self.find(b)
if a == b:
return
if self.siz[a] < self.siz[b]:
a, b = b, a
self.par[b] = a
self.siz[a] += self.siz[b]
self.arr[a] += self.arr[b]
if self.arr[a] > self.max:
self.max = self.arr[a]
def add_node(self, n):
self.sht[n] = 1
if self.arr[n] > self.max:
self.max = self.arr[n]
if n != len(self.par) - 1 and self.sht[n + 1]:
self.union(n, n + 1)
if n != 0 and self.sht[n - 1]:
self.union(n, n - 1)
def main():
import sys
input = sys.stdin.readline
n = int(input())
dsu = DSU(n)
per = list(map(int, input().split()))
ans = [0] * n
for i in range(n):
ans[~i] = dsu.max
dsu.add_node(per[~i] - 1)
for x in ans:
print(x)
return 0
main()
``` | output | 1 | 99,929 | 12 | 199,859 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array consisting of n non-negative integers a1, a2, ..., an.
You are going to destroy integers in the array one by one. Thus, you are given the permutation of integers from 1 to n defining the order elements of the array are destroyed.
After each element is destroyed you have to find out the segment of the array, such that it contains no destroyed elements and the sum of its elements is maximum possible. The sum of elements in the empty segment is considered to be 0.
Input
The first line of the input contains a single integer n (1 β€ n β€ 100 000) β the length of the array.
The second line contains n integers a1, a2, ..., an (0 β€ ai β€ 109).
The third line contains a permutation of integers from 1 to n β the order used to destroy elements.
Output
Print n lines. The i-th line should contain a single integer β the maximum possible sum of elements on the segment containing no destroyed elements, after first i operations are performed.
Examples
Input
4
1 3 2 5
3 4 1 2
Output
5
4
3
0
Input
5
1 2 3 4 5
4 2 3 5 1
Output
6
5
5
1
0
Input
8
5 5 4 4 6 6 5 5
5 2 8 7 1 3 4 6
Output
18
16
11
8
8
6
6
0
Note
Consider the first sample:
1. Third element is destroyed. Array is now 1 3 * 5. Segment with maximum sum 5 consists of one integer 5.
2. Fourth element is destroyed. Array is now 1 3 * * . Segment with maximum sum 4 consists of two integers 1 3.
3. First element is destroyed. Array is now * 3 * * . Segment with maximum sum 3 consists of one integer 3.
4. Last element is destroyed. At this moment there are no valid nonempty segments left in this array, so the answer is equal to 0. | instruction | 0 | 99,930 | 12 | 199,860 |
Tags: data structures, dsu
Correct Solution:
```
def main():
n, aa = int(input()), [0, *map(int, input().split()), 0]
l, clusters, mx = list(map(int, input().split())), [0] * (n + 2), 0
for i in range(n - 1, -1, -1):
a = clusters[a] = l[i]
l[i] = mx
for i in a - 1, a + 1:
if clusters[i]:
stack, j = [], i
while j != clusters[j]:
stack.append(j)
j = clusters[j]
for i in stack:
clusters[i] = j
aa[a] += aa[j]
clusters[j] = a
if mx < aa[a]:
mx = aa[a]
print('\n'.join(map(str, l)))
if __name__ == '__main__':
main()
``` | output | 1 | 99,930 | 12 | 199,861 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.