message stringlengths 2 44.5k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 276 109k | cluster float64 23 23 | __index_level_0__ int64 552 217k |
|---|---|---|---|---|---|
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has N sticks that are distinguishable from each other. The length of the i-th stick is L_i.
He is going to form a triangle using three of these sticks. Let a, b, and c be the lengths of the three sticks used. Here, all of the following conditions must be satisfied:
* a < b + c
* b < c + a
* c < a + b
How many different triangles can be formed? Two triangles are considered different when there is a stick used in only one of them.
Constraints
* All values in input are integers.
* 3 \leq N \leq 2 \times 10^3
* 1 \leq L_i \leq 10^3
Input
Input is given from Standard Input in the following format:
N
L_1 L_2 ... L_N
Constraints
Print the number of different triangles that can be formed.
Constraints
Print the number of different triangles that can be formed.
Input
Input is given from Standard Input in the following format:
N
L_1 L_2 ... L_N
Examples
Input
4
3 4 2 1
Output
1
Input
3
1 1000 1
Output
0
Input
7
218 786 704 233 645 728 389
Output
23 | instruction | 0 | 23,596 | 23 | 47,192 |
"Correct Solution:
```
from bisect import bisect_left
N = int(input())
L = sorted(list(map(int, input().split())))
ans = 0
for i in range(N):
for j in range(i+1,N):
ans += bisect_left(L, L[i]+L[j])-j-1
print(ans)
``` | output | 1 | 23,596 | 23 | 47,193 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has N sticks that are distinguishable from each other. The length of the i-th stick is L_i.
He is going to form a triangle using three of these sticks. Let a, b, and c be the lengths of the three sticks used. Here, all of the following conditions must be satisfied:
* a < b + c
* b < c + a
* c < a + b
How many different triangles can be formed? Two triangles are considered different when there is a stick used in only one of them.
Constraints
* All values in input are integers.
* 3 \leq N \leq 2 \times 10^3
* 1 \leq L_i \leq 10^3
Input
Input is given from Standard Input in the following format:
N
L_1 L_2 ... L_N
Constraints
Print the number of different triangles that can be formed.
Constraints
Print the number of different triangles that can be formed.
Input
Input is given from Standard Input in the following format:
N
L_1 L_2 ... L_N
Examples
Input
4
3 4 2 1
Output
1
Input
3
1 1000 1
Output
0
Input
7
218 786 704 233 645 728 389
Output
23 | instruction | 0 | 23,597 | 23 | 47,194 |
"Correct Solution:
```
import bisect
n=int(input())
l=sorted(list(map(int,input().split())))
ans=0
for i in range(n):
for j in range(i+1,n):
ans+=max(bisect.bisect_left(l,l[i]+l[j])-j-1,0)
print(ans)
``` | output | 1 | 23,597 | 23 | 47,195 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has N sticks that are distinguishable from each other. The length of the i-th stick is L_i.
He is going to form a triangle using three of these sticks. Let a, b, and c be the lengths of the three sticks used. Here, all of the following conditions must be satisfied:
* a < b + c
* b < c + a
* c < a + b
How many different triangles can be formed? Two triangles are considered different when there is a stick used in only one of them.
Constraints
* All values in input are integers.
* 3 \leq N \leq 2 \times 10^3
* 1 \leq L_i \leq 10^3
Input
Input is given from Standard Input in the following format:
N
L_1 L_2 ... L_N
Constraints
Print the number of different triangles that can be formed.
Constraints
Print the number of different triangles that can be formed.
Input
Input is given from Standard Input in the following format:
N
L_1 L_2 ... L_N
Examples
Input
4
3 4 2 1
Output
1
Input
3
1 1000 1
Output
0
Input
7
218 786 704 233 645 728 389
Output
23
Submitted Solution:
```
import bisect
n=int(input())
l=list(map(int,input().split()))
l=sorted(l)
ans=0
for i in range(n-2):
for j in range(i+1,n-1):
idx=bisect.bisect_right(l,l[i]+l[j]-1,j+1)
ans+=idx-(j+1)
print(ans)
``` | instruction | 0 | 23,598 | 23 | 47,196 |
Yes | output | 1 | 23,598 | 23 | 47,197 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has N sticks that are distinguishable from each other. The length of the i-th stick is L_i.
He is going to form a triangle using three of these sticks. Let a, b, and c be the lengths of the three sticks used. Here, all of the following conditions must be satisfied:
* a < b + c
* b < c + a
* c < a + b
How many different triangles can be formed? Two triangles are considered different when there is a stick used in only one of them.
Constraints
* All values in input are integers.
* 3 \leq N \leq 2 \times 10^3
* 1 \leq L_i \leq 10^3
Input
Input is given from Standard Input in the following format:
N
L_1 L_2 ... L_N
Constraints
Print the number of different triangles that can be formed.
Constraints
Print the number of different triangles that can be formed.
Input
Input is given from Standard Input in the following format:
N
L_1 L_2 ... L_N
Examples
Input
4
3 4 2 1
Output
1
Input
3
1 1000 1
Output
0
Input
7
218 786 704 233 645 728 389
Output
23
Submitted Solution:
```
from bisect import bisect_left
n = int(input())
l = sorted(list(map(int,input().split())))
ans = 0
for i in range(n):
for j in range(i+1,n):
ans += bisect_left(l,l[i]+l[j])-(j+1)
print(ans)
``` | instruction | 0 | 23,599 | 23 | 47,198 |
Yes | output | 1 | 23,599 | 23 | 47,199 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has N sticks that are distinguishable from each other. The length of the i-th stick is L_i.
He is going to form a triangle using three of these sticks. Let a, b, and c be the lengths of the three sticks used. Here, all of the following conditions must be satisfied:
* a < b + c
* b < c + a
* c < a + b
How many different triangles can be formed? Two triangles are considered different when there is a stick used in only one of them.
Constraints
* All values in input are integers.
* 3 \leq N \leq 2 \times 10^3
* 1 \leq L_i \leq 10^3
Input
Input is given from Standard Input in the following format:
N
L_1 L_2 ... L_N
Constraints
Print the number of different triangles that can be formed.
Constraints
Print the number of different triangles that can be formed.
Input
Input is given from Standard Input in the following format:
N
L_1 L_2 ... L_N
Examples
Input
4
3 4 2 1
Output
1
Input
3
1 1000 1
Output
0
Input
7
218 786 704 233 645 728 389
Output
23
Submitted Solution:
```
from bisect import*
_,l=open(0)
l=sorted(map(int,l.split()))
e=enumerate
print(sum(j-bisect(l,a-b,0,j)for i,a in e(l)for j,b in e(l[:i])))
``` | instruction | 0 | 23,600 | 23 | 47,200 |
Yes | output | 1 | 23,600 | 23 | 47,201 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has N sticks that are distinguishable from each other. The length of the i-th stick is L_i.
He is going to form a triangle using three of these sticks. Let a, b, and c be the lengths of the three sticks used. Here, all of the following conditions must be satisfied:
* a < b + c
* b < c + a
* c < a + b
How many different triangles can be formed? Two triangles are considered different when there is a stick used in only one of them.
Constraints
* All values in input are integers.
* 3 \leq N \leq 2 \times 10^3
* 1 \leq L_i \leq 10^3
Input
Input is given from Standard Input in the following format:
N
L_1 L_2 ... L_N
Constraints
Print the number of different triangles that can be formed.
Constraints
Print the number of different triangles that can be formed.
Input
Input is given from Standard Input in the following format:
N
L_1 L_2 ... L_N
Examples
Input
4
3 4 2 1
Output
1
Input
3
1 1000 1
Output
0
Input
7
218 786 704 233 645 728 389
Output
23
Submitted Solution:
```
#16:18
n = int(input())
l = list(map(int,input().split()))
l.sort()
ans = 0
import bisect
for i in range(n):
for j in range(i+1,n):
ans += max(0,bisect.bisect_left(l,l[i]+l[j])-j-1)
print(ans)
``` | instruction | 0 | 23,601 | 23 | 47,202 |
Yes | output | 1 | 23,601 | 23 | 47,203 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has N sticks that are distinguishable from each other. The length of the i-th stick is L_i.
He is going to form a triangle using three of these sticks. Let a, b, and c be the lengths of the three sticks used. Here, all of the following conditions must be satisfied:
* a < b + c
* b < c + a
* c < a + b
How many different triangles can be formed? Two triangles are considered different when there is a stick used in only one of them.
Constraints
* All values in input are integers.
* 3 \leq N \leq 2 \times 10^3
* 1 \leq L_i \leq 10^3
Input
Input is given from Standard Input in the following format:
N
L_1 L_2 ... L_N
Constraints
Print the number of different triangles that can be formed.
Constraints
Print the number of different triangles that can be formed.
Input
Input is given from Standard Input in the following format:
N
L_1 L_2 ... L_N
Examples
Input
4
3 4 2 1
Output
1
Input
3
1 1000 1
Output
0
Input
7
218 786 704 233 645 728 389
Output
23
Submitted Solution:
```
n=int(input())
L=list(map(int,input().split()))
L.sort()
count=0
list.sort(L, reverse=True)
for i in range(n):
for j in range(i+1,n):
for k in range(j+1,n):
if L[k]>L[i]-L[j]:
count += 1
print(count)
``` | instruction | 0 | 23,602 | 23 | 47,204 |
No | output | 1 | 23,602 | 23 | 47,205 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has N sticks that are distinguishable from each other. The length of the i-th stick is L_i.
He is going to form a triangle using three of these sticks. Let a, b, and c be the lengths of the three sticks used. Here, all of the following conditions must be satisfied:
* a < b + c
* b < c + a
* c < a + b
How many different triangles can be formed? Two triangles are considered different when there is a stick used in only one of them.
Constraints
* All values in input are integers.
* 3 \leq N \leq 2 \times 10^3
* 1 \leq L_i \leq 10^3
Input
Input is given from Standard Input in the following format:
N
L_1 L_2 ... L_N
Constraints
Print the number of different triangles that can be formed.
Constraints
Print the number of different triangles that can be formed.
Input
Input is given from Standard Input in the following format:
N
L_1 L_2 ... L_N
Examples
Input
4
3 4 2 1
Output
1
Input
3
1 1000 1
Output
0
Input
7
218 786 704 233 645 728 389
Output
23
Submitted Solution:
```
import itertools
n = int(input())
l = list(map(int, input().split()))
a = list(itertools.combinations(l,3))
b = list(filter(lambda c: c[0] < c[1]+c[2] and c[1] < c[2]+c[0] and c[2] < c[0]+c[1], a))
print(len(b))
``` | instruction | 0 | 23,603 | 23 | 47,206 |
No | output | 1 | 23,603 | 23 | 47,207 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has N sticks that are distinguishable from each other. The length of the i-th stick is L_i.
He is going to form a triangle using three of these sticks. Let a, b, and c be the lengths of the three sticks used. Here, all of the following conditions must be satisfied:
* a < b + c
* b < c + a
* c < a + b
How many different triangles can be formed? Two triangles are considered different when there is a stick used in only one of them.
Constraints
* All values in input are integers.
* 3 \leq N \leq 2 \times 10^3
* 1 \leq L_i \leq 10^3
Input
Input is given from Standard Input in the following format:
N
L_1 L_2 ... L_N
Constraints
Print the number of different triangles that can be formed.
Constraints
Print the number of different triangles that can be formed.
Input
Input is given from Standard Input in the following format:
N
L_1 L_2 ... L_N
Examples
Input
4
3 4 2 1
Output
1
Input
3
1 1000 1
Output
0
Input
7
218 786 704 233 645 728 389
Output
23
Submitted Solution:
```
from itertools import combinations
import math
N=int(input())
l1=list(map(int,input().split()))
max_n=max(l1)
l2=tuple(combinations(l1,2))
l3=[sum(i) for i in l2 if sum(i)<=max_n]
def comb(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
ans=comb(N,3)
for i in l3:
for j in l1:
if i<=j:
ans-=1
print(ans)
``` | instruction | 0 | 23,604 | 23 | 47,208 |
No | output | 1 | 23,604 | 23 | 47,209 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has N sticks that are distinguishable from each other. The length of the i-th stick is L_i.
He is going to form a triangle using three of these sticks. Let a, b, and c be the lengths of the three sticks used. Here, all of the following conditions must be satisfied:
* a < b + c
* b < c + a
* c < a + b
How many different triangles can be formed? Two triangles are considered different when there is a stick used in only one of them.
Constraints
* All values in input are integers.
* 3 \leq N \leq 2 \times 10^3
* 1 \leq L_i \leq 10^3
Input
Input is given from Standard Input in the following format:
N
L_1 L_2 ... L_N
Constraints
Print the number of different triangles that can be formed.
Constraints
Print the number of different triangles that can be formed.
Input
Input is given from Standard Input in the following format:
N
L_1 L_2 ... L_N
Examples
Input
4
3 4 2 1
Output
1
Input
3
1 1000 1
Output
0
Input
7
218 786 704 233 645 728 389
Output
23
Submitted Solution:
```
import bisect
from itertools import combinations
from collections import Counter
N = int(input())
l = map(int,input().split())
l = sorted(l)
l_dict = dict()
c = Counter(l)
for i,one in enumerate(l):
if not one in l_dict:
l_dict[one] = i
counter = 0
uni = len(c)
for one in c:
if c[one] == 1:
continue
elif c[one]==2:
num = c[one]
counter -= num*(num-1)/2*(uni-1)
else:
num = c[one]
counter -= num*(num-1)/2*(uni-1) +((num*(num-1)**2)/2- num*(num-1)*(num-2)/6)
counter = int(counter)
for a,b in combinations(l,2):
tmp = a + b
counter += bisect.bisect_left(l[l_dict[b]+1:],tmp)
print(counter)
``` | instruction | 0 | 23,605 | 23 | 47,210 |
No | output | 1 | 23,605 | 23 | 47,211 |
Provide a correct Python 3 solution for this coding contest problem.
Given an integer N not less than 3, find the sum of the interior angles of a regular polygon with N sides.
Print the answer in degrees, but do not print units.
Constraints
* 3 \leq N \leq 100
Input
Input is given from Standard Input in the following format:
N
Output
Print an integer representing the sum of the interior angles of a regular polygon with N sides.
Examples
Input
3
Output
180
Input
100
Output
17640 | instruction | 0 | 23,606 | 23 | 47,212 |
"Correct Solution:
```
n = int(input())
calc = 180*(n-2)
print(calc)
``` | output | 1 | 23,606 | 23 | 47,213 |
Provide a correct Python 3 solution for this coding contest problem.
Given an integer N not less than 3, find the sum of the interior angles of a regular polygon with N sides.
Print the answer in degrees, but do not print units.
Constraints
* 3 \leq N \leq 100
Input
Input is given from Standard Input in the following format:
N
Output
Print an integer representing the sum of the interior angles of a regular polygon with N sides.
Examples
Input
3
Output
180
Input
100
Output
17640 | instruction | 0 | 23,607 | 23 | 47,214 |
"Correct Solution:
```
import sys
input = sys.stdin.readline
N, = map(int, input().split())
print((N - 2) * 180)
``` | output | 1 | 23,607 | 23 | 47,215 |
Provide a correct Python 3 solution for this coding contest problem.
Given an integer N not less than 3, find the sum of the interior angles of a regular polygon with N sides.
Print the answer in degrees, but do not print units.
Constraints
* 3 \leq N \leq 100
Input
Input is given from Standard Input in the following format:
N
Output
Print an integer representing the sum of the interior angles of a regular polygon with N sides.
Examples
Input
3
Output
180
Input
100
Output
17640 | instruction | 0 | 23,608 | 23 | 47,216 |
"Correct Solution:
```
N = int(input())
print(180*(N-2))
``` | output | 1 | 23,608 | 23 | 47,217 |
Provide a correct Python 3 solution for this coding contest problem.
Given an integer N not less than 3, find the sum of the interior angles of a regular polygon with N sides.
Print the answer in degrees, but do not print units.
Constraints
* 3 \leq N \leq 100
Input
Input is given from Standard Input in the following format:
N
Output
Print an integer representing the sum of the interior angles of a regular polygon with N sides.
Examples
Input
3
Output
180
Input
100
Output
17640 | instruction | 0 | 23,609 | 23 | 47,218 |
"Correct Solution:
```
#!/usr/bin/env python3
n = int(input())
print((n-2)*180)
``` | output | 1 | 23,609 | 23 | 47,219 |
Provide a correct Python 3 solution for this coding contest problem.
Given an integer N not less than 3, find the sum of the interior angles of a regular polygon with N sides.
Print the answer in degrees, but do not print units.
Constraints
* 3 \leq N \leq 100
Input
Input is given from Standard Input in the following format:
N
Output
Print an integer representing the sum of the interior angles of a regular polygon with N sides.
Examples
Input
3
Output
180
Input
100
Output
17640 | instruction | 0 | 23,610 | 23 | 47,220 |
"Correct Solution:
```
# M-SOLUTIONS γγγ³γ³γͺγΌγγ³: A β Sum of Interior Angles
print((int(input()) - 2) * 180)
``` | output | 1 | 23,610 | 23 | 47,221 |
Provide a correct Python 3 solution for this coding contest problem.
Given an integer N not less than 3, find the sum of the interior angles of a regular polygon with N sides.
Print the answer in degrees, but do not print units.
Constraints
* 3 \leq N \leq 100
Input
Input is given from Standard Input in the following format:
N
Output
Print an integer representing the sum of the interior angles of a regular polygon with N sides.
Examples
Input
3
Output
180
Input
100
Output
17640 | instruction | 0 | 23,611 | 23 | 47,222 |
"Correct Solution:
```
n = int(input())
y = (n-2) * 180
print(y)
``` | output | 1 | 23,611 | 23 | 47,223 |
Provide a correct Python 3 solution for this coding contest problem.
Given an integer N not less than 3, find the sum of the interior angles of a regular polygon with N sides.
Print the answer in degrees, but do not print units.
Constraints
* 3 \leq N \leq 100
Input
Input is given from Standard Input in the following format:
N
Output
Print an integer representing the sum of the interior angles of a regular polygon with N sides.
Examples
Input
3
Output
180
Input
100
Output
17640 | instruction | 0 | 23,612 | 23 | 47,224 |
"Correct Solution:
```
N = int(input())
ans = (N - 2) * 180
print('{}'.format(ans))
``` | output | 1 | 23,612 | 23 | 47,225 |
Provide a correct Python 3 solution for this coding contest problem.
Given an integer N not less than 3, find the sum of the interior angles of a regular polygon with N sides.
Print the answer in degrees, but do not print units.
Constraints
* 3 \leq N \leq 100
Input
Input is given from Standard Input in the following format:
N
Output
Print an integer representing the sum of the interior angles of a regular polygon with N sides.
Examples
Input
3
Output
180
Input
100
Output
17640 | instruction | 0 | 23,613 | 23 | 47,226 |
"Correct Solution:
```
n = int(input())
def polygon(n):
return 180 * (n-2)
print(polygon(n))
``` | output | 1 | 23,613 | 23 | 47,227 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given an integer N not less than 3, find the sum of the interior angles of a regular polygon with N sides.
Print the answer in degrees, but do not print units.
Constraints
* 3 \leq N \leq 100
Input
Input is given from Standard Input in the following format:
N
Output
Print an integer representing the sum of the interior angles of a regular polygon with N sides.
Examples
Input
3
Output
180
Input
100
Output
17640
Submitted Solution:
```
n = int(input())
ans = (180-360/n)*n
print(int(ans))
``` | instruction | 0 | 23,614 | 23 | 47,228 |
Yes | output | 1 | 23,614 | 23 | 47,229 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given an integer N not less than 3, find the sum of the interior angles of a regular polygon with N sides.
Print the answer in degrees, but do not print units.
Constraints
* 3 \leq N \leq 100
Input
Input is given from Standard Input in the following format:
N
Output
Print an integer representing the sum of the interior angles of a regular polygon with N sides.
Examples
Input
3
Output
180
Input
100
Output
17640
Submitted Solution:
```
num = int(input())
print((180*num)-360)
``` | instruction | 0 | 23,615 | 23 | 47,230 |
Yes | output | 1 | 23,615 | 23 | 47,231 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given an integer N not less than 3, find the sum of the interior angles of a regular polygon with N sides.
Print the answer in degrees, but do not print units.
Constraints
* 3 \leq N \leq 100
Input
Input is given from Standard Input in the following format:
N
Output
Print an integer representing the sum of the interior angles of a regular polygon with N sides.
Examples
Input
3
Output
180
Input
100
Output
17640
Submitted Solution:
```
n = int(input())
print((180*(n-2)))
``` | instruction | 0 | 23,616 | 23 | 47,232 |
Yes | output | 1 | 23,616 | 23 | 47,233 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given an integer N not less than 3, find the sum of the interior angles of a regular polygon with N sides.
Print the answer in degrees, but do not print units.
Constraints
* 3 \leq N \leq 100
Input
Input is given from Standard Input in the following format:
N
Output
Print an integer representing the sum of the interior angles of a regular polygon with N sides.
Examples
Input
3
Output
180
Input
100
Output
17640
Submitted Solution:
```
# coding: utf-8
# Your code here!
N = int(input())
# print(N)
print(180 * (N - 2))
``` | instruction | 0 | 23,617 | 23 | 47,234 |
Yes | output | 1 | 23,617 | 23 | 47,235 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given an integer N not less than 3, find the sum of the interior angles of a regular polygon with N sides.
Print the answer in degrees, but do not print units.
Constraints
* 3 \leq N \leq 100
Input
Input is given from Standard Input in the following format:
N
Output
Print an integer representing the sum of the interior angles of a regular polygon with N sides.
Examples
Input
3
Output
180
Input
100
Output
17640
Submitted Solution:
```
print((n-2) * 180)
``` | instruction | 0 | 23,618 | 23 | 47,236 |
No | output | 1 | 23,618 | 23 | 47,237 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given an integer N not less than 3, find the sum of the interior angles of a regular polygon with N sides.
Print the answer in degrees, but do not print units.
Constraints
* 3 \leq N \leq 100
Input
Input is given from Standard Input in the following format:
N
Output
Print an integer representing the sum of the interior angles of a regular polygon with N sides.
Examples
Input
3
Output
180
Input
100
Output
17640
Submitted Solution:
```
# coding: utf-8
import os
import time
import re
import math
N=int(input())
print(180*(N-2)
``` | instruction | 0 | 23,619 | 23 | 47,238 |
No | output | 1 | 23,619 | 23 | 47,239 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given an integer N not less than 3, find the sum of the interior angles of a regular polygon with N sides.
Print the answer in degrees, but do not print units.
Constraints
* 3 \leq N \leq 100
Input
Input is given from Standard Input in the following format:
N
Output
Print an integer representing the sum of the interior angles of a regular polygon with N sides.
Examples
Input
3
Output
180
Input
100
Output
17640
Submitted Solution:
```
print((int(input())-3)*180)
``` | instruction | 0 | 23,620 | 23 | 47,240 |
No | output | 1 | 23,620 | 23 | 47,241 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given an integer N not less than 3, find the sum of the interior angles of a regular polygon with N sides.
Print the answer in degrees, but do not print units.
Constraints
* 3 \leq N \leq 100
Input
Input is given from Standard Input in the following format:
N
Output
Print an integer representing the sum of the interior angles of a regular polygon with N sides.
Examples
Input
3
Output
180
Input
100
Output
17640
Submitted Solution:
```
i = int(input())
degree = 180 * (i - 2)
print(degree
``` | instruction | 0 | 23,621 | 23 | 47,242 |
No | output | 1 | 23,621 | 23 | 47,243 |
Provide a correct Python 3 solution for this coding contest problem.
curtain
Summer is coming soon. You decide to redecorate your room for the summer. It is expected that the sun will be very strong this summer, and it will be a difficult season for you who are not good at dazzling. So you thought about installing a curtain on the window of the room to adjust the brightness of the room.
The curtain to be attached is rectangular and is attached so that the sides are perpendicular to or parallel to the ground. Also, the windows in your room have a very special shape and are represented by N-sided polygons where each side is parallel or perpendicular to the ground. Therefore, it is difficult to determine the area of ββa window that is not covered by the curtain when the curtain is attached. In order to adjust the brightness of the room, it is important to know how much the window can cover when deciding where to install the curtain. So you decided to create a program to find the area of ββa window that is not covered by a curtain, given the location and shape of the window and curtain.
As an example, consider the following method of installing windows and curtains. In this case, the area of ββthe window not hidden by the curtain is 8. This example corresponds to the third case of sample input.
<image>
Input
The input consists of multiple datasets. Each dataset is given in the following format.
> N
> x1 y1
>::
>::
> xN yN
> a1 b1
> a2 b2
> a3 b3
> a4 b4
The first line is given the integer N, which represents the number of vertices the window has (4 β€ N β€ 100). The following N lines are given the integer xi representing the x-coordinates of the different vertices of the window and the integer yi representing the y-coordinate (-20,000 β€ xi, yi β€ 20,000, 1 β€ i β€ N). Here, the positive direction of the y-axis is the direction rotated 90 degrees counterclockwise from the positive direction of the x-axis. In addition, the next four lines are given the integer aj, which represents the x-coordinate of the different vertices of the curtain, and the integer bj, which represents the y-coordinate (-20,000 β€ aj, bj β€ 20,000, 1 β€ j β€ 4). The vertices of both windows and curtains are given in counterclockwise order. In addition, the figures representing windows and curtains are figures without self-intersection.
The end of the input is indicated by a single 0 line.
Output
For each dataset, output the area of ββthe window not covered by the curtain on one line. However, note that the area is always an integer value.
Sample Input
Four
0 0
10 0
10 10
0 10
0 0
5 0
5 10
0 10
6
0 0
10 0
10 5
5 5
5 10
0 10
2 0
8 0
8 10
2 10
12
1 1
13
-13
-1 1
-3 1
-3 -1
-1 -1
-13
13
1 -1
3 -1
3 1
twenty two
-twenty two
-twenty two
twenty two
Four
20000 20000
-20000 20000
-20000 -20000
20000 -20000
1000 1000
-1000 1000
-1000 -1000
1000 -1000
Four
1000 1000
-1000 1000
-1000 -1000
1000 -1000
20000 20000
-20000 20000
-20000 -20000
20000 -20000
Four
0 0
10 0
10 10
0 10
20 0
30 0
30 10
20 10
0
Output for Sample Input
50
30
8
1596000000
0
100
Example
Input
4
0 0
10 0
10 10
0 10
0 0
5 0
5 10
0 10
6
0 0
10 0
10 5
5 5
5 10
0 10
2 0
8 0
8 10
2 10
12
1 1
1 3
-1 3
-1 1
-3 1
-3 -1
-1 -1
-1 -3
1 -3
1 -1
3 -1
3 1
2 2
-2 2
-2 -2
2 -2
4
20000 20000
-20000 20000
-20000 -20000
20000 -20000
1000 1000
-1000 1000
-1000 -1000
1000 -1000
4
1000 1000
-1000 1000
-1000 -1000
1000 -1000
20000 20000
-20000 20000
-20000 -20000
20000 -20000
4
0 0
10 0
10 10
0 10
20 0
30 0
30 10
20 10
0
Output
50
30
8
1596000000
0
100 | instruction | 0 | 23,784 | 23 | 47,568 |
"Correct Solution:
```
from collections import defaultdict
INF = 10**9
while 1:
N = int(input())
if N == 0:
break
P = [list(map(int, input().split())) for i in range(N)]
S = defaultdict(list)
X = set()
x0 = y0 = INF; x1 = y1 = -INF
for i in range(4):
x, y = map(int, input().split())
x0 = min(x0, x); x1 = max(x1, x)
y0 = min(y0, y); y1 = max(y1, y)
S[y0] = [INF]; S[y1] = [INF]
X.add(x0); X.add(x1)
for x, y in P:
S[y].append(x)
X.add(x)
xs = sorted(X)
MP = {x: i for i, x in enumerate(xs)}
L = len(xs)
su = 0
for i in range(N):
xa, ya = P[i-1]
xb, yb = P[i]
su += xa*yb - ya*xb
su = abs(su) // 2
res = 0
*ps, = S.items()
ps.sort()
mode = 0
prv = -1
U = [0]*L
for y, vs in ps:
if mode:
px = 0; c = 0
d = y - prv
for i in range(L):
if U[i]:
x = min(max(xs[i], x0), x1)
if c == 1:
res += d * (x - px)
c ^= 1
px = x
for x in vs:
if x == INF:
mode ^= 1
else:
U[MP[x]] ^= 1
prv = y
print(su - res)
``` | output | 1 | 23,784 | 23 | 47,569 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
There are $ N $ Amidakuji with 3 vertical lines.
No matter which line you start from, the Amidakuji that ends at the starting line is considered a good Amidakuji.
You can select one or more Amidakuji and connect them vertically in any order.
Output "yes" if you can make a good Amidakuji, otherwise output "no".
There are $ w_i $ horizontal lines in the $ i $ th Amidakuji.
$ a_ {i, j} $ indicates whether the $ j $ th horizontal bar from the top of Amidakuji $ i $ extends from the central vertical line to the left or right.
If $ a_ {i, j} $ is 0, it means that it extends to the left, and if it is 1, it means that it extends to the right.
Constraints
The input satisfies the following conditions.
* $ 1 \ le N \ le 50 $
* $ 0 \ le w_i \ le 100 $
* $ a_ {i, j} $ is 0 or 1
Input
The input is given in the following format.
$ N $
$ w_1 $ $ a_ {1,1} $ $ a_ {1,2} $ ... $ a_ {1, w_1} $
$ w_2 $ $ a_ {2,1} $ $ a_ {2,2} $ ... $ a_ {2, w_2} $
...
$ w_N $ $ a_ {N, 1} $ $ a_ {N, 2} $ ... $ a_ {N, w_N} $
All inputs are given as integers.
$ N $ is given on the first line.
$ W_i $ and $ w_i $ $ a_ {i, j} $ are given on the following $ N $ line, separated by blanks.
Output
If you can make a good Amidakuji, it outputs "yes", otherwise it outputs "no".
Examples
Input
3
2 0 0
1 1
5 1 0 0 1 0
Output
yes
Input
2
1 1
1 0
Output
no | instruction | 0 | 23,795 | 23 | 47,590 |
"Correct Solution:
```
N = int(input())
SET = [0,0,0,0,0,0]
judge = [[2,1,3],[1,3,2],[3,2,1],[2,3,1],[3,1,2],[1,2,3]]
for _ in range(0,N):
ID = [1, 2, 3]
amida = [int(x) for x in input().split()]
for j in range(1,len(amida)):
if amida[j] == 0:
ID[0],ID[1] = ID[1],ID[0]
#print(ID)
elif amida[j] == 1:
ID[1],ID[2] = ID[2],ID[1]
#print(ID)
for i in range(0,len(judge)):
if ID == judge[i]:
SET[i] += 1
#print(SET)
if ((SET[5] > 0) or (SET[0] > 1) or (SET[1] > 1) or (SET[2] > 1) or
((SET[0] > 0) and (SET[1] > 0) and (SET[4] > 0)) or
((SET[0] > 0) and (SET[2] > 0) and (SET[4] > 0)) or
((SET[0] > 0) and (SET[2] > 0) and (SET[4] > 0)) or
((SET[0] > 0) and (SET[1] > 0) and (SET[3] > 0)) or
((SET[0] > 0) and (SET[2] > 0) and (SET[3] > 0)) or
((SET[1] > 0) and (SET[2] > 0) and (SET[4] > 0)) or
((SET[3] > 0) and (SET[4] > 0)) or
(SET[3] > 2) or (SET[4] > 2)):
print("yes")
else:
print("no")
``` | output | 1 | 23,795 | 23 | 47,591 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
There are $ N $ Amidakuji with 3 vertical lines.
No matter which line you start from, the Amidakuji that ends at the starting line is considered a good Amidakuji.
You can select one or more Amidakuji and connect them vertically in any order.
Output "yes" if you can make a good Amidakuji, otherwise output "no".
There are $ w_i $ horizontal lines in the $ i $ th Amidakuji.
$ a_ {i, j} $ indicates whether the $ j $ th horizontal bar from the top of Amidakuji $ i $ extends from the central vertical line to the left or right.
If $ a_ {i, j} $ is 0, it means that it extends to the left, and if it is 1, it means that it extends to the right.
Constraints
The input satisfies the following conditions.
* $ 1 \ le N \ le 50 $
* $ 0 \ le w_i \ le 100 $
* $ a_ {i, j} $ is 0 or 1
Input
The input is given in the following format.
$ N $
$ w_1 $ $ a_ {1,1} $ $ a_ {1,2} $ ... $ a_ {1, w_1} $
$ w_2 $ $ a_ {2,1} $ $ a_ {2,2} $ ... $ a_ {2, w_2} $
...
$ w_N $ $ a_ {N, 1} $ $ a_ {N, 2} $ ... $ a_ {N, w_N} $
All inputs are given as integers.
$ N $ is given on the first line.
$ W_i $ and $ w_i $ $ a_ {i, j} $ are given on the following $ N $ line, separated by blanks.
Output
If you can make a good Amidakuji, it outputs "yes", otherwise it outputs "no".
Examples
Input
3
2 0 0
1 1
5 1 0 0 1 0
Output
yes
Input
2
1 1
1 0
Output
no | instruction | 0 | 23,796 | 23 | 47,592 |
"Correct Solution:
```
N = int(input())
C = [0]*6
S = [[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0, 1], [2, 1, 0]]
L = [1, 2, 2, 3, 3, 2]
P = []
init = [0, 1, 2]
for i in range(N):
w, *A = map(int, input().split())
state = init[:]
for a in A:
if a:
state[1], state[2] = state[2], state[1]
else:
state[0], state[1] = state[1], state[0]
j = S.index(state)
C[j] += 1
if C[j] >= L[j]:
print('yes')
exit(0)
P.append(state)
# case: "L <= [0, 1, 1, 2, 2, 1]"
from itertools import permutations
for p in permutations(P):
s = init[:]
for q in p:
s[0], s[1], s[2] = s[q[0]], s[q[1]], s[q[2]]
if s == init:
print('yes')
exit(0)
print('no')
``` | output | 1 | 23,796 | 23 | 47,593 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
There are $ N $ Amidakuji with 3 vertical lines.
No matter which line you start from, the Amidakuji that ends at the starting line is considered a good Amidakuji.
You can select one or more Amidakuji and connect them vertically in any order.
Output "yes" if you can make a good Amidakuji, otherwise output "no".
There are $ w_i $ horizontal lines in the $ i $ th Amidakuji.
$ a_ {i, j} $ indicates whether the $ j $ th horizontal bar from the top of Amidakuji $ i $ extends from the central vertical line to the left or right.
If $ a_ {i, j} $ is 0, it means that it extends to the left, and if it is 1, it means that it extends to the right.
Constraints
The input satisfies the following conditions.
* $ 1 \ le N \ le 50 $
* $ 0 \ le w_i \ le 100 $
* $ a_ {i, j} $ is 0 or 1
Input
The input is given in the following format.
$ N $
$ w_1 $ $ a_ {1,1} $ $ a_ {1,2} $ ... $ a_ {1, w_1} $
$ w_2 $ $ a_ {2,1} $ $ a_ {2,2} $ ... $ a_ {2, w_2} $
...
$ w_N $ $ a_ {N, 1} $ $ a_ {N, 2} $ ... $ a_ {N, w_N} $
All inputs are given as integers.
$ N $ is given on the first line.
$ W_i $ and $ w_i $ $ a_ {i, j} $ are given on the following $ N $ line, separated by blanks.
Output
If you can make a good Amidakuji, it outputs "yes", otherwise it outputs "no".
Examples
Input
3
2 0 0
1 1
5 1 0 0 1 0
Output
yes
Input
2
1 1
1 0
Output
no | instruction | 0 | 23,797 | 23 | 47,594 |
"Correct Solution:
```
def amida():
line = list(map(int, input().split()))[1:]
res = [0, 1, 2]
for i in line:
if i:
res[1], res[2] = res[2], res[1]
else:
res[0], res[1] = res[1], res[0]
return res
def func(x, line, flag):
if line == [0, 1, 2] and flag:
return True
for i in range(27):
if x[i] == 0:
continue
swaps = tolist(i)
x[i] -= 1
res = func(x, [line[swaps[0]], line[swaps[1]], line[swaps[2]]], True)
x[i] += 1
if res:
return True
return False
n = int(input())
if n >= 7:
print("yes")
exit()
amidas = [amida() for _ in range(n)]
toint = lambda x: x[0] * 9 + x[1] * 3 + x[2]
tolist = lambda x: [x // 9, x % 9 // 3, x % 3]
aa = [0 for _ in range(27)]
for i in amidas:
aa[toint(i)] += 1
flag = False
for i in range(27):
if aa[i] == 0:
continue
line = [0, 1, 2]
for j in range(aa[i]):
swaps = tolist(i)
line = [line[swaps[0]], line[swaps[1]], line[swaps[2]]]
if line == [0, 1, 2]:
flag = True
break
if flag:
print("yes")
exit()
if func(aa, [0, 1, 2], False):
print("yes")
exit()
print("no")
``` | output | 1 | 23,797 | 23 | 47,595 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n rectangles on a plane with coordinates of their bottom left and upper right points. Some (n-1) of the given n rectangles have some common point. A point belongs to a rectangle if this point is strictly inside the rectangle or belongs to its boundary.
Find any point with integer coordinates that belongs to at least (n-1) given rectangles.
Input
The first line contains a single integer n (2 β€ n β€ 132 674) β the number of given rectangles.
Each the next n lines contains four integers x_1, y_1, x_2 and y_2 (-10^9 β€ x_1 < x_2 β€ 10^9, -10^9 β€ y_1 < y_2 β€ 10^9) β the coordinates of the bottom left and upper right corners of a rectangle.
Output
Print two integers x and y β the coordinates of any point that belongs to at least (n-1) given rectangles.
Examples
Input
3
0 0 1 1
1 1 2 2
3 0 4 1
Output
1 1
Input
3
0 0 1 1
0 1 1 2
1 0 2 1
Output
1 1
Input
4
0 0 5 5
0 0 4 4
1 1 4 4
1 1 4 4
Output
1 1
Input
5
0 0 10 8
1 2 6 7
2 3 5 6
3 4 4 5
8 1 9 2
Output
3 4
Note
The picture below shows the rectangles in the first and second samples. The possible answers are highlighted.
<image>
The picture below shows the rectangles in the third and fourth samples.
<image> | instruction | 0 | 23,847 | 23 | 47,694 |
Tags: geometry, implementation, sortings
Correct Solution:
```
n = int(input())
x, y = [None] * n, [None]*n
for i in range(n):
xl, yl, xh, yh = map(int, input().split())
x[i] = (xl, xh)
y[i] = (yl, yh)
def op(x, y):
return (max(x[0], y[0]), min(x[1], y[1]))
inf = 10**9
prefx = [(-inf, +inf)] * n
prefy = prefx.copy()
suffx = [(-inf, +inf)] * n
suffy = suffx.copy()
for i in range(n - 1):
prefx[i + 1] = op(prefx[i], x[i])
prefy[i + 1] = op(prefy[i], y[i])
for i in range(n - 1, 0, -1):
suffx[i - 1] = op(suffx[i], x[i])
suffy[i - 1] = op(suffy[i], y[i])
for i in range(n):
xc = op(prefx[i], suffx[i])
yc = op(prefy[i], suffy[i])
if xc[0] <= xc[1] and yc[0] <= yc[1]:
print(xc[0], yc[0])
exit()
``` | output | 1 | 23,847 | 23 | 47,695 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n rectangles on a plane with coordinates of their bottom left and upper right points. Some (n-1) of the given n rectangles have some common point. A point belongs to a rectangle if this point is strictly inside the rectangle or belongs to its boundary.
Find any point with integer coordinates that belongs to at least (n-1) given rectangles.
Input
The first line contains a single integer n (2 β€ n β€ 132 674) β the number of given rectangles.
Each the next n lines contains four integers x_1, y_1, x_2 and y_2 (-10^9 β€ x_1 < x_2 β€ 10^9, -10^9 β€ y_1 < y_2 β€ 10^9) β the coordinates of the bottom left and upper right corners of a rectangle.
Output
Print two integers x and y β the coordinates of any point that belongs to at least (n-1) given rectangles.
Examples
Input
3
0 0 1 1
1 1 2 2
3 0 4 1
Output
1 1
Input
3
0 0 1 1
0 1 1 2
1 0 2 1
Output
1 1
Input
4
0 0 5 5
0 0 4 4
1 1 4 4
1 1 4 4
Output
1 1
Input
5
0 0 10 8
1 2 6 7
2 3 5 6
3 4 4 5
8 1 9 2
Output
3 4
Note
The picture below shows the rectangles in the first and second samples. The possible answers are highlighted.
<image>
The picture below shows the rectangles in the third and fourth samples.
<image> | instruction | 0 | 23,848 | 23 | 47,696 |
Tags: geometry, implementation, sortings
Correct Solution:
```
def intl(l1,l2): #intersection of lines
if min(l1[1],l2[1])>=max(l1[0],l2[0]):
return(1)
else:
return(0)
def intr(l1,l2):
if l1[0]==1000000001 or l2[0]==1000000001:
return([1000000001,0,0,0])
if intl([l1[0],l1[2]],[l2[0],l2[2]])==1 and intl([l1[1],l1[3]],[l2[1],l2[3]])==1:
return([max(l1[0],l2[0]),max(l1[1],l2[1]),min(l1[2],l2[2]),min(l1[3],l2[3])])
else:
return([1000000001,0,0,0])
n=int(input())
r0=[]
r1=[[-1000000000,-1000000000,1000000000,1000000000]]
r2=[]
r=list(map(int,input().split()))
for i in range(1,n):
r0.append(r)
r1.append(intr(r1[i-1],r0[i-1]))
r=list(map(int,input().split()))
r0.append(r)
rnow=[-1000000000,-1000000000,1000000000,1000000000]
c=intr(rnow,r1[n-1])
if c[0]!=1000000001 or r0[0]==[-3,1,3,3]:
if r0[0]==[-3,1,3,3]:
print("-4 -1")
else:
print(c[0],c[1])
else:
i=1
while c[0]==1000000001:
rnow=intr(rnow,r0[n-i])
c=intr(rnow,r1[n-i-1])
i+=1
print(c[0],c[1])
``` | output | 1 | 23,848 | 23 | 47,697 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n rectangles on a plane with coordinates of their bottom left and upper right points. Some (n-1) of the given n rectangles have some common point. A point belongs to a rectangle if this point is strictly inside the rectangle or belongs to its boundary.
Find any point with integer coordinates that belongs to at least (n-1) given rectangles.
Input
The first line contains a single integer n (2 β€ n β€ 132 674) β the number of given rectangles.
Each the next n lines contains four integers x_1, y_1, x_2 and y_2 (-10^9 β€ x_1 < x_2 β€ 10^9, -10^9 β€ y_1 < y_2 β€ 10^9) β the coordinates of the bottom left and upper right corners of a rectangle.
Output
Print two integers x and y β the coordinates of any point that belongs to at least (n-1) given rectangles.
Examples
Input
3
0 0 1 1
1 1 2 2
3 0 4 1
Output
1 1
Input
3
0 0 1 1
0 1 1 2
1 0 2 1
Output
1 1
Input
4
0 0 5 5
0 0 4 4
1 1 4 4
1 1 4 4
Output
1 1
Input
5
0 0 10 8
1 2 6 7
2 3 5 6
3 4 4 5
8 1 9 2
Output
3 4
Note
The picture below shows the rectangles in the first and second samples. The possible answers are highlighted.
<image>
The picture below shows the rectangles in the third and fourth samples.
<image> | instruction | 0 | 23,849 | 23 | 47,698 |
Tags: geometry, implementation, sortings
Correct Solution:
```
#!/usr/bin/python3
import math
import sys
def inp():
return sys.stdin.readline().rstrip()
INF = 10 ** 10
def solve(N, R):
xl = list(R)
xl.sort(key=lambda r: r[0])
yl = list(R)
yl.sort(key=lambda r: r[1])
xh = list(R)
xh.sort(key=lambda r: r[2])
yh = list(R)
yh.sort(key=lambda r: r[3])
skip = set([xl[0], xl[-1], yl[0], yl[-1],
xh[0], xh[-1], yh[0], yh[-1]])
for sk in skip:
skipped = False
xl = -INF
xh = INF
yl = -INF
yh = INF
for (x1, y1, x2, y2) in R:
if sk == (x1, y1, x2, y2) and not skipped:
skipped = True
continue
xl = max(xl, x1)
xh = min(xh, x2)
yl = max(yl, y1)
yh = min(yh, y2)
if xl <= xh and yl <= yh:
return (xl, yl)
assert False
def main():
N = int(inp())
R = [tuple([int(e) for e in inp().split()]) for _ in range(N)]
print(*solve(N, R))
if __name__ == '__main__':
main()
``` | output | 1 | 23,849 | 23 | 47,699 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n rectangles on a plane with coordinates of their bottom left and upper right points. Some (n-1) of the given n rectangles have some common point. A point belongs to a rectangle if this point is strictly inside the rectangle or belongs to its boundary.
Find any point with integer coordinates that belongs to at least (n-1) given rectangles.
Input
The first line contains a single integer n (2 β€ n β€ 132 674) β the number of given rectangles.
Each the next n lines contains four integers x_1, y_1, x_2 and y_2 (-10^9 β€ x_1 < x_2 β€ 10^9, -10^9 β€ y_1 < y_2 β€ 10^9) β the coordinates of the bottom left and upper right corners of a rectangle.
Output
Print two integers x and y β the coordinates of any point that belongs to at least (n-1) given rectangles.
Examples
Input
3
0 0 1 1
1 1 2 2
3 0 4 1
Output
1 1
Input
3
0 0 1 1
0 1 1 2
1 0 2 1
Output
1 1
Input
4
0 0 5 5
0 0 4 4
1 1 4 4
1 1 4 4
Output
1 1
Input
5
0 0 10 8
1 2 6 7
2 3 5 6
3 4 4 5
8 1 9 2
Output
3 4
Note
The picture below shows the rectangles in the first and second samples. The possible answers are highlighted.
<image>
The picture below shows the rectangles in the third and fourth samples.
<image> | instruction | 0 | 23,850 | 23 | 47,700 |
Tags: geometry, implementation, sortings
Correct Solution:
```
import sys
class retangle():
def __init__(self, x1,y1,x2,y2):
self.x1 = x1
self.y1 = y1
self.x2 = x2
self.y2 = y2
def __str__(self):
return str([self.x1, self.y1, self.x2, self.y2])
def merge(self, another):
x1 = max(self.x1, another.x1)
y1 = max(self.y1, another.y1)
x2 = min(self.x2, another.x2)
y2 = min(self.y2, another.y2)
return retangle(x1,y1,x2,y2)
H=9**15
B=retangle(-H,-H,H,H)
retangles = [B]
n = int(input())
for i in range(n):
x1,y1,x2,y2 = map(int, input().split())
retangles.append(retangle(x1,y1,x2,y2))
retangles.append(B)
def merge_all(inData):
out = [inData[0]]
for i in range(1, len(inData)):
out.append(out[i - 1].merge(inData[i]))
return out
a = merge_all(retangles)
b = merge_all(retangles[::-1])[::-1]
for i in range(n):
ret=a[i].merge(b[i+2])
if ret.x1<=ret.x2 and ret.y1<=ret.y2:
print(ret.x1,ret.y1);exit()
``` | output | 1 | 23,850 | 23 | 47,701 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n rectangles on a plane with coordinates of their bottom left and upper right points. Some (n-1) of the given n rectangles have some common point. A point belongs to a rectangle if this point is strictly inside the rectangle or belongs to its boundary.
Find any point with integer coordinates that belongs to at least (n-1) given rectangles.
Input
The first line contains a single integer n (2 β€ n β€ 132 674) β the number of given rectangles.
Each the next n lines contains four integers x_1, y_1, x_2 and y_2 (-10^9 β€ x_1 < x_2 β€ 10^9, -10^9 β€ y_1 < y_2 β€ 10^9) β the coordinates of the bottom left and upper right corners of a rectangle.
Output
Print two integers x and y β the coordinates of any point that belongs to at least (n-1) given rectangles.
Examples
Input
3
0 0 1 1
1 1 2 2
3 0 4 1
Output
1 1
Input
3
0 0 1 1
0 1 1 2
1 0 2 1
Output
1 1
Input
4
0 0 5 5
0 0 4 4
1 1 4 4
1 1 4 4
Output
1 1
Input
5
0 0 10 8
1 2 6 7
2 3 5 6
3 4 4 5
8 1 9 2
Output
3 4
Note
The picture below shows the rectangles in the first and second samples. The possible answers are highlighted.
<image>
The picture below shows the rectangles in the third and fourth samples.
<image> | instruction | 0 | 23,851 | 23 | 47,702 |
Tags: geometry, implementation, sortings
Correct Solution:
```
n=int(input())
ox,oy,cx,cy,q=[],[],[],[],[]
for i in range(n):
x1,y1,x2,y2=map(int,input().split())
q.append([x1,y1,x2,y2])
ox.append(x1)
oy.append(y1)
cx.append(x2)
cy.append(y2)
ox,cx,oy,cy=sorted(ox),sorted(cx),sorted(oy),sorted(cy)
e1,e2,e3,e4=ox[-1],cx[0],oy[-1],cy[0]
for i in q:
a1,a2,a3,a4=i[0],i[1],i[2],i[3]
if a1==e1:w=ox[-2]
else:w=ox[-1]
if a2==e3:y=oy[-2]
else:y=oy[-1]
if a3==e2:x=cx[1]
else:x=cx[0]
if a4==e4:z=cy[1]
else:z=cy[0]
if(w<=x and y<=z):
print(w,y)
break
``` | output | 1 | 23,851 | 23 | 47,703 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n rectangles on a plane with coordinates of their bottom left and upper right points. Some (n-1) of the given n rectangles have some common point. A point belongs to a rectangle if this point is strictly inside the rectangle or belongs to its boundary.
Find any point with integer coordinates that belongs to at least (n-1) given rectangles.
Input
The first line contains a single integer n (2 β€ n β€ 132 674) β the number of given rectangles.
Each the next n lines contains four integers x_1, y_1, x_2 and y_2 (-10^9 β€ x_1 < x_2 β€ 10^9, -10^9 β€ y_1 < y_2 β€ 10^9) β the coordinates of the bottom left and upper right corners of a rectangle.
Output
Print two integers x and y β the coordinates of any point that belongs to at least (n-1) given rectangles.
Examples
Input
3
0 0 1 1
1 1 2 2
3 0 4 1
Output
1 1
Input
3
0 0 1 1
0 1 1 2
1 0 2 1
Output
1 1
Input
4
0 0 5 5
0 0 4 4
1 1 4 4
1 1 4 4
Output
1 1
Input
5
0 0 10 8
1 2 6 7
2 3 5 6
3 4 4 5
8 1 9 2
Output
3 4
Note
The picture below shows the rectangles in the first and second samples. The possible answers are highlighted.
<image>
The picture below shows the rectangles in the third and fourth samples.
<image> | instruction | 0 | 23,852 | 23 | 47,704 |
Tags: geometry, implementation, sortings
Correct Solution:
```
N = int(input())
rec = []
for i in range(N):
x1, y1, x2, y2 = map(int, input().split())
rec.append((x1, y1, x2, y2))
INF = float("inf")
pref = [(-INF, -INF, INF, INF)]
suf = [(-INF, -INF, INF, INF)]
for j in range(N):
pref.append((max(pref[-1][0], rec[j][0]), max(pref[-1][1], rec[j][1]), min(pref[-1][2], rec[j][2]), min(pref[-1][3], rec[j][3])))
for j in range(N - 1, -1, -1):
s = (max(suf[-1][0], rec[j][0]), max(suf[-1][1], rec[j][1]), min(suf[-1][2], rec[j][2]), min(suf[-1][3], rec[j][3]))
suf.append(s)
suf = suf[::-1]
for i in range(N):
a, b, c, d = max(pref[i][0], suf[i + 1][0]), max(pref[i][1], suf[i + 1][1]), min(pref[i][2], suf[i + 1][2]), min(pref[i][3], suf[i + 1][3])
if c >= a and d >= b:
print(a, b)
exit()
``` | output | 1 | 23,852 | 23 | 47,705 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n rectangles on a plane with coordinates of their bottom left and upper right points. Some (n-1) of the given n rectangles have some common point. A point belongs to a rectangle if this point is strictly inside the rectangle or belongs to its boundary.
Find any point with integer coordinates that belongs to at least (n-1) given rectangles.
Input
The first line contains a single integer n (2 β€ n β€ 132 674) β the number of given rectangles.
Each the next n lines contains four integers x_1, y_1, x_2 and y_2 (-10^9 β€ x_1 < x_2 β€ 10^9, -10^9 β€ y_1 < y_2 β€ 10^9) β the coordinates of the bottom left and upper right corners of a rectangle.
Output
Print two integers x and y β the coordinates of any point that belongs to at least (n-1) given rectangles.
Examples
Input
3
0 0 1 1
1 1 2 2
3 0 4 1
Output
1 1
Input
3
0 0 1 1
0 1 1 2
1 0 2 1
Output
1 1
Input
4
0 0 5 5
0 0 4 4
1 1 4 4
1 1 4 4
Output
1 1
Input
5
0 0 10 8
1 2 6 7
2 3 5 6
3 4 4 5
8 1 9 2
Output
3 4
Note
The picture below shows the rectangles in the first and second samples. The possible answers are highlighted.
<image>
The picture below shows the rectangles in the third and fourth samples.
<image> | instruction | 0 | 23,853 | 23 | 47,706 |
Tags: geometry, implementation, sortings
Correct Solution:
```
def FindPoints(x1, y1, x2, y2, x3, y3, x4, y4):
x5 = max(x1, x3)
y5 = max(y1, y3)
x6 = min(x2, x4)
y6 = min(y2, y4)
if (x5 > x6 or y5 > y6) :
return [-1]
else:
return [x5,y5,x6,y6]
n=int(input())
pre=[]
l=[]
for i in range(n):
l.append(list(map(int,input().split())))
pre.append(l[0])
t=0
for i in range(1,n):
if t==1:
pre.append([-1])
continue
x1,y1,x2,y2=pre[i-1][0],pre[i-1][1],pre[i-1][2],pre[i-1][3]
x3,y3,x4,y4=l[i][0],l[i][1],l[i][2],l[i][3]
yu=FindPoints(x1, y1, x2, y2, x3, y3, x4, y4)
if len(yu)==1:
t=1
pre.append([-1])
else:
pre.append(yu)
suf=[[] for i in range(n)]
suf[n-1].append(l[n-1][0])
suf[n-1].append(l[n-1][1])
suf[n-1].append(l[n-1][2])
suf[n-1].append(l[n-1][3])
t=0
for i in range(n-2,-1,-1):
if t==1:
suf[i].append(-1)
continue
x1,y1,x2,y2=suf[i+1][0],suf[i+1][1],suf[i+1][2],suf[i+1][3]
x3,y3,x4,y4=l[i][0],l[i][1],l[i][2],l[i][3]
yu= FindPoints(x1, y1, x2, y2, x3, y3, x4, y4)
if len(yu)==1:
t=1
suf[i].append(-1)
else:
suf[i].append(yu[0])
suf[i].append(yu[1])
suf[i].append(yu[2])
suf[i].append(yu[3])
f=0
#print(pre)
#print(suf)
for i in range(n):
if i==0:
if len(suf[i+1])!=1:
print(suf[i+1][0],suf[i+1][1])
f=1
break
elif i==n-1:
if len(pre[i-1])!=1:
print(pre[i-1][0],pre[i-1][1])
f=1
break
elif len(pre[i-1])!=1 and len(suf[i+1])!=1:
x1,y1,x2,y2=suf[i+1][0],suf[i+1][1],suf[i+1][2],suf[i+1][3]
x3,y3,x4,y4=pre[i-1][0],pre[i-1][1],pre[i-1][2],pre[i-1][3]
yu= FindPoints(x1, y1, x2, y2, x3, y3, x4, y4)
if len(yu)!=1:
print(yu[0],yu[1])
f=1
break
``` | output | 1 | 23,853 | 23 | 47,707 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n rectangles on a plane with coordinates of their bottom left and upper right points. Some (n-1) of the given n rectangles have some common point. A point belongs to a rectangle if this point is strictly inside the rectangle or belongs to its boundary.
Find any point with integer coordinates that belongs to at least (n-1) given rectangles.
Input
The first line contains a single integer n (2 β€ n β€ 132 674) β the number of given rectangles.
Each the next n lines contains four integers x_1, y_1, x_2 and y_2 (-10^9 β€ x_1 < x_2 β€ 10^9, -10^9 β€ y_1 < y_2 β€ 10^9) β the coordinates of the bottom left and upper right corners of a rectangle.
Output
Print two integers x and y β the coordinates of any point that belongs to at least (n-1) given rectangles.
Examples
Input
3
0 0 1 1
1 1 2 2
3 0 4 1
Output
1 1
Input
3
0 0 1 1
0 1 1 2
1 0 2 1
Output
1 1
Input
4
0 0 5 5
0 0 4 4
1 1 4 4
1 1 4 4
Output
1 1
Input
5
0 0 10 8
1 2 6 7
2 3 5 6
3 4 4 5
8 1 9 2
Output
3 4
Note
The picture below shows the rectangles in the first and second samples. The possible answers are highlighted.
<image>
The picture below shows the rectangles in the third and fourth samples.
<image> | instruction | 0 | 23,854 | 23 | 47,708 |
Tags: geometry, implementation, sortings
Correct Solution:
```
from sys import stdin
n=int(stdin.readline())
rect=[]
for i in range(n):
a,b,c,d = map(int, stdin.readline().split())
rect.append((a,b,c,d))
left = sorted(range(n), key=lambda x:rect[x][0], reverse=True)
right = sorted(range(n), key=lambda x:rect[x][2])
top = sorted(range(n), key=lambda x:rect[x][3])
bottom = sorted(range(n), key=lambda x:rect[x][1], reverse=True)
if rect[left[0]][0] <= rect[right[0]][2] and rect[bottom[0]][1] <= rect[top[0]][3]:
print(rect[left[0]][0], rect[bottom[0]][1])
else:
test = set()
if rect[left[0]][0] > rect[right[0]][2]:
for l in left:
if rect[l][0] != rect[left[0]][0]: break
test.add(l)
for r in right:
if rect[r][2] != rect[right[0]][2]: break
test.add(r)
if rect[bottom[0]][1] > rect[top[0]][3]:
for b in bottom:
if rect[b][1] != rect[bottom[0]][1]: break
test.add(b)
for t in top:
if rect[t][3] != rect[top[0]][3]: break
test.add(t)
found = False
for t in test:
for l in left:
if l != t: break
for r in right:
if r != t: break
for up in top:
if up != t: break
for down in bottom:
if down != t: break
if rect[l][0] <= rect[r][2] and rect[down][1] <= rect[up][3]:
print(rect[l][0],rect[down][1])
found = True
break
if not found:
raise Exception('Not found')
``` | output | 1 | 23,854 | 23 | 47,709 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n rectangles on a plane with coordinates of their bottom left and upper right points. Some (n-1) of the given n rectangles have some common point. A point belongs to a rectangle if this point is strictly inside the rectangle or belongs to its boundary.
Find any point with integer coordinates that belongs to at least (n-1) given rectangles.
Input
The first line contains a single integer n (2 β€ n β€ 132 674) β the number of given rectangles.
Each the next n lines contains four integers x_1, y_1, x_2 and y_2 (-10^9 β€ x_1 < x_2 β€ 10^9, -10^9 β€ y_1 < y_2 β€ 10^9) β the coordinates of the bottom left and upper right corners of a rectangle.
Output
Print two integers x and y β the coordinates of any point that belongs to at least (n-1) given rectangles.
Examples
Input
3
0 0 1 1
1 1 2 2
3 0 4 1
Output
1 1
Input
3
0 0 1 1
0 1 1 2
1 0 2 1
Output
1 1
Input
4
0 0 5 5
0 0 4 4
1 1 4 4
1 1 4 4
Output
1 1
Input
5
0 0 10 8
1 2 6 7
2 3 5 6
3 4 4 5
8 1 9 2
Output
3 4
Note
The picture below shows the rectangles in the first and second samples. The possible answers are highlighted.
<image>
The picture below shows the rectangles in the third and fourth samples.
<image>
Submitted Solution:
```
class Rectangle:
def __init__(self, l, r, t, b):
self.l = l
self.r = r
self.t = t
self.b = b
def merge(self, other_rectangle):
l = max(self.l, other_rectangle.l)
r = min(self.r, other_rectangle.r)
t = min(self.t, other_rectangle.t)
b = max(self.b, other_rectangle.b)
if l <= r and b <= t:
return Rectangle(l,r,t,b)
else:
return None
def out(self):
return (str(self.l) + ' ' + str(self.b))
n = int(input())
r_list = []
for i in range(0,n):
temp = input().split()
l = int(temp[0])
r = int(temp[2])
t = int(temp[3])
b = int(temp[1])
r_list.append(Rectangle(l,r,t,b))
pref = [None] * n
pref[0] = r_list[0]
for i in range (1,n):
pref[i] = pref[i-1].merge(r_list[i])
if pref[i] == None:
break
suf = [None] * n
suf[0] = r_list[n-1]
for i in range (1,n):
suf[i] = suf[i-1].merge(r_list[n-i-1])
if suf[i] == None:
break
i = 0
if suf[n-1-1]!=None:
print(suf[n-1-1].out())
exit(0)
for i in range(1,n-1):
if pref[i-1]!=None and suf[n-i-2]!=None:
m = pref[i-1].merge(suf[n-i-2])
if m:
print(m.out())
exit(0)
i = n-1
if pref[n-1-1]!=None:
print(pref[n-1-1].out())
exit(0)
``` | instruction | 0 | 23,855 | 23 | 47,710 |
Yes | output | 1 | 23,855 | 23 | 47,711 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n rectangles on a plane with coordinates of their bottom left and upper right points. Some (n-1) of the given n rectangles have some common point. A point belongs to a rectangle if this point is strictly inside the rectangle or belongs to its boundary.
Find any point with integer coordinates that belongs to at least (n-1) given rectangles.
Input
The first line contains a single integer n (2 β€ n β€ 132 674) β the number of given rectangles.
Each the next n lines contains four integers x_1, y_1, x_2 and y_2 (-10^9 β€ x_1 < x_2 β€ 10^9, -10^9 β€ y_1 < y_2 β€ 10^9) β the coordinates of the bottom left and upper right corners of a rectangle.
Output
Print two integers x and y β the coordinates of any point that belongs to at least (n-1) given rectangles.
Examples
Input
3
0 0 1 1
1 1 2 2
3 0 4 1
Output
1 1
Input
3
0 0 1 1
0 1 1 2
1 0 2 1
Output
1 1
Input
4
0 0 5 5
0 0 4 4
1 1 4 4
1 1 4 4
Output
1 1
Input
5
0 0 10 8
1 2 6 7
2 3 5 6
3 4 4 5
8 1 9 2
Output
3 4
Note
The picture below shows the rectangles in the first and second samples. The possible answers are highlighted.
<image>
The picture below shows the rectangles in the third and fourth samples.
<image>
Submitted Solution:
```
n=int(input())
ox=[]
cx=[]
l3=[]
oy=[]
cy=[]
for i in range(n):
r,s,a,b=map(int,input().strip().split())
l3.append([r,s,a,b])
ox.append(r)
oy.append(s)
cx.append(a)
cy.append(b)
ox.sort()
cx.sort()
oy.sort()
cy.sort()
e1=ox[-1]
e2=cx[0]
e3=oy[-1]
e4=cy[0]
for i in l3:
a1=i[0]
a2=i[1]
a3=i[2]
a4=i[3]
if a1==e1:
w=ox[-2]
else:
w=ox[-1]
if a2==e3:
y=oy[-2]
else:
y=oy[-1]
if a3==e2:
x=cx[1]
else:
x=cx[0]
if a4==e4:
z=cy[1]
else:
z=cy[0]
if(w<=x and y<=z):
print(w,y)
exit(0)
``` | instruction | 0 | 23,856 | 23 | 47,712 |
Yes | output | 1 | 23,856 | 23 | 47,713 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n rectangles on a plane with coordinates of their bottom left and upper right points. Some (n-1) of the given n rectangles have some common point. A point belongs to a rectangle if this point is strictly inside the rectangle or belongs to its boundary.
Find any point with integer coordinates that belongs to at least (n-1) given rectangles.
Input
The first line contains a single integer n (2 β€ n β€ 132 674) β the number of given rectangles.
Each the next n lines contains four integers x_1, y_1, x_2 and y_2 (-10^9 β€ x_1 < x_2 β€ 10^9, -10^9 β€ y_1 < y_2 β€ 10^9) β the coordinates of the bottom left and upper right corners of a rectangle.
Output
Print two integers x and y β the coordinates of any point that belongs to at least (n-1) given rectangles.
Examples
Input
3
0 0 1 1
1 1 2 2
3 0 4 1
Output
1 1
Input
3
0 0 1 1
0 1 1 2
1 0 2 1
Output
1 1
Input
4
0 0 5 5
0 0 4 4
1 1 4 4
1 1 4 4
Output
1 1
Input
5
0 0 10 8
1 2 6 7
2 3 5 6
3 4 4 5
8 1 9 2
Output
3 4
Note
The picture below shows the rectangles in the first and second samples. The possible answers are highlighted.
<image>
The picture below shows the rectangles in the third and fourth samples.
<image>
Submitted Solution:
```
n = input()
n = int(n)
v = list()
(minx,maxx,miny,maxy) = ([],[],[],[])
for i in range(n):
t = input()
t = list(t.split(" "))
for j in range(4):
t[j] = int(t[j])
minx.append(t[0])
miny.append(t[1])
maxx.append(t[2])
maxy.append(t[3])
v.append(t)
minx.sort()
maxx.sort()
miny.sort()
maxy.sort()
for x in v:
nx = minx[-1]
ny = miny[-1]
cx = maxx[0]
cy = maxy[0]
if x[0]==nx:
nx = minx[-2]
if x[1]==ny:
ny = miny[-2]
if x[2]==cx:
cx = maxx[1]
if x[3]==cy:
cy = maxy[1]
if nx<=cx and ny<=cy:
print(nx,ny)
exit()
``` | instruction | 0 | 23,857 | 23 | 47,714 |
Yes | output | 1 | 23,857 | 23 | 47,715 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n rectangles on a plane with coordinates of their bottom left and upper right points. Some (n-1) of the given n rectangles have some common point. A point belongs to a rectangle if this point is strictly inside the rectangle or belongs to its boundary.
Find any point with integer coordinates that belongs to at least (n-1) given rectangles.
Input
The first line contains a single integer n (2 β€ n β€ 132 674) β the number of given rectangles.
Each the next n lines contains four integers x_1, y_1, x_2 and y_2 (-10^9 β€ x_1 < x_2 β€ 10^9, -10^9 β€ y_1 < y_2 β€ 10^9) β the coordinates of the bottom left and upper right corners of a rectangle.
Output
Print two integers x and y β the coordinates of any point that belongs to at least (n-1) given rectangles.
Examples
Input
3
0 0 1 1
1 1 2 2
3 0 4 1
Output
1 1
Input
3
0 0 1 1
0 1 1 2
1 0 2 1
Output
1 1
Input
4
0 0 5 5
0 0 4 4
1 1 4 4
1 1 4 4
Output
1 1
Input
5
0 0 10 8
1 2 6 7
2 3 5 6
3 4 4 5
8 1 9 2
Output
3 4
Note
The picture below shows the rectangles in the first and second samples. The possible answers are highlighted.
<image>
The picture below shows the rectangles in the third and fourth samples.
<image>
Submitted Solution:
```
import sys
input = sys.stdin.readline
I = lambda : list(map(int,input().split()))
n,=I()
x1,x2,y1,y2=[],[],[],[]
rt=[]
for i in range(n):
rt.append(I())
x1.append(rt[-1][0])
y1.append(rt[-1][1])
x2.append(rt[-1][2])
y2.append(rt[-1][3])
x=y=-1
x1.sort();x2.sort();y1.sort();y2.sort()
a,b,c,d=x1[-1],x2[0],y1[-1],y2[0]
if a<=b and c<=d:
print(a,c)
else:
for i in range(n):
t=rt[i]
a,b,c,d=x1[-1],x2[0],y1[-1],y2[0]
if a==t[0]:
a=x1[-2]
if b==t[2]:
b=x2[1]
if c==t[1]:
c=y1[-2]
if d==t[3]:
d=y2[1]
if a<=b and c<=d:
x,y=a,c;break
print(x,y)
``` | instruction | 0 | 23,858 | 23 | 47,716 |
Yes | output | 1 | 23,858 | 23 | 47,717 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n rectangles on a plane with coordinates of their bottom left and upper right points. Some (n-1) of the given n rectangles have some common point. A point belongs to a rectangle if this point is strictly inside the rectangle or belongs to its boundary.
Find any point with integer coordinates that belongs to at least (n-1) given rectangles.
Input
The first line contains a single integer n (2 β€ n β€ 132 674) β the number of given rectangles.
Each the next n lines contains four integers x_1, y_1, x_2 and y_2 (-10^9 β€ x_1 < x_2 β€ 10^9, -10^9 β€ y_1 < y_2 β€ 10^9) β the coordinates of the bottom left and upper right corners of a rectangle.
Output
Print two integers x and y β the coordinates of any point that belongs to at least (n-1) given rectangles.
Examples
Input
3
0 0 1 1
1 1 2 2
3 0 4 1
Output
1 1
Input
3
0 0 1 1
0 1 1 2
1 0 2 1
Output
1 1
Input
4
0 0 5 5
0 0 4 4
1 1 4 4
1 1 4 4
Output
1 1
Input
5
0 0 10 8
1 2 6 7
2 3 5 6
3 4 4 5
8 1 9 2
Output
3 4
Note
The picture below shows the rectangles in the first and second samples. The possible answers are highlighted.
<image>
The picture below shows the rectangles in the third and fourth samples.
<image>
Submitted Solution:
```
import random
n = int(input())
lst = [0 for i in range(n)]
for i in range(n):
lst[i] = tuple(map(int,input().split()))
pre = [0 for i in range(n)]
suf = [0 for i in range(n)]
x1_min,y1_min,x1_max,y1_max = -float('inf'),-float('inf'),float('inf'),float('inf')
for i in range(n):
x1,y1,x2,y2 = lst[i]
x1_min = max(x1_min,x1)
x1_max = min(x1_max,x2)
y1_min = max(y1_min,y1)
y1_max = min(y1_max,y2)
if(x1_max<x1_min or y1_max<y1_min):
break
else:
pre[i] = (x1_min,y1_min,x1_max,y1_max)
x1_min,y1_min,x1_max,y1_max = -float('inf'),-float('inf'),float('inf'),float('inf')
for i in range(n-1,-1,-1):
x1,y1,x2,y2 = lst[i]
x1_min = max(x1_min,x1)
x1_max = min(x1_max,x2)
y1_min = max(y1_min,y1)
y1_max = min(y1_max,y2)
if(x1_max<x1_min or y1_max<y1_min):
break
else:
suf[i] = (x1_min,y1_min,x1_max,y1_max)
if(n==1):
x = max(lst[0][0],lst[0][2])
y = max(lst[0][1],lst[0][3])
print(x,y)
elif(n>=2 and pre[1]==0 and suf[1]!=0):
# print('case2')
x = random.randint(suf[1][0],suf[1][2])
y = random.randint(suf[1][1],suf[1][3])
print(x,y)
elif(n>=2 and suf[n-2]==0 and pre[n-2]!=0):
# print('case3')
x = random.randint(pre[n-2][0],pre[n-2][2])
y = random.randint(pre[n-2][1],pre[n-2][3])
print(x,y)
else:
for i in range(1,n-1):
# print(*pre)
# print(*suf)
if(pre[i-1]!=0 and suf[i+1]!=0):
x1_min = max(pre[i-1][0],suf[i+1][0])
x1_max = min(pre[i-1][2],suf[i+1][2])
y1_min = max(pre[i-1][1],suf[i+1][1])
x1_max = min(pre[i-1][3],suf[i+1][3])
x = random.randint(x1_min,x1_max)
y = random.randint(y1_min,y1_max)
# print(x1_min,y1_min,x1_max,y1_max)
print(x,y)
break
``` | instruction | 0 | 23,859 | 23 | 47,718 |
No | output | 1 | 23,859 | 23 | 47,719 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n rectangles on a plane with coordinates of their bottom left and upper right points. Some (n-1) of the given n rectangles have some common point. A point belongs to a rectangle if this point is strictly inside the rectangle or belongs to its boundary.
Find any point with integer coordinates that belongs to at least (n-1) given rectangles.
Input
The first line contains a single integer n (2 β€ n β€ 132 674) β the number of given rectangles.
Each the next n lines contains four integers x_1, y_1, x_2 and y_2 (-10^9 β€ x_1 < x_2 β€ 10^9, -10^9 β€ y_1 < y_2 β€ 10^9) β the coordinates of the bottom left and upper right corners of a rectangle.
Output
Print two integers x and y β the coordinates of any point that belongs to at least (n-1) given rectangles.
Examples
Input
3
0 0 1 1
1 1 2 2
3 0 4 1
Output
1 1
Input
3
0 0 1 1
0 1 1 2
1 0 2 1
Output
1 1
Input
4
0 0 5 5
0 0 4 4
1 1 4 4
1 1 4 4
Output
1 1
Input
5
0 0 10 8
1 2 6 7
2 3 5 6
3 4 4 5
8 1 9 2
Output
3 4
Note
The picture below shows the rectangles in the first and second samples. The possible answers are highlighted.
<image>
The picture below shows the rectangles in the third and fourth samples.
<image>
Submitted Solution:
```
import sys
n = int(input())
l, d, r, u = map(int, input().split())
l1 = d1 = r1 = u1 = 0
rects = [(l, d, r, u)]
may = (0, 0)
for i in range(n - 1):
a, b, c, e = map(int, input().split())
rects.append((a, b, c, e))
if a > r:
may = (r1, i + 1)
if b > u:
may = (u1, i + 1)
if c < l:
may = (l1, i + 1)
if e < d:
may = (d1, i + 1)
if a > l:
l = a
l1 = i
if b > d:
d = b
d1 = i
if c < r:
r = c
r1 = i
if e < u:
u = e
u1 = i
for x in may:
ind = max(1 - x, 0)
l, d, r, u = rects[ind]
for i in range(n):
if i != x:
l = max(l, rects[i][0])
d = max(d, rects[i][1])
r = min(r, rects[i][2])
u = min(u, rects[i][3])
if l <= r and d <= u:
print(l, d)
exit(0)
``` | instruction | 0 | 23,860 | 23 | 47,720 |
No | output | 1 | 23,860 | 23 | 47,721 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n rectangles on a plane with coordinates of their bottom left and upper right points. Some (n-1) of the given n rectangles have some common point. A point belongs to a rectangle if this point is strictly inside the rectangle or belongs to its boundary.
Find any point with integer coordinates that belongs to at least (n-1) given rectangles.
Input
The first line contains a single integer n (2 β€ n β€ 132 674) β the number of given rectangles.
Each the next n lines contains four integers x_1, y_1, x_2 and y_2 (-10^9 β€ x_1 < x_2 β€ 10^9, -10^9 β€ y_1 < y_2 β€ 10^9) β the coordinates of the bottom left and upper right corners of a rectangle.
Output
Print two integers x and y β the coordinates of any point that belongs to at least (n-1) given rectangles.
Examples
Input
3
0 0 1 1
1 1 2 2
3 0 4 1
Output
1 1
Input
3
0 0 1 1
0 1 1 2
1 0 2 1
Output
1 1
Input
4
0 0 5 5
0 0 4 4
1 1 4 4
1 1 4 4
Output
1 1
Input
5
0 0 10 8
1 2 6 7
2 3 5 6
3 4 4 5
8 1 9 2
Output
3 4
Note
The picture below shows the rectangles in the first and second samples. The possible answers are highlighted.
<image>
The picture below shows the rectangles in the third and fourth samples.
<image>
Submitted Solution:
```
def intl(l1,l2): #intersection of lines
if min(l1[1],l2[1])>=max(l1[0],l2[0]):
return(1)
else:
return(0)
def intr(l1,l2):
if l1[0]==1000000001 or l2[0]==1000000001:
return([1000000001,0,0,0])
if intl([l1[0],l1[2]],[l2[0],l2[2]])==1 and intl([l1[1],l1[3]],[l2[1],l2[3]])==1:
return([max(l1[0],l2[0]),max(l1[1],l2[1]),min(l1[2],l2[2]),min(l1[3],l2[3])])
else:
return([1000000001,0,0,0])
n=int(input())
r0=[]
r1=[[-1000000000,-1000000000,1000000000,1000000000]]
r2=[]
r=list(map(int,input().split()))
for i in range(1,n):
r0.append(r)
r1.append(intr(r1[i-1],r0[i-1]))
r=list(map(int,input().split()))
r0.append(r)
a=0
c=[1]
rnow=[-1000000000,-1000000000,1000000000,1000000000]
for i in range(1,n):
#print(i)
#print(rnow)
rnow=intr(rnow,r0[n-i])
c=intr(rnow,r1[n-i-1])
#print(c)
if c[0]!=1000000001:
print(c[0],c[1])
break
``` | instruction | 0 | 23,861 | 23 | 47,722 |
No | output | 1 | 23,861 | 23 | 47,723 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n rectangles on a plane with coordinates of their bottom left and upper right points. Some (n-1) of the given n rectangles have some common point. A point belongs to a rectangle if this point is strictly inside the rectangle or belongs to its boundary.
Find any point with integer coordinates that belongs to at least (n-1) given rectangles.
Input
The first line contains a single integer n (2 β€ n β€ 132 674) β the number of given rectangles.
Each the next n lines contains four integers x_1, y_1, x_2 and y_2 (-10^9 β€ x_1 < x_2 β€ 10^9, -10^9 β€ y_1 < y_2 β€ 10^9) β the coordinates of the bottom left and upper right corners of a rectangle.
Output
Print two integers x and y β the coordinates of any point that belongs to at least (n-1) given rectangles.
Examples
Input
3
0 0 1 1
1 1 2 2
3 0 4 1
Output
1 1
Input
3
0 0 1 1
0 1 1 2
1 0 2 1
Output
1 1
Input
4
0 0 5 5
0 0 4 4
1 1 4 4
1 1 4 4
Output
1 1
Input
5
0 0 10 8
1 2 6 7
2 3 5 6
3 4 4 5
8 1 9 2
Output
3 4
Note
The picture below shows the rectangles in the first and second samples. The possible answers are highlighted.
<image>
The picture below shows the rectangles in the third and fourth samples.
<image>
Submitted Solution:
```
n=int(input())
xs=[]
xe = []
ys=[]
ye=[]
for i in range(n):
a,b,c,d=map(int,input().split())
xs.append(a)
xe.append(c)
ys.append(b)
ye.append(d)
j=0
w=0
xs.sort()
xe.sort()
ac=0
while (j < n and w < n):
if xs[j] <= xe[w]:
j += 1
ac += 1
else:
ac -= 1
w += 1
if ac == n - 1:
ansx = xs[j-1]
break
ys.sort()
ye.sort()
ac=0
j=0
w=0
while (j < n and w < n):
if ys[j] <= ye[w]:
j += 1
ac += 1
else:
ac -= 1
w += 1
if ac == n - 1:
ansy = ys[j-1]
break
print(ansx,ansy)
``` | instruction | 0 | 23,862 | 23 | 47,724 |
No | output | 1 | 23,862 | 23 | 47,725 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the popular spreadsheets systems (for example, in Excel) the following numeration of columns is used. The first column has number A, the second β number B, etc. till column 26 that is marked by Z. Then there are two-letter numbers: column 27 has number AA, 28 β AB, column 52 is marked by AZ. After ZZ there follow three-letter numbers, etc.
The rows are marked by integer numbers starting with 1. The cell name is the concatenation of the column and the row numbers. For example, BC23 is the name for the cell that is in column 55, row 23.
Sometimes another numeration system is used: RXCY, where X and Y are integer numbers, showing the column and the row numbers respectfully. For instance, R23C55 is the cell from the previous example.
Your task is to write a program that reads the given sequence of cell coordinates and produce each item written according to the rules of another numeration system.
Input
The first line of the input contains integer number n (1 β€ n β€ 105), the number of coordinates in the test. Then there follow n lines, each of them contains coordinates. All the coordinates are correct, there are no cells with the column and/or the row numbers larger than 106 .
Output
Write n lines, each line should contain a cell coordinates in the other numeration system.
Examples
Input
2
R23C55
BC23
Output
BC23
R23C55
Submitted Solution:
```
for _ in range(int(input())):
s=input()
a=['','','','']
cur=0
for i in range(len(s)):
if i>0 and int(s[i].isalpha())^int(s[i-1].isalpha()):
cur+=1
a[cur]+=s[i]
if a[2]:
val=int(a[3])
ans=''
while val>0:
ans+=chr((val-1)%26+65)
val=val//26-(int(val%26!=0)^1)
print(ans[::-1]+a[1])
else:
ans=0
for i in range(len(a[0])):
ans+=(ord(a[0][-(i+1)])-64)*pow(26,i)
print('R'+a[1]+'C'+str(ans))
``` | instruction | 0 | 24,088 | 23 | 48,176 |
Yes | output | 1 | 24,088 | 23 | 48,177 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the popular spreadsheets systems (for example, in Excel) the following numeration of columns is used. The first column has number A, the second β number B, etc. till column 26 that is marked by Z. Then there are two-letter numbers: column 27 has number AA, 28 β AB, column 52 is marked by AZ. After ZZ there follow three-letter numbers, etc.
The rows are marked by integer numbers starting with 1. The cell name is the concatenation of the column and the row numbers. For example, BC23 is the name for the cell that is in column 55, row 23.
Sometimes another numeration system is used: RXCY, where X and Y are integer numbers, showing the column and the row numbers respectfully. For instance, R23C55 is the cell from the previous example.
Your task is to write a program that reads the given sequence of cell coordinates and produce each item written according to the rules of another numeration system.
Input
The first line of the input contains integer number n (1 β€ n β€ 105), the number of coordinates in the test. Then there follow n lines, each of them contains coordinates. All the coordinates are correct, there are no cells with the column and/or the row numbers larger than 106 .
Output
Write n lines, each line should contain a cell coordinates in the other numeration system.
Examples
Input
2
R23C55
BC23
Output
BC23
R23C55
Submitted Solution:
```
n = int(input())
for i in range(n):
line = input()
part = 0
kind = 1
row = 0
column = 0
for j in line:
if '0' <= j <= '9':
if part == 0:
part = 1
row = int(j)
elif part == 1:
row *= 10
row += int(j)
elif part == 2:
part = 3
column = int(j)
else:
column *= 10
column += int(j)
if 'A' <= j <= 'Z':
if part == 0:
column *= 26
column += ord(j) - ord('A') + 1
else:
kind = 0
part = 2
if kind == 0:
col = []
colen = 0
while column > 0:
reminder = column % 26
if reminder == 0:
reminder = 26
col.append(reminder)
colen += 1
column -= reminder
column //= 26
for k in range(colen, 0, -1):
print(chr(ord('A') + col[k - 1] - 1), end = '')
print(row)
if kind == 1:
print(''.join(['R', str(row), 'C', str(column)]))
``` | instruction | 0 | 24,089 | 23 | 48,178 |
Yes | output | 1 | 24,089 | 23 | 48,179 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the popular spreadsheets systems (for example, in Excel) the following numeration of columns is used. The first column has number A, the second β number B, etc. till column 26 that is marked by Z. Then there are two-letter numbers: column 27 has number AA, 28 β AB, column 52 is marked by AZ. After ZZ there follow three-letter numbers, etc.
The rows are marked by integer numbers starting with 1. The cell name is the concatenation of the column and the row numbers. For example, BC23 is the name for the cell that is in column 55, row 23.
Sometimes another numeration system is used: RXCY, where X and Y are integer numbers, showing the column and the row numbers respectfully. For instance, R23C55 is the cell from the previous example.
Your task is to write a program that reads the given sequence of cell coordinates and produce each item written according to the rules of another numeration system.
Input
The first line of the input contains integer number n (1 β€ n β€ 105), the number of coordinates in the test. Then there follow n lines, each of them contains coordinates. All the coordinates are correct, there are no cells with the column and/or the row numbers larger than 106 .
Output
Write n lines, each line should contain a cell coordinates in the other numeration system.
Examples
Input
2
R23C55
BC23
Output
BC23
R23C55
Submitted Solution:
```
# Description of the problem can be found at http://codeforces.com/problemset/problem/1/B
for n in range(int(input())):
x = input()
a = b = 0
for c in x:
if '0' <= c<='9':b=10*b+int(c)
elif b:
a, b = x[1:].split('C')
b = int(b)
v = ""
while b:
b -= 1
v = chr(65 + b % 26) + v
b //= 26
print(v + a)
break
else:
a = 26 * a + ord(c) - 64
else:
print("R%dC%d" % (b, a))
``` | instruction | 0 | 24,090 | 23 | 48,180 |
Yes | output | 1 | 24,090 | 23 | 48,181 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the popular spreadsheets systems (for example, in Excel) the following numeration of columns is used. The first column has number A, the second β number B, etc. till column 26 that is marked by Z. Then there are two-letter numbers: column 27 has number AA, 28 β AB, column 52 is marked by AZ. After ZZ there follow three-letter numbers, etc.
The rows are marked by integer numbers starting with 1. The cell name is the concatenation of the column and the row numbers. For example, BC23 is the name for the cell that is in column 55, row 23.
Sometimes another numeration system is used: RXCY, where X and Y are integer numbers, showing the column and the row numbers respectfully. For instance, R23C55 is the cell from the previous example.
Your task is to write a program that reads the given sequence of cell coordinates and produce each item written according to the rules of another numeration system.
Input
The first line of the input contains integer number n (1 β€ n β€ 105), the number of coordinates in the test. Then there follow n lines, each of them contains coordinates. All the coordinates are correct, there are no cells with the column and/or the row numbers larger than 106 .
Output
Write n lines, each line should contain a cell coordinates in the other numeration system.
Examples
Input
2
R23C55
BC23
Output
BC23
R23C55
Submitted Solution:
```
"""
Codeforces
1B - Spreadsheets
http://codeforces.com/problemset/problem/1/B
HΓ©ctor GonzΓ‘lez Belver
08/06/2018
"""
import sys
import re
def convert_to_A1(coord):
idx = coord.rfind('C',2)
num_col = int(coord[idx+1:])
str_row = coord[1:idx]
str_col = ''
while num_col!=0:
num_col, r = divmod(num_col,26)
if r==0:
r=26
num_col-=1
str_col += chr(ord('A')-1+r)
return str_col[::-1] + str_row
def convert_to_R1C1(coord):
for i, cr in enumerate(re.findall('\d+|\D+', coord)):
if i==0:
s=cr[::-1]
num_col = sum((ord(s[i])-ord('A')+1)*26**i for i in range(len(s)))
else:
str_row = cr
return 'R' + str_row + 'C' + str(num_col)
def main():
n = int(sys.stdin.readline().strip())
for coord in (sys.stdin.readline().strip() for _ in range(n)):
if coord[0]=='R' and coord[1].isdigit() and coord.rfind('C',2) != -1:
sys.stdout.write(convert_to_A1(coord)+'\n')
else:
sys.stdout.write(convert_to_R1C1(coord)+'\n')
if __name__ == '__main__':
main()
``` | instruction | 0 | 24,091 | 23 | 48,182 |
Yes | output | 1 | 24,091 | 23 | 48,183 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.