message stringlengths 2 45.8k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 254 108k | cluster float64 3 3 | __index_level_0__ int64 508 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Sasha visited the farmer 2D and his famous magnetic farm. On this farm, the crop grows due to the influence of a special magnetic field. Maintaining of the magnetic field is provided by n machines, and the power of the i-th machine is a_i.
This year 2D decided to cultivate a new culture, but what exactly he didn't say. For the successful growth of the new culture, it is necessary to slightly change the powers of the machines. 2D can at most once choose an arbitrary integer x, then choose one machine and reduce the power of its machine by x times, and at the same time increase the power of one another machine by x times (powers of all the machines must stay positive integers). Note that he may not do that if he wants. More formally, 2D can choose two such indices i and j, and one integer x such that x is a divisor of a_i, and change powers as following: a_i = (a_i)/(x), a_j = a_j ⋅ x
Sasha is very curious, that's why he wants to calculate the minimum total power the farmer can reach. There are too many machines, and Sasha can't cope with computations, help him!
Input
The first line contains one integer n (2 ≤ n ≤ 5 ⋅ 10^4) — the number of machines.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 100) — the powers of the machines.
Output
Print one integer — minimum total power.
Examples
Input
5
1 2 3 4 5
Output
14
Input
4
4 2 4 4
Output
14
Input
5
2 4 2 3 7
Output
18
Note
In the first example, the farmer can reduce the power of the 4-th machine by 2 times, and increase the power of the 1-st machine by 2 times, then the powers will be: [2, 2, 3, 2, 5].
In the second example, the farmer can reduce the power of the 3-rd machine by 2 times, and increase the power of the 2-nd machine by 2 times. At the same time, the farmer can leave is be as it is and the total power won't change.
In the third example, it is optimal to leave it be as it is.
Submitted Solution:
```
from math import ceil
n=int(input())
a=list(map(int,input().split()))
a.sort()
ans=[0]*101
for i in range(n):
ans[a[i]]+=1
x=0
y=100
#print(ans)
res=0
flag=0
t=0
while(x<=100 and y>0):
flag=0
if(x>=y):
break
if(ans[x]<=0):
x+=1
continue
if(ans[y]<=0):
y-=1
continue
q=int(ceil(((y/x)**0.5)))
#print(q)
t=0
for i in range(q,1,-1):
if(y%i==0):
#res+=y//i
#res+=x*i
if(x+y<=x*i+y//i):
break
ans[y]-=1
ans[x]-=1
ans[y//i]+=1
ans[x*i]+=1
flag=1
break
if(flag==0):
y-=1
if(flag==1):
break
#print(y)
'''
if(flag==0):
ans[y]-=1
#res+=x
res+=y
#print(res)
'''
#print(ans)
for i in range(101):
res+=i*ans[i]
print(res)
``` | instruction | 0 | 36,909 | 3 | 73,818 |
No | output | 1 | 36,909 | 3 | 73,819 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Sasha visited the farmer 2D and his famous magnetic farm. On this farm, the crop grows due to the influence of a special magnetic field. Maintaining of the magnetic field is provided by n machines, and the power of the i-th machine is a_i.
This year 2D decided to cultivate a new culture, but what exactly he didn't say. For the successful growth of the new culture, it is necessary to slightly change the powers of the machines. 2D can at most once choose an arbitrary integer x, then choose one machine and reduce the power of its machine by x times, and at the same time increase the power of one another machine by x times (powers of all the machines must stay positive integers). Note that he may not do that if he wants. More formally, 2D can choose two such indices i and j, and one integer x such that x is a divisor of a_i, and change powers as following: a_i = (a_i)/(x), a_j = a_j ⋅ x
Sasha is very curious, that's why he wants to calculate the minimum total power the farmer can reach. There are too many machines, and Sasha can't cope with computations, help him!
Input
The first line contains one integer n (2 ≤ n ≤ 5 ⋅ 10^4) — the number of machines.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 100) — the powers of the machines.
Output
Print one integer — minimum total power.
Examples
Input
5
1 2 3 4 5
Output
14
Input
4
4 2 4 4
Output
14
Input
5
2 4 2 3 7
Output
18
Note
In the first example, the farmer can reduce the power of the 4-th machine by 2 times, and increase the power of the 1-st machine by 2 times, then the powers will be: [2, 2, 3, 2, 5].
In the second example, the farmer can reduce the power of the 3-rd machine by 2 times, and increase the power of the 2-nd machine by 2 times. At the same time, the farmer can leave is be as it is and the total power won't change.
In the third example, it is optimal to leave it be as it is.
Submitted Solution:
```
cnt=lambda s,i:s.count(i)
ii=lambda:int(input())
si=lambda:input()
f=lambda:map(int,input().split())
lf=lambda:list(map(int,input().split()))
n=ii()
l=sorted(lf())
lst=set()
for i in l:
for j in (2,101):
if i%j==0:
lst.add(j)
lst=sorted(list(lst))
for i in range(n-1,0,-1):
for j in range(len(lst)-1,-1,-1):
if l[i]%lst[j]==0:
l[i]//=lst[j]
l[0]*=lst[j]
exit(print(sum(l)))
``` | instruction | 0 | 36,910 | 3 | 73,820 |
No | output | 1 | 36,910 | 3 | 73,821 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Greg the Dwarf has been really busy recently with excavations by the Neverland Mountain. However for the well-known reasons (as you probably remember he is a very unusual dwarf and he cannot stand sunlight) Greg can only excavate at night. And in the morning he should be in his crypt before the first sun ray strikes. That's why he wants to find the shortest route from the excavation point to his crypt. Greg has recollected how the Codeforces participants successfully solved the problem of transporting his coffin to a crypt. So, in some miraculous way Greg appeared in your bedroom and asks you to help him in a highly persuasive manner. As usual, you didn't feel like turning him down.
After some thought, you formalized the task as follows: as the Neverland mountain has a regular shape and ends with a rather sharp peak, it can be represented as a cone whose base radius equals r and whose height equals h. The graveyard where Greg is busy excavating and his crypt can be represented by two points on the cone's surface. All you've got to do is find the distance between points on the cone's surface.
The task is complicated by the fact that the mountain's base on the ground level and even everything below the mountain has been dug through by gnome (one may wonder whether they've been looking for the same stuff as Greg...). So, one can consider the shortest way to pass not only along the side surface, but also along the cone's base (and in a specific case both points can lie on the cone's base — see the first sample test)
Greg will be satisfied with the problem solution represented as the length of the shortest path between two points — he can find his way pretty well on his own. He gave you two hours to solve the problem and the time is ticking!
Input
The first input line contains space-separated integers r and h (1 ≤ r, h ≤ 1000) — the base radius and the cone height correspondingly. The second and third lines contain coordinates of two points on the cone surface, groups of three space-separated real numbers. The coordinates of the points are given in the systems of coordinates where the origin of coordinates is located in the centre of the cone's base and its rotation axis matches the OZ axis. In this coordinate system the vertex of the cone is located at the point (0, 0, h), the base of the cone is a circle whose center is at the point (0, 0, 0), lying on the XOY plane, and all points on the cone surface have a non-negative coordinate z. It is guaranteed that the distances from the points to the cone surface do not exceed 10 - 12. All real numbers in the input have no more than 16 digits after decimal point.
Output
Print the length of the shortest path between the points given in the input, with absolute or relative error not exceeding 10 - 6.
Examples
Input
2 2
1.0 0.0 0.0
-1.0 0.0 0.0
Output
2.000000000
Input
2 2
1.0 0.0 0.0
1.0 0.0 1.0
Output
2.414213562
Input
2 2
1.0 0.0 1.0
-1.0 0.0 1.0
Output
2.534324263
Input
2 2
1.0 0.0 0.0
0.0 1.0 1.0
Output
3.254470198
Submitted Solution:
```
import math
mas = list(map(int, input().split()))
r = mas[0]
h = mas[1]
l = (r ** 2 + h ** 2) ** 0.5#2 * math.pi * r
mas = list(map(float, input().split()))
x1 = mas[0]
y1 = mas[1]
z1 = mas[2]
mas = list(map(float, input().split()))
x2 = mas[0]
y2 = mas[1]
z2 = mas[2]
s = 0
if ((z1 == 0) and (z2 == 0)):
s = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
elif ((z1 != 0) and (z2 != 0)):
alf = math.acos((x1 * x2 + y1 * y2) / math.sqrt((x1 ** 2 + y1 ** 2) * (x2 ** 2 + y2 ** 2)))
l1 = l * (1 - z1 / h)
l2 = l * (1 - z2 / h)
xx1 = l1; yy1 = 0;
xx1_ = l1 * math.cos(2 * math.pi * r / l); yy1_ = l1 * math.sin(2 * math.pi * r / l);
phi = alf * r / l
xx2 = l2 * math.cos(phi); yy2 = l2 * math.sin(phi)
# расстояние только по боковой поверхности
sbok = min(((xx1 - xx2) ** 2 + (yy1 - yy2) ** 2) ** 0.5, ((xx1_ - xx2) ** 2 + (yy1_ - yy2) ** 2) ** 0.5)
#print(sbok)
# расстояние через основание
step1 = 2 * math.pi
step2 = 2 * math.pi
start1 = 0
start2 = 0
smin = 1000000000000000
sbok1min = 0
sbok2min = 0
sosnmin = 0
alf1min = 0
alf2min = 0
phi1min = 0
phi2min = 0
i1min = 0
i2min = 0
for j in range(20):
k = 100
i1 = 0
for i1 in range(k + 1):
alf1 = start1 + i1 / k * step1
phi1 = alf1 * r / l
xxx1 = l * math.cos(phi1)
yyy1 = l * math.sin(phi1)
xxx1_ = r * math.cos(alf1)
yyy1_ = r * math.sin(alf1)
i2 = 0
for i2 in range(k + 1):
alf2 = start2 + i2 / k * step2
phi2 = alf2 * r / l
xxx2 = l * math.cos(phi2)
yyy2 = l * math.sin(phi2)
xxx2_ = r * math.cos(alf2)
yyy2_ = r * math.sin(alf2)
sbok1 = (min((xx1 - xxx1) ** 2 + (yy1 - yyy1) ** 2, (xx1_ - xxx1) ** 2 + (yy1_ - yyy1) ** 2)) ** 0.5
sbok2 = ((xx2 - xxx2) ** 2 + (yy2 - yyy2) ** 2) ** 0.5
sosn = ((xxx1_ - xxx2_) ** 2 + (yyy1_ - yyy2_) ** 2) ** 0.5
ss = sbok1 + sbok2 + sosn
if (ss < smin):
smin = ss
alf1min = alf1
start1min = alf1min - step1 / k
i1min = i1
alf2min = alf2
start2min = alf2min - step2 / k
i2min = i2
sbok1min = sbok1
sbok2min = sbok2
sosnmin = sosn
phi1min = phi1
phi2min = phi2
step1 = step1 / k * 2
start1 = start1min
if (start1 < 0):
start1 = 0
step2 = step2 / k * 2
start2 = start2min
if (start2 < 0):
start2 = 0
#print(smin, alf1min, alf2min, phi1min, phi2min, phi)
#print(sbok1min, sbok2min, sosnmin)
s = min(sbok, smin)
else:
if (z1 == 0):
xtemp = x2
ytemp = y2
ztemp = z2
x2 = x1
y2 = y1
z2 = z1
x1 = xtemp
y1 = ytemp
z1 = ztemp
if ((x1 ** 2 + y1 ** 2 == 0) and (x2 ** 2 + y2 ** 2 == 0)):
alf = 0
else:
alf = math.acos((x1 * x2 + y1 * y2) / math.sqrt((x1 ** 2 + y1 ** 2) * (x2 ** 2 + y2 ** 2)))
l1 = l * (1 - z1 / h)
xx1 = l1; yy1 = 0;
xx1_ = l1 * math.cos(2 * math.pi * r / l); yy1_ = l1 * math.sin(2 * math.pi * r / l);
step1 = 2 * math.pi
start1 = 0
smin = 1000000000000000
sbok1min = 0
alf1min = 0
phi1min = 0
i1min = 0
for j in range(20):
k = 100
i1 = 0
for i1 in range(k + 1):
alf1 = start1 + i1 / k * step1
phi1 = alf1 * r / l
xxx1 = l * math.cos(phi1)
yyy1 = l * math.sin(phi1)
xxx1_ = r * math.cos(alf1)
yyy1_ = r * math.sin(alf1)
sbok1 = (min((xx1 - xxx1) ** 2 + (yy1 - yyy1) ** 2, (xx1_ - xxx1) ** 2 + (yy1_ - yyy1) ** 2)) ** 0.5
rosn = (x2 ** 2 + y2 ** 2) ** 0.5
xosn = rosn * math.cos(alf)
yosn = rosn * math.sin(alf)
sosn = ((xxx1_ - xosn) ** 2 + (yyy1_ - yosn) ** 2) ** 0.5
ss = sbok1 + sosn
if (ss < smin):
smin = ss
alf1min = alf1
start1min = alf1min - step1 / k
i1min = i1
sbok1min = sbok1
sosnmin = sosn
phi1min = phi1
step1 = step1 / k * 2
start1 = start1min
if (start1 < 0):
start1 = 0
s = smin
print(s)
``` | instruction | 0 | 37,029 | 3 | 74,058 |
No | output | 1 | 37,029 | 3 | 74,059 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Greg the Dwarf has been really busy recently with excavations by the Neverland Mountain. However for the well-known reasons (as you probably remember he is a very unusual dwarf and he cannot stand sunlight) Greg can only excavate at night. And in the morning he should be in his crypt before the first sun ray strikes. That's why he wants to find the shortest route from the excavation point to his crypt. Greg has recollected how the Codeforces participants successfully solved the problem of transporting his coffin to a crypt. So, in some miraculous way Greg appeared in your bedroom and asks you to help him in a highly persuasive manner. As usual, you didn't feel like turning him down.
After some thought, you formalized the task as follows: as the Neverland mountain has a regular shape and ends with a rather sharp peak, it can be represented as a cone whose base radius equals r and whose height equals h. The graveyard where Greg is busy excavating and his crypt can be represented by two points on the cone's surface. All you've got to do is find the distance between points on the cone's surface.
The task is complicated by the fact that the mountain's base on the ground level and even everything below the mountain has been dug through by gnome (one may wonder whether they've been looking for the same stuff as Greg...). So, one can consider the shortest way to pass not only along the side surface, but also along the cone's base (and in a specific case both points can lie on the cone's base — see the first sample test)
Greg will be satisfied with the problem solution represented as the length of the shortest path between two points — he can find his way pretty well on his own. He gave you two hours to solve the problem and the time is ticking!
Input
The first input line contains space-separated integers r and h (1 ≤ r, h ≤ 1000) — the base radius and the cone height correspondingly. The second and third lines contain coordinates of two points on the cone surface, groups of three space-separated real numbers. The coordinates of the points are given in the systems of coordinates where the origin of coordinates is located in the centre of the cone's base and its rotation axis matches the OZ axis. In this coordinate system the vertex of the cone is located at the point (0, 0, h), the base of the cone is a circle whose center is at the point (0, 0, 0), lying on the XOY plane, and all points on the cone surface have a non-negative coordinate z. It is guaranteed that the distances from the points to the cone surface do not exceed 10 - 12. All real numbers in the input have no more than 16 digits after decimal point.
Output
Print the length of the shortest path between the points given in the input, with absolute or relative error not exceeding 10 - 6.
Examples
Input
2 2
1.0 0.0 0.0
-1.0 0.0 0.0
Output
2.000000000
Input
2 2
1.0 0.0 0.0
1.0 0.0 1.0
Output
2.414213562
Input
2 2
1.0 0.0 1.0
-1.0 0.0 1.0
Output
2.534324263
Input
2 2
1.0 0.0 0.0
0.0 1.0 1.0
Output
3.254470198
Submitted Solution:
```
import math
mas = list(map(int, input().split()))
r = mas[0]
h = mas[1]
l = (r ** 2 + h ** 2) ** 0.5#2 * math.pi * r
mas = list(map(float, input().split()))
x1 = mas[0]
y1 = mas[1]
z1 = mas[2]
mas = list(map(float, input().split()))
x2 = mas[0]
y2 = mas[1]
z2 = mas[2]
s = 0
if ((z1 == 0) and (z2 == 0)):
s = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
elif ((z1 != 0) and (z2 != 0)):
alf = math.acos((x1 * x2 + y1 * y2) / math.sqrt((x1 ** 2 + y1 ** 2) * (x2 ** 2 + y2 ** 2)))
l1 = l * (1 - z1 / h)
l2 = l * (1 - z2 / h)
xx1 = l1; yy1 = 0;
xx1_ = l1 * math.cos(2 * math.pi * r / l); yy1_ = l1 * math.sin(2 * math.pi * r / l);
phi = alf * r / l
xx2 = l2 * math.cos(phi); yy2 = l2 * math.sin(phi)
# расстояние только по боковой поверхности
sbok = min(((xx1 - xx2) ** 2 + (yy1 - yy2) ** 2) ** 0.5, ((xx1_ - xx2) ** 2 + (yy1_ - yy2) ** 2) ** 0.5)
#print(sbok)
# расстояние через основание
'''
step1 = 0.1
step2 = 0.1
alf1_ = 0
alf2_ = 2 * math.pi#phi
smin = 10000000000000
for j in range(1000):
for i1 in range(-1, 2, 1):
for i2 in range(-1, 2, 1):
alf1 = alf1_ + i1 * step1
alf2 = alf2_ + i2 * step2
phi1 = alf1 * r / l
xxx1 = l * math.cos(phi1)
yyy1 = l * math.sin(phi1)
xxx1_ = r * math.cos(alf1)
yyy1_ = r * math.sin(alf1)
phi2 = alf2 * r / l
xxx2 = l * math.cos(phi2)
yyy2 = l * math.sin(phi2)
xxx2_ = r * math.cos(alf2)
yyy2_ = r * math.sin(alf2)
sbok1 = (min((xx1 - xxx1) ** 2 + (yy1 - yyy1) ** 2, (xx1_ - xxx1) ** 2 + (yy1_ - yyy1) ** 2)) ** 0.5
sbok2 = ((xx2 - xxx2) ** 2 + (yy2 - yyy2) ** 2) ** 0.5
sosn = ((xxx1_ - xxx2_) ** 2 + (yyy1_ - yyy2_) ** 2) ** 0.5
ss = sbok1 + sbok2 + sosn
if (ss < smin):
smin = ss
alf1min = alf1
alf2min = alf2
print(smin)
'''
step1 = 2 * math.pi
step2 = 2 * math.pi
start1 = 0
start2 = 0
smin = 1000000000000000
sbok1min = 0
sbok2min = 0
sosnmin = 0
alf1min = 0
alf2min = 0
phi1min = 0
phi2min = 0
i1min = 0
i2min = 0
for j in range(50):
k = 10
i1 = 0
for i1 in range(k + 1):
alf1 = start1 + i1 / k * step1
phi1 = alf1 * r / l
xxx1 = l * math.cos(phi1)
yyy1 = l * math.sin(phi1)
xxx1_ = r * math.cos(alf1)
yyy1_ = r * math.sin(alf1)
i2 = 0
for i2 in range(k + 1):
alf2 = start2 + i2 / k * step2
phi2 = alf2 * r / l
xxx2 = l * math.cos(phi2)
yyy2 = l * math.sin(phi2)
xxx2_ = r * math.cos(alf2)
yyy2_ = r * math.sin(alf2)
sbok1 = (min((xx1 - xxx1) ** 2 + (yy1 - yyy1) ** 2, (xx1_ - xxx1) ** 2 + (yy1_ - yyy1) ** 2)) ** 0.5
sbok2 = ((xx2 - xxx2) ** 2 + (yy2 - yyy2) ** 2) ** 0.5
sosn = ((xxx1_ - xxx2_) ** 2 + (yyy1_ - yyy2_) ** 2) ** 0.5
ss = sbok1 + sbok2 + sosn
if (ss < smin):
smin = ss
alf1min = alf1
i1min = i1
alf2min = alf2
i2min = i2
sbok1min = sbok1
sbok2min = sbok2
sosnmin = sosn
phi1min = phi1
phi2min = phi2
step1 = step1 / k
start1 = alf1min - step1
if (start1 < 0):
start1 = 0
step2 = step2 / k
if (start2 < 0):
start2 = 0
start2 = alf2min - step2
#print(smin, alf1min, alf2min, phi1min, phi2min, phi)
#print(sbok1min, sbok2min, sosnmin)
s = min(sbok, smin)
'''
# путь по боковой поверхности конуса
if ((x1 == 0) and (y1 == 0)):
betta1 = 0
rad1 = 0
else:
r1 = (x1 ** 2 + y1 ** 2) ** 0.5
alf1 = math.acos(x1 / r1)
if (y1 < 0):
alf1 = 2 * math.pi - alf1
betta1 = alf1 * r / l
rad1 = (x1 ** 2 + y1 ** 2 + (h - z1) ** 2) ** 0.5
if ((x2 == 0) and (y2 == 0)):
betta2 = 0
rad2 = 0
else:
r2 = (x2 ** 2 + y2 ** 2) ** 0.5
alf2 = math.acos(x2 / r2)
betta2 = alf2 * r / l
if (y2 < 0):
alf2 = 2 * math.pi - alf2
rad2 = (x2 ** 2 + y2 ** 2 + (h - z2) ** 2) ** 0.5
xx1 = rad1 * math.cos(betta1)
yy1 = rad1 * math.sin(betta1)
xx2 = rad2 * math.cos(betta2)
yy2 = rad2 * math.sin(betta2)
xx2_ = rad2 * math.cos(betta2 - 2 * math.pi * r / l)
yy2_ = rad2 * math.sin(betta2 - 2 * math.pi * r / l)
s = min((xx1 - xx2) ** 2 + (yy1 - yy2) ** 2, (xx1 - xx2_) ** 2 + (yy1 - yy2_) ** 2) ** 0.5
# путь боковая + основание + боковая
step1 = 2 * math.pi
step2 = 2 * math.pi
start1 = 0
start2 = 0
smin = 1000000000000000
alf1min = 0
alf2min = 0
i1min = 0
i2min = 0
for j in range(3):
k = 150
i1 = 0
for i1 in range(k + 1):
alf1 = start1 + i1 / k * step1
betta1 = alf1 * r / l
xxx1 = l * math.cos(betta1)
yyy1 = l * math.sin(betta1)
xxx1_ = r * math.cos(alf1)
yyy1_ = r * math.sin(alf1)
i2 = 0
for i2 in range(k + 1):
alf2 = start2 + i2 / k * step2
betta2 = alf2 * r / l
xxx2 = l * math.cos(betta2)
yyy2 = l * math.sin(betta2)
xxx2_ = r * math.cos(alf2)
yyy2_ = r * math.sin(alf2)
s1 = ((xx1 - xxx1) ** 2 + (yy1 - yyy1) ** 2) ** 0.5
s2 = ((xxx1_ - xxx2_) ** 2 + (yyy1_ - yyy2_) ** 2) ** 0.5
s3 = ((xx2 - xxx2) ** 2 + (yy2 - yyy2) ** 2) ** 0.5
s_ = s1 + s2 + s3
if (s_ < smin):
smin = s_
alf1min = alf1
i1min = i1
alf2min = alf2
i2min = i2
step1 = step1 / k * 4
start1 = alf1min - step1
step2 = step2 / k * 4
start2 = alf2min - step2
#print(smin)
s = min(s, smin)
'''
else:
if (z1 == 0):
xtemp = x2
ytemp = y2
ztemp = z2
x2 = x1
y2 = y1
z2 = z1
x1 = xtemp
y1 = ytemp
z1 = ztemp
if ((x1 == 0) and (y1 == 0)):
betta1 = 0
rad1 = 0
else:
r1 = (x1 ** 2 + y1 ** 2) ** 0.5
alf1 = math.acos(x1 / r1)
if (y1 < 0):
alf1 = 2 * math.pi - alf1
betta1 = alf1 * r / l
rad1 = (x1 ** 2 + y1 ** 2 + (h - z1) ** 2) ** 0.5
if ((x2 == 0) and (y2 == 0)):
alf2 = 0
rad2 = 0
else:
r2 = (x2 ** 2 + y2 ** 2) ** 0.5
alf2 = math.acos(x2 / r2)
if (y2 < 0):
alf2 = 2 * math.pi - alf2
rad2 = r2
#print(rad2, alf2)
smin = 1000000000
start = 0
step = 2 * math.pi
for j in range(3):
k = 1000
for i in range(k + 1):
alf = start + i / k * step
#s1
xx2 = rad2 * math.cos(alf2)
yy2 = rad2 * math.sin(alf2)
xx = r * math.cos(alf)
yy = r * math.sin(alf)
s1 = ((xx - xx2) ** 2 + (yy - yy2) ** 2) ** 0.5
#if (i == 0):
# print(xx2, yy2, xx, yy, s1)
#s2
xx1 = rad1 * math.cos(betta1)
yy1 = rad1 * math.sin(betta1)
betta = alf * r / l
xx = l * math.cos(betta)
yy = l * math.sin(betta)
xx_ = l * math.cos(betta - 2 * math.pi * r / l)
yy_ = l * math.sin(betta - 2 * math.pi * r / l)
xx_ = xx
yy_ = yy
s2 = min((xx1 - xx) ** 2 + (yy1 - yy) ** 2, (xx1 - xx_) ** 2 + (yy1 - yy_) ** 2) ** 0.5
s_ = s1 + s2
#if (i == 0):
# print(xx1, yy1, xx, yy, xx_, yy_, s2)
# print(s)
if (s_ < smin):
smin = s_
alfmin = alf
imin = i
step = step / k * 2
start = alfmin - step / 2
s = smin
print(s)
``` | instruction | 0 | 37,030 | 3 | 74,060 |
No | output | 1 | 37,030 | 3 | 74,061 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Greg the Dwarf has been really busy recently with excavations by the Neverland Mountain. However for the well-known reasons (as you probably remember he is a very unusual dwarf and he cannot stand sunlight) Greg can only excavate at night. And in the morning he should be in his crypt before the first sun ray strikes. That's why he wants to find the shortest route from the excavation point to his crypt. Greg has recollected how the Codeforces participants successfully solved the problem of transporting his coffin to a crypt. So, in some miraculous way Greg appeared in your bedroom and asks you to help him in a highly persuasive manner. As usual, you didn't feel like turning him down.
After some thought, you formalized the task as follows: as the Neverland mountain has a regular shape and ends with a rather sharp peak, it can be represented as a cone whose base radius equals r and whose height equals h. The graveyard where Greg is busy excavating and his crypt can be represented by two points on the cone's surface. All you've got to do is find the distance between points on the cone's surface.
The task is complicated by the fact that the mountain's base on the ground level and even everything below the mountain has been dug through by gnome (one may wonder whether they've been looking for the same stuff as Greg...). So, one can consider the shortest way to pass not only along the side surface, but also along the cone's base (and in a specific case both points can lie on the cone's base — see the first sample test)
Greg will be satisfied with the problem solution represented as the length of the shortest path between two points — he can find his way pretty well on his own. He gave you two hours to solve the problem and the time is ticking!
Input
The first input line contains space-separated integers r and h (1 ≤ r, h ≤ 1000) — the base radius and the cone height correspondingly. The second and third lines contain coordinates of two points on the cone surface, groups of three space-separated real numbers. The coordinates of the points are given in the systems of coordinates where the origin of coordinates is located in the centre of the cone's base and its rotation axis matches the OZ axis. In this coordinate system the vertex of the cone is located at the point (0, 0, h), the base of the cone is a circle whose center is at the point (0, 0, 0), lying on the XOY plane, and all points on the cone surface have a non-negative coordinate z. It is guaranteed that the distances from the points to the cone surface do not exceed 10 - 12. All real numbers in the input have no more than 16 digits after decimal point.
Output
Print the length of the shortest path between the points given in the input, with absolute or relative error not exceeding 10 - 6.
Examples
Input
2 2
1.0 0.0 0.0
-1.0 0.0 0.0
Output
2.000000000
Input
2 2
1.0 0.0 0.0
1.0 0.0 1.0
Output
2.414213562
Input
2 2
1.0 0.0 1.0
-1.0 0.0 1.0
Output
2.534324263
Input
2 2
1.0 0.0 0.0
0.0 1.0 1.0
Output
3.254470198
Submitted Solution:
```
import math
mas = list(map(int, input().split()))
r = mas[0]
h = mas[1]
l = (r ** 2 + h ** 2) ** 0.5#2 * math.pi * r
mas = list(map(float, input().split()))
x1 = mas[0]
y1 = mas[1]
z1 = mas[2]
mas = list(map(float, input().split()))
x2 = mas[0]
y2 = mas[1]
z2 = mas[2]
s = 0
if ((z1 == 0) and (z2 == 0)):
s = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
elif ((z1 != 0) and (z2 != 0)):
alf = math.acos((x1 * x2 + y1 * y2) / math.sqrt((x1 ** 2 + y1 ** 2) * (x2 ** 2 + y2 ** 2)))
l1 = l * (1 - z1 / h)
l2 = l * (1 - z2 / h)
xx1 = l1; yy1 = 0;
xx1_ = l1 * math.cos(2 * math.pi * r / l); yy1_ = l1 * math.sin(2 * math.pi * r / l);
phi = alf * r / l
xx2 = l2 * math.cos(phi); yy2 = l2 * math.sin(phi)
# расстояние только по боковой поверхности
sbok = min(((xx1 - xx2) ** 2 + (yy1 - yy2) ** 2) ** 0.5, ((xx1_ - xx2) ** 2 + (yy1_ - yy2) ** 2) ** 0.5)
#print(sbok)
# расстояние через основание
'''
step1 = 0.1
step2 = 0.1
alf1_ = 0
alf2_ = 2 * math.pi#phi
smin = 10000000000000
for j in range(1000):
for i1 in range(-1, 2, 1):
for i2 in range(-1, 2, 1):
alf1 = alf1_ + i1 * step1
alf2 = alf2_ + i2 * step2
phi1 = alf1 * r / l
xxx1 = l * math.cos(phi1)
yyy1 = l * math.sin(phi1)
xxx1_ = r * math.cos(alf1)
yyy1_ = r * math.sin(alf1)
phi2 = alf2 * r / l
xxx2 = l * math.cos(phi2)
yyy2 = l * math.sin(phi2)
xxx2_ = r * math.cos(alf2)
yyy2_ = r * math.sin(alf2)
sbok1 = (min((xx1 - xxx1) ** 2 + (yy1 - yyy1) ** 2, (xx1_ - xxx1) ** 2 + (yy1_ - yyy1) ** 2)) ** 0.5
sbok2 = ((xx2 - xxx2) ** 2 + (yy2 - yyy2) ** 2) ** 0.5
sosn = ((xxx1_ - xxx2_) ** 2 + (yyy1_ - yyy2_) ** 2) ** 0.5
ss = sbok1 + sbok2 + sosn
if (ss < smin):
smin = ss
alf1min = alf1
alf2min = alf2
print(smin)
'''
step1 = 2 * math.pi
step2 = 2 * math.pi
start1 = 0
start2 = 0
smin = 1000000000000000
sbok1min = 0
sbok2min = 0
sosnmin = 0
alf1min = 0
alf2min = 0
phi1min = 0
phi2min = 0
i1min = 0
i2min = 0
for j in range(20):
k = 100
i1 = 0
for i1 in range(k + 1):
alf1 = start1 + i1 / k * step1
phi1 = alf1 * r / l
xxx1 = l * math.cos(phi1)
yyy1 = l * math.sin(phi1)
xxx1_ = r * math.cos(alf1)
yyy1_ = r * math.sin(alf1)
i2 = 0
for i2 in range(k + 1):
alf2 = start2 + i2 / k * step2
phi2 = alf2 * r / l
xxx2 = l * math.cos(phi2)
yyy2 = l * math.sin(phi2)
xxx2_ = r * math.cos(alf2)
yyy2_ = r * math.sin(alf2)
sbok1 = (min((xx1 - xxx1) ** 2 + (yy1 - yyy1) ** 2, (xx1_ - xxx1) ** 2 + (yy1_ - yyy1) ** 2)) ** 0.5
sbok2 = ((xx2 - xxx2) ** 2 + (yy2 - yyy2) ** 2) ** 0.5
sosn = ((xxx1_ - xxx2_) ** 2 + (yyy1_ - yyy2_) ** 2) ** 0.5
ss = sbok1 + sbok2 + sosn
if (ss < smin):
smin = ss
alf1min = alf1
start1min = alf1min - step1 / k
i1min = i1
alf2min = alf2
start2min = alf2min - step2 / k
i2min = i2
sbok1min = sbok1
sbok2min = sbok2
sosnmin = sosn
phi1min = phi1
phi2min = phi2
step1 = step1 / k * 2
start1 = start1min
if (start1 < 0):
start1 = 0
step2 = step2 / k * 2
start2 = start2min
if (start2 < 0):
start2 = 0
#print(smin, alf1min, alf2min, phi1min, phi2min, phi)
#print(sbok1min, sbok2min, sosnmin)
s = min(sbok, smin)
'''
# путь по боковой поверхности конуса
if ((x1 == 0) and (y1 == 0)):
betta1 = 0
rad1 = 0
else:
r1 = (x1 ** 2 + y1 ** 2) ** 0.5
alf1 = math.acos(x1 / r1)
if (y1 < 0):
alf1 = 2 * math.pi - alf1
betta1 = alf1 * r / l
rad1 = (x1 ** 2 + y1 ** 2 + (h - z1) ** 2) ** 0.5
if ((x2 == 0) and (y2 == 0)):
betta2 = 0
rad2 = 0
else:
r2 = (x2 ** 2 + y2 ** 2) ** 0.5
alf2 = math.acos(x2 / r2)
betta2 = alf2 * r / l
if (y2 < 0):
alf2 = 2 * math.pi - alf2
rad2 = (x2 ** 2 + y2 ** 2 + (h - z2) ** 2) ** 0.5
xx1 = rad1 * math.cos(betta1)
yy1 = rad1 * math.sin(betta1)
xx2 = rad2 * math.cos(betta2)
yy2 = rad2 * math.sin(betta2)
xx2_ = rad2 * math.cos(betta2 - 2 * math.pi * r / l)
yy2_ = rad2 * math.sin(betta2 - 2 * math.pi * r / l)
s = min((xx1 - xx2) ** 2 + (yy1 - yy2) ** 2, (xx1 - xx2_) ** 2 + (yy1 - yy2_) ** 2) ** 0.5
# путь боковая + основание + боковая
step1 = 2 * math.pi
step2 = 2 * math.pi
start1 = 0
start2 = 0
smin = 1000000000000000
alf1min = 0
alf2min = 0
i1min = 0
i2min = 0
for j in range(3):
k = 150
i1 = 0
for i1 in range(k + 1):
alf1 = start1 + i1 / k * step1
betta1 = alf1 * r / l
xxx1 = l * math.cos(betta1)
yyy1 = l * math.sin(betta1)
xxx1_ = r * math.cos(alf1)
yyy1_ = r * math.sin(alf1)
i2 = 0
for i2 in range(k + 1):
alf2 = start2 + i2 / k * step2
betta2 = alf2 * r / l
xxx2 = l * math.cos(betta2)
yyy2 = l * math.sin(betta2)
xxx2_ = r * math.cos(alf2)
yyy2_ = r * math.sin(alf2)
s1 = ((xx1 - xxx1) ** 2 + (yy1 - yyy1) ** 2) ** 0.5
s2 = ((xxx1_ - xxx2_) ** 2 + (yyy1_ - yyy2_) ** 2) ** 0.5
s3 = ((xx2 - xxx2) ** 2 + (yy2 - yyy2) ** 2) ** 0.5
s_ = s1 + s2 + s3
if (s_ < smin):
smin = s_
alf1min = alf1
i1min = i1
alf2min = alf2
i2min = i2
step1 = step1 / k * 4
start1 = alf1min - step1
step2 = step2 / k * 4
start2 = alf2min - step2
#print(smin)
s = min(s, smin)
'''
else:
if (z1 == 0):
xtemp = x2
ytemp = y2
ztemp = z2
x2 = x1
y2 = y1
z2 = z1
x1 = xtemp
y1 = ytemp
z1 = ztemp
if ((x1 == 0) and (y1 == 0)):
betta1 = 0
rad1 = 0
else:
r1 = (x1 ** 2 + y1 ** 2) ** 0.5
alf1 = math.acos(x1 / r1)
if (y1 < 0):
alf1 = 2 * math.pi - alf1
betta1 = alf1 * r / l
rad1 = (x1 ** 2 + y1 ** 2 + (h - z1) ** 2) ** 0.5
if ((x2 == 0) and (y2 == 0)):
alf2 = 0
rad2 = 0
else:
r2 = (x2 ** 2 + y2 ** 2) ** 0.5
alf2 = math.acos(x2 / r2)
if (y2 < 0):
alf2 = 2 * math.pi - alf2
rad2 = r2
#print(rad2, alf2)
smin = 1000000000
start = 0
step = 2 * math.pi
for j in range(3):
k = 1000
for i in range(k + 1):
alf = start + i / k * step
#s1
xx2 = rad2 * math.cos(alf2)
yy2 = rad2 * math.sin(alf2)
xx = r * math.cos(alf)
yy = r * math.sin(alf)
s1 = ((xx - xx2) ** 2 + (yy - yy2) ** 2) ** 0.5
#if (i == 0):
# print(xx2, yy2, xx, yy, s1)
#s2
xx1 = rad1 * math.cos(betta1)
yy1 = rad1 * math.sin(betta1)
betta = alf * r / l
xx = l * math.cos(betta)
yy = l * math.sin(betta)
xx_ = l * math.cos(betta - 2 * math.pi * r / l)
yy_ = l * math.sin(betta - 2 * math.pi * r / l)
xx_ = xx
yy_ = yy
s2 = min((xx1 - xx) ** 2 + (yy1 - yy) ** 2, (xx1 - xx_) ** 2 + (yy1 - yy_) ** 2) ** 0.5
s_ = s1 + s2
#if (i == 0):
# print(xx1, yy1, xx, yy, xx_, yy_, s2)
# print(s)
if (s_ < smin):
smin = s_
alfmin = alf
imin = i
step = step / k * 2
start = alfmin - step / 2
s = smin
print(s)
``` | instruction | 0 | 37,031 | 3 | 74,062 |
No | output | 1 | 37,031 | 3 | 74,063 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Greg the Dwarf has been really busy recently with excavations by the Neverland Mountain. However for the well-known reasons (as you probably remember he is a very unusual dwarf and he cannot stand sunlight) Greg can only excavate at night. And in the morning he should be in his crypt before the first sun ray strikes. That's why he wants to find the shortest route from the excavation point to his crypt. Greg has recollected how the Codeforces participants successfully solved the problem of transporting his coffin to a crypt. So, in some miraculous way Greg appeared in your bedroom and asks you to help him in a highly persuasive manner. As usual, you didn't feel like turning him down.
After some thought, you formalized the task as follows: as the Neverland mountain has a regular shape and ends with a rather sharp peak, it can be represented as a cone whose base radius equals r and whose height equals h. The graveyard where Greg is busy excavating and his crypt can be represented by two points on the cone's surface. All you've got to do is find the distance between points on the cone's surface.
The task is complicated by the fact that the mountain's base on the ground level and even everything below the mountain has been dug through by gnome (one may wonder whether they've been looking for the same stuff as Greg...). So, one can consider the shortest way to pass not only along the side surface, but also along the cone's base (and in a specific case both points can lie on the cone's base — see the first sample test)
Greg will be satisfied with the problem solution represented as the length of the shortest path between two points — he can find his way pretty well on his own. He gave you two hours to solve the problem and the time is ticking!
Input
The first input line contains space-separated integers r and h (1 ≤ r, h ≤ 1000) — the base radius and the cone height correspondingly. The second and third lines contain coordinates of two points on the cone surface, groups of three space-separated real numbers. The coordinates of the points are given in the systems of coordinates where the origin of coordinates is located in the centre of the cone's base and its rotation axis matches the OZ axis. In this coordinate system the vertex of the cone is located at the point (0, 0, h), the base of the cone is a circle whose center is at the point (0, 0, 0), lying on the XOY plane, and all points on the cone surface have a non-negative coordinate z. It is guaranteed that the distances from the points to the cone surface do not exceed 10 - 12. All real numbers in the input have no more than 16 digits after decimal point.
Output
Print the length of the shortest path between the points given in the input, with absolute or relative error not exceeding 10 - 6.
Examples
Input
2 2
1.0 0.0 0.0
-1.0 0.0 0.0
Output
2.000000000
Input
2 2
1.0 0.0 0.0
1.0 0.0 1.0
Output
2.414213562
Input
2 2
1.0 0.0 1.0
-1.0 0.0 1.0
Output
2.534324263
Input
2 2
1.0 0.0 0.0
0.0 1.0 1.0
Output
3.254470198
Submitted Solution:
```
import math
mas = list(map(int, input().split()))
r = mas[0]
h = mas[1]
l = (r ** 2 + h ** 2) ** 0.5#2 * math.pi * r
mas = list(map(float, input().split()))
x1 = mas[0]
y1 = mas[1]
z1 = mas[2]
mas = list(map(float, input().split()))
x2 = mas[0]
y2 = mas[1]
z2 = mas[2]
s = 0
if ((z1 == 0) and (z2 == 0)):
s = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
elif ((z1 != 0) and (z2 != 0)):
# путь по боковой поверхности конуса
if ((x1 == 0) and (y1 == 0)):
betta1 = 0
rad1 = 0
else:
r1 = (x1 ** 2 + y1 ** 2) ** 0.5
alf1 = math.acos(x1 / r1)
if (y1 < 0):
alf1 = 2 * math.pi - alf1
betta1 = alf1 * r / l
rad1 = (x1 ** 2 + y1 ** 2 + (h - z1) ** 2) ** 0.5
if ((x2 == 0) and (y2 == 0)):
betta2 = 0
rad2 = 0
else:
r2 = (x2 ** 2 + y2 ** 2) ** 0.5
alf2 = math.acos(x2 / r2)
betta2 = alf2 * r / l
if (y2 < 0):
alf2 = 2 * math.pi - alf2
rad2 = (x2 ** 2 + y2 ** 2 + (h - z2) ** 2) ** 0.5
xx1 = rad1 * math.cos(betta1)
yy1 = rad1 * math.sin(betta1)
xx2 = rad2 * math.cos(betta2)
yy2 = rad2 * math.sin(betta2)
xx2_ = rad2 * math.cos(betta2 - 2 * math.pi * r / l)
yy2_ = rad2 * math.sin(betta2 - 2 * math.pi * r / l)
s = min((xx1 - xx2) ** 2 + (yy1 - yy2) ** 2, (xx1 - xx2_) ** 2 + (yy1 - yy2_) ** 2) ** 0.5
# путь боковая + основание + боковая
step1 = 2 * math.pi
step2 = 2 * math.pi
start1 = 0
start2 = 0
smin = 1000000000000000
alf1min = 0
alf2min = 0
i1min = 0
i2min = 0
for j in range(3):
k = 100
i1 = 0
for i1 in range(k + 1):
alf1 = start1 + i1 / k * step1
betta1 = alf1 * r / l
xxx1 = l * math.cos(betta1)
yyy1 = l * math.sin(betta1)
xxx1_ = r * math.cos(alf1)
yyy1_ = r * math.sin(alf1)
i2 = 0
for i2 in range(k + 1):
alf2 = start2 + i2 / k * step2
betta2 = alf2 * r / l
xxx2 = l * math.cos(betta2)
yyy2 = l * math.sin(betta2)
xxx2_ = r * math.cos(alf2)
yyy2_ = r * math.sin(alf2)
s1 = ((xx1 - xxx1) ** 2 + (yy1 - yyy1) ** 2) ** 0.5
s2 = ((xxx1_ - xxx2_) ** 2 + (yyy1_ - yyy2_) ** 2) ** 0.5
s3 = ((xx2 - xxx2) ** 2 + (yy2 - yyy2) ** 2) ** 0.5
s_ = s1 + s2 + s3
if (s_ < smin):
smin = s_
alf1min = alf1
i1min = i1
alf2min = alf2
i2min = i2
step1 = step1 / k * 4
start1 = alf1min - step1
step2 = step2 / k * 4
start2 = alf2min - step2
print(smin)
s = min(s, smin)
else:
if (z1 == 0):
xtemp = x2
ytemp = y2
ztemp = z2
x2 = x1
y2 = y1
z2 = z1
x1 = xtemp
y1 = ytemp
z1 = ztemp
if ((x1 == 0) and (y1 == 0)):
betta1 = 0
rad1 = 0
else:
r1 = (x1 ** 2 + y1 ** 2) ** 0.5
alf1 = math.acos(x1 / r1)
if (y1 < 0):
alf1 = 2 * math.pi - alf1
betta1 = alf1 * r / l
rad1 = (x1 ** 2 + y1 ** 2 + (h - z1) ** 2) ** 0.5
if ((x2 == 0) and (y2 == 0)):
alf2 = 0
rad2 = 0
else:
r2 = (x2 ** 2 + y2 ** 2) ** 0.5
alf2 = math.acos(x2 / r2)
if (y2 < 0):
alf2 = 2 * math.pi - alf2
rad2 = r2
#print(rad2, alf2)
smin = 1000000000
start = 0
step = 2 * math.pi
for j in range(3):
k = 1000
for i in range(k + 1):
alf = start + i / k * step
#s1
xx2 = rad2 * math.cos(alf2)
yy2 = rad2 * math.sin(alf2)
xx = r * math.cos(alf)
yy = r * math.sin(alf)
s1 = ((xx - xx2) ** 2 + (yy - yy2) ** 2) ** 0.5
#if (i == 0):
# print(xx2, yy2, xx, yy, s1)
#s2
xx1 = rad1 * math.cos(betta1)
yy1 = rad1 * math.sin(betta1)
betta = alf * r / l
xx = l * math.cos(betta)
yy = l * math.sin(betta)
xx_ = l * math.cos(betta - 2 * math.pi * r / l)
yy_ = l * math.sin(betta - 2 * math.pi * r / l)
xx_ = xx
yy_ = yy
s2 = min((xx1 - xx) ** 2 + (yy1 - yy) ** 2, (xx1 - xx_) ** 2 + (yy1 - yy_) ** 2) ** 0.5
s_ = s1 + s2
#if (i == 0):
# print(xx1, yy1, xx, yy, xx_, yy_, s2)
# print(s)
if (s_ < smin):
smin = s_
alfmin = alf
imin = i
step = step / k * 2
start = alfmin - step / 2
s = smin
print(s)
``` | instruction | 0 | 37,032 | 3 | 74,064 |
No | output | 1 | 37,032 | 3 | 74,065 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Amr loves Chemistry, and specially doing experiments. He is preparing for a new interesting experiment.
Amr has n different types of chemicals. Each chemical i has an initial volume of ai liters. For this experiment, Amr has to mix all the chemicals together, but all the chemicals volumes must be equal first. So his task is to make all the chemicals volumes equal.
To do this, Amr can do two different kind of operations.
* Choose some chemical i and double its current volume so the new volume will be 2ai
* Choose some chemical i and divide its volume by two (integer division) so the new volume will be <image>
Suppose that each chemical is contained in a vessel of infinite volume. Now Amr wonders what is the minimum number of operations required to make all the chemicals volumes equal?
Input
The first line contains one number n (1 ≤ n ≤ 105), the number of chemicals.
The second line contains n space separated integers ai (1 ≤ ai ≤ 105), representing the initial volume of the i-th chemical in liters.
Output
Output one integer the minimum number of operations required to make all the chemicals volumes equal.
Examples
Input
3
4 8 2
Output
2
Input
3
3 5 6
Output
5
Note
In the first sample test, the optimal solution is to divide the second chemical volume by two, and multiply the third chemical volume by two to make all the volumes equal 4.
In the second sample test, the optimal solution is to divide the first chemical volume by two, and divide the second and the third chemical volumes by two twice to make all the volumes equal 1.
Submitted Solution:
```
#TL
def f(a, b):
k = 0
while a != b:
if a > b:
a //= 2
else:
b //= 2
k += 1
return k
x = int(input())
y = list(map(int, input().split(' ')))
ans = 10000000000000
for i in y:
ek = 0
for j in y:
ek += f(i, j)
ans = min(ans, ek)
print(ans)
``` | instruction | 0 | 37,241 | 3 | 74,482 |
No | output | 1 | 37,241 | 3 | 74,483 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N observatories in AtCoder Hill, called Obs. 1, Obs. 2, ..., Obs. N. The elevation of Obs. i is H_i. There are also M roads, each connecting two different observatories. Road j connects Obs. A_j and Obs. B_j.
Obs. i is said to be good when its elevation is higher than those of all observatories that can be reached from Obs. i using just one road. Note that Obs. i is also good when no observatory can be reached from Obs. i using just one road.
How many good observatories are there?
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq H_i \leq 10^9
* 1 \leq A_i,B_i \leq N
* A_i \neq B_i
* Multiple roads may connect the same pair of observatories.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
H_1 H_2 ... H_N
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the number of good observatories.
Examples
Input
4 3
1 2 3 4
1 3
2 3
2 4
Output
2
Input
6 5
8 6 9 1 2 1
1 3
4 2
4 3
4 6
4 6
Output
3
Submitted Solution:
```
n,m = map(int,input().split())
h = list(map(int,input().split()))
ans = [1]*n
for i in range(m):
a,b = map(int,input().split())
if h[a-1] <= h[b-1]:
ans[a-1] = 0
if h[b-1] <= h[a-1]:
ans[b-1] = 0
print(sum(ans))
``` | instruction | 0 | 37,515 | 3 | 75,030 |
Yes | output | 1 | 37,515 | 3 | 75,031 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N observatories in AtCoder Hill, called Obs. 1, Obs. 2, ..., Obs. N. The elevation of Obs. i is H_i. There are also M roads, each connecting two different observatories. Road j connects Obs. A_j and Obs. B_j.
Obs. i is said to be good when its elevation is higher than those of all observatories that can be reached from Obs. i using just one road. Note that Obs. i is also good when no observatory can be reached from Obs. i using just one road.
How many good observatories are there?
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq H_i \leq 10^9
* 1 \leq A_i,B_i \leq N
* A_i \neq B_i
* Multiple roads may connect the same pair of observatories.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
H_1 H_2 ... H_N
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the number of good observatories.
Examples
Input
4 3
1 2 3 4
1 3
2 3
2 4
Output
2
Input
6 5
8 6 9 1 2 1
1 3
4 2
4 3
4 6
4 6
Output
3
Submitted Solution:
```
N, M = list(map(int,input().split()))
H= list(map(int,input().split()))
t=[0]*N
for i in range(M):
A,B= list(map(int,input().split()))
t[A-1]=max(t[A-1],H[B-1])
t[B-1]=max(t[B-1],H[A-1])
ans=0
for i in range(N):
if t[i]<H[i]:
ans+=1
print(ans)
``` | instruction | 0 | 37,516 | 3 | 75,032 |
Yes | output | 1 | 37,516 | 3 | 75,033 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N observatories in AtCoder Hill, called Obs. 1, Obs. 2, ..., Obs. N. The elevation of Obs. i is H_i. There are also M roads, each connecting two different observatories. Road j connects Obs. A_j and Obs. B_j.
Obs. i is said to be good when its elevation is higher than those of all observatories that can be reached from Obs. i using just one road. Note that Obs. i is also good when no observatory can be reached from Obs. i using just one road.
How many good observatories are there?
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq H_i \leq 10^9
* 1 \leq A_i,B_i \leq N
* A_i \neq B_i
* Multiple roads may connect the same pair of observatories.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
H_1 H_2 ... H_N
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the number of good observatories.
Examples
Input
4 3
1 2 3 4
1 3
2 3
2 4
Output
2
Input
6 5
8 6 9 1 2 1
1 3
4 2
4 3
4 6
4 6
Output
3
Submitted Solution:
```
N,M=map(int,input().split())
H=list(map(int,input().split()))
ab=[0]*N
for i in range(M):
a,b=map(int,input().split())
ab[a-1]=max(ab[a-1],H[b-1])
ab[b-1]=max(ab[b-1],H[a-1])
ans=0
for i in range(N):
if ab[i]<H[i]:
ans+=1
print(ans)
``` | instruction | 0 | 37,517 | 3 | 75,034 |
Yes | output | 1 | 37,517 | 3 | 75,035 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N observatories in AtCoder Hill, called Obs. 1, Obs. 2, ..., Obs. N. The elevation of Obs. i is H_i. There are also M roads, each connecting two different observatories. Road j connects Obs. A_j and Obs. B_j.
Obs. i is said to be good when its elevation is higher than those of all observatories that can be reached from Obs. i using just one road. Note that Obs. i is also good when no observatory can be reached from Obs. i using just one road.
How many good observatories are there?
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq H_i \leq 10^9
* 1 \leq A_i,B_i \leq N
* A_i \neq B_i
* Multiple roads may connect the same pair of observatories.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
H_1 H_2 ... H_N
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the number of good observatories.
Examples
Input
4 3
1 2 3 4
1 3
2 3
2 4
Output
2
Input
6 5
8 6 9 1 2 1
1 3
4 2
4 3
4 6
4 6
Output
3
Submitted Solution:
```
N, M = map(int, input().split())
H = list(map(int, input().split()))
x = [1] * N
for i in range(M):
A, B = map(int, input().split())
if H[A-1] <= H[B-1]:
x[A-1] = 0
if H[A-1] >= H[B-1]:
x[B-1] = 0
print(x.count(1))
``` | instruction | 0 | 37,518 | 3 | 75,036 |
Yes | output | 1 | 37,518 | 3 | 75,037 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N observatories in AtCoder Hill, called Obs. 1, Obs. 2, ..., Obs. N. The elevation of Obs. i is H_i. There are also M roads, each connecting two different observatories. Road j connects Obs. A_j and Obs. B_j.
Obs. i is said to be good when its elevation is higher than those of all observatories that can be reached from Obs. i using just one road. Note that Obs. i is also good when no observatory can be reached from Obs. i using just one road.
How many good observatories are there?
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq H_i \leq 10^9
* 1 \leq A_i,B_i \leq N
* A_i \neq B_i
* Multiple roads may connect the same pair of observatories.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
H_1 H_2 ... H_N
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the number of good observatories.
Examples
Input
4 3
1 2 3 4
1 3
2 3
2 4
Output
2
Input
6 5
8 6 9 1 2 1
1 3
4 2
4 3
4 6
4 6
Output
3
Submitted Solution:
```
import sys
from math import factorial
from collections import Counter
from fractions import Fraction
import heapq, bisect, fractions
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
MOD = 10**9 + 7
n, m = MAP()
H = LIST()
low = [0]*m
for i in range(m):
a, b= MAP()
if H[a-1] == H[b-1]:
low.append(a-1)
low.append(b-1)
elif H[a-1] < H[b-1]:
low.append(a-1)
else:
low.append(b-1)
print(n-len(set(low)))
``` | instruction | 0 | 37,519 | 3 | 75,038 |
No | output | 1 | 37,519 | 3 | 75,039 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N observatories in AtCoder Hill, called Obs. 1, Obs. 2, ..., Obs. N. The elevation of Obs. i is H_i. There are also M roads, each connecting two different observatories. Road j connects Obs. A_j and Obs. B_j.
Obs. i is said to be good when its elevation is higher than those of all observatories that can be reached from Obs. i using just one road. Note that Obs. i is also good when no observatory can be reached from Obs. i using just one road.
How many good observatories are there?
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq H_i \leq 10^9
* 1 \leq A_i,B_i \leq N
* A_i \neq B_i
* Multiple roads may connect the same pair of observatories.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
H_1 H_2 ... H_N
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the number of good observatories.
Examples
Input
4 3
1 2 3 4
1 3
2 3
2 4
Output
2
Input
6 5
8 6 9 1 2 1
1 3
4 2
4 3
4 6
4 6
Output
3
Submitted Solution:
```
N, M = map(int, input().split())
Hi = list(map(int,input().split(" ")))
path = [list() for _ in range(M+1)]
for i in range(M):
a, b = map(int, input().split())
a -= 1
b -= 1
path[a].append(b)
path[b].append(a)
goodT = 0
T = range(M)
for i, p in zip(T, path):
good = 1
if p == []:
goodT += good
else:
for t in p:
if Hi[i] <= Hi[t]:
good = 0
goodT +=good
print (goodT)
``` | instruction | 0 | 37,520 | 3 | 75,040 |
No | output | 1 | 37,520 | 3 | 75,041 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N observatories in AtCoder Hill, called Obs. 1, Obs. 2, ..., Obs. N. The elevation of Obs. i is H_i. There are also M roads, each connecting two different observatories. Road j connects Obs. A_j and Obs. B_j.
Obs. i is said to be good when its elevation is higher than those of all observatories that can be reached from Obs. i using just one road. Note that Obs. i is also good when no observatory can be reached from Obs. i using just one road.
How many good observatories are there?
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq H_i \leq 10^9
* 1 \leq A_i,B_i \leq N
* A_i \neq B_i
* Multiple roads may connect the same pair of observatories.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
H_1 H_2 ... H_N
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the number of good observatories.
Examples
Input
4 3
1 2 3 4
1 3
2 3
2 4
Output
2
Input
6 5
8 6 9 1 2 1
1 3
4 2
4 3
4 6
4 6
Output
3
Submitted Solution:
```
def solve(n, m, h, a, b):
for j in range(m):
a[j] -= 1
b[j] -= 1
parents = [i for i in range(n)]
def root(x):
return x if parents[x] == x else root(parents[x])
for a_j, b_j in zip(a, b):
if root(a_j) != root(b_j):
if a_j > b_j:
a_j, b_j = b_j, a_j
parents[root(b_j)] = root(a_j)
D = {}
for j, pj in enumerate(parents):
if not pj in D:
D[pj] = []
D[pj].append(h[j])
ans = 0
for k, v in D.items():
if len(v) == 1:
ans += 1
else:
v = sorted(v)
ans += int(v[-1] > v[-2])
return ans
n, m = map(int, input().split())
h = list(map(int, input().split()))
a = [0] * m
b = [0] * m
for j in range(m):
a[j], b[j] = map(int, input().split())
print(solve(n,m, h, a, b))
``` | instruction | 0 | 37,521 | 3 | 75,042 |
No | output | 1 | 37,521 | 3 | 75,043 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The dice are placed in the orientation shown in the figure below.
<image>
As shown in this figure, the dice used here have 1 on the upper side and 2 on the south side, and 3 on the east side. Since the sum of the facing faces of the dice is always 7, the invisible faces are 5 on the north side, 4 on the west side, and 6 on the bottom side, respectively.
From this initial arrangement, move the dice according to the instructions. However, the instruction is to perform the following six operations several times.
<image> | <image> | <image> | <image>
--- | --- | --- | ---
<image> | <image> | |
The North, East, South, and West operations rotate the dice 90 degrees in the indicated direction. The two operations, Right and Left, rotate 90 degrees horizontally while keeping the upper and lower surfaces unchanged. (Be careful of the direction of rotation.)
The initial value is the number of eyes 1 that appears on the upper surface in the initial arrangement, and after each operation, the number of eyes that appear on the upper surface is added, and all operations are completed according to the instructions. Create a program that outputs the total value of the above.
The first line of the input file contains the total number of instructions n, and each of the following n lines contains one of the "North, East, South, West, Right, Left" instructions. Let. However, n ≤ 10000.
Input example 1 | Input example 2
--- | ---
5 | 8
North | West
North | North
East | Left
South | South
West | Right
| North
| Left
| East
Output example 1 | Output example 2
21 | 34
input
The input consists of multiple datasets. Input ends when n is 0. The number of datasets does not exceed 5.
output
The total value is output to one line for each data set.
Example
Input
5
North
North
East
South
West
8
West
North
Left
South
Right
North
Left
East
0
Output
21
34
Submitted Solution:
```
def main():
while True:
N = int(input())
if N == 0:
return
m = [1, 2, 3, 4, 5, 6]
ans = 1
for i in range(N):
o = input()[0]
if o == 'N':
m = [m[1], m[5], m[2], m[3], m[0], m[4]]
elif o == 'S':
m = [m[4], m[0], m[2], m[3], m[5], m[1]]
elif o == 'W':
m = [m[2], m[1], m[5], m[0], m[4], m[3]]
elif o == 'E':
m = [m[3], m[1], m[0], m[5], m[4], m[2]]
elif o == 'R':
m = [m[0], m[2], m[4], m[1], m[3], m[5]]
elif o == 'L':
m = [m[0], m[3], m[1], m[4], m[2], m[5]]
ans += m[0]
print(ans)
if __name__ == '__main__':
main()
``` | instruction | 0 | 37,683 | 3 | 75,366 |
Yes | output | 1 | 37,683 | 3 | 75,367 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The dice are placed in the orientation shown in the figure below.
<image>
As shown in this figure, the dice used here have 1 on the upper side and 2 on the south side, and 3 on the east side. Since the sum of the facing faces of the dice is always 7, the invisible faces are 5 on the north side, 4 on the west side, and 6 on the bottom side, respectively.
From this initial arrangement, move the dice according to the instructions. However, the instruction is to perform the following six operations several times.
<image> | <image> | <image> | <image>
--- | --- | --- | ---
<image> | <image> | |
The North, East, South, and West operations rotate the dice 90 degrees in the indicated direction. The two operations, Right and Left, rotate 90 degrees horizontally while keeping the upper and lower surfaces unchanged. (Be careful of the direction of rotation.)
The initial value is the number of eyes 1 that appears on the upper surface in the initial arrangement, and after each operation, the number of eyes that appear on the upper surface is added, and all operations are completed according to the instructions. Create a program that outputs the total value of the above.
The first line of the input file contains the total number of instructions n, and each of the following n lines contains one of the "North, East, South, West, Right, Left" instructions. Let. However, n ≤ 10000.
Input example 1 | Input example 2
--- | ---
5 | 8
North | West
North | North
East | Left
South | South
West | Right
| North
| Left
| East
Output example 1 | Output example 2
21 | 34
input
The input consists of multiple datasets. Input ends when n is 0. The number of datasets does not exceed 5.
output
The total value is output to one line for each data set.
Example
Input
5
North
North
East
South
West
8
West
North
Left
South
Right
North
Left
East
0
Output
21
34
Submitted Solution:
```
while 1:
n=int(input())
if n==0:break
a=1;s='123456'
for _ in[0]*n:
s=[s[int(e)]for e in{'N':"152304",'E':"310542",'W':"215043",'S':"402351",'R':"024135",'L':"031425"}[input()[0]]]
a+=int(s[0])
print(a)
``` | instruction | 0 | 37,684 | 3 | 75,368 |
Yes | output | 1 | 37,684 | 3 | 75,369 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The dice are placed in the orientation shown in the figure below.
<image>
As shown in this figure, the dice used here have 1 on the upper side and 2 on the south side, and 3 on the east side. Since the sum of the facing faces of the dice is always 7, the invisible faces are 5 on the north side, 4 on the west side, and 6 on the bottom side, respectively.
From this initial arrangement, move the dice according to the instructions. However, the instruction is to perform the following six operations several times.
<image> | <image> | <image> | <image>
--- | --- | --- | ---
<image> | <image> | |
The North, East, South, and West operations rotate the dice 90 degrees in the indicated direction. The two operations, Right and Left, rotate 90 degrees horizontally while keeping the upper and lower surfaces unchanged. (Be careful of the direction of rotation.)
The initial value is the number of eyes 1 that appears on the upper surface in the initial arrangement, and after each operation, the number of eyes that appear on the upper surface is added, and all operations are completed according to the instructions. Create a program that outputs the total value of the above.
The first line of the input file contains the total number of instructions n, and each of the following n lines contains one of the "North, East, South, West, Right, Left" instructions. Let. However, n ≤ 10000.
Input example 1 | Input example 2
--- | ---
5 | 8
North | West
North | North
East | Left
South | South
West | Right
| North
| Left
| East
Output example 1 | Output example 2
21 | 34
input
The input consists of multiple datasets. Input ends when n is 0. The number of datasets does not exceed 5.
output
The total value is output to one line for each data set.
Example
Input
5
North
North
East
South
West
8
West
North
Left
South
Right
North
Left
East
0
Output
21
34
Submitted Solution:
```
c={'N':"152304",'E':"310542",'W':"215043",'S':"402351",'R':"024135",'L':"031425"}
while 1:
n=int(input())
if n==0:break
a=1;s='123456'
for _ in[0]*n:
s=[s[int(e)]for e in c[input()[0]]]
a+=int(s[0])
print(a)
``` | instruction | 0 | 37,685 | 3 | 75,370 |
Yes | output | 1 | 37,685 | 3 | 75,371 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The dice are placed in the orientation shown in the figure below.
<image>
As shown in this figure, the dice used here have 1 on the upper side and 2 on the south side, and 3 on the east side. Since the sum of the facing faces of the dice is always 7, the invisible faces are 5 on the north side, 4 on the west side, and 6 on the bottom side, respectively.
From this initial arrangement, move the dice according to the instructions. However, the instruction is to perform the following six operations several times.
<image> | <image> | <image> | <image>
--- | --- | --- | ---
<image> | <image> | |
The North, East, South, and West operations rotate the dice 90 degrees in the indicated direction. The two operations, Right and Left, rotate 90 degrees horizontally while keeping the upper and lower surfaces unchanged. (Be careful of the direction of rotation.)
The initial value is the number of eyes 1 that appears on the upper surface in the initial arrangement, and after each operation, the number of eyes that appear on the upper surface is added, and all operations are completed according to the instructions. Create a program that outputs the total value of the above.
The first line of the input file contains the total number of instructions n, and each of the following n lines contains one of the "North, East, South, West, Right, Left" instructions. Let. However, n ≤ 10000.
Input example 1 | Input example 2
--- | ---
5 | 8
North | West
North | North
East | Left
South | South
West | Right
| North
| Left
| East
Output example 1 | Output example 2
21 | 34
input
The input consists of multiple datasets. Input ends when n is 0. The number of datasets does not exceed 5.
output
The total value is output to one line for each data set.
Example
Input
5
North
North
East
South
West
8
West
North
Left
South
Right
North
Left
East
0
Output
21
34
Submitted Solution:
```
def North(d):
d[0], d[1], d[3], d[5] = d[1], d[5], d[0], d[3]
return int(d[0])
def West(d):
d[0], d[2], d[4], d[5] = d[2], d[5], d[0], d[4]
return int(d[0])
def East(d):
d[0], d[2], d[4], d[5] = d[4], d[0], d[5], d[2]
return int(d[0])
def South(d):
d[0], d[1], d[3], d[5] = d[3], d[0], d[5], d[1]
return int(d[0])
def Right(d):
d[1], d[2], d[3], d[4] = d[2], d[3], d[4], d[1]
return int(d[0])
def Left(d):
d[1], d[2], d[3], d[4] = d[4], d[1], d[2], d[3]
return int(d[0])
while True:
n = int(input())
if n == 0:
break
dice = ['1','2','3','5','4','6']
total = 1
for i in range(n):
ss = str(input().split()[0])
if ss == "North":
total += North(dice)
elif ss == "West":
total += West(dice)
elif ss == "East":
total += East(dice)
elif ss == "South":
total += South(dice)
elif ss == "Right":
total += Right(dice)
elif ss == "Left":
total += Left(dice)
print(total)
``` | instruction | 0 | 37,686 | 3 | 75,372 |
Yes | output | 1 | 37,686 | 3 | 75,373 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The dice are placed in the orientation shown in the figure below.
<image>
As shown in this figure, the dice used here have 1 on the upper side and 2 on the south side, and 3 on the east side. Since the sum of the facing faces of the dice is always 7, the invisible faces are 5 on the north side, 4 on the west side, and 6 on the bottom side, respectively.
From this initial arrangement, move the dice according to the instructions. However, the instruction is to perform the following six operations several times.
<image> | <image> | <image> | <image>
--- | --- | --- | ---
<image> | <image> | |
The North, East, South, and West operations rotate the dice 90 degrees in the indicated direction. The two operations, Right and Left, rotate 90 degrees horizontally while keeping the upper and lower surfaces unchanged. (Be careful of the direction of rotation.)
The initial value is the number of eyes 1 that appears on the upper surface in the initial arrangement, and after each operation, the number of eyes that appear on the upper surface is added, and all operations are completed according to the instructions. Create a program that outputs the total value of the above.
The first line of the input file contains the total number of instructions n, and each of the following n lines contains one of the "North, East, South, West, Right, Left" instructions. Let. However, n ≤ 10000.
Input example 1 | Input example 2
--- | ---
5 | 8
North | West
North | North
East | Left
South | South
West | Right
| North
| Left
| East
Output example 1 | Output example 2
21 | 34
input
The input consists of multiple datasets. Input ends when n is 0. The number of datasets does not exceed 5.
output
The total value is output to one line for each data set.
Example
Input
5
North
North
East
South
West
8
West
North
Left
South
Right
North
Left
East
0
Output
21
34
Submitted Solution:
```
# coding: utf-8
# Here your code !
Dice = [1,2,3] # top,front,right
def North(d):
d = [d[1]] + [7 -d[0]] + [d[2]]
return d
def East(d):
d = [7-d[2]] + [d[1]] + [d[0]]
return d
def South(d):
d = [7-d[1]] + [d[0]] + [d[2]]
return d
def West(d):
d = [d[2]] + [d[1]] + [7-d[0]]
return d
def Right(d):
d = [d[0]] + [d[2]] + [7-d[1]]
return d
def Left(d):
d = [d[0]] + [7-d[2]] + [d[1]]
return d
while True:
n = int(input())
if n == 0:
break
dice = [1,2,3]
result = 1
for _ in range(n):
direction = input()
dice = eval(direction+"(dice)")
#print(dice)
result += dice[0]
print(result)
``` | instruction | 0 | 37,687 | 3 | 75,374 |
No | output | 1 | 37,687 | 3 | 75,375 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The dice are placed in the orientation shown in the figure below.
<image>
As shown in this figure, the dice used here have 1 on the upper side and 2 on the south side, and 3 on the east side. Since the sum of the facing faces of the dice is always 7, the invisible faces are 5 on the north side, 4 on the west side, and 6 on the bottom side, respectively.
From this initial arrangement, move the dice according to the instructions. However, the instruction is to perform the following six operations several times.
<image> | <image> | <image> | <image>
--- | --- | --- | ---
<image> | <image> | |
The North, East, South, and West operations rotate the dice 90 degrees in the indicated direction. The two operations, Right and Left, rotate 90 degrees horizontally while keeping the upper and lower surfaces unchanged. (Be careful of the direction of rotation.)
The initial value is the number of eyes 1 that appears on the upper surface in the initial arrangement, and after each operation, the number of eyes that appear on the upper surface is added, and all operations are completed according to the instructions. Create a program that outputs the total value of the above.
The first line of the input file contains the total number of instructions n, and each of the following n lines contains one of the "North, East, South, West, Right, Left" instructions. Let. However, n ≤ 10000.
Input example 1 | Input example 2
--- | ---
5 | 8
North | West
North | North
East | Left
South | South
West | Right
| North
| Left
| East
Output example 1 | Output example 2
21 | 34
input
The input consists of multiple datasets. Input ends when n is 0. The number of datasets does not exceed 5.
output
The total value is output to one line for each data set.
Example
Input
5
North
North
East
South
West
8
West
North
Left
South
Right
North
Left
East
0
Output
21
34
Submitted Solution:
```
import sys
def main():
for line in sys.stdin:
n = int(line)
if n == 0:
break
else:
act = []
for _ in range(n):
act.append(input())
total = 1
dice = [0, 1, 2, 3, 4, 5, 6]
#Top, South, East, West, North, Bottom
for x in range(n):
hoge = act[x]
if hoge == "North":
tmp = dice[6]
dice[6] = dice[5]
dice[5] = dice[1]
dice[1] = dice[2]
dice[2] = tmp
elif hoge == "East":
tmp = dice[6]
dice[6] = dice[3]
dice[3] = dice[1]
dice[1] = dice[4]
dice[4] = tmp
elif hoge == "West":
tmp = dice[6]
dice[6] = dice[4]
dice[4] = dice[1]
dice[1] = dice[3]
dice[3] = tmp
elif hoge == "South":
tmp = dice[6]
dice[6] = dice[2]
dice[2] = dice[1]
dice[1] = dice[5]
dice[5] = tmp
elif hoge == "Right":
tmp = dice[5]
dice[5] = dice[4]
dice[4] = dice[2]
dice[2] = dice[3]
dice[3] = tmp
elif hoge == "Left":
tmp = dice[5]
dice[5] = dice[3]
dice[3] = dice[2]
dice[2] = dice[4]
dice[4] = tmp
total += dice[1]
print(total)
if __name__ == "__main__":
main()
``` | instruction | 0 | 37,688 | 3 | 75,376 |
No | output | 1 | 37,688 | 3 | 75,377 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The dice are placed in the orientation shown in the figure below.
<image>
As shown in this figure, the dice used here have 1 on the upper side and 2 on the south side, and 3 on the east side. Since the sum of the facing faces of the dice is always 7, the invisible faces are 5 on the north side, 4 on the west side, and 6 on the bottom side, respectively.
From this initial arrangement, move the dice according to the instructions. However, the instruction is to perform the following six operations several times.
<image> | <image> | <image> | <image>
--- | --- | --- | ---
<image> | <image> | |
The North, East, South, and West operations rotate the dice 90 degrees in the indicated direction. The two operations, Right and Left, rotate 90 degrees horizontally while keeping the upper and lower surfaces unchanged. (Be careful of the direction of rotation.)
The initial value is the number of eyes 1 that appears on the upper surface in the initial arrangement, and after each operation, the number of eyes that appear on the upper surface is added, and all operations are completed according to the instructions. Create a program that outputs the total value of the above.
The first line of the input file contains the total number of instructions n, and each of the following n lines contains one of the "North, East, South, West, Right, Left" instructions. Let. However, n ≤ 10000.
Input example 1 | Input example 2
--- | ---
5 | 8
North | West
North | North
East | Left
South | South
West | Right
| North
| Left
| East
Output example 1 | Output example 2
21 | 34
input
The input consists of multiple datasets. Input ends when n is 0. The number of datasets does not exceed 5.
output
The total value is output to one line for each data set.
Example
Input
5
North
North
East
South
West
8
West
North
Left
South
Right
North
Left
East
0
Output
21
34
Submitted Solution:
```
orders = {
'North': (2, 6, 3, 4, 1, 5),
'East': (4, 2, 1, 6, 5, 3),
'West': (3, 2, 6, 1, 5, 4),
'South': (5, 1, 3, 4, 6, 2),
'Right': (1, 3, 5, 2, 4, 6),
'Left': (1, 4, 2, 5, 3, 6),
}
while True:
n = int(input())
if not n:
break
dice = list(range(1, 7))
top = 1
while n:
new_dice = [dice[s - 1] for s in orders[input()]]
dice = new_dice
top += dice[0]
n -= 1
print(top)
``` | instruction | 0 | 37,689 | 3 | 75,378 |
No | output | 1 | 37,689 | 3 | 75,379 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a chain consisting of multiple circles on a plane. The first (last) circle of the chain only intersects with the next (previous) circle, and each intermediate circle intersects only with the two neighboring circles.
Your task is to find the shortest path that satisfies the following conditions.
* The path connects the centers of the first circle and the last circle.
* The path is confined in the chain, that is, all the points on the path are located within or on at least one of the circles.
Figure E-1 shows an example of such a chain and the corresponding shortest path.
<image>
Figure E-1: An example chain and the corresponding shortest path
Input
The input consists of multiple datasets. Each dataset represents the shape of a chain in the following format.
> n
> x1 y1 r1
> x2 y2 r2
> ...
> xn yn rn
>
The first line of a dataset contains an integer n (3 ≤ n ≤ 100) representing the number of the circles. Each of the following n lines contains three integers separated by a single space. (xi, yi) and ri represent the center position and the radius of the i-th circle Ci. You can assume that 0 ≤ xi ≤ 1000, 0 ≤ yi ≤ 1000, and 1 ≤ ri ≤ 25.
You can assume that Ci and Ci+1 (1 ≤ i ≤ n−1) intersect at two separate points. When j ≥ i+2, Ci and Cj are apart and either of them does not contain the other. In addition, you can assume that any circle does not contain the center of any other circle.
The end of the input is indicated by a line containing a zero.
Figure E-1 corresponds to the first dataset of Sample Input below. Figure E-2 shows the shortest paths for the subsequent datasets of Sample Input.
<image>
Figure E-2: Example chains and the corresponding shortest paths
Output
For each dataset, output a single line containing the length of the shortest chain-confined path between the centers of the first circle and the last circle. The value should not have an error greater than 0.001. No extra characters should appear in the output.
Sample Input
10
802 0 10
814 0 4
820 1 4
826 1 4
832 3 5
838 5 5
845 7 3
849 10 3
853 14 4
857 18 3
3
0 0 5
8 0 5
8 8 5
3
0 0 5
7 3 6
16 0 5
9
0 3 5
8 0 8
19 2 8
23 14 6
23 21 6
23 28 6
19 40 8
8 42 8
0 39 5
11
0 0 5
8 0 5
18 8 10
8 16 5
0 16 5
0 24 5
3 32 5
10 32 5
17 28 8
27 25 3
30 18 5
0
Output for the Sample Input
58.953437
11.414214
16.0
61.874812
63.195179
Example
Input
10
802 0 10
814 0 4
820 1 4
826 1 4
832 3 5
838 5 5
845 7 3
849 10 3
853 14 4
857 18 3
3
0 0 5
8 0 5
8 8 5
3
0 0 5
7 3 6
16 0 5
9
0 3 5
8 0 8
19 2 8
23 14 6
23 21 6
23 28 6
19 40 8
8 42 8
0 39 5
11
0 0 5
8 0 5
18 8 10
8 16 5
0 16 5
0 24 5
3 32 5
10 32 5
17 28 8
27 25 3
30 18 5
0
Output
58.953437
11.414214
16.0
61.874812
63.195179
Submitted Solution:
```
import math
class Vec:
def __init__(self, x, y):
self.x = x
self.y = y
def __mul__(self, other):
return Vec(self.x * other, self.y * other)
def length(self):
return math.sqrt(self.x * self.x + self.y * self.y)
def __str__(self):
return "({},{})".format(self.x, self.y)
def __sub__(self, other):
return Vec(self.x - other.x, self.y - other.y)
def __add__(self, other):
return Vec(self.x + other.x, self.y + other.y)
def __truediv__(self, other):
return Vec(self.x / other, self.y / other)
def turn90(self):
return Vec(-self.y, self.x)
def normalized(self):
return self / self.length()
def is_clock(self, other):
return self.x * other.y - self.y * other.x < 0
class Circle:
def __init__(self, x, y, r):
self.r = r
self.center = Vec(x, y)
def intersection(self, other):
d = (self.center - other.center).length()
r1 = self.r
r2 = other.r
d1 = (d * d + r1 * r1 - r2 * r2) / 2 / d
x = math.sqrt(r1 * r1 - d1 * d1)
e1 = (other.center - self.center).normalized()
e2 = e1.turn90()
p1 = self.center + e1 * d1 + e2 * x
p2 = self.center + e1 * d1 - e2 * x
return p1, p2
def __str__(self):
return "({},{})".format(self.center, self.r)
def solve(ps: [Circle]):
intersects = []
for i in range(len(ps) - 1):
ci = ps[i]
ci_next = ps[i + 1]
intersection1, intersection2 = ci.intersection(ci_next)
intersects.append((intersection1, intersection2))
res = [[ps[0].center, -1, 0]] # 候補座標とその深度と左右(0,1)
dists = [[2 ** 32, 2 ** 32] for _ in range(len(intersects))] # 各交点の距離バッファ
min_path_length = 2 ** 32
while len(res) != 0:
res = sorted(res, key=lambda a: a[1], reverse=True)
c, depth, lr = res.pop()
current_path_length = dists[depth][lr] if depth != -1 else 0
if depth == len(intersects) - 1:
last_path = ps[-1].center - c
min_path_length = min(min_path_length, current_path_length + last_path.length())
continue
l_limit_min, r_limit_min = [a - c for a in intersects[depth + 1]] # 左右の限界
l_limit, r_limit = l_limit_min, r_limit_min # 到達可能限界
l_limit_d, r_limit_d = depth + 1, depth + 1
for i in range(depth + 2, len(intersects)):
l_limit2, r_limit2 = [a - c for a in intersects[i]]
if l_limit_min.is_clock(l_limit2): # 限界更新
l_limit_min = l_limit2
if l_limit2.is_clock(r_limit_min): # 到達可能なら、こっちも更新
l_limit = l_limit2
l_limit_d = i
if r_limit2.is_clock(r_limit_min): # 限界更新
r_limit_min = r_limit2
if l_limit_min.is_clock(r_limit2): # 到達可能なら、こっちも更新
r_limit = r_limit2
r_limit_d = i
last_path = ps[-1].center - c
if l_limit_min.is_clock(last_path) and last_path.is_clock(r_limit_min): # この点からゴールまで行ける
min_path_length = min(min_path_length, current_path_length + last_path.length())
continue
if dists[l_limit_d][0] > l_limit.length() + current_path_length:
dists[l_limit_d][0] = l_limit.length() + current_path_length
res.append([l_limit + c, l_limit_d, 0])
if dists[r_limit_d][1] > r_limit.length() + current_path_length:
dists[r_limit_d][1] = r_limit.length() + current_path_length
res.append([r_limit + c, r_limit_d, 1])
return min_path_length
def main():
while True:
n = int(input())
if n == 0:
break
ps = [Circle(*[int(a) for a in input().split()]) for _ in range(n)]
print(solve(ps))
if __name__ == '__main__':
main()
``` | instruction | 0 | 37,700 | 3 | 75,400 |
No | output | 1 | 37,700 | 3 | 75,401 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a chain consisting of multiple circles on a plane. The first (last) circle of the chain only intersects with the next (previous) circle, and each intermediate circle intersects only with the two neighboring circles.
Your task is to find the shortest path that satisfies the following conditions.
* The path connects the centers of the first circle and the last circle.
* The path is confined in the chain, that is, all the points on the path are located within or on at least one of the circles.
Figure E-1 shows an example of such a chain and the corresponding shortest path.
<image>
Figure E-1: An example chain and the corresponding shortest path
Input
The input consists of multiple datasets. Each dataset represents the shape of a chain in the following format.
> n
> x1 y1 r1
> x2 y2 r2
> ...
> xn yn rn
>
The first line of a dataset contains an integer n (3 ≤ n ≤ 100) representing the number of the circles. Each of the following n lines contains three integers separated by a single space. (xi, yi) and ri represent the center position and the radius of the i-th circle Ci. You can assume that 0 ≤ xi ≤ 1000, 0 ≤ yi ≤ 1000, and 1 ≤ ri ≤ 25.
You can assume that Ci and Ci+1 (1 ≤ i ≤ n−1) intersect at two separate points. When j ≥ i+2, Ci and Cj are apart and either of them does not contain the other. In addition, you can assume that any circle does not contain the center of any other circle.
The end of the input is indicated by a line containing a zero.
Figure E-1 corresponds to the first dataset of Sample Input below. Figure E-2 shows the shortest paths for the subsequent datasets of Sample Input.
<image>
Figure E-2: Example chains and the corresponding shortest paths
Output
For each dataset, output a single line containing the length of the shortest chain-confined path between the centers of the first circle and the last circle. The value should not have an error greater than 0.001. No extra characters should appear in the output.
Sample Input
10
802 0 10
814 0 4
820 1 4
826 1 4
832 3 5
838 5 5
845 7 3
849 10 3
853 14 4
857 18 3
3
0 0 5
8 0 5
8 8 5
3
0 0 5
7 3 6
16 0 5
9
0 3 5
8 0 8
19 2 8
23 14 6
23 21 6
23 28 6
19 40 8
8 42 8
0 39 5
11
0 0 5
8 0 5
18 8 10
8 16 5
0 16 5
0 24 5
3 32 5
10 32 5
17 28 8
27 25 3
30 18 5
0
Output for the Sample Input
58.953437
11.414214
16.0
61.874812
63.195179
Example
Input
10
802 0 10
814 0 4
820 1 4
826 1 4
832 3 5
838 5 5
845 7 3
849 10 3
853 14 4
857 18 3
3
0 0 5
8 0 5
8 8 5
3
0 0 5
7 3 6
16 0 5
9
0 3 5
8 0 8
19 2 8
23 14 6
23 21 6
23 28 6
19 40 8
8 42 8
0 39 5
11
0 0 5
8 0 5
18 8 10
8 16 5
0 16 5
0 24 5
3 32 5
10 32 5
17 28 8
27 25 3
30 18 5
0
Output
58.953437
11.414214
16.0
61.874812
63.195179
Submitted Solution:
```
import math
class Vec:
def __init__(self, x, y):
self.x = x
self.y = y
def __mul__(self, other):
return Vec(self.x * other, self.y * other)
def length(self):
return math.sqrt(self.x * self.x + self.y * self.y)
def __str__(self):
return "({},{})".format(self.x, self.y)
def __sub__(self, other):
return Vec(self.x - other.x, self.y - other.y)
def __add__(self, other):
return Vec(self.x + other.x, self.y + other.y)
def __truediv__(self, other):
return Vec(self.x / other, self.y / other)
def turn90(self):
return Vec(-self.y, self.x)
def normalized(self):
return self / self.length()
def is_clock(self, other):
return self.x * other.y - self.y * other.x < 0
class Circle:
def __init__(self, x, y, r):
self.r = r
self.center = Vec(x, y)
def intersection(self, other):
d = (self.center - other.center).length()
r1 = self.r
r2 = other.r
d1 = (d * d + r1 * r1 - r2 * r2) / 2 / d
x = math.sqrt(r1 * r1 - d1 * d1)
e1 = (other.center - self.center).normalized()
e2 = e1.turn90()
p1 = self.center + e1 * d1 + e2 * x
p2 = self.center + e1 * d1 - e2 * x
return p1, p2
def __str__(self):
return "({},{})".format(self.center, self.r)
def solve(ps: [Circle]):
intersects = []
for i in range(len(ps) - 1):
ci = ps[i]
ci_next = ps[i + 1]
intersection1, intersection2 = ci.intersection(ci_next)
intersects.append((intersection1, intersection2))
res = [[ps[0].center, -1, 0]] # 候補座標とその深度と左右(0,1)
dists = [[2 ** 32, 2 ** 32] for _ in range(len(intersects))] # 各交点の距離バッファ
min_path_length = 2 ** 32
while len(res) != 0:
res = sorted(res, key=lambda a: a[1], reverse=True)
c, depth, lr = res.pop()
current_path_length = dists[depth][lr] if depth != -1 else 0
if depth == len(intersects) - 1:
last_path = ps[-1].center - c
min_path_length = min(min_path_length, current_path_length + last_path.length())
continue
l_limit_min, r_limit_min = [a - c for a in intersects[depth + 1]] # 左右の限界
l_limit, r_limit = l_limit_min, r_limit_min # 到達可能限界
l_limit_d, r_limit_d = depth + 1, depth + 1
for i in range(depth + 2, len(intersects)):
l_limit2, r_limit2 = [a - c for a in intersects[i]]
if l_limit_min.is_clock(l_limit2): # 限界更新
l_limit_min = l_limit2
if l_limit2.is_clock(r_limit_min): # 到達可能なら、こっちも更新
l_limit = l_limit2
l_limit_d = i
if r_limit2.is_clock(r_limit_min): # 限界更新
r_limit_min = r_limit2
if l_limit_min.is_clock(r_limit2): # 到達可能なら、こっちも更新
r_limit = r_limit2
r_limit_d = i
# if l_limit.is_clock(l_limit2) and l_limit2.is_clock(r_limit):
# l_limit = l_limit2
# l_limit_d = i
# if l_limit.is_clock(r_limit2) and r_limit2.is_clock(r_limit):
# r_limit = r_limit2
# r_limit_d = i
last_path = ps[-1].center - c
if l_limit.is_clock(last_path) and last_path.is_clock(r_limit): # この点からゴールまで行ける
min_path_length = min(min_path_length, current_path_length + last_path.length())
continue
if dists[l_limit_d][0] > l_limit.length() + current_path_length:
dists[l_limit_d][0] = l_limit.length() + current_path_length
res.append([l_limit + c, l_limit_d, 0])
if dists[r_limit_d][1] > r_limit.length() + current_path_length:
dists[r_limit_d][1] = r_limit.length() + current_path_length
res.append([r_limit + c, r_limit_d, 1])
return min_path_length
def main():
while True:
n = int(input())
if n == 0:
break
ps = [Circle(*[int(a) for a in input().split()]) for _ in range(n)]
print(solve(ps))
if __name__ == '__main__':
main()
``` | instruction | 0 | 37,701 | 3 | 75,402 |
No | output | 1 | 37,701 | 3 | 75,403 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a chain consisting of multiple circles on a plane. The first (last) circle of the chain only intersects with the next (previous) circle, and each intermediate circle intersects only with the two neighboring circles.
Your task is to find the shortest path that satisfies the following conditions.
* The path connects the centers of the first circle and the last circle.
* The path is confined in the chain, that is, all the points on the path are located within or on at least one of the circles.
Figure E-1 shows an example of such a chain and the corresponding shortest path.
<image>
Figure E-1: An example chain and the corresponding shortest path
Input
The input consists of multiple datasets. Each dataset represents the shape of a chain in the following format.
> n
> x1 y1 r1
> x2 y2 r2
> ...
> xn yn rn
>
The first line of a dataset contains an integer n (3 ≤ n ≤ 100) representing the number of the circles. Each of the following n lines contains three integers separated by a single space. (xi, yi) and ri represent the center position and the radius of the i-th circle Ci. You can assume that 0 ≤ xi ≤ 1000, 0 ≤ yi ≤ 1000, and 1 ≤ ri ≤ 25.
You can assume that Ci and Ci+1 (1 ≤ i ≤ n−1) intersect at two separate points. When j ≥ i+2, Ci and Cj are apart and either of them does not contain the other. In addition, you can assume that any circle does not contain the center of any other circle.
The end of the input is indicated by a line containing a zero.
Figure E-1 corresponds to the first dataset of Sample Input below. Figure E-2 shows the shortest paths for the subsequent datasets of Sample Input.
<image>
Figure E-2: Example chains and the corresponding shortest paths
Output
For each dataset, output a single line containing the length of the shortest chain-confined path between the centers of the first circle and the last circle. The value should not have an error greater than 0.001. No extra characters should appear in the output.
Sample Input
10
802 0 10
814 0 4
820 1 4
826 1 4
832 3 5
838 5 5
845 7 3
849 10 3
853 14 4
857 18 3
3
0 0 5
8 0 5
8 8 5
3
0 0 5
7 3 6
16 0 5
9
0 3 5
8 0 8
19 2 8
23 14 6
23 21 6
23 28 6
19 40 8
8 42 8
0 39 5
11
0 0 5
8 0 5
18 8 10
8 16 5
0 16 5
0 24 5
3 32 5
10 32 5
17 28 8
27 25 3
30 18 5
0
Output for the Sample Input
58.953437
11.414214
16.0
61.874812
63.195179
Example
Input
10
802 0 10
814 0 4
820 1 4
826 1 4
832 3 5
838 5 5
845 7 3
849 10 3
853 14 4
857 18 3
3
0 0 5
8 0 5
8 8 5
3
0 0 5
7 3 6
16 0 5
9
0 3 5
8 0 8
19 2 8
23 14 6
23 21 6
23 28 6
19 40 8
8 42 8
0 39 5
11
0 0 5
8 0 5
18 8 10
8 16 5
0 16 5
0 24 5
3 32 5
10 32 5
17 28 8
27 25 3
30 18 5
0
Output
58.953437
11.414214
16.0
61.874812
63.195179
Submitted Solution:
```
def solve():
from math import acos
from cmath import phase, rect, pi
from sys import stdin
file_input = stdin
while True:
n = int(file_input.readline())
if n == 0:
break
C = (map(int, file_input.readline().split()) for i in range(n))
P = []
x, y, r1 = next(C)
c1 = x + y * 1j
P.append(c1)
# calculation of cross points of circles
for x, y, r2 in C:
c2 = x + y * 1j
base = c2 - c1
d = abs(base)
a = acos((r1 ** 2 + d ** 2 - r2 ** 2) / (2 * r1 * d))
t = phase(base)
cp1 = c1 + rect(r1, t + a)
cp2 = c1 + rect(r1, t - a)
P.append(cp1)
P.append(cp2)
c1, r1 = c2, r2
# search path and calculation of its cost
lim = 5000
dist = [lim] * (2 * n)
dist[0] = 0
goal = c1
g_idx = 2 * n - 1
indices = ((i + (i % 2) + 1, i + (i % 2) + 2) for i in range(g_idx))
for tpl_idx, cp, d in zip(indices, P, dist):
j, k = tpl_idx
if j != g_idx:
s1 = P[j] - cp
s2 = P[k] - cp
else:
s1 = goal - cp
s2 = goal - cp
p_s1 = None
p_s2 = None
for l, cp1, cp2 in zip(range(j, g_idx, 2), P[j::2], P[k::2]):
t_s1 = cp1 - cp
t_s2 = cp2 - cp
if phase(s1 / t_s1) >= 0:
s1 = t_s1
if phase(s2 / t_s2) <= 0:
s2 = t_s2
if phase(s1 / s2) < 0:
break
if p_s1 != s1:
dist[l] = min(dist[l], d + abs(s1))
p_s1 = s1
if p_s2 != s2:
dist[l+1] = min(dist[l+1], d + abs(s2))
p_s2 = s2
else:
gs = goal - cp
if phase(s1 / gs) >= 0 and phase(s2 / gs) <= 0:
dist[g_idx] = min(dist[g_idx], d + abs(gs))
print(dist[g_idx])
solve()
``` | instruction | 0 | 37,702 | 3 | 75,404 |
No | output | 1 | 37,702 | 3 | 75,405 |
Provide tags and a correct Python 3 solution for this coding contest problem.
[THE SxPLAY & KIVΛ - 漂流](https://soundcloud.com/kivawu/hyouryu)
[KIVΛ & Nikki Simmons - Perspectives](https://soundcloud.com/kivawu/perspectives)
With a new body, our idol Aroma White (or should we call her Kaori Minamiya?) begins to uncover her lost past through the OS space.
The space can be considered a 2D plane, with an infinite number of data nodes, indexed from 0, with their coordinates defined as follows:
* The coordinates of the 0-th node is (x_0, y_0)
* For i > 0, the coordinates of i-th node is (a_x ⋅ x_{i-1} + b_x, a_y ⋅ y_{i-1} + b_y)
Initially Aroma stands at the point (x_s, y_s). She can stay in OS space for at most t seconds, because after this time she has to warp back to the real world. She doesn't need to return to the entry point (x_s, y_s) to warp home.
While within the OS space, Aroma can do the following actions:
* From the point (x, y), Aroma can move to one of the following points: (x-1, y), (x+1, y), (x, y-1) or (x, y+1). This action requires 1 second.
* If there is a data node at where Aroma is staying, she can collect it. We can assume this action costs 0 seconds. Of course, each data node can be collected at most once.
Aroma wants to collect as many data as possible before warping back. Can you help her in calculating the maximum number of data nodes she could collect within t seconds?
Input
The first line contains integers x_0, y_0, a_x, a_y, b_x, b_y (1 ≤ x_0, y_0 ≤ 10^{16}, 2 ≤ a_x, a_y ≤ 100, 0 ≤ b_x, b_y ≤ 10^{16}), which define the coordinates of the data nodes.
The second line contains integers x_s, y_s, t (1 ≤ x_s, y_s, t ≤ 10^{16}) – the initial Aroma's coordinates and the amount of time available.
Output
Print a single integer — the maximum number of data nodes Aroma can collect within t seconds.
Examples
Input
1 1 2 3 1 0
2 4 20
Output
3
Input
1 1 2 3 1 0
15 27 26
Output
2
Input
1 1 2 3 1 0
2 2 1
Output
0
Note
In all three examples, the coordinates of the first 5 data nodes are (1, 1), (3, 3), (7, 9), (15, 27) and (31, 81) (remember that nodes are numbered from 0).
In the first example, the optimal route to collect 3 nodes is as follows:
* Go to the coordinates (3, 3) and collect the 1-st node. This takes |3 - 2| + |3 - 4| = 2 seconds.
* Go to the coordinates (1, 1) and collect the 0-th node. This takes |1 - 3| + |1 - 3| = 4 seconds.
* Go to the coordinates (7, 9) and collect the 2-nd node. This takes |7 - 1| + |9 - 1| = 14 seconds.
In the second example, the optimal route to collect 2 nodes is as follows:
* Collect the 3-rd node. This requires no seconds.
* Go to the coordinates (7, 9) and collect the 2-th node. This takes |15 - 7| + |27 - 9| = 26 seconds.
In the third example, Aroma can't collect any nodes. She should have taken proper rest instead of rushing into the OS space like that. | instruction | 0 | 37,823 | 3 | 75,646 |
Tags: brute force, constructive algorithms, geometry, greedy, implementation
Correct Solution:
```
x0, y0, ax, ay, bx, by = map(int, input().split())
sx, sy, t = map(int, input().split())
x = []
y = []
x.append(x0)
y.append(y0)
for i in range(147):
x.append(x[-1] * ax + bx)
y.append(y[-1] * ay + by)
ans = 0
for i in range(len(x)):
for zliva in range(0, i + 1):
for sprava in range(i, len(x)):
c = abs(sx - x[i]) + abs(sy - y[i])
if c <= t:
ans = max(ans, 1)
d = abs(x[i] - x[zliva]) + abs(y[i] - y[zliva])
if c + d <= t:
ans = max(ans, i - zliva + 1)
e = abs(x[zliva] - x[sprava]) + abs(y[zliva] - y[sprava])
if c + d + e <= t:
ans = max(ans, sprava - zliva + 1)
d = abs(x[i] - x[sprava]) + abs(y[i] - y[sprava])
if c + d <= t:
ans = max(ans, sprava - i + 1)
e = abs(x[zliva] - x[sprava]) + abs(y[zliva] - y[sprava])
if c + d + e <= t:
ans = max(ans, sprava - zliva + 1)
print(ans)
``` | output | 1 | 37,823 | 3 | 75,647 |
Provide tags and a correct Python 3 solution for this coding contest problem.
[THE SxPLAY & KIVΛ - 漂流](https://soundcloud.com/kivawu/hyouryu)
[KIVΛ & Nikki Simmons - Perspectives](https://soundcloud.com/kivawu/perspectives)
With a new body, our idol Aroma White (or should we call her Kaori Minamiya?) begins to uncover her lost past through the OS space.
The space can be considered a 2D plane, with an infinite number of data nodes, indexed from 0, with their coordinates defined as follows:
* The coordinates of the 0-th node is (x_0, y_0)
* For i > 0, the coordinates of i-th node is (a_x ⋅ x_{i-1} + b_x, a_y ⋅ y_{i-1} + b_y)
Initially Aroma stands at the point (x_s, y_s). She can stay in OS space for at most t seconds, because after this time she has to warp back to the real world. She doesn't need to return to the entry point (x_s, y_s) to warp home.
While within the OS space, Aroma can do the following actions:
* From the point (x, y), Aroma can move to one of the following points: (x-1, y), (x+1, y), (x, y-1) or (x, y+1). This action requires 1 second.
* If there is a data node at where Aroma is staying, she can collect it. We can assume this action costs 0 seconds. Of course, each data node can be collected at most once.
Aroma wants to collect as many data as possible before warping back. Can you help her in calculating the maximum number of data nodes she could collect within t seconds?
Input
The first line contains integers x_0, y_0, a_x, a_y, b_x, b_y (1 ≤ x_0, y_0 ≤ 10^{16}, 2 ≤ a_x, a_y ≤ 100, 0 ≤ b_x, b_y ≤ 10^{16}), which define the coordinates of the data nodes.
The second line contains integers x_s, y_s, t (1 ≤ x_s, y_s, t ≤ 10^{16}) – the initial Aroma's coordinates and the amount of time available.
Output
Print a single integer — the maximum number of data nodes Aroma can collect within t seconds.
Examples
Input
1 1 2 3 1 0
2 4 20
Output
3
Input
1 1 2 3 1 0
15 27 26
Output
2
Input
1 1 2 3 1 0
2 2 1
Output
0
Note
In all three examples, the coordinates of the first 5 data nodes are (1, 1), (3, 3), (7, 9), (15, 27) and (31, 81) (remember that nodes are numbered from 0).
In the first example, the optimal route to collect 3 nodes is as follows:
* Go to the coordinates (3, 3) and collect the 1-st node. This takes |3 - 2| + |3 - 4| = 2 seconds.
* Go to the coordinates (1, 1) and collect the 0-th node. This takes |1 - 3| + |1 - 3| = 4 seconds.
* Go to the coordinates (7, 9) and collect the 2-nd node. This takes |7 - 1| + |9 - 1| = 14 seconds.
In the second example, the optimal route to collect 2 nodes is as follows:
* Collect the 3-rd node. This requires no seconds.
* Go to the coordinates (7, 9) and collect the 2-th node. This takes |15 - 7| + |27 - 9| = 26 seconds.
In the third example, Aroma can't collect any nodes. She should have taken proper rest instead of rushing into the OS space like that. | instruction | 0 | 37,824 | 3 | 75,648 |
Tags: brute force, constructive algorithms, geometry, greedy, implementation
Correct Solution:
```
xo,yo,ax,ay,bx,by=map(int,input().split())
orx,ory=xo,yo
xs,ys,t=map(int,input().split())
cur=abs(xo-xs)+abs(yo-ys)
sort=[cur]
while True:
x,y=xo,yo
xo,yo=ax*xo+bx,ay*yo+by
cur=abs(xo-xs)+abs(yo-ys)
if cur>sort[-1]:
break
else:
sort.append(cur)
dpoint=0
copyx,copyy=x,y
mina=abs(x-xs)+abs(y-ys)
if mina<=t:
dpoint+=1
time=0
copy=time
while time<t and (x,y)!=(orx,ory):
a,b=x,y
x,y=(x-bx)//ax,(y-by)//ay
time+=abs(x-a)+abs(y-b)
if (time+min(mina,abs(x-xs)+abs(y-ys)))<=t:
dpoint+=1
if time+min(mina,(abs(x-xs)+abs(y-ys)))<t:
mina=abs(x-xs)+abs(y-ys)
while time<t:
a,b=ax*copyx+bx,ay*copyy+by
time+=abs(a-copyx)+abs(b-copyy)
copyx,copyy=a,b
x,y=a,b
if (time+min(mina,(abs(a-xs)+(b-ys))))<=t:
dpoint+=1
print(dpoint)
``` | output | 1 | 37,824 | 3 | 75,649 |
Provide tags and a correct Python 3 solution for this coding contest problem.
[THE SxPLAY & KIVΛ - 漂流](https://soundcloud.com/kivawu/hyouryu)
[KIVΛ & Nikki Simmons - Perspectives](https://soundcloud.com/kivawu/perspectives)
With a new body, our idol Aroma White (or should we call her Kaori Minamiya?) begins to uncover her lost past through the OS space.
The space can be considered a 2D plane, with an infinite number of data nodes, indexed from 0, with their coordinates defined as follows:
* The coordinates of the 0-th node is (x_0, y_0)
* For i > 0, the coordinates of i-th node is (a_x ⋅ x_{i-1} + b_x, a_y ⋅ y_{i-1} + b_y)
Initially Aroma stands at the point (x_s, y_s). She can stay in OS space for at most t seconds, because after this time she has to warp back to the real world. She doesn't need to return to the entry point (x_s, y_s) to warp home.
While within the OS space, Aroma can do the following actions:
* From the point (x, y), Aroma can move to one of the following points: (x-1, y), (x+1, y), (x, y-1) or (x, y+1). This action requires 1 second.
* If there is a data node at where Aroma is staying, she can collect it. We can assume this action costs 0 seconds. Of course, each data node can be collected at most once.
Aroma wants to collect as many data as possible before warping back. Can you help her in calculating the maximum number of data nodes she could collect within t seconds?
Input
The first line contains integers x_0, y_0, a_x, a_y, b_x, b_y (1 ≤ x_0, y_0 ≤ 10^{16}, 2 ≤ a_x, a_y ≤ 100, 0 ≤ b_x, b_y ≤ 10^{16}), which define the coordinates of the data nodes.
The second line contains integers x_s, y_s, t (1 ≤ x_s, y_s, t ≤ 10^{16}) – the initial Aroma's coordinates and the amount of time available.
Output
Print a single integer — the maximum number of data nodes Aroma can collect within t seconds.
Examples
Input
1 1 2 3 1 0
2 4 20
Output
3
Input
1 1 2 3 1 0
15 27 26
Output
2
Input
1 1 2 3 1 0
2 2 1
Output
0
Note
In all three examples, the coordinates of the first 5 data nodes are (1, 1), (3, 3), (7, 9), (15, 27) and (31, 81) (remember that nodes are numbered from 0).
In the first example, the optimal route to collect 3 nodes is as follows:
* Go to the coordinates (3, 3) and collect the 1-st node. This takes |3 - 2| + |3 - 4| = 2 seconds.
* Go to the coordinates (1, 1) and collect the 0-th node. This takes |1 - 3| + |1 - 3| = 4 seconds.
* Go to the coordinates (7, 9) and collect the 2-nd node. This takes |7 - 1| + |9 - 1| = 14 seconds.
In the second example, the optimal route to collect 2 nodes is as follows:
* Collect the 3-rd node. This requires no seconds.
* Go to the coordinates (7, 9) and collect the 2-th node. This takes |15 - 7| + |27 - 9| = 26 seconds.
In the third example, Aroma can't collect any nodes. She should have taken proper rest instead of rushing into the OS space like that. | instruction | 0 | 37,825 | 3 | 75,650 |
Tags: brute force, constructive algorithms, geometry, greedy, implementation
Correct Solution:
```
x0, y0, ax, ay, bx, by = map(int, input().split())
xs, ys, t = map(int, input().split())
ans = [(x0, y0)]
for i in range(100):
tmpx, tmpy = ans[-1]
ans.append((ax * tmpx + bx, ay * tmpy + by))
res = 0
for i in range(100):
posx, posy = xs, ys
next_i = i
time = 0
cnt = 0
while True:
if not (0 <= next_i < 100):
break
nextx, nexty = ans[next_i]
time += abs(nextx - posx) + abs(nexty - posy)
if time > t:
break
cnt += 1
next_i += 1
posy = nexty
posx = nextx
res = max(res, cnt)
for i in range(100):
posx, posy = xs, ys
next_i = i
time = 0
cnt = 0
while True:
if not (0 <= next_i < 100):
break
nextx, nexty = ans[next_i]
time += abs(nextx - posx) + abs(nexty - posy)
if time > t:
break
cnt += 1
next_i -= 1
posy = nexty
posx = nextx
res = max(res, cnt)
print(res)
``` | output | 1 | 37,825 | 3 | 75,651 |
Provide tags and a correct Python 3 solution for this coding contest problem.
[THE SxPLAY & KIVΛ - 漂流](https://soundcloud.com/kivawu/hyouryu)
[KIVΛ & Nikki Simmons - Perspectives](https://soundcloud.com/kivawu/perspectives)
With a new body, our idol Aroma White (or should we call her Kaori Minamiya?) begins to uncover her lost past through the OS space.
The space can be considered a 2D plane, with an infinite number of data nodes, indexed from 0, with their coordinates defined as follows:
* The coordinates of the 0-th node is (x_0, y_0)
* For i > 0, the coordinates of i-th node is (a_x ⋅ x_{i-1} + b_x, a_y ⋅ y_{i-1} + b_y)
Initially Aroma stands at the point (x_s, y_s). She can stay in OS space for at most t seconds, because after this time she has to warp back to the real world. She doesn't need to return to the entry point (x_s, y_s) to warp home.
While within the OS space, Aroma can do the following actions:
* From the point (x, y), Aroma can move to one of the following points: (x-1, y), (x+1, y), (x, y-1) or (x, y+1). This action requires 1 second.
* If there is a data node at where Aroma is staying, she can collect it. We can assume this action costs 0 seconds. Of course, each data node can be collected at most once.
Aroma wants to collect as many data as possible before warping back. Can you help her in calculating the maximum number of data nodes she could collect within t seconds?
Input
The first line contains integers x_0, y_0, a_x, a_y, b_x, b_y (1 ≤ x_0, y_0 ≤ 10^{16}, 2 ≤ a_x, a_y ≤ 100, 0 ≤ b_x, b_y ≤ 10^{16}), which define the coordinates of the data nodes.
The second line contains integers x_s, y_s, t (1 ≤ x_s, y_s, t ≤ 10^{16}) – the initial Aroma's coordinates and the amount of time available.
Output
Print a single integer — the maximum number of data nodes Aroma can collect within t seconds.
Examples
Input
1 1 2 3 1 0
2 4 20
Output
3
Input
1 1 2 3 1 0
15 27 26
Output
2
Input
1 1 2 3 1 0
2 2 1
Output
0
Note
In all three examples, the coordinates of the first 5 data nodes are (1, 1), (3, 3), (7, 9), (15, 27) and (31, 81) (remember that nodes are numbered from 0).
In the first example, the optimal route to collect 3 nodes is as follows:
* Go to the coordinates (3, 3) and collect the 1-st node. This takes |3 - 2| + |3 - 4| = 2 seconds.
* Go to the coordinates (1, 1) and collect the 0-th node. This takes |1 - 3| + |1 - 3| = 4 seconds.
* Go to the coordinates (7, 9) and collect the 2-nd node. This takes |7 - 1| + |9 - 1| = 14 seconds.
In the second example, the optimal route to collect 2 nodes is as follows:
* Collect the 3-rd node. This requires no seconds.
* Go to the coordinates (7, 9) and collect the 2-th node. This takes |15 - 7| + |27 - 9| = 26 seconds.
In the third example, Aroma can't collect any nodes. She should have taken proper rest instead of rushing into the OS space like that. | instruction | 0 | 37,826 | 3 | 75,652 |
Tags: brute force, constructive algorithms, geometry, greedy, implementation
Correct Solution:
```
def dist(x,y):
return abs(x[0]-y[0])+abs(x[1]-y[1])
x,y,ax,ay,bx,by = list(map(int,input().split()))
xs,ys,coins = list(map(int,input().split()))
arr = [(x,y)]
for i in range(60):
x = ax*x+bx
y = ay*y+by
arr.append((x,y))
cur = (xs,ys)
ans = 0
for i in range(60):
for j in range(60):
# current node to ith node (1 imp node) and then ith node to jth node (abs(j-i)+1 imp nodes )
t = dist(cur,arr[i])+dist(arr[i],arr[j])
if t<=coins:
ans = max(ans,abs(i-j)+1)
print(ans)
``` | output | 1 | 37,826 | 3 | 75,653 |
Provide tags and a correct Python 3 solution for this coding contest problem.
[THE SxPLAY & KIVΛ - 漂流](https://soundcloud.com/kivawu/hyouryu)
[KIVΛ & Nikki Simmons - Perspectives](https://soundcloud.com/kivawu/perspectives)
With a new body, our idol Aroma White (or should we call her Kaori Minamiya?) begins to uncover her lost past through the OS space.
The space can be considered a 2D plane, with an infinite number of data nodes, indexed from 0, with their coordinates defined as follows:
* The coordinates of the 0-th node is (x_0, y_0)
* For i > 0, the coordinates of i-th node is (a_x ⋅ x_{i-1} + b_x, a_y ⋅ y_{i-1} + b_y)
Initially Aroma stands at the point (x_s, y_s). She can stay in OS space for at most t seconds, because after this time she has to warp back to the real world. She doesn't need to return to the entry point (x_s, y_s) to warp home.
While within the OS space, Aroma can do the following actions:
* From the point (x, y), Aroma can move to one of the following points: (x-1, y), (x+1, y), (x, y-1) or (x, y+1). This action requires 1 second.
* If there is a data node at where Aroma is staying, she can collect it. We can assume this action costs 0 seconds. Of course, each data node can be collected at most once.
Aroma wants to collect as many data as possible before warping back. Can you help her in calculating the maximum number of data nodes she could collect within t seconds?
Input
The first line contains integers x_0, y_0, a_x, a_y, b_x, b_y (1 ≤ x_0, y_0 ≤ 10^{16}, 2 ≤ a_x, a_y ≤ 100, 0 ≤ b_x, b_y ≤ 10^{16}), which define the coordinates of the data nodes.
The second line contains integers x_s, y_s, t (1 ≤ x_s, y_s, t ≤ 10^{16}) – the initial Aroma's coordinates and the amount of time available.
Output
Print a single integer — the maximum number of data nodes Aroma can collect within t seconds.
Examples
Input
1 1 2 3 1 0
2 4 20
Output
3
Input
1 1 2 3 1 0
15 27 26
Output
2
Input
1 1 2 3 1 0
2 2 1
Output
0
Note
In all three examples, the coordinates of the first 5 data nodes are (1, 1), (3, 3), (7, 9), (15, 27) and (31, 81) (remember that nodes are numbered from 0).
In the first example, the optimal route to collect 3 nodes is as follows:
* Go to the coordinates (3, 3) and collect the 1-st node. This takes |3 - 2| + |3 - 4| = 2 seconds.
* Go to the coordinates (1, 1) and collect the 0-th node. This takes |1 - 3| + |1 - 3| = 4 seconds.
* Go to the coordinates (7, 9) and collect the 2-nd node. This takes |7 - 1| + |9 - 1| = 14 seconds.
In the second example, the optimal route to collect 2 nodes is as follows:
* Collect the 3-rd node. This requires no seconds.
* Go to the coordinates (7, 9) and collect the 2-th node. This takes |15 - 7| + |27 - 9| = 26 seconds.
In the third example, Aroma can't collect any nodes. She should have taken proper rest instead of rushing into the OS space like that. | instruction | 0 | 37,827 | 3 | 75,654 |
Tags: brute force, constructive algorithms, geometry, greedy, implementation
Correct Solution:
```
import sys
# sys.setrecursionlimit(10**6)
from sys import stdin, stdout
import bisect #c++ upperbound
import math
import heapq
def modinv(n,p):
return pow(n,p-2,p)
def cin():
return map(int,sin().split())
def ain(): #takes array as input
return list(map(int,sin().split()))
def sin():
return input()
def inin():
return int(input())
import math
def Divisors(n) :
l = []
for i in range(1, int(math.sqrt(n) + 1)) :
if (n % i == 0) :
if (n // i == i) :
l.append(i)
else :
l.append(i)
l.append(n//i)
return l
"""*******************************************************"""
def main():
x,y,ax,ay,bx,by=cin()
s=[(x,y)]
for i in range(100):
if(math.log10(ax)+math.log10(x)>18 or math.log10(ay)+math.log10(y)>18):
break
xx=ax*x+bx
yy=ay*y+by
x=xx
y=yy
s.append((x,y))
x,y,t=cin()
n=len(s)
p=0
if (x,y) in s:
p=1
s.remove((x,y))
# print(s)
n=len(s)
an=p
for i in range(n):
f=0
ans=p
xx=x
yy=y
for j in range(i,n):
f+=abs(s[j][0]-xx)+abs(s[j][1]-yy)
xx=s[j][0]
yy=s[j][1]
if(f>t):
break
ans+=1
an=max(an,ans)
# print(ans)
s=s[::-1]
for i in range(n):
f=0
ans=p
xx=x
yy=y
for j in range(i,n):
f+=abs(s[j][0]-xx)+abs(s[j][1]-yy)
xx=s[j][0]
yy=s[j][1]
if(f>t):
break
ans+=1
an=max(an,ans)
print(an)
######## Python 2 and 3 footer by Pajenegod and c1729
# Note because cf runs old PyPy3 version which doesn't have the sped up
# unicode strings, PyPy3 strings will many times be slower than pypy2.
# There is a way to get around this by using binary strings in PyPy3
# but its syntax is different which makes it kind of a mess to use.
# So on cf, use PyPy2 for best string performance.
py2 = round(0.5)
if py2:
from future_builtins import ascii, filter, hex, map, oct, zip
range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192
class FastIO(BytesIO):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.writable = "x" in file.mode or "w" in file.mode
self.write = super(FastIO, self).write if self.writable else None
def _fill(self):
s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
return s
def read(self):
while self._fill(): pass
return super(FastIO,self).read()
def readline(self):
while self.newlines == 0:
s = self._fill(); self.newlines = s.count(b"\n") + (not s)
self.newlines -= 1
return super(FastIO, self).readline()
def flush(self):
if self.writable:
os.write(self._fd, self.getvalue())
self.truncate(0), self.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
if py2:
self.write = self.buffer.write
self.read = self.buffer.read
self.readline = self.buffer.readline
else:
self.write = lambda s:self.buffer.write(s.encode('ascii'))
self.read = lambda:self.buffer.read().decode('ascii')
self.readline = lambda:self.buffer.readline().decode('ascii')
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')
# Cout implemented in Python
import sys
class ostream:
def __lshift__(self,a):
sys.stdout.write(str(a))
return self
cout = ostream()
endl = '\n'
# Read all remaining integers in stdin, type is given by optional argument, this is fast
def readnumbers(zero = 0):
conv = ord if py2 else lambda x:x
A = []; numb = zero; sign = 1; i = 0; s = sys.stdin.buffer.read()
try:
while True:
if s[i] >= b'0' [0]:
numb = 10 * numb + conv(s[i]) - 48
elif s[i] == b'-' [0]: sign = -1
elif s[i] != b'\r' [0]:
A.append(sign*numb)
numb = zero; sign = 1
i += 1
except:pass
if s and s[-1] >= b'0' [0]:
A.append(sign*numb)
return A
if __name__== "__main__":
main()
``` | output | 1 | 37,827 | 3 | 75,655 |
Provide tags and a correct Python 3 solution for this coding contest problem.
[THE SxPLAY & KIVΛ - 漂流](https://soundcloud.com/kivawu/hyouryu)
[KIVΛ & Nikki Simmons - Perspectives](https://soundcloud.com/kivawu/perspectives)
With a new body, our idol Aroma White (or should we call her Kaori Minamiya?) begins to uncover her lost past through the OS space.
The space can be considered a 2D plane, with an infinite number of data nodes, indexed from 0, with their coordinates defined as follows:
* The coordinates of the 0-th node is (x_0, y_0)
* For i > 0, the coordinates of i-th node is (a_x ⋅ x_{i-1} + b_x, a_y ⋅ y_{i-1} + b_y)
Initially Aroma stands at the point (x_s, y_s). She can stay in OS space for at most t seconds, because after this time she has to warp back to the real world. She doesn't need to return to the entry point (x_s, y_s) to warp home.
While within the OS space, Aroma can do the following actions:
* From the point (x, y), Aroma can move to one of the following points: (x-1, y), (x+1, y), (x, y-1) or (x, y+1). This action requires 1 second.
* If there is a data node at where Aroma is staying, she can collect it. We can assume this action costs 0 seconds. Of course, each data node can be collected at most once.
Aroma wants to collect as many data as possible before warping back. Can you help her in calculating the maximum number of data nodes she could collect within t seconds?
Input
The first line contains integers x_0, y_0, a_x, a_y, b_x, b_y (1 ≤ x_0, y_0 ≤ 10^{16}, 2 ≤ a_x, a_y ≤ 100, 0 ≤ b_x, b_y ≤ 10^{16}), which define the coordinates of the data nodes.
The second line contains integers x_s, y_s, t (1 ≤ x_s, y_s, t ≤ 10^{16}) – the initial Aroma's coordinates and the amount of time available.
Output
Print a single integer — the maximum number of data nodes Aroma can collect within t seconds.
Examples
Input
1 1 2 3 1 0
2 4 20
Output
3
Input
1 1 2 3 1 0
15 27 26
Output
2
Input
1 1 2 3 1 0
2 2 1
Output
0
Note
In all three examples, the coordinates of the first 5 data nodes are (1, 1), (3, 3), (7, 9), (15, 27) and (31, 81) (remember that nodes are numbered from 0).
In the first example, the optimal route to collect 3 nodes is as follows:
* Go to the coordinates (3, 3) and collect the 1-st node. This takes |3 - 2| + |3 - 4| = 2 seconds.
* Go to the coordinates (1, 1) and collect the 0-th node. This takes |1 - 3| + |1 - 3| = 4 seconds.
* Go to the coordinates (7, 9) and collect the 2-nd node. This takes |7 - 1| + |9 - 1| = 14 seconds.
In the second example, the optimal route to collect 2 nodes is as follows:
* Collect the 3-rd node. This requires no seconds.
* Go to the coordinates (7, 9) and collect the 2-th node. This takes |15 - 7| + |27 - 9| = 26 seconds.
In the third example, Aroma can't collect any nodes. She should have taken proper rest instead of rushing into the OS space like that. | instruction | 0 | 37,828 | 3 | 75,656 |
Tags: brute force, constructive algorithms, geometry, greedy, implementation
Correct Solution:
```
from sys import stdin, stdout
import sys
#brutal search
if __name__ == '__main__':
fa = list(map(int, stdin.readline().split()))
x0 = fa[0]
y0 = fa[1]
ax = fa[2]
ay = fa[3]
bx = fa[4]
by = fa[5]
sa = list(map(int, stdin.readline().split()))
xs = sa[0]
ys = sa[1]
t = sa[2]
dis = []
cx = x0
cy = y0
px = x0
py = y0
disSum = 0
for i in range(60):
disSum += abs(cx-px) + abs(cy-py)
la = [cx, cy, disSum]
dis.append(la)
nx = ax * cx + bx
ny = ay * cy + by
px = cx
py = cy
cx = nx
cy = ny
res = 0
#brutal
#print(dis)
for i in range(60):
for j in range(i, 60):
for k in range(i, j+1):
#op1 2*(i,k) + k,j
#print(i)
#print(j)
#print(k)
op1 = 2*(dis[k][2] - dis[i][2]) + (dis[j][2] - dis[k][2])
#op2 i,k + 2*(k,j)
op2 = (dis[k][2] - dis[i][2]) + 2*(dis[j][2] - dis[k][2])
ttldis = abs(xs-dis[k][0]) + abs(ys-dis[k][1]) + min(op1, op2)
if t >= ttldis:
res = max(res, j-i+1)
print(str(res))
``` | output | 1 | 37,828 | 3 | 75,657 |
Provide tags and a correct Python 3 solution for this coding contest problem.
[THE SxPLAY & KIVΛ - 漂流](https://soundcloud.com/kivawu/hyouryu)
[KIVΛ & Nikki Simmons - Perspectives](https://soundcloud.com/kivawu/perspectives)
With a new body, our idol Aroma White (or should we call her Kaori Minamiya?) begins to uncover her lost past through the OS space.
The space can be considered a 2D plane, with an infinite number of data nodes, indexed from 0, with their coordinates defined as follows:
* The coordinates of the 0-th node is (x_0, y_0)
* For i > 0, the coordinates of i-th node is (a_x ⋅ x_{i-1} + b_x, a_y ⋅ y_{i-1} + b_y)
Initially Aroma stands at the point (x_s, y_s). She can stay in OS space for at most t seconds, because after this time she has to warp back to the real world. She doesn't need to return to the entry point (x_s, y_s) to warp home.
While within the OS space, Aroma can do the following actions:
* From the point (x, y), Aroma can move to one of the following points: (x-1, y), (x+1, y), (x, y-1) or (x, y+1). This action requires 1 second.
* If there is a data node at where Aroma is staying, she can collect it. We can assume this action costs 0 seconds. Of course, each data node can be collected at most once.
Aroma wants to collect as many data as possible before warping back. Can you help her in calculating the maximum number of data nodes she could collect within t seconds?
Input
The first line contains integers x_0, y_0, a_x, a_y, b_x, b_y (1 ≤ x_0, y_0 ≤ 10^{16}, 2 ≤ a_x, a_y ≤ 100, 0 ≤ b_x, b_y ≤ 10^{16}), which define the coordinates of the data nodes.
The second line contains integers x_s, y_s, t (1 ≤ x_s, y_s, t ≤ 10^{16}) – the initial Aroma's coordinates and the amount of time available.
Output
Print a single integer — the maximum number of data nodes Aroma can collect within t seconds.
Examples
Input
1 1 2 3 1 0
2 4 20
Output
3
Input
1 1 2 3 1 0
15 27 26
Output
2
Input
1 1 2 3 1 0
2 2 1
Output
0
Note
In all three examples, the coordinates of the first 5 data nodes are (1, 1), (3, 3), (7, 9), (15, 27) and (31, 81) (remember that nodes are numbered from 0).
In the first example, the optimal route to collect 3 nodes is as follows:
* Go to the coordinates (3, 3) and collect the 1-st node. This takes |3 - 2| + |3 - 4| = 2 seconds.
* Go to the coordinates (1, 1) and collect the 0-th node. This takes |1 - 3| + |1 - 3| = 4 seconds.
* Go to the coordinates (7, 9) and collect the 2-nd node. This takes |7 - 1| + |9 - 1| = 14 seconds.
In the second example, the optimal route to collect 2 nodes is as follows:
* Collect the 3-rd node. This requires no seconds.
* Go to the coordinates (7, 9) and collect the 2-th node. This takes |15 - 7| + |27 - 9| = 26 seconds.
In the third example, Aroma can't collect any nodes. She should have taken proper rest instead of rushing into the OS space like that. | instruction | 0 | 37,829 | 3 | 75,658 |
Tags: brute force, constructive algorithms, geometry, greedy, implementation
Correct Solution:
```
dist = []
def get_dist(x1, y1, x2, y2):
return abs(x1-x2) + abs(y1-y2)
def bs(ind, t):
if t < 0:
return ind+1
if t == 0:
return ind
l = 0
r = ind+1
while r-l > 1:
o = (r+l)//2
if dist[ind]-dist[o] < t:
r = o
else:
l = o
if dist[ind]-dist[l] <= t:
return l
else:
return r
x0, y0, ax, ay, bx, by = map(int, input().split())
xs, ys, t = map(int, input().split())
x = ax*x0+bx
y = ay*y0+by
prevx = 0
prevy = 0
cords = [[x0, y0]]
while get_dist(x, y, xs, ys) > t:
prevx = x
prevy = y
x = ax*x+bx
y = ay*y+by
if x < prevx or y < prevy:
break
if get_dist(x, y, xs, ys) > get_dist(x0, y0, xs, ys):
break
if x > prevx and y > prevy:
prevx = x
prevy = y
while x >= prevx and y >= prevy and get_dist(x, y, xs, ys) <= t:
cords.append([x, y])
x = ax*x+bx
y = ay*y+by
dist = [0] * len(cords)
dist[0] = 0
for i in range(1, len(cords)):
dist[i] = dist[i-1] + get_dist(cords[i][0], cords[i][1], cords[i-1][0], cords[i-1][1])
ma = 0
tmp = get_dist(x0, y0, xs, ys)
for i in range(len(dist)):
if t - tmp - dist[i] >= 0:
ma = max(ma, i+1)
ma = max(ma, 1 + i - bs(i, t - get_dist(cords[i][0], cords[i][1], xs, ys)))
print(ma)
``` | output | 1 | 37,829 | 3 | 75,659 |
Provide tags and a correct Python 3 solution for this coding contest problem.
[THE SxPLAY & KIVΛ - 漂流](https://soundcloud.com/kivawu/hyouryu)
[KIVΛ & Nikki Simmons - Perspectives](https://soundcloud.com/kivawu/perspectives)
With a new body, our idol Aroma White (or should we call her Kaori Minamiya?) begins to uncover her lost past through the OS space.
The space can be considered a 2D plane, with an infinite number of data nodes, indexed from 0, with their coordinates defined as follows:
* The coordinates of the 0-th node is (x_0, y_0)
* For i > 0, the coordinates of i-th node is (a_x ⋅ x_{i-1} + b_x, a_y ⋅ y_{i-1} + b_y)
Initially Aroma stands at the point (x_s, y_s). She can stay in OS space for at most t seconds, because after this time she has to warp back to the real world. She doesn't need to return to the entry point (x_s, y_s) to warp home.
While within the OS space, Aroma can do the following actions:
* From the point (x, y), Aroma can move to one of the following points: (x-1, y), (x+1, y), (x, y-1) or (x, y+1). This action requires 1 second.
* If there is a data node at where Aroma is staying, she can collect it. We can assume this action costs 0 seconds. Of course, each data node can be collected at most once.
Aroma wants to collect as many data as possible before warping back. Can you help her in calculating the maximum number of data nodes she could collect within t seconds?
Input
The first line contains integers x_0, y_0, a_x, a_y, b_x, b_y (1 ≤ x_0, y_0 ≤ 10^{16}, 2 ≤ a_x, a_y ≤ 100, 0 ≤ b_x, b_y ≤ 10^{16}), which define the coordinates of the data nodes.
The second line contains integers x_s, y_s, t (1 ≤ x_s, y_s, t ≤ 10^{16}) – the initial Aroma's coordinates and the amount of time available.
Output
Print a single integer — the maximum number of data nodes Aroma can collect within t seconds.
Examples
Input
1 1 2 3 1 0
2 4 20
Output
3
Input
1 1 2 3 1 0
15 27 26
Output
2
Input
1 1 2 3 1 0
2 2 1
Output
0
Note
In all three examples, the coordinates of the first 5 data nodes are (1, 1), (3, 3), (7, 9), (15, 27) and (31, 81) (remember that nodes are numbered from 0).
In the first example, the optimal route to collect 3 nodes is as follows:
* Go to the coordinates (3, 3) and collect the 1-st node. This takes |3 - 2| + |3 - 4| = 2 seconds.
* Go to the coordinates (1, 1) and collect the 0-th node. This takes |1 - 3| + |1 - 3| = 4 seconds.
* Go to the coordinates (7, 9) and collect the 2-nd node. This takes |7 - 1| + |9 - 1| = 14 seconds.
In the second example, the optimal route to collect 2 nodes is as follows:
* Collect the 3-rd node. This requires no seconds.
* Go to the coordinates (7, 9) and collect the 2-th node. This takes |15 - 7| + |27 - 9| = 26 seconds.
In the third example, Aroma can't collect any nodes. She should have taken proper rest instead of rushing into the OS space like that. | instruction | 0 | 37,830 | 3 | 75,660 |
Tags: brute force, constructive algorithms, geometry, greedy, implementation
Correct Solution:
```
x0, y0, ax, ay, bx, by = map(int, input().split())
xs, ys, t = map(int, input().split())
LIM = 60
arr_xs = [x0]
for i in range(LIM * 2):
arr_xs.append(arr_xs[i] * ax + bx)
arr_ys = [y0]
for i in range(LIM * 2):
arr_ys.append(arr_ys[i] * ay + by)
# print(arr_xs[:5])
def dst(x1, y1, x2, y2):
return abs(x1 - x2) + abs(y1 - y2)
ans = 0
for start in range(len(arr_ys)):
cur_d = dst(arr_xs[start], arr_ys[start], xs, ys)
pt = start
if (cur_d > t): continue
cnt = 1
while(pt < len(arr_xs)):
cur_d += dst(arr_xs[pt], arr_ys[pt], arr_xs[pt + 1], arr_ys[pt + 1])
if (cur_d > t) : break
cnt += 1
pt += 1
ans = max(ans, cnt)
for start in range(len(arr_xs)):
cur_d = dst(arr_xs[start], arr_ys[start], xs, ys)
pt = start
if (cur_d > t): continue
cnt = 1
while(pt > 0):
cur_d += dst(arr_xs[pt], arr_ys[pt], arr_xs[pt - 1], arr_ys[pt - 1])
if (cur_d > t) : break
cnt += 1
pt -= 1
ans = max(ans, cnt)
print(ans)
``` | output | 1 | 37,830 | 3 | 75,661 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
[THE SxPLAY & KIVΛ - 漂流](https://soundcloud.com/kivawu/hyouryu)
[KIVΛ & Nikki Simmons - Perspectives](https://soundcloud.com/kivawu/perspectives)
With a new body, our idol Aroma White (or should we call her Kaori Minamiya?) begins to uncover her lost past through the OS space.
The space can be considered a 2D plane, with an infinite number of data nodes, indexed from 0, with their coordinates defined as follows:
* The coordinates of the 0-th node is (x_0, y_0)
* For i > 0, the coordinates of i-th node is (a_x ⋅ x_{i-1} + b_x, a_y ⋅ y_{i-1} + b_y)
Initially Aroma stands at the point (x_s, y_s). She can stay in OS space for at most t seconds, because after this time she has to warp back to the real world. She doesn't need to return to the entry point (x_s, y_s) to warp home.
While within the OS space, Aroma can do the following actions:
* From the point (x, y), Aroma can move to one of the following points: (x-1, y), (x+1, y), (x, y-1) or (x, y+1). This action requires 1 second.
* If there is a data node at where Aroma is staying, she can collect it. We can assume this action costs 0 seconds. Of course, each data node can be collected at most once.
Aroma wants to collect as many data as possible before warping back. Can you help her in calculating the maximum number of data nodes she could collect within t seconds?
Input
The first line contains integers x_0, y_0, a_x, a_y, b_x, b_y (1 ≤ x_0, y_0 ≤ 10^{16}, 2 ≤ a_x, a_y ≤ 100, 0 ≤ b_x, b_y ≤ 10^{16}), which define the coordinates of the data nodes.
The second line contains integers x_s, y_s, t (1 ≤ x_s, y_s, t ≤ 10^{16}) – the initial Aroma's coordinates and the amount of time available.
Output
Print a single integer — the maximum number of data nodes Aroma can collect within t seconds.
Examples
Input
1 1 2 3 1 0
2 4 20
Output
3
Input
1 1 2 3 1 0
15 27 26
Output
2
Input
1 1 2 3 1 0
2 2 1
Output
0
Note
In all three examples, the coordinates of the first 5 data nodes are (1, 1), (3, 3), (7, 9), (15, 27) and (31, 81) (remember that nodes are numbered from 0).
In the first example, the optimal route to collect 3 nodes is as follows:
* Go to the coordinates (3, 3) and collect the 1-st node. This takes |3 - 2| + |3 - 4| = 2 seconds.
* Go to the coordinates (1, 1) and collect the 0-th node. This takes |1 - 3| + |1 - 3| = 4 seconds.
* Go to the coordinates (7, 9) and collect the 2-nd node. This takes |7 - 1| + |9 - 1| = 14 seconds.
In the second example, the optimal route to collect 2 nodes is as follows:
* Collect the 3-rd node. This requires no seconds.
* Go to the coordinates (7, 9) and collect the 2-th node. This takes |15 - 7| + |27 - 9| = 26 seconds.
In the third example, Aroma can't collect any nodes. She should have taken proper rest instead of rushing into the OS space like that.
Submitted Solution:
```
from math import *
def d(x1, y1, x2, y2):
return abs(x1 - x2) + abs(y1 - y2)
x0, y0, ax, ay, bx, by = list(map(int, input().split()))
xs, ys, t = list(map(int, input().split()))
v = []
v.append([x0, y0])
for i in range(64):
x1, y1 = ax * x0 + bx, ay * y0 + by
v.append([x1, y1])
x0, y0 = x1, y1
n = len(v)
v.sort()
ans = 0
for i in range(n):
for j in range(i, n):
v1, v2 = 0, 0
px, py = xs, ys
for p in range(i, j + 1):
v2 += d(px, py, v[p][0], v[p][1])
px, py = v[p][0], v[p][1]
px, py = xs, ys
p = j
while p >= i:
v1 += d(px, py, v[p][0], v[p][1])
px, py = v[p][0], v[p][1]
p -= 1
if min(v1, v2) <= t:
ans = max(ans, j - i + 1)
print(ans)
``` | instruction | 0 | 37,831 | 3 | 75,662 |
Yes | output | 1 | 37,831 | 3 | 75,663 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
[THE SxPLAY & KIVΛ - 漂流](https://soundcloud.com/kivawu/hyouryu)
[KIVΛ & Nikki Simmons - Perspectives](https://soundcloud.com/kivawu/perspectives)
With a new body, our idol Aroma White (or should we call her Kaori Minamiya?) begins to uncover her lost past through the OS space.
The space can be considered a 2D plane, with an infinite number of data nodes, indexed from 0, with their coordinates defined as follows:
* The coordinates of the 0-th node is (x_0, y_0)
* For i > 0, the coordinates of i-th node is (a_x ⋅ x_{i-1} + b_x, a_y ⋅ y_{i-1} + b_y)
Initially Aroma stands at the point (x_s, y_s). She can stay in OS space for at most t seconds, because after this time she has to warp back to the real world. She doesn't need to return to the entry point (x_s, y_s) to warp home.
While within the OS space, Aroma can do the following actions:
* From the point (x, y), Aroma can move to one of the following points: (x-1, y), (x+1, y), (x, y-1) or (x, y+1). This action requires 1 second.
* If there is a data node at where Aroma is staying, she can collect it. We can assume this action costs 0 seconds. Of course, each data node can be collected at most once.
Aroma wants to collect as many data as possible before warping back. Can you help her in calculating the maximum number of data nodes she could collect within t seconds?
Input
The first line contains integers x_0, y_0, a_x, a_y, b_x, b_y (1 ≤ x_0, y_0 ≤ 10^{16}, 2 ≤ a_x, a_y ≤ 100, 0 ≤ b_x, b_y ≤ 10^{16}), which define the coordinates of the data nodes.
The second line contains integers x_s, y_s, t (1 ≤ x_s, y_s, t ≤ 10^{16}) – the initial Aroma's coordinates and the amount of time available.
Output
Print a single integer — the maximum number of data nodes Aroma can collect within t seconds.
Examples
Input
1 1 2 3 1 0
2 4 20
Output
3
Input
1 1 2 3 1 0
15 27 26
Output
2
Input
1 1 2 3 1 0
2 2 1
Output
0
Note
In all three examples, the coordinates of the first 5 data nodes are (1, 1), (3, 3), (7, 9), (15, 27) and (31, 81) (remember that nodes are numbered from 0).
In the first example, the optimal route to collect 3 nodes is as follows:
* Go to the coordinates (3, 3) and collect the 1-st node. This takes |3 - 2| + |3 - 4| = 2 seconds.
* Go to the coordinates (1, 1) and collect the 0-th node. This takes |1 - 3| + |1 - 3| = 4 seconds.
* Go to the coordinates (7, 9) and collect the 2-nd node. This takes |7 - 1| + |9 - 1| = 14 seconds.
In the second example, the optimal route to collect 2 nodes is as follows:
* Collect the 3-rd node. This requires no seconds.
* Go to the coordinates (7, 9) and collect the 2-th node. This takes |15 - 7| + |27 - 9| = 26 seconds.
In the third example, Aroma can't collect any nodes. She should have taken proper rest instead of rushing into the OS space like that.
Submitted Solution:
```
#!/usr/bin/env python3
# coding: utf-8
# Last Modified: 19/Jan/20 11:14:20 PM
import sys
def main():
x0, y0, ax, ay, bx, by = get_ints()
points = []
points.append((x0, y0))
xs, ys, t = get_ints()
# cin >> xs >> ys >> t;
x = x0
y = y0
def manhattan(x1, y1, x2, y2):
return abs(x1 - x2) + abs(y1 - y2)
for i in range(1, 100):
x = ax * x + bx
y = ay * y + by
points.append((x, y))
ans, curr = 0, 0
for i in range(len(points)):
T = t
XS = xs
YS = ys
curr = 0
f = 1
for j in range(i, len(points)):
x = points[j][0]
y = points[j][1]
dist = manhattan(XS, YS, x, y)
T -= dist
XS = x
YS = y
curr += 1
if T < 0:
ans = max(ans, curr - 1)
f = 0
break
if f:
ans = max(ans, curr)
points.reverse()
for i in range(len(points)):
T = t
XS = xs
YS = ys
curr = 0
f = 1
for j in range(i, len(points)):
x = points[j][0]
y = points[j][1]
dist = manhattan(XS, YS, x, y)
T -= dist
curr += 1
XS = x
YS = y
if T < 0:
ans = max(ans, curr - 1)
f = 0
break
if f:
ans = max(ans, curr)
print(ans)
get_array = lambda: list(map(int, sys.stdin.readline().split()))
get_ints = lambda: map(int, sys.stdin.readline().split())
input = lambda: sys.stdin.readline().strip()
if __name__ == "__main__":
main()
``` | instruction | 0 | 37,832 | 3 | 75,664 |
Yes | output | 1 | 37,832 | 3 | 75,665 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
[THE SxPLAY & KIVΛ - 漂流](https://soundcloud.com/kivawu/hyouryu)
[KIVΛ & Nikki Simmons - Perspectives](https://soundcloud.com/kivawu/perspectives)
With a new body, our idol Aroma White (or should we call her Kaori Minamiya?) begins to uncover her lost past through the OS space.
The space can be considered a 2D plane, with an infinite number of data nodes, indexed from 0, with their coordinates defined as follows:
* The coordinates of the 0-th node is (x_0, y_0)
* For i > 0, the coordinates of i-th node is (a_x ⋅ x_{i-1} + b_x, a_y ⋅ y_{i-1} + b_y)
Initially Aroma stands at the point (x_s, y_s). She can stay in OS space for at most t seconds, because after this time she has to warp back to the real world. She doesn't need to return to the entry point (x_s, y_s) to warp home.
While within the OS space, Aroma can do the following actions:
* From the point (x, y), Aroma can move to one of the following points: (x-1, y), (x+1, y), (x, y-1) or (x, y+1). This action requires 1 second.
* If there is a data node at where Aroma is staying, she can collect it. We can assume this action costs 0 seconds. Of course, each data node can be collected at most once.
Aroma wants to collect as many data as possible before warping back. Can you help her in calculating the maximum number of data nodes she could collect within t seconds?
Input
The first line contains integers x_0, y_0, a_x, a_y, b_x, b_y (1 ≤ x_0, y_0 ≤ 10^{16}, 2 ≤ a_x, a_y ≤ 100, 0 ≤ b_x, b_y ≤ 10^{16}), which define the coordinates of the data nodes.
The second line contains integers x_s, y_s, t (1 ≤ x_s, y_s, t ≤ 10^{16}) – the initial Aroma's coordinates and the amount of time available.
Output
Print a single integer — the maximum number of data nodes Aroma can collect within t seconds.
Examples
Input
1 1 2 3 1 0
2 4 20
Output
3
Input
1 1 2 3 1 0
15 27 26
Output
2
Input
1 1 2 3 1 0
2 2 1
Output
0
Note
In all three examples, the coordinates of the first 5 data nodes are (1, 1), (3, 3), (7, 9), (15, 27) and (31, 81) (remember that nodes are numbered from 0).
In the first example, the optimal route to collect 3 nodes is as follows:
* Go to the coordinates (3, 3) and collect the 1-st node. This takes |3 - 2| + |3 - 4| = 2 seconds.
* Go to the coordinates (1, 1) and collect the 0-th node. This takes |1 - 3| + |1 - 3| = 4 seconds.
* Go to the coordinates (7, 9) and collect the 2-nd node. This takes |7 - 1| + |9 - 1| = 14 seconds.
In the second example, the optimal route to collect 2 nodes is as follows:
* Collect the 3-rd node. This requires no seconds.
* Go to the coordinates (7, 9) and collect the 2-th node. This takes |15 - 7| + |27 - 9| = 26 seconds.
In the third example, Aroma can't collect any nodes. She should have taken proper rest instead of rushing into the OS space like that.
Submitted Solution:
```
x0, y0, ax, ay, bx, by = map(int, input().split())
xs, ys, t = map(int, input().split())
x = [x0]
y = [y0]
dx = [0]
dy = [0]
for i in range(59):
x.append(x[-1] * ax + bx)
y.append(y[-1] * ay + by)
n = len(x)
ans = 0
for i in range(n):
for j in range(i, n):
curt = min(abs(x[i] - xs) + abs(y[i] - ys), abs(x[j] - xs) + abs(y[j] - ys)) + (abs(x[i] - x[j]) + abs(y[i] - y[j]))
if curt <= t:
ans = max(ans, j - i + 1)
print(ans)
``` | instruction | 0 | 37,833 | 3 | 75,666 |
Yes | output | 1 | 37,833 | 3 | 75,667 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
[THE SxPLAY & KIVΛ - 漂流](https://soundcloud.com/kivawu/hyouryu)
[KIVΛ & Nikki Simmons - Perspectives](https://soundcloud.com/kivawu/perspectives)
With a new body, our idol Aroma White (or should we call her Kaori Minamiya?) begins to uncover her lost past through the OS space.
The space can be considered a 2D plane, with an infinite number of data nodes, indexed from 0, with their coordinates defined as follows:
* The coordinates of the 0-th node is (x_0, y_0)
* For i > 0, the coordinates of i-th node is (a_x ⋅ x_{i-1} + b_x, a_y ⋅ y_{i-1} + b_y)
Initially Aroma stands at the point (x_s, y_s). She can stay in OS space for at most t seconds, because after this time she has to warp back to the real world. She doesn't need to return to the entry point (x_s, y_s) to warp home.
While within the OS space, Aroma can do the following actions:
* From the point (x, y), Aroma can move to one of the following points: (x-1, y), (x+1, y), (x, y-1) or (x, y+1). This action requires 1 second.
* If there is a data node at where Aroma is staying, she can collect it. We can assume this action costs 0 seconds. Of course, each data node can be collected at most once.
Aroma wants to collect as many data as possible before warping back. Can you help her in calculating the maximum number of data nodes she could collect within t seconds?
Input
The first line contains integers x_0, y_0, a_x, a_y, b_x, b_y (1 ≤ x_0, y_0 ≤ 10^{16}, 2 ≤ a_x, a_y ≤ 100, 0 ≤ b_x, b_y ≤ 10^{16}), which define the coordinates of the data nodes.
The second line contains integers x_s, y_s, t (1 ≤ x_s, y_s, t ≤ 10^{16}) – the initial Aroma's coordinates and the amount of time available.
Output
Print a single integer — the maximum number of data nodes Aroma can collect within t seconds.
Examples
Input
1 1 2 3 1 0
2 4 20
Output
3
Input
1 1 2 3 1 0
15 27 26
Output
2
Input
1 1 2 3 1 0
2 2 1
Output
0
Note
In all three examples, the coordinates of the first 5 data nodes are (1, 1), (3, 3), (7, 9), (15, 27) and (31, 81) (remember that nodes are numbered from 0).
In the first example, the optimal route to collect 3 nodes is as follows:
* Go to the coordinates (3, 3) and collect the 1-st node. This takes |3 - 2| + |3 - 4| = 2 seconds.
* Go to the coordinates (1, 1) and collect the 0-th node. This takes |1 - 3| + |1 - 3| = 4 seconds.
* Go to the coordinates (7, 9) and collect the 2-nd node. This takes |7 - 1| + |9 - 1| = 14 seconds.
In the second example, the optimal route to collect 2 nodes is as follows:
* Collect the 3-rd node. This requires no seconds.
* Go to the coordinates (7, 9) and collect the 2-th node. This takes |15 - 7| + |27 - 9| = 26 seconds.
In the third example, Aroma can't collect any nodes. She should have taken proper rest instead of rushing into the OS space like that.
Submitted Solution:
```
x0,y0,ax,ay,bx,by=map(int,input().split())
xs,ys,t=map(int,input().split())
imp=[[x0,y0]]
for i in range(64):
imp.append([imp[-1][0]*ax+bx,imp[-1][1]*ay+by])
l=len(imp)
pro=0
for i in range(l):
for j in range(l):
if abs(xs-imp[i][0])+abs(ys-imp[i][1])+abs(imp[j][0]-imp[i][0])+abs(imp[j][1]-imp[i][1])<=t:
pro=max(pro,abs(i-j)+1)
print(pro)
``` | instruction | 0 | 37,834 | 3 | 75,668 |
Yes | output | 1 | 37,834 | 3 | 75,669 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
[THE SxPLAY & KIVΛ - 漂流](https://soundcloud.com/kivawu/hyouryu)
[KIVΛ & Nikki Simmons - Perspectives](https://soundcloud.com/kivawu/perspectives)
With a new body, our idol Aroma White (or should we call her Kaori Minamiya?) begins to uncover her lost past through the OS space.
The space can be considered a 2D plane, with an infinite number of data nodes, indexed from 0, with their coordinates defined as follows:
* The coordinates of the 0-th node is (x_0, y_0)
* For i > 0, the coordinates of i-th node is (a_x ⋅ x_{i-1} + b_x, a_y ⋅ y_{i-1} + b_y)
Initially Aroma stands at the point (x_s, y_s). She can stay in OS space for at most t seconds, because after this time she has to warp back to the real world. She doesn't need to return to the entry point (x_s, y_s) to warp home.
While within the OS space, Aroma can do the following actions:
* From the point (x, y), Aroma can move to one of the following points: (x-1, y), (x+1, y), (x, y-1) or (x, y+1). This action requires 1 second.
* If there is a data node at where Aroma is staying, she can collect it. We can assume this action costs 0 seconds. Of course, each data node can be collected at most once.
Aroma wants to collect as many data as possible before warping back. Can you help her in calculating the maximum number of data nodes she could collect within t seconds?
Input
The first line contains integers x_0, y_0, a_x, a_y, b_x, b_y (1 ≤ x_0, y_0 ≤ 10^{16}, 2 ≤ a_x, a_y ≤ 100, 0 ≤ b_x, b_y ≤ 10^{16}), which define the coordinates of the data nodes.
The second line contains integers x_s, y_s, t (1 ≤ x_s, y_s, t ≤ 10^{16}) – the initial Aroma's coordinates and the amount of time available.
Output
Print a single integer — the maximum number of data nodes Aroma can collect within t seconds.
Examples
Input
1 1 2 3 1 0
2 4 20
Output
3
Input
1 1 2 3 1 0
15 27 26
Output
2
Input
1 1 2 3 1 0
2 2 1
Output
0
Note
In all three examples, the coordinates of the first 5 data nodes are (1, 1), (3, 3), (7, 9), (15, 27) and (31, 81) (remember that nodes are numbered from 0).
In the first example, the optimal route to collect 3 nodes is as follows:
* Go to the coordinates (3, 3) and collect the 1-st node. This takes |3 - 2| + |3 - 4| = 2 seconds.
* Go to the coordinates (1, 1) and collect the 0-th node. This takes |1 - 3| + |1 - 3| = 4 seconds.
* Go to the coordinates (7, 9) and collect the 2-nd node. This takes |7 - 1| + |9 - 1| = 14 seconds.
In the second example, the optimal route to collect 2 nodes is as follows:
* Collect the 3-rd node. This requires no seconds.
* Go to the coordinates (7, 9) and collect the 2-th node. This takes |15 - 7| + |27 - 9| = 26 seconds.
In the third example, Aroma can't collect any nodes. She should have taken proper rest instead of rushing into the OS space like that.
Submitted Solution:
```
x0, y0, ax, ay, bx, by = list(map(int, input().split()))
xs, ys, t = list(map(int, input().split()))
all_numbers = [(x0, y0)]
for i in range(55):
x, y = all_numbers[-1]
all_numbers.append((ax * x + bx, ay * y + by))
for i in range(0, len(all_numbers)):
if xs < all_numbers[i][0]:
break
# print(all_numbers[13:17])
ind = i - 1
maximum = 0
if ind >= 0:
total = 0
t1 = t
x1, y1 = xs, ys
flag = 1
for i in range(ind, -1, -1):
diff = abs(x1 - all_numbers[i][0]) + abs(y1 - all_numbers[i][1])
if diff <= t1:
t1 -= diff
total += 1
else:
flag = 0
break
x1, y1 = all_numbers[i]
# print(t1)
if flag == 1:
t1 = t1 - (t - t1)
# print(t1)
if t1 > 0:
x1, y1 = xs, ys
for i in range(ind + 1, len(all_numbers)):
diff = abs(x1 - all_numbers[i][0]) + abs(y1 - all_numbers[i][1])
if diff <= t1:
t1 -= diff
total += 1
x1, y1 = all_numbers[i]
maximum = max(total, maximum)
if abs(xs - all_numbers[ind + 1][0]) + abs(ys - all_numbers[ind + 1][1]) <= t:
t =t-( abs(xs - all_numbers[ind + 1][0]) + abs(ys - all_numbers[ind + 1][1]))
xs, ys = all_numbers[ind + 1]
# print("asdsa")
total = 1
flag = 1
t1 = t
x1, y1 = xs, ys
flag = 1
for i in range(ind, -1, -1):
diff = abs(x1 - all_numbers[i][0]) + abs(y1 - all_numbers[i][1])
if diff <= t1:
t1 -= diff
total += 1
else:
flag = 0
break
x1, y1 = all_numbers[i]
# print(t1)
if flag == 1:
t1 = t1 - (t - t1)
# print(t1)
if t1 > 0:
x1, y1 = xs, ys
for i in range(ind + 1, len(all_numbers)):
diff = abs(x1 - all_numbers[i][0]) + abs(y1 - all_numbers[i][1])
if diff <= t1:
t1 -= diff
total += 1
x1, y1 = all_numbers[i]
maximum = max(total, maximum)
print(maximum)
else:
total=0
for i in range(0,len(all_numbers)):
diff = abs(xs - all_numbers[i][0]) + abs(ys - all_numbers[i][1])
if diff<=t:
total+=1
t-=diff
else:
break
xs,ys=all_numbers[i]
print(maximum)
``` | instruction | 0 | 37,835 | 3 | 75,670 |
No | output | 1 | 37,835 | 3 | 75,671 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
[THE SxPLAY & KIVΛ - 漂流](https://soundcloud.com/kivawu/hyouryu)
[KIVΛ & Nikki Simmons - Perspectives](https://soundcloud.com/kivawu/perspectives)
With a new body, our idol Aroma White (or should we call her Kaori Minamiya?) begins to uncover her lost past through the OS space.
The space can be considered a 2D plane, with an infinite number of data nodes, indexed from 0, with their coordinates defined as follows:
* The coordinates of the 0-th node is (x_0, y_0)
* For i > 0, the coordinates of i-th node is (a_x ⋅ x_{i-1} + b_x, a_y ⋅ y_{i-1} + b_y)
Initially Aroma stands at the point (x_s, y_s). She can stay in OS space for at most t seconds, because after this time she has to warp back to the real world. She doesn't need to return to the entry point (x_s, y_s) to warp home.
While within the OS space, Aroma can do the following actions:
* From the point (x, y), Aroma can move to one of the following points: (x-1, y), (x+1, y), (x, y-1) or (x, y+1). This action requires 1 second.
* If there is a data node at where Aroma is staying, she can collect it. We can assume this action costs 0 seconds. Of course, each data node can be collected at most once.
Aroma wants to collect as many data as possible before warping back. Can you help her in calculating the maximum number of data nodes she could collect within t seconds?
Input
The first line contains integers x_0, y_0, a_x, a_y, b_x, b_y (1 ≤ x_0, y_0 ≤ 10^{16}, 2 ≤ a_x, a_y ≤ 100, 0 ≤ b_x, b_y ≤ 10^{16}), which define the coordinates of the data nodes.
The second line contains integers x_s, y_s, t (1 ≤ x_s, y_s, t ≤ 10^{16}) – the initial Aroma's coordinates and the amount of time available.
Output
Print a single integer — the maximum number of data nodes Aroma can collect within t seconds.
Examples
Input
1 1 2 3 1 0
2 4 20
Output
3
Input
1 1 2 3 1 0
15 27 26
Output
2
Input
1 1 2 3 1 0
2 2 1
Output
0
Note
In all three examples, the coordinates of the first 5 data nodes are (1, 1), (3, 3), (7, 9), (15, 27) and (31, 81) (remember that nodes are numbered from 0).
In the first example, the optimal route to collect 3 nodes is as follows:
* Go to the coordinates (3, 3) and collect the 1-st node. This takes |3 - 2| + |3 - 4| = 2 seconds.
* Go to the coordinates (1, 1) and collect the 0-th node. This takes |1 - 3| + |1 - 3| = 4 seconds.
* Go to the coordinates (7, 9) and collect the 2-nd node. This takes |7 - 1| + |9 - 1| = 14 seconds.
In the second example, the optimal route to collect 2 nodes is as follows:
* Collect the 3-rd node. This requires no seconds.
* Go to the coordinates (7, 9) and collect the 2-th node. This takes |15 - 7| + |27 - 9| = 26 seconds.
In the third example, Aroma can't collect any nodes. She should have taken proper rest instead of rushing into the OS space like that.
Submitted Solution:
```
x0, y0, ax, ay, bx, by = list(map(int, input().split()))
xs, ys, t = list(map(int, input().split()))
r = []
for i in range(50):
r.append((x0, y0))
x0 = ax * x0 + bx
y0 = ay * y0 + by
ans = 0
def distance(l, r):
return abs(l[0] - r[0]) + abs(l[1] - r[1])
init = (xs, ys)
for i in range(len(r)):
d = distance(r[i], init)
if d <= t:
ans = max(ans, 1)
cd = d
add = 0
now = 1
for left in range(i - 1, -1, -1):
cd += distance(r[left], r[left + 1])
add += distance(r[left], r[left + 1])
now += 1
if cd <= t:
ans = max(ans, now)
maybe_cd = cd + add
maybe_now = now
for right in range(i + 1, len(r)):
maybe_cd += distance(r[right], r[right - 1])
maybe_now += 1
if maybe_cd <= t:
ans = max(ans, maybe_now)
else:
break
else:
break
cd = d
add = 0
now = 1
for right in range(i + 1, len(r)):
cd += distance(r[right], r[right - 1])
add += distance(r[right], r[right - 1])
now += 1
if cd <= t:
ans = max(ans, now)
maybe_cd = cd + add
maybe_now = now
for left in range(i - 1, -1, -1):
maybe_cd += distance(r[left], r[left + 1])
maybe_now += 1
if maybe_cd <= t:
ans = max(ans, maybe_now)
else:
break
else:
break
print(ans)
``` | instruction | 0 | 37,836 | 3 | 75,672 |
No | output | 1 | 37,836 | 3 | 75,673 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
[THE SxPLAY & KIVΛ - 漂流](https://soundcloud.com/kivawu/hyouryu)
[KIVΛ & Nikki Simmons - Perspectives](https://soundcloud.com/kivawu/perspectives)
With a new body, our idol Aroma White (or should we call her Kaori Minamiya?) begins to uncover her lost past through the OS space.
The space can be considered a 2D plane, with an infinite number of data nodes, indexed from 0, with their coordinates defined as follows:
* The coordinates of the 0-th node is (x_0, y_0)
* For i > 0, the coordinates of i-th node is (a_x ⋅ x_{i-1} + b_x, a_y ⋅ y_{i-1} + b_y)
Initially Aroma stands at the point (x_s, y_s). She can stay in OS space for at most t seconds, because after this time she has to warp back to the real world. She doesn't need to return to the entry point (x_s, y_s) to warp home.
While within the OS space, Aroma can do the following actions:
* From the point (x, y), Aroma can move to one of the following points: (x-1, y), (x+1, y), (x, y-1) or (x, y+1). This action requires 1 second.
* If there is a data node at where Aroma is staying, she can collect it. We can assume this action costs 0 seconds. Of course, each data node can be collected at most once.
Aroma wants to collect as many data as possible before warping back. Can you help her in calculating the maximum number of data nodes she could collect within t seconds?
Input
The first line contains integers x_0, y_0, a_x, a_y, b_x, b_y (1 ≤ x_0, y_0 ≤ 10^{16}, 2 ≤ a_x, a_y ≤ 100, 0 ≤ b_x, b_y ≤ 10^{16}), which define the coordinates of the data nodes.
The second line contains integers x_s, y_s, t (1 ≤ x_s, y_s, t ≤ 10^{16}) – the initial Aroma's coordinates and the amount of time available.
Output
Print a single integer — the maximum number of data nodes Aroma can collect within t seconds.
Examples
Input
1 1 2 3 1 0
2 4 20
Output
3
Input
1 1 2 3 1 0
15 27 26
Output
2
Input
1 1 2 3 1 0
2 2 1
Output
0
Note
In all three examples, the coordinates of the first 5 data nodes are (1, 1), (3, 3), (7, 9), (15, 27) and (31, 81) (remember that nodes are numbered from 0).
In the first example, the optimal route to collect 3 nodes is as follows:
* Go to the coordinates (3, 3) and collect the 1-st node. This takes |3 - 2| + |3 - 4| = 2 seconds.
* Go to the coordinates (1, 1) and collect the 0-th node. This takes |1 - 3| + |1 - 3| = 4 seconds.
* Go to the coordinates (7, 9) and collect the 2-nd node. This takes |7 - 1| + |9 - 1| = 14 seconds.
In the second example, the optimal route to collect 2 nodes is as follows:
* Collect the 3-rd node. This requires no seconds.
* Go to the coordinates (7, 9) and collect the 2-th node. This takes |15 - 7| + |27 - 9| = 26 seconds.
In the third example, Aroma can't collect any nodes. She should have taken proper rest instead of rushing into the OS space like that.
Submitted Solution:
```
x,y,ax,ay,bx,by=map(int,input().split(" "))
xs,ys,t=map(int,input().split(" "))
ans=0
points=[]
tx,ty=x,y
while(tx<=10**20 and ty<=10**20):
points.append((tx,ty))
tx=(tx*ax)+bx
ty=(ty*ay)+by
ind=-1
mini=10**20
for i in range(len(points)):
z=((points[i][0]-xs)**2)+((points[i][1]-ys)**2)
if(z<mini):
mini=z
ind=i
#print(ind)
#print(points)
#print(ind)
start=ind+1
lol=0
cx=xs
cy=ys
#print(t,lol,"ppp")
while ((lol+abs(cx-points[ind][0])+abs(cy-points[ind][1]))<=t and ind>=0):
#print("lol")
#print(cx,cy,"curr")
lol+=abs(cx-points[ind][0])+abs(cy-points[ind][1])
cx=points[ind][0]
cy=points[ind][1]
ans+=1
ind-=1
#print(lol)
#print(cx,cy,"popop",start)
while(start<len(points) and (lol+abs(cx-points[start][0])+abs(cy-points[start][1]))<=t):
lol+=abs(cx-points[start][0])+abs(cy-points[start][1])
ans+=1
start+=1
#print(ans)
``` | instruction | 0 | 37,837 | 3 | 75,674 |
No | output | 1 | 37,837 | 3 | 75,675 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
[THE SxPLAY & KIVΛ - 漂流](https://soundcloud.com/kivawu/hyouryu)
[KIVΛ & Nikki Simmons - Perspectives](https://soundcloud.com/kivawu/perspectives)
With a new body, our idol Aroma White (or should we call her Kaori Minamiya?) begins to uncover her lost past through the OS space.
The space can be considered a 2D plane, with an infinite number of data nodes, indexed from 0, with their coordinates defined as follows:
* The coordinates of the 0-th node is (x_0, y_0)
* For i > 0, the coordinates of i-th node is (a_x ⋅ x_{i-1} + b_x, a_y ⋅ y_{i-1} + b_y)
Initially Aroma stands at the point (x_s, y_s). She can stay in OS space for at most t seconds, because after this time she has to warp back to the real world. She doesn't need to return to the entry point (x_s, y_s) to warp home.
While within the OS space, Aroma can do the following actions:
* From the point (x, y), Aroma can move to one of the following points: (x-1, y), (x+1, y), (x, y-1) or (x, y+1). This action requires 1 second.
* If there is a data node at where Aroma is staying, she can collect it. We can assume this action costs 0 seconds. Of course, each data node can be collected at most once.
Aroma wants to collect as many data as possible before warping back. Can you help her in calculating the maximum number of data nodes she could collect within t seconds?
Input
The first line contains integers x_0, y_0, a_x, a_y, b_x, b_y (1 ≤ x_0, y_0 ≤ 10^{16}, 2 ≤ a_x, a_y ≤ 100, 0 ≤ b_x, b_y ≤ 10^{16}), which define the coordinates of the data nodes.
The second line contains integers x_s, y_s, t (1 ≤ x_s, y_s, t ≤ 10^{16}) – the initial Aroma's coordinates and the amount of time available.
Output
Print a single integer — the maximum number of data nodes Aroma can collect within t seconds.
Examples
Input
1 1 2 3 1 0
2 4 20
Output
3
Input
1 1 2 3 1 0
15 27 26
Output
2
Input
1 1 2 3 1 0
2 2 1
Output
0
Note
In all three examples, the coordinates of the first 5 data nodes are (1, 1), (3, 3), (7, 9), (15, 27) and (31, 81) (remember that nodes are numbered from 0).
In the first example, the optimal route to collect 3 nodes is as follows:
* Go to the coordinates (3, 3) and collect the 1-st node. This takes |3 - 2| + |3 - 4| = 2 seconds.
* Go to the coordinates (1, 1) and collect the 0-th node. This takes |1 - 3| + |1 - 3| = 4 seconds.
* Go to the coordinates (7, 9) and collect the 2-nd node. This takes |7 - 1| + |9 - 1| = 14 seconds.
In the second example, the optimal route to collect 2 nodes is as follows:
* Collect the 3-rd node. This requires no seconds.
* Go to the coordinates (7, 9) and collect the 2-th node. This takes |15 - 7| + |27 - 9| = 26 seconds.
In the third example, Aroma can't collect any nodes. She should have taken proper rest instead of rushing into the OS space like that.
Submitted Solution:
```
x0,y0,ax,ay,bx,by = list(map(int,input().split()))
x,y,hadtime = list(map(int,input().split()))
a = []
num = 0
a.append([x0,y0])
for i in range(1,100):
a.append([a[i-1][0]*ax+bx,a[i-1][1]*ay+by])
for i in range(100):
if abs(a[i][0]-x)+abs(a[i][1]-y)<=hadtime:
num+=1
print(num)
``` | instruction | 0 | 37,838 | 3 | 75,676 |
No | output | 1 | 37,838 | 3 | 75,677 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Young wilderness explorers set off to their first expedition led by senior explorer Russell. Explorers went into a forest, set up a camp and decided to split into groups to explore as much interesting locations as possible. Russell was trying to form groups, but ran into some difficulties...
Most of the young explorers are inexperienced, and sending them alone would be a mistake. Even Russell himself became senior explorer not long ago. Each of young explorers has a positive integer parameter e_i — his inexperience. Russell decided that an explorer with inexperience e can only join the group of e or more people.
Now Russell needs to figure out how many groups he can organize. It's not necessary to include every explorer in one of the groups: some can stay in the camp. Russell is worried about this expedition, so he asked you to help him.
Input
The first line contains the number of independent test cases T(1 ≤ T ≤ 2 ⋅ 10^5). Next 2T lines contain description of test cases.
The first line of description of each test case contains the number of young explorers N (1 ≤ N ≤ 2 ⋅ 10^5).
The second line contains N integers e_1, e_2, …, e_N (1 ≤ e_i ≤ N), where e_i is the inexperience of the i-th explorer.
It's guaranteed that sum of all N doesn't exceed 3 ⋅ 10^5.
Output
Print T numbers, each number on a separate line.
In i-th line print the maximum number of groups Russell can form in i-th test case.
Example
Input
2
3
1 1 1
5
2 3 1 2 2
Output
3
2
Note
In the first example we can organize three groups. There will be only one explorer in each group. It's correct because inexperience of each explorer equals to 1, so it's not less than the size of his group.
In the second example we can organize two groups. Explorers with inexperience 1, 2 and 3 will form the first group, and the other two explorers with inexperience equal to 2 will form the second group.
This solution is not unique. For example, we can form the first group using the three explorers with inexperience equal to 2, and the second group using only one explorer with inexperience equal to 1. In this case the young explorer with inexperience equal to 3 will not be included in any group.
Submitted Solution:
```
import sys
input = sys.stdin.buffer.readline
strInp = lambda : input().strip().split()
intInp = lambda : list(map(int,strInp()))
for t in range(int(input())):
n = int(input())
arr = intInp()
arr.sort(reverse=True)
m = 0
myMax = arr.pop()
groupLen = 1
while len(arr) >= 0:
if groupLen == myMax:
m += 1
groupLen = 1
if len(arr) == 0:
break
myMax = arr.pop()
continue
if len(arr) == 0:
break
nex = arr.pop()
myMax = max(myMax, nex)
groupLen += 1
print(m)
``` | instruction | 0 | 37,868 | 3 | 75,736 |
Yes | output | 1 | 37,868 | 3 | 75,737 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Young wilderness explorers set off to their first expedition led by senior explorer Russell. Explorers went into a forest, set up a camp and decided to split into groups to explore as much interesting locations as possible. Russell was trying to form groups, but ran into some difficulties...
Most of the young explorers are inexperienced, and sending them alone would be a mistake. Even Russell himself became senior explorer not long ago. Each of young explorers has a positive integer parameter e_i — his inexperience. Russell decided that an explorer with inexperience e can only join the group of e or more people.
Now Russell needs to figure out how many groups he can organize. It's not necessary to include every explorer in one of the groups: some can stay in the camp. Russell is worried about this expedition, so he asked you to help him.
Input
The first line contains the number of independent test cases T(1 ≤ T ≤ 2 ⋅ 10^5). Next 2T lines contain description of test cases.
The first line of description of each test case contains the number of young explorers N (1 ≤ N ≤ 2 ⋅ 10^5).
The second line contains N integers e_1, e_2, …, e_N (1 ≤ e_i ≤ N), where e_i is the inexperience of the i-th explorer.
It's guaranteed that sum of all N doesn't exceed 3 ⋅ 10^5.
Output
Print T numbers, each number on a separate line.
In i-th line print the maximum number of groups Russell can form in i-th test case.
Example
Input
2
3
1 1 1
5
2 3 1 2 2
Output
3
2
Note
In the first example we can organize three groups. There will be only one explorer in each group. It's correct because inexperience of each explorer equals to 1, so it's not less than the size of his group.
In the second example we can organize two groups. Explorers with inexperience 1, 2 and 3 will form the first group, and the other two explorers with inexperience equal to 2 will form the second group.
This solution is not unique. For example, we can form the first group using the three explorers with inexperience equal to 2, and the second group using only one explorer with inexperience equal to 1. In this case the young explorer with inexperience equal to 3 will not be included in any group.
Submitted Solution:
```
from sys import stdin
from sys import stdout
def main():
t = int(stdin.readline())
for _ in range(t):
n = int(stdin.readline())
e = sorted(map(int, stdin.readline().split()))
i = 0
res = 0
while i < n:
max_ = e[i]
cnt = 1
i += 1
while i < n and max_ > cnt:
max_ = e[i]
cnt += 1
i += 1
if max_ <= cnt:
res += 1
stdout.write(str(res) + "\n")
main()
``` | instruction | 0 | 37,869 | 3 | 75,738 |
Yes | output | 1 | 37,869 | 3 | 75,739 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Young wilderness explorers set off to their first expedition led by senior explorer Russell. Explorers went into a forest, set up a camp and decided to split into groups to explore as much interesting locations as possible. Russell was trying to form groups, but ran into some difficulties...
Most of the young explorers are inexperienced, and sending them alone would be a mistake. Even Russell himself became senior explorer not long ago. Each of young explorers has a positive integer parameter e_i — his inexperience. Russell decided that an explorer with inexperience e can only join the group of e or more people.
Now Russell needs to figure out how many groups he can organize. It's not necessary to include every explorer in one of the groups: some can stay in the camp. Russell is worried about this expedition, so he asked you to help him.
Input
The first line contains the number of independent test cases T(1 ≤ T ≤ 2 ⋅ 10^5). Next 2T lines contain description of test cases.
The first line of description of each test case contains the number of young explorers N (1 ≤ N ≤ 2 ⋅ 10^5).
The second line contains N integers e_1, e_2, …, e_N (1 ≤ e_i ≤ N), where e_i is the inexperience of the i-th explorer.
It's guaranteed that sum of all N doesn't exceed 3 ⋅ 10^5.
Output
Print T numbers, each number on a separate line.
In i-th line print the maximum number of groups Russell can form in i-th test case.
Example
Input
2
3
1 1 1
5
2 3 1 2 2
Output
3
2
Note
In the first example we can organize three groups. There will be only one explorer in each group. It's correct because inexperience of each explorer equals to 1, so it's not less than the size of his group.
In the second example we can organize two groups. Explorers with inexperience 1, 2 and 3 will form the first group, and the other two explorers with inexperience equal to 2 will form the second group.
This solution is not unique. For example, we can form the first group using the three explorers with inexperience equal to 2, and the second group using only one explorer with inexperience equal to 1. In this case the young explorer with inexperience equal to 3 will not be included in any group.
Submitted Solution:
```
for i in range(int(input())):
n=int(input())
q=sorted(list(map(int,input().split())))
if n==1 and q[0]==1:
print("1")
elif n==1 and q[0]!=1:
print("0")
else:
p=0
cnt=0
for i in q:
cnt+=1
if cnt==i:
cnt=0
p+=1
print(p)
``` | instruction | 0 | 37,870 | 3 | 75,740 |
Yes | output | 1 | 37,870 | 3 | 75,741 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Young wilderness explorers set off to their first expedition led by senior explorer Russell. Explorers went into a forest, set up a camp and decided to split into groups to explore as much interesting locations as possible. Russell was trying to form groups, but ran into some difficulties...
Most of the young explorers are inexperienced, and sending them alone would be a mistake. Even Russell himself became senior explorer not long ago. Each of young explorers has a positive integer parameter e_i — his inexperience. Russell decided that an explorer with inexperience e can only join the group of e or more people.
Now Russell needs to figure out how many groups he can organize. It's not necessary to include every explorer in one of the groups: some can stay in the camp. Russell is worried about this expedition, so he asked you to help him.
Input
The first line contains the number of independent test cases T(1 ≤ T ≤ 2 ⋅ 10^5). Next 2T lines contain description of test cases.
The first line of description of each test case contains the number of young explorers N (1 ≤ N ≤ 2 ⋅ 10^5).
The second line contains N integers e_1, e_2, …, e_N (1 ≤ e_i ≤ N), where e_i is the inexperience of the i-th explorer.
It's guaranteed that sum of all N doesn't exceed 3 ⋅ 10^5.
Output
Print T numbers, each number on a separate line.
In i-th line print the maximum number of groups Russell can form in i-th test case.
Example
Input
2
3
1 1 1
5
2 3 1 2 2
Output
3
2
Note
In the first example we can organize three groups. There will be only one explorer in each group. It's correct because inexperience of each explorer equals to 1, so it's not less than the size of his group.
In the second example we can organize two groups. Explorers with inexperience 1, 2 and 3 will form the first group, and the other two explorers with inexperience equal to 2 will form the second group.
This solution is not unique. For example, we can form the first group using the three explorers with inexperience equal to 2, and the second group using only one explorer with inexperience equal to 1. In this case the young explorer with inexperience equal to 3 will not be included in any group.
Submitted Solution:
```
from sys import stdin, stdout
import math,sys
from itertools import permutations, combinations
from collections import defaultdict,deque,OrderedDict
import bisect as bi
import heapq
#------------------PYPY FAst I/o--------------------------------#
def I():return (int(stdin.readline()))
def In():return(map(int,stdin.readline().split()))
'''
#------------------Sublime--------------------------------------#
#sys.stdin=open('input.txt','r');sys.stdout=open('output.txt','w');
def I():return (int(input()))
def In():return(map(int,input().split()))
def L():return(list(In()))
'''
def main():
try:
n=I()
l=list(In())
if n==1 and l[0]==1:
print(1)
else:
l.sort()
ans=0
temp=0
ma=-1
for i in range(n):
temp1=l[i]
ma=max(temp1,ma)
temp+=1
if temp==ma:
ans+=1
temp=0
ma=-1
#print(ans)
print(ans)
except:
pass
M = 998244353
P = 1000000007
if __name__ == '__main__':
for _ in range(I()):
main()
``` | instruction | 0 | 37,871 | 3 | 75,742 |
Yes | output | 1 | 37,871 | 3 | 75,743 |
Evaluate the correctness of the submitted Python 2 solution to the coding contest problem. Provide a "Yes" or "No" response.
Young wilderness explorers set off to their first expedition led by senior explorer Russell. Explorers went into a forest, set up a camp and decided to split into groups to explore as much interesting locations as possible. Russell was trying to form groups, but ran into some difficulties...
Most of the young explorers are inexperienced, and sending them alone would be a mistake. Even Russell himself became senior explorer not long ago. Each of young explorers has a positive integer parameter e_i — his inexperience. Russell decided that an explorer with inexperience e can only join the group of e or more people.
Now Russell needs to figure out how many groups he can organize. It's not necessary to include every explorer in one of the groups: some can stay in the camp. Russell is worried about this expedition, so he asked you to help him.
Input
The first line contains the number of independent test cases T(1 ≤ T ≤ 2 ⋅ 10^5). Next 2T lines contain description of test cases.
The first line of description of each test case contains the number of young explorers N (1 ≤ N ≤ 2 ⋅ 10^5).
The second line contains N integers e_1, e_2, …, e_N (1 ≤ e_i ≤ N), where e_i is the inexperience of the i-th explorer.
It's guaranteed that sum of all N doesn't exceed 3 ⋅ 10^5.
Output
Print T numbers, each number on a separate line.
In i-th line print the maximum number of groups Russell can form in i-th test case.
Example
Input
2
3
1 1 1
5
2 3 1 2 2
Output
3
2
Note
In the first example we can organize three groups. There will be only one explorer in each group. It's correct because inexperience of each explorer equals to 1, so it's not less than the size of his group.
In the second example we can organize two groups. Explorers with inexperience 1, 2 and 3 will form the first group, and the other two explorers with inexperience equal to 2 will form the second group.
This solution is not unique. For example, we can form the first group using the three explorers with inexperience equal to 2, and the second group using only one explorer with inexperience equal to 1. In this case the young explorer with inexperience equal to 3 will not be included in any group.
Submitted Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
raw_input = stdin.readline
pr = stdout.write
mod=10**9+7
def ni():
return int(raw_input())
def li():
return map(int,raw_input().split())
def pn(n):
stdout.write(str(n)+'\n')
def pa(arr):
pr(' '.join(map(str,arr))+'\n')
# fast read function for total integer input
def inp():
# this function returns whole input of
# space/line seperated integers
# Use Ctrl+D to flush stdin.
return map(int,stdin.read().split())
range = xrange # not for python 3.0+
for t in range(ni()):
n=ni()
l=li()
d=Counter(l)
temp=0
ans=0
for i in sorted(d):
ans+=(temp+d[i])/i
temp=(temp+d[i])%i
pn(ans)
``` | instruction | 0 | 37,872 | 3 | 75,744 |
Yes | output | 1 | 37,872 | 3 | 75,745 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Young wilderness explorers set off to their first expedition led by senior explorer Russell. Explorers went into a forest, set up a camp and decided to split into groups to explore as much interesting locations as possible. Russell was trying to form groups, but ran into some difficulties...
Most of the young explorers are inexperienced, and sending them alone would be a mistake. Even Russell himself became senior explorer not long ago. Each of young explorers has a positive integer parameter e_i — his inexperience. Russell decided that an explorer with inexperience e can only join the group of e or more people.
Now Russell needs to figure out how many groups he can organize. It's not necessary to include every explorer in one of the groups: some can stay in the camp. Russell is worried about this expedition, so he asked you to help him.
Input
The first line contains the number of independent test cases T(1 ≤ T ≤ 2 ⋅ 10^5). Next 2T lines contain description of test cases.
The first line of description of each test case contains the number of young explorers N (1 ≤ N ≤ 2 ⋅ 10^5).
The second line contains N integers e_1, e_2, …, e_N (1 ≤ e_i ≤ N), where e_i is the inexperience of the i-th explorer.
It's guaranteed that sum of all N doesn't exceed 3 ⋅ 10^5.
Output
Print T numbers, each number on a separate line.
In i-th line print the maximum number of groups Russell can form in i-th test case.
Example
Input
2
3
1 1 1
5
2 3 1 2 2
Output
3
2
Note
In the first example we can organize three groups. There will be only one explorer in each group. It's correct because inexperience of each explorer equals to 1, so it's not less than the size of his group.
In the second example we can organize two groups. Explorers with inexperience 1, 2 and 3 will form the first group, and the other two explorers with inexperience equal to 2 will form the second group.
This solution is not unique. For example, we can form the first group using the three explorers with inexperience equal to 2, and the second group using only one explorer with inexperience equal to 1. In this case the young explorer with inexperience equal to 3 will not be included in any group.
Submitted Solution:
```
from collections import defaultdict
a=int(input())
for i in range(a):
r=int(input())
z=list(map(int,input().split()))
from collections import defaultdict
al=defaultdict(int)
for i in range(len(z)):
al[z[i]]+=1
z.sort()
fill=0
count=0
z=list(set(z))
for i in range(len(z)):
count+=al[z[i]]//z[i]
rem=al[z[i]]%z[i]
count+=rem//z[i]
fill=rem%z[i]
print(count)
``` | instruction | 0 | 37,873 | 3 | 75,746 |
No | output | 1 | 37,873 | 3 | 75,747 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Young wilderness explorers set off to their first expedition led by senior explorer Russell. Explorers went into a forest, set up a camp and decided to split into groups to explore as much interesting locations as possible. Russell was trying to form groups, but ran into some difficulties...
Most of the young explorers are inexperienced, and sending them alone would be a mistake. Even Russell himself became senior explorer not long ago. Each of young explorers has a positive integer parameter e_i — his inexperience. Russell decided that an explorer with inexperience e can only join the group of e or more people.
Now Russell needs to figure out how many groups he can organize. It's not necessary to include every explorer in one of the groups: some can stay in the camp. Russell is worried about this expedition, so he asked you to help him.
Input
The first line contains the number of independent test cases T(1 ≤ T ≤ 2 ⋅ 10^5). Next 2T lines contain description of test cases.
The first line of description of each test case contains the number of young explorers N (1 ≤ N ≤ 2 ⋅ 10^5).
The second line contains N integers e_1, e_2, …, e_N (1 ≤ e_i ≤ N), where e_i is the inexperience of the i-th explorer.
It's guaranteed that sum of all N doesn't exceed 3 ⋅ 10^5.
Output
Print T numbers, each number on a separate line.
In i-th line print the maximum number of groups Russell can form in i-th test case.
Example
Input
2
3
1 1 1
5
2 3 1 2 2
Output
3
2
Note
In the first example we can organize three groups. There will be only one explorer in each group. It's correct because inexperience of each explorer equals to 1, so it's not less than the size of his group.
In the second example we can organize two groups. Explorers with inexperience 1, 2 and 3 will form the first group, and the other two explorers with inexperience equal to 2 will form the second group.
This solution is not unique. For example, we can form the first group using the three explorers with inexperience equal to 2, and the second group using only one explorer with inexperience equal to 1. In this case the young explorer with inexperience equal to 3 will not be included in any group.
Submitted Solution:
```
import os,sys;from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno();self.buffer = BytesIO();self.writable = "x" in file.mode or "r" not in file.mode;self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:break
ptr = self.buffer.tell();self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE));self.newlines = b.count(b"\n") + (not b);ptr = self.buffer.tell();self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:os.write(self._fd, self.buffer.getvalue());self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file);self.flush = self.buffer.flush;self.writable = self.buffer.writable;self.write = lambda s: self.buffer.write(s.encode("ascii"));self.read = lambda: self.buffer.read().decode("ascii");self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
try:sys.stdin,sys.stdout=open('in.txt','r'),open('out.txt','w')
except:pass
ii1=lambda:int(sys.stdin.readline().strip()) # for interger
is1=lambda:sys.stdin.readline().strip() # for str
iia=lambda:list(map(int,sys.stdin.readline().strip().split())) # for List[int]
isa=lambda:sys.stdin.readline().strip().split() # for List[str]
mod=int(1e9 + 7);from collections import *;from math import *
# abc = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
# sys.setrecursionlimit(500000)
###################### Start Here ######################
# from functools import lru_cache
# from collections import defaultdict as dd
from collections import deque as dq
for _ in range(ii1()):
n = ii1()
arr = iia()
ans = 0
counter = Counter(arr)
for key,val in counter.items():
ans+=val//key
print(ans)
``` | instruction | 0 | 37,874 | 3 | 75,748 |
No | output | 1 | 37,874 | 3 | 75,749 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Young wilderness explorers set off to their first expedition led by senior explorer Russell. Explorers went into a forest, set up a camp and decided to split into groups to explore as much interesting locations as possible. Russell was trying to form groups, but ran into some difficulties...
Most of the young explorers are inexperienced, and sending them alone would be a mistake. Even Russell himself became senior explorer not long ago. Each of young explorers has a positive integer parameter e_i — his inexperience. Russell decided that an explorer with inexperience e can only join the group of e or more people.
Now Russell needs to figure out how many groups he can organize. It's not necessary to include every explorer in one of the groups: some can stay in the camp. Russell is worried about this expedition, so he asked you to help him.
Input
The first line contains the number of independent test cases T(1 ≤ T ≤ 2 ⋅ 10^5). Next 2T lines contain description of test cases.
The first line of description of each test case contains the number of young explorers N (1 ≤ N ≤ 2 ⋅ 10^5).
The second line contains N integers e_1, e_2, …, e_N (1 ≤ e_i ≤ N), where e_i is the inexperience of the i-th explorer.
It's guaranteed that sum of all N doesn't exceed 3 ⋅ 10^5.
Output
Print T numbers, each number on a separate line.
In i-th line print the maximum number of groups Russell can form in i-th test case.
Example
Input
2
3
1 1 1
5
2 3 1 2 2
Output
3
2
Note
In the first example we can organize three groups. There will be only one explorer in each group. It's correct because inexperience of each explorer equals to 1, so it's not less than the size of his group.
In the second example we can organize two groups. Explorers with inexperience 1, 2 and 3 will form the first group, and the other two explorers with inexperience equal to 2 will form the second group.
This solution is not unique. For example, we can form the first group using the three explorers with inexperience equal to 2, and the second group using only one explorer with inexperience equal to 1. In this case the young explorer with inexperience equal to 3 will not be included in any group.
Submitted Solution:
```
from collections import deque
from collections import OrderedDict
import math
import sys
import os
from io import BytesIO
import threading
import bisect
import heapq
#sys.stdin = open("F:\PY\\test.txt", "r")
input = sys.stdin.readline
#file = open("F:\PY\\test.txt", "r")
#import file.readline as input
def run(val):
array = []
while(val>0):
array.append(val%10)
val=val//10
minElv = 9999999999
maxElv = 0
for i in range(len(array)):
minElv= min(array[i], minElv)
maxElv = max(array[i], maxElv)
return minElv*maxElv
for t in range(int(input())):
n = int(input())
iA = list(map(int, input().split()))
#cV = [0]*300005
cD = dict()
for i in range(n):
if iA[i] in cD:
cD[iA[i]]+=1
else:
cD[iA[i]]=1
answer = 0
sL = 0
sortDic = OrderedDict(sorted(cD.items()))
it=1
for i in sortDic.values():
#print(i)
answer+=i//it
sL+= i%it
if sL//it>0:
answer+=sL//it
sL=sL//it
it+=1
print(answer)
``` | instruction | 0 | 37,875 | 3 | 75,750 |
No | output | 1 | 37,875 | 3 | 75,751 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Young wilderness explorers set off to their first expedition led by senior explorer Russell. Explorers went into a forest, set up a camp and decided to split into groups to explore as much interesting locations as possible. Russell was trying to form groups, but ran into some difficulties...
Most of the young explorers are inexperienced, and sending them alone would be a mistake. Even Russell himself became senior explorer not long ago. Each of young explorers has a positive integer parameter e_i — his inexperience. Russell decided that an explorer with inexperience e can only join the group of e or more people.
Now Russell needs to figure out how many groups he can organize. It's not necessary to include every explorer in one of the groups: some can stay in the camp. Russell is worried about this expedition, so he asked you to help him.
Input
The first line contains the number of independent test cases T(1 ≤ T ≤ 2 ⋅ 10^5). Next 2T lines contain description of test cases.
The first line of description of each test case contains the number of young explorers N (1 ≤ N ≤ 2 ⋅ 10^5).
The second line contains N integers e_1, e_2, …, e_N (1 ≤ e_i ≤ N), where e_i is the inexperience of the i-th explorer.
It's guaranteed that sum of all N doesn't exceed 3 ⋅ 10^5.
Output
Print T numbers, each number on a separate line.
In i-th line print the maximum number of groups Russell can form in i-th test case.
Example
Input
2
3
1 1 1
5
2 3 1 2 2
Output
3
2
Note
In the first example we can organize three groups. There will be only one explorer in each group. It's correct because inexperience of each explorer equals to 1, so it's not less than the size of his group.
In the second example we can organize two groups. Explorers with inexperience 1, 2 and 3 will form the first group, and the other two explorers with inexperience equal to 2 will form the second group.
This solution is not unique. For example, we can form the first group using the three explorers with inexperience equal to 2, and the second group using only one explorer with inexperience equal to 1. In this case the young explorer with inexperience equal to 3 will not be included in any group.
Submitted Solution:
```
def main():
t=int(input())
while(t>0):
solve()
t-=1
def solve():
n=int(input())
l=list(map(int,input().strip().split()))[:n]
u=len(set(l))
if u==1:
print(len(l))
else:
print(len(l)-u)
main()
``` | instruction | 0 | 37,876 | 3 | 75,752 |
No | output | 1 | 37,876 | 3 | 75,753 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two polar bears Menshykov and Uslada from the St.Petersburg zoo and elephant Horace from the Kiev zoo got six sticks to play with and assess the animals' creativity. Menshykov, Uslada and Horace decided to make either an elephant or a bear from those sticks. They can make an animal from sticks in the following way:
* Four sticks represent the animal's legs, these sticks should have the same length.
* Two remaining sticks represent the animal's head and body. The bear's head stick must be shorter than the body stick. The elephant, however, has a long trunk, so his head stick must be as long as the body stick. Note that there are no limits on the relations between the leg sticks and the head and body sticks.
Your task is to find out which animal can be made from the given stick set. The zoo keeper wants the sticks back after the game, so they must never be broken, even bears understand it.
Input
The single line contains six space-separated integers li (1 ≤ li ≤ 9) — the lengths of the six sticks. It is guaranteed that the input is such that you cannot make both animals from the sticks.
Output
If you can make a bear from the given set, print string "Bear" (without the quotes). If you can make an elephant, print string "Elephant" (wıthout the quotes). If you can make neither a bear nor an elephant, print string "Alien" (without the quotes).
Examples
Input
4 2 5 4 4 4
Output
Bear
Input
4 4 5 4 4 5
Output
Elephant
Input
1 2 3 4 5 6
Output
Alien
Note
If you're out of creative ideas, see instructions below which show how to make a bear and an elephant in the first two samples. The stick of length 2 is in red, the sticks of length 4 are in green, the sticks of length 5 are in blue.
<image>
Submitted Solution:
```
arr = list(map(int, input().split()))
h = {}
for n in arr:
if n not in h:
h[n] = 1
else:
h[n] += 1
k = 4
if len(h)==1:
print('Elephant')
elif k+1 in h.values():
print('Bear')
elif k in h.values():
if len(h)==2:
print('Elephant')
elif len(h)==3:
print('Bear')
else:
print('Alien')
``` | instruction | 0 | 38,057 | 3 | 76,114 |
Yes | output | 1 | 38,057 | 3 | 76,115 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.