message stringlengths 2 22.8k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 16 109k | cluster float64 1 1 | __index_level_0__ int64 32 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n houses along the road where Anya lives, each one is painted in one of k possible colors.
Anya likes walking along this road, but she doesn't like when two adjacent houses at the road have the same color. She wants to select a long segment of the road such that no two adjacent houses have the same color.
Help Anya find the longest segment with this property.
Input
The first line contains two integers n and k — the number of houses and the number of colors (1 ≤ n ≤ 100 000, 1 ≤ k ≤ 100 000).
The next line contains n integers a_1, a_2, …, a_n — the colors of the houses along the road (1 ≤ a_i ≤ k).
Output
Output a single integer — the maximum number of houses on the road segment having no two adjacent houses of the same color.
Example
Input
8 3
1 2 3 3 2 1 2 2
Output
4
Note
In the example, the longest segment without neighboring houses of the same color is from the house 4 to the house 7. The colors of the houses are [3, 2, 1, 2] and its length is 4 houses. | instruction | 0 | 30,993 | 1 | 61,986 |
Tags: implementation
Correct Solution:
```
n,k=map(int,input().split())
l=list(map(int,input().split()))
ans=1
z=[]
if n==1:
print(1)
exit()
for i in range(n-1):
if l[i]!=l[i+1]:
ans+=1
z.append(ans)
else:
ans=1
z.append(ans)
print(max(z))
``` | output | 1 | 30,993 | 1 | 61,987 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n houses along the road where Anya lives, each one is painted in one of k possible colors.
Anya likes walking along this road, but she doesn't like when two adjacent houses at the road have the same color. She wants to select a long segment of the road such that no two adjacent houses have the same color.
Help Anya find the longest segment with this property.
Input
The first line contains two integers n and k — the number of houses and the number of colors (1 ≤ n ≤ 100 000, 1 ≤ k ≤ 100 000).
The next line contains n integers a_1, a_2, …, a_n — the colors of the houses along the road (1 ≤ a_i ≤ k).
Output
Output a single integer — the maximum number of houses on the road segment having no two adjacent houses of the same color.
Example
Input
8 3
1 2 3 3 2 1 2 2
Output
4
Note
In the example, the longest segment without neighboring houses of the same color is from the house 4 to the house 7. The colors of the houses are [3, 2, 1, 2] and its length is 4 houses. | instruction | 0 | 30,997 | 1 | 61,994 |
Tags: implementation
Correct Solution:
```
n,k = list(map(int,input().split()))
houses = list(map(int,input().split()))
stack = []
maxi = 0
for h in houses:
if stack != []:
if h == stack[-1]:
maxi = max(maxi,len(stack))
stack = [h]
else:
stack.append(h)
else:
stack.append(h)
maxi = max(maxi,1)
maxi = max(maxi,len(stack))
print(maxi)
``` | output | 1 | 30,997 | 1 | 61,995 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n houses along the road where Anya lives, each one is painted in one of k possible colors.
Anya likes walking along this road, but she doesn't like when two adjacent houses at the road have the same color. She wants to select a long segment of the road such that no two adjacent houses have the same color.
Help Anya find the longest segment with this property.
Input
The first line contains two integers n and k — the number of houses and the number of colors (1 ≤ n ≤ 100 000, 1 ≤ k ≤ 100 000).
The next line contains n integers a_1, a_2, …, a_n — the colors of the houses along the road (1 ≤ a_i ≤ k).
Output
Output a single integer — the maximum number of houses on the road segment having no two adjacent houses of the same color.
Example
Input
8 3
1 2 3 3 2 1 2 2
Output
4
Note
In the example, the longest segment without neighboring houses of the same color is from the house 4 to the house 7. The colors of the houses are [3, 2, 1, 2] and its length is 4 houses. | instruction | 0 | 30,998 | 1 | 61,996 |
Tags: implementation
Correct Solution:
```
#
# Вдоль дороги, на которой живёт Аня, стоят n домов, каждый из которых раскрашен в один из k цветов.
#
# Аня любит гулять вдоль дороги, но ей не нравится, когда подряд стоят два дома, раскрашенных в один и тот же цвет. Она хочет выбрать такой участок для прогулки, вдоль которого никакие два соседних дома не раскрашены в один цвет.
#
# Помогите Ане найти участок дороги, содержащий максимальное число домов, вдоль которого ей будет приятно гулять.
#
# Входные данные
# Первая строка ввода содержит два целых числа n и k — количество домов и количество цветов (1≤n≤100000, 1≤k≤100000).
#
# Вторая строка содержит n целых чисел a1,a2,…,an — цвета домов вдоль дороги (1≤ai≤k).
#
# Выходные данные
# Выведите одно число — максимальное количество домов на участке дороги, вдоль которого Ане приятно гулят
n = input()
s = input().split()
a = 1
maxa = 1
for q in range(len(s) - 1):
if s[q] == s[q + 1]:
if maxa < a:
maxa = a
a = 1
else:
a += 1
if maxa < a:
maxa = a
print(maxa)
``` | output | 1 | 30,998 | 1 | 61,997 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n houses along the road where Anya lives, each one is painted in one of k possible colors.
Anya likes walking along this road, but she doesn't like when two adjacent houses at the road have the same color. She wants to select a long segment of the road such that no two adjacent houses have the same color.
Help Anya find the longest segment with this property.
Input
The first line contains two integers n and k — the number of houses and the number of colors (1 ≤ n ≤ 100 000, 1 ≤ k ≤ 100 000).
The next line contains n integers a_1, a_2, …, a_n — the colors of the houses along the road (1 ≤ a_i ≤ k).
Output
Output a single integer — the maximum number of houses on the road segment having no two adjacent houses of the same color.
Example
Input
8 3
1 2 3 3 2 1 2 2
Output
4
Note
In the example, the longest segment without neighboring houses of the same color is from the house 4 to the house 7. The colors of the houses are [3, 2, 1, 2] and its length is 4 houses.
Submitted Solution:
```
n,k = map(int,input().split(" "))
a = list(map(int, input().split(" ")))
res = 1
curr = 1
for i in range(1,n):
if(a[i] != a[i-1]):
curr+=1
else:
curr = 1
res = max(curr,res)
print(res)
``` | instruction | 0 | 31,001 | 1 | 62,002 |
Yes | output | 1 | 31,001 | 1 | 62,003 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n houses along the road where Anya lives, each one is painted in one of k possible colors.
Anya likes walking along this road, but she doesn't like when two adjacent houses at the road have the same color. She wants to select a long segment of the road such that no two adjacent houses have the same color.
Help Anya find the longest segment with this property.
Input
The first line contains two integers n and k — the number of houses and the number of colors (1 ≤ n ≤ 100 000, 1 ≤ k ≤ 100 000).
The next line contains n integers a_1, a_2, …, a_n — the colors of the houses along the road (1 ≤ a_i ≤ k).
Output
Output a single integer — the maximum number of houses on the road segment having no two adjacent houses of the same color.
Example
Input
8 3
1 2 3 3 2 1 2 2
Output
4
Note
In the example, the longest segment without neighboring houses of the same color is from the house 4 to the house 7. The colors of the houses are [3, 2, 1, 2] and its length is 4 houses.
Submitted Solution:
```
n,k=map(int,input().split())
a=list(map(int,input().split()))
mx=0
c=1
for i in range(n-1):
if a[i]!=a[i+1]:
c+=1
else:
mx=max(mx,c)
c=1
mx=max(mx,c)
print(mx)
``` | instruction | 0 | 31,002 | 1 | 62,004 |
Yes | output | 1 | 31,002 | 1 | 62,005 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n houses along the road where Anya lives, each one is painted in one of k possible colors.
Anya likes walking along this road, but she doesn't like when two adjacent houses at the road have the same color. She wants to select a long segment of the road such that no two adjacent houses have the same color.
Help Anya find the longest segment with this property.
Input
The first line contains two integers n and k — the number of houses and the number of colors (1 ≤ n ≤ 100 000, 1 ≤ k ≤ 100 000).
The next line contains n integers a_1, a_2, …, a_n — the colors of the houses along the road (1 ≤ a_i ≤ k).
Output
Output a single integer — the maximum number of houses on the road segment having no two adjacent houses of the same color.
Example
Input
8 3
1 2 3 3 2 1 2 2
Output
4
Note
In the example, the longest segment without neighboring houses of the same color is from the house 4 to the house 7. The colors of the houses are [3, 2, 1, 2] and its length is 4 houses.
Submitted Solution:
```
a,b=map(int,input().split())
l=list(map(int,input().split()))
x,y,z=1,0,0
t=l[0]
if len(l)==1:
print(1)
else:
for i in l[1:]:
if i!=t:
x+=1
t=i
z=x
else:
if x>y:
y=x
x=1
print(max(z,y))
``` | instruction | 0 | 31,003 | 1 | 62,006 |
Yes | output | 1 | 31,003 | 1 | 62,007 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n houses along the road where Anya lives, each one is painted in one of k possible colors.
Anya likes walking along this road, but she doesn't like when two adjacent houses at the road have the same color. She wants to select a long segment of the road such that no two adjacent houses have the same color.
Help Anya find the longest segment with this property.
Input
The first line contains two integers n and k — the number of houses and the number of colors (1 ≤ n ≤ 100 000, 1 ≤ k ≤ 100 000).
The next line contains n integers a_1, a_2, …, a_n — the colors of the houses along the road (1 ≤ a_i ≤ k).
Output
Output a single integer — the maximum number of houses on the road segment having no two adjacent houses of the same color.
Example
Input
8 3
1 2 3 3 2 1 2 2
Output
4
Note
In the example, the longest segment without neighboring houses of the same color is from the house 4 to the house 7. The colors of the houses are [3, 2, 1, 2] and its length is 4 houses.
Submitted Solution:
```
n, m = map(int,input().split())
a = list(map(int,input().split()))
b = []
count = 0
for i in range(len(a)-1):
if a[i] != a[i+1]:
count+=1
b.append(count)
else:
count = 0
b.append(count)
#print(b)
if len(b) == 0:
print(n)
#elif max(b) == 0:
#print(0)
else:
print(max(b) + 1)
``` | instruction | 0 | 31,004 | 1 | 62,008 |
Yes | output | 1 | 31,004 | 1 | 62,009 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n houses along the road where Anya lives, each one is painted in one of k possible colors.
Anya likes walking along this road, but she doesn't like when two adjacent houses at the road have the same color. She wants to select a long segment of the road such that no two adjacent houses have the same color.
Help Anya find the longest segment with this property.
Input
The first line contains two integers n and k — the number of houses and the number of colors (1 ≤ n ≤ 100 000, 1 ≤ k ≤ 100 000).
The next line contains n integers a_1, a_2, …, a_n — the colors of the houses along the road (1 ≤ a_i ≤ k).
Output
Output a single integer — the maximum number of houses on the road segment having no two adjacent houses of the same color.
Example
Input
8 3
1 2 3 3 2 1 2 2
Output
4
Note
In the example, the longest segment without neighboring houses of the same color is from the house 4 to the house 7. The colors of the houses are [3, 2, 1, 2] and its length is 4 houses.
Submitted Solution:
```
n, k = map(int, input().split())
a = [int(x) for x in input().split()]
l = []
if(n == 1):
print(1)
exit()
elif(k == 1):
print(n)
exit()
for i in range(n - 1):
if(a[i] == a[i + 1]):
l.append(i)
l.append(i + 1)
# print(l)
x = []
x.append(l[0])
for i in range(1, len(l)):
x.append(l[i] - l[i - 1])
x.append(n - 1 - l[-1])
print(max(x) + 1)
``` | instruction | 0 | 31,005 | 1 | 62,010 |
No | output | 1 | 31,005 | 1 | 62,011 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n houses along the road where Anya lives, each one is painted in one of k possible colors.
Anya likes walking along this road, but she doesn't like when two adjacent houses at the road have the same color. She wants to select a long segment of the road such that no two adjacent houses have the same color.
Help Anya find the longest segment with this property.
Input
The first line contains two integers n and k — the number of houses and the number of colors (1 ≤ n ≤ 100 000, 1 ≤ k ≤ 100 000).
The next line contains n integers a_1, a_2, …, a_n — the colors of the houses along the road (1 ≤ a_i ≤ k).
Output
Output a single integer — the maximum number of houses on the road segment having no two adjacent houses of the same color.
Example
Input
8 3
1 2 3 3 2 1 2 2
Output
4
Note
In the example, the longest segment without neighboring houses of the same color is from the house 4 to the house 7. The colors of the houses are [3, 2, 1, 2] and its length is 4 houses.
Submitted Solution:
```
houses, colors = [ int(x) for x in input().split() ]
house_color = [ int(x) for x in input().split() ]
houses_segment = 1
segment_length = [1]
for h in range(houses-1):
if house_color[h]!=house_color[h+1]:
houses_segment+=1
elif house_color[h]==house_color[h+1]:
segment_length.append(houses_segment)
houses_segment=1
print (max(segment_length))
``` | instruction | 0 | 31,006 | 1 | 62,012 |
No | output | 1 | 31,006 | 1 | 62,013 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n houses along the road where Anya lives, each one is painted in one of k possible colors.
Anya likes walking along this road, but she doesn't like when two adjacent houses at the road have the same color. She wants to select a long segment of the road such that no two adjacent houses have the same color.
Help Anya find the longest segment with this property.
Input
The first line contains two integers n and k — the number of houses and the number of colors (1 ≤ n ≤ 100 000, 1 ≤ k ≤ 100 000).
The next line contains n integers a_1, a_2, …, a_n — the colors of the houses along the road (1 ≤ a_i ≤ k).
Output
Output a single integer — the maximum number of houses on the road segment having no two adjacent houses of the same color.
Example
Input
8 3
1 2 3 3 2 1 2 2
Output
4
Note
In the example, the longest segment without neighboring houses of the same color is from the house 4 to the house 7. The colors of the houses are [3, 2, 1, 2] and its length is 4 houses.
Submitted Solution:
```
n,k = map(int,input().split())
lst = list(map(int,input().split()))
c = 0
for i in range(0,len(lst)-1):
if(lst[i] == lst[i+1]):
print(c)
break
c = c + 1
``` | instruction | 0 | 31,007 | 1 | 62,014 |
No | output | 1 | 31,007 | 1 | 62,015 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n houses along the road where Anya lives, each one is painted in one of k possible colors.
Anya likes walking along this road, but she doesn't like when two adjacent houses at the road have the same color. She wants to select a long segment of the road such that no two adjacent houses have the same color.
Help Anya find the longest segment with this property.
Input
The first line contains two integers n and k — the number of houses and the number of colors (1 ≤ n ≤ 100 000, 1 ≤ k ≤ 100 000).
The next line contains n integers a_1, a_2, …, a_n — the colors of the houses along the road (1 ≤ a_i ≤ k).
Output
Output a single integer — the maximum number of houses on the road segment having no two adjacent houses of the same color.
Example
Input
8 3
1 2 3 3 2 1 2 2
Output
4
Note
In the example, the longest segment without neighboring houses of the same color is from the house 4 to the house 7. The colors of the houses are [3, 2, 1, 2] and its length is 4 houses.
Submitted Solution:
```
n, m = map(int, (input().split()))
a = list(map(int, input().split()))
ln = 0
ans = []
if n == 1:
print(1)
else:
for i in range(1, len(a)):
if a[i] == a[i - 1] or i == len(a) - 1:
ans.append(ln + 1)
ln = 0
else:
ln += 1
print(max(ans))
``` | instruction | 0 | 31,008 | 1 | 62,016 |
No | output | 1 | 31,008 | 1 | 62,017 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bearland has n cities, numbered 1 through n. Cities are connected via bidirectional roads. Each road connects two distinct cities. No two roads connect the same pair of cities.
Bear Limak was once in a city a and he wanted to go to a city b. There was no direct connection so he decided to take a long walk, visiting each city exactly once. Formally:
* There is no road between a and b.
* There exists a sequence (path) of n distinct cities v1, v2, ..., vn that v1 = a, vn = b and there is a road between vi and vi + 1 for <image>.
On the other day, the similar thing happened. Limak wanted to travel between a city c and a city d. There is no road between them but there exists a sequence of n distinct cities u1, u2, ..., un that u1 = c, un = d and there is a road between ui and ui + 1 for <image>.
Also, Limak thinks that there are at most k roads in Bearland. He wonders whether he remembers everything correctly.
Given n, k and four distinct cities a, b, c, d, can you find possible paths (v1, ..., vn) and (u1, ..., un) to satisfy all the given conditions? Find any solution or print -1 if it's impossible.
Input
The first line of the input contains two integers n and k (4 ≤ n ≤ 1000, n - 1 ≤ k ≤ 2n - 2) — the number of cities and the maximum allowed number of roads, respectively.
The second line contains four distinct integers a, b, c and d (1 ≤ a, b, c, d ≤ n).
Output
Print -1 if it's impossible to satisfy all the given conditions. Otherwise, print two lines with paths descriptions. The first of these two lines should contain n distinct integers v1, v2, ..., vn where v1 = a and vn = b. The second line should contain n distinct integers u1, u2, ..., un where u1 = c and un = d.
Two paths generate at most 2n - 2 roads: (v1, v2), (v2, v3), ..., (vn - 1, vn), (u1, u2), (u2, u3), ..., (un - 1, un). Your answer will be considered wrong if contains more than k distinct roads or any other condition breaks. Note that (x, y) and (y, x) are the same road.
Examples
Input
7 11
2 4 7 3
Output
2 7 1 3 6 5 4
7 1 5 4 6 2 3
Input
1000 999
10 20 30 40
Output
-1
Note
In the first sample test, there should be 7 cities and at most 11 roads. The provided sample solution generates 10 roads, as in the drawing. You can also see a simple path of length n between 2 and 4, and a path between 7 and 3.
<image> | instruction | 0 | 31,400 | 1 | 62,800 |
Tags: constructive algorithms, graphs
Correct Solution:
```
n,k=map(int,input().split())
a,b,c,d=input().split()
if n<5 or k<n+1: print(-1)
else:
l=list(set(map(str,range(1,n+1)))-{a,b,c,d})
print(' '.join([a,c]+l+[d,b]+['\n']+[c,a]+l+[b,d]))
``` | output | 1 | 31,400 | 1 | 62,801 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bearland has n cities, numbered 1 through n. Cities are connected via bidirectional roads. Each road connects two distinct cities. No two roads connect the same pair of cities.
Bear Limak was once in a city a and he wanted to go to a city b. There was no direct connection so he decided to take a long walk, visiting each city exactly once. Formally:
* There is no road between a and b.
* There exists a sequence (path) of n distinct cities v1, v2, ..., vn that v1 = a, vn = b and there is a road between vi and vi + 1 for <image>.
On the other day, the similar thing happened. Limak wanted to travel between a city c and a city d. There is no road between them but there exists a sequence of n distinct cities u1, u2, ..., un that u1 = c, un = d and there is a road between ui and ui + 1 for <image>.
Also, Limak thinks that there are at most k roads in Bearland. He wonders whether he remembers everything correctly.
Given n, k and four distinct cities a, b, c, d, can you find possible paths (v1, ..., vn) and (u1, ..., un) to satisfy all the given conditions? Find any solution or print -1 if it's impossible.
Input
The first line of the input contains two integers n and k (4 ≤ n ≤ 1000, n - 1 ≤ k ≤ 2n - 2) — the number of cities and the maximum allowed number of roads, respectively.
The second line contains four distinct integers a, b, c and d (1 ≤ a, b, c, d ≤ n).
Output
Print -1 if it's impossible to satisfy all the given conditions. Otherwise, print two lines with paths descriptions. The first of these two lines should contain n distinct integers v1, v2, ..., vn where v1 = a and vn = b. The second line should contain n distinct integers u1, u2, ..., un where u1 = c and un = d.
Two paths generate at most 2n - 2 roads: (v1, v2), (v2, v3), ..., (vn - 1, vn), (u1, u2), (u2, u3), ..., (un - 1, un). Your answer will be considered wrong if contains more than k distinct roads or any other condition breaks. Note that (x, y) and (y, x) are the same road.
Examples
Input
7 11
2 4 7 3
Output
2 7 1 3 6 5 4
7 1 5 4 6 2 3
Input
1000 999
10 20 30 40
Output
-1
Note
In the first sample test, there should be 7 cities and at most 11 roads. The provided sample solution generates 10 roads, as in the drawing. You can also see a simple path of length n between 2 and 4, and a path between 7 and 3.
<image> | instruction | 0 | 31,401 | 1 | 62,802 |
Tags: constructive algorithms, graphs
Correct Solution:
```
n, k = map(int, input().split())
a, b, c, d = map(int, input().split())
if k < n + 1 or n == 4:
print(-1)
else:
print(a, c, end=' ')
for i in range(1, n + 1):
if i != a and i != b and i != c and i != d:
print(i, end=' ')
print(d, b)
print(c, a, end=' ')
for i in range(1, n + 1):
if i != a and i != b and i != c and i != d:
print(i, end=' ')
print(b, d)
``` | output | 1 | 31,401 | 1 | 62,803 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bearland has n cities, numbered 1 through n. Cities are connected via bidirectional roads. Each road connects two distinct cities. No two roads connect the same pair of cities.
Bear Limak was once in a city a and he wanted to go to a city b. There was no direct connection so he decided to take a long walk, visiting each city exactly once. Formally:
* There is no road between a and b.
* There exists a sequence (path) of n distinct cities v1, v2, ..., vn that v1 = a, vn = b and there is a road between vi and vi + 1 for <image>.
On the other day, the similar thing happened. Limak wanted to travel between a city c and a city d. There is no road between them but there exists a sequence of n distinct cities u1, u2, ..., un that u1 = c, un = d and there is a road between ui and ui + 1 for <image>.
Also, Limak thinks that there are at most k roads in Bearland. He wonders whether he remembers everything correctly.
Given n, k and four distinct cities a, b, c, d, can you find possible paths (v1, ..., vn) and (u1, ..., un) to satisfy all the given conditions? Find any solution or print -1 if it's impossible.
Input
The first line of the input contains two integers n and k (4 ≤ n ≤ 1000, n - 1 ≤ k ≤ 2n - 2) — the number of cities and the maximum allowed number of roads, respectively.
The second line contains four distinct integers a, b, c and d (1 ≤ a, b, c, d ≤ n).
Output
Print -1 if it's impossible to satisfy all the given conditions. Otherwise, print two lines with paths descriptions. The first of these two lines should contain n distinct integers v1, v2, ..., vn where v1 = a and vn = b. The second line should contain n distinct integers u1, u2, ..., un where u1 = c and un = d.
Two paths generate at most 2n - 2 roads: (v1, v2), (v2, v3), ..., (vn - 1, vn), (u1, u2), (u2, u3), ..., (un - 1, un). Your answer will be considered wrong if contains more than k distinct roads or any other condition breaks. Note that (x, y) and (y, x) are the same road.
Examples
Input
7 11
2 4 7 3
Output
2 7 1 3 6 5 4
7 1 5 4 6 2 3
Input
1000 999
10 20 30 40
Output
-1
Note
In the first sample test, there should be 7 cities and at most 11 roads. The provided sample solution generates 10 roads, as in the drawing. You can also see a simple path of length n between 2 and 4, and a path between 7 and 3.
<image> | instruction | 0 | 31,402 | 1 | 62,804 |
Tags: constructive algorithms, graphs
Correct Solution:
```
n, k = map(int, input().split())
a, b, c, d = map(int, input().split())
if (k < n + 1 or n == 4):
print(-1)
exit()
v = [0 for i in range(n + 1)]
v[a] = v[b] = v[c] = v[d] = 1
e = f = 0
for i in range(1, n + 1):
if not v[i] and not e:
e = i
v[i] = 1
continue
if not v[i] and e and not f:
f = i
v[i] = 1
if n == 5:
print(a, c, e, d, b, sep = ' ')
print(c, a, e, b, d, sep = ' ')
exit()
a1 = [a, c, e]
for i in range(1, n + 1):
if not v[i]:
a1.append(i)
a1 += [f, d, b]
a2 = [c, a, e]
for i in range(1, n + 1):
if not v[i]:
a2.append(i)
a2 += [f, b, d]
print(' '.join(map(str, a1)))
print(' '.join(map(str, a2)))
``` | output | 1 | 31,402 | 1 | 62,805 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bearland has n cities, numbered 1 through n. Cities are connected via bidirectional roads. Each road connects two distinct cities. No two roads connect the same pair of cities.
Bear Limak was once in a city a and he wanted to go to a city b. There was no direct connection so he decided to take a long walk, visiting each city exactly once. Formally:
* There is no road between a and b.
* There exists a sequence (path) of n distinct cities v1, v2, ..., vn that v1 = a, vn = b and there is a road between vi and vi + 1 for <image>.
On the other day, the similar thing happened. Limak wanted to travel between a city c and a city d. There is no road between them but there exists a sequence of n distinct cities u1, u2, ..., un that u1 = c, un = d and there is a road between ui and ui + 1 for <image>.
Also, Limak thinks that there are at most k roads in Bearland. He wonders whether he remembers everything correctly.
Given n, k and four distinct cities a, b, c, d, can you find possible paths (v1, ..., vn) and (u1, ..., un) to satisfy all the given conditions? Find any solution or print -1 if it's impossible.
Input
The first line of the input contains two integers n and k (4 ≤ n ≤ 1000, n - 1 ≤ k ≤ 2n - 2) — the number of cities and the maximum allowed number of roads, respectively.
The second line contains four distinct integers a, b, c and d (1 ≤ a, b, c, d ≤ n).
Output
Print -1 if it's impossible to satisfy all the given conditions. Otherwise, print two lines with paths descriptions. The first of these two lines should contain n distinct integers v1, v2, ..., vn where v1 = a and vn = b. The second line should contain n distinct integers u1, u2, ..., un where u1 = c and un = d.
Two paths generate at most 2n - 2 roads: (v1, v2), (v2, v3), ..., (vn - 1, vn), (u1, u2), (u2, u3), ..., (un - 1, un). Your answer will be considered wrong if contains more than k distinct roads or any other condition breaks. Note that (x, y) and (y, x) are the same road.
Examples
Input
7 11
2 4 7 3
Output
2 7 1 3 6 5 4
7 1 5 4 6 2 3
Input
1000 999
10 20 30 40
Output
-1
Note
In the first sample test, there should be 7 cities and at most 11 roads. The provided sample solution generates 10 roads, as in the drawing. You can also see a simple path of length n between 2 and 4, and a path between 7 and 3.
<image> | instruction | 0 | 31,403 | 1 | 62,806 |
Tags: constructive algorithms, graphs
Correct Solution:
```
n, k = input().split(' ')
n = int(n)
k = int(k)
a,b,c,d = input().split(' ')
a,b,c,d = int(a),int(b),int(c),int(d)
if k <= n:
print(-1)
exit()
if n == 4:
print(-1)
exit()
city = list(range(1,n+1))
road = [a,c]
for i in range(len(city)):
if city[i] not in (a,b,c,d): road.append(city[i])
road += [d,b]
t = ''
print(' '.join("{0}".format(t) for t in road))
road = [c,a] + road[2:n-2] + [b,d]
print(' '.join("{0}".format(t) for t in road))
``` | output | 1 | 31,403 | 1 | 62,807 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bearland has n cities, numbered 1 through n. Cities are connected via bidirectional roads. Each road connects two distinct cities. No two roads connect the same pair of cities.
Bear Limak was once in a city a and he wanted to go to a city b. There was no direct connection so he decided to take a long walk, visiting each city exactly once. Formally:
* There is no road between a and b.
* There exists a sequence (path) of n distinct cities v1, v2, ..., vn that v1 = a, vn = b and there is a road between vi and vi + 1 for <image>.
On the other day, the similar thing happened. Limak wanted to travel between a city c and a city d. There is no road between them but there exists a sequence of n distinct cities u1, u2, ..., un that u1 = c, un = d and there is a road between ui and ui + 1 for <image>.
Also, Limak thinks that there are at most k roads in Bearland. He wonders whether he remembers everything correctly.
Given n, k and four distinct cities a, b, c, d, can you find possible paths (v1, ..., vn) and (u1, ..., un) to satisfy all the given conditions? Find any solution or print -1 if it's impossible.
Input
The first line of the input contains two integers n and k (4 ≤ n ≤ 1000, n - 1 ≤ k ≤ 2n - 2) — the number of cities and the maximum allowed number of roads, respectively.
The second line contains four distinct integers a, b, c and d (1 ≤ a, b, c, d ≤ n).
Output
Print -1 if it's impossible to satisfy all the given conditions. Otherwise, print two lines with paths descriptions. The first of these two lines should contain n distinct integers v1, v2, ..., vn where v1 = a and vn = b. The second line should contain n distinct integers u1, u2, ..., un where u1 = c and un = d.
Two paths generate at most 2n - 2 roads: (v1, v2), (v2, v3), ..., (vn - 1, vn), (u1, u2), (u2, u3), ..., (un - 1, un). Your answer will be considered wrong if contains more than k distinct roads or any other condition breaks. Note that (x, y) and (y, x) are the same road.
Examples
Input
7 11
2 4 7 3
Output
2 7 1 3 6 5 4
7 1 5 4 6 2 3
Input
1000 999
10 20 30 40
Output
-1
Note
In the first sample test, there should be 7 cities and at most 11 roads. The provided sample solution generates 10 roads, as in the drawing. You can also see a simple path of length n between 2 and 4, and a path between 7 and 3.
<image> | instruction | 0 | 31,404 | 1 | 62,808 |
Tags: constructive algorithms, graphs
Correct Solution:
```
n,k = map(int,input().split())
a,b,c,d = map(int,input().split())
notUse = [a,b,c,d]
if n >= k or n == 4:
print(-1)
exit()
f = [a,c]
cntr = 0
for i in range(n-4):
cntr += 1
while cntr in notUse:
cntr+=1
f.append(cntr)
f+=[d,b]
bk = [c,a]
cntr = 0
for i in range(n-4):
cntr += 1
while cntr in notUse:
cntr+=1
bk.append(cntr)
bk+=[b,d]
print(" ".join(map(str,f)))
print(" ".join(map(str,bk)))
``` | output | 1 | 31,404 | 1 | 62,809 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bearland has n cities, numbered 1 through n. Cities are connected via bidirectional roads. Each road connects two distinct cities. No two roads connect the same pair of cities.
Bear Limak was once in a city a and he wanted to go to a city b. There was no direct connection so he decided to take a long walk, visiting each city exactly once. Formally:
* There is no road between a and b.
* There exists a sequence (path) of n distinct cities v1, v2, ..., vn that v1 = a, vn = b and there is a road between vi and vi + 1 for <image>.
On the other day, the similar thing happened. Limak wanted to travel between a city c and a city d. There is no road between them but there exists a sequence of n distinct cities u1, u2, ..., un that u1 = c, un = d and there is a road between ui and ui + 1 for <image>.
Also, Limak thinks that there are at most k roads in Bearland. He wonders whether he remembers everything correctly.
Given n, k and four distinct cities a, b, c, d, can you find possible paths (v1, ..., vn) and (u1, ..., un) to satisfy all the given conditions? Find any solution or print -1 if it's impossible.
Input
The first line of the input contains two integers n and k (4 ≤ n ≤ 1000, n - 1 ≤ k ≤ 2n - 2) — the number of cities and the maximum allowed number of roads, respectively.
The second line contains four distinct integers a, b, c and d (1 ≤ a, b, c, d ≤ n).
Output
Print -1 if it's impossible to satisfy all the given conditions. Otherwise, print two lines with paths descriptions. The first of these two lines should contain n distinct integers v1, v2, ..., vn where v1 = a and vn = b. The second line should contain n distinct integers u1, u2, ..., un where u1 = c and un = d.
Two paths generate at most 2n - 2 roads: (v1, v2), (v2, v3), ..., (vn - 1, vn), (u1, u2), (u2, u3), ..., (un - 1, un). Your answer will be considered wrong if contains more than k distinct roads or any other condition breaks. Note that (x, y) and (y, x) are the same road.
Examples
Input
7 11
2 4 7 3
Output
2 7 1 3 6 5 4
7 1 5 4 6 2 3
Input
1000 999
10 20 30 40
Output
-1
Note
In the first sample test, there should be 7 cities and at most 11 roads. The provided sample solution generates 10 roads, as in the drawing. You can also see a simple path of length n between 2 and 4, and a path between 7 and 3.
<image> | instruction | 0 | 31,405 | 1 | 62,810 |
Tags: constructive algorithms, graphs
Correct Solution:
```
n, k = [int(i) for i in input().split()]
a,b,c,d = [int(i) for i in input().split()]
if k < n+1 or n == 4:
print(-1)
else:
s = []
for i in range(1, n+1):
if i!=a and i!=b and i!=c and i!=d:
s.append(i)
q = [a]+[c]+s+[d]+[b]
w = [c]+[a]+s+[b]+[d]
print(*q)
print(*w)
``` | output | 1 | 31,405 | 1 | 62,811 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bearland has n cities, numbered 1 through n. Cities are connected via bidirectional roads. Each road connects two distinct cities. No two roads connect the same pair of cities.
Bear Limak was once in a city a and he wanted to go to a city b. There was no direct connection so he decided to take a long walk, visiting each city exactly once. Formally:
* There is no road between a and b.
* There exists a sequence (path) of n distinct cities v1, v2, ..., vn that v1 = a, vn = b and there is a road between vi and vi + 1 for <image>.
On the other day, the similar thing happened. Limak wanted to travel between a city c and a city d. There is no road between them but there exists a sequence of n distinct cities u1, u2, ..., un that u1 = c, un = d and there is a road between ui and ui + 1 for <image>.
Also, Limak thinks that there are at most k roads in Bearland. He wonders whether he remembers everything correctly.
Given n, k and four distinct cities a, b, c, d, can you find possible paths (v1, ..., vn) and (u1, ..., un) to satisfy all the given conditions? Find any solution or print -1 if it's impossible.
Input
The first line of the input contains two integers n and k (4 ≤ n ≤ 1000, n - 1 ≤ k ≤ 2n - 2) — the number of cities and the maximum allowed number of roads, respectively.
The second line contains four distinct integers a, b, c and d (1 ≤ a, b, c, d ≤ n).
Output
Print -1 if it's impossible to satisfy all the given conditions. Otherwise, print two lines with paths descriptions. The first of these two lines should contain n distinct integers v1, v2, ..., vn where v1 = a and vn = b. The second line should contain n distinct integers u1, u2, ..., un where u1 = c and un = d.
Two paths generate at most 2n - 2 roads: (v1, v2), (v2, v3), ..., (vn - 1, vn), (u1, u2), (u2, u3), ..., (un - 1, un). Your answer will be considered wrong if contains more than k distinct roads or any other condition breaks. Note that (x, y) and (y, x) are the same road.
Examples
Input
7 11
2 4 7 3
Output
2 7 1 3 6 5 4
7 1 5 4 6 2 3
Input
1000 999
10 20 30 40
Output
-1
Note
In the first sample test, there should be 7 cities and at most 11 roads. The provided sample solution generates 10 roads, as in the drawing. You can also see a simple path of length n between 2 and 4, and a path between 7 and 3.
<image> | instruction | 0 | 31,406 | 1 | 62,812 |
Tags: constructive algorithms, graphs
Correct Solution:
```
# coding: utf-8
from __future__ import print_function
from __future__ import unicode_literals
from __future__ import division
from __future__ import absolute_import
import math
import string
import itertools
import fractions
import heapq
import collections
import re
import array
import bisect
def pp(p):
print(" ".join([str(i) for i in p]))
def cpath():
if l == 2:
ps = [i for i in range(1, n + 1) if i not in (a, b, c, d)]
path1 = [a] + ps + [b]
if a != c:
path2 = path1[::-1]
else:
path2 = path1
elif l == 3:
rb = [False, False]
if a == c:
x, y, z = a, b, d
elif a == d:
x, y, z = a, b, c
rb[1] = True
elif b == c:
x, y, z = b, a, d
rb[0] = True
else:
x, y, z = b, a, c
rb = [True, True]
ps = [i for i in range(1, n + 1) if i not in (a, b, c, d)]
path1 = [x] + ps + [z] + [y]
if rb[0]:
path1 = path1[::-1]
path2 = [x] + ps + [y] + [z]
if rb[1]:
path2 = path2[::-1]
else:
path1 = [a, c] + [i for i in range(1, n + 1) if i not in (a, b, c, d)] + [d, b]
path2 = [c, a] + [i for i in range(1, n + 1) if i not in (a, b, c, d)] + [b, d]
pp(path1)
pp(path2)
n, k = map(int, input().split(" "))
a, b, c, d = map(int, input().split(" "))
l = len(set([a, b, c, d]))
if k < n + l - 3:
print(-1)
elif n == 4:
if l <= 3:
cpath()
else:
print(-1)
else:
cpath()
``` | output | 1 | 31,406 | 1 | 62,813 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bearland has n cities, numbered 1 through n. Cities are connected via bidirectional roads. Each road connects two distinct cities. No two roads connect the same pair of cities.
Bear Limak was once in a city a and he wanted to go to a city b. There was no direct connection so he decided to take a long walk, visiting each city exactly once. Formally:
* There is no road between a and b.
* There exists a sequence (path) of n distinct cities v1, v2, ..., vn that v1 = a, vn = b and there is a road between vi and vi + 1 for <image>.
On the other day, the similar thing happened. Limak wanted to travel between a city c and a city d. There is no road between them but there exists a sequence of n distinct cities u1, u2, ..., un that u1 = c, un = d and there is a road between ui and ui + 1 for <image>.
Also, Limak thinks that there are at most k roads in Bearland. He wonders whether he remembers everything correctly.
Given n, k and four distinct cities a, b, c, d, can you find possible paths (v1, ..., vn) and (u1, ..., un) to satisfy all the given conditions? Find any solution or print -1 if it's impossible.
Input
The first line of the input contains two integers n and k (4 ≤ n ≤ 1000, n - 1 ≤ k ≤ 2n - 2) — the number of cities and the maximum allowed number of roads, respectively.
The second line contains four distinct integers a, b, c and d (1 ≤ a, b, c, d ≤ n).
Output
Print -1 if it's impossible to satisfy all the given conditions. Otherwise, print two lines with paths descriptions. The first of these two lines should contain n distinct integers v1, v2, ..., vn where v1 = a and vn = b. The second line should contain n distinct integers u1, u2, ..., un where u1 = c and un = d.
Two paths generate at most 2n - 2 roads: (v1, v2), (v2, v3), ..., (vn - 1, vn), (u1, u2), (u2, u3), ..., (un - 1, un). Your answer will be considered wrong if contains more than k distinct roads or any other condition breaks. Note that (x, y) and (y, x) are the same road.
Examples
Input
7 11
2 4 7 3
Output
2 7 1 3 6 5 4
7 1 5 4 6 2 3
Input
1000 999
10 20 30 40
Output
-1
Note
In the first sample test, there should be 7 cities and at most 11 roads. The provided sample solution generates 10 roads, as in the drawing. You can also see a simple path of length n between 2 and 4, and a path between 7 and 3.
<image> | instruction | 0 | 31,407 | 1 | 62,814 |
Tags: constructive algorithms, graphs
Correct Solution:
```
n, k = map(int,input().split())
a, b, c, d = map(int,input().split())
if k - n > 0 and n != 4:
print(a,c,end=" ")
for i in range(1,n+1):
if i != a and i != b and i != d and i != c:
print(i,end=" ")
print(d,b)
print(c,a,end=" ")
for i in range(1,n+1):
if i != a and i != b and i != d and i != c:
print(i,end=" ")
print(b,d)
else:
print(-1)
``` | output | 1 | 31,407 | 1 | 62,815 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bearland has n cities, numbered 1 through n. Cities are connected via bidirectional roads. Each road connects two distinct cities. No two roads connect the same pair of cities.
Bear Limak was once in a city a and he wanted to go to a city b. There was no direct connection so he decided to take a long walk, visiting each city exactly once. Formally:
* There is no road between a and b.
* There exists a sequence (path) of n distinct cities v1, v2, ..., vn that v1 = a, vn = b and there is a road between vi and vi + 1 for <image>.
On the other day, the similar thing happened. Limak wanted to travel between a city c and a city d. There is no road between them but there exists a sequence of n distinct cities u1, u2, ..., un that u1 = c, un = d and there is a road between ui and ui + 1 for <image>.
Also, Limak thinks that there are at most k roads in Bearland. He wonders whether he remembers everything correctly.
Given n, k and four distinct cities a, b, c, d, can you find possible paths (v1, ..., vn) and (u1, ..., un) to satisfy all the given conditions? Find any solution or print -1 if it's impossible.
Input
The first line of the input contains two integers n and k (4 ≤ n ≤ 1000, n - 1 ≤ k ≤ 2n - 2) — the number of cities and the maximum allowed number of roads, respectively.
The second line contains four distinct integers a, b, c and d (1 ≤ a, b, c, d ≤ n).
Output
Print -1 if it's impossible to satisfy all the given conditions. Otherwise, print two lines with paths descriptions. The first of these two lines should contain n distinct integers v1, v2, ..., vn where v1 = a and vn = b. The second line should contain n distinct integers u1, u2, ..., un where u1 = c and un = d.
Two paths generate at most 2n - 2 roads: (v1, v2), (v2, v3), ..., (vn - 1, vn), (u1, u2), (u2, u3), ..., (un - 1, un). Your answer will be considered wrong if contains more than k distinct roads or any other condition breaks. Note that (x, y) and (y, x) are the same road.
Examples
Input
7 11
2 4 7 3
Output
2 7 1 3 6 5 4
7 1 5 4 6 2 3
Input
1000 999
10 20 30 40
Output
-1
Note
In the first sample test, there should be 7 cities and at most 11 roads. The provided sample solution generates 10 roads, as in the drawing. You can also see a simple path of length n between 2 and 4, and a path between 7 and 3.
<image>
Submitted Solution:
```
import sys
sys.stderr = sys.stdout
def paths(n, k, a, b, c, d):
if n == 4 or k < n + 1:
return None
s = {a, b, c, d}
return [i for i in range(1, n+1) if i not in s]
def main():
n, k = readinti()
a, b, c, d = readinti()
L = paths(n, k, a, b, c, d)
if L:
s = ' '.join(map(str, L))
print(a, c, s, d, b)
print(c, a, s, b, d)
else:
print('-1')
##########
def readint():
return int(input())
def readinti():
return map(int, input().split())
def readintt():
return tuple(readinti())
def readintl():
return list(readinti())
def readinttl(k):
return [readintt() for _ in range(k)]
def readintll(k):
return [readintl() for _ in range(k)]
def log(*args, **kwargs):
print(*args, **kwargs, file=sys.__stderr__)
if __name__ == '__main__':
main()
``` | instruction | 0 | 31,408 | 1 | 62,816 |
Yes | output | 1 | 31,408 | 1 | 62,817 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bearland has n cities, numbered 1 through n. Cities are connected via bidirectional roads. Each road connects two distinct cities. No two roads connect the same pair of cities.
Bear Limak was once in a city a and he wanted to go to a city b. There was no direct connection so he decided to take a long walk, visiting each city exactly once. Formally:
* There is no road between a and b.
* There exists a sequence (path) of n distinct cities v1, v2, ..., vn that v1 = a, vn = b and there is a road between vi and vi + 1 for <image>.
On the other day, the similar thing happened. Limak wanted to travel between a city c and a city d. There is no road between them but there exists a sequence of n distinct cities u1, u2, ..., un that u1 = c, un = d and there is a road between ui and ui + 1 for <image>.
Also, Limak thinks that there are at most k roads in Bearland. He wonders whether he remembers everything correctly.
Given n, k and four distinct cities a, b, c, d, can you find possible paths (v1, ..., vn) and (u1, ..., un) to satisfy all the given conditions? Find any solution or print -1 if it's impossible.
Input
The first line of the input contains two integers n and k (4 ≤ n ≤ 1000, n - 1 ≤ k ≤ 2n - 2) — the number of cities and the maximum allowed number of roads, respectively.
The second line contains four distinct integers a, b, c and d (1 ≤ a, b, c, d ≤ n).
Output
Print -1 if it's impossible to satisfy all the given conditions. Otherwise, print two lines with paths descriptions. The first of these two lines should contain n distinct integers v1, v2, ..., vn where v1 = a and vn = b. The second line should contain n distinct integers u1, u2, ..., un where u1 = c and un = d.
Two paths generate at most 2n - 2 roads: (v1, v2), (v2, v3), ..., (vn - 1, vn), (u1, u2), (u2, u3), ..., (un - 1, un). Your answer will be considered wrong if contains more than k distinct roads or any other condition breaks. Note that (x, y) and (y, x) are the same road.
Examples
Input
7 11
2 4 7 3
Output
2 7 1 3 6 5 4
7 1 5 4 6 2 3
Input
1000 999
10 20 30 40
Output
-1
Note
In the first sample test, there should be 7 cities and at most 11 roads. The provided sample solution generates 10 roads, as in the drawing. You can also see a simple path of length n between 2 and 4, and a path between 7 and 3.
<image>
Submitted Solution:
```
n,k=map(int,input().split())
a,b,c,d=input().split()
if n<5 or k<n+1: print(-1)
else:
l=list(set(map(str,range(1,n+1)))-{a,b,c,d})
print(' '.join([a,c]+l+[d,b]+[c,a]+l+[b,d]))
``` | instruction | 0 | 31,409 | 1 | 62,818 |
Yes | output | 1 | 31,409 | 1 | 62,819 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bearland has n cities, numbered 1 through n. Cities are connected via bidirectional roads. Each road connects two distinct cities. No two roads connect the same pair of cities.
Bear Limak was once in a city a and he wanted to go to a city b. There was no direct connection so he decided to take a long walk, visiting each city exactly once. Formally:
* There is no road between a and b.
* There exists a sequence (path) of n distinct cities v1, v2, ..., vn that v1 = a, vn = b and there is a road between vi and vi + 1 for <image>.
On the other day, the similar thing happened. Limak wanted to travel between a city c and a city d. There is no road between them but there exists a sequence of n distinct cities u1, u2, ..., un that u1 = c, un = d and there is a road between ui and ui + 1 for <image>.
Also, Limak thinks that there are at most k roads in Bearland. He wonders whether he remembers everything correctly.
Given n, k and four distinct cities a, b, c, d, can you find possible paths (v1, ..., vn) and (u1, ..., un) to satisfy all the given conditions? Find any solution or print -1 if it's impossible.
Input
The first line of the input contains two integers n and k (4 ≤ n ≤ 1000, n - 1 ≤ k ≤ 2n - 2) — the number of cities and the maximum allowed number of roads, respectively.
The second line contains four distinct integers a, b, c and d (1 ≤ a, b, c, d ≤ n).
Output
Print -1 if it's impossible to satisfy all the given conditions. Otherwise, print two lines with paths descriptions. The first of these two lines should contain n distinct integers v1, v2, ..., vn where v1 = a and vn = b. The second line should contain n distinct integers u1, u2, ..., un where u1 = c and un = d.
Two paths generate at most 2n - 2 roads: (v1, v2), (v2, v3), ..., (vn - 1, vn), (u1, u2), (u2, u3), ..., (un - 1, un). Your answer will be considered wrong if contains more than k distinct roads or any other condition breaks. Note that (x, y) and (y, x) are the same road.
Examples
Input
7 11
2 4 7 3
Output
2 7 1 3 6 5 4
7 1 5 4 6 2 3
Input
1000 999
10 20 30 40
Output
-1
Note
In the first sample test, there should be 7 cities and at most 11 roads. The provided sample solution generates 10 roads, as in the drawing. You can also see a simple path of length n between 2 and 4, and a path between 7 and 3.
<image>
Submitted Solution:
```
import sys
import math
import itertools as it
import operator as op
import fractions as fr
n,k = map(int,sys.stdin.readline().split())
a,b,c,d = map(int,sys.stdin.readline().split())
if k < n+1 or n == 4:
print(-1)
else:
path = list(set(range(1,n+1)).difference([a,b,c,d]))
print(' '.join(map(str, [a,c] + path + [d,b])))
print(' '.join(map(str, [c,a] + path + [b,d])))
``` | instruction | 0 | 31,410 | 1 | 62,820 |
Yes | output | 1 | 31,410 | 1 | 62,821 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bearland has n cities, numbered 1 through n. Cities are connected via bidirectional roads. Each road connects two distinct cities. No two roads connect the same pair of cities.
Bear Limak was once in a city a and he wanted to go to a city b. There was no direct connection so he decided to take a long walk, visiting each city exactly once. Formally:
* There is no road between a and b.
* There exists a sequence (path) of n distinct cities v1, v2, ..., vn that v1 = a, vn = b and there is a road between vi and vi + 1 for <image>.
On the other day, the similar thing happened. Limak wanted to travel between a city c and a city d. There is no road between them but there exists a sequence of n distinct cities u1, u2, ..., un that u1 = c, un = d and there is a road between ui and ui + 1 for <image>.
Also, Limak thinks that there are at most k roads in Bearland. He wonders whether he remembers everything correctly.
Given n, k and four distinct cities a, b, c, d, can you find possible paths (v1, ..., vn) and (u1, ..., un) to satisfy all the given conditions? Find any solution or print -1 if it's impossible.
Input
The first line of the input contains two integers n and k (4 ≤ n ≤ 1000, n - 1 ≤ k ≤ 2n - 2) — the number of cities and the maximum allowed number of roads, respectively.
The second line contains four distinct integers a, b, c and d (1 ≤ a, b, c, d ≤ n).
Output
Print -1 if it's impossible to satisfy all the given conditions. Otherwise, print two lines with paths descriptions. The first of these two lines should contain n distinct integers v1, v2, ..., vn where v1 = a and vn = b. The second line should contain n distinct integers u1, u2, ..., un where u1 = c and un = d.
Two paths generate at most 2n - 2 roads: (v1, v2), (v2, v3), ..., (vn - 1, vn), (u1, u2), (u2, u3), ..., (un - 1, un). Your answer will be considered wrong if contains more than k distinct roads or any other condition breaks. Note that (x, y) and (y, x) are the same road.
Examples
Input
7 11
2 4 7 3
Output
2 7 1 3 6 5 4
7 1 5 4 6 2 3
Input
1000 999
10 20 30 40
Output
-1
Note
In the first sample test, there should be 7 cities and at most 11 roads. The provided sample solution generates 10 roads, as in the drawing. You can also see a simple path of length n between 2 and 4, and a path between 7 and 3.
<image>
Submitted Solution:
```
n, k = map(int, input().split())
a, b, c, d = map(int, input().split())
if n == 4:
print(-1)
exit()
if k < n + 1:
print(-1)
exit()
vertices = set([i for i in range(1, n + 1)])
vertices.remove(a)
vertices.remove(b)
vertices.remove(c)
vertices.remove(d)
lst = []
lst.append(a)
lst.append(c)
for x in vertices:
lst.append(x)
lst.append(d)
lst.append(b)
print(*lst)
print(lst[1], lst[0], end=' ')
print(*lst[2:-2], end=' ')
print(lst[-1], lst[-2])
``` | instruction | 0 | 31,411 | 1 | 62,822 |
Yes | output | 1 | 31,411 | 1 | 62,823 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bearland has n cities, numbered 1 through n. Cities are connected via bidirectional roads. Each road connects two distinct cities. No two roads connect the same pair of cities.
Bear Limak was once in a city a and he wanted to go to a city b. There was no direct connection so he decided to take a long walk, visiting each city exactly once. Formally:
* There is no road between a and b.
* There exists a sequence (path) of n distinct cities v1, v2, ..., vn that v1 = a, vn = b and there is a road between vi and vi + 1 for <image>.
On the other day, the similar thing happened. Limak wanted to travel between a city c and a city d. There is no road between them but there exists a sequence of n distinct cities u1, u2, ..., un that u1 = c, un = d and there is a road between ui and ui + 1 for <image>.
Also, Limak thinks that there are at most k roads in Bearland. He wonders whether he remembers everything correctly.
Given n, k and four distinct cities a, b, c, d, can you find possible paths (v1, ..., vn) and (u1, ..., un) to satisfy all the given conditions? Find any solution or print -1 if it's impossible.
Input
The first line of the input contains two integers n and k (4 ≤ n ≤ 1000, n - 1 ≤ k ≤ 2n - 2) — the number of cities and the maximum allowed number of roads, respectively.
The second line contains four distinct integers a, b, c and d (1 ≤ a, b, c, d ≤ n).
Output
Print -1 if it's impossible to satisfy all the given conditions. Otherwise, print two lines with paths descriptions. The first of these two lines should contain n distinct integers v1, v2, ..., vn where v1 = a and vn = b. The second line should contain n distinct integers u1, u2, ..., un where u1 = c and un = d.
Two paths generate at most 2n - 2 roads: (v1, v2), (v2, v3), ..., (vn - 1, vn), (u1, u2), (u2, u3), ..., (un - 1, un). Your answer will be considered wrong if contains more than k distinct roads or any other condition breaks. Note that (x, y) and (y, x) are the same road.
Examples
Input
7 11
2 4 7 3
Output
2 7 1 3 6 5 4
7 1 5 4 6 2 3
Input
1000 999
10 20 30 40
Output
-1
Note
In the first sample test, there should be 7 cities and at most 11 roads. The provided sample solution generates 10 roads, as in the drawing. You can also see a simple path of length n between 2 and 4, and a path between 7 and 3.
<image>
Submitted Solution:
```
n,k=map(int,input().split())
a,b,c,d=map(int,input().split())
if k<n: print(-1)
else:
l=list(set(range(1,n+1))-{a,b,c,d})
print(' '.join(map(str,[a,c,d]+l+[b])))
print(' '.join(map(str,[c,a,b]+l[::-1]+[d])))
``` | instruction | 0 | 31,412 | 1 | 62,824 |
No | output | 1 | 31,412 | 1 | 62,825 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bearland has n cities, numbered 1 through n. Cities are connected via bidirectional roads. Each road connects two distinct cities. No two roads connect the same pair of cities.
Bear Limak was once in a city a and he wanted to go to a city b. There was no direct connection so he decided to take a long walk, visiting each city exactly once. Formally:
* There is no road between a and b.
* There exists a sequence (path) of n distinct cities v1, v2, ..., vn that v1 = a, vn = b and there is a road between vi and vi + 1 for <image>.
On the other day, the similar thing happened. Limak wanted to travel between a city c and a city d. There is no road between them but there exists a sequence of n distinct cities u1, u2, ..., un that u1 = c, un = d and there is a road between ui and ui + 1 for <image>.
Also, Limak thinks that there are at most k roads in Bearland. He wonders whether he remembers everything correctly.
Given n, k and four distinct cities a, b, c, d, can you find possible paths (v1, ..., vn) and (u1, ..., un) to satisfy all the given conditions? Find any solution or print -1 if it's impossible.
Input
The first line of the input contains two integers n and k (4 ≤ n ≤ 1000, n - 1 ≤ k ≤ 2n - 2) — the number of cities and the maximum allowed number of roads, respectively.
The second line contains four distinct integers a, b, c and d (1 ≤ a, b, c, d ≤ n).
Output
Print -1 if it's impossible to satisfy all the given conditions. Otherwise, print two lines with paths descriptions. The first of these two lines should contain n distinct integers v1, v2, ..., vn where v1 = a and vn = b. The second line should contain n distinct integers u1, u2, ..., un where u1 = c and un = d.
Two paths generate at most 2n - 2 roads: (v1, v2), (v2, v3), ..., (vn - 1, vn), (u1, u2), (u2, u3), ..., (un - 1, un). Your answer will be considered wrong if contains more than k distinct roads or any other condition breaks. Note that (x, y) and (y, x) are the same road.
Examples
Input
7 11
2 4 7 3
Output
2 7 1 3 6 5 4
7 1 5 4 6 2 3
Input
1000 999
10 20 30 40
Output
-1
Note
In the first sample test, there should be 7 cities and at most 11 roads. The provided sample solution generates 10 roads, as in the drawing. You can also see a simple path of length n between 2 and 4, and a path between 7 and 3.
<image>
Submitted Solution:
```
n,k=map(int,input().split())
a,b,c,d=map(int,input().split())
if n==4 or k<n+1: print(-1)
else:
l=list(set(range(1,n+1))-{a,b,c,d})
print(' '.join(map(str,[a,c]+l+[d,b])))
print(' '.join(map(str,[c,a,b]+l+[d])))
``` | instruction | 0 | 31,413 | 1 | 62,826 |
No | output | 1 | 31,413 | 1 | 62,827 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bearland has n cities, numbered 1 through n. Cities are connected via bidirectional roads. Each road connects two distinct cities. No two roads connect the same pair of cities.
Bear Limak was once in a city a and he wanted to go to a city b. There was no direct connection so he decided to take a long walk, visiting each city exactly once. Formally:
* There is no road between a and b.
* There exists a sequence (path) of n distinct cities v1, v2, ..., vn that v1 = a, vn = b and there is a road between vi and vi + 1 for <image>.
On the other day, the similar thing happened. Limak wanted to travel between a city c and a city d. There is no road between them but there exists a sequence of n distinct cities u1, u2, ..., un that u1 = c, un = d and there is a road between ui and ui + 1 for <image>.
Also, Limak thinks that there are at most k roads in Bearland. He wonders whether he remembers everything correctly.
Given n, k and four distinct cities a, b, c, d, can you find possible paths (v1, ..., vn) and (u1, ..., un) to satisfy all the given conditions? Find any solution or print -1 if it's impossible.
Input
The first line of the input contains two integers n and k (4 ≤ n ≤ 1000, n - 1 ≤ k ≤ 2n - 2) — the number of cities and the maximum allowed number of roads, respectively.
The second line contains four distinct integers a, b, c and d (1 ≤ a, b, c, d ≤ n).
Output
Print -1 if it's impossible to satisfy all the given conditions. Otherwise, print two lines with paths descriptions. The first of these two lines should contain n distinct integers v1, v2, ..., vn where v1 = a and vn = b. The second line should contain n distinct integers u1, u2, ..., un where u1 = c and un = d.
Two paths generate at most 2n - 2 roads: (v1, v2), (v2, v3), ..., (vn - 1, vn), (u1, u2), (u2, u3), ..., (un - 1, un). Your answer will be considered wrong if contains more than k distinct roads or any other condition breaks. Note that (x, y) and (y, x) are the same road.
Examples
Input
7 11
2 4 7 3
Output
2 7 1 3 6 5 4
7 1 5 4 6 2 3
Input
1000 999
10 20 30 40
Output
-1
Note
In the first sample test, there should be 7 cities and at most 11 roads. The provided sample solution generates 10 roads, as in the drawing. You can also see a simple path of length n between 2 and 4, and a path between 7 and 3.
<image>
Submitted Solution:
```
n,k = map(int,input().split())
a,b,c,d = map(int,input().split())
notUse = [a,b,c,d]
if n > k:
print(-1)
exit()
f = [a,c]
cntr = 0
for i in range(n-4):
cntr += 1
while cntr in notUse:
cntr+=1
f.append(cntr)
f+=[d,b]
bk = [c,a]
cntr = 0
for i in range(n-4):
cntr += 1
while cntr in notUse:
cntr+=1
bk.append(cntr)
bk+=[b,d]
print(" ".join(map(str,f)))
print(" ".join(map(str,bk)))
``` | instruction | 0 | 31,414 | 1 | 62,828 |
No | output | 1 | 31,414 | 1 | 62,829 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bearland has n cities, numbered 1 through n. Cities are connected via bidirectional roads. Each road connects two distinct cities. No two roads connect the same pair of cities.
Bear Limak was once in a city a and he wanted to go to a city b. There was no direct connection so he decided to take a long walk, visiting each city exactly once. Formally:
* There is no road between a and b.
* There exists a sequence (path) of n distinct cities v1, v2, ..., vn that v1 = a, vn = b and there is a road between vi and vi + 1 for <image>.
On the other day, the similar thing happened. Limak wanted to travel between a city c and a city d. There is no road between them but there exists a sequence of n distinct cities u1, u2, ..., un that u1 = c, un = d and there is a road between ui and ui + 1 for <image>.
Also, Limak thinks that there are at most k roads in Bearland. He wonders whether he remembers everything correctly.
Given n, k and four distinct cities a, b, c, d, can you find possible paths (v1, ..., vn) and (u1, ..., un) to satisfy all the given conditions? Find any solution or print -1 if it's impossible.
Input
The first line of the input contains two integers n and k (4 ≤ n ≤ 1000, n - 1 ≤ k ≤ 2n - 2) — the number of cities and the maximum allowed number of roads, respectively.
The second line contains four distinct integers a, b, c and d (1 ≤ a, b, c, d ≤ n).
Output
Print -1 if it's impossible to satisfy all the given conditions. Otherwise, print two lines with paths descriptions. The first of these two lines should contain n distinct integers v1, v2, ..., vn where v1 = a and vn = b. The second line should contain n distinct integers u1, u2, ..., un where u1 = c and un = d.
Two paths generate at most 2n - 2 roads: (v1, v2), (v2, v3), ..., (vn - 1, vn), (u1, u2), (u2, u3), ..., (un - 1, un). Your answer will be considered wrong if contains more than k distinct roads or any other condition breaks. Note that (x, y) and (y, x) are the same road.
Examples
Input
7 11
2 4 7 3
Output
2 7 1 3 6 5 4
7 1 5 4 6 2 3
Input
1000 999
10 20 30 40
Output
-1
Note
In the first sample test, there should be 7 cities and at most 11 roads. The provided sample solution generates 10 roads, as in the drawing. You can also see a simple path of length n between 2 and 4, and a path between 7 and 3.
<image>
Submitted Solution:
```
n, k = map(int, input().split())
a,b,c,d = map(int, input().split())
#from random import shuffle
ok = 0
L = [i+1 for i in range(n)]
M = L[:]
del(L[max(a,b)-1])
del(L[min(a,b)-1])
del(M[max(c,d)-1])
del(M[min(c,d)-1])
if abs(c-d) == 1:
del(L[L.index(c)])
if c == n:
L = L + [c]
else:
L = [c] + L
if abs(a-b) == 1:
del(M[M.index(a)])
if a == n:
M = M + [a]
else:
M = [a] + M
e = set()
L = [a]+L+[b]
M = [c]+M+[d]
for i in range(1,n):
e.add(min(L[i-1:i+1])*n+max(L[i-1:i+1]))
e.add(min(M[i-1:i+1])*n+max(M[i-1:i+1]))
if len(e) > k:
print(-1)
else:
for i in range(n):
print(L[i],end=" ")
print()
for i in range(n):
print(M[i],end=" ")
``` | instruction | 0 | 31,415 | 1 | 62,830 |
No | output | 1 | 31,415 | 1 | 62,831 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Leha decided to move to a quiet town Vičkopolis, because he was tired by living in Bankopolis. Upon arrival he immediately began to expand his network of hacked computers. During the week Leha managed to get access to n computers throughout the town. Incidentally all the computers, which were hacked by Leha, lie on the same straight line, due to the reason that there is the only one straight street in Vičkopolis.
Let's denote the coordinate system on this street. Besides let's number all the hacked computers with integers from 1 to n. So the i-th hacked computer is located at the point xi. Moreover the coordinates of all computers are distinct.
Leha is determined to have a little rest after a hard week. Therefore he is going to invite his friend Noora to a restaurant. However the girl agrees to go on a date with the only one condition: Leha have to solve a simple task.
Leha should calculate a sum of F(a) for all a, where a is a non-empty subset of the set, that consists of all hacked computers. Formally, let's denote A the set of all integers from 1 to n. Noora asks the hacker to find value of the expression <image>. Here F(a) is calculated as the maximum among the distances between all pairs of computers from the set a. Formally, <image>. Since the required sum can be quite large Noora asks to find it modulo 109 + 7.
Though, Leha is too tired. Consequently he is not able to solve this task. Help the hacker to attend a date.
Input
The first line contains one integer n (1 ≤ n ≤ 3·105) denoting the number of hacked computers.
The second line contains n integers x1, x2, ..., xn (1 ≤ xi ≤ 109) denoting the coordinates of hacked computers. It is guaranteed that all xi are distinct.
Output
Print a single integer — the required sum modulo 109 + 7.
Examples
Input
2
4 7
Output
3
Input
3
4 3 1
Output
9
Note
There are three non-empty subsets in the first sample test:<image>, <image> and <image>. The first and the second subset increase the sum by 0 and the third subset increases the sum by 7 - 4 = 3. In total the answer is 0 + 0 + 3 = 3.
There are seven non-empty subsets in the second sample test. Among them only the following subsets increase the answer: <image>, <image>, <image>, <image>. In total the sum is (4 - 3) + (4 - 1) + (3 - 1) + (4 - 1) = 9. | instruction | 0 | 31,464 | 1 | 62,928 |
Tags: implementation, math, sortings
Correct Solution:
```
n = int(input())
a = sorted(list(map(int, input().split())))
base = 10**9 + 7
d = [1]
for i in range(n):
d.append((2*d[-1]) % base)
ans = 0
for i in range(1, len(a)):
diff = a[i] - a[i-1]
add = diff*(d[i]-1)*(d[n - i]-1) % base
ans += add
ans = ans % base
print(ans)
``` | output | 1 | 31,464 | 1 | 62,929 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Leha decided to move to a quiet town Vičkopolis, because he was tired by living in Bankopolis. Upon arrival he immediately began to expand his network of hacked computers. During the week Leha managed to get access to n computers throughout the town. Incidentally all the computers, which were hacked by Leha, lie on the same straight line, due to the reason that there is the only one straight street in Vičkopolis.
Let's denote the coordinate system on this street. Besides let's number all the hacked computers with integers from 1 to n. So the i-th hacked computer is located at the point xi. Moreover the coordinates of all computers are distinct.
Leha is determined to have a little rest after a hard week. Therefore he is going to invite his friend Noora to a restaurant. However the girl agrees to go on a date with the only one condition: Leha have to solve a simple task.
Leha should calculate a sum of F(a) for all a, where a is a non-empty subset of the set, that consists of all hacked computers. Formally, let's denote A the set of all integers from 1 to n. Noora asks the hacker to find value of the expression <image>. Here F(a) is calculated as the maximum among the distances between all pairs of computers from the set a. Formally, <image>. Since the required sum can be quite large Noora asks to find it modulo 109 + 7.
Though, Leha is too tired. Consequently he is not able to solve this task. Help the hacker to attend a date.
Input
The first line contains one integer n (1 ≤ n ≤ 3·105) denoting the number of hacked computers.
The second line contains n integers x1, x2, ..., xn (1 ≤ xi ≤ 109) denoting the coordinates of hacked computers. It is guaranteed that all xi are distinct.
Output
Print a single integer — the required sum modulo 109 + 7.
Examples
Input
2
4 7
Output
3
Input
3
4 3 1
Output
9
Note
There are three non-empty subsets in the first sample test:<image>, <image> and <image>. The first and the second subset increase the sum by 0 and the third subset increases the sum by 7 - 4 = 3. In total the answer is 0 + 0 + 3 = 3.
There are seven non-empty subsets in the second sample test. Among them only the following subsets increase the answer: <image>, <image>, <image>, <image>. In total the sum is (4 - 3) + (4 - 1) + (3 - 1) + (4 - 1) = 9. | instruction | 0 | 31,465 | 1 | 62,930 |
Tags: implementation, math, sortings
Correct Solution:
```
n = int(input())
ans = 0
MOD = int(10**9 + 7)
a = [int(x) for x in input().split()]
a.sort()
po = [1]
for i in range(1,n):
po.append(po[i-1]*2%MOD)
for i in range(n):
ans += a[i]*(po[i] - po[n-i-1] + MOD)
ans %= MOD
print(ans)
``` | output | 1 | 31,465 | 1 | 62,931 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Leha decided to move to a quiet town Vičkopolis, because he was tired by living in Bankopolis. Upon arrival he immediately began to expand his network of hacked computers. During the week Leha managed to get access to n computers throughout the town. Incidentally all the computers, which were hacked by Leha, lie on the same straight line, due to the reason that there is the only one straight street in Vičkopolis.
Let's denote the coordinate system on this street. Besides let's number all the hacked computers with integers from 1 to n. So the i-th hacked computer is located at the point xi. Moreover the coordinates of all computers are distinct.
Leha is determined to have a little rest after a hard week. Therefore he is going to invite his friend Noora to a restaurant. However the girl agrees to go on a date with the only one condition: Leha have to solve a simple task.
Leha should calculate a sum of F(a) for all a, where a is a non-empty subset of the set, that consists of all hacked computers. Formally, let's denote A the set of all integers from 1 to n. Noora asks the hacker to find value of the expression <image>. Here F(a) is calculated as the maximum among the distances between all pairs of computers from the set a. Formally, <image>. Since the required sum can be quite large Noora asks to find it modulo 109 + 7.
Though, Leha is too tired. Consequently he is not able to solve this task. Help the hacker to attend a date.
Input
The first line contains one integer n (1 ≤ n ≤ 3·105) denoting the number of hacked computers.
The second line contains n integers x1, x2, ..., xn (1 ≤ xi ≤ 109) denoting the coordinates of hacked computers. It is guaranteed that all xi are distinct.
Output
Print a single integer — the required sum modulo 109 + 7.
Examples
Input
2
4 7
Output
3
Input
3
4 3 1
Output
9
Note
There are three non-empty subsets in the first sample test:<image>, <image> and <image>. The first and the second subset increase the sum by 0 and the third subset increases the sum by 7 - 4 = 3. In total the answer is 0 + 0 + 3 = 3.
There are seven non-empty subsets in the second sample test. Among them only the following subsets increase the answer: <image>, <image>, <image>, <image>. In total the sum is (4 - 3) + (4 - 1) + (3 - 1) + (4 - 1) = 9. | instruction | 0 | 31,466 | 1 | 62,932 |
Tags: implementation, math, sortings
Correct Solution:
```
n = int(input())
inf = 10 ** 9 + 7
a = list(map(int, input().split()))
st = [0 for i in range(n)]
st[0] = 1
for i in range(1, n):
st[i] = (st[i - 1] * 2) % inf
a.sort()
res = 0
for i in range(n - 1):
res += (a[i + 1] - a[i]) * (st[i + 1] - 1) * (st[n - i - 1] - 1)
res %= inf
print(res)
``` | output | 1 | 31,466 | 1 | 62,933 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Leha decided to move to a quiet town Vičkopolis, because he was tired by living in Bankopolis. Upon arrival he immediately began to expand his network of hacked computers. During the week Leha managed to get access to n computers throughout the town. Incidentally all the computers, which were hacked by Leha, lie on the same straight line, due to the reason that there is the only one straight street in Vičkopolis.
Let's denote the coordinate system on this street. Besides let's number all the hacked computers with integers from 1 to n. So the i-th hacked computer is located at the point xi. Moreover the coordinates of all computers are distinct.
Leha is determined to have a little rest after a hard week. Therefore he is going to invite his friend Noora to a restaurant. However the girl agrees to go on a date with the only one condition: Leha have to solve a simple task.
Leha should calculate a sum of F(a) for all a, where a is a non-empty subset of the set, that consists of all hacked computers. Formally, let's denote A the set of all integers from 1 to n. Noora asks the hacker to find value of the expression <image>. Here F(a) is calculated as the maximum among the distances between all pairs of computers from the set a. Formally, <image>. Since the required sum can be quite large Noora asks to find it modulo 109 + 7.
Though, Leha is too tired. Consequently he is not able to solve this task. Help the hacker to attend a date.
Input
The first line contains one integer n (1 ≤ n ≤ 3·105) denoting the number of hacked computers.
The second line contains n integers x1, x2, ..., xn (1 ≤ xi ≤ 109) denoting the coordinates of hacked computers. It is guaranteed that all xi are distinct.
Output
Print a single integer — the required sum modulo 109 + 7.
Examples
Input
2
4 7
Output
3
Input
3
4 3 1
Output
9
Note
There are three non-empty subsets in the first sample test:<image>, <image> and <image>. The first and the second subset increase the sum by 0 and the third subset increases the sum by 7 - 4 = 3. In total the answer is 0 + 0 + 3 = 3.
There are seven non-empty subsets in the second sample test. Among them only the following subsets increase the answer: <image>, <image>, <image>, <image>. In total the sum is (4 - 3) + (4 - 1) + (3 - 1) + (4 - 1) = 9. | instruction | 0 | 31,467 | 1 | 62,934 |
Tags: implementation, math, sortings
Correct Solution:
```
#!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
n=int(input())
A=list(map(int,input().split()))
A.sort()
for i in range(n):
ans-=pow(2,n-i-1,mod)*A[i]
ans+=pow(2,i,mod)*A[i]
ans%=mod
print(ans)
``` | output | 1 | 31,467 | 1 | 62,935 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Leha decided to move to a quiet town Vičkopolis, because he was tired by living in Bankopolis. Upon arrival he immediately began to expand his network of hacked computers. During the week Leha managed to get access to n computers throughout the town. Incidentally all the computers, which were hacked by Leha, lie on the same straight line, due to the reason that there is the only one straight street in Vičkopolis.
Let's denote the coordinate system on this street. Besides let's number all the hacked computers with integers from 1 to n. So the i-th hacked computer is located at the point xi. Moreover the coordinates of all computers are distinct.
Leha is determined to have a little rest after a hard week. Therefore he is going to invite his friend Noora to a restaurant. However the girl agrees to go on a date with the only one condition: Leha have to solve a simple task.
Leha should calculate a sum of F(a) for all a, where a is a non-empty subset of the set, that consists of all hacked computers. Formally, let's denote A the set of all integers from 1 to n. Noora asks the hacker to find value of the expression <image>. Here F(a) is calculated as the maximum among the distances between all pairs of computers from the set a. Formally, <image>. Since the required sum can be quite large Noora asks to find it modulo 109 + 7.
Though, Leha is too tired. Consequently he is not able to solve this task. Help the hacker to attend a date.
Input
The first line contains one integer n (1 ≤ n ≤ 3·105) denoting the number of hacked computers.
The second line contains n integers x1, x2, ..., xn (1 ≤ xi ≤ 109) denoting the coordinates of hacked computers. It is guaranteed that all xi are distinct.
Output
Print a single integer — the required sum modulo 109 + 7.
Examples
Input
2
4 7
Output
3
Input
3
4 3 1
Output
9
Note
There are three non-empty subsets in the first sample test:<image>, <image> and <image>. The first and the second subset increase the sum by 0 and the third subset increases the sum by 7 - 4 = 3. In total the answer is 0 + 0 + 3 = 3.
There are seven non-empty subsets in the second sample test. Among them only the following subsets increase the answer: <image>, <image>, <image>, <image>. In total the sum is (4 - 3) + (4 - 1) + (3 - 1) + (4 - 1) = 9. | instruction | 0 | 31,468 | 1 | 62,936 |
Tags: implementation, math, sortings
Correct Solution:
```
import sys
read=lambda:sys.stdin.readline().rstrip()
readi=lambda:int(sys.stdin.readline())
writeln=lambda x:sys.stdout.write(str(x)+"\n")
write=lambda x:sys.stdout.write(x)
MOD = (10**9)+7
N = readi()
ns = list(map(int, read().split()))
ns.sort()
s = 0
powmod = 1
ps = [0]*N
ps[0] = 1
for i in range(1,N):
ps[i] = 2* ps[i-1] % MOD
for i in range(N):
s += ns[i] * ps[i]
s -= ns[i] * ps[-1-i]
s %= MOD
writeln(s)
``` | output | 1 | 31,468 | 1 | 62,937 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Leha decided to move to a quiet town Vičkopolis, because he was tired by living in Bankopolis. Upon arrival he immediately began to expand his network of hacked computers. During the week Leha managed to get access to n computers throughout the town. Incidentally all the computers, which were hacked by Leha, lie on the same straight line, due to the reason that there is the only one straight street in Vičkopolis.
Let's denote the coordinate system on this street. Besides let's number all the hacked computers with integers from 1 to n. So the i-th hacked computer is located at the point xi. Moreover the coordinates of all computers are distinct.
Leha is determined to have a little rest after a hard week. Therefore he is going to invite his friend Noora to a restaurant. However the girl agrees to go on a date with the only one condition: Leha have to solve a simple task.
Leha should calculate a sum of F(a) for all a, where a is a non-empty subset of the set, that consists of all hacked computers. Formally, let's denote A the set of all integers from 1 to n. Noora asks the hacker to find value of the expression <image>. Here F(a) is calculated as the maximum among the distances between all pairs of computers from the set a. Formally, <image>. Since the required sum can be quite large Noora asks to find it modulo 109 + 7.
Though, Leha is too tired. Consequently he is not able to solve this task. Help the hacker to attend a date.
Input
The first line contains one integer n (1 ≤ n ≤ 3·105) denoting the number of hacked computers.
The second line contains n integers x1, x2, ..., xn (1 ≤ xi ≤ 109) denoting the coordinates of hacked computers. It is guaranteed that all xi are distinct.
Output
Print a single integer — the required sum modulo 109 + 7.
Examples
Input
2
4 7
Output
3
Input
3
4 3 1
Output
9
Note
There are three non-empty subsets in the first sample test:<image>, <image> and <image>. The first and the second subset increase the sum by 0 and the third subset increases the sum by 7 - 4 = 3. In total the answer is 0 + 0 + 3 = 3.
There are seven non-empty subsets in the second sample test. Among them only the following subsets increase the answer: <image>, <image>, <image>, <image>. In total the sum is (4 - 3) + (4 - 1) + (3 - 1) + (4 - 1) = 9. | instruction | 0 | 31,469 | 1 | 62,938 |
Tags: implementation, math, sortings
Correct Solution:
```
n = int(input())
coord = [int(x) for x in input().split()]
coord = sorted(coord)
modul = 1000000007
G = [0]
P = [0]
D = [0]
for i in range(1, n + 1):
gi = (G[i - 1] * 2 + coord[i - 1]) % modul
pi = (2 * P[i - 1] + 1) % modul
G.append(gi)
P.append(pi)
for i in range(1, n):
di = (D[i - 1] + P[i] * coord[i] - G[i]) % modul
D.append(di)
# print(G, P, D)
print(D[n - 1])
``` | output | 1 | 31,469 | 1 | 62,939 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Leha decided to move to a quiet town Vičkopolis, because he was tired by living in Bankopolis. Upon arrival he immediately began to expand his network of hacked computers. During the week Leha managed to get access to n computers throughout the town. Incidentally all the computers, which were hacked by Leha, lie on the same straight line, due to the reason that there is the only one straight street in Vičkopolis.
Let's denote the coordinate system on this street. Besides let's number all the hacked computers with integers from 1 to n. So the i-th hacked computer is located at the point xi. Moreover the coordinates of all computers are distinct.
Leha is determined to have a little rest after a hard week. Therefore he is going to invite his friend Noora to a restaurant. However the girl agrees to go on a date with the only one condition: Leha have to solve a simple task.
Leha should calculate a sum of F(a) for all a, where a is a non-empty subset of the set, that consists of all hacked computers. Formally, let's denote A the set of all integers from 1 to n. Noora asks the hacker to find value of the expression <image>. Here F(a) is calculated as the maximum among the distances between all pairs of computers from the set a. Formally, <image>. Since the required sum can be quite large Noora asks to find it modulo 109 + 7.
Though, Leha is too tired. Consequently he is not able to solve this task. Help the hacker to attend a date.
Input
The first line contains one integer n (1 ≤ n ≤ 3·105) denoting the number of hacked computers.
The second line contains n integers x1, x2, ..., xn (1 ≤ xi ≤ 109) denoting the coordinates of hacked computers. It is guaranteed that all xi are distinct.
Output
Print a single integer — the required sum modulo 109 + 7.
Examples
Input
2
4 7
Output
3
Input
3
4 3 1
Output
9
Note
There are three non-empty subsets in the first sample test:<image>, <image> and <image>. The first and the second subset increase the sum by 0 and the third subset increases the sum by 7 - 4 = 3. In total the answer is 0 + 0 + 3 = 3.
There are seven non-empty subsets in the second sample test. Among them only the following subsets increase the answer: <image>, <image>, <image>, <image>. In total the sum is (4 - 3) + (4 - 1) + (3 - 1) + (4 - 1) = 9. | instruction | 0 | 31,470 | 1 | 62,940 |
Tags: implementation, math, sortings
Correct Solution:
```
import sys
import math
MOD = int(1e9 + 7)
line = lambda: map(int, input().split())
def solve():
n = int(input())
x = [x for x in line()]
x.sort()
p2 = []
p2.append(1)
for i in range(1, n):
p2.append(p2[i - 1] * 2 % MOD)
ans = 0
for i in range(n):
ans += x[i] * (p2[i] - p2[n - i - 1] + MOD)
ans %= MOD
print(ans)
def main():
solve()
exit(0)
main()
``` | output | 1 | 31,470 | 1 | 62,941 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Leha decided to move to a quiet town Vičkopolis, because he was tired by living in Bankopolis. Upon arrival he immediately began to expand his network of hacked computers. During the week Leha managed to get access to n computers throughout the town. Incidentally all the computers, which were hacked by Leha, lie on the same straight line, due to the reason that there is the only one straight street in Vičkopolis.
Let's denote the coordinate system on this street. Besides let's number all the hacked computers with integers from 1 to n. So the i-th hacked computer is located at the point xi. Moreover the coordinates of all computers are distinct.
Leha is determined to have a little rest after a hard week. Therefore he is going to invite his friend Noora to a restaurant. However the girl agrees to go on a date with the only one condition: Leha have to solve a simple task.
Leha should calculate a sum of F(a) for all a, where a is a non-empty subset of the set, that consists of all hacked computers. Formally, let's denote A the set of all integers from 1 to n. Noora asks the hacker to find value of the expression <image>. Here F(a) is calculated as the maximum among the distances between all pairs of computers from the set a. Formally, <image>. Since the required sum can be quite large Noora asks to find it modulo 109 + 7.
Though, Leha is too tired. Consequently he is not able to solve this task. Help the hacker to attend a date.
Input
The first line contains one integer n (1 ≤ n ≤ 3·105) denoting the number of hacked computers.
The second line contains n integers x1, x2, ..., xn (1 ≤ xi ≤ 109) denoting the coordinates of hacked computers. It is guaranteed that all xi are distinct.
Output
Print a single integer — the required sum modulo 109 + 7.
Examples
Input
2
4 7
Output
3
Input
3
4 3 1
Output
9
Note
There are three non-empty subsets in the first sample test:<image>, <image> and <image>. The first and the second subset increase the sum by 0 and the third subset increases the sum by 7 - 4 = 3. In total the answer is 0 + 0 + 3 = 3.
There are seven non-empty subsets in the second sample test. Among them only the following subsets increase the answer: <image>, <image>, <image>, <image>. In total the sum is (4 - 3) + (4 - 1) + (3 - 1) + (4 - 1) = 9. | instruction | 0 | 31,471 | 1 | 62,942 |
Tags: implementation, math, sortings
Correct Solution:
```
n = int(input())
a = sorted(list(map(int, input().split())))
modu = 10**9 + 7
if n < 2:
print(0)
else:
ans = 0
p2 = [1]
for i in range(n):
p2.append(2*p2[-1] % modu)
for i in range(n - 1):
ans += (a[i+1] - a[i]) * (p2[i + 1] - 1) * (p2[n - i - 1] - 1)
ans %= modu
print(ans)
``` | output | 1 | 31,471 | 1 | 62,943 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cities on a 2D plane. The coordinate of the i-th city is (x_i, y_i). Here (x_1, x_2, \dots, x_N) and (y_1, y_2, \dots, y_N) are both permuations of (1, 2, \dots, N).
For each k = 1,2,\dots,N, find the answer to the following question:
Rng is in City k. Rng can perform the following move arbitrarily many times:
* move to another city that has a smaller x-coordinate and a smaller y-coordinate, or a larger x-coordinate and a larger y-coordinate, than the city he is currently in.
How many cities (including City k) are reachable from City k?
Constraints
* 1 \leq N \leq 200,000
* (x_1, x_2, \dots, x_N) is a permutation of (1, 2, \dots, N).
* (y_1, y_2, \dots, y_N) is a permutation of (1, 2, \dots, N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print N lines. In i-th line print the answer to the question when k = i.
Examples
Input
4
1 4
2 3
3 1
4 2
Output
1
1
2
2
Input
7
6 4
4 3
3 5
7 1
2 7
5 2
1 6
Output
3
3
1
1
2
3
2 | instruction | 0 | 31,548 | 1 | 63,096 |
"Correct Solution:
```
import sys, math
import io, os
#data = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
from bisect import bisect_left as bl, bisect_right as br, insort
from heapq import heapify, heappush, heappop
from collections import defaultdict as dd, deque, Counter
# from itertools import permutations,combinations
def data(): return sys.stdin.readline().strip()
def mdata(): return list(map(int, data().split()))
def outl(var): sys.stdout.write('\n'.join(map(str, var)) + '\n')
def out(var): sys.stdout.write(str(var) + '\n')
from decimal import Decimal
# from fractions import Fraction
# sys.setrecursionlimit(100000)
mod = 998244353
INF=float('inf')
n=int(input())
BIT = [0]*(n+1)
d1=dd(int)
d2=dd(int)
d=dd(int)
for i in range(n):
x,y=mdata()
d1[x]=y
d2[y]=x
d[x]=i
l2=list(range(1,n+1))
l1=l2[::-1]
ans=[0]*n
while l1:
set1=set()
s=0
mx=l1[-1]
my=d1[l1[-1]]
set1.add(l1.pop())
while len(set1)!=s:
s=len(set1)
while l2 and l2[-1]>=my:
set1.add(d2[l2[-1]])
mx=max(mx,d2[l2.pop()])
while l1 and l1[-1]<=mx:
set1.add(l1[-1])
my=min(my,d1[l1.pop()])
l=len(set1)
for i in set1:
ans[d[i]]=l
outl(ans)
``` | output | 1 | 31,548 | 1 | 63,097 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cities on a 2D plane. The coordinate of the i-th city is (x_i, y_i). Here (x_1, x_2, \dots, x_N) and (y_1, y_2, \dots, y_N) are both permuations of (1, 2, \dots, N).
For each k = 1,2,\dots,N, find the answer to the following question:
Rng is in City k. Rng can perform the following move arbitrarily many times:
* move to another city that has a smaller x-coordinate and a smaller y-coordinate, or a larger x-coordinate and a larger y-coordinate, than the city he is currently in.
How many cities (including City k) are reachable from City k?
Constraints
* 1 \leq N \leq 200,000
* (x_1, x_2, \dots, x_N) is a permutation of (1, 2, \dots, N).
* (y_1, y_2, \dots, y_N) is a permutation of (1, 2, \dots, N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print N lines. In i-th line print the answer to the question when k = i.
Examples
Input
4
1 4
2 3
3 1
4 2
Output
1
1
2
2
Input
7
6 4
4 3
3 5
7 1
2 7
5 2
1 6
Output
3
3
1
1
2
3
2
Submitted Solution:
```
#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]
def I(): return int(sys.stdin.buffer.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI()+[i] for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
def root(x):
if par[x] == x:
return x
par[x] = root(par[x])
return par[x]
def unite(x,y):
x = root(x)
y = root(y)
if rank[x] < rank[y]:
par[x] = y
else:
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
n = I()
p = LIR(n)
p.sort()
par = list(range(n))
rank = [0]*n
q = []
q2 = []
for x,y,i in p:
f = 0
while q:
yy,j = heappop(q)
if y < yy:
heappush(q,(yy,j))
break
f = 1
unite(i,j)
q2.append((yy,j))
while q2:
yy,j = q2.pop()
heappush(q,(yy,j))
if not f:
heappush(q,(y,i))
s = [0]*(n+1)
for _,_,i in p:
s[root(i)] += 1
ans = [None]*n
for _,_,i in p:
ans[i] = s[root(i)]
for i in ans:
print(i)
return
#Solve
if __name__ == "__main__":
solve()
``` | instruction | 0 | 31,550 | 1 | 63,100 |
Yes | output | 1 | 31,550 | 1 | 63,101 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cities on a 2D plane. The coordinate of the i-th city is (x_i, y_i). Here (x_1, x_2, \dots, x_N) and (y_1, y_2, \dots, y_N) are both permuations of (1, 2, \dots, N).
For each k = 1,2,\dots,N, find the answer to the following question:
Rng is in City k. Rng can perform the following move arbitrarily many times:
* move to another city that has a smaller x-coordinate and a smaller y-coordinate, or a larger x-coordinate and a larger y-coordinate, than the city he is currently in.
How many cities (including City k) are reachable from City k?
Constraints
* 1 \leq N \leq 200,000
* (x_1, x_2, \dots, x_N) is a permutation of (1, 2, \dots, N).
* (y_1, y_2, \dots, y_N) is a permutation of (1, 2, \dots, N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print N lines. In i-th line print the answer to the question when k = i.
Examples
Input
4
1 4
2 3
3 1
4 2
Output
1
1
2
2
Input
7
6 4
4 3
3 5
7 1
2 7
5 2
1 6
Output
3
3
1
1
2
3
2
Submitted Solution:
```
# Reference: https://note.nkmk.me/python-union-find/
class UnionFind:
# if x is root: self.parents[x] = -(the number of the group nodes)
# else: self.parents[x] = the parent of x
def __init__(self, n):
self.n = n
self.parents = [-1] * n
# return the parent of x
def find(self, x):
history = []
while self.parents[x] >= 0:
history.append(x)
x = self.parents[x]
for node in history:
self.parents[node] = x
return x
# merge the group of x and the group of y
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
# return the size of the group of x
def size(self, x):
return -self.parents[self.find(x)]
from sys import stdin
input = stdin.buffer.readline
def main():
n = int(input())
l = [0] * n
for i in range(n):
x, y = map(int, input().split())
l[x-1] = (y-1, i)
uf = UnionFind(n)
roots = []
for y, i in l:
if len(roots) == 0 or roots[-1][0] > y:
roots.append((y, i))
else:
new_y = roots[-1][0]
while len(roots) > 0 and roots[-1][0] < y:
old_y, old_i = roots.pop()
uf.union(i, old_i)
roots.append((new_y, i))
# O(uf.size(i)) = 1
for i in range(n):
print(uf.size(i))
main()
``` | instruction | 0 | 31,552 | 1 | 63,104 |
Yes | output | 1 | 31,552 | 1 | 63,105 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cities on a 2D plane. The coordinate of the i-th city is (x_i, y_i). Here (x_1, x_2, \dots, x_N) and (y_1, y_2, \dots, y_N) are both permuations of (1, 2, \dots, N).
For each k = 1,2,\dots,N, find the answer to the following question:
Rng is in City k. Rng can perform the following move arbitrarily many times:
* move to another city that has a smaller x-coordinate and a smaller y-coordinate, or a larger x-coordinate and a larger y-coordinate, than the city he is currently in.
How many cities (including City k) are reachable from City k?
Constraints
* 1 \leq N \leq 200,000
* (x_1, x_2, \dots, x_N) is a permutation of (1, 2, \dots, N).
* (y_1, y_2, \dots, y_N) is a permutation of (1, 2, \dots, N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print N lines. In i-th line print the answer to the question when k = i.
Examples
Input
4
1 4
2 3
3 1
4 2
Output
1
1
2
2
Input
7
6 4
4 3
3 5
7 1
2 7
5 2
1 6
Output
3
3
1
1
2
3
2
Submitted Solution:
```
N = int(input())
x = [0] * N
y = [0] * N
for i in range(N):
x[i], y[i] = map(int, input().split())
ans=[1]*N
for i in range(N):
for j in range(i,N):
if (x[i]>x[j] and y[i]>y[j]) or (x[i]<x[j] and y[i]<y[j]):
print(i,j)
ans[i]+=1
ans[j]+=1
print(ans)
``` | instruction | 0 | 31,553 | 1 | 63,106 |
No | output | 1 | 31,553 | 1 | 63,107 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cities on a 2D plane. The coordinate of the i-th city is (x_i, y_i). Here (x_1, x_2, \dots, x_N) and (y_1, y_2, \dots, y_N) are both permuations of (1, 2, \dots, N).
For each k = 1,2,\dots,N, find the answer to the following question:
Rng is in City k. Rng can perform the following move arbitrarily many times:
* move to another city that has a smaller x-coordinate and a smaller y-coordinate, or a larger x-coordinate and a larger y-coordinate, than the city he is currently in.
How many cities (including City k) are reachable from City k?
Constraints
* 1 \leq N \leq 200,000
* (x_1, x_2, \dots, x_N) is a permutation of (1, 2, \dots, N).
* (y_1, y_2, \dots, y_N) is a permutation of (1, 2, \dots, N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print N lines. In i-th line print the answer to the question when k = i.
Examples
Input
4
1 4
2 3
3 1
4 2
Output
1
1
2
2
Input
7
6 4
4 3
3 5
7 1
2 7
5 2
1 6
Output
3
3
1
1
2
3
2
Submitted Solution:
```
# Binary Indexed Tree (Fenwick Tree)
class BIT:
def __init__(self, n):
self.n = n
self.bit = [0]*(n+1)
self.el = [0]*(n+1)
def sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= i & -i
return s
def add(self, i, x):
# assert i > 0
self.el[i] += x
while i <= self.n:
self.bit[i] += x
i += i & -i
def get(self, i, j=None):
if j is None:
return self.el[i]
return self.sum(j) - self.sum(i-1)
def lower_bound(self,x):
w = i = 0
k = 1<<((self.n).bit_length())
while k:
if i+k <= self.n and w + self.bit[i+k] < x:
w += self.bit[i+k]
i += k
k >>= 1
return i+1
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def num_roots(self):
return len([i for i, x in enumerate(self.parents) if x < 0])
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def num_members(self,x):
return abs(self.parents[self.find(x)])
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
import sys
input = sys.stdin.readline
N = int(input())
A = [list(map(int, input().split())) for i in range(N)]
y_to_i = [0]*(N+1)
for i,(x,y) in enumerate(A):
y_to_i[y] = i
ans = [1]*N
A.sort()
bit = BIT(N)
uf = UnionFind(N)
cnt = 0
for j,(x,y) in enumerate(A):
p = bit.sum(y)
for i in range(1,p+1):
y2 = bit.lower_bound(i)
if not uf.same(y_to_i[y],y_to_i[y2]):
uf.union(y_to_i[y],y_to_i[y2])
cnt += 1
if cnt>=j:
break
bit.add(y,1)
for i in range(N):
ans[i] = uf.num_members(i)
print(*ans, sep='\n')
``` | instruction | 0 | 31,554 | 1 | 63,108 |
No | output | 1 | 31,554 | 1 | 63,109 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cities on a 2D plane. The coordinate of the i-th city is (x_i, y_i). Here (x_1, x_2, \dots, x_N) and (y_1, y_2, \dots, y_N) are both permuations of (1, 2, \dots, N).
For each k = 1,2,\dots,N, find the answer to the following question:
Rng is in City k. Rng can perform the following move arbitrarily many times:
* move to another city that has a smaller x-coordinate and a smaller y-coordinate, or a larger x-coordinate and a larger y-coordinate, than the city he is currently in.
How many cities (including City k) are reachable from City k?
Constraints
* 1 \leq N \leq 200,000
* (x_1, x_2, \dots, x_N) is a permutation of (1, 2, \dots, N).
* (y_1, y_2, \dots, y_N) is a permutation of (1, 2, \dots, N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print N lines. In i-th line print the answer to the question when k = i.
Examples
Input
4
1 4
2 3
3 1
4 2
Output
1
1
2
2
Input
7
6 4
4 3
3 5
7 1
2 7
5 2
1 6
Output
3
3
1
1
2
3
2
Submitted Solution:
```
n=int(input())
x=[]
y=[]
for _ in range(n):
a,b=map(int,input().split())
x.append(a)
y.append(b)
cnt=1
for i in range(n):
for j in range(n):
if x[i]>x[j] and y[i]>y[j]:
cnt+=1
if x[i]<x[j] and y[i]<y[j]:
cnt+=1
if j==n-1:
print(cnt)
cnt=1
``` | instruction | 0 | 31,555 | 1 | 63,110 |
No | output | 1 | 31,555 | 1 | 63,111 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cities on a 2D plane. The coordinate of the i-th city is (x_i, y_i). Here (x_1, x_2, \dots, x_N) and (y_1, y_2, \dots, y_N) are both permuations of (1, 2, \dots, N).
For each k = 1,2,\dots,N, find the answer to the following question:
Rng is in City k. Rng can perform the following move arbitrarily many times:
* move to another city that has a smaller x-coordinate and a smaller y-coordinate, or a larger x-coordinate and a larger y-coordinate, than the city he is currently in.
How many cities (including City k) are reachable from City k?
Constraints
* 1 \leq N \leq 200,000
* (x_1, x_2, \dots, x_N) is a permutation of (1, 2, \dots, N).
* (y_1, y_2, \dots, y_N) is a permutation of (1, 2, \dots, N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print N lines. In i-th line print the answer to the question when k = i.
Examples
Input
4
1 4
2 3
3 1
4 2
Output
1
1
2
2
Input
7
6 4
4 3
3 5
7 1
2 7
5 2
1 6
Output
3
3
1
1
2
3
2
Submitted Solution:
```
class SegTree: # モノイドに対して適用可能、Nが2冪でなくても良い
def __init__(self ,N ,seg_func ,unit):
self.N = 1 << ( N -1).bit_length()
self.func = seg_func
self.unit = unit
self.tree = [self.unit ] *( 2 *self.N)
def build(self ,init_value): # 初期値を[N,2N)に格納
for i in range(len(init_value)):
self.tree[ i +self.N] = init_value[i]
for i in range(self. N -1 ,0 ,-1):
self.tree[i] = self.func(self.tree[i << 1] ,self.tree[i << 1 | 1])
def set_val(self ,i ,x): # i番目(0-index)の値をxに変更
i += self.N
self.tree[i] = x
i >>= 1
while i:
self.tree[i] = self.func(self.tree[i << 1] ,self.tree[i << 1 | 1])
i >>= 1
def fold(self ,L ,R): # [L,R)の区間取得
L += self.N
R += self.N
vL = self.unit
vR = self.unit
while L < R:
if L & 1:
vL = self.func(vL ,self.tree[L])
L += 1
if R & 1:
R -= 1
vR = self.func(self.tree[R] ,vR)
L >>= 1
R >>= 1
return self.func(vL ,vR)
class DSU:
def __init__(self, n):
self.n = n
self.root = [-1] * (n + 1)
self.rank = [0] * (n + 1)
def leader(self, x):
rt = self.root[x]
if rt < 0: return x
else: self.root[x] = self.leader(rt)
return self.root[x]
def merge(self, x, y):
leader = self.leader
xrt = leader(x)
yrt = leader(y)
if xrt == yrt: return
if self.rank[xrt] > self.rank[yrt]:
self.root[xrt] += self.root[yrt]
self.root[yrt] = xrt
else:
self.root[yrt] += self.root[xrt]
self.root[xrt] = yrt
self.rank[yrt] += self.rank[xrt] == self.rank[yrt]
def same(self, x, y): return self.leader(x) == self.leader(y)
def size(self, x): return -self.root[self.leader(x)]
def group(self):
n = self.n
leader = self.leader
res = [[] for _ in range(n + 1)]
for x in range(n + 1): res[leader(x)].append(x)
return [res[i] for i in range(n + 1) if len(res[i])]
def main():
n, q = map(int, input().split())
dsu = DSU(n)
for _ in range(q):
t, u, v = map(int, input().split())
if t == 0:
dsu.merge(u, v)
else:
print(1 if dsu.same(u, v) else 0)
def seg_func(x,y):
if x[0] > y[0]:
return x
else:
return y
def seg_func1(x,y):
if x[0] < y[0]:
return x
else:
return y
n = int(input())
X = []
for xx in range(n):
a, b = map(int, input().split())
X.append([xx, a, b])
X = sorted(X, key=lambda x: x[1])
dsu = DSU(n)
tree = SegTree(n+1,seg_func,[-1,-1])
for v in X:
tree.set_val(v[2], [v[2], v[0]])
get = tree.fold(0, v[2])
if get[0] != -1:
dsu.merge(get[1], v[0])
X = sorted(X, reverse=True, key=lambda x: x[1])
tree = SegTree(n+2,seg_func1,[10000000000,10000000000])
for v in X:
tree.set_val(v[2], [v[2],v[0]])
get = tree.fold(v[2]+1, n+2)
if get[0] != 10000000000:
dsu.merge(get[1], v[0])
groups = dsu.group()
ans = [0] * (n * 2 + 10)
for a in groups:
count = len(a)
for v in a:
ans[v]=count
for l, v in enumerate(ans):
if l < n:
print(str(v))
else:
exit()
``` | instruction | 0 | 31,556 | 1 | 63,112 |
No | output | 1 | 31,556 | 1 | 63,113 |
Provide a correct Python 3 solution for this coding contest problem.
The Kingdom of Neva is home to two ethnic groups, the Totata and the Tutete. The biggest feature of the Totata tribe is that they eat sweet and sour pork with pineapple. However, the Tutete tribe eats vinegared pork in pineapple. These two peoples couldn't get along with each other, and the Totata and Tutete have been in conflict for hundreds of years.
One day, a petition arrived from two ethnic groups under King Neva. According to it, the Totata tribe wants to build a road connecting the town A and the town B where they live. On the other hand, the Tutete tribe also wants to build a road connecting the town C and the town D where they live.
To prevent the two races from clashing, the roads of the Totata and Tutete cannot be crossed. Also, due to technical restrictions, it is only possible to build a road that connects the two cities in a straight line. In other words, if necessary, instead of connecting city A and city B directly with a road, it would indirectly connect city A and city B via some Totata towns (of course, of the Tutete tribe). Do not go through the city). At that time, the roads connecting the towns of the Totata tribe may intersect. The same applies to town C and town D.
Building a road costs proportional to its length. Therefore, I would like to make the total length of the roads to be constructed as short as possible while satisfying the conditions. Now, what is the minimum length?
Input
NA NB
xA, 1 yA, 1
xA, 2 yA, 2
..
..
..
xA, NA yA, NA
xB, 1 yB, 1
xB, 2 yB, 2
..
..
..
xB, NB yB, NB
The integer NA (2 ≤ NA ≤ 1,000) and the integer NB (2 ≤ NB ≤ 1,000) are written on the first line of the input, separated by blanks. This means that there are NA towns where the Totata tribe lives and NB towns where the Tutete tribe lives in the Kingdom of Neva. In the initial state, no road has been built anywhere.
The following NA line contains the integers xA, i (-10,000 ≤ xA, i ≤ 10,000) and the integers yA, i (-10,000 ≤ yA, i ≤ 10,000), separated by blanks. The geography of the Kingdom of Neva is represented by a two-dimensional Cartesian coordinate plane, and the integers xA, i and yA, i written on the 1 + i line are the position coordinates of the i-th city where the Totata tribe lives (xA, i, yA). , I). (xA, 1, yA, 1) and (xA, 2, yA, 2) are the coordinates of the two cities to be connected.
On the following NB line, the integers xB, i (-10,000 ≤ xB, i ≤ 10,000) and the integers yB, i (-10,000 ≤ yB, i ≤ 10,000) are written separated by blanks. The integers xB, i and yB, i written on the 1 + NA + i line indicate that the position coordinates of the i-th city where the Ytterbium live are (xB, i, yB, i). (xB, 1, yB, 1) and (xB, 2, yB, 2) are the coordinates of the two cities to be connected.
It can be assumed that the coordinates of the two cities are different and that none of the three cities are on the same straight line.
Output
When the road is constructed so as to meet the conditions of the problem statement, output the minimum value of the total length of the road. The "length" here is the Euclidean distance. However, if you cannot build a road that meets the conditions, output -1 instead. The output may contain errors, but the relative error to the true value must be less than 10-9.
Examples
Input
2 2
0 0
1 1
2 0
2 -1
Output
2.414213562373
Input
2 3
4 0
0 0
2 3
2 -2
3 1
Output
-1
Input
5 2
-2 1
1 2
-1 3
-1 5
1 4
0 4
0 0
Output
12.359173603117 | instruction | 0 | 31,744 | 1 | 63,488 |
"Correct Solution:
```
from heapq import heappush, heappop
from math import sqrt
import sys
readline = sys.stdin.buffer.readline
write = sys.stdout.write
N, M = map(int, readline().split())
PS = [list(map(int, readline().split())) for i in range(N)]
QS = [list(map(int, readline().split())) for i in range(M)]
def dot3(O, A, B):
ox, oy = O; ax, ay = A; bx, by = B
return (ax - ox) * (bx - ox) + (ay - oy) * (by - oy)
def cross3(O, A, B):
ox, oy = O; ax, ay = A; bx, by = B
return (ax - ox) * (by - oy) - (bx - ox) * (ay - oy)
def dist2(A, B):
ax, ay = A; bx, by = B
return (ax - bx) ** 2 + (ay - by) ** 2
def is_intersection(P0, P1, Q0, Q1):
C0 = cross3(P0, P1, Q0)
C1 = cross3(P0, P1, Q1)
D0 = cross3(Q0, Q1, P0)
D1 = cross3(Q0, Q1, P1)
if C0 == C1 == 0:
E0 = dot3(P0, P1, Q0)
E1 = dot3(P0, P1, Q1)
if not E0 < E1:
E0, E1 = E1, E0
return E0 <= dist2(P0, P1) and 0 <= E1
return C0 * C1 <= 0 and D0 * D1 <= 0
def solve(N, PS, q0, q1):
yield 10**18
p0 = PS[0]; p1 = PS[1]
if not is_intersection(p0, p1, q0, q1):
yield sqrt(dist2(p0, p1))
return
V0 = [i for i in range(2, N) if not is_intersection(p0, PS[i], q0, q1)]
V1 = [i for i in range(2, N) if not is_intersection(p1, PS[i], q0, q1)]
D0 = [sqrt(dist2(p0, p)) for p in PS]
D1 = [sqrt(dist2(p1, p)) for p in PS]
for v0 in V0:
for v1 in V1:
if v0 != v1:
if is_intersection(PS[v0], PS[v1], q0, q1):
continue
yield D0[v0] + D1[v1] + sqrt(dist2(PS[v0], PS[v1]))
else:
yield D0[v0] + D1[v1]
ans = min(
sqrt(dist2(QS[0], QS[1])) + min(solve(N, PS, QS[0], QS[1])),
sqrt(dist2(PS[0], PS[1])) + min(solve(M, QS, PS[0], PS[1]))
)
if ans < 10**9:
write("%.16f\n" % ans)
else:
write("-1\n")
``` | output | 1 | 31,744 | 1 | 63,489 |
Provide a correct Python 3 solution for this coding contest problem.
The Kingdom of Neva is home to two ethnic groups, the Totata and the Tutete. The biggest feature of the Totata tribe is that they eat sweet and sour pork with pineapple. However, the Tutete tribe eats vinegared pork in pineapple. These two peoples couldn't get along with each other, and the Totata and Tutete have been in conflict for hundreds of years.
One day, a petition arrived from two ethnic groups under King Neva. According to it, the Totata tribe wants to build a road connecting the town A and the town B where they live. On the other hand, the Tutete tribe also wants to build a road connecting the town C and the town D where they live.
To prevent the two races from clashing, the roads of the Totata and Tutete cannot be crossed. Also, due to technical restrictions, it is only possible to build a road that connects the two cities in a straight line. In other words, if necessary, instead of connecting city A and city B directly with a road, it would indirectly connect city A and city B via some Totata towns (of course, of the Tutete tribe). Do not go through the city). At that time, the roads connecting the towns of the Totata tribe may intersect. The same applies to town C and town D.
Building a road costs proportional to its length. Therefore, I would like to make the total length of the roads to be constructed as short as possible while satisfying the conditions. Now, what is the minimum length?
Input
NA NB
xA, 1 yA, 1
xA, 2 yA, 2
..
..
..
xA, NA yA, NA
xB, 1 yB, 1
xB, 2 yB, 2
..
..
..
xB, NB yB, NB
The integer NA (2 ≤ NA ≤ 1,000) and the integer NB (2 ≤ NB ≤ 1,000) are written on the first line of the input, separated by blanks. This means that there are NA towns where the Totata tribe lives and NB towns where the Tutete tribe lives in the Kingdom of Neva. In the initial state, no road has been built anywhere.
The following NA line contains the integers xA, i (-10,000 ≤ xA, i ≤ 10,000) and the integers yA, i (-10,000 ≤ yA, i ≤ 10,000), separated by blanks. The geography of the Kingdom of Neva is represented by a two-dimensional Cartesian coordinate plane, and the integers xA, i and yA, i written on the 1 + i line are the position coordinates of the i-th city where the Totata tribe lives (xA, i, yA). , I). (xA, 1, yA, 1) and (xA, 2, yA, 2) are the coordinates of the two cities to be connected.
On the following NB line, the integers xB, i (-10,000 ≤ xB, i ≤ 10,000) and the integers yB, i (-10,000 ≤ yB, i ≤ 10,000) are written separated by blanks. The integers xB, i and yB, i written on the 1 + NA + i line indicate that the position coordinates of the i-th city where the Ytterbium live are (xB, i, yB, i). (xB, 1, yB, 1) and (xB, 2, yB, 2) are the coordinates of the two cities to be connected.
It can be assumed that the coordinates of the two cities are different and that none of the three cities are on the same straight line.
Output
When the road is constructed so as to meet the conditions of the problem statement, output the minimum value of the total length of the road. The "length" here is the Euclidean distance. However, if you cannot build a road that meets the conditions, output -1 instead. The output may contain errors, but the relative error to the true value must be less than 10-9.
Examples
Input
2 2
0 0
1 1
2 0
2 -1
Output
2.414213562373
Input
2 3
4 0
0 0
2 3
2 -2
3 1
Output
-1
Input
5 2
-2 1
1 2
-1 3
-1 5
1 4
0 4
0 0
Output
12.359173603117 | instruction | 0 | 31,745 | 1 | 63,490 |
"Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**13
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def _kosa(a1, a2, b1, b2):
x1,y1 = a1
x2,y2 = a2
x3,y3 = b1
x4,y4 = b2
tc = (x1-x2)*(y3-y1)+(y1-y2)*(x1-x3)
td = (x1-x2)*(y4-y1)+(y1-y2)*(x1-x4)
return tc*td < 0
def kosa(a1, a2, b1, b2):
return _kosa(a1,a2,b1,b2) and _kosa(b1,b2,a1,a2)
def distance(x1, y1, x2, y2):
return math.sqrt((x1-x2)**2 + (y1-y2)**2)
def distance_p(a, b):
return distance(a[0], a[1], b[0], b[1])
def main():
rr = []
def f(n,m):
a = [LI() for _ in range(n)]
b = [LI() for _ in range(m)]
def search(a,b1,b2,rg):
d = collections.defaultdict(lambda: inf)
s = 0
t = 1
d[s] = 0
q = []
heapq.heappush(q, (0, s))
v = collections.defaultdict(bool)
while len(q):
k, u = heapq.heappop(q)
if v[u]:
continue
v[u] = True
if u == t:
return d[u]
for uv in rg:
if v[uv]:
continue
if kosa(a[u],a[uv], b1,b2):
continue
ud = distance_p(a[u],a[uv])
vd = k + ud
if d[uv] > vd:
d[uv] = vd
heapq.heappush(q, (vd, uv))
return -1
ad = distance_p(a[0], a[1])
bd = distance_p(b[0], b[1])
ar = search(a,b[0],b[1],list(range(1,n)))
br = search(b,a[0],a[1],list(range(1,m)))
r = -1
if ar < 0:
if br < 0:
return r
return '{:0.9f}'.format(br + ad)
if br < 0:
return '{:0.9f}'.format(ar + bd)
return '{:0.9f}'.format(min(ar + bd, br + ad))
while 1:
n,m = LI()
if n == 0:
break
rr.append(f(n,m))
# print(n, rr[-1])
break
return '\n'.join(map(str, rr))
print(main())
``` | output | 1 | 31,745 | 1 | 63,491 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The "Road Accident" band is planning an unprecedented tour around Treeland. The RA fans are looking forward to the event and making bets on how many concerts their favorite group will have.
Treeland consists of n cities, some pairs of cities are connected by bidirectional roads. Overall the country has n - 1 roads. We know that it is possible to get to any city from any other one. The cities are numbered by integers from 1 to n. For every city we know its value ri — the number of people in it.
We know that the band will travel along some path, having concerts in some cities along the path. The band's path will not pass one city twice, each time they move to the city that hasn't been previously visited. Thus, the musicians will travel along some path (without visiting any city twice) and in some (not necessarily all) cities along the way they will have concerts.
The band plans to gather all the big stadiums and concert halls during the tour, so every time they will perform in a city which population is larger than the population of the previously visited with concert city. In other words, the sequence of population in the cities where the concerts will be held is strictly increasing.
In a recent interview with the leader of the "road accident" band promised to the fans that the band will give concert in the largest possible number of cities! Thus the band will travel along some chain of cities of Treeland and have concerts in some of these cities, so that the population number will increase, and the number of concerts will be the largest possible.
The fans of Treeland are frantically trying to figure out how many concerts the group will have in Treeland. Looks like they can't manage without some help from a real programmer! Help the fans find the sought number of concerts.
Input
The first line of the input contains integer n (2 ≤ n ≤ 6000) — the number of cities in Treeland. The next line contains n integers r1, r2, ..., rn (1 ≤ ri ≤ 106), where ri is the population of the i-th city. The next n - 1 lines contain the descriptions of the roads, one road per line. Each road is defined by a pair of integers aj, bj (1 ≤ aj, bj ≤ n) — the pair of the numbers of the cities that are connected by the j-th road. All numbers in the lines are separated by spaces.
Output
Print the number of cities where the "Road Accident" band will have concerts.
Examples
Input
6
1 2 3 4 5 1
1 2
2 3
3 4
3 5
3 6
Output
4
Input
5
1 2 3 4 5
1 2
1 3
2 4
3 5
Output
3
Submitted Solution:
```
n=int(input())
tab=[0 for loop in range(n)]
s=input().split()
tab=list(map(int,s))
t=[ [] for loop in range(n) ]
for i in range(n-1):
a,b=map(int,input().split())
t[a-1].insert(0,b-1)
t[b-1].insert(0,a-1)
m=0
def look(i,v):
global m
for j in t[i]:
if tab[j]>tab[i]:
look(j,v+1)
if v>m:m=v
for i in range(n):
look(i,1)
print(m)
``` | instruction | 0 | 32,055 | 1 | 64,110 |
No | output | 1 | 32,055 | 1 | 64,111 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Someday, Drazil wanted to go on date with Varda. Drazil and Varda live on Cartesian plane. Drazil's home is located in point (0, 0) and Varda's home is located in point (a, b). In each step, he can move in a unit distance in horizontal or vertical direction. In other words, from position (x, y) he can go to positions (x + 1, y), (x - 1, y), (x, y + 1) or (x, y - 1).
Unfortunately, Drazil doesn't have sense of direction. So he randomly chooses the direction he will go to in each step. He may accidentally return back to his house during his travel. Drazil may even not notice that he has arrived to (a, b) and continue travelling.
Luckily, Drazil arrived to the position (a, b) successfully. Drazil said to Varda: "It took me exactly s steps to travel from my house to yours". But Varda is confused about his words, she is not sure that it is possible to get from (0, 0) to (a, b) in exactly s steps. Can you find out if it is possible for Varda?
Input
You are given three integers a, b, and s ( - 109 ≤ a, b ≤ 109, 1 ≤ s ≤ 2·109) in a single line.
Output
If you think Drazil made a mistake and it is impossible to take exactly s steps and get from his home to Varda's home, print "No" (without quotes).
Otherwise, print "Yes".
Examples
Input
5 5 11
Output
No
Input
10 15 25
Output
Yes
Input
0 5 1
Output
No
Input
0 0 2
Output
Yes
Note
In fourth sample case one possible route is: <image>. | instruction | 0 | 32,056 | 1 | 64,112 |
Tags: math
Correct Solution:
```
import math
a,b,s = (int(i) for i in input().split())
d = int(math.fabs(a)+math.fabs(b))
if (s<d):
print('NO')
exit(0)
s1 = s - d
if (s1%2==0):
print('YES')
else:
print('NO')
``` | output | 1 | 32,056 | 1 | 64,113 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Someday, Drazil wanted to go on date with Varda. Drazil and Varda live on Cartesian plane. Drazil's home is located in point (0, 0) and Varda's home is located in point (a, b). In each step, he can move in a unit distance in horizontal or vertical direction. In other words, from position (x, y) he can go to positions (x + 1, y), (x - 1, y), (x, y + 1) or (x, y - 1).
Unfortunately, Drazil doesn't have sense of direction. So he randomly chooses the direction he will go to in each step. He may accidentally return back to his house during his travel. Drazil may even not notice that he has arrived to (a, b) and continue travelling.
Luckily, Drazil arrived to the position (a, b) successfully. Drazil said to Varda: "It took me exactly s steps to travel from my house to yours". But Varda is confused about his words, she is not sure that it is possible to get from (0, 0) to (a, b) in exactly s steps. Can you find out if it is possible for Varda?
Input
You are given three integers a, b, and s ( - 109 ≤ a, b ≤ 109, 1 ≤ s ≤ 2·109) in a single line.
Output
If you think Drazil made a mistake and it is impossible to take exactly s steps and get from his home to Varda's home, print "No" (without quotes).
Otherwise, print "Yes".
Examples
Input
5 5 11
Output
No
Input
10 15 25
Output
Yes
Input
0 5 1
Output
No
Input
0 0 2
Output
Yes
Note
In fourth sample case one possible route is: <image>. | instruction | 0 | 32,057 | 1 | 64,114 |
Tags: math
Correct Solution:
```
a,b,c=map(int,input().split());a,b,c=abs(a),abs(b),abs(c)
if a+b==c or ((c-a+b)%2==0 and a+b<=c):print('YES')
else:print('NO')
``` | output | 1 | 32,057 | 1 | 64,115 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Someday, Drazil wanted to go on date with Varda. Drazil and Varda live on Cartesian plane. Drazil's home is located in point (0, 0) and Varda's home is located in point (a, b). In each step, he can move in a unit distance in horizontal or vertical direction. In other words, from position (x, y) he can go to positions (x + 1, y), (x - 1, y), (x, y + 1) or (x, y - 1).
Unfortunately, Drazil doesn't have sense of direction. So he randomly chooses the direction he will go to in each step. He may accidentally return back to his house during his travel. Drazil may even not notice that he has arrived to (a, b) and continue travelling.
Luckily, Drazil arrived to the position (a, b) successfully. Drazil said to Varda: "It took me exactly s steps to travel from my house to yours". But Varda is confused about his words, she is not sure that it is possible to get from (0, 0) to (a, b) in exactly s steps. Can you find out if it is possible for Varda?
Input
You are given three integers a, b, and s ( - 109 ≤ a, b ≤ 109, 1 ≤ s ≤ 2·109) in a single line.
Output
If you think Drazil made a mistake and it is impossible to take exactly s steps and get from his home to Varda's home, print "No" (without quotes).
Otherwise, print "Yes".
Examples
Input
5 5 11
Output
No
Input
10 15 25
Output
Yes
Input
0 5 1
Output
No
Input
0 0 2
Output
Yes
Note
In fourth sample case one possible route is: <image>. | instruction | 0 | 32,058 | 1 | 64,116 |
Tags: math
Correct Solution:
```
a,b,s = map(int,input().split())
mi = abs(a)+abs(b)
if s >= mi and (s-mi)%2 == 0:
print("Yes")
else:
print("No")
``` | output | 1 | 32,058 | 1 | 64,117 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Someday, Drazil wanted to go on date with Varda. Drazil and Varda live on Cartesian plane. Drazil's home is located in point (0, 0) and Varda's home is located in point (a, b). In each step, he can move in a unit distance in horizontal or vertical direction. In other words, from position (x, y) he can go to positions (x + 1, y), (x - 1, y), (x, y + 1) or (x, y - 1).
Unfortunately, Drazil doesn't have sense of direction. So he randomly chooses the direction he will go to in each step. He may accidentally return back to his house during his travel. Drazil may even not notice that he has arrived to (a, b) and continue travelling.
Luckily, Drazil arrived to the position (a, b) successfully. Drazil said to Varda: "It took me exactly s steps to travel from my house to yours". But Varda is confused about his words, she is not sure that it is possible to get from (0, 0) to (a, b) in exactly s steps. Can you find out if it is possible for Varda?
Input
You are given three integers a, b, and s ( - 109 ≤ a, b ≤ 109, 1 ≤ s ≤ 2·109) in a single line.
Output
If you think Drazil made a mistake and it is impossible to take exactly s steps and get from his home to Varda's home, print "No" (without quotes).
Otherwise, print "Yes".
Examples
Input
5 5 11
Output
No
Input
10 15 25
Output
Yes
Input
0 5 1
Output
No
Input
0 0 2
Output
Yes
Note
In fourth sample case one possible route is: <image>. | instruction | 0 | 32,059 | 1 | 64,118 |
Tags: math
Correct Solution:
```
a,b,s=map(int,input().split())
k=s-abs(a)-abs(b)
if k>=0 and k%2==0:
print('Yes')
else:
print('No')
``` | output | 1 | 32,059 | 1 | 64,119 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Someday, Drazil wanted to go on date with Varda. Drazil and Varda live on Cartesian plane. Drazil's home is located in point (0, 0) and Varda's home is located in point (a, b). In each step, he can move in a unit distance in horizontal or vertical direction. In other words, from position (x, y) he can go to positions (x + 1, y), (x - 1, y), (x, y + 1) or (x, y - 1).
Unfortunately, Drazil doesn't have sense of direction. So he randomly chooses the direction he will go to in each step. He may accidentally return back to his house during his travel. Drazil may even not notice that he has arrived to (a, b) and continue travelling.
Luckily, Drazil arrived to the position (a, b) successfully. Drazil said to Varda: "It took me exactly s steps to travel from my house to yours". But Varda is confused about his words, she is not sure that it is possible to get from (0, 0) to (a, b) in exactly s steps. Can you find out if it is possible for Varda?
Input
You are given three integers a, b, and s ( - 109 ≤ a, b ≤ 109, 1 ≤ s ≤ 2·109) in a single line.
Output
If you think Drazil made a mistake and it is impossible to take exactly s steps and get from his home to Varda's home, print "No" (without quotes).
Otherwise, print "Yes".
Examples
Input
5 5 11
Output
No
Input
10 15 25
Output
Yes
Input
0 5 1
Output
No
Input
0 0 2
Output
Yes
Note
In fourth sample case one possible route is: <image>. | instruction | 0 | 32,060 | 1 | 64,120 |
Tags: math
Correct Solution:
```
a,b,s=map(int,input().split())
s-=abs(a)+abs(b)
print(['No','Yes'][s>=0 and s%2==0])
``` | output | 1 | 32,060 | 1 | 64,121 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.