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 |
|---|---|---|---|---|---|
Provide a correct Python 3 solution for this coding contest problem.
Stellar history 2005.11.5. You are about to engage an enemy spacecraft as the captain of the UAZ Advance spacecraft. Fortunately, the enemy spaceship is still unnoticed. In addition, the space coordinates of the enemy are already known, and the "feather cannon" that emits a powerful straight beam is ready to launch. After that, I just issue a launch command.
However, there is an energy barrier installed by the enemy in outer space. The barrier is triangular and bounces off the "feather cannon" beam. Also, if the beam hits the barrier, the enemy will notice and escape. If you cannot determine that you will hit in advance, you will not be able to issue a launch command.
Therefore, enter the cosmic coordinates (three-dimensional coordinates x, y, z) of the UAZ Advance, enemy, and barrier positions, and if the beam avoids the barrier and hits the enemy, "HIT", if it hits the barrier " Create a program that outputs "MISS".
However, the barrier is only for those that look like a triangle from the Advance issue, and nothing that looks like a line segment is crushed. Barriers are also valid at boundaries containing triangular vertices and shall bounce the beam. Also, if the enemy is in the barrier, output "MISS".
Constraints
* -100 β€ x, y, z β€ 100
* The UAZ Advance and the enemy are never in the same position.
Input
The format of the input data is as follows:
The first line is the coordinates of UAZ Advance (x, y, z) (integer, half-width space delimited)
The second line is the coordinates of the enemy (x, y, z) (integer, half-width space delimiter)
The third line is the coordinates of vertex 1 of the barrier (x, y, z) (integer, half-width space delimiter)
The fourth line is the coordinates (x, y, z) of the vertex 2 of the barrier (integer, half-width space delimiter)
The fifth line is the coordinates (x, y, z) of the vertex 3 of the barrier (integer, half-width space delimiter)
Output
Output on one line with HIT or MISS.
Examples
Input
-10 0 0
10 0 0
0 10 0
0 10 10
0 0 10
Output
HIT
Input
-10 6 6
10 6 6
0 10 0
0 10 10
0 0 10
Output
MISS | instruction | 0 | 68,841 | 3 | 137,682 |
"Correct Solution:
```
def det(a,b,c):
return a[0]*b[1]*c[2] + a[2]*b[0]*c[1] + a[1]*b[2]*c[0] - a[2]*b[1]*c[0] - a[1]*b[0]*c[2] - a[0]*b[2]*c[1]
uaz = list(map(int, input().split()))
ene = list(map(int, input().split()))
br1 = list(map(int, input().split()))
br2 = list(map(int, input().split()))
br3 = list(map(int, input().split()))
edge1 = [br2[0] - br1[0], br2[1] - br1[1], br2[2] - br1[2]]
edge2 = [br3[0] - br1[0], br3[1] - br1[1], br3[2] - br1[2]]
ray = [uaz[0] - ene[0], uaz[1] - ene[1], uaz[2] - ene[2]]
rhs = [uaz[0] - br1[0], uaz[1] - br1[1], uaz[2] - br1[2]]
det_abc = det(edge1, edge2, ray)
if det_abc == 0:
print("HIT")
else:
u = det(rhs, edge2, ray)/det_abc
v = det(edge1, rhs, ray)/det_abc
t = det(edge1, edge2, rhs)/det_abc
if 0.0 <= u <= 1.0 and 0.0 <= v <= 1.0 and u+v <= 1.0 and 0.0 < t <= 1.0:
print("MISS")
else:
print("HIT")
``` | output | 1 | 68,841 | 3 | 137,683 |
Provide a correct Python 3 solution for this coding contest problem.
Stellar history 2005.11.5. You are about to engage an enemy spacecraft as the captain of the UAZ Advance spacecraft. Fortunately, the enemy spaceship is still unnoticed. In addition, the space coordinates of the enemy are already known, and the "feather cannon" that emits a powerful straight beam is ready to launch. After that, I just issue a launch command.
However, there is an energy barrier installed by the enemy in outer space. The barrier is triangular and bounces off the "feather cannon" beam. Also, if the beam hits the barrier, the enemy will notice and escape. If you cannot determine that you will hit in advance, you will not be able to issue a launch command.
Therefore, enter the cosmic coordinates (three-dimensional coordinates x, y, z) of the UAZ Advance, enemy, and barrier positions, and if the beam avoids the barrier and hits the enemy, "HIT", if it hits the barrier " Create a program that outputs "MISS".
However, the barrier is only for those that look like a triangle from the Advance issue, and nothing that looks like a line segment is crushed. Barriers are also valid at boundaries containing triangular vertices and shall bounce the beam. Also, if the enemy is in the barrier, output "MISS".
Constraints
* -100 β€ x, y, z β€ 100
* The UAZ Advance and the enemy are never in the same position.
Input
The format of the input data is as follows:
The first line is the coordinates of UAZ Advance (x, y, z) (integer, half-width space delimited)
The second line is the coordinates of the enemy (x, y, z) (integer, half-width space delimiter)
The third line is the coordinates of vertex 1 of the barrier (x, y, z) (integer, half-width space delimiter)
The fourth line is the coordinates (x, y, z) of the vertex 2 of the barrier (integer, half-width space delimiter)
The fifth line is the coordinates (x, y, z) of the vertex 3 of the barrier (integer, half-width space delimiter)
Output
Output on one line with HIT or MISS.
Examples
Input
-10 0 0
10 0 0
0 10 0
0 10 10
0 0 10
Output
HIT
Input
-10 6 6
10 6 6
0 10 0
0 10 10
0 0 10
Output
MISS | instruction | 0 | 68,842 | 3 | 137,684 |
"Correct Solution:
```
# -*- coding: utf-8 -*-
import sys
import os
import math
import random
# refs
# https://shikousakugo.wordpress.com/2012/06/27/ray-intersection-2/
def det(a, b, c):
return + a[0] * b[1] * c[2] \
+ a[2] * b[0] * c[1] \
+ a[1] * b[2] * c[0] \
- a[2] * b[1] * c[0] \
- a[1] * b[0] * c[2] \
- a[0] * b[2] * c[1]
def sub(v0, v1):
# v0 - v1
return (v0[0] - v1[0], v0[1] - v1[1], v0[2] - v1[2])
# me
p0 = list(map(int, input().split()))
# enemy
p1 = list(map(int, input().split()))
# barrier
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
a = sub(p1, p0)
b = sub(A, B)
c = sub(A, C)
d = sub(A, p0)
EPS = 0.0000001
lower = -EPS
upper = 1 + EPS
denom = det(a, b, c)
if denom != 0:
t = det(d, b, c) / denom
u = det(a, d, c) / denom
v = det(a, b, d) / denom
if t < lower:
print('HIT')
# hit barrier
elif lower < t < upper and lower <= u <= upper and lower <= v <= upper and lower <= u + v <= upper:
print('MISS')
else:
print('HIT')
else:
print('HIT')
``` | output | 1 | 68,842 | 3 | 137,685 |
Provide a correct Python 3 solution for this coding contest problem.
Stellar history 2005.11.5. You are about to engage an enemy spacecraft as the captain of the UAZ Advance spacecraft. Fortunately, the enemy spaceship is still unnoticed. In addition, the space coordinates of the enemy are already known, and the "feather cannon" that emits a powerful straight beam is ready to launch. After that, I just issue a launch command.
However, there is an energy barrier installed by the enemy in outer space. The barrier is triangular and bounces off the "feather cannon" beam. Also, if the beam hits the barrier, the enemy will notice and escape. If you cannot determine that you will hit in advance, you will not be able to issue a launch command.
Therefore, enter the cosmic coordinates (three-dimensional coordinates x, y, z) of the UAZ Advance, enemy, and barrier positions, and if the beam avoids the barrier and hits the enemy, "HIT", if it hits the barrier " Create a program that outputs "MISS".
However, the barrier is only for those that look like a triangle from the Advance issue, and nothing that looks like a line segment is crushed. Barriers are also valid at boundaries containing triangular vertices and shall bounce the beam. Also, if the enemy is in the barrier, output "MISS".
Constraints
* -100 β€ x, y, z β€ 100
* The UAZ Advance and the enemy are never in the same position.
Input
The format of the input data is as follows:
The first line is the coordinates of UAZ Advance (x, y, z) (integer, half-width space delimited)
The second line is the coordinates of the enemy (x, y, z) (integer, half-width space delimiter)
The third line is the coordinates of vertex 1 of the barrier (x, y, z) (integer, half-width space delimiter)
The fourth line is the coordinates (x, y, z) of the vertex 2 of the barrier (integer, half-width space delimiter)
The fifth line is the coordinates (x, y, z) of the vertex 3 of the barrier (integer, half-width space delimiter)
Output
Output on one line with HIT or MISS.
Examples
Input
-10 0 0
10 0 0
0 10 0
0 10 10
0 0 10
Output
HIT
Input
-10 6 6
10 6 6
0 10 0
0 10 10
0 0 10
Output
MISS | instruction | 0 | 68,843 | 3 | 137,686 |
"Correct Solution:
```
def get_det(a, b, c):
a1, a2, a3 = a
b1, b2, b3 = b
c1, c2, c3 = c
return a1 * b2 * c3 + a3 * b1 * c2 + a2 * b3 * c1 \
- a3 * b2 * c1 - a2 * b1 * c3 - a1 * b3 * c2
def solve():
import sys
f_i = sys.stdin
Sx, Sy, Sz = map(int, f_i.readline().split())
Ex, Ey, Ez = map(int, f_i.readline().split())
B1x, B1y, B1z = map(int, f_i.readline().split())
B2x, B2y, B2z = map(int, f_i.readline().split())
B3x, B3y, B3z = map(int, f_i.readline().split())
a = (B2x - B1x, B2y - B1y, B2z - B1z)
b = (B3x - B1x, B3y - B1y, B3z - B1z)
c = (Sx - Ex, Sy - Ey, Sz - Ez)
detA = get_det(a, b, c)
# the barrier looks like a line segment
if detA == 0:
print("HIT")
return
d = (Sx - B1x, Sy - B1y, Sz - B1z)
s = get_det(d, b, c)
t = get_det(a, d, c)
u = get_det(a, b, d)
if detA > 0:
if s >= 0 and t >= 0 and s + t <= detA and 0 <= u <= detA:
print("MISS")
else:
print("HIT")
else:
if s <= 0 and t <= 0 and s + t >= detA and detA <= u <= 0:
print("MISS")
else:
print("HIT")
solve()
``` | output | 1 | 68,843 | 3 | 137,687 |
Provide a correct Python 3 solution for this coding contest problem.
Stellar history 2005.11.5. You are about to engage an enemy spacecraft as the captain of the UAZ Advance spacecraft. Fortunately, the enemy spaceship is still unnoticed. In addition, the space coordinates of the enemy are already known, and the "feather cannon" that emits a powerful straight beam is ready to launch. After that, I just issue a launch command.
However, there is an energy barrier installed by the enemy in outer space. The barrier is triangular and bounces off the "feather cannon" beam. Also, if the beam hits the barrier, the enemy will notice and escape. If you cannot determine that you will hit in advance, you will not be able to issue a launch command.
Therefore, enter the cosmic coordinates (three-dimensional coordinates x, y, z) of the UAZ Advance, enemy, and barrier positions, and if the beam avoids the barrier and hits the enemy, "HIT", if it hits the barrier " Create a program that outputs "MISS".
However, the barrier is only for those that look like a triangle from the Advance issue, and nothing that looks like a line segment is crushed. Barriers are also valid at boundaries containing triangular vertices and shall bounce the beam. Also, if the enemy is in the barrier, output "MISS".
Constraints
* -100 β€ x, y, z β€ 100
* The UAZ Advance and the enemy are never in the same position.
Input
The format of the input data is as follows:
The first line is the coordinates of UAZ Advance (x, y, z) (integer, half-width space delimited)
The second line is the coordinates of the enemy (x, y, z) (integer, half-width space delimiter)
The third line is the coordinates of vertex 1 of the barrier (x, y, z) (integer, half-width space delimiter)
The fourth line is the coordinates (x, y, z) of the vertex 2 of the barrier (integer, half-width space delimiter)
The fifth line is the coordinates (x, y, z) of the vertex 3 of the barrier (integer, half-width space delimiter)
Output
Output on one line with HIT or MISS.
Examples
Input
-10 0 0
10 0 0
0 10 0
0 10 10
0 0 10
Output
HIT
Input
-10 6 6
10 6 6
0 10 0
0 10 10
0 0 10
Output
MISS | instruction | 0 | 68,844 | 3 | 137,688 |
"Correct Solution:
```
# -*- coding: utf-8 -*-
import sys
import os
import math
import random
# refs
# https://shikousakugo.wordpress.com/2012/06/27/ray-intersection-2/
def det(a, b, c):
return + a[0] * b[1] * c[2] \
+ a[2] * b[0] * c[1] \
+ a[1] * b[2] * c[0] \
- a[2] * b[1] * c[0] \
- a[1] * b[0] * c[2] \
- a[0] * b[2] * c[1]
def sub(v0, v1):
# v0 - v1
return (v0[0] - v1[0], v0[1] - v1[1], v0[2] - v1[2])
# me
p0 = list(map(int, input().split()))
# enemy
p1 = list(map(int, input().split()))
# barrier
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
def solve(p0, p1, A, B, C):
a = sub(p1, p0)
b = sub(A, B)
c = sub(A, C)
d = sub(A, p0)
EPS = 0.0000001
lower = -EPS
upper = 1 + EPS
denom = det(a, b, c)
if denom != 0:
t = det(d, b, c) / denom
u = det(a, d, c) / denom
v = det(a, b, d) / denom
if t < lower:
return 'HIT'
# hit barrier
elif lower < t < upper and lower <= u <= upper and lower <= v <= upper and lower <= u + v <= upper:
return 'MISS'
else:
return 'HIT'
else:
return 'HIT'
def correct_solve(p0, p1, A, B, C):
from fractions import Fraction
def gauss(a):
if not a or len(a) == 0: return None
n = len(a)
for i in range(n):
if a[i][i] == 0:
for j in range(i + 1, n):
if a[j][i] != 0:
for k in range(i, n + 1): a[i][k] += a[j][k]
break
else:
return None
for j in range(n):
if i != j:
r = Fraction(a[j][i], a[i][i])
for k in range(i, n + 1): a[j][k] = a[j][k] - a[i][k] * r
for i in range(n):
x = Fraction(a[i][i], 1)
for j in range(len(a[i])):
a[i][j] /= x
return a
uaz = p0
enemy = [0] + [-x + y for x, y in zip(p1, uaz)]
b0 = [1] + [x - y for x, y in zip(A, uaz)]
b1 = [1] + [x - y for x, y in zip(B, uaz)]
b2 = [1] + [x - y for x, y in zip(C, uaz)]
sol = gauss(list(map(list, zip(b0, b1, b2, enemy, [1, 0, 0, 0]))))
if sol and all(0 <= e[-1] <= 1 for e in sol):
return 'MISS'
else:
return 'HIT'
def rand_v():
return (random.randrange(-100, 100), random.randrange(-100, 100), random.randrange(-100, 100))
if __name__ == '__main__':
res = solve(p0, p1, A, B, C)
print(res)
# while True:
# p0 = rand_v()
# p1 = rand_v()
# A = rand_v()
# B = rand_v()
# C = rand_v()
# result0 = solve(p0, p1, A, B, C)
# result1 = correct_solve(p0, p1, A, B, C)
#
# if result0[0] != result1[0]:
# print(p0, p1, A, B, C)
# print(result0)
# print(result1)
# else:
# print('same')
``` | output | 1 | 68,844 | 3 | 137,689 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Stellar history 2005.11.5. You are about to engage an enemy spacecraft as the captain of the UAZ Advance spacecraft. Fortunately, the enemy spaceship is still unnoticed. In addition, the space coordinates of the enemy are already known, and the "feather cannon" that emits a powerful straight beam is ready to launch. After that, I just issue a launch command.
However, there is an energy barrier installed by the enemy in outer space. The barrier is triangular and bounces off the "feather cannon" beam. Also, if the beam hits the barrier, the enemy will notice and escape. If you cannot determine that you will hit in advance, you will not be able to issue a launch command.
Therefore, enter the cosmic coordinates (three-dimensional coordinates x, y, z) of the UAZ Advance, enemy, and barrier positions, and if the beam avoids the barrier and hits the enemy, "HIT", if it hits the barrier " Create a program that outputs "MISS".
However, the barrier is only for those that look like a triangle from the Advance issue, and nothing that looks like a line segment is crushed. Barriers are also valid at boundaries containing triangular vertices and shall bounce the beam. Also, if the enemy is in the barrier, output "MISS".
Constraints
* -100 β€ x, y, z β€ 100
* The UAZ Advance and the enemy are never in the same position.
Input
The format of the input data is as follows:
The first line is the coordinates of UAZ Advance (x, y, z) (integer, half-width space delimited)
The second line is the coordinates of the enemy (x, y, z) (integer, half-width space delimiter)
The third line is the coordinates of vertex 1 of the barrier (x, y, z) (integer, half-width space delimiter)
The fourth line is the coordinates (x, y, z) of the vertex 2 of the barrier (integer, half-width space delimiter)
The fifth line is the coordinates (x, y, z) of the vertex 3 of the barrier (integer, half-width space delimiter)
Output
Output on one line with HIT or MISS.
Examples
Input
-10 0 0
10 0 0
0 10 0
0 10 10
0 0 10
Output
HIT
Input
-10 6 6
10 6 6
0 10 0
0 10 10
0 0 10
Output
MISS
Submitted Solution:
```
# -*- coding: utf-8 -*-
import sys
import os
import math
# refs
# https://shikousakugo.wordpress.com/2012/06/27/ray-intersection-2/
def det(a, b, c):
return + a[0] * b[1] * c[2] \
+ a[2] * b[0] * c[1] \
+ a[1] * b[2] * c[0] \
- a[2] * b[1] * c[0] \
- a[1] * b[0] * c[2] \
- a[0] * b[2] * c[1]
def sub(v0, v1):
# v0 - v1
return (v0[0] - v1[0], v0[1] - v1[1], v0[2] - v1[2])
# me
p0 = list(map(int, input().split()))
# enemy
p1 = list(map(int, input().split()))
# barrier
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
a = sub(p1, p0)
b = sub(A, B)
c = sub(A, C)
d = sub(A, p0)
EPS = 0.0000001
lower = -EPS
upper = 1 + EPS
denom = det(a, b, c)
if denom > lower:
if denom == 0:
print('HIT')
exit()
t = det(d, b, c) / denom
u = det(a, d, c) / denom
v = det(a, b, d) / denom
# i am on barrier
if -EPS < t < EPS:
print('HIT')
# barrier is not between ours
elif t < 0:
print('HIT')
# hit barrier
elif lower < t < upper and lower <= u <= upper and lower <= v <= upper and lower <= u + v <= upper:
print('MISS')
else:
print('HIT')
else:
print('HIT')
``` | instruction | 0 | 68,845 | 3 | 137,690 |
No | output | 1 | 68,845 | 3 | 137,691 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Stellar history 2005.11.5. You are about to engage an enemy spacecraft as the captain of the UAZ Advance spacecraft. Fortunately, the enemy spaceship is still unnoticed. In addition, the space coordinates of the enemy are already known, and the "feather cannon" that emits a powerful straight beam is ready to launch. After that, I just issue a launch command.
However, there is an energy barrier installed by the enemy in outer space. The barrier is triangular and bounces off the "feather cannon" beam. Also, if the beam hits the barrier, the enemy will notice and escape. If you cannot determine that you will hit in advance, you will not be able to issue a launch command.
Therefore, enter the cosmic coordinates (three-dimensional coordinates x, y, z) of the UAZ Advance, enemy, and barrier positions, and if the beam avoids the barrier and hits the enemy, "HIT", if it hits the barrier " Create a program that outputs "MISS".
However, the barrier is only for those that look like a triangle from the Advance issue, and nothing that looks like a line segment is crushed. Barriers are also valid at boundaries containing triangular vertices and shall bounce the beam. Also, if the enemy is in the barrier, output "MISS".
Constraints
* -100 β€ x, y, z β€ 100
* The UAZ Advance and the enemy are never in the same position.
Input
The format of the input data is as follows:
The first line is the coordinates of UAZ Advance (x, y, z) (integer, half-width space delimited)
The second line is the coordinates of the enemy (x, y, z) (integer, half-width space delimiter)
The third line is the coordinates of vertex 1 of the barrier (x, y, z) (integer, half-width space delimiter)
The fourth line is the coordinates (x, y, z) of the vertex 2 of the barrier (integer, half-width space delimiter)
The fifth line is the coordinates (x, y, z) of the vertex 3 of the barrier (integer, half-width space delimiter)
Output
Output on one line with HIT or MISS.
Examples
Input
-10 0 0
10 0 0
0 10 0
0 10 10
0 0 10
Output
HIT
Input
-10 6 6
10 6 6
0 10 0
0 10 10
0 0 10
Output
MISS
Submitted Solution:
```
# -*- coding: utf-8 -*-
import sys
import os
import math
# refs
# https://shikousakugo.wordpress.com/2012/06/27/ray-intersection-2/
def det(a, b, c):
return a[0] * b[1] * c[2] + \
a[2] * b[0] * c[1] + \
a[1] * b[2] * c[0] - \
a[2] * b[1] * c[0] - \
a[1] * b[0] * c[2] - \
a[0] * b[2] * c[1]
def sub(v0, v1):
# v0 - v1
return (v0[0] - v1[0], v0[1] - v1[1], v0[2] - v1[2])
# me
p0 = list(map(int, input().split()))
# enemy
p1 = list(map(int, input().split()))
# barrier
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
a = sub(p1, p0)
b = sub(A, B)
c = sub(A, C)
d = sub(A, p0)
t = det(d, b, c) / det(a, b, c)
u = det(a, d, c) / det(a, b, c)
v = det(a, b, d) / det(a, b, c)
lower = -0.0000001
upper = 1.0000001
if lower <= u <= upper and lower <= v <= upper and lower <= u + v <= upper:
print('MISS')
else:
print('HIT')
``` | instruction | 0 | 68,846 | 3 | 137,692 |
No | output | 1 | 68,846 | 3 | 137,693 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Stellar history 2005.11.5. You are about to engage an enemy spacecraft as the captain of the UAZ Advance spacecraft. Fortunately, the enemy spaceship is still unnoticed. In addition, the space coordinates of the enemy are already known, and the "feather cannon" that emits a powerful straight beam is ready to launch. After that, I just issue a launch command.
However, there is an energy barrier installed by the enemy in outer space. The barrier is triangular and bounces off the "feather cannon" beam. Also, if the beam hits the barrier, the enemy will notice and escape. If you cannot determine that you will hit in advance, you will not be able to issue a launch command.
Therefore, enter the cosmic coordinates (three-dimensional coordinates x, y, z) of the UAZ Advance, enemy, and barrier positions, and if the beam avoids the barrier and hits the enemy, "HIT", if it hits the barrier " Create a program that outputs "MISS".
However, the barrier is only for those that look like a triangle from the Advance issue, and nothing that looks like a line segment is crushed. Barriers are also valid at boundaries containing triangular vertices and shall bounce the beam. Also, if the enemy is in the barrier, output "MISS".
Constraints
* -100 β€ x, y, z β€ 100
* The UAZ Advance and the enemy are never in the same position.
Input
The format of the input data is as follows:
The first line is the coordinates of UAZ Advance (x, y, z) (integer, half-width space delimited)
The second line is the coordinates of the enemy (x, y, z) (integer, half-width space delimiter)
The third line is the coordinates of vertex 1 of the barrier (x, y, z) (integer, half-width space delimiter)
The fourth line is the coordinates (x, y, z) of the vertex 2 of the barrier (integer, half-width space delimiter)
The fifth line is the coordinates (x, y, z) of the vertex 3 of the barrier (integer, half-width space delimiter)
Output
Output on one line with HIT or MISS.
Examples
Input
-10 0 0
10 0 0
0 10 0
0 10 10
0 0 10
Output
HIT
Input
-10 6 6
10 6 6
0 10 0
0 10 10
0 0 10
Output
MISS
Submitted Solution:
```
# -*- coding: utf-8 -*-
import sys
import os
import math
# refs
# https://shikousakugo.wordpress.com/2012/06/27/ray-intersection-2/
def det(a, b, c):
return + a[0] * b[1] * c[2] \
+ a[2] * b[0] * c[1] \
+ a[1] * b[2] * c[0] \
- a[2] * b[1] * c[0] \
- a[1] * b[0] * c[2] \
- a[0] * b[2] * c[1]
def sub(v0, v1):
# v0 - v1
return (v0[0] - v1[0], v0[1] - v1[1], v0[2] - v1[2])
# me
p0 = list(map(int, input().split()))
# enemy
p1 = list(map(int, input().split()))
# barrier
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
a = sub(p1, p0)
b = sub(A, B)
c = sub(A, C)
d = sub(A, p0)
denom = det(a, b, c)
lower = -0.0000001
upper = 1.0000001
if denom > 0:
t = det(d, b, c) / denom
u = det(a, d, c) / denom
v = det(a, b, d) / denom
if lower <= u <= upper and lower <= v <= upper and lower <= u + v <= upper:
if t > 1:
print('HIT')
else:
print('MISS')
else:
print('HIT')
else:
print('HIT')
``` | instruction | 0 | 68,847 | 3 | 137,694 |
No | output | 1 | 68,847 | 3 | 137,695 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Stellar history 2005.11.5. You are about to engage an enemy spacecraft as the captain of the UAZ Advance spacecraft. Fortunately, the enemy spaceship is still unnoticed. In addition, the space coordinates of the enemy are already known, and the "feather cannon" that emits a powerful straight beam is ready to launch. After that, I just issue a launch command.
However, there is an energy barrier installed by the enemy in outer space. The barrier is triangular and bounces off the "feather cannon" beam. Also, if the beam hits the barrier, the enemy will notice and escape. If you cannot determine that you will hit in advance, you will not be able to issue a launch command.
Therefore, enter the cosmic coordinates (three-dimensional coordinates x, y, z) of the UAZ Advance, enemy, and barrier positions, and if the beam avoids the barrier and hits the enemy, "HIT", if it hits the barrier " Create a program that outputs "MISS".
However, the barrier is only for those that look like a triangle from the Advance issue, and nothing that looks like a line segment is crushed. Barriers are also valid at boundaries containing triangular vertices and shall bounce the beam. Also, if the enemy is in the barrier, output "MISS".
Constraints
* -100 β€ x, y, z β€ 100
* The UAZ Advance and the enemy are never in the same position.
Input
The format of the input data is as follows:
The first line is the coordinates of UAZ Advance (x, y, z) (integer, half-width space delimited)
The second line is the coordinates of the enemy (x, y, z) (integer, half-width space delimiter)
The third line is the coordinates of vertex 1 of the barrier (x, y, z) (integer, half-width space delimiter)
The fourth line is the coordinates (x, y, z) of the vertex 2 of the barrier (integer, half-width space delimiter)
The fifth line is the coordinates (x, y, z) of the vertex 3 of the barrier (integer, half-width space delimiter)
Output
Output on one line with HIT or MISS.
Examples
Input
-10 0 0
10 0 0
0 10 0
0 10 10
0 0 10
Output
HIT
Input
-10 6 6
10 6 6
0 10 0
0 10 10
0 0 10
Output
MISS
Submitted Solution:
```
dot = lambda a,b:sum([a[i]*b[i] for i in range(3)])
cross = lambda a,b:[a[1]*b[2]-a[2]*b[1],a[2]*b[0]-a[0]*b[2],a[0]*b[1]-a[1]*b[0]]
m = lambda a,b:[a[i]-b[i] for i in range(3)]
l = lambda a:(a[0]**2+a[1]**2+a[2]**2)** 0.5
c = lambda a,b:[a*b[i] for i in range(3)]
def A():
L=[list(map(int,input().split())) for i in range(5)]
ab = m(L[1],L[0])
L2 = [m(L[3],L[2]),m(L[4],L[3]),m(L[2],L[4])]
xa = m(L[0],L[2])
xb = m(L[1],L[2])
n = cross(L2[0],L2[1])
n = c(1/l(n), n)
if abs(dot(xa,n)) < 1e10:
return 'MISS'
if abs(dot(ab,n)) < 1e10:
return 'HIT'
if dot(n,xa) * dot(n,xb) > 0:
return 'HIT'
da = abs(dot(n,xa))/l(n)
db = abs(dot(n,xb))/l(n)
a = da / (da + db)
X = [c((1-a),xa)[i] + c(a,xb)[i] + L[2][i] for i in range(3)]
for i in range(1,4):
if dot(n,cross(L2[i-1],m(X,L[2+(i%3)]))) < 0:
return 'HIT'
return "MISS"
print(A())
``` | instruction | 0 | 68,848 | 3 | 137,696 |
No | output | 1 | 68,848 | 3 | 137,697 |
Provide a correct Python 3 solution for this coding contest problem.
Many cats live on the campus of a school. Natsume's daily routine is to pet those cats. However, the cats may be capricious and go for a walk off campus.
The campus site is a rectangle with each side parallel to the x-axis or y-axis and is surrounded by a fence except for the gate, but cats can freely enter and exit through the gate and move over the fence. Sometimes.
One day, Natsume wanted to know how many cats were on campus in order to pet the cats on campus as equally as possible. Your job is to find the number of cats on campus given the location of the campus on the coordinate plane and the coordinates of the cats. However, cats walking on the fence and cats just passing through the gate are also considered to be on campus.
Notes on Submission
Multiple datasets are given in the above format. The first line of input data gives the number of datasets. Create a program that outputs the output for each data set in order in the above format.
Input
On the first line of input, four integers X, Y, W, H are given, separated by a space character. These represent the x-coordinate of the southwestern end of the campus, the y-coordinate of the same point, the east-west width of the campus, and the north-south length of the campus, respectively. These values ββsatisfy -10000 <= X, Y <= 10000 and 0 <W, H <= 10000.
The second line of input is given the number of cats N (0 <N <= 100).
The following N lines are given a set of integers (-50000 <= x, y <= 50000) representing the x, y coordinates of the cat's position, one per line for each cat.
The positive direction on the x-axis is east, the positive direction on the y-axis is north, and all numbers given are integers.
Output
Output the number of cats on campus.
Example
Input
2
1 3 20 10
4
21 13
1 15
10 10
25 10
1 3 20 10
4
21 13
1 15
10 10
25 10
Output
2
2 | instruction | 0 | 68,882 | 3 | 137,764 |
"Correct Solution:
```
n = int(input())
for _ in range(n):
x1, y1, w, h = map(int, input().split())
x2 = x1 + w
y2 = y1 + h
m = int(input())
cnt = 0
for _ in range(m):
x, y = map(int, input().split())
if x1 <= x <= x2 and y1 <= y <= y2:
cnt += 1
print(cnt)
``` | output | 1 | 68,882 | 3 | 137,765 |
Provide a correct Python 3 solution for this coding contest problem.
Many cats live on the campus of a school. Natsume's daily routine is to pet those cats. However, the cats may be capricious and go for a walk off campus.
The campus site is a rectangle with each side parallel to the x-axis or y-axis and is surrounded by a fence except for the gate, but cats can freely enter and exit through the gate and move over the fence. Sometimes.
One day, Natsume wanted to know how many cats were on campus in order to pet the cats on campus as equally as possible. Your job is to find the number of cats on campus given the location of the campus on the coordinate plane and the coordinates of the cats. However, cats walking on the fence and cats just passing through the gate are also considered to be on campus.
Notes on Submission
Multiple datasets are given in the above format. The first line of input data gives the number of datasets. Create a program that outputs the output for each data set in order in the above format.
Input
On the first line of input, four integers X, Y, W, H are given, separated by a space character. These represent the x-coordinate of the southwestern end of the campus, the y-coordinate of the same point, the east-west width of the campus, and the north-south length of the campus, respectively. These values ββsatisfy -10000 <= X, Y <= 10000 and 0 <W, H <= 10000.
The second line of input is given the number of cats N (0 <N <= 100).
The following N lines are given a set of integers (-50000 <= x, y <= 50000) representing the x, y coordinates of the cat's position, one per line for each cat.
The positive direction on the x-axis is east, the positive direction on the y-axis is north, and all numbers given are integers.
Output
Output the number of cats on campus.
Example
Input
2
1 3 20 10
4
21 13
1 15
10 10
25 10
1 3 20 10
4
21 13
1 15
10 10
25 10
Output
2
2 | instruction | 0 | 68,883 | 3 | 137,766 |
"Correct Solution:
```
d = int(input())
for _ in range(d):
x, y, w, h = map(int, input().split())
n = int(input())
ans = 0
for i in range(n):
cx, cy = map(int, input().split())
if x <= cx <= x + w and y <= cy <= y + h:
ans += 1
print(ans)
``` | output | 1 | 68,883 | 3 | 137,767 |
Provide a correct Python 3 solution for this coding contest problem.
Many cats live on the campus of a school. Natsume's daily routine is to pet those cats. However, the cats may be capricious and go for a walk off campus.
The campus site is a rectangle with each side parallel to the x-axis or y-axis and is surrounded by a fence except for the gate, but cats can freely enter and exit through the gate and move over the fence. Sometimes.
One day, Natsume wanted to know how many cats were on campus in order to pet the cats on campus as equally as possible. Your job is to find the number of cats on campus given the location of the campus on the coordinate plane and the coordinates of the cats. However, cats walking on the fence and cats just passing through the gate are also considered to be on campus.
Notes on Submission
Multiple datasets are given in the above format. The first line of input data gives the number of datasets. Create a program that outputs the output for each data set in order in the above format.
Input
On the first line of input, four integers X, Y, W, H are given, separated by a space character. These represent the x-coordinate of the southwestern end of the campus, the y-coordinate of the same point, the east-west width of the campus, and the north-south length of the campus, respectively. These values ββsatisfy -10000 <= X, Y <= 10000 and 0 <W, H <= 10000.
The second line of input is given the number of cats N (0 <N <= 100).
The following N lines are given a set of integers (-50000 <= x, y <= 50000) representing the x, y coordinates of the cat's position, one per line for each cat.
The positive direction on the x-axis is east, the positive direction on the y-axis is north, and all numbers given are integers.
Output
Output the number of cats on campus.
Example
Input
2
1 3 20 10
4
21 13
1 15
10 10
25 10
1 3 20 10
4
21 13
1 15
10 10
25 10
Output
2
2 | instruction | 0 | 68,884 | 3 | 137,768 |
"Correct Solution:
```
for _ in range(int(input())):
x, y, w, h = map(int,input().split())
c = 0
for _ in range(int(input())):
a, b = map(int,input().split())
if x <= a and a <= x + w and y <= b and b <= y + h:c += 1
print(c)
``` | output | 1 | 68,884 | 3 | 137,769 |
Provide a correct Python 3 solution for this coding contest problem.
Many cats live on the campus of a school. Natsume's daily routine is to pet those cats. However, the cats may be capricious and go for a walk off campus.
The campus site is a rectangle with each side parallel to the x-axis or y-axis and is surrounded by a fence except for the gate, but cats can freely enter and exit through the gate and move over the fence. Sometimes.
One day, Natsume wanted to know how many cats were on campus in order to pet the cats on campus as equally as possible. Your job is to find the number of cats on campus given the location of the campus on the coordinate plane and the coordinates of the cats. However, cats walking on the fence and cats just passing through the gate are also considered to be on campus.
Notes on Submission
Multiple datasets are given in the above format. The first line of input data gives the number of datasets. Create a program that outputs the output for each data set in order in the above format.
Input
On the first line of input, four integers X, Y, W, H are given, separated by a space character. These represent the x-coordinate of the southwestern end of the campus, the y-coordinate of the same point, the east-west width of the campus, and the north-south length of the campus, respectively. These values ββsatisfy -10000 <= X, Y <= 10000 and 0 <W, H <= 10000.
The second line of input is given the number of cats N (0 <N <= 100).
The following N lines are given a set of integers (-50000 <= x, y <= 50000) representing the x, y coordinates of the cat's position, one per line for each cat.
The positive direction on the x-axis is east, the positive direction on the y-axis is north, and all numbers given are integers.
Output
Output the number of cats on campus.
Example
Input
2
1 3 20 10
4
21 13
1 15
10 10
25 10
1 3 20 10
4
21 13
1 15
10 10
25 10
Output
2
2 | instruction | 0 | 68,885 | 3 | 137,770 |
"Correct Solution:
```
for _ in range(int(input())):
x,y,w,h=map(int,input().split())
c=0
for _ in range(int(input())):
a,b=map(int,input().split())
if x<=a<=x+w and y<=b<=y+h:c+=1
print(c)
``` | output | 1 | 68,885 | 3 | 137,771 |
Provide a correct Python 3 solution for this coding contest problem.
Many cats live on the campus of a school. Natsume's daily routine is to pet those cats. However, the cats may be capricious and go for a walk off campus.
The campus site is a rectangle with each side parallel to the x-axis or y-axis and is surrounded by a fence except for the gate, but cats can freely enter and exit through the gate and move over the fence. Sometimes.
One day, Natsume wanted to know how many cats were on campus in order to pet the cats on campus as equally as possible. Your job is to find the number of cats on campus given the location of the campus on the coordinate plane and the coordinates of the cats. However, cats walking on the fence and cats just passing through the gate are also considered to be on campus.
Notes on Submission
Multiple datasets are given in the above format. The first line of input data gives the number of datasets. Create a program that outputs the output for each data set in order in the above format.
Input
On the first line of input, four integers X, Y, W, H are given, separated by a space character. These represent the x-coordinate of the southwestern end of the campus, the y-coordinate of the same point, the east-west width of the campus, and the north-south length of the campus, respectively. These values ββsatisfy -10000 <= X, Y <= 10000 and 0 <W, H <= 10000.
The second line of input is given the number of cats N (0 <N <= 100).
The following N lines are given a set of integers (-50000 <= x, y <= 50000) representing the x, y coordinates of the cat's position, one per line for each cat.
The positive direction on the x-axis is east, the positive direction on the y-axis is north, and all numbers given are integers.
Output
Output the number of cats on campus.
Example
Input
2
1 3 20 10
4
21 13
1 15
10 10
25 10
1 3 20 10
4
21 13
1 15
10 10
25 10
Output
2
2 | instruction | 0 | 68,886 | 3 | 137,772 |
"Correct Solution:
```
for _ in range(int(input())):
X,Y,W,H= map(int, input().split())
x1,y1,x2,y2=X,Y,X+W,Y+H
cnt=0
for _ in range(int(input())):
x,y= map(int, input().split())
if (x>=x1 and x<=x2) and (y>=y1 and y<=y2):
cnt+=1
print(cnt)
``` | output | 1 | 68,886 | 3 | 137,773 |
Provide a correct Python 3 solution for this coding contest problem.
Many cats live on the campus of a school. Natsume's daily routine is to pet those cats. However, the cats may be capricious and go for a walk off campus.
The campus site is a rectangle with each side parallel to the x-axis or y-axis and is surrounded by a fence except for the gate, but cats can freely enter and exit through the gate and move over the fence. Sometimes.
One day, Natsume wanted to know how many cats were on campus in order to pet the cats on campus as equally as possible. Your job is to find the number of cats on campus given the location of the campus on the coordinate plane and the coordinates of the cats. However, cats walking on the fence and cats just passing through the gate are also considered to be on campus.
Notes on Submission
Multiple datasets are given in the above format. The first line of input data gives the number of datasets. Create a program that outputs the output for each data set in order in the above format.
Input
On the first line of input, four integers X, Y, W, H are given, separated by a space character. These represent the x-coordinate of the southwestern end of the campus, the y-coordinate of the same point, the east-west width of the campus, and the north-south length of the campus, respectively. These values ββsatisfy -10000 <= X, Y <= 10000 and 0 <W, H <= 10000.
The second line of input is given the number of cats N (0 <N <= 100).
The following N lines are given a set of integers (-50000 <= x, y <= 50000) representing the x, y coordinates of the cat's position, one per line for each cat.
The positive direction on the x-axis is east, the positive direction on the y-axis is north, and all numbers given are integers.
Output
Output the number of cats on campus.
Example
Input
2
1 3 20 10
4
21 13
1 15
10 10
25 10
1 3 20 10
4
21 13
1 15
10 10
25 10
Output
2
2 | instruction | 0 | 68,887 | 3 | 137,774 |
"Correct Solution:
```
d=int(input())
for i in range(d):
X,Y,W,H=map(int,input().split())
count=0
n=int(input())
for j in range(n):
x,y=map(int,input().split())
if X<=x<=X+W and Y<=y<=Y+H:count+=1
print(count)
``` | output | 1 | 68,887 | 3 | 137,775 |
Provide a correct Python 3 solution for this coding contest problem.
Many cats live on the campus of a school. Natsume's daily routine is to pet those cats. However, the cats may be capricious and go for a walk off campus.
The campus site is a rectangle with each side parallel to the x-axis or y-axis and is surrounded by a fence except for the gate, but cats can freely enter and exit through the gate and move over the fence. Sometimes.
One day, Natsume wanted to know how many cats were on campus in order to pet the cats on campus as equally as possible. Your job is to find the number of cats on campus given the location of the campus on the coordinate plane and the coordinates of the cats. However, cats walking on the fence and cats just passing through the gate are also considered to be on campus.
Notes on Submission
Multiple datasets are given in the above format. The first line of input data gives the number of datasets. Create a program that outputs the output for each data set in order in the above format.
Input
On the first line of input, four integers X, Y, W, H are given, separated by a space character. These represent the x-coordinate of the southwestern end of the campus, the y-coordinate of the same point, the east-west width of the campus, and the north-south length of the campus, respectively. These values ββsatisfy -10000 <= X, Y <= 10000 and 0 <W, H <= 10000.
The second line of input is given the number of cats N (0 <N <= 100).
The following N lines are given a set of integers (-50000 <= x, y <= 50000) representing the x, y coordinates of the cat's position, one per line for each cat.
The positive direction on the x-axis is east, the positive direction on the y-axis is north, and all numbers given are integers.
Output
Output the number of cats on campus.
Example
Input
2
1 3 20 10
4
21 13
1 15
10 10
25 10
1 3 20 10
4
21 13
1 15
10 10
25 10
Output
2
2 | instruction | 0 | 68,888 | 3 | 137,776 |
"Correct Solution:
```
t = int(input())
for _ in range(t):
x, y, w, h = map(int, input().split())
n = int(input())
ans = 0
for _ in range(n):
cx, cy = map(int, input().split())
if x <= cx <= x + w and y <= cy <= y + h:
ans += 1
print(ans)
``` | output | 1 | 68,888 | 3 | 137,777 |
Provide a correct Python 3 solution for this coding contest problem.
Run, Twins
E869120 You started running from home to school at a speed of $ P $ meters per minute.
square1001 noticed E869120's forgotten thing $ A $ minutes after E869120 left home and chased at $ Q $ meters per minute.
Then E869120 noticed something left behind $ B $ minutes after E869120 left home and turned back at $ R $ meters per minute.
E869120 How many minutes after you leave home will the twins meet?
However, E869120 and square1001 will not meet by $ B $ minutes.
Also, assume that there is only one road from E869120 and square1001's house to school, and there are no shortcuts or alternatives.
input
Input is given from standard input in the following format.
$ A $ $ B $
$ P $ $ Q $ $ R $
output
Output the time from when E869120 left home to when E869120 and square1001 meet.
However, insert a line break at the end.
If the absolute error or relative error from the assumed answer is within $ 10 ^ {-3} $, it will be treated as a correct answer.
Constraint
* $ 1 \ leq A \ leq B \ leq 100 $
* $ 1 \ leq Q \ leq P \ leq 100 $
* $ 1 \ leq R \ leq 100 $
* All inputs are integers.
Input example 1
14 86
9 1 20
Output example 1
119.428571428571
Input example 2
14
15 9 2
Output example 2
7.000000000000
Input example 3
67 87
7 4 51
Output example 3
96.618181818182
Example
Input
14 86
9 1 20
Output
119.428571428571 | instruction | 0 | 68,893 | 3 | 137,786 |
"Correct Solution:
```
a, b = map(int, input().split())
p, q, r = map(int, input().split())
x = b + (p*b-q*(b-a)) / (q+r)
print(x)
``` | output | 1 | 68,893 | 3 | 137,787 |
Provide a correct Python 3 solution for this coding contest problem.
Run, Twins
E869120 You started running from home to school at a speed of $ P $ meters per minute.
square1001 noticed E869120's forgotten thing $ A $ minutes after E869120 left home and chased at $ Q $ meters per minute.
Then E869120 noticed something left behind $ B $ minutes after E869120 left home and turned back at $ R $ meters per minute.
E869120 How many minutes after you leave home will the twins meet?
However, E869120 and square1001 will not meet by $ B $ minutes.
Also, assume that there is only one road from E869120 and square1001's house to school, and there are no shortcuts or alternatives.
input
Input is given from standard input in the following format.
$ A $ $ B $
$ P $ $ Q $ $ R $
output
Output the time from when E869120 left home to when E869120 and square1001 meet.
However, insert a line break at the end.
If the absolute error or relative error from the assumed answer is within $ 10 ^ {-3} $, it will be treated as a correct answer.
Constraint
* $ 1 \ leq A \ leq B \ leq 100 $
* $ 1 \ leq Q \ leq P \ leq 100 $
* $ 1 \ leq R \ leq 100 $
* All inputs are integers.
Input example 1
14 86
9 1 20
Output example 1
119.428571428571
Input example 2
14
15 9 2
Output example 2
7.000000000000
Input example 3
67 87
7 4 51
Output example 3
96.618181818182
Example
Input
14 86
9 1 20
Output
119.428571428571 | instruction | 0 | 68,894 | 3 | 137,788 |
"Correct Solution:
```
a, b=map(int, input().split())
p, q, r=map(int, input().split())
print((p*b+q*a+r*b)/(q+r))
``` | output | 1 | 68,894 | 3 | 137,789 |
Provide a correct Python 3 solution for this coding contest problem.
Run, Twins
E869120 You started running from home to school at a speed of $ P $ meters per minute.
square1001 noticed E869120's forgotten thing $ A $ minutes after E869120 left home and chased at $ Q $ meters per minute.
Then E869120 noticed something left behind $ B $ minutes after E869120 left home and turned back at $ R $ meters per minute.
E869120 How many minutes after you leave home will the twins meet?
However, E869120 and square1001 will not meet by $ B $ minutes.
Also, assume that there is only one road from E869120 and square1001's house to school, and there are no shortcuts or alternatives.
input
Input is given from standard input in the following format.
$ A $ $ B $
$ P $ $ Q $ $ R $
output
Output the time from when E869120 left home to when E869120 and square1001 meet.
However, insert a line break at the end.
If the absolute error or relative error from the assumed answer is within $ 10 ^ {-3} $, it will be treated as a correct answer.
Constraint
* $ 1 \ leq A \ leq B \ leq 100 $
* $ 1 \ leq Q \ leq P \ leq 100 $
* $ 1 \ leq R \ leq 100 $
* All inputs are integers.
Input example 1
14 86
9 1 20
Output example 1
119.428571428571
Input example 2
14
15 9 2
Output example 2
7.000000000000
Input example 3
67 87
7 4 51
Output example 3
96.618181818182
Example
Input
14 86
9 1 20
Output
119.428571428571 | instruction | 0 | 68,895 | 3 | 137,790 |
"Correct Solution:
```
a, b = [int(_) for _ in input().split()]
p, q, r = [int(_) for _ in input().split()]
print(b + (b*p - (b-a)*q) / (q + r))
``` | output | 1 | 68,895 | 3 | 137,791 |
Provide a correct Python 3 solution for this coding contest problem.
Run, Twins
E869120 You started running from home to school at a speed of $ P $ meters per minute.
square1001 noticed E869120's forgotten thing $ A $ minutes after E869120 left home and chased at $ Q $ meters per minute.
Then E869120 noticed something left behind $ B $ minutes after E869120 left home and turned back at $ R $ meters per minute.
E869120 How many minutes after you leave home will the twins meet?
However, E869120 and square1001 will not meet by $ B $ minutes.
Also, assume that there is only one road from E869120 and square1001's house to school, and there are no shortcuts or alternatives.
input
Input is given from standard input in the following format.
$ A $ $ B $
$ P $ $ Q $ $ R $
output
Output the time from when E869120 left home to when E869120 and square1001 meet.
However, insert a line break at the end.
If the absolute error or relative error from the assumed answer is within $ 10 ^ {-3} $, it will be treated as a correct answer.
Constraint
* $ 1 \ leq A \ leq B \ leq 100 $
* $ 1 \ leq Q \ leq P \ leq 100 $
* $ 1 \ leq R \ leq 100 $
* All inputs are integers.
Input example 1
14 86
9 1 20
Output example 1
119.428571428571
Input example 2
14
15 9 2
Output example 2
7.000000000000
Input example 3
67 87
7 4 51
Output example 3
96.618181818182
Example
Input
14 86
9 1 20
Output
119.428571428571 | instruction | 0 | 68,896 | 3 | 137,792 |
"Correct Solution:
```
A, B = map(int,input().split())
P, Q, R = map(int,input().split())
print((B*(P+R)+A*Q)/(R+Q))
``` | output | 1 | 68,896 | 3 | 137,793 |
Provide a correct Python 3 solution for this coding contest problem.
Run, Twins
E869120 You started running from home to school at a speed of $ P $ meters per minute.
square1001 noticed E869120's forgotten thing $ A $ minutes after E869120 left home and chased at $ Q $ meters per minute.
Then E869120 noticed something left behind $ B $ minutes after E869120 left home and turned back at $ R $ meters per minute.
E869120 How many minutes after you leave home will the twins meet?
However, E869120 and square1001 will not meet by $ B $ minutes.
Also, assume that there is only one road from E869120 and square1001's house to school, and there are no shortcuts or alternatives.
input
Input is given from standard input in the following format.
$ A $ $ B $
$ P $ $ Q $ $ R $
output
Output the time from when E869120 left home to when E869120 and square1001 meet.
However, insert a line break at the end.
If the absolute error or relative error from the assumed answer is within $ 10 ^ {-3} $, it will be treated as a correct answer.
Constraint
* $ 1 \ leq A \ leq B \ leq 100 $
* $ 1 \ leq Q \ leq P \ leq 100 $
* $ 1 \ leq R \ leq 100 $
* All inputs are integers.
Input example 1
14 86
9 1 20
Output example 1
119.428571428571
Input example 2
14
15 9 2
Output example 2
7.000000000000
Input example 3
67 87
7 4 51
Output example 3
96.618181818182
Example
Input
14 86
9 1 20
Output
119.428571428571 | instruction | 0 | 68,897 | 3 | 137,794 |
"Correct Solution:
```
a,b=map(int,input().split())
p,q,r=map(int,input().split())
t=b*p-(b-a)*q
print(t/(q+r)+b)
``` | output | 1 | 68,897 | 3 | 137,795 |
Provide a correct Python 3 solution for this coding contest problem.
Run, Twins
E869120 You started running from home to school at a speed of $ P $ meters per minute.
square1001 noticed E869120's forgotten thing $ A $ minutes after E869120 left home and chased at $ Q $ meters per minute.
Then E869120 noticed something left behind $ B $ minutes after E869120 left home and turned back at $ R $ meters per minute.
E869120 How many minutes after you leave home will the twins meet?
However, E869120 and square1001 will not meet by $ B $ minutes.
Also, assume that there is only one road from E869120 and square1001's house to school, and there are no shortcuts or alternatives.
input
Input is given from standard input in the following format.
$ A $ $ B $
$ P $ $ Q $ $ R $
output
Output the time from when E869120 left home to when E869120 and square1001 meet.
However, insert a line break at the end.
If the absolute error or relative error from the assumed answer is within $ 10 ^ {-3} $, it will be treated as a correct answer.
Constraint
* $ 1 \ leq A \ leq B \ leq 100 $
* $ 1 \ leq Q \ leq P \ leq 100 $
* $ 1 \ leq R \ leq 100 $
* All inputs are integers.
Input example 1
14 86
9 1 20
Output example 1
119.428571428571
Input example 2
14
15 9 2
Output example 2
7.000000000000
Input example 3
67 87
7 4 51
Output example 3
96.618181818182
Example
Input
14 86
9 1 20
Output
119.428571428571 | instruction | 0 | 68,898 | 3 | 137,796 |
"Correct Solution:
```
A,B=map(int,input().split())
P,Q,R=map(int,input().split())
print((B*(P-Q)+Q*A)/(Q+R)+B)
``` | output | 1 | 68,898 | 3 | 137,797 |
Provide a correct Python 3 solution for this coding contest problem.
Run, Twins
E869120 You started running from home to school at a speed of $ P $ meters per minute.
square1001 noticed E869120's forgotten thing $ A $ minutes after E869120 left home and chased at $ Q $ meters per minute.
Then E869120 noticed something left behind $ B $ minutes after E869120 left home and turned back at $ R $ meters per minute.
E869120 How many minutes after you leave home will the twins meet?
However, E869120 and square1001 will not meet by $ B $ minutes.
Also, assume that there is only one road from E869120 and square1001's house to school, and there are no shortcuts or alternatives.
input
Input is given from standard input in the following format.
$ A $ $ B $
$ P $ $ Q $ $ R $
output
Output the time from when E869120 left home to when E869120 and square1001 meet.
However, insert a line break at the end.
If the absolute error or relative error from the assumed answer is within $ 10 ^ {-3} $, it will be treated as a correct answer.
Constraint
* $ 1 \ leq A \ leq B \ leq 100 $
* $ 1 \ leq Q \ leq P \ leq 100 $
* $ 1 \ leq R \ leq 100 $
* All inputs are integers.
Input example 1
14 86
9 1 20
Output example 1
119.428571428571
Input example 2
14
15 9 2
Output example 2
7.000000000000
Input example 3
67 87
7 4 51
Output example 3
96.618181818182
Example
Input
14 86
9 1 20
Output
119.428571428571 | instruction | 0 | 68,899 | 3 | 137,798 |
"Correct Solution:
```
import sys
sys.setrecursionlimit(10 ** 6)
def MI(): return map(int, sys.stdin.readline().split())
def main():
a,b=MI()
p,q,r=MI()
print((p*b+a*q+r*b)/(q+r))
main()
``` | output | 1 | 68,899 | 3 | 137,799 |
Provide a correct Python 3 solution for this coding contest problem.
Run, Twins
E869120 You started running from home to school at a speed of $ P $ meters per minute.
square1001 noticed E869120's forgotten thing $ A $ minutes after E869120 left home and chased at $ Q $ meters per minute.
Then E869120 noticed something left behind $ B $ minutes after E869120 left home and turned back at $ R $ meters per minute.
E869120 How many minutes after you leave home will the twins meet?
However, E869120 and square1001 will not meet by $ B $ minutes.
Also, assume that there is only one road from E869120 and square1001's house to school, and there are no shortcuts or alternatives.
input
Input is given from standard input in the following format.
$ A $ $ B $
$ P $ $ Q $ $ R $
output
Output the time from when E869120 left home to when E869120 and square1001 meet.
However, insert a line break at the end.
If the absolute error or relative error from the assumed answer is within $ 10 ^ {-3} $, it will be treated as a correct answer.
Constraint
* $ 1 \ leq A \ leq B \ leq 100 $
* $ 1 \ leq Q \ leq P \ leq 100 $
* $ 1 \ leq R \ leq 100 $
* All inputs are integers.
Input example 1
14 86
9 1 20
Output example 1
119.428571428571
Input example 2
14
15 9 2
Output example 2
7.000000000000
Input example 3
67 87
7 4 51
Output example 3
96.618181818182
Example
Input
14 86
9 1 20
Output
119.428571428571 | instruction | 0 | 68,900 | 3 | 137,800 |
"Correct Solution:
```
a,b = map(int,input().split())
p,q,r= map(int,input().split())
#εΎγ«εΊδΌγ
d = p*b-(b-a)*q
print(d/(q+r)+b)
``` | output | 1 | 68,900 | 3 | 137,801 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob is a pirate looking for the greatest treasure the world has ever seen. The treasure is located at the point T, which coordinates to be found out.
Bob travelled around the world and collected clues of the treasure location at n obelisks. These clues were in an ancient language, and he has only decrypted them at home. Since he does not know which clue belongs to which obelisk, finding the treasure might pose a challenge. Can you help him?
As everyone knows, the world is a two-dimensional plane. The i-th obelisk is at integer coordinates (x_i, y_i). The j-th clue consists of 2 integers (a_j, b_j) and belongs to the obelisk p_j, where p is some (unknown) permutation on n elements. It means that the treasure is located at T=(x_{p_j} + a_j, y_{p_j} + b_j). This point T is the same for all clues.
In other words, each clue belongs to exactly one of the obelisks, and each obelisk has exactly one clue that belongs to it. A clue represents the vector from the obelisk to the treasure. The clues must be distributed among the obelisks in such a way that they all point to the same position of the treasure.
Your task is to find the coordinates of the treasure. If there are multiple solutions, you may print any of them.
Note that you don't need to find the permutation. Permutations are used only in order to explain the problem.
Input
The first line contains an integer n (1 β€ n β€ 1000) β the number of obelisks, that is also equal to the number of clues.
Each of the next n lines contains two integers x_i, y_i (-10^6 β€ x_i, y_i β€ 10^6) β the coordinates of the i-th obelisk. All coordinates are distinct, that is x_i β x_j or y_i β y_j will be satisfied for every (i, j) such that i β j.
Each of the next n lines contains two integers a_i, b_i (-2 β
10^6 β€ a_i, b_i β€ 2 β
10^6) β the direction of the i-th clue. All coordinates are distinct, that is a_i β a_j or b_i β b_j will be satisfied for every (i, j) such that i β j.
It is guaranteed that there exists a permutation p, such that for all i,j it holds \left(x_{p_i} + a_i, y_{p_i} + b_i\right) = \left(x_{p_j} + a_j, y_{p_j} + b_j\right).
Output
Output a single line containing two integers T_x, T_y β the coordinates of the treasure.
If there are multiple answers, you may print any of them.
Examples
Input
2
2 5
-6 4
7 -2
-1 -3
Output
1 2
Input
4
2 2
8 2
-7 0
-2 6
1 -14
16 -12
11 -18
7 -14
Output
9 -12
Note
As n = 2, we can consider all permutations on two elements.
If p = [1, 2], then the obelisk (2, 5) holds the clue (7, -2), which means that the treasure is hidden at (9, 3). The second obelisk (-6, 4) would give the clue (-1,-3) and the treasure at (-7, 1). However, both obelisks must give the same location, hence this is clearly not the correct permutation.
If the hidden permutation is [2, 1], then the first clue belongs to the second obelisk and the second clue belongs to the first obelisk. Hence (-6, 4) + (7, -2) = (2,5) + (-1,-3) = (1, 2), so T = (1,2) is the location of the treasure.
<image>
In the second sample, the hidden permutation is [2, 3, 4, 1]. | instruction | 0 | 68,959 | 3 | 137,918 |
Tags: brute force, constructive algorithms, greedy, implementation
Correct Solution:
```
n = int(input())
obelisk = [list(map(int, input().split())) for _ in range(n)]
clues = [tuple(map(int, input().split())) for _ in range(n)]
d = set(clues)
first = obelisk[0]
for clue in clues:
treasure = [0, 0]
treasure[0] = first[0]+clue[0]
treasure[1] = first[1] + clue[1]
f = False
for o in obelisk:
t = (treasure[0]-o[0], treasure[1]-o[1])
if t not in d:
f = True
break
if not f:
print(*treasure)
``` | output | 1 | 68,959 | 3 | 137,919 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob is a pirate looking for the greatest treasure the world has ever seen. The treasure is located at the point T, which coordinates to be found out.
Bob travelled around the world and collected clues of the treasure location at n obelisks. These clues were in an ancient language, and he has only decrypted them at home. Since he does not know which clue belongs to which obelisk, finding the treasure might pose a challenge. Can you help him?
As everyone knows, the world is a two-dimensional plane. The i-th obelisk is at integer coordinates (x_i, y_i). The j-th clue consists of 2 integers (a_j, b_j) and belongs to the obelisk p_j, where p is some (unknown) permutation on n elements. It means that the treasure is located at T=(x_{p_j} + a_j, y_{p_j} + b_j). This point T is the same for all clues.
In other words, each clue belongs to exactly one of the obelisks, and each obelisk has exactly one clue that belongs to it. A clue represents the vector from the obelisk to the treasure. The clues must be distributed among the obelisks in such a way that they all point to the same position of the treasure.
Your task is to find the coordinates of the treasure. If there are multiple solutions, you may print any of them.
Note that you don't need to find the permutation. Permutations are used only in order to explain the problem.
Input
The first line contains an integer n (1 β€ n β€ 1000) β the number of obelisks, that is also equal to the number of clues.
Each of the next n lines contains two integers x_i, y_i (-10^6 β€ x_i, y_i β€ 10^6) β the coordinates of the i-th obelisk. All coordinates are distinct, that is x_i β x_j or y_i β y_j will be satisfied for every (i, j) such that i β j.
Each of the next n lines contains two integers a_i, b_i (-2 β
10^6 β€ a_i, b_i β€ 2 β
10^6) β the direction of the i-th clue. All coordinates are distinct, that is a_i β a_j or b_i β b_j will be satisfied for every (i, j) such that i β j.
It is guaranteed that there exists a permutation p, such that for all i,j it holds \left(x_{p_i} + a_i, y_{p_i} + b_i\right) = \left(x_{p_j} + a_j, y_{p_j} + b_j\right).
Output
Output a single line containing two integers T_x, T_y β the coordinates of the treasure.
If there are multiple answers, you may print any of them.
Examples
Input
2
2 5
-6 4
7 -2
-1 -3
Output
1 2
Input
4
2 2
8 2
-7 0
-2 6
1 -14
16 -12
11 -18
7 -14
Output
9 -12
Note
As n = 2, we can consider all permutations on two elements.
If p = [1, 2], then the obelisk (2, 5) holds the clue (7, -2), which means that the treasure is hidden at (9, 3). The second obelisk (-6, 4) would give the clue (-1,-3) and the treasure at (-7, 1). However, both obelisks must give the same location, hence this is clearly not the correct permutation.
If the hidden permutation is [2, 1], then the first clue belongs to the second obelisk and the second clue belongs to the first obelisk. Hence (-6, 4) + (7, -2) = (2,5) + (-1,-3) = (1, 2), so T = (1,2) is the location of the treasure.
<image>
In the second sample, the hidden permutation is [2, 3, 4, 1]. | instruction | 0 | 68,960 | 3 | 137,920 |
Tags: brute force, constructive algorithms, greedy, implementation
Correct Solution:
```
obilisks = int(input())
xtreasure = 0;
ytreasure = 0;
for i in range(obilisks+obilisks):
xpos, ypos = [int(x) for x in input().split()]
xtreasure += xpos
ytreasure += ypos
print(xtreasure//obilisks, ytreasure//obilisks)
``` | output | 1 | 68,960 | 3 | 137,921 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob is a pirate looking for the greatest treasure the world has ever seen. The treasure is located at the point T, which coordinates to be found out.
Bob travelled around the world and collected clues of the treasure location at n obelisks. These clues were in an ancient language, and he has only decrypted them at home. Since he does not know which clue belongs to which obelisk, finding the treasure might pose a challenge. Can you help him?
As everyone knows, the world is a two-dimensional plane. The i-th obelisk is at integer coordinates (x_i, y_i). The j-th clue consists of 2 integers (a_j, b_j) and belongs to the obelisk p_j, where p is some (unknown) permutation on n elements. It means that the treasure is located at T=(x_{p_j} + a_j, y_{p_j} + b_j). This point T is the same for all clues.
In other words, each clue belongs to exactly one of the obelisks, and each obelisk has exactly one clue that belongs to it. A clue represents the vector from the obelisk to the treasure. The clues must be distributed among the obelisks in such a way that they all point to the same position of the treasure.
Your task is to find the coordinates of the treasure. If there are multiple solutions, you may print any of them.
Note that you don't need to find the permutation. Permutations are used only in order to explain the problem.
Input
The first line contains an integer n (1 β€ n β€ 1000) β the number of obelisks, that is also equal to the number of clues.
Each of the next n lines contains two integers x_i, y_i (-10^6 β€ x_i, y_i β€ 10^6) β the coordinates of the i-th obelisk. All coordinates are distinct, that is x_i β x_j or y_i β y_j will be satisfied for every (i, j) such that i β j.
Each of the next n lines contains two integers a_i, b_i (-2 β
10^6 β€ a_i, b_i β€ 2 β
10^6) β the direction of the i-th clue. All coordinates are distinct, that is a_i β a_j or b_i β b_j will be satisfied for every (i, j) such that i β j.
It is guaranteed that there exists a permutation p, such that for all i,j it holds \left(x_{p_i} + a_i, y_{p_i} + b_i\right) = \left(x_{p_j} + a_j, y_{p_j} + b_j\right).
Output
Output a single line containing two integers T_x, T_y β the coordinates of the treasure.
If there are multiple answers, you may print any of them.
Examples
Input
2
2 5
-6 4
7 -2
-1 -3
Output
1 2
Input
4
2 2
8 2
-7 0
-2 6
1 -14
16 -12
11 -18
7 -14
Output
9 -12
Note
As n = 2, we can consider all permutations on two elements.
If p = [1, 2], then the obelisk (2, 5) holds the clue (7, -2), which means that the treasure is hidden at (9, 3). The second obelisk (-6, 4) would give the clue (-1,-3) and the treasure at (-7, 1). However, both obelisks must give the same location, hence this is clearly not the correct permutation.
If the hidden permutation is [2, 1], then the first clue belongs to the second obelisk and the second clue belongs to the first obelisk. Hence (-6, 4) + (7, -2) = (2,5) + (-1,-3) = (1, 2), so T = (1,2) is the location of the treasure.
<image>
In the second sample, the hidden permutation is [2, 3, 4, 1]. | instruction | 0 | 68,961 | 3 | 137,922 |
Tags: brute force, constructive algorithms, greedy, implementation
Correct Solution:
```
n=int(input())
Overallx=[]
Overally=[]
for i in range(0,n):
x,y=[int(x) for x in input().split()]
Overallx.append(x)
Overally.append(y)
for i in range(0,n):
x,y=[int(x) for x in input().split()]
Overallx.append(x)
Overally.append(y)
Overallx.sort()
Overally.sort()
x=Overallx[0]+Overallx[-1]
y=Overally[0]+Overally[-1]
print(x,y)
``` | output | 1 | 68,961 | 3 | 137,923 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob is a pirate looking for the greatest treasure the world has ever seen. The treasure is located at the point T, which coordinates to be found out.
Bob travelled around the world and collected clues of the treasure location at n obelisks. These clues were in an ancient language, and he has only decrypted them at home. Since he does not know which clue belongs to which obelisk, finding the treasure might pose a challenge. Can you help him?
As everyone knows, the world is a two-dimensional plane. The i-th obelisk is at integer coordinates (x_i, y_i). The j-th clue consists of 2 integers (a_j, b_j) and belongs to the obelisk p_j, where p is some (unknown) permutation on n elements. It means that the treasure is located at T=(x_{p_j} + a_j, y_{p_j} + b_j). This point T is the same for all clues.
In other words, each clue belongs to exactly one of the obelisks, and each obelisk has exactly one clue that belongs to it. A clue represents the vector from the obelisk to the treasure. The clues must be distributed among the obelisks in such a way that they all point to the same position of the treasure.
Your task is to find the coordinates of the treasure. If there are multiple solutions, you may print any of them.
Note that you don't need to find the permutation. Permutations are used only in order to explain the problem.
Input
The first line contains an integer n (1 β€ n β€ 1000) β the number of obelisks, that is also equal to the number of clues.
Each of the next n lines contains two integers x_i, y_i (-10^6 β€ x_i, y_i β€ 10^6) β the coordinates of the i-th obelisk. All coordinates are distinct, that is x_i β x_j or y_i β y_j will be satisfied for every (i, j) such that i β j.
Each of the next n lines contains two integers a_i, b_i (-2 β
10^6 β€ a_i, b_i β€ 2 β
10^6) β the direction of the i-th clue. All coordinates are distinct, that is a_i β a_j or b_i β b_j will be satisfied for every (i, j) such that i β j.
It is guaranteed that there exists a permutation p, such that for all i,j it holds \left(x_{p_i} + a_i, y_{p_i} + b_i\right) = \left(x_{p_j} + a_j, y_{p_j} + b_j\right).
Output
Output a single line containing two integers T_x, T_y β the coordinates of the treasure.
If there are multiple answers, you may print any of them.
Examples
Input
2
2 5
-6 4
7 -2
-1 -3
Output
1 2
Input
4
2 2
8 2
-7 0
-2 6
1 -14
16 -12
11 -18
7 -14
Output
9 -12
Note
As n = 2, we can consider all permutations on two elements.
If p = [1, 2], then the obelisk (2, 5) holds the clue (7, -2), which means that the treasure is hidden at (9, 3). The second obelisk (-6, 4) would give the clue (-1,-3) and the treasure at (-7, 1). However, both obelisks must give the same location, hence this is clearly not the correct permutation.
If the hidden permutation is [2, 1], then the first clue belongs to the second obelisk and the second clue belongs to the first obelisk. Hence (-6, 4) + (7, -2) = (2,5) + (-1,-3) = (1, 2), so T = (1,2) is the location of the treasure.
<image>
In the second sample, the hidden permutation is [2, 3, 4, 1]. | instruction | 0 | 68,962 | 3 | 137,924 |
Tags: brute force, constructive algorithms, greedy, implementation
Correct Solution:
```
from collections import Counter
def read():
return int(input())
def readlist():
return list(map(int, input().split()))
def readmap():
return map(int, input().split())
n = read()
X = []
Y = []
for _ in range(n):
x, y = readmap()
X.append(x)
Y.append(y)
A = []
B = []
for _ in range(n):
a, b = readmap()
A.append(a)
B.append(b)
c = Counter()
for i in range(n):
for j in range(n):
coordinate = (X[i] + A[j], Y[i] + B[j])
c[coordinate] += 1
for k, v in c.items():
if v >= n:
print(k[0], k[1])
``` | output | 1 | 68,962 | 3 | 137,925 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob is a pirate looking for the greatest treasure the world has ever seen. The treasure is located at the point T, which coordinates to be found out.
Bob travelled around the world and collected clues of the treasure location at n obelisks. These clues were in an ancient language, and he has only decrypted them at home. Since he does not know which clue belongs to which obelisk, finding the treasure might pose a challenge. Can you help him?
As everyone knows, the world is a two-dimensional plane. The i-th obelisk is at integer coordinates (x_i, y_i). The j-th clue consists of 2 integers (a_j, b_j) and belongs to the obelisk p_j, where p is some (unknown) permutation on n elements. It means that the treasure is located at T=(x_{p_j} + a_j, y_{p_j} + b_j). This point T is the same for all clues.
In other words, each clue belongs to exactly one of the obelisks, and each obelisk has exactly one clue that belongs to it. A clue represents the vector from the obelisk to the treasure. The clues must be distributed among the obelisks in such a way that they all point to the same position of the treasure.
Your task is to find the coordinates of the treasure. If there are multiple solutions, you may print any of them.
Note that you don't need to find the permutation. Permutations are used only in order to explain the problem.
Input
The first line contains an integer n (1 β€ n β€ 1000) β the number of obelisks, that is also equal to the number of clues.
Each of the next n lines contains two integers x_i, y_i (-10^6 β€ x_i, y_i β€ 10^6) β the coordinates of the i-th obelisk. All coordinates are distinct, that is x_i β x_j or y_i β y_j will be satisfied for every (i, j) such that i β j.
Each of the next n lines contains two integers a_i, b_i (-2 β
10^6 β€ a_i, b_i β€ 2 β
10^6) β the direction of the i-th clue. All coordinates are distinct, that is a_i β a_j or b_i β b_j will be satisfied for every (i, j) such that i β j.
It is guaranteed that there exists a permutation p, such that for all i,j it holds \left(x_{p_i} + a_i, y_{p_i} + b_i\right) = \left(x_{p_j} + a_j, y_{p_j} + b_j\right).
Output
Output a single line containing two integers T_x, T_y β the coordinates of the treasure.
If there are multiple answers, you may print any of them.
Examples
Input
2
2 5
-6 4
7 -2
-1 -3
Output
1 2
Input
4
2 2
8 2
-7 0
-2 6
1 -14
16 -12
11 -18
7 -14
Output
9 -12
Note
As n = 2, we can consider all permutations on two elements.
If p = [1, 2], then the obelisk (2, 5) holds the clue (7, -2), which means that the treasure is hidden at (9, 3). The second obelisk (-6, 4) would give the clue (-1,-3) and the treasure at (-7, 1). However, both obelisks must give the same location, hence this is clearly not the correct permutation.
If the hidden permutation is [2, 1], then the first clue belongs to the second obelisk and the second clue belongs to the first obelisk. Hence (-6, 4) + (7, -2) = (2,5) + (-1,-3) = (1, 2), so T = (1,2) is the location of the treasure.
<image>
In the second sample, the hidden permutation is [2, 3, 4, 1]. | instruction | 0 | 68,963 | 3 | 137,926 |
Tags: brute force, constructive algorithms, greedy, implementation
Correct Solution:
```
n = int(input())
ob = []
q = []
for i in range(n):
ob.append(list(map(int, input().split())))
for i in range(n):
q.append(list(map(int, input().split())))
ob.sort()
q.sort(reverse=True)
print(ob[0][0] + q[0][0], ob[0][1] + q[0][1])
``` | output | 1 | 68,963 | 3 | 137,927 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob is a pirate looking for the greatest treasure the world has ever seen. The treasure is located at the point T, which coordinates to be found out.
Bob travelled around the world and collected clues of the treasure location at n obelisks. These clues were in an ancient language, and he has only decrypted them at home. Since he does not know which clue belongs to which obelisk, finding the treasure might pose a challenge. Can you help him?
As everyone knows, the world is a two-dimensional plane. The i-th obelisk is at integer coordinates (x_i, y_i). The j-th clue consists of 2 integers (a_j, b_j) and belongs to the obelisk p_j, where p is some (unknown) permutation on n elements. It means that the treasure is located at T=(x_{p_j} + a_j, y_{p_j} + b_j). This point T is the same for all clues.
In other words, each clue belongs to exactly one of the obelisks, and each obelisk has exactly one clue that belongs to it. A clue represents the vector from the obelisk to the treasure. The clues must be distributed among the obelisks in such a way that they all point to the same position of the treasure.
Your task is to find the coordinates of the treasure. If there are multiple solutions, you may print any of them.
Note that you don't need to find the permutation. Permutations are used only in order to explain the problem.
Input
The first line contains an integer n (1 β€ n β€ 1000) β the number of obelisks, that is also equal to the number of clues.
Each of the next n lines contains two integers x_i, y_i (-10^6 β€ x_i, y_i β€ 10^6) β the coordinates of the i-th obelisk. All coordinates are distinct, that is x_i β x_j or y_i β y_j will be satisfied for every (i, j) such that i β j.
Each of the next n lines contains two integers a_i, b_i (-2 β
10^6 β€ a_i, b_i β€ 2 β
10^6) β the direction of the i-th clue. All coordinates are distinct, that is a_i β a_j or b_i β b_j will be satisfied for every (i, j) such that i β j.
It is guaranteed that there exists a permutation p, such that for all i,j it holds \left(x_{p_i} + a_i, y_{p_i} + b_i\right) = \left(x_{p_j} + a_j, y_{p_j} + b_j\right).
Output
Output a single line containing two integers T_x, T_y β the coordinates of the treasure.
If there are multiple answers, you may print any of them.
Examples
Input
2
2 5
-6 4
7 -2
-1 -3
Output
1 2
Input
4
2 2
8 2
-7 0
-2 6
1 -14
16 -12
11 -18
7 -14
Output
9 -12
Note
As n = 2, we can consider all permutations on two elements.
If p = [1, 2], then the obelisk (2, 5) holds the clue (7, -2), which means that the treasure is hidden at (9, 3). The second obelisk (-6, 4) would give the clue (-1,-3) and the treasure at (-7, 1). However, both obelisks must give the same location, hence this is clearly not the correct permutation.
If the hidden permutation is [2, 1], then the first clue belongs to the second obelisk and the second clue belongs to the first obelisk. Hence (-6, 4) + (7, -2) = (2,5) + (-1,-3) = (1, 2), so T = (1,2) is the location of the treasure.
<image>
In the second sample, the hidden permutation is [2, 3, 4, 1]. | instruction | 0 | 68,964 | 3 | 137,928 |
Tags: brute force, constructive algorithms, greedy, implementation
Correct Solution:
```
n = int(input())
summ1 = 0
summ2 = 0
for i in range(2 * n):
k, m = map(int, input().split())
summ1 += k
summ2 += m
print(summ1 // n, summ2 // n)
``` | output | 1 | 68,964 | 3 | 137,929 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob is a pirate looking for the greatest treasure the world has ever seen. The treasure is located at the point T, which coordinates to be found out.
Bob travelled around the world and collected clues of the treasure location at n obelisks. These clues were in an ancient language, and he has only decrypted them at home. Since he does not know which clue belongs to which obelisk, finding the treasure might pose a challenge. Can you help him?
As everyone knows, the world is a two-dimensional plane. The i-th obelisk is at integer coordinates (x_i, y_i). The j-th clue consists of 2 integers (a_j, b_j) and belongs to the obelisk p_j, where p is some (unknown) permutation on n elements. It means that the treasure is located at T=(x_{p_j} + a_j, y_{p_j} + b_j). This point T is the same for all clues.
In other words, each clue belongs to exactly one of the obelisks, and each obelisk has exactly one clue that belongs to it. A clue represents the vector from the obelisk to the treasure. The clues must be distributed among the obelisks in such a way that they all point to the same position of the treasure.
Your task is to find the coordinates of the treasure. If there are multiple solutions, you may print any of them.
Note that you don't need to find the permutation. Permutations are used only in order to explain the problem.
Input
The first line contains an integer n (1 β€ n β€ 1000) β the number of obelisks, that is also equal to the number of clues.
Each of the next n lines contains two integers x_i, y_i (-10^6 β€ x_i, y_i β€ 10^6) β the coordinates of the i-th obelisk. All coordinates are distinct, that is x_i β x_j or y_i β y_j will be satisfied for every (i, j) such that i β j.
Each of the next n lines contains two integers a_i, b_i (-2 β
10^6 β€ a_i, b_i β€ 2 β
10^6) β the direction of the i-th clue. All coordinates are distinct, that is a_i β a_j or b_i β b_j will be satisfied for every (i, j) such that i β j.
It is guaranteed that there exists a permutation p, such that for all i,j it holds \left(x_{p_i} + a_i, y_{p_i} + b_i\right) = \left(x_{p_j} + a_j, y_{p_j} + b_j\right).
Output
Output a single line containing two integers T_x, T_y β the coordinates of the treasure.
If there are multiple answers, you may print any of them.
Examples
Input
2
2 5
-6 4
7 -2
-1 -3
Output
1 2
Input
4
2 2
8 2
-7 0
-2 6
1 -14
16 -12
11 -18
7 -14
Output
9 -12
Note
As n = 2, we can consider all permutations on two elements.
If p = [1, 2], then the obelisk (2, 5) holds the clue (7, -2), which means that the treasure is hidden at (9, 3). The second obelisk (-6, 4) would give the clue (-1,-3) and the treasure at (-7, 1). However, both obelisks must give the same location, hence this is clearly not the correct permutation.
If the hidden permutation is [2, 1], then the first clue belongs to the second obelisk and the second clue belongs to the first obelisk. Hence (-6, 4) + (7, -2) = (2,5) + (-1,-3) = (1, 2), so T = (1,2) is the location of the treasure.
<image>
In the second sample, the hidden permutation is [2, 3, 4, 1]. | instruction | 0 | 68,965 | 3 | 137,930 |
Tags: brute force, constructive algorithms, greedy, implementation
Correct Solution:
```
n = int(input().strip())
xm,ym = (0,0)
for i in range(2*n):
x,y = list(map(int,input().strip().split()))
xm+=x
ym+=y
print(xm//(n), ym//(n))
``` | output | 1 | 68,965 | 3 | 137,931 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob is a pirate looking for the greatest treasure the world has ever seen. The treasure is located at the point T, which coordinates to be found out.
Bob travelled around the world and collected clues of the treasure location at n obelisks. These clues were in an ancient language, and he has only decrypted them at home. Since he does not know which clue belongs to which obelisk, finding the treasure might pose a challenge. Can you help him?
As everyone knows, the world is a two-dimensional plane. The i-th obelisk is at integer coordinates (x_i, y_i). The j-th clue consists of 2 integers (a_j, b_j) and belongs to the obelisk p_j, where p is some (unknown) permutation on n elements. It means that the treasure is located at T=(x_{p_j} + a_j, y_{p_j} + b_j). This point T is the same for all clues.
In other words, each clue belongs to exactly one of the obelisks, and each obelisk has exactly one clue that belongs to it. A clue represents the vector from the obelisk to the treasure. The clues must be distributed among the obelisks in such a way that they all point to the same position of the treasure.
Your task is to find the coordinates of the treasure. If there are multiple solutions, you may print any of them.
Note that you don't need to find the permutation. Permutations are used only in order to explain the problem.
Input
The first line contains an integer n (1 β€ n β€ 1000) β the number of obelisks, that is also equal to the number of clues.
Each of the next n lines contains two integers x_i, y_i (-10^6 β€ x_i, y_i β€ 10^6) β the coordinates of the i-th obelisk. All coordinates are distinct, that is x_i β x_j or y_i β y_j will be satisfied for every (i, j) such that i β j.
Each of the next n lines contains two integers a_i, b_i (-2 β
10^6 β€ a_i, b_i β€ 2 β
10^6) β the direction of the i-th clue. All coordinates are distinct, that is a_i β a_j or b_i β b_j will be satisfied for every (i, j) such that i β j.
It is guaranteed that there exists a permutation p, such that for all i,j it holds \left(x_{p_i} + a_i, y_{p_i} + b_i\right) = \left(x_{p_j} + a_j, y_{p_j} + b_j\right).
Output
Output a single line containing two integers T_x, T_y β the coordinates of the treasure.
If there are multiple answers, you may print any of them.
Examples
Input
2
2 5
-6 4
7 -2
-1 -3
Output
1 2
Input
4
2 2
8 2
-7 0
-2 6
1 -14
16 -12
11 -18
7 -14
Output
9 -12
Note
As n = 2, we can consider all permutations on two elements.
If p = [1, 2], then the obelisk (2, 5) holds the clue (7, -2), which means that the treasure is hidden at (9, 3). The second obelisk (-6, 4) would give the clue (-1,-3) and the treasure at (-7, 1). However, both obelisks must give the same location, hence this is clearly not the correct permutation.
If the hidden permutation is [2, 1], then the first clue belongs to the second obelisk and the second clue belongs to the first obelisk. Hence (-6, 4) + (7, -2) = (2,5) + (-1,-3) = (1, 2), so T = (1,2) is the location of the treasure.
<image>
In the second sample, the hidden permutation is [2, 3, 4, 1]. | instruction | 0 | 68,966 | 3 | 137,932 |
Tags: brute force, constructive algorithms, greedy, implementation
Correct Solution:
```
n=int(input())
R=lambda:sorted([*map(int,input().split())]for _ in[0]*n)
o,c=R(),R()
print(o[0][0]+c[-1][0],o[0][1]+c[-1][1])
``` | output | 1 | 68,966 | 3 | 137,933 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob is a pirate looking for the greatest treasure the world has ever seen. The treasure is located at the point T, which coordinates to be found out.
Bob travelled around the world and collected clues of the treasure location at n obelisks. These clues were in an ancient language, and he has only decrypted them at home. Since he does not know which clue belongs to which obelisk, finding the treasure might pose a challenge. Can you help him?
As everyone knows, the world is a two-dimensional plane. The i-th obelisk is at integer coordinates (x_i, y_i). The j-th clue consists of 2 integers (a_j, b_j) and belongs to the obelisk p_j, where p is some (unknown) permutation on n elements. It means that the treasure is located at T=(x_{p_j} + a_j, y_{p_j} + b_j). This point T is the same for all clues.
In other words, each clue belongs to exactly one of the obelisks, and each obelisk has exactly one clue that belongs to it. A clue represents the vector from the obelisk to the treasure. The clues must be distributed among the obelisks in such a way that they all point to the same position of the treasure.
Your task is to find the coordinates of the treasure. If there are multiple solutions, you may print any of them.
Note that you don't need to find the permutation. Permutations are used only in order to explain the problem.
Input
The first line contains an integer n (1 β€ n β€ 1000) β the number of obelisks, that is also equal to the number of clues.
Each of the next n lines contains two integers x_i, y_i (-10^6 β€ x_i, y_i β€ 10^6) β the coordinates of the i-th obelisk. All coordinates are distinct, that is x_i β x_j or y_i β y_j will be satisfied for every (i, j) such that i β j.
Each of the next n lines contains two integers a_i, b_i (-2 β
10^6 β€ a_i, b_i β€ 2 β
10^6) β the direction of the i-th clue. All coordinates are distinct, that is a_i β a_j or b_i β b_j will be satisfied for every (i, j) such that i β j.
It is guaranteed that there exists a permutation p, such that for all i,j it holds \left(x_{p_i} + a_i, y_{p_i} + b_i\right) = \left(x_{p_j} + a_j, y_{p_j} + b_j\right).
Output
Output a single line containing two integers T_x, T_y β the coordinates of the treasure.
If there are multiple answers, you may print any of them.
Examples
Input
2
2 5
-6 4
7 -2
-1 -3
Output
1 2
Input
4
2 2
8 2
-7 0
-2 6
1 -14
16 -12
11 -18
7 -14
Output
9 -12
Note
As n = 2, we can consider all permutations on two elements.
If p = [1, 2], then the obelisk (2, 5) holds the clue (7, -2), which means that the treasure is hidden at (9, 3). The second obelisk (-6, 4) would give the clue (-1,-3) and the treasure at (-7, 1). However, both obelisks must give the same location, hence this is clearly not the correct permutation.
If the hidden permutation is [2, 1], then the first clue belongs to the second obelisk and the second clue belongs to the first obelisk. Hence (-6, 4) + (7, -2) = (2,5) + (-1,-3) = (1, 2), so T = (1,2) is the location of the treasure.
<image>
In the second sample, the hidden permutation is [2, 3, 4, 1].
Submitted Solution:
```
n=int(input())
ans1=0
ans2=0
for i in range(0,2*n):
a,b=[int(x) for x in input().split()]
ans1+=a
ans2+=b
print(ans1//n,ans2//n)
``` | instruction | 0 | 68,967 | 3 | 137,934 |
Yes | output | 1 | 68,967 | 3 | 137,935 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob is a pirate looking for the greatest treasure the world has ever seen. The treasure is located at the point T, which coordinates to be found out.
Bob travelled around the world and collected clues of the treasure location at n obelisks. These clues were in an ancient language, and he has only decrypted them at home. Since he does not know which clue belongs to which obelisk, finding the treasure might pose a challenge. Can you help him?
As everyone knows, the world is a two-dimensional plane. The i-th obelisk is at integer coordinates (x_i, y_i). The j-th clue consists of 2 integers (a_j, b_j) and belongs to the obelisk p_j, where p is some (unknown) permutation on n elements. It means that the treasure is located at T=(x_{p_j} + a_j, y_{p_j} + b_j). This point T is the same for all clues.
In other words, each clue belongs to exactly one of the obelisks, and each obelisk has exactly one clue that belongs to it. A clue represents the vector from the obelisk to the treasure. The clues must be distributed among the obelisks in such a way that they all point to the same position of the treasure.
Your task is to find the coordinates of the treasure. If there are multiple solutions, you may print any of them.
Note that you don't need to find the permutation. Permutations are used only in order to explain the problem.
Input
The first line contains an integer n (1 β€ n β€ 1000) β the number of obelisks, that is also equal to the number of clues.
Each of the next n lines contains two integers x_i, y_i (-10^6 β€ x_i, y_i β€ 10^6) β the coordinates of the i-th obelisk. All coordinates are distinct, that is x_i β x_j or y_i β y_j will be satisfied for every (i, j) such that i β j.
Each of the next n lines contains two integers a_i, b_i (-2 β
10^6 β€ a_i, b_i β€ 2 β
10^6) β the direction of the i-th clue. All coordinates are distinct, that is a_i β a_j or b_i β b_j will be satisfied for every (i, j) such that i β j.
It is guaranteed that there exists a permutation p, such that for all i,j it holds \left(x_{p_i} + a_i, y_{p_i} + b_i\right) = \left(x_{p_j} + a_j, y_{p_j} + b_j\right).
Output
Output a single line containing two integers T_x, T_y β the coordinates of the treasure.
If there are multiple answers, you may print any of them.
Examples
Input
2
2 5
-6 4
7 -2
-1 -3
Output
1 2
Input
4
2 2
8 2
-7 0
-2 6
1 -14
16 -12
11 -18
7 -14
Output
9 -12
Note
As n = 2, we can consider all permutations on two elements.
If p = [1, 2], then the obelisk (2, 5) holds the clue (7, -2), which means that the treasure is hidden at (9, 3). The second obelisk (-6, 4) would give the clue (-1,-3) and the treasure at (-7, 1). However, both obelisks must give the same location, hence this is clearly not the correct permutation.
If the hidden permutation is [2, 1], then the first clue belongs to the second obelisk and the second clue belongs to the first obelisk. Hence (-6, 4) + (7, -2) = (2,5) + (-1,-3) = (1, 2), so T = (1,2) is the location of the treasure.
<image>
In the second sample, the hidden permutation is [2, 3, 4, 1].
Submitted Solution:
```
n = int(input())
maxX = -10000000000
maxY = -10000000000
minA = 10000000000
minB = 10000000000
for i in range(n):
a, b = map(int, input().split())
if(a>maxX):
maxX = a
if(b>maxY):
maxY = b
for i in range(n):
a, b = map(int, input().split())
if(a<minA):
minA = a
if(b<minB):
minB = b
print(maxX+minA, maxY+minB)
``` | instruction | 0 | 68,968 | 3 | 137,936 |
Yes | output | 1 | 68,968 | 3 | 137,937 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob is a pirate looking for the greatest treasure the world has ever seen. The treasure is located at the point T, which coordinates to be found out.
Bob travelled around the world and collected clues of the treasure location at n obelisks. These clues were in an ancient language, and he has only decrypted them at home. Since he does not know which clue belongs to which obelisk, finding the treasure might pose a challenge. Can you help him?
As everyone knows, the world is a two-dimensional plane. The i-th obelisk is at integer coordinates (x_i, y_i). The j-th clue consists of 2 integers (a_j, b_j) and belongs to the obelisk p_j, where p is some (unknown) permutation on n elements. It means that the treasure is located at T=(x_{p_j} + a_j, y_{p_j} + b_j). This point T is the same for all clues.
In other words, each clue belongs to exactly one of the obelisks, and each obelisk has exactly one clue that belongs to it. A clue represents the vector from the obelisk to the treasure. The clues must be distributed among the obelisks in such a way that they all point to the same position of the treasure.
Your task is to find the coordinates of the treasure. If there are multiple solutions, you may print any of them.
Note that you don't need to find the permutation. Permutations are used only in order to explain the problem.
Input
The first line contains an integer n (1 β€ n β€ 1000) β the number of obelisks, that is also equal to the number of clues.
Each of the next n lines contains two integers x_i, y_i (-10^6 β€ x_i, y_i β€ 10^6) β the coordinates of the i-th obelisk. All coordinates are distinct, that is x_i β x_j or y_i β y_j will be satisfied for every (i, j) such that i β j.
Each of the next n lines contains two integers a_i, b_i (-2 β
10^6 β€ a_i, b_i β€ 2 β
10^6) β the direction of the i-th clue. All coordinates are distinct, that is a_i β a_j or b_i β b_j will be satisfied for every (i, j) such that i β j.
It is guaranteed that there exists a permutation p, such that for all i,j it holds \left(x_{p_i} + a_i, y_{p_i} + b_i\right) = \left(x_{p_j} + a_j, y_{p_j} + b_j\right).
Output
Output a single line containing two integers T_x, T_y β the coordinates of the treasure.
If there are multiple answers, you may print any of them.
Examples
Input
2
2 5
-6 4
7 -2
-1 -3
Output
1 2
Input
4
2 2
8 2
-7 0
-2 6
1 -14
16 -12
11 -18
7 -14
Output
9 -12
Note
As n = 2, we can consider all permutations on two elements.
If p = [1, 2], then the obelisk (2, 5) holds the clue (7, -2), which means that the treasure is hidden at (9, 3). The second obelisk (-6, 4) would give the clue (-1,-3) and the treasure at (-7, 1). However, both obelisks must give the same location, hence this is clearly not the correct permutation.
If the hidden permutation is [2, 1], then the first clue belongs to the second obelisk and the second clue belongs to the first obelisk. Hence (-6, 4) + (7, -2) = (2,5) + (-1,-3) = (1, 2), so T = (1,2) is the location of the treasure.
<image>
In the second sample, the hidden permutation is [2, 3, 4, 1].
Submitted Solution:
```
def read_row():
return [int(i) for i in input().split()]
def add(p1,p2):
return [p1[0]+p2[0], p1[1]+p2[1]]
n = int(input())
obelisks = [read_row() for _ in range(n)]
clues = [read_row() for _ in range(n)]
points = set([tuple(add(obelisks[0],offset)) for offset in clues])
for obelisk in obelisks[1:]:
new_p = set([tuple(add(obelisk,offset)) for offset in clues])
points = points & new_p
answer = list(points)[0]
print(answer[0], answer[1])
``` | instruction | 0 | 68,969 | 3 | 137,938 |
Yes | output | 1 | 68,969 | 3 | 137,939 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob is a pirate looking for the greatest treasure the world has ever seen. The treasure is located at the point T, which coordinates to be found out.
Bob travelled around the world and collected clues of the treasure location at n obelisks. These clues were in an ancient language, and he has only decrypted them at home. Since he does not know which clue belongs to which obelisk, finding the treasure might pose a challenge. Can you help him?
As everyone knows, the world is a two-dimensional plane. The i-th obelisk is at integer coordinates (x_i, y_i). The j-th clue consists of 2 integers (a_j, b_j) and belongs to the obelisk p_j, where p is some (unknown) permutation on n elements. It means that the treasure is located at T=(x_{p_j} + a_j, y_{p_j} + b_j). This point T is the same for all clues.
In other words, each clue belongs to exactly one of the obelisks, and each obelisk has exactly one clue that belongs to it. A clue represents the vector from the obelisk to the treasure. The clues must be distributed among the obelisks in such a way that they all point to the same position of the treasure.
Your task is to find the coordinates of the treasure. If there are multiple solutions, you may print any of them.
Note that you don't need to find the permutation. Permutations are used only in order to explain the problem.
Input
The first line contains an integer n (1 β€ n β€ 1000) β the number of obelisks, that is also equal to the number of clues.
Each of the next n lines contains two integers x_i, y_i (-10^6 β€ x_i, y_i β€ 10^6) β the coordinates of the i-th obelisk. All coordinates are distinct, that is x_i β x_j or y_i β y_j will be satisfied for every (i, j) such that i β j.
Each of the next n lines contains two integers a_i, b_i (-2 β
10^6 β€ a_i, b_i β€ 2 β
10^6) β the direction of the i-th clue. All coordinates are distinct, that is a_i β a_j or b_i β b_j will be satisfied for every (i, j) such that i β j.
It is guaranteed that there exists a permutation p, such that for all i,j it holds \left(x_{p_i} + a_i, y_{p_i} + b_i\right) = \left(x_{p_j} + a_j, y_{p_j} + b_j\right).
Output
Output a single line containing two integers T_x, T_y β the coordinates of the treasure.
If there are multiple answers, you may print any of them.
Examples
Input
2
2 5
-6 4
7 -2
-1 -3
Output
1 2
Input
4
2 2
8 2
-7 0
-2 6
1 -14
16 -12
11 -18
7 -14
Output
9 -12
Note
As n = 2, we can consider all permutations on two elements.
If p = [1, 2], then the obelisk (2, 5) holds the clue (7, -2), which means that the treasure is hidden at (9, 3). The second obelisk (-6, 4) would give the clue (-1,-3) and the treasure at (-7, 1). However, both obelisks must give the same location, hence this is clearly not the correct permutation.
If the hidden permutation is [2, 1], then the first clue belongs to the second obelisk and the second clue belongs to the first obelisk. Hence (-6, 4) + (7, -2) = (2,5) + (-1,-3) = (1, 2), so T = (1,2) is the location of the treasure.
<image>
In the second sample, the hidden permutation is [2, 3, 4, 1].
Submitted Solution:
```
n=int(input())
sa,sb=0,0
for i in range(2*n):
a,b=map(int,input().split())
sa+=a
sb+=b
print(sa//n,sb//n)
``` | instruction | 0 | 68,970 | 3 | 137,940 |
Yes | output | 1 | 68,970 | 3 | 137,941 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob is a pirate looking for the greatest treasure the world has ever seen. The treasure is located at the point T, which coordinates to be found out.
Bob travelled around the world and collected clues of the treasure location at n obelisks. These clues were in an ancient language, and he has only decrypted them at home. Since he does not know which clue belongs to which obelisk, finding the treasure might pose a challenge. Can you help him?
As everyone knows, the world is a two-dimensional plane. The i-th obelisk is at integer coordinates (x_i, y_i). The j-th clue consists of 2 integers (a_j, b_j) and belongs to the obelisk p_j, where p is some (unknown) permutation on n elements. It means that the treasure is located at T=(x_{p_j} + a_j, y_{p_j} + b_j). This point T is the same for all clues.
In other words, each clue belongs to exactly one of the obelisks, and each obelisk has exactly one clue that belongs to it. A clue represents the vector from the obelisk to the treasure. The clues must be distributed among the obelisks in such a way that they all point to the same position of the treasure.
Your task is to find the coordinates of the treasure. If there are multiple solutions, you may print any of them.
Note that you don't need to find the permutation. Permutations are used only in order to explain the problem.
Input
The first line contains an integer n (1 β€ n β€ 1000) β the number of obelisks, that is also equal to the number of clues.
Each of the next n lines contains two integers x_i, y_i (-10^6 β€ x_i, y_i β€ 10^6) β the coordinates of the i-th obelisk. All coordinates are distinct, that is x_i β x_j or y_i β y_j will be satisfied for every (i, j) such that i β j.
Each of the next n lines contains two integers a_i, b_i (-2 β
10^6 β€ a_i, b_i β€ 2 β
10^6) β the direction of the i-th clue. All coordinates are distinct, that is a_i β a_j or b_i β b_j will be satisfied for every (i, j) such that i β j.
It is guaranteed that there exists a permutation p, such that for all i,j it holds \left(x_{p_i} + a_i, y_{p_i} + b_i\right) = \left(x_{p_j} + a_j, y_{p_j} + b_j\right).
Output
Output a single line containing two integers T_x, T_y β the coordinates of the treasure.
If there are multiple answers, you may print any of them.
Examples
Input
2
2 5
-6 4
7 -2
-1 -3
Output
1 2
Input
4
2 2
8 2
-7 0
-2 6
1 -14
16 -12
11 -18
7 -14
Output
9 -12
Note
As n = 2, we can consider all permutations on two elements.
If p = [1, 2], then the obelisk (2, 5) holds the clue (7, -2), which means that the treasure is hidden at (9, 3). The second obelisk (-6, 4) would give the clue (-1,-3) and the treasure at (-7, 1). However, both obelisks must give the same location, hence this is clearly not the correct permutation.
If the hidden permutation is [2, 1], then the first clue belongs to the second obelisk and the second clue belongs to the first obelisk. Hence (-6, 4) + (7, -2) = (2,5) + (-1,-3) = (1, 2), so T = (1,2) is the location of the treasure.
<image>
In the second sample, the hidden permutation is [2, 3, 4, 1].
Submitted Solution:
```
n=int(input())
if(n==1):
x,y=map(int,input().split())
a,b=map(int,input().split())
print(x+a,y+b)
else:
l=[]
ll=[]
lll=[]
llll=[]
for i in range(n):
l.append(list(map(int,input().split())))
for i in range(n):
ll.append(list(map(int,input().split())))
for i in ll:
lll.append((l[0][0]+i[0],l[0][1]+i[1]))
for i in ll:
llll.append((l[1][0]+i[0],l[1][1]+i[1]))
for i in lll:
if i in llll:
z=i
break
print(z[0],z[1])
``` | instruction | 0 | 68,971 | 3 | 137,942 |
No | output | 1 | 68,971 | 3 | 137,943 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob is a pirate looking for the greatest treasure the world has ever seen. The treasure is located at the point T, which coordinates to be found out.
Bob travelled around the world and collected clues of the treasure location at n obelisks. These clues were in an ancient language, and he has only decrypted them at home. Since he does not know which clue belongs to which obelisk, finding the treasure might pose a challenge. Can you help him?
As everyone knows, the world is a two-dimensional plane. The i-th obelisk is at integer coordinates (x_i, y_i). The j-th clue consists of 2 integers (a_j, b_j) and belongs to the obelisk p_j, where p is some (unknown) permutation on n elements. It means that the treasure is located at T=(x_{p_j} + a_j, y_{p_j} + b_j). This point T is the same for all clues.
In other words, each clue belongs to exactly one of the obelisks, and each obelisk has exactly one clue that belongs to it. A clue represents the vector from the obelisk to the treasure. The clues must be distributed among the obelisks in such a way that they all point to the same position of the treasure.
Your task is to find the coordinates of the treasure. If there are multiple solutions, you may print any of them.
Note that you don't need to find the permutation. Permutations are used only in order to explain the problem.
Input
The first line contains an integer n (1 β€ n β€ 1000) β the number of obelisks, that is also equal to the number of clues.
Each of the next n lines contains two integers x_i, y_i (-10^6 β€ x_i, y_i β€ 10^6) β the coordinates of the i-th obelisk. All coordinates are distinct, that is x_i β x_j or y_i β y_j will be satisfied for every (i, j) such that i β j.
Each of the next n lines contains two integers a_i, b_i (-2 β
10^6 β€ a_i, b_i β€ 2 β
10^6) β the direction of the i-th clue. All coordinates are distinct, that is a_i β a_j or b_i β b_j will be satisfied for every (i, j) such that i β j.
It is guaranteed that there exists a permutation p, such that for all i,j it holds \left(x_{p_i} + a_i, y_{p_i} + b_i\right) = \left(x_{p_j} + a_j, y_{p_j} + b_j\right).
Output
Output a single line containing two integers T_x, T_y β the coordinates of the treasure.
If there are multiple answers, you may print any of them.
Examples
Input
2
2 5
-6 4
7 -2
-1 -3
Output
1 2
Input
4
2 2
8 2
-7 0
-2 6
1 -14
16 -12
11 -18
7 -14
Output
9 -12
Note
As n = 2, we can consider all permutations on two elements.
If p = [1, 2], then the obelisk (2, 5) holds the clue (7, -2), which means that the treasure is hidden at (9, 3). The second obelisk (-6, 4) would give the clue (-1,-3) and the treasure at (-7, 1). However, both obelisks must give the same location, hence this is clearly not the correct permutation.
If the hidden permutation is [2, 1], then the first clue belongs to the second obelisk and the second clue belongs to the first obelisk. Hence (-6, 4) + (7, -2) = (2,5) + (-1,-3) = (1, 2), so T = (1,2) is the location of the treasure.
<image>
In the second sample, the hidden permutation is [2, 3, 4, 1].
Submitted Solution:
```
# ***********************************************
#
# achie27
#
# ***********************************************
def retarray():
return list(map(int, input().split()))
obs = []
clues = []
x = [0]*(10*1000007)
y = [0]*(10*1000007)
n = int(input())
for _ in range(n):
obs.append(retarray())
for _ in range(n):
clues.append(retarray())
f = False
for ob in obs:
for clue in clues:
x[ob[0] + clue[0] + 3000001]+=1
y[ob[1] + clue[1] + 3000001]+=1
if x[ob[0] + clue[0] + 3000001] >= n and y[ob[1] + clue[1] + 3000001] >= n:
print(ob[0] + clue[0], ob[1] + clue[1], flush = True)
f = True
break
if f: break
``` | instruction | 0 | 68,972 | 3 | 137,944 |
No | output | 1 | 68,972 | 3 | 137,945 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob is a pirate looking for the greatest treasure the world has ever seen. The treasure is located at the point T, which coordinates to be found out.
Bob travelled around the world and collected clues of the treasure location at n obelisks. These clues were in an ancient language, and he has only decrypted them at home. Since he does not know which clue belongs to which obelisk, finding the treasure might pose a challenge. Can you help him?
As everyone knows, the world is a two-dimensional plane. The i-th obelisk is at integer coordinates (x_i, y_i). The j-th clue consists of 2 integers (a_j, b_j) and belongs to the obelisk p_j, where p is some (unknown) permutation on n elements. It means that the treasure is located at T=(x_{p_j} + a_j, y_{p_j} + b_j). This point T is the same for all clues.
In other words, each clue belongs to exactly one of the obelisks, and each obelisk has exactly one clue that belongs to it. A clue represents the vector from the obelisk to the treasure. The clues must be distributed among the obelisks in such a way that they all point to the same position of the treasure.
Your task is to find the coordinates of the treasure. If there are multiple solutions, you may print any of them.
Note that you don't need to find the permutation. Permutations are used only in order to explain the problem.
Input
The first line contains an integer n (1 β€ n β€ 1000) β the number of obelisks, that is also equal to the number of clues.
Each of the next n lines contains two integers x_i, y_i (-10^6 β€ x_i, y_i β€ 10^6) β the coordinates of the i-th obelisk. All coordinates are distinct, that is x_i β x_j or y_i β y_j will be satisfied for every (i, j) such that i β j.
Each of the next n lines contains two integers a_i, b_i (-2 β
10^6 β€ a_i, b_i β€ 2 β
10^6) β the direction of the i-th clue. All coordinates are distinct, that is a_i β a_j or b_i β b_j will be satisfied for every (i, j) such that i β j.
It is guaranteed that there exists a permutation p, such that for all i,j it holds \left(x_{p_i} + a_i, y_{p_i} + b_i\right) = \left(x_{p_j} + a_j, y_{p_j} + b_j\right).
Output
Output a single line containing two integers T_x, T_y β the coordinates of the treasure.
If there are multiple answers, you may print any of them.
Examples
Input
2
2 5
-6 4
7 -2
-1 -3
Output
1 2
Input
4
2 2
8 2
-7 0
-2 6
1 -14
16 -12
11 -18
7 -14
Output
9 -12
Note
As n = 2, we can consider all permutations on two elements.
If p = [1, 2], then the obelisk (2, 5) holds the clue (7, -2), which means that the treasure is hidden at (9, 3). The second obelisk (-6, 4) would give the clue (-1,-3) and the treasure at (-7, 1). However, both obelisks must give the same location, hence this is clearly not the correct permutation.
If the hidden permutation is [2, 1], then the first clue belongs to the second obelisk and the second clue belongs to the first obelisk. Hence (-6, 4) + (7, -2) = (2,5) + (-1,-3) = (1, 2), so T = (1,2) is the location of the treasure.
<image>
In the second sample, the hidden permutation is [2, 3, 4, 1].
Submitted Solution:
```
def jewel(lst, n):
sum_x, sum_y = 0, 0
for elem in lst:
sum_x += elem[0]
sum_y += elem[1]
return sum_x // n, sum_y // n
N = int(input())
a = list()
for i in range(N):
x, y = [int(j) for j in input().split()]
a.append([x, y])
print(*jewel(a, N))
``` | instruction | 0 | 68,973 | 3 | 137,946 |
No | output | 1 | 68,973 | 3 | 137,947 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob is a pirate looking for the greatest treasure the world has ever seen. The treasure is located at the point T, which coordinates to be found out.
Bob travelled around the world and collected clues of the treasure location at n obelisks. These clues were in an ancient language, and he has only decrypted them at home. Since he does not know which clue belongs to which obelisk, finding the treasure might pose a challenge. Can you help him?
As everyone knows, the world is a two-dimensional plane. The i-th obelisk is at integer coordinates (x_i, y_i). The j-th clue consists of 2 integers (a_j, b_j) and belongs to the obelisk p_j, where p is some (unknown) permutation on n elements. It means that the treasure is located at T=(x_{p_j} + a_j, y_{p_j} + b_j). This point T is the same for all clues.
In other words, each clue belongs to exactly one of the obelisks, and each obelisk has exactly one clue that belongs to it. A clue represents the vector from the obelisk to the treasure. The clues must be distributed among the obelisks in such a way that they all point to the same position of the treasure.
Your task is to find the coordinates of the treasure. If there are multiple solutions, you may print any of them.
Note that you don't need to find the permutation. Permutations are used only in order to explain the problem.
Input
The first line contains an integer n (1 β€ n β€ 1000) β the number of obelisks, that is also equal to the number of clues.
Each of the next n lines contains two integers x_i, y_i (-10^6 β€ x_i, y_i β€ 10^6) β the coordinates of the i-th obelisk. All coordinates are distinct, that is x_i β x_j or y_i β y_j will be satisfied for every (i, j) such that i β j.
Each of the next n lines contains two integers a_i, b_i (-2 β
10^6 β€ a_i, b_i β€ 2 β
10^6) β the direction of the i-th clue. All coordinates are distinct, that is a_i β a_j or b_i β b_j will be satisfied for every (i, j) such that i β j.
It is guaranteed that there exists a permutation p, such that for all i,j it holds \left(x_{p_i} + a_i, y_{p_i} + b_i\right) = \left(x_{p_j} + a_j, y_{p_j} + b_j\right).
Output
Output a single line containing two integers T_x, T_y β the coordinates of the treasure.
If there are multiple answers, you may print any of them.
Examples
Input
2
2 5
-6 4
7 -2
-1 -3
Output
1 2
Input
4
2 2
8 2
-7 0
-2 6
1 -14
16 -12
11 -18
7 -14
Output
9 -12
Note
As n = 2, we can consider all permutations on two elements.
If p = [1, 2], then the obelisk (2, 5) holds the clue (7, -2), which means that the treasure is hidden at (9, 3). The second obelisk (-6, 4) would give the clue (-1,-3) and the treasure at (-7, 1). However, both obelisks must give the same location, hence this is clearly not the correct permutation.
If the hidden permutation is [2, 1], then the first clue belongs to the second obelisk and the second clue belongs to the first obelisk. Hence (-6, 4) + (7, -2) = (2,5) + (-1,-3) = (1, 2), so T = (1,2) is the location of the treasure.
<image>
In the second sample, the hidden permutation is [2, 3, 4, 1].
Submitted Solution:
```
S = set()
N = int(input())
A = [tuple(map(int,input().split())) for i in range(N)]
B = [tuple(map(int,input().split())) for i in range(N)]
for i in range(N):
S.add((A[0][0]+B[i][0],A[0][1]+B[i][1]))
for i in range(1,N):
Sp = set()
for j in range(N):
Sp.add((A[i][0]+B[j][0],A[i][1]+B[j][1]))
for i in S:
print('%d %d'%i)
exit(0)
``` | instruction | 0 | 68,974 | 3 | 137,948 |
No | output | 1 | 68,974 | 3 | 137,949 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lunar rover finally reached planet X. After landing, he met an obstacle, that contains permutation p of length n. Scientists found out, that to overcome an obstacle, the robot should make p an identity permutation (make p_i = i for all i).
Unfortunately, scientists can't control the robot. Thus the only way to make p an identity permutation is applying the following operation to p multiple times:
* Select two indices i and j (i β j), such that p_j = i and swap the values of p_i and p_j. It takes robot (j - i)^2 seconds to do this operation.
Positions i and j are selected by the robot (scientists can't control it). He will apply this operation while p isn't an identity permutation. We can show that the robot will make no more than n operations regardless of the choice of i and j on each operation.
Scientists asked you to find out the maximum possible time it will take the robot to finish making p an identity permutation (i. e. worst-case scenario), so they can decide whether they should construct a new lunar rover or just rest and wait. They won't believe you without proof, so you should build an example of p and robot's operations that maximizes the answer.
For a better understanding of the statement, read the sample description.
Input
The first line of input contains a single integer t (1 β€ t β€ 10^4) β the number of test cases.
Each of next t lines contains the single integer n (2 β€ n β€ 10^5) β the length of p.
Note, that p is not given to you. You should find the maximum possible time over all permutations of length n.
It is guaranteed, that the total sum of n over all test cases doesn't exceed 10^5.
Output
For each test case in the first line, print how many seconds will the robot spend in the worst case.
In the next line, print the initial value of p that you used to construct an answer.
In the next line, print the number of operations m β€ n that the robot makes in your example.
In the each of next m lines print two integers i and j β indices of positions that the robot will swap on this operation. Note that p_j = i must holds (at the time of operation).
Example
Input
3
2
3
3
Output
1
2 1
1
2 1
5
2 3 1
2
1 3
3 2
5
2 3 1
2
1 3
2 3
Note
For n = 2, p can be either [1, 2] or [2, 1]. In the first case p is already identity, otherwise robot will make it an identity permutation in 1 second regardless of choise i and j on the first operation.
For n = 3, p can be equals [2, 3, 1].
* If robot will select i = 3, j = 2 on the first operation, p will become [2, 1, 3] in one second. Now robot can select only i = 1, j = 2 or i = 2, j = 1. In both cases, p will become identity in one more second (2 seconds in total).
* If robot will select i = 1, j = 3 on the first operation, p will become [1, 3, 2] in four seconds. Regardless of choise of i and j on the second operation, p will become identity in five seconds.
We can show, that for permutation of length 3 robot will always finish all operation in no more than 5 seconds. | instruction | 0 | 69,155 | 3 | 138,310 |
Tags: constructive algorithms, greedy
Correct Solution:
```
for tests in range(int(input())):
n=int(input())
AA=[]
for i in range((n+2)//2,n):
AA.append((1,i))
for i in range((n+2)//2-1,0,-1):
AA.append((i,n))
L=list(range(1,n+1))
sc=0
for x,y in AA[::-1]:L[x-1],L[y-1]=L[y-1],L[x-1];sc+=(x-y)**2
print(sc);print(*L);print(len(AA))
for x,y in AA:print(y,x) if L[x-1]==y else print(x,y);L[x-1],L[y-1]=L[y-1],L[x-1]
``` | output | 1 | 69,155 | 3 | 138,311 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lunar rover finally reached planet X. After landing, he met an obstacle, that contains permutation p of length n. Scientists found out, that to overcome an obstacle, the robot should make p an identity permutation (make p_i = i for all i).
Unfortunately, scientists can't control the robot. Thus the only way to make p an identity permutation is applying the following operation to p multiple times:
* Select two indices i and j (i β j), such that p_j = i and swap the values of p_i and p_j. It takes robot (j - i)^2 seconds to do this operation.
Positions i and j are selected by the robot (scientists can't control it). He will apply this operation while p isn't an identity permutation. We can show that the robot will make no more than n operations regardless of the choice of i and j on each operation.
Scientists asked you to find out the maximum possible time it will take the robot to finish making p an identity permutation (i. e. worst-case scenario), so they can decide whether they should construct a new lunar rover or just rest and wait. They won't believe you without proof, so you should build an example of p and robot's operations that maximizes the answer.
For a better understanding of the statement, read the sample description.
Input
The first line of input contains a single integer t (1 β€ t β€ 10^4) β the number of test cases.
Each of next t lines contains the single integer n (2 β€ n β€ 10^5) β the length of p.
Note, that p is not given to you. You should find the maximum possible time over all permutations of length n.
It is guaranteed, that the total sum of n over all test cases doesn't exceed 10^5.
Output
For each test case in the first line, print how many seconds will the robot spend in the worst case.
In the next line, print the initial value of p that you used to construct an answer.
In the next line, print the number of operations m β€ n that the robot makes in your example.
In the each of next m lines print two integers i and j β indices of positions that the robot will swap on this operation. Note that p_j = i must holds (at the time of operation).
Example
Input
3
2
3
3
Output
1
2 1
1
2 1
5
2 3 1
2
1 3
3 2
5
2 3 1
2
1 3
2 3
Note
For n = 2, p can be either [1, 2] or [2, 1]. In the first case p is already identity, otherwise robot will make it an identity permutation in 1 second regardless of choise i and j on the first operation.
For n = 3, p can be equals [2, 3, 1].
* If robot will select i = 3, j = 2 on the first operation, p will become [2, 1, 3] in one second. Now robot can select only i = 1, j = 2 or i = 2, j = 1. In both cases, p will become identity in one more second (2 seconds in total).
* If robot will select i = 1, j = 3 on the first operation, p will become [1, 3, 2] in four seconds. Regardless of choise of i and j on the second operation, p will become identity in five seconds.
We can show, that for permutation of length 3 robot will always finish all operation in no more than 5 seconds. | instruction | 0 | 69,156 | 3 | 138,312 |
Tags: constructive algorithms, greedy
Correct Solution:
```
from collections import defaultdict
from itertools import accumulate
import sys
input = sys.stdin.readline
'''
for CASES in range(int(input())):
n, m = map(int, input().split())
n = int(input())
A = list(map(int, input().split()))
S = input().strip()
sys.stdout.write(" ".join(map(str,ANS))+"\n")
'''
inf = 100000000000000000 # 1e17
mod = 998244353
for CASES in range(int(input())):
n = int(input())
A=[(i+1) for i in range(n)]
OP=[]
ans=0
l = 0
r = n - 1
tik=0
OP.append([l, r])
ans += (r - l) * (r - l)
A[l], A[r] = A[r], A[l]
for turn in range(n//2-1):
r-=1
l+=1
OP.append([0,r])
OP.append([n-1,l])
ans+=(r-0)*(r-0)+(n-1-l)*(n-1-l)
A[0], A[r] = A[r], A[0]
A[l], A[n-1] = A[n-1], A[l]
if n%2==1:
l+=1
OP.append([0,l])
ans+=(l-0)*(l-0)
A[l], A[0] = A[0], A[l]
print(ans)
print(*A)
print(len(OP))
for i in range(len(OP)-1,-1,-1):
op=OP[i]
print(op[1] + 1, op[0] + 1)
``` | output | 1 | 69,156 | 3 | 138,313 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lunar rover finally reached planet X. After landing, he met an obstacle, that contains permutation p of length n. Scientists found out, that to overcome an obstacle, the robot should make p an identity permutation (make p_i = i for all i).
Unfortunately, scientists can't control the robot. Thus the only way to make p an identity permutation is applying the following operation to p multiple times:
* Select two indices i and j (i β j), such that p_j = i and swap the values of p_i and p_j. It takes robot (j - i)^2 seconds to do this operation.
Positions i and j are selected by the robot (scientists can't control it). He will apply this operation while p isn't an identity permutation. We can show that the robot will make no more than n operations regardless of the choice of i and j on each operation.
Scientists asked you to find out the maximum possible time it will take the robot to finish making p an identity permutation (i. e. worst-case scenario), so they can decide whether they should construct a new lunar rover or just rest and wait. They won't believe you without proof, so you should build an example of p and robot's operations that maximizes the answer.
For a better understanding of the statement, read the sample description.
Input
The first line of input contains a single integer t (1 β€ t β€ 10^4) β the number of test cases.
Each of next t lines contains the single integer n (2 β€ n β€ 10^5) β the length of p.
Note, that p is not given to you. You should find the maximum possible time over all permutations of length n.
It is guaranteed, that the total sum of n over all test cases doesn't exceed 10^5.
Output
For each test case in the first line, print how many seconds will the robot spend in the worst case.
In the next line, print the initial value of p that you used to construct an answer.
In the next line, print the number of operations m β€ n that the robot makes in your example.
In the each of next m lines print two integers i and j β indices of positions that the robot will swap on this operation. Note that p_j = i must holds (at the time of operation).
Example
Input
3
2
3
3
Output
1
2 1
1
2 1
5
2 3 1
2
1 3
3 2
5
2 3 1
2
1 3
2 3
Note
For n = 2, p can be either [1, 2] or [2, 1]. In the first case p is already identity, otherwise robot will make it an identity permutation in 1 second regardless of choise i and j on the first operation.
For n = 3, p can be equals [2, 3, 1].
* If robot will select i = 3, j = 2 on the first operation, p will become [2, 1, 3] in one second. Now robot can select only i = 1, j = 2 or i = 2, j = 1. In both cases, p will become identity in one more second (2 seconds in total).
* If robot will select i = 1, j = 3 on the first operation, p will become [1, 3, 2] in four seconds. Regardless of choise of i and j on the second operation, p will become identity in five seconds.
We can show, that for permutation of length 3 robot will always finish all operation in no more than 5 seconds. | instruction | 0 | 69,157 | 3 | 138,314 |
Tags: constructive algorithms, greedy
Correct Solution:
```
import sys
input = sys.stdin.readline
t=int(input())
for tests in range(t):
n=int(input())
AA=[]
for i in range((n+2)//2,n):
AA.append((1,i))
for i in range((n+2)//2-1,0,-1):
AA.append((i,n))
L=list(range(1,n+1))
sc=0
for x,y in AA[::-1]:
L[x-1],L[y-1]=L[y-1],L[x-1]
sc+=(x-y)**2
print(sc)
print(*L)
print(len(AA))
for x,y in AA:
if L[x-1]==y:
print(y,x)
else:
print(x,y)
L[x-1],L[y-1]=L[y-1],L[x-1]
``` | output | 1 | 69,157 | 3 | 138,315 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lunar rover finally reached planet X. After landing, he met an obstacle, that contains permutation p of length n. Scientists found out, that to overcome an obstacle, the robot should make p an identity permutation (make p_i = i for all i).
Unfortunately, scientists can't control the robot. Thus the only way to make p an identity permutation is applying the following operation to p multiple times:
* Select two indices i and j (i β j), such that p_j = i and swap the values of p_i and p_j. It takes robot (j - i)^2 seconds to do this operation.
Positions i and j are selected by the robot (scientists can't control it). He will apply this operation while p isn't an identity permutation. We can show that the robot will make no more than n operations regardless of the choice of i and j on each operation.
Scientists asked you to find out the maximum possible time it will take the robot to finish making p an identity permutation (i. e. worst-case scenario), so they can decide whether they should construct a new lunar rover or just rest and wait. They won't believe you without proof, so you should build an example of p and robot's operations that maximizes the answer.
For a better understanding of the statement, read the sample description.
Input
The first line of input contains a single integer t (1 β€ t β€ 10^4) β the number of test cases.
Each of next t lines contains the single integer n (2 β€ n β€ 10^5) β the length of p.
Note, that p is not given to you. You should find the maximum possible time over all permutations of length n.
It is guaranteed, that the total sum of n over all test cases doesn't exceed 10^5.
Output
For each test case in the first line, print how many seconds will the robot spend in the worst case.
In the next line, print the initial value of p that you used to construct an answer.
In the next line, print the number of operations m β€ n that the robot makes in your example.
In the each of next m lines print two integers i and j β indices of positions that the robot will swap on this operation. Note that p_j = i must holds (at the time of operation).
Example
Input
3
2
3
3
Output
1
2 1
1
2 1
5
2 3 1
2
1 3
3 2
5
2 3 1
2
1 3
2 3
Note
For n = 2, p can be either [1, 2] or [2, 1]. In the first case p is already identity, otherwise robot will make it an identity permutation in 1 second regardless of choise i and j on the first operation.
For n = 3, p can be equals [2, 3, 1].
* If robot will select i = 3, j = 2 on the first operation, p will become [2, 1, 3] in one second. Now robot can select only i = 1, j = 2 or i = 2, j = 1. In both cases, p will become identity in one more second (2 seconds in total).
* If robot will select i = 1, j = 3 on the first operation, p will become [1, 3, 2] in four seconds. Regardless of choise of i and j on the second operation, p will become identity in five seconds.
We can show, that for permutation of length 3 robot will always finish all operation in no more than 5 seconds. | instruction | 0 | 69,158 | 3 | 138,316 |
Tags: constructive algorithms, greedy
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
a = list(range(1, n + 1))
ans = (n - 1)**2
for i in range(1, n - 1):
ans += max(i, n - i - 1)**2
pos = list(range(n - 1))
pos.sort(key=lambda i: min(i, n - i - 1))
ops = []
for i in pos:
if i * 2 < n:
ops.append([i + 1, n])
a[i], a[n - 1] = a[n - 1], a[i]
else:
ops.append([i + 1, 1])
a[i], a[0] = a[0], a[i]
print(ans)
print(*a)
print(len(ops))
for x, y in ops[::-1]:
print(x, y)
``` | output | 1 | 69,158 | 3 | 138,317 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lunar rover finally reached planet X. After landing, he met an obstacle, that contains permutation p of length n. Scientists found out, that to overcome an obstacle, the robot should make p an identity permutation (make p_i = i for all i).
Unfortunately, scientists can't control the robot. Thus the only way to make p an identity permutation is applying the following operation to p multiple times:
* Select two indices i and j (i β j), such that p_j = i and swap the values of p_i and p_j. It takes robot (j - i)^2 seconds to do this operation.
Positions i and j are selected by the robot (scientists can't control it). He will apply this operation while p isn't an identity permutation. We can show that the robot will make no more than n operations regardless of the choice of i and j on each operation.
Scientists asked you to find out the maximum possible time it will take the robot to finish making p an identity permutation (i. e. worst-case scenario), so they can decide whether they should construct a new lunar rover or just rest and wait. They won't believe you without proof, so you should build an example of p and robot's operations that maximizes the answer.
For a better understanding of the statement, read the sample description.
Input
The first line of input contains a single integer t (1 β€ t β€ 10^4) β the number of test cases.
Each of next t lines contains the single integer n (2 β€ n β€ 10^5) β the length of p.
Note, that p is not given to you. You should find the maximum possible time over all permutations of length n.
It is guaranteed, that the total sum of n over all test cases doesn't exceed 10^5.
Output
For each test case in the first line, print how many seconds will the robot spend in the worst case.
In the next line, print the initial value of p that you used to construct an answer.
In the next line, print the number of operations m β€ n that the robot makes in your example.
In the each of next m lines print two integers i and j β indices of positions that the robot will swap on this operation. Note that p_j = i must holds (at the time of operation).
Example
Input
3
2
3
3
Output
1
2 1
1
2 1
5
2 3 1
2
1 3
3 2
5
2 3 1
2
1 3
2 3
Note
For n = 2, p can be either [1, 2] or [2, 1]. In the first case p is already identity, otherwise robot will make it an identity permutation in 1 second regardless of choise i and j on the first operation.
For n = 3, p can be equals [2, 3, 1].
* If robot will select i = 3, j = 2 on the first operation, p will become [2, 1, 3] in one second. Now robot can select only i = 1, j = 2 or i = 2, j = 1. In both cases, p will become identity in one more second (2 seconds in total).
* If robot will select i = 1, j = 3 on the first operation, p will become [1, 3, 2] in four seconds. Regardless of choise of i and j on the second operation, p will become identity in five seconds.
We can show, that for permutation of length 3 robot will always finish all operation in no more than 5 seconds. | instruction | 0 | 69,159 | 3 | 138,318 |
Tags: constructive algorithms, greedy
Correct Solution:
```
import sys
readline = sys.stdin.readline
def parorder(Edge, p):
N = len(Edge)
par = [0]*N
par[p] = -1
stack = [p]
order = []
visited = set([p])
ast = stack.append
apo = order.append
while stack:
vn = stack.pop()
apo(vn)
for vf in Edge[vn]:
if vf in visited:
continue
visited.add(vf)
par[vf] = vn
ast(vf)
return par, order
def getcld(p):
res = [[] for _ in range(len(p))]
for i, v in enumerate(p[1:], 1):
res[v].append(i)
return res
T = int(readline())
Ans = []
INF = 2*10**9+7
for qu in range(T):
N = int(readline())
Edge = [[] for _ in range(N)]
m = N-1
Edge[0].append(m)
Edge[m].append(0)
ans = m*m
for i in range(1, N-1):
if i-0 > m-i:
Edge[i].append(0)
Edge[0].append(i)
ans += i*i
else:
Edge[i].append(m)
Edge[m].append(i)
ans += (m-i)**2
Ans.append(str(ans))
P, L = parorder(Edge, 0)
pe = list(range(1, N+1))
res = []
for l in L[:0:-1]:
p = P[l]
res.append((l+1, p+1))
for a, b in res[::-1]:
a -= 1
b -= 1
pe[a], pe[b] = pe[b], pe[a]
Ans.append(' '.join(map(str, pe)))
Ans.append(str(N-1))
Ans.append('\n'.join(['{} {}'.format(*a) for a in res]))
print('\n'.join(Ans))
``` | output | 1 | 69,159 | 3 | 138,319 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lunar rover finally reached planet X. After landing, he met an obstacle, that contains permutation p of length n. Scientists found out, that to overcome an obstacle, the robot should make p an identity permutation (make p_i = i for all i).
Unfortunately, scientists can't control the robot. Thus the only way to make p an identity permutation is applying the following operation to p multiple times:
* Select two indices i and j (i β j), such that p_j = i and swap the values of p_i and p_j. It takes robot (j - i)^2 seconds to do this operation.
Positions i and j are selected by the robot (scientists can't control it). He will apply this operation while p isn't an identity permutation. We can show that the robot will make no more than n operations regardless of the choice of i and j on each operation.
Scientists asked you to find out the maximum possible time it will take the robot to finish making p an identity permutation (i. e. worst-case scenario), so they can decide whether they should construct a new lunar rover or just rest and wait. They won't believe you without proof, so you should build an example of p and robot's operations that maximizes the answer.
For a better understanding of the statement, read the sample description.
Input
The first line of input contains a single integer t (1 β€ t β€ 10^4) β the number of test cases.
Each of next t lines contains the single integer n (2 β€ n β€ 10^5) β the length of p.
Note, that p is not given to you. You should find the maximum possible time over all permutations of length n.
It is guaranteed, that the total sum of n over all test cases doesn't exceed 10^5.
Output
For each test case in the first line, print how many seconds will the robot spend in the worst case.
In the next line, print the initial value of p that you used to construct an answer.
In the next line, print the number of operations m β€ n that the robot makes in your example.
In the each of next m lines print two integers i and j β indices of positions that the robot will swap on this operation. Note that p_j = i must holds (at the time of operation).
Example
Input
3
2
3
3
Output
1
2 1
1
2 1
5
2 3 1
2
1 3
3 2
5
2 3 1
2
1 3
2 3
Note
For n = 2, p can be either [1, 2] or [2, 1]. In the first case p is already identity, otherwise robot will make it an identity permutation in 1 second regardless of choise i and j on the first operation.
For n = 3, p can be equals [2, 3, 1].
* If robot will select i = 3, j = 2 on the first operation, p will become [2, 1, 3] in one second. Now robot can select only i = 1, j = 2 or i = 2, j = 1. In both cases, p will become identity in one more second (2 seconds in total).
* If robot will select i = 1, j = 3 on the first operation, p will become [1, 3, 2] in four seconds. Regardless of choise of i and j on the second operation, p will become identity in five seconds.
We can show, that for permutation of length 3 robot will always finish all operation in no more than 5 seconds. | instruction | 0 | 69,160 | 3 | 138,320 |
Tags: constructive algorithms, greedy
Correct Solution:
```
def ints():
return list(map(int, input().split()))
def go():
n, = ints()
if n <= 3:
print(sum(i**2 for i in range(n)))
print(' '.join(map(str, range(2, n+1))), 1)
print(n-1)
for i in range(1, n):
print(i, n)
else:
print(sum(max(i-1, n-i)**2 for i in range(1, n)))
m = n // 2 + 1
A = list(range(2, m))
B = list(range(m, n))
cycle = [1] + B + [n] + A
p = [None] * (n+1)
for i in range(n):
u = cycle[i]
v = cycle[(i+1)%n]
p[u] = v
print(*p[1:])
#print(1, A, B, n)
print(n-1)
for b in B:
print(b, 1)
for a in A:
print(a, n)
print(1, n)
if __name__ == '__main__':
num_cases, = ints()
for case_num in range(num_cases):
go()
``` | output | 1 | 69,160 | 3 | 138,321 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lunar rover finally reached planet X. After landing, he met an obstacle, that contains permutation p of length n. Scientists found out, that to overcome an obstacle, the robot should make p an identity permutation (make p_i = i for all i).
Unfortunately, scientists can't control the robot. Thus the only way to make p an identity permutation is applying the following operation to p multiple times:
* Select two indices i and j (i β j), such that p_j = i and swap the values of p_i and p_j. It takes robot (j - i)^2 seconds to do this operation.
Positions i and j are selected by the robot (scientists can't control it). He will apply this operation while p isn't an identity permutation. We can show that the robot will make no more than n operations regardless of the choice of i and j on each operation.
Scientists asked you to find out the maximum possible time it will take the robot to finish making p an identity permutation (i. e. worst-case scenario), so they can decide whether they should construct a new lunar rover or just rest and wait. They won't believe you without proof, so you should build an example of p and robot's operations that maximizes the answer.
For a better understanding of the statement, read the sample description.
Input
The first line of input contains a single integer t (1 β€ t β€ 10^4) β the number of test cases.
Each of next t lines contains the single integer n (2 β€ n β€ 10^5) β the length of p.
Note, that p is not given to you. You should find the maximum possible time over all permutations of length n.
It is guaranteed, that the total sum of n over all test cases doesn't exceed 10^5.
Output
For each test case in the first line, print how many seconds will the robot spend in the worst case.
In the next line, print the initial value of p that you used to construct an answer.
In the next line, print the number of operations m β€ n that the robot makes in your example.
In the each of next m lines print two integers i and j β indices of positions that the robot will swap on this operation. Note that p_j = i must holds (at the time of operation).
Example
Input
3
2
3
3
Output
1
2 1
1
2 1
5
2 3 1
2
1 3
3 2
5
2 3 1
2
1 3
2 3
Note
For n = 2, p can be either [1, 2] or [2, 1]. In the first case p is already identity, otherwise robot will make it an identity permutation in 1 second regardless of choise i and j on the first operation.
For n = 3, p can be equals [2, 3, 1].
* If robot will select i = 3, j = 2 on the first operation, p will become [2, 1, 3] in one second. Now robot can select only i = 1, j = 2 or i = 2, j = 1. In both cases, p will become identity in one more second (2 seconds in total).
* If robot will select i = 1, j = 3 on the first operation, p will become [1, 3, 2] in four seconds. Regardless of choise of i and j on the second operation, p will become identity in five seconds.
We can show, that for permutation of length 3 robot will always finish all operation in no more than 5 seconds. | instruction | 0 | 69,161 | 3 | 138,322 |
Tags: constructive algorithms, greedy
Correct Solution:
```
# Author: yumtam
# Created at: 2021-03-02 22:32
def solve():
n = int(input())
A = list(range(1, n+1))
ops = []
ans = 0
def process(i, j):
nonlocal ans
A[i], A[j] = A[j], A[i]
ops.append((i+1, j+1))
ans += (i-j)**2
process(0, n-1)
rem = n-2
d = 2
while rem:
process(n-d, 0)
rem -= 1
if rem == 0:
break
process(d-1, n-1)
rem -= 1
d += 1
print(ans)
print(*A)
print(len(ops))
for i, j in reversed(ops):
print(i, j)
import sys, os, io
input = lambda: sys.stdin.readline().rstrip('\r\n')
stdout = io.BytesIO()
sys.stdout.write = lambda s: stdout.write(s.encode("ascii"))
for _ in range(int(input())):
solve()
os.write(1, stdout.getvalue())
``` | output | 1 | 69,161 | 3 | 138,323 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lunar rover finally reached planet X. After landing, he met an obstacle, that contains permutation p of length n. Scientists found out, that to overcome an obstacle, the robot should make p an identity permutation (make p_i = i for all i).
Unfortunately, scientists can't control the robot. Thus the only way to make p an identity permutation is applying the following operation to p multiple times:
* Select two indices i and j (i β j), such that p_j = i and swap the values of p_i and p_j. It takes robot (j - i)^2 seconds to do this operation.
Positions i and j are selected by the robot (scientists can't control it). He will apply this operation while p isn't an identity permutation. We can show that the robot will make no more than n operations regardless of the choice of i and j on each operation.
Scientists asked you to find out the maximum possible time it will take the robot to finish making p an identity permutation (i. e. worst-case scenario), so they can decide whether they should construct a new lunar rover or just rest and wait. They won't believe you without proof, so you should build an example of p and robot's operations that maximizes the answer.
For a better understanding of the statement, read the sample description.
Input
The first line of input contains a single integer t (1 β€ t β€ 10^4) β the number of test cases.
Each of next t lines contains the single integer n (2 β€ n β€ 10^5) β the length of p.
Note, that p is not given to you. You should find the maximum possible time over all permutations of length n.
It is guaranteed, that the total sum of n over all test cases doesn't exceed 10^5.
Output
For each test case in the first line, print how many seconds will the robot spend in the worst case.
In the next line, print the initial value of p that you used to construct an answer.
In the next line, print the number of operations m β€ n that the robot makes in your example.
In the each of next m lines print two integers i and j β indices of positions that the robot will swap on this operation. Note that p_j = i must holds (at the time of operation).
Example
Input
3
2
3
3
Output
1
2 1
1
2 1
5
2 3 1
2
1 3
3 2
5
2 3 1
2
1 3
2 3
Note
For n = 2, p can be either [1, 2] or [2, 1]. In the first case p is already identity, otherwise robot will make it an identity permutation in 1 second regardless of choise i and j on the first operation.
For n = 3, p can be equals [2, 3, 1].
* If robot will select i = 3, j = 2 on the first operation, p will become [2, 1, 3] in one second. Now robot can select only i = 1, j = 2 or i = 2, j = 1. In both cases, p will become identity in one more second (2 seconds in total).
* If robot will select i = 1, j = 3 on the first operation, p will become [1, 3, 2] in four seconds. Regardless of choise of i and j on the second operation, p will become identity in five seconds.
We can show, that for permutation of length 3 robot will always finish all operation in no more than 5 seconds. | instruction | 0 | 69,162 | 3 | 138,324 |
Tags: constructive algorithms, greedy
Correct Solution:
```
import sys
input=sys.stdin.readline
t = int(input())
for _ in range(t):
n = int(input())
time = 0
integer = [i for i in range(1,n+1)]
l = []
for i in range(n//2,n):
time += i**2
integer[0],integer[i] = integer[i],integer[0]
l.append((i+1,1))
for i in range(1,n//2):
time += (n-1-i)**2
integer[-1],integer[i] = integer[i],integer[-1]
l.append((i+1,n))
l.reverse()
print(time)
print(*integer)
print(len(l))
for i in l:
print(i[0],i[1])
``` | output | 1 | 69,162 | 3 | 138,325 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Lunar rover finally reached planet X. After landing, he met an obstacle, that contains permutation p of length n. Scientists found out, that to overcome an obstacle, the robot should make p an identity permutation (make p_i = i for all i).
Unfortunately, scientists can't control the robot. Thus the only way to make p an identity permutation is applying the following operation to p multiple times:
* Select two indices i and j (i β j), such that p_j = i and swap the values of p_i and p_j. It takes robot (j - i)^2 seconds to do this operation.
Positions i and j are selected by the robot (scientists can't control it). He will apply this operation while p isn't an identity permutation. We can show that the robot will make no more than n operations regardless of the choice of i and j on each operation.
Scientists asked you to find out the maximum possible time it will take the robot to finish making p an identity permutation (i. e. worst-case scenario), so they can decide whether they should construct a new lunar rover or just rest and wait. They won't believe you without proof, so you should build an example of p and robot's operations that maximizes the answer.
For a better understanding of the statement, read the sample description.
Input
The first line of input contains a single integer t (1 β€ t β€ 10^4) β the number of test cases.
Each of next t lines contains the single integer n (2 β€ n β€ 10^5) β the length of p.
Note, that p is not given to you. You should find the maximum possible time over all permutations of length n.
It is guaranteed, that the total sum of n over all test cases doesn't exceed 10^5.
Output
For each test case in the first line, print how many seconds will the robot spend in the worst case.
In the next line, print the initial value of p that you used to construct an answer.
In the next line, print the number of operations m β€ n that the robot makes in your example.
In the each of next m lines print two integers i and j β indices of positions that the robot will swap on this operation. Note that p_j = i must holds (at the time of operation).
Example
Input
3
2
3
3
Output
1
2 1
1
2 1
5
2 3 1
2
1 3
3 2
5
2 3 1
2
1 3
2 3
Note
For n = 2, p can be either [1, 2] or [2, 1]. In the first case p is already identity, otherwise robot will make it an identity permutation in 1 second regardless of choise i and j on the first operation.
For n = 3, p can be equals [2, 3, 1].
* If robot will select i = 3, j = 2 on the first operation, p will become [2, 1, 3] in one second. Now robot can select only i = 1, j = 2 or i = 2, j = 1. In both cases, p will become identity in one more second (2 seconds in total).
* If robot will select i = 1, j = 3 on the first operation, p will become [1, 3, 2] in four seconds. Regardless of choise of i and j on the second operation, p will become identity in five seconds.
We can show, that for permutation of length 3 robot will always finish all operation in no more than 5 seconds.
Submitted Solution:
```
import sys
input = sys.stdin.readline
for _ in range(int(input())):
N = int(input())
res = [i for i in range(1, N + 1)]
qs = []
c = 0
for i in range(N // 2, N):
qs.append((i + 1, 1))
res[0], res[i] = res[i], res[0]
c += i ** 2
for i in range(1, N // 2):
qs.append((i + 1, N))
res[-1], res[i] = res[i], res[-1]
c += (N - i - 1) ** 2
print(c)
print(*res)
qs.reverse()
print(len(qs))
for q in qs: print(*q)
``` | instruction | 0 | 69,163 | 3 | 138,326 |
Yes | output | 1 | 69,163 | 3 | 138,327 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Lunar rover finally reached planet X. After landing, he met an obstacle, that contains permutation p of length n. Scientists found out, that to overcome an obstacle, the robot should make p an identity permutation (make p_i = i for all i).
Unfortunately, scientists can't control the robot. Thus the only way to make p an identity permutation is applying the following operation to p multiple times:
* Select two indices i and j (i β j), such that p_j = i and swap the values of p_i and p_j. It takes robot (j - i)^2 seconds to do this operation.
Positions i and j are selected by the robot (scientists can't control it). He will apply this operation while p isn't an identity permutation. We can show that the robot will make no more than n operations regardless of the choice of i and j on each operation.
Scientists asked you to find out the maximum possible time it will take the robot to finish making p an identity permutation (i. e. worst-case scenario), so they can decide whether they should construct a new lunar rover or just rest and wait. They won't believe you without proof, so you should build an example of p and robot's operations that maximizes the answer.
For a better understanding of the statement, read the sample description.
Input
The first line of input contains a single integer t (1 β€ t β€ 10^4) β the number of test cases.
Each of next t lines contains the single integer n (2 β€ n β€ 10^5) β the length of p.
Note, that p is not given to you. You should find the maximum possible time over all permutations of length n.
It is guaranteed, that the total sum of n over all test cases doesn't exceed 10^5.
Output
For each test case in the first line, print how many seconds will the robot spend in the worst case.
In the next line, print the initial value of p that you used to construct an answer.
In the next line, print the number of operations m β€ n that the robot makes in your example.
In the each of next m lines print two integers i and j β indices of positions that the robot will swap on this operation. Note that p_j = i must holds (at the time of operation).
Example
Input
3
2
3
3
Output
1
2 1
1
2 1
5
2 3 1
2
1 3
3 2
5
2 3 1
2
1 3
2 3
Note
For n = 2, p can be either [1, 2] or [2, 1]. In the first case p is already identity, otherwise robot will make it an identity permutation in 1 second regardless of choise i and j on the first operation.
For n = 3, p can be equals [2, 3, 1].
* If robot will select i = 3, j = 2 on the first operation, p will become [2, 1, 3] in one second. Now robot can select only i = 1, j = 2 or i = 2, j = 1. In both cases, p will become identity in one more second (2 seconds in total).
* If robot will select i = 1, j = 3 on the first operation, p will become [1, 3, 2] in four seconds. Regardless of choise of i and j on the second operation, p will become identity in five seconds.
We can show, that for permutation of length 3 robot will always finish all operation in no more than 5 seconds.
Submitted Solution:
```
for tests in range(int(input())):
n=int(input());AA=[(1,i) for i in range((n+2)//2,n)] + [(i,n) for i in range((n+2)//2-1,0,-1)];L=list(range(1,n+1));sc=0
for x,y in AA[::-1]:L[x-1],L[y-1]=L[y-1],L[x-1];sc+=(x-y)**2
print(sc);print(*L);print(len(AA))
for x,y in AA:print(y,x) if L[x-1]==y else print(x,y);L[x-1],L[y-1]=L[y-1],L[x-1]
``` | instruction | 0 | 69,164 | 3 | 138,328 |
Yes | output | 1 | 69,164 | 3 | 138,329 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Lunar rover finally reached planet X. After landing, he met an obstacle, that contains permutation p of length n. Scientists found out, that to overcome an obstacle, the robot should make p an identity permutation (make p_i = i for all i).
Unfortunately, scientists can't control the robot. Thus the only way to make p an identity permutation is applying the following operation to p multiple times:
* Select two indices i and j (i β j), such that p_j = i and swap the values of p_i and p_j. It takes robot (j - i)^2 seconds to do this operation.
Positions i and j are selected by the robot (scientists can't control it). He will apply this operation while p isn't an identity permutation. We can show that the robot will make no more than n operations regardless of the choice of i and j on each operation.
Scientists asked you to find out the maximum possible time it will take the robot to finish making p an identity permutation (i. e. worst-case scenario), so they can decide whether they should construct a new lunar rover or just rest and wait. They won't believe you without proof, so you should build an example of p and robot's operations that maximizes the answer.
For a better understanding of the statement, read the sample description.
Input
The first line of input contains a single integer t (1 β€ t β€ 10^4) β the number of test cases.
Each of next t lines contains the single integer n (2 β€ n β€ 10^5) β the length of p.
Note, that p is not given to you. You should find the maximum possible time over all permutations of length n.
It is guaranteed, that the total sum of n over all test cases doesn't exceed 10^5.
Output
For each test case in the first line, print how many seconds will the robot spend in the worst case.
In the next line, print the initial value of p that you used to construct an answer.
In the next line, print the number of operations m β€ n that the robot makes in your example.
In the each of next m lines print two integers i and j β indices of positions that the robot will swap on this operation. Note that p_j = i must holds (at the time of operation).
Example
Input
3
2
3
3
Output
1
2 1
1
2 1
5
2 3 1
2
1 3
3 2
5
2 3 1
2
1 3
2 3
Note
For n = 2, p can be either [1, 2] or [2, 1]. In the first case p is already identity, otherwise robot will make it an identity permutation in 1 second regardless of choise i and j on the first operation.
For n = 3, p can be equals [2, 3, 1].
* If robot will select i = 3, j = 2 on the first operation, p will become [2, 1, 3] in one second. Now robot can select only i = 1, j = 2 or i = 2, j = 1. In both cases, p will become identity in one more second (2 seconds in total).
* If robot will select i = 1, j = 3 on the first operation, p will become [1, 3, 2] in four seconds. Regardless of choise of i and j on the second operation, p will become identity in five seconds.
We can show, that for permutation of length 3 robot will always finish all operation in no more than 5 seconds.
Submitted Solution:
```
def main():
n=int(*input().split())
L=[x for x in range(n+1)];ans=[]
def swp(x,y):
L[x],L[y]=L[y],L[x]
swp(1,n);ans.append((1,n))
for i in range(2,(n+1)//2+1):
swp(i,n);ans.append((i,n))
if not n-i+1==i: swp(n-i+1,1);ans.append((n-i+1,1))
val=sum((i-j)*(i-j) for i,j in ans)
print(val)
for x in range(1,n+1): print(L[x],end=' ')
print("\n%d"%(n-1,))
for x in range(n-2,-1,-1): print(ans[x][0],ans[x][1])
T=int(*input().split())
for ii in range(T):
main()
``` | instruction | 0 | 69,165 | 3 | 138,330 |
Yes | output | 1 | 69,165 | 3 | 138,331 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.