message stringlengths 2 44.5k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 276 109k | cluster float64 23 23 | __index_level_0__ int64 552 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
DLS and JLS are bored with a Math lesson. In order to entertain themselves, DLS took a sheet of paper and drew n distinct lines, given by equations y = x + p_i for some distinct p_1, p_2, …, p_n.
Then JLS drew on the same paper sheet m distinct lines given by equations y = -x + q_i for some distinct q_1, q_2, …, q_m.
DLS and JLS are interested in counting how many line pairs have integer intersection points, i.e. points with both coordinates that are integers. Unfortunately, the lesson will end up soon, so DLS and JLS are asking for your help.
Input
The first line contains one integer t (1 ≤ t ≤ 1000), the number of test cases in the input. Then follow the test case descriptions.
The first line of a test case contains an integer n (1 ≤ n ≤ 10^5), the number of lines drawn by DLS.
The second line of a test case contains n distinct integers p_i (0 ≤ p_i ≤ 10^9) describing the lines drawn by DLS. The integer p_i describes a line given by the equation y = x + p_i.
The third line of a test case contains an integer m (1 ≤ m ≤ 10^5), the number of lines drawn by JLS.
The fourth line of a test case contains m distinct integers q_i (0 ≤ q_i ≤ 10^9) describing the lines drawn by JLS. The integer q_i describes a line given by the equation y = -x + q_i.
The sum of the values of n over all test cases in the input does not exceed 10^5. Similarly, the sum of the values of m over all test cases in the input does not exceed 10^5.
In hacks it is allowed to use only one test case in the input, so t=1 should be satisfied.
Output
For each test case in the input print a single integer — the number of line pairs with integer intersection points.
Example
Input
3
3
1 3 2
2
0 3
1
1
1
1
1
2
1
1
Output
3
1
0
Note
The picture shows the lines from the first test case of the example. Black circles denote intersection points with integer coordinates.
<image>
Submitted Solution:
```
# 1248A.py
for _ in range(int(input())):
n = int(input())
p = list(map(int,input().split()))
m = int(input())
q = list(map(int,input().split()))
podd = 0
peven = 0
qodd = 0
qeven = 0
for i in range(n):
if p[i]%2==0:
peven+=1
else:
podd+=1
for i in range(m):
if q[i]%2==0:
qeven+=1
else:
qodd+=1
ok = True
if podd==0 or qodd == 0:
if peven!=0 or qeven!=0:
ok = False
elif peven==0 or qeven == 0:
if podd==0 or qodd==0:
ok = False
if ok:
print(max(podd,qodd)+max(peven,qeven))
else:
print(0)
``` | instruction | 0 | 61,585 | 23 | 123,170 |
No | output | 1 | 61,585 | 23 | 123,171 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
DLS and JLS are bored with a Math lesson. In order to entertain themselves, DLS took a sheet of paper and drew n distinct lines, given by equations y = x + p_i for some distinct p_1, p_2, …, p_n.
Then JLS drew on the same paper sheet m distinct lines given by equations y = -x + q_i for some distinct q_1, q_2, …, q_m.
DLS and JLS are interested in counting how many line pairs have integer intersection points, i.e. points with both coordinates that are integers. Unfortunately, the lesson will end up soon, so DLS and JLS are asking for your help.
Input
The first line contains one integer t (1 ≤ t ≤ 1000), the number of test cases in the input. Then follow the test case descriptions.
The first line of a test case contains an integer n (1 ≤ n ≤ 10^5), the number of lines drawn by DLS.
The second line of a test case contains n distinct integers p_i (0 ≤ p_i ≤ 10^9) describing the lines drawn by DLS. The integer p_i describes a line given by the equation y = x + p_i.
The third line of a test case contains an integer m (1 ≤ m ≤ 10^5), the number of lines drawn by JLS.
The fourth line of a test case contains m distinct integers q_i (0 ≤ q_i ≤ 10^9) describing the lines drawn by JLS. The integer q_i describes a line given by the equation y = -x + q_i.
The sum of the values of n over all test cases in the input does not exceed 10^5. Similarly, the sum of the values of m over all test cases in the input does not exceed 10^5.
In hacks it is allowed to use only one test case in the input, so t=1 should be satisfied.
Output
For each test case in the input print a single integer — the number of line pairs with integer intersection points.
Example
Input
3
3
1 3 2
2
0 3
1
1
1
1
1
2
1
1
Output
3
1
0
Note
The picture shows the lines from the first test case of the example. Black circles denote intersection points with integer coordinates.
<image>
Submitted Solution:
```
n=int(input())
for _ in range(n):
x=input()
p=map(int,input().split())
y=input()
q=map(int,input().split())
count=0
for i in p:
for j in q:
if (i+j)%2==0:
count+=1
print(count)
``` | instruction | 0 | 61,586 | 23 | 123,172 |
No | output | 1 | 61,586 | 23 | 123,173 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Holidays are coming up really soon. Rick realized that it's time to think about buying a traditional spruce tree. But Rick doesn't want real trees to get hurt so he decided to find some in an n × m matrix consisting of "*" and ".".
<image>
To find every spruce first let's define what a spruce in the matrix is. A set of matrix cells is called a spruce of height k with origin at point (x, y) if:
* All cells in the set contain an "*".
* For each 1 ≤ i ≤ k all cells with the row number x+i-1 and columns in range [y - i + 1, y + i - 1] must be a part of the set. All other cells cannot belong to the set.
Examples of correct and incorrect spruce trees:
<image>
Now Rick wants to know how many spruces his n × m matrix contains. Help Rick solve this problem.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10).
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 500) — matrix size.
Next n lines of each test case contain m characters c_{i, j} — matrix contents. It is guaranteed that c_{i, j} is either a "." or an "*".
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 500^2 (∑ n ⋅ m ≤ 500^2).
Output
For each test case, print single integer — the total number of spruces in the matrix.
Example
Input
4
2 3
.*.
***
2 3
.*.
**.
4 5
.***.
*****
*****
*.*.*
5 7
..*.*..
.*****.
*******
.*****.
..*.*..
Output
5
3
23
34
Note
In the first test case the first spruce of height 2 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (1, 2), the third spruce of height 1 has its origin at point (2, 1), the fourth spruce of height 1 has its origin at point (2, 2), the fifth spruce of height 1 has its origin at point (2, 3).
In the second test case the first spruce of height 1 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (2, 1), the third spruce of height 1 has its origin at point (2, 2). | instruction | 0 | 61,683 | 23 | 123,366 |
Tags: brute force, dp, implementation
Correct Solution:
```
for _ in range(int(input())):
n,m=map(int,input().split())
inp=[]
out=0
for i in range(n):
inp.append(list(input()))
mat=[[] for i in range(n)]
for i in range(n):
for j in range(m):
k=0
while j-k>=0 and j+k<m:
if inp[i][j-k]=='*' and inp[i][j+k]=='*':
k+=1
else:
break
mat[i].append(k)
for i in range(n):
for j in range(m):
k=0
while i+k<n:
if mat[i+k][j]>=k+1:
k+=1
else:
break
out+=k
print(out)
``` | output | 1 | 61,683 | 23 | 123,367 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Holidays are coming up really soon. Rick realized that it's time to think about buying a traditional spruce tree. But Rick doesn't want real trees to get hurt so he decided to find some in an n × m matrix consisting of "*" and ".".
<image>
To find every spruce first let's define what a spruce in the matrix is. A set of matrix cells is called a spruce of height k with origin at point (x, y) if:
* All cells in the set contain an "*".
* For each 1 ≤ i ≤ k all cells with the row number x+i-1 and columns in range [y - i + 1, y + i - 1] must be a part of the set. All other cells cannot belong to the set.
Examples of correct and incorrect spruce trees:
<image>
Now Rick wants to know how many spruces his n × m matrix contains. Help Rick solve this problem.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10).
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 500) — matrix size.
Next n lines of each test case contain m characters c_{i, j} — matrix contents. It is guaranteed that c_{i, j} is either a "." or an "*".
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 500^2 (∑ n ⋅ m ≤ 500^2).
Output
For each test case, print single integer — the total number of spruces in the matrix.
Example
Input
4
2 3
.*.
***
2 3
.*.
**.
4 5
.***.
*****
*****
*.*.*
5 7
..*.*..
.*****.
*******
.*****.
..*.*..
Output
5
3
23
34
Note
In the first test case the first spruce of height 2 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (1, 2), the third spruce of height 1 has its origin at point (2, 1), the fourth spruce of height 1 has its origin at point (2, 2), the fifth spruce of height 1 has its origin at point (2, 3).
In the second test case the first spruce of height 1 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (2, 1), the third spruce of height 1 has its origin at point (2, 2). | instruction | 0 | 61,684 | 23 | 123,368 |
Tags: brute force, dp, implementation
Correct Solution:
```
for _ in range(int(input())):
n,m=map(int,input().split())
a=[]
t=[]
for i in range(n):
a.append(input())
x=[]
s=0
for j in a[i]:
if(j=="*"): s+=1
x.append(s)
t.append(x)
ans=0
for i in range(n):
for j in range(m):
if(a[i][j]=="*"): k=1
else:
continue
while(k<=n-i):
l=j-k+1
h=j+k-1
f=i+k-1
# print(l,h)
if(l>=0 and h<m):
if(l==0):s=t[f][h]
else: s=t[f][h]-t[f][l-1]
if(s==h-l+1):
# print(i,j,s,k,ans)
k+=1
else:
break
else:
break
ans+=k-1
print(ans)
``` | output | 1 | 61,684 | 23 | 123,369 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Holidays are coming up really soon. Rick realized that it's time to think about buying a traditional spruce tree. But Rick doesn't want real trees to get hurt so he decided to find some in an n × m matrix consisting of "*" and ".".
<image>
To find every spruce first let's define what a spruce in the matrix is. A set of matrix cells is called a spruce of height k with origin at point (x, y) if:
* All cells in the set contain an "*".
* For each 1 ≤ i ≤ k all cells with the row number x+i-1 and columns in range [y - i + 1, y + i - 1] must be a part of the set. All other cells cannot belong to the set.
Examples of correct and incorrect spruce trees:
<image>
Now Rick wants to know how many spruces his n × m matrix contains. Help Rick solve this problem.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10).
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 500) — matrix size.
Next n lines of each test case contain m characters c_{i, j} — matrix contents. It is guaranteed that c_{i, j} is either a "." or an "*".
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 500^2 (∑ n ⋅ m ≤ 500^2).
Output
For each test case, print single integer — the total number of spruces in the matrix.
Example
Input
4
2 3
.*.
***
2 3
.*.
**.
4 5
.***.
*****
*****
*.*.*
5 7
..*.*..
.*****.
*******
.*****.
..*.*..
Output
5
3
23
34
Note
In the first test case the first spruce of height 2 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (1, 2), the third spruce of height 1 has its origin at point (2, 1), the fourth spruce of height 1 has its origin at point (2, 2), the fifth spruce of height 1 has its origin at point (2, 3).
In the second test case the first spruce of height 1 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (2, 1), the third spruce of height 1 has its origin at point (2, 2). | instruction | 0 | 61,685 | 23 | 123,370 |
Tags: brute force, dp, implementation
Correct Solution:
```
t=int(input())
for _ in range(t):
n,m=map(int,input().split())
inp=[]
for i in range(n):
s=input()
inp.append(s)
ans=0
R=[]
L=[]
for i in range(n):
low=0
high=0
right=[]
left=[]
while high<m:
if inp[i][high]=="*":
while high<m and inp[i][high]=="*":
high+=1
for j in range(high-low):
left.append(j)
right.append(high-low-j-1)
low=high
else:
left.append(0)
right.append(0)
high+=1
low+=1
R.append(right)
L.append(left)
main=[[0 for i in range(m)]]
for i in range(n):
temp=[]
for j in range(m):
if inp[i][j]=="*":
x=min(main[i][j]+1,min(L[i][j],R[i][j])+1)
ans+=x
temp.append(x)
else:
temp.append(0)
main.append(temp)
print(ans)
``` | output | 1 | 61,685 | 23 | 123,371 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Holidays are coming up really soon. Rick realized that it's time to think about buying a traditional spruce tree. But Rick doesn't want real trees to get hurt so he decided to find some in an n × m matrix consisting of "*" and ".".
<image>
To find every spruce first let's define what a spruce in the matrix is. A set of matrix cells is called a spruce of height k with origin at point (x, y) if:
* All cells in the set contain an "*".
* For each 1 ≤ i ≤ k all cells with the row number x+i-1 and columns in range [y - i + 1, y + i - 1] must be a part of the set. All other cells cannot belong to the set.
Examples of correct and incorrect spruce trees:
<image>
Now Rick wants to know how many spruces his n × m matrix contains. Help Rick solve this problem.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10).
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 500) — matrix size.
Next n lines of each test case contain m characters c_{i, j} — matrix contents. It is guaranteed that c_{i, j} is either a "." or an "*".
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 500^2 (∑ n ⋅ m ≤ 500^2).
Output
For each test case, print single integer — the total number of spruces in the matrix.
Example
Input
4
2 3
.*.
***
2 3
.*.
**.
4 5
.***.
*****
*****
*.*.*
5 7
..*.*..
.*****.
*******
.*****.
..*.*..
Output
5
3
23
34
Note
In the first test case the first spruce of height 2 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (1, 2), the third spruce of height 1 has its origin at point (2, 1), the fourth spruce of height 1 has its origin at point (2, 2), the fifth spruce of height 1 has its origin at point (2, 3).
In the second test case the first spruce of height 1 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (2, 1), the third spruce of height 1 has its origin at point (2, 2). | instruction | 0 | 61,686 | 23 | 123,372 |
Tags: brute force, dp, implementation
Correct Solution:
```
for _ in range(int(input())):
ROW,COL=map(int,input().split())
arr=[]
for _ in range(ROW):
arr.append(list(input()))
sol =[[0 for i in range(COL)] for j in range(ROW)]
for row in range(ROW):
for col in range(COL):
if arr[row][col]=='*':
sol[row][col]=1
for row in range(ROW-2,-1,-1):
for col in range(COL):
if col==0 or col==COL-1:
pass
elif sol[row][col]>=1:
sol[row][col]+=min(sol[row+1][col-1],sol[row+1][col],sol[row+1][col+1])
x=0
for i in sol:
x+=sum(i)
print (x)
``` | output | 1 | 61,686 | 23 | 123,373 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Holidays are coming up really soon. Rick realized that it's time to think about buying a traditional spruce tree. But Rick doesn't want real trees to get hurt so he decided to find some in an n × m matrix consisting of "*" and ".".
<image>
To find every spruce first let's define what a spruce in the matrix is. A set of matrix cells is called a spruce of height k with origin at point (x, y) if:
* All cells in the set contain an "*".
* For each 1 ≤ i ≤ k all cells with the row number x+i-1 and columns in range [y - i + 1, y + i - 1] must be a part of the set. All other cells cannot belong to the set.
Examples of correct and incorrect spruce trees:
<image>
Now Rick wants to know how many spruces his n × m matrix contains. Help Rick solve this problem.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10).
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 500) — matrix size.
Next n lines of each test case contain m characters c_{i, j} — matrix contents. It is guaranteed that c_{i, j} is either a "." or an "*".
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 500^2 (∑ n ⋅ m ≤ 500^2).
Output
For each test case, print single integer — the total number of spruces in the matrix.
Example
Input
4
2 3
.*.
***
2 3
.*.
**.
4 5
.***.
*****
*****
*.*.*
5 7
..*.*..
.*****.
*******
.*****.
..*.*..
Output
5
3
23
34
Note
In the first test case the first spruce of height 2 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (1, 2), the third spruce of height 1 has its origin at point (2, 1), the fourth spruce of height 1 has its origin at point (2, 2), the fifth spruce of height 1 has its origin at point (2, 3).
In the second test case the first spruce of height 1 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (2, 1), the third spruce of height 1 has its origin at point (2, 2). | instruction | 0 | 61,687 | 23 | 123,374 |
Tags: brute force, dp, implementation
Correct Solution:
```
import sys
#input = sys.stdin.readline
t = int(input())
for test in range(t):
#n = int(input())
[n, m] = list(map(int, input().split(" ")))
a = []
for i in range(n):
a.append(input())
#a = list(map(int, input().split(" ")))
res = 0
b = []
for i in range(n):
k = 0
bi = []
for j in range(m):
if a[i][j]=='*':
bi.append(1)
k+=1
for x in range(1,(k+1)//2):
#print(k)
#print(k+1//2)
bi[j-x]+=1
else:
bi.append(0)
k=0
b.append(bi)
for j in range(m):
if b[0][j]>0:
res +=1
#print(res)
#print(b)
for i in range(1,n):
for j in range(m):
res = res + min(b[i][j],b[i-1][j]+1,i+1)
b[i][j] = min(b[i][j],b[i-1][j]+1,i+1)
#print(b)
print(res)
``` | output | 1 | 61,687 | 23 | 123,375 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Holidays are coming up really soon. Rick realized that it's time to think about buying a traditional spruce tree. But Rick doesn't want real trees to get hurt so he decided to find some in an n × m matrix consisting of "*" and ".".
<image>
To find every spruce first let's define what a spruce in the matrix is. A set of matrix cells is called a spruce of height k with origin at point (x, y) if:
* All cells in the set contain an "*".
* For each 1 ≤ i ≤ k all cells with the row number x+i-1 and columns in range [y - i + 1, y + i - 1] must be a part of the set. All other cells cannot belong to the set.
Examples of correct and incorrect spruce trees:
<image>
Now Rick wants to know how many spruces his n × m matrix contains. Help Rick solve this problem.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10).
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 500) — matrix size.
Next n lines of each test case contain m characters c_{i, j} — matrix contents. It is guaranteed that c_{i, j} is either a "." or an "*".
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 500^2 (∑ n ⋅ m ≤ 500^2).
Output
For each test case, print single integer — the total number of spruces in the matrix.
Example
Input
4
2 3
.*.
***
2 3
.*.
**.
4 5
.***.
*****
*****
*.*.*
5 7
..*.*..
.*****.
*******
.*****.
..*.*..
Output
5
3
23
34
Note
In the first test case the first spruce of height 2 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (1, 2), the third spruce of height 1 has its origin at point (2, 1), the fourth spruce of height 1 has its origin at point (2, 2), the fifth spruce of height 1 has its origin at point (2, 3).
In the second test case the first spruce of height 1 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (2, 1), the third spruce of height 1 has its origin at point (2, 2). | instruction | 0 | 61,688 | 23 | 123,376 |
Tags: brute force, dp, implementation
Correct Solution:
```
import sys
import math
def II():
return int(sys.stdin.readline())
def LI():
return list(map(int, sys.stdin.readline().split()))
def MI():
return map(int, sys.stdin.readline().split())
def SI():
return sys.stdin.readline().strip()
def FACT(n, mod):
s = 1
facts = [1]
for i in range(1,n+1):
s*=i
s%=mod
facts.append(s)
return facts[n]
def C(n, k, mod):
return (FACT(n,mod) * pow((FACT(k,mod)*FACT(n-k,mod))%mod,mod-2, mod))%mod
t = II()
for q in range(t):
n,m = MI()
l = []
for i in range(n):
l.append(list(SI()))
ans = 0
dp = [[0 for i in range(m)] for j in range(n)]
le = [[0 for i in range(m)] for j in range(n)]
ri = [[0 for i in range(m)] for j in range(n)]
for i in range(n):
count = 0
for j in range(m):
le[i][j] = count
if l[i][j] == "*":
dp[i][j] = 1
count+=1
ans+=1
else:
count = 0
count = 0
for j in range(m-1,-1,-1):
ri[i][j] = count
if l[i][j] == "*":
count+=1
else:
count = 0
for i in range(1,n):
for j in range(m):
if l[i][j] == "*":
x = le[i][j]
y = ri[i][j]
z = dp[i-1][j]
if z!=0 and min(x,y,(z-1)//2+1)!=0:
ans+=(min(x,y,(z-1)//2+1)*2+1)//2
dp[i][j] = min(x,y,(z-1)//2+1)*2+1
print(ans)
``` | output | 1 | 61,688 | 23 | 123,377 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Holidays are coming up really soon. Rick realized that it's time to think about buying a traditional spruce tree. But Rick doesn't want real trees to get hurt so he decided to find some in an n × m matrix consisting of "*" and ".".
<image>
To find every spruce first let's define what a spruce in the matrix is. A set of matrix cells is called a spruce of height k with origin at point (x, y) if:
* All cells in the set contain an "*".
* For each 1 ≤ i ≤ k all cells with the row number x+i-1 and columns in range [y - i + 1, y + i - 1] must be a part of the set. All other cells cannot belong to the set.
Examples of correct and incorrect spruce trees:
<image>
Now Rick wants to know how many spruces his n × m matrix contains. Help Rick solve this problem.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10).
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 500) — matrix size.
Next n lines of each test case contain m characters c_{i, j} — matrix contents. It is guaranteed that c_{i, j} is either a "." or an "*".
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 500^2 (∑ n ⋅ m ≤ 500^2).
Output
For each test case, print single integer — the total number of spruces in the matrix.
Example
Input
4
2 3
.*.
***
2 3
.*.
**.
4 5
.***.
*****
*****
*.*.*
5 7
..*.*..
.*****.
*******
.*****.
..*.*..
Output
5
3
23
34
Note
In the first test case the first spruce of height 2 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (1, 2), the third spruce of height 1 has its origin at point (2, 1), the fourth spruce of height 1 has its origin at point (2, 2), the fifth spruce of height 1 has its origin at point (2, 3).
In the second test case the first spruce of height 1 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (2, 1), the third spruce of height 1 has its origin at point (2, 2). | instruction | 0 | 61,689 | 23 | 123,378 |
Tags: brute force, dp, implementation
Correct Solution:
```
t = int(input())
for _ in range(t):
n,k = map(int,input().split())
mat = []
ans = [[0 for i in range(k)]for j in range(n)]
for i in range(n):
temp = input()
mat.append(temp)
for i in range(k):
if mat[n-1][i] == '*':
ans[n-1][i] = 1
for i in range(n-2,-1,-1):
if mat[i][0] == '*':
ans[i][0] = 1
if mat[i][k-1] == '*':
ans[i][k-1] = 1
for j in range(1,k-1):
if mat[i][j] == '*':
h = 1+min(ans[i+1][j],ans[i+1][j-1],ans[i+1][j+1])
ans[i][j] = h
res = 0
for i in range(n):
for j in range(k):
res += ans[i][j]
print(res)
``` | output | 1 | 61,689 | 23 | 123,379 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Holidays are coming up really soon. Rick realized that it's time to think about buying a traditional spruce tree. But Rick doesn't want real trees to get hurt so he decided to find some in an n × m matrix consisting of "*" and ".".
<image>
To find every spruce first let's define what a spruce in the matrix is. A set of matrix cells is called a spruce of height k with origin at point (x, y) if:
* All cells in the set contain an "*".
* For each 1 ≤ i ≤ k all cells with the row number x+i-1 and columns in range [y - i + 1, y + i - 1] must be a part of the set. All other cells cannot belong to the set.
Examples of correct and incorrect spruce trees:
<image>
Now Rick wants to know how many spruces his n × m matrix contains. Help Rick solve this problem.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10).
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 500) — matrix size.
Next n lines of each test case contain m characters c_{i, j} — matrix contents. It is guaranteed that c_{i, j} is either a "." or an "*".
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 500^2 (∑ n ⋅ m ≤ 500^2).
Output
For each test case, print single integer — the total number of spruces in the matrix.
Example
Input
4
2 3
.*.
***
2 3
.*.
**.
4 5
.***.
*****
*****
*.*.*
5 7
..*.*..
.*****.
*******
.*****.
..*.*..
Output
5
3
23
34
Note
In the first test case the first spruce of height 2 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (1, 2), the third spruce of height 1 has its origin at point (2, 1), the fourth spruce of height 1 has its origin at point (2, 2), the fifth spruce of height 1 has its origin at point (2, 3).
In the second test case the first spruce of height 1 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (2, 1), the third spruce of height 1 has its origin at point (2, 2). | instruction | 0 | 61,690 | 23 | 123,380 |
Tags: brute force, dp, implementation
Correct Solution:
```
import sys
import os
for _ in range(int(input())):
n,m=map(int,input().split())
arr=[]
for i in range(n):
s=input()
arr.append(s)
# == 0 else dp1[i][j - 1] + (1 if arr[i][j] == '*' else 0))
dp=[[0 for _ in range(m)]for _ in range(n)]
for i in range(n):
for j in range(m):
if arr[i][j]=='*':
dp[i][j]=dp[i][j-1]+1
elif j==0:
if arr[i][j]=="*":dp[i][j]=1
else:dp[i][j]=0
else:
dp[i][j]=dp[i][j-1]
ans=0
for x in range(n):
for y in range(m):
if arr[x][y]==".":continue
for level in range(min(n-x,m-y,y+1)):
k=dp[x+level][y+level]
if y-level-1<0:k1=0
else:k1=dp[x+level][y-level-1]
if k-k1!=(level*2)+1:break
ans+=1
print(ans)
``` | output | 1 | 61,690 | 23 | 123,381 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Holidays are coming up really soon. Rick realized that it's time to think about buying a traditional spruce tree. But Rick doesn't want real trees to get hurt so he decided to find some in an n × m matrix consisting of "*" and ".".
<image>
To find every spruce first let's define what a spruce in the matrix is. A set of matrix cells is called a spruce of height k with origin at point (x, y) if:
* All cells in the set contain an "*".
* For each 1 ≤ i ≤ k all cells with the row number x+i-1 and columns in range [y - i + 1, y + i - 1] must be a part of the set. All other cells cannot belong to the set.
Examples of correct and incorrect spruce trees:
<image>
Now Rick wants to know how many spruces his n × m matrix contains. Help Rick solve this problem.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10).
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 500) — matrix size.
Next n lines of each test case contain m characters c_{i, j} — matrix contents. It is guaranteed that c_{i, j} is either a "." or an "*".
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 500^2 (∑ n ⋅ m ≤ 500^2).
Output
For each test case, print single integer — the total number of spruces in the matrix.
Example
Input
4
2 3
.*.
***
2 3
.*.
**.
4 5
.***.
*****
*****
*.*.*
5 7
..*.*..
.*****.
*******
.*****.
..*.*..
Output
5
3
23
34
Note
In the first test case the first spruce of height 2 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (1, 2), the third spruce of height 1 has its origin at point (2, 1), the fourth spruce of height 1 has its origin at point (2, 2), the fifth spruce of height 1 has its origin at point (2, 3).
In the second test case the first spruce of height 1 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (2, 1), the third spruce of height 1 has its origin at point (2, 2).
Submitted Solution:
```
from itertools import accumulate
"""
def main():
n = int(input())
arr = list(map(int,input().split()))
arr = list(accumulate(arr))
cnt,ans=0,0
for i in range(n - 1):
if arr[i] * 3 == arr[n - 1] * 2:
ans += cnt
if arr[i] * 3 == arr[n - 1]:
cnt += 1
print(ans)
if __name__ == '__main__':
main()
"""
def main():
t = int(input())
for _ in range(t):
a,b = map(int,input().split())
t=[]
for i in range(a):
l = input()
t.append(l)
dp = [[0] * (b + 2) for i in range(a + 1)]
ans = 0
for i in range(a - 1, -1, -1):
for j in range(1, b + 1):
if t[i][j - 1] == "*":
dp[i][j] = 1 + min(dp[i + 1][j - 1], dp[i + 1][j], dp[i + 1][j + 1])
ans += dp[i][j]
print(ans)
if __name__ == '__main__':
main()
``` | instruction | 0 | 61,691 | 23 | 123,382 |
Yes | output | 1 | 61,691 | 23 | 123,383 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Holidays are coming up really soon. Rick realized that it's time to think about buying a traditional spruce tree. But Rick doesn't want real trees to get hurt so he decided to find some in an n × m matrix consisting of "*" and ".".
<image>
To find every spruce first let's define what a spruce in the matrix is. A set of matrix cells is called a spruce of height k with origin at point (x, y) if:
* All cells in the set contain an "*".
* For each 1 ≤ i ≤ k all cells with the row number x+i-1 and columns in range [y - i + 1, y + i - 1] must be a part of the set. All other cells cannot belong to the set.
Examples of correct and incorrect spruce trees:
<image>
Now Rick wants to know how many spruces his n × m matrix contains. Help Rick solve this problem.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10).
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 500) — matrix size.
Next n lines of each test case contain m characters c_{i, j} — matrix contents. It is guaranteed that c_{i, j} is either a "." or an "*".
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 500^2 (∑ n ⋅ m ≤ 500^2).
Output
For each test case, print single integer — the total number of spruces in the matrix.
Example
Input
4
2 3
.*.
***
2 3
.*.
**.
4 5
.***.
*****
*****
*.*.*
5 7
..*.*..
.*****.
*******
.*****.
..*.*..
Output
5
3
23
34
Note
In the first test case the first spruce of height 2 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (1, 2), the third spruce of height 1 has its origin at point (2, 1), the fourth spruce of height 1 has its origin at point (2, 2), the fifth spruce of height 1 has its origin at point (2, 3).
In the second test case the first spruce of height 1 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (2, 1), the third spruce of height 1 has its origin at point (2, 2).
Submitted Solution:
```
def main():
def conv(ind):
if ind==".":
return 0
else:
return 1
def check(x,y):
tx=x;ty=y
height=0;count=0;broke=False
while broke==False:
if ty-height>=0 and (ty+height)<=m-1 and tx+height<=n-1:
if ty-height==0:
num1=0
else:
num1=dict1[tx+height][ty-height-1]
if dict1[tx+height][ty+height]-num1==1+2*height:
count+=1
height+=1
else:
broke=True;break
else:
broke=True;break
return count
for j in range(int(input())):
n,m=map(int,input().split())
matr=[];ans=0;dict1={}
for s in range(n):
row=[conv(k) for k in input()]
matr.append(row)
for s in range(n):
pref=[matr[s][0]]
for i in range(1,m):
pref.append(pref[-1]+matr[s][i])
dict1[s]=pref
for s in range(n):
for i in range(m):
ans+=check(s,i)
print(ans)
main()
``` | instruction | 0 | 61,692 | 23 | 123,384 |
Yes | output | 1 | 61,692 | 23 | 123,385 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Holidays are coming up really soon. Rick realized that it's time to think about buying a traditional spruce tree. But Rick doesn't want real trees to get hurt so he decided to find some in an n × m matrix consisting of "*" and ".".
<image>
To find every spruce first let's define what a spruce in the matrix is. A set of matrix cells is called a spruce of height k with origin at point (x, y) if:
* All cells in the set contain an "*".
* For each 1 ≤ i ≤ k all cells with the row number x+i-1 and columns in range [y - i + 1, y + i - 1] must be a part of the set. All other cells cannot belong to the set.
Examples of correct and incorrect spruce trees:
<image>
Now Rick wants to know how many spruces his n × m matrix contains. Help Rick solve this problem.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10).
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 500) — matrix size.
Next n lines of each test case contain m characters c_{i, j} — matrix contents. It is guaranteed that c_{i, j} is either a "." or an "*".
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 500^2 (∑ n ⋅ m ≤ 500^2).
Output
For each test case, print single integer — the total number of spruces in the matrix.
Example
Input
4
2 3
.*.
***
2 3
.*.
**.
4 5
.***.
*****
*****
*.*.*
5 7
..*.*..
.*****.
*******
.*****.
..*.*..
Output
5
3
23
34
Note
In the first test case the first spruce of height 2 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (1, 2), the third spruce of height 1 has its origin at point (2, 1), the fourth spruce of height 1 has its origin at point (2, 2), the fifth spruce of height 1 has its origin at point (2, 3).
In the second test case the first spruce of height 1 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (2, 1), the third spruce of height 1 has its origin at point (2, 2).
Submitted Solution:
```
for _ in range(int(input())):
r, c = map(int, input().split())
res = 0
m = [[0 for i in range(c + 2)] for j in range(r + 1)]
data = [0 for i in range(r)]
for row in range(r):
data[row] = input()
for i in range(row, -1, -1):
for j in range(c):
if data[i][j] == '*':
m[i][j + 1] = min(m[i + 1][j], m[i + 1][j + 1], m[i + 1][j + 2]) + 1
print(sum([sum(i) for i in m]))
``` | instruction | 0 | 61,693 | 23 | 123,386 |
Yes | output | 1 | 61,693 | 23 | 123,387 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Holidays are coming up really soon. Rick realized that it's time to think about buying a traditional spruce tree. But Rick doesn't want real trees to get hurt so he decided to find some in an n × m matrix consisting of "*" and ".".
<image>
To find every spruce first let's define what a spruce in the matrix is. A set of matrix cells is called a spruce of height k with origin at point (x, y) if:
* All cells in the set contain an "*".
* For each 1 ≤ i ≤ k all cells with the row number x+i-1 and columns in range [y - i + 1, y + i - 1] must be a part of the set. All other cells cannot belong to the set.
Examples of correct and incorrect spruce trees:
<image>
Now Rick wants to know how many spruces his n × m matrix contains. Help Rick solve this problem.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10).
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 500) — matrix size.
Next n lines of each test case contain m characters c_{i, j} — matrix contents. It is guaranteed that c_{i, j} is either a "." or an "*".
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 500^2 (∑ n ⋅ m ≤ 500^2).
Output
For each test case, print single integer — the total number of spruces in the matrix.
Example
Input
4
2 3
.*.
***
2 3
.*.
**.
4 5
.***.
*****
*****
*.*.*
5 7
..*.*..
.*****.
*******
.*****.
..*.*..
Output
5
3
23
34
Note
In the first test case the first spruce of height 2 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (1, 2), the third spruce of height 1 has its origin at point (2, 1), the fourth spruce of height 1 has its origin at point (2, 2), the fifth spruce of height 1 has its origin at point (2, 3).
In the second test case the first spruce of height 1 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (2, 1), the third spruce of height 1 has its origin at point (2, 2).
Submitted Solution:
```
T = int(input())
for t in range(T):
n, m = map(int, input().split())
grid = []
for i in range(n):
grid.append(input())
counters = [[0 for i in range(m)] for j in range(n)]
ans = 0
for r in range(n-1, -1, -1):
for c in range(m):
if grid[r][c] == '*':
counters[r][c] = 1
if r < n - 1 and c > 0 and c < m - 1:
counters[r][c] += min([counters[r+1][c-1], counters[r+1][c], counters[r+1][c+1]])
ans += counters[r][c]
print(ans)
``` | instruction | 0 | 61,694 | 23 | 123,388 |
Yes | output | 1 | 61,694 | 23 | 123,389 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Holidays are coming up really soon. Rick realized that it's time to think about buying a traditional spruce tree. But Rick doesn't want real trees to get hurt so he decided to find some in an n × m matrix consisting of "*" and ".".
<image>
To find every spruce first let's define what a spruce in the matrix is. A set of matrix cells is called a spruce of height k with origin at point (x, y) if:
* All cells in the set contain an "*".
* For each 1 ≤ i ≤ k all cells with the row number x+i-1 and columns in range [y - i + 1, y + i - 1] must be a part of the set. All other cells cannot belong to the set.
Examples of correct and incorrect spruce trees:
<image>
Now Rick wants to know how many spruces his n × m matrix contains. Help Rick solve this problem.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10).
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 500) — matrix size.
Next n lines of each test case contain m characters c_{i, j} — matrix contents. It is guaranteed that c_{i, j} is either a "." or an "*".
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 500^2 (∑ n ⋅ m ≤ 500^2).
Output
For each test case, print single integer — the total number of spruces in the matrix.
Example
Input
4
2 3
.*.
***
2 3
.*.
**.
4 5
.***.
*****
*****
*.*.*
5 7
..*.*..
.*****.
*******
.*****.
..*.*..
Output
5
3
23
34
Note
In the first test case the first spruce of height 2 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (1, 2), the third spruce of height 1 has its origin at point (2, 1), the fourth spruce of height 1 has its origin at point (2, 2), the fifth spruce of height 1 has its origin at point (2, 3).
In the second test case the first spruce of height 1 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (2, 1), the third spruce of height 1 has its origin at point (2, 2).
Submitted Solution:
```
def possible_bases_for_all_star(left, right, arr):
if left == right:
return
med = (left + right) // 2
for i in range(left, med):
arr[i] = i - left + 1
for i in range(med, right):
arr[i] = right - i
def possible_bases(n, arr):
bases = [0] * n
j = 0
while j < n and arr[j] == '.':
j += 1
first_star = j
while j < n:
while j < n and arr[j] == '*':
j += 1
possible_bases_for_all_star(first_star, j, bases)
while j < n and arr[j] == '.':
j += 1
first_star = j
return bases
def find_bottom_spruce(m, n, arr):
arr[0] = possible_bases(n, arr[0])
for i in range(1, m):
row = possible_bases(n, arr[i])
for j in range(n):
arr[i][j] = min(row[j], arr[i - 1][j] + 1)
def find_spruce(m, n, arr):
find_bottom_spruce(m, n, arr)
return sum(list(map(sum, arr)))
t = int(input())
for i in range(t):
m, n = tuple(map(int, input().split(' ')))
field = [list(input()) for j in range(m)]
print(find_spruce(m, n, field))
``` | instruction | 0 | 61,695 | 23 | 123,390 |
No | output | 1 | 61,695 | 23 | 123,391 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Holidays are coming up really soon. Rick realized that it's time to think about buying a traditional spruce tree. But Rick doesn't want real trees to get hurt so he decided to find some in an n × m matrix consisting of "*" and ".".
<image>
To find every spruce first let's define what a spruce in the matrix is. A set of matrix cells is called a spruce of height k with origin at point (x, y) if:
* All cells in the set contain an "*".
* For each 1 ≤ i ≤ k all cells with the row number x+i-1 and columns in range [y - i + 1, y + i - 1] must be a part of the set. All other cells cannot belong to the set.
Examples of correct and incorrect spruce trees:
<image>
Now Rick wants to know how many spruces his n × m matrix contains. Help Rick solve this problem.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10).
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 500) — matrix size.
Next n lines of each test case contain m characters c_{i, j} — matrix contents. It is guaranteed that c_{i, j} is either a "." or an "*".
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 500^2 (∑ n ⋅ m ≤ 500^2).
Output
For each test case, print single integer — the total number of spruces in the matrix.
Example
Input
4
2 3
.*.
***
2 3
.*.
**.
4 5
.***.
*****
*****
*.*.*
5 7
..*.*..
.*****.
*******
.*****.
..*.*..
Output
5
3
23
34
Note
In the first test case the first spruce of height 2 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (1, 2), the third spruce of height 1 has its origin at point (2, 1), the fourth spruce of height 1 has its origin at point (2, 2), the fifth spruce of height 1 has its origin at point (2, 3).
In the second test case the first spruce of height 1 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (2, 1), the third spruce of height 1 has its origin at point (2, 2).
Submitted Solution:
```
def isTrue(i,j,k,l):
t=j
while(t<=k):
if(l[i][t] != '*'):
return False
t+=1
return True
for _ in range(int(input())):
n,m = map(int,input().split())
l = []
ans=0
for i in range(n):
l.append(input())
#print(l)
for i in range(n):
for j in range(m):
col = j
row = i+1
dec=1
if l[i][j] == "*":
ans+=1
while(row < n and (col - dec >= 0 and col +dec< m)):
if isTrue(row,col-dec,col+dec,l):
print(row,' = row',col-dec,' = col-dec',col+dec,' = col+dec')
ans+=1
dec+=1
row+=1
print(ans)
``` | instruction | 0 | 61,696 | 23 | 123,392 |
No | output | 1 | 61,696 | 23 | 123,393 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Holidays are coming up really soon. Rick realized that it's time to think about buying a traditional spruce tree. But Rick doesn't want real trees to get hurt so he decided to find some in an n × m matrix consisting of "*" and ".".
<image>
To find every spruce first let's define what a spruce in the matrix is. A set of matrix cells is called a spruce of height k with origin at point (x, y) if:
* All cells in the set contain an "*".
* For each 1 ≤ i ≤ k all cells with the row number x+i-1 and columns in range [y - i + 1, y + i - 1] must be a part of the set. All other cells cannot belong to the set.
Examples of correct and incorrect spruce trees:
<image>
Now Rick wants to know how many spruces his n × m matrix contains. Help Rick solve this problem.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10).
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 500) — matrix size.
Next n lines of each test case contain m characters c_{i, j} — matrix contents. It is guaranteed that c_{i, j} is either a "." or an "*".
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 500^2 (∑ n ⋅ m ≤ 500^2).
Output
For each test case, print single integer — the total number of spruces in the matrix.
Example
Input
4
2 3
.*.
***
2 3
.*.
**.
4 5
.***.
*****
*****
*.*.*
5 7
..*.*..
.*****.
*******
.*****.
..*.*..
Output
5
3
23
34
Note
In the first test case the first spruce of height 2 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (1, 2), the third spruce of height 1 has its origin at point (2, 1), the fourth spruce of height 1 has its origin at point (2, 2), the fifth spruce of height 1 has its origin at point (2, 3).
In the second test case the first spruce of height 1 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (2, 1), the third spruce of height 1 has its origin at point (2, 2).
Submitted Solution:
```
def main():
for _ in range(int(input())):
n,m = map(int,input().split())
mm = []
ans = 0
for i in range(n):
s = input()
l = []
for j in s:
if(j == '.'):
l.append(0)
else:
l.append(1)
mm.append(l)
for i in range(n-1,-1,-1):
if(i-1 >= 0):
for j in range(1,m-1):
if(mm[i][j] > 0):
if(mm[i][j-1] > 0 and mm[i][j+1] > 0):
if(mm[i][j-1] != mm[i][j+1]):
mm[i-1][j] += 1
else:
mm[i-1][j] += mm[i][j-1]
ans = 0
for l in mm:
ans += sum(l)
print(ans)
main()
``` | instruction | 0 | 61,697 | 23 | 123,394 |
No | output | 1 | 61,697 | 23 | 123,395 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Holidays are coming up really soon. Rick realized that it's time to think about buying a traditional spruce tree. But Rick doesn't want real trees to get hurt so he decided to find some in an n × m matrix consisting of "*" and ".".
<image>
To find every spruce first let's define what a spruce in the matrix is. A set of matrix cells is called a spruce of height k with origin at point (x, y) if:
* All cells in the set contain an "*".
* For each 1 ≤ i ≤ k all cells with the row number x+i-1 and columns in range [y - i + 1, y + i - 1] must be a part of the set. All other cells cannot belong to the set.
Examples of correct and incorrect spruce trees:
<image>
Now Rick wants to know how many spruces his n × m matrix contains. Help Rick solve this problem.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10).
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 500) — matrix size.
Next n lines of each test case contain m characters c_{i, j} — matrix contents. It is guaranteed that c_{i, j} is either a "." or an "*".
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 500^2 (∑ n ⋅ m ≤ 500^2).
Output
For each test case, print single integer — the total number of spruces in the matrix.
Example
Input
4
2 3
.*.
***
2 3
.*.
**.
4 5
.***.
*****
*****
*.*.*
5 7
..*.*..
.*****.
*******
.*****.
..*.*..
Output
5
3
23
34
Note
In the first test case the first spruce of height 2 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (1, 2), the third spruce of height 1 has its origin at point (2, 1), the fourth spruce of height 1 has its origin at point (2, 2), the fifth spruce of height 1 has its origin at point (2, 3).
In the second test case the first spruce of height 1 has its origin at point (1, 2), the second spruce of height 1 has its origin at point (2, 1), the third spruce of height 1 has its origin at point (2, 2).
Submitted Solution:
```
t= int(input())
for _ in range(t):
grid = []
n,m =map(int,input().split())
for i in range(n):
grid.append(input())
ans= 0
for i in range(n):
for j in range(m):
if grid[i][j]=='*':
ans+=1
tree = [-1, 0, 1]
for k in range(i+1,i+3):
if k>n-1:break
flag = 0
for l in tree:
if j+l> m-1 or j+l<0:break
if grid[k][j+l]!='*':
break
else: flag+=1
if flag==0: break
else:ans+=flag;tree=[-2,-1,0,1,2]
print(ans)
``` | instruction | 0 | 61,698 | 23 | 123,396 |
No | output | 1 | 61,698 | 23 | 123,397 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Omkar's most recent follower, Ajit, has entered the Holy Forest. Ajit realizes that Omkar's forest is an n by m grid (1 ≤ n, m ≤ 2000) of some non-negative integers. Since the forest is blessed by Omkar, it satisfies some special conditions:
1. For any two adjacent (sharing a side) cells, the absolute value of the difference of numbers in them is at most 1.
2. If the number in some cell is strictly larger than 0, it should be strictly greater than the number in at least one of the cells adjacent to it.
Unfortunately, Ajit is not fully worthy of Omkar's powers yet. He sees each cell as a "0" or a "#". If a cell is labeled as "0", then the number in it must equal 0. Otherwise, the number in it can be any nonnegative integer.
Determine how many different assignments of elements exist such that these special conditions are satisfied. Two assignments are considered different if there exists at least one cell such that the numbers written in it in these assignments are different. Since the answer may be enormous, find the answer modulo 10^9+7.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 2000, nm ≥ 2) – the dimensions of the forest.
n lines follow, each consisting of one string of m characters. Each of these characters is either a "0" or a "#".
It is guaranteed that the sum of n over all test cases does not exceed 2000 and the sum of m over all test cases does not exceed 2000.
Output
For each test case, print one integer: the number of valid configurations modulo 10^9+7.
Example
Input
4
3 4
0000
00#0
0000
2 1
#
#
1 2
##
6 29
#############################
#000##0###0##0#0####0####000#
#0#0##00#00##00####0#0###0#0#
#0#0##0#0#0##00###00000##00##
#000##0###0##0#0##0###0##0#0#
#############################
Output
2
3
3
319908071
Note
For the first test case, the two valid assignments are
0000\\\ 0000\\\ 0000
and
0000\\\ 0010\\\ 0000
Submitted Solution:
```
for _ in range(int(input())):n,m=map(int,input().split());s=sum(input().count('#')for _ in range(n));print(pow(2,s,10**9+7)-(s==n*m))
``` | instruction | 0 | 61,717 | 23 | 123,434 |
Yes | output | 1 | 61,717 | 23 | 123,435 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Omkar's most recent follower, Ajit, has entered the Holy Forest. Ajit realizes that Omkar's forest is an n by m grid (1 ≤ n, m ≤ 2000) of some non-negative integers. Since the forest is blessed by Omkar, it satisfies some special conditions:
1. For any two adjacent (sharing a side) cells, the absolute value of the difference of numbers in them is at most 1.
2. If the number in some cell is strictly larger than 0, it should be strictly greater than the number in at least one of the cells adjacent to it.
Unfortunately, Ajit is not fully worthy of Omkar's powers yet. He sees each cell as a "0" or a "#". If a cell is labeled as "0", then the number in it must equal 0. Otherwise, the number in it can be any nonnegative integer.
Determine how many different assignments of elements exist such that these special conditions are satisfied. Two assignments are considered different if there exists at least one cell such that the numbers written in it in these assignments are different. Since the answer may be enormous, find the answer modulo 10^9+7.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 2000, nm ≥ 2) – the dimensions of the forest.
n lines follow, each consisting of one string of m characters. Each of these characters is either a "0" or a "#".
It is guaranteed that the sum of n over all test cases does not exceed 2000 and the sum of m over all test cases does not exceed 2000.
Output
For each test case, print one integer: the number of valid configurations modulo 10^9+7.
Example
Input
4
3 4
0000
00#0
0000
2 1
#
#
1 2
##
6 29
#############################
#000##0###0##0#0####0####000#
#0#0##00#00##00####0#0###0#0#
#0#0##0#0#0##00###00000##00##
#000##0###0##0#0##0###0##0#0#
#############################
Output
2
3
3
319908071
Note
For the first test case, the two valid assignments are
0000\\\ 0000\\\ 0000
and
0000\\\ 0010\\\ 0000
Submitted Solution:
```
i=input
for _ in [1]*int(i()):n,m=map(int,i().split());s=sum(i().count('#')for _ in[1]*n);print(pow(2,s,10**9+7)-(s==n*m))
``` | instruction | 0 | 61,718 | 23 | 123,436 |
Yes | output | 1 | 61,718 | 23 | 123,437 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Omkar's most recent follower, Ajit, has entered the Holy Forest. Ajit realizes that Omkar's forest is an n by m grid (1 ≤ n, m ≤ 2000) of some non-negative integers. Since the forest is blessed by Omkar, it satisfies some special conditions:
1. For any two adjacent (sharing a side) cells, the absolute value of the difference of numbers in them is at most 1.
2. If the number in some cell is strictly larger than 0, it should be strictly greater than the number in at least one of the cells adjacent to it.
Unfortunately, Ajit is not fully worthy of Omkar's powers yet. He sees each cell as a "0" or a "#". If a cell is labeled as "0", then the number in it must equal 0. Otherwise, the number in it can be any nonnegative integer.
Determine how many different assignments of elements exist such that these special conditions are satisfied. Two assignments are considered different if there exists at least one cell such that the numbers written in it in these assignments are different. Since the answer may be enormous, find the answer modulo 10^9+7.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 2000, nm ≥ 2) – the dimensions of the forest.
n lines follow, each consisting of one string of m characters. Each of these characters is either a "0" or a "#".
It is guaranteed that the sum of n over all test cases does not exceed 2000 and the sum of m over all test cases does not exceed 2000.
Output
For each test case, print one integer: the number of valid configurations modulo 10^9+7.
Example
Input
4
3 4
0000
00#0
0000
2 1
#
#
1 2
##
6 29
#############################
#000##0###0##0#0####0####000#
#0#0##00#00##00####0#0###0#0#
#0#0##0#0#0##00###00000##00##
#000##0###0##0#0##0###0##0#0#
#############################
Output
2
3
3
319908071
Note
For the first test case, the two valid assignments are
0000\\\ 0000\\\ 0000
and
0000\\\ 0010\\\ 0000
Submitted Solution:
```
import os,io,sys
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r") ; sys.stdout = open("output.txt","w")
# else:
# input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def power(x, y, p) :
res = 1
x = x % p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) :
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
for _ in range(int(input())):
n,m = [int(X) for X in input().split()];aaa = 0
for i in range(n):
x = input();aaa+=x.count('#')
print(power(2,aaa,int(1e9+7)) - (1 if aaa==n*m else 0))
``` | instruction | 0 | 61,719 | 23 | 123,438 |
Yes | output | 1 | 61,719 | 23 | 123,439 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Omkar's most recent follower, Ajit, has entered the Holy Forest. Ajit realizes that Omkar's forest is an n by m grid (1 ≤ n, m ≤ 2000) of some non-negative integers. Since the forest is blessed by Omkar, it satisfies some special conditions:
1. For any two adjacent (sharing a side) cells, the absolute value of the difference of numbers in them is at most 1.
2. If the number in some cell is strictly larger than 0, it should be strictly greater than the number in at least one of the cells adjacent to it.
Unfortunately, Ajit is not fully worthy of Omkar's powers yet. He sees each cell as a "0" or a "#". If a cell is labeled as "0", then the number in it must equal 0. Otherwise, the number in it can be any nonnegative integer.
Determine how many different assignments of elements exist such that these special conditions are satisfied. Two assignments are considered different if there exists at least one cell such that the numbers written in it in these assignments are different. Since the answer may be enormous, find the answer modulo 10^9+7.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 2000, nm ≥ 2) – the dimensions of the forest.
n lines follow, each consisting of one string of m characters. Each of these characters is either a "0" or a "#".
It is guaranteed that the sum of n over all test cases does not exceed 2000 and the sum of m over all test cases does not exceed 2000.
Output
For each test case, print one integer: the number of valid configurations modulo 10^9+7.
Example
Input
4
3 4
0000
00#0
0000
2 1
#
#
1 2
##
6 29
#############################
#000##0###0##0#0####0####000#
#0#0##00#00##00####0#0###0#0#
#0#0##0#0#0##00###00000##00##
#000##0###0##0#0##0###0##0#0#
#############################
Output
2
3
3
319908071
Note
For the first test case, the two valid assignments are
0000\\\ 0000\\\ 0000
and
0000\\\ 0010\\\ 0000
Submitted Solution:
```
t=int(input())
for w in range(t):
inp=input().split()
n=int(inp[0])
m=int(inp[1])
count=0
for i in range(n):
inp=input()
for j in inp:
if j=='#':
count+=1
p=(2**count)%(10**9+7)
if n*m==count:
p=p-1
print(p)
``` | instruction | 0 | 61,720 | 23 | 123,440 |
Yes | output | 1 | 61,720 | 23 | 123,441 |
Provide a correct Python 3 solution for this coding contest problem.
There is a triangle formed by three points $(x_1, y_1)$, $(x_2, y_2)$, $(x_3, y_3)$ on a plain.
Write a program which prints "YES" if a point $P$ $(x_p, y_p)$ is in the triangle and "NO" if not.
Constraints
You can assume that:
* $ -100 \leq x_1, y_1, x_2, y_2, x_3, y_3, x_p, y_p \leq 100$
* 1.0 $\leq$ Length of each side of a tringle
* 0.001 $\leq$ Distance between $P$ and each side of a triangle
Input
Input consists of several datasets. Each dataset consists of:
$x_1$ $y_1$ $x_2$ $y_2$ $x_3$ $y_3$ $x_p$ $y_p$
All the input are real numbers. Input ends with EOF. The number of datasets is less than or equal to 100.
Output
For each dataset, print "YES" or "NO" in a line.
Example
Input
0.0 0.0 2.0 0.0 2.0 2.0 1.5 0.5
0.0 0.0 1.0 4.0 5.0 3.0 -1.0 3.0
Output
YES
NO | instruction | 0 | 62,173 | 23 | 124,346 |
"Correct Solution:
```
import math
import cmath
def dot(a:complex,b:complex):
return (a.conjugate()*b).real
def cross(a:complex,b:complex):
return (a.conjugate()*b).imag
next=[1,2,0]
try:
while True:
l=list(map(float,input().split()))
p=[complex(l[2*j],l[2*j+1]) for j in range(4)]
flg_ans=True
sgn=1 if cross(p[0]-p[3],p[1]-p[3])>0 else -1
for i in range(3):
flg_ans=flg_ans and (sgn*cross(p[i]-p[3],p[next[i]]-p[3]))>0
print('YES' if flg_ans else 'NO')
except EOFError:
pass
``` | output | 1 | 62,173 | 23 | 124,347 |
Provide a correct Python 3 solution for this coding contest problem.
There is a triangle formed by three points $(x_1, y_1)$, $(x_2, y_2)$, $(x_3, y_3)$ on a plain.
Write a program which prints "YES" if a point $P$ $(x_p, y_p)$ is in the triangle and "NO" if not.
Constraints
You can assume that:
* $ -100 \leq x_1, y_1, x_2, y_2, x_3, y_3, x_p, y_p \leq 100$
* 1.0 $\leq$ Length of each side of a tringle
* 0.001 $\leq$ Distance between $P$ and each side of a triangle
Input
Input consists of several datasets. Each dataset consists of:
$x_1$ $y_1$ $x_2$ $y_2$ $x_3$ $y_3$ $x_p$ $y_p$
All the input are real numbers. Input ends with EOF. The number of datasets is less than or equal to 100.
Output
For each dataset, print "YES" or "NO" in a line.
Example
Input
0.0 0.0 2.0 0.0 2.0 2.0 1.5 0.5
0.0 0.0 1.0 4.0 5.0 3.0 -1.0 3.0
Output
YES
NO | instruction | 0 | 62,174 | 23 | 124,348 |
"Correct Solution:
```
import math
import sys
def get_triangle_area(x1, y1, x2, y2, x3, y3):
l1 = math.sqrt(abs(x1-x2)**2+abs(y1-y2)**2)
l2 = math.sqrt(abs(x2-x3)**2+abs(y2-y3)**2)
l3 = math.sqrt(abs(x3-x1)**2+abs(y3-y1)**2)
s = (l1+l2+l3)/2
return math.sqrt(s*(s-l1)*(s-l2)*(s-l3))
for l in sys.stdin:
x1, y1, x2, y2, x3, y3, xp, yp = map(float, l.split())
s1 = get_triangle_area(x1, y1, x2, y2, x3, y3)
s2 = get_triangle_area(xp, yp, x1, y1, x2, y2)
s2 += get_triangle_area(xp, yp, x2, y2, x3, y3)
s2 += get_triangle_area(xp, yp, x3, y3, x1, y1)
print("YES" if round(s1, 5) == round(s2, 5) else "NO")
``` | output | 1 | 62,174 | 23 | 124,349 |
Provide a correct Python 3 solution for this coding contest problem.
There is a triangle formed by three points $(x_1, y_1)$, $(x_2, y_2)$, $(x_3, y_3)$ on a plain.
Write a program which prints "YES" if a point $P$ $(x_p, y_p)$ is in the triangle and "NO" if not.
Constraints
You can assume that:
* $ -100 \leq x_1, y_1, x_2, y_2, x_3, y_3, x_p, y_p \leq 100$
* 1.0 $\leq$ Length of each side of a tringle
* 0.001 $\leq$ Distance between $P$ and each side of a triangle
Input
Input consists of several datasets. Each dataset consists of:
$x_1$ $y_1$ $x_2$ $y_2$ $x_3$ $y_3$ $x_p$ $y_p$
All the input are real numbers. Input ends with EOF. The number of datasets is less than or equal to 100.
Output
For each dataset, print "YES" or "NO" in a line.
Example
Input
0.0 0.0 2.0 0.0 2.0 2.0 1.5 0.5
0.0 0.0 1.0 4.0 5.0 3.0 -1.0 3.0
Output
YES
NO | instruction | 0 | 62,175 | 23 | 124,350 |
"Correct Solution:
```
# ２点(a, b) (c, d)を通る直線の傾きと切片を返す
def func(a, b, c, d):
k = (d - b) / (c - a)
h = d - k * c
return k, h
# ２点と通る直線のf(x)を返す
def fx(a, b, c, d, x):
k, h = func(a, b, c, d)
return k * x + h
def main():
import sys
for dataset in sys.stdin:
ans = 'NO'
try :
a, b, c, d, e, f, px, py = map(float, dataset.split())
except:
break
T = [(a, b), (c, d), (e, f)]
T.sort(key=lambda x: (x[0], x[1]))
a, b, c, d, e, f = T[0][0], T[0][1], T[1][0], T[1][1], T[2][0], T[2][1]
# 共通なxを持つ２点が存在するか判定し、する場合
if a == c:
if a < px and fx(a, b, e, f, px) < py and fx(c, d, e, f, px) > py:
ans = 'YES'
elif c == e:
if px < e and fx(a, b, c, d, px) < py and fx(a, b, e, f, px) > py:
ans = 'YES'
else: # ３点において共通のxを持たない場合
if fx(a, b, e, f, c) < d: # 中間点が残り２点を通る直線より上にあるケース
if fx(a, b, c, d, px) > py and fx(c, d, e, f, px) > py and fx(a, b, e, f, px) < py:
ans = 'YES'
else:
if fx(a, b, c, d, px) < py and fx(c, d, e, f, px) < py and fx(a, b, e, f, px) > py:
ans = 'YES'
print(ans)
if __name__ == '__main__':
main()
``` | output | 1 | 62,175 | 23 | 124,351 |
Provide a correct Python 3 solution for this coding contest problem.
There is a triangle formed by three points $(x_1, y_1)$, $(x_2, y_2)$, $(x_3, y_3)$ on a plain.
Write a program which prints "YES" if a point $P$ $(x_p, y_p)$ is in the triangle and "NO" if not.
Constraints
You can assume that:
* $ -100 \leq x_1, y_1, x_2, y_2, x_3, y_3, x_p, y_p \leq 100$
* 1.0 $\leq$ Length of each side of a tringle
* 0.001 $\leq$ Distance between $P$ and each side of a triangle
Input
Input consists of several datasets. Each dataset consists of:
$x_1$ $y_1$ $x_2$ $y_2$ $x_3$ $y_3$ $x_p$ $y_p$
All the input are real numbers. Input ends with EOF. The number of datasets is less than or equal to 100.
Output
For each dataset, print "YES" or "NO" in a line.
Example
Input
0.0 0.0 2.0 0.0 2.0 2.0 1.5 0.5
0.0 0.0 1.0 4.0 5.0 3.0 -1.0 3.0
Output
YES
NO | instruction | 0 | 62,176 | 23 | 124,352 |
"Correct Solution:
```
def getTriangleArea(x1, y1, x2, y2, x3, y3): # returns the area of triangle determined by provided 3 points
ux = x2-x1
uy = y2-y1
vx = x3-x1
vy = y3-y1
return abs(ux*vy-vx*uy)/2
inputs=[]
while True:
try:
inputs.append(list(map(float,input().split())))
except EOFError:
break
for i in inputs:
x1, y1, x2, y2, x3, y3, xp, yp = i
if getTriangleArea(x1, y1, x2, y2, x3, y3)==getTriangleArea(x1, y1, x2, y2, xp, yp)+getTriangleArea(x2, y2, x3, y3, xp, yp)+getTriangleArea(x3, y3, x1, y1, xp, yp):
print("YES")
else:
print("NO")
``` | output | 1 | 62,176 | 23 | 124,353 |
Provide a correct Python 3 solution for this coding contest problem.
There is a triangle formed by three points $(x_1, y_1)$, $(x_2, y_2)$, $(x_3, y_3)$ on a plain.
Write a program which prints "YES" if a point $P$ $(x_p, y_p)$ is in the triangle and "NO" if not.
Constraints
You can assume that:
* $ -100 \leq x_1, y_1, x_2, y_2, x_3, y_3, x_p, y_p \leq 100$
* 1.0 $\leq$ Length of each side of a tringle
* 0.001 $\leq$ Distance between $P$ and each side of a triangle
Input
Input consists of several datasets. Each dataset consists of:
$x_1$ $y_1$ $x_2$ $y_2$ $x_3$ $y_3$ $x_p$ $y_p$
All the input are real numbers. Input ends with EOF. The number of datasets is less than or equal to 100.
Output
For each dataset, print "YES" or "NO" in a line.
Example
Input
0.0 0.0 2.0 0.0 2.0 2.0 1.5 0.5
0.0 0.0 1.0 4.0 5.0 3.0 -1.0 3.0
Output
YES
NO | instruction | 0 | 62,177 | 23 | 124,354 |
"Correct Solution:
```
# coding=utf-8
def direction_vector(p1: list, p2: list)->list:
return [p2[0]-p1[0], p2[1]-p1[1]]
def cross_product(v1: list, v2: list)->float:
return v1[0]*v2[1] - v1[1]*v2[0]
if __name__ == '__main__':
while True:
try:
points_receive = list(map(float, input().split()))
except EOFError:
break
points_list = [[points_receive[2*i], points_receive[2 * i + 1]] for i in range(4)]
p1_to_p2 = direction_vector(points_list[0], points_list[1])
p2_to_p3 = direction_vector(points_list[1], points_list[2])
p3_to_p1 = direction_vector(points_list[2], points_list[0])
p1_to_pp = direction_vector(points_list[0], points_list[3])
p2_to_pp = direction_vector(points_list[1], points_list[3])
p3_to_pp = direction_vector(points_list[2], points_list[3])
cp1 = cross_product(p1_to_p2, p1_to_pp)
cp2 = cross_product(p2_to_p3, p2_to_pp)
cp3 = cross_product(p3_to_p1, p3_to_pp)
if cp1 > 0 and cp2 > 0 and cp3 > 0:
print('YES')
elif cp1 < 0 and cp2 < 0 and cp3 < 0:
print('YES')
else:
print('NO')
``` | output | 1 | 62,177 | 23 | 124,355 |
Provide a correct Python 3 solution for this coding contest problem.
There is a triangle formed by three points $(x_1, y_1)$, $(x_2, y_2)$, $(x_3, y_3)$ on a plain.
Write a program which prints "YES" if a point $P$ $(x_p, y_p)$ is in the triangle and "NO" if not.
Constraints
You can assume that:
* $ -100 \leq x_1, y_1, x_2, y_2, x_3, y_3, x_p, y_p \leq 100$
* 1.0 $\leq$ Length of each side of a tringle
* 0.001 $\leq$ Distance between $P$ and each side of a triangle
Input
Input consists of several datasets. Each dataset consists of:
$x_1$ $y_1$ $x_2$ $y_2$ $x_3$ $y_3$ $x_p$ $y_p$
All the input are real numbers. Input ends with EOF. The number of datasets is less than or equal to 100.
Output
For each dataset, print "YES" or "NO" in a line.
Example
Input
0.0 0.0 2.0 0.0 2.0 2.0 1.5 0.5
0.0 0.0 1.0 4.0 5.0 3.0 -1.0 3.0
Output
YES
NO | instruction | 0 | 62,178 | 23 | 124,356 |
"Correct Solution:
```
def r(x1, y1, x2, y2, x3, y3):
return x1*(y2-y3)+x2*(y3-y1)+x3*(y1-y2) > 0
while True:
try:
line = input()
except:
break
x1, y1, x2, y2, x3, y3, xp, yp = map(float, line.strip().split())
abc = r(x1, y1, x2, y2, x3, y3)
pab = r(xp, yp, x1, y1, x2, y2)
pbc = r(xp, yp, x2, y2, x3, y3)
pca = r(xp, yp, x3, y3, x1, y1)
print('YES' if abc == pab == pbc == pca else 'NO')
``` | output | 1 | 62,178 | 23 | 124,357 |
Provide a correct Python 3 solution for this coding contest problem.
There is a triangle formed by three points $(x_1, y_1)$, $(x_2, y_2)$, $(x_3, y_3)$ on a plain.
Write a program which prints "YES" if a point $P$ $(x_p, y_p)$ is in the triangle and "NO" if not.
Constraints
You can assume that:
* $ -100 \leq x_1, y_1, x_2, y_2, x_3, y_3, x_p, y_p \leq 100$
* 1.0 $\leq$ Length of each side of a tringle
* 0.001 $\leq$ Distance between $P$ and each side of a triangle
Input
Input consists of several datasets. Each dataset consists of:
$x_1$ $y_1$ $x_2$ $y_2$ $x_3$ $y_3$ $x_p$ $y_p$
All the input are real numbers. Input ends with EOF. The number of datasets is less than or equal to 100.
Output
For each dataset, print "YES" or "NO" in a line.
Example
Input
0.0 0.0 2.0 0.0 2.0 2.0 1.5 0.5
0.0 0.0 1.0 4.0 5.0 3.0 -1.0 3.0
Output
YES
NO | instruction | 0 | 62,179 | 23 | 124,358 |
"Correct Solution:
```
def cross3(a, b, c):
return (b[0] - a[0])*(c[1] - a[1]) - (b[1] - a[1])*(c[0] - a[0])
for line in open(0).readlines():
x1, y1, x2, y2, x3, y3, xp, yp = map(float, line.split())
p1 = (x1, y1); p2 = (x2, y2); p3 = (x3, y3); pp = (xp, yp)
if cross3(p1, p2, p3) < 0:
p1, p2 = p2, p1
if cross3(p1, p2, pp) > 0 and cross3(p1, pp, p3) > 0 and cross3(p2, p3, pp) > 0:
print("YES")
else:
print("NO")
``` | output | 1 | 62,179 | 23 | 124,359 |
Provide a correct Python 3 solution for this coding contest problem.
There is a triangle formed by three points $(x_1, y_1)$, $(x_2, y_2)$, $(x_3, y_3)$ on a plain.
Write a program which prints "YES" if a point $P$ $(x_p, y_p)$ is in the triangle and "NO" if not.
Constraints
You can assume that:
* $ -100 \leq x_1, y_1, x_2, y_2, x_3, y_3, x_p, y_p \leq 100$
* 1.0 $\leq$ Length of each side of a tringle
* 0.001 $\leq$ Distance between $P$ and each side of a triangle
Input
Input consists of several datasets. Each dataset consists of:
$x_1$ $y_1$ $x_2$ $y_2$ $x_3$ $y_3$ $x_p$ $y_p$
All the input are real numbers. Input ends with EOF. The number of datasets is less than or equal to 100.
Output
For each dataset, print "YES" or "NO" in a line.
Example
Input
0.0 0.0 2.0 0.0 2.0 2.0 1.5 0.5
0.0 0.0 1.0 4.0 5.0 3.0 -1.0 3.0
Output
YES
NO | instruction | 0 | 62,180 | 23 | 124,360 |
"Correct Solution:
```
import sys
for s in sys.stdin:
x1,y1,x2,y2,x3,y3,xp,yp = [ float(x) for x in s.split() ]
v12 = (x2-x1, y2-y1)
v23 = (x3-x2, y3-y2)
v31 = (x1-x3, y1-y3)
v1p = (xp-x1, yp-y1)
v2p = (xp-x2, yp-y2)
v3p = (xp-x3, yp-y3)
cp1 = v12[0]*v1p[1] - v1p[0]*v12[1]
cp2 = v23[0]*v2p[1] - v2p[0]*v23[1]
cp3 = v31[0]*v3p[1] - v3p[0]*v31[1]
if cp1 > 0 and cp2 > 0 and cp3 > 0:
print('YES')
elif cp1 < 0 and cp2 < 0 and cp3 < 0:
print('YES')
else:
print('NO')
``` | output | 1 | 62,180 | 23 | 124,361 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a triangle formed by three points $(x_1, y_1)$, $(x_2, y_2)$, $(x_3, y_3)$ on a plain.
Write a program which prints "YES" if a point $P$ $(x_p, y_p)$ is in the triangle and "NO" if not.
Constraints
You can assume that:
* $ -100 \leq x_1, y_1, x_2, y_2, x_3, y_3, x_p, y_p \leq 100$
* 1.0 $\leq$ Length of each side of a tringle
* 0.001 $\leq$ Distance between $P$ and each side of a triangle
Input
Input consists of several datasets. Each dataset consists of:
$x_1$ $y_1$ $x_2$ $y_2$ $x_3$ $y_3$ $x_p$ $y_p$
All the input are real numbers. Input ends with EOF. The number of datasets is less than or equal to 100.
Output
For each dataset, print "YES" or "NO" in a line.
Example
Input
0.0 0.0 2.0 0.0 2.0 2.0 1.5 0.5
0.0 0.0 1.0 4.0 5.0 3.0 -1.0 3.0
Output
YES
NO
Submitted Solution:
```
def check(x1, y1, x2, y2, xp, yp):
return ((y1 > yp) != (y2 > yp)) and (xp - x1 < (x2 - x1) * (yp - y1) / (y2 - y1))
while True:
try:
x1, y1, x2, y2, x3, y3, xp, yp = map(float, input().split())
except:
break
print('YES' if (check(x1, y1, x2, y2, xp, yp) +
check(x2, y2, x3, y3, xp, yp) +
check(x3, y3, x1, y1, xp, yp)) & 1 else 'NO')
``` | instruction | 0 | 62,181 | 23 | 124,362 |
Yes | output | 1 | 62,181 | 23 | 124,363 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a triangle formed by three points $(x_1, y_1)$, $(x_2, y_2)$, $(x_3, y_3)$ on a plain.
Write a program which prints "YES" if a point $P$ $(x_p, y_p)$ is in the triangle and "NO" if not.
Constraints
You can assume that:
* $ -100 \leq x_1, y_1, x_2, y_2, x_3, y_3, x_p, y_p \leq 100$
* 1.0 $\leq$ Length of each side of a tringle
* 0.001 $\leq$ Distance between $P$ and each side of a triangle
Input
Input consists of several datasets. Each dataset consists of:
$x_1$ $y_1$ $x_2$ $y_2$ $x_3$ $y_3$ $x_p$ $y_p$
All the input are real numbers. Input ends with EOF. The number of datasets is less than or equal to 100.
Output
For each dataset, print "YES" or "NO" in a line.
Example
Input
0.0 0.0 2.0 0.0 2.0 2.0 1.5 0.5
0.0 0.0 1.0 4.0 5.0 3.0 -1.0 3.0
Output
YES
NO
Submitted Solution:
```
class vector(object):
def __init__(self,a,b):
self.x=b.x-a.x
self.y=b.y-a.y
@staticmethod
def cross_product(a,b):
return a.x*b.y-a.y*b.x
class vertex(object):
def __init__(self,a):
self.x=a[0]
self.y=a[1]
class circle(object):
def __init__(self,p,r):
self.px=p.x
self.py=p.y
self.r=r
class triangle(object):
def __init__(self,a,b,c):
self.a=a
self.b=b
self.c=c
import math
self.ab=math.sqrt((self.a.x-self.b.x)**2+(self.a.y-self.b.y)**2)
self.bc=math.sqrt((self.b.x-self.c.x)**2+(self.b.y-self.c.y)**2)
self.ca=math.sqrt((self.c.x-self.a.x)**2+(self.c.y-self.a.y)**2)
c=self.ab
a=self.bc
b=self.ca
self.cosA=(b**2+c**2-a**2)/(2*b*c)
self.cosB=(a**2+c**2-b**2)/(2*a*c)
self.cosC=(b**2+a**2-c**2)/(2*b*a)
self.sinA=math.sqrt(1-self.cosA**2)
self.sinB=math.sqrt(1-self.cosB**2)
self.sinC=math.sqrt(1-self.cosC**2)
self.sin2A=2*self.sinA*self.cosA
self.sin2B=2*self.sinB*self.cosB
self.sin2C=2*self.sinC*self.cosC
def area(self):
import math
s=(self.ab+self.bc+self.ca)/2
S=math.sqrt(s*(s-self.ab)*(s-self.bc)*(s-self.ca))
return S
def circumscribed(self):
R=self.ab/(2*self.sinC)
px=(self.sin2A*self.a.x+self.sin2B*self.b.x+self.sin2C*self.c.x)/(self.sin2A+self.sin2B+self.sin2C)
py=(self.sin2A*self.a.y+self.sin2B*self.b.y+self.sin2C*self.c.y)/(self.sin2A+self.sin2B+self.sin2C)
px=round(px,3)
py=round(py,3)
R=round(R,3)
p=vertex((px,py))
return circle(p,R)
def isin(self,p):
AB=vector(self.a,self.b)
BC=vector(self.b,self.c)
CA=vector(self.c,self.a)
AP=vector(self.a,p)
BP=vector(self.b,p)
CP=vector(self.c,p)
if (vector.cross_product(AB,AP)>0 and vector.cross_product(BC,BP)>0 and vector.cross_product(CA,CP)>0)or(vector.cross_product(AB,AP)<0 and vector.cross_product(BC,BP)<0 and vector.cross_product(CA,CP)<0):
return 'YES'
else:return 'NO'
A=[]
B=[]
C=[]
p=[]
import sys
for line in sys.stdin:
a,b,c,d,e,f,g,h=list(map(float,line.split()))
A.append(vertex((a,b)))
B.append(vertex((c,d)))
C.append(vertex((e,f)))
p.append(vertex((g,h)))
for i in range(len(A)):
Triangle=triangle(A[i],B[i],C[i])
print(Triangle.isin(p[i]))
``` | instruction | 0 | 62,182 | 23 | 124,364 |
Yes | output | 1 | 62,182 | 23 | 124,365 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a triangle formed by three points $(x_1, y_1)$, $(x_2, y_2)$, $(x_3, y_3)$ on a plain.
Write a program which prints "YES" if a point $P$ $(x_p, y_p)$ is in the triangle and "NO" if not.
Constraints
You can assume that:
* $ -100 \leq x_1, y_1, x_2, y_2, x_3, y_3, x_p, y_p \leq 100$
* 1.0 $\leq$ Length of each side of a tringle
* 0.001 $\leq$ Distance between $P$ and each side of a triangle
Input
Input consists of several datasets. Each dataset consists of:
$x_1$ $y_1$ $x_2$ $y_2$ $x_3$ $y_3$ $x_p$ $y_p$
All the input are real numbers. Input ends with EOF. The number of datasets is less than or equal to 100.
Output
For each dataset, print "YES" or "NO" in a line.
Example
Input
0.0 0.0 2.0 0.0 2.0 2.0 1.5 0.5
0.0 0.0 1.0 4.0 5.0 3.0 -1.0 3.0
Output
YES
NO
Submitted Solution:
```
import math
class Point():
def __init__(self, x, y):
self.x = x
self.y = y
def CP(p1, p2, p3):
ax = p2.x-p1.x
ay = p2.y-p1.y
bx = p3.x-p1.x
by = p3.y-p1.y
return ax*by - ay*bx
def Judge(a,b,c):
if a > 0 and b > 0 and c > 0:
print("YES")
elif a < 0 and b < 0 and c < 0:
print("YES")
else:
print("NO")
def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
N = list(get_input())
for l in range(len(N)):
x1,y1,x2,y2,x3,y3,xp,yp = [float(i) for i in N[l].split()]
P1 = Point(x1,y1)
P2 = Point(x2,y2)
P3 = Point(x3,y3)
PP = Point(xp,yp)
cp1 = CP(PP, P1, P2)
cp2 = CP(PP, P2, P3)
cp3 = CP(PP, P3, P1)
Judge(cp1,cp2,cp3)
``` | instruction | 0 | 62,183 | 23 | 124,366 |
Yes | output | 1 | 62,183 | 23 | 124,367 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a triangle formed by three points $(x_1, y_1)$, $(x_2, y_2)$, $(x_3, y_3)$ on a plain.
Write a program which prints "YES" if a point $P$ $(x_p, y_p)$ is in the triangle and "NO" if not.
Constraints
You can assume that:
* $ -100 \leq x_1, y_1, x_2, y_2, x_3, y_3, x_p, y_p \leq 100$
* 1.0 $\leq$ Length of each side of a tringle
* 0.001 $\leq$ Distance between $P$ and each side of a triangle
Input
Input consists of several datasets. Each dataset consists of:
$x_1$ $y_1$ $x_2$ $y_2$ $x_3$ $y_3$ $x_p$ $y_p$
All the input are real numbers. Input ends with EOF. The number of datasets is less than or equal to 100.
Output
For each dataset, print "YES" or "NO" in a line.
Example
Input
0.0 0.0 2.0 0.0 2.0 2.0 1.5 0.5
0.0 0.0 1.0 4.0 5.0 3.0 -1.0 3.0
Output
YES
NO
Submitted Solution:
```
# -*- coding:utf-8 -*-
def main():
while True:
try:
ax,ay,bx,by,cx,cy,px,py=map(float,input().split())
A=(bx-ax)*(py-ay)-(by-ay)*(px-ax)
B=(cx-bx)*(py-by)-(cy-by)*(px-bx)
C=(ax-cx)*(py-cy)-(ay-cy)*(px-cx)
if ((A<=0)and(B<=0)and(C<=0))or((A>0)and(B>0)and(C>0)):
print("YES")
else:
print("NO")
except:
break
if __name__ == '__main__':
main()
``` | instruction | 0 | 62,184 | 23 | 124,368 |
Yes | output | 1 | 62,184 | 23 | 124,369 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a triangle formed by three points $(x_1, y_1)$, $(x_2, y_2)$, $(x_3, y_3)$ on a plain.
Write a program which prints "YES" if a point $P$ $(x_p, y_p)$ is in the triangle and "NO" if not.
Constraints
You can assume that:
* $ -100 \leq x_1, y_1, x_2, y_2, x_3, y_3, x_p, y_p \leq 100$
* 1.0 $\leq$ Length of each side of a tringle
* 0.001 $\leq$ Distance between $P$ and each side of a triangle
Input
Input consists of several datasets. Each dataset consists of:
$x_1$ $y_1$ $x_2$ $y_2$ $x_3$ $y_3$ $x_p$ $y_p$
All the input are real numbers. Input ends with EOF. The number of datasets is less than or equal to 100.
Output
For each dataset, print "YES" or "NO" in a line.
Example
Input
0.0 0.0 2.0 0.0 2.0 2.0 1.5 0.5
0.0 0.0 1.0 4.0 5.0 3.0 -1.0 3.0
Output
YES
NO
Submitted Solution:
```
import math
def lm(x,y,xa,ya,xb,yb):
if (xb-xa)==0:return abs(x-xb)
d=(yb-ya)/(xb-xa)
return abs(d*xa+xa - y + d*x) / math.hypot(d,-1)
while True:
r=input()
if r=="":break
x1,y1,x2,y2,x3,y3,xp,yp=[float(i) for i in r.split()]
a=bool(lm(x1,y1,x2,y2,x3,y3)<lm(xp,yp,x2,y2,x3,y3))
b=bool(lm(x2,y2,x1,y1,x3,y3)<lm(xp,yp,x1,y1,x3,y3))
c=bool(lm(x3,y3,x1,y1,x2,y2)<lm(xp,yp,x1,y1,x2,y2))
if a or b or c:
print("NO")
else:
print("YES")
``` | instruction | 0 | 62,185 | 23 | 124,370 |
No | output | 1 | 62,185 | 23 | 124,371 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a triangle formed by three points $(x_1, y_1)$, $(x_2, y_2)$, $(x_3, y_3)$ on a plain.
Write a program which prints "YES" if a point $P$ $(x_p, y_p)$ is in the triangle and "NO" if not.
Constraints
You can assume that:
* $ -100 \leq x_1, y_1, x_2, y_2, x_3, y_3, x_p, y_p \leq 100$
* 1.0 $\leq$ Length of each side of a tringle
* 0.001 $\leq$ Distance between $P$ and each side of a triangle
Input
Input consists of several datasets. Each dataset consists of:
$x_1$ $y_1$ $x_2$ $y_2$ $x_3$ $y_3$ $x_p$ $y_p$
All the input are real numbers. Input ends with EOF. The number of datasets is less than or equal to 100.
Output
For each dataset, print "YES" or "NO" in a line.
Example
Input
0.0 0.0 2.0 0.0 2.0 2.0 1.5 0.5
0.0 0.0 1.0 4.0 5.0 3.0 -1.0 3.0
Output
YES
NO
Submitted Solution:
```
import math
class Triangle:
def __init__(self, x1, y1, x2, y2, x3, y3):
self.x1 = x1
self.x2 = x2
self.x3 = x3
self.y1 = y1
self.y2 = y2
self.y3 = y3
self.a = math.sqrt((x1-x2) ** 2 + (y1 - y2) ** 2)
self.b = math.sqrt((x2-x3) ** 2 + (y2 - y3) ** 2)
self.c = math.sqrt((x1-x3) ** 2 + (y1 - y3) ** 2)
def get_acos_a(self):
val = (-self.a ** 2 + self.b ** 2 + self.c ** 2) / (2 * self.b * self.c)
return math.acos(val)
while(1):
try:
x1, y1, x2, y2, x3, y3, xp, yp = list(map(float, input().split()))
t1 = Triangle(x1, y1, x2, y2, xp, yp)
t2 = Triangle(x2, y2, x3, y3, xp, yp)
t3 = Triangle(x3, y3, x1, y1, xp, yp)
if 6.283 <= t1.get_acos_a() + t2.get_acos_a() + t3.get_acos_a() <= 6.284:
print("YES")
else:
print("NO")
except:
break
``` | instruction | 0 | 62,186 | 23 | 124,372 |
No | output | 1 | 62,186 | 23 | 124,373 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a triangle formed by three points $(x_1, y_1)$, $(x_2, y_2)$, $(x_3, y_3)$ on a plain.
Write a program which prints "YES" if a point $P$ $(x_p, y_p)$ is in the triangle and "NO" if not.
Constraints
You can assume that:
* $ -100 \leq x_1, y_1, x_2, y_2, x_3, y_3, x_p, y_p \leq 100$
* 1.0 $\leq$ Length of each side of a tringle
* 0.001 $\leq$ Distance between $P$ and each side of a triangle
Input
Input consists of several datasets. Each dataset consists of:
$x_1$ $y_1$ $x_2$ $y_2$ $x_3$ $y_3$ $x_p$ $y_p$
All the input are real numbers. Input ends with EOF. The number of datasets is less than or equal to 100.
Output
For each dataset, print "YES" or "NO" in a line.
Example
Input
0.0 0.0 2.0 0.0 2.0 2.0 1.5 0.5
0.0 0.0 1.0 4.0 5.0 3.0 -1.0 3.0
Output
YES
NO
Submitted Solution:
```
length=[float(0) for i in range(3)]
while 1:
try:
x1,y1,x2,y2,x3,y3,x4,y4=[float(i) for i in input().split( )]
len1=(x1-x2)**2+(y1-y2)**2
len2=(x2-x3)**2+(y2-y3)**2
len3=(x3-x1)**2+(y3-y1)**2
length[0]=(x1-x4)**2+(y1-y4)**2
length[1]=(x2-x4)**2+(y2-y4)**2
length[2]=(x3-x4)**2+(y3-y4)**2
if ((max(length)>len1)and(max(length)>len2)and(max(length)>len3)):
print("NO")
else:
print("YES")
except EOFError:
break
``` | instruction | 0 | 62,187 | 23 | 124,374 |
No | output | 1 | 62,187 | 23 | 124,375 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a triangle formed by three points $(x_1, y_1)$, $(x_2, y_2)$, $(x_3, y_3)$ on a plain.
Write a program which prints "YES" if a point $P$ $(x_p, y_p)$ is in the triangle and "NO" if not.
Constraints
You can assume that:
* $ -100 \leq x_1, y_1, x_2, y_2, x_3, y_3, x_p, y_p \leq 100$
* 1.0 $\leq$ Length of each side of a tringle
* 0.001 $\leq$ Distance between $P$ and each side of a triangle
Input
Input consists of several datasets. Each dataset consists of:
$x_1$ $y_1$ $x_2$ $y_2$ $x_3$ $y_3$ $x_p$ $y_p$
All the input are real numbers. Input ends with EOF. The number of datasets is less than or equal to 100.
Output
For each dataset, print "YES" or "NO" in a line.
Example
Input
0.0 0.0 2.0 0.0 2.0 2.0 1.5 0.5
0.0 0.0 1.0 4.0 5.0 3.0 -1.0 3.0
Output
YES
NO
Submitted Solution:
```
import math
while True:
try:
x1, y1, x2, y2, x3, y3, xp, yp = map(float, input().split())
x = [x1, x3, x3, x1]
y = [y1, y2, y3, y1]
x = list(map(lambda x:x-xp, x))
y = list(map(lambda y:y-yp, y))
cos = lambda a1,a2,b1,b2:(a1*b1+a2*b2)/((a1**2+a2**2)**0.5*(b1**2+b2**2)**0.5)
if sum(math.acos(cos(x[i], y[i], x[i+1], y[i+1])) for i in range(3)) <= 2 * math.pi:
print('NO')
else:
print('YES')
except:
break
``` | instruction | 0 | 62,188 | 23 | 124,376 |
No | output | 1 | 62,188 | 23 | 124,377 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
F - Point Distance
Problem Statement
You work for invention center as a part time programmer. This center researches movement of protein molecules. It needs how molecules make clusters, so it will calculate distance of all pair molecules and will make a histogram. Molecules’ positions are given by a N x N grid map. Value C_{xy} of cell (x, y) in a grid map means that C_{xy} molecules are in the position (x, y).
You are given a grid map, please calculate histogram of all pair molecules.
Input
Input is formatted as follows.
N
C_{11} C_{12} ... C_{1N}
C_{21} C_{22} ... C_{2N}
...
C_{N1} C_{N2} ... C_{NN}
First line contains the grid map size N (1 \leq N \leq 1024). Each next N line contains N numbers. Each numbers C_{xy} (0 \leq C_{xy} \leq 9) means the number of molecule in position (x,y). There are at least 2 molecules.
Output
Output is formatted as follows.
D_{ave}
d_{1} c_{1}
d_{2} c_{2}
...
d_{m} c_{m}
Print D_{ave} which an average distance of all pair molecules on first line. Next, print histogram of all pair distance. Each line contains a distance d_i and the number of pair molecules c_i(0 \lt c_i). The distance d_i should be calculated by squared Euclidean distance and sorted as increasing order. If the number of different distance is more than 10,000, please show the first 10,000 lines. The answer may be printed with an arbitrary number of decimal digits, but may not contain an absolute or relative error greater than or equal to 10^{-8}.
Sample Input 1
2
1 0
0 1
Output for the Sample Input 1
1.4142135624
2 1
Sample Input 2
3
1 1 1
1 1 1
1 1 1
Output for the Sample Input 2
1.6349751825
1 12
2 8
4 6
5 8
8 2
Sample Input 3
5
0 1 2 3 4
5 6 7 8 9
1 2 3 2 1
0 0 0 0 0
0 0 0 0 1
Output for the Sample Input 3
1.8589994382
0 125
1 379
2 232
4 186
5 200
8 27
9 111
10 98
13 21
16 50
17 37
18 6
20 7
25 6
Example
Input
2
1 0
0 1
Output
1.4142135624
2 1
Submitted Solution:
```
import numpy as np
from scipy.signal import correlate
n = int( input() ) # Get grid width
c = []
for i in range(n):
c.append( input().split() ) # Get line info
c = np.array(c, dtype=np.double)
R = np.int32(np.round(correlate(c,c, method='fft'))) # Autocorrelation w/ FFT
center = np.array([1, 1]) * (n-1)
histogram = {}
for y in range(R.shape[0]):
for x in range(R.shape[1]):
d = np.array([y, x])-center
d2 = d@d
v = R[y, x]
if np.round(v) != 0:
if((d2 in histogram.keys()) == False):
histogram[d2] = v
else:
histogram[d2] += v
histogram[0] = (c*(c-1)).sum() #
histogram = sorted( histogram.items() )
sum = 0
mean = 0
for d2, v in histogram: # \sum_n d_n V_n / \sum_n V_n
sum += v
mean += v * d2**.5
print(mean / sum)
for d2, v in histogram:
if np.round(v) != 0:
print(d2, int(np.round(v/2))) # Divide out double counting
``` | instruction | 0 | 62,226 | 23 | 124,452 |
No | output | 1 | 62,226 | 23 | 124,453 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
Find the angle between the two given angles θ1 and θ2. Here, the angle between them is defined as "θ1 & plus; t'when t'is the one with the smallest absolute value among the t satisfying θ1 & plus; t = θ2 − t" as shown in the figure below.
A image of angles
Constraints
The input satisfies the following conditions.
* Angle is expressed in degrees
* 0 ≤ θ1, θ2 <360
* θ1 and θ2 are integers
* | θ1 − θ2 | ≠ 180
* No input is given that gives the answer [0,0.0001] or [359.999,360)
Input
The input is given in the following format.
θ1
θ2
Output
Output the angle between θ1 and θ2 in one line in the range [0,360) in degrees. However, it must not include an error exceeding 0.0001.
Examples
Input
10
20
Output
15.0
Input
20
350
Output
5.0 | instruction | 0 | 62,233 | 23 | 124,466 |
"Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LS(): return input().split()
def I(): return int(input())
def F(): return float(input())
def S(): return input()
def main():
a = I()
b = I()
if a > b:
a,b = b,a
if b-a > a+360-b:
a += 360
return (a+b) / 2.0 % 360
print(main())
``` | output | 1 | 62,233 | 23 | 124,467 |
Provide a correct Python 3 solution for this coding contest problem.
Your task is to calculate the distance between two $n$ dimensional vectors $x = \\{x_1, x_2, ..., x_n\\}$ and $y = \\{y_1, y_2, ..., y_n\\}$.
The Minkowski's distance defined below is a metric which is a generalization of both the Manhattan distance and the Euclidean distance.
\\[ D_{xy} = (\sum_{i=1}^n |x_i - y_i|^p)^{\frac{1}{p}} \\]
It can be the Manhattan distance
\\[ D_{xy} = |x_1 - y_1| + |x_2 - y_2| + ... + |x_n - y_n| \\]
where $p = 1 $.
It can be the Euclidean distance
\\[ D_{xy} = \sqrt{(|x_1 - y_1|)^{2} + (|x_2 - y_2|)^{2} + ... + (|x_n - y_n|)^{2}} \\]
where $p = 2 $.
Also, it can be the Chebyshev distance
\\[ D_{xy} = max_{i=1}^n (|x_i - y_i|) \\]
where $p = \infty$
Write a program which reads two $n$ dimensional vectors $x$ and $y$, and calculates Minkowski's distance where $p = 1, 2, 3, \infty$ respectively.
Constraints
* $1 \leq n \leq 100$
* $0 \leq x_i, y_i \leq 1000$
Input
In the first line, an integer $n$ is given. In the second and third line, $x = \\{x_1, x_2, ... x_n\\}$ and $y = \\{y_1, y_2, ... y_n\\}$ are given respectively. The elements in $x$ and $y$ are given in integers.
Output
Print the distance where $p = 1, 2, 3$ and $\infty$ in a line respectively. The output should not contain an absolute error greater than 10-5.
Example
Input
3
1 2 3
2 0 4
Output
4.000000
2.449490
2.154435
2.000000 | instruction | 0 | 62,253 | 23 | 124,506 |
"Correct Solution:
```
input()
a = list(map(int, input().split()))
b = list(map(int, input().split()))
d = lambda a, b, n: sum([abs(x - y) ** n for x, y in zip(a, b)]) ** (1/n)
print(d(a, b, 1))
print(d(a, b, 2))
print(d(a, b, 3))
print(max([abs(x - y) for x, y in zip(a, b)]))
``` | output | 1 | 62,253 | 23 | 124,507 |
Provide a correct Python 3 solution for this coding contest problem.
Your task is to calculate the distance between two $n$ dimensional vectors $x = \\{x_1, x_2, ..., x_n\\}$ and $y = \\{y_1, y_2, ..., y_n\\}$.
The Minkowski's distance defined below is a metric which is a generalization of both the Manhattan distance and the Euclidean distance.
\\[ D_{xy} = (\sum_{i=1}^n |x_i - y_i|^p)^{\frac{1}{p}} \\]
It can be the Manhattan distance
\\[ D_{xy} = |x_1 - y_1| + |x_2 - y_2| + ... + |x_n - y_n| \\]
where $p = 1 $.
It can be the Euclidean distance
\\[ D_{xy} = \sqrt{(|x_1 - y_1|)^{2} + (|x_2 - y_2|)^{2} + ... + (|x_n - y_n|)^{2}} \\]
where $p = 2 $.
Also, it can be the Chebyshev distance
\\[ D_{xy} = max_{i=1}^n (|x_i - y_i|) \\]
where $p = \infty$
Write a program which reads two $n$ dimensional vectors $x$ and $y$, and calculates Minkowski's distance where $p = 1, 2, 3, \infty$ respectively.
Constraints
* $1 \leq n \leq 100$
* $0 \leq x_i, y_i \leq 1000$
Input
In the first line, an integer $n$ is given. In the second and third line, $x = \\{x_1, x_2, ... x_n\\}$ and $y = \\{y_1, y_2, ... y_n\\}$ are given respectively. The elements in $x$ and $y$ are given in integers.
Output
Print the distance where $p = 1, 2, 3$ and $\infty$ in a line respectively. The output should not contain an absolute error greater than 10-5.
Example
Input
3
1 2 3
2 0 4
Output
4.000000
2.449490
2.154435
2.000000 | instruction | 0 | 62,254 | 23 | 124,508 |
"Correct Solution:
```
import math
n=int(input())
x=list(map(int, input().split()))
y=list(map(int, input().split()))
print(sum([abs(a-b) for (a,b) in zip(x,y)]))
print(math.sqrt(sum([abs(a-b)**2 for (a,b) in zip(x,y)])))
print(math.pow(sum([abs(a-b)**3 for (a,b) in zip(x,y)]), 1/3))
print((max([abs(a-b) for (a,b) in zip(x,y)])))
``` | output | 1 | 62,254 | 23 | 124,509 |
Provide a correct Python 3 solution for this coding contest problem.
Your task is to calculate the distance between two $n$ dimensional vectors $x = \\{x_1, x_2, ..., x_n\\}$ and $y = \\{y_1, y_2, ..., y_n\\}$.
The Minkowski's distance defined below is a metric which is a generalization of both the Manhattan distance and the Euclidean distance.
\\[ D_{xy} = (\sum_{i=1}^n |x_i - y_i|^p)^{\frac{1}{p}} \\]
It can be the Manhattan distance
\\[ D_{xy} = |x_1 - y_1| + |x_2 - y_2| + ... + |x_n - y_n| \\]
where $p = 1 $.
It can be the Euclidean distance
\\[ D_{xy} = \sqrt{(|x_1 - y_1|)^{2} + (|x_2 - y_2|)^{2} + ... + (|x_n - y_n|)^{2}} \\]
where $p = 2 $.
Also, it can be the Chebyshev distance
\\[ D_{xy} = max_{i=1}^n (|x_i - y_i|) \\]
where $p = \infty$
Write a program which reads two $n$ dimensional vectors $x$ and $y$, and calculates Minkowski's distance where $p = 1, 2, 3, \infty$ respectively.
Constraints
* $1 \leq n \leq 100$
* $0 \leq x_i, y_i \leq 1000$
Input
In the first line, an integer $n$ is given. In the second and third line, $x = \\{x_1, x_2, ... x_n\\}$ and $y = \\{y_1, y_2, ... y_n\\}$ are given respectively. The elements in $x$ and $y$ are given in integers.
Output
Print the distance where $p = 1, 2, 3$ and $\infty$ in a line respectively. The output should not contain an absolute error greater than 10-5.
Example
Input
3
1 2 3
2 0 4
Output
4.000000
2.449490
2.154435
2.000000 | instruction | 0 | 62,255 | 23 | 124,510 |
"Correct Solution:
```
import math
n = int(input())
x = list(map(float, input().split()))
y = list(map(float, input().split()))
d1 = []
d2 = []
d3 = []
for i, j in zip(x, y):
d1.append(abs(i - j))
d2.append(abs(i - j)**2)
d3.append(abs(i - j)**3)
print(sum(d1))
print(math.sqrt(sum(d2)))
print(sum(d3)**(1/3))
print(max(d1))
``` | output | 1 | 62,255 | 23 | 124,511 |
Provide a correct Python 3 solution for this coding contest problem.
Your task is to calculate the distance between two $n$ dimensional vectors $x = \\{x_1, x_2, ..., x_n\\}$ and $y = \\{y_1, y_2, ..., y_n\\}$.
The Minkowski's distance defined below is a metric which is a generalization of both the Manhattan distance and the Euclidean distance.
\\[ D_{xy} = (\sum_{i=1}^n |x_i - y_i|^p)^{\frac{1}{p}} \\]
It can be the Manhattan distance
\\[ D_{xy} = |x_1 - y_1| + |x_2 - y_2| + ... + |x_n - y_n| \\]
where $p = 1 $.
It can be the Euclidean distance
\\[ D_{xy} = \sqrt{(|x_1 - y_1|)^{2} + (|x_2 - y_2|)^{2} + ... + (|x_n - y_n|)^{2}} \\]
where $p = 2 $.
Also, it can be the Chebyshev distance
\\[ D_{xy} = max_{i=1}^n (|x_i - y_i|) \\]
where $p = \infty$
Write a program which reads two $n$ dimensional vectors $x$ and $y$, and calculates Minkowski's distance where $p = 1, 2, 3, \infty$ respectively.
Constraints
* $1 \leq n \leq 100$
* $0 \leq x_i, y_i \leq 1000$
Input
In the first line, an integer $n$ is given. In the second and third line, $x = \\{x_1, x_2, ... x_n\\}$ and $y = \\{y_1, y_2, ... y_n\\}$ are given respectively. The elements in $x$ and $y$ are given in integers.
Output
Print the distance where $p = 1, 2, 3$ and $\infty$ in a line respectively. The output should not contain an absolute error greater than 10-5.
Example
Input
3
1 2 3
2 0 4
Output
4.000000
2.449490
2.154435
2.000000 | instruction | 0 | 62,256 | 23 | 124,512 |
"Correct Solution:
```
n = int(input())
X = [int(i) for i in input().split(" ")]
Y = [int(i) for i in input().split(" ")]
for p in range(1, 4):
print("{:.6f}".format(sum( [abs(a - b) ** p for a, b in zip(X,Y) ] ) ** (1 / p) ) )
print("{:.6f}".format(max( [ abs(a - b) for a, b in zip(X, Y) ] ) ) )
``` | output | 1 | 62,256 | 23 | 124,513 |
Provide a correct Python 3 solution for this coding contest problem.
Your task is to calculate the distance between two $n$ dimensional vectors $x = \\{x_1, x_2, ..., x_n\\}$ and $y = \\{y_1, y_2, ..., y_n\\}$.
The Minkowski's distance defined below is a metric which is a generalization of both the Manhattan distance and the Euclidean distance.
\\[ D_{xy} = (\sum_{i=1}^n |x_i - y_i|^p)^{\frac{1}{p}} \\]
It can be the Manhattan distance
\\[ D_{xy} = |x_1 - y_1| + |x_2 - y_2| + ... + |x_n - y_n| \\]
where $p = 1 $.
It can be the Euclidean distance
\\[ D_{xy} = \sqrt{(|x_1 - y_1|)^{2} + (|x_2 - y_2|)^{2} + ... + (|x_n - y_n|)^{2}} \\]
where $p = 2 $.
Also, it can be the Chebyshev distance
\\[ D_{xy} = max_{i=1}^n (|x_i - y_i|) \\]
where $p = \infty$
Write a program which reads two $n$ dimensional vectors $x$ and $y$, and calculates Minkowski's distance where $p = 1, 2, 3, \infty$ respectively.
Constraints
* $1 \leq n \leq 100$
* $0 \leq x_i, y_i \leq 1000$
Input
In the first line, an integer $n$ is given. In the second and third line, $x = \\{x_1, x_2, ... x_n\\}$ and $y = \\{y_1, y_2, ... y_n\\}$ are given respectively. The elements in $x$ and $y$ are given in integers.
Output
Print the distance where $p = 1, 2, 3$ and $\infty$ in a line respectively. The output should not contain an absolute error greater than 10-5.
Example
Input
3
1 2 3
2 0 4
Output
4.000000
2.449490
2.154435
2.000000 | instruction | 0 | 62,257 | 23 | 124,514 |
"Correct Solution:
```
from math import sqrt
n=int(input())
x=list(map(int,input().split()))
y=list(map(int,input().split()))
p1=0;p2=0;p3=0;p=[]
for i in range(n):
a=abs(x[i]-y[i])
p1+=a
p2+=a**2
p3+=a**3
p.append(a)
print(p1)
print(sqrt(p2))
print(p3**(1/3))
print(max(p))
``` | output | 1 | 62,257 | 23 | 124,515 |
Provide a correct Python 3 solution for this coding contest problem.
Your task is to calculate the distance between two $n$ dimensional vectors $x = \\{x_1, x_2, ..., x_n\\}$ and $y = \\{y_1, y_2, ..., y_n\\}$.
The Minkowski's distance defined below is a metric which is a generalization of both the Manhattan distance and the Euclidean distance.
\\[ D_{xy} = (\sum_{i=1}^n |x_i - y_i|^p)^{\frac{1}{p}} \\]
It can be the Manhattan distance
\\[ D_{xy} = |x_1 - y_1| + |x_2 - y_2| + ... + |x_n - y_n| \\]
where $p = 1 $.
It can be the Euclidean distance
\\[ D_{xy} = \sqrt{(|x_1 - y_1|)^{2} + (|x_2 - y_2|)^{2} + ... + (|x_n - y_n|)^{2}} \\]
where $p = 2 $.
Also, it can be the Chebyshev distance
\\[ D_{xy} = max_{i=1}^n (|x_i - y_i|) \\]
where $p = \infty$
Write a program which reads two $n$ dimensional vectors $x$ and $y$, and calculates Minkowski's distance where $p = 1, 2, 3, \infty$ respectively.
Constraints
* $1 \leq n \leq 100$
* $0 \leq x_i, y_i \leq 1000$
Input
In the first line, an integer $n$ is given. In the second and third line, $x = \\{x_1, x_2, ... x_n\\}$ and $y = \\{y_1, y_2, ... y_n\\}$ are given respectively. The elements in $x$ and $y$ are given in integers.
Output
Print the distance where $p = 1, 2, 3$ and $\infty$ in a line respectively. The output should not contain an absolute error greater than 10-5.
Example
Input
3
1 2 3
2 0 4
Output
4.000000
2.449490
2.154435
2.000000 | instruction | 0 | 62,258 | 23 | 124,516 |
"Correct Solution:
```
n=int(input())
x=list(map(float,input().split()))
y=list(map(float,input().split()))
for p in range(1,4):
Dxy=float(0)
for i in range(n):
Dxy+=abs(x[i]-y[i])**p
Dxy=Dxy**(1/p)
print(f'{Dxy:.6f}')
Dxy=float(0)
for i in range(n):
if Dxy<abs(x[i]-y[i]):Dxy=abs(x[i]-y[i])
print(f'{Dxy:.6f}')
``` | output | 1 | 62,258 | 23 | 124,517 |
Provide a correct Python 3 solution for this coding contest problem.
Your task is to calculate the distance between two $n$ dimensional vectors $x = \\{x_1, x_2, ..., x_n\\}$ and $y = \\{y_1, y_2, ..., y_n\\}$.
The Minkowski's distance defined below is a metric which is a generalization of both the Manhattan distance and the Euclidean distance.
\\[ D_{xy} = (\sum_{i=1}^n |x_i - y_i|^p)^{\frac{1}{p}} \\]
It can be the Manhattan distance
\\[ D_{xy} = |x_1 - y_1| + |x_2 - y_2| + ... + |x_n - y_n| \\]
where $p = 1 $.
It can be the Euclidean distance
\\[ D_{xy} = \sqrt{(|x_1 - y_1|)^{2} + (|x_2 - y_2|)^{2} + ... + (|x_n - y_n|)^{2}} \\]
where $p = 2 $.
Also, it can be the Chebyshev distance
\\[ D_{xy} = max_{i=1}^n (|x_i - y_i|) \\]
where $p = \infty$
Write a program which reads two $n$ dimensional vectors $x$ and $y$, and calculates Minkowski's distance where $p = 1, 2, 3, \infty$ respectively.
Constraints
* $1 \leq n \leq 100$
* $0 \leq x_i, y_i \leq 1000$
Input
In the first line, an integer $n$ is given. In the second and third line, $x = \\{x_1, x_2, ... x_n\\}$ and $y = \\{y_1, y_2, ... y_n\\}$ are given respectively. The elements in $x$ and $y$ are given in integers.
Output
Print the distance where $p = 1, 2, 3$ and $\infty$ in a line respectively. The output should not contain an absolute error greater than 10-5.
Example
Input
3
1 2 3
2 0 4
Output
4.000000
2.449490
2.154435
2.000000 | instruction | 0 | 62,259 | 23 | 124,518 |
"Correct Solution:
```
n=int(input())
x=list(map(int,input().split()))
y=list(map(int,input().split()))
p1,p2,p3=0,0,0
Dxy=[0]*(n+1)
for i in range(n):
Dxy[i]=abs(x[i]-y[i])
p1+=Dxy[i]
p2+=Dxy[i]**2
p3+=Dxy[i]**3
p2**=0.5
p3**=(1/3)
print(p1,p2,p3,max(Dxy),sep='\n')
``` | output | 1 | 62,259 | 23 | 124,519 |
Provide a correct Python 3 solution for this coding contest problem.
Your task is to calculate the distance between two $n$ dimensional vectors $x = \\{x_1, x_2, ..., x_n\\}$ and $y = \\{y_1, y_2, ..., y_n\\}$.
The Minkowski's distance defined below is a metric which is a generalization of both the Manhattan distance and the Euclidean distance.
\\[ D_{xy} = (\sum_{i=1}^n |x_i - y_i|^p)^{\frac{1}{p}} \\]
It can be the Manhattan distance
\\[ D_{xy} = |x_1 - y_1| + |x_2 - y_2| + ... + |x_n - y_n| \\]
where $p = 1 $.
It can be the Euclidean distance
\\[ D_{xy} = \sqrt{(|x_1 - y_1|)^{2} + (|x_2 - y_2|)^{2} + ... + (|x_n - y_n|)^{2}} \\]
where $p = 2 $.
Also, it can be the Chebyshev distance
\\[ D_{xy} = max_{i=1}^n (|x_i - y_i|) \\]
where $p = \infty$
Write a program which reads two $n$ dimensional vectors $x$ and $y$, and calculates Minkowski's distance where $p = 1, 2, 3, \infty$ respectively.
Constraints
* $1 \leq n \leq 100$
* $0 \leq x_i, y_i \leq 1000$
Input
In the first line, an integer $n$ is given. In the second and third line, $x = \\{x_1, x_2, ... x_n\\}$ and $y = \\{y_1, y_2, ... y_n\\}$ are given respectively. The elements in $x$ and $y$ are given in integers.
Output
Print the distance where $p = 1, 2, 3$ and $\infty$ in a line respectively. The output should not contain an absolute error greater than 10-5.
Example
Input
3
1 2 3
2 0 4
Output
4.000000
2.449490
2.154435
2.000000 | instruction | 0 | 62,260 | 23 | 124,520 |
"Correct Solution:
```
import math
input()
vx = [int(i) for i in input().split()]
vy = [int(i) for i in input().split()]
Dxy = []
for p in range(1,4):
Dxy.append(sum([abs(vx[i] - vy[i]) ** p for i in range(len(vx))]) ** (1 / p))
Dxy.append(max([abs(vx[i] - vy[i]) for i in range(len(vx))]))
for res in Dxy:
print('{0:.5f}'.format(res))
``` | output | 1 | 62,260 | 23 | 124,521 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your task is to calculate the distance between two $n$ dimensional vectors $x = \\{x_1, x_2, ..., x_n\\}$ and $y = \\{y_1, y_2, ..., y_n\\}$.
The Minkowski's distance defined below is a metric which is a generalization of both the Manhattan distance and the Euclidean distance.
\\[ D_{xy} = (\sum_{i=1}^n |x_i - y_i|^p)^{\frac{1}{p}} \\]
It can be the Manhattan distance
\\[ D_{xy} = |x_1 - y_1| + |x_2 - y_2| + ... + |x_n - y_n| \\]
where $p = 1 $.
It can be the Euclidean distance
\\[ D_{xy} = \sqrt{(|x_1 - y_1|)^{2} + (|x_2 - y_2|)^{2} + ... + (|x_n - y_n|)^{2}} \\]
where $p = 2 $.
Also, it can be the Chebyshev distance
\\[ D_{xy} = max_{i=1}^n (|x_i - y_i|) \\]
where $p = \infty$
Write a program which reads two $n$ dimensional vectors $x$ and $y$, and calculates Minkowski's distance where $p = 1, 2, 3, \infty$ respectively.
Constraints
* $1 \leq n \leq 100$
* $0 \leq x_i, y_i \leq 1000$
Input
In the first line, an integer $n$ is given. In the second and third line, $x = \\{x_1, x_2, ... x_n\\}$ and $y = \\{y_1, y_2, ... y_n\\}$ are given respectively. The elements in $x$ and $y$ are given in integers.
Output
Print the distance where $p = 1, 2, 3$ and $\infty$ in a line respectively. The output should not contain an absolute error greater than 10-5.
Example
Input
3
1 2 3
2 0 4
Output
4.000000
2.449490
2.154435
2.000000
Submitted Solution:
```
n = int(input())
x = list(map(int, input().split()))
y = list(map(int, input().split()))
for p in range(1,4):
print("{0:.6f}".format(pow(sum([pow(abs(x[i] - y[i]), p) for i in range(n)]) ,1/p)))
print("{0:.6f}".format(pow(pow(max([abs(x[i] - y[i]) for i in range(n)]),n),1/n)))
``` | instruction | 0 | 62,261 | 23 | 124,522 |
Yes | output | 1 | 62,261 | 23 | 124,523 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your task is to calculate the distance between two $n$ dimensional vectors $x = \\{x_1, x_2, ..., x_n\\}$ and $y = \\{y_1, y_2, ..., y_n\\}$.
The Minkowski's distance defined below is a metric which is a generalization of both the Manhattan distance and the Euclidean distance.
\\[ D_{xy} = (\sum_{i=1}^n |x_i - y_i|^p)^{\frac{1}{p}} \\]
It can be the Manhattan distance
\\[ D_{xy} = |x_1 - y_1| + |x_2 - y_2| + ... + |x_n - y_n| \\]
where $p = 1 $.
It can be the Euclidean distance
\\[ D_{xy} = \sqrt{(|x_1 - y_1|)^{2} + (|x_2 - y_2|)^{2} + ... + (|x_n - y_n|)^{2}} \\]
where $p = 2 $.
Also, it can be the Chebyshev distance
\\[ D_{xy} = max_{i=1}^n (|x_i - y_i|) \\]
where $p = \infty$
Write a program which reads two $n$ dimensional vectors $x$ and $y$, and calculates Minkowski's distance where $p = 1, 2, 3, \infty$ respectively.
Constraints
* $1 \leq n \leq 100$
* $0 \leq x_i, y_i \leq 1000$
Input
In the first line, an integer $n$ is given. In the second and third line, $x = \\{x_1, x_2, ... x_n\\}$ and $y = \\{y_1, y_2, ... y_n\\}$ are given respectively. The elements in $x$ and $y$ are given in integers.
Output
Print the distance where $p = 1, 2, 3$ and $\infty$ in a line respectively. The output should not contain an absolute error greater than 10-5.
Example
Input
3
1 2 3
2 0 4
Output
4.000000
2.449490
2.154435
2.000000
Submitted Solution:
```
n=int(input())
x=list(map(int,input().split()))
y=list(map(int,input().split()))
def MDD(p,x,y):#Malti Dimension Distance
ans=0
for i,j in zip(x,y):
ans+=abs(i-j)**p
ans=ans**(1/p)
print(ans)
MDD(1,x,y)
MDD(2,x,y)
MDD(3,x,y)
print(max(abs(i-j) for i,j in zip(x,y)))
``` | instruction | 0 | 62,262 | 23 | 124,524 |
Yes | output | 1 | 62,262 | 23 | 124,525 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.