text
stringlengths 198
433k
| conversation_id
int64 0
109k
|
|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Little Girl loves problems on games very much. Here's one of them.
Two players have got a string s, consisting of lowercase English letters. They play a game that is described by the following rules:
* The players move in turns; In one move the player can remove an arbitrary letter from string s.
* If the player before his turn can reorder the letters in string s so as to get a palindrome, this player wins. A palindrome is a string that reads the same both ways (from left to right, and vice versa). For example, string "abba" is a palindrome and string "abc" isn't.
Determine which player will win, provided that both sides play optimally well β the one who moves first or the one who moves second.
Input
The input contains a single line, containing string s (1 β€ |s| β€ 103). String s consists of lowercase English letters.
Output
In a single line print word "First" if the first player wins (provided that both players play optimally well). Otherwise, print word "Second". Print the words without the quotes.
Examples
Input
aba
Output
First
Input
abca
Output
Second
Submitted Solution:
```
from collections import defaultdict
s = [i for i in input()]
d = defaultdict(int)
for i in s:
d[i] += 1
ar = [v for k,v in d.items() if v%2]
ar.sort()
if sum(ar)%2:
print("First")
else:
print("Second")
```
No
| 300
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Little Girl loves problems on games very much. Here's one of them.
Two players have got a string s, consisting of lowercase English letters. They play a game that is described by the following rules:
* The players move in turns; In one move the player can remove an arbitrary letter from string s.
* If the player before his turn can reorder the letters in string s so as to get a palindrome, this player wins. A palindrome is a string that reads the same both ways (from left to right, and vice versa). For example, string "abba" is a palindrome and string "abc" isn't.
Determine which player will win, provided that both sides play optimally well β the one who moves first or the one who moves second.
Input
The input contains a single line, containing string s (1 β€ |s| β€ 103). String s consists of lowercase English letters.
Output
In a single line print word "First" if the first player wins (provided that both players play optimally well). Otherwise, print word "Second". Print the words without the quotes.
Examples
Input
aba
Output
First
Input
abca
Output
Second
Submitted Solution:
```
from sys import stdin, stdout
from sys import maxsize
input = stdin.readline
#def print(n):
# stdout.write(str(n)+'\n')
def solve():
pass
test = 1
# test = int(input().strip())
for t in range(0, test):
# n = int(input().strip())
s = input().strip() # String Input, converted to mutable list.
if(s==s[::-1]):
print('First')
else:
if(len(s)%2==0):
print('Second')
else:
print('First')
# n, k = list(map(int, input().strip().split()))
# arr = [int(x) for x in input().strip().split()]
# brr = [list(map(int,input().strip().split())) for i in range(rows)] # 2D array row-wise input
ans = solve()
'''
rows, cols = (5, 5)
arr = [[0]*cols for j in range(rows)] # 2D array initialization
rev_str=s[::-1] # To reverse given string
b=input().strip().split() # list created by spliting about spaces
ch = chr(ord(ch) + 1) # To increment character by one in ASCII
brr = [[int(b[cols*i+j]) for j in range(cols)] for i in range(rows)] # 2D array Linear Input
rows,cols=len(brr),len(brr[0]) # no of rows/cols for 2D array
arr.sort(key = lambda x : x[1]) # sort list of tuples by 2nd element, Default priority - 1st Element then 2nd Element
s=set() # empty set
a=maxsize # initializing infinity
b=-maxsize # initializing -infinity
mapped=list(map(function,input)) # to apply function to list element-wise
try: # Error handling
#code 1
except: # ex. to stop at EOF
#code 2 , if error occurs
'''
```
No
| 301
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 β€ r, g, b β€ 109) β the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
Tags: combinatorics, math
Correct Solution:
```
a,b,c=map(int,input().split())
x=a//3+b//3+c//3+min(a%3,b%3,c%3)
y=min(a,b,c)
if ((a-y+1)%3==0 and ((b-y+1)%3==0) and c!=0)or ((a-y+1)%3==0 and (c-y+1)%3==0 and b!=0) or ((b-y+1)%3==0 and (c-y+1)%3==0 and a!=0):
a-=(y-1)
b-=(y-1)
c-=(y-1)
#print(a,b,c)
y+=(-1+(a//3+b//3+c//3))
else:
a-=y
b-=y
c-=y
y+=(a//3+b//3+c//3)
print(max(y,x))
#print(y)
```
| 302
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 β€ r, g, b β€ 109) β the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
Tags: combinatorics, math
Correct Solution:
```
def ciel_flowers(a,b,c):
red=a//3
green=b//3
blue=c//3
total=red+green+blue
remain=[a%3 , b%3 , c%3]
ideal=[0,2,2]
if sorted(remain)==ideal and 0 not in [a,b,c]:
print(total+1)
else:
print(total+min(remain))
a,b,c=list(map(int,input().split()))
ciel_flowers(a,b,c)
```
| 303
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 β€ r, g, b β€ 109) β the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
Tags: combinatorics, math
Correct Solution:
```
r,g,b = map(int,input().split())
print (max(i+(r-i)//3+(g-i)//3+(b-i)//3 for i in range(min(r+1,g+1,b+1,3))))
# Made By Mostafa_Khaled
```
| 304
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 β€ r, g, b β€ 109) β the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
Tags: combinatorics, math
Correct Solution:
```
r,g,b = map(int, input().split())
ans = r//3 + g//3 + b//3
y = (r-1)//3 + (g-1)//3 + (b-1)//3
if r > 0 and g > 0 and b > 0:
ans = max(ans, (r-1)//3 + (g-1)//3 + (b-1)//3 + 1)
if r > 1 and g > 1 and b > 1:
ans = max(ans, (r-2)//3 + (g-2)//3 + (b-2)//3 + 2)
print(ans)
```
| 305
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 β€ r, g, b β€ 109) β the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
Tags: combinatorics, math
Correct Solution:
```
r,g,b=map(int,input().split())
k=min(r,g,b)
t1=(r//3)+(g//3)+(b//3)+min(r%3,g%3,b%3)
t2=(r//3)+(g//3)
p=min(r%3,g%3,b)
t2=t2+p+(b-p)//3
t3=(r//3)+(b//3)
p=min(r%3,b%3,g)
t3=t3+p+(g-p)//3
t4=(b//3)+(g//3)
p=min(b%3,g%3,r)
t4=t4+p+(r-p)//3
t5=(r//3)
p=min(r%3,g,b)
t5=t5+p+(g-p)//3+(b-p)//3
t6=(g//3)
p=min(g%3,r,b)
t6=t6+p+(r-p)//3+(b-p)//3
t7=(b//3)
p=min(b%3,r,g)
t7=t7+p+(g-p)//3+(r-p)//3
t8=min(r,g,b)+(r-k)//3+(b-k)//3+(g-k)//3
print(max(t1,t2,t3,t4,t5,t6,t7,t8))
```
| 306
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 β€ r, g, b β€ 109) β the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
Tags: combinatorics, math
Correct Solution:
```
dados = input().split()
flowers = [int(dados[0]), int(dados[1]), int(dados[2])]
buques = 0
buques = flowers[0] // 3 + flowers[1] // 3 + flowers[2] // 3
if (flowers[0] and flowers[1] and flowers[2]) > 0:
buques = max(buques, 1+(flowers[0] - 1) // 3 + (flowers[1] - 1) // 3 + (flowers[2] - 1) // 3)
buques = max(buques, 2+(flowers[0] - 2) // 3 + (flowers[1] - 2) // 3 + (flowers[2] - 2) // 3)
print(buques)
```
| 307
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 β€ r, g, b β€ 109) β the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
Tags: combinatorics, math
Correct Solution:
```
def f(a, b, c):
return a // 3 + b // 3 + c // 3
a, b, c = sorted(map(int, input().split()))
print(max(f(a, b, c), f(a - 1, b - 1, c - 1) + 1 if a * b * c >= 1 else 0, f(a - 2, b - 2, c - 2) + 2 if a * b * c >= 8 else 0))
```
| 308
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 β€ r, g, b β€ 109) β the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
Tags: combinatorics, math
Correct Solution:
```
l=list(map(int,input().split()))
r,g,b=l[0],l[1],l[2]
c=0
if(r==0 or g==0 or b==0):
c=r//3+g//3+b//3
print(c)
else:
c+=r//3 + g//3+b//3
r%=3
g%=3
b%=3
c+=min(r,g,b)
if((r==0 and g==2 and b==2 ) or (r==2 and g==2 and b==0 ) or (r==2 and g==0 and b==2 ) ):
print(c+1)
else:
print(c)
```
| 309
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 β€ r, g, b β€ 109) β the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
Submitted Solution:
```
a = [int(x) for x in input().split()]
res = a[0]//3+a[1]//3+a[2]//3
for i in a:
if i==0:
print(res)
exit(0)
a = [x-1 for x in a]
res = max(res, 1+a[0]//3+a[1]//3+a[2]//3)
a = [x-1 for x in a]
res = max(res, 2+a[0]//3+a[1]//3+a[2]//3)
print(res)
```
Yes
| 310
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 β€ r, g, b β€ 109) β the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
Submitted Solution:
```
s = input()
arr = s.split(" ")
r = int(arr[0])
g = int(arr[1])
b = int(arr[2])
ans = r//3 + g//3 + b//3
if r > 0 and g > 0 and b > 0:
temp = (r-1)//3 + (g-1)//3 + (b-1)//3 + 1
ans = max(ans,temp)
if r > 1 and g > 1 and b > 1:
temp = (r-2)//3 + (g-2)//3 + (b-2)//3 + 2
ans = max(ans,temp)
print(ans)
```
Yes
| 311
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 β€ r, g, b β€ 109) β the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
Submitted Solution:
```
*arr,=map(int, input().split())
mod, div = [int(i%3) for i in arr], [int(i/3) for i in arr]
a, b = sum(div) + min(mod), max(mod) + (sum(div)-(3-mod.count(max(mod))))
if(0 in arr): print(a)
else:
print(max(a,b))
```
Yes
| 312
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 β€ r, g, b β€ 109) β the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
Submitted Solution:
```
a, b, c = map(int, input().split())
l = min(a, min(b, c))
ans = 0
x = 0
n = l
while x <= min(n, 10):
l = l - x
ans = max(ans, l + (a-l)//3 + (b-l)//3 + (c-l)//3 )
x = x + 1
print(ans)
```
Yes
| 313
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 β€ r, g, b β€ 109) β the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
Submitted Solution:
```
def solve(r, g, b):
global cnt, threecnt
cnt = int(0)
threecnt = int(0)
def change(y):
global cnt, threecnt
if y % 3:
cnt += y // 3
y = y % 3
print(cnt, y)
elif y != 0:
cnt += y // 3 - 1
y = 3
threecnt += 1
return y
r = change(r)
g = change(g)
b = change(b)
if threecnt > 1:
cnt += threecnt
else:
cnt += max(threecnt, min(r, g, b))
print(cnt)
r, g, b = map(int, input().split())
solve(r, g, b)
```
No
| 314
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 β€ r, g, b β€ 109) β the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
Submitted Solution:
```
r, b, g = [int(i) for i in input().split()]
rems = min(r, b, g)
rems1 = min(r%3,b%3,g%3)
ans = ((r-rems)//3) + ((b-rems)//3) + ((g-rems)//3) + rems
ans1 = (r//3) + (b//3) + (g//3) + rems1
print(max(ans,ans1))
```
No
| 315
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 β€ r, g, b β€ 109) β the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
Submitted Solution:
```
r,g,b = [int(x) for x in input().split()]
def bouquets(r,g,b):
ans = 0
ans += int(r/3)
ans += int(g/3)
ans += int(b/3)
li = [r%3,g%3,b%3]
if 0 in li:
if sum(li)==4: # 0,2,2
return (ans+1)
else:
return ans
else:
if sum(li)==6: #2,2,2
return (ans+2)
else:
return (ans+1)
return ans
print(bouquets(r,g,b))
#print(bouquets(4,4,4))
```
No
| 316
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 β€ r, g, b β€ 109) β the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
Submitted Solution:
```
r, g, b = sorted(map(int, input().split()))
print((r // 3) * 3 + (g - r % 3 - (r // 3) * 3) // 3 + (b - r % 3 - (r // 3) * 3) // 3 + r % 3)
```
No
| 317
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Doodle Jump the aim is to guide a four-legged creature called "The Doodler" up a never-ending series of platforms without falling. β Wikipedia.
It is a very popular game and xiaodao likes it very much. One day when playing the game she wondered whether there exists a platform that the doodler couldn't reach due to the limits of its jumping ability. Consider the following problem.
There are n platforms. The height of the x-th (1 β€ x β€ n) platform is aΒ·x mod p, where a and p are positive co-prime integers. The maximum possible height of a Doodler's jump is h. That is, it can jump from height h1 to height h2 (h1 < h2) if h2 - h1 β€ h. Initially, the Doodler is on the ground, the height of which is 0. The question is whether it can reach the highest platform or not.
For example, when a = 7, n = 4, p = 12, h = 2, the heights of the platforms are 7, 2, 9, 4 as in the picture below. With the first jump the Doodler can jump to the platform at height 2, with the second one the Doodler can jump to the platform at height 4, but then it can't jump to any of the higher platforms. So, it can't reach the highest platform.
<image>
User xiaodao thought about the problem for a long time but didn't solve it, so she asks you for help. Also, she has a lot of instances of the problem. Your task is solve all of these instances.
Input
The first line contains an integer t (1 β€ t β€ 104) β the number of problem instances. Each of the next t lines contains four integers a, n, p and h (1 β€ a β€ 109, 1 β€ n < p β€ 109, 0 β€ h β€ 109). It's guaranteed that a and p are co-prime.
Output
For each problem instance, if the Doodler can reach the highest platform, output "YES", otherwise output "NO".
Examples
Input
3
7 4 12 2
7 1 9 4
7 4 12 3
Output
NO
NO
YES
Submitted Solution:
```
def nerf():
for i in range(1,n+1):
if h<(a*i)%p:
return "NO"
return "YES"
for j in range(int(input())):
a,n,p,h=[int(i) for i in input().split()]
print(nerf())
```
No
| 318
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Doodle Jump the aim is to guide a four-legged creature called "The Doodler" up a never-ending series of platforms without falling. β Wikipedia.
It is a very popular game and xiaodao likes it very much. One day when playing the game she wondered whether there exists a platform that the doodler couldn't reach due to the limits of its jumping ability. Consider the following problem.
There are n platforms. The height of the x-th (1 β€ x β€ n) platform is aΒ·x mod p, where a and p are positive co-prime integers. The maximum possible height of a Doodler's jump is h. That is, it can jump from height h1 to height h2 (h1 < h2) if h2 - h1 β€ h. Initially, the Doodler is on the ground, the height of which is 0. The question is whether it can reach the highest platform or not.
For example, when a = 7, n = 4, p = 12, h = 2, the heights of the platforms are 7, 2, 9, 4 as in the picture below. With the first jump the Doodler can jump to the platform at height 2, with the second one the Doodler can jump to the platform at height 4, but then it can't jump to any of the higher platforms. So, it can't reach the highest platform.
<image>
User xiaodao thought about the problem for a long time but didn't solve it, so she asks you for help. Also, she has a lot of instances of the problem. Your task is solve all of these instances.
Input
The first line contains an integer t (1 β€ t β€ 104) β the number of problem instances. Each of the next t lines contains four integers a, n, p and h (1 β€ a β€ 109, 1 β€ n < p β€ 109, 0 β€ h β€ 109). It's guaranteed that a and p are co-prime.
Output
For each problem instance, if the Doodler can reach the highest platform, output "YES", otherwise output "NO".
Examples
Input
3
7 4 12 2
7 1 9 4
7 4 12 3
Output
NO
NO
YES
Submitted Solution:
```
n = int(input())
for j in range(n):
WR = []
f = True
a = list(map(int, input().split(' ')))
for i in range(1,a[1]+1):
WR.append(a[0]*i%a[2])
WR = sorted(WR)
#print(WR)
#======================================#
if len(WR)>1:
for i in range(len(WR)-1):
if WR[i+1]-WR[i]>a[3]:
f = False
break
elif len(WR) == 1:
if WR[0]>a[3]:
f = False
if f == False:
print('NO')
else:
print('YES')
```
No
| 319
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Doodle Jump the aim is to guide a four-legged creature called "The Doodler" up a never-ending series of platforms without falling. β Wikipedia.
It is a very popular game and xiaodao likes it very much. One day when playing the game she wondered whether there exists a platform that the doodler couldn't reach due to the limits of its jumping ability. Consider the following problem.
There are n platforms. The height of the x-th (1 β€ x β€ n) platform is aΒ·x mod p, where a and p are positive co-prime integers. The maximum possible height of a Doodler's jump is h. That is, it can jump from height h1 to height h2 (h1 < h2) if h2 - h1 β€ h. Initially, the Doodler is on the ground, the height of which is 0. The question is whether it can reach the highest platform or not.
For example, when a = 7, n = 4, p = 12, h = 2, the heights of the platforms are 7, 2, 9, 4 as in the picture below. With the first jump the Doodler can jump to the platform at height 2, with the second one the Doodler can jump to the platform at height 4, but then it can't jump to any of the higher platforms. So, it can't reach the highest platform.
<image>
User xiaodao thought about the problem for a long time but didn't solve it, so she asks you for help. Also, she has a lot of instances of the problem. Your task is solve all of these instances.
Input
The first line contains an integer t (1 β€ t β€ 104) β the number of problem instances. Each of the next t lines contains four integers a, n, p and h (1 β€ a β€ 109, 1 β€ n < p β€ 109, 0 β€ h β€ 109). It's guaranteed that a and p are co-prime.
Output
For each problem instance, if the Doodler can reach the highest platform, output "YES", otherwise output "NO".
Examples
Input
3
7 4 12 2
7 1 9 4
7 4 12 3
Output
NO
NO
YES
Submitted Solution:
```
t = int(input())
j = 0
l = 0
flag = True
while(j<t):
a,n,p,h = input().split()
a=int(a)
n=int(n)
p=int(p)
h=int(h)
if(h==0):
flag=False
else:
if(n==1):
x = a*1%p
if(x>h):
flag=False
else:
flag=True
else:
mas = [int((a*(i+1))%p) for i in range(n)]
mas = sorted(mas)
while (l<n-1):
if(mas[l+1]-mas[l]>h):
flag = False
break
l+=1
l=0
if(flag == False):
print('NO')
else:
print('YES')
flag=True
j+=1
```
No
| 320
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Doodle Jump the aim is to guide a four-legged creature called "The Doodler" up a never-ending series of platforms without falling. β Wikipedia.
It is a very popular game and xiaodao likes it very much. One day when playing the game she wondered whether there exists a platform that the doodler couldn't reach due to the limits of its jumping ability. Consider the following problem.
There are n platforms. The height of the x-th (1 β€ x β€ n) platform is aΒ·x mod p, where a and p are positive co-prime integers. The maximum possible height of a Doodler's jump is h. That is, it can jump from height h1 to height h2 (h1 < h2) if h2 - h1 β€ h. Initially, the Doodler is on the ground, the height of which is 0. The question is whether it can reach the highest platform or not.
For example, when a = 7, n = 4, p = 12, h = 2, the heights of the platforms are 7, 2, 9, 4 as in the picture below. With the first jump the Doodler can jump to the platform at height 2, with the second one the Doodler can jump to the platform at height 4, but then it can't jump to any of the higher platforms. So, it can't reach the highest platform.
<image>
User xiaodao thought about the problem for a long time but didn't solve it, so she asks you for help. Also, she has a lot of instances of the problem. Your task is solve all of these instances.
Input
The first line contains an integer t (1 β€ t β€ 104) β the number of problem instances. Each of the next t lines contains four integers a, n, p and h (1 β€ a β€ 109, 1 β€ n < p β€ 109, 0 β€ h β€ 109). It's guaranteed that a and p are co-prime.
Output
For each problem instance, if the Doodler can reach the highest platform, output "YES", otherwise output "NO".
Examples
Input
3
7 4 12 2
7 1 9 4
7 4 12 3
Output
NO
NO
YES
Submitted Solution:
```
def main(a,n,p,h):
heights = []
for x in range(1, n % p + 1):
heights.append(a*x % p)
heights.sort()
if 0 not in heights:
heights = [0]+heights
for i in range(1, n+1):
d = heights[i]-heights[i-1]
if d>h:
return 'NO'
return 'YES'
def init():
t = int(input())
s=''
for i in range(t):
a,n,p,h = list(map(int, input().split()))
if h==0 or (h==1 and n%p!=0):
s+='NO\n'
else:
s+=main(a,n,p,h)+'\n'
print(s[:-1])
init()
```
No
| 321
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya is learning to play chess. He has already learned how to move a king, a rook and a bishop. Let us remind you the rules of moving chess pieces. A chessboard is 64 square fields organized into an 8 Γ 8 table. A field is represented by a pair of integers (r, c) β the number of the row and the number of the column (in a classical game the columns are traditionally indexed by letters). Each chess piece takes up exactly one field. To make a move is to move a chess piece, the pieces move by the following rules:
* A rook moves any number of fields horizontally or vertically.
* A bishop moves any number of fields diagonally.
* A king moves one field in any direction β horizontally, vertically or diagonally.
<image> The pieces move like that
Petya is thinking about the following problem: what minimum number of moves is needed for each of these pieces to move from field (r1, c1) to field (r2, c2)? At that, we assume that there are no more pieces besides this one on the board. Help him solve this problem.
Input
The input contains four integers r1, c1, r2, c2 (1 β€ r1, c1, r2, c2 β€ 8) β the coordinates of the starting and the final field. The starting field doesn't coincide with the final one.
You can assume that the chessboard rows are numbered from top to bottom 1 through 8, and the columns are numbered from left to right 1 through 8.
Output
Print three space-separated integers: the minimum number of moves the rook, the bishop and the king (in this order) is needed to move from field (r1, c1) to field (r2, c2). If a piece cannot make such a move, print a 0 instead of the corresponding number.
Examples
Input
4 3 1 6
Output
2 1 3
Input
5 5 5 6
Output
1 0 1
Tags: graphs, math, shortest paths
Correct Solution:
```
def nrook(r1, c1, r2, c2):
if r1 == r2 or c1 == c2: return 1
return 2
def nking(r1, c1, r2, c2):
dr = abs(r1 - r2)
dc = abs(c1 - c2)
return dr + dc - min(dr, dc)
def iswhite(r, c):
return c % 2 != 0 if r % 2 else c % 2 == 0
def nbishop(r1, c1, r2, c2):
if iswhite(r1, c1) != iswhite(r2, c2): return 0
if r1 + c1 == r2 + c2 or r1 - c1 == r2 - c2: return 1
return 2
def main():
r1, c1, r2, c2 = [int(x) - 1 for x in input().split()]
rook = nrook(r1, c1, r2, c2)
bishop = nbishop(r1, c1, r2, c2)
king = nking(r1, c1, r2, c2)
print(rook, bishop, king)
if __name__ == '__main__':
main()
```
| 322
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya is learning to play chess. He has already learned how to move a king, a rook and a bishop. Let us remind you the rules of moving chess pieces. A chessboard is 64 square fields organized into an 8 Γ 8 table. A field is represented by a pair of integers (r, c) β the number of the row and the number of the column (in a classical game the columns are traditionally indexed by letters). Each chess piece takes up exactly one field. To make a move is to move a chess piece, the pieces move by the following rules:
* A rook moves any number of fields horizontally or vertically.
* A bishop moves any number of fields diagonally.
* A king moves one field in any direction β horizontally, vertically or diagonally.
<image> The pieces move like that
Petya is thinking about the following problem: what minimum number of moves is needed for each of these pieces to move from field (r1, c1) to field (r2, c2)? At that, we assume that there are no more pieces besides this one on the board. Help him solve this problem.
Input
The input contains four integers r1, c1, r2, c2 (1 β€ r1, c1, r2, c2 β€ 8) β the coordinates of the starting and the final field. The starting field doesn't coincide with the final one.
You can assume that the chessboard rows are numbered from top to bottom 1 through 8, and the columns are numbered from left to right 1 through 8.
Output
Print three space-separated integers: the minimum number of moves the rook, the bishop and the king (in this order) is needed to move from field (r1, c1) to field (r2, c2). If a piece cannot make such a move, print a 0 instead of the corresponding number.
Examples
Input
4 3 1 6
Output
2 1 3
Input
5 5 5 6
Output
1 0 1
Tags: graphs, math, shortest paths
Correct Solution:
```
x1,y1,x2,y2 = list(map(int,input().split()))
arr = [min(abs(x1-x2),1) + min(abs(y1-y2),1),(1 if abs(x1-x2) == abs(y1-y2) else 2) if (x1&1^y1&1)==(x2&1^y2&1) else 0,max(abs(y2-y1),abs(x2-x1))]
print(*arr)
```
| 323
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya is learning to play chess. He has already learned how to move a king, a rook and a bishop. Let us remind you the rules of moving chess pieces. A chessboard is 64 square fields organized into an 8 Γ 8 table. A field is represented by a pair of integers (r, c) β the number of the row and the number of the column (in a classical game the columns are traditionally indexed by letters). Each chess piece takes up exactly one field. To make a move is to move a chess piece, the pieces move by the following rules:
* A rook moves any number of fields horizontally or vertically.
* A bishop moves any number of fields diagonally.
* A king moves one field in any direction β horizontally, vertically or diagonally.
<image> The pieces move like that
Petya is thinking about the following problem: what minimum number of moves is needed for each of these pieces to move from field (r1, c1) to field (r2, c2)? At that, we assume that there are no more pieces besides this one on the board. Help him solve this problem.
Input
The input contains four integers r1, c1, r2, c2 (1 β€ r1, c1, r2, c2 β€ 8) β the coordinates of the starting and the final field. The starting field doesn't coincide with the final one.
You can assume that the chessboard rows are numbered from top to bottom 1 through 8, and the columns are numbered from left to right 1 through 8.
Output
Print three space-separated integers: the minimum number of moves the rook, the bishop and the king (in this order) is needed to move from field (r1, c1) to field (r2, c2). If a piece cannot make such a move, print a 0 instead of the corresponding number.
Examples
Input
4 3 1 6
Output
2 1 3
Input
5 5 5 6
Output
1 0 1
Tags: graphs, math, shortest paths
Correct Solution:
```
a = list(map(int, input().split()))
y1 = a[0]
d1 = a[1]
y2 = a[2]
d2 = a[3]
yatay = abs(y1 - y2)#0
dikey = abs(d1 - d2)#1
a = [0, 0 , 0]
# kale fil Εah
if yatay == 0 or dikey == 0:
a[0] = 1
else:
a[0] = 2
if ((y1+d1) % 2) == ((y2+d2) % 2):
if yatay == dikey:
a[1] = 1
else:
a[1] = 2
else:
a[1] = 0
if yatay == dikey:
a[2] = yatay
else:
a[2] = abs(yatay - dikey) + min(yatay, dikey)
print(*a)
```
| 324
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya is learning to play chess. He has already learned how to move a king, a rook and a bishop. Let us remind you the rules of moving chess pieces. A chessboard is 64 square fields organized into an 8 Γ 8 table. A field is represented by a pair of integers (r, c) β the number of the row and the number of the column (in a classical game the columns are traditionally indexed by letters). Each chess piece takes up exactly one field. To make a move is to move a chess piece, the pieces move by the following rules:
* A rook moves any number of fields horizontally or vertically.
* A bishop moves any number of fields diagonally.
* A king moves one field in any direction β horizontally, vertically or diagonally.
<image> The pieces move like that
Petya is thinking about the following problem: what minimum number of moves is needed for each of these pieces to move from field (r1, c1) to field (r2, c2)? At that, we assume that there are no more pieces besides this one on the board. Help him solve this problem.
Input
The input contains four integers r1, c1, r2, c2 (1 β€ r1, c1, r2, c2 β€ 8) β the coordinates of the starting and the final field. The starting field doesn't coincide with the final one.
You can assume that the chessboard rows are numbered from top to bottom 1 through 8, and the columns are numbered from left to right 1 through 8.
Output
Print three space-separated integers: the minimum number of moves the rook, the bishop and the king (in this order) is needed to move from field (r1, c1) to field (r2, c2). If a piece cannot make such a move, print a 0 instead of the corresponding number.
Examples
Input
4 3 1 6
Output
2 1 3
Input
5 5 5 6
Output
1 0 1
Tags: graphs, math, shortest paths
Correct Solution:
```
__author__ = 'Esfandiar and HajLorenzo'
a=list(map(int,input().split()))
res = 2
res-= a[0]==a[2]
res-= a[1]==a[3]
print(res,end=" ")
res=2
black1 = (a[0]+a[1]) % 2 != 0
black2 = (a[2]+a[3]) % 2 != 0
if black1 != black2 or (a[0] == a[2] and a[1] == a[3]):
print(0,end=" ")
else:
print(1 if abs(a[0]-a[2]) == abs(a[1]-a[3]) else 2,end=" ")
print(abs(a[0] - a[2]) + max(abs(a[1] - a[3]) - (abs(a[0] - a[2])),0))
```
| 325
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya is learning to play chess. He has already learned how to move a king, a rook and a bishop. Let us remind you the rules of moving chess pieces. A chessboard is 64 square fields organized into an 8 Γ 8 table. A field is represented by a pair of integers (r, c) β the number of the row and the number of the column (in a classical game the columns are traditionally indexed by letters). Each chess piece takes up exactly one field. To make a move is to move a chess piece, the pieces move by the following rules:
* A rook moves any number of fields horizontally or vertically.
* A bishop moves any number of fields diagonally.
* A king moves one field in any direction β horizontally, vertically or diagonally.
<image> The pieces move like that
Petya is thinking about the following problem: what minimum number of moves is needed for each of these pieces to move from field (r1, c1) to field (r2, c2)? At that, we assume that there are no more pieces besides this one on the board. Help him solve this problem.
Input
The input contains four integers r1, c1, r2, c2 (1 β€ r1, c1, r2, c2 β€ 8) β the coordinates of the starting and the final field. The starting field doesn't coincide with the final one.
You can assume that the chessboard rows are numbered from top to bottom 1 through 8, and the columns are numbered from left to right 1 through 8.
Output
Print three space-separated integers: the minimum number of moves the rook, the bishop and the king (in this order) is needed to move from field (r1, c1) to field (r2, c2). If a piece cannot make such a move, print a 0 instead of the corresponding number.
Examples
Input
4 3 1 6
Output
2 1 3
Input
5 5 5 6
Output
1 0 1
Tags: graphs, math, shortest paths
Correct Solution:
```
sx,sy,ex,ey=map(int,input().split())
rook=1 if sx==ex or sy==ey else 2
bishop=0
if abs(sx-ex)==abs(sy-ey): bishop=1
elif (sx+sy)%2==(ex+ey)%2: bishop=2
king=max(abs(sx-ex),abs(sy-ey))
print(rook,bishop,king)
```
| 326
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya is learning to play chess. He has already learned how to move a king, a rook and a bishop. Let us remind you the rules of moving chess pieces. A chessboard is 64 square fields organized into an 8 Γ 8 table. A field is represented by a pair of integers (r, c) β the number of the row and the number of the column (in a classical game the columns are traditionally indexed by letters). Each chess piece takes up exactly one field. To make a move is to move a chess piece, the pieces move by the following rules:
* A rook moves any number of fields horizontally or vertically.
* A bishop moves any number of fields diagonally.
* A king moves one field in any direction β horizontally, vertically or diagonally.
<image> The pieces move like that
Petya is thinking about the following problem: what minimum number of moves is needed for each of these pieces to move from field (r1, c1) to field (r2, c2)? At that, we assume that there are no more pieces besides this one on the board. Help him solve this problem.
Input
The input contains four integers r1, c1, r2, c2 (1 β€ r1, c1, r2, c2 β€ 8) β the coordinates of the starting and the final field. The starting field doesn't coincide with the final one.
You can assume that the chessboard rows are numbered from top to bottom 1 through 8, and the columns are numbered from left to right 1 through 8.
Output
Print three space-separated integers: the minimum number of moves the rook, the bishop and the king (in this order) is needed to move from field (r1, c1) to field (r2, c2). If a piece cannot make such a move, print a 0 instead of the corresponding number.
Examples
Input
4 3 1 6
Output
2 1 3
Input
5 5 5 6
Output
1 0 1
Tags: graphs, math, shortest paths
Correct Solution:
```
pos = input()
c1 = int(pos.split()[0])
r1 = int(pos.split()[1])
c2 = int(pos.split()[2])
r2 = int(pos.split()[3])
def rook():
if c1 == c2 or r1==r2:
return 1
else :
return 2
def bishop():
if (c1+r1)%2 == (c2+r2)%2:
if (c1-r1) == (c2-r2) or (c1+r1) == (c2+r2):
return 1
else :
return 2
else:
return 0
def king():
if r1==r2:
return abs(c2-c1)
elif c1==c2:
return abs(r2-r1)
else:
if abs(c2-c1)>=abs(r2-r1):
return abs(c2-c1)
else:
return abs(r2-r1)
print (rook(), bishop(), king())
```
| 327
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya is learning to play chess. He has already learned how to move a king, a rook and a bishop. Let us remind you the rules of moving chess pieces. A chessboard is 64 square fields organized into an 8 Γ 8 table. A field is represented by a pair of integers (r, c) β the number of the row and the number of the column (in a classical game the columns are traditionally indexed by letters). Each chess piece takes up exactly one field. To make a move is to move a chess piece, the pieces move by the following rules:
* A rook moves any number of fields horizontally or vertically.
* A bishop moves any number of fields diagonally.
* A king moves one field in any direction β horizontally, vertically or diagonally.
<image> The pieces move like that
Petya is thinking about the following problem: what minimum number of moves is needed for each of these pieces to move from field (r1, c1) to field (r2, c2)? At that, we assume that there are no more pieces besides this one on the board. Help him solve this problem.
Input
The input contains four integers r1, c1, r2, c2 (1 β€ r1, c1, r2, c2 β€ 8) β the coordinates of the starting and the final field. The starting field doesn't coincide with the final one.
You can assume that the chessboard rows are numbered from top to bottom 1 through 8, and the columns are numbered from left to right 1 through 8.
Output
Print three space-separated integers: the minimum number of moves the rook, the bishop and the king (in this order) is needed to move from field (r1, c1) to field (r2, c2). If a piece cannot make such a move, print a 0 instead of the corresponding number.
Examples
Input
4 3 1 6
Output
2 1 3
Input
5 5 5 6
Output
1 0 1
Tags: graphs, math, shortest paths
Correct Solution:
```
from math import ceil
d = {"r":0,"b":0,"k":0}
r1,c1,r2,c2 = map(int,input().split())
if r1 != r2:
d["r"] = d["r"] + 1
if c1 != c2:
d["r"] = d["r"] + 1
if (abs(r1-r2)+abs(c1-c2))%2 == 1:
d["b"] = 0
elif c1-c2 != 0 and (r1-r2)/(c1-c2) == -1 or c1-c2 != 0 and (r1-r2)/(c1-c2) == 1:
d["b"] = 1
elif(abs(r1-r2)+abs(c1-c2))%2 == 0:
d["b"] = 2
y1 = -(r1-c1-r2)
y2 = (r1+c1-r2)
x1 = (r1-c1+c2)
x2 = (r1+c1-c2)
d1 = pow(pow((x1-r1),2)+pow(c2-c1,2),1/2)/pow(2,1/2)+abs(x1-r2)
d2 = pow(pow((x2-r1),2)+pow(c2-c1,2),1/2)/pow(2,1/2)+abs(x2-r2)
d3 = pow(pow((r2-r1),2)+pow(c1-y2,2),1/2)/pow(2,1/2)+abs(c2-y2)
d4 = pow(pow((r2-r1),2)+pow(c1-y1,2),1/2)/pow(2,1/2)+abs(c2-y1)
d5 = (abs(r2-r1)+abs(c2-c1))
d["k"] = min(d1,d2,d3,d4,d5)
for i in d:
print(int(ceil(d[i])),end=" ")
```
| 328
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya is learning to play chess. He has already learned how to move a king, a rook and a bishop. Let us remind you the rules of moving chess pieces. A chessboard is 64 square fields organized into an 8 Γ 8 table. A field is represented by a pair of integers (r, c) β the number of the row and the number of the column (in a classical game the columns are traditionally indexed by letters). Each chess piece takes up exactly one field. To make a move is to move a chess piece, the pieces move by the following rules:
* A rook moves any number of fields horizontally or vertically.
* A bishop moves any number of fields diagonally.
* A king moves one field in any direction β horizontally, vertically or diagonally.
<image> The pieces move like that
Petya is thinking about the following problem: what minimum number of moves is needed for each of these pieces to move from field (r1, c1) to field (r2, c2)? At that, we assume that there are no more pieces besides this one on the board. Help him solve this problem.
Input
The input contains four integers r1, c1, r2, c2 (1 β€ r1, c1, r2, c2 β€ 8) β the coordinates of the starting and the final field. The starting field doesn't coincide with the final one.
You can assume that the chessboard rows are numbered from top to bottom 1 through 8, and the columns are numbered from left to right 1 through 8.
Output
Print three space-separated integers: the minimum number of moves the rook, the bishop and the king (in this order) is needed to move from field (r1, c1) to field (r2, c2). If a piece cannot make such a move, print a 0 instead of the corresponding number.
Examples
Input
4 3 1 6
Output
2 1 3
Input
5 5 5 6
Output
1 0 1
Tags: graphs, math, shortest paths
Correct Solution:
```
r1,c1,r2,c2=map(int,input().split())
def f():
if abs(r1-r2)==abs(c1-c2):
return 1
elif (r1+c1)%2==(c2+r2)%2:
return 2
else:
return 0
def k():
dx=abs(r1-r2)
dy=abs(c1-c2)
return max(dx,dy)
def r():
if r1==r2 or c1==c2:
return 1
else:
return 2
print(r(),f(),k())
```
| 329
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya is learning to play chess. He has already learned how to move a king, a rook and a bishop. Let us remind you the rules of moving chess pieces. A chessboard is 64 square fields organized into an 8 Γ 8 table. A field is represented by a pair of integers (r, c) β the number of the row and the number of the column (in a classical game the columns are traditionally indexed by letters). Each chess piece takes up exactly one field. To make a move is to move a chess piece, the pieces move by the following rules:
* A rook moves any number of fields horizontally or vertically.
* A bishop moves any number of fields diagonally.
* A king moves one field in any direction β horizontally, vertically or diagonally.
<image> The pieces move like that
Petya is thinking about the following problem: what minimum number of moves is needed for each of these pieces to move from field (r1, c1) to field (r2, c2)? At that, we assume that there are no more pieces besides this one on the board. Help him solve this problem.
Input
The input contains four integers r1, c1, r2, c2 (1 β€ r1, c1, r2, c2 β€ 8) β the coordinates of the starting and the final field. The starting field doesn't coincide with the final one.
You can assume that the chessboard rows are numbered from top to bottom 1 through 8, and the columns are numbered from left to right 1 through 8.
Output
Print three space-separated integers: the minimum number of moves the rook, the bishop and the king (in this order) is needed to move from field (r1, c1) to field (r2, c2). If a piece cannot make such a move, print a 0 instead of the corresponding number.
Examples
Input
4 3 1 6
Output
2 1 3
Input
5 5 5 6
Output
1 0 1
Submitted Solution:
```
#Program Rook,Bishop,and King
def rook(sx,sy,lx,ly):
if sx != lx or sy != ly:
if sx == lx:
move = 1
elif sy == ly:
move = 1
else:
move = 2
else:
move = 0
return move
def bishop(sx,sy,lx,ly):
if sx != lx or sy != ly:
if (sx+sy)%2 != (lx+ly)%2:
move = 0
else:
if (sx+sy) == (lx+ly) or abs(sx-lx) == abs(sy-ly):
move = 1
else:
move = 2
else:
move = 0
return move
def king(sx,sy,lx,ly):
move = 0
if sx == lx:
move = abs(sy-ly)
elif sy == ly:
move = abs(sx-lx)
else:
while sx != lx or sy != ly:
if sx > lx:
sx-=1
elif sx < lx:
sx+=1
if sy > ly:
sy-=1
elif sy < ly:
sy+=1
move+=1
return move
def main():
p1,p2,p3,p4 = map(int,input().split())
move = []
move.append(rook(p1,p2,p3,p4))
move.append(bishop(p1,p2,p3,p4))
move.append(king(p1,p2,p3,p4))
for x in move: print(x,end=" ")
main()
```
Yes
| 330
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya is learning to play chess. He has already learned how to move a king, a rook and a bishop. Let us remind you the rules of moving chess pieces. A chessboard is 64 square fields organized into an 8 Γ 8 table. A field is represented by a pair of integers (r, c) β the number of the row and the number of the column (in a classical game the columns are traditionally indexed by letters). Each chess piece takes up exactly one field. To make a move is to move a chess piece, the pieces move by the following rules:
* A rook moves any number of fields horizontally or vertically.
* A bishop moves any number of fields diagonally.
* A king moves one field in any direction β horizontally, vertically or diagonally.
<image> The pieces move like that
Petya is thinking about the following problem: what minimum number of moves is needed for each of these pieces to move from field (r1, c1) to field (r2, c2)? At that, we assume that there are no more pieces besides this one on the board. Help him solve this problem.
Input
The input contains four integers r1, c1, r2, c2 (1 β€ r1, c1, r2, c2 β€ 8) β the coordinates of the starting and the final field. The starting field doesn't coincide with the final one.
You can assume that the chessboard rows are numbered from top to bottom 1 through 8, and the columns are numbered from left to right 1 through 8.
Output
Print three space-separated integers: the minimum number of moves the rook, the bishop and the king (in this order) is needed to move from field (r1, c1) to field (r2, c2). If a piece cannot make such a move, print a 0 instead of the corresponding number.
Examples
Input
4 3 1 6
Output
2 1 3
Input
5 5 5 6
Output
1 0 1
Submitted Solution:
```
a = [int(i) for i in input().split()]
x1 = a[0]
y1 = a[1]
x2 = a[2]
y2 = a[3]
# for rook
if(x1 == x2) or (y2 == y1):
print(1, end = ' ')
elif(x1 != x2 and y2 != y1):
print(2, end = ' ')
#for bishop
if(x1 + y1 == x2 + y2 or x1-y1 == x2 - y2):
print(1, end = ' ')
elif (x1 + y1) % 2 != (x2 + y2)%2 :
print(0, end = ' ')
else:
print(2)
#for king
print(max(abs(x1 - x2), abs(y1-y2)) , end = ' ')
```
Yes
| 331
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya is learning to play chess. He has already learned how to move a king, a rook and a bishop. Let us remind you the rules of moving chess pieces. A chessboard is 64 square fields organized into an 8 Γ 8 table. A field is represented by a pair of integers (r, c) β the number of the row and the number of the column (in a classical game the columns are traditionally indexed by letters). Each chess piece takes up exactly one field. To make a move is to move a chess piece, the pieces move by the following rules:
* A rook moves any number of fields horizontally or vertically.
* A bishop moves any number of fields diagonally.
* A king moves one field in any direction β horizontally, vertically or diagonally.
<image> The pieces move like that
Petya is thinking about the following problem: what minimum number of moves is needed for each of these pieces to move from field (r1, c1) to field (r2, c2)? At that, we assume that there are no more pieces besides this one on the board. Help him solve this problem.
Input
The input contains four integers r1, c1, r2, c2 (1 β€ r1, c1, r2, c2 β€ 8) β the coordinates of the starting and the final field. The starting field doesn't coincide with the final one.
You can assume that the chessboard rows are numbered from top to bottom 1 through 8, and the columns are numbered from left to right 1 through 8.
Output
Print three space-separated integers: the minimum number of moves the rook, the bishop and the king (in this order) is needed to move from field (r1, c1) to field (r2, c2). If a piece cannot make such a move, print a 0 instead of the corresponding number.
Examples
Input
4 3 1 6
Output
2 1 3
Input
5 5 5 6
Output
1 0 1
Submitted Solution:
```
read = lambda: map(int, input().split())
r1, c1, r2, c2 = read()
L = 1 if r1 == r2 or c1 == c2 else 2
K = max(abs(r1 - r2), abs(c1 - c2))
if abs(r1 - r2) == abs(c1 - c2): S = 1
elif (r1 + c1) % 2 == (r2 + c2) % 2: S = 2
else: S = 0
print(L, S, K)
```
Yes
| 332
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya is learning to play chess. He has already learned how to move a king, a rook and a bishop. Let us remind you the rules of moving chess pieces. A chessboard is 64 square fields organized into an 8 Γ 8 table. A field is represented by a pair of integers (r, c) β the number of the row and the number of the column (in a classical game the columns are traditionally indexed by letters). Each chess piece takes up exactly one field. To make a move is to move a chess piece, the pieces move by the following rules:
* A rook moves any number of fields horizontally or vertically.
* A bishop moves any number of fields diagonally.
* A king moves one field in any direction β horizontally, vertically or diagonally.
<image> The pieces move like that
Petya is thinking about the following problem: what minimum number of moves is needed for each of these pieces to move from field (r1, c1) to field (r2, c2)? At that, we assume that there are no more pieces besides this one on the board. Help him solve this problem.
Input
The input contains four integers r1, c1, r2, c2 (1 β€ r1, c1, r2, c2 β€ 8) β the coordinates of the starting and the final field. The starting field doesn't coincide with the final one.
You can assume that the chessboard rows are numbered from top to bottom 1 through 8, and the columns are numbered from left to right 1 through 8.
Output
Print three space-separated integers: the minimum number of moves the rook, the bishop and the king (in this order) is needed to move from field (r1, c1) to field (r2, c2). If a piece cannot make such a move, print a 0 instead of the corresponding number.
Examples
Input
4 3 1 6
Output
2 1 3
Input
5 5 5 6
Output
1 0 1
Submitted Solution:
```
r1,c1,r2,c2=map(int,input().split())
if r1==r2 or c1==c2:r=1
else:r=2
if abs((r1+c1)-(r2+c2))%2==1:b=0
elif abs(c2-c1)==abs(r2-r1):b=1
else:b=2
k=max(abs(c2-c1),abs(r2-r1))
print(r,b,k)
```
Yes
| 333
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya is learning to play chess. He has already learned how to move a king, a rook and a bishop. Let us remind you the rules of moving chess pieces. A chessboard is 64 square fields organized into an 8 Γ 8 table. A field is represented by a pair of integers (r, c) β the number of the row and the number of the column (in a classical game the columns are traditionally indexed by letters). Each chess piece takes up exactly one field. To make a move is to move a chess piece, the pieces move by the following rules:
* A rook moves any number of fields horizontally or vertically.
* A bishop moves any number of fields diagonally.
* A king moves one field in any direction β horizontally, vertically or diagonally.
<image> The pieces move like that
Petya is thinking about the following problem: what minimum number of moves is needed for each of these pieces to move from field (r1, c1) to field (r2, c2)? At that, we assume that there are no more pieces besides this one on the board. Help him solve this problem.
Input
The input contains four integers r1, c1, r2, c2 (1 β€ r1, c1, r2, c2 β€ 8) β the coordinates of the starting and the final field. The starting field doesn't coincide with the final one.
You can assume that the chessboard rows are numbered from top to bottom 1 through 8, and the columns are numbered from left to right 1 through 8.
Output
Print three space-separated integers: the minimum number of moves the rook, the bishop and the king (in this order) is needed to move from field (r1, c1) to field (r2, c2). If a piece cannot make such a move, print a 0 instead of the corresponding number.
Examples
Input
4 3 1 6
Output
2 1 3
Input
5 5 5 6
Output
1 0 1
Submitted Solution:
```
r1,c1,r2,c2=map(int,input().split())
ans=[]
if r1==r2 or c1==c2:
ans.append(1)
else:
ans.append(2)
if r1%2==c1%2:
if r2%2==c2%2:
if (r1+c1)==(r2+c2) or (r1-c1)==(r2-c2):
ans.append(1)
else:
ans.append(2)
else:
ans.append(0)
elif r1%2!=c1%2:
if r2%2!=c2%2:
if (r1+c1)==(r2+c2) or abs(r1-c1)==abs(r2-c2):
ans.append(1)
else:
ans.append(2)
else:
ans.append(0)
ans.append(max(abs(r1-r2),abs(c1-c2)))
#diff
print(*ans)
```
No
| 334
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya is learning to play chess. He has already learned how to move a king, a rook and a bishop. Let us remind you the rules of moving chess pieces. A chessboard is 64 square fields organized into an 8 Γ 8 table. A field is represented by a pair of integers (r, c) β the number of the row and the number of the column (in a classical game the columns are traditionally indexed by letters). Each chess piece takes up exactly one field. To make a move is to move a chess piece, the pieces move by the following rules:
* A rook moves any number of fields horizontally or vertically.
* A bishop moves any number of fields diagonally.
* A king moves one field in any direction β horizontally, vertically or diagonally.
<image> The pieces move like that
Petya is thinking about the following problem: what minimum number of moves is needed for each of these pieces to move from field (r1, c1) to field (r2, c2)? At that, we assume that there are no more pieces besides this one on the board. Help him solve this problem.
Input
The input contains four integers r1, c1, r2, c2 (1 β€ r1, c1, r2, c2 β€ 8) β the coordinates of the starting and the final field. The starting field doesn't coincide with the final one.
You can assume that the chessboard rows are numbered from top to bottom 1 through 8, and the columns are numbered from left to right 1 through 8.
Output
Print three space-separated integers: the minimum number of moves the rook, the bishop and the king (in this order) is needed to move from field (r1, c1) to field (r2, c2). If a piece cannot make such a move, print a 0 instead of the corresponding number.
Examples
Input
4 3 1 6
Output
2 1 3
Input
5 5 5 6
Output
1 0 1
Submitted Solution:
```
from math import ceil
d = {"r":0,"b":0,"k":0}
r1,c1,r2,c2 = map(int,input().split())
if r1 != r2:
d["r"] = d["r"] + 1
if c1 != c2:
d["r"] = d["r"] + 1
if (abs(r1-r2)+abs(c1-c2))%2 == 1:
d["b"] = 0
elif (r1-r2)/(c1-c2) == -1 or (r1-r2)/(c1-c2) == 1:
d["b"] = 1
elif(abs(r1-r2)+abs(c1-c2))%2 == 0:
d["b"] = 2
y1 = r1-c1-r2
y2 = r1+c1-r2
x1 = r1-c1-c2
x2 = r1+c1-c2
d1 = pow(pow((x1-r1),2)+pow(c2-c1,2),1/2)/pow(2,1/2)+abs(y1-c2)
d2 = pow(pow((x2-r1),2)+pow(c2-c1,2),1/2)/pow(2,1/2)+abs(y2-c2)
d3 = pow(pow((r2-r1),2)+pow(c1-y2,2),1/2)/pow(2,1/2)+abs(x2-r2)
d4 = pow(pow((r2-r1),2)+pow(c1-y1,2),1/2)/pow(2,1/2)+abs(x1-r2)
d5 = (abs(r2-r1)+abs(c2-c1))
# print(d1,d2,d3,d4,d5)
d["k"] = min(d1,d2,d3,d4,d5)
for i in d:
print(int(ceil(d[i])),end=" ")
```
No
| 335
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya is learning to play chess. He has already learned how to move a king, a rook and a bishop. Let us remind you the rules of moving chess pieces. A chessboard is 64 square fields organized into an 8 Γ 8 table. A field is represented by a pair of integers (r, c) β the number of the row and the number of the column (in a classical game the columns are traditionally indexed by letters). Each chess piece takes up exactly one field. To make a move is to move a chess piece, the pieces move by the following rules:
* A rook moves any number of fields horizontally or vertically.
* A bishop moves any number of fields diagonally.
* A king moves one field in any direction β horizontally, vertically or diagonally.
<image> The pieces move like that
Petya is thinking about the following problem: what minimum number of moves is needed for each of these pieces to move from field (r1, c1) to field (r2, c2)? At that, we assume that there are no more pieces besides this one on the board. Help him solve this problem.
Input
The input contains four integers r1, c1, r2, c2 (1 β€ r1, c1, r2, c2 β€ 8) β the coordinates of the starting and the final field. The starting field doesn't coincide with the final one.
You can assume that the chessboard rows are numbered from top to bottom 1 through 8, and the columns are numbered from left to right 1 through 8.
Output
Print three space-separated integers: the minimum number of moves the rook, the bishop and the king (in this order) is needed to move from field (r1, c1) to field (r2, c2). If a piece cannot make such a move, print a 0 instead of the corresponding number.
Examples
Input
4 3 1 6
Output
2 1 3
Input
5 5 5 6
Output
1 0 1
Submitted Solution:
```
r1,c1,r2,c2 = input().split(" ")
r1,c1,r2,c2 = int(r1),int(c1),int(r2),int(c2)
analyze = r2-r1==c2-c1 or r2-r1==c1-c2 or r1-r2==c2-c1 or r1-r2==c1-c2
if (r1==r2) and (c1==c2): r = 0
elif (r1==r2) or (c1==c2): r = 1
else: r = 2
if (r1%2==c1%2)!=(r2%2==c2%2) or (r1==r2 and c1==c2): b = 0
elif analyze: b = 1
else: b = 2
if analyze: k = r2-r1
elif r2==r1 and c2!=c1: k = c2-c1
elif c2==c1 and r2!=r1: k = r2-r1
elif r2-r1==c2-c1-1 or r2-r1==c1-c2-1 or r1-r2==c2-c1-1 or r1-r2==c1-c2-1 or r2-r1==c2-c1+1 or r2-r1==c1-c2+1 or r1-r2==c2-c1+1 or r1-r2==c1-c2+1:
k = r2-r1
if k<0: 0-k
k += 1
elif r2<r1:
k = r1-r2
if c2<c1: k += c1-c2
else: k += c2-c1
elif r2>r1:
k = r2-r1
if c2<c1: k += c1-c2
else: k += c2-c1
if k<0: k = 0-k
print(r,b,k)
```
No
| 336
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya is learning to play chess. He has already learned how to move a king, a rook and a bishop. Let us remind you the rules of moving chess pieces. A chessboard is 64 square fields organized into an 8 Γ 8 table. A field is represented by a pair of integers (r, c) β the number of the row and the number of the column (in a classical game the columns are traditionally indexed by letters). Each chess piece takes up exactly one field. To make a move is to move a chess piece, the pieces move by the following rules:
* A rook moves any number of fields horizontally or vertically.
* A bishop moves any number of fields diagonally.
* A king moves one field in any direction β horizontally, vertically or diagonally.
<image> The pieces move like that
Petya is thinking about the following problem: what minimum number of moves is needed for each of these pieces to move from field (r1, c1) to field (r2, c2)? At that, we assume that there are no more pieces besides this one on the board. Help him solve this problem.
Input
The input contains four integers r1, c1, r2, c2 (1 β€ r1, c1, r2, c2 β€ 8) β the coordinates of the starting and the final field. The starting field doesn't coincide with the final one.
You can assume that the chessboard rows are numbered from top to bottom 1 through 8, and the columns are numbered from left to right 1 through 8.
Output
Print three space-separated integers: the minimum number of moves the rook, the bishop and the king (in this order) is needed to move from field (r1, c1) to field (r2, c2). If a piece cannot make such a move, print a 0 instead of the corresponding number.
Examples
Input
4 3 1 6
Output
2 1 3
Input
5 5 5 6
Output
1 0 1
Submitted Solution:
```
def fn(r1,c1,r2,c2):
if r1==r2 and c1==c2:
rook = bishop = king = 0
print(rook, bishop, king)
return
if r1==r2 or c1==c2:
rook=1
else:
rook=2
if (r1-r2 == c1-c2) or (r1-r2 ==c2-c1):
bishop=1
elif (r1-r2) % 2== 1 or (c1-c2) % 2 == 1:
bishop=0
else:
bishop=2
if r1==r2:
king=abs(c1-c2)
elif c1==c2:
king=abs(r1-r2)
elif (r1-r2 == c1-c2) or (r1-r2 == c2-c1):
king = abs(r1-r2)
else:
king = abs(r1-r2) + abs(c2-c1+abs(r1-r2))
print(rook, bishop, king)
return
```
No
| 337
|
Provide tags and a correct Python 3 solution for this coding contest problem.
This problem consists of three subproblems: for solving subproblem F1 you will receive 8 points, for solving subproblem F2 you will receive 15 points, and for solving subproblem F3 you will receive 10 points.
Manao has developed a model to predict the stock price of a company over the next n days and wants to design a profit-maximizing trading algorithm to make use of these predictions. Unfortunately, Manao's trading account has the following restrictions:
* It only allows owning either zero or one shares of stock at a time;
* It only allows buying or selling a share of this stock once per day;
* It allows a maximum of k buy orders over the next n days;
For the purposes of this problem, we define a trade to a be the act of buying one share of stock on day i, then holding the stock until some day j > i at which point the share is sold. To restate the above constraints, Manao is permitted to make at most k non-overlapping trades during the course of an n-day trading period for which Manao's model has predictions about the stock price.
Even though these restrictions limit the amount of profit Manao can make compared to what would be achievable with an unlimited number of trades or the ability to hold more than one share at a time, Manao still has the potential to make a lot of money because Manao's model perfectly predicts the daily price of the stock. For example, using this model, Manao could wait until the price is low, then buy one share and hold until the price reaches a high value, then sell for a profit, and repeat this process up to k times until n days have passed.
Nevertheless, Manao is not satisfied by having a merely good trading algorithm, and wants to develop an optimal strategy for trading subject to these constraints. Help Manao achieve this goal by writing a program that will determine when to buy and sell stock to achieve the greatest possible profit during the n-day trading period subject to the above constraints.
Input
The first line contains two integers n and k, separated by a single space, with <image>. The i-th of the following n lines contains a single integer pi (0 β€ pi β€ 1012), where pi represents the price at which someone can either buy or sell one share of stock on day i.
The problem consists of three subproblems. The subproblems have different constraints on the input. You will get some score for the correct submission of the subproblem. The description of the subproblems follows.
* In subproblem F1 (8 points), n will be between 1 and 3000, inclusive.
* In subproblem F2 (15 points), n will be between 1 and 100000, inclusive.
* In subproblem F3 (10 points), n will be between 1 and 4000000, inclusive.
Output
For this problem, the program will only report the amount of the optimal profit, rather than a list of trades that can achieve this profit.
Therefore, the program should print one line containing a single integer, the maximum profit Manao can achieve over the next n days with the constraints of starting with no shares on the first day of trading, always owning either zero or one shares of stock, and buying at most k shares over the course of the n-day trading period.
Examples
Input
10 2
2
7
3
9
8
7
9
7
1
9
Output
15
Input
10 5
2
7
3
9
8
7
9
7
1
9
Output
21
Note
In the first example, the best trade overall is to buy at a price of 1 on day 9 and sell at a price of 9 on day 10 and the second best trade overall is to buy at a price of 2 on day 1 and sell at a price of 9 on day 4. Since these two trades do not overlap, both can be made and the profit is the sum of the profits of the two trades. Thus the trade strategy looks like this:
2 | 7 | 3 | 9 | 8 | 7 | 9 | 7 | 1 | 9
buy | | | sell | | | | | buy | sell
The total profit is then (9 - 2) + (9 - 1) = 15.
In the second example, even though Manao is allowed up to 5 trades there are only 4 profitable trades available. Making a fifth trade would cost Manao money so he only makes the following 4:
2 | 7 | 3 | 9 | 8 | 7 | 9 | 7 | 1 | 9
buy | sell | buy | sell | | buy | sell | | buy | sell
The total profit is then (7 - 2) + (9 - 3) + (9 - 7) + (9 - 1) = 21.
Tags: dp
Correct Solution:
```
import sys
ammount_prices, days_for_trading=map(int, input().split())
stonks=[]
for i in range (0, ammount_prices):
price=int(sys.stdin.readline())
stonks.append(price)
def get_max(days_for_trading, stonks):
size_prices = len(stonks)
if size_prices == 0 or size_prices == 1 or days_for_trading == 0:
return 0
if days_for_trading >= size_prices/2:
profit = 0
for i in range(size_prices-1):
diff = stonks[i + 1] - stonks[i]
if diff > 0:
profit += diff
return profit
hold = days_for_trading * [float('-inf')]
hold_prev = days_for_trading * [float('-inf')]
release = days_for_trading * [float('-inf')]
release_prev = days_for_trading * [float('-inf')]
for price in stonks:
for j in range(0, days_for_trading):
if j == 0:
hold[j] = max(-price, hold_prev[j])
else:
hold[j] = max(release_prev[j - 1] - price, hold_prev[j])
release[j] = max(hold_prev[j] + price, release_prev[j])
hold_prev = hold
release_prev = release
return release[-1]
print(get_max(days_for_trading, stonks))
```
| 338
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem consists of three subproblems: for solving subproblem F1 you will receive 8 points, for solving subproblem F2 you will receive 15 points, and for solving subproblem F3 you will receive 10 points.
Manao has developed a model to predict the stock price of a company over the next n days and wants to design a profit-maximizing trading algorithm to make use of these predictions. Unfortunately, Manao's trading account has the following restrictions:
* It only allows owning either zero or one shares of stock at a time;
* It only allows buying or selling a share of this stock once per day;
* It allows a maximum of k buy orders over the next n days;
For the purposes of this problem, we define a trade to a be the act of buying one share of stock on day i, then holding the stock until some day j > i at which point the share is sold. To restate the above constraints, Manao is permitted to make at most k non-overlapping trades during the course of an n-day trading period for which Manao's model has predictions about the stock price.
Even though these restrictions limit the amount of profit Manao can make compared to what would be achievable with an unlimited number of trades or the ability to hold more than one share at a time, Manao still has the potential to make a lot of money because Manao's model perfectly predicts the daily price of the stock. For example, using this model, Manao could wait until the price is low, then buy one share and hold until the price reaches a high value, then sell for a profit, and repeat this process up to k times until n days have passed.
Nevertheless, Manao is not satisfied by having a merely good trading algorithm, and wants to develop an optimal strategy for trading subject to these constraints. Help Manao achieve this goal by writing a program that will determine when to buy and sell stock to achieve the greatest possible profit during the n-day trading period subject to the above constraints.
Input
The first line contains two integers n and k, separated by a single space, with <image>. The i-th of the following n lines contains a single integer pi (0 β€ pi β€ 1012), where pi represents the price at which someone can either buy or sell one share of stock on day i.
The problem consists of three subproblems. The subproblems have different constraints on the input. You will get some score for the correct submission of the subproblem. The description of the subproblems follows.
* In subproblem F1 (8 points), n will be between 1 and 3000, inclusive.
* In subproblem F2 (15 points), n will be between 1 and 100000, inclusive.
* In subproblem F3 (10 points), n will be between 1 and 4000000, inclusive.
Output
For this problem, the program will only report the amount of the optimal profit, rather than a list of trades that can achieve this profit.
Therefore, the program should print one line containing a single integer, the maximum profit Manao can achieve over the next n days with the constraints of starting with no shares on the first day of trading, always owning either zero or one shares of stock, and buying at most k shares over the course of the n-day trading period.
Examples
Input
10 2
2
7
3
9
8
7
9
7
1
9
Output
15
Input
10 5
2
7
3
9
8
7
9
7
1
9
Output
21
Note
In the first example, the best trade overall is to buy at a price of 1 on day 9 and sell at a price of 9 on day 10 and the second best trade overall is to buy at a price of 2 on day 1 and sell at a price of 9 on day 4. Since these two trades do not overlap, both can be made and the profit is the sum of the profits of the two trades. Thus the trade strategy looks like this:
2 | 7 | 3 | 9 | 8 | 7 | 9 | 7 | 1 | 9
buy | | | sell | | | | | buy | sell
The total profit is then (9 - 2) + (9 - 1) = 15.
In the second example, even though Manao is allowed up to 5 trades there are only 4 profitable trades available. Making a fifth trade would cost Manao money so he only makes the following 4:
2 | 7 | 3 | 9 | 8 | 7 | 9 | 7 | 1 | 9
buy | sell | buy | sell | | buy | sell | | buy | sell
The total profit is then (7 - 2) + (9 - 3) + (9 - 7) + (9 - 1) = 21.
Submitted Solution:
```
import sys
best_profit=0
def get_numered_list():
damn=list(map(int, sys.stdin.readline().split()))
ammount_prices=damn[0]
days_for_trading=damn[1]
stonks=[]
for i in range (0, ammount_prices):
price=int(sys.stdin.readline())
stonks.append(price)
stonks=list(enumerate(stonks))
tmp=[]
for i in range (0,len(stonks)):
for d, b in stonks:
if b>stonks[i][1] and d>i:
high=b
low=stonks[i][1]
buy=high-low
register_deal=(i, d, buy)
tmp.append(register_deal)
return get_max(sorted(tmp, key=lambda x:x [2], reverse=True), days_for_trading)
def get_max(tmp, days_for_trading):
global best_profit
for day_start, day_end, price in tmp:
traiding_sequence=[]
cur_profit=0
count=0
deal=(day_start, day_end, price)
traiding_sequence.append(deal)
cur_profit+=price
for next_day_start, next_day_end, next_price in tmp:
if days_for_trading==len(traiding_sequence):
break
else:
if next_day_start>traiding_sequence[count][1]:
next_deal=(next_day_start, next_day_end, next_price)
traiding_sequence.append(next_deal)
cur_profit+=next_price
count+=1
best_profit=cur_profit if cur_profit>best_profit else best_profit
get_numered_list()
print(best_profit)
```
No
| 339
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem consists of three subproblems: for solving subproblem F1 you will receive 8 points, for solving subproblem F2 you will receive 15 points, and for solving subproblem F3 you will receive 10 points.
Manao has developed a model to predict the stock price of a company over the next n days and wants to design a profit-maximizing trading algorithm to make use of these predictions. Unfortunately, Manao's trading account has the following restrictions:
* It only allows owning either zero or one shares of stock at a time;
* It only allows buying or selling a share of this stock once per day;
* It allows a maximum of k buy orders over the next n days;
For the purposes of this problem, we define a trade to a be the act of buying one share of stock on day i, then holding the stock until some day j > i at which point the share is sold. To restate the above constraints, Manao is permitted to make at most k non-overlapping trades during the course of an n-day trading period for which Manao's model has predictions about the stock price.
Even though these restrictions limit the amount of profit Manao can make compared to what would be achievable with an unlimited number of trades or the ability to hold more than one share at a time, Manao still has the potential to make a lot of money because Manao's model perfectly predicts the daily price of the stock. For example, using this model, Manao could wait until the price is low, then buy one share and hold until the price reaches a high value, then sell for a profit, and repeat this process up to k times until n days have passed.
Nevertheless, Manao is not satisfied by having a merely good trading algorithm, and wants to develop an optimal strategy for trading subject to these constraints. Help Manao achieve this goal by writing a program that will determine when to buy and sell stock to achieve the greatest possible profit during the n-day trading period subject to the above constraints.
Input
The first line contains two integers n and k, separated by a single space, with <image>. The i-th of the following n lines contains a single integer pi (0 β€ pi β€ 1012), where pi represents the price at which someone can either buy or sell one share of stock on day i.
The problem consists of three subproblems. The subproblems have different constraints on the input. You will get some score for the correct submission of the subproblem. The description of the subproblems follows.
* In subproblem F1 (8 points), n will be between 1 and 3000, inclusive.
* In subproblem F2 (15 points), n will be between 1 and 100000, inclusive.
* In subproblem F3 (10 points), n will be between 1 and 4000000, inclusive.
Output
For this problem, the program will only report the amount of the optimal profit, rather than a list of trades that can achieve this profit.
Therefore, the program should print one line containing a single integer, the maximum profit Manao can achieve over the next n days with the constraints of starting with no shares on the first day of trading, always owning either zero or one shares of stock, and buying at most k shares over the course of the n-day trading period.
Examples
Input
10 2
2
7
3
9
8
7
9
7
1
9
Output
15
Input
10 5
2
7
3
9
8
7
9
7
1
9
Output
21
Note
In the first example, the best trade overall is to buy at a price of 1 on day 9 and sell at a price of 9 on day 10 and the second best trade overall is to buy at a price of 2 on day 1 and sell at a price of 9 on day 4. Since these two trades do not overlap, both can be made and the profit is the sum of the profits of the two trades. Thus the trade strategy looks like this:
2 | 7 | 3 | 9 | 8 | 7 | 9 | 7 | 1 | 9
buy | | | sell | | | | | buy | sell
The total profit is then (9 - 2) + (9 - 1) = 15.
In the second example, even though Manao is allowed up to 5 trades there are only 4 profitable trades available. Making a fifth trade would cost Manao money so he only makes the following 4:
2 | 7 | 3 | 9 | 8 | 7 | 9 | 7 | 1 | 9
buy | sell | buy | sell | | buy | sell | | buy | sell
The total profit is then (7 - 2) + (9 - 3) + (9 - 7) + (9 - 1) = 21.
Submitted Solution:
```
import sys
best_profit=0
def get_numered_list():
damn=list(map(int, sys.stdin.readline().split()))
ammount_prices=damn[0]
days_for_trading=damn[1]
stonks=[]
for i in range (0, ammount_prices):
price=int(sys.stdin.readline())
stonks.append(price)
stonks=list(enumerate(stonks))
tmp=[]
for i in range (0,len(stonks)):
for d, b in stonks:
if b>stonks[i][1] and d>i:
high=b
low=stonks[i][1]
buy=high-low
register_deal=(i, d, buy)
tmp.append(register_deal)
return get_max(sorted(tmp, key=lambda x:x [2], reverse=True), days_for_trading)
def get_max(tmp, days_for_trading):
global best_profit
for day_start, day_end, price in tmp:
traiding_sequence=[]
cur_profit=0
count=0
deal=(day_start, day_end, price)
traiding_sequence.append(deal)
cur_profit+=price
for next_day_start, next_day_end, next_price in tmp:
if days_for_trading==len(traiding_sequence):
break
else:
if next_day_start>traiding_sequence[count][1]:
next_deal=(next_day_start, next_day_end, next_price)
traiding_sequence.append(next_deal)
cur_profit+=next_price
count+=1
best_profit=cur_profit if cur_profit>best_profit else best_profit
get_numered_list()
print("profit",best_profit)
```
No
| 340
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem consists of three subproblems: for solving subproblem F1 you will receive 8 points, for solving subproblem F2 you will receive 15 points, and for solving subproblem F3 you will receive 10 points.
Manao has developed a model to predict the stock price of a company over the next n days and wants to design a profit-maximizing trading algorithm to make use of these predictions. Unfortunately, Manao's trading account has the following restrictions:
* It only allows owning either zero or one shares of stock at a time;
* It only allows buying or selling a share of this stock once per day;
* It allows a maximum of k buy orders over the next n days;
For the purposes of this problem, we define a trade to a be the act of buying one share of stock on day i, then holding the stock until some day j > i at which point the share is sold. To restate the above constraints, Manao is permitted to make at most k non-overlapping trades during the course of an n-day trading period for which Manao's model has predictions about the stock price.
Even though these restrictions limit the amount of profit Manao can make compared to what would be achievable with an unlimited number of trades or the ability to hold more than one share at a time, Manao still has the potential to make a lot of money because Manao's model perfectly predicts the daily price of the stock. For example, using this model, Manao could wait until the price is low, then buy one share and hold until the price reaches a high value, then sell for a profit, and repeat this process up to k times until n days have passed.
Nevertheless, Manao is not satisfied by having a merely good trading algorithm, and wants to develop an optimal strategy for trading subject to these constraints. Help Manao achieve this goal by writing a program that will determine when to buy and sell stock to achieve the greatest possible profit during the n-day trading period subject to the above constraints.
Input
The first line contains two integers n and k, separated by a single space, with <image>. The i-th of the following n lines contains a single integer pi (0 β€ pi β€ 1012), where pi represents the price at which someone can either buy or sell one share of stock on day i.
The problem consists of three subproblems. The subproblems have different constraints on the input. You will get some score for the correct submission of the subproblem. The description of the subproblems follows.
* In subproblem F1 (8 points), n will be between 1 and 3000, inclusive.
* In subproblem F2 (15 points), n will be between 1 and 100000, inclusive.
* In subproblem F3 (10 points), n will be between 1 and 4000000, inclusive.
Output
For this problem, the program will only report the amount of the optimal profit, rather than a list of trades that can achieve this profit.
Therefore, the program should print one line containing a single integer, the maximum profit Manao can achieve over the next n days with the constraints of starting with no shares on the first day of trading, always owning either zero or one shares of stock, and buying at most k shares over the course of the n-day trading period.
Examples
Input
10 2
2
7
3
9
8
7
9
7
1
9
Output
15
Input
10 5
2
7
3
9
8
7
9
7
1
9
Output
21
Note
In the first example, the best trade overall is to buy at a price of 1 on day 9 and sell at a price of 9 on day 10 and the second best trade overall is to buy at a price of 2 on day 1 and sell at a price of 9 on day 4. Since these two trades do not overlap, both can be made and the profit is the sum of the profits of the two trades. Thus the trade strategy looks like this:
2 | 7 | 3 | 9 | 8 | 7 | 9 | 7 | 1 | 9
buy | | | sell | | | | | buy | sell
The total profit is then (9 - 2) + (9 - 1) = 15.
In the second example, even though Manao is allowed up to 5 trades there are only 4 profitable trades available. Making a fifth trade would cost Manao money so he only makes the following 4:
2 | 7 | 3 | 9 | 8 | 7 | 9 | 7 | 1 | 9
buy | sell | buy | sell | | buy | sell | | buy | sell
The total profit is then (7 - 2) + (9 - 3) + (9 - 7) + (9 - 1) = 21.
Submitted Solution:
```
import heapq
def algo(arr,elem):
start = 0
end = len(arr)-1
index = 0
while start < end:
mid = (start+end)//2
if arr[start] <= elem and arr[start+1] >= elem:
index = start+1
break
elif elem > arr[start] and elem > arr[start+1]:
start = mid
elif elem < arr[start] and elem < arr[start+1]:
end = mid+1
for i in range(index,len(arr)):
arr[index]
return index
(n,k)=map(int,input().split())
arr=[]
transactions=[]
profit=[]
max_profit=0
buy=0
sell=0
heapq.heapify(profit)
for i in range(n):
arr.append(int(input()))
while sell<n:
buy=sell
while buy<n-1 and arr[buy]>=arr[buy+1]:
buy+=1
sell=buy+1
while sell<n and arr[sell]>=arr[sell-1]:
sell+=1
while transactions and arr[buy]<arr[transactions[-1][0]]:
x=transactions[-1]
#profit.append(arr[x[1]-1]-arr[x[0]])
heapq.heappush(profit,arr[x[1]-1]-arr[x[0]])
transactions.pop()
#profit.sort()
while transactions and arr[sell-1]>arr[transactions[-1][1]-1]:
x=transactions[-1]
heapq.heappush(profit,(arr[x[1]-1]-arr[buy]))
buy=x[0]
transactions.pop()
transactions.append([buy,sell])
#profit.sort()
for y in transactions:
heapq.heappush(profit,(arr[y[1]-1]-arr[y[0]]))
while k and profit:
max_profit+=profit.pop()
k-=1
print(max_profit)
# arr = [1,2,3,4,7]
# r = algo(arr,5)
# print(r)
# arrs = [1,2,4,5,3]
# a = {}
# for i in arrs:
# a[i] = 1
# print(a)
```
No
| 341
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem consists of three subproblems: for solving subproblem F1 you will receive 8 points, for solving subproblem F2 you will receive 15 points, and for solving subproblem F3 you will receive 10 points.
Manao has developed a model to predict the stock price of a company over the next n days and wants to design a profit-maximizing trading algorithm to make use of these predictions. Unfortunately, Manao's trading account has the following restrictions:
* It only allows owning either zero or one shares of stock at a time;
* It only allows buying or selling a share of this stock once per day;
* It allows a maximum of k buy orders over the next n days;
For the purposes of this problem, we define a trade to a be the act of buying one share of stock on day i, then holding the stock until some day j > i at which point the share is sold. To restate the above constraints, Manao is permitted to make at most k non-overlapping trades during the course of an n-day trading period for which Manao's model has predictions about the stock price.
Even though these restrictions limit the amount of profit Manao can make compared to what would be achievable with an unlimited number of trades or the ability to hold more than one share at a time, Manao still has the potential to make a lot of money because Manao's model perfectly predicts the daily price of the stock. For example, using this model, Manao could wait until the price is low, then buy one share and hold until the price reaches a high value, then sell for a profit, and repeat this process up to k times until n days have passed.
Nevertheless, Manao is not satisfied by having a merely good trading algorithm, and wants to develop an optimal strategy for trading subject to these constraints. Help Manao achieve this goal by writing a program that will determine when to buy and sell stock to achieve the greatest possible profit during the n-day trading period subject to the above constraints.
Input
The first line contains two integers n and k, separated by a single space, with <image>. The i-th of the following n lines contains a single integer pi (0 β€ pi β€ 1012), where pi represents the price at which someone can either buy or sell one share of stock on day i.
The problem consists of three subproblems. The subproblems have different constraints on the input. You will get some score for the correct submission of the subproblem. The description of the subproblems follows.
* In subproblem F1 (8 points), n will be between 1 and 3000, inclusive.
* In subproblem F2 (15 points), n will be between 1 and 100000, inclusive.
* In subproblem F3 (10 points), n will be between 1 and 4000000, inclusive.
Output
For this problem, the program will only report the amount of the optimal profit, rather than a list of trades that can achieve this profit.
Therefore, the program should print one line containing a single integer, the maximum profit Manao can achieve over the next n days with the constraints of starting with no shares on the first day of trading, always owning either zero or one shares of stock, and buying at most k shares over the course of the n-day trading period.
Examples
Input
10 2
2
7
3
9
8
7
9
7
1
9
Output
15
Input
10 5
2
7
3
9
8
7
9
7
1
9
Output
21
Note
In the first example, the best trade overall is to buy at a price of 1 on day 9 and sell at a price of 9 on day 10 and the second best trade overall is to buy at a price of 2 on day 1 and sell at a price of 9 on day 4. Since these two trades do not overlap, both can be made and the profit is the sum of the profits of the two trades. Thus the trade strategy looks like this:
2 | 7 | 3 | 9 | 8 | 7 | 9 | 7 | 1 | 9
buy | | | sell | | | | | buy | sell
The total profit is then (9 - 2) + (9 - 1) = 15.
In the second example, even though Manao is allowed up to 5 trades there are only 4 profitable trades available. Making a fifth trade would cost Manao money so he only makes the following 4:
2 | 7 | 3 | 9 | 8 | 7 | 9 | 7 | 1 | 9
buy | sell | buy | sell | | buy | sell | | buy | sell
The total profit is then (7 - 2) + (9 - 3) + (9 - 7) + (9 - 1) = 21.
Submitted Solution:
```
(n,k)=map(int,input().split())
arr=[]
transactions=[]
profit=[]
max_profit=0
buy=0
sell=0
for i in range(n):
arr.append(int(input()))
while sell<n:
buy=sell
while buy<n-1 and arr[buy]>=arr[buy+1]:
buy+=1
sell=buy+1
while sell<n and arr[sell]>=arr[sell-1]:
sell+=1
while transactions and arr[buy]<arr[transactions[-1][0]]:
x=transactions[-1]
profit.append(arr[x[1]-1]-arr[x[0]])
transactions.pop()
#profit.sort(reverse=True)
while transactions and arr[sell-1]>arr[transactions[-1][1]-1]:
x=transactions[-1]
profit.append(arr[x[1]-1]-arr[buy])
buy=x[0]
transactions.pop()
transactions.append([buy,sell])
profit.sort()
for y in transactions:
profit.append(arr[y[1]-1]-arr[y[0]])
while k and profit:
max_profit+=profit.pop()
k-=1
print(max_profit)
```
No
| 342
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Valera loves his garden, where n fruit trees grow.
This year he will enjoy a great harvest! On the i-th tree bi fruit grow, they will ripen on a day number ai. Unfortunately, the fruit on the tree get withered, so they can only be collected on day ai and day ai + 1 (all fruits that are not collected in these two days, become unfit to eat).
Valera is not very fast, but there are some positive points. Valera is ready to work every day. In one day, Valera can collect no more than v fruits. The fruits may be either from the same tree, or from different ones. What is the maximum amount of fruit Valera can collect for all time, if he operates optimally well?
Input
The first line contains two space-separated integers n and v (1 β€ n, v β€ 3000) β the number of fruit trees in the garden and the number of fruits that Valera can collect in a day.
Next n lines contain the description of trees in the garden. The i-th line contains two space-separated integers ai and bi (1 β€ ai, bi β€ 3000) β the day the fruits ripen on the i-th tree and the number of fruits on the i-th tree.
Output
Print a single integer β the maximum number of fruit that Valera can collect.
Examples
Input
2 3
1 5
2 3
Output
8
Input
5 10
3 20
2 20
1 20
4 20
5 20
Output
60
Note
In the first sample, in order to obtain the optimal answer, you should act as follows.
* On the first day collect 3 fruits from the 1-st tree.
* On the second day collect 1 fruit from the 2-nd tree and 2 fruits from the 1-st tree.
* On the third day collect the remaining fruits from the 2-nd tree.
In the second sample, you can only collect 60 fruits, the remaining fruit will simply wither.
Tags: greedy, implementation
Correct Solution:
```
MOD = 1000000007
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
n,v=f()
l=[0]*3003
for _ in range(n):
a,b=f()
l[a]+=b
fromprevDay=0
currDay=0
temp=0
ans=0
for i in range(1,3002):
currDay=l[i]
if fromprevDay+currDay<=v:
ans+=fromprevDay+currDay
fromprevDay=0
elif fromprevDay>=v:
ans+=v
fromprevDay=currDay
else:
ans+=v
temp=v-fromprevDay
fromprevDay=currDay-temp
print(ans)
```
| 343
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Valera loves his garden, where n fruit trees grow.
This year he will enjoy a great harvest! On the i-th tree bi fruit grow, they will ripen on a day number ai. Unfortunately, the fruit on the tree get withered, so they can only be collected on day ai and day ai + 1 (all fruits that are not collected in these two days, become unfit to eat).
Valera is not very fast, but there are some positive points. Valera is ready to work every day. In one day, Valera can collect no more than v fruits. The fruits may be either from the same tree, or from different ones. What is the maximum amount of fruit Valera can collect for all time, if he operates optimally well?
Input
The first line contains two space-separated integers n and v (1 β€ n, v β€ 3000) β the number of fruit trees in the garden and the number of fruits that Valera can collect in a day.
Next n lines contain the description of trees in the garden. The i-th line contains two space-separated integers ai and bi (1 β€ ai, bi β€ 3000) β the day the fruits ripen on the i-th tree and the number of fruits on the i-th tree.
Output
Print a single integer β the maximum number of fruit that Valera can collect.
Examples
Input
2 3
1 5
2 3
Output
8
Input
5 10
3 20
2 20
1 20
4 20
5 20
Output
60
Note
In the first sample, in order to obtain the optimal answer, you should act as follows.
* On the first day collect 3 fruits from the 1-st tree.
* On the second day collect 1 fruit from the 2-nd tree and 2 fruits from the 1-st tree.
* On the third day collect the remaining fruits from the 2-nd tree.
In the second sample, you can only collect 60 fruits, the remaining fruit will simply wither.
Tags: greedy, implementation
Correct Solution:
```
n,v=map(int, input().split())
b=[0]*3002
for _ in range(n):
a = list(map(int,input().split()))
b[a[0]]+=a[1]
s = 0
for i in range(1,3002):
r=v
t=min(r,b[i-1])
s+=t
r-=t
b[i-1]-=t
t=min(r, b[i])
s+=t
r-=t
b[i]-=t
print(s)
```
| 344
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Valera loves his garden, where n fruit trees grow.
This year he will enjoy a great harvest! On the i-th tree bi fruit grow, they will ripen on a day number ai. Unfortunately, the fruit on the tree get withered, so they can only be collected on day ai and day ai + 1 (all fruits that are not collected in these two days, become unfit to eat).
Valera is not very fast, but there are some positive points. Valera is ready to work every day. In one day, Valera can collect no more than v fruits. The fruits may be either from the same tree, or from different ones. What is the maximum amount of fruit Valera can collect for all time, if he operates optimally well?
Input
The first line contains two space-separated integers n and v (1 β€ n, v β€ 3000) β the number of fruit trees in the garden and the number of fruits that Valera can collect in a day.
Next n lines contain the description of trees in the garden. The i-th line contains two space-separated integers ai and bi (1 β€ ai, bi β€ 3000) β the day the fruits ripen on the i-th tree and the number of fruits on the i-th tree.
Output
Print a single integer β the maximum number of fruit that Valera can collect.
Examples
Input
2 3
1 5
2 3
Output
8
Input
5 10
3 20
2 20
1 20
4 20
5 20
Output
60
Note
In the first sample, in order to obtain the optimal answer, you should act as follows.
* On the first day collect 3 fruits from the 1-st tree.
* On the second day collect 1 fruit from the 2-nd tree and 2 fruits from the 1-st tree.
* On the third day collect the remaining fruits from the 2-nd tree.
In the second sample, you can only collect 60 fruits, the remaining fruit will simply wither.
Tags: greedy, implementation
Correct Solution:
```
import sys
import math
n, v = [int(x) for x in (sys.stdin.readline()).split()]
k = [0] * 3002
for i in range(n):
a, b = [int(x) for x in (sys.stdin.readline()).split()]
k[a] += b
i = 1
res = 0
while(i <= 3001):
val = 0
if(k[i - 1] < v):
val = k[i - 1]
res += val
d = v - val
if(k[i] < d):
res += k[i]
k[i] = 0
else:
res += d
k[i] = k[i] - d
else:
res += v
i += 1
print(res)
```
| 345
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Valera loves his garden, where n fruit trees grow.
This year he will enjoy a great harvest! On the i-th tree bi fruit grow, they will ripen on a day number ai. Unfortunately, the fruit on the tree get withered, so they can only be collected on day ai and day ai + 1 (all fruits that are not collected in these two days, become unfit to eat).
Valera is not very fast, but there are some positive points. Valera is ready to work every day. In one day, Valera can collect no more than v fruits. The fruits may be either from the same tree, or from different ones. What is the maximum amount of fruit Valera can collect for all time, if he operates optimally well?
Input
The first line contains two space-separated integers n and v (1 β€ n, v β€ 3000) β the number of fruit trees in the garden and the number of fruits that Valera can collect in a day.
Next n lines contain the description of trees in the garden. The i-th line contains two space-separated integers ai and bi (1 β€ ai, bi β€ 3000) β the day the fruits ripen on the i-th tree and the number of fruits on the i-th tree.
Output
Print a single integer β the maximum number of fruit that Valera can collect.
Examples
Input
2 3
1 5
2 3
Output
8
Input
5 10
3 20
2 20
1 20
4 20
5 20
Output
60
Note
In the first sample, in order to obtain the optimal answer, you should act as follows.
* On the first day collect 3 fruits from the 1-st tree.
* On the second day collect 1 fruit from the 2-nd tree and 2 fruits from the 1-st tree.
* On the third day collect the remaining fruits from the 2-nd tree.
In the second sample, you can only collect 60 fruits, the remaining fruit will simply wither.
Tags: greedy, implementation
Correct Solution:
```
n, v = map(int, input().split())
d, s = {}, 0
for i in range(n):
a, b = map(int, input().split())
d[a] = d.get(a, 0) + b
s += b
r = v
for i in sorted(d.keys()):
d[i] -= min(d[i], r)
r, b = v, min(d[i], v)
d[i] -= b
if i+1 in d:
r -= b
print(s - sum(d.values()))
```
| 346
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Valera loves his garden, where n fruit trees grow.
This year he will enjoy a great harvest! On the i-th tree bi fruit grow, they will ripen on a day number ai. Unfortunately, the fruit on the tree get withered, so they can only be collected on day ai and day ai + 1 (all fruits that are not collected in these two days, become unfit to eat).
Valera is not very fast, but there are some positive points. Valera is ready to work every day. In one day, Valera can collect no more than v fruits. The fruits may be either from the same tree, or from different ones. What is the maximum amount of fruit Valera can collect for all time, if he operates optimally well?
Input
The first line contains two space-separated integers n and v (1 β€ n, v β€ 3000) β the number of fruit trees in the garden and the number of fruits that Valera can collect in a day.
Next n lines contain the description of trees in the garden. The i-th line contains two space-separated integers ai and bi (1 β€ ai, bi β€ 3000) β the day the fruits ripen on the i-th tree and the number of fruits on the i-th tree.
Output
Print a single integer β the maximum number of fruit that Valera can collect.
Examples
Input
2 3
1 5
2 3
Output
8
Input
5 10
3 20
2 20
1 20
4 20
5 20
Output
60
Note
In the first sample, in order to obtain the optimal answer, you should act as follows.
* On the first day collect 3 fruits from the 1-st tree.
* On the second day collect 1 fruit from the 2-nd tree and 2 fruits from the 1-st tree.
* On the third day collect the remaining fruits from the 2-nd tree.
In the second sample, you can only collect 60 fruits, the remaining fruit will simply wither.
Tags: greedy, implementation
Correct Solution:
```
from collections import defaultdict
dd = defaultdict(int)
n, v = map(int, input().split())
def foo(day, toadd):
z = 0
if(newDD[day]<toadd):
z+=newDD[day]
newDD[day] = 0
else:
z+=toadd
newDD[day]-=toadd
return z
for _ in range(n):
temp1, temp2 = map(int, input().split())
dd[temp1]+=temp2
newDD = dict(sorted(dd.items()))
# print(newDD)
ans = 0
mxday = max(newDD.keys())
for key in range(1, mxday+2):
V = v
if((key-1) in newDD):
if(newDD[key-1]>0):
temp=foo(key-1, V)
V-=temp
ans+=temp
if(key in newDD):
if(V>0):
ans+=foo(key, V)
print(ans)
```
| 347
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Valera loves his garden, where n fruit trees grow.
This year he will enjoy a great harvest! On the i-th tree bi fruit grow, they will ripen on a day number ai. Unfortunately, the fruit on the tree get withered, so they can only be collected on day ai and day ai + 1 (all fruits that are not collected in these two days, become unfit to eat).
Valera is not very fast, but there are some positive points. Valera is ready to work every day. In one day, Valera can collect no more than v fruits. The fruits may be either from the same tree, or from different ones. What is the maximum amount of fruit Valera can collect for all time, if he operates optimally well?
Input
The first line contains two space-separated integers n and v (1 β€ n, v β€ 3000) β the number of fruit trees in the garden and the number of fruits that Valera can collect in a day.
Next n lines contain the description of trees in the garden. The i-th line contains two space-separated integers ai and bi (1 β€ ai, bi β€ 3000) β the day the fruits ripen on the i-th tree and the number of fruits on the i-th tree.
Output
Print a single integer β the maximum number of fruit that Valera can collect.
Examples
Input
2 3
1 5
2 3
Output
8
Input
5 10
3 20
2 20
1 20
4 20
5 20
Output
60
Note
In the first sample, in order to obtain the optimal answer, you should act as follows.
* On the first day collect 3 fruits from the 1-st tree.
* On the second day collect 1 fruit from the 2-nd tree and 2 fruits from the 1-st tree.
* On the third day collect the remaining fruits from the 2-nd tree.
In the second sample, you can only collect 60 fruits, the remaining fruit will simply wither.
Tags: greedy, implementation
Correct Solution:
```
n, v = map(int, input().split(' '))
trees = dict()
count = 0
b_last = 0
for i in range(n):
a, b = map(int, input().split(' '))
if trees.get(a):
trees[a] += b
else:
trees[a] = b
m = max(trees.keys())
for i in range(1, m+2):
if trees.get(i):
k = min(v, b_last)
count += k
k1 = min(v - k, trees[i])
count += k1
b_last = trees[i] - k1
else:
count += min(v, b_last)
b_last = 0
print(count)
```
| 348
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Valera loves his garden, where n fruit trees grow.
This year he will enjoy a great harvest! On the i-th tree bi fruit grow, they will ripen on a day number ai. Unfortunately, the fruit on the tree get withered, so they can only be collected on day ai and day ai + 1 (all fruits that are not collected in these two days, become unfit to eat).
Valera is not very fast, but there are some positive points. Valera is ready to work every day. In one day, Valera can collect no more than v fruits. The fruits may be either from the same tree, or from different ones. What is the maximum amount of fruit Valera can collect for all time, if he operates optimally well?
Input
The first line contains two space-separated integers n and v (1 β€ n, v β€ 3000) β the number of fruit trees in the garden and the number of fruits that Valera can collect in a day.
Next n lines contain the description of trees in the garden. The i-th line contains two space-separated integers ai and bi (1 β€ ai, bi β€ 3000) β the day the fruits ripen on the i-th tree and the number of fruits on the i-th tree.
Output
Print a single integer β the maximum number of fruit that Valera can collect.
Examples
Input
2 3
1 5
2 3
Output
8
Input
5 10
3 20
2 20
1 20
4 20
5 20
Output
60
Note
In the first sample, in order to obtain the optimal answer, you should act as follows.
* On the first day collect 3 fruits from the 1-st tree.
* On the second day collect 1 fruit from the 2-nd tree and 2 fruits from the 1-st tree.
* On the third day collect the remaining fruits from the 2-nd tree.
In the second sample, you can only collect 60 fruits, the remaining fruit will simply wither.
Tags: greedy, implementation
Correct Solution:
```
def main():
n,m = map(int,input().split())
a = []
b = []
for _ in range(n):
a1,b1 = map(int,input().split())
a.append(a1)
b.append(b1)
prev = 0
tv = 0
ans = 0
for i in range(1,3002):
curr = 0
for j in range(n):
if a[j]==i:
curr+=b[j]
if curr+prev<=m:
ans += prev+curr
prev = 0
else:
ans += m
tv = m - prev
if tv<0:
tv = 0
prev = curr-tv
print(ans)
return
main()
```
| 349
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Valera loves his garden, where n fruit trees grow.
This year he will enjoy a great harvest! On the i-th tree bi fruit grow, they will ripen on a day number ai. Unfortunately, the fruit on the tree get withered, so they can only be collected on day ai and day ai + 1 (all fruits that are not collected in these two days, become unfit to eat).
Valera is not very fast, but there are some positive points. Valera is ready to work every day. In one day, Valera can collect no more than v fruits. The fruits may be either from the same tree, or from different ones. What is the maximum amount of fruit Valera can collect for all time, if he operates optimally well?
Input
The first line contains two space-separated integers n and v (1 β€ n, v β€ 3000) β the number of fruit trees in the garden and the number of fruits that Valera can collect in a day.
Next n lines contain the description of trees in the garden. The i-th line contains two space-separated integers ai and bi (1 β€ ai, bi β€ 3000) β the day the fruits ripen on the i-th tree and the number of fruits on the i-th tree.
Output
Print a single integer β the maximum number of fruit that Valera can collect.
Examples
Input
2 3
1 5
2 3
Output
8
Input
5 10
3 20
2 20
1 20
4 20
5 20
Output
60
Note
In the first sample, in order to obtain the optimal answer, you should act as follows.
* On the first day collect 3 fruits from the 1-st tree.
* On the second day collect 1 fruit from the 2-nd tree and 2 fruits from the 1-st tree.
* On the third day collect the remaining fruits from the 2-nd tree.
In the second sample, you can only collect 60 fruits, the remaining fruit will simply wither.
Tags: greedy, implementation
Correct Solution:
```
n,v = [int(i) for i in input().split()]
f = 0
l = [0]*3002
for i in range(n):
a,b = [int(i) for i in input().split()]
l[a] += b
for i in range(1,3002):
pick = min(v,l[i-1])
l[i-1] -= pick
pick2 = min(v-pick,l[i])
l[i] -= pick2
f += pick + pick2
print(f)
```
| 350
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera loves his garden, where n fruit trees grow.
This year he will enjoy a great harvest! On the i-th tree bi fruit grow, they will ripen on a day number ai. Unfortunately, the fruit on the tree get withered, so they can only be collected on day ai and day ai + 1 (all fruits that are not collected in these two days, become unfit to eat).
Valera is not very fast, but there are some positive points. Valera is ready to work every day. In one day, Valera can collect no more than v fruits. The fruits may be either from the same tree, or from different ones. What is the maximum amount of fruit Valera can collect for all time, if he operates optimally well?
Input
The first line contains two space-separated integers n and v (1 β€ n, v β€ 3000) β the number of fruit trees in the garden and the number of fruits that Valera can collect in a day.
Next n lines contain the description of trees in the garden. The i-th line contains two space-separated integers ai and bi (1 β€ ai, bi β€ 3000) β the day the fruits ripen on the i-th tree and the number of fruits on the i-th tree.
Output
Print a single integer β the maximum number of fruit that Valera can collect.
Examples
Input
2 3
1 5
2 3
Output
8
Input
5 10
3 20
2 20
1 20
4 20
5 20
Output
60
Note
In the first sample, in order to obtain the optimal answer, you should act as follows.
* On the first day collect 3 fruits from the 1-st tree.
* On the second day collect 1 fruit from the 2-nd tree and 2 fruits from the 1-st tree.
* On the third day collect the remaining fruits from the 2-nd tree.
In the second sample, you can only collect 60 fruits, the remaining fruit will simply wither.
Submitted Solution:
```
def main() :
R = lambda : map(int, input().split())
n, v = R()
mlist = [0] * 3003
for i in range(n) :
a, b = R()
mlist[a] += b
mlist2 = mlist[:]
ans = 0
for i in range(1, 3002) :
tmp = min(v, mlist[i])
ans += tmp
mlist[i + 1] += min(mlist[i] - tmp, mlist2[i])
print(ans)
if __name__ == "__main__" :
main()
```
Yes
| 351
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera loves his garden, where n fruit trees grow.
This year he will enjoy a great harvest! On the i-th tree bi fruit grow, they will ripen on a day number ai. Unfortunately, the fruit on the tree get withered, so they can only be collected on day ai and day ai + 1 (all fruits that are not collected in these two days, become unfit to eat).
Valera is not very fast, but there are some positive points. Valera is ready to work every day. In one day, Valera can collect no more than v fruits. The fruits may be either from the same tree, or from different ones. What is the maximum amount of fruit Valera can collect for all time, if he operates optimally well?
Input
The first line contains two space-separated integers n and v (1 β€ n, v β€ 3000) β the number of fruit trees in the garden and the number of fruits that Valera can collect in a day.
Next n lines contain the description of trees in the garden. The i-th line contains two space-separated integers ai and bi (1 β€ ai, bi β€ 3000) β the day the fruits ripen on the i-th tree and the number of fruits on the i-th tree.
Output
Print a single integer β the maximum number of fruit that Valera can collect.
Examples
Input
2 3
1 5
2 3
Output
8
Input
5 10
3 20
2 20
1 20
4 20
5 20
Output
60
Note
In the first sample, in order to obtain the optimal answer, you should act as follows.
* On the first day collect 3 fruits from the 1-st tree.
* On the second day collect 1 fruit from the 2-nd tree and 2 fruits from the 1-st tree.
* On the third day collect the remaining fruits from the 2-nd tree.
In the second sample, you can only collect 60 fruits, the remaining fruit will simply wither.
Submitted Solution:
```
n,v = map(int, input().split())
arr = [0]*3002
for _ in range(n):
a,b = map(int, input().split())
arr[a] += b
x = v
ans = 0
prev = 0
for i in range(1,3002):
x = max(x-prev,0)
ans += (v-x)
if arr[i]<=x:
ans += arr[i]
prev = 0
else:
ans += x
prev = arr[i]-x
x = v
print(ans)
```
Yes
| 352
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera loves his garden, where n fruit trees grow.
This year he will enjoy a great harvest! On the i-th tree bi fruit grow, they will ripen on a day number ai. Unfortunately, the fruit on the tree get withered, so they can only be collected on day ai and day ai + 1 (all fruits that are not collected in these two days, become unfit to eat).
Valera is not very fast, but there are some positive points. Valera is ready to work every day. In one day, Valera can collect no more than v fruits. The fruits may be either from the same tree, or from different ones. What is the maximum amount of fruit Valera can collect for all time, if he operates optimally well?
Input
The first line contains two space-separated integers n and v (1 β€ n, v β€ 3000) β the number of fruit trees in the garden and the number of fruits that Valera can collect in a day.
Next n lines contain the description of trees in the garden. The i-th line contains two space-separated integers ai and bi (1 β€ ai, bi β€ 3000) β the day the fruits ripen on the i-th tree and the number of fruits on the i-th tree.
Output
Print a single integer β the maximum number of fruit that Valera can collect.
Examples
Input
2 3
1 5
2 3
Output
8
Input
5 10
3 20
2 20
1 20
4 20
5 20
Output
60
Note
In the first sample, in order to obtain the optimal answer, you should act as follows.
* On the first day collect 3 fruits from the 1-st tree.
* On the second day collect 1 fruit from the 2-nd tree and 2 fruits from the 1-st tree.
* On the third day collect the remaining fruits from the 2-nd tree.
In the second sample, you can only collect 60 fruits, the remaining fruit will simply wither.
Submitted Solution:
```
#pyrival orz
import os
import sys
from io import BytesIO, IOBase
input = sys.stdin.readline
############ ---- Input Functions ---- ############
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
def main():
try:
n, v = invr()
a = [0]*(3002)
for i in range(n):
x, y = invr()
a[x] += y
ans = 0
prev = 0
for i in range(1, 3002):
curr = a[i]
if curr + prev <= v:
ans += curr + prev
curr = 0
else:
ans += v
if prev < v:
curr -= v - prev
prev = curr
print(ans)
except Exception as e:
print(e)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
```
Yes
| 353
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera loves his garden, where n fruit trees grow.
This year he will enjoy a great harvest! On the i-th tree bi fruit grow, they will ripen on a day number ai. Unfortunately, the fruit on the tree get withered, so they can only be collected on day ai and day ai + 1 (all fruits that are not collected in these two days, become unfit to eat).
Valera is not very fast, but there are some positive points. Valera is ready to work every day. In one day, Valera can collect no more than v fruits. The fruits may be either from the same tree, or from different ones. What is the maximum amount of fruit Valera can collect for all time, if he operates optimally well?
Input
The first line contains two space-separated integers n and v (1 β€ n, v β€ 3000) β the number of fruit trees in the garden and the number of fruits that Valera can collect in a day.
Next n lines contain the description of trees in the garden. The i-th line contains two space-separated integers ai and bi (1 β€ ai, bi β€ 3000) β the day the fruits ripen on the i-th tree and the number of fruits on the i-th tree.
Output
Print a single integer β the maximum number of fruit that Valera can collect.
Examples
Input
2 3
1 5
2 3
Output
8
Input
5 10
3 20
2 20
1 20
4 20
5 20
Output
60
Note
In the first sample, in order to obtain the optimal answer, you should act as follows.
* On the first day collect 3 fruits from the 1-st tree.
* On the second day collect 1 fruit from the 2-nd tree and 2 fruits from the 1-st tree.
* On the third day collect the remaining fruits from the 2-nd tree.
In the second sample, you can only collect 60 fruits, the remaining fruit will simply wither.
Submitted Solution:
```
n, v = map(int, input().split())
T = 3010
a = [[] for i in range(T)]
for i in range(n):
x, y = map(int, input().split())
a[x].append([y, 1])
ans = 0
for i in range(T):
a[i] = a[i][::-1]
j = 0
cur = v
while j < len(a[i]):
if a[i][j][0] > cur:
ans += cur
if a[i][j][1] == 0:
j += 1
else:
a[i][j][0] -= cur
break
else:
ans += a[i][j][0]
cur -= a[i][j][0]
j += 1
for t in range(j, len(a[i])):
if a[i][t][1] != 0:
a[i + 1].append([a[i][t][0], 0])
print(ans)
```
Yes
| 354
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera loves his garden, where n fruit trees grow.
This year he will enjoy a great harvest! On the i-th tree bi fruit grow, they will ripen on a day number ai. Unfortunately, the fruit on the tree get withered, so they can only be collected on day ai and day ai + 1 (all fruits that are not collected in these two days, become unfit to eat).
Valera is not very fast, but there are some positive points. Valera is ready to work every day. In one day, Valera can collect no more than v fruits. The fruits may be either from the same tree, or from different ones. What is the maximum amount of fruit Valera can collect for all time, if he operates optimally well?
Input
The first line contains two space-separated integers n and v (1 β€ n, v β€ 3000) β the number of fruit trees in the garden and the number of fruits that Valera can collect in a day.
Next n lines contain the description of trees in the garden. The i-th line contains two space-separated integers ai and bi (1 β€ ai, bi β€ 3000) β the day the fruits ripen on the i-th tree and the number of fruits on the i-th tree.
Output
Print a single integer β the maximum number of fruit that Valera can collect.
Examples
Input
2 3
1 5
2 3
Output
8
Input
5 10
3 20
2 20
1 20
4 20
5 20
Output
60
Note
In the first sample, in order to obtain the optimal answer, you should act as follows.
* On the first day collect 3 fruits from the 1-st tree.
* On the second day collect 1 fruit from the 2-nd tree and 2 fruits from the 1-st tree.
* On the third day collect the remaining fruits from the 2-nd tree.
In the second sample, you can only collect 60 fruits, the remaining fruit will simply wither.
Submitted Solution:
```
import sys
import math
n, v = [int(x) for x in (sys.stdin.readline()).split()]
k = [0] * (n + 2)
for i in range(n):
a, b = [int(x) for x in (sys.stdin.readline()).split()]
k[a] = b
i = 1
res = 0
while(i <= n + 1):
val = 0
if(k[i - 1] < v):
val = k[i - 1]
res += val
d = v - val
if(k[i] < d):
res += k[i]
k[i] = 0
else:
res += d
k[i] = k[i] - d
else:
res += v
i += 1
print(res)
```
No
| 355
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera loves his garden, where n fruit trees grow.
This year he will enjoy a great harvest! On the i-th tree bi fruit grow, they will ripen on a day number ai. Unfortunately, the fruit on the tree get withered, so they can only be collected on day ai and day ai + 1 (all fruits that are not collected in these two days, become unfit to eat).
Valera is not very fast, but there are some positive points. Valera is ready to work every day. In one day, Valera can collect no more than v fruits. The fruits may be either from the same tree, or from different ones. What is the maximum amount of fruit Valera can collect for all time, if he operates optimally well?
Input
The first line contains two space-separated integers n and v (1 β€ n, v β€ 3000) β the number of fruit trees in the garden and the number of fruits that Valera can collect in a day.
Next n lines contain the description of trees in the garden. The i-th line contains two space-separated integers ai and bi (1 β€ ai, bi β€ 3000) β the day the fruits ripen on the i-th tree and the number of fruits on the i-th tree.
Output
Print a single integer β the maximum number of fruit that Valera can collect.
Examples
Input
2 3
1 5
2 3
Output
8
Input
5 10
3 20
2 20
1 20
4 20
5 20
Output
60
Note
In the first sample, in order to obtain the optimal answer, you should act as follows.
* On the first day collect 3 fruits from the 1-st tree.
* On the second day collect 1 fruit from the 2-nd tree and 2 fruits from the 1-st tree.
* On the third day collect the remaining fruits from the 2-nd tree.
In the second sample, you can only collect 60 fruits, the remaining fruit will simply wither.
Submitted Solution:
```
n,v = map(int,input().split())
lis=[0]*(4000)
for i in range(n):
a,b = map(int,input().split())
lis[a]+=b
prev=0
ans=0
for i in range(1,3000):
cap=v
# print(prev,lis[i],v)
cap=v-min(prev,v)
ans+=min(prev,v)
zz=min(lis[i],cap)
ans+=zz
prev=lis[i]-zz
# print(ans)
print(ans)
```
No
| 356
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera loves his garden, where n fruit trees grow.
This year he will enjoy a great harvest! On the i-th tree bi fruit grow, they will ripen on a day number ai. Unfortunately, the fruit on the tree get withered, so they can only be collected on day ai and day ai + 1 (all fruits that are not collected in these two days, become unfit to eat).
Valera is not very fast, but there are some positive points. Valera is ready to work every day. In one day, Valera can collect no more than v fruits. The fruits may be either from the same tree, or from different ones. What is the maximum amount of fruit Valera can collect for all time, if he operates optimally well?
Input
The first line contains two space-separated integers n and v (1 β€ n, v β€ 3000) β the number of fruit trees in the garden and the number of fruits that Valera can collect in a day.
Next n lines contain the description of trees in the garden. The i-th line contains two space-separated integers ai and bi (1 β€ ai, bi β€ 3000) β the day the fruits ripen on the i-th tree and the number of fruits on the i-th tree.
Output
Print a single integer β the maximum number of fruit that Valera can collect.
Examples
Input
2 3
1 5
2 3
Output
8
Input
5 10
3 20
2 20
1 20
4 20
5 20
Output
60
Note
In the first sample, in order to obtain the optimal answer, you should act as follows.
* On the first day collect 3 fruits from the 1-st tree.
* On the second day collect 1 fruit from the 2-nd tree and 2 fruits from the 1-st tree.
* On the third day collect the remaining fruits from the 2-nd tree.
In the second sample, you can only collect 60 fruits, the remaining fruit will simply wither.
Submitted Solution:
```
n, v = map(int, input().split())
l = [0]*(3010)
ans = 0
for i in range(n):
a, b = map(int, input().split())
l[a] = b
day = 1
for i in range(3004):
temp = min(v, l[day-1])
ans += temp
l[day-1] -= temp
rem = v - temp
temp2 = min(rem, l[day])
ans+=temp2
l[day]-=temp2
day+=1
print(ans)
```
No
| 357
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera loves his garden, where n fruit trees grow.
This year he will enjoy a great harvest! On the i-th tree bi fruit grow, they will ripen on a day number ai. Unfortunately, the fruit on the tree get withered, so they can only be collected on day ai and day ai + 1 (all fruits that are not collected in these two days, become unfit to eat).
Valera is not very fast, but there are some positive points. Valera is ready to work every day. In one day, Valera can collect no more than v fruits. The fruits may be either from the same tree, or from different ones. What is the maximum amount of fruit Valera can collect for all time, if he operates optimally well?
Input
The first line contains two space-separated integers n and v (1 β€ n, v β€ 3000) β the number of fruit trees in the garden and the number of fruits that Valera can collect in a day.
Next n lines contain the description of trees in the garden. The i-th line contains two space-separated integers ai and bi (1 β€ ai, bi β€ 3000) β the day the fruits ripen on the i-th tree and the number of fruits on the i-th tree.
Output
Print a single integer β the maximum number of fruit that Valera can collect.
Examples
Input
2 3
1 5
2 3
Output
8
Input
5 10
3 20
2 20
1 20
4 20
5 20
Output
60
Note
In the first sample, in order to obtain the optimal answer, you should act as follows.
* On the first day collect 3 fruits from the 1-st tree.
* On the second day collect 1 fruit from the 2-nd tree and 2 fruits from the 1-st tree.
* On the third day collect the remaining fruits from the 2-nd tree.
In the second sample, you can only collect 60 fruits, the remaining fruit will simply wither.
Submitted Solution:
```
def read_integer_pair():
line = input()
pair = line.split(" ")
assert len(pair) == 2
return int(pair[0]), int(pair[1])
if __name__ == '__main__':
n, v = read_integer_pair()
trees = {}
for i in range(n):
a, b = read_integer_pair()
if a in trees:
trees[a] += b
else:
trees[a] = b
trees = list(trees.items())
trees.sort(key=lambda x: x[0])
prev_a = 0
prev_b = 0
apples = 0
for a, b in trees:
dv = min(v, prev_b)
apples += dv
if a - prev_a != 1:
dv = 0
if dv < v:
dv = min(v - dv, b)
apples += dv
prev_a = a
prev_b = b - dv
dv = min(v, prev_b)
apples += dv
print(apples)
```
No
| 358
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Gargari is jealous that his friend Caisa won the game from the previous problem. He wants to prove that he is a genius.
He has a n Γ n chessboard. Each cell of the chessboard has a number written on it. Gargari wants to place two bishops on the chessboard in such a way that there is no cell that is attacked by both of them. Consider a cell with number x written on it, if this cell is attacked by one of the bishops Gargari will get x dollars for it. Tell Gargari, how to place bishops on the chessboard to get maximum amount of money.
We assume a cell is attacked by a bishop, if the cell is located on the same diagonal with the bishop (the cell, where the bishop is, also considered attacked by it).
Input
The first line contains a single integer n (2 β€ n β€ 2000). Each of the next n lines contains n integers aij (0 β€ aij β€ 109) β description of the chessboard.
Output
On the first line print the maximal number of dollars Gargari will get. On the next line print four integers: x1, y1, x2, y2 (1 β€ x1, y1, x2, y2 β€ n), where xi is the number of the row where the i-th bishop should be placed, yi is the number of the column where the i-th bishop should be placed. Consider rows are numbered from 1 to n from top to bottom, and columns are numbered from 1 to n from left to right.
If there are several optimal solutions, you can print any of them.
Examples
Input
4
1 1 1 1
2 1 1 0
1 1 1 0
1 0 0 1
Output
12
2 2 3 2
Tags: greedy, hashing, implementation
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
def main():
n = int(input())
a = [list(map(int,input().split())) for _ in range(n)]
lst = [0]*(2*n-1)
for i in range(n):
for j in range(n):
lst[i+j] += a[i][j]
odd,eve = -1,-1
ls = [[-1,-1],[-1,-1]]
for j in range(n):
ans,aa = 0,-1
for i in range(n-j):
ans += a[i][j+i]
if lst[2*i+j]-a[i][j+i] > aa:
aa = lst[2*i+j]-a[i][j+i]
v = [i+1,j+i+1]
if j&1:
if odd < ans+aa:
odd = ans+aa
ls[1] = v
else:
if eve < ans+aa:
eve = ans+aa
ls[0] = v
for i in range(n):
ans,aa = 0,-1
for j in range(n-i):
ans += a[i+j][j]
if lst[i+2*j]-a[i+j][j] > aa:
aa = lst[i+2*j]-a[i+j][j]
v = [i+j+1,j+1]
if i&1:
if odd < ans+aa:
odd = ans+aa
ls[1] = v
else:
if eve < ans+aa:
eve = ans+aa
ls[0] = v
print(odd+eve)
print(ls[0][0],ls[0][1],ls[1][0],ls[1][1])
# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
```
| 359
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Gargari is jealous that his friend Caisa won the game from the previous problem. He wants to prove that he is a genius.
He has a n Γ n chessboard. Each cell of the chessboard has a number written on it. Gargari wants to place two bishops on the chessboard in such a way that there is no cell that is attacked by both of them. Consider a cell with number x written on it, if this cell is attacked by one of the bishops Gargari will get x dollars for it. Tell Gargari, how to place bishops on the chessboard to get maximum amount of money.
We assume a cell is attacked by a bishop, if the cell is located on the same diagonal with the bishop (the cell, where the bishop is, also considered attacked by it).
Input
The first line contains a single integer n (2 β€ n β€ 2000). Each of the next n lines contains n integers aij (0 β€ aij β€ 109) β description of the chessboard.
Output
On the first line print the maximal number of dollars Gargari will get. On the next line print four integers: x1, y1, x2, y2 (1 β€ x1, y1, x2, y2 β€ n), where xi is the number of the row where the i-th bishop should be placed, yi is the number of the column where the i-th bishop should be placed. Consider rows are numbered from 1 to n from top to bottom, and columns are numbered from 1 to n from left to right.
If there are several optimal solutions, you can print any of them.
Examples
Input
4
1 1 1 1
2 1 1 0
1 1 1 0
1 0 0 1
Output
12
2 2 3 2
Tags: greedy, hashing, implementation
Correct Solution:
```
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")
#######################################
a=int(input())
ans=[]
for i in range(a):
z=list(map(int,input().split()))
ans.append(z)
pri1=pow(10,9)+7
from collections import *
obt=defaultdict(int)
act=defaultdict(int)
for i in range(a):
for j in range(a):
p,q=i,j
p,q=p-min(p,q),q-min(p,q)
obt[p-q]+=ans[i][j]
p,q=i,j
act[p+q]+=ans[i][j]
maxa1=0
maxa2=0
p1=0
p2=0
p3=0
p4=0
for i in range(a):
for j in range(a):
if(i%2==j%2):
if(min(i,j)==0 or min(i,j)==a-1):
value=ans[i][j]
else:
p,q=i,j
p,q=p-min(p,q),q-min(p,q)
value=0
value+=obt[p-q]
value+=act[i+j]
value-=ans[i][j]
maxa1=max(maxa1,value)
if(maxa1==value):
p1,p2=i,j
else:
if(min(i,j)==0 or min(i,j)==a-1):
value=ans[i][j]
else:
p,q=i,j
value=0
p,q=p-min(p,q),q-min(p,q)
value+=obt[p-q]
value+=act[i+j]
value-=ans[i][j]
maxa2=max(maxa2,value)
if(maxa2==value):
p3,p4=i,j
print(maxa1+maxa2)
print(p1+1,p2+1,p3+1,p4+1)
```
| 360
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Gargari is jealous that his friend Caisa won the game from the previous problem. He wants to prove that he is a genius.
He has a n Γ n chessboard. Each cell of the chessboard has a number written on it. Gargari wants to place two bishops on the chessboard in such a way that there is no cell that is attacked by both of them. Consider a cell with number x written on it, if this cell is attacked by one of the bishops Gargari will get x dollars for it. Tell Gargari, how to place bishops on the chessboard to get maximum amount of money.
We assume a cell is attacked by a bishop, if the cell is located on the same diagonal with the bishop (the cell, where the bishop is, also considered attacked by it).
Input
The first line contains a single integer n (2 β€ n β€ 2000). Each of the next n lines contains n integers aij (0 β€ aij β€ 109) β description of the chessboard.
Output
On the first line print the maximal number of dollars Gargari will get. On the next line print four integers: x1, y1, x2, y2 (1 β€ x1, y1, x2, y2 β€ n), where xi is the number of the row where the i-th bishop should be placed, yi is the number of the column where the i-th bishop should be placed. Consider rows are numbered from 1 to n from top to bottom, and columns are numbered from 1 to n from left to right.
If there are several optimal solutions, you can print any of them.
Examples
Input
4
1 1 1 1
2 1 1 0
1 1 1 0
1 0 0 1
Output
12
2 2 3 2
Tags: greedy, hashing, implementation
Correct Solution:
```
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
from collections import deque
import threading
#sys.setrecursionlimit(300000)
#threading.stack_size(10**8)
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")
#-------------------------------------------------------------------------
#mod = 9223372036854775807
class SegmentTree:
def __init__(self, data, default=-10**6, func=lambda a, b: max(a,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
class SegmentTree1:
def __init__(self, data, default=10**6, func=lambda a, b: min(a,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
MOD=10**9+7
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
mod=10**9+7
omod=998244353
#-------------------------------------------------------------------------
prime = [True for i in range(50001)]
pp=[]
def SieveOfEratosthenes(n=50000):
# Create a boolean array "prime[0..n]" and initialize
# all entries it as true. A value in prime[i] will
# finally be false if i is Not a prime, else true.
p = 2
while (p * p <= n):
# If prime[p] is not changed, then it is a prime
if (prime[p] == True):
# Update all multiples of p
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
for i in range(50001):
if prime[i]:
pp.append(i)
#---------------------------------running code------------------------------------------
n=int(input())
a=[]
d1=defaultdict(int)
d2=defaultdict(int)
for i in range (n):
b=list(map(int,input().split()))
a.append(b)
for j in range (n):
d1[i+j]+=b[j]
d2[i-j]+=b[j]
m1,m2=-1,-1
res1,res2=[0,0],[0,0]
#print(d1)
#print(d2)
for i in range (n):
for j in range (n):
if (i+j)%2==0:
if d1[i+j]+d2[i-j]-a[i][j]>m1:
m1=d1[i+j]+d2[i-j]-a[i][j]
res1=[i+1,j+1]
else:
if d1[i+j]+d2[i-j]-a[i][j]>m2:
m2=d1[i+j]+d2[i-j]-a[i][j]
res2=[i+1,j+1]
#print(m1,m2,d1[i+j]+d2[i-j]-a[i][j])
print(m1+m2)
print(*res1,*res2)
```
| 361
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Gargari is jealous that his friend Caisa won the game from the previous problem. He wants to prove that he is a genius.
He has a n Γ n chessboard. Each cell of the chessboard has a number written on it. Gargari wants to place two bishops on the chessboard in such a way that there is no cell that is attacked by both of them. Consider a cell with number x written on it, if this cell is attacked by one of the bishops Gargari will get x dollars for it. Tell Gargari, how to place bishops on the chessboard to get maximum amount of money.
We assume a cell is attacked by a bishop, if the cell is located on the same diagonal with the bishop (the cell, where the bishop is, also considered attacked by it).
Input
The first line contains a single integer n (2 β€ n β€ 2000). Each of the next n lines contains n integers aij (0 β€ aij β€ 109) β description of the chessboard.
Output
On the first line print the maximal number of dollars Gargari will get. On the next line print four integers: x1, y1, x2, y2 (1 β€ x1, y1, x2, y2 β€ n), where xi is the number of the row where the i-th bishop should be placed, yi is the number of the column where the i-th bishop should be placed. Consider rows are numbered from 1 to n from top to bottom, and columns are numbered from 1 to n from left to right.
If there are several optimal solutions, you can print any of them.
Examples
Input
4
1 1 1 1
2 1 1 0
1 1 1 0
1 0 0 1
Output
12
2 2 3 2
Tags: greedy, hashing, implementation
Correct Solution:
```
import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
# from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
import copy
import time
# import numpy as np
starttime = time.time()
# import numpy as np
mod = int(pow(10, 9) + 7)
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(*var, end="\n"): sys.stdout.write(' '.join(map(str, var))+end)
def L(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]
try:
# sys.setrecursionlimit(int(pow(10,6)))
sys.stdin = open("input.txt", "r")
# sys.stdout = open("../output.txt", "w")
except:
pass
from sys import stdin
input = stdin.buffer.readline
I = lambda : list(map(int,input().split()))
n,=I()
l=[]
for i in range(n):
l.append(I())
d={};su={};s=0;an=[1,1,2,1]
for i in range(n):
for j in range(n):
d[i-j]=d.get(i-j,0)+l[i][j]
su[i+j]=su.get(i+j,0)+l[i][j]
x=0;y=0
for i in range(n):
for j in range(n):
p=d[i-j]+su[i+j]-l[i][j]
if (i+j)%2:
if p>x:
an[0],an[1]=i+1,j+1
x=p
else:
if p>y:
an[2],an[3]=i+1,j+1
y=p
s=x+y
print(s)
print(*an)
endtime = time.time()
# print(f"Runtime of the program is {endtime - starttime}")
```
| 362
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Gargari is jealous that his friend Caisa won the game from the previous problem. He wants to prove that he is a genius.
He has a n Γ n chessboard. Each cell of the chessboard has a number written on it. Gargari wants to place two bishops on the chessboard in such a way that there is no cell that is attacked by both of them. Consider a cell with number x written on it, if this cell is attacked by one of the bishops Gargari will get x dollars for it. Tell Gargari, how to place bishops on the chessboard to get maximum amount of money.
We assume a cell is attacked by a bishop, if the cell is located on the same diagonal with the bishop (the cell, where the bishop is, also considered attacked by it).
Input
The first line contains a single integer n (2 β€ n β€ 2000). Each of the next n lines contains n integers aij (0 β€ aij β€ 109) β description of the chessboard.
Output
On the first line print the maximal number of dollars Gargari will get. On the next line print four integers: x1, y1, x2, y2 (1 β€ x1, y1, x2, y2 β€ n), where xi is the number of the row where the i-th bishop should be placed, yi is the number of the column where the i-th bishop should be placed. Consider rows are numbered from 1 to n from top to bottom, and columns are numbered from 1 to n from left to right.
If there are several optimal solutions, you can print any of them.
Examples
Input
4
1 1 1 1
2 1 1 0
1 1 1 0
1 0 0 1
Output
12
2 2 3 2
Tags: greedy, hashing, implementation
Correct Solution:
```
from sys import stdin
input = stdin.buffer.readline
from collections import defaultdict as dd
I = lambda : list(map(int,input().split()))
n,=I()
l=[];d=dd(int);su=dd(int);s=0;an=[1,1,2,1]
for i in range(n):
l.append(I())
for j in range(n):
d[i-j]+=l[i][j]
su[i+j]+=l[i][j]
x=0;y=0
for i in range(n):
for j in range(n):
l[i][j]=d[i-j]+su[i+j]-l[i][j]
if (i+j)%2:
if l[i][j]>x:
an[0],an[1]=i+1,j+1
x=l[i][j]
else:
if l[i][j]>y:
an[2],an[3]=i+1,j+1
y=l[i][j]
s=x+y
print(s)
print(*an)
```
| 363
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Gargari is jealous that his friend Caisa won the game from the previous problem. He wants to prove that he is a genius.
He has a n Γ n chessboard. Each cell of the chessboard has a number written on it. Gargari wants to place two bishops on the chessboard in such a way that there is no cell that is attacked by both of them. Consider a cell with number x written on it, if this cell is attacked by one of the bishops Gargari will get x dollars for it. Tell Gargari, how to place bishops on the chessboard to get maximum amount of money.
We assume a cell is attacked by a bishop, if the cell is located on the same diagonal with the bishop (the cell, where the bishop is, also considered attacked by it).
Input
The first line contains a single integer n (2 β€ n β€ 2000). Each of the next n lines contains n integers aij (0 β€ aij β€ 109) β description of the chessboard.
Output
On the first line print the maximal number of dollars Gargari will get. On the next line print four integers: x1, y1, x2, y2 (1 β€ x1, y1, x2, y2 β€ n), where xi is the number of the row where the i-th bishop should be placed, yi is the number of the column where the i-th bishop should be placed. Consider rows are numbered from 1 to n from top to bottom, and columns are numbered from 1 to n from left to right.
If there are several optimal solutions, you can print any of them.
Examples
Input
4
1 1 1 1
2 1 1 0
1 1 1 0
1 0 0 1
Output
12
2 2 3 2
Tags: greedy, hashing, implementation
Correct Solution:
```
import sys
input=sys.stdin.buffer.readline
t=1
for __ in range(t):
a=[]
n=int(input())
for i in range(n):
b=list(map(int,input().split()))
a.append(b)
dr={}
di={}
for i in range(n):
for j in range(n):
dr[i+j]=dr.get(i+j,0)+a[i][j]
di[i+n-j+1]=di.get(i+n-j+1,0)+a[i][j]
ind1=[0]*2
ind2=[0]*2
maxi1=0
maxi2=0
for i in range(n):
for j in range(n):
#if maxi<(dr[i+j]+di[i+n-j+1]-a[i][j]):
if ((i+j)&1)==1:
if maxi1<=(dr[i+j]+di[i+n-j+1]-a[i][j]):
maxi1=(dr[i+j]+di[i+n-j+1]-a[i][j])
ind1[0]=i+1
ind1[1]=j+1
else:
if maxi2<=(dr[i+j]+di[i+n-j+1]-a[i][j]):
maxi2=(dr[i+j]+di[i+n-j+1]-a[i][j])
ind2[0]=i+1
ind2[1]=j+1
print(maxi1+maxi2)
print(ind1[0],ind1[1],ind2[0],ind2[1])
```
| 364
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Gargari is jealous that his friend Caisa won the game from the previous problem. He wants to prove that he is a genius.
He has a n Γ n chessboard. Each cell of the chessboard has a number written on it. Gargari wants to place two bishops on the chessboard in such a way that there is no cell that is attacked by both of them. Consider a cell with number x written on it, if this cell is attacked by one of the bishops Gargari will get x dollars for it. Tell Gargari, how to place bishops on the chessboard to get maximum amount of money.
We assume a cell is attacked by a bishop, if the cell is located on the same diagonal with the bishop (the cell, where the bishop is, also considered attacked by it).
Input
The first line contains a single integer n (2 β€ n β€ 2000). Each of the next n lines contains n integers aij (0 β€ aij β€ 109) β description of the chessboard.
Output
On the first line print the maximal number of dollars Gargari will get. On the next line print four integers: x1, y1, x2, y2 (1 β€ x1, y1, x2, y2 β€ n), where xi is the number of the row where the i-th bishop should be placed, yi is the number of the column where the i-th bishop should be placed. Consider rows are numbered from 1 to n from top to bottom, and columns are numbered from 1 to n from left to right.
If there are several optimal solutions, you can print any of them.
Examples
Input
4
1 1 1 1
2 1 1 0
1 1 1 0
1 0 0 1
Output
12
2 2 3 2
Tags: greedy, hashing, implementation
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
def main():
pass
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
n=int(input())
arr=[]
for i in range(n):
li=[int(x) for x in input().split()]
arr.append(li)
d1,d2={},{}
for i in range(n):
for j in range(n):
if((i-j) in d1):
d1[i-j]+=arr[i][j]
else:
d1[i-j]=arr[i][j]
if((i+j) in d2):
d2[i+j]+=arr[i][j]
else:
d2[i+j]=arr[i][j]
m1,m2=-1,-1
ans1,ans2=(),()
for i in range(n):
for j in range(n):
if((i+j)%2==0):
if(d1[i-j]+d2[i+j]-arr[i][j]>m1):
ans1=(i,j)
m1=d1[i-j]+d2[i+j]-arr[i][j]
else:
if(d1[i-j]+d2[i+j]-arr[i][j]>m2):
ans2=(i,j)
m2=d1[i-j]+d2[i+j]-arr[i][j]
print(m1+m2,ans1[0]+1,ans1[1]+1,ans2[0]+1,ans2[1]+1)
```
| 365
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Gargari is jealous that his friend Caisa won the game from the previous problem. He wants to prove that he is a genius.
He has a n Γ n chessboard. Each cell of the chessboard has a number written on it. Gargari wants to place two bishops on the chessboard in such a way that there is no cell that is attacked by both of them. Consider a cell with number x written on it, if this cell is attacked by one of the bishops Gargari will get x dollars for it. Tell Gargari, how to place bishops on the chessboard to get maximum amount of money.
We assume a cell is attacked by a bishop, if the cell is located on the same diagonal with the bishop (the cell, where the bishop is, also considered attacked by it).
Input
The first line contains a single integer n (2 β€ n β€ 2000). Each of the next n lines contains n integers aij (0 β€ aij β€ 109) β description of the chessboard.
Output
On the first line print the maximal number of dollars Gargari will get. On the next line print four integers: x1, y1, x2, y2 (1 β€ x1, y1, x2, y2 β€ n), where xi is the number of the row where the i-th bishop should be placed, yi is the number of the column where the i-th bishop should be placed. Consider rows are numbered from 1 to n from top to bottom, and columns are numbered from 1 to n from left to right.
If there are several optimal solutions, you can print any of them.
Examples
Input
4
1 1 1 1
2 1 1 0
1 1 1 0
1 0 0 1
Output
12
2 2 3 2
Tags: greedy, hashing, implementation
Correct Solution:
```
from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
from math import inf
def main():
# a bishop has to be on a cell intercepted by even diagonals,
# and another on a cell intercepted by odd diagonals
# i + j is even -> white
# i + j is odd -> gray
# diagonal 1 -> i - j (top-left to bottom-right) (this difference is constant)
# diagonal 2 -> i + j (top-right to bottom-left) (this sum is constant)
# calculate the sum of each diagonal (n2)
# find the best cell (with max total) intercepted by even diagonals and the
# best cell (with max total) intercepted by odd diagonals
n = int(input())
chessboard = [
[ int(x) for x in input().split() ]
for row in range(n)
]
mainDiagonalSums = {}
secondaryDiagonalSums = {}
for i in range(n):
for j in range(n):
mainDiagonal = i - j
if mainDiagonal in mainDiagonalSums:
mainDiagonalSums[mainDiagonal] += chessboard[i][j]
else:
mainDiagonalSums[mainDiagonal] = chessboard[i][j]
secondaryDiagonal = i + j
if secondaryDiagonal in secondaryDiagonalSums:
secondaryDiagonalSums[secondaryDiagonal] += chessboard[i][j]
else:
secondaryDiagonalSums[secondaryDiagonal] = chessboard[i][j]
maxPoints = [-inf, -inf]
bestPosition = [None, None]
for i in range(n):
for j in range(n):
points = (
mainDiagonalSums[i-j] + secondaryDiagonalSums[i+j]
- chessboard[i][j]
)
if (i + j) & 1:
if points > maxPoints[1]:
bestPosition[1] = (i, j)
maxPoints[1] = points
else:
if points > maxPoints[0]:
bestPosition[0] = (i, j)
maxPoints[0] = points
print(sum(maxPoints))
print(' '.join([ f'{i+1} {j+1}' for i, j in bestPosition ]))
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")
input = lambda: sys.stdin.readline().rstrip("\r\n")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep = kwargs.pop("sep", " ")
file = kwargs.pop("file", sys.stdout)
atStart = True
for x in args:
if not atStart:
file.write(sep)
file.write(str(x))
atStart = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
main()
```
| 366
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gargari is jealous that his friend Caisa won the game from the previous problem. He wants to prove that he is a genius.
He has a n Γ n chessboard. Each cell of the chessboard has a number written on it. Gargari wants to place two bishops on the chessboard in such a way that there is no cell that is attacked by both of them. Consider a cell with number x written on it, if this cell is attacked by one of the bishops Gargari will get x dollars for it. Tell Gargari, how to place bishops on the chessboard to get maximum amount of money.
We assume a cell is attacked by a bishop, if the cell is located on the same diagonal with the bishop (the cell, where the bishop is, also considered attacked by it).
Input
The first line contains a single integer n (2 β€ n β€ 2000). Each of the next n lines contains n integers aij (0 β€ aij β€ 109) β description of the chessboard.
Output
On the first line print the maximal number of dollars Gargari will get. On the next line print four integers: x1, y1, x2, y2 (1 β€ x1, y1, x2, y2 β€ n), where xi is the number of the row where the i-th bishop should be placed, yi is the number of the column where the i-th bishop should be placed. Consider rows are numbered from 1 to n from top to bottom, and columns are numbered from 1 to n from left to right.
If there are several optimal solutions, you can print any of them.
Examples
Input
4
1 1 1 1
2 1 1 0
1 1 1 0
1 0 0 1
Output
12
2 2 3 2
Submitted Solution:
```
from sys import stdin
input = stdin.buffer.readline
n=int(input())
l=[[*map(int,input().split())] for _ in range(n)]
d={};su={};s=0;an=[1,1,2,1]
for i in range(n):
for j in range(n):
d[i-j]=d.get(i-j,0)+l[i][j]
su[i+j]=su.get(i+j,0)+l[i][j]
position=[2,1,1,1]
x,y=0,0
for i in range(n):
for j in range(n):
p=d[i-j]+su[i+j]-l[i][j]
if (i+j)%2:
if p>x:
x=p
position[:2]=[i+1,j+1]
else:
if p>y:
y=p
position[2:]=[i+1,j+1]
print(x+y)
print(*position)
```
Yes
| 367
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gargari is jealous that his friend Caisa won the game from the previous problem. He wants to prove that he is a genius.
He has a n Γ n chessboard. Each cell of the chessboard has a number written on it. Gargari wants to place two bishops on the chessboard in such a way that there is no cell that is attacked by both of them. Consider a cell with number x written on it, if this cell is attacked by one of the bishops Gargari will get x dollars for it. Tell Gargari, how to place bishops on the chessboard to get maximum amount of money.
We assume a cell is attacked by a bishop, if the cell is located on the same diagonal with the bishop (the cell, where the bishop is, also considered attacked by it).
Input
The first line contains a single integer n (2 β€ n β€ 2000). Each of the next n lines contains n integers aij (0 β€ aij β€ 109) β description of the chessboard.
Output
On the first line print the maximal number of dollars Gargari will get. On the next line print four integers: x1, y1, x2, y2 (1 β€ x1, y1, x2, y2 β€ n), where xi is the number of the row where the i-th bishop should be placed, yi is the number of the column where the i-th bishop should be placed. Consider rows are numbered from 1 to n from top to bottom, and columns are numbered from 1 to n from left to right.
If there are several optimal solutions, you can print any of them.
Examples
Input
4
1 1 1 1
2 1 1 0
1 1 1 0
1 0 0 1
Output
12
2 2 3 2
Submitted Solution:
```
from sys import stdin
input = stdin.buffer.readline
I = lambda : list(map(int,input().split()))
n = int(input())
ans = []
for _ in range(n):
arr = I()
ans.append(arr)
topLeft, bottomLeft = {}, {}
for i in range(n):
for j in range(n):
topLeft[i-j] = topLeft.get(i-j, 0) + ans[i][j]
bottomLeft[i+j] = bottomLeft.get(i+j, 0) + ans[i][j]
mx1, mx2, pos1, pos2 = -1, -1, [-1,-1], [-1,-1]
for i in range(n):
for j in range(n):
if (i+j) & 1:
if mx1 < topLeft[i-j] + bottomLeft[i+j] - ans[i][j]:
mx1, pos1 = topLeft[i-j] + bottomLeft[i+j] - ans[i][j], [i+1,j+1]
else:
if mx2 < topLeft[i - j] + bottomLeft[i + j] - ans[i][j]:
mx2, pos2 = topLeft[i - j] + bottomLeft[i + j] - ans[i][j], [i+1, j+1]
print(mx1+mx2)
print(pos1[0], pos1[1], pos2[0], pos2[1])
```
Yes
| 368
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gargari is jealous that his friend Caisa won the game from the previous problem. He wants to prove that he is a genius.
He has a n Γ n chessboard. Each cell of the chessboard has a number written on it. Gargari wants to place two bishops on the chessboard in such a way that there is no cell that is attacked by both of them. Consider a cell with number x written on it, if this cell is attacked by one of the bishops Gargari will get x dollars for it. Tell Gargari, how to place bishops on the chessboard to get maximum amount of money.
We assume a cell is attacked by a bishop, if the cell is located on the same diagonal with the bishop (the cell, where the bishop is, also considered attacked by it).
Input
The first line contains a single integer n (2 β€ n β€ 2000). Each of the next n lines contains n integers aij (0 β€ aij β€ 109) β description of the chessboard.
Output
On the first line print the maximal number of dollars Gargari will get. On the next line print four integers: x1, y1, x2, y2 (1 β€ x1, y1, x2, y2 β€ n), where xi is the number of the row where the i-th bishop should be placed, yi is the number of the column where the i-th bishop should be placed. Consider rows are numbered from 1 to n from top to bottom, and columns are numbered from 1 to n from left to right.
If there are several optimal solutions, you can print any of them.
Examples
Input
4
1 1 1 1
2 1 1 0
1 1 1 0
1 0 0 1
Output
12
2 2 3 2
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
nmbr = lambda: int(input())
lst = lambda: list(map(int, input().split()))
def main():
# n, k = map(int, input().split())
# s = input()
n = int(input())
a = [list(map(int, input().split())) for _ in range(n)]
ss = {} # /
sd = {} # \
mx = 0;
x = y = x1 = y1 = -1
for i in range(n):
for j in range(n):
ss[i + j] = ss.get(i + j, 0) + a[i][j]
sd[i - j] = sd.get(i - j, 0) + a[i][j]
for i in range(n):
for j in range(n):
val = ss[i + j] + sd[i - j] - a[i][j]
if val >= mx:
mx = val
x, y = i, j
mx1 = 0
for i in range(n):
for j in range(n):
if (i + j) & 1 == (x + y) & 1: continue
val = ss[i + j] + sd[i - j] - a[i][j]
if val >= mx1:
mx1 = val
x1, y1 = i, j
print(mx + mx1)
print(x + 1, y + 1, x1 + 1, y1 + 1)
# sys.stdout.write(str(ans))
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
for t in range(1):main()#int(input())):
```
Yes
| 369
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gargari is jealous that his friend Caisa won the game from the previous problem. He wants to prove that he is a genius.
He has a n Γ n chessboard. Each cell of the chessboard has a number written on it. Gargari wants to place two bishops on the chessboard in such a way that there is no cell that is attacked by both of them. Consider a cell with number x written on it, if this cell is attacked by one of the bishops Gargari will get x dollars for it. Tell Gargari, how to place bishops on the chessboard to get maximum amount of money.
We assume a cell is attacked by a bishop, if the cell is located on the same diagonal with the bishop (the cell, where the bishop is, also considered attacked by it).
Input
The first line contains a single integer n (2 β€ n β€ 2000). Each of the next n lines contains n integers aij (0 β€ aij β€ 109) β description of the chessboard.
Output
On the first line print the maximal number of dollars Gargari will get. On the next line print four integers: x1, y1, x2, y2 (1 β€ x1, y1, x2, y2 β€ n), where xi is the number of the row where the i-th bishop should be placed, yi is the number of the column where the i-th bishop should be placed. Consider rows are numbered from 1 to n from top to bottom, and columns are numbered from 1 to n from left to right.
If there are several optimal solutions, you can print any of them.
Examples
Input
4
1 1 1 1
2 1 1 0
1 1 1 0
1 0 0 1
Output
12
2 2 3 2
Submitted Solution:
```
from sys import stdin
input = stdin.buffer.readline
I = lambda : list(map(int,input().split()))
n,=I()
l=[]
for i in range(n):
l.append(I())
d={};su={};s=0;an=[1,1,2,1]
for i in range(n):
for j in range(n):
d[i-j]=d.get(i-j,0)+l[i][j]
su[i+j]=su.get(i+j,0)+l[i][j]
x=0;y=0
for i in range(n):
for j in range(n):
p=d[i-j]+su[i+j]-l[i][j]
if (i+j)%2:
if p>x:
an[0],an[1]=i+1,j+1
x=p
else:
if p>y:
an[2],an[3]=i+1,j+1
y=p
s=x+y
print(s)
print(*an)
```
Yes
| 370
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gargari is jealous that his friend Caisa won the game from the previous problem. He wants to prove that he is a genius.
He has a n Γ n chessboard. Each cell of the chessboard has a number written on it. Gargari wants to place two bishops on the chessboard in such a way that there is no cell that is attacked by both of them. Consider a cell with number x written on it, if this cell is attacked by one of the bishops Gargari will get x dollars for it. Tell Gargari, how to place bishops on the chessboard to get maximum amount of money.
We assume a cell is attacked by a bishop, if the cell is located on the same diagonal with the bishop (the cell, where the bishop is, also considered attacked by it).
Input
The first line contains a single integer n (2 β€ n β€ 2000). Each of the next n lines contains n integers aij (0 β€ aij β€ 109) β description of the chessboard.
Output
On the first line print the maximal number of dollars Gargari will get. On the next line print four integers: x1, y1, x2, y2 (1 β€ x1, y1, x2, y2 β€ n), where xi is the number of the row where the i-th bishop should be placed, yi is the number of the column where the i-th bishop should be placed. Consider rows are numbered from 1 to n from top to bottom, and columns are numbered from 1 to n from left to right.
If there are several optimal solutions, you can print any of them.
Examples
Input
4
1 1 1 1
2 1 1 0
1 1 1 0
1 0 0 1
Output
12
2 2 3 2
Submitted Solution:
```
def max_num(a):
maxm=a[0][0]
ind=[0,0]
for i in range(n):
for j in range(n):
if a[i][j]>maxm:
maxm=a[i][j]
ind=[i,j]
return ind
n = int(input())
a=[]
for i in range(n):
a.append(list(map(int,input().split())))
b=[[0 for i in range(n)] for j in range(n)]
c=[[0 for i in range(n)] for j in range(n)]
for i in range(n):
for j in range(n-i):
b[0][i]+=a[j][i+j]
for i in range(1,n):
for j in range(n-i):
b[i][0]+=a[i+j][j]
for i in range(1,n):
for j in range(1,n):
z=min(i,j)
b[i][j]+=b[i-z][j-z]
for i in range(n):
for j in range(i+1):
c[0][i]+=a[i-j][j]
for i in range(1,n):
for j in range(n-i):
c[i][-1]+=a[i+j][n-j-1]
for i in range(1,n):
for j in range(n-1):
c[i][j]+=c[i-1][j+1]
d = [[0 for i in range(n)] for j in range(n)]
for i in range(n):
for j in range(n):
d[i][j]=b[i][j]+c[i][j]-a[i][j]
ans1=max_num(d)
ans3=d[ans1[0]][ans1[1]]
d[ans1[0]][ans1[1]]=0
ans2=max_num(d)
ans3+=d[ans2[0]][ans2[1]]
print(ans3)
print(ans1[0]+1,ans1[1]+1,ans2[0]+1,ans2[1]+1)
```
No
| 371
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gargari is jealous that his friend Caisa won the game from the previous problem. He wants to prove that he is a genius.
He has a n Γ n chessboard. Each cell of the chessboard has a number written on it. Gargari wants to place two bishops on the chessboard in such a way that there is no cell that is attacked by both of them. Consider a cell with number x written on it, if this cell is attacked by one of the bishops Gargari will get x dollars for it. Tell Gargari, how to place bishops on the chessboard to get maximum amount of money.
We assume a cell is attacked by a bishop, if the cell is located on the same diagonal with the bishop (the cell, where the bishop is, also considered attacked by it).
Input
The first line contains a single integer n (2 β€ n β€ 2000). Each of the next n lines contains n integers aij (0 β€ aij β€ 109) β description of the chessboard.
Output
On the first line print the maximal number of dollars Gargari will get. On the next line print four integers: x1, y1, x2, y2 (1 β€ x1, y1, x2, y2 β€ n), where xi is the number of the row where the i-th bishop should be placed, yi is the number of the column where the i-th bishop should be placed. Consider rows are numbered from 1 to n from top to bottom, and columns are numbered from 1 to n from left to right.
If there are several optimal solutions, you can print any of them.
Examples
Input
4
1 1 1 1
2 1 1 0
1 1 1 0
1 0 0 1
Output
12
2 2 3 2
Submitted Solution:
```
a, b, c, d = 0, 0, 0, 0
m1 = 0
m2 = 0
n = int(input())
board = []
for _ in range(n):
board.append(list(map(int, input().split())))
pos = {}
neg = {}
for i in range(-n+1, n):
pos[i] = 0
for i in range(2*n):
neg[i] = 0
for i in range(n):
for j in range(n):
pos[j-i]+=board[i][j]
neg[j+i]+=board[i][j]
for i in range(n):
for j in range(n):
if (i+j)%2==0:
temp = pos[j-i] + neg[j+i] - board[i][j]
if temp>=m1:
m1 = temp
a = i
b = j
else:
temp = pos[j - i] + neg[j + i] - board[i][j]
if temp >= m2:
m2 = temp
c = i
d = j
print(m1 + m2)
print(str(a)+' '+str(b)+' '+str(c)+' '+str(d))
```
No
| 372
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gargari is jealous that his friend Caisa won the game from the previous problem. He wants to prove that he is a genius.
He has a n Γ n chessboard. Each cell of the chessboard has a number written on it. Gargari wants to place two bishops on the chessboard in such a way that there is no cell that is attacked by both of them. Consider a cell with number x written on it, if this cell is attacked by one of the bishops Gargari will get x dollars for it. Tell Gargari, how to place bishops on the chessboard to get maximum amount of money.
We assume a cell is attacked by a bishop, if the cell is located on the same diagonal with the bishop (the cell, where the bishop is, also considered attacked by it).
Input
The first line contains a single integer n (2 β€ n β€ 2000). Each of the next n lines contains n integers aij (0 β€ aij β€ 109) β description of the chessboard.
Output
On the first line print the maximal number of dollars Gargari will get. On the next line print four integers: x1, y1, x2, y2 (1 β€ x1, y1, x2, y2 β€ n), where xi is the number of the row where the i-th bishop should be placed, yi is the number of the column where the i-th bishop should be placed. Consider rows are numbered from 1 to n from top to bottom, and columns are numbered from 1 to n from left to right.
If there are several optimal solutions, you can print any of them.
Examples
Input
4
1 1 1 1
2 1 1 0
1 1 1 0
1 0 0 1
Output
12
2 2 3 2
Submitted Solution:
```
import sys
input = sys.stdin.readline
I = lambda : list(map(int,input().split()))
n,=I()
l=[]
for i in range(n):
l.append(I())
d={};su={};s=0;an=[1,1,2,1]
for i in range(n):
for j in range(n):
d[i-j]=d.get(i-j,0)+l[i][j]
su[i+j]=su.get(i+j,0)+l[i][j]
x=0;y=0
for i in range(n):
for j in range(n):
l[i][j]=d[i-j]+su[i+j]-l[i][j]
if l[i][j]>x:
k=x;x=l[i][j];p=list(an)
an[0],an[1]=i+1,j+1
if k>y:
y=k;an[2]=p[0]
an[3]=p[1]
elif l[i][j]>y:
y=l[i][j]
an[2]=i+1;an[3]=j+1
s=x+y
print(s)
print(*an)
```
No
| 373
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gargari is jealous that his friend Caisa won the game from the previous problem. He wants to prove that he is a genius.
He has a n Γ n chessboard. Each cell of the chessboard has a number written on it. Gargari wants to place two bishops on the chessboard in such a way that there is no cell that is attacked by both of them. Consider a cell with number x written on it, if this cell is attacked by one of the bishops Gargari will get x dollars for it. Tell Gargari, how to place bishops on the chessboard to get maximum amount of money.
We assume a cell is attacked by a bishop, if the cell is located on the same diagonal with the bishop (the cell, where the bishop is, also considered attacked by it).
Input
The first line contains a single integer n (2 β€ n β€ 2000). Each of the next n lines contains n integers aij (0 β€ aij β€ 109) β description of the chessboard.
Output
On the first line print the maximal number of dollars Gargari will get. On the next line print four integers: x1, y1, x2, y2 (1 β€ x1, y1, x2, y2 β€ n), where xi is the number of the row where the i-th bishop should be placed, yi is the number of the column where the i-th bishop should be placed. Consider rows are numbered from 1 to n from top to bottom, and columns are numbered from 1 to n from left to right.
If there are several optimal solutions, you can print any of them.
Examples
Input
4
1 1 1 1
2 1 1 0
1 1 1 0
1 0 0 1
Output
12
2 2 3 2
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Sun Jun 16 21:28:32 2019
@author: sj
"""
n=int(input())
a=[]
for i in range(0,n):
s=input().split(" ")
for j in range(0,n):
s[j]=int(s[j])
a.append(s)
b=[]
c=[]
d=[]
for i in range(0,n):
cc=[]
for j in range(0,n):
cc.append(0)
b.append(cc)
d.append(cc)
c.append(cc)
for i in range(0,n):
j=0
x=i
ans=0
while(x<n):
ans+=a[j][x]
x+=1
j+=1
x=i
j=0
while(x<n):
b[j][x]=ans
x+=1
j+=1
for i in range(1,n):
j=0
x=i
ans=0
while(x<n):
ans+=a[x][j]
x+=1
j+=1
x=i
j=0
while(x<n):
b[x][j]=ans
x+=1
j+=1
for i in range(0,n):
j=0
x=n-i-1
ans=0
while(x>=0):
ans+=a[j][x]
x-=1
j+=1
x=n-i-1
j=0
while(x>=0):
b[j][x]=ans
x-=1
j+=1
for i in range(1,n):
j=n-1
x=i
ans=0
while(x<n):
ans+=a[x][j]
x+=1
j-=1
x=i
j=n-1
while(x<n):
c[x][j]=ans
x+=1
j-=1
for i in range(0,n):
for j in range(0,n):
d[i][j]=b[i][j]+c[i][j]-a[i][j]
max=0
x=i
y=j
for i in range(0,n):
for j in range(0,n):
if max<d[i][j]:
max=d[i][j]
x=i
y=j
max1=0
x1=0
y1=0
for i in range(0,n):
for j in range(0,n):
if max1<d[i][j] and (i!=x or j!=y) and ((x+y+i+j)%2==1):
max1=d[i][j]
x1=i
y1=j
print(max+max1)
print(x,y,x1,y1)
```
No
| 374
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Alexandra has a paper strip with n numbers on it. Let's call them ai from left to right.
Now Alexandra wants to split it into some pieces (possibly 1). For each piece of strip, it must satisfy:
* Each piece should contain at least l numbers.
* The difference between the maximal and the minimal number on the piece should be at most s.
Please help Alexandra to find the minimal number of pieces meeting the condition above.
Input
The first line contains three space-separated integers n, s, l (1 β€ n β€ 105, 0 β€ s β€ 109, 1 β€ l β€ 105).
The second line contains n integers ai separated by spaces ( - 109 β€ ai β€ 109).
Output
Output the minimal number of strip pieces.
If there are no ways to split the strip, output -1.
Examples
Input
7 2 2
1 3 1 2 4 1 2
Output
3
Input
7 2 2
1 100 1 100 1 100 1
Output
-1
Note
For the first sample, we can split the strip into 3 pieces: [1, 3, 1], [2, 4], [1, 2].
For the second sample, we can't let 1 and 100 be on the same piece, so no solution exists.
Tags: binary search, data structures, dp, two pointers
Correct Solution:
```
def split(a,n,s,l):
pieces = []
i = 1
tmpmin = a[0]
tmpmax = a[0]
tmppc = [a[0]]
while i<n:
if abs(a[i]-tmpmin)<=s and abs(a[i]-tmpmax)<=s:
tmppc.append(a[i])
if a[i]<tmpmin: tmpmin=a[i]
elif a[i]>tmpmax: tmpmax = a[i]
else:
pieces.append(tmppc)
tmppc = [a[i]]
tmpmin = a[i]
tmpmax = a[i]
i += 1
pieces.append(tmppc)
fail = False
for j in range(len(pieces)):
if len(pieces[j])<l:
if j>0:
prevpc = pieces[j-1]
minj = min(pieces[j])
maxj = max(pieces[j])
while len(pieces[j])<l:
tmp = prevpc.pop()
if abs(tmp-minj)<=s and abs(tmp-maxj)<=s:
pieces[j].insert(0,tmp)
if tmp<minj: minj=tmp
elif tmp>maxj: maxj=tmp
else:
return -1
if len(prevpc)<l:
return -1
else:
return -1
return len(pieces)
n,s,l = [int(s) for s in input().split()]
a = [int(s) for s in input().split()]
res = split(a,n,s,l)
if res<0:
a.reverse()
res = split(a,n,s,l)
print(res)
```
| 375
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alexandra has a paper strip with n numbers on it. Let's call them ai from left to right.
Now Alexandra wants to split it into some pieces (possibly 1). For each piece of strip, it must satisfy:
* Each piece should contain at least l numbers.
* The difference between the maximal and the minimal number on the piece should be at most s.
Please help Alexandra to find the minimal number of pieces meeting the condition above.
Input
The first line contains three space-separated integers n, s, l (1 β€ n β€ 105, 0 β€ s β€ 109, 1 β€ l β€ 105).
The second line contains n integers ai separated by spaces ( - 109 β€ ai β€ 109).
Output
Output the minimal number of strip pieces.
If there are no ways to split the strip, output -1.
Examples
Input
7 2 2
1 3 1 2 4 1 2
Output
3
Input
7 2 2
1 100 1 100 1 100 1
Output
-1
Note
For the first sample, we can split the strip into 3 pieces: [1, 3, 1], [2, 4], [1, 2].
For the second sample, we can't let 1 and 100 be on the same piece, so no solution exists.
Submitted Solution:
```
n,s,l = [int(s) for s in input().split()]
a = [int(s) for s in input().split()]
pieces = []
m = 0
i = 1
tmpmin = a[0]
tmpmax = a[0]
tmppc = [a[0]]
while i<n:
if abs(a[i]-tmpmin)<=s and abs(a[i]-tmpmax)<=s:
tmppc.append(a[i])
if a[i]<tmpmin: tmpmin=a[i]
elif a[i]>tmpmax: tmpmax = a[i]
else:
pieces.append(tmppc)
tmppc = [a[i]]
tmpmin = a[i]
tmpmax = a[i]
i += 1
pieces.append(tmppc)
fail = False
for j in range(len(pieces)):
if len(pieces[j])<l:
if j>0:
prevpc = pieces[j-1]
minj = min(pieces[j])
maxj = max(pieces[j])
while len(pieces[j])<l:
tmp = prevpc.pop()
if abs(tmp-minj)<=s and abs(tmp-maxj)<=s:
pieces[j].insert(0,tmp)
else:
fail = True
break
if len(prevpc)<l:
fail = True
break
else:
fail = True
break
if not fail:
print(len(pieces))
else:
print(-1)
```
No
| 376
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alexandra has a paper strip with n numbers on it. Let's call them ai from left to right.
Now Alexandra wants to split it into some pieces (possibly 1). For each piece of strip, it must satisfy:
* Each piece should contain at least l numbers.
* The difference between the maximal and the minimal number on the piece should be at most s.
Please help Alexandra to find the minimal number of pieces meeting the condition above.
Input
The first line contains three space-separated integers n, s, l (1 β€ n β€ 105, 0 β€ s β€ 109, 1 β€ l β€ 105).
The second line contains n integers ai separated by spaces ( - 109 β€ ai β€ 109).
Output
Output the minimal number of strip pieces.
If there are no ways to split the strip, output -1.
Examples
Input
7 2 2
1 3 1 2 4 1 2
Output
3
Input
7 2 2
1 100 1 100 1 100 1
Output
-1
Note
For the first sample, we can split the strip into 3 pieces: [1, 3, 1], [2, 4], [1, 2].
For the second sample, we can't let 1 and 100 be on the same piece, so no solution exists.
Submitted Solution:
```
n,s,l = [int(s) for s in input().split()]
a = [int(s) for s in input().split()]
pieces = []
m = 0
i = 1
tmpmin = a[0]
tmpmax = a[0]
tmppc = [a[0]]
while i<n:
if abs(a[i]-tmpmin)<=s and abs(a[i]-tmpmax)<=s:
tmppc.append(a[i])
if a[i]<tmpmin: tmpmin=a[i]
elif a[i]>tmpmax: tmpmax = a[i]
else:
pieces.append(tmppc)
tmppc = [a[i]]
tmpmin = a[i]
tmpmax = a[i]
i += 1
pieces.append(tmppc)
fail = False
for j in range(len(pieces)):
if len(pieces[j])<l:
if j>0:
prevpc = pieces[j-1]
minj = min(pieces[j])
maxj = max(pieces[j])
while len(pieces[j])<l:
tmp = prevpc.pop()
if abs(tmp-minj)<=s and abs(tmp-maxj)<=s:
pieces[j].append(tmp)
else:
fail = True
break
if len(prevpc)<l:
fail = True
break
else:
fail = True
break
if not fail:
print(len(pieces))
else:
print(-1)
```
No
| 377
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alexandra has a paper strip with n numbers on it. Let's call them ai from left to right.
Now Alexandra wants to split it into some pieces (possibly 1). For each piece of strip, it must satisfy:
* Each piece should contain at least l numbers.
* The difference between the maximal and the minimal number on the piece should be at most s.
Please help Alexandra to find the minimal number of pieces meeting the condition above.
Input
The first line contains three space-separated integers n, s, l (1 β€ n β€ 105, 0 β€ s β€ 109, 1 β€ l β€ 105).
The second line contains n integers ai separated by spaces ( - 109 β€ ai β€ 109).
Output
Output the minimal number of strip pieces.
If there are no ways to split the strip, output -1.
Examples
Input
7 2 2
1 3 1 2 4 1 2
Output
3
Input
7 2 2
1 100 1 100 1 100 1
Output
-1
Note
For the first sample, we can split the strip into 3 pieces: [1, 3, 1], [2, 4], [1, 2].
For the second sample, we can't let 1 and 100 be on the same piece, so no solution exists.
Submitted Solution:
```
n, s, l = map(int, input().split(' '))
L = list(map(int, input().split(' ')))
ans = 1
i = l
maxi = max(L[:l])
mini = min(L[:l])
left = 0
right = i
if maxi - mini > s :
ans = -1
else :
while i < n:
new = L[i]
i+= 1
right += 1
maxi = max(maxi, new)
mini = min(mini, new)
if maxi - mini > s :
if left+l > i :
ans = -1
break
ans += 1
new_left = i
maxi = new
mini = new
while new_left != left+l :
new_left -= 1
pmaxi = maxi
pmini = mini
maxi = max(L[new_left], maxi)
mini = min(L[new_left], mini)
if maxi - mini > s :
new_left += 1
maxi = pmaxi
mini = pmini
left = new_left
break
left = new_left
print(ans)
```
No
| 378
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alexandra has a paper strip with n numbers on it. Let's call them ai from left to right.
Now Alexandra wants to split it into some pieces (possibly 1). For each piece of strip, it must satisfy:
* Each piece should contain at least l numbers.
* The difference between the maximal and the minimal number on the piece should be at most s.
Please help Alexandra to find the minimal number of pieces meeting the condition above.
Input
The first line contains three space-separated integers n, s, l (1 β€ n β€ 105, 0 β€ s β€ 109, 1 β€ l β€ 105).
The second line contains n integers ai separated by spaces ( - 109 β€ ai β€ 109).
Output
Output the minimal number of strip pieces.
If there are no ways to split the strip, output -1.
Examples
Input
7 2 2
1 3 1 2 4 1 2
Output
3
Input
7 2 2
1 100 1 100 1 100 1
Output
-1
Note
For the first sample, we can split the strip into 3 pieces: [1, 3, 1], [2, 4], [1, 2].
For the second sample, we can't let 1 and 100 be on the same piece, so no solution exists.
Submitted Solution:
```
n, s, l = map(int, input().split(' '))
L = list(map(int, input().split(' ')))
ans = 1
i = l
maxi = max(L[:l])
mini = min(L[:l])
left = 0
right = i
if maxi - mini > s :
ans = -1
else :
while i < n:
new = L[i]
i+= 1
right += 1
maxi = max(maxi, new)
mini = min(mini, new)
if maxi - mini > s :
if left+l > i-1:
ans = -1
break
ans += 1
new_left = i-1
maxi = new
mini = new
while new_left != left+l :
new_left -= 1
pmaxi = maxi
pmini = mini
maxi = max(L[new_left], maxi)
mini = min(L[new_left], mini)
if maxi - mini > s :
new_left += 1
maxi = pmaxi
mini = pmini
left = new_left
break
left = new_left
print(ans)
```
No
| 379
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 β€ n, m β€ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
Tags: implementation
Correct Solution:
```
n,m=map(int,input().split())
k=0
for i in range(n):
if i%2==0:
print("#"*m)
elif k==0:
print("."*(m-1)+"#")
k=1
else:
print("#"+"."*(m-1))
k=0
```
| 380
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 β€ n, m β€ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
Tags: implementation
Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Spyder Editor
This is a temporary script file.
"""
n, m = [int(x) for x in input().split()]
row = n
col = m
def snake(row = m):
print('#'*row)
def empty1(row = m):
row = row - 1
print('.'*row, end="")
print('#')
def empty2(row = m):
row = row - 1
print('#',end="")
print('.'*row)
count = 0
for i in range(row):
if i % 2 == 0:
snake()
elif i % 2 == 1 and count == 0:
empty1()
count = 1
elif i % 2 == 1 and count == 1 :
empty2()
count = 0
```
| 381
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 β€ n, m β€ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
Tags: implementation
Correct Solution:
```
n, m = map(int, input().split())
for i in range(n):
for j in range(m):
if(i % 2 == 0):
if(j == m-1):
print('#')
else:
print('#', sep ='', end='')
else:
if((i//2)%2 == 0):
if(j == m-1):
print('#')
else:
print('.', sep='',end='')
else:
if(j == 0):
print('#', sep='',end='')
elif(j == m-1):
print('.')
else:
print('.', sep='',end='')
```
| 382
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 β€ n, m β€ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
Tags: implementation
Correct Solution:
```
a,b =map(int,input().split())
co=0
for i in range(a):
if i%2==0:
for i in range(b):
print("#",end='')
print("")
else:
if co%2==0:
for i in range(b-1):
print(".",end='')
print("#")
co+=1
else:
print("#",end="")
for i in range(b-1):
print(".",end='')
print("")
co+=1
```
| 383
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 β€ n, m β€ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
Tags: implementation
Correct Solution:
```
n,m=map(int,input().split())
for i in range(n):
if i%2==0:
print('#'*m)
elif (i-1)%4==0:
print('.'*(m-1)+'#')
elif (i+1)%4==0:
print('#'+'.'*(m-1))
```
| 384
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 β€ n, m β€ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
Tags: implementation
Correct Solution:
```
n, m = [int(s) for s in input().split()]
e = 0
for x in range(1, n + 1):
if x % 2 != 0:
for _ in range(m):
print("#", end="")
print()
elif e % 2 == 0:
for _ in range(m - 1):
print(".", end="")
print("#")
e += 1
elif e % 2 != 0:
print("#", end="")
for _ in range(m - 1):
print(".", end="")
print()
e += 1
```
| 385
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 β€ n, m β€ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
Tags: implementation
Correct Solution:
```
a=list(map(int,input().split()))
k=1
while k<=a[0]:
if k%4==1:
for i in range(a[1]):
print('#',end='')
k+=1
print('')
elif k%4==2:
for i in range(a[1]-1):
print('.',end='')
print('#')
k+=1
elif k%4==3:
for i in range(a[1]):
print('#',end='')
print('')
k+=1
elif k%4==0:
print('#',end='')
for i in range(a[1]-1):
print('.',end='')
print('')
k+=1
```
| 386
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 β€ n, m β€ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
Tags: implementation
Correct Solution:
```
n,m=map(int,input().split())
snake="#"*m
nosnake="."*(m-1)+"#"
even=snake+"\n"+nosnake
odd=snake+"\n"+nosnake[::-1]
for i in range(n//2+1):
if(i+1>n//2):
print(snake)
else:
if(i%2==0):
print(even)
else:
print(odd)
```
| 387
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 β€ n, m β€ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
Submitted Solution:
```
def drawSnake(n,m):
hashBool = True
for row in range(n):
for col in range(m):
if row % 2 == 0:
print('#', end='')
else:
if hashBool:
hashSpace = m-1
else:
hashSpace = 0
if col == hashSpace:
print('#', end='')
else:
print('.', end='')
print()
if row % 2 == 1:
if hashBool == True:
hashBool = False
else:
hashBool = True
[n,m] = [int(x) for x in input().split()]
drawSnake(n,m)
```
Yes
| 388
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 β€ n, m β€ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
Submitted Solution:
```
line,times=map(int,input().split())
headortail=0
for i in range(line):
if (i+1)%2 == 1 :
for e in range(times):
print("#",end='')
print()
else :
if headortail == 0 :
for l in range(times-1):
print(".",end='')
print("#")
headortail =1
else :
print("#",end='')
for l in range(times-1):
print(".",end='')
print()
headortail =0
```
Yes
| 389
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 β€ n, m β€ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
Submitted Solution:
```
vector = [int(i) for i in str(input()).split()]
leftRight = 1
for i in range(vector[0]):
if i%2 ==0:
print("#"*vector[1])
else:
if leftRight ==1:
print("."*(vector[1]-1) + "#")
leftRight = 0
else:
print("#" + "."*(vector[1]-1))
leftRight = 1
```
Yes
| 390
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 β€ n, m β€ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
Submitted Solution:
```
n, m = map(int, input().split())
flag = True
while n:
if n % 2 != 0:
print("#" * m)
elif flag:
print("#".rjust(m, "."))
flag = False
else:
print("#".ljust(m, "."))
flag = True
n -= 1
```
Yes
| 391
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 β€ n, m β€ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
Submitted Solution:
```
r,c = list(map(int,input().split()))
temp = 0
for i in range(0,r):
for j in range(0,c):
if(i%2==0):
print("#",end="")
elif (temp==0):
if(j==(c-1)):
print("#",end="")
else:
print(".",end="")
temp=1
else:
if(j == 0):
print("#",end="")
else:
print(".",end="")
temp=0
print("\n")
```
No
| 392
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 β€ n, m β€ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
Submitted Solution:
```
m, n = map(int, input().split())
for i in range(1, n+1):
if i % 4 == 0:
print('#', '.' * (m-1), sep='')
elif i % 2 == 0:
print('.' * (m-1), '#', sep='')
else:
print('#' * m, sep='')
```
No
| 393
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 β€ n, m β€ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
Submitted Solution:
```
# import sys
# sys.stdin=open("input.in","r")
# sys.stdout=open("output.out","w")
l=list(map(int,input().split()))
n=l[0]
m=l[1]
count=0
for i in range(n):
if(i%2==0):
for j in range(m-1):
print("#",end=" ")
print("#")
else:
count+=1
if(count%2!=0):
for k in range(m-1):
print(".",end=" ")
print("#")
else:
print("#",end=" ")
for p in range(m-2):
print(".",end=" ")
print(".")
```
No
| 394
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 β€ n, m β€ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
Submitted Solution:
```
r,c=map(int,input().strip().split())
for i in range(c):
print("#",end="")
print()
r-=1
for i in range(1,r+1,1):
if i%2==1:
if i%3==1:
for j in range(c):
if j==c-1:
print("#",end="")
else:
print(".",end="")
else:
for j in range(c):
if j!=0:
print(".",end="")
else:
print("#",end="")
elif i%2==0:
for j in range(c):
print("#",end="")
print()
```
No
| 395
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Once again Tavas started eating coffee mix without water! Keione told him that it smells awful, but he didn't stop doing that. That's why Keione told his smart friend, SaDDas to punish him! SaDDas took Tavas' headphones and told him: "If you solve the following problem, I'll return it to you."
<image>
The problem is:
You are given a lucky number n. Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
If we sort all lucky numbers in increasing order, what's the 1-based index of n?
Tavas is not as smart as SaDDas, so he asked you to do him a favor and solve this problem so he can have his headphones back.
Input
The first and only line of input contains a lucky number n (1 β€ n β€ 109).
Output
Print the index of n among all lucky numbers.
Examples
Input
4
Output
1
Input
7
Output
2
Input
77
Output
6
Tags: bitmasks, brute force, combinatorics, implementation
Correct Solution:
```
n=input()
l=len(n)
s=0
l-=1
while l>0:
s+=2**l
l-=1
f=list(n)
f.reverse()
j=0
for i in f:
if i=='7':
s+=2**j
j+=1
s+=1
print(s)
```
| 396
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Once again Tavas started eating coffee mix without water! Keione told him that it smells awful, but he didn't stop doing that. That's why Keione told his smart friend, SaDDas to punish him! SaDDas took Tavas' headphones and told him: "If you solve the following problem, I'll return it to you."
<image>
The problem is:
You are given a lucky number n. Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
If we sort all lucky numbers in increasing order, what's the 1-based index of n?
Tavas is not as smart as SaDDas, so he asked you to do him a favor and solve this problem so he can have his headphones back.
Input
The first and only line of input contains a lucky number n (1 β€ n β€ 109).
Output
Print the index of n among all lucky numbers.
Examples
Input
4
Output
1
Input
7
Output
2
Input
77
Output
6
Tags: bitmasks, brute force, combinatorics, implementation
Correct Solution:
```
n = input()
if n=='4' :
print(1)
else:
s='4'
for i in range(2,100000):
if s[len(s)-1]=='4':
s=list(s)
s[len(s)-1]='7'
s=''.join(s)
elif '4' not in s:
l=len(s)
s=''
for j in range(l+1):
s=s+'4'
elif s[len(s)-1]=='7' :
j=len(s)-1
while s[j]=='7':
s=list(s)
s[j]='4'
j-=1
s[j]='7'
s=''.join(s)
if s==n:
print(i)
break
```
| 397
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Once again Tavas started eating coffee mix without water! Keione told him that it smells awful, but he didn't stop doing that. That's why Keione told his smart friend, SaDDas to punish him! SaDDas took Tavas' headphones and told him: "If you solve the following problem, I'll return it to you."
<image>
The problem is:
You are given a lucky number n. Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
If we sort all lucky numbers in increasing order, what's the 1-based index of n?
Tavas is not as smart as SaDDas, so he asked you to do him a favor and solve this problem so he can have his headphones back.
Input
The first and only line of input contains a lucky number n (1 β€ n β€ 109).
Output
Print the index of n among all lucky numbers.
Examples
Input
4
Output
1
Input
7
Output
2
Input
77
Output
6
Tags: bitmasks, brute force, combinatorics, implementation
Correct Solution:
```
def getDecValue(n):
n = binConvert(n)
decValue = int(n, 2)
return decValue
def binConvert(n):
narray = list(str(n))
for i in range(len(narray)):
if(narray[i] == '4'):
narray[i] = '0'
else:
narray[i] = '1'
binValue = "".join(narray)
return binValue
def getBits(n):
bitarray = list(str(n))
bits = len(bitarray)
return bits
def getLeftPos(bits):
temp = 0
for i in range(1, bits+1):
temp = temp + pow(2, i)
return temp
def getPosition(n):
decValue = int(getDecValue(n)) + 1
bits = int(getBits(n))
leftpos = getLeftPos(bits-1)
res = leftpos + decValue
return res
n = int(input())
pos = getPosition(n)
print(pos, end="")
```
| 398
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Once again Tavas started eating coffee mix without water! Keione told him that it smells awful, but he didn't stop doing that. That's why Keione told his smart friend, SaDDas to punish him! SaDDas took Tavas' headphones and told him: "If you solve the following problem, I'll return it to you."
<image>
The problem is:
You are given a lucky number n. Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
If we sort all lucky numbers in increasing order, what's the 1-based index of n?
Tavas is not as smart as SaDDas, so he asked you to do him a favor and solve this problem so he can have his headphones back.
Input
The first and only line of input contains a lucky number n (1 β€ n β€ 109).
Output
Print the index of n among all lucky numbers.
Examples
Input
4
Output
1
Input
7
Output
2
Input
77
Output
6
Tags: bitmasks, brute force, combinatorics, implementation
Correct Solution:
```
s = input().replace('7', '1').replace('4', '0')
n = 0
for i in range(1, len(s)):
n += 2**i
print(n + int(s, 2) + 1)
```
| 399
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.