message stringlengths 2 67k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 463 109k | cluster float64 19 19 | __index_level_0__ int64 926 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya and Vasya are tossing a coin. Their friend Valera is appointed as a judge. The game is very simple. First Vasya tosses a coin x times, then Petya tosses a coin y times. If the tossing player gets head, he scores one point. If he gets tail, nobody gets any points. The winner is the player with most points by the end of the game. If boys have the same number of points, the game finishes with a draw.
At some point, Valera lost his count, and so he can not say exactly what the score is at the end of the game. But there are things he remembers for sure. He remembers that the entire game Vasya got heads at least a times, and Petya got heads at least b times. Moreover, he knows that the winner of the game was Vasya. Valera wants to use this information to know every possible outcome of the game, which do not contradict his memories.
Input
The single line contains four integers x, y, a, b (1 ≤ a ≤ x ≤ 100, 1 ≤ b ≤ y ≤ 100). The numbers on the line are separated by a space.
Output
In the first line print integer n — the number of possible outcomes of the game. Then on n lines print the outcomes. On the i-th line print a space-separated pair of integers ci, di — the number of heads Vasya and Petya got in the i-th outcome of the game, correspondingly. Print pairs of integers (ci, di) in the strictly increasing order.
Let us remind you that the pair of numbers (p1, q1) is less than the pair of numbers (p2, q2), if p1 < p2, or p1 = p2 and also q1 < q2.
Examples
Input
3 2 1 1
Output
3
2 1
3 1
3 2
Input
2 4 2 2
Output
0 | instruction | 0 | 32,795 | 19 | 65,590 |
Tags: brute force, implementation
Correct Solution:
```
x,y,a,b = map(int,input().split(' '))
c = []
for p in range(a,x+1):
for q in range(b,y+1):
if(q<p):
c.append((p,q))
print(len(c))
if c != []:
for p in c :
print(p[0],p[1])
``` | output | 1 | 32,795 | 19 | 65,591 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya and Vasya are tossing a coin. Their friend Valera is appointed as a judge. The game is very simple. First Vasya tosses a coin x times, then Petya tosses a coin y times. If the tossing player gets head, he scores one point. If he gets tail, nobody gets any points. The winner is the player with most points by the end of the game. If boys have the same number of points, the game finishes with a draw.
At some point, Valera lost his count, and so he can not say exactly what the score is at the end of the game. But there are things he remembers for sure. He remembers that the entire game Vasya got heads at least a times, and Petya got heads at least b times. Moreover, he knows that the winner of the game was Vasya. Valera wants to use this information to know every possible outcome of the game, which do not contradict his memories.
Input
The single line contains four integers x, y, a, b (1 ≤ a ≤ x ≤ 100, 1 ≤ b ≤ y ≤ 100). The numbers on the line are separated by a space.
Output
In the first line print integer n — the number of possible outcomes of the game. Then on n lines print the outcomes. On the i-th line print a space-separated pair of integers ci, di — the number of heads Vasya and Petya got in the i-th outcome of the game, correspondingly. Print pairs of integers (ci, di) in the strictly increasing order.
Let us remind you that the pair of numbers (p1, q1) is less than the pair of numbers (p2, q2), if p1 < p2, or p1 = p2 and also q1 < q2.
Examples
Input
3 2 1 1
Output
3
2 1
3 1
3 2
Input
2 4 2 2
Output
0 | instruction | 0 | 32,796 | 19 | 65,592 |
Tags: brute force, implementation
Correct Solution:
```
alll = [];
x, y, a, b = [int(x) for x in input().split()]
for i in range(a, x+1):
for j in range(b, y+1):
if i > j:
alll.append((i, j))
print(len(alll))
print("\n".join([" ".join([str(x) for x in v]) for v in alll]))
``` | output | 1 | 32,796 | 19 | 65,593 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya and Vasya are tossing a coin. Their friend Valera is appointed as a judge. The game is very simple. First Vasya tosses a coin x times, then Petya tosses a coin y times. If the tossing player gets head, he scores one point. If he gets tail, nobody gets any points. The winner is the player with most points by the end of the game. If boys have the same number of points, the game finishes with a draw.
At some point, Valera lost his count, and so he can not say exactly what the score is at the end of the game. But there are things he remembers for sure. He remembers that the entire game Vasya got heads at least a times, and Petya got heads at least b times. Moreover, he knows that the winner of the game was Vasya. Valera wants to use this information to know every possible outcome of the game, which do not contradict his memories.
Input
The single line contains four integers x, y, a, b (1 ≤ a ≤ x ≤ 100, 1 ≤ b ≤ y ≤ 100). The numbers on the line are separated by a space.
Output
In the first line print integer n — the number of possible outcomes of the game. Then on n lines print the outcomes. On the i-th line print a space-separated pair of integers ci, di — the number of heads Vasya and Petya got in the i-th outcome of the game, correspondingly. Print pairs of integers (ci, di) in the strictly increasing order.
Let us remind you that the pair of numbers (p1, q1) is less than the pair of numbers (p2, q2), if p1 < p2, or p1 = p2 and also q1 < q2.
Examples
Input
3 2 1 1
Output
3
2 1
3 1
3 2
Input
2 4 2 2
Output
0 | instruction | 0 | 32,797 | 19 | 65,594 |
Tags: brute force, implementation
Correct Solution:
```
import sys
import math
import collections
import heapq
import decimal
input=sys.stdin.readline
x,y,a,b=(int(i) for i in input().split())
ans=[]
for i in range(b,y+1):
for j in range(max(i+1,a),x+1):
ans.append([j,i])
print(len(ans))
ans.sort()
for i in ans:
print(*i)
``` | output | 1 | 32,797 | 19 | 65,595 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya and Vasya are tossing a coin. Their friend Valera is appointed as a judge. The game is very simple. First Vasya tosses a coin x times, then Petya tosses a coin y times. If the tossing player gets head, he scores one point. If he gets tail, nobody gets any points. The winner is the player with most points by the end of the game. If boys have the same number of points, the game finishes with a draw.
At some point, Valera lost his count, and so he can not say exactly what the score is at the end of the game. But there are things he remembers for sure. He remembers that the entire game Vasya got heads at least a times, and Petya got heads at least b times. Moreover, he knows that the winner of the game was Vasya. Valera wants to use this information to know every possible outcome of the game, which do not contradict his memories.
Input
The single line contains four integers x, y, a, b (1 ≤ a ≤ x ≤ 100, 1 ≤ b ≤ y ≤ 100). The numbers on the line are separated by a space.
Output
In the first line print integer n — the number of possible outcomes of the game. Then on n lines print the outcomes. On the i-th line print a space-separated pair of integers ci, di — the number of heads Vasya and Petya got in the i-th outcome of the game, correspondingly. Print pairs of integers (ci, di) in the strictly increasing order.
Let us remind you that the pair of numbers (p1, q1) is less than the pair of numbers (p2, q2), if p1 < p2, or p1 = p2 and also q1 < q2.
Examples
Input
3 2 1 1
Output
3
2 1
3 1
3 2
Input
2 4 2 2
Output
0 | instruction | 0 | 32,798 | 19 | 65,596 |
Tags: brute force, implementation
Correct Solution:
```
x,y,a,b=(map(int,input().split()))
l=[]
for i in range(a,x+1):
for j in range(b,y+1):
if i>j:
l.append((i,j))
print(len(l))
for i in range(len(l)):
print(*l[i])
``` | output | 1 | 32,798 | 19 | 65,597 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya and Vasya are tossing a coin. Their friend Valera is appointed as a judge. The game is very simple. First Vasya tosses a coin x times, then Petya tosses a coin y times. If the tossing player gets head, he scores one point. If he gets tail, nobody gets any points. The winner is the player with most points by the end of the game. If boys have the same number of points, the game finishes with a draw.
At some point, Valera lost his count, and so he can not say exactly what the score is at the end of the game. But there are things he remembers for sure. He remembers that the entire game Vasya got heads at least a times, and Petya got heads at least b times. Moreover, he knows that the winner of the game was Vasya. Valera wants to use this information to know every possible outcome of the game, which do not contradict his memories.
Input
The single line contains four integers x, y, a, b (1 ≤ a ≤ x ≤ 100, 1 ≤ b ≤ y ≤ 100). The numbers on the line are separated by a space.
Output
In the first line print integer n — the number of possible outcomes of the game. Then on n lines print the outcomes. On the i-th line print a space-separated pair of integers ci, di — the number of heads Vasya and Petya got in the i-th outcome of the game, correspondingly. Print pairs of integers (ci, di) in the strictly increasing order.
Let us remind you that the pair of numbers (p1, q1) is less than the pair of numbers (p2, q2), if p1 < p2, or p1 = p2 and also q1 < q2.
Examples
Input
3 2 1 1
Output
3
2 1
3 1
3 2
Input
2 4 2 2
Output
0 | instruction | 0 | 32,799 | 19 | 65,598 |
Tags: brute force, implementation
Correct Solution:
```
a, b, c, d = map(int, input().split(' '))
ct = 0
ct2 = 0
badtoed= []
for i in range(1, a+1):
for j in range(1, b+1):
if i > j and i >= c and j >= d:
badtoed.append(str(i) + ' ' + str(j))
ct += 1
print(ct)
for i in badtoed:
print(i)
``` | output | 1 | 32,799 | 19 | 65,599 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya and Vasya are tossing a coin. Their friend Valera is appointed as a judge. The game is very simple. First Vasya tosses a coin x times, then Petya tosses a coin y times. If the tossing player gets head, he scores one point. If he gets tail, nobody gets any points. The winner is the player with most points by the end of the game. If boys have the same number of points, the game finishes with a draw.
At some point, Valera lost his count, and so he can not say exactly what the score is at the end of the game. But there are things he remembers for sure. He remembers that the entire game Vasya got heads at least a times, and Petya got heads at least b times. Moreover, he knows that the winner of the game was Vasya. Valera wants to use this information to know every possible outcome of the game, which do not contradict his memories.
Input
The single line contains four integers x, y, a, b (1 ≤ a ≤ x ≤ 100, 1 ≤ b ≤ y ≤ 100). The numbers on the line are separated by a space.
Output
In the first line print integer n — the number of possible outcomes of the game. Then on n lines print the outcomes. On the i-th line print a space-separated pair of integers ci, di — the number of heads Vasya and Petya got in the i-th outcome of the game, correspondingly. Print pairs of integers (ci, di) in the strictly increasing order.
Let us remind you that the pair of numbers (p1, q1) is less than the pair of numbers (p2, q2), if p1 < p2, or p1 = p2 and also q1 < q2.
Examples
Input
3 2 1 1
Output
3
2 1
3 1
3 2
Input
2 4 2 2
Output
0 | instruction | 0 | 32,800 | 19 | 65,600 |
Tags: brute force, implementation
Correct Solution:
```
x, y, a, b = map(int, input().split())
n = 0
outcomes = []
for i in range(max(a, b + 1), x + 1):
for j in range(b, min(i, y + 1)):
n += 1
outcomes.append((i, j))
print (n)
for a, b in outcomes:
print (a, b)
``` | output | 1 | 32,800 | 19 | 65,601 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya and Vasya are tossing a coin. Their friend Valera is appointed as a judge. The game is very simple. First Vasya tosses a coin x times, then Petya tosses a coin y times. If the tossing player gets head, he scores one point. If he gets tail, nobody gets any points. The winner is the player with most points by the end of the game. If boys have the same number of points, the game finishes with a draw.
At some point, Valera lost his count, and so he can not say exactly what the score is at the end of the game. But there are things he remembers for sure. He remembers that the entire game Vasya got heads at least a times, and Petya got heads at least b times. Moreover, he knows that the winner of the game was Vasya. Valera wants to use this information to know every possible outcome of the game, which do not contradict his memories.
Input
The single line contains four integers x, y, a, b (1 ≤ a ≤ x ≤ 100, 1 ≤ b ≤ y ≤ 100). The numbers on the line are separated by a space.
Output
In the first line print integer n — the number of possible outcomes of the game. Then on n lines print the outcomes. On the i-th line print a space-separated pair of integers ci, di — the number of heads Vasya and Petya got in the i-th outcome of the game, correspondingly. Print pairs of integers (ci, di) in the strictly increasing order.
Let us remind you that the pair of numbers (p1, q1) is less than the pair of numbers (p2, q2), if p1 < p2, or p1 = p2 and also q1 < q2.
Examples
Input
3 2 1 1
Output
3
2 1
3 1
3 2
Input
2 4 2 2
Output
0
Submitted Solution:
```
x,y,a,b=(map(int,input().split()))
ht=[]
for i in range(a,x+1):
for j in range(b,y+1):
if i>j:
ht.append((i,j))
print(len(ht))
for i in range(len(ht)):
print(*ht[i])
``` | instruction | 0 | 32,801 | 19 | 65,602 |
Yes | output | 1 | 32,801 | 19 | 65,603 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya and Vasya are tossing a coin. Their friend Valera is appointed as a judge. The game is very simple. First Vasya tosses a coin x times, then Petya tosses a coin y times. If the tossing player gets head, he scores one point. If he gets tail, nobody gets any points. The winner is the player with most points by the end of the game. If boys have the same number of points, the game finishes with a draw.
At some point, Valera lost his count, and so he can not say exactly what the score is at the end of the game. But there are things he remembers for sure. He remembers that the entire game Vasya got heads at least a times, and Petya got heads at least b times. Moreover, he knows that the winner of the game was Vasya. Valera wants to use this information to know every possible outcome of the game, which do not contradict his memories.
Input
The single line contains four integers x, y, a, b (1 ≤ a ≤ x ≤ 100, 1 ≤ b ≤ y ≤ 100). The numbers on the line are separated by a space.
Output
In the first line print integer n — the number of possible outcomes of the game. Then on n lines print the outcomes. On the i-th line print a space-separated pair of integers ci, di — the number of heads Vasya and Petya got in the i-th outcome of the game, correspondingly. Print pairs of integers (ci, di) in the strictly increasing order.
Let us remind you that the pair of numbers (p1, q1) is less than the pair of numbers (p2, q2), if p1 < p2, or p1 = p2 and also q1 < q2.
Examples
Input
3 2 1 1
Output
3
2 1
3 1
3 2
Input
2 4 2 2
Output
0
Submitted Solution:
```
x,y,a,b=list(map(int,input().split()))
ans=[]
for i in range(b,y+1):
for j in range(a,x+1):
if i<j:
ans.append([j,i])
print(len(ans))
ans.sort()
for i in ans:
print(*i)
``` | instruction | 0 | 32,802 | 19 | 65,604 |
Yes | output | 1 | 32,802 | 19 | 65,605 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya and Vasya are tossing a coin. Their friend Valera is appointed as a judge. The game is very simple. First Vasya tosses a coin x times, then Petya tosses a coin y times. If the tossing player gets head, he scores one point. If he gets tail, nobody gets any points. The winner is the player with most points by the end of the game. If boys have the same number of points, the game finishes with a draw.
At some point, Valera lost his count, and so he can not say exactly what the score is at the end of the game. But there are things he remembers for sure. He remembers that the entire game Vasya got heads at least a times, and Petya got heads at least b times. Moreover, he knows that the winner of the game was Vasya. Valera wants to use this information to know every possible outcome of the game, which do not contradict his memories.
Input
The single line contains four integers x, y, a, b (1 ≤ a ≤ x ≤ 100, 1 ≤ b ≤ y ≤ 100). The numbers on the line are separated by a space.
Output
In the first line print integer n — the number of possible outcomes of the game. Then on n lines print the outcomes. On the i-th line print a space-separated pair of integers ci, di — the number of heads Vasya and Petya got in the i-th outcome of the game, correspondingly. Print pairs of integers (ci, di) in the strictly increasing order.
Let us remind you that the pair of numbers (p1, q1) is less than the pair of numbers (p2, q2), if p1 < p2, or p1 = p2 and also q1 < q2.
Examples
Input
3 2 1 1
Output
3
2 1
3 1
3 2
Input
2 4 2 2
Output
0
Submitted Solution:
```
x,y,a,b=map(int,input().split())
if(a<b and (x-a)<=(b-a)) or (a==b and x<y):
print(0)
else:
c=0
for i in range(a,x+1):
for j in range(b,y+1):
if(i>j):
c=c+1
print(c)
for i in range(a,x+1):
for j in range(b,y+1):
if(i>j):
print(i,j)
``` | instruction | 0 | 32,803 | 19 | 65,606 |
Yes | output | 1 | 32,803 | 19 | 65,607 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya and Vasya are tossing a coin. Their friend Valera is appointed as a judge. The game is very simple. First Vasya tosses a coin x times, then Petya tosses a coin y times. If the tossing player gets head, he scores one point. If he gets tail, nobody gets any points. The winner is the player with most points by the end of the game. If boys have the same number of points, the game finishes with a draw.
At some point, Valera lost his count, and so he can not say exactly what the score is at the end of the game. But there are things he remembers for sure. He remembers that the entire game Vasya got heads at least a times, and Petya got heads at least b times. Moreover, he knows that the winner of the game was Vasya. Valera wants to use this information to know every possible outcome of the game, which do not contradict his memories.
Input
The single line contains four integers x, y, a, b (1 ≤ a ≤ x ≤ 100, 1 ≤ b ≤ y ≤ 100). The numbers on the line are separated by a space.
Output
In the first line print integer n — the number of possible outcomes of the game. Then on n lines print the outcomes. On the i-th line print a space-separated pair of integers ci, di — the number of heads Vasya and Petya got in the i-th outcome of the game, correspondingly. Print pairs of integers (ci, di) in the strictly increasing order.
Let us remind you that the pair of numbers (p1, q1) is less than the pair of numbers (p2, q2), if p1 < p2, or p1 = p2 and also q1 < q2.
Examples
Input
3 2 1 1
Output
3
2 1
3 1
3 2
Input
2 4 2 2
Output
0
Submitted Solution:
```
l = input().split()
l = [int(x) for x in l]
x = l[0]
y = l[1]
a = l[2]
b = l[3]
r = []
for i in range(a, x+1):
for j in range(b, y+1):
if i>j:
r.append((i, j))
else:
break
print(len(r))
for x in r:
print(x[0], x[1])
``` | instruction | 0 | 32,804 | 19 | 65,608 |
Yes | output | 1 | 32,804 | 19 | 65,609 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya and Vasya are tossing a coin. Their friend Valera is appointed as a judge. The game is very simple. First Vasya tosses a coin x times, then Petya tosses a coin y times. If the tossing player gets head, he scores one point. If he gets tail, nobody gets any points. The winner is the player with most points by the end of the game. If boys have the same number of points, the game finishes with a draw.
At some point, Valera lost his count, and so he can not say exactly what the score is at the end of the game. But there are things he remembers for sure. He remembers that the entire game Vasya got heads at least a times, and Petya got heads at least b times. Moreover, he knows that the winner of the game was Vasya. Valera wants to use this information to know every possible outcome of the game, which do not contradict his memories.
Input
The single line contains four integers x, y, a, b (1 ≤ a ≤ x ≤ 100, 1 ≤ b ≤ y ≤ 100). The numbers on the line are separated by a space.
Output
In the first line print integer n — the number of possible outcomes of the game. Then on n lines print the outcomes. On the i-th line print a space-separated pair of integers ci, di — the number of heads Vasya and Petya got in the i-th outcome of the game, correspondingly. Print pairs of integers (ci, di) in the strictly increasing order.
Let us remind you that the pair of numbers (p1, q1) is less than the pair of numbers (p2, q2), if p1 < p2, or p1 = p2 and also q1 < q2.
Examples
Input
3 2 1 1
Output
3
2 1
3 1
3 2
Input
2 4 2 2
Output
0
Submitted Solution:
```
# your code goes here
arr = input().split()
p = int(arr[0])
q = int(arr[1])
a = int(arr[2])
b = int(arr[3])
flag = 0
if a <= b:
a = b+1
x = b
y = a
while(a <= p):
b = x
while(b < a):
flag += 1
#print(str(a) + ' ' + str(b))
b += 1
a += 1
print(str(flag))
a = y
b = x
while(a <= p):
b = x
while(b < a):
flag += 1
print(str(a) + ' ' + str(b))
b += 1
a += 1
``` | instruction | 0 | 32,805 | 19 | 65,610 |
No | output | 1 | 32,805 | 19 | 65,611 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya and Vasya are tossing a coin. Their friend Valera is appointed as a judge. The game is very simple. First Vasya tosses a coin x times, then Petya tosses a coin y times. If the tossing player gets head, he scores one point. If he gets tail, nobody gets any points. The winner is the player with most points by the end of the game. If boys have the same number of points, the game finishes with a draw.
At some point, Valera lost his count, and so he can not say exactly what the score is at the end of the game. But there are things he remembers for sure. He remembers that the entire game Vasya got heads at least a times, and Petya got heads at least b times. Moreover, he knows that the winner of the game was Vasya. Valera wants to use this information to know every possible outcome of the game, which do not contradict his memories.
Input
The single line contains four integers x, y, a, b (1 ≤ a ≤ x ≤ 100, 1 ≤ b ≤ y ≤ 100). The numbers on the line are separated by a space.
Output
In the first line print integer n — the number of possible outcomes of the game. Then on n lines print the outcomes. On the i-th line print a space-separated pair of integers ci, di — the number of heads Vasya and Petya got in the i-th outcome of the game, correspondingly. Print pairs of integers (ci, di) in the strictly increasing order.
Let us remind you that the pair of numbers (p1, q1) is less than the pair of numbers (p2, q2), if p1 < p2, or p1 = p2 and also q1 < q2.
Examples
Input
3 2 1 1
Output
3
2 1
3 1
3 2
Input
2 4 2 2
Output
0
Submitted Solution:
```
a=input()
a=a.split(' ')
a=[*map(int,a)]
b=a[1]
c=a[2]
d=a[3]
a=a[0]
e=c
f=d
g=[]
h=[]
while(e<=a):
for o in range(d,f+1):
if(o<e and o<=b):
h.append(o)
g.append(e)
f=e
e+=1
print(len(g))
for i in range(len(g)):
print(g[i],h[i])
``` | instruction | 0 | 32,806 | 19 | 65,612 |
No | output | 1 | 32,806 | 19 | 65,613 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya and Vasya are tossing a coin. Their friend Valera is appointed as a judge. The game is very simple. First Vasya tosses a coin x times, then Petya tosses a coin y times. If the tossing player gets head, he scores one point. If he gets tail, nobody gets any points. The winner is the player with most points by the end of the game. If boys have the same number of points, the game finishes with a draw.
At some point, Valera lost his count, and so he can not say exactly what the score is at the end of the game. But there are things he remembers for sure. He remembers that the entire game Vasya got heads at least a times, and Petya got heads at least b times. Moreover, he knows that the winner of the game was Vasya. Valera wants to use this information to know every possible outcome of the game, which do not contradict his memories.
Input
The single line contains four integers x, y, a, b (1 ≤ a ≤ x ≤ 100, 1 ≤ b ≤ y ≤ 100). The numbers on the line are separated by a space.
Output
In the first line print integer n — the number of possible outcomes of the game. Then on n lines print the outcomes. On the i-th line print a space-separated pair of integers ci, di — the number of heads Vasya and Petya got in the i-th outcome of the game, correspondingly. Print pairs of integers (ci, di) in the strictly increasing order.
Let us remind you that the pair of numbers (p1, q1) is less than the pair of numbers (p2, q2), if p1 < p2, or p1 = p2 and also q1 < q2.
Examples
Input
3 2 1 1
Output
3
2 1
3 1
3 2
Input
2 4 2 2
Output
0
Submitted Solution:
```
x, y, a, b = map(int, input().split())
a = max(a, b + 1)
l = []
if a < x:
for i in range(a, x + 1):
for j in range(b, y + 1):
if i > j:
l.append((i, j))
print(len(l))
for i in l:
print(i[0], i[1])
``` | instruction | 0 | 32,807 | 19 | 65,614 |
No | output | 1 | 32,807 | 19 | 65,615 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya and Vasya are tossing a coin. Their friend Valera is appointed as a judge. The game is very simple. First Vasya tosses a coin x times, then Petya tosses a coin y times. If the tossing player gets head, he scores one point. If he gets tail, nobody gets any points. The winner is the player with most points by the end of the game. If boys have the same number of points, the game finishes with a draw.
At some point, Valera lost his count, and so he can not say exactly what the score is at the end of the game. But there are things he remembers for sure. He remembers that the entire game Vasya got heads at least a times, and Petya got heads at least b times. Moreover, he knows that the winner of the game was Vasya. Valera wants to use this information to know every possible outcome of the game, which do not contradict his memories.
Input
The single line contains four integers x, y, a, b (1 ≤ a ≤ x ≤ 100, 1 ≤ b ≤ y ≤ 100). The numbers on the line are separated by a space.
Output
In the first line print integer n — the number of possible outcomes of the game. Then on n lines print the outcomes. On the i-th line print a space-separated pair of integers ci, di — the number of heads Vasya and Petya got in the i-th outcome of the game, correspondingly. Print pairs of integers (ci, di) in the strictly increasing order.
Let us remind you that the pair of numbers (p1, q1) is less than the pair of numbers (p2, q2), if p1 < p2, or p1 = p2 and also q1 < q2.
Examples
Input
3 2 1 1
Output
3
2 1
3 1
3 2
Input
2 4 2 2
Output
0
Submitted Solution:
```
x,y,a,b = map(int, input().split())
final = []
for i in range(a+1, x+1):
for j in range(b, y+1):
if(i > j):
final.append([i,j])
else:
break
print(len(final))
for i in range(len(final)):
print(*final[i])
``` | instruction | 0 | 32,808 | 19 | 65,616 |
No | output | 1 | 32,808 | 19 | 65,617 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alex doesn't like boredom. That's why whenever he gets bored, he comes up with games. One long winter evening he came up with a game and decided to play it.
Given a sequence a consisting of n integers. The player can make several steps. In a single step he can choose an element of the sequence (let's denote it ak) and delete it, at that all elements equal to ak + 1 and ak - 1 also must be deleted from the sequence. That step brings ak points to the player.
Alex is a perfectionist, so he decided to get as many points as possible. Help him.
Input
The first line contains integer n (1 ≤ n ≤ 105) that shows how many numbers are in Alex's sequence.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105).
Output
Print a single integer — the maximum number of points that Alex can earn.
Examples
Input
2
1 2
Output
2
Input
3
1 2 3
Output
4
Input
9
1 2 1 3 2 2 2 2 3
Output
10
Note
Consider the third test example. At first step we need to choose any element equal to 2. After that step our sequence looks like this [2, 2, 2, 2]. Then we do 4 steps, on each step we choose any element equals to 2. In total we earn 10 points. | instruction | 0 | 32,906 | 19 | 65,812 |
Tags: dp
Correct Solution:
```
n = int(input())
l = list(map(int,input().split()))
m = (10**5)+2
f = [0]*m
for i in l :
f[i] += 1
#print(f)
dp = [0]*m
#print(dp)
dp[1] , dp[2] = f[1] , f[2]*2
for i in range(3,m):
dp[i] +=max(dp[i - 2] , dp[i-3]) + (f[i]*i)
#print(dp)
print(max(dp))
``` | output | 1 | 32,906 | 19 | 65,813 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alex doesn't like boredom. That's why whenever he gets bored, he comes up with games. One long winter evening he came up with a game and decided to play it.
Given a sequence a consisting of n integers. The player can make several steps. In a single step he can choose an element of the sequence (let's denote it ak) and delete it, at that all elements equal to ak + 1 and ak - 1 also must be deleted from the sequence. That step brings ak points to the player.
Alex is a perfectionist, so he decided to get as many points as possible. Help him.
Input
The first line contains integer n (1 ≤ n ≤ 105) that shows how many numbers are in Alex's sequence.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105).
Output
Print a single integer — the maximum number of points that Alex can earn.
Examples
Input
2
1 2
Output
2
Input
3
1 2 3
Output
4
Input
9
1 2 1 3 2 2 2 2 3
Output
10
Note
Consider the third test example. At first step we need to choose any element equal to 2. After that step our sequence looks like this [2, 2, 2, 2]. Then we do 4 steps, on each step we choose any element equals to 2. In total we earn 10 points. | instruction | 0 | 32,907 | 19 | 65,814 |
Tags: dp
Correct Solution:
```
input()
l = list(map(int,input().split())) # Get list of all numbers
n = max(l)+1 # Determine length of cnt
cnt = [0]*n # Initialize array cnt, used to store the count of every number in list l
for i in l: cnt[i] += 1 # Calculate cnt
# print(cnt) #
# test = [] #
# for i in range(n): #
# test.append(cnt[i]*i) #
# print(test) #
dp = [0]*n
dp[0] = 0
dp[1] = cnt[1]
for i in range(2,n):
dp[i] = max(dp[i-1],dp[i-2]+cnt[i]*i)
##z,x=x,max(x,z+cnt[i]*i)
# print(i,z,x) #
print(dp[-1])
``` | output | 1 | 32,907 | 19 | 65,815 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alex doesn't like boredom. That's why whenever he gets bored, he comes up with games. One long winter evening he came up with a game and decided to play it.
Given a sequence a consisting of n integers. The player can make several steps. In a single step he can choose an element of the sequence (let's denote it ak) and delete it, at that all elements equal to ak + 1 and ak - 1 also must be deleted from the sequence. That step brings ak points to the player.
Alex is a perfectionist, so he decided to get as many points as possible. Help him.
Input
The first line contains integer n (1 ≤ n ≤ 105) that shows how many numbers are in Alex's sequence.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105).
Output
Print a single integer — the maximum number of points that Alex can earn.
Examples
Input
2
1 2
Output
2
Input
3
1 2 3
Output
4
Input
9
1 2 1 3 2 2 2 2 3
Output
10
Note
Consider the third test example. At first step we need to choose any element equal to 2. After that step our sequence looks like this [2, 2, 2, 2]. Then we do 4 steps, on each step we choose any element equals to 2. In total we earn 10 points. | instruction | 0 | 32,908 | 19 | 65,816 |
Tags: dp
Correct Solution:
```
input()
p = [0] * 100002
s = input().split()
for k in s:
p[int(k)] += 1
for i in range(1, 100002):
p[i] = max(p[i-1], p[i-2] + i*p[i])
print(p[-1])
``` | output | 1 | 32,908 | 19 | 65,817 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alex doesn't like boredom. That's why whenever he gets bored, he comes up with games. One long winter evening he came up with a game and decided to play it.
Given a sequence a consisting of n integers. The player can make several steps. In a single step he can choose an element of the sequence (let's denote it ak) and delete it, at that all elements equal to ak + 1 and ak - 1 also must be deleted from the sequence. That step brings ak points to the player.
Alex is a perfectionist, so he decided to get as many points as possible. Help him.
Input
The first line contains integer n (1 ≤ n ≤ 105) that shows how many numbers are in Alex's sequence.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105).
Output
Print a single integer — the maximum number of points that Alex can earn.
Examples
Input
2
1 2
Output
2
Input
3
1 2 3
Output
4
Input
9
1 2 1 3 2 2 2 2 3
Output
10
Note
Consider the third test example. At first step we need to choose any element equal to 2. After that step our sequence looks like this [2, 2, 2, 2]. Then we do 4 steps, on each step we choose any element equals to 2. In total we earn 10 points. | instruction | 0 | 32,909 | 19 | 65,818 |
Tags: dp
Correct Solution:
```
#Dynamic Programming - Boredom
# https://codeforces.com/problemset/problem/455/A?fbclid=IwAR2MNUknSk6z3fU7C29BR_QNN0R7mat-Ei2_lt24NAKypORavAWAMO_vMus
import queue
n = int(input())
def dp(n,countArr, arrDP):
if arrDP[n] != -1:
return arrDP[n]
arrDP[n] = max(dp(n - 1,countArr, arrDP),dp(n - 2,countArr, arrDP) + countArr[n]*n)
return arrDP[n]
arr = list(map(int, input().split()))
countArr = [0] * 100001
maxNum = 0
for i in range(len(arr)):
maxNum = max(maxNum, arr[i])
countArr[arr[i]] += 1
maxArr = [-1] * 100001
maxArr[0] = 0
maxArr[1] = countArr[1]
for i in range(maxNum + 1):
result = dp(i, countArr, maxArr)
print(result)
``` | output | 1 | 32,909 | 19 | 65,819 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alex doesn't like boredom. That's why whenever he gets bored, he comes up with games. One long winter evening he came up with a game and decided to play it.
Given a sequence a consisting of n integers. The player can make several steps. In a single step he can choose an element of the sequence (let's denote it ak) and delete it, at that all elements equal to ak + 1 and ak - 1 also must be deleted from the sequence. That step brings ak points to the player.
Alex is a perfectionist, so he decided to get as many points as possible. Help him.
Input
The first line contains integer n (1 ≤ n ≤ 105) that shows how many numbers are in Alex's sequence.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105).
Output
Print a single integer — the maximum number of points that Alex can earn.
Examples
Input
2
1 2
Output
2
Input
3
1 2 3
Output
4
Input
9
1 2 1 3 2 2 2 2 3
Output
10
Note
Consider the third test example. At first step we need to choose any element equal to 2. After that step our sequence looks like this [2, 2, 2, 2]. Then we do 4 steps, on each step we choose any element equals to 2. In total we earn 10 points. | instruction | 0 | 32,910 | 19 | 65,820 |
Tags: dp
Correct Solution:
```
from collections import defaultdict
n=int(input())
l=list(map(int,input().split()))
d={}
d=defaultdict(int)
maxi=-99
for i in l:
d[i]+=1
maxi=max(i,maxi)
dp=[0]*(100001)
dp[1]=d[1]
for i in range(2,100000+1):
dp[i]=max(dp[i-1],dp[i-2]+(d[i])*i)
print(max(dp))
``` | output | 1 | 32,910 | 19 | 65,821 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alex doesn't like boredom. That's why whenever he gets bored, he comes up with games. One long winter evening he came up with a game and decided to play it.
Given a sequence a consisting of n integers. The player can make several steps. In a single step he can choose an element of the sequence (let's denote it ak) and delete it, at that all elements equal to ak + 1 and ak - 1 also must be deleted from the sequence. That step brings ak points to the player.
Alex is a perfectionist, so he decided to get as many points as possible. Help him.
Input
The first line contains integer n (1 ≤ n ≤ 105) that shows how many numbers are in Alex's sequence.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105).
Output
Print a single integer — the maximum number of points that Alex can earn.
Examples
Input
2
1 2
Output
2
Input
3
1 2 3
Output
4
Input
9
1 2 1 3 2 2 2 2 3
Output
10
Note
Consider the third test example. At first step we need to choose any element equal to 2. After that step our sequence looks like this [2, 2, 2, 2]. Then we do 4 steps, on each step we choose any element equals to 2. In total we earn 10 points. | instruction | 0 | 32,911 | 19 | 65,822 |
Tags: dp
Correct Solution:
```
import sys
import math
from collections import defaultdict,Counter
# input=sys.stdin.readline
# def print(x):
# sys.stdout.write(str(x)+"\n")
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# sys.stdout=open("CP1/output.txt",'w')
# sys.stdin=open("CP1/input.txt",'r')
# mod=pow(10,9)+7
n=int(input())
a=list(map(int,input().split()))
c=Counter(a)
dp=[0]*(10**5+2)
for j in range(1,10**5+1):
dp[j]=dp[j-1]
if c.get(j)!=None:
dp[j]=max(dp[j],c[j]*j+dp[j-2])
print(dp[10**5])
``` | output | 1 | 32,911 | 19 | 65,823 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alex doesn't like boredom. That's why whenever he gets bored, he comes up with games. One long winter evening he came up with a game and decided to play it.
Given a sequence a consisting of n integers. The player can make several steps. In a single step he can choose an element of the sequence (let's denote it ak) and delete it, at that all elements equal to ak + 1 and ak - 1 also must be deleted from the sequence. That step brings ak points to the player.
Alex is a perfectionist, so he decided to get as many points as possible. Help him.
Input
The first line contains integer n (1 ≤ n ≤ 105) that shows how many numbers are in Alex's sequence.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105).
Output
Print a single integer — the maximum number of points that Alex can earn.
Examples
Input
2
1 2
Output
2
Input
3
1 2 3
Output
4
Input
9
1 2 1 3 2 2 2 2 3
Output
10
Note
Consider the third test example. At first step we need to choose any element equal to 2. After that step our sequence looks like this [2, 2, 2, 2]. Then we do 4 steps, on each step we choose any element equals to 2. In total we earn 10 points. | instruction | 0 | 32,912 | 19 | 65,824 |
Tags: dp
Correct Solution:
```
n = int(input().strip())
l = [0]*100002
for x in input().split():
l[int(x)] += int(x)
max = l[1]
for i in range (2,len(l)):
if l[i-2] + l[i] > max:
max = l[i-2] + l[i]
l[i] = max
print (max)
``` | output | 1 | 32,912 | 19 | 65,825 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alex doesn't like boredom. That's why whenever he gets bored, he comes up with games. One long winter evening he came up with a game and decided to play it.
Given a sequence a consisting of n integers. The player can make several steps. In a single step he can choose an element of the sequence (let's denote it ak) and delete it, at that all elements equal to ak + 1 and ak - 1 also must be deleted from the sequence. That step brings ak points to the player.
Alex is a perfectionist, so he decided to get as many points as possible. Help him.
Input
The first line contains integer n (1 ≤ n ≤ 105) that shows how many numbers are in Alex's sequence.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105).
Output
Print a single integer — the maximum number of points that Alex can earn.
Examples
Input
2
1 2
Output
2
Input
3
1 2 3
Output
4
Input
9
1 2 1 3 2 2 2 2 3
Output
10
Note
Consider the third test example. At first step we need to choose any element equal to 2. After that step our sequence looks like this [2, 2, 2, 2]. Then we do 4 steps, on each step we choose any element equals to 2. In total we earn 10 points. | instruction | 0 | 32,913 | 19 | 65,826 |
Tags: dp
Correct Solution:
```
n=int(input())
a=[int(x) for x in input().split()]
l=[0]*(10**5+1)
ma=0
for i in a:
l[i]+=1
ma=max(ma,i)
f=[0]*(ma+1)
f[0]=0
f[1]=l[1]
for i in range(2,ma+1):
f[i]=max(f[i-1],f[i-2]+l[i]*i)
print(f[ma])
``` | output | 1 | 32,913 | 19 | 65,827 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alex doesn't like boredom. That's why whenever he gets bored, he comes up with games. One long winter evening he came up with a game and decided to play it.
Given a sequence a consisting of n integers. The player can make several steps. In a single step he can choose an element of the sequence (let's denote it ak) and delete it, at that all elements equal to ak + 1 and ak - 1 also must be deleted from the sequence. That step brings ak points to the player.
Alex is a perfectionist, so he decided to get as many points as possible. Help him.
Input
The first line contains integer n (1 ≤ n ≤ 105) that shows how many numbers are in Alex's sequence.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105).
Output
Print a single integer — the maximum number of points that Alex can earn.
Examples
Input
2
1 2
Output
2
Input
3
1 2 3
Output
4
Input
9
1 2 1 3 2 2 2 2 3
Output
10
Note
Consider the third test example. At first step we need to choose any element equal to 2. After that step our sequence looks like this [2, 2, 2, 2]. Then we do 4 steps, on each step we choose any element equals to 2. In total we earn 10 points.
Submitted Solution:
```
from collections import Counter
input()
c = Counter(map(int, input().split()))
max_ = max(c)
max_points = {1: c[1], 2: max(c[1], 2 * c[2])}
for i in range(3, max_ + 1):
max_points[i] = max(max_points[i - 2] + i * c[i], max_points[i - 1])
print(max_points[max_])
``` | instruction | 0 | 32,914 | 19 | 65,828 |
Yes | output | 1 | 32,914 | 19 | 65,829 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alex doesn't like boredom. That's why whenever he gets bored, he comes up with games. One long winter evening he came up with a game and decided to play it.
Given a sequence a consisting of n integers. The player can make several steps. In a single step he can choose an element of the sequence (let's denote it ak) and delete it, at that all elements equal to ak + 1 and ak - 1 also must be deleted from the sequence. That step brings ak points to the player.
Alex is a perfectionist, so he decided to get as many points as possible. Help him.
Input
The first line contains integer n (1 ≤ n ≤ 105) that shows how many numbers are in Alex's sequence.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105).
Output
Print a single integer — the maximum number of points that Alex can earn.
Examples
Input
2
1 2
Output
2
Input
3
1 2 3
Output
4
Input
9
1 2 1 3 2 2 2 2 3
Output
10
Note
Consider the third test example. At first step we need to choose any element equal to 2. After that step our sequence looks like this [2, 2, 2, 2]. Then we do 4 steps, on each step we choose any element equals to 2. In total we earn 10 points.
Submitted Solution:
```
# dynamic programming
input()
seq = [int(i) for i in input().split()]
max_n = max(seq)
ans = [0] * (max_n + 1)
# count = {num:seq.count(num) for num in range(max(seq)+1)}
count = [0] * (max_n + 1)
for n in seq:
count[n] += 1
ans[1] = count[1]
for i in range(2, max_n + 1):
ans[i] = max(ans[i-2]+i*count[i], ans[i-1])
print(ans[-1])
``` | instruction | 0 | 32,915 | 19 | 65,830 |
Yes | output | 1 | 32,915 | 19 | 65,831 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alex doesn't like boredom. That's why whenever he gets bored, he comes up with games. One long winter evening he came up with a game and decided to play it.
Given a sequence a consisting of n integers. The player can make several steps. In a single step he can choose an element of the sequence (let's denote it ak) and delete it, at that all elements equal to ak + 1 and ak - 1 also must be deleted from the sequence. That step brings ak points to the player.
Alex is a perfectionist, so he decided to get as many points as possible. Help him.
Input
The first line contains integer n (1 ≤ n ≤ 105) that shows how many numbers are in Alex's sequence.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105).
Output
Print a single integer — the maximum number of points that Alex can earn.
Examples
Input
2
1 2
Output
2
Input
3
1 2 3
Output
4
Input
9
1 2 1 3 2 2 2 2 3
Output
10
Note
Consider the third test example. At first step we need to choose any element equal to 2. After that step our sequence looks like this [2, 2, 2, 2]. Then we do 4 steps, on each step we choose any element equals to 2. In total we earn 10 points.
Submitted Solution:
```
input()
n=[0]*100001
for i in map(int,input().split()):
n[i]+=i
a=b=0
for j in n:
a,b=max(a,j+b),a
print(a)
``` | instruction | 0 | 32,916 | 19 | 65,832 |
Yes | output | 1 | 32,916 | 19 | 65,833 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alex doesn't like boredom. That's why whenever he gets bored, he comes up with games. One long winter evening he came up with a game and decided to play it.
Given a sequence a consisting of n integers. The player can make several steps. In a single step he can choose an element of the sequence (let's denote it ak) and delete it, at that all elements equal to ak + 1 and ak - 1 also must be deleted from the sequence. That step brings ak points to the player.
Alex is a perfectionist, so he decided to get as many points as possible. Help him.
Input
The first line contains integer n (1 ≤ n ≤ 105) that shows how many numbers are in Alex's sequence.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105).
Output
Print a single integer — the maximum number of points that Alex can earn.
Examples
Input
2
1 2
Output
2
Input
3
1 2 3
Output
4
Input
9
1 2 1 3 2 2 2 2 3
Output
10
Note
Consider the third test example. At first step we need to choose any element equal to 2. After that step our sequence looks like this [2, 2, 2, 2]. Then we do 4 steps, on each step we choose any element equals to 2. In total we earn 10 points.
Submitted Solution:
```
n = int(input())
dp = [0]*100001
arr =[0]*100001
l = list(map(int,input().split()))
for i in range(n):
arr[l[i]]+=l[i]
dp[0]=arr[0]
dp[1]=arr[1]
for i in range(2,100001):
if arr[i]+dp[i-2]>dp[i-1]:
dp[i]=arr[i]+dp[i-2]
else :
dp[i]=dp[i-1]
print(int(dp[100000]))
``` | instruction | 0 | 32,917 | 19 | 65,834 |
Yes | output | 1 | 32,917 | 19 | 65,835 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alex doesn't like boredom. That's why whenever he gets bored, he comes up with games. One long winter evening he came up with a game and decided to play it.
Given a sequence a consisting of n integers. The player can make several steps. In a single step he can choose an element of the sequence (let's denote it ak) and delete it, at that all elements equal to ak + 1 and ak - 1 also must be deleted from the sequence. That step brings ak points to the player.
Alex is a perfectionist, so he decided to get as many points as possible. Help him.
Input
The first line contains integer n (1 ≤ n ≤ 105) that shows how many numbers are in Alex's sequence.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105).
Output
Print a single integer — the maximum number of points that Alex can earn.
Examples
Input
2
1 2
Output
2
Input
3
1 2 3
Output
4
Input
9
1 2 1 3 2 2 2 2 3
Output
10
Note
Consider the third test example. At first step we need to choose any element equal to 2. After that step our sequence looks like this [2, 2, 2, 2]. Then we do 4 steps, on each step we choose any element equals to 2. In total we earn 10 points.
Submitted Solution:
```
input()
seq = sorted([int(i) for i in input().split()])
points, before, index = [0, 0], 0, 1
for i in range(len(seq)):
now = seq[i]
if now > before:
index = 1 - index
points[index] += now
before = now
print(max(points))
``` | instruction | 0 | 32,918 | 19 | 65,836 |
No | output | 1 | 32,918 | 19 | 65,837 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alex doesn't like boredom. That's why whenever he gets bored, he comes up with games. One long winter evening he came up with a game and decided to play it.
Given a sequence a consisting of n integers. The player can make several steps. In a single step he can choose an element of the sequence (let's denote it ak) and delete it, at that all elements equal to ak + 1 and ak - 1 also must be deleted from the sequence. That step brings ak points to the player.
Alex is a perfectionist, so he decided to get as many points as possible. Help him.
Input
The first line contains integer n (1 ≤ n ≤ 105) that shows how many numbers are in Alex's sequence.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105).
Output
Print a single integer — the maximum number of points that Alex can earn.
Examples
Input
2
1 2
Output
2
Input
3
1 2 3
Output
4
Input
9
1 2 1 3 2 2 2 2 3
Output
10
Note
Consider the third test example. At first step we need to choose any element equal to 2. After that step our sequence looks like this [2, 2, 2, 2]. Then we do 4 steps, on each step we choose any element equals to 2. In total we earn 10 points.
Submitted Solution:
```
d=[int(i) for i in input().split()]
a=b=0
for i in d:
a,b=max(a,i+b),a
print(a)
``` | instruction | 0 | 32,919 | 19 | 65,838 |
No | output | 1 | 32,919 | 19 | 65,839 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alex doesn't like boredom. That's why whenever he gets bored, he comes up with games. One long winter evening he came up with a game and decided to play it.
Given a sequence a consisting of n integers. The player can make several steps. In a single step he can choose an element of the sequence (let's denote it ak) and delete it, at that all elements equal to ak + 1 and ak - 1 also must be deleted from the sequence. That step brings ak points to the player.
Alex is a perfectionist, so he decided to get as many points as possible. Help him.
Input
The first line contains integer n (1 ≤ n ≤ 105) that shows how many numbers are in Alex's sequence.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105).
Output
Print a single integer — the maximum number of points that Alex can earn.
Examples
Input
2
1 2
Output
2
Input
3
1 2 3
Output
4
Input
9
1 2 1 3 2 2 2 2 3
Output
10
Note
Consider the third test example. At first step we need to choose any element equal to 2. After that step our sequence looks like this [2, 2, 2, 2]. Then we do 4 steps, on each step we choose any element equals to 2. In total we earn 10 points.
Submitted Solution:
```
from sys import stdin, stdout
input = stdin.readline
n = int(input())
a = list(map(int, input().split()))
dp = [0] * (10 ** 5 - 1)
for i in a:
dp[i - 1] += 1
m1 = m2 = 0
for i in range(n):
if i % 2 == 0:
m1 += (i + 1) * dp[i]
else:
m2 += (i + 1) * dp[i]
stdout.write(str(max(m1, m2)))
``` | instruction | 0 | 32,920 | 19 | 65,840 |
No | output | 1 | 32,920 | 19 | 65,841 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alex doesn't like boredom. That's why whenever he gets bored, he comes up with games. One long winter evening he came up with a game and decided to play it.
Given a sequence a consisting of n integers. The player can make several steps. In a single step he can choose an element of the sequence (let's denote it ak) and delete it, at that all elements equal to ak + 1 and ak - 1 also must be deleted from the sequence. That step brings ak points to the player.
Alex is a perfectionist, so he decided to get as many points as possible. Help him.
Input
The first line contains integer n (1 ≤ n ≤ 105) that shows how many numbers are in Alex's sequence.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105).
Output
Print a single integer — the maximum number of points that Alex can earn.
Examples
Input
2
1 2
Output
2
Input
3
1 2 3
Output
4
Input
9
1 2 1 3 2 2 2 2 3
Output
10
Note
Consider the third test example. At first step we need to choose any element equal to 2. After that step our sequence looks like this [2, 2, 2, 2]. Then we do 4 steps, on each step we choose any element equals to 2. In total we earn 10 points.
Submitted Solution:
```
n = int(input())
if n == 0:
print(0)
pass
items = [int(s) for s in input().split()]
dp = [0] * (n + 1)
dp[1] = items[0]
for i in range(2, n+1):
dp[i] = max(dp[i - 1], items[i - 1] + dp[i - 2])
print(dp[n])
``` | instruction | 0 | 32,921 | 19 | 65,842 |
No | output | 1 | 32,921 | 19 | 65,843 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's holiday. Mashmokh and his boss, Bimokh, are playing a game invented by Mashmokh.
In this game Mashmokh writes sequence of n distinct integers on the board. Then Bimokh makes several (possibly zero) moves. On the first move he removes the first and the second integer from from the board, on the second move he removes the first and the second integer of the remaining sequence from the board, and so on. Bimokh stops when the board contains less than two numbers. When Bimokh removes numbers x and y from the board, he gets gcd(x, y) points. At the beginning of the game Bimokh has zero points.
Mashmokh wants to win in the game. For this reason he wants his boss to get exactly k points in total. But the guy doesn't know how choose the initial sequence in the right way.
Please, help him. Find n distinct integers a1, a2, ..., an such that his boss will score exactly k points. Also Mashmokh can't memorize too huge numbers. Therefore each of these integers must be at most 109.
Input
The first line of input contains two space-separated integers n, k (1 ≤ n ≤ 105; 0 ≤ k ≤ 108).
Output
If such sequence doesn't exist output -1 otherwise output n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Examples
Input
5 2
Output
1 2 3 4 5
Input
5 3
Output
2 4 3 7 1
Input
7 2
Output
-1
Note
gcd(x, y) is greatest common divisor of x and y. | instruction | 0 | 33,720 | 19 | 67,440 |
Tags: constructive algorithms, number theory
Correct Solution:
```
"""
Codeforces Round 240 Div 1 Problem C
Author : chaotic_iak
Language: Python 3.3.4
"""
class InputHandlerObject(object):
inputs = []
def getInput(self, n = 0):
res = ""
inputs = self.inputs
if not inputs: inputs.extend(input().split(" "))
if n == 0:
res = inputs[:]
inputs[:] = []
while n > len(inputs):
inputs.extend(input().split(" "))
if n > 0:
res = inputs[:n]
inputs[:n] = []
return res
InputHandler = InputHandlerObject()
g = InputHandler.getInput
############################## SOLUTION ##############################
n,k = [int(x) for x in g()]
if k < n//2:
print(-1)
elif n == 1:
if k == 0:
print(1)
else:
print(-1)
else:
m = k+1-n//2
r = [m, 2*m]
if m < 10**6:
r += [10**7+i for i in range(n-2)]
else:
r += [1+i for i in range(n-2)]
print(" ".join(str(x) for x in r))
``` | output | 1 | 33,720 | 19 | 67,441 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's holiday. Mashmokh and his boss, Bimokh, are playing a game invented by Mashmokh.
In this game Mashmokh writes sequence of n distinct integers on the board. Then Bimokh makes several (possibly zero) moves. On the first move he removes the first and the second integer from from the board, on the second move he removes the first and the second integer of the remaining sequence from the board, and so on. Bimokh stops when the board contains less than two numbers. When Bimokh removes numbers x and y from the board, he gets gcd(x, y) points. At the beginning of the game Bimokh has zero points.
Mashmokh wants to win in the game. For this reason he wants his boss to get exactly k points in total. But the guy doesn't know how choose the initial sequence in the right way.
Please, help him. Find n distinct integers a1, a2, ..., an such that his boss will score exactly k points. Also Mashmokh can't memorize too huge numbers. Therefore each of these integers must be at most 109.
Input
The first line of input contains two space-separated integers n, k (1 ≤ n ≤ 105; 0 ≤ k ≤ 108).
Output
If such sequence doesn't exist output -1 otherwise output n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Examples
Input
5 2
Output
1 2 3 4 5
Input
5 3
Output
2 4 3 7 1
Input
7 2
Output
-1
Note
gcd(x, y) is greatest common divisor of x and y. | instruction | 0 | 33,721 | 19 | 67,442 |
Tags: constructive algorithms, number theory
Correct Solution:
```
n,k = [int(i) for i in input().split()]
if n==1 and k==0:
print(1)
elif n==1 and k>0:
print(-1)
elif k<n//2 :
print(-1)
elif n>=2:
if n%2==0:
m = n-2
summ = 0
st = 10**8
while(m>0):
print(st,end=' ')
st+=1
print(st,end=' ')
summ+=1
st+=1
m-=2
diff = k-summ
print(diff,diff*8)
else:
m= n-3
summ = 0
st = 10**8
while(m>0):
print(st,end=' ')
st+=1
print(st,end=' ')
summ+=1
st+=1
m-=2
diff = k-summ
print(diff,diff*8,end=' ')
print(diff*8+1)
``` | output | 1 | 33,721 | 19 | 67,443 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's holiday. Mashmokh and his boss, Bimokh, are playing a game invented by Mashmokh.
In this game Mashmokh writes sequence of n distinct integers on the board. Then Bimokh makes several (possibly zero) moves. On the first move he removes the first and the second integer from from the board, on the second move he removes the first and the second integer of the remaining sequence from the board, and so on. Bimokh stops when the board contains less than two numbers. When Bimokh removes numbers x and y from the board, he gets gcd(x, y) points. At the beginning of the game Bimokh has zero points.
Mashmokh wants to win in the game. For this reason he wants his boss to get exactly k points in total. But the guy doesn't know how choose the initial sequence in the right way.
Please, help him. Find n distinct integers a1, a2, ..., an such that his boss will score exactly k points. Also Mashmokh can't memorize too huge numbers. Therefore each of these integers must be at most 109.
Input
The first line of input contains two space-separated integers n, k (1 ≤ n ≤ 105; 0 ≤ k ≤ 108).
Output
If such sequence doesn't exist output -1 otherwise output n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Examples
Input
5 2
Output
1 2 3 4 5
Input
5 3
Output
2 4 3 7 1
Input
7 2
Output
-1
Note
gcd(x, y) is greatest common divisor of x and y. | instruction | 0 | 33,722 | 19 | 67,444 |
Tags: constructive algorithms, number theory
Correct Solution:
```
n, k = map(int, input().split())
ans = [(1000000000 - 2 * i, 1000000000 - 2 * i - 1) for i in range(n // 2 - 1)] + [(k - (n // 2 - 1), 2 * (k - (n // 2 - 1)))]
if k < n // 2 or k > 0 and n == 1:
print(-1)
else:
print(" ".join(["%d %d" % (ans[i][0], ans[i][1]) for i in range(n // 2)]) + (" 100500" if n % 2 == 1 else ""))
``` | output | 1 | 33,722 | 19 | 67,445 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's holiday. Mashmokh and his boss, Bimokh, are playing a game invented by Mashmokh.
In this game Mashmokh writes sequence of n distinct integers on the board. Then Bimokh makes several (possibly zero) moves. On the first move he removes the first and the second integer from from the board, on the second move he removes the first and the second integer of the remaining sequence from the board, and so on. Bimokh stops when the board contains less than two numbers. When Bimokh removes numbers x and y from the board, he gets gcd(x, y) points. At the beginning of the game Bimokh has zero points.
Mashmokh wants to win in the game. For this reason he wants his boss to get exactly k points in total. But the guy doesn't know how choose the initial sequence in the right way.
Please, help him. Find n distinct integers a1, a2, ..., an such that his boss will score exactly k points. Also Mashmokh can't memorize too huge numbers. Therefore each of these integers must be at most 109.
Input
The first line of input contains two space-separated integers n, k (1 ≤ n ≤ 105; 0 ≤ k ≤ 108).
Output
If such sequence doesn't exist output -1 otherwise output n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Examples
Input
5 2
Output
1 2 3 4 5
Input
5 3
Output
2 4 3 7 1
Input
7 2
Output
-1
Note
gcd(x, y) is greatest common divisor of x and y. | instruction | 0 | 33,723 | 19 | 67,446 |
Tags: constructive algorithms, number theory
Correct Solution:
```
n,k=map(int,input().split())
if n//2>k or (k!=0 and n==1):
print(-1)
exit(0)
ans=[0]*n
ans[0]=k-n//2+1
if n>1:
ans[1]=2*ans[0]
for i in range(2,n):
ans[i]=ans[i-1]+1
print(*ans)
``` | output | 1 | 33,723 | 19 | 67,447 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's holiday. Mashmokh and his boss, Bimokh, are playing a game invented by Mashmokh.
In this game Mashmokh writes sequence of n distinct integers on the board. Then Bimokh makes several (possibly zero) moves. On the first move he removes the first and the second integer from from the board, on the second move he removes the first and the second integer of the remaining sequence from the board, and so on. Bimokh stops when the board contains less than two numbers. When Bimokh removes numbers x and y from the board, he gets gcd(x, y) points. At the beginning of the game Bimokh has zero points.
Mashmokh wants to win in the game. For this reason he wants his boss to get exactly k points in total. But the guy doesn't know how choose the initial sequence in the right way.
Please, help him. Find n distinct integers a1, a2, ..., an such that his boss will score exactly k points. Also Mashmokh can't memorize too huge numbers. Therefore each of these integers must be at most 109.
Input
The first line of input contains two space-separated integers n, k (1 ≤ n ≤ 105; 0 ≤ k ≤ 108).
Output
If such sequence doesn't exist output -1 otherwise output n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Examples
Input
5 2
Output
1 2 3 4 5
Input
5 3
Output
2 4 3 7 1
Input
7 2
Output
-1
Note
gcd(x, y) is greatest common divisor of x and y. | instruction | 0 | 33,724 | 19 | 67,448 |
Tags: constructive algorithms, number theory
Correct Solution:
```
m,k = [int(x) for x in input().split()]
n = m
if m%2 == 1:n-=1
if m == 1:
if k == 0:print(1)
else : print(-1)
elif k < n//2 : print(-1)
else:
x = k - (n//2 - 1)
ans = [str(x),str(2*x)]
i = 1
while len(ans) < m:
if i not in [x,2*x]:ans.append(str(i))
i+=1
print(' '.join(ans))
``` | output | 1 | 33,724 | 19 | 67,449 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's holiday. Mashmokh and his boss, Bimokh, are playing a game invented by Mashmokh.
In this game Mashmokh writes sequence of n distinct integers on the board. Then Bimokh makes several (possibly zero) moves. On the first move he removes the first and the second integer from from the board, on the second move he removes the first and the second integer of the remaining sequence from the board, and so on. Bimokh stops when the board contains less than two numbers. When Bimokh removes numbers x and y from the board, he gets gcd(x, y) points. At the beginning of the game Bimokh has zero points.
Mashmokh wants to win in the game. For this reason he wants his boss to get exactly k points in total. But the guy doesn't know how choose the initial sequence in the right way.
Please, help him. Find n distinct integers a1, a2, ..., an such that his boss will score exactly k points. Also Mashmokh can't memorize too huge numbers. Therefore each of these integers must be at most 109.
Input
The first line of input contains two space-separated integers n, k (1 ≤ n ≤ 105; 0 ≤ k ≤ 108).
Output
If such sequence doesn't exist output -1 otherwise output n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Examples
Input
5 2
Output
1 2 3 4 5
Input
5 3
Output
2 4 3 7 1
Input
7 2
Output
-1
Note
gcd(x, y) is greatest common divisor of x and y. | instruction | 0 | 33,725 | 19 | 67,450 |
Tags: constructive algorithms, number theory
Correct Solution:
```
n, k = map(int, input().split())
if k == 0 and n == 1:
print(1)
elif n // 2 > k or n == 1:
print(-1)
else:
x = (k - n // 2 + 1)
print(x, x * 2, *range(x * 2 + 1, x * 2 + 1 + n - 2))
# Made By Mostafa_Khaled
``` | output | 1 | 33,725 | 19 | 67,451 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's holiday. Mashmokh and his boss, Bimokh, are playing a game invented by Mashmokh.
In this game Mashmokh writes sequence of n distinct integers on the board. Then Bimokh makes several (possibly zero) moves. On the first move he removes the first and the second integer from from the board, on the second move he removes the first and the second integer of the remaining sequence from the board, and so on. Bimokh stops when the board contains less than two numbers. When Bimokh removes numbers x and y from the board, he gets gcd(x, y) points. At the beginning of the game Bimokh has zero points.
Mashmokh wants to win in the game. For this reason he wants his boss to get exactly k points in total. But the guy doesn't know how choose the initial sequence in the right way.
Please, help him. Find n distinct integers a1, a2, ..., an such that his boss will score exactly k points. Also Mashmokh can't memorize too huge numbers. Therefore each of these integers must be at most 109.
Input
The first line of input contains two space-separated integers n, k (1 ≤ n ≤ 105; 0 ≤ k ≤ 108).
Output
If such sequence doesn't exist output -1 otherwise output n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Examples
Input
5 2
Output
1 2 3 4 5
Input
5 3
Output
2 4 3 7 1
Input
7 2
Output
-1
Note
gcd(x, y) is greatest common divisor of x and y. | instruction | 0 | 33,726 | 19 | 67,452 |
Tags: constructive algorithms, number theory
Correct Solution:
```
n, k = tuple(map(int, input().split()))
if n % 2:
pairs = (n - 1) // 2
else:
pairs = n // 2
if (pairs > k) or (not pairs and k > 0):
print(-1)
else:
if pairs < k:
answer = [k - pairs + 1]
answer.append(answer[0] * 2)
answer += [i for i in range(answer[1] + 1, answer[1] + n - 1)]
else:
answer = [i for i in range(1, n + 1)]
print(' '.join(map(str, answer)))
``` | output | 1 | 33,726 | 19 | 67,453 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's holiday. Mashmokh and his boss, Bimokh, are playing a game invented by Mashmokh.
In this game Mashmokh writes sequence of n distinct integers on the board. Then Bimokh makes several (possibly zero) moves. On the first move he removes the first and the second integer from from the board, on the second move he removes the first and the second integer of the remaining sequence from the board, and so on. Bimokh stops when the board contains less than two numbers. When Bimokh removes numbers x and y from the board, he gets gcd(x, y) points. At the beginning of the game Bimokh has zero points.
Mashmokh wants to win in the game. For this reason he wants his boss to get exactly k points in total. But the guy doesn't know how choose the initial sequence in the right way.
Please, help him. Find n distinct integers a1, a2, ..., an such that his boss will score exactly k points. Also Mashmokh can't memorize too huge numbers. Therefore each of these integers must be at most 109.
Input
The first line of input contains two space-separated integers n, k (1 ≤ n ≤ 105; 0 ≤ k ≤ 108).
Output
If such sequence doesn't exist output -1 otherwise output n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Examples
Input
5 2
Output
1 2 3 4 5
Input
5 3
Output
2 4 3 7 1
Input
7 2
Output
-1
Note
gcd(x, y) is greatest common divisor of x and y. | instruction | 0 | 33,727 | 19 | 67,454 |
Tags: constructive algorithms, number theory
Correct Solution:
```
n, k = list(map(int, input().split()))
if k == 0 and n == 1:
print(777, end=' ')
elif n//2 > k or n == 1:
print(-1)
exit()
else:
real = k - (n-2)//2
k -= real
print(real*2, real, end=' ')
# print(k)
r = real*2+10
while k > 0:
print(r, r+1, end=' ')
k -= 1
r += 2
if n % 2 == 1:
print(999999999, end=' ')
print()
``` | output | 1 | 33,727 | 19 | 67,455 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's holiday. Mashmokh and his boss, Bimokh, are playing a game invented by Mashmokh.
In this game Mashmokh writes sequence of n distinct integers on the board. Then Bimokh makes several (possibly zero) moves. On the first move he removes the first and the second integer from from the board, on the second move he removes the first and the second integer of the remaining sequence from the board, and so on. Bimokh stops when the board contains less than two numbers. When Bimokh removes numbers x and y from the board, he gets gcd(x, y) points. At the beginning of the game Bimokh has zero points.
Mashmokh wants to win in the game. For this reason he wants his boss to get exactly k points in total. But the guy doesn't know how choose the initial sequence in the right way.
Please, help him. Find n distinct integers a1, a2, ..., an such that his boss will score exactly k points. Also Mashmokh can't memorize too huge numbers. Therefore each of these integers must be at most 109.
Input
The first line of input contains two space-separated integers n, k (1 ≤ n ≤ 105; 0 ≤ k ≤ 108).
Output
If such sequence doesn't exist output -1 otherwise output n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Examples
Input
5 2
Output
1 2 3 4 5
Input
5 3
Output
2 4 3 7 1
Input
7 2
Output
-1
Note
gcd(x, y) is greatest common divisor of x and y.
Submitted Solution:
```
def numbers(n, k):
if k == 0 and n == 1:
return [1]
if n == 1 or k < n // 2:
return [-1]
result, t = list(), k - (n - 2) // 2
result.append(t)
result.append(2 * t)
for i in range(n - 2):
result.append(2 * t + i + 1)
return result
N, K = [int(j) for j in input().split()]
print(*numbers(N, K))
``` | instruction | 0 | 33,728 | 19 | 67,456 |
Yes | output | 1 | 33,728 | 19 | 67,457 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's holiday. Mashmokh and his boss, Bimokh, are playing a game invented by Mashmokh.
In this game Mashmokh writes sequence of n distinct integers on the board. Then Bimokh makes several (possibly zero) moves. On the first move he removes the first and the second integer from from the board, on the second move he removes the first and the second integer of the remaining sequence from the board, and so on. Bimokh stops when the board contains less than two numbers. When Bimokh removes numbers x and y from the board, he gets gcd(x, y) points. At the beginning of the game Bimokh has zero points.
Mashmokh wants to win in the game. For this reason he wants his boss to get exactly k points in total. But the guy doesn't know how choose the initial sequence in the right way.
Please, help him. Find n distinct integers a1, a2, ..., an such that his boss will score exactly k points. Also Mashmokh can't memorize too huge numbers. Therefore each of these integers must be at most 109.
Input
The first line of input contains two space-separated integers n, k (1 ≤ n ≤ 105; 0 ≤ k ≤ 108).
Output
If such sequence doesn't exist output -1 otherwise output n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Examples
Input
5 2
Output
1 2 3 4 5
Input
5 3
Output
2 4 3 7 1
Input
7 2
Output
-1
Note
gcd(x, y) is greatest common divisor of x and y.
Submitted Solution:
```
n, k = map(int, input().split())
if n // 2 > k:
print(-1)
elif n == 1 and k != 0:
print(-1)
elif n == 1 and k == 0:
print(1)
else:
a = n // 2 - 1
for i in range(1, a + 1):
print(2 * i - 1, 2 * i, end=' ')
print((k - a) * 3 + 4 * a - (4 * a) % (k - a), 4 * a - (4 * a) % (k - a) + (k - a) * 4, end=' ')
if n % 2:
print(998244353)
``` | instruction | 0 | 33,729 | 19 | 67,458 |
Yes | output | 1 | 33,729 | 19 | 67,459 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's holiday. Mashmokh and his boss, Bimokh, are playing a game invented by Mashmokh.
In this game Mashmokh writes sequence of n distinct integers on the board. Then Bimokh makes several (possibly zero) moves. On the first move he removes the first and the second integer from from the board, on the second move he removes the first and the second integer of the remaining sequence from the board, and so on. Bimokh stops when the board contains less than two numbers. When Bimokh removes numbers x and y from the board, he gets gcd(x, y) points. At the beginning of the game Bimokh has zero points.
Mashmokh wants to win in the game. For this reason he wants his boss to get exactly k points in total. But the guy doesn't know how choose the initial sequence in the right way.
Please, help him. Find n distinct integers a1, a2, ..., an such that his boss will score exactly k points. Also Mashmokh can't memorize too huge numbers. Therefore each of these integers must be at most 109.
Input
The first line of input contains two space-separated integers n, k (1 ≤ n ≤ 105; 0 ≤ k ≤ 108).
Output
If such sequence doesn't exist output -1 otherwise output n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Examples
Input
5 2
Output
1 2 3 4 5
Input
5 3
Output
2 4 3 7 1
Input
7 2
Output
-1
Note
gcd(x, y) is greatest common divisor of x and y.
Submitted Solution:
```
n, k = map(int, input().split())
if n % 2:
pairs = (n-1)//2
else:
pairs = n//2
if pairs > k or (not pairs and k > 0):
print(-1)
else:
if pairs < k:
answer = [k-pairs+1, (k-pairs+1)*2]
answer += [i for i in range(answer[1]+1, answer[1]+n-1)]
else:
answer = [i for i in range(1, n+1)]
print(' '.join(map(str, answer)))
``` | instruction | 0 | 33,730 | 19 | 67,460 |
Yes | output | 1 | 33,730 | 19 | 67,461 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's holiday. Mashmokh and his boss, Bimokh, are playing a game invented by Mashmokh.
In this game Mashmokh writes sequence of n distinct integers on the board. Then Bimokh makes several (possibly zero) moves. On the first move he removes the first and the second integer from from the board, on the second move he removes the first and the second integer of the remaining sequence from the board, and so on. Bimokh stops when the board contains less than two numbers. When Bimokh removes numbers x and y from the board, he gets gcd(x, y) points. At the beginning of the game Bimokh has zero points.
Mashmokh wants to win in the game. For this reason he wants his boss to get exactly k points in total. But the guy doesn't know how choose the initial sequence in the right way.
Please, help him. Find n distinct integers a1, a2, ..., an such that his boss will score exactly k points. Also Mashmokh can't memorize too huge numbers. Therefore each of these integers must be at most 109.
Input
The first line of input contains two space-separated integers n, k (1 ≤ n ≤ 105; 0 ≤ k ≤ 108).
Output
If such sequence doesn't exist output -1 otherwise output n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Examples
Input
5 2
Output
1 2 3 4 5
Input
5 3
Output
2 4 3 7 1
Input
7 2
Output
-1
Note
gcd(x, y) is greatest common divisor of x and y.
Submitted Solution:
```
n,k=map(int,input().split())
ans=[]
if n==1:
if k==0:
print(1)
else:
print(-1)
elif (k<n//2):
print(-1)
else:
ans.append(k+1-n//2)
ans.append(2*ans[0])
for i in range(2,n):
ans.append(ans[-1]+1)
print(*ans)
``` | instruction | 0 | 33,731 | 19 | 67,462 |
Yes | output | 1 | 33,731 | 19 | 67,463 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's holiday. Mashmokh and his boss, Bimokh, are playing a game invented by Mashmokh.
In this game Mashmokh writes sequence of n distinct integers on the board. Then Bimokh makes several (possibly zero) moves. On the first move he removes the first and the second integer from from the board, on the second move he removes the first and the second integer of the remaining sequence from the board, and so on. Bimokh stops when the board contains less than two numbers. When Bimokh removes numbers x and y from the board, he gets gcd(x, y) points. At the beginning of the game Bimokh has zero points.
Mashmokh wants to win in the game. For this reason he wants his boss to get exactly k points in total. But the guy doesn't know how choose the initial sequence in the right way.
Please, help him. Find n distinct integers a1, a2, ..., an such that his boss will score exactly k points. Also Mashmokh can't memorize too huge numbers. Therefore each of these integers must be at most 109.
Input
The first line of input contains two space-separated integers n, k (1 ≤ n ≤ 105; 0 ≤ k ≤ 108).
Output
If such sequence doesn't exist output -1 otherwise output n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Examples
Input
5 2
Output
1 2 3 4 5
Input
5 3
Output
2 4 3 7 1
Input
7 2
Output
-1
Note
gcd(x, y) is greatest common divisor of x and y.
Submitted Solution:
```
n, k = map(int, input().split())
if n // 2 > k:
print(-1)
else:
ext = k - (n // 2) + 1
ans = [ext, 2 * ext]
n -= 2
for i in range(1, 100001, 2):
if n <= 1:
break
if i not in ans and i + 1 not in ans:
print(i, i + 1, end=' ')
n -= 2
print(*ans, end=' ')
if n & 1:
print(1000000000)
``` | instruction | 0 | 33,732 | 19 | 67,464 |
No | output | 1 | 33,732 | 19 | 67,465 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's holiday. Mashmokh and his boss, Bimokh, are playing a game invented by Mashmokh.
In this game Mashmokh writes sequence of n distinct integers on the board. Then Bimokh makes several (possibly zero) moves. On the first move he removes the first and the second integer from from the board, on the second move he removes the first and the second integer of the remaining sequence from the board, and so on. Bimokh stops when the board contains less than two numbers. When Bimokh removes numbers x and y from the board, he gets gcd(x, y) points. At the beginning of the game Bimokh has zero points.
Mashmokh wants to win in the game. For this reason he wants his boss to get exactly k points in total. But the guy doesn't know how choose the initial sequence in the right way.
Please, help him. Find n distinct integers a1, a2, ..., an such that his boss will score exactly k points. Also Mashmokh can't memorize too huge numbers. Therefore each of these integers must be at most 109.
Input
The first line of input contains two space-separated integers n, k (1 ≤ n ≤ 105; 0 ≤ k ≤ 108).
Output
If such sequence doesn't exist output -1 otherwise output n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Examples
Input
5 2
Output
1 2 3 4 5
Input
5 3
Output
2 4 3 7 1
Input
7 2
Output
-1
Note
gcd(x, y) is greatest common divisor of x and y.
Submitted Solution:
```
n, k = list(map(int, input().split()))
if n//2 > k or n == 1:
print(-1)
exit()
else:
real = k - (n-2)//2
k -= real
print(real*2, real, end=' ')
# print(k)
r = real*2+10
while k > 0:
print(r, r+1, end=' ')
k -= 1
r += 2
if n % 2 == 1:
print(999999999, end=' ')
print()
``` | instruction | 0 | 33,733 | 19 | 67,466 |
No | output | 1 | 33,733 | 19 | 67,467 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's holiday. Mashmokh and his boss, Bimokh, are playing a game invented by Mashmokh.
In this game Mashmokh writes sequence of n distinct integers on the board. Then Bimokh makes several (possibly zero) moves. On the first move he removes the first and the second integer from from the board, on the second move he removes the first and the second integer of the remaining sequence from the board, and so on. Bimokh stops when the board contains less than two numbers. When Bimokh removes numbers x and y from the board, he gets gcd(x, y) points. At the beginning of the game Bimokh has zero points.
Mashmokh wants to win in the game. For this reason he wants his boss to get exactly k points in total. But the guy doesn't know how choose the initial sequence in the right way.
Please, help him. Find n distinct integers a1, a2, ..., an such that his boss will score exactly k points. Also Mashmokh can't memorize too huge numbers. Therefore each of these integers must be at most 109.
Input
The first line of input contains two space-separated integers n, k (1 ≤ n ≤ 105; 0 ≤ k ≤ 108).
Output
If such sequence doesn't exist output -1 otherwise output n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Examples
Input
5 2
Output
1 2 3 4 5
Input
5 3
Output
2 4 3 7 1
Input
7 2
Output
-1
Note
gcd(x, y) is greatest common divisor of x and y.
Submitted Solution:
```
n,k = [int(i) for i in input().split()]
if n==1 and k==0:
print(1)
elif n==1 and k>0:
print(-1)
elif k<n//2 :
print(-1)
elif n>=2:
if n%2==0:
m = n-2
summ = 0
st = 10**8
while(m>0):
print(st,end=' ')
st+=1
print(st,end=' ')
summ+=1
st+=1
m-=2
diff = k-summ
print(diff,diff*8)
else:
m= n-3
summ = 0
st = 10**8
while(m>0):
print(st,end=' ')
st+=1
print(st,end=' ')
summ+=1
st+=1
m-=2
diff = k-summ
print(diff,diff*8,end=' ')
print(diff+1)
``` | instruction | 0 | 33,734 | 19 | 67,468 |
No | output | 1 | 33,734 | 19 | 67,469 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's holiday. Mashmokh and his boss, Bimokh, are playing a game invented by Mashmokh.
In this game Mashmokh writes sequence of n distinct integers on the board. Then Bimokh makes several (possibly zero) moves. On the first move he removes the first and the second integer from from the board, on the second move he removes the first and the second integer of the remaining sequence from the board, and so on. Bimokh stops when the board contains less than two numbers. When Bimokh removes numbers x and y from the board, he gets gcd(x, y) points. At the beginning of the game Bimokh has zero points.
Mashmokh wants to win in the game. For this reason he wants his boss to get exactly k points in total. But the guy doesn't know how choose the initial sequence in the right way.
Please, help him. Find n distinct integers a1, a2, ..., an such that his boss will score exactly k points. Also Mashmokh can't memorize too huge numbers. Therefore each of these integers must be at most 109.
Input
The first line of input contains two space-separated integers n, k (1 ≤ n ≤ 105; 0 ≤ k ≤ 108).
Output
If such sequence doesn't exist output -1 otherwise output n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Examples
Input
5 2
Output
1 2 3 4 5
Input
5 3
Output
2 4 3 7 1
Input
7 2
Output
-1
Note
gcd(x, y) is greatest common divisor of x and y.
Submitted Solution:
```
n, k = tuple(map(int, input().split()))
if n % 2:
pairs = (n - 1) // 2
else:
pairs = n // 2
if (pairs > k) or (not pairs and k > 0):
print(-1)
else:
answer = [i for i in range(1, n + 1)]
if pairs < k:
if n % 2:
answer[-3] = k - pairs + 2
answer[-2] = answer[-3] * 2
else:
answer[-2] = k - pairs + 2
answer[-1] = answer[-2] * 2
print(' '.join(map(str, answer)))
``` | instruction | 0 | 33,735 | 19 | 67,470 |
No | output | 1 | 33,735 | 19 | 67,471 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Have you ever played Hanabi? If not, then you've got to try it out! This problem deals with a simplified version of the game.
Overall, the game has 25 types of cards (5 distinct colors and 5 distinct values). Borya is holding n cards. The game is somewhat complicated by the fact that everybody sees Borya's cards except for Borya himself. Borya knows which cards he has but he knows nothing about the order they lie in. Note that Borya can have multiple identical cards (and for each of the 25 types of cards he knows exactly how many cards of this type he has).
The aim of the other players is to achieve the state when Borya knows the color and number value of each of his cards. For that, other players can give him hints. The hints can be of two types: color hints and value hints.
A color hint goes like that: a player names some color and points at all the cards of this color.
Similarly goes the value hint. A player names some value and points at all the cards that contain the value.
Determine what minimum number of hints the other players should make for Borya to be certain about each card's color and value.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of Borya's cards. The next line contains the descriptions of n cards. The description of each card consists of exactly two characters. The first character shows the color (overall this position can contain five distinct letters — R, G, B, Y, W). The second character shows the card's value (a digit from 1 to 5). Borya doesn't know exact order of the cards they lie in.
Output
Print a single integer — the minimum number of hints that the other players should make.
Examples
Input
2
G3 G3
Output
0
Input
4
G4 R4 R3 B3
Output
2
Input
5
B1 Y1 W1 G1 R1
Output
4
Note
In the first sample Borya already knows for each card that it is a green three.
In the second sample we can show all fours and all red cards.
In the third sample you need to make hints about any four colors. | instruction | 0 | 33,736 | 19 | 67,472 |
Tags: bitmasks, brute force, implementation
Correct Solution:
```
from itertools import combinations
from copy import copy
def variants(a):
for i in range(6):
for j in combinations(a, i):
yield j
def main():
input()
cards = set((i[0], int(i[1])) for i in input().split())
values = [0 for i in range(6)]
masks = {i: 0 for i in "RGBYW"}
for i in cards:
values[i[1]] += 1
masks[i[0]] += 1
result = float("inf")
for i in variants("RGBYW"):
for j in variants(list(range(1, 6))):
c = copy(cards)
v, m = values[:], copy(masks)
for k in copy(c):
if k[0] in i and k[1] in j:
v[k[1]] -= 1
m[k[0]] -= 1
c.remove(k)
for l in range(11):
for k in copy(c):
if (v[k[1]] == 1 and k[1] in j or
m[k[0]] == 1 and k[0] in i):
v[k[1]] -= 1
m[k[0]] -= 1
c.remove(k)
if len(c) <= 1:
result = min(result, len(i) + len(j))
print(result)
main()
``` | output | 1 | 33,736 | 19 | 67,473 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Have you ever played Hanabi? If not, then you've got to try it out! This problem deals with a simplified version of the game.
Overall, the game has 25 types of cards (5 distinct colors and 5 distinct values). Borya is holding n cards. The game is somewhat complicated by the fact that everybody sees Borya's cards except for Borya himself. Borya knows which cards he has but he knows nothing about the order they lie in. Note that Borya can have multiple identical cards (and for each of the 25 types of cards he knows exactly how many cards of this type he has).
The aim of the other players is to achieve the state when Borya knows the color and number value of each of his cards. For that, other players can give him hints. The hints can be of two types: color hints and value hints.
A color hint goes like that: a player names some color and points at all the cards of this color.
Similarly goes the value hint. A player names some value and points at all the cards that contain the value.
Determine what minimum number of hints the other players should make for Borya to be certain about each card's color and value.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of Borya's cards. The next line contains the descriptions of n cards. The description of each card consists of exactly two characters. The first character shows the color (overall this position can contain five distinct letters — R, G, B, Y, W). The second character shows the card's value (a digit from 1 to 5). Borya doesn't know exact order of the cards they lie in.
Output
Print a single integer — the minimum number of hints that the other players should make.
Examples
Input
2
G3 G3
Output
0
Input
4
G4 R4 R3 B3
Output
2
Input
5
B1 Y1 W1 G1 R1
Output
4
Note
In the first sample Borya already knows for each card that it is a green three.
In the second sample we can show all fours and all red cards.
In the third sample you need to make hints about any four colors. | instruction | 0 | 33,737 | 19 | 67,474 |
Tags: bitmasks, brute force, implementation
Correct Solution:
```
"""
Codeforces Round 253 Div 1 Problem A
Author : chaotic_iak
Language: Python 3.3.4
"""
def read(mode=2):
# 0: String
# 1: List of strings
# 2: List of integers
inputs = input().strip()
if mode == 0:
return inputs
if mode == 1:
return inputs.split()
if mode == 2:
return [int(x) for x in inputs.split()]
def write(s="\n"):
if isinstance(s, list): s = " ".join(map(str,s))
s = str(s)
print(s, end="")
################################################### SOLUTION
import itertools
covers = itertools.product([0,1], repeat=10)
n, = read()
s = read(1)
a = [0] * 25
colors = "RGBYW"
for i in s:
a[colors.index(i[0]) * 5 + int(i[1])-1] |= 1
def check(cover):
global a
unknowns = [0] * 11
for i in range(25):
if not a[i]: continue
id = -1
if not cover[i%5]: id = 5+i//5
if not cover[5+i//5]:
if id == -1:
id = i%5
else:
id = 10
if id > -1:
if unknowns[id]: return False
unknowns[id] = 1
return True
mn = 99
for i in covers:
if check(i):
mn = min(mn, sum(i))
print(mn)
``` | output | 1 | 33,737 | 19 | 67,475 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Have you ever played Hanabi? If not, then you've got to try it out! This problem deals with a simplified version of the game.
Overall, the game has 25 types of cards (5 distinct colors and 5 distinct values). Borya is holding n cards. The game is somewhat complicated by the fact that everybody sees Borya's cards except for Borya himself. Borya knows which cards he has but he knows nothing about the order they lie in. Note that Borya can have multiple identical cards (and for each of the 25 types of cards he knows exactly how many cards of this type he has).
The aim of the other players is to achieve the state when Borya knows the color and number value of each of his cards. For that, other players can give him hints. The hints can be of two types: color hints and value hints.
A color hint goes like that: a player names some color and points at all the cards of this color.
Similarly goes the value hint. A player names some value and points at all the cards that contain the value.
Determine what minimum number of hints the other players should make for Borya to be certain about each card's color and value.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of Borya's cards. The next line contains the descriptions of n cards. The description of each card consists of exactly two characters. The first character shows the color (overall this position can contain five distinct letters — R, G, B, Y, W). The second character shows the card's value (a digit from 1 to 5). Borya doesn't know exact order of the cards they lie in.
Output
Print a single integer — the minimum number of hints that the other players should make.
Examples
Input
2
G3 G3
Output
0
Input
4
G4 R4 R3 B3
Output
2
Input
5
B1 Y1 W1 G1 R1
Output
4
Note
In the first sample Borya already knows for each card that it is a green three.
In the second sample we can show all fours and all red cards.
In the third sample you need to make hints about any four colors. | instruction | 0 | 33,738 | 19 | 67,476 |
Tags: bitmasks, brute force, implementation
Correct Solution:
```
#!/usr/bin/python3
import sys
n = int(sys.stdin.readline())
cards = list(set(sys.stdin.readline().split()))
m = 10 # Minimal number of hints
def count_ones(n):
cnt = 0
while n > 0:
if n & 1:
cnt += 1
n //= 2
return cnt
def split(l, c):
a, b = [], []
for card in l:
if c in card:
a.append(card)
else:
b.append(card)
return a, b
def is_clear(cards, h):
cl = [cards]
namig = 'RGBYW12345'
for i in range(10):
hint = (h & 1) == 1
h //= 2
if not hint: continue
cl2 = []
for c in cl:
a, b = split(c, namig[i])
if len(a) >= 2:
cl2.append(a)
if len(b) >= 2:
cl2.append(b)
cl = cl2
# print(cl)
cl = [x for x in cl if len(x) >= 2]
return len(cl) == 0
for h in range(2**10):
hints = count_ones(h)
if is_clear(cards, h):
m = min(m, hints)
print(m)
``` | output | 1 | 33,738 | 19 | 67,477 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Have you ever played Hanabi? If not, then you've got to try it out! This problem deals with a simplified version of the game.
Overall, the game has 25 types of cards (5 distinct colors and 5 distinct values). Borya is holding n cards. The game is somewhat complicated by the fact that everybody sees Borya's cards except for Borya himself. Borya knows which cards he has but he knows nothing about the order they lie in. Note that Borya can have multiple identical cards (and for each of the 25 types of cards he knows exactly how many cards of this type he has).
The aim of the other players is to achieve the state when Borya knows the color and number value of each of his cards. For that, other players can give him hints. The hints can be of two types: color hints and value hints.
A color hint goes like that: a player names some color and points at all the cards of this color.
Similarly goes the value hint. A player names some value and points at all the cards that contain the value.
Determine what minimum number of hints the other players should make for Borya to be certain about each card's color and value.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of Borya's cards. The next line contains the descriptions of n cards. The description of each card consists of exactly two characters. The first character shows the color (overall this position can contain five distinct letters — R, G, B, Y, W). The second character shows the card's value (a digit from 1 to 5). Borya doesn't know exact order of the cards they lie in.
Output
Print a single integer — the minimum number of hints that the other players should make.
Examples
Input
2
G3 G3
Output
0
Input
4
G4 R4 R3 B3
Output
2
Input
5
B1 Y1 W1 G1 R1
Output
4
Note
In the first sample Borya already knows for each card that it is a green three.
In the second sample we can show all fours and all red cards.
In the third sample you need to make hints about any four colors. | instruction | 0 | 33,739 | 19 | 67,478 |
Tags: bitmasks, brute force, implementation
Correct Solution:
```
n = int(input())
data = set(input().split())
temp = 'RGBYW'
c = []
res = 10
for i in data:
p1 = temp.find(i[0])
p2 = int(i[1]) - 1
c.append(2 ** p1 + 2 ** (p2 + 5))
for i in range(1024):
ok = True
for j in range(len(c) - 1):
for k in range(j + 1, len(c)):
if (c[j] & i) == (c[k] & i):
ok = False
if ok:
tt = 0
inow = i
while inow != 0:
tt += inow % 2
inow //= 2
res = min(res, tt)
print(res)
``` | output | 1 | 33,739 | 19 | 67,479 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.