message stringlengths 2 48.6k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 318 108k | cluster float64 8 8 | __index_level_0__ int64 636 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It is nighttime and Joe the Elusive got into the country's main bank's safe. The safe has n cells positioned in a row, each of them contains some amount of diamonds. Let's make the problem more comfortable to work with and mark the cells with positive numbers from 1 to n from the left to the right.
Unfortunately, Joe didn't switch the last security system off. On the plus side, he knows the way it works.
Every minute the security system calculates the total amount of diamonds for each two adjacent cells (for the cells between whose numbers difference equals 1). As a result of this check we get an n - 1 sums. If at least one of the sums differs from the corresponding sum received during the previous check, then the security system is triggered.
Joe can move the diamonds from one cell to another between the security system's checks. He manages to move them no more than m times between two checks. One of the three following operations is regarded as moving a diamond: moving a diamond from any cell to any other one, moving a diamond from any cell to Joe's pocket, moving a diamond from Joe's pocket to any cell. Initially Joe's pocket is empty, and it can carry an unlimited amount of diamonds. It is considered that before all Joe's actions the system performs at least one check.
In the morning the bank employees will come, which is why Joe has to leave the bank before that moment. Joe has only k minutes left before morning, and on each of these k minutes he can perform no more than m operations. All that remains in Joe's pocket, is considered his loot.
Calculate the largest amount of diamonds Joe can carry with him. Don't forget that the security system shouldn't be triggered (even after Joe leaves the bank) and Joe should leave before morning.
Input
The first line contains integers n, m and k (1 β€ n β€ 104, 1 β€ m, k β€ 109). The next line contains n numbers. The i-th number is equal to the amount of diamonds in the i-th cell β it is an integer from 0 to 105.
Output
Print a single number β the maximum number of diamonds Joe can steal.
Examples
Input
2 3 1
2 3
Output
0
Input
3 2 2
4 1 3
Output
2
Note
In the second sample Joe can act like this:
The diamonds' initial positions are 4 1 3.
During the first period of time Joe moves a diamond from the 1-th cell to the 2-th one and a diamond from the 3-th cell to his pocket.
By the end of the first period the diamonds' positions are 3 2 2. The check finds no difference and the security system doesn't go off.
During the second period Joe moves a diamond from the 3-rd cell to the 2-nd one and puts a diamond from the 1-st cell to his pocket.
By the end of the second period the diamonds' positions are 2 3 1. The check finds no difference again and the security system doesn't go off.
Now Joe leaves with 2 diamonds in his pocket.
Submitted Solution:
```
n,m,k=map(int,input().split())
L=list(map(int,input().split()))
if(n%2==0):
print(0)
else:
n-=1
x=n//2+1
if(m<x):
print(0)
else:
mm=L[0]
for i in range(0,n+1,2):
if(L[i]<mm):
mm=L[i]
print(min(mm,k))
``` | instruction | 0 | 33,074 | 8 | 66,148 |
No | output | 1 | 33,074 | 8 | 66,149 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It is nighttime and Joe the Elusive got into the country's main bank's safe. The safe has n cells positioned in a row, each of them contains some amount of diamonds. Let's make the problem more comfortable to work with and mark the cells with positive numbers from 1 to n from the left to the right.
Unfortunately, Joe didn't switch the last security system off. On the plus side, he knows the way it works.
Every minute the security system calculates the total amount of diamonds for each two adjacent cells (for the cells between whose numbers difference equals 1). As a result of this check we get an n - 1 sums. If at least one of the sums differs from the corresponding sum received during the previous check, then the security system is triggered.
Joe can move the diamonds from one cell to another between the security system's checks. He manages to move them no more than m times between two checks. One of the three following operations is regarded as moving a diamond: moving a diamond from any cell to any other one, moving a diamond from any cell to Joe's pocket, moving a diamond from Joe's pocket to any cell. Initially Joe's pocket is empty, and it can carry an unlimited amount of diamonds. It is considered that before all Joe's actions the system performs at least one check.
In the morning the bank employees will come, which is why Joe has to leave the bank before that moment. Joe has only k minutes left before morning, and on each of these k minutes he can perform no more than m operations. All that remains in Joe's pocket, is considered his loot.
Calculate the largest amount of diamonds Joe can carry with him. Don't forget that the security system shouldn't be triggered (even after Joe leaves the bank) and Joe should leave before morning.
Input
The first line contains integers n, m and k (1 β€ n β€ 104, 1 β€ m, k β€ 109). The next line contains n numbers. The i-th number is equal to the amount of diamonds in the i-th cell β it is an integer from 0 to 105.
Output
Print a single number β the maximum number of diamonds Joe can steal.
Examples
Input
2 3 1
2 3
Output
0
Input
3 2 2
4 1 3
Output
2
Note
In the second sample Joe can act like this:
The diamonds' initial positions are 4 1 3.
During the first period of time Joe moves a diamond from the 1-th cell to the 2-th one and a diamond from the 3-th cell to his pocket.
By the end of the first period the diamonds' positions are 3 2 2. The check finds no difference and the security system doesn't go off.
During the second period Joe moves a diamond from the 3-rd cell to the 2-nd one and puts a diamond from the 1-st cell to his pocket.
By the end of the second period the diamonds' positions are 2 3 1. The check finds no difference again and the security system doesn't go off.
Now Joe leaves with 2 diamonds in his pocket.
Submitted Solution:
```
import sys
from array import array # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
n, m, k = map(int, input().split())
a = list(map(int, input().split()))
if n == 1:
print(min(a[0], m * k))
exit()
if n % 2 == 0 or n - 1 > m:
print(0)
exit()
turn = (m // (n - 1)) * k
print(min(turn, min(a[::2])))
``` | instruction | 0 | 33,075 | 8 | 66,150 |
No | output | 1 | 33,075 | 8 | 66,151 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It is nighttime and Joe the Elusive got into the country's main bank's safe. The safe has n cells positioned in a row, each of them contains some amount of diamonds. Let's make the problem more comfortable to work with and mark the cells with positive numbers from 1 to n from the left to the right.
Unfortunately, Joe didn't switch the last security system off. On the plus side, he knows the way it works.
Every minute the security system calculates the total amount of diamonds for each two adjacent cells (for the cells between whose numbers difference equals 1). As a result of this check we get an n - 1 sums. If at least one of the sums differs from the corresponding sum received during the previous check, then the security system is triggered.
Joe can move the diamonds from one cell to another between the security system's checks. He manages to move them no more than m times between two checks. One of the three following operations is regarded as moving a diamond: moving a diamond from any cell to any other one, moving a diamond from any cell to Joe's pocket, moving a diamond from Joe's pocket to any cell. Initially Joe's pocket is empty, and it can carry an unlimited amount of diamonds. It is considered that before all Joe's actions the system performs at least one check.
In the morning the bank employees will come, which is why Joe has to leave the bank before that moment. Joe has only k minutes left before morning, and on each of these k minutes he can perform no more than m operations. All that remains in Joe's pocket, is considered his loot.
Calculate the largest amount of diamonds Joe can carry with him. Don't forget that the security system shouldn't be triggered (even after Joe leaves the bank) and Joe should leave before morning.
Input
The first line contains integers n, m and k (1 β€ n β€ 104, 1 β€ m, k β€ 109). The next line contains n numbers. The i-th number is equal to the amount of diamonds in the i-th cell β it is an integer from 0 to 105.
Output
Print a single number β the maximum number of diamonds Joe can steal.
Examples
Input
2 3 1
2 3
Output
0
Input
3 2 2
4 1 3
Output
2
Note
In the second sample Joe can act like this:
The diamonds' initial positions are 4 1 3.
During the first period of time Joe moves a diamond from the 1-th cell to the 2-th one and a diamond from the 3-th cell to his pocket.
By the end of the first period the diamonds' positions are 3 2 2. The check finds no difference and the security system doesn't go off.
During the second period Joe moves a diamond from the 3-rd cell to the 2-nd one and puts a diamond from the 1-st cell to his pocket.
By the end of the second period the diamonds' positions are 2 3 1. The check finds no difference again and the security system doesn't go off.
Now Joe leaves with 2 diamonds in his pocket.
Submitted Solution:
```
from sys import stdin
n,m,k = [int(x) for x in stdin.readline().split()]
d = [int(x) for x in stdin.readline().split()]
if n == 1:
print(min(d[0], k*m))
elif n == 2:
print(0)
elif d[0] == 0 or d[-1] == 0:
print(0)
elif n % 2 == 0:
print(0)
else:
if m >= n//2+1:
times = m//(n//2+1)
print(min(times*k, d[0], d[-1]))
else:
print(0)
``` | instruction | 0 | 33,076 | 8 | 66,152 |
No | output | 1 | 33,076 | 8 | 66,153 |
Provide a correct Python 3 solution for this coding contest problem.
An art exhibition will be held in JOI. At the art exhibition, various works of art from all over the country will be exhibited.
N works of art were collected as candidates for the works of art to be exhibited. These works of art are numbered 1, 2, ..., N. Each work of art has a set value called size and value. The size of the work of art i (1 \ leq i \ leq N) is A_i, and the value is B_i.
At the art exhibition, one or more of these works of art will be selected and exhibited. The venue for the art exhibition is large enough to display all N works of art. However, due to the aesthetic sense of the people of JOI, I would like to select works of art to be exhibited so that the size difference between the works of art does not become too large. On the other hand, I would like to exhibit as many works of art as possible. Therefore, I decided to select the works of art to be exhibited so as to meet the following conditions:
* Let A_ {max} be the size of the largest piece of art and A_ {min} be the size of the smallest piece of art selected. Also, let S be the sum of the values ββof the selected works of art.
* At this time, maximize S-(A_ {max} --A_ {min}).
Task
Given the number of candidates for the works of art to be exhibited and the size and value of each work of art, find the maximum value of S-(A_ {max} --A_ {min}).
input
Read the following input from standard input.
* The integer N is written on the first line. This represents the number of candidates for the works of art to be exhibited.
* In the i-th line (1 \ leq i \ leq N) of the following N lines, two integers A_i and B_i are written separated by a blank. These indicate that the size of the work of art i is A_i and the value is B_i.
output
Output the maximum value of S-(A_ {max} --A_ {min}) to the standard output on one line.
Limits
All input data satisfy the following conditions.
* 2 \ leq N \ leq 500 000.
* 1 \ leq A_i \ leq 1 000 000 000 000 000 = 10 ^ {15} (1 \ leq i \ leq N).
* 1 \ leq B_i \ leq 1 000 000 000 (1 \ leq i \ leq N).
Input / output example
Input example 1
3
twenty three
11 2
4 5
Output example 1
6
In this input example, there are three candidates for the works of art to be exhibited. The size and value of each work of art are as follows.
* The size of art 1 is 2 and the value is 3.
* Art 2 has a size of 11 and a value of 2.
* Art 3 has a size of 4 and a value of 5.
In this case, if you choose to display art 1 and art 3, then S-(A_ {max} --A_ {min}) = 6 as follows.
* The largest work of art selected is work of art 3. Therefore, A_ {max} = 4.
* The smallest work of art selected is work of art 1. Therefore, A_ {min} = 2.
* Since the sum of the values ββof the selected works of art is 3 + 5 = 8, S = 8.
Since it is impossible to set S-(A_ {max} --A_ {min}) to 7 or more, 6 is output.
Input example 2
6
4 1
1 5
10 3
9 1
4 2
5 3
Output example 2
7
Input example 3
15
1543361732 260774320
2089759661 257198921
1555665663 389548466
4133306295 296394520
2596448427 301103944
1701413087 274491541
2347488426 912791996
2133012079 444074242
2659886224 656957044
1345396764 259870638
2671164286 233246973
2791812672 585862344
2996614635 91065315
971304780 488995617
1523452673 988137562
Output example 3
4232545716
Creative Commons License
Information Olympics Japan Committee work "17th Japan Information Olympics (JOI 2017/2018) Final Selection"
Example
Input
3
2 3
11 2
4 5
Output
6 | instruction | 0 | 33,263 | 8 | 66,526 |
"Correct Solution:
```
import sys
sys.setrecursionlimit(2000000000)
input=lambda : sys.stdin.readline().rstrip('\n')
n=int(input())
data=[]
s=[0]
for i in range(n):
data.append(tuple(map(int,input().split())))
data=[(0,0)]+sorted(data)
for i in range(n):
s.append(s[-1]+data[i+1][1])
mx=0
ans=0
mn=10**18
for i in range(1,n+1):
if mn>s[i-1]-data[i][0]:
mn=s[i-1]-data[i][0]
if ans<s[i]-data[i][0]-mn:
ans=s[i]-data[i][0]-mn
print(ans)
``` | output | 1 | 33,263 | 8 | 66,527 |
Provide a correct Python 3 solution for this coding contest problem.
An art exhibition will be held in JOI. At the art exhibition, various works of art from all over the country will be exhibited.
N works of art were collected as candidates for the works of art to be exhibited. These works of art are numbered 1, 2, ..., N. Each work of art has a set value called size and value. The size of the work of art i (1 \ leq i \ leq N) is A_i, and the value is B_i.
At the art exhibition, one or more of these works of art will be selected and exhibited. The venue for the art exhibition is large enough to display all N works of art. However, due to the aesthetic sense of the people of JOI, I would like to select works of art to be exhibited so that the size difference between the works of art does not become too large. On the other hand, I would like to exhibit as many works of art as possible. Therefore, I decided to select the works of art to be exhibited so as to meet the following conditions:
* Let A_ {max} be the size of the largest piece of art and A_ {min} be the size of the smallest piece of art selected. Also, let S be the sum of the values ββof the selected works of art.
* At this time, maximize S-(A_ {max} --A_ {min}).
Task
Given the number of candidates for the works of art to be exhibited and the size and value of each work of art, find the maximum value of S-(A_ {max} --A_ {min}).
input
Read the following input from standard input.
* The integer N is written on the first line. This represents the number of candidates for the works of art to be exhibited.
* In the i-th line (1 \ leq i \ leq N) of the following N lines, two integers A_i and B_i are written separated by a blank. These indicate that the size of the work of art i is A_i and the value is B_i.
output
Output the maximum value of S-(A_ {max} --A_ {min}) to the standard output on one line.
Limits
All input data satisfy the following conditions.
* 2 \ leq N \ leq 500 000.
* 1 \ leq A_i \ leq 1 000 000 000 000 000 = 10 ^ {15} (1 \ leq i \ leq N).
* 1 \ leq B_i \ leq 1 000 000 000 (1 \ leq i \ leq N).
Input / output example
Input example 1
3
twenty three
11 2
4 5
Output example 1
6
In this input example, there are three candidates for the works of art to be exhibited. The size and value of each work of art are as follows.
* The size of art 1 is 2 and the value is 3.
* Art 2 has a size of 11 and a value of 2.
* Art 3 has a size of 4 and a value of 5.
In this case, if you choose to display art 1 and art 3, then S-(A_ {max} --A_ {min}) = 6 as follows.
* The largest work of art selected is work of art 3. Therefore, A_ {max} = 4.
* The smallest work of art selected is work of art 1. Therefore, A_ {min} = 2.
* Since the sum of the values ββof the selected works of art is 3 + 5 = 8, S = 8.
Since it is impossible to set S-(A_ {max} --A_ {min}) to 7 or more, 6 is output.
Input example 2
6
4 1
1 5
10 3
9 1
4 2
5 3
Output example 2
7
Input example 3
15
1543361732 260774320
2089759661 257198921
1555665663 389548466
4133306295 296394520
2596448427 301103944
1701413087 274491541
2347488426 912791996
2133012079 444074242
2659886224 656957044
1345396764 259870638
2671164286 233246973
2791812672 585862344
2996614635 91065315
971304780 488995617
1523452673 988137562
Output example 3
4232545716
Creative Commons License
Information Olympics Japan Committee work "17th Japan Information Olympics (JOI 2017/2018) Final Selection"
Example
Input
3
2 3
11 2
4 5
Output
6 | instruction | 0 | 33,264 | 8 | 66,528 |
"Correct Solution:
```
N = int(input())
P = [list(map(int, input().split())) for i in range(N)]
P.sort()
su = 0
S = -P[0][0]
ans = -10**19
for a, b in P:
S = min(S, su - a)
ans = max(ans, su + b - a - S)
su += b
print(ans)
``` | output | 1 | 33,264 | 8 | 66,529 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An art exhibition will be held in JOI. At the art exhibition, various works of art from all over the country will be exhibited.
N works of art were collected as candidates for the works of art to be exhibited. These works of art are numbered 1, 2, ..., N. Each work of art has a set value called size and value. The size of the work of art i (1 \ leq i \ leq N) is A_i, and the value is B_i.
At the art exhibition, one or more of these works of art will be selected and exhibited. The venue for the art exhibition is large enough to display all N works of art. However, due to the aesthetic sense of the people of JOI, I would like to select works of art to be exhibited so that the size difference between the works of art does not become too large. On the other hand, I would like to exhibit as many works of art as possible. Therefore, I decided to select the works of art to be exhibited so as to meet the following conditions:
* Let A_ {max} be the size of the largest piece of art and A_ {min} be the size of the smallest piece of art selected. Also, let S be the sum of the values ββof the selected works of art.
* At this time, maximize S-(A_ {max} --A_ {min}).
Task
Given the number of candidates for the works of art to be exhibited and the size and value of each work of art, find the maximum value of S-(A_ {max} --A_ {min}).
input
Read the following input from standard input.
* The integer N is written on the first line. This represents the number of candidates for the works of art to be exhibited.
* In the i-th line (1 \ leq i \ leq N) of the following N lines, two integers A_i and B_i are written separated by a blank. These indicate that the size of the work of art i is A_i and the value is B_i.
output
Output the maximum value of S-(A_ {max} --A_ {min}) to the standard output on one line.
Limits
All input data satisfy the following conditions.
* 2 \ leq N \ leq 500 000.
* 1 \ leq A_i \ leq 1 000 000 000 000 000 = 10 ^ {15} (1 \ leq i \ leq N).
* 1 \ leq B_i \ leq 1 000 000 000 (1 \ leq i \ leq N).
Input / output example
Input example 1
3
twenty three
11 2
4 5
Output example 1
6
In this input example, there are three candidates for the works of art to be exhibited. The size and value of each work of art are as follows.
* The size of art 1 is 2 and the value is 3.
* Art 2 has a size of 11 and a value of 2.
* Art 3 has a size of 4 and a value of 5.
In this case, if you choose to display art 1 and art 3, then S-(A_ {max} --A_ {min}) = 6 as follows.
* The largest work of art selected is work of art 3. Therefore, A_ {max} = 4.
* The smallest work of art selected is work of art 1. Therefore, A_ {min} = 2.
* Since the sum of the values ββof the selected works of art is 3 + 5 = 8, S = 8.
Since it is impossible to set S-(A_ {max} --A_ {min}) to 7 or more, 6 is output.
Input example 2
6
4 1
1 5
10 3
9 1
4 2
5 3
Output example 2
7
Input example 3
15
1543361732 260774320
2089759661 257198921
1555665663 389548466
4133306295 296394520
2596448427 301103944
1701413087 274491541
2347488426 912791996
2133012079 444074242
2659886224 656957044
1345396764 259870638
2671164286 233246973
2791812672 585862344
2996614635 91065315
971304780 488995617
1523452673 988137562
Output example 3
4232545716
Creative Commons License
Information Olympics Japan Committee work "17th Japan Information Olympics (JOI 2017/2018) Final Selection"
Example
Input
3
2 3
11 2
4 5
Output
6
Submitted Solution:
```
def main():
n = int(input())
lst = [tuple(map(int, input().split())) for _ in range(n)]
lst.sort(reverse=True)
ssum = 0
for i in range(n):
ssum += lst[i][1]
base = ssum + lst[-1][0]
ans = 0
acc = 0
for i in range(n):
ans = max(ans, base - acc - lst[i][0])
acc += lst[i][1]
print(ans)
main()
``` | instruction | 0 | 33,265 | 8 | 66,530 |
No | output | 1 | 33,265 | 8 | 66,531 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob Bubblestrong just got a new job as security guard. Bob is now responsible for safety of a collection of warehouses, each containing the most valuable Bubble Cup assets - the high-quality bubbles. His task is to detect thieves inside the warehouses and call the police.
Looking from the sky, each warehouse has a shape of a convex polygon. Walls of no two warehouses intersect, and of course, none of the warehouses is built inside of another warehouse.
Little did the Bubble Cup bosses know how lazy Bob is and that he enjoys watching soap operas (he heard they are full of bubbles) from the coziness of his office. Instead of going from one warehouse to another to check if warehouses are secured, the plan Bob has is to monitor all the warehouses from the comfort of his office using the special X-ray goggles. The goggles have an infinite range, so a thief in any of the warehouses could easily be spotted.
However, the goggles promptly broke and the X-rays are now strong only enough to let Bob see through a single wall. Now, Bob would really appreciate if you could help him find out what is the total area inside of the warehouses monitored by the broken goggles, so that he could know how much area of the warehouses he needs to monitor in person.
Input
The first line contains one integer N (1 β€ N β€ 10^4) β the number of warehouses.
The next N lines describe the warehouses.
The first number of the line is integer c_i (3 β€ c_i β€ 10^4) β the number corners in the i^{th} warehouse, followed by c_i pairs of integers. The j^{th} pair is (x_j, y_j) β the coordinates of the j^{th} corner (|x_j|, |y_j| β€ 3 * 10^4). The corners are listed in the clockwise order. The total number of corners in all the warehouses is at most 5 * 10^4.
Bob's office is positioned at the point with coordinates (0, 0). The office is not contained within any of the warehouses.
Output
Print a single line containing a single decimal number accurate to at least four decimal places β the total area of the warehouses Bob can monitor using the broken X-ray goggles.
Example
Input
5
4 1 1 1 3 3 3 3 1
4 4 3 6 2 6 0 4 0
6 -5 3 -4 4 -3 4 -2 3 -3 2 -4 2
3 0 -1 1 -3 -1 -3
4 1 -4 1 -6 -1 -6 -1 -4
Output
13.333333333333
Note
<image>
Areas monitored by the X-ray goggles are colored green and areas not monitored by the goggles are colored red.
The warehouses ABCD, IJK and LMNOPQ are completely monitored using the googles.
The warehouse EFGH is partially monitored using the goggles: part EFW is not monitored because to monitor each point inside it, the X-rays must go through two walls of warehouse ABCD.
The warehouse RUTS is not monitored from the Bob's office, because there are two walls of the warehouse IJK between Bob's office and each point in RUTS.
The total area monitored by the goggles is P = P_{ABCD} + P_{FGHW} + P_{IJK} + P_{LMNOPQ} = 4 + 3.333333333333 + 2 + 4 = 13.333333333333.
Submitted Solution:
```
import math
import itertools
from operator import attrgetter
class Punto:
def __init__(self,x_ent,y_ent):
self.x=x_ent
self.y=y_ent
def __str__(self):
return "x: "+str(self.x)+"\ty: "+str(self.y)
def __eq__(p1,p2):
return p1.x==p2.x and p1.y==p2.y
def ordenar(puntos,comparador):
i=1
N=len(puntos)
while True:
finalizar=1
for j in range(N-i):
if comparador(puntos[j],puntos[j+1]):
aux = puntos[j]
puntos[j] = puntos[j+1]
puntos[j+1] = aux
finalizar = 0
if finalizar:
break
i+=1
def calcularAngulos(puntos,ref):
angulos = []
for p in puntos:
p2 = Punto(p[0].x-ref.x,p[0].y-ref.y)
d = math.sqrt(p2.x*p2.x+p2.y*p2.y)
angulos.append(math.atan2(p2.y, p2.x))
return angulos
def ordenarAng(puntos,angulos):
i=1
N=len(puntos)
while True:
finalizar=1
for j in range(N-i):
if angulos[j]>angulos[j+1]:
aux = angulos[j]
angulos[j] = angulos[j+1]
angulos[j+1] = aux
aux = puntos[j]
puntos[j] = puntos[j+1]
puntos[j+1] = aux
finalizar = 0
if finalizar:
break
i+=1
class Linea:
def __init__(self,a_ent,b_ent,c_ent):
if b_ent==0:
self.a=a_ent
self.b=0
self.c=c_ent
else:
self.a=a_ent/b_ent
self.b=1.0
self.c=c_ent/b_ent
def __str__(self):
return "a: "+str(self.a)+"\tb: "+str(self.b)+"\tc: "+str(self.c)
def obtenerLinea(p1,p2):
if p1.x==p2.x:
a = 1.0
b = 0.0
c = -p1.x
else:
a = -(p1.y-p2.y)/(p1.x-p2.x)
b = 1.0
c = -(a*p1.x)-p1.y
return Linea(a,b,c)
def sonParalelas(l1,l2):
return l1.a==l2.a and l1.b==l2.b
def interseccion(l1,l2):
if sonParalelas(l1,l2):
return False,None
else:
x = (l1.b*l2.c-l1.c*l2.b)/(l2.b*l1.a-l1.b*l2.a)
if l2.b==0: #paralela al eje y
y = -(l1.a*x+l1.c)
else:
y = -(l2.a*x+l2.c)
return True,Punto(x,y)
class Poligono:
def __init__(self, lista): #suponemos que los vΓ©rtices se dan en sentido antihorario
self.puntos = lista
self.n = len(lista)
def calcularAreaGauss(self):
Area = 0
for i in range(self.n):
A = self.puntos[i]
B = self.puntos[(i+1)%self.n]
Area += (A.x*B.y-B.x*A.y)
return Area/2
def guardingWarehouses(input_data):
warehouses = input_data[1:]
poligonos = []
points = []
for pol in warehouses:
puntos = []
for i in range(pol[0]):
punto = Punto(pol[1+i*2], pol[1+i*2+1])
d = math.sqrt(punto.x*punto.x+punto.y*punto.y)
puntos.append(punto)
points.append([punto, len(poligonos), d])
puntos.reverse()
poligonos.append([Poligono(puntos), len(poligonos), pol[0]])
angulos = calcularAngulos(points,Punto(0,0))
ordenarAng(points, angulos)
visible_points = []
for i in range(len(points)):
if i==0:
visible_points.append(points[i])
else:
puntos_existentes = True
puntos_inm_ant_dif = True
while(puntos_existentes and puntos_inm_ant_dif):
puntos_existentes = False
puntos_inm_ant_dif = False
for j in range(len(visible_points)):
if visible_points[j][1] == points[i][1]:
puntos_existentes = True
if visible_points[-1][1] != points[i][1]:
puntos_inm_ant_dif = True
if(puntos_existentes and puntos_inm_ant_dif):
if points[i][2] < visible_points[-1][2]:
visible_points.pop()
else:
break
else:
visible_points.append(points[i])
cont = 1
Area = 0
for i in range(len(visible_points)-1):
if visible_points[i][1] == visible_points[i+1][1]:
cont += 1
else:
for p in poligonos:
if p[1] == visible_points[i][1] and p[2] == cont:
Area += p[0].calcularAreaGauss()
elif p[1] == visible_points[i][1] and p[2] > cont:
linea = obtenerLinea(Punto(0,0), visible_points[i+1][0])
new_vertices = []
for j in range(len(p[0].puntos)):
primero = False
segundo = False
for vp in visible_points:
if vp[1] == p[1] and p[0].puntos[j] == vp[0]:
primero = True
for vp in visible_points:
if j == (len(p[0].puntos)-1):
segundo_punto = p[0].puntos[0]
if vp[1] == p[1] and segundo_punto == vp[0]:
segundo = True
else:
segundo_punto = p[0].puntos[j+1]
if vp[1] == p[1] and segundo_punto == vp[0]:
segundo = True
if primero and segundo:
new_vertices.append(p[0].puntos[j])
if primero and not segundo:
new_vertices.append(p[0].puntos[j])
lado = obtenerLinea(p[0].puntos[j], segundo_punto)
_, inter = interseccion(linea, lado)
new_vertices.append(inter)
if not primero and segundo:
lado = obtenerLinea(p[0].puntos[j], segundo_punto)
_, inter = interseccion(linea, lado)
new_vertices.append(inter)
Area += Poligono(new_vertices).calcularAreaGauss()
cont = 1
if i == len(visible_points)-2:
for p in poligonos:
if p[1] == visible_points[i+1][1] and p[2] == cont:
Area += p[0].calcularAreaGauss()
return Area
data = []
n = int(input())
data.append(n)
for i in range(n):
c = input().split()
corners = [int(ci) for ci in c]
data.append(corners)
print(guardingWarehouses(data))
``` | instruction | 0 | 33,435 | 8 | 66,870 |
No | output | 1 | 33,435 | 8 | 66,871 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Tower of Hanoi is a well-known mathematical puzzle. It consists of three rods, and a number of disks of different sizes which can slide onto any rod. The puzzle starts with the disks in a neat stack in ascending order of size on one rod, the smallest at the top, thus making a conical shape.
The objective of the puzzle is to move the entire stack to another rod, obeying the following simple rules:
1. Only one disk can be moved at a time.
2. Each move consists of taking the upper disk from one of the stacks and placing it on top of another stack i.e. a disk can only be moved if it is the uppermost disk on a stack.
3. No disk may be placed on top of a smaller disk.
With three disks, the puzzle can be solved in seven moves. The minimum number of moves required to solve a Tower of Hanoi puzzle is 2n - 1, where n is the number of disks. (c) Wikipedia.
SmallY's puzzle is very similar to the famous Tower of Hanoi. In the Tower of Hanoi puzzle you need to solve a puzzle in minimum number of moves, in SmallY's puzzle each move costs some money and you need to solve the same puzzle but for minimal cost. At the beginning of SmallY's puzzle all n disks are on the first rod. Moving a disk from rod i to rod j (1 β€ i, j β€ 3) costs tij units of money. The goal of the puzzle is to move all the disks to the third rod.
In the problem you are given matrix t and an integer n. You need to count the minimal cost of solving SmallY's puzzle, consisting of n disks.
Input
Each of the first three lines contains three integers β matrix t. The j-th integer in the i-th line is tij (1 β€ tij β€ 10000; i β j). The following line contains a single integer n (1 β€ n β€ 40) β the number of disks.
It is guaranteed that for all i (1 β€ i β€ 3), tii = 0.
Output
Print a single integer β the minimum cost of solving SmallY's puzzle.
Examples
Input
0 1 1
1 0 1
1 1 0
3
Output
7
Input
0 2 2
1 0 100
1 2 0
3
Output
19
Input
0 2 1
1 0 100
1 2 0
5
Output
87 | instruction | 0 | 33,713 | 8 | 67,426 |
Tags: dp
Correct Solution:
```
costs = []
costs.append(list(map(int, input().split())))
costs.append(list(map(int, input().split())))
costs.append(list(map(int, input().split())))
n = int(input())
memo = {}
def cost_hanoi(n, from_, to_):
if (n, from_, to_) in memo:
return memo[(n, from_, to_)]
rods = [1, 2, 3]
other = [x for x in rods if x not in (from_, to_)][0]
if n == 1:
return min(costs[from_ - 1][to_ - 1], costs[from_ - 1][other - 1] + costs[other - 1][to_ - 1])
tactic1_s1 = min(cost_hanoi(n - 1, from_, other), cost_hanoi(n - 1, from_, to_) + cost_hanoi(n - 1, to_, other))
tactic1_s2 = costs[from_-1][to_-1]
tactic1_s3 = min(cost_hanoi(n - 1, other, to_), cost_hanoi(n - 1, other, from_) + cost_hanoi(n - 1, from_, to_))
tactic1 = tactic1_s1 + tactic1_s2 + tactic1_s3
tactic2_s1 = min(cost_hanoi(n - 1, from_, to_), cost_hanoi(n - 1, from_, other) + cost_hanoi(n - 1, other, to_))
tactic2_s2 = costs[from_-1][other-1]
tactic2_s3 = cost_hanoi(n - 1, to_, from_)
tactic2_s4 = costs[other-1][to_-1]
tactic2_s5 = min(cost_hanoi(n - 1, from_, to_), cost_hanoi(n - 1, from_, other) + cost_hanoi(n - 1, other, to_))
tactic2 = tactic2_s1 + tactic2_s2 + tactic2_s3 + tactic2_s4 + tactic2_s5
res = min(tactic1, tactic2)
memo[(n, from_, to_)] = res
return res
# print(min_hanoi(n, 1, 3))
# print(cost_hanoi(n, 1, 3))
print(cost_hanoi(n, 1, 3))
# print(min_hanoi(n, 2, 1))
# print(min_hanoi(n, 1, 3))
``` | output | 1 | 33,713 | 8 | 67,427 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Tower of Hanoi is a well-known mathematical puzzle. It consists of three rods, and a number of disks of different sizes which can slide onto any rod. The puzzle starts with the disks in a neat stack in ascending order of size on one rod, the smallest at the top, thus making a conical shape.
The objective of the puzzle is to move the entire stack to another rod, obeying the following simple rules:
1. Only one disk can be moved at a time.
2. Each move consists of taking the upper disk from one of the stacks and placing it on top of another stack i.e. a disk can only be moved if it is the uppermost disk on a stack.
3. No disk may be placed on top of a smaller disk.
With three disks, the puzzle can be solved in seven moves. The minimum number of moves required to solve a Tower of Hanoi puzzle is 2n - 1, where n is the number of disks. (c) Wikipedia.
SmallY's puzzle is very similar to the famous Tower of Hanoi. In the Tower of Hanoi puzzle you need to solve a puzzle in minimum number of moves, in SmallY's puzzle each move costs some money and you need to solve the same puzzle but for minimal cost. At the beginning of SmallY's puzzle all n disks are on the first rod. Moving a disk from rod i to rod j (1 β€ i, j β€ 3) costs tij units of money. The goal of the puzzle is to move all the disks to the third rod.
In the problem you are given matrix t and an integer n. You need to count the minimal cost of solving SmallY's puzzle, consisting of n disks.
Input
Each of the first three lines contains three integers β matrix t. The j-th integer in the i-th line is tij (1 β€ tij β€ 10000; i β j). The following line contains a single integer n (1 β€ n β€ 40) β the number of disks.
It is guaranteed that for all i (1 β€ i β€ 3), tii = 0.
Output
Print a single integer β the minimum cost of solving SmallY's puzzle.
Examples
Input
0 1 1
1 0 1
1 1 0
3
Output
7
Input
0 2 2
1 0 100
1 2 0
3
Output
19
Input
0 2 1
1 0 100
1 2 0
5
Output
87 | instruction | 0 | 33,714 | 8 | 67,428 |
Tags: dp
Correct Solution:
```
# !/bin/env python3
# coding: UTF-8
# βͺ H4WK3yEδΉ‘
# Mohd. Farhan Tahir
# Indian Institute Of Information Technology and Management,Gwalior
# Question Link
# https://codeforces.com/problemset/problem/392/B
#
# ///==========Libraries, Constants and Functions=============///
import sys
inf = float("inf")
mod = 1000000007
def get_array(): return list(map(int, sys.stdin.readline().split()))
def get_ints(): return map(int, sys.stdin.readline().split())
def input(): return sys.stdin.readline()
# ///==========MAIN=============///
def main():
dp = [[[0 for _ in range(3)] for _ in range(3)] for _ in range(43)]
matrix = [[0 for _ in range(3)] for _ in range(3)]
for i in range(3):
matrix[i] = get_array()
n = int(input())
for i in range(1, n+1):
for frm in range(3):
for to in range(3):
other = 3-frm-to
if frm == to:
continue
dp[i][frm][to] = dp[i-1][frm][other]+matrix[frm][to]+dp[i-1][other][to]
c = dp[i-1][frm][to]+matrix[frm][other] + \
dp[i-1][to][frm]+matrix[other][to]+dp[i-1][frm][to]
dp[i][frm][to] = min(c, dp[i][frm][to])
print(dp[n][0][2])
if __name__ == "__main__":
main()
``` | output | 1 | 33,714 | 8 | 67,429 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Tower of Hanoi is a well-known mathematical puzzle. It consists of three rods, and a number of disks of different sizes which can slide onto any rod. The puzzle starts with the disks in a neat stack in ascending order of size on one rod, the smallest at the top, thus making a conical shape.
The objective of the puzzle is to move the entire stack to another rod, obeying the following simple rules:
1. Only one disk can be moved at a time.
2. Each move consists of taking the upper disk from one of the stacks and placing it on top of another stack i.e. a disk can only be moved if it is the uppermost disk on a stack.
3. No disk may be placed on top of a smaller disk.
With three disks, the puzzle can be solved in seven moves. The minimum number of moves required to solve a Tower of Hanoi puzzle is 2n - 1, where n is the number of disks. (c) Wikipedia.
SmallY's puzzle is very similar to the famous Tower of Hanoi. In the Tower of Hanoi puzzle you need to solve a puzzle in minimum number of moves, in SmallY's puzzle each move costs some money and you need to solve the same puzzle but for minimal cost. At the beginning of SmallY's puzzle all n disks are on the first rod. Moving a disk from rod i to rod j (1 β€ i, j β€ 3) costs tij units of money. The goal of the puzzle is to move all the disks to the third rod.
In the problem you are given matrix t and an integer n. You need to count the minimal cost of solving SmallY's puzzle, consisting of n disks.
Input
Each of the first three lines contains three integers β matrix t. The j-th integer in the i-th line is tij (1 β€ tij β€ 10000; i β j). The following line contains a single integer n (1 β€ n β€ 40) β the number of disks.
It is guaranteed that for all i (1 β€ i β€ 3), tii = 0.
Output
Print a single integer β the minimum cost of solving SmallY's puzzle.
Examples
Input
0 1 1
1 0 1
1 1 0
3
Output
7
Input
0 2 2
1 0 100
1 2 0
3
Output
19
Input
0 2 1
1 0 100
1 2 0
5
Output
87 | instruction | 0 | 33,715 | 8 | 67,430 |
Tags: dp
Correct Solution:
```
def play(price, n):
# dp[i][j][k] - naimen'shaya stoimost' peremeshcheniya i blinov so sterzhnya j => k
# U nas vsegda est' dva varianta dejstviya:
# 1. Peremeshchaem i - 1 blin na mesto 2. Dalee, peremeshchaem i - yj blin na mesto 3. I nakonec peremeshchaem i - 1 blin na mesto 3.
# 2. Peremeshchaem i - 1 blin na mesto 3. Zatem i - yj na mesto 2, zatem i - 1 blin na mesto 1, dalee i -yj na 3-e mesto i nakonec i - 1 blin na 3 mesto
# t.e, dp[i][j][k] = min(dp[i - 1][j][k ^ j] + Price[j][k] + dp[i - 1][k ^ j][k],
# dp[i - 1][j][k] + Price[j][k ^ j] + dp[i - 1][k][j] + Price[j ^ k][k] + dp[i - 1][j][k])
dp = [[[0 for k in range(0, 4)] for j in range(0, 4)] for i in range(0, n + 1)]
for i in range(1, n + 1):
for j in range(1, 4):
for k in range(1, 4):
dp[i][j][k] = min(dp[i - 1][j][k ^ j] + price[j][k] + dp[i - 1][k ^ j][k], 2 * dp[i - 1][j][k] + price[j][k ^ j] + dp[i - 1][k][j] + price[j ^ k][k])
return dp[n][1][3]
def main():
matrix = [[0 for j in range(0, 4)] for i in range(0, 4)]
i = 1
while i < 4:
row = list(map(int, input().split()))
for j in range(1, 4):
matrix[i][j] = row[j - 1]
i += 1
n = int(input())
print(play(matrix, n))
main()
#print(play([[0, 0, 0, 0], [0, 0, 1, 1],[0, 1, 0, 1],[0, 1, 1, 0]], 3))
``` | output | 1 | 33,715 | 8 | 67,431 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Tower of Hanoi is a well-known mathematical puzzle. It consists of three rods, and a number of disks of different sizes which can slide onto any rod. The puzzle starts with the disks in a neat stack in ascending order of size on one rod, the smallest at the top, thus making a conical shape.
The objective of the puzzle is to move the entire stack to another rod, obeying the following simple rules:
1. Only one disk can be moved at a time.
2. Each move consists of taking the upper disk from one of the stacks and placing it on top of another stack i.e. a disk can only be moved if it is the uppermost disk on a stack.
3. No disk may be placed on top of a smaller disk.
With three disks, the puzzle can be solved in seven moves. The minimum number of moves required to solve a Tower of Hanoi puzzle is 2n - 1, where n is the number of disks. (c) Wikipedia.
SmallY's puzzle is very similar to the famous Tower of Hanoi. In the Tower of Hanoi puzzle you need to solve a puzzle in minimum number of moves, in SmallY's puzzle each move costs some money and you need to solve the same puzzle but for minimal cost. At the beginning of SmallY's puzzle all n disks are on the first rod. Moving a disk from rod i to rod j (1 β€ i, j β€ 3) costs tij units of money. The goal of the puzzle is to move all the disks to the third rod.
In the problem you are given matrix t and an integer n. You need to count the minimal cost of solving SmallY's puzzle, consisting of n disks.
Input
Each of the first three lines contains three integers β matrix t. The j-th integer in the i-th line is tij (1 β€ tij β€ 10000; i β j). The following line contains a single integer n (1 β€ n β€ 40) β the number of disks.
It is guaranteed that for all i (1 β€ i β€ 3), tii = 0.
Output
Print a single integer β the minimum cost of solving SmallY's puzzle.
Examples
Input
0 1 1
1 0 1
1 1 0
3
Output
7
Input
0 2 2
1 0 100
1 2 0
3
Output
19
Input
0 2 1
1 0 100
1 2 0
5
Output
87
Submitted Solution:
```
#!/usr/bin/env python
# coding: utf-8
# In[7]:
def smallYpuzzle(tCost,source,aux,des,n):
if(n==1):
path1=tCost[source-1][aux-1]+tCost[aux-1][des-1]
path2=tCost[source-1][des-1]
if(path1<path2):
return path1
else:
return path2
tempcost1=smallYpuzzle(tCost,source,des,aux,n-1)
temp1=tCost[source-1][des-1]
finalCost1=tempcost1+temp1+smallYpuzzle(tCost,aux,source,des,n-1)
tempcost2=smallYpuzzle(tCost,source,aux,des,n-1)
temp2=tCost[source-1][aux-1]
tempcost2a=smallYpuzzle(tCost,des,aux,source,n-1)
temp2b=tCost[aux-1][des-1]
finalCost2=tempcost2+temp2+tempcost2a+temp2b+smallYpuzzle(tCost,source,aux,des,n-1)
return min(finalCost1,finalCost2)
tCost=[[int(ele) for ele in input().split()]for i in range(3)]
n=int(input())
smallYpuzzle(tCost,1,2,3,n)
``` | instruction | 0 | 33,716 | 8 | 67,432 |
No | output | 1 | 33,716 | 8 | 67,433 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Tower of Hanoi is a well-known mathematical puzzle. It consists of three rods, and a number of disks of different sizes which can slide onto any rod. The puzzle starts with the disks in a neat stack in ascending order of size on one rod, the smallest at the top, thus making a conical shape.
The objective of the puzzle is to move the entire stack to another rod, obeying the following simple rules:
1. Only one disk can be moved at a time.
2. Each move consists of taking the upper disk from one of the stacks and placing it on top of another stack i.e. a disk can only be moved if it is the uppermost disk on a stack.
3. No disk may be placed on top of a smaller disk.
With three disks, the puzzle can be solved in seven moves. The minimum number of moves required to solve a Tower of Hanoi puzzle is 2n - 1, where n is the number of disks. (c) Wikipedia.
SmallY's puzzle is very similar to the famous Tower of Hanoi. In the Tower of Hanoi puzzle you need to solve a puzzle in minimum number of moves, in SmallY's puzzle each move costs some money and you need to solve the same puzzle but for minimal cost. At the beginning of SmallY's puzzle all n disks are on the first rod. Moving a disk from rod i to rod j (1 β€ i, j β€ 3) costs tij units of money. The goal of the puzzle is to move all the disks to the third rod.
In the problem you are given matrix t and an integer n. You need to count the minimal cost of solving SmallY's puzzle, consisting of n disks.
Input
Each of the first three lines contains three integers β matrix t. The j-th integer in the i-th line is tij (1 β€ tij β€ 10000; i β j). The following line contains a single integer n (1 β€ n β€ 40) β the number of disks.
It is guaranteed that for all i (1 β€ i β€ 3), tii = 0.
Output
Print a single integer β the minimum cost of solving SmallY's puzzle.
Examples
Input
0 1 1
1 0 1
1 1 0
3
Output
7
Input
0 2 2
1 0 100
1 2 0
3
Output
19
Input
0 2 1
1 0 100
1 2 0
5
Output
87
Submitted Solution:
```
import fileinput
i=0
costMatrix = []
for line in fileinput.input():
if i<3:
costMatrix.append([int(i) for i in line.split()])
i+=1
else:
n = int(line)
def switchC(MAT):
SW = [[0]*3 for i in range(3)]
SW[0][1]=MAT[0][2]
SW[0][2]=MAT[0][1]
SW[1][0]=MAT[1][0]
SW[2][0]=MAT[1][0]
SW[1][2] = MAT[2][1]
SW[2][1] = MAT[1][2]
return SW
def switchC2(MAT):
SW = [[0]*3 for i in range(3)]
SW[0][1]=MAT[1][0]
SW[0][2]=MAT[1][2]
SW[1][0]=MAT[0][1]
SW[2][0]=MAT[2][1]
SW[1][2] = MAT[0][2]
SW[2][1] = MAT[2][0]
return SW
def switchC3(MAT):
SW = [[0]*3 for i in range(3)]
SW[0][1]=MAT[2][1]
SW[0][2]=MAT[2][0]
SW[1][0]=MAT[1][2]
SW[2][0]=MAT[0][2]
SW[1][2] = MAT[1][0]
SW[2][1] = MAT[0][1]
return SW
def hashMAT(n,MAT):
M = max(n,MAT[0][1],MAT[0][2],MAT[1][0],MAT[1][2],MAT[2][0],MAT[2][1])
hashed = n + M*MAT[0][1]+M**2*MAT[0][2]+M**3*MAT[1][0]+M**4*MAT[1][2]+M**5*MAT[2][0]+M**6*MAT[2][1]
return hashed
a = {}
def SmallY(n,MAT):
h = hashMAT(n,MAT)
isIN = h in list(a.keys())
if n == 1:
if isIN:
return a[h]
else:
a[h] = min(MAT[0][2], MAT[0][1]+MAT[1][2])
return a[h]
else:
if isIN:
return a[h]
else:
a[h] = min(MAT[0][2]+SmallY(n-1,switchC(MAT))+SmallY(n-1,switchC2(MAT)),MAT[0][1]+MAT[1][2]+2*SmallY(n-1,MAT)+SmallY(n-1,switchC3(MAT)))
return a[h]
print(SmallY(n,costMatrix))
``` | instruction | 0 | 33,717 | 8 | 67,434 |
No | output | 1 | 33,717 | 8 | 67,435 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Tower of Hanoi is a well-known mathematical puzzle. It consists of three rods, and a number of disks of different sizes which can slide onto any rod. The puzzle starts with the disks in a neat stack in ascending order of size on one rod, the smallest at the top, thus making a conical shape.
The objective of the puzzle is to move the entire stack to another rod, obeying the following simple rules:
1. Only one disk can be moved at a time.
2. Each move consists of taking the upper disk from one of the stacks and placing it on top of another stack i.e. a disk can only be moved if it is the uppermost disk on a stack.
3. No disk may be placed on top of a smaller disk.
With three disks, the puzzle can be solved in seven moves. The minimum number of moves required to solve a Tower of Hanoi puzzle is 2n - 1, where n is the number of disks. (c) Wikipedia.
SmallY's puzzle is very similar to the famous Tower of Hanoi. In the Tower of Hanoi puzzle you need to solve a puzzle in minimum number of moves, in SmallY's puzzle each move costs some money and you need to solve the same puzzle but for minimal cost. At the beginning of SmallY's puzzle all n disks are on the first rod. Moving a disk from rod i to rod j (1 β€ i, j β€ 3) costs tij units of money. The goal of the puzzle is to move all the disks to the third rod.
In the problem you are given matrix t and an integer n. You need to count the minimal cost of solving SmallY's puzzle, consisting of n disks.
Input
Each of the first three lines contains three integers β matrix t. The j-th integer in the i-th line is tij (1 β€ tij β€ 10000; i β j). The following line contains a single integer n (1 β€ n β€ 40) β the number of disks.
It is guaranteed that for all i (1 β€ i β€ 3), tii = 0.
Output
Print a single integer β the minimum cost of solving SmallY's puzzle.
Examples
Input
0 1 1
1 0 1
1 1 0
3
Output
7
Input
0 2 2
1 0 100
1 2 0
3
Output
19
Input
0 2 1
1 0 100
1 2 0
5
Output
87
Submitted Solution:
```
costs = []
costs.append(list(map(int,input().split())))
costs.append(list(map(int,input().split())))
costs.append(list(map(int,input().split())))
n = int(input())
memo = {}
def min_hanoi(n,from_,to_):
if (n, from_, to_) in memo:
return memo[(n, from_, to_)]
rods = [1,2,3]
other = [x for x in rods if x not in (from_,to_)][0]
if n==1:
return min(costs[from_-1][to_-1], costs[from_-1][other-1] + costs[other-1][to_-1])
res = min(min_hanoi(n-1,from_,other), min_hanoi(n-1,from_,to_)+min_hanoi(n-1,to_,other))+min_hanoi(1,from_,to_)+min(min_hanoi(n-1,other,to_), min_hanoi(n-1,other,from_)+min_hanoi(n-1,from_,to_))
memo[(n, from_, to_)] = res
return res
print(min_hanoi(n,1,3))
``` | instruction | 0 | 33,718 | 8 | 67,436 |
No | output | 1 | 33,718 | 8 | 67,437 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Tower of Hanoi is a well-known mathematical puzzle. It consists of three rods, and a number of disks of different sizes which can slide onto any rod. The puzzle starts with the disks in a neat stack in ascending order of size on one rod, the smallest at the top, thus making a conical shape.
The objective of the puzzle is to move the entire stack to another rod, obeying the following simple rules:
1. Only one disk can be moved at a time.
2. Each move consists of taking the upper disk from one of the stacks and placing it on top of another stack i.e. a disk can only be moved if it is the uppermost disk on a stack.
3. No disk may be placed on top of a smaller disk.
With three disks, the puzzle can be solved in seven moves. The minimum number of moves required to solve a Tower of Hanoi puzzle is 2n - 1, where n is the number of disks. (c) Wikipedia.
SmallY's puzzle is very similar to the famous Tower of Hanoi. In the Tower of Hanoi puzzle you need to solve a puzzle in minimum number of moves, in SmallY's puzzle each move costs some money and you need to solve the same puzzle but for minimal cost. At the beginning of SmallY's puzzle all n disks are on the first rod. Moving a disk from rod i to rod j (1 β€ i, j β€ 3) costs tij units of money. The goal of the puzzle is to move all the disks to the third rod.
In the problem you are given matrix t and an integer n. You need to count the minimal cost of solving SmallY's puzzle, consisting of n disks.
Input
Each of the first three lines contains three integers β matrix t. The j-th integer in the i-th line is tij (1 β€ tij β€ 10000; i β j). The following line contains a single integer n (1 β€ n β€ 40) β the number of disks.
It is guaranteed that for all i (1 β€ i β€ 3), tii = 0.
Output
Print a single integer β the minimum cost of solving SmallY's puzzle.
Examples
Input
0 1 1
1 0 1
1 1 0
3
Output
7
Input
0 2 2
1 0 100
1 2 0
3
Output
19
Input
0 2 1
1 0 100
1 2 0
5
Output
87
Submitted Solution:
```
costs = []
costs.append(list(map(int,input().split())))
costs.append(list(map(int,input().split())))
costs.append(list(map(int,input().split())))
n = int(input())
memo = {}
def min_hanoi(n,from_,to_):
if (n, from_, to_) in memo:
return memo[(n, from_, to_)]
if n==1:
return costs[from_-1][to_-1]
rods = [1,2,3]
other = [x for x in rods if x not in (from_,to_)][0]
res = min(min_hanoi(n-1,from_,other), min_hanoi(n-1,from_,to_)+min_hanoi(n-1,to_,other))+min_hanoi(1,from_,to_)+min(min_hanoi(n-1,other,to_), min_hanoi(n-1,other,from_)+min_hanoi(n-1,from_,to_))
memo[(n, from_, to_)] = res
return res
print(min_hanoi(n,1,3))
``` | instruction | 0 | 33,719 | 8 | 67,438 |
No | output | 1 | 33,719 | 8 | 67,439 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arnie the Worm has finished eating an apple house yet again and decided to move. He made up his mind on the plan, the way the rooms are located and how they are joined by corridors. He numbered all the rooms from 1 to n. All the corridors are bidirectional.
Arnie wants the new house to look just like the previous one. That is, it should have exactly n rooms and, if a corridor from room i to room j existed in the old house, it should be built in the new one.
We know that during the house constructing process Arnie starts to eat an apple starting from some room and only stops when he eats his way through all the corridors and returns to the starting room. It is also known that Arnie eats without stopping. That is, until Arnie finishes constructing the house, he is busy every moment of his time gnawing a new corridor. Arnie doesn't move along the already built corridors.
However, gnawing out corridors in one and the same order any time you change a house is a very difficult activity. That's why Arnie, knowing the order in which the corridors were located in the previous house, wants to gnaw corridors in another order. It is represented as a list of rooms in the order in which they should be visited. The new list should be lexicographically smallest, but it also should be strictly lexicographically greater than the previous one. Help the worm.
Input
The first line contains two integers n and m (3 β€ n β€ 100, 3 β€ m β€ 2000). It is the number of rooms and corridors in Arnie's house correspondingly. The next line contains m + 1 positive integers that do not exceed n. They are the description of Arnie's old path represented as a list of rooms he visited during the gnawing. It is guaranteed that the last number in the list coincides with the first one.
The first room described in the list is the main entrance, that's why Arnie should begin gnawing from it.
You may assume that there is no room which is connected to itself and there is at most one corridor between any pair of rooms. However, it is possible to find some isolated rooms which are disconnected from others.
Output
Print m + 1 positive integers that do not exceed n. Those numbers are the description of the new path, according to which Arnie should gnaw out his new house. If it is impossible to find new path you should print out No solution. The first number in your answer should be equal to the last one. Also it should be equal to the main entrance.
Examples
Input
3 3
1 2 3 1
Output
1 3 2 1
Input
3 3
1 3 2 1
Output
No solution
Submitted Solution:
```
from typing import DefaultDict, List
import sys
input = sys.stdin.readline
from collections import defaultdict
############ ---- 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 find_bridges(graph: DefaultDict[int, List[int]]):
t_in = defaultdict(int)
low = defaultdict(int)
def dfs(node, parent, time):
if not t_in[node]:
return
t_in[node] = low[node] = time
for adj in graph[node]:
if not low[adj]:
dfs(adj, node, time + 1)
low[node] = min([time] + [low[adj] for adj in graph[node] if adj != parent])
dfs(node=1, parent=None, time=0)
bridges = set()
for node, adj_list in graph.items():
for neigh in adj_list:
if t_in[node] < low[neigh]:
bridges.add((node, neigh))
return bridges
def create_graph_from_path(old_path: List[int]) -> DefaultDict[int, List[int]]:
graph = defaultdict(list)
for index in range(0, len(old_path) - 1):
graph[old_path[index]].append(old_path[index + 1])
graph[old_path[index + 1]].append(old_path[index])
return graph
def build_home_path(n: int, m: int, old_path: List[int]):
"""
Parameters:
:n (int): number of rooms
:m (int): number of corridors
:old_path (list): old build path
:return: new build path
"""
graph = create_graph_from_path(old_path)
bridges = find_bridges(graph)
new_path = list()
new_path.append(old_path[0])
visited = set()
for index in range(0, len(old_path) - 1):
x = old_path[index]
y = old_path[index + 1]
max_candidates = [adj for adj in graph[x] if (x, adj) not in bridges]
if max_candidates:
z = max(max_candidates)
if z > y and (x, z) not in bridges:
new_path.append(z)
break
if new_path == old_path[0]:
return None
visited.add((old_path[0], z))
while z != old_path[0]:
min_candidates = [adj for adj in graph[z] if (adj, z) not in visited]
if min_candidates:
next_room = min(min_candidates)
if (next_room, z) not in bridges:
new_path.append(next_room)
visited.add((next_room, z))
z = next_room
else:
break
return new_path if new_path != old_path else "No solution"
nm = inlt()
n = nm[0]
m = nm[1]
old_path = inlt()
new_path = build_home_path(n, m, old_path)
if new_path != "No solution":
for i in new_path:
print(i, end=" ")
else:
print(new_path)
``` | instruction | 0 | 33,839 | 8 | 67,678 |
No | output | 1 | 33,839 | 8 | 67,679 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arnie the Worm has finished eating an apple house yet again and decided to move. He made up his mind on the plan, the way the rooms are located and how they are joined by corridors. He numbered all the rooms from 1 to n. All the corridors are bidirectional.
Arnie wants the new house to look just like the previous one. That is, it should have exactly n rooms and, if a corridor from room i to room j existed in the old house, it should be built in the new one.
We know that during the house constructing process Arnie starts to eat an apple starting from some room and only stops when he eats his way through all the corridors and returns to the starting room. It is also known that Arnie eats without stopping. That is, until Arnie finishes constructing the house, he is busy every moment of his time gnawing a new corridor. Arnie doesn't move along the already built corridors.
However, gnawing out corridors in one and the same order any time you change a house is a very difficult activity. That's why Arnie, knowing the order in which the corridors were located in the previous house, wants to gnaw corridors in another order. It is represented as a list of rooms in the order in which they should be visited. The new list should be lexicographically smallest, but it also should be strictly lexicographically greater than the previous one. Help the worm.
Input
The first line contains two integers n and m (3 β€ n β€ 100, 3 β€ m β€ 2000). It is the number of rooms and corridors in Arnie's house correspondingly. The next line contains m + 1 positive integers that do not exceed n. They are the description of Arnie's old path represented as a list of rooms he visited during the gnawing. It is guaranteed that the last number in the list coincides with the first one.
The first room described in the list is the main entrance, that's why Arnie should begin gnawing from it.
You may assume that there is no room which is connected to itself and there is at most one corridor between any pair of rooms. However, it is possible to find some isolated rooms which are disconnected from others.
Output
Print m + 1 positive integers that do not exceed n. Those numbers are the description of the new path, according to which Arnie should gnaw out his new house. If it is impossible to find new path you should print out No solution. The first number in your answer should be equal to the last one. Also it should be equal to the main entrance.
Examples
Input
3 3
1 2 3 1
Output
1 3 2 1
Input
3 3
1 3 2 1
Output
No solution
Submitted Solution:
```
from typing import DefaultDict, List
import sys
input = sys.stdin.readline
from collections import defaultdict
############ ---- 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 find_bridges(graph: DefaultDict[int, List[int]]):
t_in = defaultdict(int)
low = defaultdict(int)
def dfs(node, parent, time):
if not t_in[node]:
return
t_in[node] = low[node] = time
for adj in graph[node]:
if not low[adj]:
dfs(adj, node, time + 1)
low[node] = min([time] + [low[adj] for adj in graph[node] if adj != parent])
dfs(node=1, parent=None, time=0)
bridges = set()
for node, adj_list in graph.items():
for neigh in adj_list:
if t_in[node] < low[neigh]:
bridges.add((node, neigh))
return bridges
def create_graph_from_path(old_path: List[int]) -> DefaultDict[int, List[int]]:
graph = defaultdict(list)
for index in range(0, len(old_path) - 1):
graph[old_path[index]].append(old_path[index + 1])
graph[old_path[index + 1]].append(old_path[index])
return graph
def build_home_path(n: int, m: int, old_path: List[int]):
"""
Parameters:
:n (int): number of rooms
:m (int): number of corridors
:old_path (list): old build path
:return: new build path
"""
graph = create_graph_from_path(old_path)
bridges = find_bridges(graph)
new_path = list()
new_path.append(1)
visited = set()
for index in range(0, len(old_path) - 1):
x = old_path[index]
y = old_path[index + 1]
max_candidates = [adj for adj in graph[x] if (x, adj) not in bridges]
if max_candidates:
z = max(max_candidates)
if z > y and (x, z) not in bridges:
new_path.append(z)
break
if new_path == [1]:
return None
visited.add((1, z))
while z != 1:
min_candidates = [adj for adj in graph[z] if (adj, z) not in visited]
if min_candidates:
next_room = min(min_candidates)
if (next_room, z) not in bridges:
new_path.append(next_room)
visited.add((next_room, z))
z = next_room
else:
break
return new_path if new_path != old_path else "No solution"
nm = inlt()
n = nm[0]
m = nm[1]
old_path = inlt()
new_path = build_home_path(n, m, old_path)
if new_path != "No solution":
for i in new_path:
print(i, end=" ")
else:
print(new_path)
``` | instruction | 0 | 33,840 | 8 | 67,680 |
No | output | 1 | 33,840 | 8 | 67,681 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arnie the Worm has finished eating an apple house yet again and decided to move. He made up his mind on the plan, the way the rooms are located and how they are joined by corridors. He numbered all the rooms from 1 to n. All the corridors are bidirectional.
Arnie wants the new house to look just like the previous one. That is, it should have exactly n rooms and, if a corridor from room i to room j existed in the old house, it should be built in the new one.
We know that during the house constructing process Arnie starts to eat an apple starting from some room and only stops when he eats his way through all the corridors and returns to the starting room. It is also known that Arnie eats without stopping. That is, until Arnie finishes constructing the house, he is busy every moment of his time gnawing a new corridor. Arnie doesn't move along the already built corridors.
However, gnawing out corridors in one and the same order any time you change a house is a very difficult activity. That's why Arnie, knowing the order in which the corridors were located in the previous house, wants to gnaw corridors in another order. It is represented as a list of rooms in the order in which they should be visited. The new list should be lexicographically smallest, but it also should be strictly lexicographically greater than the previous one. Help the worm.
Input
The first line contains two integers n and m (3 β€ n β€ 100, 3 β€ m β€ 2000). It is the number of rooms and corridors in Arnie's house correspondingly. The next line contains m + 1 positive integers that do not exceed n. They are the description of Arnie's old path represented as a list of rooms he visited during the gnawing. It is guaranteed that the last number in the list coincides with the first one.
The first room described in the list is the main entrance, that's why Arnie should begin gnawing from it.
You may assume that there is no room which is connected to itself and there is at most one corridor between any pair of rooms. However, it is possible to find some isolated rooms which are disconnected from others.
Output
Print m + 1 positive integers that do not exceed n. Those numbers are the description of the new path, according to which Arnie should gnaw out his new house. If it is impossible to find new path you should print out No solution. The first number in your answer should be equal to the last one. Also it should be equal to the main entrance.
Examples
Input
3 3
1 2 3 1
Output
1 3 2 1
Input
3 3
1 3 2 1
Output
No solution
Submitted Solution:
```
from typing import DefaultDict, List
import sys
input = sys.stdin.readline
from collections import defaultdict
############ ---- 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 find_bridges(graph: DefaultDict[int, List[int]]):
t_in = defaultdict(int)
low = defaultdict(int)
def dfs(node, parent, time):
if not t_in[node]:
return
t_in[node] = low[node] = time
for adj in graph[node]:
if not low[adj]:
dfs(adj, node, time + 1)
low[node] = min([time] + [low[adj] for adj in graph[node] if adj != parent])
dfs(node=1, parent=None, time=0)
bridges = set()
for node, adj_list in graph.items():
for neigh in adj_list:
if t_in[node] < low[neigh]:
bridges.add((node, neigh))
return bridges
def create_graph_from_path(old_path: List[int]) -> DefaultDict[int, List[int]]:
graph = defaultdict(list)
for index in range(0, len(old_path) - 1):
graph[old_path[index]].append(old_path[index + 1])
graph[old_path[index + 1]].append(old_path[index])
return graph
def build_home_path(n: int, m: int, old_path: List[int]):
"""
Parameters:
:n (int): number of rooms
:m (int): number of corridors
:old_path (list): old build path
:return: new build path
"""
graph = create_graph_from_path(old_path)
bridges = find_bridges(graph)
new_path = list()
new_path.append(1)
visited = set()
for index in range(0, len(old_path) - 1):
x = old_path[index]
y = old_path[index + 1]
max_candidates = [adj for adj in graph[x] if (x, adj) not in bridges]
if max_candidates:
z = max(max_candidates)
if z > y and (x, z) not in bridges:
new_path.append(z)
break
if new_path == [1]:
return None
visited.add((1, z))
while z != 1:
min_candidates = [adj for adj in graph[z] if (adj, z) not in visited]
if min_candidates:
next_room = min(min_candidates)
if (next_room, z) not in bridges:
new_path.append(next_room)
visited.add((next_room, z))
z = next_room
else:
break
return new_path if new_path != old_path else "No solution"
nm = inlt()
n = nm[0]
m = nm[1]
old_path = inlt()
new_path = build_home_path(n, m, old_path)
for i in new_path:
print(i, end=" ")
``` | instruction | 0 | 33,841 | 8 | 67,682 |
No | output | 1 | 33,841 | 8 | 67,683 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arnie the Worm has finished eating an apple house yet again and decided to move. He made up his mind on the plan, the way the rooms are located and how they are joined by corridors. He numbered all the rooms from 1 to n. All the corridors are bidirectional.
Arnie wants the new house to look just like the previous one. That is, it should have exactly n rooms and, if a corridor from room i to room j existed in the old house, it should be built in the new one.
We know that during the house constructing process Arnie starts to eat an apple starting from some room and only stops when he eats his way through all the corridors and returns to the starting room. It is also known that Arnie eats without stopping. That is, until Arnie finishes constructing the house, he is busy every moment of his time gnawing a new corridor. Arnie doesn't move along the already built corridors.
However, gnawing out corridors in one and the same order any time you change a house is a very difficult activity. That's why Arnie, knowing the order in which the corridors were located in the previous house, wants to gnaw corridors in another order. It is represented as a list of rooms in the order in which they should be visited. The new list should be lexicographically smallest, but it also should be strictly lexicographically greater than the previous one. Help the worm.
Input
The first line contains two integers n and m (3 β€ n β€ 100, 3 β€ m β€ 2000). It is the number of rooms and corridors in Arnie's house correspondingly. The next line contains m + 1 positive integers that do not exceed n. They are the description of Arnie's old path represented as a list of rooms he visited during the gnawing. It is guaranteed that the last number in the list coincides with the first one.
The first room described in the list is the main entrance, that's why Arnie should begin gnawing from it.
You may assume that there is no room which is connected to itself and there is at most one corridor between any pair of rooms. However, it is possible to find some isolated rooms which are disconnected from others.
Output
Print m + 1 positive integers that do not exceed n. Those numbers are the description of the new path, according to which Arnie should gnaw out his new house. If it is impossible to find new path you should print out No solution. The first number in your answer should be equal to the last one. Also it should be equal to the main entrance.
Examples
Input
3 3
1 2 3 1
Output
1 3 2 1
Input
3 3
1 3 2 1
Output
No solution
Submitted Solution:
```
def build_home_path(n: int, m: int, old_path: list) -> list:
"""
Parameters:
:n (int): number of rooms
:m (int): number of corridors
:old_path (list): old build path
:return: new build path
"""
M = [[0 for j in range(n)] for i in range(n)]
higher_vertex = False
unused_edges_count = 0
while len(old_path) > 1 and not higher_vertex:
# go back on last edge in current path
next = old_path.pop()
cur = old_path[-1]
# add this edge to unused edges
M[cur - 1][next - 1] = 1
M[next - 1][cur - 1] = 1
unused_edges_count += 1
higher_vertex = exist_path_to_higher_num(cur, next, M, n)
if higher_vertex:
# ΡΠ΅ΠΏΠ΅ΡΡ ΠΏΠΎΠΉΠ΄Π΅ΠΌ ΡΠ΅ΡΠ΅Π· Π½Π΅Π΅
old_path.append(higher_vertex)
# ΡΠ΄Π°Π»ΡΠ΅ΠΌ ΠΈΠ· ΠΌΠ°ΡΡΠΈΡΡ unused edges
M[cur - 1][higher_vertex - 1] = 0
M[higher_vertex - 1][cur - 1] = 0
unused_edges_count -= 1
if not higher_vertex:
return None
# Π΅ΡΠ»ΠΈ Π½Π°ΡΠ»ΠΈ Π²ΠΎ Π²ΡΠ΅ΠΌ ΠΏΡΡΠΈ Π»ΡΡΡΠΈΠΉ Ρ
ΠΎΠ΄
# Π»ΡΡΡΠΈΠΉ Ρ
ΠΎΠ΄ - Π³Π΄Π΅-ΡΠΎ Π² ΠΊΠΎΠ½ΡΠ΅ ΠΏΠΎΠΏΠ°Π»ΠΈ Π² Π²Π΅ΡΡΠΈΠ½Ρ Ρ Π±ΠΠ»ΡΡΠΈΠΌ Π½ΠΎΠΌΠ΅ΡΠΎΠΌ
# ΡΠΎΠ³Π΄Π° Π΄Π°Π»Π΅Π΅ ΠΈΡΠ΅ΠΌ Π½Π°ΠΈΠΌΠ΅Π½ΡΡΠΈΠΉ ΡΠΉΠ»Π΅ΡΠΎΠ² ΠΏΡΡΡ
cur = old_path[-1]
comp_count = dfs(cur, M, n, [0]*n, count=0)
while comp_count > 1:
# ΠΈΡΠ΅ΠΌ Ρ
ΠΎΠ΄ Π² Π²Π΅ΡΡΠΈΠ½Ρ Ρ Π½Π°ΠΈΠΌ. Π½ΠΎΠΌΠ΅ΡΠΎΠΌ, Π½ΠΎ ΠΏΡΡΡ Π½Π΅ ΠΌΠΎΡΡ
next, comp_count = min_nonbridge_path(cur, M, n, comp_count)
# Π΅ΡΠ»ΠΈ Π²ΡΠ΅ ΠΌΠΎΡΡΡ, ΡΠΎ Π½Π΅ ΠΏΠΎΠ΄Ρ
ΠΎΠ΄ΠΈΡ
# (ΠΈΠ½Π°ΡΠ΅ Π²ΠΏΠΎΡΠ»Π΅Π΄ΡΡΠ²ΠΈΠ΅ Π½Π΅ ΡΠΌΠΎΠΆΠ΅ΠΌ ΠΎΠ±ΠΎΠΉΡΠΈ Π²ΡΠ΅ Π½Π΅ΠΈΡΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°Π½Π½ΡΠ΅ ΡΠ΅Π±ΡΠ°,
# ΠΎΠ½ΠΈ Π±ΡΠ΄ΡΡ Π² Π΄Ρ. ΠΊΠΎΠΌΠΏ. ΡΠ²ΡΠ·Π½ΠΎΡΡΠΈ)
if not next:
return None
# delete from unused
M[cur - 1][next - 1] = 0
M[next - 1][cur - 1] = 0
old_path.append(next)
cur = next
return old_path
def min_nonbridge_path(cur, M, n, comp_size):
available_paths_to = []
for i in range(n):
if M[cur - 1][i]:
available_paths_to.append(i + 1)
available_paths_to.sort()
for v in available_paths_to:
bridge, comp_size = is_bridge(cur, v, M, n, comp_size)
if not bridge:
return v, comp_size
return False, comp_size
def is_bridge(u, v, M, n, comp_size):
M[u-1][v-1] = 0
M[v-1][u-1] = 0
new_comp_size = dfs(v, M, n, [0]*n, count=0)
M[u - 1][v - 1] = 1
M[v - 1][u - 1] = 1
if new_comp_size >= comp_size - 1:
return False, new_comp_size
return True, comp_size
def exist_path_to_higher_num(cur, next, M, n):
max_v = next
for i in range(n):
if M[cur - 1][i]:
max_v = max(i+1, max_v)
return max_v if max_v > next else False
def dfs(v, M, n, visited, count=0):
visited[v - 1] = True
count += 1
for i in range(n):
if M[v - 1][i] and not visited[i]:
count = dfs(i+1, M, n, visited, count)
return count
def get_adj_matrix(n, path):
M = [[0 for _ in range(n)] for _ in range(n)]
prev = path[0]
for cur in path[1:]:
M[prev - 1][cur - 1] = 1
M[cur - 1][prev - 1] = 1
prev = cur
return M
``` | instruction | 0 | 33,842 | 8 | 67,684 |
No | output | 1 | 33,842 | 8 | 67,685 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n piles of stones of sizes a1, a2, ..., an lying on the table in front of you.
During one move you can take one pile and add it to the other. As you add pile i to pile j, the size of pile j increases by the current size of pile i, and pile i stops existing. The cost of the adding operation equals the size of the added pile.
Your task is to determine the minimum cost at which you can gather all stones in one pile.
To add some challenge, the stone piles built up conspiracy and decided that each pile will let you add to it not more than k times (after that it can only be added to another pile).
Moreover, the piles decided to puzzle you completely and told you q variants (not necessarily distinct) of what k might equal.
Your task is to find the minimum cost for each of q variants.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of stone piles. The second line contains n space-separated integers: a1, a2, ..., an (1 β€ ai β€ 109) β the initial sizes of the stone piles.
The third line contains integer q (1 β€ q β€ 105) β the number of queries. The last line contains q space-separated integers k1, k2, ..., kq (1 β€ ki β€ 105) β the values of number k for distinct queries. Note that numbers ki can repeat.
Output
Print q whitespace-separated integers β the answers to the queries in the order, in which the queries are given in the input.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
2 3 4 1 1
2
2 3
Output
9 8
Note
In the first sample one way to get the optimal answer goes like this: we add in turns the 4-th and the 5-th piles to the 2-nd one; then we add the 1-st pile to the 3-rd one; we add the 2-nd pile to the 3-rd one. The first two operations cost 1 each; the third one costs 2, the fourth one costs 5 (the size of the 2-nd pile after the first two operations is not 3, it already is 5).
In the second sample you can add the 2-nd pile to the 3-rd one (the operations costs 3); then the 1-st one to the 3-th one (the cost is 2); then the 5-th one to the 4-th one (the costs is 1); and at last, the 4-th one to the 3-rd one (the cost is 2). | instruction | 0 | 34,560 | 8 | 69,120 |
Tags: greedy
Correct Solution:
```
n = int(input())
stones = list(map(lambda t : int(t), input().split()))
q = int(input())
queries = list(map(lambda t : int(t), input().split()))
stones.sort()
added_stones = []
added_stones.append(stones[0])
for i in range(1, n, 1):
added_stones.append(stones[i] + added_stones[i - 1])
computed_queries = {}
for qidx, qq in enumerate(queries):
if qq in computed_queries:
queries[qidx] = computed_queries[qq]
continue
i = n - 2
multiplier = 1
cost = 0
while i >= 0:
pp = pow(qq, multiplier)
nexti = i - pp
if nexti < 0:
cost += added_stones[i] * multiplier
break
cost += (added_stones[i] - added_stones[nexti]) * multiplier
multiplier += 1
i = nexti
queries[qidx] = cost
computed_queries[qq] = cost
print(*queries, sep=' ')
``` | output | 1 | 34,560 | 8 | 69,121 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Fair Nut lives in n story house. a_i people live on the i-th floor of the house. Every person uses elevator twice a day: to get from the floor where he/she lives to the ground (first) floor and to get from the first floor to the floor where he/she lives, when he/she comes back home in the evening.
It was decided that elevator, when it is not used, will stay on the x-th floor, but x hasn't been chosen yet. When a person needs to get from floor a to floor b, elevator follows the simple algorithm:
* Moves from the x-th floor (initially it stays on the x-th floor) to the a-th and takes the passenger.
* Moves from the a-th floor to the b-th floor and lets out the passenger (if a equals b, elevator just opens and closes the doors, but still comes to the floor from the x-th floor).
* Moves from the b-th floor back to the x-th.
The elevator never transposes more than one person and always goes back to the floor x before transposing a next passenger. The elevator spends one unit of electricity to move between neighboring floors. So moving from the a-th floor to the b-th floor requires |a - b| units of electricity.
Your task is to help Nut to find the minimum number of electricity units, that it would be enough for one day, by choosing an optimal the x-th floor. Don't forget than elevator initially stays on the x-th floor.
Input
The first line contains one integer n (1 β€ n β€ 100) β the number of floors.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 100) β the number of people on each floor.
Output
In a single line, print the answer to the problem β the minimum number of electricity units.
Examples
Input
3
0 2 1
Output
16
Input
2
1 1
Output
4
Note
In the first example, the answer can be achieved by choosing the second floor as the x-th floor. Each person from the second floor (there are two of them) would spend 4 units of electricity per day (2 to get down and 2 to get up), and one person from the third would spend 8 units of electricity per day (4 to get down and 4 to get up). 4 β
2 + 8 β
1 = 16.
In the second example, the answer can be achieved by choosing the first floor as the x-th floor. | instruction | 0 | 35,171 | 8 | 70,342 |
Tags: brute force, implementation
Correct Solution:
```
n = int(input())
numOfPeople = list(map(int, input().split(' ')))
counter = 0
while n > 1:
counter = counter + 2*(numOfPeople[n-1]*((2*n)- 2))
n = n - 1
print(counter)
``` | output | 1 | 35,171 | 8 | 70,343 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Fair Nut lives in n story house. a_i people live on the i-th floor of the house. Every person uses elevator twice a day: to get from the floor where he/she lives to the ground (first) floor and to get from the first floor to the floor where he/she lives, when he/she comes back home in the evening.
It was decided that elevator, when it is not used, will stay on the x-th floor, but x hasn't been chosen yet. When a person needs to get from floor a to floor b, elevator follows the simple algorithm:
* Moves from the x-th floor (initially it stays on the x-th floor) to the a-th and takes the passenger.
* Moves from the a-th floor to the b-th floor and lets out the passenger (if a equals b, elevator just opens and closes the doors, but still comes to the floor from the x-th floor).
* Moves from the b-th floor back to the x-th.
The elevator never transposes more than one person and always goes back to the floor x before transposing a next passenger. The elevator spends one unit of electricity to move between neighboring floors. So moving from the a-th floor to the b-th floor requires |a - b| units of electricity.
Your task is to help Nut to find the minimum number of electricity units, that it would be enough for one day, by choosing an optimal the x-th floor. Don't forget than elevator initially stays on the x-th floor.
Input
The first line contains one integer n (1 β€ n β€ 100) β the number of floors.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 100) β the number of people on each floor.
Output
In a single line, print the answer to the problem β the minimum number of electricity units.
Examples
Input
3
0 2 1
Output
16
Input
2
1 1
Output
4
Note
In the first example, the answer can be achieved by choosing the second floor as the x-th floor. Each person from the second floor (there are two of them) would spend 4 units of electricity per day (2 to get down and 2 to get up), and one person from the third would spend 8 units of electricity per day (4 to get down and 4 to get up). 4 β
2 + 8 β
1 = 16.
In the second example, the answer can be achieved by choosing the first floor as the x-th floor. | instruction | 0 | 35,172 | 8 | 70,344 |
Tags: brute force, implementation
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
ans=0
for i in range(n):
ans+=4*a[i]*i
print(ans)
``` | output | 1 | 35,172 | 8 | 70,345 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Fair Nut lives in n story house. a_i people live on the i-th floor of the house. Every person uses elevator twice a day: to get from the floor where he/she lives to the ground (first) floor and to get from the first floor to the floor where he/she lives, when he/she comes back home in the evening.
It was decided that elevator, when it is not used, will stay on the x-th floor, but x hasn't been chosen yet. When a person needs to get from floor a to floor b, elevator follows the simple algorithm:
* Moves from the x-th floor (initially it stays on the x-th floor) to the a-th and takes the passenger.
* Moves from the a-th floor to the b-th floor and lets out the passenger (if a equals b, elevator just opens and closes the doors, but still comes to the floor from the x-th floor).
* Moves from the b-th floor back to the x-th.
The elevator never transposes more than one person and always goes back to the floor x before transposing a next passenger. The elevator spends one unit of electricity to move between neighboring floors. So moving from the a-th floor to the b-th floor requires |a - b| units of electricity.
Your task is to help Nut to find the minimum number of electricity units, that it would be enough for one day, by choosing an optimal the x-th floor. Don't forget than elevator initially stays on the x-th floor.
Input
The first line contains one integer n (1 β€ n β€ 100) β the number of floors.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 100) β the number of people on each floor.
Output
In a single line, print the answer to the problem β the minimum number of electricity units.
Examples
Input
3
0 2 1
Output
16
Input
2
1 1
Output
4
Note
In the first example, the answer can be achieved by choosing the second floor as the x-th floor. Each person from the second floor (there are two of them) would spend 4 units of electricity per day (2 to get down and 2 to get up), and one person from the third would spend 8 units of electricity per day (4 to get down and 4 to get up). 4 β
2 + 8 β
1 = 16.
In the second example, the answer can be achieved by choosing the first floor as the x-th floor. | instruction | 0 | 35,173 | 8 | 70,346 |
Tags: brute force, implementation
Correct Solution:
```
#########################################################################################################\
#########################################################################################################
###################################The_Apurv_Rathore#####################################################
#########################################################################################################
#########################################################################################################
import sys,os,io
from sys import stdin
from math import log, gcd, ceil
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_left , bisect_right
import math
alphabets = list('abcdefghijklmnopqrstuvwxyz')
#for deep recursion__________________________________________-
from types import GeneratorType
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
def ncr(n, r, p):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den,p - 2, p)) % p
def primeFactors(n):
l = []
while n % 2 == 0:
l.append(2)
n = n / 2
for i in range(3,int(math.sqrt(n))+1,2):
while n % i== 0:
l.append(int(i))
n = n / i
if n > 2:
l.append(n)
c = dict(Counter(l))
return list(set(l))
# return c
def power(x, y, p) :
res = 1
x = x % p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) :
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
#____________________GetPrimeFactors in log(n)________________________________________
def sieveForSmallestPrimeFactor():
MAXN = 100001
spf = [0 for i in range(MAXN)]
spf[1] = 1
for i in range(2, MAXN):
spf[i] = i
for i in range(4, MAXN, 2):
spf[i] = 2
for i in range(3, math.ceil(math.sqrt(MAXN))):
if (spf[i] == i):
for j in range(i * i, MAXN, i):
if (spf[j] == j):
spf[j] = i
return spf
def getPrimeFactorizationLOGN(x):
spf = sieveForSmallestPrimeFactor()
ret = list()
while (x != 1):
ret.append(spf[x])
x = x // spf[x]
return ret
#____________________________________________________________
def SieveOfEratosthenes(n):
#time complexity = nlog(log(n))
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
return prime
def si():
return input()
def divideCeil(n,x):
if (n%x==0):
return n//x
return n//x+1
def ii():
return int(input())
def li():
return list(map(int,input().split()))
#__________________________TEMPLATE__________________OVER_______________________________________________________
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r") ; sys.stdout = open("output.txt","w")
else:
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def solve():
n =ii()
a = li()
ans =10000000000000000
for x in range(1,n+1):
cur = 0
for i in range(1,n+1):
cur+=(abs(i-x)+abs(i-1)+abs(x-1))*a[i-1]
# if cur==8:
# print(x)
ans=min(cur,ans)
print(ans*2)
t = 1
# t = ii()
for _ in range(t):
solve()
``` | output | 1 | 35,173 | 8 | 70,347 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Fair Nut lives in n story house. a_i people live on the i-th floor of the house. Every person uses elevator twice a day: to get from the floor where he/she lives to the ground (first) floor and to get from the first floor to the floor where he/she lives, when he/she comes back home in the evening.
It was decided that elevator, when it is not used, will stay on the x-th floor, but x hasn't been chosen yet. When a person needs to get from floor a to floor b, elevator follows the simple algorithm:
* Moves from the x-th floor (initially it stays on the x-th floor) to the a-th and takes the passenger.
* Moves from the a-th floor to the b-th floor and lets out the passenger (if a equals b, elevator just opens and closes the doors, but still comes to the floor from the x-th floor).
* Moves from the b-th floor back to the x-th.
The elevator never transposes more than one person and always goes back to the floor x before transposing a next passenger. The elevator spends one unit of electricity to move between neighboring floors. So moving from the a-th floor to the b-th floor requires |a - b| units of electricity.
Your task is to help Nut to find the minimum number of electricity units, that it would be enough for one day, by choosing an optimal the x-th floor. Don't forget than elevator initially stays on the x-th floor.
Input
The first line contains one integer n (1 β€ n β€ 100) β the number of floors.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 100) β the number of people on each floor.
Output
In a single line, print the answer to the problem β the minimum number of electricity units.
Examples
Input
3
0 2 1
Output
16
Input
2
1 1
Output
4
Note
In the first example, the answer can be achieved by choosing the second floor as the x-th floor. Each person from the second floor (there are two of them) would spend 4 units of electricity per day (2 to get down and 2 to get up), and one person from the third would spend 8 units of electricity per day (4 to get down and 4 to get up). 4 β
2 + 8 β
1 = 16.
In the second example, the answer can be achieved by choosing the first floor as the x-th floor. | instruction | 0 | 35,174 | 8 | 70,348 |
Tags: brute force, implementation
Correct Solution:
```
Input=lambda:map(int,input().split())
n = int(input())
ans = 0
Min = float('inf')
List = list(Input())
x = List.index(max(List)) + 1
for i in range(1,n+1):
if List[i-1] != 0:
ans+= (i-1) * 4 * List[i-1]
print(ans)
``` | output | 1 | 35,174 | 8 | 70,349 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Fair Nut lives in n story house. a_i people live on the i-th floor of the house. Every person uses elevator twice a day: to get from the floor where he/she lives to the ground (first) floor and to get from the first floor to the floor where he/she lives, when he/she comes back home in the evening.
It was decided that elevator, when it is not used, will stay on the x-th floor, but x hasn't been chosen yet. When a person needs to get from floor a to floor b, elevator follows the simple algorithm:
* Moves from the x-th floor (initially it stays on the x-th floor) to the a-th and takes the passenger.
* Moves from the a-th floor to the b-th floor and lets out the passenger (if a equals b, elevator just opens and closes the doors, but still comes to the floor from the x-th floor).
* Moves from the b-th floor back to the x-th.
The elevator never transposes more than one person and always goes back to the floor x before transposing a next passenger. The elevator spends one unit of electricity to move between neighboring floors. So moving from the a-th floor to the b-th floor requires |a - b| units of electricity.
Your task is to help Nut to find the minimum number of electricity units, that it would be enough for one day, by choosing an optimal the x-th floor. Don't forget than elevator initially stays on the x-th floor.
Input
The first line contains one integer n (1 β€ n β€ 100) β the number of floors.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 100) β the number of people on each floor.
Output
In a single line, print the answer to the problem β the minimum number of electricity units.
Examples
Input
3
0 2 1
Output
16
Input
2
1 1
Output
4
Note
In the first example, the answer can be achieved by choosing the second floor as the x-th floor. Each person from the second floor (there are two of them) would spend 4 units of electricity per day (2 to get down and 2 to get up), and one person from the third would spend 8 units of electricity per day (4 to get down and 4 to get up). 4 β
2 + 8 β
1 = 16.
In the second example, the answer can be achieved by choosing the first floor as the x-th floor. | instruction | 0 | 35,175 | 8 | 70,350 |
Tags: brute force, implementation
Correct Solution:
```
n=int(input())
a=[int(x) for x in input().split()]
m=1000000000
for x in range(0, n):
temp=0
for i in range(n):
temp+=2*a[i]*(abs(i-x)+i+x)
# print (x, temp)
if temp<m:
m=temp
print (m)
``` | output | 1 | 35,175 | 8 | 70,351 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Fair Nut lives in n story house. a_i people live on the i-th floor of the house. Every person uses elevator twice a day: to get from the floor where he/she lives to the ground (first) floor and to get from the first floor to the floor where he/she lives, when he/she comes back home in the evening.
It was decided that elevator, when it is not used, will stay on the x-th floor, but x hasn't been chosen yet. When a person needs to get from floor a to floor b, elevator follows the simple algorithm:
* Moves from the x-th floor (initially it stays on the x-th floor) to the a-th and takes the passenger.
* Moves from the a-th floor to the b-th floor and lets out the passenger (if a equals b, elevator just opens and closes the doors, but still comes to the floor from the x-th floor).
* Moves from the b-th floor back to the x-th.
The elevator never transposes more than one person and always goes back to the floor x before transposing a next passenger. The elevator spends one unit of electricity to move between neighboring floors. So moving from the a-th floor to the b-th floor requires |a - b| units of electricity.
Your task is to help Nut to find the minimum number of electricity units, that it would be enough for one day, by choosing an optimal the x-th floor. Don't forget than elevator initially stays on the x-th floor.
Input
The first line contains one integer n (1 β€ n β€ 100) β the number of floors.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 100) β the number of people on each floor.
Output
In a single line, print the answer to the problem β the minimum number of electricity units.
Examples
Input
3
0 2 1
Output
16
Input
2
1 1
Output
4
Note
In the first example, the answer can be achieved by choosing the second floor as the x-th floor. Each person from the second floor (there are two of them) would spend 4 units of electricity per day (2 to get down and 2 to get up), and one person from the third would spend 8 units of electricity per day (4 to get down and 4 to get up). 4 β
2 + 8 β
1 = 16.
In the second example, the answer can be achieved by choosing the first floor as the x-th floor. | instruction | 0 | 35,176 | 8 | 70,352 |
Tags: brute force, implementation
Correct Solution:
```
#for i in range(int(input())):
n=int(input())
arr=[int(x) for x in input().split()]
final=-1
for i in range(n):
temp=2
cost=0
for j in range(i+1):
# print(arr[j],j+1)
cost+=arr[j]*(j)+abs(j-i)*arr[j]+abs(i)*arr[j]
cost+=arr[j]*(j)+abs(j-i)*arr[j]+abs(i)*arr[j]
#print(cost,i)
for j in range(i+1,n):
cost+=arr[j]*(j)+abs(j-i)*arr[j]+abs(i)*arr[j]
cost+=arr[j]*(j)+abs(j-i)*arr[j]+abs(i)*arr[j]
if cost<final or final==-1:
final=cost
#print(cost,i)
print(final)
``` | output | 1 | 35,176 | 8 | 70,353 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Fair Nut lives in n story house. a_i people live on the i-th floor of the house. Every person uses elevator twice a day: to get from the floor where he/she lives to the ground (first) floor and to get from the first floor to the floor where he/she lives, when he/she comes back home in the evening.
It was decided that elevator, when it is not used, will stay on the x-th floor, but x hasn't been chosen yet. When a person needs to get from floor a to floor b, elevator follows the simple algorithm:
* Moves from the x-th floor (initially it stays on the x-th floor) to the a-th and takes the passenger.
* Moves from the a-th floor to the b-th floor and lets out the passenger (if a equals b, elevator just opens and closes the doors, but still comes to the floor from the x-th floor).
* Moves from the b-th floor back to the x-th.
The elevator never transposes more than one person and always goes back to the floor x before transposing a next passenger. The elevator spends one unit of electricity to move between neighboring floors. So moving from the a-th floor to the b-th floor requires |a - b| units of electricity.
Your task is to help Nut to find the minimum number of electricity units, that it would be enough for one day, by choosing an optimal the x-th floor. Don't forget than elevator initially stays on the x-th floor.
Input
The first line contains one integer n (1 β€ n β€ 100) β the number of floors.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 100) β the number of people on each floor.
Output
In a single line, print the answer to the problem β the minimum number of electricity units.
Examples
Input
3
0 2 1
Output
16
Input
2
1 1
Output
4
Note
In the first example, the answer can be achieved by choosing the second floor as the x-th floor. Each person from the second floor (there are two of them) would spend 4 units of electricity per day (2 to get down and 2 to get up), and one person from the third would spend 8 units of electricity per day (4 to get down and 4 to get up). 4 β
2 + 8 β
1 = 16.
In the second example, the answer can be achieved by choosing the first floor as the x-th floor. | instruction | 0 | 35,177 | 8 | 70,354 |
Tags: brute force, implementation
Correct Solution:
```
n = int(input())
arr = [int(x) for x in input().split()]
def get_for(x):
global n, arr
ret = 0
for i in range(n):
ret += (abs(x-i) + i + x) * arr[i] * 2
return ret
mn = get_for(0)
for i in range(1, n):
mn = min(mn, get_for(i))
print(mn)
``` | output | 1 | 35,177 | 8 | 70,355 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Fair Nut lives in n story house. a_i people live on the i-th floor of the house. Every person uses elevator twice a day: to get from the floor where he/she lives to the ground (first) floor and to get from the first floor to the floor where he/she lives, when he/she comes back home in the evening.
It was decided that elevator, when it is not used, will stay on the x-th floor, but x hasn't been chosen yet. When a person needs to get from floor a to floor b, elevator follows the simple algorithm:
* Moves from the x-th floor (initially it stays on the x-th floor) to the a-th and takes the passenger.
* Moves from the a-th floor to the b-th floor and lets out the passenger (if a equals b, elevator just opens and closes the doors, but still comes to the floor from the x-th floor).
* Moves from the b-th floor back to the x-th.
The elevator never transposes more than one person and always goes back to the floor x before transposing a next passenger. The elevator spends one unit of electricity to move between neighboring floors. So moving from the a-th floor to the b-th floor requires |a - b| units of electricity.
Your task is to help Nut to find the minimum number of electricity units, that it would be enough for one day, by choosing an optimal the x-th floor. Don't forget than elevator initially stays on the x-th floor.
Input
The first line contains one integer n (1 β€ n β€ 100) β the number of floors.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 100) β the number of people on each floor.
Output
In a single line, print the answer to the problem β the minimum number of electricity units.
Examples
Input
3
0 2 1
Output
16
Input
2
1 1
Output
4
Note
In the first example, the answer can be achieved by choosing the second floor as the x-th floor. Each person from the second floor (there are two of them) would spend 4 units of electricity per day (2 to get down and 2 to get up), and one person from the third would spend 8 units of electricity per day (4 to get down and 4 to get up). 4 β
2 + 8 β
1 = 16.
In the second example, the answer can be achieved by choosing the first floor as the x-th floor. | instruction | 0 | 35,178 | 8 | 70,356 |
Tags: brute force, implementation
Correct Solution:
```
n = int(input())
ar = list(map(int, input().split()))
res = 0
for i in range(n):
res += ar[i] * 4 * i
print(res)
``` | output | 1 | 35,178 | 8 | 70,357 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Fair Nut lives in n story house. a_i people live on the i-th floor of the house. Every person uses elevator twice a day: to get from the floor where he/she lives to the ground (first) floor and to get from the first floor to the floor where he/she lives, when he/she comes back home in the evening.
It was decided that elevator, when it is not used, will stay on the x-th floor, but x hasn't been chosen yet. When a person needs to get from floor a to floor b, elevator follows the simple algorithm:
* Moves from the x-th floor (initially it stays on the x-th floor) to the a-th and takes the passenger.
* Moves from the a-th floor to the b-th floor and lets out the passenger (if a equals b, elevator just opens and closes the doors, but still comes to the floor from the x-th floor).
* Moves from the b-th floor back to the x-th.
The elevator never transposes more than one person and always goes back to the floor x before transposing a next passenger. The elevator spends one unit of electricity to move between neighboring floors. So moving from the a-th floor to the b-th floor requires |a - b| units of electricity.
Your task is to help Nut to find the minimum number of electricity units, that it would be enough for one day, by choosing an optimal the x-th floor. Don't forget than elevator initially stays on the x-th floor.
Input
The first line contains one integer n (1 β€ n β€ 100) β the number of floors.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 100) β the number of people on each floor.
Output
In a single line, print the answer to the problem β the minimum number of electricity units.
Examples
Input
3
0 2 1
Output
16
Input
2
1 1
Output
4
Note
In the first example, the answer can be achieved by choosing the second floor as the x-th floor. Each person from the second floor (there are two of them) would spend 4 units of electricity per day (2 to get down and 2 to get up), and one person from the third would spend 8 units of electricity per day (4 to get down and 4 to get up). 4 β
2 + 8 β
1 = 16.
In the second example, the answer can be achieved by choosing the first floor as the x-th floor.
Submitted Solution:
```
n = int(input())
a = [int(x) for x in input().split(' ')]
minUnits = -1
for i in range(n):
currentUnits = 0
for j in range(n):
currentUnits += 2 * a[j] * (2*(abs(i-j)+i))
if minUnits == -1:
minUnits = currentUnits
else:
minUnits = min(minUnits, currentUnits)
print(minUnits)
``` | instruction | 0 | 35,179 | 8 | 70,358 |
Yes | output | 1 | 35,179 | 8 | 70,359 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Fair Nut lives in n story house. a_i people live on the i-th floor of the house. Every person uses elevator twice a day: to get from the floor where he/she lives to the ground (first) floor and to get from the first floor to the floor where he/she lives, when he/she comes back home in the evening.
It was decided that elevator, when it is not used, will stay on the x-th floor, but x hasn't been chosen yet. When a person needs to get from floor a to floor b, elevator follows the simple algorithm:
* Moves from the x-th floor (initially it stays on the x-th floor) to the a-th and takes the passenger.
* Moves from the a-th floor to the b-th floor and lets out the passenger (if a equals b, elevator just opens and closes the doors, but still comes to the floor from the x-th floor).
* Moves from the b-th floor back to the x-th.
The elevator never transposes more than one person and always goes back to the floor x before transposing a next passenger. The elevator spends one unit of electricity to move between neighboring floors. So moving from the a-th floor to the b-th floor requires |a - b| units of electricity.
Your task is to help Nut to find the minimum number of electricity units, that it would be enough for one day, by choosing an optimal the x-th floor. Don't forget than elevator initially stays on the x-th floor.
Input
The first line contains one integer n (1 β€ n β€ 100) β the number of floors.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 100) β the number of people on each floor.
Output
In a single line, print the answer to the problem β the minimum number of electricity units.
Examples
Input
3
0 2 1
Output
16
Input
2
1 1
Output
4
Note
In the first example, the answer can be achieved by choosing the second floor as the x-th floor. Each person from the second floor (there are two of them) would spend 4 units of electricity per day (2 to get down and 2 to get up), and one person from the third would spend 8 units of electricity per day (4 to get down and 4 to get up). 4 β
2 + 8 β
1 = 16.
In the second example, the answer can be achieved by choosing the first floor as the x-th floor.
Submitted Solution:
```
t=int(input())
l=list(map(int,input().split()))
mi=float('Inf')
for i in range(t):
x=0
for j in range(t):
x+=(abs(i-j)*l[j]+j*l[j]+i*l[j])*2
if(x<mi):
mi=x
print(mi)
``` | instruction | 0 | 35,180 | 8 | 70,360 |
Yes | output | 1 | 35,180 | 8 | 70,361 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Fair Nut lives in n story house. a_i people live on the i-th floor of the house. Every person uses elevator twice a day: to get from the floor where he/she lives to the ground (first) floor and to get from the first floor to the floor where he/she lives, when he/she comes back home in the evening.
It was decided that elevator, when it is not used, will stay on the x-th floor, but x hasn't been chosen yet. When a person needs to get from floor a to floor b, elevator follows the simple algorithm:
* Moves from the x-th floor (initially it stays on the x-th floor) to the a-th and takes the passenger.
* Moves from the a-th floor to the b-th floor and lets out the passenger (if a equals b, elevator just opens and closes the doors, but still comes to the floor from the x-th floor).
* Moves from the b-th floor back to the x-th.
The elevator never transposes more than one person and always goes back to the floor x before transposing a next passenger. The elevator spends one unit of electricity to move between neighboring floors. So moving from the a-th floor to the b-th floor requires |a - b| units of electricity.
Your task is to help Nut to find the minimum number of electricity units, that it would be enough for one day, by choosing an optimal the x-th floor. Don't forget than elevator initially stays on the x-th floor.
Input
The first line contains one integer n (1 β€ n β€ 100) β the number of floors.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 100) β the number of people on each floor.
Output
In a single line, print the answer to the problem β the minimum number of electricity units.
Examples
Input
3
0 2 1
Output
16
Input
2
1 1
Output
4
Note
In the first example, the answer can be achieved by choosing the second floor as the x-th floor. Each person from the second floor (there are two of them) would spend 4 units of electricity per day (2 to get down and 2 to get up), and one person from the third would spend 8 units of electricity per day (4 to get down and 4 to get up). 4 β
2 + 8 β
1 = 16.
In the second example, the answer can be achieved by choosing the first floor as the x-th floor.
Submitted Solution:
```
def inint():
return int(input())
def inlist():
return list(map(int,input().split()))
def main():
n=inint()
a=inlist()
sol=999999999
for j in range(n):
sol1=0;x=j
for i in range(n):
sol1+=a[i]*(abs(i-x)+i+x+abs(x-0)+abs(i-0)+abs(x-i))
sol=min(sol,sol1)
print(sol)
if __name__ == "__main__":
#import profile
#profile.run("main()")
main()
``` | instruction | 0 | 35,181 | 8 | 70,362 |
Yes | output | 1 | 35,181 | 8 | 70,363 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Fair Nut lives in n story house. a_i people live on the i-th floor of the house. Every person uses elevator twice a day: to get from the floor where he/she lives to the ground (first) floor and to get from the first floor to the floor where he/she lives, when he/she comes back home in the evening.
It was decided that elevator, when it is not used, will stay on the x-th floor, but x hasn't been chosen yet. When a person needs to get from floor a to floor b, elevator follows the simple algorithm:
* Moves from the x-th floor (initially it stays on the x-th floor) to the a-th and takes the passenger.
* Moves from the a-th floor to the b-th floor and lets out the passenger (if a equals b, elevator just opens and closes the doors, but still comes to the floor from the x-th floor).
* Moves from the b-th floor back to the x-th.
The elevator never transposes more than one person and always goes back to the floor x before transposing a next passenger. The elevator spends one unit of electricity to move between neighboring floors. So moving from the a-th floor to the b-th floor requires |a - b| units of electricity.
Your task is to help Nut to find the minimum number of electricity units, that it would be enough for one day, by choosing an optimal the x-th floor. Don't forget than elevator initially stays on the x-th floor.
Input
The first line contains one integer n (1 β€ n β€ 100) β the number of floors.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 100) β the number of people on each floor.
Output
In a single line, print the answer to the problem β the minimum number of electricity units.
Examples
Input
3
0 2 1
Output
16
Input
2
1 1
Output
4
Note
In the first example, the answer can be achieved by choosing the second floor as the x-th floor. Each person from the second floor (there are two of them) would spend 4 units of electricity per day (2 to get down and 2 to get up), and one person from the third would spend 8 units of electricity per day (4 to get down and 4 to get up). 4 β
2 + 8 β
1 = 16.
In the second example, the answer can be achieved by choosing the first floor as the x-th floor.
Submitted Solution:
```
n = int(input())
ar = list(map(int, input().split(" ")))
res = 0
for i in range(n):
res += (4*i*ar[i])
print(res)
``` | instruction | 0 | 35,182 | 8 | 70,364 |
Yes | output | 1 | 35,182 | 8 | 70,365 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Fair Nut lives in n story house. a_i people live on the i-th floor of the house. Every person uses elevator twice a day: to get from the floor where he/she lives to the ground (first) floor and to get from the first floor to the floor where he/she lives, when he/she comes back home in the evening.
It was decided that elevator, when it is not used, will stay on the x-th floor, but x hasn't been chosen yet. When a person needs to get from floor a to floor b, elevator follows the simple algorithm:
* Moves from the x-th floor (initially it stays on the x-th floor) to the a-th and takes the passenger.
* Moves from the a-th floor to the b-th floor and lets out the passenger (if a equals b, elevator just opens and closes the doors, but still comes to the floor from the x-th floor).
* Moves from the b-th floor back to the x-th.
The elevator never transposes more than one person and always goes back to the floor x before transposing a next passenger. The elevator spends one unit of electricity to move between neighboring floors. So moving from the a-th floor to the b-th floor requires |a - b| units of electricity.
Your task is to help Nut to find the minimum number of electricity units, that it would be enough for one day, by choosing an optimal the x-th floor. Don't forget than elevator initially stays on the x-th floor.
Input
The first line contains one integer n (1 β€ n β€ 100) β the number of floors.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 100) β the number of people on each floor.
Output
In a single line, print the answer to the problem β the minimum number of electricity units.
Examples
Input
3
0 2 1
Output
16
Input
2
1 1
Output
4
Note
In the first example, the answer can be achieved by choosing the second floor as the x-th floor. Each person from the second floor (there are two of them) would spend 4 units of electricity per day (2 to get down and 2 to get up), and one person from the third would spend 8 units of electricity per day (4 to get down and 4 to get up). 4 β
2 + 8 β
1 = 16.
In the second example, the answer can be achieved by choosing the first floor as the x-th floor.
Submitted Solution:
```
def flor(n,a):
for i in range(n):
if a[i] == 0:
return a[0] *0
elif len(a) == 2:
return a[0]*0 + a[1] * 4
else:
return a[0]*0 + a[1] * 4 + a[2] * 8
``` | instruction | 0 | 35,183 | 8 | 70,366 |
No | output | 1 | 35,183 | 8 | 70,367 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Fair Nut lives in n story house. a_i people live on the i-th floor of the house. Every person uses elevator twice a day: to get from the floor where he/she lives to the ground (first) floor and to get from the first floor to the floor where he/she lives, when he/she comes back home in the evening.
It was decided that elevator, when it is not used, will stay on the x-th floor, but x hasn't been chosen yet. When a person needs to get from floor a to floor b, elevator follows the simple algorithm:
* Moves from the x-th floor (initially it stays on the x-th floor) to the a-th and takes the passenger.
* Moves from the a-th floor to the b-th floor and lets out the passenger (if a equals b, elevator just opens and closes the doors, but still comes to the floor from the x-th floor).
* Moves from the b-th floor back to the x-th.
The elevator never transposes more than one person and always goes back to the floor x before transposing a next passenger. The elevator spends one unit of electricity to move between neighboring floors. So moving from the a-th floor to the b-th floor requires |a - b| units of electricity.
Your task is to help Nut to find the minimum number of electricity units, that it would be enough for one day, by choosing an optimal the x-th floor. Don't forget than elevator initially stays on the x-th floor.
Input
The first line contains one integer n (1 β€ n β€ 100) β the number of floors.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 100) β the number of people on each floor.
Output
In a single line, print the answer to the problem β the minimum number of electricity units.
Examples
Input
3
0 2 1
Output
16
Input
2
1 1
Output
4
Note
In the first example, the answer can be achieved by choosing the second floor as the x-th floor. Each person from the second floor (there are two of them) would spend 4 units of electricity per day (2 to get down and 2 to get up), and one person from the third would spend 8 units of electricity per day (4 to get down and 4 to get up). 4 β
2 + 8 β
1 = 16.
In the second example, the answer can be achieved by choosing the first floor as the x-th floor.
Submitted Solution:
```
n = int(input())
arr = list(map(int, input().split()))
base = 0
bigNumber = 0
electricity = 0
temp=0
for i in range(0, len(arr)):
electricity += (i+i+1)*arr[i]*2
for i in range(1, len(arr)):
base = i
temp = 0
for j in range(0, len(arr)):
if base >= j:
temp += ((base-j)+(j+1))*2*arr[j]
elif base < j:
temp += ((j - base) + (j+ 1)) * 2 * arr[j]
if temp < electricity:
electricity = temp
print(electricity)
``` | instruction | 0 | 35,184 | 8 | 70,368 |
No | output | 1 | 35,184 | 8 | 70,369 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Fair Nut lives in n story house. a_i people live on the i-th floor of the house. Every person uses elevator twice a day: to get from the floor where he/she lives to the ground (first) floor and to get from the first floor to the floor where he/she lives, when he/she comes back home in the evening.
It was decided that elevator, when it is not used, will stay on the x-th floor, but x hasn't been chosen yet. When a person needs to get from floor a to floor b, elevator follows the simple algorithm:
* Moves from the x-th floor (initially it stays on the x-th floor) to the a-th and takes the passenger.
* Moves from the a-th floor to the b-th floor and lets out the passenger (if a equals b, elevator just opens and closes the doors, but still comes to the floor from the x-th floor).
* Moves from the b-th floor back to the x-th.
The elevator never transposes more than one person and always goes back to the floor x before transposing a next passenger. The elevator spends one unit of electricity to move between neighboring floors. So moving from the a-th floor to the b-th floor requires |a - b| units of electricity.
Your task is to help Nut to find the minimum number of electricity units, that it would be enough for one day, by choosing an optimal the x-th floor. Don't forget than elevator initially stays on the x-th floor.
Input
The first line contains one integer n (1 β€ n β€ 100) β the number of floors.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 100) β the number of people on each floor.
Output
In a single line, print the answer to the problem β the minimum number of electricity units.
Examples
Input
3
0 2 1
Output
16
Input
2
1 1
Output
4
Note
In the first example, the answer can be achieved by choosing the second floor as the x-th floor. Each person from the second floor (there are two of them) would spend 4 units of electricity per day (2 to get down and 2 to get up), and one person from the third would spend 8 units of electricity per day (4 to get down and 4 to get up). 4 β
2 + 8 β
1 = 16.
In the second example, the answer can be achieved by choosing the first floor as the x-th floor.
Submitted Solution:
```
n = int(input())
a = [0]+list(map(int, input().split()))
mindist = 800*n
for x in range(1, n+1):
dist = sum([ 4*a[i]*(max(a[i],x)-1) for i in range(1,n+1)])
mindist = min(dist, mindist)
print(mindist)
``` | instruction | 0 | 35,185 | 8 | 70,370 |
No | output | 1 | 35,185 | 8 | 70,371 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Fair Nut lives in n story house. a_i people live on the i-th floor of the house. Every person uses elevator twice a day: to get from the floor where he/she lives to the ground (first) floor and to get from the first floor to the floor where he/she lives, when he/she comes back home in the evening.
It was decided that elevator, when it is not used, will stay on the x-th floor, but x hasn't been chosen yet. When a person needs to get from floor a to floor b, elevator follows the simple algorithm:
* Moves from the x-th floor (initially it stays on the x-th floor) to the a-th and takes the passenger.
* Moves from the a-th floor to the b-th floor and lets out the passenger (if a equals b, elevator just opens and closes the doors, but still comes to the floor from the x-th floor).
* Moves from the b-th floor back to the x-th.
The elevator never transposes more than one person and always goes back to the floor x before transposing a next passenger. The elevator spends one unit of electricity to move between neighboring floors. So moving from the a-th floor to the b-th floor requires |a - b| units of electricity.
Your task is to help Nut to find the minimum number of electricity units, that it would be enough for one day, by choosing an optimal the x-th floor. Don't forget than elevator initially stays on the x-th floor.
Input
The first line contains one integer n (1 β€ n β€ 100) β the number of floors.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 100) β the number of people on each floor.
Output
In a single line, print the answer to the problem β the minimum number of electricity units.
Examples
Input
3
0 2 1
Output
16
Input
2
1 1
Output
4
Note
In the first example, the answer can be achieved by choosing the second floor as the x-th floor. Each person from the second floor (there are two of them) would spend 4 units of electricity per day (2 to get down and 2 to get up), and one person from the third would spend 8 units of electricity per day (4 to get down and 4 to get up). 4 β
2 + 8 β
1 = 16.
In the second example, the answer can be achieved by choosing the first floor as the x-th floor.
Submitted Solution:
```
import math
n = int(input())
a = list(map(int, input().strip().split()))
minim = 10000000000000
su = 0
for j in range(1,len(a)):
su = 0
for i in range(1,len(a)+1):
su += a[i-1]*(abs(j-i)+abs(i-1)+abs(j-1))*2
if(su < minim):
minim = su
print(minim)
``` | instruction | 0 | 35,186 | 8 | 70,372 |
No | output | 1 | 35,186 | 8 | 70,373 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A sky scraper with 1000 floors has been built in the city of N. It has modern superfast elevators to help to travel from one floor to another. Each elevator has two doors, the front one and the back one. If one goes in through the front door, he goes out through the back one and vice versa. The elevator has two rails numbered with numbers 1 and 2. Rail 1 is located to the left of the entrance to the front door (or correspondingly, to the right of the entrance to the back door). Rail 2 is located opposite it, to the right of the entrance to the front door and to the left of the entrance to the back door. We know that each person in the city of N holds at a rail with the strongest hand.
One day a VIP person visited the city and of course, he took a look at the skyscraper and took a ride in the elevator. We know the door through which he entered and the rail he was holding at. Now we need to determine as soon as possible whether he is left-handed or right-handed.
Input
The first line indicates the door through which the very important person entered the elevator. It contains "front" if the person enters the elevator through the front door and "back" if he entered the elevator through the back door. The second line contains integer a (1 β€ a β€ 2) which denotes the number of the rail at which the person was holding.
Output
Print character "R" if the VIP is right-handed or "L" if he is left-handed.
Examples
Input
front
1
Output
L
Submitted Solution:
```
with open('input.txt') as f:
lines = f.readlines()
file = open('output.txt','a')
s = lines[0]
n = int(lines[1])
if n == 1 and s == "front":
file.write("L")
elif n == 2 and s == "back":
file.write("L")
elif n == 1 and s == "back":
file.write("R")
elif n == 2 and s == "front":
file.write("R")
``` | instruction | 0 | 35,248 | 8 | 70,496 |
No | output | 1 | 35,248 | 8 | 70,497 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A sky scraper with 1000 floors has been built in the city of N. It has modern superfast elevators to help to travel from one floor to another. Each elevator has two doors, the front one and the back one. If one goes in through the front door, he goes out through the back one and vice versa. The elevator has two rails numbered with numbers 1 and 2. Rail 1 is located to the left of the entrance to the front door (or correspondingly, to the right of the entrance to the back door). Rail 2 is located opposite it, to the right of the entrance to the front door and to the left of the entrance to the back door. We know that each person in the city of N holds at a rail with the strongest hand.
One day a VIP person visited the city and of course, he took a look at the skyscraper and took a ride in the elevator. We know the door through which he entered and the rail he was holding at. Now we need to determine as soon as possible whether he is left-handed or right-handed.
Input
The first line indicates the door through which the very important person entered the elevator. It contains "front" if the person enters the elevator through the front door and "back" if he entered the elevator through the back door. The second line contains integer a (1 β€ a β€ 2) which denotes the number of the rail at which the person was holding.
Output
Print character "R" if the VIP is right-handed or "L" if he is left-handed.
Examples
Input
front
1
Output
L
Submitted Solution:
```
w, r = open('output.txt', 'w'), open('input.txt', 'r')
d, n = r.read(), r.read()
w.write('R' if (str(d) == 'front') ^ (str(n) == '1') else 'L')
``` | instruction | 0 | 35,249 | 8 | 70,498 |
No | output | 1 | 35,249 | 8 | 70,499 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A sky scraper with 1000 floors has been built in the city of N. It has modern superfast elevators to help to travel from one floor to another. Each elevator has two doors, the front one and the back one. If one goes in through the front door, he goes out through the back one and vice versa. The elevator has two rails numbered with numbers 1 and 2. Rail 1 is located to the left of the entrance to the front door (or correspondingly, to the right of the entrance to the back door). Rail 2 is located opposite it, to the right of the entrance to the front door and to the left of the entrance to the back door. We know that each person in the city of N holds at a rail with the strongest hand.
One day a VIP person visited the city and of course, he took a look at the skyscraper and took a ride in the elevator. We know the door through which he entered and the rail he was holding at. Now we need to determine as soon as possible whether he is left-handed or right-handed.
Input
The first line indicates the door through which the very important person entered the elevator. It contains "front" if the person enters the elevator through the front door and "back" if he entered the elevator through the back door. The second line contains integer a (1 β€ a β€ 2) which denotes the number of the rail at which the person was holding.
Output
Print character "R" if the VIP is right-handed or "L" if he is left-handed.
Examples
Input
front
1
Output
L
Submitted Solution:
```
import sys
sys.stdin=open('input.txt','r')
sys.stdout=open('output.txt','w')
door,rail = input(),input()
if((door=='front' and rail==' 1') or (door=='back' and rail==' 2')):
ans="L"
else:
ans="R"
print(ans)
``` | instruction | 0 | 35,250 | 8 | 70,500 |
No | output | 1 | 35,250 | 8 | 70,501 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A sky scraper with 1000 floors has been built in the city of N. It has modern superfast elevators to help to travel from one floor to another. Each elevator has two doors, the front one and the back one. If one goes in through the front door, he goes out through the back one and vice versa. The elevator has two rails numbered with numbers 1 and 2. Rail 1 is located to the left of the entrance to the front door (or correspondingly, to the right of the entrance to the back door). Rail 2 is located opposite it, to the right of the entrance to the front door and to the left of the entrance to the back door. We know that each person in the city of N holds at a rail with the strongest hand.
One day a VIP person visited the city and of course, he took a look at the skyscraper and took a ride in the elevator. We know the door through which he entered and the rail he was holding at. Now we need to determine as soon as possible whether he is left-handed or right-handed.
Input
The first line indicates the door through which the very important person entered the elevator. It contains "front" if the person enters the elevator through the front door and "back" if he entered the elevator through the back door. The second line contains integer a (1 β€ a β€ 2) which denotes the number of the rail at which the person was holding.
Output
Print character "R" if the VIP is right-handed or "L" if he is left-handed.
Examples
Input
front
1
Output
L
Submitted Solution:
```
with open('input.txt') as f:
lines = f.readlines()
file = open('output.txt','a')
s = lines[0]
n = int(lines[1])
if s == "front":
if n == 1 :
file.write("R")
else :
file.write("L")
else :
if n == 1 :
file.write("L")
else :
file.write("R")
``` | instruction | 0 | 35,251 | 8 | 70,502 |
No | output | 1 | 35,251 | 8 | 70,503 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a robot in a warehouse and n packages he wants to collect. The warehouse can be represented as a coordinate grid. Initially, the robot stays at the point (0, 0). The i-th package is at the point (x_i, y_i). It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The robot is semi-broken and only can move up ('U') and right ('R'). In other words, in one move the robot can go from the point (x, y) to the point (x + 1, y) or to the point (x, y + 1).
As we say above, the robot wants to collect all n packages (in arbitrary order). He wants to do it with the minimum possible number of moves. If there are several possible traversals, the robot wants to choose the lexicographically smallest path.
The string s of length n is lexicographically less than the string t of length n if there is some index 1 β€ j β€ n that for all i from 1 to j-1 s_i = t_i and s_j < t_j. It is the standard comparison of string, like in a dictionary. Most programming languages compare strings in this way.
Input
The first line of the input contains an integer t (1 β€ t β€ 100) β the number of test cases. Then test cases follow.
The first line of a test case contains one integer n (1 β€ n β€ 1000) β the number of packages.
The next n lines contain descriptions of packages. The i-th package is given as two integers x_i and y_i (0 β€ x_i, y_i β€ 1000) β the x-coordinate of the package and the y-coordinate of the package.
It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The sum of all values n over test cases in the test doesn't exceed 1000.
Output
Print the answer for each test case.
If it is impossible to collect all n packages in some order starting from (0,0), print "NO" on the first line.
Otherwise, print "YES" in the first line. Then print the shortest path β a string consisting of characters 'R' and 'U'. Among all such paths choose the lexicographically smallest path.
Note that in this problem "YES" and "NO" can be only uppercase words, i.e. "Yes", "no" and "YeS" are not acceptable.
Example
Input
3
5
1 3
1 2
3 3
5 5
4 3
2
1 0
0 1
1
4 3
Output
YES
RUUURRRRUU
NO
YES
RRRRUUU
Note
For the first test case in the example the optimal path RUUURRRRUU is shown below:
<image>
Submitted Solution:
```
t = int(input())
def solve():
n = int(input())
packages = []
moves = []
for _ in range(n):
a, b = map(int, input().split())
packages.append((a, b))
packages.sort()
x = 0
y = 0
for px, py in packages:
while x != px or y != py:
if px > x:
x += 1
moves.append('R')
elif py > y:
y += 1
moves.append('U')
else:
print("NO")
return
print("YES")
ans = ''.join(moves)
print(ans)
for _ in range(t):
solve()
``` | instruction | 0 | 35,308 | 8 | 70,616 |
Yes | output | 1 | 35,308 | 8 | 70,617 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a robot in a warehouse and n packages he wants to collect. The warehouse can be represented as a coordinate grid. Initially, the robot stays at the point (0, 0). The i-th package is at the point (x_i, y_i). It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The robot is semi-broken and only can move up ('U') and right ('R'). In other words, in one move the robot can go from the point (x, y) to the point (x + 1, y) or to the point (x, y + 1).
As we say above, the robot wants to collect all n packages (in arbitrary order). He wants to do it with the minimum possible number of moves. If there are several possible traversals, the robot wants to choose the lexicographically smallest path.
The string s of length n is lexicographically less than the string t of length n if there is some index 1 β€ j β€ n that for all i from 1 to j-1 s_i = t_i and s_j < t_j. It is the standard comparison of string, like in a dictionary. Most programming languages compare strings in this way.
Input
The first line of the input contains an integer t (1 β€ t β€ 100) β the number of test cases. Then test cases follow.
The first line of a test case contains one integer n (1 β€ n β€ 1000) β the number of packages.
The next n lines contain descriptions of packages. The i-th package is given as two integers x_i and y_i (0 β€ x_i, y_i β€ 1000) β the x-coordinate of the package and the y-coordinate of the package.
It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The sum of all values n over test cases in the test doesn't exceed 1000.
Output
Print the answer for each test case.
If it is impossible to collect all n packages in some order starting from (0,0), print "NO" on the first line.
Otherwise, print "YES" in the first line. Then print the shortest path β a string consisting of characters 'R' and 'U'. Among all such paths choose the lexicographically smallest path.
Note that in this problem "YES" and "NO" can be only uppercase words, i.e. "Yes", "no" and "YeS" are not acceptable.
Example
Input
3
5
1 3
1 2
3 3
5 5
4 3
2
1 0
0 1
1
4 3
Output
YES
RUUURRRRUU
NO
YES
RRRRUUU
Note
For the first test case in the example the optimal path RUUURRRRUU is shown below:
<image>
Submitted Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
packages = [tuple(map(int,input().split())) for _ in range(n)]
packages = sorted(packages)
done = False
for p1,p2 in zip(packages[:-1],packages[1:]):
if p1[1]>p2[1]:
print ("NO")
done = True
break
if done:
continue
x = 0
y = 0
steps = ""
for a,b in packages:
steps += "R"*(a-x)
steps += "U"*(b-y)
x = a
y = b
print ("YES")
print (steps)
``` | instruction | 0 | 35,309 | 8 | 70,618 |
Yes | output | 1 | 35,309 | 8 | 70,619 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a robot in a warehouse and n packages he wants to collect. The warehouse can be represented as a coordinate grid. Initially, the robot stays at the point (0, 0). The i-th package is at the point (x_i, y_i). It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The robot is semi-broken and only can move up ('U') and right ('R'). In other words, in one move the robot can go from the point (x, y) to the point (x + 1, y) or to the point (x, y + 1).
As we say above, the robot wants to collect all n packages (in arbitrary order). He wants to do it with the minimum possible number of moves. If there are several possible traversals, the robot wants to choose the lexicographically smallest path.
The string s of length n is lexicographically less than the string t of length n if there is some index 1 β€ j β€ n that for all i from 1 to j-1 s_i = t_i and s_j < t_j. It is the standard comparison of string, like in a dictionary. Most programming languages compare strings in this way.
Input
The first line of the input contains an integer t (1 β€ t β€ 100) β the number of test cases. Then test cases follow.
The first line of a test case contains one integer n (1 β€ n β€ 1000) β the number of packages.
The next n lines contain descriptions of packages. The i-th package is given as two integers x_i and y_i (0 β€ x_i, y_i β€ 1000) β the x-coordinate of the package and the y-coordinate of the package.
It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The sum of all values n over test cases in the test doesn't exceed 1000.
Output
Print the answer for each test case.
If it is impossible to collect all n packages in some order starting from (0,0), print "NO" on the first line.
Otherwise, print "YES" in the first line. Then print the shortest path β a string consisting of characters 'R' and 'U'. Among all such paths choose the lexicographically smallest path.
Note that in this problem "YES" and "NO" can be only uppercase words, i.e. "Yes", "no" and "YeS" are not acceptable.
Example
Input
3
5
1 3
1 2
3 3
5 5
4 3
2
1 0
0 1
1
4 3
Output
YES
RUUURRRRUU
NO
YES
RRRRUUU
Note
For the first test case in the example the optimal path RUUURRRRUU is shown below:
<image>
Submitted Solution:
```
t = int(input())
ans = []
for j in range(t):
n = int(input())
arr = []
for i in range(n):
s = input().split()
arr.append( (int(s[0]), int(s[1])) )
a = 'YES'
for x in range(len(arr)):
for y in range(len(arr)):
if arr[x][0]>arr[y][0] and arr[x][1]< arr[y][1]:
a = 'NO'
if a == 'NO':
break
if a == 'YES':
arr.sort()
x = 0
y = 0
a += '\n'
while True:
if len(arr) < 1:
break
if x < arr[0][0]:
a += 'R'
x += 1
elif y < arr[0][1]:
a += 'U'
y += 1
else:
arr = arr[1:]
ans.append(a)
for aa in ans:
print(aa)
``` | instruction | 0 | 35,310 | 8 | 70,620 |
Yes | output | 1 | 35,310 | 8 | 70,621 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a robot in a warehouse and n packages he wants to collect. The warehouse can be represented as a coordinate grid. Initially, the robot stays at the point (0, 0). The i-th package is at the point (x_i, y_i). It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The robot is semi-broken and only can move up ('U') and right ('R'). In other words, in one move the robot can go from the point (x, y) to the point (x + 1, y) or to the point (x, y + 1).
As we say above, the robot wants to collect all n packages (in arbitrary order). He wants to do it with the minimum possible number of moves. If there are several possible traversals, the robot wants to choose the lexicographically smallest path.
The string s of length n is lexicographically less than the string t of length n if there is some index 1 β€ j β€ n that for all i from 1 to j-1 s_i = t_i and s_j < t_j. It is the standard comparison of string, like in a dictionary. Most programming languages compare strings in this way.
Input
The first line of the input contains an integer t (1 β€ t β€ 100) β the number of test cases. Then test cases follow.
The first line of a test case contains one integer n (1 β€ n β€ 1000) β the number of packages.
The next n lines contain descriptions of packages. The i-th package is given as two integers x_i and y_i (0 β€ x_i, y_i β€ 1000) β the x-coordinate of the package and the y-coordinate of the package.
It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The sum of all values n over test cases in the test doesn't exceed 1000.
Output
Print the answer for each test case.
If it is impossible to collect all n packages in some order starting from (0,0), print "NO" on the first line.
Otherwise, print "YES" in the first line. Then print the shortest path β a string consisting of characters 'R' and 'U'. Among all such paths choose the lexicographically smallest path.
Note that in this problem "YES" and "NO" can be only uppercase words, i.e. "Yes", "no" and "YeS" are not acceptable.
Example
Input
3
5
1 3
1 2
3 3
5 5
4 3
2
1 0
0 1
1
4 3
Output
YES
RUUURRRRUU
NO
YES
RRRRUUU
Note
For the first test case in the example the optimal path RUUURRRRUU is shown below:
<image>
Submitted Solution:
```
import sys
T = int(sys.stdin.readline())
while T:
n = int(sys.stdin.readline())
packages = []
for i in range(n):
packages.append(list(map(int, sys.stdin.readline().rstrip().split())))
for pack in packages:
pack.append(pack[0]+pack[1])
packages.sort(key=lambda x: x[2])
prev=[0,0]
flag = True
answer = ""
for pack in packages:
if pack[0] < prev[0] or pack[1] < prev[1]:
flag=False
break
right = pack[0] - prev[0]
up = pack[1] - prev[1]
answer += right*"R" + up*"U"
prev[0] = pack[0]
prev[1] = pack[1]
if flag:
print("YES")
print(answer)
else:
print("NO")
T-=1
``` | instruction | 0 | 35,311 | 8 | 70,622 |
Yes | output | 1 | 35,311 | 8 | 70,623 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a robot in a warehouse and n packages he wants to collect. The warehouse can be represented as a coordinate grid. Initially, the robot stays at the point (0, 0). The i-th package is at the point (x_i, y_i). It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The robot is semi-broken and only can move up ('U') and right ('R'). In other words, in one move the robot can go from the point (x, y) to the point (x + 1, y) or to the point (x, y + 1).
As we say above, the robot wants to collect all n packages (in arbitrary order). He wants to do it with the minimum possible number of moves. If there are several possible traversals, the robot wants to choose the lexicographically smallest path.
The string s of length n is lexicographically less than the string t of length n if there is some index 1 β€ j β€ n that for all i from 1 to j-1 s_i = t_i and s_j < t_j. It is the standard comparison of string, like in a dictionary. Most programming languages compare strings in this way.
Input
The first line of the input contains an integer t (1 β€ t β€ 100) β the number of test cases. Then test cases follow.
The first line of a test case contains one integer n (1 β€ n β€ 1000) β the number of packages.
The next n lines contain descriptions of packages. The i-th package is given as two integers x_i and y_i (0 β€ x_i, y_i β€ 1000) β the x-coordinate of the package and the y-coordinate of the package.
It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The sum of all values n over test cases in the test doesn't exceed 1000.
Output
Print the answer for each test case.
If it is impossible to collect all n packages in some order starting from (0,0), print "NO" on the first line.
Otherwise, print "YES" in the first line. Then print the shortest path β a string consisting of characters 'R' and 'U'. Among all such paths choose the lexicographically smallest path.
Note that in this problem "YES" and "NO" can be only uppercase words, i.e. "Yes", "no" and "YeS" are not acceptable.
Example
Input
3
5
1 3
1 2
3 3
5 5
4 3
2
1 0
0 1
1
4 3
Output
YES
RUUURRRRUU
NO
YES
RRRRUUU
Note
For the first test case in the example the optimal path RUUURRRRUU is shown below:
<image>
Submitted Solution:
```
t = int(input())
while t > 0:
n = int(input())
x = []
while n > 0:
x.append(list(map(int, input().split())))
n -= 1
x = sorted(x)
print(x)
vujs, kotis = [], []
for xy in x:
vujs.append(xy[0])
kotis.append(xy[1])
print(vujs, kotis)
if vujs == sorted(vujs) and kotis == sorted(kotis):
print('YES')
moves = 0
pos = [0, 0]
command = ''
for xy in x:
while pos[0] != xy[0] and pos[1] != xy[1]:
pos[0] += 1
pos[1] += 1
command += 'RU'
if pos[0] == xy[0] and pos[1] != xy[1]:
pos[1] += 1
command += 'U'
if pos[1] == xy[1] and pos[0] != xy[0]:
pos[0] += 1
print(command)
else:
print('NO')
t -= 1
``` | instruction | 0 | 35,312 | 8 | 70,624 |
No | output | 1 | 35,312 | 8 | 70,625 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a robot in a warehouse and n packages he wants to collect. The warehouse can be represented as a coordinate grid. Initially, the robot stays at the point (0, 0). The i-th package is at the point (x_i, y_i). It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The robot is semi-broken and only can move up ('U') and right ('R'). In other words, in one move the robot can go from the point (x, y) to the point (x + 1, y) or to the point (x, y + 1).
As we say above, the robot wants to collect all n packages (in arbitrary order). He wants to do it with the minimum possible number of moves. If there are several possible traversals, the robot wants to choose the lexicographically smallest path.
The string s of length n is lexicographically less than the string t of length n if there is some index 1 β€ j β€ n that for all i from 1 to j-1 s_i = t_i and s_j < t_j. It is the standard comparison of string, like in a dictionary. Most programming languages compare strings in this way.
Input
The first line of the input contains an integer t (1 β€ t β€ 100) β the number of test cases. Then test cases follow.
The first line of a test case contains one integer n (1 β€ n β€ 1000) β the number of packages.
The next n lines contain descriptions of packages. The i-th package is given as two integers x_i and y_i (0 β€ x_i, y_i β€ 1000) β the x-coordinate of the package and the y-coordinate of the package.
It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The sum of all values n over test cases in the test doesn't exceed 1000.
Output
Print the answer for each test case.
If it is impossible to collect all n packages in some order starting from (0,0), print "NO" on the first line.
Otherwise, print "YES" in the first line. Then print the shortest path β a string consisting of characters 'R' and 'U'. Among all such paths choose the lexicographically smallest path.
Note that in this problem "YES" and "NO" can be only uppercase words, i.e. "Yes", "no" and "YeS" are not acceptable.
Example
Input
3
5
1 3
1 2
3 3
5 5
4 3
2
1 0
0 1
1
4 3
Output
YES
RUUURRRRUU
NO
YES
RRRRUUU
Note
For the first test case in the example the optimal path RUUURRRRUU is shown below:
<image>
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Spyder Editor
This is a temporary script file.
"""
def robot():
nbrOfPacks=int(input())
if nbrOfPacks==0:
return False
packsPositions=[]
for i in range(0,nbrOfPacks):
current=input()
processed=current.split()
packsPositions.append([int(processed[0]),int(processed[1])])
packsPositions.sort(key=lambda x: x[0])
myPosition=[0,0]
path=""
xsDone=[0,0]
while len(packsPositions)!=0:
if packsPositions[0][0]<0 or packsPositions[0][1]<0:
return False
elif packsPositions[0][0]==xsDone[0] and myPosition[1]>packsPositions[0][1] \
and len(path)!=0 and path[-1]=="U":
packsPositions=packsPositions[1:]
elif myPosition[0]>packsPositions[0][0] or myPosition[1]>packsPositions[0][1]:
return False
break
elif packsPositions[0][0]==myPosition[0]:
temp=packsPositions[0][1]-myPosition[1]
path+=("U"*temp)
xsDone=packsPositions[0]
myPosition[1]+=temp
packsPositions=packsPositions[1:]
elif packsPositions[0][0]>myPosition[0]:
path+="R"
myPosition[0]+=1
return path
repeat=int(input())
for i in range(0,repeat):
tempo=robot()
if type(tempo)==bool or len(tempo)==0:
print("NO")
elif type(tempo)==str:
print("YES")
print(tempo)
``` | instruction | 0 | 35,313 | 8 | 70,626 |
No | output | 1 | 35,313 | 8 | 70,627 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a robot in a warehouse and n packages he wants to collect. The warehouse can be represented as a coordinate grid. Initially, the robot stays at the point (0, 0). The i-th package is at the point (x_i, y_i). It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The robot is semi-broken and only can move up ('U') and right ('R'). In other words, in one move the robot can go from the point (x, y) to the point (x + 1, y) or to the point (x, y + 1).
As we say above, the robot wants to collect all n packages (in arbitrary order). He wants to do it with the minimum possible number of moves. If there are several possible traversals, the robot wants to choose the lexicographically smallest path.
The string s of length n is lexicographically less than the string t of length n if there is some index 1 β€ j β€ n that for all i from 1 to j-1 s_i = t_i and s_j < t_j. It is the standard comparison of string, like in a dictionary. Most programming languages compare strings in this way.
Input
The first line of the input contains an integer t (1 β€ t β€ 100) β the number of test cases. Then test cases follow.
The first line of a test case contains one integer n (1 β€ n β€ 1000) β the number of packages.
The next n lines contain descriptions of packages. The i-th package is given as two integers x_i and y_i (0 β€ x_i, y_i β€ 1000) β the x-coordinate of the package and the y-coordinate of the package.
It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The sum of all values n over test cases in the test doesn't exceed 1000.
Output
Print the answer for each test case.
If it is impossible to collect all n packages in some order starting from (0,0), print "NO" on the first line.
Otherwise, print "YES" in the first line. Then print the shortest path β a string consisting of characters 'R' and 'U'. Among all such paths choose the lexicographically smallest path.
Note that in this problem "YES" and "NO" can be only uppercase words, i.e. "Yes", "no" and "YeS" are not acceptable.
Example
Input
3
5
1 3
1 2
3 3
5 5
4 3
2
1 0
0 1
1
4 3
Output
YES
RUUURRRRUU
NO
YES
RRRRUUU
Note
For the first test case in the example the optimal path RUUURRRRUU is shown below:
<image>
Submitted Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
tab = []
for i in range(n):
x, y = map(int, input().split())
tab += [[x, y]]
tab.sort()
path = ''
last = [0, 0]
p = 1
for x in range(tab[-1][0]+1):
m = -1
for coor in tab:
if coor[0] <= x:
if coor[0] == x:
m = max(m, coor[1])
else:
if m == -1:
path += 'R'
last = [x, last[1]]
else:
if m >= last[1] and x >= last[0]:
path += ('U' * (m - last[1]))
last = [x, m]
if x < tab[-1][0]:
path += 'R'
else:
p = 0
break
if p:
if m >= last[1] and tab[-1][0] >= last[0]:
path += ('U' * (m - last[1]))
print('YES')
print(path)
else:
print('NO')
else:
print('NO')
``` | instruction | 0 | 35,314 | 8 | 70,628 |
No | output | 1 | 35,314 | 8 | 70,629 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a robot in a warehouse and n packages he wants to collect. The warehouse can be represented as a coordinate grid. Initially, the robot stays at the point (0, 0). The i-th package is at the point (x_i, y_i). It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The robot is semi-broken and only can move up ('U') and right ('R'). In other words, in one move the robot can go from the point (x, y) to the point (x + 1, y) or to the point (x, y + 1).
As we say above, the robot wants to collect all n packages (in arbitrary order). He wants to do it with the minimum possible number of moves. If there are several possible traversals, the robot wants to choose the lexicographically smallest path.
The string s of length n is lexicographically less than the string t of length n if there is some index 1 β€ j β€ n that for all i from 1 to j-1 s_i = t_i and s_j < t_j. It is the standard comparison of string, like in a dictionary. Most programming languages compare strings in this way.
Input
The first line of the input contains an integer t (1 β€ t β€ 100) β the number of test cases. Then test cases follow.
The first line of a test case contains one integer n (1 β€ n β€ 1000) β the number of packages.
The next n lines contain descriptions of packages. The i-th package is given as two integers x_i and y_i (0 β€ x_i, y_i β€ 1000) β the x-coordinate of the package and the y-coordinate of the package.
It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The sum of all values n over test cases in the test doesn't exceed 1000.
Output
Print the answer for each test case.
If it is impossible to collect all n packages in some order starting from (0,0), print "NO" on the first line.
Otherwise, print "YES" in the first line. Then print the shortest path β a string consisting of characters 'R' and 'U'. Among all such paths choose the lexicographically smallest path.
Note that in this problem "YES" and "NO" can be only uppercase words, i.e. "Yes", "no" and "YeS" are not acceptable.
Example
Input
3
5
1 3
1 2
3 3
5 5
4 3
2
1 0
0 1
1
4 3
Output
YES
RUUURRRRUU
NO
YES
RRRRUUU
Note
For the first test case in the example the optimal path RUUURRRRUU is shown below:
<image>
Submitted Solution:
```
# Author Name: Ajay Meena
# Codeforce : https://codeforces.com/profile/majay1638
import sys
import math
import bisect
import heapq
from bisect import bisect_right
from sys import stdin, stdout
# -------------- INPUT FUNCTIONS ------------------
def get_ints_in_variables(): return map(
int, sys.stdin.readline().strip().split())
def get_int(): return int(sys.stdin.readline())
def get_ints_in_list(): return list(
map(int, sys.stdin.readline().strip().split()))
def get_list_of_list(n): return [list(
map(int, sys.stdin.readline().strip().split())) for _ in range(n)]
def get_string(): return sys.stdin.readline().strip()
# -------- SOME CUSTOMIZED FUNCTIONS-----------
def myceil(x, y): return (x + y - 1) // y
# -------------- SOLUTION FUNCTION ------------------
def Solution(grid, n):
# Write Your Code Here
package = 0
grid = sorted(grid)
path = []
x = 0
y = 0
flag = True
for cord in grid:
xi = cord[0]
yi = cord[1]
if xi < x or yi < y:
flag = False
break
for _ in range(xi-x):
path.append("R")
for _ in range(yi-y):
path.append("U")
package += 1
x, y = xi, yi
if flag and package == n:
print("YES")
print(*path)
else:
print("NO")
def main():
# Take input Here and Call solution function
for _ in range(get_int()):
n = get_int()
grid = get_list_of_list(n)
Solution(grid, n)
# calling main Function
if __name__ == '__main__':
main()
``` | instruction | 0 | 35,315 | 8 | 70,630 |
No | output | 1 | 35,315 | 8 | 70,631 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Having bought his own apartment, Boris decided to paper the walls in every room. Boris's flat has n rooms, each of which has the form of a rectangular parallelepiped. For every room we known its length, width and height of the walls in meters (different rooms can have different dimensions, including height).
Boris chose m types of wallpaper to paper the walls of the rooms with (but it is not necessary to use all the types). Each type of wallpaper is sold in rolls of a fixed length and width (the length, naturally, shows how long the unfolded roll will be). In addition, for each type we know the price of one roll of this type.
The wallpaper of each type contains strips running along the length of the roll. When gluing the strips must be located strictly vertically (so the roll cannot be rotated, even if the length is less than the width). Besides, a roll can be cut in an arbitrary manner, but the joints of glued pieces should also be vertical. In addition, each room should be papered by only one type of wallpaper. And pieces of the same roll cannot be used to paper different rooms. That is, for each room the rolls are purchased separately. Also, some rolls can be used not completely.
After buying an apartment Boris is short of cash, so he wants to spend the minimum money on wallpaper. Help him.
Input
The first line contains a positive integer n (1 β€ n β€ 500) β the number of rooms in Boris's apartment.
Each of the next n lines contains three space-separated positive integers β the length, width and height of the walls in a given room in meters, respectively.
The next line contains a positive integer m (1 β€ m β€ 500) β the number of available wallpaper types.
Each of the following m lines contains three space-separated positive integers β the length and width in meters of a given wallpaper and the price of one roll, respectively.
All numbers in the input data do not exceed 500. It is guaranteed that each room can be papered using these types of wallpaper.
Output
Print a single number β the minimum total cost of the rolls.
Examples
Input
1
5 5 3
3
10 1 100
15 2 320
3 19 500
Output
640
Note
Note to the sample:
The total length of the walls (the perimeter) of the room is 20 m.
One roll of the first type can be cut into pieces to get three vertical 1 meter wide strips, ergo you need 7 rolls of this type, the price equals 700.
A roll of the second type can be cut into pieces to get five 2 meter wide strips, we need 2 rolls, the price is 640.
One roll of the third type can immediately paper 19 meters out of 20, but we cannot use other types and we have to buy a second roll, the price is 1000. | instruction | 0 | 35,369 | 8 | 70,738 |
Tags: implementation, math
Correct Solution:
```
from math import ceil
n = int(input())
mas = []
matrix = []
for i in range(n):
d, l, h = map(int, input().split())
mas.append((d, l, h))
m = int(input())
for i in range(m):
matrix.append(tuple(map(int, input().split())))
ans = 0
for i in range(len(mas)):
minimum = 10 ** 9
per = 2 * (mas[i][0] + mas[i][1])
for j in range(len(matrix)):
foring = matrix[j][0] // mas[i][2]
if foring != 0:
minimum = min(minimum, ceil(per / (foring * matrix[j][1])) * matrix[j][2])
ans += minimum
print(ans)
``` | output | 1 | 35,369 | 8 | 70,739 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Having bought his own apartment, Boris decided to paper the walls in every room. Boris's flat has n rooms, each of which has the form of a rectangular parallelepiped. For every room we known its length, width and height of the walls in meters (different rooms can have different dimensions, including height).
Boris chose m types of wallpaper to paper the walls of the rooms with (but it is not necessary to use all the types). Each type of wallpaper is sold in rolls of a fixed length and width (the length, naturally, shows how long the unfolded roll will be). In addition, for each type we know the price of one roll of this type.
The wallpaper of each type contains strips running along the length of the roll. When gluing the strips must be located strictly vertically (so the roll cannot be rotated, even if the length is less than the width). Besides, a roll can be cut in an arbitrary manner, but the joints of glued pieces should also be vertical. In addition, each room should be papered by only one type of wallpaper. And pieces of the same roll cannot be used to paper different rooms. That is, for each room the rolls are purchased separately. Also, some rolls can be used not completely.
After buying an apartment Boris is short of cash, so he wants to spend the minimum money on wallpaper. Help him.
Input
The first line contains a positive integer n (1 β€ n β€ 500) β the number of rooms in Boris's apartment.
Each of the next n lines contains three space-separated positive integers β the length, width and height of the walls in a given room in meters, respectively.
The next line contains a positive integer m (1 β€ m β€ 500) β the number of available wallpaper types.
Each of the following m lines contains three space-separated positive integers β the length and width in meters of a given wallpaper and the price of one roll, respectively.
All numbers in the input data do not exceed 500. It is guaranteed that each room can be papered using these types of wallpaper.
Output
Print a single number β the minimum total cost of the rolls.
Examples
Input
1
5 5 3
3
10 1 100
15 2 320
3 19 500
Output
640
Note
Note to the sample:
The total length of the walls (the perimeter) of the room is 20 m.
One roll of the first type can be cut into pieces to get three vertical 1 meter wide strips, ergo you need 7 rolls of this type, the price equals 700.
A roll of the second type can be cut into pieces to get five 2 meter wide strips, we need 2 rolls, the price is 640.
One roll of the third type can immediately paper 19 meters out of 20, but we cannot use other types and we have to buy a second roll, the price is 1000. | instruction | 0 | 35,370 | 8 | 70,740 |
Tags: implementation, math
Correct Solution:
```
n = int(input())
rooms = [[int(i) for i in input().split()] for i in range(n)]
m = int(input())
papers = [[int(i) for i in input().split()] for i in range(m)]
ans = 0
for room in rooms:
per = (room[0]+room[1])*2
prices = []
for cur in papers:
power = cur[0]//room[2]*cur[1]
if(power == 0):
continue
prices.append((per+power-1)//power*cur[2])
ans += min(prices)
print(ans)
# Made By Mostafa_Khaled
``` | output | 1 | 35,370 | 8 | 70,741 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Having bought his own apartment, Boris decided to paper the walls in every room. Boris's flat has n rooms, each of which has the form of a rectangular parallelepiped. For every room we known its length, width and height of the walls in meters (different rooms can have different dimensions, including height).
Boris chose m types of wallpaper to paper the walls of the rooms with (but it is not necessary to use all the types). Each type of wallpaper is sold in rolls of a fixed length and width (the length, naturally, shows how long the unfolded roll will be). In addition, for each type we know the price of one roll of this type.
The wallpaper of each type contains strips running along the length of the roll. When gluing the strips must be located strictly vertically (so the roll cannot be rotated, even if the length is less than the width). Besides, a roll can be cut in an arbitrary manner, but the joints of glued pieces should also be vertical. In addition, each room should be papered by only one type of wallpaper. And pieces of the same roll cannot be used to paper different rooms. That is, for each room the rolls are purchased separately. Also, some rolls can be used not completely.
After buying an apartment Boris is short of cash, so he wants to spend the minimum money on wallpaper. Help him.
Input
The first line contains a positive integer n (1 β€ n β€ 500) β the number of rooms in Boris's apartment.
Each of the next n lines contains three space-separated positive integers β the length, width and height of the walls in a given room in meters, respectively.
The next line contains a positive integer m (1 β€ m β€ 500) β the number of available wallpaper types.
Each of the following m lines contains three space-separated positive integers β the length and width in meters of a given wallpaper and the price of one roll, respectively.
All numbers in the input data do not exceed 500. It is guaranteed that each room can be papered using these types of wallpaper.
Output
Print a single number β the minimum total cost of the rolls.
Examples
Input
1
5 5 3
3
10 1 100
15 2 320
3 19 500
Output
640
Note
Note to the sample:
The total length of the walls (the perimeter) of the room is 20 m.
One roll of the first type can be cut into pieces to get three vertical 1 meter wide strips, ergo you need 7 rolls of this type, the price equals 700.
A roll of the second type can be cut into pieces to get five 2 meter wide strips, we need 2 rolls, the price is 640.
One roll of the third type can immediately paper 19 meters out of 20, but we cannot use other types and we have to buy a second roll, the price is 1000. | instruction | 0 | 35,371 | 8 | 70,742 |
Tags: implementation, math
Correct Solution:
```
from math import ceil
p = [tuple(map(int, input().split())) for i in range(int(input()))]
q = [tuple(map(int, input().split())) for i in range(int(input()))]
print(sum(min(d * ceil(2 * (a + b) / (w * int(h / c))) for h, w, d in q if h >= c) for a, b, c in p))
``` | output | 1 | 35,371 | 8 | 70,743 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.