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 tags and a correct Python 3 solution for this coding contest problem.
By 2312 there were n Large Hadron Colliders in the inhabited part of the universe. Each of them corresponded to a single natural number from 1 to n. However, scientists did not know what activating several colliders simultaneously could cause, so the colliders were deactivated.
In 2312 there was a startling discovery: a collider's activity is safe if and only if all numbers of activated colliders are pairwise relatively prime to each other (two numbers are relatively prime if their greatest common divisor equals 1)! If two colliders with relatively nonprime numbers are activated, it will cause a global collapse.
Upon learning this, physicists rushed to turn the colliders on and off and carry out all sorts of experiments. To make sure than the scientists' quickness doesn't end with big trouble, the Large Hadron Colliders' Large Remote Control was created. You are commissioned to write the software for the remote (well, you do not expect anybody to operate it manually, do you?).
Initially, all colliders are deactivated. Your program receives multiple requests of the form "activate/deactivate the i-th collider". The program should handle requests in the order of receiving them. The program should print the processed results in the format described below.
To the request of "+ i" (that is, to activate the i-th collider), the program should print exactly one of the following responses:
* "Success" if the activation was successful.
* "Already on", if the i-th collider was already activated before the request.
* "Conflict with j", if there is a conflict with the j-th collider (that is, the j-th collider is on, and numbers i and j are not relatively prime). In this case, the i-th collider shouldn't be activated. If a conflict occurs with several colliders simultaneously, you should print the number of any of them.
The request of "- i" (that is, to deactivate the i-th collider), should receive one of the following responses from the program:
* "Success", if the deactivation was successful.
* "Already off", if the i-th collider was already deactivated before the request.
You don't need to print quotes in the output of the responses to the requests.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the number of colliders and the number of requests, correspondingly.
Next m lines contain numbers of requests, one per line, in the form of either "+ i" (without the quotes) — activate the i-th collider, or "- i" (without the quotes) — deactivate the i-th collider (1 ≤ i ≤ n).
Output
Print m lines — the results of executing requests in the above given format. The requests should be processed in the order, in which they are given in the input. Don't forget that the responses to the requests should be printed without quotes.
Examples
Input
10 10
+ 6
+ 10
+ 5
- 10
- 5
- 6
+ 10
+ 3
+ 6
+ 3
Output
Success
Conflict with 6
Success
Already off
Success
Success
Success
Success
Conflict with 10
Already on
Note
Note that in the sample the colliders don't turn on after the second and ninth requests. The ninth request could also receive response "Conflict with 3". | instruction | 0 | 12,716 | 3 | 25,432 |
Tags: math, number theory
Correct Solution:
```
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now----------------------------------------------------
# Function to call the actual solution
def solution(li, n, m):
s = [[] for i in range(n)]
for j in range(2, n, 2):
s[j] = [2]
for i in range(3, n, 2):
if s[i]:
continue
for j in range(i, n, i):
s[j].append(i)
p, d, r = {}, set(), [''] * m
for j in range(len(li)):
t = li[j][0]
i = int(li[j][1])
if t[0] == '+':
if i in d:
r[j] = 'Already on'
continue
for q in s[i]:
if q in p:
r[j] = 'Conflict with ' + str(p[q])
break
else:
r[j] = 'Success'
d.add(i)
for q in s[i]: p[q] = i
else:
if i in d:
r[j] = 'Success'
for q in s[i]: p.pop(q)
d.remove(i)
else:
r[j] = 'Already off'
return r
# Function to take input
def input_test():
# for _ in range(int(input())):
# n = int(input())
n, m = map(int, input().strip().split(" "))
quer = []
for i in range(m):
qu = list(map(str, input().strip().split(" ")))
quer.append(qu)
# a, b, c = map(int, input().strip().split(" "))
# li = list(map(int, input().strip().split(" ")))
out = solution(quer, n+1, m)
for i in out:
print(i)
# Function to test my code
def test():
pass
# seive()
input_test()
# test()
``` | output | 1 | 12,716 | 3 | 25,433 |
Provide tags and a correct Python 3 solution for this coding contest problem.
By 2312 there were n Large Hadron Colliders in the inhabited part of the universe. Each of them corresponded to a single natural number from 1 to n. However, scientists did not know what activating several colliders simultaneously could cause, so the colliders were deactivated.
In 2312 there was a startling discovery: a collider's activity is safe if and only if all numbers of activated colliders are pairwise relatively prime to each other (two numbers are relatively prime if their greatest common divisor equals 1)! If two colliders with relatively nonprime numbers are activated, it will cause a global collapse.
Upon learning this, physicists rushed to turn the colliders on and off and carry out all sorts of experiments. To make sure than the scientists' quickness doesn't end with big trouble, the Large Hadron Colliders' Large Remote Control was created. You are commissioned to write the software for the remote (well, you do not expect anybody to operate it manually, do you?).
Initially, all colliders are deactivated. Your program receives multiple requests of the form "activate/deactivate the i-th collider". The program should handle requests in the order of receiving them. The program should print the processed results in the format described below.
To the request of "+ i" (that is, to activate the i-th collider), the program should print exactly one of the following responses:
* "Success" if the activation was successful.
* "Already on", if the i-th collider was already activated before the request.
* "Conflict with j", if there is a conflict with the j-th collider (that is, the j-th collider is on, and numbers i and j are not relatively prime). In this case, the i-th collider shouldn't be activated. If a conflict occurs with several colliders simultaneously, you should print the number of any of them.
The request of "- i" (that is, to deactivate the i-th collider), should receive one of the following responses from the program:
* "Success", if the deactivation was successful.
* "Already off", if the i-th collider was already deactivated before the request.
You don't need to print quotes in the output of the responses to the requests.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the number of colliders and the number of requests, correspondingly.
Next m lines contain numbers of requests, one per line, in the form of either "+ i" (without the quotes) — activate the i-th collider, or "- i" (without the quotes) — deactivate the i-th collider (1 ≤ i ≤ n).
Output
Print m lines — the results of executing requests in the above given format. The requests should be processed in the order, in which they are given in the input. Don't forget that the responses to the requests should be printed without quotes.
Examples
Input
10 10
+ 6
+ 10
+ 5
- 10
- 5
- 6
+ 10
+ 3
+ 6
+ 3
Output
Success
Conflict with 6
Success
Already off
Success
Success
Success
Success
Conflict with 10
Already on
Note
Note that in the sample the colliders don't turn on after the second and ninth requests. The ninth request could also receive response "Conflict with 3". | instruction | 0 | 12,717 | 3 | 25,434 |
Tags: math, number theory
Correct Solution:
```
import sys
input=sys.stdin.readline
from math import gcd
n,k=map(int,input().split())
a=[[] for i in range(n+1)] # have primes of i
active=[0]*(n+1)
act={}
for i in range(2,n+1):
if not a[i]:
act[i]=0
for j in range(i,n+1,i):
a[j].append(i)
for _ in range(k):
s,x=input().rstrip().split()
x=int(x)
if s=="-":
if active[x]:
print("Success")
active[x]=0
for xx in a[x]:
act[xx]=0
else:
print("Already off")
else:
if active[x]:
print("Already on")
else:
t=1
flag=True
for xx in a[x]:
if act[xx]:
t=xx
flag=False
break
if flag:
print("Success")
active[x]=1
for xx in a[x]:
act[xx]=x
else:
print("Conflict with",act[t])
``` | output | 1 | 12,717 | 3 | 25,435 |
Provide tags and a correct Python 3 solution for this coding contest problem.
By 2312 there were n Large Hadron Colliders in the inhabited part of the universe. Each of them corresponded to a single natural number from 1 to n. However, scientists did not know what activating several colliders simultaneously could cause, so the colliders were deactivated.
In 2312 there was a startling discovery: a collider's activity is safe if and only if all numbers of activated colliders are pairwise relatively prime to each other (two numbers are relatively prime if their greatest common divisor equals 1)! If two colliders with relatively nonprime numbers are activated, it will cause a global collapse.
Upon learning this, physicists rushed to turn the colliders on and off and carry out all sorts of experiments. To make sure than the scientists' quickness doesn't end with big trouble, the Large Hadron Colliders' Large Remote Control was created. You are commissioned to write the software for the remote (well, you do not expect anybody to operate it manually, do you?).
Initially, all colliders are deactivated. Your program receives multiple requests of the form "activate/deactivate the i-th collider". The program should handle requests in the order of receiving them. The program should print the processed results in the format described below.
To the request of "+ i" (that is, to activate the i-th collider), the program should print exactly one of the following responses:
* "Success" if the activation was successful.
* "Already on", if the i-th collider was already activated before the request.
* "Conflict with j", if there is a conflict with the j-th collider (that is, the j-th collider is on, and numbers i and j are not relatively prime). In this case, the i-th collider shouldn't be activated. If a conflict occurs with several colliders simultaneously, you should print the number of any of them.
The request of "- i" (that is, to deactivate the i-th collider), should receive one of the following responses from the program:
* "Success", if the deactivation was successful.
* "Already off", if the i-th collider was already deactivated before the request.
You don't need to print quotes in the output of the responses to the requests.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the number of colliders and the number of requests, correspondingly.
Next m lines contain numbers of requests, one per line, in the form of either "+ i" (without the quotes) — activate the i-th collider, or "- i" (without the quotes) — deactivate the i-th collider (1 ≤ i ≤ n).
Output
Print m lines — the results of executing requests in the above given format. The requests should be processed in the order, in which they are given in the input. Don't forget that the responses to the requests should be printed without quotes.
Examples
Input
10 10
+ 6
+ 10
+ 5
- 10
- 5
- 6
+ 10
+ 3
+ 6
+ 3
Output
Success
Conflict with 6
Success
Already off
Success
Success
Success
Success
Conflict with 10
Already on
Note
Note that in the sample the colliders don't turn on after the second and ninth requests. The ninth request could also receive response "Conflict with 3". | instruction | 0 | 12,718 | 3 | 25,436 |
Tags: math, number theory
Correct Solution:
```
import random, math, sys
from copy import deepcopy as dc
from bisect import bisect_left, bisect_right
from collections import Counter
input = sys.stdin.readline
# Function to call the actual solution
def solution(li, n, m):
s = [[] for i in range(n)]
for j in range(2, n, 2):
s[j] = [2]
for i in range(3, n, 2):
if s[i]:
continue
for j in range(i, n, i):
s[j].append(i)
p, d, r = {}, set(), [''] * m
for j in range(len(li)):
t = li[j][0]
i = int(li[j][1])
if t[0] == '+':
if i in d:
r[j] = 'Already on'
continue
for q in s[i]:
if q in p:
r[j] = 'Conflict with ' + str(p[q])
break
else:
r[j] = 'Success'
d.add(i)
for q in s[i]: p[q] = i
else:
if i in d:
r[j] = 'Success'
for q in s[i]: p.pop(q)
d.remove(i)
else:
r[j] = 'Already off'
return r
# Function to take input
def input_test():
# for _ in range(int(input())):
# n = int(input())
n, m = map(int, input().strip().split(" "))
quer = []
for i in range(m):
qu = list(map(str, input().strip().split(" ")))
quer.append(qu)
# a, b, c = map(int, input().strip().split(" "))
# li = list(map(int, input().strip().split(" ")))
out = solution(quer, n+1, m)
for i in out:
print(i)
# Function to test my code
def test():
pass
# seive()
input_test()
# test()
``` | output | 1 | 12,718 | 3 | 25,437 |
Provide tags and a correct Python 3 solution for this coding contest problem.
By 2312 there were n Large Hadron Colliders in the inhabited part of the universe. Each of them corresponded to a single natural number from 1 to n. However, scientists did not know what activating several colliders simultaneously could cause, so the colliders were deactivated.
In 2312 there was a startling discovery: a collider's activity is safe if and only if all numbers of activated colliders are pairwise relatively prime to each other (two numbers are relatively prime if their greatest common divisor equals 1)! If two colliders with relatively nonprime numbers are activated, it will cause a global collapse.
Upon learning this, physicists rushed to turn the colliders on and off and carry out all sorts of experiments. To make sure than the scientists' quickness doesn't end with big trouble, the Large Hadron Colliders' Large Remote Control was created. You are commissioned to write the software for the remote (well, you do not expect anybody to operate it manually, do you?).
Initially, all colliders are deactivated. Your program receives multiple requests of the form "activate/deactivate the i-th collider". The program should handle requests in the order of receiving them. The program should print the processed results in the format described below.
To the request of "+ i" (that is, to activate the i-th collider), the program should print exactly one of the following responses:
* "Success" if the activation was successful.
* "Already on", if the i-th collider was already activated before the request.
* "Conflict with j", if there is a conflict with the j-th collider (that is, the j-th collider is on, and numbers i and j are not relatively prime). In this case, the i-th collider shouldn't be activated. If a conflict occurs with several colliders simultaneously, you should print the number of any of them.
The request of "- i" (that is, to deactivate the i-th collider), should receive one of the following responses from the program:
* "Success", if the deactivation was successful.
* "Already off", if the i-th collider was already deactivated before the request.
You don't need to print quotes in the output of the responses to the requests.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the number of colliders and the number of requests, correspondingly.
Next m lines contain numbers of requests, one per line, in the form of either "+ i" (without the quotes) — activate the i-th collider, or "- i" (without the quotes) — deactivate the i-th collider (1 ≤ i ≤ n).
Output
Print m lines — the results of executing requests in the above given format. The requests should be processed in the order, in which they are given in the input. Don't forget that the responses to the requests should be printed without quotes.
Examples
Input
10 10
+ 6
+ 10
+ 5
- 10
- 5
- 6
+ 10
+ 3
+ 6
+ 3
Output
Success
Conflict with 6
Success
Already off
Success
Success
Success
Success
Conflict with 10
Already on
Note
Note that in the sample the colliders don't turn on after the second and ninth requests. The ninth request could also receive response "Conflict with 3". | instruction | 0 | 12,719 | 3 | 25,438 |
Tags: math, number theory
Correct Solution:
```
from sys import stdin
import math
n, k = map(int, stdin.readline().rstrip().split(" "))
a = [[] for i in range(n+1)]
act = {}
active = [0]*(n+1)
for i in range(2,n+1):
if not a[i]:
act[i]=0
for j in range(i,n+1,i):
a[j].append(i)
storing = {}
for _ in range(k):
s, v = stdin.readline().rstrip().split(" ")
v = int(v)
if s=="-":
if active[v]==1:
print("Success")
active[v]=0
for i in list(a[v]):
act[i]=0
else:
print("Already off")
else:
if active[v]:
print("Already on")
else:
test = 1
r = True
for i in list(a[v]):
if act[i]:
test = i
r=False
break
if r:
print("Success")
active[v]=1
for i in list(a[v])[::-1]:
act[i] = v
else:
x = 0
print("Conflict with", act[test])
``` | output | 1 | 12,719 | 3 | 25,439 |
Provide tags and a correct Python 3 solution for this coding contest problem.
By 2312 there were n Large Hadron Colliders in the inhabited part of the universe. Each of them corresponded to a single natural number from 1 to n. However, scientists did not know what activating several colliders simultaneously could cause, so the colliders were deactivated.
In 2312 there was a startling discovery: a collider's activity is safe if and only if all numbers of activated colliders are pairwise relatively prime to each other (two numbers are relatively prime if their greatest common divisor equals 1)! If two colliders with relatively nonprime numbers are activated, it will cause a global collapse.
Upon learning this, physicists rushed to turn the colliders on and off and carry out all sorts of experiments. To make sure than the scientists' quickness doesn't end with big trouble, the Large Hadron Colliders' Large Remote Control was created. You are commissioned to write the software for the remote (well, you do not expect anybody to operate it manually, do you?).
Initially, all colliders are deactivated. Your program receives multiple requests of the form "activate/deactivate the i-th collider". The program should handle requests in the order of receiving them. The program should print the processed results in the format described below.
To the request of "+ i" (that is, to activate the i-th collider), the program should print exactly one of the following responses:
* "Success" if the activation was successful.
* "Already on", if the i-th collider was already activated before the request.
* "Conflict with j", if there is a conflict with the j-th collider (that is, the j-th collider is on, and numbers i and j are not relatively prime). In this case, the i-th collider shouldn't be activated. If a conflict occurs with several colliders simultaneously, you should print the number of any of them.
The request of "- i" (that is, to deactivate the i-th collider), should receive one of the following responses from the program:
* "Success", if the deactivation was successful.
* "Already off", if the i-th collider was already deactivated before the request.
You don't need to print quotes in the output of the responses to the requests.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the number of colliders and the number of requests, correspondingly.
Next m lines contain numbers of requests, one per line, in the form of either "+ i" (without the quotes) — activate the i-th collider, or "- i" (without the quotes) — deactivate the i-th collider (1 ≤ i ≤ n).
Output
Print m lines — the results of executing requests in the above given format. The requests should be processed in the order, in which they are given in the input. Don't forget that the responses to the requests should be printed without quotes.
Examples
Input
10 10
+ 6
+ 10
+ 5
- 10
- 5
- 6
+ 10
+ 3
+ 6
+ 3
Output
Success
Conflict with 6
Success
Already off
Success
Success
Success
Success
Conflict with 10
Already on
Note
Note that in the sample the colliders don't turn on after the second and ninth requests. The ninth request could also receive response "Conflict with 3". | instruction | 0 | 12,720 | 3 | 25,440 |
Tags: math, number theory
Correct Solution:
```
MAXN = 100005
pr = [0] * MAXN
n, m = map(int, input().split())
for i in range(2, n + 1, 2):
pr[i] = 2
for i in range(3, n + 1, 2):
if not pr[i]:
j = i
while j <= n:
if not pr[j]:
pr[j] = i
j += i
answer = [''] * m
p, d = {}, set()
for i in range(m):
temp = input()
ch = temp[0]
x = int(temp[2:])
if ch == '+':
if x in d:
answer[i] = 'Already on'
continue
y = x
while y > 1:
if pr[y] in p:
answer[i] = 'Conflict with ' + str(p[pr[y]])
break
y //= pr[y]
else:
answer[i] = 'Success'
d.add(x)
y = x
while y > 1:
p[pr[y]] = x
y //= pr[y]
else:
if x in d:
answer[i] = 'Success'
y = x
while y > 1:
if pr[y] in p:
p.pop(pr[y])
y //= pr[y]
d.remove(x)
else:
answer[i] = 'Already off'
print('\n'.join(answer))
``` | output | 1 | 12,720 | 3 | 25,441 |
Provide tags and a correct Python 3 solution for this coding contest problem.
By 2312 there were n Large Hadron Colliders in the inhabited part of the universe. Each of them corresponded to a single natural number from 1 to n. However, scientists did not know what activating several colliders simultaneously could cause, so the colliders were deactivated.
In 2312 there was a startling discovery: a collider's activity is safe if and only if all numbers of activated colliders are pairwise relatively prime to each other (two numbers are relatively prime if their greatest common divisor equals 1)! If two colliders with relatively nonprime numbers are activated, it will cause a global collapse.
Upon learning this, physicists rushed to turn the colliders on and off and carry out all sorts of experiments. To make sure than the scientists' quickness doesn't end with big trouble, the Large Hadron Colliders' Large Remote Control was created. You are commissioned to write the software for the remote (well, you do not expect anybody to operate it manually, do you?).
Initially, all colliders are deactivated. Your program receives multiple requests of the form "activate/deactivate the i-th collider". The program should handle requests in the order of receiving them. The program should print the processed results in the format described below.
To the request of "+ i" (that is, to activate the i-th collider), the program should print exactly one of the following responses:
* "Success" if the activation was successful.
* "Already on", if the i-th collider was already activated before the request.
* "Conflict with j", if there is a conflict with the j-th collider (that is, the j-th collider is on, and numbers i and j are not relatively prime). In this case, the i-th collider shouldn't be activated. If a conflict occurs with several colliders simultaneously, you should print the number of any of them.
The request of "- i" (that is, to deactivate the i-th collider), should receive one of the following responses from the program:
* "Success", if the deactivation was successful.
* "Already off", if the i-th collider was already deactivated before the request.
You don't need to print quotes in the output of the responses to the requests.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the number of colliders and the number of requests, correspondingly.
Next m lines contain numbers of requests, one per line, in the form of either "+ i" (without the quotes) — activate the i-th collider, or "- i" (without the quotes) — deactivate the i-th collider (1 ≤ i ≤ n).
Output
Print m lines — the results of executing requests in the above given format. The requests should be processed in the order, in which they are given in the input. Don't forget that the responses to the requests should be printed without quotes.
Examples
Input
10 10
+ 6
+ 10
+ 5
- 10
- 5
- 6
+ 10
+ 3
+ 6
+ 3
Output
Success
Conflict with 6
Success
Already off
Success
Success
Success
Success
Conflict with 10
Already on
Note
Note that in the sample the colliders don't turn on after the second and ninth requests. The ninth request could also receive response "Conflict with 3". | instruction | 0 | 12,721 | 3 | 25,442 |
Tags: math, number theory
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# Python3 program to find prime factorization
# of a number n in O(Log n) time with
# precomputation allowed.
import math as mt
# Calculating SPF (Smallest Prime Factor)
# for every number till MAXN.
# Time Complexity : O(nloglogn)
def sieve():
spf[1] = 1
for i in range(2, MAXN):
# marking smallest prime factor
# for every number to be itself.
spf[i] = i
# separately marking spf for
# every even number as 2
for i in range(4, MAXN, 2):
spf[i] = 2
for i in range(3, mt.ceil(mt.sqrt(MAXN))):
# checking if i is prime
if (spf[i] == i):
# marking SPF for all numbers
# divisible by i
for j in range(i * i, MAXN, i):
# marking spf[j] if it is
# not previously marked
if (spf[j] == j):
spf[j] = i
# A O(log n) function returning prime
# factorization by dividing by smallest
# prime factor at every step
def getFactorization(x, check = False):
ret = set()
while (x != 1):
if len(primetaken[spf[x]]) != 0 and check:
z = primetaken[spf[x]].pop()
print(f'Conflict with {z}')
primetaken[spf[x]].add(z)
return None
ret.add(spf[x])
x = x // spf[x]
return ret
n, m = map(int, input().rstrip().split(" "))
MAXN = n + 1
# stores smallest prime factor for
# every number
spf = [0 for i in range(n + 1)]
sieve()
#print(spf)
primetaken = [set() for i in range(n + 1)]
numtaken = [False] * (n + 1)
for _ in range(m):
s, x = input().rstrip().split(" ")
x = int(x)
if s == '+':
if numtaken[x]:
print('Already on')
else:
f = getFactorization(x, True)
if f is not None:
for ele in f:
primetaken[ele].add(x)
print('Success')
numtaken[x] = True
else:
if numtaken[x]:
f = getFactorization(x)
for ele in f:
primetaken[ele].remove(x)
numtaken[x] = False
print('Success')
else:
print('Already off')
``` | output | 1 | 12,721 | 3 | 25,443 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
By 2312 there were n Large Hadron Colliders in the inhabited part of the universe. Each of them corresponded to a single natural number from 1 to n. However, scientists did not know what activating several colliders simultaneously could cause, so the colliders were deactivated.
In 2312 there was a startling discovery: a collider's activity is safe if and only if all numbers of activated colliders are pairwise relatively prime to each other (two numbers are relatively prime if their greatest common divisor equals 1)! If two colliders with relatively nonprime numbers are activated, it will cause a global collapse.
Upon learning this, physicists rushed to turn the colliders on and off and carry out all sorts of experiments. To make sure than the scientists' quickness doesn't end with big trouble, the Large Hadron Colliders' Large Remote Control was created. You are commissioned to write the software for the remote (well, you do not expect anybody to operate it manually, do you?).
Initially, all colliders are deactivated. Your program receives multiple requests of the form "activate/deactivate the i-th collider". The program should handle requests in the order of receiving them. The program should print the processed results in the format described below.
To the request of "+ i" (that is, to activate the i-th collider), the program should print exactly one of the following responses:
* "Success" if the activation was successful.
* "Already on", if the i-th collider was already activated before the request.
* "Conflict with j", if there is a conflict with the j-th collider (that is, the j-th collider is on, and numbers i and j are not relatively prime). In this case, the i-th collider shouldn't be activated. If a conflict occurs with several colliders simultaneously, you should print the number of any of them.
The request of "- i" (that is, to deactivate the i-th collider), should receive one of the following responses from the program:
* "Success", if the deactivation was successful.
* "Already off", if the i-th collider was already deactivated before the request.
You don't need to print quotes in the output of the responses to the requests.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the number of colliders and the number of requests, correspondingly.
Next m lines contain numbers of requests, one per line, in the form of either "+ i" (without the quotes) — activate the i-th collider, or "- i" (without the quotes) — deactivate the i-th collider (1 ≤ i ≤ n).
Output
Print m lines — the results of executing requests in the above given format. The requests should be processed in the order, in which they are given in the input. Don't forget that the responses to the requests should be printed without quotes.
Examples
Input
10 10
+ 6
+ 10
+ 5
- 10
- 5
- 6
+ 10
+ 3
+ 6
+ 3
Output
Success
Conflict with 6
Success
Already off
Success
Success
Success
Success
Conflict with 10
Already on
Note
Note that in the sample the colliders don't turn on after the second and ninth requests. The ninth request could also receive response "Conflict with 3".
Submitted Solution:
```
n, m = map(int, input().split())
n += 1
s = [[] for i in range(n)]
for j in range(2, n, 2): s[j] = [2]
for i in range(3, n, 2):
if s[i]: continue
for j in range(i, n, i): s[j].append(i)
p, d, r = {}, set(), [''] * m
for j in range(m):
t = input()
i = int(t[2: ])
if t[0] == '+':
if i in d:
r[j] = 'Already on'
continue
for q in s[i]:
if q in p:
r[j] = 'Conflict with ' + str(p[q])
break
else:
r[j] = 'Success'
d.add(i)
for q in s[i]: p[q] = i
else:
if i in d:
r[j] = 'Success'
for q in s[i]: p.pop(q)
d.remove(i)
else: r[j] = 'Already off'
print('\n'.join(r))
# Made By Mostafa_Khaled
``` | instruction | 0 | 12,722 | 3 | 25,444 |
Yes | output | 1 | 12,722 | 3 | 25,445 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
By 2312 there were n Large Hadron Colliders in the inhabited part of the universe. Each of them corresponded to a single natural number from 1 to n. However, scientists did not know what activating several colliders simultaneously could cause, so the colliders were deactivated.
In 2312 there was a startling discovery: a collider's activity is safe if and only if all numbers of activated colliders are pairwise relatively prime to each other (two numbers are relatively prime if their greatest common divisor equals 1)! If two colliders with relatively nonprime numbers are activated, it will cause a global collapse.
Upon learning this, physicists rushed to turn the colliders on and off and carry out all sorts of experiments. To make sure than the scientists' quickness doesn't end with big trouble, the Large Hadron Colliders' Large Remote Control was created. You are commissioned to write the software for the remote (well, you do not expect anybody to operate it manually, do you?).
Initially, all colliders are deactivated. Your program receives multiple requests of the form "activate/deactivate the i-th collider". The program should handle requests in the order of receiving them. The program should print the processed results in the format described below.
To the request of "+ i" (that is, to activate the i-th collider), the program should print exactly one of the following responses:
* "Success" if the activation was successful.
* "Already on", if the i-th collider was already activated before the request.
* "Conflict with j", if there is a conflict with the j-th collider (that is, the j-th collider is on, and numbers i and j are not relatively prime). In this case, the i-th collider shouldn't be activated. If a conflict occurs with several colliders simultaneously, you should print the number of any of them.
The request of "- i" (that is, to deactivate the i-th collider), should receive one of the following responses from the program:
* "Success", if the deactivation was successful.
* "Already off", if the i-th collider was already deactivated before the request.
You don't need to print quotes in the output of the responses to the requests.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the number of colliders and the number of requests, correspondingly.
Next m lines contain numbers of requests, one per line, in the form of either "+ i" (without the quotes) — activate the i-th collider, or "- i" (without the quotes) — deactivate the i-th collider (1 ≤ i ≤ n).
Output
Print m lines — the results of executing requests in the above given format. The requests should be processed in the order, in which they are given in the input. Don't forget that the responses to the requests should be printed without quotes.
Examples
Input
10 10
+ 6
+ 10
+ 5
- 10
- 5
- 6
+ 10
+ 3
+ 6
+ 3
Output
Success
Conflict with 6
Success
Already off
Success
Success
Success
Success
Conflict with 10
Already on
Note
Note that in the sample the colliders don't turn on after the second and ninth requests. The ninth request could also receive response "Conflict with 3".
Submitted Solution:
```
from sys import stdin, stdout
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
mod = pow(10, 9) + 7
mod2 = 998244353
def inp(): return stdin.readline().strip()
def iinp(): return int(inp())
def out(var, end="\n"): stdout.write(str(var)+"\n")
def outa(*var, end="\n"): stdout.write(' '.join(map(str, var)) + end)
def lmp(): return list(mp())
def mp(): return map(int, inp().split())
def smp(): return map(str, inp().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(m, val) for j in range(n)]
def remadd(x, y): return 1 if x%y else 0
def ceil(a,b): return (a+b-1)//b
def isprime(x):
if x<=1: return False
if x in (2, 3): return True
if x%2 == 0: return False
for i in range(3, int(sqrt(x))+1, 2):
if x%i == 0: return False
return True
n, m = mp()
md1 = dd(int)
status = dd(int)
pfs = {}
for i in range(m):
a, b = inp().split()
b = int(b)
if a == '-':
if status[b]:
status[b] = 0
print("Success")
for i in pfs[b]: md1[i] = 0
else:
print("Already off")
else:
if status[b]:
print("Already on")
continue
s = set()
tb = b
if tb%2==0:
s.add(2)
while tb%2==0: tb//=2
j = 3
while j*j<=tb:
if tb%j==0:
s.add(j)
while tb%j==0: tb//=j
j += 2
if tb>1: s.add(tb)
flg = True
for i in s:
if md1[i]:
ind = i
flg=False
break
if flg:
for i in s:
md1[i] = b
pfs[b] = s
status[b] = 1
print("Success")
else:
print("Conflict with", md1[ind])
``` | instruction | 0 | 12,723 | 3 | 25,446 |
Yes | output | 1 | 12,723 | 3 | 25,447 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
By 2312 there were n Large Hadron Colliders in the inhabited part of the universe. Each of them corresponded to a single natural number from 1 to n. However, scientists did not know what activating several colliders simultaneously could cause, so the colliders were deactivated.
In 2312 there was a startling discovery: a collider's activity is safe if and only if all numbers of activated colliders are pairwise relatively prime to each other (two numbers are relatively prime if their greatest common divisor equals 1)! If two colliders with relatively nonprime numbers are activated, it will cause a global collapse.
Upon learning this, physicists rushed to turn the colliders on and off and carry out all sorts of experiments. To make sure than the scientists' quickness doesn't end with big trouble, the Large Hadron Colliders' Large Remote Control was created. You are commissioned to write the software for the remote (well, you do not expect anybody to operate it manually, do you?).
Initially, all colliders are deactivated. Your program receives multiple requests of the form "activate/deactivate the i-th collider". The program should handle requests in the order of receiving them. The program should print the processed results in the format described below.
To the request of "+ i" (that is, to activate the i-th collider), the program should print exactly one of the following responses:
* "Success" if the activation was successful.
* "Already on", if the i-th collider was already activated before the request.
* "Conflict with j", if there is a conflict with the j-th collider (that is, the j-th collider is on, and numbers i and j are not relatively prime). In this case, the i-th collider shouldn't be activated. If a conflict occurs with several colliders simultaneously, you should print the number of any of them.
The request of "- i" (that is, to deactivate the i-th collider), should receive one of the following responses from the program:
* "Success", if the deactivation was successful.
* "Already off", if the i-th collider was already deactivated before the request.
You don't need to print quotes in the output of the responses to the requests.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the number of colliders and the number of requests, correspondingly.
Next m lines contain numbers of requests, one per line, in the form of either "+ i" (without the quotes) — activate the i-th collider, or "- i" (without the quotes) — deactivate the i-th collider (1 ≤ i ≤ n).
Output
Print m lines — the results of executing requests in the above given format. The requests should be processed in the order, in which they are given in the input. Don't forget that the responses to the requests should be printed without quotes.
Examples
Input
10 10
+ 6
+ 10
+ 5
- 10
- 5
- 6
+ 10
+ 3
+ 6
+ 3
Output
Success
Conflict with 6
Success
Already off
Success
Success
Success
Success
Conflict with 10
Already on
Note
Note that in the sample the colliders don't turn on after the second and ninth requests. The ninth request could also receive response "Conflict with 3".
Submitted Solution:
```
import math
t=[]
n,m=list(map(int,input().split()))
for i in range(m):
s=input()
a=int(s[1:])
q=0
y=len(t)
if s[0]=='+':
if a not in t:
if y==0:
t.append(a)
print('Sucess')
else:
for k in t:
if math.gcd(a,k)!=1:
print('Conflict with ',k)
q+=1
break
if q==0:
t.append(a)
print('Success')
else:
print('Already on')
else:
if a not in t:
print('Already off')
else:
t.remove(a)
print('Success')
``` | instruction | 0 | 12,724 | 3 | 25,448 |
No | output | 1 | 12,724 | 3 | 25,449 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
By 2312 there were n Large Hadron Colliders in the inhabited part of the universe. Each of them corresponded to a single natural number from 1 to n. However, scientists did not know what activating several colliders simultaneously could cause, so the colliders were deactivated.
In 2312 there was a startling discovery: a collider's activity is safe if and only if all numbers of activated colliders are pairwise relatively prime to each other (two numbers are relatively prime if their greatest common divisor equals 1)! If two colliders with relatively nonprime numbers are activated, it will cause a global collapse.
Upon learning this, physicists rushed to turn the colliders on and off and carry out all sorts of experiments. To make sure than the scientists' quickness doesn't end with big trouble, the Large Hadron Colliders' Large Remote Control was created. You are commissioned to write the software for the remote (well, you do not expect anybody to operate it manually, do you?).
Initially, all colliders are deactivated. Your program receives multiple requests of the form "activate/deactivate the i-th collider". The program should handle requests in the order of receiving them. The program should print the processed results in the format described below.
To the request of "+ i" (that is, to activate the i-th collider), the program should print exactly one of the following responses:
* "Success" if the activation was successful.
* "Already on", if the i-th collider was already activated before the request.
* "Conflict with j", if there is a conflict with the j-th collider (that is, the j-th collider is on, and numbers i and j are not relatively prime). In this case, the i-th collider shouldn't be activated. If a conflict occurs with several colliders simultaneously, you should print the number of any of them.
The request of "- i" (that is, to deactivate the i-th collider), should receive one of the following responses from the program:
* "Success", if the deactivation was successful.
* "Already off", if the i-th collider was already deactivated before the request.
You don't need to print quotes in the output of the responses to the requests.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the number of colliders and the number of requests, correspondingly.
Next m lines contain numbers of requests, one per line, in the form of either "+ i" (without the quotes) — activate the i-th collider, or "- i" (without the quotes) — deactivate the i-th collider (1 ≤ i ≤ n).
Output
Print m lines — the results of executing requests in the above given format. The requests should be processed in the order, in which they are given in the input. Don't forget that the responses to the requests should be printed without quotes.
Examples
Input
10 10
+ 6
+ 10
+ 5
- 10
- 5
- 6
+ 10
+ 3
+ 6
+ 3
Output
Success
Conflict with 6
Success
Already off
Success
Success
Success
Success
Conflict with 10
Already on
Note
Note that in the sample the colliders don't turn on after the second and ninth requests. The ninth request could also receive response "Conflict with 3".
Submitted Solution:
```
import random, math
from copy import deepcopy as dc
MAXN = 100001
primes = [set() for i in range(MAXN)]
primes[0] = set()
primes[1] = set()
primes[1].add(1)
def seive():
i = 2
while i*i < MAXN:
if primes[i] == set():
for j in range(i, MAXN, i):
primes[j].add(i)
i += 1
def solution_on(num, turned_on, setter):
if num in turned_on:
return turned_on, setter, "Already on"
for i in primes[num]:
if i in setter and setter[i]!=0:
return turned_on, setter, "Conflict with "+str(setter[i])
# some = set(setter.keys())
# some = some.intersection(primes[num])
# if len(some):
# some = list(some)
# return turned_on, setter, "Conflict with "+str(setter[some[-1]])
turned_on.add(num)
for i in primes[num]:
setter[i] = num
return turned_on, setter, "Success"
# Function to call the actual solution
def solution(num, turned_on, setter):
if num not in turned_on:
return turned_on, setter, "Already off"
turned_on.remove(num)
for i in primes[num]:
setter[i] = 0
return turned_on, setter, "Success"
# Function to take input
def input_test():
n, m = map(int, input().strip().split(" "))
turned_on = set()
setter = {}
rev = []
turned_on1 = set()
for i in range(m):
cmd = list(map(str, input().strip().split(" ")))
if cmd[0] == "+":
turned_on, setter, out= solution_on(int(cmd[1]), turned_on, setter)
print(out)
elif cmd[0] == "-":
turned_on, setter, out = solution(int(cmd[1]), turned_on, setter)
print(out)
seive()
# print(primes[:11])
input_test()
``` | instruction | 0 | 12,725 | 3 | 25,450 |
No | output | 1 | 12,725 | 3 | 25,451 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
By 2312 there were n Large Hadron Colliders in the inhabited part of the universe. Each of them corresponded to a single natural number from 1 to n. However, scientists did not know what activating several colliders simultaneously could cause, so the colliders were deactivated.
In 2312 there was a startling discovery: a collider's activity is safe if and only if all numbers of activated colliders are pairwise relatively prime to each other (two numbers are relatively prime if their greatest common divisor equals 1)! If two colliders with relatively nonprime numbers are activated, it will cause a global collapse.
Upon learning this, physicists rushed to turn the colliders on and off and carry out all sorts of experiments. To make sure than the scientists' quickness doesn't end with big trouble, the Large Hadron Colliders' Large Remote Control was created. You are commissioned to write the software for the remote (well, you do not expect anybody to operate it manually, do you?).
Initially, all colliders are deactivated. Your program receives multiple requests of the form "activate/deactivate the i-th collider". The program should handle requests in the order of receiving them. The program should print the processed results in the format described below.
To the request of "+ i" (that is, to activate the i-th collider), the program should print exactly one of the following responses:
* "Success" if the activation was successful.
* "Already on", if the i-th collider was already activated before the request.
* "Conflict with j", if there is a conflict with the j-th collider (that is, the j-th collider is on, and numbers i and j are not relatively prime). In this case, the i-th collider shouldn't be activated. If a conflict occurs with several colliders simultaneously, you should print the number of any of them.
The request of "- i" (that is, to deactivate the i-th collider), should receive one of the following responses from the program:
* "Success", if the deactivation was successful.
* "Already off", if the i-th collider was already deactivated before the request.
You don't need to print quotes in the output of the responses to the requests.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the number of colliders and the number of requests, correspondingly.
Next m lines contain numbers of requests, one per line, in the form of either "+ i" (without the quotes) — activate the i-th collider, or "- i" (without the quotes) — deactivate the i-th collider (1 ≤ i ≤ n).
Output
Print m lines — the results of executing requests in the above given format. The requests should be processed in the order, in which they are given in the input. Don't forget that the responses to the requests should be printed without quotes.
Examples
Input
10 10
+ 6
+ 10
+ 5
- 10
- 5
- 6
+ 10
+ 3
+ 6
+ 3
Output
Success
Conflict with 6
Success
Already off
Success
Success
Success
Success
Conflict with 10
Already on
Note
Note that in the sample the colliders don't turn on after the second and ninth requests. The ninth request could also receive response "Conflict with 3".
Submitted Solution:
```
import re
n = input()
a = list(input().split(" "))
s = "".join(a)
l = list(map(lambda x: len(x), list(re.findall("(1+)", s))))
h = list(map(lambda x: len(x), list(re.findall("^(1+)", s))))
t = list(map(lambda x: len(x), list(re.findall("(1+)$", s))))
result = 0
if len(l) > 0:
result = max(l)
if len(h)*len(t) > 0:
result = max(result, h[0] + t[0])
print(result)
``` | instruction | 0 | 12,726 | 3 | 25,452 |
No | output | 1 | 12,726 | 3 | 25,453 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
By 2312 there were n Large Hadron Colliders in the inhabited part of the universe. Each of them corresponded to a single natural number from 1 to n. However, scientists did not know what activating several colliders simultaneously could cause, so the colliders were deactivated.
In 2312 there was a startling discovery: a collider's activity is safe if and only if all numbers of activated colliders are pairwise relatively prime to each other (two numbers are relatively prime if their greatest common divisor equals 1)! If two colliders with relatively nonprime numbers are activated, it will cause a global collapse.
Upon learning this, physicists rushed to turn the colliders on and off and carry out all sorts of experiments. To make sure than the scientists' quickness doesn't end with big trouble, the Large Hadron Colliders' Large Remote Control was created. You are commissioned to write the software for the remote (well, you do not expect anybody to operate it manually, do you?).
Initially, all colliders are deactivated. Your program receives multiple requests of the form "activate/deactivate the i-th collider". The program should handle requests in the order of receiving them. The program should print the processed results in the format described below.
To the request of "+ i" (that is, to activate the i-th collider), the program should print exactly one of the following responses:
* "Success" if the activation was successful.
* "Already on", if the i-th collider was already activated before the request.
* "Conflict with j", if there is a conflict with the j-th collider (that is, the j-th collider is on, and numbers i and j are not relatively prime). In this case, the i-th collider shouldn't be activated. If a conflict occurs with several colliders simultaneously, you should print the number of any of them.
The request of "- i" (that is, to deactivate the i-th collider), should receive one of the following responses from the program:
* "Success", if the deactivation was successful.
* "Already off", if the i-th collider was already deactivated before the request.
You don't need to print quotes in the output of the responses to the requests.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the number of colliders and the number of requests, correspondingly.
Next m lines contain numbers of requests, one per line, in the form of either "+ i" (without the quotes) — activate the i-th collider, or "- i" (without the quotes) — deactivate the i-th collider (1 ≤ i ≤ n).
Output
Print m lines — the results of executing requests in the above given format. The requests should be processed in the order, in which they are given in the input. Don't forget that the responses to the requests should be printed without quotes.
Examples
Input
10 10
+ 6
+ 10
+ 5
- 10
- 5
- 6
+ 10
+ 3
+ 6
+ 3
Output
Success
Conflict with 6
Success
Already off
Success
Success
Success
Success
Conflict with 10
Already on
Note
Note that in the sample the colliders don't turn on after the second and ninth requests. The ninth request could also receive response "Conflict with 3".
Submitted Solution:
```
n,m = [int(x) for x in input().split()]
query = []
def gcd(a,b):
maximum = max(a,b)
minimum = min(a,b)
if maximum % minimum == 0:
return minimum
return gcd(maximum % minimum, minimum)
primes = [1]*(n + 1)
primes[0],primes[1] = 0,0
i = 2
while i*i <= n:
j = i
if primes[i] == 1:
while j*j <= n:
primes[i*j] = 0
j += 1
i += 1
for i in range(m):
q = 0
qi = [x for x in input().split()]
if qi[0] == '+':
q = int(qi[1])
else:
q = (-1)*int(qi[1])
if q < 0:
bool1 = False
for i in range(len(query)):
if query[i] == (-1)*q:
bool1 = True
query.pop(i)
break
if bool1 :
print('Success')
else:
print('Already off')
else:
if len(query) == 0:
print('Success')
query.append(q)
else:
b = False
for j in range(len(query)):
if query[j] == q:
b = True
break
if b:
print('Already on')
else:
boolean = True
for i in range(n + 1):
if primes[i] == q:
print('Success')
query.append(q)
boolean = False
break
if boolean:
g = 0
bool2 = True
for i in range(len(query)):
g = gcd(q,query[i])
if g != 1:
bool2 = False
break
if bool2 :
print('Success')
query.append(q)
else:
print('Conflict with', query[i])
else:
break
``` | instruction | 0 | 12,727 | 3 | 25,454 |
No | output | 1 | 12,727 | 3 | 25,455 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 ≤ ax, ay, bx, by, tx, ty ≤ 109) — initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 ≤ n ≤ 100 000) — the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 ≤ xi, yi ≤ 109) — position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number — the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long. | instruction | 0 | 12,947 | 3 | 25,894 |
Tags: dp, geometry, greedy, implementation
Correct Solution:
```
import math
ax,ay,bx,by,tx,ty = map(float,input().split(" "))
n = int(input())
dis = 0.0
a1Dis = 100000000000.0**2
a2Dis = 100000000000.0**2
b1Dis = 100000000000.0**2
b2Dis = 100000000000.0**2
a1=0
b1=0
rec=0.0
for i in range(n):
x,y = map(float,input().split(" "))
rec=math.sqrt((x-tx)**2+(y-ty)**2)
dis+=rec*2
aDis = math.sqrt((x-ax)**2+(y-ay)**2)
if aDis-rec < a1Dis:
a1 = i
a2Dis = a1Dis
a1Dis = aDis-rec
elif aDis-rec<a2Dis:
a2Dis=aDis-rec
bDis = math.sqrt((x-bx)**2+(y-by)**2)
if bDis-rec < b1Dis:
b1=i
b2Dis = b1Dis
b1Dis = bDis-rec
elif bDis-rec<b2Dis:
b2Dis=bDis-rec
options=[a1Dis+b2Dis,b1Dis+a2Dis,a1Dis,b1Dis]
if a1!=b1:
options.append(b1Dis+a1Dis)
print(dis+min(options))
``` | output | 1 | 12,947 | 3 | 25,895 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 ≤ ax, ay, bx, by, tx, ty ≤ 109) — initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 ≤ n ≤ 100 000) — the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 ≤ xi, yi ≤ 109) — position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number — the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long. | instruction | 0 | 12,948 | 3 | 25,896 |
Tags: dp, geometry, greedy, implementation
Correct Solution:
```
import math
ax, ay, bx, by, tx, ty = [int(coord) for coord in input().split()]
n = int(input())
x ,y = [], []
minDis = 0
diff1 = []
diff2 = []
for i in range(n):
xi, yi = [int(coord) for coord in input().split()]
x.append(xi)
y.append(yi)
disBin = math.sqrt((xi-tx)**2 + (yi-ty)**2)
diff1.append(( math.sqrt((ax-xi)**2 + (ay-yi)**2) - disBin, i))
diff2.append(( math.sqrt((bx-xi)**2 + (by-yi)**2) - disBin, i))
minDis += 2 * disBin
diff1.sort()
diff2.sort()
ans = min(minDis + diff1[0][0], minDis + diff2[0][0])
if diff1[0][1] != diff2[0][1]:
ans = min(ans, minDis + diff1[0][0] + diff2[0][0])
elif n>1:
ans = min(ans, minDis + diff1[0][0] + diff2[1][0])
ans = min(ans, minDis + diff1[1][0] + diff2[0][0])
print(ans)
``` | output | 1 | 12,948 | 3 | 25,897 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 ≤ ax, ay, bx, by, tx, ty ≤ 109) — initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 ≤ n ≤ 100 000) — the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 ≤ xi, yi ≤ 109) — position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number — the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long. | instruction | 0 | 12,949 | 3 | 25,898 |
Tags: dp, geometry, greedy, implementation
Correct Solution:
```
ax, ay, bx, by, tx, ty = map(int, input().split())
n = int(input())
X = [0] * n
Y = [0] * n
T = [0.0] * n
res = 0.0
for i in range(n):
X[i], Y[i] = map(int, input().split())
T[i] = ((X[i] - tx) ** 2 + (Y[i] - ty) ** 2) ** 0.5
res += T[i] * 2
L1 = [[0]] * (n + 2)
L2 = [[0]] * (n + 2)
for i in range(n + 2):
L1[i] = [0.0] * 2
L2[i] = [0.0] * 2
L1[n][1] = n
L2[n][1] = n
L1[n + 1][1] = -1
L2[n + 1][1] = -2
L1[n + 1][0] = ((tx - ax) ** 2 + (ty - ay) ** 2) ** 0.5
L2[n + 1][0] = ((tx - bx) ** 2 + (ty - by) ** 2) ** 0.5
for i in range(n):
L1[i][0] = ((X[i] - ax) ** 2 + (Y[i] - ay) ** 2) ** 0.5 - T[i]
L2[i][0] = ((X[i] - bx) ** 2 + (Y[i] - by) ** 2) ** 0.5 - T[i]
L1[i][1] = L2[i][1] = i
L1.sort()
L2.sort()
d = 10**18
for i in range(min(n + 2, 10)):
for j in range(min(n + 2, 10)):
if L1[i][1] != L2[j][1]:
d = min(d, res + L1[i][0] + L2[j][0])
print(d)
``` | output | 1 | 12,949 | 3 | 25,899 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 ≤ ax, ay, bx, by, tx, ty ≤ 109) — initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 ≤ n ≤ 100 000) — the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 ≤ xi, yi ≤ 109) — position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number — the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long. | instruction | 0 | 12,950 | 3 | 25,900 |
Tags: dp, geometry, greedy, implementation
Correct Solution:
```
import math
R = lambda: map(int, input().split())
ax, ay, bx, by, tx, ty = R()
n = int(input())
dp = [[0] * (n + 1) for i in range(4)]
for i in range(n):
x, y = R()
da, db, dt = ((x - ax) ** 2 + (y - ay) ** 2) ** 0.5, ((x - bx) ** 2 + (y - by) ** 2) ** 0.5, ((x - tx) ** 2 + (y - ty) ** 2) ** 0.5
dp[0][i] = dp[0][i - 1] + dt * 2
dp[1][i] = min(dp[0][i - 1] + db + dt, dp[1][i - 1] + dt * 2 if i else math.inf)
dp[2][i] = min(dp[0][i - 1] + da + dt, dp[2][i - 1] + dt * 2 if i else math.inf)
dp[3][i] = min(dp[1][i - 1] + da + dt, dp[2][i - 1] + db + dt, dp[3][i - 1] + dt * 2) if i else math.inf
print(min(dp[3][n - 1], dp[2][n - 1], dp[1][n - 1]))
``` | output | 1 | 12,950 | 3 | 25,901 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 ≤ ax, ay, bx, by, tx, ty ≤ 109) — initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 ≤ n ≤ 100 000) — the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 ≤ xi, yi ≤ 109) — position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number — the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long. | instruction | 0 | 12,951 | 3 | 25,902 |
Tags: dp, geometry, greedy, implementation
Correct Solution:
```
import math
def dist(x1, y1, x2, y2):
return math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
ax, ay, bx, by, tx, ty = map(int, input().split())
n = int(input())
p = [tuple(int(x) for x in input().split()) for _ in range(n)]
da = [(dist(x[0], x[1], ax, ay) - dist(x[0], x[1], tx, ty), i)
for i, x in enumerate(p)]
db = [(dist(x[0], x[1], bx, by) - dist(x[0], x[1], tx, ty), i)
for i, x in enumerate(p)]
d = sum(2 * dist(x[0], x[1], tx, ty) for x in p)
da.sort()
db.sort()
ca, cb = -1, -1
md = 1e20
if d + da[0][0] < md:
md = d + da[0][0]
if d + db[0][0] < md:
md = d + db[0][0]
if da[0][1] != db[0][1]:
if d + da[0][0] + db[0][0] < md:
md = d + da[0][0] + db[0][0]
elif n > 1:
if d + da[1][0] + db[0][0] < md:
md = d + da[1][0] + db[0][0]
if d + da[0][0] + db[1][0] < md:
md = d + da[0][0] + db[1][0]
print(md)
``` | output | 1 | 12,951 | 3 | 25,903 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 ≤ ax, ay, bx, by, tx, ty ≤ 109) — initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 ≤ n ≤ 100 000) — the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 ≤ xi, yi ≤ 109) — position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number — the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long. | instruction | 0 | 12,952 | 3 | 25,904 |
Tags: dp, geometry, greedy, implementation
Correct Solution:
```
from math import *
ax, ay, bx, by, cx, cy = map(lambda t: int(t), input().split())
n = int(input())
dist = 0
maxv = [[-inf, -inf], [-inf, -inf]]
index = [[0,0], [0,0]]
def update(d, idx, p):
global maxv, index
if d > maxv[p][0]:
maxv[p][1] = maxv[p][0]
index[p][1] = index[p][0]
maxv[p][0] = d
index[p][0] = idx
elif d > maxv[p][1]:
maxv[p][1] = d
index[p][1] = idx
for i in range(n):
x, y = map(lambda t: int(t), input().split())
bottle_recycle = sqrt((cx - x) ** 2 + (cy - y) ** 2)
dist += bottle_recycle * 2
dista = bottle_recycle - sqrt((ax - x) ** 2 + (ay - y) ** 2)
distb = bottle_recycle - sqrt((bx - x) ** 2 + (by - y) ** 2)
update(dista, i, 0)
update(distb, i, 1)
ans = dist - maxv[0][0]
ans = min(ans, dist - maxv[1][0])
if(index[0][0] != index[1][0]):
ans = min(ans, dist - maxv[0][0] - maxv[1][0])
elif(n > 1):
ans = min(ans, dist - maxv[0][1] - maxv[1][0], dist - maxv[0][0] - maxv[1][1])
print(ans)
``` | output | 1 | 12,952 | 3 | 25,905 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 ≤ ax, ay, bx, by, tx, ty ≤ 109) — initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 ≤ n ≤ 100 000) — the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 ≤ xi, yi ≤ 109) — position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number — the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long. | instruction | 0 | 12,953 | 3 | 25,906 |
Tags: dp, geometry, greedy, implementation
Correct Solution:
```
from math import *
ax, ay, bx, by, cx, cy = [int(t) for t in input().split()]
n = int(input())
dist = 0
maxv = [[-inf, -inf], [-inf, -inf]]
index = [[0,0], [0,0]]
def update(d, idx, p):
global maxv, index
if d > maxv[p][0]:
maxv[p][1] = maxv[p][0]
index[p][1] = index[p][0]
maxv[p][0] = d
index[p][0] = idx
elif d > maxv[p][1]:
maxv[p][1] = d
index[p][1] = idx
for i in range(n):
x, y = [int(t) for t in input().split()]
bottle_recycle = sqrt((cx - x) ** 2 + (cy - y) ** 2)
dist += bottle_recycle * 2
dista = bottle_recycle - sqrt((ax - x) ** 2 + (ay - y) ** 2)
distb = bottle_recycle - sqrt((bx - x) ** 2 + (by - y) ** 2)
update(dista, i, 0)
update(distb, i, 1)
ans = dist - maxv[0][0]
ans = min(ans, dist - maxv[1][0])
if(index[0][0] != index[1][0]):
ans = min(ans, dist - maxv[0][0] - maxv[1][0])
elif(n > 1):
ans = min(ans, dist - maxv[0][1] - maxv[1][0], dist - maxv[0][0] - maxv[1][1])
print(ans)
``` | output | 1 | 12,953 | 3 | 25,907 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 ≤ ax, ay, bx, by, tx, ty ≤ 109) — initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 ≤ n ≤ 100 000) — the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 ≤ xi, yi ≤ 109) — position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number — the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long. | instruction | 0 | 12,954 | 3 | 25,908 |
Tags: dp, geometry, greedy, implementation
Correct Solution:
```
import math
def dist(x1, y1, x2, y2):
res = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)
res = math.sqrt(res)
return res
ax, ay, bx, by, tx, ty = list(map(int, input().split()))
n = int(input())
ans = 0
bottles = [(0, 0) for i in range(n)]
da = [(0, -1) for i in range(n + 1)]
db = [(0, -1) for i in range(n + 1)]
for i in range(n):
xi, yi = list(map(int, input().split()))
bottles.append((xi, yi))
# We compute the dist from xi, yi to tx ty and add the double to the ans
dt = dist(xi, yi, tx, ty)
ans += 2 * dt
# We now compute dist from ax, ay to xi, yi and dt (the path to collect the bottle and go to the center)
dist_a = dist(ax, ay, xi, yi) - dt
da[i] = (dist_a, i)
# Same for b
dist_b = dist(bx, by, xi, yi) - dt
db[i] = (dist_b, i)
best = 10 ** 18
da = sorted(da)
db = sorted(db)
for i in range(min(3, n + 1)):
for j in range(min(3, n + 1)):
if da[i][1] == db[j][1]:
continue
if da[i][1] == -1 and db[j][1] == -1:
continue
best = min(best, da[i][0] + db[j][0])
print(ans + best)
# Now we just need to know if a and b can pick something up
# For that, several cases
# If both min_dist_a and min_dist_b are greater than the distance needed to collect the corresponding bottle
# Only one of them will, the one with the least distance
# If one of them has a min_dist greater than the distance needed to collect, it won't
# If both of them can collect one (less then their distance), they both do
# We suppose for now this happen all the time
# print(s)
``` | output | 1 | 12,954 | 3 | 25,909 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 ≤ ax, ay, bx, by, tx, ty ≤ 109) — initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 ≤ n ≤ 100 000) — the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 ≤ xi, yi ≤ 109) — position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number — the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long.
Submitted Solution:
```
def D(x1, y1, x2, y2) :
return ((x1 - x2) ** 2 + (y1 - y2)**2)**0.5
Ax, Ay, Bx, By, Rx, Ry = [ float(_) for _ in input().split() ]
N = int(input())
PosX, PosY = [0.0] * N, [0.0] * N
for i in range(N) :
PosX[i], PosY[i] = map(int, input().split())
CutA, CutB = [0.0] * N, [0.0] * N
ans = 0
for i in range(N) :
DA = D(PosX[i], PosY[i], Ax, Ay)
DB = D(PosX[i], PosY[i], Bx, By)
DR = D(PosX[i], PosY[i], Rx, Ry)
CutA[i] = ( [i, DR - DA] )
CutB[i] = ( [i, DR - DB] )
ans += 2 * D(PosX[i], PosY[i], Rx, Ry)
CutA.sort(key = lambda x : x[1], reverse = True)
CutB.sort(key = lambda x : x[1], reverse = True)
CutCase = []
CutCase.append( CutA[0][1] )
CutCase.append( CutB[0][1] )
if N >= 2 :
if CutA[0][0] != CutB[0][0] :
CutCase.append( CutA[0][1] + CutB[0][1] )
else :
CutCase.append( CutA[0][1] + CutB[1][1] )
CutCase.append( CutA[1][1] + CutB[0][1])
ans -= max(CutCase)
print(ans)
``` | instruction | 0 | 12,955 | 3 | 25,910 |
Yes | output | 1 | 12,955 | 3 | 25,911 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 ≤ ax, ay, bx, by, tx, ty ≤ 109) — initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 ≤ n ≤ 100 000) — the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 ≤ xi, yi ≤ 109) — position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number — the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long.
Submitted Solution:
```
def main():
from math import hypot
from sys import stdin
ax, ay, bx, by, tx, ty = map(float, input().split())
s, tot = input(), 0.
m0 = m1 = m2 = m3 = -9e9
j = k = 0
for i, s in enumerate(stdin.read().splitlines()):
x, y = map(float, s.split())
r = hypot(tx - x, ty - y)
tot += r
d = r - hypot(ax - x, ay - y)
if m1 < d:
if m0 < d:
m0, m1, j = d, m0, i
else:
m1 = d
d = r - hypot(bx - x, by - y)
if m3 < d:
if m2 < d:
m2, m3, k = d, m2, i
else:
m3 = d
print(tot * 2. - max((m0, m2, m0 + m2) if j != k else (m0, m2, m0 + m3, m1 + m2)))
if __name__ == '__main__':
main()
``` | instruction | 0 | 12,956 | 3 | 25,912 |
Yes | output | 1 | 12,956 | 3 | 25,913 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 ≤ ax, ay, bx, by, tx, ty ≤ 109) — initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 ≤ n ≤ 100 000) — the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 ≤ xi, yi ≤ 109) — position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number — the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long.
Submitted Solution:
```
def dis(x1, y1, x2, y2):
return ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
ax, ay, bx, by, tx, ty = map(int, input().split())
n = int(input())
a, b, s = [], [], 0
for i in range(n):
x, y = map(int, input().split())
dist = dis(tx, ty, x, y)
a.append((dis(ax, ay, x, y) - dist, i))
b.append((dis(bx, by, x, y) - dist, i))
s += dist * 2
a.sort()
b.sort()
if n > 1 and a[0][1] == b[0][1]:
res = min(a[0][0], b[0][0], a[0][0]+b[1][0], a[1][0]+b[0][0])
else:
res = min(a[0][0], b[0][0])
if (n > 1) :
res = min(a[0][0]+b[0][0], res)
print(res + s)
``` | instruction | 0 | 12,957 | 3 | 25,914 |
Yes | output | 1 | 12,957 | 3 | 25,915 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 ≤ ax, ay, bx, by, tx, ty ≤ 109) — initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 ≤ n ≤ 100 000) — the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 ≤ xi, yi ≤ 109) — position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number — the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long.
Submitted Solution:
```
from math import sqrt
ax, ay, bx, by, tx, ty = map(int, input().split())
n = int(input())
d = 0
mina = (2*10**9,0,0)
mina2 = (2*10**9,0,0)
minb = (2*10**9,0,0)
minb2 = (2*10**9,0,0)
for _ in range(n):
x, y = map(int, input().split())
dt = sqrt((x-tx)**2+(y-ty)**2)
d += 2*dt
da = sqrt((ax-x)**2+(ay-y)**2)
dat = (da-dt,x,y)
if dat[0] < mina[0]:
mina, mina2 = dat, mina
elif dat[0] < mina2[0]:
mina2 = dat
db = sqrt((bx-x)**2+(by-y)**2)
dbt = (db-dt,x,y)
if dbt[0] < minb[0]:
minb, minb2 = dbt, minb
elif dbt[0] < minb2[0]:
minb2 = dbt
if n >= 2 and mina[0] < 0 and minb[0] < 0:
if mina[1] != minb[1] or mina[2] != minb[2]:
d += mina[0] + minb[0]
elif mina2[0] < 0 and minb2[0] < 0:
d += min(mina[0]+minb2[0],mina2[0]+minb[0])
elif mina2[0] < 0:
d += min(mina[0],mina2[0]+minb[0])
elif minb2[0] < 0:
d += min(mina[0]+minb2[0],minb[0])
else:
d += min(mina[0],minb[0])
else:
d += min(mina[0],minb[0])
print(d)
``` | instruction | 0 | 12,958 | 3 | 25,916 |
Yes | output | 1 | 12,958 | 3 | 25,917 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 ≤ ax, ay, bx, by, tx, ty ≤ 109) — initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 ≤ n ≤ 100 000) — the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 ≤ xi, yi ≤ 109) — position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number — the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long.
Submitted Solution:
```
def glen(x1,y1,x2,y2):
return ((x1-x2)**2+(y1-y2)**2)**0.5
xa, ya, xb, yb, xt, yt = map(int,input().split())
n = int(input())
x = [0]*n
y = [0]*n
for i in range(n):
x[i], y[i] = map(int,input().split())
inf = 10**10
afmin = [0, 0]
asmin = [0, 0]
for i in range(n):
a = glen(xa,ya,x[i],y[i])-glen(xa,ya,xt,yt)-glen(xt,yt,x[i],y[i])
if asmin[0] > a:
asmin[0] = a
asmin[1] = i
if asmin[0] < afmin[0]: asmin,afmin = afmin, asmin
bfmin = [0, 0]
bsmin = [0, 0]
for i in range(n):
b = glen(xb,yb,x[i],y[i])-glen(xb,yb,xt,yt)-glen(xt,yt,x[i],y[i])
if bsmin[0] > b:
bsmin[0] = b
bsmin[1] = i
if bsmin[0] < bfmin[0]: bsmin,bfmin = bfmin, bsmin
res = 0
b = bfmin[1]
a = afmin[1]
b1 = bsmin[1]
a1 = asmin[1]
res1 = min(glen(x[a], y[a], xa, ya) - glen(x[a],y[a],xt,yt),
glen(x[b], y[b], xb, yb) - glen(x[b],y[b],xt,yt))
if b != a:
res += glen(x[a], y[a], xa, ya) - glen(x[a],y[a],xt,yt)
res += glen(x[b], y[b], xb, yb) - glen(x[b],y[b],xt,yt)
else:
res += min(glen(x[a], y[a], xa, ya) - glen(x[a],y[a],xt,yt) + glen(x[b1], y[b1], xb, yb) - glen(x[b1],y[b1],xt,yt),
glen(x[a1], y[a1], xa, ya) - glen(x[a],y[a],xt,yt) + glen(x[b], y[b], xb, yb) - glen(x[b1],y[b1],xt,yt))
for i in range(n):
res += 2*glen(xt,yt,x[i],y[i])
res1 += 2*glen(xt,yt,x[i],y[i])
print(min(res, res1))
``` | instruction | 0 | 12,959 | 3 | 25,918 |
No | output | 1 | 12,959 | 3 | 25,919 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 ≤ ax, ay, bx, by, tx, ty ≤ 109) — initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 ≤ n ≤ 100 000) — the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 ≤ xi, yi ≤ 109) — position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number — the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long.
Submitted Solution:
```
ax,ay,bx,by,rx,ry=map(int,input().split())
a,b=[],[]
from math import sqrt
n=int(input())
#print(n)
for i in range(n):
m,rn=map(int,input().split())
a.append(m)
b.append(rn)
#print(a,b)
ra,rb=[],[]
ans=0
for i in range(n):
#print('i m i')
da=sqrt((ax-a[i])**2+(ay-b[i])**2)
db=sqrt((bx-a[i])**2+(by-b[i])**2)
dr=sqrt((rx-a[i])**2+(ry-b[i])**2)
##print(da,db,dr)
ra.append(dr-da)
rb.append(dr-db)
ans+=(2*dr)
#print(ans)
l=range(n)
ran1=sorted(zip(ra,l))[::-1]
ran2=sorted(zip(rb,l))[::-1]
if(ran1[0][1]!=ran2[0][1]):
print(ans-(ran1[0][0]+ran2[0][0]))
elif(ran1[1][0]>=ran2[1][0]):
print(ans-(ran1[1][0]+ran2[0][0]))
else:
print(ans-(ran1[0][0]+ran2[1][0]))
``` | instruction | 0 | 12,960 | 3 | 25,920 |
No | output | 1 | 12,960 | 3 | 25,921 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 ≤ ax, ay, bx, by, tx, ty ≤ 109) — initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 ≤ n ≤ 100 000) — the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 ≤ xi, yi ≤ 109) — position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number — the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long.
Submitted Solution:
```
def distance(x, y, a, b):
return ((x - a) ** 2 + (y - b) ** 2) ** 0.5
ax, ay, bx, by, tx, ty = map(int, input().split())
n = int(input())
arr = []
for i in range(n):
x, y = map(int, input().split())
arr.append((x, y))
temp1 = [(distance(ax, ay, *arr[i]), distance(bx, by, *arr[i]), distance(tx, ty,
*arr[i]), -distance(ax, ay, *arr[i]) + distance(tx, ty, *arr[i]), -distance(bx,
by, *arr[i]) + distance(tx, ty, *arr[i])) for i in range(n)]
temp2 = temp1[:]
temp1.sort(key = lambda T : T[-2], reverse = True)
temp2.sort(key = lambda T : T[-1], reverse = True)
ans1, ans2 = 0, 0
ans1 += temp1[0][0] + temp1[0][2]
del temp1[0]
temp1.sort(key = lambda T : T[-1], reverse = True)
if temp1[0][1] < temp1[0][2]:
ans1 += temp1[0][1] + temp1[0][2]
else:
ans1 += 2 * temp1[0][2]
del temp1[0]
for i in range(len(temp1)):
ans1 += 2 * temp1[i][2]
ans2 += temp2[0][1] + temp2[0][2]
del temp2[0]
temp2.sort(key = lambda T : T[-2], reverse = True)
if temp2[0][0] < temp2[0][2]:
ans2 += temp2[0][0] + temp2[0][2]
else:
ans2 += 2 * temp2[0][2]
del temp2[0]
for i in range(len(temp2)):
ans2 += 2 * temp2[0][2]
print(min(ans1, ans2))
``` | instruction | 0 | 12,961 | 3 | 25,922 |
No | output | 1 | 12,961 | 3 | 25,923 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 ≤ ax, ay, bx, by, tx, ty ≤ 109) — initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 ≤ n ≤ 100 000) — the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 ≤ xi, yi ≤ 109) — position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number — the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long.
Submitted Solution:
```
import math
def dist(x, y):
a = x[0] - y[0]
b = x[1] - y[1]
return math.sqrt(a*a + b*b)
def solve(a, b, t, data):
summ = 0
dists = []
econ1 = []
max_econ1 = dist(data[0], t) - dist(a, data[0])
max_econ2 = dist(data[0], t) - dist(b, data[0])
argmax_econ1 = -1
argmax_econ2 = -1
econ2 = []
n = len(data)
if (n == 1):
min_adil = dist(a, data[0]) + dist(data[0], t)
min_bera = dist(b, data[0]) + dist(data[0], t)
return min(min_adil, min_bera)
else:
for i in range(len(data)):
c = data[i]
tmp = dist(c, t)
tmp2 = dist(a, c) + tmp
tmp3 = dist(b, c) + tmp
tmp *= 2
dists.append(tmp)
summ += tmp
tmp4 = tmp - tmp2
tmp5 = tmp - tmp3
econ1.append(tmp4)
econ2.append(tmp5)
if tmp4 > max_econ1:
max_econ1 = tmp4
argmax_econ1 = i
if tmp5 > max_econ2:
max_econ2 = tmp5
argmax_econ2 = i
if max_econ1 > 0:
if max_econ2 < 0:
summ -= max_econ1
else:
if argmax_econ1 != argmax_econ2:
summ = summ - max_econ1 - max_econ2
else:
if max_econ1 > max_econ2:
summ -= max_econ1
del econ2[argmax_econ1]
summ -= max(econ2)
else:
summ -= max_econ2
del econ1[argmax_econ1]
summ -= max(econ1)
else:
if max_econ2 > 0:
summ -= max_econ2
else:
summ -= max(max_econ2, max_econ1)
return summ
data1 = [int(x) for x in input().split()]
a = data1[0:2]
b = data1[2:4]
t = data1[4:]
n = int(input())
data = []
for i in range(n):
data.append([int(x) for x in input().split()])
print(solve(a, b, t, data))
``` | instruction | 0 | 12,962 | 3 | 25,924 |
No | output | 1 | 12,962 | 3 | 25,925 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two neighbours, Alan and Bob, live in the city, where there are three buildings only: a cinema, a shop and the house, where they live. The rest is a big asphalt square.
Once they went to the cinema, and the film impressed them so deeply, that when they left the cinema, they did not want to stop discussing it.
Bob wants to get home, but Alan has to go to the shop first, and only then go home. So, they agreed to cover some distance together discussing the film (their common path might pass through the shop, or they might walk circles around the cinema together), and then to part each other's company and go each his own way. After they part, they will start thinking about their daily pursuits; and even if they meet again, they won't be able to go on with the discussion. Thus, Bob's path will be a continuous curve, having the cinema and the house as its ends. Alan's path — a continuous curve, going through the shop, and having the cinema and the house as its ends.
The film ended late, that's why the whole distance covered by Alan should not differ from the shortest one by more than t1, and the distance covered by Bob should not differ from the shortest one by more than t2.
Find the maximum distance that Alan and Bob will cover together, discussing the film.
Input
The first line contains two integers: t1, t2 (0 ≤ t1, t2 ≤ 100). The second line contains the cinema's coordinates, the third one — the house's, and the last line — the shop's.
All the coordinates are given in meters, are integer, and do not exceed 100 in absolute magnitude. No two given places are in the same building.
Output
In the only line output one number — the maximum distance that Alan and Bob will cover together, discussing the film. Output the answer accurate to not less than 4 decimal places.
Examples
Input
0 2
0 0
4 0
-3 0
Output
1.0000000000
Input
0 0
0 0
2 0
1 0
Output
2.0000000000
Submitted Solution:
```
#!/usr/bin/env python
'''
' Author: Cheng-Shih Wong
' Email: mob5566@gmail.com
' Date: 2017-08-26
'''
def main():
import math
from itertools import combinations, chain
EPS = 1e-8
def fcomp(x):
return -1 if x < -EPS else int(x>EPS)
def dist(A, B):
return math.sqrt((A[0]-B[0])**2+(A[1]-B[1])**2)
def root(a, b, c):
if fcomp(b**2-4*a*c) >= 0:
sq = math.sqrt(b**2-4*a*c) if b**2-4*a*c > 0 else 0
return ((-b+sq)/(2*a), (-b-sq)/(2*a))
return None
def circle_intersect(A, r1, B, r2):
print('CI', dist(A, B), r1+r2)
if fcomp(dist(A, B)-(r1+r2)) <= 0:
if fcomp(dist(A, B)+r2-r1)<=0 or fcomp(dist(A, B)+r1-r2)<=0:
return True, None
else:
x1, y1 = A
x2, y2 = B
if fcomp(y1-y2) == 0:
x = -(x1**2-x2**2-r1**2+r2**2)/(2*x2-2*x1)
a = 1
b = -2*y1
c = x**2+x1**2-2*x1*x+y1**2-r1**2
y = root(a, b, c)
if y is None:
return False, None
intsec = ((x, y[0]), (x, y[1]))
else:
m = (x1-x2)/(y2-y1)
k = (r1**2-r2**2+x2**2-x1**2+y2**2-y1**2)/(2*(y2-y1))
a = 1+m**2
b = 2*(m*k-m*y2-x2)
c = x2**2+y2**2+k**2-2*k*y2-r2**2
x = root(a, b, c)
if x is None:
return False, None
intsec = ((x[0], m*x[0]+k), (x[1], m*x[1]+k))
return True, intsec
else:
return False, None
def check(CA, CB, CC):
intsec = []
if CA[1]<=0 or CB[1]<=0 or CC[1]<=0:
return False
for pair in combinations([CA, CB, CC], 2):
ret, ip = circle_intersect(*pair[0], *pair[1])
if not ret:
return False
intsec.append(ip)
if None not in intsec:
for p in chain.from_iterable(intsec):
if fcomp(dist(p, CA[0])-CA[1])<=0 and \
fcomp(dist(p, CB[0])-CB[1])<=0 and \
fcomp(dist(p, CC[0])-CC[1])<=0:
return True
return False
return True
def bisec(l, r):
nonlocal A, B, C, T1, T2
while fcomp(r-l) > 0:
mid = (l+r)/2
if check((A, mid), (B, T2-mid), (C, T1-dist(B, C)-mid)):
l = mid
else:
r = mid
return l
# input
t1, t2 = map(float, input().split())
A, B, C = [tuple(map(float, input().split())) for _ in range(3)]
# init
T1 = dist(A, C)+dist(C, B)+t1
T2 = dist(A, B)+t2
if T2 >= dist(A, C)+dist(C, B):
print('{0:6f}'.format(min(T1, T2)))
else:
print('{0:6f}'.format(bisec(0, min(T1, T2))))
if __name__ == '__main__':
import sys, os
from time import time
if len(sys.argv)>1 and os.path.exists(sys.argv[1]):
sys.stdin = open(sys.argv[1], 'rb')
st = time()
main()
print('----- Run {:.6f} seconds. -----'.format(time()-st), file=sys.stderr)
``` | instruction | 0 | 13,055 | 3 | 26,110 |
No | output | 1 | 13,055 | 3 | 26,111 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two neighbours, Alan and Bob, live in the city, where there are three buildings only: a cinema, a shop and the house, where they live. The rest is a big asphalt square.
Once they went to the cinema, and the film impressed them so deeply, that when they left the cinema, they did not want to stop discussing it.
Bob wants to get home, but Alan has to go to the shop first, and only then go home. So, they agreed to cover some distance together discussing the film (their common path might pass through the shop, or they might walk circles around the cinema together), and then to part each other's company and go each his own way. After they part, they will start thinking about their daily pursuits; and even if they meet again, they won't be able to go on with the discussion. Thus, Bob's path will be a continuous curve, having the cinema and the house as its ends. Alan's path — a continuous curve, going through the shop, and having the cinema and the house as its ends.
The film ended late, that's why the whole distance covered by Alan should not differ from the shortest one by more than t1, and the distance covered by Bob should not differ from the shortest one by more than t2.
Find the maximum distance that Alan and Bob will cover together, discussing the film.
Input
The first line contains two integers: t1, t2 (0 ≤ t1, t2 ≤ 100). The second line contains the cinema's coordinates, the third one — the house's, and the last line — the shop's.
All the coordinates are given in meters, are integer, and do not exceed 100 in absolute magnitude. No two given places are in the same building.
Output
In the only line output one number — the maximum distance that Alan and Bob will cover together, discussing the film. Output the answer accurate to not less than 4 decimal places.
Examples
Input
0 2
0 0
4 0
-3 0
Output
1.0000000000
Input
0 0
0 0
2 0
1 0
Output
2.0000000000
Submitted Solution:
```
__author__ = 'Darren'
def solve():
t1, t2 = map(int, input().split())
cinema = complex(*map(int, input().split()))
house = complex(*map(int, input().split()))
shop = complex(*map(int, input().split()))
cinema_to_house = abs(house - cinema)
cinema_to_shop = abs(shop - cinema)
shop_to_house = abs(house - shop)
alice_max = cinema_to_shop + shop_to_house + t1
bob_max = cinema_to_house + t2
def check(d):
c1, c2, c3 = (cinema, d), (house, bob_max-d), (shop, alice_max-d-shop_to_house)
for i in range(3):
status = intersect(c1, c2)
if status == 0:
return False
if status == 1:
return intersect(c1 if c1[1] < c2[1] else c2, c3)
for intersection in status:
if abs(intersection - c3[0]) + 1e-8 <= c3[1]:
return True
c1, c2, c3 = c2, c3, c1
if cinema_to_shop + shop_to_house <= bob_max:
print(min(alice_max, bob_max))
else:
lower, upper = 0, min(alice_max, bob_max)
while upper - lower > 1e-8:
mid = (lower + upper) * 0.5
if check(mid):
lower = mid
else:
upper = mid
print(lower)
# See http://mathforum.org/library/drmath/view/51836.html
def intersect(a, b):
dif = b[0] - a[0]
dist = abs(dif)
if dist > a[1] + b[1] + 1e-8:
return 0
if dist <= abs(a[1] - b[1]) - 1e-8:
return 1
k = (dist * dist + a[1] * a[1] - b[1] * b[1]) / (2 * dist)
u = dif * k / dist
v = dif * 1j / dist * (a[1] * a[1] - k * k) ** 0.5
return [a[0]+u+v, a[0]+u-v]
if __name__ == '__main__':
solve()
``` | instruction | 0 | 13,056 | 3 | 26,112 |
No | output | 1 | 13,056 | 3 | 26,113 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two neighbours, Alan and Bob, live in the city, where there are three buildings only: a cinema, a shop and the house, where they live. The rest is a big asphalt square.
Once they went to the cinema, and the film impressed them so deeply, that when they left the cinema, they did not want to stop discussing it.
Bob wants to get home, but Alan has to go to the shop first, and only then go home. So, they agreed to cover some distance together discussing the film (their common path might pass through the shop, or they might walk circles around the cinema together), and then to part each other's company and go each his own way. After they part, they will start thinking about their daily pursuits; and even if they meet again, they won't be able to go on with the discussion. Thus, Bob's path will be a continuous curve, having the cinema and the house as its ends. Alan's path — a continuous curve, going through the shop, and having the cinema and the house as its ends.
The film ended late, that's why the whole distance covered by Alan should not differ from the shortest one by more than t1, and the distance covered by Bob should not differ from the shortest one by more than t2.
Find the maximum distance that Alan and Bob will cover together, discussing the film.
Input
The first line contains two integers: t1, t2 (0 ≤ t1, t2 ≤ 100). The second line contains the cinema's coordinates, the third one — the house's, and the last line — the shop's.
All the coordinates are given in meters, are integer, and do not exceed 100 in absolute magnitude. No two given places are in the same building.
Output
In the only line output one number — the maximum distance that Alan and Bob will cover together, discussing the film. Output the answer accurate to not less than 4 decimal places.
Examples
Input
0 2
0 0
4 0
-3 0
Output
1.0000000000
Input
0 0
0 0
2 0
1 0
Output
2.0000000000
Submitted Solution:
```
#!/usr/bin/env python
'''
' Author: Cheng-Shih Wong
' Email: mob5566@gmail.com
' Date: 2017-08-26
'''
def main():
import math
from itertools import combinations, chain
EPS = 1e-8
def fcomp(x):
return -1 if x < -EPS else int(x>EPS)
def dist(A, B):
return math.sqrt((A[0]-B[0])**2+(A[1]-B[1])**2)
def root(a, b, c):
if fcomp(b**2-4*a*c) >= 0:
sq = math.sqrt(b**2-4*a*c) if b**2-4*a*c > 0 else 0
return ((-b+sq)/(2*a), (-b-sq)/(2*a))
return None
def circle_intersect(A, r1, B, r2):
if fcomp(dist(A, B)-(r1+r2)) <= 0:
if fcomp(dist(A, B)+r2-r1)<=0 or fcomp(dist(A, B)+r1-r2)<=0:
return True, None
else:
x1, y1 = A
x2, y2 = B
if fcomp(y1-y2) == 0:
x = -(x1**2-x2**2-r1**2+r2**2)/(2*x2-2*x1)
a = 1
b = -2*y1
c = x**2+x1**2-2*x1*x+y1**2-r1**2
y = root(a, b, c)
if y is None:
return False, None
intsec = ((x, y[0]), (x, y[1]))
else:
m = (x1-x2)/(y2-y1)
k = (r1**2-r2**2+x2**2-x1**2+y2**2-y1**2)/(2*(y2-y1))
a = 1+m**2
b = 2*(m*k-m*y2-x2)
c = x2**2+y2**2+k**2-2*k*y2-r2**2
x = root(a, b, c)
if x is None:
return False, None
intsec = ((x[0], m*x[0]+k), (x[1], m*x[1]+k))
return True, intsec
else:
return False, None
def check(CA, CB, CC):
intsec = []
for pair in combinations([CA, CB, CC], 2):
ret, ip = circle_intersect(*pair[0], *pair[1])
if not ret:
return False
intsec.append(ip)
if None not in intsec:
for p in chain.from_iterable(intsec):
if fcomp(dist(p, CA[0])-CA[1])<=0 and \
fcomp(dist(p, CB[0])-CB[1])<=0 and \
fcomp(dist(p, CC[0])-CC[1])<=0:
return True
return False
return True
def bisec(l, r):
nonlocal A, B, C, T1, T2
while fcomp(r-l) > 0:
mid = (l+r)/2
if check((A, mid), (B, T2-mid), (C, T1-dist(B, C)-mid)):
l = mid
else:
r = mid
return l
# input
t1, t2 = map(float, input().split())
A, B, C = [tuple(map(float, input().split())) for _ in range(3)]
# init
T1 = dist(A, C)+dist(C, B)+t1
T2 = dist(A, B)+t2
if T2 >= dist(A, C)+dist(C, B):
print('{0:6f}'.format(min(T1, T2)))
else:
print('{0:6f}'.format(bisec(0, min(T1, T2))))
if __name__ == '__main__':
import sys, os
from time import time
if len(sys.argv)>1 and os.path.exists(sys.argv[1]):
sys.stdin = open(sys.argv[1], 'rb')
st = time()
main()
print('----- Run {:.6f} seconds. -----'.format(time()-st), file=sys.stderr)
``` | instruction | 0 | 13,057 | 3 | 26,114 |
No | output | 1 | 13,057 | 3 | 26,115 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tube which is reflective inside represented as two non-coinciding, but parallel to Ox lines. Each line has some special integer points — positions of sensors on sides of the tube.
You are going to emit a laser ray in the tube. To do so, you have to choose two integer points A and B on the first and the second line respectively (coordinates can be negative): the point A is responsible for the position of the laser, and the point B — for the direction of the laser ray. The laser ray is a ray starting at A and directed at B which will reflect from the sides of the tube (it doesn't matter if there are any sensors at a reflection point or not). A sensor will only register the ray if the ray hits exactly at the position of the sensor.
<image> Examples of laser rays. Note that image contains two examples. The 3 sensors (denoted by black bold points on the tube sides) will register the blue ray but only 2 will register the red.
Calculate the maximum number of sensors which can register your ray if you choose points A and B on the first and the second lines respectively.
Input
The first line contains two integers n and y_1 (1 ≤ n ≤ 10^5, 0 ≤ y_1 ≤ 10^9) — number of sensors on the first line and its y coordinate.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9) — x coordinates of the sensors on the first line in the ascending order.
The third line contains two integers m and y_2 (1 ≤ m ≤ 10^5, y_1 < y_2 ≤ 10^9) — number of sensors on the second line and its y coordinate.
The fourth line contains m integers b_1, b_2, …, b_m (0 ≤ b_i ≤ 10^9) — x coordinates of the sensors on the second line in the ascending order.
Output
Print the only integer — the maximum number of sensors which can register the ray.
Example
Input
3 1
1 5 6
1 3
3
Output
3
Note
One of the solutions illustrated on the image by pair A_2 and B_2. | instruction | 0 | 13,323 | 3 | 26,646 |
Tags: data structures, divide and conquer, dp, math
Correct Solution:
```
n, y1 = map(int, input().split())
a = list(map(int, input().split()))
m, y2 = map(int, input().split())
b = list(map(int, input().split()))
a_st, b_st = dict(), dict()
osn = 2 ** 30
k_a, k_b = set(), set()
for el in a:
try:
a_st[el % osn] += 1
except KeyError:
a_st[el % osn] = 1
finally:
k_a.add(el % osn)
for el in b:
try:
b_st[el % osn] += 1
except KeyError:
b_st[el % osn] = 1
finally:
k_b.add(el % osn)
ans = 2
for i in range(1, 31)[::-1]:
temp = 0
for el in k_a:
try:
temp = max(temp, a_st[el] + b_st[(el + osn // 2) % osn])
except KeyError:
temp = max(temp, a_st[el])
for el in k_b:
try:
temp = max(temp, b_st[el] + a_st[(el + osn // 2) % osn])
except KeyError:
temp = max(temp, b_st[el])
ans = max(ans, temp)
osn //= 2
k_ = set()
k_add = set()
for el in k_a:
if el >= osn:
try:
a_st[el - osn] += a_st[el]
except KeyError:
a_st[el - osn] = a_st[el]
finally:
del a_st[el]
k_add.add(el - osn)
k_.add(el)
for el in k_:
k_a.remove(el)
for el in k_add:
k_a.add(el)
k_ = set()
k_add = set()
for el in k_b:
if el >= osn:
try:
b_st[el - osn] += b_st[el]
except KeyError:
b_st[el - osn] = b_st[el]
finally:
del b_st[el]
k_add.add(el - osn)
k_.add(el)
for el in k_:
k_b.remove(el)
for el in k_add:
k_b.add(el)
print(ans)
``` | output | 1 | 13,323 | 3 | 26,647 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tube which is reflective inside represented as two non-coinciding, but parallel to Ox lines. Each line has some special integer points — positions of sensors on sides of the tube.
You are going to emit a laser ray in the tube. To do so, you have to choose two integer points A and B on the first and the second line respectively (coordinates can be negative): the point A is responsible for the position of the laser, and the point B — for the direction of the laser ray. The laser ray is a ray starting at A and directed at B which will reflect from the sides of the tube (it doesn't matter if there are any sensors at a reflection point or not). A sensor will only register the ray if the ray hits exactly at the position of the sensor.
<image> Examples of laser rays. Note that image contains two examples. The 3 sensors (denoted by black bold points on the tube sides) will register the blue ray but only 2 will register the red.
Calculate the maximum number of sensors which can register your ray if you choose points A and B on the first and the second lines respectively.
Input
The first line contains two integers n and y_1 (1 ≤ n ≤ 10^5, 0 ≤ y_1 ≤ 10^9) — number of sensors on the first line and its y coordinate.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9) — x coordinates of the sensors on the first line in the ascending order.
The third line contains two integers m and y_2 (1 ≤ m ≤ 10^5, y_1 < y_2 ≤ 10^9) — number of sensors on the second line and its y coordinate.
The fourth line contains m integers b_1, b_2, …, b_m (0 ≤ b_i ≤ 10^9) — x coordinates of the sensors on the second line in the ascending order.
Output
Print the only integer — the maximum number of sensors which can register the ray.
Example
Input
3 1
1 5 6
1 3
3
Output
3
Note
One of the solutions illustrated on the image by pair A_2 and B_2. | instruction | 0 | 13,324 | 3 | 26,648 |
Tags: data structures, divide and conquer, dp, math
Correct Solution:
```
#coding:utf-8
n, _ = map (int, input().strip ().split ())
a = list (map (int, input().strip ().split ()))
m, _ = map (int, input().strip ().split ())
b = list (map (int, input().strip ().split ()))
def solve (T):
global a, b
d = dict()
for i in b:
pos = i%T
if pos in d:
d[pos] += 1
else:
d[pos] = 1
for i in a:
pos = (i+T/2)%T
if pos in d:
d[pos] += 1
else:
d[pos] = 1
return max (d.values())
T = 2
ans = 0
while True:
ans = max (ans, solve (T))
T *= 2
if T > 1e9:
break
if len (set (a) and set (b)) > 0:
ans = max (ans, 2)
print (ans)
``` | output | 1 | 13,324 | 3 | 26,649 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tube which is reflective inside represented as two non-coinciding, but parallel to Ox lines. Each line has some special integer points — positions of sensors on sides of the tube.
You are going to emit a laser ray in the tube. To do so, you have to choose two integer points A and B on the first and the second line respectively (coordinates can be negative): the point A is responsible for the position of the laser, and the point B — for the direction of the laser ray. The laser ray is a ray starting at A and directed at B which will reflect from the sides of the tube (it doesn't matter if there are any sensors at a reflection point or not). A sensor will only register the ray if the ray hits exactly at the position of the sensor.
<image> Examples of laser rays. Note that image contains two examples. The 3 sensors (denoted by black bold points on the tube sides) will register the blue ray but only 2 will register the red.
Calculate the maximum number of sensors which can register your ray if you choose points A and B on the first and the second lines respectively.
Input
The first line contains two integers n and y_1 (1 ≤ n ≤ 10^5, 0 ≤ y_1 ≤ 10^9) — number of sensors on the first line and its y coordinate.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9) — x coordinates of the sensors on the first line in the ascending order.
The third line contains two integers m and y_2 (1 ≤ m ≤ 10^5, y_1 < y_2 ≤ 10^9) — number of sensors on the second line and its y coordinate.
The fourth line contains m integers b_1, b_2, …, b_m (0 ≤ b_i ≤ 10^9) — x coordinates of the sensors on the second line in the ascending order.
Output
Print the only integer — the maximum number of sensors which can register the ray.
Example
Input
3 1
1 5 6
1 3
3
Output
3
Note
One of the solutions illustrated on the image by pair A_2 and B_2. | instruction | 0 | 13,325 | 3 | 26,650 |
Tags: data structures, divide and conquer, dp, math
Correct Solution:
```
n, y1 = map(int, input().split())
a = list(map(int, input().split()))
m, y2 = map(int, input().split())
b = list(map(int, input().split()))
a_st, b_st = dict(), dict()
osn = 2 ** 32
k_a, k_b = set(), set()
for el in a:
try:
a_st[el % osn] += 1
except KeyError:
a_st[el % osn] = 1
finally:
k_a.add(el % osn)
for el in b:
try:
b_st[el % osn] += 1
except KeyError:
b_st[el % osn] = 1
finally:
k_b.add(el % osn)
ans = 2
for i in range(1, 33)[::-1]:
temp = 0
for el in k_a:
try:
temp = max(temp, a_st[el] + b_st[(el + osn // 2) % osn])
except KeyError:
temp = max(temp, a_st[el])
for el in k_b:
try:
temp = max(temp, b_st[el] + a_st[(el + osn // 2) % osn])
except KeyError:
temp = max(temp, b_st[el])
ans = max(ans, temp)
osn //= 2
k_ = set()
k_add = set()
for el in k_a:
if el >= osn:
try:
a_st[el - osn] += a_st[el]
except KeyError:
a_st[el - osn] = a_st[el]
finally:
del a_st[el]
k_add.add(el - osn)
k_.add(el)
for el in k_:
k_a.remove(el)
for el in k_add:
k_a.add(el)
k_ = set()
k_add = set()
for el in k_b:
if el >= osn:
try:
b_st[el - osn] += b_st[el]
except KeyError:
b_st[el - osn] = b_st[el]
finally:
del b_st[el]
k_add.add(el - osn)
k_.add(el)
for el in k_:
k_b.remove(el)
for el in k_add:
k_b.add(el)
print(ans)
``` | output | 1 | 13,325 | 3 | 26,651 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tube which is reflective inside represented as two non-coinciding, but parallel to Ox lines. Each line has some special integer points — positions of sensors on sides of the tube.
You are going to emit a laser ray in the tube. To do so, you have to choose two integer points A and B on the first and the second line respectively (coordinates can be negative): the point A is responsible for the position of the laser, and the point B — for the direction of the laser ray. The laser ray is a ray starting at A and directed at B which will reflect from the sides of the tube (it doesn't matter if there are any sensors at a reflection point or not). A sensor will only register the ray if the ray hits exactly at the position of the sensor.
<image> Examples of laser rays. Note that image contains two examples. The 3 sensors (denoted by black bold points on the tube sides) will register the blue ray but only 2 will register the red.
Calculate the maximum number of sensors which can register your ray if you choose points A and B on the first and the second lines respectively.
Input
The first line contains two integers n and y_1 (1 ≤ n ≤ 10^5, 0 ≤ y_1 ≤ 10^9) — number of sensors on the first line and its y coordinate.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9) — x coordinates of the sensors on the first line in the ascending order.
The third line contains two integers m and y_2 (1 ≤ m ≤ 10^5, y_1 < y_2 ≤ 10^9) — number of sensors on the second line and its y coordinate.
The fourth line contains m integers b_1, b_2, …, b_m (0 ≤ b_i ≤ 10^9) — x coordinates of the sensors on the second line in the ascending order.
Output
Print the only integer — the maximum number of sensors which can register the ray.
Example
Input
3 1
1 5 6
1 3
3
Output
3
Note
One of the solutions illustrated on the image by pair A_2 and B_2. | instruction | 0 | 13,326 | 3 | 26,652 |
Tags: data structures, divide and conquer, dp, math
Correct Solution:
```
n, y1 = map(int, input().split())
a = list(map(int, input().split()))
m, y2 = map(int, input().split())
b = list(map(int, input().split()))
ans = 2
for i in range(30):
step = (2 << i)
half = (step >> 1)
counts = dict()
for x in a:
rem = x % step
count = counts.get(rem, 0)
counts[rem] = count + 1
for x in b:
rem = (x + half) % step
count = counts.get(rem, 0)
counts[rem] = count + 1
res = max(counts.values())
ans = max(ans, res)
print(ans)
``` | output | 1 | 13,326 | 3 | 26,653 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tube which is reflective inside represented as two non-coinciding, but parallel to Ox lines. Each line has some special integer points — positions of sensors on sides of the tube.
You are going to emit a laser ray in the tube. To do so, you have to choose two integer points A and B on the first and the second line respectively (coordinates can be negative): the point A is responsible for the position of the laser, and the point B — for the direction of the laser ray. The laser ray is a ray starting at A and directed at B which will reflect from the sides of the tube (it doesn't matter if there are any sensors at a reflection point or not). A sensor will only register the ray if the ray hits exactly at the position of the sensor.
<image> Examples of laser rays. Note that image contains two examples. The 3 sensors (denoted by black bold points on the tube sides) will register the blue ray but only 2 will register the red.
Calculate the maximum number of sensors which can register your ray if you choose points A and B on the first and the second lines respectively.
Input
The first line contains two integers n and y_1 (1 ≤ n ≤ 10^5, 0 ≤ y_1 ≤ 10^9) — number of sensors on the first line and its y coordinate.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9) — x coordinates of the sensors on the first line in the ascending order.
The third line contains two integers m and y_2 (1 ≤ m ≤ 10^5, y_1 < y_2 ≤ 10^9) — number of sensors on the second line and its y coordinate.
The fourth line contains m integers b_1, b_2, …, b_m (0 ≤ b_i ≤ 10^9) — x coordinates of the sensors on the second line in the ascending order.
Output
Print the only integer — the maximum number of sensors which can register the ray.
Example
Input
3 1
1 5 6
1 3
3
Output
3
Note
One of the solutions illustrated on the image by pair A_2 and B_2. | instruction | 0 | 13,327 | 3 | 26,654 |
Tags: data structures, divide and conquer, dp, math
Correct Solution:
```
n, y1 = map(int, input().split())
a = list(map(int, input().split()))
m, y2 = map(int, input().split())
b = list(map(int, input().split()))
a_st, b_st = dict(), dict()
osn = 2 ** 29
k_a, k_b = set(), set()
for el in a:
try:
a_st[el % osn] += 1
except KeyError:
a_st[el % osn] = 1
finally:
k_a.add(el % osn)
for el in b:
try:
b_st[el % osn] += 1
except KeyError:
b_st[el % osn] = 1
finally:
k_b.add(el % osn)
ans = 2
for i in range(1, 30)[::-1]:
temp = 0
for el in k_a:
try:
temp = max(temp, a_st[el] + b_st[(el + osn // 2) % osn])
except KeyError:
temp = max(temp, a_st[el])
for el in k_b:
try:
temp = max(temp, b_st[el] + a_st[(el + osn // 2) % osn])
except KeyError:
temp = max(temp, b_st[el])
ans = max(ans, temp)
osn //= 2
k_ = set()
k_add = set()
for el in k_a:
if el >= osn:
try:
a_st[el - osn] += a_st[el]
except KeyError:
a_st[el - osn] = a_st[el]
finally:
del a_st[el]
k_add.add(el - osn)
k_.add(el)
for el in k_:
k_a.remove(el)
for el in k_add:
k_a.add(el)
k_ = set()
k_add = set()
for el in k_b:
if el >= osn:
try:
b_st[el - osn] += b_st[el]
except KeyError:
b_st[el - osn] = b_st[el]
finally:
del b_st[el]
k_add.add(el - osn)
k_.add(el)
for el in k_:
k_b.remove(el)
for el in k_add:
k_b.add(el)
print(ans)
``` | output | 1 | 13,327 | 3 | 26,655 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tube which is reflective inside represented as two non-coinciding, but parallel to Ox lines. Each line has some special integer points — positions of sensors on sides of the tube.
You are going to emit a laser ray in the tube. To do so, you have to choose two integer points A and B on the first and the second line respectively (coordinates can be negative): the point A is responsible for the position of the laser, and the point B — for the direction of the laser ray. The laser ray is a ray starting at A and directed at B which will reflect from the sides of the tube (it doesn't matter if there are any sensors at a reflection point or not). A sensor will only register the ray if the ray hits exactly at the position of the sensor.
<image> Examples of laser rays. Note that image contains two examples. The 3 sensors (denoted by black bold points on the tube sides) will register the blue ray but only 2 will register the red.
Calculate the maximum number of sensors which can register your ray if you choose points A and B on the first and the second lines respectively.
Input
The first line contains two integers n and y_1 (1 ≤ n ≤ 10^5, 0 ≤ y_1 ≤ 10^9) — number of sensors on the first line and its y coordinate.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9) — x coordinates of the sensors on the first line in the ascending order.
The third line contains two integers m and y_2 (1 ≤ m ≤ 10^5, y_1 < y_2 ≤ 10^9) — number of sensors on the second line and its y coordinate.
The fourth line contains m integers b_1, b_2, …, b_m (0 ≤ b_i ≤ 10^9) — x coordinates of the sensors on the second line in the ascending order.
Output
Print the only integer — the maximum number of sensors which can register the ray.
Example
Input
3 1
1 5 6
1 3
3
Output
3
Note
One of the solutions illustrated on the image by pair A_2 and B_2. | instruction | 0 | 13,328 | 3 | 26,656 |
Tags: data structures, divide and conquer, dp, math
Correct Solution:
```
n,w56=map(int,input().split())
if(n==1):
x=[int(input())]
else:
x=[int(i) for i in input().split()]
k,w90=map(int,input().split())
if(k==1):
y=[int(input())]
else:
y=[int(i) for i in input().split()]
t=0
import collections
for i in range(1,35):
m=collections.Counter()
for j in range(n):
m[((x[j]-(2**(i-1)))%(2**i))]+=1
for j in range(k):
m[(y[j])%(2**i)]+=1
t=max(t,max([m[o] for o in m.keys()]))
if(t>=2):
print(t)
else:
p=0
for i in range(len(x)):
for j in range(len(y)):
if(x[i]==y[j]):
print(2)
p=1
break
if(p==1):
break
if(p==0):
print(1)
``` | output | 1 | 13,328 | 3 | 26,657 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tube which is reflective inside represented as two non-coinciding, but parallel to Ox lines. Each line has some special integer points — positions of sensors on sides of the tube.
You are going to emit a laser ray in the tube. To do so, you have to choose two integer points A and B on the first and the second line respectively (coordinates can be negative): the point A is responsible for the position of the laser, and the point B — for the direction of the laser ray. The laser ray is a ray starting at A and directed at B which will reflect from the sides of the tube (it doesn't matter if there are any sensors at a reflection point or not). A sensor will only register the ray if the ray hits exactly at the position of the sensor.
<image> Examples of laser rays. Note that image contains two examples. The 3 sensors (denoted by black bold points on the tube sides) will register the blue ray but only 2 will register the red.
Calculate the maximum number of sensors which can register your ray if you choose points A and B on the first and the second lines respectively.
Input
The first line contains two integers n and y_1 (1 ≤ n ≤ 10^5, 0 ≤ y_1 ≤ 10^9) — number of sensors on the first line and its y coordinate.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9) — x coordinates of the sensors on the first line in the ascending order.
The third line contains two integers m and y_2 (1 ≤ m ≤ 10^5, y_1 < y_2 ≤ 10^9) — number of sensors on the second line and its y coordinate.
The fourth line contains m integers b_1, b_2, …, b_m (0 ≤ b_i ≤ 10^9) — x coordinates of the sensors on the second line in the ascending order.
Output
Print the only integer — the maximum number of sensors which can register the ray.
Example
Input
3 1
1 5 6
1 3
3
Output
3
Note
One of the solutions illustrated on the image by pair A_2 and B_2. | instruction | 0 | 13,329 | 3 | 26,658 |
Tags: data structures, divide and conquer, dp, math
Correct Solution:
```
x,y = map(int,input().split())
a = list(map(int,input().split()))
o,p = map(int,input().split())
b = list(map(int,input().split()))
ans = 0
from collections import defaultdict
for i in range(34):
fac = 2**i
fac2 = fac*2
if i == 33:
fac = fac2
map = defaultdict(int)
for j in a:
map[j%fac2] += 1
for j in b:
map[(j+fac)%fac2] += 1
for v in map.values():
ans = max(ans,v)
print(ans)
``` | output | 1 | 13,329 | 3 | 26,659 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tube which is reflective inside represented as two non-coinciding, but parallel to Ox lines. Each line has some special integer points — positions of sensors on sides of the tube.
You are going to emit a laser ray in the tube. To do so, you have to choose two integer points A and B on the first and the second line respectively (coordinates can be negative): the point A is responsible for the position of the laser, and the point B — for the direction of the laser ray. The laser ray is a ray starting at A and directed at B which will reflect from the sides of the tube (it doesn't matter if there are any sensors at a reflection point or not). A sensor will only register the ray if the ray hits exactly at the position of the sensor.
<image> Examples of laser rays. Note that image contains two examples. The 3 sensors (denoted by black bold points on the tube sides) will register the blue ray but only 2 will register the red.
Calculate the maximum number of sensors which can register your ray if you choose points A and B on the first and the second lines respectively.
Input
The first line contains two integers n and y_1 (1 ≤ n ≤ 10^5, 0 ≤ y_1 ≤ 10^9) — number of sensors on the first line and its y coordinate.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9) — x coordinates of the sensors on the first line in the ascending order.
The third line contains two integers m and y_2 (1 ≤ m ≤ 10^5, y_1 < y_2 ≤ 10^9) — number of sensors on the second line and its y coordinate.
The fourth line contains m integers b_1, b_2, …, b_m (0 ≤ b_i ≤ 10^9) — x coordinates of the sensors on the second line in the ascending order.
Output
Print the only integer — the maximum number of sensors which can register the ray.
Example
Input
3 1
1 5 6
1 3
3
Output
3
Note
One of the solutions illustrated on the image by pair A_2 and B_2. | instruction | 0 | 13,330 | 3 | 26,660 |
Tags: data structures, divide and conquer, dp, math
Correct Solution:
```
n, y1 = map(int, input().split())
a = list(map(int, input().split()))
m, y2 = map(int, input().split())
b = list(map(int, input().split()))
ans = 2
for i in range(31):
step = (2 << i)
half = (step >> 1)
counts = dict()
for x in a:
rem = x % step
count = counts.get(rem, 0)
counts[rem] = count + 1
for x in b:
rem = (x + half) % step
count = counts.get(rem, 0)
counts[rem] = count + 1
res = max(counts.values())
ans = max(ans, res)
print(ans)
``` | output | 1 | 13,330 | 3 | 26,661 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a tube which is reflective inside represented as two non-coinciding, but parallel to Ox lines. Each line has some special integer points — positions of sensors on sides of the tube.
You are going to emit a laser ray in the tube. To do so, you have to choose two integer points A and B on the first and the second line respectively (coordinates can be negative): the point A is responsible for the position of the laser, and the point B — for the direction of the laser ray. The laser ray is a ray starting at A and directed at B which will reflect from the sides of the tube (it doesn't matter if there are any sensors at a reflection point or not). A sensor will only register the ray if the ray hits exactly at the position of the sensor.
<image> Examples of laser rays. Note that image contains two examples. The 3 sensors (denoted by black bold points on the tube sides) will register the blue ray but only 2 will register the red.
Calculate the maximum number of sensors which can register your ray if you choose points A and B on the first and the second lines respectively.
Input
The first line contains two integers n and y_1 (1 ≤ n ≤ 10^5, 0 ≤ y_1 ≤ 10^9) — number of sensors on the first line and its y coordinate.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9) — x coordinates of the sensors on the first line in the ascending order.
The third line contains two integers m and y_2 (1 ≤ m ≤ 10^5, y_1 < y_2 ≤ 10^9) — number of sensors on the second line and its y coordinate.
The fourth line contains m integers b_1, b_2, …, b_m (0 ≤ b_i ≤ 10^9) — x coordinates of the sensors on the second line in the ascending order.
Output
Print the only integer — the maximum number of sensors which can register the ray.
Example
Input
3 1
1 5 6
1 3
3
Output
3
Note
One of the solutions illustrated on the image by pair A_2 and B_2.
Submitted Solution:
```
import math
nsensors1, ycoord1 = [int(x) for x in input().split()] # number of sensors in the first line, y coordinate of the line
sensors_x_coord1 = [int(x) for x in input().split()] # x coordinates of the sensors in the first line
nsensors2, ycoord2 = [int(x) for x in input().split()] # number of sensors in the second line, y coordinate of the line
sensors_x_coord2 = [int(x) for x in input().split()] # x coordinates of the sensors in the second line
# sensor coordinates
sensors1 = []
sensors2 = []
for i in range(nsensors1):
sensors1.append([sensors_x_coord1[i], ycoord1])
for i in range(nsensors2):
sensors2.append([sensors_x_coord2[i], ycoord2])
pointAx, pointAy = [-3, ycoord1]
pointBx, pointBy = [-1, ycoord2]
distanceAB = math.sqrt((pointAx - pointBx) ** 2 + (pointAy - pointBy) ** 2)
angle = math.atan((pointBy - pointAy) / (pointBx - pointAx))
reflection_distance = 2 * distanceAB * math.cos(angle)
sensor_count = 0
for sensor in sensors1:
result = round((sensor[0] - pointAx) / reflection_distance, 2)
if result.is_integer() and ((pointAx < pointBx and result > 0) or (pointAx > pointBx and result < 0)):
sensor_count += 1
for sensor in sensors2:
result = round((sensor[0] - pointBx) / reflection_distance, 2)
if result.is_integer() and ((pointAx < pointBx and result > 0) or (pointAx > pointBx and result < 0)):
sensor_count += 1
print(3)
``` | instruction | 0 | 13,331 | 3 | 26,662 |
No | output | 1 | 13,331 | 3 | 26,663 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a tube which is reflective inside represented as two non-coinciding, but parallel to Ox lines. Each line has some special integer points — positions of sensors on sides of the tube.
You are going to emit a laser ray in the tube. To do so, you have to choose two integer points A and B on the first and the second line respectively (coordinates can be negative): the point A is responsible for the position of the laser, and the point B — for the direction of the laser ray. The laser ray is a ray starting at A and directed at B which will reflect from the sides of the tube (it doesn't matter if there are any sensors at a reflection point or not). A sensor will only register the ray if the ray hits exactly at the position of the sensor.
<image> Examples of laser rays. Note that image contains two examples. The 3 sensors (denoted by black bold points on the tube sides) will register the blue ray but only 2 will register the red.
Calculate the maximum number of sensors which can register your ray if you choose points A and B on the first and the second lines respectively.
Input
The first line contains two integers n and y_1 (1 ≤ n ≤ 10^5, 0 ≤ y_1 ≤ 10^9) — number of sensors on the first line and its y coordinate.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9) — x coordinates of the sensors on the first line in the ascending order.
The third line contains two integers m and y_2 (1 ≤ m ≤ 10^5, y_1 < y_2 ≤ 10^9) — number of sensors on the second line and its y coordinate.
The fourth line contains m integers b_1, b_2, …, b_m (0 ≤ b_i ≤ 10^9) — x coordinates of the sensors on the second line in the ascending order.
Output
Print the only integer — the maximum number of sensors which can register the ray.
Example
Input
3 1
1 5 6
1 3
3
Output
3
Note
One of the solutions illustrated on the image by pair A_2 and B_2.
Submitted Solution:
```
n, y1 = map(int, input().split())
a = list(map(int, input().split()))
m, y2 = map(int, input().split())
b = list(map(int, input().split()))
ans = 0
for i in range(30):
step = (2 << i)
half = (step >> 1)
counts = dict()
for x in a:
rem = x % step
count = counts.get(rem, 0)
counts[rem] = count + 1
for x in b:
rem = (x + half) % step
count = counts.get(rem, 0)
counts[rem] = count + 1
res = max(counts.values())
ans = max(ans, res)
print(ans)
``` | instruction | 0 | 13,332 | 3 | 26,664 |
No | output | 1 | 13,332 | 3 | 26,665 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a tube which is reflective inside represented as two non-coinciding, but parallel to Ox lines. Each line has some special integer points — positions of sensors on sides of the tube.
You are going to emit a laser ray in the tube. To do so, you have to choose two integer points A and B on the first and the second line respectively (coordinates can be negative): the point A is responsible for the position of the laser, and the point B — for the direction of the laser ray. The laser ray is a ray starting at A and directed at B which will reflect from the sides of the tube (it doesn't matter if there are any sensors at a reflection point or not). A sensor will only register the ray if the ray hits exactly at the position of the sensor.
<image> Examples of laser rays. Note that image contains two examples. The 3 sensors (denoted by black bold points on the tube sides) will register the blue ray but only 2 will register the red.
Calculate the maximum number of sensors which can register your ray if you choose points A and B on the first and the second lines respectively.
Input
The first line contains two integers n and y_1 (1 ≤ n ≤ 10^5, 0 ≤ y_1 ≤ 10^9) — number of sensors on the first line and its y coordinate.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9) — x coordinates of the sensors on the first line in the ascending order.
The third line contains two integers m and y_2 (1 ≤ m ≤ 10^5, y_1 < y_2 ≤ 10^9) — number of sensors on the second line and its y coordinate.
The fourth line contains m integers b_1, b_2, …, b_m (0 ≤ b_i ≤ 10^9) — x coordinates of the sensors on the second line in the ascending order.
Output
Print the only integer — the maximum number of sensors which can register the ray.
Example
Input
3 1
1 5 6
1 3
3
Output
3
Note
One of the solutions illustrated on the image by pair A_2 and B_2.
Submitted Solution:
```
import math
# return the distance between two consecutive points
def get_distance(point_a, point_b):
return math.sqrt((point_a[0] - point_b[0]) ** 2 + (point_a[1] - point_b[1]) ** 2)
# return true if the distance between any two consecutive points is constant
def distance_const(sensor_list):
for sensor in range(len(sensor_list) - 2):
if get_distance(sensor[i], sensor[i + 1]) != get_distance(sensor[i + 1], sensor[i + 2]):
return False
return [True, get_distance(sensor_list[0], sensor_list[1])]
def get_slope(point_a, point_b):
return (point_b[1] - point_a[1]) / (point_b[0] - point_a[0])
nsensors1, ycoord1 = [int(x) for x in input().split()] # number of sensors in the first line, y coordinate of the line
sensors_x_coord1 = [int(x) for x in input().split()] # x coordinates of the sensors in the first line
nsensors2, ycoord2 = [int(x) for x in input().split()] # number of sensors in the second line, y coordinate of the line
sensors_x_coord2 = [int(x) for x in input().split()] # x coordinates of the sensors in the second line
# sensor coordinates
sensors1 = []
sensors2 = []
for i in range(nsensors1):
sensors1.append([sensors_x_coord1[i], ycoord1])
for i in range(nsensors2):
sensors2.append([sensors_x_coord2[i], ycoord2])
# distance from point n to point n + 1 on both horizontal lines
distance1 = []
distance2 = []
for i in range(len(sensors1) - 1):
distance1.append(get_distance(sensors1[i], sensors1[i + 1]))
# if there are no sensors on a given line and the distance between sensors on the opposite line is constant and greater
# than 1, the maximum number of hit sensors is equal to the number of sensors in the line that has them
if len(sensors_x_coord1) == 0 and distance_const(sensors2)[0] and distance_const(sensors2)[1] > 1:
print(len(sensors2))
exit(0)
elif len(sensors_x_coord2) == 0 and distance_const(sensors1)[0] and distance_const(sensors1)[1] > 1:
print(len(sensors1))
exit(0)
counter = []
i = 0
# First pass: check distance between consecutive sensors on line1
while i < len(sensors1) - 1:
# if len(sensors2) > 1 and len(sensors1) > 1:
# if get_distance(sensors1[i], sensors1[i + 1]) == 1 or get_distance(sensors2[i], [i + 1]) == 1:
# continue
middlePoint = [(sensors1[i][0] + sensors1[i + 1][0]) / 2, ycoord2]
distance_ab = get_distance(sensors1[i], middlePoint)
angle = math.atan(get_slope(sensors1[i], middlePoint))
distance_consecutive = 2 * distance_ab * math.cos(angle)
point_a = [sensors1[i][0] - distance_consecutive, ycoord1]
point_b = [middlePoint[0] - distance_consecutive, ycoord2]
moving_a = sensors1[0]
moving_b = sensors2[0]
j = 0
while moving_a[0] <= sensors1[-1][0] or moving_b[0] <= sensors2[-1][0]:
moving_a = [round(point_a[0] + abs(distance_consecutive * j)), point_a[1]]
moving_b = [round(point_b[0] + abs(distance_consecutive * j)), point_b[1]]
if moving_a in sensors1:
try:
counter[i] += 1
except IndexError:
counter.append(1)
if moving_b in sensors2:
try:
counter[i] += 1
except IndexError:
counter.append(1)
j += 1
i += 1
if i > 0:
i += 1
for j in range(len(sensors2) - 1):
# if len(sensors2) > 1 and len(sensors1) > 1 and (
# get_distance(sensors1[i], sensors1[i + 1]) == 1 or get_distance(sensors2[i], [i + 1]) == 1):
# continue
middlePoint = [(sensors2[j][0] + sensors2[j + 1][0]) / 2, ycoord1]
distance_ab = get_distance(sensors2[j], middlePoint)
angle = math.atan(get_slope(sensors2[j], middlePoint))
distance_consecutive = 2 * distance_ab * math.cos(angle)
point_a = [sensors2[j][0] - distance_consecutive, ycoord2]
point_b = [middlePoint[0] - distance_consecutive, ycoord1]
moving_a = sensors1[0]
moving_b = sensors2[0]
k = 0
while moving_a[0] <= sensors1[-1][0] or moving_b[0] <= sensors2[-1][0]:
moving_a = [round(point_a[0] + abs(distance_consecutive * k)), point_a[1]]
moving_b = [round(point_b[0] + abs(distance_consecutive * k)), point_b[1]]
if moving_a in sensors2:
try:
counter[i] += 1
except IndexError:
counter.append(1)
if moving_b in sensors1:
try:
counter[i] += 1
except IndexError:
counter.append(1)
k += 1
i += 1
if len(counter) == 0:
print(0)
exit(0)
_max = counter[0]
for i in range(len(counter)):
if counter[i] > _max:
_max = counter[i]
print(_max)
``` | instruction | 0 | 13,333 | 3 | 26,666 |
No | output | 1 | 13,333 | 3 | 26,667 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a tube which is reflective inside represented as two non-coinciding, but parallel to Ox lines. Each line has some special integer points — positions of sensors on sides of the tube.
You are going to emit a laser ray in the tube. To do so, you have to choose two integer points A and B on the first and the second line respectively (coordinates can be negative): the point A is responsible for the position of the laser, and the point B — for the direction of the laser ray. The laser ray is a ray starting at A and directed at B which will reflect from the sides of the tube (it doesn't matter if there are any sensors at a reflection point or not). A sensor will only register the ray if the ray hits exactly at the position of the sensor.
<image> Examples of laser rays. Note that image contains two examples. The 3 sensors (denoted by black bold points on the tube sides) will register the blue ray but only 2 will register the red.
Calculate the maximum number of sensors which can register your ray if you choose points A and B on the first and the second lines respectively.
Input
The first line contains two integers n and y_1 (1 ≤ n ≤ 10^5, 0 ≤ y_1 ≤ 10^9) — number of sensors on the first line and its y coordinate.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9) — x coordinates of the sensors on the first line in the ascending order.
The third line contains two integers m and y_2 (1 ≤ m ≤ 10^5, y_1 < y_2 ≤ 10^9) — number of sensors on the second line and its y coordinate.
The fourth line contains m integers b_1, b_2, …, b_m (0 ≤ b_i ≤ 10^9) — x coordinates of the sensors on the second line in the ascending order.
Output
Print the only integer — the maximum number of sensors which can register the ray.
Example
Input
3 1
1 5 6
1 3
3
Output
3
Note
One of the solutions illustrated on the image by pair A_2 and B_2.
Submitted Solution:
```
import math
# return the distance between two consecutive points
def get_distance(point_a, point_b):
return math.sqrt((point_a[0] - point_b[0]) ** 2 + (point_a[1] - point_b[1]) ** 2)
def get_slope(point_a, point_b):
return (point_b[1] - point_a[1]) / (point_b[0] - point_a[0])
def generate_coordinates(nsensors, sensor_x, sensor_y, sensor_list):
for i in range(nsensors):
sensor_list.append([sensor_x[i], sensor_y])
def compute_distances(sensors, distances):
for i in range(len(sensors) - 1):
distances.append(get_distance(sensors[i], sensors[i + 1]))
def on_line(sensor, ylower, yupper):
if sensor[1] == ylower:
return 0
elif sensor[1] == yupper:
return 1
# number of sensors in the lower line and y coordinate of the line
nsensors_lower, ycoord_lower = [int(x) for x in input().split()]
# x coordinates of the sensors in the lower line
sensors_x_coord_lower = [int(x) for x in input().split()]
# number of sensors in the upper line, y coordinate of the line
nsensors_upper, ycoord_upper = [int(x) for x in input().split()]
# x coordinates of the sensors in the upper line
sensors_x_coord_upper = [int(x) for x in input().split()]
# sensor coordinates on the upper and lower lines
sensors_upper = []
sensors_lower = []
# distance between two consecutive sensors on the upper and lower lines
distance_sensors_upper = []
distance_sensors_lower = []
# generate coordinates for the sensors in each line
generate_coordinates(nsensors_lower, sensors_x_coord_lower, ycoord_lower, sensors_lower)
generate_coordinates(nsensors_upper, sensors_x_coord_upper, ycoord_upper, sensors_upper)
sensors_sorted = sorted(sensors_upper + sensors_lower)
compute_distances(sensors_upper, distance_sensors_upper)
compute_distances(sensors_lower, distance_sensors_lower)
leftmost_sensor = list(sensors_sorted[0])
start_sensor = list(leftmost_sensor)
counter_lower = []
max_distance_lower = get_distance(sensors_lower[0], sensors_lower[-1])
max_distance_upper = get_distance(sensors_upper[0], sensors_upper[-1])
# if the leftmost sensor is on line 0
if on_line(leftmost_sensor, ycoord_lower, ycoord_upper) == 0:
middlePoint = [round((start_sensor[0] + distance_sensors_lower[0] + 1) / 2), ycoord_upper]
for i in range(len(distance_sensors_lower)):
added_distance = i
while added_distance <= max_distance_lower:
if distance_sensors_lower[i] == 1:
break
if middlePoint in sensors_upper:
try:
counter_lower[i] += 1
except IndexError:
counter_lower.append(1)
if start_sensor in sensors_lower:
try:
counter_lower[i] += 1
except IndexError:
counter_lower.append(1)
added_distance += distance_sensors_lower[i]
middlePoint[0] += distance_sensors_lower[i]
start_sensor[0] += distance_sensors_lower[i]
start_sensor = list(leftmost_sensor)
middlePoint = [round((start_sensor[0] + distance_sensors_lower[i] + 1) / 2), ycoord_upper]
elif on_line(leftmost_sensor, ycoord_lower, ycoord_upper) == 1:
middlePoint = [round(start_sensor[0] + distance_sensors_upper[0] + 1) / 2, ycoord_lower]
for i in range(len(distance_sensors_upper)):
added_distance = i
while added_distance <= max_distance_upper:
if middlePoint in sensors_lower:
try:
counter_lower[i] += 1
except IndexError:
counter_lower.append(1)
if start_sensor in sensors_upper:
try:
counter_lower[i] += 1
except IndexError:
counter_lower.append(1)
added_distance += distance_sensors_upper[i]
middlePoint[0] += distance_sensors_upper[i]
start_sensor[0] += distance_sensors_upper[i]
start_sensor = list(leftmost_sensor)
middlePoint = [round((start_sensor[0] + distance_sensors_upper[i] + 1) / 2), ycoord_lower]
_max = counter_lower[0]
for i in range(len(counter_lower)):
if counter_lower[i] > _max:
_max = counter_lower[i]
print(_max)
``` | instruction | 0 | 13,334 | 3 | 26,668 |
No | output | 1 | 13,334 | 3 | 26,669 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem.
In good old times dwarves tried to develop extrasensory abilities:
* Exactly n dwarves entered completely dark cave.
* Each dwarf received a hat — white or black. While in cave, none of the dwarves was able to see either his own hat or hats of other Dwarves.
* Dwarves went out of the cave to the meadow and sat at an arbitrary place one after the other. When a dwarf leaves the cave, he sees the colors of all hats of all dwarves that are seating on the meadow (i.e. left the cave before him). However, he is not able to see the color of his own hat and none of the dwarves can give him this information.
* The task for dwarves was to got diverged into two parts — one with dwarves with white hats and one with black hats.
After many centuries, dwarves finally managed to select the right place on the meadow without error. Will you be able to repeat their success?
You are asked to successively name n different integer points on the plane. After naming each new point you will be given its color — black or white. Your task is to ensure that the named points can be split by a line in such a way that all points of one color lie on the same side from the line and points of different colors lie on different sides. Moreover, no points can belong to the line. Also, you need to report any such line at the end of the process.
In this problem, the interactor is adaptive — the colors of the points in the tests are not fixed beforehand and the jury program can select them arbitrarily, in particular, depending on your program output.
Interaction
The first line of the standard input stream contains an integer n (1 ≤ n ≤ 30) — the number of points your program should name.
Then n times your program must print two integer coordinates x and y (0 ≤ x ≤ 109, 0 ≤ y ≤ 109). All points you print must be distinct.
In response to each coordinate pair your program will receive the string "black", if the point is black, or "white", if the point is white.
When all n points are processed, you need to print four integers x1, y1, x2 and y2 (0 ≤ x1, y1 ≤ 109, 0 ≤ x2, y2 ≤ 109) — coordinates of points (x1, y1) and (x2, y2), which form a line, which separates n points into black and white. Points (x1, y1) and (x2, y2) should not coincide.
Hacks
To hack solution use the following format. The first line must contain word "hack", the second line should contain the number n and the last line should contain the sequence of 0 and 1 — colors of points, which will be reported to the solution. Unlike the jury tests, colors of points in hacks are always fixed in advance. Of course, the hacked solution wouldn't be able to get the information about the colors in advance.
For example, the hack corresponding to sample test will look like this:
hack
5
0 0 1 1 0
Example
Input
5
<span class="tex-span"></span>
black
<span class="tex-span"></span>
black
<span class="tex-span"></span>
white
<span class="tex-span"></span>
white
<span class="tex-span"></span>
black
Output
<span class="tex-span"></span>
0 0
<span class="tex-span"></span>
3 1
<span class="tex-span"></span>
2 3
<span class="tex-span"></span>
4 4
<span class="tex-span"></span>
0 2
<span class="tex-span"></span>
1 3 4 1
Note
In the sample input and output values are aligned only for simplicity of interpreting them chronologically. In real interaction no "extra" line breaks should appear.
The following picture illustrates the first test.
<image>
Submitted Solution:
```
from sys import stdout
def main():
n = int(input()) - 1
print(0, 0)
stdout.flush()
start = input()
if n == 0:
return
print(500000000, 1000000000)
stdout.flush()
p1 = None
if input() == start:
p1 = (500000001, 1000000000)
else:
p1 = (499999999, 1000000000)
left, right = 0, 999999999
for i in range(n - 1):
mid = (left + right) >> 1
print(mid, 0)
stdout.flush()
if input() == start:
left = mid
else:
right = mid
mid = (left + right) >> 1
print(mid, 0, p1[0], p1[1])
main()
``` | instruction | 0 | 13,335 | 3 | 26,670 |
No | output | 1 | 13,335 | 3 | 26,671 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem.
In good old times dwarves tried to develop extrasensory abilities:
* Exactly n dwarves entered completely dark cave.
* Each dwarf received a hat — white or black. While in cave, none of the dwarves was able to see either his own hat or hats of other Dwarves.
* Dwarves went out of the cave to the meadow and sat at an arbitrary place one after the other. When a dwarf leaves the cave, he sees the colors of all hats of all dwarves that are seating on the meadow (i.e. left the cave before him). However, he is not able to see the color of his own hat and none of the dwarves can give him this information.
* The task for dwarves was to got diverged into two parts — one with dwarves with white hats and one with black hats.
After many centuries, dwarves finally managed to select the right place on the meadow without error. Will you be able to repeat their success?
You are asked to successively name n different integer points on the plane. After naming each new point you will be given its color — black or white. Your task is to ensure that the named points can be split by a line in such a way that all points of one color lie on the same side from the line and points of different colors lie on different sides. Moreover, no points can belong to the line. Also, you need to report any such line at the end of the process.
In this problem, the interactor is adaptive — the colors of the points in the tests are not fixed beforehand and the jury program can select them arbitrarily, in particular, depending on your program output.
Interaction
The first line of the standard input stream contains an integer n (1 ≤ n ≤ 30) — the number of points your program should name.
Then n times your program must print two integer coordinates x and y (0 ≤ x ≤ 109, 0 ≤ y ≤ 109). All points you print must be distinct.
In response to each coordinate pair your program will receive the string "black", if the point is black, or "white", if the point is white.
When all n points are processed, you need to print four integers x1, y1, x2 and y2 (0 ≤ x1, y1 ≤ 109, 0 ≤ x2, y2 ≤ 109) — coordinates of points (x1, y1) and (x2, y2), which form a line, which separates n points into black and white. Points (x1, y1) and (x2, y2) should not coincide.
Hacks
To hack solution use the following format. The first line must contain word "hack", the second line should contain the number n and the last line should contain the sequence of 0 and 1 — colors of points, which will be reported to the solution. Unlike the jury tests, colors of points in hacks are always fixed in advance. Of course, the hacked solution wouldn't be able to get the information about the colors in advance.
For example, the hack corresponding to sample test will look like this:
hack
5
0 0 1 1 0
Example
Input
5
<span class="tex-span"></span>
black
<span class="tex-span"></span>
black
<span class="tex-span"></span>
white
<span class="tex-span"></span>
white
<span class="tex-span"></span>
black
Output
<span class="tex-span"></span>
0 0
<span class="tex-span"></span>
3 1
<span class="tex-span"></span>
2 3
<span class="tex-span"></span>
4 4
<span class="tex-span"></span>
0 2
<span class="tex-span"></span>
1 3 4 1
Note
In the sample input and output values are aligned only for simplicity of interpreting them chronologically. In real interaction no "extra" line breaks should appear.
The following picture illustrates the first test.
<image>
Submitted Solution:
```
n = int(input())
print(0, 0)
color = input()
cl = 1
cr = 10 ** 9
for i in range(n - 1):
m = (cl + cr) // 2
print(m, 0)
c = input()
if c == color:
cl = m + 1
else:
cr = m - 1
print((cl + cr) // 2 , 0, (cl + cr) // 2, 1)
``` | instruction | 0 | 13,336 | 3 | 26,672 |
No | output | 1 | 13,336 | 3 | 26,673 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem.
In good old times dwarves tried to develop extrasensory abilities:
* Exactly n dwarves entered completely dark cave.
* Each dwarf received a hat — white or black. While in cave, none of the dwarves was able to see either his own hat or hats of other Dwarves.
* Dwarves went out of the cave to the meadow and sat at an arbitrary place one after the other. When a dwarf leaves the cave, he sees the colors of all hats of all dwarves that are seating on the meadow (i.e. left the cave before him). However, he is not able to see the color of his own hat and none of the dwarves can give him this information.
* The task for dwarves was to got diverged into two parts — one with dwarves with white hats and one with black hats.
After many centuries, dwarves finally managed to select the right place on the meadow without error. Will you be able to repeat their success?
You are asked to successively name n different integer points on the plane. After naming each new point you will be given its color — black or white. Your task is to ensure that the named points can be split by a line in such a way that all points of one color lie on the same side from the line and points of different colors lie on different sides. Moreover, no points can belong to the line. Also, you need to report any such line at the end of the process.
In this problem, the interactor is adaptive — the colors of the points in the tests are not fixed beforehand and the jury program can select them arbitrarily, in particular, depending on your program output.
Interaction
The first line of the standard input stream contains an integer n (1 ≤ n ≤ 30) — the number of points your program should name.
Then n times your program must print two integer coordinates x and y (0 ≤ x ≤ 109, 0 ≤ y ≤ 109). All points you print must be distinct.
In response to each coordinate pair your program will receive the string "black", if the point is black, or "white", if the point is white.
When all n points are processed, you need to print four integers x1, y1, x2 and y2 (0 ≤ x1, y1 ≤ 109, 0 ≤ x2, y2 ≤ 109) — coordinates of points (x1, y1) and (x2, y2), which form a line, which separates n points into black and white. Points (x1, y1) and (x2, y2) should not coincide.
Hacks
To hack solution use the following format. The first line must contain word "hack", the second line should contain the number n and the last line should contain the sequence of 0 and 1 — colors of points, which will be reported to the solution. Unlike the jury tests, colors of points in hacks are always fixed in advance. Of course, the hacked solution wouldn't be able to get the information about the colors in advance.
For example, the hack corresponding to sample test will look like this:
hack
5
0 0 1 1 0
Example
Input
5
<span class="tex-span"></span>
black
<span class="tex-span"></span>
black
<span class="tex-span"></span>
white
<span class="tex-span"></span>
white
<span class="tex-span"></span>
black
Output
<span class="tex-span"></span>
0 0
<span class="tex-span"></span>
3 1
<span class="tex-span"></span>
2 3
<span class="tex-span"></span>
4 4
<span class="tex-span"></span>
0 2
<span class="tex-span"></span>
1 3 4 1
Note
In the sample input and output values are aligned only for simplicity of interpreting them chronologically. In real interaction no "extra" line breaks should appear.
The following picture illustrates the first test.
<image>
Submitted Solution:
```
l, r = 0, 1e9
g = int(input())
print(0, 0)
if input() == "black":
l, r = r, l
for i in range(g - 1):
m = int((l + r) // 2)
print(m, 0)
sa = input()
if sa == "black":
r = m
else:
l = m
m = int((l + r) // 2)
print(m, 1, m, 0)
``` | instruction | 0 | 13,337 | 3 | 26,674 |
No | output | 1 | 13,337 | 3 | 26,675 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem.
In good old times dwarves tried to develop extrasensory abilities:
* Exactly n dwarves entered completely dark cave.
* Each dwarf received a hat — white or black. While in cave, none of the dwarves was able to see either his own hat or hats of other Dwarves.
* Dwarves went out of the cave to the meadow and sat at an arbitrary place one after the other. When a dwarf leaves the cave, he sees the colors of all hats of all dwarves that are seating on the meadow (i.e. left the cave before him). However, he is not able to see the color of his own hat and none of the dwarves can give him this information.
* The task for dwarves was to got diverged into two parts — one with dwarves with white hats and one with black hats.
After many centuries, dwarves finally managed to select the right place on the meadow without error. Will you be able to repeat their success?
You are asked to successively name n different integer points on the plane. After naming each new point you will be given its color — black or white. Your task is to ensure that the named points can be split by a line in such a way that all points of one color lie on the same side from the line and points of different colors lie on different sides. Moreover, no points can belong to the line. Also, you need to report any such line at the end of the process.
In this problem, the interactor is adaptive — the colors of the points in the tests are not fixed beforehand and the jury program can select them arbitrarily, in particular, depending on your program output.
Interaction
The first line of the standard input stream contains an integer n (1 ≤ n ≤ 30) — the number of points your program should name.
Then n times your program must print two integer coordinates x and y (0 ≤ x ≤ 109, 0 ≤ y ≤ 109). All points you print must be distinct.
In response to each coordinate pair your program will receive the string "black", if the point is black, or "white", if the point is white.
When all n points are processed, you need to print four integers x1, y1, x2 and y2 (0 ≤ x1, y1 ≤ 109, 0 ≤ x2, y2 ≤ 109) — coordinates of points (x1, y1) and (x2, y2), which form a line, which separates n points into black and white. Points (x1, y1) and (x2, y2) should not coincide.
Hacks
To hack solution use the following format. The first line must contain word "hack", the second line should contain the number n and the last line should contain the sequence of 0 and 1 — colors of points, which will be reported to the solution. Unlike the jury tests, colors of points in hacks are always fixed in advance. Of course, the hacked solution wouldn't be able to get the information about the colors in advance.
For example, the hack corresponding to sample test will look like this:
hack
5
0 0 1 1 0
Example
Input
5
<span class="tex-span"></span>
black
<span class="tex-span"></span>
black
<span class="tex-span"></span>
white
<span class="tex-span"></span>
white
<span class="tex-span"></span>
black
Output
<span class="tex-span"></span>
0 0
<span class="tex-span"></span>
3 1
<span class="tex-span"></span>
2 3
<span class="tex-span"></span>
4 4
<span class="tex-span"></span>
0 2
<span class="tex-span"></span>
1 3 4 1
Note
In the sample input and output values are aligned only for simplicity of interpreting them chronologically. In real interaction no "extra" line breaks should appear.
The following picture illustrates the first test.
<image>
Submitted Solution:
```
from sys import stdout
n = int(input()) - 1
print(0, 0)
stdout.flush()
start = input()
left, right = 0, 999999999
for i in range(n):
mid = (left + right) >> 1
print(mid, 0)
stdout.flush()
if input() == start:
left = mid
else:
right = mid
mid = (left + right) >> 1
print(mid, 1, mid, -1)
``` | instruction | 0 | 13,338 | 3 | 26,676 |
No | output | 1 | 13,338 | 3 | 26,677 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During one of the space missions, humans have found an evidence of previous life at one of the planets. They were lucky enough to find a book with birth and death years of each individual that had been living at this planet. What's interesting is that these years are in the range (1, 10^9)! Therefore, the planet was named Longlifer.
In order to learn more about Longlifer's previous population, scientists need to determine the year with maximum number of individuals that were alive, as well as the number of alive individuals in that year. Your task is to help scientists solve this problem!
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) — the number of people.
Each of the following n lines contain two integers b and d (1 ≤ b < d ≤ 10^9) representing birth and death year (respectively) of each individual.
Output
Print two integer numbers separated by blank character, y — the year with a maximum number of people alive and k — the number of people alive in year y.
In the case of multiple possible solutions, print the solution with minimum year.
Examples
Input
3
1 5
2 4
5 6
Output
2 2
Input
4
3 4
4 5
4 6
8 10
Output
4 2
Note
You can assume that an individual living from b to d has been born at the beginning of b and died at the beginning of d, and therefore living for d - b years. | instruction | 0 | 13,485 | 3 | 26,970 |
Tags: data structures, sortings
Correct Solution:
```
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
# from fractions import *
# from heapq import*
from bisect import *
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
ALPHA='abcdefghijklmnopqrstuvwxyz/'
M=1000000007
EPS=1e-6
def Ceil(a,b): return a//b+int(a%b>0)
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
# vsInput()
n=Int()
a=defaultdict(int)
for i in range(n):
x,y=value()
a[x]+=1
a[y]-=1
a=[(i,a[i]) for i in a]
a.sort()
MA=0
y=-1
cur=0
for c,f in a:
cur+=f
if(cur>MA):
MA=cur
y=c
print(y,MA)
``` | output | 1 | 13,485 | 3 | 26,971 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During one of the space missions, humans have found an evidence of previous life at one of the planets. They were lucky enough to find a book with birth and death years of each individual that had been living at this planet. What's interesting is that these years are in the range (1, 10^9)! Therefore, the planet was named Longlifer.
In order to learn more about Longlifer's previous population, scientists need to determine the year with maximum number of individuals that were alive, as well as the number of alive individuals in that year. Your task is to help scientists solve this problem!
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) — the number of people.
Each of the following n lines contain two integers b and d (1 ≤ b < d ≤ 10^9) representing birth and death year (respectively) of each individual.
Output
Print two integer numbers separated by blank character, y — the year with a maximum number of people alive and k — the number of people alive in year y.
In the case of multiple possible solutions, print the solution with minimum year.
Examples
Input
3
1 5
2 4
5 6
Output
2 2
Input
4
3 4
4 5
4 6
8 10
Output
4 2
Note
You can assume that an individual living from b to d has been born at the beginning of b and died at the beginning of d, and therefore living for d - b years. | instruction | 0 | 13,486 | 3 | 26,972 |
Tags: data structures, sortings
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def print_list(l):
print(' '.join(map(str,l)))
# import heapq as hq
# import bisect as bs
# from collections import deque as dq
from collections import defaultdict as dc
# from math import ceil,floor,sqrt
# from collections import Counter
born = dc(int)
die = dc(int)
for _ in range(N()):
a,b = RL()
born[a]+=1
die[b]+=1
s = list(sorted(set(born.keys())|set(die.keys())))
m = 0
now = 0
for i in s:
now+=born[i]-die[i]
if now>m:
res = i
m = now
print(res,m)
``` | output | 1 | 13,486 | 3 | 26,973 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During one of the space missions, humans have found an evidence of previous life at one of the planets. They were lucky enough to find a book with birth and death years of each individual that had been living at this planet. What's interesting is that these years are in the range (1, 10^9)! Therefore, the planet was named Longlifer.
In order to learn more about Longlifer's previous population, scientists need to determine the year with maximum number of individuals that were alive, as well as the number of alive individuals in that year. Your task is to help scientists solve this problem!
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) — the number of people.
Each of the following n lines contain two integers b and d (1 ≤ b < d ≤ 10^9) representing birth and death year (respectively) of each individual.
Output
Print two integer numbers separated by blank character, y — the year with a maximum number of people alive and k — the number of people alive in year y.
In the case of multiple possible solutions, print the solution with minimum year.
Examples
Input
3
1 5
2 4
5 6
Output
2 2
Input
4
3 4
4 5
4 6
8 10
Output
4 2
Note
You can assume that an individual living from b to d has been born at the beginning of b and died at the beginning of d, and therefore living for d - b years. | instruction | 0 | 13,487 | 3 | 26,974 |
Tags: data structures, sortings
Correct Solution:
```
from sys import stdout, stdin, setrecursionlimit
from io import BytesIO, IOBase
from collections import *
from itertools import *
from random import *
from bisect import *
from string import *
from queue import *
from heapq import *
from math import *
from re import *
from os import *
####################################---fast-input-output----#########################################
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = read(self._fd, max(fstat(self._fd).st_size, 8192))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = read(self._fd, max(fstat(self._fd).st_size, 8192))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
stdin, stdout = IOWrapper(stdin), IOWrapper(stdout)
graph, mod, szzz = {}, 10**9 + 7, lambda: sorted(zzz())
def getStr(): return input()
def getInt(): return int(input())
def listStr(): return list(input())
def getStrs(): return input().split()
def isInt(s): return '0' <= s[0] <= '9'
def input(): return stdin.readline().strip()
def zzz(): return [int(i) for i in input().split()]
def output(answer, end='\n'): stdout.write(str(answer) + end)
def lcd(xnum1, xnum2): return (xnum1 * xnum2 // gcd(xnum1, xnum2))
dx = [-1, 1, 0, 0, 1, -1, 1, -1]
dy = [0, 0, 1, -1, 1, -1, -1, 1]
daysInMounth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
#################################################---Some Rule For Me To Follow---#################################
"""
--instants of Reading problem continuously try to understand them.
--If you Know some-one , Then you probably don't know him !
--Try & again try, maybe you're just one statement away!
"""
##################################################---START-CODING---###############################################
n = getInt()
lst = []
for i in range(n):
x,y=zzz()
lst.append((x,1))
lst.append((y,-1))
lst =sorted(lst)
ans,c=0,0
for i in lst:
c+=i[1]
if ans<c:
ans,y=c,i[0]
print(y,ans)
``` | output | 1 | 13,487 | 3 | 26,975 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.